P. 1
MODELO DE LAS 6D´S

MODELO DE LAS 6D´S

3.0

|Views: 8.579|Likes:

More info:

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

Availability:

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

09/24/2014

pdf

text

original

Sections

  • INTRODUCCIÓN
  • MÉTODO DE LAS 6’D
  • ETAPAS Y PASOS
  • MARCO DE TRABAJO
  • MODELAMIENTO
  • ALGORITMO
  • PROGRAMACIÓN
  • VARIABLES
  • TIPOS DE DATOS
  • CONVERSIÓN DE DATOS
  • 1. Estructura para la salida de información
  • 3. Estructura para operaciones aritméticas y de cálculo
  • 1. Estructuras lógicas de decisión simple
  • 2. Estructuras lógicas de decisión doble
  • Instrucciones de bifurcación:
  • Mapa de Estructuras Lógicas detallado:
  • MANEJO DE EXCEPCIONES
  • EL PAQUETE DEL LENGUAJE JAVA
  • Definición:
  • Tipos:
  • Ingreso de datos a un Arreglo
  • Manejo de datos de un Arreglo
  • FORMALIZACIÓN DE LA SOLUCIÓN UTILIZANDO EL MÉTODO DE LAS 6’D
  • Metodo que no devuelven valor y no reciben parámetros
  • Métodos que devuelven valor y no reciben parámetros
  • Métodos que no devuelven valor y reciben parámetros
  • Método constructor
  • OCULTAR ATRIBUTOS DE INSTANCIA
  • INGRESO DE DATOS A TRAVÉS DEL TECLADO
  • MÉTODO DE LAS 6’D: Etapas y pasos
  • OTROS CONCEPTOS
  • Problemas propuestos
  • Clase Lectura
  • BIBLIOGRAFÍA

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

.

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

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

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

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

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

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

.

.

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

