Método de las 6`D Modelamiento - Algoritmo - Programación.

Tomo I. Enfoque orientado a las estructuras lógicas

Autores: Juan José Flores Cueto y Carmen Bertoloƫ Zuñiga

© Derechos de autor registrados:

Empresa Editora Macro EIRL

© Derechos de edición, arte gráfico y diagramación reservados:

Empresa Editora Macro EIRL

Corrección de esƟlo:
Mónica Barrera Velasco
Milton A. Gonzales M.

Coordinación de arte y diseño:

Alejandro Marcas León

Diagramación:
Lizbeth Eufracio Quispe
SebasƟan Alvarez Sanchez

Edición a cargo de:

© Empresa Editora Macro EIRL
Av. Paseo de la República N.° 5613 , Miraflores, Lima, Perú

 Teléfono: (511) 748 0560

 E-mail: [email protected]
Página web: www.editorialmacro.com

Primera edición: seƟembre de 2014

Tiraje: 1000 ejemplares

Impresión
Talleres gráficos de la Empresa Editora Macro EIRL
Jr. San Agusơn N.° 612-624, Surquillo, Lima, Perú

ISBN N.° 978-612-304-218-9

Hecho el depósito legal en la Biblioteca Nacional del Perú Nº 2014-12577

Prohibida la reproducción parcial o total, por cualquier medio o método, de este libro sin
previa autorización de la Empresa Editora Macro EIRL.
 Juan José Flores Cueto
Ingeniero de Computación y Sistemas, magister en Administración con mención en Gerencia Estratégica de
Organización; doctor en Educación por la Universidad de San Marơn de Porres (USMP). Además, obtuvo el ơtulo
de Especialista y el Diploma de Estudios Avanzados (DEA) en Integración de las Tecnologías de la Información en
las Organizaciones (ITIO), por la Universidad Politécnica de Valencia (UPV), España. Actualmente, es doctorando
del Programa ITIO de la UPV.

Se ha desempeñado profesionalmente en diversas empresas nacionales, ocupando las funciones de desarrollador

de soŌware, analista de sistemas, auditor de sistemas y jefe de proyectos. Desde mayo del 2009 ocupa el cargo
de director de la USMP Virtual, donde además ejerce la docencia. También se desempeña como catedráƟco en la
Facultad de Ingeniería y Arquitectura (FIA) de la Universidad de San Marơn de Porres (USMP), y en la Universidad
Nacional José FausƟno Sánchez Carrión (UNJFSC).

Es autor de diversos libros, como guías y manuales, los cuales se uƟlizan para la enseñanza universitaria. También
ha colaborado con arơculos para revistas nacionales e internacionales, y ha parƟcipado en diversos congresos.

La página personal del autor es: hƩp://jjflorescueto.googlepages.com/. Y sus publicaciones se pueden encontrar
en: hƩp://www.lulu.com/spotlight/jjflorescueto, y en la red: hƩp://www.reddolac.org
 Carmen Bertoloƫ Zuñiga
Ingeniera de Computación y Sistemas, egresada de la Universidad de San Marơn de Porres (USMP).
Con estudios finalizados en la maestría en Educación con mención en InformáƟca y Tecnología, en la
USMP. Se desempeña como docente contratada en la Facultad de Ingeniería y Arquitectura (FIA), de la
USMP, así como en otras insƟtuciones educaƟvas.

Es autora del libro Método de las 6’D. Modelamiento - Algoritmo - Programación. (Enfoque orientado a
las estructuras lógicas). 2da. ed. Lima: Fondo Editorial USMP, 2008. También ha escrito diversos arơculos
en el boleơn electrónico InfoFIA de la FIA USMP; además, es autora de guías y manuales uƟlizados en el
quehacer universitario. Ha laborado en diversas empresas del sector privado, desempeñándose como
ingeniera de desarrollo y jefe de sistemas.
 Dedicatoria

A nuestros hijos, Danae y el pequeño Rodrigo

 Índice

Capítulo 1
Método y herramientas .......................................................................................................................... 13
1.1 Método de las 6’D ...........................................................................................................15
1.1.1 Etapas y pasos ..........................................................................................................16
1.1.2 Resumen de método ................................................................................................23
1.1.3 Resultado de las etapas del método ........................................................................24
1.2 Marco de trabajo .............................................................................................................25
1.3 Modelamiento .................................................................................................................26
1.3.1 Paquete ...................................................................................................................26
1.3.2 Clase .........................................................................................................................26
1.3.3 Objeto ......................................................................................................................27
1.3.4 Diagrama de paquetes .............................................................................................28
1.4 Algoritmo..........................................................................................................................29
1.4.1 CaracterísƟcas ..........................................................................................................29
1.4.2 Herramientas ...........................................................................................................30
1.5 Programación ..................................................................................................................39
1.5.1 Tipos de lenguajes de programación .......................................................................40

Capítulo 2
Estructuras lógicas de secuencia y estructura de datos variable ........................................................... 41
2.1 Estructuras lógicas de secuencia .....................................................................................45
2.1.1 Definición .................................................................................................................45
2.2 Método de las 6´D - Desarrollo de soluciones con un paquete .......................................46
2.3 Estructuras lógicas de secuencia: Mostrar información ..................................................47
2.3.1 Definición .................................................................................................................47
2.3.2 Representación ........................................................................................................47
2.3.3 Consideraciones adicionales para los lenguajes de programación C++ y Java .........49
2.4 Estructura de datos: Variable ..........................................................................................60
2.4.1 Definición .................................................................................................................60
2.4.2 Declaración ..............................................................................................................60
2.4.3 Nombre ....................................................................................................................60
2.4.4 Inicialización .............................................................................................................61
2.4.5 Almacenamiento o asignación de datos ..................................................................61
2.4.6 Constantes ...............................................................................................................62
2.5 Tipos de dato ...................................................................................................................62
2.5.1 Definición .................................................................................................................62
2.5.2 En pseudocódigo y diagrama de flujo ......................................................................63
2.5.3 En lenguaje C++........................................................................................................64
2.5.4 En lenguaje Java .......................................................................................................65
 2.6 Uso de comentarios .........................................................................................................75
2.7 Estructura lógica de secuencia: Ingresar datos................................................................80
2.7.1 Definición .................................................................................................................80
2.7.2 Representación ........................................................................................................80
2.8 Estructura lógica de secuencia: Procesar datos................................................................91
2.8.1 Definición .................................................................................................................91
2.8.2 Tipos.........................................................................................................................91
2.9 Método de las 6`D - Desarrollo de soluciones con dos paquetes ....................................100
2.10 Desarrollo de Aplicaciones Java, uƟlizando Java Development Kit (JDK ) ......................126
2.10.1 Edición....................................................................................................................126
2.10.2 Compilación ...........................................................................................................126
2.10.3 Ejecución ................................................................................................................126
2.11 Soluciones uƟlizando cuadros de diálogo......................................................................128
2.11.1 Uso de la clase LE codificada en Java .....................................................................128
2.11.2 Método de las 6´D - Uso de cuadros de diálogo ....................................................129

