Método de las 6`D Modelamiento - Algoritmo - Programación. › media › eb_0104 › samples ›...

Método de las 6`D Modelamiento - Algoritmo - Programación.Tomo I. Enfoque orientado a las estructuras lógicasAutores: Juan José Flores Cueto y Carmen Bertolo Zuñiga

© Derechos de autor registrados:Empresa Editora Macro EIRL

© Derechos de edición, arte gráfi co 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 QuispeSebas an Alvarez Sanchez

Edición a cargo de:© Empresa Editora Macro EIRLAv. Paseo de la República N.° 5613 , Mirafl ores, Lima, Perú

Teléfono: (511) 748 0560E-mail: [email protected]ágina web: www.editorialmacro.com

Primera edición: se embre de 2014Tiraje: 1000 ejemplares

ImpresiónTalleres gráfi cos de la Empresa Editora Macro EIRLJr. San Agus n N.° 612-624, Surquillo, Lima, Perú

ISBN N.° 978-612-304-218-9Hecho 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://jjfl orescueto.googlepages.com/. Y sus publicaciones se pueden encontrar en: h p://www.lulu.com/spotlight/jjfl orescueto, 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 fi nalizados 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 ...........................................................................................................151.1.1 Etapas y pasos ..........................................................................................................161.1.2 Resumen de método ................................................................................................231.1.3 Resultado de las etapas del método ........................................................................24

1.2 Marco de trabajo .............................................................................................................251.3 Modelamiento .................................................................................................................26

1.3.1 Paquete ...................................................................................................................261.3.2 Clase .........................................................................................................................261.3.3 Objeto ......................................................................................................................271.3.4 Diagrama de paquetes .............................................................................................28

1.4 Algoritmo ..........................................................................................................................291.4.1 Caracterís cas ..........................................................................................................291.4.2 Herramientas ...........................................................................................................30

1.5 Programación ..................................................................................................................391.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 .....................................................................................452.1.1 Defi nición .................................................................................................................45

2.2 Método de las 6´D - Desarrollo de soluciones con un paquete .......................................462.3 Estructuras lógicas de secuencia: Mostrar información ..................................................47

2.3.1 Defi nición .................................................................................................................472.3.2 Representación ........................................................................................................472.3.3 Consideraciones adicionales para los lenguajes de programación C++ y Java .........49

2.4 Estructura de datos: Variable ..........................................................................................602.4.1 Defi nición .................................................................................................................602.4.2 Declaración ..............................................................................................................602.4.3 Nombre ....................................................................................................................602.4.4 Inicialización .............................................................................................................612.4.5 Almacenamiento o asignación de datos ..................................................................612.4.6 Constantes ...............................................................................................................62

2.5 Tipos de dato ...................................................................................................................622.5.1 Defi nición .................................................................................................................622.5.2 En pseudocódigo y diagrama de fl ujo ......................................................................632.5.3 En lenguaje C++ ........................................................................................................642.5.4 En lenguaje Java .......................................................................................................65

2.6 Uso de comentarios .........................................................................................................752.7 Estructura lógica de secuencia: Ingresar datos ................................................................80

2.7.1 Defi nición .................................................................................................................802.7.2 Representación ........................................................................................................80

2.8 Estructura lógica de secuencia: Procesar datos ................................................................912.8.1 Defi nición .................................................................................................................912.8.2 Tipos .........................................................................................................................91

