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 ........................................................................................................ Método de las 6’D ............................................................................................... Etapas y pasos ...................................................................................... Resumen del método ............................................................................. Resultado de las etapas del método ...................................................... Marco de trabajo ................................................................................................. Modelamiento ..................................................................................................... Algoritmo ............................................................................................................. Programación ..................................................................................................... CAPÍTULO 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 25 27 28 35 36 37 39 45 54

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 ........................................................................................................ El paquete del lenguaje Java: java.lang ............................................................. Envoltorios de tipos de datos primitivos: wrappers. Introducción ........................................................................................... Métodos ................................................................................................. Problemas resueltos del 61 al 64 ........................................................... Funciones matemáticas: Clase Math. Introducción ........................................................................................... Métodos ................................................................................................. Problemas resueltos del 65 al 99 ........................................................... Manejo de cadenas: Clase String. Introducción ........................................................................................... Métodos ................................................................................................. Problemas resueltos del 100 al 130 ....................................................... Otras clases en Java. Problema resuelto 131 ........................................................................... 259 263 267 269 278 281 282 287 339 340 345 397

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

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

.

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

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

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

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

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

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

.

.

Marco de trabajo. Programación. . • Resultado de las etapas del método. Método de las 6’D: • Etapas y pasos. Modelamiento.Capítulo MÉTODO DE LAS 6’D Un Enfoque Algorítmico 1 Temas: Introducción. Algoritmo. • Resumen del método.

.

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

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

Pag.MÉTODO DE LAS 6’D – Un Enfoque Algorítmico. 27 . 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 Diseño Solución Ingeniería Reversa Etapa 04 Desarrollo Solución Etapa 05 Depuración Pruebas Etapa 06 Document.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

43 . Regla general para especificar los nombres de los paquetes. Pag. Si el nombre es compuesto. se tendrá clase Lectura1 que facilitará el ingreso de los datos a la computadora. Los nombres de los atributos se escriben en minúscula. Los nombres de los métodos cumplen las mismas características que los nombres de atributos a excepción de los métodos constructores. 1 La clase Lectura se trata en el Capítulo II y se especifica en el Apéndice. En caso que el nombre sea compuesto.MÉTODO DE LAS 6’D – Un Enfoque Algorítmico. clases. atributos y métodos: El nombre de la clase y el nombre del paquete deben comenzar con una letra mayúscula y el resto en minúscula. a partir de la segunda palabra se escribe la primera letra en mayúscula. todas las primeras letras de los nombres simples que forman el nombre de la clase o paquete deberán comenzar con mayúscula. En el paquete “biblioteca”.

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

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

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

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

Elementos o símbolos básicos: PROCESO Utilizado para asignar valores a variables y resultados de operaciones matemáticas. Juan José Flores Cueto. 48 .Ing. CONECTOR Este símbolo permite que no se crucen los flujos (líneas) en un diagrama. ENTRADA / SALIDA Utilizado para ingresar datos y visualizar información que resulta del procesamiento. Pag. la INICIO / FIN Este símbolo permite marcar el inicio y el final del algoritmo. FLUJOS (LINEAS) Líneas que permiten unir los diagramas y mostrar la secuencia lógica a la solución del problema.

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

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

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

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

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

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

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

el método principal es conocido como método main ( ). es aquella que tiene un significado especial para un lenguaje de programación. en el lenguaje de programación Java. Todas las clases que tienen especificado un “método principal”. No existe código que no esté contenido dentro de un método (a excepción de los bloques estáticos). Juan José Flores Cueto. En el caso de Java tenemos las siguientes: abstract byte char continue double final for implements int native package public static switch throw try while Palabras reservadas en Java boolean catch case do class extends default float else if finally instanceof import long interface null new protected private short return super strictfp this synchronized transient throws volatile void widefp break Pag. Todos los lenguajes tienen palabras claves. se utiliza las siguientes sentencias: public static void main (String arg[]) Por lo tanto. En el lenguaje de programación Java. Palabras reservadas en Java: Una palabra reservada o palabra clave. 56 . Todo el código ejecutable reside dentro de los métodos de la clase. Es importante comprender que una clase está constituida por atributos y métodos. Existen clases que tienen un método especial conocido como “método principal”.Ing. para especificar que una clase tiene un “método principal”. son clases que pueden ejecutarse.

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

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

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

.

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 lista completa de los pasos se desarrolla utilizando las estructuras lógicas y las instrucciones de bifurcación. mientras que los datos se almacenan en las estructuras de datos. La acción de escribir un programa para computadoras se conoce como codificación.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. 61 . La programación es la traducción del modelamiento y los algoritmos en sentencias que una computadora puede comprender y ejecutar. Un algoritmo constituye una lista completa de los pasos y una descripción de los datos que son necesarios para resolver un determinado problema en el ámbito de un método.

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

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

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

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

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

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

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

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

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

// La siguiente línea no genera error. Esto es válido ya que el tipo de dato long en Java es de mayor precisión que el tipo de dato int. long numEnteroGrande . numEnteroGrande = numEntero . // Se visualiza 5 System. 71 . 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. Pero como toda regla. short. long. class PrgTipoDato04 { public static void main ( String arg [ ] ) { int numEntero = 5 . long.out. También se puede aplicar sobre el tipo de dato char. int.println ( numEnteroGrande ) . float y double. es decir entre datos de tipo byte. 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. Pag.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. y la excepción para estos casos se denomina conversión de datos. La conversión de datos se aplica generalmente sobre los tipos de datos numéricos. mas grande) y son generadas automáticamente por el compilador Java. float y double Ejemplos. int. } } 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). 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. esta también tiene su excepción. short. Clase PrgTipoDato04 package dominioDeLaAplicacion .

Ing. se da de un tipo de dato de menor precisión a uno de mayor precisión. 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. numReal = caracter . El cast se realiza colocando entre paréntesis Pag. En ambos casos. el programa indicará un error.0 System. La conversión implícita de datos en Java. class PrgTipoDato05 { public static void main ( String arg [ ] ) { char caracter = ‘a’ . } } 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. 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 . 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. Clase PrgTipoDato05 package dominioDeLaAplicacion . // Se visualiza 97.println ( numReal ) . por lo que se visualiza 97.0 (la letra a en código ASCII es 97). // La siguiente línea no genera error. Juan José Flores Cueto. Estás conversiones son inseguras y puedan dar lugar a errores.out. Lado izquierdo de la expresión En caso contrario. Este tipo de conversión de datos se le denomina también cast (casting). 72 . double numReal . si el lado derecho de la expresión tiene un tipo de dato más amplio que el lado izquierdo.

class PrgTipoDato07 { public static void main ( String arg [ ] ) { double num1 = 20.out. Ejemplo. System. System. div = num1 / num2 . int div . div = ( int ) ( num1 / num2 ) .ESTRUCTURAS FUNDAMENTALES PARA LA SOLUCIÓN DE PROBLEMAS el tipo de dato al que se desea convertir el resultado de una expresión. int div . class PrgTipoDato06 { public static void main ( String arg [ ] ) { double num1 = 20.println ( div ) .println ( div ) . num2 = 3 . 73 . Pag. Finalmente. entre otras. } } 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). } } Clase PrgTipoDato07 package dominioDeLaAplicacion . // La siguiente línea no genera error. // La siguiente línea genera error.out. Clase PrgTipoDato06 package dominioDeLaAplicacion . num2 = 3 . // Se visualiza 6. 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.

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

. Este tipo de estructura permite mostrar información a través de un dispositivo de salida de una computadora.La regla. 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. En pseudocódigo.El símbolo. finalizada la ejecución de una instrucción.La clase. Tipos: 1. 75 . 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. System En Java. En diagrama de flujo. Las instrucciones se ejecutan una a una de tal modo que. se inicia la ejecución de la siguiente hasta completar la ejecución de todas las instrucciones que forman parte de la secuencia.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. Representación: Para representar la salida o visualización de la información se utiliza: . Pag. ESCRIBIR .

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

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

-. *.. /). FIN EXPLICACIÓN: Todas las instrucciones que son parte de la solución del problema deberán aparecer entre las reglas INICIO y FIN. Estas instrucciones se ejecutarán 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: O lógico: Negación: En Java: Y lógico: O lógico: Negación: && || ~ Y (AND) O (OR) N (NOT) Formatos: Formato para diseñar algoritmos: Pseudocódigo INICIO Instrucciones . Representación: Para representar las operaciones aritméticas se utilizan los mismos signos que se emplean en la aritmética tradicional (+. 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. 78 .Ing. Juan José Flores Cueto. Pag.

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

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. no se ejecutan las instrucciones que se encuentran entre las reglas ENTONCES y FINSI. Las Estructuras Lógicas de Decisión son conocidas también como Estructuras de Selección. Tipos: 1. 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. SI (condición) ENTONCES instrucciones... de tal forma que en función de una condición o el valor de una variable. Formato para diseñar algoritmos: Pseudocódigo EXPLICACIÓN: Si la condición resulta verdadera. Este tipo de estructura es útil cuando se tiene la posibilidad de escoger una determinada opción. 80 . Estructuras lógicas de decisión simple Definición: Una estructura de decisión simple “SI.Ing. FINSI Pag... Juan José Flores Cueto. se pueda desviar la secuencia de la solución entre diferentes alternativas. se ejecutan las instrucciones que se encuentran entre las reglas ENTONCES y FINSI. Si la condición resulta falsa.

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

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

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

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

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. 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. El flujo con la regla OTROS es opcional. Pag. se ejecutan las instrucciones que están seguidas del flujo (las que indica la flecha).

se deberá utilizar un caracter encerrado entre comillas simples después de la palabra reservada case.. Cuando se codifique un algoritmo recuerde que se tiene que seguir las reglas del lenguaje de programación que usará. caso contrario. En caso que la variable sea de tipo caracter (definida con la palabra reservada char). Cuando se diseñe un algoritmo que necesite utilizar estructuras de decisión.. 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. switch (variable) { case valor 1 : sentencias. } 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. default : sentencias. Si la variable es de tipo entero (definida con la palabra reservada int). se dará con la sorpresa que tendrá errores de sintaxis. valor 2.. se ejecutan las sentencias que están dentro de la palabra reservada default. se debe emplear correctamente los formatos establecidos.. se ejecutan las sentencias que están dentro del mismo hasta llegar al final (es decir hasta la llave) a no ser que encuentre una palabra reservada break entre las sentencias que se ejecutan. Si el valor de la variable no es igual a ninguno de los valores colocados después de una de las palabras reservadas case. al momento de ejecutar un programa.. case valor n : sentencias. La palabra reservada default es opcional (es decir puede aparecer como no). ya que estos constituyen lo que denominamos un “estándar” o acuerdo. 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.. 86 ... Juan José Flores Cueto. Pag. se deberá utilizar números enteros después de la palabra reservada case.Ing. etc). case valor 2 : sentencias.

en función de una condición o el valor de una variable. de tal forma que. 87 . Formato para diseñar algoritmos: Pseudocódigo DESDE i = valorInicial HASTA valorFinal INCREMENTA valor instrucción 1 . Tipos: 1. FINDESDE” permite repetir una instrucción. 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. Estructura lógica de repetición “DESDE” Definición: Una estructura de repetición “DESDE.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. o un bloque de instrucciones.. . se pueda repetir un conjunto de pasos un determinado número de veces.. Este tipo de estructura es útil cuando se necesita repetir una instrucción o bloque de instrucciones un cierto número de veces. Una estructura lógica de repetición “DESDE. instrucción n FINDESDE Pag. Las Estructuras Lógicas de Repetición son conocidas también como estructuras de iteración o bucles.. un número determinado de veces o hasta que una condición se cumpla. ..

EXPLICACIÓN: Esta estructura tiene tres partes: 1. 88 . Prueba: HASTA valorFinal 3.Ing. En caso que la variable índice sea igual a valorFinal. 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. FINDESDE y permite asignar un valor inicial a la variable “i” o la que se utilice en vez de ésta. También existe la posibilidad de reducir el valor de la variable índice “i”. en este caso. se procede a ejecutar esta parte. El equivalente de esta estructura en diagrama de flujo se muestra a continuación: Pag.. Incremento: INCREMENTA valor Cada vez que finaliza la ejecución de las instrucciones o bloque de instrucciones ubicadas entre las reglas DESDE y FINDESDE. Si la variable índice no es igual a valorFinal. 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. se utiliza la regla DECREMENTA en lugar de la regla INCREMENTA. 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. Una vez que se termina de INCREMENTAR o DECREMENTAR la variable índice. Aquí se evalúa si la variable índice es igual a valorFinal. se volverá a ejecutar las instrucciones o bloque de instrucciones ubicadas entre las reglas DESDE y FINDESDE. 2.. Juan José Flores Cueto. 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.

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. instrucciones. Pag.. Ambas reglas se encuentran dentro del símbolo que representa la regla o pauta DESDE.ESTRUCTURAS FUNDAMENTALES PARA LA SOLUCIÓN DE PROBLEMAS Diagrama de Flujo DESDE i HASTA z INCREMENTA x FALSO VERDADERO .. ... 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. 89 .

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

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

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

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

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

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

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

Esta sentencia permite salir anticipadamente de una iteracción de un bucle. Esta sentencia se utiliza para volver explícitamente de un método. 97 . 2. 3. es decir. 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. 1. se utilizan las instrucciones de bifurcación o salto. cuando se encuentra la sentencia continue se ejecuta la siguiente iteracción del bucle sin procesar el resto del código. Instrucción “CONTINUAR” En Java. 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). Para esto. esta sentencia permite que el control de la ejecución de la solución vuelva al método llamante. esta instrucción de bifurcación es conocida como la sentencia continue. sin analizar la condición y sin ejecutar el resto de código del cuerpo del bucle. Instrucción “TERMINAR”. Se utiliza para salir de un bucle. Pag. esta instrucción de bifurcación es conocida como la sentencia return. En Java. Instrucción “RETORNAR” En Java. 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).

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Algoritmo PrgHospital . Diseño de algoritmo para el método principal.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. sexo CUANDO tipoEnfermedad SEA CASO 1 : costoTotal = 200 * dias SI (sexo = 2 ) ENTONCES costoTotal = costoTotal * 1. dias. sexo costoTotal INICIO NUMERO tipoEnfermedad = 0. costoTotal = 0 LEER tipoEnfermedad. dias = 0.método main ( ) ENTRADA: SALIDA: tipoEnfermedad. dias.ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS 4. 139 .

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

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

n2 = 0. n3 menor. Diseño de algoritmo para el método principal. intermedio.método main ( ) ENTRADA: SALIDA: INICIO NUMERO n1 = 0. n3 = 0. intermedio = 0 NUMERO mayor = 0 LEER n1. mayor Pag. Juan José Flores Cueto. intermedio. 142 . menor = 0. Algoritmo PrgOrdena . mayor FIN n1. n2.Ing. 4. n2. 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.

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

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

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

146 . n4.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 n1. n2. n3. n3 = 0.Ing. Algoritmo PrgCategoriaAlumno . n2 = 0. 4. n4. 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 .método main ( ) ENTRADA: SALIDA: INICIO NUMERO n1 = 0. n5 = 0. n5 categoria Pag. n3. promedio = 0 TEXTO categoria = ‘ ’ LEER n1. sumaNotas = 0 NUMERO notaMenor = 0. n2. n4 = 0. Juan José Flores Cueto. Diseño de algoritmo para el método principal.

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

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

Diseño de algoritmo para el método principal. 149 . Clases dominioDeLaAplicacion Clases biblioteca 4. edad categoria Pag.ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS 3. Algoritmo PrgCategoriaPostulante .método main ( ) ENTRADA: SALIDA: INICIO NUMERO edad = 0 TEXTO sexo = ‘F’. categoria = 0 LEER sexo. Definición de las Clases. 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 sexo.

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

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

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

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

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

n3. 155 . 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. n2 = 0. n2. n3. Diseño de algoritmo para el método principal. n4. n2. n1 = 0. Clases dominioDeLaAplicacion Clases biblioteca 4. nf = 0 TEXTO continua = ‘ ’ HACER LEER n1. continua SALIDA: nf INICIO NUMERO i = 1. Algoritmo PrgNotasAlumnos2 . n3 = 0. n4 = 0.ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS 3.método main ( ) ENTRADA: n1.

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

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

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

ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS 4. Diseño de algoritmo para el método principal. mayorSueldo = 0 NUMERO menorSueldo = 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. mayorSueldo. 159 . categoria = 0. sueldo2. Algoritmo PrgSueldoCategoria . sueldo3 ESCRIBIR menorSueldo. sueldo3. sueldo2. mayorSueldo FIN sueldo. sueldo2 = 0 NUMERO sueldo3 = 0.método main ( ) ENTRADA: SALIDA: INICIO NUMERO sueldo = 0. menorSueldo Pag. sueldo1 = 0. categoria sueldo1.

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

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

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

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

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

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

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

totalMez FIN costoPla. 167 . costoPal. gananciaPal = 0 NUMERO ganaciaMez = 0 LEER costoPla. costoPal.método main ( ) ENTRADA: SALIDA: INICIO NUMERO numBoleto = 0. Diseño de algoritmo para el método principal.ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS 4. totalGanancia. costoMez = 0 NUMERO totalGanancia =0. totalVendidas = 0 NUMERO totalPla = 0. costoMez totalVendidas. totalPla. totalMez = 0 NUMERO costoPla = 0. totalPal. totaMez Pag. gananciaPla = 0. Algoritmo PrgTeatro . totalPal. tipo = 0. 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. totalPal = 0. costoPal = 0.

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

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

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

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

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

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

