MÉTODO DE LAS 6’D

UML – Pseudocódigo – Java

(Enfoque algorítmico)

UNIVERSIDAD DE S AN M ARTIN DE PORRES
Facultad de Ingeniería y Arquitectura

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

(Enfoque algorítmico)

Ing. Juan José Flores Cueto.

- 2005 -

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

......................................................................... 563 Otros conceptos ……………………………………………………………………… 569 APÉNDICE......................... GregorianCalendar................................................................................... 605 BIBLIOGRAFÍA . SimpleDateFormat ....................... DecimalFormat.................... 547 Métodos que no devuelven valor y reciben parámetros ……........................................... Clase ……......................... 561 Problema resuelto 151 .......... 573 Clase Lectura ............................................................................ Problemas propuestos ……………………………………………………................. Introducción .................................................. 603 Otras clases Java................ 532 Objeto ……..........................................................................CAPÍTULO V: Introducción al Desarrollo de Soluciones Orientadas a Objetos.......... Etapas y pasos …………...... 544 Métodos que devuelven valor y no reciben parámetros …....................... 534 Atributo ………………….............................. 550 Método constructor ……………………………………………….................. 559 Método de las 6’D.................................. 542 Métodos que no devuelven valor y no reciben parámetros ...... 554 Ocultar atributos de instancia ……………………………………………… 556 Ingreso de datos a través del teclado ……………………………………..... 527 Conceptos básicos.......................................................................... 625 ...................... Calendar...................................... 535 Método …………………...........

.

que para muchos es agobiante. Escasamente un año atrás la Facultad de Ingeniería y Arquitectura de la USMP publicó el primer libro de J. reflejada en la aparición de nuevos paradigmas que deben aplicarse rápidamente. Comprobamos así. las características más importantes del texto se reflejan en su fácil lectura y en su orientación al estudiante. (Un enfoque algorítmico). como consecuencia. El rápido avance de la ciencia y de la tecnología. es resultado de la conjunción de varios factores: su experiencia académica. poniendo énfasis en la solución de problemas y empleando a fondo las capacidades lógicas para el desarrollo de soluciones utilizando una computadora. el método es llamado ahora método de las 6 D’s. pues. Este novedoso método está conformado por seis etapas y cada una de ellas tiene una denominación que comienza con la letra D. problemas y aplicaciones que contiene. nuestro autor sabía ya cuáles eran las nuevas tendencias que se perfilaban. acumulaba información y escribía sobre ellas. 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. 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. ¿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. al momento de aparecer su primer libro. acertadamente. A mi juicio. J. profundizando en el método de las 6 D’s para presentarnos en tan corto plazo una nueva obra. su desempeño profesional y la constante necesidad de estar actualizado. Flores Cueto: Método para la solución de Problemas utilizando la Programación Orientada a Objetos y. entonces. el título del libro que hoy motiva estas líneas: Método de las 6’D: UML – Pseudocódigo – Java. El panorama de la ingeniería de computación y sistemas evoluciona y cambia mientras trabajamos en ella. 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. 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. ya el embrión de la segunda y de aquí. lo que hace que estos seis pasos se puedan recordar fácilmente. que la ópera prima de Juan José contenía. Al reflexionar sobre la tarea que representa escribir un prólogo para este libro. Se tuvo en cuenta primordialmente al usuario y por ello. resulta estimulante para un espíritu como el de este prolífico docente de la USMP. pero cuya difusión en los textos no tiene la misma celeridad.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. pero mejor aun: en el hecho de haber sido probado .

José Antonio Chang Escobedo. una buena documentación y la planificación de soluciones por algoritmos. . por la amistad que me une a Juan José. Ing.con los alumnos. RECTOR USMP. Por lo arriba expresado y. 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. comprobando su progreso y teniendo en cuenta la definición del problema.

son tratados durante el desarrollo de los cinco capítulos que forman parte del presente libro. diseño de la solución. Estos pasos generalmente se desarrollan desde el planteamiento del problema. se van agregando. eliminando o redefiniendo los pasos de algunas de las etapas del método. necesarios para el desarrollo de soluciones utilizando el Método de las 6’D y el desarrollo de sus capacidades lógicas. hasta la codificación y prueba de la misma utilizando herramientas y lenguajes de programación.PREFACIO Actualmente. 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. Desarrollo de la solución. existe una tendencia creciente en el uso de herramientas de desarrollo de software y lenguajes de programación orientados a objetos. agrupados en seis etapas (Descripción del problema. Capítulo II: Se desarrolla la estructura de datos más simple: la variable. también se tratan los conceptos fundamentales sobre modelado y el lenguaje unificado de modelado UML. 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. sobre Algoritmos y las herramientas de diseño conocidas como Diagrama de Flujo y Pseudocódigo. Se describen sus etapas. Depuración y pruebas. así como los pasos y los resultados que se deben esperar de cada una de ellas. la conversión de datos y la forma cómo son utilizados por las herramientas tratadas en el capítulo anterior. y se complementa con el estudio de los tipos básicos de datos. . Definición de la solución. a través del cual se definen los pasos que se tienen que desarrollar para la solución de un problema utilizando una computadora. análisis del problema. y sobre la programación utilizando el lenguaje de programación orientado a objetos Java. En este capítulo. Los conceptos y temas fundamentales. dependiendo de la forma de solucionar los problemas. Es importante mencionar que. 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). y Documentación). Capítulo I: Se desarrolla la parte teórico formal del método de las 6’D. Diseño de la solución. En este libro se utiliza y se profundiza en el Método de las 6’D.

En este capítulo. La clase Math. Es importante que se analicen cada una de las soluciones. Capítulo III: Se desarrollan los conceptos fundamentales sobre las clases básicas incorporadas en el paquete java. traslación. Se presentan 31 problemas desarrollados utilizando el método de las 6’D. extraerlos como subcadenas. comprobación. separando explícitamente el código que maneja los errores del código básico de la aplicación. Las clases Wrappers. 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. también se tratan las estructuras lógicas de secuencia. las instrucciones de bifurcación y el manejo de excepciones. las estructuras lógicas de repetición. ubicarlos. con la finalidad de mejorar el desarrollo de sus capacidades lógicas. las estructuras lógicas de decisión. se intenten mejorarlas y se desarrollen cada uno de los problemas propuestos incluyendo las variaciones planteadas. son un complemento de los tipos de datos primitivos y proporcionan métodos para realizar diferentes tareas con los tipos de datos primitivos. 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. Se tratan los conceptos fundamentales sobre el paquete del lenguaje. logaritmo. raíz cuadrada y funciones trigonométricas. La clase Math contiene métodos de cálculo básico como exponencial. También se presentan 30 problemas desarrollados sobre diferentes tipos de figuras geométricas. las clases wrappers (envoltorios). Se presentan 35 problemas codificados en Java para mejorar la comprensión del tema. tales como la conversión con cadenas de caracteres. entre otras. La clase String. la clase Math y la clase String. Se presentan 5 problemas codificados en Java para mejorar la comprensión del tema. crear copias de . permite declarar y manipular variables de tipo texto o cadena (en realidad no se declaran variables de tipo texto o cadena. Las estructuras de datos. 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. problemas que se van complicando conforme se tratan y explican los conceptos fundamentales.lang.lang del lenguaje de programación Java. proporciona métodos y atributos para implementar diversas funciones matemáticas. el paquete java.

Capítulo IV: Se desarrolla la estructura de datos conocida como arreglos (arrays). redefiniendo algunos de sus pasos para poder ajustar el método a este tipo de soluciones. Estoy seguro que el lector estará de acuerdo conmigo. 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. GregorianCalendar y SimpleDateFormat. Calendar. . Se presentan 30 problemas codificados en Java para mejorar la comprensión del tema. Se presentan 14 problemas desarrollados. métodos y ocultamiento de atributos de instancia. Al final de este capítulo. fue el primero en ser desarrollado. objetos. En el apéndice se incluyen otras clases Java. representación gráfica. utilizando el método de las 6’D para mejorar la comprensión del tema. atributos. Finalmente. creación y su inicialización. declaración. tipos. tales como las clases DecimalFomat. se consideró no incluirlo en el presente texto. se formaliza el método de las 6’D. También se hace una referencia a otras clases en Java que el lector puede explorar. En base al marco teórico se desarrollan soluciones para el ingreso. Se tratan los conceptos básicos fundamentales sobre las clases. A pesar de ello. considero una buena decisión que se incluyera el presente capítulo. Capítulo V: Se desarrolla una introducción al desarrollo de soluciones orientadas a objetos. Es importante comentar que el presente capítulo. Conforme se presenta cada uno de los conceptos mencionados. 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.una cadena convirtiendo todos sus caracteres a letra mayúscula o minúscula. visualización y cálculo de datos contenido en los arreglos. entre otras. pero faltando unos días para la entrega oficial de todo el material que conformaba el presente libro fue incluido. formalizando el método de las 6’D para el adecuado manejo de los mismos. su definición. Finalmente.

Como se puede apreciar. conforme avance con el entendimiento de los problemas resueltos y el desarrollo de los problemas propuestos. Por otro lado. 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. se profundiza en el Método de las 6’D. . Juan José Flores Cueto. los cuales permiten sentar las bases modernas para la programación. pueden ser utilizados de diferente manera de acuerdo a la experiencia de cada persona. necesarias para el desarrollo de soluciones utilizando una computadora. Sólo se tendrá que redefinir algunos de los pasos de las etapas especificadas en el método. Es importante comprender que se puede extender el uso del método a otros temas y a problemas con soluciones mucho más complicadas. Los temas desarrollados a través de los 5 capítulos que forman parte de esta obra. también se tratan conceptos de la programación estructurada y fundamentos de programación orientada a objetos. Ing.

.

.

. Modelamiento. Algoritmo. Capítulo 1 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. Programación. • Resultado de las etapas del método. Marco de trabajo.

.

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.MÉTODO DE LAS 6’D – Un Enfoque Algorítmico. que está compuesto de seis etapas. se ha definido que el nombre de cada una de las etapas del método comience con la misma letra. Con la finalidad de recordar el método. El método propuesto y utilizado en el presente texto es el Método de las 6’D. Algunos problemas. Pag. Algunos de ellos podemos solucionarlos fácilmente. Es decir. por su naturaleza. Este método debe ser fácil de comprender y nos debe guiar paso a paso hasta la solución del problema. pueden ser resueltos utilizando una computadora. Para resolver problemas estructurados utilizando la computadora es importante utilizar un método. de modo que este se pueda recordar como el Método de las 6’D. el método tiene seis etapas y el nombre de cada una de las etapas comienza con la letra “D”. 25 . la letra “D”. tienen una solución determinada y pueden ser desde muy sencillos hasta muy complejos. Estos problemas generalmente son de tipo estructurado. cada una de las cuales consta de una serie de pasos. mientras que otros se complican de tal forma que nos afectan de una manera muy profunda. los cuales se van modificando (ajustando) dependiendo del grado de complejidad del problema y las herramientas que se utilicen para su solución. es decir.

26 . Juan José Flores Cueto. Ing. Pag.

27 . Pag. MÉTODO DE LAS 6’D En la siguiente figura se muestra el Método de las 6’D con sus respectivas etapas: Etapa 01 Descripción Problema Etapa 02 Definición Solución n veces Etapa 03 Ingeniería Reversa Diseño Solución Etapa 04 Desarrollo Solución Etapa 05 Depuración Pruebas Etapa 06 Document.MÉTODO DE LAS 6’D – Un Enfoque Algorítmico.

es necesario identificar cual es el problema que se desea resolver. Descripción de la Etapa 01 – “Descripción del Problema”: Etapa 01 En esta etapa. Identificado el problema es necesario poder comprenderlo en su totalidad. muchas veces resulta Descripción una tarea agotadora ya que generalmente existen del Problema muchas opiniones de cual es el problema central. concreto y conciso del problema a resolver. Esto que parece algo sumamente sencillo. en primer lugar. ETAPAS Y PASOS METODO 6’D. Finalmente se deberá escribir un enunciado claro. Pag. 28 . ƒ Descripción general del problema. Ing. ENUNCIADO El resultado obtenido en esta etapa es un enunciado claro del problema que se desea solucionar. ƒ Enunciado claro y preciso del problema. es decir. PASOS: ƒ Identificación del problema. Identificarlo es una de las tareas más importante que los analistas deben afrontar. comprender qué es exactamente lo que se desea que se resuelva. Juan José Flores Cueto.

PASOS: ƒ Definir el resultado deseado. 29 . ƒ Determinar la forma en que los datos serán procesados para transformarlos en información. se está en condiciones de estudiarlo a fondo y plantear diversas alternativas que permitan solucionar el problema. Descripción de la Etapa 02 – “Definición de la Solución”: Etapa 02 En esta etapa. Una vez entendido el problema. ƒ Determinar los datos que se deben ingresar o generar para obtener el resultado deseado. Pag. METODO 6’D. saber exactamente en qué consiste y poder descomponerlo en cada una Definición de de sus partes para facilitar su comprensión y posterior la Solución solución.MÉTODO DE LAS 6’D – Un Enfoque Algorítmico. es necesario estudiar a fondo el problema para poder solucionarlo. para finalmente. ESPECIFICACIONES El resultado obtenido en esta etapa son las especificaciones de lo que se debe hacer para solucionar el problema. seleccionar la alternativa mas adecuada. Esta es una regla que siempre deberá ser aplicada se utilice o no una computadora en la solución de un problema.

Finalizado el desarrollo de los algoritmos es necesario verificar si se ha incluido soluciones para todas las formas en que se presente el problema. Pag. ƒ Desarrollo de Algoritmos. Para el desarrollo de algoritmos se utiliza Pseudocódigos o Diagramas de Flujo (DF). el cual es una herramienta usada para describir clases. relaciones y clases. Descripción de la Etapa 03 – “Diseño de la Solución”: Etapa 03 Definida la solución. Juan José Flores Cueto. 30 . ƒ Definición de diagramas. se procede a diseñar la lógica modelando y desarrollando algoritmos. UML). Para el modelado de la solución del problema se utiliza Diseño de la el Lenguaje Unificado de Modelado (Unified Modeling Solución Language. PASOS: ƒ Definir un nombre para el proyecto. METODO 6’D. los cuales son herramientas utilizadas para diseñar los algoritmos de los diferentes métodos de una clase. DIAGRAMAS Y ALGORITMOS El resultado obtenido en esta etapa son los diagramas y los algoritmos que especifican cómo se debe hacer para solucionar el problema. Ing. objetos y sus relaciones. A este tipo de prueba se le denomina “Prueba de escritorio”.

ƒ Desarrollar copias de seguridad de los programas de computadora. La codificación involucra traducir los diagramas.MÉTODO DE LAS 6’D – Un Enfoque Algorítmico. Descripción de la Etapa 04 – “Desarrollo de la Solución”: Etapa 04 Una vez previstas todas las posibilidades y alternativas que puedan presentarse y que pasen sin inconvenientes por la clase y los algoritmos. las especificaciones de las clases (expresadas en notación UML). Estas sentencias son almacenadas en un proyecto (o archivo) lógico. y los pasos del algoritmo de cada método (expresado en DF o pseudocódigo). ƒ Desarrollar comentarios internos en los programas de computadora. se podrá Desarrollo de proceder a la codificación del problema en algún la Solución lenguaje de programación. Pag. que permiten solucionar el problema. 31 . codificados en un lenguaje de programación. y constituyen lo que la computadora podrá ejecutar. en sentencias de un lenguaje de programación determinado. PROGRAMAS El resultado obtenido en esta etapa son los programas y/o clases. PASOS: ƒ Codificar el proyecto. METODO 6’D.

Juan José Flores Cueto. siendo los errores de lógica y sintaxis los más comunes. 32 . PASOS: ƒ Realizar la depuración y verificar la correcta escritura de los programas. y Pruebas Al realizarse ésta. METODO 6’D. ƒ Realizar pruebas de lógica. Pag. Hay que corregir el programa. anular. volver a probar el programa y continuar con la corrección y pruebas hasta conseguir el resultado deseado. deben ser probados mediante la ejecución de los Depuración mismos (esto es conocido como corrida del programa). PRUEBAS El resultado obtenido en esta etapa son las pruebas que registran el adecuado funcionamiento de la solución del problema. Descripción de la Etapa 05 – “Depuración y Pruebas”: Etapa 05 Luego que se codifiquen los programas y/o clases. Ing. modificar o crear nuevas sentencias. pueden surgir diferentes tipos de errores. ƒ Realizar pruebas de sintaxis.

Diagramas UML. ƒ Generar el manual del programa. PASOS: ƒ Recopilar el material generado en cada una de las etapas anteriores. . Listado de programas con comentarios internos. como mínimo: . Manuales El resultado obtenido en esta etapa son los manuales que permiten un adecuado manejo de la solución desarrollada. DF y/o Pseudocódigo. Documentación Dedicarle tiempo a esta etapa nos ayudará a desarrollar buenos hábitos. METODO 6’D. Pruebas desarrolladas. Pag. . la cual va a servir como base para la elaboración del manual técnico. los cuales serán necesarios cuando se desarrolle software en forma profesional.MÉTODO DE LAS 6’D – Un Enfoque Algorítmico. . 33 . Descripción de la Etapa 06 – “Documentación”: Etapa 06 En esta etapa se recopila toda la documentación generada en las etapas anteriores. . Resultados esperados y datos necesarios para generar dichos resultados. El manual técnico debe incluir. ƒ Generar el manual del usuario. Descripción del problema.

METODO 6’D. Desarrollo Solución Etapa 05 PASOS: • Exportar proyecto (archivos class o Depuración java) al disco de la PC. Adicionalmente es posible realizar “Ingeniería Reversa” entre las Etapas 03. Ing. 04 y 05: La ingeniería reversa nos permite crear o Ingeniería Reversa actualizar 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 n veces ETAPA 05 “Depuración y pruebas”. si está Pruebas trabajando con un IDE. • Importar proyecto (archivos class o java) a una herramienta CASE y realizar la ingeniería reversa. a través de la Ingeniería Reversa es Etapa 03 posible programar o codificar algunas partes (hasta su correcto funcionamiento) que no estén especificadas en la Etapa 03 “Diseño de Diseño la Solución”. DIAGRAMAS ACTUALIZADOS Pag. A partir de esta solución se Solución Etapa 04 actualizan los diagramas de la Etapa 03 y se continúa con el proceso hasta llegar a la solución deseada. Es decir. • Organizar el modelo obtenido en la herramienta CASE. Juan José Flores Cueto. 34 .

clases. nombre para proyecto. para transformarlos programas de en información. del usuario. computadora. RESUMEN DEL MÉTODO METODO 6’D. copias de ƒ Realizar pruebas serán procesados seguridad de los de lógica. deseado. en que los datos Algoritmos. internos en los de los ƒ Generar el manual ƒ Enunciado para obtener el relaciones y programas de programas. problema. ƒ Determinar la forma ƒ Desarrollo de ƒ Desarrollar de sintaxis. depuración y material generado ƒ Descripción ƒ Determinar los el proyecto. claro y preciso resultado deseado. computadora. Resumen de las etapas y los pasos del método: Etapa 01 Etapa 02 Etapa 03 Etapa 04 Etapa 05 Etapa 06 Descripción Definición Diseño Desarrollo Depuración Document.MÉTODO DE LAS 6’D – Un Enfoque Algorítmico. del programa. ƒ Realizar pruebas ƒ Generar el manual del problema. ingresar o generar diagramas. 35 . ƒ Desarrollar verificar la en cada una de las general del datos que se deben ƒ Definición de comentarios correcta escritura etapas anteriores. Problema Solución Solución Solución Pruebas ƒ Identificación ƒ Definir el resultado ƒ Definir un ƒ Codificar el ƒ Realizar la ƒ Recopilar el del problema. Pag.

Resultado de las etapas del Método: Etapa 01 Etapa 02 Etapa 03 Etapa 04 Etapa 05 Etapa 06 Descripción Definición Diseño Desarrollo Depuración Document. Problema Solución Solución Solución Pruebas DIAGRAMAS Y ENUNCIADO ESPECIFICACIONES PROGRAMAS PRUEBAS ALGORITMOS Manuales Pag. Juan José Flores Cueto. 36 . Ing. RESULTADO DE LAS ETAPAS DEL MÉTODO METODO 6’D.

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. 37 . etapa 03 (“Diseño de la solución”) y etapa 04 (“Desarrollo de la solución”).MÉTODO DE LAS 6’D – Un Enfoque Algorítmico. 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 01 Descripción Problema ENUNCIADO MARCO DE TRABAJO Etapa 02 Definición Solución Etapa 03 Diseño Solución Etapa 04 Desarrollo Solución Pag. MARCO DE TRABAJO En el presente texto se solucionarán problemas sencillos utilizando el Método de las 6’D. es decir.

Encapsulamiento. Objetos. se puede plantear nuevos pasos y eliminar pasos ya existentes en las diferentes etapas del método. También es posible plantear soluciones más complejas utilizando el Método de las 6’D. algoritmo y programación. Interfaces Gráficas. 38 . Esto significa. Pag. en el capítulo IV y en el capítulo V del presente texto. los pasos especificados en cada una de las etapas del método se pueden redefinir (modificar). Ing. Para poder solucionar problemas sencillos utilizando el Método de las 6’D. solo se desarrolla la etapa 04 (“Desarrollo de la solución”). Para ello se tendría que dominar otros conceptos. se solucionan los problemas utilizando el marco de trabajo especificado. Conexión a Base de Datos. Juan José Flores Cueto. y dominar el uso de las estructuras lógicas. Este tipo de soluciones son el objetivo del presente texto. Métodos. es necesario conocer los conceptos fundamentales de modelamiento. Es importante precisar que en la primera parte del capítulo II. mientras que en la segunda parte del capítulo II y el capítulo III. Servlets entre otros. Es importante mencionar. Herencia. tales como. que dependiendo de la complejidad del problema. con la finalidad de resolver una mayor cantidad de problemas y profundizar en la codificación utilizando el lenguaje de programación Java. instrucciones o sentencias de bifurcación y las estructuras de datos. Polimorfismo. que dependiendo de la complejidad del problema y de su solución.

Para desarrollar un modelo y representarlo en UML. Visual Basic. En su forma más sencilla. un paquete se representa de la siguiente forma: NombrePaquete Nombre del paquete.MÉTODO DE LAS 6’D – Un Enfoque Algorítmico. se detallarán algunos conceptos básicos que serán utilizados en las soluciones planteadas en el presente texto.. En UML.). no ambiguos). • Construir un modelo en un lenguaje de programación (se establecen correspondencias con lenguajes Orientados a Objetos. • Documentar los componentes de un sistema de software (arquitectura. 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. pruebas.. como Java. Un paquete contiene clases que tienen funciones similares. • Describir el ciclo de vida completo del desarrollo Orientado a Objetos. que está bajo observación o estudio. 39 ..). diseño. ƒ Paquete. El Lenguaje Unificado de Modelado (UML) es un lenguaje gráfico que nos permite: • Visualizar un modelo. Una clase es una abstracción y no Pag. una clase es un conjunto de atributos y métodos. versiones. es necesario conocer todos los conceptos relacionados con el desarrollo de Software Orientado a Objetos. Para nuestro propósito.. planificación. un modelo que se utiliza para describir uno o más objetos del mismo tipo. ƒ Clase. • Especificar un modelo (construir modelos precisos. Un modelo es una representación gráfica o simbólica de algún aspecto del mundo real. es simplemente. requisitos..Una clase.. C++.Los paquetes nos permiten organizar las clases de un modelo. Para representar un modelo se utilizará el UML (Unified Modeling Language).

acerca de la cual almacenamos datos y los métodos que controlan y manipulan dichos datos. En UML. En UML. un objeto se representa de la siguiente forma: NombreClase : Nombre de la clase a la cual nombreObjeto pertenece el objeto y el nombre del objeto. los cuales se muestran a continuación: Diagramas de Clase Diagramas de Paquete Diagramas de Casos de Uso Diagramas de Objeto Secuencia Diagramas de Diagramas de Colaboración Componentes Modelo Diagramas de Diagramas de Estado Distribución Diagramas de Actividad Pag. Atributos Lista de atributos de la clase. Juan José Flores Cueto.. 40 . ƒ Objeto. Ambos nombres deben estar separados por dos puntos. una clase se representa de la siguiente forma: NombreClase Nombre de la clase y (NombrePaquete del paquete al cual al que pertenece) pertenece la clase. Ing. Un objeto se crea o instancia a partir de una clase. Métodos Lista de métodos de la clase. UML incorpora nueve diagramas que permiten representar un modelo desde diferentes perspectivas. real o abstracta. representa a ningún objeto en particular.Un objeto es cualquier cosa.

41 . 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).. 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).MÉTODO DE LAS 6’D – Un Enfoque Algorítmico.Un diagrama de paquetes permite especificar y visualizar las relaciones de dependencia que existe entre los paquetes que forman parte de una solución. Pag. una relación de dependencia unidireccional entre dos paquetes se gráfica de la siguiente manera: Relación de dependencia unidireccional. Para nuestro propósito. ƒ Diagrama de paquetes. 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. se detallará el diagrama de paquetes que será utilizado en las soluciones planteadas en el presente texto.

En este paso se desarrollará el diagrama de paquetes y se especificará la relación de dependencia entre los paquetes utilizando UML. Ing. ƒ Definición de diagramas. 42 . seguido de un nombre que identifique al proyecto.“Diseño de la solución”: Etapa 03 Diseño Solución Se desarrollan los siguientes pasos: ƒ Definir un nombre para el proyecto. el modelamiento de una solución se desarrolla durante la Etapa 03 . La definición del nombre del proyecto. El nombre del proyecto comenzará con las letras “Proy” (abreviatura de proyecto). permite agrupar a todos los elementos que serán parte de la solución del problema utilizando el método planteado. Dicha clase no tendrá ningún atributo definido y solo se definirá un método (el método principal). Este nombre debe ser seleccionado adecuadamente. Para nuestros fines se crearán dos paquetes en las soluciones. Juan José Flores Cueto. Este nombre debe ser seleccionado adecuadamente. Uno de ellos lo se llamará “dominioDeLaAplicación” y el otro “biblioteca”. En el paquete “dominioDeLaAplicacion”. se definirá la clase que permitirá solucionar el problema planteado utilizando UML. y se establecerá una relación de dependencia unidireccional del primero hacia el segundo. seguido de un nombre que identifique a la clase. El nombre de la clase comenzará con las letras “Prg” (abreviatura de programa). En el Método de las 6’D. relaciones y clases. Pag.

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.MÉTODO DE LAS 6’D – Un Enfoque Algorítmico. se tendrá clase Lectura1 que facilitará el ingreso de los datos a la computadora. 43 . En caso que el nombre sea compuesto. Regla general para especificar los nombres de los paquetes. Si el nombre es compuesto. En el paquete “biblioteca”. Pag. 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. 1 La clase Lectura se trata en el Capítulo II y se especifica en el Apéndice. Los nombres de los métodos cumplen las mismas características que los nombres de atributos a excepción de los métodos constructores. a partir de la segunda palabra se escribe la primera letra en mayúscula. clases.

Juan José Flores Cueto. Pag. Ing. 44 .

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. 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. se debe obtener el mismo resultado. CARACTERÍSTICAS ƒ Descripción de los pasos que deben ser ejecutados (estructuras lógicas). Si se sigue un algoritmo dos veces. en su forma más simple. ƒ Todo algoritmo debe ser finito. Los métodos representan pequeños subprogramas encapsulados dentro de las clases y contribuyen a definir el comportamiento típico de los objetos. 45 . ALGORITMO Una clase. indicando el orden de realización de cada paso. está constituida por atributos y métodos. 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. ƒ Un algoritmo debe ser preciso. ƒ Descripción de los datos que son manipulados por estos pasos (estructuras de datos). ƒ Un algoritmo debe estar definido. Pag. ƒ Un algoritmo puede o no tener datos de entrada. ƒ Una descripción de los datos que son manipulados por estos pasos. éste debe terminar en algún momento. Si se sigue un algoritmo.MÉTODO DE LAS 6’D – Un Enfoque Algorítmico. De esto. ƒ Un algoritmo producirá uno o más datos de salida.

Por ejemplo. ‰ Para asignar un valor a una variable “x” se utiliza el signo igual. Por ejemplo. la primera letra de cada palabra simple deberá estar en mayúscula. 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. 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 determinen los datos de entrada y la información de salida. entender. si se desea asignar 5 a la variable “x” se realizará de la siguiente manera: x = 5. usar y cambiar si es preciso. Juan José Flores Cueto. Por lo tanto. ƒ Debe ser estructurado. En conclusión. se debe entender la importancia de estudiar los “algoritmos” para comprender como se está solucionando un determinado problema. Es decir. ‰ Para declarar una variable “x” se deberá determinar qué tipo de dato se almacenará. ƒ El resultado que se obtenga debe satisfacer los requerimientos de la persona interesada (efectividad). debe ser fácil de leer. ƒ Los datos de entrada y salida deben almacenarse en estructuras de datos. 46 . Pautas básicas: ‰ Todo algoritmo debe tener un nombre. Entre dichas herramientas se puede mencionar al pseudocódigo y al diagrama de flujo. Se dispone de diversas herramientas para desarrollar los algoritmos para los métodos de las clases. Ing. Pag. Si es un nombre compuesto. los algoritmos permiten especificar la lógica de desarrollo de los métodos que conforman una clase. el cual deberá comenzar con una letra mayúscula. Si se desea declarar una variable de tipo texto se realizaría de la siguiente manera: TEXTO x.

Estructura básica de un pseudocódigo: Algoritmo NombreClase – nombreMetodo() ENTRADA: SALIDA: En ENTRADA y SALIDA se especifican las variables que se usarán en el INICIO desarrollo del algoritmo. ‰ Para indicar que la computadora lea un valor desde un dispositivo externo y lo almacene en la variable “z”. … … Este es el cuerpo del … algoritmo expresado en pseudocódigo..MÉTODO DE LAS 6’D – Un Enfoque Algorítmico. 47 .. DIAGRAMA Por el hecho de ser un dibujo que no requiere estar a escala. Entonces. La combinación de símbolos especializados y líneas de flujo describe la lógica para la solución del problema (algoritmo). Pag. ‰ Para escribir el resultado de una expresión (observe que la expresión no está entre comillas) se utiliza: ESCRIBIR x + 2. ƒ 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. se utiliza: LEER z. FIN. se puede afirmar que el Diagrama de Flujo es la representación gráfica de un algoritmo. Las … instrucciones se colocan FIN entre INICIO. ‰ 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”. FLUJO Porque muestra la secuencia de lo que se tiene que realizar. ‰ Para escribir el valor de una variable (observe que la variable no está entre comillas) se utiliza: ESCRIBIR x.

ENTRADA / SALIDA Utilizado para ingresar datos y visualizar la información que resulta del procesamiento. Juan José Flores Cueto. Ing. CONECTOR Este símbolo permite que no se crucen los flujos (líneas) en un diagrama. 48 . FLUJOS (LINEAS) Líneas que permiten unir los diagramas y mostrar la secuencia lógica a la solución del problema. Elementos o símbolos básicos: 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. Pag.

el ESCRIBIR ESCRIBIR x contenido de una variable o el resultado ESCRIBIR x + z de una operación matemática.MÉTODO DE LAS 6’D – Un Enfoque Algorítmico. Permite asignar el valor FALSO a una FALSO aprobado = FALSO variable lógica. Utilizada para realizar comentarios COMENTARIO COMENTARIO “Variables” internos en la codificación de las soluciones. GRUPO 2 SI (condición) Permite especificar una estructura de ENTONCES decisión simple “SI.. estructuras lógicas serán tratadas en el FINSI capítulo II.. El dato LEER LEER x ingresado se almacena en la variable especificada. Las SI instrucciones. Permite declarar a una variable de tipo CARACTER CARACTER letra texto o cadena de una sola letra. desarrollados en pseudocódigo y diagrama de flujo. Permite declarar una variable de tipo TEXTO TEXTO mensaje texto o cadena. Permite declarar una variable de tipo LÓGICO LÓGICO aprobado lógico. ƒ REGLAS UTILIZADAS POR LAS HERRAMIENTAS Con la finalidad de comprender mejor el diseño de los algoritmos. Pag. se han clasificado en 6 grupos las reglas definidas. Permite declarar una variable de tipo NUMERO NUMERO x numérico. ESCRIBIR “Hola” Se puede visualizar una cadena. 49 . Utilizada para la salida de información.. REGLA FORMATO DESCRIPCIÓN GRUPO 1 Utilizada para el ingreso de datos.. Permite asignar el valor VERDADERO a VERDADERO aprobado = VERDADERO una variable lógica. FINSI”.

SINO.FINHACER”. estructuras lógicas serán tratadas en el . estructuras lógicas serán tratadas en el . FINCUANDO DESDE i = valorInicial HASTA valorFinal instrucción 1 Permite especificar una estructura de ... Las HACER . instrucción n FINDESDE MIENTRAS (condición) instrucción 1 Permite especificar una estructura de . el capítulo II. FINCUANDO”.... OTROS instrucciones.. repetición “DESDE... instrucciones. capítulo II. repetición “MIENTRAS.. FINSI”. Pag. REGLA FORMATO DESCRIPCIÓN SI (condición) ENTONCES Permite especificar una estructura de instrucciones. MIENTRAS .... Permite volver a ejecutar una estructura lógica de repetición sin finalizar todas las CONTINUAR CONTINUAR instrucciones que forman parte de la misma. decisión doble “SI. FINDESDE”.... CASO (valor 2) : Las estructuras lógicas serán tratadas en CUANDO instrucciones... instrucción n MIENTRAS (condición) Permite terminar la ejecución de una TERMINAR TERMINAR estructura lógica de repetición.. Las DESDE . Juan José Flores Cueto. Ing.FINMIENTRAS”. capítulo II. Las SI / SINO SINO estructuras lógicas serán tratadas en el instrucciones. el capítulo II.. FINSI CUANDO (variable) SEA Permite especificar una estructura de CASO (valor 1) : decisión múltiple “CUANDO.. instrucción n FINMIENTRAS HACER instrucción 1 Permite especificar una estructura de . capítulo II. Las estructuras lógicas serán tratadas en . repetición “HACER. 50 .... CASO (valor n) : instrucciones.

Ver capítulo III. El resultado se almacena en la variable “x”. GRUPO 4 Permite obtener el resto de la división RESTO x = z RESTO n entre las variables “z” y “n”. Ver capítulo III. Permite obtener la parte entera de la DIVIDIR x = z DIVIDIR n división de las variables “z” y “n”. Permite obtener la raíz “n” del número RAIZ x = z RAIZ n “z”.MÉTODO DE LAS 6’D – Un Enfoque Algorítmico. Permite obtener el número de filas de FILA x = FILA n una matriz “n”. REGLA FORMATO DESCRIPCIÓN GRUPO 3 Permite obtener el coseno del valor almacenado en la variable “n”. Ver capítulo III. El resultado se almacena en la variable “x”. El resultado se almacena en la variable “x”. Permite cambiar a minúscula la cadena almacenada en la variable “n”. El resultado se almacena en la variable “x”. El resultado se almacena en la variable “x”. El resultado se almacena en la variable “x”. Permite cambiar a mayúscula la cadena MAYÚSCULA x = MAYÚSCULA n almacenada en la variable “n”. 51 . Permite obtener la longitud de la cadena almacenada en la variable “n” o la LONGITUD x = LONGITUD n longitud del vector “n”. El COSENO x = COSENO n resultado se almacena en la variable “x”. Permite obtener el número de columnas COLUMNA x = COLUMNA n de una matriz “n”. El resultado se almacena en la variable “x”. Ver capítulo III. Ver capítulo III y capítulo IV. Permite obtener el seno del valor SENO x = SENO n almacenado en la variable “n”. Pag. El resultado se almacena en la variable “x”. El MINUSCULA x = MINUSCULA n resultado se almacena en la variable “x”.

El resultado se almacena en la variable “x”. GRUPO 6 Utilizada para crear arreglos previamente CREAR vector[n] declarados. ALEATORIO x = z ALEATORIO n El resultado se almacena en la variable “x”. Permite obtener un número cualquiera (aleatorio) entre los valores de “n” y “z”. El resultado se almacena en la variable “x”. Juan José Flores Cueto. REGLA FORMATO DESCRIPCIÓN Permite obtener la potencia “n” del POTENCIA x = z POTENCIA n número “z”. Los arreglos serán tratados en el capítulo IV. 52 . Un arreglo permite CREAR almacenar más de un dato del mismo CREAR matriz[n1][n2] tipo. n2 en una cadena entre las posiciones especificadas por “n1” y “n2”. El resultado se almacena en la variable “x”. GRUPO 5 Permite obtener una subcadena comprendida entre las posiciones SUBCADENA x = z SUBCADENA n1. Permite obtener el número menor entre el valor almacenado en la variable “n” y la MINIMO x = z MINIMO n variable “z”. Permite eliminar los espacios existentes ELIMINAESPACIO x = z ELIMINAESPACIO n1. Permite obtener el carácter ubicado en la CARACTER x = z CARACTER n posición “n” de la cadena “z”. Ing. Pag. El resultado se almacena en la variable “x”. El resultado se almacena en la variable “x”. El resultado se almacena en la variable “x”. n2 especificadas por “n1” y “n2” de la cadena “z”. Permite obtener el número mayor entre el valor almacenado en la variable “n” y la MAXIMO x = z MAXIMO n variable “z”. Permite crear un objeto de una CREAR CREAR objeto determinada clase EJECUTAR EJECUTAR algoritmo Permite ejecutar otro algoritmo.

“Diseño de la solución”: Etapa 03 Diseño Solución Se desarrollará el siguiente paso: ƒ Desarrollo de algoritmos. En este paso. Pag. 53 . la cual forma parte del paquete “dominioDeLaAplicación”. REGLA FORMATO DESCRIPCIÓN Permite especificar si un algoritmo recibe PARAMETRO PARAMETRO listaVariables datos o valores. En el Método de las 6’D. Permite especificar si un algoritmo RETORNAR RETORNAR variable retorna una respuesta. Para el desarrollo del algoritmo se utilizará pseudocódigo. durante la Etapa 03 . el algoritmo de una solución se desarrolla después del modelamiento. se desarrollará el algoritmo para el método especificado en la clase.MÉTODO DE LAS 6’D – Un Enfoque Algorítmico.

Entre los lenguajes de programación orientados a objetos podemos destacar a Java. se desarrolló la programación lineal. PROGRAMACIÓN La programación es la traducción del modelamiento y los algoritmos en sentencias que la computadora puede comprender y ejecutar. después la programación estructurada y ahora la programación orientada a objetos. que la programación es la acción de escribir programas para una computadora. LENGUAJES DE PROGRAMACIÓN ƒ JAVA Java es un lenguaje de programación orientado a objetos desarrollado por Sun MicroSystems. Juan José Flores Cueto. la mayor parte de los cuales tienen un conjunto de reglas o sentencias muy especializadas. Pag. En términos sencillos. una compañía reconocida por sus estaciones de trabajo UNIX de alta calidad. La forma de programación ha variado con el paso de los años. luego la programación modular. los cuales están divididos en categorías según su experiencia y dominio de diferentes lenguajes de programación. Al inicio. Las personas que escriben los programas son conocidas como programadores. Existen diferentes lenguajes de programación. un lenguaje de programación es un lenguaje que los programadores utilizan para escribir programas que son comprendidos y ejecutados en una computadora. Ing. 54 . utilizando alguno de los lenguajes de programación existentes. Se puede decir. Nos “comunicamos” con las computadoras a través de los programas desarrollados en un lenguaje de programación en particular. Entonces. La acción de escribir programas para una computadora se conoce como codificación.

también puede ser utilizado como un lenguaje estructurado. programa en Java. pueden ejecutarse en cualquier computadora que tenga instalada una máquina virtual de Java. Las … sentencias se colocan dentro de los corchetes del método main ( ). sencillo y portátil a través de plataformas y sistemas operativos. Fundamentado en el lenguaje de programación C++. para definir que una clase forma parte de un paquete determinado. class NombreClase { public static void main ( String arg[ ] ) { … Este es el cuerpo del sentencias. 55 . 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 Pag. lo cual se hace necesario para poder iniciar el estudio de los conceptos fundamentales de programación. aplicaciones y servlets). } } En el lenguaje de programación Java. el lenguaje Java se diseñó para ser pequeño. A pesar que Java es un lenguaje de programación orientado a objetos. Estructura básica de un programa desarrollado en Java: package NombrePaquete.MÉTODO DE LAS 6’D – Un Enfoque Algorítmico. lo que significa que los programas Java (applets. tanto a nivel de código fuente como binario.

Todos los lenguajes tienen palabras claves. Es importante comprender que una clase está constituida por atributos y métodos. 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 ( ). Ing. Palabras reservadas en Java: Una palabra reservada o palabra clave. Existen clases que tienen un método especial conocido como “método principal”. para especificar que una clase tiene un “método principal”. en el lenguaje de programación Java. Juan José Flores Cueto. son clases que pueden ejecutarse. Todo el código ejecutable reside dentro de los métodos de la clase. 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 Pag. es aquella que tiene un significado especial para un lenguaje de programación. No existe código que no esté contenido dentro de un método (a excepción de los bloques estáticos). 56 . Todas las clases que tienen especificado un “método principal”.

incorporando nuevas características y nuevos conceptos. Es decir. la programación de una solución se desarrolla durante la Etapa 04 . En el Método de las 6’D. Una característica importante de la POO es que utiliza los mejores conceptos de la PE y de las otras formas de programación.MÉTODO DE LAS 6’D – Un Enfoque Algorítmico. 57 . utilizando el lenguaje de programación Java. En este paso. Pag. siendo la POO la más reciente y la que promete solucionar muchos de los problemas de la PE. se desarrollará la codificación del proyecto.“Desarrollo de la solución”: Etapa 04 Desarrollo Solución Se desarrollará solo el primer paso: ƒ Codificar el proyecto. 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. en sentencias que la computadora pueda comprender y ejecutar. se traducirá lo especificado en el modelamiento y en los algoritmos.

Juan José Flores Cueto. Ing. 58 . Pag.

• Estructuras lógicas de repetición. • Instrucciones de bifurcación. Estructuras Lógicas: • Estructuras lógicas de secuencia. Problemas resueltos en general y sobre figuras. Estructuras de Datos: Variables • Tipos de datos. Método de las 6´D. . • Estructuras lógicas de decisión. Capítulo 2 Estructuras Fundamentales para la Solución de Problemas Temas: Introducción. Etapas y pasos. • Conversión de datos. • Mapa de estructuras lógicas detallado.

.

61 .ESTRUCTURAS FUNDAMENTALES PARA LA SOLUCIÓN DE PROBLEMAS 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. La lista completa de los pasos se desarrolla utilizando las estructuras lógicas y las instrucciones de bifurcación. 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. MARCO DE TRABAJO ENUNCIADO DEL PROBLEMA Etapa 02 Definición Solución Etapa 03 Diseño Solución Etapa 04 Desarrollo Solución Pag. 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. mientras que los datos se almacenan en las estructuras de datos.

En su lugar. El presente capítulo. • Instrucciones de bifucación. Ing. Juan José Flores Cueto. 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. ALMACENADOS EN: • Estructuras de datos tipo variables. Es importante mencionar que utilizando las estructuras fundamentales para la solución de problemas (estructuras lógicas. se pueden desarrollar algoritmos de tal forma que estos puedan ser diseñados en pseudocódigo o diagrama de flujo. LISTA DE PASOS SENTENCIAS DESCRIPCIÓN DECLARACIÓN Y DE DATOS DEFINICIÓN DE DATOS SE DESARROLLAN UTILIZANDO: • Estructuras lógicas de secuencia. se utilizan las interfaces gráficas de usuario o GUI (por sus siglas en inglés). • Estructuras lógicas de repetición. La técnica que se emplea en el presente texto para el ingreso de datos y visualización de la información. gráficos. que incorporan ventanas. 62 . colores y otros objetos que permiten una interface visual con el usuario. • Estructuras lógicas de decisión. trata sobre las estructuras fundamentales para la solución de problemas. Pag. para luego ser codificados en un lenguaje de programación. 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). instrucciones de bifurcación y las estructuras de datos conocidas como variables). 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).

y Java no es la excepción. Si el nombre de la variable está formado por varias palabras. No es válido que el nombre de una variable tenga espacios en blanco ni caracteres especiales (tales como /()=?¨^* etc). Nombre de variable: Siempre es necesario que las variables tengan un nombre para poder referirse a ellas en cualquier parte de un programa. En pseudocódigo: Una variable no puede tener el nombre de una regla o pauta definida. a partir de la segunda palabra que forme parte del nombre. Generalmente se realiza al inicio de un programa. Si se necesita almacenar dos o tres datos. se requerirán dos o tres variables según sea el caso. (ejemplo: ESCRIBIR). 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.ESTRUCTURAS FUNDAMENTALES PARA LA SOLUCIÓN DE PROBLEMAS 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. El nombre de una variable deberá comenzar con una letra minúscula. Declaración de una variable: Declarar una variable significa definir el nombre de la variable y el tipo de dato que podrá almacenar. 63 . Una variable sólo puede almacenar un dato a la vez. En pseudocódigo y diagrama de flujo: TipoDeDato ListaDeVariables En Java: TipoDeDato ListaDeVariables . se deberá escribir con mayúscula la primera letra de cada palabra. En Java: Pag. 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.

64 . Almacenamiento de datos en variables: Para almacenar un valor en una variable se utiliza el nombre con el que esta fue declarada. Es posible almacenar un valor en una variable en cualquier parte del programa. En pseudocódigo y diagrama de flujo: variable = valor En Java: variable = valor . Donde valor debe ser un valor equivalente al tipo de variable o tipo de dato definido. Juan José Flores Cueto. Es bueno definir con un valor inicial a todas las variables declaradas en el programa. Aquí TipoDeDato es opcional y se utiliza sólo si la variable no ha sido declarada anteriormente. guarde relación con el valor que estas almacenan. El único requisito es que la variable donde se almacene el valor esté previamente declarada. Inicialización de una variable: Es posible que una variable sea definida con un valor inicial y que este valor posteriormente sea modificado. Por ejemplo: En pseudocódigo y diagrama de flujo: suma = 7 + 5 Pag. El valor de una variable puede también ser sustituido por el resultado de una operación aritmética o de cálculo. Una variable no puede tener el nombre de una palabra reservada. perderá el valor que anteriormente tenía esta. a continuación el signo igual. Se recomienda que el nombre a utilizar en las variables que se empleen. (Ejemplo: String). 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. seguido del valor que se desea almacenar. Ing. En pseudocódigo y diagrama de flujo: TipoDeDato variable = valor En Java: TipoDeDato variable = valor .

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). verdadero/falso. es necesario utilizar variables que permitan almacenar resultados parciales. Pag. se observará que el valor obtenido será 12. Dependiendo del valor que tome el interruptor se ejecutarán ciertos pasos. 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. Cabe mencionar que en una solución se puede utilizar una o varias variables que pueden asumir las funciones de contador. si/no. Otros usos de las variables: Muchas veces.ESTRUCTURAS FUNDAMENTALES PARA LA SOLUCIÓN DE PROBLEMAS En Java: suma = 7 + 5 . cuando se desee visualizar el contenido de la variable suma. La función que pueda asumir una variable dependerá de la forma como se plantee la solución para un determinado problema. bandera o flag) es una variable que puede tomar dos posibles valores (1/0. 65 . 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. Acumuladores: Un acumulador o totalizador es una variable cuya función es almacenar un valor como resultado de sumas o restas sucesivas. En ambos casos. acumulador o interruptor. Un contador puede ser creciente o decreciente. Interruptores: Un interruptor o conmutador (denominado también centinela. Dichas variables pueden asumir la función de contador. encendido/apagado) dentro de una determinada solución. acumulador o interruptor.

en los lenguajes de programación se tiene una gran variedad de tipos de datos. double. Ing.).en dos categorías: básicos o simples y compuestos. A pesar que en el pseudocódigo y diagrama de flujo sólo se reconocen tres tipos de datos. Se puede subdividir en ENTERO y REAL. float. se debe tener presente que las operaciones matemáticas se resuelven siguiendo las mismas reglas que se aplican en la aritmética tradicional. Pag. CARACTER. TEXTO Referidos a cualquier texto encerrado entre comillas dobles. resta. REAL. Estos datos nos permiten definir los tres tipos de variables utilizadas: Variables numéricas: Permiten almacenar sólo tipos de datos numéricos (NUMERO. Los tipos de datos básicos se tratarán en este capítulo y constituyen la base para los tipos de datos compuestos. short. 66 . CARACTER Referidos a cualquier letra. TEXTO y LOGICO son reglas utilizadas en el pseudocódigo y diagrama de flujo. digito o símbolo encerrado entre comilla simple. división. int. ENTERO. long. multiplicación. Tipos de datos en Pseudocódigo: Reglas definidas para los tipos de datos: NUMERO Referidos a cualquier número. por lo que no podrán ser usadas como nombre de variable. LOGICO Referido a los dos posibles valores lógicos (VERDADERO y/o FALSO). etc. char y boolean. Existen diferentes tipos de datos. byte. Con una variable numérica se puede realizar operaciones matemáticas (suma. todos los datos son derivados de ocho tipos de datos básicos. TIPOS DE DATOS Definición: Los tipos de datos permiten declarar las variables. En pseudocódigo y diagrama de flujo se utilizan tres tipos (NUMERO. TEXTO y LOGICO). los cuales están divididos –generalmente. En este contexto. ENTERO y REAL). Hay que tener presente que las palabras NUMERO. Juan José Flores Cueto. En Java. 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.

Existen sólo dos valores que se pueden almacenar en este tipo de variable: verdadero y falso. luego las sumas y restas. 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. direcciones. Pag. Para alterar esta prioridad se podrá utilizar los paréntesis. Las variables tipo texto son útiles para almacenar cualquier cadena de texto. Primero se resuelven las multiplicaciones y divisiones. 67 . tales como nombres de personas. etc.ESTRUCTURAS FUNDAMENTALES PARA LA SOLUCIÓN DE PROBLEMAS Por ejemplo: Una serie de operaciones. Ejemplos: nombre = “Pedro” letra = ‘J’ Donde nombre y siglas son variables que previamente han sido declaradas como variables de tipo texto. por lo que no está permitido que se usen como nombres de variables. Variables de texto: Permiten almacenar datos de tipo texto y datos de tipo caracter (TEXTO y CARACTER). Las palabras VERDADERO y FALSO constituyen reglas en pseudocódigo y diagrama de flujo. Ejemplos: masculino = VERDADERO estudiante = FALSO Donde masculino y estudiante son variables que previamente han sido declaradas como variables de tipo lógico. número de AFP. Variables lógicas: Permiten almacenar sólo tipo de datos lógicos.

767 se le suma 1. pero entre ellos se pueden agrupar como datos de tipo NUMERO (byte. Es importante mencionar que Java no realiza una comprobación de rangos.372. long) y valores de tipo REAL (float. en Java los tipos de datos simples no dependen de la plataforma ni del sistema operativo. double). Las palabras reservadas de Java no pueden ser utilizadas como nombre de variable. Es importante destacar que estos ocho tipos de datos simples son diferentes. Tipo Descripción Longitud Rango byte Tipo byte 1 byte -128 … 127 short Entero corto 2 bytes -32768 … 32767 -2.223. char Caracter 2 bytes 0 … 65. double.036. Los valores de los datos de tipo String van entre comillas dobles (ejemplo. sino un tipo de dato compuesto (a pesar de ello. tipo CARACTER (char) y tipo LOGICO (boolean). int. “Hola”) y permite almacenar cadenas de texto. se utiliza la clase String.4*10-38 … ±3. mientras que los de tipo char van entre comillas simples (ejemplo. Las palabras reservadas que permiten declarar variables son byte.854.4*1038 de simple precisión Real con coma flotante double 8 bytes ±1.036.775. Los datos tipo NUMERO (datos numéricos) se pueden dividir en valores de tipo ENTERO (byte.7*10308 de doble precisión. long. double). Un entero de tipo int siempre tendrá 4 bytes.854.768 y no se producirá ningún error de ejecución. long. por lo que no habrá sorpresas al migrar un programa de un sistema operativo a otro.147.775.808 long Entero largo 8 bytes 9. Pag.807 Real en coma flotante float 4 bytes ±3.223.147.372. 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.535 boolean Lógico 1 byte true / flase A diferencia de otros lenguajes de programación. short. Ing. el resultado será -32. Juan José Flores Cueto. short. y forman parte de las palabras reservadas del lenguaje.483.7*10-308 … ±1. short. Los String en Java no son un tipo de dato básico (simple). se puede utilizar como un tipo de dato simple para definir datos de tipo TEXTO en Java). int. Para representar una cadena de caracteres en Java. float.647 -9. Por ejemplo: si a una variable de tipo short con el valor 32.648 int Entero 4 bytes 2. ‘K’) y sólo permiten almacenar un solo caracter. int. char y boolean.483. 68 . float.

// La siguiente línea genera error.ESTRUCTURAS FUNDAMENTALES PARA LA SOLUCIÓN DE PROBLEMAS Como regla general. Clase PrgTipoDato02 package dominioDeLaAplicacion . si se declara una variable con un tipo de dato específico. // La siguiente línea genera error.3 . 69 . Ejemplos: Clase PrgTipoDato01 package dominioDeLaAplicacion . Pag. } } Observación: No se puede almacenar un número real grande (double) en una variable entera (int).3 . una variable solo puede almacenar valores de acuerdo al tipo de dato con el que fue declarado. class PrgTipoDato01 { public static void main ( String arg [ ] ) { double numReal = 4. class PrgTipoDato02 { public static void main ( String arg [ ] ) { double numRealDouble = 2. float numRealFloat . En base a esto. al momento de compilar. System. System.println ( numRealFloat ) . numEntero = numReal .out.out. numRealFloat = numRealDouble .println ( numEntero ) . } } Observación: No se puede almacenar un número real grande (double) en una variable real (float). int numEntero . si se declara una variable con un tipo de dato específico y se intenta almacenar un valor de distinto tipo. Es decir. el programa indicará un error. solo podrá almacenar valores de dicho tipo de dato.

70 . class PrgTipoDato03 { public static void main ( String arg [ ] ) { boolean estado = true . Pag. Juan José Flores Cueto.out. System. // La siguiente línea genera error.println ( caracter ) . } } Observación: No se puede almacenar un valor lógico (boolean) en una variable caracter (char). char caracter . Clase PrgTipoDato03 package dominioDeLaAplicacion . caracter = estado . Ing.

Conversión implícita de datos en Java: La conversión implícita de datos se da entre un tipo de dato de menor precisión a un tipo de dato de mayor precisión (mas amplio. Clase PrgTipoDato04 package dominioDeLaAplicacion . short. y la excepción para estos casos se denomina conversión de datos. int. Pero como toda regla. numEnteroGrande = numEntero . float y double. short.ESTRUCTURAS FUNDAMENTALES PARA LA SOLUCIÓN DE PROBLEMAS 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. long. A continuación se muestra los tipos de datos numéricos ubicados desde el tipo de dato de menor precisión al tipo de dato de mayor precisión: byte. int. A través de la conversión de datos se puede almacenar en una variable valores de tipo diferente al tipo de dato con el que se declaró la variable. Esto es válido ya que el tipo de dato long en Java es de mayor precisión que el tipo de dato int. mas grande) y son generadas automáticamente por el compilador Java. // La siguiente línea no genera error.println ( numEnteroGrande ) . } } Observación: Al ejecutar esta aplicación el compilador utiliza la conversión implícita y convierte un número entero (int) en un número entero largo (long). long numEnteroGrande . La conversión de datos se aplica generalmente sobre los tipos de datos numéricos. Pag.out. 71 . También se puede aplicar sobre el tipo de dato char. class PrgTipoDato04 { public static void main ( String arg [ ] ) { int numEntero = 5 . esta también tiene su excepción. float y double Ejemplos. es decir entre datos de tipo byte. // Se visualiza 5 System. long.

class PrgTipoDato05 { public static void main ( String arg [ ] ) { char caracter = ‘a’ . Este tipo de conversión de datos se le denomina también cast (casting). se da de un tipo de dato de menor precisión a uno de mayor precisión. } } Observación: Al ejecutar esta aplicación el compilador utiliza la conversión implícita y convierte la letra ‘a’ en un valor real (double) equivalente a su código ASCII.0 (la letra a en código ASCII es 97). si el lado derecho de la expresión tiene un tipo de dato más amplio que el lado izquierdo. Lado izquierdo de la expresión En caso contrario. por lo que se visualiza 97. 72 . La conversión implícita de datos se realiza al mezclar variables de distinto tipo en expresiones matemáticas o al ejecutar instrucciones o sentencias de asignación. es necesario que el lado izquierdo de la expresión tenga un tipo de dato más amplio que el resultado de evaluar el lado derecho: numReal = numEntero + 5 . Estás conversiones son inseguras y puedan dar lugar a errores. // La siguiente línea no genera error. El cast se realiza colocando entre paréntesis Pag. Clase PrgTipoDato05 package dominioDeLaAplicacion . double numReal . Juan José Flores Cueto. La conversión implícita de datos en Java. // Se visualiza 97.0 System. Ing. numReal = caracter .out. el programa indicará un error. Conversión explicita de datos en Java (casting): Las conversiones de un tipo de dato de mayor precisón a otro tipo de dato de menor precisión requieren que se coloque en forma explicita en los programas. al momento de compilar. En ambos casos.println ( numReal ) .

num2 = 3 . // La siguiente línea no genera error. Finalmente. } } Observación: Al ejecutar esta aplicación el compilador utiliza la conversión explícita (casting) para poder almacenar el resultado de una división de numeros reales (double) en una variable entera (int). entre otras. num2 = 3 . div = num1 / num2 . int div .out. Clase PrgTipoDato06 package dominioDeLaAplicacion . System. System. 73 . Ejemplo. en el capítulo III se tratán las clases Wrappers que envuelven los tipos de datos simples y también permiten realizar operaciones de conversión. class PrgTipoDato07 { public static void main ( String arg [ ] ) { double num1 = 20. int div . // Se visualiza 6.println ( div ) .ESTRUCTURAS FUNDAMENTALES PARA LA SOLUCIÓN DE PROBLEMAS el tipo de dato al que se desea convertir el resultado de una expresión.out. // La siguiente línea genera error. Pag. class PrgTipoDato06 { public static void main ( String arg [ ] ) { double num1 = 20.println ( div ) . } } Clase PrgTipoDato07 package dominioDeLaAplicacion . div = ( int ) ( num1 / num2 ) .

Ing. Pag. Juan José Flores Cueto. 74 .

Pag. se inicia la ejecución de la siguiente hasta completar la ejecución de todas las instrucciones que forman parte de la secuencia. Este tipo de estructura permite mostrar información a través de un dispositivo de salida de una computadora.ESTRUCTURAS FUNDAMENTALES PARA LA SOLUCIÓN DE PROBLEMAS ESTRUCTURAS LÓGICAS ESTRUCTURAS LÓGICAS DE SECUENCIA Definición: Las Estructuras Lógicas de Secuencia son aquellas en las que una instrucción sigue a otra en secuencia. System En Java. Estructura para la salida de información Definición: La salida de información se refiere a la forma o mecanismos que se emplean para poder conocer el resultado de un determinado algoritmo. Tipos: 1. ESCRIBIR En pseudocódigo. finalizada la ejecución de una instrucción.La clase. Representación: Para representar la salida o visualización de la información se utiliza: . Las instrucciones se ejecutan una a una de tal modo que. .El símbolo. En diagrama de flujo. Las Estructuras Lógicas de Secuencia son las estructuras lógicas más comunes y constituyen la base sobre la cual se desarrollan las demás estructuras lógicas. 75 . .La regla.

Cuando se utiliza la palabra “print” se mostrará la cadena de texto y el cursor permanecerá al final de la cadena de texto mostrada. lo realizará de la siguiente manera: ESCRIBIR “Hola Mundo” “Hola Mundo” Si desea codificarlo en el lenguaje de programación Java.println (“Hola Mundo”).out. deberá realizarlo de la siguiente manera: System. Se puede utilizar la palabra “print” o “println”. Por ejemplo.El símbolo. System. y cuando se utiliza la palabra “println” se mostrará la cadena de texto y el cursor se colocará en la siguiente línea. 2. Si desea visualizar la cadena de texto “Hola Mundo” utilizando pseudocódigo y diagrama de flujo. . En diagrama de flujo. Pag. Ing. posteriormente. la información necesaria. Representación: Para representar la entrada de datos se utiliza: . Este tipo de estructura permite ingresar datos a través de un dispositivo de entrada de una computadora.print (“Hola Mundo”).La regla. 76 . el contenido de una variable o el resultado de una operación matemática. LEER En pseudocódigo. Juan José Flores Cueto. Es importante mencionar que se puede visualizar una cadena de texto.out. Estructura para la entrada de datos Definición: La entrada de datos se refiere a la forma o mecanismos que se emplean para ingresar los datos que necesita un algoritmo para procesarlos y obtener.

que esta clase permitirá ingresar datos en forma tradicional y será usada para la codificación de algoritmos en Java. Permite ingresar un leerDouble() número con parte decimal. En consecuencia.class Permite ingresar un leerLong() número entero largo. 77 .La clase.ESTRUCTURAS FUNDAMENTALES PARA LA SOLUCIÓN DE PROBLEMAS . La clase Lectura va a facilitar el ingreso de datos en forma tradicional. Permite ingresar un leerChar() caracter (una sola letra o número) Permite ingresar un leerInt() número entero. 1 Se puede revisar el uso de la clase Math2 en el primer libro del autor. se trata en detalle la clase Lectura. 1 Esta clase es una implementación mejorada de la clase Math2 Es importante mencionar. Permite ingresar un leerFloat() número con parte decimal. En el Apéndice. se utilizará una clase en Java desarrollada especialmente para que cumpla dicha finalidad. Es importante mencionar que el lenguaje de programación Java no proporciona una clase que facilite el ingreso de datos en forma tradicional. CLASE MÉTODO DESCRIPCIÓN Permite ingresar una leerString() cadena de texto. Pag. La clase Lectura fue desarrollada por la Srta. titulado “Método para la solución de problemas utilizando la programación orientada a objetos – Aspectos básicos”. Lectura. Lectura En Java. Gisella Guzmán.

78 . Pag. *.. Estructura para operaciones aritméticas y de cálculo Definición: Las operaciones aritméticas y de cálculo se refieren a la forma o mecanismos que se emplean para poder procesar los datos ingresados y obtener la información necesaria. 3. Representación: Para representar las operaciones aritméticas se utilizan los mismos signos que se emplean en la aritmética tradicional (+. -.. /). aparecer entre las reglas INICIO y FIN. Juan José Flores Cueto. Estas instrucciones se ejecutarán FIN una tras otra. Suma: + Resta: - Multiplicación: * División: / Las operaciones lógicas se representan de la siguiente manera: En pseudocódigo y diagrama de flujo: Y lógico: Y (AND) O lógico: O (OR) Negación: N (NOT) En Java: Y lógico: && O lógico: || Negación: ~ Formatos: Formato para diseñar algoritmos: Pseudocódigo EXPLICACIÓN: INICIO Todas las instrucciones que son parte de la solución del problema deberán Instrucciones . Ing.

. Pag. Al conjunto de pasos que forman parte de un programa de computadora se les denomina sentencias. El método main ( ) // sentencias es conocido como el método . métodos.ESTRUCTURAS FUNDAMENTALES PARA LA SOLUCIÓN DE PROBLEMAS Diagrama de Flujo EXPLICACIÓN: INICIO Todas las instrucciones que son parte de la solución del problema aparecerán entre el siguiente símbolo: Instrucciones . se puede afirmar class NombreClase { que todas las sentencias que son parte de la solución public static void main (String a[]) { aparecerán dentro de los .. Dentro del símbolo se indicará si es el FIN inicio o el fin de la solución con las reglas INICIO o FIN.. principal. y es desde donde se } inicia la ejecución de las } sentencias.. 79 ... Formato para codificar algoritmos: Lenguaje de Programación Java EXPLICACIÓN: Inicialmente. Al conjunto de pasos que forman parte de un algoritmo se les denomina instrucciones...

Estructuras lógicas de decisión simple Definición: Una estructura de decisión simple “SI. de tal forma que en función de una condición o el valor de una variable. Tipos: 1. Formato para diseñar algoritmos: Pseudocódigo EXPLICACIÓN: Si la condición resulta verdadera. Juan José Flores Cueto. FINSI” permite alterar el flujo secuencial (o pasos secuenciales) de una solución ejecutando un conjunto de pasos adicionales si el resultado de una condición lógica es verdadera. se pueda desviar la secuencia de la solución entre diferentes alternativas. Este tipo de estructura es útil cuando se tiene la posibilidad de escoger una determinada opción. se ejecutan las instrucciones que se SI (condición) encuentran entre las reglas ENTONCES ENTONCES y FINSI.. FINSI Si la condición resulta falsa. Pag. Las Estructuras Lógicas de Decisión son conocidas también como Estructuras de Selección. 80 . Ing. ESTRUCTURAS LÓGICAS DE DECISIÓN Definición: Las Estructuras Lógicas de Decisión son construcciones que permiten alterar el flujo secuencial de una solución. instrucciones.... no se ejecutan las instrucciones que se encuentran entre las reglas ENTONCES y FINSI.

81 . no se ejecutan las sentencias que se } encuentran entre las llaves { }. sigue el flujo etiquetado con la regla o pauta “FALSO” y no se ejecutan las instrucciones que se encuentran en el flujo etiquetado con la regla “VERDADERO”. Pag... sentencias... se .. FALSO instrucciones.. Si la condición resulta falsa.ESTRUCTURAS FUNDAMENTALES PARA LA SOLUCIÓN DE PROBLEMAS Diagrama de Flujo EXPLICACIÓN: Si la condición resulta verdadera. se ejecutan las VERDADERO instrucciones que se condición ? encuentran en el flujo etiquetado con la regla “VERDADERO”. se ejecutan las sentencias que se if (condición) { encuentra entre las llaves { }. Formato para codificar algoritmos: Lenguaje de Programación Java EXPLICACIÓN: Si la condición resulta verdadera.. .. Si la condición resulta falsa.

82 . se ejecuta otro conjunto de pasos. ejecutando un conjunto de pasos dependiendo del resultado de una condición lógica. En ningún caso se podrá ejecutar ambos conjuntos de pasos a la vez.. en ningún caso se podrá ejecutar ambos grupos. Pag. FINSI” permite alterar el flujo secuencial (o pasos secuenciales) de una solución. se ejecuta un conjunto de pasos. se ejecutan las instrucciones que se encuentran entre las reglas SI (condición) ENTONCES y SINO.. Sólo se ejecuta uno de los grupos de instrucción. SINO.. y si la condición resulta falsa. Ing. Si la condición resulta falsa se SINO ejecutan las instrucciones que se instrucciones. Estructuras lógicas de decisión doble Definición: Una estructura de decisión doble “SI. Si la condición resulta verdadera. 2.. Formato para diseñar algoritmos: Pseudocódigo EXPLICACIÓN: Si la condición resulta verdadera.. encuentran entre las reglas SINO y FINSI FINSI. ENTONCES instrucciones.. Juan José Flores Cueto... Este tipo de estructura es útil cuando se tiene la necesidad de escoger entre dos posibles opciones.

. se ejecutan las sentencias que se if (condición) { encuentran entre las llaves { } sentencias... .... else { sentencias. se ejecutan las instrucciones que se encuentran en el flujo etiquetado con la regla “FALSO”.. instrucciones instrucciones Si la condición resulta falsa.ESTRUCTURAS FUNDAMENTALES PARA LA SOLUCIÓN DE PROBLEMAS Diagrama de Flujo EXPLICACIÓN: Si la condición resulta VERDADERO FALSO verdadera.. . se ejecutan las condición ? instrucciones que se encuentran en el flujo etiquetado con la regla “VERDADERO”. ubicadas después de la palabra } reservada if. .. Si la condición resulta falsa. Formato para codificar algoritmos: Lenguaje de Programación Java EXPLICACIÓN: Si la condición resulta verdadera. 83 .. Pag... se } ejecutan las sentencias que se encuentran entre las llaves { } ubicadas después de la palabra reservada else..

. para cada posible valor que pueda tener la variable se define un conjunto de pasos a ejecutar.. después de una de las reglas CASO. Este tipo de estructura es útil cuando se tiene la necesidad de escoger entre más de dos opciones. Si el valor de la variable no es igual a CASO (valor n) : ninguno de los valores colocados instrucciones. se ejecutan CASO (valor 1) : las instrucciones que están dentro del instrucciones... Ing. se ejecutan las instrucciones que están OTROS instrucciones. CASO (valor 2) : instrucciones. dentro de la regla OTROS. Juan José Flores Cueto. Pag. La regla OTROS es opcional (es decir. También se define un conjunto de pasos a ejecutar en caso que uno de los valores de la variable no tenga asociado un conjunto de pasos a ejecutar.. puede FINCUANDO aparecer como no). Formato para diseñar algoritmos: Pseudocódigo EXPLICACIÓN: Si el valor de la variable es igual a uno de los valores colocados después de CUANDO (variable) SEA una de las reglas CASO. Estructuras lógicas de decisión múltiple Definición: Una estructura de decisión múltiple “CUANDO. 84 .. 3. Generalmente.... mismo. FINCUANDO” permite alterar el flujo secuencial de una solución ejecutando un conjunto de pasos dependiendo del valor de una variable..

El flujo con la regla OTROS es opcional. 85 .ESTRUCTURAS FUNDAMENTALES PARA LA SOLUCIÓN DE PROBLEMAS Diagrama de Flujo variable ? valor 1 valor 2 valor n OTROS instrucciones instrucciones instrucciones instrucciones EXPLICACIÓN: Si el valor de la variable es igual a uno de los valores que tiene como etiqueta el flujo. Pag. se ejecuta el flujo que tiene como regla OTROS. Si el valor de la variable no es igual a uno de los valores de las etiquetas de los flujos. se ejecutan las instrucciones que están seguidas del flujo (las que indica la flecha).

se debe emplear correctamente los formatos establecidos. Formato para codificar algoritmos: Lenguaje de Programación Java EXPLICACIÓN: Si el valor de la variable es igual a uno de los valores colocados después de la palabra reservada case (valor 1. se deberá utilizar números enteros después de la palabra reservada case. Cuando se diseñe un algoritmo que necesite utilizar estructuras de decisión. 86 . se ejecutan las sentencias que están dentro de la palabra reservada default. Si el valor de la variable no es igual a ninguno de los valores colocados default : sentencias... Pag. al momento de ejecutar un programa. Es importante tener presente que en Java se deberá usar la palabra reservada break al final de cada bloque de sentencias si se desea que cada alternativa (case) ejecute un grupo de sentencias sin que ejecute el grupo de sentencias de las alternativas (case) que están a continuación... Ing. Si la variable es de tipo entero (definida con la palabra reservada int). La palabra reservada default es opcional (es decir puede aparecer como no). final (es decir hasta la llave) a no ser case valor 2 : que encuentre una palabra reservada sentencias. se deberá utilizar un caracter encerrado entre comillas simples después de la palabra reservada case. después de una de las palabras } reservadas case. se ejecutan las sentencias que case valor 1 : están dentro del mismo hasta llegar al sentencias... valor switch (variable) { 2. caso contrario. En caso que la variable sea de tipo caracter (definida con la palabra reservada char). sentencias.. break entre las sentencias que se case valor n : ejecutan. ya que estos constituyen lo que denominamos un “estándar” o acuerdo.. También es importante mencionar que en Java la variable utilizada junto a la palabra reservada switch sólo puede ser de tipo entero o de tipo caracter. Cuando se codifique un algoritmo recuerde que se tiene que seguir las reglas del lenguaje de programación que usará. etc). se dará con la sorpresa que tendrá errores de sintaxis. Juan José Flores Cueto.

Tipos: 1. FINDESDE” permite repetir una instrucción.ESTRUCTURAS FUNDAMENTALES PARA LA SOLUCIÓN DE PROBLEMAS ESTRUCTURAS LÓGICAS DE REPETICIÓN Definición: Las Estructuras Lógicas de Repetición son construcciones que permiten repetir determinadas partes de una solución. 87 . . instrucción n FINDESDE Pag... FINDESDE” con frecuencia se utiliza para iteraciones sencillas en donde se repite un bloque de instrucciones un cierto número de veces y después se detiene. o un bloque de instrucciones. un número determinado de veces o hasta que una condición se cumpla. Las Estructuras Lógicas de Repetición son conocidas también como estructuras de iteración o bucles. ... en función de una condición o el valor de una variable. Este tipo de estructura es útil cuando se necesita repetir una instrucción o bloque de instrucciones un cierto número de veces. de tal forma que. Una estructura lógica de repetición “DESDE. Formato para diseñar algoritmos: Pseudocódigo DESDE i = valorInicial HASTA valorFinal INCREMENTA valor instrucción 1 . se pueda repetir un conjunto de pasos un determinado número de veces. Estructura lógica de repetición “DESDE” Definición: Una estructura de repetición “DESDE.

se volverá a ejecutar las instrucciones o bloque de instrucciones ubicadas entre las reglas DESDE y FINDESDE. 2. Aquí se evalúa si la variable índice es igual a valorFinal. Juan José Flores Cueto. 88 . Incremento: INCREMENTA valor Cada vez que finaliza la ejecución de las instrucciones o bloque de instrucciones ubicadas entre las reglas DESDE y FINDESDE. Esta variable funciona como un índice que permite mantener el control sobre el número de veces que se repiten las instrucciones ubicadas entre las reglas DESDE y FINDESDE.. 3. Inicialización: DESDE i = valorInicial Esta parte se ejecuta una sola vez al momento de iniciar la ejecución de la estructura lógica de repetición DESDE.. es decir si ya llegó HASTA valorFinal. se ejecuta esta parte y se INCREMENTA (aumenta) el valor de la variable índice “i” según se indique en valor. Si la variable índice no es igual a valorFinal. El equivalente de esta estructura en diagrama de flujo se muestra a continuación: Pag. se utiliza la regla DECREMENTA en lugar de la regla INCREMENTA. EXPLICACIÓN: Esta estructura tiene tres partes: 1. Ing. También existe la posibilidad de reducir el valor de la variable índice “i”. en este caso. FINDESDE y permite asignar un valor inicial a la variable “i” o la que se utilice en vez de ésta. Prueba: HASTA valorFinal Una vez que se termina de INCREMENTAR o DECREMENTAR la variable índice. se finaliza la ejecución del DESDE y se continúa con la ejecución de la instrucción ubicada después de la regla FINDESDE. En caso que la variable índice sea igual a valorFinal. se procede a ejecutar esta parte.

la cual se muestra a continuación: El fin de las instrucciones o bloque de instrucciones que forman parte de la regla DESDE. EXPLICACIÓN: Las tres partes de esta estructura se representan en el diagrama de flujo a través de las siguientes reglas: DESDE i HASTA z Aquí “i” es la variable índice y “z” es el valor que el índice “i” debe alcanzar para finalizar la ejecución.ESTRUCTURAS FUNDAMENTALES PARA LA SOLUCIÓN DE PROBLEMAS Diagrama de Flujo DESDE i HASTA z FALSO INCREMENTA x VERDADERO . Ambas reglas se encuentran dentro del símbolo que representa la regla o pauta DESDE. Pag.. instrucciones. INCREMENTA x Aquí “x” representa el valor que se incrementará a la variable índice cada vez que se termine la ejecución de las instrucciones que forman parte de la estructura... se representa por el siguiente símbolo: Este último símbolo es equivalente a la regla FINDESDE utilizada en pseudocódigo. 89 ... ..

Juan José Flores Cueto. incremento) { sentencias.. 90 . se continúa con la ejecución de las sentencias o bloque de sentencias que pertenecen a la estructura de repetición. 2. la regla DESDE está representada por la sentencia for. Ing. en el caso que sea falso. Pag.. condición .. Estructura lógica de repetición “MIENTRAS” Definición: Una estructura de repetición “MIENTRAS. se finaliza la ejecución continuando con la siguiente sentencia. FINMIENTRAS”. Al igual que en pseudocódigo y diagrama de flujo. Este tipo de estructura es útil cuando se necesita repetir una instrucción o bloque de instrucciones un número de veces no determinado. En pseudocódigo y diagrama de flujo se utiliza la regla HASTA valorFinal. Es importante indicar que el inicio y fin de la sentencia for se representan con llaves ({ }).... } EXPLICACIÓN: En Java. mientras que en Java se utiliza una condición lógica (ejemplo: i >10). FINDESDE”. permite repetir una instrucción o un bloque de instrucción mientras que una condición se cumpla o ésta sea verdadera. en Java esta estructura está constituida por tres partes. al igual que una estructura lógica de repetición “DESDE. Esta parte constituye la prueba en Java. Formato para codificar algoritmos: Lenguaje de Programación Java for ( i = valorInicial . Si la condición es verdadera.

El equivalente de esta estructura en diagrama de flujo se muestra a continuación. 91 . no se ejecutan las instrucciones que están dentro de la estructura lógica de repetición MIENTRAS. Una vez evaluada la condición lógica. podemos obtener dos posibles resultados: Si el resultado de evaluar la condición lógica es verdadera. Si el resultado de evaluar la condición lógica es falsa. FINMIENTRAS y se evalúa. . Esto significa que mientras la evaluación de la condición lógica resulte verdadera... Pag.. se procede a ejecutar las instrucciones que están dentro de la estructura lógica de repetición MIENTRAS. se ejecutará la estructura lógica de repetición MIENTRAS. FINMIENTRAS lo primero que se realiza es la evaluación de la condición lógica ubicada junto a la regla MIENTRAS. nuevamente. la condición lógica. instrucción n FINMIENTRAS EXPLICACIÓN: Cuando se ejecuta la estructura lógica de repetición MIENTRAS... . FINMIENTRAS y se continúa con la ejecución del algoritmo.ESTRUCTURAS FUNDAMENTALES PARA LA SOLUCIÓN DE PROBLEMAS Formato para diseñar algoritmos: Pseudocódigo MIENTRAS (condición) instrucción 1 .. se observa donde se ubica la condición lógica y los flujos etiquetados con las reglas “VERDADERO” y “FALSO”. En la figura.. FINMIENTRAS y que sólo finalizará cuando la evaluación de la condición lógica resulte falsa..

Ing..... Formato para codificar algoritmos: Lenguaje de Programación Java while (condición) { sentencias.... } Pag. 92 .. instrucciones. Diagrama de Flujo FALSO condición ? VERDADERO . Juan José Flores Cueto. .

. al igual que en pseudocódigo y diagrama de flujo. Pag. MIENTRAS”. se continúa con la ejecución de las sentencias o bloque de sentencias que pertenecen a la estructura de repetición. Esta condición lógica constituye la prueba en Java.. 93 . FINMIENTRAS” prueba la condición antes de ejecutar la instrucción o bloque de instrucciones. en el caso que sea falso.. Estructura lógica de repetición “HACER” Definición: Una estructura lógica de repetición “HACER. se utiliza una condición lógica (ejemplo: i >10) para verificar si se ejecuta la estructura o no... MIENTRAS” ejecuta al menos una vez las instrucciones o bloque de instrucciones antes de probar la condición. lo que hace posible que dichas instrucciones no se ejecuten si la condición es falsa la primera vez que se prueba la condición.. Este tipo de estructura es útil cuando se necesita repetir una instrucción o bloque de instrucciones un número de veces no determinado. FINMIENTRAS”. Es importante indicar que el inicio y fin de la sentencia while se representan con llaves ({ }). se finaliza la ejecución continuando con la siguiente sentencia.. La estructura lógica de repetición “HACER. Si la condición es verdadera.ESTRUCTURAS FUNDAMENTALES PARA LA SOLUCIÓN DE PROBLEMAS EXPLICACIÓN: En Java. al igual que una estructura lógica de repetición “DESDE... siendo necesario ejecutar la instrucción o bloque de instrucciones por lo menos una vez. En la sentencia while. permite repetir una instrucción o un bloque de instrucciones mientras que una condición se cumpla o sea verdadera. La principal diferencia entre ambos consiste en que la estructura lógica de repetición “MIENTRAS. la regla MIENTRAS está representada por la sentencia while. FINDESDE” y una estructura lógica de repetición “MIENTRAS.. 3.

. . nuevamente. caso contrario. nuevamente la condición lógica. Ing. Pag. continuando con la siguiente instrucción del algoritmo. MIENTRAS y se evalúa. se vuelve a ejecutar la estructura.. se realiza la evaluación de la condición lógica ubicada junto a la regla MIENTRAS. Si el resultado de evaluar la condición lógica es falso. se continúa con la ejecución del algoritmo. Si al evaluar la condición lógica ésta resulta verdadera.. Juan José Flores Cueto.. Formato para diseñar algoritmos: Pseudocódigo HACER instrucción 1 .. Al final. . se procede a ejecutar. Esto significa que la estructura lógica de repetición HACER. instrucción n MIENTRAS (condición) EXPLICACIÓN: Cuando se ejecuta la estructura lógica de repetición HACER. MIENTRAS se procede a ejecutar las instrucciones que están dentro de la misma.. finaliza la ejecución de la estructura. MIENTRAS se ejecuta por lo menos una vez antes de ser evaluada la condición lógica. 94 . Una vez evaluada la condición lógica se puede obtener dos posibles resultados: Si el resultado de evaluar la condición lógica es verdadero. las instrucciones que están dentro de la estructura lógica de repetición HACER.

.... Pag. 95 . . En la figura.. VERDADERO condición ? FALSO Formato para codificar algoritmos: Lenguaje de Programación Java do { sentencias.. Diagrama de Flujo . } while (condición) .ESTRUCTURAS FUNDAMENTALES PARA LA SOLUCIÓN DE PROBLEMAS El equivalente de está estructura en diagrama de flujo se muestra a continuación. instrucciones . se observa donde se ubica la condición lógica y los flujos etiquetados con las reglas “VERDADERO” y “FALSO”...

la regla HACER está representada por la sentencia do. 96 . Pag. Esta condición lógica constituye la prueba en Java. Es importante indicar que el inicio y fin de la sentencia do se representan con llaves ({ }). En la sentencia do. continuando con la siguiente sentencia. Si la condición es verdadera. al igual que en pseudocódigo y diagrama de flujo. para verificar si se vuelve a ejecuta la estructura o no. en el caso que sea falso. se vuelve a ejecutar las sentencias o bloque de sentencias que pertenecen a la estructura de repetición. se finaliza la ejecución. Juan José Flores Cueto. Ing. se utiliza una condición lógica (ejemplo: i >10) al final de la estructura. EXPLICACIÓN: En Java.

Para esto. Esta sentencia se utiliza para volver explícitamente de un método. sin analizar la condición y sin ejecutar el resto de código del cuerpo del bucle. esta instrucción de bifurcación es conocida como la sentencia break y tiene tres usos: ƒ Permite finalizar una secuencia de sentencias en un switch (específicamente en el case). esta instrucción de bifurcación es conocida como la sentencia continue. Es decir.ESTRUCTURAS FUNDAMENTALES PARA LA SOLUCIÓN DE PROBLEMAS Instrucciones de bifurcación: Muchas veces es necesario cambiar o alterar el flujo normal de ejecución de una solución a otra parte de la misma. ƒ Se emplea para proporcionar un mecanismo que permita cambiar el flujo de ejecución a otra parte de la solución (equivalente a un goto en otros lenguajes de programación). 1. esta instrucción de bifurcación es conocida como la sentencia return. En Java. 3. es decir. se utilizan las instrucciones de bifurcación o salto. Pag. ƒ Se utiliza para salir de un bucle. cuando se encuentra la sentencia continue se ejecuta la siguiente iteracción del bucle sin procesar el resto del código. Instrucción “TERMINAR”. Instrucción “RETORNAR” En Java. 97 . esta sentencia permite que el control de la ejecución de la solución vuelva al método llamante. 2. Esta sentencia permite salir anticipadamente de una iteracción de un bucle. Instrucción “CONTINUAR” En Java.

de Repetición. Juan José Flores Cueto. Mapa de Estructuras Lógicas detallado: Utilizando las estructuras lógicas fundamentales y las instrucciones de bifurcación. Las estructuras lógicas fundamentales y las instrucciones de bifurcación se resumen a continuación: Estructuras Lógicas. 98 . “LEER” “SI” “DESDE” “TERMINAR” “ESCRIBIR” “SI / SINO” “MIENTRAS” “CONTINUAR” “PROCESAR” “CUANDO” “HACER” “RETORNAR” Pag. Ing. Estructuras Lógicas Estructuras Lógicas Estructuras Lógicas Instrucciones de Secuencia. de Decisión. para luego ser codificados en un lenguaje de programación. se pueden desarrollar algoritmos de tal forma que estos puedan ser diseñados en pseudocódigo o diagrama de flujo. de Bifurcación.

• Definir los paquetes y utiliza el lenguaje de • Establecer como se desarrollar el diagrama de programación Java. (Utilice UML). Dichas etapas y pasos han sido desarrollados en su totalidad en los primeros 22 problemas. Pag. • Definir las clases que serán parte de la solución del problema. Establecer la dependencia. 99 . (Utilice UML). También se puede utilizar esta división en el desarrollo de las soluciones. Sin embargo. para los siguientes problemas hasta el final del presente capítulo (capítulo II). • Diseñar el algoritmo para el método principal. Se utiliza pseudocódigo. problema (proceso). Esto permite presentar una mayor cantidad de problemas con sus respectivas codificaciones. se presentan las etapas del Método de las 6’D con sus respectivos pasos. En forma general. ENUNCIADO DEL PROBLEMA Etapa 02 Etapa 03 Etapa 04 Definición Diseño Desarrollo Solución Solución Solución • Determinar la información deseada (salida). Se de entrada (entrada). mientras que en la Etapa 04 - “Desarrollo de la solución” se tiene la parte de codificación (paso 1). solo se ha incluido la Etapa 04 – “Desarrollo de la solución”. solucionará el paquetes respectivo.“Diseño de la lógica” se divide en dos partes: modelamiento (paso 1.ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS MÉTODO DE LAS 6´D – ETAPAS Y PASOS A continuación. • Determinar el nombre del • Codificar el diseño de la • Determinar los datos proyecto. la Etapa 03 . y para los problemas del siguiente capítulo (capítulo III). solución del problema. 2 y 3) y algoritmo (paso 4).

Ing. 100 . Juan José Flores Cueto. Pag.

ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS Problema 01 Etapas para la solución de un problema: Etapa 01 . 101 . ‰ Resultado deseado: Mostrar mensaje “Hola bienvenidos”. Paquete y clase DominioDeLaAplicacion PrgMensaje main() Pag. 1. Para solucionar el problema se desarrollarán las especificaciones del proyecto en UML y el algoritmo en pseudocódigo. Desarrollar un proyecto que permita mostrar un mensaje por la pantalla.Descripción del problema. Definición de Paquete y Clase. ‰ Datos necesarios: Ninguno. Nombre del Proyecto: ProyMensaje 2.Diseño de la lógica. ‰ Procesamiento: El mensaje será almacenado en una variable (mensaje) y posteriormente mostrado. Etapa 02 – Definición de la solución. Etapa 03 . El mensaje a mostrar será “Hola bienvenidos”.

La codificación se desarrolla utilizando el lenguaje de programación Java.out. */ package dominioDeLaAplicacion . Aunque es sencillo. Una vez que se ejecute este programa. mensaje = “ Hola bienvenido ” . podemos apreciar los elementos básicos de un programa en Java. 3. Ing. se visualiza en la pantalla el mensaje “Hola Bienvenido”. System. ESCRIBIR mensaje FIN Etapa 04 – Desarrollo de la Codificación. Diseño de algoritmo para el método principal Algoritmo PrgMensaje . Clase PrgMensaje /* Este es el primer programa.print (mensaje) . public static void main ( String arg [ ] ) { String mensaje . } } Pag.método main() ENTRADA: SALIDA: mensaje INICIO Algoritmo para el método main ( ) diseñado en TEXTO mensaje mensaje = “ Hola bienvenido ” pseudocódigo. Juan José Flores Cueto. 102 . class PrgMensaje { // La ejecución empieza en el método main.

Recuerde que.ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS Análisis de la solución: En primer lugar. A continuación. SALIDA: mensaje Luego tenemos: INICIO Esta palabra permite indicar el inicio de los pasos que constituyen la solución al problema planteado. Aquí se asigna el valor “ Hola bienvenidos ” a la variable mensaje. se estableció el nombre del paquete. para asignar un valor a una variable. Observe que no se ha definido ninguna variable de entrada. en el cual se codifica la solución. Observe que la primera letra se escribe con mayúscula. el nombre es PrgMensaje. Aquí se declara que se utilizará una variable de nombre mensaje cuyo tipo de dato es TEXTO o cadena. Luego tenemos: ENTRADA: En esta parte se hace referencia a todas las variables. 103 . Observe que se ha definido la variable mensaje como una variable de salida. cuya función en el algoritmo es almacenar datos de salida. A continuación: SALIDA: En esta parte se hace referencia a todas las variables. cuya función en el algoritmo es almacenar datos de entrada. A continuación: ESCRIBIR mensaje Pag. Luego tenemos: mensaje = “ Hola bienvenidos ” Esta línea está referida al paso 2 del algoritmo diseñado en pseudocódigo. En este caso. se definió el nombre del proyecto. A continuación: TEXTO mensaje Esta línea está referida al paso 1 del algoritmo diseñado en pseudocódigo. se utiliza el símbolo igual (=). La primera línea: ALGORTIMO PrgMensaje Está referida al nombre del algoritmo. analizaremos el algoritmo del método main ( ) diseñado en pseudocódigo para la solución del problema anterior. el nombre de la clase y el método main ( ).

Java le permite colocar comentarios en el código fuente de los programas. el comentario nos permite identificar el programa. Es decir. Esta línea está referida al paso 3 del algoritmo diseñado en pseudocódigo. */ Este es un comentario. analicemos cada línea de la codificación del algoritmo en el lenguaje de programación Java: En primer lugar. Aunque es sencillo podemos apreciar los elementos básicos de un programa en Java. En Java existen tres tipos de comentarios. Es decir. En nuestro caso. */ es ignorado al momento de ejecutar el programa. A través de la palabra ESCRIBIR se muestra el contenido de la variable mensaje. Tal como la mayoría de lenguajes de programación. y su propósito es describir o explicar el objetivo de un programa a cualquiera que lea el código fuente. Juan José Flores Cueto. se puede utilizar los comentarios para describir paso a paso lo que hace el programa. Los comentarios no son ejecutados. valor que fue asignado a la variable en el paso 2. Los pasos que están entre las palabras INICIO… FIN constituyen la parte más importante del algoritmo y es conocido como “cuerpo del algoritmo”. observamos que el programa empieza con las siguientes líneas: /* Este es el primer programa. 104 . se muestra “ Hola bienvenidos ” . Ahora. Todo aquello que se escribe entre los dos símbolos de comentario de múltiples líneas /*………. Ing. El que se acaba de mostrar se llama comentario de múltiples líneas. Los comentarios de múltiples líneas pueden tener una o varias líneas de longitud. Este tipo de comentario comienza con una barra seguida de un asterisco (/*) y termina donde aparece un asterisco seguido de una barra (*/). Finalmente: FIN Esta palabra permite indicar el fin de los pasos que constituyen la solución al problema planteado. el final del algoritmo. Es decir. En problemas grandes se utilizan los comentarios para explicar para qué sirve cada característica del programa y cómo éstas se ejecutan. Pag.

Finalmente. lo cual nos indica que se declara una clase. Este también es un comentario. A continuación encontramos el nombre de la clase PrgMensaje. En este caso. Esta línea especifica el paquete al cual pertenecerá la clase que se creará con la palabra reservada class. Usa el segundo tipo de comentario disponible en Java y se llama comentario de una sola línea. el nombre del paquete es “dominioDeLaAplicacion”. seguido del nombre se coloca una llave de apertura ( { ). La siguiente línea del programa es: public static void main ( String arg [ ] ) { Pag. La siguiente línea del programa es: // La ejecución empieza en el método main. 105 . En la siguiente línea de código: class PrgMensaje { Observe que en la línea de código anterior se utiliza la palabra reservada class. la cual indica el inicio del cuerpo de la misma. Los comentarios de una sola línea comienzan con dos barras ( // ) y terminan al final de la línea.ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS Observemos la siguiente línea de código: package dominioDeLaAplicacion . El nombre del paquete está a continuación de la palabra reservada package.

En este caso. todas las sentencias en Java terminan en punto y coma. a la variable mensaje se le asigna el valor “ Hola bienvenido ”. se debe de anteponer al nombre de la variable la palabra String. A través de esta sentencia se asigna un valor a la variable. A través de esta línea se declara el uso de la variable mensaje de tipo TEXTO o cadena. Juan José Flores Cueto. Es importante mencionar que esta línea de código termina en punto y coma ( . Recuerde que esto se realizó con las siguientes líneas de código: package dominioDeLaAplicacion . Esta línea de código es conocida como la firma del método main ( ) o método principal. Para asignar valor a una Pag. En este caso. podemos decir que para desarrollar un programa básico en Java necesitamos definir un paquete. En resumen. debido a que Java diferencia las letras mayúsculas de las letras minúsculas. 106 . ). En Java. para declarar una variable de tipo TEXTO o cadena. todas las variables deben ser declaradas antes de ser utilizadas (lo que no es necesario realizar en las herramientas utilizadas para diseñar algoritmos). class PrgMensaje { public static void main ( String arg [ ] ) { } } La siguiente línea del programa es: String mensaje . De hecho. Toda clase en Java. debe tener un valor asignado. La siguiente línea del programa es: mensaje = “ Hola bienvenido ” . que deseamos tenga la posibilidad de ejecutarse. Ing. Además. En Java. deberá tener un método main ( ) exactamente como ha sido escrito. una clase y un método principal o método main ( ). también se debe especificar el tipo de dato que la variable puede almacenar. antes de ser utilizada. el tipo de la variable mensaje es TEXTO o cadena. Es importante mencionar que una variable.

107 . es dominioDeLaAplicacion y PrgMensaje respectivamente. que las siguientes líneas de código se utilizarán en todos los programas que se desarrollen. también uno puede visualizar cadenas y los resultados de operaciones matemáticas.print (mensaje) . se utiliza el signo igual ( = ). Esta es una sentencia de salida por la consola. en este caso. “ Hola bienvenido ” es una cadena. De esta manera.out. En Java se crea una cadena cuando se encierra una secuencia de caracteres entre comillas. package dominioDeLaAplicacion . class PrgMensaje { public static void main ( String arg [ ] ) { } } Pag. La siguiente línea del programa es: System. De hecho. Las dos últimas líneas del programa son: } } La primera indica que el método main ( ) ha terminado y la segunda indica el final de la clase. Sólo variará el nombre del paquete y el nombre de la clase que. De esto se deduce. Hace que el valor de la variable mensaje se visualice por la pantalla.ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS variable.

Definición de Paquete y Clase. Paquete y clase DominioDeLaAplicacion PrgOperaciones main() Pag.Definición de la solución. ‰ Resultado deseado: Mostrar el resultado de las operaciones matemáticas básicas. finalmente. 2. Se requiere mostrar el resultado de sumar. Nombre del Proyecto: ProyOperaciones. Etapa 02 . ‰ Datos necesarios: Ninguno. multiplicación. multiplicar. suma.Descripción del problema. Para solucionar el problema se desarrollarán las especificaciones del proyecto en UML y el algoritmo en pseudocódigo. Juan José Flores Cueto.Diseño de la lógica. luego se realizarán las operaciones matemáticas y. se mostrarán los resultados de dichas operaciones. resta y división de los números 9121236 y 735. 108 . 1. ‰ Procesamiento: Los números serán almacenados en variables. Ing. restar y dividir los números 9121236 y 735. Problema 02 Etapas para la solución de un problema: Etapa 01 . Etapa 03 .

Diseño de algoritmo para el método principal. multi. divi = (double) (num1) / num2. public static void main ( String arg[ ] ) { long num1=9121236. Clase PrgOperaciones package dominioDeLaAplicacion. resta.ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS 3.out. multi = num1 * num2.println (“La resta es: ” + resta). num2=735 NUMERO suma.divi INICIO NUMERO num1=9121236. multi. La codificación se desarrolla utilizando el lenguaje de programación Java. System. num2=735.num2 divi = num1 / num2 ESCRIBIR “La suma es ” + suma ESCRIBIR “La multiplicación es ” + multi ESCRIBIR “La resta es ” + resta ESCRIBIR “La división es ” + divi FIN Etapa 04 .out. resta = num1 – num2. suma = num1 + num2.println (“La suma es: ” + suma). System.método main() ENTRADA: SALIDA: suma. double divi. 109 .Desarrollo de la Codificación. System. class PrgOperaciones { // la ejecución empieza en main. } } Pag. resta.out. System. resta. suma.out.println (“La división es: ” + divi). multi. divi suma = num1 + num2 multi = num1 * num2 resta = num1 . Algoritmo PrgOperaciones .println (“La multiplicación es: ” + multi).

Para solucionar el problema se desarrollarán las especificaciones del proyecto en UML y el algoritmo en pseudocódigo. Convertir y mostrar una cantidad de dinero. en su equivalente en nuevos soles. de una cantidad expresada en dólares. se calculará el equivalente en nuevos soles utilizando la siguiente operación: soles = dolares * tipo El resultado se almacenará en una variable (soles) para luego ser mostrada por pantalla. Juan José Flores Cueto. 2. Luego. ‰ Procesamiento: El monto en dólares y el tipo de cambio serán ingresados por teclado y almacenados en dos variables (dolares y tipo respectivamente). Ingresar la cantidad en dólares y el tipo de cambio.Definición de la solución.Descripción del problema. 110 . Diagrama de paquetes Pag. ‰ Resultado deseado: Mostrar el equivalente. Etapa 03 . Ing. ‰ Datos necesarios: El monto en dólares y el tipo de cambio.Diseño de la lógica. Nombre del Proyecto: ProyDolaresSoles. Etapa 02 . Problema 03 Etapa 01 . Definición de Paquetes y desarrollo de Diagrama de Paquetes. 1. expresado en dólares. en nuevos soles.

Diseño de algoritmo para el método principal. tipo. Algoritmo PrgDolaresSoles . Definición de las Clases. tipo SALIDA: soles INICIO NUMERO dolares.ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS 3. soles LEER dolares. 111 .método main ( ) ENTRADA: dolares. Clases Clases dominioDeLaAplicacion biblioteca 4. tipo soles = dolares * tipo ESCRIBIR soles FIN Pag.

soles .leerDouble ( ) . Etapa 04 . Clase PrgDolaresSoles package dominioDeLaAplicacion . System.print ( “ Ingrese una cantidad de dólares: ” ) . } } Pag.out.out.out. Ing.println ( “ Cantidad equivalente en soles es: ” + soles) .Desarrollo de la Codificación. System.print ( “ Ingrese tipo de cambio del dólar: ” ) . tipo = Lectura. 112 . soles = dolares * tipo . import biblioteca. Juan José Flores Cueto. tipo.leerDouble ( ) . class PrgDolaresSoles { public static void main (String arg[]) { double dolares. La codificación se desarrolla utilizando el lenguaje de programación Java.Lectura . System. dolares = Lectura.

ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS Problema 04 Etapa 01 . 2. n3 y n4 a través del teclado.Descripción del problema. Diagrama de paquetes Pag. n3 y n4 respectivamente). 1. n2. se realizará el cálculo de la nota final sobre la base de la siguiente fórmula: nf = ( n1 + n2 + n3 + ( n4 * 2) ) / 5 El resultado se almacenará en una variable (nf) para luego ser mostrada por pantalla. 113 . Etapa 03 . Ingresar las notas n1. Nombre del Proyecto: ProyNotaFinal. ‰ Procesamiento: Las notas serán ingresadas por teclado y almacenadas en variables (n1. Luego. Etapa 02 .Definición de la solución. Definición de Paquetes y desarrollo de Diagrama de Paquetes. Para solucionar el problema se desarrollarán las especificaciones del proyecto en UML y el algoritmo en pseudocódigo. n2. ‰ Datos necesarios: Las notas del alumno (en este caso tenemos 4 notas). ‰ Resultado deseado: Mostrar la nota final de un determinado alumno. Utilizar la siguiente fórmula: nf = (n1 + n2 + n3 + (n4 * 2)) / 5. Calcular la nota final que ha obtenido un alumno en el curso de programación avanzada.Diseño de la lógica.

Diseño de algoritmo para el método principal. 3.método main ( ) ENTRADA: n1. n2. Definición de las Clases. Clases Clases dominioDeLaAplicacion biblioteca 4. n3. Juan José Flores Cueto. n2. n4 nf = ( n1 + n2 + n3 + ( n4 * 2 ) ) / 5 ESCRIBIR nf FIN Pag. 114 . n4 SALIDA: nf INICIO NUMERO n1 = 0. Ing. Algoritmo PrgNotaFinal . n3 = 0. n3. n4 = 0 LEER n1. n2 = 0.

out.out. System. Clase PrgNotaFinal package dominioDeLaAplicacion . n3 = 0. n3 = Lectura.print ( “ El promedio obtenido por el alumno es : ” ) .print ( “ Ingrese la nota 2 del alumno: ” ) .ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS Etapa 04 .println ( nf ) .print ( “ Ingrese la nota 4 del alumno: ” ) .Desarrollo de la Codificación.print ( “ Ingrese la nota 1 del alumno: ” ) .leerDouble ( ) . 115 . n1 = Lectura.leerDouble ( ) .out. n4 = Lectura. n2 = Lectura. System.out. System. nf = 0 .Lectura .out. } } Pag. n2 = 0.leerDouble ( ) . nf = ( n1 + n2 + n3 + ( n4 * 2)) / 5 .print ( “ Ingrese la nota 3 del alumno: ” ) .leerDouble ( ) . System. class PrgNotaFinal { public static void main (String arg[]) { double n1 = 0. n4 = 0. import biblioteca. System. La codificación se desarrolla utilizando el lenguaje de programación Java. System.out.

Nombre del Proyecto: ProySueldoObrero. Problema 05 Etapa 01 . Etapa 02 . Ingresar el sueldo de un obrero de la empresa “La Poderosa S.A. Luego. utilizando las siguientes operaciones: desc = sueldo * 0. 2.” y calcular su respectivo descuento del 15% por concepto de impuestos y el 5% por concepto de cafetería. 116 .Definición de la solución. ‰ Datos necesarios: El sueldo total del obrero. ‰ Resultado deseado: Mostrar el total de descuento y el sueldo a cobrar de un obrero de la empresa.Descripción del problema. Ing. Diagrama de paquetes Pag. Juan José Flores Cueto. 1. Para solucionar el problema se desarrollarán las especificaciones del proyecto en UML y el algoritmo en pseudocódigo. ‰ Procesamiento: El sueldo total será ingresado por teclado y almacenado en una variable (sueldo).Diseño de la lógica. Definición de Paquetes y desarrollo de Diagrama de Paquetes. Se deberá visualizar por pantalla el total de descuentos y el sueldo a cobrar. Etapa 03 . se realizarán los cálculos del descuento y del sueldo a cobrar del obrero.2 pago = sueldo – desc Los resultados se almacenarán en las variables (desc y pago respectivamente) para luego ser mostradas por pantalla.

Definición de las Clases. pago = 0 LEER sueldo desc = sueldo * 0. pago FIN Pag. desc = 0. Algoritmo PrgSueldoObrero . pago INICIO NUMERO sueldo = 0.2 pago = sueldo .desc ESCRIBIR desc.ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS 3. Clases Clases dominioDeLaAplicacion biblioteca 4.método main ( ) ENTRADA: sueldo SALIDA: desc. Diseño de algoritmo para el método principal. 117 .

println ( desc + “ soles ” ) . System.out. System. 118 .Desarrollo de la Codificación.print ( “ El total de descuento es: ” ) .out.print ( “ Ingrese el sueldo de un obrero: ” ) . } } Pag.Lectura . import biblioteca. La codificación se desarrolla utilizando el lenguaje de programación Java. class PrgSueldoObrero { public static void main (String arg[]) { double sueldo = 0. System.out. // calculando el monto a pagar pago = sueldo – desc . Etapa 04 . desc = 0. Juan José Flores Cueto.println ( “ El sueldo a pagar es: ” + pago + “ soles ” ) .2 . // Calculando el descuento ( 20% ) desc = sueldo * 0.out. Ing. Clase PrgSueldoObrero package dominioDeLaAplicacion . sueldo = Lectura. pago = 0 . System.leerDouble ( ) .

119 . ‰ Resultado deseado: Calcular y mostrar la temperatura en grados Fahrenheit. ‰ Datos necesarios: La temperatura en grados Celsius. Etapa 02 . de acuerdo a la siguiente fórmula: F = (9/5) * C + 32. Etapa 03 . Definición de Paquetes y desarrollo de Diagrama de Paquetes.Descripción del problema. Para solucionar el problema se desarrollarán las especificaciones del proyecto en UML y el algoritmo en pseudocódigo.Definición de la solución. ‰ Procesamiento: La temperatura en grados Celsius será ingresada y almacenada en una variable (gradosCel). 1. Convertir la temperatura de grados Celsius a grados Fahrenheit. Nombre del Proyecto: ProyTemperatura.Diseño de la lógica. El resultado será almacenado en una variable (gradosFar) para luego ser mostrado por pantalla. 2. luego se realizará el cálculo de la temperatura en grados Fahrenheit de acuerdo a la siguiente fórmula: gradosFar = (9/5) * gradosCel + 32.ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS Problema 06 Etapa 01 . Diagrama de paquetes Pag.

3. Juan José Flores Cueto. Diseño de algoritmo para el método principal. Ing. Definición de las Clases. 120 . Algoritmo PrgTemperatura .método main ( ) ENTRADA: gradosCel SALIDA: gradosFar INICIO NUMERO gradosCel = 0. gradosFar = 0 LEER gradosCel gradosFar = ( 9 / 5 ) * gradosCel + 32 ESCRIBIR gradosFar FIN Pag. Clases Clases dominioDeLaAplicacion biblioteca 4.

System. } } Pag.leerDouble ( ) . gradosCel = Lectura.Desarrollo de la Codificación. 121 .out.ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS Etapa 04 .print ( “ Ingrese la temperatura en grados Celsius: " ) . gradosFar = 0 .Lectura . La codificación se desarrolla utilizando el lenguaje de programación Java. System. class PrgTemperatura { public static void main ( String arg[] ) { double gradosCel = 0.println ( “ La temperatura en grados Fahrenheit es: " + gradosFar) . gradosFar = ( 9 / 5 ) * gradosCel + 32 .out. Clase PrgTemperatura package dominioDeLaAplicacion . import biblioteca.

Etapa 03 . Diagrama de paquetes Pag. Nombre del Proyecto: ProyUtilidad. Leer el costo de un artículo y su precio de venta.Diseño de la lógica. Calcular y mostrar su utilidad. 1. luego se realizará el cálculo de la utilidad del artículo de acuerdo a la siguiente fórmula: utilidad = precioVta . ‰ Datos necesarios: El costo y el precio de venta del artículo. Etapa 02 . 122 . ‰ Resultado deseado: Calcular y mostrar la utilidad de un artículo. 2. precioVta). Definición de Paquetes y desarrollo de Diagrama de Paquetes. Para solucionar el problema se desarrollarán las especificaciones del proyecto en UML y el algoritmo en pseudocódigo.Definición de la solución.costo El resultado será almacenado en una variable (utilidad) para luego ser mostrado por pantalla.Descripción del problema. Juan José Flores Cueto. Ing. Problema 07 Etapa 01 . ‰ Procesamiento: El costo y el precio de venta del artículo serán ingresados y almacenados en variables (costo.

precioVta = 0.método main ( ) ENTRADA: costo. Algoritmo PrgUtilidad . precioVta utilidad = precioVta . Definición de las Clases.costo ESCRIBIR utilidad FIN Pag. 123 . precioVta SALIDA: utilidad INICIO NUMERO costo = 0. Clases Clases dominioDeLaAplicacion biblioteca 4.ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS 3. utilidad = 0 LEER costo. Diseño de algoritmo para el método principal.

System.print ( “ Ingrese el costo del artículo: ” ) . Ing. System.Desarrollo de la Codificación. costo = Lectura. class PrgUtilidad { public static void main ( String arg[] ) { double costo = 0. Etapa 04 . } } Pag.leerDouble ( ) .print ( “ Ingrese el precio de venta del artículo: ” ) . ” + utilidad + “ soles ” ) . System.costo .Lectura .out. utilidad = 0 .leerDouble ( ) . precioVta = 0. Clase PrgUtilidad package dominioDeLaAplicacion .out.out. La codificación se desarrolla utilizando el lenguaje de programación Java.println ( “ La utilidad del artículo es: s/. 124 . Juan José Flores Cueto. import biblioteca. utilidad = precioVta . precioVta = Lectura.

Definición de Paquetes y desarrollo de Diagrama de Paquetes. se muestra la nota final y el mensaje. 125 . Si la nota final resulta mayor que 13 entonces se almacenará el mensaje “Felicitaciones” en una variable (mensaje). ‰ Datos necesarios: Las dos notas del alumno. Nombre del Proyecto: ProyNotaFinal2. 1. Etapa 02 . Diagrama de paquetes Pag. Para solucionar el problema se desarrollarán las especificaciones del proyecto en UML y el algoritmo en pseudocódigo.Definición de la solución.ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS Problema 08 Etapa 01 .Descripción del problema. Calcular y mostrar la nota final (nf) de un alumno. Si el alumno obtiene una nota final mayor a 13 se deberá visualizar un mensaje de felicitaciones. Etapa 03 . 2. ‰ Resultado deseado: Mostrar nota final y un mensaje de felicitaciones si la nota final es mayor a 13. ‰ Procesamiento: Las notas se ingresarán por el teclado y serán almacenadas en variables (nota1 y nota2). luego se realizará el cálculo de la nota final: nf = ((nota1 + nota2) / 2) El resultado se almacena en una variable (nf). Finalmente.Diseño de la lógica. sabiendo que se tienen sólo dos notas.

Clases Clases dominioDeLaAplicacion biblioteca 4. Juan José Flores Cueto. nota2 SALIDA: nf. Definición de las Clases. mensaje INICIO NUMERO nota1 = 0. Ing. mensaje FIN Pag.método main ( ) ENTRADA: nota1. Diseño de algoritmo para el método principal. 126 . Algoritmo PrgNotaFinal2 . nf = 0 TEXTO mensaje = “ ” LEER nota1. nota2 = 0. 3. nota2 nf = (nota1 + nota2) / 2 SI ( nf > 13 ) ENTONCES mensaje = “Felicitaciones” FINSI ESCRIBIR nf.

127 .println ( “ La nota final es: ” + nf + “ ” + mensaje ) . } } Pag. La codificación se desarrolla utilizando el lenguaje de programación Java. nota2 = 0.Desarrollo de la Codificación.Lectura .out. class PrgNotaFinal2 { public static void main ( String arg[] ) { double nota1 = 0.leerDouble ( ) . nota2 = Lectura. } System. import biblioteca. nota1 = Lectura. nf = (nota1 + nota2) / 2 . String mensaje = “ ” . if (nf > 13) { mensaje = “ Felicitaciones ” . System.leerDouble ( ) .ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS Etapa 04 .out. nf = 0 . Clase PrgNotaFinal2 package dominioDeLaAplicacion .print ( “ Ingrese la primera nota: ” ) .print ( “ Ingrese la segunda nota: ” ) . System.out.

Si el sueldo resulta mayor que S/. Calcular y mostrar el sueldo de un trabajador conociendo el número de horas trabajadas y su tarifa horaria. ‰ Procesamiento: El total de horas trabajadas y la tarifa horaria se ingresarán por teclado y se almacenarán en variables (horas y tarifa). Juan José Flores Cueto.Diseño de la lógica. 3000.Definición de la solución.3000 entonces se calcula el sueldo a cobrar restando el 10% del sueldo. sabiendo que se debe descontar un 10% del sueldo por concepto de impuestos si este es mayor de S/. Para solucionar el problema se desarrollarán las especificaciones del proyecto en UML y el algoritmo en pseudocódigo. ‰ Datos necesarios: El total de horas trabajadas y la tarifa horaria. Etapa 02 .Descripción del problema. Definición de Paquetes y desarrollo de Diagrama de Paquetes. El resultado se almacena en la variable sueldo y se muestra a través de la pantala. Problema 09 Etapa 01 . Ing. 2. Etapa 03 . ‰ Resultado deseado: Mostrar el sueldo de un trabajador. 1. Nombre del Proyecto: ProySueldoTrabajador. 128 . Diagrama de paquetes Pag. luego se realizará el cálculo del sueldo utilizando la siguiente operación: sueldo = horas * tarifa El resultado se almacenará en una variable (sueldo).

9 FINSI ESCRIBIR sueldo FIN Pag. Algoritmo PrgSueldoTrabajador . sueldo = 0 LEER horas. Definición de las Clases. 129 . Diseño de algoritmo para el método principal. Clases Clases dominioDeLaAplicacion biblioteca 4.método main ( ) ENTRADA: horas. tarifa = 0. tarifa SALIDA: sueldo INICIO NUMERO horas = 0. tarifa sueldo = horas * tarifa SI ( sueldo > 3000 ) ENTONCES sueldo = sueldo * 0.ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS 3.

leerDouble ( ) .print ( “ Ingrese el total de horas trabajadas: ” ) . import biblioteca.9 . System.Desarrollo de la Codificación. La codificación se desarrolla utilizando el lenguaje de programación Java. Juan José Flores Cueto. Ing.out. } } Pag. 130 . Clase PrgSueldoTrabajador package dominioDeLaAplicacion .out. tarifa = Lectura. System. class PrgSueldoTrabajador { public static void main ( String arg[] ) { int horas = 0 . double tarifa = 0. Etapa 04 .out.Lectura . sueldo = horas * tarifa .print ( “ Ingrese la tarifa del trabajador: ” ) . if (sueldo > 3000) { sueldo = sueldo * 0. sueldo = 0 .leerInt ( ) .println ( “ El sueldo es: ” + sueldo ) . horas = Lectura. } System.

131 .500 nuevos soles.Diseño de la lógica. caso contrario el descuento será de 2%. ‰ Datos necesarios: Monto total. Para solucionar el problema se desarrollarán las especificaciones del proyecto en UML y el algoritmo en pseudocódigo. Etapa 02 . ‰ Resultado deseado: Mostrar monto total a pagar. 2. En caso que el monto total a pagar incluido IGV sea mayor a S/.ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS Problema 10 Etapa 01 . 1.18) y se almacena en una variable (montoPago). Se asume que el IGV es 18%. Diagrama de paquetes Pag.Descripción del problema. Definición de Paquetes y desarrollo de Diagrama de Paquetes. Luego se realizará el cálculo del monto total a pagar (monto total * 1. Etapa 03 . sino sólo se descontará el 2%. ‰ Procesamiento: El monto total será almacenado en una variable (montoTotal). se descuenta el 8%. Nombre del Proyecto: ProyArticulos. Si el monto total resulta mayor a S/.Definición de la solución.500 nuevos soles se aplica un descuento de 8%. Calcular y mostrar el monto total a pagar por la compra de varios artículos si se tiene que agregar el IGV (Impuesto General a las Ventas).

92 SINO montoPago = montoPago * 0. 132 . Juan José Flores Cueto. 3. Clases Clases dominioDeLaAplicacion biblioteca 4. Diseño de algoritmo para el método principal. Algoritmo PrgArticulos .18 SI ( montoPago > 500 ) ENTONCES montoPago = montoPago * 0.98 FINSI ESCRIBIR montoPago FIN Pag. Ing. Definición de las Clases.método main ( ) ENTRADA: montoTotal SALIDA: montoPago INICIO NUMERO montoTotal = 0. montoPago = 0 LEER montoTotal montoPago = montoTotal * 1.

import biblioteca. montoPago = 0 .out.Desarrollo de la Codificación.println ( montoPago + “ soles ” ) . class PrgArticulos { public static void main ( String arg[] ) { double montoTotal = 0.print ( “ Ingrese el monto total: ” ) .18 . montoTotal = Lectura. montoPago = montoTotal * 1. } System.ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS Etapa 04 . System.out. System.leerDouble ( ) .92 . } else { montoPago = montoPago * 0.98 . if (montoPago > 500) { montoPago = montoPago * 0.Lectura . La codificación se desarrolla utilizando el lenguaje de programación Java. 133 .out.print ( “ El monto total a pagar incluido IGV y descuentos es: ” ) . } } Pag. Clase PrgArticulos package dominioDeLaAplicacion .

Nombre del Proyecto: ProyAumentoSueldo. Problema 11 Etapa 01 . ‰ Resultado deseado: Mostrar nuevo sueldo del trabajador. Finalmente. 134 . Juan José Flores Cueto. 2. Categoría Aumento 1 25 % 2 15 % 3 10 % 4 05 % Etapa 02 . Dependiendo la categoría ingresada. 1.Descripción del problema. Muestrar el nuevo sueldo del trabajador.Definición de la solución. ‰ Datos necesarios: La categoría y el sueldo del trabajador. Ing. Diagrama de paquetes Pag.Diseño de la lógica. y calcular el aumento correspondiente teniendo en cuenta la siguiente tabla. Leer la categoría y el sueldo de un trabajador. teniendo como base la tabla mostrada. se mostrará el nuevo sueldo del trabajador. se procederá a calcular el nuevo sueldo del trabajador (nuevoSueldo). Etapa 03 . Definición de Paquetes y desarrollo de Diagrama de Paquetes. Para solucionar el problema se desarrollarán las especificaciones del proyecto en UML y el algoritmo en pseudocódigo. ‰ Procesamiento: La categoría y el sueldo del trabajador serán almacenados en variables (categoria y sueldo).

categoria CUANDO categoria SEA CASO 1 : nuevoSueldo = sueldo * 1.ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS 3.10 TERMINAR CASO 4 : nuevoSueldo = sueldo * 1. Clases Clases dominioDeLaAplicacion biblioteca 4.15 TERMINAR CASO 3 : nuevoSueldo = sueldo * 1. Diseño de algoritmo para el método principal. sueldo = 0. sueldo SALIDA: nuevoSueldo INICIO NUMERO categoria = 0. Definición de las Clases.método main ( ) ENTRADA: categoria. Algoritmo PrgAumentoSueldo . 135 .25 TERMINAR CASO 2 : nuevoSueldo = sueldo * 1. nuevoSueldo = 0 LEER sueldo.05 TERMINAR OTROS : nuevoSueldo = sueldo FINCUANDO ESCRIBIR nuevoSueldo FIN Pag.

break . class PrgAumentoSueldo { public static void main ( String arg[] ) { double sueldo = 0.leerInt ( ) . } } Pag. 136 .leerDouble ( ) . case 4: nuevoSueldo = sueldo * 1.print ( “ Ingrese el sueldo del trabajador: ” ) . switch (categoria) { case 1: nuevoSueldo = sueldo * 1. Clase PrgAumentoSueldo package dominioDeLaAplicacion . default: nuevoSueldo = sueldo .15 .Lectura . case 3: nuevoSueldo = sueldo * 1.out. Etapa 04 . Ing. import biblioteca.out.10 . nuevoSueldo = 0 . sueldo = Lectura.print ( “ Ingrese la categoría del trabajador: ” ) .25 . La codificación se desarrolla utilizando el lenguaje de programación Java. break .println ( “ El nuevo sueldo del trabajador es: ” + nuevoSueldo ) . categoria = Lectura.Desarrollo de la Codificación. break . case 2: nuevoSueldo = sueldo * 1. Juan José Flores Cueto.out. int categoria = 0.05 . } System. System. System. break .

según los datos de la tabla. el número de días de permanencia del paciente y su sexo. Pag. Adicionalmente deberá considerarse que las mujeres tienen un incremento del 10% para el primer tipo de enfermedad y los hombres tienen un aumento del 5% para el tercer tipo de enfermedad. se procederá hacer el cálculo del costo que representa para el hospital el paciente.ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS Problema 12 Etapa 01 . dias y sexo). de acuerdo a la siguiente operación costoTotal = ( costo * número de días). ‰ Datos necesarios: El tipo de enfermedad. Dependiendo del tipo de enfermedad. El resultado se almacena en una variable (costoTotal) para luego ser mostrado. Enfermedad Tipo Costo / Paciente / Día 1 200 2 350 3 420 Etapa 02 . ‰ Procesamiento: El tipo de enfermedad. Calcular y mostrar el costo total que representa un paciente para un hospital de acuerdo al tipo de enfermedad.Definición de la solución. el número de días y el sexo (1 si es hombre y 2 si es mujer) del paciente se almacenarán en variables (tipoEnfermedad.Descripción del problema. ‰ Resultado deseado: Mostrar el costo total de un paciente para un hospital. Si se trata del primer tipo de enfermedad y el paciente es mujer se le incrementará el 10%. Por otro lado. si se trata del tercer tipo de enfermedad y el paciente es hombre se procederá a incrementar el 5%. 137 .

Diagrama de paquetes 3. Para solucionar el problema se desarrollarán las especificaciones del proyecto en UML y el algoritmo en pseudocódigo. Ing. Definición de Paquetes y desarrollo de Diagrama de Paquetes. Etapa 03 . Clases Clases dominioDeLaAplicacion biblioteca Pag.Diseño de la lógica. Definición de las Clases. Nombre del Proyecto: ProyHospital. 138 . 1. Juan José Flores Cueto. 2.

139 . Algoritmo PrgHospital .método main ( ) ENTRADA: tipoEnfermedad. sexo SALIDA: costoTotal INICIO NUMERO tipoEnfermedad = 0. sexo CUANDO tipoEnfermedad SEA CASO 1 : costoTotal = 200 * dias SI (sexo = 2 ) ENTONCES costoTotal = costoTotal * 1. costoTotal = 0 LEER tipoEnfermedad.10 FINSI TERMINAR CASO 2 : costoTotal = 350 * dias TERMINAR CASO 3 : costoTotal = 420 * dias SI ( sexo = 1 ) ENTONCES costoTotal = costoTotal * 1.05 FINSI FINCUANDO ESCRIBIR costoTotal FIN Pag. sexo = 0. Diseño de algoritmo para el método principal. dias = 0. dias.ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS 4. dias.

10 . Etapa 04 .out. Clase PrgHospital package dominioDeLaAplicacion .print ( “ Ingrese el número de días que ha estado el paciente: ” ) . class PrgHospital { public static void main ( String arg[] ) { int tipoEnfermedad = 0. System. if ( sexo == 1 ) { costoTotal = costoTotal * 1. dias = 0. System. Juan José Flores Cueto.out. sexo = Lectura.leerInt ( ) . } } Pag.print ( “ Ingrese el sexo del paciente [1=hombre. sexo = 0 .print ( “ Ingrese el tipo de enfermedad: ” ) .Lectura . case 2 : costoTotal = 350 * dias . 2= Mujer]: ” ) .Desarrollo de la Codificación.out. if ( sexo == 2 ) { costoTotal = costoTotal * 1.05 .out. Ing. } break .leerInt ( ) . switch ( tipoEnfermedad) { case 1 : costoTotal = 200 * dias . 140 .leerInt ( ) . La codificación se desarrolla utilizando el lenguaje de programación Java. case 3 : costoTotal = 420 * dias .println ( “ El costo total es: ” + costoTotal ) . System. tipoEnfermedad = Lectura. } } System. double costoTotal = 0 . import biblioteca. break . dias = Lectura.

Se utilizarán tres variables auxiliares para almacenar el orden de las notas (menor. las variables auxiliares mayor. Etapa 02 . intemedio y menor almacenarán las notas y se mostrarán en orden ascendente. Diagrama de paquetes 3. 141 . Nombre del Proyecto: ProyOrdena. ‰ Resultado deseado: Mostrar las tres notas en forma ascendente.Descripción del problema. intermedio y mayor). ‰ Datos necesarios: Las tres notas del alumno en cualquier orden. 2. Definición de Paquetes y desarrollo del Diagrama de Paquetes.ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS Problema 13 Etapa 01 . Muestrar las notas ordenadas en forma ascendente. Etapa 03 . Finalmente. Definición de las Clases.Diseño de la lógica. 1. ‰ Procesamiento: Las tres notas del alumno serán almacenadas en variables (n1. Clases Clases dominioDeLaAplicacion biblioteca Pag. n2 y n3). Ingresar tres notas de un alumno.Definición de la solución.

Diseño de algoritmo para el método principal. 4. n3 SALIDA: menor. intermedio. Algoritmo PrgOrdena . n3 = 0. n2. menor = 0. Juan José Flores Cueto.método main ( ) ENTRADA: n1. n2 = 0. Ing. 142 . intermedio = 0 NUMERO mayor = 0 LEER n1. n2. mayor FIN Pag. mayor INICIO NUMERO n1 = 0. intermedio. n3 SI (n1 > n2) ENTONCES SI (n1 > n3) ENTONCES mayor = n1 SI (n2 > n3) ENTONCES intermedio = n2 menor = n3 SINO intermedio = n3 menor = n2 FINSI SINO mayor = n3 intermedio = n1 menor = n2 FINSI SINO SI (n2 > n3) ENTONCES mayor = n2 SI (n1 > n3) ENTONCES intermedio = n1 menor = n3 SINO intermedio = n3 menor = n1 FINSI SINO mayor = n3 intermedio = n2 menor = n1 FINSI FINSI ESCRIBIR menor.

intermedio = n2 .out.leerInt ( ) . menor = 0. n3 = Lectura. System. System. class PrgOrdena { public static void main ( String arg[] ) { int n1 = 0.out. n2 = 0. } else { intermedio = n3 . menor = n3 . n3 = 0.leerInt ( ) .ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS Etapa 04 .Lectura . if ( n1 > n3) { intermedio = n1 .print ( “ Ingrese la segunda nota: ” ) .out. menor = n1 . } } else { mayor = n3 . if (n1 > n2) { if (n1 > n3) { mayor = n1 . 143 .out. Clase PrgOrdena package dominioDeLaAplicacion . } } else { mayor = n3 .leerInt ( ) . } } Pag. intermedio = 0.Desarrollo de la Codificación. menor = n2 . mayor = 0 . menor = n2 . } } else { if (n2 > n3) { mayor = n2 . intermedio = n1 .print ( “ Ingrese la tercera nota: ” ) . menor = n1 . import biblioteca. } else { intermedio = n3 . n1 = Lectura.print ( “ Ingrese la primera nota: ” ) . } } System.println ( menor + “ ” + intermedio + “ ” + mayor ) . n2 = Lectura. menor = n3 . System. if (n2 > n3) { intermedio = n2 .

Etapa 02 . ‰ Resultado deseado: Mostrar la categoría del alumno. Problema 14 Etapa 01 . 144 . Según la siguiente tabla: Rango Categoria Desde 17 a 20 A Desde 14 a 16 B Desde 10 a 13 C Desde 00 a 09 D Determinar la categoría del alumno. Ing. se determina el promedio de las cuatro notas más altas y se le da al estudiante una categoría que puede ser A.Definición de la solución. n3. Pag. La menor de estas notas se guardará en una variable (notaMenor). ‰ Datos necesarios: Las cinco notas del estudiante. n4 y n5). n2.Descripción del problema. Juan José Flores Cueto. El resultado es almacenado en la variable (promedio). Se realizará el cálculo del promedio del alumno de la siguiente forma: promedio = ( sumaNotas – notaMenor ) / 4 ). ‰ Procesamiento: Las cinco notas del estudiante se ingresan a través del teclado y se almacenan en variables (n1. B. La suma de las cinco notas se guardará en una variable (sumaNotas). este resultado nos permitirá obtener la categoría del alumno (categoria). para luego ser mostrada por pantalla. C o D. Un curso se evalúa de la siguiente forma: se toma cinco prácticas calificadas.

145 .ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS Etapa 03 . Definición de Paquetes y desarrollo del Diagrama de Paquetes. Definición de las Clases. Diagrama de paquetes 3. 1. 2. Clases Clases dominioDeLaAplicacion biblioteca Pag.Diseño de la lógica. Nombre del Proyecto: ProyCategoriaAlumno.

n5 = 0. 4. n4 = 0. n3.notaMenor) / 4 SI (promedio <= 20 AND promedio >= 17) ENTONCES categoria = ‘A’ SINO SI (promedio <= 16 AND promedio >= 14) ENTONCES categoria = ‘B’ SINO SI (promedio <= 13 AND promedio >= 10) ENTONCES categoria = ‘C’ SINO SI (promedio<=10 AND promedio>=0) ENTONCES categoria = ‘D’ FINSI FINSI FINSI FINSI ESCRIBIR categoria FIN Pag. n5 sumaNotas = n1 + n2 + n3 + n4 + n5 notaMenor = n1 SI (notaMenor>n2) ENTONCES notaMenor = n2 FINSI SI (notaMenor > n3) ENTONCES notaMenor = n3 FINSI SI (notaMenor > n4) ENTONCES notaMenor = n4 FINSI SI (notaMenor > n5) ENTONCES notaMenor = n5 FINSI promedio = (sumaNotas . n5 SALIDA: categoria INICIO NUMERO n1 = 0. Juan José Flores Cueto. n2 = 0. n3. n4. promedio = 0 TEXTO categoria = ‘ ’ LEER n1. n2. Ing. n4. 146 .método main ( ) ENTRADA: n1. n2. n3 = 0. sumaNotas = 0 NUMERO notaMenor = 0. Algoritmo PrgCategoriaAlumno . Diseño de algoritmo para el método principal.

leerDouble ( ) . System. if (promedio <= 20 && promedio >= 17) { categoria = ‘A’ . n3 = Lectura. if (notaMenor > n4) notaMenor = n4 .leerDouble ( ) . System. } else { if (promedio <= 10 && promedio >= 0) { categoria = ‘D’ .print ( “ Ingrese la 4ta. nota: ” ) . n4 = 0. n5 = 0. n3 = 0. if (notaMenor > n2) notaMenor = n2 .out. nota: ” ) .println ( “ La categoría del alumno es: ” + categoria ) . promedio = 0 . } } } } System. System.ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS Etapa 04 . 147 . sumaNotas = n1 + n2 + n3 + n4 + n5 . import biblioteca. if (notaMenor > n3) notaMenor = n3 . n2 = Lectura. nota: ” ) .print ( “ Ingrese la 5ta.notaMenor) / 4 . double notaMenor = 0.print ( “ Ingrese la 2da. char categoria = ‘ ’ . System.leerDouble ( ) .out. Clase PrgCategoriaAlumno package dominioDeLaAplicacion . System.out.leerDouble ( ) . notaMenor = n1 . promedio = (sumaNotas .Desarrollo de la Codificación. if (notaMenor > n5) notaMenor = n5 . } } Pag.out. } else { if (promedio <= 16 && promedio >= 14) { categoria = ‘B’ . n5 = Lectura.leerDouble ( ) . n2 = 0.out.print ( “ Ingrese la 3ra. class PrgCategoriaAlumno { public static void main ( String arg[] ) { double n1 = 0.Lectura . n1 = Lectura. nota: ” ) .print ( “ Ingrese la 1ra. n4 = Lectura. nota: ” ) . } else { if (promedio <= 13 && promedio >= 10) { categoria = ‘C’ .out. sumaNotas = 0 .

En una oficina de empleados. de acuerdo a lo siguiente: . ‰ Resultado deseado: Mostrar la categoría del postulante. o Categoría MB en caso contrario. Ing. Si es hombre o mujer asignaremos su respectiva categoría dependiendo de la edad del postulante. 2.Diseño de la lógica. Definición de Paquetes y desarrollo del Diagrama de Paquetes. ‰ Procesamiento: El sexo y la edad del postulante se ingresan a través del teclado y se almacenan en variables (sexo y edad). Diagrama de paquetes Pag. Problema 15 Etapa 01 . categorizan a los postulantes en función del sexo y de la edad. Juan José Flores Cueto. o Categoría FB en caso contrario. El resultado es almacenado en una variable (categoria) para luego ser mostrada por pantalla. Etapa 02 . Nombre del Proyecto: ProyCategoriaPostulante. Etapa 03 . . 1.Descripción del problema.Si la persona es de sexo femenino: o Categoría FA si tienen menos de 23 años. 148 .Definición de la solución.Si la persona es de sexo masculino: o Categoría MA si tiene menos de 25 años. ‰ Datos necesarios: El sexo y la edad del postulante.

Diseño de algoritmo para el método principal. Clases Clases dominioDeLaAplicacion biblioteca 4. categoria = 0 LEER sexo.método main ( ) ENTRADA: sexo. Algoritmo PrgCategoriaPostulante . edad SALIDA: categoria INICIO NUMERO edad = 0 TEXTO sexo = ‘F’.ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS 3. 149 . edad CUANDO sexo SEA CASO ‘f’: CASO ‘F’: SI (edad < 23) ENTONCES categoria = “FA” SINO categoria = “FB” FINSI TERMINAR CASO ‘m’: CASO ‘M’: SI (edad < 25) ENTONCES categoria = “MA” SINO categoria = “MB” FINSI FINCUANDO ESCRIBIR categoria FIN Pag. Definición de las Clases.

break .Lectura . String categoria = “ ” .Desarrollo de la Codificación.leerInt ( ) . Juan José Flores Cueto. class PrgCategoriaPostulante { public static void main ( String arg[] ) { int edad = 0 . System.print ( “ Ingrese la edad del postulante: ” ) . System. } } Pag.leerChar ( ) . } System. sexo = Lectura. char sexo = ‘F’ . switch (sexo) { case ‘f’ : case ‘F’ : if (edad < 23) categoria = “FA” . Etapa 04 . import biblioteca.print ( “ Ingrese sexo del postulante [ F/M ]: ” ) . else categoria = “MB” .out. edad = Lectura. else categoria = “FB” . 150 .out. case ‘m’ : case ‘M’ : if (edad < 25) categoria = “MA” .out. Ing. Clase PrgCategoriaPostulante package dominioDeLaAplicacion .println ( “ La categoría del postulante es: ” + categoria ) .

El resultado es almacenado en la variable (nf) para luego ser mostrada. Se realizará el cálculo de la nota final en base a la fórmula: nf = ( n1 + n2 + n3 + ( n4 * 2 ) ) / 5. 2. Utilizar la estructura lógica MIENTRAS. Esto se repite para todos los alumnos del curso.ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS Problema 16 Etapa 01 .Definición de la solución. 151 . Etapa 03 . Etapa 02 . n2.Diseño de la lógica. Definición de Paquetes y desarrollo del Diagrama de Paquetes. con la finalidad de poder mostrar la nota final de cada uno de ellos. ‰ Datos necesarios: Las cuatro notas de cada uno de los alumnos del curso. 1.Descripción del problema. Diagrama de paquetes Pag. n3 y n4). ‰ Procesamiento: Las cuatro notas del alumno se ingresan a través del teclado y se almacenan en variables (n1. Nombre del Proyecto: ProyNotasAlumnos. ‰ Resultado deseado: Mostrar la nota final de todos los alumnos de un curso. Calcular la nota final de todos los alumnos del curso utilizando la siguiente fórmula: nf = ( n1 + n2 + n3 + ( n4 * 2 ) ) / 5 Ingresar las notas a través del teclado.

n3 = 0. Diseño de algoritmo para el método principal. n3. Algoritmo PrgNotasAlumnos . n4 SALIDA: nf INICIO NUMERO i = 1.método main ( ) ENTRADA: numAlumnos. nf = 0 NUMERO numAlumnos = 1 LEER numAlumnos MIENTRAS ( i <= numAlumnos ) LEER n1. Ing. n2. Juan José Flores Cueto. n4 = 0. n1. n1 = 0. 152 . Clases Clases dominioDeLaAplicacion biblioteca 4. n2. 3. n3. n2 = 0. Definición de las Clases. n4 nf = ( n1 + n2 + n3 + ( n4 * 2 ) ) / 5 ESCRIBIR nf i=i+1 FINMIENTRAS FIN Pag.

out. n3 = 0.out. n2 = Lectura.println ( “Ingrese el número de alumnos: ” ) . double n1= 0. import biblioteca.println ( “ Ingrese nota 1 del alumno [” + i + “]: ” ) .leerDouble ( ) .println ( “ Ingrese nota 2 del alumno [” + i + “]: ” ) .leerDouble ( ) . 153 .println ( “ Nota final del alumno [” + i + “]: ” + nf ) .ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS Etapa 04 . System. n3 = Lectura. while ( i <= numAlumnos ) { System.out.Desarrollo de la Codificación.Lectura . n2 = 0. n1 = Lectura.out.leerInt ( ) .leerDouble ( ) .println ( “ Ingrese nota 3 del alumno [” + i + “]: ” ) . nf = 0 . System. class PrgNotasAlumnos { public static void main ( String arg[] ) { int i = 1.leerDouble ( ) . numAlumnos = Lectura. System. i ++ . numAlumnos = 0 . } } } Pag. n4 = 0. System. Clase PrgNotasAlumnos package dominioDeLaAplicacion . nf = ( n1 + n2 + n3 + ( n4 * 2 ) ) / 5 .out. n4 = Lectura.println ( “ Ingrese nota 4 del alumno [” + i + “]: ” ) .out. System.

Juan José Flores Cueto. Esto se repite para todos los alumnos del curso con la finalidad de poder mostrar la nota final de cada uno de ellos. Ing. Utilizar la estructura lógica HACER. n3 y n4). Calcular la nota final de todos los alumnos del curso utilizando la siguiente fórmula: nf = ( n1 + n2 + n3 + ( n4 * 2 ) ) / 5. 2. 1. 154 . ‰ Procesamiento: Las cuatro notas del alumno se ingresan a través del teclado y se almacenan en variables (n1. Definición de Paquetes y desarrollo del Diagrama de Paquetes. Diagrama de paquetes Pag. Ingresar las notas a través del teclado. ‰ Datos necesarios: Las cuatro notas de cada uno de los alumnos del curso. Problema 17 Etapa 01 . Etapa 03 . ‰ Resultado deseado: Mostrar la nota final de todos los alumnos de un curso. Nombre del Proyecto: ProyNotasAlumnos2.Definición de la solución. Se realizará el cálculo de la nota final sobre la base de la fórmula: nf = ( n1 + n2 + n3 + ( n4 * 2 ) ) / 5.Descripción del problema. Etapa 02 . El resultado es almacenado en la variable (nf) para luego ser mostrada. n2.Diseño de la lógica.

n2 = 0.ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS 3. continua SALIDA: nf INICIO NUMERO i = 1. Diseño de algoritmo para el método principal. n4 = 0. 155 . n2. n3 = 0. n2.método main ( ) ENTRADA: n1. n3. nf = 0 TEXTO continua = ‘ ’ HACER LEER n1. n4 nf = ( n1 + n2 + n3 + ( n4 * 2 ) ) / 5 ESCRIBIR nf LEER continua i=i+1 MIENTRAS ( continua = ‘s’ OR continua = ‘S’ ) FIN Pag. Definición de las Clases. n4. n3. Clases Clases dominioDeLaAplicacion biblioteca 4. Algoritmo PrgNotasAlumnos2 . n1 = 0.

Lectura .out. n3 = Lectura. 156 . i++ .println ( “ Ingrese nota 4 del alumno [” + i + “]: ” ) . System.out.Desarrollo de la Codificación. n1 = Lectura.out. Juan José Flores Cueto. nf = ( n1 + n2 + n3 + ( n4 * 2 ) ) / 5 .leerDouble ( ) .leerDouble ( ) . double n1 = 0.leerDouble ( ) . continua = Lectura.println ( “ Ingrese nota 2 del alumno [” + i + “]: ” ) .out.println ( “ Ingrese nota 1 del alumno [” + i + “]: ” ) . Ing.out. do { System. System. n4 = 0.println ( “ Desea continuar (s/n): ” ) . class PrgNotasAlumnos2 { public static void main ( String arg[] ) { int i = 1 .out. char continua = ‘ ’ . System. nf = 0 . n2 = Lectura. Etapa 04 . System. n4 = Lectura. import biblioteca. Clase PrgNotasAlumnos2 package dominioDeLaAplicacion . } while ( continua == ‘s’ || continua == ‘S’ ) . n3 = 0.leerChar ( ) . n2 = 0.println ( “ Nota final del alumno [” + i + “]: ” + nf ) . System. } } Pag.leerDouble ( ) .println ( “ Ingrese nota 3 del alumno [” + i + “]: ” ) .

determinar cuál es el mayor y el menor sueldo en la empresa. se verificará si es el sueldo menor. se mostrará por pantalla el sueldo mayor (mayorSueldo).ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS Problema 18 Etapa 01 . Pag. Adicionalmente. se almacenará en la variable menorSueldo.Definición de la solución. Al finalizar el ingreso de los datos de todos los trabajadores de la empresa. Si el sueldo ingresado resulta ser el sueldo mayor. 157 . Si el sueldo ingresado resulta ser el sueldo menor. la suma de sueldos de los empleados (categoría 2) y la suma de sueldos de los gerentes (categoría 3) de una determinada empresa. la suma de sueldos de los obreros (sueldo1). ‰ Resultado deseado: La suma de sueldos de los obreros. la suma de sueldos de los empleados y la suma de sueldos de los gerentes. Adicionalmente el sueldo mayor y el sueldo menor.Descripción del problema. Si resulta ser un obrero se suma su sueldo a la variable sueldo1. se almacenará en la variable mayorSueldo. la suma de sueldo de los empleados (sueldo2) y la suma de los sueldos de los gerentes (sueldo3). También se evaluará la categoría del trabajador. ‰ Datos necesarios: El sueldo y la categoría de cada uno de los trabajadores de la empresa. ‰ Procesamiento: El sueldo y la categoría de cada trabajador de la empresa se ingresarán a través del teclado y se almacenarán en las variables sueldo y categoria. Determinar la suma de sueldos de los obreros (categoría 1). Cada vez que se ingrese el sueldo de un trabajador se deberá verificar si es el sueldo mayor. si resulta ser un empleado se suma su sueldo a la variable sueldo2 y si resulta ser un gerente se suma su sueldo a la varaiable sueldo3. Etapa 02 . el sueldo menor (menorSueldo). De igual forma.

Definición de Paquetes y desarrollo del Diagrama de Paquetes. 158 . 2. Ing. Definición de las Clases. 1. Diagrama de paquetes 3.Diseño de la lógica. Clases Clases dominioDeLaAplicacion biblioteca Pag. Juan José Flores Cueto. Etapa 03 . Nombre del Proyecto: ProySueldoCategoria.

menorSueldo INICIO NUMERO sueldo = 0. sueldo2 = 0 NUMERO sueldo3 = 0. i = 1 HACER LEER categoria SI (categoria <> 0) ENTONCES LEER sueldo SI (i = 1) ENTONCES i=0 mayorSueldo = sueldo menorSueldo = sueldo SINO SI ( sueldo < menorSueldo ) ENTONCES menorSueldo = sueldo FINSI SI (sueldo > mayorSueldo) ENTONCES mayorSueldo = sueldo FINSI FINSI CUANDO categoria SEA CASO 1: sueldo1 = sueldo1 + sueldo TERMINAR CASO 2: sueldo2 = sueldo2 + sueldo TERMINAR CASO 3: sueldo3 = sueldo3 + sueldo FINCUANDO FINSI MIENTRAS ( categoria <> 0 ) ESCRIBIR sueldo1. sueldo2. sueldo3.método main ( ) ENTRADA: sueldo. sueldo2. sueldo3 ESCRIBIR menorSueldo. mayorSueldo.ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS 4. sueldo1 = 0. Algoritmo PrgSueldoCategoria . mayorSueldo FIN Pag. 159 . categoria = 0. categoria SALIDA: sueldo1. mayorSueldo = 0 NUMERO menorSueldo = 0. Diseño de algoritmo para el método principal.

leerInt ( ) . if ( categoria != 0 ) { System. break . } if (sueldo > mayorSueldo ) { mayorSueldo = sueldo . } } Pag.Desarrollo de la Codificación. mayorSueldo = 0. Etapa 04 . do { System. menorSueldo = 0 .Lectura . Clase PrgSueldoCategoria package dominioDeLaAplicacion . categoria = Lectura.println ( “ Suma de sueldos de empleados: ” + sueldo2 ) . Juan José Flores Cueto. class PrgSueldoCategoria { public static void main ( String arg[] ) { int i = 1.println ( “ Ingrese el sueldo del trabajador : ” ) . System. 160 .println ( “ Ingrese la categoría del trabajador : ” ) . sueldo = Lectura.out. } } } while (categoria != 0 ) . System. double sueldo1 = 0.println ( “ Suma de sueldos de obreros: ” + sueldo1 ) . System. Ing. sueldo3 = 0 . case 2: sueldo2 = sueldo2 + sueldo . } } switch (categoria) { case 1: sueldo1 = sueldo1 + sueldo . case 3: sueldo3 = sueldo3 + sueldo . System. double sueldo = 0. } else { if (sueldo < menorSueldo ) { menorSueldo = sueldo . sueldo2 = 0.println ( “ El sueldo más alto es: ” + mayorSueldo ) . System.out.out. categoria = 0 .out.out.out.println ( “ Suma de sueldos de gerentes: ” + sueldo3 ) . if ( i == 1) { i=0.leerDouble ( ) . menorSueldo = sueldo . mayorSueldo = sueldo .println ( “ El sueldo más bajo es: ” +menorSueldo ) .out. import biblioteca. break .

Calcular y mostrar el número de alumnos que tienen promedio final menor que 10. Este proceso se repite para todos los alumnos del curso con la finalidad de determinar su promedio final (nf) y evaluar su rango. 161 . Si el promedio final (nf) está entre 10 y 14 se aumenta 1 a la variable total2. El resultado es almacenado en la variable nf. el número de alumnos con promedio final entre 15 y 18. y los alumnos que tienen promedio final mayor que 18. ‰ Resultado deseado: Mostrar el número de alumnos con promedio final menor que 10. los alumnos que tienen promedio final entre 15 y 18. Se realiza el cálculo del promedio final en base a la fomula: nf = ( n1 + n2 + n3 + ( n4 * 2 ) ) / 5. Ingresar las 4 notas de cada alumno y calcular su promedio final en base a la siguiente fórmula: nf = ( n1 + n2 + n3 + ( n4 * 2 ) ) / 5.Definición de la solución. ‰ Datos necesarios: Las cuatro notas de cada uno de los alumnos del curso. y el número de alumnos con promedio final mayor que 18. Si el promedio final (nf) está entre 15 y 18 se aumenta 1 a la variable total3 y si el promedio final (nf) es mayor que 18 se aumenta 1 a la variable total4.Descripción del problema. n2. el número de alumnos con promedio final entre 10 y 14. Pag. Si el promedio final (nf) es menor que 10 se aumenta 1 a la variable total1. ‰ Procesamiento: Las cuatro notas del alumno se ingresan y se almacenan en las variables n1. Etapa 02 . para ser evaluada. los alumnos que tiene promedio final entre 10 y 14. n3 y n4.ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS Problema 19 Etapa 01 .

1. Diagrama de paquetes 3. 162 . Nombre del Proyecto: ProyNotasRango. Definición de Paquetes y desarrollo del Diagrama de Paquetes.Diseño de la lógica. 2. Juan José Flores Cueto. Ing. Definición de las Clases. Clases Clases dominioDeLaAplicacion biblioteca Pag. Etapa 03 .

total3. n1. total2.5 AND nf < 14.5) ENTONCES total4 = total4 + 1 FINSI i=i+1 FINMIENTRAS ESCRIBIR total1. 163 . Diseño de algoritmo para el método principal. n2. total2. numAlumnos = 0 NUMERO i = 1. total4 INICIO NUMERO n1 = 0. total2 = 0 . nf = 0. n3 = 0. total3 = 0 .método main ( ) ENTRADA: numAlumnos. n3.5) ENTONCES total3 = total3 + 1 FINSI SI (nf >= 17.5 AND nf < 17. total4 FIN Pag.ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS 3. n4 SALIDA: total1. n2 = 0. Algoritmo PrgNotasRango .5) ENTONCES total1 = total1 + 1 FINSI SI (nf >= 10. n4 = 0. total3. total1 = 0 .5) ENTONCES total2 = total2 + 1 FINSI SI (nf >= 14. total4 = 0 LEER numAlumnos MIENTRAS ( i <= numAlumnos ) HACER LEER n1 MIENTRAS (n1 < 0 OR n1> 20) HACER LEER n2 MIENTRAS (n2 < 0 OR n2 > 20) HACER LEER n3 MIENTRAS (n3 < 0 OR n3 > 20) HACER LEER n4 MIENTRAS (n4 < 0 OR n4 > 20) nf = (n1 + n2 + n3 + ( n4 * 2 ) ) / 5 SI (nf < 10.

} } Pag. total2 = 0. i ++ . n1 = Lectura. Ing.leerDouble ( ) .leerDouble ( ) . System. n2 = Lectura.out. if (nf >= 15. } while ((n2 < 0 || n2 > 20) .out. while (i <= numAlumnos) { do { System.out. if (nf >= 10.println ( “ Total alumnos con promedio menor a 10: ” + total1 ) .println ( “ Total alumnos con promedio entre 10 y 14: ” + total2 ) .println ( “ Ingrese el número de alumnos: ” ) . } while ((n1 < 0 || n1 > 20) . System. if (nf >= 17. do { System.out.5 && nf < 15. double n1= 0. n3 = Lectura.5) total4++ .println ( “ Total alumnos con promedio entre 15 y 18: ” + total3 ) .5 && nf < 17.println ( “ Ingrese nota 1 del alumno [” + i + “]: ”). n4 = Lectura. 164 .println ( “ Ingrese nota 2 del alumno [” + i + “]: ”). numAlumnos = 0 .leerInt ( ) . class PrgNotasRango { public static void main ( String arg[] ) { int i = 1. numAlumnos = Lectura.5) total2++ .out. } while (( n3 < 0 || n3 > 20 ) . total3 = 0.leerDouble ( ) .leerDouble ( ) . total4 = 0 . } while (( n4 < 0 || n4 > 20 ) .Desarrollo de la Codificación. Juan José Flores Cueto.println ( “ Ingrese nota 3 del alumno [” + i + “]: ”).out.println ( “ Ingrese nota 4 del alumno [” + i + “]: ”). do { System.out. n3= 0.println ( “ Total alumnos con promedio mayor a 18: ” + total4 ) . nf = (n1 + n2 + n3 + ( n4 * 2) ) / 5 . import biblioteca. System. n2= 0.out. System.5) total1++ . } System. do { System. n4= 0. total1 = 0.Lectura . Etapa 04 . if (nf < 10.out.5) total3++ . Clase PrgNotasRango package dominioDeLaAplicacion . nf= 0.

Elaborar una solución que permita controlar la venta de boletos en un determinado día en un teatro de la capital. ‰ Procesamiento: El costo del boleto para platea. • Número de entradas vendidas para platea. palco y mezanine en un determinado día. costoPal y costoMez respectivamente. platea y mezanine. el monto total recaudado y el número de entradas vendidas para platea. el número de boleto y el tipo de boleto (es decir. • Antes de finalizar. si es para platea. De igual forma. totalPal y totalMez para obtener el total de boletos vendidos (totalVendidas). y se almacenarán en las variables numBoleto y tipo respectivamente. para obtener la ganancia en Pag. costoPal y costoMez) según corresponda. palco o mezanine). cada variable (totalPla. Luego se evaluará el tipo de boleto. Al finalizar la venta de boletos se suma el valor de las variables totalPla. palco y mezanine en el día. Si es un boleto para platea se aumenta 1 a la variable totalPla. Etapa 02 .Definición de la solución. en base a la siguiente información: • Al comenzar. y por cada venta. ‰ Resultado deseado: El número total de entradas vendidas. se leerá una sola vez el precio de entrada para palco. • El total de soles recaudados en el día. si es un boleto para palco se aumenta 1 a la variable totalPal y si es un boleto para mezanine se aumenta 1 a la variable totalMez. Cada vez que se venda un boleto se ingresará el número y tipo de boleto.Descripción del problema. palco y mezanine en general. palco y mezanine se ingresarán a través del teclado y se almacenarán en las variables costoPla. totalPal y totalMez) se multiplica por el costo del boleto (costoPla. palco o mezanine).ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS Problema 20 Etapa 01 . ‰ Datos necesarios: El costo del boleto para platea. 165 . • Por cada entrada vendida se leerá los siguientes datos: número de boleto y lugar (puede ser platea. • El programa terminará cuando el número de boleto sea igual a cero. se deberá proporcionar la siguiente información: • Número total de entradas vendidas durante el día.

Definición de Paquetes y desarrollo del Diagrama de Paquetes. 2. Diagrama de paquetes 3. Definición de las Clases. platea (gananciaPla). 1. Juan José Flores Cueto. 166 . La ganancia total (totalGanancia) se obtiene al sumar el valor de las variables ganaciaPla. Ing.Diseño de la lógica. Nombre del Proyecto: ProyTeatro. Etapa 03 . palco (gananciaPal) y mezanine (gananciaMez). Clases Clases dominioDeLaAplicacion biblioteca Pag. gananciaPal y gananciaMez.

costoPal. Algoritmo PrgTeatro . costoMez HACER HACER LEER numBoleto MIENTRAS ( numBoleto < 0) SI ( numBoleto <> 0 ) ENTONCES HACER LEER tipo MIENTRAS (tipo < 1 OR tipo >3) CUANDO tipo SEA CASO 1 : totalPla = totalPla + 1 TERMINAR CASO 2 totalPal = totalPal + 1 TERMINAR CASO 3 totalMez = totalMez + 1 FINCUANDO MIENTRAS (numBoleto <> 0) totalVendidas = totalPla + totalPal + totalMez ganaciaPla = totalPla * costoPla ganaciaPal = totalPal * costoPal ganaciaMez = totalMez * costoMez totalGanancia = gananciaPla + gananciaPal + gananciaMez ESCRIBIR totalVendidas ESCRIBIR totalGanancia ESCRIBIR totalPla. costoPal. gananciaPal = 0 NUMERO ganaciaMez = 0 LEER costoPla. totalMez = 0 NUMERO costoPla = 0. totalPla. Diseño de algoritmo para el método principal. totalPal = 0. tipo = 0. 167 . totaMez INICIO NUMERO numBoleto = 0. totalGanancia. totalMez FIN Pag. costoPal = 0. totalVendidas = 0 NUMERO totalPla = 0. totalPal. totalPal.método main ( ) ENTRADA: costoPla. costoMez = 0 NUMERO totalGanancia =0.ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS 4. costoMez SALIDA: totalVendidas. gananciaPla = 0.

double gananciaPla = 0. totalVendidas = 0. System. case 2 : totalPal ++ .println ( “ Ingrese el costo de la entrada para palco: ” ) .out.println ( “ Ingrese el costo de la entrada para platea: ” ) . totalMez=0 .out. switch ( tipo) { case 1 : totalPla ++ .out.println ( “ Total vendidas platea: ” + totalPla ) .println ( “ Total vendidas mezanine: ” + totalMez ) . System.leerDouble ( ) .out. Ing.leerDouble ( ) . break . import biblioteca.println ( “ Ingrese el costo de la entrada para mezanine: ” ) .println ( “ Total vendidas palco: ” + totalPal ) . tipo = Lectura. System. break . ganaciaMez = 0 . totalPla=0. [2] Palco [3] Mezanine ” ) .leerInt ( ) . numBoleto = Lectura. System. totalVendidas = totalPla + totalPal + totalMez . System. Juan José Flores Cueto.Desarrollo de la Codificación.out. case 3 : totalMez ++ . costoPla = Lectura.println ( “ [1] Platea.println ( “ Ingrese el número de boleto: ” ) . } } } while ( numBoleto != 0 ) . class PrgTeatro { public static void main ( String arg[] ) { int numBoleto = 0. System. costoPal = 0. costoMez = 0 .out. } } Pag.out.out. System. costoMez = Lectura.out.println ( “ Número total de entradas: ” + totalVendidas ) . ganaciaPla = totalPla * costoPla . totalPal=0. ” + totalGanancia ) . ganaciaMez = totalMez * costoMez . System. costoPal = Lectura. 168 . if ( numBoleto != 0) { do { System.Lectura .out. } while (numBoleto < 0) . gananciaPal = 0. costoPla = 0. Clase PrgTeatro package dominioDeLaAplicacion . totalGanancia = gananciaPla + gananciaPal + gananciaMez . } while (tipo < 1 || tipo > 3) .leerDouble ( ) . tipo = 0. System. do { do { System. double totalGanancia=0.out. Etapa 04 . ganaciaPal = totalPal * costoPal .leerInt ( ) .println ( “ Total recaudado S/.println ( “ Ingrese el lugar ” ) .

169 . el turno y el día del empleado se ingresan a través del teclado y se almacenan en variables (horas. Los empleados de una fábrica trabajan en tres turnos.Descripción del problema. Pag. Etapa 02 . . Dependiendo del turno se obtiene la tarifa para luego hacer el cálculo del jornal de la siguiente forma: jornal = horas * tarifa . Para el turno tarde se incrementa S/ 10. el turno y el día que trabajó el empleado. ‰ Resultado deseado: Calcular y mostrar el jornal diario de cada empleado.00 soles por hora. El resultado es almacenado en una variable (jornal) para luego ser mostrada por pantalla. tarde y noche. La tarifa del turno mañana y tarde es de S/ 8.00 soles por hora. mañana. ‰ Procesamiento: El número de horas. . La tarifa del turno noche es de S/ 10.Definición de la solución.00 soles por concepto de movilidad. la tarifa se incrementa en 50% para los turnos mañana y tarde y en 60% para el turno noche.ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS Problema 21 Etapa 01 . Se desea calcular el jornal diario de cada empleado teniendo en cuenta lo siguiente: . . ‰ Datos necesarios: El número de horas. turno y dia). En caso de ser un día domingo. Este proceso se repite para cada uno de los empleados de la fábrica.

Diagrama de paquetes 3. 170 . Juan José Flores Cueto. 2. Nombre del Proyecto: ProyJornal. 1.Diseño de la lógica. Ing. Definición de Paquetes y desarrollo del Diagrama de Paquetes. Definición de las Clases. Clases Clases dominioDeLaAplicacion biblioteca Pag. Etapa 03 .

” FINSI MIENTRAS (numEmpleados <= 0) MIENTRAS (i < numEmpleados) i=i+1 HACER LEER horas SI (horas <= 0) ENTONCES ESCRIBIR “ Número horas mayor a 0. Algoritmo PrgJornal . Diseño de algoritmo para el método principal. turno.ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS 4. horas. turno = 0 NUMERO tarifa = 0. horas = 0.5 * 8 SINO tarifa = 8 FINSI TERMINAR CASO 3: SI (dia = 7) ENTONCES tarifa = 1. jornal = 0 HACER LEER numEmpleados SI (numEmpleados <= 0) ENTONCES ESCRIBIR “ Número empleados mayor a 0. dia = 0. i = 0. ” FINSI MIENTRAS (dia < 1 OR dia > 7) HACER LEER turno CUANDO turno SEA: CASO 1: CASO 2: SI (dia = 7) ENTONCES tarifa = 1. 171 . dia SALIDA: jornal INICIO NUMERO numEmpleados = 0.método main ( ) ENTRADA: numEmpleados. ” FINSI MIENTRAS (horas <= 0) HACER LEER dia SI (dia < 1 OR dia > 7) ENTONCES ESCRIBIR “ La opción no es válida.6 * 10 SINO tarifa = 10 FINSI TERMINAR OTROS ESCRIBIR “opción no válida” FINCUANDO MIENTRAS (turno <>1 AND turno <>2 AND turno <>3) Pag.

} while (horas <= 0) . Continúa… 4. Pag.Lectura .print ( “ Ingrese horas trabajadas empleado [” + i + “]: ” ) . i = 0. if (numEmpleados <= 0) System. dia = 0. Juan José Flores Cueto.print ( “ Ingrese el número de empleados: ”) . class PrgJornal { public static void main ( String arg[] ) { int numEmpleados = 0. Clase PrgJornal package dominioDeLaAplicacion .Desarrollo de la Codificación.out.método main ( ) SI (turno = 2) ENTONCES jornal = horas * tarifa + 10 SINO jornal = horas * tarifa FINSI ESCRIBIR jornal FINMIENTRAS FIN Etapa 04 . Algoritmo PrgJornal .leerInt ( ) . double tarifa = 0. do { System. if (horas <= 0 ) System.println ( “ El número de empleados debe ser mayor a 0 ” ) . jornal = 0 . turno = 0 . horas = 0. import biblioteca.println ( “ Número de horas mayor a 0 ” ) .leerInt ( ) . numEmpleados = Lectura.out.out. while ( i < numEmpleados ) { i++ . 172 . do { System. Ing. horas = Lectura. } while (numEmpleados <= 0) . Diseño de algoritmo para el método principal.out.

ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS Continúa… Etapa 04 .println ( “ Seleccione el turno del empleado: ”) . else tarifa = 8 .println ( “ Seleccione día trabajado empleado [“ + i + ”]: ” ) . Clase PrgJornal do { System. System.out.println ( “ La opción no es válida ”) .out.out.println ( “ [1] Mañana ”) .println ( “ [2] Martes ” ) . System.println ( “ [3] Noche ”) . System. System. System. else tarifa = 10 . do { System. break .println ( “ [3] Miércoles ” ) .println ( “ [7] Domingo ” ) .out.println ( “ [2] Tarde ”) .5 * 8 .out. if (dia < 1 || dia > 7) System.out.out. turno = Lectura. } } while (turno != 1 && turno != 2 && turno != 3) .out.println ( “ [6] Sábado ” ) .out.out.print ( “ Opción: ”) .println ( “ [1] Lunes ” ) .out. System. System. if (turno == 2) jornal = horas * tarifa + 10 .out. } } } Pag.print( “ Opción: ” ) . System.out. switch (turno) { case 1 : case 2 : if (dia == 7) tarifa = 1. else jornal = horas * tarifa . break .println ( “ El jornal del día del empleado [” + i + “] es: ” + jornal ) . dia = Lectura. default : System. System. case 3 : if (dia == 7) tarifa = 1.leerInt ( ) .println ( “ [5] Viernes ” ) .leerInt ( ) .Desarrollo de la Codificación.println ( “ [4] Jueves ” ) . System.6 * 10 .out.out. System. } while (dia < 1 || dia > 7) .out. System.println ( “ La opción no es válida ”) .out. System. 173 .

‰ Procesamiento: El sexo. la edad y la nota de cada alumno se ingresarán a través del teclado y se almacenarán en variables (sexo. Ing. así como una variable que determine si se continúa o no con el ingreso de los datos de un nuevo alumno. 174 . ‰ Datos necesarios: Sexo. edad y nota). Pag. Problema 22 Etapa 01 .Descripción del problema. mayores de 18 años y aprobados. edad y nota de cada uno de los alumnos del curso. Juan José Flores Cueto. Desarrollar una solución que permita obtener la siguiente información en un salón de clase: ¿Cuántas alumnas están matriculadas en el curso? ¿Cuántos alumnos están matriculados en el curso? ¿Cuántas alumnas son menores de 20 años? ¿Cuántos alumnos son mayores de 18 años? ¿Cuántos alumnos están aprobados? ¿Cuántas alumnas están desaprobadas? Etapa 02 . además número de alumnos matriculados. por cada alumna menor de 20 años o cada alumno mayor de 18 años incrementaremos las variables correspondientes (menores y mayores) y por cada alumna desaprobada o cada alumno aprobado incrementaremos las variables correspondientes (desaprobadas y aprobados) para luego mostrarlos por pantalla. menores de 20 años y desaprobadas. Dicha respuesta será almacenada en una variable (rpta). ‰ Resultado deseado: Número de alumnas matriculadas. Este proceso se repetirá mientras el usuario confirme su deseo de ingresar los datos de otro alumno. Si es una alumna o es un alumno incrementaremos las variables correspondientes (matriculadas y matriculados).Definición de la solución.

Diseño de la lógica. Definición de las Clases. 1. Diagrama de paquetes 3. 2. 175 . Clases Clases dominioDeLaAplicacion biblioteca Pag. Definición de Paquetes y desarrollo del Diagrama de Paquetes. Nombre del Proyecto: ProyClase.ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS Etapa 03 .

edad. matriculados. nota. matriculados = 0 NUMERO menores = 0. ” FINSI MIENTRAS (edad <= 0) HACER LEER nota SI (nota < 0 OR nota > 20) ENTONCES ESCRIBIR “ La nota no es válida. mayores = 0. 176 . menores. desaprobadas = 0. 4. Diseño de algoritmo para el método principal. Juan José Flores Cueto. ” FINSI MIENTRAS (nota < 0 OR nota > 20) CUANDO sexo SEA: CASO ‘f’: CASO ‘F’: matriculadas = matriculadas + 1 SI (edad < 20) ENTONCES menores = menores + 1 FINSI SI (nota < 11) ENTONCES desaprobadas = desaprobadas + 1 FINSI TERMINAR Pag. Algoritmo PrgClase . edad = 0. aprobados = 0 TEXTO sexo = ‘F’.método main ( ) ENTRADA: sexo. ” FINSI MIENTRAS ( sexo<> ‘f’ AND sevo<> ‘F’ AND sexo<> ‘m’ AND sexo<> ‘M’ ) HACER LEER edad SI (edad <= 0) ENTONCES ESCRIBIR “ La edad no es válida. matriculadas = 0. rpta SALIDA: matriculadas. mayores. Ing. desaprobadas. rpta = ‘ ’ HACER i=i+1 HACER LEER sexo SI ( sexo <> ‘f’ AND sexo <> ‘F’ AND sexo <> ‘m’ AND sexo<> ‘M’ ) ENTONCES ESCRIBIR “ El sexo no es válido. nota = 0. aprobados INICIO NUMERO i = 0.

Diseño de algoritmo para el método principal.ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS Continúa… 4.método main ( ) CASO ‘m’: CASO ‘M’: matriculados = matriculados + 1 SI (edad > 18) ENTONCES mayores = mayores + 1 FINSI SI (nota > 10) ENTONCES aprobados = aprobados + 1 FINSI FINCUANDO HACER ESCRIBIR “¿Desea continuar[S/N]? ” LEER rpta SI ( rpta <> ‘s’ AND rpta <> ‘S’ AND rpta <> ‘n’ AND rpta <> ‘N’ ) ENTONCES ESCRIBIR “ La opción no es válida. 177 . ” FINSI MIENTRAS ( rpta <> ‘s’ AND rpta <> ‘S’ AND rpta <> ‘n’ AND rpta <> ‘N’ ) MIENTRAS ( rpta <> ‘s’ OR rpta <> ‘S’ ) ESCRIBIR matriculadas ESCRIBIR matriculados ESCRIBIR menores ESCRIBIR mayores ESCRIBIR aprobados ESCRIBIR desaprobadas FIN Pag. Algoritmo PrgClase .

println( “ Nota no válida ” ) . do { System.out. Juan José Flores Cueto. do { System. do { i ++ . matriculadas = 0. Pag. if (edad <= 0) System. import biblioteca. int mayores = 0. menores = 0 . switch (sexo) { case ‘f’ : case ‘F’ : matriculadas += 1 . 178 . aprobados = 0 . rpta = ‘ ’ . Ing. do { System.Lectura .println ( “ Ingrese la nota del alumno [” + i + “]: ” ) . if (nota < 11) desaprobadas += 1 .out.println ( “ Sexo no válido.println ( “ Ingrese sexo alumno [” + i + “] matriculado [F/M]: ” ) . } while ( sexo != ‘f’ && sexo != ‘F’ && sexo != ‘m’ && sexo != ‘M’ ) .leerChar ( ) . nota = 0. break .leerInt ( ) . ” ) . ”) . } while (nota < 0 || nota > 20) .out.out.println ( “ Edad no válida. char sexo = ‘F’. } while (edad <= 0) .out. edad = Lectura. if (edad < 20) menores += 1 . matriculados = 0. edad = 0. Clase PrgClase package dominioDeLaAplicacion . sexo = Lectura.out.Desarrollo de la Codificación. desaprobadas = 0. if (nota < 0 || nota > 20) System. class PrgClase { public static void main ( String arg[] ) { int i = 0. nota = Lectura.leerInt ( ) . if ( sexo != ‘f’ && sexo != ‘F’ && sexo != ‘m’ && sexo != ‘M’ ) System.println ( “ Ingrese la edad del alumno [” + i + “]: ” ) . Etapa 04 .

} do { System. System.println ( “Hay ” + matriculados + “ alumno(s) matriculado(s).println ( “ ¿Desea ingresar un nuevo alumno [S/N]?: ” ) .Desarrollo de la Codificación. } while ( rpta == ‘s’ || rpta == ‘S’ ) .ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS Continúa… Etapa 04 .out. ”) . Clase PrgClase case ‘m’ : case ‘M’ : matriculados += 1 . ” ) .” ) . ”) . ” ) .out. } while ( rpta != ‘s’ && rpta != ‘S’ && rpta != ‘n’ && rpta != ‘N’ ) . System. rpta = Lectura.leerChar ( ) . if ( rpta != ‘s’ && rpta != ‘S’ && rpta != ‘n’ && rpta != ‘N ’ ) System.out.println ( “Hay ” + matriculadas + “ alumna(s) matriculada(s).out. System.println ( “Hay ” + menores + “ alumna(s) menor(es) de 20 años.println ( “Hay ” + aprobados + “ alumno(s) aprobado(s). System. ” ) .out.println ( “Respuesta no válida.println ( “Hay ” + desaprobadas + “ alumna(s) desaprobada(s).out. System.out. } } Pag.println ( “Hay ” + mayores + “ alumno(s) mayor(es) de 18 años. 179 . System. ” ) . if (nota > 10) aprobados += 1 . if (edad > 18) mayores += 1 .out.

Ing. Juan José Flores Cueto. 180 . Pag.

res = 0. el número de cifras que tiene el número. System. cont = 0.out. else contImp ++ .println ( “ La suma de las cifras es : ” + suma ) . if ( num == numInv ) System.println ( “ El número de cifras impares es : ” + contImp ) . System. else System. Pag. suma = suma + res . System. while ( n != 0 ) { res = n % 10 . numInv = 0. num = Lectura.println ( “ El número es capicua ” ) . Desarrollar una solución que permita ingresar un número por teclado.Descripción del problema.ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS Problema 23 Etapa 01 .Lectura . contPar = 0. System.println ( “ Ingrese un número entero: ” ) . suma = 0. contImp = 0.out.println ( “ El número de cifras es : ” + cont ) . el número de cifras pares e impares. } System.println ( “ El número no es capicua ” ) . Mostrar el número con las cifras invertidas. System. cont ++ . y si el número es capicua o no. numInv = numInv * 10 + res .println ( “ El número invertido es : ” + numInv ) .out.out.out.out. la suma de las cifras.out. if ( res % 2 == 0 ) contPar ++ .Desarrollo de la Codificación. class PrgNumCifras { public static void main ( String arg [ ] ) { int num = 0.println ( “ El número de cifras pares es : ” + contPar ) . import biblioteca. 181 . } } En base al análisis de la codificación desarrolle la Etapa 02 y la Etapa 03 del método. n = n / 10 . n .out. Etapa 04 . Clase PrgNumCifras package dominioDeLaAplicacion .leerInt ( ) . n = num .

*/ import biblioteca. Desarrollar un programa que permita ingresar el día. año = Lectura. mientras que 2000 si lo es.out.println ( “ Ingrese el número del mes: ” ) .println ( “ Ingrese el número del día: ” ) .out. Clase PrgVerificaFecha package dominioDeLaAplicacion. dia = Lectura.java * Dada una fecha en dia. Juan José Flores Cueto. System. System. Ing.leerInt ( ) . bisiesto = false . mes. /** Clase: PrgVerificaFecha. pero los años * múltiplos de 100 sólo son bisiestos cuando a su vez son múltiplos de 400. System. mes y año se determina si esta correcta la fecha y si * es año bisiesto * Un año es bisiesto si es múltiplo de 4. por ejemplo 1984.Descripción del problema. class PrgVerificaFecha { public static void main ( String arg[] ) { int dia.println ( “ Ingrese el año: ” ) . 182 .leerInt ( ) . el mes y el año de una determina fecha. año .Lectura. // verifica año bisiesto if ( año % 4 == 0 && año % 100 != 0 || año % 400 == 0 ) { bisiesto = true .leerInt ( ) . * por ejemplo 1800 no es bisiesto.out.Desarrollo de la Codificación. } //verifica el dia switch (mes) { case 1 : case 3 : case 5 : case 7 : case 8 : case 10 : case 12 : Pag. boolean verifdia = false. mes = Lectura. Determinar si la fecha ingresada es correcta y si el año es bisiesto o no. Problema 24 Etapa 01 . String mess = “ ” . Etapa 04 .

case 2 : mess = “Febrero” . } //selecciona el nombre del mes if ( verifdia && ( mes > 0 ) && ( mes <= 12 ) && ( año > 0 ) ) { switch (mes) { case 1 : mess = “Enero” . case 4 : mess = “Abril” . 183 . case 8 : mess = “Agosto” . case 4 : case 6 : case 9 : case 11 : if ( ( dia > 0) && ( dia <= 30 ) ) verifdia = true . break . } } break . case 7 : mess = “Julio” . break . Pag. case 3 : mess = “Marzo” . } break .ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS Clase PrgVerificaFecha If ( dia > 0 && dia <= 31 ) { verifdia = true . } else { if ( ( dia > 0 ) && ( dia <= 28 ) ) verifdia = true . break . break . break . break . case 6 : mess = “Junio” . break . case 2 : if ( bisiesto ) { if ( ( dia > 0 ) && ( dia <= 29 ) ) { verifdia = true . break . case 5 : mess = “Mayo” . break .

println ( “ Es año bisiesto ” ) . break. } System. } else { System. case 11 : mess = “Noviembre” . 184 . break . Clase PrgVerificaFecha case 10 : mess = “Octubre” . if ( bisiesto ) { System.println ( “ error en fecha ” ) .out.out. } } else { System. break . case 12 : mess = “Diciembre” .out. } } } Pag.println ( “ No es año bisiesto ” ) .println ( dia + “ de ” + mess + “ de ” + año ) . Juan José Flores Cueto. Ing.out.

decena = resto / 10 . centena. System. if ( arabigo >= 1000 && arabigo <= 3000 ) { miles = arabigo / 1000 . break . String romano = “ ” . decena. arabigo = Lectura.leerInt ( ) . resto = resto % 100 . unidad = resto % 10 . case 2 : romano = romano + “MM” .Desarrollo de la Codificación. miles . imprimirlo en números romanos dentro de * rango de 1000 a 3000 * Programación Básica */ import biblioteca. Clase PrgNumRomano package dominioDeLaAplicacion . break .Lectura . /** Clase: PrgNumRomano. class PrgNumRomano { public static void main ( String arg [ ] ) { int arabigo. 185 . Obtener miles switch ( miles ) { case 1 : romano = romano + “M” .java * Dado un año en números arábigos. resto = arabigo % 1000 .ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS Problema 25 Etapa 01 . centena = resto / 100 . case 3 : romano = romano + “MMM” . unidad. Etapa 04 . break .Descripción del problema. Desarrollar un programa que permita ingresar un número arábico entre 1000 y 3000. Determinar y mostrar el equivalente del número ingresado en número romano. //formar el número romano.out. } Pag.println ( “ Ingrese un número entre 1000 y 3000: ” ) . resto.

break . case 3 : romano = romano + “CCC” . case 8 : romano = romano + “DCCC” . break . Juan José Flores Cueto. break . Clase PrgNumRomano //obtener centenas switch ( centena ) { case 1 : romano = romano + “C” . case 5 : romano = romano + “D” . break . case 2 : romano = romano + “XX” . Ing. case 5 : romano = romano + “L” . break . } //obtener decenas switch ( decena ) { case 1 : romano = romano + “X” . case 3 : romano = romano + “XXX” . break . case 6 : romano = romano + “DC” . break . break . break . Pag. break . case 4 : romano = romano + “XL” . case 4 : romano = romano + “CD” . break . break . break . break . case 9 : romano = romano + “CM” . case 2 : romano = romano + “CC” . 186 . case 7 : romano = romano + “DCC” . break . case 6 : romano = romano + “LX” .

case 8 : romano = romano + “VIII” . case 5 : romano = romano + “V” . break . break . break . case 4 : romano = romano + “IV” . case 2 : romano = romano + “II” . } //obtener unidades switch ( unidad ) { case 1 : romano = romano + “I” . break . 187 . case 6 : romano = romano + “VI” . } else { System. break . case 3 : romano = romano + “III” .ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS Clase PrgNumRomano case 7 : romano = romano + “LXX” . break . break . break . case 8 : romano = romano + “LXXX” .out.out. break . } } } Pag. case 7 : romano = romano + “VII” . case 9 : romano = romano + “IX” . break . } // Mostrar número romano System. break . break .println ( " Número ingresado no válido " ) . case 9 : romano = romano + “XC” .println ( Arábigo + “ = ” + romano ) .

println ( “Ingrese un número entero menor que 100: ” ) . switch ( uni ) { case 0 : letra = cero . diez = “diez”. class PrgNumALetras01 { public static void main ( String arg [ ] ) { String letra = “”. do { System. cero = “cero”. uni = num % 10 . siete = “siete” . ochenta = “ochenta”. Juan José Flores Cueto.Lectura . String setenta = “setenta”. 188 .out. } while ( num < 0 || num > 99 ) . Desarrollar un programa que permita ingresar un número entero menor que 100 y permita mostrar su equivalente en letras. Problema 26 Etapa 01 . uno = “uno”. y = “ y ”... trece = “trece”. case 1 : letra = uno . cinco = “cinco”. Clase PrgNumALetras01 package dominioDeLaAplicacion . Reintente!!! ” ) . quince = “quince” . dec. if ( num < 0 || num > 99 ) System. Etapa 04 . dos = “dos”. uni . dec = num / 10 . String veinte = “veinte”.out. String cuatro = “cuatro”. Pag. once = “once” . catorce = “catorce”.Desarrollo de la Codificación. sesenta = “sesenta” . nueve = “nueve”. Ing. break . import biblioteca. treinta = “treinta” . noventa = “noventa” . veinti = “veinti”. String dieci = “dieci” .leerInt ( ) . int num. String doce = “doce”. cincuenta = “cincuenta”. break . num = Lectura.println ( “Número ingresado no válido. tres = “tres” . String ocho = “ocho”.Descripción del problema. String cuarenta = “cuarenta”. seis = “seis”.

case 2 : letra = doce . break . case 3 : letra = trece . case 4 : letra = cuatro . case 1 : letra = once . break . } switch ( dec ) { case 1 : switch ( uni ) { case 0 : letra = diez . case 9 : letra = nueve . break . case 4 : letra = catorce . break . case 6 : letra = seis . case 5 : letra = cinco . case 8 : letra = ocho . break . } break . break . break . break . default : letra = dieci + letra . break . 189 . break . break . case 5 : letra = quince . break . break . break . case 3 : letra = tres . case 7 : letra = siete .ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS Clase PrgNumALetras01 case 2 : letra = dos . Pag.

case 7 : if ( uni == 0 ) letra = setenta . break . } } Pag. case 6 : if ( uni == 0 ) letra = sesenta . Clase PrgNumALetras01 case 2 : if ( uni == 0 ) letra = veinte . Juan José Flores Cueto.print ( “El número ” + num + “ en letras es ” + letra ) . else letra = sesenta + y + letra . Ing. break . case 9 : if ( uni == 0 ) letra = noventa . break . break . break . break . else letra = ochenta + y + letra . else letra = cuarenta + y + letra . 190 . else letra = setenta + y + letra . else letra = cincuenta + y + letra . case 8 : if ( uni == 0 ) letra = ochenta . else letra = noventa + y + letra . break . } System. case 5 : if ( uni == 0 ) letra = cincuenta .out. case 3 : if ( uni == 0 ) letra = treinta . else letra = treinta + y + letra . case 4 : if ( uni == 0 ) letra = cuarenta . else letra = veinti + letra .

println ( “ Ingrese un número entero menor que 1000: ” ) . switch ( uni ) { case 0 : letra = cero .out. desarrollar otro programa que permita ingresar un número entero menor que 1000 y permita mostrar su equivalente en letras. String doce = “doce”. String cuarenta = “cuarenta”. En base al programa anterior.ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS Problema 27 Etapa 01 . String cien = “cien”. String cuatro = “cuatro”. treinta = “treinta”. String setenta = “setenta”. dos = “dos”. 191 . do { System.Lectura . uno = “uno”. ciento = “ciento ”. break . String quinientos = “quinientos ”. trece = “trece”. resto. cincuenta = “cincuenta”. cientos = “cientos ”. cen. nove = “nove”. Etapa 04 . Clase PrgNumALetras02 package dominioDeLaAplicacion . } while ( num < 0 || num > 999 ) . cinco = “cinco”.println ( “ Número ingresado no válido.. diez = “diez”. sesenta = “sesenta”. sete = “sete”. resto = num % 100 . String ocho = “ocho”. quince = “quince”. uni. nueve = “nueve”. tres = “tres”. if ( num < 0 || num > 999 ) System. String dieci = “dieci”. String veinte = “veinte”. noventa = “noventa”. uni = resto % 10 .Descripción del problema. class PrgNumALetras02 { public static void main ( String arg [ ] ) { String letra = “”. ochenta = “ochenta”. dec. catorce = “catorce”. import biblioteca. veinti = “veinti”.Desarrollo de la Codificación. cen = num / 100 . seis = “seis”. int num.. cero = “cero”. num = Lectura. y = “ y ”.leerInt ( ) . once = “once”. siete = “siete”. case 1 : letra = uno . break . Reintente!!! ” ) .out. dec = resto / 10 . Pag.

case 7 : letra = siete . Juan José Flores Cueto. break . case 9 : letra = nueve . break . case 2 : letra = doce . break . case 6 : letra = seis . break . break . case 2 : Pag. case 8 : letra = ocho . break . case 4 : letra = catorce . case 5 : letra = quince . } break . Clase PrgNumALetras02 case 2 : letra = dos . break . break . case 5 : letra = cinco . } switch (dec) { case 1 : switch (uni) { case 0 : letra = diez . break . case 3 : letra = tres . break . break . case 4 : letra = cuatro . Ing. break . case 3 : letra = trece . break . 192 . break . default : letra = dieci + letra . case 1 : letra = once .

case 5 : if ( uni == 0 ) letra = cincuenta . else letra = ochenta + y + letra . case 6 : if ( uni == 0 ) letra = sesenta . case 8 : if ( uni == 0 ) letra = ochenta . else Pag. case 9 : if ( uni == 0 ) letra = noventa . else letra = sesenta + y + letra . case 3 : if ( uni == 0 ) letra = treinta . } switch ( cen ) { case 1 : if ( dec == 0 && uni == 0 ) letra = cien . else letra = veinti + letra . else letra = cincuenta + y + letra . case 4 : if (uni == 0) letra = cuarenta . else letra = treinta + y + letra . else letra = setenta + y + letra . break . else letra = cuarenta + y + letra . break . case 7 : if ( uni == 0 ) letra = setenta . break . 193 . break . else letra = noventa + y + letra .ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS Clase PrgNumALetras02 if ( uni == 0 ) letra = veinte . break . break . break .

break . case 7 : if ( dec == 0 && uni == 0 ) letra = sete + cientos . break . 194 . else letra = sete + cientos + letra . break . else letra = quinientos + letra . else letra = ocho + cientos + letra . break . break . Ing. } } Pag. break . case 3 : if ( dec == 0 && uni == 0 ) letra = tres + cientos . break . else letra = seis + cientos + letra .out. case 4 : if ( dec == 0 && uni == 0 ) letra = cuatro + cientos . break . case 9 : if ( dec == 0 && uni == 0 ) letra = nove + cientos . Juan José Flores Cueto. case 6 : if ( dec == 0 && uni == 0 ) letra = seis + cientos . else letra = dos + cientos + letra . case 5 : if ( dec == 0 && uni == 0 ) letra = quinientos . Clase PrgNumALetras02 letra = ciento + letra .print ( “El número ” + num + “ en letras es ” + letra ) . case 8 : if ( dec == 0 && uni == 0 ) letra = ocho + cientos . else letra = cuatro + cientos + letra . } System. else letra = nove + cientos + letra . break . case 2 : if ( dec == 0 && uni == 0 ) letra = dos + cientos . else letra = tres + cientos + letra .

Existen diversos errores que pueden ocasionar que se lance una excepción en un programa. se debe utilizar la sentencia try para alertar al programa acerca del código que puede ocasionar un error. Ahora. si se desea que la ejecución del programa no se detenga. y utilizar la sentencia catch para capturar y manejar cada una de las excepciones que se puedan lanzar. 195 . una entrada incorrecta de datos (IOException). no ocurren). … … … … … } catch ( ) { // Código de tratamiento de la excepción. Para evitar que la ejecución de un programa se detenga debido a un error que lanza una excepción. Java lanza una excepción que cuando no se captura da lugar a un mensaje sobre lo ocurrido y detiene la ejecución del programa (es importante establecer que las excepciones se lanzan. se deberá capturar la excepción lanzada y manejarla. Las excepciones en Java son objetos de subclases de la clase Throwable. manejarla. una división por cero (ArithmeticException) o una conversión de datos no válida (NumberFormatException). … … … … … } Significa: “Intentar ejecutar las sentencias ubicadas entre las llaves del try y si ocurre un error y se lanza una excepción capturarla con la sentencia catch y manejarla con las sentencias ubicadas entre las llaves del catch”. Pag. por ejemplo. El formato de la sentencia try y catch es el siguiente: Tipo de excepción try { capturada por la sentencia catch con la finalidad de // Código de la aplicación.ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS MANEJO DE EXCEPCIONES Cuando se está ejecutando un programa y ocurre un error.

*/ … … } En el ejemplo anterior. Como se ha indicado. Cada sentencia catch capturará y manejara un excepción. Esto significa que durante la ejecución del programa normalmente se ejecutarán las sentencias que están dentro de las llaves de la sentencia try: try { // Código de la aplicación. interrumpiéndose la ejecución de las sentencias que están entre las llaves de la sentencia try y se ejecutarán las sentencias que están entre las llaves de la sentencia catch. existen diferentes tipos de excepciones por lo que es común observar en un programa una sentencia try con varias sentencias catch. Juan José Flores Cueto. lo que significa que las sentencias que están entre las llaves de la sentencia catch no se ejecutarán. … … } Si no ocurre un error. Ing. no se lanzará ninguna excepción. Pag. siempre y cuando se haya especificado capturar la excepción lanzada. try { /* Código de la aplicación que se prevee que puedan lanzar una excepción. Si ocurre un error. se lanzará una excepción. 196 . */ … … } catch ( NumberFormatException e ) { /* Código de tratamiento de la excepción NumberFormatException. se ha especificado capturar dos excepciones en caso de que estás se lancen (ArithmeticException y NumberFormatException).*/ … … } catch ( ArithmeticException e ) { /* Código de tratamiento de la excepción ArithmeticException.

Un arreglo fué accedido con un ArrayIndexOutOfBoundException índice ilegal (fuera de los límites permitidos). se considera como “buen estilo de programación” el uso de las excepciones en los programas. Se intentó utilizar null donde se NullPointerException requería un objeto.ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS El manejo de excepciones ofrece una forma de escribir o codificar programas con una mayor claridad y sencillez. separando explícitamente el código que maneja los errores del código básico de una aplicación. Se intentó convertir una cadena NumberFormatException con un formato inapropiado a un número. 197 . Como ejemplo de excepciones se puede mencionar: Excepción Descripción Una condición aritmética ArithmeticException excepcional ocurrio. Problemas al realizar operaciones IOException de entrada y salida de datos. Pag. En la actualidad.

Etapa 04 .println ( “ Ingrese el dividendo: ” ) . rpta = dividendo / divisor .leerInt ( ) .println ( “ El resultado de la división es: ” + rpta ) .Lectura . finalizando la ejecución del programa. Analice el siguiente programa y anote sus conclusiones. System. 198 . Intente incluir en el programa anterior el manejo de la excepción lanzada. Ing. rpta .out. class PrgDivisionSinExcepcion { public static void main ( String arg [ ] ) { int dividendo. System.leerInt ( ) . Juan José Flores Cueto. divisor. Al momento de realizar la división se lanzará la excepcion llamada ArithmeticException debido a que no se puede dividir un número entero entre cero. Pag. Desarrollar una solución que permita ingresar dos números enteros.println ( “ Ingrese el divisor: ” ) .Desarrollo de la Codificación. Mostrar el resultado de dividir ambos números. Problema 28 Etapa 01 . dividendo = Lectura. } } Ejecute el siguiente programa e ingrese cero al divisor. Clase PrgDivisionSinExcepcion package dominioDeLaAplicacion .out. import biblioteca.out. Para evitar que el programa finalice es necesario manejar dicha excepción. System.Descripción del problema. Se debe tener en cuenta que existe la posibilidad que el divisor sea igual a cero. divisor = Lectura.

ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS Clase PrgDivisionConExcepcion package dominioDeLaAplicacion. System. dividendo = Lectura.println ( “ El resultado de la división es: ” + rpta ) . System. divisor = Lectura. 199 . divisor. try { rpta = dividendo / divisor .out.Lectura.out.println ( “ Ingrese el dividendo: ” ) .println ( “ Ingrese el divisor: ” ) .out. } } } Pag.println ( “ No se puede dividir un número entre cero ” ) .out. import biblioteca.leerInt ( ) . rpta . } catch ( ArithmeticException e ) { System. class PrgDivisionConExcepcion { public static void main ( String arg [ ] ) { int dividendo. System.leerInt ( ) .

} else { tmp = hora. Manejar excepciones.println ( “ minuto ingresado no válido ” ) . “mm” es igual a los minutos (de 00 a 59 minutos) y “ss” es igual a los segundos (de 00 a 59 segundos). 200 .out. import biblioteca.leerString ( ) . if (ss < 0 || ss > 59) { System. hh = Integer. ss . Clase PrgHoraConExcepcion package dominioDeLaAplicacion .println ( “ Ingrese la hora en el siguiente formato: hh:mm:ss ” ) . ss = Integer. class PrgHoraConExcepcion { public static void main ( String arg [ ] ) { boolean valido . valido = true . } else { valido = false . try { tmp = hora. Desarrollar una solución que permita ingresar la hora en el siguiente formato hh:mm:ss donde “hh” es igual a la hora (de 00 a 23 horas). Problema 29 Etapa 01 . hora = Lectura. if ( hh < 0 || hh > 23 ) { System.parseInt ( tmp ) . Mostrar un mensaje cuando la hora ingresada sea válida.println ( “ Hora ingresada no válida ” ) . tmp .parseInt ( tmp ) .out. mm = Integer. if (mm < 0 || mm > 59) { System.substring ( 3. Ing. mm.Lectura . String hora. } } } Pag.out. } else { tmp = hora.out.Descripción del problema. 2 ) .parseInt ( tmp ) . int hh. Etapa 04 . 5 ) .println ( “ segundo ingresado no válido ” ) .substring ( 0.substring ( 6 ) .Desarrollo de la Codificación. do { System. Juan José Flores Cueto. valido = true . valido = true .

ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS Clase PrgHoraConExcepcion } catch ( NumberFormatException error ) { System. System. ingrese letras en lugar de números. } } En este programa se captura la excepción NumberFormatException para prevenir que no se intente convertir una cadena con un formato inapropiado a un número. valido = true ....println ( “ La hora se ingresó correctamente..out.println ( “Error. Puede probar el programa ingresando como hora lo siguiente: 23:10:xx Es decir. Para poder entender la solución del programa sugiero que revise en el siguiente capítulo la clase Integer (Clase Wrapper) y la clase String. en cualquier parte del formato indicado. ” ) .out. ” ) . 201 . Pag. } } while ( valido ) .

do { System.leerString ( ) . int dia. Juan José Flores Cueto. tmp = fecha.substring ( 5. mes = Integer. 6 ) . if ( fecha. Manejar excepciones. puntos1 = fecha.equals (“/”) && puntos2. if (puntos1.Lectura .substring ( 2. Problema 30 Etapa 01 .Descripción del problema. puntos2 . fecha = fecha. fecha = Lectura.substring ( 0.trim ( ) . Ing.Desarrollo de la Codificación. año . 2 ) .println ( “ Ingrese la fecha en el formato: dd/mm/aaaa ” ) . class PrgFechaConExcepcion { public static void main ( String arg [ ] ) { boolean valido = true . else valido = true . 202 . puntos2 = fecha.substring ( 3. Validar que la fecha ingresada tenga el formato especificado. Clase PrgFechaConExcepcion package dominioDeLaAplicacion . } Pag. import biblioteca. 3 ) .parseInt ( tmp ) .parseInt ( tmp ) . mes. Desarrollar una solución que permita ingresar la fecha en una variable de tipo texto o cadena con el siguiente formato: dd/mm/aaaa. String fecha. Etapa 04 . 5 ) . puntos1. tmp.parseInt ( tmp ) .substring ( 6 ) . tmp = fecha.out. año = Integer.length ( ) == 10 ) { try { tmp = fecha.equals (“/”) ) valido = false . dia = Integer. } catch (NumberFormatException error ) { valido = true .

out.println ( “ El formato esta correcto. System.. 203 . } while ( valido ) .out..out..ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS Clase PrgFechaConExcepcion } else valido = true . Pag. mes y año ” ) .out.print ( “ Ahora Ud. Ingrese la fecha según formato!!! ” ) . } } En este programa se captura la excepción NumberFormatException para prevenir que no se intente convertir una cadena con un formato inapropiado a un número. Puede probar el programa ingresando como fecha lo siguiente: 23/xx/2005 Es decir. System. Para poder entender la solución del programa sugiero que revise en el siguiente capítulo la clase Integer (Clase Wrapper) y la clase String... ver problema 24 y 127. if ( valido ) System.println ( “ Error. en cualquier parte del formato indicado. // Continúa la validación de la fecha. ingrese letras en lugar de números (inclusive en el lugar del / ). continue el programa validando el valor ” ) . System..println ( “ de las variable dia. ” ) .

} else { valido = true .leerString ( ) . tmp = numeros. puntos1 .parseInt ( tmp ) . Clase PrgNumeroConExcepcion package dominioDeLaAplicacion . do { System. numeros = Lectura. int num1.Desarrollo de la Codificación. tmp. } Pag. if ( numeros. Etapa 04 . resultado = num1 / num2 .length ( ) == 8 ) { try { tmp = numeros. Desarrollar una solución que permita ingresar dos números de tres digitos en una variable de tipo texto o cadena con el siguiente formato: nnn//nnn.parseInt ( tmp ) . class PrgNumeroConExcepcion { public static void main ( String arg [ ] ) { boolean valido = true . 3 ) .equals ( “//” ) ) { valido = false .println ( “ Ingrese dos números con el formato: nnn//nnn ” ) . Validar que los números sean de tres cifras y mostrar la división de los mismos. String numeros. Juan José Flores Cueto.trim ( ) .substring ( 0. puntos1 = numeros. System.println ( “ La división es: ” + resultado ) . import biblioteca. 5 ) . numeros = numeros. Ing. Manejar excepciones. 204 .Descripción del problema. Problema 31 Etapa 01 .Lectura . num1 = Integer. num2 = Integer. num2 .out.substring ( 3. if ( puntos1.out.substring ( 5 ) . double resultado .

println ( “ Error.. en cualquier parte del formato indicado. valido = false .out. Puede probar el programa ingresando como números lo siguiente: aaa//123 Es decir. } catch ( ArithmeticException error ) { System. 205 .println ( “ Formato no válido ” ) . Puede probar el programa ingresando como números lo siguiente: 123//000 Para poder entender la solución del programa sugiero que revise en el siguiente capítulo la clase Integer (Clase Wrapper) y la clase String. Ingrese en el formato indicado!!! ” ) . } } while ( valido ) .out. ingrese letras en lugar de números (inclusive en el lugar de las // ).out.println ( “ No se puede dividir un número entre cero ” ) . } } else { valido = true . También se captura la excepción ArithmeticException para prevenir que no se intente dividir los números cuando el segundo número es cero. } } En este programa se captura la excepción NumberFormatException para prevenir que no se intente convertir una cadena con un formato inapropiado a un número.. Pag.ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS Clase PrgNumeroConExcepcion } catch ( NumberFormatException error ) { System. } if ( valido ) { System. valido = true .

206 . Ing. Juan José Flores Cueto. Pag.

los cuales se desarrollan en esta última parte del presente capítulo. Es importante analizar cada una de las soluciones propuestas siguiendo paso a paso el desarrollo de las mismas y desarrollando a su vez las variaciones planteadas sobre los problemas. lenguaje de programación utilizado en el presente texto. desarrollando soluciones y codificándolas en un lenguaje de programación determinado. El desarrollo de las capacidades lógicas se logra con la práctica. Pag. como por ejemplo el lenguaje de programación Java. Existen problemas que por su naturaleza contribuyen de manera significativa a lograr este objetivo. 207 . es necesario que comprenda los conceptos fundamentales relacionados a las estructuras lógicas y las estructuras de datos elementales. con la finalidad de utilizarlas en forma conjunta y lograr desarrollar sus capacidades lógicas. Es decir.ESTRUCTURAS FUNDAMENTALES PARA LA SOLUCIÓN DE PROBLEMAS DESARROLLO DE LAS CAPACIDADES LÓGICAS Cuando un estudiante se inicia en el estudio de la programación.

Pag. Juan José Flores Cueto. 208 . Ing.

* . System. j <= totalFilas. System. j = 0 . for ( i = 1 . } } } Pag. i = 0. * * * * * Etapa 04 – Desarrollo de la codificación. totalFilas = Lectura. public class PrgCuadrado01 { public static void main (String[] args) { int totalFilas = 0. } } while (totalFilas < 2 || totalFilas > 20 ) .out.out. import biblioteca. j++ ) { // Se muestra un asterisco.print ( “*”) . } // Se realiza un salto de línea. Asuma * * * * * que el número de filas puede variar desde 2 hasta 20 y que * * * * * entre los asteriscos no existen espacios en blanco.leerInt ( ) . do { System. 209 . Clase PrgCuadrado01 package dominioDeLaAplicacion . i++ ) { for ( j = 1 . i <= totalFilas. Desarrollar la codificación de una solución que permita mostrar la siguiente figura: * * * * * * * * * * Nota: En la figura mostrada el número de filas = 5. if (totalFilas < 2 || totalFilas > 20 ) { System.print ( “ Valor de fila no válido… Reintente!.println ( ) .print ( “ Valores válidos desde 2 hasta 20: ” ) .out. ” ) .ESTRUCTURAS FUNDAMENTALES PARA LA SOLUCIÓN DE PROBLEMAS Problema 32 Etapa 01 – Descripción del problema.println ( “ Ingresar el número de filas de la figura ” ) . System.out.out.

los valores válidos para i son i=1. Análisis de la solución: Se ingresa el número de filas que va ha tener la figura y se almacena en la variable totalFilas. i++ ) { for ( j = 1 . i=3. j++ ) { … } … } Para cada una de las filas (en el caso de totalFilas=5. Los siguientes 2 problemas son una variación de este problema. el for interno se ejecuta la misma cantidad de veces que el número de filas de la figura y cada vez que se ejecuta muestra un asterisco (en el caso de totalFilas=5. Pag. Para fila=5: 1ra fila ( i=1 ) * * * * * 2da fila ( i=2 ) * * * * * for ( i = 1 . i=4 e i=5). i++ ) { 3ra fila ( i=3 ) * * * * * 4ta fila ( i=4 ) * * * * * } 5ta fila ( i=5 ) * * * * * Ahora necesitamos mostrar un número determinado de asteriscos en cada una de las filas y ese número de asteriscos a mostrar coincide con el número de filas de la figura (para nuestro caso totalFilas=5). i=2.out. nos permite hacer un salto de línea y continuar con la ejecución de la solución siempre y cuando la condición del primer for sea verdadera. i <= totalFilas. Juan José Flores Cueto. la condición de la primera sentencia for va ser verdadera para valores de i=1 hasta i=totalFilas (en el caso de totalFilas=5. Analice sus respectivas soluciones y desarrolle sus propias observaciones. la cual puede variar desde 2 hasta 20.println ( ). Esta situación determina la existencia de la segunda sentencia for dentro de la primera sentencia for (for interno). para i=1. i <= totalFilas. i=3. Cada vez que finaliza el for interno. Ing. Entonces. Los valores válidos de i coinciden con el número de filas que nuestra figura va ha tener. for ( i = 1 . la sentencia System. el for interno se ejecuta 5 veces y mostrará en total 5 asteriscos en cada una de las filas). i=2. por lo cual podemos afirmar que para cada valor de i. j <= totalFilas. corresponde una fila de la figura. 210 . i=4 e i=5). Para nuestra explicación asumiremos que el valor de totalFilas=5.

j <= totalFilas.print ( “ Valores válidos desde 2 hasta 9: ” ) . System.println ( ) . public class PrgCuadrado02 { public static void main (String[] args) { int totalFilas = 0. 1 2 3 4 5 Etapa 04 – Desarrollo de la codificación. if (totalFilas < 2 || totalFilas > 9 ) { System.out. j++ ) { // Se muestra el valor de la variable j.leerInt ( ) . do { System. } } } Pag. for ( i = 1 . Asuma 1 2 3 4 5 que el número de filas puede variar desde 2 hasta 9 y que 1 2 3 4 5 entre los números no existen espacios en blanco. Desarrollar la codificación de una solución que permita mostrar la siguiente figura: 1 2 3 4 5 1 2 3 4 5 Nota: En la figura mostrada el número de filas = 5. i++ ) { for ( j = 1 .* . j = 0 . i <= totalFilas. System.out.print ( j ) . import biblioteca.println ( “ Ingresar el número de filas de la figura ” ) .ESTRUCTURAS FUNDAMENTALES PARA LA SOLUCIÓN DE PROBLEMAS Problema 33 Etapa 01 – Descripción del problema. i = 0. System.println ( “ Valor de fila no válido… Reintente!. totalFilas = Lectura. } // Se realiza un salto de línea.out. Clase PrgCuadrado02 package dominioDeLaAplicacion . 211 . } } while (totalFilas < 2 || totalFilas > 9 ) . ” ) .out.out.

Desarrollar la codificación de una solución que permita mostrar la siguiente figura: 1 1 1 1 1 2 2 2 2 2 Nota: En la figura mostrada el número de filas = 5. do { System. Juan José Flores Cueto. Ing. i = 0. if (totalFilas < 2 || totalFilas > 9 ) { System. j++ ) { // Se muestra el valor de la variable i. Problema 34 Etapa 01 – Descripción del problema. System.out. System.println ( “ Valor de fila no válido… Reintente!. System.print ( “ Valores válidos desde 2 hasta 9: ” ) .out. Asuma 3 3 3 3 3 que el número de filas puede variar desde 2 hasta 9 y que 4 4 4 4 4 entre los números no existen espacios en blanco.out. i++ ) { for ( j = 1 . ” ) . j <= totalFilas. totalFilas = Lectura.* . import biblioteca. } // Se realiza un salto de línea.println ( ) . } } } Pag. } } while (totalFilas < 2 || totalFilas > 9 ) . i <= totalFilas.out. 212 .println ( “ Ingresar el número de filas de la figura ” ) . public class PrgCuadrado03 { public static void main (String[] args) { int totalFilas = 0. Clase PrgCuadrado03 package dominioDeLaAplicacion . 5 5 5 5 5 Etapa 04 – Desarrollo de la codificación. for ( i = 1 .print ( i ) . j = 0 .out.leerInt ( ) .

213 .ESTRUCTURAS FUNDAMENTALES PARA LA SOLUCIÓN DE PROBLEMAS Los últimos dos problemas son una variación del problema 32. en el cuál se desarrolla la siguiente figura: * * * * * * * * * * * * * * * * * * * * * * * * * Con la finalidad de mejorar sus capacidades lógicas sugiero que desarrolle las siguientes variaciones del problema: 1 2 3 4 5 5 4 3 2 1 5 5 5 5 5 6 7 8 9 0 5 4 3 2 1 4 4 4 4 4 1 2 3 4 5 5 4 3 2 1 3 3 3 3 3 6 7 8 9 0 5 4 3 2 1 2 2 2 2 2 1 2 3 4 5 5 4 3 2 1 1 1 1 1 1 Pag.

print ( “ Valores válidos desde 2 hasta 20: ” ) . System.println ( “ Valor de fila no válido… Reintente!. Desarrollar la codificación de una solución que permita mostrar la siguiente figura: * * * Nota: En la figura mostrada el número de filas = 5. Asuma * * * que el número de filas puede variar desde 2 hasta 20 y que * * * * entre los asteriscos no existen espacios en blanco. Ing. } } while (totalFilas < 2 || totalFilas > 20 ) . } // Se realiza un salto de línea.println ( ) . 214 . i <= totalFilas.out. ” ) .leerInt ( ) . if (totalFilas < 2 || totalFilas > 20 ) { System. do { System.*.out. public class PrgTriangulo01 { public static void main(String[] args) { int totalFilas = 0. Clase PrgTriangulo01 package dominioDeLaAplicacion. System. j++ ) { // Se muestra un asterisco. for ( i = 1 .out. * * * * * Etapa 04 – Desarrollo de la codificación. j = 0 . i++ ) { for ( j = 1 . import biblioteca. Juan José Flores Cueto.println ( “ Ingresar el número de filas de la figura ” ) . i = 0. System. j <= i .print ( “*”) .out. Problema 35 Etapa 01 – Descripción del problema. totalFilas = Lectura.out. } } } Pag.

Esto se cumple ya que para i=2 los valores válidos para j serían j=1 y j=2. la sentencia System. Finalizada la ejecución del for interno. Es decir. por lo que el for interno se ejecutaría dos veces y en cada una de las ejecuciones del for interno se mostraría dos asterisco (en consecuencia se mostrarían en total dos asteriscos). Esto se cumple ya que para i=1 el único valor válido para j sería j=1. Para fila=5: 1ra fila ( i=1 ) * 2da fila ( i=2 ) * * for ( i = 1 .ESTRUCTURAS FUNDAMENTALES PARA LA SOLUCIÓN DE PROBLEMAS Análisis de la solución: Se ingresa el número de filas que va ha tener la figura y se almacena en la variable totalFilas.out.Esto se cumple ya que para i=5. los valores válidos para i son i=1. Es decir. j++ ) { … } … } En la primera fila (i=1) se necesita mostrar un asterisco. i=3. pasar a la tercera fila. En nuestro caso la última fila es 5 (i=5) y se necesita mostrar 5 asteriscos. por lo cual podemos afirmar que para cada valor de i. la condición de la primera sentencia for va ser verdadera para valores de i=1 hasta i=totalFilas (en el caso de totalFilas=5. por lo que el for interno Pag. nos permite hacer un salto de línea. i=4 e i=5). j=4 y j=5. Finalizada la ejecución del for interno. Esta situación determina la existencia de la segunda sentencia for dentro de la primera sentencia for (for interno). i <= totalFilas. corresponde una fila de la figura. pasar a la segunda fila. por lo que el for interno se ejecutaría una sola vez y se mostraría solo un asterisco. i++ ) { 3ra fila ( i=3 ) * * * 4ta fila ( i=4 ) * * * * } 5ta fila ( i=5 ) * * * * * Ahora necesitamos mostrar un asterisco en la primera fila (i=1). i=2. 2 asteriscos en la segunda fila (i=2) y asi sucesivamente hasta llegar a la última fila (para nuestro caso hasta la quinta fila Æ i=5).out. i <= totalFilas. Para nuestra explicación asumiremos que el valor de totalFilas=5. En la segunda fila (i=2) se necesita mostrar dos asterisco. Los valores válidos de i coinciden con el número de filas que nuestra figura va ha tener.println ( ). for ( i = 1 . nos permite hacer un salto de línea.println ( ). la sentencia System. 215 . los valores válidos para j serían j=1. Y así sucesivamente hasta llegar a la última fila. i++ ) { for ( j = 1 . Entonces. la cual puede variar desde 2 hasta 20. j=2. j <= i . j=3.

Los siguientes 7 problemas son una variación de este problema. Juan José Flores Cueto. se ejecutaría cinco veces y en cada una de las ejecuciones del for interno se mostraría un asterisco (en consecuencia se mostrarían en total cinco asteriscos). 216 . Pag. Luego se hace un salto de linea y se finaliza la ejecución. Analice sus respectivas soluciones y desarrolle sus propias observaciones. Ing.

public class PrgTriangulo02 { public static void main(String[] args) { int totalFilas = 0. totalFilas = Lectura.out.ESTRUCTURAS FUNDAMENTALES PARA LA SOLUCIÓN DE PROBLEMAS Problema 36 Etapa 01 – Descripción del problema. } } while (totalFilas < 2 || totalFilas > 9 ) .out.*. System.print ( j ) . 1 2 3 4 5 Etapa 04 – Desarrollo de la codificación. i = 0. System. Clase PrgTriangulo02 package dominioDeLaAplicacion. import biblioteca. } // Se realiza un salto de línea. j <= i .println ( ) . } } } Pag. i++ ) { for ( j = 1 .println ( “ Valor de fila no válido… Reintente!. ” ) . j = 0 .print ( “ Valores válidos desde 2 hasta 9: ” ) . i <= totalFilas. for ( i = 1 . 217 .out.leerInt ( ) . System. if (totalFilas < 2 || totalFilas > 9 ) { System. do { System.println ( “ Ingresar el número de filas de la figura ” ) .out. Asuma 1 2 3 que el número de filas puede variar desde 2 hasta 9 y que 1 2 3 4 entre los números no existen espacios en blanco. Desarrollar la codificación de una solución que permita mostrar la siguiente figura: 1 1 2 Nota: En la figura mostrada el número de filas = 5.out. j++ ) { // Se muestra el valor de la variable j.

println ( ) . public class PrgTriangulo03 { public static void main(String[] args) { int totalFilas = 0. import biblioteca. System. j = 0 . Clase PrgTriangulo03 package dominioDeLaAplicacion. i = 0. 5 5 5 5 5 Etapa 04 – Desarrollo de la codificación. System. } } while (totalFilas < 2 || totalFilas > 9 ) . Problema 37 Etapa 01 – Descripción del problema.leerInt ( ) .println ( “ Valor de fila no válido… Reintente!.println ( “ Ingresar el número de filas de la figura ” ) . System. totalFilas = Lectura. i++ ) { for ( j = 1 . Desarrollar la codificación de una solución que permita mostrar la siguiente figura: 1 2 2 Nota: En la figura mostrada el número de filas = 5.out.print ( i ) . for ( i = 1 .out.out. Asuma 3 3 3 que el número de filas puede variar desde 2 hasta 9 y que 4 4 4 4 entre los números no existen espacios en blanco. } // Se realiza un salto de línea. Juan José Flores Cueto.out. j++ ) { // Se muestra el valor de la variable i. 218 . do { System. i <= totalFilas.*.out.print ( “ Valores válidos desde 2 hasta 9: ” ) . j <= i . } } } Pag. Ing. if (totalFilas < 2 || totalFilas > 9 ) { System. ” ) .

if (totalFilas < 2 || totalFilas > 9 ) { System. i . totalFilas = Lectura. i >= 1 . Asuma 5 4 3 que el número de filas puede variar desde 2 hasta 9 y que 5 4 3 2 entre los números no existen espacios en blanco. for ( i = totalFilas. j = 0 . Clase PrgTriangulo04 package dominioDeLaAplicacion. ” ) .ESTRUCTURAS FUNDAMENTALES PARA LA SOLUCIÓN DE PROBLEMAS Problema 38 Etapa 01 – Descripción del problema.out. public class PrgTriangulo04 { public static void main(String[] args) { int totalFilas = 0. } } while (totalFilas < 2 || totalFilas > 9 ) . 219 .println ( “ Valor de fila no válido… Reintente!.) { for ( j = totalFilas.out. do { System.println ( “ Ingresar el número de filas de la figura ” ) . System. System.out. } } } Pag.out. j >= i .out.*. import biblioteca.. Desarrollar la codificación de una solución que permita mostrar la siguiente figura: 5 5 4 Nota: En la figura mostrada el número de filas = 5..) { // Se muestra el valor de la variable j. 5 4 3 2 1 Etapa 04 – Desarrollo de la codificación. } // Se realiza un salto de línea.println ( ) . i = 0. System. j .print ( j ) .print ( “ Valores válidos desde 2 hasta 9: ” ) .leerInt ( ) .

j >= i . } } while (totalFilas < 2 || totalFilas > 9 ) . 1 1 1 1 1 Etapa 04 – Desarrollo de la codificación. System. Problema 39 Etapa 01 – Descripción del problema. Desarrollar la codificación de una solución que permita mostrar la siguiente figura: 5 4 4 Nota: En la figura mostrada el número de filas = 5. i >= 1 . System.print ( “ Valores válidos desde 2 hasta 9: ” ) . i . } } } Pag.out. if (totalFilas < 2 || totalFilas > 9 ) { System.*. do { System. j . 220 . Clase PrgTriangulo05 package dominioDeLaAplicacion. ” ) . j = 0 .) { // Se muestra el valor de la variable i. Juan José Flores Cueto.out. i = 0.println ( ) .println ( “ Valor de fila no válido… Reintente!.out. Ing... public class PrgTriangulo05 { public static void main(String[] args) { int totalFilas = 0. } // Se realiza un salto de línea. totalFilas = Lectura. System. Asuma 3 3 3 que el número de filas puede variar desde 2 hasta 9 y que 2 2 2 2 entre los números no existen espacios en blanco.println ( “ Ingresar el número de filas de la figura ” ) .print ( i ) .) { for ( j = totalFilas.out.out. import biblioteca. for ( i = totalFilas.leerInt ( ) .

for ( i = 1 .out. Desarrollar la codificación de una solución que permita mostrar la siguiente figura: 1 2 3 Nota: En la figura mostrada el número de filas = 5. } System.println ( “ Ingresar el número de filas de la figura ” ) .out. i <= totalFilas. } } while (totalFilas < 2 || totalFilas > 9 ) .out. j++ ) { if ( k == totalFilas) { k=1. i++ ) { for ( j = 1 . Clase PrgTriangulo06 package dominioDeLaAplicacion.print ( k ) . j <= i .println ( ) .*. if (totalFilas < 2 || totalFilas > 9 ) { System. } System.out. totalFilas = Lectura. public class PrgTriangulo06 { public static void main(String[] args) { int totalFilas = 0. 1 2 3 4 5 Etapa 04 – Desarrollo de la codificación. 221 . } else { k ++ . Asuma 4 5 1 que el número de filas puede variar desde 2 hasta 9 y que 2 3 4 5 entre los números no existen espacios en blanco.leerInt ( ) .out.println ( “ Valor de fila no válido… Reintente!.ESTRUCTURAS FUNDAMENTALES PARA LA SOLUCIÓN DE PROBLEMAS Problema 40 Etapa 01 – Descripción del problema. import biblioteca. System. k=0 . do { System. j = 0. i = 0. ” ) .print ( “ Valores válidos desde 2 hasta 9: ” ) . } } } Pag.

j++ ) { if ( k == 9 ) { k=0. Desarrollar la codificación de una solución que permita mostrar la siguiente figura: 1 2 3 Nota: En la figura mostrada el número de filas = 5. ” ) . 1 2 3 4 5 Etapa 04 – Desarrollo de la codificación. j = 0 . i <= totalFilas. System. Ing. do { System. } } } Pag. } System.out. if (totalFilas < 2 || totalFilas > 20 ) { System. totalFilas = Lectura. 222 . public class PrgTriangulo07 { public static void main(String[] args) { int totalFilas = 0. } System.print ( “ Valores válidos desde 2 hasta 20: ” ) .println ( ) . Problema 41 Etapa 01 – Descripción del problema. j <= i . Juan José Flores Cueto.out. for ( i = 1 . import biblioteca. } else { k ++ . Clase PrgTriangulo07 package dominioDeLaAplicacion.out. i++ ) { for ( j = 1 . Asuma 4 5 6 que el número de filas puede variar desde 2 hasta 20 y que 7 8 9 0 entre los números no existen espacios en blanco.print ( k ) .*.println ( “ Valor de fila no válido… Reintente!.out.out.println ( “ Ingresar el número de filas de la figura ” ) . } } while (totalFilas < 2 || totalFilas > 20 ) . i = 0.leerInt ( ) .

*. } System. } } } Pag. Clase PrgTriangulo08 package dominioDeLaAplicacion.out.out. } else { k--. k=0 . totalFilas = Lectura.ESTRUCTURAS FUNDAMENTALES PARA LA SOLUCIÓN DE PROBLEMAS Problema 42 Etapa 01 – Descripción del problema. k=totalFilas+1.out.println ( ) . i = 0. public class PrgTriangulo08 { public static void main(String[] args) { int totalFilas = 0.out. for ( i = 1 . if (totalFilas < 2 || totalFilas > 9 ) { System. Desarrollar la codificación de una solución que permita mostrar la siguiente figura: 5 4 3 Nota: En la figura mostrada el número de filas = 5. j = 0.print ( k ) . j++ ) { if ( k == 1 ) { k = totalFilas .println ( “ Ingresar el número de filas de la figura ” ) . Asuma 2 1 5 que el número de filas puede variar desde 2 hasta 9 y que 4 3 2 1 entre los números no existen espacios en blanco. do { System.out. 5 4 3 2 1 Etapa 04 – Desarrollo de la codificación.leerInt ( ) . } System. j <= i . import biblioteca. i <= totalFilas.print ( “ Valores válidos desde 2 hasta 9: ” ) . 223 . System. i++ ) { for ( j = 1 .println ( “ Valor de fila no válido… Reintente!. } } while (totalFilas < 2 || totalFilas > 9 ) . ” ) .

Los últimos siete problemas son una variación del problema 35. en el cuál se desarrolla la siguiente figura: * * * * * * * * * * * * * * * Con la finalidad de mejorar sus capacidades lógicas sugiero que desarrolle las siguientes figuras y sus respectivas variaciones: * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Pag. 224 . Juan José Flores Cueto. Ing.

} } while (totalFilas < 2 || totalFilas > 20 ) . j = 0 .print ( “ ” ) .leerInt ( ) . j < i .out. Clase PrgTriangulo09 package dominioDeLaAplicacion .println ( “ Valor de fila no válido… Reintente!. ” ) . public class PrgTriangulo09 { public static void main (String[] args) { int totalFilas = 0. * Etapa 04 – Desarrollo de la codificación.print ( “ Valores válidos desde 2 hasta 20: ” ) . Pag. j ++ ) { System.out. j ++ ) { System. i <= totalFilas. import biblioteca. do { System.print ( “*” ) . } } } Intente mejorar la solución anterior (en lugar de usar tres sentencias for utilice solo dos). for ( i = 1 . Asuma * * * que el número de filas puede variar desde 2 hasta 20 y que * * entre los asteriscos no existen espacios en blanco.println ( ) .ESTRUCTURAS FUNDAMENTALES PARA LA SOLUCIÓN DE PROBLEMAS Problema 43 Etapa 01 – Descripción del problema.out. j <= totalFilas . sino lo consigue analice la siguiente solución. totalFilas = Lectura. } System. } for ( j = i .println ( “ Ingresar el número de filas de la figura ” ) . i = 0. i ++ ) { for ( j = 1 .out. 225 .* . if (totalFilas < 2 || totalFilas > 20 ) { System. System.out. Desarrollar la codificación de una solución que permita mostrar la siguiente figura: * * * * * * * * * Nota: En la figura mostrada el número de filas = 5.out.

out. System. } } } Pag. i <= totalFilas.* . if (totalFilas < 2 || totalFilas > 20 ) { System. j ++ ) { if ( i < = j ) { System. j = 0 . i ++ ) { for ( j = 1 .println ( ) .print ( “ ” ) . } } while (totalFilas < 2 || totalFilas > 20 ) . Ing. totalFilas = Lectura. Clase PrgTriangulo09Mejorado package dominioDeLaAplicacion .print ( “*” ) .out.out.out.print ( “ Valores válidos desde 2 hasta 20: ” ) . public class PrgTriangulo09Mejorado { public static void main (String[] args) { int totalFilas = 0. import biblioteca. do { System. for ( i = 1 . i = 0.out.out. Juan José Flores Cueto. 226 .leerInt ( ) . } } System.println ( “ Ingresar el número de filas de la figura ” ) .println ( “ Valor de fila no válido… Reintente!. ” ) . j < = totalFilas . } else { System.

System. if (totalFilas < 2 || totalFilas > 20 ) { System. j = 0 .println ( “ Ingresar el número de filas de la figura ” ) . public class PrgTriangulo10 { public static void main (String[] args) { int totalFilas = 0. } } System. } else { System.println ( ) . 227 . i = 0. for ( i = 1 . i <= totalFilas.out.out.leerInt ( ) . j . } } while (totalFilas < 2 || totalFilas > 20 ) .* .println ( “ Valor de fila no válido… Reintente!.print ( “*” ) .out.out. do { System. Desarrollar la codificación de una solución que permita mostrar la siguiente figura: * Nota: la cantidad de asteriscos que tiene la figura al lado * * derecho es el dato que se debe ingresar. Dicho dato debe tener * * * un valor entre 2 y 20.. } } } Pag.out.out. ” ) .) { if ( i < j ) { System. * * * * * Etapa 04 .Desarrollo de la Codificación. import biblioteca.print ( “ ” ) . En la figura el lado = 5.print ( “ Valores válidos desde 2 hasta 20: ” ) . No existen * * * * espacios en blanco entre los asteriscos.ESTRUCTURAS FUNDAMENTALES PARA LA SOLUCIÓN DE PROBLEMAS Problema 44 Etapa 01 – Descripción del problema. i ++ ) { for ( j = totalFilas . totalFilas = Lectura. j > = 1 . Clase PrgTriangulo10 package dominioDeLaAplicacion .

j++ ) … … … } Sino lo consigue analice la siguiente solución: Clase PrgTriangulo10Mejorado package dominioDeLaAplicacion .print ( “*” ) . } } } Es importante indicar que un mismo problema puede ser solucionado de diferentes maneras. i = 0. 228 .println ( “ Ingresar el número de filas de la figura ” ) .out.out. } } System.out. Ing. do { System. j++ ) { if ( j <= totalFilas . } else { System. import biblioteca.print ( “ ” ) . i ++ ) { for ( j = 1 .print ( “ Valores válidos desde 2 hasta 20: ” ) . i <= totalFilas.* .out.print ( “ Valor de fila no válido… Reintente!.i ) { System. if (totalFilas < 2 || totalFilas > 20 ) { System. System. Juan José Flores Cueto.println ( ) . public class PrgTriangulo10Mejorado { public static void main (String[] args) { int totalFilas = 0. Intente mejorar la solución anterior de tal forma que cambie el for interno por el siguiente for: for ( j = 1 . Pag. j = 0 .leerInt ( ) . ” ) . totalFilas = Lectura.out. j < = totalFilas . for ( i = 1 .out. j < = totalFilas . } } while (totalFilas < 2 || totalFilas > 20 ) .

} } } Pag. System.print ( “ ”) . i <= totalFilas .println ( “ Ingresar el número de filas de la figura ” ) .println ( ) .out. * * * * * Etapa 04 – Desarrollo de la codificación.println ( “ Valor de fila no válido… Reintente!. import biblioteca. Asuma * * * que el número de filas puede variar desde 2 hasta 20 y que * * * * entre los asteriscos existe un espacio en blanco. System.out. System. i = 0.out. System. j < totalFilas . j++ ) { // Se muestra un espacio en blanco. j <= i . 229 .leerInt() . } // Se realiza un salto de linea. j = 0 .*. } } while (totalFilas < 2 || totalFilas > 20 ) . do { System.print ( “* ”) .print ( “ Valores válidos desde 2 hasta 20: ” ) . public class PrgTriangulo11 { public static void main(String[] args) { int totalFilas = 0. i++ ) { for ( j = i . } for ( j = 1 . Clase PrgTriangulo11 package dominioDeLaAplicacion.out. ” ) . if (totalFilas < 2 || totalFilas > 20 ) { System. Desarrollar la codificación de una solución que permita mostrar la siguiente figura: * * * Nota: En la figura mostrada el número de filas = 5. j++ ) { // Se muestra un asterisco y un espacio en blanco. totalFilas = Lectura.out.ESTRUCTURAS FUNDAMENTALES PARA LA SOLUCIÓN DE PROBLEMAS Problema 45 Etapa 01 – Descripción del problema.out. for ( i = 1 .

* ..* . un espacio en blanco y otro asterisco en la segundo fila (i=2) y asi sucesivamente hasta llegar a la última fila (para nuestro caso hasta la quinta fila Æ i=5).* menos cada vez que se muestra una nueva fila. * Nota: Los guiones representan espacios en blanco. Análisis de la solución: Se ingresa el número de filas que va ha tener la figura y se almacena en la variable totalFilas. . Ahora.* . lo cual nos complica la lógica de nuestra solución. * . Es necesario encontrar algunos parámetros para establecer una constante matemática (una relación matemática) que nos permita mostrar adecuadamente la figura. * . hasta llegar a la última fila donde no se muestra * . . Cada vez que se ejecuta el primer for debemos asegurarnos de mostrar los asteriscos necesarios. En la . . .* símbolo. * . * . Para nuestra explicación asumiremos que el valor de totalFilas=5. * . Juan José Flores Cueto. 230 . . * .* . i <= totalFilas .* . * . . Pag. El primer for (como en todos los casos anteriores) está justificado y se ejecuta la misma cantidad de veces que el número de filas de la figura.* Entre un guión y un asterisco no hay ningún . i++ ) { 3ra fila ( i=3 ) * * * 4ta fila ( i=4 ) * * * * } 5ta fila ( i=5 ) * * * * * Es necesario entonces mostrar un asterisco en la primera fila (i=1). * primera fila (i=1) se muestran fila .* . * Nota: Se determina que existe una relación en la parte donde están los espacios en blanco.* . * . un asterisco.* blanco y luego se muestra un espacio en blanco ..* ..* ningún espacio en blanco. para realizar un mejor análisis se va ha representar los espacios en blanco de la figura con un guión - (esto para visualizar la cantidad de espacios en blanco necesarios en cada fila): . * . Para fila=5: 1ra fila ( i=1 ) * 2da fila ( i=2 ) * * for ( i = 1 . Ing. * .. .* Ahora realizaremos una división imaginaria en la figura y separaremos los espacios en blanco que están a la izquierda del primer asterisco de cada fila: .. la cual puede variar desde 2 hasta 20. * . * .1 espacio en .. Pero si observamos bien la figura tenemos que tener en cuenta la ubicación de los asteriscos en cada fila.

ESTRUCTURAS FUNDAMENTALES PARA LA SOLUCIÓN DE PROBLEMAS En la parte que tiene los asteriscos y espacios en blanco entre los asteriscos.. 231 .. * ..* - Intente mejorar la solución anterior (en lugar de usar tres sentencias for utilice solo dos). * .. * . Para fila=5: 1ra fila ( i=1 ) . * . sino lo consigue analice la siguiente solución. for ( j = 1 .out. 3ra fila ( i=3 ) ... (una pareja “*-”)..* ..- 2da fila ( i=2 ) . j++ ) { System. sucesivamente hasta llegar a la última fila donde se muestran cinco parejas.* .* - 5ta fila ( i=5 ) * .* .print ( “* ”) . Para esto.. En la primera fila (i=1) se muestran un asterisco y un espacio en blanco . j <= i .. } 4ta fila ( i=4 ) * . * . Una pareja (formada por un asterisco y un espacio en blanco). * .* . * .* . blanco entre los asteriscos. j++ ) { System. 3ra fila ( i=3 ) * . * .* . Pag. } 4ta fila ( i=4 ) - 5ta fila ( i=5 ) El segundo for interno nos permite mostrar los asteriscos y espacios en blanco que están después de cada uno de los asteriscos en cada una de las filas: Para fila=5: 1ra fila ( i=1 ) * - 2da fila ( i=2 ) * . * . * .. parte donde están los asteriscos y espacios en . for ( j = 1 . en la segunda fila 2 parejas y así * .* . Al analizar la figura determinamos que hay dos partes las cuales son independientes. * . incluiremos un espacio en blanco al final de cada una de las filas de la figura: . por lo cual determinamos la necesidad de emplear dos for internos.print ( “ ”) . es necesario buscar una relación matemática. j < totalFilas . * .* . * .out.* . El primer for interno nos permite mostrar los espacios en blanco que están antes del primer asterisco de cada una de las filas. Nota: Se determina que existe una relación en la .

public class PrgTriangulo11Mejorado { public static void main(String[] args) { int totalFilas = 0. .out.*. Juan José Flores Cueto. .println ( “ Valor de fila no válido… Reintente!.print ( “ ”) . if (totalFilas < 2 || totalFilas > 20 ) { System. j = 0. j < totalFilas * 2 . . i++ ) { for ( j = 1 . i = 0. Entre un guión y un asterisco no hay ningún . System. * . . * . . .. . * .out. 232 .println ( “ Ingresar el número de filas de la figura ” ) . * . j++ ) { if ( ( j >= totalFilas – cont ) && ( j <= totalFilas + cont ) ) { // Se muestra unasterisco y un espacio en blanco.out.print ( “* ”) . * . .out.leerInt() .out. j ++ .print ( “ Valores válidos desde 2 hasta 20: ” ) . do { System. System. mientras que la variable j va ha representar cada una de las columnas. } } while (totalFilas < 2 || totalFilas > 20 ) . System.. * . totalFilas = Lectura. * . * - * . ” ) . . La variable i va ha representar cada una de las filas.* Pag. cont = 0 . * . i <= totalFilas . import biblioteca. * . } else { // Se muestra un espacio en blanco. * .println ( ) . . for ( i = 1 . Ing. símbolo. . * . Clase PrgTriangulo11Mejorado package dominioDeLaAplicacion.out. } } cont ++ . Nota: Los guiones representan espacios en blanco. * . } } } Análisis de la solución: Imagínese ahora al triángulo como si este fuera un rectángulo (complete con guiones los espacios en blanco que tendría la figura si fuera un rectángulo). . System.

* . } Ahora.out. System.out.println ( ) .print ( “ ”) . System.print ( “ ”) .i ) { // Se muestra un espacio en blanco. Utilice el primer planteamiento desarrollado. * . if ( ( j >= totalFilas – cont ) && ( j <= totalFilas + cont ) ) { // Se muestra un asterisco y un espacio en blanco. i <= totalFilas . * . * - . System. } } System. nuevamente intente mejorar la solución. j++ ) { if ( j > totalFilas . } Pag. } También: for ( i = 1 .ESTRUCTURAS FUNDAMENTALES PARA LA SOLUCIÓN DE PROBLEMAS El primer for controla el número de filas que se van ha mostrar (desde i=1 hasta i=totalFilas). * . i++ ) { for ( j = 1 .println ( ) .print ( “* ”) . } else { // Se muestra un espacio en blanco.out.out.print ( “ ”) . * - . j <= totalFilas . . * . 233 . } else { // Se muestra un asterisco y un espacio en blanco. j <= totalFilas . System. .* - * . En el for interno hay una sentencia if que nos permite determinar el símbolo que se va ha mostrar. j++ ) { if ( j <= totalFilas . j ++ .* - for ( i = 1 . * . * - . i++ ) { for ( j = 1 . . i <= totalFilas . * . . System.out.out. . System. El segundo for (for interno) se ejecuta para cada una de la filas y controla el número de símbolos (asteriscos o espacios en blanco) que se van a mostrar (en total se deben mostrar totalFilas * 2 – 1 símbolos). * .out. . } else { // Se muestra un espacio en blanco.print ( “* ”) . } } System. * .i ) { // Se muestra un asterisco y un espacio en blanco.out. Analice nuevamente el siguiente gráfico: .print ( “* ”) .

7… y así suceivamente (no hay espacios en blanco entre los asteriscos).out. Adicionalmente desarrolle las siguientes figuras y sus posibles variaciones: * .1. } else { // Se muestra un espacio en blanco. * * * * * * * * * * * * . * * * * * * * * * * * * . Con la finalidad de mejorar sus capacidades lógicas sugiero que desarrolle todas las variaciones posibles o que se pueda imaginar del presente problema.out. * . System. * * * * * * * * * * * * . i++ ) { for ( j = 1 . * . 234 . * . } } cont ++ . * . } Pag. * . System.out. i <= totalFilas . * . mostrar un asterisco y en las siguientes filas 3.print ( “*”) .println ( ) . // Se muestra la última parte de la solución: for ( i = 1 . j++ ) { if ( ( j >= totalFilas – cont ) && ( j <= totalFilas + cont ) ) { // Se muestra un asterisco. Relación: el número de asteriscos a mostrar en cada fila esta dado por la fórmula: totalFilas * 2 . 5. System. * * * * * * * * * * * * * * * * * * * * * * Nota: Recuerde que los Nota: Observe que en la guiones representan primera fila se desea espacios en blanco. Ing. j < totalFilas * 2 . Juan José Flores Cueto.print ( “ ”) .

import biblioteca. System. * * * * * * Etapa 04 .out.1 . Ingrese entero entre [2.* .leerInt ( ).Desarrollo de la Codificación. System. } } while (totalFilas < 2 || totalFilas > 10 ) .10]: ” ) . j = 1 . diagonal = totalFilas * 2 . El lado del rombo debe tener un valor entre 2 y 10.out. En la figura el lado = 4.out. if (totalFilas < 2 || totalFilas > 10 ) { System.print ( “ Ingrese el lado del rombo entre [2. cont = 0. 235 .10]: ” ) .println ( ) .println ( “ Programa que realiza un rombo de *s con la estructura \“WHILE\” \n” ) .ESTRUCTURAS FUNDAMENTALES PARA LA SOLUCIÓN DE PROBLEMAS Problema 46 Etapa 01 – Descripción del problema. do { totalFilas = Lectura. i = 1. public class PrgRombo01 { public static void main (String args[]) { int totalFilas = 0.println ( “\nValor fuera de rango. Desarrollar la codificación de una solución que permita mostrar la siguiente figura: * * * * * * Nota: desarrollar la figura con la estructura de repetición * * * * MIENTRAS (while). Clase PrgRombo01 package dominioDeLaAplicacion . System.out. Pag. diagonal = 0.

System.out. Intente resolverlo utilizando la sentencia for de Java.cont || j > totalFilas + cont ) // Se muestra un espacio en blanco. while ( i <= diagonal ) { j=1. } j ++ . Ing. System. 236 . else { // Se muestra un asterisco y un espacio en blanco.. else cont .println ( ) . j ++ . System.out.. } } } Analice la solución del problema y anote sus conclusiones. Pag. } if ( i < totalFilas ) cont ++ .print ( “* ” ) .print ( “ ” ) . Juan José Flores Cueto. i ++ . while ( j <= diagonal ) { if ( j < totalFilas .out.

println ( “ Programa que realiza un rombo de números ” ) . cont = 0. diagonal = 0.leerInt ( ) . Ingresar un 4 4 4 4 valor entero desde 2 hasta 9 que representa el número de 3 3 3 elementos de la fila central. Pag. diagonal = 2 * num . System.. 237 . if ( num < 2 || num > 9 ) { System. En la figura el dato = 4.9]: ” ) .out.print ( “ Ingrese el número máximo de la figura entre [2. j = 1 .out.9]: ” ) . Ingrese enteros entre [2.1 . public class PrgRombo02 { public static void main (String args[]) { int num = 0. System. i = 1.ESTRUCTURAS FUNDAMENTALES PARA LA SOLUCIÓN DE PROBLEMAS Problema 47 Etapa 01 – Descripción del problema.println ( ) . do { num = Lectura.out.out.Desarrollo de la Codificación.. import biblioteca. 2 2 1 Etapa 04 . Clase PrgRombo02 package dominioDeLaAplicacion . n = 0. Desarrollar la codificación de una solución que permita mostrar la siguiente figura: 1 2 2 3 3 3 Nota: la figura mostrada es un rombo de número.* . System.println ( “\nValor fuera de rango. } } while ( num < 2 || num > 9 ) .

Adicionalmente desarrolle la siguiente figura y sus posibles variaciones: 1 2 3 4 5 6 7 8 9 1 2 3 4 5 6 7 8 9 1 2 3 4 5 6 7 A continuación se presentan diversas soluciones que permitirán contribuir con el desarrollo de sus capacidades lógicas. System.out. i <= diagonal . System.cont && j <= num + cont ) { // Se muestra el contenido de la variable n y un espacio en blanco.. Ing. j <= diagonal .out. Analice cada una de las soluciones en forma detallada. for ( j = 1 . } } } Modifique está solución utilizando la estructura de repetición while en lugar de la estructura for. j ++ .print ( “ ” ) . System. j ++ ) { if ( j >= num .print ( n + “ ” ) . for ( i = 1 . } else // Se muestra un espacio en blanco. } if ( i < num ) cont ++ . 238 . Pag. else cont . i ++ ) { n = cont + 1 . Tenga en cuenta que se han cambiado los nombres de las variables utilizadas en las soluciones anteriores.out..println ( ) . Con la finalidad de mejorar sus capacidades lógicas sugiero que desarrolle todas las variaciones posibles o que se pueda imaginar del presente problema. Juan José Flores Cueto.

System. fil ++ ) { for( int col = 1 . Asuma * * que el número de filas puede variar desde 2 hasta 15.println ( ) . } } while ( lado < 2 || lado > 15 ) .println ( ) . Clase PrgFiguraA package dominioDeLaAplicacion . System. System. for( int fil = 1 .print ( “ ” ) . Desarrollar la codificación de una solución que permita mostrar la siguiente figura: * * * * * * * Nota: En la figura mostrada el número de filas = 5. col <= lado .ESTRUCTURAS FUNDAMENTALES PARA LA SOLUCIÓN DE PROBLEMAS Problema 48 Etapa 01 – Descripción del problema.print ( “ Ingrese lado del cuadrado entre [2.println ( “\nValor fuera de rango.out.out. } else { // Se muestra un asterisco y un espacio en blanco.15]: ” ) .out. do { lado = Lectura. if ( lado < 2 || lado > 15 ) { System. * * * * * * * Etapa 04 . 239 . Ingrese entero entre [2. System. public class PrgFiguraA { public static void main(String args[]) { int lado = 0.leerInt ( ).println ( “ Programa que realiza un cuadrado hueco\n ” ) . System.Desarrollo de la Codificación.out.15]: ” ) .out.print ( “* ” ) .* . } } } Pag. import biblioteca. col ++ ) { if ( ( 1 < fil && fil < lado ) && ( 1 < col && col < lado ) ) { // Se muestran dos espacios en blanco. fil <= lado . } } System.out.out.

20]: ” ) . Problema 49 Etapa 01 – Descripción del problema. if ( lado < 2 || lado > 20 ) { System. } } } Pag.println ( “\nValor fuera de rango.20]: ” ) .leerInt ( ) .println ( ) . fil ++ ) { for ( int col = 1 .print ( “* ” ) . Clase PrgFiguraB package dominioDeLaAplicacion . Ingrese entero entre [2. public class PrgFiguraB { public static void main(String args[]) { int lado = 0 .out.Desarrollo de la Codificación. En la figura el lado = 5. Ing.out.println ( “ Programa que realiza un triángulo de asteriscos: ” ) . fil <= lado .out. * * * * * * * Etapa 04 .print ( “ Ingrese el lado del triángulo entre [2. } System.out. System. 240 . System. // Un asterisco y un espacio. Juan José Flores Cueto. else System. do { lado = Lectura. } } while ( lado < 2 || lado > 20 ) . Dicho dato debe * * tener un valor entre 2 y 20. import biblioteca.* . col ++ ) { if ( ( col == 1 ) || ( fil == col ) || ( fil == lado ) ) System. System. col <= fil .out. // Dos espacios.println ( ) . Desarrollar la codificación de una solución que permita mostrar la siguiente figura: * * * Nota: la cantidad de asteriscos que tiene la figura al lado izquierdo es el dato que se debe ingresar.out.print ( “ ” ) .out. for ( int fil = 1 .

// Un asterisco y un espacio. La base debe tener un valor impar entre 3 y 25. import biblioteca.out.println ( “ Programa que realiza un triángulo hueco de base impar \n ” ) .out. else System.Desarrollo de la Codificación. * * * * * * * * * * * Etapa 04 .out.println ( “\nValor fuera de rango.println ( ) .fil || fil + 1 == medio ) System. do { base = Lectura. System. col++ ) { if ( col == medio + fil || col == medio . public class PrgFiguraC { public static void main(String args[]) { int base = 0. System. Ingrese impar entre [3.print ( “* ” ) .out.ESTRUCTURAS FUNDAMENTALES PARA LA SOLUCIÓN DE PROBLEMAS Problema 50 Etapa 01 – Descripción del problema. medio = base / 2 + 1 .out. System.* .25]: ” ) . 241 . } } while ( base < 3 || base > 25 || base % 2 == 0 ) .leerInt ( ) . for ( int fil = 0 . col <= base . medio = 0 .out. Clase PrgFiguraC package dominioDeLaAplicacion .print ( “ ” ) . Desarrollar la codificación de una solución que permita mostrar la siguiente figura: * * * Nota: el dato de ingreso debe ser la cantidad de asteriscos que tiene la base. // Dos espacios. * * En la figura la base = 9.25]: ” ) . } } } Pag.out. if ( base < 3 || base > 25 || base % 2 == 0 ) { System. fil++ ) { for ( int col = 1 . fil < medio .print ( “ Ingrese la base impar del triángulo entre [3. } System.println ( ) .

leerInt ( ) . fil <= lado . do { lado = Lectura. System.out. for ( int fil = 1 .* .println ( “\nValor fuera de rango. Ingrese entero impar entre [5. Ing. System.out.print ( “ ” ) . fil ++ ) { for ( int col = 1 .print ( “* ” ) .println ( ) .out.print ( “ Ingrese el lado impar de la ventana entre [5. Clase PrgFiguraD package dominioDeLaAplicacion .15]: ” ) . 242 . Desarrollar la codificación de una solución que permita mostrar la siguiente figura: * * * * * * * * Nota: el lado de la figura debe tener un valor impar entre 5 y 15. } } while ( lado < 5 || lado > 15 || lado % 2 == 0 ) . Juan José Flores Cueto. else System. Problema 51 Etapa 01 – Descripción del problema. import biblioteca. System. public class PrgFiguraD { public static void main ( String args[] ) { int lado = 0 . * * * * * * * * Etapa 04 . } } } Pag. col ++ ) { if ( fil == 1 || fil == lado || fil == lado/2+1 || col == 1 || col == lado || col == lado / 2+1) System.Desarrollo de la Codificación. if ( lado < 5 || lado > 15 || lado % 2 ==0 ) { System.println ( “ Programa que realiza una ventana \n” ) . } System.out.out.println ( ) . col <= lado .out. * * * * * En la figura el lado = 5.15]: ” ) .out.

System. System. do { lado = Lectura. } } while ( lado < 5 || lado > 15 || lado % 2 == 0 ) .Desarrollo de la Codificación.out. fil ++ ) { for ( int col = 1 .print ( “ sus diagonales \n ” ) . } } } Pag.out.print ( “* ” ) . Desarrollar la codificación de una solución que permita mostrar la siguiente figura: * * * * * * * * * Nota: el lado de la figura debe tener un valor impar entre 5 y 15.println ( “ Programa que realiza un cuadrado de asteriscos. col ++ ) { if ( fil == 1 || fil == lado || fil == col || col == 1 || col == lado || col == (lado –fil +1) ) System. public class PrgFiguraE { public static void main (String args[]) { int lado = 0 . fil <= lado .out.15]: ” ) .println ( “\nValor fuera de rango.ESTRUCTURAS FUNDAMENTALES PARA LA SOLUCIÓN DE PROBLEMAS Problema 52 Etapa 01 – Descripción del problema. Clase PrgFiguraE package dominioDeLaAplicacion .print ( “ Ingrese el lado impar del cuadrado entre[5.out.out.15]: ” ) . for ( int fil = 1 . System. col <= lado .out. 243 .print ( “ ” ) .println ( ) .println ( ) . Ingrese impar entre [5. } System. System.out. mostrando ” ) . * * * * * * * * * Etapa 04 .* .out. else System. if ( lado < 5 || lado > 15 || lado % 2 == 0 ) { System. * * * En la figura el lado = 5.leerInt ( ) . import biblioteca.

col <= alto .leerInt ( ) . Clase PrgFiguraF package dominioDeLaAplicacion . else System. public class PrgFiguraF { public static void main (String args[]) { int alto = 0 .out. Juan José Flores Cueto.out. 244 . import biblioteca.print ( “ Ingrese el alto (número par) de la figura entre [4.out.18]: ” ) . fil ++ ) { for ( int col = 1 .print ( “* ” ) . Desarrollar la codificación de una solución que permita mostrar la siguiente figura: * * Nota: el lado de la figura debe ser un número par con un valor * * desde 4 hasta 18.out. } } while ( ( alto < 4 ) || ( alto > 18 ) || ( alto % 2 == 0 ) ) .println ( ) .out.out. * * * * * * * * Etapa 04 .out. else System. for ( int fil = 1 . fil <= alto .print ( “* ” ) . col ++ ) { if ( fil <= ( alto / 2 ) ) if ( col == 1 || col == alto ) System.Ingrese un número par entre [4. } } } Pag. } System.Desarrollo de la Codificación.prinlnt ( “\nValor fuera de rango.println ( ) .18]: ” ) .println ( “ Programa que realiza una figura similar a la letra U \n ” ) . System.* . System. if ( ( alto < 4 ) || ( alto > 18 ) || ( alto % 2 == 0 ) ) { System. En la figura el lado = 4.print ( “ ” ) .out. Ing. Problema 53 Etapa 01 – Descripción del problema. System. do { alto = Lectura.

print ( “ Ingrese el lado del triángulo entre [2.out. else System. Clase PrgFiguraG package dominioDeLaAplicacion . public class PrgFiguraG { public static void main (String args[]) { int lado = 0. System. if ( lado < 2 || lado > 15 ) { System.println ( ) . System.fil < col ) System. while ( col <= mayor ) { if ( col <= fil || mayor . do { lado = Lectura.15]: ” ) . En la * * * * * * figura el lado = 5.ESTRUCTURAS FUNDAMENTALES PARA LA SOLUCIÓN DE PROBLEMAS Problema 54 Etapa 01 – Descripción del problema.out.out.Desarrollo de la Codificación. fil <= lado .print ( “ frente a frente a sus hipotenusas \n ” ) .print ( “ ” ) . for ( int fil = 1 .out.leerInt ( ) .println ( “ Programa que realiza dos triángulos de asteriscos ”). } } while ( lado < 2 || lado > 15 ) . fil ++ ) { col = 1 . col = 0 . col ++ . import biblioteca.15]: ” ) .out.print ( “* ” ) .out.println ( “\nValor fuera de rango. System.println ( ) .out.out. } System. Ingrese entero entre [2. * * * * * * * * * * * * * * * * * * Etapa 04 . } } } Pag.* . mayor = (2 * lado ) + 1 . mayor = 0. Desarrollar la codificación de una solución que permita mostrar la siguiente figura: * * * * * * Nota: el lado de la figura debe tener un valor entre 2 y 15. System. 245 .

15]: ” ) . ” ) . Juan José Flores Cueto. Clase PrgFiguraH package dominioDeLaAplicacion . do { base = Lectura. En la * * * * * * figura el lado = 5. for ( int fil = 1 . public class PrgFiguraH { public static void main (String args[]) { int base = 0. } System. * * * * * * * * * * * * * * * * * * Etapa 04 . col ++ . while ( col <= mayor ) { if ( (( base-fil ) < col && col <= base) || (( base+1) < col && col <= base+1+fil ) ) System.print ( “ Ingrese la base del triángulo entre [2. 246 .15]: ” ) . fil ++ ) { col = 1 . System.println ( ) .out. System. mayor = 0. Desarrollar la codificación de una solución que permita mostrar la siguiente figura: * * * * * * Nota: el lado de la figura debe tener un valor entre 2 y 15. import biblioteca. mayor = ( 2 * base ) + 1 .Desarrollo de la Codificación.* . else System.print ( ‘ ’ ) .println ( “ Programa que realiza dos triángulos de asteriscos. System. fil <= base .print ( “ frente a frente a sus catetos \n ” ) .out.print ( ‘*’ ) . Problema 55 Etapa 01 – Descripción del problema.out. if ( base < 2 || base > 15 ) { System.out. System. } } while ( base < 2 || base > 15 ) . col = 0. } } } Pag.println ( ) .leerInt ( ) .out.out. Ing.println ( “\nValor fuera de rango.out. Ingrese entero entre [2.out.

print ( “ Ingrese la base del rectángulo: ” ) . System. } } } while ( ! ( alto >1 && alto < base ) ) . Ingrese entero mayor a 1 y ” ) . En la figura la base=10 * * y altura=5.. if ( base < 2 ) { System.out. System.Debe ser menor a la base [“ + base + ”]: ” ) . Ingrese entero mayor a 2: ” ) .println ( “\nValor fuera de rango. public class PrgFiguraI { public static void main (String args[]) { int base = 0. import biblioteca. } else { System.leerInt ( ) .. Desarrollar la codificación de una solución que permita mostrar la siguiente figura: * * * * * * * * * * * Nota: la base y la altura del cuadrado se ingresarán por teclado. alto = 0. do { base = Lectura.out. 247 . Pag.out.leerInt ( ) .out.print ( “ Ingrese el alto del rectángulo. Clase PrgfiguraI package dominioDeLaAplicacion .out.println ( “ Programa que genera un rectángulo hueco de base > alto \n ” ) . } } while ( base < 2 ) .out. do { alto = Lectura. if ( alto < 1 || alto >= base ) { if ( alto == base ) { System. * * * * * * * * * * * Etapa 04 .println ( “ Para generar el rectángulo hueco en pantalla la base ” ) . System.print ( “\nEs un cuadrado.out.print ( “ a base [“ + base + ”]: ” ) .Desarrollo de la Codificación.print ( “ debe ser >2 y el alto>1 \n ” ) . Ingrese entero mayor a 1 y menor ” ) . System.out.print ( “ menor a base [“ + base + ”]: ” ) . System.out. La base deberá ser mayor que la altura.ESTRUCTURAS FUNDAMENTALES PARA LA SOLUCIÓN DE PROBLEMAS Problema 56 Etapa 01 – Descripción del problema. System.* .print ( “\nValor fuera de rango. System.out.

Ing. Juan José Flores Cueto.

System.out.println ( ) ;
for ( int fil = 1 ; fil <= alto ; fil ++ ) {
for ( int col = 1 ; col <= base ; col ++ ) {
if ( fil == 1 || fil == alto || col == 1 || col == base )
System.out.print ( “* ” ) ;
else
System.out.print ( “ ” ) ;
}
System.out.println ( “ ” ) ;
}
}
}

Pag. 248

ESTRUCTURAS FUNDAMENTALES PARA LA SOLUCIÓN DE PROBLEMAS

Problema 57

Etapa 01 – Descripción del problema.

Desarrollar la codificación de una solución que permita mostrar en pantalla la tabla de multiplicar
de los 12 primeros números naturales. Asegurese de establecer el espaciado correspondiente
para que no se muestre desordenada la tabla, de tal modo que quede de la siguiente forma:

Etapa 04 – Desarrollo de la codificación.

Clase PrgFiguraJ

package dominioDeLaAplicacion ;

public class PrgFiguraJ {

public static void main (String[] args) {

for ( int i = -1 ; i <= 12 ; i ++ ) {
for ( int j = -1 ; j <= 12 ; j++) {
if ( i >= 1 && j >= 1 ) {
if ( i * j < 10 ) // condiciones para dar el correcto.
System.out.print ( “ ” + ( i * j ) + “ ” ) ; // espaciado en los productos.
else {
if ( i * j < 100 )
System.out.print ( “ ” + ( i * j ) + “ ” ) ;
else
System.out.print ( ( i * j ) + “ ” ) ;
}
} else {
if ( j == -1 && i == -1 ) // condiciones para dar el correcto
System.out.print ( “ * ” ) ; // espaciado en la prim. Fila y la
else { // prim. Columna

Pag. 249

Ing. Juan José Flores Cueto.

if ( i == -1 && j > 0 )
if ( j < 10 )
System.out.print ( “ ” + j + “ ” ) ;
else
System.out.print ( “ ” + j + “ ” ) ;
if ( j == -1 && i > 0 ) {
if ( i < 10 )
System.out.print ( “ ” + i + “ ” ) ;
else
System.out.print ( i + “ ” ) ;
}
if ( j == 0 && i != 0 )
System.out.print ( “ i ” ) ;
if ( i == 0 )
System.out.print ( “----” ) ;
}
}
}
System.out.println ( ) ;
}
}
}

Analice la solución y modifíquela de tal forma que el usuario ingrese la cantidad de números
que debe incluir la tabla de multiplicación. Asegúrese de establecer los valores válidos para
dicha tabla de multiplicar.

Pag. 250

ESTRUCTURAS FUNDAMENTALES PARA LA SOLUCIÓN DE PROBLEMAS

Problema 58

Etapa 01 – Descripción del problema.

Desarrollar la codificación de una solución que permita mostrar la siguiente figura:

Etapa 04 – Desarrollo de la codificación.

Clase PrgFiguraK

package dominioDeLaAplicacion ;

public class PrgFiguraK {

public static void main ( String[] args ) {

int fil = 10, col = 10 ;

for ( int i = 1 ; i <= fil ; i ++ ) {

for ( int j = 1 ; j <= col ; j ++ ) {

if ( i == j || ( col + 1 - j ) == i )
System.out.print ( “ ” ) ;
else
System.out.print ( “***” ) ;
}

System.out.println ( ) ;

}
}
}

Analice la solución y modifíquela de tal forma que el usuario ingrese la cantidad de filas y
columnas que debe tener la figura. Asegúrese de establecer los valores válidos para dichos
datos.

Pag. 251

Ing. Juan José Flores Cueto.

Problema 59

Etapa 01 – Descripción del problema.

Desarrollar la codificación de una solución que permita mostrar la siguiente figura:

Etapa 04 – Desarrollo de la codificación.

Clase PrgFiguraL

package dominioDeLaAplicacion;

public class PrgFiguraL {

public static void main ( String[] args ) {
int fil = 10, col = 10 ;

for ( int i = 1 ; i <= fil ; i ++ ) {
for ( int j = 1 ; j <= col ; j ++ ) {
if ( i == 1 || j == 1 || j == col || i == fil )
System.out.print ( “* ” ) ;
else {
if ( (( i==3 || i==8 ) && j>=3 && j<=8 ) || (( j==3 || j==8 ) && i>=3 && i<=8 ) )
System.out.print ( “* ” ) ;
else {
if ( ( i >=5 && i<=6 ) && ( j>=5 && j<=6 ) )
System.out.print ( “* ” ) ;
else
System.out.print ( “ ” ) ;
}
}
}
System.out.println ( ) ;
}
}
}

Analice la solución y modifíquela de tal forma que el usuario ingrese la cantidad de
cuadrados que debe tener la figura. Asegúrese de establecer los valores válidos para dicho
dato.

Pag. 252

ESTRUCTURAS FUNDAMENTALES PARA LA SOLUCIÓN DE PROBLEMAS

Problema 60

Etapa 01 – Descripción del problema.

Desarrollar la codificación de una solución que permita mostrar la siguiente figura:

Etapa 04 – Desarrollo de la codificación.

Clase PrgFiguraM

package dominioDeLaAplicacion ;

public class PrgFiguraM {

public static void main (String args[]) {

int fil = 27, col = 24 ;

for ( int i = 1 ; i <= fil ; i ++ ) {
for ( int j = 1 ; j <= col ; j ++ ) {
if ( ( ( j == 4 || j == 21 ) && ( i >= 4 && i <= 24 ) ) ||
( ( i == 4 || i==24 ) && ( j >= 4 && j <=20 ) ) ||
( i >= 8 && i <= 20 ) && ( j >= 8 && j <= 17 ) )
System.out.print ( “ ” ) ;
else
System.out.print ( “* ” ) ;
}
System.out.println ( ) ;
}
}
}

Analice la solución y modifíquela de tal forma que el usuario ingrese la cantidad de filas y
columnas que debe tener la figura.

Pag. 253

Ing. Juan José Flores Cueto.

Finalmente, sugiero que desarrolle las posibles variaciones de los siguientes problemas:

* * * * * * *
* - - - * * * * - *
* - - - * * - * * - - - *
* - - - * * - - * * - - - - - *
* * * * * * * * * * * * * * * * * * *

* * 1
* * * - * 2 - 3
* * * * - - - * 4 - 5 - 6
* * * * * - - - - - * 7 - 8 - 9 - 0
* * * * * * * * * * - - - - - - - * 1 - 2 - 3 - 4 - 5
* * * * * - - - - - * 6 - 7 - 8 - 9
* * * * - - - * 0 - 1 - 2
* * * - * 3 - 4
* * 5

Nota; Tenga presente que los guiones (-) en las figuras representan espacios en blanco.

Pag. 254

ESTRUCTURAS FUNDAMENTALES PARA LA SOLUCIÓN DE PROBLEMAS

Pag. 255

Ing. Juan José Flores Cueto.

Pag. 256

Capítulo
Clases Básicas Incorporadas en

3
el Lenguaje de Programación
Java

Temas:
Introducción.
El paquete del lenguaje Java: java.lang
Envoltorios de tipos de datos primitivos: Wrappers
• Introducción.
• Métodos.
• Problemas resueltos.

Funciones matemáticas: Clase Math
• Introducción.
• Métodos.
• Problemas resueltos.

Manejo de cadenas: Clase String
• Introducción.
• Métodos.
• Problemas resueltos.

Otras clases en Java

CLASES BÁSICAS INCORPORADAS EN EL LENGUAJE DE PROGRAMACIÓN JAVA

CAPÍTULO III

CLASES BÁSICAS INCORPORADAS EN EL
LENGUAJE DE POGRAMACION JAVA

INTRODUCCIÓN

Un algoritmo constituye una lista completa de pasos secuenciales y una descripción de los
datos que dichos pasos deben manipular para resolver un determinado problema. La lista de
pasos se desarrolla utilizando las estructuras lógicas y las instrucciones o sentencias de
bifurcación y están contenidas en los métodos, mientras que los datos se almacenan en las
estructuras de datos.

MARCO DE TRABAJO
ENUNCIADO
DEL
PROBLEMA
Etapa 02

Definición
Solución Etapa 03

Diseño
Solución Etapa 04

Desarrollo
Solución

Pag. 259

ALMACENADOS EN: • Estructuras de datos tipo variables. siendo el método main( ). Ing. • Estructuras lógicas de repetición. LISTA DE PASOS SENTENCIAS DESCRIPCIÓN DECLARACIÓN Y DE DATOS DEFINICIÓN DE DATOS SE DESARROLLAN UTILIZANDO: • Estructuras lógicas de secuencia. 260 . que tienen diferentes funciones y están agrupadas por medio de paquetes. • Estructuras lógicas de decisión. es decir. TAMBIÉN: • Clases incorporadas en el lenguaje de programación utilizado. con métodos y atributos. contiene una gran variedad de clases. el método principal que tiene como función iniciar la ejecución de una aplicación desarrollada en Java. • Instrucciones de bifucación. Es decir. Pag. Los algoritmos son desarrollados dentro de los métodos. El lenguaje de programación Java contiene diversas clases preprogramadas. Juan José Flores Cueto. todo programa en Java está contenido en uno o mas métodos.

especifica una estructura para almacenar los atributos y los métodos operativos permisibles que se aplican a cada uno de sus objetos (comparten datos o atributos y métodos comunes). 2 Clase: Colección de objetos del mismo tipo. Un paquete permiten organizar las clases.lang. 261 . 2 Es importante mencionar que utilizando las clases preprogramadas de Java se puede ahorrar mucho tiempo y esfuerzo de programación. construyendo fácilmente aplicaciones profesionales. El mundo real se modela mediante clases.CLASES BÁSICAS INCORPORADAS EN EL LENGUAJE DE PROGRAMACIÓN JAVA El presente capítulo. agrupadas en el paquete java. trata sobre las clases básicas incorporadas en el lenguaje de 1 programación Java. Una clase es una abstracción y no referencia a ningún objeto en particular. Un paquete contiene clases que tienen funciones similares. 1 Paquete: Conjunto de clases similares. Pag. Una clase es una implantación de un “tipo de objeto”.

Pag. Ing. Juan José Flores Cueto. 262 .

263 . real o abstracta.lang debido a su importancia no requiere ser importado por las aplicaciones para usar las clases que contiene. en los métodos se desarrollan o codifican los algoritmos. clases para 5 manipular cadenas de caracteres.lang.CLASES BÁSICAS INCORPORADAS EN EL LENGUAJE DE PROGRAMACIÓN JAVA EL PAQUETE DEL LENGUAJE JAVA El paquete del lenguaje Java. Una API es un conjunto de normas que determinan como debe usarse una determinada función de un lenguaje de programación en una aplicación. es decir. es uno de los paquetes más 3 importantes de la API de Java.* . acerca del cual almacenamos datos y los métodos que controlan dichos datos. está automáticamente importado para todos los programas. una clase que proporciona métodos correpondientes a las funciones matemáticas. conocido también como java. Pag. por lo que la siguiente sentencia no será necesaria: import java. Entre las clases más importantes están las siguientes: Boolean Double Object StringBuffer Byte Float Package System Character Integer Process Thread Class Long Runtime Trowable ClassLoader Math Short Compiler Number String 3 API: Aplication Program Interface. 4 Objetos: Modelos de entes del mundo. Los métodos especifican la forma en que se controlan los datos de un objeto y es donde se define el comportamiento del mismo. El paquete java. En palabras sencillas. 5 Métodos: Desarrollo de algoritmos. y contiene las clases que constituyen el corazón del lenguaje de programación Java. El paquete Java.lang contiene clases que encapsulan los tipos primitivos de datos.lang. una clase 4 que proporciona los objetos para manipular la entrada y la salida estándar. Un objeto de software es cualquier cosa. etc.

En su lugar. Las clases abstractas se utilizan para forzar a los programadores a desarrollar algunos o todos los métodos de una clase. Clase que proporciona los objetos necesarios para manipular y tratar cadenas de caracteres. Pag. codificar los métodos que son declarados como abstractos en la clase abstracta y crear o instanciar objetos a partir de la clase derivada. 2. Entre las clases a tratar en el presente capítulo se tienen: 1. Utilizando la herencia se puede derivar una nueva clase a partir de otra clase existente. Clases que envuelven los tipos de datos primitivos. La Herencia es uno de los conceptos más importantes de la Programación Orientada a Objetos (POO). • Character. Cada una de estas clases (consideradas subclases ). 3. La nueva clase se llama Clase Derivada (o subclase) y la clase original se llama Clase Base (o superclase). Clase que proporciona métodos correspondientes a las funciones matemáticas básicas. • Float. • Double. 7 Clase Abstracta: Clase tratada como SuperClase. conocidas como las clases 6 wrappers (envoltorios). se debe derivar una nueva clase a partir de la clase abstracta. 264 . 6 Herencia: Subclase y Superclase. Una Clase Abstracta es un tipo de clase de la cual no se pueden crear o instanciar objetos. • Boolean. • Byte. se derivan de la clase abstracta Number (considerada superclase). • Short. • Integer. Juan José Flores Cueto. • Math. Ing. • Long. a 7 excepción de la clase Character. donde la nueva clase derivada heredará todos los atributos y métodos de la clase existente. • String.

8 Por otro lado. Algunos métodos pueden ser invocados o ejecutados utilizando directamente el nombre de la clase en la cual están definidos. Crear un objeto o instanciar una clase se refiere a poder tener una representación real de una clase. 8 Instancia: Representación concreta de una clase. Una Instancia viene a ser lo mismo que un objeto. 265 . Estos métodos son conocidos como métodos estáticos o de clase. Pag. tal es el caso de los métodos de la clase String de Java.CLASES BÁSICAS INCORPORADAS EN EL LENGUAJE DE PROGRAMACIÓN JAVA En Java. otros métodos son invocados o ejecutados utilizando un objeto o instancia de la clase en la cual están definidos. los métodos siempre están dentro de una clase. Estos métodos son conocidos como métodos de instancia o de objeto. tal es el caso de los métodos de la clase Math de Java.

266 . Juan José Flores Cueto. Pag. Ing.

Esto tiene algunas ventajas desde el punto de vista de la eficiencia. Dichas clases son conocidas como las clases wrappers (envoltorios). byte. estando en la parte superior de la jerarquía. short). que permiten tratarlos como objetos. long. char. Esto significa que los tipos de datos primitivos no son objetos y se sitúan fuera de la 9 jerarquía de clases de Java. traslación.lang). conocidos también como tipos de datos simples. Dichas clases se muestran a continuación: TIPO DE DATO CLASES PRIMITIVO WRAPPERS boolean Boolean byte Byte char Character double Double float Float int Integer Long Long 9 Jerarquía de clases: Forma de ordenar las clases. entre otras. double. La jerarquía de clases es una forma de ordenar las clases existentes en un lenguaje de Programación Orientado a Objetos (POO). Existe una clase wrapper para cada uno de los tipos de datos primitivos. tales como la conversión con cadenas de caracteres. Pag. tal y como se representan en un lenguaje de programación convencional. Una jerarquía de clases define conceptos abstractos en la parte superior de la jerarquía y conforme se desciende en la jerarquía los conceptos se tornan cada vez más concretos. son los únicos elementos del lenguaje de programación Java que se representan internamente a través de valores. comprobación. por lo que en Java se han creado clases que permiten integrar los tipos de datos primitivos o simples dentro de la jerarquía de clases. float. 267 . Java tiene su propia jerarquía de clases.CLASES BÁSICAS INCORPORADAS EN EL LENGUAJE DE PROGRAMACIÓN JAVA ENVOLTORIOS DE LOS TIPOS DE DATOS PRIMITIVOS: CLASES WRAPPERS INTRODUCCIÓN Los tipos de datos primitivos (boolean. interesa sacrificar parte de la eficiencia por flexibilidad. Los wrappers son clases diseñadas para ser un complemento de los tipos de datos primitivos y proporcionan métodos para realizar diferentes tareas con los tipos de datos primitivos. En ocasiones. la clase Object (esta clase pertenece al paquete java. int.

Juan José Flores Cueto. tienen un método que permite convertir desde una cadena (String) al tipo primitivo. TIPO DE DATO CLASES PRIMITIVO WRAPPERS Short Short Cada uno de estas clases wrappers (a excepción de Character). en general.lang.lang. JERARQUÍA DE CLASES Y HERENCIA java.lang.Boolean java. para crear un objeto de la clase Integer utilizamos: int i = 5. Para crear un objeto en Java se usa la sentencia new (a excepción de los objetos de algunas clases. como los objetos de la clase String que no necesariamente se crean con dicha sentencia). Por ejemplo.lang. Pag. es un objeto de la clase Integer. tienen métodos estáticos y métodos de instancia. Para ejecutar un método de instancia es necesario crear un objeto de la clase donde está definido dicho método. Integer I = new Integer ( i ).Character java. 268 . Simplemente hay que ejecutar el método de la clase wrappers adecuada y el String se convierte al tipo de dato primitivo asociado. que tiene un valor igual a 5 y métodos para manipular dicho valor.Object java. Ing. Donde el objeto I.Number Byte Double Float Integer Long Short Las clases Java.

Dichos objetos son: CLASE AL QUE OBJETO PERTENECE S String I Integer L Long F Float D Double C Character También se utilizarán algunas variables para lo cual se deberá asumir que dichas variables han sido declaradas previamente.CLASES BÁSICAS INCORPORADAS EN EL LENGUAJE DE PROGRAMACIÓN JAVA MÉTODOS Con la finalidad de resumir los métodos de las clases wrappers que permiten la conversión. mientras que. para referirnos a las variables se utilizará una letra minúscula. comprobación y traslación de datos. se utilizarán algunos objetos de dichas clases. 269 . Pag. Las variables son: TIPO DE DATO VARIABLE PRIMITIVO i int l long f float d double b boolean c char Para referirnos a objetos se utilizará una letra en mayúscula. Se asume que los objetos han sido creados previamente.

Conversión de tipo de dato primitivo a objeto String Se puede convertir el valor de un tipo de dato primitivo o simple. S = D.toString ( ) .toString ( f ) . Observe que se utiliza el método toString ( ) para convertir el valor de una variable a un valor de tipo cadena contenido en un objeto String. S = Float.toString (i ) . S = Double. A pesar que el método toString ( ) es un método estático o de clase. S = Long. Para realizar esta conversión. Ing. también puede ejecutarse utilizando un objeto.toString ( ) . Juan José Flores Cueto. o utilizar objetos de las clases wrappers. 270 . S = F. Conversión de tipo de dato primitivo a objeto String utilizando objetos wrappers: OBJETO STRING OBJETOS WRAPPERS S = I. a un valor de tipo cadena contenido en un objeto String. Pag. El método toString ( ) es un método estático o de clase por que se utiliza directamente el nombre de la clase para ejecutar el método. S = L. Conversión de tipo de dato primitivo a objeto String utilizando clases wrappers y variables: CLASES WRAPPERS Y OBJETO STRING VARIABLES S = Integer. se puede utilizar clases wrappers y variables.toString ( ) .toString ( ) .toString ( d ) . Observe que se utiliza el método toString ( ) para convertir el valor contenido en el objeto wrappers a un valor de tipo cadena contenido en un objeto String.toString ( l ) . Esto depende si se tiene disponible la variable (con el tipo de dato primitivo) o el objeto de la clase wrapper (que contiene el valor).

valueOf (S) . es el método toString ( ). i = Integer. La clase Object es la clase principal en la Jerarquía de Clases de Java (se puede decir que es la clase padre de todas las clases). Float y Double respectivamente. Esto se debe. parseFloat ( ) y parseDouble ( ) para los wrappers Integer. a que este método no pertenece a dichas clases. sino que pertenece a la clase Object. a un dato de tipo primitivo o valor de una variable.parseInt (S) . Long.CLASES BÁSICAS INCORPORADAS EN EL LENGUAJE DE PROGRAMACIÓN JAVA Todas las clases wrappers tienen en común el método estático o de clase toString ( ). f = Float. parseLong ( ). y uno de los métodos definidos en esta clase.valueOf (S) .valueOf (S) . utilizando clases wrappers y objeto String: VARIABLE WRAPPERS Y OBJETO STRING Integer.parseFloat (S) . Double. Observe que se utiliza el método valueOf ( ) para convertir el valor contenido en el objeto String S. siempre y cuando el objeto String contenga un dato equivalente al tipo de dato primitivo que se desea convertir. como ya se ha mencionado. 271 . d = Double. l = Long. Float. Conversión de objetos String a tipos de dato primitivo. Este método es un método estático o de clase. Long. Todas las clases en Java pueden utilizar los métodos definidos en la clase Object (debido fundamentalmente a la herencia).parseDouble (S) . | Conversión de objetos String a tipo de dato primitivo Se puede convertir un objeto String a un tipo de dato primitivo.parseLong (S) .valueOf (S) . También se tiene la posibilidad de utilizar los métodos parseInt ( ). Pag.

Ing. L.doubleValue ( ) . I. D. Juan José Flores Cueto. Conversión de objetos wrappers a tipos de datos primitivos Se puede convertir un valor de tipo cadena contenido en un objeto String a un valor de un tipo de dato primitivo o simple. La clase Number es la superclase de las clases wrappers (a excepción de la clase wrapper Character). Pag.longValue ( ) . D. utilizando clases wrappers: VARIABLE CLASES WRAPPERS I.longValue ( ) . siempre y cuando el objeto String contenga un valor equivalente al valor del tipo de dato primitivo que se desea convertir.intValue ( ) . Estas clases pueden utilizar los métodos definidos en la clase Number a través de la herencia. 272 .doubleValue ( ) .doubleValue ( ) . I.longValue ( ) . L. d = F. L. I.longValue ( ) .doubleValue ( ) . longValue ( ). D.intValue ( ) . Conversión de objetos wrappers a tipos de dato primitivo. l = F. floatValue( ) y doubleValue( ). Todas las clases wrappers tienen en común los métodos de instancia intValue( ). f = F.floatValue ( ) .intValue ( ) . L. Observe que todas las clases wrappers tienen en común los métodos de instancia intValue ( ).floatValue ( ) . floatValue ( ) y doubleValue ( ). i = F. Estos métodos pertenecen en realidad a la clase Number. longValue( ). D.floatValue ( ) .floatValue ( ) .intValue ( ) .

Pag.isNaN ( ). Comprobaciones del valor infinito Comprobación del valor infinito utilizando clases wrappers y variables: CLASES WRAPPERS Y VARIABLE VARIABLES Float. b = D. Los valores Not-a-Number proceden de indeterminaciones tales como por ejemplo el resultado de la siguiente operación: 0.isNaN ( ) .0 / 0. Observe que se utiliza el método isNaN ( ) para determinar si la variable es o no un número. Comprobación del valor Not-a-Number utilizando clases wrappers y variables: VARIABLE OBJETOS WRAPPERS F. 273 .isInfinite ( d ). El método devuelve true si el valor de la variable no es un número.0.isNaN ( d ). b = Double.CLASES BÁSICAS INCORPORADAS EN EL LENGUAJE DE PROGRAMACIÓN JAVA Comprobaciones del valor Not-a-Number Comprobación del valor Not-a-Number utilizando clases wrappers y variables: CLASES WRAPPERS Y VARIABLE VARIABLES Float. b = Double.isNaN ( f ) .isInfinite ( f ) .

isLowerCase (c) . Juan José Flores Cueto. Comprobación del valor infinito utilizando objetos wrappers: VARIABLE OBJETOS WRAPPERS F.isInfinite ( ) .isUpperCase (c) .isSpace (c) . Por ejemplo el resultado de la siguiente operación: 10. 274 . Comprobaciones de caracteres Comprobación de caracteres utilizando la clase Character y variable tipo char: VARIABLE CLASE Character Y VARIABLE char “Devuelve true si el Character. caracter es una letra mayúscula”.0. b = D. Pag. b = “Devuelve true si el Character. El método devuelve true si el valor de la variable es un número infinito.isInfinite ( ). Ing. “Devuelve true si el Character.5 / 0. caracter es un espacio en blanco”. caracter es una letra minúscula”. Observe que se utiliza el método isInfinite ( ) para determinar si la variable es o no un número infinito. Los valores Infinite proceden normalmente de la división por cero de un valor finito. caracter es un dígito decimal”. “Devuelve true si el Character.isDigit (c) .

toLowerCase (c). caracter a una letra minúscula”. 275 .CLASES BÁSICAS INCORPORADAS EN EL LENGUAJE DE PROGRAMACIÓN JAVA Traslación de caracteres Traslación de caracteres utilizando la clase Character y variable tipo char: VARIABLE CLASE Character y VARIABLE char “Convierte el Character. caracter a una letra mayúscula”. c = “Convierte el Character.toUpperCase (c). Pag.

valueOf ( numRealDoble ) .valueOf ( numEnteroLargo ) . long numEnteroLargo = 100000000. class PrgConvertirAString { public static void main ( String arg [ ] ) { boolean estado = true.5f. cadena = String. System. Analice como se pueden manipular las variables de tipo cadena (String) más adelante en este mismo capítulo.out.println( “ Tipo long en String: ” + cadena ) . Ing.println ( “ Tipo double en String: ” + cadena ) .println ( “ Tipo float en String: ” + cadena ) . System.out. Clase PrgConvertirAString package dominioDeLaAplicacion . System. int numEntero = 10. cadena = String.Desarrollo de la Codificación. Problema 61 Etapa 01 . cadena = String. } } Observe que es posible convertir cualquier tipo de dato a cadena (String) utilizando el método valueOf ( ) de la clase String.out.valueOf ( estado ) .out. System.valueOf ( numReal ) . double numRealDoble = 10000.out. cadena = String.println ( “ Tipo int en String: ” + cadena ) . cadena = String. Pag.valueOf ( letra ) . Juan José Flores Cueto. Desarrollar un programa en Java que permita convertir valores de diferentes tipos de datos en valores de tipo cadena.out. cadena = String. String cadena = “ ”. float numReal = 15. 276 .valueOf ( numEntero ) .Descripción del problema.println ( “ Tipo boolean en String: ” + cadena ) . char letra = ‘z’. En ciertas ocasiones esto es necesario ya que las cadenas pueden ser manipuladas.98. Etapa 04 . System.println ( “ Tipo char en String: ” + cadena ) . System.

String cadena = “ ”. el año actual o la hora del sistema. } } La clase Date.out. Analice como se pueden manipular las variables de tipo cadena (String) más adelante en este mismo capítulo. Desarrollar un programa en Java que permita obtener la fecha del sistema y la convierta en un valor de tipo cadena. tales como. el día. Etapa 04 . es una clase propia de Java y está incluida en el paquete java. el mes.Date . class PrgConvertirFecha { public static void main ( String arg [ ] ) { Date hoy = new Date() .Descripción del problema.CLASES BÁSICAS INCORPORADAS EN EL LENGUAJE DE PROGRAMACIÓN JAVA Problema 62 Etapa 01 .println ( “ Fecha: ” + cadena ) . 277 . cadena = hoy. import java.Desarrollo de la Codificación.util. System. Este paquete está fuera del alcance del presente texto (sugiero que investigue las clases que forman parte de este paquete). Pag. En este paquete podrá encontrar clases de utilidad para sus aplicaciones.util.toString ( ) . El ejecutar esta aplicación se visualizará algo parecido a lo siguiente: Fecha: Sat Mar 20 11:38:46 GMT-05:00 2004. Observe como se convierte la fecha almacenada en un objeto (llamado hoy) de la clase Date en una cadena (String) utilizando el método toString ( ) de la clase String. Clase PrgConvertirFecha package dominioDeLaAplicacion . Esta cadena de texto podrá ser manipulada para obtener otros datos.

Juan José Flores Cueto.println ( “ Valores enteros: ” + numEntero + “ " + objInteger ) .Desarrollo de la Codificación.Descripción del problema. Integer objInteger = Integer. que deberá asegurarse que la cadena contenga un valor válido para que pueda ser almacenado en un tipo de dato determinado.out. Clase PrgCadenaAEntero package dominioDeLaAplicacion . Problema 63 Etapa 01 . Pag. 278 .println ( “ La suma es: ” + (numEntero + objInteger. } } Observe que es posible convertir una cadena (String) en un valor entero (int) o en un objeto de la clase Integer. class PrgCadenaAEntero { public static void main ( String arg [ ] ) { int numEntero = 0 . Como sugerencia desarrolle un programa en Java que realice lo mismo que este programa pero utilice una variable long y la clase Long. Ing. Etapa 04 . String cadena = “10" .valueOf ( cadena ) .parseInt ( cadena ) . Recuerde. System. Puede utilizar el método parseInt ( ) de la clase String para convertir una cadena en un número entero (numEntero) y también el método valueOf ( ) de la clase Integer para convertir una cadena en un un objeto (objInteger) de la clase Integer. Desarrollar un programa en Java que permita convertir una cadena en un número entero y en un objeto de tipo Integer. Calcular y mostrar la suma de ambos valores. El método intValue ( ) nos permite obtener el valor entero del objeto (objInteger) de la clase Integer. numEntero = Integer.out. System.intValue ( ) ) ) .

Calcular y mostrar la suma de ambos valores. 279 . class PrgCadenaAReal { public static void main ( String arg [ ] ) { double numRealDoble = 0 .Desarrollo de la Codificación.out.out. El método doubleValue ( ) nos permite obtener el valor real del objeto (objDouble) de la clase Double. Recuerde. Pag. Desarrollar un programa en Java que permita convertir una cadena en un número real y en un objeto de tipo Double. System. Etapa 04 . System.out. } } Observe que es posible convertir una cadena (String) en un valor entero (double) o en un objeto de la clase Double.doubleValue ( ) ) .println ( “ Valores enteros: ” + numRealDoble + “ ” + objDouble ) .print ( “ La suma es: ” ) . Como sugerencia desarrolle un programa en Java que realice lo mismo que este programa pero utilice una variable float y la clase Float.Descripción del problema.CLASES BÁSICAS INCORPORADAS EN EL LENGUAJE DE PROGRAMACIÓN JAVA Problema 64 Etapa 01 . Double objDouble = Double.5” . numRealDoble = Double. Clase PrgCadenaAReal package dominioDeLaAplicacion . Puede utilizar el método parseDouble ( ) de la clase Double para convertir una cadena en un número real (numRealDoble) y también el método valueOf ( ) de la clase Double para convertir una cadena en un un objeto (objDouble) de la clase Double.valueOf ( cadena ) . System. que deberá asegurarse que la cadena contenga un valor válido para que pueda ser almacenado en un tipo de dato determinado.println ( numRealDoble + objDouble. String cadena = “10.parseDouble ( cadena ) .

Pag. Ing. 280 . Juan José Flores Cueto.

Math El paquete java.lang cada vez que se necesite utilizar la clase Math de Java. 10 Clase Final: No puede ser una superclase. En consecuencia.lang. Todos los métodos de una clase final son implícitamente finales. Los métodos de la clase Math son métodos estáticos (llamados también métodos de clase) y para poder utilizarlos solo se debe colocar el nombre de la clase. la cual nos proporciona métodos y atributos. no será necesario importar el paquete java.CLASES BÁSICAS INCORPORADAS EN EL LENGUAJE DE PROGRAMACIÓN JAVA FUNCIONES MATEMÁTICAS: CLASE MATH INTRODUCCIÓN La clase Math. para implementar diversas funciones mátemáticas. Esto significa que no puede ser instanciada (es decir.Object java. JERARQUÍA DE CLASES Y HERENCIA java. Una clase final o declarada como final es una clase que no puede ser una superclase.lang es el paquete principal del lenguaje Java por lo cual no se necesita importar ninguna clase incluida en dicho paquete. b) . como exponencial. Es decir. las clases finales no pueden heredarse. 281 .lang. no se pueden crear objetos de la clase Math). raiz cuadrada y funciones trigonométricas. La clase Math a diferencia de otras clases es 10 una clase final . Ejemplo: Math. el operador punto y el nombre del método a utilizar. es una clase que viene incorporada en el lenguaje de programación Java. Pag.pow (a. incluida en el paquete java. logaritmo. La clase Math contiene métodos de cálculo básico.lang.

toRadians( ). sin( ). 8. 12. Para ejecutar un método de clase. Para trabajar con los métodos de clase. exp( ). E. max( ). 11. estos deben ser necesariamente proporcionados en la cantidad y tipos requeridos. 7. no será necesario crear previamente un objeto de dicha clase (esto se cumple para todas las clases que implementen métodos de clase). round( ). acos( ). 10. 5. Ing. toDegrees( ). A continuación se presenta una breve descripción del uso de cada uno de los métodos de la clase Math: Pag. 19. random( ). 4. 17. 15. el método necesita algunos datos. min( ). asin( ). Asimismo. 18. 9. de la clase Math. En caso que el método devuelva un resultado deberá almacenarlo en una variable del mismo tipo que el resultado proporcionado o mostrarlo a través de la pantalla. Juan José Flores Cueto. de la clase Math. es necesario colocar la palabra Math (que es el nombre de la clase). 2. atan( ). Métodos de clase: 1. pow( ). el operador punto (. sqrt( ). 14. abs( ). PI. 282 . tan( ). 2. cos( ). MÉTODOS La clase Math presenta los siguientes atributos y métodos de clase: Atributos de clase: 1. para ejecutar un método de la clase Math debemos tener en cuenta que si. 3. log( ). 13. 16.) y el nombre del método de clase que desea ejecutar. floor( ). ceil( ). 6.

abs (double) Retorna el valor absoluto de un System.0 * Math.9033391107665127 Retorna un valor double con el arcotangente de un ángulo expresado double angulo = 45. int.out.PI/180. Pag. enviado al método como parámetro. Almacena el valor de E.PI .abs( x)) . System.E .acos( angulo ) . double result . El ángulo expresado en radianes debe ser un valor double Resultado : enviado al método como parámetro. e = 2.718281828459045.atan( angulo ) . atan (double) en radianes. Retorna un valor double con el result = Math.print( Math. PI almacena el valor equivalente a 3. El ángulo expresado en radianes debe ser un valor double Resultado : enviado al método como parámetro.CLASES BÁSICAS INCORPORADAS EN EL LENGUAJE DE PROGRAMACIÓN JAVA CLASE Math ATRIBUTOS DE DESCRIPCIÓN USO CLASE double e = Math. 283 .out. double. arcoseno de un ángulo expresado en result = Math.0.out. radianes debe ser un valor double System. long) dado como parámetro.out. nos System. result = 0. asin (double) radianes.718281828459045. double result .print( result ) .0 * Math. El ángulo expresado en result = Math. Es decir.print( e) .0 .PI/180. proporciona la base de un logaritmo E natural.print( pi) . MÉTODOS DE DESCRIPCIÓN USO CLASE abs (float) int x = -5 . arcocoseno de un ángulo expresado System.out.0 .141592653589793. Resultado: pi = 3. result = 0. Almacena el valor de PI.6674572160283838 double angulo = 45. acos (double) en radianes.print( result ) .PI/180. número (que puede ser float.141592653589793.out. Retorna un valor double con el double result .asin( angulo ) . System. El valor es equivalente a Resultado: 2.0 * Math. Es decir. Resultado: abs (int) x = 5. double pi = Math.print( result ) . abs (long) double angulo = 45.

65 . Retorna un valor double con el valor System. de un ángulo expresado en radianes. Retorna un valor double con el valor System. result . log (double) parámetro dado.cos( angulo ) . mayor = Math.println(result) .0 . El parámetro dado Resultado: debe ser double. result = Math.max( x . exponencial de Euler del parámetro exp (double) dado.out.print ( mayor ) .0 .8660254037844387 double exponente=1.6657737500283538 double n = 0. result = Math. logaritmo natural (base e) de un System.println( result ) . y = 15 .PI/180. El parámetro dado Resultado: sebe ser double.out. result = 2. y ) . double) Resultado: Pag. long) de dos números dados como max (float. result .65 . System.out. MÉTODOS DE DESCRIPCIÓN USO CLASE Resultado : result = 0.0986122886681096 Retorna el valor del número mayor (que puede ser float.0 double angulo = 30. resutl = 5. result = 1.log(logaritmo) . Juan José Flores Cueto. result .0 * Math. result = 0. 284 .0 .out.out. ceil (double) dado.7182818284590455 double n = 5.println( result ) . double x = 10 . mayor .ceil( n ) . int. Retorna un valor double con el result = Math.exp(exponente) . double. max (double. ser un valor double enviado al método Resultado : como parámetro.floor(n) .print( result ) . result . result = Math. floor (double) más grande no mayor que el parámetro dado. El parámetro dado debe ser double. Resultado: result = 1.out. Ing. Retorna un valor double con el valor result = Math.0 double logaritmo = 3. más corto no menor que el parámetro System. float) parámetros.print(result) . El parámetro dado sebe ser Resultado: double. Retorna un valor double con el coseno double result . cos (double) El ángulo expresado en radianes debe System.

Resultado: round (double) result = 11.println(result) .CLASES BÁSICAS INCORPORADAS EN EL LENGUAJE DE PROGRAMACIÓN JAVA MÉTODOS DE DESCRIPCIÓN USO CLASE max (int.0. int) parámetros. result . que 1. y ) .pow( x . potencia de un número (dado como System. min (long. primer parámetro) elevado a otro pow (double. result = 16. como parámetro.round( x ) . Retorna un valor double con el seno de un ángulo expresado en radianes. (que puede ser float.sin(angulo) . Retorna un valor (que puede ser float result = Math.print ( num ) .print ( result ) .print ( result ) . menor = 10. y = 4 . número generado aleatoriamente (al num = Math.0 * El ángulo expresado en radianes debe Math. double angulo = 37. round (float) double x = 10. long) min (float. sin (double) ser un valor double enviado al método result = Math.out.0 y menor System. menor = Math. Retorna un valor double con la result = Math. double. 285 . double) número (dado como segundo Resultado: parámetro). parámetro dado.out. random () azar) mayor o igual que 0.53 . System. min (double. double) Retorna el valor del número menor System.0.min( x .random( ) . double result . y ) . int) mayor = 15. max (long.out. El parámetro dado puede ser un valor float o double. menor . Los dos parámetros dados deben ser double. Resultado: Pag. int. o double) con el valor redondeado del System. Retorna un valor double con un double num . float) double x = 10 .out. result .PI/180. y = 15 . long) double x = 2 .print ( menor ) . long) de dos números dados como Resultado: min (int.out.

tangente de un ángulo expresado en result = Math.PI/180.print ( result ) . toRadians (double) sexadecimal (enviado como parámetro double) en un ángulo expresado en Resultado: radianes. result = 59.out. tan (double) radianes.out. convertir un ángulo expresado en System. toDegrees (double) radianes (enviado como parámetro double) en un ángulo expresado en Resultado: sexagesimal. result = 1. result . double angulo = 53. Retorna un valor double con la raiz result = Math.toRadians(angulo) . cuadrada del parámetro dado. Pag.6018150231520483 double x = 16 . se presentan algunas soluciones a problemas planteados utilizando algunos de los métodos de la clase Math.out.0 * Math.99999999999999 double angulo = 60. Retorna un valor double con la double result . MÉTODOS DE DESCRIPCIÓN USO CLASE result = 0. System.0471975511965976 A continuación.PI/3. El sqrt (double) parámetro dado debe ser un valor double.0 . Permite result = Math. El ángulo expresado en System. radianes debe ser un valor double Resultado: enviado al método como parámetro. result . Permite result = Math. Retorna un valor double. Analice cada una de las siguientes soluciones. 286 . result = 1. Retorna un valor double.println( result ) . Juan José Flores Cueto.println( result ) . Ing.3270448216204098 double angulo = Math.tan(angulo). con la finalidad de mejorar la comprensión del tema tratado.println(result) .out. Resultado: result = 4. result . convertir un ángulo expresado en System.sqrt( x ) .toDegrees(angulo) .

Pag. System. num3 ) ) . Clase PrgNumeroMayor package dominioDeLaAplicacion . num2 = Lectura.Desarrollo de la Codificación. num3 = Lectura.leerInt( ) . num1 = Lectura.println ( “ Ingresar el segundo número: ” ) . num3 ) Parámetros. class PrgNumeroMayor { public static void main ( String arg [ ] ) { int num1.println ( “ El número mayor es: ” + resultado ) .max ( num2.max ( num1. num2.println ( “ Ingresar el tercer número: ” ) . System. System.leerInt( ) .out.Lectura . resultado .CLASES BÁSICAS INCORPORADAS EN EL LENGUAJE DE PROGRAMACIÓN JAVA Problema 65 Etapa 01 .out. Operador punto. 287 . Desarrollar un programa en Java que permita ingresar 3 números enteros a través del teclado.max ( num2. Math.println ( “ Ingresar el primer número: ” ) . System. Etapa 04 . import biblioteca. Determinar y mostrar cuál de ellos es el número mayor. Nombre del método. Nombre de la Clase.Descripción del problema.out.out. resultado = Math. num3. } } ¿Que hay de nuevo en la codificación? Observe el uso del método max ( ) de la clase Math: Math.leerInt( ) .

double. num3 ) ) . Math. Observe que en esta solución se emplea una estrategia mas simple para determinar el número mayor entre tres números. int o long) de dos números dados como parámetros. En nuestro ejemplo determinamos el mayor de los dos últimos números ingresados y en la misma línea de código evaluamos el mayor de estos dos números con el primer número ingresado. Es importante tener presente que el método max ( ) es un método que solo podemos utilizar con la clase Math y su función es determinar el número mayor entre dos números dados como parámetros.max ( num1. El método max ( ) nos permite determinar el número mayor entre dos números (en nuestro caso el número mayor entre num2 y num3). El método max ( ) de la clase Math. Juan José Flores Cueto. Ing. 288 . Pag.max ( num2. retorna el valor del número mayor (puede ser un número float. tal y como se muestra a continuación: resultado = Math.

System.println ( “Ingresar el tercer número: ” ) . double. tal y como se muestra a continuación: resultado = Math. Math.Lectura .leerInt( ) . resultado .out. num3.leerInt( ) . Determinar y mostrar cuál de ellos es el número menor.min ( num1. En nuestro ejemplo hallamos el menor de los dos últimos números ingresados. class PrgNumeroMenor { public static void main ( String arg [ ] ) { int num1.println ( “ Ingresar el primer número: ” ) . long) de dos números dados como parámetros.leerInt( ) .out. num2 = Lectura. Etapa 04 . y en la misma línea evaluamos el menor de estos dos números con el primer número ingresado. num3 ) ) . System. import biblioteca. num3 = Lectura.out.Descripción del problema.min ( num2.println ( “ El número menor es: " + resultado ) .CLASES BÁSICAS INCORPORADAS EN EL LENGUAJE DE PROGRAMACIÓN JAVA Problema 66 Etapa 01 .println ( “Ingresar el segundo número: ” ) .min ( ) retorna el valor del número menor (que puede ser float. System. System.min ( num2.out.min ( num1. Clase PrgNumeroMenor package dominioDeLaAplicacion . int. } } ¿Que hay de nuevo en la codificación? Observe el uso del método min ( ) de la clase Math: En la codificación de esta solución se emplea una nueva estrategia para hallar el menor de tres números ingresados por teclado (anteriormente se utilizaban sentencias if anidadas). num2. Desarrollar un programa en Java que permita ingresar 3 números enteros a través del teclado. resultado = Math.Desarrollo de la Codificación. Pag. num1 = Lectura. num3 ) ) . Math. Observe que Math. 289 .

utilizando el método random ( ) de la clase Math. Etapa 04 . cant. for ( x = 1. En la codificación de esta solución se utiliza una sentencia for con la finalidad de generar la cantidad de números aleatorios (al azar) que el usuario desee.Lectura . cant = Lectura. Problema 67 Etapa 01 . Finalizada la ejecución de la sentencia for se muestra el contenido de dicha variable (es decir.println ( “La suma de los números aleatorios es: ” + suma ) . el cual es acumulado en la variable suma. Recuerde que para generar números aleatorios entre dos números (entre un intervalo o rango).Descripción del problema.println ( “El número aleatorio generado es: ” + num ) . Mostrar el número generado aleatoriamente y la suma de dichos números. se genera y muestra un número aleatorio (un número entre 1 y 6).random( ) * 6 ) . System. Clase PrgNumerosAleatorios package dominioDeLaAplicacion . Desarrollar un programa en Java que permita generar una cantidad determinada de números aleatorios.print ( “Ingresar la cantidad de números aleatorios a generar: ” ) . suma = suma + num .out. x++) { num = 1 + (int) ( Math.out. Juan José Flores Cueto.out. import biblioteca. } System. 290 . suma=0 .leerInt( ) . se muestra la suma de los números aleatorios generados). x <= cant. } } ¿Que hay de nuevo en la codificación? Observe el uso del método random ( ) de la clase Math: num = 1 + (int) (Math. se emplea la siguiente fórmula: Pag. num.random ( ) * 6 ) . Cada vez que se ejecuta la sentencia for. Ing. Los números aleatorios generados deberán estar entre 1 y 6. class PrgNumerosAleatorios { public static void main ( String arg [ ] ) { int x. System.Desarrollo de la Codificación.

1 + (int) ( Math. Pag.random( ) * ( 6 ) ) .CLASES BÁSICAS INCORPORADAS EN EL LENGUAJE DE PROGRAMACIÓN JAVA min + (int) ( Math. Para nuestro ejemplo tenemos: 1 + (int) ( Math.random( ) * ( 6 – 1 + 1 ) ) .random( ) * (max – min + 1 ) ) . 291 .

System. Clase PrgNumAleatoriosPares package dominioDeLaAplicacion . System. if (num % 2 == 0) { cont++.Lectura . Mostrar los números aleatorios que son números pares. } } ¿Que hay de nuevo en la codificación? En la codificación de esta solución se utiliza una sentencia do con la finalidad de generar números aleatorios.print ( “Ingresar la cantidad de números aleatorios a generar: ” ) . Desarrollar un programa en Java que permita generar una cantidad determinada de números aleatorios. Los números aleatorios generados deberán estar entre 1 y 10. import biblioteca. do { num = 1 + (int) ( Math. num. Problema 68 Etapa 01 .print ( num + “ \t ” ) . 292 .random( ) * 10 ) .out. Ing.Descripción del problema.leerInt( ) . Juan José Flores Cueto.Desarrollo de la Codificación.out. cant = Lectura. cant. Pag. Etapa 04 . class PrgNumAleatoriosPares { public static void main ( String arg [ ] ) { int x. Si el número generado es par se le aumenta uno a la variable cont (que esta trabajando como contador de números pares generados al azar) y se muestra el número generado. } } while (cant != cont) . cont = 0 .

System.print ( “Ingresar la cantidad de números aleatorios a generar: ” ) .print ( num + “ \t ” ) . Mostrar los números aleatorios que son números impares. class PrgNumAleatoriosImpares { public static void main ( String arg [ ] ) { int x. cant = Lectura. } } ¿Que hay de nuevo en la codificación? En la codificación de esta solución se utiliza una sentencia do con la finalidad de generar números aleatorios.out. num.leerInt( ) . Pag.Desarrollo de la Codificación.Descripción del problema. Clase PrgNumAleatoriosImpares package dominioDeLaAplicacion . cont = 0 . 293 . Desarrollar un programa en Java que permita generar una cantidad determinada de números aleatorios. Si el número generado es impar se le aumenta uno a la variable cont (que esta trabajando como contador de números impares generados al azar) y se muestra el número generado.random( ) * 10 ) . Los números aleatorios generados deberán estar entre 1 y 10. do { num = 1 + (int) ( Math. Etapa 04 . System.out.Lectura . if ( num % 2 == 1 ) { cont ++. cant.CLASES BÁSICAS INCORPORADAS EN EL LENGUAJE DE PROGRAMACIÓN JAVA Problema 69 Etapa 01 . import biblioteca. } } while ( cant != cont ) .

3 ) . 3 ) .pow ( radio. El método pow ( ) retorna un valor double con la potencia de un número (dado como primer parámetro) elevado a otro número (dado como segundo parámetro). Juan José Flores Cueto. System.println ( “Ingresar el radio de la esfera: ” ) . Para hallar el volumen de la esfera se tendrá que utilizar la fórmula v=4/3*PI*R3.Desarrollo de la Codificación. System.println ( “El volumen de la esfera es: ” + volume ) .PI * Math.leerDouble().out. class PrgRadioEsfera { public static void main ( String arg [ ] ) { double radio. Desarrollar un programa en Java que permita ingresar por teclado el radio de una esfera. La clase Math define un atributo (constante) muy útil.PI). } } ¿Que hay de nuevo en la codificación? Observe el uso del método pow ( ) y del atributo PI de la clase Math: volume = (4 / 3) * Math. volume = (4 / 3) * Math.out. Calcular y mostrar el volumen de dicha esfera.pow ( radio. Clase PrgRadioEsfera package dominioDeLaAplicacion .Lectura .Descripción del problema. Problema 70 Etapa 01 . Pag. radio = Lectura. Etapa 04 . volume . 294 . import biblioteca. que contiene en valor del número PI (Math. En nuestro caso el método pow ( ) eleva a la potencia 3 el radio del círculo. Ing.PI * Math.

El método round ( ) permite redondear un número dado como parámetro. resultado . Etapa 04 . resultado = Math. num = Lectura. System.println ( “El número redondeado es: ” + resultado ) .leerDouble( ) . Mostrar el número ingresado redondeado. System.out. En esta solución se ingresa un número y se almacena en la variable num. } } ¿Que hay de nuevo en la codificación? Observe el uso del método round ( ) de la clase Math: resultado = Math. 295 . class PrgNumRedondeado { public static void main ( String arg [ ] ) { double num. Clase PrgNumRedondeado package dominioDeLaAplicacion . dicho número es redondeado utilizando el método round ( ) y se almacena en la variable resultado.round(num) .CLASES BÁSICAS INCORPORADAS EN EL LENGUAJE DE PROGRAMACIÓN JAVA Problema 71 Etapa 01 . Pag.println ( “Ingrese un número decimal: ” ) . import biblioteca. Luego.Desarrollo de la Codificación.out.Descripción del problema. Desarrollar un programa en Java que permita ingresar un número decimal.round(num) .Lectura .

retorna un valor double.println ( “Ingresar un número entero: ” ) . Pag.out.leerInt( ) . En la presente solución se utiliza una sentencia for con la finalidad de elevar a la potencia todos los números menores que la variable cant y mostrarlos por pantala.out.leerInt( ) . for ( int x = 1. expo = Lectura. 296 . Etapa 04 . x++) { rpta = Math.Descripción del problema. System. Juan José Flores Cueto. Problema 72 Etapa 01 . expo ) . x < cant. cant = Lectura. El método pow ( ) permite elevar a la potencia un número determinado. La variable cant y el exponente expo se ingresan por el teclado. Mostrar el resultado de calcular la potencia de todos los números menores que el número ingresado elevado al exponente ingresado.pow ( x. System. import biblioteca. double rpta .println ( “El Exponencial de ” + x + “ es: ” + rpta ) .out. System.Desarrollo de la Codificación.pow ( x.Lectura . Ing. expo . Recuerde y siempre tenga presente que el método pow ( ) de la clase Math. por lo que dicho valor deberá ser almacenado en una variable del mismo tipo o deberá mostrarse por la pantalla. } } } ¿Que hay de nuevo en la codificación? Observe el uso del método pow ( ) de la clase Math: rpta = Math. class PrgNumPotencia { public static void main ( String arg [ ] ) { int cant.println ( “Ingresar el exponente: ” ) . Desarrollar un programa en Java que permita ingresar un número entero y un exponente. Clase PrgNumPotencia package dominioDeLaAplicacion . expo ) .

Etapa 04 .Descripción del problema.println ( “Ingrese un número entero: ” ) .out. por lo que dicho valor deberá ser almacenado en una variable del mismo tipo o deberá mostrarse por la pantalla. System.leerInt( ) . for ( int x = 1.sqrt ( x ) . Clase PrgNumRaiz package dominioDeLaAplicacion . cant = Lectura. x < cant.println ( “La raíz cuadrada de ” + x + “ es: ” + rpta ) . import biblioteca. 297 .Lectura . Pag. retorno un valor double. class PrgNumRaiz { public static void main ( String arg [ ] ) { int cant . Mostrar el resultado de calcular la raíz cuadrada de todos los números menores que el número ingresado.out. En la presente solución se utiliza una sentencia for con la finalidad de obtener la raíz cuadrada de todos los números menores que la variable cant y mostrarlos por pantalla. La variable cant se ingresa por el teclado. System. } } } ¿Que hay de nuevo en la codificación? Observe el uso del método sqrt ( ) de la clase Math: rpta = Math.Desarrollo de la Codificación.CLASES BÁSICAS INCORPORADAS EN EL LENGUAJE DE PROGRAMACIÓN JAVA Problema 73 Etapa 01 . El método sqrt ( ) permite obtener la raíz cuadrada de un número determinado. Desarrollar un programa en Java que permita ingresar un número entero.sqrt (x) . x++ ) { rpta = Math. Recuerde y siempre tenga presente que el método sqrt ( ) de la clase Math. double rpta .

Desarrollar un programa en Java que permita generar una cantidad determinada de números aleatorios. num .out. class PrgNumAleatorioCuad { public static void main ( String arg [ ] ) { int cant. System. System.Lectura . Mostrar los números generados aleatoriamente elevados al cuadrado. } } } ¿Que hay de nuevo en la codificación? Observe el uso de los métodos random ( ) y sqrt ( ) de la clase Math: num = (int) ( 1 + ( Math. La variable cant se ingresa por el teclado. Ing. Etapa 04 . x++ ) { num = (int) ( 1 + ( Math. import biblioteca. elevarlos al cuadrado y mostrarlos por pantalla. Clase PrgNumAleatorioCuad package dominioDeLaAplicacion .random() * 10 ) ) .println ( num + “ elevado al cuadrado es: ” + rpta ) . 2) . Problema 74 Etapa 01 . rpta = Math.random() * 10 ) ) .print ( “Ingresar la cantidad de números aleatorios a generar: ” ) . Pag. x <= cant. cant = Lectura.Desarrollo de la Codificación. 298 .Descripción del problema.leerInt( ) . Juan José Flores Cueto.pow (num. 2) . rpta = Math.pow (num. double rpta . for ( int x = 1.out. Los números aleatorios generados deberán estar entre 1 y 10. En la presente solución se utiliza una sentencia for con la finalidad de obtener números aleatorios.

import biblioteca. class PrgTriangulo { public static void main ( String arg [ ] ) { double a.CLASES BÁSICAS INCORPORADAS EN EL LENGUAJE DE PROGRAMACIÓN JAVA Problema 75 Etapa 01 .abs(p .b) ) ) . 299 .out. System.println ( “Ingrese el valor del primer lado del triángulo (a): ” ) . c = Lados del triángulo. Utilizar las siguientes fórmulas: area = ( p * (|p-a|)*(|p-b|)*(|p-c|)) RAIZ (2). System. Clase PrgTriangulo package dominioDeLaAplicacion .out. p = (a + b + c) / 2 . Desarrollar un programa en Java que permita determinar y mostrar el área de un tríangulo en base a las longitudes de sus lados. p = (a+b+c) / 2. p.c)) * (Math. b = Lectura.leerDouble( ) . c.out. tmp. Considerar el valor absoluto de la diferencia entre el semiperimetro y cada uno de los lados. Donde: p = Semiperímetro. tmp = ( p * (Math.a)) * (Math. area .abs(p . b. area = Math.out. } } Pag.println ( “Ingrese el valor del terecr lado del triángulo (c): ” ) .leerDouble( ) . a.Descripción del problema. System. Etapa 04 .Lectura .println ( “El área del triángulo es: ” + area ) . c = Lectura.leerDouble( ) .abs(p . System.sqrt ( tmp ) . b.println ( “Ingrese el valor del segundo lado del triángulo (b): ” ) .Desarrollo de la Codificación. a = Lectura.

Ing. Luego. 300 .abs(p .a)) * (Math. Pag.sqrt ( tmp ) . se multiplican los valores resultantes con el valor del semiperímetro del triángulo y finalmente. Luego. se obtiene la raíz cuadrada del valor resultante utilizando el método sqrt ( ) de la clase Math.c)) * (Math.abs(p . se hace uso del método abs ( ) de la clase Math para calcular el valor absoluto de la diferencia entre el semiperímetro y cada uno de los lados del triángulo. ¿Que hay de nuevo en la codificación? Observe el uso de los métodos abs ( ) y sqrt ( ) de la clase Math: tmp = ( p * (Math.abs(p . se procede a calcular el área del triángulo en base a la siguiente fórmula: area = ( p * (|p-a|)*(|p-b|)*(|p-c|)) RAIZ (2) Primero. En esta solución se ingresan los valores de los tres lados de un triángulo y se obtiene el valor del semiperímetro del triángulo.b) ) ) . area = Math. Juan José Flores Cueto.

301 .leerDouble( ) . Clase PrgCirculo package dominioDeLaAplicacion .Lectura .out. System.Desarrollo de la Codificación.println ( “ El perímetro del círculo es : ” + perimetroCirculo ) . Utilizar las siguientes fórmulas: perimetro = 2 * PI * radio.println ( “ El área del círculo es: ” + areaCirculo ) .pow (radioCirculo. Desarrollar un programa en Java que permita determinar y mostrar el perímetro y el área de un círculo. } } Pag. areaCirculo.out. perimetroCirculo .CLASES BÁSICAS INCORPORADAS EN EL LENGUAJE DE PROGRAMACIÓN JAVA Problema 76 Etapa 01 .PI * radioCirculo .Descripción del problema. class PrgCirculo { public static void main ( String arg [ ] ) { double radioCirculo. System. Etapa 04 . perimetroCirculo = 2 * Math. 2) .out. import biblioteca. radioCirculo = Lectura. areaCirculo = Math. area = PI * radio * radio.PI * Math.println ( “ Ingrese el valor del radio del círculo: ” ) . System.

System.out. Desarrollar un programa en Java que permita ingresar un ángulo expresado en grados.Desarrollo de la Codificación. if (anguloGrados == 0) tipoAngulo = “Nulo” . if (anguloGrados > 0 && anguloGrados < 90) tipoAngulo = “Agudo” .leerDouble( ) .println ( “ Ingrese un ángulo en grados (entre 0 y 360): ” ) . Entre 0 y 90 grados. if (anguloGrados == 180) tipoAngulo = “Llano” . = Agudo.toRadians (anguloGrados) .Lectura . System.println ( “ Tipo de ángulo: ” + tipoAngulo ) . Problema 77 Etapa 01 . import biblioteca. Entre 180 grados y 360 grados. 90 grados. = Cóncavo. Juan José Flores Cueto. 360 grados.out. } } Pag. = Nulo. = Recto. 180 grados. if (anguloGrados > 180 && anguloGrados < 360) tipoAngulo = “Concavo” . anguloGrados = Lectura. = Obtuso.out. anguloRadianes = Math.println ( “ Ángulo expresado en radianes: ” + anguloRadianes ) . = Llano. = Completo. if (anguloGrados == 360) tipoAngulo = “Completo” . Entre 90 y 180 grados. Etapa 04 . Clase PrgConversionAngulo package dominioDeLaAplicacion . Ing. if (anguloGrados == 90) tipoAngulo = “Recto” . if (anguloGrados > 90 && anguloGrados < 180) tipoAngulo = “Obtuso” . Los ángulos expresados en grados se clasifican de la siguiente manera: 0 grados. 302 . String tipoAngulo = “” . anguloRadianes .Descripción del problema. class PrgConversionAngulo { public static void main ( String arg [ ] ) { double anguloGrados. System. Deeterminar el tipo de ángulo ingresado y su equivalente en radianes.

Para el desarrollo de esta solución se hace uso de sentencias if múltiples con la finalidad de determinar el tipo de ángulo ingresado por teclado. Pag.toRadians (anguloGrados) . El tipo de ángulo es almacenado en una variable String (tipoAngulo) y mostrado por pantalla. Para realizar la conversión del ángulo ingresado en el sistema sexagesimal al sistema radial se utiliza el método toRadians ( ) de la clase Math.CLASES BÁSICAS INCORPORADAS EN EL LENGUAJE DE PROGRAMACIÓN JAVA ¿Que hay de nuevo en la codificación? Observe el uso del método toRadians ( ) de la clase Math: anguloRadianes = Math. 303 .

println ( “ Ingrese el coeficiente C: ” ) .println ( “ Ingrese el coeficiente A: ” ) .println ( “ La ecuación tiene raices imaginarias ” ) . Tipo: 2 Ax + Bx + C = 0 Considerar que la solución puede tener raíces imaginarias. } } } } } Pag. } else { if (a == 0) { x = c / b * (-1) .println ( “ La ecuación no tiene solución ” ) . Juan José Flores Cueto. b = Lectura.pow (b. System. b. Problema 78 Etapa 01 .out. Etapa 04 .(4 * a * c) . System. x1.println ( “ El segundo valor para x es: ” + x2 ) . 304 .println ( “ El primer valor para x es: ” + x1 ) . Desarrollar un programa en Java que permita determinar y mostrar las raíces de una ecuación de segundo grado.sqrt (tmp)) / (2 * a) .Descripción del problema. a = Lectura.leerInt( ) . Utilizar la siguiente fórmula: x = ( .leerInt( ) . x2 . System.out.( ( B ** 2 – 4 * A * C ) RAIZ ( 2 ) ) ) / 2 * A. double tmp.Lectura .Desarrollo de la Codificación.b . x2 = ( . import biblioteca.out.out.Math.out.leerInt( ) .println ( “ El valor para x es: ” + x ) . System. Ing. c .out. if (a == 0 && b == 0) { System. Clase PrgEcuacion2Grado package dominioDeLaAplicacion . } else { x1 = ( . if (tmp < 0) { System.out. System. 2) . x.sqrt (tmp)) / (2 * a) . c = Lectura.println ( “ Ingrese el coeficiente B: ” ) . } else { tmp = Math. System.out. class PrgEcuacion2Grado { public static void main ( String arg [ ] ) { int a.B + .b + Math.

2) . x2 = ( .b . Caso contrario. “La ecuación tiene raices imaginarias”. se muestra un mensaje por la pantalla. Si los coeficientes a y b son iguales a cero. Pag. si el coeficiente a es igual a cero la ecuación tendría una sola solución.pow (b.sqrt (tmp)) / (2 * a) . “La ecuación no tiene solución”.sqrt (tmp)) / (2 * a) . la cual se calcularía utilizando: x = c / b * (-1) . se determina el valor de la discriminante. b y c). el cual se almacena en la variable tmp utilizando la siguiente formula: tmp = Math. Caso contrario. En caso que el valor de tmp sea igual a cero.CLASES BÁSICAS INCORPORADAS EN EL LENGUAJE DE PROGRAMACIÓN JAVA ¿Que hay de nuevo en la codificación? Observe el uso de los métodos pow ( ) y sqrt ( ) de la clase Math: En esta solución se ingresan los coeficientes de una ecuación de segundo grado (a. las cuales se calcularían utilizando: x1 = ( .Math.b + Math.(4 * a * c) . 305 . se muestra el siguiente mensaje por pantalla. Si el coeficiente a es diferente de cero la ecuación tendría dos soluciones.

println ( “ Bienvenido al juego: ¿Que número es? ” ) . System. } while (num < 0 || num > 100 ) .Descripción del problema.La computadora genera un -” ) . inten = 1 . encontró el número en: ” + inten + “ intento(s) ” ) . Problema 79 Etapa 01 . tmp = maximo * Math. Clase PrgJuego package dominioDeLaAplicacion .println ( “ El número buscado es mayor ” ) . do { System. y cada vez que intente adivinar le indicará si el número buscado es menor o es mayor. num = Lectura. numAzar.out.println ( “ .el menor número de intentos -” ) .leerInt( ) .Lectura . Ing.println ( “ El número buscado es menor ” ) . } while (num < 0 || num > 100) .leerInt( ) .100: ” ) . do { System. System. El rango de números válidos en el juego es de 1 a 100. if (num < numAzar) System. Desarrollar un juego en Java que permita generar un número aleatorio. Juan José Flores Cueto.println ( “ . Se debe intentar adivinar que número es el que generó la computadora.out.println ( “ Ud.out.println ( “ ----------------------------------------------------” ) .Desarrollo de la Codificación. System.100: ” ) .println ( “ Ingrese otro número entre 0. class PrgJuego { public static void main ( String arg [ ] ) { int maximo = 100.out. System. import biblioteca.out. System. } } Pag. numAzar = (int) Math.out. while (num != numAzar) { inten++ .println ( “ .out.random( ) . 306 .out..de adivinar que número es -” ) .out.println ( “ Ingrese un número entre 0..numero aleatorio y ud.out.Trate de adivinar el número en -” ) .out. double tmp. Etapa 04 . num.println ( “ .round(tmp) . num = Lectura. else System.out. System. tratara -” ) . } System. System.println ( “ .

Si ambos son iguales. Utilice la sentencia do y optimice el código. almacenado en la variable numAzar. 307 . Luego es redondeado utilizando el método round ( ) y convertido a un número entero utilizando la siguiente sentencia: numAzar = (int) Math. El número generado aleatoriamente es almacenado en la varable tmp.random( ) . indicando si el número buscado es mayor o es menor (en relación al número ingresado) y se solicitará otro número hasta encontrar el número que se generó en forma aleatoria. Intente modificar la codificación de la solución. utilizando la siguiente fórmula: tmp = maximo * Math. Pag. se mostrará un mensaje. se mostrará un mensaje indicando que el número numAzar fue encontrado. es comparado con un número previamente ingresado por teclado y almacenado en la variable num.CLASES BÁSICAS INCORPORADAS EN EL LENGUAJE DE PROGRAMACIÓN JAVA ¿Qué hay de nuevo en la codificación? Observe el uso de los métodos random ( ) y round ( ) de la clase Math: Utilizando el método random ( ) generamos un número aleatorio (al azar) entre el número 0 y el número 100. Si no son iguales. Este número generado al azar.round(tmp) .

println ( “ Ingrese el segundo número: ” ) .n6) . menor = Math.Desarrollo de la Codificación. Utilice una sentencia for. meno r.out.leerInt( ) .min (n1. Ing. System.n2) . Clase PrgNumeroMayorMenor package dominioDeLaAplicacion .out. System.out. mayor = Math.println ( “ Ingrese el cuarto número: ” ) .n5) . n2.min (menor.Descripción del problema.max (n1. double mayor. Etapa 04 .println ( “ El mayor número es: " + mayor ) . Determinar y mostrar cuál de ellos es el número mayor y cuál es el número menor. menor = Math.n6) .println ( “ Ingrese el quinto número: ” ) . Desarrollar un programa en Java que permita ingresar 6 números a traves del teclado. System. mayor = Math. n4.out. 308 . n6 .leerInt( ) . n2 = Lectura. n6 = Lectura. import biblioteca.println ( “ El menor número es: " + menor ) . menor = Math.max (mayor. n4 = Lectura. Pag. n3.leerInt( ) .leerInt().n2) .min (menor. } } Modificar la codificación de la solución de tal forma que pueda optimizar el código.max (mayor.leerInt( ) . Problema 80 Etapa 01 . menor = Math.out.max (mayor. System.max (mayor. System. System.println ( “ Ingrese el sexto número: ” ) .n3) .n4) .n3) . mayor = Math. System.Lectura .println ( “ Ingrese el tercer número: ” ) .out. n1 = Lectura.println ( “ Ingrese el primer número: ” ) .leerInt( ) .min (menor. n5. mayor = Math.min (menor. mayor = Math.n5) . Juan José Flores Cueto. System. n3 = Lectura.out. class PrgNumeroMayorMenor { public static void main ( String arg [ ] ) { int n1. menor = Math.out.n4) . n5 = Lectura.

Calcular y mostrar el promedio final de cada alumno en base a la siguiente fórmula: pf = ( pp + ep + ( ef * 2 ) ) / 4.min (notaMenor. p2 = Lectura.out.leerDouble( ) . notaMenor . notaMenor = Math. System. Etapa 04 . p2.min (p1. System. import biblioteca. Pag.println ( “ Ingrese la nota de la práctica 4: ” ) . notaMenor = Math. p3.out.p3) .p2) . pp = Promedio de prácticas.CLASES BÁSICAS INCORPORADAS EN EL LENGUAJE DE PROGRAMACIÓN JAVA Problema 81 Etapa 01 . System. Desarrollar un programa en Java que permita ingresar las notas de todos los alumnos de un determinado salon de clase. char opc .println ( “ Ingrese la nota del examen parcial: ” ) .leerDouble( ) . class PrgPromedioNotas { public static void main ( String arg [ ] ) { double pf. ef.Lectura .leerDouble( ) .leerDouble( ) . p3 = Lectura.p4) .out. Clase PrgPromedioNotas package dominioDeLaAplicacion . ef = Lectura.out. p1 = Lectura.out. System.leerDouble( ) .Desarrollo de la Codificación. p1. ef = Examen final.out. ep = Lectura. Son 4 prácticas de las cuales se elimina la más baja pp = ( p1 + p2 + p3 + p4 – notaMenor ) / 3 ep = Examen parcial.println ( “ Ingrese la nota de la práctica 3: ” ) .println ( “ Ingrese la nota de la práctica 2: ” ) .min (notaMenor. p4 = Lectura.leerDouble( ) .println ( “ Ingrese la nota del examen final: ” ) . ep.println ( “ Ingrese la nota de la práctica 1: ” ) . Donde: pf = Promedio final. System. p4. do { System. pp. notaMenor = Math. 309 .Descripción del problema.

System.Desarrollo de la Codificación. Clase PrgPromedioNotas pp = ( p1 + p2 + p3 + p4 – notaMenor ) / 3 . pf = ( pp + ep + ef ) / 3 .out. Muestre el promedio de las notas redondeado a dos decimales.println ( “ Desea continuar (si=s/ no=n)?: ” ) . Juan José Flores Cueto. Pag. } } Modificar la codificación de la solución de tal forma que se elimine la práctica con la nota más baja y se duplique la nota de la práctica más alta.out. Ing. opc=Lectura. System. Continúa… Etapa 04 .leerChar( ) . pf = Math. } while ( opc=='s' || opc=='S' ) .println ( “ El promedio final del alumno es: ” + pf ) . 310 .round (pf) .

Clase PrgRedondearNumero package dominioDeLaAplicacion .println ( Math.out.out.println ( “ El número redondeado a tres decimales es: ” ) .out.5 ) / 10 ) . System.println ( “ La parte entera del número es: ” ) .out. numero=Lectura. Observe como se redondea un número con uno.out.out.println ( Math.println ( “ El número redondeado a un decimal es: ” ) .out. System.CLASES BÁSICAS INCORPORADAS EN EL LENGUAJE DE PROGRAMACIÓN JAVA Problema 82 Etapa 01 .Lectura .println ( “ Ingrese un número con decimales: ” ) .floor (numero) ) .out. System. System. class PrgRedondearNumero { public static void main ( String arg [ ] ) { double numero .println ( “ El número redondeado a dos decimales es: ” ) .leerDouble( ) . el número redondeado sin decimales.floor (numero * 1000 + 0. Pag. System.floor (numero * 10 + 0.floor (numero+0.println ( “ -----------------------------------” ) . } } ¿Qué hay de nuevo en la codificación? Observe el uso del método floor ( ) de la clase Math: El método floor ( ) retorna un valor double con el valor más grande no mayor que el parámetro dado.println ( Math. System. y el número redondeado a uno.out. System. Etapa 04 . System. 311 .5 para que en el segundo cálculo tenga efecto de redondeo perfecto. Desarrollar un programa en Java que permita ingresar un número cualquiera con parte decimal y muestre la parte entera del número.println ( “ El número redondeado es: ” ) .5 ) / 1000 ) . dos y tres decimales.out.5 ) / 100 ) .out.floor (numero * 100 + 0. System. import biblioteca. System.Descripción del problema.println ( Math.out.5) ) .println ( Math. System.Desarrollo de la Codificación. System. El parámetro dado debe ser double. Nótese que si ingresamos un numero cuya parte decimal es mayor que 5 sólo retorna la parte entera para tal caso se le agrega 0. dos y tres decimales utilizando el método floor ( ).

do { System. class PrgSorteo { public static void main ( String arg [ ] ) { double num . System.println ( “ Ingrese el total de boletos: ” ) .println ( “ El número ganador es: ” + ganador ) .round(num) . Juan José Flores Cueto. Etapa 04 . boletos = Lectura.random( ) . Problema 83 Etapa 01 . ganador = (int) Math.out. Sugerencia: Utilice el método random ( ) de la clase Math para generar el número del boleto ganador. import biblioteca.Desarrollo de la Codificación. } while (ganador == 0) . 312 . } } Pag. if (boletos > 0) { do { num = boletos * Math.leerInt( ) . ganador .out. Desarrollar un programa en Java que permite realizar un sorteo en base a un número determinado de boletos. int boletos. } } while ( boletos < 0 ) .Descripción del problema. Clase PrgSorteo package dominioDeLaAplicacion .Lectura . Ing.

print ( “ La suma de cuadrados de 1 hasta ” + num + “ es: ” ) . System.println ( “ Ingrese un numero cualquiera: ” ) .leerLong( ) . i++ ) { sumaCuad += Math. System. class PrgSumaCuadradosCubos { public static void main ( String arg [ ] ) { long num.print ( “ La suma de cubos de 1 hasta ” + num + “ es: ” ) . i <= num.Desarrollo de la Codificación.out. 313 . num = Lectura. Clase PrgSumaCuadradosCubos package dominioDeLaAplicacion . System.Lectura . sumaCubos += Math. System. import biblioteca. Desarrollar un programa en Java que permita calcular la suma de cuadrados y la suma de cubos de los “n” primeros números.CLASES BÁSICAS INCORPORADAS EN EL LENGUAJE DE PROGRAMACIÓN JAVA Problema 84 Etapa 01 . Etapa 04 .out. sumaCubos = 0 .Descripción del problema. Se deberá ingresar un número por teclado y mostrar los resultados.println ( sumaCuad ) .println ( sumaCubos ) .out.out.2) .pow (i.out.pow (i. for ( int i=1. } } Pag.3) . sumaCuad = 0. } System.

sin( anguloRadianes ) . Este método retorna un valor double y permite convertir un ángulo expresado en el sistema sexagesimal (enviado como parámetro double) en un ángulo expresado Pag.Desarrollo de la Codificación. System. anguloGrados = Lectura. } } ¿Qué hay de nuevo en la codificación? Observe el uso de los métodos toRadians ( ). coseno = Math. 314 . do{ System. intente otra vez: ” ).toRadians( anguloGrados ) . anguloRadianes. anguloRadianes = Math. de un ángulo ingresado por teclado hay que convertirlo primero al sistema radial. System. class PrgSenCos { public static void main ( String arg [ ] ) { double anguloGrados. sin ( ) y cos ( ) de la clase Math: Es importante mencionar que Java trabaja con el sistema radial y para obtener las razones trigonométricas.leerDouble( ) . Problema 85 Etapa 01 . import biblioteca. Mostrar como resultado el seno y el coseno del ángulo ingresado. Juan José Flores Cueto.println ( “ El sen [” + anguloGrados + “ ] = ” + seno ) . seno y coseno.cos( anguloRadianes ) .println ( “ Ingrese un ángulo en grados entre 0 y 360: ” ) .out. Clase PrgSenCos package dominioDeLaAplicacion . Etapa 04 . seno = Math. if (anguloGrados < 0 || anguloGrados > 360 ){ System.out. Ing.Lectura . Para esto. coseno = 0 .println ( “El dato ingresado es incorrecto. Desarrollar un programa en Java que permita ingresar un ángulo no mayor de 360 grados ni menor de 0 grados.out. utilizamos el método toRadians ( ) de la clase Math.println ( “ y el cos [” + anguloGrados + “ ] = ” + coseno ) . } }while(anguloGrados < 0 || anguloGrados > 360) .out.Descripción del problema. seno = 0.

CLASES BÁSICAS INCORPORADAS EN EL LENGUAJE DE PROGRAMACIÓN JAVA en radianes. Pag. Una vez convertido el ángulo en radianes podemos utilizar los métodos sin ( ) y cos ( ) de la clase Math para obtener el seno y el coseno del ángulo ingresado por teclado. 315 .

Problema 86 Etapa 01 . } } ¿Qué hay de nuevo en la codificación? Observe el uso del método tan ( ) de la clase Math: El método tan ( ) permite hallar la pendiente de una recta con respecto al eje X.out. class PrgTangente { public static void main ( String arg [ ] ) { double anguloGrados. tal y como se muestra: tangente = Math. expresado en el sistema radial.toRadians(anguloGrados) .Descripción del problema.leerDouble( ) . System. anguloRadianes. anguloGrados = Lectura. tangente = 0 . tangente = Math. Juan José Flores Cueto.println ( “ Ingrese el ángulo de inclinación de la recta: ” ) .tan(anguloRadianes) .Lectura . anguloRadianes = Math.out. Pag. 316 . System.Desarrollo de la Codificación. Clase PrgTangente package dominioDeLaAplicacion . Para ello. Desarrollar un programa en Java que permita ingresar un ángulo de inclinación de la recta con respecto al eje x. Ing. utiliza el ángulo de inclinación de la recta.tan(anguloRadianes) . import biblioteca. Etapa 04 .println ( “ La pendiente de la resta es = ” + tangente ) . Mostrar como resultado la pendiente de la recta.

605551275463989 Pag.Lectura . se suman.println ( “ Ingrese el primer cateto: ” ) . System.out.CLASES BÁSICAS INCORPORADAS EN EL LENGUAJE DE PROGRAMACIÓN JAVA Problema 87 Etapa 01 . } } La fórmula para este caso sería: (hipotenusa)2 = (cateto1)2 + (cateto2)2 . System. Clase PrgHipotenusa package dominioDeLaAplicacion . hipotenusa = Math. Calcular y mostrar la hipotenusa del tríangulo.println ( “ Ingrese el segundo cateto: ”) . System. import biblioteca. class PrgHipotenusa { public static void main ( String arg [ ] ) { double cateto1. Desarrollar un programa en Java que permita ingresar los catetos de un triángulo perpendicular. Luego se obtiene la raíz cuadrada con Math.pow (cateto1.pow (cateto2. hipotenusa .println ( “ La hipotenusa del triángulo es: ” + hipotenusa) . 2) + Math.out. Se ingresan los catetos por el teclado y son elevados al cuadrado con Math.pow ( ).sqrt ( Math.out.leerDouble( ) .Descripción del problema. 2) ) . El resultado obtenido. Ejemplo: Ingrese el primer cateto: 2 Ingrese el segundo cateto: 3 La hipotenusa del triángulo es: 3.sqrt ( ) y finalmente se muestra el resultado almacenado en la variable hipotenusa. Etapa 04 . al elevar al cuadrado cada uno de los catetos.Desarrollo de la Codificación.leerDouble( ) . 317 . cateto1 = Lectura. cateto2. cateto2 = Lectura.

System.Lectura . Calcular y mostrar el ángulo de las coordenadas del punto en grados.toDegrees(anguloRadianes) . Problema 88 Etapa 01 . anguloGrados = Math.out. abscisa) . Juan José Flores Cueto. ordenada = Lectura. abscisa. } } ¿Qué hay de nuevo en la codificación? Observe el uso de los métodos atan2 ( ) y toDegress ( ) de la clase Math: anguloRadianes = Math. System. abscisa) .leerDouble( ) . System.out. Desarrollar un programa en Java que permita ingresar la ordenada y la abscisa de un punto.leerDouble( ) .println ( “ Ingrese la abscisa(x) del punto: ” ) . class PrgPunto { public static void main ( String arg [ ] ) { double ordenada. Dicho ángulo expresado en radianes debe ser un valor double enviado al método como parámetro. Clase PrgPunto package dominioDeLaAplicacion .println ( abscisa + “] es: ” + anguloGrados) . abscisa = Lectura. Ing. 318 .print ( “ El ángulo en grados de [” + ordenada + “. import biblioteca. anguloRadianes .atan2(ordenada.Descripción del problema.toDegrees(anguloRadianes) .atan2(ordenada.Desarrollo de la Codificación. Sabemos que Math. anguloGrados. System.” ) . anguloGrados = Math.out.println ( “ Ingrese la ordenada(y) del punto: ” ) .out. anguloRadianes = Math. Pag. Etapa 04 .atan ( ) retorna un valor double con el arcotangente de un ángulo expresado en radianes.

se ingresan por teclado la ordenada y la abcisa de un punto cualquiera en el sistema de coordenadas. Pag. utilizando el método toDegrees ( ) de la clase Math. 319 .CLASES BÁSICAS INCORPORADAS EN EL LENGUAJE DE PROGRAMACIÓN JAVA Pero en este caso. Es importante mencionar que el método atan2 ( ) nos devuelve el arcotangente de un ángulo expresado en radianes por lo cual se tendrá que convertir dicho ángulo al sistema sexagesimal. se utiliza el método atan2 ( ) de la clase Math. Este método nos permite obtener el valor del arcotangente de un par ordenado. En este caso. por lo que el método atan ( ) de la clase Math no nos serviría (este método necesita el valor de un ángulo expresado en radianes y no los valores de las coordenadas de un punto).

class PrgExpLog { public static void main ( String arg [ ] ) { double num. logaritmo = Math. Problema 89 Etapa 01 . System. Ing.out.Lectura . exponencial = Math. Calcular y mostrar el número e elevado al número ingresado y el logaritmo natural (de base e) del número ingresado.print ( “ El valor del número [e] elevado a [” + num ) . System.println ( num + “] es: ” + logaritmo) . En esta solución se hace necesario el uso del método exp ( ) para obtener el número e elevado al número ingresado por teclado: enum También se hace necesario el uso del método log ( ) para obtener el logaritmo natural del número ingresado en base e: logenum Pag.out. num=Lectura. Juan José Flores Cueto.log(num) .out.println ( “ Ingrese un número: ” ) . logaritmo = Math.Desarrollo de la Codificación. } } ¿Qué hay de nuevo en la codificación? Observe el uso de los métodos exp ( ) y log ( ) de la clase Math: exponencial = Math.exp(num) .println ( “] es: ” + exponencial ) . Clase PrgExpLog package dominioDeLaAplicacion . Desarrollar un programa en Java que permita ingresar un número cualquiera. logaritmo . System.out. System.print ( “ El valor del logaritmo [en base e] del número [” ) . 320 .exp(num) .log(num) .Descripción del problema. System. exponencial.out.leerDouble(). Etapa 04 . import biblioteca.

A continuación se presentan algunas soluciones a problemas utilizando básicamente el método random ( ) de la clase Math. Pag. 321 .CLASES BÁSICAS INCORPORADAS EN EL LENGUAJE DE PROGRAMACIÓN JAVA Tenga presente que Java sólo resuelve logaritmos en base e y no en base 10. Analizar cada uno de las soluciones y desarrolle sus propias conclusiones. desarrollados con la finalidad de mejorar su comprensión del tema y sus capacidades lógicas.

Problema 90 Etapa 01 . cada uno de los cuales tiene 6 caras. class PrgLanzarDados1 { public static void main ( String arg [ ] ) { double n1.println ( “Lanzar dados” ) . import biblioteca. if ( suma1 == 7 || suma1 == 11 ) { opc1 = “s” . el jugador debe seguir tirando los dados hasta “lograr su punto”. 6. opc2 = “ ” . System. Etapa 04 .random ( ) * 6 ) ) . el jugador gana. el jugador pierde (es decir.println ( “Dado2 : ” + dado2 ) . Clase PrgLanzarDados1 package dominioDeLaAplicacion . Si la suma es 7 o 11 en el primer lanzamiento. n2. 9. las caras contienen 1. Juan José Flores Cueto.5 y 6 puntos. 3. Lectura. int dado1 = 0.println ( “Dado1 : ” + dado1 ) .out. System. nf . esto suma se convierte en el punto del jugador. 8. Para ganar. El jugador perderá si tira un 7 antes de lograr su punto. Si la suma es 2. 5. String opc1 = “ ”. do { System.out. Pag.* .leerString ( ) .out. suma2 = 0.Descripción del problema. dado2 = 0. dado1 = ( int ) (1 + ( Math. suma1 = dado1 + dado2 . Una vez que los dados quedan en reposo. 322 . Si la suma es 4. 2. estado = 1 . dado2 = ( int ) (1 + ( Math. 10 en el primer lanzamiento. Un jugador lanza dos dados.random ( ) * 6 ) ) . 4 . se suman los puntos de las dos caras que quedan hacia arriba. suma1 = 0. la casa gana). 3 o 12 en el primer lanzamiento (resultado que en los casinos reciben el nombre de “craps”). n3. estado = 0 . Ing.Desarrollo de la Codificación.

System. opc1 = “s” . if ( suma1 == suma2 ) { estado = 1 .out. } else if ( suma2 == 7 ) { estado = 0 . System. suma2 = dado1 + dado2 .println ( “Dado1 : ” + dado1 ) . dado1 = ( int ) (1 + ( Math.Desarrollo de la Codificación. 323 . } else { do { System. } } Pag.println ( “Lanzar dados” ) .CLASES BÁSICAS INCORPORADAS EN EL LENGUAJE DE PROGRAMACIÓN JAVA Continúa… Etapa 04 .out. dado2 = ( int ) (1 + ( Math. } }while ( opc1 != “s” ) . opc2 = “s” . if ( estado == 1 ) System.println ( “El jugador gana” ) . Lectura.out. } } while ( opc2 != “s” ) .println ( “Dado2 : ” + dado2 ) .leerString ( ) .random ( ) * 6 ) ) .out.println ( “El jugador pierde ” ) .out. else System. opc1 = “s” .random ( ) * 6 ) ) . estado = 0 . Clase PrgLanzarDados1 } else if ( suma1 == 2 || suma1 == 3 || suma1 == 12 ) { opc1 = “s” . opc2 = “s” .

random ( ) * 6 ) ) . suma1 = 0. Juan José Flores Cueto. opc2 = “ ” . char opc3 = ‘n’ . Problema 91 Etapa 01 . 324 . if ( suma1 == 7 || suma1 == 11 ) { opc1 = “s” . do { opc1 = “ ” . Lectura.out. estado = 0 . suma2 = 0.out.Descripción del problema. } else { Pag. import biblioteca.random ( ) * 6 ) ) . dado2 = ( int ) (1 + ( Math.leerString ( ) . Etapa 04 .Desarrollo de la Codificación.* . class PrgLanzarDados2 { public static void main ( String arg [ ] ) { int dado1 = 0. dado1 = ( int ) (1 + ( Math. Clase PrgLanzarDados2 package dominioDeLaAplicacion .println ( “Dado1 : ” + dado1 ) . opc2 = “ ” .println ( “Lanzar dados” ) . dado2 = 0. estado = 1 . suma1 = dado1 + dado2 . } else if (suma1 == 2 || suma1 == 3 || suma1 == 12) { opc1 = “s” . System. System. de tal forma que se muestre un mensaje preguntando si desea volver a tirar los dados. estado = 0 . String opc1 = “ ”. Modificar el programa del problema anterior.println ( “Dado2 : ” + dado2 ) . Ing.out. do { System.

System. suma2 = dado1 + dado2 . System. Lectura. if ( estado == 1 ) System.println ( “Dado2 : ” + dado2 ) .Desarrollo de la Codificación.CLASES BÁSICAS INCORPORADAS EN EL LENGUAJE DE PROGRAMACIÓN JAVA Continúa… Etapa 04 . opc2 = “s” .out.random ( ) * 6 ) ) .println ( “Dado1 : ” + dado1 ) . Clase PrgLanzarDados2 do { System.println ( “Desea volver a jugar [s/n] ” ) .println ( “ El jugador gana ” ) . opc2 = “s” .println ( “Lanzar dados” ) . System. dado1 = ( int ) (1 + ( Math. } } Pag. if ( suma1 == suma2 ) { estado = 1 .out. opc1 = “s” .leerChar ( ) .random ( ) * 6 ) ) .out. } } while ( opc1 != “s” ) . else System.println ( “ El jugador pierde ” ) . } while ( opc3 != ‘n’ ) .out. } } while ( opc2 != “s” ) . 325 .out. opc1 = “s” . opc3 = Lectura.leerString ( ) . } else if ( suma2 == 7 ) { estado = 0 .out. dado2 = ( int ) (1 + ( Math.

class PrgLanzarMoneda { public static void main ( String arg [ ] ) { int moneda.* . Clase PrgLanzarMoneda package dominioDeLaAplicacion . import biblioteca. Etapa 04 .Desarrollo de la Codificación. cont2 = 0. for ( int x = 1. Cuentar el número de veces que aparece cada lado de la moneda.println ( “La cantidad de veces que a salido la cara es : ” + cont1 ) . System. System. } } Pag.Descripción del problema. } System.println ( “La cantidad de veces que a salido el sello es : ” + cont2 ) .out.println ( “Cuántas veces desea Lanzar moneda ? ” ) .leerInt ( ) . Problema 92 Etapa 01 . cant . cant = Lectura. Elaborar un programa que simule el lanzamiento de una moneda. Juan José Flores Cueto. Mostrar los resultados.out. x++ ) { moneda = ( int ) (1 + ( Math.out. cont1 = 0. else cont2 ++ . Solicitar el número de veces que se lanzará la moneda. if (moneda == 1) cont1 ++ . 326 . x <= cant. Ing.random ( ) * 2 ) ) .

Pag.CLASES BÁSICAS INCORPORADAS EN EL LENGUAJE DE PROGRAMACIÓN JAVA Problema 93 Etapa 01 . System. 2. valor1 = ( int ) (1 + ( Math. Clase PrgTragamoneda1 package dominioDeLaAplicacion . monto = 0 .Desarrollo de la Codificación. Los números deberán ser generados aleatoriamente. Lectura. import biblioteca.random ( ) * 7 ) ) . if ( valor1 == valor2 && valor1 == valor3 ) { s = (char) valor1 .Descripción del problema. break . case 3 : monto = 300 .random ( ) * 7 ) ) .println( “Presionar enter para empezar” ) . switch (s) { case 1 : monto = 100 . char s.* .println ( valor1 + “ ” + valor2 + “ ” + valor3 ) . 5 . 327 . case 2 : monto = 200 . break . do { System.6 y 7 opciones de ganar. 3. class PrgTragamoneda1 { public static void main ( String arg [ ] ) { int valor1 = 0. opc1 . valor3 = ( int ) (1 + ( Math. Elaborar un programa que simule el juego de tragamonedas.leerString ( ) .out. valor2 = 0. los números son: 1. El jugador gana cuando el número se repita tres veces. 4. break .random ( ) * 7 ) ) .out. Etapa 04 . valor2 = ( int ) (1 + ( Math. valor3 = 0. El premio mayor se obtiene con el número 7.

println ( “La casa gana” ) .println ( “Usted gana : ” + monto + “Soles ” ) .println ( “Desea volver a jugador [s/n] : ” ) . Continúa… Etapa 04 . case 7 : monto = 1000 . } } Pag. break . case 6 : monto = 600 . Clase PrgTragamoneda1 case 4 : monto = 400 .out. Juan José Flores Cueto. opc1 = Lectura. monto = 0 .out. 328 . } System. } while ( opc1 != ‘n’ ) .out. Ing. break . System. break . case 5 : monto = 500 . break . } else System.leerChar ( ) .Desarrollo de la Codificación.

acumonto = 0 .Descripción del problema.out. monto = 0. valor2 = 0. valor3=( int ) (1 + ( Math. switch ( s ) { case 1 : monto=100 . de tal forma que se muestre la cantidad acumulada del dinero ganado en el tragamoneda. Lectura.* .CLASES BÁSICAS INCORPORADAS EN EL LENGUAJE DE PROGRAMACIÓN JAVA Problema 94 Etapa 01 . valor2=( int ) (1 + ( Math. import biblioteca.random ( ) * 7 ) ) . Modificar el programa del problema anterior. Etapa 04 .println ( valor1 + “ ” + valor2 + “ ” + valor3 ) . valor1=( int ) (1 + ( Math.random ( ) * 7 ) ) . break .println ( “Presionar enter para empezar” ) . break . case 2 : monto=200 . class PrgTragamoneda2 { public static void main ( String arg [ ] ) { int valor1 = 0. Clase PrgTragamoneda2 package dominioDeLaAplicacion . Pag. char s. if ( valor1 == valor2 && valor1 == valor3 ) { s= (char) valor1 .Desarrollo de la Codificación. do { System. valor3 = 0. 329 .leerString ( ) .opc1 .out.random ( ) * 7 ) ) . System.

Clase PrgTragamoneda2 case 3 : monto=300 . } acumonto = acumonto + monto . case 6 : monto=600 . break . case 5 : monto=500 . break . Continúa… Etapa 04 . case 7 : monto=1000 . System. System.Desarrollo de la Codificación.out.println ( “Desea volver a jugador [s/n] : ” ) .println ( “El dinero acumulado ganado es : ” + acumonto ) . } } Pag. break .out. Ing. } while ( opc1! = ‘n’ ) . break . break . System.println ( “La casa gana” ) . Juan José Flores Cueto.leerChar ( ) . } else System. 330 . case 4 : monto=400 . monto = 0 .out. opc1=Lectura.out.println ( “Usted gana : ” + monto ) .

println ( “Desea volver a intentarlo [s/n] : ” ) . El programa deberá preguntar ¿Cuánto es 6 por 7?. if ( resul1 == resul2 ) System. } } Pag. Las computadoras están desempeñando un papel cada vez más importante en la educación.Descripción del problema. por favor intente otra vez!. import biblioteca. Clase PrgMultiplicacion package dominioDeLaAplicacion .println ( “Respuesta correcta… Muy bien” ) . do { System.leerChar ( ) .println ( “Ingresar resultado de la multiplicación : ” ) . opc1 . Si es correcta mostrará un mensaje ¡Muy bien! y si es incorrecto mostrará el mensaje ¡No es correcto. resul1 = valor1 * valor2 .out. Lectura. System. System.out.random() * 9 ) ) . System.out.* .println ( “Aprendiendo a Multiplicar” ) .out.random() * 9 ) ) . El programa verificara si la respuesta es correcta. Etapa 04 .out. El estudiante deberá ingresar la respuesta. resul1 = 0. class PrgMultiplicacion { public static void main ( String arg [ ] ) { int valor1 = 0. 331 .CLASES BÁSICAS INCORPORADAS EN EL LENGUAJE DE PROGRAMACIÓN JAVA Problema 95 Etapa 01 . valor1 = ( int ) (1 + ( Math. resul2 = Lectura.out.println ( “¿Cuánto es ” + valor1 + “ por ” + valor2 + “ ?” ) . resul2 = 0 .println ( “No es la respuesta correcta… Vuelva a intentarlo” ) . else System. valor2 = ( int ) (1 + ( Math. char s. Desarrolle un programa que ayude a un estudiante de primaria a aprender a multiplicar.Desarrollo de la Codificación. } while ( opc1 != ‘n’ ) . opc1 = Lectura. valor2 = 0.leerInt ( ) .leerString ( ) . Utilice números aleatorios para producir dos enteros positivos de un solo digito.

System. multiplicar y dividir dos números generados al azar.Descripción del problema.println ( “[1] Sumar ”). signo = ‘ ’ .println ( “[5] Salir ”). de tal forma que se muestre un menú de opciones donde permita sumar. class PrgMenuOperaciones1 { public static void main ( String arg [ ] ) { int valor1 = 0. String operacion = “ ” . System. break .out. Pag.out.println ( “-----------------------------” ) . System. Modificar el programa del problema anterior.out. restar. do { System.println ( “[2] Restar ”). resul2 = 0. System.Desarrollo de la Codificación.out. Juan José Flores Cueto. System. 332 . valor1=( int ) (1 + ( Math.out. switch ( op ) { case 1 : resul1 = valor1 + valor2 .println ( “[3] Multiplicar ” ) . valor2=( int ) (1 + ( Math.out.println ( “Elegir opcion : ” ) . op . Ing. operacion = “Suma” . Etapa 04 .println ( “[4] Dividir ”). import biblioteca. valor2 = 0. resul1 = 0. op=Lectura. char opc.println ( “Menú de operaciones” ) .out.out. System. Problema 96 Etapa 01 .* . Se permitirá al estudiante contestar la misma pregunta una y otra vez hasta que responda correctamente. System.random ( ) * 9 ) ) .random ( ) * 9 ) ) . signo = ‘+’ .leerInt ( ) . Clase PrgMenuOperaciones1 package dominioDeLaAplicacion .

println ( “Ingresar resultado de la ” + operacion + “ :” ) . } System. System. case 3 : resul1 = valor1 * valor2 .leerInt ( ) . 333 . if ( resul1 != resul2 ) System. } while ( resul1 != resul2 ) .out. } while ( op != 5 ) . operacion = “Multiplicación” .valor2 .println ( “No es.out. signo = ‘-’ .exit (0) . case 4 : resul1 = valor1 / valor2 . operacion = “División” . por favor trata otra vez” ) . Clase PrgMenuOperaciones1 case 2 : resul1 = valor1 . case 5 : System.out. resul2 = Lectura. break . signo = ‘*’ . break . } } Pag. break . operacion = “Resta” .CLASES BÁSICAS INCORPORADAS EN EL LENGUAJE DE PROGRAMACIÓN JAVA Continúa… Etapa 04 . signo = ‘/’ . break . do { System.println ( “¿Cuánto es ” + valor1 + “ ” + signo + “ ” + valor2 + “ ?” ) .Desarrollo de la Codificación.println ( “Muy bien” ) .out.

Modificar el programa del problema anterior.println ( “[1] Sumar ”). valor2 = 0. Etapa 04 .* . multiplicar y dividir dos números al azar.println ( “-----------------------------” ) .out.out.leerInt ( ) . Juan José Flores Cueto. String operacion = “ ” .out. System.out.Descripción del problema. 334 .println ( “[2] Restar ”).println ( “Elegir opcion : ” ) .random ( ) * 9 ) ) . Clase PrgMenuOperaciones2 package dominioDeLaAplicacion . Problema 97 Etapa 01 . System.Desarrollo de la Codificación. System. de tal forma que se muestre un menú de opciones donde permita sumar.out. Ing. break .println ( “[5] Salir ”). cont2 = 0 . cont1 = 0. do { System. import biblioteca. System.println ( “[3] Multiplicar ” ) . class PrgMenuOperaciones2 { public static void main ( String arg [ ] ) { int valor1 = 0. System. signo = ‘+’ . Mostrar la cantidad de preguntas correctas y la cantidad de preguntas incorrectas. op = Lectura. resul2 = 0 .println ( “[4] Dividir ”).random ( ) * 9 ) ) .println ( “Menú de operaciones” ) .out. System. int op. resul1 = 0.out. operacion = “Suma” . valor2 = ( int ) (1 + ( Math. signo = ‘ ’ . valor1 = ( int ) (1 + ( Math. char opc. restar. switch ( op ) { case 1 : resul1 = valor1 + valor2 .out. Pag. System.

resul2 = Lectura. System. operacion = “Resta” . } } while ( op != 5 ) . Clase PrgMenuOperaciones2 case 2 : resul1 = valor1 .println ( “La cantidad de respuestas incorrectas fueron : ” + cont2 ) . break .CLASES BÁSICAS INCORPORADAS EN EL LENGUAJE DE PROGRAMACIÓN JAVA Continúa… Etapa 04 . cont2 ++ .out. break . break . } } Pag.out.println ( “Muy bien” ) . signo = ‘-’ . signo = ‘*’ . case 4 : resul1 = valor1 / valor2 . signo = ‘/’ . operacion = “Multiplicación” . cont1 ++ . } else { System.println ( “La cantidad de respuesta correctas fueron : ” + cont1 ) .out.println ( “Ingresar resultado de la ” + operacion + “: ” ) . System.out.Desarrollo de la Codificación.println ( “¿Cuánto es ” + valor1 + “ ” + signo + “ ” + valor2 + “ ?” ) . case 3 : resul1 = valor1 * valor2 .exit (0) .out.out. System. operacion = “División” .println ( “No es.valor2 . case 5 : System.leerInt ( ) . if ( resul1 != resul2 ) { System. break . } System. 335 . por favor trata otra vez” ) .

Etapa 04 .* .println ( “Desea Continuar [s/n]: ” ) . class PrgAdivinarNumero1 { public static void main ( String arg [ ] ) { int valor = 0.println ( “Felicidades adivinaste el número ” ) .println ( “Adivine el número” ) . num = Lectura. import biblioteca. Pruebe otra vez” ) . } } Pag.println ( “El número es demasiado grande. char opc = ‘ ’ . } while ( opc != ‘n’ ) .out. Problema 98 Etapa 01 .out. Elaborar un programa que permita adivinar cuál es el número entero generado al azar entre 1 y 1000. 336 . El jugador ingresará una primera estimación. Clase PrgAdivinarNumero1 package dominioDeLaAplicacion .Desarrollo de la Codificación.out. do { System.out. num = 0 .leerInt ( ) . valor = ( int ) (1 + ( Math. do { System. Cuando la respuesta sea correcta se mostrará un mensaje de felicitaciones. Pruebe otra vez” ) . } while (num != valor ) . el programa deberá indicar si el número ingresado fue más grande o fué más pequeño que el número generado al azar. opc = Lectura.random ( ) * 1000 ) ) .println ( “El número es demasiado chico.out. Juan José Flores Cueto. si la estimación del jugador es incorrecta.leerChar ( ) . Ing. System. if ( num < valor ) System. else if ( num > valor ) System.out. else System.Descripción del problema.println ( “Ingresar número : ” ) .

println ( “Ingresar número : ” ) .leerInt ( ) .out. opc=Lectura. } while ( opc != ‘n’ ) . } else if ( num < valor ) System.out. Pruebe otra vez ” ) .println ( “Deberías haberlo hecho mejor” ) .out. num = Lectura. else System. Etapa 04 .out.println ( “Ingrese la cantidad de intentos : ” ) . System. } while ( num != valor ) . class PrgAdivinarNumero2 { public static void main ( String arg [ ] ) { int valor = 0.CLASES BÁSICAS INCORPORADAS EN EL LENGUAJE DE PROGRAMACIÓN JAVA Problema 99 Etapa 01 . else if ( num > valor ) System. cont ++ .leerInt ( ) .Descripción del problema.println ( “El número es demasiado grande. do { System. char opc = ‘ ’ . intentos=Lectura.out.println ( “Felicidades adivinaste el número” ) .* . valor = num . System.out. de tal forma que se pueda ingresar la cantidad de intentos que se tiene para adivinar el número.println ( “Desea Continuar [s/n]: ” ) .out. Modificar el programa del problema anterior.out.println ( “Adivine el número” ) . cont = 0 .Desarrollo de la Codificación.random ( ) * 1000 ) ) . 337 . Import biblioteca. if (cont >= intentos ) { System. do { System. Pruebe otra vez” ) . valor = ( int ) (1 + ( Math. intentos.println ( “El número es demasiado chico. num = 0. } } Pag.leerChar ( ) . Clase PrgAdivinarNumero2 package dominioDeLaAplicacion .

Juan José Flores Cueto. Pag. Ing. 338 .

sino que se crean objetos de la clase String). es una clase que viene incorporada en el lenguaje de programación Java. para ubicarlos.lang cada vez que se necesite utilizar la clase String de Java. números y símbolos especiales almacenados en una variable de tipo texto o cadena. Las conversiones son realizadas a través del método toString ( ). Ejemplo: String nom = “Danae” . 339 .lang. no será necesario importar el paquete java. el cual puede ser utilizado por todas las clases Java a través de la herencia. la cual permite declarar y manipular variables de tipo texto o cadena (en realidad no se declaran variables de tipo texto o cadena. JERARQUÍA DE CLASES Y HERENCIA java.Object java.lang es el paquete principal del lenguaje Java por lo cual no se necesita importar ninguna clase incluida en dicho paquete.CLASES BÁSICAS INCORPORADAS EN EL LENGUAJE DE PROGRAMACIÓN JAVA MANEJO DE CADENAS: CLASE STRING INTRODUCCIÓN Una cadena es un conjunto de caracteres. incluida en el paquete java.lang.lang. La clase String permite manipular las variables de tipo texto o cadena a través de los métodos que implementa (la clase String tiene métodos de instancia y métodos de clase). En consecuencia. método definido en la clase Object. La clase String incluye métodos que permiten examinar los caracteres individuales de una cadena para compararlos. Pag. y para crear copias de una cadena convirtiendo todos sus caracteres a letra mayúscula o minúscula.String El paquete java. para extraerlos como subcadenas. La clase String.

) y el nombre del método de clase que se desea ejecutar. En caso. concat( ). 13. Para trabajar con los métodos de instancia de la clase String es necesario previamente haber declarado y asignado un valor a una variable de tipo texto o cadena. toCharArray( ). 16. equalsIgnoreCase( ). Para ejecutar un método de instancia de la clase String es necesario colocar el nombre de la variable (que debe ser de tipo texto o cadena). length( ). Para el caso de los métodos de clase esto no será necesario. toUpperCase( ). 12. substring( ). 7. 5. 9. 14. 340 . éstos deben ser necesariamente proporcionados en la cantidad y tipos requeridos. se debe tener en cuenta que si. valueOf( ). charAt( ). 8. A continuación se presenta una breve descripción del uso de cada uno de los métodos de la clase String: Pag.) y el nombre del método de instancia que se desea ejecutar. el método necesita algunos datos. Asimismo. Para el caso de los métodos de clase deberá colocar la palabra String. equals( ). Juan José Flores Cueto. lastIndexOf( ). 3. 2. éste deberá almacenarse en una variable del mismo tipo o mostrarse a través de la pantalla. para ejecutar cualquiera de los método de la clase String. 11. el operador punto (. Métodos de clase: 17. 4. toLowerCase( ). 15. 6. 10. indexOf( ). endsWith( ). el operador punto (. compareTo( ). Ing. MÉTODOS La clase String presenta los siguientes métodos: Métodos de instancia: 1. trim( ). replace( ). que el método devuelva un resultado. startsWith( ).

Devuelve true (verdadero) si el String cad2 = “Danae”. que cero. minúscula y mayúscula. Resultado : cadena = "Hola a todos” String cad1 = “Hola Danae”. Caso contrario devuelve false (falso). cadena se encuentra ubicado en la posición 0 (cero). equalsIgnoreCase(String) pero la comparación la realiza sin boolean x.equals(cad2). String cad1 = “Danae”. concat(String) cadena = cad1. endsWith(String) cadena colocada como parámetro. por la variable entera o número char x = cad1. Este método permite juntar dos cad2 = " a todos". tener en cuenta las letras x = cad1. x = true. entero colocado como parámetro. Resultado: Pag. devuelve un número entero menor String cad2 = “Hola Pedro”. Resultado: x = true.charAt(5). Devuelve true (verdadero) si la String cad2 = “Danae”. el primer caracter de una x = ‘D’. el método devuelve un entero mayor que cero. charAt(int) Es importante mencionar que en resultado: Java. cadena. 341 . el método String cad1 = “Hola Danae”. cadena coincide con la cadena boolean x = cad1. Caso contrario devuelve false Resultado: (falso). compareTo(String) alfabéticamente iguales devuelve un número cero y si la cadena es Resultado: alfabéticmente mayor que la x < 0 (cad1<cad2).equalsIgnoreCase(cad2). String cad1. final de la cadena coincide con la boolean x = cad1.endsWith(cad2). cadenas en una sola cadena. equals(String) colocada como parámetro. Si las dos cadenas son int x = cad1.compareTo(cad2). cad1 = "Hola". Si la cadena es alfabéticamente menor que la cadena colocada como parámetro.concat (cad2). cadena colocada como parámetro. Este método realiza la misma String cad1 = “DANAE”. cad2. función que el método equals ( ) String cad2 = “Danae”.CLASES BÁSICAS INCORPORADAS EN EL LENGUAJE DE PROGRAMACIÓN JAVA CLASE String MÉTODOS DE DESCRIPCIÓN USO INSTANCIA Devuelve el caracter que encuentre en la posición indicada String cad1 = “Hola Danae”.

6). String cad1 = “Hola Danae”.lastIndexOf( “ana” ).lastIndexOf(‘a’. int x = cad1. indexOf(String) delante. MÉTODOS DE DESCRIPCIÓN USO INSTANCIA x = true.int) Devuelve la posición de la cadena en la que aparece por primera vez Resultado: el caracter colocado como x = 8. Ing.indexOf(‘a’. int x = cad1. indexOf(char. indexOf(String.lastIndexOf( “lo”. lastIndexOf(char. Resultado: x = 8. indexOf(char) Resultado: x = 5.5 ). String cad1 = “Hola Danae”. Pag. parámetro. cual se empieza a buscar hacia int x = cad1.5). String cad1 = “Hola Danae”. 342 .int) Resultado: x = 2.lastIndexOf(‘a’).3 ). String cad1 = “Hola Danae”. lastIndexOf(String. String cad1 = “Hola Danae”.int) Devuelve la posición de la cadena en la que aparece por última vez el Resultado: caracter colocado como parámetro. Juan José Flores Cueto. También se puede especificar un segundo parámetro a partir del String cad1 = “Hola Danae”. También se puede especificar un segundo parámetro a partir del String cad1 = “Hola Danae”. int x = cad1.indexOf( “ana” ).indexOf( “Dan”. int x = cad1. int x = cad1. cual se empieza a buscar hacia int x = cad1. lastIndexOf(String) atrás. String cad1 = “Hola Danae”. lastIndexOf(char) Resultado: x = 8. Resultado: x = 6. int x = cad1.indexOf(‘D’). int) Resultado: x = 5. x = 3.

9). x = “Holo Donoe”. (Los toCharArray() vectores serán tratados en el Resultado: capítulo IV).toCharArray(). Permite reemplazar todos los String cad1 = “Hola Danae”. caracteres iguales al caracter String x = cad1. en un vector de caracteres. ‘a’.‘e’}. trim() blanco del inicio y del final de una cadena.substring(6.substring(5).int) Resultado: x = “ana”. si el comienzo de la cadena boolean x. String cad1 = “Hola Danae”. ‘D’. Devuelve la longitud de una int x = cad1. Convierte una cadena específica char[ ] x = cad1. Resultado: x = “hola danae”. ‘n’. length() cadena.char) colocado como primer parámetro con el caracter colocado como Resultado: segundo parámetro. Resultado: x = 10. el número de caracteres que tiene la cadena. Resultado: x = “Hola Danae”. como parámetro. replace(char. String cad1 = “Hola Danae”.‘a’. caso contrario devuelve false (falso).‘ ’. String cad1 = “Hola Danae”. String x = cad1. Pag. String x = cad1. Convierte las letras de una cadena toLowerCase() en letras minúsculas.replace(‘a’. String x = cad1.CLASES BÁSICAS INCORPORADAS EN EL LENGUAJE DE PROGRAMACIÓN JAVA MÉTODOS DE DESCRIPCIÓN USO INSTANCIA String cad1 = “Hola Danae”. x = {‘H’. String cad1 = “ Hola Danae ”.length(). Resultado: x = true. ‘a’. String cad1 = “Hola Danae”.toLowerCase(). indicada en el primer parámetro hasta el final o hasta una posición anterior a la indicada en el String cad1 = “Hola Danae”. Devuelve un valor true (verdadero) String cad2 = “Hola”. ‘o’). Resultado: empezando desde la posición x = “Danae”. substring(int) Devuelve una subcadena a partir de la cadena especificada. Permite eliminar los espacios en String x = cad1. Es decir. startsWith(String) coincide con la cadena colocada x = cad1. segundo parámetro del método. 343 .trim(). substring(int.startsWith(cad2).‘l’.‘o’.

con la finalidad de mejorar la comprensión del tema tratado. 344 . Analice cada una de las siguientes soluciones. MÉTODO DE CLASE DESCRIPCIÓN USO String. MÉTODOS DE DESCRIPCIÓN USO INSTANCIA String cad1 = “Hola Danae”.valueOf(char[ ]) x = “3.valueOf(float) convertir los valores de otros tipos String. se presentan algunas soluciones a problemas planteados utilizando algunos de los métodos de la clase String. Juan José Flores Cueto.1416.valueOf(long) Método de clase que permite String x = String. Convierte las letras de una cadena toUpperCase() en letras mayúsculas.valueOf(boolean) String.valueOf(char[ ].valueOf(double) de datos o variables a una cadena.toUpperCase(). String. Resultado: x = “HOLA DANAE”. String. Pag.valueOf(int) double pi = 3.valueOf(Object) resultado: String. String. int. String.valueOf(pi). String x = cad1.1416”.int) A continuación. Ing.

import biblioteca.toUpperCase ( ) . nom = Lectura.print ( “ Ingresar el nombre: ” ) .out. podemos mostrar el resultado utilizando System. Mostrar el nombre del alumno en letras mayúscula.leerString( ) .println ( “ El nombre en Mayúscula es: ” + nom ) .toUpperCase( ) . Nombre del método. tal y como lo hemos realizado en nuestro ejemplo: Pag. public class PrgConvertirMayuscula { public static void main(String [ ] args) { String nom .println o almacenarlo en una variable (que puede ser la variable que contenía la cadena original). El método toUpperCase ( ) se utiliza con variables de tipo String y permite convertir en letras mayúsculas el contenido de la variable que antecede al nombre del método y al operador punto (en nuestro caso la variable nom). Operador punto.* . Etapa 04 – Desarrollo de la codificación.out. Desarrollar un programa en Java que permita ingresar el nombre de un alumno. Como el método toUpperCase ( ) nos devuelve un valor de tipo String (el contenido de la variable en letra mayúscula). } } ¿Qué hay de nuevo en la codificación? Observe el uso del método toUpperCase ( ) de la clase String: nom. 345 . System. System. Nombre de la variable (objeto). Clase PrgConvertirMayuscula package dominioDeLaAplicacion .out.CLASES BÁSICAS INCORPORADAS EN EL LENGUAJE DE PROGRAMACIÓN JAVA Problema 100 Etapa 01 – Descripción del problema. nom = nom.

toUpperCase ( ) . Ing. Es importante tener presente que el método toUpperCase ( ) es un método que solo podemos utilizar con variables de tipo String y su función es convertir el contenido de una variable en letras mayúscula. Pag. nom = nom. 346 . Juan José Flores Cueto.

toLowerCase( ) . Nombre del método. Nombre de la variable (objeto). Operador punto. Mostrar el nombre del alumno en letras minúsculas.* . System.println o almacenarlo en una variable (que puede ser la variable que contenía la cadena original). 347 . tal y como lo hemos realizado en nuestro ejemplo: Pag.out.CLASES BÁSICAS INCORPORADAS EN EL LENGUAJE DE PROGRAMACIÓN JAVA Problema 101 Etapa 01 – Descripción del problema.toLowerCase ( ) . System. Clase PrgConvertirMinuscula package dominioDeLaAplicacion . nom = Lectura. Como el método toLowerCase ( ) nos devuelve un valor de tipo String (el contenido de la variable en letra minúscula).leerString( ) . El método toLowerCase ( ) se utiliza con variables de tipo String y permite convertir en letras minúsculas el contenido de la variable que antecede al nombre del método y al operador punto (en nuestro caso la variable nom).out. } } ¿Qué hay de nuevo en la codificación? Observe el uso del método toLowerCase ( ) de la clase String: nom.out. import biblioteca.println ( “ El nombre en Minúscula es: ” + nom ) . Etapa 04 – Desarrollo de la codificación. nom = nom. podemos mostrar el resultado utilizando System. Desarrollar un programa en Java que permita ingresar el nombre de un alumno. public class PrgConvertirMinuscula { public static void main(String [ ] args) { String nom .print ( “ Ingresar el nombre: ” ) .

Pag.toLowerCase ( ) . Ing. Juan José Flores Cueto. Es importante tener presente que el método toLowerCase ( ) es un método que solo podemos utilizar con variables de tipo String y su función es convertir el contenido de una variable en letras minúscula. 348 . nom = nom.

espacio = “ ” .println ( “ Ingresar el primer nombre del alumno: ” ) . nom1 = nom1. Luego el contenido de la variable nom1 se junta con el contenido de la variable nom2 y el resultado se almacena en la variable nombre. import biblioteca. Concatenar y Mostrar los nombres del alumno en letras mayúsculas y letra minúsculas. Etapa 04 – Desarrollo de la codificación.println ( “ El nombre en Minúscula es: ” + nombre. public class PrgConcatenarNombres { public static void main(String [ ] args) { String nom1. System. 349 . nom2. El método concat ( ) se utiliza para juntar o concatenar el contenido de dos variables de tipo String (la misma función cumple el signo “+ “cuando trabaja con variables de tipo String).println ( “ Ingresar el segundo nombre del alumno: ” ) .toLowerCase() ) . System.out.concat(nom2) .concat(espacio) .toUpperCase() ) .* .out. nom1 = nom1. Es decir. nom2 = Lectura. nombre = nom1.out. System.out.concat(nom2) . System. el contenido de la variable nom1 y el contenido de la variable espacio se juntan (o concatenan) y el resultado se almacena en la variable que antecede al signo = (en nuestro caso la misma variable nom1). Pag. nombre = nom1.concat (espacio) . Desarrollar un programa en Java que permita ingresar el primer nombre y el segundo nombre de un alumno.leerString( ) . nombre.leerString( ) . } } ¿Qué hay de nuevo en la codificación? Observe el uso del método concat ( ) de la clase String: nom = nom. Clase PrgConcatenarNombres package dominioDeLaAplicacion . nom1 = Lectura.concat (espacio) .println ( “ El nombre en Mayúscula es: ”" + nombre.CLASES BÁSICAS INCORPORADAS EN EL LENGUAJE DE PROGRAMACIÓN JAVA Problema 102 Etapa 01 – Descripción del problema.

println. Pag. Juan José Flores Cueto.concat (nom2) ) .out. explicados en los problemas anteriores. como se muestra a continuación: System.println para mostrar el nombre del alumno en letra minúscula y en letra mayúscula. Esto permite juntar o concatenar los nombres del alumno con un espacio en blanco entre ellos en una única variable de tipo String. También podría visualizarse directamente el resultado de juntar o concatenar dos variables de tipo String (cadenas) utilizando System.println (nom1. Finalmente. Ing.out. 350 . directamente con System. se utilizan los métodos toUpperCase ( ) y toLowerCase ( ).out.

351 . También observe el uso del método length ( ) de la clase String: Pag. Desarrollar un programa en Java que permita ingresar el nombre de un alumno. ya que el usuario puede haber presionado la barra espaciadora antes de ingresar el nombre del alumno y esto se almacena en la variable como espacios en blanco.println ( “ Nombre ingresado no válido… Reintente! ” ) . } } ¿Qué hay de nuevo en la codificación? Observe el uso del método trim ( ) de la clase String: nom = nom. El método trim ( ) permite eliminar los espacios en blanco que pueden existir al inicio y/o al final de una cadena contenida en una variable (en nuestro caso la cadena contenida en la variable nom). } } while (nom. Esto se realiza como precaución.trim ( ) . System. if ( nom.CLASES BÁSICAS INCORPORADAS EN EL LENGUAJE DE PROGRAMACIÓN JAVA Problema 103 Etapa 01 – Descripción del problema.trim( ) . nom = nom. Etapa 04 – Desarrollo de la codificación.* . String nom .leerString( ) . import biblioteca. public class PrgLongitudCadena { public static void main(String [ ] args) { int cant .out.println ( “ La cantidad de caracteres del nombre es: ” + cant ) . do { System.out.length( ) .length( ) < 2 ) . Consistenciar el nombre del alumno al momento de ingresarlo. nom = Lectura. Mostrar el número de caracteres del nombre ingresado por teclado. cant = nom.out. Clase PrgLongitudCadena package dominioDeLaAplicacion .length( ) < 2 ) { System.println ( “ Ingresar el nombre: ” ) .

como por ejemplo.println ( “Nombre ingresado no válido… Reintente! ” ) .out.println(). Lu. utilizarlo en una condición lógica o almacenarlo en una variable. 3. Pedro.trim ( ) . podemos mostrar el resultado utilizando System. se consistencia el ingreso del nombre de tal forma que no se permita ingresar un nombre que tenga menos de 2 caracteres (se asume que pueden haber nombres de 2 caracteres o mas.println ( “ Ingresar el nombre: ” ) . } } while (nom.out.length ( ) < 2 ) { System. la cantidad de caracteres que almacena la variable nom). Ing. if ( nom. do { System.length ( ) < 2) . En la líneas de código mostradas a continuación. Pag. nom = nom. que tienen 2.length ( ) . El método length ( ) se utiliza con variables de tipo String y nos permite contar la cantidad de caracteres que almacena una variable (en nuestro caso. nom = Lectura. y 5 caracteres respectivamente).out. cant = nom. Juan José Flores Cueto. 4. Como el método length ( ) devuelve la cantidad de caracteres que tiene una variable (incluido los espacios en blanco). 352 .leerString( ) . Ana. José. En nuestro ejemplo lo utilizamos como condición lógica y para almacenarlo en una variable.

length( ) < 2 ) .toUpperCase( ) . luego se consistencia que tenga por lo menos 2 caracteres y luego se convierte el contenido de la variable nom en letra mayúscula.CLASES BÁSICAS INCORPORADAS EN EL LENGUAJE DE PROGRAMACIÓN JAVA Problema 104 Etapa 01 – Descripción del problema. if ( nom. Pag. do { System. Desarrollar un programa en Java que permita ingresar el nombre de un alumno. public class PrgConvertirMayuscula2 { public static void main(String [ ] args) { String nom . } } while ( nom. } } Observe el uso de los métodos trim ( ).trim( ) . nom = nom.println ( “ Ingresar el nombre: ” ) . para finalmente mostrar su contenido por pantalla. nom = nom. Consistenciar el nombre del alumno al momento de ingresarlo. se debe eliminar los espacios en blanco que la variable nom pueda tener al inicio y al final del dato que contiene.length( ) < 2 ) { System.out.println ( “ El nombre en Mayúscula es: ” + nom ) . length ( ) y toUpperCase ( ) de la clase String. En consecuencia. En la codificación de este programa. Clase PrgConvertirMayuscula2 package dominioDeLaAplicacion .leerString( ) .println ( “ Nombre ingresado no válido… Reintente! ” ) . System. Mostrar el nombre del alumno en letras mayúscula. se puede afirmar que esta solución es más óptima que la solución presentada en el problema 100.out.* . nom = Lectura. import biblioteca. 353 .out. Etapa 04 – Desarrollo de la codificación.

length( ) < 2 ) { System. } } ¿Qué hay de nuevo en la codificación? Observe el uso del método substring ( ) de la clase String: cadena1 = nom. import biblioteca. cadena2 = nom. nom = nom. Juan José Flores Cueto. Etapa 04 – Desarrollo de la codificación. Imagínese que la variable nom contiene el nombre “danae”. La primera forma nos permite obtener una subcadena desde una posición inicial hasta un caracter antes de la posición final indicada. cadena2 = nom. Mostrar el primer caracter del nombre ingresado en mayúsculas. cadena2= “” . cadena1 = nom. El método substring ( ) se utiliza de dos formas.leerString( ) . 354 . tal y como se muestra a continuación: Pag.out.toUpperCase( ) .* .concat(cadena2) .length( ) < 2 ) . System. cadena1= “”.substring(1) . La segunda forma nos permite obtener una subcadena desde una posición determinada hasta el final de la cadena. Problema 105 Etapa 01 – Descripción del problema.substring(1) . Ing. nom = cadena1.1) . do { System. if ( nom.trim( ) .substring(0.1) .out. nom = Lectura. Desarrollar un programa en Java que permita ingresar el nombre de un alumno.println ( “ Ingresar el nombre: ” ) .println ( “ Nombre ingresado no válido… Reintente! ” ) . } } while (nom. cadena1 = cadena1.out. Clase PrgPrimeroMayuscula package dominioDeLaAplicacion .substring(0.println ( “ El nombre del alumno es: ” + nom ) . public class PrgPrimeroMayuscula { public static void main(String [ ] args) { String nom.

substring (1. nom = cadena1. Continuando con nuestro ejemplo. si deseamos obtener la primera letra de la cadena utilizamos la siguiente sentencia: cadena1 = nom. Donde. Esto lo realizamos utilizando: cadena2 = nom.toUpperCase ( ) . Suponiendo que se desee obtener la subcadena “ana” de la cadena “danae” contenida en la variable nom.substring (1) . indica la posición de la cadena nom donde va a comenzar la subcadena (la primera letra “a”) hasta el final de la cadena. donde el número (en nuestro caso el número 1). 355 . empezando por la posición cero (0). posición 0 Entonces. Ahora es necesario obtener el resto del contenido de la variable nom. Para finalizar solo será necesario juntar o concatenar ambas variables en la variable original nom.4) . nom = “danae”. Pag. el primer número del método substring ( ) indica la posición de la cadena nom desde donde va a empezar la subcadena y el segundo número indica la posición final de la cadena (es importante mencionar que se debe incluir hasta un caracter antes de la posición final indicada). Esta es la segunda forma de utilizar el método substring ( ). Esto nos permite solo obtener el primer caracter de nom (la letra “d”). Cuando manipulamos cadenas con el método substring ( ) debemos tener en cuenta que cada caracter de la cadena tiene una determinada posición. utilizaríamos la siguiente sentencia: cadena1 = nom. El resultado que se obtiene es el nombre ingresado con la primera letra en mayúscula. Ahora en la variable cadena1 tenemos almacenada la letra “D” y en la variable cadena2 tenemos almacenadas las letras “anae”.CLASES BÁSICAS INCORPORADAS EN EL LENGUAJE DE PROGRAMACIÓN JAVA nom = “danae”. utilizando el método concat ( ).concat (cadena2) .substring(0.1) . una vez obtenida la primera letra del nombre se convierte a mayúscula utilizando: cadena1 = cadena1.

substring(1) . se puede afirmar que esta solución es más óptima que la solución presentada en el problema 104.concat(cadena2) .length( ) < 2) { System.out. toUpperCase ( ). cadena2 = nom. cadena1 = nom. String nom.substring(0. length ( ). Finalmente siempre el nombre tendrá la primera letra en mayúscula y el resto en letra minúscula. System.toLowerCase( ) . do { System.1) . } } while (nom.println ( “ Ingresar el nombre: ” ) . Pag. if ( nom.length( ) < 2 ) . cadena1 = “” . substring ( ) en sus dos formas. Etapa 04 – Desarrollo de la codificación. Clase PrgMayusculaMinuscula package dominioDeLaAplicacion . cadena2 = cadena2. public class PrgMayusculaMinuscula { public static void main(String [ ] args) { int cant . } } Observe el uso de los métodos trim ( ).println ( “ El nombre del alumno es: ” + nom ) . Ing. Desarrollar un programa en Java que permita ingresar el nombre de un alumno. import biblioteca.* . Esto como precaución de que se ingrese todo el nombre en mayúscula o en forma combinada entre letras mayúsculas y minúsculas. cadena1 = cadena1. cadena2 = “” .leerString( ) .toUpperCase( ) . nom = nom.trim( ) . nom = Lectura.println ( “ Nombre ingresado no válido… Reintente! ” ) .out. nom = cadena1. En consecuencia. se convierte en mayúscula la primera letra del nombre y el resto se convierte en minúscula. 356 .out. En la codificación de este programa. Juan José Flores Cueto. Mostrar el primer caracter del nombre ingresado en mayúsculas y el resto en minúscula. toLowerCase ( ) y concat ( ) de la clase String. Problema 106 Etapa 01 – Descripción del problema.

* . caracter .trim( ) .substring(0.x+1) . String nom. nom = nom. caracter = caracter. cadena2 = nom. x<cant.cadena2 = “”.out. } } while (nom. cadena1 = “”. Clase PrgNombreCompleto package dominioDeLaAplicacion .substring(0. Etapa 04 – Desarrollo de la codificación.concat(cadena2) .toUpperCase( ). cant = nom. cadena2 = nom. nom = cadena1 + caracter + cadena2 . nom = Lectura.substring(x+2) . Mostrar el primer caracter de cada palabra del nombre en mayúsculas y el resto de cada palabra en minúscula.toLowerCase( ) . public class PrgNombreCompleto { public static void main(String [ ] args) { int cant . } else { caracter = nom. if ( nom.out.println ( “ Ingresar el nombre: ” ) . caracter = nom.CLASES BÁSICAS INCORPORADAS EN EL LENGUAJE DE PROGRAMACIÓN JAVA Problema 107 Etapa 01 – Descripción del problema.equals ( “ ” ) ) { cadena1 = nom. nom = cadena1. Desarrollar un programa en Java que permita ingresar el nombre completo de un alumno (nombres y apellidos en una sola variable). x+1) .length( ) < 2) . do { System.length( ) .substring(1) . cadena2 = cadena2. import biblioteca. } } } System.length( ) < 2) { System. for (int x=0. cadena1 = cadena1. if (caracter.substring(x.1) .toUpperCase( ) . } } ¿Qué hay de nuevo en la codificación? Pag. 357 .println ( “ El nombre del alumno es: ” + nom ) .out.leerString( ) . x++) { if ( x==0) { cadena1 = nom.substring(x+1. x+2) .println ( “ Nombre ingresado no válido… Reintente! ” ) .

sw = false . en caso contrario nos devuelve un valor falso (false).length( ) . Observe el uso del método equals ( ) de la clase String: if (caracter. Si el caracter resulta ser un espacio en blanco entonces se almacena y se convierte en letra mayúscula la letra siguiente al espacio en blanco.concat(cadena2) . if (caracter. Danae a lessandra flores bertolotti. nom = cadena1. Al inicio utilizamos parte de la solución del problema 105. ¿Qué sucede? Modificando la solución anterior para poder considerar la problemática anterior tendríamos la siguiente variación: cant = nom.toUpperCase( ) .equals( “ ” ) ) { sw = true .substring(x.toLowerCase( ) . } else { if (sw) { Pag. x++) { if (x==0) { cadena1 = nom. Juan José Flores Cueto. cadena1 = cadena1. El siguiente esquema muestra como se debe almacenar parcialmente el nombre del ejemplo en la variable nom. 358 . cadena2 = cadena2. mientras que el resto de las letras estén en letra minúscula. cadena2 = nom. for (int x=0. Ing. x+1) . } else { caracter = nom. Imagínese que la variable nom contiene el siguiente nombre: nom = “danae alessandra flores bertolotti” . A cadena1 caracter cadena2 Después se concatenan las tres variables y se almacenan en la variable nom. Este valor devuelto se evalúa en la estructura de decisión if. Ahora considere si entre los nombres existe más de un espacio en blanco.substring(0. el método equals ( ) nos devuelve un valor verdadero (true).substring(1) . El proceso se repite hasta llegar al final de la cadena. x<cant. Nosotros desearíamos que la primera letra de cada nombre y de cada apellido de un alumno este en letra mayúscula. Si al comparar el contenido de las dos cadenas resulta que ambas variables son iguales. Después obtenemos caracter por caracter y evaluamos si el caracter obtenido es un espacio en blanco.1) .equals (“ “)) { } El método equals ( ) se utiliza con variables de tipo String y nos permite comparar el contenido de dos cadenas (en nuestro caso la variable caracter con un espacio en blanco).

nom = cadena1 + caracter + cadena2 . caracter = nom.toUpperCase( ). x+1) .substring(x+1) . caracter = caracter.substring(0. Pag.CLASES BÁSICAS INCORPORADAS EN EL LENGUAJE DE PROGRAMACIÓN JAVA cadena1 = nom. sin preocuparnos de la cantidad de espacios en blanco que pueda existir entre dos nombres.x) .substring(x. sw = false . 359 . } } } } En esta parte modificada de la solución se utiliza un centinela (o flag) que nos permite indicar el momento preciso para realizar la conversión de la primera letra del nombre o apellido a letra mayúscula. cadena2 = nom.

println ( “ Ingresar el nombre: ” ) .substring(x.cont=0 .out. Ing.x++) { caracter = nom. Mostrar el número de caracteres blancos o espacios en blanco que existan. Si el caracter es igual a un espacio en blanco (“ “). } } while (nom. se evalúa caracter por caracter (de la variable nom). for (x=0. length ( ). Juan José Flores Cueto.out. } } Observe el uso de los métodos trim ( ). if ( nom.trim( ) . public class PrgLongitudCadenaBlanco { public static void main(String [ ] args) { int x. nom = nom.caracter .out. Pag. se le aumenta uno a la variable cont (que esta trabajando como contador de espacios encontrados en la variable nom).length( ) < 2 ) . String nom.length( ) < 2 ) { System.* .println ( “ Nombre ingresado no válido… Reintente! ” ) . if (caracter. substring ( ) y equals ( ) de la clase String. Clase PrgLongitudCadenaBlanco package dominioDeLaAplicacion . do { System. cant = nom.length( ) . Etapa 04 – Desarrollo de la codificación. 360 . nom = Lectura. import biblioteca.cant. Desarrollar un programa en Java que permita ingresar los apellidos y nombres de un obrero (en una sola variable).println ( “ La cantidad de espacios: ” + cont ) .leerString( ) .equals ( “ ” ) ) { cont ++ . En la codificación de este programa. } } System. Problema 108 Etapa 01 – Descripción del problema.x<cant.x+1) .

En la codificación de este programa. 361 . x++) { caracter = nom. que equivale a la cantidad de caracteres de la variable nom diferentes a espacios en blanco.leerString( ) .equals ( “ ” ) ) { cadena = cadena.out.trim( ) . nom = Lectura.println ( “ Ingresar el nombre: ” ) . Desarrollar un programa en Java que permita ingresar los apellidos y nombres de un obrero (en una sola variable). import biblioteca. Al final se obtiene la longitud de la variable cadena.out.length( ) . } } while (nom. caracter . } } Observe el uso de los métodos trim ( ).* . } } cant = cadena.CLASES BÁSICAS INCORPORADAS EN EL LENGUAJE DE PROGRAMACIÓN JAVA Problema 109 Etapa 01 – Descripción del problema. for (x=0. do { System. x<cant. public class PrgLongitudCadenaNoBlanco { public static void main(String [ ] args) { int cant. nom = nom.x+1) .println ( “ La cantidad de caracteres sin contar espacios: ” + cant ) . if ( !caracter. if ( nom.substring(x. length ( ). Mostrar el número de caracteres del nombre ingresado por teclado que no sean espacios en blanco. se evalúa caracter por caracter (de la variable nom). System.out. Si el caracter no es un espacio en blanco se junta o concatena con los caracteres de la variable cadena (al inicio no contiene ningún caracter).length( ) < 2 ) { System. substring ( ) y equals ( ) de la clase String. Pag. String nom.x.length( ) .length( ) < 2 ) .concat(caracter) . cant = nom. Clase PrgLongitudCadenaNoBlanco package dominioDeLaAplicacion . cadena = “”.println ( “ Nombre ingresado no válido… Reintente! ” ) . Etapa 04 – Desarrollo de la codificación.

Al final se obtiene la longitud total de la cadena nom y realizando una simple resta se obtiene el número de caracteres de la variable nom que no son espacios en blanco. nom = Lectura. do { System.* .println ( “ La cantidad de espacios: ” + cont ) . se emplea la misma estrategia que la utilizada en la solución del problema 108.equals ( “ ” ) ) { cont ++ . Problema 110 Etapa 01 – Descripción del problema. public class PrgLongitudCadenaBlancoNoBlanco { public static void main(String [ ] args) { int x. para obtener el número de espacios en blanco contenidos en la variable nom.cont ) ) .out. } } while (nom.leerString( ) .length( ) < 2 ) .length( ) < 2 ) { System. Pag. Mostrar el número de caracteres que no son espacios en blanco y el número de caracteres que son espacios en blanco.out.println ( “ Nombre ingresado no válido… Reintente! ” ) . Desarrollar una solución que permita ingresar los apellidos y nombres de un obrero (en una sola variable).println ( “ Ingresar el nombre: ” ) . if ( nom.trim( ) .substring(x. cant = nom. String nom. 362 . x<cant. if (caracter. fo r(x=0.out.length( ) . cont = 0 .out. System.x+1) . nom = nom. Ing. } } En la codificación de este programa. import biblioteca. Clase PrgLongitudCadenaBlancoNoBlanco package dominioDeLaAplicacion . cant. Juan José Flores Cueto. caracter . Etapa 04 – Desarrollo de la codificación. x++) { caracter = nom.println ( “ La cantidad de caracteres sin contar espacios: ” + ( cant . } } System.

char c = ‘ ’ . // u } } System.println ( “ El Total de Vocales es: ” + cont ) . Etapa 04 – Desarrollo de la codificación.length( ) == 0 ) { System. Desarrollar una solución que permita ingresar el nombre de un alumno. 363 . if ( nom. Mostrar el número de vocales que hay en el nombre ingresado. nom = nom.trim( ) .* .length( ) == 0 ) . cont = 0.println ( “ Ingresar el nombre: ” ) . d = (int) (c) .CLASES BÁSICAS INCORPORADAS EN EL LENGUAJE DE PROGRAMACIÓN JAVA Problema 111 Etapa 01 – Descripción del problema.toLowerCase( ) .leerString( ) . do { System.length( ) . String nom . cant = nom. } } Pag. public class PrgTotalVocales1 { public static void main(String [ ] args) { int cant. x<cant. Clase PrgTotalVocales1 package dominioDeLaAplicacion .out. import biblioteca.println ( “ Nombre ingresado no válido… Reintente! ” ) . switch (c) { case 97 : // a case 101 : // e case 105 : // i case 111 : // o case 117 : cont ++ .out.out. for (x=0. d = 0. nom = Lectura. x . x++) { c = nom. } } while (nom. nom = nom.charAt(x) .

i. Antes de iniciar la evaluación de cada uno de los caracteres de la variable nom. Juan José Flores Cueto. e. El método charAt ( ) se utiliza con variables de tipo String y nos permite obtener un caracter de una cadena. Ing. Modifique la solución anterior de tal forma que pueda determinar cuantas vocales almacenadas en la variable son a. Pag. 364 . c = nom.charAt (x) . En nuestro caso. obtenemos un caracter de la variable nom y lo almacenamos en una variable de tipo char (el método charAt ( ) devuelve un caracter). se utiliza el método toLowerCase ( ) para asegurarnos de convertir a letras minúsculas todos los caracteres de la variable nom y luego utilizar los códigos ASC equivalentes a las vocales en minúscula. El caracter obtenido es evaluado para determinar si es o no una vocal.charAt (x) . Esta evaluación se realiza a través de los códigos ASC correspondientes a las vocales (es importante mencionar que la evaluación de una variable de tipo char se puede realizar utilizando los códigos ASC equivalentes a los caracteres especiales. o y u (en forma independiente). letras y números). ¿Qué hay de nuevo en la codificación? Observe el uso del método charAt ( ) de la clase String: nom.

out. for (x=0. if ( nom. import biblioteca. cont = 0 .println ( “ Ingresar el nombre: ” ) . System.length( ) == 0 ) .CLASES BÁSICAS INCORPORADAS EN EL LENGUAJE DE PROGRAMACIÓN JAVA Problema 112 Etapa 01 – Descripción del problema.trim( ) . Clase PrgTotalVocalesNoVocales package dominioDeLaAplicacion .length( ) .length( ) == 0 ) { System. nom = nom. } } while (nom. Mostrar el número de vocales y el número de caracteres que no son vocales que hay en el nombre ingresado.out. // u } } System.out. Etapa 04 – Desarrollo de la codificación. x++) { c = nom.toLowerCase( ) .out. char c = ‘ ’ . Desarrollar un programa en Java que permita ingresar el nombre de un alumno. public class PrgTotalVocalesNoVocales { public static void main(String [ ] args) { int cant. switch (c) { case 97 : // a case 101 : // e case 105 : // i case 111 : // o case 117 : cont ++ .println ( “ El Total de caracteres que no son vocales es: ” + (cant – cont) ) .println ( “ El Total de Vocales es: ” + cont ) .println ( “ Nombre ingresado no válido… Reintente! ” ) . nom = nom. x<cant. d = (int) (c) . } } Pag. 365 . cant = nom.* . d = 0 . nom = Lectura. do { System. x .leerString( ) .charAt(x) . String nom .

para poder obtener el total de caracteres que no son vocales. Ing. Modifique la solución anterior de tal forma que pueda determinar cuántas vocales almacenadas en la variable nom son mayúsculas y cuántas son minúsculas. Juan José Flores Cueto. Este programa es similar al programa desarrolado en el problema 111. Recuerde utilizar los equivalentes en código ASC de las consonantes en letra minúscula o en letra mayúscula. Pag. La diferencia es que se obtiene el total de caracteres que tiene la variable y se resta del total de vocales que tiene. 366 . También puede modificar la solución de tal forma que permita determinar cuántas consonantes contiene la variable nom.

println ( “ la subcadena en la cadena es: ” + cont ) . if (cad1.println ( “ El número de veces que se repite ” ) . } } while (cad1.out.length( ) . Contar y mostrar cuantas veces se repite la segunda cadena en la primera cadena ingresada. import biblioteca. Clase PrgCadenaSubcadena package dominioDeLaAplicacion .cad2.CLASES BÁSICAS INCORPORADAS EN EL LENGUAJE DE PROGRAMACIÓN JAVA Problema 113 Etapa 01 – Descripción del problema. i++) { subcad = cad1.leerString( ) . Pag.trim( ) .length( ) == 0 ) .length( ) == 0) { System.* . Reintente! ” ) . cad2 = cad2. Etapa 04 – Desarrollo de la codificación.leerString( ) .println ( “ Cadena ingresada no válido. if (cad2.out. subcad . int total. } } System. i + cad2.substring (i.length( ) .. do { System. if (cad1.out. System. } } while (cad2.. cad1 = Lectura. public class PrgCadenaSubcadena { public static void main(String [ ] args) { String cad1. i.trim( ) .length( ) == 0 ) { System.length( ) == 0 ) . i <= total.out.length( ) ) .. cad2 = Lectura.. Desarrollar un programa en Java que permita ingresar dos cadenas.length( ) > cad2.out.println ( “ Ingresar una subcadena de la primera cadena: ” ) .out. if (cad2. cad2. cont = 0 . do { System. Reintente! ” ) . 367 . for (i = 0. cad1 = cad1.println ( “ Ingresar una cadena: ” ) .equals(subcad) ) { cont ++ .println ( “ Cadena ingresada no válida.length( ) ) { total = cad1.

Luego.equals (subcad)) { cont ++ .length( ) .println ( “ la subcadena en la cadena es: ” + cont ) . } else { if (cad1. y se almacena en la variable total. for (i = 0.out.cad2.length( ) ) .equals (cad2) ) { System. Ing.length( ) ) { total = cad1. se obtiene la diferencia entre las longitudes de cad1 y cad2.println ( “ las cadenas son iguales ” ) . Etapa 04 .out.out.. se verifica que la primera cadena (cad1) tenga una longitud mayor que la segunda cadena (cad2). i <= total. i + cad2.println ( “ mayor que la primera cadena ” ) . } else { System. empezando desde el primer caracter de cad1 se extrae una subcadena (subcad) del mismo tamaño que cad2 y se comparan para ver si son iguales utilizando el método equals ( ). } } System. Después. es el caracter ubicado en la posición total de cad2. } } } } Observe el uso de los métodos trim ( ). Continúa.substring(i. i++) { subcad = cad1. calculamos el valor de la variable total (total = 5-3 = 2). Como ejemplo utilizaremos las siguientes cadenas: cad1 = “Danae” cad2 = “ana” En primer lugar determinamos que cad1 tiene una longitud mayor que cad2. System. System.out.length( ) > cad2. } } En primer lugar.Desarrollo de la codificación.length( ) . System..println ( “ la segunda cadena no debe tener una longitud ” ) .out.println ( “ mayor que la primera cadena ” ) . Pag. Si son iguales el contador cont aumenta en 1. Este proceso se repite utilizando el siguiente caracter de cad1. substring ( ) y equals ( ) de la clase String. if (cad2.println ( “ la segunda cadena no debe tener una longitud ” ) .println ( “ El número de veces que se repite ” ).equals (cad2) ) { System. Juan José Flores Cueto. Clase PrgCadenaSubcadena } else { if (cad1. Luego.println ( “ las cadenas son iguales ” ) . } else { System. El límite para la evaluación del número de veces que se repite cad2 en cad1. length ( ).out. 368 .out. La parte central de la solución radica en las siguientes líneas de código: if (cad1.out.

cad1 = “Danae” 0 12 Observe que cad2 tiene una Límite para la longitud=3 por lo que la última evaluación evaluación será: cad2 = “ana” y subcad= “nae” Primera evaluación: cad2 = “ana” y subcad = “Dan” Resultado: falso. Finalmente. se concluye que cad2 se repite una vez en cad1. Segunda evaluación: cad2 = “ana” y subcad = “ana” Resultado: verdadero (cont =1).CLASES BÁSICAS INCORPORADAS EN EL LENGUAJE DE PROGRAMACIÓN JAVA El límite para la evaluación del número de veces que se repite cad2 en cad1 es el caracter ubicado en la posición 2 de cad2. Primera evaluación: cad2 = “ana” y subcad = “nae” Resultado: falso. Pag. 369 .

do { System. if ( nom1.out. nom2 = nom2.length( ) < 2 ) { System. } } } Observe el uso de los métodos trim ( ). nom1 = Lectura. } else { System. nom1 = nom1.length( ) < 2 ) . Pag. } } while ( nom2. if ( nom2. do { System. length ( ) y equals ( ) de la clase String.trim( ) .println ( “ Ingresar el nombre del primer alumno: ” ) .println ( “ Los nombres ingresados son iguales ” ) . if ( nom1.out.length( ) < 2 ) .println("Nombre ingresado no válido… Reintente! ").out.out. Desarrollar un programa en Java que permita ingresar el nombre de dos alumnos. Mostrar si los nombres ingresados son iguales o no.println ( “ Los nombres ingresados son diferentes ” ) .println ( “ Ingresar el nombre del segundo alumno: ” ) .* . 370 . Se comparan dos variables de tipo cadena (nom1 y nom2 respectivamente) y se determinan si ambas cadenas son iguales o no. Problema 114 Etapa 01 – Descripción del problema.length( ) < 2 ) { System.leerString( ) .trim( ) .out. public class PrgNombresIguales { public static void main(String [ ] args) { String nom1.leerString( ) . Ing.println ( “ Nombre ingresado no válido… Reintente! ” ) . Etapa 04 – Desarrollo de la codificación. nom2 = Lectura. Clase PrgNombresIguales package dominioDeLaAplicacion . nom2 . Juan José Flores Cueto. import biblioteca.out.equals (nom2) ) { System. } } while ( nom1.

compareTo (nombre2) .CLASES BÁSICAS INCORPORADAS EN EL LENGUAJE DE PROGRAMACIÓN JAVA Problema 115 Etapa 01 – Descripción del problema. es decir. Si el valor devuelto es igual a cero (0). import biblioteca. Finalmente.compareTo(nombre2) < 0 ) { nombreMenor = nombre1 . System.out. entonces la variable nombre1 es menor que la variable nombre2.” ) .println (nombreMayor) . System. } else { nombreMenor = nombre2 . Desarrollar un programa en Java que permita ingresar los nombres de dos alumnos. entonces las cadenas son iguales.println ( “ ------------------------------------------------.println ( “ Nombres ordenados alfabéticamente ” ) .” ) . Mostrar los nombres ordenados alfabéticamente. Etapa 04 – Desarrollo de la codificación.leerString( ) .leerString( ) . nombre2 = Lectura. Pag. System. nombre2. System.out. if (nombre1. System.println ( “ ------------------------------------------------. nombreMayor. si el valor devuelto es menor que cero.out.println ( “ Ingrese el nombre de otra persona: ” ) . nombreMayor = nombre2 . 371 . nombreMayor = nombre1 . nombre1 = Lectura. Clase PrgOrdenados1 package dominioDeLaAplicacion . } System.println (nombreMenor) .out.out. System. El método permite compareTo ( ) nos devuelve un valor entero.println ( “ Ingrese el nombre de una persona: ” ) .out. } } ¿Qué hay de nuevo en la codificación? Observe el uso del método compareTo ( ) de la clase String: nombre1.out. public class PrgOrdenados1 { public static void main(String [ ] args) { String nombre1. El método compareTo ( ) permite comparar dos variables de tipo String. nombreMenor. las variables nombre1 y nombre2 contiene cadenas iguales.* . Si el valor devuelto es mayor que cero (0). entonces la variable nombre1 es mayor que la variable nombre2.

nombre1 = “Danae” y nombre2 = “Danae”. nombre1 = “Pedro” y nombre2 = “Luis”. Juan José Flores Cueto. mejore la solución de tal forma que se pueda realizar la consistencia de los nombres ingresados. 2. comparemos las siguientes cadenas: nombre1 > nombre2 1. Cuando se comparan dos cadenas. las letras minúsculas. se realiza una comparación alfabética en la cual tienen significado las letras mayúsculas. Ing. nombre1 < nombre2 En base a esto. nombre1 = nombre2 3. los caracteres especiales y los espacios en blanco. 372 . Por ejemplo. nombre1 = “Carmen” y nombre2 = “Juan”. Pag.

length( ) < 2 ) { System.out. nombre2 = Lectura. if ( nombre1.out.CLASES BÁSICAS INCORPORADAS EN EL LENGUAJE DE PROGRAMACIÓN JAVA Problema 116 Etapa 01 – Descripción del problema.leerString( ) .Reintente!!! ” ) . 373 . nombre2.out. public class PrgOrdenados2 { public static void main(String [ ] args) { String nombre1.length( ) < 2 ) { System. nombreMayor = nombre2 . nombreMayor. } } while (nombre1.. Clase PrgOrdenados2 package dominioDeLaAplicacion .println ( “ Nombre ingresado no válido.Reintente!!! ” ) .trim( ) .trim( ) .println ( “ Ingrese el nombre de la segunda persona: ” ) . nombre1 = Lectura.. Etapa 04 – Desarrollo de la codificación.println ( “ Nombre ingresado no válido.. } } while ( nombre2.* . Desarrollar un programa en Java que permita ingresar los nombres de dos alumnos (no permite el ingreso de solo espacios en blanco). nombreMayor = nombre1 ..println ( “ Ingrese el nombre de la primera persona: ” ) . if (nombre1. do { System. } Pag.length( ) < 2 ) .out. Mostrar los nombres ordenados alfabéticamente. import biblioteca. if ( nombre2.length( ) < 2 ) . nombreMenor . nombre2 = nombre2. nombre1 = nombre1.leerString( ). } else { nombreMenor = nombre2 . do { System.compareTo(nombre2) < 0 ) { nombreMenor = nombre1 .

System. Clase PrgOrdenados2 System. Etapa 04 ..out.” ) .out. System. } } Mejore la codificación del programa.Desarrollo de la codificación.println ( “------------------------------------------------.println (nombreMenor) .out.” ) .println ( “------------------------------------------------. Continúa.println ( “Nombres ordenados alfabéticamente ” ) . Ing. 374 .out. System.out. System. Juan José Flores Cueto. Pag.println (nombreMayor) .. de tal forma que se contemple la posibilidad que los nombres ingresados sean iguales.

length( ) == 0 ) . } } while ( nombre3. } } while (nombre2.println ( “ Nombre ingresado no válido. } } while ( nombre1.length( ) == 0 ) .leerString( ) . Etapa 04 – Desarrollo de la codificación. do { System... if ( nombre3. nombre3 = Lectura.println ( “ Nombre ingresado no válido.Reintente!!! ” ) .println ( “ Ingrese el nombre de la segunda persona: ” ) . nombre2 = Lectura.* . if ( nombre1..println ( “ Ingrese el nombre de la tercera persona: ” ) .trim( ) .out.length( ) == 0 ) { System.out..CLASES BÁSICAS INCORPORADAS EN EL LENGUAJE DE PROGRAMACIÓN JAVA Problema 117 Etapa 01 – Descripción del problema.trim( ) . nombre1 = nombre1. nombre3 . public class PrgOrdenados3 { public static void main(String [ ] args) { String nombre1. Desarrollar un programa en Java que permita ingresar los nombres de tres alumnos (los nombres no deben ser iguales). if ( nombre2.length( ) == 0 ) { System.out.Reintente!!! ” ) .out. nombre3 = nombre3. nombre2. Clase PrgOrdenados3 package dominioDeLaAplicacion ..println ( “ Ingrese el nombre de la primera persona: ” ) . nombre2 = nombre2. nom03 = “” . Mostrar los nombres ordenados alfabéticamente.println ( “ Nombre ingresado no válido.out. String nom01 = “ ”.length( ) == 0 ) { System. nom02 = “”. nombre1 = Lectura. do { System.trim( ) .. import biblioteca. do { System. Pag.Reintente!!! ” ) .out.length( ) == 0 ) .leerString( ) .leerString( ) . 375 .

if (nombre1. System. nom03 = nombre1 . Modifique la codificación de la solución de tal forma que pueda mejorarla. 2.out.” ) . } } if (nombre2.println ( “ ------------------------------------------------. Juan José Flores Cueto. nom03 = nombre2 . nom03 = nombre3 . System.compareTo(nombre2) < 0 && nombre1. if (nombre2. Finalmente ingrese los siguientes datos. ingrese los siguientes datos y compruebe lo que sucede: nombre1 = “Armando”..out. Continúa. System. } } if (nombre3.compareTo(nombre2) < 0 ) { nom02 = nombre1 .out.println ( “ Nombres ordenados alfabéticamente ” ) . } } System.out.compareTo(nombre3) < 0 ) { nom01 = nombre1 .compareTo(nombre3) < 0 ) { nom02 = nombre2 . System. } else { nom02 = nombre2 .compareTo(nombre2) < 0 ) { nom01 = nombre3 . nombre2 = “Beto”.println (nom02) . Ejecute el programa. Luego ingrese los siguientes datos y compruebe nuevamente lo que sucede: nombre1 = “Armando”. } else { nom02 = nombre3 . nom03 = nombre2 .compareTo(nombre3) < 0) { nom01 = nombre2 . Etapa 04 . nombre3 = “Beto”. 376 . Ing. nombre2 = “Armando”.out.. nom03 = nombre1 . } } Desarrolle la siguiente prueba: 1.” ) .compareTo(nombre1) < 0 && nombre2.compareTo(nombre3) < 0 ) { nom02 = nombre1 .println (nom03) . nombre3 = “Beto”. nombre3 = “Armando”. System. nom03 = nombre3 . Compruebe lo que sucede: nombre1 = “Armando”. 3. } else { nom02 = nombre3 .println ( “ ------------------------------------------------.compareTo(nombre1) < 0 && nombre3.Desarrollo de la codificación.println (nom01) . Pag. Clase PrgOrdenados3 if (nombre1. if (nombre1. nombre2 = “Armando”.out.

Mostrar los nombres ordenados alfabéticamente. if ( nombre3.out. if (nombre1. do { System.println ( “ Ingrese el nombre de la primera persona: ” ) . String nom01 = “”. } } while ( nombre1.out.out.leerString( ) .Reintente!!! ” ) . 377 .Reintente!!! ” ) . } } while ( nombre2.length( ) == 0 ) .println ( “ Nombre ingresado no válido. Pag. nom03 = “”..length( ) == 0) { System...leerString( ) .* . if (nombre2.CLASES BÁSICAS INCORPORADAS EN EL LENGUAJE DE PROGRAMACIÓN JAVA Problema 118 Etapa 01 – Descripción del problema. nombre3 .Reintente!!! ” ) .println ( “ Nombre ingresado no válido..trim( ) .leerString( ) . do { System. nombre3 = nombre3. public class PrgOrdenados4 { public static void main(String [ ] args) { String nombre1.println ( “ Ingrese el nombre de la tercera persona: ” ) .trim( ) .. nombre2. nombre2 = nombre2. } } while (nombre3.out.length( ) == 0 ) . import biblioteca. nombre3 = Lectura.length( ) == 0 ) { System.println ( “ Ingrese el nombre de la segunda persona: ” ) .trim( ) . nombre1 = Lectura.println ( “ Nombre ingresado no válido. Clase PrgOrdenados4 package dominioDeLaAplicacion .out.length( ) == 0 ) { System..length( ) == 0 ) . Desarrollar un programa en Java que permita ingresar los nombres de tres alumnos (los nombres pueden ser iguales). do { System. nom02 = “”. Etapa 04 – Desarrollo de la codificación. nombre2 = Lectura.out. nombre1 = nombre1.

compareTo(nombre3) < 0 ) { nom01 = nombre1 . Etapa 04 . nom02 = nombre2 .out. nom03 = nombre3 .compareTo(nombre2) < 0 ) { if ( nombre1.println ( “ ------------------------------------------------. nombre3 = “Armando”. nom03 = nombre1 .compareTo(nombre3) < 0 ) { nom02 = nombre1 . System.out. } } Desarrolle la siguiente prueba: Ingrese los nombres con letras mayúsculas y minúsculas. Ing. nom02 = nombre1 . System.” ) . } } else { nom01 = nombre3 .out. System.out. nombre2 = “Beto”. if (nombre2. Compruebe lo que sucede. Pag.Desarrollo de la codificación. nom03 = nombre3 . Modifique el programa de tal forma que se cambie la primera letra del nombre ingresado a mayúscula.compareTo(nombre3) < 0 ) { nom02 = nombre2 .println (nom02) . Se ordenarán primero los nombres que comiencen con mayúscula y luego los nombres que comiencen con minúscula. System.println (nom01) .out. nom03 = nombre2 .println ( “ ------------------------------------------------.” ) . nom03 = nombre2 .println (nom03) . } } System. 378 ..out. } else { nom02 = nombre3 .. nom03 = nombre1 . } } else { if ( nombre2. } else { nom02 = nombre3 .compareTo(nombre3) < 0 ) { nom01 = nombre2 . por ejemplo: nombre1 = “armando”. Continúa. if ( nombre1. Juan José Flores Cueto.println ( “ Nombres ordenados alfabéticamente ” ) . System. } } else { nom01 = nombre3 . Clase PrgOrdenados4 if ( nombre1.

nombre1 = Lectura.length( ) == 0 ) .* . do { System.substring(1)) . nom02 = “”.println ( “ Ingrese el nombre de la tercera persona: ” ) . nombre2 = Lectura.concat(nombre2.trim( ) .out. Pag.out. nombre3. Asegúrese que los nombres ingresados empiecen con una letra mayúscula.Reintente!!! ” ) . import biblioteca.length( ) == 0 ) . Mostrar los nombres ordenados alfabéticamente.toUpperCase()).println ( “ Nombre ingresado no válido. letra. } } while ( nombre2.println ( “ Ingrese el nombre de la primera persona: ” ) . } } while ( nombre1. Clase PrgOrdenados5 package dominioDeLaAplicacion . nombre2.CLASES BÁSICAS INCORPORADAS EN EL LENGUAJE DE PROGRAMACIÓN JAVA Problema 119 Etapa 01 – Descripción del problema.leerString( ) .Reintente!!! ” ) .substring(0. Desarrollar un programa en Java que permita ingresar los nombres de tres alumnos. } else { nombre1 = ((nombre1.. nombre2 = nombre2. do { System.length( ) == 0 ) { System.println ( “ Nombre ingresado no válido. String nom01 = “”.toUpperCase()). public class PrgOrdenados5 { public static void main(String [ ] args) { String nombre1.length( ) == 0 ) { System. nombre3 = Lectura.. 379 .. nombre3 = nombre3.concat(nombre1. 1)).out.trim( ) .leerString( ) .out.out.println ( “ Ingrese el nombre de la segunda persona: ” ) . if ( nombre1.substring(1)) .trim( ) . } else { nombre2 = ((nombre2. nom03 = “” . Etapa 04 – Desarrollo de la codificación.leerString( ) . 1)). resto .. if ( nombre2.substring(0. do { System. nombre1 = nombre1.

1)).out. if ( nombre2. Continúa. if ( nombre1. Clase PrgOrdenados5 if ( nombre3.println ( “ Nombres ordenados alfabéticamente ” ) . nom03 = nombre2 .Reintente!!! ” ) .println ( “ Nombre ingresado no válido.compareTo(nombre2) < 0 ) { if ( nombre1.out..length( ) == 0 ) .length( ) == 0 ) { System.. } } else { nom01 = nombre3 .Desarrollo de la codificación.compareTo(nombre3) < 0 ) { nom02 = nombre2 .. Etapa 04 . Luego.substring(0.compareTo(nombre3) < 0 ) { nom01 = nombre1 .println (nom02) . Asegúrese que los nombres ingresados empiecen con una letra mayúscula y que el resto de las letras de los nombres estén en minúscula.out. 380 . } else { nom02 = nombre3 .println (nom01) . nom02 = nombre2 . } } else { if ( nombre2. Pag. if ( nombre1. } } System.compareTo(nombre3) < 0 ) { nom01 = nombre2 .println (nom03) . nom03 = nombre2 . System. Muestre los nombres ordenados alfabéticamente. nom03 = nombre3 . Juan José Flores Cueto. nom03 = nombre1 .toUpperCase())..concat(nombre3. } else { nombre3 = ((nombre3.out. nom02 = nombre1 . } } while ( nombre3.out.substring(1)) . System. } else { nom02 = nombre3 . } } else { nom01 = nombre3 . nom03 = nombre3 . nom03 = nombre1 .compareTo(nombre3) < 0 ) { nom02 = nombre1 . System. } } Mejore la solución desarrollando un programa que permita ingresar tres nombres de alumnos. complemente la solución permitiendo el ingreso de los nombres de todos los alumnos de un determinado salón de clase. Ing.

un caracter que este contenido en el nombre ingresado y otro caracter por el cual se reemplazará el primer caracter ingresado.x+1) . } System. public class PrgCadenaModifcada { public static void main(String [ ] args) { int cant .equals(caracter) == true ) cadena = cadena + dato2 . else cadena = cadena + caracter .leerString( ) . import biblioteca. Etapa 04 – Desarrollo de la codificación. 381 .print ( “ Ingrese el caracter por el cual se va reemplazar: ” ) .length( ) .out. Desarrollar un programa en Java que permita ingresar el nombre de una persona. dato1.substring(x. x<cant. } } ¿Qué hay de nuevo en la codificación? Observe el uso del método equals ( ) de la clase String: nombre1. Mostrar el nombre modificado. dato2 = Lectura. dato1 = Lectura. System.print ( “ Ingresar el nombre de una persona: ” ) . dato2.leerString( ) . Pag.out. System. for (x=0. System.print ( “ Ingrese el caracter que se va buscar: ” ) . if ( dato1. Clase PrgCadenaModifcada package dominioDeLaAplicacion .out.println ( “ El resultado es: ” + cadena ) .out.equals (nombre2) . caracter. nom = Lectura.leerString( ) .CLASES BÁSICAS INCORPORADAS EN EL LENGUAJE DE PROGRAMACIÓN JAVA Problema 120 Etapa 01 – Descripción del problema.* . String nom. x++ ) { caracter = nom. cant = nom. cadena= “” .

Pag. Ing. En base a esto. caso contrario devuelve false (falso).equals (caracter) == true ) La sentencia if puede evaluar una condición lógica. x+1) .equals (caracter) ) Resulta evidente que no es necesario realizar comparaciones booleanas dentro de las condiciones lógicas utilizadas en la sentencia if (esto se hace extensivo a las sentencias do. El método equals ( ) devuelve true (verdadero) si la cadena coincide con la cadena colocada como parámetro del método equals ( ). Un punto muy importante es el análisis de la siguiente línea de código: if ( dato1. el método equals ( ) devuelve true (verdadero) o false (falso). En nuestro caso. una variable booleana o el resultado de una operación.equals (caracter) == true ) if ( dato1. dependiendo del resultado de la comparación entre las variables dato1 y caracter. while y for). 382 . podemos afirmar que las siguientes sentencias en Java son equivalentes: if ( dato1. La variable caracter tuvo que declararse como String para poder ser utilizada por el método equals ( ) de esta forma: caracter = nom. Juan José Flores Cueto. Por lo que en este caso el método equals ( ) evalúa a la variable dato1 y a la variable caracter.substring (x .

out. dato2. import biblioteca. if (num < 100) { System. En nuestra solución convertimos la variable num a String con la finalidad de poder manipular el contenido de la variable con métodos de la clase String. luego intercambiar posiciones. el primer digito pasarlo al último y el último digito pasarlo al primero. 383 . cadena = dato3 + dato2 + dato1.* . public class PrgIntercambioCadena { public static void main(String [ ] args) { int num.println(" El resultado es: " + cadena). dato2 = cadena.1). El método valueOf ( ) se utiliza directamente con la clase String (y no con una variable de tipo String).CLASES BÁSICAS INCORPORADAS EN EL LENGUAJE DE PROGRAMACIÓN JAVA Problema 121 Etapa 01 – Descripción del problema. Pag. 1). Una vez convertida la variable num. cant = cadena.valueOf (num) . dato1 = cadena. se utiliza el método substring ( ) para intercambiar las posiciones deseadas.out. Mostrar el nuevo número. dato3 = cadena. System.leerInt(). cant. } } while (num < 100).substring(1.out. num = Lectura.} } ¿Qué hay de nuevo en la codificación? Observe el uso del método valueOf ( ) de la clase String: String. cadena = String. String dato1. cant .print(" Ingresar un numero mayor de 3 dígitos: "). do { System.println(" Número ingresado no válido… Reintente! "). dato3.substring(0. Etapa 04 – Desarrollo de la codificación. cadena = "".length(). Convertir el número en cadena. Desarrollar un programa en Java que permita ingresar un número mayor de tres dígitos.valueOf(num). Clase PrgIntercambioCadena package dominioDeLaAplicacion . Este método permite convertir una variable de cualquier tipo a una variable de tipo String o cadena.substring(cant-1).

concat(caracter) . nom = nom. Etapa 04 – Desarrollo de la codificación. caracter. for (x=cant-1. cadena = cadena.substring(x. } System. 384 . } } ¿Qué hay de nuevo en la codificación? Observe el uso del método concat ( ) de la clase String: En este programa. Clase PrgInvertirCadena package dominioDeLaAplicacion . Mostrar el nombre ingresado. Pag.println ( “ El nombre al revés es: ” + cadena ) . Cada vez que se obtiene un caracter este se agrega a la variable cadena.length( ).out.* .x+1) . } } while ( nom.trim( ) . de tal forma que al finalizar la ejecución de la sentencia for se tiene almacenado en la variable cadena el nombre ingresado con los caracteres finales al inicio y los caracteres iniciales al final. Problema 122 Etapa 01 – Descripción del problema. x>=0. cant = nom. cadena = “” . Ing. Juan José Flores Cueto. declaramos la variable caracter como una cadena (String). do { System.length( ) == 0 ) .) { caracter = nom. public class PrgInvertirCadena { public static void main(String [ ] args) { int cant. nom = Lectura. String nom.out. Cada vez que se ejecuta la sentencia for.println ( “ Ingresar el nombre: ” ) . import biblioteca. se obtiene de la variable nom un caracter empezando desde el último y terminando en el primero.length( ) == 0 ) { System. x . if ( nom. de tal forma que se lea de izquierda a derecha (nombre mostrado al revés).out. Desarrollar un programa en Java que permita ingresar el nombre de un alumno. x-.leerString( ) .println ( “ Nombre ingresado no válido… Reintente! ” ) .

x . para agregarlos a la variable cadena utilizando el signo “+” (concatenación). Observe como se utiliza el método charAt ( ) de la clase String. con la finalidad de obtener caracter por caracter de la variable nom (empezando desde el último y terminando en el primero). x >= 0.charAt (x) . Pag.) { caracter = nom. } Es importante indicar que para esta solución. 385 .. la variable caracter debe declararse como char.CLASES BÁSICAS INCORPORADAS EN EL LENGUAJE DE PROGRAMACIÓN JAVA Otra manera de solucionar este problema es la siguiente: for ( x = cant .1. cadena += caracter .

* . Problema 123 Etapa 01 – Descripción del problema. int i. } if ( letraFin. Juan José Flores Cueto.out. contA = 0 .println ( “ Nombres que terminan con la letra a: ” + contA). for (i = 0. public class PrgCuentaLetras1 { public static void main(String [ ] args) { String nombre.length( ) == 0 ) { System. import biblioteca.length( ) ) . Desarrollar un programa en Java que permita ingresar los nombres de 10 alumnos y permita visualizar la cantidad de nombres que empiezan con la letra “P” y la cantidad de nombres que terminan con la letra “a”.trim( ) .out.leerString( ) .length( ) == 0 ) . 386 . nombre = nombre.equals( “a” ) ) { contA++. System. Ing. nombre = Lectura. Reintente! ” ) . Clase PrgCuentaLetras1 package dominioDeLaAplicacion . Asegúrese que los nombres ingresados empiecen con una letra mayúscula y que el resto de las letras de los nombres estén en minúscula. if ( letraIni.. Pag.substring(0. letraIni = nombre. if ( nombre. i++) { do { System.length( )-1.println ( “ Nombre ingresado no válido. letraIni = “”. letraFin = “” . } } while (nombre. Etapa 04 – Desarrollo de la codificación. letraFin = nombre. contP= 0.nombre.1) . Utilice la estructura do… while.equals( “P” ) ) { contP++.substring ( nombre. i <11.out.println ( “ Nombres que comienzas con la letra P: ” + contP). } } Mejore la solución desarrollando un programa que permita ingresar los nombres de todos los alumnos..out. } } System.println ( “ Ingresar el nombre del alumno: ” ) .

CLASES BÁSICAS INCORPORADAS EN EL LENGUAJE DE PROGRAMACIÓN JAVA Problema 124 Etapa 01 – Descripción del problema. cant = nom. Clase PrgTotalVocales2 package dominioDeLaAplicacion . System.leerString( ) . } } while ( nom. Desarrollar un programa en Java que permita ingresar los nombres de todos los empleados de una empresa. for ( x=0.trim( ) .leerInt( ) . } while ( opc != 1 ) .toLowerCase( ) . char c = ‘ ’ . d = (int) (c) . opc =Lectura. d=0.println ( “ Ingresar el nombre: ” ) . Etapa 04 – Desarrollo de la codificación.charAt(x) .println ( “ Desea ingresar otro nombre (Sí = 1. nom = nom. 387 . String nom . public class PrgTotalVocales2 { public static void main(String [ ] args) { int cant. nom = nom.println ( “ El Total de Vocales del nombre ingresado es: ” + cont ) . // u } } System.out.out.length( ) == 0 ) .* . x . Mostrar el número de vocales que existen en cada uno de los nombres ingresados. cont=0. if ( nom.length( ) . do { do { System.length( ) == 0 ) { System. x++ ) { c = nom. import biblioteca. opc. } } Pag.println ( “ Nombre no válido… Reintente! ” ) .out. switch(c) { case 97 : // a case 101 : // e case 105 : // i case 111 : // o case 117 : cont ++ . No = 2): ” ) .out. nom = Lectura. x<cant.

Como sugerencia investigue los códigos ASCII de las vocales acentuadas y las vocales en letra mayúscula. 388 . Pag. Mejore la solución desarrollando un programa que considere el conteo de las vocales acentuadas y las vocales en letra mayúscula. y agréguelos en la sentencia switch ( ). Juan José Flores Cueto. Ing.

x) .Lectura . } } Pag.CLASES BÁSICAS INCORPORADAS EN EL LENGUAJE DE PROGRAMACIÓN JAVA Problema 125 Etapa 01 .leerString( ) . Etapa 04 . 389 .length(). Desarrollar un programa en Java que permita ingresar los nombres de todos los productos de una determinada tienda. acum = “” .println ( “ Cantidad no válida… Reintente! ” ) .out.out. } while ( cantidad != cont ) . x++ ) { if ( x % 2 == 0 ) { acum = acum + producto. String producto.Desarrollo de la Codificación. producto = Lectura. cont = 0 .out. class PrgProductosTienda { public static void main ( String arg [ ] ) { int x. } } while ( cantidad < 1 ) . import biblioteca.Descripción del problema.leerInt( ) . cantidad = Lectura.println ( “ Ingresar la cantidad de productos: ” ) . cont ++ .1.substring(x .println ( “ Las posiciones pares del producto son: ” + acum ) . acum = “” . for ( x = 1.out. do { System. if ( cantidad < 1 ) { System.println ( “ Ingresar el nombre del producto: ” ) . x <= producto. Clase PrgProductosTienda package dominioDeLaAplicacion . cantidad. } } System. Mostrar como resultado las posiciones pares. do { System.

Juan José Flores Cueto. Ing. Pag. se valida el número de alumnos ingresado. de tal forma que sea mayor a cero. Esto último se logra utilizando una sentencia for dentro de la sentencia do. Observe el uso de los métodos length ( ) y substring ( ) de la clase String. Luego. y la forma como se utilizan las estructuras lógicas para la solución del problema. Análisis de la solución Ingresamos la cantidad de alumnos y la almacenamos en la variable cantidad. 390 . se utiliza una sentencia do para ingresar el nombre de cada uno de los productos y determinar sus posiciones pares.

println ( nomMayor + “ tiene de longitud ” + longMayor ) .length( ) ) { longMayor = alumno.println ( nomMenor + “ tiene de longitud ” + longMenor ) .leerString( ) . } } Pag. String alumno. longMenor = 100 .out.Descripción del problema. } cont ++ .println ( “ La Longitud es: ” + alumno. 391 .leerInt( ) .Desarrollo de la Codificación. longMayor = 0. nomMenor = alumno . System. import biblioteca. Clase PrgLongitudNombre package dominioDeLaAplicacion . Desarrollar un programa en Java que permita ingresar los nombres de todos los alumnos de un salón de clase. el nombre que tiene la mayor longitud y el nombre que tiene la menor longitud. nomMayor = alumno . } if ( longMenor > alumno. nomMayor = “”.Lectura .out. do { System. Mostrar la longitud de cada nombre ingresado. System.CLASES BÁSICAS INCORPORADAS EN EL LENGUAJE DE PROGRAMACIÓN JAVA Problema 126 Etapa 01 . } } while ( cantidad < 1 ) .length( ) .println ( “ Ingresar el nombre del alumno: ” ) .println ( “ Cantidad no válida… Reintente! ” ) . class PrgLongitudNombre { public static void main ( String arg [ ] ) { int cantidad.length( ) ) { longMenor = alumno. if ( cantidad < 1 ) { System. } while ( cantidad != cont ) .out. do { System. nomMenor = “” .out.out.length( ) ) . if ( longMayor < alumno. alumno = Lectura.length( ) . cont = 0.out. System. Etapa 04 .println ( “ Ingresar la cantidad de alumnos: ” ) . cantidad = Lectura.

Ing. Análisis de la solución Ingresamos la cantidad de alumnos y la almacenamos en la variable cantidad. Luego. y la forma como se utilizan las estructuras lógicas para la solución del problema. Observe el uso de los métodos length ( ) de la clase String. y se determina la longitud de cada nombre ingresado. se utiliza una sentencia do para ingresar el nombre de cada uno de los alumnos. 392 . Juan José Flores Cueto. el nombre con la mayor longitud y el nombre con la menor longitud. Pag. se valida el número de alumnos ingresado. de tal forma que sea mayor a cero.

println ( “ La fecha ingresada es correcta ” ) . Clase PrgFechaFormato package dominioDeLaAplicacion . num1 = Integer. num2 = 0 . num2 = Integer.CLASES BÁSICAS INCORPORADAS EN EL LENGUAJE DE PROGRAMACIÓN JAVA Problema 127 Etapa 01 .parseInt(mes) . int num1 = 0.out. class PrgFechaFormato { public static void main ( String arg [ ] ) { String fecha.length( ) != 4 ) { System. } else { if ( anio.length() != 2 ) || ( num1 < 31 ) ) { System.leerString( ) .Lectura . import biblioteca. if ( fecha. 5) .println ( “ Ingresar la fecha actual: ” ) .Descripción del problema.out.Desarrollo de la Codificación.substring(6.out.out. if ( ( dia. } else { System. System. mes = fecha. 393 . mes. fecha = Lectura.out.length( ) <= 10 ) { dia = fecha.println ( “ El mes ingresado es incorrecto ” ) . Pag. } else { if ( (mes.length() != 2 ) || ( num2 < 12 ) ) { System.substring(3. Etapa 04 .parseInt(dia) . Desarrollar un programa en Java que permita ingresar una fecha con el siguiente formato “dd-mm-aaaa” y validarla. System. anio = fecha. anio . Incluya la posibilidad que el mes de febrero sea bisiesto.println ( “ Formato de la fecha es : dd-mm-aaaa ” ) . 10) . 2) . } } } } } } Intente mejorar la solución validando la fecha. de tal forma que el mes ingresado sólo sea válido si es que la variable dia contiene el número de días válidos para dicho mes.out.println ( “ El año ingresado esta incorrecto ” ) . dia.substring(0.println ( “ El dia ingresado es incorrecto ” ) .

394 . Problema 128 Etapa 01 .out. Ejemplo: Se ingresa: Longitud = 10 Cadena = “Danae” Resultado: Cadena = “Danae*****” Etapa 04 .Descripción del problema. for ( x = 1.length( ) ) { tamaño = longitud . Juan José Flores Cueto.Desarrollo de la Codificación.out. } } Pag. } } System. x <= tamaño. System.leerInt( ) . import biblioteca. longitud = Lectura.out. if ( longitud > cadena. class PrgCompletarCadenaIzq { public static void main ( String arg [ ] ) { String cadena . Clase PrgCompletarCadenaIzq package dominioDeLaAplicacion . int longitud. x .println ( “ La longitud especificada es: ” ) . System.length( ) .println ( “ La nueva cadena es: ” + cadena ) . tamaño. Ing. Desarrollar un programa en Java que permita completar por la izquierda (utilizando asteriscos) una determinada cadena en base a una longitud especificada.leerString( ) . x++) { cadena = cadena + “*” .println ( “ Ingresar cadena: ” ) .cadena.Lectura . cadena = Lectura.

import biblioteca.println ( “ Ingresar cadena: ” ) . Desarrollar un programa en Java que permita completar por la derecha (utilizando asteriscos) una determinada cadena en base a una longitud especificada.length( ) .Descripción del problema. class PrgCompletarCadenaDer { public static void main ( String arg [ ] ) { String cadena .out. System.CLASES BÁSICAS INCORPORADAS EN EL LENGUAJE DE PROGRAMACIÓN JAVA Problema 129 Etapa 01 . Clase PrgCompletarCadenaDer package dominioDeLaAplicacion .out.leerString( ) . 395 . Ejemplo: Se ingresa: Longitud = 10 Cadena = “Danae” Resultado: Cadena = “*****Danae” Etapa 04 . longitud = Lectura.cadena. x++ ) { cadena = “*” + cadena . } } System. x . System.length( ) ) { tamaño = longitud . x <= tamaño. int longitud.println ( “ La nueva cadena es: ” + cadena ) .out.Desarrollo de la Codificación. for ( x = 1.Lectura . cadena = Lectura. if ( longitud > cadena. tamaño.leerInt( ) .println ( “ La longitud especificada es: ” ) . } } Pag.

Desarrollar un programa en Java que permita transformar un arreglo de caracteres en una cadena. Este método permite convertir un arreglo de caracteres o parte de él. ‘e’ } . Pag. Etapa 04 .out. ‘a’. En segundo lugar.Lectura . especificando la posición del arreglo donde va ha comenzar la cadena y su longitud. Clase PrgArregloCadena package dominioDeLaAplicacion . int ) . en una variable de tipo String o cadena. El método valueOf ( ) se utiliza directamente con la clase String (y no con una variable de tipo String).Desarrollo de la Codificación. ‘n’.valueOf ( char [ ].valueOf (arregloA. import biblioteca. se indica la longitud o el número de caracteres que se van a obtener del arreglo. Observe que en este método. Juan José Flores Cueto.Descripción del problema. System. Ing. En nuestra solución convertimos parte del arreglo arregloA a un String con la finalidad de mostrar el contenido de dicha variable. Los arreglos serán tratados en el siguiente capítulo. en primer lugar. int. se especifica el arreglo de tipo char del cual se va ha obtener la cadena. 396 . Problema 130 Etapa 01 . class PrgArregloCadena { public static void main ( String arg [ ] ) { char arregloA = { ‘D’. } } ¿Qué hay de nuevo en la codificación? Observe el uso del método valueOf ( ) de la clase String: String. se indica la posición del arreglo desde el cual se van a tomar los datos y finalmente. 3) . 1. En el ejemplo. String cadena = String.println ( “ La cadena es: ” + cadena ) . Analizar la solución. ‘a’. se muestra como resultado la cadena “ana”.

Problema 131 Etapa 01 . Como ejemplo. num = Lectura. Analizar la solución. el lenguaje de programación Java incorpora una gran cantidad de clases en paquetes organizados en su Jerarquía de Clases. DecimalFormat numFormato . encontrará más información sobre otras clases de la Jerarquía de Clases de Java. Clase PrgFormatoNumero package dominioDeLaAplicacion . adjunto al presente texto.println ( “El número con formato es : ” + df. System. numFormato = new DecimalFormat ( “###. Etapa 04 . se puede mencionar la clase DecimalFormat del paquete java. Luego con el método format ( ) se procede a establecer el formato establecido para el número ingresado. Mostrar el número ingresado con un formato determinado.Lectura . Es fundamental que se continúe investigando el uso de otras clases incorporadas en esta jerarquía de clases con la finalidad de mejorar la calidad de las soluciones que se desarrollen. class PrgFormatoNumero { public static void main ( String arg [ ] ) { double num .text. Luego este objeto es creado utilizando el operador new. Pag. estableciendo el formato a utilizar en el método constructor. import biblioteca.leerDouble().println ( “Ingrese numero entero: ” ) . Desarrollar un programa en Java que permita ingresar un número por teclado.text. import java. En el CD.format ( num ) ) .Desarrollo de la Codificación.000" ) . System. 397 .out. } } Observe que se declara un objeto de la clase DecimalFormat llamado numFormato.Descripción del problema.CLASES BÁSICAS INCORPORADAS EN EL LENGUAJE DE PROGRAMACIÓN JAVA OTRAS CLASES EN JAVA En general.out.* .

Juan José Flores Cueto. Ing. Pag. 398 .

• Manejo básico de datos. • Declaración. • Generalidades. creación e inicialización. Desarrollo de soluciones utilizando múltiples arreglos: • Arreglos en paralelo. Desarrollo de soluciones utilizando arreglos: • Formalización del método de las 6’D. • Problemas resueltos. Capítulo 4 Estructura de Datos Arreglos Temas: Introducción. • Ingreso y visualización de datos. • Problemas resueltos. Estructura de Datos: Arreglos. .

.

Los arreglos permiten almacenar varios valores a la vez y constituyen las estructuras de datos más sencillas después de la variable. CAPÍTULO IV ESTRUCTURA DE DATOS – ARREGLOS INTRODUCCIÓN Un algoritmo constituye una lista completa de pasos secuenciales y una descripción de datos necesarios para resolver un determinado problema. Dichos datos deben almacenarse en una estructura de datos. MARCO DE TRABAJO ENUNCIADO DEL PROBLEMA Etapa 02 Definición Solución Etapa 03 Diseño Solución Etapa 04 Desarrollo Solución Pag. 401 .ESTRUCTURAS DE DATOS – Arreglos.

• Instrucciones de bifucación. Pag. ALMACENADOS EN: • Estructuras de datos tipo variables. LISTA DE PASOS SENTENCIAS DESCRIPCIÓN DECLARACIÓN Y DE DATOS DEFINICIÓN DE DATOS SE DESARROLLAN UTILIZANDO: • Estructuras lógicas de secuencia. 402 . • Estructuras de datos tipo arreglo. trata sobre las estructuras de datos conocidas como arreglos y los conceptos más importantes relacionados a éstos. Juan José Flores Cueto. • Estructuras lógicas de decisión. Al desarrollar soluciones básicas. Las estructuras lógicas y las estructuras de datos que se utilicen en una solución. van a depender en general de la complejidad del problema. Ing. como se utilizan en las herramientas para diseñar algoritmos y como se emplean en un lenguaje de programación para codificar programas de computadora. El presente capítulo. TAMBIÉN: • Clases incorporadas en el lenguaje de programación utilizado. se utilizan las estructuras lógicas y las estructuras de datos en forma simultánea. • Estructuras lógicas de repetición.

modificado o eliminado. Es. Pag. Tipos: Existen dos tipos de arreglos: Arreglos Unidimensionales (registro o vector) Estructuras de datos que permiten almacenar un conjunto de datos de un mismo tipo (técnicamente dichos valores se almacenan en celdas de memoria que están consecutivas). en el cual el orden de cada uno de los datos es significativo. son estructuras de datos que permiten almacenar más de un dato del mismo tipo a la vez. un arreglo contiene un conjunto de datos. ESTRUCTURA DE DATOS ARREGLOS Definición: Los arreglos conocidos también como arrays. todos del mismo tipo. Cada dato perteneciente al arreglo se almacena en una posición y puede ser mostrado. Es decir. Un arreglo puede almacenar un conjunto limitado de datos.ESTRUCTURAS DE DATOS – Arreglos. todos del mismo tipo. El acceso a uno de los datos del arrreglo unidimensional se realiza mediante un índice. 403 . Aquellas que tienen una dimensión (llamadas arreglos unidimensionales) se les conoce como registro o vector y aquellos que tienen dos dimensiones (llamados arreglos bidimensionales) se les denomina tabla o matriz. Los arreglos o arrays pueden tener de una a varias dimensiones. por consiguiente una estructura de datos que permite almacenar un conjunto de datos. Arreglos bidimensionales (tabla o matriz) El arreglo bidimensional se considera como un vector de vectores. y en el que se necesita especificar dos índices para poder acceder a cada uno de ellos. Se dice que un arreglo es una colección de datos relacionados a los que se hace referencia por medio de un nombre en común (el nombre del arreglo).

Esto nos permite reducir el uso de variables y constantes. se necesitará uno o dos índices para acceder a los datos almacenados en el arreglo. pero no se puede tener un arreglo que contenga por ejemplo: cadenas y números enteros a la vez. • Se utiliza un único nombre (nombre del arreglo) para referirse al conjunto de datos almacenados en el arreglo. Pag. Se puede tener un arreglo de números enteros. que pertenece al paquete java. • Dependiendo del tipo de arreglo. • Los arreglos permiten almacenar datos de entrada y datos utilizados durante el procesamiento. denominada Vector. por lo que pueden ser considerados como globales o locales. o un arreglo de cadenas. Ventajas: • Los datos están almacenados en una sola estructura de datos siendo más fácil el acceso a los mismos. los arreglos tienen un tiempo de vida. • Antes de crear un arreglo es necesario conocer el número exacto de datos que se necesitan almacenar (esto no es tan cierto ya que existe una clase en Java. Desventajas: • Un arreglo no puede almacenar datos de diferente tipo.util. 404 . • Al igual que otras estructuras de datos (como las variables y constantes). Ing. que tiene métodos que permiten crear un vector y redefinir su tamaño cada vez que sea necesario). unidimensional o bidimensional. Juan José Flores Cueto.

.2 … X 0.0 X i-1. A continuación se muestra la representación gráfica de un arreglo bidimensional llamado nombre: Como matriz: X 0.0 X 0.. X 1.0 X 2. X i -1 ] i Como registro: nombre X0 X1 X2 .j -1 X 1.1 X 0. X0. .0 nombre = .. Arreglos Bidimensionales Un arreglo bidimensional puede ser representado como una matriz o como una tabla.ESTRUCTURAS DE DATOS – Arreglos. X 2.. X I-1 i 0 1 2 . i = Tamaño del vector... j) Como tabla: Pag..j -1 (i. 405 ... X 3.X i -1 = Datos almacenados en el vector. A continuación se muestra la representación gráfica de un arreglo unidimensional llamado nombre: Como vector: nombre = [ X 0. i -1 Donde: nombre = Nombre del vector. . Representación gráfica Arreglos Unidimensionales: Un arreglo unidimensional puede ser representado como un vector o como un registro.. X i-1.

i = Número de alumnos..j -1 (i. Para poder acceder a los datos almacenados en un arreglo unidimensional se necesita un índice que indique a cual de todos los datos del arreglo se desea acceder.. si se desea representar el almacenamiento de las notas finales de 10 alumnos de un salón de clase en un arreglo unidimensional (representado como un vector). 10. para poder acceder a la nota final del alumno 2 se utilizaría el nombre del vector (notas). nombre Columnas 0 1 2 j-1 0 X 0.09 = Son las notas finales de cada uno de los alumnos. En el presente texto... 15.j -1 1 X 1.0 X 0.0 i-1 X i-1. Por ejemplo. para referirnos a los arreglos unidimensionales se utilizará la representación del arreglo como registro y para referirnos a los arreglos bidimensionales se utilizará la representación del arreglo como tabla.1 X 0...0 X i-1.Xi-1. Así. Juan José Flores Cueto.0 Filas 2 X 2. en el vector anterior. j -1 = Datos almacenados en la matriz. se realizaría de la siguiente manera: notas 10 15 20 19 14 13 16 11 17 09 i =10 0 1 2 3 4 5 6 7 8 9 Donde: notas = Nombre del arreglo. seguido de un índice igual a 1 entre corchetes ([1]).2 … X 0. X0. 406 . j) Donde: nombre = Nombre de la matriz. i*j = Tamaño de la matriz. Ing. según se muestre a continuación: Pag.0.

10. 407 . 12.09 = Son las notas de Examen Parcial de c/u de los alumnos del salón de clase.…. entre corchetes ( [2] [1] ).11.14. j = Número de alumnos. según se muestra a continuación: Pag. para poder acceder a la nota del examen final (Nota EF) del alumno 2 se utilizaría el nombre de la tabla (notas). i = Número de notas. j=10) Donde: notas = Nombre del arreglo.11.11 = Son las notas de Examen Final de c/u de los alumnos del salón de clase. del trabajo y del examen final de 10 alumnos de un salón de clase en un arreglo bidimensional (representado como una tabla).…. notas[1] notas 10 15 20 19 14 13 16 11 17 09 i =10 0 1 2 3 4 5 6 7 8 9 También. por ejemplo. si se desea representar el almacenamiento de las notas del examen parcial. seguido de dos índices iguales a 2 y 1. 03. en la tabla anterior.ESTRUCTURAS DE DATOS – Arreglos.…. Así. se realizaría de la siguiente manera: notas Alumno 1 Alumno 2 … … … … … … … Alumno10 0 1 2 3 4 5 6 7 8 9 Nota EP 0 10 11 02 05 18 16 17 11 17 09 Nota Tra 1 12 14 12 11 16 17 12 18 10 08 Nota EF 2 03 11 15 05 12 17 02 11 09 11 (i =3. Para poder acceder a los datos almacenados en un arreglo bidimensional se necesitan dos índices que indiquen a cual de todos los datos del arreglo se desea acceder.08 = Son las notas de Trabajo de c/u de los alumnos del salón de clase.

Para declarar un arreglo unidimensional se utiliza solo un corchete de apertura y cierre “[ ]” al final del nombre del arreglo. definir un nombre para referirnos al arreglo. se debe determinar que tipo de dato podrá almacenar un arreglo. En general. En segundo lugar. Donde TipoDeDato debe ser un tipo de arreglo o tipo de dato válido y arreglo es el nombre del arreglo (puede existir más de un arreglo. mientras que para declarar un arreglo bidimensional se utilizan dos corchetes de apertura y cierre “[ ][ ]” al final del nombre del arreglo. Un arreglo solo puede almacenar datos del mismo tipo. para declarar un arreglo se utiliza el siguiente formato: En pseudocódigo y diagrama de flujo: TipoDeDato arreglo[ ] TipoDeDato arreglo[ ][ ] En Java: TipoDeDato arreglo[ ] . notas Alumno 1 Alumno 2 … … … … … … … Alumno10 0 1 2 3 4 5 6 7 8 9 Nota EP 0 10 11 02 05 18 16 17 11 17 09 Nota Tra 1 12 14 12 11 16 17 12 18 10 08 Nota EF 2 03 11 15 05 12 17 02 11 09 11 (i =3. TipoDeDato arreglo[ ][ ] . Para definir un nombre de un arreglo se siguen las mismas reglas utilizadas para la definición de nombres de variables y constantes. en primer lugar. Los tipos de datos válidos para declarar un arreglo son los mismos tipos de datos válidos definidos para declarar variables y constantes. Pag. Juan José Flores Cueto. j=10) Notas[2][1] Declaración de Arreglos Para declarar un arreglo es necesario. los cuales serán separados por comas). Ing. 408 .

cual va ser la cantidad total de datos que se podrá almacenar en el arreglo. Para crear un arreglo se utiliza el siguiente formato: En pseudocódigo y diagrama de flujo: CREAR arreglo[tamaño] Pag. Se declara un arreglo unidimensional llamado nombres en el String nombres[ ] . Antes de crear un arreglo se debe determinar cual va ser el tamaño del mismo. cual se podrá almacenar datos de tipo NUMERO. parte entera y parte decimal (double). según se muestra a continuación: En pseudocódigo y diagrama de flujo: TipoDeDato[ ] arreglo TipoDeDato[ ][ ] arreglo En Java: TipoDeDato[ ] arreglo . El tamaño de un arreglo puede especificarse en forma directa utilizando un número entero o en forma indirecta utilizando una variable entera. Se declara un arreglo bidimensional llamado notas. cual se podrá almacenar datos de tipo TEXTO (String). También se puede declarar un arreglo colocando los corchetes de apertura y cierre después del tipo de dato y no después del nombre del arreglo. se podrá almacenar datos de tipo NUMERO. en el cual double notas[ ][ ] . Es decir. es necesario que el arreglo previamente haya sido declarado. tal y como se explicó anteriormente.ESTRUCTURAS DE DATOS – Arreglos. Creación de Arreglos Para crear un arreglo. Como ejemplo de declaración de arreglos válidos en Java podemos utilizar: EJEMPLOS DESCRIPCIÓN Se declara un arreglo unidimensional llamado edades en el int edades[ ] . solo parte entera (int). En ambos casos. TipoDeDato[ ][ ] arreglo . 409 . el tamaño del arreglo siempre deberá especificarse como un número entero.

utilizando el siguiente formato: En Java: TipoDeDato arreglo[ ] = new TipoDeDato [tamaño]. existe también una forma directa para declarar y crear arreglos. Las consideraciones tratadas en los temas “Declaración de arreglo” y “Creación de arreglos” son válidas al utilizar este formato. arreglo = new TipoDeDato [filas][columnas] . Juan José Flores Cueto. Donde TipoDeDato debe ser un tipo de arreglo o tipo de dato válido y arreglo es el nombre del arreglo. TipoDeDato arreglo[ ][ ] = new TipoDeDato [filas][columnas]. mientras que para crear un arreglo bidimensional es necesario especificar dos índices. El operador new nos permite crear un arreglo. se debe indicar el tamaño del arreglo. uno para referirnos al número total de filas y el otro para referirnos al número total de columnas que va a tener el arreglo. Ing. CREAR arreglo[filas ][columnas] En Java: arreglo = new TipoDeDato [tamaño] . Donde TipoDeDato debe ser un tipo de arreglo o tipo de dato válido y arreglo es el nombre del arreglo. Es importante mencionar que el tipo de dato utilizado para crear un arreglo deberá ser el mismo tipo de dato con el cual se declaró el arreglo. Pag. es decir cuantos datos podrá almacenar. En Java. 410 . Para crear un arreglo unidimensional es necesario especificar solo un índice. Cuando se crea un arreglo con el operador new. Utilizando este formato se declara y crea el arreglo en forma directa (esto es conocido como “Definición de un arreglo”).

nombres = new String[total] . Se crea un arreglo bidimensional numAlu = 10 . Pag.ESTRUCTURAS DE DATOS – Arreglos.leerInt( ) . previamente declarado. System.out. en el cual se podrá almacenar 10 datos de tipo NUMERO (int). previamente int total = 10 . previamente edades = new int [10] . llamado notas. declarado. Se crea un arreglo unidimensional llamado nombres. int numAlu. Se podría modificar esta parte para que el valor se ingrese a través del teclado. ya que puede ocasionar resultados no deseados. En el ejemplo. almacenar 10 datos de tipo TEXTO (String). tal y como se muestra a continuación: EJEMPLOS int total . Ejemplo de creación de arreglos válidos en Java (se asume que los arreglos han sido declarados previamente): EJEMPLO DESCRIPCION Se crea un arreglo unidimensional llamado edades. Esto quiere decir que se puede desbordar el final de un arreglo (se lanza una excepción de tipo ArrayIndexOutOfBoundException). Es necesario recordar y tener presente que es responsabilidad directa del programador asegurarse que nunca suceda esto. numNot . 411 . y que se finalice la ejecución del programa”. declarado. de tipo NUMERO (double). en el cual se podrá nombres = new String [total] . Una consideración importante antes de utilizar un arreglo en Java: “En Java. En el segundo ejemplo se utiliza una variable llamada total de tipo entero para crear el arreglo unidimensional llamado nombres. en el cual se podrá almacenar 30 datos notas = new double [numNot][numAlu] . total = Lectura. no se realiza ninguna clase de comprobación del tamaño de los arreglos en forma automática. numNot = 3 . se asigna directamente el valor 10 a la variable total.print ( “Ingrese el numero total de alumno: ” ).

numNot . int numAlu. Es necesario que se ingresen datos a todas las posiciones del arreglo. los arreglos de caracteres con ‘###BOT_TEXT###’ y los arreglos de objetos con null. numNot = 3 . los arreglos numéricos (tipo NUMERO) se inicializan con cero (0). inicializar todas las posiciones del mismo. parte entera y parte decimal (double en Java). double notas[ ][ ] = new double [numNota[numAlu] . Inicialización de Arreglos Cuando se crea un arreglo utilizando el operador new es recomendable. Recuerde que tratar de acceder a una Pag. En el tercer ejemplo se crea un arreglo bidimensional llamado notas previamente declarado. Dichos datos estarán organizados en 3 filas y 10 columnas. int total = 10 . Inicializar todas las posiciones de un arreglo significa asignar un valor a cada posición con la finalidad de evitar que se produzca un error si se intenta acceder a una posición del arreglo que todavía no contiene un dato. los arreglos lógicos (tipo LOGICO) o booleanos se inicializan con false. Juan José Flores Cueto. Generalmente. Si no se ingresan datos a todas las posiciones del arreglo deberá asegurarse de inicializar el arreglo o en su defecto de mantener un adecuado control de las posiciones que tienen datos almacenados y aquellas que no. inicialice o no el arreglo. en forma directa. 412 . aunque no necesario. en el cual se podrá almacenar 30 datos de tipo NUMERO. numAlu =10 . tal y como se muestra a continuación. Ing. Ingreso de datos a un Arreglo Después de crear un arreglo. EJEMPLOS int edades [ ] = new int [10] . se deberán ingresar datos. String nombres [ ] = new String [total] . También se podría haber declarado y creado los arreglos del ejemplo anterior.

separadas por comas. No se ha utilizado el operador new (para crear el arreglo) y tampoco se ha especificado el tamaño con el cual se ha creado el arreglo. ‘C’. se declara y crea un arreglo unidimensional llamado edades de tipo NUMERO (solo números enteros) con 10 valores. para esto se encierran los datos que se almacenarán en el arreglo dentro de llaves. 413 . se utilizaría la siguiente sentencia: EJEMPLO char letras[ ] = { ‘A’.42. También se puede utilizar una forma directa que permite declarar. ‘B’. tal y como se muestra a continuación.59 } . En el ejemplo anterior. Para declarar y crear un arreglo unidimensional llamado letras de tipo TEXTO (de solo una letra) con 4 valores. posición del arreglo que no tiene un dato o que no ha sido inicializado.28. Para ingresar datos a todas las posiciones de un arreglo generalmente se utiliza la estructura lógica de repetición DESDE (for en Java). produce un error que ocasiona que se interrumpa la ejecución del programa. EJEMPLO int edades[ ] = { 10.15.ESTRUCTURAS DE DATOS – Arreglos.32.35. Pag.51. Cada uno de los valores entre las llaves deben ser del mismo tipo de dato y debe coincidir también con el tipo de dato con el que se declara el arreglo unidimensional.23. crear e ingresar datos a un arreglo unidimensional. ‘D’ } .20.

Se pueden dividir en: • Proceso de visualización de datos. Pag. La ordenación puede ser en forma alfabética o numérica de mayor a menor o viceversa. Juan José Flores Cueto. • Proceso de cálculo basado en datos del arreglo. Ing. utilizando para ello un proceso de búsqueda de datos. el manejo de arreglos se puede agrupar en dos grandes grupos: 1). Proceso de Modificación de Datos: Permite modificar uno o más datos de un arreglo. utilizando para ello un proceso de búsqueda de datos y previniendo al usuario que si se elimina el dato no podrá ser recuperado posteriormente. En términos generales. Manejo de datos de un Arreglo Una vez que se han ingresado los datos a todas las posiciones del arreglo. Se pueden dividir en: • Proceso de modificación de datos. • Proceso de búsqueda datos. 2). 414 . Es importante tener en cuenta que antes de modificar un dato se debe verificar que este existe dentro del arreglo. Procesos que permiten cambiar o modificar el contenido del arreglo. que se ingresaron a través de un proceso de ingreso de datos. Proceso de Eliminación de Datos: Permite eliminar uno o más datos de un arreglo que se ingresaron a través de un proceso de ingreso de datos. Dicho criterio establece la forma de ordenar los datos de un arreglo. • Proceso de ordenación de datos. Es importante tener en cuenta que antes de eliminar un dato se debe verificar que este existe dentro del arreglo. se pueden manipular dichos datos con la finalidad de cumplir con el objetivo del programa o proyecto de solución de un determinado problema. Proceso que permite visualizar o consultar el contenido del arreglo. Proceso de Ordenación de Datos: Permite ordenar todos los datos de un arreglo en función de un criterio. • Proceso de eliminación de datos.

se considera que la búsqueda fue exitosa. indicará la posición del arreglo en donde está almacenado el dato buscado. 415 . Proceso de visualización de Datos: Permite visualizar los datos que contiene un arreglo. Proceso de búsqueda datos: Permite buscar uno o más datos dentro de un arreglo. Dependiendo lo que se necesite visualizar se podrá mostrar todos los datos del arreglo o solo una parte de ellos. promedio. Es importante mencionar que para poder visualizar los datos de un arreglo. dichos datos deben haber sido ingresados previamente. En este caso.ESTRUCTURAS DE DATOS – Arreglos. Pag. tales como suma de datos. etc. Si el dato buscado es encontrado. Proceso de cálculo basado en datos del arreglo: Nos permite realizar diferentes tipos de cálculo con los datos de un arreglo.

Juan José Flores Cueto. Ing. Pag. 416 .

for ( int i = 0.length . Inclusive. i ++ ) { suma += Integer. usted deberá asegurarse de incluir una lista de números. 417 . incluidos como parámetros */ package dominioDeLaAplicacion . i++ ) { suma += Integer. Pag.length .ESTRUCTURAS DE DATOS – Arreglos. public static void main ( String arg[ ] ) { } Arreglo de tipo String denominado “arg” Esto significa que se puede incluir algunos parámetros al momento de ejecutar un proyecto de solución. main( ) en Java.parseInt ( arg [ i ] ) . i < a. para que estos puedan ser sumados.out.println (suma) . los arreglos en Java poseen un atributo que almacena la cantidad de datos que pueden contener. } En primer lugar. Analizando las siguientes sentencias: for ( int i = 0 . Dichos parámetros se pasan al método main ( ) y se almacenan en el arreglo arg. Este atributo se denomina length. i < a.parseInt (arg [ i ] ) . } } Es importante mencionar que cuando se ejecute esta clase. tal y como se muestra a continuación. DESARROLLO DE SOLUCIONES BÁSICAS UTILIZANDO ARREGLOS Los arreglos pueden ser utilizados como parte de las soluciones a los problemas que se nos plantean. siempre hemos definido un arreglo como parte de la estructura del método principal. } System. class Suma { public static void main ( String arg [ ] ) { int suma = 0 . Analizar las siguientes sentencias: Clase Suma /* Clase que nos permite sumar varios números enteros .

En consecuencia. lo convertimos a un dato tipo NUMERO utilizando Integer. double promedio .* . public class PrgAlumno { public static void main ( String arg [ ] ) { int suma = 0. cuando necesitamos convertir un dato a un número entero. Ing.parseInt(). i ++ ) { System. Clase PrgAlumno package dominioDeLaAplicacion . 418 . nota . la lista de números se almacena en el arreglo arg de tipo String. } } Observe que la solución anterior nos permite realizar el cálculo y la visualización del promedio general de notas. y luego lo sumamos a la variable suma. Utilizando la sentencia for podemos acceder a cada uno de los datos almacenados en el arreglo arg[]. Pag. utilizamos el método parseInt() de la clase Integer. En segundo lugar. nota = lectura. i < 10 . Juan José Flores Cueto. Al finalizar la sentencia for se tiene la suma de los números incluidos como parámetros en la variable suma. (Recuerde que una variable solo nos permite almacenar un dato a la vez).leerInt ( ) . System. for ( int i = 0. Pero. } promedio = suma / 10 .out.out.print ( “ El promedio general de notas es ” + promedio ) . no podemos almacenar a la vez las notas finales de los 10 alumnos.print ( “ Ingrese la Nota Final del Alumno ” + ( i + 1 ) ) . A continuación se presenta la codificación en Java de una solución que permite ingresar la nota final de 10 alumnos. suma = suma + nota . al utilizar solo una variable (notas). y calcula el promedio general de notas del salón de clase. import biblioteca.

// Creación del arreglo notas. En la solución. el siguiente paso quedaría definido de la siguiente manera: ƒ Manejar los datos almacenados en el arreglo o arreglos utilizados en la solución con la finalidad de proporcionar la información solicitada. ƒ Inicializar el arreglo o arreglos. Por lo tanto. Es importante destacar que para trabajar con arreglos se deben seguir los siguientes pasos: ƒ Declarar el arreglo o arreglos que se van ha utilizar en la solución del problema. import biblioteca. Pag. para finalmente formalizar el Método de las 6’D. A partir de este punto podemos realizar cualquier proceso con los datos almacenados en el arreglo o arreglos definidos en la solución. int numAlu =10 . se modificará el programa anterior. Estos tres pasos generalmente se desarrollarán en todas las soluciones.ESTRUCTURAS DE DATOS – Arreglos. A partir de este punto. ingresar los datos necesarios al arreglo o arreglos utilizados en la solución. definiendo un nombre adecuado para cada uno de ellos.* . notas[ ] . de tal forma que se incorporen progresivamente los conceptos tratados en este capítulo. public class PrgAlumnos { public static void main ( String [ ] args ) { // Declaración de variables y arreglos. notas = new double [numAlu] . double sumaNotas=0. Clase PrgAlumnos package dominioDeLaAplicacion . o en su defecto. Una vez almacenadas las notas finales de los 10 alumnos se calculará y mostrará el promedio de las mismas. ƒ Crear el arreglo o arreglos con el tamaño necesario para poder almacenar todos los datos. El arreglo notas almacenará datos de tipo NUMERO (número entero con parte decimal). 419 . se utilizará un arreglo unidimensional llamado notas que permitirá almacenar las notas finales de 10 alumnos de un determinado salón de clase.

i < numAlu .out. } } En la solución anterior. i=7. i=6. La variable numAlu fue declarada previamente con la sentencia int. Ing. para i=0.print ( “El promedio es : ” + ( sumaNotas / numAlu ) ) . i=5. i=2. siendo valores válidos de i. El uso de la sentencia for tiene como finalidad repetir 10 veces las sentencias que nos permitirán el ingreso de los datos. Cuando i = 1 (la segunda vez que se ejecuta la sentencia for). // Proceso de ingreso de datos al arreglo notas. i=3. notas = new double [numAlu] .leerDouble( ) . se crea el arreglo notas[ ] utilizando la siguiente sentencia: // Creación del arreglo notas.leerDouble( ) . i < numAlu .out. Observe que para crear el arreglo notas[ ] se utiliza la variable entera numAlu. Clase PrgAlumnos // Proceso de ingreso de datos al arreglo notas[ ]. } // Proceso de cálculo del promedio de notas finales.print ( “ Ingrese nota : " ) . i=9). Dicho arreglo podrá almacenar datos numéricos (parte entera y decimal). almacenando la nota ingresada en la décima posición del arreglo notas[ ]. y así sucesivamente hasta cuando i = 9 (la décima y última vez que se ejecuta la sentencia for). for ( int I = 0 . i++) { System. Esto nos permite crear un arreglo llamado notas[ ] con un tamaño igual a 10. la variable i aumenta su valor en 1. for ( int i = 0 . desde 0 hasta 9 (es decir. es decir en notas[0]. la nota ingresada se almacena en la segunda posición del arreglo notas[ ]. } System. notas[i] = Lectura.out. es decir en notas[1]. se declara un arreglo unidimensional llamado notas[ ] (vector). Es decir. i=4.print ( “ Ingrese nota : " ) . i < numAlu . Cuando i = 0 (la primera vez que se ejecuta la sentencia for). En tercer lugar. Los datos que se ingresarán serán las notas finales de los 10 alumnos del salón de clase. en primer lugar. i++ ) { sumaNotas = sumaNotas + notas[i] . Cada vez que la estructura lógica de repetición for se ejecuta. i++) { System. notas[i] = Lectura. es decir en notas[9]. for ( int i = 0 .leerDouble( ) .out. } La estructura lógica de repetición for permite que se repitan 10 veces las siguientes sentencias: System. se ejecuta el proceso de ingreso de datos al arreglo notas[ ]. la nota ingresada se almacena en la primera posición del arreglo notas[ ]. Pag. Para esto. En segundo lugar. i=1. Juan José Flores Cueto. 420 . las cuales están ubicadas dentro de la misma sentencia for. y se le asignó un valor igual a 10.print ( “ Ingrese nota : ” ) . notas[i] = Lectura. se utiliza una sentencia for. en el arreglo notas[ ] se podrán almacenar 10 notas finales. i=8.

ESTRUCTURAS DE DATOS – Arreglos. Pag. se suma uno de los datos almacenados en el arreglo notas[ ] (empezando desde el primero i = 0 hasta el último i = 9) a la variable sumaNotas (la variable sumaNotas actúa como acumulador). 421 . Observe que el proceso de ingreso de datos y el proceso de cálculo del promedio de las 10 notas finales se desarrollan utilizando 2 sentencias for exactamente iguales. Finalizada la ejecución de la primera sentencia for. se utiliza una segunda sentencia for exactamente igual a la primera sentencia for. Finalizada la ejecución de la sentencia for se muestra el promedio de las 10 notas finales. el arreglo notas[ ] deberá tener almacenadas las notas finales de los 10 alumnos del salón de clase. Esto es recomendable como buena práctica de programación ya que posteriormente cada proceso desarrollado se convertirá en un método de una clase con una función determinada. se ejecuta el proceso de cálculo del promedio de las 10 notas finales. Para ello. Tal y como se muestra a continuación: notas 10 15 20 19 14 13 16 11 17 09 i =10 0 1 2 3 4 5 6 7 8 9 Finalmente. Cada vez que se ejecuta la segunda sentencia for.

i++ ) { sumaNotas = sumaNotas + notas[i] . i < numAlu . Observe que para crear el arreglo notas[ ] se utiliza la variable entera numAlu. public class PrgAlumnos { public static void main(String[] args) { // Declaración de variables.print ( “ Ingrese la nota final del alumno [” + ( i + 1) + “]: ” ) . La variable numAlu fue declarada previamente con la sentencia int. for ( int i = 0 . numAlu = Lectura. double notas[] = new double [numAlu] .out. import biblioteca. for ( int i = 0 .out. Juan José Flores Cueto. Ing. i++ ) { System. Esto nos permite crear un arreglo llamado notas[ ] con un tamaño equivalente al valor almacenado en la variable numAlu. // Proceso de ingreso de datos al arreglo notas[ ]. se modificará la solución anterior de tal forma que permita almacenar las notas finales de todos los alumnos de un determinado salón de clase. // Determinación del tamaño del arreglo. Pag. en el arreglo notas[ ] se podrán almacenar las notas finales de todos los alumnos de un salón de clase.print ( “ El promedio es : ” + ( sumaNotas / numAlu ) ) . y se le asignó un valor que fue ingresado por el usuario a través del teclado. // Declaración y creación del arreglo notas.* . i < numAlu . int numAlu . se declara y crea el arreglo notas[ ] utilizando la siguiente sentencia: // Declaración y creación del arreglo notas. Clase PrgAlumnos package dominioDeLaAplicacion . } // Proceso de cálculo del promedio de notas finales.leerInt( ) . Es decir. System.out.leerDouble( ) . } } En la solución anterior. Ahora. } System.print ( “ Ingrese el número de alumnos : ” ) . double sumaNotas = 0 . notas[i] = Lectura. double notas[] = new double [numAlu] . 422 .

423 . se mostrará el siguiente mensaje: Ingrese la nota final del alumno [1]: La nota final ingresada se almacenará en la primera posición del arreglo notas[ ]. Otra modificación que vale la pena destacar es la siguiente: System. Cuando i = 1 (la segunda vez que se ejecuta la sentencia for). es decir en notas[0]. i++ ) { System. i < numAlu .leerDouble( ) .print ( “ Ingrese la nota final del alumno [” + ( i + 1) + “]: ” ) .out. se mostrará el siguiente mensaje: Ingrese la nota final del alumno [2]: La nota final ingresada se almacenará en la segunda posición del arreglo notas[ ].ESTRUCTURAS DE DATOS – Arreglos.print ( “ Ingrese la nota final del alumno [” + ( i + 1) + “]: ” ) . se puede personalizar el mensaje que se le muestra al usuario al momento del ingreso de las notas finales. } Utilizando dicha sentencia con la variable i (la cual aumenta su valor en 1 cada vez que se ejecuta la sentencia for). // Proceso de ingreso de datos al arreglo notas[ ]. y así sucesivamente hasta ingresar la nota final del último alumno. notas[i] = Lectura. for ( int i = 0 . es decir en notas[1].out. Cuando i = 0 (la primera vez que se ejecuta la sentencia for). Pag. Esta sentencia esta ubicada dentro de la sentencia for y nos permite el ingreso de datos al arreglo llamado notas[ ].

de tal forma que permita consistenciar la entrada de datos. double sumaNotas = 0 . } } while ( notas[i] > 20 || notas[i] < 0 ) . // Proceso de ingreso de datos al arreglo notas[ ] con consistencia de datos. i++ ) { sumaNotas = sumaNotas + notas[i] .* .out. Juan José Flores Cueto. // Determinación del tamaño del arreglo con consistencia de datos. notas[i] = Lectura. se modificará nuevamente la solución anterior. } } Observe el uso de la sentencia do dentro de la sentencia for. Se consistenciará el ingreso del número total de alumnos y de la nota final de cada uno de ellos.print ( “ El promedio es : ” + ( sumaNotas / numAlu ) ) . } // Proceso de cálculo del promedio de notas finales. La consistencia de datos nos permite asegurarnos que el usuario ingrese solo datos válidos antes de que estos se almacenen en las variables o en los arreglos. for ( int i = 0 .out. if ( notas[i] > 20 || notas[i] < 0 ) { System. } System. Pag. i < numAlu . do { System. double notas[] = new double [numAlu] .out.print ( “ Ingrese la nota final del alumno [” + ( i + 1) + “]: ” ) . Ahora. Uno de los principales usos de la sentencia do es la consistencia de datos. } } while ( numAlu < 0 ) . for ( int I = 0 . numAlu = Lectura. Clase PrgAlumnos package dominioDeLaAplicacion . import biblioteca. if ( numAlu <= 0 ) { System. i++ ) { do { System. // Declaración y creación de arreglo. i < numAlu .leerDouble( ) . public class PrgAlumnos { public static void main(String[] args) { // Declaración de variables.leerInt( ) .println ( “ Nota ingresada no es valida… Reintente! ” ) .println ( “ El número de alumnos no es valido… Reintente! ” ) .out. int numAlu .print ( “ Ingrese el número de alumnos : ” ) .out. Ing. 424 .

Después. Con el número de alumnos ingresado se crea un arreglo (notas[ ]).Definición de la solución.ESTRUCTURAS DE DATOS – Arreglos. Finalmente. se realiza la suma de todas las notas finales y el resultado se almacena en una variable acumulador (sumaNotas). Luego se procede a ingresar las notas finales de todos los alumnos y se almacenan en el arreglo creado. Desarrollar una solución que permita ingresar y almacenar las notas finales de todos los alumnos de un determinado salón de clase. Etapa 02 . FORMALIZACIÓN DE LA SOLUCIÓN UTILIZANDO EL MÉTODO DE LAS 6’D Problema 132 Etapa 01 . Determinar y mostrar el promedio de las notas finales. se almacena el resultado en una variable (prom) y se muestra por pantalla. ‰ Datos necesarios: El número de alumnos y las notas finales de cada uno de ellos.Descripción del problema. ‰ Procesamiento: El número de alumnos se ingresa a través del teclado y se almacena en una variable (numAlu). 425 . Pag. se realiza el cálculo del promedio. ‰ Resultado deseado: Mostrar el promedio de las notas finales de los alumnos de un determinado salón de clase. Consistenciar el ingreso de datos.

Etapa 03 . 2. 426 . 1. Definición de Paquetes y desarrollo del Diagrama de Paquetes.Diseño de la lógica. Nombre del Proyecto: ProyAlumnos. Ing. Clases Clases dominioDeLaAplicacion biblioteca Pag. Definición de las Clases. Juan José Flores Cueto. Diagrama de paquetes 3.

numAlu..1 INCREMENTA 1 sumaNotas = sumaNotas + notas[i] FINDESDE prom = sumaNotas / numAlu ESCRIBIR prom FIN Pag. 427 . Reintente!” FINSI MIENTRAS ( notas[i] > 20 || notas[i] < 0 ) FINDESDE COMENTARIO “Cálculo del promedio de notas finales” DESDE i = 0 HASTA i = numAlu . Diseño de algoritmo para el método principal.1 INCREMENTA 1 HACER LEER notas[i] SI ( notas[i] > 20 || notas[i] < 0 ) ENTONCES ESCRIBIR “Nota no válida.. notas[ ] SALIDA: prom INICIO COMENTARIO “Declaración de variables” NUMERO i. notas[ ].método main ( ) ENTRADA: numAlu. 4. Reintente!” FINSI MIENTRAS (numAlu <= 0 ) COMENTARIO “Creación del arreglo” CREAR notas [numAlu] COMENTARIO “Ingreso de datos al arreglo notas[ ]. Algoritmo PrgAlumnos01 .” DESDE i = 0 HASTA i = numAlu . prom COMENTARIO “Determinación del tamaño del arreglo” HACER LEER numAlu SI (numAlu <= 0 ) ENTONCES ESCRIBIR “Número de alumnos no válido. sumaNotas = 0..ESTRUCTURAS DE DATOS – Arreglos..

print ( “ Ingrese el número de alumnos : ” ) . } } while ( numAlu <= 0 ) .out. Juan José Flores Cueto. double sumaNotas = 0.out.* . i < numAlu . notas[i] = Lectura. // Declaración y creación del arreglo. for ( i = 0 . for ( i = 0 . double notas[ ] = new double [numAlu] .out.println ( “ El número de alumnos no es válido… Reintente! ” ) . i++ ) { sumaNotas = sumaNotas + notas[i] .print ( “ Ingrese la nota final del alumno [ ” + ( i + 1) + “]: ” ) .out. numAlu . i++ ) { do { System. // Determinación del tamaño del arreglo con consistencia de datos. numAlu = Lectura. public class PrgAlumnos01 { public static void main(String[] args) { // Declaración de variables. Clase PrgAlumnos01 package dominioDeLaAplicacion . System. Ing. prom . Etapa 04 . do { System.Desarrollo de la Codificación.println ( “ El promedio es : ” + prom ) . } prom = sumaNotas / numAlu . 428 . } } while ( notas[i] > 20 || notas[i] < 0 ) . if ( notas[i] > 20 || notas[i] < 0 ) { System. // Proceso de ingreso de datos al arreglo notas[ ] con consistencia de datos. } // Proceso de cálculo del promedio de notas finales. import biblioteca. i < numAlu .leerDouble( ) . if ( numAlu <= 0 ) { System.leerInt( ) .out. int i. } } Pag.println ( “ Nota ingresada no es válida… Reintente! ” ) .

‰ Procesamiento: El número de prácticas se ingresa a través del teclado y se almacena en una variable (numPra). Después. Determinar el promedio de las prácticas sabiendo que se elimina la práctica con la nota mas baja.Descripción del problema. Con el número de prácticas se crea un arreglo (notas[ ]).ESTRUCTURAS DE DATOS – Arreglos. Consistenciar el ingreso de datos. Finalmente. Desarrollar una solución que permita ingresar y almacenar las notas de todas las prácticas de un alumno. Etapa 02 . se determina la nota más baja del alumno y se almacena en una variable (notaMenor). ‰ Resultado deseado: Mostrar el promedio redondeado de las notas de las prácticas de un alumno. Mostrar el promedio redondeado. se almacena el resultado en una variable (promAlu). se redondea y se muestra por pantalla.Definición de la solución. Pag. se realiza el cálculo del promedio ((sumaNotas – notaMenor) / (numPra – 1)). Luego. Problema 133 Etapa 01 . se realiza la suma de todas las notas de las prácticas y el resultado se almacena en una variable de tipo acumulador (sumaNotas). ‰ Datos necesarios: El número de prácticas y las notas de las prácticas del alumno. Luego se procede a ingresar las notas de las prácticas del alumno y se almacenan en el arreglo creado. 429 .

Diseño de la lógica. 2. 1. Nombre del Proyecto: ProyAlumnos. 430 . Etapa 03 . Clases Clases dominioDeLaAplicacion biblioteca Pag. Definición de Paquetes y desarrollo del Diagrama de Paquetes. Diagrama de paquetes 3. Juan José Flores Cueto. Definición de las Clases. Ing.

notas[ ] SALIDA: promAlu INICIO COMENTARIO “Declaración de variables” NUMERO i.1 INCREMENTA 1 sumaNotas = sumaNotas + notas[i] FINDESDE DESDE i = 0 HASTA i = numPra . Algoritmo PrgAlumnos02 . notaMenor = 20 NUMERO notas[ ].método main ( ) ENTRADA: numPra.” DESDE i = 0 HASTA i = numPra . 431 . Diseño de algoritmo para el método principal.ESTRUCTURAS DE DATOS – Arreglos.1 INCREMENTA 1 SI ( notaMenor > notas[i] ) ENTONCES notaMenor = notas[i] FINSI FINDESDE promAlu = ( sumaNotas .1 INCREMENTA 1 HACER LEER notas[i] SI ( notas[i] > 20 || notas[i] < 0 ) ENTONCES ESCRIBIR “Nota no válida.. sumaNotas = 0.. numPra. promAlu COMENTARIO “Determinación del tamaño del arreglo” HACER LEER numPra SI (numPra <= 0 ) ENTONCES ESCRIBIR “Número de prácticas no válido… Reintente!” FINSI MIENTRAS (numPra <= 0 ) COMENTARIO “Creación del arreglo” CREAR notas [numPra] COMENTARIO “Ingreso de datos al arreglo notas[ ].notaMenor ) / ( numPra . 4.1 ) promAlu = promAlu REDONDEA 0 ESCRIBIR promAlu FIN Pag. Reintente!” FINSI MIENTRAS ( notas[i] > 20 || notas[i] < 0 ) FINDESDE COMENTARIO “Cálculo del promedio de notas de las prácticas” DESDE i = 0 HASTA i = numPra .

println ( “ Nota ingresada no es válida… Reintente! ” ) .out. Etapa 04 . numPra .out. promAlu = Math.leerDouble( ) . // Declaración y creación del arreglo. Ing. notaMenor = 20. // Ingreso de datos al arreglo notas[ ] con consistencia de datos.print ( “ Ingrese la nota de la práctica [ ” + ( i + 1) + “]: ” ) .out. for ( i = 0 . } } while ( notas[i] > 20 || notas[i] < 0 ) .leerInt( ) . import biblioteca. i++ ) { do { System. } promAlu = sumaNotas / numAlu . double notas[ ] = new double [numPra] . i < numPra . } } Pag. notas[i] = Lectura. Clase PrgAlumnos02 package dominioDeLaAplicacion . i < numPra . int i. promAlu .println ( “ El número de prácticas no es válido… Reintente! ” ) .out. for ( i = 0 . do { System. 432 .Desarrollo de la Codificación. i < numPra . } } while ( numPra <= 0 ) . public class PrgAlumnos02 { public static void main(String[] args) { // Declaración de variables. if ( numPra <= 0 ) { System.print ( “ Ingrese el número de prácticas del alumno : ” ) . if ( notas[i] > 20 || notas[i] < 0 ) { System. } for ( i = 0 . // Determinación del tamaño del arreglo con consistencia de datos.round (promAlu) . } // Proceso de cálculo del promedio de notas de las prácticas. i++ ) { if ( notaMenor > notas [i] ) notaMenor = notas[i] . System. i++ ) { sumaNotas = sumaNotas + notas[i] . Juan José Flores Cueto.* .out. numPra = Lectura.println ( “ El promedio es : ” + promAlu ) . double sumaNotas = 0.

Después. Etapa 02 . ‰ Procesamiento: El número de alumnos se ingresa a través del teclado y se almacena en una variable (numAlu). se redondea y se muestra por pantalla. Luego. por cada alumno. se realiza el cálculo de su promedio ((sumaNotas + notaMayor) / 4). Luego se procede a ingresar las notas de las tres prácticas de cada alumno y se almacenan en el arreglo creado. se realiza la suma de las notas de sus tres prácticas y el resultado se almacena en una variable acumulador (sumaNotas). Pag. Consistenciar el ingreso de datos. Con el número de alumnos se crea un arreglo (notas[ ][ ]). Problema 134 Etapa 01 . Determinar el promedio de cada alumno sabiendo que se duplica su nota más alta. 433 . ‰ Datos necesarios: El número de alumnos y las notas de las tres prácticas de cada alumno.Definición de la solución. ‰ Resultado deseado: Mostrar el promedio redondeado de las notas de las tres prácticas de cada alumno.ESTRUCTURAS DE DATOS – Arreglos. se almacena el resultado en una variable (promAlu). Finalmente.Descripción del problema. Mostrar el promedio redondeado. Desarrollar una solución que permita ingresar y almacenar las notas de las tres prácticas de todos los alumnos de un salón de clase. se determina su nota más alta y se almacena en una variable (notaMayor).

Definición de Paquetes y desarrollo del Diagrama de Paquetes. Juan José Flores Cueto. Definición de las Clases. Clases Clases dominioDeLaAplicacion biblioteca Pag. 434 .Diseño de la lógica. 2. 1. Etapa 03 . Ing. Diagrama de paquetes 3. Nombre del Proyecto: ProyAlumnos.

método main ( ) ENTRADA: numAlu. promAlu COMENTARIO “Determinación del tamaño del arreglo” HACER LEER numAlu SI (numAlu <= 0 ) ENTONCES ESCRIBIR “Número de alumnos no válido… Reintente!” FINSI MIENTRAS (numAlu <= 0 ) COMENTARIO “Creación del arreglo” CREAR notas [numAlu][3] COMENTARIO “Ingreso de datos al arreglo notas[ ][ ]” DESDE i = 0 HASTA i = numAlu .1 INCREMENTA 1 notaMayor = notas[i][0] MAXIMO notas[i][1] notaMayor = notas[i][2] MAXIMO notaMayor sumaNotas = notas[i][0] + notas[i][1] + notas[i][2] promAlu = ( sumaNotas + notaMayor ) / 4 promAlu = promAlu REDONDEA 0 ESCRIBIR promAlu FINDESDE FIN Pag. 435 . sumaNotas = 0.ESTRUCTURAS DE DATOS – Arreglos. Reintente!” FINSI MIENTRAS ( notas[i][j] > 20 || notas[i][j] < 0 ) FINDESDE FINDESDE COMENTARIO “Cálculo del promedio de notas por alumno” DESDE i = 0 HASTA i = numAlu ... notaMayor = 0 NUMERO notas[ ][ ]. numAlu. 4. notas[ ][ ] SALIDA: promAlu INICIO COMENTARIO “Declaración de variables” NUMERO i. Diseño de algoritmo para el método principal. j.1 INCREMENTA 1 DESDE j = 0 HASTA j = 2 INCREMENTA 1 HACER LEER notas[i][j] SI ( notas[i][j] > 20 || notas[i][j] < 0 ) ENTONCES ESCRIBIR “Nota no válida. Algoritmo PrgAlumnos03 .

notas[i][1] ) . } } while ( numAlu <= 0 ) . for { i = 0 . promAlu = Math. } } // Cálculo del promedio de notas por alumno. notaMayor = Math.out.leerInt( ) . import biblioteca. if ( numAlu <= 0 ) { System.* .out. Juan José Flores Cueto. i < numAlu .max (notas[i][0]. // Determinación del tamaño del arreglo con consistencia de datos.leerDouble( ) .out.out. promAlu . } } while ( notas[i][j] > 20 || notas[i][j] < 0 ) .println ( “ Nota ingresada no es válida… Reintente! ” ) . notaMayor = 0. public class PrgAlumnos03 { public static void main(String[] args) { // Declaración de variables. System. notas[i][j] = Lectura. sumaNotas = notas[i][0] + notas[i][1] + notas[i][2] . double notas[ ][ ] = new double [numAlu][3] . j < 3 .print ( “ Ingrese la nota de la práctica [ ” + ( j + 1) + “]: ” ) . for ( i = 0 . numAlu = Lectura.round (promAlu) . i++ ) { System. Etapa 04 .println ( “ El promedio del alumno [ ” + ( i + 1 ) + “ ] es: ” + promAlu ) . j.println ( “ El número de alumnos no es válido… Reintente! ” ) . notaMayor ) .max (notas[i][2]. double sumaNotas = 0.println ( “ Alumno [ ” + ( i + 1) + “ ]: ” ) .out. numAlu . // Ingreso de datos al arreglo notas[ ][ ] con consistencia de datos. 436 .Desarrollo de la Codificación. Ing. i < numAlu . int i. do { System.out. i++ ) { notaMayor = Math. // Declaración y creación del arreglo. promAlu = ( sumaNotas + notaMayor ) / 4 . if ( notas[i][j] > 20 || notas[i][j] < 0 ) { System. } } } Pag. for ( i = 0 .print ( “ Ingrese el número de alumnos : ” ) . Clase PrgAlumnos03 package dominioDeLaAplicacion . j++ ) { do { System.

437 . Desarrollar una solución que permita ingresar y almacenar las notas de las prácticas de todos los alumnos de un salón de clase. se realiza el cálculo de su promedio ((sumaNotas + notaMayor . Luego. Mostrar el promedio redondeado a dos decimales. Luego se procede a ingresar las notas de las prácticas de cada alumno y se almacenan en el arreglo creado. ‰ Procesamiento: El número de alumnos y el número de prácticas se ingresa a través del teclado y se almacenan en variables (numAlu y numPra respectivamente). Problema 135 Etapa 01 . ‰ Datos necesarios: El número de alumnos. se determina su nota más alta y se almacena en una variable (notaMayor). Finalmente.Descripción del problema.ESTRUCTURAS DE DATOS – Arreglos. se almacena el resultado en una variable (promAlu). Consistenciar el ingreso de datos. se realiza la suma de las notas de las prácticas y el resultado se almacenan en una variable de tipo acumulador (sumaNotas). Pag. por cada alumno. Con los datos ingresados se crea un arreglo (notas[ ][ ]). ‰ Resultado deseado: Mostrar el promedio redondeado a dos decimales de las notas de las prácticas de cada alumno y el promedio simple de todas las notas de las prácticas de los alumnos. Después.notaMenor) / numPra). el número de prácticas y las notas de las prácticas de cada alumno. Determinar el promedio de cada alumno sabiendo que se duplica su nota más alta y se elimina su práctica con la nota mas baja. También se determina su nota mas baja y se almacena en una variable (notaMenor). determinar y mostrar el promedio simple de todas las notas de las prácticas de los alumnos del salón de clase. se redondea y se muestra por pantalla.Definición de la solución. Finalmente. Etapa 02 .

Juan José Flores Cueto. Ing. 2. 1. se almacena el resultado en una variable (prom) y se muestra por pantalla. se realiza la suma de las notas de las prácticas de todos los alumnos del salón de clase y el resultado se almacena nuevamente en una variable de tipo acumulador (sumaNotas). Etapa 03 . Definición de las Clases. 438 . Nombre del Proyecto: ProyAlumnos.Diseño de la lógica. Definición de Paquetes y desarrollo del Diagrama de Paquetes. Se determina el promedio simple. Adicionalmente. Diagrama de paquetes 3. Clases Clases dominioDeLaAplicacion biblioteca Pag.

4.1 INCREMENTA 1 HACER LEER notas[i][j] SI ( notas[i][j] > 20 || notas[i][j] < 0 ) ENTONCES ESCRIBIR “Nota no válida.método main ( ) ENTRADA: numAlu. Reintente!” FINSI MIENTRAS ( notas[i][j] > 20 || notas[i][j] < 0 ) FINDESDE FINDESDE Pag. prom INICIO COMENTARIO “Declaración de variables” NUMERO i. notas[ ][ ]. numPra. sumaNotas = 0.. Reintente!” FINSI MIENTRAS (numPra < 0 ) COMENTARIO “Creación del arreglo” CREAR notas [numAlu][numPra] COMENTARIO “Ingreso de datos al arreglo notas[ ][ ]” DESDE i = 0 HASTA i = numAlu . numPra. notas[ ][ ] SALIDA: promAlu. numAlu. prom COMENTARIO “Determinación del tamaño del arreglo” HACER LEER numAlu SI (numAlu <= 0 ) ENTONCES ESCRIBIR “Número de alumnos no válido. Reintente!” FINSI MIENTRAS (numAlu <= 0 ) HACER LEER numPra SI (numPra <= 0 ) ENTONCES ESCRIBIR “Número de prácticas no válido. j..ESTRUCTURAS DE DATOS – Arreglos.. Diseño de algoritmo para el método principal. 439 .. promAlu.1 INCREMENTA 1 DESDE j = 0 HASTA j = numPra . notaMayor = 0 NUMERO notaMenor = 20. Algoritmo PrgAlumnos04 .

Ing.1 INCREMENTA 1 notaMayor = 0 notaMenor = 20 sumaNotas = 0 DESDE j = 0 HASTA j = numPra . Algoritmo PrgAlumnos04 – método main ( ) COMENTARIO “Cálculo del promedio de notas por alumno” DESDE i = 0 HASTA i = numAlu . 440 . Diseño de algoritmo para el método principal.1 INCREMENTA 1 notaMayor = notaMayor MAXIMO notas[i][j] notaMenor = notaMenor MAXIMO notas[i][j] sumaNotas = sumaNotas + notas[i][j] FINDESDE promAlu = (sumaNotas+notaMayor-notaMenor) / numPra promAlu = promAlu REDONDEA 2 ESCRIBIR promAlu FINDESDE COMENTARIO “Cálculo del promedio simple de todas las notas” sumaNotas = 0 DESDE i = 0 HASTA i = numAlu . Juan José Flores Cueto. Continúa… 4.1 INCREMENTA 1 DESDE j = 0 HASTA j = numPra .1 INCREMENTA 1 sumaNotas = sumaNotas + notas[i][j] FINDESDE FINDESDE prom = sumaNotas / ( numAlu * numPra ) prom = prom REDONDEA 2 ESCRIBIR prom FIN Pag.

i++ ) { System. promAlu. double sumaNotas = 0. j < numPra .println ( “ El número de alumnos no es válido… Reintente! ” ) .leerInt( ) . public class PrgAlumnos04 { public static void main(String[] args) { // Declaración de variables. do { System.println ( “ El número de prácticas no es válido… Reintente! ” ) .print ( “ Ingrese la nota de la práctica [ ” + ( j + 1) + “]: ” ) .* .print ( “ Ingrese el número de prácticas : ” ) .out.out.Desarrollo de la Codificación.println ( “ Nota ingresada no es válida… Reintente! ” ) .print ( “ Ingrese el número de alumnos : ” ) .leerDouble( ) .out. } } while ( notas[i][j] > 20 || notas[i][j] < 0 ) . // Declaración y creación del arreglo.leerInt( ) . for ( i = 0 . notaMenor = 20.ESTRUCTURAS DE DATOS – Arreglos. 441 . import biblioteca. if ( numAlu <= 0 ) { System. int i. for { i = 0 . j++ ) { do { System.println ( “ Alumno [ ” + ( i + 1) + “ ]: ” ) . double notas[ ][ ] = new double [numAlu][numPra] . i < numAlu .out. j. numAlu = Lectura.out. notas[i][j] = Lectura. // Ingreso de datos al arreglo notas[ ][ ] con consistencia de datos.out. do { System. numPra . if ( numPra <= 0 ) { System. Etapa 04 . } } while ( numAlu <= 0 ) .out. if ( notas[i][j] > 20 || notas[i][j] < 0 ) { System. Clase PrgAlumnos04 package dominioDeLaAplicacion . numPra = Lectura. numAlu. } } while ( numPra < 0 ) . /// Determinación del tamaño del arreglo con consistencia de datos. } } Pag. notaMayor = 0. prom .

Continúa… Etapa 04 . notaMenor = Math.notaMenor) / ( numAlu * numPra ) .notaMenor) / numPra . j < numPra . notaMenor ) .out.0 . System.println ( “ El promedio simple de las notas es : ” + prom ) . for ( i = 0 . sumaNotas = 0 . i++ ) { for { i = 0 .max (notas[i][j].max (notas[i][j]. i < numAlu .round (prom * 100) ) / 100. promAlu = ( Math.round (prom * 100) ) / 100.println ( “ El promedio del alumno [ ” + ( i + 1 ) + “ ] es: ” + promAlu ) .out. j < numPra . System. j++ ) { sumaNotas = sumaNotas + notas[i][j] . sumaNotas = 0 . i < numAlu . for { i = 0 . i++ ) { notaMayor = 0 . prom = ( Math. notaMenor = 20 . } // Cálculo del promedio simple de todas las notas. } } Pag. j++ ) { notaMayor = Math. Clase PrgAlumnos04 // Cálculo del promedio de notas por alumno. } promAlu = ( sumaNotas + notaMayor .0 . 442 . sumaNotas = sumaNotas + notas[i][j] . for ( i = 0 .Desarrollo de la Codificación. } } prom = ( sumaNotas + notaMayor . Ing. Juan José Flores Cueto. notaMayor) .

Finalmente. Adicionalmente. Con el número de alumnos se crea un arreglo (notas[ ][ ]). Problema 136 Etapa 01 .Definición de la solución. se redondea y se muestra por pantalla. promedio de trabajos y examen final (multiplicado por 2). Luego se procede a ingresar las notas del examen parcial. se realiza la suma de la nota del examen parcial. Después. Desarrollar una solución que permita ingresar y almacenar las notas del examen parcial. promedio de trabajos y examen final de cada alumno y se almacenan en el arreglo creado. promedio de trabajos y examen final de todos los alumnos de un salón de clase. por cada alumno. Luego. se almacena el resultado en una variable (promAlu). determinar y mostrar el porcentaje de alumnos aprobados y el porcentaje de alumnos desaprobados. ‰ Datos necesarios: El número de alumnos y las notas del examen parcial. ‰ Resultado deseado: Mostrar el promedio redondeado de las notas de cada alumno. 443 . ‰ Procesamiento: El número de alumnos se ingresa a través del teclado y se almacena en una variable (numAlu). se realiza la suma de las notas del examen final de todos los alumnos del salón de clase y el resultado se almacena nuevamente en una variable acumulador (sumaEF). También. Consistenciar el ingreso de los datos. calcular y mostrar el promedio obtenido por los alumnos en el examen final. Mostrar el promedio redondeado. Determinar el promedio de cada alumno sabiendo que se duplica la nota del examen final.Descripción del problema. el promedio obtenido por los alumnos en el examen final y el porcentaje de alumnos aprobados y desaprobados. Pag. Etapa 02 . se determina su promedio ((sumaNotas notaMenor) / 4). Se determina el promedio simple. promedio de trabajos y examen final de cada alumno.ESTRUCTURAS DE DATOS – Arreglos. y el resultado se almacena en una variable de tipo acumulador (sumaNotas).

444 . Definición de Paquetes y desarrollo del Diagrama de Paquetes. luego se realiza el calculo del porcentaje de alumno aprobados y desaprobados. se almacena el resultado en variables (porceAprob y porceDesaprob respectivamente). Ing. se redondea y se muestra por pantalla. Finalmente. Juan José Flores Cueto. Definición de las Clases. 1. Diagrama de paquetes 3. Nombre del Proyecto: ProyAlumnos. y se muestran por pantalla.Diseño de la lógica. Clases Clases dominioDeLaAplicacion biblioteca Pag. se almacena el resultado en una variable (promEF). almacenando los resultados en variables (aprobados y desaprobados respectivamente). 2. se realiza nuevamente el cálculo del promedio de notas de cada alumno (promAlu) y se determina la cantidad de alumnos aprobados y la cantidades de desaprobados. Etapa 03 .

promAlu. Reintente!” FINSI MIENTRAS ( notas[1][i] > 20 || notas[1][i] < 0 ) Pag. promEF.. 445 ..1 INCREMENTA 1 HACER COMENTARIO “Examen Parcial” LEER notas[0][i] SI ( notas[0][i] > 20 || notas[0][i] < 0 ) ENTONCES ESCRIBIR “Nota no válida. Diseño de algoritmo para el método principal. porceAprob. notas[ ][ ] SALIDA: promAlu. porceDesaprob NUMERO aprobados = 0. 4. numAlu.. sumaNotas = 0. Algoritmo PrgAlumnos05.ESTRUCTURAS DE DATOS – Arreglos. porceDesaprob INICIO COMENTARIO “Declaración de variables” NUMERO i. promEF. Reintente!” FINSI MIENTRAS ( notas[0][i] > 20 || notas[0][i] < 0 ) HACER COMENTARIO “Promedio de trabajos” LEER notas[1][i] SI ( notas[1][i] > 20 || notas[1][i] < 0 ) ENTONCES ESCRIBIR “Nota no válida.método main ( ) ENTRADA: numAlu. desaprobados = 0. porceAprob COMENTARIO “Determinación del tamaño del arreglo” HACER LEER numAlu SI (numAlu <= 0 ) ENTONCES ESCRIBIR “Número de alumnos no válido… Reintente!” FINSI MIENTRAS (numAlu <= 0 ) COMENTARIO “Creación del arreglo” CREAR notas [3][numAlu] COMENTARIO “Ingreso de datos al arreglo notas[ ][ ]” DESDE i = 0 HASTA i = numAlu . sumaEF = 0 NUMERO notas[ ][ ]..

Algoritmo PrgAlumnos05. 446 .1 INCREMENTA 1 sumaNotas = notas[0][i] + notas[1][i] + notas[2][i] * 2 promAlu = sumaNotas / 4 promAlu = promAlu REDONDEA 0 SI ( promAlu < 11 ) ENTONCES desaprobados = desaprobados + 1 SINO Aprobados = aprobados + 1 FINSI FINDESDE porceAprob = ( aprobados * 100 ) / numAlu porceAprob = porceAprob REDONDEA 2 porceDesaprob = 100 . Reintente!” FINSI MIENTRAS ( notas[2][i] > 20 || notas[2][i] < 0 ) FINDESDE COMENTARIO “Cálculo del promedio de notas por alumno” DESDE i = 0 HASTA i = numAlu . Ing.1 INCREMENTA 1 sumaNotas = notas[0][i] + notas[1][i] + notas[2][i] * 2 promAlu = sumaNotas / 4 promAlu = promAlu REDONDEA 0 ESCRIBIR promAlu FINDESDE COMENTARIO “Cálculo del promedio simple de examen final” DESDE i = 0 HASTA i = numAlu . Diseño de algoritmo para el método principal.. Continúa… 4.1 INCREMENTA 1 sumaEF = sumaEF + notas[2][i] FINDESDE promEF = sumaEF / numAlu promEF = promEF REDONDEA 2 ESCRIBIR promEF COMENTARIO “Cálculo de alumnos aprobados y desaprobados” DESDE i = 0 HASTA i = numAlu .método main ( ) HACER COMENTARIO “Examen Final” LEER notas[2][i] SI ( notas[2][i] > 20 || notas[2][i] < 0 ) ENTONCES ESCRIBIR “Nota no válida.porceAprob ESCRIBIR porceAprob + “ % ” ESCRIBIR porceDesaprob + “ % ” FIN Pag. Juan José Flores Cueto..

promAlu. double sumaNotas = 0.print ( “ Ingrese la nota promedio de trabajos : ” ) .* . // Determinación del tamaño del arreglo con consistencia de datos.out. if ( notas[2][i] > 20 || notas[2][i] < 0 ) { System. notas[1][i] = Lectura. numAlu = Lectura. desaprobados = 0 .println ( “ Nota ingresada no es válida… Reintente! ” ) .out. i++ ) { System.out.println ( “ Nota ingresada no es válida… Reintente! ” ) .println ( “ Alumno [ ” + ( i + 1) + “ ]: ” ) . int i.print ( “ Ingrese el número de alumnos : ” ) . } } while ( notas[2][i] > 20 || notas[2][i] < 0 ) . do { System. } } while ( notas[0][i] > 20 || notas[0][i] < 0 ) .out.println ( “ Nota ingresada no es válida… Reintente! ” ) . promEF. // Ingreso de datos al arreglo notas[ ][ ] con consistencia de datos. notas[0][i] = Lectura. public class PrgAlumnos05 { public static void main(String[] args) { // Declaración de variables. } Pag. Etapa 04 . for ( i = 0 . porceAprob.println ( “ El número de alumnos no es válido… Reintente! ” ) .leerDouble( ) .Desarrollo de la Codificación.out. do { System.print ( “ Ingrese la nota del examen final : ” ) . do { System. if ( numAlu <= 0 ) { System. 447 .out.print ( “ Ingrese la nota del examen parcial : ” ) .ESTRUCTURAS DE DATOS – Arreglos. Clase PrgAlumnos05 package dominioDeLaAplicacion . aprobados = 0.leerDouble( ) .leerInt( ) . porceDesaprob . import biblioteca.out. notas[2][i] = Lectura.leerDouble( ) . } } while ( notas[1][i] > 20 || notas[1][i] < 0 ) . } } while ( numAlu <= 0 ) . sumaEF = 0.out. if ( notas[1][i] > 20 || notas[1][i] < 0 ) { System. if ( notas[0][i] > 20 || notas[0][i] < 0 ) { System. numAlu.out. i < numAlu . double notas[ ][ ] = new double [3][numAlu] . do { System. // Declaración y creación del arreglo.

System. } // Cálculo del promedio simple del examen final.out.round (porceAprob * 100) ) / 100.out.0 .print ( “ El porcentaje de alumnos desaprobados es : ” ) . i < numAlu . i++ ) { sumaEF = sumaEF + notas[2][i] .round (promAlu) . if ( promAlu < 11 ) { desaprobados ++ . i < numAlu .println ( “ El porcentaje de alumnos aprobados es : ” + porceAprob + “ % ” ) .0 . i++ ) { sumaNotas = notas[0][i] + notas[1][i] + notas[2][i] * 2 . Clase PrgAlumnos05 // Cálculo del promedio de notas por alumno.println ( “ El promedio de las notas del examen final es : ” + promEF ) .println ( “ El promedio del alumno [ ” + ( i + 1 ) + “ ] es: ” + promAlu ) . } } porceAprob = ( aprobados * 100 ) / numAlu . } } Pag. promAlu = Math. i++ ) { sumaNotas = notas[0][i] + notas[1][i] + notas[2][i] * 2 . } promEF = sumaEF / numAlu . System. System. // Cálculo de alumnos aprobados y desaprobados. for ( i = 0 .round (promAlu) . i < numAlu . promAlu = sumaNotas / 4 . porceAprob = ( Math. System. Ing.round (promEF * 100) ) / 100.out. porceDesaprob = 100 – porceAprob . for ( i = 0 .out. promEF = ( Math. for ( i = 0 . System.Desarrollo de la Codificación.out. Continúa… Etapa 04 . Juan José Flores Cueto. } else { aprobados ++ . promAlu = Math.println ( porceDesaprob + “ % ” ) . promAlu = sumaNotas / 4 . 448 .

600. Con el número de trabajadores se crea un arreglo (sueldos[ ]). Si el trabajador tiene un sueldo menor a S/. ‰ Procesamiento: El número de trabajadores se ingresa a través del teclado y se almacena en una variable (numTrab). Condición Aumento sueldo < 410 20 % sueldo >= 410 y sueldo <= 1600 10 % sueldo > 1600 05 % Etapa 02 .Definición de la solución. en base a su sueldo se determina su aumento de sueldo. de acuerdo a la siguiente tabla. Calcular y mostrar el aumento de sueldo de cada uno de los trabajadores (redondeado a dos decimales).410.1.ESTRUCTURAS DE DATOS – Arreglos. Luego se procede a ingresar los sueldos de cada trabajador y se almacenan en el arreglo creado. Desarrollar una solución que permita ingresar y almacenar el sueldo de todos los trabajadores de una empresa.Descripción del problema. ‰ Resultado deseado: Mostrar el aumento de sueldo de cada uno de los trabajadores de una empresa. se redondea y se muestra por pantalla. El aumento se almacena en una variable (aumento). por cada trabajador. Después. Pag. 449 . Si el trabajador tiene un sueldo mayor a S/. Consistenciar los datos ingresados.00 nuevos soles se le aumenta el 20% de su sueldo.00 nuevos soles. se le aumenta el 5% de su sueldo y en otros casos el aumento es del 10% de su sueldo. Problema 137 Etapa 01 . ‰ Datos necesarios: El número de trabajadores de la empresa y el sueldo de cada uno de ellos.

Diseño de la lógica. Nombre del Proyecto: ProyTrabajadores. Definición de las Clases. 2. Ing. 450 . Diagrama de paquetes 3. 1. Etapa 03 . Definición de Paquetes y desarrollo del Diagrama de Paquetes. Clases Clases dominioDeLaAplicacion biblioteca Pag. Juan José Flores Cueto.

sueldos[ ]. sueldos[ ] SALIDA: aumento INICIO COMENTARIO “Declaración de variables” NUMERO i.1 INCREMENTA 1 SI ( sueldos[i] < 410 ) ENTONCES aumento = sueldos[i] * 0. 451 . ” FINSI MIENTRAS ( sueldos[i] <= 0 ) FINDESDE COMENTARIO “Cálculo del aumento de sueldo por trabajador” DESDE i = 0 HASTA i = numTrab ..1 INCREMENTA 1 HACER LEER sueldos[i] SI ( sueldos[i] <= 0 ) ENTONCES ESCRIBIR “Sueldo ingresado no es válido. aumento = 0 COMENTARIO “Determinación del tamaño del arreglo” HACER LEER numTrab SI (numTrab <= 0 ) ENTONCES ESCRIBIR “Número de trabajadores no válido… ” FINSI MIENTRAS (numTrab <= 0 ) COMENTARIO “Creación del arreglo” CREAR sueldos [numTrab] COMENTARIO “Ingreso de datos al arreglo sueldos[ ]” DESDE i = 0 HASTA i = numTrab .. Diseño de algoritmo para el método principal.ESTRUCTURAS DE DATOS – Arreglos.método main ( ) ENTRADA: numTrab.10 FINSI FINSI aumento = aumento REDONDEA 2 ESCRIBIR aumento FINDESDE FIN Pag. Algoritmo PrgTrabajadores01 . numTrab. 4.05 SINO aumento = sueldos[i] * 0.2 SINO SI ( sueldos[i] > 1600 ) aumento = sueldos[i] * 0.

out. numTrab . double sueldos[ ] = new double [numTrab] . i < numTrab . import biblioteca. do { System. } } } Pag.println ( “ Sueldo ingresado no es válido… Reintente! ” ) . } else { aumento = sueldos[i] * 0.out.* . // Determinación del tamaño del arreglo con consistencia de datos.out.0 . System. i++ ) { if ( sueldos[i] < 410 ) { aumento = sueldos[i] * 0.leerInt( ) . sueldos[i] = Lectura.out. Juan José Flores Cueto.println ( “ El número de trabajadores no es válido… Reintente! ” ) .Desarrollo de la Codificación. } // Cálculo del aumento de sueldo por trabajador. i < numTrab . } } aumento = ( Math. Etapa 04 . } } while ( numTrab <= 0 ) . } else { if ( sueldos[i] > 1600 ) { aumento = sueldos[i] * 0.leerDouble( ) . // Declaración y creación del arreglo. if ( sueldos[i] <= 0 ) { System.print ( “ Ingrese el número de trabajadores de la empresa : ” ) .2 .10 . i++ ) { do { System. 452 . if ( numTrab <= 0 ) { System. for ( i = 0 .05 . for ( i = 0 . public class PrgTrabajadores01 { public static void main(String[] args) { // Declaración de variables.print ( “ Ingrese el sueldo del trabajador [ ” + ( i + 1) + “ ]: ” ) . } } while ( sueldos[i] <= 0 ) . numTrab = Lectura. int i. Clase PrgTrabajadores01 package dominioDeLaAplicacion .println ( “ Aumento del trabajador [ ” + ( i + 1) + “ ] es : ” + aumento ) . Ing. double aumento = 0 .round (aumento * 100) ) / 100. // Ingreso de datos al arreglo sueldos[ ] con consistencia de datos.out.

Si el trabajador tiene un sueldo mayor a S/. ‰ Datos necesarios: El número de trabajadores de la empresa y el sueldo de cada uno de ellos. se almacena el resultado en una variable (sueldoNeto).00 nuevos soles se le descontará el 15% de su sueldo por impuestos y se almacena en una variable (descuento).1. ‰ Resultado deseado: Mostrar el sueldo neto a cobrar por cada trabajador de la empresa. se determina el sueldo neto ((sueldo – descuento + aumento). Luego. Pag. Etapa 02 . y se almacena en una variable (aumento).Descripción del problema. ‰ Procesamiento: El número de trabajadores se ingresa a través del teclado y se almacena en una variable (numTrab).1600.1000. por cada trabajador. Consistenciar los datos ingresados. Problema 138 Etapa 01 . Mostrar el sueldo neto a cobrar por cada trabajador redondeado a dos decimales. Si el trabajador tiene un sueldo menor a S/. Desarrollar una solución que permita ingresar y almacenar el sueldo de todos los trabajadores de una empresa.1000.Definición de la solución. A todos los empleados cuyo sueldo sea mayor a S/.600. 453 .00 nuevos soles se le deberá descontar 15% por impuestos y a todos los trabajadores cuyo sueldo sea menor a S/. se le aumenta el 10% de su sueldo por concepto de refrigerio y movilidad. Con el número de trabajadores se crea un arreglo (sueldos[ ]).00 nuevos soles se le deberá aumentar el 10% por concepto de refrigerio y movilidad. Luego se procede a ingresar los sueldos de cada trabajador y se almacenan en el arreglo creado. se redondea y se muestra por pantalla. Después.ESTRUCTURAS DE DATOS – Arreglos.00 nuevos soles. en base a su sueldo se determina su descuento o su aumento.

Juan José Flores Cueto.Diseño de la lógica. Clases Clases dominioDeLaAplicacion biblioteca Pag. Diagrama de paquetes 3. 1. Nombre del Proyecto: ProyTrabajadores. Ing. Definición de las Clases. Etapa 03 . 2. Definición de Paquetes y desarrollo del Diagrama de Paquetes. 454 .

descuento = 0.ESTRUCTURAS DE DATOS – Arreglos.10 FINSI sueldoNeto = sueldos[i] – descuento + aumento sueldoNeto = sueldoNeto REDONDEA 2 ESCRIBIR sueldoNeto FINDESDE FIN Pag.. sueldos[ ] SALIDA: sueldoNeto INICIO COMENTARIO “Declaración de variables” NUMERO i.método main ( ) ENTRADA: numTrab. Diseño de algoritmo para el método principal.15 FINSI SI ( sueldos[i] < 1000 ) aumento = sueldos[i] * 0.1 INCREMENTA 1 descuento = 0 aumento = 0 SI ( sueldos[i] > 1600 ) ENTONCES descuento = sueldos[i] * 0. Algoritmo PrgTrabajadores02 . aumento = 0 NUMERO sueldoNeto COMENTARIO “Determinación del tamaño del arreglo” HACER LEER numTrab SI (numTrab <= 0 ) ENTONCES ESCRIBIR “Número de trabajadores no válido… ” FINSI MIENTRAS (numTrab <= 0 ) COMENTARIO “Creación del arreglo” CREAR sueldos [numTrab] COMENTARIO “Ingreso de datos al arreglo sueldos[ ]” DESDE i = 0 HASTA i = numTrab . ” FINSI MIENTRAS ( sueldos[i] <= 0 ) FINDESDE COMENTARIO “Cálculo del sueldo neto de cada trabajador” DESDE i = 0 HASTA i = numTrab . 455 . sueldos[ ]. 4..1 INCREMENTA 1 HACER LEER sueldos[i] SI ( sueldos[i] <= 0 ) ENTONCES ESCRIBIR “Sueldo ingresado no es válido. numTrab.

println ( “ El número de trabajadores no es válido… Reintente! ” ) .print ( “ Ingrese el sueldo del trabajador [ ” + ( i + 1) + “ ]: ” ) . Etapa 04 .out. Ing. double aumento = 0. i++ ) { descuento = 0 .0 . int i. if ( sueldos[i] > 1600 ) descuento = sueldos[i] * 0. // Declaración y creación del arreglo. for ( i = 0 . i++ ) { do { System.round (sueldoNeto * 100) ) / 100.println ( “ Sueldo ingresado no es válido… Reintente! ” ) .out. Juan José Flores Cueto.* . if ( numTrab <= 0 ) { System.out.print ( “ El sueldo neto del trabajador [ ” + ( i + 1) + “ ] es : ” ) .Desarrollo de la Codificación. } } } Pag. numTrab . sueldos[i] = Lectura. sueldoNeto = ( Math. 456 .10 . import biblioteca. i < numTrab . if ( sueldos[i] < 1000 ) aumento = sueldos[i] * 0. } } while ( numTrab <= 0 ) . Clase PrgTrabajadores02 package dominioDeLaAplicacion . do { System. double sueldos[ ] = new double [numTrab] .15 . public class PrgTrabajadores02 { public static void main(String[] args) { // Declaración de variables. sueldoNeto = sueldos[i] – descuento + aumento . for ( i = 0 . } // Cálculo del sueldo neto de cada trabjador.out. // Determinación del tamaño del arreglo con consistencia de datos. numTrab = Lectura.out. if ( sueldos[i] <= 0 ) { System. System. } } while ( sueldos[i] <= 0 ) . System.leerInt( ) .println ( sueldoNeto ) . i < numTrab .out. aumento = 0 .print ( “ Ingrese el número de trabajadores de la empresa : ” ) .leerDouble( ) . // Ingreso de datos al arreglo sueldos[ ] con consistencia de datos. descuento = 0 .

Descripción del problema. ‰ Datos necesarios: El número de trabajadores de la empresa y el sueldo de cada uno de ellos.1. Después.00 nuevos soles se le aumenta el 20% de su sueldo y no se le realiza ningún descuento.ESTRUCTURAS DE DATOS – Arreglos. su aumento y su respectivo descuento. por cada trabajador.600. En otros casos el aumento es del 10% de su sueldo y el descuento es de Pag. Calcular y mostrar el sueldo neto de cada trabajador. Desarrollar una solución que permita ingresar y almacenar el sueldo de todos los trabajadores de una empresa. se le aumenta el 5% de su sueldo y se le descuenta 15%. ‰ Resultado deseado: Mostrar el sueldo neto a cobrar por cada trabajador de la empresa. Consistenciar los datos ingresados.Definición de la solución. Adicionalmente. También mostrar el monto total que paga la empresa por concepto de sueldos.410. Con el número de trabajadores se crea un arreglo (sueldos[ ]).00 nuevos soles. 457 . su aumento y su respectivo descuento en base a la tabla mostrada (redondear dichas cantidades a dos decimales). mostrar el monto total que paga la empresa por concepto de sueldos. Condición Aumento Descuento sueldo < 410 20% 00 % sueldo >= 410 y sueldo <= 1600 10% 08 % sueldo > 1600 05% 15 % Etapa 02 . Si el trabajador tiene un sueldo menor a S/. ‰ Procesamiento: El número de trabajadores se ingresa a través del teclado y se almacena en una variable (numTrab). en base a su sueldo se determina su respectivo aumento y descuento. Si el trabajador tiene un sueldo mayor a S/. Luego se procede a ingresar los sueldos de cada trabajador y se almacenan en el arreglo creado. Problema 139 Etapa 01 .

El sueldo neto obtenido se suma a una variable acumulador (sueldoTotal). Después de finalizar el cálculo del sueldo neto de cada trabajador se muestra por pantalla el contenido de la variable acumulador sueldoTotal. se redondea y se muestra por pantalla. Diagrama de paquetes Pag. También se muestra el aumento y el descuento calculado. Definición de Paquetes y desarrollo del Diagrama de Paquetes. Nombre del Proyecto: ProyTrabajadores. 1. 8%. Juan José Flores Cueto. se determina el sueldo neto ((sueldo – descuento + aumento). Luego. 2. se almacena el resultado en una variable (sueldoNeto). Ing. 458 . El aumento se almacena en una variable (aumento) y el descuento en otra variable (descuento).Diseño de la lógica. Etapa 03 .

Algoritmo PrgTrabajadores03 . numTrab. descuento. aumento = 0. sueldoTotal INICIO COMENTARIO “Declaración de variables” NUMERO i. sueldos[ ]. 459 . sueldoTotal = 0 COMENTARIO “Determinación del tamaño del arreglo” HACER LEER numTrab SI (numTrab <= 0 ) ENTONCES ESCRIBIR “Número de trabajadores no válido… ” FINSI MIENTRAS (numTrab <= 0 ) COMENTARIO “Creación del arreglo” CREAR sueldos [numTrab] Pag. 3. aumento. Clases Clases dominioDeLaAplicacion biblioteca 4. Diseño de algoritmo para el método principal. Definición de las Clases. sueldos[ ] SALIDA: sueldoNeto.método main ( ) ENTRADA: numTrab. descuento = 0 NUMERO sueldoNeto.ESTRUCTURAS DE DATOS – Arreglos.

10 descuento = sueldos[i] * 0. Ing. Continúa… 4. aumento.15 SINO aumento = sueldos[i] * 0.. ” FINSI MIENTRAS ( sueldos[i] <= 0 ) FINDESDE COMENTARIO “Cálculo del sueldo neto.05 descuento = sueldos[i] * 0.método main ( ) COMENTARIO “Ingreso de datos al arreglo sueldos[ ]” DESDE i = 0 HASTA i = numTrab .2 descuento = 0 SINO SI ( sueldos[i] > 1600 ) aumento = sueldos[i] * 0. descuento sueldoTotal = sueldoTotal + sueldoNeto FINDESDE ESCRIBIR sueldoTotal FIN Pag. Algoritmo PrgTrabajadores03 .. Juan José Flores Cueto.08 FINSI FINSI sueldoNeto = sueldos[i] – descuento + aumento sueldoNeto = sueldoNeto REDONDEA 2 aumento = aumento REDONDEA 2 descuento = descuento REDONDEA 2 ESCRIBIR sueldoNeto. Diseño de algoritmo para el método principal. aumento y descuento por trabajador.1 INCREMENTA 1 SI ( sueldos[i] < 410 ) ENTONCES aumento = sueldos[i] * 0.1 INCREMENTA 1 HACER LEER sueldos[i] SI ( sueldos[i] <= 0 ) ENTONCES ESCRIBIR “Sueldo ingresado no es válido. y del total de sueldos ” DESDE i = 0 HASTA i = numTrab . 460 .

461 . for ( i = 0 .print ( “ Ingrese el sueldo del trabajador [ ” + ( i + 1) + “ ]: ” ) . double aumento = 0.out. public class PrgTrabajadores03 { public static void main(String[] args) { // Declaración de variables. // Ingreso de datos al arreglo sueldos[ ] con consistencia de datos. i++ ) { do { System. sueldoNeto. if ( numTrab <= 0 ) { System. numTrab = Lectura. } } while ( numTrab <= 0 ) . Clase PrgTrabajadores03 package dominioDeLaAplicacion .out.println ( “ Sueldo ingresado no es válido… Reintente! ” ) .println ( “ El número de trabajadores no es válido… Reintente! ” ) . sueldoTotal = 0 .out. if ( sueldos[i] <= 0 ) { System. sueldos[i] = Lectura. import biblioteca. // Determinación del tamaño del arreglo con consistencia de datos. } Pag. descuento = 0. numTrab .out. } } while ( sueldos[i] <= 0 ) .print ( “ Ingrese el número de trabajadores de la empresa : ” ) . Etapa 04 .leerDouble( ) . i < numTrab . do { System.Desarrollo de la Codificación.ESTRUCTURAS DE DATOS – Arreglos. int i. double sueldos[ ] = new double [numTrab] .leerInt( ) . // Declaración y creación del arreglo.* .

aumento y descuento por trabajador. Juan José Flores Cueto. sueldoNeto = ( Math. System. i++ ) { if ( sueldos[i] < 410 ) { aumento = sueldos[i] * 0.round (aumento * 100) ) / 100.round (descuento * 100) ) / 100.Desarrollo de la Codificación. Clase PrgTrabajadores03 // Cálculo del sueldo neto. } } Pag.out.println ( sueldoNeto ) . System. } } sueldoNeto = sueldos[i] + aumento – descuento . System.05 .println ( “ Su aumento es : ” + aumento ) .out. Continúa… Etapa 04 . Ing. } else { if ( sueldos[i] > 1600 ) { aumento = sueldos[i] * 0.2 .round (sueldoNeto * 100) ) / 100.08 . } System.out.print ( “ El sueldo neto del trabajador [ ” + ( i + 1) + “ ] es : ” ) .out.out. System. sueldoTotal = sueldoTotal + sueldoNeto . descuento = sueldos[i] * 0. y del total de sueldos.15 .0 .10 .println ( “ Monto total pagado por concepto de sueldos : ” + sueldoTotal ) .println ( “ Su descuento es : ” + descuento ) . i < numTrab .0 . descuento = sueldos[i] * 0.0 . descuento = ( Math. 462 . aumento = ( Math. for ( i = 0 . descuento = 0 . } else { aumento = sueldos[i] * 0.

Problema 140 Etapa 01 . Desarrollar una solución que permita ingresar y almacenar las horas trabajadas y la tarifa horaria de todos los trabajadores de una empresa.Definición de la solución.ESTRUCTURAS DE DATOS – Arreglos. se determina el sueldo neto ((horas trabajadas * tarifa horaria * 1. ‰ Datos necesarios: El número de trabajadores de la empresa.Diseño de la lógica. ‰ Procesamiento: El número de trabajadores se ingresa a través del teclado y se almacena en una variable (numTrab). se almacena el resultado en una variable (sueldoNeto).Descripción del problema. Nombre del Proyecto: ProyTrabajadores. Calcular y mostrar el sueldo neto de cada trabajador.15). se redondea y se muestra por pantalla. Con el número de trabajadores se crea un arreglo (sueldos[ ][ ]). Etapa 03 . y las horas trabajadas y la tarifa horaria de cada uno de ellos. 463 . Luego se procede a ingresar las horas trabajadas y la tarifa horaria de cada trabajador y se almacenan en el arreglo creado. por cada trabajador. sabiendo que se tiene que descontar el 10% por impuestos y el 5% por seguro. Etapa 02 . ‰ Resultado deseado: Mostrar el sueldo de cada trabajador de la empresa. Pag. 1. Después.

Juan José Flores Cueto. Definición de Paquetes y desarrollo del Diagrama de Paquetes. Diagrama de paquetes 3. Ing. 464 . Definición de las Clases. Clases Clases dominioDeLaAplicacion biblioteca Pag. 2.

sueldos[ ][ ].1 INCREMENTA 1 HACER COMENTARIO “Ingreso de las horas trabajadas” LEER sueldos[i][0] SI ( sueldos[i][0] <= 0 ) ENTONCES ESCRIBIR “Número de horas no válida. sueldoNeto COMENTARIO “Determinación del tamaño del arreglo” HACER LEER numTrab SI (numTrab <= 0 ) ENTONCES ESCRIBIR “Número de trabajadores no válido… ” FINSI MIENTRAS (numTrab <= 0 ) COMENTARIO “Creación del arreglo” CREAR sueldos [numTrab][2] COMENTARIO “Ingreso de datos al arreglo sueldos[ ][ ]” DESDE i = 0 HASTA i = numTrab . Algoritmo PrgTrabajadores04 .85 ESCRIBIR sueldoNeto FINDESDE FIN Pag. ” FINSI MIENTRAS ( sueldos[i][0] <= 0 ) HACER COMENTARIO “Ingreso de la tarifa horaria” LEER sueldos[i][1] SI ( sueldos[i][1] <= 0 ) ENTONCES ESCRIBIR “Tarifa horaria no válida.. 465 . 4.... numTrab. ” FINSI MIENTRAS ( sueldos[i][1] <= 0 ) FINDESDE COMENTARIO “Cálculo del sueldo neto de cada trabajador” DESDE i = 0 HASTA i = numTrab .método main ( ) ENTRADA: numTrab. sueldos[ ][ ] SALIDA: sueldoNeto INICIO COMENTARIO “Declaración de variables” NUMERO i. Diseño de algoritmo para el método principal.ESTRUCTURAS DE DATOS – Arreglos.1 INCREMENTA 1 sueldoNeto = sueldo[i][0] * sueldo[i][1] * 0.

out. numTrab = Lectura. i++ ) { System. for ( i = 0 . } } while ( sueldos[i][0] <= 0 ) . if ( numTrab <= 0 ) { System.leerDouble( ) .* .leerInt( ) .out. sueldos[i][0] = Lectura. import biblioteca.println ( “Número de horas trabajadas no válida… ” ) .println ( “ El número de trabajadores no es válido… Reintente! ” ) . int i.out.print ( “ Tarifa horaria: ” ) . // Ingreso de datos al arreglo sueldos[ ][ ] con consistencia de datos.out. public class PrgTrabajadores04 { public static void main(String[] args) { // Declaración de variables. 466 . do { System. do { System.out. Juan José Flores Cueto. i < numTrab . if ( sueldos[i][1] <= 0 ) { System.Desarrollo de la Codificación. numTrab .print ( “ Ingrese el número de trabajadores de la empresa : ” ) . sueldos[i][1] = Lectura. double sueldoNeto . // Declaración y creación del arreglo.println ( “ Ingrese los datos del trabajador [ ” + ( i + 1) + “ ]: ” ) . Etapa 04 . // Determinación del tamaño del arreglo con consistencia de datos. } } while ( sueldos[i][1] <= 0 ) .println ( “ Tarifa horaria no válida… ” ) . Ing. do { System. Clase PrgTrabajadores04 package dominioDeLaAplicacion . } Pag.leerDouble( ) .out. if ( sueldos[i][0] <= 0 ) { System. } } while ( numTrab <= 0 ) . double sueldos[ ][ ] = new double [numTrab][2] .print ( “ Número de horas trabajadas: ” ) .out.

ESTRUCTURAS DE DATOS – Arreglos. System.print ( “ El sueldo neto del trabajador [ ” + ( i + 1) + “ ] es : ” ) .Desarrollo de la Codificación. i++ ) { sueldoNeto = sueldos[i][0] * sueldos[i][1] * 0. Clase PrgTrabajadores04 // Cálculo del sueldo neto de cada trabajador. Continúa… Etapa 04 . for ( i = 0 .out. i < numTrab .println ( sueldoNeto ) . 467 .out.85 . } } } Pag. System.

25 ) + ( 48 * tarifa horaria) En caso contrario se determina de la siguiente forma: ( horas trabajadas * tarifa horaria ) El sueldo bruto se almacena en una variable (sueldoBruto). ‰ Datos necesarios: El número de trabajadores de la empresa. Pag. 468 . al trabajador se le descuenta el 15%. ‰ Procesamiento: El número de trabajadores se ingresa a través del teclado y se almacena en una variable (numTrab).1.600. equivalente al 15% del sueldo. Problema 141 Etapa 01 . Juan José Flores Cueto. Luego se procede a ingresar las horas trabajadas y la tarifa horaria de cada trabajador y se almacenan en el arreglo creado. Mostrar el sueldo total (sueldo bruto) y el sueldo a cobrar (sueldo neto) de cada trabajador redondeado a dos decimales. Con el número de trabajadores se crea un arreglo (sueldos[ ][ ]). se ha establecido un aumento a todos los trabajadores. Ing.Definición de la solución. ‰ Resultado deseado: Mostrar el sueldo de cada trabajador de la empresa. el sueldo bruto se determina de la siguiente forma: ( horas trabajadas – 48 ) * ( tarifa horaria * 1.Descripción del problema.00 nuevos soles.500. y las horas trabajadas y la tarifa horaria de cada uno de ellos. se paga la tarifa con un recargo del 25%. si el sueldo es superior a S/.00 nuevos soles. Adicionalmente.3. Si el número de horas trabajadas es mayor a 48 horas. Desarrollar una solución que permita ingresar y almacenar las horas trabajadas y la tarifa horaria de todos los trabajadores de una empresa. se determina el sueldo bruto. por cada trabajador. Etapa 02 . Después. sabiendo que hasta 48 horas trabajadas se paga una tarifa normal y sobre las 48 horas. Calcular y mostrar el sueldo de cada trabajador. al trabajador se le descuenta el 10% y si el sueldo es superior a S/. Por otro lado.

En todos los casos el descuento se almacena en una variable (descuento).3. Definición de Paquetes y desarrollo del Diagrama de Paquetes. Si el sueldo bruto es menor o igual a S/. Después. se determina el descuento y el aumento de sueldo.500.00 nuevos soles y si el sueldo bruto es mayor a S/. Nombre del Proyecto: ProyTrabajadores. Si el sueldo bruto es mayor a S/. Luego.00 nuevos soles.00 nuevos soles.1600.500. El sueldo neto y el sueldo bruto se redondean a dos decimales y se muestran por pantalla. 2. Etapa 03 . Diagrama de paquetes Pag. 1. se calcula el descuento del 15%. Caso contrario el descuento es cero. 469 . se calcula el descuento del 10%.Diseño de la lógica.3. se calcula el aumento del 15% del sueldo y se almacena en la variable (aumento). Finalmente se realiza el calculo del sueldo neto (sueldoBruto + aumento – descuento) y se almacena en una variable (sueldoNeto). por cada trabajador.ESTRUCTURAS DE DATOS – Arreglos.

Algoritmo PrgTrabajadores05 . descuento NUMERO sueldoNeto. sueldoBruto COMENTARIO “Determinación del tamaño del arreglo” HACER LEER numTrab SI (numTrab <= 0 ) ENTONCES ESCRIBIR “Número de trabajadores no válido… ” FINSI MIENTRAS (numTrab <= 0 ) COMENTARIO “Creación del arreglo” CREAR sueldos [2][numTrab] Pag. Juan José Flores Cueto. numTrab. 3. Clases Clases dominioDeLaAplicacion biblioteca 4. Diseño de algoritmo para el método principal. sueldos[ ][ ].método main ( ) ENTRADA: numTrab. sueldos[ ][ ] SALIDA: sueldoBruto. sueldoNeto INICIO COMENTARIO “Declaración de variables” NUMERO i. Ing. Definición de las Clases. 470 .

.1 INCREMENTA 1 HACER COMENTARIO “Ingreso de las horas trabajadas” LEER sueldos[0][i] SI ( sueldos[0][i] <= 0 ) ENTONCES ESCRIBIR “Número de horas no válida.10 SINO descuento = 0 FINSI FINSI aumento = sueldoBruto * 0. sueldoNeto FINDESDE FIN Pag. Continúa… 4. Diseño de algoritmo para el método principal.. 471 . Algoritmo PrgTrabajadores05 .método main ( ) COMENTARIO “Ingreso de datos al arreglo sueldos[ ][ ]” DESDE i = 0 HASTA i = numTrab .25) + (48 * sueldos[1][i]) SINO sueldoBruto = sueldos[0][i] * sueldos[1][i] FINSI SI ( sueldoBruto > 3500 ) ENTONCES descuento = sueldoBruto * 0..ESTRUCTURAS DE DATOS – Arreglos.. ” FINSI MIENTRAS ( sueldos[0][i] <= 0 ) HACER COMENTARIO “Ingreso de la tarifa horaria” LEER sueldos[1][i] SI ( sueldos[1][i] <= 0 ) ENTONCES ESCRIBIR “Tarifa horaria no válida. ” FINSI MIENTRAS ( sueldos[1][i] <= 0 ) FINDESDE COMENTARIO “Cálculo del sueldo bruto y neto por trabajador” DESDE i = 0 HASTA i = numTrab .1 INCREMENTA 1 SI ( sueldos[0][i] > 48 ) ENTONCES sueldoBruto = (sueldos[0][i] – 48) * (sueldos[1][i] * 1.15 sueldoNeto = sueldoBruto + aumento – descuento sueldoBruto = sueldoBruto REDONDEA 2 sueldoNeto = sueldoNeto REDONDEA 2 ESCRIBIR sueldoBruto.15 SINO SI (suesldoBruto > 1600 ) ENTONCES descuento = sueldoBruto * 0.

out. // Declaración y creación del arreglo. do { System. Ing.println ( “ Ingrese los datos del trabajador [ ” + ( i + 1) + “ ]: ” ) .print ( “ Ingrese el número de trabajadores de la empresa : ” ) . if ( numTrab <= 0 ) { System. // Ingreso de datos al arreglo sueldos[ ][ ] con consistencia de datos.out. i < numTrab . for ( i = 0 . double sueldos[ ][ ] = new double[2][numTrab] . public class PrgTrabajadores05 { public static void main(String[] args) { // Declaración de variables. Juan José Flores Cueto. if ( sueldos[0][i] <= 0 ) { System. numTrab = Lectura. i++ ) { System.leerInt( ) . // Determinación del tamaño del arreglo con consistencia de datos.leerDouble( ) .out.out. Clase PrgTrabajadores05 package dominioDeLaAplicacion . } } while ( numTrab <= 0 ) .print ( “ Número de horas trabajadas: ” ) . } } while ( sueldos[1][i] <= 0 ) . Etapa 04 .* .out. int i. numTrab . import biblioteca.println ( “ El número de trabajadores no es válido… Reintente! ” ) . 472 . do { System.println ( “Número de horas trabajadas no válida… ” ) . sueldos[1][i] = Lectura.Desarrollo de la Codificación. } } while ( sueldos[0][i] <= 0 ) . } Pag.leerDouble( ) . double sueldoNeto .print ( “ Tarifa horaria: ” ) .out. do { System. sueldos[0][i] = Lectura.println ( “ Tarifa horaria no válida… ” ) .out. if ( sueldos[1][i] <= 0 ) { System.

15 .sueldos[1][i] ) . 473 .0 . } else { sueldoBruto = sueldos[0][i] * sueldos[1][i] ) .out. } } aumento = sueldoBruto * 0.round (sueldoNeto * 100) ) / 100. Clase PrgTrabajadores05 // Cálculo del sueldo bruto y neto por trabajador.println ( ) . sueldoNeto = sueldoBruto + aumento – descuento . System.Desarrollo de la Codificación.println ( “ Sueldo bruto : ” + sueldoBruto ) . sueldoNeto = ( Math. System. System. } } } Pag.ESTRUCTURAS DE DATOS – Arreglos.round (sueldoBruto * 100) ) / 100. i < numTrab .out. Continúa… Etapa 04 .println ( “ Trabajador [ ” + ( i + 1) + “ ] ” ) . } else { descuento = 0 . System.15 .0 . } else { if ( sueldoBruto > 1600 ) { descuento = sueldoBruto * 0.println ( “ Sueldo neto : ” + sueldoNeto ) .25) + (48 . for ( i = 0 .10 .out. i++ ) { if ( sueldos[0][i] > 48 ) { sueldoBruto = ( sueldos[0][i] – 48) * (sueldos[1][i] * 1. sueldoBruto = ( Math.out. } if ( sueldoBruto > 3500 ) { descuento = sueldoBruto * 0.

Desarrollar una solución que permita ingresar y almacenar el nombre de todos los artículos de una bodega.Diseño de la lógica. Etapa 02 . luego se eliminan los espacios del inicio y final del nombre. Después. Problema 142 Etapa 01 . Etapa 03 . ‰ Datos necesarios: El número de artículos y el nombre de cada uno de los artículos. Mostrar cada uno de los nombre con su respectiva longitud. 2. Juan José Flores Cueto. ‰ Procesamiento: El número de artículos se ingresa a través del teclado y se almacena en una variable (numArt). se determina su longitud. Consistenciar la entrada de datos. ‰ Resultado deseado: Mostrar el nombre y la longitud del nombre de todos los artículos de una bodega. Con el número de artículos se crea un arreglo (articulos[ ]). se almacena en una variable (tamaño) y se muestra por pantalla. para cada uno de los nombres. se almacenan temporalmente en una variable (sueldo). Luego se procede a ingresar el nombre de los artículos de la bodega. 474 . Nombre del Proyecto: ProyArticulos. Ing. Diagrama de paquetes Pag. y se almacenan en el arreglo creado. 1.Definición de la solución. Definición de Paquetes y desarrollo del Diagrama de Paquetes.Descripción del problema.

475 . 3. nombre COMENTARIO “Determinación del tamaño del arreglo” HACER LEER numArt SI (numArt <= 0 ) ENTONCES ESCRIBIR “Número de artículos no válido… ” FINSI MIENTRAS (numArt <= 0 ) COMENTARIO “Creación del arreglo” CREAR articulos [numArt] Pag. Clases Clases dominioDeLaAplicacion biblioteca 4. tamaño TEXTO articulos[ ].ESTRUCTURAS DE DATOS – Arreglos. Algoritmo PrgArticulos01 . Diseño de algoritmo para el método principal. numArt. Definición de las Clases. nombres SALIDA: tamaño INICIO COMENTARIO “Declaración de variables” NUMERO i.método main ( ) ENTRADA: numArt.

numArt = Lectura.método main ( ) COMENTARIO “Ingreso de datos al arreglo articulos [ ]” DESDE i = 0 HASTA i = numArt . // Determinación del tamaño del arreglo con consistencia de datos. Diseño de algoritmo para el método principal.” FINSI MIENTRAS (LONGITUD articulos[i] < 3 ) FINDESDE COMENTARIO “Cálculo de la longitud de los nombres” DESDE i = 0 HASTA i = numArt .. import biblioteca. int i. } } while ( numArt <= 0 ) . do { System.out.print ( “ Ingrese el número de artículos : ” ) .Desarrollo de la Codificación.. tamaño FINDESDE FIN Etapa 04 .println ( “ El número de artículos no es válido… Reintente! ” ) . Ing. Continúa… 4.* . 476 .out. if ( numArt <= 0 ) { System. Pag.1 INCREMENTA 1 HACER LEER nombre articulos[i] = nombre ELIMINAESPACIO INICIO.leerInt( ) . FIN SI ( LONGITUD articulos[i] < 3 ) ENTONCES ESCRIBIR “Nombre de artículo no válido. numArt. Clase PrgArticulos01 package dominioDeLaAplicacion .1 INCREMENTA 1 tamaño = LONGITUD articulos[i] ESCRIBIR articulos[i]. String nombre . Juan José Flores Cueto. public class PrgArticulos01 { public static void main(String[] args) { // Declaración de variables. Algoritmo PrgArticulos01 . tamaño .

print ( “ Ingrese el nombre del artículo [ ” + ( i + 1) + “]: ” ) . } } } Pag.length( ) . Continúa… Etapa 04 . for ( i = 0 . System. String articulos[ ] = new String [numArt] . } // Cálculo de la longitud de los nombres.ESTRUCTURAS DE DATOS – Arreglos.println ( “ Artículo ” + articulos[i] + “ tiene una longitud de ” + tamaño ) . i++ ) { do { System.length( ) < 3 ) { System. articulos[i] = nombre.leerString( ) .length( ) < 3 ) . nombre = Lectura. i < numArt . // Ingreso de datos al arreglo artículos[ ] con consistencia de datos.out. 477 .out.out. i++ ) { tamaño = articulos[i].trim( ) .println ( “ El nombre ingresado no es válido… Reintente! ” ) .Desarrollo de la Codificación. for ( i = 0 . Clase PrgArticulos01 // Declaración y creación del arreglo. } } while ( articulos[i]. if ( articulos[i]. i < numArt .

se determina la longitud del nombre y se almacena en una variable (tamaño). Luego se procede a ingresar el nombre de los artículos de la bodega. se obtiene la primera letra. Mostrar la primera letra de cada nombre en mayúscula y el resto en minúscula. ‰ Procesamiento: El número de artículos se ingresa a través del teclado y se almacena en una variable (numArt). Problema 143 Etapa 01 . Etapa 02 . se muestra la primera letra del nombre en mayúscula. y se almacenan en el arreglo creado. Pag. Juan José Flores Cueto.Descripción del problema. También. se obtiene las demás letras. Luego. Adicionalmente. mostrar la longitud de cada uno de los nombres. ‰ Resultado deseado: Mostrar la primera letra de todos los nombres en letra mayúscula y el resto en letra minúscula. Desarrollar una solución que permita ingresar y almacenar el nombre de todos los artículos de una bodega. para cada uno de los nombres. 478 . Ing. las demás letras en minúscula y la longitud del nombre por pantalla. Consistenciar la entrada de datos. se eliminan los espacios del inicio y final del nombre. se almacenan en una variable (resto) y se convierten en minúscula. se almacena en una variable (letra) y se convierte en mayúscula. ‰ Datos necesarios: El número de artículos y el nombre de cada uno de los artículos. Con el número de artículos se crea un arreglo (articulos[ ]). Finalmente. Después. Adicionalmente mostrar la longitud de cada uno de los nombres de los artículos.Definición de la solución.

ESTRUCTURAS DE DATOS – Arreglos. 2. 1. 479 . Nombre del Proyecto: ProyArticulos. Definición de las Clases. Etapa 03 .Diseño de la lógica. Diagrama de paquetes 3. Definición de Paquetes y desarrollo del Diagrama de Paquetes. Clases Clases dominioDeLaAplicacion biblioteca Pag.

1 letra = MAYUSCULA letra resto = articulos[i] SUBCADENA 1 resto = MINUSCULA resto tamaño = LONGITUD articulos[i] ESCRIBIR letra.” FINSI MIENTRAS (LONGITUD articulos[i] < 3 ) FINDESDE COMENTARIO “ Manipulación del nombre de los artículos ” DESDE i = 0 HASTA i = numArt . Algoritmo PrgArticulos02 . resto COMENTARIO “Determinación del tamaño del arreglo” HACER LEER numArt SI (numArt <= 0 ) ENTONCES ESCRIBIR “Número de artículos no válido… ” FINSI MIENTRAS (numArt <= 0 ) COMENTARIO “Creación del arreglo” CREAR articulos [numArt] COMENTARIO “Ingreso de datos al arreglo articulos [ ]” DESDE i = 0 HASTA i = numArt . numArt. resto. resto. tamaño INICIO COMENTARIO “Declaración de variables” NUMERO i. articulos[ ] SALIDA: letra. FIN SI ( LONGITUD articulos[i] < 3 ) ENTONCES ESCRIBIR “Nombre de artículo no válido. tamaño TEXTO articulos[ ]. Ing.. Juan José Flores Cueto. Diseño de algoritmo para el método principal. letra.método main ( ) ENTRADA: numArt. 480 . 4..1 INCREMENTA 1 HACER LEER articulos[i] articulos[i] = articulos[i] ELIMINAESPACIO INICIO.1 INCREMENTA 1 letra = articulos[i] SUBCADENA 0. tamaño FINDESDE FIN Pag.

articulos[i] = articulos[i].Desarrollo de la Codificación.out. String articulos[ ] = new String [numArt] .out. numArt = Lectura. i < numArt .println ( “ Artículo ” + letra + resto + “ tiene una longitud de ” + tamaño ) . Clase PrgArticulos02 package dominioDeLaAplicacion .println ( “ El número de artículos no es válido… Reintente! ” ) . for ( i = 0 . numArt.out. do { System. resto . resto = articulos[i].leerInt( ) . } } while ( numArt <= 0 ) . i++ ) { letra = articulos[i]. } // Manipulación del nombre de los artículos. // Ingreso de datos al arreglo articulos[ ] con consistencia de datos.print ( “ Ingrese el número de artículos : ” ) .leerString( ) .* . letra = letra.length( ) . int i.out.length( ) < 3 ) { System. if ( articulos[i].println ( “ El nombre ingresado no es válido… Reintente! ” ) . i++ ) { do { System. } } } Pag.trim( ) .print ( “ Ingrese el nombre del artículo [ ” + ( i + 1) + “]: ” ) . for ( i = 0 . tamaño . if ( numArt <= 0 ) { System. tamaño = articulos[i].toLowerCase( ) . articulos[i] = Lectura. resto = resto]. // Determinación del tamaño del arreglo con consistencia de datos.ESTRUCTURAS DE DATOS – Arreglos.length( ) < 3 ) . String letra.out. System. 481 . // Declaración y creación del arreglo.1) . i < numArt .toUpperCase( ).substring(1) . import biblioteca. Etapa 04 . public class PrgArticulos02 { public static void main(String[] args) { // Declaración de variables. } } while ( articulos[i].substring(0.

Luego se procede a ingresar el nombre de los artículos de la bodega. se obtiene la última letra. Finalmente. se obtiene la primera letra. se muestra por pantalla. ‰ Resultado deseado: Mostrar la primera letra de todos los nombres en letra mayúscula y el resto en letra minúscula. Desarrollar una solución que permita ingresar y almacenar el nombre de todos los artículos de una bodega. se almacena en una variable (letraIni) y se convierte en mayúscula. Después. Problema 144 Etapa 01 . Ing. Con el número de artículos se crea un arreglo (articulos[ ]). Pag. ‰ Datos necesarios: El número de artículos y el nombre de cada uno de los artículos.Definición de la solución. se almacenan en una variable (letraFin) y se convierten en minúscula. 482 . Adicionalmente mostrar la longitud de cada uno de los nombres de los artículos. ‰ Procesamiento: El número de artículos se ingresa a través del teclado y se almacena en una variable (numArt). se eliminan los espacios del inicio y final del nombre. Luego. Juan José Flores Cueto. la primera letra del nombre en mayúscula y la última letra del nombre en minúscula. y se almacenan en el arreglo creado. Consistenciar la entrada de datos. Mostrar la primera letra y la última letra de cada uno de los nombres en letra mayúscula y minúscula respectivamente. para cada uno de los nombres.Descripción del problema. Etapa 02 .

Diseño de la lógica. 2. Nombre del Proyecto: ProyArticulos. Diagrama de paquetes 3. Definición de las Clases. Etapa 03 .ESTRUCTURAS DE DATOS – Arreglos. 1. 483 . Definición de Paquetes y desarrollo del Diagrama de Paquetes. Clases Clases dominioDeLaAplicacion biblioteca Pag.

484 . letraFin FINDESDE FIN Pag. letraIni. letraFin COMENTARIO “Determinación del tamaño del arreglo” HACER LEER numArt SI (numArt <= 0 ) ENTONCES ESCRIBIR “Número de artículos no válido… ” FINSI MIENTRAS (numArt <= 0 ) COMENTARIO “Creación del arreglo” CREAR articulos [numArt] COMENTARIO “Ingreso de datos al arreglo articulos [ ]” DESDE i = 0 HASTA i = numArt . articulos[ ] SALIDA: letraIni.método main ( ) ENTRADA: numArt. Algoritmo PrgArticulos03 . FIN SI ( LONGITUD articulos[i] < 3 ) ENTONCES ESCRIBIR “Nombre de artículo no válido. 4. Juan José Flores Cueto.” FINSI MIENTRAS (LONGITUD articulos[i] < 3 ) FINDESDE COMENTARIO “ Manipulación del nombre de los artículos ” DESDE i = 0 HASTA i = numArt . Diseño de algoritmo para el método principal.. letraFin INICIO COMENTARIO “Declaración de variables” NUMERO i.1 INCREMENTA 1 HACER LEER articulos[i] articulos[i] = articulos[i] ELIMINAESPACIO INICIO. Ing.1 INCREMENTA 1 letraIni = articulos[i] CARACTER INICIO letraIni = MAYUSCULA letraIni letraFin = articulos[i] CARACTER FIN letraFin = MINUSCULA letraFin ESCRIBIR letraIni. numArt TEXTO articulos[ ]..

” ) .charAt (articulos[i].toLowerCase(letraFin) . i < numArt . i++ ) { do { System. 485 . for ( i = 0 . char letraIni.leerString( ) . do { System. letraFin = articulos[i].out.length( ) -1) . } // Manipulación del nombre de los artículos.trim( ) .println ( “ Artículo ” + articulos[i] ) .println ( ) .Desarrollo de la Codificación. System.out.charAt(0) . LetraFin = Character.print ( “ Ingrese el número de artículos : ” ) . } } while ( articulos[i].out. if ( articulos[i].length( ) < 3 ) . // Determinación del tamaño del arreglo con consistencia de datos.toUpperCase(letraIni) . // Declaración y creación del arreglo. import biblioteca. i < numArt .out. for ( i = 0 . // Ingreso de datos al arreglo artículos[ ] con consistencia de datos. articulos[i] = articulos[i]. if ( numArt <= 0 ) { System.ESTRUCTURAS DE DATOS – Arreglos.out. Letra final : ” + letraFin + “. } } while ( numArt <= 0 ) . System. String articulos[ ] = new String [numArt] . } } } Pag. letraFin .println ( “ Letra inicial : ” + letraIni + “.length( ) < 3 ) { System. i++ ) { letraIni = articulos[i]. Clase PrgArticulos03 package dominioDeLaAplicacion . public class PrgArticulos03 { public static void main(String[] args) { // Declaración de variables. int i. numArt = Lectura.print ( “ Ingrese el nombre del artículo [ ” + ( i + 1) + “]: ” ) .println ( “ El número de artículos no es válido… Reintente! ” ) .out. letraIni = Character.* . articulos[i] = Lectura.leerInt( ) .out.println ( “ El nombre ingresado no es válido… Reintente! ” ) . numArt . Etapa 04 . System.

Juan José Flores Cueto. . los resultados se muestran por pantalla. ‰ Procesamiento: El número de artículos se ingresa a través del teclado y se almacena en una variable (numArt).Definición de la solución. Ing. Finalmente. para cada uno de los nombres. mostrar las siglas del artículo en mayúscula. Etapa 02 . También mostrar las siglas del artículo en minúscula. Luego.Descripción del problema. la descripción y las siglas de cada uno de los artículos. ‰ Resultado deseado: Mostrar la primera letra de todos los nombres y las descripciones en letra mayúscula y el resto en letra minúscula. También. 486 . También. Desarrollar una solución que permita ingresar y almacenar el nombre. se convierte a mayúscula las siglas de cada artículo y se almacena en una variable (siglas). se obtiene las demás letras y se almacenan en una variable (resto). Mostrar la primera letra del nombre y la descripción en mayúscula y el resto en minúscula. se almacena en una variable (letra). y se almacenan en el arreglo creado. Consistenciar la entrada de datos. Pag. Problema 145 Etapa 01 . se obtiene la primera letra. el nombre. para cada una de las descripciones se realiza lo mismo y el resultado se almacenan en una variable (descrip). se eliminan los espacios del inicio y final de los mismos. ‰ Datos necesarios: El número de artículos y. Con el número de artículos se crea un arreglo (articulos[ ]). Luego se procede a ingresar el nombre. la descripción y las siglas de los artículos de la bodega. Después. la sigla y la descripción de todos los artículos de una bodega. Luego se convierte a mayúscula la variable letra y a minúscula la variable resto y se almacenan en una variable (nombre).

ESTRUCTURAS DE DATOS – Arreglos.

Etapa 03 - Diseño de la lógica.

1. Nombre del Proyecto: ProyArticulos.

2. Definición de Paquetes y desarrollo del Diagrama de Paquetes.

Diagrama de paquetes

3. Definición de las Clases.

Clases Clases
dominioDeLaAplicacion biblioteca

Pag. 487

Ing. Juan José Flores Cueto.

4. Diseño de algoritmo para el método principal.

Algoritmo PrgArticulos04 - método main ( )

ENTRADA: numArt, articulos[ ][ ]
SALIDA: nombre, descrip, siglas

INICIO

COMENTARIO “Declaración de variables”
NUMERO i, numArt
TEXTO articulos[ ][ ], nombre, descrip, siglas

COMENTARIO “Determinación del tamaño del arreglo”
HACER
LEER numArt
SI (numArt <= 0 )
ENTONCES
ESCRIBIR “Número de artículos no válido… ”
FINSI
MIENTRAS (numArt <= 0 )

COMENTARIO “Creación del arreglo”
CREAR articulos [numArt][3]

COMENTARIO “Ingreso de datos al arreglo articulos [ ]”
DESDE i = 0 HASTA i = numArt - 1 INCREMENTA 1

HACER

COMENTARIO “ Ingreso del nombre de los artículos ”
LEER articulos[i][0]
articulos[i][0] = articulos[i][0] ELIMINAESPACIO INICIO
articulos[i][0] = articulos[i][0] ELIMINAESPACIO FIN
SI ( LONGITUD articulos[i][0] < 3 )
ENTONCES
ESCRIBIR “Nombre de artículo no válido...”
FINSI
MIENTRAS (LONGITUD articulos[i][0] < 3 )

HACER

COMENTARIO “ Ingreso descripción de los artículos ”
LEER articulos[i][1]
articulos[i][1] = articulos[i][1] ELIMINAESPACIO INICIO
articulos[i][1] = articulos[i][1] ELIMINAESPACIO FIN
SI ( LONGITUD articulos[i][1] < 3 )
ENTONCES
ESCRIBIR “Descripción de artículo no válida...”
FINSI
MIENTRAS (LONGITUD articulos[i][1] < 3 )

Pag. 488

ESTRUCTURAS DE DATOS – Arreglos.

Continúa… 4. Diseño de algoritmo para el método principal.

Algoritmo PrgArticulos04 - método main ( )

HACER
COMENTARIO “ Ingreso siglas de los artículos ”

LEER articulos[i][2]

articulos[i][2] = articulos[i][2] ELIMINAESPACIO INICIO
articulos[i][2] = articulos[i][2] ELIMINAESPACIO FIN

SI ( LONGITUD articulos[i][2] < 3 )
ENTONCES
ESCRIBIR “Sigla de artículo no válida...”
FINSI

MIENTRAS (LONGITUD articulos[i][2] < 3 )

FINDESDE

COMENTARIO “Manipulación del nombre de los artículos”
DESDE i = 0 HASTA i = numArt - 1 INCREMENTA 1

letra = articulos[i][0] SUBCADENA 0,1
resto = articulos[i][0] SUBCADENA 1
nombre = MAYUSCULA letra + MINUSCULA resto

letra = articulos[i][1] SUBCADENA 0,1
resto = articulos[i][1] SUBCADENA 1
descrip = MAYUSCULA letra + MINUSCULA resto

siglas = MAYUSCULA articulos[i][2]

ESCRIBIR nombre, descrip, siglas
FINDESDE

FIN

Pag. 489

Ing. Juan José Flores Cueto.

Etapa 04 - Desarrollo de la Codificación.

Clase PrgArticulos04

package dominioDeLaAplicacion ;

import biblioteca.* ;
public class PrgArticulos04 {

public static void main(String[] args) {

// Declaración de variables.
int i, numArt ;
String letra, resto, nombre, descrip, siglas ;

// Determinación del tamaño del arreglo con consistencia de datos.
do {
System.out.print ( “ Ingrese el número de artículos : ” ) ;
numArt = Lectura.leerInt( ) ;

if ( numArt <= 0 ) {
System.out.println ( “ El número de artículos no es válido… Reintente! ” ) ;
}
} while ( numArt <= 0 ) ;

// Declaración y creación del arreglo.
String articulos[ ][ ] = new String [numArt][3] ;

// Ingreso de datos al arreglo artículos[ ][ ] con consistencia de datos.
for ( i = 0 ; i < numArt ; i++ ) {
do {
System.out.print ( “ Ingrese el nombre del artículo [ ” + ( i + 1) + “ ]: ” ) ;
articulos[i][0] = Lectura.leerString( ) ;
articulos[i][0] = articulos[i][0].trim( ) ;

if (articulos[i][0].length( ) < 3 ) {
System.out.println ( “ El nombre ingresado no es válido… ” ) ;
}
} while (articulos[i][0].length( ) < 3 ) ;

do {
System.out.print ( “ Ingrese la descripción del artículo [ ” + ( i + 1) + “ ]: ” ) ;
articulos[i][1] = Lectura.leerString( ) ;
articulos[i][1] = articulos[i][1].trim( ) ;

if (articulos[i][1].length( ) < 3 ) {
System.out.println ( “ La descripción ingresada no es válida… ” ) ;
}
} while (articulos[i][1].length( ) < 3 ) ;

Pag. 490

ESTRUCTURAS DE DATOS – Arreglos.

Continúa… Etapa 04 - Desarrollo de la Codificación.

Clase PrgArticulos04

do {
System.out.print ( “ Ingrese la sigla del artículo [ ” + ( i + 1) + “ ]: ” ) ;
articulos[i][2] = Lectura.leerString( ) ;
articulos[i][2] = articulos[i][2].trim( ) ;

if (articulos[i][2].length( ) < 3 ) {
System.out.println ( “ La sigla ingresada no es válida… ” ) ;
}
} while (articulos[i][2].length( ) < 3 ) ;

}

// Manipulación del nombres, descripción y sigla de los artículos
for ( i = 0 ; i < numArt ; i++ ) {

letra = articulos[i][0].substring(0,1) ;
resto = articulos[i][0].substring(1) ;
nombre = letra.toUpperCase( ) + resto.toLowerCase( ) ;

letra = articulos[i][1].substring(0,1) ;
resto = articulos[i][1].substring(1) ;
descrip = letra.toUpperCase( ) + resto.toLowerCase( ) ;

siglas = articulos[i][2].toUpperCase( ) ;

System.out.println ( “ Artículo ” + ( i+1 ) ) ;
System.out.println ( “ ---------------------- ” ) ;
System.out.println ( “ Nombre: ” + nombre + “.” ) ;
System.out.println ( “ Descripción: ” + descrip + “.” ) ;
System.out.println ( “ Siglas: ” + siglas + “.” ) ;
System.out.println ( ) ;

}
}
}

Pag. 491

Ing. Juan José Flores Cueto.

Pag. 492

ESTRUCTURAS DE DATOS – Arreglos.

DESARROLLO DE SOLUCIONES UTILIZANDO MÚLTIPLES ARREGLOS

Arreglos en paralelos

Cuando se plantean soluciones a diversos problemas es necesario utilizar variables, vectores
y matrices en forma simultánea para almacenar los datos. Es decir, en una solución se puede
utilizar algunas variables, un vector, dos vectores o muchos vectores. También, se puede
utilizar variables, un vector y una matriz, o dos vectores y una matriz. En términos generales
se puede afirmar que en una solución se utilizan variables, vectores y matrices en forma
simultánea y en el número que se necesiten. Esto va a depender de la complejidad y tipo de
problema que se necesite resolver.

Cuando en una solución se utiliza más de un arreglo y el orden en que se disponen los datos
entre los arreglos tiene un significado se les denomina vectores paralelos.

En la solución del problema 146 se utilizan algunas variables y dos vectores en forma
simultanea (en paralelo). En una de las variables (numTrab) se almacena el número de
trabajadores y con este valor se crean los dos vectores (los arreglos en paralelo deben tener
el mismo tamaño). En uno de los vectores (nombres[ ]) se almacenan los nombres de todos
los trabajadores y en el otro vector (sueldos[ ]) se almacenan sus respectivos sueldos. Se
puede observar que un dato almacenado en una posición de un vector esta relacionado con
el dato almacenado en la misma posición del otro vector. A continuación, se muestra el
planteamiento de la solución en forma gráfica. Es importante tener presente que los vectores
paralelos se grafican en forma vertical para comprender mejor la relación que existe entre
ellos.

nombres sueldos
Datos del mismo
trabajador.
0 0
1 1
2 2
: : : :
: : : :
numTrab - 1 : numTrab - 1 :
nombre de los sueldo de los
trabajadores trabajadores

Si en nombres[0] se almacena el nombre “Danae”, resulta lógico y necesario que en
sueldos[0] almacenemos su respectivo sueldo.

La pregunta lógica que se pueden formular sería la siguiente: ¿por qué en vez de crear dos
vectores en paralelo no creamos una matriz con dos columnas?, y la respuesta sería que en
una matriz solo se pueden almacenar datos del mismo tipo, mientras que usando dos
vectores en paralelo se pueden almacenar datos de diferente tipo. En el planteamiento de la

Pag. 493

Ing. Juan José Flores Cueto.

solución anterior en uno de los vectores se almacenan datos de tipo TEXTO mientras que en
el otro vector se almacenan datos de tipo NUMERO.

En la solución del problema 147 se utilizan algunas variables y tres vectores en forma
simultanea (en paralelo). En una de las variables (numSoc) se almacena el número de socios
de un club y con este valor se crean los tres vectores. En uno de los vectores (nombres[ ]) se
almacenan los nombres de los socios, en otro vector (sexos[ ]) se almacena el sexo de cada
uno de los socios y en el tercer vector (edades[ ]) sus respectivas edades. Como ejemplo, se
puede observar, que todos los datos de la socia Danae están almacenados en la posición
cero de los vectores en paralelo. A continuación se muestra el planteamiento de la solución.

nombres sexos Edades

0 Danae 0 F 0 10
1 1 1
2 2 2
: : : : : :
: : : : : :
numSoc - 1 : numSoc - 1 : numSoc - 1 :
nombres de sexo de sueldo de
cada socios cada socio cada socio

En la solución del problema 148 se utilizan algunas variables, un vector y una matriz con dos
columnas en forma simultanea (en paralelo). A continuación se muestra el planteamiento de
la solución.

nombres precios
0 1
0 0
1 1
2 2
: : : : :
: : : : :
numArt - 1 : numArt - 1 : :
nombre de precio de compra precio de venta
cada artículos de cada artículos de cada artículos

Pag. 494

ESTRUCTURAS DE DATOS – Arreglos.

Problema 146

Etapa 01 - Descripción del problema.

Desarrollar una solución que permita ingresar y almacenar el nombre y el sueldo de
todos los trabajadores de una empresa. Mostrar el nombre del trabajador que tiene el
sueldo más alto y el promedio del sueldo de todos los trabajadores redondeado a dos
decimales.

Etapa 02 - Definición de la solución.

‰ Resultado deseado: Mostrar el nombre del trabajador que tiene el
sueldo más alto y el promedio del sueldo de
todos los trabajadores.

‰ Datos necesarios: El número de trabajadores y, el nombre y el
sueldo de cada trabajador.

‰ Procesamiento: El número de trabajadores se ingresa a través
del teclado y se almacena en una variable
(numTrab). Con el número de trabajadores
se crean dos arreglos (nombres[] y
sueldos[]). Luego se procede a ingresar el
nombre de los trabajadores, se eliminan los
espacios del inicio y final de los mismos, y se
almacenan en uno de los arreglos creados
(nombres[ ]). También, se procede a ingresar
el sueldo de los trabajadores y se almacenan
en el otro arreglo creado (sueldos[ ]).

Después, se determina el sueldo mas alto
entre todos los trabajadores comparando el
sueldo de cada trabajador con el contenido de
una variable (sueldoMayor), inicializada con
cero. Si el contenido de la variable
sueldoMayor resulta menor que el sueldo de
un trabajador, el sueldo de dicho trabajador
pasa a ser el sueldo mayor y se almacena en
la variable sueldoMayor. Una vez
determinado el sueldo mayor se muestra el
nombre de todos los trabajadores cuyo sueldo
es igual al sueldoMayor.

Luego, se determina el promedio del sueldo
de todos los trabajadores sumando el sueldo
de cada trabajador a una variable acumulador

Pag. 495

Ing. Juan José Flores Cueto.

(sumaSueldos) y dividiendo la suma total de
los sueldos entre el número de trabajadores.
El resultado se almacena en una variable
(sueldoPromedo), se redondea a dos
decimales y se muestra por pantalla.

Etapa 03 - Diseño de la lógica.

1. Nombre del Proyecto: ProyTrabajadores.

2. Definición de Paquetes y desarrollo del Diagrama de Paquetes.

Diagrama de paquetes

3. Definición de las Clases.

Clases Clases
dominioDeLaAplicacion biblioteca

Pag. 496

ESTRUCTURAS DE DATOS – Arreglos.

4. Diseño de algoritmo para el método principal.

Algoritmo PrgTrabajadores06 - método main ( )

ENTRADA: numTrab, nombres[ ], sueldos[ ]
SALIDA: nombres[ ], sueldoPromedio

INICIO

COMENTARIO “Declaración de variables”
NUMERO i, numTrab, sueldos[ ]
NUMERO sueldoMayor = 0, sumaSueldos = 0, sueldoPromedio
TEXTO nombres[ ]

COMENTARIO “Determinación del tamaño del arreglo”
HACER
LEER numTrab
SI (numTrab <= 0 )
ENTONCES
ESCRIBIR “Número de trabajadores no válido… ”
FINSI
MIENTRAS (numTrab <= 0 )

COMENTARIO “Creación de los arreglos”
CREAR nombres [numTrab]
CREAR sueldos [numTrab]

COMENTARIO “Ingreso de nombres y sueldos de trabajadores”
DESDE i = 0 HASTA i = numTrab - 1 INCREMENTA 1
HACER

COMENTARIO “ Ingreso de nombre de trabajadores ”
LEER nombres[i]
nombres[i] = nombres[i] ELIMINAESPACIO INICIO,FIN
SI ( LONGITUD nombres[i] < 3 )
ENTONCES
ESCRIBIR “Nombre del trabajador no válido...”
FINSI
MIENTRAS ( LONGITUD nombres[i] < 3 )

HACER

COMENTARIO “ Ingreso de sueldo de trabajadores ”
LEER sueldos[i]
SI ( sueldos[i] <= 0 )
ENTONCES
ESCRIBIR “Sueldo de trabajador no válido...”
FINSI
MIENTRAS ( sueldos[i] <= 0 )

FINDESDE

Pag. 497

Ing. Juan José Flores Cueto.

Continúa… 4. Diseño de algoritmo para el método principal.

Algoritmo PrgTrabajadores06 - método main ( )

COMENTARIO “Determinando el nombre de los trabajador con el
sueldo mas alto”
DESDE i = 0 HASTA i = numArt - 1 INCREMENTA 1
SI ( i = 0 )
ENTONCES
sueldoMayor = sueldos[i]
SINO
SI ( sueldoMayor < sueldo[i] )
ENTONCES
sueldoMayor = sueldo[i]
FINSI
FINSI
FINDESDE

DESDE i = 0 HASTA i = numArt - 1 INCREMENTA 1
SI (sueldoMayor = sueldo[i] )
ENTONCES
ESCRIBIR nombres[i]
SINO
FINDESDE

COMENTARIO “Determinando el promedio del sueldo de todos los
trabajadores”
DESDE i = 0 HASTA i = numArt - 1 INCREMENTA 1
sumaSueldos = sumaSueldos + sueldos[i]
FINDESDE

sueldoPromedio = sumaSueldos / numTrab
sueldoPromedio = sueldoPromedio REDONDEA 2
ESCRIBIR sueldoPromedio

FIN

Pag. 498

out. for ( i = 0 . // Ingreso de nombres y sueldos de trabajadores con consistencia de datos. sueldos[i] = Lectura. // Declaración y creación del arreglo. String nombres[ ] = new String [numTrab] . if ( numTrab <= 0 ) { System.out. int i.leerInt( ) . numTrab = Lectura. // Determinación del tamaño de los arreglos con consistencia de datos. double sueldos[ ] = new double [numTrab] .print ( “ Ingrese el nombre del trabajador [ ” + ( i + 1) + “ ]: ” ) . double sueldoMayor = 0. 499 . } } while ( nombres[i]. sueldoPromedio . Etapa 04 . i++ ) { do { System.trim( ) .ESTRUCTURAS DE DATOS – Arreglos. do { System.out.out. do { System.println ( “ El nombre del trabajador no es válido… ” ) .out. numTrab .out.leerString( ) .* . } Pag.print ( “ Ingrese el sueldo del trabajador [ ” + ( i + 1) + “ ]: ” ) . sumaSueldos = 0.print ( “ Ingrese el número de trabajadores : ” ) . } } while ( numTrab <= 0 ) . if ( nombres[i].Desarrollo de la Codificación.println ( “ El sueldo del trabajador no es válido… ” ) . i < numTrab . nombres[i] = Lectura.leerString( ) .length( ) < 3 ) . public class PrgTrabajadores06 { public static void main(String[] args) { // Declaración de variables. } } while (sueldos[i] <= 0 ) .println ( “ El número de trabajadores no es válido… Reintente! ” ) . import biblioteca.length( ) < 3 ) { System. if ( sueldos[i] <= 0 ) { System. Clase PrgTrabajadores06 package dominioDeLaAplicacion . nombres[i] = nombres[i].

println ( “ Nombres de los trabajadores con el sueldo más alto ” ) . } } Pag.0 . Clase PrgTrabajadores06 // Determinando el nombre de los trabajadores con el sueldo mas alto.Desarrollo de la Codificación.println ( “ ” + nombres[i] ) . i < numTrab . i++ ) { if ( i == 0 ) { sueldoMayor = sueldos[i] . i < numTrab .out. 500 . for ( i = 0 . for ( i = 0 . } sueldoPromedio = sumaSueldos / numTrab . Juan José Flores Cueto.out.out.round (sueldoPromedio * 100) ) / 100. sueldoPromedio = ( Math. for ( i = 0 . } else { if ( sueldoMayor < sueldos[i] ) { sueldoMayor = sueldos[i] . Continúa… Etapa 04 . } } } System. System. i++ ) { sumaSueldos = sumaSueldos + sueldos[i] . i++ ) { if ( sueldoMayor == sueldos[i] ) { System. i < numTrab . } } // Determinando el promedio del sueldo de todos los trabajadores. Ing.println ( “ El sueldo promedio de los trabajadores es: ” + sueldoPromedio ) .

Definición de la solución. Luego se procede a ingresar el nombre de los socios.sexos[] y edades[]).Descripción del problema. se convierte a mayúscula y se almacenan en otro de los arreglos creado (sexos[]). Desarrollar una solución que permita ingresar y almacenar el nombre. se determina el número de socios hombres. ‰ Procesamiento: El número de socios se ingresa a través del teclado y se almacena en una variable (numSoc). Etapa 02 . Para esto se obtiene la primera letra del nombre de Pag. mayores de edad. se eliminan los espacios del inicio y final de los mismos. Luego. entonces se aumenta 1 a una variable de tipo contador (totalMayoresHombres). 501 . el nombre. se procede a ingresar el sexo de los socios (M = Masculino y F = Femenino). Con el número de socios se crean tres arreglos (nombres[]. el sexo y la edad de todos los socios de un club. ‰ Resultado deseado: Mostrar el número de socios hombres mayores de edad y el número de socios cuyo nombre comienza con la letra “D”. Finalizada la evaluación de los datos de todos los socios se muestra el contenido de la variable totalMayoresHombres. se determina el número de socios cuyo nombre comienza con la letra ‘D’. Luego. se ingresan las edades de los socios y se almacenan en el tercer arreglo (edades[]). Para esto se evalúan los datos de cada uno de los socios y si resulta que es hombre (sexo = ‘M’) y es mayor de edad (edad >= 18). Indicar el número de socios mayores de edad que son hombres y el número de socios cuyo nombre comienza con la letra “D”. ‰ Datos necesarios: El número de socios y. Por último. Después.ESTRUCTURAS DE DATOS – Arreglos. Problema 147 Etapa 01 . y se almacenan en uno de los arreglos creados (nombres[]). sexo y edad de cada socio.

Definición de Paquetes y desarrollo del Diagrama de Paquetes. Si letra = ‘D’. 1.Diseño de la lógica. Clases Clases dominioDeLaAplicacion biblioteca Pag. Finalizada la evaluación se muestra el contenido de la variable totalNombresD. se convierte a mayúscula y se compara con la letra ‘D’. Nombre del Proyecto: ProySocios. Diagrama de paquetes 3. Etapa 03 . Juan José Flores Cueto. Definición de las Clases. Ing. 2. entonces se aumenta 1 a otra variable tipo contador (totalNombresD). 502 . cada socio y se almacena en una variable (letra).

.método main ( ) ENTRADA: numSoc. Algoritmo PrgSocios01 ..” FINSI MIENTRAS ( LONGITUD nombres[i] < 3 ) HACER COMENTARIO “ Ingreso de sexo de socios ” LEER sexos[i] sexos[i] = MAYUSCULA sexos[i] SI ( sexos[i] <> ‘M’ OR sexos[i] <> ’F’ ) ENTONCES ESCRIBIR “Sexo de socio no válido.ESTRUCTURAS DE DATOS – Arreglos. edades[ ] SALIDA: totalMayoresHombres. sexos[ ].. 503 .” FINSI MIENTRAS ( sexos[i] <> ‘M’ OR sexos[i] <> ’F’ ) Pag. sexos[ ].1 INCREMENTA 1 HACER COMENTARIO “ Ingreso de nombre de socios ” LEER nombres[i] nombres[i] = nombres[i] ELIMINAESPACIO INICIO. totalNombresD = 0 TEXTO nombres[ ].. FIN SI ( LONGITUD nombres[i] < 3 ) ENTONCES ESCRIBIR “Nombre del socio no válido. sexo y edad de los socios ” DESDE i = 0 HASTA i = numSoc . nombres[ ]. numSoc. totalNombresD INICIO COMENTARIO “Declaración de variables” NUMERO i. letra COMENTARIO “Determinación del tamaño del arreglo” HACER LEER numSoc SI (numSoc <= 0 ) ENTONCES ESCRIBIR “Número de socios no válido… ” FINSI MIENTRAS (numSoc <= 0 ) COMENTARIO “Creación de los arreglos” CREAR nombres [numSoc] CREAR sexos [numSoc] CREAR edades [numSoc] COMENTARIO “Ingreso de nombres. edades[ ] NUMERO totalMayoresHombres = 0. 4. Diseño de algoritmo para el método principal.

Ing...1 INCREMENTA 1 SI ( edades[i] >= 18 AND sexos[i] = ‘M’ ) ENTONCES totalMayorHombres = totalMayorHombres + 1 FINSI FINDESDE ESCRIBIR totalMayorHombres COMENTARIO “Determinando el promedio del sueldo de todos los trabajadores” DESDE i = 0 HASTA i = numSoc . Diseño de algoritmo para el método principal.1 INCREMENTA 1 letra = nombres[i] CARACTER 0 letra = MAYUSCULA letra SI ( letra = ‘D’ ) ENTONCES totalNombresD = totalNombresD + 1 FINSI FINDESDE ESCRIBIR totalNombresD FIN Pag.método main ( ) HACER COMENTARIO “ Ingreso de edad de socios ” LEER edades[i] SI ( edades[i] <= 0 ) ENTONCES ESCRIBIR “Edad de socio no válida. Algoritmo PrgSocios01 .” FINSI MIENTRAS ( edades[i] <= 0 ) FINDESDE COMENTARIO “Determinando número de socios hombres mayores de edad” DESDE i = 0 HASTA i = numSoc . Continúa… 4. Juan José Flores Cueto. 504 .

} } while ( nombres[i].print ( “ Ingrese el nombre del socio [ ” + ( i + 1) + “ ]: ” ) .out. sexos[i] = Lectura. do { System. int i.ESTRUCTURAS DE DATOS – Arreglos. } } while ( sexos[i] != ‘M’ || sexos[i] != ‘F’ ) . numSoc = Lectura.out.println ( “ El número de socios no es válido… Reintente! ” ) .length( ) < 3 ) { System. // Determinación del tamaño de los arreglos con consistencia de datos.println ( “ El nombre del socio no es válido… ” ) .leerInt( ) . sexo y edad de los socios con consistencia de datos. totalMayoresHombres = 0.Desarrollo de la Codificación. int edades[ ] = new int [numSoc] . String nombres[ ] = new String [numSoc] . Etapa 04 . nombres[i] = Lectura. char sexos[ ] = new char [numSoc] .print ( “ Ingrese el número de socios : ” ) . public class PrgSocios01 { public static void main(String[] args) { // Declaración de variables. Clase PrgSocios01 package dominioDeLaAplicacion . numSoc.print ( “ Ingrese el sexo del trabajador [ ” + ( i + 1) + “ ]: ” ) .leerChar( ) . i < numSoc . Pag.toUpperCase( sexos[i] ) . for ( i = 0 . } } while ( numSoc <= 0 ) . // Ingreso de nombre. if ( numSoc <= 0 ) { System. // Declaración y creación del arreglo. if ( sexos[i] != ‘M’ || sexos[i] != ‘F’ ) { System. import biblioteca.* .length( ) < 3 ) . sexos[i] = Character.leerString( ) . i++ ) { do { System.out. do { System. 505 .out. char letra .out.out. totalNombresD = 0 . if ( nombres[i].trim( ) .println ( “ El sexo del trabajador no es válido… ” ) . nombres[i] = nombres[i].

letra = carácter.println ( totalMayoresHombres ) . System. edades[i] = Lectura.out. Juan José Flores Cueto. } } System.print ( “ El número de socios cuyo nombre comienza con la letra D es : ” ) . i < numSoc .println ( “ La edad del socio no es válida… ” ) . if ( letra == ‘M’ ) { totalNombresD ++ .out. Ing.out.toUpperCase(letra) . Clase PrgSocios01 do { System. } } System. i++ ) { letra = nombres[i]. for ( i = 0 . // Determinando el número de socios cuyo nombre comienza con la letra D. 506 .out.charAt(0) .out. for ( i = 0 .leerInt( ) .print ( “ El número de socios hombres mayores de edad es : ” ) . i < numSoc . if ( edades[i] <= 0 ) { System.Desarrollo de la Codificación.print ( “ Ingrese la edad del socio [ ” + ( i + 1) + “ ]: ” ) . System. i++ ) { if ( edades[i] >= 18 && sexos[i] == ‘M’ ) { totalMayoresHombres ++ . } } Pag.println ( totalNombresD ) . Continúa… Etapa 04 .out. } } while ( edades[i] <= 0 ) . } // Determinando el número de socios hombres mayores de edad.

Problema 148 Etapa 01 . y se almacenan en uno de los arreglos creados (nombres[ ]). un vector y una matriz con dos columnas (nombres[ ] y precios[ ][ ]). El precio de compra se almacena en la primera columna del arreglo y el precio de venta se almacena en la segunda columna. Luego. Luego se procede a ingresar el nombre de los artículos. Para esto. Pag. se eliminan los espacios del inicio y final de los mismos. Etapa 02 . ‰ Resultado deseado: Mostrar el nombre de cada artículo y su margen de utilidad. ‰ Datos necesarios: El número de artículos y. Desarrollar una solución que permita ingresar y almacenar el nombre.Descripción del problema.ESTRUCTURAS DE DATOS – Arreglos. el nombre. el precio de compra y el precio de venta de todos los artículos de una bodega. Indicar el nombre de cada artículo y su margen de utilidad.Definición de la solución. Con el número de artículos se crean dos arreglos. el precio de venta del artículo se resta de su precio de compra. y se almacenan en el otro arreglo creado (precios[ ][ ]). Después. se determina la utilidad de cada artículo. ‰ Procesamiento: El número de artículos se ingresa a través del teclado y se almacena en una variable (numArt). el precio de compra y el precio de venta de cada artículo. se almacena el resultado en una variable (utilidad) y se muestra el nombre del artículo junto con su utilidad. se procede a ingresar el precio de compra y el precio de venta. 507 .

508 . Definición de Paquetes y desarrollo del Diagrama de Paquetes. Ing. Definición de las Clases. Etapa 03 . Diagrama de paquetes 3. 2.Diseño de la lógica. Nombre del Proyecto: ProyArticulos. Clases Clases dominioDeLaAplicacion biblioteca Pag. 1. Juan José Flores Cueto.

utilidad INICIO COMENTARIO “Declaración de variables” NUMERO i. utilidad TEXTO nombres[ ] COMENTARIO “Determinación del tamaño del arreglo” HACER LEER numArt SI (numArt <= 0 ) ENTONCES ESCRIBIR “Número de artículos no válido… ” FINSI MIENTRAS (numArt <= 0 ) COMENTARIO “Creación de los arreglos” CREAR nombres [numArt] CREAR precios [numArt][2] COMENTARIO “Ingreso de nombre.. precios[ ][ ]. numArt. 509 .” FINSI MIENTRAS ( precios[i][0] <= 0 ) Pag. precios[ ][ ] SALIDA: nombres[ ].... Diseño de algoritmo para el método principal.” FINSI MIENTRAS ( LONGITUD nombres[i] < 3 ) HACER COMENTARIO “ Ingreso de precio de compra ” LEER precios[i][0] SI ( precios[i][0] <= 0 ) ENTONCES ESCRIBIR “Precio de compra no válido. 4. precio de compra y precio de venta de los artículos ” DESDE i = 0 HASTA i = numArt .método main ( ) ENTRADA: numArt.ESTRUCTURAS DE DATOS – Arreglos. FIN SI ( LONGITUD nombres[i] < 3 ) ENTONCES ESCRIBIR “Nombre del artículo no válido.1 INCREMENTA 1 HACER COMENTARIO “ Ingreso de nombre de artículo ” LEER nombres[i] nombres[i] = nombres[i] ELIMINAESPACIO INICIO. Algoritmo PrgArticulos06 . nombres[ ].

Diseño de algoritmo para el método principal. Juan José Flores Cueto. Continúa… 4.” FINSI MIENTRAS ( precios[i][1] <= 0 ) FINDESDE COMENTARIO “Determinando la utilidad de cada artículo ” DESDE i = 0 HASTA i = numArt . Algoritmo PrgArticulos06 .. Ing.método main ( ) HACER COMENTARIO “ Ingreso de precio de venta ” LEER precios[i][1] SI ( precios[i][1] <= 0 ) ENTONCES ESCRIBIR “Precio de venta no válido. 510 .. utilidad FINDESDE FIN Pag.1 INCREMENTA 1 utilidad = precios[i][1] – precios[i][0] ESCRIBIR nombres[i].

511 . String nombres[ ] = new String [numArt] . double utilidad .out. if ( precios[i][0] <= 0 ) { System.leerDouble( ) . precio de compra y precio de venta de los artículos.leerInt( ) . double edades[ ] = new double [numArt][2] . // Determinación del tamaño de los arreglos con consistencia de datos. if ( nombres[i]. Pag.print ( “ Ingrese su precio de compra : ” ) . nombres[i] = nombres[i]. i < numArt . public class PrgArticulos06 { public static void main(String[] args) { // Declaración de variables.length( ) < 3 ) . import biblioteca. i++ ) { do { System. if ( numArt <= 0 ) { System. Clase PrgArticulos06 package dominioDeLaAplicacion . nombres[i] = Lectura.out.out.leerString( ) .Desarrollo de la Codificación.* . do { System.print ( “ Ingrese el nombre del artículo [ ” + ( i + 1) + “ ]: ” ) . // Ingreso de nombre.length( ) < 3 ) { System. do { System. } } while ( nombres[i].println ( “ El número de artículos no es válido… Reintente! ” ) . Etapa 04 . numArt = Lectura.trim( ) . numArt . // Declaración y creación del arreglo. } } while ( precios[i][0] <= 0 ) . for ( i = 0 .out.out.ESTRUCTURAS DE DATOS – Arreglos. int i.println ( “ El nombre del artículo no es válido… ” ) .out.print ( “ Ingrese el número de artículos : ” ) . precios[i][0] = Lectura.println ( “ Precio de compra no válido… ” ) . } } while ( numArt <= 0 ) .

leerDouble( ) . for ( i = 0 . i++ ) { utilidad = precios[i][1] – precios[i][0] .println ( “ Precio de venta no válido… ” ) . 512 .out.” ) . System.out.print ( “ El artículo : ” + nombres[i] + “ tiene una utilidad de ” ) . System. } // Determinando la utilidad de cada artículo. } } } Pag. Continúa… Etapa 04 . if ( precios[i][1] <= 0 ) { System.out. Ing.out. } } while ( precios[i][1] <= 0 ) .print ( “ Ingrese su precio de venta : ” ) . Juan José Flores Cueto.println ( “ ” + utilidad + “. precios[i][1] = Lectura.Desarrollo de la Codificación. Clase PrgArticulos06 do { System. i < numArt .

Etapa 02 . Adicionalmente. ‰ Resultado deseado: Mostrar el nombre. El resultado se almacenada en otra variable (promAlu). Para esto. notas[][] y promedios[][]). se determina el promedio de cada alumno y el promedio mayor. Indicar el nombre. Adicionalmente. 513 . tres vectores y una matriz (nombres[]. Támbien se ingresan las notas de cada alumno y se almacenan en otro de los arreglos (notas[][]). Con el número de alumnos y el número de notas se crean cuatro arreglos. ‰ Datos necesarios: El número de alumnos y. codigos[]. se redondea y esta a su vez se almacena en el arreglo promedios[]. se suman las notas del alumno y se almacenan en una variable (sumaNotas) y luego se divide entre el número de notas (numNot). se procede a ingresar el código de los alumnos y se almacenan en otro arreglo (codigos[]). el código y el promedio de cada alumno. el código y el promedio de notas de cada alumno. Después. el código y el promedio de notas de cada alumno. Problema 149 Etapa 01 . Luego se procede a ingresar el nombre de los alumnos.Definición de la solución. indicar el nombre de los alumnos que obtuvieron el mayor promedio. ‰ Procesamiento: El número de alumnos y el número de notas se ingresa a través del teclado y se almacena en variables (numAlu y numNot respectivamente). el código y las notas de cada alumno. Luego se determina el promedio mayor y se almacena Pag. y se almacenan en uno de los arreglos creados (nombres[]).ESTRUCTURAS DE DATOS – Arreglos. el código y las diferentes notas de los alumnos de un salón de clase. Después se muestra el nombre.Descripción del problema. Almacenar el promedio de notas de cada alumno. Desarrollar una solución que permita ingresar y almacenar el nombre. indicar el nombre de los alumnos que obtuvieron el mayor promedio. el nombre. Luego.

Diagrama de paquetes 3. se muestran los nombres de todos los alumnos que tienen promedio igual a promAluMayor. Ing. Juan José Flores Cueto.Diseño de la lógica. Definición de las Clases. Definición de Paquetes y desarrollo del Diagrama de Paquetes. Etapa 03 . Finalmente. en una variable (promAluMayor). Nombre del Proyecto: ProyAlumnos. 514 . 1. 2. Clases Clases dominioDeLaAplicacion biblioteca Pag.

ESTRUCTURAS DE DATOS – Arreglos. promAlu = 0.FIN SI ( LONGITUD nombres[i] < 3 ) ENTONCES ESCRIBIR “Nombre del alumno no válido. promedios[ ] INICIO COMENTARIO “Declaración de variables” NUMERO i. j. codigos[ ]. codigo y notas de todos los alumnos ” DESDE i = 0 HASTA i = numAlu .método main ( ) ENTRADA: numAlu. Diseño de algoritmo para el método principal.1 INCREMENTA 1 HACER LEER nombres[i] nombres[i] = nombres[i] ELIMINAESPACIO INICIO. nomNot. codigos[ ]. promedios[ ] NUMERO sumaNotas = 0. notas[ ][ ] SALIDA: nombres[ ]. 4.” FINSI MIENTRAS ( LONGITUD nombres[i] < 3 ) Pag. numNot. nombre[ ]. Algoritmo PrgAlumnos06 ... notas[ ][ ]. promAluMayor = 0 TEXTO nombres[ ] COMENTARIO “Determinación del tamaño del arreglo” HACER LEER numAlu SI (numAlu <= 0 ) ENTONCES ESCRIBIR “Número de alumnos no válido… ” FINSI MIENTRAS (numAlu <= 0 ) HACER LEER numNot SI (numNot <= 0 ) ENTONCES ESCRIBIR “Número de notas no válido… ” FINSI MIENTRAS (numNot <= 0 ) COMENTARIO “Creación de los arreglos” CREAR nombres [numAlu] CREAR codigos [numAlu] CREAR notas [numAlu][numNot] CREAR promedios[numAlu] COMENTARIO “Ingreso de nombre. 515 . codigos[ ]. numAlu.

.1 INCREMENTA 1 sumaNotas = 0 DESDE j = 0 HASTA j = numNot . Juan José Flores Cueto. promedios[i] SI ( i = 0 ) ENTONCES promAluMayor = promAlu SINO SI ( promAluMayor < promAlu ) ENTONCES promAluMayor = promAlu FINSI FINSI FINDESDE COMENTARIO “Mostrando los alumnos con el promedio mayor” DESDE i = 0 HASTA i = numAlu . 516 ..1 INCREMENTA 1 HACER LEER notas[i][j] SI ( notas[i][j] < 0 OR notas[i][j] > 20 ) ENTONCES ESCRIBIR “Nota ingresada no válida. Algoritmo PrgAlumnos06 .1 INCREMENTA 1 sumaNotas = sumaNotas + notas[i][j] FINDESDE promAlu = sumaNotas / numNot promAlu = promAlu REDONDEA 2 promedio[i] = promAlu ESCRIBIR nombres[i]. Diseño de algoritmo para el método principal. codigos[i]. Continúa… 4.1 INCREMENTA 1 SI ( promedios[i] = promAluMayor ) ENTONCES ESCRIBIR nombres[i] FINSI FINDESDE FIN Pag.” FINSI MIENTRAS ( notas[i][j] < 0 OR notas[i][j] > 20 ) FINDESDE FINDESDE COMENTARIO “Determinando el promedio de cada alumno y el promedio mayor ” DESDE i = 0 HASTA i = numAlu .. Ing.” FINSI MIENTRAS ( codigos[i] < 100000 OR codigos[i] > 999999 ) DESDE j = 0 HASTA j = numNot .método main ( ) HACER LEER codigos[i] SI ( codigos[i] < 100000 OR codigos[i] > 999999 ) ENTONCES ESCRIBIR “Código ingresado no válido..

ESTRUCTURAS DE DATOS – Arreglos.

Etapa 04 - Desarrollo de la Codificación.

Clase PrgAlumnos06

package dominioDeLaAplicacion ;

import biblioteca.* ;
public class PrgAlumnos06 {

public static void main(String[] args) {

// Declaración de variables.
int i, j, numAlu, numNot ;
double sumaNotas = 0, promAlu = 0, promAluMayor = 0 ;

// Determinación del tamaño de los arreglos con consistencia de datos.
do {
System.out.print ( “ Ingrese el número de alumnos : ” ) ;
numAlu = Lectura.leerInt( ) ;
if ( numAlu <= 0 ) {
System.out.println ( “ El número de alumnos no es válido… Reintente! ” ) ;
}
} while ( numAlu <= 0 ) ;

do {
System.out.print ( “ Ingrese el número de notas por alumno : ” ) ;
numNot = Lectura.leerInt( ) ;
if ( numNot <= 0 ) {
System.out.println ( “ El número de notas no es válido… Reintente! ” ) ;
}
} while ( numNot <= 0 ) ;

// Declaración y creación del arreglo.
String nombres[ ] = new String [numAlu] ;
long codigos[ ] = new long [numAlu] ;
double notas[ ][ ] = new double [numAlu][numNot] ;
double promedios[ ] = new double [numAlu] ;

// Ingreso de nombre, precio de compra y precio de venta de los artículos.
for ( i = 0 ; i < numAlu ; i++ ) {
do {
System.out.print ( “ Ingrese el nombre del alumno [ ” + ( i + 1) + “ ]: ” ) ;
nombres[i] = Lectura.leerString( ) ;
nombres[i] = nombres[i].trim( ) ;

if ( nombres[i].length( ) < 3 ) {
System.out.println ( “ El nombre del alumno no es válido… ” ) ;
}
} while ( nombres[i].length( ) < 3 ) ;

Pag. 517

Ing. Juan José Flores Cueto.

Continúa… Etapa 04 - Desarrollo de la Codificación.

Clase PrgAlumnos06

do {
System.out.print ( “ Ingrese su código : ” ) ;
codigos[i] = Lectura.leerLong( ) ;
if ( codigos[i] < 100000 || codigos[i] > 999999 ) {
System.out.println ( “ Precio de compra no válido… ” ) ;
}
} while ( codigos[i] < 100000 || codigos[i] > 999999 ) ;
for ( j = 0 ; j < numNot ; j++ ) {
do {
System.out.print ( “ Ingrese su nota ” + ( j + 1) + “ : ” ) ;
notas[i][j] = Lectura.leerDouble( ) ;
if (notas[i][j] < 0 || notas[i][j] > 20 ) {
System.out.println ( “ Nota ingresada no válida… ” ) ;
}
} while (notas[i][j] < 0 || notas[i][j] > 20 ) ;
}
}

// Determinando el promedio de cada alumno y el promedio mayor.
for ( i = 0 ; i < numAlu ; i++ ) {
sumaNotas = 0 ;
for ( j = 0 ; j < numNot ; j++ ) {
sumaNotas = sumaNotas + notas[i][j] ;
}
promAlu = sumaNotas / numNot ;
promAlu = ( Math.round (promAlu * 100) ) / 100.0 ;
promedios[i] = promAlu ;
System.out.print ( “ El alumno ” + nombres[i] + “ con código ” + codigos[i] ) ;
System.out.println ( “ tiene un promedio de ” + promedios[i] + “.” ) ;
System.out.println ( ) ;
if ( i == 0 ) {
promAluMayor = promAlu ;
} else {
if ( promAluMayor < promAlu ) {
promAluMayor = promAlu ;
}
}
}

// Mostrando los alumnos con el promedio mayor.
System.out.println ( “ Alumnos que tienen el mayor promedio : ” ) ;
for ( i = 0 ; i < numAlu ; i++ ) {
if ( promedios[i] == promAluMayor ) {
System.out.println ( nombres[i] ;
}
}
}
}

Pag. 518

ESTRUCTURAS DE DATOS – Arreglos.

Problema 150

Etapa 01 - Descripción del problema.

Desarrollar una solución que permita ingresar y almacenar el nombre de todos los
artículos de una bodega. Consistenciar la entrada de datos. Mostrar los nombres
ordenados alfabéticamente, considerando la primera letra de cada nombre en
mayúscula y el resto en minúscula. Adicionalmente, mostrar la longitud de cada uno de
los nombres.

Etapa 02 - Definición de la solución.

‰ Resultado deseado: Mostrar los nombres ordenados
alfabéticamente, considerando la primera
letra de cada nombres en letra mayúscula y el
resto en letra minúscula. Adicionalmente
mostrar la longitud de cada uno de los
nombres de los artículos.

‰ Datos necesarios: El número de artículos y el nombre de cada
uno de los artículos.

‰ Procesamiento: El número de artículos se ingresa a través del
teclado y se almacena en una variable
(numArt). Con el número de artículos se crea
un arreglo (articulos[ ]). Luego se procede a
ingresar el nombre de los artículos de la
bodega, se eliminan los espacios del inicio y
final del nombre, y se almacenan en el arreglo
creado.

Después se ordenan los nombres utilizando el
método de ordenación por Intercambio.
Finalizado el método de ordenación, para
cada uno de los nombres, se obtiene la
primera letra, se almacena en una variable
(letra) y se convierte en mayúscula. Luego,
se obtiene las demás letras, se almacenan en
una variable (resto) y se convierten en
minúscula. También, se determina la longitud
del nombre y se almacena en una variable
(tamaño). Finalmente, se muestra la primera
letra del nombre en mayúscula, las demás
letras en minúscula y la longitud del nombre
por pantalla.

Pag. 519

Ing. Juan José Flores Cueto.

Etapa 03 - Diseño de la lógica.

1. Nombre del Proyecto: ProyArticulos.

2. Definición de Paquetes y desarrollo del Diagrama de Paquetes.

Diagrama de paquetes

3. Definición de las Clases.

Clases Clases
dominioDeLaAplicacion biblioteca

Pag. 520

ESTRUCTURAS DE DATOS – Arreglos.

4. Diseño de algoritmo para el método principal.

Algoritmo PrgArticulos07 - método main ( )

ENTRADA: numArt, articulos[ ]
SALIDA: letra, resto, tamaño

INICIO

COMENTARIO “Declaración de variables”
NUMERO i, j, numArt, tamaño
TEXTO articulos[ ], letra, resto, x

COMENTARIO “Determinación del tamaño del arreglo”
HACER
LEER numArt
SI (numArt <= 0 )
ENTONCES
ESCRIBIR “Número de artículos no válido… ”
FINSI
MIENTRAS (numArt <= 0 )

COMENTARIO “Creación del arreglo”
CREAR articulos [numArt]

COMENTARIO “Ingreso de datos al arreglo articulos [ ]”
DESDE i = 0 HASTA i = numArt - 1 INCREMENTA 1
HACER
LEER articulos[i]
articulos[i] = articulos[i] ELIMINAESPACIO INICIO, FIN
SI ( LONGITUD articulos[i] < 3 )
ENTONCES
ESCRIBIR “Nombre de artículo no válido...”
FINSI
MIENTRAS (LONGITUD articulos[i] < 3 )
FINDESDE

COMENTARIO “Método de Intercambio. Ordenación de datos ”
DESDE i = 0 HASTA i = numArt - 2 INCREMENTA 1

DESDE j = i + 1 HASTA i = numArt - 1 INCREMENTA 1
SI ( articulos[i] > articulos[j] )
ENTONCES
x = articulos[i]
articulos[i] = articulos[j]
articulos[i] = x
FINSI
FINDESDE

FINDESDE

Pag. 521

Ing. Juan José Flores Cueto.

Continúa… 4. Diseño de algoritmo para el método principal.

Algoritmo PrgArticulos07 - método main ( )

COMENTARIO “ Manipulación del nombre de los artículos ”
DESDE i = 0 HASTA i = numArt - 1 INCREMENTA 1
letra = articulos[i] SUBCADENA 0,1
letra = MAYUSCULA letra

resto = articulos[i] SUBCADENA 1
resto = MINUSCULA resto
tamaño = LONGITUD articulos[i]

ESCRIBIR letra, resto, tamaño

FINDESDE

FIN

Etapa 04 - Desarrollo de la Codificación.

Clase PrgArticulos07

package dominioDeLaAplicacion ;

import biblioteca.* ;
public class PrgArticulos07 {

public static void main(String[] args) {

// Declaración de variables.
int i, j, numArt, tamaño ;
String letra, resto, x ;

// Determinación del tamaño del arreglo con consistencia de datos.
do {
System.out.print ( “ Ingrese el número de artículos : ” ) ;
numArt = Lectura.leerInt( ) ;
if ( numArt <= 0 ) {
System.out.println ( “ El número de artículos no es válido… Reintente! ” ) ;
}
} while ( numArt <= 0 ) ;

// Declaración y creación del arreglo.
String articulos[ ] = new String [numArt] ;

Pag. 522

ESTRUCTURAS DE DATOS – Arreglos.

Continúa… Etapa 04 - Desarrollo de la Codificación.

Clase PrgArticulos07

// Ingreso de datos al arreglo artículos[ ] con consistencia de datos.
for ( i = 0 ; i < numArt ; i++ ) {
do {
System.out.print ( “ Ingrese el nombre del artículo [ ” + ( i + 1) + “]: ” ) ;
articulos[i] = Lectura.leerString( ) ;
articulos[i] = articulos[i].trim( ) ;

if ( articulos[i].length( ) < 3 ) {
System.out.println ( “ El nombre ingresado no es válido… Reintente! ” ) ;
}
} while ( articulos[i].length( ) < 3 ) ;
}

// Método de Intercambio. Ordenación de datos.
for ( i = 0 ; i < numArt – 1 ; i++ ) {
for ( j = i + 1; j < numArt ; j++ ) {
if ( articulos[i].compareTo(articulos[j] ) > 0 ) {
x = articulos[i] ;
articulos[i] = articulos[j] ;
articulos[j] = x ;
}
}
}

// Manipulación del nombre de los artículos.
for ( i = 0 ; i < numArt ; i++ ) {
letra = articulos[i].substring(0,1) ;
letra = letra.toUpperCase( );
resto = articulos[i].substring(1) ;
resto = resto].toLowerCase( ) ;
tamaño = articulos[i].length( ) ;
System.out.println ( “ Artículo ” + letra + resto + “ tiene una longitud de ” + tamaño ) ;
}
}
}

Pag. 523

Ing. Juan José Flores Cueto.

Pag. 524

Capítulo
Introducción al Desarrollo de
Soluciones Orientadas a Objetos

5
Temas:

Introducción.

Conceptos básicos:

• Clase.
• Objeto.
• Atributo.
• Método.
• Ocultar Atributos de Instancia.

Método de las 6´D. Etapas y pasos.

Problema desarrollado.

INTRODUCCIÓN AL DESARROLLO DE SOLUCIONES ORIENTADAS A OBJETOS

CAPÍTULO V

INTRODUCCIÓN AL DESARROLLO DE SOLUCIONES
ORIENTADAS A OBJETOS

INTRODUCCIÓN

La clase constituye la base de la programación orientada a objetos y es el núcleo o unidad
fundamental de encapsulación en Java. Cualquier concepto que desee desarrollar en Java
debe ser encapsulado en una clase. Una clase se usa para crear objetos.

MARCO DE TRABAJO
ENUNCIADO
DEL
PROBLEMA

Etapa 02

Definición
Solución Etapa 03

Diseño
Solución Etapa 04

Desarrollo
Solución

Pag. 527

Ing. Juan José Flores Cueto.

En los capítulos anteriores, se ha utilizado la clase en su forma más simple. Las clases
creadas se utilizaban simplemente para encapsular el método main(), lo que ha permitido
mostrar la base de la sintaxis de Java, las estructuras de datos, las estructuras lógicas, las
instrucciones de bifurcación, el manejo de excepciones y algunas de las clases incorporadas
en Java. Como se verá en el presente capítulo, las clases son mucho más poderosas que las
presentadas hasta ahora.

Observe la solución del siguiente problema utilizando el método de las 6’D:

Etapa 01 - Descripción del problema.

Calcular el promedio final de un alumno. Utilice la siguiente fórmula: prom = (nota1 +
nota2 + nota3) / 3. Ingrese las notas nota1, nota2 y nota3 a través del teclado.

Etapa 02 - Definición de la solución.

ƒ Resultado deseado: Mostrar la nota final de un determinado alumno.

ƒ Datos necesarios: Las notas del alumno (en esta caso tenemos 3
notas).

ƒ Procesamiento: La 3 notas serán ingresadas por teclado y
almacenadas en las variables nota1, nota2, y nota3.
Luego, se realizará el cálculo de la nota final sobre la
base de la siguiente fórmula:

prom = (nota1 + nota2 + nota3) / 3.

El resultado se almacenará en una variable (prom)
para luego ser mostradas por pantalla.

Etapa 03 - Diseño de la lógica.

ƒ Nombre del Proyecto: ProyAlumno.

Pag. 528

Algoritmo PrgAlumno . nota3. nota2.método main() ENTRADA: nota1. nota3 prom = ( nota1 + nota2 + nota3) / 3 ESCRIBIR prom FIN Pag. nota3 SALIDA: prom INICIO NUMERO nota1. 529 .INTRODUCCIÓN AL DESARROLLO DE SOLUCIONES ORIENTADAS A OBJETOS ƒ Definición de Paquetes y desarrollo del Diagrama de Paquetes. nota2. Diagrama de paquetes ƒ Definición de las Clases. nota2. Clases Clases dominioDeLaAplicacion biblioteca ƒ Diseño del algoritmo para el método principal. prom LEER nota1.

System. En la clase PrgAlumno se define un método main() y dentro del mismo se codifica toda la solución. Para ello. nota1 = Lectura. Todos estos nuevos conceptos presentados se incorporarán progresivamente en el ejemplo planteado. las clases son mucho más poderosas que las presentadas hasta ahora.println ( “Ingrese la nota 3 del alumno: ” ) .println ( “Ingrese la nota 1 del alumno: ” ) .leerDouble( ) . nota2 = Lectura.leerDouble( ) . para incluir los conceptos presentados.out.Desarrollo de la Codificación. A partir de este punto. import biblioteca.Lectura .out. nuevos conceptos hasta llegar al concepto de ocultamiento de atributos de instancia. class PrgAlumno { public static void main ( String arg [ ] ) { double nota1. el Método de las 6D.leerDouble( ) . System. nota3. 530 . Etapa 04 . Al final. Ing. Juan José Flores Cueto. System. se formalizará el método de solución.println ( “Ingrese la nota 2 del alumno: ” ) . nota3 = Lectura.out.println ( “ El promedio obtenido por el alumno es ” + prom ) . prom = ( nota1 + nota2 + nota3 ) / 3 . Como se ha mencionado. nota2. Clase PrgAlumno package dominioDeLaAplicacion . prom . System. Pag.out. se ampliará el conocimiento sobre las clases. en forma progresiva. } } En este proyecto ProyAlumno se crea un paquete dominioDeLaAplicación con una clase PrgAlumno la cual se utiliza en su forma más simple. se revisarán algunos conceptos básicos y se presentarán.

531 .INTRODUCCIÓN AL DESARROLLO DE SOLUCIONES ORIENTADAS A OBJETOS Pag.

Ing. Juan José Flores Cueto. Pag. 532 .

. } } Los datos o variables definidos en una clase se llaman atributos. // . Pag.. tipo variableInstancia2 . // METODOS tipo nombreMetodo1 (listaDeParámetros) { // cuerpo del método1. los métodos y los atributos definidos dentro de una clase son los miembros de la clase. tipo variableInstanciaN . En Java.INTRODUCCIÓN AL DESARROLLO DE SOLUCIONES ORIENTADAS A OBJETOS CONCEPTOS BÁSICOS CLASE Una clase es una implantación de un tipo de objeto. 533 . tipo nombreMetodoN (listaDeParámetros) { // cuerpo del métodoN. El código está contenido en los métodos.. El formato general de una clase en Java es el siguiente: class NombreClase { // ATRIBUTOS tipo variableInstancia1 . Especifica una estructura de datos (atributos) y los métodos operativos permisibles que se aplican a cada uno de sus objetos. El mundo real se modela mediante clases.. } tipo nombreMetodo2 (listaDeParámetros) { // cuerpo del método2. Las clases que se han utilizado anteriormente son ejemplos muy limitados en los que no aparece su formato general. una clase se declara utilizando la palabra reservada class. } //. En conjunto. Una clase define un nuevo tipo de objeto. Una clase es una abstracción y no referencia a ningún objeto en particular.

En el formato general de una clase no se especifica un método main(). static o public static. que muchos métodos no se especificarán como public. es importante mencionar. Los atributos definidos dentro de una clase. Solo necesitarán tener un método main() aquellas clases que tengan como función principal iniciar la ejecución del proyecto. el proyecto de solución ProyAlumno tiene definidas las clases PrgAlumno y Alumno en el paquete dominioDeLaAplicacion. Pag. 534 . Sin embargo. permiten que los objetos o instancias de una clase puedan almacenar datos. Juan José Flores Cueto. La declaración de esta clase en Java es la siguiente: class Alumno { } Ahora. En el proyecto de solución ProyAlumno se agregará una clase llamada Alumno. Todos los métodos tienen el mismo formato que el método main() utilizado en los ejemplos anteriores. Esto debido fundamentalmente a que todas las clases en Java no necesitan tener un método main(). Ing.

es decir se utiliza el constructor por defecto. Java automáticamente utiliza un constructor por defecto (es decir. En dicha sentencia. Más adelante se verá la forma de definir métodos constructores en una clase. Es importante recordar que la definición de una clase sólo crea un molde. Para definir otros objetos de la clase Alumno solo se tendría que repetir la sentencia y cambiar el nombre del objeto. Si no se especifica explícitamente el constructor. El nombre de la clase seguida por los paréntesis especifica el método constructor de la clase. modelo o patrón a partir del cual se pueden crear objetos. Pag. Donde. En el ejemplo. En el proyecto de solución ProyAlumno se utilizará la clase Alumno para definir objetos de tipo Alumno a través de la siguiente sentencia: Alumno objAlumno = new Alumno ( ) . se define el objeto objAlumno de la clase Alumno. • new es un operador en Java que permite crear un objeto. • nombreObjeto es el nombre del objeto que se desea crear. • nombreClase es el nombre de la clase que está siendo instanciada. cuando se crea un objeto no ocurre nada). 535 .INTRODUCCIÓN AL DESARROLLO DE SOLUCIONES ORIENTADAS A OBJETOS OBJETO Objetos: Modelos de entes del mundo. Un objeto de software es cualquier cosa real o abstracta acerca de la cual almacenamos datos y los métodos que controlan dichos datos. la clase Alumno no define explícitamente un constructor. La mayoría de las clases del mundo real definen explícitamente sus propios constructores dentro de la definición de la clase. mientras que la definición de un objeto crea un objeto real o una instancia de una clase. y se realiza utilizando la siguiente sentencia: NombreClase nombreObjeto = new NombreClase ( ) . Un constructor define que ocurre cuando se crea un objeto de una clase. La definición de un objeto en Java comprende la declaración y la creación del mismo.

Es decir. Ing. arreglos u objetos que almacenan valores distintos para todos los objetos de una misma clase. ƒ Atributos de Clase. incluido los tipos de Clase. que puede ser cualquier identificador válido diferente a los que se está utilizando en el mismo ámbito. Puede ser cualquier tipo válido. sirven para almacenar valores de los objetos que se instancian a partir de una clase. para luego definirlos dentro de la clase Alumno. tipo nombreAtributo. La forma mínima de un atributo es la siguiente. mientras que a partir de un atributo de instancia se crea una copia por cada objeto que se instancia. son variables. Los atributos se clasifican en dos categorías: ƒ Atributos de Instancia. Si no se especifica lo contrario los atributos son de instancia y no de clase. Donde : • tipo especifica el tipo de dato que el atributo almacenará. 536 . Para declarar un atributo de clase se utiliza la palabra reservada static. se ha creado la clase Alumno sin atributos ni métodos. Los atributos de instancia conocidos también como atributos de objeto. en principio. Los atributos de clase son variables. areglos u objetos que almacenan el mismo valor para todos los objetos de una misma clase. ATRIBUTO Hasta este punto. En otras palabras. cada objeto tendrá sus propios valores para cada atributo de instancia definido en su clase y existirá para todos los objetos un único valor por cada atributo de clase definido en su clase. a partir de un atributo de clase sólo se crea una copia de ese atributo para todos los objetos que se instancien. • nombreAtributo especifica el nombre del atributo. Los atributos. Ahora. es necesario conocer algunos conceptos básicas sobre los atributos. Pag. Juan José Flores Cueto.

Se agregarán algunos métodos a la clase Alumno mas adelante.nota2 = 19 . En consecuencia. } En la clase Alumno solo se han definido dos atributos. 537 . Cada vez que se define un objeto de una clase. si se desea asignar el valor 15 y 19 a los atributos de instancia nota1 y nota2 del objeto objAlumno.nota1 = 15 . Estas sentencias permiten asignar a las copias de los atributos de instancia nota1 y nota2 que están contenidas en el objeto objAlumno los valores 15 y 19 respectivamente. El operador punto relaciona el nombre del objeto con el nombre de un atributo de instancia. se utilizarían las siguientes sentencias: objAlumno.println ( “ La nota del alumno es: ” + objAlumno. distinto al valor de las copias de los atributos de instancia que otros objetos definidos puedan tener. se declara y crea un objeto que contiene una copia de todos los atributos de instancia definidos para la clase. en la clase Alumno se definirá dos atributos de instancia llamados nota1 y nota2. También. Por ejemplo.out.). el objeto objAlumno de la clase Alumno tendrá su propia copia de los atributos de instancia nota1 y nota2 con un valor para cada uno de ellos.INTRODUCCIÓN AL DESARROLLO DE SOLUCIONES ORIENTADAS A OBJETOS En el proyecto de solución ProyAlumno.nota1 ) . tal y como se especificó anteriormente a través de la siguiente sentencia: Alumno objAlumno = new Alumno ( ) . se definirá el objeto objAlumno de la clase Alumno. class Alumno { double nota1 . cada objeto que se defina de la clase Alumno tendrá su propia copia de los atributos de instancia nota1 y nota2. Cuando se desea acceder a la copia de los atributos de instancia de un objeto se utiliza el operador punto (. Pag. dentro del método main() de la clase PrgAlumno. En el proyecto de solución ProyAlumno. Si se desea mostrar el valor del atributo de instancia nota1 del objeto objAlumno se utilizaría la siguiente sentencia: System. objAlumno. double nota2 . pero todavía no se han definido método.

nota1 + objAlumno. // Primero declaramos y creamos un objeto de la clase Alumno. objAlumno. prom = ( objAlumno. Esta sentencia permite que se muestre el mensaje “La nota del alumno es:” y el valor del atributo nota1 del objeto objAlumno.nota2 = 19 .out. Al ejecutar el proyecto. para luego mostrar el mensaje “El promedio final del alumno es:” y el valor de la variable prom calculada.nota1 = 15 . se necesita calcular y mostrar el promedio del alumno. En el proyecto de solución ProyAlumno. Ing. para lo cual se utilizarían las siguientes sentencias: prom = ( objAlumno.nota2 ) / 2 . el proyecto de solución ProyAlumno se desarrollaría de la siguiente manera: package dominioDeLaAplicacion . class Alumno { double nota1 .out. 538 . Según lo mencionado anteriormente. } package dominioDeLaAplicacion .nota1 + objAlumno. Juan José Flores Cueto. class PrgAlumno { public static void main ( String args [ ] ) { double prom . // Finalmente.println ( “ El promedio final del alumno es: ” + prom ) . double nota2 . Estás sentencias permiten obtener el valor de los atributos nota1 y nota2 del objeto objAlumno para calcular el promedio de las notas y almacenarlo en la variable prom. calculamos el promedio de notas del alumno objAlumno. Alumno objAlumno = new Alumno ( ) . } } Es importante recordar que ambas clases pertenecen al paquete dominioDeLaAplicacion y que el proyecto de solución se denomina ProyAlumno. se ejecuta el método main() de la clase PrgAlumno y se obtiene el siguiente resultado: El promedio final del alumno es: 17 Pag. System. System.nota2 ) / 2 . // Ahora asignamos valores a las variables de instancia del objeto creado. objAlumno.println ( “El promedio final del alumno es: ” + prom ) .

nota3 = 11 . // Finalmente. se puede separar sus nombres mediante comas (. nota2.out. Dicho método main( ) inicia la ejecución del proyecto y está definido en una de las clases que pertenecen al proyecto. nota3 . Tal y como se muestra a continuación: class Alumno { double nota1.INTRODUCCIÓN AL DESARROLLO DE SOLUCIONES ORIENTADAS A OBJETOS Es común que en todo proyecto de solución solo exista un método main( ). class Alumno { double nota1. class PrgAlumno { public static void main ( String args [ ] ) { double prom . de la siguiente manera: package dominioDeLaAplicacion . 539 . objAlumno. objAlumno. Ahora. nota3 .nota2 = 19 .) y declararlos con una solo sentencia. prom = ( objAlumno. nota2.println ( “ El promedio final del alumno es: ” + prom ) .nota2 + objAlumno. } En base a esto. nota2 y nota3. se realizarán algunos cambios en el proyecto de solución ProyAlumno. Es importante mencionar que si existen varios atributos del mismo tipo en una misma clase. calculamos el promedio de notas del alumno objAlumno. Se agregará un atributo de instancia en la definición de la clase Alumno.nota2 y nota3. objAlumno. de tal forma.nota3 ) / 3 . se modificará el método main() de la clase PrgAlumno para utilizar el atributo de instancia nota3. // Primero declaramos y creamos un objeto de la clase Alumno. } } Aquí el objeto objAlumno de la clase Alumno creado en el método main( ) de la clase PrgAlumno tiene su propia copia de los atributos de instancia nota1. System.nota1 + objAlumno. Alumno objAlumno = new Alumno ( ) .nota1 = 15 . // Ahora asignamos valores a las variables de instancia del objeto creado. Es importante mencionar que los cambios que se realicen en los atributos de instancia de un objeto no afectan a los atributos de instancia de los otros objetos ya que cada objeto tiene un Pag. } package dominioDeLaAplicacion . que se definan los atributos de instancia nota1.

nota2 y nota3. System. se les asignará valores a cada copia de los atributos de instancia nota1.nota1 = 15 .println ( “ El promedio final del alumno es: ” + prom ) . // y a las variables de instancia del objeto objAlumno03. se obtiene el siguiente resultado: El promedio final del alumno es: 15 El promedio final del alumno es: 11 El promedio final del alumno es: 14 Pag.nota2 + objAlumno03. Ing. el proyecto de solución ProyAlumno se desarrollaría de la siguiente manera: package dominioDeLaAplicacion . // Ahora asignamos valores a las variables de instancia del objeto objAlumno. objAlumno03.nota3 = 11 .nota3 = 11 .println ( “ El promedio final del alumno es: ” + prom ) . System.out. se definirán dos objetos más denominados objAlumno02 y objAlumno03 en el método main( ) de la clase PrgAlumno.nota2 = 14 .println ( “ El promedio final del alumno es: ” + prom ) .nota2 + objAlumno02.nota1 = 13 . nota2. para finalmente calcular y mostrar el promedio de las notas de cada uno de los objeto de la clase Alumno. } } Al ejecutar el proyecto (recuerde que cuando se ejecuta un proyecto en realidad se ejecuta el método main( ) ). Alumno objAlumno03 = new Alumno ( ) . // Primero declaramos y creamos tres objetos de la clase Alumno. prom = ( objAlumno. prom = ( objAlumno03. prom = ( objAlumno02.nota1 + objAlumno.out. Esto se puede comprobar fácilmente definiendo más de un objeto en el proyecto de solución ProyAlumno.nota3 ) / 3 .nota3 ) / 3 .nota1 = 11 . objAlumno. // Finalmente.nota2 = 19 . objAlumno02. Para esto. // También asignamos valores a las variables de instancia del objeto objAlumno02. Luego.out.nota1 + objAlumno02. Según lo mencionado anteriormente. objAlumno02. } package dominioDeLaAplicacion . valor distinto para cada atributo de instancia independiente de los valores que pueden tener los otros objetos. System. nota3 . objAlumno02. Alumno objAlumno = new Alumno ( ) . class Alumno { double nota1.nota1 + objAlumno03.nota2 = 11 . // También calculamos el promedio de notas del objeto objAlumno02. class PrgAlumno { public static void main ( String args [ ] ) { double prom . 540 .nota3 ) / 3 . // Calculamos el promedio de notas del objeto objAlumno. objAlumno.nota3 = 15 . calculamos el promedio de notas del objeto objAlumno03. objAlumno03. objAlumno. Alumno objAlumno02 = new Alumno ( ) . Juan José Flores Cueto. objAlumno03.nota2 + objAlumno.

y que los valores de un objeto son independientes de los otros valores que tienen los otros objetos. 541 .INTRODUCCIÓN AL DESARROLLO DE SOLUCIONES ORIENTADAS A OBJETOS Y se puede comprobar que cada objeto de la clase Alumno tiene una copia de los atributos de instancia nota1. Pag. nota2 y nota3.

para ejecutar un método de clase se utiliza el siguiente formato: NombreClase. Ahora es necesario conocer algunas cosas básicas sobre los métodos para luego poder definirlos dentro de la clase Alumno. MÉTODO Hasta este punto se ha creado la clase Alumno con tres variables de instancia y sin ningún método. son métodos que pueden ser llamados a través de un objeto instanciado a partir de una clase. 542 . Los métodos definen el comportamiento de un objeto. Juan José Flores Cueto. Los métodos de clase son métodos que pueden ser llamados también a través de un objeto instanciado a partir de una clase o utilizando directamente la clase. En otras palabras. para ejecutar un método de clase no se requiere crear un objeto ya que se puede hacer directamente utilizando el nombre de la clase donde está definido el método. Un método de instancia se ejecuta utilizando el siguiente formato: nombreObjeto. A través de métodos de clase se puede manipular solo atributos de clase. ] Pag. tipo nombreMétodo ( listaDeParámetros ) { // Cuerpo del método . Mientras que a través de métodos de instancia se puede manipular tanto atributos de clase como atributos de instancia. mientras que para ejecutar un método de instancia se requiere crear primero un objeto de la clase donde está definido el método. La forma mínima de un método es la siguiente.nombreMétodoInstancia ( ) . Los métodos de instancia. Para declarar un método de clase se utiliza la palabra reservada static. conocidos también como métodos de objeto. Un método representa un pequeño subprograma encapsulado dentro de una clase y contribuye a definir el comportamiento típico de los objetos.nombreMétodoClase ( ) . Los métodos se clasifican en dos categorías: ƒ Métodos de Instancia. ƒ Métodos de Clase. Generalmente. Ing. Los métodos especifican la forma en que se controlan los datos (atributos) de un objeto.

Si el método no tiene parámetros. Si el método no devuelve ningún valor. Los parámetros son variables que reciben el valor de los argumentos que se pasan al método cuando este es ejecutado.INTRODUCCIÓN AL DESARROLLO DE SOLUCIONES ORIENTADAS A OBJETOS Donde : • tipo especifica el tipo de dato devuelto por el método. Generalmente la sentencia return se coloca al final del cuerpo del método. incluido los tipos de clase. Pag. Los métodos que devuelven un tipo distinto de void. • nombreMétodo especifica el nombre del método que puede ser cualquier identificador válido diferente de los que se están utilizando en el mismo ámbito. Puede ser cualquier tipo válido. devuelven un valor a la sentencia que ejecuta el método utilizando la siguiente forma de la sentencia return: return valor . • listaDeParámetros es una secuencia de parejas de tipo e identificador separados por comas. Aquí valor es el dato que el método devuelve a la sentencia que lo ejecutó. el tipo devuelto debe ser void. entonces la lista de parámetros estará vacía. 543 .

nota2 = 11 . objAlumno. y permitirá calcular y mostrar el promedio de notas de un alumno.promedio ( ) . objAlumno02. class Alumno { double nota1.out. se definirá un método dentro de la clase Alumno. El método se llamará promedio( ). el cual se desarrolla a continuación: package dominioDeLaAplicacion . nota2. nota3 . Alumno objAlumno = new Alumno ( ) . System.nota1 = 11 .nota1 = 15 . objAlumno03. } } Pag. objAlumno02. objAlumno03. // Primero declaramos y creamos tres objetos de la clase Alumno. class PrgAlumno { public static void main ( String args [ ] ) { double prom . // Calculamos el promedio de notas para cada alumno. 544 .print ( “ El promedio final del alumno es: ” ) .nota3 = 11 .out. void promedio ( ) { System. // Ahora asignamos valores a las variables de instancia del objeto objAlumno. Juan José Flores Cueto. } } package dominioDeLaAplicacion . Ahora. objAlumno. objAlumno03. Como el promedio de notas depende de las notas. // También asignamos valores a las variables de instancia del objeto objAlumno02. // y a las variables de instancia del objeto objAlumno03.promedio ( ) . Alumno objAlumno03 = new Alumno ( ) .println ( (nota1 + nota2 + nota3 ) / 3 ) .promedio ( ) . objAlumno02. Ing.nota1 = 13 . objAlumno02. Aunque. esto ya se había realizado en la clase PrgAlumno es perfectamente válido haber pensado que esto era algo que había que hacer en la clase Alumno y no en la clase PrgAlumno. tiene mucho mas sentido que el cálculo lo realice la clase Alumno a través del método promedio( ).nota2 = 14 . Metodo que no devuelven valor y no reciben parámetros Talvez se tengan algunos problemas para comprender los conceptos que rodean a los métodos. poco a poco conforme se modifique el proyecto de solución ProyAlumno se podrán comprender mejor. objAlumno.nota3 = 11 .nota2 = 19 . anteriormente.nota3 = 15 . objAlumno03. objAlumno. Alumno objAlumno02 = new Alumno ( ) .

promedio ( ) .INTRODUCCIÓN AL DESARROLLO DE SOLUCIONES ORIENTADAS A OBJETOS Al ejecutar el proyecto se obtiene el siguiente resultado. Se calcula y visualiza el promedio de notas del objeto objAlumno03 en base a los valores de su copia de los atributos de instancia ( nota1 = 13.promedio ( ) . ubicadas dentro del método main( ) de la clase PrgAlumno. Esta sentencia es parte del método main( ) de la clase PrgAlumno y permite que se ejecute el método promedio( ) del objeto objAlumno definido en la clase Alumno. el cual es igual al resultado anterior: El promedio final del alumno es: 15 El promedio final del alumno es: 11 El promedio final del alumno es: 14 Las tres líneas siguientes.). Se calcula y visualiza el promedio de notas del objeto objAlumno en base a los valores de su copia de los atributos de instancia ( nota1 = 15.promedio ( ) . Se calcula y visualiza el promedio de notas del objeto objAlumno02 en base a los valores de su copia de los atributos de instancia ( nota1 = 11. Al igual que para acceder a las variables de instancia. El operador punto relaciona el nombre del objeto con el nombre de un método. se ejecuta el método promedio( ) utilizando el nombre de un objeto de la clase Alumno seguido por el operador punto. 545 . objAlumno03. • objAlumno03.promedio ( ) . Pag. objAlumno. Analicemos la siguiente sentencia. nota2 = 11 y nota3 = 11 ).promedio ( ) .promedio ( ) . Así. permiten ejecutar el método promedio( ) definido en la clase Alumno: objAlumno. Es decir.promedio ( ) . • objAlumno02. • objAlumno. nota2 = 14 y nota3 = 15 ). nota2 = 19 y nota3 = 11 ). objAlumno02. cuando se ejecuta. para acceder a los métodos se utiliza el operador punto (.

void promedio ( ) { System. cuando se ejecute el método promedio( ) se ejecutarán las dos sentencia que están dentro de su ámbito (es decir.out.println ( ( nota1 + nota2 + nota3 ) / 3 ) .print ( “ El promedio final del alumno es: ” ) . se puede referir a ella en forma directa utilizando solo su nombre. En el caso anterior. por lo que no es necesario especificar una sentencia return al final de este método. Ing. 546 . entre las llaves). tampoco tiene parámetros ya que al final del nombre del método los paréntesis se encuentran vacíos.print ( “ El promedio final del alumno es: ” ) . nota2 y nota3 se utilizan directamente sin estar precedidas del nombre del objeto y el operador punto (. En el ámbito del método promedio( ) se puede observar que las variables de instancia nota1. parámetros. Cuando un método utiliza una variable de instancia que ha sido definida en su misma clase.). void promedio ( ) { System. System. System. } La llave de apertura “{”.out. Todos los métodos definidos con void no devuelven valor.out.out. No devuelve No tiene valor. El método promedio().println ( (nota1 + nota2 + nota3 ) / 3 ) . Pag. } El método promedio( ) no devuelve ningún valor ya que tiene definido como tipo de retorno void. Juan José Flores Cueto. El ámbito de un método define todas las sentencias que se ejecutarán cuando el método se ejecute. Ahora. se analizará la definición del método promedio( ) de la clase Alumno. ubicada después del paréntesis y la llave de cierre “}” ubicada en la última línea definen el ámbito del método promedio( ).

// Calculamos el promedio de notas para cada alumno.nota2 = 19 . objAlumno. Pag.nota3 = 11 .INTRODUCCIÓN AL DESARROLLO DE SOLUCIONES ORIENTADAS A OBJETOS Métodos que devuelven valor y no reciben parámetros Aunque en el método promedio( ) se realiza el cálculo y visualización del promedio de notas.println ( “ La nota final de Luis es ” + prom + “.nota3 = 11 . double promedio ( ) { return ( nota1 + nota2 + nota3 ) / 3 . nota2.out. esto no constituye la mejor forma o alternativa de desarrollar dicho método. class Alumno { double nota1. A continuación se modificará el proyecto de solución ProyAlumno con la finalidad de mejorar la implementación del método promedio( ): package dominioDeLaAplicacion . nota3 . 547 . // También asignamos valores a las variables de instancia del objeto objAlumno02 objAlumno02. class PrgAlumno { public static void main ( String args [ ] ) { double prom . objAlumno02. } } package dominioDeLaAplicacion . Alumno objAlumno = new Alumno ( ) .nota1 = 15 . objAlumno03. objAlumno03. objAlumno. se puede realizar solo el cálculo del promedio de notas y devolver dicho valor para que este pueda ser utilizado de diferente forma. Esto se debe.nota1 = 11 . pero no todos necesitarán que una vez calculado el promedio de notas este se visualice.promedio ( ) . Con la finalidad de mejorar la implementación del método promedio( ). Alumno objAlumno02 = new Alumno ( ) . objAlumno02. System. // Ahora asignamos valores a las variables de instancia del objeto objAlumno.nota2 = 11 .nota2 = 14 . // Primero declaramos y creamos tres objetos de la clase Alumno.nota3 = 15 . Alumno objAlumno03 = new Alumno ( ) . prom = objAlumno. objAlumno. objAlumno03.” ) .nota1 = 13 . a que en mucho casos. // y a las variables de instancia del objeto objAlumno03. otras partes del método main( ) u otros métodos necesitarán que se ejecute el método promedio( ) para que se realice el cálculo del promedio de notas.

Esta sentencia es parte del método main( ) de la clase PrgAlumno y permite que se ejecute el método promedio( ) del objeto objAlumno definido en la clase Alumno. pero debido a que el método devuelve un valor. se muestra el valor de prom. System. un método que devuelve un valor. prom = prom + 1 . } } Para ejecutar. double promedio ( ) { return ( nota1 + nota2 + nota3 ) / 3 . Como el método promedio( ) devuelve un valor.promedio ( ) + “. System. Juan José Flores Cueto. se utiliza también el nombre del objeto. éste deberá ser asignado a una variable del mismo tipo que el valor devuelto por el método. y en el segundo caso. Una vez que prom ya tiene el valor devuelto por el método promedio( ) se puede procesar dicho valor según sea necesario.println ( “ La nota final de Pedro es ” + objAlumno03.println ( “ La nota final de María es ” + prom + “.) y el nombre del método. antes de mostrar el valor de prom se le suma 1. Ing. main( ) de la clase PrgAlumno. En el primer caso. 548 . } prom = objAlumno.out.promedio ( ) . Sentencia definida en el método Método definido en la clase Alumno. prom = objAlumno02.out. el operador punto (. En el ejemplo tenemos la siguiente sentencia: prom = objAlumno. Pag.promedio ( ) . Observe que la variable prom es del mismo tipo que el valor devuelto por el método promedio( ). entonces el valor devuelto será almacenado en la variable prom.” ) .” ) .promedio ( ) .

al ejecutar println( ). prom = prom + 1 . El tipo de dato que un método devuelve (con la sentencia return).” ) . se aumenta 1 y se muestra el resultado: prom = objAlumno02. } 2. 549 . Declarada como double. Observe la siguiente sentencia: System.INTRODUCCIÓN AL DESARROLLO DE SOLUCIONES ORIENTADAS A OBJETOS Se obtiene el promedio de notas y se muestra el resultado: prom = objAlumno.out.promedio ( ) . que se puede escribir estas sentencias de una manera más eficiente. La variable que recibe el valor devuelto por el método debe también ser compatible con el tipo de dato especificado por el método. se ejecuta a su vez el método objAlumno3.promedio ( ) + “. Se obtiene el promedio de notas.” ) . La ejecución del método promedio( ) se realiza directamente en la sentencia println(). Existen dos puntos importantes relacionados con los métodos que devuelven valor: 1. Es preciso mencionar.out.promedio ( ) . Lo cual es compatible con el tipo de dato especificado por el método. Aquí no se hace uso de la variable prom.promedio ( ) . Es decir. parámetros. Pag. debe ser compatible con el tipo de dato especificado por el método. Especifica que se debe devolver un No tiene valor double.out.println ( “ La nota final de María es ” + prom + “. System.promedio( ) y el valor devuelto se muestra a través de la pantalla.println ( “ La nota final de Pedro es ” + objAlumno03. double promedio ( ) { return (nota1 + nota2 + nota3 ) / 3 .println ( “ La nota final de Luis es ” + prom + “. System. prom = objAlumno.” ) .

prom = objAlumno. objAlumno03. Métodos que no devuelven valor y reciben parámetros Ahora. a través de sus parámetros. objAlumno.setNotas ( 11.promedio ( ) . Alumno objAlumno = new Alumno ( ) .11 ) . El método setNotas( ) recibirá.promedio ( ) .14. // Calculamos el promedio de notas para cada alumno. nota3 = c .setNotas ( 13. // Primero declaramos y creamos tres objetos de la clase Alumno. // y a los atributos de instancia del objeto objAlumno03. Juan José Flores Cueto. a que en problemas Java bien diseñados las variables de instancia deberían ser accesibles sólo a través de los métodos definidos por sus clases y no en forma directa. double c ) { nota1 = a . } } package dominioDeLaAplicacion . } void setNotas ( double a. 550 . double promedio ( ) { return ( nota1 + nota2 + nota3 ) / 3 . package dominioDeLaAplicacion . double b. Los parámetros generalizan el uso de un método permitiendo trabajar con diversos datos y utilizarlo en diferentes situaciones.out. Alumno objAlumno02 = new Alumno ( ) . El método se llamará setNotas( ) y permitirá asignar valores a las variables de instancia nota1.15 ) .” ) . fundamentalmente. // También asignamos valores a los atributos de instancia del objeto objAlumno02.11 ) . Ing.19.11. // Ahora asignamos valores a los atributos de instancia del objeto objAlumno. Esto debido. objAlumno02.println ( “ La nota final de Luis es ” + prom + “. class Alumno { double nota1. Pag. Alumno objAlumno03 = new Alumno ( ) . nota2. nota2 y nota3. class PrgAlumno { public static void main ( String args [ ] ) { double prom . nota2 = b .setNotas ( 15. se definirá un segundo método dentro de la clase Alumno. las notas de un alumno y las asignará a los atributos de instancia. nota3 . System. prom = objAlumno02.

Como el método setNotas( ) tiene definido 3 parámetros es necesario que al momento de ejecutar el método se incluya entre los paréntesis los 3 argumentos que se van ha enviar al método. double b. Sentencia definida en el método Método definido en la clase Alumno.11 ) . System.promedio() + “. Pag. double c ) { nota1 = a .19. } 3 ARGUMENTOS 3 PARÁMETROS Un argumento es un valor que se Un parámetro es una variable envía a un método cuando este definida por un método.setNotas ( 15. el nombre del método a ejecutar y los argumentos necesarios.” ). main() de la clase PrgAlumno.out. 551 . que es ejecutado.println ( “ La nota final de María es ” + prom + “. void setNotas ( double a.). nota3 = c .11 ) .out. System.” ) . } } Para ejecutar un método que tiene parámetros se utiliza el nombre del objeto.INTRODUCCIÓN AL DESARROLLO DE SOLUCIONES ORIENTADAS A OBJETOS prom = prom + 1 . nota2 = b .19.setNotas (15. En el ejemplo anterior tenemos: objAlumno. Esta sentencia es parte del método main( ) de la clase PrgAlumno( ) y permite ejecutar el método setNotas( ) del objeto objAlumno definido en la clase Alumno. el operado punto(. recibe un valor cuando se ejecuta dicho método.