P. 1
MODELO DE LAS 6D´S

MODELO DE LAS 6D´S

3.0

|Views: 8,574|Likes:

More info:

Published by: Roger E. Canche Pool on Oct 04, 2011
Copyright:Attribution Non-commercial

Availability:

Read on Scribd mobile: iPhone, iPad and Android.
download as PDF, TXT or read online from Scribd
See more
See less

09/24/2014

pdf

text

original

MÉTODO DE LAS 6’D
UML – Pseudocódigo – Java

(Enfoque algorítmico)

MÉTODO DE LAS 6’D
UML – Pseudocódigo - Java

(Enfoque algorítmico)

Ing. Juan José Flores Cueto.

- 2005 -

UNIVERSIDAD DE SAN MARTIN DE PORRES
Facultad de Ingeniería y Arquitectura

A mi madre adorada,
por siempre.

“Lo que escucho, lo olvido.
Lo que veo, lo recuerdo.
Pero lo que hago, lo entiendo”

Confucio.

“Fallar no te convierte en un fracaso,
aceptar el fracaso y no querer volver
a intentarlo, si lo hace”

Richard Exley.

AGRADECIMIENTOS

Es importante destacar la participación de mis alumnos del curso de Algoritmo y Estructura de
Datos, integrantes del equipo de trabajo, formado para el desarrollo del presente libro. Este
libro no se hubiera terminado en tan corto tiempo, con la calidad y cantidad de problemas
desarrollados, sino hubiera sido por su valiosa colaboración y aporte. A todos ellos, mi
agradecimiento y mis sinceras felicitaciones por el trabajo realizado.

Equipo de trabajo:

• Isabel Rojas Vidal.
• Jorge Condezo Guerra.
• Roberto Pérez Huamaní.
• Ricky Vilcachagua Mosquera.
• Shugeily Pérez Campos.
• Boris Ortega Lescano.

Un agradecimiento especial a Isabel y a Jorge por participar desde el inicio hasta el
final del proyecto, por todo el tiempo y esfuerzo dedicado. Gracias Jorge por verificar
todos los programas desarrollados en Java.

Deseo también hacer extensivo mi agradecimiento a todos los docentes que contribuyeron en
el desarrollo del presente libro, a mi esposa Carmen por revisarlo y corregirlo, y a mi amigo
Omar por diseñar la carátula.

Finalmente, mi sincero agradecimiento a las autoridades de la Facultad de Ingeniería y
Arquitectura (FIA) de la Universidad de San Martín de Porres (USMP), en especial al Ing.
Raúl Bao García, Decano de la FIA, por todo el apoyo brindado durante el desarrollo del
presente libro.

ÍNDICE

PRESENTACIÓN.
INDICE.
PROLOGO.
PREFACIO.

CAPÍTULO I: Método de las 6’D. Un enfoque algorítmico.

Introducción ........................................................................................................ 25
Método de las 6’D ............................................................................................... 27
Etapas y pasos ...................................................................................... 28
Resumen del método ............................................................................. 35
Resultado de las etapas del método ......................................................36
Marco de trabajo ................................................................................................. 37
Modelamiento ..................................................................................................... 39
Algoritmo ............................................................................................................. 45
Programación ..................................................................................................... 54

CAPÍTULO II: Estructuras fundamentales para la solución de problemas.

Introducción ........................................................................................................ 61
Estructuras de datos.

Variables ................................................................................................ 63
Tipos de datos ....................................................................................... 66
Conversión de datos ……………………………………………………….. 71

Estructuras lógicas.