.

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

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

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

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

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

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. UML). Descripción de la Etapa 03 – “Diseño de la Solución”: Etapa 03 Diseño de la Solución Definida la solución.Ing. 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. el cual es una herramienta usada para describir clases. relaciones y clases. Para el desarrollo de algoritmos se utiliza Pseudocódigos o Diagramas de Flujo (DF). Juan José Flores Cueto. A este tipo de prueba se le denomina “Prueba de escritorio”. METODO 6’D. objetos y sus relaciones. PASOS: Definir un nombre para el proyecto. Pag. Para el modelado de la solución del problema se utiliza el Lenguaje Unificado de Modelado (Unified Modeling Language. 30 . 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. Definición de diagramas.

PROGRAMAS El resultado obtenido en esta etapa son los programas y/o clases. METODO 6’D. y constituyen lo que la computadora podrá ejecutar. que permiten solucionar el problema. y los pasos del algoritmo de cada método (expresado en DF o pseudocódigo). 31 . Pag. en sentencias de un lenguaje de programación determinado. Estas sentencias son almacenadas en un proyecto (o archivo) lógico. codificados en un lenguaje de programación.MÉTODO DE LAS 6’D – Un Enfoque Algorítmico. Desarrollar copias de seguridad de los programas de computadora. se podrá proceder a la codificación del problema en algún lenguaje de programación. las especificaciones de las clases (expresadas en notación UML). La codificación involucra traducir los diagramas. Desarrollar comentarios internos en los programas de computadora. PASOS: Codificar el proyecto. 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.

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

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

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”. Es decir. Organizar el modelo obtenido en la herramienta CASE. Juan José Flores Cueto. METODO 6’D. Adicionalmente es posible realizar “Ingeniería Reversa” entre las Etapas 03.Ing. 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”. DIAGRAMAS ACTUALIZADOS Pag. 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. 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. 34 . si está trabajando con un IDE. Importar proyecto (archivos class o java) a una herramienta CASE y realizar la ingeniería reversa.

Determinar los datos que se deben ingresar o generar para obtener el resultado deseado. Definir un nombre para el proyecto. Desarrollar comentarios internos en programas computadora. 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. Recopilar el material generado en cada una de las etapas anteriores. Realizar la depuración y verificar la correcta escritura de los programas. Desarrollar copias seguridad de programas computadora. Descripción general del problema. 35 . Pag. Codificar proyecto. Enunciado claro y preciso del problema. Desarrollo de Algoritmos. relaciones y clases. Determinar la forma en que los datos serán procesados para transformarlos en información. Realizar pruebas de lógica. Generar el manual del usuario.MÉTODO DE LAS 6’D – Un Enfoque Algorítmico. los de de los de Definir el resultado deseado. Generar el manual del programa. Definición de diagramas. RESUMEN DEL MÉTODO METODO 6’D. Realizar pruebas de sintaxis. Descripción Problema Definición Solución el Identificación del problema.

Descripción Problema Definición Solución ENUNCIADO ESPECIFICACIONES DIAGRAMAS Y ALGORITMOS PROGRAMAS PRUEBAS Manuales Pag. 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 . Juan José Flores Cueto.Ing.

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

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

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

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. acerca de la cual almacenamos datos y los métodos que controlan y manipulan dichos datos. Un objeto se crea o instancia a partir de una clase.. Ambos nombres deben estar separados por dos puntos.Ing. real o abstracta. 40 . NombreClase (NombrePaquete al que pertenece) Atributos Métodos Objeto. representa a ningún objeto en particular. Lista de atributos de la clase. Lista de métodos de la clase.Un objeto es cualquier cosa. En UML. Juan José Flores Cueto. 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. En UML. una clase se representa de la siguiente forma: Nombre de la clase y del paquete al cual pertenece la clase. UML incorpora nueve diagramas que permiten representar un modelo desde diferentes perspectivas.

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

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

Pag. Regla general para especificar los nombres de los paquetes. 43 . todas las primeras letras de los nombres simples que forman el nombre de la clase o paquete deberán comenzar con mayúscula. clases. Si el nombre es compuesto. 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. se tendrá clase Lectura1 que facilitará el ingreso de los datos a la computadora. 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. a partir de la segunda palabra se escribe la primera letra en mayúscula.MÉTODO DE LAS 6’D – Un Enfoque Algorítmico. En caso que el nombre sea compuesto. En el paquete “biblioteca”. Los nombres de los atributos se escriben en minúscula.

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

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

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

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

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

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

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

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”.MÉTODO DE LAS 6’D – Un Enfoque Algorítmico. Permite obtener el número de filas de una matriz “n”. Ver capítulo III. 51 . El resultado se almacena en la variable “x”. El resultado se almacena en la variable “x”. Permite obtener la raíz “n” del número “z”. El resultado se almacena en la variable “x”. Ver capítulo III y capítulo IV. SENO x = SENO n Permite obtener el seno del valor almacenado en la variable “n”. Permite obtener la longitud de la cadena almacenada en la variable “n” o la longitud del vector “n”. El resultado se almacena en la variable “x”. 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”. Ver capítulo III. Permite cambiar a minúscula la cadena almacenada en la variable “n”. El resultado se almacena en la variable “x”. Permite cambiar a mayúscula la cadena almacenada en la variable “n”. El resultado se almacena en la variable “x”. DIVIDIR x = z DIVIDIR n Permite obtener la parte entera de la división de las variables “z” y “n”. Ver capítulo III. El resultado se almacena en la variable “x”. 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”. RAIZ x = z RAIZ n Pag. El resultado se almacena en la variable “x”.

El resultado se almacena en la variable “x”. El resultado se almacena en la variable “x”. Permite obtener un número cualquiera (aleatorio) entre los valores de “n” y “z”. Pag. 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”. El resultado se almacena en la variable “x”. Permite obtener el número menor entre el valor almacenado en la variable “n” y la variable “z”. GRUPO 6 Utilizada para crear arreglos previamente declarados. SUBCADENA x = z SUBCADENA n1.Ing. n2 ELIMINAESPACIO x = z ELIMINAESPACIO n1. El resultado se almacena en la variable “x”. 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”. REGLA POTENCIA FORMATO x = z POTENCIA n DESCRIPCIÓN Permite obtener la potencia “n” del número “z”. Juan José Flores Cueto. El resultado se almacena en la variable “x”. El resultado se almacena en la variable “x”. Permite obtener el carácter ubicado en la posición “n” de la cadena “z”. 52 . Un arreglo permite almacenar más de un dato del mismo tipo. Los arreglos serán tratados en el capítulo IV. n2 Permite eliminar los espacios existentes en una cadena entre las posiciones especificadas por “n1” y “n2”. Permite obtener el número mayor entre el valor almacenado en la variable “n” y la variable “z”.

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

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

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

Juan José Flores Cueto. 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”. 56 . para especificar que una clase tiene un “método principal”. se utiliza las siguientes sentencias: public static void main (String arg[]) Por lo tanto. en el lenguaje de programación Java. 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.Ing. No existe código que no esté contenido dentro de un método (a excepción de los bloques estáticos). es aquella que tiene un significado especial para un lenguaje de programación. Todas las clases que tienen especificado un “método principal”. En el lenguaje de programación Java. son clases que pueden ejecutarse. Palabras reservadas en Java: Una palabra reservada o palabra clave. el método principal es conocido como método main ( ). Todos los lenguajes tienen palabras claves. Todo el código ejecutable reside dentro de los métodos de la clase.

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

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

Estructuras de Datos: Variables • Tipos de datos. Método de las 6´D. 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. Estructuras lógicas de repetición. . Estructuras Lógicas: • • • • • Estructuras lógicas de secuencia. • Conversión de datos. Etapas y pasos. Mapa de estructuras lógicas detallado. Estructuras lógicas de decisión.

.

La acción de escribir un programa para computadoras se conoce como codificación. 61 . 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. 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 programación es la traducción del modelamiento y los algoritmos en sentencias que una computadora puede comprender y ejecutar. La lista completa de los pasos se desarrolla utilizando las estructuras lógicas y las instrucciones de bifurcació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.

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

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

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

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

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

etc. por lo que no está permitido que se usen como nombres de variables. luego las sumas y restas. Primero se resuelven las multiplicaciones y divisiones. Ejemplos: edad = 15 resultado = 5 + 8 * ( 6 – 2) Donde edad y resultado son variables que previamente han sido declaradas como variables de tipo numéricas. direcciones. Variables de texto: Permiten almacenar datos de tipo texto y datos de tipo caracter (TEXTO y CARACTER). Las variables tipo texto son útiles para almacenar cualquier cadena de texto. número de AFP. Existen sólo dos valores que se pueden almacenar en este tipo de variable: verdadero y falso. tales como nombres de personas. Pag. Las palabras VERDADERO y FALSO constituyen reglas en pseudocódigo y diagrama de flujo. Para alterar esta prioridad se podrá utilizar los paréntesis. 67 . Ejemplos: masculino = VERDADERO estudiante = FALSO Donde masculino y estudiante son variables que previamente han sido declaradas como variables de tipo lógico. Ejemplos: nombre = “Pedro” letra = ‘J’ Donde nombre y siglas son variables que previamente han sido declaradas como variables de tipo 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.

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

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

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

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. es decir entre datos de tipo byte. // La siguiente línea no genera error. 71 . 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.out. long.println ( numEnteroGrande ) . float y double Ejemplos. 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. esta también tiene su excepción. Clase PrgTipoDato04 package dominioDeLaAplicacion . float y double. mas grande) y son generadas automáticamente por el compilador Java. 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. int. class PrgTipoDato04 { public static void main ( String arg [ ] ) { int numEntero = 5 . long numEnteroGrande . numEnteroGrande = numEntero . short. Pag. short. } } 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).ESTRUCTURAS FUNDAMENTALES PARA LA SOLUCIÓN DE PROBLEMAS CONVERSIÓN DE DATOS Anteriormente se mencionó que por regla general en una variable solo se puede almacenar un solo valor y este valor debe ser del tipo de dato con el que la variable fue declarada. long. También se puede aplicar sobre el tipo de dato char. Esto es válido ya que el tipo de dato long en Java es de mayor precisión que el tipo de dato int. // Se visualiza 5 System. int. Pero como toda regla.

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

System. class PrgTipoDato07 { public static void main ( String arg [ ] ) { double num1 = 20.out.println ( div ) . num2 = 3 . Pag. // Se visualiza 6. div = num1 / num2 . // La siguiente línea genera error. // La siguiente línea no genera error. num2 = 3 . Clase PrgTipoDato06 package dominioDeLaAplicacion . int div . } } Clase PrgTipoDato07 package dominioDeLaAplicacion . int div .out. System.println ( div ) . en el capítulo III se tratán las clases Wrappers que envuelven los tipos de datos simples y también permiten realizar operaciones de conversión. class PrgTipoDato06 { public static void main ( String arg [ ] ) { double num1 = 20. 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. 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). Ejemplo. Finalmente. 73 .

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

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

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

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

Ing.. Estas instrucciones se ejecutarán una tras otra. -. *. Representación: Para representar las operaciones aritméticas se utilizan los mismos signos que se emplean en la aritmética tradicional (+.. 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 . /). 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. 78 . Pag. FIN EXPLICACIÓN: Todas las instrucciones que son parte de la solución del problema deberán aparecer entre las reglas INICIO y FIN. Juan José Flores Cueto. 3.

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

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

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

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

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

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

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.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. Pag. se ejecutan las instrucciones que están seguidas del flujo (las que indica la flecha). 85 .

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

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

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

Ambas reglas se encuentran dentro del símbolo que representa la regla o pauta DESDE.. la cual se muestra a continuación: El fin de las instrucciones o bloque de instrucciones que forman parte de la regla DESDE. Pag...ESTRUCTURAS FUNDAMENTALES PARA LA SOLUCIÓN DE PROBLEMAS Diagrama de Flujo DESDE i HASTA z INCREMENTA x FALSO VERDADERO . se representa por el siguiente símbolo: Este último símbolo es equivalente a la regla FINDESDE utilizada en pseudocódigo.. . 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. 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. 89 ... instrucciones.

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

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

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

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

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

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

se finaliza la ejecución. EXPLICACIÓN: En Java. se vuelve a ejecutar las sentencias o bloque de sentencias que pertenecen a la estructura de repetición. 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 . para verificar si se vuelve a ejecuta la estructura o no. Si la condición es verdadera. en el caso que sea falso.Ing. Pag. se utiliza una condición lógica (ejemplo: i >10) al final de la estructura. Juan José Flores Cueto. En la sentencia do. Esta condición lógica constituye la prueba en Java. continuando con la siguiente sentencia. al igual que en pseudocódigo y diagrama de flujo.

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

se pueden desarrollar algoritmos de tal forma que estos puedan ser diseñados en pseudocódigo o diagrama de flujo. Estructuras Lógicas de Repetición.Ing. Instrucciones de Bifurcación. Estructuras Lógicas de Decisión. 98 . Estructuras Lógicas de Secuencia. Mapa de Estructuras Lógicas detallado: Utilizando las estructuras lógicas fundamentales y las instrucciones de bifurcación. “LEER” “ESCRIBIR” “PROCESAR” “SI” “SI / SINO” “CUANDO” “DESDE” “MIENTRAS” “HACER” “TERMINAR” “CONTINUAR” “RETORNAR” Pag. 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.

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

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

Etapa 03 .ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS Problema 01 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. 1. Nombre del Proyecto: ProyMensaje 2. Resultado deseado: Datos necesarios: Procesamiento: Mostrar mensaje “Hola bienvenidos”.Diseño de la lógica. 101 . Paquete y clase DominioDeLaAplicacion PrgMensaje main() Pag. Definición de Paquete y Clase. Ninguno. El mensaje a mostrar será “Hola bienvenidos”. Desarrollar un proyecto que permita mostrar un mensaje por la pantalla.Descripción del problema. El mensaje será almacenado en una variable (mensaje) y posteriormente mostrado. Etapa 02 – Definición de la solución.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Para evitar que la ejecución de un programa se detenga debido a un error que lanza una excepción. Ahora. no ocurren). si se desea que la ejecución del programa no se detenga. por ejemplo. Existen diversos errores que pueden ocasionar que se lance una excepción en un programa. 195 . se debe utilizar la sentencia try para alertar al programa acerca del código que puede ocasionar un error. 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”. se deberá capturar la excepción lanzada y manejarla. … … … … … } catch ( ) { // Código de tratamiento de la 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. una entrada incorrecta de datos (IOException). 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.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. Pag. una división por cero (ArithmeticException) o una conversión de datos no válida (NumberFormatException). Las excepciones en Java son objetos de subclases de la clase Throwable.

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

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

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

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

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

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

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

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

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

205 . ingrese letras en lugar de números (inclusive en el lugar de las // ). en cualquier parte del formato indicado. } } 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.ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS Clase PrgNumeroConExcepcion } catch ( NumberFormatException error ) { System. } if ( valido ) { System..out..out. Ingrese en el formato indicado!!! ” ) . 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. 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. valido = false .println ( “ Formato no válido ” ) . valido = true . Puede probar el programa ingresando como números lo siguiente: aaa//123 Es decir.println ( “ No se puede dividir un número entre cero ” ) . } } else { valido = true . } catch ( ArithmeticException error ) { System.out.println ( “ Error. } } while ( valido ) . Pag.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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. ” ) . Etapa 04 – Desarrollo de la codificación.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. j <= i . Clase PrgTriangulo06 package dominioDeLaAplicacion. i = 0. j++ ) { if ( k == totalFilas) { k=1. } else { k ++ .leerInt ( ) . for ( i = 1 . import biblioteca. 221 . } } } Pag.out.ESTRUCTURAS FUNDAMENTALES PARA LA SOLUCIÓN DE PROBLEMAS Problema 40 Etapa 01 – Descripción del problema. } System. } } while (totalFilas < 2 || totalFilas > 9 ) .println ( “ Ingresar el número de filas de la figura ” ) . } System. totalFilas = Lectura. i <= totalFilas. i++ ) { for ( j = 1 .println ( “ Valor de fila no válido… Reintente!. j = 0. public class PrgTriangulo06 { public static void main(String[] args) { int totalFilas = 0. do { System.*. System.println ( ) .print ( k ) . if (totalFilas < 2 || totalFilas > 9 ) { System.out. k=0 .out.print ( “ Valores válidos desde 2 hasta 9: ” ) .out.

} System.Ing.leerInt ( ) . Juan José Flores Cueto.*. for ( i = 1 . i++ ) { for ( j = 1 . j++ ) { if ( k == 9 ) { k=0. } else { k ++ . totalFilas = Lectura. ” ) .out. j <= i . } } } Pag.out.println ( ) . } } while (totalFilas < 2 || totalFilas > 20 ) . j = 0 . Problema 41 Etapa 01 – Descripción del problema.out.print ( “ Valores válidos desde 2 hasta 20: ” ) . Etapa 04 – Desarrollo de la codificación.println ( “ Valor de fila no válido… Reintente!.println ( “ Ingresar el número de filas de la figura ” ) . } System. 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. System.print ( k ) . i <= totalFilas.out. 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.out. public class PrgTriangulo07 { public static void main(String[] args) { int totalFilas = 0. if (totalFilas < 2 || totalFilas > 20 ) { System. Clase PrgTriangulo07 package dominioDeLaAplicacion. i = 0. 222 . import biblioteca.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

println ( ) . } if ( i < num ) cont ++ .. System. 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. System. Con la finalidad de mejorar sus capacidades lógicas sugiero que desarrolle todas las variaciones posibles o que se pueda imaginar del presente problema. j ++ ) { if ( j >= num .. j ++ . i ++ ) { n = cont + 1 . i <= diagonal .print ( n + “ ” ) . System. Pag. for ( i = 1 . Analice cada una de las soluciones en forma detallada.Ing. 238 .cont && j <= num + cont ) { // Se muestra el contenido de la variable n y un espacio en blanco.print ( “ ” ) . else cont . } } } Modifique está solución utilizando la estructura de repetición while en lugar de la estructura for. j <= diagonal . } else // Se muestra un espacio en blanco. Juan José Flores Cueto. for ( j = 1 .out.out.out. Tenga en cuenta que se han cambiado los nombres de las variables utilizadas en las soluciones anteriores.

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

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

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

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

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

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

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

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

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

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

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

261 . Un paquete permiten organizar las clases. 2 Paquete: Conjunto de clases similares.lang. agrupadas en el paquete 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). construyendo fácilmente aplicaciones profesionales. Es importante mencionar que utilizando las clases preprogramadas de Java se puede ahorrar mucho tiempo y esfuerzo de programación. Un paquete contiene clases que tienen funciones similares. Clase: Colección de objetos del mismo tipo. Una clase es una implantación de un “tipo de objeto”. Una clase es una abstracción y no referencia a ningún objeto en particular.CLASES BÁSICAS INCORPORADAS EN EL LENGUAJE DE PROGRAMACIÓN JAVA El presente capítulo. El mundo real se modela mediante clases. 2 1 Pag. trata sobre las clases básicas incorporadas en el lenguaje de 1 programación Java.

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

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

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

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

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

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

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

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. 269 . se utilizarán algunos objetos de dichas clases. Se asume que los objetos han sido creados previamente. 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. Pag. para referirnos a las variables se utilizará una letra minúscula. mientras que. 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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Pag. 315 . 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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

cad1 = "Hola". String cad2 = “Danae”. cadena = cad1. boolean x = cad1. 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. el método devuelve un número entero menor que cero. concat(String) Este método permite juntar dos cadenas en una sola cadena. Caso contrario devuelve false (falso). String cad2 = “Hola Pedro”. compareTo(String) Si la cadena es alfabéticamente menor que la cadena colocada como parámetro. String cad1 = “Hola Danae”.endsWith(cad2). String cad2 = “Danae”. resultado: x = ‘D’. Resultado: x < 0 (cad1<cad2).equalsIgnoreCase(cad2). el método devuelve un entero mayor que cero. boolean x. x = cad1. cad2.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. boolean x = cad1. String cad1 = “Hola Danae”. char x = cad1. 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. Es importante mencionar que en Java. cad2 = " a todos". Pag. String cad1. cadena.compareTo(cad2). Caso contrario devuelve false (falso).charAt(5). String cad1 = “DANAE”. 341 . int x = cad1. Resultado: x = true.concat (cad2). el primer caracter de una cadena se encuentra ubicado en la posición 0 (cero). String cad2 = “Danae”. Resultado : cadena = "Hola a todos” endsWith(String) Devuelve true (verdadero) si el final de la cadena coincide con la cadena colocada como parámetro. Resultado: x = true. String cad1 = “Danae”. Resultado: equals(String) Devuelve true (verdadero) si la cadena coincide con la cadena colocada como parámetro.equals(cad2).

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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 = “Dan” Segunda evaluación: cad2 = “ana” y subcad = “ana” Resultado: verdadero (cont =1). 369 .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. Pag. subcad = “nae” Finalmente. se concluye que cad2 se repite una vez en cad1. Primera evaluación: cad2 = “ana” y Resultado: falso.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

de tal forma que sea mayor a cero. se utiliza una sentencia do para ingresar el nombre de cada uno de los productos y determinar sus posiciones pares. Juan José Flores Cueto.Ing. Luego. se valida el número de alumnos ingresado. Pag. 390 . 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. y la forma como se utilizan las estructuras lógicas para la solución del problema. Observe el uso de los métodos length ( ) y substring ( ) de la clase String.

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

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

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

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

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

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

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

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

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

.

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

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

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

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

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

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

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

mientras que para declarar un arreglo bidimensional se utilizan dos corchetes de apertura y cierre “[ ][ ]” al final del nombre del arreglo. En segundo lugar. 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 se utiliza el siguiente formato: En pseudocódigo y diagrama de flujo: TipoDeDato arreglo[ ] TipoDeDato arreglo[ ][ ] En Java: TipoDeDato arreglo[ ] . 408 . En general. definir un nombre para referirnos al arreglo. 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.Ing. Juan José Flores Cueto. los cuales serán separados por comas). Para declarar un arreglo unidimensional se utiliza solo un corchete de apertura y cierre “[ ]” al final del nombre del arreglo. Pag. se debe determinar que tipo de dato podrá almacenar un arreglo. 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. Los tipos de datos válidos para declarar un arreglo son los mismos tipos de datos válidos definidos para declarar variables y constantes. en primer lugar. Un arreglo solo puede almacenar datos del mismo tipo. TipoDeDato arreglo[ ][ ] .

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

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

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

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

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

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

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

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

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

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

// Creación del arreglo notas.ESTRUCTURAS DE DATOS – Arreglos. de tal forma que se incorporen progresivamente los conceptos tratados en este capítulo.* . o en su defecto. Una vez almacenadas las notas finales de los 10 alumnos se calculará y mostrará el promedio de las mismas. import biblioteca. notas[ ] . A partir de este punto podemos realizar cualquier proceso con los datos almacenados en el arreglo o arreglos definidos en la solución. Estos tres pasos generalmente se desarrollarán en todas las soluciones. 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. A partir de este punto. definiendo un nombre adecuado para cada uno de ellos. 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. notas = new double [numAlu] . 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. Inicializar el arreglo o arreglos. 419 . En la solución. Clase PrgAlumnos package dominioDeLaAplicacion . 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. se modificará el programa anterior. double sumaNotas=0. Pag. Por lo tanto. int numAlu =10 . para finalmente formalizar el Método de las 6’D. ingresar los datos necesarios al arreglo o arreglos utilizados en la solución.

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

Finalizada la ejecución de la sentencia for se muestra el promedio de las 10 notas finales. 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. se ejecuta el proceso de cálculo del promedio de las 10 notas finales. Para ello. 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. Finalizada la ejecución de la primera sentencia for. 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). se utiliza una segunda sentencia for exactamente igual a la primera sentencia for.ESTRUCTURAS DE DATOS – Arreglos. el arreglo notas[ ] deberá tener almacenadas las notas finales de los 10 alumnos del salón de clase. 421 . Pag.

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

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

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

Resultado deseado: Mostrar el promedio de las notas finales de los alumnos de un determinado salón de clase.Definición de la solución.ESTRUCTURAS DE DATOS – Arreglos.Descripción del problema. 425 . se realiza la suma de todas las notas finales y el resultado se almacena en una variable acumulador (sumaNotas). El número de alumnos se ingresa a través del teclado y se almacena en una variable (numAlu). Consistenciar el ingreso de datos. El número de alumnos y las notas finales de cada uno de ellos. Desarrollar una solución que permita ingresar y almacenar las notas finales de todos los alumnos de un determinado salón de clase. Con el número de alumnos ingresado se crea un arreglo (notas[ ]). se almacena el resultado en una variable (prom) y se muestra por pantalla. 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 . Determinar y mostrar el promedio de las notas finales. Etapa 02 . Finalmente. Datos necesarios: Procesamiento: Pag. se realiza el cálculo del promedio. Después.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

.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.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. Diseño de algoritmo para el método principal. Juan José Flores Cueto. Continúa… 4.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 . 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 . 446 . Algoritmo PrgAlumnos05.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 .

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Juan José Flores Cueto.. 504 . Algoritmo PrgSocios01 .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. Continúa… 4.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 ..Ing.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Pag. 541 . 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.

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

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

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

• objAlumno03. objAlumno03. nota2 = 14 y nota3 = 15 ). 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. El operador punto relaciona el nombre del objeto con el nombre de un método.promedio ( ) . cuando se ejecuta. 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. Analicemos la siguiente sentencia. Pag. Así. 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. • objAlumno02. 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. se ejecuta el método promedio( ) utilizando el nombre de un objeto de la clase Alumno seguido por el operador punto. objAlumno02. • objAlumno. ubicadas dentro del método main( ) de la clase PrgAlumno. para acceder a los métodos se utiliza el operador punto (.promedio ( ) . Al igual que para acceder a las variables de instancia.promedio ( ) . 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. nota2 = 11 y nota3 = 11 ). objAlumno. Es decir.).promedio ( ) .promedio ( ) . nota2 = 19 y nota3 = 11 ). 545 . permiten ejecutar el método promedio( ) definido en la clase Alumno: objAlumno.promedio ( ) .

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

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

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

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

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

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

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

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

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