Capítulo 3
Estructuras lógicas de decisión o selección ............................................................................................ 143
3.1 Desarrollo de soluciones con un paquete .......................................................................147
3.2 Estructuras lógicas de decisión ........................................................................................147
3.2.1 Definición .................................................................................................................147
3.2.2 Estructura lógica de decisión simple ........................................................................148
3.2.3 Estructura lógica de decisión doble .........................................................................167
3.2.4 Estructura lógica de decisión múlƟple: “CUANDO” .................................................184
3.2.5 Estructura lógica de decisión múlƟple: “SI ANIDADOS” ..........................................208
3.3 Uso combinado de las estructuras lógicas de decisión....................................................237
3.4 Uso anidado de las estructuras lógicas de decisión.........................................................237
3.5 Desarrollo de aplicaciones Java, uƟlizando Integrated Development Environment (IDE) .. 257
3.6 Método de las 6´D - Uso de cuadros de diálogo ..............................................................259

Capítulo 4
Estructuras lógicas de control o repeƟción ............................................................................................ 281
4.1 Método de las 6’D - Desarrollo de soluciones con dos paquetes ...................................285
4.2 Estructuras lógicas de repeƟción .....................................................................................286
4.2.1 Otros usos de las variables .......................................................................................287
4.2.2 Estructura lógica de repeƟción: “HACER” ................................................................287
4.2.4 Estructura lógica de repeƟción: “MIENTRAS” ..........................................................348
4.2.5 Estructura lógica de repeƟción: “DESDE” o “PARA” .................................................378
4.3 Empaquetar aplicaciones Java uƟlizando Java ARchives ( JAR ).......................................409
4.3.1 Creación de un JAR...................................................................................................409
 4.3.2 Ejecución de un JAR .................................................................................................411
4.3.3 Visualizar un JAR ......................................................................................................412
4.3.4 Extracción de un JAR ................................................................................................413
4.4 SoŌware para decompilar aplicaciones java ...................................................................415
4.4.1 Uso de javap del JDK ................................................................................................415
4.4.2 Uso de otros soŌware ..............................................................................................416
4.5 Método de las 6´D - Uso de cuadros de diálogo ..............................................................418

Capítulo 5
Estructuras lógicas combinadas .............................................................................................................. 435
5.1 Uso combinado de las estructuras lógicas ......................................................................439
5.2 Manejo de excepciones en el lenguaje de programación Java ........................................522
5.3 Desarrollo de las capacidades lógicas..............................................................................530
5.4 Desarrollo de miniaplicaciones Java (Applet) uƟlizando Java Development Kit ( JDK ) ...557
5.5 Métodos de las 6´D – Uso de cuadros de diálogo ...........................................................559

Capítulo 6
Introducción al desarrollo de soluciones orientadas a objetos y al uso de Interfaz Gráfica de
Usuario .................................................................................................................................................... 583
6.1 Conceptos básicos ...........................................................................................................588
6.1.1 Clase .........................................................................................................................588
6.1.2 Objeto (Modelos de entes del mundo) ...................................................................589
6.1.3 Atributo ....................................................................................................................590
6.1.4 Método ....................................................................................................................595
6.2 Método de las 6’D: Redefinición de pasos ......................................................................608
6.2.1 Ajuste de los pasos definidos para las etapas del método .......................................608
6.3 SoŌware para generar ejecutables en MS-Windows basado en aplicaciones Java ........615
6.3.1 Uso de soŌware ......................................................................................................615
6.4 Introducción a las soluciones uƟlizando Interfaz Gráfica de Usuario (GUI) .....................618
6.4.1 Introducción .............................................................................................................618
6.4.2 Definición .................................................................................................................618
6.4.3 Etapas para el desarrollo de GUI ..............................................................................618
6.4.4 Contenedores y componentes de la GUI..................................................................619
6.4.5 Administradores de diseño de la GUI.......................................................................620
6.4.6 Manejadores de evento de la GUI ...........................................................................620
6.5 Método de las 6´D – Desarrollo de soluciones con GUI ..................................................621

Bibliograİa .............................................................................................................................................. 631

 Apéndice *

Clases creadas e incorporadas en Java ................................................................................................... 633

Clases incorporadas en el lenguaje Java ..................................................................................635
Clase Lectura........................................................................................................................635
Clase LE (versión 2.2) ...........................................................................................................636
El paquete del lenguaje Java................................................................................................643
Conversión de datos .................................................................................................................645
Conversión implícita de datos en Java .................................................................................646
Conversión explícita de datos en Java (casƟng) ...................................................................648
Envoltorios de los Ɵpos de datos primiƟvos: clases wrappers.............................................649
Funciones matemáƟcas: clase Math ........................................................................................659
Introducción ........................................................................................................................659
Métodos ..............................................................................................................................660
Manejo de cadenas: clase String ..............................................................................................703
Introducción ........................................................................................................................703
Métodos ..............................................................................................................................704
Manejo de formatos: clase Decimalformat ..............................................................................754
Manejo de fechas: clase Calendar............................................................................................759
Manejo de fechas: clase Gregoriancalendar ............................................................................764
Manejo de fechas: clase Simpledateformat .............................................................................766

* El presente apéndice solo se encuentra disponible en la página web de la editorial: www.editorialmacro.com

 Introducción
En este libro se trata en forma detallada y dinámica los conceptos y temas fundamentales necesarios
para el desarrollo de soluciones uƟlizando el Método de las 6’D, y el empleo de sus capacidades
lógicas.

Se explican los conceptos fundamentales sobre el modelamiento y el UML, profundizando en el

tema de algoritmos y su diseño uƟlizando diagramas de flujo y pseudocódigo. Se presenta también
el diagrama de acƟvidades como una herramienta adicional para diseñar algoritmos, y se desarrollan
conceptos sobre programación y codificación uƟlizando los lenguajes de programación orientados
a objetos C++ y Java.

Se tratan las Estructuras Lógicas de Secuencia (ELS), las variables, las Estructuras Lógicas de Decisión
(ELD), las Estructuras Lógicas de RepeƟción (ELR) y las Estructuras Lógicas Combinadas (ELC).
También se tratan las estructuras de bifurcación y el manejo de excepciones en Java (try, catch), y
se finaliza con una introducción al desarrollo de soluciones orientadas a objetos y al uso de Interfaz
Gráfica de Usuario (GUI) en los programas Java.

La estructura de los capítulos y su relación directa con los problemas propuestos al final de cada
uno de ellos, y la gran canƟdad de soluciones desarrolladas (250 en total), en las cuales se incluyen
75 pseudocódigos, 59 diagramas de Flujo, 6 diagramas de acƟvidad, 76 programas en C++, 217
problemas en Java uƟlizando la consola y 23 programas en Java uƟlizando cuadros de diálogo,
garanƟzan un aprendizaje progresivo y adecuado de cada uno de los temas tratados.

Finalmente, se incluye una sección llamada PUNTO A PARTE, que permiƟrá al lector conocer
nuevas herramientas de soŌware gratuitas que complementarán sus conocimientos y le ayudarán a
desarrollar mejores aplicaciones en Java. Los temas incluidos son:

Desarrollo de aplicaciones Java uƟlizando Java Development Kit ( JDK )