Estructuras lógicas de secuencia.
Estructuras para la salida de información ESCRIBIR .................. 75
Estructuras para la entrada de datos LEER ................................. 76
Estructuras para operaciones aritméticas y de cálculo ................78
Estructuras lógicas de decisión.
Estructuras lógicas de decisión simple SI ....................................80
Estructuras lógicas de decisión doble SI / SINO .......................... 82
Estructuras lógicas de decisión simple CUANDO ........................ 84
Estructuras lógicas de repetición.
Estructuras lógica de repetición DESDE ...................................... 87
Estructuras lógica de repetición MIENTRAS ................................ 90
Estructuras lógica de repetición HACER ...................................... 93
Instrucciones de bifurcación .................................................................. 97
Mapa de estructuras lógicas detallado .................................................. 98
Método de las 6’D. Etapas y pasos ....................................................... 99
Problemas resueltos en general del 01 al 27 ........................................ 101
Manejo de excepciones ……………………………………………………………… 195
Problemas resueltos del 28 al 31 ……………………………………….....198

Desarrollo de capacidades lógicas ..................................................................... 207
Problemas resueltos sobre figuras del 32 al 60 ..................................... 209

CAPÍTULO III: Clases básicas incorporadas en el lenguaje Java.

Introducción ........................................................................................................ 259
El paquete del lenguaje Java: java.lang ............................................................. 263
Envoltorios de tipos de datos primitivos: wrappers.
Introducción ........................................................................................... 267
Métodos .................................................................................................269
Problemas resueltos del 61 al 64 ...........................................................278
Funciones matemáticas: Clase Math.
Introducción ........................................................................................... 281
Métodos .................................................................................................282
Problemas resueltos del 65 al 99 ...........................................................287
Manejo de cadenas: Clase String.
Introducción ........................................................................................... 339
Métodos .................................................................................................340
Problemas resueltos del 100 al 130 .......................................................345

Otras clases en Java.

Problema resuelto 131 ........................................................................... 397

CAPÍTULO IV: Estructuras de datos arreglos.

Introducción ........................................................................................................ 401
Estructuras de datos: Arreglos.

Definición ...............................................................................................403
Tipos ......................................................................................................403
Ventajas y desventajas .......................................................................... 404
Representación gráfica .......................................................................... 406
Declaración, creación e inicialización de arreglos …..............................408
Ingreso de datos a un arreglo ................................................................ 412
Manejo de datos de un arreglo ..............................................................414
Desarrollo de soluciones básicas utilizando arreglos.
Introducción ........................................................................................... 416
Formalización de la solución utilizando el método de las 6’D ................ 425
Problemas resueltos del 132 al 145 .......................................................425
Desarrollo de soluciones utilizando múltiples arreglos.
Arreglos paralelos .................................................................................. 493
Problemas resueltos del 146 al 150 .......................................................495

CAPÍTULO V: Introducción al Desarrollo de Soluciones Orientadas a Objetos.

Introducción ........................................................................................................ 527
Conceptos básicos.

Clase ……...............................................................................................532
Objeto …….............................................................................................534
Atributo …………………......................................................................... 535
Método ………………….......................................................................... 542
Métodos que no devuelven valor y no reciben parámetros ...... 544
Métodos que devuelven valor y no reciben parámetros …........ 547
Métodos que no devuelven valor y reciben parámetros …….... 550
Método constructor ………………………………………………... 554
Ocultar atributos de instancia ……………………………………………… 556
Ingreso de datos a través del teclado ……………………………………..559
Método de las 6’D. Etapas y pasos …………...................................................... 561
Problema resuelto 151 ........................................................................... 563
Otros conceptos ……………………………………………………………………… 569

APÉNDICE.

Problemas propuestos ……………………………………………………... 573
Clase Lectura ......................................................................................... 603
Otras clases Java.

DecimalFormat, Calendar, GregorianCalendar, SimpleDateFormat ......................605

BIBLIOGRAFÍA ................................................................................................... 625

PRÓLOGO

Quiero pensar que al aceptar el grato pedido de Juan José Flores Cueto para prologar su
nuevo libro estoy compartiendo o participando de alguna manera en el excelente trabajo que
ha realizado para poner al alcance de estudiantes e informáticos un método para la solución
de problemas utilizando una computadora.