Descripción del problema. Datos necesarios: Procesamiento: Pag. edad y nota). edad y nota de cada uno de los alumnos del curso. 174 . Resultado deseado: Número de alumnas matriculadas. Problema 22 Etapa 01 . Sexo. mayores de 18 años y aprobados. la edad y la nota de cada alumno se ingresarán a través del teclado y se almacenarán en variables (sexo. así como una variable que determine si se continúa o no con el ingreso de los datos de un nuevo alumno. Si es una alumna o es un alumno incrementaremos las variables correspondientes (matriculadas y matriculados). Dicha respuesta será almacenada en una variable (rpta). El sexo.Ing. menores de 20 años y desaprobadas. 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 . Este proceso se repetirá mientras el usuario confirme su deseo de ingresar los datos de otro alumno. además número de alumnos matriculados. Juan José Flores Cueto. 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.Definición de la solución.

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

4. rpta matriculadas. Diseño de algoritmo para el método principal.método main ( ) ENTRADA: SALIDA: INICIO NUMERO i = 0. aprobados Pag. ” 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 sexo. desaprobadas. aprobados = 0 TEXTO sexo = ‘F’. Juan José Flores Cueto. edad. edad = 0. matriculados.Ing. Algoritmo PrgClase . nota. 176 . 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. matriculadas = 0. mayores = 0. mayores. ” FINSI MIENTRAS (edad <= 0) HACER LEER nota SI (nota < 0 OR nota > 20) ENTONCES ESCRIBIR “ La nota no es válida. menores. nota = 0. matriculados = 0 NUMERO menores = 0. ” 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. desaprobadas = 0.

Algoritmo PrgClase . 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.ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS Continúa… 4. Diseño de algoritmo para el método principal.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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Pag. 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”. … … … … … } catch ( ) { // Código de tratamiento de la excepción. se deberá capturar la excepción lanzada y manejarla. una entrada incorrecta de datos (IOException). Para evitar que la ejecución de un programa se detenga debido a un error que lanza una excepción. El formato de la sentencia try y catch es el siguiente: try { // Código de la aplicación. … … … … … } Tipo de excepción capturada por la sentencia catch con la finalidad de manejarla.ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS MANEJO DE EXCEPCIONES Cuando se está ejecutando un programa y ocurre un error. y utilizar la sentencia catch para capturar y manejar cada una de las excepciones que se puedan lanzar. Existen diversos errores que pueden ocasionar que se lance una excepción en un programa. una división por cero (ArithmeticException) o una conversión de datos no válida (NumberFormatException). 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. 195 . Ahora. por ejemplo. Las excepciones en Java son objetos de subclases de la clase Throwable. se debe utilizar la sentencia try para alertar al programa acerca del código que puede ocasionar un error. no ocurren). si se desea que la ejecución del programa no se detenga.

existen diferentes tipos de excepciones por lo que es común observar en un programa una sentencia try con varias sentencias catch. no se lanzará ninguna excepción. 196 . Cada sentencia catch capturará y manejara un excepción. */ … … } de la excepción la excepción En el ejemplo anterior. 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. 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. se ha especificado capturar dos excepciones en caso de que estás se lancen (ArithmeticException y NumberFormatException). se lanzará una excepción. Si ocurre un error. Como se ha indicado. Pag.*/ … … } catch ( ArithmeticException e ) { /* Código de tratamiento de ArithmeticException. Juan José Flores Cueto.Ing. … … } Si no ocurre un error. lo que significa que las sentencias que están entre las llaves de la sentencia catch no se ejecutarán. */ … … } catch ( NumberFormatException e ) { /* Código de tratamiento NumberFormatException.

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. Se intentó utilizar null donde se requería un objeto. Un arreglo fué accedido con un índice ilegal (fuera de los límites permitidos). Se intentó convertir una cadena con un formato inapropiado a un número. 197 . En la actualidad. se considera como “buen estilo de programación” el uso de las excepciones en los programas. NumberFormatException IOException ArrayIndexOutOfBoundException NullPointerException Pag. Como ejemplo de excepciones se puede mencionar: Excepción ArithmeticException Descripción Una condición aritmética excepcional ocurrio. separando explícitamente el código que maneja los errores del código básico de una aplicación. Problemas al realizar operaciones de entrada y salida de datos.

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

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

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

en cualquier parte del formato indicado.. System.out. ingrese letras en lugar de números. ” ) .ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS Clase PrgHoraConExcepcion } catch ( NumberFormatException error ) { System. 201 . valido = true .println ( “Error. Puede probar el programa ingresando como hora lo siguiente: 23:10:xx Es decir..out. Pag.println ( “ La hora se ingresó correctamente. ” ) .. 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 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. } } while ( valido ) ..

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

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...out. System. ” ) .out. System. continue el programa validando el valor ” ) .println ( “ El formato esta correcto. mes y año ” ) . if ( valido ) System.. } } 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..print ( “ Ahora Ud..out. Ingrese la fecha según formato!!! ” ) . // Continúa la validación de la fecha. System. Pag.println ( “ Error.ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS Clase PrgFechaConExcepcion } else valido = true .. 203 . ingrese letras en lugar de números (inclusive en el lugar del / ). en cualquier parte del formato indicado. } while ( valido ) .println ( “ de las variable dia.out. ver problema 24 y 127.

num1 = Integer. 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. 5 ) . Etapa 04 .out.parseInt ( tmp ) .length ( ) == 8 ) { try { tmp = numeros.Ing.equals ( “//” ) ) { valido = false .substring ( 0. puntos1 = numeros. if ( puntos1. tmp = numeros. Juan José Flores Cueto.parseInt ( tmp ) .Lectura . class PrgNumeroConExcepcion { public static void main ( String arg [ ] ) { boolean valido = true . System. resultado = num1 / num2 . Clase PrgNumeroConExcepcion package dominioDeLaAplicacion .println ( “ La división es: ” + resultado ) . int num1.println ( “ Ingrese dos números con el formato: nnn//nnn ” ) . tmp. Manejar excepciones. Problema 31 Etapa 01 .Descripción del problema. if ( numeros. 204 . num2 = Integer. Validar que los números sean de tres cifras y mostrar la división de los mismos. num2 . import biblioteca.trim ( ) . numeros = numeros. puntos1 . do { System. numeros = Lectura. String numeros.out. 3 ) . double resultado .substring ( 3. } Pag.Desarrollo de la Codificación.leerString ( ) .substring ( 5 ) . } 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.println ( “ Formato no válido ” ) .out. } } 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. Ingrese en el formato indicado!!! ” ) . Puede probar el programa ingresando como números lo siguiente: aaa//123 Es decir.println ( “ No se puede dividir un número entre cero ” ) .out. 205 .println ( “ Error. } if ( valido ) { System.ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS Clase PrgNumeroConExcepcion } catch ( NumberFormatException error ) { System. ingrese letras en lugar de números (inclusive en el lugar de las // ).out. en cualquier parte del formato indicado. valido = true . 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. } catch ( ArithmeticException error ) { System. Pag.. } } else { valido = true . } } while ( valido ) .. valido = false .

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

desarrollando soluciones y codificándolas en un lenguaje de programación determinado. lenguaje de programación utilizado en el presente texto. con la finalidad de utilizarlas en forma conjunta y lograr desarrollar sus capacidades lógicas. 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. como por ejemplo el lenguaje de programación Java. 207 . Existen problemas que por su naturaleza contribuyen de manera significativa a lograr este objetivo. los cuales se desarrollan en esta última parte del presente capítulo. Pag. es necesario que comprenda los conceptos fundamentales relacionados a las estructuras lógicas y las estructuras de datos elementales.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. El desarrollo de las capacidades lógicas se logra con la práctica. Es decir.

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

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

Entonces. Esta situación determina la existencia de la segunda sentencia for dentro de la primera sentencia for (for interno). Los siguientes 2 problemas son una variación de este problema. j++ ) { … } … } Para cada una de las filas (en el caso de totalFilas=5. Cada vez que finaliza el for interno. por lo cual podemos afirmar que para cada valor de i. Los valores válidos de i coinciden con el número de filas que nuestra figura va ha tener.out. j <= totalFilas. i=2. Analice sus respectivas soluciones y desarrolle sus propias observaciones. para 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 <= totalFilas. 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. los valores válidos para i son i=1. 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. i=4 e i=5). Pag. Para nuestra explicación asumiremos que el valor de totalFilas=5.println ( ). la cual puede variar desde 2 hasta 20. i=2. el for interno se ejecuta 5 veces y mostrará en total 5 asteriscos en cada una de las filas). la sentencia System. i=3. 210 . i=4 e i=5). i++ ) { for ( j = 1 . Para fila=5: 1ra fila ( i=1 ) 2da fila ( i=2 ) 3ra fila ( i=3 ) 4ta fila ( i=4 ) 5ta fila ( i=5 ) * * * * * * * * * * * * * * * * * * * * * * * * * for ( i = 1 . i <= totalFilas. i=3. 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. for ( i = 1 . Juan José Flores Cueto. corresponde una fila de la figura.Ing. i++ ) { } 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).

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

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

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

j=2. Para nuestra explicación asumiremos que el valor de totalFilas=5. los valores válidos para i son i=1. En la segunda fila (i=2) se necesita mostrar dos asterisco. la sentencia System. j++ ) { … } … } En la primera fila (i=1) se necesita mostrar un asterisco. Y así sucesivamente hasta llegar a la última fila. i <= totalFilas. Entonces. i=3. nos permite hacer un salto de línea.out. i++ ) { } Ahora necesitamos mostrar un asterisco en la primera fila (i=1). En nuestro caso la última fila es 5 (i=5) y se necesita mostrar 5 asteriscos. i=4 e i=5).println ( ). Esta situación determina la existencia de la segunda sentencia for dentro de la primera sentencia for (for interno). nos permite hacer un salto de línea. Es decir. i=2.out. corresponde una fila de la figura. i <= totalFilas. j <= i . 215 . 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. 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. Esto se cumple ya que para i=2 los valores válidos para j serían j=1 y j=2. 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).println ( ). pasar a la tercera fila. Es decir. Para fila=5: 1ra fila ( i=1 ) 2da fila ( i=2 ) 3ra fila ( i=3 ) 4ta fila ( i=4 ) 5ta fila ( i=5 ) * * * * * * * * * * * * * * * for ( i = 1 . pasar a la segunda fila. j=4 y j=5. por lo que el for interno se ejecutaría una sola vez y se mostraría solo un asterisco. j=3. Finalizada la ejecución del for interno. la cual puede variar desde 2 hasta 20.Esto se cumple ya que para i=5. Esto se cumple ya que para i=1 el único valor válido para j sería j=1. los valores válidos para j serían j=1. Los valores válidos de i coinciden con el número de filas que nuestra figura va ha tener. la sentencia System. Finalizada la ejecución del for interno. 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). i++ ) { for ( j = 1 . por lo que el for interno Pag.

Juan José Flores Cueto. Los siguientes 7 problemas son una variación de este problema. 216 . Analice sus respectivas soluciones y desarrolle sus propias observaciones. Luego se hace un salto de linea y se finaliza la ejecución. 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).Ing. Pag.

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

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

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

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

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

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

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

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.Ing. 224 . Los últimos siete problemas son una variación del problema 35. Juan José Flores Cueto.

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

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

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

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

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

En la primera fila (i=1) se muestran fila .* . hasta llegar a la última fila donde no se muestra ningún espacio en blanco. Ahora.* . 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. lo cual nos complica la lógica de nuestra solución. la cual puede variar desde 2 hasta 20.1 espacio en blanco y luego se muestra un espacio en blanco menos cada vez que se muestra una nueva fila. Pero si observamos bien la figura tenemos que tener en cuenta la ubicación de los asteriscos en cada fila. Para fila=5: 1ra fila ( i=1 ) 2da fila ( i=2 ) 3ra fila ( i=3 ) 4ta fila ( i=4 ) 5ta fila ( i=5 ) * * * * * * * * * * * * * * * for ( i = 1 .* - * * * * . i <= totalFilas .* Nota: Se determina que existe una relación en la parte donde están los espacios en blanco.* * .* * ...* .* Nota: Los guiones representan espacios en blanco. 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.* . Pag.. Para nuestra explicación asumiremos que el valor de totalFilas=5. 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: . 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).Ing.* * .* .. Es necesario encontrar algunos parámetros para establecer una constante matemática (una relación matemática) que nos permita mostrar adecuadamente la figura. un asterisco. Juan José Flores Cueto. Cada vez que se ejecuta el primer for debemos asegurarnos de mostrar los asteriscos necesarios.* . i++ ) { } Es necesario entonces mostrar un asterisco en la primera fila (i=1). Entre un guión y un asterisco no hay ningún símbolo. 230 . 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): * * - * * * * - * * * * ..* ..

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

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

print ( “ ”) .print ( “ ”) . 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). } else { // Se muestra un espacio en blanco. } } System. Utilice el primer planteamiento desarrollado. j++ ) { if ( j > totalFilas . System. i <= totalFilas . j ++ .* - for ( i = 1 .print ( “* ”) .out. } else { // Se muestra un espacio en blanco. } Pag.println ( ) . System. En el for interno hay una sentencia if que nos permite determinar el símbolo que se va ha mostrar. System. i <= totalFilas .i ) { // Se muestra un asterisco y un espacio en blanco.* * . System. } else { // Se muestra un asterisco y un espacio en blanco.out. System.out.println ( ) .i ) { // Se muestra un espacio en blanco. if ( ( j >= totalFilas – cont ) && ( j <= totalFilas + cont ) ) { // Se muestra un asterisco y un espacio en blanco. 233 .out. System. i++ ) { for ( j = 1 .out. } Ahora.out. } } System. i++ ) { for ( j = 1 .out.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). j++ ) { if ( j <= totalFilas .print ( “* ”) . Analice nuevamente el siguiente gráfico: * * - * * * * - * * * * * - * .out. nuevamente intente mejorar la solución.print ( “* ”) .print ( “ ”) . j <= totalFilas . j <= totalFilas . } También: for ( i = 1 .

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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 7 6 4 - 2 0 2 - 8 - 7 3

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

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

Clases Básicas Incorporadas en el Lenguaje de Programación Java

Capítulo

3

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

2 1 Pag. Una clase es una implantación de un “tipo de objeto”. Clase: Colección de objetos del mismo tipo. trata sobre las clases básicas incorporadas en el lenguaje de 1 programación Java. 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). Un paquete contiene clases que tienen funciones similares. 2 Paquete: Conjunto de clases similares.lang. 261 . Es importante mencionar que utilizando las clases preprogramadas de Java se puede ahorrar mucho tiempo y esfuerzo de programación. Una clase es una abstracción y no referencia a ningún objeto en particular. agrupadas en el paquete java. Un paquete permiten organizar las clases. 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.

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

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

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

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

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

long. interesa sacrificar parte de la eficiencia por flexibilidad. Existe una clase wrapper para cada uno de los tipos de datos primitivos. int. Java tiene su propia jerarquía de clases. 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. que permiten tratarlos como objetos. Dichas clases se muestran a continuación: TIPO DE DATO PRIMITIVO boolean byte char double float int Long CLASES WRAPPERS Boolean Byte Character Double Float Integer Long 9 Jerarquía de clases: Forma de ordenar las clases. float. char. comprobación. Dichas clases son conocidas como las clases wrappers (envoltorios). En ocasiones. conocidos también como tipos de datos simples.lang). La jerarquía de clases es una forma de ordenar las clases existentes en un lenguaje de Programación Orientado a Objetos (POO). 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. Pag. entre otras. la clase Object (esta clase pertenece al paquete java. traslación. Esto tiene algunas ventajas desde el punto de vista de la eficiencia. double. tales como la conversión con cadenas de caracteres. 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. 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. byte. tal y como se representan en un lenguaje de programación convencional.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. short). 267 . son los únicos elementos del lenguaje de programación Java que se representan internamente a través de valores. estando en la parte superior de la jerarquía.

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

Las variables son: VARIABLE i l f d b c TIPO DE DATO PRIMITIVO int long float double boolean char Para referirnos a objetos se utilizará una letra en mayúscula. mientras que. Se asume que los objetos han sido creados previamente. se utilizarán algunos objetos de dichas clases. Pag. para referirnos a las variables se utilizará una letra minúscula.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. comprobación y traslación de datos. Dichos objetos son: CLASE AL QUE PERTENECE String Integer Long Float Double Character OBJETO S I L F D C También se utilizarán algunas variables para lo cual se deberá asumir que dichas variables han sido declaradas previamente. 269 .

toString ( d ) .toString ( f ) . a un valor de tipo cadena contenido en un objeto String. Pag. L. Conversión de tipo de dato primitivo a objeto String utilizando clases wrappers y variables: OBJETO STRING S S S S = = = = CLASES WRAPPERS Y VARIABLES Integer. Float. Conversión de tipo de dato primitivo a objeto String Se puede convertir el valor de un tipo de dato primitivo o simple. o utilizar objetos de las clases wrappers.toString (i ) .toString ( ) . 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). 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. A pesar que el método toString ( ) es un método estático o de clase. 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. F. Conversión de tipo de dato primitivo a objeto String utilizando objetos wrappers: OBJETO STRING S S S S = = = = OBJETOS WRAPPERS I.toString ( ) . también puede ejecutarse utilizando un objeto. Double. 270 . D. Para realizar esta conversión. Juan José Flores Cueto. se puede utilizar clases wrappers y variables.toString ( l ) . 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. Long.toString ( ) .toString ( ) .Ing.

Float.valueOf (S) . Long. Long. Double. es el método toString ( ). Esto se debe. parseLong ( ).valueOf (S) .parseFloat (S) . a que este método no pertenece a dichas clases. Observe que se utiliza el método valueOf ( ) para convertir el valor contenido en el objeto String S. También se tiene la posibilidad de utilizar los métodos parseInt ( ). a un dato de tipo primitivo o valor de una variable. Long. Integer. parseFloat ( ) y parseDouble ( ) para los wrappers Integer.parseInt (S) .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 ( ). Conversión de objetos String a tipos de dato primitivo. Double.valueOf (S) .parseLong (S) . siempre y cuando el objeto String contenga un dato equivalente al tipo de dato primitivo que se desea convertir. y uno de los métodos definidos en esta clase. 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). como ya se ha mencionado. utilizando clases wrappers y objeto String: VARIABLE i l f d = = = = WRAPPERS Y OBJETO STRING Integer. 271 .valueOf (S) .parseDouble (S) . | Conversión de objetos String a tipo de dato primitivo Se puede convertir un objeto String a un tipo de dato primitivo. Todas las clases en Java pueden utilizar los métodos definidos en la clase Object (debido fundamentalmente a la herencia). sino que pertenece a la clase Object. Este método es un método estático o de clase. Float y Double respectivamente. Float. Pag.

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

El método devuelve true si el valor de la variable no es un número. Pag.0.isNaN ( d ). 273 . Double.0 / 0. Observe que se utiliza el método isNaN ( ) para determinar si la variable es o no un número. Double.isInfinite ( f ) .isNaN ( ). Comprobación del valor Not-a-Number utilizando clases wrappers y variables: VARIABLE b = OBJETOS WRAPPERS F.isNaN ( ) . Los valores Not-a-Number proceden de indeterminaciones tales como por ejemplo el resultado de la siguiente operación: 0. D.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: VARIABLE b = CLASES WRAPPERS Y VARIABLES Float.isInfinite ( d ). Comprobaciones del valor infinito Comprobación del valor infinito utilizando clases wrappers y variables: VARIABLE b = CLASES WRAPPERS Y VARIABLES Float.isNaN ( f ) .

Comprobación del valor infinito utilizando objetos wrappers: VARIABLE b = OBJETOS WRAPPERS F.isInfinite ( ).Ing.isLowerCase (c) . “Devuelve true si el caracter es una letra mayúscula”. Character.isUpperCase (c) .isDigit (c) . 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. D.0. 274 .isSpace (c) . Juan José Flores Cueto. “Devuelve true si el caracter es un espacio en blanco”.5 / 0. Character. El método devuelve true si el valor de la variable es un número infinito. 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 caracter es una letra minúscula”. b = Character. Pag. Por ejemplo el resultado de la siguiente operación: 10. Character.isInfinite ( ) . “Devuelve true si el caracter es un dígito decimal”.

“Convierte el caracter a una letra mayúscula”. Character. 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 caracter a una letra minúscula”.toUpperCase (c). c = Character. Pag.toLowerCase (c).

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

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

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

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

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

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

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

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

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

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

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

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

tal y como se muestra a continuación: resultado = Math.max ( num2. Pag. Juan José Flores Cueto. retorna el valor del número mayor (puede ser un número float. 288 . int o long) de dos números dados como parámetros. double. 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. El método max ( ) de la clase Math.Ing. Observe que en esta solución se emplea una estrategia mas simple para determinar el número mayor entre tres números. 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). Math. 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. num3 ) ) .max ( num1.

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

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

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

Descripción del problema. Problema 68 Etapa 01 . System. System. Mostrar los números aleatorios que son números pares. import biblioteca. Pag. Clase PrgNumAleatoriosPares package dominioDeLaAplicacion .Ing.leerInt( ) .random( ) * 10 ) . cant. cant = Lectura. Juan José Flores Cueto.print ( “Ingresar la cantidad de números aleatorios a generar: ” ) . } } ¿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. 292 .Lectura .out.Desarrollo de la Codificación. Los números aleatorios generados deberán estar entre 1 y 10.print ( num + “ \t ” ) . 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. Desarrollar un programa en Java que permita generar una cantidad determinada de números aleatorios. cont = 0 . do { num = 1 + (int) ( Math. num.out. Etapa 04 . if (num % 2 == 0) { cont++. class PrgNumAleatoriosPares { public static void main ( String arg [ ] ) { int x. } } while (cant != cont) .

do { num = 1 + (int) ( Math. } } while ( cant != cont ) .out. 293 .print ( num + “ \t ” ) . System. import biblioteca.print ( “Ingresar la cantidad de números aleatorios a generar: ” ) . Etapa 04 .leerInt( ) . } } ¿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. cont = 0 . System. Mostrar los números aleatorios que son números impares. Los números aleatorios generados deberán estar entre 1 y 10. Desarrollar un programa en Java que permita generar una cantidad determinada de números aleatorios.random( ) * 10 ) . num. Pag.Lectura . cant = Lectura. 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. cant. Clase PrgNumAleatoriosImpares package dominioDeLaAplicacion .CLASES BÁSICAS INCORPORADAS EN EL LENGUAJE DE PROGRAMACIÓN JAVA Problema 69 Etapa 01 .Descripción del problema.out.Desarrollo de la Codificación. class PrgNumAleatoriosImpares { public static void main ( String arg [ ] ) { int x. if ( num % 2 == 1 ) { cont ++.

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

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

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

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

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

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

se multiplican los valores resultantes con el valor del semiperímetro del triángulo y finalmente. 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. Pag.abs(p . ¿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. 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.Ing. Luego. area = Math. 300 .b) ) ) . se obtiene la raíz cuadrada del valor resultante utilizando el método sqrt ( ) de la clase Math. 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.a)) * (Math.c)) * (Math.abs(p .sqrt ( tmp ) . Luego.abs(p . Juan José Flores Cueto.

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

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

Pag.toRadians (anguloGrados) . 303 . 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. El tipo de ángulo es almacenado en una variable String (tipoAngulo) y mostrado por pantalla.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. 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.

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

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. Caso contrario.pow (b. Pag. la cual se calcularía utilizando: x = c / b * (-1) . x2 = ( . b y c).b . “La ecuación no tiene solución”. se muestra el siguiente mensaje por pantalla. 2) .Math. Si los coeficientes a y b son iguales a cero.sqrt (tmp)) / (2 * a) . las cuales se calcularían utilizando: x1 = ( . En caso que el valor de tmp sea igual a cero. Si el coeficiente a es diferente de cero la ecuación tendría dos soluciones. 305 . “La ecuación tiene raices imaginarias”. el cual se almacena en la variable tmp utilizando la siguiente formula: tmp = Math.b + Math. Caso contrario. se determina el valor de la discriminante. si el coeficiente a es igual a cero la ecuación tendría una sola solución.(4 * a * c) .sqrt (tmp)) / (2 * a) . se muestra un mensaje por la pantalla.

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

utilizando la siguiente fórmula: tmp = maximo * Math. Utilice la sentencia do y optimice el código. Este número generado al azar. se mostrará un mensaje indicando que el número numAzar fue encontrado. Si ambos son iguales. Si no son iguales.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. Intente modificar la codificación de la solución. es comparado con un número previamente ingresado por teclado y almacenado en la variable num. almacenado en la variable numAzar. Luego es redondeado utilizando el método round ( ) y convertido a un número entero utilizando la siguiente sentencia: numAzar = (int) Math. 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.random( ) . El número generado aleatoriamente es almacenado en la varable tmp.round(tmp) . 307 . Pag. se mostrará un mensaje.

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

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

System. System. Clase PrgPromedioNotas pp = ( p1 + p2 + p3 + p4 – notaMenor ) / 3 . pf = ( pp + ep + ef ) / 3 . } while ( opc=='s' || opc=='S' ) . pf = Math.Desarrollo de la Codificación. Muestre el promedio de las notas redondeado a dos decimales.println ( “ Desea continuar (si=s/ no=n)?: ” ) .out.round (pf) . 310 . } } 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. Pag.leerChar( ) . opc=Lectura.out. Continúa… Etapa 04 .println ( “ El promedio final del alumno es: ” + pf ) .Ing. Juan José Flores Cueto.

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

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

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

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

315 . 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.CLASES BÁSICAS INCORPORADAS EN EL LENGUAJE DE PROGRAMACIÓN JAVA en radianes.

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

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

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

319 . Este método nos permite obtener el valor del arcotangente de un par ordenado. se ingresan por teclado la ordenada y la abcisa de un punto cualquiera en el sistema de coordenadas. Pag. 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).CLASES BÁSICAS INCORPORADAS EN EL LENGUAJE DE PROGRAMACIÓN JAVA Pero en este caso. se utiliza el método atan2 ( ) de la clase Math. En este caso. utilizando el método toDegrees ( ) de la clase Math. 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.

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

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. 321 . Pag. 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. A continuación se presentan algunas soluciones a problemas utilizando básicamente el método random ( ) de la clase Math.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

toUpperCase ( ) . 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. nom = nom. Pag. Juan José Flores Cueto. 346 .Ing.

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

toLowerCase ( ) . Pag.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. nom = nom. 348 .

espacio = “ ” .println ( “ Ingresar el segundo nombre del alumno: ” ) .concat(nom2) . nom2 = Lectura.CLASES BÁSICAS INCORPORADAS EN EL LENGUAJE DE PROGRAMACIÓN JAVA Problema 102 Etapa 01 – Descripción del problema.toUpperCase() ) . nom1 = nom1. 349 . Clase PrgConcatenarNombres package dominioDeLaAplicacion . public class PrgConcatenarNombres { public static void main(String [ ] args) { String nom1.concat(nom2) . import biblioteca.println ( “ Ingresar el primer nombre del alumno: ” ) . 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).out. nom1 = nom1. System. nombre. Concatenar y Mostrar los nombres del alumno en letras mayúsculas y letra minúsculas. System. Desarrollar un programa en Java que permita ingresar el primer nombre y el segundo nombre de un alumno.concat(espacio) .out.toLowerCase() ) .concat (espacio) .concat (espacio) .leerString( ) . nombre = nom1. Pag.out. Etapa 04 – Desarrollo de la codificación.println ( “ El nombre en Mayúscula es: ”" + nombre. } } ¿Qué hay de nuevo en la codificación? Observe el uso del método concat ( ) de la clase String: nom = nom.out.* . nombre = nom1.println ( “ El nombre en Minúscula es: ” + nombre. System. nom1 = Lectura. Es decir.leerString( ) . nom2. System. 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). 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.

como se muestra a continuación: System. explicados en los problemas anteriores.out.out.println para mostrar el nombre del alumno en letra minúscula y en letra mayúscula.out. 350 . directamente con System. Juan José Flores Cueto. 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.concat (nom2) ) . se utilizan los métodos toUpperCase ( ) y toLowerCase ( ).Ing.println. Pag.println (nom1. Finalmente.

length( ) < 2 ) .length( ) < 2 ) { System. Clase PrgLongitudCadena package dominioDeLaAplicacion . También observe el uso del método length ( ) de la clase String: Pag.trim( ) .println ( “ La cantidad de caracteres del nombre es: ” + cant ) .out. nom = Lectura. 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. public class PrgLongitudCadena { public static void main(String [ ] args) { int cant . Etapa 04 – Desarrollo de la codificación. do { System. Mostrar el número de caracteres del nombre ingresado por teclado. cant = nom.out.println ( “ Ingresar el nombre: ” ) . Consistenciar el nombre del alumno al momento de ingresarlo.out.println ( “ Nombre ingresado no válido… Reintente! ” ) . 351 .leerString( ) . if ( nom. nom = nom.length( ) . } } ¿Qué hay de nuevo en la codificación? Observe el uso del método trim ( ) de la clase String: nom = nom. String 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). Desarrollar un programa en Java que permita ingresar el nombre de un alumno. } } while (nom. Esto se realiza como precaución. import biblioteca.* .CLASES BÁSICAS INCORPORADAS EN EL LENGUAJE DE PROGRAMACIÓN JAVA Problema 103 Etapa 01 – Descripción del problema. System.trim ( ) .

do { System. la cantidad de caracteres que almacena la variable nom). En la líneas de código mostradas a continuación. En nuestro ejemplo lo utilizamos como condición lógica y para almacenarlo en una variable. nom = nom. nom = Lectura. Pedro.out. Juan José Flores Cueto.length ( ) < 2 ) { System. Lu. } } while (nom. que tienen 2.length ( ) < 2) .println(). 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.trim ( ) . Ana.out. 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.length ( ) . 4. José. cant = nom. podemos mostrar el resultado utilizando System.leerString( ) .out. como por ejemplo. Como el método length ( ) devuelve la cantidad de caracteres que tiene una variable (incluido los espacios en blanco). utilizarlo en una condición lógica o almacenarlo en una variable. 352 .println ( “ Ingresar el nombre: ” ) . if ( nom. Pag.println ( “Nombre ingresado no válido… Reintente! ” ) . 3. y 5 caracteres respectivamente).Ing.

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

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

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

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

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

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

substring(x+1) . x+1) . cadena2 = nom. 359 . caracter = caracter. sw = false .CLASES BÁSICAS INCORPORADAS EN EL LENGUAJE DE PROGRAMACIÓN JAVA cadena1 = nom.x) . sin preocuparnos de la cantidad de espacios en blanco que pueda existir entre dos nombres.substring(0. nom = cadena1 + caracter + cadena2 . caracter = nom.substring(x. } } } } 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.toUpperCase( ). Pag.

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

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

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

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

En nuestro caso. i. o y u (en forma independiente).charAt (x) . letras y números). Juan José Flores Cueto.charAt (x) . 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. c = nom. El caracter obtenido es evaluado para determinar si es o no una vocal. e. 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. Pag. El método charAt ( ) se utiliza con variables de tipo String y nos permite obtener un caracter de una cadena. 364 . ¿Qué hay de nuevo en la codificación? Observe el uso del método charAt ( ) de la clase String: nom. obtenemos un caracter de la variable nom y lo almacenamos en una variable de tipo char (el método charAt ( ) devuelve un caracter). Antes de iniciar la evaluación de cada uno de los caracteres de la variable nom.Ing. Modifique la solución anterior de tal forma que pueda determinar cuantas vocales almacenadas en la variable son a.

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

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

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

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

Pag. cad1 = “Danae” 0 12 Límite para la evaluación Observe que cad2 tiene una longitud=3 por lo que la última evaluación será: cad2 = “ana” y subcad= “nae” Primera evaluación: cad2 = “ana” y Resultado: falso. subcad = “nae” Finalmente. 369 . subcad = “Dan” 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 Resultado: falso. se concluye que cad2 se repite una vez en cad1.

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

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

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

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

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

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

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

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

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

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

println ( “ Nombre ingresado no válido. 380 . Clase PrgOrdenados5 if ( nombre3.compareTo(nombre3) < 0 ) { nom01 = nombre1 . Juan José Flores Cueto.println (nom01) .concat(nombre3. nom03 = nombre3 . } } while ( nombre3... nom02 = nombre2 .length( ) == 0 ) .out.length( ) == 0 ) { System. if ( nombre1.substring(0.substring(1)) . Luego.out. } else { nombre3 = ((nombre3.toUpperCase()). complemente la solución permitiendo el ingreso de los nombres de todos los alumnos de un determinado salón de clase. 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.compareTo(nombre2) < 0 ) { if ( nombre1.compareTo(nombre3) < 0 ) { nom02 = nombre2 . System..Ing. } } else { nom01 = nombre3 . nom03 = nombre1 . } else { nom02 = nombre3 .. nom03 = nombre1 .out. Etapa 04 . if ( nombre1.println (nom02) . System. nom03 = nombre2 . } } Mejore la solución desarrollando un programa que permita ingresar tres nombres de alumnos. Continúa.compareTo(nombre3) < 0 ) { nom02 = nombre1 . nom03 = nombre2 .println (nom03) . } } System. 1)).Desarrollo de la codificación. nom02 = nombre1 . } else { nom02 = nombre3 . Pag. nom03 = nombre3 .Reintente!!! ” ) .println ( “ Nombres ordenados alfabéticamente ” ) .compareTo(nombre3) < 0 ) { nom01 = nombre2 . System. Muestre los nombres ordenados alfabéticamente. } } else { nom01 = nombre3 .out. } } else { if ( nombre2.out. if ( nombre2.

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

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

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

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

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

Problema 123 Etapa 01 – Descripción del problema.equals( “a” ) ) { contA++. } if ( letraFin. letraFin = nombre.equals( “P” ) ) { contP++.Ing.length( ) ) .length( ) == 0 ) { System.println ( “ Ingresar el nombre del alumno: ” ) . public class PrgCuentaLetras1 { public static void main(String [ ] args) { String nombre.substring ( nombre.out.leerString( ) .1) . contP= 0. 386 .out.length( )-1. i++) { do { System. letraIni = nombre.trim( ) . Clase PrgCuentaLetras1 package dominioDeLaAplicacion . int i. Etapa 04 – Desarrollo de la codificación.println ( “ Nombres que terminan con la letra a: ” + contA). } } System. } } while (nombre. nombre = Lectura.. letraFin = “” .println ( “ Nombre ingresado no válido. Utilice la estructura do… while. } } Mejore la solución desarrollando un programa que permita ingresar los nombres de todos los alumnos. 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. i <11. nombre = nombre. 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”.* .substring(0.out. import biblioteca.println ( “ Nombres que comienzas con la letra P: ” + contP). for (i = 0. if ( nombre.length( ) == 0 ) . contA = 0 .out. Juan José Flores Cueto.nombre. System. Reintente! ” ) .. Pag. letraIni = “”. if ( letraIni.

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

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

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

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

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

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

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

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

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

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

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

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

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

.

Dichos datos deben almacenarse en una estructura de datos. 401 . 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. Los arreglos permiten almacenar varios valores a la vez y constituyen las estructuras de datos más sencillas después de la variable. MARCO DE TRABAJO ENUNCIADO DEL PROBLEMA Etapa 02 Definición Solución Etapa 03 Diseño Solución Etapa 04 Desarrollo Solución Pag.ESTRUCTURAS DE DATOS – Arreglos.

• Estructuras de datos tipo arreglo. ALMACENADOS EN: • Estructuras de datos tipo variables. El presente capítulo. van a depender en general de la complejidad del problema.Ing. • Estructuras lógicas de decisión. 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. trata sobre las estructuras de datos conocidas como arreglos y los conceptos más importantes relacionados a éstos. Al desarrollar soluciones básicas. LISTA DE PASOS DESCRIPCIÓN DE DATOS SENTENCIAS DECLARACIÓN Y DEFINICIÓN DE DATOS SE DESARROLLAN UTILIZANDO: • Estructuras lógicas de secuencia. 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. Pag. 402 . • Estructuras lógicas de repetición. • Instrucciones de bifucación. Juan José Flores Cueto. Las estructuras lógicas y las estructuras de datos que se utilicen en una solución.

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). Un arreglo puede almacenar un conjunto limitado de datos. en el cual el orden de cada uno de los datos es significativo. todos del mismo tipo. Cada dato perteneciente al arreglo se almacena en una posición y puede ser mostrado. y en el que se necesita especificar dos índices para poder acceder a cada uno de ellos. modificado o eliminado. 403 .ESTRUCTURAS DE DATOS – Arreglos. Pag. ESTRUCTURA DE DATOS ARREGLOS Definición: Los arreglos conocidos también como arrays. Es. Arreglos bidimensionales (tabla o matriz) El arreglo bidimensional se considera como un vector de vectores. todos del mismo tipo. 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). Los arreglos o arrays pueden tener de una a varias dimensiones. 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. por consiguiente una estructura de datos que permite almacenar un conjunto de datos. 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. Es decir. El acceso a uno de los datos del arrreglo unidimensional se realiza mediante un índice.

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

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

...Ing.j -1 (i. Así. 15. Datos almacenados en la matriz. Por ejemplo. seguido de un índice igual a 1 entre corchetes ([1]). 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.Xi-1.. para poder acceder a la nota final del alumno 2 se utilizaría el nombre del vector (notas).. 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. j) Donde: nombre X0.0 X 0. según se muestre a continuación: Pag. 406 . j -1 i*j = = = Nombre de la matriz.0 X 1.j -1 i-1 X i-1. nombre Columnas 0 0 1 Filas 2 1 2 j-1 X 0..09 = = = Nombre del arreglo.0 X 2. Son las notas finales de cada uno de los alumnos. Juan José Flores Cueto. 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).0. En el presente texto. se realizaría de la siguiente manera: notas 10 0 15 1 20 2 19 3 14 4 13 5 16 6 11 7 17 8 09 i =10 9 Donde: notas i 10. en el vector anterior.2 … X 0. Tamaño de la matriz.1 X 0.0 X i-1. Número de alumnos.

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

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

en el cual se podrá almacenar datos de tipo NUMERO. 409 . Antes de crear un arreglo se debe determinar cual va ser el tamaño del mismo. 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.ESTRUCTURAS DE DATOS – Arreglos. El tamaño de un arreglo puede especificarse en forma directa utilizando un número entero o en forma indirecta utilizando una variable entera. cual va ser la cantidad total de datos que se podrá almacenar en el arreglo. En ambos casos. según se muestra a continuación: En pseudocódigo y diagrama de flujo: TipoDeDato[ ] arreglo TipoDeDato[ ][ ] arreglo En Java: TipoDeDato[ ] arreglo . parte entera y parte decimal (double). int edades[ ] . Para crear un arreglo se utiliza el siguiente formato: En pseudocódigo y diagrama de flujo: CREAR arreglo[tamaño] Pag. String nombres[ ] . solo parte entera (int). Se declara un arreglo unidimensional llamado nombres en el cual se podrá almacenar datos de tipo TEXTO (String). es necesario que el arreglo previamente haya sido declarado. TipoDeDato[ ][ ] arreglo . double notas[ ][ ] . 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 cual se podrá almacenar datos de tipo NUMERO. tal y como se explicó anteriormente. el tamaño del arreglo siempre deberá especificarse como un número entero. Es decir. Se declara un arreglo bidimensional llamado notas. Creación de Arreglos Para crear un arreglo.

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

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

en el cual se podrá almacenar 30 datos de tipo NUMERO. Generalmente. se deberán ingresar datos. Inicialización de Arreglos Cuando se crea un arreglo utilizando el operador new es recomendable. double notas[ ][ ] = new double [numNota[numAlu] . parte entera y parte decimal (double en Java).Ing. Es necesario que se ingresen datos a todas las posiciones del arreglo. 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. EJEMPLOS int edades [ ] = new int [10] . 412 . int numAlu. los arreglos numéricos (tipo NUMERO) se inicializan con cero (0). Dichos datos estarán organizados en 3 filas y 10 columnas. los arreglos lógicos (tipo LOGICO) o booleanos se inicializan con false. También se podría haber declarado y creado los arreglos del ejemplo anterior. Ingreso de datos a un Arreglo Después de crear un arreglo. inicializar todas las posiciones del mismo. aunque no necesario. Juan José Flores Cueto. int total = 10 . 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. los arreglos de caracteres con ‘\0’ y los arreglos de objetos con null. En el tercer ejemplo se crea un arreglo bidimensional llamado notas previamente declarado. en forma directa. tal y como se muestra a continuación. inicialice o no el arreglo. Recuerde que tratar de acceder a una Pag. numNot = 3 . numAlu =10 . String nombres [ ] = new String [total] . numNot .

crear e ingresar datos a un arreglo unidimensional. También se puede utilizar una forma directa que permite declarar. posición del arreglo que no tiene un dato o que no ha sido inicializado.23. 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.28. se declara y crea un arreglo unidimensional llamado edades de tipo NUMERO (solo números enteros) con 10 valores.20.ESTRUCTURAS DE DATOS – Arreglos. Para ingresar datos a todas las posiciones de un arreglo generalmente se utiliza la estructura lógica de repetición DESDE (for en Java). ‘B’. tal y como se muestra a continuación.15.42. En el ejemplo anterior. para esto se encierran los datos que se almacenarán en el arreglo dentro de llaves.32. 413 .59 } . 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. ‘D’ } .51. ‘C’.35. EJEMPLO int edades[ ] = { 10. Para declarar y crear un arreglo unidimensional llamado letras de tipo TEXTO (de solo una letra) con 4 valores. produce un error que ocasiona que se interrumpa la ejecución del programa. se utilizaría la siguiente sentencia: EJEMPLO char letras[ ] = { ‘A’. separadas por comas. Pag.

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

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

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

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

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

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

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

ESTRUCTURAS DE DATOS – Arreglos. Finalizada la ejecución de la primera sentencia for. 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. 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. Cada vez que se ejecuta la segunda sentencia for. se ejecuta el proceso de cálculo del promedio de las 10 notas finales. 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). el arreglo notas[ ] deberá tener almacenadas las notas finales de los 10 alumnos del salón de clase. 421 . Pag. Tal y como se muestra a continuación: notas 10 0 15 1 20 2 19 3 14 4 13 5 16 6 11 7 17 8 09 i =10 9 Finalmente. Finalizada la ejecución de la sentencia for se muestra el promedio de las 10 notas finales. Para ello. se utiliza una segunda sentencia for exactamente igual a la primera sentencia for.

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

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

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

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

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

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

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

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

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

notaMenor = 20 NUMERO notas[ ]. notas[ ] SALIDA: promAlu INICIO COMENTARIO “Declaración de variables” NUMERO i. sumaNotas = 0.1 INCREMENTA 1 SI ( notaMenor > notas[i] ) ENTONCES notaMenor = notas[i] FINSI FINDESDE promAlu = ( sumaNotas .ESTRUCTURAS DE DATOS – Arreglos. numPra.notaMenor ) / ( numPra . 431 .. 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 .. Algoritmo PrgAlumnos02 .1 INCREMENTA 1 sumaNotas = sumaNotas + notas[i] FINDESDE DESDE i = 0 HASTA i = numPra .” DESDE i = 0 HASTA i = numPra .1 INCREMENTA 1 HACER LEER notas[i] SI ( notas[i] > 20 || notas[i] < 0 ) ENTONCES ESCRIBIR “Nota no válida. 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[ ].1 ) promAlu = promAlu REDONDEA 0 ESCRIBIR promAlu FIN Pag. 4.método main ( ) ENTRADA: numPra. Diseño de algoritmo para el método principal.

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

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

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

método main ( ) ENTRADA: numAlu. j. numAlu. Algoritmo PrgAlumnos03 . 435 .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.ESTRUCTURAS DE DATOS – Arreglos. notaMayor = 0 NUMERO notas[ ][ ]. 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 . notas[ ][ ] SALIDA: promAlu INICIO COMENTARIO “Declaración de variables” NUMERO i.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. Diseño de algoritmo para el método principal.. 4. 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 . sumaNotas = 0..

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

se redondea y se muestra por pantalla. se determina su nota más alta y se almacena en una variable (notaMayor). Datos necesarios: Procesamiento: Pag. Con los datos ingresados se crea un arreglo (notas[ ][ ]). 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 la suma de las notas de las prácticas y el resultado se almacenan en una variable de tipo acumulador (sumaNotas). Luego. Finalmente. El número de alumnos. Finalmente. se almacena el resultado en una variable (promAlu). Problema 135 Etapa 01 . 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. 437 . Consistenciar el ingreso de datos. por cada alumno.notaMenor) / numPra). Después. 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. determinar y mostrar el promedio simple de todas las notas de las prácticas de los alumnos del salón de clase. Etapa 02 . 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).Definición de la solución.Descripción del problema.ESTRUCTURAS DE DATOS – Arreglos. También se determina su nota mas baja y se almacena en una variable (notaMenor). se realiza el cálculo de su promedio ((sumaNotas + notaMayor . el número de prácticas y las notas de las prácticas de cada alumno. Luego se procede a ingresar las notas de las prácticas de cada alumno y se almacenan en el arreglo creado. Mostrar el promedio redondeado a dos decimales.

Ing. Etapa 03 . se almacena el resultado en una variable (prom) y se muestra por pantalla. Diagrama de paquetes 3. Nombre del Proyecto: ProyAlumnos. Adicionalmente. 2. Se determina el promedio simple. Juan José Flores Cueto.Diseño de la lógica. 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). 438 . Definición de las Clases. Definición de Paquetes y desarrollo del Diagrama de Paquetes. 1. Clases dominioDeLaAplicacion Clases biblioteca Pag.

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

Juan José Flores Cueto. Diseño de algoritmo para el método principal.1 INCREMENTA 1 notaMayor = 0 notaMenor = 20 sumaNotas = 0 DESDE j = 0 HASTA j = numPra .Ing. Algoritmo PrgAlumnos04 – método main ( ) COMENTARIO “Cálculo del promedio de notas por alumno” DESDE i = 0 HASTA i = numAlu .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.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 . 440 . Continúa… 4.

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

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

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

2. almacenando los resultados en variables (aprobados y desaprobados respectivamente). Definición de las Clases. 1. Finalmente.Ing. Definición de Paquetes y desarrollo del Diagrama de Paquetes. se almacena el resultado en variables (porceAprob y porceDesaprob respectivamente). Nombre del Proyecto: ProyAlumnos. y se muestran por pantalla. se almacena el resultado en una variable (promEF). 444 . Juan José Flores Cueto. 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. Clases dominioDeLaAplicacion Clases biblioteca Pag. se redondea y se muestra por pantalla. luego se realiza el calculo del porcentaje de alumno aprobados y desaprobados. Diagrama de paquetes 3. Etapa 03 .Diseño de la lógica.

Algoritmo PrgAlumnos05. Reintente!” FINSI MIENTRAS ( notas[1][i] > 20 || notas[1][i] < 0 ) Pag. 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 . notas[ ][ ] SALIDA: promAlu..método main ( ) ENTRADA: numAlu.. Diseño de algoritmo para el método principal. 4. porceAprob.ESTRUCTURAS DE DATOS – Arreglos. promAlu. sumaNotas = 0.. desaprobados = 0. 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. sumaEF = 0 NUMERO notas[ ][ ]. porceDesaprob NUMERO aprobados = 0. porceDesaprob INICIO COMENTARIO “Declaración de variables” NUMERO i.. 445 . promEF.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. promEF. 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. 446 . 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 . Algoritmo PrgAlumnos05. Continúa… 4.. Juan José Flores Cueto.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 .Ing.porceAprob ESCRIBIR porceAprob + “ % ” ESCRIBIR porceDesaprob + “ % ” FIN Pag.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 .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 . Diseño de algoritmo para el método principal..

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

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

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

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

10 FINSI FINSI aumento = aumento REDONDEA 2 ESCRIBIR aumento FINDESDE FIN Pag. 4. numTrab. ” FINSI MIENTRAS ( sueldos[i] <= 0 ) FINDESDE COMENTARIO “Cálculo del aumento de sueldo por trabajador” DESDE i = 0 HASTA i = numTrab .método main ( ) ENTRADA: numTrab.1 INCREMENTA 1 SI ( sueldos[i] < 410 ) ENTONCES aumento = sueldos[i] * 0. 451 . Algoritmo PrgTrabajadores01 ... sueldos[ ]. Diseño de algoritmo para el método principal.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 .ESTRUCTURAS DE DATOS – Arreglos.05 SINO aumento = sueldos[i] * 0. sueldos[ ] SALIDA: aumento INICIO COMENTARIO “Declaración de variables” NUMERO i.2 SINO SI ( sueldos[i] > 1600 ) aumento = sueldos[i] * 0.

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

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

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

4.15 FINSI SI ( sueldos[i] < 1000 ) aumento = sueldos[i] * 0.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..1 INCREMENTA 1 HACER LEER sueldos[i] SI ( sueldos[i] <= 0 ) ENTONCES ESCRIBIR “Sueldo ingresado no es válido. 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 . numTrab.método main ( ) ENTRADA: numTrab. Algoritmo PrgTrabajadores02 .. descuento = 0. ” FINSI MIENTRAS ( sueldos[i] <= 0 ) FINDESDE COMENTARIO “Cálculo del sueldo neto de cada trabajador” DESDE i = 0 HASTA i = numTrab . 455 .ESTRUCTURAS DE DATOS – Arreglos. sueldos[ ].1 INCREMENTA 1 descuento = 0 aumento = 0 SI ( sueldos[i] > 1600 ) ENTONCES descuento = sueldos[i] * 0. Diseño de algoritmo para el método principal.

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

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

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

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. descuento = 0 NUMERO sueldoNeto. Definición de las Clases. sueldos[ ] SALIDA: sueldoNeto. Clases dominioDeLaAplicacion Clases biblioteca 4. 3. sueldoTotal INICIO COMENTARIO “Declaración de variables” NUMERO i. 459 . aumento. numTrab.ESTRUCTURAS DE DATOS – Arreglos. Algoritmo PrgTrabajadores03 . sueldos[ ]. descuento.método main ( ) ENTRADA: numTrab. aumento = 0. Diseño de algoritmo para el método principal.

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

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

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

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

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

. 4. sueldos[ ][ ] SALIDA: sueldoNeto INICIO COMENTARIO “Declaración de variables” NUMERO i.85 ESCRIBIR sueldoNeto FINDESDE FIN Pag.. Algoritmo PrgTrabajadores04 . sueldos[ ][ ].ESTRUCTURAS DE DATOS – Arreglos.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.. ” 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.método main ( ) ENTRADA: numTrab. Diseño de algoritmo para el método principal. ” FINSI MIENTRAS ( sueldos[i][1] <= 0 ) FINDESDE COMENTARIO “Cálculo del sueldo neto de cada trabajador” DESDE i = 0 HASTA i = numTrab .. numTrab. 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 . 465 .1 INCREMENTA 1 sueldoNeto = sueldo[i][0] * sueldo[i][1] * 0.

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

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

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

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

Definición de las Clases. descuento NUMERO sueldoNeto. 470 . 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. numTrab.método main ( ) ENTRADA: numTrab. sueldos[ ][ ]. Diseño de algoritmo para el método principal. Algoritmo PrgTrabajadores05 . sueldos[ ][ ] SALIDA: sueldoBruto. 3. Juan José Flores Cueto.Ing. sueldoNeto INICIO COMENTARIO “Declaración de variables” NUMERO i. Clases dominioDeLaAplicacion Clases biblioteca 4.

. Diseño de algoritmo para el método principal.15 sueldoNeto = sueldoBruto + aumento – descuento sueldoBruto = sueldoBruto REDONDEA 2 sueldoNeto = sueldoNeto REDONDEA 2 ESCRIBIR sueldoBruto.25) + (48 * sueldos[1][i]) SINO sueldoBruto = sueldos[0][i] * sueldos[1][i] FINSI SI ( sueldoBruto > 3500 ) ENTONCES descuento = sueldoBruto * 0...15 SINO SI (suesldoBruto > 1600 ) ENTONCES descuento = sueldoBruto * 0. Continúa… 4.método main ( ) COMENTARIO “Ingreso de datos al arreglo sueldos[ ][ ]” DESDE i = 0 HASTA i = numTrab ..ESTRUCTURAS DE DATOS – Arreglos.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. 471 .10 SINO descuento = 0 FINSI FINSI aumento = sueldoBruto * 0. sueldoNeto FINDESDE FIN Pag. ” 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.1 INCREMENTA 1 SI ( sueldos[0][i] > 48 ) ENTONCES sueldoBruto = (sueldos[0][i] – 48) * (sueldos[1][i] * 1. ” FINSI MIENTRAS ( sueldos[1][i] <= 0 ) FINDESDE COMENTARIO “Cálculo del sueldo bruto y neto por trabajador” DESDE i = 0 HASTA i = numTrab . Algoritmo PrgTrabajadores05 .

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

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

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

Clases dominioDeLaAplicacion Clases biblioteca 4. nombres SALIDA: tamaño INICIO COMENTARIO “Declaración de variables” NUMERO i. 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. 475 . 3. numArt. tamaño TEXTO articulos[ ]. Definición de las Clases. Algoritmo PrgArticulos01 .método main ( ) ENTRADA: numArt.ESTRUCTURAS DE DATOS – Arreglos. Diseño de algoritmo para el método principal.

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

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

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

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

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

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

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

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

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

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

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

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 dominioDeLaAplicacion

Clases 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 0 1 2 0 1 2 sueldos

Datos del mismo trabajador.

: :
numTrab - 1

: : :
nombre de los trabajadores

: :
numTrab - 1

: : :
sueldo de los 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 0 1 2 Danae 0 1 2 sexos F 0 1 2 Edades 10

: :
numSoc - 1

: : :
nombres de cada socios

: :
numSoc - 1

: : :
sexo de cada socio

: :
numSoc - 1

: : :
sueldo de 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 0 1 2 0 1 2 precios 0

1

: :
numArt - 1

: : :
nombre de cada artículos

: :
numArt - 1

: : :
precio de compra de cada artículos

: : :
precio de venta 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. El número de trabajadores y, el nombre y el sueldo de cada trabajador. 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

Datos necesarios: Procesamiento:

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 dominioDeLaAplicacion

Clases 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

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

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

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

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

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

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 .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.” FINSI MIENTRAS ( edades[i] <= 0 ) FINDESDE COMENTARIO “Determinando número de socios hombres mayores de edad” DESDE i = 0 HASTA i = numSoc . Juan José Flores Cueto.1 INCREMENTA 1 letra = nombres[i] CARACTER 0 letra = MAYUSCULA letra SI ( letra = ‘D’ ) ENTONCES totalNombresD = totalNombresD + 1 FINSI FINDESDE ESCRIBIR totalNombresD FIN Pag. Diseño de algoritmo para el método principal..Ing. 504 . Algoritmo PrgSocios01 .. Continúa… 4.

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

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

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

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

1 INCREMENTA 1 HACER COMENTARIO “ Ingreso de nombre de artículo ” LEER nombres[i] nombres[i] = nombres[i] ELIMINAESPACIO INICIO.método main ( ) ENTRADA: numArt. FIN SI ( LONGITUD nombres[i] < 3 ) ENTONCES ESCRIBIR “Nombre del artículo no válido. precios[ ][ ] SALIDA: nombres[ ]. utilidad INICIO COMENTARIO “Declaración de variables” NUMERO i. Algoritmo PrgArticulos06 .ESTRUCTURAS DE DATOS – Arreglos.. precio de compra y precio de venta de los artículos ” DESDE i = 0 HASTA i = numArt .” FINSI MIENTRAS ( precios[i][0] <= 0 ) Pag. 4.” 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.. nombres[ ]. numArt. precios[ ][ ]. Diseño de algoritmo para el método principal.. 509 .. 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.

1 INCREMENTA 1 utilidad = precios[i][1] – precios[i][0] ESCRIBIR nombres[i]. Diseño de algoritmo para el método principal.Ing.. Continúa… 4. utilidad FINDESDE FIN Pag.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 . Algoritmo PrgArticulos06 .” FINSI MIENTRAS ( precios[i][1] <= 0 ) FINDESDE COMENTARIO “Determinando la utilidad de cada artículo ” DESDE i = 0 HASTA i = numArt .. Juan José Flores Cueto.

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

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

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

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

. notas[ ][ ]. numNot. Algoritmo PrgAlumnos06 .ESTRUCTURAS DE DATOS – Arreglos. Diseño de algoritmo para el método principal. promedios[ ] NUMERO sumaNotas = 0. notas[ ][ ] SALIDA: nombres[ ]. numAlu.método main ( ) ENTRADA: numAlu.. 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.FIN SI ( LONGITUD nombres[i] < 3 ) ENTONCES ESCRIBIR “Nombre del alumno no válido. codigos[ ]. 515 . promAlu = 0.1 INCREMENTA 1 HACER LEER nombres[i] nombres[i] = nombres[i] ELIMINAESPACIO INICIO. nomNot. codigos[ ].” FINSI MIENTRAS ( LONGITUD nombres[i] < 3 ) Pag. promedios[ ] INICIO COMENTARIO “Declaración de variables” NUMERO i. codigos[ ]. nombre[ ]. j. codigo y notas de todos los alumnos ” DESDE i = 0 HASTA i = numAlu . 4.

Algoritmo PrgAlumnos06 . Diseño de algoritmo para el método principal.1 INCREMENTA 1 sumaNotas = 0 DESDE j = 0 HASTA j = numNot . 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. codigos[i]..” 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 .método main ( ) HACER LEER codigos[i] SI ( codigos[i] < 100000 OR codigos[i] > 999999 ) ENTONCES ESCRIBIR “Código ingresado no válido. Juan José Flores Cueto.1 INCREMENTA 1 SI ( promedios[i] = promAluMayor ) ENTONCES ESCRIBIR nombres[i] FINSI FINDESDE FIN Pag.Ing.1 INCREMENTA 1 sumaNotas = sumaNotas + notas[i][j] FINDESDE promAlu = sumaNotas / numNot promAlu = promAlu REDONDEA 2 promedio[i] = promAlu ESCRIBIR nombres[i].. Continúa… 4.” FINSI MIENTRAS ( codigos[i] < 100000 OR codigos[i] > 999999 ) DESDE j = 0 HASTA j = numNot .. 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 .

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. El número de artículos y el nombre de cada uno de los artículos. 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.

Datos necesarios: Procesamiento:

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 dominioDeLaAplicacion Clases 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: Datos necesarios: Procesamiento: Mostrar la nota final de un determinado alumno. Las notas del alumno (en esta caso tenemos 3 notas). 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

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

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

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

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

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

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

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

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

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

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

objAlumno. } package dominioDeLaAplicacion .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( ). } } 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.nota2 + objAlumno.nota2 y nota3. Alumno objAlumno = new Alumno ( ) . se puede separar sus nombres mediante comas (. que se definan los atributos de instancia nota1.nota3 ) / 3 .) y declararlos con una solo sentencia. class Alumno { double nota1.nota2 = 19 . Ahora. // Primero declaramos y creamos un objeto de la clase Alumno. se realizarán algunos cambios en el proyecto de solución ProyAlumno.println ( “ El promedio final del alumno es: ” + prom ) . nota2.nota1 + objAlumno.nota3 = 11 . 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. se modificará el método main() de la clase PrgAlumno para utilizar el atributo de instancia nota3. Tal y como se muestra a continuación: class Alumno { double nota1. } En base a esto. Es importante mencionar que si existen varios atributos del mismo tipo en una misma clase. de tal forma. nota3 . // Ahora asignamos valores a las variables de instancia del objeto creado. objAlumno. de la siguiente manera: package dominioDeLaAplicacion . objAlumno. Dicho método main( ) inicia la ejecución del proyecto y está definido en una de las clases que pertenecen al proyecto. 539 .out. calculamos el promedio de notas del alumno objAlumno. nota2. Se agregará un atributo de instancia en la definición de la clase Alumno. // Finalmente.nota1 = 15 . nota3 . class PrgAlumno { public static void main ( String args [ ] ) { double prom . nota2 y nota3. prom = ( objAlumno. System.

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

y que los valores de un objeto son independientes de los otros valores que tienen los otros objetos. nota2 y nota3.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. 541 . Pag.

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

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

nota2 = 11 . // y a las variables de instancia del objeto objAlumno03. objAlumno02.nota2 = 14 .promedio ( ) . 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. void promedio ( ) { System. // Calculamos el promedio de notas para cada alumno. Ahora. objAlumno03. Juan José Flores Cueto. objAlumno03. y permitirá calcular y mostrar el promedio de notas de un alumno. // Ahora asignamos valores a las variables de instancia del objeto objAlumno.nota2 = 19 . objAlumno03. // También asignamos valores a las variables de instancia del objeto objAlumno02. anteriormente. El método se llamará promedio( ). nota3 .nota3 = 15 .Ing. // Primero declaramos y creamos tres objetos de la clase Alumno. objAlumno. objAlumno03. objAlumno. nota2.nota1 = 13 . Como el promedio de notas depende de las notas.nota1 = 11 .nota1 = 15 . Aunque. poco a poco conforme se modifique el proyecto de solución ProyAlumno se podrán comprender mejor. 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.promedio ( ) . el cual se desarrolla a continuación: package dominioDeLaAplicacion .out. tiene mucho mas sentido que el cálculo lo realice la clase Alumno a través del método promedio( ). objAlumno. class Alumno { double nota1.println ( (nota1 + nota2 + nota3 ) / 3 ) .nota3 = 11 . objAlumno. Alumno objAlumno = new Alumno ( ) . objAlumno02. 544 .promedio ( ) . } } package dominioDeLaAplicacion . objAlumno02. objAlumno02. System.print ( “ El promedio final del alumno es: ” ) . } } Pag. class PrgAlumno { public static void main ( String args [ ] ) { double prom . Alumno objAlumno03 = new Alumno ( ) . se definirá un método dentro de la clase Alumno. Alumno objAlumno02 = new Alumno ( ) .out.nota3 = 11 .

promedio ( ) . Analicemos la siguiente sentencia. nota2 = 19 y nota3 = 11 ). nota2 = 11 y nota3 = 11 ).promedio ( ) . se ejecuta el método promedio( ) utilizando el nombre de un objeto de la clase Alumno seguido por el operador punto. 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. objAlumno02. nota2 = 14 y nota3 = 15 ). objAlumno. objAlumno03.promedio ( ) .). Pag. Es decir. permiten ejecutar el método promedio( ) definido en la clase Alumno: objAlumno. 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.promedio ( ) .INTRODUCCIÓN AL DESARROLLO DE SOLUCIONES ORIENTADAS A OBJETOS Al ejecutar el proyecto se obtiene el siguiente resultado. para acceder a los métodos se utiliza el operador punto (.promedio ( ) . 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. ubicadas dentro del método main( ) de la clase PrgAlumno. 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 ( ) . cuando se ejecuta. • objAlumno. • objAlumno02. • objAlumno03. 545 . 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. 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. Así.promedio ( ) .

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

se puede realizar solo el cálculo del promedio de notas y devolver dicho valor para que este pueda ser utilizado de diferente forma. objAlumno03. } } package dominioDeLaAplicacion . // Primero declaramos y creamos tres objetos de la clase Alumno.nota1 = 15 .println ( “ La nota final de Luis es ” + prom + “. nota3 . Alumno objAlumno = new Alumno ( ) . objAlumno02. objAlumno03.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.nota2 = 14 .nota1 = 13 .nota3 = 15 . objAlumno03. objAlumno.out.nota1 = 11 . objAlumno.nota3 = 11 .nota3 = 11 .nota2 = 11 . double promedio ( ) { return ( nota1 + nota2 + nota3 ) / 3 . 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 . esto no constituye la mejor forma o alternativa de desarrollar dicho método.promedio ( ) . 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. pero no todos necesitarán que una vez calculado el promedio de notas este se visualice. objAlumno. class PrgAlumno { public static void main ( String args [ ] ) { double prom . System. Pag.” ) . objAlumno02. 547 . Con la finalidad de mejorar la implementación del método promedio( ). // Ahora asignamos valores a las variables de instancia del objeto objAlumno. // y a las variables de instancia del objeto objAlumno03. nota2. // Calculamos el promedio de notas para cada alumno. class Alumno { double nota1. Esto se debe. Alumno objAlumno02 = new Alumno ( ) . prom = objAlumno. a que en mucho casos.nota2 = 19 . // También asignamos valores a las variables de instancia del objeto objAlumno02 objAlumno02. Alumno objAlumno03 = new Alumno ( ) .

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

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

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

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

19. Cuando se ejecuta un método que tiene parámetros. Existen dos puntos importantes relacionados con los métodos que tienen parámetros: 1. se debe pasar al método un valor por cada parámetro definido (es decir. Juan José Flores Cueto. nota3 = c . nota2 = b .setNotas(15. Especifica que se tiene definido 3 parámetros de tipo double.11). objAlumno. 552 . Cada argumento deberá ser compatible con el tipo de dato definido por el parámetro al cual será asignado: Especifica que se envían 3 valores (argumentos) de tipo double al método setNotas ( ). } 2. El valor recibido debe ser compatible con el tipo de dato definido por el parámetro al cual será asignado: No devuelve valor. double c ) { nota1 = a .Ing. Pag. void setNotas ( double a. Un método que tiene parámetros debe recibir un valor por cada parámetro definido. double b. se deben pasar los argumentos).

print ( “ El promedio final del alumno es: ” ) . void promedio ( ) { System. } 4. } 3. No devuelve valor.out. devolver un valor y no tener definido parámetros. 553 . devolver un valor y tener definido uno o más parámetros. } 2. nota2 = b . (Este tipo de métodos no han sido tratados en el presente capítulo). System. no devolver un valor y tener definido uno o más parámetros. no devolver valor y no tener definido parámetros. Pag. double c ) { nota1 = a . double promedio ( ) { return (nota1 + nota2 + nota3 ) / 3 . Especifica que se tiene definido 3 parámetros de tipo double. No tiene parámetros.INTRODUCCIÓN AL DESARROLLO DE SOLUCIONES ORIENTADAS A OBJETOS En conclusión.out. Un método puede. double b. Especifica que se debe devolver un valor double. void setNotas ( double a.println ( ( nota1 + nota2 + nota3 ) / 3 ) . Un método puede. Un método puede. No devuelve valor. Un método puede. nota3 = c . No tiene parámetros. se puede afirmar lo siguiente: 1.

Los métodos constructores pueden tener parámetros al igual que otros métodos. } } Pag. de tal forma que se defina solo el objeto objAlumno de la clase Alumno en el método main() de la clase PrgAlumno (esto con la finalidad de implementar nuevos conceptos en un proyecto de solución sencillo y pequeño).” ) .11 ) . } double promedio ( ) { return ( nota1 + nota2 + nota3 ) / 3 . } void setNotas ( double a. Método constructor En Java. nota2. double b. objAlumno. } } package dominioDeLaAplicacion . nota2 y nota3 para el objeto objAlumno: package dominioDeLaAplicacion . ni siguiera void. 554 . // Calculamos y mostramos el promedio de notas. nota3 = 0 . Cada vez que se crea un objeto se ejecuta en forma automática el método constructor. nota2 = b . Alumno objAlumno = new Alumno ( ) . El método constructor permite que se inicialicen la copia de los atributos de instancia de los objetos inmediatamente después de su creación.setNotas ( 15. nota3 . la inicialización de objetos no se puede realizar en el momento en que estos son definidos. Se modificará el proyecto de solución ProyAlumno. // Primero declaramos y creamos un objeto de la clase Alumno.println ( “ La nota final de Luis es ” + prom + “. prom = objAlumno.19. Alumno ( ) { nota1 = 0 . System. se tiene la característica de disponer de un método que permite inicializar objetos inmediatamente después que se crean. nota2 = 0 .out. Un constructor es un método especial que sirve para construir o inicializar objetos. nota3 = c .Ing. // Ahora asignamos valores a la copia de las variables de instancia del objeto creado.promedio ( ) . class PrgAlumno { public static void main ( String args [ ] ) { double prom . class Alumno { double nota1. Por lo cual. y se incluirá un método constructor en la clase Alumno que permita inicializar la copia de los atributos de instancia nota1. double c ) { nota1 = a . pero no devuelven ningún valor. Juan José Flores Cueto. Este método es conocido como el método constructor. El método constructor tiene el mismo nombre que la clase en la cual está definido.

a todas las copias de los atributos de instancia de los objetos que se creen. podemos enviar al método constructor Alumno( ). Después que se crea el objeto objAlumno se ejecuta en forma automática al método constructor Alumno( ). (Recuerde que el método constructor solo se ejecutará en forma automática inmediatamente después de crear un objeto y si se requiere cambiar el valor de una copia de los atributos de instancia del objeto después de haberlo creado. los valores de la copia de los atributos de instancia nota1. no se eliminará el método setNotas( ). El método constructor Alumno( ) permite inicializar la copia de los atributos de instancia nota1. nota2 y nota3 del objeto objAlumno con el valor cero. Pag. mientras que el método setNotas( ) se encargará de modificar los valores de las copias de los atributos de instancia de los objetos cuando esto sea necesario.INTRODUCCIÓN AL DESARROLLO DE SOLUCIONES ORIENTADAS A OBJETOS Cuando se ejecuta la siguiente sentencia: Alumno objAlumno = new Alumno(). deberá realizarlo empleando otro método. 555 . En ese caso. El método constructor Alumno( ) se encargará de inicializar con el valor cero. nota2 y nota3 del objeto creado y eliminar el método setNotas( ). dicho método es setNotas( ) ). El método constructor puede tener definido parámetros. Para nuestro caso. Aunque esto es posible y perfectamente válido. Se declara y crea el objeto objAlumno de la clase Alumno.

se han declarado 3 variables locales (parámetros) para recibir las notas cuando se ejecute el método. Sin embargo. Estás variables locales no fueron declaradas con los nombres nota1. no pueden tener nombres iguales. se dice que las variables locales ocultan a los atributos de instancia. que no tienen ningún significado especial. nota2 y nota3. ya que dichos nombres de variables no reflejan el valor que almacenan. Cuando una variable local tiene el mismo nombre que un atributo. una variable local (declarada dentro de un método) puede tener el mismo nombre que un atributo. Para esto. Si analiza la implementación del método setNotas( ) podrá observar que en dicho método se utilizan las variables locales a. no es correcto que dos variables que están dentro del mismo ámbito tengan el mismo nombre. } } Dentro del método setNotas( ). nota2 y nota3 debido a que dichos nombres ya eran utilizados por los atributos de instancia. nota2 y nota3. Es decir. nota3 = c . Alumno ( ) { nota1 = 0 . } void setNotas ( double a. nota3 = 0 .Ing. double b. nota2. Cuando sucede esto. 556 . se asumiría que se hace referencia a las variables locales y no a los atributos de instancia (ya que ambos tendrían el mismo nombre). class Alumno { double nota1. double c ) { nota1 = a . nota2 = b . nota3 . Si se hubieran declarado las variables locales con los nombres nota1. b y c. la variable local oculta al atributo. no se podrían utilizar los atributos de instancia ya que siempre que se utilicen los nombres nota1. nota2 y nota3. cada vez que necesite referirse a las variables locales se utilizará el Pag. Observe la codificación de la clase Alumno: package dominioDeLaAplicacion . Dichas variables locales fueron declaradas con los nombres a. Juan José Flores Cueto. y también se utilizan los atributos de instancia nota1. b y c. Utilizando el operador this es posible nombrar a las variables locales igual que los atributos de instancia. } double promedio ( ) { return ( nota1 + nota2 + nota3 ) / 3 . nota2 = 0 . dos variables locales declaradas dentro del mismo método o dos atributos. OCULTAR ATRIBUTOS DE INSTANCIA En Java.

nota1 = nota1. nota2 = 0 . Nos referimos a la variable local nota1. } double promedio ( ) { return ( nota1 + nota2 + nota3 ) / 3 . nota2. Alumno ( ) { nota1 = 0 . } void setNotas ( double nota1. se utilizan los mismos nombres para las variables locales (declarados como parámetros) y para los atributos de instancia. this. this.nombreAtributoInstancia . en el método setNotas( ).) Nos referimos al atributo de instancia nota1.nota2 = nota2 . Cuando se utiliza el operador this se indica que se está refiriendo al atributo de instancia y no a una variable local.nota1 = nota1 .) y el nombre del atributo. double nota3 ) { this. Forma general del operador this: this. This. } } Ahora. Analizar la variación en la codificación de la clase Alumno: package dominioDeLaAplicacion . class Alumno { double nota1. double nota2. 557 .nota3 = nota3 .INTRODUCCIÓN AL DESARROLLO DE SOLUCIONES ORIENTADAS A OBJETOS nombre de la variable local y cada vez que necesite referirse a los atributos de instancia se utilizará el operador this seguido del operador punto (. nota3 . nota3 = 0 . Pag. Al momento de referirnos a los atributos de instancia anteponemos al nombre del mismo el operador this y el operador punto (.

558 . A partir de ahora. Juan José Flores Cueto. otros programadores piensan que es una buena práctica utilizar mismos nombres por claridad y utilizar el operador this para referirse a los atributos instancia.Ing. Por otro lado. se utilizará el operador this como una buena práctica programación. de los de de Pag. Algunos programadores procurar no utilizar variables locales que oculten los atributos instancia.

INTRODUCCIÓN AL DESARROLLO DE SOLUCIONES ORIENTADAS A OBJETOS INGRESO DE DATOS A TRAVÉS DEL TECLADO Ahora. // Ingresamos las notas. class PrgAlumno { public static void main ( String args [ ] ) { double n1.println ( “ Ingrese la nota de prácticas del alumno: ” ) . n1 = Lectura.out. n2 = Lectura.nota2 = nota2 . Alumno ( ) { nota1 = 0 .out. } } package dominioDeLaAplicacion .” ) .promedio ( ) . // Ahora enviamos las notas a la copia de los atributos de instancia del objeto. } Pag.nota3 = nota3 . public class Lectura { // Cuerpo de la clase Lectura definida en capítulos anteriores.* . prom = objAlumno.n2.out. nota2. System.nota1 = nota1 . double nota2. this.leerInt ( ) .setNotas ( n1.println ( “ Ingrese la nota de examen final: ” ) . nota2 = 0 . } void setNotas ( double noat1. System. } double promedio ( ) { return ( nota1 + nota2+nota3 ) / 3 . se utilizará la clase Lectura presentada en capítulos anteriores. se modificará el proyecto de solución ProyAlumno. n2.out. System.leerInt ( ) . import biblioteca.println ( “ La nota final de Luis es ” + prom + “.n3 ) . nota3 . double nota3 ) { this. La clase Lectura pertenece al paquete biblioteca: package dominioDeLaAplicacion . n3.leerInt ( ) . nota3 = 0 . Alumno objAlumno = new Alumno ( ) . objAlumno. class Alumno { double nota1. prom . } } package biblioteca . n3 = Lectura.println ( “ Ingrese la nota del examen parcial: ” ) . de tal forma que los datos sean ingresados a través del teclado de la computadora. Para ello. this. 559 . System.

Un paquete denominado biblioteca que contiene a la clase Lectura y un paquete denominado dominioDeLaAplicacion que contiene las clases PrgAlumno y Alumno. el proyecto de solución ProyAlumno tiene dos paquetes. Dentro del método main( ). Uno de los métodos realiza el cálculo del promedio. se ingresan las notas del alumno y se muestra el promedio. Clase Alumno: Clase Lectura: Pag. Clase PrgAlumno: Tiene el método main( ) que permite que el proyecto se ejecute. se crea al objeto objAlumno de la clase Alumno. Define métodos que facilitan el ingreso de datos utilizando el teclado. 560 .Ing. Ahora. Define los atributos de instancia para almacenar las notas y los métodos que permiten manipular dichos atributos de instancia. Cada clase tiene funciones específicas que se detallan a continuación. Juan José Flores Cueto.

o Uso de la clase Lectura con sus métodos definidos. Ajuste de los pasos definidos para las etapas del método En la solución del problema anterior. Los mayores cambios los desarrollamos en las 2 clases del paquete dominioDeLaAplicacion.INTRODUCCIÓN AL DESARROLLO DE SOLUCIONES ORIENTADAS A OBJETOS MÉTODO DE LAS 6’D: Etapas y pasos El proyecto de solución ProyAlumno. (Utilice UML). • Diseño del diagrama de paquetes respectivo. Establecer la dependencia. • Diseño del algoritmo para los método definidos. métodos de instancia y método constructor válido para los objetos. o Definición de clases con sus atributos y métodos. Pag. 561 . (Utilice UML). se utilizó dos paquetes. Es un buen momento para ajustar los pasos definidos en las etapas del método de las 6’D y poder desarrollar un proyecto que permitan al lector familiarizarse con este tipo de soluciones. En una clase se desarrollará el método main( ) y se definirán objetos de la otra clase. • Definición del algoritmo. se pretende dar un paso importante para acercarnos al desarrollo de soluciones orientadas a objetos. el método de solución queda definido según se muestra a continuación: ENUNCIADO DEL PROBLEMA Etapa 02 Definición Solución Etapa 03 Diseño Solución Etapa 04 Desarrollo Solución • Definición del proyecto de solución. • Codificar el diseño de la solución del problema utilizando el lenguaje de programación Java. • Diseño de las clases que serán parte del paquete Aplicación. Con la última solución desarrollada para el proyecto ProyAlumno. En base a esto. mientras que en la otra clase se definirán los atributos de instancia. • Definición del paquete Aplicación. • Definición del paquete biblioteca. se ha modificado poco a poco con la finalidad de tratar nuevos conceptos relacionados a la POO utilizando Java. Utilizar pseudocódigo.

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

en los métodos de esta clase. Pero. nota2 y nota3 a través del teclado. se volverá a solucionar el problema anterior. se realizará el cálculo de la nota final sobre la base de la siguiente fórmula: prom = ( nota1 + nota2 + nota3 ) / 3. La función de la primera clase será de procesamiento y almacenamiento de datos.Descripción del problema. 3. La 3 notas serán ingresadas por teclado y almacenadas en las variables nota1. Para solucionar el problema se creará un proyecto denominado ProyAlumno. si se utilizarán los mismos nombres para referirnos a variables locales y a los atributos Pag. PROBLEMA 151 Etapa 01 . no se realizará ingreso de datos. nota2. En el paquete dominioDeLaAplicacion definiremos dos clases. Etapa 02 . Definición del paquete Aplicación. 563 . Como buena práctica de programación. 1. Las notas del alumno (en esta caso tenemos 3 notas). Resultado deseado: Datos necesarios: Procesamiento: Mostrar la nota final de un determinado alumno. dentro del cual se definirá el paquete dominioDeLaAplicacion y se incluirá el paquete biblioteca (el cual incluye la clase Lectura).INTRODUCCIÓN AL DESARROLLO DE SOLUCIONES ORIENTADAS A OBJETOS Con el propósito de describir los pasos definidos de las etapas del método 6’D. Calcular el promedio final de un alumno. ni se mostrarán mensajes de ningún tipo. El resultado se almacenará en una variable (prom) para luego ser mostradas por pantalla. Utilice la siguiente fórmula: prom = ( nota1 + nota2 + nota3 ) / 3. Definición del algoritmo. Definición del proyecto de solución. Ingrese las notas nota1. y nota3. 2.Definición de la solución. Luego.

Su definición será la siguiente: Clase: Atributos: Métodos: PrgAlumno. solo podrán ser definidos como atributos de instancia los datos de entrada. la creación del objeto objAlumno. Como atributos de instancia definiremos al objeto objAlumno de la clase Alumno. recibe los valores de las notas ). 564 . Como buena práctica de programación. la clase Alumno). Su definición será la siguiente: Clase: Atributos: Métodos: Alumno. Necesitamos los siguientes métodos: Método constructor para inicializar los atributos de instancia (método Alumno()).Ing. Método para modificar los valores de las notas (método setNotas(). no se realizará ningún tipo de cálculo y solo podrán ser definidos como atributos de instancia objetos de la otra clase (para este caso. Pag. En el paquete biblioteca se tendrá la clase Lectura para poder utilizar sus métodos. nota2 y nota3. Juan José Flores Cueto. Definición del paquete biblioteca. de instancia. 4. el ingreso de los datos y mostrar los resultados esperados. Como atributos de instancia definiremos las variables de entrada nota1. devuelve el valor del cálculo del promedio de las notas). Método para calcular el promedio de las notas (método promedio(). La función de la segunda clase será el ingreso de los datos y mostrar los resultados esperados. Utilizamos el método main( ) para iniciar la ejecución del proyecto. Por otro lado. en los métodos de esta clase.

INTRODUCCIÓN AL DESARROLLO DE SOLUCIONES ORIENTADAS A OBJETOS Etapa 03 – Diseño de la lógica.promedio ( ) ESCRIBIR prom FIN Pag. n2. prom CREAR OBJETO objAlumno CLASE Alumno EJECUTAR Alumno ( ) LEER n1. n3 EJECUTAR objAlumno. double. Diagrama de paquetes dominioDeLaAplicacion biblioteca Diseño de las clases.n2. n3 prom INICIO NUMERO n1. n2.setNotas ( n1.n3 ) prom = EJECUTAR objAlumno. Algoritmo PrgAlumno METODO MAIN( ) ENTRADA: SALIDA: n1. n2. n3. Diseño del Diagrama de Paquetes. Clases de dominioDeLaAplicacion PrgAlumno nota1 : double nota2 : double nota3 : double main( ) Alumno( ) setNotas(double. double) : void promedio( ) : double Alumno Clase de biblioteca Lectura leerString( ) : String leerChar( ) : char leerInt( ) : int leerLong( ) : long leerFloat( ) : float leerDouble( ) : double Diseño de algoritmos. 565 .

nota3 METODO CONSTRUCTOR PARAMETRO: INICIO nota1 = 0 nota2 = 0 nota3 = 0 FIN METODO SETNOTAS PARAMETRO: RETORNO: nota1.nota1 = nota1 ATRIBUTO. se ha utilizado nuevas reglas de pseudocódigo las cuales describimos a continuación: CREAR OBJETO Se utiliza para indicar la creación de un determinado objeto. Pag.nota2 = nota2 ATRIBUTO. El formato completo se muestra a continuación a través de un ejemplo: CREAR OBJETO objAlumno CLASE Alumno EJECUTA Alumno ( ) A través de esta instrucción se crea un objeto denominado objAlumno de la clase Alumno y se ejecuta el método constructor especificado.Ing. nota2. 566 . nota3 INICIO ATRIBUTO. Algoritmo Alumno ATRIBUTOS NUMERO nota1. nota2.nota3 = nota3 FIN METODO PROMEDIO PARAMETRO: RETORNO: prom INICIO NUMERO prom prom = ( nota1 + nota2 +nota3 ) / 3 RETORNAR prom FIN Observe que en esta Etapa – Diseño de la lógica. Juan José Flores Cueto.

PARAMETRO Se utiliza para especificar las variables que utilizamos para recibir los valores enviados a un determinado método. RETORNO: prom Se especifica que el valor almacenado en la variable prom será devuelto como respuesta cuando se ejecuta el método al cual pertenece la instrucción. n2 y n3.n2. prom = EJECUTAR objAlumno.) y el nombre del objeto antes de colocar el nombre del método que se desea ejecutar. nota2 y nota3 para recibir los valores que se envían al método al cual pertenece la instrucción.setNotas ( n1. nota3 Se especifica que se utilizan las variables nota1.) y al nombre del atributo.INTRODUCCIÓN AL DESARROLLO DE SOLUCIONES ORIENTADAS A OBJETOS EJECUTAR Se utiliza para ejecutar un método. Hay que tener presente que si el método es de clase se deberá anteponer el operador punto (. RETORNO Se utiliza para especificar la variable que utilizaremos para devolver o retornar una respuesta de un determinado método.) y el nombre de la clase antes de colocar el nombre del método que se desea ejecutar. PARAMETRO: nota1.nota1 = nota1 Para referirnos al atributo nota1 utilizamos la regla ATRIBUTO. ATRIBUTO Se utiliza para diferenciar un atributo de una variable local cuando ambos tienen el mismo nombre y se utilizan en un mismo método.n3 ) Se ejecuta el método setNotas() del objeto objAlumno. Pag. EJECUTAR objAlumno. nota2. la cual antecede al operador punto (. ATRIBUTO.promedio ( ) Se ejecuta el método promedio del objeto objAlumno. El método promedio devuelve un resultado. el cual se almacena en la variable prom. y se le envían los valores de la variables n1. Si el método es de instancia se deberá anteponer el operador punto (. 567 . tal y como se muestra en el ejemplo anterior.

Clase PrgAlumno package dominioDeLaAplicacion .promedio ( ) . n1 = Lectura. this. n3 = Lectura.Desarrollo de la Codificación.Ing. n3. System. objAlumno. Alumno objAlumno = new Alumno ( ) . } double promedio ( ) { return ( nota1 + nota2 + nota3 ) / 3 . } } Clase Alumno package dominioDeLaAplicacion . // Enviamos las notas a la copia de los atributos de instancia del objeto. } void setNotas ( double nota1. class Alumno { double nota1. Juan José Flores Cueto. double nota2.out.setNotas ( n1.println ( “ La nota final de Luis es ” + prom + “.leerInt ( ) . n2 = Lectura.n3 ) .n2. System.println ( “ Ingrese la nota del examen parcial: ” ) . Etapa 04 .println ( “ Ingrese la nota de prácticas del alumno: ” ) .nota2 = nota2 .leerInt ( ) . prom .nota3 = nota3 . System. nota3 = 0 .Lectura .println ( “ Ingrese la nota de examen final: ” ) .leerInt ( ) . System. import biblioteca. nota3 . double nota3 ) { this. 568 . class PrgAlumno { public static void main ( String args [ ] ) { double n1.out. } } Pag. prom = objAlumno. this. n2.” ) .out. // Ingresamos las notas.out. nota2 = 0 .nota1 = nota1 . Alumno ( ) { nota1 = 0 . nota2.

Servlets. Conexiones a BD. Polimorfismo. es importante mencionar. tales como. que deberá continuar investigando otros conceptos importantes de la Programación Orientada a Objetos. entre otros. 569 . Interfaces Gráficas. Pag. Herencia. para luego poder iniciar con una base adecuada su investigación en el desarrollo de soluciones J2EE (Java 2 Enterprise Edition) basadas en tecnología Internet.INTRODUCCIÓN AL DESARROLLO DE SOLUCIONES ORIENTADAS A OBJETOS OTROS CONCEPTOS Finalmente. Encapsulamieno. Dichos conceptos avanzados permitirán elaborar soluciones robustas y profesionales.

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

APÉNDICE .

.

573 .APÉNDICE Problemas propuestos ENUNCIADO DE PROBLEMAS RESUELTOS 1. Desarrollar una solución que permita mostrar el nombre. 7. multiplicar. 4. Desarrollar una solución que permita mostrar un mensaje por la pantalla. Desarrollar una solución que permita mostrar el resultado de sumar. Pag. Desarrollar una solución que permita leer el costo de un artículo y su precio de venta. 5. Desarrollar una solución que permita ingresar el precio de un artículo y su respectivo descuento (expresado en %). restar y dividir los números 124 y 35. Calcular y mostrar su utilidad. Desarrollar una solución que permita ingresar el precio de un artículo y mostrar el precio total a pagar incluyendo el IGV respectivo (Impuesto General a las Ventas = 19%). Mostrar el precio total a pagar incluyendo el IGV (Impuesto General a las Ventas = 19%). Utilizar la siguiente fórmula: Promedio: nf = (nota1 + nota2 + nota3) / 3. nota2=13 y nota3=15. 2. Desarrollar una solución que permita ingresar el nombre de dos personas y luego mostrar los nombres junto con un mensaje de bienvenida. 6. apellido y el promedio del alumno Julio César Arias Pimentel que ha obtenido las siguientes notas: nota1=11. 3. El mensaje a mostrar será “Hola bienvenidos mi nombre es Danae”.

Desarrollar una solución que permita calcular y mostrar el perímetro y el área de un círculo.c)) RAIZ 2.352 soles. 13. Ingresar la cantidad en dólares y el tipo de cambio. 574 . Area = ((p*(p .09 Euros. y 1 Dólar = 1. 15. expresado en dólares. Pag.b)*(p . Desarrollar una solución que permita leer un número y calcular el resto de dividir el número entre 3. Desarrollar una solución que permita convertir y mostrar una cantidad de soles a Dólares y a Euros. en su equivalente en nuevos soles. Desarrollar una solución que permita ingresar el lado de un cuadrado. Considerar como tipo de cambio. 12. Ingresar el radio del círculo. Desarrollar una solución que permita calcular el área de un triángulo en función de las longitudes de sus lados. 10.a)*(p . Desarrollar una solución que permita convertir y mostrar una cantidad de dinero. Mostrar el resultado obtenido. 14.APÉNDICE 8. 11. Ingresar la base y la altura del rectángulo. 9. 1 Dólar = 3. Semiperímetro p = (a +b + c) / 2. Desarrollar una solución que permita calcular y mostrar el área de un triángulo rectángulo. Ingresar la base y la altura del triángulo rectángulo. Mostrar el resto de la división. Desarrollar una solución que permita calcular y visualizar el perímetro y el área de un rectángulo. Calcular y mostrar el área del cuadrado.

Donde PL = Promedio de Laboratorio. 20. Pag. sabiendo que se elimina la menor nota y se duplica la mayor nota. Calcular la suma. 21. n2. Mostrar el sueldo a cobrar. 18. multiplicación y división de dichos números. resta. n3 y n4 a través del teclado. Utilizar la siguiente fórmula: nf = (n1 + n2 + n3 + (n4 * 2)) / 5. Desarrollar una solución que permita calcular la nota final que ha obtenido un alumno en el curso de laboratorio de Programación Avanzada. 17. Ingresar las notas n1. Calcular el tiempo que permaneció en la empresa. n3 y n4 a través del teclado.APÉNDICE 16. Adicionalmente. calcular la potencia de 5 y la raíz cuadrada de cada uno de los números ingresados. 22. multiplicación y división de dichos números. 575 . Desarrollar una solución que permita ingresar el sueldo de un obrero. Desarrollar una solución que permita ingresar 2 números a través del teclado. Ingresar la hora y los minutos de entrada y de salida. Desarrollar una solución que permita ingresar 2 números a través del teclado. Desarrollar una solución que permita ingresar la hora de ingreso y la hora de salida de un obrero en la empresa que labora. Desarrollar una solución que permita calcular la nota final que ha obtenido un alumno en el curso de Algoritmo y Estructura de Datos. n2. Calcular la suma. Mostrar el resultado de las operaciones. Calcular el aumento de sueldo del obrero por concepto de escolaridad (17%). Mostrar el resultado de todas las operaciones. resta. 19. Ingresar las notas n1. El promedio final se obtiene de la siguiente fórmula: PF = (PL + EP + EF*2)/4. Desarrollar una solución que permita ingresar las notas de un determinado alumno y visualizar su promedio final. EP = Examen Parcial y EF = Examen Final.

1 pie = 12 pulgadas). pulgadas. Considerar la siguiente información: 1 metro = 100 cm. Desarrollar una solución que permita ingresar una cantidad expresada en metros. 24. Cada uno de los puntos está expresado en coordenadas y éstos deben ser ingresados por el usuario: P1(x1. 28. y visualizar su equivalente en pulgadas y en pies (1 metro = 39. Mostrar el total de descuentos y el sueldo a cobrar. 25.APÉNDICE 23. Calcular su respectivo descuento del 14% por concepto de impuestos y el 3% por concepto de cafetería. 1 yarda = 3 pies. y2).54 cm. 27.A.37 pulgadas. Intercambie las unidades de los dos números. Desarrollar una solución que permita ingresar el sueldo de un obrero de la empresa “La Poderosa S. Desarrollar una solución que permita ingresar un número de 4 cifras. Utilizar la fórmula del problema anterior para determinar la distancia entre cada uno de los puntos. 29. La distancia entre los dos puntos se calcula a partir de la siguiente fórmula: Distancia = ((x1-x2) **2 + (y1-y2) ** 2) RAIZ 2. P2(x2. los cuales corresponden a los vértices de un triángulo. 26. 576 . Desarrollar una solución que permita convertir una cantidad expresada en metros a sus equivalentes en centímetros.”. Pag. 1 pulgada = 2. Determinar la suma de las cifras del número ingresado. y1). P2 y P3. Desarrollar una solución que permita ingresar 2 números enteros positivos de dos cifras. 1 pie = 12 pulgadas. Desarrollar una solución que permita calcular y visualizar la distancia que existe entre dos puntos dados. pies y yardas. Desarrollar una solución que permita calcular el perímetro de un triángulo dadas las coordenadas de los puntos P1.

S/ 5 y S/ 1.APÉNDICE 30. Desarrollar una solución que permita convertir una temperatura expresada en grados Celsius a su equivalente en grados Fahrenheit. 577 Utilizar la siguiente . Al sueldo bruto se le aplica un descuento del 12% obteniéndose el sueldo neto. Dicho cálculo se realiza en base a un sueldo básico equivalente a S/ 465. Desarrollar una solución que permita ingresar una cantidad entera de dinero. (Ejemplo: se ingresa el número 3579 se debe visualizar el 9753). fórmula: F = (9 / 5) * C + 32. el sueldo bruto y el sueldo neto de un trabajador.. Mostrar el sueldo básico. Desarrollar una solución que permita invertir un número de cuatro dígitos. Desarrollar una solución que permita calcular y visualizar el número de segundos que hay en un determinado número de días. 31. Mostrar el sueldo neto del vendedor sabiendo que hizo 5 ventas en el mes. que existen en la cantidad de dinero ingresada. El número deberá ser ingresado por teclado. Dicho cálculo se realiza de la siguientes manera: el sueldo básico se calcula en base al número total de horas trabajadas basada en una tarifa horaria. 33. S/ 10. Desarrollar una solución que permita realizar el cálculo del pago mensual del sueldo de un empleado de una empresa. S/ 20. Desarrollar una solución que permita determinar si un número ingresado por teclado es capicúa o no. 32. 35. Pag. 34.00 nuevos soles. 36. Al sueldo básico se le aplica una bonificación del 35% obteniéndose el sueldo bruto. Un número es capicúa si se lee igual de derecha a izquierda o viceversa. S/ 50. más una comisión del 18% por cada venta que el vendedor realice. Desarrollar una solución que permita calcula el sueldo neto de un vendedor. Mostrar el número de billetes de S/ 100. (Ejemplo de número capicúa 4554).

39. donde: Vf = Velocidad final. Agudo. Desarrollar una solución que permita determinar si una persona es o no mayor de edad. Desarrollar una solución que permita calcular y mostrar el área de un cuadrado. 40. 1 Megabyte= 1024 Kilobytes. a = Aceleración. Desarrollar una solución que permita calcular el porcentaje de hombres y el porcentaje de mujeres que están matriculados en un determinado curso. Desarrollar una solución que permita leer la capacidad de un disco duro en Gigabytes. Considerar las siguientes fórmulas: e = Vot + at 2 Vf = Vo + at. código y edad de la persona. conociendo su velocidad final. Desarrollar una solución que permita determinar con qué velocidad inicial partió un automóvil de un determinado punto y qué distancia. e = Espacio recorrido. apellidos. Los ángulos se clasifican de la siguiente manera: Ángulo = 0 0 < ángulo > 90 Pag. t = Tiempo empleado en el recorrido. Kilobytes y Bytes. se deberá visualizar el mensaje “Cuadrado pequeño”. . 38. 41. Desarrollar una solución que permita determinar cómo se clasifica un ángulo ingresado por teclado. Vo = Velocidad Inicial. 578 Nulo. 42. 1 Kilobyte= 1024 Bytes.APÉNDICE 37. Mostrar el equivalente en Megabytes. 1 Gigabyte= 1024 Megabytes. Ingresar el nombre. Si el área del cuadrado resulta menor que 768. su aceleración y el tiempo empleado en el recorrido.

La empresa paga a sus vendedores por horas trabajadas. Mostrar el sueldo y el descuento respectivo. sabiendo que se tienen sólo dos notas. Desarrollar una solución que permita Pag. 3000. sabiendo que se debe descontar un 10% del sueldo por concepto de impuestos si éste es mayor de S/. 579 . 44.00 el sueldo del trabajador está sujeto a un descuento del 15%. 45. Llano. se paga la tarifa con un recargo del 20%. Cóncavo. 46. Obtuso. Hasta 40 horas trabajadas se paga una tarifa normal y sobre las 48 horas. Desarrollar una solución que permita calcular y mostrar el sueldo de un trabajador conociendo el número de horas trabajadas y su tarifa horaria. ‘B’. 47. el sueldo bruto y el descuento de un trabajador de una empresa. Completo. Si el alumno obtiene una nota final mayor a 17 se deberá visualizar un mensaje de felicitaciones. Desarrollar una solución que permita calcular el sueldo de un trabajador conociendo el número de horas trabajadas y su tarifa horaria. Desarrollar una solución que permita calcular y mostrar la nota final (nf) de un alumno.00. Desarrollar una solución que permita ingresar los votos obtenidos por cada candidato en una elección democrática.00. Por otro lado. Considerar que han participado 5 candidatos cuyos códigos son ‘A’.APÉNDICE Ángulo = 90 90 < ángulo > 180 Ángulo = 180 180 < ángulo > 360 Ángulo = 360 Recto.1650. Desarrollar una solución que permita determinar el sueldo neto. Determinar la votación promedio y mostrar los códigos de los candidatos que obtuvieron una votación inferior a la votación promedio. si el sueldo bruto es superior a S/. ‘D’ y ‘E’. ‘C’. 43. sabiendo que se debe descontar un 12% del sueldo por concepto de impuestos si éste es mayor de S/. 1860.

Desarrollar una solución que permita ingresar tres notas de un determinado alumno. Desarrollar una solución que permita determinar que proveedor es más conveniente para una empresa. 49. Considerar que deberá agregar el IGV respectivo. caso contrario se mostrará el mensaje “Alumno aprobado”. Desarrollar una solución que permita calcular y mostrar la nota final de un alumno.0 y 15% de descuento para más de 50 unidades adquiridas. Desarrollar una solución que permita calcular y mostrar el monto total a pagar por la compra de varios artículos. Si la nota final (nf) es menor a 13 se deberá mostrar el mensaje “Alumno desaprobado”. considerando un descuento del 27% por la compra de 150 unidades. Si el monto total a pagar incluido IGV es mayor a S/.APÉNDICE 48. de acuerdo a lo especificado a continuación: Proveedor A: Costo unitario igual a $25. Utilizar la expresión (num1 RESTO num2 > 0) donde “num1” y “num2” son los números. 1800. 51. La empresa desea adquirir cierta cantidad de unidades de un producto para lo cual cuenta con una oferta de dos proveedores. 580 . Desarrollar una solución que permita que permita calcular el monto a pagar por la compra de un producto.5 y 10% de descuento para mas de 35 unidades adquiridas. 50. 52. Desarrollar una solución que permita determinar si un número es divisor de otro número. Pag. 53. Mostrar las notas ordenadas en forma ascendente (de menor a mayor). Proveedor B: Costo unitario igual a $27. caso contrario el descuento será del 3%. Fórmula: nf = (n1+n2+n3) / 3.00 nuevos soles se aplica un descuento del 12%.

Si el número es par o impar.APÉNDICE 54. 60.. Desarrollar una solución que permita determinar si un numero (num) es par. Desarrollar una solución que permita ingresar un número entero. Indicar lo siguiente en base al número ingresado: Si el número es positivo o negativo. Mostrar el nombre del día de la semana correspondiente. Desarrollar una solución que permita ingresar un número entero. Mostrar el nuevo sueldo del trabajador. (Lunes. Mostrar si el número ingresado es un número par o un número impar. Categoría 1 2 3 Aumento 35 % 25 % 15 % Pag.etc). 56. Febrero. un número par o un número múltiplo de 7. 59. Desarrollar una solución que permita ingresar un número entero. 581 . Desarrollar una solución que permita ingresar un número entre 1 y 12. Mostrar el nombre del mes del año correspondiente. (Enero. 55. impar o nulo. Mostrar si el número ingresado es un número negativo.. Si el número es Menor que 500 o no. Desarrollar una solución que permita ingresar la categoría y el sueldo de un trabajador. Mostrar un mensaje si el número es par. Si el número es múltiplo de 3 o no. 57. Desarrollar un programa que permita ingresar un número entre 1 y 7.. Utilizar lo siguiente: -1 elevado a la potencia del número ingresado (-1 ** num). 58. martes…etc). impar o nulo. Calcular el aumento correspondiente teniendo en cuenta la siguiente tabla.

debe considerar que las mujeres tienen un incremento del 19% para el primer tipo de enfermedad y los hombres tienen un aumento del 4% para el tercer tipo. 4. Considerar que se venden 4 tipos de sándwich. Enfermedad Tipo 1 2 Costo diario 180 420 Pag. sabiendo que.00 62. 2. hay que pagar el 6% por el servicio y 7% por propinas. 3. Enfermedad Tipo 1 2 3 Costo diario 120 380 620 63. según los datos de la tabla. Desarrollar una solución que permita calcular y mostrar el costo total que representa un paciente para un hospital de acuerdo al tipo de enfermedad. Adicionalmente. 6. 582 . adicionalmente. Desarrollar una solución que permita calcular y mostrar el monto total a pagar por un sándwich. Desarrollar una solución que permita calcular y mostrar el costo total que representa un paciente para un hospital de acuerdo al tipo de enfermedad.APÉNDICE 4 5% 61. Tipo Moderado Mediano Extra Grande Full Costo S/. de acuerdo a la siguiente tabla. Adicionalmente.00 S/.00 S/. debe considerar que los pacientes menores de 18 años implican un costo adicional de 25 %.00 S/. según los datos de la tabla.

Desarrollar una solución que permita ingresar las notas obtenidas por un alumno del curso de Matemática Básica III. considerando que la nota mínima aprobatoria es 12 (doce).APÉNDICE 3 513 64. 583 . Considerar la siguiente tabla: Edad 18 -más 11 -17 0 –10 Categoría Contenido para adultos. debe considerar que los pacientes de sexo femenino menores de 14 años implican un costo adicional de 8%. Desarrollar una solución que permita calcular y mostrar el costo total que representa un paciente para un hospital de acuerdo al tipo de enfermedad. de acuerdo a la fórmula empleada por su profesor. Calcular su nota final (nf). según los datos de la tabla. Mostrar la nota final (nf) del alumno y si está aprobado o no. Apta para todos. Adicionalmente. Desarrollar una solución que permita determinar y mostrar si una persona que está a punto de observar un programa de televisión esta apto o no. Mayores de 14. según los datos de la tabla. Enfermedad Tipo 1 2 3 4 Costo diario 122 234 345 587 66. 65. Código Profesor 1 2 3 Fórmula nf = (n1 + n2 ) / 2 nf = (n1 + n2*2) / 3 nf = (n1*2 + n2) / 3 Pag.

Desarrollar una solución que permita determinar la categoría de cada alumno. Considerar que la categorización de los postulantes se realiza en función de su sexo y edad. Calcular el promedio del alumno sabiendo que se elimina la nota mas baja. de acuerdo a lo siguiente: Si la persona es de sexo femenino: Categoría FA si tienen menos de 30 años.APÉNDICE 67. Si la persona es de sexo masculino: Categoría MA si tiene menos de 40 años. Categoría FB en caso contrario. 584 . Finalmente. Desarrollar una solución que permita determinar la categoría de cada postulante. determinar la categoría obtenida por un alumno. Considerar que la categorización de los alumnos se realiza en función de la nota en base a la siguiente tabla: Promedio 18 – 20 15 – 17 11 – 14 00 – 10 Bueno Regular Malo Categoría Excelente 69. Desarrollar una solución que permita ingresar las ‘n’ notas de un alumno. tal y como se muestra en la siguiente tabla: Promedio Desde 17 a 20 Desde 14 a 16 Desde 10 a 13 Desde cero a 9 Categoría A B C D Pag. 68. considerando que la categoría del alumno está en función de su promedio. Categoría MB en caso contrario.

y si el área es mayor o igual que 1000. el tipo de participante (profesor. Desarrollar una solución que permita ingresar el sueldo de un trabajador. externo) y el nivel del curso (básico. Si el área es menor que 100. se deberá visualizar el mensaje “rectángulo pequeño”. Si el área es menor que 100. Calcular y mostrar su aumento por incremento del costo de vida de acuerdo a la siguiente tabla: Pag. Desarrollar una solución que permita ingresar el nombre del alumno. 71. Desarrollar una solución que permita calcular el área de un rectángulo conociendo su base y altura. alumno. 585 . Desarrollar una solución que permita calcular el área de un rectángulo conociendo su base y altura. En la tabla que se muestra a continuación se detallan los costos de los cursos: Básico Profesor Alumno Externo 35 40 60 Intermedio 40 50 80 Avanzado 45 60 100 Mostrar los datos del recibo. intermedio. avanzado).APÉNDICE 70. se visualizará el mensaje “rectángulo mediano”. se deberá visualizar el mensaje “rectángulo pequeño” y si el área es mayor o igual que 1000 se deberá visualizar el mensaje “rectángulo grande”. si el área es mayor o igual a 100 y menor que 1000. el mensaje será “rectángulo grande”. 72. tal y como se muestra en el siguiente ejemplo: ********************* RECIBO ****************** Alumno : Juan Pérez Costo Nivel : (de acuerdo a la tabla) : (de acuerdo al ingresado) *************************************************** 73.

78.APÉNDICE Condición Sueldo < 2000 2000 < =Sueldo < =3000 Sueldo > 3000 Aumento 23 % 17 % 12 % 74. Desarrollar una solución que permita ingresar un número de 3 cifras. Desarrollar una solución que permita calcular el factorial de un número entero positivo. Mostrar el equivalente del número ingresado en letras. Mostrar el equivalente del número ingresado en letras. 586 . 77. Calcular el número de días que tiene el mes y si el año ingresado es bisiesto o no. Se deberá mostrar: 12 de Mayo del 2005. 79. Ejemplo: Ingreso 12/05/2005. Desarrollar una solución que permita ingresar la temperatura promedio (tp) de un día y permita mostrar el tipo de clima de acuerdo a la siguiente tabla: Temperatura (tp) TP<=9 9<TP<=17 17<TP<=27 TP>27 Tipo de Clima Frió Nublado Caluroso Trópico 75. Desarrollar una solución que permita ingresar un número de 2 cifras. Pag. Desarrollar una solución que permita ingresar una fecha en el siguiente formato: (dd/mm/aaaa). Desarrollar una solución que permita ingresar una fecha (dd/mm/aaaaa) y la convierta al siguiente formato de fecha: “dd de NombreMes de aaaa”. 76.

Solicitar el valor del primer término. 82. 587 . 2 2 2 2 Pag. Desarrollar una solución que permita determinar cuáles son los términos de una progresión aritmética. 86. Mostrar el número mayor. 88. Desarrollar una solución que permita determinar cuales son los términos de una progresión aritmética y la suma de los mismos. 85. Desarrollar una solución que permita determinar cuales son los términos de una progresión geométrica y la suma de los mismos. Solicitar el valor del primer término.. Desarrollar una solución que permita determinar la suma de todos los números cuadrados perfectos existentes entre los 1000 primeros números. Desarrollar una solución que permita ingresar tres números enteros. Desarrollar una solución que permita mostrar la tabla de multiplicar de un número cualquiera ingresado por teclado. 84.APÉNDICE 80. Desarrollar una solución que permita determinar los 3 primeros números perfectos.. la suma de dígitos y la cantidad de dígitos pares e impares de un número entero. 87. el valor de la razón y el número de términos. el valor de la razón y el número de términos. Desarrollar una solución que permita calcular la cantidad de dígitos. 83. el valor de la razón y el número de términos. 81. Desarrollar una solución que permita determinar y mostrar la suma de los términos de la siguiente serie: 1 + 1/3 + 1/5 + 1/7 + 1/9 +. Solicitar el valor del primer término.

Calcular y mostrar la suma de los números pares. ceros y positivos. 94. Desarrollar una solución que permita ingresar un número entero. 96. Desarrollar un programa que genere cada uno de los siguientes gráficos: Pag. Desarrollar una solución que permita ingresar 100 números. Determinar cuántos números son negativos. 95. Determinar y mostrar si el número ingresado es un número primo o no. 91. la suma de los números impares y la media de todos los número ingresados. Desarrollar una solución que permita ingresar 10 números. Desarrollar una solución que permita ingresar 50 números. 90. 92. Desarrollar una solución que permita calcular y mostrar la suma de los números pares y la suma de los números impares comprendidos entre los números 1 y 100 (no incluir los números 1 y 100). Determinar y mostrar la suma de todos los números pares y la suma de todos los números primos. 93. Determinar la suma de todos los números impares y la cantidad de números primos ingresados.APÉNDICE 89. 588 . Desarrollar un programa que genere cada uno de los siguientes gráficos: * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 97. Desarrollar una solución que permita ingresar 50 números enteros cualesquiera. Desarrollar una solución que permita calcular y mostrar el producto de los números pares comprendidos entre los números 20 y 400.

Mostrar la cadena ingresada en forma triangular. Desarrollar un programa que genere el siguiente gráfico: 1 2 4 7 2 7 2 5 7 3 8 3 6 8 4 9 4 5 9 5 1 3 6 1 6 99.APÉNDICE * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 98. Se ingresa la cadena “Danae”. D DA DAN DANA DANAE 100. Se ingresa la cadena “Danae”. DANAE DANA DAN Pag. Tal y como se muestra a continuación: Ejemplo. Mostrar la cadena ingresada en forma triangular. Desarrollar un programa que permita leer una cadena. Tal y como se muestra a continuación: Ejemplo. Desarrollar un programa que permita leer una cadena. 589 .

Calcular y mostrar lo siguiente: Suma de todas la edades. La cantidad de símbolos. 590 . 102. Desarrollar una solución que permita calcular la nota final de todos los alumnos. 103. Desarrollar una solución que permita calcular la nota final de todos los alumnos. Ingresar las notas a través del teclado. El número deberá ser ingresado por teclado. Se deberá utilizar la estructura lógica MIENTRAS. Desarrollar una solución que permita calcular y mostrar la nota final de 10 alumno. Pag. Utilizar la siguiente fórmula: nf = (n1+n2+n3+(n4*2))/5. Utilizar la siguiente fórmula: nf = (n1 + n2 + n3 + (n4 * 2)) / 5. 105. Utilizar la siguiente fórmula: nf = (n1 + n2 + n3 + (n4 * 2)) / 5. Desarrollar una solución que permita ingresar un texto y permita determinar lo siguiente: La cantidad de vocales. Edad máxima. 106. Desarrollar una solución que permita ingresar las edades de 10 alumnos. Desarrollar una solución que permita invertir un número cualquiera. Promedio de edades pares. Ingresar las notas a través del teclado. 104. Edad mínima. La cantidad de espacios en blanco.APÉNDICE DA D 101. Promedio de edades. La cantidad de consonantes.

aquellos que tienen promedio final entre 15 y 17. 110.00 y S/. y cuántos más de S/.70 metros y 1. 800. 107. 800. 3.70 metros. 591 . En un salón de clase se ha realizado un examen con tres pruebas distintas.000. Se desea conocer el promedio obtenido en cada una de las pruebas realizadas. Determinar cuántos ganan menos de S/. determinar cuál es el mayor y el menor sueldo en la empresa. 3.3. Desarrollar una solución para el siguiente problema.60 metros.APÉNDICE Ingrese las notas a través del teclado. Desarrollar una solución para el siguiente problema. la suma de sueldos de los empleados (categoría B) y la suma de sueldos de los gerentes (categoría A) de una determinada empresa. 800. Desarrollar una solución para el siguiente problema. Adicionalmente.00 (Incluidos S/.60 metros y 1. Calcular y mostrar el número de alumnos que tienen promedio final menos de 11. Se tiene una relación de 100 obreros y su sueldo.000. Alturas entre 1. y los que tienen promedio final mayor de 17. Alturas mayores de 1.80 metros. Alturas entre 1.00. 109. Desarrollar una solución que permita determinar la suma de sueldos de los obreros (categoría C). Se desea hacer una estadística de las estaturas de los 1000 alumnos de un colegio.80 metros. Se deberá utilizar la estructura lógica HACER. los que tiene promedio final entre 11 y 14. 108. entre S/. 111. Pag. Ingresar 4 notas y calcular el promedio del alumno en base a la siguiente fórmula: nf = (n1 + n2 + n3 + (n4 * 2)) / 5.00).000. de acuerdo a lo siguiente: Alturas hasta 1.00 y S/.00.

Se desea calcular el jornal diario de cada empleado teniendo en cuenta lo siguiente: Pag. Los empleados de una fábrica trabajan en tres turnos.00 soles y el resto de empleados de acuerdo a sus posibilidades. [2] Proceso (determinar área y perímetro del rectángulo). los profesionales con S/ 25. Desarrollar una solución que permita emitir la factura correspondiente a la compra de varios artículos. [4] Terminar.APÉNDICE 112. Calcular la nota media de los alumnos de una clase considerando “n” alumnos y “c” notas. El IGV a aplicar es el 19% y si el monto total de la factura.00 soles. incluido IGV. tarde y noche. Calcular el total de loterías vendidas de cada tipo. 113. Determinar el total recaudado. 3. Desarrollar una solución que permita desarrollar el siguiente menú con las opciones solicitadas. mañana. Se determina que los gerentes contribuirán con S/ 35. [1] Ingreso de datos (base y altura de un rectángulo). Tipo lotería 1 2 3 4 Costo 2 4 6 8 114. Un canillita vende 4 tipos de loterías según se muestra en el siguiente cuadro. 592 . 117. es mayor a S/. 115. 116.00 nuevos soles se aplicará un descuento del 12%.000. En una empresa se decide hacer una colecta de dinero con la finalidad de ayudar a uno de los empleados de la empresa que ha sufrido un accidente automovilístico. Desarrollar una solución para el siguiente problema. [3] Resultado (Mostrar el valor de área y perímetro obtenidos).

se deberá proporcionar la siguiente información: Número total de entradas vendidas durante el día. 119. Por cada entrada vendida se leerá los siguientes datos: número de boleto y lugar (puede ser platea.APÉNDICE La tarifa del turno mañana y tarde es de S/ 8. palco y mezanine en el día. platea y mezanine. 593 . 118. En caso de ser un día domingo. Para el turno tarde se incrementa S/ 10. palco o mezanine). Número de entradas vendidas para platea. en base a la siguiente información: Al comenzar. La tarifa del turno noche es de S/ 10.00 soles por concepto de movilidad.00 soles por hora. Antes de finalizar. 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? Pag. El total de soles recaudados en el día. la tarifa se incrementa en 50% para los turnos mañana y tarde y en 60% para el turno noche. se leerá una sola vez el precio de entrada para palco. El programa terminará cuando el número de boleto sea igual a cero.00 soles por hora. Desarrollar una solución que permita controlar la venta de boletos en un determinado día en un teatro de la capital.

121. desaprobados.200. el nombre del alumno con la mayor nota y el nombre del alumno con la menor nota. deberá indicar el promedio del costo de todos los artículos. deberá considerar que los pacientes menores de 18 años implican un costo adicional de 35% y las mujeres un costo adicional de 12%. 2.A. entre S/. y cuantos tienen un salario mayor a S/.”. Adicionalmente. deberá indicar el porcentaje de alumnos aprobados. según los datos de la tabla.00 y S/. el precio de venta y la utilidad de cada artículo. Desarrollar una solución que permita determinar la nota final obtenida por cada uno de los alumnos del curso de Álgebra del colegio “La Excelencia” (considere 3 notas). Adicionalmente. 500. 2. Adicionalmente. Desarrollar una solución para el siguiente problema. En la fabrica “LA CLONACION S. 500. Desarrollar una solución que permita calcular y mostrar el costo total que representan los pacientes de un hospital de acuerdo al tipo de enfermedad. 123. la nota final más baja y más alta.00.200.00. 2. Trabajan miles de obreros y se desea determinar cuantos tienen un salario menor a S/. Enfermedad Tipo 1 2 3 Costo diario 100 150 300 Pag.00 (incluidos S/. Ingresar el nombre. 594 . el articulo más caro y el más barato.200. Ingresar la cantidad de alumnos y las 3 notas de cada alumno. Desarrollar una solución que permita determinar el costo de cada uno de los artículos que se venden en la bodega “La China” (considere el precio de venta y la utilidad obtenida por el artículo). Determinar la suma de las edades. 122. Desarrollar una solución que permita ingresar los nombres y las edades de ‘n’ alumnos.00).00 y S/. 124. 500.APÉNDICE 120.

Pag. la cantidad existente y el almacén donde están ubicados). (Ingresar solo los siguientes datos: Número de sala y el horario al cuál el cliente ingresa).APÉNDICE 4 450 125. Desarrollar una solución para el siguiente problema. caramelo y gaseosa). Deberá ingresar el tipo de hamburguesa y el local en el que fue vendida. Desarrollar una solución que permita determinar cuántos tipos de productos de cada empresa de apoyo social fueron vendidos por la comunidad “La buena Venta” durante el presente año (considere solo tres empresas de apoyo social y asuma que cada empresa fabrica 3 tipos de producto: chocolate. su precio de venta. 595 . Desarrollar una solución que permita determinar cuántas hamburguesas fueron vendidas de cada tipo (considere 3 tipos) en cada uno de los 3 locales de la empresa “El Rápido”. Ingresar el tipo de diario vendido y la empresa a la cuál pertenece. 126. (considere solo tres empresas periodísticas. Calcular el número de personas que ingresaron a cada una de las salas en cada uno de los horarios en un determinado día. normal y especializado). 129. Desarrollar una solución para el siguiente problema. Una empresa cuenta con cuatro almacenes de productos. 127. ¿Cuál sería la ganancia por cada almacén si el dueño de la empresa decide vender todos sus productos? (Ingresar solo los siguientes datos: El precio de compra de cada producto. 128. y asuma que cada empresa desarrolla 3 tipos de diario: popular. quien ganó el premio al mejor canillita 1999 otorgado por un diario de la capital. Ingresar el producto vendido y la empresa que lo fabricó. vermouth y noche. El cine “Pantalla Láser” cuenta con 3 salas y atiende en horarios de matinée. Desarrollar una solución que permita determinar cuántos tipos de periódicos de cada empresa fue vendido por José Luis Candado.

131. Salida. Determinar lo siguiente: Sueldo promedio. Pag.APÉNDICE 130. Salida. resta y multiplicación de dos números. El promedio de edades. Menor sueldo. Desarrollar una solución que permita ingresar los valores de una matriz de 4*4. La edad menor. Determinar el número inverso de un número. Nombre del empleado con mayor sueldo. Calcular la suma de la diagonal y la suma de la diagonal inversa. 133. 596 . Cantidad de nombre que comiencen entre “c y p”. El promedio de edades pares. 132. Desarrollar una solución que permita ingresar las edades de 10 alumnos. Determinar si un número es primo o no. Determinar el área y perímetro de un círculo. La cantidad de edades impares. Determinar lo siguiente: La suma de todas las edades. La edad mayor. Desarrollar una solución que permita mostrar un menú con las siguientes opciones: Suma. Desarrollar una solución que permita ingresar los nombres y sueldos de 5 empleados. Desarrollar una solución que permita mostrar un menú con las siguientes opciones: Determinar si un número es par o impar. El nombre de la alumna que tiene la mayor edad. 134.

30/09/2004 18:10:10. 142. Determinar y mostrar el digito mayor del número ingresado. Determinar el número de nombres cuya primera letra es una letra ‘c’ o una letra ‘x’. la edad y el estado civil de 15 empleados. 136. así como también intercambiar la segunda fila por la cuarta fila. Desarrollar una solución que permita leer 10 nombres. Ejemplo. Desarrollar una solución que permita leer 10 apellidos. Desarrollar una solución que reciba la fecha con el siguiente formato: 09-302004 (mm-dd-aaaa) y lo convierta a este otro formato: 30 de Septiembre del 2004. Determinar cuantos nombres comienzan entre las letras ‘z’ y ‘p’. Mostrar los datos de la siguiente manera: Hoy es 30 de septiembre y son las 18 y 10 de la tarde. así como los símbolos indicados. 137. También determine el nombre que tiene el menor número de caracteres. Validar que la fecha y la hora tenga el número de caracteres correctos. 139.APÉNDICE 135. Desarrollar una solución que permita ingresar un número entero de cualquier número de cifras. Utilizar un vector. y otro listado con los datos de todo los empleados solteros. Desarrollar una solución que reciba la fecha y hora con el siguiente formato: “dd/mm/aaaa hh:mm:ss”. Elaborar un listado con los datos de los empleados cuya edad este ente 18 y 30 años. Intercambiar la primera columna por la tercera columna. 597 . Desarrollar una solución que permita almacenar el nombre. Determinar cuál es el apellido mayor (alfabéticamente hablando). Pag. 138. Desarrollar una solución que permita ingresar 10 nombres. 140. Desarrollar una solución que permita ingresar los valores de una matriz de 5*4. 141. Validar el número ingresado.

Nombre del alumno con mayor nota. nombre. tipo (Ingresantes. Los datos de los alumnos son. Calcular los años de servicio (que tiene trabajando). Desarrollar una solución que permita leer los datos de 5 empleados. fecha de nacimiento (dd/mm/aaaa) y nota. nombre. Regular o Egresado) y nota. Se solicita: Ingresar los datos haciendo las validaciones a la fecha (tamaño de fecha y que contenga los símbolos “/”) y nota. Hallar: Hallar la nota promedio de todos los alumnos ingresados. Utilizar un vector y validar que el número ingresado sea de 3 cifras. nombre. Hallar: Hallar el sueldo promedio. fecha de ingreso (dd/mm/aaaa) y sueldo. Cantidad de empleado que ingresaron entre 1980 y 2004. Mostrar su categoría. Desarrollar una solución que permita leer los datos de 5 alumnos. Crear un menú de opciones para acceder al programa. Se solicita: Ingresar los datos haciendo las validaciones a la fecha (tamaño de fecha y que contenga los símbolos “/”) y sueldo. 598 . Los datos de los alumnos son. Si el número está entre 301 y 600 pertenece a la categoría B. 145. Si el número está entre 100 y 300 pertenece a la categoría A. Nombre del empleado con menos años de servicio. 144. Pag. Crear un menú de opciones para acceder al programa. Cantidad de alumnos cuyo nombre comience entre a y p. Los datos de los empleados son. 146. Desarrollar una solución que permita leer 4 números de 3 cifras. y si el número está entre 601 y 999 pertenece a la categoría C. Calcular y mostrar la edad de cada alumno .APÉNDICE 143. Desarrollar una solución que permita leer los datos de ‘n’ alumnos.

Los datos de los alumnos son. 148. Por cada alumno mostrar: Nombre al revés. 147. fecha de nacimiento (dd/mm/aaaa) y nota. Desarrollar una solución que permita leer los datos de ‘n’ alumnos. edad y sexo. Pag. Los datos de los alumnos son. Crear un menú para acceder al programa. Crear una opción para continuar ejecutando el programa. Los 3 primeros caracteres del nombre. Si es egresado y tiene entre 17-20 categoría EA.APÉNDICE Se solicita: Ingresar los datos haciendo las validaciones al tipo y nota. Cálculos: Hallar la edad promedio. Las 3 ultima letras. Cálculos: Hallar el promedio de los ingresantes y regulares. Por cada alumno mostrar la categoría: Si es ingresante y tiene entre 17-20 categoría IA. 599 . Desarrollar una solución que permita leer los datos de ‘n’ alumnos. Nombre de la persona con mayor edad. Si es ingresante y tiene entre 12-16 categoría IB. Si es regular y tiene entre 17-20 categoría RA. Se solicita: Ingresar los datos validando que en el sexo y la edad. nombre. Por cada alumno mostrar: Nombre en Mayúscula. Mayor nota de los ingresantes y de los Egresados. Nombre de mujer con menos edad. Ultimo carácter. nombre. Nombre del alumno con mayor nota.

Mostrar el nombre de la persona más nueva es decir con menos años de ingreso. Unión y ProFuturo). Calcular y mostrar el sueldo Total por cada empleado ( sueldo Total = sueldo Básico – descuentos): Si tiene 4 o más años de antigüedad se le descuenta 8% más el descuento de la AFP. Los datos de los empleados son. Crear un menú de opciones para acceder al programa.APÉNDICE Se solicita: Ingresar los datos validando la fecha de nacimiento y la nota. sueldo Básico y fecha de ingreso (dd-mm-aaaa). sueldo y fecha de ingreso. Si tiene menos de 4 años se le descuenta 10% más el descuento de la AFP. 149. Cálculos: Hallar la edad promedio. Crear un menú de opciones para acceder al programa. AFP (Integra. Nombre de mujer con menos edad. Desarrollar una solución que permita leer los datos de ‘n’ empleados. Nombre y la edad de la persona con mayor nota. El descuento de la AFP se ve en la siguiente tabla: AFP Integra Unión ProFuturo Cálculos: Mostrar el nombre y el AFP de la persona con mayor sueldo. 600 Descuento 12% 13% 14% . Pag. Mostrar por cada alumno la edad exacta (años y meses cumplidos a la fecha de hoy). nombre. Se solicita: Ingresar los datos validando AFP.

Cantidad de vocales del nombre. Pag. Se solicita: Ingresar los datos validando que en el sexo solo se ingrese ‘M’ o ‘F’. sexo (M/F). Crear un menú de opciones para acceder al programa. Cálculos: Hallar la edad promedio. Los datos de los alumnos son. 601 . y la edad sea un número positivo.APÉNDICE 150. Nombre de hombre con menos edad. Desarrollar una solución que permita leer los datos de ‘n’ alumnos. edad y nombre. Mostrar lo siguiente por cada alumno: Si es mayor o menor de edad. Nombre de la persona con mayor edad.

602 .APÉNDICE Pag.

valueOf(leerString()).. return leerFloat().print("ERROR..io.length == 1) c = c1[0]. */ public static float leerFloat() { try { return Float. /* * Clase que permite capturar literales desde el teclado.APÉNDICE Clase Lectura package biblioteca. return c. char[] c1 = leerString(). } /** * Retorna un literal double capturado desde el teclado. } catch (NumberFormatException e) { System..doubleValue()..\n Ingrese de nuevo: "). } } /** * Retorna un literal float capturado desde el teclado. } } Pag.toCharArray(). */ public static double leerDouble() { try { return Double.*.out. } catch (NumberFormatException e) { System. return leerDouble(). 603 .floatValue().print("ERROR. * */ public class Lectura { /** * Retorna el char capturado desde el teclado. */ public static char leerChar() { char c = ' '. if (c1.out. import java.\n Ingrese de nuevo: ").valueOf(leerString()).

print("ERROR. return leerLong().parseInt(leerString()).out. try { cadena = in. */ public static int leerInt() { try { return Integer.out.\n Ingrese de nuevo: ").. 604 . return leerInt().valueOf(leerString()). } } Pag.\n Ingrese de nuevo: "). } catch (IOException e) { System.print("ERROR. return leerShort().out.readLine(). } catch (NumberFormatException e) { System..\n Ingrese de nuevo: "). } catch (NumberFormatException e) { System. */ public static long leerLong() { try { return Long. } catch (NumberFormatException e) { System..shortValue(). String cadena = ""..APÉNDICE /** * Retorna un literal int capturado desde el teclado. } } /** * Retorna un literal short capturado desde el teclado..in)).print("ERROR. } } /** * Retorna un literal long capturado desde el teclado. */ public static short leerShort() { try { return Short.out.longValue(). } return cadena..println(e). */ public static String leerString() { BufferedReader in = new BufferedReader(new InputStreamReader(System. } } /** * Retorna una cadena capturada desde el teclado.valueOf(leerString()).

605 .text.APÉNDICE Clase DecimalFormat java. Tiene una gran variedad de opciones para dar formatos a números en cualquier sistema. La clase DecimalFormatSymbols permite modificar los símbolos de formato como separadores decimales o el signo negativo entre otros. Pag. en Francia. notación científica.NumberFormat java. Por ejemplo. Los programas almacenan y operan con números de una forma independiente de la Localidad. y en Alemania debería aparecer como 123.Object java.78.78 debería ser formateado como 123 456. incluye soporte para dígitos Occidentales. decimales.Format java. Con la clase DecimalFormat se específica un formato de número con patrón. Arábigos e Índicos. como son: enteros.text. Se puede utilizar la clase DecimalFormat para formatear números decimales en cadenas específicas de la Localidad. etc.78. Antes de mostrar o imprimir un número el programa debe convertirlo a un String que esté en un formato sensible a la Localidad.text. el número 123456. métodos: Par poner en práctica esto podemos recurrir a 2 NumberFormat formato .456.DecimalFormat DecimalFormat es una clase concreta de NumberFormat que da formato a números decimales. formato de moneda. También soporta gran variedad de formatos numéricos.lang. DecimalFormat df .

###E0" muestra 1234 como "1. separadores (millares).getNumberInstance(currentLocale). los sufijos y prefijos. E . se puede utilizar DecimalFormatSymbols en conjunción con la clase DecimalFormat Símbolos usados para formato Símbolo Significado 0 # .APÉNDICE Si queremos dar formato a números: formato = NumberFormat. Si queremos dar formato a monedas: formato = NumberFormat. Si se quiere cambiar un símbolo del formateo como el separador decimal. Luego aplicamos las características locales almacenadas en formato a df: DecimalFormat df = (DecimalFormat)nf. el cero se muestra como ausente Separador decimal Signo menos Separador de agrupación Para notación científica "0.234E3" Para separar formatos positivos y negativos Multiplica por 100 y lo muestra como porcentaje Multiplica por 1000 y muestra como millares ¤ (\u00A4) Utilizado para mostrar símbolos monetarios ' Usado para mostrar caracteres especiales Ejemplo: Pag. . 606 . y el separador decimal. % \u2030 Digito Digito. Esta clase permite controlar los ceros iniciales y finales.getCurrencyInstance(currentLocale).

f = new DecimalFormat("###. s = f. System.00"). s = f. System.out. s = f.00").out. f = new DecimalFormat("'U$' ###. f = new DecimalFormat("'S/. Si queremos que un número que no tiene parte decimal muestre un ‘0’antes del separador decimal debemos poner un ‘0’ en esa posición en nuestra cadena de formato. f = new DecimalFormat("#. System. s = f. s = f.format(n).format(n).leerDouble(). s = f.'###.format(n). String s.println(s).format(n). System.out. s = f. Debemos tener en cuenta que: • • Para poner completar con ceros la parte decimal debemos poner tantos “0” como dígitos decimales queremos que tenga nuestro número en la cadena de formato.00 Soles").###"). public static void main(java. n = Lectura.String[] args) { double n. f = new DecimalFormat("###.APÉNDICE En el ejemplo siguiente usaremos distintos cadenas de texto para dar formato a un número ingresado por teclado.out. System.out.out. System.###.println(s). 607 .###.####E0").##0. f = new DecimalFormat("###.println(s).##0.##0.out.out.lang. System.format(n). } Pag.print("Ingresa número a dar formato : ").00%").println(s).println(s).format(n).##0.format(n).println(s). f = new DecimalFormat("###.0000"). DecimalFormat f.println(s). System.

simbolosraros. System. String s. } Pag. reemplazamos el símbolo que representa números negativos (-) por n public static void main(java.setGroupingSize(4). f = new DecimalFormat("###. simbolosraros.setMinusSign('n'). //Ahora modificamos los símbolos usados como separadores decimales //y de millares.String[] args) { double n. y reemplazamos el símbolo de separación decimal por | y el separador de grupos por ^ asimismo los grupos los hacemos de 4 dígitos (en vez de 3 como es regularmente) y por último.lang.leerDouble().out. //esto lo hacemos utilizando la clase DecimalFormatSymbols DecimalFormatSymbols simbolosraros = new DecimalFormatSymbols().print("Ingresa número a dar formato : ").APÉNDICE En el siguiente ejemplo utilizamos la clase DecimalFormatSymbols. DecimalFormat f.setDecimalSeparator('|'). simbolosraros. s = f.out.format(n).00". f.println("Alterando los símbolos : " + s). n = Lectura. simbolosraros).setGroupingSeparator('^'). System. asi como el símbolo usado para especificar un negativo.##0. 608 .

cal. DATE. Esta plataforma implementa una subclase concreta: GregorianCalendar. día) . // cambiamos los campos YEAR. Los campos de un objeto calendario pueden ser manipulados usando 3 métodos: set() // cambiamos los campos YEAR.getInstance(). Pag. DAY(día). Subclases de la clase calendario interpretan una fecha de acuerdo con las reglas específicas de un calendario determinado.YEAR. 609 . mes. // cambiamos el valor del campo YEAR del calendario cal // al valor guardado en año cal.Calendar Calendar es una clase base abstracta para conversiones entre un objeto Date y una gama de enteros como YEAR(año). MONTH(mes). Futuras subclases podrían representar los diferentes tipos de calendarios lunares en muchos sitios del mundo. hora.util. HOUR y MINUTE // del calendario cal a los valores dados en año. día.Object java.año) . mes y día. Para inicializar un objeto Calendar con los valores de fecha y horas actuales utilizaremos el método getInstance( ): Calendar cal = Calendar.set (año.set (cal. mes. cal. minuto) . HOUR(hora). MONTH y DATE del calendario cal // a los valores dados en año.set (año.APÉNDICE Clase Calendar java. y así sucesivamente.lang. MONTH . mes. etc….

HOUR. 610 static int .add(cal. Esto es equivalente a hacer set (f. get(f) + cambio) // agrega cambio al valor del campo campo del calendario cal cal. cal. esto es.APÉNDICE add() // agrega cambio al campo f.. 1) //aumenta el mes actual en 1 roll() // roll (f.roll(cal. la nueva hora sería 3:10 a // diferencia del método add ( ) que nos daría 4:10. la nueva hora sería 3:10 a diferencia del // método add ( ) que nos daría 4:10.MONTH. // si aumentamos por ejemplo 40 minutos a la hora 3:30. cambio) agrega cambio al campo f sin variar campos superiores. 40) // si la hora actual fuera 3:30. Sumario de campos static int static int static int static int static int static int static int static int static int AM Constante que representa el campo AM AM_PM Constante que representa el campo AM_PM DATE Constante que representa la fecha del calendario actual (día) DAY_OF_MONTH Constante que representa el campo Día del mes DAY_OF_WEEK Constante que representa el campo Día de la semana DAY_OF_WEEK_IN_MONTH Constante que representa el campo Día del mes DAY_OF_YEAR Constante que representa el campo Día del año ERA Constante que representa el campo AC/DC FIELD_COUNT Indica el número de campos que pueden ser usados por la instrucción get o set HOUR Constante que representa el campo hora Pag.

APÉNDICE

static int static int static int

HOUR_OF_DAY Constante que representa el campo Hora del día JANUARY , FEBRUARY, MARCH , etc… Constantes que representan a los meses que corresponden del año. MILLISECOND Constante que representa el campo que indica los milisegundos de la hora actual MINUTE Constante que representa el campo que indica los minutos de la hora actual. MONDAY, TUESDAY, WEDNESDAY, etc… Constantes que representan a los días que corresponden de la semana. MONTH Constante que representa el campo que indica el mes actual PM SECOND Constante que representa el campo Indica o establece los segundo de la hora actual UNDECIMBER indica el 13o mes del mes WEEK_OF_MONTH Constante que representa el campo Semana del mes WEEK_OF_YEAR Constante que representa el campo Semana del año YEAR Constante que representa el campo Año

static int static int static int static int static int

static int static int static int static int

Estas constantes nos sirven para especificar en los métodos, que se detallan a continuación, cuales son los campos que queremos manipular, por ejemplo, si queremos agregar un minuto al calendario actual debemos utilizar el método add, este método tiene como parámetros: int Campo, int Cantidad ; Entonces para agregar un minuto debemos especificarle al método que queremos manipular el campo minuto y la cantidad que queremos agregar al valor almacenado en este campo (supongamos ya definido un Calendar cal): cal.add (cal.MINUTE,1) ;

Pag. 611

APÉNDICE

Sumario de métodos
abstract void boolean add(int Campo, int Cantidad) Date Arithmetic function. after(Object cuando) Compara los tiempos, si la fecha actual de nuestro calendario es superior a cuando, retorna verdadero before(Object cuando) Compara los tiempos,, si la fecha actual de nuestro calendario es inferior a cuando, retorna verdadero clear() limpia los valores de todos los campos del calendario clear(int campo) Limpia el valor del campo indicado equals(Object objeto) Compara este calendario con el objeto dado, y si son iguales retorna verdadero. get(int campo) Obtiene el valor almacenado en el campo dado. getActualMaximum(int campo) Retorna el valor máximo que puede obtener este campo con la fecha del calendario actual. Por ejemplo, si campo=Calendar.DAY_OF_MONTH y el mes actual es Abril, entonces el valor retornado será 30 (el máximo valor getActualMinimum(int campo) Retorna el valor mínimo que puede obtener este campo con la fecha del calendario actual. getFirstDayOfWeek() Obtiene el primer día de la semana. Por ejemplo SUNDAY (0) getInstance() Obtiene un calendario utilizando la zona actual y las reglas dadas getInstance(TimeZone zona) Obtiene un calendario utilizando zona y las reglas dadas getTime() Obtiene la hora actual del calendario. getTimeInMillis() Obtiene la hora actual del calendario en milisegundos getTimeZone() Obtiene la zona horaria. isSet(int campo) Pag. 612

boolean

void void boolean

int int

int

int static Calendar static Calendar Date long TimeZone

boolean

APÉNDICE

Determina si el campo dado tiene un valor almacenado. abstract void void void roll(int field, boolean up) Time Field Rolling function. roll(int field, int amount) set(int field, int value) setFirstDayOfWeek(int value) Establece cual es primer día de la semana para el calendario actual. Ej MONDAY setTime(Date fecha) Establece la hora del calendario actual a fecha setTimeInMillis(long milisegundos) Establece la hora del calendario actual utilizando los milisegundos dados setTimeZone(TimeZone value) Sets the time zone with the given time zone value. toString() Retorna una representación de cadena del calendario actual

void void

void String

Pag. 613

APÉNDICE

Ejemplo:

Pag. 614

APÉNDICE

Pag. 615

APÉNDICE

Pag. 616

APÉNDICE

Clase GregorianCalendar
java.lang.Object java.util.Calendar java.util.GregorianCalendar

GregorianCalendar es una subclase concreta de la Clase Calendar y provee el calendario Standard usado por la mayoría del mundo. ¿Qué es el Calendario Gregoriano? El calendario Gregoriano surgirá de la reforma que el papa Gregorio XIII (1502-1585) ordenó hacer para compensar las desviaciones del calendario juliano (pierde un día cada 128 años, y por lo tanto cada año se hacía más notorio que la fecha de la Pascua de Resurrección se atrasaba con respecto al equinoccio) y hacer coincidir el año civil con el año trópico. La tarea recayó en una comisión, que dirigida por Cristóbal Clavio que basándose en los cálculos Luigi Lilio (el auténtico artífice de la reforma), presentó el nuevo calendario al papa. Los cálculos supusieron un día medio de 24 horas y un año medio de 365 días, 5 horas, 49 minutos y 20 segundos (26 segundos más que el año real). Para ello se alternarían años de 365 días, años de 366 días. El calendario gregoriano intercala un año bisiesto cada cuatro años, pero no cuenta como bisiestos los años seculares (los que terminan en doble cero: 1800, 1900, 2000), excepto cuando las dos primeras cifras son múltiplo de 4, como el 2000. Esta excepción se produce porque con los cálculos de Luigi Lilio se produce un error de un día 134 años, o lo que es lo mismo 3 días cada 402 años. Había, pues, que suprimir tres días cada 402 años. Como esta cifra está relativamente cerca de 400 se acordó que no fuesen bisiestos los años terminados en doble cero (100, 200 y 300) pero sí el 400 y sus múltiplos. De esta manera se produce un error de sólo un día cada 3323 años. No obstante, si se suprimiese un año bisiesto cada 128 años, el error acumulado sería menor a un día cada 100.000 años. El calendario se adoptó en 1582 y como en los 1.257 años de vigencia del calendario juliano se habían acumulado 10 días de retraso, se estableció que el día siguiente al 4 de octubre de 1582 fuese el 15 de octubre de 1582. El año comienza el 1 de enero. El calendario gregoriano consta de doce meses: enero (31 días), febrero (28 ó 29), marzo (31), abril (30), mayo (31), junio (30), julio (31), agosto (31), septiembre (30), octubre (31),

Pag. 617

APÉNDICE

noviembre (30) y diciembre (31); y de una semana de siete días: lunes, martes, miércoles, jueves, viernes, sábado y domingo; que es independiente del mes. Para el cómputo eclesiástico el primer día de la semana es el domingo. Los días del mes se numeran correlativamente. El Calendario gregoriano Standard tiene 2 eras: AC y DC. Realmente para trabajar con fechas en Java que puedan encontrarse entre ambos calendarios lo recomendable es rescribir todo el proceso y operaciones necesarias a mano, pero si las fechas van a estar dentro del calendario gregoriano, lo mejor es usar la clase GregorianCalendar que trae un buen montón de métodos para operar con fechas en Java.

Ejemplo:

Pag. 618

APÉNDICE

Pag. 619

APÉNDICE

Pag. 620

APÉNDICE

Clase SimpleDateFormat
java.lang.Object java.text.Format java.text.DateFormat

Esta clase se utiliza para presentar las fechas como cadenas de texto con formato de acuerdo a un patrón establecido. Los patrones que se utilizan son: Letra Significado G Era y Año M Mes del año w Semana del año W Semana del mes D Día del año d Día del mes F Día de la semana en el mes E Día de la semana a AM/PM H Hora del día (0-23) k Hora del día (1-24) K Hora en AM/PM (0-11) h Hora en AM/PM (1-12) m Minuto de la hora s Segundo del minuto S Milisegundo z Zona horaria Z Zona horaria Ejemplos AD 1996; 96 Julio; Jul; 07 27 2 189 10 2 Jueves; Jue PM 0 24 0 12 30 55 978 GMT -5:00 -0500

Pag. 621

APÉNDICE

Los pasos a seguir son: 1.- Creación del formateador: SimpleDateFormat s=new SimpleDateFormat("EEEEE,dd 'de' MMMM 'del' yyyy G zz");

2.- Aplicar el formato a una fecha y asignarlo a una cadena: //asumimos que se tiene un onjeto calendar previamente creado e inicializado String Cad=s.format(calendar.getTime()) ; System.out.println(Cad) ; // jueves,20 de mayo del 2004 AD GMT-05:00

Pag. 622

623 .Pag.

Pag. 624 .

FIA . FIA . Manual de referencia. Patrick Naughton / Herbert Schildt. Metodología de la Programación. Algoritmos. Como Programar en Java. 625 .2003. Juan José Flores Cueto . 1ra Edición . Java. Jefferson López Goycochea. 1998. Osvaldo Cairó Battistutti. Deitel y Deitel. Método para la Solución de Problemas Utilizando la Programación Orientada A Objetos .BIBLIOGRAFÍA Introducción a las Tecnologías de Información. UML Gota a Gota.USMP. 1ra Edición . Pag. Diagrama de flujo y programas 2da Edición .2003.2004.Aspectos básicos.USMP. Martín Fowler / Kendall Scott. 1999.

Pag. 626 .

627 . Pag. enviándome un correo electrónico a la siguiente dirección: jflores@usmp.edu.pe De antemano. agradezco cualquier contribución que permita mejorar el material y contenido del presente libro.NOTAS FINALES Cualquier observación. sugerencia o recomendación relacionada al contenido del presente texto podrá realizarla.

Pag. 628 .

Sign up to vote on this title
UsefulNot useful