Desarrollo de aplicaciones Java uƟlizando Integrated Development Environment ( IDE )
Empaquetar aplicaciones Java uƟlizando Java ARchives ( JAR )

SoŌware para decompilar aplicaciones Java

Desarrollo de miniaplicaciones Java (Applet) uƟlizando Java Development Kit ( JDK )

SoŌware para generar ejecutables en MS-Windows basado en aplicaciones Java

 CAP.

M é to d o y h e r r a m i e n t a s
1
 CAP. 1: M ÉTODO Y HERRAMIENTAS 15

Durante el transcurso de nuestra vida nos enfrentamos a diversos problemas. Algunos de ellos
podemos solucionarlos fácilmente, mientras que otros se complican de tal forma que nos afectan de
una manera muy profunda.
Por su naturaleza, algunos problemas pueden ser resueltos uƟlizando una computadora. Generalmente
son de Ɵpo estructurado; es decir, que Ɵenen una solución determinada y pueden llegar a ser muy
sencillos o extremadamente complejos. Para resolver estos problemas estructurados uƟlizando una
computadora, es importante aplicar un método fácil de comprender y que guíe paso a paso hasta la
solución del problema.
El método propuesto y uƟlizado en el presente texto es el Método de las 6’D. Está compuesto de
seis etapas, cada una de las cuales consta de una serie de pasos que se van modificando o ajustando,
dependiendo del grado de complejidad del problema y las herramientas que se uƟlicen para su
solución.
Con la finalidad de recordar el método, se ha establecido que el nombre de cada una de sus seis etapas
comience con la letra “D”.

1.1 MÉTODO DE LAS 6’D

En la siguiente figura se muestra el Método de las 6’D con sus respecƟvas etapas.

Etapa 01
Descripción
del problema

Etapa 02
Definición
Solución n veces Ingeniería
reversa
Etapa 03
Diseño
Solución

Etapa 04
Desarrollo
Solución

MODELAMIENTO Etapa 05
ALGORITMO Depuración
Pruebas
Etapa 06
CODIFICACIÓN
N Documento
16 MÉTODO DE LAS 6’D - ENFOQUE ORIENTADO A LAS ESTRUCTURAS LÓGICAS

1.1.1 Etapas y pasos

A. Descripción de la Etapa 01 – Descripción del problema

Etapa 01
Lo primero que se debe hacer en esta
Descripción etapa es idenƟficar cuál es el problema que
del problema se desea resolver. Esto que parece algo
sumamente sencillo, muchas veces resulta
una tarea agotadora, ya que existen muchas
opiniones acerca de cuál es el problema
central. IdenƟficarlo es una de las tareas más
importantes que los analistas deben afrontar.

Una vez idenƟficado el problema, es necesario

comprenderlo en su totalidad, es decir,
entender qué es exactamente lo que se
desea resolver. Finalmente, se debe escribir
un enunciado claro, concreto y conciso del
problema a resolver.

Pasos:

IdenƟficacióndel problema.
Descripcióngeneral del problema.
Enunciado claro y preciso del problema.

ENUNCIADO

El resultado obtenido en esta etapa es un enunciado claro del problema que se desea solucionar.
 CAP. 1: M ÉTODO Y HERRAMIENTAS 17

B. Descripción de la Etapa 02 – Definición de la solución

Etapa 02
En esta etapa es necesario estudiar a fondo
Definición el problema para poder solucionarlo, saber
de la solución exactamente en qué consiste y descomponerlo
en cada una de sus partes, facilitando su
comprensión y posterior solución. Esta es una
regla que siempre debe ser aplicada, se uƟlice
o no una computadora en la solución de un
problema.

Una vez entendido el problema se está en

condiciones de estudiarlo a fondo y plantear
diversas alternaƟvas que permitan solucionarlo,
aplicando siempre la más adecuada.

Pasos:

Definir el resultado deseado.

Determinar los datos que se deben ingresar
o generar para obtener el resultado
deseado.
Determinar la forma en que los datos
serán procesados para transformarlos en
información.

ESPECIFICACIONES

En esta etapa se obƟenen las especificaciones, que determinan lo que se debe hacer para solucionar
el problema.
18 MÉTODO DE LAS 6’D - ENFOQUE ORIENTADO A LAS ESTRUCTURAS LÓGICAS

C. Descripción de la Etapa 03 – Definición de la solución

Etapa 03
Una vez definida la solución se procederá a
Diseño diseñar la lógica, modelando y desarrollando
de la solución algoritmos.

Para el modelado de la solución del problema

se uƟlizará el Lenguaje Unificado de Modelado
(Unified Modeling Language, UML), que es
una herramienta usada para describir clases,
objetos y sus relaciones.

Para el desarrollo de algoritmos se uƟlizarán

Pseudocódigos o Diagramas de Flujo (DF),
que son herramientas uƟlizadas para diseñar
algoritmos de los diferentes métodos de una
clase.

Finalizado el desarrollo de los algoritmos es

necesario verificar si se han incluido soluciones
para todas las formas en que se presenta el
problema. A este Ɵpo de prueba se le denomina
“Prueba de escritorio”.

Pasos:

Definir un nombre para el proyecto.

MODELAMIENTO Definición de diagramas, relaciones y
clases.
ALGORITMO Desarrollo de algoritmos.

DIAGRAMAS Y
ALGORITMOS

El resultado obtenido en esta etapa son los diagramas y los algoritmos, que especifican cómo se
debe hacer para solucionar el problema.
 CAP. 1: M ÉTODO Y HERRAMIENTAS 19

D. Descripción de la Etapa 04 – Desarrollo de la solución

Etapa 04
Una vez previstas todas las posibilidades y
Desarrollo alternaƟvas que puedan presentarse y que
de la solución pasen sin inconvenientes por la clase y los
algoritmos, se procederá a la codificación del
problema en algún lenguaje de programación.

La codificación involucra traducir los

diagramas, las especificaciones de las clases
(expresadas en notación UML), y los pasos
del algoritmo de cada método (expresado
en DF o pseudocódigo), en sentencias de un
lenguaje de programación determinado. Estas
sentencias son almacenadas en un proyecto
(o archivo) lógico, y consƟtuyen lo que la
computadora podrá ejecutar.

Pasos:

CODIFICACIÓN Codificarel proyecto.

Desarrollar comentarios internos en los
programas de computadora.
Desarrollar copias de seguridad de los
programas de computadora.

PROGRAMAS

El resultado obtenido en esta etapa son los programas y/o clases codificados en un lenguaje de
programación, que permiten solucionar el problema.
20 MÉTODO DE LAS 6’D - ENFOQUE ORIENTADO A LAS ESTRUCTURAS LÓGICAS

E. Descripción de la Etapa 05 – Depuración y pruebas

Etapa 05
Luego que se codifiquen los programas y/o
Depuración y clases, deberán ser probados mediante su
pruebas ejecución (esta acción se conoce como corrida
del programa). Al realizarse pueden surgir
diferentes Ɵpos de errores, siendo los de lógica
y sintaxis los más comunes.

Hay que corregir el programa, anular, modificar

o crear nuevas sentencias, volver a probar
el programa y conƟnuar con la corrección y
pruebas hasta conseguir el resultado deseado.

