Método de las 6D. UML - PSEUDOCODIGO -JAVA. Enfoque algortimico

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

25 27 28 35 36 37 39 45 54

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

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

CAPÍTULO III: Clases básicas incorporadas en el lenguaje Java. Introducción ........................................................................................................ 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. Introducción ........................................................................................................ Conceptos básicos. Clase ……............................................................................................... Objeto ……............................................................................................. Atributo …………………......................................................................... Método ………………….......................................................................... Métodos 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 …………...................................................... Problema resuelto 151 ........................................................................... Otros conceptos ………………………………………………………………………

527 532 534 535 542 544 547 550 554 556 559 561 563 569

APÉNDICE. Problemas propuestos ……………………………………………………... 573 Clase Lectura ......................................................................................... 603 Otras clases Java. DecimalFormat, Calendar, GregorianCalendar, SimpleDateFormat ...................... 605 BIBLIOGRAFÍA ................................................................................................... 625

PRÓLOGO Quiero pensar que al aceptar el grato pedido de Juan José Flores Cueto para prologar su nuevo libro estoy compartiendo o participando de alguna manera en el excelente trabajo que ha realizado para poner al alcance de estudiantes e informáticos un método para la solución de problemas utilizando una computadora. Al reflexionar sobre la tarea que representa escribir un prólogo para este libro, he reparado en lo difícil que resulta agregar valor al ya presentado por su contenido, pues el texto que mi joven amigo pone hoy a disposición de nuestros alumnos y también de profesionales de la especialidad de computación y sistemas, es resultado de la conjunción de varios factores: su experiencia académica, su desempeño profesional y la constante necesidad de estar actualizado. Escasamente un año atrás la Facultad de Ingeniería y Arquitectura de la USMP publicó el primer libro de J. J. Flores Cueto: Método para la solución de Problemas utilizando la Programación Orientada a Objetos y, una de las muchas razones del éxito obtenido por esa obra es que desarrolla una metodología para la solución de la gran cantidad de ejercicios, problemas y aplicaciones que contiene. Este novedoso método está conformado por seis etapas y cada una de ellas tiene una denominación que comienza con la letra D, lo que hace que estos seis pasos se puedan recordar fácilmente. Se tuvo en cuenta primordialmente al usuario y por ello, acertadamente, el método es llamado ahora método de las 6 D’s; pero es importante comprender que su uso puede extenderse a otros temas y a problemas con soluciones más complicadas y que para eso se tiene que redefinir algunos de los pasos de las etapas especificadas en el método. Comprobamos así, que la ópera prima de Juan José contenía, pues, ya el embrión de la segunda y de aquí, entonces, como consecuencia, el título del libro que hoy motiva estas líneas: Método de las 6’D: UML – Pseudocódigo – Java. (Un enfoque algorítmico). ¿Por qué la prisa en publicar esta segunda parte? Sabemos que lo más característico de la informática es su permanente dinámica, reflejada en la aparición de nuevos paradigmas que deben aplicarse rápidamente, pero cuya difusión en los textos no tiene la misma celeridad. El rápido avance de la ciencia y de la tecnología, que para muchos es agobiante, resulta estimulante para un espíritu como el de este prolífico docente de la USMP. El panorama de la ingeniería de computación y sistemas evoluciona y cambia mientras trabajamos en ella; al momento de aparecer su primer libro, nuestro autor sabía ya cuáles eran las nuevas tendencias que se perfilaban, acumulaba información y escribía sobre ellas, profundizando en el método de las 6 D’s para presentarnos en tan corto plazo una nueva obra. El mercado exige que los profesionales de Computación y Sistemas conozcan la últimas técnicas de programación e ingeniería de software y este libro responde a esas demandas introduciendo al estudiante en los conceptos de programación estructurada y en el dominio de la programación orientada a objetos, poniendo énfasis en la solución de problemas y empleando a fondo las capacidades lógicas para el desarrollo de soluciones utilizando una computadora. A mi juicio, las características más importantes del texto se reflejan en su fácil lectura y en su orientación al estudiante; pero mejor aun: en el hecho de haber sido probado

con los alumnos, comprobando su progreso y teniendo en cuenta la definición del problema, una buena documentación y la planificación de soluciones por algoritmos. Por lo arriba expresado y, por la amistad que me une a Juan José, es para mí sumamente gratificante escribir estas apreciaciones sobre su segundo libro y le auguro nuevos aportes como ingeniero y como docente de la USMP.

Ing. José Antonio Chang Escobedo. RECTOR USMP.

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

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

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

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


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

Temas: Introducción. Método de las 6’D: • Etapas y pasos. • Resumen del método. • Resultado de las etapas del método.

Marco de trabajo. Modelamiento. Algoritmo. Programación.

1

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

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

Pag. 25


Pag. 26


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.

Pag. 27


ETAPAS Y PASOS METODO 6’D. Descripción de la Etapa 01 – “Descripción del Problema”: Etapa 01 Descripción del Problema

En esta etapa, en primer lugar, es necesario identificar cual es el problema que se desea resolver. Esto que parece algo sumamente sencillo, muchas veces resulta una tarea agotadora ya que generalmente existen muchas opiniones de cual es el problema central. Identificarlo es una de las tareas más importante que los analistas deben afrontar. Identificado el problema es necesario poder comprenderlo en su totalidad, es decir, comprender qué es exactamente lo que se desea que se resuelva. Finalmente se deberá escribir un enunciado claro, concreto y conciso del problema a resolver. PASOS:

Identificación del problema. Descripción general del problema. Enunciado claro y preciso del problema.

ENUNCIADO

El resultado obtenido en esta etapa es un enunciado claro del problema que se desea solucionar.

Pag. 28


METODO 6’D. Descripción de la Etapa 02 – “Definición de la Solución”: Etapa 02 Definición de la Solución

En esta etapa, es necesario estudiar a fondo el problema para poder solucionarlo, saber exactamente en qué consiste y poder descomponerlo en cada una de sus partes para facilitar su comprensión y posterior solución. Esta es una regla que siempre deberá ser aplicada se utilice o no una computadora en la solución de un problema. Una vez entendido el problema, se está en condiciones de estudiarlo a fondo y plantear diversas alternativas que permitan solucionar el problema, para finalmente, seleccionar la alternativa mas adecuada.

PASOS:

Definir el resultado deseado. Determinar los datos que se deben ingresar o generar para obtener el resultado deseado. Determinar la forma en que los datos serán procesados para transformarlos en información.

ESPECIFICACIONES

El resultado obtenido en esta etapa son las especificaciones de lo que se debe hacer para solucionar el problema.

Pag. 29


METODO 6’D. Descripción de la Etapa 03 – “Diseño de la Solución”: Etapa 03 Diseño de la Solución

Definida la solución, se procede a diseñar la lógica modelando y desarrollando algoritmos. Para el modelado de la solución del problema se utiliza el Lenguaje Unificado de Modelado (Unified Modeling Language, UML), el cual es una herramienta usada para describir clases, objetos y sus relaciones. Para el desarrollo de algoritmos se utiliza Pseudocódigos o Diagramas de Flujo (DF), los cuales son herramientas utilizadas para diseñar los algoritmos de los diferentes métodos de una clase. Finalizado el desarrollo de los algoritmos es necesario verificar si se ha incluido soluciones para todas las formas en que se presente el problema. A este tipo de prueba se le denomina “Prueba de escritorio”.

PASOS:

Definir un nombre para el proyecto. Definición de diagramas, relaciones y clases.

Desarrollo de Algoritmos.

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.

Pag. 30


METODO 6’D. 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, se podrá proceder a la codificación del problema en algún lenguaje de programación. La codificación involucra traducir los diagramas, las especificaciones de las clases (expresadas en notación UML), y los pasos del algoritmo de cada método (expresado en DF o pseudocódigo), en sentencias de un lenguaje de programación determinado. Estas sentencias son almacenadas en un proyecto (o archivo) lógico, y constituyen lo que la computadora podrá ejecutar. PASOS:

Codificar el proyecto.

Desarrollar comentarios internos en los programas de computadora. Desarrollar copias de seguridad de los programas de computadora.

PROGRAMAS

El resultado obtenido en esta etapa son los programas y/o clases, codificados en un lenguaje de programación, que permiten solucionar el problema.

Pag. 31


METODO 6’D. 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, deben ser probados mediante la ejecución de los mismos (esto es conocido como corrida del programa). Al realizarse ésta, pueden surgir diferentes tipos de errores, siendo los errores de lógica y sintaxis los más comunes. Hay que corregir el programa; anular, modificar o crear nuevas sentencias, volver a probar el programa y continuar con la corrección y pruebas hasta conseguir el resultado deseado. PASOS:

Realizar la depuración y verificar la correcta escritura de los programas. Realizar pruebas de sintaxis. Realizar pruebas de lógica.

PRUEBAS

El resultado obtenido en esta etapa son las pruebas que registran el adecuado funcionamiento de la solución del problema.

Pag. 32


METODO 6’D. 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, la cual va a servir como base para la elaboración del manual técnico. Dedicarle tiempo a esta etapa nos ayudará a desarrollar buenos hábitos, los cuales serán necesarios cuando se desarrolle software en forma profesional. El manual técnico debe incluir, como mínimo: -

-

Descripción del problema. Resultados esperados y datos necesarios para generar dichos resultados. Diagramas UML, DF y/o Pseudocódigo. Pruebas desarrolladas. Listado de programas con comentarios internos.

PASOS:

Recopilar el material generado en cada una de las etapas anteriores. Generar el manual del programa. Generar el manual del usuario.

Manuales

El resultado obtenido en esta etapa son los manuales que permiten un adecuado manejo de la solución desarrollada.

Pag. 33


METODO 6’D. Adicionalmente es posible realizar “Ingeniería Reversa” entre las Etapas 03, 04 y 05:

Ingeniería Reversa

n veces

Es decir, a través de la Ingeniería Reversa es posible programar o codificar algunas partes (hasta su correcto funcionamiento) que no estén especificadas en la Etapa 03 “Diseño de la Solución”. A partir de esta solución se actualizan los diagramas de la Etapa 03 y se continúa con el proceso hasta llegar a la solución deseada.


Etapa 04 Desarrollo Solución

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

PASOS:

Etapa 05

•

Depuración Pruebas

• •

Exportar proyecto (archivos class o java) al disco de la PC, si está trabajando con un IDE. Importar proyecto (archivos class o java) a una herramienta CASE y realizar la ingeniería reversa. Organizar el modelo obtenido en la herramienta CASE.

DIAGRAMAS ACTUALIZADOS

Pag. 34

Definición Solución

Definir el resultado deseado. Determinar los datos que se deben ingresar o generar para obtener el resultado deseado. Determinar la forma en que los datos serán procesados para transformarlos en información.

Identificación del problema. Descripción general del problema. Enunciado claro y preciso del problema.

Etapa 02

Descripción Problema

Etapa 01

Definir un nombre para el proyecto. Definición de diagramas, relaciones y clases. Desarrollo de Algoritmos.

Pag. 35


Resumen de las etapas y los pasos del método:

METODO 6’D.

RESUMEN DEL MÉTODO


Codificar proyecto. Desarrollar comentarios internos en programas computadora. Desarrollar copias seguridad de programas computadora.

Desarrollo Solución

de los de

los de

el

Etapa 04

Realizar la depuración y verificar la correcta escritura de los programas. Realizar pruebas de sintaxis. Realizar pruebas de lógica.

Depuración Pruebas

Etapa 05

Recopilar el material generado en cada una de las etapas anteriores. Generar el manual del programa. Generar el manual del usuario.

Document.

Etapa 06

Definición Solución

ESPECIFICACIONES

ENUNCIADO

Etapa 02

Descripción Problema

Etapa 01

Resultado de las etapas del Método:

METODO 6’D.

RESULTADO DE LAS ETAPAS DEL MÉTODO

Desarrollo Solución

PROGRAMAS

DIAGRAMAS Y ALGORITMOS

Etapa 04

Diseño Solución

Pag. 36

Etapa 03

PRUEBAS

Depuración Pruebas

Etapa 05

Manuales

Document.

Etapa 06



MARCO DE TRABAJO En el presente texto se solucionarán problemas sencillos utilizando el Método de las 6’D. La solución de los problemas comenzará con el enunciado del problema y luego se desarrollará la etapa 02 (“Definición de la solución”), etapa 03 (“Diseño de la solución”) y etapa 04 (“Desarrollo de la solución”), es decir, solo se desarrollarán las tres etapas del método que son posibles especificar en el presente texto. La etapa 05 (“Depuración y pruebas”) se desarrolla directamente en un lenguaje de programación y la etapa 06 (“Documentación”) es la recopilación del material y la elaboración de los manuales respectivos. Etapa 01 Descripción Problema

ENUNCIADO Etapa 02 Definición Solución

MARCO DE TRABAJO



Pag. 37


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

Pag. 38


MODELAMIENTO El modelamiento se refiere a la forma como se representa la solución de un problema del mundo real en términos de un modelo. Un modelo es una representación gráfica o simbólica de algún aspecto del mundo real, que está bajo observación o estudio. Para representar un modelo se utilizará el UML (Unified Modeling Language). El Lenguaje Unificado de Modelado (UML) es un lenguaje gráfico que nos permite: • • • • •

Visualizar un modelo. Especificar un modelo (construir modelos precisos, no ambiguos). Construir un modelo en un lenguaje de programación (se establecen correspondencias con lenguajes Orientados a Objetos, como Java, C++, Visual Basic...). Documentar los componentes de un sistema de software (arquitectura, requisitos, diseño, pruebas, versiones, planificación...). Describir el ciclo de vida completo del desarrollo Orientado a Objetos.

Para desarrollar un modelo y representarlo en UML, es necesario conocer todos los conceptos relacionados con el desarrollo de Software Orientado a Objetos. Para nuestro propósito, se detallarán algunos conceptos básicos que serán utilizados en las soluciones planteadas en el presente texto.

Paquete.- Los paquetes nos permiten organizar las clases de un modelo. Un paquete contiene clases que tienen funciones similares. En UML, un paquete se representa de la siguiente forma:

NombrePaquete

Nombre del paquete.

Clase.- Una clase, es simplemente, un modelo que se utiliza para describir uno o más objetos del mismo tipo. En su forma más sencilla, una clase es un conjunto de atributos y métodos. Una clase es una abstracción y no

Pag. 39


representa a ningún objeto en particular. En UML, una clase se representa de la siguiente forma: Nombre de la clase y del paquete al cual pertenece la clase.

NombreClase (NombrePaquete al que pertenece)

Atributos

Lista de atributos de la clase.

Métodos

Lista de métodos de la clase.

Objeto.- Un objeto es cualquier cosa, real o abstracta, acerca de la cual almacenamos datos y los métodos que controlan y manipulan dichos datos. Un objeto se crea o instancia a partir de una clase, En UML, un objeto se representa de la siguiente forma:

Nombre de la clase a la cual pertenece el objeto y el nombre del objeto. Ambos nombres deben estar separados por dos puntos.

NombreClase : nombreObjeto

UML incorpora nueve diagramas que permiten representar un modelo desde diferentes perspectivas, los cuales se muestran a continuación:

Diagramas de Secuencia

Diagramas de Casos de Uso

Diagramas de Clase Paquete

Diagramas de Componentes

Diagramas de Colaboración

Modelo Diagramas de Estado

Diagramas de Objeto

Diagramas de Actividad

Pag. 40

Diagramas de Distribución


Para nuestro propósito, se detallará el diagrama de paquetes que será utilizado en las soluciones planteadas en el presente texto.

Diagrama de paquetes.- Un diagrama de paquetes permite especificar y visualizar las relaciones de dependencia que existe entre los paquetes que forman parte de una solución. Una relación de dependencia entre dos o más paquetes se establece cuando las clases que pertenecen a un paquete pueden tener acceso a todas o a algunas de las clases que pertenecen a otro paquete (dependencia unidireccional). También se puede establecer una relación de dependencia bidireccional cuando las clases que pertenecen a un paquete pueden tener acceso a todas o a algunas de las clases que pertenecen a otro paquete y viceversa. En UML, una relación de dependencia unidireccional entre dos paquetes se gráfica de la siguiente manera:

Relación de dependencia unidireccional.

La dependencia en este caso significa que todas las clases que pertenecen al paquete “dominioDeLaAplicacion” podrán tener acceso a todas o algunas de las clases que pertenecen al paquete “biblioteca” (observe el sentido de la flecha que marca la dependencia unidireccional).

Pag. 41


En el Método de las 6’D, el modelamiento de una solución se desarrolla durante la Etapa 03 - “Diseño de la solución”: Etapa 03 Diseño Solución

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

Pag. 42


En el paquete “biblioteca”, se tendrá clase Lectura1 que facilitará el ingreso de los datos a la computadora.

Regla general para especificar los nombres de los paquetes, clases, atributos y métodos: El nombre de la clase y el nombre del paquete deben comenzar con una letra mayúscula y el resto en minúscula. Si el nombre es compuesto, todas las primeras letras de los nombres simples que forman el nombre de la clase o paquete deberán comenzar con mayúscula. Los nombres de los atributos se escriben en minúscula. En caso que el nombre sea compuesto, a partir de la segunda palabra se escribe la primera letra en mayúscula. Los nombres de los métodos cumplen las mismas características que los nombres de atributos a excepción de los métodos constructores.

1

La clase Lectura se trata en el Capítulo II y se especifica en el Apéndice.

Pag. 43


Pag. 44


ALGORITMO Una clase, en su forma más simple, está constituida por atributos y métodos. Los métodos representan pequeños subprogramas encapsulados dentro de las clases y contribuyen a definir el comportamiento típico de los objetos. Para especificar cuáles son los pasos desarrollados en un determinado método y cuáles son los datos que manejan dichos pasos se desarrollan los algoritmos. Un algoritmo constituye una lista completa de los pasos y una descripción de los datos que son necesarios para resolver un determinado problema en el ámbito de un método. De esto, se deriva que un algoritmo se desarrolla para un determinado método y que su definición tiene dos partes esenciales:

Una lista de pasos que deben ser ejecutados.

Una descripción de los datos que son manipulados por estos pasos.

CARACTERÍSTICAS

Descripción de los pasos que deben ser ejecutados (estructuras lógicas).

Descripción de los datos que son manipulados por estos pasos (estructuras de datos).

Un algoritmo debe ser preciso, indicando el orden de realización de cada paso.

Todo algoritmo debe ser finito. Si se sigue un algoritmo, éste debe terminar en algún momento.

Un algoritmo debe estar definido. Si se sigue un algoritmo dos veces, se debe obtener el mismo resultado.

Un algoritmo puede o no tener datos de entrada.

Un algoritmo producirá uno o más datos de salida.

Pag. 45


Los datos de entrada y salida deben almacenarse en estructuras de datos.

El resultado que se obtenga debe satisfacer los requerimientos de la persona interesada (efectividad).

Debe ser estructurado. Es decir, debe ser fácil de leer, entender, usar y cambiar si es preciso.

En conclusión, los algoritmos permiten especificar la lógica de desarrollo de los métodos que conforman una clase. Por lo tanto, se debe entender la importancia de estudiar los “algoritmos” para comprender como se está solucionando un determinado problema.

Se dispone de diversas herramientas para desarrollar los algoritmos para los métodos de las clases. Entre dichas herramientas se puede mencionar al pseudocódigo y al diagrama de flujo. HERRAMIENTAS

PSEUDOCODIGO Un pseudocódigo permite expresar un algoritmo con palabras en castellano que son semejantes a las sentencias de un lenguaje de programación. Pautas básicas:

Todo algoritmo debe tener un nombre, el cual deberá comenzar con una letra mayúscula. Si es un nombre compuesto, la primera letra de cada palabra simple deberá estar en mayúscula. No se permiten los espacios en blanco en el nombre del algoritmo (generalmente se utilizará el nombre de la clase y el nombre del método para referirse a un determinado algoritmo). Es necesario que se determinen los datos de entrada y la información de salida. Para declarar una variable “x” se deberá determinar qué tipo de dato se almacenará. Por ejemplo. Si se desea declarar una variable de tipo texto se realizaría de la siguiente manera: TEXTO x. Para asignar un valor a una variable “x” se utiliza el signo igual. Por ejemplo, si se desea asignar 5 a la variable “x” se realizará de la siguiente manera: x = 5.

Pag. 46


Para indicar que la computadora lea un valor desde un dispositivo externo y lo almacene en la variable “z”, se utiliza: LEER z. Para indicar que la computadora escriba hacia un dispositivo externo: Para escribir un mensaje (observe que el mensaje está entre comillas) se utiliza: ESCRIBIR “hola”. Para escribir el valor de una variable (observe que la variable no está entre comillas) se utiliza: ESCRIBIR x. Para escribir el resultado de una expresión (observe que la expresión no está entre comillas) se utiliza: ESCRIBIR x + 2.

Estructura básica de un pseudocódigo: Algoritmo NombreClase – nombreMetodo() ENTRADA: SALIDA:

En ENTRADA y SALIDA se especifican las variables que se usarán en el desarrollo del algoritmo.

INICIO … … … …

Este es el cuerpo del algoritmo expresado en pseudocódigo. Las instrucciones se colocan entre INICIO... FIN.

FIN

DIAGRAMA DE FLUJO Un Diagrama de Flujo permite ilustrar la secuencia de pasos de un algoritmo por medio de símbolos especializados y líneas de flujo. La combinación de símbolos especializados y líneas de flujo describe la lógica para la solución del problema (algoritmo). Entonces, se puede afirmar que el Diagrama de Flujo es la representación gráfica de un algoritmo.

FLUJO Porque muestra la secuencia de lo que se tiene que realizar.

DIAGRAMA Por el hecho de ser un dibujo que no requiere estar a escala.

Pag. 47


Elementos o símbolos básicos:

PROCESO Utilizado para asignar valores a variables y resultados de operaciones matemáticas.

ENTRADA / SALIDA Utilizado para ingresar datos y visualizar información que resulta del procesamiento.

la

INICIO / FIN Este símbolo permite marcar el inicio y el final del algoritmo.

CONECTOR Este símbolo permite que no se crucen los flujos (líneas) en un diagrama.

FLUJOS (LINEAS) Líneas que permiten unir los diagramas y mostrar la secuencia lógica a la solución del problema.

Pag. 48


REGLAS UTILIZADAS POR LAS HERRAMIENTAS Con la finalidad de comprender mejor el diseño de los algoritmos, desarrollados en pseudocódigo y diagrama de flujo, se han clasificado en 6 grupos las reglas definidas. REGLA

FORMATO

DESCRIPCIÓN GRUPO 1

Utilizada para el ingreso de datos. El dato ingresado se almacena en la variable especificada.

LEER

LEER x

ESCRIBIR

ESCRIBIR “Hola” ESCRIBIR x ESCRIBIR x + z

Utilizada para la salida de información. Se puede visualizar una cadena, el contenido de una variable o el resultado de una operación matemática.

COMENTARIO

COMENTARIO “Variables”

Utilizada para realizar comentarios internos en la codificación de las soluciones.

NUMERO

NUMERO x

Permite declarar una variable de tipo numérico.

TEXTO

TEXTO mensaje

Permite declarar una variable de tipo texto o cadena.

CARACTER

CARACTER letra

Permite declarar a una variable de tipo texto o cadena de una sola letra.

LÓGICO

LÓGICO aprobado

Permite declarar una variable de tipo lógico.

VERDADERO

aprobado = VERDADERO

Permite asignar el valor VERDADERO a una variable lógica.

FALSO

aprobado = FALSO

Permite asignar el valor FALSO a una variable lógica.

GRUPO 2

SI

SI (condición) ENTONCES instrucciones... FINSI

Pag. 49

Permite especificar una estructura de decisión simple “SI... FINSI”. Las estructuras lógicas serán tratadas en el capítulo II.


REGLA

FORMATO

SI / SINO

SI (condición) ENTONCES instrucciones... SINO instrucciones... FINSI

Permite especificar una estructura de decisión doble “SI... SINO... FINSI”. Las estructuras lógicas serán tratadas en el capítulo II.

CUANDO (variable) SEA CASO (valor 1) : instrucciones...

Permite especificar una estructura de decisión múltiple “CUANDO... FINCUANDO”.

CASO (valor 2) : instrucciones... CASO (valor n) : instrucciones... OTROS instrucciones.. FINCUANDO

Las estructuras lógicas serán tratadas en el capítulo II.

CUANDO

DESCRIPCIÓN

DESDE

DESDE i = valorInicial HASTA valorFinal instrucción 1 . . . instrucción n FINDESDE

Permite especificar una estructura de repetición “DESDE... FINDESDE”. Las estructuras lógicas serán tratadas en el capítulo II.

MIENTRAS

MIENTRAS (condición) instrucción 1 . . . instrucción n FINMIENTRAS

Permite especificar una estructura de repetición “MIENTRAS...FINMIENTRAS”. Las estructuras lógicas serán tratadas en el capítulo II.

HACER

HACER instrucción 1 . . . instrucción n MIENTRAS (condición)

Permite especificar una estructura de repetición “HACER...FINHACER”. Las estructuras lógicas serán tratadas en el capítulo II.

TERMINAR

TERMINAR

CONTINUAR

Permite terminar la ejecución de una estructura lógica de repetición.

CONTINUAR

Pag. 50

Permite volver a ejecutar una estructura lógica de repetición sin finalizar todas las instrucciones que forman parte de la misma.


REGLA

FORMATO

DESCRIPCIÓN GRUPO 3

COSENO

x = COSENO n

SENO

x = SENO n

Permite obtener el coseno del valor almacenado en la variable “n”. El resultado se almacena en la variable “x”. Ver capítulo III.

Permite obtener el seno del valor almacenado en la variable “n”. El resultado se almacena en la variable “x”. Ver capítulo III.

LONGITUD

x = LONGITUD n

Permite obtener la longitud de la cadena almacenada en la variable “n” o la longitud del vector “n”. El resultado se almacena en la variable “x”. Ver capítulo III y capítulo IV.

FILA

x = FILA n

Permite obtener el número de filas de una matriz “n”. El resultado se almacena en la variable “x”.

COLUMNA

x = COLUMNA n

Permite obtener el número de columnas de una matriz “n”. El resultado se almacena en la variable “x”.

MAYÚSCULA

x = MAYÚSCULA n

Permite cambiar a mayúscula la cadena almacenada en la variable “n”. El resultado se almacena en la variable “x”. Ver capítulo III.

MINUSCULA

x = MINUSCULA n

Permite cambiar a minúscula la cadena almacenada en la variable “n”. El resultado se almacena en la variable “x”. Ver capítulo III.

GRUPO 4

RESTO

x = z RESTO n

Permite obtener el resto de la división entre las variables “z” y “n”. El resultado se almacena en la variable “x”.

DIVIDIR

x = z DIVIDIR n

Permite obtener la parte entera de la división de las variables “z” y “n”. El resultado se almacena en la variable “x”.

RAIZ

x = z RAIZ n

Permite obtener la raíz “n” del número “z”. El resultado se almacena en la variable “x”.

Pag. 51


REGLA

FORMATO

POTENCIA

x = z POTENCIA n

Permite obtener la potencia “n” del número “z”. El resultado se almacena en la variable “x”.

MAXIMO

x = z MAXIMO n

Permite obtener el número mayor entre el valor almacenado en la variable “n” y la variable “z”. El resultado se almacena en la variable “x”.

MINIMO

x = z MINIMO n

Permite obtener el número menor entre el valor almacenado en la variable “n” y la variable “z”. El resultado se almacena en la variable “x”.

CARACTER

x = z CARACTER n

Permite obtener el carácter ubicado en la posición “n” de la cadena “z”. El resultado se almacena en la variable “x”.

x = z ALEATORIO n

Permite obtener un número cualquiera (aleatorio) entre los valores de “n” y “z”. El resultado se almacena en la variable “x”.

ALEATORIO

DESCRIPCIÓN

GRUPO 5

SUBCADENA

x = z SUBCADENA n1, n2

ELIMINAESPACIO x = z ELIMINAESPACIO n1, n2

Permite obtener una subcadena comprendida entre las posiciones especificadas por “n1” y “n2” de la cadena “z”. El resultado se almacena en la variable “x”.

Permite eliminar los espacios existentes en una cadena entre las posiciones especificadas por “n1” y “n2”. El resultado se almacena en la variable “x”.

GRUPO 6

CREAR

CREAR vector[n] CREAR matriz[n1][n2]

Utilizada para crear arreglos previamente declarados. Un arreglo permite almacenar más de un dato del mismo tipo. Los arreglos serán tratados en el capítulo IV.

CREAR

CREAR objeto

Permite crear un determinada clase

EJECUTAR

EJECUTAR algoritmo

Permite ejecutar otro algoritmo.

Pag. 52

objeto

de

una


REGLA

FORMATO

DESCRIPCIÓN

PARAMETRO

PARAMETRO listaVariables

Permite especificar si un algoritmo recibe datos o valores.

RETORNAR

RETORNAR variable

Permite especificar si retorna una respuesta.

un

algoritmo

En el Método de las 6’D, el algoritmo de una solución se desarrolla después del modelamiento, durante la Etapa 03 - “Diseño de la solución”: Etapa 03 Diseño Solución

Se desarrollará el siguiente paso: Desarrollo de algoritmos. En este paso, se desarrollará el algoritmo para el método especificado en la clase, la cual forma parte del paquete “dominioDeLaAplicación”. Para el desarrollo del algoritmo se utilizará pseudocódigo.

Pag. 53


PROGRAMACIÓN La programación es la traducción del modelamiento y los algoritmos en sentencias que la computadora puede comprender y ejecutar. En términos sencillos. Se puede decir, que la programación es la acción de escribir programas para una computadora, utilizando alguno de los lenguajes de programación existentes. La acción de escribir programas para una computadora se conoce como codificación. Las personas que escriben los programas son conocidas como programadores, los cuales están divididos en categorías según su experiencia y dominio de diferentes lenguajes de programación. Entonces, un lenguaje de programación es un lenguaje que los programadores utilizan para escribir programas que son comprendidos y ejecutados en una computadora. Nos “comunicamos” con las computadoras a través de los programas desarrollados en un lenguaje de programación en particular. Existen diferentes lenguajes de programación, la mayor parte de los cuales tienen un conjunto de reglas o sentencias muy especializadas.

La forma de programación ha variado con el paso de los años. Al inicio, se desarrolló la programación lineal, luego la programación modular, después la programación estructurada y ahora la programación orientada a objetos. Entre los lenguajes de programación orientados a objetos podemos destacar a Java. LENGUAJES DE PROGRAMACIÓN

JAVA Java es un lenguaje de programación orientado a objetos desarrollado por Sun MicroSystems, una compañía reconocida por sus estaciones de trabajo UNIX de alta calidad.

Pag. 54


Fundamentado en el lenguaje de programación C++, el lenguaje Java se diseñó para ser pequeño, sencillo y portátil a través de plataformas y sistemas operativos, tanto a nivel de código fuente como binario, lo que significa que los programas Java (applets, aplicaciones y servlets), pueden ejecutarse en cualquier computadora que tenga instalada una máquina virtual de Java. A pesar que Java es un lenguaje de programación orientado a objetos, también puede ser utilizado como un lenguaje estructurado, lo cual se hace necesario para poder iniciar el estudio de los conceptos fundamentales de programación.

Estructura básica de un programa desarrollado en Java:

package NombrePaquete; class NombreClase { public static void main ( String arg[ ] ) { … sentencias; …

Este es el cuerpo del programa en Java. Las sentencias se colocan dentro de los corchetes del método main ( ).

} }

En el lenguaje de programación Java, para definir que una clase forma parte de un paquete determinado, se utiliza la siguiente palabra reservada: package En el lenguaje de programación Java para definir una clase se utiliza la siguiente palabra reservada: class

Pag. 55


Es importante comprender que una clase está constituida por atributos y métodos. Todo el código ejecutable reside dentro de los métodos de la clase. No existe código que no esté contenido dentro de un método (a excepción de los bloques estáticos). Existen clases que tienen un método especial conocido como “método principal”. Todas las clases que tienen especificado un “método principal”, son clases que pueden ejecutarse. En el lenguaje de programación Java, para especificar que una clase tiene un “método principal”, se utiliza las siguientes sentencias: public static void main (String arg[]) Por lo tanto, en el lenguaje de programación Java, el método principal es conocido como método main ( ).

Palabras reservadas en Java: Una palabra reservada o palabra clave, es aquella que tiene un significado especial para un lenguaje de programación. Todos los lenguajes tienen palabras claves. En el caso de Java tenemos las siguientes:

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


En la actualidad, la Programación Estructurada (PE) y la Programación Orientada a Objetos (POO) son las formas de programación utilizadas por la mayoría de los programadores, siendo la POO la más reciente y la que promete solucionar muchos de los problemas de la PE, incorporando nuevas características y nuevos conceptos. Una característica importante de la POO es que utiliza los mejores conceptos de la PE y de las otras formas de programación. En el Método de las 6’D, la programación de una solución se desarrolla durante la Etapa 04 - “Desarrollo de la solución”: Etapa 04 Desarrollo Solución

Se desarrollará solo el primer paso: Codificar el proyecto. En este paso, se desarrollará la codificación del proyecto. Es decir, utilizando el lenguaje de programación Java, se traducirá lo especificado en el modelamiento y en los algoritmos, en sentencias que la computadora pueda comprender y ejecutar.

Pag. 57


Pag. 58

Capítulo Estructuras Fundamentales para la Solución de Problemas

2

Temas: Introducción. Estructuras de Datos: Variables • Tipos de datos. • Conversión de datos.

Estructuras Lógicas: • • • • •

Estructuras lógicas de secuencia. Estructuras lógicas de decisión. Estructuras lógicas de repetición. Instrucciones de bifurcación. Mapa de estructuras lógicas detallado.

Método de las 6´D. Etapas y pasos. Problemas resueltos en general y sobre figuras.

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

MARCO DE TRABAJO ENUNCIADO DEL PROBLEMA Etapa 02 Definición Solución



Pag. 61


LISTA DE PASOS

SENTENCIAS

DESCRIPCIÓN DE DATOS

DECLARACIÓN Y DEFINICIÓN DE DATOS

SE DESARROLLAN UTILIZANDO: • Estructuras lógicas de secuencia. • Estructuras lógicas de decisión. • Estructuras lógicas de repetición. • Instrucciones de bifucación. ALMACENADOS EN: • Estructuras de datos tipo variables.

El presente capítulo, trata sobre las estructuras fundamentales para la solución de problemas. Es importante mencionar que utilizando las estructuras fundamentales para la solución de problemas (estructuras lógicas, instrucciones de bifurcación y las estructuras de datos conocidas como variables), se pueden desarrollar algoritmos de tal forma que estos puedan ser diseñados en pseudocódigo o diagrama de flujo, para luego ser codificados en un lenguaje de programación. La técnica que se emplea en el presente texto para el ingreso de datos y visualización de la información, cada día se utiliza con menos frecuencia (técnica tradicional basada en el ingreso de datos y visualización de información utilizando solo caracteres). En su lugar, se utilizan las interfaces gráficas de usuario o GUI (por sus siglas en inglés), que incorporan ventanas, gráficos, colores y otros objetos que permiten una interface visual con el usuario. El lenguaje de programación Java incorpora un paquete denominado AWT (Abstract Windows Toolking) que contiene clases que permiten crear cualquier tipo de interfaces gráficas de usuarios o GUI (interfaces visuales). También incorpora un paquete llamado SWING (a partir de la versión 2 de Java), que facilita el ingreso y visualización de datos utilizando cuadros de dialogo visuales.

Pag. 62


ESTRUCTURAS DE DATOS VARIABLES Definición: Una variable es una estructura de datos que permite reservar un espacio con la finalidad de almacenar o guardar temporalmente los datos. Una variable sólo puede almacenar un dato a la vez. Si se necesita almacenar dos o tres datos, se requerirán dos o tres variables según sea el caso. Declaración de una variable: Declarar una variable significa definir el nombre de la variable y el tipo de dato que podrá almacenar. Generalmente se realiza al inicio de un programa. La declaración de una variable se debe realizar antes de que ésta pueda ser utilizada; esto es necesario en los diferentes lenguajes de programación, y Java no es la excepción. En pseudocódigo y diagrama de flujo: TipoDeDato ListaDeVariables En Java: TipoDeDato ListaDeVariables ; Donde TipoDeDato debe ser un tipo de variable o tipo de dato válido y ListaDeVariables puede tener uno o más nombres de variables separadas por comas. Nombre de variable: Siempre es necesario que las variables tengan un nombre para poder referirse a ellas en cualquier parte de un programa. El nombre de una variable deberá comenzar con una letra minúscula. Si el nombre de la variable está formado por varias palabras, se deberá escribir con mayúscula la primera letra de cada palabra, a partir de la segunda palabra que forme parte del nombre. No es válido que el nombre de una variable tenga espacios en blanco ni caracteres especiales (tales como /()=?¨^* etc). En pseudocódigo: Una variable no puede tener el nombre de una regla o pauta definida. (ejemplo: ESCRIBIR). En Java:

Pag. 63


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

Pag. 64


En Java: suma = 7 + 5 ; En ambos casos, cuando se desee visualizar el contenido de la variable suma, se observará que el valor obtenido será 12. Otros usos de las variables: Muchas veces, es necesario utilizar variables que permitan almacenar resultados parciales, obtenidos cada vez que se ejecuta una estructura lógica de repetición (las estructuras lógicas se repetición se estudian más adelante en este mismo capítulo). Dichas variables pueden asumir la función de contador, acumulador o interruptor. La función que pueda asumir una variable dependerá de la forma como se plantee la solución para un determinado problema. Contadores: Un contador es una variable cuyo valor se incrementa o decrementa en una cantidad fija cada vez que se ejecutan los pasos que forman parte de una estructura de repetición. Un contador puede ser creciente o decreciente. Acumuladores: Un acumulador o totalizador es una variable cuya función es almacenar un valor como resultado de sumas o restas sucesivas. Un acumulador realiza la misma función que un contador con la diferencia que el incremento o decremento no es una cantidad fija sino una cantidad variable. Interruptores: Un interruptor o conmutador (denominado también centinela, bandera o flag) es una variable que puede tomar dos posibles valores (1/0, verdadero/falso, si/no, encendido/apagado) dentro de una determinada solución. Dependiendo del valor que tome el interruptor se ejecutarán ciertos pasos. Cabe mencionar que en una solución se puede utilizar una o varias variables que pueden asumir las funciones de contador, acumulador o interruptor.

Pag. 65


TIPOS DE DATOS Definición: Los tipos de datos permiten declarar las variables. A pesar que en el pseudocódigo y diagrama de flujo sólo se reconocen tres tipos de datos, en los lenguajes de programación se tiene una gran variedad de tipos de datos, los cuales están divididos –generalmente- en dos categorías: básicos o simples y compuestos. Existen diferentes tipos de datos. En pseudocódigo y diagrama de flujo se utilizan tres tipos (NUMERO, TEXTO y LOGICO). Los lenguajes de programación permiten trabajar con una amplia diversidad de tipos de datos que se extienden desde los más básicos hasta los más complejos. En Java, todos los datos son derivados de ocho tipos de datos básicos; byte, short, int, long, float, double, char y boolean. Los tipos de datos básicos se tratarán en este capítulo y constituyen la base para los tipos de datos compuestos. Tipos de datos en Pseudocódigo: Reglas definidas para los tipos de datos: NUMERO CARACTER TEXTO LOGICO

Referidos a cualquier número. Se puede subdividir en ENTERO y REAL. Referidos a cualquier letra, digito o símbolo encerrado entre comilla simple. Referidos a cualquier texto encerrado entre comillas dobles. Referido a los dos posibles valores lógicos (VERDADERO y/o FALSO).

Hay que tener presente que las palabras NUMERO, ENTERO, REAL. CARACTER. TEXTO y LOGICO son reglas utilizadas en el pseudocódigo y diagrama de flujo, por lo que no podrán ser usadas como nombre de variable. Estos datos nos permiten definir los tres tipos de variables utilizadas: Variables numéricas: Permiten almacenar sólo tipos de datos numéricos (NUMERO, ENTERO y REAL). Con una variable numérica se puede realizar operaciones matemáticas (suma, resta, multiplicación, división, etc.). En este contexto, se debe tener presente que las operaciones matemáticas se resuelven siguiendo las mismas reglas que se aplican en la aritmética tradicional.

Pag. 66


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

Pag. 67


Tipos de datos en Java: Los tipos de datos básicos o simples de Java son utilizados para declarar las variables que serán utilizadas en los programas, y forman parte de las palabras reservadas del lenguaje. Las palabras reservadas que permiten declarar variables son byte, short, int, long, float, double, char y boolean.

Tipo byte short

Descripción Tipo byte Entero corto

Longitud 1 byte 2 bytes

int

Entero

4 bytes

Entero largo

8 bytes

-128 … 127 -32768 … 32767 -2.147.483.648 2.147.483.647 -9.223.372.036.854.775.808 9.223.372.036.854.775.807

4 bytes

±3,4*10-38 … ±3,4*1038

8 bytes

±1,7*10-308 … ±1,7*10308

2 bytes 1 byte

0 … 65.535 true / flase

long float double char boolean

Real en coma flotante de simple precisión Real con coma flotante de doble precisión. Caracter Lógico

Rango

A diferencia de otros lenguajes de programación, en Java los tipos de datos simples no dependen de la plataforma ni del sistema operativo. Un entero de tipo int siempre tendrá 4 bytes, por lo que no habrá sorpresas al migrar un programa de un sistema operativo a otro. Es importante mencionar que Java no realiza una comprobación de rangos. Por ejemplo: si a una variable de tipo short con el valor 32.767 se le suma 1, el resultado será -32.768 y no se producirá ningún error de ejecución. Es importante destacar que estos ocho tipos de datos simples son diferentes, pero entre ellos se pueden agrupar como datos de tipo NUMERO (byte, short, int, long, float, double), tipo CARACTER (char) y tipo LOGICO (boolean). Los datos tipo NUMERO (datos numéricos) se pueden dividir en valores de tipo ENTERO (byte, short, int, long) y valores de tipo REAL (float, double). Para representar una cadena de caracteres en Java, se utiliza la clase String. Los String en Java no son un tipo de dato básico (simple), sino un tipo de dato compuesto (a pesar de ello, se puede utilizar como un tipo de dato simple para definir datos de tipo TEXTO en Java). Los valores de los datos de tipo String van entre comillas dobles (ejemplo; “Hola”) y permite almacenar cadenas de texto, mientras que los de tipo char van entre comillas simples (ejemplo; ‘K’) y sólo permiten almacenar un solo caracter. Las palabras reservadas de Java no pueden ser utilizadas como nombre de variable.

Pag. 68


Como regla general, una variable solo puede almacenar valores de acuerdo al tipo de dato con el que fue declarado. Es decir, si se declara una variable con un tipo de dato específico, solo podrá almacenar valores de dicho tipo de dato. En base a esto, si se declara una variable con un tipo de dato específico y se intenta almacenar un valor de distinto tipo, al momento de compilar, el programa indicará un error. Ejemplos:

Clase PrgTipoDato01 package dominioDeLaAplicacion ; class PrgTipoDato01 { public static void main ( String arg [ ] ) { double numReal = 4.3 ; int numEntero ; // La siguiente línea genera error. numEntero = numReal ; System.out.println ( numEntero ) ; } } Observación: No se puede almacenar un número real grande (double) en una variable entera (int).

Clase PrgTipoDato02 package dominioDeLaAplicacion ; class PrgTipoDato02 { public static void main ( String arg [ ] ) { double numRealDouble = 2.3 ; float numRealFloat ; // La siguiente línea genera error. numRealFloat = numRealDouble ; System.out.println ( numRealFloat ) ; } } Observación: No se puede almacenar un número real grande (double) en una variable real (float).

Pag. 69


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

Pag. 70


CONVERSIÓN DE DATOS Anteriormente se mencionó que por regla general en una variable solo se puede almacenar un solo valor y este valor debe ser del tipo de dato con el que la variable fue declarada. Pero como toda regla, esta también tiene su excepción, y la excepción para estos casos se denomina conversión de datos. A través de la conversión de datos se puede almacenar en una variable valores de tipo diferente al tipo de dato con el que se declaró la variable. La conversión de datos se aplica generalmente sobre los tipos de datos numéricos, es decir entre datos de tipo byte, short, int, long, float y double. También se puede aplicar sobre el tipo de dato char. 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, mas grande) y son generadas automáticamente por el compilador Java. 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, short, int, long, float y double Ejemplos; Clase PrgTipoDato04 package dominioDeLaAplicacion ; class PrgTipoDato04 { public static void main ( String arg [ ] ) { int numEntero = 5 ; long numEnteroGrande ; // La siguiente línea no genera error. numEnteroGrande = numEntero ; // Se visualiza 5 System.out.println ( numEnteroGrande ) ; } }

Observación: Al ejecutar esta aplicación el compilador utiliza la conversión implícita y convierte un número entero (int) en un número entero largo (long). Esto es válido ya que el tipo de dato long en Java es de mayor precisión que el tipo de dato int.

Pag. 71


Clase PrgTipoDato05 package dominioDeLaAplicacion ; class PrgTipoDato05 { public static void main ( String arg [ ] ) { char caracter = ‘a’ ; double numReal ; // La siguiente línea no genera error. numReal = caracter ; // Se visualiza 97.0 System.out.println ( numReal ) ; } }

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, por lo que se visualiza 97.0 (la letra a en código ASCII es 97).

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. En ambos casos, 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 ;

Lado izquierdo de la expresión

En caso contrario, si el lado derecho de la expresión tiene un tipo de dato más amplio que el lado izquierdo, al momento de compilar, el programa indicará un error. La conversión implícita de datos en Java, se da de un tipo de dato de menor precisión a uno de mayor precisión. 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. Estás conversiones son inseguras y puedan dar lugar a errores. Este tipo de conversión de datos se le denomina también cast (casting). El cast se realiza colocando entre paréntesis

Pag. 72


el tipo de dato al que se desea convertir el resultado de una expresión. Ejemplo; Clase PrgTipoDato06 package dominioDeLaAplicacion ; class PrgTipoDato06 { public static void main ( String arg [ ] ) { double num1 = 20, num2 = 3 ; int div ; // La siguiente línea genera error. div = num1 / num2 ; System.out.println ( div ) ; } }

Clase PrgTipoDato07 package dominioDeLaAplicacion ; class PrgTipoDato07 { public static void main ( String arg [ ] ) { double num1 = 20, num2 = 3 ; int div ; // La siguiente línea no genera error. div = ( int ) ( num1 / num2 ) ; // Se visualiza 6. System.out.println ( div ) ; } } 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).

Finalmente, 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, entre otras.

Pag. 73


Pag. 74


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. Las instrucciones se ejecutan una a una de tal modo que, finalizada la ejecución de una instrucción, se inicia la ejecución de la siguiente hasta completar la ejecución de todas las instrucciones que forman parte de la secuencia. 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. Tipos: 1. 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. Este tipo de estructura permite mostrar información a través de un dispositivo de salida de una computadora. Representación: Para representar la salida o visualización de la información se utiliza: - La regla; ESCRIBIR

En pseudocódigo.

- El símbolo; En diagrama de flujo. - La clase; System

Pag. 75

En Java.


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. Por ejemplo; Si desea visualizar la cadena de texto “Hola Mundo” utilizando pseudocódigo y diagrama de flujo, lo realizará de la siguiente manera: “Hola Mundo”

ESCRIBIR “Hola Mundo”

Si desea codificarlo en el lenguaje de programación Java, deberá realizarlo de la siguiente manera: System.out.print (“Hola Mundo”); System.out.println (“Hola Mundo”); Se puede utilizar la palabra “print” o “println”. Cuando se utiliza la palabra “print” se mostrará la cadena de texto y el cursor permanecerá al final de la cadena de texto mostrada, y cuando se utiliza la palabra “println” se mostrará la cadena de texto y el cursor se colocará en la siguiente línea.

2. 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, posteriormente, la información necesaria. Este tipo de estructura permite ingresar datos a través de un dispositivo de entrada de una computadora. Representación: Para representar la entrada de datos se utiliza: - La regla; LEER

En pseudocódigo.

- El símbolo; En diagrama de flujo.

Pag. 76


- La clase; Lectura

En Java.

Es importante mencionar que el lenguaje de programación Java no proporciona una clase que facilite el ingreso de datos en forma tradicional. En consecuencia, se utilizará una clase en Java desarrollada especialmente para que cumpla dicha finalidad.

CLASE

MÉTODO

DESCRIPCIÓN

leerString()

Permite ingresar cadena de texto.

leerChar()

Permite ingresar un caracter (una sola letra o número)

leerInt()

Permite ingresar número entero.

un

leerLong()

Permite ingresar número entero largo.

un

leerFloat()

Permite ingresar un número con parte decimal.

leerDouble()

Permite ingresar un número con parte decimal.

Lectura.class

una

La clase Lectura fue desarrollada por la Srta. Gisella Guzmán.

La clase Lectura va a facilitar el ingreso de datos en forma tradicional. 1 Esta clase es una implementación mejorada de la clase Math2 Es importante mencionar, que esta clase permitirá ingresar datos en forma tradicional y será usada para la codificación de algoritmos en Java. En el Apéndice, se trata en detalle la clase Lectura.

1

Se puede revisar el uso de la clase Math2 en el primer libro del autor, titulado “Método para la solución de problemas utilizando la programación orientada a objetos – Aspectos básicos”.

Pag. 77


3. 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. 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:

Y (AND) O (OR) N (NOT)

En Java: Y lógico: O lógico: Negación:

&& || ~

Formatos: Formato para diseñar algoritmos: Pseudocódigo

EXPLICACIÓN:

INICIO

Todas las instrucciones que son parte de la solución del problema deberán aparecer entre las reglas INICIO y FIN. Estas instrucciones se ejecutarán una tras otra.

Instrucciones ... FIN

Pag. 78


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

FIN

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 algoritmo se les denomina instrucciones.

Formato para codificar algoritmos: Lenguaje de Programación Java

class NombreClase { public static void main (String a[]) { .... // sentencias .... } }

EXPLICACIÓN: Inicialmente, se puede afirmar que todas las sentencias que son parte de la solución aparecerán dentro de los métodos. El método main ( ) es conocido como el método principal, y es desde donde se inicia la ejecución de las sentencias.

Al conjunto de pasos que forman parte de un programa de computadora se les denomina sentencias.

Pag. 79


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, de tal forma que en función de una condición o el valor de una variable, 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. Tipos: 1. Estructuras lógicas de decisión simple Definición: Una estructura de decisión simple “SI... 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. Formato para diseñar algoritmos:

Pseudocódigo EXPLICACIÓN: Si la condición resulta verdadera, se ejecutan las instrucciones que se encuentran entre las reglas ENTONCES y FINSI.

SI (condición) ENTONCES instrucciones... FINSI

Si la condición resulta falsa, no se ejecutan las instrucciones que se encuentran entre las reglas ENTONCES y FINSI.

Pag. 80


Diagrama de Flujo

VERDADERO

EXPLICACIÓN: Si la condición resulta verdadera, se ejecutan las instrucciones que se encuentran en el flujo etiquetado con la regla “VERDADERO”.

condición ?

... instrucciones... ...

FALSO

Si la condición resulta falsa, 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”.


EXPLICACIÓN: Si la condición resulta verdadera, se ejecutan las sentencias que se encuentra entre las llaves { }.

if (condición) {

Si la condición resulta falsa, no se ejecutan las sentencias que se encuentran entre las llaves { }.

sentencias... }

Pag. 81


2. Estructuras lógicas de decisión doble Definición: Una estructura de decisión doble “SI... SINO... 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. Si la condición resulta verdadera, se ejecuta un conjunto de pasos, y si la condición resulta falsa, se ejecuta otro conjunto de pasos. En ningún caso se podrá ejecutar ambos conjuntos de pasos a la vez. Este tipo de estructura es útil cuando se tiene la necesidad de escoger entre dos posibles opciones. Formato para diseñar algoritmos:

Pseudocódigo

EXPLICACIÓN: Si la condición resulta verdadera, se ejecutan las instrucciones que se encuentran entre las reglas ENTONCES y SINO.

SI (condición) ENTONCES instrucciones... SINO instrucciones... FINSI

Si la condición resulta falsa se ejecutan las instrucciones que se encuentran entre las reglas SINO y FINSI. Sólo se ejecuta uno de los grupos de instrucción, en ningún caso se podrá ejecutar ambos grupos.

Pag. 82


Diagrama de Flujo EXPLICACIÓN: VERDADERO

FALSO condición ?

... instrucciones ...

... instrucciones ...

Si la condición resulta verdadera, se ejecutan las instrucciones que se encuentran en el flujo etiquetado con la regla “VERDADERO”. Si la condición resulta falsa, se ejecutan las instrucciones que se encuentran en el flujo etiquetado con la regla “FALSO”.


EXPLICACIÓN: Si la condición resulta verdadera, se ejecutan las sentencias que se encuentran entre las llaves { } ubicadas después de la palabra reservada if.

if (condición) { sentencias... } else { sentencias... }

Si la condición resulta falsa, se ejecutan las sentencias que se encuentran entre las llaves { } ubicadas después de la palabra reservada else.

Pag. 83


3. Estructuras lógicas de decisión múltiple Definición: Una estructura de decisión múltiple “CUANDO... FINCUANDO” permite alterar el flujo secuencial de una solución ejecutando un conjunto de pasos dependiendo del valor de una variable. Generalmente, para cada posible valor que pueda tener la variable se define un conjunto de pasos a ejecutar. 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. Este tipo de estructura es útil cuando se tiene la necesidad de escoger entre más de dos opciones.

Formato para diseñar algoritmos: Pseudocódigo

EXPLICACIÓN:

CUANDO (variable) SEA CASO (valor 1) : instrucciones... CASO (valor 2) : instrucciones... CASO (valor n) : instrucciones... OTROS instrucciones... FINCUANDO

Pag. 84

Si el valor de la variable es igual a uno de los valores colocados después de una de las reglas CASO, se ejecutan las instrucciones que están dentro del mismo. Si el valor de la variable no es igual a ninguno de los valores colocados después de una de las reglas CASO, se ejecutan las instrucciones que están dentro de la regla OTROS. La regla OTROS es opcional (es decir, puede aparecer como no).


Diagrama de Flujo

variable ?

valor 1

instrucciones

valor 2

instrucciones

valor n

instrucciones

OTROS

instrucciones

EXPLICACIÓN: Si el valor de la variable es igual a uno de los valores que tiene como etiqueta el flujo, se ejecutan las instrucciones que están seguidas del flujo (las que indica la flecha). Si el valor de la variable no es igual a uno de los valores de las etiquetas de los flujos, se ejecuta el flujo que tiene como regla OTROS. El flujo con la regla OTROS es opcional.

Pag. 85



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, valor 2, etc), 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.

switch (variable) { case valor 1 : sentencias... case valor 2 : sentencias... case valor n : sentencias...

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 ejecutan las sentencias que están dentro de la palabra reservada default. La palabra reservada default es opcional (es decir puede aparecer como no).

default : sentencias... }

Es importante tener presente que en Java se deberá usar la palabra reservada break al final de cada bloque de sentencias si se desea que cada alternativa (case) ejecute un grupo de sentencias sin que ejecute el grupo de sentencias de las alternativas (case) que están a continuación. 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. Si la variable es de tipo entero (definida con la palabra reservada int), se deberá utilizar números enteros después de la palabra reservada case. En caso que la variable sea de tipo caracter (definida con la palabra reservada char), se deberá utilizar un caracter encerrado entre comillas simples después de la palabra reservada case.

Cuando se diseñe un algoritmo que necesite utilizar estructuras de decisión, se debe emplear correctamente los formatos establecidos, ya que estos constituyen lo que denominamos un “estándar” o acuerdo. Cuando se codifique un algoritmo recuerde que se tiene que seguir las reglas del lenguaje de programación que usará, caso contrario, al momento de ejecutar un programa, se dará con la sorpresa que tendrá errores de sintaxis.

Pag. 86


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

instrucción n FINDESDE

Pag. 87


EXPLICACIÓN: Esta estructura tiene tres partes: 1.

Inicialización:

DESDE i = valorInicial

Esta parte se ejecuta una sola vez al momento de iniciar la ejecución de la estructura lógica de repetición DESDE... FINDESDE y permite asignar un valor inicial a la variable “i” o la que se utilice en vez de ésta. 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.

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 ejecuta esta parte y se INCREMENTA (aumenta) el valor de la variable índice “i” según se indique en valor. También existe la posibilidad de reducir el valor de la variable índice “i”; en este caso, se utiliza la regla DECREMENTA en lugar de la regla INCREMENTA.

3.

Prueba:

HASTA valorFinal

Una vez que se termina de INCREMENTAR o DECREMENTAR la variable índice, se procede a ejecutar esta parte. Aquí se evalúa si la variable índice es igual a valorFinal, es decir si ya llegó HASTA valorFinal. Si la variable índice no es igual a valorFinal, se volverá a ejecutar las instrucciones o bloque de instrucciones ubicadas entre las reglas DESDE y FINDESDE. En caso que la variable índice sea igual a valorFinal, 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.

El equivalente de esta estructura en diagrama de flujo se muestra a continuación:

Pag. 88


Diagrama de Flujo

DESDE i HASTA z

FALSO

INCREMENTA x VERDADERO


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. 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, se representa por el siguiente símbolo:

Este último símbolo es equivalente a la regla FINDESDE utilizada en pseudocódigo.

Pag. 89


Formato para codificar algoritmos: Lenguaje de Programación Java for ( i = valorInicial ; condición ; incremento) { sentencias... } EXPLICACIÓN: En Java, la regla DESDE está representada por la sentencia for. Al igual que en pseudocódigo y diagrama de flujo, en Java esta estructura está constituida por tres partes. En pseudocódigo y diagrama de flujo se utiliza la regla HASTA valorFinal, mientras que en Java se utiliza una condición lógica (ejemplo: i >10). Esta parte constituye la prueba en Java. Si la condición es verdadera, se continúa con la ejecución de las sentencias o bloque de sentencias que pertenecen a la estructura de repetición; en el caso que sea falso, se finaliza la ejecución continuando con la siguiente sentencia. Es importante indicar que el inicio y fin de la sentencia for se representan con llaves ({ }).

2. Estructura lógica de repetición “MIENTRAS” Definición: Una estructura de repetición “MIENTRAS... FINMIENTRAS”, al igual que una estructura lógica de repetición “DESDE... FINDESDE”, permite repetir una instrucción o un bloque de instrucción mientras que una condición se cumpla o ésta sea verdadera. Este tipo de estructura es útil cuando se necesita repetir una instrucción o bloque de instrucciones un número de veces no determinado.

Pag. 90


Formato para diseñar algoritmos: Pseudocódigo MIENTRAS (condición) instrucción 1 . . .

instrucción n FINMIENTRAS

EXPLICACIÓN: Cuando se ejecuta la estructura lógica de repetición MIENTRAS... FINMIENTRAS lo primero que se realiza es la evaluación de la condición lógica ubicada junto a la regla MIENTRAS. 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, se procede a ejecutar las instrucciones que están dentro de la estructura lógica de repetición MIENTRAS... FINMIENTRAS y se evalúa, nuevamente, la condición lógica. Si el resultado de evaluar la condición lógica es falsa, no se ejecutan las instrucciones que están dentro de la estructura lógica de repetición MIENTRAS... FINMIENTRAS y se continúa con la ejecución del algoritmo. Esto significa que mientras la evaluación de la condición lógica resulte verdadera, se ejecutará la estructura lógica de repetición MIENTRAS... FINMIENTRAS y que sólo finalizará cuando la evaluación de la condición lógica resulte falsa.

El equivalente de esta estructura en diagrama de flujo se muestra a continuación. En la figura, se observa donde se ubica la condición lógica y los flujos etiquetados con las reglas “VERDADERO” y “FALSO”.

Pag. 91


Diagrama de Flujo

FALSO condición ?

VERDADERO


Formato para codificar algoritmos:

Lenguaje de Programación Java while (condición) { sentencias... }

Pag. 92


EXPLICACIÓN: En Java, la regla MIENTRAS está representada por la sentencia while. En la sentencia while, al igual que en pseudocódigo y diagrama de flujo, se utiliza una condición lógica (ejemplo: i >10) para verificar si se ejecuta la estructura o no. Esta condición lógica constituye la prueba en Java. Si la condición es verdadera, se continúa con la ejecución de las sentencias o bloque de sentencias que pertenecen a la estructura de repetición; en el caso que sea falso, 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 ({ }).

3. Estructura lógica de repetición “HACER” Definición: Una estructura lógica de repetición “HACER... MIENTRAS”, al igual que una estructura lógica de repetición “DESDE... FINDESDE” y una estructura lógica de repetición “MIENTRAS... FINMIENTRAS”, permite repetir una instrucción o un bloque de instrucciones mientras que una condición se cumpla o sea verdadera. La principal diferencia entre ambos consiste en que la estructura lógica de repetición “MIENTRAS... FINMIENTRAS” prueba la condición antes de ejecutar la instrucción o bloque de instrucciones, 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. La estructura lógica de repetición “HACER... MIENTRAS” ejecuta al menos una vez las instrucciones o bloque de instrucciones antes de probar la condición. Este tipo de estructura es útil cuando se necesita repetir una instrucción o bloque de instrucciones un número de veces no determinado, siendo necesario ejecutar la instrucción o bloque de instrucciones por lo menos una vez.

Pag. 93


Formato para diseñar algoritmos:

Pseudocódigo HACER instrucción 1 . . .

instrucción n MIENTRAS (condición)

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

Pag. 94


El equivalente de está estructura en diagrama de flujo se muestra a continuación. En la figura, se observa donde se ubica la condición lógica y los flujos etiquetados con las reglas “VERDADERO” y “FALSO”.

Diagrama de Flujo

... instrucciones ... ... VERDADERO condición ? FALSO

Formato para codificar algoritmos:

Lenguaje de Programación Java do { sentencias... } while (condición) ;

Pag. 95


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

Pag. 96


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. Para esto, se utilizan las instrucciones de bifurcación o salto. 1. Instrucción “TERMINAR”. En Java, esta instrucción de bifurcación es conocida como la sentencia break y tiene tres usos:

Permite finalizar una secuencia de sentencias en un switch (específicamente en el case). Se utiliza para salir de un bucle, sin analizar la condición y sin ejecutar el resto de código del cuerpo del bucle. 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).

2. Instrucción “CONTINUAR” En Java, esta instrucción de bifurcación es conocida como la sentencia continue. Esta sentencia permite salir anticipadamente de una iteracción de un bucle. Es decir; cuando se encuentra la sentencia continue se ejecuta la siguiente iteracción del bucle sin procesar el resto del código. 3. Instrucción “RETORNAR” En Java, esta instrucción de bifurcación es conocida como la sentencia return. Esta sentencia se utiliza para volver explícitamente de un método, es decir, esta sentencia permite que el control de la ejecución de la solución vuelva al método llamante.

Pag. 97


Mapa de Estructuras Lógicas detallado:

Utilizando las estructuras lógicas fundamentales y las instrucciones de bifurcación, se pueden desarrollar algoritmos de tal forma que estos puedan ser diseñados en pseudocódigo o diagrama de flujo, para luego ser codificados en un lenguaje de programación. Las estructuras lógicas fundamentales y las instrucciones de bifurcación se resumen a continuación:

Estructuras Lógicas.

Estructuras Lógicas de Secuencia.

Estructuras Lógicas de Decisión.

Estructuras Lógicas de Repetición.

Instrucciones de Bifurcación.

“LEER”

“SI”

“DESDE”

“TERMINAR”

“ESCRIBIR”

“SI / SINO”

“MIENTRAS”

“CONTINUAR”

“PROCESAR”

“CUANDO”

“HACER”

“RETORNAR”

Pag. 98

ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS

MÉTODO DE LAS 6´D – ETAPAS Y PASOS A continuación, se presentan las etapas del Método de las 6’D con sus respectivos pasos. Dichas etapas y pasos han sido desarrollados en su totalidad en los primeros 22 problemas. Sin embargo, para los siguientes problemas hasta el final del presente capítulo (capítulo II), y para los problemas del siguiente capítulo (capítulo III), solo se ha incluido la Etapa 04 – “Desarrollo de la solución”. Esto permite presentar una mayor cantidad de problemas con sus respectivas codificaciones.

ENUNCIADO DEL PROBLEMA


• Determinar la información deseada (salida). • Determinar los datos de entrada (entrada). • Establecer como se solucionará el problema (proceso).


• Determinar el nombre del proyecto. • Definir los paquetes y desarrollar el diagrama de paquetes respectivo. Establecer la dependencia. (Utilice UML). • Definir las clases que serán parte de la solución del problema. (Utilice UML).


• Codificar el diseño de la solución del problema. Se utiliza el lenguaje de programación Java.

• Diseñar el algoritmo para el método principal. Se utiliza pseudocódigo.

En forma general, la Etapa 03 - “Diseño de la lógica” se divide en dos partes: modelamiento (paso 1, 2 y 3) y algoritmo (paso 4), mientras que en la Etapa 04 “Desarrollo de la solución” se tiene la parte de codificación (paso 1). También se puede utilizar esta división en el desarrollo de las soluciones.

Pag. 99


Pag. 100


Problema 01 Etapas para la solución de un problema: Etapa 01 - Descripción del problema. Desarrollar un proyecto que permita mostrar un mensaje por la pantalla. El mensaje a mostrar será “Hola bienvenidos”. Etapa 02 – Definición de la solución.

Resultado deseado:

Mostrar mensaje “Hola bienvenidos”.

Datos necesarios:

Ninguno.

Procesamiento:

El mensaje será almacenado en una variable (mensaje) y posteriormente mostrado.

Etapa 03 - Diseño de la lógica. Para solucionar el problema se desarrollarán las especificaciones del proyecto en UML y el algoritmo en pseudocódigo. 1. Nombre del Proyecto: ProyMensaje 2. Definición de Paquete y Clase.

Paquete y clase

DominioDeLaAplicacion

PrgMensaje main()

Pag. 101


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

Algoritmo PrgMensaje - método main() ENTRADA: SALIDA:

mensaje

INICIO TEXTO mensaje mensaje = “ Hola bienvenido ” ESCRIBIR mensaje

Algoritmo para el método main ( ) diseñado en pseudocódigo.

FIN

Etapa 04 – Desarrollo de la Codificación. La codificación se desarrolla utilizando el lenguaje de programación Java. Una vez que se ejecute este programa, se visualiza en la pantalla el mensaje “Hola Bienvenido”.

Clase PrgMensaje /* Este es el primer programa. Aunque es sencillo, podemos apreciar los elementos básicos de un programa en Java. */ package dominioDeLaAplicacion ; class PrgMensaje

{

// La ejecución empieza en el método main. public static void main ( String arg [ ] ) { String mensaje ; mensaje = “ Hola bienvenido ” ; System.out.print (mensaje) ; } }

Pag. 102


Análisis de la solución: En primer lugar, se definió el nombre del proyecto, se estableció el nombre del paquete, el nombre de la clase y el método main ( ), en el cual se codifica la solución. A continuación, analizaremos el algoritmo del método main ( ) diseñado en pseudocódigo para la solución del problema anterior. La primera línea:

ALGORTIMO PrgMensaje Está referida al nombre del algoritmo. En este caso, el nombre es PrgMensaje. Observe que la primera letra se escribe con mayúscula.

Luego tenemos:

ENTRADA: En esta parte se hace referencia a todas las variables, cuya función en el algoritmo es almacenar datos de entrada. Observe que no se ha definido ninguna variable de entrada.

A continuación:

SALIDA: En esta parte se hace referencia a todas las variables, cuya función en el algoritmo es almacenar datos de salida. Observe que se ha definido la variable mensaje como una variable de salida. SALIDA:

Luego tenemos:

mensaje

INICIO Esta palabra permite indicar el inicio de los pasos que constituyen la solución al problema planteado.

A continuación:

TEXTO mensaje Esta línea está referida al paso 1 del algoritmo diseñado en pseudocódigo. Aquí se declara que se utilizará una variable de nombre mensaje cuyo tipo de dato es TEXTO o cadena.

Luego tenemos:

mensaje = “ Hola bienvenidos ” Esta línea está referida al paso 2 del algoritmo diseñado en pseudocódigo. Aquí se asigna el valor “ Hola bienvenidos ” a la variable mensaje. Recuerde que, para asignar un valor a una variable, se utiliza el símbolo igual (=).

A continuación:

ESCRIBIR mensaje

Pag. 103


Esta línea está referida al paso 3 del algoritmo diseñado en pseudocódigo. A través de la palabra ESCRIBIR se muestra el contenido de la variable mensaje. Es decir, se muestra “ Hola bienvenidos ” , valor que fue asignado a la variable en el paso 2. Finalmente:

FIN Esta palabra permite indicar el fin de los pasos que constituyen la solución al problema planteado. Es decir, el final del algoritmo.

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

Ahora, analicemos cada línea de la codificación del algoritmo en el lenguaje de programación Java: En primer lugar, observamos que el programa empieza con las siguientes líneas: /* Este es el primer programa. Aunque es sencillo podemos apreciar los elementos básicos de un programa en Java. */

Este es un comentario. Tal como la mayoría de lenguajes de programación, Java le permite colocar comentarios en el código fuente de los programas. Los comentarios no son ejecutados, y su propósito es describir o explicar el objetivo de un programa a cualquiera que lea el código fuente. En nuestro caso, el comentario nos permite identificar el programa. En problemas grandes se utilizan los comentarios para explicar para qué sirve cada característica del programa y cómo éstas se ejecutan. Es decir, se puede utilizar los comentarios para describir paso a paso lo que hace el programa. En Java existen tres tipos de comentarios. El que se acaba de mostrar se llama 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 (*/). Todo aquello que se escribe entre los dos símbolos de comentario de múltiples líneas /*………. */ es ignorado al momento de ejecutar el programa. Los comentarios de múltiples líneas pueden tener una o varias líneas de longitud.

Pag. 104


Observemos la siguiente línea de código:

package dominioDeLaAplicacion ;

Esta línea especifica el paquete al cual pertenecerá la clase que se creará con la palabra reservada class. El nombre del paquete está a continuación de la palabra reservada package. En este caso, el nombre del paquete es “dominioDeLaAplicacion”.

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, lo cual nos indica que se declara una clase. A continuación encontramos el nombre de la clase PrgMensaje. Finalmente, seguido del nombre se coloca una llave de apertura ( { ), la cual indica el inicio del cuerpo de la misma. La siguiente línea del programa es:

// La ejecución empieza en el método main.

Este también es un comentario. Usa el segundo tipo de comentario disponible en Java y se llama comentario de una sola línea. Los comentarios de una sola línea comienzan con dos barras ( // ) y terminan al final de la línea. La siguiente línea del programa es:

public static void main ( String arg [ ] ) {

Pag. 105


Esta línea de código es conocida como la firma del método main ( ) o método principal. Toda clase en Java, que deseamos tenga la posibilidad de ejecutarse, deberá tener un método main ( ) exactamente como ha sido escrito, debido a que Java diferencia las letras mayúsculas de las letras minúsculas. En resumen, podemos decir que para desarrollar un programa básico en Java necesitamos definir un paquete, una clase y un método principal o método main ( ). Recuerde que esto se realizó con las siguientes líneas de código:

package dominioDeLaAplicacion ; class PrgMensaje { public static void main ( String arg [ ] ) { } }

La siguiente línea del programa es:

String mensaje ;

A través de esta línea se declara el uso de la variable mensaje de tipo TEXTO o cadena. En Java, todas las variables deben ser declaradas antes de ser utilizadas (lo que no es necesario realizar en las herramientas utilizadas para diseñar algoritmos). Además, también se debe especificar el tipo de dato que la variable puede almacenar. En este caso, el tipo de la variable mensaje es TEXTO o cadena. En Java, para declarar una variable de tipo TEXTO o cadena, se debe de anteponer al nombre de la variable la palabra String. Es importante mencionar que esta línea de código termina en punto y coma ( ; ). De hecho, todas las sentencias en Java terminan en punto y coma. La siguiente línea del programa es:

mensaje = “ Hola bienvenido ” ;

A través de esta sentencia se asigna un valor a la variable. Es importante mencionar que una variable, antes de ser utilizada, debe tener un valor asignado. En este caso, a la variable mensaje se le asigna el valor “ Hola bienvenido ”. Para asignar valor a una

Pag. 106


variable, se utiliza el signo igual ( = ). En Java se crea una cadena cuando se encierra una secuencia de caracteres entre comillas. De esta manera, “ Hola bienvenido ” es una cadena.

La siguiente línea del programa es:

System.out.print (mensaje) ;

Esta es una sentencia de salida por la consola. Hace que el valor de la variable mensaje se visualice por la pantalla. De hecho, también uno puede visualizar cadenas y los resultados de operaciones matemáticas. Las dos últimas líneas del programa son:

} }

La primera indica que el método main ( ) ha terminado y la segunda indica el final de la clase. De esto se deduce, que las siguientes líneas de código se utilizarán en todos los programas que se desarrollen. Sólo variará el nombre del paquete y el nombre de la clase que, en este caso, es dominioDeLaAplicacion y PrgMensaje respectivamente.

package dominioDeLaAplicacion ; class PrgMensaje { public static void main ( String arg [ ] ) { } }

Pag. 107


Problema 02 Etapas para la solución de un problema: Etapa 01 - Descripción del problema. Se requiere mostrar el resultado de sumar, multiplicar, restar y dividir los números 9121236 y 735. Etapa 02 - Definición de la solución.

Resultado deseado:

Datos necesarios: Procesamiento:

Mostrar el resultado de las operaciones matemáticas básicas; suma, multiplicación, resta y división de los números 9121236 y 735. Ninguno. Los números serán almacenados en variables, luego se realizarán las operaciones matemáticas y, finalmente, se mostrarán los resultados de dichas operaciones.

Etapa 03 - Diseño de la lógica. Para solucionar el problema se desarrollarán las especificaciones del proyecto en UML y el algoritmo en pseudocódigo. 1. Nombre del Proyecto: ProyOperaciones. 2. Definición de Paquete y Clase.

Paquete y clase

DominioDeLaAplicacion

PrgOperaciones main()

Pag. 108


3. Diseño de algoritmo para el método principal. Algoritmo PrgOperaciones - método main() ENTRADA: SALIDA:

suma, multi, resta,divi

INICIO NUMERO num1=9121236, num2=735 NUMERO suma, multi, resta, divi suma = num1 + num2 multi = num1 * num2 resta = num1 - 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 - Desarrollo de la Codificación. La codificación se desarrolla utilizando el lenguaje de programación Java. Clase PrgOperaciones package dominioDeLaAplicacion; class PrgOperaciones

{

// la ejecución empieza en main. public static void main ( String arg[ ] ) { long num1=9121236, num2=735, suma, resta, multi; double divi; suma = num1 + num2; resta = num1 – num2; multi = num1 * num2; divi = (double) (num1) / num2; System.out.println (“La suma es: ” + suma); System.out.println (“La resta es: ” + resta); System.out.println (“La multiplicación es: ” + multi); System.out.println (“La división es: ” + divi); } }

Pag. 109


Problema 03 Etapa 01 - Descripción del problema. Convertir y mostrar una cantidad de dinero, expresado en dólares, en su equivalente en nuevos soles. Ingresar la cantidad en dólares y el tipo de cambio. Etapa 02 - Definición de la solución.

Resultado deseado:


Mostrar el equivalente, en nuevos soles, de una cantidad expresada en dólares. El monto en dólares y el tipo de cambio. El monto en dólares y el tipo de cambio serán ingresados por teclado y almacenados en dos variables (dolares y tipo respectivamente). Luego, 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.

Etapa 03 - Diseño de la lógica. Para solucionar el problema se desarrollarán las especificaciones del proyecto en UML y el algoritmo en pseudocódigo. 1. Nombre del Proyecto: ProyDolaresSoles. 2. Definición de Paquetes y desarrollo de Diagrama de Paquetes.

Diagrama de paquetes

Pag. 110


3. Definición de las Clases. Clases dominioDeLaAplicacion

Clases biblioteca

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

Algoritmo PrgDolaresSoles - método main ( )

ENTRADA: dolares, tipo SALIDA: soles

INICIO NUMERO dolares, tipo, soles LEER dolares, tipo soles = dolares * tipo ESCRIBIR soles FIN

Pag. 111


Etapa 04 - Desarrollo de la Codificación. La codificación se desarrolla utilizando el lenguaje de programación Java.

Clase PrgDolaresSoles package dominioDeLaAplicacion ; import biblioteca.Lectura ; class PrgDolaresSoles { public static void main (String arg[]) { double dolares, tipo, soles ; System.out.print ( “ Ingrese una cantidad de dólares: ” ) ; dolares = Lectura.leerDouble ( ) ; System.out.print ( “ Ingrese tipo de cambio del dólar: ” ) ; tipo = Lectura.leerDouble ( ) ; soles = dolares * tipo ; System.out.println ( “ Cantidad equivalente en soles es: ” + soles) ; } }

Pag. 112


Problema 04 Etapa 01 - Descripción del problema. Calcular la nota final que ha obtenido un alumno en el curso de programación avanzada. Utilizar la siguiente fórmula: nf = (n1 + n2 + n3 + (n4 * 2)) / 5. Ingresar las notas n1, n2, n3 y n4 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 este caso tenemos 4 notas). Las notas serán ingresadas por teclado y almacenadas en variables (n1, n2, n3 y n4 respectivamente). Luego, 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.

Etapa 03 - Diseño de la lógica. Para solucionar el problema se desarrollarán las especificaciones del proyecto en UML y el algoritmo en pseudocódigo. 1. Nombre del Proyecto: ProyNotaFinal. 2. Definición de Paquetes y desarrollo de Diagrama de Paquetes. Diagrama de paquetes

Pag. 113


3. Definición de las Clases.

Clases dominioDeLaAplicacion

Clases biblioteca


Algoritmo PrgNotaFinal - método main ( )

ENTRADA: SALIDA:

n1, n2, n3, n4 nf

INICIO NUMERO n1 = 0, n2 = 0, n3 = 0, n4 = 0 LEER n1, n2, n3, n4 nf = ( n1 + n2 + n3 + ( n4 * 2 ) ) / 5 ESCRIBIR nf FIN

Pag. 114



Clase PrgNotaFinal package dominioDeLaAplicacion ; import biblioteca.Lectura ; class PrgNotaFinal { public static void main (String arg[]) { double n1 = 0, n2 = 0, n3 = 0, n4 = 0, nf = 0 ; System.out.print ( “ Ingrese la nota 1 del alumno: ” ) ; n1 = Lectura.leerDouble ( ) ; System.out.print ( “ Ingrese la nota 2 del alumno: ” ) ; n2 = Lectura.leerDouble ( ) ; System.out.print ( “ Ingrese la nota 3 del alumno: ” ) ; n3 = Lectura.leerDouble ( ) ; System.out.print ( “ Ingrese la nota 4 del alumno: ” ) ; n4 = Lectura.leerDouble ( ) ; nf = ( n1 + n2 + n3 + ( n4 * 2)) / 5 ; System.out.print ( “ El promedio obtenido por el alumno es : ” ) ; System.out.println ( nf ) ; } }

Pag. 115


Problema 05 Etapa 01 - Descripción del problema. Ingresar el sueldo de un obrero de la empresa “La Poderosa S.A.” y calcular su respectivo descuento del 15% por concepto de impuestos y el 5% por concepto de cafetería. Se deberá visualizar por pantalla el total de descuentos y el sueldo a cobrar. Etapa 02 - Definición de la solución.

Resultado deseado:


Mostrar el total de descuento y el sueldo a cobrar de un obrero de la empresa. El sueldo total del obrero. El sueldo total será ingresado por teclado y almacenado en una variable (sueldo). Luego, se realizarán los cálculos del descuento y del sueldo a cobrar del obrero, utilizando las siguientes operaciones: desc = sueldo * 0.2 pago = sueldo – desc Los resultados se almacenarán en las variables (desc y pago respectivamente) para luego ser mostradas por pantalla.

Etapa 03 - Diseño de la lógica. Para solucionar el problema se desarrollarán las especificaciones del proyecto en UML y el algoritmo en pseudocódigo. 1. Nombre del Proyecto: ProySueldoObrero. 2. Definición de Paquetes y desarrollo de Diagrama de Paquetes. Diagrama de paquetes

Pag. 116



Clases biblioteca

4. Diseño de algoritmo para el método principal. Algoritmo PrgSueldoObrero - método main ( )

ENTRADA: SALIDA:

sueldo desc, pago

INICIO NUMERO sueldo = 0, desc = 0, pago = 0 LEER sueldo desc = sueldo * 0.2 pago = sueldo - desc ESCRIBIR desc, pago FIN

Pag. 117



Clase PrgSueldoObrero package dominioDeLaAplicacion ; import biblioteca.Lectura ; class PrgSueldoObrero { public static void main (String arg[]) { double sueldo = 0, desc = 0, pago = 0 ; System.out.print ( “ Ingrese el sueldo de un obrero: ” ) ; sueldo = Lectura.leerDouble ( ) ; // Calculando el descuento ( 20% ) desc = sueldo * 0.2 ; // calculando el monto a pagar pago = sueldo – desc ; System.out.print ( “ El total de descuento es: ” ) ; System.out.println ( desc + “ soles ” ) ; System.out.println ( “ El sueldo a pagar es: ” + pago + “ soles ” ) ; } }

Pag. 118


Problema 06 Etapa 01 - Descripción del problema. Convertir la temperatura de grados Celsius a grados Fahrenheit, de acuerdo a la siguiente fórmula: F = (9/5) * C + 32. Etapa 02 - Definición de la solución.

Resultado deseado:


Calcular y mostrar la temperatura en grados Fahrenheit. La temperatura en grados Celsius. La temperatura en grados Celsius será ingresada y almacenada en una variable (gradosCel), luego se realizará el cálculo de la temperatura en grados Fahrenheit de acuerdo a la siguiente fórmula: gradosFar = (9/5) * gradosCel + 32. El resultado será almacenado en una variable (gradosFar) para luego ser mostrado por pantalla.

Etapa 03 - Diseño de la lógica. Para solucionar el problema se desarrollarán las especificaciones del proyecto en UML y el algoritmo en pseudocódigo. 1. Nombre del Proyecto: ProyTemperatura. 2. Definición de Paquetes y desarrollo de Diagrama de Paquetes. Diagrama de paquetes

Pag. 119



Clases biblioteca


Algoritmo PrgTemperatura - método main ( ) ENTRADA: SALIDA:

gradosCel gradosFar

INICIO NUMERO gradosCel = 0, gradosFar = 0 LEER gradosCel gradosFar = ( 9 / 5 ) * gradosCel + 32 ESCRIBIR gradosFar FIN

Pag. 120



Clase PrgTemperatura package dominioDeLaAplicacion ; import biblioteca.Lectura ; class PrgTemperatura { public static void main ( String arg[] ) { double gradosCel = 0, gradosFar = 0 ; System.out.print ( “ Ingrese la temperatura en grados Celsius: " ) ; gradosCel = Lectura.leerDouble ( ) ; gradosFar = ( 9 / 5 ) * gradosCel + 32 ; System.out.println ( “ La temperatura en grados Fahrenheit es: " + gradosFar) ; } }

Pag. 121


Problema 07 Etapa 01 - Descripción del problema. Leer el costo de un artículo y su precio de venta. Calcular y mostrar su utilidad. Etapa 02 - Definición de la solución.

Resultado deseado: Datos necesarios: Procesamiento:

Calcular y mostrar la utilidad de un artículo. El costo y el precio de venta del artículo. El costo y el precio de venta del artículo serán ingresados y almacenados en variables (costo, precioVta), luego se realizará el cálculo de la utilidad del artículo de acuerdo a la siguiente fórmula: utilidad = precioVta - costo El resultado será almacenado en una variable (utilidad) para luego ser mostrado por pantalla.

Etapa 03 - Diseño de la lógica. Para solucionar el problema se desarrollarán las especificaciones del proyecto en UML y el algoritmo en pseudocódigo. 1. Nombre del Proyecto: ProyUtilidad. 2. Definición de Paquetes y desarrollo de Diagrama de Paquetes. Diagrama de paquetes

Pag. 122



Clases biblioteca


Algoritmo PrgUtilidad - método main ( ) ENTRADA: SALIDA:

costo, precioVta utilidad

INICIO NUMERO costo = 0, precioVta = 0, utilidad = 0 LEER costo, precioVta utilidad = precioVta - costo ESCRIBIR utilidad FIN

Pag. 123



Clase PrgUtilidad package dominioDeLaAplicacion ; import biblioteca.Lectura ; class PrgUtilidad { public static void main ( String arg[] ) { double costo = 0, precioVta = 0, utilidad = 0 ; System.out.print ( “ Ingrese el costo del artículo: ” ) ; costo = Lectura.leerDouble ( ) ; System.out.print ( “ Ingrese el precio de venta del artículo: ” ) ; precioVta = Lectura.leerDouble ( ) ; utilidad = precioVta - costo ; System.out.println ( “ La utilidad del artículo es: s/. ” + utilidad + “ soles ” ) ; } }

Pag. 124


Problema 08 Etapa 01 - Descripción del problema. Calcular y mostrar la nota final (nf) de un alumno, sabiendo que se tienen sólo dos notas. Si el alumno obtiene una nota final mayor a 13 se deberá visualizar un mensaje de felicitaciones. Etapa 02 - Definición de la solución.

Resultado deseado:


Mostrar nota final y un mensaje de felicitaciones si la nota final es mayor a 13. Las dos notas del alumno. Las notas se ingresarán por el teclado y serán almacenadas en variables (nota1 y nota2), luego se realizará el cálculo de la nota final: nf = ((nota1 + nota2) / 2) El resultado se almacena en una variable (nf). Si la nota final resulta mayor que 13 entonces se almacenará el mensaje “Felicitaciones” en una variable (mensaje). Finalmente, se muestra la nota final y el mensaje.

Etapa 03 - Diseño de la lógica. Para solucionar el problema se desarrollarán las especificaciones del proyecto en UML y el algoritmo en pseudocódigo. 1. Nombre del Proyecto: ProyNotaFinal2. 2. Definición de Paquetes y desarrollo de Diagrama de Paquetes.


Pag. 125



Clases biblioteca


Algoritmo PrgNotaFinal2 - método main ( )

ENTRADA: nota1, nota2 SALIDA: nf, mensaje

INICIO NUMERO nota1 = 0, nota2 = 0, nf = 0 TEXTO mensaje = “ ” LEER nota1, nota2 nf = (nota1 + nota2) / 2 SI ( nf > 13 ) ENTONCES mensaje = “Felicitaciones” FINSI ESCRIBIR nf, mensaje FIN

Pag. 126



Clase PrgNotaFinal2

package dominioDeLaAplicacion ; import biblioteca.Lectura ; class PrgNotaFinal2 { public static void main ( String arg[] ) { double nota1 = 0, nota2 = 0, nf = 0 ; String mensaje = “ ” ; System.out.print ( “ Ingrese la primera nota: ” ) ; nota1 = Lectura.leerDouble ( ) ; System.out.print ( “ Ingrese la segunda nota: ” ) ; nota2 = Lectura.leerDouble ( ) ; nf = (nota1 + nota2) / 2 ; if (nf > 13) { mensaje = “ Felicitaciones ” ; } System.out.println ( “ La nota final es: ” + nf + “ ” + mensaje ) ; } }

Pag. 127


Problema 09 Etapa 01 - Descripción del problema. Calcular y mostrar el sueldo de un trabajador conociendo el número de horas trabajadas y su tarifa horaria, sabiendo que se debe descontar un 10% del sueldo por concepto de impuestos si este es mayor de S/. 3000. Etapa 02 - Definición de la solución.


Mostrar el sueldo de un trabajador. El total de horas trabajadas y la tarifa horaria. El total de horas trabajadas y la tarifa horaria se ingresarán por teclado y se almacenarán en variables (horas y tarifa), luego se realizará el cálculo del sueldo utilizando la siguiente operación: sueldo = horas * tarifa El resultado se almacenará en una variable (sueldo). Si el sueldo resulta mayor que S/.3000 entonces se calcula el sueldo a cobrar restando el 10% del sueldo. El resultado se almacena en la variable sueldo y se muestra a través de la pantala.

Etapa 03 - Diseño de la lógica. Para solucionar el problema se desarrollarán las especificaciones del proyecto en UML y el algoritmo en pseudocódigo. 1. Nombre del Proyecto: ProySueldoTrabajador. 2. Definición de Paquetes y desarrollo de Diagrama de Paquetes. Diagrama de paquetes

Pag. 128



Clases biblioteca


Algoritmo PrgSueldoTrabajador - método main ( )

ENTRADA: SALIDA:

horas, tarifa sueldo

INICIO NUMERO horas = 0, tarifa = 0, sueldo = 0 LEER horas, tarifa sueldo = horas * tarifa SI ( sueldo > 3000 ) ENTONCES sueldo = sueldo * 0.9 FINSI ESCRIBIR sueldo FIN

Pag. 129



Clase PrgSueldoTrabajador package dominioDeLaAplicacion ; import biblioteca.Lectura ; class PrgSueldoTrabajador { public static void main ( String arg[] ) { int horas = 0 ; double tarifa = 0, sueldo = 0 ; System.out.print ( “ Ingrese el total de horas trabajadas: ” ) ; horas = Lectura.leerInt ( ) ; System.out.print ( “ Ingrese la tarifa del trabajador: ” ) ; tarifa = Lectura.leerDouble ( ) ; sueldo = horas * tarifa ; if (sueldo > 3000) { sueldo = sueldo * 0.9 ; } System.out.println ( “ El sueldo es: ” + sueldo ) ; } }

Pag. 130


Problema 10 Etapa 01 - Descripción del problema. 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/.500 nuevos soles se aplica un descuento de 8%, caso contrario el descuento será de 2%. Etapa 02 - Definición de la solución.


Mostrar monto total a pagar. Monto total. El monto total será almacenado en una variable (montoTotal). 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). Si el monto total resulta mayor a S/.500 nuevos soles, se descuenta el 8%, sino sólo se descontará el 2%.

Etapa 03 - Diseño de la lógica. Para solucionar el problema se desarrollarán las especificaciones del proyecto en UML y el algoritmo en pseudocódigo. 1. Nombre del Proyecto: ProyArticulos. 2. Definición de Paquetes y desarrollo de Diagrama de Paquetes. Diagrama de paquetes

Pag. 131



Clases biblioteca

4. Diseño de algoritmo para el método principal. Algoritmo PrgArticulos - método main ( )

ENTRADA: SALIDA:

montoTotal montoPago

INICIO NUMERO montoTotal = 0, montoPago = 0 LEER montoTotal montoPago = montoTotal * 1.18 SI ( montoPago > 500 ) ENTONCES montoPago = montoPago * 0.92 SINO montoPago = montoPago * 0.98 FINSI ESCRIBIR montoPago FIN

Pag. 132



Clase PrgArticulos package dominioDeLaAplicacion ; import biblioteca.Lectura ; class PrgArticulos { public static void main ( String arg[] ) { double montoTotal = 0, montoPago = 0 ; System.out.print ( “ Ingrese el monto total: ” ) ; montoTotal = Lectura.leerDouble ( ) ; montoPago = montoTotal * 1.18 ; if (montoPago > 500) { montoPago = montoPago * 0.92 ; } else { montoPago = montoPago * 0.98 ; } System.out.print ( “ El monto total a pagar incluido IGV y descuentos es: ” ) ; System.out.println ( montoPago + “ soles ” ) ; } }

Pag. 133


Problema 11 Etapa 01 - Descripción del problema. Leer la categoría y el sueldo de un trabajador, y calcular el aumento correspondiente teniendo en cuenta la siguiente tabla. Muestrar el nuevo sueldo del trabajador. Categoría 1 2 3 4

Aumento 25 % 15 % 10 % 05 %

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


Mostrar nuevo sueldo del trabajador. La categoría y el sueldo del trabajador. La categoría y el sueldo del trabajador serán almacenados en variables (categoria y sueldo). Dependiendo la categoría ingresada, se procederá a calcular el nuevo sueldo del trabajador (nuevoSueldo), teniendo como base la tabla mostrada. Finalmente, se mostrará el nuevo sueldo del trabajador.

Etapa 03 - Diseño de la lógica. Para solucionar el problema se desarrollarán las especificaciones del proyecto en UML y el algoritmo en pseudocódigo. 1. Nombre del Proyecto: ProyAumentoSueldo. 2. Definición de Paquetes y desarrollo de Diagrama de Paquetes. Diagrama de paquetes

Pag. 134



Clases biblioteca

4. Diseño de algoritmo para el método principal. Algoritmo PrgAumentoSueldo - método main ( ) ENTRADA: SALIDA:

categoria, sueldo nuevoSueldo

INICIO NUMERO categoria = 0, sueldo = 0, nuevoSueldo = 0 LEER sueldo, categoria CUANDO categoria SEA CASO 1 : nuevoSueldo = sueldo * 1.25 TERMINAR CASO 2 : nuevoSueldo = sueldo * 1.15 TERMINAR CASO 3 : nuevoSueldo = sueldo * 1.10 TERMINAR CASO 4 : nuevoSueldo = sueldo * 1.05 TERMINAR OTROS : nuevoSueldo = sueldo FINCUANDO ESCRIBIR nuevoSueldo FIN

Pag. 135



Clase PrgAumentoSueldo package dominioDeLaAplicacion ; import biblioteca.Lectura ; class PrgAumentoSueldo { public static void main ( String arg[] ) { double sueldo = 0, nuevoSueldo = 0 ; int categoria = 0; System.out.print ( “ Ingrese el sueldo del trabajador: ” ) ; sueldo = Lectura.leerDouble ( ) ; System.out.print ( “ Ingrese la categoría del trabajador: ” ) ; categoria = Lectura.leerInt ( ) ; switch (categoria) { case 1: nuevoSueldo = sueldo * 1.25 ; break ; case 2: nuevoSueldo = sueldo * 1.15 ; break ; case 3: nuevoSueldo = sueldo * 1.10 ; break ; case 4: nuevoSueldo = sueldo * 1.05 ; break ; default: nuevoSueldo = sueldo ; } System.out.println ( “ El nuevo sueldo del trabajador es: ” + nuevoSueldo ) ; } }

Pag. 136


Problema 12 Etapa 01 - Descripción del problema. Calcular y mostrar el costo total que representa un paciente para un hospital de acuerdo al tipo de enfermedad, según los datos de la tabla. 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. Enfermedad Tipo 1 2 3

Costo / Paciente / Día 200 350 420


Resultado deseado:

Datos necesarios:

Procesamiento:

Mostrar el costo total de un paciente para un hospital. El tipo de enfermedad, el número de días de permanencia del paciente y su sexo. El 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, dias y sexo). Dependiendo del tipo de enfermedad, se procederá hacer el cálculo del costo que representa para el hospital el paciente, de acuerdo a la siguiente operación costoTotal = ( costo * número de días). Si se trata del primer tipo de enfermedad y el paciente es mujer se le incrementará el 10%. Por otro lado, si se trata del tercer tipo de enfermedad y el paciente es hombre se procederá a incrementar el 5%. El resultado se almacena en una variable (costoTotal) para luego ser mostrado.

Pag. 137


Etapa 03 - Diseño de la lógica. Para solucionar el problema se desarrollarán las especificaciones del proyecto en UML y el algoritmo en pseudocódigo.

1. Nombre del Proyecto: ProyHospital. 2. Definición de Paquetes y desarrollo de Diagrama de Paquetes.



Clases biblioteca

Pag. 138



Algoritmo PrgHospital - método main ( )

ENTRADA: SALIDA:

tipoEnfermedad, dias, sexo costoTotal

INICIO NUMERO tipoEnfermedad = 0, dias = 0, sexo = 0, costoTotal = 0 LEER tipoEnfermedad, dias, sexo CUANDO tipoEnfermedad SEA CASO 1 : costoTotal = 200 * dias SI (sexo = 2 ) ENTONCES costoTotal = costoTotal * 1.10 FINSI TERMINAR CASO 2 : costoTotal = 350 * dias TERMINAR CASO 3 : costoTotal = 420 * dias SI ( sexo = 1 ) ENTONCES costoTotal = costoTotal * 1.05 FINSI FINCUANDO ESCRIBIR costoTotal FIN

Pag. 139



Clase PrgHospital package dominioDeLaAplicacion ; import biblioteca.Lectura ; class PrgHospital { public static void main ( String arg[] ) { int tipoEnfermedad = 0, dias = 0, sexo = 0 ; double costoTotal = 0 ; System.out.print ( “ Ingrese el tipo de enfermedad: ” ) ; tipoEnfermedad = Lectura.leerInt ( ) ; System.out.print ( “ Ingrese el sexo del paciente [1=hombre, 2= Mujer]: ” ) ; sexo = Lectura.leerInt ( ) ; System.out.print ( “ Ingrese el número de días que ha estado el paciente: ” ) ; dias = Lectura.leerInt ( ) ; switch ( tipoEnfermedad) { case 1 : costoTotal = 200 * dias ; if ( sexo == 2 ) { costoTotal = costoTotal * 1.10 ; } break ; case 2 : costoTotal = 350 * dias ; break ; case 3 : costoTotal = 420 * dias ; if ( sexo == 1 ) { costoTotal = costoTotal * 1.05 ; } } System.out.println ( “ El costo total es: ” + costoTotal ) ; } }

Pag. 140


Problema 13 Etapa 01 - Descripción del problema. Ingresar tres notas de un alumno. Muestrar las notas ordenadas en forma ascendente. Etapa 02 - Definición de la solución.


Mostrar las tres notas en forma ascendente. Las tres notas del alumno en cualquier orden. Las tres notas del alumno serán almacenadas en variables (n1, n2 y n3). Se utilizarán tres variables auxiliares para almacenar el orden de las notas (menor, intermedio y mayor). Finalmente, las variables auxiliares mayor, intemedio y menor almacenarán las notas y se mostrarán en orden ascendente.

Etapa 03 - Diseño de la lógica. 1. Nombre del Proyecto: ProyOrdena. 2. Definición de Paquetes y desarrollo del Diagrama de Paquetes. Diagrama de paquetes


Clases biblioteca

Pag. 141



Algoritmo PrgOrdena - método main ( ) ENTRADA: SALIDA:

n1, n2, n3 menor, intermedio, mayor

INICIO NUMERO n1 = 0, n2 = 0, n3 = 0, menor = 0, intermedio = 0 NUMERO mayor = 0 LEER n1, n2, n3 SI (n1 > n2) ENTONCES SI (n1 > n3) ENTONCES mayor = n1 SI (n2 > n3) ENTONCES intermedio = n2 menor = n3 SINO intermedio = n3 menor = n2 FINSI SINO mayor = n3 intermedio = n1 menor = n2 FINSI SINO SI (n2 > n3) ENTONCES mayor = n2 SI (n1 > n3) ENTONCES intermedio = n1 menor = n3 SINO intermedio = n3 menor = n1 FINSI SINO mayor = n3 intermedio = n2 menor = n1 FINSI FINSI ESCRIBIR menor, intermedio, mayor FIN

Pag. 142


Etapa 04 - Desarrollo de la Codificación.

Clase PrgOrdena package dominioDeLaAplicacion ; import biblioteca.Lectura ; class PrgOrdena { public static void main ( String arg[] ) { int n1 = 0, n2 = 0, n3 = 0, menor = 0, intermedio = 0, mayor = 0 ; System.out.print ( “ Ingrese la primera nota: ” ) ; n1 = Lectura.leerInt ( ) ; System.out.print ( “ Ingrese la segunda nota: ” ) ; n2 = Lectura.leerInt ( ) ; System.out.print ( “ Ingrese la tercera nota: ” ) ; n3 = Lectura.leerInt ( ) ; if (n1 > n2) { if (n1 > n3) { mayor = n1 ; if (n2 > n3) { intermedio = n2 ; menor = n3 ; } else { intermedio = n3 ; menor = n2 ; } } else { mayor = n3 ; intermedio = n1 ; menor = n2 ; } } else { if (n2 > n3) { mayor = n2 ; if ( n1 > n3) { intermedio = n1 ; menor = n3 ; } else { intermedio = n3 ; menor = n1 ; } } else { mayor = n3 ; intermedio = n2 ; menor = n1 ; } } System.out.println ( menor + “ ” + intermedio + “ ” + mayor ) ; } }

Pag. 143


Problema 14 Etapa 01 - Descripción del problema. Un curso se evalúa de la siguiente forma: se toma cinco prácticas calificadas, se determina el promedio de las cuatro notas más altas y se le da al estudiante una categoría que puede ser A, B, C o D. 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.


Resultado deseado:

Mostrar la categoría del alumno.

Datos necesarios:

Las cinco notas del estudiante.

Procesamiento:

Las cinco notas del estudiante se ingresan a través del teclado y se almacenan en variables (n1, n2, n3, n4 y n5). La menor de estas notas se guardará en una variable (notaMenor). La suma de las cinco notas se guardará en una variable (sumaNotas). Se realizará el cálculo del promedio del alumno de la siguiente forma: promedio = ( sumaNotas – notaMenor ) / 4 ). El resultado es almacenado en la variable (promedio), este resultado nos permitirá obtener la categoría del alumno (categoria), para luego ser mostrada por pantalla.

Pag. 144


Etapa 03 - Diseño de la lógica. 1. Nombre del Proyecto: ProyCategoriaAlumno. 2. Definición de Paquetes y desarrollo del Diagrama de Paquetes.



Clases biblioteca

Pag. 145



Algoritmo PrgCategoriaAlumno - método main ( ) ENTRADA: SALIDA:

n1, n2, n3, n4, n5 categoria

INICIO NUMERO n1 = 0, n2 = 0, n3 = 0, n4 = 0, n5 = 0, sumaNotas = 0 NUMERO notaMenor = 0, promedio = 0 TEXTO categoria = ‘ ’ LEER n1, n2, n3, n4, n5 sumaNotas = n1 + n2 + n3 + n4 + n5 notaMenor = n1 SI (notaMenor>n2) ENTONCES notaMenor = n2 FINSI SI (notaMenor > n3) ENTONCES notaMenor = n3 FINSI SI (notaMenor > n4) ENTONCES notaMenor = n4 FINSI SI (notaMenor > n5) ENTONCES notaMenor = n5 FINSI promedio = (sumaNotas - notaMenor) / 4 SI (promedio <= 20 AND promedio >= 17) ENTONCES categoria = ‘A’ SINO SI (promedio <= 16 AND promedio >= 14) ENTONCES categoria = ‘B’ SINO SI (promedio <= 13 AND promedio >= 10) ENTONCES categoria = ‘C’ SINO SI (promedio<=10 AND promedio>=0) ENTONCES categoria = ‘D’ FINSI FINSI FINSI FINSI ESCRIBIR categoria FIN

Pag. 146


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

Pag. 147


Problema 15 Etapa 01 - Descripción del problema. En una oficina de empleados, categorizan a los postulantes en función del sexo y de la edad, de acuerdo a lo siguiente: - Si la persona es de sexo femenino: o Categoría FA si tienen menos de 23 años. o Categoría FB en caso contrario. - Si la persona es de sexo masculino: o Categoría MA si tiene menos de 25 años. o Categoría MB en caso contrario. Etapa 02 - Definición de la solución.


Mostrar la categoría del postulante. El sexo y la edad del postulante. El sexo y la edad del postulante se ingresan a través del teclado y se almacenan en variables (sexo y edad). Si es hombre o mujer asignaremos su respectiva categoría dependiendo de la edad del postulante. El resultado es almacenado en una variable (categoria) para luego ser mostrada por pantalla.

Etapa 03 - Diseño de la lógica. 1. Nombre del Proyecto: ProyCategoriaPostulante. 2. Definición de Paquetes y desarrollo del Diagrama de Paquetes. Diagrama de paquetes

Pag. 148



Clases biblioteca

4. Diseño de algoritmo para el método principal. Algoritmo PrgCategoriaPostulante - método main ( ) ENTRADA: SALIDA:

sexo, edad categoria

INICIO NUMERO edad = 0 TEXTO sexo = ‘F’, categoria = 0 LEER sexo, edad CUANDO sexo SEA CASO ‘f’: CASO ‘F’: SI (edad < 23) ENTONCES categoria = “FA” SINO categoria = “FB” FINSI TERMINAR CASO ‘m’: CASO ‘M’: SI (edad < 25) ENTONCES categoria = “MA” SINO categoria = “MB” FINSI FINCUANDO ESCRIBIR categoria FIN

Pag. 149



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

Pag. 150


Problema 16 Etapa 01 - Descripción del problema. 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. Utilizar la estructura lógica MIENTRAS. Etapa 02 - Definición de la solución.

Resultado deseado:

Datos necesarios:

Procesamiento:

Mostrar la nota final de todos los alumnos de un curso. 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, n3 y n4). Se realizará el cálculo de la nota final en base a la fórmula: nf = ( n1 + n2 + n3 + ( n4 * 2 ) ) / 5. El resultado es almacenado en la variable (nf) para luego ser mostrada. Esto se repite para todos los alumnos del curso, con la finalidad de poder mostrar la nota final de cada uno de ellos.

Etapa 03 - Diseño de la lógica. 1. Nombre del Proyecto: ProyNotasAlumnos. 2. Definición de Paquetes y desarrollo del Diagrama de Paquetes. Diagrama de paquetes

Pag. 151



Clases biblioteca


Algoritmo PrgNotasAlumnos - método main ( )

ENTRADA: numAlumnos, n1, n2, n3, n4 SALIDA: nf INICIO NUMERO i = 1, n1 = 0, n2 = 0, n3 = 0, n4 = 0, nf = 0 NUMERO numAlumnos = 1 LEER numAlumnos MIENTRAS ( i <= numAlumnos ) LEER n1, n2, n3, n4 nf = ( n1 + n2 + n3 + ( n4 * 2 ) ) / 5 ESCRIBIR nf i=i+1 FINMIENTRAS FIN

Pag. 152



Clase PrgNotasAlumnos package dominioDeLaAplicacion ; import biblioteca.Lectura ; class PrgNotasAlumnos { public static void main ( String arg[] ) { int i = 1, numAlumnos = 0 ; double n1= 0, n2 = 0, n3 = 0, n4 = 0, nf = 0 ; System.out.println ( “Ingrese el número de alumnos: ” ) ; numAlumnos = Lectura.leerInt ( ) ; while ( i <= numAlumnos ) { System.out.println ( “ Ingrese nota 1 del alumno [” + i + “]: ” ) ; n1 = Lectura.leerDouble ( ) ; System.out.println ( “ Ingrese nota 2 del alumno [” + i + “]: ” ) ; n2 = Lectura.leerDouble ( ) ; System.out.println ( “ Ingrese nota 3 del alumno [” + i + “]: ” ) ; n3 = Lectura.leerDouble ( ) ; System.out.println ( “ Ingrese nota 4 del alumno [” + i + “]: ” ) ; n4 = Lectura.leerDouble ( ) ; nf = ( n1 + n2 + n3 + ( n4 * 2 ) ) / 5 ; System.out.println ( “ Nota final del alumno [” + i + “]: ” + nf ) ; i ++ ; } } }

Pag. 153


Problema 17 Etapa 01 - Descripción del problema. 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. Utilizar la estructura lógica HACER.


Resultado deseado:

Datos necesarios:

Procesamiento:

Mostrar la nota final de todos los alumnos de un curso. 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, n3 y n4). Se realizará el cálculo de la nota final sobre la base de la fórmula: nf = ( n1 + n2 + n3 + ( n4 * 2 ) ) / 5. El resultado es almacenado en la variable (nf) para luego ser mostrada. Esto se repite para todos los alumnos del curso con la finalidad de poder mostrar la nota final de cada uno de ellos.

Etapa 03 - Diseño de la lógica. 1. Nombre del Proyecto: ProyNotasAlumnos2. 2. Definición de Paquetes y desarrollo del Diagrama de Paquetes. Diagrama de paquetes

Pag. 154



Clases biblioteca

4. Diseño de algoritmo para el método principal. Algoritmo PrgNotasAlumnos2 - método main ( ) ENTRADA: n1, n2, n3, n4, continua SALIDA: nf INICIO NUMERO i = 1, n1 = 0, n2 = 0, n3 = 0, n4 = 0, nf = 0 TEXTO continua = ‘ ’ HACER LEER n1, n2, n3, n4 nf = ( n1 + n2 + n3 + ( n4 * 2 ) ) / 5 ESCRIBIR nf LEER continua i=i+1 MIENTRAS ( continua = ‘s’ OR continua = ‘S’ ) FIN

Pag. 155



Clase PrgNotasAlumnos2 package dominioDeLaAplicacion ; import biblioteca.Lectura ; class PrgNotasAlumnos2 { public static void main ( String arg[] ) { int i = 1 ; double n1 = 0, n2 = 0, n3 = 0, n4 = 0, nf = 0 ; char continua = ‘ ’ ; do { System.out.println ( “ Ingrese nota 1 del alumno [” + i + “]: ” ) ; n1 = Lectura.leerDouble ( ) ; System.out.println ( “ Ingrese nota 2 del alumno [” + i + “]: ” ) ; n2 = Lectura.leerDouble ( ) ; System.out.println ( “ Ingrese nota 3 del alumno [” + i + “]: ” ) ; n3 = Lectura.leerDouble ( ) ; System.out.println ( “ Ingrese nota 4 del alumno [” + i + “]: ” ) ; n4 = Lectura.leerDouble ( ) ; nf = ( n1 + n2 + n3 + ( n4 * 2 ) ) / 5 ; System.out.println ( “ Nota final del alumno [” + i + “]: ” + nf ) ; System.out.println ( “ Desea continuar (s/n): ” ) ; continua = Lectura.leerChar ( ) ; i++ ; } while ( continua == ‘s’ || continua == ‘S’ ) ; } }

Pag. 156


Problema 18 Etapa 01 - Descripción del problema. Determinar la suma de sueldos de los obreros (categoría 1), 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. Adicionalmente, determinar cuál es el mayor y el menor sueldo en la empresa. Etapa 02 - Definición de la solución.

Resultado deseado:

Datos necesarios:

Procesamiento:

La suma de sueldos de los obreros, la suma de sueldos de los empleados y la suma de sueldos de los gerentes. Adicionalmente el sueldo mayor y el sueldo menor. El sueldo y la categoría de cada uno de los trabajadores de la empresa. El sueldo y la categoría de cada trabajador de la empresa se ingresarán a través del teclado y se almacenarán en las variables sueldo y categoria. Cada vez que se ingrese el sueldo de un trabajador se deberá verificar si es el sueldo mayor. Si el sueldo ingresado resulta ser el sueldo mayor, se almacenará en la variable mayorSueldo. De igual forma, se verificará si es el sueldo menor. Si el sueldo ingresado resulta ser el sueldo menor, se almacenará en la variable menorSueldo. También se evaluará la categoría del trabajador. Si resulta ser un obrero se suma su sueldo a la variable sueldo1, 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. Al finalizar el ingreso de los datos de todos los trabajadores de la empresa, se mostrará por pantalla el sueldo mayor (mayorSueldo), el sueldo menor (menorSueldo), la suma de sueldos de los obreros (sueldo1), la suma de sueldo de los empleados (sueldo2) y la suma de los sueldos de los gerentes (sueldo3).

Pag. 157


Etapa 03 - Diseño de la lógica. 1. Nombre del Proyecto: ProySueldoCategoria. 2. Definición de Paquetes y desarrollo del Diagrama de Paquetes. Diagrama de paquetes


Clases biblioteca

Pag. 158



Algoritmo PrgSueldoCategoria - método main ( ) ENTRADA: SALIDA:

sueldo, categoria sueldo1, sueldo2, sueldo3, mayorSueldo, menorSueldo

INICIO NUMERO sueldo = 0, categoria = 0, mayorSueldo = 0 NUMERO menorSueldo = 0, sueldo1 = 0, sueldo2 = 0 NUMERO sueldo3 = 0, i = 1 HACER LEER categoria SI (categoria <> 0) ENTONCES LEER sueldo SI (i = 1) ENTONCES i=0 mayorSueldo = sueldo menorSueldo = sueldo SINO SI ( sueldo < menorSueldo ) ENTONCES menorSueldo = sueldo FINSI SI (sueldo > mayorSueldo) ENTONCES mayorSueldo = sueldo FINSI FINSI CUANDO categoria SEA CASO 1: sueldo1 = sueldo1 + sueldo TERMINAR CASO 2: sueldo2 = sueldo2 + sueldo TERMINAR CASO 3: sueldo3 = sueldo3 + sueldo FINCUANDO FINSI MIENTRAS ( categoria <> 0 ) ESCRIBIR sueldo1, sueldo2, sueldo3 ESCRIBIR menorSueldo, mayorSueldo FIN

Pag. 159



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

Pag. 160


Problema 19 Etapa 01 - Descripción del problema. Calcular y mostrar el número de alumnos que tienen promedio final menor que 10, los alumnos que tiene promedio final entre 10 y 14, los alumnos que tienen promedio final entre 15 y 18, y los alumnos que tienen promedio final mayor que 18. 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. Etapa 02 - Definición de la solución.

Resultado deseado:

Datos necesarios:

Procesamiento:

Mostrar el número de alumnos con promedio final menor que 10, el número de alumnos con promedio final entre 10 y 14, el número de alumnos con promedio final entre 15 y 18, y el número de alumnos con promedio final mayor que 18. Las cuatro notas de cada uno de los alumnos del curso. Las cuatro notas del alumno se ingresan y se almacenan en las variables n1, n2, n3 y n4. Se realiza el cálculo del promedio final en base a la fomula: nf = ( n1 + n2 + n3 + ( n4 * 2 ) ) / 5. El resultado es almacenado en la variable nf, para ser evaluada. Si el promedio final (nf) es menor que 10 se aumenta 1 a la variable total1. Si el promedio final (nf) está entre 10 y 14 se aumenta 1 a la variable total2. 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. Este proceso se repite para todos los alumnos del curso con la finalidad de determinar su promedio final (nf) y evaluar su rango.

Pag. 161


Etapa 03 - Diseño de la lógica. 1. Nombre del Proyecto: ProyNotasRango. 2. Definición de Paquetes y desarrollo del Diagrama de Paquetes. Diagrama de paquetes


Clases biblioteca

Pag. 162



Algoritmo PrgNotasRango - método main ( ) ENTRADA: SALIDA:

numAlumnos, n1, n2, n3, n4 total1, total2, total3, total4

INICIO NUMERO n1 = 0, n2 = 0, n3 = 0, n4 = 0, nf = 0, numAlumnos = 0 NUMERO i = 1, total1 = 0 , total2 = 0 , total3 = 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.5) ENTONCES total1 = total1 + 1 FINSI SI (nf >= 10.5 AND nf < 14.5) ENTONCES total2 = total2 + 1 FINSI SI (nf >= 14.5 AND nf < 17.5) ENTONCES total3 = total3 + 1 FINSI SI (nf >= 17.5) ENTONCES total4 = total4 + 1 FINSI i=i+1 FINMIENTRAS ESCRIBIR total1, total2, total3, total4 FIN

Pag. 163



Clase PrgNotasRango package dominioDeLaAplicacion ; import biblioteca.Lectura ; class PrgNotasRango { public static void main ( String arg[] ) { int i = 1, numAlumnos = 0 ; double n1= 0, n2= 0, n3= 0, n4= 0, nf= 0, total1 = 0, total2 = 0, total3 = 0, total4 = 0 ; System.out.println ( “ Ingrese el número de alumnos: ” ) ; numAlumnos = Lectura.leerInt ( ) ; while (i <= numAlumnos) { do { System.out.println ( “ Ingrese nota 1 del alumno [” + i + “]: n1 = Lectura.leerDouble ( ) ; } while ((n1 < 0 || n1 > 20) ; do { System.out.println ( “ Ingrese nota 2 del alumno [” + i + “]: n2 = Lectura.leerDouble ( ) ; } while ((n2 < 0 || n2 > 20) ; do { System.out.println ( “ Ingrese nota 3 del alumno [” + i + “]: n3 = Lectura.leerDouble ( ) ; } while (( n3 < 0 || n3 > 20 ) ; do { System.out.println ( “ Ingrese nota 4 del alumno [” + i + “]: n4 = Lectura.leerDouble ( ) ; } while (( n4 < 0 || n4 > 20 ) ;

”);

”);

”);

”);

nf = (n1 + n2 + n3 + ( n4 * 2) ) / 5 ; if (nf < 10.5) total1++ ; if (nf >= 10.5 && nf < 15.5) total2++ ; if (nf >= 15.5 && nf < 17.5) total3++ ; if (nf >= 17.5) total4++ ; i ++ ; } System.out.println ( “ Total alumnos con promedio menor a 10: ” + total1 ) ; System.out.println ( “ Total alumnos con promedio entre 10 y 14: ” + total2 ) ; System.out.println ( “ Total alumnos con promedio entre 15 y 18: ” + total3 ) ; System.out.println ( “ Total alumnos con promedio mayor a 18: ” + total4 ) ; } }

Pag. 164


Problema 20 Etapa 01 - Descripción del problema. Elaborar una solución que permita controlar la venta de boletos en un determinado día en un teatro de la capital, en base a la siguiente información: • Al comenzar, se leerá una sola vez el precio de entrada para palco, platea y mezanine. • Por cada entrada vendida se leerá los siguientes datos: número de boleto y lugar (puede ser platea, palco o mezanine). • El programa terminará cuando el número de boleto sea igual a cero. • Antes de finalizar, se deberá proporcionar la siguiente información: • Número total de entradas vendidas durante el día. • El total de soles recaudados en el día. • Número de entradas vendidas para platea, palco y mezanine en el día.


Resultado deseado:

Datos necesarios:

Procesamiento:

El número total de entradas vendidas, el monto total recaudado y el número de entradas vendidas para platea, palco y mezanine en un determinado día. El costo del boleto para platea, palco y mezanine en general, y por cada venta, el número de boleto y el tipo de boleto (es decir, si es para platea, palco o mezanine). El costo del boleto para platea, palco y mezanine se ingresarán a través del teclado y se almacenarán en las variables costoPla, costoPal y costoMez respectivamente. Cada vez que se venda un boleto se ingresará el número y tipo de boleto, y se almacenarán en las variables numBoleto y tipo respectivamente. Luego se evaluará el tipo de boleto. Si es un boleto para platea se aumenta 1 a la variable totalPla, 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. Al finalizar la venta de boletos se suma el valor de las variables totalPla, totalPal y totalMez para obtener el total de boletos vendidos (totalVendidas). De igual forma, cada variable (totalPla, totalPal y totalMez) se multiplica por el costo del boleto (costoPla, costoPal y costoMez) según corresponda, para obtener la ganancia en

Pag. 165


platea (gananciaPla), palco (gananciaPal) y mezanine (gananciaMez). La ganancia total (totalGanancia) se obtiene al sumar el valor de las variables ganaciaPla, gananciaPal y gananciaMez.

Etapa 03 - Diseño de la lógica. 1. Nombre del Proyecto: ProyTeatro. 2. Definición de Paquetes y desarrollo del Diagrama de Paquetes. Diagrama de paquetes


Clases biblioteca

Pag. 166


4. Diseño de algoritmo para el método principal. Algoritmo PrgTeatro - método main ( ) ENTRADA: SALIDA:

costoPla, costoPal, costoMez totalVendidas, totalGanancia, totalPla, totalPal, totaMez

INICIO NUMERO numBoleto = 0, tipo = 0, totalVendidas = 0 NUMERO totalPla = 0, totalPal = 0, totalMez = 0 NUMERO costoPla = 0, costoPal = 0, costoMez = 0 NUMERO totalGanancia =0, gananciaPla = 0, gananciaPal = 0 NUMERO ganaciaMez = 0 LEER costoPla, costoPal, costoMez HACER HACER LEER numBoleto MIENTRAS ( numBoleto < 0) SI ( numBoleto <> 0 ) ENTONCES HACER LEER tipo MIENTRAS (tipo < 1 OR tipo >3) CUANDO tipo SEA CASO 1 : totalPla = totalPla + 1 TERMINAR CASO 2 totalPal = totalPal + 1 TERMINAR CASO 3 totalMez = totalMez + 1 FINCUANDO MIENTRAS (numBoleto <> 0) totalVendidas = totalPla + totalPal + totalMez ganaciaPla = totalPla * costoPla ganaciaPal = totalPal * costoPal ganaciaMez = totalMez * costoMez totalGanancia = gananciaPla + gananciaPal + gananciaMez ESCRIBIR totalVendidas ESCRIBIR totalGanancia ESCRIBIR totalPla, totalPal, totalMez FIN

Pag. 167


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

Pag. 168


Problema 21 Etapa 01 - Descripción del problema. Los empleados de una fábrica trabajan en tres turnos; mañana, tarde y noche. 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.00 soles por hora. La tarifa del turno noche es de S/ 10.00 soles por hora. En caso de ser un día domingo, 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.00 soles por concepto de movilidad.


Resultado deseado:

Datos necesarios:

Procesamiento:

Calcular y mostrar el jornal diario de cada empleado. El número de horas, el turno y el día que trabajó el empleado. El número de horas, el turno y el día del empleado se ingresan a través del teclado y se almacenan en variables (horas, turno y dia). Dependiendo del turno se obtiene la tarifa para luego hacer el cálculo del jornal de la siguiente forma: jornal = horas * tarifa ; El resultado es almacenado en una variable (jornal) para luego ser mostrada por pantalla. Este proceso se repite para cada uno de los empleados de la fábrica.

Pag. 169


Etapa 03 - Diseño de la lógica. 1. Nombre del Proyecto: ProyJornal. 2. Definición de Paquetes y desarrollo del Diagrama de Paquetes. Diagrama de paquetes


Clases biblioteca

Pag. 170


4. Diseño de algoritmo para el método principal. Algoritmo PrgJornal - método main ( ) ENTRADA: SALIDA:

numEmpleados, horas, turno, dia jornal

INICIO NUMERO numEmpleados = 0, i = 0, horas = 0, dia = 0, turno = 0 NUMERO tarifa = 0, jornal = 0 HACER LEER numEmpleados SI (numEmpleados <= 0) ENTONCES ESCRIBIR “ Número empleados mayor a 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. ” FINSI MIENTRAS (horas <= 0) HACER LEER dia SI (dia < 1 OR dia > 7) ENTONCES ESCRIBIR “ La opción no es válida. ” FINSI MIENTRAS (dia < 1 OR dia > 7) HACER LEER turno CUANDO turno SEA: CASO 1: CASO 2: SI (dia = 7) ENTONCES tarifa = 1.5 * 8 SINO tarifa = 8 FINSI TERMINAR CASO 3: SI (dia = 7) ENTONCES tarifa = 1.6 * 10 SINO tarifa = 10 FINSI TERMINAR OTROS ESCRIBIR “opción no válida” FINCUANDO MIENTRAS (turno <>1 AND turno <>2 AND turno <>3)

Pag. 171


Continúa… 4. Diseño de algoritmo para el método principal. Algoritmo PrgJornal - método main ( ) SI (turno = 2) ENTONCES jornal = horas * tarifa + 10 SINO jornal = horas * tarifa FINSI ESCRIBIR jornal FINMIENTRAS FIN

Etapa 04 - Desarrollo de la Codificación. Clase PrgJornal package dominioDeLaAplicacion ; import biblioteca.Lectura ; class PrgJornal { public static void main ( String arg[] ) { int numEmpleados = 0, i = 0, horas = 0, dia = 0, turno = 0 ; double tarifa = 0, jornal = 0 ; do { System.out.print ( “ Ingrese el número de empleados: ”) ; numEmpleados = Lectura.leerInt ( ) ; if (numEmpleados <= 0) System.out.println ( “ El número de empleados debe ser mayor a 0 ” ) ; } while (numEmpleados <= 0) ; while ( i < numEmpleados ) { i++ ; do { System.out.print ( “ Ingrese horas trabajadas empleado [” + i + “]: ” ) ; horas = Lectura.leerInt ( ) ; if (horas <= 0 ) System.out.println ( “ Número de horas mayor a 0 ” ) ; } while (horas <= 0) ;

Pag. 172


Continúa…

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

} } }

Pag. 173


Problema 22 Etapa 01 - Descripción del problema. 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 - Definición de la solución.

Resultado deseado:

Datos necesarios:

Procesamiento:

Número de alumnas matriculadas, menores de 20 años y desaprobadas; además número de alumnos matriculados, mayores de 18 años y aprobados. Sexo, edad y nota de cada uno de los alumnos del curso, así como una variable que determine si se continúa o no con el ingreso de los datos de un nuevo alumno. El sexo, la edad y la nota de cada alumno se ingresarán a través del teclado y se almacenarán en variables (sexo, edad y nota). Si es una alumna o es un alumno incrementaremos las variables correspondientes (matriculadas y matriculados), por cada alumna menor de 20 años o cada alumno mayor de 18 años incrementaremos las variables correspondientes (menores y mayores) y por cada alumna desaprobada o cada alumno aprobado incrementaremos las variables correspondientes (desaprobadas y aprobados) para luego mostrarlos por pantalla. Este proceso se repetirá mientras el usuario confirme su deseo de ingresar los datos de otro alumno. Dicha respuesta será almacenada en una variable (rpta).

Pag. 174


Etapa 03 - Diseño de la lógica. 1. Nombre del Proyecto: ProyClase. 2. Definición de Paquetes y desarrollo del Diagrama de Paquetes. Diagrama de paquetes


Clases biblioteca

Pag. 175


4. Diseño de algoritmo para el método principal. Algoritmo PrgClase - método main ( ) ENTRADA: SALIDA:

sexo, edad, nota, rpta matriculadas, matriculados, menores, mayores, desaprobadas, aprobados

INICIO NUMERO i = 0, edad = 0, nota = 0, matriculadas = 0, matriculados = 0 NUMERO menores = 0, mayores = 0, desaprobadas = 0, aprobados = 0 TEXTO sexo = ‘F’, 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. ” 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. ” FINSI MIENTRAS (edad <= 0) HACER LEER nota SI (nota < 0 OR nota > 20) ENTONCES ESCRIBIR “ La nota no es válida. ” FINSI MIENTRAS (nota < 0 OR nota > 20) CUANDO sexo SEA: CASO ‘f’: CASO ‘F’: matriculadas = matriculadas + 1 SI (edad < 20) ENTONCES menores = menores + 1 FINSI SI (nota < 11) ENTONCES desaprobadas = desaprobadas + 1 FINSI TERMINAR

Pag. 176


Continúa…


Algoritmo PrgClase - 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. ” 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. 177


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

Pag. 178


Continúa…


Clase PrgClase case ‘m’ : case ‘M’ : matriculados += 1 ; if (edad > 18) mayores += 1 ; if (nota > 10) aprobados += 1 ; } do { System.out.println ( “ ¿Desea ingresar un nuevo alumno [S/N]?: ” ) ; rpta = Lectura.leerChar ( ) ; if ( rpta != ‘s’ && rpta != ‘S’ && rpta != ‘n’ && rpta != ‘N ’ ) System.out.println ( “Respuesta no válida.” ) ; } while ( rpta != ‘s’ && rpta != ‘S’ && rpta != ‘n’ && rpta != ‘N’ ) ; } while ( rpta == ‘s’ || rpta == ‘S’ ) ; System.out.println ( “Hay ” + matriculadas + “ alumna(s) matriculada(s). ”) ; System.out.println ( “Hay ” + matriculados + “ alumno(s) matriculado(s). ”) ; System.out.println ( “Hay ” + menores + “ alumna(s) menor(es) de 20 años. ” ) ; System.out.println ( “Hay ” + mayores + “ alumno(s) mayor(es) de 18 años. ” ) ; System.out.println ( “Hay ” + desaprobadas + “ alumna(s) desaprobada(s). ” ) ; System.out.println ( “Hay ” + aprobados + “ alumno(s) aprobado(s). ” ) ; } }

Pag. 179


Pag. 180


Problema 23 Etapa 01 - Descripción del problema. Desarrollar una solución que permita ingresar un número por teclado. Mostrar el número con las cifras invertidas, el número de cifras que tiene el número, la suma de las cifras, el número de cifras pares e impares, y si el número es capicua o no. Etapa 04 - Desarrollo de la Codificación. Clase PrgNumCifras package dominioDeLaAplicacion ; import biblioteca.Lectura ; class PrgNumCifras { public static void main ( String arg [ ] ) { int num = 0, numInv = 0, res = 0, cont = 0, suma = 0, contPar = 0, contImp = 0, n ; System.out.println ( “ Ingrese un número entero: ” ) ; num = Lectura.leerInt ( ) ; n = num ; while ( n != 0 ) { res = n % 10 ; numInv = numInv * 10 + res ; cont ++ ; suma = suma + res ; if ( res % 2 == 0 ) contPar ++ ; else contImp ++ ; n = n / 10 ; } System.out.println ( “ El número invertido es : ” + numInv ) ; System.out.println ( “ El número de cifras es : ” + cont ) ; System.out.println ( “ La suma de las cifras es : ” + suma ) ; System.out.println ( “ El número de cifras pares es : ” + contPar ) ; System.out.println ( “ El número de cifras impares es : ” + contImp ) ; if ( num == numInv ) System.out.println ( “ El número es capicua ” ) ; else System.out.println ( “ El número no es capicua ” ) ; } }

En base al análisis de la codificación desarrolle la Etapa 02 y la Etapa 03 del método.

Pag. 181


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

Pag. 182


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

Pag. 183


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

Pag. 184


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

Pag. 185


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

Pag. 186


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

Pag. 187


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

Pag. 188


Clase PrgNumALetras01 case 2 : letra = dos ; break ; case 3 : letra = tres ; break ; case 4 : letra = cuatro ; break ; case 5 : letra = cinco ; break ; case 6 : letra = seis ; break ; case 7 : letra = siete ; break ; case 8 : letra = ocho ; break ; case 9 : letra = nueve ; break ; } switch ( dec ) { case 1 : switch ( uni ) { case 0 : letra = diez ; break ; case 1 : letra = once ; break ; case 2 : letra = doce ; break ; case 3 : letra = trece ; break ; case 4 : letra = catorce ; break ; case 5 : letra = quince ; break ; default : letra = dieci + letra ; } break ;

Pag. 189


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

Pag. 190


Problema 27 Etapa 01 - Descripción del problema. En base al programa anterior, desarrollar otro programa que permita ingresar un número entero menor que 1000 y permita mostrar su equivalente en letras. Etapa 04 - Desarrollo de la Codificación.

Clase PrgNumALetras02 package dominioDeLaAplicacion ; import biblioteca.Lectura ; class PrgNumALetras02 { public static void main ( String arg [ ] ) { String letra = “”, cero = “cero”, uno = “uno”, dos = “dos”, tres = “tres”; String cuatro = “cuatro”, cinco = “cinco”, seis = “seis”, siete = “siete”; String ocho = “ocho”, nueve = “nueve”, diez = “diez”, once = “once”; String doce = “doce”, trece = “trece”, catorce = “catorce”, quince = “quince”; String dieci = “dieci”; String veinte = “veinte”, veinti = “veinti”, y = “ y ”, treinta = “treinta”; String cuarenta = “cuarenta”, cincuenta = “cincuenta”, sesenta = “sesenta”; String setenta = “setenta”, ochenta = “ochenta”, noventa = “noventa”; String cien = “cien”, ciento = “ciento ”, cientos = “cientos ”; String quinientos = “quinientos ”, sete = “sete”, nove = “nove”; int num, cen, resto, dec, uni; do { System.out.println ( “ Ingrese un número entero menor que 1000: ” ) ; num = Lectura.leerInt ( ) ; if ( num < 0 || num > 999 ) System.out.println ( “ Número ingresado no válido... Reintente!!! ” ) ; } while ( num < 0 || num > 999 ) ; cen = num / 100 ; resto = num % 100 ; dec = resto / 10 ; uni = resto % 10 ; switch ( uni ) { case 0 : letra = cero ; break ; case 1 : letra = uno ; break ;

Pag. 191


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

Pag. 192


Clase PrgNumALetras02 if ( uni == 0 ) letra = veinte ; else letra = veinti + letra ; break ; case 3 : if ( uni == 0 ) letra = treinta ; else letra = treinta + y + letra ; break ; case 4 : if (uni == 0) letra = cuarenta ; else letra = cuarenta + y + letra ; break ; case 5 : if ( uni == 0 ) letra = cincuenta ; else letra = cincuenta + y + letra ; break ; case 6 : if ( uni == 0 ) letra = sesenta ; else letra = sesenta + y + letra ; break ; case 7 : if ( uni == 0 ) letra = setenta ; else letra = setenta + y + letra ; break ; case 8 : if ( uni == 0 ) letra = ochenta ; else letra = ochenta + y + letra ; break ; case 9 : if ( uni == 0 ) letra = noventa ; else letra = noventa + y + letra ; } switch ( cen ) { case 1 : if ( dec == 0 && uni == 0 ) letra = cien ; else

Pag. 193


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

Pag. 194


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

Tipo de excepción capturada por la sentencia catch con la finalidad de manejarla.

try { // Código de la aplicación. … … … … … } catch (

) { // Código de tratamiento de la excepción. … … … … …

}

Significa: “Intentar ejecutar las sentencias ubicadas entre las llaves del try y si ocurre un error y se lanza una excepción capturarla con la sentencia catch y manejarla con las sentencias ubicadas entre las llaves del catch”.

Pag. 195


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. … … }

Si no ocurre un error, no se lanzará ninguna excepción, lo que significa que las sentencias que están entre las llaves de la sentencia catch no se ejecutarán. Si ocurre un error, se lanzará una excepción, interrumpiéndose la ejecución de las sentencias que están entre las llaves de la sentencia try y se ejecutarán las sentencias que están entre las llaves de la sentencia catch, siempre y cuando se haya especificado capturar la excepción lanzada. Como se ha indicado, existen diferentes tipos de excepciones por lo que es común observar en un programa una sentencia try con varias sentencias catch. Cada sentencia catch capturará y manejara un excepción. 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. */ … … } catch ( NumberFormatException e ) { /* Código de tratamiento NumberFormatException. */ … …

de

la

excepción

la

excepción

}

En el ejemplo anterior, se ha especificado capturar dos excepciones en caso de que estás se lancen (ArithmeticException y NumberFormatException).

Pag. 196


El manejo de excepciones ofrece una forma de escribir o codificar programas con una mayor claridad y sencillez, separando explícitamente el código que maneja los errores del código básico de una aplicación. En la actualidad, se considera como “buen estilo de programación” el uso de las excepciones en los programas. Como ejemplo de excepciones se puede mencionar:

Excepción

Descripción

ArithmeticException

Una condición aritmética excepcional ocurrio.

NumberFormatException

Se intentó convertir una cadena con un formato inapropiado a un número.

IOException

Problemas al realizar operaciones de entrada y salida de datos.

ArrayIndexOutOfBoundException

Un arreglo fué accedido con un índice ilegal (fuera de los límites permitidos).

NullPointerException

Se intentó utilizar null donde se requería un objeto.

Pag. 197


Problema 28 Etapa 01 - Descripción del problema. Desarrollar una solución que permita ingresar dos números enteros. Mostrar el resultado de dividir ambos números. Se debe tener en cuenta que existe la posibilidad que el divisor sea igual a cero. Etapa 04 - Desarrollo de la Codificación.

Clase PrgDivisionSinExcepcion package dominioDeLaAplicacion ; import biblioteca.Lectura ; class PrgDivisionSinExcepcion { public static void main ( String arg [ ] ) { int dividendo, divisor, rpta ; System.out.println ( “ Ingrese el dividendo: ” ) ; dividendo = Lectura.leerInt ( ) ; System.out.println ( “ Ingrese el divisor: ” ) ; divisor = Lectura.leerInt ( ) ; rpta = dividendo / divisor ; System.out.println ( “ El resultado de la división es: ” + rpta ) ; } }

Ejecute el siguiente programa e ingrese cero al 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, finalizando la ejecución del programa. Para evitar que el programa finalice es necesario manejar dicha excepción. Intente incluir en el programa anterior el manejo de la excepción lanzada. Analice el siguiente programa y anote sus conclusiones.

Pag. 198


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

Pag. 199


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

Pag. 200


Clase PrgHoraConExcepcion } catch ( NumberFormatException error ) { System.out.println ( “Error... ” ) ; valido = true ; } } while ( valido ) ; System.out.println ( “ La hora se ingresó correctamente... ” ) ; } }

En este programa se captura la excepción NumberFormatException para prevenir que no se intente convertir una cadena con un formato inapropiado a un número. Puede probar el programa ingresando como hora lo siguiente: 23:10:xx Es decir, en cualquier parte del formato indicado, ingrese letras en lugar de números. 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. 201


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

Pag. 202


Clase PrgFechaConExcepcion } else valido = true ; if ( valido ) System.out.println ( “ Error... Ingrese la fecha según formato!!! ” ) ; } while ( valido ) ; System.out.println ( “ El formato esta correcto... ” ) ; System.out.print ( “ Ahora Ud. continue el programa validando el valor ” ) ; System.out.println ( “ de las variable dia, mes y año ” ) ; // Continúa la validación de la fecha... ver problema 24 y 127. } }

En este programa se captura la excepción NumberFormatException para prevenir que no se intente convertir una cadena con un formato inapropiado a un número. Puede probar el programa ingresando como fecha lo siguiente: 23/xx/2005 Es decir, en cualquier parte del formato indicado, ingrese letras en lugar de números (inclusive en el lugar del / ). 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. 203


Problema 31 Etapa 01 - Descripción del problema. 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. Validar que los números sean de tres cifras y mostrar la división de los mismos. Manejar excepciones. Etapa 04 - Desarrollo de la Codificación.

Clase PrgNumeroConExcepcion package dominioDeLaAplicacion ; import biblioteca.Lectura ; class PrgNumeroConExcepcion { public static void main ( String arg [ ] ) { boolean valido = true ; String numeros, tmp, puntos1 ; int num1, num2 ; double resultado ; do { System.out.println ( “ Ingrese dos números con el formato: nnn//nnn ” ) ; numeros = Lectura.leerString ( ) ; numeros = numeros.trim ( ) ; if ( numeros.length ( ) == 8 ) { try { tmp = numeros.substring ( 0, 3 ) ; num1 = Integer.parseInt ( tmp ) ; tmp = numeros.substring ( 5 ) ; num2 = Integer.parseInt ( tmp ) ; puntos1 = numeros.substring ( 3, 5 ) ; if ( puntos1.equals ( “//” ) ) { valido = false ; resultado = num1 / num2 ; System.out.println ( “ La división es: ” + resultado ) ; } else { valido = true ; }

Pag. 204


Clase PrgNumeroConExcepcion } catch ( NumberFormatException error ) { System.out.println ( “ Formato no válido ” ) ; valido = true ; } catch ( ArithmeticException error ) { System.out.println ( “ No se puede dividir un número entre cero ” ) ; valido = false ; } } else { valido = true ; } if ( valido ) { System.out.println ( “ Error... Ingrese en el formato indicado!!! ” ) ; } } while ( valido ) ; } }

En este programa se captura la excepción NumberFormatException para prevenir que no se intente convertir una cadena con un formato inapropiado a un número. Puede probar el programa ingresando como números lo siguiente: aaa//123 Es decir, en cualquier parte del formato indicado, ingrese letras en lugar de números (inclusive en el lugar de las // ). 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.

Pag. 205


Pag. 206


DESARROLLO DE LAS CAPACIDADES LÓGICAS

Cuando un estudiante se inicia en el estudio de la programación, 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. El desarrollo de las capacidades lógicas se logra con la práctica. Es decir, desarrollando soluciones y codificándolas en un lenguaje de programación determinado, como por ejemplo el lenguaje de programación Java, lenguaje de programación utilizado en el presente texto. Existen problemas que por su naturaleza contribuyen de manera significativa a lograr este objetivo, los cuales se desarrollan en esta última parte del presente capítulo. 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.

Pag. 207


Pag. 208


Problema 32 Etapa 01 – Descripción del problema. Desarrollar la codificación de una solución que permita mostrar la siguiente figura:

* * * * *

* * * * *

* * * * *

* * * * *

* * * * *

Nota: En la figura mostrada el número de filas = 5. Asuma que el número de filas puede variar desde 2 hasta 20 y que entre los asteriscos no existen espacios en blanco.

Etapa 04 – Desarrollo de la codificación. Clase PrgCuadrado01 package dominioDeLaAplicacion ; import biblioteca.* ; public class PrgCuadrado01 { public static void main (String[] args) { int totalFilas = 0, i = 0, j = 0 ; do { System.out.println ( “ Ingresar el número de filas de la figura ” ) ; System.out.print ( “ Valores válidos desde 2 hasta 20: ” ) ; totalFilas = Lectura.leerInt ( ) ; if (totalFilas < 2 || totalFilas > 20 ) { System.out.print ( “ Valor de fila no válido… Reintente!. ” ) ; } } while (totalFilas < 2 || totalFilas > 20 ) ; for ( i = 1 ; i <= totalFilas; i++ ) { for ( j = 1 ; j <= totalFilas; j++ ) { // Se muestra un asterisco. System.out.print ( “*”) ; } // Se realiza un salto de línea. System.out.println ( ) ; } } }

Pag. 209


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 cual puede variar desde 2 hasta 20. Para nuestra explicación asumiremos que el valor de totalFilas=5. Entonces, 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; los valores válidos para i son i=1, i=2, i=3, i=4 e i=5). Los valores válidos de i coinciden con el número de filas que nuestra figura va ha tener, por lo cual podemos afirmar que para cada valor de i, corresponde una fila de la figura. Para fila=5: 1ra fila ( i=1 ) 2da fila ( i=2 ) 3ra fila ( i=3 ) 4ta fila ( i=4 ) 5ta fila ( i=5 )

* * * * *

* * * * *

* * * * *

* * * * *

* * * * *

for ( i = 1 ; i <= totalFilas; i++ ) { }

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). Esta situación determina la existencia de la segunda sentencia for dentro de la primera sentencia for (for interno). for ( i = 1 ; i <= totalFilas; i++ ) { for ( j = 1 ; j <= totalFilas; j++ ) { … } … }

Para cada una de las filas (en el caso de totalFilas=5; para i=1, i=2, i=3, i=4 e i=5), 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, el for interno se ejecuta 5 veces y mostrará en total 5 asteriscos en cada una de las filas). Cada vez que finaliza el for interno, la sentencia System.out.println ( ); nos permite hacer un salto de línea y continuar con la ejecución de la solución siempre y cuando la condición del primer for sea verdadera. Los siguientes 2 problemas son una variación de este problema. Analice sus respectivas soluciones y desarrolle sus propias observaciones.

Pag. 210


Problema 33 Etapa 01 – Descripción del problema. Desarrollar la codificación de una solución que permita mostrar la siguiente figura: 1 2 3 4 5 1 2 3 4 5

Nota: En la figura mostrada el número de filas = 5. Asuma que el número de filas puede variar desde 2 hasta 9 y que entre los números no existen espacios en blanco.

1 2 3 4 5 1 2 3 4 5 1 2 3 4 5

Etapa 04 – Desarrollo de la codificación. Clase PrgCuadrado02 package dominioDeLaAplicacion ; import biblioteca.* ; public class PrgCuadrado02 { public static void main (String[] args) { int totalFilas = 0, i = 0, j = 0 ; do { System.out.println ( “ Ingresar el número de filas de la figura ” ) ; System.out.print ( “ Valores válidos desde 2 hasta 9: ” ) ; totalFilas = Lectura.leerInt ( ) ; if (totalFilas < 2 || totalFilas > 9 ) { System.out.println ( “ Valor de fila no válido… Reintente!. ” ) ; } } while (totalFilas < 2 || totalFilas > 9 ) ; for ( i = 1 ; i <= totalFilas; i++ ) { for ( j = 1 ; j <= totalFilas; j++ ) { // Se muestra el valor de la variable j. System.out.print ( j ) ; } // Se realiza un salto de línea. System.out.println ( ) ; } } }

Pag. 211


Problema 34 Etapa 01 – Descripción del problema. Desarrollar la codificación de una solución que permita mostrar la siguiente figura: 1 1 1 1 1 2 2 2 2 2


3 3 3 3 3 4 4 4 4 4 5 5 5 5 5

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

Pag. 212


Los últimos dos problemas son una variación del problema 32, en el cuál se desarrolla la siguiente figura:

* * * * *

* * * * *

* * * * *

* * * * *

* * * * *

Con la finalidad de mejorar sus capacidades lógicas sugiero que desarrolle las siguientes variaciones del problema:

1 2 3 4 5

5 4 3 2 1

5 5 5 5 5

6 7 8 9 0

5 4 3 2 1

4 4 4 4 4

1 2 3 4 5

5 4 3 2 1

3 3 3 3 3

6 7 8 9 0

5 4 3 2 1

2 2 2 2 2

1 2 3 4 5

5 4 3 2 1

1 1 1 1 1

Pag. 213



* * * * *

* * * * * * * * * *


Etapa 04 – Desarrollo de la codificación. Clase PrgTriangulo01 package dominioDeLaAplicacion; import biblioteca.*; public class PrgTriangulo01 { public static void main(String[] args) { int totalFilas = 0, i = 0, j = 0 ; do { System.out.println ( “ Ingresar el número de filas de la figura ” ) ; System.out.print ( “ Valores válidos desde 2 hasta 20: ” ) ; totalFilas = Lectura.leerInt ( ) ; if (totalFilas < 2 || totalFilas > 20 ) { System.out.println ( “ Valor de fila no válido… Reintente!. ” ) ; } } while (totalFilas < 2 || totalFilas > 20 ) ; for ( i = 1 ; i <= totalFilas; i++ ) { for ( j = 1 ; j <= i ; j++ ) { // Se muestra un asterisco. System.out.print ( “*”) ; } // Se realiza un salto de línea. System.out.println ( ) ; } } }

Pag. 214



Se ingresa el número de filas que va ha tener la figura y se almacena en la variable totalFilas, la cual puede variar desde 2 hasta 20. Para nuestra explicación asumiremos que el valor de totalFilas=5. Entonces, 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; los valores válidos para i son i=1, i=2, i=3, i=4 e i=5). Los valores válidos de i coinciden con el número de filas que nuestra figura va ha tener, por lo cual podemos afirmar que para cada valor de i, corresponde una fila de la figura. Para fila=5: 1ra fila ( i=1 ) 2da fila ( i=2 ) 3ra fila ( i=3 ) 4ta fila ( i=4 ) 5ta fila ( i=5 )

* * * * *

* * * * * * * * * *

for ( i = 1 ; i <= totalFilas; i++ ) { }

Ahora necesitamos mostrar un asterisco en la primera fila (i=1), 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). Esta situación determina la existencia de la segunda sentencia for dentro de la primera sentencia for (for interno). for ( i = 1 ; i <= totalFilas; i++ ) { for ( j = 1 ; j <= i ; j++ ) { … } … }

En la primera fila (i=1) se necesita mostrar un asterisco. Esto se cumple ya que para i=1 el único valor válido para j sería j=1, por lo que el for interno se ejecutaría una sola vez y se mostraría solo un asterisco. Finalizada la ejecución del for interno, la sentencia System.out.println ( ); nos permite hacer un salto de línea. Es decir, pasar a la segunda fila. En la segunda fila (i=2) se necesita mostrar dos asterisco. Esto se cumple ya que para i=2 los valores válidos para j serían j=1 y j=2, por lo que el for interno se ejecutaría dos veces y en cada una de las ejecuciones del for interno se mostraría dos asterisco (en consecuencia se mostrarían en total dos asteriscos). Finalizada la ejecución del for interno, la sentencia System.out.println ( ); nos permite hacer un salto de línea. Es decir, pasar a la tercera fila. Y así sucesivamente hasta llegar a la última fila. En nuestro caso la última fila es 5 (i=5) y se necesita mostrar 5 asteriscos.Esto se cumple ya que para i=5, los valores válidos para j serían j=1, j=2, j=3, j=4 y j=5, por lo que el for interno

Pag. 215


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

Pag. 216


Problema 36 Etapa 01 – Descripción del problema. 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

Etapa 04 – Desarrollo de la codificación. Clase PrgTriangulo02 package dominioDeLaAplicacion; import biblioteca.*; public class PrgTriangulo02 { public static void main(String[] args) { int totalFilas = 0, i = 0, j = 0 ; do { System.out.println ( “ Ingresar el número de filas de la figura ” ) ; System.out.print ( “ Valores válidos desde 2 hasta 9: ” ) ; totalFilas = Lectura.leerInt ( ) ; if (totalFilas < 2 || totalFilas > 9 ) { System.out.println ( “ Valor de fila no válido… Reintente!. ” ) ; } } while (totalFilas < 2 || totalFilas > 9 ) ; for ( i = 1 ; i <= totalFilas; i++ ) { for ( j = 1 ; j <= i ; j++ ) { // Se muestra el valor de la variable j. System.out.print ( j ) ; } // Se realiza un salto de línea. System.out.println ( ) ; } } }

Pag. 217




3 3 3 4 4 4 4 5 5 5 5 5

Etapa 04 – Desarrollo de la codificación. Clase PrgTriangulo03 package dominioDeLaAplicacion; import biblioteca.*; public class PrgTriangulo03 { public static void main(String[] args) { int totalFilas = 0, i = 0, j = 0 ; do { System.out.println ( “ Ingresar el número de filas de la figura ” ) ; System.out.print ( “ Valores válidos desde 2 hasta 9: ” ) ; totalFilas = Lectura.leerInt ( ) ; if (totalFilas < 2 || totalFilas > 9 ) { System.out.println ( “ Valor de fila no válido… Reintente!. ” ) ; } } while (totalFilas < 2 || totalFilas > 9 ) ; for ( i = 1 ; i <= totalFilas; i++ ) { for ( j = 1 ; j <= i ; j++ ) { // Se muestra el valor de la variable i. System.out.print ( i ) ; } // Se realiza un salto de línea. System.out.println ( ) ; } } }

Pag. 218




5 4 3 5 4 3 2 5 4 3 2 1

Etapa 04 – Desarrollo de la codificación. Clase PrgTriangulo04 package dominioDeLaAplicacion; import biblioteca.*; public class PrgTriangulo04 { public static void main(String[] args) { int totalFilas = 0, i = 0, j = 0 ; do { System.out.println ( “ Ingresar el número de filas de la figura ” ) ; System.out.print ( “ Valores válidos desde 2 hasta 9: ” ) ; totalFilas = Lectura.leerInt ( ) ; if (totalFilas < 2 || totalFilas > 9 ) { System.out.println ( “ Valor de fila no válido… Reintente!. ” ) ; } } while (totalFilas < 2 || totalFilas > 9 ) ; for ( i = totalFilas; i >= 1 ; i - - ) { for ( j = totalFilas; j >= i ; j - - ) { // Se muestra el valor de la variable j. System.out.print ( j ) ; } // Se realiza un salto de línea. System.out.println ( ) ; } } }

Pag. 219




3 3 3 2 2 2 2 1 1 1 1 1

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

Pag. 220




4 5 1 2 3 4 5 1 2 3 4 5

Etapa 04 – Desarrollo de la codificación. Clase PrgTriangulo06 package dominioDeLaAplicacion; import biblioteca.*; public class PrgTriangulo06 { public static void main(String[] args) { int totalFilas = 0, i = 0, j = 0, k=0 ; do { System.out.println ( “ Ingresar el número de filas de la figura ” ) ; System.out.print ( “ Valores válidos desde 2 hasta 9: ” ) ; totalFilas = Lectura.leerInt ( ) ; if (totalFilas < 2 || totalFilas > 9 ) { System.out.println ( “ Valor de fila no válido… Reintente!. ” ) ; } } while (totalFilas < 2 || totalFilas > 9 ) ; for ( i = 1 ; i <= totalFilas; i++ ) { for ( j = 1 ; j <= i ; j++ ) { if ( k == totalFilas) { k=1; } else { k ++ ; } System.out.print ( k ) ; } System.out.println ( ) ; } } }

Pag. 221




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

Etapa 04 – Desarrollo de la codificación. Clase PrgTriangulo07 package dominioDeLaAplicacion; import biblioteca.*; public class PrgTriangulo07 { public static void main(String[] args) { int totalFilas = 0, i = 0, j = 0 ; do { System.out.println ( “ Ingresar el número de filas de la figura ” ) ; System.out.print ( “ Valores válidos desde 2 hasta 20: ” ) ; totalFilas = Lectura.leerInt ( ) ; if (totalFilas < 2 || totalFilas > 20 ) { System.out.println ( “ Valor de fila no válido… Reintente!. ” ) ; } } while (totalFilas < 2 || totalFilas > 20 ) ; for ( i = 1 ; i <= totalFilas; i++ ) { for ( j = 1 ; j <= i ; j++ ) { if ( k == 9 ) { k=0; } else { k ++ ; } System.out.print ( k ) ; } System.out.println ( ) ; } } }

Pag. 222




2 1 5 4 3 2 1 5 4 3 2 1

Etapa 04 – Desarrollo de la codificación. Clase PrgTriangulo08 package dominioDeLaAplicacion; import biblioteca.*; public class PrgTriangulo08 { public static void main(String[] args) { int totalFilas = 0, i = 0, j = 0, k=0 ; do { System.out.println ( “ Ingresar el número de filas de la figura ” ) ; System.out.print ( “ Valores válidos desde 2 hasta 9: ” ) ; totalFilas = Lectura.leerInt ( ) ; if (totalFilas < 2 || totalFilas > 9 ) { System.out.println ( “ Valor de fila no válido… Reintente!. ” ) ; } } while (totalFilas < 2 || totalFilas > 9 ) ; k=totalFilas+1; for ( i = 1 ; i <= totalFilas; i++ ) { for ( j = 1 ; j <= i ; j++ ) { if ( k == 1 ) { k = totalFilas ; } else { k--; } System.out.print ( k ) ; } System.out.println ( ) ; } } }

Pag. 223


Los últimos siete problemas son una variación del problema 35, en el cuál se desarrolla la siguiente figura:

* * * * *

* * * * * * * * * *

Con la finalidad de mejorar sus capacidades lógicas sugiero que desarrolle las siguientes figuras y sus respectivas variaciones:

*

*

*

*

*

* *

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

* *

Pag. 224



* * * * * * * * * *

* * * * *


Etapa 04 – Desarrollo de la codificación. Clase PrgTriangulo09 package dominioDeLaAplicacion ; import biblioteca.* ; public class PrgTriangulo09 { public static void main (String[] args) { int totalFilas = 0, i = 0, j = 0 ; do { System.out.println ( “ Ingresar el número de filas de la figura ” ) ; System.out.print ( “ Valores válidos desde 2 hasta 20: ” ) ; totalFilas = Lectura.leerInt ( ) ; if (totalFilas < 2 || totalFilas > 20 ) { System.out.println ( “ Valor de fila no válido… Reintente!. ” ) ; } } while (totalFilas < 2 || totalFilas > 20 ) ; for ( i = 1 ; i <= totalFilas; i ++ ) { for ( j = 1 ; j < i ; j ++ ) { System.out.print ( “ ” ) ; } for ( j = i ; j <= totalFilas ; j ++ ) { System.out.print ( “*” ) ; } System.out.println ( ) ; } } }

Intente mejorar la solución anterior (en lugar de usar tres sentencias for utilice solo dos), sino lo consigue analice la siguiente solución.

Pag. 225


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

Pag. 226



* * * * * * * * * *

* * * * *

Nota: la cantidad de asteriscos que tiene la figura al lado derecho es el dato que se debe ingresar. Dicho dato debe tener un valor entre 2 y 20. En la figura el lado = 5. No existen espacios en blanco entre los asteriscos.


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

Pag. 227


Intente mejorar la solución anterior de tal forma que cambie el for interno por el siguiente for: for ( j = 1 ; j < = totalFilas ; j++ ) … … … }

Sino lo consigue analice la siguiente solución:

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

Es importante indicar que un mismo problema puede ser solucionado de diferentes maneras.

Pag. 228



* * * * *

* *

* *

* *

Nota: En la figura mostrada el número de filas = 5. Asuma que el número de filas puede variar desde 2 hasta 20 y que entre los asteriscos existe un espacio en blanco.

* * *

*

Etapa 04 – Desarrollo de la codificación. Clase PrgTriangulo11 package dominioDeLaAplicacion; import biblioteca.*; public class PrgTriangulo11 { public static void main(String[] args) { int totalFilas = 0, i = 0, j = 0 ; do { System.out.println ( “ Ingresar el número de filas de la figura ” ) ; System.out.print ( “ Valores válidos desde 2 hasta 20: ” ) ; totalFilas = Lectura.leerInt() ; if (totalFilas < 2 || totalFilas > 20 ) { System.out.println ( “ Valor de fila no válido… Reintente!. ” ) ; } } while (totalFilas < 2 || totalFilas > 20 ) ; for ( i = 1 ; i <= totalFilas ; i++ ) { for ( j = i ; j < totalFilas ; j++ ) { // Se muestra un espacio en blanco. System.out.print ( “ ”) ; } for ( j = 1 ; j <= i ; j++ ) { // Se muestra un asterisco y un espacio en blanco. System.out.print ( “* ”) ; } // Se realiza un salto de linea. System.out.println ( ) ; } } }

Pag. 229



Se ingresa el número de filas que va ha tener la figura y se almacena en la variable totalFilas, la cual puede variar desde 2 hasta 20. Para nuestra explicación asumiremos que el valor de totalFilas=5. 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. Cada vez que se ejecuta el primer for debemos asegurarnos de mostrar los asteriscos necesarios. Para fila=5:

*

1ra fila ( i=1 )

*

2da fila ( i=2 )

*

3ra fila ( i=3 )

*

4ta fila ( i=4 )

*

5ta fila ( i=5 )

* *

* *

* *

for ( i = 1 ; i <= totalFilas ; i++ ) {

*

}

* *

*

Es necesario entonces mostrar un asterisco en la primera fila (i=1), un asterisco, 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). 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. Es necesario encontrar algunos parámetros para establecer una constante matemática (una relación matemática) que nos permita mostrar adecuadamente la figura. Ahora, 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):

*

* -

* *

* * -

* * *

* - * * - * - * - *

Nota: Los guiones representan espacios en blanco. Entre un guión y un asterisco no hay ningún símbolo.

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:

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

* * *

* - * * - * - * - *

Nota: Se determina que existe una relación en la parte donde están los espacios en blanco. En la primera fila (i=1) se muestran fila - 1 espacio en blanco y luego se muestra un espacio en blanco menos cada vez que se muestra una nueva fila, hasta llegar a la última fila donde no se muestra ningún espacio en blanco.

Pag. 230


En la parte que tiene los asteriscos y espacios en blanco entre los asteriscos, es necesario buscar una relación matemática. Para esto, incluiremos un espacio en blanco al final de cada una de las filas de la figura:

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

* * *

* * -

Nota: Se determina que existe una relación en la parte donde están los asteriscos y espacios en blanco entre los asteriscos. En la primera fila (i=1) se muestran un asterisco y un espacio en blanco (una pareja “*-”), en la segunda fila 2 parejas y así sucesivamente hasta llegar a la última fila donde se muestran cinco parejas.

* - * * - * -

Una pareja (formada por un asterisco y un espacio en blanco).

Al analizar la figura determinamos que hay dos partes las cuales son independientes, por lo cual determinamos la necesidad de emplear dos for internos. El primer for interno nos permite mostrar los espacios en blanco que están antes del primer asterisco de cada una de las filas. Para fila=5: 1ra fila ( i=1 ) 2da fila ( i=2 ) 3ra fila ( i=3 ) 4ta fila ( i=4 )

- - - - - - -

for ( j = 1 ; j < totalFilas ; j++ ) { System.out.print ( “ ”) ; }

5ta fila ( i=5 )

El segundo for interno nos permite mostrar los asteriscos y espacios en blanco que están después de cada uno de los asteriscos en cada una de las filas: Para fila=5: 1ra fila ( i=1 ) 2da fila ( i=2 ) 3ra fila ( i=3 ) 4ta fila ( i=4 ) 5ta fila ( i=5 )

* * * - * * - * -

* * *

* * -

* - * * - * -

for ( j = 1 ; j <= i ; j++ ) { System.out.print ( “* ”) ; }

Intente mejorar la solución anterior (en lugar de usar tres sentencias for utilice solo dos), sino lo consigue analice la siguiente solución.

Pag. 231


Clase PrgTriangulo11Mejorado package dominioDeLaAplicacion; import biblioteca.*; public class PrgTriangulo11Mejorado { public static void main(String[] args) { int totalFilas = 0, i = 0, j = 0, cont = 0 ; do { System.out.println ( “ Ingresar el número de filas de la figura ” ) ; System.out.print ( “ Valores válidos desde 2 hasta 20: ” ) ; totalFilas = Lectura.leerInt() ; if (totalFilas < 2 || totalFilas > 20 ) { System.out.println ( “ Valor de fila no válido… Reintente!. ” ) ; } } while (totalFilas < 2 || totalFilas > 20 ) ; for ( i = 1 ; i <= totalFilas ; i++ ) { for ( j = 1 ; j < totalFilas * 2 ; j++ ) { if ( ( j >= totalFilas – cont ) && ( j <= totalFilas + cont ) ) { // Se muestra unasterisco y un espacio en blanco. System.out.print ( “* ”) ; j ++ ; } else { // Se muestra un espacio en blanco. System.out.print ( “ ”) ; } } cont ++ ; System.out.println ( ) ; } } }

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). La variable i va ha representar cada una de las filas, mientras que la variable j va ha representar cada una de las columnas.

*

* -

* *

* * -

* * *

* * -

* *

- - * - *

Nota: Los guiones representan espacios en blanco. Entre un guión y un asterisco no hay ningún símbolo.

Pag. 232


El primer for controla el número de filas que se van ha mostrar (desde i=1 hasta i=totalFilas). 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). En el for interno hay una sentencia if que nos permite determinar el símbolo que se va ha mostrar. if ( ( j >= totalFilas – cont ) && ( j <= totalFilas + cont ) ) { // Se muestra un asterisco y un espacio en blanco. System.out.print ( “* ”) ; j ++ ; } else { // Se muestra un espacio en blanco. System.out.print ( “ ”) ; }

Ahora, nuevamente intente mejorar la solución. Utilice el primer planteamiento desarrollado. Analice nuevamente el siguiente gráfico:

*

* -

* *

* * -

* * *

* * -

* - * * - * -

for ( i = 1 ; i <= totalFilas ; i++ ) { for ( j = 1 ; j <= totalFilas ; j++ ) { if ( j > totalFilas - i ) { // Se muestra un asterisco y un espacio en blanco. System.out.print ( “* ”) ; } else { // Se muestra un espacio en blanco. System.out.print ( “ ”) ; } } System.out.println ( ) ; }

También: for ( i = 1 ; i <= totalFilas ; i++ ) { for ( j = 1 ; j <= totalFilas ; j++ ) { if ( j <= totalFilas - i ) { // Se muestra un espacio en blanco. System.out.print ( “ ”) ; } else { // Se muestra un asterisco y un espacio en blanco. System.out.print ( “* ”) ; } } System.out.println ( ) ; }

Pag. 233


Con la finalidad de mejorar sus capacidades lógicas sugiero que desarrolle todas las variaciones posibles o que se pueda imaginar del presente problema. Adicionalmente desarrolle las siguientes figuras y sus posibles variaciones:

*

-

*

-

*

-

*

-

*

-

*

-

*

-

*

-

*

-

*

*

-

*

*

* Nota: Recuerde que los guiones representan espacios en blanco.

*

* *

*

*

* *

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

* *

*

*

*

*

*

*

*

*

Nota: Observe que en la primera fila se desea mostrar un asterisco y en las siguientes filas 3, 5, 7… y así suceivamente (no hay espacios en blanco entre los asteriscos). Relación: el número de asteriscos a mostrar en cada fila esta dado por la fórmula: totalFilas * 2 - 1.

// Se muestra la última parte de la solución: for ( i = 1 ; i <= totalFilas ; i++ ) { for ( j = 1 ; j < totalFilas * 2 ; j++ ) { if ( ( j >= totalFilas – cont ) && ( j <= totalFilas + cont ) ) { // Se muestra un asterisco. System.out.print ( “*”) ; } else { // Se muestra un espacio en blanco. System.out.print ( “ ”) ; } } cont ++ ; System.out.println ( ) ; }

Pag. 234



* * * *

* *

* *

* *

* *

* *

Nota: desarrollar la figura con la estructura de repetición MIENTRAS (while). El lado del rombo debe tener un valor entre 2 y 10. En la figura el lado = 4.

* *

Etapa 04 - Desarrollo de la Codificación. Clase PrgRombo01 package dominioDeLaAplicacion ; import biblioteca.* ; public class PrgRombo01 { public static void main (String args[]) { int totalFilas = 0, diagonal = 0, cont = 0, i = 1, j = 1 ; System.out.println ( “ Programa que realiza un rombo de *s con la estructura \“WHILE\” \n” ) ; System.out.print ( “ Ingrese el lado del rombo entre [2,10]: ” ) ; do { totalFilas = Lectura.leerInt ( ); if (totalFilas < 2 || totalFilas > 10 ) { System.out.println ( “\nValor fuera de rango. Ingrese entero entre [2,10]: ” ) ; } } while (totalFilas < 2 || totalFilas > 10 ) ; System.out.println ( ) ; diagonal = totalFilas * 2 - 1 ;

Pag. 235


while ( i <= diagonal ) { j=1; while ( j <= diagonal ) { if ( j < totalFilas - cont || j > totalFilas + cont ) // Se muestra un espacio en blanco. System.out.print ( “ ” ) ; else { // Se muestra un asterisco y un espacio en blanco. System.out.print ( “* ” ) ; j ++ ; } j ++ ; } if ( i < totalFilas ) cont ++ ; else cont - - ; System.out.println ( ) ; i ++ ; } } }

Analice la solución del problema y anote sus conclusiones. Intente resolverlo utilizando la sentencia for de Java.

Pag. 236



1 2 3 4

2 3

4 3

3 4

3 2

4 3

Nota: la figura mostrada es un rombo de número. Ingresar un valor entero desde 2 hasta 9 que representa el número de elementos de la fila central. En la figura el dato = 4.

2 1

Etapa 04 - Desarrollo de la Codificación. Clase PrgRombo02 package dominioDeLaAplicacion ; import biblioteca.* ; public class PrgRombo02 { public static void main (String args[]) { int num = 0, diagonal = 0, cont = 0, n = 0, i = 1, j = 1 ; System.out.println ( “ Programa que realiza un rombo de números ” ) ; System.out.print ( “ Ingrese el número máximo de la figura entre [2,9]: ” ) ; do { num = Lectura.leerInt ( ) ; if ( num < 2 || num > 9 ) { System.out.println ( “\nValor fuera de rango. Ingrese enteros entre [2...9]: ” ) ; } } while ( num < 2 || num > 9 ) ; System.out.println ( ) ; diagonal = 2 * num - 1 ;

Pag. 237


for ( i = 1 ; i <= diagonal ; i ++ ) { n = cont + 1 ; for ( j = 1 ; j <= diagonal ; j ++ ) { if ( j >= num - cont && j <= num + cont ) { // Se muestra el contenido de la variable n y un espacio en blanco. System.out.print ( n + “ ” ) ; j ++ ; } else // Se muestra un espacio en blanco. System.out.print ( “ ” ) ; } if ( i < num ) cont ++ ; else cont - - ; System.out.println ( ) ; } } }

Modifique está solución utilizando la estructura de repetición while en lugar de la estructura for.

Con la finalidad de mejorar sus capacidades lógicas sugiero que desarrolle todas las variaciones posibles o que se pueda imaginar del presente problema. Adicionalmente desarrolle la siguiente figura y sus posibles variaciones:

1 2 4 7 2

3 5

8 3

7

6 9

4 8

2

1 5

9 3

5

6 1

4 6

7

A continuación se presentan diversas soluciones que permitirán contribuir con el desarrollo de sus capacidades lógicas. Analice cada una de las soluciones en forma detallada. Tenga en cuenta que se han cambiado los nombres de las variables utilizadas en las soluciones anteriores.

Pag. 238



* * * * * * * * * * * * * * * *

Nota: En la figura mostrada el número de filas = 5. Asuma que el número de filas puede variar desde 2 hasta 15.

Etapa 04 - Desarrollo de la Codificación. Clase PrgFiguraA package dominioDeLaAplicacion ; import biblioteca.* ; public class PrgFiguraA { public static void main(String args[]) { int lado = 0; System.out.println ( “ Programa que realiza un cuadrado hueco\n ” ) ; System.out.print ( “ Ingrese lado del cuadrado entre [2,15]: ” ) ; do { lado = Lectura.leerInt ( ); if ( lado < 2 || lado > 15 ) { System.out.println ( “\nValor fuera de rango. Ingrese entero entre [2,15]: ” ) ; } } while ( lado < 2 || lado > 15 ) ; System.out.println ( ) ; for( int fil = 1 ; fil <= lado ; fil ++ ) { for( int col = 1 ; col <= lado ; col ++ ) { if ( ( 1 < fil && fil < lado ) && ( 1 < col && col < lado ) ) { // Se muestran dos espacios en blanco. System.out.print ( “ ” ) ; } else { // Se muestra un asterisco y un espacio en blanco. System.out.print ( “* ” ) ; } } System.out.println ( ) ; } } }

Pag. 239



* * * * * * * * * * * *

Nota: la cantidad de asteriscos que tiene la figura al lado izquierdo es el dato que se debe ingresar. Dicho dato debe tener un valor entre 2 y 20. En la figura el lado = 5.

Etapa 04 - Desarrollo de la Codificación. Clase PrgFiguraB package dominioDeLaAplicacion ; import biblioteca.* ; public class PrgFiguraB { public static void main(String args[]) { int lado = 0 ; System.out.println ( “ Programa que realiza un triángulo de asteriscos: ” ) ; System.out.print ( “ Ingrese el lado del triángulo entre [2,20]: ” ) ; do { lado = Lectura.leerInt ( ) ; if ( lado < 2 || lado > 20 ) { System.out.println ( “\nValor fuera de rango. Ingrese entero entre [2,20]: ” ) ; } } while ( lado < 2 || lado > 20 ) ; System.out.println ( ) ; for ( int fil = 1 ; fil <= lado ; fil ++ ) { for ( int col = 1 ; col <= fil ; col ++ ) { if ( ( col == 1 ) || ( fil == col ) || ( fil == lado ) ) System.out.print ( “* ” ) ; // Un asterisco y un espacio. else System.out.print ( “ ” ) ; // Dos espacios. } System.out.println ( ) ; } } }

Pag. 240



* *

*

* * * * * * * * * * * * *

Nota: el dato de ingreso debe ser la cantidad de asteriscos que tiene la base. La base debe tener un valor impar entre 3 y 25. En la figura la base = 9.

Etapa 04 - Desarrollo de la Codificación. Clase PrgFiguraC package dominioDeLaAplicacion ; import biblioteca.* ; public class PrgFiguraC { public static void main(String args[]) { int base = 0, medio = 0 ; System.out.println ( “ Programa que realiza un triángulo hueco de base impar \n ” ) ; System.out.print ( “ Ingrese la base impar del triángulo entre [3,25]: ” ) ; do { base = Lectura.leerInt ( ) ; if ( base < 3 || base > 25 || base % 2 == 0 ) { System.out.println ( “\nValor fuera de rango. Ingrese impar entre [3,25]: ” ) ; } } while ( base < 3 || base > 25 || base % 2 == 0 ) ; System.out.println ( ) ; medio = base / 2 + 1 ; for ( int fil = 0 ; fil < medio ; fil++ ) { for ( int col = 1 ; col <= base ; col++ ) { if ( col == medio + fil || col == medio - fil || fil + 1 == medio ) System.out.print ( “* ” ) ; // Un asterisco y un espacio. else System.out.print ( “ ” ) ; // Dos espacios. } System.out.println ( ) ; } } }

Pag. 241



* * * * * * * * * * * * * * * * * * * * *

Nota: el lado de la figura debe tener un valor impar entre 5 y 15. En la figura el lado = 5.

Etapa 04 - Desarrollo de la Codificación. Clase PrgFiguraD package dominioDeLaAplicacion ; import biblioteca.* ; public class PrgFiguraD { public static void main ( String args[] ) { int lado = 0 ; System.out.println ( “ Programa que realiza una ventana \n” ) ; System.out.print ( “ Ingrese el lado impar de la ventana entre [5,15]: ” ) ; do { lado = Lectura.leerInt ( ) ; if ( lado < 5 || lado > 15 || lado % 2 ==0 ) { System.out.println ( “\nValor fuera de rango. Ingrese entero impar entre [5,15]: ” ) ; } } while ( lado < 5 || lado > 15 || lado % 2 == 0 ) ; System.out.println ( ) ; for ( int fil = 1 ; fil <= lado ; fil ++ ) { for ( int col = 1 ; col <= lado ; col ++ ) { if ( fil == 1 || fil == lado || fil == lado/2+1 || col == 1 || col == lado || col == lado / 2+1) System.out.print ( “* ” ) ; else System.out.print ( “ ” ) ; } System.out.println ( ) ; } } }

Pag. 242



* * * * *

* * * * * * * * * * *

* * * * *

Nota: el lado de la figura debe tener un valor impar entre 5 y 15. En la figura el lado = 5.

Etapa 04 - Desarrollo de la Codificación. Clase PrgFiguraE package dominioDeLaAplicacion ; import biblioteca.* ; public class PrgFiguraE { public static void main (String args[]) { int lado = 0 ; System.out.println ( “ Programa que realiza un cuadrado de asteriscos, mostrando ” ) ; System.out.print ( “ sus diagonales \n ” ) ; System.out.print ( “ Ingrese el lado impar del cuadrado entre[5,15]: ” ) ; do { lado = Lectura.leerInt ( ) ; if ( lado < 5 || lado > 15 || lado % 2 == 0 ) { System.out.println ( “\nValor fuera de rango. Ingrese impar entre [5,15]: ” ) ; } } while ( lado < 5 || lado > 15 || lado % 2 == 0 ) ; System.out.println ( ) ; for ( int fil = 1 ; fil <= lado ; fil ++ ) { for ( int col = 1 ; col <= lado ; col ++ ) { if ( fil == 1 || fil == lado || fil == col || col == 1 || col == lado || col == (lado –fil +1) ) System.out.print ( “* ” ) ; else System.out.print ( “ ” ) ; } System.out.println ( ) ; } } }

Pag. 243



* * * * * * * *

* * * *

Nota: el lado de la figura debe ser un número par con un valor desde 4 hasta 18. En la figura el lado = 4.

Etapa 04 - Desarrollo de la Codificación. Clase PrgFiguraF package dominioDeLaAplicacion ; import biblioteca.* ; public class PrgFiguraF { public static void main (String args[]) { int alto = 0 ; System.out.println ( “ Programa que realiza una figura similar a la letra U \n ” ) ; System.out.print ( “ Ingrese el alto (número par) de la figura entre [4,18]: ” ) ; do { alto = Lectura.leerInt ( ) ; if ( ( alto < 4 ) || ( alto > 18 ) || ( alto % 2 == 0 ) ) { System.out.prinlnt ( “\nValor fuera de rango.Ingrese un número par entre [4,18]: ” ) ; } } while ( ( alto < 4 ) || ( alto > 18 ) || ( alto % 2 == 0 ) ) ; System.out.println ( ) ; for ( int fil = 1 ; fil <= alto ; fil ++ ) { for ( int col = 1 ; col <= alto ; col ++ ) { if ( fil <= ( alto / 2 ) ) if ( col == 1 || col == alto ) System.out.print ( “* ” ) ; else System.out.print ( “ ” ) ; else System.out.print ( “* ” ) ; } System.out.println ( ) ; } } }

Pag. 244



* * * * *

* * * * * * * * * *

* * * * * * * * * *

* * * * *

Nota: el lado de la figura debe tener un valor entre 2 y 15. En la figura el lado = 5.

Etapa 04 - Desarrollo de la Codificación. Clase PrgFiguraG package dominioDeLaAplicacion ; import biblioteca.* ; public class PrgFiguraG { public static void main (String args[]) { int lado = 0, mayor = 0, col = 0 ; System.out.println ( “ Programa que realiza dos triángulos de asteriscos ”); System.out.print ( “ frente a frente a sus hipotenusas \n ” ) ; System.out.print ( “ Ingrese el lado del triángulo entre [2,15]: ” ) ; do { lado = Lectura.leerInt ( ) ; if ( lado < 2 || lado > 15 ) { System.out.println ( “\nValor fuera de rango. Ingrese entero entre [2,15]: ” ) ; } } while ( lado < 2 || lado > 15 ) ; System.out.println ( ) ; mayor = (2 * lado ) + 1 ; for ( int fil = 1 ; fil <= lado ; fil ++ ) { col = 1 ; while ( col <= mayor ) { if ( col <= fil || mayor - fil < col ) System.out.print ( “* ” ) ; else System.out.print ( “ ” ) ; col ++ ; } System.out.println ( ) ; } } }

Pag. 245



* * * * * * * * * *

* * * * *

* * * * *

* * * * * * * * * *

Nota: el lado de la figura debe tener un valor entre 2 y 15. En la figura el lado = 5.

Etapa 04 - Desarrollo de la Codificación. Clase PrgFiguraH package dominioDeLaAplicacion ; import biblioteca.* ; public class PrgFiguraH { public static void main (String args[]) { int base = 0, mayor = 0, col = 0; System.out.println ( “ Programa que realiza dos triángulos de asteriscos, ” ) ; System.out.print ( “ frente a frente a sus catetos \n ” ) ; System.out.print ( “ Ingrese la base del triángulo entre [2,15]: ” ) ; do { base = Lectura.leerInt ( ) ; if ( base < 2 || base > 15 ) { System.out.println ( “\nValor fuera de rango. Ingrese entero entre [2,15]: ” ) ; } } while ( base < 2 || base > 15 ) ; System.out.println ( ) ; mayor = ( 2 * base ) + 1 ; for ( int fil = 1 ; fil <= base ; fil ++ ) { col = 1 ; while ( col <= mayor ) { if ( (( base-fil ) < col && col <= base) || (( base+1) < col && col <= base+1+fil ) ) System.out.print ( ‘*’ ) ; else System.out.print ( ‘ ’ ) ; col ++ ; } System.out.println ( ) ; } } }

Pag. 246



* * * * * * * * * * * * * * * * * * * * * * * *

Nota: la base y la altura del cuadrado se ingresarán por teclado. La base deberá ser mayor que la altura. En la figura la base=10 y altura=5.

Etapa 04 - Desarrollo de la Codificación. Clase PrgfiguraI package dominioDeLaAplicacion ; import biblioteca.* ; public class PrgFiguraI { public static void main (String args[]) { int base = 0, alto = 0; System.out.println ( “ Programa que genera un rectángulo hueco de base > alto \n ” ) ; System.out.println ( “ Para generar el rectángulo hueco en pantalla la base ” ) ; System.out.print ( “ debe ser >2 y el alto>1 \n ” ) ; System.out.print ( “ Ingrese la base del rectángulo: ” ) ; do { base = Lectura.leerInt ( ) ; if ( base < 2 ) { System.out.println ( “\nValor fuera de rango. Ingrese entero mayor a 2: ” ) ; } } while ( base < 2 ) ; System.out.print ( “ Ingrese el alto del rectángulo...Debe ser menor a la base [“ + base + ”]: ” ) ; do { alto = Lectura.leerInt ( ) ; if ( alto < 1 || alto >= base ) { if ( alto == base ) { System.out.print ( “\nEs un cuadrado. Ingrese entero mayor a 1 y menor ” ) ; System.out.print ( “ a base [“ + base + ”]: ” ) ; } else { System.out.print ( “\nValor fuera de rango. Ingrese entero mayor a 1 y ” ) ; System.out.print ( “ menor a base [“ + base + ”]: ” ) ; } } } while ( ! ( alto >1 && alto < base ) ) ;

Pag. 247


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


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


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



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



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



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


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

*

*

*

*

*

*

*

-

-

-

*

*

*

*

*

-

-

-

*

*

-

*

*

-

-

-

*

*

-

-

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

-

*

-

-

-

*

*

-

-

-

-

-

*

*

*

*

*

*

*

*

* *

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

-

*

1 *

2

*

-

-

-

*

*

-

-

-

-

-

-

-

-

-

-

-

-

*

-

-

-

-

-

*

-

-

-

*

*

-

*

*

*

*

4 *

7 *

1

- 5

- 8

- 2 6

- 0

- 4

- 8

- 1 3

- 6

- 9

- 3

- 7 0

- 3

- 2

- 4 5

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

Pag. 254

- 5

- 9


Pag. 255


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.




Pag. 259


LISTA DE PASOS

SENTENCIAS



SE DESARROLLAN UTILIZANDO: • Estructuras lógicas de secuencia. • Estructuras lógicas de decisión. • Estructuras lógicas de repetición. • Instrucciones de bifucación. TAMBIÉN: • Clases incorporadas en el lenguaje de programación utilizado.

ALMACENADOS EN: • Estructuras de datos tipo variables.

Los algoritmos son desarrollados dentro de los métodos. Es decir, todo programa en Java está contenido en uno o mas métodos, siendo el método main( ), el método principal que tiene como función iniciar la ejecución de una aplicación desarrollada en Java. El lenguaje de programación Java contiene diversas clases preprogramadas, es decir, contiene una gran variedad de clases, con métodos y atributos, que tienen diferentes funciones y están agrupadas por medio de paquetes.

Pag. 260


El presente capítulo, trata sobre las clases básicas incorporadas en el lenguaje de 1 programación Java, agrupadas en el paquete java.lang. 2

Es importante mencionar que utilizando las clases preprogramadas de Java se puede ahorrar mucho tiempo y esfuerzo de programación, construyendo fácilmente aplicaciones profesionales.

1

Paquete: Conjunto de clases similares. Un paquete permiten organizar las clases. Un paquete contiene clases que tienen funciones similares. 2

Clase: Colección de objetos del mismo tipo. Una clase es una implantación de un “tipo de objeto”, 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). El mundo real se modela mediante clases. Una clase es una abstracción y no referencia a ningún objeto en particular.

Pag. 261


Pag. 262


EL PAQUETE DEL LENGUAJE JAVA El paquete del lenguaje Java, conocido también como java.lang, es uno de los paquetes más 3 importantes de la API de Java, y contiene las clases que constituyen el corazón del lenguaje de programación Java. El paquete Java.lang debido a su importancia no requiere ser importado por las aplicaciones para usar las clases que contiene, es decir, está automáticamente importado para todos los programas, por lo que la siguiente sentencia no será necesaria:

import java.lang.* ; El paquete java.lang contiene clases que encapsulan los tipos primitivos de datos, una clase 4 que proporciona los objetos para manipular la entrada y la salida estándar, clases para 5 manipular cadenas de caracteres, una clase que proporciona métodos correpondientes a las funciones matemáticas, etc. 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. 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.

4

Objetos: Modelos de entes del mundo. Un objeto de software es cualquier cosa, real o abstracta, acerca del cual almacenamos datos y los métodos que controlan dichos datos.

5

Métodos: Desarrollo de algoritmos. Los métodos especifican la forma en que se controlan los datos de un objeto y es donde se define el comportamiento del mismo. En palabras sencillas; en los métodos se desarrollan o codifican los algoritmos.

Pag. 263


Entre las clases a tratar en el presente capítulo se tienen: 1. Clases que envuelven los tipos de datos primitivos, conocidas como las clases 6 wrappers (envoltorios). Cada una de estas clases (consideradas subclases ), a 7 excepción de la clase Character, se derivan de la clase abstracta Number (considerada superclase). • • • • • • • •

Boolean. Byte. Character. Double. Float. Integer. Long. Short.

2. Clase que proporciona métodos correspondientes a las funciones matemáticas básicas. •

Math.

3. Clase que proporciona los objetos necesarios para manipular y tratar cadenas de caracteres. •

String.

6

Herencia: Subclase y Superclase. La Herencia es uno de los conceptos más importantes de la Programación Orientada a Objetos (POO). Utilizando la herencia se puede derivar una nueva clase a partir de otra clase existente, donde la nueva clase derivada heredará todos los atributos y métodos de la clase existente. La nueva clase se llama Clase Derivada (o subclase) y la clase original se llama Clase Base (o superclase). 7

Clase Abstracta: Clase tratada como SuperClase. Una Clase Abstracta es un tipo de clase de la cual no se pueden crear o instanciar objetos. En su lugar, se debe derivar una nueva clase a partir de la clase abstracta, codificar los métodos que son declarados como abstractos en la clase abstracta y crear o instanciar objetos a partir de la clase derivada. Las clases abstractas se utilizan para forzar a los programadores a desarrollar algunos o todos los métodos de una clase.

Pag. 264


En Java, los métodos siempre están dentro de una clase. Algunos métodos pueden ser invocados o ejecutados utilizando directamente el nombre de la clase en la cual están definidos, tal es el caso de los métodos de la clase Math de Java. Estos métodos son conocidos como métodos estáticos o de clase. 8

Por otro lado, otros métodos son invocados o ejecutados utilizando un objeto o instancia de la clase en la cual están definidos, tal es el caso de los métodos de la clase String de Java. Estos métodos son conocidos como métodos de instancia o de objeto.

8

Instancia: Representación concreta de una clase. Una Instancia viene a ser lo mismo que un objeto. Crear un objeto o instanciar una clase se refiere a poder tener una representación real de una clase.

Pag. 265


Pag. 266


ENVOLTORIOS DE LOS TIPOS DE DATOS PRIMITIVOS: CLASES WRAPPERS INTRODUCCIÓN Los tipos de datos primitivos (boolean, byte, char, double, float, int, long, short), conocidos también como tipos de datos simples, son los únicos elementos del lenguaje de programación Java que se representan internamente a través de valores, tal y como se representan en un lenguaje de programación convencional. 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. Esto tiene algunas ventajas desde el punto de vista de la eficiencia. En ocasiones, interesa sacrificar parte de la eficiencia por flexibilidad, 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. Dichas clases son conocidas como las clases wrappers (envoltorios). 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, tales como la conversión con cadenas de caracteres, comprobación, traslación, entre otras. Existe una clase wrapper para cada uno de los tipos de datos primitivos, que permiten tratarlos como objetos. Dichas clases se muestran a continuación: TIPO DE DATO PRIMITIVO

CLASES WRAPPERS

boolean

Boolean

byte

Byte

char

Character

double

Double

float

Float

int

Integer

Long

Long

9

Jerarquía de clases: Forma de ordenar las clases. La jerarquía de clases es una forma de ordenar las clases existentes en un lenguaje de Programación Orientado a Objetos (POO). 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. Java tiene su propia jerarquía de clases, estando en la parte superior de la jerarquía, la clase Object (esta clase pertenece al paquete java.lang).

Pag. 267


TIPO DE DATO PRIMITIVO Short

CLASES WRAPPERS Short

Cada uno de estas clases wrappers (a excepción de Character), tienen un método que permite convertir desde una cadena (String) al tipo primitivo. Simplemente hay que ejecutar el método de la clase wrappers adecuada y el String se convierte al tipo de dato primitivo asociado.

JERARQUÍA DE CLASES Y HERENCIA java.lang.Object

java.lang.Boolean

java.lang.Character

Byte

Double

Float

java.lang.Number

Integer

Long

Short

Las clases Java, en general, tienen métodos estáticos y métodos de instancia. Para ejecutar un método de instancia es necesario crear un objeto de la clase donde está definido dicho método. Para crear un objeto en Java se usa la sentencia new (a excepción de los objetos de algunas clases, como los objetos de la clase String que no necesariamente se crean con dicha sentencia). Por ejemplo, para crear un objeto de la clase Integer utilizamos: int i = 5; Integer I = new Integer ( i ); Donde el objeto I, es un objeto de la clase Integer, que tiene un valor igual a 5 y métodos para manipular dicho valor.

Pag. 268


MÉTODOS Con la finalidad de resumir los métodos de las clases wrappers que permiten la conversión, comprobación y traslación de datos, se utilizarán algunos objetos de dichas clases. Se asume que los objetos han sido creados previamente. Dichos objetos son:

OBJETO

CLASE AL QUE PERTENECE

S

String

I

Integer

L

Long

F

Float

D

Double

C

Character

También se utilizarán algunas variables para lo cual se deberá asumir que dichas variables han sido declaradas previamente. Las variables son: VARIABLE

TIPO DE DATO PRIMITIVO

i

int

l

long

f

float

d

double

b

boolean

c

char

Para referirnos a objetos se utilizará una letra en mayúscula, mientras que, para referirnos a las variables se utilizará una letra minúscula.

Pag. 269


Conversión de tipo de dato primitivo a objeto String Se puede convertir el valor de un tipo de dato primitivo o simple, a un valor de tipo cadena contenido en un objeto String. Para realizar esta conversión, se puede utilizar clases wrappers y variables, o utilizar objetos de las clases wrappers. 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 utilizando clases wrappers y variables: CLASES WRAPPERS Y VARIABLES

OBJETO STRING S

=

Integer.toString (i ) ;

S

=

Long.toString ( l ) ;

S

=

Float.toString ( f ) ;

S

=

Double.toString ( d ) ;

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

Conversión de tipo de dato primitivo a objeto String utilizando objetos wrappers: OBJETO STRING

OBJETOS WRAPPERS

S

=

I.toString ( ) ;

S

=

L.toString ( ) ;

S

=

F.toString ( ) ;

S

=

D.toString ( ) ;

Observe que se utiliza el método toString ( ) para convertir el valor contenido en el objeto wrappers a un valor de tipo cadena contenido en un objeto String. A pesar que el método toString ( ) es un método estático o de clase, también puede ejecutarse utilizando un objeto.

Pag. 270


Todas las clases wrappers tienen en común el método estático o de clase toString ( ). Esto se debe, a que este método no pertenece a dichas clases, sino que pertenece a la clase Object. 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). Todas las clases en Java pueden utilizar los métodos definidos en la clase Object (debido fundamentalmente a la herencia), y uno de los métodos definidos en esta clase, como ya se ha mencionado, es el método toString ( ). | Conversión de objetos String a tipo de dato primitivo Se puede convertir un objeto String a un tipo de dato primitivo, siempre y cuando el objeto String contenga un dato equivalente al tipo de dato primitivo que se desea convertir.

Conversión de objetos String a tipos de dato primitivo, utilizando clases wrappers y objeto String: VARIABLE

WRAPPERS Y OBJETO STRING

i

=

Integer.valueOf (S) ; Integer.parseInt (S) ;

l

=

Long.valueOf (S) ; Long.parseLong (S) ;

f

=

Float.valueOf (S) ; Float.parseFloat (S) ;

d

=

Double.valueOf (S) ; Double.parseDouble (S) ;

Observe que se utiliza el método valueOf ( ) para convertir el valor contenido en el objeto String S, a un dato de tipo primitivo o valor de una variable. Este método es un método estático o de clase. También se tiene la posibilidad de utilizar los métodos parseInt ( ), parseLong ( ), parseFloat ( ) y parseDouble ( ) para los wrappers Integer, Long, Float y Double respectivamente.

Pag. 271


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, siempre y cuando el objeto String contenga un valor equivalente al valor del tipo de dato primitivo que se desea convertir.

Conversión de objetos wrappers a tipos de dato primitivo, utilizando clases wrappers: VARIABLE

CLASES WRAPPERS

i

=

I.intValue ( ) ; L.intValue ( ) ; F.intValue ( ) ; D.intValue ( ) ;

l

=

I.longValue ( ) ; L.longValue ( ) ; F.longValue ( ) ; D.longValue ( ) ;

f

=

I.floatValue ( ) ; L.floatValue ( ) ; F.floatValue ( ) ; D.floatValue ( ) ;

d

=

I.doubleValue ( ) ; L.doubleValue ( ) ; F.doubleValue ( ) ; D.doubleValue ( ) ;

Observe que todas las clases wrappers tienen en común los métodos de instancia intValue ( ), longValue ( ), floatValue ( ) y doubleValue ( ).

Todas las clases wrappers tienen en común los métodos de instancia intValue( ), longValue( ), floatValue( ) y doubleValue( ). Estos métodos pertenecen en realidad a la clase Number. La clase Number es la superclase de las clases wrappers (a excepción de la clase wrapper Character). Estas clases pueden utilizar los métodos definidos en la clase Number a través de la herencia.

Pag. 272


Comprobaciones del valor Not-a-Number

Comprobación del valor Not-a-Number utilizando clases wrappers y variables: CLASES WRAPPERS Y VARIABLES

VARIABLE b

=

Float.isNaN ( f ) ; Double.isNaN ( d );

Comprobación del valor Not-a-Number utilizando clases wrappers y variables: VARIABLE b

OBJETOS WRAPPERS =

F.isNaN ( ) ; D.isNaN ( );

Observe que se utiliza el método isNaN ( ) para determinar si la variable es o no un número. 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.0 / 0.0.

Comprobaciones del valor infinito

Comprobación del valor infinito utilizando clases wrappers y variables: CLASES WRAPPERS Y VARIABLES

VARIABLE b

=

Float.isInfinite ( f ) ; Double.isInfinite ( d );

Pag. 273


Comprobación del valor infinito utilizando objetos wrappers: VARIABLE

OBJETOS WRAPPERS

b

F.isInfinite ( ) ; D.isInfinite ( );

=

Observe que se utiliza el método isInfinite ( ) para determinar si la variable es o no un número infinito. El método devuelve true si el valor de la variable es un número infinito. Los valores Infinite proceden normalmente de la división por cero de un valor finito. Por ejemplo el resultado de la siguiente operación: 10.5 / 0.0.

Comprobaciones de caracteres

Comprobación de caracteres utilizando la clase Character y variable tipo char: CLASE Character Y VARIABLE char

VARIABLE

b

Character.isLowerCase (c) ;

“Devuelve true si el caracter es una letra minúscula”.

Character.isUpperCase (c) ;

“Devuelve true si el caracter es una letra mayúscula”.

Character.isDigit (c) ;

“Devuelve true si el caracter es un dígito decimal”.

Character.isSpace (c) ;

“Devuelve true si el caracter es un espacio en blanco”.

=

Pag. 274


Traslación de caracteres

Traslación de caracteres utilizando la clase Character y variable tipo char:

CLASE Character y VARIABLE char

VARIABLE

c

Character.toLowerCase (c);

“Convierte el caracter a una letra minúscula”.

Character.toUpperCase (c);

“Convierte el caracter a una letra mayúscula”.

=

Pag. 275


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

Pag. 276


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

Pag. 277


Problema 63 Etapa 01 - Descripción del problema. Desarrollar un programa en Java que permita convertir una cadena en un número entero y en un objeto de tipo Integer. Calcular y mostrar la suma de ambos valores. Etapa 04 - Desarrollo de la Codificación. Clase PrgCadenaAEntero package dominioDeLaAplicacion ; class PrgCadenaAEntero { public static void main ( String arg [ ] ) { int numEntero = 0 ; String cadena = “10" ; numEntero = Integer.parseInt ( cadena ) ; Integer objInteger = Integer.valueOf ( cadena ) ; System.out.println ( “ Valores enteros: ” + numEntero + “ " + objInteger ) ; System.out.println ( “ La suma es: ” + (numEntero + objInteger.intValue ( ) ) ) ; } }

Observe que es posible convertir una cadena (String) en un valor entero (int) o en un objeto de la clase Integer. Recuerde, que deberá asegurarse que la cadena contenga un valor válido para que pueda ser almacenado en un tipo de dato determinado. 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. El método intValue ( ) nos permite obtener el valor entero del objeto (objInteger) de la clase Integer. Como sugerencia desarrolle un programa en Java que realice lo mismo que este programa pero utilice una variable long y la clase Long.

Pag. 278


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

Pag. 279


Pag. 280


FUNCIONES MATEMÁTICAS: CLASE MATH INTRODUCCIÓN La clase Math, es una clase que viene incorporada en el lenguaje de programación Java, incluida en el paquete java.lang, la cual nos proporciona métodos y atributos, para implementar diversas funciones mátemáticas.

JERARQUÍA DE CLASES Y HERENCIA

java.lang.Object

java.lang.Math

El paquete java.lang es el paquete principal del lenguaje Java por lo cual no se necesita importar ninguna clase incluida en dicho paquete. En consecuencia, no será necesario importar el paquete java.lang cada vez que se necesite utilizar la clase Math de Java. La clase Math contiene métodos de cálculo básico, como exponencial, logaritmo, raiz cuadrada y funciones trigonométricas. La clase Math a diferencia de otras clases es 10 una clase final . Esto significa que no puede ser instanciada (es decir; no se pueden crear objetos de la clase Math). 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, el operador punto y el nombre del método a utilizar. Ejemplo: Math.pow (a, b) ;

10

Clase Final: No puede ser una superclase. Una clase final o declarada como final es una clase que no puede ser una superclase. Es decir, las clases finales no pueden heredarse. Todos los métodos de una clase final son implícitamente finales.

Pag. 281


MÉTODOS La clase Math presenta los siguientes atributos y métodos de clase: Atributos de clase: 1. E. 2. PI. Métodos de clase: 1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19.

abs( ). acos( ). asin( ). atan( ). ceil( ). cos( ). exp( ). floor( ). log( ). max( ). min( ). pow( ). random( ). round( ). sin( ). sqrt( ). tan( ). toDegrees( ). toRadians( ).

Para trabajar con los métodos de clase, de la clase Math, no será necesario crear previamente un objeto de dicha clase (esto se cumple para todas las clases que implementen métodos de clase). Para ejecutar un método de clase, de la clase Math, es necesario colocar la palabra Math (que es el nombre de la clase), el operador punto (.) y el nombre del método de clase que desea ejecutar. Asimismo; para ejecutar un método de la clase Math debemos tener en cuenta que si, el método necesita algunos datos, estos deben ser necesariamente proporcionados en la cantidad y tipos requeridos. 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. A continuación se presenta una breve descripción del uso de cada uno de los métodos de la clase Math:

Pag. 282


CLASE Math ATRIBUTOS DE CLASE

DESCRIPCIÓN Almacena el valor de E. Es decir, nos proporciona la base de un logaritmo natural. El valor es equivalente a 2.718281828459045.

E

PI

MÉTODOS DE CLASE

Almacena el valor de PI. Es decir, almacena el valor equivalente a 3.141592653589793.

USO double e = Math.E ; System.out.print( e) ; Resultado: e = 2.718281828459045. double pi = Math.PI ; System.out.print( pi) ; Resultado: pi = 3.141592653589793.

DESCRIPCIÓN

USO

abs (float) abs (double) abs (int)

Retorna el valor absoluto de un número (que puede ser float, double, int, long) dado como parámetro.

int x = -5 ; System.out.print( Math.abs( x)) ; Resultado: x = 5.

abs (long)

acos (double)

asin (double)

Retorna un valor double con el arcocoseno de un ángulo expresado en radianes. El ángulo expresado en radianes debe ser un valor double enviado al método como parámetro.

Retorna un valor double con el arcoseno de un ángulo expresado en radianes. El ángulo expresado en radianes debe ser un valor double enviado al método como parámetro.

double angulo = 45.0 * Math.PI/180.0; double result ; result = Math.acos( angulo ) ; System.out.print( result ) ; Resultado : result = 0.6674572160283838

double angulo = 45.0 * Math.PI/180.0 ; double result ; result = Math.asin( angulo ) ; System.out.print( result ) ; Resultado : result = 0.9033391107665127

atan (double)

Retorna un valor double con el arcotangente de un ángulo expresado en radianes. El ángulo expresado en radianes debe ser un valor double enviado al método como parámetro.

Pag. 283

double angulo = 45.0 * Math.PI/180.0 ; double result ; result = Math.atan( angulo ) ; System.out.print( result ) ;


MÉTODOS DE CLASE

DESCRIPCIÓN

USO Resultado : result = 0.6657737500283538

ceil (double)

Retorna un valor double con el valor más corto no menor que el parámetro dado. El parámetro dado debe ser double.

double n = 0.65 , result ; result = Math.ceil( n ) ; System.out.print( result ) ; Resultado: result = 1.0

cos (double)

Retorna un valor double con el coseno de un ángulo expresado en radianes. El ángulo expresado en radianes debe ser un valor double enviado al método como parámetro.

double angulo = 30.0 * Math.PI/180.0 ; double result ; result = Math.cos( angulo ) ; System.out.println( result ) ; Resultado : result = 0.8660254037844387

exp (double)

Retorna un valor double con el valor exponencial de Euler del parámetro dado. El parámetro dado sebe ser double.

double exponente=1.0 , result ; result = Math.exp(exponente) ; System.out.println(result) ; Resultado: result = 2.7182818284590455

floor (double)

Retorna un valor double con el valor más grande no mayor que el parámetro dado. El parámetro dado debe ser double.

double n = 5.65 , result ; result = Math.floor(n) ; System.out.print(result) ; Resultado: resutl = 5.0

log (double)

Retorna un valor double con el logaritmo natural (base e) de un parámetro dado. El parámetro dado sebe ser double.

double logaritmo = 3.0 , result ; result = Math.log(logaritmo) ; System.out.println( result ) ; Resultado: result = 1.0986122886681096

max (float, float)

Retorna el valor del número mayor (que puede ser float, double, int, long) de dos números dados como parámetros.

max (double, double)

double x = 10 , y = 15 , mayor ; mayor = Math.max( x , y ) ; System.out.print ( mayor ) ; Resultado:

Pag. 284


MÉTODOS DE CLASE

DESCRIPCIÓN

max (int, int)

USO mayor = 15.

max (long, long)

min (float, float) min (double, double) min (int, int)

Retorna el valor del número menor (que puede ser float, double, int, long) de dos números dados como parámetros.

double x = 10 , y = 15 , menor ; menor = Math.min( x , y ) ; System.out.print ( menor ) ; Resultado: menor = 10.

min (long, long)

pow (double, double)

random ()

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). Los dos parámetros dados deben ser double.

Retorna un valor double con un número generado aleatoriamente (al azar) mayor o igual que 0.0 y menor que 1.0.

double x = 2 , y = 4 , result ; result = Math.pow( x , y ) ; System.out.print ( result ) ; Resultado: result = 16.

double num ; num = Math.random( ) ; System.out.print ( num ) ;

round (float) Retorna un valor (que puede ser float o double) con el valor redondeado del parámetro dado. El parámetro dado puede ser un valor float o double. round (double)

sin (double)

double x = 10.53 , result ; result = Math.round( x ) ; System.out.print ( result ) ; Resultado: result = 11.

Retorna un valor double con el seno de un ángulo expresado en radianes. El ángulo expresado en radianes debe ser un valor double enviado al método como parámetro.

double angulo = 37.0 * Math.PI/180.0; double result ; result = Math.sin(angulo) ; System.out.println(result) ; Resultado:

Pag. 285


MÉTODOS DE CLASE

DESCRIPCIÓN

USO result = 0.6018150231520483

sqrt (double)

Retorna un valor double con la raiz cuadrada del parámetro dado. El parámetro dado debe ser un valor double.

double x = 16 , result ; result = Math.sqrt( x ) ; System.out.print ( result ) ; Resultado: result = 4.

tan (double)

Retorna un valor double con la tangente de un ángulo expresado en radianes. El ángulo expresado en radianes debe ser un valor double enviado al método como parámetro.

double angulo = 53.0 * Math.PI/180.0 ; double result ; result = Math.tan(angulo); System.out.println( result ) ; Resultado: result = 1.3270448216204098

toDegrees (double)

Retorna un valor double. Permite convertir un ángulo expresado en radianes (enviado como parámetro double) en un ángulo expresado en sexagesimal.

double angulo = Math.PI/3, result ; result = Math.toDegrees(angulo) ; System.out.println(result) ; Resultado: result = 59.99999999999999

toRadians (double)

Retorna un valor double. Permite convertir un ángulo expresado en sexadecimal (enviado como parámetro double) en un ángulo expresado en radianes.

double angulo = 60, result ; result = Math.toRadians(angulo) ; System.out.println( result ) ; Resultado: result = 1.0471975511965976

A continuación, con la finalidad de mejorar la comprensión del tema tratado, se presentan algunas soluciones a problemas planteados utilizando algunos de los métodos de la clase Math. Analice cada una de las siguientes soluciones.

Pag. 286


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

Pag. 287


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). Observe que en esta solución se emplea una estrategia mas simple para determinar el número mayor entre tres números. El método max ( ) de la clase Math, retorna el valor del número mayor (puede ser un número float, double, int o long) de dos números dados como parámetros. En nuestro ejemplo determinamos el mayor de los dos últimos números ingresados y en la misma línea de código evaluamos el mayor de estos dos números con el primer número ingresado, tal y como se muestra a continuación: resultado = Math.max ( num1, Math.max ( num2, num3 ) ) ; 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.

Pag. 288


Problema 66 Etapa 01 - Descripción del problema. Desarrollar un programa en Java que permita ingresar 3 números enteros a través del teclado. Determinar y mostrar cuál de ellos es el número menor. Etapa 04 - Desarrollo de la Codificación. Clase PrgNumeroMenor package dominioDeLaAplicacion ; import biblioteca.Lectura ; class PrgNumeroMenor { public static void main ( String arg [ ] ) { int num1, num2, num3, resultado ; System.out.println ( “ Ingresar el primer número: ” ) ; num1 = Lectura.leerInt( ) ; System.out.println ( “Ingresar el segundo número: ” ) ; num2 = Lectura.leerInt( ) ; System.out.println ( “Ingresar el tercer número: ” ) ; num3 = Lectura.leerInt( ) ; resultado = Math.min ( num1, Math.min ( num2, num3 ) ) ; System.out.println ( “ El número menor es: " + resultado ) ; } }

¿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). Observe que Math.min ( ) retorna el valor del número menor (que puede ser float, double, int, long) de dos números dados como parámetros. En nuestro ejemplo hallamos el menor de los dos últimos números ingresados, y en la misma línea evaluamos el menor de estos dos números con el primer número ingresado, tal y como se muestra a continuación: resultado = Math.min ( num1, Math.min ( num2, num3 ) ) ;

Pag. 289


Problema 67 Etapa 01 - Descripción del problema. Desarrollar un programa en Java que permita generar una cantidad determinada de números aleatorios. Los números aleatorios generados deberán estar entre 1 y 6. Mostrar el número generado aleatoriamente y la suma de dichos números. Etapa 04 - Desarrollo de la Codificación. Clase PrgNumerosAleatorios package dominioDeLaAplicacion ; import biblioteca.Lectura ; class PrgNumerosAleatorios { public static void main ( String arg [ ] ) { int x, cant, num, suma=0 ; System.out.print ( “Ingresar la cantidad de números aleatorios a generar: ” ) ; cant = Lectura.leerInt( ) ; for ( x = 1; x <= cant; x++) { num = 1 + (int) ( Math.random( ) * 6 ) ; System.out.println ( “El número aleatorio generado es: ” + num ) ; suma = suma + num ; } System.out.println ( “La suma de los números aleatorios es: ” + suma ) ; } }

¿Que hay de nuevo en la codificación? Observe el uso del método random ( ) de la clase Math: num = 1 + (int) (Math.random ( ) * 6 ) ; 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. Cada vez que se ejecuta la sentencia for, se genera y muestra un número aleatorio (un número entre 1 y 6), el cual es acumulado en la variable suma. Finalizada la ejecución de la sentencia for se muestra el contenido de dicha variable (es decir, se muestra la suma de los números aleatorios generados). Recuerde que para generar números aleatorios entre dos números (entre un intervalo o rango), utilizando el método random ( ) de la clase Math, se emplea la siguiente fórmula:

Pag. 290


min + (int) ( Math.random( ) * (max – min + 1 ) ) ; Para nuestro ejemplo tenemos: 1 + (int) ( Math.random( ) * ( 6 – 1 + 1 ) ) ; 1 + (int) ( Math.random( ) * ( 6 ) ) ;

Pag. 291


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

Pag. 292


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

Pag. 293


Problema 70 Etapa 01 - Descripción del problema. Desarrollar un programa en Java que permita ingresar por teclado el radio de una esfera. Calcular y mostrar el volumen de dicha esfera. Etapa 04 - Desarrollo de la Codificación. Clase PrgRadioEsfera package dominioDeLaAplicacion ; import biblioteca.Lectura ; class PrgRadioEsfera { public static void main ( String arg [ ] ) { double radio, volume ; System.out.println ( “Ingresar el radio de la esfera: ” ) ; radio = Lectura.leerDouble(); volume = (4 / 3) * Math.PI * Math.pow ( radio, 3 ) ; System.out.println ( “El volumen de la esfera es: ” + volume ) ; } }

¿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.PI * Math.pow ( radio, 3 ) ; 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). En nuestro caso el método pow ( ) eleva a la potencia 3 el radio del círculo. Para hallar el volumen de la esfera se tendrá que utilizar la fórmula v=4/3*PI*R3. La clase Math define un atributo (constante) muy útil, que contiene en valor del número PI (Math.PI).

Pag. 294


Problema 71 Etapa 01 - Descripción del problema. Desarrollar un programa en Java que permita ingresar un número decimal. Mostrar el número ingresado redondeado. Etapa 04 - Desarrollo de la Codificación. Clase PrgNumRedondeado package dominioDeLaAplicacion ; import biblioteca.Lectura ; class PrgNumRedondeado { public static void main ( String arg [ ] ) { double num, resultado ; System.out.println ( “Ingrese un número decimal: ” ) ; num = Lectura.leerDouble( ) ; resultado = Math.round(num) ; System.out.println ( “El número redondeado es: ” + resultado ) ; } }

¿Que hay de nuevo en la codificación? Observe el uso del método round ( ) de la clase Math: resultado = Math.round(num) ; El método round ( ) permite redondear un número dado como parámetro. En esta solución se ingresa un número y se almacena en la variable num. Luego, dicho número es redondeado utilizando el método round ( ) y se almacena en la variable resultado.

Pag. 295


Problema 72 Etapa 01 - Descripción del problema. Desarrollar un programa en Java que permita ingresar un número entero y un exponente. Mostrar el resultado de calcular la potencia de todos los números menores que el número ingresado elevado al exponente ingresado. Etapa 04 - Desarrollo de la Codificación. Clase PrgNumPotencia package dominioDeLaAplicacion ; import biblioteca.Lectura ; class PrgNumPotencia { public static void main ( String arg [ ] ) { int cant, expo ; double rpta ; System.out.println ( “Ingresar un número entero: ” ) ; cant = Lectura.leerInt( ) ; System.out.println ( “Ingresar el exponente: ” ) ; expo = Lectura.leerInt( ) ; for ( int x = 1; x < cant; x++) { rpta = Math.pow ( x, expo ) ; System.out.println ( “El Exponencial de ” + x + “ es: ” + rpta ) ; } } }

¿Que hay de nuevo en la codificación? Observe el uso del método pow ( ) de la clase Math: rpta = Math.pow ( x, expo ) ; El método pow ( ) permite elevar a la potencia un número determinado. 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. La variable cant y el exponente expo se ingresan por el teclado. Recuerde y siempre tenga presente que el método pow ( ) de la clase Math, retorna un valor double, por lo que dicho valor deberá ser almacenado en una variable del mismo tipo o deberá mostrarse por la pantalla.

Pag. 296


Problema 73 Etapa 01 - Descripción del problema. Desarrollar un programa en Java que permita ingresar un número entero. Mostrar el resultado de calcular la raíz cuadrada de todos los números menores que el número ingresado. Etapa 04 - Desarrollo de la Codificación. Clase PrgNumRaiz package dominioDeLaAplicacion ; import biblioteca.Lectura ; class PrgNumRaiz { public static void main ( String arg [ ] ) { int cant ; double rpta ; System.out.println ( “Ingrese un número entero: ” ) ; cant = Lectura.leerInt( ) ; for ( int x = 1; x < cant; x++ ) { rpta = Math.sqrt (x) ; System.out.println ( “La raíz cuadrada de ” + x + “ es: ” + rpta ) ; } } }

¿Que hay de nuevo en la codificación? Observe el uso del método sqrt ( ) de la clase Math: rpta = Math.sqrt ( x ) ; El método sqrt ( ) permite obtener la raíz cuadrada de un número determinado. En la presente solución se utiliza una sentencia for con la finalidad de obtener la raíz cuadrada de todos los números menores que la variable cant y mostrarlos por pantalla. La variable cant se ingresa por el teclado. Recuerde y siempre tenga presente que el método sqrt ( ) de la clase Math, retorno un valor double, por lo que dicho valor deberá ser almacenado en una variable del mismo tipo o deberá mostrarse por la pantalla.

Pag. 297


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

Pag. 298


Problema 75 Etapa 01 - Descripción del problema. Desarrollar un programa en Java que permita determinar y mostrar el área de un tríangulo en base a las longitudes de sus lados. Considerar el valor absoluto de la diferencia entre el semiperimetro y cada uno de los lados. Utilizar las siguientes fórmulas: area = ( p * (|p-a|)*(|p-b|)*(|p-c|)) RAIZ (2). p = (a+b+c) / 2. Donde: p = Semiperímetro. a, b, c = Lados del triángulo.

Etapa 04 - Desarrollo de la Codificación. Clase PrgTriangulo package dominioDeLaAplicacion ; import biblioteca.Lectura ; class PrgTriangulo { public static void main ( String arg [ ] ) { double a, b, c, p, tmp, area ; System.out.println ( “Ingrese el valor del primer lado del triángulo (a): ” ) ; a = Lectura.leerDouble( ) ; System.out.println ( “Ingrese el valor del segundo lado del triángulo (b): ” ) ; b = Lectura.leerDouble( ) ; System.out.println ( “Ingrese el valor del terecr lado del triángulo (c): ” ) ; c = Lectura.leerDouble( ) ; p = (a + b + c) / 2 ; tmp = ( p * (Math.abs(p - a)) * (Math.abs(p - c)) * (Math.abs(p - b) ) ) ; area = Math.sqrt ( tmp ) ; System.out.println ( “El área del triángulo es: ” + area ) ; } }

Pag. 299


¿Que hay de nuevo en la codificación?

Observe el uso de los métodos abs ( ) y sqrt ( ) de la clase Math: tmp = ( p * (Math.abs(p - a)) * (Math.abs(p - c)) * (Math.abs(p - b) ) ) ; area = Math.sqrt ( tmp ) ; 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. Luego, 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, 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. Luego, se multiplican los valores resultantes con el valor del semiperímetro del triángulo y finalmente, se obtiene la raíz cuadrada del valor resultante utilizando el método sqrt ( ) de la clase Math.

Pag. 300


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

Pag. 301


Problema 77 Etapa 01 - Descripción del problema. Desarrollar un programa en Java que permita ingresar un ángulo expresado en grados. Deeterminar el tipo de ángulo ingresado y su equivalente en radianes. Los ángulos expresados en grados se clasifican de la siguiente manera: 0 grados. Entre 0 y 90 grados. 90 grados. Entre 90 y 180 grados. 180 grados. Entre 180 grados y 360 grados. 360 grados.

= Nulo. = Agudo. = Recto. = Obtuso. = Llano. = Cóncavo. = Completo.

Etapa 04 - Desarrollo de la Codificación. Clase PrgConversionAngulo package dominioDeLaAplicacion ; import biblioteca.Lectura ; class PrgConversionAngulo { public static void main ( String arg [ ] ) { double anguloGrados, anguloRadianes ; String tipoAngulo = “” ; System.out.println ( “ Ingrese un ángulo en grados (entre 0 y 360): ” ) ; anguloGrados = Lectura.leerDouble( ) ; if (anguloGrados == 0) tipoAngulo = “Nulo” ; if (anguloGrados > 0 && anguloGrados < 90) tipoAngulo = “Agudo” ; if (anguloGrados == 90) tipoAngulo = “Recto” ; if (anguloGrados > 90 && anguloGrados < 180) tipoAngulo = “Obtuso” ; if (anguloGrados == 180) tipoAngulo = “Llano” ; if (anguloGrados > 180 && anguloGrados < 360) tipoAngulo = “Concavo” ; if (anguloGrados == 360) tipoAngulo = “Completo” ; anguloRadianes = Math.toRadians (anguloGrados) ; System.out.println ( “ Tipo de ángulo: ” + tipoAngulo ) ; System.out.println ( “ Ángulo expresado en radianes: ” + anguloRadianes ) ; } }

Pag. 302


¿Que hay de nuevo en la codificación? Observe el uso del método toRadians ( ) de la clase Math: anguloRadianes = Math.toRadians (anguloGrados) ; 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. El tipo de ángulo es almacenado en una variable String (tipoAngulo) y mostrado por pantalla. Para realizar la conversión del ángulo ingresado en el sistema sexagesimal al sistema radial se utiliza el método toRadians ( ) de la clase Math.

Pag. 303


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

Pag. 304


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

Pag. 305


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

Pag. 306


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

Pag. 307


Problema 80 Etapa 01 - Descripción del problema. Desarrollar un programa en Java que permita ingresar 6 números a traves del teclado. Determinar y mostrar cuál de ellos es el número mayor y cuál es el número menor. Etapa 04 - Desarrollo de la Codificación. Clase PrgNumeroMayorMenor package dominioDeLaAplicacion ; import biblioteca.Lectura ; class PrgNumeroMayorMenor { public static void main ( String arg [ ] ) { int n1, n2, n3, n4, n5, n6 ; double mayor, meno r; System.out.println ( “ Ingrese el primer número: ” ) ; n1 = Lectura.leerInt(); System.out.println ( “ Ingrese el segundo número: ” ) ; n2 = Lectura.leerInt( ) ; System.out.println ( “ Ingrese el tercer número: ” ) ; n3 = Lectura.leerInt( ) ; System.out.println ( “ Ingrese el cuarto número: ” ) ; n4 = Lectura.leerInt( ) ; System.out.println ( “ Ingrese el quinto número: ” ) ; n5 = Lectura.leerInt( ) ; System.out.println ( “ Ingrese el sexto número: ” ) ; n6 = Lectura.leerInt( ) ; mayor = Math.max (n1,n2) ; mayor = Math.max (mayor,n3) ; mayor = Math.max (mayor,n4) ; mayor = Math.max (mayor,n5) ; mayor = Math.max (mayor,n6) ; menor = Math.min (n1,n2) ; menor = Math.min (menor,n3) ; menor = Math.min (menor,n4) ; menor = Math.min (menor,n5) ; menor = Math.min (menor,n6) ; System.out.println ( “ El mayor número es: " + mayor ) ; System.out.println ( “ El menor número es: " + menor ) ; } }

Modificar la codificación de la solución de tal forma que pueda optimizar el código. Utilice una sentencia for.

Pag. 308


Problema 81 Etapa 01 - Descripción del problema. Desarrollar un programa en Java que permita ingresar las notas de todos los alumnos de un determinado salon de clase. Calcular y mostrar el promedio final de cada alumno en base a la siguiente fórmula: pf = ( pp + ep + ( ef * 2 ) ) / 4. Donde: pf = Promedio final. pp = Promedio de prácticas. Son 4 prácticas de las cuales se elimina la más baja pp = ( p1 + p2 + p3 + p4 – notaMenor ) / 3 ep = Examen parcial. ef = Examen final.

Etapa 04 - Desarrollo de la Codificación. Clase PrgPromedioNotas package dominioDeLaAplicacion ; import biblioteca.Lectura ; class PrgPromedioNotas { public static void main ( String arg [ ] ) { double pf, pp, ep, ef, p1, p2, p3, p4, notaMenor ; char opc ; do { System.out.println ( “ Ingrese la nota de la práctica 1: ” ) ; p1 = Lectura.leerDouble( ) ; System.out.println ( “ Ingrese la nota de la práctica 2: ” ) ; p2 = Lectura.leerDouble( ) ; System.out.println ( “ Ingrese la nota de la práctica 3: ” ) ; p3 = Lectura.leerDouble( ) ; System.out.println ( “ Ingrese la nota de la práctica 4: ” ) ; p4 = Lectura.leerDouble( ) ; System.out.println ( “ Ingrese la nota del examen parcial: ” ) ; ep = Lectura.leerDouble( ) ; System.out.println ( “ Ingrese la nota del examen final: ” ) ; ef = Lectura.leerDouble( ) ; notaMenor = Math.min (p1,p2) ; notaMenor = Math.min (notaMenor,p3) ; notaMenor = Math.min (notaMenor,p4) ;

Pag. 309


Continúa…


Clase PrgPromedioNotas pp = ( p1 + p2 + p3 + p4 – notaMenor ) / 3 ; pf = ( pp + ep + ef ) / 3 ; pf = Math.round (pf) ; System.out.println ( “ El promedio final del alumno es: ” + pf ) ; System.out.println ( “ Desea continuar (si=s/ no=n)?: ” ) ; opc=Lectura.leerChar( ) ; } while ( opc=='s' || opc=='S' ) ; } }

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. Muestre el promedio de las notas redondeado a dos decimales.

Pag. 310


Problema 82 Etapa 01 - Descripción del problema. Desarrollar un programa en Java que permita ingresar un número cualquiera con parte decimal y muestre la parte entera del número, el número redondeado sin decimales, y el número redondeado a uno, dos y tres decimales. Etapa 04 - Desarrollo de la Codificación. Clase PrgRedondearNumero package dominioDeLaAplicacion ; import biblioteca.Lectura ; class PrgRedondearNumero { public static void main ( String arg [ ] ) { double numero ; System.out.println ( “ Ingrese un número con decimales: ” ) ; numero=Lectura.leerDouble( ) ; System.out.println ( “ -----------------------------------” ) ; System.out.println ( “ La parte entera del número es: ” ) ; System.out.println ( Math.floor (numero) ) ; System.out.println ( “ El número redondeado es: ” ) ; System.out.println ( Math.floor (numero+0.5) ) ; System.out.println ( “ El número redondeado a un decimal es: ” ) ; System.out.println ( Math.floor (numero * 10 + 0.5 ) / 10 ) ; System.out.println ( “ El número redondeado a dos decimales es: ” ) ; System.out.println ( Math.floor (numero * 100 + 0.5 ) / 100 ) ; System.out.println ( “ El número redondeado a tres decimales es: ” ) ; System.out.println ( Math.floor (numero * 1000 + 0.5 ) / 1000 ) ; } } ¿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. El parámetro dado debe ser double. Nótese que si ingresamos un numero cuya parte decimal es mayor que 5 sólo retorna la parte entera para tal caso se le agrega 0.5 para que en el segundo cálculo tenga efecto de redondeo perfecto. Observe como se redondea un número con uno, dos y tres decimales utilizando el método floor ( ).

Pag. 311


Problema 83 Etapa 01 - Descripción del problema. 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.

Etapa 04 - Desarrollo de la Codificación. Clase PrgSorteo package dominioDeLaAplicacion ; import biblioteca.Lectura ; class PrgSorteo { public static void main ( String arg [ ] ) { double num ; int boletos, ganador ; do { System.out.println ( “ Ingrese el total de boletos: ” ) ; boletos = Lectura.leerInt( ) ; if (boletos > 0) { do { num = boletos * Math.random( ) ; ganador = (int) Math.round(num) ; } while (ganador == 0) ; System.out.println ( “ El número ganador es: ” + ganador ) ; } } while ( boletos < 0 ) ; } }

Pag. 312


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

Pag. 313


Problema 85 Etapa 01 - Descripción del problema. Desarrollar un programa en Java que permita ingresar un ángulo no mayor de 360 grados ni menor de 0 grados. Mostrar como resultado el seno y el coseno del ángulo ingresado. Etapa 04 - Desarrollo de la Codificación. Clase PrgSenCos package dominioDeLaAplicacion ; import biblioteca.Lectura ; class PrgSenCos { public static void main ( String arg [ ] ) { double anguloGrados, anguloRadianes, seno = 0, coseno = 0 ; do{ System.out.println ( “ Ingrese un ángulo en grados entre 0 y 360: ” ) ; anguloGrados = Lectura.leerDouble( ) ; if (anguloGrados < 0 || anguloGrados > 360 ){ System.out.println ( “El dato ingresado es incorrecto, intente otra vez: ” ); } }while(anguloGrados < 0 || anguloGrados > 360) ; anguloRadianes = Math.toRadians( anguloGrados ) ; seno = Math.sin( anguloRadianes ) ; coseno = Math.cos( anguloRadianes ) ; System.out.println ( “ El sen [” + anguloGrados + “ ] = ” + seno ) ; System.out.println ( “ y el cos [” + anguloGrados + “ ] = ” + coseno ) ; } }

¿Qué hay de nuevo en la codificación? Observe el uso de los métodos toRadians ( ), sin ( ) y cos ( ) de la clase Math: Es importante mencionar que Java trabaja con el sistema radial y para obtener las razones trigonométricas, seno y coseno, de un ángulo ingresado por teclado hay que convertirlo primero al sistema radial. Para esto, utilizamos el método toRadians ( ) de la clase Math. 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. 314


en radianes. 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.

Pag. 315


Problema 86 Etapa 01 - Descripción del problema. Desarrollar un programa en Java que permita ingresar un ángulo de inclinación de la recta con respecto al eje x. Mostrar como resultado la pendiente de la recta.

Etapa 04 - Desarrollo de la Codificación. Clase PrgTangente package dominioDeLaAplicacion ; import biblioteca.Lectura ; class PrgTangente { public static void main ( String arg [ ] ) { double anguloGrados, anguloRadianes, tangente = 0 ; System.out.println ( “ Ingrese el ángulo de inclinación de la recta: ” ) ; anguloGrados = Lectura.leerDouble( ) ; anguloRadianes = Math.toRadians(anguloGrados) ; tangente = Math.tan(anguloRadianes) ; System.out.println ( “ La pendiente de la resta es = ” + tangente ) ; } }

¿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. Para ello, utiliza el ángulo de inclinación de la recta, expresado en el sistema radial, tal y como se muestra: tangente = Math.tan(anguloRadianes) ;

Pag. 316


Problema 87 Etapa 01 - Descripción del problema. Desarrollar un programa en Java que permita ingresar los catetos de un triángulo perpendicular. Calcular y mostrar la hipotenusa del tríangulo. Etapa 04 - Desarrollo de la Codificación. Clase PrgHipotenusa package dominioDeLaAplicacion ; import biblioteca.Lectura ; class PrgHipotenusa { public static void main ( String arg [ ] ) { double cateto1, cateto2, hipotenusa ; System.out.println ( “ Ingrese el primer cateto: ” ) ; cateto1 = Lectura.leerDouble( ) ; System.out.println ( “ Ingrese el segundo cateto: ”) ; cateto2 = Lectura.leerDouble( ) ; hipotenusa = Math.sqrt ( Math.pow (cateto1, 2) + Math.pow (cateto2, 2) ) ; System.out.println ( “ La hipotenusa del triángulo es: ” + hipotenusa) ; } }

La fórmula para este caso sería: (hipotenusa)2 = (cateto1)2 + (cateto2)2 . Se ingresan los catetos por el teclado y son elevados al cuadrado con Math.pow ( ). El resultado obtenido, al elevar al cuadrado cada uno de los catetos, se suman. Luego se obtiene la raíz cuadrada con Math.sqrt ( ) y finalmente se muestra el resultado almacenado en la variable hipotenusa. Ejemplo: Ingrese el primer cateto: 2 Ingrese el segundo cateto: 3 La hipotenusa del triángulo es: 3.605551275463989

Pag. 317


Problema 88 Etapa 01 - Descripción del problema. Desarrollar un programa en Java que permita ingresar la ordenada y la abscisa de un punto. Calcular y mostrar el ángulo de las coordenadas del punto en grados. Etapa 04 - Desarrollo de la Codificación.

Clase PrgPunto package dominioDeLaAplicacion ; import biblioteca.Lectura ; class PrgPunto { public static void main ( String arg [ ] ) { double ordenada, abscisa, anguloGrados, anguloRadianes ; System.out.println ( “ Ingrese la ordenada(y) del punto: ” ) ; ordenada = Lectura.leerDouble( ) ; System.out.println ( “ Ingrese la abscisa(x) del punto: ” ) ; abscisa = Lectura.leerDouble( ) ; anguloRadianes = Math.atan2(ordenada, abscisa) ; anguloGrados = Math.toDegrees(anguloRadianes) ; System.out.print ( “ El ángulo en grados de [” + ordenada + “,” ) ; System.out.println ( abscisa + “] es: ” + anguloGrados) ; } }

¿Qué hay de nuevo en la codificación? Observe el uso de los métodos atan2 ( ) y toDegress ( ) de la clase Math: anguloRadianes = Math.atan2(ordenada, abscisa) ; anguloGrados = Math.toDegrees(anguloRadianes) ; Sabemos que Math.atan ( ) retorna un valor double con el arcotangente de un ángulo expresado en radianes. Dicho ángulo expresado en radianes debe ser un valor double enviado al método como parámetro.

Pag. 318


Pero en este caso, se ingresan por teclado la ordenada y la abcisa de un punto cualquiera en el sistema de coordenadas, 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). En este caso, se utiliza el método atan2 ( ) de la clase Math. Este método nos permite obtener el valor del arcotangente de un par ordenado. 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, utilizando el método toDegrees ( ) de la clase Math.

Pag. 319


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

Pag. 320


Tenga presente que Java sólo resuelve logaritmos en base e y no en base 10.

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

Pag. 321


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

Pag. 322


Continúa…

Etapa 04 - Desarrollo de la Codificación. Clase PrgLanzarDados1

} else if ( suma1 == 2 || suma1 == 3 || suma1 == 12 ) { opc1 = “s” ; estado = 0 ; } else { do { System.out.println ( “Lanzar dados” ) ; Lectura.leerString ( ) ; dado1 = ( int ) (1 + ( Math.random ( ) * 6 ) ) ; dado2 = ( int ) (1 + ( Math.random ( ) * 6 ) ) ; suma2 = dado1 + dado2 ; System.out.println ( “Dado1 : ” + dado1 ) ; System.out.println ( “Dado2 : ” + dado2 ) ; if ( suma1 == suma2 ) { estado = 1 ; opc1 = “s” ; opc2 = “s” ; } else if ( suma2 == 7 ) { estado = 0 ; opc1 = “s” ; opc2 = “s” ; } } while ( opc2 != “s” ) ; } }while ( opc1 != “s” ) ; if ( estado == 1 ) System.out.println ( “El jugador gana” ) ; else System.out.println ( “El jugador pierde ” ) ; } }

Pag. 323


Problema 91 Etapa 01 - Descripción del problema. Modificar el programa del problema anterior, de tal forma que se muestre un mensaje preguntando si desea volver a tirar los dados. Etapa 04 - Desarrollo de la Codificación.

Clase PrgLanzarDados2 package dominioDeLaAplicacion ; import biblioteca.* ; class PrgLanzarDados2 { public static void main ( String arg [ ] ) { int dado1 = 0, dado2 = 0, suma1 = 0, suma2 = 0, estado = 0 ; String opc1 = “ ”, opc2 = “ ” ; char opc3 = ‘n’ ; do { opc1 = “ ” ; opc2 = “ ” ; do { System.out.println ( “Lanzar dados” ) ; Lectura.leerString ( ) ; dado1 = ( int ) (1 + ( Math.random ( ) * 6 ) ) ; dado2 = ( int ) (1 + ( Math.random ( ) * 6 ) ) ; suma1 = dado1 + dado2 ; System.out.println ( “Dado1 : ” + dado1 ) ; System.out.println ( “Dado2 : ” + dado2 ) ; if ( suma1 == 7 || suma1 == 11 ) { opc1 = “s” ; estado = 1 ; } else if (suma1 == 2 || suma1 == 3 || suma1 == 12) { opc1 = “s” ; estado = 0 ; } else {

Pag. 324


Continúa…


Clase PrgLanzarDados2

do { System.out.println ( “Lanzar dados” ) ; Lectura.leerString ( ) ; dado1 = ( int ) (1 + ( Math.random ( ) * 6 ) ) ; dado2 = ( int ) (1 + ( Math.random ( ) * 6 ) ) ; suma2 = dado1 + dado2 ; System.out.println ( “Dado1 : ” + dado1 ) ; System.out.println ( “Dado2 : ” + dado2 ) ; if ( suma1 == suma2 ) { estado = 1 ; opc1 = “s” ; opc2 = “s” ; } else if ( suma2 == 7 ) { estado = 0 ; opc1 = “s” ; opc2 = “s” ; } } while ( opc2 != “s” ) ; } } while ( opc1 != “s” ) ; if ( estado == 1 ) System.out.println ( “ El jugador gana ” ) ; else System.out.println ( “ El jugador pierde ” ) ; System.out.println ( “Desea volver a jugar [s/n] ” ) ; opc3 = Lectura.leerChar ( ) ; } while ( opc3 != ‘n’ ) ; }

}

Pag. 325


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

Pag. 326


Problema 93 Etapa 01 - Descripción del problema. Elaborar un programa que simule el juego de tragamonedas, los números son: 1, 2, 3, 4, 5 ,6 y 7 opciones de ganar. El jugador gana cuando el número se repita tres veces. Los números deberán ser generados aleatoriamente. El premio mayor se obtiene con el número 7. Etapa 04 - Desarrollo de la Codificación.

Clase PrgTragamoneda1 package dominioDeLaAplicacion ; import biblioteca.* ; class PrgTragamoneda1 { public static void main ( String arg [ ] ) { int valor1 = 0, valor2 = 0, valor3 = 0, monto = 0 ; char s, opc1 ; do { System.out.println( “Presionar enter para empezar” ) ; Lectura.leerString ( ) ; valor1 = ( int ) (1 + ( Math.random ( ) * 7 ) ) ; valor2 = ( int ) (1 + ( Math.random ( ) * 7 ) ) ; valor3 = ( int ) (1 + ( Math.random ( ) * 7 ) ) ; System.out.println ( valor1 + “ ” + valor2 + “ ” + valor3 ) ; if ( valor1 == valor2 && valor1 == valor3 ) { s = (char) valor1 ; switch (s) { case 1 : monto = 100 ; break ; case 2 : monto = 200 ; break ; case 3 : monto = 300 ; break ;

Pag. 327


Continúa…


Clase PrgTragamoneda1

case 4 : monto = 400 ; break ; case 5 : monto = 500 ; break ; case 6 : monto = 600 ; break ; case 7 : monto = 1000 ; break ; } System.out.println ( “Usted gana : ” + monto + “Soles ” ) ; } else System.out.println ( “La casa gana” ) ; monto = 0 ; System.out.println ( “Desea volver a jugador [s/n] : ” ) ; opc1 = Lectura.leerChar ( ) ; } while ( opc1 != ‘n’ ) ; } }

Pag. 328


Problema 94 Etapa 01 - Descripción del problema. Modificar el programa del problema anterior, de tal forma que se muestre la cantidad acumulada del dinero ganado en el tragamoneda. Etapa 04 - Desarrollo de la Codificación.

Clase PrgTragamoneda2 package dominioDeLaAplicacion ; import biblioteca.* ; class PrgTragamoneda2 { public static void main ( String arg [ ] ) { int valor1 = 0, valor2 = 0, valor3 = 0, monto = 0, acumonto = 0 ; char s,opc1 ; do { System.out.println ( “Presionar enter para empezar” ) ; Lectura.leerString ( ) ; valor1=( int ) (1 + ( Math.random ( ) * 7 ) ) ; valor2=( int ) (1 + ( Math.random ( ) * 7 ) ) ; valor3=( int ) (1 + ( Math.random ( ) * 7 ) ) ; System.out.println ( valor1 + “ ” + valor2 + “ ” + valor3 ) ; if ( valor1 == valor2 && valor1 == valor3 ) { s= (char) valor1 ; switch ( s ) { case 1 : monto=100 ; break ; case 2 : monto=200 ; break ;

Pag. 329


Continúa…


Clase PrgTragamoneda2

case 3 : monto=300 ; break ; case 4 : monto=400 ; break ; case 5 : monto=500 ; break ; case 6 : monto=600 ; break ; case 7 : monto=1000 ; break ; } acumonto = acumonto + monto ; System.out.println ( “Usted gana : ” + monto ) ; System.out.println ( “El dinero acumulado ganado es : ” + acumonto ) ; } else System.out.println ( “La casa gana” ) ; monto = 0 ; System.out.println ( “Desea volver a jugador [s/n] : ” ) ; opc1=Lectura.leerChar ( ) ; } while ( opc1! = ‘n’ ) ; } }

Pag. 330


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

}

Pag. 331


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

Pag. 332


Continúa…


Clase PrgMenuOperaciones1

case 2 : resul1 = valor1 - valor2 ; operacion = “Resta” ; signo = ‘-’ ; break ; case 3 : resul1 = valor1 * valor2 ; operacion = “Multiplicación” ; signo = ‘*’ ; break ; case 4 : resul1 = valor1 / valor2 ; operacion = “División” ; signo = ‘/’ ; break ; case 5 : System.exit (0) ; break ; } System.out.println ( “¿Cuánto es ” + valor1 + “ ” + signo + “ ” + valor2 + “ ?” ) ; do { System.out.println ( “Ingresar resultado de la ” + operacion + “ :” ) ; resul2 = Lectura.leerInt ( ) ; if ( resul1 != resul2 ) System.out.println ( “No es, por favor trata otra vez” ) ; } while ( resul1 != resul2 ) ; System.out.println ( “Muy bien” ) ; } while ( op != 5 ) ; } }

Pag. 333


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

Pag. 334


Continúa…


Clase PrgMenuOperaciones2 case 2 : resul1 = valor1 - valor2 ; operacion = “Resta” ; signo = ‘-’ ; break ; case 3 : resul1 = valor1 * valor2 ; operacion = “Multiplicación” ; signo = ‘*’ ; break ; case 4 : resul1 = valor1 / valor2 ; operacion = “División” ; signo = ‘/’ ; break ; case 5 : System.exit (0) ; break ; } System.out.println ( “¿Cuánto es ” + valor1 + “ ” + signo + “ ” + valor2 + “ ?” ) ; System.out.println ( “Ingresar resultado de la ” + operacion + “: ” ) ; resul2 = Lectura.leerInt ( ) ; if ( resul1 != resul2 ) { System.out.println ( “No es, por favor trata otra vez” ) ; cont1 ++ ; } else { System.out.println ( “Muy bien” ) ; cont2 ++ ; } } while ( op != 5 ) ; System.out.println ( “La cantidad de respuesta correctas fueron : ” + cont1 ) ; System.out.println ( “La cantidad de respuestas incorrectas fueron : ” + cont2 ) ; } }

Pag. 335


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

Pag. 336


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

Pag. 337


Pag. 338


MANEJO DE CADENAS: CLASE STRING INTRODUCCIÓN Una cadena es un conjunto de caracteres, números y símbolos especiales almacenados en una variable de tipo texto o cadena. La clase String, es una clase que viene incorporada en el lenguaje de programación Java, incluida en el paquete java.lang, la cual 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). Ejemplo: String nom = “Danae” ;

JERARQUÍA DE CLASES Y HERENCIA java.lang.Object

java.lang.String

El paquete java.lang es el paquete principal del lenguaje Java por lo cual no se necesita importar ninguna clase incluida en dicho paquete. En consecuencia, no será necesario importar el paquete java.lang cada vez que se necesite utilizar la clase String de Java. 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). La clase String incluye métodos que permiten examinar los caracteres individuales de una cadena para compararlos, para ubicarlos, para extraerlos como subcadenas, y para crear copias de una cadena convirtiendo todos sus caracteres a letra mayúscula o minúscula. Las conversiones son realizadas a través del método toString ( ), método definido en la clase Object, el cual puede ser utilizado por todas las clases Java a través de la herencia.

Pag. 339


MÉTODOS La clase String presenta los siguientes métodos: Métodos de instancia: 1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16.

charAt( ). compareTo( ). concat( ). endsWith( ). equals( ). equalsIgnoreCase( ). indexOf( ). lastIndexOf( ). length( ). replace( ). startsWith( ). substring( ). toCharArray( ). toLowerCase( ). trim( ). toUpperCase( ).

Métodos de clase: 17. valueOf( ). 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. Para el caso de los métodos de clase esto no será necesario. 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), el operador punto (.) y el nombre del método de instancia que se desea ejecutar. Para el caso de los métodos de clase deberá colocar la palabra String, el operador punto (.) y el nombre del método de clase que se desea ejecutar. Asimismo, para ejecutar cualquiera de los método de la clase String, se debe tener en cuenta que si, el método necesita algunos datos, éstos deben ser necesariamente proporcionados en la cantidad y tipos requeridos. En caso, que el método devuelva un resultado, éste deberá almacenarse en una variable del mismo tipo o mostrarse a través de la pantalla. A continuación se presenta una breve descripción del uso de cada uno de los métodos de la clase String:

Pag. 340


CLASE String MÉTODOS DE INSTANCIA

charAt(int)

compareTo(String)

concat(String)

DESCRIPCIÓN

Devuelve el caracter que encuentre en la posición indicada por la variable entera o número entero colocado como parámetro. Es importante mencionar que en Java, el primer caracter de una cadena se encuentra ubicado en la posición 0 (cero).

Si la cadena es alfabéticamente menor que la cadena colocada como parámetro, el método devuelve un número entero menor que cero. 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, el método devuelve un entero mayor que cero.

Este método permite juntar dos cadenas en una sola cadena.

USO

String cad1 = “Hola Danae”; char x = cad1.charAt(5); resultado: x = ‘D’.

String cad1 = “Hola Danae”; String cad2 = “Hola Pedro”; int x = cad1.compareTo(cad2); Resultado: x < 0 (cad1
String cad1, cad2, cadena; cad1 = "Hola"; cad2 = " a todos"; cadena = cad1.concat (cad2); Resultado : cadena = "Hola a todos”

endsWith(String)

equals(String)

equalsIgnoreCase(String)

Devuelve true (verdadero) si el final de la cadena coincide con la cadena colocada como parámetro. Caso contrario devuelve false (falso).

Devuelve true (verdadero) si la cadena coincide con la cadena colocada como parámetro. Caso contrario devuelve false (falso).

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.

Pag. 341

String cad1 = “Hola Danae”; String cad2 = “Danae”; boolean x = cad1.endsWith(cad2); Resultado: x = true. String cad1 = “Danae”; String cad2 = “Danae”; boolean x = cad1.equals(cad2); Resultado: x = true. String cad1 = “DANAE”; String cad2 = “Danae”; boolean x; x = cad1.equalsIgnoreCase(cad2); Resultado:


MÉTODOS DE INSTANCIA

DESCRIPCIÓN

USO x = true.

String cad1 = “Hola Danae”; int x = cad1.indexOf(‘D’); indexOf(char) Resultado: x = 5.

indexOf(char,int)

indexOf(String)

Devuelve la posición de la cadena en la que aparece por primera vez el caracter colocado como parámetro. También se puede especificar un segundo parámetro a partir del cual se empieza a buscar hacia delante.

String cad1 = “Hola Danae”; int x = cad1.indexOf(‘a’,6); Resultado: x = 8. String cad1 = “Hola Danae”; int x = cad1.indexOf( “ana” ); Resultado: x = 6. String cad1 = “Hola Danae”; int x = cad1.indexOf( “Dan”,3 );

indexOf(String, int) Resultado: x = 5. String cad1 = “Hola Danae”; int x = cad1.lastIndexOf(‘a’); lastIndexOf(char) Resultado: x = 8. String cad1 = “Hola Danae”; int x = cad1.lastIndexOf(‘a’,5); lastIndexOf(char,int)

lastIndexOf(String)

Devuelve la posición de la cadena en la que aparece por última vez el caracter colocado como parámetro. También se puede especificar un segundo parámetro a partir del cual se empieza a buscar hacia atrás.

Resultado: x = 3. String cad1 = “Hola Danae”; int x = cad1.lastIndexOf( “ana” ); Resultado: x = 8. String cad1 = “Hola Danae”; int x = cad1.lastIndexOf( “lo”,5 );

lastIndexOf(String,int) Resultado: x = 2.

Pag. 342



length()

replace(char,char)

startsWith(String)

DESCRIPCIÓN

Devuelve la longitud de una cadena. Es decir, el número de caracteres que tiene la cadena.

Permite reemplazar todos los caracteres iguales al caracter colocado como primer parámetro con el caracter colocado como segundo parámetro.

Devuelve un valor true (verdadero) si el comienzo de la cadena coincide con la cadena colocada como parámetro, caso contrario devuelve false (falso).

USO String cad1 = “Hola Danae”; int x = cad1.length(); Resultado: x = 10. String cad1 = “Hola Danae”; String x = cad1.replace(‘a’, ‘o’); Resultado: x = “Holo Donoe”. String cad1 = “Hola Danae”; String cad2 = “Hola”; boolean x; x = cad1.startsWith(cad2); Resultado: x = true. String cad1 = “Hola Danae”; String x = cad1.substring(5);

substring(int)

substring(int,int)

Devuelve una subcadena a partir de la cadena especificada, 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.

Resultado: x = “Danae”. String cad1 = “Hola Danae”; String x = cad1.substring(6,9); Resultado: x = “ana”.

toCharArray()

toLowerCase()

trim()

Convierte una cadena específica en un vector de caracteres. (Los vectores serán tratados en el capítulo IV).

Convierte las letras de una cadena en letras minúsculas.

Permite eliminar los espacios en blanco del inicio y del final de una cadena.

Pag. 343

String cad1 = “Hola Danae”; char[ ] x = cad1.toCharArray(); Resultado: x = {‘H’,‘o’,‘l’,‘a’,‘ ’, ‘D’, ‘a’, ‘n’, ‘a’,‘e’}. String cad1 = “Hola Danae”; String x = cad1.toLowerCase(); Resultado: x = “hola danae”. String cad1 = “ Hola Danae ”; String x = cad1.trim(); Resultado: x = “Hola Danae”.



toUpperCase()

DESCRIPCIÓN

Convierte las letras de una cadena en letras mayúsculas.

MÉTODO DE CLASE

DESCRIPCIÓN

String.valueOf(boolean) String.valueOf(int) String.valueOf(long) String.valueOf(float) String.valueOf(double) String.valueOf(Object) String.valueOf(char[ ]) String.valueOf(char[ ], int,int)

Método de clase que permite convertir los valores de otros tipos de datos o variables a una cadena.

USO String cad1 = “Hola Danae”; String x = cad1.toUpperCase(); Resultado: x = “HOLA DANAE”.

USO

double pi = 3.1416; String x = String.valueOf(pi); resultado: x = “3.1416”.

A continuación, con la finalidad de mejorar la comprensión del tema tratado, se presentan algunas soluciones a problemas planteados utilizando algunos de los métodos de la clase String. Analice cada una de las siguientes soluciones.

Pag. 344


Problema 100 Etapa 01 – Descripción del problema. Desarrollar un programa en Java que permita ingresar el nombre de un alumno. Mostrar el nombre del alumno en letras mayúscula. Etapa 04 – Desarrollo de la codificación. Clase PrgConvertirMayuscula package dominioDeLaAplicacion ; import biblioteca.* ; public class PrgConvertirMayuscula { public static void main(String [ ] args) { String nom ; System.out.print ( “ Ingresar el nombre: ” ) ; nom = Lectura.leerString( ) ; nom = nom.toUpperCase( ) ; System.out.println ( “ El nombre en Mayúscula es: ” + nom ) ; } }

¿Qué hay de nuevo en la codificación? Observe el uso del método toUpperCase ( ) de la clase String: nom.toUpperCase ( ) ; Nombre del método. Operador punto. Nombre de la variable (objeto). El método toUpperCase ( ) se utiliza con variables de tipo String y permite convertir en letras mayúsculas el contenido de la variable que antecede al nombre del método y al operador punto (en nuestro caso la variable nom). Como el método toUpperCase ( ) nos devuelve un valor de tipo String (el contenido de la variable en letra mayúscula), podemos mostrar el resultado utilizando System.out.println o almacenarlo en una variable (que puede ser la variable que contenía la cadena original), tal y como lo hemos realizado en nuestro ejemplo:

Pag. 345


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

Pag. 346


Problema 101 Etapa 01 – Descripción del problema. Desarrollar un programa en Java que permita ingresar el nombre de un alumno. Mostrar el nombre del alumno en letras minúsculas. Etapa 04 – Desarrollo de la codificación. Clase PrgConvertirMinuscula package dominioDeLaAplicacion ; import biblioteca.* ; public class PrgConvertirMinuscula { public static void main(String [ ] args) { String nom ; System.out.print ( “ Ingresar el nombre: ” ) ; nom = Lectura.leerString( ) ; nom = nom.toLowerCase( ) ; System.out.println ( “ El nombre en Minúscula es: ” + nom ) ; } }

¿Qué hay de nuevo en la codificación? Observe el uso del método toLowerCase ( ) de la clase String: nom.toLowerCase ( ) ; Nombre del método. Operador punto. Nombre de la variable (objeto). 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). Como el método toLowerCase ( ) nos devuelve un valor de tipo String (el contenido de la variable en letra minúscula), podemos mostrar el resultado utilizando System.out.println o almacenarlo en una variable (que puede ser la variable que contenía la cadena original), tal y como lo hemos realizado en nuestro ejemplo:

Pag. 347


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

Pag. 348


Problema 102 Etapa 01 – Descripción del problema. Desarrollar un programa en Java que permita ingresar el primer nombre y el segundo nombre de un alumno. Concatenar y Mostrar los nombres del alumno en letras mayúsculas y letra minúsculas. Etapa 04 – Desarrollo de la codificación. Clase PrgConcatenarNombres package dominioDeLaAplicacion ; import biblioteca.* ; public class PrgConcatenarNombres { public static void main(String [ ] args) { String nom1, nom2, nombre, espacio = “ ” ; System.out.println ( “ Ingresar el primer nombre del alumno: ” ) ; nom1 = Lectura.leerString( ) ; System.out.println ( “ Ingresar el segundo nombre del alumno: ” ) ; nom2 = Lectura.leerString( ) ; nom1 = nom1.concat(espacio) ; nombre = nom1.concat(nom2) ; System.out.println ( “ El nombre en Mayúscula es: ”" + nombre.toUpperCase() ) ; System.out.println ( “ El nombre en Minúscula es: ” + nombre.toLowerCase() ) ; } }

¿Qué hay de nuevo en la codificación? Observe el uso del método concat ( ) de la clase String: nom = nom.concat (espacio) ; 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). Es decir, 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). 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. nom1 = nom1.concat (espacio) ; nombre = nom1.concat(nom2) ;

Pag. 349


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

Pag. 350


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

Pag. 351


cant = nom.length ( ) ; El método length ( ) se utiliza con variables de tipo String y nos permite contar la cantidad de caracteres que almacena una variable (en nuestro caso, la cantidad de caracteres que almacena la variable nom). Como el método length ( ) devuelve la cantidad de caracteres que tiene una variable (incluido los espacios en blanco), podemos mostrar el resultado utilizando System.out.println(), utilizarlo en una condición lógica o almacenarlo en una variable. 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, 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, como por ejemplo; Lu, Ana, José, Pedro, que tienen 2, 3, 4, y 5 caracteres respectivamente). do { System.out.println ( “ Ingresar el nombre: ” ) ; nom = Lectura.leerString( ) ; nom = nom.trim ( ) ; if ( nom.length ( ) < 2 ) { System.out.println ( “Nombre ingresado no válido… Reintente! ” ) ; } } while (nom.length ( ) < 2) ;

Pag. 352


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

Pag. 353


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

Pag. 354


nom = “danae”. Cuando manipulamos cadenas con el método substring ( ) debemos tener en cuenta que cada caracter de la cadena tiene una determinada posición, empezando por la posición cero (0). nom = “danae”. posición 0

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

Pag. 355


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

Pag. 356


Problema 107 Etapa 01 – Descripción del problema. Desarrollar un programa en Java que permita ingresar el nombre completo de un alumno (nombres y apellidos en una sola variable). Mostrar el primer caracter de cada palabra del nombre en mayúsculas y el resto de cada palabra en minúscula. Etapa 04 – Desarrollo de la codificación. Clase PrgNombreCompleto package dominioDeLaAplicacion ; import biblioteca.* ; public class PrgNombreCompleto { public static void main(String [ ] args) { int cant ; String nom, cadena1 = “”,cadena2 = “”, caracter ; do { System.out.println ( “ Ingresar el nombre: ” ) ; nom = Lectura.leerString( ) ; nom = nom.trim( ) ; if ( nom.length( ) < 2) { System.out.println ( “ Nombre ingresado no válido… Reintente! ” ) ; } } while (nom.length( ) < 2) ; cant = nom.length( ) ; for (int x=0; x
Pag. 357


Observe el uso del método equals ( ) de la clase String: if (caracter.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). Si al comparar el contenido de las dos cadenas resulta que ambas variables son iguales, el método equals ( ) nos devuelve un valor verdadero (true), en caso contrario nos devuelve un valor falso (false). Este valor devuelto se evalúa en la estructura de decisión if. Imagínese que la variable nom contiene el siguiente nombre: nom = “danae alessandra flores bertolotti” ; Nosotros desearíamos que la primera letra de cada nombre y de cada apellido de un alumno este en letra mayúscula, mientras que el resto de las letras estén en letra minúscula. Al inicio utilizamos parte de la solución del problema 105. Después obtenemos caracter por caracter y evaluamos si el caracter obtenido es un espacio en blanco. 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. El siguiente esquema muestra como se debe almacenar parcialmente el nombre del ejemplo en la variable nom.

Danae a lessandra flores bertolotti.

A cadena1

caracter

cadena2

Después se concatenan las tres variables y se almacenan en la variable nom. El proceso se repite hasta llegar al final de la cadena. Ahora considere si entre los nombres existe más de un espacio en blanco. ¿Qué sucede? Modificando la solución anterior para poder considerar la problemática anterior tendríamos la siguiente variación: cant = nom.length( ) ; sw = false ; for (int x=0; x
Pag. 358


cadena1 = nom.substring(0,x) ; caracter = nom.substring(x, x+1) ; caracter = caracter.toUpperCase( ); cadena2 = nom.substring(x+1) ; nom = cadena1 + caracter + cadena2 ; sw = false ; } } } } 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, sin preocuparnos de la cantidad de espacios en blanco que pueda existir entre dos nombres.

Pag. 359


Problema 108 Etapa 01 – Descripción del problema. Desarrollar un programa en Java que permita ingresar los apellidos y nombres de un obrero (en una sola variable). Mostrar el número de caracteres blancos o espacios en blanco que existan. Etapa 04 – Desarrollo de la codificación. Clase PrgLongitudCadenaBlanco package dominioDeLaAplicacion ; import biblioteca.* ; public class PrgLongitudCadenaBlanco { public static void main(String [ ] args) { int x,cant,cont=0 ; String nom,caracter ; do { System.out.println ( “ Ingresar el nombre: ” ) ; nom = Lectura.leerString( ) ; nom = nom.trim( ) ; if ( nom.length( ) < 2 ) { System.out.println ( “ Nombre ingresado no válido… Reintente! ” ) ; } } while (nom.length( ) < 2 ) ; cant = nom.length( ) ; for (x=0;x
Pag. 360


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

Pag. 361


Problema 110 Etapa 01 – Descripción del problema. Desarrollar una solución que permita ingresar los apellidos y nombres de un obrero (en una sola variable). Mostrar el número de caracteres que no son espacios en blanco y el número de caracteres que son espacios en blanco. Etapa 04 – Desarrollo de la codificación. Clase PrgLongitudCadenaBlancoNoBlanco package dominioDeLaAplicacion ; import biblioteca.* ; public class PrgLongitudCadenaBlancoNoBlanco { public static void main(String [ ] args) { int x, cant, cont = 0 ; String nom, caracter ; do { System.out.println ( “ Ingresar el nombre: ” ) ; nom = Lectura.leerString( ) ; nom = nom.trim( ) ; if ( nom.length( ) < 2 ) { System.out.println ( “ Nombre ingresado no válido… Reintente! ” ) ; } } while (nom.length( ) < 2 ) ; cant = nom.length( ) ; fo r(x=0; x
Pag. 362


Problema 111 Etapa 01 – Descripción del problema. Desarrollar una solución que permita ingresar el nombre de un alumno. Mostrar el número de vocales que hay en el nombre ingresado. Etapa 04 – Desarrollo de la codificación. Clase PrgTotalVocales1 package dominioDeLaAplicacion ; import biblioteca.* ; public class PrgTotalVocales1 { public static void main(String [ ] args) { int cant, cont = 0, d = 0, x ; String nom ; char c = ‘ ’ ; do { System.out.println ( “ Ingresar el nombre: ” ) ; nom = Lectura.leerString( ) ; nom = nom.trim( ) ; if ( nom.length( ) == 0 ) { System.out.println ( “ Nombre ingresado no válido… Reintente! ” ) ; } } while (nom.length( ) == 0 ) ; cant = nom.length( ) ; nom = nom.toLowerCase( ) ; for (x=0; x
Pag. 363


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

Pag. 364


Problema 112 Etapa 01 – Descripción del problema. Desarrollar un programa en Java que permita ingresar el nombre de un alumno. Mostrar el número de vocales y el número de caracteres que no son vocales que hay en el nombre ingresado. Etapa 04 – Desarrollo de la codificación. Clase PrgTotalVocalesNoVocales package dominioDeLaAplicacion ; import biblioteca.* ; public class PrgTotalVocalesNoVocales { public static void main(String [ ] args) { int cant, cont = 0 , d = 0 , x ; String nom ; char c = ‘ ’ ; do { System.out.println ( “ Ingresar el nombre: ” ) ; nom = Lectura.leerString( ) ; nom = nom.trim( ) ; if ( nom.length( ) == 0 ) { System.out.println ( “ Nombre ingresado no válido… Reintente! ” ) ; } } while (nom.length( ) == 0 ) ; cant = nom.length( ) ; nom = nom.toLowerCase( ) ; for (x=0; x
Pag. 365


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

Pag. 366


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

Pag. 367


Continúa... Etapa 04 - Desarrollo de la codificación. Clase PrgCadenaSubcadena } else { if (cad1.equals (cad2) ) { System.out.println ( “ las cadenas son iguales ” ) ; } else { System.out.println ( “ la segunda cadena no debe tener una longitud ” ) ; System.out.println ( “ mayor que la primera cadena ” ) ; } } } } Observe el uso de los métodos trim ( ), length ( ), substring ( ) y equals ( ) de la clase String. La parte central de la solución radica en las siguientes líneas de código: if (cad1.length( ) > cad2.length( ) ) { total = cad1.length( ) - cad2.length( ) ; for (i = 0; i <= total; i++) { subcad = cad1.substring(i, i + cad2.length( ) ) ; if (cad2.equals (subcad)) { cont ++ ; } } System.out.println ( “ El número de veces que se repite ” ); System.out.println ( “ la subcadena en la cadena es: ” + cont ) ; } else { if (cad1.equals (cad2) ) { System.out.println ( “ las cadenas son iguales ” ) ; } else { System.out.println ( “ la segunda cadena no debe tener una longitud ” ) ; System.out.println ( “ mayor que la primera cadena ” ) ; } }

En primer lugar, se verifica que la primera cadena (cad1) tenga una longitud mayor que la segunda cadena (cad2). Luego, se obtiene la diferencia entre las longitudes de cad1 y cad2, y se almacena en la variable total. 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 total de cad2. Después, 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 ( ). Si son iguales el contador cont aumenta en 1. Este proceso se repite utilizando el siguiente caracter de cad1. Como ejemplo utilizaremos las siguientes cadenas: cad1 = “Danae”

cad2 = “ana”

En primer lugar determinamos que cad1 tiene una longitud mayor que cad2. Luego, calculamos el valor de la variable total (total = 5-3 = 2).

Pag. 368


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. 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). Primera evaluación: cad2 = “ana” y Resultado: falso.

subcad = “nae”

Finalmente, se concluye que cad2 se repite una vez en cad1.

Pag. 369


Problema 114 Etapa 01 – Descripción del problema. Desarrollar un programa en Java que permita ingresar el nombre de dos alumnos. Mostrar si los nombres ingresados son iguales o no. Etapa 04 – Desarrollo de la codificación. Clase PrgNombresIguales package dominioDeLaAplicacion ; import biblioteca.* ; public class PrgNombresIguales { public static void main(String [ ] args) { String nom1, nom2 ; do { System.out.println ( “ Ingresar el nombre del primer alumno: ” ) ; nom1 = Lectura.leerString( ) ; nom1 = nom1.trim( ) ; if ( nom1.length( ) < 2 ) { System.out.println("Nombre ingresado no válido… Reintente! "); } } while ( nom1.length( ) < 2 ) ; do { System.out.println ( “ Ingresar el nombre del segundo alumno: ” ) ; nom2 = Lectura.leerString( ) ; nom2 = nom2.trim( ) ; if ( nom2.length( ) < 2 ) { System.out.println ( “ Nombre ingresado no válido… Reintente! ” ) ; } } while ( nom2.length( ) < 2 ) ; if ( nom1.equals (nom2) ) { System.out.println ( “ Los nombres ingresados son iguales ” ) ; } else { System.out.println ( “ Los nombres ingresados son diferentes ” ) ; } } }

Observe el uso de los métodos trim ( ), length ( ) y equals ( ) de la clase String. Se comparan dos variables de tipo cadena (nom1 y nom2 respectivamente) y se determinan si ambas cadenas son iguales o no.

Pag. 370


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

Pag. 371


Cuando se comparan dos cadenas, se realiza una comparación alfabética en la cual tienen significado las letras mayúsculas, las letras minúsculas, los caracteres especiales y los espacios en blanco. Por ejemplo; comparemos las siguientes cadenas: 1. nombre1 = “Pedro” y nombre2 = “Luis”.

nombre1 > nombre2

2. nombre1 = “Danae” y nombre2 = “Danae”.

nombre1 = nombre2

3. nombre1 = “Carmen” y nombre2 = “Juan”.

nombre1 < nombre2

En base a esto, mejore la solución de tal forma que se pueda realizar la consistencia de los nombres ingresados.

Pag. 372


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

Pag. 373


Continúa... Etapa 04 - Desarrollo de la codificación. Clase PrgOrdenados2 System.out.println ( “------------------------------------------------- ” ) ; System.out.println ( “Nombres ordenados alfabéticamente ” ) ; System.out.println ( “------------------------------------------------- ” ) ; System.out.println (nombreMenor) ; System.out.println (nombreMayor) ; } }

Mejore la codificación del programa, de tal forma que se contemple la posibilidad que los nombres ingresados sean iguales.

Pag. 374


Problema 117 Etapa 01 – Descripción del problema. Desarrollar un programa en Java que permita ingresar los nombres de tres alumnos (los nombres no deben ser iguales). Mostrar los nombres ordenados alfabéticamente. Etapa 04 – Desarrollo de la codificación.

Clase PrgOrdenados3 package dominioDeLaAplicacion ; import biblioteca.* ; public class PrgOrdenados3 { public static void main(String [ ] args) { String nombre1, nombre2, nombre3 ; String nom01 = “ ”, nom02 = “”, nom03 = “” ; do { System.out.println ( “ Ingrese el nombre de la primera persona: ” ) ; nombre1 = Lectura.leerString( ) ; nombre1 = nombre1.trim( ) ; if ( nombre1.length( ) == 0 ) { System.out.println ( “ Nombre ingresado no válido...Reintente!!! ” ) ; } } while ( nombre1.length( ) == 0 ) ; do { System.out.println ( “ Ingrese el nombre de la segunda persona: ” ) ; nombre2 = Lectura.leerString( ) ; nombre2 = nombre2.trim( ) ; if ( nombre2.length( ) == 0 ) { System.out.println ( “ Nombre ingresado no válido...Reintente!!! ” ) ; } } while (nombre2.length( ) == 0 ) ; do { System.out.println ( “ Ingrese el nombre de la tercera persona: ” ) ; nombre3 = Lectura.leerString( ) ; nombre3 = nombre3.trim( ) ; if ( nombre3.length( ) == 0 ) { System.out.println ( “ Nombre ingresado no válido...Reintente!!! ” ) ; } } while ( nombre3.length( ) == 0 ) ;

Pag. 375


Continúa... Etapa 04 - Desarrollo de la codificación. Clase PrgOrdenados3 if (nombre1.compareTo(nombre2) < 0 && nombre1.compareTo(nombre3) < 0 ) { nom01 = nombre1 ; if (nombre2.compareTo(nombre3) < 0 ) { nom02 = nombre2 ; nom03 = nombre3 ; } else { nom02 = nombre3 ; nom03 = nombre2 ; } } if (nombre2.compareTo(nombre1) < 0 && nombre2.compareTo(nombre3) < 0) { nom01 = nombre2 ; if (nombre1.compareTo(nombre3) < 0 ) { nom02 = nombre1 ; nom03 = nombre3 ; } else { nom02 = nombre3 ; nom03 = nombre1 ; } } if (nombre3.compareTo(nombre1) < 0 && nombre3.compareTo(nombre2) < 0 ) { nom01 = nombre3 ; if (nombre1.compareTo(nombre2) < 0 ) { nom02 = nombre1 ; nom03 = nombre2 ; } else { nom02 = nombre2 ; nom03 = nombre1 ; } } System.out.println ( “ ------------------------------------------------- ” ) ; System.out.println ( “ Nombres ordenados alfabéticamente ” ) ; System.out.println ( “ ------------------------------------------------- ” ) ; System.out.println (nom01) ; System.out.println (nom02) ; System.out.println (nom03) ; } } Desarrolle la siguiente prueba: 1.

Ejecute el programa, ingrese los siguientes datos y compruebe lo que sucede: nombre1 = “Armando”. nombre2 = “Armando”. nombre3 = “Beto”.

2.

Luego ingrese los siguientes datos y compruebe nuevamente lo que sucede: nombre1 = “Armando”. nombre2 = “Beto”. nombre3 = “Beto”.

3.

Finalmente ingrese los siguientes datos. Compruebe lo que sucede: nombre1 = “Armando”. nombre2 = “Armando”. nombre3 = “Armando”.

Modifique la codificación de la solución de tal forma que pueda mejorarla.

Pag. 376


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

Pag. 377


Continúa... Etapa 04 - Desarrollo de la codificación. Clase PrgOrdenados4 if ( nombre1.compareTo(nombre2) < 0 ) { if ( nombre1.compareTo(nombre3) < 0 ) { nom01 = nombre1 ; if (nombre2.compareTo(nombre3) < 0 ) { nom02 = nombre2 ; nom03 = nombre3 ; } else { nom02 = nombre3 ; nom03 = nombre2 ; } } else { nom01 = nombre3 ; nom02 = nombre1 ; nom03 = nombre2 ; } } else { if ( nombre2.compareTo(nombre3) < 0 ) { nom01 = nombre2 ; if ( nombre1.compareTo(nombre3) < 0 ) { nom02 = nombre1 ; nom03 = nombre3 ; } else { nom02 = nombre3 ; nom03 = nombre1 ; } } else { nom01 = nombre3 ; nom02 = nombre2 ; nom03 = nombre1 ; } } System.out.println ( “ ------------------------------------------------- ” ) ; System.out.println ( “ Nombres ordenados alfabéticamente ” ) ; System.out.println ( “ ------------------------------------------------- ” ) ; System.out.println (nom01) ; System.out.println (nom02) ; System.out.println (nom03) ; } } Desarrolle la siguiente prueba: Ingrese los nombres con letras mayúsculas y minúsculas, por ejemplo: nombre1 = “armando”.

nombre2 = “Beto”.

nombre3 = “Armando”.

Compruebe lo que sucede. Se ordenarán primero los nombres que comiencen con mayúscula y luego los nombres que comiencen con minúscula. Modifique el programa de tal forma que se cambie la primera letra del nombre ingresado a mayúscula.

Pag. 378


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

Pag. 379


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

Pag. 380


Problema 120 Etapa 01 – Descripción del problema. Desarrollar un programa en Java que permita ingresar el nombre de una persona, un caracter que este contenido en el nombre ingresado y otro caracter por el cual se reemplazará el primer caracter ingresado. Mostrar el nombre modificado. Etapa 04 – Desarrollo de la codificación. Clase PrgCadenaModifcada package dominioDeLaAplicacion ; import biblioteca.* ; public class PrgCadenaModifcada { public static void main(String [ ] args) { int cant ; String nom, dato1, dato2, caracter, cadena= “” ; System.out.print ( “ Ingresar el nombre de una persona: ” ) ; nom = Lectura.leerString( ) ; System.out.print ( “ Ingrese el caracter que se va buscar: ” ) ; dato1 = Lectura.leerString( ) ; System.out.print ( “ Ingrese el caracter por el cual se va reemplazar: ” ) ; dato2 = Lectura.leerString( ) ; cant = nom.length( ) ; for (x=0; x
¿Qué hay de nuevo en la codificación? Observe el uso del método equals ( ) de la clase String: nombre1.equals (nombre2) ;

Pag. 381


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

Pag. 382


Problema 121 Etapa 01 – Descripción del problema. Desarrollar un programa en Java que permita ingresar un número mayor de tres dígitos. Convertir el número en cadena, luego intercambiar posiciones, el primer digito pasarlo al último y el último digito pasarlo al primero. Mostrar el nuevo número. Etapa 04 – Desarrollo de la codificación. Clase PrgIntercambioCadena package dominioDeLaAplicacion ; import biblioteca.* ; public class PrgIntercambioCadena { public static void main(String [ ] args) { int num, cant; String dato1, dato2, dato3, cadena = ""; do { System.out.print(" Ingresar un numero mayor de 3 dígitos: "); num = Lectura.leerInt(); if (num < 100) { System.out.println(" Número ingresado no válido… Reintente! "); } } while (num < 100); cadena = String.valueOf(num); cant = cadena.length(); dato1 = cadena.substring(0, 1); dato2 = cadena.substring(1, cant - 1); dato3 = cadena.substring(cant-1); cadena = dato3 + dato2 + dato1; System.out.println(" El resultado es: " + cadena);} }

¿Qué hay de nuevo en la codificación? Observe el uso del método valueOf ( ) de la clase String: String.valueOf (num) ;

El método valueOf ( ) se utiliza directamente con la clase String (y no con una variable de tipo String). Este método permite convertir una variable de cualquier tipo a una variable de tipo String o 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. Una vez convertida la variable num, se utiliza el método substring ( ) para intercambiar las posiciones deseadas.

Pag. 383


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

Pag. 384


Otra manera de solucionar este problema es la siguiente: for ( x = cant - 1; x >= 0; x - - ) { caracter = nom.charAt (x) ; cadena += caracter ; } Es importante indicar que para esta solución, la variable caracter debe declararse como char. Observe como se utiliza el método charAt ( ) de la clase String, con la finalidad de obtener caracter por caracter de la variable nom (empezando desde el último y terminando en el primero), para agregarlos a la variable cadena utilizando el signo “+” (concatenación).

Pag. 385


Problema 123 Etapa 01 – Descripción del problema. 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”. Etapa 04 – Desarrollo de la codificación. Clase PrgCuentaLetras1 package dominioDeLaAplicacion ; import biblioteca.* ; public class PrgCuentaLetras1 { public static void main(String [ ] args) { String nombre, letraIni = “”, letraFin = “” ; int i, contP= 0, contA = 0 ; for (i = 0; i <11; i++) { do { System.out.println ( “ Ingresar el nombre del alumno: ” ) ; nombre = Lectura.leerString( ) ; nombre = nombre.trim( ) ; if ( nombre.length( ) == 0 ) { System.out.println ( “ Nombre ingresado no válido... Reintente! ” ) ; } } while (nombre.length( ) == 0 ) ; letraIni = nombre.substring(0,1) ; letraFin = nombre.substring ( nombre.length( )-1,nombre.length( ) ) ; if ( letraIni.equals( “P” ) ) { contP++; } if ( letraFin.equals( “a” ) ) { contA++; } } System.out.println ( “ Nombres que comienzas con la letra P: ” + contP); System.out.println ( “ Nombres que terminan con la letra a: ” + contA); } }

Mejore la solución desarrollando un programa que permita ingresar los nombres de todos los alumnos. Utilice la estructura do… while. 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.

Pag. 386


Problema 124 Etapa 01 – Descripción del problema. Desarrollar un programa en Java que permita ingresar los nombres de todos los empleados de una empresa. Mostrar el número de vocales que existen en cada uno de los nombres ingresados. Etapa 04 – Desarrollo de la codificación. Clase PrgTotalVocales2 package dominioDeLaAplicacion ; import biblioteca.* ; public class PrgTotalVocales2 { public static void main(String [ ] args) { int cant, cont=0, opc, d=0, x ; String nom ; char c = ‘ ’ ; do { do { System.out.println ( “ Ingresar el nombre: ” ) ; nom = Lectura.leerString( ) ; nom = nom.trim( ) ; if ( nom.length( ) == 0 ) { System.out.println ( “ Nombre no válido… Reintente! ” ) ; } } while ( nom.length( ) == 0 ) ; cant = nom.length( ) ; nom = nom.toLowerCase( ) ; for ( x=0; x
Pag. 387


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

Pag. 388


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

Pag. 389


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

Pag. 390


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

Pag. 391


Análisis de la solución Ingresamos la cantidad de alumnos y la almacenamos en la variable cantidad, se valida el número de alumnos ingresado, de tal forma que sea mayor a cero. Luego, se utiliza una sentencia do para ingresar el nombre de cada uno de los alumnos, y se determina la longitud de cada nombre ingresado, el nombre con la mayor longitud y el nombre con la menor longitud. 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.

Pag. 392


Problema 127 Etapa 01 - Descripción del problema. Desarrollar un programa en Java que permita ingresar una fecha con el siguiente formato “dd-mm-aaaa” y validarla. Etapa 04 - Desarrollo de la Codificación. Clase PrgFechaFormato package dominioDeLaAplicacion ; import biblioteca.Lectura ; class PrgFechaFormato { public static void main ( String arg [ ] ) { String fecha, dia, mes, anio ; int num1 = 0, num2 = 0 ; System.out.println ( “ Formato de la fecha es : dd-mm-aaaa ” ) ; System.out.println ( “ Ingresar la fecha actual: ” ) ; fecha = Lectura.leerString( ) ; if ( fecha.length( ) <= 10 ) { dia = fecha.substring(0, 2) ; num1 = Integer.parseInt(dia) ; mes = fecha.substring(3, 5) ; num2 = Integer.parseInt(mes) ; anio = fecha.substring(6, 10) ; if ( ( dia.length() != 2 ) || ( num1 < 31 ) ) { System.out.println ( “ El dia ingresado es incorrecto ” ) ; } else { if ( (mes.length() != 2 ) || ( num2 < 12 ) ) { System.out.println ( “ El mes ingresado es incorrecto ” ) ; } else { if ( anio.length( ) != 4 ) { System.out.println ( “ El año ingresado esta incorrecto ” ) ; } else { System.out.println ( “ La fecha ingresada es correcta ” ) ; } } } } } }

Intente mejorar la solución validando la fecha, de tal forma que el mes ingresado sólo sea válido si es que la variable dia contiene el número de días válidos para dicho mes. Incluya la posibilidad que el mes de febrero sea bisiesto.

Pag. 393


Problema 128 Etapa 01 - Descripción del problema. Desarrollar un programa en Java que permita completar por la izquierda (utilizando asteriscos) una determinada cadena en base a una longitud especificada. Ejemplo: Se ingresa: Longitud = 10 Cadena = “Danae” Resultado: Cadena = “Danae*****”

Etapa 04 - Desarrollo de la Codificación. Clase PrgCompletarCadenaIzq package dominioDeLaAplicacion ; import biblioteca.Lectura ; class PrgCompletarCadenaIzq { public static void main ( String arg [ ] ) { String cadena ; int longitud, tamaño, x ; System.out.println ( “ La longitud especificada es: ” ) ; longitud = Lectura.leerInt( ) ; System.out.println ( “ Ingresar cadena: ” ) ; cadena = Lectura.leerString( ) ; if ( longitud > cadena.length( ) ) { tamaño = longitud - cadena.length( ) ; for ( x = 1; x <= tamaño; x++) { cadena = cadena + “*” ; } } System.out.println ( “ La nueva cadena es: ” + cadena ) ; } }

Pag. 394


Problema 129 Etapa 01 - Descripción del problema. Desarrollar un programa en Java que permita completar por la derecha (utilizando asteriscos) una determinada cadena en base a una longitud especificada. Ejemplo: Se ingresa: Longitud = 10 Cadena = “Danae” Resultado: Cadena = “*****Danae”

Etapa 04 - Desarrollo de la Codificación. Clase PrgCompletarCadenaDer package dominioDeLaAplicacion ; import biblioteca.Lectura ; class PrgCompletarCadenaDer { public static void main ( String arg [ ] ) { String cadena ; int longitud, tamaño, x ; System.out.println ( “ La longitud especificada es: ” ) ; longitud = Lectura.leerInt( ) ; System.out.println ( “ Ingresar cadena: ” ) ; cadena = Lectura.leerString( ) ; if ( longitud > cadena.length( ) ) { tamaño = longitud - cadena.length( ) ; for ( x = 1; x <= tamaño; x++ ) { cadena = “*” + cadena ; } } System.out.println ( “ La nueva cadena es: ” + cadena ) ; } }

Pag. 395


Problema 130 Etapa 01 - Descripción del problema. Desarrollar un programa en Java que permita transformar un arreglo de caracteres en una cadena, especificando la posición del arreglo donde va ha comenzar la cadena y su longitud. Analizar la solución. Etapa 04 - Desarrollo de la Codificación. Clase PrgArregloCadena package dominioDeLaAplicacion ; import biblioteca.Lectura ; class PrgArregloCadena { public static void main ( String arg [ ] ) { char arregloA = { ‘D’, ‘a’, ‘n’, ‘a’, ‘e’ } ; String cadena = String.valueOf (arregloA, 1, 3) ; System.out.println ( “ La cadena es: ” + cadena ) ; } }

¿Qué hay de nuevo en la codificación? Observe el uso del método valueOf ( ) de la clase String: String.valueOf ( char [ ], int, int ) ; El método valueOf ( ) se utiliza directamente con la clase String (y no con una variable de tipo String). Este método permite convertir un arreglo de caracteres o parte de él, en una variable de tipo String o cadena. En nuestra solución convertimos parte del arreglo arregloA a un String con la finalidad de mostrar el contenido de dicha variable. Observe que en este método, en primer lugar, se especifica el arreglo de tipo char del cual se va ha obtener la cadena. En segundo lugar, se indica la posición del arreglo desde el cual se van a tomar los datos y finalmente, se indica la longitud o el número de caracteres que se van a obtener del arreglo. En el ejemplo, se muestra como resultado la cadena “ana”. Los arreglos serán tratados en el siguiente capítulo.

Pag. 396


OTRAS CLASES EN JAVA En general, el lenguaje de programación Java incorpora una gran cantidad de clases en paquetes organizados en su Jerarquía de Clases. 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. En el CD, adjunto al presente texto, encontrará más información sobre otras clases de la Jerarquía de Clases de Java. Como ejemplo, se puede mencionar la clase DecimalFormat del paquete java.text.

Problema 131 Etapa 01 - Descripción del problema. Desarrollar un programa en Java que permita ingresar un número por teclado. Mostrar el número ingresado con un formato determinado. Analizar la solución. Etapa 04 - Desarrollo de la Codificación. Clase PrgFormatoNumero package dominioDeLaAplicacion ; import biblioteca.Lectura ; import java.text.* ; class PrgFormatoNumero { public static void main ( String arg [ ] ) { double num ; DecimalFormat numFormato ; System.out.println ( “Ingrese numero entero: ” ) ; num = Lectura.leerDouble(); numFormato = new DecimalFormat ( “###.000" ) ; System.out.println ( “El número con formato es : ” + df.format ( num ) ) ; } } Observe que se declara un objeto de la clase DecimalFormat llamado numFormato, Luego este objeto es creado utilizando el operador new, estableciendo el formato a utilizar en el método constructor. Luego con el método format ( ) se procede a establecer el formato establecido para el número ingresado.

Pag. 397


Pag. 398

Capítulo Estructura de Datos Arreglos

4

Temas: Introducción. Estructura de Datos: Arreglos. • • • •

Generalidades. Declaración, creación e inicialización. Ingreso y visualización de datos. Manejo básico de datos.

Desarrollo de soluciones utilizando arreglos: • Formalización del método de las 6’D. • Problemas resueltos.

Desarrollo de soluciones utilizando múltiples arreglos: • Arreglos en paralelo. • Problemas resueltos.

ESTRUCTURAS DE DATOS – Arreglos.

CAPÍTULO IV ESTRUCTURA DE DATOS – ARREGLOS INTRODUCCIÓN Un algoritmo constituye una lista completa de pasos secuenciales y una descripción de datos necesarios para resolver un determinado problema. Dichos datos deben almacenarse en una estructura de datos. Los arreglos permiten almacenar varios valores a la vez y constituyen las estructuras de datos más sencillas después de la variable.




Pag. 401


LISTA DE PASOS

SENTENCIAS



SE DESARROLLAN UTILIZANDO: • Estructuras lógicas de secuencia. • Estructuras lógicas de decisión. • Estructuras lógicas de repetición. • Instrucciones de bifucación. TAMBIÉN: • Clases incorporadas en el lenguaje de programación utilizado.

ALMACENADOS EN: • Estructuras de datos tipo variables. • Estructuras de datos tipo arreglo.

El presente capítulo, trata sobre las estructuras de datos conocidas como arreglos y los conceptos más importantes relacionados a éstos; 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. Al desarrollar soluciones básicas, se utilizan las estructuras lógicas y las estructuras de datos en forma simultánea. 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.

Pag. 402


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

Pag. 403


Ventajas: •

Los datos están almacenados en una sola estructura de datos siendo más fácil el acceso a los mismos.

•

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.

•

Los arreglos permiten almacenar datos de entrada y datos utilizados durante el procesamiento.

•

Al igual que otras estructuras de datos (como las variables y constantes), los arreglos tienen un tiempo de vida, por lo que pueden ser considerados como globales o locales.

Desventajas: •

Un arreglo no puede almacenar datos de diferente tipo. Se puede tener un arreglo de números enteros, o un arreglo de cadenas, pero no se puede tener un arreglo que contenga por ejemplo: cadenas y números enteros a la vez.

•

Dependiendo del tipo de arreglo, unidimensional o bidimensional, se necesitará uno o dos índices para acceder a los datos almacenados en el arreglo.

•

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, denominada Vector, que pertenece al paquete java.util, que tiene métodos que permiten crear un vector y redefinir su tamaño cada vez que sea necesario).

Pag. 404


Representación gráfica Arreglos Unidimensionales: Un arreglo unidimensional puede ser representado como un vector o como un registro. A continuación se muestra la representación gráfica de un arreglo unidimensional llamado nombre: Como vector: nombre = [ X 0, X 1, X 2, X 3,..., X i -1 ]

i

Como registro: nombre X0

X1

0

1

X2 2

...

X I-1

...

i -1

i

Donde: nombre X0...X i -1 i

= = =

Nombre del vector. Datos almacenados en el vector. Tamaño del vector.

Arreglos Bidimensionales Un arreglo bidimensional puede ser representado como una matriz o como una tabla. A continuación se muestra la representación gráfica de un arreglo bidimensional llamado nombre: Como matriz: X 0,0

X 0,1

X 0,2

…

X 0,j -1

X 1,0 X 2,0 nombre =

. . . X i-1,0

Como tabla:

Pag. 405

X i-1,j -1

(i, j)


nombre Columnas

Filas

0

1

2

0

X 0,0

X 0,1

X 0,2

j-1

1

X 1,0

2

X 2,0

i-1

X i-1,0

X 0,j -1

…

X i-1,j -1

(i, j)

Donde: nombre X0,0...Xi-1, j -1 i*j

= = =

Nombre de la matriz. Datos almacenados en la matriz. Tamaño de la matriz.

En el presente texto, 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. Por ejemplo; 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), se realizaría de la siguiente manera:

notas

10

15

20

19

14

13

16

11

17

09

0

1

2

3

4

5

6

7

8

9

i =10

Donde: notas i 10, 15,...,09

= = =

Nombre del arreglo. Número de alumnos. Son las notas finales de cada uno de los alumnos.

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. Así, en el vector anterior, para poder acceder a la nota final del alumno 2 se utilizaría el nombre del vector (notas), seguido de un índice igual a 1 entre corchetes ([1]), según se muestre a continuación:

Pag. 406


notas[1]

notas

10

15

20

19

14

13

16

11

17

09

0

1

2

3

4

5

6

7

8

9

i =10

También, por ejemplo; si se desea representar el almacenamiento de las notas del examen parcial, del trabajo y del examen final de 10 alumnos de un salón de clase en un arreglo bidimensional (representado como una tabla), se realizaría de la siguiente manera:

notas

Alumno 1

0

1

2

3

4

5

6

7

8

9

Nota EP

0

10

11

02

05

18

16

17

11

17

09

Nota Tra

1

12

14

12

11

16

17

12

18

10

08

Nota EF

2

03

11

15

05

12

17

02

11

09

11

Alumno 2

…

…

…

…

…

…

…

Alumno10

(i =3, j=10)

Donde: notas j i 10,11,…,09 12,14,…,08 03,11,…,11

= = = = = =

Nombre del arreglo. Número de alumnos. Número de notas. Son las notas de Examen Parcial de c/u de los alumnos del salón de clase. Son las notas de Trabajo de c/u de los alumnos del salón de clase. Son las notas de Examen Final de c/u de los alumnos del salón de clase.

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. Así, en la tabla anterior, para poder acceder a la nota del examen final (Nota EF) del alumno 2 se utilizaría el nombre de la tabla (notas), seguido de dos índices iguales a 2 y 1, entre corchetes ( [2] [1] ), según se muestra a continuación:

Pag. 407


notas

Alumno 1

Alumno 2

…

…

…

…

…

…

…

Alumno10

0

1

2

3

4

5

6

7

8

9

Nota EP

0

10

11

02

05

18

16

17

11

17

09

Nota Tra

1

12

14

12

11

16

17

12

18

10

08

Nota EF

2

03

11

15

05

12

17

02

11

09

11

(i =3, j=10)

Notas[2][1]

Declaración de Arreglos Para declarar un arreglo es necesario, en primer lugar, definir un nombre para referirnos al arreglo. Para definir un nombre de un arreglo se siguen las mismas reglas utilizadas para la definición de nombres de variables y constantes. En segundo lugar, se debe determinar que tipo de dato podrá almacenar un arreglo. Un arreglo solo puede almacenar datos del mismo tipo. Los tipos de datos válidos para declarar un arreglo son los mismos tipos de datos válidos definidos para declarar variables y constantes. En general, para declarar un arreglo se utiliza el siguiente formato: En pseudocódigo y diagrama de flujo: TipoDeDato arreglo[ ] TipoDeDato arreglo[ ][ ] En Java: TipoDeDato arreglo[ ] ; TipoDeDato 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, 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, mientras que para declarar un arreglo bidimensional se utilizan dos corchetes de apertura y cierre “[ ][ ]” al final del nombre del arreglo.

Pag. 408


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, según se muestra a continuación: En pseudocódigo y diagrama de flujo: TipoDeDato[ ] arreglo TipoDeDato[ ][ ] arreglo En Java: TipoDeDato[ ] arreglo ; TipoDeDato[ ][ ] arreglo ; Como ejemplo de declaración de arreglos válidos en Java podemos utilizar: EJEMPLOS

DESCRIPCIÓN

int edades[ ] ;

Se declara un arreglo unidimensional llamado edades en el cual se podrá almacenar datos de tipo NUMERO, solo parte entera (int).

String nombres[ ] ;

Se declara un arreglo unidimensional llamado nombres en el cual se podrá almacenar datos de tipo TEXTO (String).

double notas[ ][ ] ;

Se declara un arreglo bidimensional llamado notas, en el cual se podrá almacenar datos de tipo NUMERO, parte entera y parte decimal (double).

Creación de Arreglos Para crear un arreglo, es necesario que el arreglo previamente haya sido declarado, tal y como se explicó anteriormente. Antes de crear un arreglo se debe determinar cual va ser el tamaño del mismo. Es decir, cual va ser la cantidad total de datos que se podrá almacenar en el arreglo. El tamaño de un arreglo puede especificarse en forma directa utilizando un número entero o en forma indirecta utilizando una variable entera. En ambos casos, el tamaño del arreglo siempre deberá especificarse como un número entero. Para crear un arreglo se utiliza el siguiente formato: En pseudocódigo y diagrama de flujo: CREAR arreglo[tamaño]

Pag. 409


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

Pag. 410


Una consideración importante antes de utilizar un arreglo en Java: “En Java, no se realiza ninguna clase de comprobación del tamaño de los arreglos en forma automática. Esto quiere decir que se puede desbordar el final de un arreglo (se lanza una excepción de tipo ArrayIndexOutOfBoundException). Es necesario recordar y tener presente que es responsabilidad directa del programador asegurarse que nunca suceda esto, ya que puede ocasionar resultados no deseados, y que se finalice la ejecución del programa”.

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, en el cual se podrá almacenar 10 datos de tipo NUMERO (int).

edades = new int [10] ;

int total = 10 ; nombres = new String [total] ;

Se crea un arreglo unidimensional llamado nombres, previamente declarado, en el cual se podrá almacenar 10 datos de tipo TEXTO (String).

int numAlu, numNot ; numAlu = 10 ; numNot = 3 ; notas = new double [numNot][numAlu] ;

Se crea un arreglo bidimensional llamado notas, previamente declarado, en el cual se podrá almacenar 30 datos de tipo NUMERO (double).

En el segundo ejemplo se utiliza una variable llamada total de tipo entero para crear el arreglo unidimensional llamado nombres. En el ejemplo, se asigna directamente el valor 10 a la variable total. Se podría modificar esta parte para que el valor se ingrese a través del teclado, tal y como se muestra a continuación:

EJEMPLOS int total ; System.out.print ( “Ingrese el numero total de alumno: ” ); total = Lectura.leerInt( ) ; nombres = new String[total] ;

Pag. 411


En el tercer ejemplo se crea un arreglo bidimensional llamado notas previamente declarado, en el cual se podrá almacenar 30 datos de tipo NUMERO, parte entera y parte decimal (double en Java). Dichos datos estarán organizados en 3 filas y 10 columnas. También se podría haber declarado y creado los arreglos del ejemplo anterior, en forma directa, tal y como se muestra a continuación;

EJEMPLOS int edades [ ] = new int [10] ; int total = 10 ; String nombres [ ] = new String [total] ; int numAlu, numNot ; numAlu =10 ; numNot = 3 ; double notas[ ][ ] = new double [numNota[numAlu] ;

Inicialización de Arreglos Cuando se crea un arreglo utilizando el operador new es recomendable, aunque no necesario, inicializar todas las posiciones del mismo. 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. Generalmente, los arreglos numéricos (tipo NUMERO) se inicializan con cero (0), 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.

Ingreso de datos a un Arreglo Después de crear un arreglo, inicialice o no el arreglo, se deberán ingresar datos. Es necesario que se ingresen datos a todas las posiciones del arreglo. 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. Recuerde que tratar de acceder a una

Pag. 412


posición del arreglo que no tiene un dato o que no ha sido inicializado, produce un error que ocasiona que se interrumpa la ejecución del programa. Para ingresar datos a todas las posiciones de un arreglo generalmente se utiliza la estructura lógica de repetición DESDE (for en Java). También se puede utilizar una forma directa que permite declarar, crear e ingresar datos a un arreglo unidimensional, para esto se encierran los datos que se almacenarán en el arreglo dentro de llaves, separadas por comas, tal y como se muestra a continuación.

EJEMPLO int edades[ ] = { 10,15,20,23,28,32,35,42,51,59 } ;

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. En el ejemplo anterior, se declara y crea un arreglo unidimensional llamado edades de tipo NUMERO (solo números enteros) con 10 valores. 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. Para declarar y crear un arreglo unidimensional llamado letras de tipo TEXTO (de solo una letra) con 4 valores, se utilizaría la siguiente sentencia:

EJEMPLO char letras[ ] = { ‘A’, ‘B’, ‘C’, ‘D’ } ;

Pag. 413


Manejo de datos de un Arreglo Una vez que se han ingresado los datos a todas las posiciones del arreglo, se pueden manipular dichos datos con la finalidad de cumplir con el objetivo del programa o proyecto de solución de un determinado problema. En términos generales, el manejo de arreglos se puede agrupar en dos grandes grupos: 1). Procesos que permiten cambiar o modificar el contenido del arreglo. Se pueden dividir en: • • •

Proceso de modificación de datos. Proceso de eliminación de datos. Proceso de ordenación de datos.

Proceso de Modificación de Datos: Permite modificar uno o más datos de un arreglo, que se ingresaron a través de un proceso de ingreso de datos. Es importante tener en cuenta que antes de modificar un dato se debe verificar que este existe dentro del arreglo, utilizando para ello un proceso de búsqueda de datos. Proceso de Eliminación de Datos: Permite eliminar uno o más datos de un arreglo que se ingresaron a través de un proceso de ingreso de datos. Es importante tener en cuenta que antes de eliminar un dato se debe verificar que este existe dentro del 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 Ordenación de Datos: Permite ordenar todos los datos de un arreglo en función de un criterio. Dicho criterio establece la forma de ordenar los datos de un arreglo. La ordenación puede ser en forma alfabética o numérica de mayor a menor o viceversa. 2). Proceso que permite visualizar o consultar el contenido del arreglo. Se pueden dividir en: • • •

Proceso de visualización de datos. Proceso de búsqueda datos. Proceso de cálculo basado en datos del arreglo.

Pag. 414


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

Pag. 415


Pag. 416


DESARROLLO DE SOLUCIONES BÁSICAS UTILIZANDO ARREGLOS Los arreglos pueden ser utilizados como parte de las soluciones a los problemas que se nos plantean. Inclusive, siempre hemos definido un arreglo como parte de la estructura del método principal, main( ) en Java, tal y como se muestra a continuación. 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. Dichos parámetros se pasan al método main ( ) y se almacenan en el arreglo arg. Analizar las siguientes sentencias:

Clase Suma /* Clase que nos permite sumar varios números enteros , incluidos como parámetros */ package dominioDeLaAplicacion ; class Suma { public static void main ( String arg [ ] ) { int suma = 0 ; for ( int i = 0, i < a.length ; i ++ ) { suma += Integer.parseInt (arg [ i ] ) ; } System.out.println (suma) ; } }

Es importante mencionar que cuando se ejecute esta clase, usted deberá asegurarse de incluir una lista de números, para que estos puedan ser sumados. Analizando las siguientes sentencias:

for ( int i = 0 ; i < a.length ; i++ ) { suma += Integer.parseInt ( arg [ i ] ) ; } En primer lugar, los arreglos en Java poseen un atributo que almacena la cantidad de datos que pueden contener. Este atributo se denomina length.

Pag. 417


En segundo lugar, cuando necesitamos convertir un dato a un número entero, utilizamos el método parseInt() de la clase Integer. En consecuencia, la lista de números se almacena en el arreglo arg de tipo String. Utilizando la sentencia for podemos acceder a cada uno de los datos almacenados en el arreglo arg[], lo convertimos a un dato tipo NUMERO utilizando Integer.parseInt(), y luego lo sumamos a la variable suma. 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, y calcula el promedio general de notas del salón de clase.

Clase PrgAlumno package dominioDeLaAplicacion ; import biblioteca.* ; public class PrgAlumno { public static void main ( String arg [ ] ) { int suma = 0, nota ; double promedio ; for ( int i = 0; i < 10 ; i ++ ) { System.out.print ( “ Ingrese la Nota Final del Alumno ” + ( i + 1 ) ) ; nota = lectura.leerInt ( ) ; suma = suma + nota ; } promedio = suma / 10 ; System.out.print ( “ El promedio general de notas es ” + promedio ) ; } }

Observe que la solución anterior nos permite realizar el cálculo y la visualización del promedio general de notas. Pero, al utilizar solo una variable (notas), no podemos almacenar a la vez las notas finales de los 10 alumnos. (Recuerde que una variable solo nos permite almacenar un dato a la vez).

Pag. 418


A partir de este punto, se modificará el programa anterior, de tal forma que se incorporen progresivamente los conceptos tratados en este capítulo, para finalmente formalizar el Método de las 6’D. 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, definiendo un nombre adecuado para cada uno de ellos.

Crear el arreglo o arreglos con el tamaño necesario para poder almacenar todos los datos.

Inicializar el arreglo o arreglos, o en su defecto, ingresar los datos necesarios al arreglo o arreglos utilizados en la solución.

Estos tres pasos generalmente se desarrollarán en todas las soluciones. A partir de este punto podemos realizar cualquier proceso con los datos almacenados en el arreglo o arreglos definidos en la solución. Por lo tanto, 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.

En la solución, se utilizará un arreglo unidimensional llamado notas que permitirá almacenar las notas finales de 10 alumnos de un determinado salón de clase. El arreglo notas almacenará datos de tipo NUMERO (número entero con parte decimal). Una vez almacenadas las notas finales de los 10 alumnos se calculará y mostrará el promedio de las mismas.

Clase PrgAlumnos package dominioDeLaAplicacion ; import biblioteca.* ; public class PrgAlumnos { public static void main ( String [ ] args ) { // Declaración de variables y arreglos. int numAlu =10 ; double sumaNotas=0, notas[ ] ; // Creación del arreglo notas. notas = new double [numAlu] ;

Pag. 419


Clase PrgAlumnos // Proceso de ingreso de datos al arreglo notas[ ]. for ( int i = 0 ; i < numAlu ; i++) { System.out.print ( “ Ingrese nota : ” ) ; notas[i] = Lectura.leerDouble( ) ; } // Proceso de cálculo del promedio de notas finales. for ( int i = 0 ; i < numAlu ; i++ ) { sumaNotas = sumaNotas + notas[i] ; } System.out.print ( “El promedio es : ” + ( sumaNotas / numAlu ) ) ; } }

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

Pag. 420


Finalizada la ejecución de la primera sentencia for, el arreglo notas[ ] deberá tener almacenadas las notas finales de los 10 alumnos del salón de clase. Tal y como se muestra a continuación:

notas

10

15

20

19

14

13

16

11

17

09

0

1

2

3

4

5

6

7

8

9

i =10

Finalmente, se ejecuta el proceso de cálculo del promedio de las 10 notas finales. Para ello, se utiliza una segunda sentencia for exactamente igual a la primera sentencia for. Cada vez que se ejecuta la segunda 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). Finalizada la ejecución de la sentencia for se muestra el promedio de las 10 notas finales. 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. 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.

Pag. 421


Ahora, 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.

Clase PrgAlumnos package dominioDeLaAplicacion ; import biblioteca.* ; public class PrgAlumnos { public static void main(String[] args) { // Declaración de variables. int numAlu ; double sumaNotas = 0 ; // Determinación del tamaño del arreglo. System.out.print ( “ Ingrese el número de alumnos : ” ) ; numAlu = Lectura.leerInt( ) ; // Declaración y creación del arreglo notas. double notas[] = new double [numAlu] ; // Proceso de ingreso de datos al arreglo notas[ ]. for ( int i = 0 ; i < numAlu ; i++ ) { System.out.print ( “ Ingrese la nota final del alumno [” + ( i + 1) + “]: ” ) ; notas[i] = Lectura.leerDouble( ) ; } // Proceso de cálculo del promedio de notas finales. for ( int i = 0 ; i < numAlu ; i++ ) { sumaNotas = sumaNotas + notas[i] ; } System.out.print ( “ El promedio es : ” + ( sumaNotas / numAlu ) ) ; } }

En la solución anterior, se declara y crea el arreglo notas[ ] utilizando la siguiente sentencia:

// Declaración y creación del arreglo notas. double notas[] = new double [numAlu] ;

Observe que para crear el arreglo notas[ ] se utiliza la variable entera numAlu. La variable numAlu fue declarada previamente con la sentencia int, y se le asignó un valor que fue ingresado por el usuario a través del teclado. Esto nos permite crear un arreglo llamado notas[ ] con un tamaño equivalente al valor almacenado en la variable numAlu. Es decir, en el arreglo notas[ ] se podrán almacenar las notas finales de todos los alumnos de un salón de clase.

Pag. 422


Otra modificación que vale la pena destacar es la siguiente:

System.out.print ( “ Ingrese la nota final del alumno [” + ( i + 1) + “]: ” ) ; Esta sentencia esta ubicada dentro de la sentencia for y nos permite el ingreso de datos al arreglo llamado notas[ ]. // Proceso de ingreso de datos al arreglo notas[ ]. for ( int i = 0 ; i < numAlu ; i++ ) { System.out.print ( “ Ingrese la nota final del alumno [” + ( i + 1) + “]: ” ) ; notas[i] = Lectura.leerDouble( ) ; } Utilizando dicha sentencia con la variable i (la cual aumenta su valor en 1 cada vez que se ejecuta la sentencia for), se puede personalizar el mensaje que se le muestra al usuario al momento del ingreso de las notas finales. 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[ ], es decir en notas[0].

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[ ], es decir en notas[1], y así sucesivamente hasta ingresar la nota final del último alumno.

Pag. 423


Ahora, se modificará nuevamente la solución anterior, de tal forma que permita consistenciar la entrada de datos. Se consistenciará el ingreso del número total de alumnos y de la nota final de cada uno de ellos.

Clase PrgAlumnos package dominioDeLaAplicacion ; import biblioteca.* ; public class PrgAlumnos { public static void main(String[] args) { // Declaración de variables. int numAlu ; double sumaNotas = 0 ; // Determinación del tamaño del arreglo 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 valido… Reintente! ” ) ; } } while ( numAlu < 0 ) ; // Declaración y creación de arreglo. double notas[] = new double [numAlu] ; // Proceso de ingreso de datos al arreglo notas[ ] con consistencia de datos. for ( int i = 0 ; i < numAlu ; i++ ) { do { System.out.print ( “ Ingrese la nota final del alumno [” + ( i + 1) + “]: ” ) ; notas[i] = Lectura.leerDouble( ) ; if ( notas[i] > 20 || notas[i] < 0 ) { System.out.println ( “ Nota ingresada no es valida… Reintente! ” ) ; } } while ( notas[i] > 20 || notas[i] < 0 ) ; } // Proceso de cálculo del promedio de notas finales. for ( int I = 0 ; i < numAlu ; i++ ) { sumaNotas = sumaNotas + notas[i] ; } System.out.print ( “ El promedio es : ” + ( sumaNotas / numAlu ) ) ; } } Observe el uso de la sentencia do dentro de la sentencia for. Uno de los principales usos de la sentencia do es la consistencia de datos. 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.

Pag. 424


FORMALIZACIÓN DE LA SOLUCIÓN UTILIZANDO EL MÉTODO DE LAS 6’D

Problema 132 Etapa 01 - Descripción del problema. Desarrollar una solución que permita ingresar y almacenar las notas finales de todos los alumnos de un determinado salón de clase. Determinar y mostrar el promedio de las notas finales. Consistenciar el ingreso de datos. Etapa 02 - Definición de la solución.

Resultado deseado:

Mostrar el promedio de las notas finales de los alumnos de un determinado salón de clase.

Datos necesarios:

El número de alumnos y las notas finales de cada uno de ellos.

Procesamiento:

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 ingresado se crea un arreglo (notas[ ]). Luego se procede a ingresar las notas finales de todos los alumnos y se almacenan en el arreglo creado. Después, se realiza la suma de todas las notas finales y el resultado se almacena en una variable acumulador (sumaNotas). Finalmente, se realiza el cálculo del promedio, se almacena el resultado en una variable (prom) y se muestra por pantalla.

Pag. 425


Etapa 03 - Diseño de la lógica. 1. Nombre del Proyecto: ProyAlumnos. 2. Definición de Paquetes y desarrollo del Diagrama de Paquetes.




Clases biblioteca

Pag. 426



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

Pag. 427



Clase PrgAlumnos01 package dominioDeLaAplicacion ; import biblioteca.* ; public class PrgAlumnos01 { public static void main(String[] args) { // Declaración de variables. int i, numAlu ; double sumaNotas = 0, prom ; // Determinación del tamaño del arreglo 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 ) ; // Declaración y creación del arreglo. double notas[ ] = new double [numAlu] ; // Proceso de ingreso de datos al arreglo notas[ ] con consistencia de datos. for ( i = 0 ; i < numAlu ; i++ ) { do { System.out.print ( “ Ingrese la nota final del alumno [ ” + ( i + 1) + “]: ” ) ; notas[i] = Lectura.leerDouble( ) ; if ( notas[i] > 20 || notas[i] < 0 ) { System.out.println ( “ Nota ingresada no es válida… Reintente! ” ) ; } } while ( notas[i] > 20 || notas[i] < 0 ) ; } // Proceso de cálculo del promedio de notas finales. for ( i = 0 ; i < numAlu ; i++ ) { sumaNotas = sumaNotas + notas[i] ; } prom = sumaNotas / numAlu ; System.out.println ( “ El promedio es : ” + prom ) ; } }

Pag. 428


Problema 133 Etapa 01 - Descripción del problema. Desarrollar una solución que permita ingresar y almacenar las notas de todas las prácticas de un alumno. Determinar el promedio de las prácticas sabiendo que se elimina la práctica con la nota mas baja. Mostrar el promedio redondeado. Consistenciar el ingreso de datos. Etapa 02 - Definición de la solución.

Resultado deseado:

Mostrar el promedio redondeado de las notas de las prácticas de un alumno.

Datos necesarios:

El número de prácticas y las notas de las prácticas del alumno.

Procesamiento:

El número de prácticas se ingresa a través del teclado y se almacena en una variable (numPra). Con el número de prácticas se crea un arreglo (notas[ ]). Luego se procede a ingresar las notas de las prácticas del alumno y se almacenan en el arreglo creado. 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). Luego, se determina la nota más baja del alumno y se almacena en una variable (notaMenor). Finalmente, se realiza el cálculo del promedio ((sumaNotas – notaMenor) / (numPra – 1)), se almacena el resultado en una variable (promAlu), se redondea y se muestra por pantalla.

Pag. 429






Clases biblioteca

Pag. 430



Algoritmo PrgAlumnos02 - método main ( ) ENTRADA: numPra, notas[ ] SALIDA: promAlu INICIO COMENTARIO “Declaración de variables” NUMERO i, numPra, sumaNotas = 0, notaMenor = 20 NUMERO notas[ ], 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[ ].” DESDE i = 0 HASTA i = numPra - 1 INCREMENTA 1 HACER LEER notas[i] SI ( notas[i] > 20 || notas[i] < 0 ) ENTONCES ESCRIBIR “Nota no válida... 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 sumaNotas = sumaNotas + notas[i] FINDESDE DESDE i = 0 HASTA i = numPra - 1 INCREMENTA 1 SI ( notaMenor > notas[i] ) ENTONCES notaMenor = notas[i] FINSI FINDESDE promAlu = ( sumaNotas - notaMenor ) / ( numPra - 1 ) promAlu = promAlu REDONDEA 0 ESCRIBIR promAlu FIN

Pag. 431



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

Pag. 432


Problema 134 Etapa 01 - Descripción del problema. 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. Determinar el promedio de cada alumno sabiendo que se duplica su nota más alta. Mostrar el promedio redondeado. Consistenciar el ingreso de datos. Etapa 02 - Definición de la solución.

Resultado deseado:

Mostrar el promedio redondeado de las notas de las tres prácticas de cada alumno.

Datos necesarios:

El número de alumnos y las notas de las tres prácticas de cada alumno.

Procesamiento:

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 de las tres prácticas de cada alumno y se almacenan en el arreglo creado. Después, por cada alumno, se realiza la suma de las notas de sus tres prácticas y el resultado se almacena en una variable acumulador (sumaNotas). Luego, se determina su nota más alta y se almacena en una variable (notaMayor). Finalmente, se realiza el cálculo de su promedio ((sumaNotas + notaMayor) / 4), se almacena el resultado en una variable (promAlu), se redondea y se muestra por pantalla.

Pag. 433






Clases biblioteca

Pag. 434



Algoritmo PrgAlumnos03 - método main ( ) ENTRADA: numAlu, notas[ ][ ] SALIDA: promAlu INICIO COMENTARIO “Declaración de variables” NUMERO i, j, numAlu, sumaNotas = 0, notaMayor = 0 NUMERO notas[ ][ ], promAlu COMENTARIO “Determinación del tamaño del arreglo” HACER LEER numAlu SI (numAlu <= 0 ) ENTONCES ESCRIBIR “Número de alumnos no válido… Reintente!” FINSI MIENTRAS (numAlu <= 0 ) COMENTARIO “Creación del arreglo” CREAR notas [numAlu][3] COMENTARIO “Ingreso de datos al arreglo notas[ ][ ]” DESDE i = 0 HASTA i = numAlu - 1 INCREMENTA 1 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... 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 - 1 INCREMENTA 1 notaMayor = notas[i][0] MAXIMO notas[i][1] notaMayor = notas[i][2] MAXIMO notaMayor sumaNotas = notas[i][0] + notas[i][1] + notas[i][2] promAlu = ( sumaNotas + notaMayor ) / 4 promAlu = promAlu REDONDEA 0 ESCRIBIR promAlu FINDESDE FIN

Pag. 435


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

Pag. 436


Problema 135 Etapa 01 - Descripción del problema. 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. 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. Mostrar el promedio redondeado a dos decimales. Consistenciar el ingreso de datos. Finalmente; determinar y mostrar el promedio simple de todas las notas de las prácticas de los alumnos del salón de clase. Etapa 02 - Definición de la solución.

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.

Datos necesarios:

El número de alumnos, el número de prácticas y las notas de las prácticas de cada alumno.

Procesamiento:

El número de alumnos y el número de prácticas se ingresa a través del teclado y se almacenan en variables (numAlu y numPra respectivamente). Con los datos ingresados se crea un arreglo (notas[ ][ ]). Luego se procede a ingresar las notas de las prácticas de cada alumno y se almacenan en el arreglo creado. Después, por cada alumno, se realiza la suma de las notas de las prácticas y el resultado se almacenan en una variable de tipo acumulador (sumaNotas). Luego, se determina su nota más alta y se almacena en una variable (notaMayor). También se determina su nota mas baja y se almacena en una variable (notaMenor). Finalmente, se realiza el cálculo de su promedio ((sumaNotas + notaMayor - notaMenor) / numPra), se almacena el resultado en una variable (promAlu), se redondea y se muestra por pantalla.

Pag. 437


Adicionalmente, 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). Se determina el promedio simple, se almacena el resultado en una variable (prom) y se muestra por pantalla.




Clases biblioteca

Pag. 438



Algoritmo PrgAlumnos04 - método main ( ) ENTRADA: numAlu, numPra, notas[ ][ ] SALIDA: promAlu, prom INICIO COMENTARIO “Declaración de variables” NUMERO i, j, numAlu, numPra, sumaNotas = 0, notaMayor = 0 NUMERO notaMenor = 20, notas[ ][ ], promAlu, prom COMENTARIO “Determinación del tamaño del arreglo” HACER LEER numAlu SI (numAlu <= 0 ) ENTONCES ESCRIBIR “Número de alumnos no válido.. Reintente!” FINSI MIENTRAS (numAlu <= 0 ) HACER LEER numPra SI (numPra <= 0 ) ENTONCES ESCRIBIR “Número de prácticas no válido.. 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 - 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... Reintente!” FINSI MIENTRAS ( notas[i][j] > 20 || notas[i][j] < 0 ) FINDESDE FINDESDE

Pag. 439


Continúa… 4. 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 - 1 INCREMENTA 1 notaMayor = 0 notaMenor = 20 sumaNotas = 0 DESDE j = 0 HASTA j = numPra - 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 - 1 INCREMENTA 1 DESDE j = 0 HASTA j = numPra - 1 INCREMENTA 1 sumaNotas = sumaNotas + notas[i][j] FINDESDE FINDESDE prom = sumaNotas / ( numAlu * numPra ) prom = prom REDONDEA 2 ESCRIBIR prom FIN

Pag. 440



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

Pag. 441


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

Clase PrgAlumnos04 // Cálculo del promedio de notas por alumno. for ( i = 0 ; i < numAlu ; i++ ) { notaMayor = 0 ; notaMenor = 20 ; sumaNotas = 0 ; for { i = 0 ; j < numPra ; j++ ) { notaMayor = Math.max (notas[i][j], notaMayor) ; notaMenor = Math.max (notas[i][j], notaMenor ) ; sumaNotas = sumaNotas + notas[i][j] ; } promAlu = ( sumaNotas + notaMayor - notaMenor) / numPra ; promAlu = ( Math.round (prom * 100) ) / 100.0 ; System.out.println ( “ El promedio del alumno [ ” + ( i + 1 ) + “ ] es: ” + promAlu ) ; } // Cálculo del promedio simple de todas las notas. sumaNotas = 0 ; for ( i = 0 ; i < numAlu ; i++ ) { for { i = 0 ; j < numPra ; j++ ) { sumaNotas = sumaNotas + notas[i][j] ; } } prom = ( sumaNotas + notaMayor - notaMenor) / ( numAlu * numPra ) ; prom = ( Math.round (prom * 100) ) / 100.0 ; System.out.println ( “ El promedio simple de las notas es : ” + prom ) ; } }

Pag. 442


Problema 136 Etapa 01 - Descripción del problema. Desarrollar una solución que permita ingresar y almacenar las notas del examen parcial, promedio de trabajos y examen final de todos los alumnos de un salón de clase. Consistenciar el ingreso de los datos. Determinar el promedio de cada alumno sabiendo que se duplica la nota del examen final. Mostrar el promedio redondeado. También, calcular y mostrar el promedio obtenido por los alumnos en el examen final. Finalmente; determinar y mostrar el porcentaje de alumnos aprobados y el porcentaje de alumnos desaprobados. Etapa 02 - Definición de la solución.

Resultado deseado:

Mostrar el promedio redondeado de las notas de cada alumno, el promedio obtenido por los alumnos en el examen final y el porcentaje de alumnos aprobados y desaprobados.

Datos necesarios:

El número de alumnos y las notas del examen parcial, promedio de trabajos y examen final de cada alumno.

Procesamiento:

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, promedio de trabajos y examen final de cada alumno y se almacenan en el arreglo creado. Después, por cada alumno, se realiza la suma de la nota del examen parcial, promedio de trabajos y examen final (multiplicado por 2), y el resultado se almacena en una variable de tipo acumulador (sumaNotas). Luego, se determina su promedio ((sumaNotas notaMenor) / 4), se almacena el resultado en una variable (promAlu), se redondea y se muestra por pantalla. Adicionalmente, 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). Se determina el promedio simple,

Pag. 443


se almacena el resultado en una variable (promEF), se redondea y se muestra por pantalla. Finalmente, 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, almacenando los resultados en variables (aprobados y desaprobados respectivamente), luego se realiza el calculo del porcentaje de alumno aprobados y desaprobados, se almacena el resultado en variables (porceAprob y porceDesaprob respectivamente), y se muestran por pantalla.

Etapa 03 - Diseño de la lógica. 1. Nombre del Proyecto: ProyAlumnos. 2. Definición de Paquetes y desarrollo del Diagrama de Paquetes. Diagrama de paquetes


Clases biblioteca

Pag. 444



Algoritmo PrgAlumnos05- método main ( ) ENTRADA: numAlu, notas[ ][ ] SALIDA: promAlu, promEF, porceAprob, porceDesaprob INICIO COMENTARIO “Declaración de variables” NUMERO i, numAlu, sumaNotas = 0, sumaEF = 0 NUMERO notas[ ][ ], promAlu, promEF, porceDesaprob NUMERO aprobados = 0, desaprobados = 0, porceAprob COMENTARIO “Determinación del tamaño del arreglo” HACER LEER numAlu SI (numAlu <= 0 ) ENTONCES ESCRIBIR “Número de alumnos no válido… Reintente!” FINSI MIENTRAS (numAlu <= 0 ) COMENTARIO “Creación del arreglo” CREAR notas [3][numAlu] COMENTARIO “Ingreso de datos al arreglo notas[ ][ ]” DESDE i = 0 HASTA i = numAlu - 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... 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... Reintente!” FINSI MIENTRAS ( notas[1][i] > 20 || notas[1][i] < 0 )

Pag. 445



Algoritmo PrgAlumnos05- 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... 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 - 1 INCREMENTA 1 sumaNotas = notas[0][i] + notas[1][i] + notas[2][i] * 2 promAlu = sumaNotas / 4 promAlu = promAlu REDONDEA 0 ESCRIBIR promAlu FINDESDE COMENTARIO “Cálculo del promedio simple de examen final” DESDE i = 0 HASTA i = numAlu - 1 INCREMENTA 1 sumaEF = sumaEF + notas[2][i] FINDESDE promEF = sumaEF / numAlu promEF = promEF REDONDEA 2 ESCRIBIR promEF COMENTARIO “Cálculo de alumnos aprobados y desaprobados” DESDE i = 0 HASTA i = numAlu - 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 - porceAprob ESCRIBIR porceAprob + “ % ” ESCRIBIR porceDesaprob + “ % ” FIN

Pag. 446


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

Pag. 447


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

Pag. 448


Problema 137 Etapa 01 - Descripción del problema. Desarrollar una solución que permita ingresar y almacenar el sueldo de todos los trabajadores de una empresa. Calcular y mostrar el aumento de sueldo de cada uno de los trabajadores (redondeado a dos decimales), de acuerdo a la siguiente tabla. Consistenciar los datos ingresados. Condición

Aumento

sueldo < 410 sueldo >= 410 y sueldo <= 1600

20 % 10 %

sueldo > 1600

05 %


Resultado deseado:

Mostrar el aumento de sueldo de cada uno de los trabajadores de una empresa.

Datos necesarios:

El número de trabajadores de la empresa y el sueldo de cada uno de ellos.

Procesamiento:

El número de trabajadores se ingresa a través del teclado y se almacena en una variable (numTrab). Con el número de trabajadores se crea un arreglo (sueldos[ ]). Luego se procede a ingresar los sueldos de cada trabajador y se almacenan en el arreglo creado. Después, por cada trabajador, en base a su sueldo se determina su aumento de sueldo. Si el trabajador tiene un sueldo menor a S/.410.00 nuevos soles se le aumenta el 20% de su sueldo. Si el trabajador tiene un sueldo mayor a S/.1,600.00 nuevos soles, se le aumenta el 5% de su sueldo y en otros casos el aumento es del 10% de su sueldo. El aumento se almacena en una variable (aumento), se redondea y se muestra por pantalla.

Pag. 449


Etapa 03 - Diseño de la lógica. 1. Nombre del Proyecto: ProyTrabajadores.

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




Clases biblioteca

Pag. 450



Algoritmo PrgTrabajadores01 - método main ( ) ENTRADA: numTrab, sueldos[ ] SALIDA: aumento INICIO COMENTARIO “Declaración de variables” NUMERO i, numTrab, sueldos[ ], 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 - 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 - 1 INCREMENTA 1 SI ( sueldos[i] < 410 ) ENTONCES aumento = sueldos[i] * 0.2 SINO SI ( sueldos[i] > 1600 ) aumento = sueldos[i] * 0.05 SINO aumento = sueldos[i] * 0.10 FINSI FINSI aumento = aumento REDONDEA 2 ESCRIBIR aumento FINDESDE FIN

Pag. 451


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

Pag. 452


Problema 138 Etapa 01 - Descripción del problema. Desarrollar una solución que permita ingresar y almacenar el sueldo de todos los trabajadores de una empresa. A todos los empleados cuyo sueldo sea mayor a S/.1600.00 nuevos soles se le deberá descontar 15% por impuestos y a todos los trabajadores cuyo sueldo sea menor a S/.1000.00 nuevos soles se le deberá aumentar el 10% por concepto de refrigerio y movilidad. Mostrar el sueldo neto a cobrar por cada trabajador redondeado a dos decimales. Consistenciar los datos ingresados. Etapa 02 - Definición de la solución.

Resultado deseado:

Mostrar el sueldo neto a cobrar por cada trabajador de la empresa.

Datos necesarios:


Procesamiento:

El número de trabajadores se ingresa a través del teclado y se almacena en una variable (numTrab). Con el número de trabajadores se crea un arreglo (sueldos[ ]). Luego se procede a ingresar los sueldos de cada trabajador y se almacenan en el arreglo creado. Después, por cada trabajador, en base a su sueldo se determina su descuento o su aumento. Si el trabajador tiene un sueldo mayor a S/.1,600.00 nuevos soles se le descontará el 15% de su sueldo por impuestos y se almacena en una variable (descuento). Si el trabajador tiene un sueldo menor a S/.1000.00 nuevos soles, se le aumenta el 10% de su sueldo por concepto de refrigerio y movilidad, y se almacena en una variable (aumento). Luego, se determina el sueldo neto ((sueldo – descuento + aumento), se almacena el resultado en una variable (sueldoNeto), se redondea y se muestra por pantalla.

Pag. 453







Clases biblioteca

Pag. 454



Algoritmo PrgTrabajadores02 - método main ( ) ENTRADA: numTrab, sueldos[ ] SALIDA: sueldoNeto INICIO COMENTARIO “Declaración de variables” NUMERO i, numTrab, sueldos[ ], descuento = 0, 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 - 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 sueldo neto de cada trabajador” DESDE i = 0 HASTA i = numTrab - 1 INCREMENTA 1 descuento = 0 aumento = 0 SI ( sueldos[i] > 1600 ) ENTONCES descuento = sueldos[i] * 0.15 FINSI SI ( sueldos[i] < 1000 ) aumento = sueldos[i] * 0.10 FINSI sueldoNeto = sueldos[i] – descuento + aumento sueldoNeto = sueldoNeto REDONDEA 2 ESCRIBIR sueldoNeto FINDESDE FIN

Pag. 455


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

Pag. 456


Problema 139 Etapa 01 - Descripción del problema. Desarrollar una solución que permita ingresar y almacenar el sueldo de todos los trabajadores de una empresa. Calcular y mostrar el sueldo neto de cada trabajador, su aumento y su respectivo descuento en base a la tabla mostrada (redondear dichas cantidades a dos decimales). Adicionalmente, mostrar el monto total que paga la empresa por concepto de sueldos. Consistenciar los datos ingresados. Aumento

Descuento

sueldo < 410 sueldo >= 410 y sueldo <= 1600

Condición

20% 10%

00 % 08 %

sueldo > 1600

05%

15 %


Resultado deseado:

Mostrar el sueldo neto a cobrar por cada trabajador de la empresa, su aumento y su respectivo descuento. También mostrar el monto total que paga la empresa por concepto de sueldos.

Datos necesarios:


Procesamiento:

El número de trabajadores se ingresa a través del teclado y se almacena en una variable (numTrab). Con el número de trabajadores se crea un arreglo (sueldos[ ]). Luego se procede a ingresar los sueldos de cada trabajador y se almacenan en el arreglo creado. Después, por cada trabajador, en base a su sueldo se determina su respectivo aumento y descuento. Si el trabajador tiene un sueldo menor a S/.410.00 nuevos soles se le aumenta el 20% de su sueldo y no se le realiza ningún descuento. Si el trabajador tiene un sueldo mayor a S/.1,600.00 nuevos soles, se le aumenta el 5% de su sueldo y se le descuenta 15%. En otros casos el aumento es del 10% de su sueldo y el descuento es de

Pag. 457


8%. El aumento se almacena en una variable (aumento) y el descuento en otra variable (descuento). Luego, se determina el sueldo neto ((sueldo – descuento + aumento), se almacena el resultado en una variable (sueldoNeto), se redondea y se muestra por pantalla. También se muestra el aumento y el descuento calculado. El sueldo neto obtenido se suma a una variable acumulador (sueldoTotal). Después de finalizar el cálculo del sueldo neto de cada trabajador se muestra por pantalla el contenido de la variable acumulador sueldoTotal.

Etapa 03 - Diseño de la lógica. 1. Nombre del Proyecto: ProyTrabajadores. 2. Definición de Paquetes y desarrollo del Diagrama de Paquetes.


Pag. 458




Clases biblioteca


Algoritmo PrgTrabajadores03 - método main ( ) ENTRADA: numTrab, sueldos[ ] SALIDA: sueldoNeto, aumento, descuento, sueldoTotal INICIO COMENTARIO “Declaración de variables” NUMERO i, numTrab, sueldos[ ], aumento = 0, descuento = 0 NUMERO sueldoNeto, 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. 459



Algoritmo PrgTrabajadores03 - método main ( ) COMENTARIO “Ingreso de datos al arreglo sueldos[ ]” DESDE i = 0 HASTA i = numTrab - 1 INCREMENTA 1 HACER LEER sueldos[i] SI ( sueldos[i] <= 0 ) ENTONCES ESCRIBIR “Sueldo ingresado no es válido... ” FINSI MIENTRAS ( sueldos[i] <= 0 ) FINDESDE COMENTARIO “Cálculo del sueldo neto, aumento y descuento por trabajador, y del total de sueldos ” DESDE i = 0 HASTA i = numTrab - 1 INCREMENTA 1 SI ( sueldos[i] < 410 ) ENTONCES aumento = sueldos[i] * 0.2 descuento = 0 SINO SI ( sueldos[i] > 1600 ) aumento = sueldos[i] * 0.05 descuento = sueldos[i] * 0.15 SINO aumento = sueldos[i] * 0.10 descuento = sueldos[i] * 0.08 FINSI FINSI sueldoNeto = sueldos[i] – descuento + aumento sueldoNeto = sueldoNeto REDONDEA 2 aumento = aumento REDONDEA 2 descuento = descuento REDONDEA 2 ESCRIBIR sueldoNeto, aumento, descuento sueldoTotal = sueldoTotal + sueldoNeto FINDESDE ESCRIBIR sueldoTotal FIN

Pag. 460



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

Pag. 461



Clase PrgTrabajadores03 // Cálculo del sueldo neto, aumento y descuento por trabajador, y del total de sueldos. for ( i = 0 ; i < numTrab ; i++ ) { if ( sueldos[i] < 410 ) { aumento = sueldos[i] * 0.2 ; descuento = 0 ; } else { if ( sueldos[i] > 1600 ) { aumento = sueldos[i] * 0.05 ; descuento = sueldos[i] * 0.15 ; } else { aumento = sueldos[i] * 0.10 ; descuento = sueldos[i] * 0.08 ; } } sueldoNeto = sueldos[i] + aumento – descuento ; sueldoNeto = ( Math.round (sueldoNeto * 100) ) / 100.0 ; aumento = ( Math.round (aumento * 100) ) / 100.0 ; descuento = ( Math.round (descuento * 100) ) / 100.0 ; System.out.print ( “ El sueldo neto del trabajador [ ” + ( i + 1) + “ ] es : ” ) ; System.out.println ( sueldoNeto ) ; System.out.println ( “ Su aumento es : ” + aumento ) ; System.out.println ( “ Su descuento es : ” + descuento ) ; sueldoTotal = sueldoTotal + sueldoNeto ; } System.out.println ( “ Monto total pagado por concepto de sueldos : ” + sueldoTotal ) ; } }

Pag. 462


Problema 140 Etapa 01 - Descripción del problema. Desarrollar una solución que permita ingresar y almacenar las horas trabajadas y la tarifa horaria de todos los trabajadores de una empresa. Calcular y mostrar el sueldo neto de cada trabajador, sabiendo que se tiene que descontar el 10% por impuestos y el 5% por seguro. Etapa 02 - Definición de la solución.

Resultado deseado:

Mostrar el sueldo de cada trabajador de la empresa.

Datos necesarios:

El número de trabajadores de la empresa, y las horas trabajadas y la tarifa horaria de cada uno de ellos.

Procesamiento:

El número de trabajadores se ingresa a través del teclado y se almacena en una variable (numTrab). Con el número de trabajadores se 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. Después, por cada trabajador, se determina el sueldo neto ((horas trabajadas * tarifa horaria * 1.15), se almacena el resultado en una variable (sueldoNeto), se redondea y se muestra por pantalla.


Pag. 463






Clases biblioteca

Pag. 464



Algoritmo PrgTrabajadores04 - método main ( ) ENTRADA: numTrab, sueldos[ ][ ] SALIDA: sueldoNeto INICIO COMENTARIO “Declaración de variables” NUMERO i, numTrab, sueldos[ ][ ], 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 HACER COMENTARIO “Ingreso de las horas trabajadas” LEER sueldos[i][0] SI ( sueldos[i][0] <= 0 ) ENTONCES ESCRIBIR “Número de horas no válida... ” FINSI MIENTRAS ( sueldos[i][0] <= 0 ) HACER COMENTARIO “Ingreso de la tarifa horaria” LEER sueldos[i][1] SI ( sueldos[i][1] <= 0 ) ENTONCES ESCRIBIR “Tarifa horaria no válida... ” FINSI MIENTRAS ( sueldos[i][1] <= 0 ) FINDESDE COMENTARIO “Cálculo del sueldo neto de cada trabajador” DESDE i = 0 HASTA i = numTrab - 1 INCREMENTA 1 sueldoNeto = sueldo[i][0] * sueldo[i][1] * 0.85 ESCRIBIR sueldoNeto FINDESDE FIN

Pag. 465



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

Pag. 466


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

Pag. 467


Problema 141 Etapa 01 - Descripción del problema. Desarrollar una solución que permita ingresar y almacenar las horas trabajadas y la tarifa horaria de todos los trabajadores de una empresa. Calcular y mostrar el sueldo de cada trabajador, sabiendo que hasta 48 horas trabajadas se paga una tarifa normal y sobre las 48 horas, se paga la tarifa con un recargo del 25%. Por otro lado, si el sueldo es superior a S/.1,600.00 nuevos soles, al trabajador se le descuenta el 10% y si el sueldo es superior a S/.3,500.00 nuevos soles, al trabajador se le descuenta el 15%. Adicionalmente, se ha establecido un aumento a todos los trabajadores, equivalente al 15% del sueldo. Mostrar el sueldo total (sueldo bruto) y el sueldo a cobrar (sueldo neto) de cada trabajador redondeado a dos decimales. Etapa 02 - Definición de la solución.

Resultado deseado:

Mostrar el sueldo de cada trabajador de la empresa.

Datos necesarios:

El número de trabajadores de la empresa, y las horas trabajadas y la tarifa horaria de cada uno de ellos.

Procesamiento:

El número de trabajadores se ingresa a través del teclado y se almacena en una variable (numTrab). Con el número de trabajadores se 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. Después, por cada trabajador, se determina el sueldo bruto. Si el número de horas trabajadas es mayor a 48 horas, el sueldo bruto se determina de la siguiente forma: ( horas trabajadas – 48 ) * ( tarifa horaria * 1.25 ) + ( 48 * tarifa horaria) En caso contrario se siguiente forma:

determina de la

( horas trabajadas * tarifa horaria ) El sueldo bruto se almacena en una variable (sueldoBruto).

Pag. 468


Luego, por cada trabajador, se determina el descuento y el aumento de sueldo. Si el sueldo bruto es mayor a S/.3,500.00 nuevos soles, se calcula el descuento del 15%. Si el sueldo bruto es menor o igual a S/.3,500.00 nuevos soles y si el sueldo bruto es mayor a S/.1600.00 nuevos soles, se calcula el descuento del 10%. Caso contrario el descuento es cero. En todos los casos el descuento se almacena en una variable (descuento). Después, se calcula el aumento del 15% del sueldo y se almacena en la variable (aumento). Finalmente se realiza el calculo del sueldo neto (sueldoBruto + aumento – descuento) y se almacena en una variable (sueldoNeto). El sueldo neto y el sueldo bruto se redondean a dos decimales y se muestran por pantalla.




Pag. 469




Clases biblioteca


Algoritmo PrgTrabajadores05 - método main ( ) ENTRADA: numTrab, sueldos[ ][ ] SALIDA: sueldoBruto, sueldoNeto INICIO COMENTARIO “Declaración de variables” NUMERO i, numTrab, sueldos[ ][ ], descuento NUMERO sueldoNeto, sueldoBruto COMENTARIO “Determinación del tamaño del arreglo” HACER LEER numTrab SI (numTrab <= 0 ) ENTONCES ESCRIBIR “Número de trabajadores no válido… ” FINSI MIENTRAS (numTrab <= 0 ) COMENTARIO “Creación del arreglo” CREAR sueldos [2][numTrab]

Pag. 470


Continúa… 4. Diseño de algoritmo para el método principal. Algoritmo PrgTrabajadores05 - método main ( ) COMENTARIO “Ingreso de datos al arreglo sueldos[ ][ ]” DESDE i = 0 HASTA i = numTrab - 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[0][i] <= 0 ) HACER COMENTARIO “Ingreso de la tarifa horaria” LEER sueldos[1][i] SI ( sueldos[1][i] <= 0 ) ENTONCES ESCRIBIR “Tarifa horaria no válida... ” FINSI MIENTRAS ( sueldos[1][i] <= 0 ) FINDESDE COMENTARIO “Cálculo del sueldo bruto y neto por trabajador” DESDE i = 0 HASTA i = numTrab - 1 INCREMENTA 1 SI ( sueldos[0][i] > 48 ) ENTONCES sueldoBruto = (sueldos[0][i] – 48) * (sueldos[1][i] * 1.25) + (48 * sueldos[1][i]) SINO sueldoBruto = sueldos[0][i] * sueldos[1][i] FINSI SI ( sueldoBruto > 3500 ) ENTONCES descuento = sueldoBruto * 0.15 SINO SI (suesldoBruto > 1600 ) ENTONCES descuento = sueldoBruto * 0.10 SINO descuento = 0 FINSI FINSI aumento = sueldoBruto * 0.15 sueldoNeto = sueldoBruto + aumento – descuento sueldoBruto = sueldoBruto REDONDEA 2 sueldoNeto = sueldoNeto REDONDEA 2 ESCRIBIR sueldoBruto, sueldoNeto FINDESDE FIN

Pag. 471



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

Pag. 472


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

Pag. 473


Problema 142 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 cada uno de los nombre con su respectiva longitud. Etapa 02 - Definición de la solución.

Resultado deseado:

Mostrar el nombre y la longitud del nombre de todos los artículos de una bodega.

Datos necesarios:

El número de artículos y el nombre de cada uno de los artículos.

Procesamiento:

El número de artículos se ingresa a través del teclado y se almacena en una variable (numArt). Con el número de artículos se crea un arreglo (articulos[ ]). Luego se procede a ingresar el nombre de los artículos de la bodega, se almacenan temporalmente en una variable (sueldo), luego se eliminan los espacios del inicio y final del nombre, y se almacenan en el arreglo creado. Después, para cada uno de los nombres, se determina su longitud, se almacena en una variable (tamaño) y se muestra por pantalla.

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

Pag. 474




Clases biblioteca


Algoritmo PrgArticulos01 - método main ( ) ENTRADA: numArt, nombres SALIDA: tamaño INICIO COMENTARIO “Declaración de variables” NUMERO i, numArt, tamaño TEXTO articulos[ ], 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



Algoritmo PrgArticulos01 - método main ( ) COMENTARIO “Ingreso de datos al arreglo articulos [ ]” DESDE i = 0 HASTA i = numArt - 1 INCREMENTA 1 HACER LEER nombre articulos[i] = nombre 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 “Cálculo de la longitud de los nombres” DESDE i = 0 HASTA i = numArt - 1 INCREMENTA 1 tamaño = LONGITUD articulos[i] ESCRIBIR articulos[i], tamaño FINDESDE FIN

Etapa 04 - Desarrollo de la Codificación. Clase PrgArticulos01 package dominioDeLaAplicacion ; import biblioteca.* ; public class PrgArticulos01 { public static void main(String[] args) { // Declaración de variables. int i, numArt, tamaño ; String nombre ; // 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 ) ;

Pag. 476



Clase PrgArticulos01 // Declaración y creación del arreglo. String articulos[ ] = new String [numArt] ; // 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) + “]: ” ) ; nombre = Lectura.leerString( ) ; articulos[i] = nombre.trim( ) ; if ( articulos[i].length( ) < 3 ) { System.out.println ( “ El nombre ingresado no es válido… Reintente! ” ) ; } } while ( articulos[i].length( ) < 3 ) ; } // Cálculo de la longitud de los nombres. for ( i = 0 ; i < numArt ; i++ ) { tamaño = articulos[i].length( ) ; System.out.println ( “ Artículo ” + articulos[i] + “ tiene una longitud de ” + tamaño ) ; } } }

Pag. 477


Problema 143 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 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 la primera letra de todos los nombres en letra mayúscula y el resto en letra minúscula. Adicionalmente mostrar la longitud de cada uno de los nombres de los artículos.

Datos necesarios:


Procesamiento:

El número de artículos se ingresa a través del teclado y se almacena en una variable (numArt). Con el número de artículos se crea un arreglo (articulos[ ]). Luego se procede a ingresar el nombre de los artículos de la bodega, se eliminan los espacios del inicio y final del nombre, y se almacenan en el arreglo creado. Después, para cada uno de los nombres, se obtiene la primera letra, se almacena en una variable (letra) y se convierte en mayúscula. Luego, se obtiene las demás letras, se almacenan en una variable (resto) y se convierten en minúscula. También, se determina la longitud del nombre y se almacena en una variable (tamaño). Finalmente, se muestra la primera letra del nombre en mayúscula, las demás letras en minúscula y la longitud del nombre por pantalla.

Pag. 478


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

1. Nombre del Proyecto: ProyArticulos.





Clases biblioteca

Pag. 479



Algoritmo PrgArticulos02 - método main ( ) ENTRADA: numArt, articulos[ ] SALIDA: letra, resto, tamaño INICIO COMENTARIO “Declaración de variables” NUMERO i, numArt, tamaño TEXTO articulos[ ], letra, 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 - 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 “ 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

Pag. 480



Clase PrgArticulos02 package dominioDeLaAplicacion ; import biblioteca.* ; public class PrgArticulos02 { public static void main(String[] args) { // Declaración de variables. int i, numArt, tamaño ; String letra, resto ; // 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] ; // Ingreso de datos al arreglo articulos[ ] 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 ) ; } // 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. 481


Problema 144 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 la primera letra y la última letra de cada uno de los nombres en letra mayúscula y minúscula respectivamente. Etapa 02 - Definición de la solución.

Resultado deseado:

Mostrar la primera letra de todos los nombres en letra mayúscula y el resto en letra minúscula. Adicionalmente mostrar la longitud de cada uno de los nombres de los artículos.

Datos necesarios:


Procesamiento:

El número de artículos se ingresa a través del teclado y se almacena en una variable (numArt). Con el número de artículos se crea un arreglo (articulos[ ]). Luego se procede a ingresar el nombre de los artículos de la bodega, se eliminan los espacios del inicio y final del nombre, y se almacenan en el arreglo creado. Después, para cada uno de los nombres, se obtiene la primera letra, se almacena en una variable (letraIni) y se convierte en mayúscula. Luego, se obtiene la última letra, se almacenan en una variable (letraFin) y se convierten en minúscula. Finalmente, se muestra por pantalla, la primera letra del nombre en mayúscula y la última letra del nombre en minúscula.

Pag. 482








Clases biblioteca

Pag. 483



Algoritmo PrgArticulos03 - método main ( ) ENTRADA: numArt, articulos[ ] SALIDA: letraIni, letraFin INICIO COMENTARIO “Declaración de variables” NUMERO i, numArt TEXTO articulos[ ], 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 - 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 “ Manipulación del nombre de los artículos ” DESDE i = 0 HASTA i = numArt - 1 INCREMENTA 1 letraIni = articulos[i] CARACTER INICIO letraIni = MAYUSCULA letraIni letraFin = articulos[i] CARACTER FIN letraFin = MINUSCULA letraFin ESCRIBIR letraIni, letraFin FINDESDE FIN

Pag. 484



Clase PrgArticulos03 package dominioDeLaAplicacion ; import biblioteca.* ; public class PrgArticulos03 { public static void main(String[] args) { // Declaración de variables. int i, numArt ; char letraIni, letraFin ; // 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] ; // 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 ) ; } // Manipulación del nombre de los artículos. for ( i = 0 ; i < numArt ; i++ ) { letraIni = articulos[i].charAt(0) ; letraIni = Character.toUpperCase(letraIni) ; letraFin = articulos[i].charAt (articulos[i].length( ) -1) ; LetraFin = Character.toLowerCase(letraFin) ; System.out.println ( “ Artículo ” + articulos[i] ) ; System.out.println ( “ Letra inicial : ” + letraIni + “. Letra final : ” + letraFin + “.” ) ; System.out.println ( ) ; } } }

Pag. 485


Problema 145 Etapa 01 - Descripción del problema. Desarrollar una solución que permita ingresar y almacenar el nombre, la sigla y la descripción de todos los artículos de una bodega. Consistenciar la entrada de datos. Mostrar la primera letra del nombre y la descripción en mayúscula y el resto en minúscula. . También, mostrar las siglas del artículo en mayúscula. Etapa 02 - Definición de la solución.

Resultado deseado:

Mostrar la primera letra de todos los nombres y las descripciones en letra mayúscula y el resto en letra minúscula. También mostrar las siglas del artículo en minúscula.

Datos necesarios:

El número de artículos y, el nombre, la descripción y las siglas de cada uno de los artículos.

Procesamiento:

El número de artículos se ingresa a través del teclado y se almacena en una variable (numArt). Con el número de artículos se crea un arreglo (articulos[ ]). Luego se procede a ingresar el nombre, la descripción y las siglas de los artículos de la bodega, se eliminan los espacios del inicio y final de los mismos, y se almacenan en el arreglo creado. Después, para cada uno de los nombres, se obtiene la primera letra, se almacena en una variable (letra), se obtiene las demás letras y se almacenan en una variable (resto). Luego se convierte a mayúscula la variable letra y a minúscula la variable resto y se almacenan en una variable (nombre). Luego, para cada una de las descripciones se realiza lo mismo y el resultado se almacenan en una variable (descrip). También, se convierte a mayúscula las siglas de cada artículo y se almacena en una variable (siglas). Finalmente, los resultados se muestran por pantalla.

Pag. 486








Clases biblioteca

Pag. 487



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



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



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



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


Pag. 492


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

Datos del mismo trabajador.

sueldos

0

0

1

1

2

: : numTrab - 1

2

: : :

: : numTrab - 1

nombre de los trabajadores

: : : 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


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

sexos

Danae

0

Edades

F

0

10

1

1

1

2

2

2

: :

: : :

numSoc - 1

: :

: : :

numSoc - 1

nombres de cada socios

: :

: : :

numSoc - 1

sexo de cada socio

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

precios

0

0

1

1

2

2

: : numArt - 1

: : :

: : numArt - 1

nombre de cada artículos

Pag. 494

0

1

: : :

: : :

precio de compra de cada artículos

precio de venta de cada artículos


Problema 146 Etapa 01 - Descripción del problema. Desarrollar una solución que permita ingresar y almacenar el nombre y el sueldo de todos los trabajadores de una empresa. Mostrar el nombre del trabajador que tiene el sueldo más alto y el promedio del sueldo de todos los trabajadores redondeado a dos decimales. Etapa 02 - Definición de la solución.

Resultado deseado:

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

Datos necesarios:

El número de trabajadores y, el nombre y el sueldo de cada trabajador.

Procesamiento:

El número de trabajadores se ingresa a través del teclado y se almacena en una variable (numTrab). Con el número de trabajadores se crean dos arreglos (nombres[] y sueldos[]). Luego se procede a ingresar el nombre de los trabajadores, se eliminan los espacios del inicio y final de los mismos, y se almacenan en uno de los arreglos creados (nombres[ ]). También, se procede a ingresar el sueldo de los trabajadores y se almacenan en el otro arreglo creado (sueldos[ ]). Después, se determina el sueldo mas alto entre todos los trabajadores comparando el sueldo de cada trabajador con el contenido de una variable (sueldoMayor), inicializada con cero. Si el contenido de la variable sueldoMayor resulta menor que el sueldo de un trabajador, el sueldo de dicho trabajador pasa a ser el sueldo mayor y se almacena en la variable sueldoMayor. Una vez determinado el sueldo mayor se muestra el nombre de todos los trabajadores cuyo sueldo es igual al sueldoMayor. Luego, se determina el promedio del sueldo de todos los trabajadores sumando el sueldo de cada trabajador a una variable acumulador

Pag. 495


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




Clases biblioteca

Pag. 496



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



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



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

Pag. 499



Clase PrgTrabajadores06 // Determinando el nombre de los trabajadores con el sueldo mas alto. for ( i = 0 ; i < numTrab ; i++ ) { if ( i == 0 ) { sueldoMayor = sueldos[i] ; } else { if ( sueldoMayor < sueldos[i] ) { sueldoMayor = sueldos[i] ; } } } System.out.println ( “ Nombres de los trabajadores con el sueldo más alto ” ) ; for ( i = 0 ; i < numTrab ; i++ ) { if ( sueldoMayor == sueldos[i] ) { System.out.println ( “ ” + nombres[i] ) ; } } // Determinando el promedio del sueldo de todos los trabajadores. for ( i = 0 ; i < numTrab ; i++ ) { sumaSueldos = sumaSueldos + sueldos[i] ; } sueldoPromedio = sumaSueldos / numTrab ; sueldoPromedio = ( Math.round (sueldoPromedio * 100) ) / 100.0 ; System.out.println ( “ El sueldo promedio de los trabajadores es: ” + sueldoPromedio ) ; } }

Pag. 500


Problema 147 Etapa 01 - Descripción del problema. Desarrollar una solución que permita ingresar y almacenar el nombre, el sexo y la edad de todos los socios de un club. 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”. Etapa 02 - Definición de la solución.

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

Datos necesarios:

El número de socios y, el nombre, sexo y edad de cada socio.

Procesamiento:

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[],sexos[] y edades[]). Luego se procede a ingresar el nombre de los socios, se eliminan los espacios del inicio y final de los mismos, y se almacenan en uno de los arreglos creados (nombres[]). Luego, se procede a ingresar el sexo de los socios (M = Masculino y F = Femenino), se convierte a mayúscula y se almacenan en otro de los arreglos creado (sexos[]). Por último, se ingresan las edades de los socios y se almacenan en el tercer arreglo (edades[]). Después, se determina el número de socios hombres, mayores de edad. 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), entonces se aumenta 1 a una variable de tipo contador (totalMayoresHombres). Finalizada la evaluación de los datos de todos los socios se muestra el contenido de la variable totalMayoresHombres. Luego, se determina el número de socios cuyo nombre comienza con la letra ‘D’. Para esto se obtiene la primera letra del nombre de

Pag. 501


cada socio y se almacena en una variable (letra), se convierte a mayúscula y se compara con la letra ‘D’. Si letra = ‘D’, entonces se aumenta 1 a otra variable tipo contador (totalNombresD). Finalizada la evaluación se muestra el contenido de la variable totalNombresD.

Etapa 03 - Diseño de la lógica. 1. Nombre del Proyecto: ProySocios. 2. Definición de Paquetes y desarrollo del Diagrama de Paquetes. Diagrama de paquetes


Clases biblioteca

Pag. 502



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

Pag. 503



Algoritmo PrgSocios01 - 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 - 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 - 1 INCREMENTA 1 letra = nombres[i] CARACTER 0 letra = MAYUSCULA letra SI ( letra = ‘D’ ) ENTONCES totalNombresD = totalNombresD + 1 FINSI FINDESDE ESCRIBIR totalNombresD FIN

Pag. 504



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

Pag. 505



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

Pag. 506


Problema 148 Etapa 01 - Descripción del problema. Desarrollar una solución que permita ingresar y almacenar el nombre, el precio de compra y el precio de venta de todos los artículos de una bodega. Indicar el nombre de cada artículo y su margen de utilidad. Etapa 02 - Definición de la solución.

Resultado deseado:

Mostrar el nombre de cada artículo y su margen de utilidad.

Datos necesarios:

El número de artículos y, el nombre, el precio de compra y el precio de venta de cada artículo.

Procesamiento:

El número de artículos se ingresa a través del teclado y se almacena en una variable (numArt). Con el número de artículos se crean dos arreglos, un vector y una matriz con dos columnas (nombres[ ] y precios[ ][ ]). Luego se procede a ingresar el nombre de los artículos, se eliminan los espacios del inicio y final de los mismos, y se almacenan en uno de los arreglos creados (nombres[ ]). Luego, se procede a ingresar el precio de compra y el precio de venta, y se almacenan en el otro arreglo creado (precios[ ][ ]). El precio de compra se almacena en la primera columna del arreglo y el precio de venta se almacena en la segunda columna. Después, se determina la utilidad de cada artículo. Para esto, el precio de venta del artículo se resta de su precio de compra, se almacena el resultado en una variable (utilidad) y se muestra el nombre del artículo junto con su utilidad.

Pag. 507


Etapa 03 - Diseño de la lógica. 1. Nombre del Proyecto: ProyArticulos.





Clases biblioteca

Pag. 508



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

Pag. 509



Algoritmo PrgArticulos06 - 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...” FINSI MIENTRAS ( precios[i][1] <= 0 ) FINDESDE COMENTARIO “Determinando la utilidad de cada artículo ” DESDE i = 0 HASTA i = numArt - 1 INCREMENTA 1 utilidad = precios[i][1] – precios[i][0] ESCRIBIR nombres[i], utilidad FINDESDE FIN

Pag. 510



Clase PrgArticulos06 package dominioDeLaAplicacion ; import biblioteca.* ; public class PrgArticulos06 { public static void main(String[] args) { // Declaración de variables. int i, numArt ; double utilidad ; // Determinación del tamaño de los arreglos 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 nombres[ ] = new String [numArt] ; double edades[ ] = new double [numArt][2] ; // Ingreso de nombre, precio de compra y precio de venta de los artículos. for ( i = 0 ; i < numArt ; i++ ) { do { System.out.print ( “ Ingrese el nombre del artículo [ ” + ( i + 1) + “ ]: ” ) ; nombres[i] = Lectura.leerString( ) ; nombres[i] = nombres[i].trim( ) ; if ( nombres[i].length( ) < 3 ) { System.out.println ( “ El nombre del artículo no es válido… ” ) ; } } while ( nombres[i].length( ) < 3 ) ; do { System.out.print ( “ Ingrese su precio de compra : ” ) ; precios[i][0] = Lectura.leerDouble( ) ; if ( precios[i][0] <= 0 ) { System.out.println ( “ Precio de compra no válido… ” ) ; } } while ( precios[i][0] <= 0 ) ;

Pag. 511



Clase PrgArticulos06 do { System.out.print ( “ Ingrese su precio de venta : ” ) ; precios[i][1] = Lectura.leerDouble( ) ; if ( precios[i][1] <= 0 ) { System.out.println ( “ Precio de venta no válido… ” ) ; } } while ( precios[i][1] <= 0 ) ; } // Determinando la utilidad de cada artículo. for ( i = 0 ; i < numArt ; i++ ) { utilidad = precios[i][1] – precios[i][0] ; System.out.print ( “ El artículo : ” + nombres[i] + “ tiene una utilidad de ” ) ; System.out.println ( “ ” + utilidad + “.” ) ; } } }

Pag. 512


Problema 149 Etapa 01 - Descripción del problema. Desarrollar una solución que permita ingresar y almacenar el nombre, el código y las diferentes notas de los alumnos de un salón de clase. Indicar el nombre, el código y el promedio de notas de cada alumno. Almacenar el promedio de notas de cada alumno. Adicionalmente, indicar el nombre de los alumnos que obtuvieron el mayor promedio. Etapa 02 - Definición de la solución.

Resultado deseado:

Mostrar el nombre, el código y el promedio de notas de cada alumno. Adicionalmente, indicar el nombre de los alumnos que obtuvieron el mayor promedio.

Datos necesarios:

El número de alumnos y, el nombre, el código y las notas de cada alumno.

Procesamiento:

El número de alumnos y el número de notas se ingresa a través del teclado y se almacena en variables (numAlu y numNot respectivamente). Con el número de alumnos y el número de notas se crean cuatro arreglos, tres vectores y una matriz (nombres[], codigos[], notas[][] y promedios[][]). Luego se procede a ingresar el nombre de los alumnos, y se almacenan en uno de los arreglos creados (nombres[]). Luego, se procede a ingresar el código de los alumnos y se almacenan en otro arreglo (codigos[]). Támbien se ingresan las notas de cada alumno y se almacenan en otro de los arreglos (notas[][]). Después, se determina el promedio de cada alumno y el promedio mayor. Para esto, se suman las notas del alumno y se almacenan en una variable (sumaNotas) y luego se divide entre el número de notas (numNot). El resultado se almacenada en otra variable (promAlu), se redondea y esta a su vez se almacena en el arreglo promedios[]. Después se muestra el nombre, el código y el promedio de cada alumno. Luego se determina el promedio mayor y se almacena

Pag. 513


en una variable (promAluMayor). Finalmente, se muestran los nombres de todos los alumnos que tienen promedio igual a promAluMayor. Etapa 03 - Diseño de la lógica. 1. Nombre del Proyecto: ProyAlumnos. 2. Definición de Paquetes y desarrollo del Diagrama de Paquetes.



Clases biblioteca

Pag. 514



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

Pag. 515



Algoritmo PrgAlumnos06 - método main ( ) HACER LEER codigos[i] SI ( codigos[i] < 100000 OR codigos[i] > 999999 ) ENTONCES ESCRIBIR “Código ingresado no válido...” 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...” 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 sumaNotas = 0 DESDE j = 0 HASTA j = numNot - 1 INCREMENTA 1 sumaNotas = sumaNotas + notas[i][j] FINDESDE promAlu = sumaNotas / numNot promAlu = promAlu REDONDEA 2 promedio[i] = promAlu ESCRIBIR nombres[i], codigos[i], 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 - 1 INCREMENTA 1 SI ( promedios[i] = promAluMayor ) ENTONCES ESCRIBIR nombres[i] FINSI FINDESDE FIN

Pag. 516



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


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


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

Resultado deseado:

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

Datos necesarios:


Procesamiento:

El número de artículos se ingresa a través del teclado y se almacena en una variable (numArt). Con el número de artículos se crea un arreglo (articulos[ ]). Luego se procede a ingresar el nombre de los artículos de la bodega, se eliminan los espacios del inicio y final del nombre, y se almacenan en el arreglo creado. Después se ordenan los nombres utilizando el método de ordenación por Intercambio. Finalizado el método de ordenación, para cada uno de los nombres, se obtiene la primera letra, se almacena en una variable (letra) y se convierte en mayúscula. Luego, se obtiene las demás letras, se almacenan en una variable (resto) y se convierten en minúscula. También, se determina la longitud del nombre y se almacena en una variable (tamaño). Finalmente, se muestra la primera letra del nombre en mayúscula, las demás letras en minúscula y la longitud del nombre por pantalla.

Pag. 519


Etapa 03 - Diseño de la lógica. 1. Nombre del Proyecto: ProyArticulos.




Clases biblioteca

Pag. 520



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



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



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


Pag. 524

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

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.

5

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




Pag. 527


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

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

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

Resultado deseado:

Mostrar la nota final de un determinado alumno.

Datos necesarios:

Las notas del alumno (en esta caso tenemos 3 notas).

Procesamiento:

La 3 notas serán ingresadas por teclado y almacenadas en las variables nota1, nota2, y nota3. Luego, se realizará el cálculo de la nota final sobre la base de la siguiente fórmula: prom = (nota1 + nota2 + nota3) / 3. El resultado se almacenará en una variable (prom) para luego ser mostradas por pantalla.


Nombre del Proyecto: ProyAlumno.

Pag. 528


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

Definición de las Clases. Clases dominioDeLaAplicacion

Clases biblioteca

Diseño del algoritmo para el método principal. Algoritmo PrgAlumno - método main() ENTRADA: nota1, nota2, nota3 SALIDA: prom INICIO NUMERO nota1, nota2, nota3, prom LEER nota1, nota2, nota3 prom = ( nota1 + nota2 + nota3) / 3 ESCRIBIR prom FIN

Pag. 529


Etapa 04 - Desarrollo de la Codificación. Clase PrgAlumno package dominioDeLaAplicacion ; import biblioteca.Lectura ; class PrgAlumno { public static void main ( String arg [ ] ) { double nota1, nota2, nota3, prom ; System.out.println ( “Ingrese la nota 1 del alumno: ” ) ; nota1 = Lectura.leerDouble( ) ; System.out.println ( “Ingrese la nota 2 del alumno: ” ) ; nota2 = Lectura.leerDouble( ) ; System.out.println ( “Ingrese la nota 3 del alumno: ” ) ; nota3 = Lectura.leerDouble( ) ; prom = ( nota1 + nota2 + nota3 ) / 3 ; System.out.println ( “ El promedio obtenido por el alumno es ” + prom ) ; } }

En este proyecto ProyAlumno se crea un paquete dominioDeLaAplicación con una clase PrgAlumno la cual se utiliza en su forma más simple. En la clase PrgAlumno se define un método main() y dentro del mismo se codifica toda la solución. Como se ha mencionado, las clases son mucho más poderosas que las presentadas hasta ahora. A partir de este punto, se ampliará el conocimiento sobre las clases. Para ello, se revisarán algunos conceptos básicos y se presentarán, en forma progresiva, nuevos conceptos hasta llegar al concepto de ocultamiento de atributos de instancia. Todos estos nuevos conceptos presentados se incorporarán progresivamente en el ejemplo planteado. Al final, se formalizará el método de solución, el Método de las 6D, para incluir los conceptos presentados.

Pag. 530


Pag. 531


Pag. 532


CONCEPTOS BÁSICOS

CLASE Una clase es una implantación de un tipo de objeto. Especifica una estructura de datos (atributos) y los métodos operativos permisibles que se aplican a cada uno de sus objetos. El mundo real se modela mediante clases. Una clase es una abstracción y no referencia a ningún objeto en particular. Una clase define un nuevo tipo de objeto. En Java, una clase se declara utilizando la palabra reservada class. Las clases que se han utilizado anteriormente son ejemplos muy limitados en los que no aparece su formato general. El formato general de una clase en Java es el siguiente:

class NombreClase { // ATRIBUTOS tipo variableInstancia1 ; tipo variableInstancia2 ; // ... tipo variableInstanciaN ; // METODOS tipo nombreMetodo1 (listaDeParámetros) { // cuerpo del método1. } tipo nombreMetodo2 (listaDeParámetros) { // cuerpo del método2. } //... tipo nombreMetodoN (listaDeParámetros) { // cuerpo del métodoN. } }

Los datos o variables definidos en una clase se llaman atributos. El código está contenido en los métodos. En conjunto, los métodos y los atributos definidos dentro de una clase son los miembros de la clase.

Pag. 533


Los atributos definidos dentro de una clase, permiten que los objetos o instancias de una clase puedan almacenar datos. Todos los métodos tienen el mismo formato que el método main() utilizado en los ejemplos anteriores. Sin embargo, es importante mencionar, que muchos métodos no se especificarán como public, static o public static. 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(). Solo necesitarán tener un método main() aquellas clases que tengan como función principal iniciar la ejecución del proyecto. En el proyecto de solución ProyAlumno se agregará una clase llamada Alumno. La declaración de esta clase en Java es la siguiente: class Alumno { }

Ahora, el proyecto de solución ProyAlumno tiene definidas las clases PrgAlumno y Alumno en el paquete dominioDeLaAplicacion.

Pag. 534


OBJETO Objetos: Modelos de entes del mundo. Un objeto de software es cualquier cosa real o abstracta acerca de la cual almacenamos datos y los métodos que controlan dichos datos. La definición de un objeto en Java comprende la declaración y la creación del mismo, y se realiza utilizando la siguiente sentencia: NombreClase nombreObjeto = new NombreClase ( ) ;

Donde; •

nombreObjeto es el nombre del objeto que se desea crear.

•

nombreClase es el nombre de la clase que está siendo instanciada. El nombre de la clase seguida por los paréntesis especifica el método constructor de la clase. Un constructor define que ocurre cuando se crea un objeto de una clase. La mayoría de las clases del mundo real definen explícitamente sus propios constructores dentro de la definición de la clase. Si no se especifica explícitamente el constructor, Java automáticamente utiliza un constructor por defecto (es decir, cuando se crea un objeto no ocurre nada). En el ejemplo, la clase Alumno no define explícitamente un constructor, es decir se utiliza el constructor por defecto. Más adelante se verá la forma de definir métodos constructores en una clase.

•

new es un operador en Java que permite crear un objeto.

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 ( ) ;

En dicha sentencia, se define el objeto objAlumno de la clase Alumno. Para definir otros objetos de la clase Alumno solo se tendría que repetir la sentencia y cambiar el nombre del objeto. Es importante recordar que la definición de una clase sólo crea un molde, modelo o patrón a partir del cual se pueden crear objetos, mientras que la definición de un objeto crea un objeto real o una instancia de una clase.

Pag. 535


ATRIBUTO Hasta este punto, se ha creado la clase Alumno sin atributos ni métodos. Ahora, es necesario conocer algunos conceptos básicas sobre los atributos, para luego definirlos dentro de la clase Alumno. Los atributos, en principio, sirven para almacenar valores de los objetos que se instancian a partir de una clase. Los atributos se clasifican en dos categorías:

Atributos de Instancia. Los atributos de instancia conocidos también como atributos de objeto, son variables, arreglos u objetos que almacenan valores distintos para todos los objetos de una misma clase.

Atributos de Clase. Los atributos de clase son variables, areglos u objetos que almacenan el mismo valor para todos los objetos de una misma clase.

En otras palabras, 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. Si no se especifica lo contrario los atributos son de instancia y no de clase. Para declarar un atributo de clase se utiliza la palabra reservada static. Es decir, 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. La forma mínima de un atributo es la siguiente; tipo nombreAtributo;

Donde : •

tipo especifica el tipo de dato que el atributo almacenará. Puede ser cualquier tipo válido, incluido los tipos de Clase.

•

nombreAtributo especifica el nombre del atributo, que puede ser cualquier identificador válido diferente a los que se está utilizando en el mismo ámbito.

Pag. 536


En el proyecto de solución ProyAlumno, en la clase Alumno se definirá dos atributos de instancia llamados nota1 y nota2. class Alumno { double nota1 ; double nota2 ; }

En la clase Alumno solo se han definido dos atributos, pero todavía no se han definido método. Se agregarán algunos métodos a la clase Alumno mas adelante. También, se definirá el objeto objAlumno de la clase Alumno, dentro del método main() de la clase PrgAlumno, tal y como se especificó anteriormente a través de la siguiente sentencia: Alumno objAlumno = new Alumno ( ) ;

Cada vez que se define un objeto de una clase, se declara y crea un objeto que contiene una copia de todos los atributos de instancia definidos para la clase. En el proyecto de solución ProyAlumno, cada objeto que se defina de la clase Alumno tendrá su propia copia de los atributos de instancia nota1 y nota2. En consecuencia, 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, distinto al valor de las copias de los atributos de instancia que otros objetos definidos puedan tener. Cuando se desea acceder a la copia de los atributos de instancia de un objeto se utiliza el operador punto (.). El operador punto relaciona el nombre del objeto con el nombre de un atributo de instancia. Por ejemplo, si se desea asignar el valor 15 y 19 a los atributos de instancia nota1 y nota2 del objeto objAlumno, se utilizarían las siguientes sentencias: objAlumno.nota1 = 15 ; objAlumno.nota2 = 19 ;

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. Si se desea mostrar el valor del atributo de instancia nota1 del objeto objAlumno se utilizaría la siguiente sentencia: System.out.println ( “ La nota del alumno es: ” + objAlumno.nota1 ) ;

Pag. 537


Esta sentencia permite que se muestre el mensaje “La nota del alumno es:” y el valor del atributo nota1 del objeto objAlumno. En el proyecto de solución ProyAlumno, se necesita calcular y mostrar el promedio del alumno, para lo cual se utilizarían las siguientes sentencias: prom = ( objAlumno.nota1 + objAlumno.nota2 ) / 2 ; System.out.println ( “El promedio final del alumno es: ” + prom ) ;

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, para luego mostrar el mensaje “El promedio final del alumno es:” y el valor de la variable prom calculada. Según lo mencionado anteriormente, el proyecto de solución ProyAlumno se desarrollaría de la siguiente manera: package dominioDeLaAplicacion ; class Alumno { double nota1 ; double nota2 ; } package dominioDeLaAplicacion ; class PrgAlumno { public static void main ( String args [ ] ) { double prom ; // Primero declaramos y creamos un objeto de la clase Alumno. Alumno objAlumno = new Alumno ( ) ; // Ahora asignamos valores a las variables de instancia del objeto creado. objAlumno.nota1 = 15 ; objAlumno.nota2 = 19 ; // Finalmente, calculamos el promedio de notas del alumno objAlumno. prom = ( objAlumno.nota1 + objAlumno.nota2 ) / 2 ; System.out.println ( “ El promedio final del alumno es: ” + prom ) ; } }

Es importante recordar que ambas clases pertenecen al paquete dominioDeLaAplicacion y que el proyecto de solución se denomina ProyAlumno. Al ejecutar el proyecto, se ejecuta el método main() de la clase PrgAlumno y se obtiene el siguiente resultado: El promedio final del alumno es: 17

Pag. 538


Es común que en todo proyecto de solución solo exista un método main( ). Dicho método main( ) inicia la ejecución del proyecto y está definido en una de las clases que pertenecen al proyecto. Ahora, se realizarán algunos cambios en el proyecto de solución ProyAlumno. Se agregará un atributo de instancia en la definición de la clase Alumno, de tal forma, que se definan los atributos de instancia nota1, nota2 y nota3. Es importante mencionar que si existen varios atributos del mismo tipo en una misma clase, se puede separar sus nombres mediante comas (,) y declararlos con una solo sentencia. Tal y como se muestra a continuación: class Alumno { double nota1, nota2, nota3 ; }

En base a esto, se modificará el método main() de la clase PrgAlumno para utilizar el atributo de instancia nota3, de la siguiente manera: package dominioDeLaAplicacion ; class Alumno { double nota1, nota2, nota3 ; }

package dominioDeLaAplicacion ; class PrgAlumno { public static void main ( String args [ ] ) { double prom ; // Primero declaramos y creamos un objeto de la clase Alumno. Alumno objAlumno = new Alumno ( ) ; // Ahora asignamos valores a las variables de instancia del objeto creado. objAlumno.nota1 = 15 ; objAlumno.nota2 = 19 ; objAlumno.nota3 = 11 ; // Finalmente, calculamos el promedio de notas del alumno objAlumno. prom = ( objAlumno.nota1 + objAlumno.nota2 + objAlumno.nota3 ) / 3 ; System.out.println ( “ El promedio final del alumno es: ” + prom ) ; } }

Aquí el objeto objAlumno de la clase Alumno creado en el método main( ) de la clase PrgAlumno tiene su propia copia de los atributos de instancia nota1,nota2 y nota3. 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. 539


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

Al ejecutar el proyecto (recuerde que cuando se ejecuta un proyecto en realidad se ejecuta el método main( ) ), 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. 540


Y se puede comprobar que cada objeto de la clase Alumno tiene una copia de los atributos de instancia nota1, nota2 y nota3, y que los valores de un objeto son independientes de los otros valores que tienen los otros objetos.

Pag. 541


MÉTODO Hasta este punto se ha creado la clase Alumno con tres variables de instancia y sin ningún método. Ahora es necesario conocer algunas cosas básicas sobre los métodos para luego poder definirlos dentro de la clase Alumno. Un método representa un pequeño subprograma encapsulado dentro de una clase y contribuye a definir el comportamiento típico de los objetos. Los métodos especifican la forma en que se controlan los datos (atributos) de un objeto. Los métodos definen el comportamiento de un objeto. Los métodos se clasifican en dos categorías:

Métodos de Instancia. Los métodos de instancia, conocidos también como métodos de objeto, son métodos que pueden ser llamados a través de un objeto instanciado a partir de una clase. Un método de instancia se ejecuta utilizando el siguiente formato: nombreObjeto.nombreMétodoInstancia ( ) ;

Métodos de Clase. 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. Generalmente, para ejecutar un método de clase se utiliza el siguiente formato: NombreClase.nombreMétodoClase ( ) ;

En otras palabras, mientras que para ejecutar un método de instancia se requiere crear primero un objeto de la clase donde está definido el método, para ejecutar un método de clase no se requiere crear un objeto ya que se puede hacer directamente utilizando el nombre de la clase donde está definido el método. Para declarar un método de clase se utiliza la palabra reservada static. A través de métodos de clase se puede manipular solo atributos de clase. Mientras que a través de métodos de instancia se puede manipular tanto atributos de clase como atributos de instancia. La forma mínima de un método es la siguiente; tipo nombreMétodo ( listaDeParámetros ) { // Cuerpo del método ; ]

Pag. 542


Donde : •

tipo especifica el tipo de dato devuelto válido, incluido los tipos de clase. Si el devuelto debe ser void. Los métodos devuelven un valor a la sentencia que forma de la sentencia return:

por el método. Puede ser cualquier tipo método no devuelve ningún valor, el tipo que devuelven un tipo distinto de void, ejecuta el método utilizando la siguiente

return valor ; Aquí valor es el dato que el método devuelve a la sentencia que lo ejecutó. 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.

•

listaDeParámetros es una secuencia de parejas de tipo e identificador separados por comas. Los parámetros son variables que reciben el valor de los argumentos que se pasan al método cuando este es ejecutado. Si el método no tiene parámetros, entonces la lista de parámetros estará vacía.

Pag. 543


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

Pag. 544


Al ejecutar el proyecto se obtiene el siguiente resultado, 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, ubicadas dentro del método main( ) de la clase PrgAlumno, permiten ejecutar el método promedio( ) definido en la clase Alumno: objAlumno.promedio ( ) ; objAlumno02.promedio ( ) ; objAlumno03.promedio ( ) ;

Al igual que para acceder a las variables de instancia, para acceder a los métodos se utiliza el operador punto (.). El operador punto relaciona el nombre del objeto con el nombre de un método. Analicemos la siguiente sentencia; objAlumno.promedio ( ) ;

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. Es decir; se ejecuta el método promedio( ) utilizando el nombre de un objeto de la clase Alumno seguido por el operador punto. Así, cuando se ejecuta;

•

objAlumno.promedio ( ) ;

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, nota2 = 19 y nota3 = 11 ).

•

objAlumno02.promedio ( ) ;

Se calcula y visualiza el promedio de notas del objeto objAlumno02 en base a los valores de su copia de los atributos de instancia ( nota1 = 11, nota2 = 11 y nota3 = 11 ).

•

objAlumno03.promedio ( ) ;

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, nota2 = 14 y nota3 = 15 ).

Pag. 545


Ahora, se analizará la definición del método promedio( ) de la clase Alumno; void promedio ( ) { System.out.print ( “ El promedio final del alumno es: ” ) ; System.out.println ( (nota1 + nota2 + nota3 ) / 3 ) ; }

El método promedio( ) no devuelve ningún valor ya que tiene definido como tipo de retorno void. Todos los métodos definidos con void no devuelven valor, por lo que no es necesario especificar una sentencia return al final de este método. El método promedio(), tampoco tiene parámetros ya que al final del nombre del método los paréntesis se encuentran vacíos. No devuelve valor.

No tiene parámetros.

void promedio ( ) { System.out.print ( “ El promedio final del alumno es: ” ) ; System.out.println ( ( nota1 + nota2 + nota3 ) / 3 ) ; }

La llave de apertura “{”, ubicada después del paréntesis y la llave de cierre “}” ubicada en la última línea definen el ámbito del método promedio( ). El ámbito de un método define todas las sentencias que se ejecutarán cuando el método se ejecute. En el caso anterior, cuando se ejecute el método promedio( ) se ejecutarán las dos sentencia que están dentro de su ámbito (es decir, entre las llaves). En el ámbito del método promedio( ) se puede observar que las variables de instancia nota1, nota2 y nota3 se utilizan directamente sin estar precedidas del nombre del objeto y el operador punto (.). Cuando un método utiliza una variable de instancia que ha sido definida en su misma clase, se puede referir a ella en forma directa utilizando solo su nombre.

Pag. 546


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

Pag. 547


prom = objAlumno02.promedio ( ) ; prom = prom + 1 ; System.out.println ( “ La nota final de María es ” + prom + “.” ) ; System.out.println ( “ La nota final de Pedro es ” + objAlumno03.promedio ( ) + “.” ) ; } }

Para ejecutar, un método que devuelve un valor, se utiliza también el nombre del objeto, el operador punto (.) y el nombre del método, pero debido a que el método devuelve un valor, éste deberá ser asignado a una variable del mismo tipo que el valor devuelto por el método. En el ejemplo tenemos la siguiente sentencia: prom = objAlumno.promedio ( ) ;

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. Como el método promedio( ) devuelve un valor, entonces el valor devuelto será almacenado en la variable prom. Observe que la variable prom es del mismo tipo que el valor devuelto por el método promedio( ).

Sentencia definida en el método main( ) de la clase PrgAlumno.

Método definido en la clase Alumno.

double promedio ( ) { return ( nota1 + nota2 + nota3 ) / 3 ; }

prom =

objAlumno.promedio ( ) ;

Una vez que prom ya tiene el valor devuelto por el método promedio( ) se puede procesar dicho valor según sea necesario. En el primer caso, se muestra el valor de prom, y en el segundo caso, antes de mostrar el valor de prom se le suma 1.

Pag. 548


Se obtiene el promedio de notas y se muestra el resultado:

prom = objAlumno.promedio ( ) ; System.out.println ( “ La nota final de Luis es ” + prom + “.” ) ; Se obtiene el promedio de notas, se aumenta 1 y se muestra el resultado:

prom = objAlumno02.promedio ( ) ; prom = prom + 1 ; System.out.println ( “ La nota final de María es ” + prom + “.” ) ;

Es preciso mencionar, que se puede escribir estas sentencias de una manera más eficiente. Observe la siguiente sentencia: System.out.println ( “ La nota final de Pedro es ” + objAlumno03.promedio ( ) + “.” ) ;

Aquí no se hace uso de la variable prom. La ejecución del método promedio( ) se realiza directamente en la sentencia println(). Es decir, al ejecutar println( ), se ejecuta a su vez el método objAlumno3.promedio( ) y el valor devuelto se muestra a través de la pantalla.

Existen dos puntos importantes relacionados con los métodos que devuelven valor: 1. El tipo de dato que un método devuelve (con la sentencia return), debe ser compatible con el tipo de dato especificado por el método. Especifica que se debe devolver un valor double.


double promedio ( ) { return (nota1 + nota2 + nota3 ) / 3 ; }

2. 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. Declarada como double. Lo cual es compatible con el tipo de dato especificado por el método.

prom = objAlumno.promedio ( ) ;

Pag. 549


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

Pag. 550


prom = prom + 1 ; System.out.println ( “ La nota final de María es ” + prom + “.” ) ; System.out.println ( “ La nota final de Pedro es ” + objAlumno03.promedio() + “.” ); } }

Para ejecutar un método que tiene parámetros se utiliza el nombre del objeto, el operado punto(.), el nombre del método a ejecutar y los argumentos necesarios.

En el ejemplo anterior tenemos: objAlumno.setNotas ( 15,19,11 ) ;

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

Sentencia definida en el método main() de la clase PrgAlumno.

Método definido en la clase Alumno.

a = 15

objAlumno.setNotas (15,19,11 ) ;

void setNotas ( double a, double b, double c ) { nota1 = a ; nota2 = b ; nota3 = c ; }

3 ARGUMENTOS

3 PARÁMETROS

Un argumento es un valor que se envía a un método cuando este es ejecutado.

Un parámetro es una variable definida por un método, que recibe un valor cuando se ejecuta dicho método.

Pag. 551


Existen dos puntos importantes relacionados con los métodos que tienen parámetros: 1. Un método que tiene parámetros debe recibir un valor por cada parámetro definido. El valor recibido debe ser compatible con el tipo de dato definido por el parámetro al cual será asignado: No devuelve valor.

Especifica que se tiene definido 3 parámetros de tipo double.


2. Cuando se ejecuta un método que tiene parámetros, se debe pasar al método un valor por cada parámetro definido (es decir, se deben pasar los argumentos). 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 ( ).

objAlumno.setNotas(15,19,11);

Pag. 552


En conclusión, se puede afirmar lo siguiente: 1. Un método puede; no devolver valor y no tener definido parámetros. No devuelve valor.


void promedio ( ) { System.out.print ( “ El promedio final del alumno es: ” ) ; System.out.println ( ( nota1 + nota2 + nota3 ) / 3 ) ; }

2. Un método puede; no devolver un valor y tener definido uno o más parámetros. No devuelve valor.

Especifica que se tiene definido 3 parámetros de tipo double.


3. Un método puede; devolver un valor y no tener definido parámetros. Especifica que se debe devolver un valor double.


double promedio ( ) { return (nota1 + nota2 + nota3 ) / 3 ; }

4. Un método puede; devolver un valor y tener definido uno o más parámetros. (Este tipo de métodos no han sido tratados en el presente capítulo).

Pag. 553


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

Pag. 554


Cuando se ejecuta la siguiente sentencia:

Alumno objAlumno = new Alumno();

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( ). El método constructor Alumno( ) permite inicializar la copia de los atributos de instancia nota1, nota2 y nota3 del objeto objAlumno con el valor cero.

El método constructor puede tener definido parámetros. En ese caso, podemos enviar al método constructor Alumno( ), los valores de la copia de los atributos de instancia nota1, nota2 y nota3 del objeto creado y eliminar el método setNotas( ). Aunque esto es posible y perfectamente válido, no se eliminará el método setNotas( ). El método constructor Alumno( ) se encargará de inicializar con el valor cero, 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. (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, deberá realizarlo empleando otro método. Para nuestro caso, dicho método es setNotas( ) ).

Pag. 555


OCULTAR ATRIBUTOS DE INSTANCIA En Java, no es correcto que dos variables que están dentro del mismo ámbito tengan el mismo nombre. Es decir, dos variables locales declaradas dentro del mismo método o dos atributos, no pueden tener nombres iguales. Sin embargo, una variable local (declarada dentro de un método) puede tener el mismo nombre que un atributo. Cuando una variable local tiene el mismo nombre que un atributo, la variable local oculta al atributo. Observe la codificación de la clase Alumno: package dominioDeLaAplicacion ; class Alumno { double nota1, nota2, nota3 ; Alumno ( ) { nota1 = 0 ; nota2 = 0 ; nota3 = 0 ; } double promedio ( ) { return ( nota1 + nota2 + nota3 ) / 3 ; } void setNotas ( double a, double b, double c ) { nota1 = a ; nota2 = b ; nota3 = c ; } }

Dentro del método setNotas( ), se han declarado 3 variables locales (parámetros) para recibir las notas cuando se ejecute el método. Dichas variables locales fueron declaradas con los nombres a, b y c, que no tienen ningún significado especial, ya que dichos nombres de variables no reflejan el valor que almacenan. Estás variables locales no fueron declaradas con los nombres nota1, nota2 y nota3 debido a que dichos nombres ya eran utilizados por los atributos de instancia. Si analiza la implementación del método setNotas( ) podrá observar que en dicho método se utilizan las variables locales a, b y c, y también se utilizan los atributos de instancia nota1, nota2 y nota3. Si se hubieran declarado las variables locales con los nombres nota1, nota2 y nota3, no se podrían utilizar los atributos de instancia ya que siempre que se utilicen los nombres nota1, nota2 y nota3, 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). Cuando sucede esto, se dice que las variables locales ocultan a los atributos de instancia. Utilizando el operador this es posible nombrar a las variables locales igual que los atributos de instancia. Para esto, cada vez que necesite referirse a las variables locales se utilizará el

Pag. 556


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 (.) y el nombre del atributo. Cuando se utiliza el operador this se indica que se está refiriendo al atributo de instancia y no a una variable local. Forma general del operador this: this.nombreAtributoInstancia ;

Analizar la variación en la codificación de la clase Alumno: package dominioDeLaAplicacion ; class Alumno { double nota1, nota2, nota3 ; Alumno ( ) { nota1 = 0 ; nota2 = 0 ; nota3 = 0 ; } double promedio ( ) { return ( nota1 + nota2 + nota3 ) / 3 ; } void setNotas ( double nota1, double nota2, double nota3 ) { this.nota1 = nota1 ; this.nota2 = nota2 ; this.nota3 = nota3 ; } }

Ahora, en el método setNotas( ), se utilizan los mismos nombres para las variables locales (declarados como parámetros) y para los atributos de instancia. Al momento de referirnos a los atributos de instancia anteponemos al nombre del mismo el operador this y el operador punto (.) Nos referimos al atributo de instancia nota1.

This.nota1 = nota1;

Nos referimos a la variable local nota1.

Pag. 557


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

Pag. 558

de los de de


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

Pag. 559


Ahora, el proyecto de solución ProyAlumno tiene dos paquetes. Un paquete denominado biblioteca que contiene a la clase Lectura y un paquete denominado dominioDeLaAplicacion que contiene las clases PrgAlumno y Alumno. Cada clase tiene funciones específicas que se detallan a continuación. Clase PrgAlumno:

Tiene el método main( ) que permite que el proyecto se ejecute. Dentro del método main( ), se crea al objeto objAlumno de la clase Alumno, se ingresan las notas del alumno y se muestra el promedio.

Clase Alumno:

Define los atributos de instancia para almacenar las notas y los métodos que permiten manipular dichos atributos de instancia. Uno de los métodos realiza el cálculo del promedio.

Clase Lectura:

Define métodos que facilitan el ingreso de datos utilizando el teclado.

Pag. 560


MÉTODO DE LAS 6’D: Etapas y pasos El proyecto de solución ProyAlumno, se ha modificado poco a poco con la finalidad de tratar nuevos conceptos relacionados a la POO utilizando Java. Con la última solución desarrollada para el proyecto ProyAlumno, se pretende dar un paso importante para acercarnos al desarrollo de soluciones orientadas a objetos. 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. Ajuste de los pasos definidos para las etapas del método En la solución del problema anterior, se utilizó dos paquetes. Los mayores cambios los desarrollamos en las 2 clases del paquete dominioDeLaAplicacion. En una clase se desarrollará el método main( ) y se definirán objetos de la otra clase, mientras que en la otra clase se definirán los atributos de instancia, métodos de instancia y método constructor válido para los objetos. En base a esto, el método de solución queda definido según se muestra a continuación:

ENUNCIADO DEL PROBLEMA


• Definición del proyecto de solución. • Definición del algoritmo. • Definición del paquete Aplicación. o Definición de clases con sus atributos y métodos. • Definición del paquete biblioteca. o Uso de la clase Lectura con sus métodos definidos.


• Diseño del diagrama de paquetes respectivo. Establecer la dependencia. (Utilice UML). • Diseño de las clases que serán parte del paquete Aplicación. (Utilice UML).

• Diseño del algoritmo para los método definidos. Utilizar pseudocódigo.

Pag. 561


• Codificar el diseño de la solución del problema utilizando el lenguaje de programación Java.


Pag. 562


Con el propósito de describir los pasos definidos de las etapas del método 6’D, se volverá a solucionar el problema anterior.

PROBLEMA 151

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. 1. Definición del proyecto de solución. Para solucionar el problema se creará un proyecto denominado ProyAlumno, dentro del cual se definirá el paquete dominioDeLaAplicacion y se incluirá el paquete biblioteca (el cual incluye la clase Lectura). 2. Definición del algoritmo.

Resultado deseado:

Mostrar la nota final de un determinado alumno.

Datos necesarios:

Las notas del alumno (en esta caso tenemos 3 notas).

Procesamiento:

La 3 notas serán ingresadas por teclado y almacenadas en las variables nota1, nota2, y nota3. Luego, se realizará el cálculo de la nota final sobre la base de la siguiente fórmula: prom = ( nota1 + nota2 + nota3 ) / 3. El resultado se almacenará en una variable (prom) para luego ser mostradas por pantalla.

3. Definición del paquete Aplicación. En el paquete dominioDeLaAplicacion definiremos dos clases. La función de la primera clase será de procesamiento y almacenamiento de datos. Como buena práctica de programación, en los métodos de esta clase, no se realizará ingreso de datos, ni se mostrarán mensajes de ningún tipo. Pero, si se utilizarán los mismos nombres para referirnos a variables locales y a los atributos

Pag. 563


de instancia. Por otro lado, solo podrán ser definidos como atributos de instancia los datos de entrada. Su definición será la siguiente: Clase:

Alumno.

Atributos:

Como atributos de instancia definiremos las variables de entrada nota1, nota2 y nota3.

Métodos:

Necesitamos los siguientes métodos:

Método constructor para inicializar los atributos de instancia (método Alumno()).

Método para modificar los valores de las notas (método setNotas(), recibe los valores de las notas ).

Método para calcular el promedio de las notas (método promedio(), devuelve el valor del cálculo del promedio de las notas).

La función de la segunda clase será el ingreso de los datos y mostrar los resultados esperados. Como buena práctica de programación, en los métodos de esta clase, 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, la clase Alumno). Su definición será la siguiente: Clase:

PrgAlumno.

Atributos:

Como atributos de instancia definiremos al objeto objAlumno de la clase Alumno.

Métodos:

Utilizamos el método main( ) para iniciar la ejecución del proyecto, la creación del objeto objAlumno, el ingreso de los datos y mostrar los resultados esperados.

4. Definición del paquete biblioteca. En el paquete biblioteca se tendrá la clase Lectura para poder utilizar sus métodos.

Pag. 564


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

Diseño del Diagrama de Paquetes. Diagrama de paquetes

dominioDeLaAplicacion

biblioteca

Diseño de las clases. Clases de dominioDeLaAplicacion PrgAlumno

Alumno

Lectura

Alumno( ) setNotas(double, double, double) : void promedio( ) : double

leerString( ) : String leerChar( ) : char leerInt( ) : int leerLong( ) : long leerFloat( ) : float leerDouble( ) : double

nota1 : double nota2 : double nota3 : double main( )

Clase de biblioteca

Diseño de algoritmos. Algoritmo PrgAlumno METODO MAIN( ) ENTRADA: SALIDA:

n1, n2, n3 prom

INICIO NUMERO n1, n2, n3, prom CREAR OBJETO objAlumno CLASE Alumno EJECUTAR Alumno ( ) LEER n1, n2, n3 EJECUTAR objAlumno.setNotas ( n1,n2,n3 ) prom = EJECUTAR objAlumno.promedio ( ) ESCRIBIR prom FIN

Pag. 565


Algoritmo Alumno ATRIBUTOS NUMERO

nota1, nota2, nota3

METODO CONSTRUCTOR PARAMETRO: INICIO nota1 = 0 nota2 = 0 nota3 = 0 FIN METODO SETNOTAS PARAMETRO: RETORNO:

nota1, nota2, nota3

INICIO ATRIBUTO.nota1 = nota1 ATRIBUTO.nota2 = nota2 ATRIBUTO.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, 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. 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.

Pag. 566


EJECUTAR Se utiliza para ejecutar un método. Hay que tener presente que si el método es de clase se deberá anteponer el operador punto (.) y el nombre de la clase antes de colocar el nombre del método que se desea ejecutar. Si el método es de instancia se deberá anteponer el operador punto (.) y el nombre del objeto antes de colocar el nombre del método que se desea ejecutar. EJECUTAR objAlumno.setNotas ( n1,n2,n3 ) Se ejecuta el método setNotas() del objeto objAlumno, y se le envían los valores de la variables n1, n2 y n3. prom = EJECUTAR objAlumno.promedio ( ) Se ejecuta el método promedio del objeto objAlumno. El método promedio devuelve un resultado, el cual se almacena en la variable prom.

PARAMETRO Se utiliza para especificar las variables que utilizamos para recibir los valores enviados a un determinado método. PARAMETRO: nota1, nota2, nota3 Se especifica que se utilizan las variables nota1, nota2 y nota3 para recibir los valores que se envían al método al cual pertenece la instrucción.

RETORNO Se utiliza para especificar la variable que utilizaremos para devolver o retornar una respuesta de un determinado método. RETORNO: prom Se especifica que el valor almacenado en la variable prom será devuelto como respuesta cuando se ejecuta el método al cual pertenece la instrucción.

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. ATRIBUTO.nota1 = nota1 Para referirnos al atributo nota1 utilizamos la regla ATRIBUTO, la cual antecede al operador punto (.) y al nombre del atributo, tal y como se muestra en el ejemplo anterior.

Pag. 567


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

Clase Alumno package dominioDeLaAplicacion ; class Alumno { double nota1, nota2, nota3 ; Alumno ( ) { nota1 = 0 ; nota2 = 0 ; nota3 = 0 ; } double promedio ( ) { return ( nota1 + nota2 + nota3 ) / 3 ; } void setNotas ( double nota1, double nota2, double nota3 ) { this.nota1 = nota1 ; this.nota2 = nota2 ; this.nota3 = nota3 ; } }

Pag. 568


OTROS CONCEPTOS Finalmente, es importante mencionar, que deberá continuar investigando otros conceptos importantes de la Programación Orientada a Objetos, tales como; Encapsulamieno, Herencia, Polimorfismo, Interfaces Gráficas, Conexiones a BD, Servlets, entre otros. Dichos conceptos avanzados permitirán elaborar soluciones robustas y profesionales, 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.

Pag. 569


Pag. 570

APÉNDICE

APÉNDICE

Problemas propuestos

ENUNCIADO DE PROBLEMAS RESUELTOS

1. Desarrollar una solución que permita mostrar un mensaje por la pantalla. El mensaje a mostrar será “Hola bienvenidos mi nombre es Danae”. 2. 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, nota2=13 y nota3=15. Utilizar la siguiente fórmula: Promedio: nf = (nota1 + nota2 + nota3) / 3. 3. Desarrollar una solución que permita mostrar el resultado de sumar, multiplicar, restar y dividir los números 124 y 35. 4. Desarrollar una solución que permita ingresar el nombre de dos personas y luego mostrar los nombres junto con un mensaje de bienvenida. 5. Desarrollar una solución que permita leer el costo de un artículo y su precio de venta. Calcular y mostrar su utilidad. 6. 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%). 7. Desarrollar una solución que permita ingresar el precio de un artículo y su respectivo descuento (expresado en %). Mostrar el precio total a pagar incluyendo el IGV (Impuesto General a las Ventas = 19%).

Pag. 573

APÉNDICE

8. Desarrollar una solución que permita ingresar el lado de un cuadrado. Calcular y mostrar el área del cuadrado. 9. Desarrollar una solución que permita calcular y mostrar el área de un triángulo rectángulo. Ingresar la base y la altura del triángulo rectángulo. 10. Desarrollar una solución que permita calcular y mostrar el perímetro y el área de un círculo. Ingresar el radio del círculo. 11. Desarrollar una solución que permita calcular y visualizar el perímetro y el área de un rectángulo. Ingresar la base y la altura del rectángulo. 12. Desarrollar una solución que permita calcular el área de un triángulo en función de las longitudes de sus lados. Mostrar el resultado obtenido. ¾

Area = ((p*(p - a)*(p - b)*(p - c)) RAIZ 2.

¾

Semiperímetro p = (a +b + c) / 2.

13. Desarrollar una solución que permita convertir y mostrar una cantidad de dinero, expresado en dólares, en su equivalente en nuevos soles. Ingresar la cantidad en dólares y el tipo de cambio. 14. Desarrollar una solución que permita convertir y mostrar una cantidad de soles a Dólares y a Euros. Considerar como tipo de cambio; 1 Dólar = 3.352 soles, y 1 Dólar = 1.09 Euros. 15. Desarrollar una solución que permita leer un número y calcular el resto de dividir el número entre 3. Mostrar el resto de la división.

Pag. 574

APÉNDICE

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

Pag. 575

APÉNDICE

23. Desarrollar una solución que permita ingresar el sueldo de un obrero de la empresa “La Poderosa S.A.”. Calcular su respectivo descuento del 14% por concepto de impuestos y el 3% por concepto de cafetería. Mostrar el total de descuentos y el sueldo a cobrar. 24. Desarrollar una solución que permita ingresar una cantidad expresada en metros, y visualizar su equivalente en pulgadas y en pies (1 metro = 39.37 pulgadas, 1 pie = 12 pulgadas). 25. Desarrollar una solución que permita convertir una cantidad expresada en metros a sus equivalentes en centímetros, pulgadas, pies y yardas. Considerar la siguiente información: ¾

1 metro = 100 cm.

¾

1 pulgada = 2.54 cm.

¾

1 pie = 12 pulgadas.

¾

1 yarda = 3 pies.

26. Desarrollar una solución que permita calcular y visualizar la distancia que existe entre dos puntos dados. Cada uno de los puntos está expresado en coordenadas y éstos deben ser ingresados por el usuario: P1(x1, y1), P2(x2, y2). La distancia entre los dos puntos se calcula a partir de la siguiente fórmula: Distancia = ((x1-x2) **2 + (y1-y2) ** 2) RAIZ 2. 27. Desarrollar una solución que permita calcular el perímetro de un triángulo dadas las coordenadas de los puntos P1, P2 y P3, los cuales corresponden a los vértices de un triángulo.

Utilizar la fórmula del problema anterior para

determinar la distancia entre cada uno de los puntos. 28. Desarrollar una solución que permita ingresar 2 números enteros positivos de dos cifras. Intercambie las unidades de los dos números. 29. Desarrollar una solución que permita ingresar un número de 4 cifras. Determinar la suma de las cifras del número ingresado. Pag. 576

APÉNDICE

30. Desarrollar una solución que permita determinar si un número ingresado por teclado es capicúa o no. Un número es capicúa si se lee igual de derecha a izquierda o viceversa. (Ejemplo de número capicúa 4554). 31. Desarrollar una solución que permita invertir un número de cuatro dígitos. El número deberá ser ingresado por teclado. (Ejemplo: se ingresa el número 3579 se debe visualizar el 9753). 32. Desarrollar una solución que permita convertir una temperatura expresada en grados Celsius a su equivalente en grados Fahrenheit.

Utilizar

la

siguiente

fórmula: F = (9 / 5) * C + 32. 33. Desarrollar una solución que permita calcular y visualizar el número de segundos que hay en un determinado número de días. 34. Desarrollar una solución que permita ingresar una cantidad entera de dinero. Mostrar el número de billetes de S/ 100, S/ 50, S/ 20, S/ 10, S/ 5 y S/ 1, que existen en la cantidad de dinero ingresada.. 35. Desarrollar una solución que permita realizar el cálculo del pago mensual del sueldo de un empleado de una empresa. 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. Al sueldo básico se le aplica una bonificación del 35% obteniéndose el sueldo bruto. Al sueldo bruto se le aplica un descuento del 12% obteniéndose el sueldo neto. Mostrar el sueldo básico, el sueldo bruto y el sueldo neto de un trabajador. 36. Desarrollar una solución que permita calcula el sueldo neto de un vendedor. Dicho cálculo se realiza en base a un sueldo básico equivalente a S/ 465.00 nuevos soles, más una comisión del 18% por cada venta que el vendedor realice. Mostrar el sueldo neto del vendedor sabiendo que hizo 5 ventas en el mes. Pag. 577

APÉNDICE

37. Desarrollar una solución que permita calcular el porcentaje de hombres y el porcentaje de mujeres que están matriculados en un determinado curso. 38. Desarrollar una solución que permita leer la capacidad de un disco duro en Gigabytes. Mostrar el equivalente en Megabytes, Kilobytes y Bytes. ¾

1 Kilobyte= 1024 Bytes.

¾

1 Megabyte= 1024 Kilobytes.

¾

1 Gigabyte= 1024 Megabytes.

39. Desarrollar una solución que permita determinar con qué velocidad inicial partió un automóvil de un determinado punto y qué distancia, conociendo su velocidad final, su aceleración y el tiempo empleado en el recorrido. Considerar las siguientes fórmulas: 2

e = Vot + at

Vf = Vo + at.

donde: Vf = Velocidad final. Vo = Velocidad Inicial. a = Aceleración. e = Espacio recorrido. t = Tiempo empleado en el recorrido.

40. Desarrollar una solución que permita determinar si una persona es o no mayor de edad. Ingresar el nombre, apellidos, código y edad de la persona. 41. Desarrollar una solución que permita calcular y mostrar el área de un cuadrado. Si el área del cuadrado resulta menor que 768, se deberá visualizar el mensaje “Cuadrado pequeño”. 42. Desarrollar una solución que permita determinar cómo se clasifica un ángulo ingresado por teclado. Los ángulos se clasifican de la siguiente manera: ¾

Ángulo = 0

Nulo.

¾

0 < ángulo > 90

Agudo.

Pag. 578

APÉNDICE

¾

Ángulo = 90

Recto.

¾

90 < ángulo > 180

Obtuso.

¾

Ángulo = 180

Llano.

¾

180 < ángulo > 360

Cóncavo.

¾

Ángulo = 360

Completo.

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

Pag. 579

APÉNDICE

48. Desarrollar una solución que permita calcular y mostrar la nota final de un alumno. Si la nota final (nf) es menor a 13 se deberá mostrar el mensaje “Alumno desaprobado”, caso contrario se mostrará el mensaje “Alumno aprobado”. Fórmula: nf = (n1+n2+n3) / 3. 49. Desarrollar una solución que permita ingresar tres notas de un determinado alumno. Mostrar las notas ordenadas en forma ascendente (de menor a mayor). 50. Desarrollar una solución que permita que permita calcular el monto a pagar por la compra de un producto, considerando un descuento del 27% por la compra de 150 unidades. 51. Desarrollar una solución que permita calcular y mostrar el monto total a pagar por la compra de varios artículos. Considerar que deberá agregar el IGV respectivo. Si el monto total a pagar incluido IGV es mayor a S/. 1800.00 nuevos soles se aplica un descuento del 12%, caso contrario el descuento será del 3%. 52. Desarrollar una solución que permita determinar que proveedor es más conveniente para una empresa. La empresa desea adquirir cierta cantidad de unidades de un producto para lo cual cuenta con una oferta de dos proveedores, 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.

¾

Proveedor B: Costo unitario igual a $27.5 y 10% de descuento para mas de 35 unidades adquiridas.

53. Desarrollar una solución que permita determinar si un número es divisor de otro número. Utilizar la expresión (num1 RESTO num2 > 0) donde “num1” y “num2” son los números.

Pag. 580

APÉNDICE

54. Desarrollar una solución que permita ingresar un número entero. Mostrar si el número ingresado es un número par o un número impar. 55. Desarrollar una solución que permita ingresar un número entero. Mostrar si el número ingresado es un número negativo, un número par o un número múltiplo de 7. 56. Desarrollar una solución que permita ingresar un número entero. Indicar lo siguiente en base al número ingresado: ¾

Si el número es positivo o negativo.

¾

Si el número es par o impar.

¾

Si el número es múltiplo de 3 o no.

¾

Si el número es Menor que 500 o no.

57. Desarrollar una solución que permita determinar si un numero (num) es par, impar o nulo. Utilizar lo siguiente: -1 elevado a la potencia del número ingresado (-1 ** num). Mostrar un mensaje si el número es par, impar o nulo. 58. Desarrollar una solución que permita ingresar un número entre 1 y 12. Mostrar el nombre del mes del año correspondiente. (Enero, Febrero,...etc). 59. Desarrollar un programa que permita ingresar un número entre 1 y 7. Mostrar el nombre del día de la semana correspondiente. (Lunes, martes…etc). 60. Desarrollar una solución que permita ingresar la categoría y el sueldo de un trabajador. Calcular el aumento correspondiente teniendo en cuenta la siguiente tabla. Mostrar el nuevo sueldo del trabajador. Categoría

Aumento

1

35 %

2

25 %

3

15 %

Pag. 581

APÉNDICE

4

5%

61. Desarrollar una solución que permita calcular y mostrar el monto total a pagar por un sándwich, sabiendo que, adicionalmente, hay que pagar el 6% por el servicio y 7% por propinas. Considerar que se venden 4 tipos de sándwich, de acuerdo a la siguiente tabla. Tipo

Costo

Moderado

S/. 2.00

Mediano

S/. 3.00

Extra Grande

S/. 4.00

Full

S/. 6.00

62. 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, según los datos de la tabla. Adicionalmente, debe considerar que los pacientes menores de 18 años implican un costo adicional de 25 %. Enfermedad Tipo

Costo diario

1

120

2

380

3

620

63. 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, según los datos de la tabla. Adicionalmente, 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

Costo diario

1

180

2

420

Pag. 582

APÉNDICE

3

513

64. 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. Considerar la siguiente tabla: Edad

Categoría

18 -más

Contenido para adultos.

11 -17

Mayores de 14.

0 –10

Apta para todos.

65. 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, según los datos de la tabla. Adicionalmente, debe considerar que los pacientes de sexo femenino menores de 14 años implican un costo adicional de 8%. Enfermedad Tipo

Costo diario

1

122

2

234

3

345

4

587

66. Desarrollar una solución que permita ingresar las notas obtenidas por un alumno del curso de Matemática Básica III. Calcular su nota final (nf), de acuerdo a la fórmula empleada por su profesor, según los datos de la tabla. Mostrar la nota final (nf) del alumno y si está aprobado o no, considerando que la nota mínima aprobatoria es 12 (doce). Código Profesor

Fórmula

1

nf = (n1 + n2 ) / 2

2

nf = (n1 + n2*2) / 3

3

nf = (n1*2 + n2) / 3

Pag. 583

APÉNDICE

67. Desarrollar una solución que permita determinar la categoría de cada postulante. Considerar que la categorización de los postulantes se realiza en función de su sexo y edad, 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.

Si la persona es de sexo masculino: ¾

Categoría MA si tiene menos de 40 años.

¾

Categoría MB en caso contrario.

68. Desarrollar una solución que permita determinar la categoría de cada alumno. Considerar que la categorización de los alumnos se realiza en función de la nota en base a la siguiente tabla: Promedio

Categoría

18 – 20

Excelente

15 – 17

Bueno

11 – 14

Regular

00 – 10

Malo

69. Desarrollar una solución que permita ingresar las ‘n’ notas de un alumno. Calcular el promedio del alumno sabiendo que se elimina la nota mas baja. Finalmente, determinar la categoría obtenida por un alumno, considerando que la categoría del alumno está en función de su promedio, tal y como se muestra en la siguiente tabla: Promedio

Categoría

Desde 17 a 20

A

Desde 14 a 16

B

Desde 10 a 13

C

Desde cero a 9

D

Pag. 584

APÉNDICE

70. Desarrollar una solución que permita calcular el área de un rectángulo conociendo su base y altura. Si el área es menor que 100, 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”. 71. Desarrollar una solución que permita calcular el área de un rectángulo conociendo su base y altura. Si el área es menor que 100, se deberá visualizar el mensaje “rectángulo pequeño”; si el área es mayor o igual a 100 y menor que 1000, se visualizará el mensaje “rectángulo mediano”; y si el área es mayor o igual que 1000, el mensaje será “rectángulo grande”. 72. Desarrollar una solución que permita ingresar el nombre del alumno, el tipo de participante (profesor, alumno, externo) y el nivel del curso (básico, intermedio, avanzado). En la tabla que se muestra a continuación se detallan los costos de los cursos: Básico

Intermedio

Avanzado

Profesor

35

40

45

Alumno

40

50

60

Externo

60

80

100

Mostrar los datos del recibo, tal y como se muestra en el siguiente ejemplo: ********************* RECIBO ****************** Alumno : Juan Pérez Costo

: (de acuerdo a la tabla)

Nivel

: (de acuerdo al ingresado)

*************************************************** 73. Desarrollar una solución que permita ingresar el sueldo de un trabajador. Calcular y mostrar su aumento por incremento del costo de vida de acuerdo a la siguiente tabla: Pag. 585

APÉNDICE

Condición

Aumento

Sueldo < 2000

23 %

2000 < =Sueldo < =3000

17 %

Sueldo > 3000

12 %

74. 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)

Tipo de Clima

TP<=9

Frió

9
Nublado

17
Caluroso

TP>27

Trópico

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

Pag. 586

APÉNDICE

80. Desarrollar una solución que permita ingresar tres números enteros. Mostrar el número mayor. 81. Desarrollar una solución que permita mostrar la tabla de multiplicar de un número cualquiera ingresado por teclado. 82. Desarrollar una solución que permita determinar cuáles son los términos de una progresión aritmética. Solicitar el valor del primer término, el valor de la razón y el número de términos. 83. Desarrollar una solución que permita determinar cuales son los términos de una progresión aritmética y la suma de los mismos. Solicitar el valor del primer término, el valor de la razón y el número de términos. 84. Desarrollar una solución que permita determinar cuales son los términos de una progresión geométrica y la suma de los mismos. Solicitar el valor del primer término, el valor de la razón y el número de términos. 85. Desarrollar una solución que permita determinar y mostrar la suma de los términos de la siguiente serie: 2

2

2

2

1 + 1/3 + 1/5 + 1/7 + 1/9 +... 86. Desarrollar una solución que permita determinar los 3 primeros números perfectos. 87. Desarrollar una solución que permita determinar la suma de todos los números cuadrados perfectos existentes entre los 1000 primeros números. 88. Desarrollar una solución que permita calcular la cantidad de dígitos, la suma de dígitos y la cantidad de dígitos pares e impares de un número entero.

Pag. 587

APÉNDICE

89. Desarrollar una solución que permita calcular y mostrar el producto de los números pares comprendidos entre los números 20 y 400. 90. 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). 91. Desarrollar

una

solución

que

permita

ingresar

50

números

enteros

cualesquiera. Determinar cuántos números son negativos, ceros y positivos. 92. Desarrollar una solución que permita ingresar 100 números. Calcular y mostrar la suma de los números pares, la suma de los números impares y la media de todos los número ingresados. 93. Desarrollar una solución que permita ingresar un número entero. Determinar y mostrar si el número ingresado es un número primo o no. 94. 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. 95. Desarrollar una solución que permita ingresar 10 números. Determinar y mostrar la suma de todos los números pares y la suma de todos los números primos. 96. Desarrollar un programa que genere cada uno de los siguientes gráficos:

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

97. Desarrollar un programa que genere cada uno de los siguientes gráficos:

Pag. 588

*

APÉNDICE

*

-

*

-

*

-

*

-

*

-

*

-

*

-

*

-

*

-

*

*

-

*

*

*

* *

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

* *

*

*

*

*

*

*

*

*

98. Desarrollar un programa que genere el siguiente gráfico: 1 2 4 7 2

3 5

8 3

7

6 9

4 8

2

1 5

9 3

5

6 1

4 6

7

99. Desarrollar un programa que permita leer una cadena. Mostrar la cadena ingresada en forma triangular. Tal y como se muestra a continuación: Ejemplo; Se ingresa la cadena “Danae”. D DA DAN DANA DANAE 100. Desarrollar un programa que permita leer una cadena. Mostrar la cadena ingresada en forma triangular. Tal y como se muestra a continuación: Ejemplo; Se ingresa la cadena “Danae”. DANAE DANA DAN Pag. 589

APÉNDICE

DA D 101. Desarrollar una solución que permita invertir un número cualquiera. El número deberá ser ingresado por teclado. 102. Desarrollar una solución que permita ingresar un texto y permita determinar lo siguiente: ¾

La cantidad de vocales.

¾

La cantidad de consonantes.

¾

La cantidad de espacios en blanco.

¾

La cantidad de símbolos.

103. Desarrollar una solución que permita calcular y mostrar la nota final de 10 alumno. Utilizar la siguiente fórmula: nf = (n1+n2+n3+(n4*2))/5. Ingresar las notas a través del teclado. 104. Desarrollar una solución que permita ingresar las edades de 10 alumnos. Calcular y mostrar lo siguiente: ¾

Suma de todas la edades.

¾

Promedio de edades.

¾

Promedio de edades pares.

¾

Edad máxima.

¾

Edad mínima.

105. 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. Ingresar las notas a través del teclado. Se deberá utilizar la estructura lógica MIENTRAS. 106. 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.

Pag. 590

APÉNDICE

Ingrese las notas a través del teclado. Se deberá utilizar la estructura lógica HACER. 107. Desarrollar una solución para el siguiente problema. En un salón de clase se ha realizado un examen con tres pruebas distintas. Se desea conocer el promedio obtenido en cada una de las pruebas realizadas. 108. Desarrollar una solución para el siguiente problema. Se tiene una relación de 100 obreros y su sueldo. Determinar cuántos ganan menos de S/. 800.00, entre S/. 800.00 y S/. 3,000.00 (Incluidos S/. 800.00 y S/. 3,000.00), y cuántos más de S/.3,000.00. 109. Desarrollar una solución que permita determinar la suma de sueldos de los obreros (categoría C), 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. Adicionalmente, determinar cuál es el mayor y el menor sueldo en la empresa. 110. Desarrollar una solución para el siguiente problema. Se desea hacer una estadística de las estaturas de los 1000 alumnos de un colegio, de acuerdo a lo siguiente: ¾

Alturas hasta 1,60 metros.

¾

Alturas entre 1,60 metros y 1,70 metros.

¾

Alturas entre 1,70 metros y 1,80 metros.

¾

Alturas mayores de 1,80 metros.

111. Calcular y mostrar el número de alumnos que tienen promedio final menos de 11; los que tiene promedio final entre 11 y 14; aquellos que tienen promedio final entre 15 y 17; y los que tienen promedio final mayor de 17. Ingresar 4 notas y calcular el promedio del alumno en base a la siguiente fórmula: nf = (n1 + n2 + n3 + (n4 * 2)) / 5.

Pag. 591

APÉNDICE

112. Calcular la nota media de los alumnos de una clase considerando “n” alumnos y “c” notas. 113. Un canillita vende 4 tipos de loterías según se muestra en el siguiente cuadro. Calcular el total de loterías vendidas de cada tipo. Tipo lotería

Costo

1

2

2

4

3

6

4

8

114. 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. Se determina que los gerentes contribuirán con S/ 35.00 soles, los profesionales con S/ 25.00 soles y el resto de empleados de acuerdo a sus posibilidades. Determinar el total recaudado. 115. 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, incluido IGV, es mayor a S/. 3,000.00 nuevos soles se aplicará un descuento del 12%. 116. Desarrollar una solución que permita desarrollar el siguiente menú con las opciones solicitadas. ¾

[1] Ingreso de datos (base y altura de un rectángulo).

¾

[2] Proceso (determinar área y perímetro del rectángulo).

¾

[3] Resultado (Mostrar el valor de área y perímetro obtenidos).

¾

[4] Terminar.

117. Desarrollar una solución para el siguiente problema. Los empleados de una fábrica trabajan en tres turnos; mañana, tarde y noche. Se desea calcular el jornal diario de cada empleado teniendo en cuenta lo siguiente: Pag. 592

APÉNDICE

¾

La tarifa del turno mañana y tarde es de S/ 8.00 soles por hora.

¾

La tarifa del turno noche es de S/ 10.00 soles por hora.

¾

En caso de ser un día domingo, 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.00 soles por concepto de movilidad.

118. Desarrollar una solución que permita controlar la venta de boletos en un determinado día en un teatro de la capital, en base a la siguiente información: ¾

Al comenzar, se leerá una sola vez el precio de entrada para palco, platea y mezanine.

¾

Por cada entrada vendida se leerá los siguientes datos: número de boleto y lugar (puede ser platea, palco o mezanine).

¾

El programa terminará cuando el número de boleto sea igual a cero.

¾

Antes de finalizar, se deberá proporcionar la siguiente información: ¾

Número total de entradas vendidas durante el día.

¾

El total de soles recaudados en el día.

¾

Número de entradas vendidas para platea, palco y mezanine en el día.

119. 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. 593

APÉNDICE

120. Desarrollar una solución que permita ingresar los nombres y las edades de ‘n’ alumnos. Determinar la suma de las edades, el nombre del alumno con la mayor nota y el nombre del alumno con la menor nota. 121. Desarrollar una solución que permita determinar la nota final obtenida por cada uno de los alumnos del curso de Álgebra del colegio “La Excelencia” (considere 3 notas). Adicionalmente, deberá indicar el porcentaje de alumnos aprobados, desaprobados, la nota final más baja y más alta. Ingresar la cantidad de alumnos y las 3 notas de cada alumno. 122. 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). Adicionalmente, deberá indicar el promedio del costo de todos los artículos, el articulo más caro y el más barato. Ingresar el nombre, el precio de venta y la utilidad de cada artículo. 123. Desarrollar una solución para el siguiente problema. En la fabrica “LA CLONACION S.A.”. Trabajan miles de obreros y se desea determinar cuantos tienen un salario menor a S/. 500.00, entre S/. 500.00 y S/. 2,200.00 (incluidos S/. 500.00 y S/. 2,200.00), y cuantos tienen un salario mayor a S/. 2,200.00. 124. 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, según los datos de la tabla. Adicionalmente, deberá considerar que los pacientes menores de 18 años implican un costo adicional de 35% y las mujeres un costo adicional de 12%. Enfermedad Tipo

Costo diario

1

100

2

150

3

300

Pag. 594

APÉNDICE

4

450

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

Pag. 595

APÉNDICE

130. Desarrollar una solución que permita mostrar un menú con las siguientes opciones: ¾

Determinar si un número es par o impar.

¾

Determinar si un número es primo o no.

¾

Salida.

131. Desarrollar una solución que permita mostrar un menú con las siguientes opciones: ¾

Suma, resta y multiplicación de dos números.

¾

Determinar el número inverso de un número.

¾

Determinar el área y perímetro de un círculo.

¾

Salida.

132. Desarrollar una solución que permita ingresar las edades de 10 alumnos. Determinar lo siguiente: ¾

La suma de todas las edades.

¾

La cantidad de edades impares.

¾

El promedio de edades.

¾

El promedio de edades pares.

¾

La edad mayor.

¾

La edad menor.

¾

El nombre de la alumna que tiene la mayor edad.

133. Desarrollar una solución que permita ingresar los nombres y sueldos de 5 empleados. Determinar lo siguiente: ¾

Sueldo promedio.

¾

Menor sueldo.

¾

Nombre del empleado con mayor sueldo.

¾

Cantidad de nombre que comiencen entre “c y p”.

134. Desarrollar una solución que permita ingresar los valores de una matriz de 4*4. Calcular la suma de la diagonal y la suma de la diagonal inversa.

Pag. 596

APÉNDICE

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

Pag. 597

APÉNDICE

143. Desarrollar una solución que permita leer 4 números de 3 cifras. Mostrar su categoría. Si el número está entre 100 y 300 pertenece a la categoría A. Si el número está entre 301 y 600 pertenece a la categoría B, y si el número está entre 601 y 999 pertenece a la categoría C. Utilizar un vector y validar que el número ingresado sea de 3 cifras. 144. Desarrollar una solución que permita leer los datos de ‘n’ alumnos. Los datos de los alumnos son; nombre, fecha de nacimiento (dd/mm/aaaa) y nota. Se solicita: ¾

Ingresar los datos haciendo las validaciones a la fecha (tamaño de fecha y que contenga los símbolos “/”) y nota.

¾

Calcular y mostrar la edad de cada alumno .

¾

Hallar:

¾

¾

Hallar la nota promedio de todos los alumnos ingresados.

¾

Nombre del alumno con mayor nota.

¾

Cantidad de alumnos cuyo nombre comience entre a y p.

Crear un menú de opciones para acceder al programa.

145. Desarrollar una solución que permita leer los datos de 5 empleados. Los datos de los empleados son; nombre, 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.

¾

Calcular los años de servicio (que tiene trabajando).

¾

Hallar:

¾

¾

Hallar el sueldo promedio.

¾

Nombre del empleado con menos años de servicio.

¾

Cantidad de empleado que ingresaron entre 1980 y 2004.


146. Desarrollar una solución que permita leer los datos de 5 alumnos. Los datos de los alumnos son; nombre, tipo (Ingresantes, Regular o Egresado) y nota. Pag. 598

APÉNDICE

Se solicita: ¾

Ingresar los datos haciendo las validaciones al tipo y nota.

¾

Por cada alumno mostrar la categoría:

¾

¾

¾

¾

Si es ingresante y tiene entre 17-20 categoría IA.

¾

Si es ingresante y tiene entre 12-16 categoría IB.

¾

Si es regular y tiene entre 17-20 categoría RA.

¾

Si es egresado y tiene entre 17-20 categoría EA.

Por cada alumno mostrar: ¾

Nombre en Mayúscula.

¾

Los 3 primeros caracteres del nombre.

Cálculos: ¾

Hallar el promedio de los ingresantes y regulares.

¾

Nombre del alumno con mayor nota.

¾

Mayor nota de los ingresantes y de los Egresados.

Crear una opción para continuar ejecutando el programa.

147. Desarrollar una solución que permita leer los datos de ‘n’ alumnos. Los datos de los alumnos son; nombre, edad y sexo. Se solicita: ¾

Ingresar los datos validando que en el sexo y la edad.

¾

Por cada alumno mostrar:

¾

¾

¾

Nombre al revés.

¾

Ultimo carácter.

¾

Las 3 ultima letras.

Cálculos: ¾

Hallar la edad promedio.

¾

Nombre de la persona con mayor edad.

¾

Nombre de mujer con menos edad.

Crear un menú para acceder al programa.

148. Desarrollar una solución que permita leer los datos de ‘n’ alumnos. Los datos de los alumnos son; nombre, fecha de nacimiento (dd/mm/aaaa) y nota. Pag. 599

APÉNDICE

Se solicita: ¾

Ingresar los datos validando la fecha de nacimiento y la nota.

¾

Mostrar por cada alumno la edad exacta (años y meses cumplidos a la fecha de hoy).

¾

¾

Cálculos: ¾


¾

Nombre y la edad de la persona con mayor nota.

¾

Nombre de mujer con menos edad.


149. Desarrollar una solución que permita leer los datos de ‘n’ empleados. Los datos de los empleados son; nombre, AFP (Integra, Unión y ProFuturo), sueldo Básico y fecha de ingreso (dd-mm-aaaa). Se solicita: ¾

Ingresar los datos validando AFP, sueldo y fecha de ingreso.

¾

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.

¾

Si tiene menos de 4 años se le descuenta 10% más el descuento de la AFP.

¾

El descuento de la AFP se ve en la siguiente tabla: AFP

¾

Descuento

Integra

12%

Unión

13%

ProFuturo

14%

Cálculos: ¾

Mostrar el nombre y el AFP de la persona con mayor sueldo.

¾

Mostrar el nombre de la persona más nueva es decir con menos años de ingreso.

¾

Crear un menú de opciones para acceder al programa. Pag. 600

APÉNDICE

150. Desarrollar una solución que permita leer los datos de ‘n’ alumnos. Los datos de los alumnos son; sexo (M/F), edad y nombre. Se solicita: ¾

Ingresar los datos validando que en el sexo solo se ingrese ‘M’ o ‘F’, y la edad sea un número positivo.

¾

¾

¾

Mostrar lo siguiente por cada alumno: ¾

Si es mayor o menor de edad.

¾

Cantidad de vocales del nombre.

Cálculos: ¾


¾

Nombre de la persona con mayor edad.

¾

Nombre de hombre con menos edad.


Pag. 601

APÉNDICE

Pag. 602

APÉNDICE

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

Pag. 603

APÉNDICE

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

Pag. 604

APÉNDICE

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

Par poner en práctica esto podemos recurrir a 2

métodos:

NumberFormat formato ; DecimalFormat df ;

Pag. 605

APÉNDICE

Si queremos dar formato a números: formato = NumberFormat.getNumberInstance(currentLocale); Si queremos dar formato a monedas: formato = NumberFormat.getCurrencyInstance(currentLocale); Luego aplicamos las características locales almacenadas en formato a df: DecimalFormat df = (DecimalFormat)nf; Esta clase permite controlar los ceros iniciales y finales, los sufijos y prefijos, separadores (millares), y el separador decimal. Si se quiere cambiar un símbolo del formateo como el separador decimal, se puede utilizar DecimalFormatSymbols en conjunción con la clase DecimalFormat

Símbolos usados para formato Símbolo Significado 0

Digito

#

Digito, el cero se muestra como ausente

.

Separador decimal

-

Signo menos

,

Separador de agrupación

E

Para notación científica "0.###E0" muestra 1234 como "1.234E3"

;

Para separar formatos positivos y negativos

%

Multiplica por 100 y lo muestra como porcentaje

\u2030

Multiplica por 1000 y muestra como millares

¤ (\u00A4) Utilizado para mostrar símbolos monetarios '

Usado para mostrar caracteres especiales

Ejemplo:

Pag. 606

APÉNDICE

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

Pag. 607

APÉNDICE

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

Pag. 608

APÉNDICE

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

Pag. 609

APÉNDICE

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

Sumario de campos static int

AM Constante que representa el campo AM

static int

AM_PM Constante que representa el campo AM_PM

static int

DATE Constante que representa la fecha del calendario actual (día)

static int

DAY_OF_MONTH Constante que representa el campo Día del mes

static int

DAY_OF_WEEK Constante que representa el campo Día de la semana

static int

DAY_OF_WEEK_IN_MONTH Constante que representa el campo Día del mes

static int

DAY_OF_YEAR Constante que representa el campo Día del año

static int

ERA Constante que representa el campo AC/DC

static int

FIELD_COUNT Indica el número de campos que pueden ser usados por la instrucción get o set

static int

HOUR Constante que representa el campo hora Pag. 610

APÉNDICE

static int

HOUR_OF_DAY Constante que representa el campo Hora del día

static int

JANUARY , FEBRUARY, MARCH , etc… Constantes que representan a los meses que corresponden del año.

static int

MILLISECOND Constante que representa el campo que indica los milisegundos de la hora actual

static int

MINUTE Constante que representa el campo que indica los minutos de la hora actual.

static int

MONDAY, TUESDAY, WEDNESDAY, etc… Constantes que representan a los días que corresponden de la semana.

static int

MONTH Constante que representa el campo que indica el mes actual

static int

PM

static int

SECOND Constante que representa el campo Indica o establece los segundo de la hora actual

static int

UNDECIMBER indica el 13o mes del mes

static int

WEEK_OF_MONTH Constante que representa el campo Semana del mes

static int

WEEK_OF_YEAR Constante que representa el campo Semana del año

static int

YEAR Constante que representa el campo Año

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

add(int Campo, int Cantidad) Date Arithmetic function.

boolean

after(Object cuando) Compara los tiempos, si la fecha actual de nuestro calendario es superior a cuando, retorna verdadero

boolean

before(Object cuando) Compara los tiempos,, si la fecha actual de nuestro calendario es inferior a cuando, retorna verdadero

void

clear() limpia los valores de todos los campos del calendario

void

clear(int campo) Limpia el valor del campo indicado

boolean

equals(Object objeto) Compara este calendario con el objeto dado, y si son iguales retorna verdadero.

int

get(int campo) Obtiene el valor almacenado en el campo dado.

int

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

int

getActualMinimum(int campo) Retorna el valor mínimo que puede obtener este campo con la fecha del calendario actual.

int

getFirstDayOfWeek() Obtiene el primer día de la semana. Por ejemplo SUNDAY (0)

static Calendar

getInstance() Obtiene un calendario utilizando la zona actual y las reglas dadas

static Calendar

getInstance(TimeZone zona) Obtiene un calendario utilizando zona y las reglas dadas

Date

getTime() Obtiene la hora actual del calendario.

long

getTimeInMillis() Obtiene la hora actual del calendario en milisegundos

TimeZone

getTimeZone() Obtiene la zona horaria.

boolean

isSet(int campo) Pag. 612

APÉNDICE

Determina si el campo dado tiene un valor almacenado. abstract void

roll(int field, boolean up) Time Field Rolling function.

void

roll(int field, int amount) set(int field, int value)

void

setFirstDayOfWeek(int value) Establece cual es primer día de la semana para el calendario actual. Ej MONDAY

void

setTime(Date fecha) Establece la hora del calendario actual a fecha

void

setTimeInMillis(long milisegundos) Establece la hora del calendario actual utilizando los milisegundos dados

void

setTimeZone(TimeZone value) Sets the time zone with the given time zone value.

String

toString() Retorna una representación de cadena del calendario actual

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

Pag. 623

Pag. 624

BIBLIOGRAFÍA

Introducción a las Tecnologías de Información. 1ra Edición - 2004. FIA - USMP.

Jefferson López Goycochea.

Método para la Solución de Problemas Utilizando la Programación Orientada A Objetos - Aspectos básicos. 1ra Edición - 2003. FIA - USMP.

Juan José Flores Cueto .

Metodología de la Programación. Algoritmos, Diagrama de flujo y programas 2da Edición - 2003.

Osvaldo Cairó Battistutti.

Java, Manual de referencia.

Patrick Naughton / Herbert Schildt.

UML Gota a Gota. 1999.

Martín Fowler / Kendall Scott.

Como Programar en Java. 1998.

Deitel y Deitel.

Pag. 625

Pag. 626

NOTAS FINALES

Cualquier observación, sugerencia o recomendación relacionada al contenido del presente texto podrá realizarla, enviándome un correo electrónico a la siguiente dirección: [email protected] De antemano, agradezco cualquier contribución que permita mejorar el material y contenido del presente libro.

Pag. 627

Pag. 628

Método de las 6D. UML - PSEUDOCODIGO -JAVA. Enfoque algortimico

Recommend Documents