555 . Pag. nota2 y nota3 del objeto creado y eliminar el método setNotas( ). El método constructor Alumno( ) permite inicializar la copia de los atributos de instancia nota1. Se declara y crea el objeto objAlumno de la clase Alumno. Después que se crea el objeto objAlumno se ejecuta en forma automática al método constructor Alumno( ). En ese caso. Para nuestro caso. El método constructor puede tener definido parámetros. nota2 y nota3 del objeto objAlumno con el valor cero. dicho método es setNotas( ) ). no se eliminará el método setNotas( ). El método constructor Alumno( ) se encargará de inicializar con el valor cero.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. Aunque esto es posible y perfectamente válido. (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. a todas las copias de los atributos de instancia de los objetos que se creen. 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. podemos enviar al método constructor Alumno( ).

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

} } Ahora.nota2 = nota2 . nota2 = 0 . se utilizan los mismos nombres para las variables locales (declarados como parámetros) y para los atributos de instancia.nombreAtributoInstancia . double nota3 ) { this. Nos referimos a la variable local nota1. en el método setNotas( ).) Nos referimos al atributo de instancia nota1. } double promedio ( ) { return ( nota1 + nota2 + nota3 ) / 3 . this.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 (. this. Pag.) y el nombre del atributo. } void setNotas ( double nota1.nota1 = nota1. Analizar la variación en la codificación de la clase Alumno: package dominioDeLaAplicacion . nota2. 557 .nota3 = nota3 . Al momento de referirnos a los atributos de instancia anteponemos al nombre del mismo el operador this y el operador punto (.nota1 = nota1 . Forma general del operador this: this. nota3 = 0 . Alumno ( ) { nota1 = 0 . nota3 . class Alumno { double nota1. double nota2. Cuando se utiliza el operador this se indica que se está refiriendo al atributo de instancia y no a una variable local. This.

Juan José Flores Cueto. A partir de ahora.Ing. Algunos programadores procurar no utilizar variables locales que oculten los atributos instancia. 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. 558 . se utilizará el operador this como una buena práctica programación. de los de de Pag. Por otro lado.

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

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

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

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

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

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

Diagrama de paquetes dominioDeLaAplicacion biblioteca Diseño de las clases.INTRODUCCIÓN AL DESARROLLO DE SOLUCIONES ORIENTADAS A OBJETOS Etapa 03 – Diseño de la lógica. Clases de dominioDeLaAplicacion PrgAlumno nota1 : double nota2 : double nota3 : double main( ) Alumno( ) setNotas(double.n3 ) prom = EJECUTAR objAlumno.promedio ( ) ESCRIBIR prom FIN Pag. n3. n2. n2. prom CREAR OBJETO objAlumno CLASE Alumno EJECUTAR Alumno ( ) LEER n1. double. n3 EJECUTAR objAlumno. 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 .setNotas ( n1. Algoritmo PrgAlumno METODO MAIN( ) ENTRADA: SALIDA: n1. Diseño del Diagrama de Paquetes.n2. n2. n3 prom INICIO NUMERO n1.

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. 566 . nota2. 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. Pag. nota3 METODO CONSTRUCTOR PARAMETRO: INICIO nota1 = 0 nota2 = 0 nota3 = 0 FIN METODO SETNOTAS PARAMETRO: RETORNO: nota1.nota2 = nota2 ATRIBUTO.nota1 = nota1 ATRIBUTO.Ing. 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. Juan José Flores Cueto. Algoritmo Alumno ATRIBUTOS NUMERO nota1. nota3 INICIO ATRIBUTO.

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

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

Servlets. Encapsulamieno. Pag.INTRODUCCIÓN AL DESARROLLO DE SOLUCIONES ORIENTADAS A OBJETOS OTROS CONCEPTOS Finalmente. Conexiones a BD. Dichos conceptos avanzados permitirán elaborar soluciones robustas y profesionales. 569 . Herencia. que deberá continuar investigando otros conceptos importantes de la Programación Orientada a Objetos. es importante mencionar. Interfaces Gráficas. entre otros. 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. Polimorfismo. tales como.

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

APÉNDICE .

.

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

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

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

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

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

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

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

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

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

Considerar que se venden 4 tipos de sándwich. según los datos de la tabla.00 S/. 6. 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. Tipo Moderado Mediano Extra Grande Full Costo S/.APÉNDICE 4 5% 61. 582 . Desarrollar una solución que permita calcular y mostrar el monto total a pagar por un sándwich. de acuerdo a la siguiente tabla. sabiendo que. debe considerar que los pacientes menores de 18 años implican un costo adicional de 25 %. adicionalmente.00 S/. según los datos de la 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. Enfermedad Tipo 1 2 Costo diario 180 420 Pag.00 S/. 4. Adicionalmente.00 62. Enfermedad Tipo 1 2 3 Costo diario 120 380 620 63. 3. hay que pagar el 6% por el servicio y 7% por propinas. Adicionalmente. 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. 2.

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. 583 . según los datos de la tabla. 65. Mayores de 14. Considerar la siguiente tabla: Edad 18 -más 11 -17 0 –10 Categoría Contenido para adultos. considerando que la nota mínima aprobatoria es 12 (doce). de acuerdo a la fórmula empleada por su profesor. Enfermedad Tipo 1 2 3 4 Costo diario 122 234 345 587 66. 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. Apta para todos. 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. Adicionalmente. Calcular su nota final (nf). Código Profesor 1 2 3 Fórmula nf = (n1 + n2 ) / 2 nf = (n1 + n2*2) / 3 nf = (n1*2 + n2) / 3 Pag. Mostrar la nota final (nf) del alumno y si está aprobado o no.APÉNDICE 3 513 64. debe considerar que los pacientes de sexo femenino menores de 14 años implican un costo adicional de 8%.

Considerar que la categorización de los postulantes se realiza en función de su sexo y edad. 584 . Finalmente.APÉNDICE 67. Desarrollar una solución que permita determinar la categoría de cada postulante. determinar la categoría obtenida por un alumno. Si la persona es de sexo masculino: Categoría MA si tiene menos de 40 años. Desarrollar una solución que permita ingresar las ‘n’ notas de un alumno. de acuerdo a lo siguiente: Si la persona es de sexo femenino: Categoría FA si tienen menos de 30 años. Categoría FB en caso contrario. 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 determinar la categoría de cada alumno. 68. Calcular el promedio del alumno sabiendo que se elimina la nota mas baja. Categoría MB en caso contrario. 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. considerando que la categoría del alumno está en función de su promedio.

externo) y el nivel del curso (básico. alumno. Si el área es menor que 100. Desarrollar una solución que permita ingresar el nombre del alumno. 585 . 71. 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”. el tipo de participante (profesor.APÉNDICE 70. si el área es mayor o igual a 100 y menor que 1000. Desarrollar una solución que permita ingresar el sueldo de un trabajador. se deberá visualizar el mensaje “rectángulo pequeño”. avanzado). 72. se visualizará el mensaje “rectángulo mediano”. Desarrollar una solución que permita calcular el área de un rectángulo conociendo su base y altura. el mensaje será “rectángulo grande”. 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. 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. Desarrollar una solución que permita calcular el área de un rectángulo conociendo su base y altura. 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. y si el área es mayor o igual que 1000. intermedio.

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”. 77. Se deberá mostrar: 12 de Mayo del 2005. Desarrollar una solución que permita ingresar un número de 3 cifras. Pag. Desarrollar una solución que permita ingresar un número de 2 cifras. 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. 76. Desarrollar una solución que permita ingresar una fecha en el siguiente formato: (dd/mm/aaaa). 78. 586 . Ejemplo: Ingreso 12/05/2005. Calcular el número de días que tiene el mes y si el año ingresado es bisiesto o no. Desarrollar una solución que permita calcular el factorial de un número entero positivo.APÉNDICE Condición Sueldo < 2000 2000 < =Sueldo < =3000 Sueldo > 3000 Aumento 23 % 17 % 12 % 74. 79. Mostrar el equivalente del número ingresado en letras. Mostrar el equivalente del número ingresado en letras.

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

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

Desarrollar un programa que permita leer una cadena. 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. Se ingresa la cadena “Danae”. Tal y como se muestra a continuación: Ejemplo. Mostrar la cadena ingresada en forma triangular. 589 . Mostrar la cadena ingresada en forma triangular. Tal y como se muestra a continuación: Ejemplo. DANAE DANA DAN Pag. Desarrollar un programa que permita leer una cadena. Se ingresa la cadena “Danae”. D DA DAN DANA DANAE 100.APÉNDICE * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 98.

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

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

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

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

500. 500. 594 .200. deberá indicar el porcentaje de alumnos aprobados.00 (incluidos S/. Ingresar la cantidad de alumnos y las 3 notas de cada alumno. 2. 122.A. 2. 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. Desarrollar una solución que permita ingresar los nombres y las edades de ‘n’ alumnos. Ingresar el nombre. el precio de venta y la utilidad de cada artículo. Determinar la suma de las edades. y cuantos tienen un salario mayor a S/. Adicionalmente.00. el articulo más caro y el más barato. entre S/.200.”. Adicionalmente. 121. 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. Desarrollar una solución para el siguiente problema.00 y S/.00 y S/. Enfermedad Tipo 1 2 3 Costo diario 100 150 300 Pag. 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).00). En la fabrica “LA CLONACION S. 123. 2. deberá considerar que los pacientes menores de 18 años implican un costo adicional de 35% y las mujeres un costo adicional de 12%. desaprobados. Adicionalmente. 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).200. según los datos de la tabla. 124.00. 500.APÉNDICE 120. Trabajan miles de obreros y se desea determinar cuantos tienen un salario menor a S/. la nota final más baja y más alta.

Desarrollar una solución para el siguiente problema. normal y especializado). (Ingresar solo los siguientes datos: Número de sala y el horario al cuál el cliente ingresa). Desarrollar una solución para el siguiente problema. y asuma que cada empresa desarrolla 3 tipos de diario: popular. Ingresar el tipo de diario vendido y la empresa a la cuál pertenece. El cine “Pantalla Láser” cuenta con 3 salas y atiende en horarios de matinée. Ingresar el producto vendido y la empresa que lo fabricó. 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. quien ganó el premio al mejor canillita 1999 otorgado por un diario de la capital. Pag. (considere solo tres empresas periodísticas. 129. 595 . Desarrollar una solución que permita determinar cuántos tipos de periódicos de cada empresa fue vendido por José Luis Candado.APÉNDICE 4 450 125. ¿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. la cantidad existente y el almacén donde están ubicados). 128. 127. Una empresa cuenta con cuatro almacenes de productos. su precio de venta. Deberá ingresar el tipo de hamburguesa y el local en el que fue vendida. 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”. 126. 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. caramelo y gaseosa). vermouth y noche.

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

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

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

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

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

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

APÉNDICE Pag. 602 .

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

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

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

E . y el separador decimal. % \u2030 Digito Digito. 606 . Si queremos dar formato a monedas: formato = NumberFormat.APÉNDICE Si queremos dar formato a números: formato = NumberFormat.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.getNumberInstance(currentLocale).getCurrencyInstance(currentLocale). separadores (millares). se puede utilizar DecimalFormatSymbols en conjunción con la clase DecimalFormat Símbolos usados para formato Símbolo Significado 0 # . 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. los sufijos y prefijos. Si se quiere cambiar un símbolo del formateo como el separador decimal.###E0" muestra 1234 como "1. Esta clase permite controlar los ceros iniciales y finales. .

###.####E0"). System. System.out.println(s).'###.format(n).println(s).format(n). f = new DecimalFormat("###. public static void main(java. f = new DecimalFormat("###.00").0000").println(s).##0.out.format(n).###.out. 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. s = f.APÉNDICE En el ejemplo siguiente usaremos distintos cadenas de texto para dar formato a un número ingresado por teclado. DecimalFormat f.println(s). System. f = new DecimalFormat("###. System. String s.println(s). System. f = new DecimalFormat("'U$' ###.00%"). s = f.format(n).out.out.out. System. s = f. s = f. } Pag.lang.out. s = f. System. 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.format(n).leerDouble(). s = f. System.##0.format(n).println(s).print("Ingresa número a dar formato : ").###").##0.00"). n = Lectura.##0.out.format(n).00 Soles"). f = new DecimalFormat("'S/. f = new DecimalFormat("#. 607 .String[] args) { double n.println(s). s = f. f = new DecimalFormat("###.

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

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

add(cal.MONTH. la nueva hora sería 3:10 a diferencia del // método add ( ) que nos daría 4:10.. 40) // si la hora actual fuera 3:30. get(f) + cambio) // agrega cambio al valor del campo campo del calendario cal cal. 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 add() // agrega cambio al campo f. Esto es equivalente a hacer set (f. esto es. cambio) agrega cambio al campo f sin variar campos superiores.roll(cal. la nueva hora sería 3:10 a // diferencia del método add ( ) que nos daría 4:10. 610 static int .HOUR. // si aumentamos por ejemplo 40 minutos a la hora 3:30. cal. 1) //aumenta el mes actual en 1 roll() // roll (f.

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 .

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

626 .Pag.

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

628 .Pag.

You're Reading a Free Preview

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