Al reflexionar sobre la tarea que representa escribir un prólogo para este libro, he reparado en
lo difícil que resulta agregar valor al ya presentado por su contenido, pues el texto que mi
joven amigo pone hoy a disposición de nuestros alumnos y también de profesionales de la
especialidad de computación y sistemas, es resultado de la conjunción de varios factores: su
experiencia académica, su desempeño profesional y la constante necesidad de estar
actualizado. Escasamente un año atrás la Facultad de Ingeniería y Arquitectura de la USMP
publicó el primer libro de J. J. Flores Cueto: Método para la solución de Problemas
utilizando la Programación Orientada a Objetos
y, una de las muchas razones del éxito
obtenido por esa obra es que desarrolla una metodología para la solución de la gran cantidad
de ejercicios, problemas y aplicaciones que contiene. Este novedoso método está
conformado por seis etapas y cada una de ellas tiene una denominación que comienza con la
letra D, lo que hace que estos seis pasos se puedan recordar fácilmente. Se tuvo en cuenta
primordialmente al usuario y por ello, acertadamente, el método es llamado ahora método de
las 6 D’s; pero es importante comprender que su uso puede extenderse a otros temas y a
problemas con soluciones más complicadas y que para eso se tiene que redefinir algunos de
los pasos de las etapas especificadas en el método. Comprobamos así, que la ópera prima
de Juan José contenía, pues, ya el embrión de la segunda y de aquí, entonces, como
consecuencia, el título del libro que hoy motiva estas líneas: Método de las 6’D: UML –
Pseudocódigo – Java. (Un enfoque algorítmico)
.

¿Por qué la prisa en publicar esta segunda parte? Sabemos que lo más característico de la
informática es su permanente dinámica, reflejada en la aparición de nuevos paradigmas que
deben aplicarse rápidamente, pero cuya difusión en los textos no tiene la misma celeridad. El
rápido avance de la ciencia y de la tecnología, que para muchos es agobiante, resulta
estimulante para un espíritu como el de este prolífico docente de la USMP. El panorama de la
ingeniería de computación y sistemas evoluciona y cambia mientras trabajamos en ella; al
momento de aparecer su primer libro, nuestro autor sabía ya cuáles eran las nuevas
tendencias que se perfilaban, acumulaba información y escribía sobre ellas, profundizando en
el método de las 6 D’s para presentarnos en tan corto plazo una nueva obra.

El mercado exige que los profesionales de Computación y Sistemas conozcan la últimas
técnicas de programación e ingeniería de software y este libro responde a esas demandas
introduciendo al estudiante en los conceptos de programación estructurada y en el dominio de
la programación orientada a objetos, poniendo énfasis en la solución de problemas y
empleando a fondo las capacidades lógicas para el desarrollo de soluciones utilizando una
computadora. A mi juicio, las características más importantes del texto se reflejan en su fácil
lectura y en su orientación al estudiante; pero mejor aun: en el hecho de haber sido probado

con los alumnos, comprobando su progreso y teniendo en cuenta la definición del problema,
una buena documentación y la planificación de soluciones por algoritmos.

Por lo arriba expresado y, por la amistad que me une a Juan José, es para mí sumamente
gratificante escribir estas apreciaciones sobre su segundo libro y le auguro nuevos aportes
como ingeniero y como docente de la USMP.

Ing. José Antonio Chang Escobedo.
RECTOR USMP.

PREFACIO

Actualmente, existe una tendencia creciente en el uso de herramientas de desarrollo de
software y lenguajes de programación orientados a objetos. También existen una serie de
métodos que permiten definir los pasos que se tienen que desarrollar para solucionar
problemas basados en una computadora. Estos pasos generalmente se desarrollan desde el
planteamiento del problema, análisis del problema, diseño de la solución, hasta la codificación
y prueba de la misma utilizando herramientas y lenguajes de programación.