Pasos:

Realizar la depuración y verificar la correcta

escritura de los programas.
Realizar pruebas de sintaxis.
Realizar pruebas de lógica.

PRUEBAS

El resultado obtenido en esta etapa son las pruebas, que registran el adecuado funcionamiento de la
solución del problema.
 CAP. 1: M ÉTODO Y HERRAMIENTAS 21

F. Descripción de la Etapa 06 – Documentación

Etapa 06
En esta etapa se recopila toda la documentación
Documentación generada en las etapas anteriores, la cual
servirá como base para la elaboración del
manual técnico.

El Ɵempo dedicado a esta etapa será de

mucha ayuda para desarrollar buenos hábitos,
necesarios cuando se desarrolle el soŌware en
forma profesional.

El manual técnico debe incluir, como mínimo:

Descripcióndel problema.
Resultados esperados y datos necesarios
para generar dichos resultados.
Diagramas UML, DF y/o pseudocódigo.

Pruebas desarrolladas.

Listado de programas con comentarios

internos.

Pasos:

Recopilar el material generado en cada

una de las etapas anteriores.
Generar el manual del programa.

Generar el manual del usuario.

MANUALES

El resultado obtenido en esta etapa son los manuales, que permiten un adecuado manejo de la
solución desarrollada.
22 MÉTODO DE LAS 6’D - ENFOQUE ORIENTADO A LAS ESTRUCTURAS LÓGICAS

Adicionalmente, es posible realizar ingeniería reversa entre las etapas 03, 04 y 05.

Ingeniería La ingeniería reversa permite crear o

reversa actualizar el modelo preliminar realizado en
la Etapa 03 “Diseño de la solución”, a parƟr
del código del programa realizado en la Etapa
n veces 04 “Desarrollo de la solución”, y corregido en
la Etapa 05 “Depuración y pruebas”.
Etapa 03
Es decir, a través de la ingeniería reversa es
Diseño
posible programar o codificar algunas partes
Solución
(hasta su correcto funcionamiento) que no
estén especificadas en la Etapa 03 “Diseño
de la solución”. A parƟr de esta solución, se
actualizan los diagramas de la Etapa 03 y
Etapa 04 se conƟnúa con el proceso hasta llegar a la
solución deseada.
Desarrollo
Solución

Pasos:
Etapa 05
Exportar proyecto (archivos class o
Depuración y Java) al disco de la PC, si está trabajando
pruebas con un IDE.
Importar proyecto (archivos class o
Java) a una herramienta CASE y realizar
la ingeniería reversa.
MODELAMIENTO
Organizar el modelo obtenido en la
ALGORITMO herramienta CASE.

CODIFICACIÓN

DIAGRAMAS
ACTUALIZADOS
 Etapa 01 Etapa 02 Etapa 03 Etapa 04 Etapa 05 Etapa 06

Descripción Definición Diseño Desarrollo Depuración

Documento
Problema Solución Solución Solución Pruebas
1.1.2 Resumen de método

IdenƟficación Definir el Definir un Codificarel Realizar la Recopilar el

del problema. resultado nombre para el proyecto. depuración material generado
Descripción deseado. proyecto. Desarrollar y verificar en cada una de las
general del Determinar los Definición de comentarios la correcta etapas anteriores.
Resumen de las etapas y los pasos del método.

problema. datos que se diagramas, internos en los escritura de los Generar el manual

Enunciado claro deben ingresar relaciones y programas de programas. del programa.

y preciso del o generar clases. computadora. Realizar pruebas Generar el manual
problema. para obtener Desarrollo de Desarrollar de sintaxis. del usuario.
el resultado algoritmos. copias de Realizar pruebas
deseado. seguridad de lógica.
Determinar la de los
forma en que programas de
los datos serán computadora.
procesados
CAP. 1: M ÉTODO

para
transformarlos
en información.
Y HERRAMIENTAS
23
 24

Etapa 01 Etapa 02 Etapa 03 Etapa 04 Etapa 05 Etapa 06

Descripción Definición Diseño Desarrollo Depuración Documento

Problema Solución Solución Solución Pruebas
1.1.3 Resultado de las etapas del método

Diagramas
Enunciado Especificaciones Programas Pruebas
y algoritmos

Manuales
MÉTODO DE LAS 6’D - ENFOQUE ORIENTADO A LAS ESTRUCTURAS LÓGICAS
 CAP. 1: M ÉTODO Y HERRAMIENTAS 25

1.2 MARCO DE TRABAJO

Este libro busca dar solución a problemas sencillos uƟlizando el Método de las 6’D. La solución de los
problemas se iniciará con el enunciado del problema, para luego desarrollar la etapa 02 (“Definición de
la solución”), etapa 03 (“Diseño de la solución”) y etapa 04 (“Desarrollo de la solución”); es decir, solo
se desarrollarán las tres etapas del método que son posibles especificar en el presente texto. La etapa
05 (“Depuración y pruebas”) se desarrollará directamente en un lenguaje de programación, y la etapa
06 (“Documentación”) es la recopilación del material y la elaboración de los manuales respecƟvos.

Etapa 01
MARCO DE TRABAJO
Descripción
del problema

ENUNCIADO

Etapa 02
Definición
Solución
Etapa 03
Diseño
Solución
Etapa 04
MODELAMIENTO Desarrollo
ALGORITMO Solución

CODIFICACIÓN

Para solucionar problemas sencillos uƟlizando el Método de las 6’D, es necesario conocer los conceptos
fundamentales de modelamiento, algoritmo y programación, y dominar el uso de las estructuras
lógicas, instrucciones o sentencias de bifurcación y las estructuras de datos conocidas como variables.
Este Ɵpo de soluciones son el objeƟvo del presente texto.

También es posible plantear soluciones más complejas uƟlizando el Método de las 6’D. Para ello
se deben dominar algunos conceptos claves como Objetos, Métodos, Encapsulamiento, Herencia,
Polimorfismo, Interfaces gráficas, Conexión a base de datos y Servlets, entre otros.

Es importante mencionar que, dependiendo de la complejidad del problema, los pasos especificados
en cada una de las etapas del método se pueden redefinir o modificar. Esto significa que, dependiendo
de la complejidad del problema y de su solución, se puede plantear nuevos pasos y eliminar los ya
existentes en las diferentes etapas del método. Conforme se avance con el desarrollo de las soluciones,
se podrá observar cómo se redefinen los pasos de las etapas del método.
26 MÉTODO DE LAS 6’D - ENFOQUE ORIENTADO A LAS ESTRUCTURAS LÓGICAS

1.3 MODELAMIENTO
Se llama modelamiento a la forma en la que se representa la solución de un problema del mundo real
en términos de un modelo. Esta es una representación gráfica o simbólica de algún aspecto del mundo
que se encuentra bajo observación o estudio. Para representar un modelo se uƟliza el UML (Unified
Modeling Language).

El Lenguaje Unificado de Modelado (UML) es un lenguaje gráfico que permite:

