Descarga la aplicación para disfrutar aún más
Lea materiales sin conexión, sin usar Internet. Además de muchas otras características!
metodo_de_las_6_d_uml_pseudocodigo_java_enfoque_algoritmico_
Alex Bustamante
Compartir
Vista previa del material en texto
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 -
U N I V E RS I D AD D E S AN M AR T I N DE P O R RE S
F a c u l ta d d e I ng e n i e r í a y Ar q u i t e c t ur a
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
redefiniendolos 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
INTRODUCCIÓN
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.
Algunos problemas, por su naturaleza, pueden ser resueltos utilizando una
computadora. Estos problemas generalmente son de tipo estructurado, es decir,
tienen una solución determinada y pueden ser desde muy sencillos hasta muy
complejos.
Para resolver problemas estructurados utilizando la computadora es importante
utilizar un método. Este método debe ser fácil de comprender y nos debe guiar
paso a paso hasta la solución del problema.
El método propuesto y utilizado en el presente texto es el Método de las 6’D,
que está compuesto de seis etapas, cada una de las cuales consta de una serie
de pasos, los cuales se van modificando (ajustando) dependiendodel grado de
complejidad del problema y las herramientas que se utilicen para su solución.
Con la finalidad de recordar el método, se ha definido que el nombre de cada una
de las etapas del método comience con la misma letra, la letra “D”. Es decir, el
método tiene seis etapas y el nombre de cada una de las etapas comienza con la
letra “D”, de modo que este se pueda recordar como el Método de las 6’D.
Ing. Juan José Flores Cueto.
Pag. 26
MÉTODO DE LAS 6’D – Un Enfoque Algorítmico.
Pag. 27
MÉTODO DE LAS 6’D
En la siguiente figura se muestra el Método de las 6’D con sus respectivas
etapas:
Descripción
Problema
Definición
Solución
Document.
Ingeniería Reversa
Etapa 01
Etapa 02
Etapa 06
Diseño
Solución
Desarrollo
Solución
Depuración
Pruebas
n veces
Etapa 03
Etapa 04
Etapa 05
Ing. Juan José Flores Cueto.
Pag. 28
ETAPAS Y PASOS
Descripción de la Etapa 01 – “Descripción del Problema”:
El resultado obtenido en esta etapa es un enunciado claro del problema que se desea
solucionar.
Descripción
del Problema
METODO 6’D.
Etapa 01 En esta etapa, en primer lugar, es necesario identificar
cual es el problema que se desea resolver. Esto que
parece algo sumamente sencillo, muchas veces resulta
una tarea agotadora ya que generalmente existen
muchas opiniones de cual es el problema central.
Identificarlo es una de las tareas más importante que
los analistas deben afrontar.
Identificado el problema es necesario poder
comprenderlo en su totalidad, es decir, comprender qué
es exactamente lo que se desea que se resuelva.
Finalmente se deberá escribir un enunciado claro,
concreto y conciso del problema a resolver.
ENUNCIADO
PASOS:
Identificación del problema.
Descripción general del problema.
Enunciado claro y preciso del problema.
MÉTODO DE LAS 6’D – Un Enfoque Algorítmico.
Pag. 29
Descripción de la Etapa 02 – “Definición de la Solución”:
El resultado obtenido en esta etapa son las especificaciones de lo que se debe hacer para
solucionar el problema.
PASOS:
Definición de
la Solución
Etapa 02 En esta etapa, es necesario estudiar a fondo el
problema para poder solucionarlo, saber exactamente
en qué consiste y poder descomponerlo en cada una
de sus partes para facilitar su comprensión y posterior
solución. Esta es una regla que siempre deberá ser
aplicada se utilice 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 alternativas
que permitan solucionar el problema, para finalmente,
seleccionar la alternativa mas adecuada.
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
METODO 6’D.
Ing. Juan José Flores Cueto.
Pag. 30
Descripción de la Etapa 03 – “Diseño de la Solución”:
El resultado obtenido en esta etapa son los diagramas y los algoritmos que especifican
cómo se debe hacer para solucionar el problema.
Diseño de la
Solución
METODO 6’D.
Etapa 03
Definir un nombre para el proyecto.
Definición de diagramas, relaciones y clases.
Desarrollo de Algoritmos.
PASOS:
DIAGRAMAS Y
ALGORITMOS
Definida la solución, se procede a diseñar la lógica
modelando y desarrollando algoritmos.
Para el modelado de la solución del problema se utiliza
el Lenguaje Unificado de Modelado (Unified Modeling
Language, UML), el cual es una herramienta usada
para describir clases, objetos y sus relaciones.
Para el desarrollo de algoritmos se utiliza
Pseudocódigos o Diagramas de Flujo (DF), los
cuales son herramientas utilizadas para diseñar los
algoritmos de los diferentes métodos de una clase.
Finalizado el desarrollo de los algoritmos es necesario
verificar si se ha incluido soluciones para todas las
formas en que se presente el problema. A este tipo de
prueba se le denomina “Prueba de escritorio”.
MÉTODO DE LAS 6’D – Un Enfoque Algorítmico.
Pag. 31
Descripción de la Etapa 04 – “Desarrollo de la Solución”:
El resultado obtenido en esta etapa son los programas y/o clases, codificados en un
lenguaje de programación, que permiten solucionar el problema.
Desarrollo de
la Solución
METODO 6’D.
Etapa 04 Una vez previstas todas las posibilidades y alternativas
que puedan presentarse y que pasen sin
inconvenientes por la clase y los algoritmos, se podrá
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 constituyen lo que la computadora podrá
ejecutar.
PASOS:
PROGRAMAS
Codificar el proyecto.
Desarrollar comentarios internos en los
programas de computadora.
Desarrollar copias de seguridad de los
programas de computadora.
Ing. Juan José Flores Cueto.
Pag. 32
Descripción de la Etapa 05 – “Depuración y Pruebas”:
El resultado obtenido en esta etapa son las pruebas que registran el adecuado
funcionamiento de la solución del problema.
Depuración
y Pruebas
METODO 6’D.
Etapa 05
Luego que se codifiquen los programas y/o clases,
deben ser probados mediante la ejecución de los
mismos (esto es conocido como corrida del programa).
Al realizarse ésta, pueden surgir diferentes tipos de
errores, siendo los errores 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
continuar con la corrección y pruebas hasta conseguir
el resultado deseado.
Realizar la depuración y verificar la correcta
escritura de los programas.
Realizar pruebas de sintaxis.
Realizar pruebas de lógica.
PASOS:
PRUEBAS
MÉTODO DE LAS 6’D – Un Enfoque Algorítmico.
Pag. 33
Descripción de la Etapa 06 – “Documentación”:
El resultado obtenido en esta etapa son los manuales que permiten un adecuado manejo de
la solución desarrollada.
Documentación
METODO 6’D.
Etapa 06 En esta etapa se recopila toda la documentación
generada en las etapas anteriores, la cual va a servir
como base para la elaboración del manual técnico.
Dedicarle tiempo a esta etapa nos ayudará a
desarrollar buenos hábitos, los cuales serán necesarios
cuando se desarrolle software 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.
PASOS:
ManualesManualesManualesManuales
Recopilar el material generado en cada una
de las etapas anteriores.
Generar el manual del programa.
Generar el manual del usuario.
Ing. Juan José Flores Cueto.
Pag. 34
Adicionalmente es posible realizar “Ingeniería Reversa” entre las Etapas 03, 04 y 05:
METODO 6’D.
La ingeniería reversa nos permite crear oactualizar el modelo preliminar realizado en la
ETAPA 03 “Diseño de la solución” a partir 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 codificar algunas partes
(hasta su correcto funcionamiento) que no
estén especificadas en la Etapa 03 “Diseño de
la Solución”. A partir de esta solución se
actualizan los diagramas de la Etapa 03 y se
continúa con el proceso hasta llegar a la
solución deseada.
• 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.
PASOS:
n veces
Diseño
Solución
Desarrollo
Solución
Depuración
Pruebas
Etapa 03
Etapa 04
Etapa 05
Ingeniería Reversa
DIAGRAMAS
ACTUALIZADOS
M
É
TO
D
O
D
E
LA
S
6
’D
–
U
n
E
nf
oq
ue
A
lg
or
ítm
ic
o.
P
ag
. 3
5
R
ES
U
M
EN
D
EL
M
ÉT
O
D
O
R
es
um
en
d
e
la
s
et
ap
as
y
lo
s
pa
so
s
de
l m
ét
od
o:
Id
en
tif
ic
ac
ió
n
de
l p
ro
bl
em
a.
D
es
cr
ip
ci
ón
ge
ne
ra
l
de
l
pr
ob
le
m
a.
En
un
ci
ad
o
cl
ar
o
y
pr
ec
is
o
de
l p
ro
bl
em
a.
M
ET
O
D
O
6
’D
.
Et
ap
a
01
Et
ap
a
02
Et
ap
a
03
Et
ap
a
04
Et
ap
a
05
D
es
cr
ip
ci
ón
Pr
ob
le
m
a
D
ef
in
ic
ió
n
So
lu
ci
ón
D
oc
um
en
t.
D
is
eñ
o
So
lu
ci
ón
D
es
ar
ro
llo
So
lu
ci
ón
D
ep
ur
ac
ió
n
Pr
ue
ba
s
Et
ap
a
06
D
ef
in
ir
el
re
su
lta
do
de
se
ad
o.
D
et
er
m
in
ar
lo
s
da
to
s
qu
e
se
d
eb
en
in
gr
es
ar
o
ge
ne
ra
r
pa
ra
ob
te
ne
r
el
re
su
lta
do
d
es
ea
do
.
D
et
er
m
in
ar
la
f
or
m
a
en
qu
e
lo
s
da
to
s
se
rá
n
pr
oc
es
ad
os
pa
ra
tra
ns
fo
rm
ar
lo
s
en
in
fo
rm
ac
ió
n.
D
ef
in
ir
un
no
m
br
e
pa
ra
el
p
ro
ye
ct
o.
D
ef
in
ic
ió
n
de
di
ag
ra
m
as
,
re
la
ci
on
es
y
cl
as
es
.
D
es
ar
ro
llo
d
e
Al
go
rit
m
os
.
C
od
ifi
ca
r
el
pr
oy
ec
to
.
D
es
ar
ro
lla
r
co
m
en
ta
rio
s
in
te
rn
os
en
lo
s
pr
og
ra
m
as
de
co
m
pu
ta
do
ra
.
D
es
ar
ro
lla
r
co
pi
as
de
se
gu
rid
ad
d
e
lo
s
pr
og
ra
m
as
de
co
m
pu
ta
do
ra
.
R
ea
liz
ar
la
de
pu
ra
ci
ón
y
ve
rif
ic
ar
la
co
rr
ec
ta
e
sc
rit
ur
a
de
lo
s
pr
og
ra
m
as
.
R
ea
liz
ar
p
ru
eb
as
de
s
in
ta
xi
s.
R
ea
liz
ar
p
ru
eb
as
de
ló
gi
ca
.
R
ec
op
ila
r
el
m
at
er
ia
l
ge
ne
ra
do
en
c
ad
a
un
a
de
la
s
et
ap
as
a
nt
er
io
re
s.
G
en
er
ar
e
l m
an
ua
l
de
l p
ro
gr
am
a.
G
en
er
ar
e
l m
an
ua
l
de
l u
su
ar
io
.
In
g.
J
ua
n
Jo
sé
F
lo
re
s
C
ue
to
.
P
ag
. 3
6
R
ES
U
LT
A
D
O
D
E
LA
S
ET
A
PA
S
D
EL
M
ÉT
O
D
O
R
es
ul
ta
do
d
e
la
s
et
ap
as
d
el
M
ét
od
o:
MM
aa nn
uu aa
ll ee
ss
E
N
U
N
C
IA
D
O
E
SP
E
C
IF
IC
A
C
IO
N
ES
D
IA
G
R
A
M
AS
Y
A
LG
O
R
IT
M
O
S
P
R
O
G
R
A
M
AS
P
R
U
E
BA
S
M
ET
O
D
O
6
’D
.
Et
ap
a
01
Et
ap
a
02
Et
ap
a
03
Et
ap
a
04
Et
ap
a
05
D
es
cr
ip
ci
ón
Pr
ob
le
m
a
D
ef
in
ic
ió
n
So
lu
ci
ón
D
oc
um
en
t.
D
is
eñ
o
So
lu
ci
ón
D
es
ar
ro
llo
So
lu
ci
ón
D
ep
ur
ac
ió
n
Pr
ue
ba
s
Et
ap
a
06
MÉTODO DE LAS 6’D – Un Enfoque Algorítmico.
Pag. 37
MARCO DE TRABAJO
En el presente texto se solucionarán problemas sencillos utilizando el
Método de las 6’D. La solución de los problemas comenzará con el
enunciado del problema y luego se 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 desarrolla 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 respectivos.
Definición
Solución
Etapa 02
Diseño
Solución
Desarrollo
Solución
Etapa 03
Etapa 04
ENUNCIADO
Etapa 01
MARCO DE TRABAJO
Descripción
Problema
Ing. Juan José Flores Cueto.
Pag. 38
Es importante precisar que en la primera parte del capítulo II, en el capítulo IV y en el
capítulo V del presente texto, se solucionan los problemas utilizando el marco de
trabajo especificado, mientras que en la segunda parte del capítulo II y el capítulo III,
solo se desarrolla la etapa 04 (“Desarrollo de la solución”), con la finalidad de resolver
una mayor cantidad de problemas y profundizar en la codificación utilizando el
lenguaje de programación Java.
Para poder solucionar problemas sencillos utilizando 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. Este tipo de soluciones
son el objetivo del presente texto.
También es posible plantear soluciones más complejas utilizando el Método
de las 6’D. Para ello se tendría que dominar otros conceptos, tales como,
Objetos, Métodos, Encapsulamiento, Herencia, Polimorfismo, Interfaces
Gráficas, Conexión a Base de Datos, 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 (modificar). Esto significa, que dependiendo de la complejidad del
problema y de su solución, se puede plantear nuevos pasos y eliminar pasos
ya existentes en las diferentes etapas del método.
MÉTODO DE LAS 6’D – Un Enfoque Algorítmico.
Pag. 39
MODELAMIENTO
El modelamiento se refiere a la forma como se representa la solución de un
problema del mundo real en términos de un modelo. Un modelo es una
representación gráfica o simbólica de algún aspecto del mundo real, que está
bajo observación o estudio. Para representar un modelo se utilizará el UML
(Unified Modeling Language).
El Lenguaje Unificado de Modelado (UML) es un lenguaje gráfico que nos
permite:
• Visualizar un 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 software (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 Software Orientado a
Objetos. Para nuestro propósito, se detallarán algunos conceptos básicos que
serán utilizados en las soluciones planteadas en el presente texto.
Paquete.- Los paquetes nos permiten organizar las clases de un modelo. Un
paquete contiene clases que tienen funciones similares. En UML, un paquete
se representa de la siguiente forma:
Clase.- Una clase, es simplemente, un modelo que se utiliza para describir
uno o más objetos del mismo tipo. En su forma más sencilla, una clase es un
conjunto de atributos y métodos. Una clase es una abstracción y no
Nombredel
paquete.
NombrePaquete
Ing. Juan José Flores Cueto.
Pag. 40
representa a ningún objeto en particular. En UML, una clase se representa de
la siguiente forma:
Objeto.- Un objeto es cualquier cosa, real o abstracta, acerca de la cual
almacenamos datos y los métodos que controlan y manipulan dichos datos.
Un objeto se crea o instancia a partir de una clase, En UML, un objeto se
representa de la siguiente forma:
UML incorpora nueve diagramas que permiten representar un modelo desde
diferentes perspectivas, los cuales se muestran a continuación:
NombreClase
(NombrePaquete
al que pertenece)
Atributos
Métodos
Nombre de la clase y
del paquete al cual
pertenece la clase.
Lista de atributos de la
clase.
Lista de métodos de la
clase.
Nombre de la clase a la cual
pertenece el objeto y el nombre
del objeto. Ambos nombres
deben estar separados por dos
puntos.
Diagramas de
Casos de Uso
Diagramas de
Colaboración
Diagramas de
Componentes
Diagramas de
Distribución
Diagramas de
Objeto
Diagramas de
Estado
Diagramas de
Secuencia
Diagramas de
Clase
Paquete
Diagramas de
Actividad
Modelo
NombreClase :
nombreObjeto
MÉTODO DE LAS 6’D – Un Enfoque Algorítmico.
Pag. 41
Para nuestro propósito, se detallará el diagrama de paquetes que será
utilizado en las soluciones planteadas en el presente texto.
Diagrama de paquetes.- Un diagrama de paquetes permite especificar y
visualizar las relaciones de dependencia que existe 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 a 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 a algunas de las clases que
pertenecen a otro paquete y viceversa. En UML, una relación de dependencia
unidireccional entre dos paquetes se gráfica de la siguiente manera:
La dependencia en este caso significa que todas las clases que pertenecen
al paquete “dominioDeLaAplicacion” podrán tener acceso a todas o algunas
de las clases que pertenecen al paquete “biblioteca” (observe el sentido de la
flecha que marca la dependencia unidireccional).
Relación de dependencia
unidireccional.
Ing. Juan José Flores Cueto.
Pag. 42
Diseño
Solución
Etapa 03
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:
Definir un nombre para el proyecto.
La definición del nombre del proyecto, permite agrupar a todos los
elementos que serán parte de la solución del problema utilizando el
método planteado. El nombre del proyecto comenzará con las letras “Proy”
(abreviatura de proyecto), seguido de un nombre que identifique 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 los paquetes utilizando UML. Para nuestros
fines se crearán dos paquetes en las soluciones. Uno de ellos lo se
llamará “dominioDeLaAplicación” y el otro “biblioteca”, y se establecerá
una relación de dependencia unidireccional del primero hacia el segundo.
En el paquete “dominioDeLaAplicacion”, se definirá la clase que permitirá
solucionar el problema planteado utilizando UML. El nombre de la clase
comenzará con las letras “Prg” (abreviatura de programa), seguido de un
nombre que identifique a la clase. Este nombre debe ser seleccionado
adecuadamente. Dicha clase no tendrá ningún atributo definido y solo se
definirá un método (el método principal).
MÉTODO DE LAS 6’D – Un Enfoque Algorítmico.
Pag. 43
En el paquete “biblioteca”, se tendrá clase Lectura1 que facilitará el ingreso
de los datos a la computadora.
1 La clase Lectura se trata en el Capítulo II y se especifica en el Apéndice.
Regla general para especificar los nombres de los paquetes, clases,
atributos y métodos:
El nombre de la clase y el nombre del paquete deben 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.
Los nombres de los atributos se escriben en minúscula. En caso que el nombre
sea compuesto, a partir de la segunda palabra se escribe la primera letra en
mayúscula.
Los nombres de los métodos cumplen las mismas características que los
nombres de atributos a excepción de los métodos constructores.
Ing. Juan José Flores Cueto.
Pag. 44
MÉTODO DE LAS 6’D – Un Enfoque Algorítmico.
Pag. 45
ALGORITMO
Una clase, en su forma más simple, está constituida por atributos y métodos.
Los métodos representan pequeños subprogramas encapsulados dentro de
las clases y contribuyen a definir el comportamiento típico de los objetos.
Para especificar cuáles son los pasos desarrollados en un determinado
método y cuáles son los datos que manejan dichos pasos se desarrollan los
algoritmos.
Un algoritmo constituye 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 tiene dos partes esenciales:
Una lista de pasos que deben ser ejecutados.
Una descripción de los datos que son manipulados por estos
pasos.
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, éste
debe terminar en algún momento.
Un algoritmo debe estar definido. Si se sigue un algoritmo dos
veces, se debe obtener el mismo resultado.
Un algoritmo puede o no tener datos de entrada.
Un algoritmo producirá uno o más datos de salida.
Ing. Juan José Flores Cueto.
Pag. 46
Los datos de entrada y salida deben almacenarse en estructuras
de datos.
El resultado que se obtenga debe satisfacer los requerimientos
de la persona interesada (efectividad).
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 como se está
solucionando un determinado problema.
Se dispone de diversas herramientas para desarrollar los algoritmos para los
métodos de las clases. Entre dichas herramientas se puede mencionar al
pseudocódigo y al diagrama de flujo.
HERRAMIENTAS
PSEUDOCODIGO
Un pseudocódigo permite expresar un algoritmo con palabras en castellano
que son semejantes a las sentencias de un lenguaje de programación.
Pautas básicas:
Todo algoritmo debe tener un nombre, el cual deberá comenzar 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 utilizará el
nombre de la clase y el nombre del método para referirse a un
determinado algoritmo).
Es necesario que se determinenlos datos de entrada y la información de
salida.
Para declarar una variable “x” se deberá determinar qué tipo de dato se
almacenará. Por ejemplo. Si se desea declarar una variable de tipo texto
se realizaría de la siguiente manera: TEXTO x.
Para asignar un valor a una variable “x” se utiliza el signo igual. Por
ejemplo, si se desea asignar 5 a la variable “x” se realizará de la siguiente
manera: x = 5.
MÉTODO DE LAS 6’D – Un Enfoque Algorítmico.
Pag. 47
Para indicar que la computadora lea un valor desde un dispositivo externo
y lo almacene en la variable “z”, se utiliza: LEER z.
Para indicar que la computadora escriba hacia un dispositivo externo:
Para escribir un mensaje (observe que el mensaje está entre
comillas) se utiliza: ESCRIBIR “hola”.
Para escribir el valor de una variable (observe que la variable no
está entre comillas) se utiliza: ESCRIBIR x.
Para escribir el resultado de una expresión (observe que la
expresión no está entre comillas) se utiliza: ESCRIBIR x + 2.
Estructura básica de un pseudocódigo:
Algoritmo NombreClase – nombreMetodo()
ENTRADA:
SALIDA:
INICIO
…
…
…
…
FIN
DIAGRAMA DE FLUJO
Un 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.
Este es el cuerpo del
algoritmo expresado en
pseudocódigo. Las
instrucciones se colocan
entre INICIO... FIN.
En ENTRADA y SALIDA se
especifican las variables
que se usarán en el
desarrollo del algoritmo.
FLUJO
Porque muestra la secuencia de lo
que se tiene que realizar.
DIAGRAMA
Por el hecho de ser un dibujo que
no requiere estar a escala.
Ing. Juan José Flores Cueto.
Pag. 48
Elementos o símbolos básicos:
FLUJOS (LINEAS)
Líneas que permiten unir los diagramas y mostrar la
secuencia lógica a la solución del problema.
CONECTOR
Este símbolo permite que no se crucen los flujos
(líneas) en un diagrama.
PROCESO
Utilizado para asignar valores a variables y resultados
de operaciones matemáticas.
INICIO / FIN
Este símbolo permite marcar el inicio y el final del
algoritmo.
ENTRADA / SALIDA
Utilizado para ingresar datos y visualizar la
información que resulta del procesamiento.
MÉTODO DE LAS 6’D – Un Enfoque Algorítmico.
Pag. 49
REGLAS UTILIZADAS POR LAS HERRAMIENTAS
Con la finalidad de comprender mejor el diseño de los algoritmos,
desarrollados en pseudocódigo y diagrama de flujo, se han clasificado en 6
grupos las reglas definidas.
REGLA FORMATO DESCRIPCIÓN
GRUPO 1
LEER LEER x
Utilizada para el ingreso de datos. El dato
ingresado se almacena en la variable
especificada.
ESCRIBIR
ESCRIBIR “Hola”
ESCRIBIR x
ESCRIBIR 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 la codificación de las
soluciones.
NUMERO NUMERO x
Permite declarar una variable de tipo
numérico.
TEXTO TEXTO mensaje
Permite declarar una variable de tipo
texto o cadena.
CARACTER CARACTER letra
Permite declarar a una variable de tipo
texto o cadena de una sola letra.
LÓGICO LÓGICO aprobado
Permite declarar una variable de tipo
lógico.
VERDADERO aprobado = VERDADERO
Permite asignar el valor VERDADERO a
una variable lógica.
FALSO aprobado = FALSO
Permite asignar el valor FALSO a una
variable lógica.
GRUPO 2
SI
SI (condición)
ENTONCES
instrucciones...
FINSI
Permite especificar una estructura de
decisión simple “SI... FINSI”. Las
estructuras lógicas serán tratadas en el
capítulo II.
Ing. Juan José Flores Cueto.
Pag. 50
REGLA FORMATO DESCRIPCIÓN
SI / SINO
SI (condición)
ENTONCES
instrucciones...
SINO
instrucciones...
FINSI
Permite especificar una estructura de
decisión doble “SI... SINO... FINSI”. Las
estructuras lógicas serán tratadas en el
capítulo II.
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”.
Las estructuras lógicas serán tratadas en
el capítulo II.
DESDE
DESDE i = valorInicial
HASTA valorFinal
instrucción 1
.
.
.
instrucción n
FINDESDE
Permite especificar una estructura de
repetición “DESDE... FINDESDE”. Las
estructuras lógicas serán tratadas en el
capítulo II.
MIENTRAS
MIENTRAS (condición)
instrucción 1
.
.
.
instrucción n
FINMIENTRAS
Permite especificar una estructura de
repetición “MIENTRAS...FINMIENTRAS”.
Las estructuras lógicas serán tratadas en
el capítulo II.
HACER
HACER
instrucción 1
.
.
.
instrucción n
MIENTRAS (condición)
Permite especificar una estructura de
repetición “HACER...FINHACER”. Las
estructuras lógicas serán tratadas en el
capítulo II.
TERMINAR TERMINAR
Permite terminar la ejecución de una
estructura lógica de repetición.
CONTINUAR CONTINUAR
Permite volver a ejecutar una estructura
lógica de repetición sin finalizar todas las
instrucciones que forman parte de la
misma.
MÉTODO DE LAS 6’D – Un Enfoque Algorítmico.
Pag. 51
REGLA FORMATO DESCRIPCIÓN
GRUPO 3
COSENO x = COSENO n
Permite obtener el coseno del valor
almacenado en la variable “n”. El
resultado se almacena en la variable “x”.
Ver capítulo III.
SENO x = SENO n
Permite obtener el seno del valor
almacenado en la variable “n”. El
resultado se almacena en la variable “x”.
Ver capítulo III.
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”.
Ver capítulo III y capítulo IV.
FILA x = FILA n
Permite 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”.
MAYÚSCULA x = MAYÚSCULA n
Permite cambiar a mayúscula la cadena
almacenada en la variable “n”. El
resultado se almacena en la variable “x”.
Ver capítulo III.
MINUSCULA x = MINUSCULA n
Permite cambiar a minúscula la cadena
almacenada en la variable “n”. El
resultado se almacena en la variable “x”.
Ver capítulo III.
GRUPO 4
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 n
Permite obtener la raíz “n” del número
“z”. El resultado se almacena en la
variable “x”.
Ing. Juan José Flores Cueto.
Pag. 52
REGLA FORMATO DESCRIPCIÓN
POTENCIA x = z POTENCIA n
Permite 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”.
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”.
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 “n” y “z”.
El resultado se almacena en la variable
“x”.
GRUPO 5
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”.
ELIMINAESPACIO x = 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”.
GRUPO 6
CREAR
CREAR vector[n]
CREAR matriz[n1][n2]
Utilizada para crear arreglos previamente
declarados. Un arreglo permite
almacenar más de un dato del mismo
tipo. Los arreglos serán tratados en el
capítulo IV.
CREAR CREAR objeto
Permite crear un objeto de una
determinada clase
EJECUTAR EJECUTAR algoritmo
Permite ejecutar otro algoritmo.
MÉTODO DE LAS 6’D – Un Enfoque Algorítmico.
Pag. 53
Diseño
Solución
Etapa 03
REGLA FORMATO DESCRIPCIÓN
PARAMETRO PARAMETRO listaVariables
Permite especificar si un algoritmo recibe
datos o valores.
RETORNAR RETORNAR variable
Permite especificar si un algoritmo
retorna una respuesta.
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 especificado en
la clase, la cual forma parte del paquete “dominioDeLaAplicación”. Para el
desarrollo del algoritmo se utilizará pseudocódigo.
Ing. Juan José Flores Cueto.
Pag. 54
PROGRAMACIÓN
La programación es la traducción del modelamiento y los algoritmos en
sentencias que la computadora puede comprender y ejecutar. En términos
sencillos. Se puede decir, que la programación es la acción de escribir
programas para una computadora, utilizando alguno de los lenguajes de
programación existentes. La acción de escribir programas para una
computadora 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 un lenguaje que los
programadores utilizan para escribir programas 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 particular. Existen
diferentes lenguajes de programación, la mayor parte de los cuales tienen
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 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 Java.
LENGUAJES DE PROGRAMACIÓN
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.
MÉTODO DE LAS 6’D – Un Enfoque Algorítmico.
Pag. 55
Fundamentado en el lenguaje de programación C++, el lenguaje Java se
diseñó para ser pequeño, sencillo y portátil a través de plataformas y
sistemas operativos, tanto a nivel de código fuente como binario, lo que
significa que los programas Java (applets, aplicaciones y servlets), pueden
ejecutarse en cualquier computadora que tenga instalada una máquina virtual
de Java.
A pesar que Java es un lenguaje de programación orientado a objetos,
también puede ser utilizado como un lenguaje estructurado, lo cual se hace
necesario para poder iniciar el estudio de los conceptos fundamentales de
programación.
Estructura básica de un programa desarrollado en Java:
package NombrePaquete;
class NombreClase {
public static void main ( String arg[ ] ) {
}
}
En el lenguaje de programación Java, para definir que una clase forma
parte de un paquete determinado, se utiliza la siguiente palabra reservada:
package
En el lenguaje de programación Java para definir una clase se utiliza la
siguiente palabra reservada:
class
…
sentencias;
…
Este es el cuerpo del
programa en Java. Las
sentencias se colocan
dentro de los corchetes
del método main ( ).
Ing. Juan José Flores Cueto.
Pag. 56
Es importante comprender que una clase está constituida por atributos y
métodos. Todo el código ejecutable reside dentro de los métodos de la
clase. No existe código que no esté contenido dentro de un método (a
excepción de los bloques estáticos).
Existen clases que tienen un método especial conocido como “método
principal”. Todas las clases que tienen especificado un “método principal”,
son clases que pueden ejecutarse.
En el lenguaje de programación Java, para especificar que una clase tiene
un “método principal”, se utiliza las siguientes sentencias:
public static void main (String arg[])
Por lo tanto, en el lenguaje de programación Java, el método principal es
conocido como método main ( ).
Palabras reservadas en Java:
Una palabra reservada o palabra clave, es aquella que tiene un significado
especial para un lenguaje de programación. Todos los lenguajes tienen
palabras claves. En el caso de Java tenemos las siguientes:
Palabras reservadas en Java
abstract boolean catch
byte case do
char class extends
continue default float
double else if
final finally instanceof
for import long
implements interface null
int new protected
native private short
package return super
public strictfp this
static synchronized transient
switch throws volatile
throw void
try widefp
while break
MÉTODO DE LAS 6’D – Un Enfoque Algorítmico.
Pag. 57
En la actualidad, la Programación Estructurada (PE) y la Programación
Orientada a Objetos (POO) son las formas de programación utilizadas por la
mayoría de los programadores, siendo la POO la más reciente y la que
promete solucionar muchos de los problemas de la PE, incorporando nuevas
características y nuevos conceptos. Una característica importante de la POO
es que utiliza los mejores conceptos 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:
Codificar el proyecto.
En este paso, se desarrollará la codificación del proyecto. Es decir,
utilizando el lenguaje de programación Java, se traducirá lo especificado
en el modelamiento y en los algoritmos, en sentencias que la computadora
pueda comprender y ejecutar.
Desarrollo
Solución
Etapa 04
Ing. Juan José Flores Cueto.
Pag. 58
Estructuras Fundamentales para la
Solución de Problemas
Temas:
Introducción.
Estructuras de Datos: Variables
• Tipos de datos.
• Conversión de datos.
Estructuras Lógicas:
• Estructuras lógicas de secuencia.
• Estructuras lógicas de decisión.
• Estructuras lógicas de repetición.
• Instrucciones de bifurcación.
• Mapa de estructuras lógicas detallado.
Método de las 6´D. Etapas y pasos.
Problemas resueltos en general y sobre figuras.
Capítulo
2
ESTRUCTURAS FUNDAMENTALES PARA LA SOLUCIÓN DE PROBLEMAS
Pag.61
CAPÍTULO II
ESTRUCTURAS FUNDAMENTALES PARA LA
SOLUCION DE PROBLEMAS
INTRODUCCIÓN
El modelamiento se refiere a la forma como representamos la solución de un problema del
mundo real en términos de un modelo. Un algoritmo constituye 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. La lista completa de los pasos se desarrolla utilizando
las estructuras lógicas y las instrucciones de bifurcación, mientras que los datos se
almacenan en las estructuras de datos. La programación es la traducción del modelamiento y
los algoritmos en sentencias que una computadora puede comprender y ejecutar. La acción
de escribir un programa para computadoras se conoce como codificación.
Definición
Solución
Etapa 02
Diseño
Solución
Desarrollo
Solución
Etapa 03
Etapa 04
ENUNCIADO
DEL
PROBLEMA
MARCO DE TRABAJO
Ing. Juan José Flores Cueto.
Pag. 62
El presente capítulo, trata sobre las estructuras fundamentales para la solución de problemas.
Es importante mencionar que utilizando las estructuras fundamentales para la solución de
problemas (estructuras lógicas, instrucciones de bifurcación y las estructuras de datos
conocidas como variables), se pueden desarrollar algoritmos de tal forma que estos puedan
ser diseñados en pseudocódigo o diagrama de flujo, para luego ser codificados en un
lenguaje de programación.
La técnica que se emplea en el presente texto para el ingreso de datos y visualización de la
información, cada día se utiliza con menos frecuencia (técnica tradicional basada en el
ingreso de datos y visualización de información utilizando solo caracteres). En su lugar, se
utilizan las interfaces gráficas de usuario o GUI (por sus siglas en inglés), que incorporan
ventanas, gráficos, colores y otros objetos que permiten una interface visual con el usuario.
El lenguaje de programación Java incorpora un paquete denominado AWT (Abstract Windows
Toolking) que contiene clases que permiten crear cualquier tipo de interfaces gráficas de
usuarios o GUI (interfaces visuales). También incorpora un paquete llamado SWING (a partir
de la versión 2 de Java), que facilita el ingreso y visualización de datos utilizando cuadros de
dialogo visuales.
DECLARACIÓN Y
DEFINICIÓN DE
DATOS
LISTA DE PASOS
DESCRIPCIÓN
DE DATOS
SENTENCIAS
ALMACENADOS EN:
• Estructuras de datos tipo variables.
SE DESARROLLAN UTILIZANDO:
• Estructuras lógicas de secuencia.
• Estructuras lógicas de decisión.
• Estructuras lógicas de repetición.
• Instrucciones de bifucación.
ESTRUCTURAS FUNDAMENTALES PARA LA SOLUCIÓN DE PROBLEMAS
Pag. 63
ESTRUCTURAS DE DATOS
VARIABLES
Definición:
Una variable es una estructura de datos que permite reservar un espacio con la
finalidad de almacenar o guardar temporalmente los datos. Una variable sólo puede
almacenar un dato a la vez. Si se necesita almacenar dos o tres datos, se requerirán
dos o tres variables según sea el caso.
Declaración de una variable:
Declarar una variable significa definir el nombre de la variable y el tipo de dato que
podrá almacenar. Generalmente se realiza al inicio de un programa.
La declaración de una variable se debe realizar antes de que ésta pueda ser
utilizada; esto es necesario en los diferentes lenguajes de programación, y Java no es
la excepción.
En pseudocódigo y diagrama de flujo:
TipoDeDato ListaDeVariables
En Java:
TipoDeDato ListaDeVariables ;
Donde TipoDeDato debe ser un tipo de variable o tipo de dato válido y
ListaDeVariables puede tener uno o más nombres de variables
separadas por comas.
Nombre de variable:
Siempre es necesario que las variables tengan un nombre para poder referirse a ellas
en cualquier parte de un programa. El nombre de una variable deberá comenzar con
una letra minúscula. Si el nombre de la variable está formado por varias palabras, se
deberá escribir con mayúscula la primera letra de cada palabra, a partir de la segunda
palabra que forme parte del nombre. No es válido que el nombre de una variable
tenga espacios en blanco ni caracteres especiales (tales como /()=?¨^* etc).
En pseudocódigo:
Una variable no puede tener el nombre de una regla o pauta
definida. (ejemplo: ESCRIBIR).
En Java:
Ing. Juan José Flores Cueto.
Pag. 64
Una variable no puede tener el nombre de una palabra
reservada. (Ejemplo: String).
Se recomienda que el nombre a utilizar en las variables que se empleen, guarde
relación con el valor que estas almacenan.
Inicialización de una variable:
Es posible que una variable sea definida con un valor inicial y que este valor
posteriormente sea modificado. Es bueno definir con un valor inicial a todas las
variables declaradas en el programa.
En pseudocódigo y diagrama de flujo:
TipoDeDato variable = valor
En Java:
TipoDeDato variable = valor ;
Donde valor debe ser un valor equivalente al tipo de variable o tipo de
dato definido. Aquí TipoDeDato es opcional y se utiliza sólo si la
variable no ha sido declarada anteriormente.
Almacenamiento de datos en variables:
Para almacenar un valor en una variable se utiliza el nombre con el que esta fue
declarada, a continuación el signo igual, seguido del valor que se desea almacenar.
En pseudocódigo y diagrama de flujo:
variable = valor
En Java:
variable = valor ;
Se deberá tener presente que una variable puede almacenar sólo un valor a la vez y
que este valor deberá ser equivalente al tipo de dato con el que se declaró la variable.
Cada vez que almacena un valor en la variable, perderá el valor que anteriormente
tenía esta. Es posible almacenar un valor en una variable en cualquier parte del
programa. El único requisito es que la variable donde se almacene el valor esté
previamente declarada.
El valor de una variable puede también ser sustituido por el resultado de una
operación aritmética o de cálculo. Por ejemplo:
En pseudocódigo y diagrama de flujo:
suma = 7 + 5
ESTRUCTURAS FUNDAMENTALES PARA LA SOLUCIÓN DE PROBLEMAS
Pag. 65
En Java:
suma = 7 + 5 ;
En ambos casos, cuando se desee visualizar el contenido de la
variable suma, se observará que el valor obtenido será 12.
Otros usos de las variables:
Muchas veces, es necesario utilizar variables que permitan almacenar resultados
parciales, obtenidos cada vez que se ejecuta una estructura lógica de repetición (las
estructuras lógicas se repetición se estudian más adelante en este mismo capítulo).
Dichas variables pueden asumir la función de contador, acumulador o interruptor. La
función que pueda asumir una variable dependerá de la forma como se plantee la
solución para un determinado problema.
Contadores:
Un contador es una variable cuyo valor se incrementa o decrementa
en una cantidad fija cada vez que se ejecutan los pasos que forman
parte de una estructura de repetición. Un contador puede ser
creciente o decreciente.
Acumuladores:
Un acumulador o totalizador es una variable cuya función es
almacenar un valor como resultado de sumas o restas sucesivas.
Un acumulador realiza la misma función que un contador con la
diferencia que el incremento o decremento no es una cantidad fija
sino una cantidad variable.
Interruptores:
Un interruptor o conmutador (denominado también centinela, bandera
o flag) es una variable que puede tomar dos posibles valores (1/0,
verdadero/falso, si/no, encendido/apagado) dentro de una
determinada solución. Dependiendo del valor que tome el interruptor
se ejecutarán ciertos pasos.
Cabe mencionar que en una solución se puede utilizar una o varias variables que
pueden asumir las funciones de contador, acumulador o interruptor.
Ing. Juan JoséFlores Cueto.
Pag. 66
TIPOS DE DATOS
Definición:
Los tipos de datos permiten declarar las variables. A pesar que en el pseudocódigo y
diagrama de flujo sólo se reconocen tres tipos de datos, en los lenguajes de
programación se tiene una gran variedad de tipos de datos, los cuales están divididos
–generalmente- en dos categorías: básicos o simples y compuestos.
Existen diferentes tipos de datos. En pseudocódigo y diagrama de flujo se utilizan tres
tipos (NUMERO, TEXTO y LOGICO). Los lenguajes de programación permiten
trabajar con una amplia diversidad de tipos de datos que se extienden desde los más
básicos hasta los más complejos. En Java, todos los datos son derivados de ocho
tipos de datos básicos; byte, short, int, long, float, double, char y boolean.
Los tipos de datos básicos se tratarán en este capítulo y constituyen la base para los
tipos de datos compuestos.
Tipos de datos en Pseudocódigo:
Reglas definidas para los tipos de datos:
NUMERO Referidos a cualquier número. Se puede subdividir en
ENTERO y REAL.
CARACTER Referidos a cualquier letra, digito o símbolo encerrado
entre comilla simple.
TEXTO Referidos a cualquier texto encerrado entre comillas
dobles.
LOGICO Referido a los dos posibles valores lógicos
(VERDADERO y/o FALSO).
Hay que tener presente que las palabras NUMERO, ENTERO, REAL. CARACTER.
TEXTO y LOGICO son reglas utilizadas en el pseudocódigo y diagrama de flujo, por
lo que no podrán ser usadas como nombre de variable. Estos datos nos permiten
definir los tres tipos de variables utilizadas:
Variables numéricas:
Permiten almacenar sólo tipos de datos numéricos (NUMERO,
ENTERO y REAL).
Con una variable numérica se puede realizar operaciones
matemáticas (suma, resta, multiplicación, división, etc.).
En este contexto, se debe tener presente que las operaciones
matemáticas se resuelven siguiendo las mismas reglas que se
aplican en la aritmética tradicional.
ESTRUCTURAS FUNDAMENTALES PARA LA SOLUCIÓN DE PROBLEMAS
Pag. 67
Por ejemplo: Una serie de operaciones.
Primero se resuelven las multiplicaciones y divisiones; luego las
sumas y restas. Para alterar esta prioridad se podrá utilizar los
paréntesis.
Ejemplos:
edad = 15
resultado = 5 + 8 * ( 6 – 2)
Donde edad y resultado son variables que previamente han sido
declaradas como variables de tipo numéricas.
Variables de texto:
Permiten almacenar datos de tipo texto y datos de tipo caracter
(TEXTO y CARACTER).
Las variables tipo texto son útiles para almacenar cualquier cadena
de texto, tales como nombres de personas, direcciones, número de
AFP, etc.
Ejemplos:
nombre = “Pedro”
letra = ‘J’
Donde nombre y siglas son variables que previamente han sido
declaradas como variables de tipo texto.
Variables lógicas:
Permiten almacenar sólo tipo de datos lógicos.
Existen sólo dos valores que se pueden almacenar en este tipo de
variable: verdadero y falso.
Ejemplos:
masculino = VERDADERO
estudiante = FALSO
Donde masculino y estudiante son variables que previamente han
sido declaradas como variables de tipo lógico.
Las palabras VERDADERO y FALSO constituyen reglas en
pseudocódigo y diagrama de flujo, por lo que no está permitido que se
usen como nombres de variables.
Ing. Juan José Flores Cueto.
Pag. 68
Tipos de datos en Java:
Los tipos de datos básicos o simples de Java son utilizados para declarar las
variables que serán utilizadas en los programas, y forman parte de las palabras
reservadas del lenguaje. Las palabras reservadas que permiten declarar variables
son byte, short, int, long, float, double, char y boolean.
Tipo Descripción Longitud Rango
byte Tipo byte 1 byte -128 … 127
short Entero corto 2 bytes -32768 … 32767
int Entero 4 bytes -2.147.483.648 2.147.483.647
long Entero largo 8 bytes -9.223.372.036.854.775.808 9.223.372.036.854.775.807
float Real en coma flotante de simple precisión 4 bytes ±3,4*10
-38 … ±3,4*1038
double Real con coma flotante de doble precisión. 8 bytes ±1,7*10
-308 … ±1,7*10308
char Caracter 2 bytes 0 … 65.535
boolean Lógico 1 byte true / flase
A diferencia de otros lenguajes de programación, en Java los tipos de datos simples
no dependen de la plataforma ni del sistema operativo. Un entero de tipo int siempre
tendrá 4 bytes, por lo que no habrá sorpresas al migrar un programa de un sistema
operativo a otro.
Es importante mencionar que Java no realiza una comprobación de rangos.
Por ejemplo: si a una variable de tipo short con el valor 32.767 se le suma 1, el
resultado será -32.768 y no se producirá ningún error de ejecución.
Es importante destacar que estos ocho tipos de datos simples son diferentes, pero
entre ellos se pueden agrupar como datos de tipo NUMERO (byte, short, int, long,
float, double), tipo CARACTER (char) y tipo LOGICO (boolean). Los datos tipo
NUMERO (datos numéricos) se pueden dividir en valores de tipo ENTERO (byte,
short, int, long) y valores de tipo REAL (float, double).
Para representar una cadena de caracteres en Java, se utiliza la clase String. Los
String en Java no son un tipo de dato básico (simple), sino un tipo de dato compuesto
(a pesar de ello, se puede utilizar como un tipo de dato simple para definir datos de
tipo TEXTO en Java). Los valores de los datos de tipo String van entre comillas
dobles (ejemplo; “Hola”) y permite almacenar cadenas de texto, mientras que los de
tipo char van entre comillas simples (ejemplo; ‘K’) y sólo permiten almacenar un solo
caracter.
Las palabras reservadas de Java no pueden ser utilizadas como nombre de variable.
ESTRUCTURAS FUNDAMENTALES PARA LA SOLUCIÓN DE PROBLEMAS
Pag. 69
Como regla general, una variable solo puede almacenar valores de acuerdo al tipo de
dato con el que fue declarado. Es decir, si se declara una variable con un tipo de dato
específico, solo podrá almacenar valores de dicho tipo de dato. En base a esto, si se
declara una variable con un tipo de dato específico y se intenta almacenar un valor de
distinto tipo, al momento de compilar, el programa indicará un error. Ejemplos:
Clase PrgTipoDato01
package dominioDeLaAplicacion ;
class PrgTipoDato01 {
public static void main ( String arg [ ] ) {
double numReal = 4.3 ;
int numEntero ;
// La siguiente línea genera error.
numEntero = numReal ;
System.out.println ( numEntero ) ;
}
}
Observación: No se puede almacenar un número real grande (double) en una variable entera (int).
Clase PrgTipoDato02
package dominioDeLaAplicacion ;
class PrgTipoDato02 {
public static void main ( String arg [ ] ) {
double numRealDouble = 2.3 ;
float numRealFloat ;
// La siguiente línea genera error.
numRealFloat = numRealDouble ;
System.out.println ( numRealFloat ) ;
}
}
Observación: No se puede almacenar un número real grande (double) en una variable real (float).
Ing. Juan José Flores Cueto.
Pag. 70
Clase PrgTipoDato03
package dominioDeLaAplicacion ;
class PrgTipoDato03 {
public static void main ( String arg [ ] ) {
boolean estado = true ;
char caracter ;
// La siguiente línea genera error.
caracter = estado ;
System.out.println ( caracter ) ;
}
}
Observación: No se puede almacenar un valor lógico (boolean) en una variable caracter (char).
ESTRUCTURAS FUNDAMENTALES PARA LA SOLUCIÓN DE PROBLEMAS
Pag. 71
CONVERSIÓN DE DATOS
Anteriormente se mencionó que por regla general en una variable solo se puede
almacenar un solo valor y este valor debe ser del tipo de dato con el que la variable
fue declarada. Pero como toda regla, esta también tiene su excepción, y la excepción
para estos casos se denomina conversión de datos.
A través de la conversión de datos se puede almacenar en una variable
Continuar navegando
Contenido elegido para ti
Compartir