En este libro se utiliza y se profundiza en el Método de las 6’D, a través del cual se definen
los pasos que se tienen que desarrollar para la solución de un problema utilizando una
computadora, agrupados en seis etapas (Descripción del problema, Definición de la solución,
Diseño de la solución, Desarrollo de la solución, Depuración y pruebas, y Documentación).
Todos los nombres de las etapas del Método de las 6’D comienzan con la letra D (de ahí el
nombre de método).

Los conceptos y temas fundamentales, necesarios para el desarrollo de soluciones utilizando
el Método de las 6’D y el desarrollo de sus capacidades lógicas, son tratados durante el
desarrollo de los cinco capítulos que forman parte del presente libro.

Capítulo I:

Se desarrolla la parte teórico formal del método de las 6’D. Se describen
sus etapas, así como los pasos y los resultados que se deben esperar de
cada una de ellas. Es importante mencionar que, dependiendo de la
forma de solucionar los problemas, se van agregando, eliminando o
redefiniendo los pasos de algunas de las etapas del método. El método
de las 6’D es interactivo e incremental y se puede utilizar la Ingeniería
Reversa para actualizar los modelos a partir del código creado.

En este capítulo, también se tratan los conceptos fundamentales sobre
modelado y el lenguaje unificado de modelado UML, sobre Algoritmos y
las herramientas de diseño conocidas como Diagrama de Flujo y
Pseudocódigo, y sobre la programación utilizando el lenguaje de
programación orientado a objetos Java.

Capítulo II:

Se desarrolla la estructura de datos más simple: la variable, y se
complementa con el estudio de los tipos básicos de datos, la conversión
de datos y la forma cómo son utilizados por las herramientas tratadas en
el capítulo anterior.

En este capítulo, también se tratan las estructuras lógicas de secuencia,
las estructuras lógicas de decisión, las estructuras lógicas de repetición,
las instrucciones de bifurcación y el manejo de excepciones.

Las estructuras de datos, las estructuras lógicas y las instrucciones de
bifurcación son conceptos propios de la programación estructurada y son
utilizadas por la programación orientada a objetos para la codificación de
los métodos que forman parte de las clases. El manejo de excepciones
es un concepto propio de la programación orientada a objetos y ofrece
una forma de codificar programas con una mayor claridad y sencillez,
separando explícitamente el código que maneja los errores del código
básico de la aplicación.

Se presentan 31 problemas desarrollados utilizando el método de las
6’D, problemas que se van complicando conforme se tratan y explican
los conceptos fundamentales.

También se presentan 30 problemas desarrollados sobre diferentes tipos
de figuras geométricas, con la finalidad de mejorar el desarrollo de sus
capacidades lógicas. Es importante que se analicen cada una de las
soluciones, se intenten mejorarlas y se desarrollen cada uno de los
problemas propuestos incluyendo las variaciones planteadas.

Capítulo III:

Se desarrollan los conceptos fundamentales sobre las clases básicas
incorporadas en el paquete java.lang del lenguaje de programación Java.
Se tratan los conceptos fundamentales sobre el paquete del lenguaje, el
paquete java.lang, las clases wrappers (envoltorios), la clase Math y la
clase String.

Las clases Wrappers, son un complemento de los tipos de datos
primitivos y proporcionan métodos para realizar diferentes tareas con los
tipos de datos primitivos, tales como la conversión con cadenas de
caracteres, comprobación, traslación, entre otras. Se presentan 5
problemas codificados en Java para mejorar la comprensión del tema.

La clase Math, proporciona métodos y atributos para implementar
diversas funciones matemáticas. La clase Math contiene métodos de
cálculo básico como exponencial, logaritmo, raíz cuadrada y funciones
trigonométricas. Se presentan 35 problemas codificados en Java para
mejorar la comprensión del tema.