Visualizarun modelo.
Especificar un modelo (construir modelos precisos, no ambiguos).
Construir un modelo en un lenguaje de programación (se establecen correspondencias con lenguajes
orientados a objetos, como Java, C++, Visual Basic.
Documentar los componentes de un sistema de soŌware (arquitectura, requisitos, diseño, pruebas,
versiones, planificación).
Describir el ciclo de vida completo del desarrollo orientado a objetos.

Para desarrollar un modelo y representarlo en UML es necesario conocer todos los conceptos
relacionados con el desarrollo de soŌware orientado a objetos. Para dicho propósito, se detallarán
algunos conceptos básicos que serán uƟlizados en las soluciones que plantea este libro.

1.3.1 Paquete

Los paquetes permiten organizar las clases de un modelo. Un paquete conƟene clases cuyas
funciones similares. En UML, un paquete se representa de la siguiente forma:

NombrePaquete Nombre del paquete

1.3.2 Clase

Una clase es un modelo que se uƟliza para describir uno o más objetos del mismo Ɵpo. En su forma
más sencilla, una clase es un conjunto de atributos y métodos; es una abstracción y no representa a
ningún objeto en parƟcular. En UML, una clase se representa de la siguiente forma:

NombreClase Nombre de la clase y del paquete al

(NombrePaquete al que cual pertenece la clase
pertenece)

Atributos Lista de atributos de la clase

Métodos Lista de métodos de la clase

 CAP. 1: M ÉTODO Y HERRAMIENTAS 27

1.3.3 Objeto

Es cualquier cosa real o abstracta de la que se almacenan datos, y los métodos controlan y manipulan
dichos datos. Un objeto se crea o instancia a parƟr de una clase. En UML, un objeto se representa
de la siguiente forma:

Nombre de la clase a la cual

pertenece el objeto y el nombre
NombreClase : nombreObjeto del objeto. Ambos nombres
deben estar separados por dos
puntos.

UML incorpora nueve diagramas que permiten representar un modelo desde diferentes perspecƟvas.
Estos se muestran a conƟnuación:

Diagramas de
Casos de Uso
Diagramas de
Diagramas de
Clase
Secuencia
Paquete

Diagramas de Diagramas de
Colaboración MODELO Objeto

Diagramas de Diagramas de
Estado Componentes

Diagramas de Diagramas de
AcƟvidad Distribución
28 MÉTODO DE LAS 6’D - ENFOQUE ORIENTADO A LAS ESTRUCTURAS LÓGICAS

A conƟnuación, se detalla el diagrama de paquetes que será uƟlizado en las soluciones planteadas
en el presente texto.

1.3.4 Diagrama de paquetes

Este permite especificar y visualizar las relaciones de dependencia existentes entre los paquetes que
forman parte de una solución. Una relación de dependencia entre dos o más paquetes se establece
cuando las clases que pertenecen a un paquete pueden tener acceso a todas o algunas de las clases
que pertenecen a otro paquete (dependencia unidireccional). También se puede establecer una
relación de dependencia bidireccional, cuando las clases que pertenecen a un paquete pueden tener
acceso a todas o algunas de las clases que pertenecen a otro paquete, y viceversa. En UML, una
relación de dependencia unidireccional entre dos paquetes se grafica de la siguiente manera:

dominioDeLaAplicacion Biblioteca

Relación de dependencia
unidireccional

En este caso, dependencia significa que todas las clases pertenecientes al paquete
“dominioDeLaAplicacion” podrán tener acceso a todas o algunas de las clases que pertenecen al
paquete “Biblioteca”. (Observe el senƟdo de la flecha que marca la dependencia unidireccional).

En el Método de las 6’D, el modelamiento de una solución se desarrolla durante la Etapa 03 - Diseño
de la solución.

Etapa 03
Definición
Solución

MODELAMIENTO

Se desarrollan los siguientes pasos:

Definir un nombre para el proyecto. Este paso permiƟrá agrupar todos los elementos que serán
parte de la solución del problema uƟlizando el método planteado. El nombre del proyecto comenzará
con las letras “Proy” (abreviatura de proyecto), seguido de un nombre que idenƟfique al proyecto.
Este nombre debe ser seleccionado adecuadamente.
Definición de diagramas, relaciones y clases. En este paso se desarrollará el diagrama de paquetes
y se especificará la relación de dependencia entre estos, uƟlizando UML. En las soluciones, primero
se creará un paquete y luego todos los demás. Fundamentalmente, se desarrollarán soluciones
con dos paquetes donde uno de ellos se llamará “dominioDeLaAplicación” y el otro “Biblioteca”,
estableciendo una relación de dependencia unidireccional del primero hacia el segundo.
 CAP. 1: M ÉTODO Y HERRAMIENTAS 29

En el paquete “dominioDeLaAplicacion” se definirá la clase que va a permiƟr solucionar el problema

planteado uƟlizando UML. El nombre de la clase que define el método principal comienza con las
letras “Prg” (abreviatura de programa), seguido de un nombre que idenƟfique a la clase. Este nombre
deberá ser seleccionado adecuadamente. Dicha clase por lo general no tendrá atributos definidos.

En el paquete “Biblioteca” se tendrán clases reuƟlizables, tales como la clase Lectura1 y la clase LE2,
que facilitarán el ingreso de los datos a la computadora.

Regla general para especificar los nombres de los paquetes, clases, atributos y métodos:

El nombre de las clases debe comenzar con una letra mayúscula y el resto en minúscula. Si el nombre
es compuesto, todas las primeras letras de los nombres simples que forman el nombre de la clase o
paquete deberán comenzar con mayúscula.

El nombre de los paquetes, el nombre de los atributos y el nombre de los métodos se escriben en
letra minúscula. En caso que el nombre sea compuesto, a parƟr de la segunda palabra se escribirá
la primera letra en mayúscula. Los métodos constructores son una excepción a esta regla y Ɵenen el
mismo nombre que su clase (por lo que su nombre comienza con letra mayúscula).

1.4 ALGORITMO
En su forma más simple, una clase está consƟtuida por atributos y métodos. Los métodos representan
pequeños subprogramas encapsulados dentro de las clases y contribuyen a definir el comportamiento
ơpico de los objetos.

Los algoritmos se desarrollan para especificar cuáles son los pasos desarrollados en un determinado
método y cuáles son los datos que manejan dichos pasos. Un algoritmo consƟtuye una lista completa
de los pasos y una descripción de los datos que son necesarios para resolver un determinado problema
en el ámbito de un método.

De esto se deriva que un algoritmo se desarrolla para un determinado método y que su definición
Ɵene dos partes esenciales:

Una lista de pasos que deben ser ejecutados.

Una descripción de los datos que son manipulados por estos pasos.

1.4.1 Características

Descripción de los pasos que deben ser ejecutados (estructuras lógicas).

Descripción de los datos que son manipulados por estos pasos (estructuras de datos).
Un algoritmo debe ser preciso, indicando el orden de realización de cada paso.

Todo algoritmo debe ser finito. Si se sigue un algoritmo, este debe terminar en algún momento.

Un algoritmo debe estar definido. Si se sigue un algoritmo dos veces, se debe obtener el mismo
resultado.

1
La clase Lectura se uƟliza en todos los capítulos. La clase Lectura se especifica en el apéndice.
2
La clase LE se trata en la parte final de cada capítulo, y con mayor intensidad en el capítulo final. La clase LE se
especifica en el apéndice.
30 MÉTODO DE LAS 6’D - ENFOQUE ORIENTADO A LAS ESTRUCTURAS LÓGICAS

Un algoritmo puede o no tener datos de entrada.

Un algoritmo producirá uno o más datos de salida.
Los datos de entrada y salida deben almacenarse en estructuras de datos.

El resultado que se obtenga debe saƟsfacer los requerimientos de la persona interesada (efecƟvidad).

Debe ser estructurado. Es decir, debe ser fácil de leer, entender, usar y cambiar si es preciso.

En conclusión, los algoritmos permiten especificar la lógica de desarrollo de los métodos que
conforman una clase; por lo tanto, se debe entender la importancia de estudiar los algoritmos para
comprender cómo se está solucionando un determinado problema.

Se dispone de diversas herramientas para desarrollar los algoritmos en los métodos de las clases.
Entre estas herramientas se puede mencionar al pseudocódigo y al diagrama de flujo.

1.4.2 Herramientas

A. Pseudocódigo
B. Diagrama de flujo
C. Diagrama de acƟvidad

A. Pseudocódigo
Permite expresar un algoritmo con palabras en castellano que son semejantes a las sentencias de
un lenguaje de programación.

a. Pautas básicas:
Todo algoritmo debe tener un nombre que empiece con una letra mayúscula. Si es un nombre
compuesto, la primera letra de cada palabra simple deberá estar en mayúscula. No se permiten
los espacios en blanco en el nombre del algoritmo (generalmente se uƟlizará el nombre de la
clase y el nombre del método para referirse a un determinado algoritmo).
Es necesario que se determinen los datos de entrada y la información de salida.
Para declarar una variable “x” se deberá determinar qué Ɵpo de dato se almacenará. Por ejemplo,
si se desea declarar una variable de Ɵpo texto se realizará de la siguiente manera: TEXTO x.
Para asignar un valor a una variable “x” se uƟlizará el signo igual. Por ejemplo, si se desea asignar
5 a la variable “x” se realizará de la siguiente manera: x = 5.
Para indicar que la computadora lea un valor desde un disposiƟvo externo y lo almacene en la
variable “z”, se uƟliza: LEER z.
Para indicar que la computadora escriba hacia un disposiƟvo externo:
Para escribir un mensaje (observe que el mensaje está entre comillas) se uƟliza:
ESCRIBIR “hola”.
Para escribir el valor de una variable (observe que la variable no está entre comillas) se uƟliza:
ESCRIBIR x.
Para escribir el resultado de una expresión (observe que la expresión no está entre comillas)
se uƟliza: ESCRIBIR x + 2.
 CAP. 1: M ÉTODO Y HERRAMIENTAS 31

b. Estructura básica de un pseudocódigo:

Algoritmo NombreClase – nombreMetodo( )

ENTRADA:
En Entrada y Salida se especifican
SALIDA: las variables que se usarán en el
desarrollo del algoritmo.

INICIO:
...
... Este es el cuerpo del algoritmo
expresado en pseudocódigo. Las
... instrucciones se colocan entre
FIN:
INICIO... FIN

c. Reglas o pautas
Con la finalidad de comprender mejor el diseño de los algoritmos desarrollados en pseudocódigo
y diagrama de flujo, se han clasificado en seis grupos las reglas definidas.

REGLA FORMATO DESCRIPCIÓN

GRUPO 1

Utilizada para el ingreso de datos.

LEER LEER x El dato ingresado se almacena en la
variable especificada.

Utilizada para la salida de

ESCRIBIR “Hola”
información. Se puede visualizar una
ESCRIBIR x
ESCRIBIR cadena, el contenido de una variable
ESCRIBIR x + z
o el resultado de una operación
matemática.

Utilizada para realizar comentarios

COMENTARIO COMENTARIO “Variables” internos en los algoritmos de las
soluciones.

Permite declarar una variable de tipo

NUMERO NUMERO x
numérico.

Permite declarar una variable de tipo

TEXTO TEXTO mensaje
texto o cadena.

Permite declarar a una variable de

CARACTER CARACTER letra
tipo texto o cadena de una sola letra.

Permite declarar una variable de tipo

LOGICO LOGICO aprobado
lógico

Permite asignar el valor VERDADERO

VERDADERO aprobado = VERDADERO
a una variable lógica.

Permite asignar el valor FALSO a una

FALSO aprobado = FALSO
variable lógica.
32 MÉTODO DE LAS 6’D - ENFOQUE ORIENTADO A LAS ESTRUCTURAS LÓGICAS

REGLA FORMATO DESCRIPCIÓN

GRUPO 2
SI (condición) ENTONCES

Permite especificar una estructura de

SI instrucciones...
decisión simple “SI... FINSI”.

FINSI

SI (condición) ENTONCES
instrucciones...
Permite especificar una estructura de
SI / SINO SINO
decisión doble “SI... SINO... FINSI”.
instrucciones...
FINSI

CUANDO (variable) SEA

CASO valor 1 :
instrucciones...

CASO valor 2 :
Permite especificar una estructura
instrucciones...
CUANDO de decisión múltiple “CUANDO...
CASO valor n :
FINCUANDO”.
instrucciones...
OTROS
instrucciones…

FINCUANDO
DESDE i = valorInicial
HASTA valorFinal
instrucción 1
Permite especificar una estructura
.
de repetición “DESDE... FINDESDE”.
DESDE .
Esta estructura es equivalente a
.
PARA.
instrucción n

FINDESDE
PARA ( i = valorInicial ;
condición ; valor )
instrucción 1
. Permite especificar una estructura de
PARA . repetición “PARA... FINPARA”. Esta
. estructura es equivalente a DESDE.
instrucción n

FINPARA
MIENTRAS (condición)
instrucción 1
.
Permite especificar una estructura
.
MIENTRAS de repetición “MIENTRAS...
.
FINMIENTRAS”.
instrucción n

FINMIENTRAS
HACER
instrucción 1
.
Permite especificar una estructura de
HACER .
repetición “HACER... MIENTRAS”.
.
instrucción n
MIENTRAS (condición
 CAP. 1: M ÉTODO Y HERRAMIENTAS 33

Permite terminar la ejecución de una

TERMINAR TERMINAR
estructura lógica de repetición.

Permite volver a ejecutar una

estructura lógica de repetición, sin
CONTINUAR CONTINUA
finalizar todas las instrucciones que
forman parte de la misma.

REGLA FORMATO DESCRIPCIÓN

GRUPO 3

Permite obtener el coseno del valor

almacenado en la variable “n”. El
COSENO
x = COSENO n resultado se almacena en la variable
“x”.

Permite obtener el seno del valor

almacenado en la variable “n”. El
SENO x = SENO n
resultado se almacena en la variable
“x”.

Permite obtener la longitud de la

cadena almacenada en la variable
LONGITUD x = LONGITUD n “n” o la longitud del vector “n”. El
resultado se almacena en la variable
“x”.

Permite obtener el número de filas

FILA x = FILA n de una matriz “n”. El resultado se
almacena en la variable “x”.

Permite obtener el número de

columnas de una matriz “n”. El
COLUMNA x = COLUMNA n
resultado se almacena en la variable
“x”.

Permite cambiar a mayúscula la

x = MAYUSCULA n cadena almacenada en la variable
MAYUSCULA
“n”. El resultado se almacena en la
variable “x”.

Permite cambiar a minúscula la

cadena almacenada en la variable
MINUSCULA x = MINUSCULA n
“n”. El resultado se almacena en la
variable “x”.
34 MÉTODO DE LAS 6’D - ENFOQUE ORIENTADO A LAS ESTRUCTURAS LÓGICAS

REGLA FORMATO DESCRIPCIÓN

GRUPO 4

Permite obtener el resto de la división

entre las variables “z” y “n”. El
RESTO x = z RESTO n
resultado se almacena en la variable
“x”.

Permite obtener la parte entera de la

división de las variables “z” y “n”. El
DIVIDIR x = z DIVIDIR n
resultado se almacena en la variable
“x”.

Permite obtener la raíz “n” del número

RAIZ x = z RAIZ n “z”. El resultado se almacena en la
variable “x”.

Permite obtener la potencia “n” del

POTENCIA x = z POTENCIA n número “z”. El resultado se almacena
en la variable “x”.

Permite obtener el número mayor

entre el valor almacenado en la
MAXIMO x = z MAXIMO n variable “n” y la variable “z”. El
resultado se almacena en la variable
“x”.

Permite obtener el número mayor

entre los valores almacenados en las
MAYOR x = MAYOR n1, n2, n3… variables “n1”, “n2”, “n3”…
El resultado se almacena en la
variable “x”.

Permite obtener el número menor

entre los valores almacenados en las
MENOR x = MENOR n1, n2, n3… variables “n1”, “n2”, “n3”…
El resultado se almacena en la
variable “x”.

Permite obtener el número menor

entre el valor almacenado en la
MINIMO x = z MINIMO n variable “n” y la variable “z”. El
resultado se almacena en la variable
“x”.

Permite obtener el promedio entre los

valores almacenados en las variables
PROMEDIO x = PROMEDIO n1, n2, n3… “n1”, “n2”, “n3”…
El resultado se almacena en la
variable “x”
 CAP. 1: M ÉTODO Y HERRAMIENTAS 35

Permite obtener el carácter ubicado

en la posición “n” de la cadena “z”. El
CARACTER x = z CARACTER n
resultado se almacena en la variable
“x”.

Permite obtener un número cualquiera

(aleatorio) entre los valores de “z” y
ALEATORIO x = z ALEATORIO n
“n”. El resultado se almacena en la
variable “x”.

Permite redondear un número “z” al

número de decimales especificado
REDONDEAR x = z REDONDEAR n
en “n” El resultado se almacena en la
variable “x”.

REGLA FORMATO DESCRIPCIÓN

GRUPO 5

Permite obtener una subcadena

comprendida entre las posiciones
SUBCADENA x = z SUBCADENA n1, n2 especificadas por “n1” y “n2” de la
cadena “z”. El resultado se almacena
en la variable “x”.

Permite eliminar los espacios

existentes en una cadena entre las
x = z ELIMINAESPACIO n1,
ELIMINAESPACIO posiciones especificadas por “n1” y
n2
“n2”. El resultado se almacena en la
variable “x”.

REGLA FORMATO DESCRIPCIÓN

GRUPO 6

Utilizada para crear arreglos

CREAR vector[n] previamente declarados. Un arreglo
CREAR permite almacenar más de un dato
CREAR matriz[n1][n2] del mismo tipo.

CLASE CLASE PrgEjemplo Utilizada para especificar una clase.

Permite crear un objeto de una

CREAR CREAR objeto
determinada clase.

EJECUTAR EJECUTAR algoritmo Permite ejecutar otro algoritmo.

Permite especificar si un algoritmo

PARAMETRO PARAMETRO listaVariables
recibe datos o valores.

Permite especificar si un algoritmo

RETORNAR RETORNAR variable
retorna una respuesta.
36 MÉTODO DE LAS 6’D - ENFOQUE ORIENTADO A LAS ESTRUCTURAS LÓGICAS

B. Diagrama de flujo
Permite ilustrar la secuencia de pasos de un algoritmo por medio de símbolos especializados y
líneas de flujo. La combinación de símbolos especializados y líneas de flujo describe la lógica para
la solución del problema (algoritmo). Entonces, se puede afirmar que el Diagrama de Flujo es la
representación gráfica de un algoritmo.

DIAGRAMA DE FLUJO

FLUJO
Porque muestra la secuencia de lo que se
Ɵene que realizar.

DIAGRAMA
Por el hecho de ser dibujo que no
requiere estar a escala.

Elementos o símbolos básicos:

PROCESO
UƟlizado para asignar valores a variables y resultados de
operaciones matemáƟcas.

ENTRADA / SALIDA
UƟlizado para ingresar datos y visualizar la información que
resulta del procesamiento.

INICIO / FIN
Este símbolo permite marcar el inicio y el final del algoritmo.

CONECTOR
Este símbolo permite que no se crucen los flujos (líneas) en
un diagrama.

FLUJOS (LÍNEAS)
Líneas que permiten unir los diagramas y mostrar la secuencia
lógica a la solución del problema.
 CAP. 1: M ÉTODO Y HERRAMIENTAS 37

Estructura básica de un diagrama de flujo:

Algoritmo NombreClase – nombreMetodo()

INICIO

Este es el cuerpo del algoritmo

expresado en diagrama de
Instrucciones… flujo. Las instrucciones se
colocan entre INICIO… FIN.

FIN

C. Diagrama de acƟvidades
Son parte del lenguaje unificado de modelado (UML) y se uƟlizan comúnmente en dos formas:
1.- Es el modelado de flujos de trabajo, haciendo hincapié en las acƟvidades tal y como son vistas
por los actores que colaboran con el sistema, esto es, modelando procesos de negocio.
2.- Es el modelado de una operación, uƟlizando los diagramas de acƟvidad como diagramas de flujo
para amostrar detalles de un algoritmo, haciendo amplio uso de las condiciones de procesos
concurrentes.
Los diagramas de acƟvidad están compuestos por símbolos de propósito especial, tales como
los símbolos de estado de acción, diamantes, pequeños círculos y barras de sincronización. Estos
símbolos están conectados mediante flechas de transición, las cuales representan el flujo de
acƟvidad.
Cada estado de acción representa la realización de una o varias tareas. Se representa por un
rectángulo de sus lados izquierdo y derecho reemplazados con arcos hacia fuera. Cada acƟvidad
conƟene una expresión de acción que especifica una acción parƟcular a realizar. Las acciones
pueden incluir cálculos aritméƟcos, lógicos u operaciones de entrada y salida. La expresión de
acción puede especificarse en lenguaje natural o uƟlizando pseudocódigo.

Las flechas en el Diagrama de AcƟvidad se llaman flechas de transición. Estas flechas representan
transiciones, las cuales indican el orden en el que ocurren las acciones representadas por los
estados de acción.

El círculo sólido en la parte superior del diagrama de acƟvidad representa el estado inicial de la
acƟvidad, es decir, el inicio de flujo de trabajo antes de que el programa realice las tareas modeladas.
El círculo sólido rodeado por una circunferencia que aparece en la parte inferior del diagrama de
acƟvidad representa el estado final, es decir, el final del flujo de trabajo después de que el programa
realiza todas las tareas. Un diamante o rombo permite representar caminos alternaƟvos según se
cumpla alguna condición.
38 MÉTODO DE LAS 6’D - ENFOQUE ORIENTADO A LAS ESTRUCTURAS LÓGICAS

Las barras de sincronización permiten mostrar acƟvidades concurrentes, es decir, acƟvidades

que pueden realizarse en paralelo. Sin embargo, en la realidad puede ser que no se ejecuten
simultáneamente. La idea es indicar qué acƟvidades se pueden realizar en paralelo, sin que ello
signifique que deba forzosamente realizarse así. Puede realizarse en cualquier orden, lo importante
es dar la idea de que se pueden ejecutar al mismo Ɵempo. Las barras de sincronización son líneas
conƟnuas gruesas y pueden ser verƟcales u horizontales.
En un Diagrama de AcƟvidad, como en cualquier diagrama UML, puede incluir notas. Las notas
son comentarios con explicaciones que describen el propósito de los símbolos del diagrama de
AcƟvidad. Las notas son símbolos representados por rectángulos con la esquina superior derecha
doblada. Una línea punteada permite conectar cada nota con el elemento que describe dicha nota.
Generalmente, las notas pueden uƟlizarse para describir como se relacionan los diagramas con un
lenguaje de programación en parƟcular.
Al igual que los Pseudocódigo y los Diagramas de Flujo, los Diagramas de AcƟvidades ayudan a los
programadores a desarrollar y representar los algoritmos, aunque muchos programadores prefieren
uƟlizar Pseudocódigo o Diagramas de Flujo. Los Diagramas de AcƟvidad claramente muestran cómo
operan las estructuras lógicas y pueden ser usados para diseñar algoritmos.

Elementos o símbolos básicos:

ESTADO INICIAL
Este símbolo permite marcar el inicio del algoritmo.

ESTADO DE ACCIÓN O ACTIVIDAD

Representa la realización de una o varias tareas.

DECISIÓN
Permite representar caminos alternaƟvos en base a una
condición.

ESTADO FINAL
Este símbolo permite marcar el final del algoritmo.

FLECHAS DE TRANSICIÓN
Líneas que indican el orden en que ocurren las acciones.

BARRAS DE SINCRONIZACIÓN
Líneas que permiten mostrar acƟvidades concurrentes.

NOTAS
Comentarios que permiten describir el propósito de los
diagramas.
 CAP. 1: M ÉTODO Y HERRAMIENTAS 39

En el Método de las 6`D, el algoritmo de una solución se desarrolla después del modelamiento,
durante la Etapa 03 – “Diseño de la Solución”.

Etapa 03
Diseño
Solución

MODELAMIENTO
ALGORITMO

Se desarrollará el siguiente paso:

Desarrollo de algoritmos. En este paso, se desarrollará el algoritmo para el método especificado en

la clase, la cual forma parte del paquete “dominioDeLaAplicación”. Para el desarrollo del algoritmo
se uƟlizará Pseudocódigo y/o Diagrama de Flujo.

También, en algunos casos, a modo de introducción se uƟlizarán los diagramas de acƟvidades.

1.5 PROGRAMACIÓN
La programación es la traducción del modelamiento y los algoritmos en sentencias que la computadora
puede comprender y ejecutar. Es decir, que la programación es la acción de escribir programas para
una computadora, uƟlizando alguno de los lenguajes de programación existentes. Dicha acción se
conoce como codificación.

Las personas que escriben los programas son conocidas como programadores, los cuales están
divididos en categorías según su experiencia y dominio de diferentes lenguajes de programación.

Entonces, un lenguaje de programación es aquel que uƟlizan los programadores, que son comprendidos
y ejecutados en una computadora.

Nos “comunicamos” con las computadoras a través de los programas desarrollados en un lenguaje
de programación en parƟcular. Existen diferentes lenguajes de programación, la mayor parte de los
cuales Ɵenen un conjunto de reglas o sentencias muy especializadas.

La forma de programación ha variado con el paso de los años. Al inicio, se desarrolló la programación
lineal, luego de la programación modular, después la programación estructurada y ahora la
programación orientada a objetos.

Entre los lenguajes de programación orientados a objetos podemos destacar a C++ y Java.
40 MÉTODO DE LAS 6’D - ENFOQUE ORIENTADO A LAS ESTRUCTURAS LÓGICAS

1.5.1 Tipos de lenguajes de programación

A. C++
C++ es un lenguaje de programación, diseñado a mediados de los años 1980 por Bjame Stroudstrup,
como extensión del lenguaje de programación C.
Actualmente, existe un estándar denominado ISO C++, al que se han adherido la mayoría de los
fabricantes de compiladores más modernos.
Existen también algunos intérpretes como ROOT (enlace externo). Las principales caracterísƟcas del
C++ son el soporte para programación orientada a objetos y el soporte de planƟllas o programación
genérica (templates). Se puede decir que C++ es un lenguaje que abarca tres paradigmas de la
programación: la programación estructurada, la programación genérica y la programación orientada
a objetos.
C++ está considerado por muchos programadores como uno de los mejores lenguajes de
programación, debido a que permite trabajar tanto a alto como a bajo nivel; sin embargo es a su vez
uno de los que menos automaƟzaciones Ɵene (obliga a hacerlo casi todo manualmente al igual que
C) lo que genera más Ɵempo para su aprendizaje.

B. Java
Java es un lenguaje de programación orientado a objetos, desarrollado por Sun MicroSystems, una
compañía reconocida por sus estaciones de trabajo UNIX de alta calidad.
Fundamentado en el lenguaje de programación C++, el lenguaje Java se diseñó para ser pequeño,
sencillo y portáƟl a través de plataformas y sistemas operaƟvos, tanto a nivel de código fuente como
binario, lo que significa que los programas Java (applets, aplicaciones y servlests), pueden ejecutarse
en cualquier computadora que tenga instalada una máquina virtual de Java.
En la actualidad, la Programación Estructurada (PE) y la Programación Orientada a Objetos (POO)
son las formas de programación uƟlizadas por la mayoría de los programadores, siendo la POO la
más reciente y la que asegura solucionar la mayoría de los problemas de la PE, incorporando nuevas
caracterísƟcas y nuevos conceptos. Una caracterísƟca importante de la POO es que uƟliza conceptos
ópƟmos de la PE y de las otras formas de programación.
En el Método de las 6´D, la programación de una solución se desarrolla durante la Etapa 04 –
“Desarrollo de la Solución”.

Etapa 04
Desarrollo
Solución

CODIFICACIÓN

Se desarrollará solo el primer paso.

Codificar el proyecto. En este paso, se desarrollará la codificación del proyecto; es decir, uƟlizando
el lenguaje de programación Java y/o C++, se traducirá lo especificado en el modelamiento y en los
algoritmos en sentencias que la computadora pueda comprender y ejecutar.