2.9 Método de las 6`D - Desarrollo de soluciones con dos paquetes ....................................1002.10 Desarrollo de Aplicaciones Java, u lizando Java Development Kit (JDK ) ......................126

2.10.1 Edición ....................................................................................................................1262.10.2 Compilación ...........................................................................................................1262.10.3 Ejecución ................................................................................................................126

2.11 Soluciones u lizando cuadros de diálogo ......................................................................1282.11.1 Uso de la clase LE codifi cada en Java .....................................................................1282.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 .......................................................................1473.2 Estructuras lógicas de decisión ........................................................................................147

3.2.1 Defi nición .................................................................................................................1473.2.2 Estructura lógica de decisión simple ........................................................................1483.2.3 Estructura lógica de decisión doble .........................................................................1673.2.4 Estructura lógica de decisión múl ple: “CUANDO” .................................................1843.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 ....................................................2373.4 Uso anidado de las estructuras lógicas de decisión .........................................................2373.5 Desarrollo de aplicaciones Java, u lizando Integrated Development Environment (IDE) .. 2573.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 ...................................2854.2 Estructuras lógicas de repe ción .....................................................................................286

4.2.1 Otros usos de las variables .......................................................................................2874.2.2 Estructura lógica de repe ción: “HACER” ................................................................2874.2.4 Estructura lógica de repe ción: “MIENTRAS” ..........................................................3484.2.5 Estructura lógica de repe ción: “DESDE” o “PARA” .................................................378

4.3 Empaquetar aplicaciones Java u lizando Java ARchives ( JAR ) .......................................4094.3.1 Creación de un JAR ...................................................................................................409

4.3.2 Ejecución de un JAR .................................................................................................4114.3.3 Visualizar un JAR ......................................................................................................4124.3.4 Extracción de un JAR ................................................................................................413

4.4 So ware para decompilar aplicaciones java ...................................................................4154.4.1 Uso de javap del JDK ................................................................................................4154.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 ......................................................................4395.2 Manejo de excepciones en el lenguaje de programación Java ........................................5225.3 Desarrollo de las capacidades lógicas ..............................................................................5305.4 Desarrollo de miniaplicaciones Java (Applet) u lizando Java Development Kit ( JDK ) ...5575.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áfi ca de

Usuario .................................................................................................................................................... 583

6.1 Conceptos básicos ...........................................................................................................5886.1.1 Clase .........................................................................................................................5886.1.2 Objeto (Modelos de entes del mundo) ...................................................................5896.1.3 Atributo ....................................................................................................................5906.1.4 Método ....................................................................................................................595

6.2 Método de las 6’D: Redefi nición de pasos ......................................................................6086.2.1 Ajuste de los pasos defi nidos para las etapas del método .......................................608

6.3 So ware para generar ejecutables en MS-Windows basado en aplicaciones Java ........6156.3.1 Uso de so ware ......................................................................................................615

6.4 Introducción a las soluciones u lizando Interfaz Gráfi ca de Usuario (GUI) .....................6186.4.1 Introducción .............................................................................................................6186.4.2 Defi nición .................................................................................................................6186.4.3 Etapas para el desarrollo de GUI ..............................................................................6186.4.4 Contenedores y componentes de la GUI..................................................................6196.4.5 Administradores de diseño de la GUI .......................................................................6206.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 ..................................................................................635Clase Lectura ........................................................................................................................635Clase LE (versión 2.2) ...........................................................................................................636El paquete del lenguaje Java ................................................................................................643

Conversión de datos .................................................................................................................645Conversión implícita de datos en Java .................................................................................646Conversión explícita de datos en Java (cas ng) ...................................................................648Envoltorios de los pos de datos primi vos: clases wrappers.............................................649

Funciones matemá cas: clase Math ........................................................................................659Introducción ........................................................................................................................659Métodos ..............................................................................................................................660

Manejo de cadenas: clase String ..............................................................................................703Introducción ........................................................................................................................703Métodos ..............................................................................................................................704

Manejo de formatos: clase Decimalformat ..............................................................................754Manejo de fechas: clase Calendar ............................................................................................759Manejo de fechas: clase Gregoriancalendar ............................................................................764Manejo 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 fl ujo 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 codifi cació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 fi naliza con una introducción al desarrollo de soluciones orientadas a objetos y al uso de Interfaz Gráfi ca de Usuario (GUI) en los programas Java.

La estructura de los capítulos y su relación directa con los problemas propuestos al fi nal 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

Método y herramientasMétodo y herramientas1CAP.

CAP. 1: MÉTODO Y HERRAMIENTAS 15

1.1 MÉTODO DE LAS 6’D

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

n veces

MODELAMIENTOMODELAMIENTO ALGORITMO ALGORITMO

CODIFICACIÓNNN

Etapa 01

Descripción del problema

Ingeniería reversa

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 modifi cando o ajustando, dependiendo del grado de complejidad del problema y las herramientas que se u licen para su solución.

Con la fi nalidad de recordar el método, se ha establecido que el nombre de cada una de sus seis etapas comience con la letra “D”.

Defi niciónSolución

Etapa 02

DiseñoSolución

Etapa 03

DesarrolloSolución

Etapa 04

DepuraciónPruebas

Etapa 05

Documento

Etapa 06

MÉTODO DE LAS 6’D - ENFOQUE ORIENTADO A LAS ESTRUCTURAS LÓGICAS16

1.1.1 Etapas y pasos

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

Lo primero que se debe hacer en esta etapa es iden fi car cuál es el problema que 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 fi carlo es una de las tareas más importantes que los analistas deben afrontar.

Una vez iden fi cado 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.

Etapa 01


Pasos:

Iden fi cación del problema. Descripción general del problema. Enunciado claro y preciso del problema.

El resultado obtenido en esta etapa es un enunciado claro del problema que se desea solucionar.

ENUNCIADO


B. Descripción de la Etapa 02 – Defi nición de la solución

En esta etapa es necesario estudiar a fondo el problema para poder solucionarlo, saber 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.

Etapa 02

Defi nición de la solución

ESPECIFICACIONES

Pasos:

Defi nir 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.

En esta etapa se ob enen las especifi caciones, que determinan lo que se debe hacer para solucionar el problema.


C. Descripción de la Etapa 03 – Defi nición de la solución

Una vez defi nida la solución se procederá a diseñar la lógica, modelando y desarrollando algoritmos.

Para el modelado de la solución del problema se u lizará el Lenguaje Unifi cado de Modelado (Unifi ed 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 verifi car 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”.

Etapa 03

Diseñode la solución

Pasos:

Defi nir un nombre para el proyecto. Defi nición de diagramas, relaciones y

clases. Desarrollo de algoritmos.

DIAGRAMAS Y ALGORITMOS

El resultado obtenido en esta etapa son los diagramas y los algoritmos, que especifi can cómo se debe hacer para solucionar el problema.

MODELAMIENTOMODELAMIENTO

ALGORITMO ALGORITMO


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

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

La codifi cación involucra traducir los diagramas, las especifi caciones 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.

Etapa 04

Desarrollode la solución

Pasos:

Codifi car el 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 codifi cados en un lenguaje de programación, que permiten solucionar el problema.

CODIFICACIÓNCODIFICACIÓN


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

Luego que se codifi quen los programas y/o clases, deberán ser probados mediante su 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, modifi car o crear nuevas sentencias, volver a probar el programa y con nuar con la corrección y pruebas hasta conseguir el resultado deseado.

Etapa 05

Depuración y pruebas

Pasos:

Realizar la depuración y verifi car 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.


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

En esta etapa se recopila toda la 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ón del 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.

Etapa 06

Documentación

Pasos:

Recopilar el material generado en cada una de las etapas anteriores.

Generar el manual del programa. Generar el manual del usuario.

El resultado obtenido en esta etapa son los manuales, que permiten un adecuado manejo de la solución desarrollada.

MANUALES


La ingeniería reversa permite crear o 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 04 “Desarrollo de la solución”, y corregido en la Etapa 05 “Depuración y pruebas”.

Es decir, a través de la ingeniería reversa es posible programar o codifi car algunas partes (hasta su correcto funcionamiento) que no estén especifi cadas 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 se con núa con el proceso hasta llegar a la solución deseada.

Etapa 03

DiseñoSolución

Pasos:

Exportar proyecto (archivos class o Java) al disco de la PC, si está trabajando con un IDE.

Importar proyecto (archivos class o Java) a una herramienta CASE y realizar la ingeniería reversa.

Organizar el modelo obtenido en la herramienta CASE.

DIAGRAMASACTUALIZADOS

Etapa 04

DesarrolloSolución

Etapa 05

Depuración y pruebas

n veces

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

MODELAMIENTOMODELAMIENTOALGORITMOALGORITMO


Ingeniería reversa


1.1.2 Resumen de método

Resumen de las etapas y los pasos del método.Et

apa

01Et

apa

03Et

apa

05Et

apa

02Et

apa

04Et

apa

06

Desc

ripci

ónPr

oble

ma

Dise

ñoSo

luci

ónDe

pura

ción

Prue

bas

Defi n

ició

nSo

luci

ónDe

sarr

ollo

Solu

ción

Docu

men

to

Iden

fi ca

ción

de

l pro

blem

a.

Desc

ripci

ón

gene

ral d

el

prob

lem

a.

Enun

ciad

o cl

aro

y pr

eciso

del

pr

oble

ma.

Defi n

ir el

re

sulta

do

dese

ado.

Dete

rmin

ar lo

s da

tos q

ue se

de

ben

ingr

esar

o

gene

rar

para

obt

ener

el

resu

ltado

de

sead

o.

Dete

rmin

ar la

fo

rma

en q

ue

los d

atos

será

n pr

oces

ados

pa

ra

tran

sfor

mar

los

en in

form

ació

n.

Defi n

ir un

no

mbr

e pa

ra e

l pr

oyec

to.

Defi n

ició

n de

di

agra

mas

, re

laci

ones

y

clas

es.

Desa

rrol

lo d

e al

gorit

mos

.

Codifi c

ar e

l pr

oyec

to.

Desa

rrol

lar

com

enta

rios

inte

rnos

en

los

prog

ram

as d

e co

mpu

tado

ra.

Desa

rrol

lar

copi

as d

e se

gurid

ad

de lo

s pr

ogra

mas

de

com

puta

dora

.

Real

izar l

a de

pura

ción

y

verifi

car

la

cor

rect

a es

critu

ra d

e lo

s pr

ogra

mas

.

Real

izar p

rueb

as

de si

ntax

is.

Real

izar p

rueb

as

de ló

gica

.

Reco

pila

r el

mat

eria

l gen

erad

o en

cad

a un

a de

las

etap

as a

nter

iore

s.

Gen

erar

el m

anua

l de

l pro

gram

a.

Gen

erar

el m

anua

l de

l usu

ario

.


1.1.3 Resultado de las etapas del método

Etap

a 01

Etap

a 03

Etap

a 05

Etap

a 02

Etap

a 04

Etap

a 06

Desc

ripci

ónPr

oble

ma

Dise

ñoSo

luci

ónDe

pura

ción

Prue

bas

Defi n

ició

nSo

luci

ónDe

sarr

ollo

Solu

ción

Docu

men

to

Enun

ciad

oEs

pecifi c

acio

nes

Diag

ram

asy

algo

ritm

osPr

ogra

mas

Prue

bas

Man

uale

s


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 (“Defi nició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 especifi car 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.

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, Polimorfi smo, Interfaces gráfi cas, Conexión a base de datos y Servlets, entre otros.

Es importante mencionar que, dependiendo de la complejidad del problema, los pasos especifi cados en cada una de las etapas del método se pueden redefi nir o modifi car. Esto signifi ca 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 redefi nen los pasos de las etapas del método.

Defi niciónSolución

DiseñoSolución

MARCO DE TRABAJO

DesarrolloSolución

Etapa 02

Etapa 03

Etapa 04

Etapa 01


ENUNCIADO




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áfi ca 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 (Unifi ed Modeling Language).

El Lenguaje Unifi cado de Modelado (UML) es un lenguaje gráfi co que permite:

Visualizar un modelo. Especifi car 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, planifi cació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:

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:

NombrePaquete Nombre del paquete

NombreClase(NombrePaquete al que

pertenece)

Nombre de la clase y del paquete al cual pertenece la clase

Atributos Lista de atributos de la clase

Métodos Lista de métodos de la clase


Diagramas deClase

Paquete

MODELODiagramas de

Objeto

Diagramas de Casos de Uso

Diagramas deSecuencia

Diagramas deColaboración

Diagramas deComponentes

Diagramas deEstado

Diagramas deDistribución

Diagramas deAc vidad

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:

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

Nombre de la clase a la cual pertenece el objeto y el nombre del objeto. Ambos nombres deben estar separados por dos puntos.

NombreClase : nombreObjeto


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 especifi car 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 grafi ca de la siguiente manera:

En este caso, dependencia signifi ca 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 fl echa 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.

Se desarrollan los siguientes pasos:

Defi nir 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 fi que al proyecto. Este nombre debe ser seleccionado adecuadamente.

Defi nición de diagramas, relaciones y clases. En este paso se desarrollará el diagrama de paquetes y se especifi cará 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.

Relación de dependencia unidireccional

dominioDeLaAplicacion Biblioteca

Etapa 03Defi niciónSolución

MODELAMIENTOMODELAMIENTO


En el paquete “dominioDeLaAplicacion” se defi nirá la clase que va a permi r solucionar el problema planteado u lizando UML. El nombre de la clase que defi ne el método principal comienza con las letras “Prg” (abreviatura de programa), seguido de un nombre que iden fi que a la clase. Este nombre deberá ser seleccionado adecuadamente. Dicha clase por lo general no tendrá atributos defi nidos.

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 especifi car 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 defi nir el comportamiento pico de los objetos.

Los algoritmos se desarrollan para especifi car 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 defi nició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 fi nito. Si se sigue un algoritmo, este debe terminar en algún momento. Un algoritmo debe estar defi nido. 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 especifi ca en el apéndice.2 La clase LE se trata en la parte fi nal de cada capítulo, y con mayor intensidad en el capítulo fi nal. La clase LE se especifi ca en el apéndice.


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 especifi car 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 fl ujo.

1.4.2 Herramientas

A. Pseudocódigo

B. Diagrama de fl ujo

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.


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

c. Reglas o pautas

Con la fi nalidad de comprender mejor el diseño de los algoritmos desarrollados en pseudocódigo y diagrama de fl ujo, se han clasifi cado en seis grupos las reglas defi nidas.

Algoritmo NombreClase – nombreMetodo( )

ENTRADA:

SALIDA:

INICIO:

FIN:

En Entrada y Salida se especifi can las variables que se usarán en el

desarrollo del algoritmo.

Este es el cuerpo del algoritmo expresado en pseudocódigo. Las

instrucciones se colocan entre INICIO... FIN

...

...

...

REGLA FORMATO DESCRIPCIÓNGRUPO 1

LEER LEER xUtilizada para el ingreso de datos. El dato ingresado se almacena en la variable especificada.

ESCRIBIR

ESCRIBIR “Hola”ESCRIBIR xESCRIBIR x + z

Utilizada para la salida de información. Se puede visualizar una cadena, el contenido de una variable o el resultado de una operación matemática.

COMENTARIO COMENTARIO “Variables”Utilizada para realizar comentarios internos en los algoritmos de las soluciones.

NUMERO NUMERO xPermite declarar una variable de tipo numérico.

TEXTO TEXTO mensajePermite declarar una variable de tipo texto o cadena.

CARACTER CARACTER letraPermite declarar a una variable de tipo texto o cadena de una sola letra.

LOGICO LOGICO aprobadoPermite declarar una variable de tipo lógico

VERDADERO aprobado = VERDADEROPermite asignar el valor VERDADERO a una variable lógica.

FALSO aprobado = FALSOPermite asignar el valor FALSO a una variable lógica.



SI

SI (condición) ENTONCES instrucciones...

FINSI

Permite especificar una estructura de decisión simple “SI... FINSI”.

SI / SINO

SI (condición) ENTONCES instrucciones...SINO instrucciones...FINSI

Permite especificar una estructura de decisión doble “SI... SINO... FINSI”.

CUANDO

CUANDO (variable) SEA CASO valor 1 : instrucciones...

CASO valor 2 : instrucciones... CASO valor n : instrucciones... OTROS instrucciones…

FINCUANDO

Permite especificar una estructura de decisión múltiple “CUANDO... FINCUANDO”.

DESDE

DESDE i = valorInicial HASTA valorFinal instrucción 1 . . . instrucción n FINDESDE

Permite especificar una estructura de repetición “DESDE... FINDESDE”. Esta estructura es equivalente a PARA.

PARA

PARA ( i = valorInicial ; condición ; valor ) instrucción 1 . . . instrucción n FINPARA

Permite especificar una estructura de repetición “PARA... FINPARA”. Esta estructura es equivalente a DESDE.

MIENTRAS

MIENTRAS (condición) instrucción 1 . . . instrucción n

FINMIENTRAS

Permite especificar una estructura de repetición “MIENTRAS...FINMIENTRAS”.

HACER

HACER instrucción 1 . . . instrucción nMIENTRAS (condición

Permite especificar una estructura de repetición “HACER... MIENTRAS”.


TERMINAR TERMINARPermite terminar la ejecución de una estructura lógica de repetición.

CONTINUAR CONTINUA

Permite volver a ejecutar una estructura lógica de repetición, sin finalizar todas las instrucciones que forman parte de la misma.


COSENOx = COSENO n

Permite obtener el coseno del valor almacenado en la variable “n”. El resultado se almacena en la variable “x”.

SENO x = SENO n

Permite obtener el seno del valor almacenado en la variable “n”. El resultado se almacena en la variable “x”.

LONGITUD x = LONGITUD n

Permite obtener la longitud de la cadena almacenada en la variable “n” o la longitud del vector “n”. El resultado se almacena en la variable “x”.

FILA x = FILA nPermite obtener el número de filas de una matriz “n”. El resultado se almacena en la variable “x”.

COLUMNA x = COLUMNA n

Permite obtener el número de columnas de una matriz “n”. El resultado se almacena en la variable “x”.

MAYUSCULAx = MAYUSCULA n

Permite cambiar a mayúscula la cadena almacenada en la variable “n”. El resultado se almacena en la variable “x”.

MINUSCULA x = MINUSCULA n

Permite cambiar a minúscula la cadena almacenada en la variable “n”. El resultado se almacena en la variable “x”.



RESTO x = z RESTO n

Permite obtener el resto de la división entre las variables “z” y “n”. El resultado se almacena en la variable “x”.

DIVIDIR x = z DIVIDIR n

Permite obtener la parte entera de la división de las variables “z” y “n”. El resultado se almacena en la variable “x”.

RAIZ x = z RAIZ nPermite obtener la raíz “n” del número “z”. El resultado se almacena en la variable “x”.

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

MAXIMO x = z MAXIMO n

Permite obtener el número mayor entre el valor almacenado en la variable “n” y la variable “z”. El resultado se almacena en la variable “x”.

MAYOR x = MAYOR n1, n2, n3…

Permite obtener el número mayor entre los valores almacenados en las variables “n1”, “n2”, “n3”…El resultado se almacena en la variable “x”.

MENOR x = MENOR n1, n2, n3…

Permite obtener el número menor entre los valores almacenados en las variables “n1”, “n2”, “n3”…El resultado se almacena en la variable “x”.

MINIMO x = z MINIMO n

Permite obtener el número menor entre el valor almacenado en la variable “n” y la variable “z”. El resultado se almacena en la variable “x”.

PROMEDIO x = PROMEDIO n1, n2, n3…

Permite obtener el promedio entre los valores almacenados en las variables “n1”, “n2”, “n3”…El resultado se almacena en la variable “x”


CARACTER x = z CARACTER n

Permite obtener el carácter ubicado en la posición “n” de la cadena “z”. El resultado se almacena en la variable “x”.

ALEATORIO x = z ALEATORIO n

Permite obtener un número cualquiera (aleatorio) entre los valores de “z” y “n”. El resultado se almacena en la variable “x”.

REDONDEAR x = z REDONDEAR n

Permite redondear un número “z” al número de decimales especificado en “n” El resultado se almacena en la variable “x”.


SUBCADENA x = z SUBCADENA n1, n2

Permite obtener una subcadena comprendida entre las posiciones especificadas por “n1” y “n2” de la cadena “z”. El resultado se almacena en la variable “x”.

ELIMINAESPACIOx = z ELIMINAESPACIO n1, n2

Permite eliminar los espacios existentes en una cadena entre las posiciones especificadas por “n1” y “n2”. El resultado se almacena en la variable “x”.


CREARCREAR vector[n]

CREAR matriz[n1][n2]

Utilizada para crear arreglos previamente declarados. Un arreglo permite almacenar más de un dato del mismo tipo.

CLASE CLASE PrgEjemplo Utilizada para especificar una clase.

CREAR CREAR objetoPermite crear un objeto de una determinada clase.

EJECUTAR EJECUTAR algoritmo Permite ejecutar otro algoritmo.

PARAMETRO PARAMETRO listaVariablesPermite especificar si un algoritmo recibe datos o valores.

RETORNAR RETORNAR variablePermite especificar si un algoritmo retorna una respuesta.


B. Diagrama de fl ujo

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

DIAGRAMA DE FLUJO

FLUJOPorque muestra la secuencia de lo que se

ene que realizar.

DIAGRAMAPor el hecho de ser dibujo que no

requiere estar a escala.

Elementos o símbolos básicos:

PROCESOU lizado para asignar valores a variables y resultados de operaciones matemá cas.

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

INICIO / FINEste símbolo permite marcar el inicio y el fi nal del algoritmo.

CONECTOREste símbolo permite que no se crucen los fl ujos (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.


Algoritmo NombreClase – nombreMetodo()

INICIO

Instrucciones…

Este es el cuerpo del algoritmo expresado en diagrama de fl ujo. Las instrucciones se

colocan entre INICIO… FIN.

FIN

Estructura básica de un diagrama de fl ujo:

C. Diagrama de ac vidades

Son parte del lenguaje unifi cado de modelado (UML) y se u lizan comúnmente en dos formas:

1.- Es el modelado de fl ujos 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 fl ujo 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 fl echas de transición, las cuales representan el fl ujo 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 especifi ca 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 especifi carse en lenguaje natural o u lizando pseudocódigo.

Las fl echas en el Diagrama de Ac vidad se llaman fl echas de transición. Estas fl echas 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 fl ujo 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 fi nal, es decir, el fi nal del fl ujo 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.


Elementos o símbolos básicos:

ESTADO INICIALEste símbolo permite marcar el inicio del algoritmo.

ESTADO DE ACCIÓN O ACTIVIDADRepresenta la realización de una o varias tareas.

DECISIÓNPermite representar caminos alterna vos en base a una condición.

ESTADO FINALEste símbolo permite marcar el fi nal del algoritmo.

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

BARRAS DE SINCRONIZACIÓNLíneas que permiten mostrar ac vidades concurrentes.

NOTASComentarios que permiten describir el propósito de los diagramas.

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 signifi que 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 prefi eren 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.


Etapa 03

DiseñoSolución

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”.

Se desarrollará el siguiente paso:

Desarrollo de algoritmos. En este paso, se desarrollará el algoritmo para el método especifi cado 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 codifi cació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.



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 signifi ca 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”.

Se desarrollará solo el primer paso.

Codifi car el proyecto. En este paso, se desarrollará la codifi cación del proyecto; es decir, u lizando el lenguaje de programación Java y/o C++, se traducirá lo especifi cado en el modelamiento y en los algoritmos en sentencias que la computadora pueda comprender y ejecutar.

Etapa 04

DesarrolloSolución


Método de las 6`D Modelamiento - Algoritmo - Programación. › media › eb_0104 › samples ›...

Documents

Transcript of Método de las 6`D Modelamiento - Algoritmo - Programación. › media › eb_0104 › samples ›...