La clase String, permite declarar y manipular variables de tipo texto o
cadena (en realidad no se declaran variables de tipo texto o cadena, sino
que se crean objetos de la clase String). La clase String contiene
métodos que permiten examinar los caracteres de una cadena para
compararlos, ubicarlos, extraerlos como subcadenas, crear copias de

una cadena convirtiendo todos sus caracteres a letra mayúscula o
minúscula, entre otras. Se presentan 30 problemas codificados en Java
para mejorar la comprensión del tema.

También se hace una referencia a otras clases en Java que el lector
puede explorar. En el apéndice se incluyen otras clases Java, tales como
las clases DecimalFomat, Calendar, GregorianCalendar y
SimpleDateFormat.

Capítulo IV:

Se desarrolla la estructura de datos conocida como arreglos (arrays), su
definición, tipos, representación gráfica, declaración, creación y su
inicialización.

En base al marco teórico se desarrollan soluciones para el ingreso,
visualización y cálculo de datos contenido en los arreglos, formalizando
el método de las 6’D para el adecuado manejo de los mismos. Se
presentan 14 problemas desarrollados, utilizando el método de las 6’D
para mejorar la comprensión del tema.

Finalmente, se presentan los conceptos fundamentales sobre el manejo
de arreglos múltiples (arreglos en paralelos) y se desarrollan 5
problemas utilizando el método de las 6’D.

Capítulo V:

Se desarrolla una introducción al desarrollo de soluciones orientadas a
objetos. Se tratan los conceptos básicos fundamentales sobre las clases,
objetos, atributos, métodos y ocultamiento de atributos de instancia.

Conforme se presenta cada uno de los conceptos mencionados, se va
modificando un proyecto desarrollado en Java para que se pueda
analizar como se utiliza el concepto tratado en un lenguaje de
programación orientado a objetos.

Al final de este capítulo, se formaliza el método de las 6’D, redefiniendo
algunos de sus pasos para poder ajustar el método a este tipo de
soluciones.

Es importante comentar que el presente capítulo, fue el primero en ser
desarrollado. A pesar de ello, se consideró no incluirlo en el presente
texto, pero faltando unos días para la entrega oficial de todo el material
que conformaba el presente libro fue incluido. Finalmente, considero una
buena decisión que se incluyera el presente capítulo. Estoy seguro que
el lector estará de acuerdo conmigo.

Como se puede apreciar, se profundiza en el Método de las 6’D. Es importante comprender
que se puede extender el uso del método a otros temas y a problemas con soluciones mucho
más complicadas. Sólo se tendrá que redefinir algunos de los pasos de las etapas
especificadas en el método. Por otro lado, también se tratan conceptos de la programación
estructurada y fundamentos de programación orientada a objetos, los cuales permiten sentar
las bases modernas para la programación, necesarias para el desarrollo de soluciones
utilizando una computadora.

Los temas desarrollados a través de los 5 capítulos que forman parte de esta obra, pueden
ser utilizados de diferente manera de acuerdo a la experiencia de cada persona. Es
importante indicar que el lector tendrá un mejor entendimiento del método empleado en la
solución de los problemas y de todos los conceptos tratados, conforme avance con el
entendimiento de los problemas resueltos y el desarrollo de los problemas propuestos.

Ing. Juan José Flores Cueto.

MÉTODO DE LAS 6’D
Un Enfoque Algorítmico

Temas:

Introducción.

Método de las 6’D:

• Etapas y pasos.
• Resumen del método.
• Resultado de las etapas del método.

Marco de trabajo.

Modelamiento.

Algoritmo.

Programación.

Capítulo

1

MÉTODO DE LAS 6’D – Un Enfoque Algorítmico.

Pag. 25

CAPÍTULO I

MÉTODO DE LAS 6’D
Un Enfoque Algorítmico

You're Reading a Free Preview

Download
scribd
/*********** DO NOT ALTER ANYTHING BELOW THIS LINE ! ************/ var s_code=s.t();if(s_code)document.write(s_code)//-->