Método 6'D UML pseudocódigo Java

MTODO DE LAS 6D UML Pseudocdigo Java
(Enfoque algortmico)
UNIVERSIDAD DE S AN M ARTIN DE PORRES Facultad de Ingeniera y Arquitectura
MTODO DE LAS 6D UML Pseudocdigo - Java

(Enfoque algortmico)
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 participacin 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 colaboracin 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 Prez Huaman. Ricky Vilcachagua Mosquera. Shugeily Prez 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 tambin 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 disear la cartula. Finalmente, mi sincero agradecimiento a las autoridades de la Facultad de Ingeniera y Arquitectura (FIA) de la Universidad de San Martn de Porres (USMP), en especial al Ing. Ral Bao Garca, Decano de la FIA, por todo el apoyo brindado durante el desarrollo del presente libro.
NDICE PRESENTACIN. INDICE. PROLOGO. PREFACIO. CAPTULO I: Mtodo de las 6D. Un enfoque algortmico. Introduccin ........................................................................................................ Mtodo de las 6D ............................................................................................... Etapas y pasos ...................................................................................... Resumen del mtodo ............................................................................. Resultado de las etapas del mtodo ...................................................... Marco de trabajo ................................................................................................. Modelamiento ..................................................................................................... Algoritmo ............................................................................................................. Programacin ..................................................................................................... CAPTULO II: Estructuras fundamentales para la solucin de problemas. Introduccin ........................................................................................................ 61 Estructuras de datos. Variables ................................................................................................ 63 Tipos de datos ....................................................................................... 66 Conversin de datos .. 71 Estructuras lgicas. Estructuras lgicas de secuencia. Estructuras para la salida de informacin ESCRIBIR .................. 75 Estructuras para la entrada de datos LEER ................................. 76 Estructuras para operaciones aritmticas y de clculo ................ 78 Estructuras lgicas de decisin. Estructuras lgicas de decisin simple SI .................................... 80 Estructuras lgicas de decisin doble SI / SINO .......................... 82 Estructuras lgicas de decisin simple CUANDO ........................ 84 Estructuras lgicas de repeticin. Estructuras lgica de repeticin DESDE ...................................... 87 Estructuras lgica de repeticin MIENTRAS ................................ 90 Estructuras lgica de repeticin HACER ...................................... 93 Instrucciones de bifurcacin .................................................................. 97 Mapa de estructuras lgicas detallado .................................................. 98 Mtodo de las 6D. Etapas y pasos ....................................................... 99 Problemas resueltos en general del 01 al 27 ........................................ 101 Manejo de excepciones 195 Problemas resueltos del 28 al 31 ..... 198 25 27 28 35 36 37 39 45 54
Desarrollo de capacidades lgicas ..................................................................... 207 Problemas resueltos sobre figuras del 32 al 60 ..................................... 209
CAPTULO III: Clases bsicas incorporadas en el lenguaje Java. Introduccin ........................................................................................................ El paquete del lenguaje Java: java.lang ............................................................. Envoltorios de tipos de datos primitivos: wrappers. Introduccin ........................................................................................... Mtodos ................................................................................................. Problemas resueltos del 61 al 64 ........................................................... Funciones matemticas: Clase Math. Introduccin ........................................................................................... Mtodos ................................................................................................. Problemas resueltos del 65 al 99 ........................................................... Manejo de cadenas: Clase String. Introduccin ........................................................................................... Mtodos ................................................................................................. 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
CAPTULO IV: Estructuras de datos arreglos. Introduccin ........................................................................................................ Estructuras de datos: Arreglos. Definicin ............................................................................................... Tipos ...................................................................................................... Ventajas y desventajas .......................................................................... Representacin grfica .......................................................................... Declaracin, creacin e inicializacin de arreglos .............................. Ingreso de datos a un arreglo ................................................................ Manejo de datos de un arreglo .............................................................. Desarrollo de soluciones bsicas utilizando arreglos. Introduccin ........................................................................................... Formalizacin de la solucin utilizando el mtodo de las 6D ................ Problemas resueltos del 132 al 145 ....................................................... Desarrollo de soluciones utilizando mltiples arreglos. Arreglos paralelos .................................................................................. Problemas resueltos del 146 al 150 ....................................................... 401 403 403 404 406 408 412 414 416 425 425 493 495
CAPTULO V: Introduccin al Desarrollo de Soluciones Orientadas a Objetos. Introduccin ........................................................................................................ Conceptos bsicos. Clase ............................................................................................... Objeto ............................................................................................. Atributo ......................................................................... Mtodo .......................................................................... Mtodos que no devuelven valor y no reciben parmetros ...... Mtodos que devuelven valor y no reciben parmetros ........ Mtodos que no devuelven valor y reciben parmetros .... Mtodo constructor ... Ocultar atributos de instancia Ingreso de datos a travs del teclado .. Mtodo de las 6D. Etapas y pasos ...................................................... Problema resuelto 151 ........................................................................... Otros conceptos 527 532 534 535 542 544 547 550 554 556 559 561 563 569
APNDICE. Problemas propuestos ... 573 Clase Lectura ......................................................................................... 603 Otras clases Java. DecimalFormat, Calendar, GregorianCalendar, SimpleDateFormat ...................... 605 BIBLIOGRAFA ................................................................................................... 625
PRLOGO 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 informticos un mtodo para la solucin de problemas utilizando una computadora. Al reflexionar sobre la tarea que representa escribir un prlogo para este libro, he reparado en lo difcil que resulta agregar valor al ya presentado por su contenido, pues el texto que mi joven amigo pone hoy a disposicin de nuestros alumnos y tambin de profesionales de la especialidad de computacin y sistemas, es resultado de la conjuncin de varios factores: su experiencia acadmica, su desempeo profesional y la constante necesidad de estar actualizado. Escasamente un ao atrs la Facultad de Ingeniera y Arquitectura de la USMP public el primer libro de J. J. Flores Cueto: Mtodo para la solucin de Problemas utilizando la Programacin Orientada a Objetos y, una de las muchas razones del xito obtenido por esa obra es que desarrolla una metodologa para la solucin de la gran cantidad de ejercicios, problemas y aplicaciones que contiene. Este novedoso mtodo est conformado por seis etapas y cada una de ellas tiene una denominacin que comienza con la letra D, lo que hace que estos seis pasos se puedan recordar fcilmente. Se tuvo en cuenta primordialmente al usuario y por ello, acertadamente, el mtodo es llamado ahora mtodo de las 6 Ds; pero es importante comprender que su uso puede extenderse a otros temas y a problemas con soluciones ms complicadas y que para eso se tiene que redefinir algunos de los pasos de las etapas especificadas en el mtodo. Comprobamos as, que la pera prima de Juan Jos contena, pues, ya el embrin de la segunda y de aqu, entonces, como consecuencia, el ttulo del libro que hoy motiva estas lneas: Mtodo de las 6D: UML Pseudocdigo Java. (Un enfoque algortmico). Por qu la prisa en publicar esta segunda parte? Sabemos que lo ms caracterstico de la informtica es su permanente dinmica, reflejada en la aparicin de nuevos paradigmas que deben aplicarse rpidamente, pero cuya difusin en los textos no tiene la misma celeridad. El rpido avance de la ciencia y de la tecnologa, que para muchos es agobiante, resulta estimulante para un espritu como el de este prolfico docente de la USMP. El panorama de la ingeniera de computacin y sistemas evoluciona y cambia mientras trabajamos en ella; al momento de aparecer su primer libro, nuestro autor saba ya cules eran las nuevas tendencias que se perfilaban, acumulaba informacin y escriba sobre ellas, profundizando en el mtodo de las 6 Ds para presentarnos en tan corto plazo una nueva obra. El mercado exige que los profesionales de Computacin y Sistemas conozcan la ltimas tcnicas de programacin e ingeniera de software y este libro responde a esas demandas introduciendo al estudiante en los conceptos de programacin estructurada y en el dominio de la programacin orientada a objetos, poniendo nfasis en la solucin de problemas y empleando a fondo las capacidades lgicas para el desarrollo de soluciones utilizando una computadora. A mi juicio, las caractersticas ms importantes del texto se reflejan en su fcil lectura y en su orientacin al estudiante; pero mejor aun: en el hecho de haber sido probado
con los alumnos, comprobando su progreso y teniendo en cuenta la definicin del problema, una buena documentacin y la planificacin 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 programacin orientados a objetos. Tambin existen una serie de mtodos 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, anlisis del problema, diseo de la solucin, hasta la codificacin y prueba de la misma utilizando herramientas y lenguajes de programacin. En este libro se utiliza y se profundiza en el Mtodo de las 6D, a travs del cual se definen los pasos que se tienen que desarrollar para la solucin de un problema utilizando una computadora, agrupados en seis etapas (Descripcin del problema, Definicin de la solucin, Diseo de la solucin, Desarrollo de la solucin, Depuracin y pruebas, y Documentacin). Todos los nombres de las etapas del Mtodo de las 6D comienzan con la letra D (de ah el nombre de mtodo). Los conceptos y temas fundamentales, necesarios para el desarrollo de soluciones utilizando el Mtodo de las 6D y el desarrollo de sus capacidades lgicas, son tratados durante el desarrollo de los cinco captulos que forman parte del presente libro. Captulo I: Se desarrolla la parte terico formal del mtodo de las 6D. 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 mtodo. El mtodo de las 6D es interactivo e incremental y se puede utilizar la Ingeniera Reversa para actualizar los modelos a partir del cdigo creado. En este captulo, tambin se tratan los conceptos fundamentales sobre modelado y el lenguaje unificado de modelado UML, sobre Algoritmos y las herramientas de diseo conocidas como Diagrama de Flujo y Pseudocdigo, y sobre la programacin utilizando el lenguaje de programacin orientado a objetos Java. Captulo II: Se desarrolla la estructura de datos ms simple: la variable, y se complementa con el estudio de los tipos bsicos de datos, la conversin de datos y la forma cmo son utilizados por las herramientas tratadas en el captulo anterior.
En este captulo, tambin se tratan las estructuras lgicas de secuencia, las estructuras lgicas de decisin, las estructuras lgicas de repeticin, las instrucciones de bifurcacin y el manejo de excepciones. Las estructuras de datos, las estructuras lgicas y las instrucciones de bifurcacin son conceptos propios de la programacin estructurada y son utilizadas por la programacin orientada a objetos para la codificacin de los mtodos que forman parte de las clases. El manejo de excepciones es un concepto propio de la programacin orientada a objetos y ofrece una forma de codificar programas con una mayor claridad y sencillez, separando explcitamente el cdigo que maneja los errores del cdigo bsico de la aplicacin. Se presentan 31 problemas desarrollados utilizando el mtodo de las 6D, problemas que se van complicando conforme se tratan y explican los conceptos fundamentales. Tambin se presentan 30 problemas desarrollados sobre diferentes tipos de figuras geomtricas, con la finalidad de mejorar el desarrollo de sus capacidades lgicas. 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. Captulo III: Se desarrollan los conceptos fundamentales sobre las clases bsicas incorporadas en el paquete java.lang del lenguaje de programacin 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 mtodos para realizar diferentes tareas con los tipos de datos primitivos, tales como la conversin con cadenas de caracteres, comprobacin, traslacin, entre otras. Se presentan 5 problemas codificados en Java para mejorar la comprensin del tema. La clase Math, proporciona mtodos y atributos para implementar diversas funciones matemticas. La clase Math contiene mtodos de clculo bsico como exponencial, logaritmo, raz cuadrada y funciones trigonomtricas. Se presentan 35 problemas codificados en Java para mejorar la comprensin 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 mtodos 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 mayscula o minscula, entre otras. Se presentan 30 problemas codificados en Java para mejorar la comprensin del tema. Tambin se hace una referencia a otras clases en Java que el lector puede explorar. En el apndice se incluyen otras clases Java, tales como las clases DecimalFomat, Calendar, GregorianCalendar y SimpleDateFormat. Captulo IV: Se desarrolla la estructura de datos conocida como arreglos (arrays), su definicin, tipos, representacin grfica, declaracin, creacin y su inicializacin. En base al marco terico se desarrollan soluciones para el ingreso, visualizacin y clculo de datos contenido en los arreglos, formalizando el mtodo de las 6D para el adecuado manejo de los mismos. Se presentan 14 problemas desarrollados, utilizando el mtodo de las 6D para mejorar la comprensin del tema. Finalmente, se presentan los conceptos fundamentales sobre el manejo de arreglos mltiples (arreglos en paralelos) y se desarrollan 5 problemas utilizando el mtodo de las 6D. Captulo V: Se desarrolla una introduccin al desarrollo de soluciones orientadas a objetos. Se tratan los conceptos bsicos fundamentales sobre las clases, objetos, atributos, mtodos 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 programacin orientado a objetos. Al final de este captulo, se formaliza el mtodo de las 6D, redefiniendo algunos de sus pasos para poder ajustar el mtodo a este tipo de soluciones. Es importante comentar que el presente captulo, fue el primero en ser desarrollado. A pesar de ello, se consider no incluirlo en el presente texto, pero faltando unos das para la entrega oficial de todo el material que conformaba el presente libro fue incluido. Finalmente, considero una buena decisin que se incluyera el presente captulo. Estoy seguro que el lector estar de acuerdo conmigo.
Como se puede apreciar, se profundiza en el Mtodo de las 6D. Es importante comprender que se puede extender el uso del mtodo a otros temas y a problemas con soluciones mucho ms complicadas. Slo se tendr que redefinir algunos de los pasos de las etapas especificadas en el mtodo. Por otro lado, tambin se tratan conceptos de la programacin estructurada y fundamentos de programacin orientada a objetos, los cuales permiten sentar las bases modernas para la programacin, necesarias para el desarrollo de soluciones utilizando una computadora. Los temas desarrollados a travs de los 5 captulos 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 mtodo empleado en la solucin 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.
Captulo
MTODO DE LAS 6D Un Enfoque Algortmico
Temas: Introduccin. Mtodo de las 6D:

Etapas y pasos. Resumen del mtodo. Resultado de las etapas del mtodo.
Marco de trabajo. Modelamiento. Algoritmo. Programacin.
MTODO DE LAS 6D Un Enfoque Algortmico.
CAPTULO I MTODO DE LAS 6D Un Enfoque Algortmico INTRODUCCIN Durante el transcurso de nuestra vida nos enfrentamos a diversos problemas. Algunos de ellos podemos solucionarlos fcilmente, 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 solucin determinada y pueden ser desde muy sencillos hasta muy complejos. Para resolver problemas estructurados utilizando la computadora es importante utilizar un mtodo. Este mtodo debe ser fcil de comprender y nos debe guiar paso a paso hasta la solucin del problema. El mtodo propuesto y utilizado en el presente texto es el Mtodo de las 6D, 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 solucin. Con la finalidad de recordar el mtodo, se ha definido que el nombre de cada una de las etapas del mtodo comience con la misma letra, la letra D. Es decir, el mtodo 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 Mtodo de las 6D.
Pag. 25
Pag. 26
MTODO DE LAS 6D En la siguiente figura se muestra el Mtodo de las 6D con sus respectivas etapas:
Etapa 01
Descripcin Problema
Etapa 02
Definicin Solucin
n veces
Etapa 03
Diseo Solucin
Ingeniera Reversa Etapa 04

Desarrollo Solucin
Etapa 05
Depuracin Pruebas
Etapa 06
Document.
Pag. 27
ETAPAS Y PASOS METODO 6D. Descripcin de la Etapa 01 Descripcin del Problema: Etapa 01 Descripcin 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 ms 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: Identificacin del problema. Descripcin 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 6D. Descripcin de la Etapa 02 Definicin de la Solucin: Etapa 02 Definicin de la Solucin

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 comprensin y posterior solucin. Esta es una regla que siempre deber ser aplicada se utilice o no una computadora en la solucin 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 sern procesados para transformarlos en informacin.
ESPECIFICACIONES
El resultado obtenido en esta etapa son las especificaciones de lo que se debe hacer para solucionar el problema.
Pag. 29
METODO 6D. Descripcin de la Etapa 03 Diseo de la Solucin: Etapa 03 Diseo de la Solucin

Definida la solucin, se procede a disear la lgica modelando y desarrollando algoritmos. Para el modelado de la solucin 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 Pseudocdigos o Diagramas de Flujo (DF), los cuales son herramientas utilizadas para disear los algoritmos de los diferentes mtodos 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. Definicin 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 cmo se debe hacer para solucionar el problema.
Pag. 30
METODO 6D. Descripcin de la Etapa 04 Desarrollo de la Solucin: Etapa 04 Desarrollo de la Solucin

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 codificacin del problema en algn lenguaje de programacin. La codificacin involucra traducir los diagramas, las especificaciones de las clases (expresadas en notacin UML), y los pasos del algoritmo de cada mtodo (expresado en DF o pseudocdigo), en sentencias de un lenguaje de programacin determinado. Estas sentencias son almacenadas en un proyecto (o archivo) lgico, 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 programacin, que permiten solucionar el problema.
Pag. 31
METODO 6D. Descripcin de la Etapa 05 Depuracin y Pruebas: Etapa 05 Depuracin y Pruebas

Luego que se codifiquen los programas y/o clases, deben ser probados mediante la ejecucin de los mismos (esto es conocido como corrida del programa). Al realizarse sta, pueden surgir diferentes tipos de errores, siendo los errores de lgica y sintaxis los ms comunes. Hay que corregir el programa; anular, modificar o crear nuevas sentencias, volver a probar el programa y continuar con la correccin y pruebas hasta conseguir el resultado deseado. PASOS: Realizar la depuracin y verificar la correcta escritura de los programas. Realizar pruebas de sintaxis. Realizar pruebas de lgica.
PRUEBAS
El resultado obtenido en esta etapa son las pruebas que registran el adecuado funcionamiento de la solucin del problema.
Pag. 32
METODO 6D. Descripcin de la Etapa 06 Documentacin: Etapa 06 Documentacin

En esta etapa se recopila toda la documentacin generada en las etapas anteriores, la cual va a servir como base para la elaboracin del manual tcnico. Dedicarle tiempo a esta etapa nos ayudar a desarrollar buenos hbitos, los cuales sern necesarios cuando se desarrolle software en forma profesional. El manual tcnico debe incluir, como mnimo:
Descripcin del problema. Resultados esperados y datos necesarios para generar dichos resultados. Diagramas UML, DF y/o Pseudocdigo. 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 solucin desarrollada.
Pag. 33
METODO 6D.
Adicionalmente es posible realizar Ingeniera Reversa entre las Etapas 03, 04 y 05:
La ingeniera reversa nos permite crear o actualizar el modelo preliminar realizado en la ETAPA 03 Diseo de la solucin a partir del cdigo del programa realizado en la ETAPA 04 Desarrollo de la solucin y corregido en la ETAPA 05 Depuracin y pruebas. Es decir, a travs de la Ingeniera Reversa es posible programar o codificar algunas partes (hasta su correcto funcionamiento) que no estn especificadas en la Etapa 03 Diseo de la Solucin. A partir de esta solucin se actualizan los diagramas de la Etapa 03 y se contina con el proceso hasta llegar a la solucin deseada.
Ingeniera Reversa
n veces
Etapa 03
Diseo Solucin
Etapa 04
Desarrollo Solucin
Etapa 05
Depuracin Pruebas
PASOS:
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 ingeniera reversa. Organizar el modelo obtenido en la herramienta CASE.
DIAGRAMAS ACTUALIZADOS
Pag. 34
RESUMEN DEL MTODO
METODO 6D.
Resumen de las etapas y los pasos del mtodo:
Etapa 01 Etapa 03 Diseo Solucin Desarrollo Solucin Depuracin Pruebas
Etapa 02
Etapa 04
Etapa 05
Etapa 06 Document.
Descripcin Problema
Definicin Solucin
el
Identificacin del problema. Descripcin general del problema. Enunciado claro y preciso del problema. Definir un nombre para el proyecto. Definicin de diagramas, relaciones y clases. Desarrollo de Algoritmos. Codificar proyecto. Desarrollar comentarios internos en programas computadora. Desarrollar copias seguridad de programas computadora.
los de de los de
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 sern procesados para transformarlos en informacin.
Realizar la depuracin y verificar la correcta escritura de los programas. Realizar pruebas de sintaxis. Realizar pruebas de lgica.
Recopilar el material generado en cada una de las etapas anteriores. Generar el manual del programa. Generar el manual del usuario.
Pag. 35
RESULTADO DE LAS ETAPAS DEL MTODO
METODO 6D.
Resultado de las etapas del Mtodo:
Etapa 01 Etapa 03 Diseo Solucin Desarrollo Solucin Depuracin Pruebas
Etapa 02
Etapa 04
Etapa 05
Etapa 06 Document.
Descripcin Problema
Definicin Solucin
ENUNCIADO
ESPECIFICACIONES
DIAGRAMAS Y ALGORITMOS
PROGRAMAS
PRUEBAS
Manuales
Pag. 36
MARCO DE TRABAJO En el presente texto se solucionarn problemas sencillos utilizando el Mtodo de las 6D. La solucin de los problemas comenzar con el enunciado del problema y luego se desarrollar la etapa 02 (Definicin de la solucin), etapa 03 (Diseo de la solucin) y etapa 04 (Desarrollo de la solucin), es decir, solo se desarrollarn las tres etapas del mtodo que son posibles especificar en el presente texto. La etapa 05 (Depuracin y pruebas) se desarrolla directamente en un lenguaje de programacin y la etapa 06 (Documentacin) es la recopilacin del material y la elaboracin de los manuales respectivos.
Etapa 01 Descripcin Problema
ENUNCIADO Etapa 02 Definicin Solucin
MARCO DE TRABAJO
Etapa 03 Diseo Solucin
Etapa 04 Desarrollo Solucin
Pag. 37
Es importante precisar que en la primera parte del captulo II, en el captulo IV y en el captulo V del presente texto, se solucionan los problemas utilizando el marco de trabajo especificado, mientras que en la segunda parte del captulo II y el captulo III, solo se desarrolla la etapa 04 (Desarrollo de la solucin), con la finalidad de resolver una mayor cantidad de problemas y profundizar en la codificacin utilizando el lenguaje de programacin Java. Para poder solucionar problemas sencillos utilizando el Mtodo de las 6D, es necesario conocer los conceptos fundamentales de modelamiento, algoritmo y programacin, y dominar el uso de las estructuras lgicas, instrucciones o sentencias de bifurcacin y las estructuras de datos. Este tipo de soluciones son el objetivo del presente texto. Tambin es posible plantear soluciones ms complejas utilizando el Mtodo de las 6D. Para ello se tendra que dominar otros conceptos, tales como, Objetos, Mtodos, Encapsulamiento, Herencia, Polimorfismo, Interfaces Grficas, Conexin 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 mtodo se pueden redefinir (modificar). Esto significa, que dependiendo de la complejidad del problema y de su solucin, se puede plantear nuevos pasos y eliminar pasos ya existentes en las diferentes etapas del mtodo.
Pag. 38
MODELAMIENTO El modelamiento se refiere a la forma como se representa la solucin de un problema del mundo real en trminos de un modelo. Un modelo es una representacin grfica o simblica de algn aspecto del mundo real, que est bajo observacin o estudio. Para representar un modelo se utilizar el UML (Unified Modeling Language). El Lenguaje Unificado de Modelado (UML) es un lenguaje grfico que nos permite:
Visualizar un modelo. Especificar un modelo (construir modelos precisos, no ambiguos). Construir un modelo en un lenguaje de programacin (se establecen correspondencias con lenguajes Orientados a Objetos, como Java, C++, Visual Basic...). Documentar los componentes de un sistema de software (arquitectura, requisitos, diseo, pruebas, versiones, planificacin...). 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 propsito, se detallarn algunos conceptos bsicos que sern 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 ms objetos del mismo tipo. En su forma ms sencilla, una clase es un conjunto de atributos y mtodos. Una clase es una abstraccin y no
Pag. 39
representa a ningn 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. Lista de atributos de la clase. Lista de mtodos de la clase.
NombreClase
(NombrePaquete al que pertenece)
Atributos Mtodos
Objeto.- Un objeto es cualquier cosa, real o abstracta, acerca de la cual almacenamos datos y los mtodos 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:
NombreClase : nombreObjeto
Nombre de la clase a la cual pertenece el objeto y el nombre del objeto. Ambos nombres deben estar separados por dos puntos.
UML incorpora nueve diagramas que permiten representar un modelo desde diferentes perspectivas, los cuales se muestran a continuacin:
Diagramas de Clase Paquete
Diagramas de Secuencia
Diagramas de Casos de Uso
Diagramas de Objeto
Diagramas de Colaboracin
Diagramas de Componentes
Modelo
Diagramas de Estado Diagramas de Distribucin
Diagramas de Actividad
Pag. 40
Para nuestro propsito, 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 solucin. Una relacin de dependencia entre dos o ms 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). Tambin se puede establecer una relacin 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 relacin de dependencia unidireccional entre dos paquetes se grfica de la siguiente manera:
Relacin de dependencia unidireccional.
La dependencia en este caso significa que todas las clases que pertenecen al paquete dominioDeLaAplicacion podrn 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 Mtodo de las 6D, el modelamiento de una solucin se desarrolla durante la Etapa 03 - Diseo de la solucin:
Se desarrollan los siguientes pasos: Definir un nombre para el proyecto. La definicin del nombre del proyecto, permite agrupar a todos los elementos que sern parte de la solucin del problema utilizando el mtodo 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. Definicin de diagramas, relaciones y clases. En este paso se desarrollar el diagrama de paquetes y se especificar la relacin de dependencia entre los paquetes utilizando UML. Para nuestros fines se crearn dos paquetes en las soluciones. Uno de ellos lo se llamar dominioDeLaAplicacin y el otro biblioteca, y se establecer una relacin 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 ningn atributo definido y solo se definir un mtodo (el mtodo 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 mtodos: El nombre de la clase y el nombre del paquete deben comenzar con una letra mayscula y el resto en minscula. Si el nombre es compuesto, todas las primeras letras de los nombres simples que forman el nombre de la clase o paquete debern comenzar con mayscula. Los nombres de los atributos se escriben en minscula. En caso que el nombre sea compuesto, a partir de la segunda palabra se escribe la primera letra en mayscula. Los nombres de los mtodos cumplen las mismas caractersticas que los nombres de atributos a excepcin de los mtodos constructores.
La clase Lectura se trata en el Captulo II y se especifica en el Apndice.
Pag. 43
Pag. 44
ALGORITMO Una clase, en su forma ms simple, est constituida por atributos y mtodos. Los mtodos representan pequeos subprogramas encapsulados dentro de las clases y contribuyen a definir el comportamiento tpico de los objetos. Para especificar cules son los pasos desarrollados en un determinado mtodo y cules son los datos que manejan dichos pasos se desarrollan los algoritmos. Un algoritmo constituye una lista completa de los pasos y una descripcin de los datos que son necesarios para resolver un determinado problema en el mbito de un mtodo. De esto, se deriva que un algoritmo se desarrolla para un determinado mtodo y que su definicin tiene dos partes esenciales:
Una lista de pasos que deben ser ejecutados. Una descripcin de los datos que son manipulados por estos pasos. CARACTERSTICAS Descripcin de los pasos que deben ser ejecutados (estructuras lgicas). Descripcin de los datos que son manipulados por estos pasos (estructuras de datos). Un algoritmo debe ser preciso, indicando el orden de realizacin de cada paso. Todo algoritmo debe ser finito. Si se sigue un algoritmo, ste debe terminar en algn 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 ms 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 fcil de leer, entender, usar y cambiar si es preciso.
En conclusin, los algoritmos permiten especificar la lgica de desarrollo de los mtodos 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 mtodos de las clases. Entre dichas herramientas se puede mencionar al pseudocdigo y al diagrama de flujo.
HERRAMIENTAS
PSEUDOCODIGO
Un pseudocdigo permite expresar un algoritmo con palabras en castellano que son semejantes a las sentencias de un lenguaje de programacin. Pautas bsicas: Todo algoritmo debe tener un nombre, el cual deber comenzar con una letra mayscula. Si es un nombre compuesto, la primera letra de cada palabra simple deber estar en mayscula. No se permiten los espacios en blanco en el nombre del algoritmo (generalmente se utilizar el nombre de la clase y el nombre del mtodo para referirse a un determinado algoritmo). Es necesario que se determinen los datos de entrada y la informacin 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 realizara 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 expresin (observe que la expresin no est entre comillas) se utiliza: ESCRIBIR x + 2. Estructura bsica de un pseudocdigo: Algoritmo NombreClase nombreMetodo() ENTRADA: SALIDA: INICIO FIN
En ENTRADA y SALIDA se especifican las variables que se usarn en el desarrollo del algoritmo. Este es el cuerpo del algoritmo expresado en pseudocdigo. Las instrucciones se colocan entre INICIO... FIN.
DIAGRAMA DE FLUJO Un Diagrama de Flujo permite ilustrar la secuencia de pasos de un algoritmo por medio de smbolos especializados y lneas de flujo. La combinacin de smbolos especializados y lneas de flujo describe la lgica para la solucin del problema (algoritmo). Entonces, se puede afirmar que el Diagrama de Flujo es la representacin grfica 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 smbolos bsicos:
PROCESO Utilizado para asignar valores a variables y resultados de operaciones matemticas.
ENTRADA / SALIDA Utilizado para ingresar datos y visualizar informacin que resulta del procesamiento. la
INICIO / FIN Este smbolo permite marcar el inicio y el final del algoritmo.
CONECTOR Este smbolo permite que no se crucen los flujos (lneas) en un diagrama.
FLUJOS (LINEAS) Lneas que permiten unir los diagramas y mostrar la secuencia lgica a la solucin del problema.
Pag. 48
REGLAS UTILIZADAS POR LAS HERRAMIENTAS Con la finalidad de comprender mejor el diseo de los algoritmos, desarrollados en pseudocdigo y diagrama de flujo, se han clasificado en 6 grupos las reglas definidas.
REGLA FORMATO DESCRIPCIN GRUPO 1
LEER
LEER x
Utilizada para el ingreso de datos. El dato ingresado se almacena en la variable especificada.
ESCRIBIR
ESCRIBIR Hola ESCRIBIR x ESCRIBIR x + z
Utilizada para la salida de informacin. Se puede visualizar una cadena, el contenido de una variable o el resultado de una operacin matemtica.
COMENTARIO
COMENTARIO Variables
Utilizada para realizar comentarios internos en la codificacin de las soluciones. Permite declarar una variable de tipo numrico. Permite declarar una variable de tipo texto o cadena. Permite declarar a una variable de tipo texto o cadena de una sola letra. Permite declarar una variable de tipo lgico. Permite asignar el valor VERDADERO a una variable lgica. Permite asignar el valor FALSO a una variable lgica.
NUMERO
NUMERO x
TEXTO
TEXTO mensaje
CARACTER
CARACTER letra
LGICO
LGICO aprobado
VERDADERO
aprobado = VERDADERO
FALSO
aprobado = FALSO
GRUPO 2 SI (condicin) ENTONCES instrucciones... FINSI Permite especificar una estructura de decisin simple SI... FINSI. Las estructuras lgicas sern tratadas en el captulo II.
SI
Pag. 49
REGLA
FORMATO SI (condicin) ENTONCES instrucciones... SINO instrucciones... FINSI CUANDO (variable) SEA CASO (valor 1) : instrucciones... CASO (valor 2) : instrucciones... CASO (valor n) : instrucciones... OTROS instrucciones.. FINCUANDO DESDE i = valorInicial HASTA valorFinal instruccin 1 . . . instruccin n FINDESDE MIENTRAS (condicin) instruccin 1 . . . instruccin n FINMIENTRAS HACER instruccin 1 . . . instruccin n MIENTRAS (condicin)
DESCRIPCIN Permite especificar una estructura de decisin doble SI... SINO... FINSI. Las estructuras lgicas sern tratadas en el captulo II.
SI / SINO
Permite especificar una estructura de decisin mltiple CUANDO... FINCUANDO. Las estructuras lgicas sern tratadas en el captulo II.
CUANDO
DESDE
Permite especificar una estructura de repeticin DESDE... FINDESDE. Las estructuras lgicas sern tratadas en el captulo II.
MIENTRAS
Permite especificar una estructura de repeticin MIENTRAS...FINMIENTRAS. Las estructuras lgicas sern tratadas en el captulo II.
HACER
Permite especificar una estructura de repeticin HACER...FINHACER. Las estructuras lgicas sern tratadas en el captulo II.
TERMINAR
TERMINAR
Permite terminar la ejecucin de una estructura lgica de repeticin.
CONTINUAR
CONTINUAR
Permite volver a ejecutar una estructura lgica de repeticin sin finalizar todas las instrucciones que forman parte de la misma.
Pag. 50
REGLA
FORMATO
DESCRIPCIN GRUPO 3
COSENO
x = COSENO n
Permite obtener el coseno del valor almacenado en la variable n. El resultado se almacena en la variable x. Ver captulo III.
SENO
x = SENO n
Permite obtener el seno del valor almacenado en la variable n. El resultado se almacena en la variable x. Ver captulo III. 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 captulo III y captulo IV. Permite obtener el nmero de filas de una matriz n. El resultado se almacena en la variable x. Permite obtener el nmero de columnas de una matriz n. El resultado se almacena en la variable x. Permite cambiar a mayscula la cadena almacenada en la variable n. El resultado se almacena en la variable x. Ver captulo III. Permite cambiar a minscula la cadena almacenada en la variable n. El resultado se almacena en la variable x. Ver captulo III.
LONGITUD
x = LONGITUD n
FILA
x = FILA n
COLUMNA
x = COLUMNA n
MAYSCULA
x = MAYSCULA n
MINUSCULA
x = MINUSCULA n
GRUPO 4
RESTO
x = z RESTO n
Permite obtener el resto de la divisin 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 divisin de las variables z y n. El resultado se almacena en la variable x. Permite obtener la raz n del nmero z. El resultado se almacena en la variable x.
RAIZ
x = z RAIZ n
Pag. 51
REGLA POTENCIA
FORMATO x = z POTENCIA n
DESCRIPCIN Permite obtener la potencia n del nmero z. El resultado se almacena en la variable x. Permite obtener el nmero mayor entre el valor almacenado en la variable n y la variable z. El resultado se almacena en la variable x. Permite obtener el nmero menor entre el valor almacenado en la variable n y la variable z. El resultado se almacena en la variable x. Permite obtener el carcter ubicado en la posicin n de la cadena z. El resultado se almacena en la variable x. Permite obtener un nmero cualquiera (aleatorio) entre los valores de n y z. El resultado se almacena en la variable x.
MAXIMO
x = z MAXIMO n
MINIMO
x = z MINIMO n
CARACTER
x = z CARACTER n
ALEATORIO
x = z ALEATORIO n
GRUPO 5 Permite obtener una subcadena comprendida entre las posiciones especificadas por n1 y n2 de la cadena z. El resultado se almacena en la variable x.
SUBCADENA
x = z SUBCADENA n1, n2
ELIMINAESPACIO x = z ELIMINAESPACIO n1, n2
Permite eliminar los espacios existentes en una cadena entre las posiciones especificadas por n1 y n2. El resultado se almacena en la variable x.
GRUPO 6 Utilizada para crear arreglos previamente declarados. Un arreglo permite almacenar ms de un dato del mismo tipo. Los arreglos sern tratados en el captulo IV. Permite crear un determinada clase objeto de una
CREAR
CREAR vector[n] CREAR matriz[n1][n2]
CREAR
CREAR objeto
EJECUTAR
EJECUTAR algoritmo
Permite ejecutar otro algoritmo.
Pag. 52
REGLA PARAMETRO
FORMATO PARAMETRO listaVariables
DESCRIPCIN Permite especificar si un algoritmo recibe datos o valores. Permite especificar si retorna una respuesta. un algoritmo
RETORNAR
RETORNAR variable
En el Mtodo de las 6D, el algoritmo de una solucin se desarrolla despus del modelamiento, durante la Etapa 03 - Diseo de la solucin:
Se desarrollar el siguiente paso: Desarrollo de algoritmos. En este paso, se desarrollar el algoritmo para el mtodo especificado en la clase, la cual forma parte del paquete dominioDeLaAplicacin. Para el desarrollo del algoritmo se utilizar pseudocdigo.
Pag. 53
PROGRAMACIN La programacin es la traduccin del modelamiento y los algoritmos en sentencias que la computadora puede comprender y ejecutar. En trminos sencillos. Se puede decir, que la programacin es la accin de escribir programas para una computadora, utilizando alguno de los lenguajes de programacin existentes. La accin de escribir programas para una computadora se conoce como codificacin. Las personas que escriben los programas son conocidas como programadores, los cuales estn divididos en categoras segn su experiencia y dominio de diferentes lenguajes de programacin. Entonces, un lenguaje de programacin es un lenguaje que los programadores utilizan para escribir programas que son comprendidos y ejecutados en una computadora.
Nos comunicamos con las computadoras a travs de los programas desarrollados en un lenguaje de programacin en particular. Existen diferentes lenguajes de programacin, la mayor parte de los cuales tienen un conjunto de reglas o sentencias muy especializadas.
La forma de programacin ha variado con el paso de los aos. Al inicio, se desarroll la programacin lineal, luego la programacin modular, despus la programacin estructurada y ahora la programacin orientada a objetos. Entre los lenguajes de programacin orientados a objetos podemos destacar a Java.
LENGUAJES DE PROGRAMACIN JAVA Java es un lenguaje de programacin orientado a objetos desarrollado por Sun MicroSystems, una compaa reconocida por sus estaciones de trabajo UNIX de alta calidad.
Pag. 54
Fundamentado en el lenguaje de programacin C++, el lenguaje Java se dise para ser pequeo, sencillo y porttil a travs de plataformas y sistemas operativos, tanto a nivel de cdigo fuente como binario, lo que significa que los programas Java (applets, aplicaciones y servlets), pueden ejecutarse en cualquier computadora que tenga instalada una mquina virtual de Java. A pesar que Java es un lenguaje de programacin orientado a objetos, tambin puede ser utilizado como un lenguaje estructurado, lo cual se hace necesario para poder iniciar el estudio de los conceptos fundamentales de programacin.
Estructura bsica 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 mtodo main ( ).
En el lenguaje de programacin Java, para definir que una clase forma parte de un paquete determinado, se utiliza la siguiente palabra reservada: package En el lenguaje de programacin 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 mtodos. Todo el cdigo ejecutable reside dentro de los mtodos de la clase. No existe cdigo que no est contenido dentro de un mtodo (a excepcin de los bloques estticos). Existen clases que tienen un mtodo especial conocido como mtodo principal. Todas las clases que tienen especificado un mtodo principal, son clases que pueden ejecutarse. En el lenguaje de programacin Java, para especificar que una clase tiene un mtodo principal, se utiliza las siguientes sentencias: public static void main (String arg[]) Por lo tanto, en el lenguaje de programacin Java, el mtodo principal es conocido como mtodo main ( ).
Palabras reservadas en Java: Una palabra reservada o palabra clave, es aquella que tiene un significado especial para un lenguaje de programacin. 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 Programacin Estructurada (PE) y la Programacin Orientada a Objetos (POO) son las formas de programacin utilizadas por la mayora de los programadores, siendo la POO la ms reciente y la que promete solucionar muchos de los problemas de la PE, incorporando nuevas caractersticas y nuevos conceptos. Una caracterstica importante de la POO es que utiliza los mejores conceptos de la PE y de las otras formas de programacin. En el Mtodo de las 6D, la programacin de una solucin se desarrolla durante la Etapa 04 - Desarrollo de la solucin:
Se desarrollar solo el primer paso: Codificar el proyecto. En este paso, se desarrollar la codificacin del proyecto. Es decir, utilizando el lenguaje de programacin 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
Captulo
Estructuras Fundamentales para la Solucin de Problemas
Temas: Introduccin. Estructuras de Datos: Variables

Tipos de datos. Conversin de datos.
Estructuras Lgicas:
Estructuras lgicas de secuencia. Estructuras lgicas de decisin. Estructuras lgicas de repeticin. Instrucciones de bifurcacin. Mapa de estructuras lgicas detallado.
Mtodo de las 6D. Etapas y pasos. Problemas resueltos en general y sobre figuras.
ESTRUCTURAS FUNDAMENTALES PARA LA SOLUCIN DE PROBLEMAS
CAPTULO II ESTRUCTURAS FUNDAMENTALES PARA LA SOLUCION DE PROBLEMAS INTRODUCCIN El modelamiento se refiere a la forma como representamos la solucin de un problema del mundo real en trminos de un modelo. Un algoritmo constituye una lista completa de los pasos y una descripcin de los datos que son necesarios para resolver un determinado problema en el mbito de un mtodo. La lista completa de los pasos se desarrolla utilizando las estructuras lgicas y las instrucciones de bifurcacin, mientras que los datos se almacenan en las estructuras de datos. La programacin es la traduccin del modelamiento y los algoritmos en sentencias que una computadora puede comprender y ejecutar. La accin de escribir un programa para computadoras se conoce como codificacin.
MARCO DE TRABAJO
ENUNCIADO DEL PROBLEMA Etapa 02 Definicin Solucin
Pag. 61
LISTA DE PASOS DESCRIPCIN DE DATOS
SENTENCIAS DECLARACIN Y DEFINICIN DE DATOS
SE DESARROLLAN UTILIZANDO: Estructuras lgicas de secuencia. Estructuras lgicas de decisin. Estructuras lgicas de repeticin. Instrucciones de bifucacin. ALMACENADOS EN: Estructuras de datos tipo variables.
El presente captulo, trata sobre las estructuras fundamentales para la solucin de problemas. Es importante mencionar que utilizando las estructuras fundamentales para la solucin de problemas (estructuras lgicas, instrucciones de bifurcacin y las estructuras de datos conocidas como variables), se pueden desarrollar algoritmos de tal forma que estos puedan ser diseados en pseudocdigo o diagrama de flujo, para luego ser codificados en un lenguaje de programacin. La tcnica que se emplea en el presente texto para el ingreso de datos y visualizacin de la informacin, cada da se utiliza con menos frecuencia (tcnica tradicional basada en el ingreso de datos y visualizacin de informacin utilizando solo caracteres). En su lugar, se utilizan las interfaces grficas de usuario o GUI (por sus siglas en ingls), que incorporan ventanas, grficos, colores y otros objetos que permiten una interface visual con el usuario. El lenguaje de programacin Java incorpora un paquete denominado AWT (Abstract Windows Toolking) que contiene clases que permiten crear cualquier tipo de interfaces grficas de usuarios o GUI (interfaces visuales). Tambin incorpora un paquete llamado SWING (a partir de la versin 2 de Java), que facilita el ingreso y visualizacin de datos utilizando cuadros de dialogo visuales.
Pag. 62
ESTRUCTURAS DE DATOS VARIABLES Definicin: Una variable es una estructura de datos que permite reservar un espacio con la finalidad de almacenar o guardar temporalmente los datos. Una variable slo puede almacenar un dato a la vez. Si se necesita almacenar dos o tres datos, se requerirn dos o tres variables segn sea el caso. Declaracin 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 declaracin de una variable se debe realizar antes de que sta pueda ser utilizada; esto es necesario en los diferentes lenguajes de programacin, y Java no es la excepcin. En pseudocdigo y diagrama de flujo: TipoDeDato ListaDeVariables En Java: TipoDeDato ListaDeVariables ; Donde TipoDeDato debe ser un tipo de variable o tipo de dato vlido y ListaDeVariables puede tener uno o ms 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 minscula. Si el nombre de la variable est formado por varias palabras, se deber escribir con mayscula la primera letra de cada palabra, a partir de la segunda palabra que forme parte del nombre. No es vlido que el nombre de una variable tenga espacios en blanco ni caracteres especiales (tales como /()=?^* etc). En pseudocdigo: 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 relacin con el valor que estas almacenan. Inicializacin 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 pseudocdigo 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 slo 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 continuacin el signo igual, seguido del valor que se desea almacenar. En pseudocdigo y diagrama de flujo: variable = valor En Java: variable = valor ; Se deber tener presente que una variable puede almacenar slo 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 tena 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 tambin ser sustituido por el resultado de una operacin aritmtica o de clculo. Por ejemplo: En pseudocdigo 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 lgica de repeticin (las estructuras lgicas se repeticin se estudian ms adelante en este mismo captulo). Dichas variables pueden asumir la funcin de contador, acumulador o interruptor. La funcin que pueda asumir una variable depender de la forma como se plantee la solucin 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 repeticin. Un contador puede ser creciente o decreciente. Acumuladores: Un acumulador o totalizador es una variable cuya funcin es almacenar un valor como resultado de sumas o restas sucesivas. Un acumulador realiza la misma funcin 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 tambin 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 solucin. Dependiendo del valor que tome el interruptor se ejecutarn ciertos pasos. Cabe mencionar que en una solucin se puede utilizar una o varias variables que pueden asumir las funciones de contador, acumulador o interruptor.
Pag. 65
TIPOS DE DATOS Definicin: Los tipos de datos permiten declarar las variables. A pesar que en el pseudocdigo y diagrama de flujo slo se reconocen tres tipos de datos, en los lenguajes de programacin se tiene una gran variedad de tipos de datos, los cuales estn divididos generalmente- en dos categoras: bsicos o simples y compuestos. Existen diferentes tipos de datos. En pseudocdigo y diagrama de flujo se utilizan tres tipos (NUMERO, TEXTO y LOGICO). Los lenguajes de programacin permiten trabajar con una amplia diversidad de tipos de datos que se extienden desde los ms bsicos hasta los ms complejos. En Java, todos los datos son derivados de ocho tipos de datos bsicos; byte, short, int, long, float, double, char y boolean. Los tipos de datos bsicos se tratarn en este captulo y constituyen la base para los tipos de datos compuestos. Tipos de datos en Pseudocdigo: Reglas definidas para los tipos de datos: NUMERO CARACTER TEXTO LOGICO Referidos a cualquier nmero. Se puede subdividir en ENTERO y REAL. Referidos a cualquier letra, digito o smbolo encerrado entre comilla simple. Referidos a cualquier texto encerrado entre comillas dobles. Referido a los dos posibles valores lgicos (VERDADERO y/o FALSO).
Hay que tener presente que las palabras NUMERO, ENTERO, REAL. CARACTER. TEXTO y LOGICO son reglas utilizadas en el pseudocdigo y diagrama de flujo, por lo que no podrn ser usadas como nombre de variable. Estos datos nos permiten definir los tres tipos de variables utilizadas: Variables numricas: Permiten almacenar slo tipos de datos numricos (NUMERO, ENTERO y REAL). Con una variable numrica se puede realizar operaciones matemticas (suma, resta, multiplicacin, divisin, etc.). En este contexto, se debe tener presente que las operaciones matemticas se resuelven siguiendo las mismas reglas que se aplican en la aritmtica 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 parntesis. Ejemplos: edad = 15 resultado = 5 + 8 * ( 6 2) Donde edad y resultado son variables que previamente han sido declaradas como variables de tipo numricas. 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, nmero 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 lgicas: Permiten almacenar slo tipo de datos lgicos. Existen slo 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 lgico. Las palabras VERDADERO y FALSO constituyen reglas en pseudocdigo 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 bsicos o simples de Java son utilizados para declarar las variables que sern 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 int long float double char boolean
Descripcin Tipo byte Entero corto Entero Entero largo Real en coma flotante de simple precisin Real con coma flotante de doble precisin. Caracter Lgico
Longitud 1 byte 2 bytes 4 bytes 8 bytes 4 bytes 8 bytes 2 bytes 1 byte
Rango
-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 3,4*10-38 3,4*1038 1,7*10-308 1,7*10308 0 65.535 true / flase
A diferencia de otros lenguajes de programacin, 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 comprobacin 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 ningn error de ejecucin. 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 numricos) 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 bsico (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 slo 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 especfico, solo podr almacenar valores de dicho tipo de dato. En base a esto, si se declara una variable con un tipo de dato especfico 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 lnea genera error. numEntero = numReal ; System.out.println ( numEntero ) ; } } Observacin: No se puede almacenar un nmero 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 lnea genera error. numRealFloat = numRealDouble ; System.out.println ( numRealFloat ) ; } } Observacin: No se puede almacenar un nmero 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 lnea genera error. caracter = estado ; System.out.println ( caracter ) ; } } Observacin: No se puede almacenar un valor lgico (boolean) en una variable caracter (char).
Pag. 70
CONVERSIN 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 tambin tiene su excepcin, y la excepcin para estos casos se denomina conversin de datos. A travs de la conversin de datos se puede almacenar en una variable valores de tipo diferente al tipo de dato con el que se declar la variable. La conversin de datos se aplica generalmente sobre los tipos de datos numricos, es decir entre datos de tipo byte, short, int, long, float y double. Tambin se puede aplicar sobre el tipo de dato char. Conversin implcita de datos en Java: La conversin implcita de datos se da entre un tipo de dato de menor precisin a un tipo de dato de mayor precisin (mas amplio, mas grande) y son generadas automticamente por el compilador Java. A continuacin se muestra los tipos de datos numricos ubicados desde el tipo de dato de menor precisin al tipo de dato de mayor precisin: 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 lnea no genera error. numEnteroGrande = numEntero ; // Se visualiza 5 System.out.println ( numEnteroGrande ) ; } }
Observacin: Al ejecutar esta aplicacin el compilador utiliza la conversin implcita y convierte un nmero entero (int) en un nmero entero largo (long). Esto es vlido ya que el tipo de dato long en Java es de mayor precisin 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 lnea no genera error. numReal = caracter ; // Se visualiza 97.0 System.out.println ( numReal ) ; } }
Observacin: Al ejecutar esta aplicacin el compilador utiliza la conversin implcita y convierte la letra a en un valor real (double) equivalente a su cdigo ASCII, por lo que se visualiza 97.0 (la letra a en cdigo ASCII es 97).
La conversin implcita de datos se realiza al mezclar variables de distinto tipo en expresiones matemticas o al ejecutar instrucciones o sentencias de asignacin. En ambos casos, es necesario que el lado izquierdo de la expresin tenga un tipo de dato ms amplio que el resultado de evaluar el lado derecho:
numReal = numEntero + 5 ;
Lado izquierdo de la expresin
En caso contrario, si el lado derecho de la expresin tiene un tipo de dato ms amplio que el lado izquierdo, al momento de compilar, el programa indicar un error. La conversin implcita de datos en Java, se da de un tipo de dato de menor precisin a uno de mayor precisin. Conversin explicita de datos en Java (casting): Las conversiones de un tipo de dato de mayor precisn a otro tipo de dato de menor precisin requieren que se coloque en forma explicita en los programas. Ests conversiones son inseguras y puedan dar lugar a errores. Este tipo de conversin de datos se le denomina tambin cast (casting). El cast se realiza colocando entre parntesis
Pag. 72
el tipo de dato al que se desea convertir el resultado de una expresin. Ejemplo;

Clase PrgTipoDato06
package dominioDeLaAplicacion ; class PrgTipoDato06 { public static void main ( String arg [ ] ) { double num1 = 20, num2 = 3 ; int div ; // La siguiente lnea 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 lnea no genera error. div = ( int ) ( num1 / num2 ) ; // Se visualiza 6. System.out.println ( div ) ; } } Observacin: Al ejecutar esta aplicacin el compilador utiliza la conversin explcita (casting) para poder almacenar el resultado de una divisin de numeros reales (double) en una variable entera (int).
Finalmente, en el captulo III se tratn las clases Wrappers que envuelven los tipos de datos simples y tambin permiten realizar operaciones de conversin, entre otras.
Pag. 73
Pag. 74
ESTRUCTURAS LGICAS ESTRUCTURAS LGICAS DE SECUENCIA Definicin: Las Estructuras Lgicas de Secuencia son aquellas en las que una instruccin sigue a otra en secuencia. Las instrucciones se ejecutan una a una de tal modo que, finalizada la ejecucin de una instruccin, se inicia la ejecucin de la siguiente hasta completar la ejecucin de todas las instrucciones que forman parte de la secuencia. Las Estructuras Lgicas de Secuencia son las estructuras lgicas ms comunes y constituyen la base sobre la cual se desarrollan las dems estructuras lgicas. Tipos: 1. Estructura para la salida de informacin Definicin: La salida de informacin 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 informacin a travs de un dispositivo de salida de una computadora. Representacin: Para representar la salida o visualizacin de la informacin se utiliza: - La regla; ESCRIBIR - El smbolo; En diagrama de flujo. - La clase; System En Java. En pseudocdigo.
Pag. 75
Es importante mencionar que se puede visualizar una cadena de texto, el contenido de una variable o el resultado de una operacin matemtica. Por ejemplo; Si desea visualizar la cadena de texto Hola Mundo utilizando pseudocdigo y diagrama de flujo, lo realizar de la siguiente manera: ESCRIBIR Hola Mundo
Hola Mundo
Si desea codificarlo en el lenguaje de programacin 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 lnea.
2. Estructura para la entrada de datos Definicin: 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 informacin necesaria. Este tipo de estructura permite ingresar datos a travs de un dispositivo de entrada de una computadora. Representacin: Para representar la entrada de datos se utiliza: - La regla; LEER - El smbolo; En diagrama de flujo. En pseudocdigo.
Pag. 76
- La clase; Lectura En Java.
Es importante mencionar que el lenguaje de programacin 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
MTODO
leerString()
DESCRIPCIN
Permite ingresar cadena de texto. una
leerChar()
Permite ingresar un caracter (una sola letra o nmero) Permite ingresar nmero entero. Permite ingresar nmero entero largo. un
leerInt() Lectura.class leerLong()
un
leerFloat()
Permite ingresar un nmero con parte decimal. Permite ingresar un nmero con parte decimal.
leerDouble()
La clase Lectura fue desarrollada por la Srta. Gisella Guzmn.
La clase Lectura va a facilitar el ingreso de datos en forma tradicional. 1 Esta clase es una implementacin mejorada de la clase Math2 Es importante mencionar, que esta clase permitir ingresar datos en forma tradicional y ser usada para la codificacin de algoritmos en Java. En el Apndice, se trata en detalle la clase Lectura.
Se puede revisar el uso de la clase Math2 en el primer libro del autor, titulado Mtodo para la solucin de problemas utilizando la programacin orientada a objetos Aspectos bsicos.
Pag. 77
3. Estructura para operaciones aritmticas y de clculo Definicin: Las operaciones aritmticas y de clculo se refieren a la forma o mecanismos que se emplean para poder procesar los datos ingresados y obtener la informacin necesaria. Representacin: Para representar las operaciones aritmticas se utilizan los mismos signos que se emplean en la aritmtica tradicional (+, -, *, /). Suma: Resta: Multiplicacin: Divisin: + * /
Las operaciones lgicas se representan de la siguiente manera: En pseudocdigo y diagrama de flujo: Y lgico: O lgico: Negacin: En Java: Y lgico: O lgico: Negacin: && || ~ Y (AND) O (OR) N (NOT)
Formatos: Formato para disear algoritmos: Pseudocdigo INICIO Instrucciones ... FIN
EXPLICACIN: Todas las instrucciones que son parte de la solucin del problema debern aparecer entre las reglas INICIO y FIN. Estas instrucciones se ejecutarn una tras otra.
Pag. 78
Diagrama de Flujo EXPLICACIN:

INICIO
Todas las instrucciones que son parte de la solucin del problema aparecern entre el siguiente smbolo:
Instrucciones ... Dentro del smbolo se indicar si es el inicio o el fin de la solucin con las reglas INICIO o FIN.
FIN
Al conjunto de pasos que forman parte de un algoritmo se les denomina instrucciones.
Formato para codificar algoritmos: Lenguaje de Programacin Java
EXPLICACIN: Inicialmente, se puede afirmar que todas las sentencias que son parte de la solucin aparecern dentro de los mtodos. El mtodo main ( ) es conocido como el mtodo principal, y es desde donde se inicia la ejecucin de las sentencias.
class NombreClase { public static void main (String a[]) { .... // sentencias .... } }
Al conjunto de pasos que forman parte de un programa de computadora se les denomina sentencias.
Pag. 79
ESTRUCTURAS LGICAS DE DECISIN Definicin: Las Estructuras Lgicas de Decisin son construcciones que permiten alterar el flujo secuencial de una solucin, de tal forma que en funcin de una condicin o el valor de una variable, se pueda desviar la secuencia de la solucin entre diferentes alternativas. Las Estructuras Lgicas de Decisin son conocidas tambin como Estructuras de Seleccin. Tipos: 1. Estructuras lgicas de decisin simple Definicin: Una estructura de decisin simple SI... FINSI permite alterar el flujo secuencial (o pasos secuenciales) de una solucin ejecutando un conjunto de pasos adicionales si el resultado de una condicin lgica es verdadera. Este tipo de estructura es til cuando se tiene la posibilidad de escoger una determinada opcin. Formato para disear algoritmos:
Pseudocdigo EXPLICACIN: Si la condicin resulta verdadera, se ejecutan las instrucciones que se encuentran entre las reglas ENTONCES y FINSI. Si la condicin resulta falsa, no se ejecutan las instrucciones que se encuentran entre las reglas ENTONCES y FINSI.
SI (condicin) ENTONCES instrucciones... FINSI
Pag. 80
Diagrama de Flujo
EXPLICACIN: Si la condicin resulta verdadera, se ejecutan las instrucciones que se encuentran en el flujo etiquetado con la regla VERDADERO. Si la condicin 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.
VERDADERO
condicin ?
... instrucciones... ...
FALSO
EXPLICACIN: Si la condicin resulta verdadera, se ejecutan las sentencias que se encuentra entre las llaves { }. Si la condicin resulta falsa, no se ejecutan las sentencias que se encuentran entre las llaves { }.
if (condicin) { sentencias... }
Pag. 81
2. Estructuras lgicas de decisin doble Definicin: Una estructura de decisin doble SI... SINO... FINSI permite alterar el flujo secuencial (o pasos secuenciales) de una solucin, ejecutando un conjunto de pasos dependiendo del resultado de una condicin lgica. Si la condicin resulta verdadera, se ejecuta un conjunto de pasos, y si la condicin resulta falsa, se ejecuta otro conjunto de pasos. En ningn 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 disear algoritmos:
Pseudocdigo
EXPLICACIN: Si la condicin resulta verdadera, se ejecutan las instrucciones que se encuentran entre las reglas ENTONCES y SINO. Si la condicin resulta falsa se ejecutan las instrucciones que se encuentran entre las reglas SINO y FINSI. Slo se ejecuta uno de los grupos de instruccin, en ningn caso se podr ejecutar ambos grupos.
SI (condicin) ENTONCES instrucciones... SINO instrucciones... FINSI
Pag. 82
Diagrama de Flujo EXPLICACIN:

VERDADERO condicin ? FALSO
... instrucciones ...
... instrucciones ...
Si la condicin resulta verdadera, se ejecutan las instrucciones que se encuentran en el flujo etiquetado con la regla VERDADERO. Si la condicin resulta falsa, se ejecutan las instrucciones que se encuentran en el flujo etiquetado con la regla FALSO.
EXPLICACIN: Si la condicin resulta verdadera, se ejecutan las sentencias que se encuentran entre las llaves { } ubicadas despus de la palabra reservada if. Si la condicin resulta falsa, se ejecutan las sentencias que se encuentran entre las llaves { } ubicadas despus de la palabra reservada else.
if (condicin) { sentencias... } else { sentencias... }
Pag. 83
3. Estructuras lgicas de decisin mltiple Definicin: Una estructura de decisin mltiple CUANDO... FINCUANDO permite alterar el flujo secuencial de una solucin 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. Tambin 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 ms de dos opciones.
Formato para disear algoritmos: Pseudocdigo EXPLICACIN: Si el valor de la variable es igual a uno de los valores colocados despus de una de las reglas CASO, se ejecutan las instrucciones que estn dentro del mismo. Si el valor de la variable no es igual a ninguno de los valores colocados despus de una de las reglas CASO, se ejecutan las instrucciones que estn dentro de la regla OTROS. La regla OTROS es opcional (es decir, puede aparecer como no).
CUANDO (variable) SEA CASO (valor 1) : instrucciones... CASO (valor 2) : instrucciones... CASO (valor n) : instrucciones... OTROS instrucciones... FINCUANDO
Pag. 84
Diagrama de Flujo
variable ?
valor 1
valor 2
valor n
OTROS
instrucciones
instrucciones
instrucciones
instrucciones
EXPLICACIN: Si el valor de la variable es igual a uno de los valores que tiene como etiqueta el flujo, se ejecutan las instrucciones que estn 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
Formato para codificar algoritmos: Lenguaje de Programacin Java EXPLICACIN: Si el valor de la variable es igual a uno de los valores colocados despus de la palabra reservada case (valor 1, valor 2, etc), se ejecutan las sentencias que estn dentro del mismo hasta llegar al final (es decir hasta la llave) a no ser que encuentre una palabra reservada break entre las sentencias que se ejecutan. Si el valor de la variable no es igual a ninguno de los valores colocados despus de una de las palabras reservadas case, se ejecutan las sentencias que estn dentro de la palabra reservada default. La palabra reservada default es opcional (es decir puede aparecer como no).
switch (variable) { case valor 1 : sentencias... case valor 2 : sentencias... case valor n : sentencias... 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 estn a continuacin. Tambin es importante mencionar que en Java la variable utilizada junto a la palabra reservada switch slo 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 nmeros enteros despus 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 despus de la palabra reservada case.
Cuando se disee un algoritmo que necesite utilizar estructuras de decisin, se debe emplear correctamente los formatos establecidos, ya que estos constituyen lo que denominamos un estndar o acuerdo. Cuando se codifique un algoritmo recuerde que se tiene que seguir las reglas del lenguaje de programacin que usar, caso contrario, al momento de ejecutar un programa, se dar con la sorpresa que tendr errores de sintaxis.
Pag. 86
ESTRUCTURAS LGICAS DE REPETICIN Definicin: Las Estructuras Lgicas de Repeticin son construcciones que permiten repetir determinadas partes de una solucin, de tal forma que, en funcin de una condicin o el valor de una variable, se pueda repetir un conjunto de pasos un determinado nmero de veces. Las Estructuras Lgicas de Repeticin son conocidas tambin como estructuras de iteracin o bucles. Tipos: 1. Estructura lgica de repeticin DESDE Definicin: Una estructura de repeticin DESDE... FINDESDE permite repetir una instruccin, o un bloque de instrucciones, un nmero determinado de veces o hasta que una condicin se cumpla. Una estructura lgica de repeticin DESDE... FINDESDE con frecuencia se utiliza para iteraciones sencillas en donde se repite un bloque de instrucciones un cierto nmero de veces y despus se detiene. Este tipo de estructura es til cuando se necesita repetir una instruccin o bloque de instrucciones un cierto nmero de veces. Formato para disear algoritmos: Pseudocdigo DESDE i = valorInicial HASTA valorFinal INCREMENTA valor instruccin 1
. . .
instruccin n FINDESDE
Pag. 87
EXPLICACIN: Esta estructura tiene tres partes: 1. Inicializacin: DESDE i = valorInicial
Esta parte se ejecuta una sola vez al momento de iniciar la ejecucin de la estructura lgica de repeticin 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 nmero de veces que se repiten las instrucciones ubicadas entre las reglas DESDE y FINDESDE. 2. Incremento: INCREMENTA valor Cada vez que finaliza la ejecucin 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 segn se indique en valor. Tambin 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. Prueba: HASTA valorFinal
3.
Una vez que se termina de INCREMENTAR o DECREMENTAR la variable ndice, se procede a ejecutar esta parte. Aqu se evala 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 ejecucin del DESDE y se contina con la ejecucin de la instruccin ubicada despus de la regla FINDESDE.
El equivalente de esta estructura en diagrama de flujo se muestra a continuacin:
Pag. 88
Diagrama de Flujo
DESDE i HASTA z INCREMENTA x
FALSO
VERDADERO
EXPLICACIN: Las tres partes de esta estructura se representan en el diagrama de flujo a travs 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 ejecucin. INCREMENTA x Aqu x representa el valor que se incrementar a la variable ndice cada vez que se termine la ejecucin de las instrucciones que forman parte de la estructura. Ambas reglas se encuentran dentro del smbolo que representa la regla o pauta DESDE, la cual se muestra a continuacin:
El fin de las instrucciones o bloque de instrucciones que forman parte de la regla DESDE, se representa por el siguiente smbolo:
Este ltimo smbolo es equivalente a la regla FINDESDE utilizada en pseudocdigo.
Pag. 89
Formato para codificar algoritmos: Lenguaje de Programacin Java for ( i = valorInicial ; condicin ; incremento) { sentencias... } EXPLICACIN: En Java, la regla DESDE est representada por la sentencia for. Al igual que en pseudocdigo y diagrama de flujo, en Java esta estructura est constituida por tres partes. En pseudocdigo y diagrama de flujo se utiliza la regla HASTA valorFinal, mientras que en Java se utiliza una condicin lgica (ejemplo: i >10). Esta parte constituye la prueba en Java. Si la condicin es verdadera, se contina con la ejecucin de las sentencias o bloque de sentencias que pertenecen a la estructura de repeticin; en el caso que sea falso, se finaliza la ejecucin continuando con la siguiente sentencia. Es importante indicar que el inicio y fin de la sentencia for se representan con llaves ({ }).
2. Estructura lgica de repeticin MIENTRAS Definicin: Una estructura de repeticin MIENTRAS... FINMIENTRAS, al igual que una estructura lgica de repeticin DESDE... FINDESDE, permite repetir una instruccin o un bloque de instruccin mientras que una condicin se cumpla o sta sea verdadera. Este tipo de estructura es til cuando se necesita repetir una instruccin o bloque de instrucciones un nmero de veces no determinado.
Pag. 90
Formato para disear algoritmos: Pseudocdigo MIENTRAS (condicin) instruccin 1

. . .
instruccin n FINMIENTRAS
EXPLICACIN: Cuando se ejecuta la estructura lgica de repeticin MIENTRAS... FINMIENTRAS lo primero que se realiza es la evaluacin de la condicin lgica ubicada junto a la regla MIENTRAS. Una vez evaluada la condicin lgica, podemos obtener dos posibles resultados: Si el resultado de evaluar la condicin lgica es verdadera, se procede a ejecutar las instrucciones que estn dentro de la estructura lgica de repeticin MIENTRAS... FINMIENTRAS y se evala, nuevamente, la condicin lgica. Si el resultado de evaluar la condicin lgica es falsa, no se ejecutan las instrucciones que estn dentro de la estructura lgica de repeticin MIENTRAS... FINMIENTRAS y se contina con la ejecucin del algoritmo. Esto significa que mientras la evaluacin de la condicin lgica resulte verdadera, se ejecutar la estructura lgica de repeticin MIENTRAS... FINMIENTRAS y que slo finalizar cuando la evaluacin de la condicin lgica resulte falsa.
El equivalente de esta estructura en diagrama de flujo se muestra a continuacin. En la figura, se observa donde se ubica la condicin lgica y los flujos etiquetados con las reglas VERDADERO y FALSO.
Pag. 91
Diagrama de Flujo
FALSO condicin ?
VERDADERO
Formato para codificar algoritmos:
Lenguaje de Programacin Java while (condicin) { sentencias... }
Pag. 92
EXPLICACIN: En Java, la regla MIENTRAS est representada por la sentencia while. En la sentencia while, al igual que en pseudocdigo y diagrama de flujo, se utiliza una condicin lgica (ejemplo: i >10) para verificar si se ejecuta la estructura o no. Esta condicin lgica constituye la prueba en Java. Si la condicin es verdadera, se contina con la ejecucin de las sentencias o bloque de sentencias que pertenecen a la estructura de repeticin; en el caso que sea falso, se finaliza la ejecucin continuando con la siguiente sentencia. Es importante indicar que el inicio y fin de la sentencia while se representan con llaves ({ }).
3. Estructura lgica de repeticin HACER Definicin: Una estructura lgica de repeticin HACER... MIENTRAS, al igual que una estructura lgica de repeticin DESDE... FINDESDE y una estructura lgica de repeticin MIENTRAS... FINMIENTRAS, permite repetir una instruccin o un bloque de instrucciones mientras que una condicin se cumpla o sea verdadera. La principal diferencia entre ambos consiste en que la estructura lgica de repeticin MIENTRAS... FINMIENTRAS prueba la condicin antes de ejecutar la instruccin o bloque de instrucciones, lo que hace posible que dichas instrucciones no se ejecuten si la condicin es falsa la primera vez que se prueba la condicin. La estructura lgica de repeticin HACER... MIENTRAS ejecuta al menos una vez las instrucciones o bloque de instrucciones antes de probar la condicin. Este tipo de estructura es til cuando se necesita repetir una instruccin o bloque de instrucciones un nmero de veces no determinado, siendo necesario ejecutar la instruccin o bloque de instrucciones por lo menos una vez.
Pag. 93
Formato para disear algoritmos:
Pseudocdigo HACER instruccin 1

. . .
instruccin n MIENTRAS (condicin)
EXPLICACIN: Cuando se ejecuta la estructura lgica de repeticin HACER... MIENTRAS se procede a ejecutar las instrucciones que estn dentro de la misma. Al final, se realiza la evaluacin de la condicin lgica ubicada junto a la regla MIENTRAS. Una vez evaluada la condicin lgica se puede obtener dos posibles resultados: Si el resultado de evaluar la condicin lgica es verdadero, se procede a ejecutar, nuevamente, las instrucciones que estn dentro de la estructura lgica de repeticin HACER... MIENTRAS y se evala, nuevamente la condicin lgica. Si el resultado de evaluar la condicin lgica es falso, se contina con la ejecucin del algoritmo. Esto significa que la estructura lgica de repeticin HACER... MIENTRAS se ejecuta por lo menos una vez antes de ser evaluada la condicin lgica. Si al evaluar la condicin lgica sta resulta verdadera, se vuelve a ejecutar la estructura; caso contrario, finaliza la ejecucin de la estructura, continuando con la siguiente instruccin del algoritmo.
Pag. 94
El equivalente de est estructura en diagrama de flujo se muestra a continuacin. En la figura, se observa donde se ubica la condicin lgica y los flujos etiquetados con las reglas VERDADERO y FALSO.
Diagrama de Flujo
... instrucciones ... ...

VERDADERO condicin ? FALSO
Formato para codificar algoritmos:
Lenguaje de Programacin Java do { sentencias... } while (condicin) ;
Pag. 95
EXPLICACIN: En Java, la regla HACER est representada por la sentencia do. En la sentencia do, al igual que en pseudocdigo y diagrama de flujo, se utiliza una condicin lgica (ejemplo: i >10) al final de la estructura, para verificar si se vuelve a ejecuta la estructura o no. Esta condicin lgica constituye la prueba en Java. Si la condicin es verdadera, se vuelve a ejecutar las sentencias o bloque de sentencias que pertenecen a la estructura de repeticin, en el caso que sea falso, se finaliza la ejecucin, 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 bifurcacin: Muchas veces es necesario cambiar o alterar el flujo normal de ejecucin de una solucin a otra parte de la misma. Para esto, se utilizan las instrucciones de bifurcacin o salto. 1. Instruccin TERMINAR. En Java, esta instruccin de bifurcacin es conocida como la sentencia break y tiene tres usos: Permite finalizar una secuencia de sentencias en un switch (especficamente en el case). Se utiliza para salir de un bucle, sin analizar la condicin y sin ejecutar el resto de cdigo del cuerpo del bucle. Se emplea para proporcionar un mecanismo que permita cambiar el flujo de ejecucin a otra parte de la solucin (equivalente a un goto en otros lenguajes de programacin). 2. Instruccin CONTINUAR En Java, esta instruccin de bifurcacin es conocida como la sentencia continue. Esta sentencia permite salir anticipadamente de una iteraccin de un bucle. Es decir; cuando se encuentra la sentencia continue se ejecuta la siguiente iteraccin del bucle sin procesar el resto del cdigo. 3. Instruccin RETORNAR En Java, esta instruccin de bifurcacin es conocida como la sentencia return. Esta sentencia se utiliza para volver explcitamente de un mtodo, es decir, esta sentencia permite que el control de la ejecucin de la solucin vuelva al mtodo llamante.
Pag. 97
Mapa de Estructuras Lgicas detallado:
Utilizando las estructuras lgicas fundamentales y las instrucciones de bifurcacin, se pueden desarrollar algoritmos de tal forma que estos puedan ser diseados en pseudocdigo o diagrama de flujo, para luego ser codificados en un lenguaje de programacin. Las estructuras lgicas fundamentales y las instrucciones de bifurcacin se resumen a continuacin:
Estructuras Lgicas.
Estructuras Lgicas de Secuencia.
Estructuras Lgicas de Decisin.
Estructuras Lgicas de Repeticin.
Instrucciones de Bifurcacin.
LEER ESCRIBIR PROCESAR
SI SI / SINO CUANDO
DESDE MIENTRAS HACER
TERMINAR CONTINUAR RETORNAR
Pag. 98
ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIN DE PROBLEMAS
MTODO DE LAS 6D ETAPAS Y PASOS A continuacin, se presentan las etapas del Mtodo de las 6D 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 captulo (captulo II), y para los problemas del siguiente captulo (captulo III), solo se ha incluido la Etapa 04 Desarrollo de la solucin. Esto permite presentar una mayor cantidad de problemas con sus respectivas codificaciones.
ENUNCIADO DEL PROBLEMA
Etapa 02 Definicin Solucin
Determinar la informacin 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 sern parte de la solucin del problema. (Utilice UML).
Codificar el diseo de la solucin del problema. Se utiliza el lenguaje de programacin Java.
Disear el algoritmo para el mtodo principal. Se utiliza pseudocdigo.
En forma general, la Etapa 03 - Diseo de la lgica se divide en dos partes: modelamiento (paso 1, 2 y 3) y algoritmo (paso 4), mientras que en la Etapa 04 Desarrollo de la solucin se tiene la parte de codificacin (paso 1). Tambin se puede utilizar esta divisin en el desarrollo de las soluciones.
Pag. 99
Pag. 100
Problema 01 Etapas para la solucin de un problema: Etapa 01 - Descripcin del problema. Desarrollar un proyecto que permita mostrar un mensaje por la pantalla. El mensaje a mostrar ser Hola bienvenidos. Etapa 02 Definicin de la solucin. Resultado deseado: Datos necesarios: Procesamiento: Mostrar mensaje Hola bienvenidos. Ninguno. El mensaje ser almacenado en una variable (mensaje) y posteriormente mostrado.
Etapa 03 - Diseo de la lgica. Para solucionar el problema se desarrollarn las especificaciones del proyecto en UML y el algoritmo en pseudocdigo. 1. Nombre del Proyecto: ProyMensaje 2. Definicin de Paquete y Clase.
Paquete y clase
DominioDeLaAplicacion
PrgMensaje main()
Pag. 101
3. Diseo de algoritmo para el mtodo principal
Algoritmo PrgMensaje - mtodo main()

ENTRADA: SALIDA: INICIO TEXTO mensaje mensaje = Hola bienvenido ESCRIBIR mensaje FIN mensaje
Algoritmo para el mtodo main ( ) diseado en pseudocdigo.
Etapa 04 Desarrollo de la Codificacin. La codificacin se desarrolla utilizando el lenguaje de programacin 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 bsicos de un programa en Java. */ package dominioDeLaAplicacion ; class PrgMensaje {
// La ejecucin empieza en el mtodo main. public static void main ( String arg [ ] ) { String mensaje ; mensaje = Hola bienvenido ; System.out.print (mensaje) ; } }
Pag. 102
Anlisis de la solucin: En primer lugar, se defini el nombre del proyecto, se estableci el nombre del paquete, el nombre de la clase y el mtodo main ( ), en el cual se codifica la solucin. A continuacin, analizaremos el algoritmo del mtodo main ( ) diseado en pseudocdigo para la solucin del problema anterior. La primera lnea: ALGORTIMO PrgMensaje Est referida al nombre del algoritmo. En este caso, el nombre es PrgMensaje. Observe que la primera letra se escribe con mayscula. Luego tenemos: ENTRADA: En esta parte se hace referencia a todas las variables, cuya funcin en el algoritmo es almacenar datos de entrada. Observe que no se ha definido ninguna variable de entrada. SALIDA: En esta parte se hace referencia a todas las variables, cuya funcin en el algoritmo es almacenar datos de salida. Observe que se ha definido la variable mensaje como una variable de salida. SALIDA: Luego tenemos: INICIO Esta palabra permite indicar el inicio de los pasos que constituyen la solucin al problema planteado. A continuacin: TEXTO mensaje Esta lnea est referida al paso 1 del algoritmo diseado en pseudocdigo. 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 lnea est referida al paso 2 del algoritmo diseado en pseudocdigo. Aqu se asigna el valor Hola bienvenidos a la variable mensaje. Recuerde que, para asignar un valor a una variable, se utiliza el smbolo igual (=). A continuacin: ESCRIBIR mensaje mensaje
A continuacin:
Pag. 103
Esta lnea est referida al paso 3 del algoritmo diseado en pseudocdigo. A travs 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 solucin al problema planteado. Es decir, el final del algoritmo. Los pasos que estn entre las palabras INICIO FIN constituyen la parte ms importante del algoritmo y es conocido como cuerpo del algoritmo.
Ahora, analicemos cada lnea de la codificacin del algoritmo en el lenguaje de programacin Java: En primer lugar, observamos que el programa empieza con las siguientes lneas:
/* Este es el primer programa. Aunque es sencillo podemos apreciar los elementos bsicos de un programa en Java. */
Este es un comentario. Tal como la mayora de lenguajes de programacin, Java le permite colocar comentarios en el cdigo fuente de los programas. Los comentarios no son ejecutados, y su propsito es describir o explicar el objetivo de un programa a cualquiera que lea el cdigo fuente. En nuestro caso, el comentario nos permite identificar el programa. En problemas grandes se utilizan los comentarios para explicar para qu sirve cada caracterstica del programa y cmo 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 mltiples lneas. 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 smbolos de comentario de mltiples lneas /*. */ es ignorado al momento de ejecutar el programa. Los comentarios de mltiples lneas pueden tener una o varias lneas de longitud.
Pag. 104
Observemos la siguiente lnea de cdigo:
package dominioDeLaAplicacion ;
Esta lnea especifica el paquete al cual pertenecer la clase que se crear con la palabra reservada class. El nombre del paquete est a continuacin de la palabra reservada package. En este caso, el nombre del paquete es dominioDeLaAplicacion.
En la siguiente lnea de cdigo:
class PrgMensaje {
Observe que en la lnea de cdigo anterior se utiliza la palabra reservada class, lo cual nos indica que se declara una clase. A continuacin 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 lnea del programa es:
// La ejecucin empieza en el mtodo main.
Este tambin es un comentario. Usa el segundo tipo de comentario disponible en Java y se llama comentario de una sola lnea. Los comentarios de una sola lnea comienzan con dos barras ( // ) y terminan al final de la lnea. La siguiente lnea del programa es:
public static void main ( String arg [ ] ) {
Pag. 105
Esta lnea de cdigo es conocida como la firma del mtodo main ( ) o mtodo principal. Toda clase en Java, que deseamos tenga la posibilidad de ejecutarse, deber tener un mtodo main ( ) exactamente como ha sido escrito, debido a que Java diferencia las letras maysculas de las letras minsculas. En resumen, podemos decir que para desarrollar un programa bsico en Java necesitamos definir un paquete, una clase y un mtodo principal o mtodo main ( ). Recuerde que esto se realiz con las siguientes lneas de cdigo:
package dominioDeLaAplicacion ; class PrgMensaje { public static void main ( String arg [ ] ) { } }
La siguiente lnea del programa es:
String mensaje ;
A travs de esta lnea 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 disear algoritmos). Adems, tambin 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 lnea de cdigo termina en punto y coma ( ; ). De hecho, todas las sentencias en Java terminan en punto y coma. La siguiente lnea del programa es:
mensaje = Hola bienvenido ;
A travs 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 lnea 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, tambin uno puede visualizar cadenas y los resultados de operaciones matemticas. Las dos ltimas lneas del programa son:
} }
La primera indica que el mtodo main ( ) ha terminado y la segunda indica el final de la clase. De esto se deduce, que las siguientes lneas de cdigo se utilizarn en todos los programas que se desarrollen. Slo 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 solucin de un problema: Etapa 01 - Descripcin del problema. Se requiere mostrar el resultado de sumar, multiplicar, restar y dividir los nmeros 9121236 y 735. Etapa 02 - Definicin de la solucin. Resultado deseado: Mostrar el resultado de las operaciones matemticas bsicas; suma, multiplicacin, resta y divisin de los nmeros 9121236 y 735. Ninguno. Los nmeros sern almacenados en variables, luego se realizarn las operaciones matemticas y, finalmente, se mostrarn los resultados de dichas operaciones.
Datos necesarios: Procesamiento:
Etapa 03 - Diseo de la lgica. Para solucionar el problema se desarrollarn las especificaciones del proyecto en UML y el algoritmo en pseudocdigo. 1. Nombre del Proyecto: ProyOperaciones. 2. Definicin de Paquete y Clase.
Paquete y clase
DominioDeLaAplicacion
PrgOperaciones main()
Pag. 108
3. Diseo de algoritmo para el mtodo principal.

Algoritmo PrgOperaciones - mtodo 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 multiplicacin es + multi ESCRIBIR La resta es + resta ESCRIBIR La divisin es + divi FIN
Etapa 04 - Desarrollo de la Codificacin. La codificacin se desarrolla utilizando el lenguaje de programacin Java.

Clase PrgOperaciones
package dominioDeLaAplicacion; class PrgOperaciones {
// la ejecucin 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 multiplicacin es: + multi); System.out.println (La divisin es: + divi); } }
Pag. 109
Problema 03 Etapa 01 - Descripcin del problema. Convertir y mostrar una cantidad de dinero, expresado en dlares, en su equivalente en nuevos soles. Ingresar la cantidad en dlares y el tipo de cambio. Etapa 02 - Definicin de la solucin. Resultado deseado: Datos necesarios: Procesamiento: Mostrar el equivalente, en nuevos soles, de una cantidad expresada en dlares. El monto en dlares y el tipo de cambio. El monto en dlares y el tipo de cambio sern ingresados por teclado y almacenados en dos variables (dolares y tipo respectivamente). Luego, se calcular el equivalente en nuevos soles utilizando la siguiente operacin: soles = dolares * tipo El resultado se almacenar en una variable (soles) para luego ser mostrada por pantalla.
Etapa 03 - Diseo de la lgica. Para solucionar el problema se desarrollarn las especificaciones del proyecto en UML y el algoritmo en pseudocdigo. 1. Nombre del Proyecto: ProyDolaresSoles. 2. Definicin de Paquetes y desarrollo de Diagrama de Paquetes.
Diagrama de paquetes
Pag. 110
3. Definicin de las Clases.

Clases dominioDeLaAplicacion Clases biblioteca
Algoritmo PrgDolaresSoles - mtodo main ( )
ENTRADA: dolares, tipo SALIDA: soles
INICIO NUMERO dolares, tipo, soles LEER dolares, tipo soles = dolares * tipo ESCRIBIR soles FIN
Pag. 111
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 dlares: ) ; dolares = Lectura.leerDouble ( ) ; System.out.print ( Ingrese tipo de cambio del dlar: ) ; tipo = Lectura.leerDouble ( ) ; soles = dolares * tipo ; System.out.println ( Cantidad equivalente en soles es: + soles) ; } }
Pag. 112
Problema 04 Etapa 01 - Descripcin del problema. Calcular la nota final que ha obtenido un alumno en el curso de programacin avanzada. Utilizar la siguiente frmula: nf = (n1 + n2 + n3 + (n4 * 2)) / 5. Ingresar las notas n1, n2, n3 y n4 a travs del teclado. Etapa 02 - Definicin de la solucin. 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 sern ingresadas por teclado y almacenadas en variables (n1, n2, n3 y n4 respectivamente). Luego, se realizar el clculo de la nota final sobre la base de la siguiente frmula: nf = ( n1 + n2 + n3 + ( n4 * 2) ) / 5 El resultado se almacenar en una variable (nf) para luego ser mostrada por pantalla.
Etapa 03 - Diseo de la lgica. Para solucionar el problema se desarrollarn las especificaciones del proyecto en UML y el algoritmo en pseudocdigo. 1. Nombre del Proyecto: ProyNotaFinal. 2. Definicin de Paquetes y desarrollo de Diagrama de Paquetes.
Pag. 113
Clases dominioDeLaAplicacion
Clases biblioteca
Algoritmo PrgNotaFinal - mtodo 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 - Descripcin 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 cafetera. Se deber visualizar por pantalla el total de descuentos y el sueldo a cobrar. Etapa 02 - Definicin de la solucin. Resultado deseado: Datos necesarios: Procesamiento: Mostrar el total de descuento y el sueldo a cobrar de un obrero de la empresa. El sueldo total del obrero. El sueldo total ser ingresado por teclado y almacenado en una variable (sueldo). Luego, se realizarn los clculos del descuento y del sueldo a cobrar del obrero, utilizando las siguientes operaciones: desc = sueldo * 0.2 pago = sueldo desc Los resultados se almacenarn en las variables (desc y pago respectivamente) para luego ser mostradas por pantalla.
Etapa 03 - Diseo de la lgica. Para solucionar el problema se desarrollarn las especificaciones del proyecto en UML y el algoritmo en pseudocdigo. 1. Nombre del Proyecto: ProySueldoObrero. 2. Definicin de Paquetes y desarrollo de Diagrama de Paquetes.
Pag. 116


Algoritmo PrgSueldoObrero - mtodo 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 - Descripcin del problema. Convertir la temperatura de grados Celsius a grados Fahrenheit, de acuerdo a la siguiente frmula: F = (9/5) * C + 32. Etapa 02 - Definicin de la solucin. Resultado deseado: Datos necesarios: Procesamiento: 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 clculo de la temperatura en grados Fahrenheit de acuerdo a la siguiente frmula: gradosFar = (9/5) * gradosCel + 32. El resultado ser almacenado en una variable (gradosFar) para luego ser mostrado por pantalla.
Etapa 03 - Diseo de la lgica. Para solucionar el problema se desarrollarn las especificaciones del proyecto en UML y el algoritmo en pseudocdigo. 1. Nombre del Proyecto: ProyTemperatura. 2. Definicin de Paquetes y desarrollo de Diagrama de Paquetes.
Pag. 119

Algoritmo PrgTemperatura - mtodo main ( )

ENTRADA: SALIDA: INICIO NUMERO gradosCel = 0, gradosFar = 0 LEER gradosCel gradosFar = ( 9 / 5 ) * gradosCel + 32 ESCRIBIR gradosFar FIN gradosCel gradosFar
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 - Descripcin del problema. Leer el costo de un artculo y su precio de venta. Calcular y mostrar su utilidad. Etapa 02 - Definicin de la solucin. Resultado deseado: Datos necesarios: Procesamiento: Calcular y mostrar la utilidad de un artculo. El costo y el precio de venta del artculo. El costo y el precio de venta del artculo sern ingresados y almacenados en variables (costo, precioVta), luego se realizar el clculo de la utilidad del artculo de acuerdo a la siguiente frmula: utilidad = precioVta - costo El resultado ser almacenado en una variable (utilidad) para luego ser mostrado por pantalla.
Etapa 03 - Diseo de la lgica. Para solucionar el problema se desarrollarn las especificaciones del proyecto en UML y el algoritmo en pseudocdigo. 1. Nombre del Proyecto: ProyUtilidad. 2. Definicin de Paquetes y desarrollo de Diagrama de Paquetes.
Pag. 122

Algoritmo PrgUtilidad - mtodo main ( )

ENTRADA: SALIDA: INICIO NUMERO costo = 0, precioVta = 0, utilidad = 0 LEER costo, precioVta utilidad = precioVta - costo ESCRIBIR utilidad FIN costo, precioVta utilidad
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 artculo: ) ; costo = Lectura.leerDouble ( ) ; System.out.print ( Ingrese el precio de venta del artculo: ) ; precioVta = Lectura.leerDouble ( ) ; utilidad = precioVta - costo ; System.out.println ( La utilidad del artculo es: s/. + utilidad + soles ) ; } }
Pag. 124
Problema 08 Etapa 01 - Descripcin del problema. Calcular y mostrar la nota final (nf) de un alumno, sabiendo que se tienen slo dos notas. Si el alumno obtiene una nota final mayor a 13 se deber visualizar un mensaje de felicitaciones. Etapa 02 - Definicin de la solucin. Resultado deseado: Datos necesarios: Procesamiento: Mostrar nota final y un mensaje de felicitaciones si la nota final es mayor a 13. Las dos notas del alumno. Las notas se ingresarn por el teclado y sern almacenadas en variables (nota1 y nota2), luego se realizar el clculo 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 - Diseo de la lgica. Para solucionar el problema se desarrollarn las especificaciones del proyecto en UML y el algoritmo en pseudocdigo. 1. Nombre del Proyecto: ProyNotaFinal2. 2. Definicin de Paquetes y desarrollo de Diagrama de Paquetes.
Pag. 125

Algoritmo PrgNotaFinal2 - mtodo 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 - Descripcin del problema. Calcular y mostrar el sueldo de un trabajador conociendo el nmero 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 - Definicin de la solucin. Resultado deseado: Datos necesarios: Procesamiento: 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 ingresarn por teclado y se almacenarn en variables (horas y tarifa), luego se realizar el clculo del sueldo utilizando la siguiente operacin: 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 travs de la pantala.
Etapa 03 - Diseo de la lgica. Para solucionar el problema se desarrollarn las especificaciones del proyecto en UML y el algoritmo en pseudocdigo. 1. Nombre del Proyecto: ProySueldoTrabajador. 2. Definicin de Paquetes y desarrollo de Diagrama de Paquetes.
Pag. 128

Algoritmo PrgSueldoTrabajador - mtodo 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 - Descripcin del problema. Calcular y mostrar el monto total a pagar por la compra de varios artculos 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 - Definicin de la solucin. Resultado deseado: Datos necesarios: Procesamiento: 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 clculo 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 slo se descontar el 2%.
Etapa 03 - Diseo de la lgica. Para solucionar el problema se desarrollarn las especificaciones del proyecto en UML y el algoritmo en pseudocdigo. 1. Nombre del Proyecto: ProyArticulos. 2. Definicin de Paquetes y desarrollo de Diagrama de Paquetes.
Pag. 131


Algoritmo PrgArticulos - mtodo 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 - Descripcin del problema. Leer la categora y el sueldo de un trabajador, y calcular el aumento correspondiente teniendo en cuenta la siguiente tabla. Muestrar el nuevo sueldo del trabajador.
Categora 1 2 3 4 Aumento 25 % 15 % 10 % 05 %
Etapa 02 - Definicin de la solucin. Resultado deseado: Datos necesarios: Procesamiento: Mostrar nuevo sueldo del trabajador. La categora y el sueldo del trabajador. La categora y el sueldo del trabajador sern almacenados en variables (categoria y sueldo). Dependiendo la categora 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 - Diseo de la lgica. Para solucionar el problema se desarrollarn las especificaciones del proyecto en UML y el algoritmo en pseudocdigo. 1. Nombre del Proyecto: ProyAumentoSueldo. 2. Definicin de Paquetes y desarrollo de Diagrama de Paquetes.
Pag. 134


Algoritmo PrgAumentoSueldo - mtodo 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 categora 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 - Descripcin del problema. Calcular y mostrar el costo total que representa un paciente para un hospital de acuerdo al tipo de enfermedad, segn 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 / Da 200 350 420
Etapa 02 - Definicin de la solucin. Resultado deseado: Datos necesarios: Procesamiento: Mostrar el costo total de un paciente para un hospital. El tipo de enfermedad, el nmero de das de permanencia del paciente y su sexo. El tipo de enfermedad, el nmero de das y el sexo (1 si es hombre y 2 si es mujer) del paciente se almacenarn en variables (tipoEnfermedad, dias y sexo). Dependiendo del tipo de enfermedad, se proceder hacer el clculo del costo que representa para el hospital el paciente, de acuerdo a la siguiente operacin costoTotal = ( costo * nmero de das). 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 - Diseo de la lgica. Para solucionar el problema se desarrollarn las especificaciones del proyecto en UML y el algoritmo en pseudocdigo.
1. Nombre del Proyecto: ProyHospital. 2. Definicin de Paquetes y desarrollo de Diagrama de Paquetes.

Pag. 138
Algoritmo PrgHospital - mtodo 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 nmero de das 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 - Descripcin del problema. Ingresar tres notas de un alumno. Muestrar las notas ordenadas en forma ascendente. Etapa 02 - Definicin de la solucin. Resultado deseado: Datos necesarios: Procesamiento: Mostrar las tres notas en forma ascendente. Las tres notas del alumno en cualquier orden. Las tres notas del alumno sern almacenadas en variables (n1, n2 y n3). Se utilizarn tres variables auxiliares para almacenar el orden de las notas (menor, intermedio y mayor). Finalmente, las variables auxiliares mayor, intemedio y menor almacenarn las notas y se mostrarn en orden ascendente.
Etapa 03 - Diseo de la lgica. 1. Nombre del Proyecto: ProyOrdena. 2. Definicin de Paquetes y desarrollo del Diagrama de Paquetes.

Pag. 141
Algoritmo PrgOrdena - mtodo main ( )

ENTRADA: SALIDA: 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 n1, n2, n3 menor, intermedio, mayor
Pag. 142
Etapa 04 - Desarrollo de la Codificacin.
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 - Descripcin del problema. Un curso se evala de la siguiente forma: se toma cinco prcticas calificadas, se determina el promedio de las cuatro notas ms altas y se le da al estudiante una categora que puede ser A, B, C o D. Segn 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 categora del alumno.
Etapa 02 - Definicin de la solucin. Resultado deseado: Datos necesarios: Procesamiento: Mostrar la categora del alumno. Las cinco notas del estudiante. Las cinco notas del estudiante se ingresan a travs 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 clculo 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 categora del alumno (categoria), para luego ser mostrada por pantalla.
Pag. 144
Etapa 03 - Diseo de la lgica. 1. Nombre del Proyecto: ProyCategoriaAlumno. 2. Definicin de Paquetes y desarrollo del Diagrama de Paquetes.

Pag. 145
Algoritmo PrgCategoriaAlumno - mtodo main ( )

ENTRADA: SALIDA: 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 n1, n2, n3, n4, n5 categoria
Pag. 146

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 categora del alumno es: + categoria ) ; } }
Pag. 147
Problema 15 Etapa 01 - Descripcin del problema. En una oficina de empleados, categorizan a los postulantes en funcin del sexo y de la edad, de acuerdo a lo siguiente: - Si la persona es de sexo femenino: o Categora FA si tienen menos de 23 aos. o Categora FB en caso contrario. - Si la persona es de sexo masculino: o Categora MA si tiene menos de 25 aos. o Categora MB en caso contrario. Etapa 02 - Definicin de la solucin. Resultado deseado: Datos necesarios: Procesamiento: Mostrar la categora del postulante. El sexo y la edad del postulante. El sexo y la edad del postulante se ingresan a travs del teclado y se almacenan en variables (sexo y edad). Si es hombre o mujer asignaremos su respectiva categora dependiendo de la edad del postulante. El resultado es almacenado en una variable (categoria) para luego ser mostrada por pantalla.
Etapa 03 - Diseo de la lgica. 1. Nombre del Proyecto: ProyCategoriaPostulante. 2. Definicin de Paquetes y desarrollo del Diagrama de Paquetes.
Pag. 148


Algoritmo PrgCategoriaPostulante - mtodo main ( )
ENTRADA: SALIDA: 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 sexo, edad categoria
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 categora del postulante es: + categoria ) ; } }
Pag. 150
Problema 16 Etapa 01 - Descripcin del problema. Calcular la nota final de todos los alumnos del curso utilizando la siguiente frmula: nf = ( n1 + n2 + n3 + ( n4 * 2 ) ) / 5 Ingresar las notas a travs del teclado. Utilizar la estructura lgica MIENTRAS. Etapa 02 - Definicin de la solucin. 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 travs del teclado y se almacenan en variables (n1, n2, n3 y n4). Se realizar el clculo de la nota final en base a la frmula: 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 - Diseo de la lgica. 1. Nombre del Proyecto: ProyNotasAlumnos. 2. Definicin de Paquetes y desarrollo del Diagrama de Paquetes.
Pag. 151

Algoritmo PrgNotasAlumnos - mtodo 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 nmero 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 - Descripcin del problema.

Calcular la nota final de todos los alumnos del curso utilizando la siguiente frmula: nf = ( n1 + n2 + n3 + ( n4 * 2 ) ) / 5. Ingresar las notas a travs del teclado. Utilizar la estructura lgica HACER.
Etapa 02 - Definicin de la solucin. 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 travs del teclado y se almacenan en variables (n1, n2, n3 y n4). Se realizar el clculo de la nota final sobre la base de la frmula: 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 - Diseo de la lgica. 1. Nombre del Proyecto: ProyNotasAlumnos2. 2. Definicin de Paquetes y desarrollo del Diagrama de Paquetes.
Pag. 154


Algoritmo PrgNotasAlumnos2 - mtodo 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 - Descripcin del problema. Determinar la suma de sueldos de los obreros (categora 1), la suma de sueldos de los empleados (categora 2) y la suma de sueldos de los gerentes (categora 3) de una determinada empresa. Adicionalmente, determinar cul es el mayor y el menor sueldo en la empresa. Etapa 02 - Definicin de la solucin. Resultado deseado: La suma de sueldos de los obreros, la suma de sueldos de los empleados y la suma de sueldos de los gerentes. Adicionalmente el sueldo mayor y el sueldo menor. El sueldo y la categora de cada uno de los trabajadores de la empresa. El sueldo y la categora de cada trabajador de la empresa se ingresarn a travs del teclado y se almacenarn 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. Tambin se evaluar la categora 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 - Diseo de la lgica. 1. Nombre del Proyecto: ProySueldoCategoria. 2. Definicin de Paquetes y desarrollo del Diagrama de Paquetes.

Pag. 158
Algoritmo PrgSueldoCategoria - mtodo main ( )

ENTRADA: SALIDA: 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 sueldo, categoria sueldo1, sueldo2, sueldo3, mayorSueldo, menorSueldo
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 categora 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 ms bajo es: +menorSueldo ) ; System.out.println ( El sueldo ms alto es: + mayorSueldo ) ; } }
Pag. 160
Problema 19 Etapa 01 - Descripcin del problema. Calcular y mostrar el nmero 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 frmula: nf = ( n1 + n2 + n3 + ( n4 * 2 ) ) / 5. Etapa 02 - Definicin de la solucin. Resultado deseado: Mostrar el nmero de alumnos con promedio final menor que 10, el nmero de alumnos con promedio final entre 10 y 14, el nmero de alumnos con promedio final entre 15 y 18, y el nmero 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 clculo 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 - Diseo de la lgica. 1. Nombre del Proyecto: ProyNotasRango. 2. Definicin de Paquetes y desarrollo del Diagrama de Paquetes.

Pag. 162
Algoritmo PrgNotasRango - mtodo main ( )

ENTRADA: SALIDA: 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 numAlumnos, n1, n2, n3, n4 total1, total2, total3, total4
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 nmero 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 - Descripcin del problema.

Elaborar una solucin que permita controlar la venta de boletos en un determinado da en un teatro de la capital, en base a la siguiente informacin: 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: nmero de boleto y lugar (puede ser platea, palco o mezanine). El programa terminar cuando el nmero de boleto sea igual a cero. Antes de finalizar, se deber proporcionar la siguiente informacin: Nmero total de entradas vendidas durante el da. El total de soles recaudados en el da. Nmero de entradas vendidas para platea, palco y mezanine en el da.
Etapa 02 - Definicin de la solucin. Resultado deseado: El nmero total de entradas vendidas, el monto total recaudado y el nmero de entradas vendidas para platea, palco y mezanine en un determinado da. El costo del boleto para platea, palco y mezanine en general, y por cada venta, el nmero 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 ingresarn a travs del teclado y se almacenarn en las variables costoPla, costoPal y costoMez respectivamente. Cada vez que se venda un boleto se ingresar el nmero y tipo de boleto, y se almacenarn 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) segn corresponda, para obtener la ganancia en
Datos necesarios:
Procesamiento:
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 - Diseo de la lgica. 1. Nombre del Proyecto: ProyTeatro. 2. Definicin de Paquetes y desarrollo del Diagrama de Paquetes.

Pag. 166

Algoritmo PrgTeatro - mtodo main ( )
ENTRADA: SALIDA: 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 costoPla, costoPal, costoMez totalVendidas, totalGanancia, totalPla, totalPal, totaMez
Pag. 167

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 nmero 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 ( Nmero 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 - Descripcin del problema. Los empleados de una fbrica trabajan en tres turnos; maana, tarde y noche. Se desea calcular el jornal diario de cada empleado teniendo en cuenta lo siguiente: La tarifa del turno maana 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 da domingo, la tarifa se incrementa en 50% para los turnos maana y tarde y en 60% para el turno noche. Para el turno tarde se incrementa S/ 10.00 soles por concepto de movilidad.
Etapa 02 - Definicin de la solucin. Resultado deseado: Datos necesarios: Procesamiento: Calcular y mostrar el jornal diario de cada empleado. El nmero de horas, el turno y el da que trabaj el empleado. El nmero de horas, el turno y el da del empleado se ingresan a travs del teclado y se almacenan en variables (horas, turno y dia). Dependiendo del turno se obtiene la tarifa para luego hacer el clculo 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 fbrica.
Pag. 169
Etapa 03 - Diseo de la lgica. 1. Nombre del Proyecto: ProyJornal. 2. Definicin de Paquetes y desarrollo del Diagrama de Paquetes.

Pag. 170

Algoritmo PrgJornal - mtodo main ( )
ENTRADA: SALIDA: 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 Nmero empleados mayor a 0. FINSI MIENTRAS (numEmpleados <= 0) MIENTRAS (i < numEmpleados) i=i+1 HACER LEER horas SI (horas <= 0) ENTONCES ESCRIBIR Nmero horas mayor a 0. FINSI MIENTRAS (horas <= 0) HACER LEER dia SI (dia < 1 OR dia > 7) ENTONCES ESCRIBIR La opcin no es vlida. 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 opcin no vlida FINCUANDO MIENTRAS (turno <>1 AND turno <>2 AND turno <>3) numEmpleados, horas, turno, dia jornal
Pag. 171
Contina 4. Diseo de algoritmo para el mtodo principal.

Algoritmo PrgJornal - mtodo main ( )
SI (turno = 2) ENTONCES jornal = horas * tarifa + 10 SINO jornal = horas * tarifa FINSI ESCRIBIR jornal FINMIENTRAS FIN

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 nmero de empleados: ) ; numEmpleados = Lectura.leerInt ( ) ; if (numEmpleados <= 0) System.out.println ( El nmero 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 ( Nmero de horas mayor a 0 ) ; } while (horas <= 0) ;
Pag. 172
Contina

Clase PrgJornal
do { System.out.println ( Seleccione da trabajado empleado [ + i + ]: ) ; System.out.println ( [1] Lunes ) ; System.out.println ( [2] Martes ) ; System.out.println ( [3] Mircoles ) ; System.out.println ( [4] Jueves ) ; System.out.println ( [5] Viernes ) ; System.out.println ( [6] Sbado ) ; System.out.println ( [7] Domingo ) ; System.out.print( Opcin: ) ; dia = Lectura.leerInt ( ) ; if (dia < 1 || dia > 7) System.out.println ( La opcin no es vlida ) ; } while (dia < 1 || dia > 7) ; do { System.out.println ( Seleccione el turno del empleado: ) ; System.out.println ( [1] Maana ) ; System.out.println ( [2] Tarde ) ; System.out.println ( [3] Noche ) ; System.out.print ( Opcin: ) ; 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 opcin no es vlida ) ; } } while (turno != 1 && turno != 2 && turno != 3) ; if (turno == 2) jornal = horas * tarifa + 10 ; else jornal = horas * tarifa ; System.out.println ( El jornal del da del empleado [ + i + ] es: + jornal ) ;
} } }
Pag. 173
Problema 22 Etapa 01 - Descripcin del problema. Desarrollar una solucin que permita obtener la siguiente informacin en un saln de clase: Cuntas alumnas estn matriculadas en el curso? Cuntos alumnos estn matriculados en el curso? Cuntas alumnas son menores de 20 aos? Cuntos alumnos son mayores de 18 aos? Cuntos alumnos estn aprobados? Cuntas alumnas estn desaprobadas? Etapa 02 - Definicin de la solucin. Resultado deseado: Nmero de alumnas matriculadas, menores de 20 aos y desaprobadas; adems nmero de alumnos matriculados, mayores de 18 aos y aprobados. Sexo, edad y nota de cada uno de los alumnos del curso, as como una variable que determine si se contina o no con el ingreso de los datos de un nuevo alumno. El sexo, la edad y la nota de cada alumno se ingresarn a travs del teclado y se almacenarn 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 aos o cada alumno mayor de 18 aos 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).
Datos necesarios:
Procesamiento:
Pag. 174
Etapa 03 - Diseo de la lgica. 1. Nombre del Proyecto: ProyClase. 2. Definicin de Paquetes y desarrollo del Diagrama de Paquetes.

Pag. 175

Algoritmo PrgClase - mtodo main ( )
ENTRADA: SALIDA: 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 vlido. 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 vlida. FINSI MIENTRAS (edad <= 0) HACER LEER nota SI (nota < 0 OR nota > 20) ENTONCES ESCRIBIR La nota no es vlida. FINSI MIENTRAS (nota < 0 OR nota > 20) CUANDO sexo SEA: CASO f: CASO F: matriculadas = matriculadas + 1 SI (edad < 20) ENTONCES menores = menores + 1 FINSI SI (nota < 11) ENTONCES desaprobadas = desaprobadas + 1 FINSI TERMINAR sexo, edad, nota, rpta matriculadas, matriculados, menores, mayores, desaprobadas, aprobados
Pag. 176
Contina
Algoritmo PrgClase - mtodo 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 opcin no es vlida. 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

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 vlido. ) ; } 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 vlida. ) ; } 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 vlida ) ; } 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
Contina
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 vlida. ) ; } 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 aos. ) ; System.out.println ( Hay + mayores + alumno(s) mayor(es) de 18 aos. ) ; 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 - Descripcin del problema. Desarrollar una solucin que permita ingresar un nmero por teclado. Mostrar el nmero con las cifras invertidas, el nmero de cifras que tiene el nmero, la suma de las cifras, el nmero de cifras pares e impares, y si el nmero es capicua o no. Etapa 04 - Desarrollo de la Codificacin.
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 nmero 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 nmero invertido es : + numInv ) ; System.out.println ( El nmero de cifras es : + cont ) ; System.out.println ( La suma de las cifras es : + suma ) ; System.out.println ( El nmero de cifras pares es : + contPar ) ; System.out.println ( El nmero de cifras impares es : + contImp ) ; if ( num == numInv ) System.out.println ( El nmero es capicua ) ; else System.out.println ( El nmero no es capicua ) ; } }
En base al anlisis de la codificacin desarrolle la Etapa 02 y la Etapa 03 del mtodo.
Pag. 181
Problema 24 Etapa 01 - Descripcin del problema. Desarrollar un programa que permita ingresar el da, el mes y el ao de una determina fecha. Determinar si la fecha ingresada es correcta y si el ao es bisiesto o no. Etapa 04 - Desarrollo de la Codificacin.
Clase PrgVerificaFecha
package dominioDeLaAplicacion; /** Clase: PrgVerificaFecha.java * Dada una fecha en dia, mes y ao se determina si esta correcta la fecha y si * es ao bisiesto * Un ao es bisiesto si es mltiplo de 4, por ejemplo 1984, pero los aos * mltiplos de 100 slo son bisiestos cuando a su vez son mltiplos 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, ao ; boolean verifdia = false, bisiesto = false ; String mess = ; System.out.println ( Ingrese el nmero del da: ) ; dia = Lectura.leerInt ( ) ; System.out.println ( Ingrese el nmero del mes: ) ; mes = Lectura.leerInt ( ) ; System.out.println ( Ingrese el ao: ) ; ao = Lectura.leerInt ( ) ; // verifica ao bisiesto if ( ao % 4 == 0 && ao % 100 != 0 || ao % 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
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 ) && ( ao > 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
case 10 : mess = Octubre ; break ; case 11 : mess = Noviembre ; break; case 12 : mess = Diciembre ; break ; } System.out.println ( dia + de + mess + de + ao ) ; if ( bisiesto ) { System.out.println ( Es ao bisiesto ) ; } else { System.out.println ( No es ao bisiesto ) ; } } else { System.out.println ( error en fecha ) ; } } }
Pag. 184
Problema 25 Etapa 01 - Descripcin del problema. Desarrollar un programa que permita ingresar un nmero arbico entre 1000 y 3000. Determinar y mostrar el equivalente del nmero ingresado en nmero romano. Etapa 04 - Desarrollo de la Codificacin.
Clase PrgNumRomano
package dominioDeLaAplicacion ; /** Clase: PrgNumRomano.java * Dado un ao en nmeros arbigos, imprimirlo en nmeros romanos dentro de * rango de 1000 a 3000 * Programacin Bsica */ 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 nmero 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 nmero 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 nmero romano System.out.println ( Arbigo + = + romano ) ; } else { System.out.println ( " Nmero ingresado no vlido " ) ; } } }
Pag. 187
Problema 26 Etapa 01 - Descripcin del problema. Desarrollar un programa que permita ingresar un nmero entero menor que 100 y permita mostrar su equivalente en letras. Etapa 04 - Desarrollo de la Codificacin.
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 nmero entero menor que 100: ) ; num = Lectura.leerInt ( ) ; if ( num < 0 || num > 99 ) System.out.println ( Nmero ingresado no vlido... 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
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
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 nmero + num + en letras es + letra ) ; } }
Pag. 190
Problema 27 Etapa 01 - Descripcin del problema. En base al programa anterior, desarrollar otro programa que permita ingresar un nmero entero menor que 1000 y permita mostrar su equivalente en letras. Etapa 04 - Desarrollo de la Codificacin.
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 nmero entero menor que 1000: ) ; num = Lectura.leerInt ( ) ; if ( num < 0 || num > 999 ) System.out.println ( Nmero ingresado no vlido... 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
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
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
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 nmero + num + en letras es + letra ) ; } }
Pag. 194
MANEJO DE EXCEPCIONES Cuando se est ejecutando un programa y ocurre un error, Java lanza una excepcin que cuando no se captura da lugar a un mensaje sobre lo ocurrido y detiene la ejecucin del programa (es importante establecer que las excepciones se lanzan, no ocurren). Ahora, si se desea que la ejecucin del programa no se detenga, se deber capturar la excepcin 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 excepcin en un programa, por ejemplo, una entrada incorrecta de datos (IOException), una divisin por cero (ArithmeticException) o una conversin de datos no vlida (NumberFormatException). Para evitar que la ejecucin de un programa se detenga debido a un error que lanza una excepcin, se debe utilizar la sentencia try para alertar al programa acerca del cdigo 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:
try { // Cdigo de la aplicacin. } catch ( ) { // Cdigo de tratamiento de la excepcin. }
Tipo de excepcin capturada por la sentencia catch con la finalidad de manejarla.
Significa: Intentar ejecutar las sentencias ubicadas entre las llaves del try y si ocurre un error y se lanza una excepcin capturarla con la sentencia catch y manejarla con las sentencias ubicadas entre las llaves del catch.
Pag. 195
Esto significa que durante la ejecucin del programa normalmente se ejecutarn las sentencias que estn dentro de las llaves de la sentencia try:
try { // Cdigo de la aplicacin. }
Si no ocurre un error, no se lanzar ninguna excepcin, lo que significa que las sentencias que estn entre las llaves de la sentencia catch no se ejecutarn. Si ocurre un error, se lanzar una excepcin, interrumpindose la ejecucin de las sentencias que estn entre las llaves de la sentencia try y se ejecutarn las sentencias que estn entre las llaves de la sentencia catch, siempre y cuando se haya especificado capturar la excepcin lanzada. Como se ha indicado, existen diferentes tipos de excepciones por lo que es comn observar en un programa una sentencia try con varias sentencias catch. Cada sentencia catch capturar y manejara un excepcin.
try { /* Cdigo de la aplicacin que se prevee que puedan lanzar una excepcin.*/ } catch ( ArithmeticException e ) { /* Cdigo de tratamiento de ArithmeticException. */ } catch ( NumberFormatException e ) { /* Cdigo de tratamiento NumberFormatException. */ } de la excepcin
la
excepcin
En el ejemplo anterior, se ha especificado capturar dos excepciones en caso de que ests 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 explcitamente el cdigo que maneja los errores del cdigo bsico de una aplicacin. En la actualidad, se considera como buen estilo de programacin el uso de las excepciones en los programas. Como ejemplo de excepciones se puede mencionar:
Excepcin ArithmeticException
Descripcin Una condicin aritmtica excepcional ocurrio. Se intent convertir una cadena con un formato inapropiado a un nmero. Problemas al realizar operaciones de entrada y salida de datos. Un arreglo fu accedido con un ndice ilegal (fuera de los lmites permitidos). Se intent utilizar null donde se requera un objeto.
NumberFormatException
IOException
ArrayIndexOutOfBoundException
NullPointerException
Pag. 197
Problema 28 Etapa 01 - Descripcin del problema. Desarrollar una solucin que permita ingresar dos nmeros enteros. Mostrar el resultado de dividir ambos nmeros. Se debe tener en cuenta que existe la posibilidad que el divisor sea igual a cero. Etapa 04 - Desarrollo de la Codificacin.
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 divisin es: + rpta ) ; } }
Ejecute el siguiente programa e ingrese cero al divisor. Al momento de realizar la divisin se lanzar la excepcion llamada ArithmeticException debido a que no se puede dividir un nmero entero entre cero, finalizando la ejecucin del programa. Para evitar que el programa finalice es necesario manejar dicha excepcin. Intente incluir en el programa anterior el manejo de la excepcin 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 divisin es: + rpta ) ; } catch ( ArithmeticException e ) { System.out.println ( No se puede dividir un nmero entre cero ) ; } } }
Pag. 199
Problema 29 Etapa 01 - Descripcin del problema. Desarrollar una solucin 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 vlida. Manejar excepciones. Etapa 04 - Desarrollo de la Codificacin.
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 vlida ) ; valido = true ; } else { tmp = hora.substring ( 3, 5 ) ; mm = Integer.parseInt ( tmp ) ; if (mm < 0 || mm > 59) { System.out.println ( minuto ingresado no vlido ) ; valido = true ; } else { tmp = hora.substring ( 6 ) ; ss = Integer.parseInt ( tmp ) ; if (ss < 0 || ss > 59) { System.out.println ( segundo ingresado no vlido ) ; 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 excepcin NumberFormatException para prevenir que no se intente convertir una cadena con un formato inapropiado a un nmero. 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 nmeros. Para poder entender la solucin del programa sugiero que revise en el siguiente captulo la clase Integer (Clase Wrapper) y la clase String.
Pag. 201
Problema 30 Etapa 01 - Descripcin del problema. Desarrollar una solucin 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 Codificacin.
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, ao ; 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 ) ; ao = 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 segn 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 ao ) ; // Contina la validacin de la fecha... ver problema 24 y 127. } }
En este programa se captura la excepcin NumberFormatException para prevenir que no se intente convertir una cadena con un formato inapropiado a un nmero. 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 nmeros (inclusive en el lugar del / ). Para poder entender la solucin del programa sugiero que revise en el siguiente captulo la clase Integer (Clase Wrapper) y la clase String.
Pag. 203
Problema 31 Etapa 01 - Descripcin del problema. Desarrollar una solucin que permita ingresar dos nmeros de tres digitos en una variable de tipo texto o cadena con el siguiente formato: nnn//nnn. Validar que los nmeros sean de tres cifras y mostrar la divisin de los mismos. Manejar excepciones. Etapa 04 - Desarrollo de la Codificacin.
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 nmeros 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 divisin es: + resultado ) ; } else { valido = true ; }
Pag. 204
Clase PrgNumeroConExcepcion
} catch ( NumberFormatException error ) { System.out.println ( Formato no vlido ) ; valido = true ; } catch ( ArithmeticException error ) { System.out.println ( No se puede dividir un nmero 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 excepcin NumberFormatException para prevenir que no se intente convertir una cadena con un formato inapropiado a un nmero. Puede probar el programa ingresando como nmeros lo siguiente: aaa//123 Es decir, en cualquier parte del formato indicado, ingrese letras en lugar de nmeros (inclusive en el lugar de las // ). Tambin se captura la excepcin ArithmeticException para prevenir que no se intente dividir los nmeros cuando el segundo nmero es cero. Puede probar el programa ingresando como nmeros lo siguiente: 123//000 Para poder entender la solucin del programa sugiero que revise en el siguiente captulo la clase Integer (Clase Wrapper) y la clase String.
Pag. 205
Pag. 206
DESARROLLO DE LAS CAPACIDADES LGICAS
Cuando un estudiante se inicia en el estudio de la programacin, es necesario que comprenda los conceptos fundamentales relacionados a las estructuras lgicas y las estructuras de datos elementales, con la finalidad de utilizarlas en forma conjunta y lograr desarrollar sus capacidades lgicas. El desarrollo de las capacidades lgicas se logra con la prctica. Es decir, desarrollando soluciones y codificndolas en un lenguaje de programacin determinado, como por ejemplo el lenguaje de programacin Java, lenguaje de programacin 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 captulo. 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 Descripcin del problema. Desarrollar la codificacin de una solucin que permita mostrar la siguiente figura:
* * * * *
* * * * *
* * * * *
* * * * *
* * * * *
Nota: En la figura mostrada el nmero de filas = 5. Asuma que el nmero de filas puede variar desde 2 hasta 20 y que entre los asteriscos no existen espacios en blanco.
Etapa 04 Desarrollo de la codificacin. 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 nmero de filas de la figura ) ; System.out.print ( Valores vlidos desde 2 hasta 20: ) ; totalFilas = Lectura.leerInt ( ) ; if (totalFilas < 2 || totalFilas > 20 ) { System.out.print ( Valor de fila no vlido 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 lnea. System.out.println ( ) ; } } }
Pag. 209
Anlisis de la solucin:
Se ingresa el nmero 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 explicacin asumiremos que el valor de totalFilas=5. Entonces, la condicin de la primera sentencia for va ser verdadera para valores de i=1 hasta i=totalFilas (en el caso de totalFilas=5; los valores vlidos para i son i=1, i=2, i=3, i=4 e i=5). Los valores vlidos de i coinciden con el nmero 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 nmero determinado de asteriscos en cada una de las filas y ese nmero de asteriscos a mostrar coincide con el nmero de filas de la figura (para nuestro caso totalFilas=5). Esta situacin 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 nmero 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 lnea y continuar con la ejecucin de la solucin siempre y cuando la condicin del primer for sea verdadera. Los siguientes 2 problemas son una variacin de este problema. Analice sus respectivas soluciones y desarrolle sus propias observaciones.
Pag. 210
1 2 3 4 5 1 2 3 4 5 1 2 3 4 5 1 2 3 4 5 1 2 3 4 5 Nota: En la figura mostrada el nmero de filas = 5. Asuma que el nmero de filas puede variar desde 2 hasta 9 y que entre los nmeros no existen espacios en blanco.

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 nmero de filas de la figura ) ; System.out.print ( Valores vlidos desde 2 hasta 9: ) ; totalFilas = Lectura.leerInt ( ) ; if (totalFilas < 2 || totalFilas > 9 ) { System.out.println ( Valor de fila no vlido 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 lnea. System.out.println ( ) ; } } }
Pag. 211
1 1 1 1 1 2 2 2 2 2 3 3 3 3 3 4 4 4 4 4 5 5 5 5 5 Nota: En la figura mostrada el nmero de filas = 5. Asuma que el nmero de filas puede variar desde 2 hasta 9 y que entre los nmeros no existen espacios en blanco.

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 nmero de filas de la figura ) ; System.out.print ( Valores vlidos desde 2 hasta 9: ) ; totalFilas = Lectura.leerInt ( ) ; if (totalFilas < 2 || totalFilas > 9 ) { System.out.println ( Valor de fila no vlido 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 lnea. System.out.println ( ) ; } } }
Pag. 212
Los ltimos dos problemas son una variacin del problema 32, en el cul se desarrolla la siguiente figura:
* * * * *
* * * * *
* * * * *
* * * * *
* * * * *
Con la finalidad de mejorar sus capacidades lgicas sugiero que desarrolle las siguientes variaciones del problema:
1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5
5 4 3 2 1 5 4 3 2 1 5 4 3 2 1 5 4 3 2 1 5 4 3 2 1
5 5 5 5 5 4 4 4 4 4 3 3 3 3 3 2 2 2 2 2 1 1 1 1 1
Pag. 213
* * * * *
* * * * * * * * * *
Etapa 04 Desarrollo de la codificacin. 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 nmero de filas de la figura ) ; System.out.print ( Valores vlidos desde 2 hasta 20: ) ; totalFilas = Lectura.leerInt ( ) ; if (totalFilas < 2 || totalFilas > 20 ) { System.out.println ( Valor de fila no vlido 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 lnea. System.out.println ( ) ; } } }
Pag. 214
Se ingresa el nmero 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 explicacin asumiremos que el valor de totalFilas=5. Entonces, la condicin de la primera sentencia for va ser verdadera para valores de i=1 hasta i=totalFilas (en el caso de totalFilas=5; los valores vlidos para i son i=1, i=2, i=3, i=4 e i=5). Los valores vlidos de i coinciden con el nmero 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:
* * * * *
* * * * * * * * * *
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 situacin 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 vlido para j sera j=1, por lo que el for interno se ejecutara una sola vez y se mostrara solo un asterisco. Finalizada la ejecucin del for interno, la sentencia System.out.println ( ); nos permite hacer un salto de lnea. 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 vlidos para j seran j=1 y j=2, por lo que el for interno se ejecutara dos veces y en cada una de las ejecuciones del for interno se mostrara dos asterisco (en consecuencia se mostraran en total dos asteriscos). Finalizada la ejecucin del for interno, la sentencia System.out.println ( ); nos permite hacer un salto de lnea. 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 vlidos para j seran j=1, j=2, j=3, j=4 y j=5, por lo que el for interno
Pag. 215
se ejecutara cinco veces y en cada una de las ejecuciones del for interno se mostrara un asterisco (en consecuencia se mostraran en total cinco asteriscos). Luego se hace un salto de linea y se finaliza la ejecucin. Los siguientes 7 problemas son una variacin de este problema. Analice sus respectivas soluciones y desarrolle sus propias observaciones.
Pag. 216
1 1 2 1 2 3 1 2 3 4 1 2 3 4 5 Nota: En la figura mostrada el nmero de filas = 5. Asuma que el nmero de filas puede variar desde 2 hasta 9 y que entre los nmeros no existen espacios en blanco.

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 nmero de filas de la figura ) ; System.out.print ( Valores vlidos desde 2 hasta 9: ) ; totalFilas = Lectura.leerInt ( ) ; if (totalFilas < 2 || totalFilas > 9 ) { System.out.println ( Valor de fila no vlido 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 lnea. System.out.println ( ) ; } } }
Pag. 217

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 nmero de filas de la figura ) ; System.out.print ( Valores vlidos desde 2 hasta 9: ) ; totalFilas = Lectura.leerInt ( ) ; if (totalFilas < 2 || totalFilas > 9 ) { System.out.println ( Valor de fila no vlido 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 lnea. System.out.println ( ) ; } } }
Pag. 218

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 nmero de filas de la figura ) ; System.out.print ( Valores vlidos desde 2 hasta 9: ) ; totalFilas = Lectura.leerInt ( ) ; if (totalFilas < 2 || totalFilas > 9 ) { System.out.println ( Valor de fila no vlido 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 lnea. System.out.println ( ) ; } } }
Pag. 219

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 nmero de filas de la figura ) ; System.out.print ( Valores vlidos desde 2 hasta 9: ) ; totalFilas = Lectura.leerInt ( ) ; if (totalFilas < 2 || totalFilas > 9 ) { System.out.println ( Valor de fila no vlido 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 lnea. System.out.println ( ) ; } } }
Pag. 220

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 nmero de filas de la figura ) ; System.out.print ( Valores vlidos desde 2 hasta 9: ) ; totalFilas = Lectura.leerInt ( ) ; if (totalFilas < 2 || totalFilas > 9 ) { System.out.println ( Valor de fila no vlido 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

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 nmero de filas de la figura ) ; System.out.print ( Valores vlidos desde 2 hasta 20: ) ; totalFilas = Lectura.leerInt ( ) ; if (totalFilas < 2 || totalFilas > 20 ) { System.out.println ( Valor de fila no vlido 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

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 nmero de filas de la figura ) ; System.out.print ( Valores vlidos desde 2 hasta 9: ) ; totalFilas = Lectura.leerInt ( ) ; if (totalFilas < 2 || totalFilas > 9 ) { System.out.println ( Valor de fila no vlido 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 variacin del problema 35, en el cul se desarrolla la siguiente figura:
* * * * *
* * * * * * * * * *
Con la finalidad de mejorar sus capacidades lgicas sugiero que desarrolle las siguientes figuras y sus respectivas variaciones:
* * * * * * * * * * * * * * *
* * * * *
* * * *
* * *
* *
* *
* * *
* * * *
* * * * *
Pag. 224
* * * * * * * * * *
* * * * *

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 nmero de filas de la figura ) ; System.out.print ( Valores vlidos desde 2 hasta 20: ) ; totalFilas = Lectura.leerInt ( ) ; if (totalFilas < 2 || totalFilas > 20 ) { System.out.println ( Valor de fila no vlido 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 solucin anterior (en lugar de usar tres sentencias for utilice solo dos), sino lo consigue analice la siguiente solucin.
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 nmero de filas de la figura ) ; System.out.print ( Valores vlidos desde 2 hasta 20: ) ; totalFilas = Lectura.leerInt ( ) ; if (totalFilas < 2 || totalFilas > 20 ) { System.out.println ( Valor de fila no vlido 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 nmero de filas de la figura ) ; System.out.print ( Valores vlidos desde 2 hasta 20: ) ; totalFilas = Lectura.leerInt ( ) ; if (totalFilas < 2 || totalFilas > 20 ) { System.out.println ( Valor de fila no vlido 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 solucin 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 solucin:
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 nmero de filas de la figura ) ; System.out.print ( Valores vlidos desde 2 hasta 20: ) ; totalFilas = Lectura.leerInt ( ) ; if (totalFilas < 2 || totalFilas > 20 ) { System.out.print ( Valor de fila no vlido 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 nmero de filas = 5. Asuma que el nmero de filas puede variar desde 2 hasta 20 y que entre los asteriscos existe un espacio en blanco.

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 nmero de filas de la figura ) ; System.out.print ( Valores vlidos desde 2 hasta 20: ) ; totalFilas = Lectura.leerInt() ; if (totalFilas < 2 || totalFilas > 20 ) { System.out.println ( Valor de fila no vlido 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 nmero 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 explicacin 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 nmero de filas de la figura. Cada vez que se ejecuta el primer for debemos asegurarnos de mostrar los asteriscos necesarios. Para fila=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 ubicacin de los asteriscos en cada fila, lo cual nos complica la lgica de nuestra solucin. Es necesario encontrar algunos parmetros para establecer una constante matemtica (una relacin matemtica) que nos permita mostrar adecuadamente la figura. Ahora, para realizar un mejor anlisis se va ha representar los espacios en blanco de la figura con un guin (esto para visualizar la cantidad de espacios en blanco necesarios en cada fila):
* -
* *
* * -
* * *
* - * * - * - * - *
Nota: Los guiones representan espacios en blanco. Entre un guin y un asterisco no hay ningn smbolo.
Ahora realizaremos una divisin imaginaria en la figura y separaremos los espacios en blanco que estn a la izquierda del primer asterisco de cada fila:
- - - - - - * - - * - * - * * - * -
* * *
* - * * - * - * - *
Nota: Se determina que existe una relacin en la parte donde estn 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 ningn espacio en blanco.
Pag. 230
En la parte que tiene los asteriscos y espacios en blanco entre los asteriscos, es necesario buscar una relacin matemtica. Para esto, incluiremos un espacio en blanco al final de cada una de las filas de la figura:
- - - - - - * - - * - * - * * - * -
* * *
* * -
* - * * - * -
Nota: Se determina que existe una relacin en la parte donde estn 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 estn antes del primer asterisco de cada una de las filas. Para fila=5:
- - - - - - -
for ( j = 1 ; j < totalFilas ; j++ ) { System.out.print ( ) ; }
El segundo for interno nos permite mostrar los asteriscos y espacios en blanco que estn despus de cada uno de los asteriscos en cada una de las filas: Para fila=5:
* * * - * * - * -
* * *
* * -
* - * * - * -
for ( j = 1 ; j <= i ; j++ ) { System.out.print ( * ) ; }
Intente mejorar la solucin anterior (en lugar de usar tres sentencias for utilice solo dos), sino lo consigue analice la siguiente solucin.
Pag. 231
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 nmero de filas de la figura ) ; System.out.print ( Valores vlidos desde 2 hasta 20: ) ; totalFilas = Lectura.leerInt() ; if (totalFilas < 2 || totalFilas > 20 ) { System.out.println ( Valor de fila no vlido 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 ( ) ; } } }
Anlisis de la solucin: Imagnese ahora al tringulo como si este fuera un rectngulo (complete con guiones los espacios en blanco que tendra la figura si fuera un rectngulo). 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 guin y un asterisco no hay ningn smbolo.
Pag. 232
El primer for controla el nmero 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 nmero de smbolos (asteriscos o espacios en blanco) que se van a mostrar (en total se deben mostrar totalFilas * 2 1 smbolos). En el for interno hay una sentencia if que nos permite determinar el smbolo 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 solucin. Utilice el primer planteamiento desarrollado. Analice nuevamente el siguiente grfico:
* -
* *
* * -
* * *
* * -
* - * * - * -
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 ( ) ; }
Tambin:
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 lgicas 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). Relacin: el nmero de asteriscos a mostrar en cada fila esta dado por la frmula: totalFilas * 2 - 1.
// Se muestra la ltima parte de la solucin: 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 repeticin 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 Codificacin. 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 solucin del problema y anote sus conclusiones. Intente resolverlo utilizando la sentencia for de Java.
Pag. 236
1 2 3 4 3 2 1 4 3 2 3 4 3 2 3 4 Nota: la figura mostrada es un rombo de nmero. Ingresar un valor entero desde 2 hasta 9 que representa el nmero de elementos de la fila central. En la figura el dato = 4.
Etapa 04 - Desarrollo de la Codificacin. 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 nmeros ) ; System.out.print ( Ingrese el nmero mximo 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 solucin utilizando la estructura de repeticin while en lugar de la estructura for.
Con la finalidad de mejorar sus capacidades lgicas 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 7 2 5 7 3 8 3 6 8 4 9 4 5 9 5 1 3 6 1 6
A continuacin se presentan diversas soluciones que permitirn contribuir con el desarrollo de sus capacidades lgicas. 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 nmero de filas = 5. Asuma que el nmero de filas puede variar desde 2 hasta 15.
Etapa 04 - Desarrollo de la Codificacin. 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 Codificacin. 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 tringulo de asteriscos: ) ; System.out.print ( Ingrese el lado del tringulo 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 Codificacin. 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 tringulo hueco de base impar \n ) ; System.out.print ( Ingrese la base impar del tringulo 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 Codificacin. 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 Codificacin. 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 nmero par con un valor desde 4 hasta 18. En la figura el lado = 4.
Etapa 04 - Desarrollo de la Codificacin. 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 (nmero 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 nmero 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 Codificacin. 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 tringulos de asteriscos ); System.out.print ( frente a frente a sus hipotenusas \n ) ; System.out.print ( Ingrese el lado del tringulo 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 Codificacin. 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 tringulos de asteriscos, ) ; System.out.print ( frente a frente a sus catetos \n ) ; System.out.print ( Ingrese la base del tringulo 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 ingresarn por teclado. La base deber ser mayor que la altura. En la figura la base=10 y altura=5.
Etapa 04 - Desarrollo de la Codificacin. 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 rectngulo hueco de base > alto \n ) ; System.out.println ( Para generar el rectngulo hueco en pantalla la base ) ; System.out.print ( debe ser >2 y el alto>1 \n ) ; System.out.print ( Ingrese la base del rectngulo: ) ; 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 rectngulo...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 Descripcin del problema. Desarrollar la codificacin de una solucin que permita mostrar en pantalla la tabla de multiplicar de los 12 primeros nmeros 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 codificacin.

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 solucin y modifquela de tal forma que el usuario ingrese la cantidad de nmeros que debe incluir la tabla de multiplicacin. Asegrese de establecer los valores vlidos para dicha tabla de multiplicar.
Pag. 250
Etapa 04 Desarrollo de la codificacin. 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 solucin y modifquela de tal forma que el usuario ingrese la cantidad de filas y columnas que debe tener la figura. Asegrese de establecer los valores vlidos para dichos datos.
Pag. 251
Etapa 04 Desarrollo de la codificacin. 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 solucin y modifquela de tal forma que el usuario ingrese la cantidad de cuadrados que debe tener la figura. Asegrese de establecer los valores vlidos para dicho dato.
Pag. 252
Etapa 04 Desarrollo de la codificacin. 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 solucin y modifquela 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 7 6 4 - 2 0 2 - 8 - 7 3
1 - 3 - 6 - 0 - 5 - 9 - 4 - 2 - 9 - 8 - 4 5 - 5 - 3 - 1
Nota; Tenga presente que los guiones (-) en las figuras representan espacios en blanco.
Pag. 254
Pag. 255
Pag. 256
Clases Bsicas Incorporadas en el Lenguaje de Programacin Java
Captulo
Temas:
Introduccin. El paquete del lenguaje Java: java.lang Envoltorios de tipos de datos primitivos: Wrappers
Introduccin. Mtodos. Problemas resueltos.
Funciones matemticas: Clase Math

Manejo de cadenas: Clase String

Otras clases en Java
CLASES BSICAS INCORPORADAS EN EL LENGUAJE DE PROGRAMACIN JAVA
CAPTULO III CLASES BSICAS INCORPORADAS EN EL LENGUAJE DE POGRAMACION JAVA INTRODUCCIN Un algoritmo constituye una lista completa de pasos secuenciales y una descripcin de los datos que dichos pasos deben manipular para resolver un determinado problema. La lista de pasos se desarrolla utilizando las estructuras lgicas y las instrucciones o sentencias de bifurcacin y estn contenidas en los mtodos, mientras que los datos se almacenan en las estructuras de datos.
MARCO DE TRABAJO
Pag. 259
SE DESARROLLAN UTILIZANDO: Estructuras lgicas de secuencia. Estructuras lgicas de decisin. Estructuras lgicas de repeticin. Instrucciones de bifucacin. TAMBIN: Clases incorporadas en el lenguaje de programacin utilizado.
ALMACENADOS EN: Estructuras de datos tipo variables.
Los algoritmos son desarrollados dentro de los mtodos. Es decir, todo programa en Java est contenido en uno o mas mtodos, siendo el mtodo main( ), el mtodo principal que tiene como funcin iniciar la ejecucin de una aplicacin desarrollada en Java. El lenguaje de programacin Java contiene diversas clases preprogramadas, es decir, contiene una gran variedad de clases, con mtodos y atributos, que tienen diferentes funciones y estn agrupadas por medio de paquetes.
Pag. 260
El presente captulo, trata sobre las clases bsicas incorporadas en el lenguaje de 1 programacin Java, agrupadas en el paquete java.lang. Es importante mencionar que utilizando las clases preprogramadas de Java se puede ahorrar mucho tiempo y esfuerzo de programacin, construyendo fcilmente aplicaciones profesionales.
2
Paquete: Conjunto de clases similares. Un paquete permiten organizar las clases. Un paquete contiene clases que tienen funciones similares. Clase: Coleccin de objetos del mismo tipo. Una clase es una implantacin de un tipo de objeto, especifica una estructura para almacenar los atributos y los mtodos operativos permisibles que se aplican a cada uno de sus objetos (comparten datos o atributos y mtodos comunes). El mundo real se modela mediante clases. Una clase es una abstraccin y no referencia a ningn objeto en particular.
2
Pag. 261
Pag. 262
EL PAQUETE DEL LENGUAJE JAVA El paquete del lenguaje Java, conocido tambin como java.lang, es uno de los paquetes ms 3 importantes de la API de Java, y contiene las clases que constituyen el corazn del lenguaje de programacin 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 automticamente 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 estndar, clases para 5 manipular cadenas de caracteres, una clase que proporciona mtodos correpondientes a las funciones matemticas, etc. Entre las clases ms importantes estn las siguientes:
Boolean Byte Character Class ClassLoader Compiler
Double Float Integer Long Math Number
Object Package Process Runtime Short String
StringBuffer System Thread Trowable
API: Aplication Program Interface. Una API es un conjunto de normas que determinan como debe usarse una determinada funcin de un lenguaje de programacin en una aplicacin.
Objetos: Modelos de entes del mundo. Un objeto de software es cualquier cosa, real o abstracta, acerca del cual almacenamos datos y los mtodos que controlan dichos datos.
Mtodos: Desarrollo de algoritmos. Los mtodos 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 mtodos se desarrollan o codifican los algoritmos.
Pag. 263
Entre las clases a tratar en el presente captulo 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 excepcin 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 mtodos correspondientes a las funciones matemticas bsicas. Math.
3. Clase que proporciona los objetos necesarios para manipular y tratar cadenas de caracteres. String.
Herencia: Subclase y Superclase. La Herencia es uno de los conceptos ms importantes de la Programacin 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 mtodos 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 mtodos 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 mtodos de una clase.
Pag. 264
En Java, los mtodos siempre estn dentro de una clase. Algunos mtodos pueden ser invocados o ejecutados utilizando directamente el nombre de la clase en la cual estn definidos, tal es el caso de los mtodos de la clase Math de Java. Estos mtodos son conocidos como mtodos estticos o de clase. Por otro lado, otros mtodos son invocados o ejecutados utilizando un objeto o instancia de la clase en la cual estn definidos, tal es el caso de los mtodos de la clase String de Java. Estos mtodos son conocidos como mtodos de instancia o de objeto.
8
Instancia: Representacin 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 representacin real de una clase.
Pag. 265
Pag. 266
ENVOLTORIOS DE LOS TIPOS DE DATOS PRIMITIVOS: CLASES WRAPPERS INTRODUCCIN Los tipos de datos primitivos (boolean, byte, char, double, float, int, long, short), conocidos tambin como tipos de datos simples, son los nicos elementos del lenguaje de programacin Java que se representan internamente a travs de valores, tal y como se representan en un lenguaje de programacin convencional. Esto significa que los tipos de datos primitivos no son objetos y se sitan fuera de la 9 jerarqua 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 jerarqua de clases. Dichas clases son conocidas como las clases wrappers (envoltorios). Los wrappers son clases diseadas para ser un complemento de los tipos de datos primitivos y proporcionan mtodos para realizar diferentes tareas con los tipos de datos primitivos, tales como la conversin con cadenas de caracteres, comprobacin, traslacin, 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 continuacin: TIPO DE DATO PRIMITIVO
boolean byte char double float int Long
CLASES WRAPPERS
Boolean Byte Character Double Float Integer Long
Jerarqua de clases: Forma de ordenar las clases. La jerarqua de clases es una forma de ordenar las clases existentes en un lenguaje de Programacin Orientado a Objetos (POO). Una jerarqua de clases define conceptos abstractos en la parte superior de la jerarqua y conforme se desciende en la jerarqua los conceptos se tornan cada vez ms concretos. Java tiene su propia jerarqua de clases, estando en la parte superior de la jerarqua, 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 excepcin de Character), tienen un mtodo que permite convertir desde una cadena (String) al tipo primitivo. Simplemente hay que ejecutar el mtodo de la clase wrappers adecuada y el String se convierte al tipo de dato primitivo asociado.
JERARQUA DE CLASES Y HERENCIA java.lang.Object
java.lang.Boolean
java.lang.Character
java.lang.Number
Byte
Double
Float
Integer
Long
Short
Las clases Java, en general, tienen mtodos estticos y mtodos de instancia. Para ejecutar un mtodo de instancia es necesario crear un objeto de la clase donde est definido dicho mtodo. Para crear un objeto en Java se usa la sentencia new (a excepcin 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 mtodos para manipular dicho valor.
Pag. 268
MTODOS Con la finalidad de resumir los mtodos de las clases wrappers que permiten la conversin, comprobacin y traslacin de datos, se utilizarn algunos objetos de dichas clases. Se asume que los objetos han sido creados previamente. Dichos objetos son: CLASE AL QUE PERTENECE
String Integer Long Float Double Character
OBJETO
S I L F D C
Tambin se utilizarn algunas variables para lo cual se deber asumir que dichas variables han sido declaradas previamente. Las variables son: VARIABLE
i l f d b c
TIPO DE DATO PRIMITIVO

int long float double boolean char
Para referirnos a objetos se utilizar una letra en mayscula, mientras que, para referirnos a las variables se utilizar una letra minscula.
Pag. 269
Conversin 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 conversin, 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). Conversin de tipo de dato primitivo a objeto String utilizando clases wrappers y variables: OBJETO STRING
S S S S = = = =
CLASES WRAPPERS Y VARIABLES

Integer.toString (i ) ; Long.toString ( l ) ; Float.toString ( f ) ; Double.toString ( d ) ;
Observe que se utiliza el mtodo toString ( ) para convertir el valor de una variable a un valor de tipo cadena contenido en un objeto String. El mtodo toString ( ) es un mtodo esttico o de clase por que se utiliza directamente el nombre de la clase para ejecutar el mtodo.
Conversin de tipo de dato primitivo a objeto String utilizando objetos wrappers: OBJETO STRING
S S S S = = = =
OBJETOS WRAPPERS
I.toString ( ) ; L.toString ( ) ; F.toString ( ) ; D.toString ( ) ;
Observe que se utiliza el mtodo 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 mtodo toString ( ) es un mtodo esttico o de clase, tambin puede ejecutarse utilizando un objeto.
Pag. 270
Todas las clases wrappers tienen en comn el mtodo esttico o de clase toString ( ). Esto se debe, a que este mtodo no pertenece a dichas clases, sino que pertenece a la clase Object. La clase Object es la clase principal en la Jerarqua de Clases de Java (se puede decir que es la clase padre de todas las clases). Todas las clases en Java pueden utilizar los mtodos definidos en la clase Object (debido fundamentalmente a la herencia), y uno de los mtodos definidos en esta clase, como ya se ha mencionado, es el mtodo toString ( ). | Conversin 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.
Conversin de objetos String a tipos de dato primitivo, utilizando clases wrappers y objeto String: VARIABLE
i l f d = = = =
WRAPPERS Y OBJETO STRING

Integer.valueOf (S) ; Integer.parseInt (S) ; Long.valueOf (S) ; Long.parseLong (S) ; Float.valueOf (S) ; Float.parseFloat (S) ; Double.valueOf (S) ; Double.parseDouble (S) ;
Observe que se utiliza el mtodo valueOf ( ) para convertir el valor contenido en el objeto String S, a un dato de tipo primitivo o valor de una variable. Este mtodo es un mtodo esttico o de clase. Tambin se tiene la posibilidad de utilizar los mtodos parseInt ( ), parseLong ( ), parseFloat ( ) y parseDouble ( ) para los wrappers Integer, Long, Float y Double respectivamente.
Pag. 271
Conversin 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.
Conversin de objetos wrappers a tipos de dato primitivo, utilizando clases wrappers: VARIABLE CLASES WRAPPERS
I.intValue ( ) ; L.intValue ( ) ; F.intValue ( ) ; D.intValue ( ) ; I.longValue ( ) ; L.longValue ( ) ; F.longValue ( ) ; D.longValue ( ) ; I.floatValue ( ) ; L.floatValue ( ) ; F.floatValue ( ) ; D.floatValue ( ) ; I.doubleValue ( ) ; L.doubleValue ( ) ; F.doubleValue ( ) ; D.doubleValue ( ) ;
Observe que todas las clases wrappers tienen en comn los mtodos de instancia intValue ( ), longValue ( ), floatValue ( ) y doubleValue ( ).
Todas las clases wrappers tienen en comn los mtodos de instancia intValue( ), longValue( ), floatValue( ) y doubleValue( ). Estos mtodos pertenecen en realidad a la clase Number. La clase Number es la superclase de las clases wrappers (a excepcin de la clase wrapper Character). Estas clases pueden utilizar los mtodos definidos en la clase Number a travs de la herencia.
Pag. 272
Comprobaciones del valor Not-a-Number
Comprobacin del valor Not-a-Number utilizando clases wrappers y variables: VARIABLE

b =

Float.isNaN ( f ) ; Double.isNaN ( d );
Comprobacin del valor Not-a-Number utilizando clases wrappers y variables: VARIABLE

b =
OBJETOS WRAPPERS
F.isNaN ( ) ; D.isNaN ( );
Observe que se utiliza el mtodo isNaN ( ) para determinar si la variable es o no un nmero. El mtodo devuelve true si el valor de la variable no es un nmero. Los valores Not-a-Number proceden de indeterminaciones tales como por ejemplo el resultado de la siguiente operacin: 0.0 / 0.0.
Comprobaciones del valor infinito
Comprobacin del valor infinito utilizando clases wrappers y variables: VARIABLE

b =

Float.isInfinite ( f ) ; Double.isInfinite ( d );
Pag. 273
Comprobacin del valor infinito utilizando objetos wrappers: VARIABLE

b =
OBJETOS WRAPPERS
F.isInfinite ( ) ; D.isInfinite ( );
Observe que se utiliza el mtodo isInfinite ( ) para determinar si la variable es o no un nmero infinito. El mtodo devuelve true si el valor de la variable es un nmero infinito. Los valores Infinite proceden normalmente de la divisin por cero de un valor finito. Por ejemplo el resultado de la siguiente operacin: 10.5 / 0.0.
Comprobaciones de caracteres
Comprobacin de caracteres utilizando la clase Character y variable tipo char: VARIABLE CLASE Character Y VARIABLE char
Devuelve true si el caracter es una letra minscula. Devuelve true si el caracter es una letra mayscula. Devuelve true si el caracter es un dgito decimal. Devuelve true si el caracter es un espacio en blanco.
Character.isLowerCase (c) ;
Character.isUpperCase (c) ; b = Character.isDigit (c) ;
Character.isSpace (c) ;
Pag. 274
Traslacin de caracteres
Traslacin de caracteres utilizando la clase Character y variable tipo char:
VARIABLE
CLASE Character y VARIABLE char

Convierte el caracter a una letra minscula. Convierte el caracter a una letra mayscula.
Character.toLowerCase (c); c = Character.toUpperCase (c);
Pag. 275
Problema 61 Etapa 01 - Descripcin 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 Codificacin.
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 mtodo 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) ms adelante en este mismo captulo.
Pag. 276
Problema 62 Etapa 01 - Descripcin 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 Codificacin.
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 aplicacin 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 mtodo toString ( ) de la clase String. Esta cadena de texto podr ser manipulada para obtener otros datos, tales como, el da, el mes, el ao actual o la hora del sistema. Analice como se pueden manipular las variables de tipo cadena (String) ms adelante en este mismo captulo.
Pag. 277
Problema 63 Etapa 01 - Descripcin del problema. Desarrollar un programa en Java que permita convertir una cadena en un nmero entero y en un objeto de tipo Integer. Calcular y mostrar la suma de ambos valores. Etapa 04 - Desarrollo de la Codificacin.
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 vlido para que pueda ser almacenado en un tipo de dato determinado. Puede utilizar el mtodo parseInt ( ) de la clase String para convertir una cadena en un nmero entero (numEntero) y tambin el mtodo valueOf ( ) de la clase Integer para convertir una cadena en un un objeto (objInteger) de la clase Integer. El mtodo 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 - Descripcin del problema. Desarrollar un programa en Java que permita convertir una cadena en un nmero real y en un objeto de tipo Double. Calcular y mostrar la suma de ambos valores. Etapa 04 - Desarrollo de la Codificacin.
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 vlido para que pueda ser almacenado en un tipo de dato determinado. Puede utilizar el mtodo parseDouble ( ) de la clase Double para convertir una cadena en un nmero real (numRealDoble) y tambin el mtodo valueOf ( ) de la clase Double para convertir una cadena en un un objeto (objDouble) de la clase Double. El mtodo 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 MATEMTICAS: CLASE MATH INTRODUCCIN La clase Math, es una clase que viene incorporada en el lenguaje de programacin Java, incluida en el paquete java.lang, la cual nos proporciona mtodos y atributos, para implementar diversas funciones mtemticas.
JERARQUA 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 mtodos de clculo bsico, como exponencial, logaritmo, raiz cuadrada y funciones trigonomtricas. 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 mtodos de la clase Math son mtodos estticos (llamados tambin mtodos de clase) y para poder utilizarlos solo se debe colocar el nombre de la clase, el operador punto y el nombre del mtodo 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 mtodos de una clase final son implcitamente finales.
Pag. 281
MTODOS La clase Math presenta los siguientes atributos y mtodos de clase: Atributos de clase: 1. E. 2. PI. Mtodos 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 mtodos 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 mtodos de clase). Para ejecutar un mtodo 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 mtodo de clase que desea ejecutar. Asimismo; para ejecutar un mtodo de la clase Math debemos tener en cuenta que si, el mtodo necesita algunos datos, estos deben ser necesariamente proporcionados en la cantidad y tipos requeridos. En caso que el mtodo devuelva un resultado deber almacenarlo en una variable del mismo tipo que el resultado proporcionado o mostrarlo a travs de la pantalla. A continuacin se presenta una breve descripcin del uso de cada uno de los mtodos de la clase Math:
Pag. 282
CLASE Math ATRIBUTOS DE CLASE DESCRIPCIN

Almacena el valor de E. Es decir, nos proporciona la base de un logaritmo natural. El valor es equivalente a 2.718281828459045.
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.
PI
Almacena el valor de PI. Es decir, almacena el valor equivalente a 3.141592653589793.
MTODOS DE CLASE
abs (float) abs (double) abs (int) abs (long)
DESCRIPCIN
USO
Retorna el valor absoluto de un nmero (que puede ser float, double, int, long) dado como parmetro.
int x = -5 ; System.out.print( Math.abs( x)) ; Resultado: x = 5.
acos (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 mtodo como parmetro.
double angulo = 45.0 * Math.PI/180.0; double result ; result = Math.acos( angulo ) ; System.out.print( result ) ; Resultado : result = 0.6674572160283838
asin (double)
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 mtodo como parmetro. 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 mtodo como parmetro.
double angulo = 45.0 * Math.PI/180.0 ; double result ; result = Math.asin( angulo ) ; System.out.print( result ) ; Resultado : result = 0.9033391107665127
atan (double)
double angulo = 45.0 * Math.PI/180.0 ; double result ; result = Math.atan( angulo ) ; System.out.print( result ) ;
Pag. 283
MTODOS DE CLASE
DESCRIPCIN
Resultado :
USO
result = 0.6657737500283538
ceil (double)
Retorna un valor double con el valor ms corto no menor que el parmetro dado. El parmetro dado debe ser double.
double n = 0.65 , result ; result = Math.ceil( n ) ; System.out.print( result ) ; Resultado: result = 1.0
double angulo = 30.0 * Math.PI/180.0 ; double result ; result = Math.cos( angulo ) ; System.out.println( result ) ; Resultado : result = 0.8660254037844387
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 mtodo como parmetro.
exp (double)
Retorna un valor double con el valor exponencial de Euler del parmetro dado. El parmetro dado sebe ser double.
double exponente=1.0 , result ; result = Math.exp(exponente) ; System.out.println(result) ; Resultado: result = 2.7182818284590455 double n = 5.65 , result ; result = Math.floor(n) ; System.out.print(result) ; Resultado: resutl = 5.0
double logaritmo = 3.0 , result ; result = Math.log(logaritmo) ; System.out.println( result ) ; Resultado: result = 1.0986122886681096
floor (double)
Retorna un valor double con el valor ms grande no mayor que el parmetro dado. El parmetro dado debe ser double.
log (double)
Retorna un valor double con el logaritmo natural (base e) de un parmetro dado. El parmetro dado sebe ser double. Retorna el valor del nmero mayor (que puede ser float, double, int, long) de dos nmeros dados como parmetros.
max (float, float) max (double, double)
double x = 10 , y = 15 , mayor ; mayor = Math.max( x , y ) ; System.out.print ( mayor ) ; Resultado:
Pag. 284
MTODOS DE CLASE
max (int, int) max (long, long)
DESCRIPCIN
mayor = 15.
USO
min (float, float) min (double, double) min (int, int) min (long, long) double x = 2 , y = 4 , result ; result = Math.pow( x , y ) ; System.out.print ( result ) ; Resultado: result = 16. Retorna el valor del nmero menor (que puede ser float, double, int, long) de dos nmeros dados como parmetros. double x = 10 , y = 15 , menor ; menor = Math.min( x , y ) ; System.out.print ( menor ) ; Resultado: menor = 10.
pow (double, double)
Retorna un valor double con la potencia de un nmero (dado como primer parmetro) elevado a otro nmero (dado como segundo parmetro). Los dos parmetros dados deben ser double.
random ()
Retorna un valor double con un nmero generado aleatoriamente (al azar) mayor o igual que 0.0 y menor que 1.0.
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 parmetro dado. El parmetro dado puede ser un valor float o double. round (double) double x = 10.53 , result ; result = Math.round( x ) ; System.out.print ( result ) ; Resultado: result = 11.
sin (double)
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 mtodo como parmetro.
double angulo = 37.0 * Math.PI/180.0; double result ; result = Math.sin(angulo) ; System.out.println(result) ; Resultado:
Pag. 285
MTODOS DE CLASE
DESCRIPCIN
USO
result = 0.6018150231520483
sqrt (double)
Retorna un valor double con la raiz cuadrada del parmetro dado. El parmetro dado debe ser un valor double.
double x = 16 , result ; result = Math.sqrt( x ) ; System.out.print ( result ) ; Resultado: result = 4.

double angulo = 53.0 * Math.PI/180.0 ; double result ; result = Math.tan(angulo); System.out.println( result ) ; Resultado: result = 1.3270448216204098
tan (double)
Retorna un valor double con la tangente de un ngulo expresado en radianes. El ngulo expresado en radianes debe ser un valor double enviado al mtodo como parmetro.
toDegrees (double)
Retorna un valor double. Permite convertir un ngulo expresado en radianes (enviado como parmetro 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 double angulo = 60, result ; result = Math.toRadians(angulo) ; System.out.println( result ) ; Resultado: result = 1.0471975511965976
toRadians (double)
Retorna un valor double. Permite convertir un ngulo expresado en sexadecimal (enviado como parmetro double) en un ngulo expresado en radianes.
A continuacin, con la finalidad de mejorar la comprensin del tema tratado, se presentan algunas soluciones a problemas planteados utilizando algunos de los mtodos de la clase Math. Analice cada una de las siguientes soluciones.
Pag. 286
Problema 65 Etapa 01 - Descripcin del problema. Desarrollar un programa en Java que permita ingresar 3 nmeros enteros a travs del teclado. Determinar y mostrar cul de ellos es el nmero mayor. Etapa 04 - Desarrollo de la Codificacin.
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 nmero: ) ; num1 = Lectura.leerInt( ) ; System.out.println ( Ingresar el segundo nmero: ) ; num2 = Lectura.leerInt( ) ; System.out.println ( Ingresar el tercer nmero: ) ; num3 = Lectura.leerInt( ) ; resultado = Math.max ( num1, Math.max ( num2, num3 ) ) ; System.out.println ( El nmero mayor es: + resultado ) ; } } Que hay de nuevo en la codificacin? Observe el uso del mtodo max ( ) de la clase Math: Math.max ( num2, num3 ) Parmetros. Nombre del mtodo. Operador punto. Nombre de la Clase.
Pag. 287
El mtodo max ( ) nos permite determinar el nmero mayor entre dos nmeros (en nuestro caso el nmero mayor entre num2 y num3). Observe que en esta solucin se emplea una estrategia mas simple para determinar el nmero mayor entre tres nmeros. El mtodo max ( ) de la clase Math, retorna el valor del nmero mayor (puede ser un nmero float, double, int o long) de dos nmeros dados como parmetros. En nuestro ejemplo determinamos el mayor de los dos ltimos nmeros ingresados y en la misma lnea de cdigo evaluamos el mayor de estos dos nmeros con el primer nmero ingresado, tal y como se muestra a continuacin: resultado = Math.max ( num1, Math.max ( num2, num3 ) ) ; Es importante tener presente que el mtodo max ( ) es un mtodo que solo podemos utilizar con la clase Math y su funcin es determinar el nmero mayor entre dos nmeros dados como parmetros.
Pag. 288
Problema 66 Etapa 01 - Descripcin del problema. Desarrollar un programa en Java que permita ingresar 3 nmeros enteros a travs del teclado. Determinar y mostrar cul de ellos es el nmero menor. Etapa 04 - Desarrollo de la Codificacin.
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 nmero: ) ; num1 = Lectura.leerInt( ) ; System.out.println ( Ingresar el segundo nmero: ) ; num2 = Lectura.leerInt( ) ; System.out.println ( Ingresar el tercer nmero: ) ; num3 = Lectura.leerInt( ) ; resultado = Math.min ( num1, Math.min ( num2, num3 ) ) ; System.out.println ( El nmero menor es: " + resultado ) ; } }
Que hay de nuevo en la codificacin? Observe el uso del mtodo min ( ) de la clase Math: En la codificacin de esta solucin se emplea una nueva estrategia para hallar el menor de tres nmeros ingresados por teclado (anteriormente se utilizaban sentencias if anidadas). Observe que Math.min ( ) retorna el valor del nmero menor (que puede ser float, double, int, long) de dos nmeros dados como parmetros. En nuestro ejemplo hallamos el menor de los dos ltimos nmeros ingresados, y en la misma lnea evaluamos el menor de estos dos nmeros con el primer nmero ingresado, tal y como se muestra a continuacin: resultado = Math.min ( num1, Math.min ( num2, num3 ) ) ;
Pag. 289
Problema 67 Etapa 01 - Descripcin del problema. Desarrollar un programa en Java que permita generar una cantidad determinada de nmeros aleatorios. Los nmeros aleatorios generados debern estar entre 1 y 6. Mostrar el nmero generado aleatoriamente y la suma de dichos nmeros. Etapa 04 - Desarrollo de la Codificacin.
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 nmeros aleatorios a generar: ) ; cant = Lectura.leerInt( ) ; for ( x = 1; x <= cant; x++) { num = 1 + (int) ( Math.random( ) * 6 ) ; System.out.println ( El nmero aleatorio generado es: + num ) ; suma = suma + num ; } System.out.println ( La suma de los nmeros aleatorios es: + suma ) ; } }
Que hay de nuevo en la codificacin? Observe el uso del mtodo random ( ) de la clase Math: num = 1 + (int) (Math.random ( ) * 6 ) ; En la codificacin de esta solucin se utiliza una sentencia for con la finalidad de generar la cantidad de nmeros aleatorios (al azar) que el usuario desee. Cada vez que se ejecuta la sentencia for, se genera y muestra un nmero aleatorio (un nmero entre 1 y 6), el cual es acumulado en la variable suma. Finalizada la ejecucin de la sentencia for se muestra el contenido de dicha variable (es decir, se muestra la suma de los nmeros aleatorios generados). Recuerde que para generar nmeros aleatorios entre dos nmeros (entre un intervalo o rango), utilizando el mtodo random ( ) de la clase Math, se emplea la siguiente frmula:
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 - Descripcin del problema. Desarrollar un programa en Java que permita generar una cantidad determinada de nmeros aleatorios. Los nmeros aleatorios generados debern estar entre 1 y 10. Mostrar los nmeros aleatorios que son nmeros pares. Etapa 04 - Desarrollo de la Codificacin.
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 nmeros 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 codificacin? En la codificacin de esta solucin se utiliza una sentencia do con la finalidad de generar nmeros aleatorios. Si el nmero generado es par se le aumenta uno a la variable cont (que esta trabajando como contador de nmeros pares generados al azar) y se muestra el nmero generado.
Pag. 292
Problema 69 Etapa 01 - Descripcin del problema. Desarrollar un programa en Java que permita generar una cantidad determinada de nmeros aleatorios. Los nmeros aleatorios generados debern estar entre 1 y 10. Mostrar los nmeros aleatorios que son nmeros impares. Etapa 04 - Desarrollo de la Codificacin.
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 nmeros 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 codificacin? En la codificacin de esta solucin se utiliza una sentencia do con la finalidad de generar nmeros aleatorios. Si el nmero generado es impar se le aumenta uno a la variable cont (que esta trabajando como contador de nmeros impares generados al azar) y se muestra el nmero generado.
Pag. 293
Problema 70 Etapa 01 - Descripcin 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 Codificacin.
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 codificacin? Observe el uso del mtodo pow ( ) y del atributo PI de la clase Math: volume = (4 / 3) * Math.PI * Math.pow ( radio, 3 ) ; El mtodo pow ( ) retorna un valor double con la potencia de un nmero (dado como primer parmetro) elevado a otro nmero (dado como segundo parmetro). En nuestro caso el mtodo pow ( ) eleva a la potencia 3 el radio del crculo. Para hallar el volumen de la esfera se tendr que utilizar la frmula v=4/3*PI*R3. La clase Math define un atributo (constante) muy til, que contiene en valor del nmero PI (Math.PI).
Pag. 294
Problema 71 Etapa 01 - Descripcin del problema. Desarrollar un programa en Java que permita ingresar un nmero decimal. Mostrar el nmero ingresado redondeado. Etapa 04 - Desarrollo de la Codificacin.
Clase PrgNumRedondeado
package dominioDeLaAplicacion ; import biblioteca.Lectura ; class PrgNumRedondeado { public static void main ( String arg [ ] ) { double num, resultado ; System.out.println ( Ingrese un nmero decimal: ) ; num = Lectura.leerDouble( ) ; resultado = Math.round(num) ; System.out.println ( El nmero redondeado es: + resultado ) ; } }
Que hay de nuevo en la codificacin? Observe el uso del mtodo round ( ) de la clase Math: resultado = Math.round(num) ; El mtodo round ( ) permite redondear un nmero dado como parmetro. En esta solucin se ingresa un nmero y se almacena en la variable num. Luego, dicho nmero es redondeado utilizando el mtodo round ( ) y se almacena en la variable resultado.
Pag. 295
Problema 72 Etapa 01 - Descripcin del problema. Desarrollar un programa en Java que permita ingresar un nmero entero y un exponente. Mostrar el resultado de calcular la potencia de todos los nmeros menores que el nmero ingresado elevado al exponente ingresado. Etapa 04 - Desarrollo de la Codificacin.
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 nmero 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 codificacin? Observe el uso del mtodo pow ( ) de la clase Math: rpta = Math.pow ( x, expo ) ; El mtodo pow ( ) permite elevar a la potencia un nmero determinado. En la presente solucin se utiliza una sentencia for con la finalidad de elevar a la potencia todos los nmeros 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 mtodo 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 - Descripcin del problema. Desarrollar un programa en Java que permita ingresar un nmero entero. Mostrar el resultado de calcular la raz cuadrada de todos los nmeros menores que el nmero ingresado. Etapa 04 - Desarrollo de la Codificacin.
Clase PrgNumRaiz
package dominioDeLaAplicacion ; import biblioteca.Lectura ; class PrgNumRaiz { public static void main ( String arg [ ] ) { int cant ; double rpta ; System.out.println ( Ingrese un nmero entero: ) ; cant = Lectura.leerInt( ) ; for ( int x = 1; x < cant; x++ ) { rpta = Math.sqrt (x) ; System.out.println ( La raz cuadrada de + x + es: + rpta ) ; } } }
Que hay de nuevo en la codificacin? Observe el uso del mtodo sqrt ( ) de la clase Math: rpta = Math.sqrt ( x ) ; El mtodo sqrt ( ) permite obtener la raz cuadrada de un nmero determinado. En la presente solucin se utiliza una sentencia for con la finalidad de obtener la raz cuadrada de todos los nmeros menores que la variable cant y mostrarlos por pantalla. La variable cant se ingresa por el teclado. Recuerde y siempre tenga presente que el mtodo 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 - Descripcin del problema. Desarrollar un programa en Java que permita generar una cantidad determinada de nmeros aleatorios. Los nmeros aleatorios generados debern estar entre 1 y 10. Mostrar los nmeros generados aleatoriamente elevados al cuadrado. Etapa 04 - Desarrollo de la Codificacin.
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 nmeros 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 codificacin? Observe el uso de los mtodos random ( ) y sqrt ( ) de la clase Math: num = (int) ( 1 + ( Math.random() * 10 ) ) ; rpta = Math.pow (num, 2) ; En la presente solucin se utiliza una sentencia for con la finalidad de obtener nmeros aleatorios, elevarlos al cuadrado y mostrarlos por pantalla. La variable cant se ingresa por el teclado.
Pag. 298
Problema 75 Etapa 01 - Descripcin del problema. Desarrollar un programa en Java que permita determinar y mostrar el rea de un trangulo 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 frmulas: area = ( p * (|p-a|)*(|p-b|)*(|p-c|)) RAIZ (2). p = (a+b+c) / 2.
Donde: p = Semipermetro. a, b, c = Lados del tringulo.

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 tringulo (a): ) ; a = Lectura.leerDouble( ) ; System.out.println ( Ingrese el valor del segundo lado del tringulo (b): ) ; b = Lectura.leerDouble( ) ; System.out.println ( Ingrese el valor del terecr lado del tringulo (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 tringulo es: + area ) ; } }
Pag. 299
Que hay de nuevo en la codificacin?
Observe el uso de los mtodos 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 solucin se ingresan los valores de los tres lados de un tringulo y se obtiene el valor del semipermetro del tringulo. Luego, se procede a calcular el rea del tringulo en base a la siguiente frmula: area = ( p * (|p-a|)*(|p-b|)*(|p-c|)) RAIZ (2) Primero, se hace uso del mtodo abs ( ) de la clase Math para calcular el valor absoluto de la diferencia entre el semipermetro y cada uno de los lados del tringulo. Luego, se multiplican los valores resultantes con el valor del semipermetro del tringulo y finalmente, se obtiene la raz cuadrada del valor resultante utilizando el mtodo sqrt ( ) de la clase Math.
Pag. 300
Problema 76 Etapa 01 - Descripcin del problema. Desarrollar un programa en Java que permita determinar y mostrar el permetro y el rea de un crculo. Utilizar las siguientes frmulas: perimetro = 2 * PI * radio. area = PI * radio * radio. Etapa 04 - Desarrollo de la Codificacin.
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 crculo: ) ; radioCirculo = Lectura.leerDouble( ) ; areaCirculo = Math.PI * Math.pow (radioCirculo, 2) ; perimetroCirculo = 2 * Math.PI * radioCirculo ; System.out.println ( El rea del crculo es: + areaCirculo ) ; System.out.println ( El permetro del crculo es : + perimetroCirculo ) ; } }
Pag. 301
Problema 77 Etapa 01 - Descripcin 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. = Cncavo. = Completo.

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 codificacin? Observe el uso del mtodo toRadians ( ) de la clase Math: anguloRadianes = Math.toRadians (anguloGrados) ; Para el desarrollo de esta solucin se hace uso de sentencias if mltiples 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 conversin del ngulo ingresado en el sistema sexagesimal al sistema radial se utiliza el mtodo toRadians ( ) de la clase Math.
Pag. 303
Problema 78 Etapa 01 - Descripcin del problema. Desarrollar un programa en Java que permita determinar y mostrar las races de una ecuacin de segundo grado. Tipo: 2 Ax + Bx + C = 0 Considerar que la solucin puede tener races imaginarias. Utilizar la siguiente frmula: x = ( - B + - ( ( B ** 2 4 * A * C ) RAIZ ( 2 ) ) ) / 2 * A. Etapa 04 - Desarrollo de la Codificacin.
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 ecuacin no tiene solucin ) ; } else { tmp = Math.pow (b, 2) - (4 * a * c) ; if (tmp < 0) { System.out.println ( La ecuacin 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 codificacin? Observe el uso de los mtodos pow ( ) y sqrt ( ) de la clase Math: En esta solucin se ingresan los coeficientes de una ecuacin 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 ecuacin no tiene solucin. 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 ecuacin tiene raices imaginarias. Caso contrario, si el coeficiente a es igual a cero la ecuacin tendra una sola solucin, la cual se calculara utilizando: x = c / b * (-1) ; Si el coeficiente a es diferente de cero la ecuacin tendra dos soluciones, las cuales se calcularan utilizando: x1 = ( - b + Math.sqrt (tmp)) / (2 * a) ; x2 = ( - b - Math.sqrt (tmp)) / (2 * a) ;
Pag. 305
Problema 79 Etapa 01 - Descripcin del problema. Desarrollar un juego en Java que permita generar un nmero aleatorio. Se debe intentar adivinar que nmero es el que gener la computadora. El rango de nmeros vlidos en el juego es de 1 a 100, y cada vez que intente adivinar le indicar si el nmero buscado es menor o es mayor. Etapa 04 - Desarrollo de la Codificacin.
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 nmero 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 nmero es - ) ; System.out.println ( - Trate de adivinar el nmero en - ) ; System.out.println ( - el menor nmero de intentos - ) ; do { System.out.println ( Ingrese un nmero 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 nmero buscado es mayor ) ; else System.out.println ( El nmero buscado es menor ) ; do { System.out.println ( Ingrese otro nmero entre 0..100: ) ; num = Lectura.leerInt( ) ; } while (num < 0 || num > 100) ; } System.out.println ( Ud. encontr el nmero en: + inten + intento(s) ) ; } }
Pag. 306
Qu hay de nuevo en la codificacin? Observe el uso de los mtodos random ( ) y round ( ) de la clase Math: Utilizando el mtodo random ( ) generamos un nmero aleatorio (al azar) entre el nmero 0 y el nmero 100, utilizando la siguiente frmula: tmp = maximo * Math.random( ) ; El nmero generado aleatoriamente es almacenado en la varable tmp. Luego es redondeado utilizando el mtodo round ( ) y convertido a un nmero entero utilizando la siguiente sentencia: numAzar = (int) Math.round(tmp) ; Este nmero generado al azar, almacenado en la variable numAzar, es comparado con un nmero previamente ingresado por teclado y almacenado en la variable num. Si ambos son iguales, se mostrar un mensaje indicando que el nmero numAzar fue encontrado. Si no son iguales, se mostrar un mensaje, indicando si el nmero buscado es mayor o es menor (en relacin al nmero ingresado) y se solicitar otro nmero hasta encontrar el nmero que se gener en forma aleatoria. Intente modificar la codificacin de la solucin. Utilice la sentencia do y optimice el cdigo.
Pag. 307
Problema 80 Etapa 01 - Descripcin del problema. Desarrollar un programa en Java que permita ingresar 6 nmeros a traves del teclado. Determinar y mostrar cul de ellos es el nmero mayor y cul es el nmero menor. Etapa 04 - Desarrollo de la Codificacin.
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 nmero: ) ; n1 = Lectura.leerInt(); System.out.println ( Ingrese el segundo nmero: ) ; n2 = Lectura.leerInt( ) ; System.out.println ( Ingrese el tercer nmero: ) ; n3 = Lectura.leerInt( ) ; System.out.println ( Ingrese el cuarto nmero: ) ; n4 = Lectura.leerInt( ) ; System.out.println ( Ingrese el quinto nmero: ) ; n5 = Lectura.leerInt( ) ; System.out.println ( Ingrese el sexto nmero: ) ; 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 nmero es: " + mayor ) ; System.out.println ( El menor nmero es: " + menor ) ; } }
Modificar la codificacin de la solucin de tal forma que pueda optimizar el cdigo. Utilice una sentencia for.
Pag. 308
Problema 81 Etapa 01 - Descripcin 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 frmula: pf = ( pp + ep + ( ef * 2 ) ) / 4.
Donde: pf = Promedio final. pp = Promedio de prcticas. Son 4 prcticas de las cuales se elimina la ms baja pp = ( p1 + p2 + p3 + p4 notaMenor ) / 3 ep = Examen parcial. ef = Examen final.

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 prctica 1: ) ; p1 = Lectura.leerDouble( ) ; System.out.println ( Ingrese la nota de la prctica 2: ) ; p2 = Lectura.leerDouble( ) ; System.out.println ( Ingrese la nota de la prctica 3: ) ; p3 = Lectura.leerDouble( ) ; System.out.println ( Ingrese la nota de la prctica 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
Contina
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 codificacin de la solucin de tal forma que se elimine la prctica con la nota ms baja y se duplique la nota de la prctica ms alta. Muestre el promedio de las notas redondeado a dos decimales.
Pag. 310
Problema 82 Etapa 01 - Descripcin del problema. Desarrollar un programa en Java que permita ingresar un nmero cualquiera con parte decimal y muestre la parte entera del nmero, el nmero redondeado sin decimales, y el nmero redondeado a uno, dos y tres decimales. Etapa 04 - Desarrollo de la Codificacin.
Clase PrgRedondearNumero
package dominioDeLaAplicacion ; import biblioteca.Lectura ; class PrgRedondearNumero { public static void main ( String arg [ ] ) { double numero ; System.out.println ( Ingrese un nmero con decimales: ) ; numero=Lectura.leerDouble( ) ; System.out.println ( ----------------------------------- ) ; System.out.println ( La parte entera del nmero es: ) ; System.out.println ( Math.floor (numero) ) ; System.out.println ( El nmero redondeado es: ) ; System.out.println ( Math.floor (numero+0.5) ) ; System.out.println ( El nmero redondeado a un decimal es: ) ; System.out.println ( Math.floor (numero * 10 + 0.5 ) / 10 ) ; System.out.println ( El nmero redondeado a dos decimales es: ) ; System.out.println ( Math.floor (numero * 100 + 0.5 ) / 100 ) ; System.out.println ( El nmero redondeado a tres decimales es: ) ; System.out.println ( Math.floor (numero * 1000 + 0.5 ) / 1000 ) ; } } Qu hay de nuevo en la codificacin? Observe el uso del mtodo floor ( ) de la clase Math: El mtodo floor ( ) retorna un valor double con el valor ms grande no mayor que el parmetro dado. El parmetro dado debe ser double. Ntese que si ingresamos un numero cuya parte decimal es mayor que 5 slo retorna la parte entera para tal caso se le agrega 0.5 para que en el segundo clculo tenga efecto de redondeo perfecto. Observe como se redondea un nmero con uno, dos y tres decimales utilizando el mtodo floor ( ).
Pag. 311
Problema 83 Etapa 01 - Descripcin del problema. Desarrollar un programa en Java que permite realizar un sorteo en base a un nmero determinado de boletos.
Sugerencia: Utilice el mtodo random ( ) de la clase Math para generar el nmero del boleto ganador.

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 nmero ganador es: + ganador ) ; } } while ( boletos < 0 ) ; } }
Pag. 312
Problema 84 Etapa 01 - Descripcin del problema. Desarrollar un programa en Java que permita calcular la suma de cuadrados y la suma de cubos de los n primeros nmeros. Se deber ingresar un nmero por teclado y mostrar los resultados. Etapa 04 - Desarrollo de la Codificacin.
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 - Descripcin 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 Codificacin.
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 codificacin? Observe el uso de los mtodos toRadians ( ), sin ( ) y cos ( ) de la clase Math: Es importante mencionar que Java trabaja con el sistema radial y para obtener las razones trigonomtricas, seno y coseno, de un ngulo ingresado por teclado hay que convertirlo primero al sistema radial. Para esto, utilizamos el mtodo toRadians ( ) de la clase Math. Este mtodo retorna un valor double y permite convertir un ngulo expresado en el sistema sexagesimal (enviado como parmetro double) en un ngulo expresado
Pag. 314
en radianes. Una vez convertido el ngulo en radianes podemos utilizar los mtodos 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 - Descripcin del problema. Desarrollar un programa en Java que permita ingresar un ngulo de inclinacin de la recta con respecto al eje x. Mostrar como resultado la pendiente de la recta.

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 inclinacin 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 codificacin? Observe el uso del mtodo tan ( ) de la clase Math: El mtodo tan ( ) permite hallar la pendiente de una recta con respecto al eje X. Para ello, utiliza el ngulo de inclinacin de la recta, expresado en el sistema radial, tal y como se muestra: tangente = Math.tan(anguloRadianes) ;
Pag. 316
Problema 87 Etapa 01 - Descripcin del problema. Desarrollar un programa en Java que permita ingresar los catetos de un tringulo perpendicular. Calcular y mostrar la hipotenusa del trangulo. Etapa 04 - Desarrollo de la Codificacin.
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 tringulo es: + hipotenusa) ; } }
La frmula para este caso sera: (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 raz 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 tringulo es: 3.605551275463989
Pag. 317
Problema 88 Etapa 01 - Descripcin 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 Codificacin.
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 codificacin? Observe el uso de los mtodos 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 mtodo como parmetro.
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 mtodo atan ( ) de la clase Math no nos servira (este mtodo 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 mtodo atan2 ( ) de la clase Math. Este mtodo nos permite obtener el valor del arcotangente de un par ordenado. Es importante mencionar que el mtodo 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 mtodo toDegrees ( ) de la clase Math.
Pag. 319
Problema 89 Etapa 01 - Descripcin del problema. Desarrollar un programa en Java que permita ingresar un nmero cualquiera. Calcular y mostrar el nmero e elevado al nmero ingresado y el logaritmo natural (de base e) del nmero ingresado. Etapa 04 - Desarrollo de la Codificacin.
Clase PrgExpLog
package dominioDeLaAplicacion ; import biblioteca.Lectura ; class PrgExpLog { public static void main ( String arg [ ] ) { double num, exponencial, logaritmo ; System.out.println ( Ingrese un nmero: ) ; num=Lectura.leerDouble(); exponencial = Math.exp(num) ; logaritmo = Math.log(num) ; System.out.print ( El valor del nmero [e] elevado a [ + num ) ; System.out.println ( ] es: + exponencial ) ; System.out.print ( El valor del logaritmo [en base e] del nmero [ ) ; System.out.println ( num + ] es: + logaritmo) ; } } Qu hay de nuevo en la codificacin? Observe el uso de los mtodos exp ( ) y log ( ) de la clase Math: exponencial = Math.exp(num) ; logaritmo = Math.log(num) ; En esta solucin se hace necesario el uso del mtodo exp ( ) para obtener el nmero e elevado al nmero ingresado por teclado: enum Tambin se hace necesario el uso del mtodo log ( ) para obtener el logaritmo natural del nmero ingresado en base e: logenum
Pag. 320
Tenga presente que Java slo resuelve logaritmos en base e y no en base 10.
A continuacin se presentan algunas soluciones a problemas utilizando bsicamente el mtodo random ( ) de la clase Math, desarrollados con la finalidad de mejorar su comprensin del tema y sus capacidades lgicas. Analizar cada uno de las soluciones y desarrolle sus propias conclusiones.
Pag. 321
Problema 90 Etapa 01 - Descripcin 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 Codificacin.
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
Contina

} 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 - Descripcin 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 Codificacin.
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
Contina
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 - Descripcin del problema. Elaborar un programa que simule el lanzamiento de una moneda. Solicitar el nmero de veces que se lanzar la moneda. Cuentar el nmero de veces que aparece cada lado de la moneda. Mostrar los resultados. Etapa 04 - Desarrollo de la Codificacin.
Clase PrgLanzarMoneda
package dominioDeLaAplicacion ; import biblioteca.* ; class PrgLanzarMoneda { public static void main ( String arg [ ] ) { int moneda, cont1 = 0, cont2 = 0, cant ; System.out.println ( Cuntas 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 - Descripcin del problema. Elaborar un programa que simule el juego de tragamonedas, los nmeros son: 1, 2, 3, 4, 5 ,6 y 7 opciones de ganar. El jugador gana cuando el nmero se repita tres veces. Los nmeros debern ser generados aleatoriamente. El premio mayor se obtiene con el nmero 7. Etapa 04 - Desarrollo de la Codificacin.
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
Contina
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 - Descripcin 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 Codificacin.
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
Contina
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 - Descripcin del problema. Las computadoras estn desempeando un papel cada vez ms importante en la educacin. Desarrolle un programa que ayude a un estudiante de primaria a aprender a multiplicar. Utilice nmeros aleatorios para producir dos enteros positivos de un solo digito. El programa deber preguntar Cunto 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 Codificacin.
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 ( Cunto es + valor1 + por + valor2 + ? ) ; System.out.println ( Ingresar resultado de la multiplicacin : ) ; 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 - Descripcin 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 nmeros generados al azar. Se permitir al estudiante contestar la misma pregunta una y otra vez hasta que responda correctamente. Etapa 04 - Desarrollo de la Codificacin.
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
Contina
case 2 : resul1 = valor1 - valor2 ; operacion = Resta ; signo = - ; break ; case 3 : resul1 = valor1 * valor2 ; operacion = Multiplicacin ; signo = * ; break ; case 4 : resul1 = valor1 / valor2 ; operacion = Divisin ; signo = / ; break ; case 5 : System.exit (0) ; break ; } System.out.println ( Cunto 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 - Descripcin 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 nmeros al azar. Mostrar la cantidad de preguntas correctas y la cantidad de preguntas incorrectas. Etapa 04 - Desarrollo de la Codificacin.
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
Contina
case 2 : resul1 = valor1 - valor2 ; operacion = Resta ; signo = - ; break ; case 3 : resul1 = valor1 * valor2 ; operacion = Multiplicacin ; signo = * ; break ; case 4 : resul1 = valor1 / valor2 ; operacion = Divisin ; signo = / ; break ; case 5 : System.exit (0) ; break ; } System.out.println ( Cunto 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 - Descripcin del problema. Elaborar un programa que permita adivinar cul es el nmero entero generado al azar entre 1 y 1000. El jugador ingresar una primera estimacin, si la estimacin del jugador es incorrecta, el programa deber indicar si el nmero ingresado fue ms grande o fu ms pequeo que el nmero generado al azar. Cuando la respuesta sea correcta se mostrar un mensaje de felicitaciones. Etapa 04 - Desarrollo de la Codificacin.
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 nmero ) ; valor = ( int ) (1 + ( Math.random ( ) * 1000 ) ) ; do { System.out.println ( Ingresar nmero : ) ; num = Lectura.leerInt ( ) ; if ( num < valor ) System.out.println ( El nmero es demasiado chico. Pruebe otra vez ) ; else if ( num > valor ) System.out.println ( El nmero es demasiado grande. Pruebe otra vez ) ; else System.out.println ( Felicidades adivinaste el nmero ) ; } while (num != valor ) ; System.out.println ( Desea Continuar [s/n]: ) ; opc = Lectura.leerChar ( ) ; } while ( opc != n ) ; } }
Pag. 336
Problema 99 Etapa 01 - Descripcin 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 nmero. Etapa 04 - Desarrollo de la Codificacin.
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 nmero ) ; System.out.println ( Ingrese la cantidad de intentos : ) ; intentos=Lectura.leerInt ( ) ; valor = ( int ) (1 + ( Math.random ( ) * 1000 ) ) ; do { System.out.println ( Ingresar nmero : ) ; num = Lectura.leerInt ( ) ; if (cont >= intentos ) { System.out.println ( Deberas haberlo hecho mejor ) ; valor = num ; } else if ( num < valor ) System.out.println ( El nmero es demasiado chico. Pruebe otra vez ) ; else if ( num > valor ) System.out.println ( El nmero es demasiado grande. Pruebe otra vez ) ; else System.out.println ( Felicidades adivinaste el nmero ) ; 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 INTRODUCCIN Una cadena es un conjunto de caracteres, nmeros y smbolos especiales almacenados en una variable de tipo texto o cadena. La clase String, es una clase que viene incorporada en el lenguaje de programacin 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 ;
JERARQUA 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 travs de los mtodos que implementa (la clase String tiene mtodos de instancia y mtodos de clase). La clase String incluye mtodos 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 mayscula o minscula. Las conversiones son realizadas a travs del mtodo toString ( ), mtodo definido en la clase Object, el cual puede ser utilizado por todas las clases Java a travs de la herencia.
Pag. 339
MTODOS La clase String presenta los siguientes mtodos: Mtodos 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( ).
Mtodos de clase: 17. valueOf( ). Para trabajar con los mtodos 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 mtodos de clase esto no ser necesario. Para ejecutar un mtodo 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 mtodo de instancia que se desea ejecutar. Para el caso de los mtodos de clase deber colocar la palabra String, el operador punto (.) y el nombre del mtodo de clase que se desea ejecutar. Asimismo, para ejecutar cualquiera de los mtodo de la clase String, se debe tener en cuenta que si, el mtodo necesita algunos datos, stos deben ser necesariamente proporcionados en la cantidad y tipos requeridos. En caso, que el mtodo devuelva un resultado, ste deber almacenarse en una variable del mismo tipo o mostrarse a travs de la pantalla. A continuacin se presenta una breve descripcin del uso de cada uno de los mtodos de la clase String:
Pag. 340
CLASE String MTODOS DE INSTANCIA DESCRIPCIN USO
charAt(int)
Devuelve el caracter que encuentre en la posicin indicada por la variable entera o nmero entero colocado como parmetro. Es importante mencionar que en Java, el primer caracter de una cadena se encuentra ubicado en la posicin 0 (cero).
String cad1 = Hola Danae; char x = cad1.charAt(5); resultado: x = D.
compareTo(String)
Si la cadena es alfabticamente menor que la cadena colocada como parmetro, el mtodo devuelve un nmero entero menor que cero. Si las dos cadenas son alfabticamente iguales devuelve un nmero cero y si la cadena es alfabticmente mayor que la cadena colocada como parmetro, el mtodo devuelve un entero mayor que cero.
String cad1 = Hola Danae; String cad2 = Hola Pedro; int x = cad1.compareTo(cad2); Resultado: x < 0 (cad1<cad2).
concat(String)
Este mtodo permite juntar dos cadenas en una sola cadena.
String cad1, cad2, cadena; cad1 = "Hola"; cad2 = " a todos"; cadena = cad1.concat (cad2); Resultado : cadena = "Hola a todos
endsWith(String)
Devuelve true (verdadero) si el final de la cadena coincide con la cadena colocada como parmetro. Caso contrario devuelve false (falso).
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:
equals(String)
Devuelve true (verdadero) si la cadena coincide con la cadena colocada como parmetro. Caso contrario devuelve false (falso).
equalsIgnoreCase(String)
Este mtodo realiza la misma funcin que el mtodo equals ( ) pero la comparacin la realiza sin tener en cuenta las letras minscula y mayscula.
Pag. 341
MTODOS DE INSTANCIA
DESCRIPCIN
x = true.
USO
String cad1 = Hola Danae; int x = cad1.indexOf(D); indexOf(char) Resultado: x = 5. 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) Devuelve la posicin de la cadena en la que aparece por ltima vez el caracter colocado como parmetro. Tambin se puede especificar un segundo parmetro a partir del cual se empieza a buscar hacia atrs. 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.
indexOf(char,int)
indexOf(String)
Devuelve la posicin de la cadena en la que aparece por primera vez el caracter colocado como parmetro. Tambin se puede especificar un segundo parmetro a partir del cual se empieza a buscar hacia delante.
lastIndexOf(String)
Pag. 342
MTODOS DE INSTANCIA
DESCRIPCIN
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);
length()
Devuelve la longitud de una cadena. Es decir, el nmero de caracteres que tiene la cadena.
replace(char,char)
Permite reemplazar todos los caracteres iguales al caracter colocado como primer parmetro con el caracter colocado como segundo parmetro.
startsWith(String)
Devuelve un valor true (verdadero) si el comienzo de la cadena coincide con la cadena colocada como parmetro, caso contrario devuelve false (falso).
substring(int)
substring(int,int)
Devuelve una subcadena a partir de la cadena especificada, empezando desde la posicin indicada en el primer parmetro hasta el final o hasta una posicin anterior a la indicada en el segundo parmetro del mtodo.
Resultado: x = Danae. String cad1 = Hola Danae; String x = cad1.substring(6,9); Resultado: x = ana.
toCharArray()
Convierte una cadena especfica en un vector de caracteres. (Los vectores sern tratados en el captulo IV).
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.
toLowerCase()
Convierte las letras de una cadena en letras minsculas.
trim()
Permite eliminar los espacios en blanco del inicio y del final de una cadena.
Pag. 343
MTODOS DE INSTANCIA
DESCRIPCIN
USO
String cad1 = Hola Danae; String x = cad1.toUpperCase(); Resultado: x = HOLA DANAE.
toUpperCase()
Convierte las letras de una cadena en letras maysculas.
MTODO DE CLASE
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)
DESCRIPCIN
USO
Mtodo de clase que permite convertir los valores de otros tipos de datos o variables a una cadena.
double pi = 3.1416; String x = String.valueOf(pi); resultado: x = 3.1416.
A continuacin, con la finalidad de mejorar la comprensin del tema tratado, se presentan algunas soluciones a problemas planteados utilizando algunos de los mtodos de la clase String. Analice cada una de las siguientes soluciones.
Pag. 344
Problema 100 Etapa 01 Descripcin del problema. Desarrollar un programa en Java que permita ingresar el nombre de un alumno. Mostrar el nombre del alumno en letras mayscula. Etapa 04 Desarrollo de la codificacin.
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 Mayscula es: + nom ) ; } }
Qu hay de nuevo en la codificacin? Observe el uso del mtodo toUpperCase ( ) de la clase String: nom.toUpperCase ( ) ; Nombre del mtodo. Operador punto. Nombre de la variable (objeto). El mtodo toUpperCase ( ) se utiliza con variables de tipo String y permite convertir en letras maysculas el contenido de la variable que antecede al nombre del mtodo y al operador punto (en nuestro caso la variable nom). Como el mtodo toUpperCase ( ) nos devuelve un valor de tipo String (el contenido de la variable en letra mayscula), podemos mostrar el resultado utilizando System.out.println o almacenarlo en una variable (que puede ser la variable que contena la cadena original), tal y como lo hemos realizado en nuestro ejemplo:
Pag. 345
nom = nom.toUpperCase ( ) ; Es importante tener presente que el mtodo toUpperCase ( ) es un mtodo que solo podemos utilizar con variables de tipo String y su funcin es convertir el contenido de una variable en letras mayscula.
Pag. 346
Problema 101 Etapa 01 Descripcin del problema. Desarrollar un programa en Java que permita ingresar el nombre de un alumno. Mostrar el nombre del alumno en letras minsculas. Etapa 04 Desarrollo de la codificacin.
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 Minscula es: + nom ) ; } }
Qu hay de nuevo en la codificacin? Observe el uso del mtodo toLowerCase ( ) de la clase String: nom.toLowerCase ( ) ; Nombre del mtodo. Operador punto. Nombre de la variable (objeto). El mtodo toLowerCase ( ) se utiliza con variables de tipo String y permite convertir en letras minsculas el contenido de la variable que antecede al nombre del mtodo y al operador punto (en nuestro caso la variable nom). Como el mtodo toLowerCase ( ) nos devuelve un valor de tipo String (el contenido de la variable en letra minscula), podemos mostrar el resultado utilizando System.out.println o almacenarlo en una variable (que puede ser la variable que contena la cadena original), tal y como lo hemos realizado en nuestro ejemplo:
Pag. 347
nom = nom.toLowerCase ( ) ; Es importante tener presente que el mtodo toLowerCase ( ) es un mtodo que solo podemos utilizar con variables de tipo String y su funcin es convertir el contenido de una variable en letras minscula.
Pag. 348
Problema 102 Etapa 01 Descripcin 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 maysculas y letra minsculas. Etapa 04 Desarrollo de la codificacin.
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 Mayscula es: " + nombre.toUpperCase() ) ; System.out.println ( El nombre en Minscula es: + nombre.toLowerCase() ) ; } }
Qu hay de nuevo en la codificacin? Observe el uso del mtodo concat ( ) de la clase String: nom = nom.concat (espacio) ; El mtodo concat ( ) se utiliza para juntar o concatenar el contenido de dos variables de tipo String (la misma funcin 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. Tambin podra visualizarse directamente el resultado de juntar o concatenar dos variables de tipo String (cadenas) utilizando System.out.println, como se muestra a continuacin: System.out.println (nom1.concat (nom2) ) ; Finalmente, se utilizan los mtodos toUpperCase ( ) y toLowerCase ( ), explicados en los problemas anteriores, directamente con System.out.println para mostrar el nombre del alumno en letra minscula y en letra mayscula.
Pag. 350
Problema 103 Etapa 01 Descripcin del problema. Desarrollar un programa en Java que permita ingresar el nombre de un alumno. Mostrar el nmero de caracteres del nombre ingresado por teclado. Consistenciar el nombre del alumno al momento de ingresarlo. Etapa 04 Desarrollo de la codificacin.
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 vlido 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 codificacin? Observe el uso del mtodo trim ( ) de la clase String: nom = nom.trim ( ) ; El mtodo 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 precaucin, 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. Tambin observe el uso del mtodo length ( ) de la clase String:
Pag. 351
cant = nom.length ( ) ; El mtodo 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 mtodo 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 condicin lgica o almacenarlo en una variable. En nuestro ejemplo lo utilizamos como condicin lgica y para almacenarlo en una variable. En la lneas de cdigo mostradas a continuacin, 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 vlido Reintente! ) ; } } while (nom.length ( ) < 2) ;
Pag. 352
Problema 104 Etapa 01 Descripcin del problema. Desarrollar un programa en Java que permita ingresar el nombre de un alumno. Mostrar el nombre del alumno en letras mayscula. Consistenciar el nombre del alumno al momento de ingresarlo. Etapa 04 Desarrollo de la codificacin.
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 vlido Reintente! ) ; } } while ( nom.length( ) < 2 ) ; nom = nom.toUpperCase( ) ; System.out.println ( El nombre en Mayscula es: + nom ) ; } } Observe el uso de los mtodos trim ( ), length ( ) y toUpperCase ( ) de la clase String. En la codificacin 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 mayscula, para finalmente mostrar su contenido por pantalla. En consecuencia, se puede afirmar que esta solucin es ms ptima que la solucin presentada en el problema 100.
Pag. 353
Problema 105 Etapa 01 Descripcin del problema. Desarrollar un programa en Java que permita ingresar el nombre de un alumno. Mostrar el primer caracter del nombre ingresado en maysculas. Etapa 04 Desarrollo de la codificacin.
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 vlido 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 codificacin? Observe el uso del mtodo substring ( ) de la clase String: cadena1 = nom.substring(0,1) ; cadena2 = nom.substring(1) ; El mtodo substring ( ) se utiliza de dos formas. La primera forma nos permite obtener una subcadena desde una posicin inicial hasta un caracter antes de la posicin final indicada. La segunda forma nos permite obtener una subcadena desde una posicin determinada hasta el final de la cadena. Imagnese que la variable nom contiene el nombre danae, tal y como se muestra a continuacin:
Pag. 354
nom = danae. Cuando manipulamos cadenas con el mtodo substring ( ) debemos tener en cuenta que cada caracter de la cadena tiene una determinada posicin, empezando por la posicin cero (0). nom = danae.
posicin 0
Entonces, si deseamos obtener la primera letra de la cadena utilizamos la siguiente sentencia: cadena1 = nom.substring(0,1) ; Donde, el primer nmero del mtodo substring ( ) indica la posicin de la cadena nom desde donde va a empezar la subcadena y el segundo nmero indica la posicin final de la cadena (es importante mencionar que se debe incluir hasta un caracter antes de la posicin 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, utilizaramos la siguiente sentencia: cadena1 = nom.substring (1,4) ; Continuando con nuestro ejemplo, una vez obtenida la primera letra del nombre se convierte a mayscula 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 mtodo substring ( ), donde el nmero (en nuestro caso el nmero 1), indica la posicin 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 mtodo concat ( ). nom = cadena1.concat (cadena2) ; El resultado que se obtiene es el nombre ingresado con la primera letra en mayscula.
Pag. 355
Problema 106 Etapa 01 Descripcin del problema. Desarrollar un programa en Java que permita ingresar el nombre de un alumno. Mostrar el primer caracter del nombre ingresado en maysculas y el resto en minscula. Etapa 04 Desarrollo de la codificacin.
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 vlido 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 mtodos trim ( ), length ( ), substring ( ) en sus dos formas, toUpperCase ( ), toLowerCase ( ) y concat ( ) de la clase String. En la codificacin de este programa, se convierte en mayscula la primera letra del nombre y el resto se convierte en minscula. Esto como precaucin de que se ingrese todo el nombre en mayscula o en forma combinada entre letras maysculas y minsculas. Finalmente siempre el nombre tendr la primera letra en mayscula y el resto en letra minscula. En consecuencia, se puede afirmar que esta solucin es ms ptima que la solucin presentada en el problema 104.
Pag. 356
Problema 107 Etapa 01 Descripcin 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 maysculas y el resto de cada palabra en minscula. Etapa 04 Desarrollo de la codificacin.
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 vlido Reintente! ) ; } } while (nom.length( ) < 2) ; cant = nom.length( ) ; for (int x=0; x<cant; x++) { if ( x==0) { cadena1 = nom.substring(0,1) ; cadena1 = cadena1.toUpperCase( ) ; cadena2 = nom.substring(1) ; cadena2 = cadena2.toLowerCase( ) ; nom = cadena1.concat(cadena2) ; } else { caracter = nom.substring(x, x+1) ; if (caracter.equals ( ) ) { cadena1 = nom.substring(0,x+1) ; caracter = nom.substring(x+1, x+2) ; caracter = caracter.toUpperCase( ); cadena2 = nom.substring(x+2) ; nom = cadena1 + caracter + cadena2 ; } } } System.out.println ( El nombre del alumno es: + nom ) ; } } Qu hay de nuevo en la codificacin?
Pag. 357
Observe el uso del mtodo equals ( ) de la clase String: if (caracter.equals ( )) { } El mtodo 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 mtodo equals ( ) nos devuelve un valor verdadero (true), en caso contrario nos devuelve un valor falso (false). Este valor devuelto se evala en la estructura de decisin if. Imagnese que la variable nom contiene el siguiente nombre: nom = danae alessandra flores bertolotti ; Nosotros desearamos que la primera letra de cada nombre y de cada apellido de un alumno este en letra mayscula, mientras que el resto de las letras estn en letra minscula. Al inicio utilizamos parte de la solucin del problema 105. Despus 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 mayscula 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
Despus 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 ms de un espacio en blanco. Qu sucede? Modificando la solucin anterior para poder considerar la problemtica anterior tendramos la siguiente variacin: cant = nom.length( ) ; sw = false ; for (int x=0; x<cant; x++) { if (x==0) { cadena1 = nom.substring(0,1) ; cadena1 = cadena1.toUpperCase( ) ; cadena2 = nom.substring(1) ; cadena2 = cadena2.toLowerCase( ) ; nom = cadena1.concat(cadena2) ; } else { caracter = nom.substring(x, x+1) ; if (caracter.equals( ) ) { sw = true ; } else { if (sw) {
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 solucin se utiliza un centinela (o flag) que nos permite indicar el momento preciso para realizar la conversin de la primera letra del nombre o apellido a letra mayscula, sin preocuparnos de la cantidad de espacios en blanco que pueda existir entre dos nombres.
Pag. 359
Problema 108 Etapa 01 Descripcin del problema. Desarrollar un programa en Java que permita ingresar los apellidos y nombres de un obrero (en una sola variable). Mostrar el nmero de caracteres blancos o espacios en blanco que existan. Etapa 04 Desarrollo de la codificacin.
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 vlido Reintente! ) ; } } while (nom.length( ) < 2 ) ; cant = nom.length( ) ; for (x=0;x<cant;x++) { caracter = nom.substring(x,x+1) ; if (caracter.equals ( ) ) { cont ++ ; } } System.out.println ( La cantidad de espacios: + cont ) ; } } Observe el uso de los mtodos trim ( ), length ( ), substring ( ) y equals ( ) de la clase String. En la codificacin de este programa, se evala caracter por caracter (de la variable nom). Si el caracter es igual a un espacio en blanco ( ), se le aumenta uno a la variable cont (que esta trabajando como contador de espacios encontrados en la variable nom).
Pag. 360
Problema 109 Etapa 01 Descripcin del problema. Desarrollar un programa en Java que permita ingresar los apellidos y nombres de un obrero (en una sola variable). Mostrar el nmero de caracteres del nombre ingresado por teclado que no sean espacios en blanco. Etapa 04 Desarrollo de la codificacin.
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 vlido Reintente! ) ; } } while (nom.length( ) < 2 ) ; cant = nom.length( ) ; for (x=0; x<cant; x++) { caracter = nom.substring(x,x+1) ; if ( !caracter.equals ( ) ) { cadena = cadena.concat(caracter) ; } } cant = cadena.length( ) ; System.out.println ( La cantidad de caracteres sin contar espacios: + cant ) ; } }
Observe el uso de los mtodos trim ( ), length ( ), substring ( ) y equals ( ) de la clase String. En la codificacin de este programa, se evala 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 ningn 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 Descripcin del problema. Desarrollar una solucin que permita ingresar los apellidos y nombres de un obrero (en una sola variable). Mostrar el nmero de caracteres que no son espacios en blanco y el nmero de caracteres que son espacios en blanco. Etapa 04 Desarrollo de la codificacin.
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 vlido Reintente! ) ; } } while (nom.length( ) < 2 ) ; cant = nom.length( ) ; fo r(x=0; x<cant; x++) { caracter = nom.substring(x,x+1) ; if (caracter.equals ( ) ) { cont ++ ; } } System.out.println ( La cantidad de espacios: + cont ) ; System.out.println ( La cantidad de caracteres sin contar espacios: + ( cant - cont ) ) ; } } En la codificacin de este programa, se emplea la misma estrategia que la utilizada en la solucin del problema 108, para obtener el nmero de espacios en blanco contenidos en la variable nom. Al final se obtiene la longitud total de la cadena nom y realizando una simple resta se obtiene el nmero de caracteres de la variable nom que no son espacios en blanco.
Pag. 362
Problema 111 Etapa 01 Descripcin del problema. Desarrollar una solucin que permita ingresar el nombre de un alumno. Mostrar el nmero de vocales que hay en el nombre ingresado. Etapa 04 Desarrollo de la codificacin.
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 vlido Reintente! ) ; } } while (nom.length( ) == 0 ) ; cant = nom.length( ) ; nom = nom.toLowerCase( ) ; for (x=0; x<cant; x++) { c = nom.charAt(x) ; d = (int) (c) ; switch (c) { case 97 : // a case 101 : // e case 105 : // i case 111 : // o case 117 : cont ++ ; // u } } System.out.println ( El Total de Vocales es: + cont ) ; } }
Pag. 363
Qu hay de nuevo en la codificacin? Observe el uso del mtodo charAt ( ) de la clase String: nom.charAt (x) ; El mtodo 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 mtodo charAt ( ) devuelve un caracter). c = nom.charAt (x) ; El caracter obtenido es evaluado para determinar si es o no una vocal. Esta evaluacin se realiza a travs de los cdigos ASC correspondientes a las vocales (es importante mencionar que la evaluacin de una variable de tipo char se puede realizar utilizando los cdigos ASC equivalentes a los caracteres especiales, letras y nmeros). Antes de iniciar la evaluacin de cada uno de los caracteres de la variable nom, se utiliza el mtodo toLowerCase ( ) para asegurarnos de convertir a letras minsculas todos los caracteres de la variable nom y luego utilizar los cdigos ASC equivalentes a las vocales en minscula. Modifique la solucin 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 Descripcin del problema. Desarrollar un programa en Java que permita ingresar el nombre de un alumno. Mostrar el nmero de vocales y el nmero de caracteres que no son vocales que hay en el nombre ingresado. Etapa 04 Desarrollo de la codificacin.
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 vlido Reintente! ) ; } } while (nom.length( ) == 0 ) ; cant = nom.length( ) ; nom = nom.toLowerCase( ) ; for (x=0; x<cant; x++) { c = nom.charAt(x) ; d = (int) (c) ; switch (c) { case 97 : // a case 101 : // e case 105 : // i case 111 : // o case 117 : cont ++ ; // u } } System.out.println ( El Total de Vocales es: + cont ) ; System.out.println ( El Total de caracteres que no son vocales es: + (cant cont) ) ; } }
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 solucin anterior de tal forma que pueda determinar cuntas vocales almacenadas en la variable nom son maysculas y cuntas son minsculas. Tambin puede modificar la solucin de tal forma que permita determinar cuntas consonantes contiene la variable nom. Recuerde utilizar los equivalentes en cdigo ASC de las consonantes en letra minscula o en letra mayscula.
Pag. 366
Problema 113 Etapa 01 Descripcin 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 codificacin.
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 vlido... 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 vlida... 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 nmero de veces que se repite ) ; System.out.println ( la subcadena en la cadena es: + cont ) ;
Pag. 367
Contina... Etapa 04 - Desarrollo de la codificacin.

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 mtodos trim ( ), length ( ), substring ( ) y equals ( ) de la clase String. La parte central de la solucin radica en las siguientes lneas de cdigo: 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 nmero 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 lmite para la evaluacin del nmero de veces que se repite cad2 en cad1, es el caracter ubicado en la posicin total de cad2. Despus, empezando desde el primer caracter de cad1 se extrae una subcadena (subcad) del mismo tamao que cad2 y se comparan para ver si son iguales utilizando el mtodo 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 lmite para la evaluacin del nmero de veces que se repite cad2 en cad1 es el caracter ubicado en la posicin 2 de cad2. cad1 = Danae
0 12
Lmite para la evaluacin
Observe que cad2 tiene una longitud=3 por lo que la ltima evaluacin ser: cad2 = ana y subcad= nae
Primera evaluacin: cad2 = ana y Resultado: falso.
subcad = Dan
Segunda evaluacin: cad2 = ana y subcad = ana Resultado: verdadero (cont =1). Primera evaluacin: cad2 = ana y Resultado: falso. subcad = nae
Finalmente, se concluye que cad2 se repite una vez en cad1.
Pag. 369
Problema 114 Etapa 01 Descripcin 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 codificacin.
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 vlido 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 vlido 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 mtodos 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 Descripcin del problema. Desarrollar un programa en Java que permita ingresar los nombres de dos alumnos. Mostrar los nombres ordenados alfabticamente. Etapa 04 Desarrollo de la codificacin.
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 alfabticamente ) ; System.out.println ( ------------------------------------------------- ) ; System.out.println (nombreMenor) ; System.out.println (nombreMayor) ; } } Qu hay de nuevo en la codificacin? Observe el uso del mtodo compareTo ( ) de la clase String: nombre1.compareTo (nombre2) ; El mtodo compareTo ( ) permite comparar dos variables de tipo String. El mtodo 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 comparacin alfabtica en la cual tienen significado las letras maysculas, las letras minsculas, los caracteres especiales y los espacios en blanco. Por ejemplo; comparemos las siguientes cadenas: 1. nombre1 = Pedro y nombre2 = Luis. 2. nombre1 = Danae y nombre2 = Danae. 3. nombre1 = Carmen y nombre2 = Juan. nombre1 > nombre2 nombre1 = nombre2 nombre1 < nombre2
En base a esto, mejore la solucin de tal forma que se pueda realizar la consistencia de los nombres ingresados.
Pag. 372
Problema 116 Etapa 01 Descripcin 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 alfabticamente. Etapa 04 Desarrollo de la codificacin.
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 vlido...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 vlido...Reintente!!! ) ; } } while ( nombre2.length( ) < 2 ) ; if ( nombre1.compareTo(nombre2) < 0 ) { nombreMenor = nombre1 ; nombreMayor = nombre2 ; } else { nombreMenor = nombre2 ; nombreMayor = nombre1 ; }
Pag. 373

Clase PrgOrdenados2
System.out.println ( ------------------------------------------------- ) ; System.out.println ( Nombres ordenados alfabticamente ) ; System.out.println ( ------------------------------------------------- ) ; System.out.println (nombreMenor) ; System.out.println (nombreMayor) ; } }
Mejore la codificacin del programa, de tal forma que se contemple la posibilidad que los nombres ingresados sean iguales.
Pag. 374
Problema 117 Etapa 01 Descripcin 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 alfabticamente. Etapa 04 Desarrollo de la codificacin.
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 vlido...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 vlido...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 vlido...Reintente!!! ) ; } } while ( nombre3.length( ) == 0 ) ;
Pag. 375

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 alfabticamente ) ; System.out.println ( ------------------------------------------------- ) ; System.out.println (nom01) ; System.out.println (nom02) ; System.out.println (nom03) ; } } Desarrolle la siguiente prueba: 1. 2. 3. Ejecute el programa, ingrese los siguientes datos y compruebe lo que sucede: nombre1 = Armando. nombre2 = Armando. nombre3 = Beto. Luego ingrese los siguientes datos y compruebe nuevamente lo que sucede: nombre1 = Armando. nombre2 = Beto. nombre3 = Beto. Finalmente ingrese los siguientes datos. Compruebe lo que sucede: nombre1 = Armando. nombre2 = Armando. nombre3 = Armando.
Modifique la codificacin de la solucin de tal forma que pueda mejorarla.
Pag. 376
Problema 118 Etapa 01 Descripcin del problema. Desarrollar un programa en Java que permita ingresar los nombres de tres alumnos (los nombres pueden ser iguales). Mostrar los nombres ordenados alfabticamente. Etapa 04 Desarrollo de la codificacin.
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 vlido...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 vlido...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 vlido...Reintente!!! ) ; } } while (nombre3.length( ) == 0 ) ;
Pag. 377

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 alfabticamente ) ; System.out.println ( ------------------------------------------------- ) ; System.out.println (nom01) ; System.out.println (nom02) ; System.out.println (nom03) ; } } Desarrolle la siguiente prueba: Ingrese los nombres con letras maysculas y minsculas, por ejemplo: nombre1 = armando. nombre2 = Beto. nombre3 = Armando.
Compruebe lo que sucede. Se ordenarn primero los nombres que comiencen con mayscula y luego los nombres que comiencen con minscula. Modifique el programa de tal forma que se cambie la primera letra del nombre ingresado a mayscula.
Pag. 378
Problema 119 Etapa 01 Descripcin del problema. Desarrollar un programa en Java que permita ingresar los nombres de tres alumnos. Asegrese que los nombres ingresados empiecen con una letra mayscula. Mostrar los nombres ordenados alfabticamente. Etapa 04 Desarrollo de la codificacin.
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 vlido...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 vlido...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

Clase PrgOrdenados5
if ( nombre3.length( ) == 0 ) { System.out.println ( Nombre ingresado no vlido...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 alfabticamente ) ; System.out.println (nom01) ; System.out.println (nom02) ; System.out.println (nom03) ; } } Mejore la solucin desarrollando un programa que permita ingresar tres nombres de alumnos. Asegrese que los nombres ingresados empiecen con una letra mayscula y que el resto de las letras de los nombres estn en minscula. Muestre los nombres ordenados alfabticamente. Luego, complemente la solucin permitiendo el ingreso de los nombres de todos los alumnos de un determinado saln de clase.
Pag. 380
Problema 120 Etapa 01 Descripcin 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 codificacin.
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<cant; x++ ) { caracter = nom.substring(x,x+1) ; if ( dato1.equals(caracter) == true ) cadena = cadena + dato2 ; else cadena = cadena + caracter ; } System.out.println ( El resultado es: + cadena ) ; } }
Qu hay de nuevo en la codificacin? Observe el uso del mtodo equals ( ) de la clase String: nombre1.equals (nombre2) ;
Pag. 381
El mtodo equals ( ) devuelve true (verdadero) si la cadena coincide con la cadena colocada como parmetro del mtodo equals ( ), caso contrario devuelve false (falso). Por lo que en este caso el mtodo equals ( ) evala a la variable dato1 y a la variable caracter. La variable caracter tuvo que declararse como String para poder ser utilizada por el mtodo equals ( ) de esta forma: caracter = nom.substring (x , x+1) ; Un punto muy importante es el anlisis de la siguiente lnea de cdigo: if ( dato1.equals (caracter) == true ) La sentencia if puede evaluar una condicin lgica, una variable booleana o el resultado de una operacin. En nuestro caso, el mtodo equals ( ) devuelve true (verdadero) o false (falso), dependiendo del resultado de la comparacin 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 lgicas utilizadas en la sentencia if (esto se hace extensivo a las sentencias do, while y for).
Pag. 382
Problema 121 Etapa 01 Descripcin del problema. Desarrollar un programa en Java que permita ingresar un nmero mayor de tres dgitos. Convertir el nmero en cadena, luego intercambiar posiciones, el primer digito pasarlo al ltimo y el ltimo digito pasarlo al primero. Mostrar el nuevo nmero. Etapa 04 Desarrollo de la codificacin.
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 dgitos: "); num = Lectura.leerInt(); if (num < 100) { System.out.println(" Nmero ingresado no vlido 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 codificacin? Observe el uso del mtodo valueOf ( ) de la clase String:
String.valueOf (num) ;
El mtodo valueOf ( ) se utiliza directamente con la clase String (y no con una variable de tipo String). Este mtodo permite convertir una variable de cualquier tipo a una variable de tipo String o cadena. En nuestra solucin convertimos la variable num a String con la finalidad de poder manipular el contenido de la variable con mtodos de la clase String. Una vez convertida la variable num, se utiliza el mtodo substring ( ) para intercambiar las posiciones deseadas.
Pag. 383
Problema 122 Etapa 01 Descripcin 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 revs). Etapa 04 Desarrollo de la codificacin.
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 vlido 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 revs es: + cadena ) ; } } Qu hay de nuevo en la codificacin? Observe el uso del mtodo 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 ejecucin 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 solucin, la variable caracter debe declararse como char. Observe como se utiliza el mtodo 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 + (concatenacin).
Pag. 385
Problema 123 Etapa 01 Descripcin 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 codificacin.
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 vlido... 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 solucin desarrollando un programa que permita ingresar los nombres de todos los alumnos. Utilice la estructura do while. Asegrese que los nombres ingresados empiecen con una letra mayscula y que el resto de las letras de los nombres estn en minscula.
Pag. 386
Problema 124 Etapa 01 Descripcin del problema. Desarrollar un programa en Java que permita ingresar los nombres de todos los empleados de una empresa. Mostrar el nmero de vocales que existen en cada uno de los nombres ingresados. Etapa 04 Desarrollo de la codificacin.
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 vlido Reintente! ) ; } } while ( nom.length( ) == 0 ) ; cant = nom.length( ) ; nom = nom.toLowerCase( ) ; for ( x=0; x<cant; x++ ) { c = nom.charAt(x) ; d = (int) (c) ; switch(c) { case 97 : // a case 101 : // e case 105 : // i case 111 : // o case 117 : cont ++ ; // u } } System.out.println ( El Total de Vocales del nombre ingresado es: + cont ) ; System.out.println ( Desea ingresar otro nombre (S = 1, No = 2): ) ; opc =Lectura.leerInt( ) ; } while ( opc != 1 ) ; } }
Pag. 387
Mejore la solucin desarrollando un programa que considere el conteo de las vocales acentuadas y las vocales en letra mayscula. Como sugerencia investigue los cdigos ASCII de las vocales acentuadas y las vocales en letra mayscula, y agrguelos en la sentencia switch ( ).
Pag. 388
Problema 125 Etapa 01 - Descripcin 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 Codificacin.
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 vlida 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
Anlisis de la solucin Ingresamos la cantidad de alumnos y la almacenamos en la variable cantidad, se valida el nmero 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 mtodos length ( ) y substring ( ) de la clase String, y la forma como se utilizan las estructuras lgicas para la solucin del problema.
Pag. 390
Problema 126 Etapa 01 - Descripcin del problema. Desarrollar un programa en Java que permita ingresar los nombres de todos los alumnos de un saln 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 Codificacin.
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 vlida 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
Anlisis de la solucin Ingresamos la cantidad de alumnos y la almacenamos en la variable cantidad, se valida el nmero 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 mtodos length ( ) de la clase String, y la forma como se utilizan las estructuras lgicas para la solucin del problema.
Pag. 392
Problema 127 Etapa 01 - Descripcin 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 Codificacin.
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 ao ingresado esta incorrecto ) ; } else { System.out.println ( La fecha ingresada es correcta ) ; } } } } } }
Intente mejorar la solucin validando la fecha, de tal forma que el mes ingresado slo sea vlido si es que la variable dia contiene el nmero de das vlidos para dicho mes. Incluya la posibilidad que el mes de febrero sea bisiesto.
Pag. 393
Problema 128 Etapa 01 - Descripcin 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*****

Clase PrgCompletarCadenaIzq
package dominioDeLaAplicacion ; import biblioteca.Lectura ; class PrgCompletarCadenaIzq { public static void main ( String arg [ ] ) { String cadena ; int longitud, tamao, x ; System.out.println ( La longitud especificada es: ) ; longitud = Lectura.leerInt( ) ; System.out.println ( Ingresar cadena: ) ; cadena = Lectura.leerString( ) ; if ( longitud > cadena.length( ) ) { tamao = longitud - cadena.length( ) ; for ( x = 1; x <= tamao; x++) { cadena = cadena + * ; } } System.out.println ( La nueva cadena es: + cadena ) ; } }
Pag. 394
Problema 129 Etapa 01 - Descripcin 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

Clase PrgCompletarCadenaDer
package dominioDeLaAplicacion ; import biblioteca.Lectura ; class PrgCompletarCadenaDer { public static void main ( String arg [ ] ) { String cadena ; int longitud, tamao, x ; System.out.println ( La longitud especificada es: ) ; longitud = Lectura.leerInt( ) ; System.out.println ( Ingresar cadena: ) ; cadena = Lectura.leerString( ) ; if ( longitud > cadena.length( ) ) { tamao = longitud - cadena.length( ) ; for ( x = 1; x <= tamao; x++ ) { cadena = * + cadena ; } } System.out.println ( La nueva cadena es: + cadena ) ; } }
Pag. 395
Problema 130 Etapa 01 - Descripcin del problema. Desarrollar un programa en Java que permita transformar un arreglo de caracteres en una cadena, especificando la posicin del arreglo donde va ha comenzar la cadena y su longitud. Analizar la solucin. Etapa 04 - Desarrollo de la Codificacin.
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 codificacin? Observe el uso del mtodo valueOf ( ) de la clase String: String.valueOf ( char [ ], int, int ) ; El mtodo valueOf ( ) se utiliza directamente con la clase String (y no con una variable de tipo String). Este mtodo permite convertir un arreglo de caracteres o parte de l, en una variable de tipo String o cadena. En nuestra solucin convertimos parte del arreglo arregloA a un String con la finalidad de mostrar el contenido de dicha variable. Observe que en este mtodo, en primer lugar, se especifica el arreglo de tipo char del cual se va ha obtener la cadena. En segundo lugar, se indica la posicin del arreglo desde el cual se van a tomar los datos y finalmente, se indica la longitud o el nmero de caracteres que se van a obtener del arreglo. En el ejemplo, se muestra como resultado la cadena ana. Los arreglos sern tratados en el siguiente captulo.
Pag. 396
OTRAS CLASES EN JAVA En general, el lenguaje de programacin Java incorpora una gran cantidad de clases en paquetes organizados en su Jerarqua de Clases. Es fundamental que se contine investigando el uso de otras clases incorporadas en esta jerarqua de clases con la finalidad de mejorar la calidad de las soluciones que se desarrollen. En el CD, adjunto al presente texto, encontrar ms informacin sobre otras clases de la Jerarqua de Clases de Java. Como ejemplo, se puede mencionar la clase DecimalFormat del paquete java.text.
Problema 131 Etapa 01 - Descripcin del problema. Desarrollar un programa en Java que permita ingresar un nmero por teclado. Mostrar el nmero ingresado con un formato determinado. Analizar la solucin. Etapa 04 - Desarrollo de la Codificacin.
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 nmero 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 mtodo constructor. Luego con el mtodo format ( ) se procede a establecer el formato establecido para el nmero ingresado.
Pag. 397
Pag. 398
Captulo
Estructura de Datos Arreglos
Temas: Introduccin. Estructura de Datos: Arreglos.

Generalidades. Declaracin, creacin e inicializacin. Ingreso y visualizacin de datos. Manejo bsico de datos.
Desarrollo de soluciones utilizando arreglos:

Formalizacin del mtodo de las 6D. Problemas resueltos.
Desarrollo de soluciones utilizando mltiples arreglos:

Arreglos en paralelo. Problemas resueltos.
ESTRUCTURAS DE DATOS Arreglos.
CAPTULO IV ESTRUCTURA DE DATOS ARREGLOS INTRODUCCIN Un algoritmo constituye una lista completa de pasos secuenciales y una descripcin 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 ms sencillas despus de la variable.
MARCO DE TRABAJO
Pag. 401
SE DESARROLLAN UTILIZANDO: Estructuras lgicas de secuencia. Estructuras lgicas de decisin. Estructuras lgicas de repeticin. Instrucciones de bifucacin. TAMBIN: Clases incorporadas en el lenguaje de programacin utilizado.
ALMACENADOS EN: Estructuras de datos tipo variables. Estructuras de datos tipo arreglo.
El presente captulo, trata sobre las estructuras de datos conocidas como arreglos y los conceptos ms importantes relacionados a stos; como se utilizan en las herramientas para disear algoritmos y como se emplean en un lenguaje de programacin para codificar programas de computadora. Al desarrollar soluciones bsicas, se utilizan las estructuras lgicas y las estructuras de datos en forma simultnea. Las estructuras lgicas y las estructuras de datos que se utilicen en una solucin, van a depender en general de la complejidad del problema.
Pag. 402
ESTRUCTURA DE DATOS ARREGLOS Definicin: Los arreglos conocidos tambin como arrays, son estructuras de datos que permiten almacenar ms 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 coleccin de datos relacionados a los que se hace referencia por medio de un nombre en comn (el nombre del arreglo). Los arreglos o arrays pueden tener de una a varias dimensiones. Aquellas que tienen una dimensin (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 posicin 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 (tcnicamente dichos valores se almacenan en celdas de memoria que estn 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 estn almacenados en una sola estructura de datos siendo ms fcil 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 nmeros enteros, o un arreglo de cadenas, pero no se puede tener un arreglo que contenga por ejemplo: cadenas y nmeros 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 nmero 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 mtodos que permiten crear un vector y redefinir su tamao cada vez que sea necesario).
Pag. 404
Representacin grfica Arreglos Unidimensionales: Un arreglo unidimensional puede ser representado como un vector o como un registro. A continuacin se muestra la representacin grfica 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
0
X1
1
X2
2
...
...
X I-1
i -1
Donde: nombre X0...X i -1 i = = = Nombre del vector. Datos almacenados en el vector. Tamao del vector.
Arreglos Bidimensionales Un arreglo bidimensional puede ser representado como una matriz o como una tabla. A continuacin se muestra la representacin grfica de un arreglo bidimensional llamado nombre: Como matriz:
X 0,0 X 1,0 X 2,0 nombre = X 0,1 X 0,2
X 0,j -1
. . .
X i-1,0 X i-1,j -1
(i, j)
Como tabla:
Pag. 405
nombre
Columnas
0 0 1 Filas 2
j-1
X 0,0 X 1,0 X 2,0 X i-1,0
X 0,1
X 0,2
X 0,j -1
i-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. Tamao de la matriz.
En el presente texto, para referirnos a los arreglos unidimensionales se utilizar la representacin del arreglo como registro y para referirnos a los arreglos bidimensionales se utilizar la representacin del arreglo como tabla. Por ejemplo; si se desea representar el almacenamiento de las notas finales de 10 alumnos de un saln de clase en un arreglo unidimensional (representado como un vector), se realizara de la siguiente manera:
notas
10
0
15
1
20
2
19
3
14
4
13
5
16
6
11
7
17
8
09
i =10 9
Donde: notas i 10, 15,...,09 = = = Nombre del arreglo. Nmero 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 utilizara el nombre del vector (notas), seguido de un ndice igual a 1 entre corchetes ([1]), segn se muestre a continuacin:
Pag. 406
notas[1]
notas
10
0
15
1
20
2
19
3
14
4
13
5
16
6
11
7
17
8
09
i =10 9
Tambin, 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 saln de clase en un arreglo bidimensional (representado como una tabla), se realizara de la siguiente manera:
notas
Alumno 1
Alumno 2
Alumno10
Nota EP
10 12 03
11 14 11
02 12 15
05 11 05
18 16 12
16 17 17
17 12 02
11 18 11
17 10 09
09 08 11
Nota Tra
Nota EF
(i =3, j=10)
Donde: notas j i 10,11,,09 12,14,,08 03,11,,11 = = = = = = Nombre del arreglo. Nmero de alumnos. Nmero de notas. Son las notas de Examen Parcial de c/u de los alumnos del saln de clase. Son las notas de Trabajo de c/u de los alumnos del saln de clase. Son las notas de Examen Final de c/u de los alumnos del saln 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 utilizara el nombre de la tabla (notas), seguido de dos ndices iguales a 2 y 1, entre corchetes ( [2] [1] ), segn se muestra a continuacin:
Pag. 407
notas
Alumno 1
Alumno 2
Alumno10
0 Nota EP 0
10 12 03
11 14 11
02 12 15
05 11 05
18 16 12
16 17 17
17 12 02
11 18 11
17 10 09
09 08 11
Nota Tra
Nota EF
(i =3, j=10)
Notas[2][1]
Declaracin 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 definicin 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 vlidos para declarar un arreglo son los mismos tipos de datos vlidos definidos para declarar variables y constantes. En general, para declarar un arreglo se utiliza el siguiente formato: En pseudocdigo 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 vlido y arreglo es el nombre del arreglo (puede existir ms de un arreglo, los cuales sern 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
Tambin se puede declarar un arreglo colocando los corchetes de apertura y cierre despus del tipo de dato y no despus del nombre del arreglo, segn se muestra a continuacin: En pseudocdigo y diagrama de flujo: TipoDeDato[ ] arreglo TipoDeDato[ ][ ] arreglo En Java: TipoDeDato[ ] arreglo ; TipoDeDato[ ][ ] arreglo ; Como ejemplo de declaracin de arreglos vlidos en Java podemos utilizar:
EJEMPLOS DESCRIPCIN
Se declara un arreglo unidimensional llamado edades en el cual se podr almacenar datos de tipo NUMERO, solo parte entera (int).
int edades[ ] ;
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).
Creacin 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 tamao del mismo. Es decir, cual va ser la cantidad total de datos que se podr almacenar en el arreglo. El tamao de un arreglo puede especificarse en forma directa utilizando un nmero entero o en forma indirecta utilizando una variable entera. En ambos casos, el tamao del arreglo siempre deber especificarse como un nmero entero. Para crear un arreglo se utiliza el siguiente formato: En pseudocdigo y diagrama de flujo: CREAR arreglo[tamao]
Pag. 409
CREAR arreglo[filas ][columnas] En Java: arreglo = new TipoDeDato [tamao] ; arreglo = new TipoDeDato [filas][columnas] ; Donde TipoDeDato debe ser un tipo de arreglo o tipo de dato vlido 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 tamao 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 nmero total de filas y el otro para referirnos al nmero total de columnas que va a tener el arreglo. En Java, existe tambin una forma directa para declarar y crear arreglos, utilizando el siguiente formato: En Java: TipoDeDato arreglo[ ] = new TipoDeDato [tamao]; TipoDeDato arreglo[ ][ ] = new TipoDeDato [filas][columnas]; Donde TipoDeDato debe ser un tipo de arreglo o tipo de dato vlido y arreglo es el nombre del arreglo. Utilizando este formato se declara y crea el arreglo en forma directa (esto es conocido como Definicin de un arreglo). Las consideraciones tratadas en los temas Declaracin de arreglo y Creacin de arreglos son vlidas al utilizar este formato.
Pag. 410
Una consideracin importante antes de utilizar un arreglo en Java:

En Java, no se realiza ninguna clase de comprobacin del tamao de los arreglos en forma automtica. Esto quiere decir que se puede desbordar el final de un arreglo (se lanza una excepcin 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 ejecucin del programa.
Ejemplo de creacin de arreglos vlidos 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). Se crea un arreglo unidimensional llamado nombres, previamente declarado, en el cual se podr almacenar 10 datos de tipo TEXTO (String). Se crea un arreglo bidimensional llamado notas, previamente declarado, en el cual se podr almacenar 30 datos de tipo NUMERO (double).
edades = new int [10] ;
int total = 10 ; nombres = new String [total] ;
int numAlu, numNot ; numAlu = 10 ; numNot = 3 ; notas = new double [numNot][numAlu] ;
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 podra modificar esta parte para que el valor se ingrese a travs del teclado, tal y como se muestra a continuacin:
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 estarn organizados en 3 filas y 10 columnas. Tambin se podra haber declarado y creado los arreglos del ejemplo anterior, en forma directa, tal y como se muestra a continuacin;
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] ;
Inicializacin 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 posicin con la finalidad de evitar que se produzca un error si se intenta acceder a una posicin del arreglo que todava no contiene un dato. Generalmente, los arreglos numricos (tipo NUMERO) se inicializan con cero (0), los arreglos lgicos (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 Despus de crear un arreglo, inicialice o no el arreglo, se debern 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
posicin del arreglo que no tiene un dato o que no ha sido inicializado, produce un error que ocasiona que se interrumpa la ejecucin del programa. Para ingresar datos a todas las posiciones de un arreglo generalmente se utiliza la estructura lgica de repeticin DESDE (for en Java). Tambin 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 almacenarn en el arreglo dentro de llaves, separadas por comas, tal y como se muestra a continuacin.
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 tambin 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 nmeros enteros) con 10 valores. No se ha utilizado el operador new (para crear el arreglo) y tampoco se ha especificado el tamao 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 utilizara 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 solucin de un determinado problema. En trminos 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 modificacin de datos. Proceso de eliminacin de datos. Proceso de ordenacin de datos.
Proceso de Modificacin de Datos: Permite modificar uno o ms datos de un arreglo, que se ingresaron a travs 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 bsqueda de datos. Proceso de Eliminacin de Datos: Permite eliminar uno o ms datos de un arreglo que se ingresaron a travs 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 bsqueda de datos y previniendo al usuario que si se elimina el dato no podr ser recuperado posteriormente. Proceso de Ordenacin de Datos: Permite ordenar todos los datos de un arreglo en funcin de un criterio. Dicho criterio establece la forma de ordenar los datos de un arreglo. La ordenacin puede ser en forma alfabtica o numrica de mayor a menor o viceversa. 2). Proceso que permite visualizar o consultar el contenido del arreglo. Se pueden dividir en: Proceso de visualizacin de datos. Proceso de bsqueda datos. Proceso de clculo basado en datos del arreglo.
Pag. 414
Proceso de visualizacin 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 bsqueda datos: Permite buscar uno o ms datos dentro de un arreglo. Si el dato buscado es encontrado, indicar la posicin del arreglo en donde est almacenado el dato buscado. En este caso, se considera que la bsqueda fue exitosa. Proceso de clculo basado en datos del arreglo: Nos permite realizar diferentes tipos de clculo con los datos de un arreglo, tales como suma de datos, promedio, etc.
Pag. 415
Pag. 416
DESARROLLO DE SOLUCIONES BSICAS 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 mtodo principal, main( ) en Java, tal y como se muestra a continuacin. public static void main ( String arg[ ] ) { }
Arreglo de tipo String denominado arg
Esto significa que se puede incluir algunos parmetros al momento de ejecutar un proyecto de solucin. Dichos parmetros se pasan al mtodo main ( ) y se almacenan en el arreglo arg. Analizar las siguientes sentencias:
Clase Suma
/* Clase que nos permite sumar varios nmeros enteros , incluidos como parmetros */ 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 nmeros, 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 nmero entero, utilizamos el mtodo parseInt() de la clase Integer. En consecuencia, la lista de nmeros 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 nmeros incluidos como parmetros en la variable suma.
A continuacin se presenta la codificacin en Java de una solucin que permite ingresar la nota final de 10 alumnos, y calcula el promedio general de notas del saln 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 solucin anterior nos permite realizar el clculo y la visualizacin 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 captulo, para finalmente formalizar el Mtodo de las 6D. 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 solucin del problema, definiendo un nombre adecuado para cada uno de ellos. Crear el arreglo o arreglos con el tamao 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 solucin. Estos tres pasos generalmente se desarrollarn 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 solucin. Por lo tanto, el siguiente paso quedara definido de la siguiente manera: Manejar los datos almacenados en el arreglo o arreglos utilizados en la solucin con la finalidad de proporcionar la informacin solicitada. En la solucin, se utilizar un arreglo unidimensional llamado notas que permitir almacenar las notas finales de 10 alumnos de un determinado saln de clase. El arreglo notas almacenar datos de tipo NUMERO (nmero 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 ) { // Declaracin de variables y arreglos. int numAlu =10 ; double sumaNotas=0, notas[ ] ; // Creacin 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 clculo 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 solucin anterior, en primer lugar, se declara un arreglo unidimensional llamado notas[ ] (vector). Dicho arreglo podr almacenar datos numricos (parte entera y decimal). En segundo lugar, se crea el arreglo notas[ ] utilizando la siguiente sentencia: // Creacin 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 tamao igual a 10. Es decir, en el arreglo notas[ ] se podrn 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 permitirn el ingreso de los datos, las cuales estn ubicadas dentro de la misma sentencia for. Los datos que se ingresarn sern las notas finales de los 10 alumnos del saln 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 lgica de repeticin for permite que se repitan 10 veces las siguientes sentencias: System.out.print ( Ingrese nota : " ) ; notas[i] = Lectura.leerDouble( ) ; Cada vez que la estructura lgica de repeticin for se ejecuta, la variable i aumenta su valor en 1, siendo valores vlidos 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 posicin 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 posicin del arreglo notas[ ], es decir en notas[1], y as sucesivamente hasta cuando i = 9 (la dcima y ltima vez que se ejecuta la sentencia for), almacenando la nota ingresada en la dcima posicin del arreglo notas[ ], es decir en notas[9].
Pag. 420
Finalizada la ejecucin de la primera sentencia for, el arreglo notas[ ] deber tener almacenadas las notas finales de los 10 alumnos del saln de clase. Tal y como se muestra a continuacin:
notas
10
0
15
1
20
2
19
3
14
4
13
5
16
6
11
7
17
8
09
i =10 9
Finalmente, se ejecuta el proceso de clculo 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 acta como acumulador). Finalizada la ejecucin 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 clculo del promedio de las 10 notas finales se desarrollan utilizando 2 sentencias for exactamente iguales. Esto es recomendable como buena prctica de programacin ya que posteriormente cada proceso desarrollado se convertir en un mtodo de una clase con una funcin determinada.
Pag. 421
Ahora, se modificar la solucin anterior de tal forma que permita almacenar las notas finales de todos los alumnos de un determinado saln de clase.
Clase PrgAlumnos
package dominioDeLaAplicacion ; import biblioteca.* ; public class PrgAlumnos { public static void main(String[] args) { // Declaracin de variables. int numAlu ; double sumaNotas = 0 ; // Determinacin del tamao del arreglo. System.out.print ( Ingrese el nmero de alumnos : ) ; numAlu = Lectura.leerInt( ) ; // Declaracin y creacin 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 clculo 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 solucin anterior, se declara y crea el arreglo notas[ ] utilizando la siguiente sentencia:
// Declaracin y creacin 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 travs del teclado. Esto nos permite crear un arreglo llamado notas[ ] con un tamao equivalente al valor almacenado en la variable numAlu. Es decir, en el arreglo notas[ ] se podrn almacenar las notas finales de todos los alumnos de un saln de clase.
Pag. 422
Otra modificacin 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 posicin 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 posicin 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 solucin anterior, de tal forma que permita consistenciar la entrada de datos. Se consistenciar el ingreso del nmero 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) { // Declaracin de variables. int numAlu ; double sumaNotas = 0 ; // Determinacin del tamao del arreglo con consistencia de datos. do { System.out.print ( Ingrese el nmero de alumnos : ) ; numAlu = Lectura.leerInt( ) ; if ( numAlu <= 0 ) { System.out.println ( El nmero de alumnos no es valido Reintente! ) ; } } while ( numAlu < 0 ) ; // Declaracin y creacin 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 clculo 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 vlidos antes de que estos se almacenen en las variables o en los arreglos.
Pag. 424
FORMALIZACIN DE LA SOLUCIN UTILIZANDO EL MTODO DE LAS 6D
Problema 132 Etapa 01 - Descripcin del problema. Desarrollar una solucin que permita ingresar y almacenar las notas finales de todos los alumnos de un determinado saln de clase. Determinar y mostrar el promedio de las notas finales. Consistenciar el ingreso de datos. Etapa 02 - Definicin de la solucin. Resultado deseado: Mostrar el promedio de las notas finales de los alumnos de un determinado saln de clase. El nmero de alumnos y las notas finales de cada uno de ellos. El nmero de alumnos se ingresa a travs del teclado y se almacena en una variable (numAlu). Con el nmero 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. Despus, se realiza la suma de todas las notas finales y el resultado se almacena en una variable acumulador (sumaNotas). Finalmente, se realiza el clculo del promedio, se almacena el resultado en una variable (prom) y se muestra por pantalla.
Pag. 425
Etapa 03 - Diseo de la lgica. 1. Nombre del Proyecto: ProyAlumnos. 2. Definicin de Paquetes y desarrollo del Diagrama de Paquetes.
Clases biblioteca
Pag. 426
Algoritmo PrgAlumnos01 - mtodo main ( )

ENTRADA: numAlu, notas[ ] SALIDA: prom INICIO COMENTARIO Declaracin de variables NUMERO i, numAlu, sumaNotas = 0, notas[ ], prom COMENTARIO Determinacin del tamao del arreglo HACER LEER numAlu SI (numAlu <= 0 ) ENTONCES ESCRIBIR Nmero de alumnos no vlido... Reintente! FINSI MIENTRAS (numAlu <= 0 ) COMENTARIO Creacin 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 vlida... Reintente! FINSI MIENTRAS ( notas[i] > 20 || notas[i] < 0 ) FINDESDE COMENTARIO Clculo 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) { // Declaracin de variables. int i, numAlu ; double sumaNotas = 0, prom ; // Determinacin del tamao del arreglo con consistencia de datos. do { System.out.print ( Ingrese el nmero de alumnos : ) ; numAlu = Lectura.leerInt( ) ; if ( numAlu <= 0 ) { System.out.println ( El nmero de alumnos no es vlido Reintente! ) ; } } while ( numAlu <= 0 ) ; // Declaracin y creacin 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 vlida Reintente! ) ; } } while ( notas[i] > 20 || notas[i] < 0 ) ; } // Proceso de clculo 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 - Descripcin del problema. Desarrollar una solucin que permita ingresar y almacenar las notas de todas las prcticas de un alumno. Determinar el promedio de las prcticas sabiendo que se elimina la prctica con la nota mas baja. Mostrar el promedio redondeado. Consistenciar el ingreso de datos. Etapa 02 - Definicin de la solucin. Resultado deseado: Datos necesarios: Procesamiento: Mostrar el promedio redondeado de las notas de las prcticas de un alumno. El nmero de prcticas y las notas de las prcticas del alumno. El nmero de prcticas se ingresa a travs del teclado y se almacena en una variable (numPra). Con el nmero de prcticas se crea un arreglo (notas[ ]). Luego se procede a ingresar las notas de las prcticas del alumno y se almacenan en el arreglo creado. Despus, se realiza la suma de todas las notas de las prcticas y el resultado se almacena en una variable de tipo acumulador (sumaNotas). Luego, se determina la nota ms baja del alumno y se almacena en una variable (notaMenor). Finalmente, se realiza el clculo 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

ENTRADA: numPra, notas[ ] SALIDA: promAlu INICIO COMENTARIO Declaracin de variables NUMERO i, numPra, sumaNotas = 0, notaMenor = 20 NUMERO notas[ ], promAlu COMENTARIO Determinacin del tamao del arreglo HACER LEER numPra SI (numPra <= 0 ) ENTONCES ESCRIBIR Nmero de prcticas no vlido Reintente! FINSI MIENTRAS (numPra <= 0 ) COMENTARIO Creacin 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 vlida... Reintente! FINSI MIENTRAS ( notas[i] > 20 || notas[i] < 0 ) FINDESDE COMENTARIO Clculo del promedio de notas de las prcticas 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) { // Declaracin de variables. int i, numPra ; double sumaNotas = 0, notaMenor = 20, promAlu ; // Determinacin del tamao del arreglo con consistencia de datos. do { System.out.print ( Ingrese el nmero de prcticas del alumno : ) ; numPra = Lectura.leerInt( ) ; if ( numPra <= 0 ) { System.out.println ( El nmero de prcticas no es vlido Reintente! ) ; } } while ( numPra <= 0 ) ; // Declaracin y creacin 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 prctica [ + ( i + 1) + ]: ) ; notas[i] = Lectura.leerDouble( ) ; if ( notas[i] > 20 || notas[i] < 0 ) { System.out.println ( Nota ingresada no es vlida Reintente! ) ; } } while ( notas[i] > 20 || notas[i] < 0 ) ; } // Proceso de clculo del promedio de notas de las prcticas. 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 - Descripcin del problema. Desarrollar una solucin que permita ingresar y almacenar las notas de las tres prcticas de todos los alumnos de un saln de clase. Determinar el promedio de cada alumno sabiendo que se duplica su nota ms alta. Mostrar el promedio redondeado. Consistenciar el ingreso de datos. Etapa 02 - Definicin de la solucin. Resultado deseado: Datos necesarios: Procesamiento: Mostrar el promedio redondeado de las notas de las tres prcticas de cada alumno. El nmero de alumnos y las notas de las tres prcticas de cada alumno. El nmero de alumnos se ingresa a travs del teclado y se almacena en una variable (numAlu). Con el nmero de alumnos se crea un arreglo (notas[ ][ ]). Luego se procede a ingresar las notas de las tres prcticas de cada alumno y se almacenan en el arreglo creado. Despus, por cada alumno, se realiza la suma de las notas de sus tres prcticas y el resultado se almacena en una variable acumulador (sumaNotas). Luego, se determina su nota ms alta y se almacena en una variable (notaMayor). Finalmente, se realiza el clculo 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

ENTRADA: numAlu, notas[ ][ ] SALIDA: promAlu INICIO COMENTARIO Declaracin de variables NUMERO i, j, numAlu, sumaNotas = 0, notaMayor = 0 NUMERO notas[ ][ ], promAlu COMENTARIO Determinacin del tamao del arreglo HACER LEER numAlu SI (numAlu <= 0 ) ENTONCES ESCRIBIR Nmero de alumnos no vlido Reintente! FINSI MIENTRAS (numAlu <= 0 ) COMENTARIO Creacin 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 vlida... Reintente! FINSI MIENTRAS ( notas[i][j] > 20 || notas[i][j] < 0 ) FINDESDE FINDESDE COMENTARIO Clculo 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

Clase PrgAlumnos03
package dominioDeLaAplicacion ; import biblioteca.* ; public class PrgAlumnos03 { public static void main(String[] args) { // Declaracin de variables. int i, j, numAlu ; double sumaNotas = 0, notaMayor = 0, promAlu ; // Determinacin del tamao del arreglo con consistencia de datos. do { System.out.print ( Ingrese el nmero de alumnos : ) ; numAlu = Lectura.leerInt( ) ; if ( numAlu <= 0 ) { System.out.println ( El nmero de alumnos no es vlido Reintente! ) ; } } while ( numAlu <= 0 ) ; // Declaracin y creacin 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 prctica [ + ( j + 1) + ]: ) ; notas[i][j] = Lectura.leerDouble( ) ; if ( notas[i][j] > 20 || notas[i][j] < 0 ) { System.out.println ( Nota ingresada no es vlida Reintente! ) ; } } while ( notas[i][j] > 20 || notas[i][j] < 0 ) ; } } // Clculo 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 - Descripcin del problema. Desarrollar una solucin que permita ingresar y almacenar las notas de las prcticas de todos los alumnos de un saln de clase. Determinar el promedio de cada alumno sabiendo que se duplica su nota ms alta y se elimina su prctica 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 prcticas de los alumnos del saln de clase. Etapa 02 - Definicin de la solucin. Resultado deseado: Mostrar el promedio redondeado a dos decimales de las notas de las prcticas de cada alumno y el promedio simple de todas las notas de las prcticas de los alumnos. El nmero de alumnos, el nmero de prcticas y las notas de las prcticas de cada alumno. El nmero de alumnos y el nmero de prcticas se ingresa a travs 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 prcticas de cada alumno y se almacenan en el arreglo creado. Despus, por cada alumno, se realiza la suma de las notas de las prcticas y el resultado se almacenan en una variable de tipo acumulador (sumaNotas). Luego, se determina su nota ms alta y se almacena en una variable (notaMayor). Tambin se determina su nota mas baja y se almacena en una variable (notaMenor). Finalmente, se realiza el clculo de su promedio ((sumaNotas + notaMayor - notaMenor) / numPra), se almacena el resultado en una variable (promAlu), se redondea y se muestra por pantalla.
Datos necesarios:
Procesamiento:
Pag. 437
Adicionalmente, se realiza la suma de las notas de las prcticas de todos los alumnos del saln 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.

Pag. 438

ENTRADA: numAlu, numPra, notas[ ][ ] SALIDA: promAlu, prom INICIO COMENTARIO Declaracin de variables NUMERO i, j, numAlu, numPra, sumaNotas = 0, notaMayor = 0 NUMERO notaMenor = 20, notas[ ][ ], promAlu, prom COMENTARIO Determinacin del tamao del arreglo HACER LEER numAlu SI (numAlu <= 0 ) ENTONCES ESCRIBIR Nmero de alumnos no vlido.. Reintente! FINSI MIENTRAS (numAlu <= 0 ) HACER LEER numPra SI (numPra <= 0 ) ENTONCES ESCRIBIR Nmero de prcticas no vlido.. Reintente! FINSI MIENTRAS (numPra < 0 ) COMENTARIO Creacin 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 vlida... Reintente! FINSI MIENTRAS ( notas[i][j] > 20 || notas[i][j] < 0 ) FINDESDE FINDESDE
Pag. 439
Algoritmo PrgAlumnos04 mtodo main ( )

COMENTARIO Clculo 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 Clculo 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) { // Declaracin de variables. int i, j, numAlu, numPra ; double sumaNotas = 0, notaMayor = 0, notaMenor = 20, promAlu, prom ; /// Determinacin del tamao del arreglo con consistencia de datos. do { System.out.print ( Ingrese el nmero de alumnos : ) ; numAlu = Lectura.leerInt( ) ; if ( numAlu <= 0 ) { System.out.println ( El nmero de alumnos no es vlido Reintente! ) ; } } while ( numAlu <= 0 ) ; do { System.out.print ( Ingrese el nmero de prcticas : ) ; numPra = Lectura.leerInt( ) ; if ( numPra <= 0 ) { System.out.println ( El nmero de prcticas no es vlido Reintente! ) ; } } while ( numPra < 0 ) ; // Declaracin y creacin 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 prctica [ + ( j + 1) + ]: ) ; notas[i][j] = Lectura.leerDouble( ) ; if ( notas[i][j] > 20 || notas[i][j] < 0 ) { System.out.println ( Nota ingresada no es vlida Reintente! ) ; } } while ( notas[i][j] > 20 || notas[i][j] < 0 ) ; } }
Pag. 441
Contina Etapa 04 - Desarrollo de la Codificacin.
Clase PrgAlumnos04
// Clculo 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 ) ; } // Clculo 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 - Descripcin del problema. Desarrollar una solucin que permita ingresar y almacenar las notas del examen parcial, promedio de trabajos y examen final de todos los alumnos de un saln 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. Tambin, 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 - Definicin de la solucin. 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. El nmero de alumnos y las notas del examen parcial, promedio de trabajos y examen final de cada alumno. El nmero de alumnos se ingresa a travs del teclado y se almacena en una variable (numAlu). Con el nmero 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. Despus, 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 saln de clase y el resultado se almacena nuevamente en una variable acumulador (sumaEF). Se determina el promedio simple,
Datos necesarios:
Procesamiento:
Pag. 443
se almacena el resultado en una variable (promEF), se redondea y se muestra por pantalla. Finalmente, se realiza nuevamente el clculo 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.

Pag. 444
Algoritmo PrgAlumnos05- mtodo main ( )

ENTRADA: numAlu, notas[ ][ ] SALIDA: promAlu, promEF, porceAprob, porceDesaprob INICIO COMENTARIO Declaracin de variables NUMERO i, numAlu, sumaNotas = 0, sumaEF = 0 NUMERO notas[ ][ ], promAlu, promEF, porceDesaprob NUMERO aprobados = 0, desaprobados = 0, porceAprob COMENTARIO Determinacin del tamao del arreglo HACER LEER numAlu SI (numAlu <= 0 ) ENTONCES ESCRIBIR Nmero de alumnos no vlido Reintente! FINSI MIENTRAS (numAlu <= 0 ) COMENTARIO Creacin 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 vlida... 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 vlida... Reintente! FINSI MIENTRAS ( notas[1][i] > 20 || notas[1][i] < 0 )
Pag. 445
Algoritmo PrgAlumnos05- mtodo main ( )

HACER COMENTARIO Examen Final LEER notas[2][i] SI ( notas[2][i] > 20 || notas[2][i] < 0 ) ENTONCES ESCRIBIR Nota no vlida... Reintente! FINSI MIENTRAS ( notas[2][i] > 20 || notas[2][i] < 0 ) FINDESDE COMENTARIO Clculo 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 Clculo 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 Clculo 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

Clase PrgAlumnos05
package dominioDeLaAplicacion ; import biblioteca.* ; public class PrgAlumnos05 { public static void main(String[] args) { // Declaracin de variables. int i, numAlu, aprobados = 0, desaprobados = 0 ; double sumaNotas = 0, sumaEF = 0, promAlu, promEF, porceAprob, porceDesaprob ; // Determinacin del tamao del arreglo con consistencia de datos. do { System.out.print ( Ingrese el nmero de alumnos : ) ; numAlu = Lectura.leerInt( ) ; if ( numAlu <= 0 ) { System.out.println ( El nmero de alumnos no es vlido Reintente! ) ; } } while ( numAlu <= 0 ) ; // Declaracin y creacin 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 vlida 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 vlida 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 vlida Reintente! ) ; } } while ( notas[2][i] > 20 || notas[2][i] < 0 ) ; }
Pag. 447

Clase PrgAlumnos05
// Clculo 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 ) ; } // Clculo 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 ) ; // Clculo 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 - Descripcin del problema. Desarrollar una solucin 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. Condicin
sueldo < 410 sueldo >= 410 y sueldo <= 1600 sueldo > 1600
Aumento
20 % 10 % 05 %
Etapa 02 - Definicin de la solucin. Resultado deseado: Datos necesarios: Procesamiento: Mostrar el aumento de sueldo de cada uno de los trabajadores de una empresa. El nmero de trabajadores de la empresa y el sueldo de cada uno de ellos. El nmero de trabajadores se ingresa a travs del teclado y se almacena en una variable (numTrab). Con el nmero de trabajadores se crea un arreglo (sueldos[ ]). Luego se procede a ingresar los sueldos de cada trabajador y se almacenan en el arreglo creado. Despus, 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 - Diseo de la lgica. 1. Nombre del Proyecto: ProyTrabajadores.
2. Definicin de Paquetes y desarrollo del Diagrama de Paquetes.
Clases biblioteca
Pag. 450
Algoritmo PrgTrabajadores01 - mtodo main ( )

ENTRADA: numTrab, sueldos[ ] SALIDA: aumento INICIO COMENTARIO Declaracin de variables NUMERO i, numTrab, sueldos[ ], aumento = 0 COMENTARIO Determinacin del tamao del arreglo HACER LEER numTrab SI (numTrab <= 0 ) ENTONCES ESCRIBIR Nmero de trabajadores no vlido FINSI MIENTRAS (numTrab <= 0 ) COMENTARIO Creacin 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 vlido... FINSI MIENTRAS ( sueldos[i] <= 0 ) FINDESDE COMENTARIO Clculo 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

Clase PrgTrabajadores01
package dominioDeLaAplicacion ; import biblioteca.* ; public class PrgTrabajadores01 { public static void main(String[] args) { // Declaracin de variables. int i, numTrab ; double aumento = 0 ; // Determinacin del tamao del arreglo con consistencia de datos. do { System.out.print ( Ingrese el nmero de trabajadores de la empresa : ) ; numTrab = Lectura.leerInt( ) ; if ( numTrab <= 0 ) { System.out.println ( El nmero de trabajadores no es vlido Reintente! ) ; } } while ( numTrab <= 0 ) ; // Declaracin y creacin 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 vlido Reintente! ) ; } } while ( sueldos[i] <= 0 ) ; } // Clculo 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 - Descripcin del problema. Desarrollar una solucin 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 - Definicin de la solucin. Resultado deseado: Datos necesarios: Procesamiento: Mostrar el sueldo neto a cobrar por cada trabajador de la empresa. El nmero de trabajadores de la empresa y el sueldo de cada uno de ellos. El nmero de trabajadores se ingresa a travs del teclado y se almacena en una variable (numTrab). Con el nmero de trabajadores se crea un arreglo (sueldos[ ]). Luego se procede a ingresar los sueldos de cada trabajador y se almacenan en el arreglo creado. Despus, 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

ENTRADA: numTrab, sueldos[ ] SALIDA: sueldoNeto INICIO COMENTARIO Declaracin de variables NUMERO i, numTrab, sueldos[ ], descuento = 0, aumento = 0 NUMERO sueldoNeto COMENTARIO Determinacin del tamao del arreglo HACER LEER numTrab SI (numTrab <= 0 ) ENTONCES ESCRIBIR Nmero de trabajadores no vlido FINSI MIENTRAS (numTrab <= 0 ) COMENTARIO Creacin 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 vlido... FINSI MIENTRAS ( sueldos[i] <= 0 ) FINDESDE COMENTARIO Clculo 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

package dominioDeLaAplicacion ; import biblioteca.* ; public class PrgTrabajadores02 { public static void main(String[] args) { // Declaracin de variables. int i, numTrab ; double aumento = 0, descuento = 0 ; // Determinacin del tamao del arreglo con consistencia de datos. do { System.out.print ( Ingrese el nmero de trabajadores de la empresa : ) ; numTrab = Lectura.leerInt( ) ; if ( numTrab <= 0 ) { System.out.println ( El nmero de trabajadores no es vlido Reintente! ) ; } } while ( numTrab <= 0 ) ; // Declaracin y creacin 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 vlido Reintente! ) ; } } while ( sueldos[i] <= 0 ) ; } // Clculo 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 - Descripcin del problema. Desarrollar una solucin 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. Condicin
sueldo < 410 sueldo >= 410 y sueldo <= 1600 sueldo > 1600
Aumento
20% 10% 05%
Descuento
00 % 08 % 15 %
Etapa 02 - Definicin de la solucin. Resultado deseado: Mostrar el sueldo neto a cobrar por cada trabajador de la empresa, su aumento y su respectivo descuento. Tambin mostrar el monto total que paga la empresa por concepto de sueldos. El nmero de trabajadores de la empresa y el sueldo de cada uno de ellos. El nmero de trabajadores se ingresa a travs del teclado y se almacena en una variable (numTrab). Con el nmero de trabajadores se crea un arreglo (sueldos[ ]). Luego se procede a ingresar los sueldos de cada trabajador y se almacenan en el arreglo creado. Despus, 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 ningn 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. Tambin se muestra el aumento y el descuento calculado. El sueldo neto obtenido se suma a una variable acumulador (sueldoTotal). Despus de finalizar el clculo del sueldo neto de cada trabajador se muestra por pantalla el contenido de la variable acumulador sueldoTotal.
Etapa 03 - Diseo de la lgica. 1. Nombre del Proyecto: ProyTrabajadores. 2. Definicin de Paquetes y desarrollo del Diagrama de Paquetes.
Pag. 458
Clases biblioteca

ENTRADA: numTrab, sueldos[ ] SALIDA: sueldoNeto, aumento, descuento, sueldoTotal INICIO COMENTARIO Declaracin de variables NUMERO i, numTrab, sueldos[ ], aumento = 0, descuento = 0 NUMERO sueldoNeto, sueldoTotal = 0 COMENTARIO Determinacin del tamao del arreglo HACER LEER numTrab SI (numTrab <= 0 ) ENTONCES ESCRIBIR Nmero de trabajadores no vlido FINSI MIENTRAS (numTrab <= 0 ) COMENTARIO Creacin del arreglo CREAR sueldos [numTrab]
Pag. 459

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 vlido... FINSI MIENTRAS ( sueldos[i] <= 0 ) FINDESDE COMENTARIO Clculo 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
package dominioDeLaAplicacion ; import biblioteca.* ; public class PrgTrabajadores03 { public static void main(String[] args) { // Declaracin de variables. int i, numTrab ; double aumento = 0, descuento = 0, sueldoNeto, sueldoTotal = 0 ; // Determinacin del tamao del arreglo con consistencia de datos. do { System.out.print ( Ingrese el nmero de trabajadores de la empresa : ) ; numTrab = Lectura.leerInt( ) ; if ( numTrab <= 0 ) { System.out.println ( El nmero de trabajadores no es vlido Reintente! ) ; } } while ( numTrab <= 0 ) ; // Declaracin y creacin 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 vlido Reintente! ) ; } } while ( sueldos[i] <= 0 ) ; }
Pag. 461
// Clculo 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 - Descripcin del problema. Desarrollar una solucin 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 - Definicin de la solucin. Resultado deseado: Datos necesarios: Mostrar el sueldo de cada trabajador de la empresa. El nmero de trabajadores de la empresa, y las horas trabajadas y la tarifa horaria de cada uno de ellos. El nmero de trabajadores se ingresa a travs del teclado y se almacena en una variable (numTrab). Con el nmero 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. Despus, 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.
Procesamiento:
Pag. 463
Clases biblioteca
Pag. 464

ENTRADA: numTrab, sueldos[ ][ ] SALIDA: sueldoNeto INICIO COMENTARIO Declaracin de variables NUMERO i, numTrab, sueldos[ ][ ], sueldoNeto COMENTARIO Determinacin del tamao del arreglo HACER LEER numTrab SI (numTrab <= 0 ) ENTONCES ESCRIBIR Nmero de trabajadores no vlido FINSI MIENTRAS (numTrab <= 0 ) COMENTARIO Creacin 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 Nmero de horas no vlida... 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 vlida... FINSI MIENTRAS ( sueldos[i][1] <= 0 ) FINDESDE COMENTARIO Clculo 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
package dominioDeLaAplicacion ; import biblioteca.* ; public class PrgTrabajadores04 { public static void main(String[] args) { // Declaracin de variables. int i, numTrab ; double sueldoNeto ; // Determinacin del tamao del arreglo con consistencia de datos. do { System.out.print ( Ingrese el nmero de trabajadores de la empresa : ) ; numTrab = Lectura.leerInt( ) ; if ( numTrab <= 0 ) { System.out.println ( El nmero de trabajadores no es vlido Reintente! ) ; } } while ( numTrab <= 0 ) ; // Declaracin y creacin 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 ( Nmero de horas trabajadas: ) ; sueldos[i][0] = Lectura.leerDouble( ) ; if ( sueldos[i][0] <= 0 ) { System.out.println ( Nmero de horas trabajadas no vlida ) ; } } 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 vlida ) ; } } while ( sueldos[i][1] <= 0 ) ; }
Pag. 466

// Clculo 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 - Descripcin del problema. Desarrollar una solucin 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 - Definicin de la solucin. Resultado deseado: Datos necesarios: Mostrar el sueldo de cada trabajador de la empresa. El nmero de trabajadores de la empresa, y las horas trabajadas y la tarifa horaria de cada uno de ellos. El nmero de trabajadores se ingresa a travs del teclado y se almacena en una variable (numTrab). Con el nmero 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. Despus, por cada trabajador, se determina el sueldo bruto. Si el nmero 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
Procesamiento:
( 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). Despus, 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

ENTRADA: numTrab, sueldos[ ][ ] SALIDA: sueldoBruto, sueldoNeto INICIO COMENTARIO Declaracin de variables NUMERO i, numTrab, sueldos[ ][ ], descuento NUMERO sueldoNeto, sueldoBruto COMENTARIO Determinacin del tamao del arreglo HACER LEER numTrab SI (numTrab <= 0 ) ENTONCES ESCRIBIR Nmero de trabajadores no vlido FINSI MIENTRAS (numTrab <= 0 ) COMENTARIO Creacin del arreglo CREAR sueldos [2][numTrab]
Pag. 470

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 Nmero de horas no vlida... 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 vlida... FINSI MIENTRAS ( sueldos[1][i] <= 0 ) FINDESDE COMENTARIO Clculo 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
package dominioDeLaAplicacion ; import biblioteca.* ; public class PrgTrabajadores05 { public static void main(String[] args) { // Declaracin de variables. int i, numTrab ; double sueldoNeto ; // Determinacin del tamao del arreglo con consistencia de datos. do { System.out.print ( Ingrese el nmero de trabajadores de la empresa : ) ; numTrab = Lectura.leerInt( ) ; if ( numTrab <= 0 ) { System.out.println ( El nmero de trabajadores no es vlido Reintente! ) ; } } while ( numTrab <= 0 ) ; // Declaracin y creacin 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 ( Nmero de horas trabajadas: ) ; sueldos[0][i] = Lectura.leerDouble( ) ; if ( sueldos[0][i] <= 0 ) { System.out.println ( Nmero de horas trabajadas no vlida ) ; } } 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 vlida ) ; } } while ( sueldos[1][i] <= 0 ) ; }
Pag. 472

// Clculo 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 - Descripcin del problema. Desarrollar una solucin que permita ingresar y almacenar el nombre de todos los artculos de una bodega. Consistenciar la entrada de datos. Mostrar cada uno de los nombre con su respectiva longitud. Etapa 02 - Definicin de la solucin. Resultado deseado: Datos necesarios: Procesamiento: Mostrar el nombre y la longitud del nombre de todos los artculos de una bodega. El nmero de artculos y el nombre de cada uno de los artculos. El nmero de artculos se ingresa a travs del teclado y se almacena en una variable (numArt). Con el nmero de artculos se crea un arreglo (articulos[ ]). Luego se procede a ingresar el nombre de los artculos 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. Despus, para cada uno de los nombres, se determina su longitud, se almacena en una variable (tamao) y se muestra por pantalla.
Etapa 03 - Diseo de la lgica. 1. Nombre del Proyecto: ProyArticulos. 2. Definicin de Paquetes y desarrollo del Diagrama de Paquetes.
Pag. 474
Clases biblioteca
Algoritmo PrgArticulos01 - mtodo main ( )

ENTRADA: numArt, nombres SALIDA: tamao INICIO COMENTARIO Declaracin de variables NUMERO i, numArt, tamao TEXTO articulos[ ], nombre COMENTARIO Determinacin del tamao del arreglo HACER LEER numArt SI (numArt <= 0 ) ENTONCES ESCRIBIR Nmero de artculos no vlido FINSI MIENTRAS (numArt <= 0 ) COMENTARIO Creacin del arreglo CREAR articulos [numArt]
Pag. 475

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 artculo no vlido... FINSI MIENTRAS (LONGITUD articulos[i] < 3 ) FINDESDE COMENTARIO Clculo de la longitud de los nombres DESDE i = 0 HASTA i = numArt - 1 INCREMENTA 1 tamao = LONGITUD articulos[i] ESCRIBIR articulos[i], tamao FINDESDE FIN

Clase PrgArticulos01
package dominioDeLaAplicacion ; import biblioteca.* ; public class PrgArticulos01 { public static void main(String[] args) { // Declaracin de variables. int i, numArt, tamao ; String nombre ; // Determinacin del tamao del arreglo con consistencia de datos. do { System.out.print ( Ingrese el nmero de artculos : ) ; numArt = Lectura.leerInt( ) ; if ( numArt <= 0 ) { System.out.println ( El nmero de artculos no es vlido Reintente! ) ; } } while ( numArt <= 0 ) ;
Pag. 476
// Declaracin y creacin del arreglo. String articulos[ ] = new String [numArt] ; // Ingreso de datos al arreglo artculos[ ] con consistencia de datos. for ( i = 0 ; i < numArt ; i++ ) { do { System.out.print ( Ingrese el nombre del artculo [ + ( i + 1) + ]: ) ; nombre = Lectura.leerString( ) ; articulos[i] = nombre.trim( ) ; if ( articulos[i].length( ) < 3 ) { System.out.println ( El nombre ingresado no es vlido Reintente! ) ; } } while ( articulos[i].length( ) < 3 ) ; } // Clculo de la longitud de los nombres. for ( i = 0 ; i < numArt ; i++ ) { tamao = articulos[i].length( ) ; System.out.println ( Artculo + articulos[i] + tiene una longitud de + tamao ) ; } } }
Pag. 477
Problema 143 Etapa 01 - Descripcin del problema. Desarrollar una solucin que permita ingresar y almacenar el nombre de todos los artculos de una bodega. Consistenciar la entrada de datos. Mostrar la primera letra de cada nombre en mayscula y el resto en minscula. Adicionalmente, mostrar la longitud de cada uno de los nombres. Etapa 02 - Definicin de la solucin. Resultado deseado: Mostrar la primera letra de todos los nombres en letra mayscula y el resto en letra minscula. Adicionalmente mostrar la longitud de cada uno de los nombres de los artculos. El nmero de artculos y el nombre de cada uno de los artculos. El nmero de artculos se ingresa a travs del teclado y se almacena en una variable (numArt). Con el nmero de artculos se crea un arreglo (articulos[ ]). Luego se procede a ingresar el nombre de los artculos de la bodega, se eliminan los espacios del inicio y final del nombre, y se almacenan en el arreglo creado. Despus, para cada uno de los nombres, se obtiene la primera letra, se almacena en una variable (letra) y se convierte en mayscula. Luego, se obtiene las dems letras, se almacenan en una variable (resto) y se convierten en minscula. Tambin, se determina la longitud del nombre y se almacena en una variable (tamao). Finalmente, se muestra la primera letra del nombre en mayscula, las dems letras en minscula y la longitud del nombre por pantalla.
Pag. 478
Etapa 03 - Diseo de la lgica.
1. Nombre del Proyecto: ProyArticulos.
Clases biblioteca
Pag. 479

ENTRADA: numArt, articulos[ ] SALIDA: letra, resto, tamao INICIO COMENTARIO Declaracin de variables NUMERO i, numArt, tamao TEXTO articulos[ ], letra, resto COMENTARIO Determinacin del tamao del arreglo HACER LEER numArt SI (numArt <= 0 ) ENTONCES ESCRIBIR Nmero de artculos no vlido FINSI MIENTRAS (numArt <= 0 ) COMENTARIO Creacin 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 artculo no vlido... FINSI MIENTRAS (LONGITUD articulos[i] < 3 ) FINDESDE COMENTARIO Manipulacin del nombre de los artculos 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 tamao = LONGITUD articulos[i] ESCRIBIR letra, resto, tamao FINDESDE FIN
Pag. 480
package dominioDeLaAplicacion ; import biblioteca.* ; public class PrgArticulos02 { public static void main(String[] args) { // Declaracin de variables. int i, numArt, tamao ; String letra, resto ; // Determinacin del tamao del arreglo con consistencia de datos. do { System.out.print ( Ingrese el nmero de artculos : ) ; numArt = Lectura.leerInt( ) ; if ( numArt <= 0 ) { System.out.println ( El nmero de artculos no es vlido Reintente! ) ; } } while ( numArt <= 0 ) ; // Declaracin y creacin 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 artculo [ + ( i + 1) + ]: ) ; articulos[i] = Lectura.leerString( ) ; articulos[i] = articulos[i].trim( ) ; if ( articulos[i].length( ) < 3 ) { System.out.println ( El nombre ingresado no es vlido Reintente! ) ; } } while ( articulos[i].length( ) < 3 ) ; } // Manipulacin del nombre de los artculos. for ( i = 0 ; i < numArt ; i++ ) { letra = articulos[i].substring(0,1) ; letra = letra.toUpperCase( ); resto = articulos[i].substring(1) ; resto = resto].toLowerCase( ) ; tamao = articulos[i].length( ) ; System.out.println ( Artculo + letra + resto + tiene una longitud de + tamao ) ; } } }
Pag. 481
Problema 144 Etapa 01 - Descripcin del problema. Desarrollar una solucin que permita ingresar y almacenar el nombre de todos los artculos de una bodega. Consistenciar la entrada de datos. Mostrar la primera letra y la ltima letra de cada uno de los nombres en letra mayscula y minscula respectivamente. Etapa 02 - Definicin de la solucin. Resultado deseado: Mostrar la primera letra de todos los nombres en letra mayscula y el resto en letra minscula. Adicionalmente mostrar la longitud de cada uno de los nombres de los artculos. El nmero de artculos y el nombre de cada uno de los artculos. El nmero de artculos se ingresa a travs del teclado y se almacena en una variable (numArt). Con el nmero de artculos se crea un arreglo (articulos[ ]). Luego se procede a ingresar el nombre de los artculos de la bodega, se eliminan los espacios del inicio y final del nombre, y se almacenan en el arreglo creado. Despus, para cada uno de los nombres, se obtiene la primera letra, se almacena en una variable (letraIni) y se convierte en mayscula. Luego, se obtiene la ltima letra, se almacenan en una variable (letraFin) y se convierten en minscula. Finalmente, se muestra por pantalla, la primera letra del nombre en mayscula y la ltima letra del nombre en minscula.
Pag. 482
Clases biblioteca
Pag. 483

ENTRADA: numArt, articulos[ ] SALIDA: letraIni, letraFin INICIO COMENTARIO Declaracin de variables NUMERO i, numArt TEXTO articulos[ ], letraIni, letraFin COMENTARIO Determinacin del tamao del arreglo HACER LEER numArt SI (numArt <= 0 ) ENTONCES ESCRIBIR Nmero de artculos no vlido FINSI MIENTRAS (numArt <= 0 ) COMENTARIO Creacin 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 artculo no vlido... FINSI MIENTRAS (LONGITUD articulos[i] < 3 ) FINDESDE COMENTARIO Manipulacin del nombre de los artculos 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
package dominioDeLaAplicacion ; import biblioteca.* ; public class PrgArticulos03 { public static void main(String[] args) { // Declaracin de variables. int i, numArt ; char letraIni, letraFin ; // Determinacin del tamao del arreglo con consistencia de datos. do { System.out.print ( Ingrese el nmero de artculos : ) ; numArt = Lectura.leerInt( ) ; if ( numArt <= 0 ) { System.out.println ( El nmero de artculos no es vlido Reintente! ) ; } } while ( numArt <= 0 ) ; // Declaracin y creacin del arreglo. String articulos[ ] = new String [numArt] ; // Ingreso de datos al arreglo artculos[ ] con consistencia de datos. for ( i = 0 ; i < numArt ; i++ ) { do { System.out.print ( Ingrese el nombre del artculo [ + ( i + 1) + ]: ) ; articulos[i] = Lectura.leerString( ) ; articulos[i] = articulos[i].trim( ) ; if ( articulos[i].length( ) < 3 ) { System.out.println ( El nombre ingresado no es vlido Reintente! ) ; } } while ( articulos[i].length( ) < 3 ) ; } // Manipulacin del nombre de los artculos. 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 ( Artculo + articulos[i] ) ; System.out.println ( Letra inicial : + letraIni + . Letra final : + letraFin + . ) ; System.out.println ( ) ; } } }
Pag. 485
Problema 145 Etapa 01 - Descripcin del problema. Desarrollar una solucin que permita ingresar y almacenar el nombre, la sigla y la descripcin de todos los artculos de una bodega. Consistenciar la entrada de datos. Mostrar la primera letra del nombre y la descripcin en mayscula y el resto en minscula. . Tambin, mostrar las siglas del artculo en mayscula. Etapa 02 - Definicin de la solucin. Resultado deseado: Mostrar la primera letra de todos los nombres y las descripciones en letra mayscula y el resto en letra minscula. Tambin mostrar las siglas del artculo en minscula. El nmero de artculos y, el nombre, la descripcin y las siglas de cada uno de los artculos. El nmero de artculos se ingresa a travs del teclado y se almacena en una variable (numArt). Con el nmero de artculos se crea un arreglo (articulos[ ]). Luego se procede a ingresar el nombre, la descripcin y las siglas de los artculos de la bodega, se eliminan los espacios del inicio y final de los mismos, y se almacenan en el arreglo creado. Despus, para cada uno de los nombres, se obtiene la primera letra, se almacena en una variable (letra), se obtiene las dems letras y se almacenan en una variable (resto). Luego se convierte a mayscula la variable letra y a minscula 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). Tambin, se convierte a mayscula las siglas de cada artculo y se almacena en una variable (siglas). Finalmente, los resultados se muestran por pantalla.
Datos necesarios:
Procesamiento:
Pag. 486
Clases biblioteca
Pag. 487

ENTRADA: numArt, articulos[ ][ ] SALIDA: nombre, descrip, siglas INICIO COMENTARIO Declaracin de variables NUMERO i, numArt TEXTO articulos[ ][ ], nombre, descrip, siglas COMENTARIO Determinacin del tamao del arreglo HACER LEER numArt SI (numArt <= 0 ) ENTONCES ESCRIBIR Nmero de artculos no vlido FINSI MIENTRAS (numArt <= 0 ) COMENTARIO Creacin 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 artculos 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 artculo no vlido... FINSI MIENTRAS (LONGITUD articulos[i][0] < 3 ) HACER COMENTARIO Ingreso descripcin de los artculos 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 Descripcin de artculo no vlida... FINSI MIENTRAS (LONGITUD articulos[i][1] < 3 )
Pag. 488

HACER COMENTARIO Ingreso siglas de los artculos 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 artculo no vlida... FINSI MIENTRAS (LONGITUD articulos[i][2] < 3 ) FINDESDE COMENTARIO Manipulacin del nombre de los artculos 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
package dominioDeLaAplicacion ; import biblioteca.* ; public class PrgArticulos04 { public static void main(String[] args) { // Declaracin de variables. int i, numArt ; String letra, resto, nombre, descrip, siglas ; // Determinacin del tamao del arreglo con consistencia de datos. do { System.out.print ( Ingrese el nmero de artculos : ) ; numArt = Lectura.leerInt( ) ; if ( numArt <= 0 ) { System.out.println ( El nmero de artculos no es vlido Reintente! ) ; } } while ( numArt <= 0 ) ; // Declaracin y creacin del arreglo. String articulos[ ][ ] = new String [numArt][3] ; // Ingreso de datos al arreglo artculos[ ][ ] con consistencia de datos. for ( i = 0 ; i < numArt ; i++ ) { do { System.out.print ( Ingrese el nombre del artculo [ + ( 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 vlido ) ; } } while (articulos[i][0].length( ) < 3 ) ; do { System.out.print ( Ingrese la descripcin del artculo [ + ( i + 1) + ]: ) ; articulos[i][1] = Lectura.leerString( ) ; articulos[i][1] = articulos[i][1].trim( ) ; if (articulos[i][1].length( ) < 3 ) { System.out.println ( La descripcin ingresada no es vlida ) ; } } while (articulos[i][1].length( ) < 3 ) ;
Pag. 490
do { System.out.print ( Ingrese la sigla del artculo [ + ( 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 vlida ) ; } } while (articulos[i][2].length( ) < 3 ) ; } // Manipulacin del nombres, descripcin y sigla de los artculos 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 ( Artculo + ( i+1 ) ) ; System.out.println ( ---------------------- ) ; System.out.println ( Nombre: + nombre + . ) ; System.out.println ( Descripcin: + descrip + . ) ; System.out.println ( Siglas: + siglas + . ) ; System.out.println ( ) ; } } }
Pag. 491
Pag. 492
DESARROLLO DE SOLUCIONES UTILIZANDO MLTIPLES ARREGLOS Arreglos en paralelos Cuando se plantean soluciones a diversos problemas es necesario utilizar variables, vectores y matrices en forma simultnea para almacenar los datos. Es decir, en una solucin se puede utilizar algunas variables, un vector, dos vectores o muchos vectores. Tambin, se puede utilizar variables, un vector y una matriz, o dos vectores y una matriz. En trminos generales se puede afirmar que en una solucin se utilizan variables, vectores y matrices en forma simultnea y en el nmero que se necesiten. Esto va a depender de la complejidad y tipo de problema que se necesite resolver. Cuando en una solucin se utiliza ms 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 solucin del problema 146 se utilizan algunas variables y dos vectores en forma simultanea (en paralelo). En una de las variables (numTrab) se almacena el nmero de trabajadores y con este valor se crean los dos vectores (los arreglos en paralelo deben tener el mismo tamao). 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 posicin de un vector esta relacionado con el dato almacenado en la misma posicin del otro vector. A continuacin, se muestra el planteamiento de la solucin en forma grfica. Es importante tener presente que los vectores paralelos se grafican en forma vertical para comprender mejor la relacin que existe entre ellos.
nombres 0 1 2 0 1 2 sueldos
Datos del mismo trabajador.
: :
numTrab - 1
: : :
nombre de los trabajadores
: :
numTrab - 1
: : :
sueldo de los trabajadores
Si en nombres[0] se almacena el nombre Danae, resulta lgico y necesario que en sueldos[0] almacenemos su respectivo sueldo. La pregunta lgica que se pueden formular sera la siguiente: por qu en vez de crear dos vectores en paralelo no creamos una matriz con dos columnas?, y la respuesta sera 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
solucin 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 solucin del problema 147 se utilizan algunas variables y tres vectores en forma simultanea (en paralelo). En una de las variables (numSoc) se almacena el nmero 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 estn almacenados en la posicin cero de los vectores en paralelo. A continuacin se muestra el planteamiento de la solucin.
nombres 0 1 2 Danae 0 1 2 sexos F 0 1 2 Edades 10
: :
numSoc - 1
: : :
nombres de cada socios
: :
numSoc - 1
: : :
sexo de cada socio
: :
numSoc - 1
: : :
sueldo de cada socio
En la solucin del problema 148 se utilizan algunas variables, un vector y una matriz con dos columnas en forma simultanea (en paralelo). A continuacin se muestra el planteamiento de la solucin.
nombres 0 1 2 0 1 2 precios 0
: :
numArt - 1
: : :
nombre de cada artculos
: :
numArt - 1
: : :
precio de compra de cada artculos
: : :
precio de venta de cada artculos
Pag. 494
Problema 146 Etapa 01 - Descripcin del problema. Desarrollar una solucin 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 ms alto y el promedio del sueldo de todos los trabajadores redondeado a dos decimales. Etapa 02 - Definicin de la solucin. Resultado deseado: Mostrar el nombre del trabajador que tiene el sueldo ms alto y el promedio del sueldo de todos los trabajadores. El nmero de trabajadores y, el nombre y el sueldo de cada trabajador. El nmero de trabajadores se ingresa a travs del teclado y se almacena en una variable (numTrab). Con el nmero 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[ ]). Tambin, se procede a ingresar el sueldo de los trabajadores y se almacenan en el otro arreglo creado (sueldos[ ]). Despus, 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 nmero de trabajadores. El resultado se almacena en una variable (sueldoPromedo), se redondea a dos decimales y se muestra por pantalla.
Etapa 03 - Diseo de la lgica. 1. Nombre del Proyecto: ProyTrabajadores. 2. Definicin de Paquetes y desarrollo del Diagrama de Paquetes.
Clases biblioteca
Pag. 496

ENTRADA: numTrab, nombres[ ], sueldos[ ] SALIDA: nombres[ ], sueldoPromedio INICIO COMENTARIO Declaracin de variables NUMERO i, numTrab, sueldos[ ] NUMERO sueldoMayor = 0, sumaSueldos = 0, sueldoPromedio TEXTO nombres[ ] COMENTARIO Determinacin del tamao del arreglo HACER LEER numTrab SI (numTrab <= 0 ) ENTONCES ESCRIBIR Nmero de trabajadores no vlido FINSI MIENTRAS (numTrab <= 0 ) COMENTARIO Creacin 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 vlido... 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 vlido... FINSI MIENTRAS ( sueldos[i] <= 0 ) FINDESDE
Pag. 497

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
package dominioDeLaAplicacion ; import biblioteca.* ; public class PrgTrabajadores06 { public static void main(String[] args) { // Declaracin de variables. int i, numTrab ; double sueldoMayor = 0, sumaSueldos = 0, sueldoPromedio ; // Determinacin del tamao de los arreglos con consistencia de datos. do { System.out.print ( Ingrese el nmero de trabajadores : ) ; numTrab = Lectura.leerInt( ) ; if ( numTrab <= 0 ) { System.out.println ( El nmero de trabajadores no es vlido Reintente! ) ; } } while ( numTrab <= 0 ) ; // Declaracin y creacin 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 vlido ) ; } } 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 vlido ) ; } } while (sueldos[i] <= 0 ) ; }
Pag. 499
// 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 ms 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 - Descripcin del problema. Desarrollar una solucin que permita ingresar y almacenar el nombre, el sexo y la edad de todos los socios de un club. Indicar el nmero de socios mayores de edad que son hombres y el nmero de socios cuyo nombre comienza con la letra D. Etapa 02 - Definicin de la solucin. Resultado deseado: Mostrar el nmero de socios hombres mayores de edad y el nmero de socios cuyo nombre comienza con la letra D. El nmero de socios y, el nombre, sexo y edad de cada socio. El nmero de socios se ingresa a travs del teclado y se almacena en una variable (numSoc). Con el nmero 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 mayscula 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[]). Despus, se determina el nmero de socios hombres, mayores de edad. Para esto se evalan 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 evaluacin de los datos de todos los socios se muestra el contenido de la variable totalMayoresHombres. Luego, se determina el nmero 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 mayscula y se compara con la letra D. Si letra = D, entonces se aumenta 1 a otra variable tipo contador (totalNombresD). Finalizada la evaluacin se muestra el contenido de la variable totalNombresD.
Etapa 03 - Diseo de la lgica. 1. Nombre del Proyecto: ProySocios. 2. Definicin de Paquetes y desarrollo del Diagrama de Paquetes.

Pag. 502
Algoritmo PrgSocios01 - mtodo main ( )

ENTRADA: numSoc, nombres[ ], sexos[ ], edades[ ] SALIDA: totalMayoresHombres, totalNombresD INICIO COMENTARIO Declaracin de variables NUMERO i, numSoc, edades[ ] NUMERO totalMayoresHombres = 0, totalNombresD = 0 TEXTO nombres[ ], sexos[ ], letra COMENTARIO Determinacin del tamao del arreglo HACER LEER numSoc SI (numSoc <= 0 ) ENTONCES ESCRIBIR Nmero de socios no vlido FINSI MIENTRAS (numSoc <= 0 ) COMENTARIO Creacin 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 vlido... 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 vlido... FINSI MIENTRAS ( sexos[i] <> M OR sexos[i] <> F )
Pag. 503
Algoritmo PrgSocios01 - mtodo main ( )

HACER COMENTARIO Ingreso de edad de socios LEER edades[i] SI ( edades[i] <= 0 ) ENTONCES ESCRIBIR Edad de socio no vlida... FINSI MIENTRAS ( edades[i] <= 0 ) FINDESDE COMENTARIO Determinando nmero 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) { // Declaracin de variables. int i, numSoc, totalMayoresHombres = 0, totalNombresD = 0 ; char letra ; // Determinacin del tamao de los arreglos con consistencia de datos. do { System.out.print ( Ingrese el nmero de socios : ) ; numSoc = Lectura.leerInt( ) ; if ( numSoc <= 0 ) { System.out.println ( El nmero de socios no es vlido Reintente! ) ; } } while ( numSoc <= 0 ) ; // Declaracin y creacin 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 vlido ) ; } } 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 vlido ) ; } } 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 vlida ) ; } } while ( edades[i] <= 0 ) ; } // Determinando el nmero de socios hombres mayores de edad. for ( i = 0 ; i < numSoc ; i++ ) { if ( edades[i] >= 18 && sexos[i] == M ) { totalMayoresHombres ++ ; } } System.out.print ( El nmero de socios hombres mayores de edad es : ) ; System.out.println ( totalMayoresHombres ) ; // Determinando el nmero de socios cuyo nombre comienza con la letra D. for ( i = 0 ; i < numSoc ; i++ ) { letra = nombres[i].charAt(0) ; letra = carcter.toUpperCase(letra) ; if ( letra == M ) { totalNombresD ++ ; } } System.out.print ( El nmero de socios cuyo nombre comienza con la letra D es : ) ; System.out.println ( totalNombresD ) ; } }
Pag. 506
Problema 148 Etapa 01 - Descripcin del problema. Desarrollar una solucin que permita ingresar y almacenar el nombre, el precio de compra y el precio de venta de todos los artculos de una bodega. Indicar el nombre de cada artculo y su margen de utilidad. Etapa 02 - Definicin de la solucin. Resultado deseado: Datos necesarios: Mostrar el nombre de cada artculo y su margen de utilidad. El nmero de artculos y, el nombre, el precio de compra y el precio de venta de cada artculo. El nmero de artculos se ingresa a travs del teclado y se almacena en una variable (numArt). Con el nmero de artculos se crean dos arreglos, un vector y una matriz con dos columnas (nombres[ ] y precios[ ][ ]). Luego se procede a ingresar el nombre de los artculos, 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. Despus, se determina la utilidad de cada artculo. Para esto, el precio de venta del artculo se resta de su precio de compra, se almacena el resultado en una variable (utilidad) y se muestra el nombre del artculo junto con su utilidad.
Procesamiento:
Pag. 507
Etapa 03 - Diseo de la lgica. 1. Nombre del Proyecto: ProyArticulos.
Clases biblioteca
Pag. 508

ENTRADA: numArt, nombres[ ], precios[ ][ ] SALIDA: nombres[ ], utilidad INICIO COMENTARIO Declaracin de variables NUMERO i, numArt, precios[ ][ ], utilidad TEXTO nombres[ ] COMENTARIO Determinacin del tamao del arreglo HACER LEER numArt SI (numArt <= 0 ) ENTONCES ESCRIBIR Nmero de artculos no vlido FINSI MIENTRAS (numArt <= 0 ) COMENTARIO Creacin de los arreglos CREAR nombres [numArt] CREAR precios [numArt][2] COMENTARIO Ingreso de nombre, precio de compra y precio de venta de los artculos DESDE i = 0 HASTA i = numArt - 1 INCREMENTA 1 HACER COMENTARIO Ingreso de nombre de artculo LEER nombres[i] nombres[i] = nombres[i] ELIMINAESPACIO INICIO, FIN SI ( LONGITUD nombres[i] < 3 ) ENTONCES ESCRIBIR Nombre del artculo no vlido... 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 vlido... FINSI MIENTRAS ( precios[i][0] <= 0 )
Pag. 509

HACER COMENTARIO Ingreso de precio de venta LEER precios[i][1] SI ( precios[i][1] <= 0 ) ENTONCES ESCRIBIR Precio de venta no vlido... FINSI MIENTRAS ( precios[i][1] <= 0 ) FINDESDE COMENTARIO Determinando la utilidad de cada artculo DESDE i = 0 HASTA i = numArt - 1 INCREMENTA 1 utilidad = precios[i][1] precios[i][0] ESCRIBIR nombres[i], utilidad FINDESDE FIN
Pag. 510
package dominioDeLaAplicacion ; import biblioteca.* ; public class PrgArticulos06 { public static void main(String[] args) { // Declaracin de variables. int i, numArt ; double utilidad ; // Determinacin del tamao de los arreglos con consistencia de datos. do { System.out.print ( Ingrese el nmero de artculos : ) ; numArt = Lectura.leerInt( ) ; if ( numArt <= 0 ) { System.out.println ( El nmero de artculos no es vlido Reintente! ) ; } } while ( numArt <= 0 ) ; // Declaracin y creacin 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 artculos. for ( i = 0 ; i < numArt ; i++ ) { do { System.out.print ( Ingrese el nombre del artculo [ + ( i + 1) + ]: ) ; nombres[i] = Lectura.leerString( ) ; nombres[i] = nombres[i].trim( ) ; if ( nombres[i].length( ) < 3 ) { System.out.println ( El nombre del artculo no es vlido ) ; } } 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 vlido ) ; } } while ( precios[i][0] <= 0 ) ;
Pag. 511
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 vlido ) ; } } while ( precios[i][1] <= 0 ) ; } // Determinando la utilidad de cada artculo. for ( i = 0 ; i < numArt ; i++ ) { utilidad = precios[i][1] precios[i][0] ; System.out.print ( El artculo : + nombres[i] + tiene una utilidad de ) ; System.out.println ( + utilidad + . ) ; } } }
Pag. 512
Problema 149 Etapa 01 - Descripcin del problema. Desarrollar una solucin que permita ingresar y almacenar el nombre, el cdigo y las diferentes notas de los alumnos de un saln de clase. Indicar el nombre, el cdigo 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 - Definicin de la solucin. Resultado deseado: Mostrar el nombre, el cdigo y el promedio de notas de cada alumno. Adicionalmente, indicar el nombre de los alumnos que obtuvieron el mayor promedio. El nmero de alumnos y, el nombre, el cdigo y las notas de cada alumno. El nmero de alumnos y el nmero de notas se ingresa a travs del teclado y se almacena en variables (numAlu y numNot respectivamente). Con el nmero de alumnos y el nmero 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 cdigo de los alumnos y se almacenan en otro arreglo (codigos[]). Tmbien se ingresan las notas de cada alumno y se almacenan en otro de los arreglos (notas[][]). Despus, 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 nmero de notas (numNot). El resultado se almacenada en otra variable (promAlu), se redondea y esta a su vez se almacena en el arreglo promedios[]. Despus se muestra el nombre, el cdigo 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 - Diseo de la lgica. 1. Nombre del Proyecto: ProyAlumnos. 2. Definicin de Paquetes y desarrollo del Diagrama de Paquetes.

Pag. 514

ENTRADA: numAlu, numNot, nombre[ ], codigos[ ], notas[ ][ ] SALIDA: nombres[ ], codigos[ ], promedios[ ] INICIO COMENTARIO Declaracin de variables NUMERO i, j, numAlu, nomNot, codigos[ ], notas[ ][ ], promedios[ ] NUMERO sumaNotas = 0, promAlu = 0, promAluMayor = 0 TEXTO nombres[ ] COMENTARIO Determinacin del tamao del arreglo HACER LEER numAlu SI (numAlu <= 0 ) ENTONCES ESCRIBIR Nmero de alumnos no vlido FINSI MIENTRAS (numAlu <= 0 ) HACER LEER numNot SI (numNot <= 0 ) ENTONCES ESCRIBIR Nmero de notas no vlido FINSI MIENTRAS (numNot <= 0 ) COMENTARIO Creacin 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 vlido... FINSI MIENTRAS ( LONGITUD nombres[i] < 3 )
Pag. 515

HACER LEER codigos[i] SI ( codigos[i] < 100000 OR codigos[i] > 999999 ) ENTONCES ESCRIBIR Cdigo ingresado no vlido... 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 vlida... 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) { // Declaracin de variables. int i, j, numAlu, numNot ; double sumaNotas = 0, promAlu = 0, promAluMayor = 0 ; // Determinacin del tamao de los arreglos con consistencia de datos. do { System.out.print ( Ingrese el nmero de alumnos : ) ; numAlu = Lectura.leerInt( ) ; if ( numAlu <= 0 ) { System.out.println ( El nmero de alumnos no es vlido Reintente! ) ; } } while ( numAlu <= 0 ) ; do { System.out.print ( Ingrese el nmero de notas por alumno : ) ; numNot = Lectura.leerInt( ) ; if ( numNot <= 0 ) { System.out.println ( El nmero de notas no es vlido Reintente! ) ; } } while ( numNot <= 0 ) ; // Declaracin y creacin 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 artculos. 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 vlido ) ; } } while ( nombres[i].length( ) < 3 ) ;
Pag. 517

Clase PrgAlumnos06
do { System.out.print ( Ingrese su cdigo : ) ; codigos[i] = Lectura.leerLong( ) ; if ( codigos[i] < 100000 || codigos[i] > 999999 ) { System.out.println ( Precio de compra no vlido ) ; } } 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 vlida ) ; } } 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 cdigo + 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 - Descripcin del problema. Desarrollar una solucin que permita ingresar y almacenar el nombre de todos los artculos de una bodega. Consistenciar la entrada de datos. Mostrar los nombres ordenados alfabticamente, considerando la primera letra de cada nombre en mayscula y el resto en minscula. Adicionalmente, mostrar la longitud de cada uno de los nombres. Etapa 02 - Definicin de la solucin. Resultado deseado: Mostrar los nombres ordenados alfabticamente, considerando la primera letra de cada nombres en letra mayscula y el resto en letra minscula. Adicionalmente mostrar la longitud de cada uno de los nombres de los artculos. El nmero de artculos y el nombre de cada uno de los artculos. El nmero de artculos se ingresa a travs del teclado y se almacena en una variable (numArt). Con el nmero de artculos se crea un arreglo (articulos[ ]). Luego se procede a ingresar el nombre de los artculos de la bodega, se eliminan los espacios del inicio y final del nombre, y se almacenan en el arreglo creado. Despus se ordenan los nombres utilizando el mtodo de ordenacin por Intercambio. Finalizado el mtodo de ordenacin, para cada uno de los nombres, se obtiene la primera letra, se almacena en una variable (letra) y se convierte en mayscula. Luego, se obtiene las dems letras, se almacenan en una variable (resto) y se convierten en minscula. Tambin, se determina la longitud del nombre y se almacena en una variable (tamao). Finalmente, se muestra la primera letra del nombre en mayscula, las dems letras en minscula y la longitud del nombre por pantalla.
Pag. 519
Etapa 03 - Diseo de la lgica. 1. Nombre del Proyecto: ProyArticulos.

Pag. 520

ENTRADA: numArt, articulos[ ] SALIDA: letra, resto, tamao INICIO COMENTARIO Declaracin de variables NUMERO i, j, numArt, tamao TEXTO articulos[ ], letra, resto, x COMENTARIO Determinacin del tamao del arreglo HACER LEER numArt SI (numArt <= 0 ) ENTONCES ESCRIBIR Nmero de artculos no vlido FINSI MIENTRAS (numArt <= 0 ) COMENTARIO Creacin 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 artculo no vlido... FINSI MIENTRAS (LONGITUD articulos[i] < 3 ) FINDESDE COMENTARIO Mtodo de Intercambio. Ordenacin 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

COMENTARIO Manipulacin del nombre de los artculos 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 tamao = LONGITUD articulos[i] ESCRIBIR letra, resto, tamao FINDESDE FIN

package dominioDeLaAplicacion ; import biblioteca.* ; public class PrgArticulos07 { public static void main(String[] args) { // Declaracin de variables. int i, j, numArt, tamao ; String letra, resto, x ; // Determinacin del tamao del arreglo con consistencia de datos. do { System.out.print ( Ingrese el nmero de artculos : ) ; numArt = Lectura.leerInt( ) ; if ( numArt <= 0 ) { System.out.println ( El nmero de artculos no es vlido Reintente! ) ; } } while ( numArt <= 0 ) ; // Declaracin y creacin del arreglo. String articulos[ ] = new String [numArt] ;
Pag. 522
// Ingreso de datos al arreglo artculos[ ] con consistencia de datos. for ( i = 0 ; i < numArt ; i++ ) { do { System.out.print ( Ingrese el nombre del artculo [ + ( i + 1) + ]: ) ; articulos[i] = Lectura.leerString( ) ; articulos[i] = articulos[i].trim( ) ; if ( articulos[i].length( ) < 3 ) { System.out.println ( El nombre ingresado no es vlido Reintente! ) ; } } while ( articulos[i].length( ) < 3 ) ; } // Mtodo de Intercambio. Ordenacin 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 ; } } } // Manipulacin del nombre de los artculos. for ( i = 0 ; i < numArt ; i++ ) { letra = articulos[i].substring(0,1) ; letra = letra.toUpperCase( ); resto = articulos[i].substring(1) ; resto = resto].toLowerCase( ) ; tamao = articulos[i].length( ) ; System.out.println ( Artculo + letra + resto + tiene una longitud de + tamao ) ; } } }
Pag. 523
Pag. 524
Captulo
Introduccin al Desarrollo de Soluciones Orientadas a Objetos
Temas: Introduccin. Conceptos bsicos:

Clase. Objeto. Atributo. Mtodo. Ocultar Atributos de Instancia.
Mtodo de las 6D. Etapas y pasos. Problema desarrollado.
INTRODUCCIN AL DESARROLLO DE SOLUCIONES ORIENTADAS A OBJETOS
CAPTULO V
INTRODUCCIN AL DESARROLLO DE SOLUCIONES ORIENTADAS A OBJETOS INTRODUCCIN La clase constituye la base de la programacin orientada a objetos y es el ncleo o unidad fundamental de encapsulacin 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
Pag. 527
En los captulos anteriores, se ha utilizado la clase en su forma ms simple. Las clases creadas se utilizaban simplemente para encapsular el mtodo main(), lo que ha permitido mostrar la base de la sintaxis de Java, las estructuras de datos, las estructuras lgicas, las instrucciones de bifurcacin, el manejo de excepciones y algunas de las clases incorporadas en Java. Como se ver en el presente captulo, las clases son mucho ms poderosas que las presentadas hasta ahora.
Observe la solucin del siguiente problema utilizando el mtodo de las 6D:
Etapa 01 - Descripcin del problema. Calcular el promedio final de un alumno. Utilice la siguiente frmula: prom = (nota1 + nota2 + nota3) / 3. Ingrese las notas nota1, nota2 y nota3 a travs del teclado. Etapa 02 - Definicin de la solucin. Resultado deseado: Datos necesarios: Procesamiento: Mostrar la nota final de un determinado alumno. Las notas del alumno (en esta caso tenemos 3 notas). La 3 notas sern ingresadas por teclado y almacenadas en las variables nota1, nota2, y nota3. Luego, se realizar el clculo de la nota final sobre la base de la siguiente frmula: prom = (nota1 + nota2 + nota3) / 3. El resultado se almacenar en una variable (prom) para luego ser mostradas por pantalla.
Etapa 03 - Diseo de la lgica. Nombre del Proyecto: ProyAlumno.
Pag. 528
Definicin de Paquetes y desarrollo del Diagrama de Paquetes.

Definicin de las Clases.

Diseo del algoritmo para el mtodo principal. Algoritmo PrgAlumno - mtodo 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 Codificacin. 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 dominioDeLaAplicacin con una clase PrgAlumno la cual se utiliza en su forma ms simple. En la clase PrgAlumno se define un mtodo main() y dentro del mismo se codifica toda la solucin. Como se ha mencionado, las clases son mucho ms poderosas que las presentadas hasta ahora. A partir de este punto, se ampliar el conocimiento sobre las clases. Para ello, se revisarn algunos conceptos bsicos y se presentarn, en forma progresiva, nuevos conceptos hasta llegar al concepto de ocultamiento de atributos de instancia. Todos estos nuevos conceptos presentados se incorporarn progresivamente en el ejemplo planteado. Al final, se formalizar el mtodo de solucin, el Mtodo de las 6D, para incluir los conceptos presentados.
Pag. 530
Pag. 531
Pag. 532
CONCEPTOS BSICOS
CLASE Una clase es una implantacin de un tipo de objeto. Especifica una estructura de datos (atributos) y los mtodos operativos permisibles que se aplican a cada uno de sus objetos. El mundo real se modela mediante clases. Una clase es una abstraccin y no referencia a ningn 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 (listaDeParmetros) { // cuerpo del mtodo1. } tipo nombreMetodo2 (listaDeParmetros) { // cuerpo del mtodo2. } //... tipo nombreMetodoN (listaDeParmetros) { // cuerpo del mtodoN. } }
Los datos o variables definidos en una clase se llaman atributos. El cdigo est contenido en los mtodos. En conjunto, los mtodos 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 mtodos tienen el mismo formato que el mtodo main() utilizado en los ejemplos anteriores. Sin embargo, es importante mencionar, que muchos mtodos no se especificarn como public, static o public static. En el formato general de una clase no se especifica un mtodo main(). Esto debido fundamentalmente a que todas las clases en Java no necesitan tener un mtodo main(). Solo necesitarn tener un mtodo main() aquellas clases que tengan como funcin principal iniciar la ejecucin del proyecto. En el proyecto de solucin ProyAlumno se agregar una clase llamada Alumno. La declaracin de esta clase en Java es la siguiente:
class Alumno { }
Ahora, el proyecto de solucin 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 mtodos que controlan dichos datos. La definicin de un objeto en Java comprende la declaracin y la creacin 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 parntesis especifica el mtodo constructor de la clase. Un constructor define que ocurre cuando se crea un objeto de una clase. La mayora de las clases del mundo real definen explcitamente sus propios constructores dentro de la definicin de la clase. Si no se especifica explcitamente el constructor, Java automticamente utiliza un constructor por defecto (es decir, cuando se crea un objeto no ocurre nada). En el ejemplo, la clase Alumno no define explcitamente un constructor, es decir se utiliza el constructor por defecto. Ms adelante se ver la forma de definir mtodos constructores en una clase. new es un operador en Java que permite crear un objeto.
En el proyecto de solucin ProyAlumno se utilizar la clase Alumno para definir objetos de tipo Alumno a travs 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 tendra que repetir la sentencia y cambiar el nombre del objeto. Es importante recordar que la definicin de una clase slo crea un molde, modelo o patrn a partir del cual se pueden crear objetos, mientras que la definicin 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 mtodos. Ahora, es necesario conocer algunos conceptos bsicas 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 categoras: Atributos de Instancia. Los atributos de instancia conocidos tambin 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 slo 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 mnima de un atributo es la siguiente;
tipo nombreAtributo;
Donde : tipo especifica el tipo de dato que el atributo almacenar. Puede ser cualquier tipo vlido, incluido los tipos de Clase. nombreAtributo especifica el nombre del atributo, que puede ser cualquier identificador vlido diferente a los que se est utilizando en el mismo mbito.
Pag. 536
En el proyecto de solucin 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 todava no se han definido mtodo. Se agregarn algunos mtodos a la clase Alumno mas adelante. Tambin, se definir el objeto objAlumno de la clase Alumno, dentro del mtodo main() de la clase PrgAlumno, tal y como se especific anteriormente a travs 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 solucin 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 utilizaran 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 estn 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 utilizara 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 solucin ProyAlumno, se necesita calcular y mostrar el promedio del alumno, para lo cual se utilizaran las siguientes sentencias:
prom = ( objAlumno.nota1 + objAlumno.nota2 ) / 2 ; System.out.println ( El promedio final del alumno es: + prom ) ;
Ests 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. Segn lo mencionado anteriormente, el proyecto de solucin ProyAlumno se desarrollara 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 solucin se denomina ProyAlumno. Al ejecutar el proyecto, se ejecuta el mtodo main() de la clase PrgAlumno y se obtiene el siguiente resultado:
El promedio final del alumno es: 17
Pag. 538
Es comn que en todo proyecto de solucin solo exista un mtodo main( ). Dicho mtodo main( ) inicia la ejecucin del proyecto y est definido en una de las clases que pertenecen al proyecto. Ahora, se realizarn algunos cambios en el proyecto de solucin ProyAlumno. Se agregar un atributo de instancia en la definicin 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 continuacin:
class Alumno { double nota1, nota2, nota3 ; }
En base a esto, se modificar el mtodo 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 mtodo 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 fcilmente definiendo ms de un objeto en el proyecto de solucin ProyAlumno. Para esto, se definirn dos objetos ms denominados objAlumno02 y objAlumno03 en el mtodo 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. Segn lo mencionado anteriormente, el proyecto de solucin ProyAlumno se desarrollara 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 ; // Tambin 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 ) ; // Tambin 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 mtodo 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
MTODO Hasta este punto se ha creado la clase Alumno con tres variables de instancia y sin ningn mtodo. Ahora es necesario conocer algunas cosas bsicas sobre los mtodos para luego poder definirlos dentro de la clase Alumno. Un mtodo representa un pequeo subprograma encapsulado dentro de una clase y contribuye a definir el comportamiento tpico de los objetos. Los mtodos especifican la forma en que se controlan los datos (atributos) de un objeto. Los mtodos definen el comportamiento de un objeto. Los mtodos se clasifican en dos categoras: Mtodos de Instancia. Los mtodos de instancia, conocidos tambin como mtodos de objeto, son mtodos que pueden ser llamados a travs de un objeto instanciado a partir de una clase. Un mtodo de instancia se ejecuta utilizando el siguiente formato: nombreObjeto.nombreMtodoInstancia ( ) ; Mtodos de Clase. Los mtodos de clase son mtodos que pueden ser llamados tambin a travs de un objeto instanciado a partir de una clase o utilizando directamente la clase. Generalmente, para ejecutar un mtodo de clase se utiliza el siguiente formato: NombreClase.nombreMtodoClase ( ) ; En otras palabras, mientras que para ejecutar un mtodo de instancia se requiere crear primero un objeto de la clase donde est definido el mtodo, para ejecutar un mtodo de clase no se requiere crear un objeto ya que se puede hacer directamente utilizando el nombre de la clase donde est definido el mtodo. Para declarar un mtodo de clase se utiliza la palabra reservada static. A travs de mtodos de clase se puede manipular solo atributos de clase. Mientras que a travs de mtodos de instancia se puede manipular tanto atributos de clase como atributos de instancia. La forma mnima de un mtodo es la siguiente;
tipo nombreMtodo ( listaDeParmetros ) { // Cuerpo del mtodo ; ]
Pag. 542
Donde : tipo especifica el tipo de dato devuelto vlido, incluido los tipos de clase. Si el devuelto debe ser void. Los mtodos devuelven un valor a la sentencia que forma de la sentencia return: por el mtodo. Puede ser cualquier tipo mtodo no devuelve ningn valor, el tipo que devuelven un tipo distinto de void, ejecuta el mtodo utilizando la siguiente
return valor ; Aqu valor es el dato que el mtodo devuelve a la sentencia que lo ejecut. Generalmente la sentencia return se coloca al final del cuerpo del mtodo. nombreMtodo especifica el nombre del mtodo que puede ser cualquier identificador vlido diferente de los que se estn utilizando en el mismo mbito. listaDeParmetros es una secuencia de parejas de tipo e identificador separados por comas. Los parmetros son variables que reciben el valor de los argumentos que se pasan al mtodo cuando este es ejecutado. Si el mtodo no tiene parmetros, entonces la lista de parmetros estar vaca.
Pag. 543
Metodo que no devuelven valor y no reciben parmetros Talvez se tengan algunos problemas para comprender los conceptos que rodean a los mtodos, poco a poco conforme se modifique el proyecto de solucin ProyAlumno se podrn comprender mejor. Ahora, se definir un mtodo dentro de la clase Alumno. El mtodo se llamar promedio( ), y permitir calcular y mostrar el promedio de notas de un alumno. Aunque, anteriormente, esto ya se haba realizado en la clase PrgAlumno es perfectamente vlido haber pensado que esto era algo que haba 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 clculo lo realice la clase Alumno a travs del mtodo promedio( ), el cual se desarrolla a continuacin:
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 ; // Tambin 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 lneas siguientes, ubicadas dentro del mtodo main( ) de la clase PrgAlumno, permiten ejecutar el mtodo 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 mtodos se utiliza el operador punto (.). El operador punto relaciona el nombre del objeto con el nombre de un mtodo. Analicemos la siguiente sentencia;
objAlumno.promedio ( ) ;
Esta sentencia es parte del mtodo main( ) de la clase PrgAlumno y permite que se ejecute el mtodo promedio( ) del objeto objAlumno definido en la clase Alumno. Es decir; se ejecuta el mtodo promedio( ) utilizando el nombre de un objeto de la clase Alumno seguido por el operador punto. As, cuando se ejecuta;
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 ). 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 ). 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 ).
objAlumno02.promedio ( ) ;
objAlumno03.promedio ( ) ;
Pag. 545
Ahora, se analizar la definicin del mtodo promedio( ) de la clase Alumno;

void promedio ( ) { System.out.print ( El promedio final del alumno es: ) ; System.out.println ( (nota1 + nota2 + nota3 ) / 3 ) ; }
El mtodo promedio( ) no devuelve ningn valor ya que tiene definido como tipo de retorno void. Todos los mtodos definidos con void no devuelven valor, por lo que no es necesario especificar una sentencia return al final de este mtodo. El mtodo promedio(), tampoco tiene parmetros ya que al final del nombre del mtodo los parntesis se encuentran vacos.
No devuelve valor. No tiene parmetros.
void promedio ( ) { System.out.print ( El promedio final del alumno es: ) ; System.out.println ( ( nota1 + nota2 + nota3 ) / 3 ) ; }
La llave de apertura {, ubicada despus del parntesis y la llave de cierre } ubicada en la ltima lnea definen el mbito del mtodo promedio( ). El mbito de un mtodo define todas las sentencias que se ejecutarn cuando el mtodo se ejecute. En el caso anterior, cuando se ejecute el mtodo promedio( ) se ejecutarn las dos sentencia que estn dentro de su mbito (es decir, entre las llaves). En el mbito del mtodo 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 mtodo 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
Mtodos que devuelven valor y no reciben parmetros Aunque en el mtodo promedio( ) se realiza el clculo y visualizacin del promedio de notas, esto no constituye la mejor forma o alternativa de desarrollar dicho mtodo. Esto se debe, a que en mucho casos, otras partes del mtodo main( ) u otros mtodos necesitarn que se ejecute el mtodo promedio( ) para que se realice el clculo del promedio de notas, pero no todos necesitarn que una vez calculado el promedio de notas este se visualice. Con la finalidad de mejorar la implementacin del mtodo promedio( ), se puede realizar solo el clculo del promedio de notas y devolver dicho valor para que este pueda ser utilizado de diferente forma. A continuacin se modificar el proyecto de solucin ProyAlumno con la finalidad de mejorar la implementacin del mtodo 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 ; // Tambin 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 Mara es + prom + . ) ; System.out.println ( La nota final de Pedro es + objAlumno03.promedio ( ) + . ) ; } }
Para ejecutar, un mtodo que devuelve un valor, se utiliza tambin el nombre del objeto, el operador punto (.) y el nombre del mtodo, pero debido a que el mtodo devuelve un valor, ste deber ser asignado a una variable del mismo tipo que el valor devuelto por el mtodo. En el ejemplo tenemos la siguiente sentencia:
prom = objAlumno.promedio ( ) ;
Esta sentencia es parte del mtodo main( ) de la clase PrgAlumno y permite que se ejecute el mtodo promedio( ) del objeto objAlumno definido en la clase Alumno. Como el mtodo 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 mtodo promedio( ).
Sentencia definida en el mtodo main( ) de la clase PrgAlumno.
Mtodo definido en la clase Alumno.
double promedio ( ) { return ( nota1 + nota2 + nota3 ) / 3 ; }
prom =
Una vez que prom ya tiene el valor devuelto por el mtodo promedio( ) se puede procesar dicho valor segn 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 Mara es + prom + . ) ;
Es preciso mencionar, que se puede escribir estas sentencias de una manera ms 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 ejecucin del mtodo promedio( ) se realiza directamente en la sentencia println(). Es decir, al ejecutar println( ), se ejecuta a su vez el mtodo objAlumno3.promedio( ) y el valor devuelto se muestra a travs de la pantalla.
Existen dos puntos importantes relacionados con los mtodos que devuelven valor: 1. El tipo de dato que un mtodo devuelve (con la sentencia return), debe ser compatible con el tipo de dato especificado por el mtodo.
Especifica que se debe devolver un valor double. No tiene parmetros.
double promedio ( ) { return (nota1 + nota2 + nota3 ) / 3 ; }
2. La variable que recibe el valor devuelto por el mtodo debe tambin ser compatible con el tipo de dato especificado por el mtodo.
Declarada como double. Lo cual es compatible con el tipo de dato especificado por el mtodo.
prom = objAlumno.promedio ( ) ;
Pag. 549
Mtodos que no devuelven valor y reciben parmetros Ahora, se definir un segundo mtodo dentro de la clase Alumno. El mtodo 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 diseados las variables de instancia deberan ser accesibles slo a travs de los mtodos definidos por sus clases y no en forma directa. El mtodo setNotas( ) recibir, a travs de sus parmetros, las notas de un alumno y las asignar a los atributos de instancia. Los parmetros generalizan el uso de un mtodo 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 ) ; // Tambin 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 Mara es + prom + . ) ; System.out.println ( La nota final de Pedro es + objAlumno03.promedio() + . ); } }
Para ejecutar un mtodo que tiene parmetros se utiliza el nombre del objeto, el operado punto(.), el nombre del mtodo a ejecutar y los argumentos necesarios.
En el ejemplo anterior tenemos:

objAlumno.setNotas ( 15,19,11 ) ;
Esta sentencia es parte del mtodo main( ) de la clase PrgAlumno( ) y permite ejecutar el mtodo setNotas( ) del objeto objAlumno definido en la clase Alumno. Como el mtodo setNotas( ) tiene definido 3 parmetros es necesario que al momento de ejecutar el mtodo se incluya entre los parntesis los 3 argumentos que se van ha enviar al mtodo.
Sentencia definida en el mtodo main() de la clase PrgAlumno.

a = 15
Mtodo definido en la clase Alumno.
objAlumno.setNotas (15,19,11 ) ;
void setNotas ( double a, double b, double c ) { nota1 = a ; nota2 = b ; nota3 = c ; }
3 ARGUMENTOS Un argumento es un valor que se enva a un mtodo cuando este es ejecutado.
3 PARMETROS Un parmetro es una variable definida por un mtodo, que recibe un valor cuando se ejecuta dicho mtodo.
Pag. 551
Existen dos puntos importantes relacionados con los mtodos que tienen parmetros: 1. Un mtodo que tiene parmetros debe recibir un valor por cada parmetro definido. El valor recibido debe ser compatible con el tipo de dato definido por el parmetro al cual ser asignado:
No devuelve valor. Especifica que se tiene definido 3 parmetros de tipo double.
2. Cuando se ejecuta un mtodo que tiene parmetros, se debe pasar al mtodo un valor por cada parmetro definido (es decir, se deben pasar los argumentos). Cada argumento deber ser compatible con el tipo de dato definido por el parmetro al cual ser asignado:
Especifica que se envan 3 valores (argumentos) de tipo double al mtodo setNotas ( ).
objAlumno.setNotas(15,19,11);
Pag. 552
En conclusin, se puede afirmar lo siguiente: 1. Un mtodo puede; no devolver valor y no tener definido parmetros.
No devuelve valor. No tiene parmetros.
void promedio ( ) { System.out.print ( El promedio final del alumno es: ) ; System.out.println ( ( nota1 + nota2 + nota3 ) / 3 ) ; }
2. Un mtodo puede; no devolver un valor y tener definido uno o ms parmetros.

No devuelve valor. Especifica que se tiene definido 3 parmetros de tipo double.
3. Un mtodo puede; devolver un valor y no tener definido parmetros.

Especifica que se debe devolver un valor double.
No tiene parmetros.
double promedio ( ) { return (nota1 + nota2 + nota3 ) / 3 ; }
4. Un mtodo puede; devolver un valor y tener definido uno o ms parmetros. (Este tipo de mtodos no han sido tratados en el presente captulo).
Pag. 553
Mtodo constructor En Java, la inicializacin de objetos no se puede realizar en el momento en que estos son definidos; Por lo cual, se tiene la caracterstica de disponer de un mtodo que permite inicializar objetos inmediatamente despus que se crean. Este mtodo es conocido como el mtodo constructor. Un constructor es un mtodo especial que sirve para construir o inicializar objetos. Cada vez que se crea un objeto se ejecuta en forma automtica el mtodo constructor. El mtodo constructor permite que se inicialicen la copia de los atributos de instancia de los objetos inmediatamente despus de su creacin. El mtodo constructor tiene el mismo nombre que la clase en la cual est definido. Los mtodos constructores pueden tener parmetros al igual que otros mtodos, pero no devuelven ningn valor, ni siguiera void. Se modificar el proyecto de solucin ProyAlumno, de tal forma que se defina solo el objeto objAlumno de la clase Alumno en el mtodo main() de la clase PrgAlumno (esto con la finalidad de implementar nuevos conceptos en un proyecto de solucin sencillo y pequeo), y se incluir un mtodo 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. Despus que se crea el objeto objAlumno se ejecuta en forma automtica al mtodo constructor Alumno( ). El mtodo constructor Alumno( ) permite inicializar la copia de los atributos de instancia nota1, nota2 y nota3 del objeto objAlumno con el valor cero.
El mtodo constructor puede tener definido parmetros. En ese caso, podemos enviar al mtodo constructor Alumno( ), los valores de la copia de los atributos de instancia nota1, nota2 y nota3 del objeto creado y eliminar el mtodo setNotas( ). Aunque esto es posible y perfectamente vlido, no se eliminar el mtodo setNotas( ). El mtodo 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 mtodo 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 mtodo constructor solo se ejecutar en forma automtica inmediatamente despus de crear un objeto y si se requiere cambiar el valor de una copia de los atributos de instancia del objeto despus de haberlo creado, deber realizarlo empleando otro mtodo. Para nuestro caso, dicho mtodo es setNotas( ) ).
Pag. 555
OCULTAR ATRIBUTOS DE INSTANCIA En Java, no es correcto que dos variables que estn dentro del mismo mbito tengan el mismo nombre. Es decir, dos variables locales declaradas dentro del mismo mtodo o dos atributos, no pueden tener nombres iguales. Sin embargo, una variable local (declarada dentro de un mtodo) 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 codificacin 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 mtodo setNotas( ), se han declarado 3 variables locales (parmetros) para recibir las notas cuando se ejecute el mtodo. Dichas variables locales fueron declaradas con los nombres a, b y c, que no tienen ningn significado especial, ya que dichos nombres de variables no reflejan el valor que almacenan. Ests 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 implementacin del mtodo setNotas( ) podr observar que en dicho mtodo se utilizan las variables locales a, b y c, y tambin 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 podran utilizar los atributos de instancia ya que siempre que se utilicen los nombres nota1, nota2 y nota3, se asumira que se hace referencia a las variables locales y no a los atributos de instancia (ya que ambos tendran 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 variacin en la codificacin 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 mtodo setNotas( ), se utilizan los mismos nombres para las variables locales (declarados como parmetros) 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 prctica 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 prctica programacin.
de los de de
Pag. 558
INGRESO DE DATOS A TRAVS DEL TECLADO Ahora, se modificar el proyecto de solucin ProyAlumno, de tal forma que los datos sean ingresados a travs del teclado de la computadora. Para ello, se utilizar la clase Lectura presentada en captulos 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 prcticas 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 captulos anteriores. }
Pag. 559
Ahora, el proyecto de solucin 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 especficas que se detallan a continuacin. Clase PrgAlumno: Tiene el mtodo main( ) que permite que el proyecto se ejecute. Dentro del mtodo main( ), se crea al objeto objAlumno de la clase Alumno, se ingresan las notas del alumno y se muestra el promedio. Define los atributos de instancia para almacenar las notas y los mtodos que permiten manipular dichos atributos de instancia. Uno de los mtodos realiza el clculo del promedio. Define mtodos que facilitan el ingreso de datos utilizando el teclado.
Clase Alumno:
Clase Lectura:
Pag. 560
MTODO DE LAS 6D: Etapas y pasos El proyecto de solucin ProyAlumno, se ha modificado poco a poco con la finalidad de tratar nuevos conceptos relacionados a la POO utilizando Java. Con la ltima solucin 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 mtodo de las 6D y poder desarrollar un proyecto que permitan al lector familiarizarse con este tipo de soluciones. Ajuste de los pasos definidos para las etapas del mtodo En la solucin 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 mtodo main( ) y se definirn objetos de la otra clase, mientras que en la otra clase se definirn los atributos de instancia, mtodos de instancia y mtodo constructor vlido para los objetos. En base a esto, el mtodo de solucin queda definido segn se muestra a continuacin:
Definicin del proyecto de solucin. Definicin del algoritmo. Definicin del paquete Aplicacin. o Definicin de clases con sus atributos y mtodos. Definicin del paquete biblioteca. o Uso de la clase Lectura con sus mtodos definidos.
Diseo del diagrama de paquetes respectivo. Establecer la dependencia. (Utilice UML). Diseo de las clases que sern parte del paquete Aplicacin. (Utilice UML).
Codificar el diseo de la solucin del problema utilizando el lenguaje de programacin Java.
Diseo del algoritmo para los mtodo definidos. Utilizar pseudocdigo.
Pag. 561
Pag. 562
Con el propsito de describir los pasos definidos de las etapas del mtodo 6D, se volver a solucionar el problema anterior.
PROBLEMA 151
Etapa 01 - Descripcin del problema. Calcular el promedio final de un alumno. Utilice la siguiente frmula: prom = ( nota1 + nota2 + nota3 ) / 3. Ingrese las notas nota1, nota2 y nota3 a travs del teclado. Etapa 02 - Definicin de la solucin. 1. Definicin del proyecto de solucin. 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. Definicin del algoritmo. Resultado deseado: Datos necesarios: Procesamiento: Mostrar la nota final de un determinado alumno. Las notas del alumno (en esta caso tenemos 3 notas). La 3 notas sern ingresadas por teclado y almacenadas en las variables nota1, nota2, y nota3. Luego, se realizar el clculo de la nota final sobre la base de la siguiente frmula: prom = ( nota1 + nota2 + nota3 ) / 3. El resultado se almacenar en una variable (prom) para luego ser mostradas por pantalla.
3. Definicin del paquete Aplicacin. En el paquete dominioDeLaAplicacion definiremos dos clases. La funcin de la primera clase ser de procesamiento y almacenamiento de datos. Como buena prctica de programacin, en los mtodos de esta clase, no se realizar ingreso de datos, ni se mostrarn mensajes de ningn tipo. Pero, si se utilizarn los mismos nombres para referirnos a variables locales y a los atributos
Pag. 563
de instancia. Por otro lado, solo podrn ser definidos como atributos de instancia los datos de entrada. Su definicin ser la siguiente: Clase: Atributos: Mtodos: Alumno. Como atributos de instancia definiremos las variables de entrada nota1, nota2 y nota3. Necesitamos los siguientes mtodos: Mtodo constructor para inicializar los atributos de instancia (mtodo Alumno()). Mtodo para modificar los valores de las notas (mtodo setNotas(), recibe los valores de las notas ). Mtodo para calcular el promedio de las notas (mtodo promedio(), devuelve el valor del clculo del promedio de las notas).
La funcin de la segunda clase ser el ingreso de los datos y mostrar los resultados esperados. Como buena prctica de programacin, en los mtodos de esta clase, no se realizar ningn tipo de clculo y solo podrn ser definidos como atributos de instancia objetos de la otra clase (para este caso, la clase Alumno). Su definicin ser la siguiente: Clase: Atributos: Mtodos: PrgAlumno. Como atributos de instancia definiremos al objeto objAlumno de la clase Alumno. Utilizamos el mtodo main( ) para iniciar la ejecucin del proyecto, la creacin del objeto objAlumno, el ingreso de los datos y mostrar los resultados esperados.
4. Definicin del paquete biblioteca. En el paquete biblioteca se tendr la clase Lectura para poder utilizar sus mtodos.
Pag. 564
Etapa 03 Diseo de la lgica. Diseo del Diagrama de Paquetes. Diagrama de paquetes
dominioDeLaAplicacion
biblioteca
Diseo de las clases. Clases de dominioDeLaAplicacion

PrgAlumno nota1 : double nota2 : double nota3 : double main( ) Alumno( ) setNotas(double, double, double) : void promedio( ) : double Alumno
Clase de biblioteca
Lectura leerString( ) : String leerChar( ) : char leerInt( ) : int leerLong( ) : long leerFloat( ) : float leerDouble( ) : double
Diseo 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 Diseo de la lgica, se ha utilizado nuevas reglas de pseudocdigo las cuales describimos a continuacin:
CREAR OBJETO Se utiliza para indicar la creacin de un determinado objeto. El formato completo se muestra a continuacin a travs de un ejemplo: CREAR OBJETO objAlumno CLASE Alumno EJECUTA Alumno ( ) A travs de esta instruccin se crea un objeto denominado objAlumno de la clase Alumno y se ejecuta el mtodo constructor especificado.
Pag. 566
EJECUTAR Se utiliza para ejecutar un mtodo. Hay que tener presente que si el mtodo es de clase se deber anteponer el operador punto (.) y el nombre de la clase antes de colocar el nombre del mtodo que se desea ejecutar. Si el mtodo es de instancia se deber anteponer el operador punto (.) y el nombre del objeto antes de colocar el nombre del mtodo que se desea ejecutar. EJECUTAR objAlumno.setNotas ( n1,n2,n3 ) Se ejecuta el mtodo setNotas() del objeto objAlumno, y se le envan los valores de la variables n1, n2 y n3. prom = EJECUTAR objAlumno.promedio ( ) Se ejecuta el mtodo promedio del objeto objAlumno. El mtodo 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 mtodo. PARAMETRO: nota1, nota2, nota3 Se especifica que se utilizan las variables nota1, nota2 y nota3 para recibir los valores que se envan al mtodo al cual pertenece la instruccin. RETORNO Se utiliza para especificar la variable que utilizaremos para devolver o retornar una respuesta de un determinado mtodo. RETORNO: prom Se especifica que el valor almacenado en la variable prom ser devuelto como respuesta cuando se ejecuta el mtodo al cual pertenece la instruccin. ATRIBUTO Se utiliza para diferenciar un atributo de una variable local cuando ambos tienen el mismo nombre y se utilizan en un mismo mtodo. 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 Codificacin. 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 prcticas 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 Programacin Orientada a Objetos, tales como; Encapsulamieno, Herencia, Polimorfismo, Interfaces Grficas, Conexiones a BD, Servlets, entre otros. Dichos conceptos avanzados permitirn elaborar soluciones robustas y profesionales, para luego poder iniciar con una base adecuada su investigacin en el desarrollo de soluciones J2EE (Java 2 Enterprise Edition) basadas en tecnologa Internet.
Pag. 569
Pag. 570
APNDICE
APNDICE
Problemas propuestos
ENUNCIADO DE PROBLEMAS RESUELTOS
1. Desarrollar una solucin que permita mostrar un mensaje por la pantalla. El mensaje a mostrar ser Hola bienvenidos mi nombre es Danae. 2. Desarrollar una solucin que permita mostrar el nombre, apellido y el promedio del alumno Julio Csar Arias Pimentel que ha obtenido las siguientes notas: nota1=11, nota2=13 y nota3=15. Utilizar la siguiente frmula: Promedio: nf = (nota1 + nota2 + nota3) / 3. 3. Desarrollar una solucin que permita mostrar el resultado de sumar, multiplicar, restar y dividir los nmeros 124 y 35. 4. Desarrollar una solucin que permita ingresar el nombre de dos personas y luego mostrar los nombres junto con un mensaje de bienvenida. 5. Desarrollar una solucin que permita leer el costo de un artculo y su precio de venta. Calcular y mostrar su utilidad. 6. Desarrollar una solucin que permita ingresar el precio de un artculo y mostrar el precio total a pagar incluyendo el IGV respectivo (Impuesto General a las Ventas = 19%). 7. Desarrollar una solucin que permita ingresar el precio de un artculo y su respectivo descuento (expresado en %). Mostrar el precio total a pagar incluyendo el IGV (Impuesto General a las Ventas = 19%).
Pag. 573
APNDICE
8. Desarrollar una solucin que permita ingresar el lado de un cuadrado. Calcular y mostrar el rea del cuadrado. 9. Desarrollar una solucin que permita calcular y mostrar el rea de un tringulo rectngulo. Ingresar la base y la altura del tringulo rectngulo. 10. Desarrollar una solucin que permita calcular y mostrar el permetro y el rea de un crculo. Ingresar el radio del crculo. 11. Desarrollar una solucin que permita calcular y visualizar el permetro y el rea de un rectngulo. Ingresar la base y la altura del rectngulo. 12. Desarrollar una solucin que permita calcular el rea de un tringulo en funcin de las longitudes de sus lados. Mostrar el resultado obtenido. Area = ((p*(p - a)*(p - b)*(p - c)) RAIZ 2. Semipermetro p = (a +b + c) / 2. 13. Desarrollar una solucin que permita convertir y mostrar una cantidad de dinero, expresado en dlares, en su equivalente en nuevos soles. Ingresar la cantidad en dlares y el tipo de cambio. 14. Desarrollar una solucin que permita convertir y mostrar una cantidad de soles a Dlares y a Euros. Considerar como tipo de cambio; 1 Dlar = 3.352 soles, y 1 Dlar = 1.09 Euros. 15. Desarrollar una solucin que permita leer un nmero y calcular el resto de dividir el nmero entre 3. Mostrar el resto de la divisin.
Pag. 574
APNDICE
16. Desarrollar una solucin que permita ingresar 2 nmeros a travs del teclado. Calcular la suma, resta, multiplicacin y divisin de dichos nmeros. Mostrar el resultado de las operaciones. 17. Desarrollar una solucin que permita ingresar 2 nmeros a travs del teclado. Calcular la suma, resta, multiplicacin y divisin de dichos nmeros. Adicionalmente, calcular la potencia de 5 y la raz cuadrada de cada uno de los nmeros ingresados. Mostrar el resultado de todas las operaciones. 18. Desarrollar una solucin que permita ingresar las notas de un determinado alumno y visualizar su promedio final. El promedio final se obtiene de la siguiente frmula: PF = (PL + EP + EF*2)/4. Donde PL = Promedio de Laboratorio. EP = Examen Parcial y EF = Examen Final. 19. Desarrollar una solucin que permita calcular la nota final que ha obtenido un alumno en el curso de laboratorio de Programacin Avanzada. Utilizar la siguiente frmula: nf = (n1 + n2 + n3 + (n4 * 2)) / 5. Ingresar las notas n1, n2, n3 y n4 a travs del teclado. 20. Desarrollar una solucin 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 travs del teclado. 21. Desarrollar una solucin 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 solucin 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
APNDICE
23. Desarrollar una solucin 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 cafetera. Mostrar el total de descuentos y el sueldo a cobrar. 24. Desarrollar una solucin 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 solucin que permita convertir una cantidad expresada en metros a sus equivalentes en centmetros, pulgadas, pies y yardas. Considerar la siguiente informacin: 1 metro = 100 cm. 1 pulgada = 2.54 cm. 1 pie = 12 pulgadas. 1 yarda = 3 pies. 26. Desarrollar una solucin 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 frmula: Distancia = ((x1-x2) **2 + (y1-y2) ** 2) RAIZ 2. 27. Desarrollar una solucin que permita calcular el permetro de un tringulo dadas las coordenadas de los puntos P1, P2 y P3, los cuales corresponden a los vrtices de un tringulo. Utilizar la frmula del problema anterior para determinar la distancia entre cada uno de los puntos. 28. Desarrollar una solucin que permita ingresar 2 nmeros enteros positivos de dos cifras. Intercambie las unidades de los dos nmeros. 29. Desarrollar una solucin que permita ingresar un nmero de 4 cifras. Determinar la suma de las cifras del nmero ingresado. Pag. 576
APNDICE
30. Desarrollar una solucin que permita determinar si un nmero ingresado por teclado es capica o no. Un nmero es capica si se lee igual de derecha a izquierda o viceversa. (Ejemplo de nmero capica 4554). 31. Desarrollar una solucin que permita invertir un nmero de cuatro dgitos. El nmero deber ser ingresado por teclado. (Ejemplo: se ingresa el nmero 3579 se debe visualizar el 9753). 32. Desarrollar una solucin que permita convertir una temperatura expresada en grados Celsius a su equivalente en grados Fahrenheit. frmula: F = (9 / 5) * C + 32. 33. Desarrollar una solucin que permita calcular y visualizar el nmero de segundos que hay en un determinado nmero de das. 34. Desarrollar una solucin que permita ingresar una cantidad entera de dinero. Mostrar el nmero 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 solucin que permita realizar el clculo del pago mensual del sueldo de un empleado de una empresa. Dicho clculo se realiza de la siguientes manera: el sueldo bsico se calcula en base al nmero total de horas trabajadas basada en una tarifa horaria. Al sueldo bsico se le aplica una bonificacin del 35% obtenindose el sueldo bruto. Al sueldo bruto se le aplica un descuento del 12% obtenindose el sueldo neto. Mostrar el sueldo bsico, el sueldo bruto y el sueldo neto de un trabajador. 36. Desarrollar una solucin que permita calcula el sueldo neto de un vendedor. Dicho clculo se realiza en base a un sueldo bsico equivalente a S/ 465.00 nuevos soles, ms una comisin 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 Utilizar la siguiente
APNDICE
37. Desarrollar una solucin que permita calcular el porcentaje de hombres y el porcentaje de mujeres que estn matriculados en un determinado curso. 38. Desarrollar una solucin 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 solucin que permita determinar con qu velocidad inicial parti un automvil de un determinado punto y qu distancia, conociendo su velocidad final, su aceleracin y el tiempo empleado en el recorrido. Considerar las siguientes frmulas: e = Vot + at
2
Vf = Vo + at.
donde: Vf = Velocidad final. Vo = Velocidad Inicial. a = Aceleracin. e = Espacio recorrido. t = Tiempo empleado en el recorrido.
40. Desarrollar una solucin que permita determinar si una persona es o no mayor de edad. Ingresar el nombre, apellidos, cdigo y edad de la persona. 41. Desarrollar una solucin 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 pequeo. 42. Desarrollar una solucin que permita determinar cmo se clasifica un ngulo ingresado por teclado. Los ngulos se clasifican de la siguiente manera: ngulo = 0 0 < ngulo > 90 Pag. 578 Nulo. Agudo.
APNDICE
ngulo = 90 90 < ngulo > 180 ngulo = 180 180 < ngulo > 360 ngulo = 360
Recto. Obtuso. Llano. Cncavo. Completo.
43. Desarrollar una solucin que permita calcular y mostrar la nota final (nf) de un alumno, sabiendo que se tienen slo dos notas. Si el alumno obtiene una nota final mayor a 17 se deber visualizar un mensaje de felicitaciones. 44. Desarrollar una solucin que permita ingresar los votos obtenidos por cada candidato en una eleccin democrtica. Determinar la votacin promedio y mostrar los cdigos de los candidatos que obtuvieron una votacin inferior a la votacin promedio. Considerar que han participado 5 candidatos cuyos cdigos son A, B, C, D y E. 45. Desarrollar una solucin que permita calcular y mostrar el sueldo de un trabajador conociendo el nmero 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 solucin que permita calcular el sueldo de un trabajador conociendo el nmero 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 solucin 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 solucin que permita
Pag. 579
APNDICE
48. Desarrollar una solucin 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. Frmula: nf = (n1+n2+n3) / 3. 49. Desarrollar una solucin que permita ingresar tres notas de un determinado alumno. Mostrar las notas ordenadas en forma ascendente (de menor a mayor). 50. Desarrollar una solucin 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 solucin que permita calcular y mostrar el monto total a pagar por la compra de varios artculos. 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 solucin que permita determinar que proveedor es ms 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 continuacin: Proveedor A: Costo unitario igual a $25.0 y 15% de descuento para ms 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 solucin que permita determinar si un nmero es divisor de otro nmero. Utilizar la expresin (num1 RESTO num2 > 0) donde num1 y num2 son los nmeros.
Pag. 580
APNDICE
54. Desarrollar una solucin que permita ingresar un nmero entero. Mostrar si el nmero ingresado es un nmero par o un nmero impar. 55. Desarrollar una solucin que permita ingresar un nmero entero. Mostrar si el nmero ingresado es un nmero negativo, un nmero par o un nmero mltiplo de 7. 56. Desarrollar una solucin que permita ingresar un nmero entero. Indicar lo siguiente en base al nmero ingresado: Si el nmero es positivo o negativo. Si el nmero es par o impar. Si el nmero es mltiplo de 3 o no. Si el nmero es Menor que 500 o no. 57. Desarrollar una solucin que permita determinar si un numero (num) es par, impar o nulo. Utilizar lo siguiente: -1 elevado a la potencia del nmero ingresado (-1 ** num). Mostrar un mensaje si el nmero es par, impar o nulo. 58. Desarrollar una solucin que permita ingresar un nmero entre 1 y 12. Mostrar el nombre del mes del ao correspondiente. (Enero, Febrero,...etc). 59. Desarrollar un programa que permita ingresar un nmero entre 1 y 7. Mostrar el nombre del da de la semana correspondiente. (Lunes, martesetc). 60. Desarrollar una solucin que permita ingresar la categora y el sueldo de un trabajador. Calcular el aumento correspondiente teniendo en cuenta la siguiente tabla. Mostrar el nuevo sueldo del trabajador. Categora 1 2 3 Aumento 35 % 25 % 15 %
Pag. 581
APNDICE
5%
61. Desarrollar una solucin que permita calcular y mostrar el monto total a pagar por un sndwich, sabiendo que, adicionalmente, hay que pagar el 6% por el servicio y 7% por propinas. Considerar que se venden 4 tipos de sndwich, de acuerdo a la siguiente tabla. Tipo Moderado Mediano Extra Grande Full Costo S/. 2.00 S/. 3.00 S/. 4.00 S/. 6.00
62. Desarrollar una solucin que permita calcular y mostrar el costo total que representa un paciente para un hospital de acuerdo al tipo de enfermedad, segn los datos de la tabla. Adicionalmente, debe considerar que los pacientes menores de 18 aos implican un costo adicional de 25 %. Enfermedad Tipo 1 2 3 Costo diario 120 380 620
63. Desarrollar una solucin que permita calcular y mostrar el costo total que representa un paciente para un hospital de acuerdo al tipo de enfermedad, segn 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 1 2 Costo diario 180 420
Pag. 582
APNDICE
513
64. Desarrollar una solucin que permita determinar y mostrar si una persona que est a punto de observar un programa de televisin esta apto o no. Considerar la siguiente tabla: Edad 18 -ms 11 -17 0 10 Categora Contenido para adultos. Mayores de 14. Apta para todos.
65. Desarrollar una solucin que permita calcular y mostrar el costo total que representa un paciente para un hospital de acuerdo al tipo de enfermedad, segn los datos de la tabla. Adicionalmente, debe considerar que los pacientes de sexo femenino menores de 14 aos implican un costo adicional de 8%. Enfermedad Tipo 1 2 3 4 Costo diario 122 234 345 587
66. Desarrollar una solucin que permita ingresar las notas obtenidas por un alumno del curso de Matemtica Bsica III. Calcular su nota final (nf), de acuerdo a la frmula empleada por su profesor, segn los datos de la tabla. Mostrar la nota final (nf) del alumno y si est aprobado o no, considerando que la nota mnima aprobatoria es 12 (doce). Cdigo Profesor 1 2 3 Frmula nf = (n1 + n2 ) / 2 nf = (n1 + n2*2) / 3 nf = (n1*2 + n2) / 3
Pag. 583
APNDICE
67. Desarrollar una solucin que permita determinar la categora de cada postulante. Considerar que la categorizacin de los postulantes se realiza en funcin de su sexo y edad, de acuerdo a lo siguiente: Si la persona es de sexo femenino: Categora FA si tienen menos de 30 aos. Categora FB en caso contrario. Si la persona es de sexo masculino: Categora MA si tiene menos de 40 aos. Categora MB en caso contrario. 68. Desarrollar una solucin que permita determinar la categora de cada alumno. Considerar que la categorizacin de los alumnos se realiza en funcin de la nota en base a la siguiente tabla: Promedio 18 20 15 17 11 14 00 10 Bueno Regular Malo Categora Excelente
69. Desarrollar una solucin 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 categora obtenida por un alumno, considerando que la categora del alumno est en funcin de su promedio, tal y como se muestra en la siguiente tabla: Promedio Desde 17 a 20 Desde 14 a 16 Desde 10 a 13 Desde cero a 9 Categora A B C D
Pag. 584
APNDICE
70. Desarrollar una solucin que permita calcular el rea de un rectngulo conociendo su base y altura. Si el rea es menor que 100, se deber visualizar el mensaje rectngulo pequeo y si el rea es mayor o igual que 1000 se deber visualizar el mensaje rectngulo grande. 71. Desarrollar una solucin que permita calcular el rea de un rectngulo conociendo su base y altura. Si el rea es menor que 100, se deber visualizar el mensaje rectngulo pequeo; si el rea es mayor o igual a 100 y menor que 1000, se visualizar el mensaje rectngulo mediano; y si el rea es mayor o igual que 1000, el mensaje ser rectngulo grande. 72. Desarrollar una solucin que permita ingresar el nombre del alumno, el tipo de participante (profesor, alumno, externo) y el nivel del curso (bsico, intermedio, avanzado). En la tabla que se muestra a continuacin se detallan los costos de los cursos: Bsico Profesor Alumno Externo 35 40 60 Intermedio 40 50 80 Avanzado 45 60 100
Mostrar los datos del recibo, tal y como se muestra en el siguiente ejemplo: ********************* RECIBO ****************** Alumno : Juan Prez Costo Nivel : (de acuerdo a la tabla) : (de acuerdo al ingresado)
*************************************************** 73. Desarrollar una solucin 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
APNDICE
Condicin Sueldo < 2000 2000 < =Sueldo < =3000 Sueldo > 3000
Aumento 23 % 17 % 12 %
74. Desarrollar una solucin que permita ingresar la temperatura promedio (tp) de un da y permita mostrar el tipo de clima de acuerdo a la siguiente tabla: Temperatura (tp) TP<=9 9<TP<=17 17<TP<=27 TP>27 Tipo de Clima Fri Nublado Caluroso Trpico
75. Desarrollar una solucin que permita ingresar una fecha en el siguiente formato: (dd/mm/aaaa). Calcular el nmero de das que tiene el mes y si el ao ingresado es bisiesto o no. 76. Desarrollar una solucin 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 solucin que permita ingresar un nmero de 2 cifras. Mostrar el equivalente del nmero ingresado en letras. 78. Desarrollar una solucin que permita ingresar un nmero de 3 cifras. Mostrar el equivalente del nmero ingresado en letras. 79. Desarrollar una solucin que permita calcular el factorial de un nmero entero positivo.
Pag. 586
APNDICE
80. Desarrollar una solucin que permita ingresar tres nmeros enteros. Mostrar el nmero mayor. 81. Desarrollar una solucin que permita mostrar la tabla de multiplicar de un nmero cualquiera ingresado por teclado. 82. Desarrollar una solucin que permita determinar cules son los trminos de una progresin aritmtica. Solicitar el valor del primer trmino, el valor de la razn y el nmero de trminos. 83. Desarrollar una solucin que permita determinar cuales son los trminos de una progresin aritmtica y la suma de los mismos. Solicitar el valor del primer trmino, el valor de la razn y el nmero de trminos. 84. Desarrollar una solucin que permita determinar cuales son los trminos de una progresin geomtrica y la suma de los mismos. Solicitar el valor del primer trmino, el valor de la razn y el nmero de trminos. 85. Desarrollar una solucin que permita determinar y mostrar la suma de los trminos de la siguiente serie: 1 + 1/3 + 1/5 + 1/7 + 1/9 +... 86. Desarrollar una solucin que permita determinar los 3 primeros nmeros perfectos. 87. Desarrollar una solucin que permita determinar la suma de todos los nmeros cuadrados perfectos existentes entre los 1000 primeros nmeros. 88. Desarrollar una solucin que permita calcular la cantidad de dgitos, la suma de dgitos y la cantidad de dgitos pares e impares de un nmero entero.
2 2 2 2
Pag. 587
APNDICE
89. Desarrollar una solucin que permita calcular y mostrar el producto de los nmeros pares comprendidos entre los nmeros 20 y 400. 90. Desarrollar una solucin que permita calcular y mostrar la suma de los nmeros pares y la suma de los nmeros impares comprendidos entre los nmeros 1 y 100 (no incluir los nmeros 1 y 100). 91. Desarrollar una solucin que permita ingresar 50 nmeros enteros
cualesquiera. Determinar cuntos nmeros son negativos, ceros y positivos. 92. Desarrollar una solucin que permita ingresar 100 nmeros. Calcular y mostrar la suma de los nmeros pares, la suma de los nmeros impares y la media de todos los nmero ingresados. 93. Desarrollar una solucin que permita ingresar un nmero entero. Determinar y mostrar si el nmero ingresado es un nmero primo o no. 94. Desarrollar una solucin que permita ingresar 50 nmeros. Determinar la suma de todos los nmeros impares y la cantidad de nmeros primos ingresados. 95. Desarrollar una solucin que permita ingresar 10 nmeros. Determinar y mostrar la suma de todos los nmeros pares y la suma de todos los nmeros primos. 96. Desarrollar un programa que genere cada uno de los siguientes grficos:
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
97. Desarrollar un programa que genere cada uno de los siguientes grficos:
Pag. 588
APNDICE
* *
* *
* * *
* *
* *
* * * * * * * * * * *
* * * * * * * * * * * * * * *
* *
* * *
* * * *
* * * * *
* * * *
* * *
* *
98. Desarrollar un programa que genere el siguiente grfico:

1 2 4 7 2 7 2 5 7 3 8 3 6 8 4 9 4 5 9 5 1 3 6 1 6
99. Desarrollar un programa que permita leer una cadena. Mostrar la cadena ingresada en forma triangular. Tal y como se muestra a continuacin: 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 continuacin: Ejemplo; Se ingresa la cadena Danae. DANAE DANA DAN Pag. 589
APNDICE
DA D 101. Desarrollar una solucin que permita invertir un nmero cualquiera. El nmero deber ser ingresado por teclado. 102. Desarrollar una solucin 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 smbolos. 103. Desarrollar una solucin que permita calcular y mostrar la nota final de 10 alumno. Utilizar la siguiente frmula: nf = (n1+n2+n3+(n4*2))/5. Ingresar las notas a travs del teclado. 104. Desarrollar una solucin 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 mxima. Edad mnima. 105. Desarrollar una solucin que permita calcular la nota final de todos los alumnos. Utilizar la siguiente frmula: nf = (n1 + n2 + n3 + (n4 * 2)) / 5. Ingresar las notas a travs del teclado. Se deber utilizar la estructura lgica MIENTRAS. 106. Desarrollar una solucin que permita calcular la nota final de todos los alumnos. Utilizar la siguiente frmula: nf = (n1 + n2 + n3 + (n4 * 2)) / 5.
Pag. 590
APNDICE
Ingrese las notas a travs del teclado. Se deber utilizar la estructura lgica HACER. 107. Desarrollar una solucin para el siguiente problema. En un saln 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 solucin para el siguiente problema. Se tiene una relacin de 100 obreros y su sueldo. Determinar cuntos 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 cuntos ms de S/.3,000.00. 109. Desarrollar una solucin que permita determinar la suma de sueldos de los obreros (categora C), la suma de sueldos de los empleados (categora B) y la suma de sueldos de los gerentes (categora A) de una determinada empresa. Adicionalmente, determinar cul es el mayor y el menor sueldo en la empresa. 110. Desarrollar una solucin para el siguiente problema. Se desea hacer una estadstica 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 nmero 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 frmula: nf = (n1 + n2 + n3 + (n4 * 2)) / 5.
Pag. 591
APNDICE
112. Calcular la nota media de los alumnos de una clase considerando n alumnos y c notas. 113. Un canillita vende 4 tipos de loteras segn se muestra en el siguiente cuadro. Calcular el total de loteras vendidas de cada tipo. Tipo lotera 1 2 3 4 Costo 2 4 6 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 automovilstico. Se determina que los gerentes contribuirn 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 solucin que permita emitir la factura correspondiente a la compra de varios artculos. 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 solucin que permita desarrollar el siguiente men con las opciones solicitadas. [1] Ingreso de datos (base y altura de un rectngulo). [2] Proceso (determinar rea y permetro del rectngulo). [3] Resultado (Mostrar el valor de rea y permetro obtenidos). [4] Terminar. 117. Desarrollar una solucin para el siguiente problema. Los empleados de una fbrica trabajan en tres turnos; maana, tarde y noche. Se desea calcular el jornal diario de cada empleado teniendo en cuenta lo siguiente: Pag. 592
APNDICE
La tarifa del turno maana 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 da domingo, la tarifa se incrementa en 50% para los turnos maana 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 solucin que permita controlar la venta de boletos en un determinado da en un teatro de la capital, en base a la siguiente informacin: 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: nmero de boleto y lugar (puede ser platea, palco o mezanine). El programa terminar cuando el nmero de boleto sea igual a cero. Antes de finalizar, se deber proporcionar la siguiente informacin: Nmero total de entradas vendidas durante el da. El total de soles recaudados en el da. Nmero de entradas vendidas para platea, palco y mezanine en el da. 119. Desarrollar una solucin que permita obtener la siguiente informacin en un saln de clase: Cuntas alumnas estn matriculadas en el curso? Cuntos alumnos estn matriculados en el curso? Cuntas alumnas son menores de 20 aos? Cuntos alumnos son mayores de 18 aos? Cuntos alumnos estn aprobados? Cuntas alumnas estn desaprobadas?
Pag. 593
APNDICE
120. Desarrollar una solucin 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 solucin 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 ms baja y ms alta. Ingresar la cantidad de alumnos y las 3 notas de cada alumno. 122. Desarrollar una solucin que permita determinar el costo de cada uno de los artculos que se venden en la bodega La China (considere el precio de venta y la utilidad obtenida por el artculo). Adicionalmente, deber indicar el promedio del costo de todos los artculos, el articulo ms caro y el ms barato. Ingresar el nombre, el precio de venta y la utilidad de cada artculo. 123. Desarrollar una solucin 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 solucin que permita calcular y mostrar el costo total que representan los pacientes de un hospital de acuerdo al tipo de enfermedad, segn los datos de la tabla. Adicionalmente, deber considerar que los pacientes menores de 18 aos implican un costo adicional de 35% y las mujeres un costo adicional de 12%. Enfermedad Tipo 1 2 3 Costo diario 100 150 300
Pag. 594
APNDICE
450
125. Desarrollar una solucin para el siguiente problema. El cine Pantalla Lser cuenta con 3 salas y atiende en horarios de matine, vermouth y noche. Calcular el nmero de personas que ingresaron a cada una de las salas en cada uno de los horarios en un determinado da. (Ingresar solo los siguientes datos: Nmero de sala y el horario al cul el cliente ingresa). 126. Desarrollar una solucin para el siguiente problema. Una empresa cuenta con cuatro almacenes de productos. Cul sera la ganancia por cada almacn si el dueo 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 almacn donde estn ubicados). 127. Desarrollar una solucin que permita determinar cuntas hamburguesas fueron vendidas de cada tipo (considere 3 tipos) en cada uno de los 3 locales de la empresa El Rpido. Deber ingresar el tipo de hamburguesa y el local en el que fue vendida. 128. Desarrollar una solucin que permita determinar cuntos tipos de productos de cada empresa de apoyo social fueron vendidos por la comunidad La buena Venta durante el presente ao (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 solucin que permita determinar cuntos tipos de peridicos 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 periodsticas, 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 cul pertenece.
Pag. 595
APNDICE
130. Desarrollar una solucin que permita mostrar un men con las siguientes opciones: Determinar si un nmero es par o impar. Determinar si un nmero es primo o no. Salida. 131. Desarrollar una solucin que permita mostrar un men con las siguientes opciones: Suma, resta y multiplicacin de dos nmeros. Determinar el nmero inverso de un nmero. Determinar el rea y permetro de un crculo. Salida. 132. Desarrollar una solucin 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 solucin 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 solucin 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
APNDICE
135. Desarrollar una solucin que permita ingresar los valores de una matriz de 5*4. Intercambiar la primera columna por la tercera columna, as como tambin intercambiar la segunda fila por la cuarta fila. 136. Desarrollar una solucin 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 aos, y otro listado con los datos de todo los empleados solteros. 137. Desarrollar una solucin que permita ingresar un nmero entero de cualquier nmero de cifras. Determinar y mostrar el digito mayor del nmero ingresado. Validar el nmero ingresado. 138. Desarrollar una solucin que permita ingresar 10 nombres. Determinar el nmero de nombres cuya primera letra es una letra c o una letra x. Tambin determine el nombre que tiene el menor nmero de caracteres. 139. Desarrollar una solucin que permita leer 10 apellidos. Determinar cul es el apellido mayor (alfabticamente hablando). 140. Desarrollar una solucin que permita leer 10 nombres. Determinar cuantos nombres comienzan entre las letras z y p. Utilizar un vector. 141. Desarrollar una solucin 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 solucin 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 nmero de caracteres correctos, as como los smbolos indicados. Mostrar los datos de la siguiente manera: Hoy es 30 de septiembre y son las 18 y 10 de la tarde.
Pag. 597
APNDICE
143. Desarrollar una solucin que permita leer 4 nmeros de 3 cifras. Mostrar su categora. Si el nmero est entre 100 y 300 pertenece a la categora A. Si el nmero est entre 301 y 600 pertenece a la categora B, y si el nmero est entre 601 y 999 pertenece a la categora C. Utilizar un vector y validar que el nmero ingresado sea de 3 cifras. 144. Desarrollar una solucin 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 (tamao de fecha y que contenga los smbolos /) 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 solucin 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 (tamao de fecha y que contenga los smbolos /) y sueldo. Calcular los aos de servicio (que tiene trabajando). Hallar: Hallar el sueldo promedio. Nombre del empleado con menos aos de servicio. Cantidad de empleado que ingresaron entre 1980 y 2004. Crear un men de opciones para acceder al programa. 146. Desarrollar una solucin que permita leer los datos de 5 alumnos. Los datos de los alumnos son; nombre, tipo (Ingresantes, Regular o Egresado) y nota. Pag. 598
APNDICE
Se solicita: Ingresar los datos haciendo las validaciones al tipo y nota. Por cada alumno mostrar la categora: Si es ingresante y tiene entre 17-20 categora IA. Si es ingresante y tiene entre 12-16 categora IB. Si es regular y tiene entre 17-20 categora RA. Si es egresado y tiene entre 17-20 categora EA. Por cada alumno mostrar: Nombre en Mayscula. Los 3 primeros caracteres del nombre. Clculos: 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 opcin para continuar ejecutando el programa. 147. Desarrollar una solucin 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 revs. Ultimo carcter. Las 3 ultima letras. Clculos: 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 solucin 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
APNDICE
Se solicita: Ingresar los datos validando la fecha de nacimiento y la nota. Mostrar por cada alumno la edad exacta (aos y meses cumplidos a la fecha de hoy). Clculos: Hallar la edad promedio. Nombre y la edad de la persona con mayor nota. Nombre de mujer con menos edad. Crear un men de opciones para acceder al programa.
149. Desarrollar una solucin que permita leer los datos de n empleados. Los datos de los empleados son; nombre, AFP (Integra, Unin y ProFuturo), sueldo Bsico 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 Bsico descuentos): Si tiene 4 o ms aos de antigedad se le descuenta 8% ms el descuento de la AFP. Si tiene menos de 4 aos se le descuenta 10% ms el descuento de la AFP. El descuento de la AFP se ve en la siguiente tabla: AFP Integra Unin ProFuturo Clculos: Mostrar el nombre y el AFP de la persona con mayor sueldo. Mostrar el nombre de la persona ms nueva es decir con menos aos de ingreso. Crear un men de opciones para acceder al programa. Pag. 600 Descuento 12% 13% 14%
APNDICE
150. Desarrollar una solucin 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 nmero positivo. Mostrar lo siguiente por cada alumno: Si es mayor o menor de edad. Cantidad de vocales del nombre. Clculos: Hallar la edad promedio. Nombre de la persona con mayor edad. Nombre de hombre con menos edad. Crear un men de opciones para acceder al programa.
Pag. 601
APNDICE
Pag. 602
APNDICE
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
APNDICE
/** * 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
APNDICE
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 nmeros decimales. Tiene una gran variedad de opciones para dar formatos a nmeros en cualquier sistema, incluye soporte para dgitos Occidentales, Arbigos e ndicos. Tambin soporta gran variedad de formatos numricos, como son: enteros, decimales, notacin cientfica, formato de moneda, etc. Con la clase DecimalFormat se especfica un formato de nmero con patrn. La clase DecimalFormatSymbols permite modificar los smbolos de formato como separadores decimales o el signo negativo entre otros. Se puede utilizar la clase DecimalFormat para formatear nmeros decimales en cadenas especficas de la Localidad. Los programas almacenan y operan con nmeros de una forma independiente de la Localidad. Antes de mostrar o imprimir un nmero el programa debe convertirlo a un String que est en un formato sensible a la Localidad. Por ejemplo, en Francia, el nmero 123456.78 debera ser formateado como 123 456,78, y en Alemania debera aparecer como 123.456,78. mtodos: Par poner en prctica esto podemos recurrir a 2
NumberFormat formato ; DecimalFormat df ;
Pag. 605
APNDICE
Si queremos dar formato a nmeros: formato = NumberFormat.getNumberInstance(currentLocale); Si queremos dar formato a monedas: formato = NumberFormat.getCurrencyInstance(currentLocale); Luego aplicamos las caractersticas 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 smbolo del formateo como el separador decimal, se puede utilizar DecimalFormatSymbols en conjuncin con la clase DecimalFormat
Smbolos usados para formato

Smbolo Significado 0 # . , E ; % \u2030 Digito Digito, el cero se muestra como ausente Separador decimal Signo menos Separador de agrupacin Para notacin cientfica "0.###E0" muestra 1234 como "1.234E3" Para separar formatos positivos y negativos Multiplica por 100 y lo muestra como porcentaje Multiplica por 1000 y muestra como millares
(\u00A4) Utilizado para mostrar smbolos monetarios ' Usado para mostrar caracteres especiales
Ejemplo:
Pag. 606
APNDICE
En el ejemplo siguiente usaremos distintos cadenas de texto para dar formato a un nmero ingresado por teclado. Debemos tener en cuenta que: Para poner completar con ceros la parte decimal debemos poner tantos 0 como dgitos decimales queremos que tenga nuestro nmero en la cadena de formato. Si queremos que un nmero que no tiene parte decimal muestre un 0antes del separador decimal debemos poner un 0 en esa posicin en nuestra cadena de formato.
public static void main(java.lang.String[] args) { double n; String s; DecimalFormat f; System.out.print("Ingresa nmero 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
APNDICE
En el siguiente ejemplo utilizamos la clase DecimalFormatSymbols, y reemplazamos el smbolo de separacin decimal por | y el separador de grupos por ^ asimismo los grupos los hacemos de 4 dgitos (en vez de 3 como es regularmente) y por ltimo, reemplazamos el smbolo que representa nmeros negativos (-) por n
public static void main(java.lang.String[] args) { double n; String s; DecimalFormat f; System.out.print("Ingresa nmero a dar formato : "); n = Lectura.leerDouble(); //Ahora modificamos los smbolos usados como separadores decimales //y de millares, asi como el smbolo 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 smbolos : " + s); }
Pag. 608
APNDICE
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(ao), MONTH(mes), DAY(da), HOUR(hora), y as sucesivamente. Subclases de la clase calendario interpretan una fecha de acuerdo con las reglas especficas de un calendario determinado. Esta plataforma implementa una subclase concreta: GregorianCalendar. Futuras subclases podran 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 mtodo getInstance( ): Calendar cal = Calendar.getInstance(); Los campos de un objeto calendario pueden ser manipulados usando 3 mtodos: set() // cambiamos los campos YEAR, MONTH y DATE del calendario cal // a los valores dados en ao, mes y da. cal.set (ao, mes, da) ; // cambiamos el valor del campo YEAR del calendario cal // al valor guardado en ao cal.set (cal.YEAR,ao) ; // cambiamos los campos YEAR, MONTH , DATE, HOUR y MINUTE // del calendario cal a los valores dados en ao, mes, etc. cal.set (ao, mes, da, hora, minuto) ;
Pag. 609
APNDICE
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 sera 3:10 a // diferencia del mtodo add ( ) que nos dara 4:10.. cal.roll(cal.HOUR, 40) // si la hora actual fuera 3:30, la nueva hora sera 3:10 a diferencia del // mtodo add ( ) que nos dara 4:10.
Sumario de campos
static int static int static int static int static int static int static int static int static int AM Constante que representa el campo AM AM_PM Constante que representa el campo AM_PM DATE Constante que representa la fecha del calendario actual (da) DAY_OF_MONTH Constante que representa el campo Da del mes DAY_OF_WEEK Constante que representa el campo Da de la semana DAY_OF_WEEK_IN_MONTH Constante que representa el campo Da del mes DAY_OF_YEAR Constante que representa el campo Da del ao ERA Constante que representa el campo AC/DC FIELD_COUNT Indica el nmero de campos que pueden ser usados por la instruccin get o set HOUR Constante que representa el campo hora Pag. 610
static int
APNDICE
static int static int static int
HOUR_OF_DAY Constante que representa el campo Hora del da JANUARY , FEBRUARY, MARCH , etc Constantes que representan a los meses que corresponden del ao. MILLISECOND Constante que representa el campo que indica los milisegundos de la hora actual MINUTE Constante que representa el campo que indica los minutos de la hora actual. MONDAY, TUESDAY, WEDNESDAY, etc Constantes que representan a los das que corresponden de la semana. MONTH Constante que representa el campo que indica el mes actual PM SECOND Constante que representa el campo Indica o establece los segundo de la hora actual UNDECIMBER indica el 13o mes del mes WEEK_OF_MONTH Constante que representa el campo Semana del mes WEEK_OF_YEAR Constante que representa el campo Semana del ao YEAR Constante que representa el campo Ao
static int static int static int static int static int
static int static int static int static int
Estas constantes nos sirven para especificar en los mtodos, que se detallan a continuacin, cuales son los campos que queremos manipular, por ejemplo, si queremos agregar un minuto al calendario actual debemos utilizar el mtodo add, este mtodo tiene como parmetros: int Campo, int Cantidad ; Entonces para agregar un minuto debemos especificarle al mtodo 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
APNDICE
Sumario de mtodos
abstract void boolean add(int Campo, int Cantidad) Date Arithmetic function. after(Object cuando) Compara los tiempos, si la fecha actual de nuestro calendario es superior a cuando, retorna verdadero before(Object cuando) Compara los tiempos,, si la fecha actual de nuestro calendario es inferior a cuando, retorna verdadero clear() limpia los valores de todos los campos del calendario clear(int campo) Limpia el valor del campo indicado equals(Object objeto) Compara este calendario con el objeto dado, y si son iguales retorna verdadero. get(int campo) Obtiene el valor almacenado en el campo dado. getActualMaximum(int campo) Retorna el valor mximo 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 mximo valor getActualMinimum(int campo) Retorna el valor mnimo que puede obtener este campo con la fecha del calendario actual. getFirstDayOfWeek() Obtiene el primer da de la semana. Por ejemplo SUNDAY (0) getInstance() Obtiene un calendario utilizando la zona actual y las reglas dadas getInstance(TimeZone zona) Obtiene un calendario utilizando zona y las reglas dadas getTime() Obtiene la hora actual del calendario. getTimeInMillis() Obtiene la hora actual del calendario en milisegundos getTimeZone() Obtiene la zona horaria. isSet(int campo) Pag. 612
boolean
void void boolean
int int
int
int static Calendar static Calendar Date long TimeZone
boolean
APNDICE
Determina si el campo dado tiene un valor almacenado. abstract void void void roll(int field, boolean up) Time Field Rolling function. roll(int field, int amount) set(int field, int value) setFirstDayOfWeek(int value) Establece cual es primer da de la semana para el calendario actual. Ej MONDAY setTime(Date fecha) Establece la hora del calendario actual a fecha setTimeInMillis(long milisegundos) Establece la hora del calendario actual utilizando los milisegundos dados setTimeZone(TimeZone value) Sets the time zone with the given time zone value. toString() Retorna una representacin de cadena del calendario actual
void void
void String
Pag. 613
APNDICE
Ejemplo:
Pag. 614
APNDICE
Pag. 615
APNDICE
Pag. 616
APNDICE
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 mayora 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 da cada 128 aos, y por lo tanto cada ao se haca ms notorio que la fecha de la Pascua de Resurreccin se atrasaba con respecto al equinoccio) y hacer coincidir el ao civil con el ao trpico. La tarea recay en una comisin, que dirigida por Cristbal Clavio que basndose en los clculos Luigi Lilio (el autntico artfice de la reforma), present el nuevo calendario al papa. Los clculos supusieron un da medio de 24 horas y un ao medio de 365 das, 5 horas, 49 minutos y 20 segundos (26 segundos ms que el ao real). Para ello se alternaran aos de 365 das, aos de 366 das. El calendario gregoriano intercala un ao bisiesto cada cuatro aos, pero no cuenta como bisiestos los aos seculares (los que terminan en doble cero: 1800, 1900, 2000), excepto cuando las dos primeras cifras son mltiplo de 4, como el 2000. Esta excepcin se produce porque con los clculos de Luigi Lilio se produce un error de un da 134 aos, o lo que es lo mismo 3 das cada 402 aos. Haba, pues, que suprimir tres das cada 402 aos. Como esta cifra est relativamente cerca de 400 se acord que no fuesen bisiestos los aos terminados en doble cero (100, 200 y 300) pero s el 400 y sus mltiplos. De esta manera se produce un error de slo un da cada 3323 aos. No obstante, si se suprimiese un ao bisiesto cada 128 aos, el error acumulado sera menor a un da cada 100.000 aos. El calendario se adopt en 1582 y como en los 1.257 aos de vigencia del calendario juliano se haban acumulado 10 das de retraso, se estableci que el da siguiente al 4 de octubre de 1582 fuese el 15 de octubre de 1582. El ao comienza el 1 de enero. El calendario gregoriano consta de doce meses: enero (31 das), febrero (28 29), marzo (31), abril (30), mayo (31), junio (30), julio (31), agosto (31), septiembre (30), octubre (31),
Pag. 617
APNDICE
noviembre (30) y diciembre (31); y de una semana de siete das: lunes, martes, mircoles, jueves, viernes, sbado y domingo; que es independiente del mes. Para el cmputo eclesistico el primer da de la semana es el domingo. Los das 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 montn de mtodos para operar con fechas en Java.
Ejemplo:
Pag. 618
APNDICE
Pag. 619
APNDICE
Pag. 620
APNDICE
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 patrn establecido. Los patrones que se utilizan son: Letra Significado G Era y Ao M Mes del ao w Semana del ao W Semana del mes D Da del ao d Da del mes F Da de la semana en el mes E Da de la semana a AM/PM H Hora del da (0-23) k Hora del da (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
APNDICE
Los pasos a seguir son: 1.- Creacin 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
BIBLIOGRAFA
Introduccin a las Tecnologas de Informacin. 1ra Edicin - 2004. FIA - USMP. Mtodo para la Solucin de Problemas Utilizando la Programacin Orientada A Objetos - Aspectos bsicos. 1ra Edicin - 2003. FIA - USMP. Metodologa de la Programacin. Algoritmos, Diagrama de flujo y programas 2da Edicin - 2003. Java, Manual de referencia. UML Gota a Gota. 1999. Como Programar en Java. 1998.
Jefferson Lpez Goycochea.
Juan Jos Flores Cueto .
Osvaldo Cair Battistutti. Patrick Naughton / Herbert Schildt.
Martn Fowler / Kendall Scott.
Deitel y Deitel.
Pag. 625
Pag. 626
NOTAS FINALES
Cualquier observacin, sugerencia o recomendacin relacionada al contenido del presente texto podr realizarla, envindome un correo electrnico a la siguiente direccin: jflores@usmp.edu.pe De antemano, agradezco cualquier contribucin que permita mejorar el material y contenido del presente libro.
Pag. 627
Pag. 628

Método 6'D UML pseudocódigo Java

Cargado por

Información del documento

Descripción original:

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Método 6'D UML pseudocódigo Java

Cargado por

Copyright:

Formatos disponibles

MTODO DE LAS 6D UML Pseudocdigo Java

UNIVERSIDAD DE S AN M ARTIN DE PORRES Facultad de Ingeniera y Arquitectura

MTODO DE LAS 6D UML Pseudocdigo - Java

Ing. Juan Jos Flores Cueto.

A mi madre adorada, por siempre.

Ing. Jos Antonio Chang Escobedo. RECTOR USMP.

Ing. Juan Jos Flores Cueto.

Temas: Introduccin. Mtodo de las 6D:

Marco de trabajo. Modelamiento. Algoritmo. Programacin.

MTODO DE LAS 6D Un Enfoque Algortmico.

Ing. Juan Jos Flores Cueto.

MTODO DE LAS 6D Un Enfoque Algortmico.

Ingeniera Reversa Etapa 04

Ing. Juan Jos Flores Cueto.

MTODO DE LAS 6D Un Enfoque Algortmico.

METODO 6D. Descripcin de la Etapa 02 Definicin de la Solucin: Etapa 02 Definicin de la Solucin

Ing. Juan Jos Flores Cueto.

METODO 6D. Descripcin de la Etapa 03 Diseo de la Solucin: Etapa 03 Diseo de la Solucin

MTODO DE LAS 6D Un Enfoque Algortmico.

METODO 6D. Descripcin de la Etapa 04 Desarrollo de la Solucin: Etapa 04 Desarrollo de la Solucin

Ing. Juan Jos Flores Cueto.

METODO 6D. Descripcin de la Etapa 05 Depuracin y Pruebas: Etapa 05 Depuracin y Pruebas

MTODO DE LAS 6D Un Enfoque Algortmico.

METODO 6D. Descripcin de la Etapa 06 Documentacin: Etapa 06 Documentacin

Ing. Juan Jos Flores Cueto.

MTODO DE LAS 6D Un Enfoque Algortmico.

RESUMEN DEL MTODO

Resumen de las etapas y los pasos del mtodo:

Etapa 01 Etapa 03 Diseo Solucin Desarrollo Solucin Depuracin Pruebas

Ing. Juan Jos Flores Cueto.

RESULTADO DE LAS ETAPAS DEL MTODO

Resultado de las etapas del Mtodo:

Etapa 01 Etapa 03 Diseo Solucin Desarrollo Solucin Depuracin Pruebas

MTODO DE LAS 6D Un Enfoque Algortmico.

ENUNCIADO Etapa 02 Definicin Solucin

Etapa 03 Diseo Solucin

Etapa 04 Desarrollo Solucin

Ing. Juan Jos Flores Cueto.

MTODO DE LAS 6D Un Enfoque Algortmico.

Nombre del paquete.

Ing. Juan Jos Flores Cueto.

Diagramas de Casos de Uso

MTODO DE LAS 6D Un Enfoque Algortmico.

Relacin de dependencia unidireccional.

Ing. Juan Jos Flores Cueto.

MTODO DE LAS 6D Un Enfoque Algortmico.

La clase Lectura se trata en el Captulo II y se especifica en el Apndice.

Ing. Juan Jos Flores Cueto.

MTODO DE LAS 6D Un Enfoque Algortmico.

Ing. Juan Jos Flores Cueto.

MTODO DE LAS 6D Un Enfoque Algortmico.

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

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

Ing. Juan Jos Flores Cueto.

Elementos o smbolos bsicos:

PROCESO Utilizado para asignar valores a variables y resultados de operaciones matemticas.

MTODO DE LAS 6D Un Enfoque Algortmico.

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

ESCRIBIR Hola ESCRIBIR x ESCRIBIR x + z

Ing. Juan Jos Flores Cueto.

Permite terminar la ejecucin de una estructura lgica de repeticin.

MTODO DE LAS 6D Un Enfoque Algortmico.