MODELO-DE-LAS-6D S - Flores Cueto Juan Jose

MÉTODO DE LAS 6’D
UML – Pseudocódigo – Java
(Enfoque algorítmico)
UNIVERSIDAD DE S AN M ARTIN DE PORRES
Facultad de Ingeniería y Arquitectura

UML – Pseudocódigo - Java
(Enfoque algorítmico)
Ing. Juan José Flores Cueto.
- 2005 -
A mi madre adorada,
por siempre.
“Lo que escucho, lo olvido.
Lo que veo, lo recuerdo.
Pero lo que hago, lo entiendo”
Confucio.
“Fallar no te convierte en un fracaso,

aceptar el fracaso y no querer volver
a intentarlo, si lo hace”
Richard Exley.
AGRADECIMIENTOS
Es importante destacar la participación de mis alumnos del curso de Algoritmo y Estructura de

Datos, integrantes del equipo de trabajo, formado para el desarrollo del presente libro. Este
libro no se hubiera terminado en tan corto tiempo, con la calidad y cantidad de problemas
desarrollados, sino hubiera sido por su valiosa colaboración y aporte. A todos ellos, mi
agradecimiento y mis sinceras felicitaciones por el trabajo realizado.
Equipo de trabajo:
• Isabel Rojas Vidal.
• Jorge Condezo Guerra.
• Roberto Pérez Huamaní.
• Ricky Vilcachagua Mosquera.
• Shugeily Pérez Campos.
• Boris Ortega Lescano.
Un agradecimiento especial a Isabel y a Jorge por participar desde el inicio hasta el

final del proyecto, por todo el tiempo y esfuerzo dedicado. Gracias Jorge por verificar
todos los programas desarrollados en Java.
Deseo también hacer extensivo mi agradecimiento a todos los docentes que contribuyeron en
el desarrollo del presente libro, a mi esposa Carmen por revisarlo y corregirlo, y a mi amigo
Omar por diseñar la carátula.
Finalmente, mi sincero agradecimiento a las autoridades de la Facultad de Ingeniería y

Arquitectura (FIA) de la Universidad de San Martín de Porres (USMP), en especial al Ing.
Raúl Bao García, Decano de la FIA, por todo el apoyo brindado durante el desarrollo del
presente libro.
ÍNDICE
PRESENTACIÓN.
INDICE.
PROLOGO.
PREFACIO.
CAPÍTULO I: Método de las 6’D. Un enfoque algorítmico.
Introducción ........................................................................................................ 25
Método de las 6’D ............................................................................................... 27
Etapas y pasos ...................................................................................... 28
Resumen del método ............................................................................. 35
Resultado de las etapas del método ...................................................... 36
Marco de trabajo ................................................................................................. 37
Modelamiento ..................................................................................................... 39
Algoritmo ............................................................................................................. 45
Programación ..................................................................................................... 54
CAPÍTULO II: Estructuras fundamentales para la solución de problemas.
Introducción ........................................................................................................ 61
Estructuras de datos.
Variables ................................................................................................ 63
Tipos de datos ....................................................................................... 66
Conversión de datos ……………………………………………………….. 71
Estructuras lógicas.
Estructuras lógicas de secuencia.
Estructuras para la salida de información ESCRIBIR .................. 75
Estructuras para la entrada de datos LEER ................................. 76
Estructuras para operaciones aritméticas y de cálculo ................ 78
Estructuras lógicas de decisión.
Estructuras lógicas de decisión simple SI .................................... 80
Estructuras lógicas de decisión doble SI / SINO .......................... 82
Estructuras lógicas de decisión simple CUANDO ........................ 84
Estructuras lógicas de repetición.
Estructuras lógica de repetición DESDE ...................................... 87
Estructuras lógica de repetición MIENTRAS ................................ 90
Estructuras lógica de repetición HACER ...................................... 93
Instrucciones de bifurcación .................................................................. 97
Mapa de estructuras lógicas detallado .................................................. 98
Método de las 6’D. Etapas y pasos ....................................................... 99
Problemas resueltos en general del 01 al 27 ........................................ 101
Manejo de excepciones ……………………………………………………………… 195
Problemas resueltos del 28 al 31 ………………………………………..... 198
Desarrollo de capacidades lógicas ..................................................................... 207
Problemas resueltos sobre figuras del 32 al 60 ..................................... 209
CAPÍTULO III: Clases básicas incorporadas en el lenguaje Java.
Introducción ........................................................................................................ 259

El paquete del lenguaje Java: java.lang ............................................................. 263
Envoltorios de tipos de datos primitivos: wrappers.
Introducción ........................................................................................... 267
Métodos ................................................................................................. 269
Problemas resueltos del 61 al 64 ........................................................... 278
Funciones matemáticas: Clase Math.
Introducción ........................................................................................... 281
Métodos ................................................................................................. 282
Problemas resueltos del 65 al 99 ........................................................... 287
Manejo de cadenas: Clase String.
Introducción ........................................................................................... 339
Métodos ................................................................................................. 340
Problemas resueltos del 100 al 130 ....................................................... 345
Otras clases en Java.
Problema resuelto 131 ........................................................................... 397
CAPÍTULO IV: Estructuras de datos arreglos.
Introducción ........................................................................................................ 401

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

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

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

técnicas de programación e ingeniería de software y este libro responde a esas demandas
introduciendo al estudiante en los conceptos de programación estructurada y en el dominio de
la programación orientada a objetos, poniendo énfasis en la solución de problemas y
empleando a fondo las capacidades lógicas para el desarrollo de soluciones utilizando una
computadora. A mi juicio, las características más importantes del texto se reflejan en su fácil
lectura y en su orientación al estudiante; pero mejor aun: en el hecho de haber sido probado
con los alumnos, comprobando su progreso y teniendo en cuenta la definición del problema,
una buena documentación y la planificación de soluciones por algoritmos.
Por lo arriba expresado y, por la amistad que me une a Juan José, es para mí sumamente
gratificante escribir estas apreciaciones sobre su segundo libro y le auguro nuevos aportes
como ingeniero y como docente de la USMP.
Ing. José Antonio Chang Escobedo.

RECTOR USMP.
PREFACIO
Actualmente, existe una tendencia creciente en el uso de herramientas de desarrollo de

software y lenguajes de programación orientados a objetos. También existen una serie de
métodos que permiten definir los pasos que se tienen que desarrollar para solucionar
problemas basados en una computadora. Estos pasos generalmente se desarrollan desde el
planteamiento del problema, análisis del problema, diseño de la solución, hasta la codificación
y prueba de la misma utilizando herramientas y lenguajes de programación.
En este libro se utiliza y se profundiza en el Método de las 6’D, a través del cual se definen
los pasos que se tienen que desarrollar para la solución de un problema utilizando una
computadora, agrupados en seis etapas (Descripción del problema, Definición de la solución,
Diseño de la solución, Desarrollo de la solución, Depuración y pruebas, y Documentación).
Todos los nombres de las etapas del Método de las 6’D comienzan con la letra D (de ahí el
nombre de método).
Los conceptos y temas fundamentales, necesarios para el desarrollo de soluciones utilizando

el Método de las 6’D y el desarrollo de sus capacidades lógicas, son tratados durante el
desarrollo de los cinco capítulos que forman parte del presente libro.
Capítulo I:
Se desarrolla la parte teórico formal del método de las 6’D. Se describen

sus etapas, así como los pasos y los resultados que se deben esperar de
cada una de ellas. Es importante mencionar que, dependiendo de la
forma de solucionar los problemas, se van agregando, eliminando o
redefiniendo los pasos de algunas de las etapas del método. El método
de las 6’D es interactivo e incremental y se puede utilizar la Ingeniería
Reversa para actualizar los modelos a partir del código creado.
En este capítulo, también se tratan los conceptos fundamentales sobre

modelado y el lenguaje unificado de modelado UML, sobre Algoritmos y
las herramientas de diseño conocidas como Diagrama de Flujo y
Pseudocódigo, y sobre la programación utilizando el lenguaje de
programación orientado a objetos Java.
Capítulo II:
Se desarrolla la estructura de datos más simple: la variable, y se

complementa con el estudio de los tipos básicos de datos, la conversión
de datos y la forma cómo son utilizados por las herramientas tratadas en
el capítulo anterior.
En este capítulo, también se tratan las estructuras lógicas de secuencia,
las estructuras lógicas de decisión, las estructuras lógicas de repetición,
las instrucciones de bifurcación y el manejo de excepciones.
Las estructuras de datos, las estructuras lógicas y las instrucciones de

bifurcación son conceptos propios de la programación estructurada y son
utilizadas por la programación orientada a objetos para la codificación de
los métodos que forman parte de las clases. El manejo de excepciones
es un concepto propio de la programación orientada a objetos y ofrece
una forma de codificar programas con una mayor claridad y sencillez,
separando explícitamente el código que maneja los errores del código
básico de la aplicación.
Se presentan 31 problemas desarrollados utilizando el método de las

6’D, problemas que se van complicando conforme se tratan y explican
los conceptos fundamentales.
También se presentan 30 problemas desarrollados sobre diferentes tipos

de figuras geométricas, con la finalidad de mejorar el desarrollo de sus
capacidades lógicas. Es importante que se analicen cada una de las
soluciones, se intenten mejorarlas y se desarrollen cada uno de los
problemas propuestos incluyendo las variaciones planteadas.
Capítulo III:
Se desarrollan los conceptos fundamentales sobre las clases básicas

incorporadas en el paquete java.lang del lenguaje de programación Java.
Se tratan los conceptos fundamentales sobre el paquete del lenguaje, el
paquete java.lang, las clases wrappers (envoltorios), la clase Math y la
clase String.
Las clases Wrappers, son un complemento de los tipos de datos

primitivos y proporcionan métodos para realizar diferentes tareas con los
tipos de datos primitivos, tales como la conversión con cadenas de
caracteres, comprobación, traslación, entre otras. Se presentan 5
problemas codificados en Java para mejorar la comprensión del tema.
La clase Math, proporciona métodos y atributos para implementar

diversas funciones matemáticas. La clase Math contiene métodos de
cálculo básico como exponencial, logaritmo, raíz cuadrada y funciones
trigonométricas. Se presentan 35 problemas codificados en Java para
mejorar la comprensión del tema.
La clase String, permite declarar y manipular variables de tipo texto o

cadena (en realidad no se declaran variables de tipo texto o cadena, sino
que se crean objetos de la clase String). La clase String contiene
métodos que permiten examinar los caracteres de una cadena para
compararlos, ubicarlos, extraerlos como subcadenas, crear copias de
una cadena convirtiendo todos sus caracteres a letra mayúscula o
minúscula, entre otras. Se presentan 30 problemas codificados en Java
para mejorar la comprensión del tema.
También se hace una referencia a otras clases en Java que el lector

puede explorar. En el apéndice se incluyen otras clases Java, tales como
las clases DecimalFomat, Calendar, GregorianCalendar y
SimpleDateFormat.
Capítulo IV:
Se desarrolla la estructura de datos conocida como arreglos (arrays), su

definición, tipos, representación gráfica, declaración, creación y su
inicialización.
En base al marco teórico se desarrollan soluciones para el ingreso,

visualización y cálculo de datos contenido en los arreglos, formalizando
el método de las 6’D para el adecuado manejo de los mismos. Se
presentan 14 problemas desarrollados, utilizando el método de las 6’D
para mejorar la comprensión del tema.
Finalmente, se presentan los conceptos fundamentales sobre el manejo

de arreglos múltiples (arreglos en paralelos) y se desarrollan 5
problemas utilizando el método de las 6’D.
Capítulo V:
Se desarrolla una introducción al desarrollo de soluciones orientadas a

objetos. Se tratan los conceptos básicos fundamentales sobre las clases,
objetos, atributos, métodos y ocultamiento de atributos de instancia.
Conforme se presenta cada uno de los conceptos mencionados, se va

modificando un proyecto desarrollado en Java para que se pueda
analizar como se utiliza el concepto tratado en un lenguaje de
programación orientado a objetos.
Al final de este capítulo, se formaliza el método de las 6’D, redefiniendo

algunos de sus pasos para poder ajustar el método a este tipo de
soluciones.
Es importante comentar que el presente capítulo, fue el primero en ser

desarrollado. A pesar de ello, se consideró no incluirlo en el presente
texto, pero faltando unos días para la entrega oficial de todo el material
que conformaba el presente libro fue incluido. Finalmente, considero una
buena decisión que se incluyera el presente capítulo. Estoy seguro que
el lector estará de acuerdo conmigo.
Como se puede apreciar, se profundiza en el Método de las 6’D. Es importante comprender
que se puede extender el uso del método a otros temas y a problemas con soluciones mucho
más complicadas. Sólo se tendrá que redefinir algunos de los pasos de las etapas
especificadas en el método. Por otro lado, también se tratan conceptos de la programación
estructurada y fundamentos de programación orientada a objetos, los cuales permiten sentar
las bases modernas para la programación, necesarias para el desarrollo de soluciones
utilizando una computadora.
Los temas desarrollados a través de los 5 capítulos que forman parte de esta obra, pueden
ser utilizados de diferente manera de acuerdo a la experiencia de cada persona. Es
importante indicar que el lector tendrá un mejor entendimiento del método empleado en la
solución de los problemas y de todos los conceptos tratados, conforme avance con el
entendimiento de los problemas resueltos y el desarrollo de los problemas propuestos.

Capítulo
1
Un Enfoque Algorítmico
Temas:
Introducción.
Método de las 6’D:

• Etapas y pasos.
• Resumen del método.
• Resultado de las etapas del método.
Marco de trabajo.
Modelamiento.
Algoritmo.
Programación.
MÉTODO DE LAS 6’D – Un Enfoque Algorítmico.
CAPÍTULO I

Un Enfoque Algorítmico
INTRODUCCIÓN
Durante el transcurso de nuestra vida nos enfrentamos a diversos problemas.

Algunos de ellos podemos solucionarlos fácilmente, mientras que otros se
complican de tal forma que nos afectan de una manera muy profunda.
Algunos problemas, por su naturaleza, pueden ser resueltos utilizando una

computadora. Estos problemas generalmente son de tipo estructurado, es decir,
tienen una solución determinada y pueden ser desde muy sencillos hasta muy
complejos.
Para resolver problemas estructurados utilizando la computadora es importante

utilizar un método. Este método debe ser fácil de comprender y nos debe guiar
paso a paso hasta la solución del problema.
El método propuesto y utilizado en el presente texto es el Método de las 6’D,

que está compuesto de seis etapas, cada una de las cuales consta de una serie
de pasos, los cuales se van modificando (ajustando) dependiendo del grado de
complejidad del problema y las herramientas que se utilicen para su solución.
Con la finalidad de recordar el método, se ha definido que el nombre de cada una

de las etapas del método comience con la misma letra, la letra “D”. Es decir, el
método tiene seis etapas y el nombre de cada una de las etapas comienza con la
letra “D”, de modo que este se pueda recordar como el Método de las 6’D.
Pag. 25
Pag. 26
En la siguiente figura se muestra el Método de las 6’D con sus respectivas

etapas:
Etapa 01
Descripción
Problema
Etapa 02
Definición
Solución n veces
Etapa 03
Ingeniería Reversa
Diseño
Solución
Etapa 04
Desarrollo
Solución
Etapa 05
Depuración
Pruebas
Etapa 06
Document.
Pag. 27
ETAPAS Y PASOS
METODO 6’D.
Descripción de la Etapa 01 – “Descripción del Problema”:
Etapa 01 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
Descripción una tarea agotadora ya que generalmente existen
del Problema muchas opiniones de cual es el problema central.
Identificarlo es una de las tareas más importante que
los analistas deben afrontar.
Identificado el problema es necesario poder

comprenderlo en su totalidad, es decir, comprender qué
es exactamente lo que se desea que se resuelva.
Finalmente se deberá escribir un enunciado claro,
concreto y conciso del problema a resolver.
PASOS:
Identificación del problema.

Descripción general del problema.
Enunciado claro y preciso del problema.
ENUNCIADO
El resultado obtenido en esta etapa es un enunciado claro del problema que se desea
solucionar.
Pag. 28
METODO 6’D.
Descripción de la Etapa 02 – “Definición de la Solución”:
Etapa 02 En esta etapa, es necesario estudiar a fondo el

problema para poder solucionarlo, saber exactamente
en qué consiste y poder descomponerlo en cada una
Definición de de sus partes para facilitar su comprensión y posterior
la Solución solución. Esta es una regla que siempre deberá ser
aplicada se utilice o no una computadora en la solución
de un problema.
Una vez entendido el problema, se está en condiciones

de estudiarlo a fondo y plantear diversas alternativas
que permitan solucionar el problema, para finalmente,
seleccionar la alternativa mas adecuada.
PASOS:
Definir el resultado deseado.

Determinar los datos que se deben ingresar o
generar para obtener el resultado deseado.
Determinar la forma en que los datos serán
procesados para transformarlos en
información.
ESPECIFICACIONES
El resultado obtenido en esta etapa son las especificaciones de lo que se debe hacer para
solucionar el problema.
Pag. 29
METODO 6’D.
Descripción de la Etapa 03 – “Diseño de la Solución”:
Etapa 03 Definida la solución, se procede a diseñar la lógica

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

Definición de diagramas, relaciones y clases.
Desarrollo de Algoritmos.
DIAGRAMAS Y
ALGORITMOS
El resultado obtenido en esta etapa son los diagramas y los algoritmos que especifican
cómo se debe hacer para solucionar el problema.
Pag. 30
METODO 6’D.
Descripción de la Etapa 04 – “Desarrollo de la Solución”:
Etapa 04 Una vez previstas todas las posibilidades y alternativas

que puedan presentarse y que pasen sin
inconvenientes por la clase y los algoritmos, se podrá
Desarrollo de proceder a la codificación del problema en algún
la Solución lenguaje de programación.
La codificación involucra traducir los diagramas, las

especificaciones de las clases (expresadas en notación
UML), y los pasos del algoritmo de cada método
(expresado en DF o pseudocódigo), en sentencias de
un lenguaje de programación determinado. Estas
sentencias son almacenadas en un proyecto (o archivo)
lógico, y constituyen lo que la computadora podrá
ejecutar.
PASOS:
Codificar el proyecto.
Desarrollar comentarios internos en los
programas de computadora.
Desarrollar copias de seguridad de los
PROGRAMAS
El resultado obtenido en esta etapa son los programas y/o clases, codificados en un
lenguaje de programación, que permiten solucionar el problema.
Pag. 31
METODO 6’D.
Descripción de la Etapa 05 – “Depuración y Pruebas”:
Etapa 05
Luego que se codifiquen los programas y/o clases,
deben ser probados mediante la ejecución de los
Depuración mismos (esto es conocido como corrida del programa).
y Pruebas Al realizarse ésta, pueden surgir diferentes tipos de
errores, siendo los errores de lógica y sintaxis los más
comunes.
Hay que corregir el programa; anular, modificar o crear

nuevas sentencias, volver a probar el programa y
continuar con la corrección y pruebas hasta conseguir
el resultado deseado.
PASOS:
Realizar la depuración y verificar la correcta
escritura de los programas.
Realizar pruebas de sintaxis.
Realizar pruebas de lógica.
PRUEBAS
El resultado obtenido en esta etapa son las pruebas que registran el adecuado
funcionamiento de la solución del problema.
Pag. 32
METODO 6’D.
Descripción de la Etapa 06 – “Documentación”:
Etapa 06 En esta etapa se recopila toda la documentación

generada en las etapas anteriores, la cual va a servir
como base para la elaboración del manual técnico.
Documentación
Dedicarle tiempo a esta etapa nos ayudará a
desarrollar buenos hábitos, los cuales serán necesarios
cuando se desarrolle software en forma profesional.
El manual técnico debe incluir, como mínimo:

- Descripción del problema.
- Resultados esperados y datos necesarios para generar dichos
resultados.
- Diagramas UML, DF y/o Pseudocódigo.
- Pruebas desarrolladas.
- Listado de programas con comentarios internos.
PASOS:
Recopilar el material generado en cada una
de las etapas anteriores.
Generar el manual del programa.
Generar el manual del usuario.
Manuales
El resultado obtenido en esta etapa son los manuales que permiten un adecuado manejo de
la solución desarrollada.
Pag. 33
METODO 6’D.
Adicionalmente es posible realizar “Ingeniería Reversa” entre las Etapas 03, 04 y 05:
La ingeniería reversa nos permite crear o

Ingeniería Reversa actualizar el modelo preliminar realizado en la
ETAPA 03 “Diseño de la solución” a partir del
código del programa realizado en la ETAPA 04
“Desarrollo de la solución” y corregido en la
n veces ETAPA 05 “Depuración y pruebas”.
Es decir, a través de la Ingeniería Reversa es

Etapa 03 posible programar o codificar algunas partes
(hasta su correcto funcionamiento) que no
estén especificadas en la Etapa 03 “Diseño de
Diseño
la Solución”. A partir de esta solución se
Solución Etapa 04 actualizan los diagramas de la Etapa 03 y se
continúa con el proceso hasta llegar a la
solución deseada.
Desarrollo
Solución
Etapa 05 PASOS:
• Exportar proyecto (archivos class o
Depuración java) al disco de la PC, si está
Pruebas trabajando con un IDE.
• Importar proyecto (archivos class o
java) a una herramienta CASE y
realizar la ingeniería reversa.
• Organizar el modelo obtenido en la
herramienta CASE.
DIAGRAMAS
ACTUALIZADOS
Pag. 34
RESUMEN DEL MÉTODO
METODO 6’D.
Resumen de las etapas y los pasos del método:
Etapa 01 Etapa 02 Etapa 03 Etapa 04 Etapa 05 Etapa 06
Descripción Definición Diseño Desarrollo Depuración Document.

Problema Solución Solución Solución Pruebas
Identificación Definir el resultado Definir un Codificar el Realizar la Recopilar el

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

Problema Solución Solución Solución Pruebas
DIAGRAMAS Y
ENUNCIADO ESPECIFICACIONES PROGRAMAS PRUEBAS
ALGORITMOS
Manuales
Pag. 36
MARCO DE TRABAJO
En el presente texto se solucionarán problemas sencillos utilizando el

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

capítulo V del presente texto, se solucionan los problemas utilizando el marco de
trabajo especificado, mientras que en la segunda parte del capítulo II y el capítulo III,
solo se desarrolla la etapa 04 (“Desarrollo de la solución”), con la finalidad de resolver
una mayor cantidad de problemas y profundizar en la codificación utilizando el
lenguaje de programación Java.
Para poder solucionar problemas sencillos utilizando el Método de las 6’D, es

necesario conocer los conceptos fundamentales de modelamiento, algoritmo y
programación, y dominar el uso de las estructuras lógicas, instrucciones o
sentencias de bifurcación y las estructuras de datos. Este tipo de soluciones
son el objetivo del presente texto.
También es posible plantear soluciones más complejas utilizando el Método

de las 6’D. Para ello se tendría que dominar otros conceptos, tales como,
Objetos, Métodos, Encapsulamiento, Herencia, Polimorfismo, Interfaces
Gráficas, Conexión a Base de Datos, Servlets entre otros.
Es importante mencionar, que dependiendo de la complejidad del problema,

los pasos especificados en cada una de las etapas del método se pueden
redefinir (modificar). Esto significa, que dependiendo de la complejidad del
problema y de su solución, se puede plantear nuevos pasos y eliminar pasos
ya existentes en las diferentes etapas del método.
Pag. 38
MODELAMIENTO
El modelamiento se refiere a la forma como se representa la solución de un

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

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

todos los conceptos relacionados con el desarrollo de Software Orientado a
Objetos. Para nuestro propósito, se detallarán algunos conceptos básicos que
serán utilizados en las soluciones planteadas en el presente texto.
Paquete.- Los paquetes nos permiten organizar las clases de un modelo. Un

paquete contiene clases que tienen funciones similares. En UML, un paquete
se representa de la siguiente forma:
NombrePaquete Nombre del

paquete.
Clase.- Una clase, es simplemente, un modelo que se utiliza para describir

uno o más objetos del mismo tipo. En su forma más sencilla, una clase es un
conjunto de atributos y métodos. Una clase es una abstracción y no
Pag. 39
representa a ningún objeto en particular. En UML, una clase se representa de

la siguiente forma:
NombreClase Nombre de la clase y

(NombrePaquete del paquete al cual
al que pertenece) pertenece la clase.
Atributos Lista de atributos de la

clase.
Métodos Lista de métodos de la
clase.
Objeto.- Un objeto es cualquier cosa, real o abstracta, acerca de la cual

almacenamos datos y los métodos que controlan y manipulan dichos datos.
Un objeto se crea o instancia a partir de una clase, En UML, un objeto se
representa de la siguiente forma:
NombreClase : Nombre de la clase a la cual

nombreObjeto 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 continuación:
Diagramas de
Clase
Diagramas de
Paquete Diagramas de
Casos de Uso
Diagramas de Objeto
Secuencia
Diagramas de Diagramas de
Colaboración Componentes
Modelo
Diagramas de Diagramas de
Estado Distribución
Diagramas de
Actividad
Pag. 40
Para nuestro propósito, se detallará el diagrama de paquetes que será

utilizado en las soluciones planteadas en el presente texto.
Diagrama de paquetes.- Un diagrama de paquetes permite especificar y

visualizar las relaciones de dependencia que existe entre los paquetes que
forman parte de una solución. Una relación de dependencia entre dos o más
paquetes se establece cuando las clases que pertenecen a un paquete
pueden tener acceso a todas o a algunas de las clases que pertenecen a otro
paquete (dependencia unidireccional). También se puede establecer una
relación de dependencia bidireccional cuando las clases que pertenecen a un
paquete pueden tener acceso a todas o a algunas de las clases que
pertenecen a otro paquete y viceversa. En UML, una relación de dependencia
unidireccional entre dos paquetes se gráfica de la siguiente manera:
Relación de dependencia
unidireccional.
La dependencia en este caso significa que todas las clases que pertenecen
al paquete “dominioDeLaAplicacion” podrán tener acceso a todas o algunas
de las clases que pertenecen al paquete “biblioteca” (observe el sentido de la
flecha que marca la dependencia unidireccional).
Pag. 41
En el Método de las 6’D, el modelamiento de una solución se desarrolla

durante la Etapa 03 - “Diseño de la solución”:
Etapa 03
Diseño
Solución
Se desarrollan los siguientes pasos:
Definir un nombre para el proyecto.

La definición del nombre del proyecto, permite agrupar a todos los
elementos que serán parte de la solución del problema utilizando el
método planteado. El nombre del proyecto comenzará con las letras “Proy”
(abreviatura de proyecto), seguido de un nombre que identifique al
proyecto. Este nombre debe ser seleccionado adecuadamente.
Definición de diagramas, relaciones y clases.

En este paso se desarrollará el diagrama de paquetes y se especificará la
relación de dependencia entre los paquetes utilizando UML. Para nuestros
fines se crearán dos paquetes en las soluciones. Uno de ellos lo se
llamará “dominioDeLaAplicación” y el otro “biblioteca”, y se establecerá
una relación de dependencia unidireccional del primero hacia el segundo.
En el paquete “dominioDeLaAplicacion”, se definirá la clase que permitirá

solucionar el problema planteado utilizando UML. El nombre de la clase
comenzará con las letras “Prg” (abreviatura de programa), seguido de un
nombre que identifique a la clase. Este nombre debe ser seleccionado
adecuadamente. Dicha clase no tendrá ningún atributo definido y solo se
definirá un método (el método principal).
Pag. 42
En el paquete “biblioteca”, se tendrá clase Lectura1 que facilitará el ingreso

de los datos a la computadora.
Regla general para especificar los nombres de los paquetes, clases,

atributos y métodos:
El nombre de la clase y el nombre del paquete deben comenzar con una letra
mayúscula y el resto en minúscula. Si el nombre es compuesto, todas las
primeras letras de los nombres simples que forman el nombre de la clase o
paquete deberán comenzar con mayúscula.
Los nombres de los atributos se escriben en minúscula. En caso que el nombre
sea compuesto, a partir de la segunda palabra se escribe la primera letra en
mayúscula.
Los nombres de los métodos cumplen las mismas características que los
nombres de atributos a excepción de los métodos constructores.
1
La clase Lectura se trata en el Capítulo II y se especifica en el Apéndice.
Pag. 43
Pag. 44
ALGORITMO
Una clase, en su forma más simple, está constituida por atributos y métodos.
Los métodos representan pequeños subprogramas encapsulados dentro de
las clases y contribuyen a definir el comportamiento típico de los objetos.
Para especificar cuáles son los pasos desarrollados en un determinado

método y cuáles son los datos que manejan dichos pasos se desarrollan los
algoritmos.
Un algoritmo constituye una lista completa de los pasos y una descripción de

los datos que son necesarios para resolver un determinado problema en el
ámbito de un método.
De esto, se deriva que un algoritmo se desarrolla para un determinado

método y que su definición tiene dos partes esenciales:
Una lista de pasos que deben ser ejecutados.
Una descripción de los datos que son manipulados por estos

pasos.
CARACTERÍSTICAS
Descripción de los pasos que deben ser ejecutados (estructuras

lógicas).
Descripción de los datos que son manipulados por estos pasos

(estructuras de datos).
Un algoritmo debe ser preciso, indicando el orden de realización

de cada paso.
Todo algoritmo debe ser finito. Si se sigue un algoritmo, éste

debe terminar en algún momento.
Un algoritmo debe estar definido. Si se sigue un algoritmo dos

veces, se debe obtener el mismo resultado.
Un algoritmo puede o no tener datos de entrada.
Un algoritmo producirá uno o más datos de salida.
Pag. 45
Los datos de entrada y salida deben almacenarse en estructuras

de datos.
El resultado que se obtenga debe satisfacer los requerimientos

de la persona interesada (efectividad).
Debe ser estructurado. Es decir, debe ser fácil de leer, entender,

usar y cambiar si es preciso.
En conclusión, los algoritmos permiten especificar la lógica de desarrollo de

los métodos que conforman una clase. Por lo tanto, se debe entender la
importancia de estudiar los “algoritmos” para comprender como se está
solucionando un determinado problema.
Se dispone de diversas herramientas para desarrollar los algoritmos para los

métodos de las clases. Entre dichas herramientas se puede mencionar al
pseudocódigo y al diagrama de flujo.
HERRAMIENTAS
PSEUDOCODIGO
Un pseudocódigo permite expresar un algoritmo con palabras en castellano
que son semejantes a las sentencias de un lenguaje de programación.
Pautas básicas:
Todo algoritmo debe tener un nombre, el cual deberá comenzar con una
letra mayúscula. Si es un nombre compuesto, la primera letra de cada
palabra simple deberá estar en mayúscula. No se permiten los espacios
en blanco en el nombre del algoritmo (generalmente se utilizará el
nombre de la clase y el nombre del método para referirse a un
determinado algoritmo).
Es necesario que se determinen los datos de entrada y la información de
salida.
Para declarar una variable “x” se deberá determinar qué tipo de dato se
almacenará. Por ejemplo. Si se desea declarar una variable de tipo texto
se realizaría de la siguiente manera: TEXTO x.
Para asignar un valor a una variable “x” se utiliza el signo igual. Por
ejemplo, si se desea asignar 5 a la variable “x” se realizará de la siguiente
manera: x = 5.
Pag. 46
Para indicar que la computadora lea un valor desde un dispositivo externo

y lo almacene en la variable “z”, se utiliza: LEER z.
Para indicar que la computadora escriba hacia un dispositivo externo:
Para escribir un mensaje (observe que el mensaje está entre
comillas) se utiliza: ESCRIBIR “hola”.
Para escribir el valor de una variable (observe que la variable no
está entre comillas) se utiliza: ESCRIBIR x.
Para escribir el resultado de una expresión (observe que la
expresión no está entre comillas) se utiliza: ESCRIBIR x + 2.
Estructura básica de un pseudocódigo:
Algoritmo NombreClase – nombreMetodo()
ENTRADA:
SALIDA: En ENTRADA y SALIDA se
especifican las variables
que se usarán en el
INICIO desarrollo del algoritmo.
…
… Este es el cuerpo del
… algoritmo expresado en
pseudocódigo. Las
… instrucciones se colocan
FIN entre INICIO... FIN.
DIAGRAMA DE FLUJO
Un Diagrama de Flujo permite ilustrar la secuencia de pasos de un algoritmo

por medio de símbolos especializados y líneas de flujo. La combinación de
símbolos especializados y líneas de flujo describe la lógica para la solución
del problema (algoritmo). Entonces, se puede afirmar que el Diagrama de
Flujo es la representación gráfica de un algoritmo.
FLUJO
Porque muestra la secuencia de lo
que se tiene que realizar.
DIAGRAMA
Por el hecho de ser un dibujo que
no requiere estar a escala.
Pag. 47
Elementos o símbolos básicos:
PROCESO
Utilizado para asignar valores a variables y resultados
de operaciones matemáticas.
ENTRADA / SALIDA
Utilizado para ingresar datos y visualizar la
información que resulta del procesamiento.
INICIO / FIN
Este símbolo permite marcar el inicio y el final del
algoritmo.
CONECTOR
Este símbolo permite que no se crucen los flujos
(líneas) en un diagrama.
FLUJOS (LINEAS)
Líneas que permiten unir los diagramas y mostrar la
secuencia lógica a la solución del problema.
Pag. 48
REGLAS UTILIZADAS POR LAS HERRAMIENTAS
Con la finalidad de comprender mejor el diseño de los algoritmos,

desarrollados en pseudocódigo y diagrama de flujo, se han clasificado en 6
grupos las reglas definidas.
REGLA FORMATO DESCRIPCIÓN
GRUPO 1
Utilizada para el ingreso de datos. El dato

LEER LEER x
ingresado se almacena en la variable
especificada.
Utilizada para la salida de información.

ESCRIBIR “Hola”
Se puede visualizar una cadena, el
ESCRIBIR ESCRIBIR x
contenido de una variable o el resultado
ESCRIBIR x + z
de una operación matemática.
Utilizada para realizar comentarios

COMENTARIO COMENTARIO “Variables” internos en la codificación de las
soluciones.
Permite declarar una variable de tipo

NUMERO NUMERO x
numérico.

TEXTO TEXTO mensaje
texto o cadena.
Permite declarar a una variable de tipo

CARACTER CARACTER letra
texto o cadena de una sola letra.

LÓGICO LÓGICO aprobado
lógico.
Permite asignar el valor VERDADERO a

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

FALSO aprobado = FALSO
variable lógica.
GRUPO 2
SI (condición) Permite especificar una estructura de

ENTONCES decisión simple “SI... FINSI”. Las
SI
instrucciones... estructuras lógicas serán tratadas en el
FINSI capítulo II.
Pag. 49
SI (condición)
ENTONCES Permite especificar una estructura de
instrucciones... decisión doble “SI... SINO... FINSI”. Las
SI / SINO
SINO estructuras lógicas serán tratadas en el
instrucciones... capítulo II.
FINSI
CUANDO (variable) SEA Permite especificar una estructura de

CASO (valor 1) : decisión múltiple “CUANDO...
instrucciones... FINCUANDO”.
CASO (valor 2) : Las estructuras lógicas serán tratadas en

CUANDO
instrucciones... el capítulo II.
CASO (valor n) :
instrucciones...
OTROS
instrucciones..
FINCUANDO
DESDE i = valorInicial
HASTA valorFinal
instrucción 1 Permite especificar una estructura de
. repetición “DESDE... FINDESDE”. Las
DESDE
. estructuras lógicas serán tratadas en el
. capítulo II.
instrucción n
FINDESDE
MIENTRAS (condición)
instrucción 1
Permite especificar una estructura de
.
repetición “MIENTRAS...FINMIENTRAS”.
MIENTRAS .
Las estructuras lógicas serán tratadas en
.
el capítulo II.
instrucción n
FINMIENTRAS
HACER
instrucción 1
Permite especificar una estructura de
.
repetición “HACER...FINHACER”. Las
HACER .
estructuras lógicas serán tratadas en el
.
capítulo II.
instrucción n
Permite terminar la ejecución de una

TERMINAR TERMINAR estructura lógica de repetición.
Permite volver a ejecutar una estructura

lógica de repetición sin finalizar todas las
CONTINUAR CONTINUAR
instrucciones que forman parte de la
misma.
Pag. 50
GRUPO 3
Permite obtener el coseno del valor

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

SENO x = SENO n almacenado en la variable “n”. El
Ver capítulo III.
Permite obtener la longitud de la cadena

almacenada en la variable “n” o la
LONGITUD x = LONGITUD n longitud del vector “n”. El resultado se
almacena en la variable “x”.
Ver capítulo III y capítulo IV.
Permite obtener el número de filas de

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

COLUMNA x = COLUMNA n de una matriz “n”. El resultado se
almacena en la variable “x”.
Permite cambiar a mayúscula la cadena

MAYÚSCULA x = MAYÚSCULA n almacenada en la variable “n”. El
Ver capítulo III.
Permite cambiar a minúscula la cadena
almacenada en la variable “n”. El
MINUSCULA x = MINUSCULA n
Ver capítulo III.
GRUPO 4
Permite obtener el resto de la división

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

DIVIDIR x = z DIVIDIR n división de las variables “z” y “n”. El
Permite obtener la raíz “n” del número

RAIZ x = z RAIZ n “z”. El resultado se almacena en la
variable “x”.
Pag. 51
Permite obtener la potencia “n” del

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

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

valor almacenado en la variable “n” y la
MINIMO x = z MINIMO n
variable “z”. El resultado se almacena en
Permite obtener el carácter ubicado en la

CARACTER x = z CARACTER n posición “n” de la cadena “z”. El resultado
Permite obtener un número cualquiera

(aleatorio) entre los valores de “n” y “z”.
ALEATORIO x = z ALEATORIO n
El resultado se almacena en la variable
“x”.
GRUPO 5
Permite obtener una subcadena

comprendida entre las posiciones
SUBCADENA x = z SUBCADENA n1, n2 especificadas por “n1” y “n2” de la
cadena “z”. El resultado se almacena en
Permite eliminar los espacios existentes

ELIMINAESPACIO x = z ELIMINAESPACIO n1, n2 en una cadena entre las posiciones
especificadas por “n1” y “n2”. El resultado
GRUPO 6
Utilizada para crear arreglos previamente

CREAR vector[n] declarados. Un arreglo permite
CREAR almacenar más de un dato del mismo
CREAR matriz[n1][n2] tipo. Los arreglos serán tratados en el
capítulo IV.
Permite crear un objeto de una

CREAR CREAR objeto
determinada clase
EJECUTAR EJECUTAR algoritmo Permite ejecutar otro algoritmo.
Pag. 52
Permite especificar si un algoritmo recibe

PARAMETRO PARAMETRO listaVariables
datos o valores.
Permite especificar si un algoritmo

RETORNAR RETORNAR variable
retorna una respuesta.
En el Método de las 6’D, el algoritmo de una solución se desarrolla después

del modelamiento, durante la Etapa 03 - “Diseño de la solución”:
Etapa 03
Diseño
Solución
Se desarrollará el siguiente paso:
Desarrollo de algoritmos.
En este paso, se desarrollará el algoritmo para el método especificado en
la clase, la cual forma parte del paquete “dominioDeLaAplicación”. Para el
desarrollo del algoritmo se utilizará pseudocódigo.
Pag. 53
PROGRAMACIÓN
La programación es la traducción del modelamiento y los algoritmos en

sentencias que la computadora puede comprender y ejecutar. En términos
sencillos. Se puede decir, que la programación es la acción de escribir
programas para una computadora, utilizando alguno de los lenguajes de
programación existentes. La acción de escribir programas para una
computadora se conoce como codificación.
Las personas que escriben los programas son conocidas como

programadores, los cuales están divididos en categorías según su experiencia
y dominio de diferentes lenguajes de programación.
Entonces, un lenguaje de programación es un lenguaje que los

programadores utilizan para escribir programas que son comprendidos y
ejecutados en una computadora.
Nos “comunicamos” con las computadoras a través de los programas

desarrollados en un lenguaje de programación en particular. Existen
diferentes lenguajes de programación, la mayor parte de los cuales tienen
un conjunto de reglas o sentencias muy especializadas.
La forma de programación ha variado con el paso de los años. Al inicio, se

desarrolló la programación lineal, luego la programación modular, después la
programación estructurada y ahora la programación orientada a objetos.
Entre los lenguajes de programación orientados a objetos podemos destacar

a Java.
LENGUAJES DE PROGRAMACIÓN
JAVA
Java es un lenguaje de programación orientado a objetos desarrollado por

Sun MicroSystems, una compañía reconocida por sus estaciones de trabajo
UNIX de alta calidad.
Pag. 54
Fundamentado en el lenguaje de programación C++, el lenguaje Java se

diseñó para ser pequeño, sencillo y portátil a través de plataformas y
sistemas operativos, tanto a nivel de código fuente como binario, lo que
significa que los programas Java (applets, aplicaciones y servlets), pueden
ejecutarse en cualquier computadora que tenga instalada una máquina virtual
de Java.
A pesar que Java es un lenguaje de programación orientado a objetos,

también puede ser utilizado como un lenguaje estructurado, lo cual se hace
necesario para poder iniciar el estudio de los conceptos fundamentales de
programación.
Estructura básica de un programa desarrollado en Java:
package NombrePaquete;
class NombreClase {
public static void main ( String arg[ ] ) {
… Este es el cuerpo del

sentencias; programa en Java. Las
… sentencias se colocan
dentro de los corchetes
del método main ( ).
}
}
En el lenguaje de programación Java, para definir que una clase forma

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

siguiente palabra reservada:
class
Pag. 55
Es importante comprender que una clase está constituida por atributos y

métodos. Todo el código ejecutable reside dentro de los métodos de la
clase. No existe código que no esté contenido dentro de un método (a
excepción de los bloques estáticos).
Existen clases que tienen un método especial conocido como “método

principal”. Todas las clases que tienen especificado un “método principal”,
son clases que pueden ejecutarse.
En el lenguaje de programación Java, para especificar que una clase tiene

un “método principal”, se utiliza las siguientes sentencias:
public static void main (String arg[])
Por lo tanto, en el lenguaje de programación Java, el método principal es

conocido como método main ( ).
Palabras reservadas en Java:
Una palabra reservada o palabra clave, es aquella que tiene un significado

especial para un lenguaje de programación. Todos los lenguajes tienen
palabras claves. En el caso de Java tenemos las siguientes:
Palabras reservadas en Java

abstract boolean catch
byte case do
char class extends
continue default float
double else if
final finally instanceof
for import long
implements interface null
int new protected
native private short
package return super
public strictfp this
static synchronized transient
switch throws volatile
throw void
try widefp
while break
Pag. 56
En la actualidad, la Programación Estructurada (PE) y la Programación

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

durante la Etapa 04 - “Desarrollo de la solución”:
Etapa 04
Desarrollo
Solución
Se desarrollará solo el primer paso:
Codificar el proyecto.
En este paso, se desarrollará la codificación del proyecto. Es decir,
utilizando el lenguaje de programación Java, se traducirá lo especificado
en el modelamiento y en los algoritmos, en sentencias que la computadora
pueda comprender y ejecutar.
Pag. 57
Pag. 58
Capítulo
2
Estructuras Fundamentales para la
Solución de Problemas
Temas:
Introducción.
Estructuras de Datos: Variables
• Tipos de datos.
• Conversión de datos.
Estructuras Lógicas:
• Estructuras lógicas de secuencia.
• Estructuras lógicas de decisión.
• Estructuras lógicas de repetición.
• Instrucciones de bifurcación.
• Mapa de estructuras lógicas detallado.
Método de las 6´D. Etapas y pasos.

Problemas resueltos en general y sobre figuras.
ESTRUCTURAS FUNDAMENTALES PARA LA SOLUCIÓN DE PROBLEMAS
CAPÍTULO II
ESTRUCTURAS FUNDAMENTALES PARA LA

SOLUCION DE PROBLEMAS
INTRODUCCIÓN
El modelamiento se refiere a la forma como representamos la solución de un problema del

mundo real en términos de un modelo. Un algoritmo constituye una lista completa de los
pasos y una descripción de los datos que son necesarios para resolver un determinado
problema en el ámbito de un método. La lista completa de los pasos se desarrolla utilizando
las estructuras lógicas y las instrucciones de bifurcación, mientras que los datos se
almacenan en las estructuras de datos. La programación es la traducción del modelamiento y
los algoritmos en sentencias que una computadora puede comprender y ejecutar. La acción
de escribir un programa para computadoras se conoce como codificación.
MARCO DE TRABAJO
ENUNCIADO
DEL
PROBLEMA
Etapa 02
Definición
Solución Etapa 03
Diseño
Solución Etapa 04
Desarrollo
Solución
Pag. 61
LISTA DE PASOS SENTENCIAS

DESCRIPCIÓN DECLARACIÓN Y
DE DATOS DEFINICIÓN DE
DATOS
SE DESARROLLAN UTILIZANDO:
• Instrucciones de bifucación.
ALMACENADOS EN:
• Estructuras de datos tipo variables.
El presente capítulo, trata sobre las estructuras fundamentales para la solución de problemas.
Es importante mencionar que utilizando las estructuras fundamentales para la solución de
problemas (estructuras lógicas, instrucciones de bifurcación y las estructuras de datos
conocidas como variables), se pueden desarrollar algoritmos de tal forma que estos puedan
ser diseñados en pseudocódigo o diagrama de flujo, para luego ser codificados en un
lenguaje de programación.
La técnica que se emplea en el presente texto para el ingreso de datos y visualización de la

información, cada día se utiliza con menos frecuencia (técnica tradicional basada en el
ingreso de datos y visualización de información utilizando solo caracteres). En su lugar, se
utilizan las interfaces gráficas de usuario o GUI (por sus siglas en inglés), que incorporan
ventanas, gráficos, colores y otros objetos que permiten una interface visual con el usuario.
El lenguaje de programación Java incorpora un paquete denominado AWT (Abstract Windows

Toolking) que contiene clases que permiten crear cualquier tipo de interfaces gráficas de
usuarios o GUI (interfaces visuales). También incorpora un paquete llamado SWING (a partir
de la versión 2 de Java), que facilita el ingreso y visualización de datos utilizando cuadros de
dialogo visuales.
Pag. 62
ESTRUCTURAS DE DATOS
VARIABLES
Definición:
Una variable es una estructura de datos que permite reservar un espacio con la
finalidad de almacenar o guardar temporalmente los datos. Una variable sólo puede
almacenar un dato a la vez. Si se necesita almacenar dos o tres datos, se requerirán
dos o tres variables según sea el caso.
Declaración de una variable:
Declarar una variable significa definir el nombre de la variable y el tipo de dato que
podrá almacenar. Generalmente se realiza al inicio de un programa.
La declaración de una variable se debe realizar antes de que ésta pueda ser
utilizada; esto es necesario en los diferentes lenguajes de programación, y Java no es
la excepción.
En pseudocódigo y diagrama de flujo:

TipoDeDato ListaDeVariables
En Java:
TipoDeDato ListaDeVariables ;
Donde TipoDeDato debe ser un tipo de variable o tipo de dato válido y

ListaDeVariables puede tener uno o más nombres de variables
separadas por comas.
Nombre de variable:
Siempre es necesario que las variables tengan un nombre para poder referirse a ellas
en cualquier parte de un programa. El nombre de una variable deberá comenzar con
una letra minúscula. Si el nombre de la variable está formado por varias palabras, se
deberá escribir con mayúscula la primera letra de cada palabra, a partir de la segunda
palabra que forme parte del nombre. No es válido que el nombre de una variable
tenga espacios en blanco ni caracteres especiales (tales como /()=?¨^* etc).
En pseudocódigo:
Una variable no puede tener el nombre de una regla o pauta
definida. (ejemplo: ESCRIBIR).
En Java:
Pag. 63
Una variable no puede tener el nombre de una palabra

reservada. (Ejemplo: String).
Se recomienda que el nombre a utilizar en las variables que se empleen, guarde

relación con el valor que estas almacenan.
Inicialización de una variable:
Es posible que una variable sea definida con un valor inicial y que este valor
posteriormente sea modificado. Es bueno definir con un valor inicial a todas las
variables declaradas en el programa.

TipoDeDato variable = valor
En Java:
TipoDeDato variable = valor ;
Donde valor debe ser un valor equivalente al tipo de variable o tipo de

dato definido. Aquí TipoDeDato es opcional y se utiliza sólo si la
variable no ha sido declarada anteriormente.
Almacenamiento de datos en variables:
Para almacenar un valor en una variable se utiliza el nombre con el que esta fue
declarada, a continuación el signo igual, seguido del valor que se desea almacenar.

variable = valor
En Java:
variable = valor ;
Se deberá tener presente que una variable puede almacenar sólo un valor a la vez y
que este valor deberá ser equivalente al tipo de dato con el que se declaró la variable.
Cada vez que almacena un valor en la variable, perderá el valor que anteriormente
tenía esta. Es posible almacenar un valor en una variable en cualquier parte del
programa. El único requisito es que la variable donde se almacene el valor esté
previamente declarada.
El valor de una variable puede también ser sustituido por el resultado de una
operación aritmética o de cálculo. Por ejemplo:

suma = 7 + 5
Pag. 64
En Java:
suma = 7 + 5 ;
En ambos casos, cuando se desee visualizar el contenido de la

variable suma, se observará que el valor obtenido será 12.
Otros usos de las variables:
Muchas veces, es necesario utilizar variables que permitan almacenar resultados

parciales, obtenidos cada vez que se ejecuta una estructura lógica de repetición (las
estructuras lógicas se repetición se estudian más adelante en este mismo capítulo).
Dichas variables pueden asumir la función de contador, acumulador o interruptor. La
función que pueda asumir una variable dependerá de la forma como se plantee la
solución para un determinado problema.
Contadores:
Un contador es una variable cuyo valor se incrementa o decrementa

en una cantidad fija cada vez que se ejecutan los pasos que forman
parte de una estructura de repetición. Un contador puede ser
creciente o decreciente.
Acumuladores:
Un acumulador o totalizador es una variable cuya función es

almacenar un valor como resultado de sumas o restas sucesivas.
Un acumulador realiza la misma función que un contador con la
diferencia que el incremento o decremento no es una cantidad fija
sino una cantidad variable.
Interruptores:
Un interruptor o conmutador (denominado también centinela, bandera

o flag) es una variable que puede tomar dos posibles valores (1/0,
verdadero/falso, si/no, encendido/apagado) dentro de una
determinada solución. Dependiendo del valor que tome el interruptor
se ejecutarán ciertos pasos.
Cabe mencionar que en una solución se puede utilizar una o varias variables que
pueden asumir las funciones de contador, acumulador o interruptor.
Pag. 65
TIPOS DE DATOS
Definición:
Los tipos de datos permiten declarar las variables. A pesar que en el pseudocódigo y
diagrama de flujo sólo se reconocen tres tipos de datos, en los lenguajes de
programación se tiene una gran variedad de tipos de datos, los cuales están divididos
–generalmente- en dos categorías: básicos o simples y compuestos.
Existen diferentes tipos de datos. En pseudocódigo y diagrama de flujo se utilizan tres

tipos (NUMERO, TEXTO y LOGICO). Los lenguajes de programación permiten
trabajar con una amplia diversidad de tipos de datos que se extienden desde los más
básicos hasta los más complejos. En Java, todos los datos son derivados de ocho
tipos de datos básicos; byte, short, int, long, float, double, char y boolean.
Los tipos de datos básicos se tratarán en este capítulo y constituyen la base para los
tipos de datos compuestos.
Tipos de datos en Pseudocódigo:
Reglas definidas para los tipos de datos:
NUMERO Referidos a cualquier número. Se puede subdividir en

ENTERO y REAL.
CARACTER Referidos a cualquier letra, digito o símbolo encerrado
entre comilla simple.
TEXTO Referidos a cualquier texto encerrado entre comillas
dobles.
LOGICO Referido a los dos posibles valores lógicos
(VERDADERO y/o FALSO).
Hay que tener presente que las palabras NUMERO, ENTERO, REAL. CARACTER.
TEXTO y LOGICO son reglas utilizadas en el pseudocódigo y diagrama de flujo, por
lo que no podrán ser usadas como nombre de variable. Estos datos nos permiten
definir los tres tipos de variables utilizadas:
Variables numéricas:
Permiten almacenar sólo tipos de datos numéricos (NUMERO,

ENTERO y REAL).
Con una variable numérica se puede realizar operaciones
matemáticas (suma, resta, multiplicación, división, etc.).
En este contexto, se debe tener presente que las operaciones

matemáticas se resuelven siguiendo las mismas reglas que se
aplican en la aritmética tradicional.
Pag. 66
Por ejemplo: Una serie de operaciones.
Primero se resuelven las multiplicaciones y divisiones; luego las

sumas y restas. Para alterar esta prioridad se podrá utilizar los
paréntesis.
Ejemplos:
edad = 15
resultado = 5 + 8 * ( 6 – 2)
Donde edad y resultado son variables que previamente han sido

declaradas como variables de tipo numéricas.
Variables de texto:
Permiten almacenar datos de tipo texto y datos de tipo caracter

(TEXTO y CARACTER).
Las variables tipo texto son útiles para almacenar cualquier cadena
de texto, tales como nombres de personas, direcciones, número de
AFP, etc.
Ejemplos:
nombre = “Pedro”
letra = ‘J’
Donde nombre y siglas son variables que previamente han sido

declaradas como variables de tipo texto.
Variables lógicas:
Permiten almacenar sólo tipo de datos lógicos.

Existen sólo dos valores que se pueden almacenar en este tipo de
variable: verdadero y falso.
Ejemplos:
masculino = VERDADERO
estudiante = FALSO
Donde masculino y estudiante son variables que previamente han

sido declaradas como variables de tipo lógico.
Las palabras VERDADERO y FALSO constituyen reglas en

pseudocódigo y diagrama de flujo, por lo que no está permitido que se
usen como nombres de variables.
Pag. 67
Tipos de datos en Java:
Los tipos de datos básicos o simples de Java son utilizados para declarar las
variables que serán utilizadas en los programas, y forman parte de las palabras
reservadas del lenguaje. Las palabras reservadas que permiten declarar variables
son byte, short, int, long, float, double, char y boolean.
Tipo Descripción Longitud Rango

byte Tipo byte 1 byte -128 … 127
short Entero corto 2 bytes -32768 … 32767
-2.147.483.648
int Entero 4 bytes 2.147.483.647
-9.223.372.036.854.775.808
long Entero largo 8 bytes 9.223.372.036.854.775.807
Real en coma flotante
float 4 bytes ±3,4*10-38 … ±3,4*1038
de simple precisión
Real con coma flotante
double 8 bytes ±1,7*10-308 … ±1,7*10308
de doble precisión.
char Caracter 2 bytes 0 … 65.535
boolean Lógico 1 byte true / flase
A diferencia de otros lenguajes de programación, en Java los tipos de datos simples

no dependen de la plataforma ni del sistema operativo. Un entero de tipo int siempre
tendrá 4 bytes, por lo que no habrá sorpresas al migrar un programa de un sistema
operativo a otro.
Es importante mencionar que Java no realiza una comprobación de rangos.

Por ejemplo: si a una variable de tipo short con el valor 32.767 se le suma 1, el
resultado será -32.768 y no se producirá ningún error de ejecución.
Es importante destacar que estos ocho tipos de datos simples son diferentes, pero
entre ellos se pueden agrupar como datos de tipo NUMERO (byte, short, int, long,
float, double), tipo CARACTER (char) y tipo LOGICO (boolean). Los datos tipo
NUMERO (datos numéricos) se pueden dividir en valores de tipo ENTERO (byte,
short, int, long) y valores de tipo REAL (float, double).
Para representar una cadena de caracteres en Java, se utiliza la clase String. Los
String en Java no son un tipo de dato básico (simple), sino un tipo de dato compuesto
(a pesar de ello, se puede utilizar como un tipo de dato simple para definir datos de
tipo TEXTO en Java). Los valores de los datos de tipo String van entre comillas
dobles (ejemplo; “Hola”) y permite almacenar cadenas de texto, mientras que los de
tipo char van entre comillas simples (ejemplo; ‘K’) y sólo permiten almacenar un solo
caracter.
Las palabras reservadas de Java no pueden ser utilizadas como nombre de variable.
Pag. 68
Como regla general, una variable solo puede almacenar valores de acuerdo al tipo de
dato con el que fue declarado. Es decir, si se declara una variable con un tipo de dato
específico, solo podrá almacenar valores de dicho tipo de dato. En base a esto, si se
declara una variable con un tipo de dato específico y se intenta almacenar un valor de
distinto tipo, al momento de compilar, el programa indicará un error. Ejemplos:
Clase PrgTipoDato01
package dominioDeLaAplicacion ;
class PrgTipoDato01 {
public static void main ( String arg [ ] ) {
double numReal = 4.3 ;

int numEntero ;
// La siguiente línea genera error.

numEntero = numReal ;
System.out.println ( numEntero ) ;
}
}
Observación: No se puede almacenar un número real grande (double) en una variable entera (int).
Clase PrgTipoDato02
double numRealDouble = 2.3 ;

float numRealFloat ;

numRealFloat = numRealDouble ;
System.out.println ( numRealFloat ) ;
}
}
Observación: No se puede almacenar un número real grande (double) en una variable real (float).
Pag. 69
Clase PrgTipoDato03
boolean estado = true ;

char caracter ;

caracter = estado ;
System.out.println ( caracter ) ;
}
}
Observación: No se puede almacenar un valor lógico (boolean) en una variable caracter (char).
Pag. 70
CONVERSIÓN DE DATOS
Anteriormente se mencionó que por regla general en una variable solo se puede
almacenar un solo valor y este valor debe ser del tipo de dato con el que la variable
fue declarada. Pero como toda regla, esta también tiene su excepción, y la excepción
para estos casos se denomina conversión de datos.
A través de la conversión de datos se puede almacenar en una variable valores de

tipo diferente al tipo de dato con el que se declaró la variable. La conversión de datos
se aplica generalmente sobre los tipos de datos numéricos, es decir entre datos de
tipo byte, short, int, long, float y double. También se puede aplicar sobre el tipo de
dato char.
Conversión implícita de datos en Java:
La conversión implícita de datos se da entre un tipo de dato de menor

precisión a un tipo de dato de mayor precisión (mas amplio, mas
grande) y son generadas automáticamente por el compilador Java.
A continuación se muestra los tipos de datos numéricos ubicados

desde el tipo de dato de menor precisión al tipo de dato de mayor
precisión:
byte, short, int, long, float y double
Ejemplos;
Clase PrgTipoDato04
int numEntero = 5 ;
long numEnteroGrande ;
// La siguiente línea no genera error.

numEnteroGrande = numEntero ;
// Se visualiza 5
System.out.println ( numEnteroGrande ) ;
}
}
Observación: Al ejecutar esta aplicación el compilador utiliza la conversión

implícita y convierte un número entero (int) en un número entero largo (long).
Esto es válido ya que el tipo de dato long en Java es de mayor precisión que
el tipo de dato int.
Pag. 71
Clase PrgTipoDato05
char caracter = ‘a’ ;

double numReal ;

numReal = caracter ;
// Se visualiza 97.0
System.out.println ( numReal ) ;
}
}

implícita y convierte la letra ‘a’ en un valor real (double) equivalente a su
código ASCII, por lo que se visualiza 97.0 (la letra a en código ASCII es 97).
La conversión implícita de datos se realiza al mezclar variables de

distinto tipo en expresiones matemáticas o al ejecutar instrucciones o
sentencias de asignación. En ambos casos, es necesario que el lado
izquierdo de la expresión tenga un tipo de dato más amplio que el
resultado de evaluar el lado derecho:
numReal = numEntero + 5 ;
Lado izquierdo
de la expresión
En caso contrario, si el lado derecho de la expresión tiene un tipo de

dato más amplio que el lado izquierdo, al momento de compilar, el
programa indicará un error.
La conversión implícita de datos en Java, se da de un tipo de dato de

menor precisión a uno de mayor precisión.
Conversión explicita de datos en Java (casting):
Las conversiones de un tipo de dato de mayor precisón a otro tipo de

dato de menor precisión requieren que se coloque en forma explicita
en los programas. Estás conversiones son inseguras y puedan dar
lugar a errores. Este tipo de conversión de datos se le denomina
también cast (casting). El cast se realiza colocando entre paréntesis
Pag. 72
el tipo de dato al que se desea convertir el resultado de una

expresión.
Ejemplo;
Clase PrgTipoDato06

double num1 = 20, num2 = 3 ;
int div ;

div = num1 / num2 ;
System.out.println ( div ) ;
}
}
Clase PrgTipoDato07

double num1 = 20, num2 = 3 ;
int div ;

div = ( int ) ( num1 / num2 ) ;
// Se visualiza 6.
System.out.println ( div ) ;
}
}

explícita (casting) para poder almacenar el resultado de una división de
numeros reales (double) en una variable entera (int).
Finalmente, en el capítulo III se tratán las clases Wrappers que envuelven los tipos de
datos simples y también permiten realizar operaciones de conversión, entre otras.
Pag. 73
Pag. 74
ESTRUCTURAS LÓGICAS
ESTRUCTURAS LÓGICAS DE SECUENCIA
Definición:
Las Estructuras Lógicas de Secuencia son aquellas en las que una instrucción
sigue a otra en secuencia. Las instrucciones se ejecutan una a una de tal modo que,
finalizada la ejecución de una instrucción, se inicia la ejecución de la siguiente hasta
completar la ejecución de todas las instrucciones que forman parte de la secuencia.
Las Estructuras Lógicas de Secuencia son las estructuras lógicas más comunes y
constituyen la base sobre la cual se desarrollan las demás estructuras lógicas.
Tipos:
1. Estructura para la salida de información
Definición:
La salida de información se refiere a la forma o mecanismos que se

emplean para poder conocer el resultado de un determinado algoritmo.
Este tipo de estructura permite mostrar información a través de un

dispositivo de salida de una computadora.
Representación:
Para representar la salida o visualización de la información se utiliza:
- La regla;
ESCRIBIR En pseudocódigo.
- El símbolo;
En diagrama de flujo.
- La clase;
System En Java.
Pag. 75
Es importante mencionar que se puede visualizar una cadena de texto,

el contenido de una variable o el resultado de una operación
matemática. Por ejemplo;
Si desea visualizar la cadena de texto “Hola Mundo” utilizando

pseudocódigo y diagrama de flujo, lo realizará de la siguiente
manera:
ESCRIBIR “Hola Mundo” “Hola Mundo”
Si desea codificarlo en el lenguaje de programación Java, deberá

realizarlo de la siguiente manera:
System.out.print (“Hola Mundo”);

System.out.println (“Hola Mundo”);
Se puede utilizar la palabra “print” o “println”. Cuando se utiliza la

palabra “print” se mostrará la cadena de texto y el cursor
permanecerá al final de la cadena de texto mostrada, y cuando se
utiliza la palabra “println” se mostrará la cadena de texto y el
cursor se colocará en la siguiente línea.
2. Estructura para la entrada de datos
Definición:
La entrada de datos se refiere a la forma o mecanismos que se

emplean para ingresar los datos que necesita un algoritmo para
procesarlos y obtener, posteriormente, la información necesaria.
Este tipo de estructura permite ingresar datos a través de un dispositivo

de entrada de una computadora.
Representación:
Para representar la entrada de datos se utiliza:
- La regla;
LEER En pseudocódigo.
- El símbolo;
En diagrama de flujo.
Pag. 76
- La clase;
Lectura En Java.
Es importante mencionar que el lenguaje de programación Java no

proporciona una clase que facilite el ingreso de datos en forma
tradicional. En consecuencia, se utilizará una clase en Java desarrollada
especialmente para que cumpla dicha finalidad.
CLASE MÉTODO DESCRIPCIÓN

Permite ingresar una
leerString()
cadena de texto.
Permite ingresar un
leerChar() caracter (una sola letra o
número)
Permite ingresar un
leerInt()
número entero.
Lectura.class
Permite ingresar un
leerLong()
número entero largo.
Permite ingresar un
leerFloat()
número con parte decimal.
Permite ingresar un
leerDouble()
número con parte decimal.
La clase Lectura fue desarrollada por la Srta. Gisella Guzmán.
La clase Lectura va a facilitar el ingreso de datos en forma tradicional.

1
Esta clase es una implementación mejorada de la clase Math2 Es
importante mencionar, que esta clase permitirá ingresar datos en forma
tradicional y será usada para la codificación de algoritmos en Java.
En el Apéndice, se trata en detalle la clase Lectura.
1
Se puede revisar el uso de la clase Math2 en el primer libro del autor, titulado “Método para la solución de
problemas utilizando la programación orientada a objetos – Aspectos básicos”.
Pag. 77
3. Estructura para operaciones aritméticas y de cálculo
Definición:
Las operaciones aritméticas y de cálculo se refieren a la forma o

mecanismos que se emplean para poder procesar los datos ingresados
y obtener la información necesaria.
Representación:
Para representar las operaciones aritméticas se utilizan los mismos

signos que se emplean en la aritmética tradicional (+, -, *, /).
Suma: +
Resta: -
Multiplicación: *
División: /
Las operaciones lógicas se representan de la siguiente manera:

Y lógico: Y (AND)
O lógico: O (OR)
Negación: N (NOT)
En Java:
Y lógico: &&
O lógico: ||
Negación: ~
Formatos:
Formato para diseñar algoritmos:
Pseudocódigo
EXPLICACIÓN:
INICIO Todas las instrucciones que son parte

de la solución del problema deberán
Instrucciones ... aparecer entre las reglas INICIO y
FIN. Estas instrucciones se ejecutarán
FIN una tras otra.
Pag. 78
Diagrama de Flujo
EXPLICACIÓN:
INICIO Todas las instrucciones que son parte de

la solución del problema aparecerán
entre el siguiente símbolo:
Instrucciones ...
Dentro del símbolo se indicará si es el

FIN inicio o el fin de la solución con las
reglas INICIO o FIN.
Al conjunto de pasos que forman parte de un algoritmo se les denomina instrucciones.
Formato para codificar algoritmos:
Lenguaje de Programación Java

EXPLICACIÓN:
Inicialmente, se puede afirmar

class NombreClase { que todas las sentencias que
son parte de la solución
public static void main (String a[]) { aparecerán dentro de los
.... métodos. El método main ( )
// sentencias es conocido como el método
.... principal, y es desde donde se
} inicia la ejecución de las
} sentencias.
Al conjunto de pasos que forman parte de un programa de computadora se les denomina

sentencias.
Pag. 79
ESTRUCTURAS LÓGICAS DE DECISIÓN
Definición:
Las Estructuras Lógicas de Decisión son construcciones que permiten alterar el

flujo secuencial de una solución, de tal forma que en función de una condición o el
valor de una variable, se pueda desviar la secuencia de la solución entre diferentes
alternativas.
Las Estructuras Lógicas de Decisión son conocidas también como Estructuras de

Selección.
Tipos:
1. Estructuras lógicas de decisión simple
Definición:
Una estructura de decisión simple “SI... FINSI” permite alterar el flujo

secuencial (o pasos secuenciales) de una solución ejecutando un
conjunto de pasos adicionales si el resultado de una condición lógica es
verdadera.
Este tipo de estructura es útil cuando se tiene la posibilidad de escoger

una determinada opción.
Pseudocódigo
EXPLICACIÓN:
Si la condición resulta verdadera, se

ejecutan las instrucciones que se
SI (condición) encuentran entre las reglas
ENTONCES ENTONCES y FINSI.
instrucciones...
FINSI Si la condición resulta falsa, no se
encuentran entre las reglas
ENTONCES y FINSI.
Pag. 80
Diagrama de Flujo EXPLICACIÓN:
Si la condición resulta
verdadera, se ejecutan las
VERDADERO instrucciones que se
condición ? encuentran en el flujo
etiquetado con la regla
“VERDADERO”.
... FALSO
instrucciones... Si la condición resulta falsa, se
... sigue el flujo etiquetado con la
regla o pauta “FALSO” y no
se ejecutan las instrucciones
que se encuentran en el flujo
“VERDADERO”.
Lenguaje de
Programación Java
EXPLICACIÓN:

ejecutan las sentencias que se
if (condición) { encuentra entre las llaves { }.
sentencias... Si la condición resulta falsa, no se

} encuentran entre las llaves { }.
Pag. 81
2. Estructuras lógicas de decisión doble
Definición:
Una estructura de decisión doble “SI... SINO... FINSI” permite alterar

el flujo secuencial (o pasos secuenciales) de una solución, ejecutando
un conjunto de pasos dependiendo del resultado de una condición
lógica. Si la condición resulta verdadera, se ejecuta un conjunto de
pasos, y si la condición resulta falsa, se ejecuta otro conjunto de pasos.
En ningún caso se podrá ejecutar ambos conjuntos de pasos a la vez.
Este tipo de estructura es útil cuando se tiene la necesidad de escoger

entre dos posibles opciones.
Pseudocódigo
EXPLICACIÓN:

encuentran entre las reglas
SI (condición) ENTONCES y SINO.
ENTONCES
instrucciones... Si la condición resulta falsa se
SINO ejecutan las instrucciones que se
instrucciones... encuentran entre las reglas SINO y
FINSI FINSI.
Sólo se ejecuta uno de los grupos de

instrucción, en ningún caso se podrá
ejecutar ambos grupos.
Pag. 82
Diagrama de Flujo
EXPLICACIÓN:
Si la condición resulta
VERDADERO FALSO verdadera, se ejecutan las
condición ? instrucciones que se
encuentran en el flujo
“VERDADERO”.
... ...
instrucciones instrucciones
Si la condición resulta falsa,
... ...
se ejecutan las instrucciones
que se encuentran en el flujo
“FALSO”.
Lenguaje de
Programación Java
EXPLICACIÓN:

if (condición) { encuentran entre las llaves { }
sentencias... ubicadas después de la palabra
} reservada if.
else {
sentencias... Si la condición resulta falsa, se
} ejecutan las sentencias que se
encuentran entre las llaves { }
ubicadas después de la palabra
reservada else.
Pag. 83
3. Estructuras lógicas de decisión múltiple
Definición:
Una estructura de decisión múltiple “CUANDO... FINCUANDO”

permite alterar el flujo secuencial de una solución ejecutando un
conjunto de pasos dependiendo del valor de una variable.
Generalmente, para cada posible valor que pueda tener la variable se
define un conjunto de pasos a ejecutar. También se define un conjunto
de pasos a ejecutar en caso que uno de los valores de la variable no
tenga asociado un conjunto de pasos a ejecutar.
Este tipo de estructura es útil cuando se tiene la necesidad de escoger

entre más de dos opciones.
Pseudocódigo EXPLICACIÓN:
Si el valor de la variable es igual a uno

de los valores colocados después de
CUANDO (variable) SEA una de las reglas CASO, se ejecutan
CASO (valor 1) : las instrucciones que están dentro del
instrucciones... mismo.
CASO (valor 2) :
instrucciones... Si el valor de la variable no es igual a
CASO (valor n) : ninguno de los valores colocados
instrucciones... después de una de las reglas CASO,
se ejecutan las instrucciones que están
OTROS
instrucciones... dentro de la regla OTROS. La regla
OTROS es opcional (es decir, puede
FINCUANDO
aparecer como no).
Pag. 84
Diagrama de Flujo
variable ?
valor 1 valor 2 valor n OTROS
instrucciones instrucciones instrucciones instrucciones
EXPLICACIÓN:
Si el valor de la variable es igual a uno de los valores que tiene como

etiqueta el flujo, se ejecutan las instrucciones que están seguidas del
flujo (las que indica la flecha).
Si el valor de la variable no es igual a uno de los valores de las etiquetas

de los flujos, se ejecuta el flujo que tiene como regla OTROS. El flujo
con la regla OTROS es opcional.
Pag. 85
Lenguaje de
Programación Java EXPLICACIÓN:
Si el valor de la variable es igual a uno

de los valores colocados después de la
palabra reservada case (valor 1, valor
switch (variable) { 2, etc), se ejecutan las sentencias que
case valor 1 : están dentro del mismo hasta llegar al
sentencias... final (es decir hasta la llave) a no ser
case valor 2 : que encuentre una palabra reservada
sentencias... break entre las sentencias que se
case valor n : ejecutan.
sentencias...
Si el valor de la variable no es igual a
ninguno de los valores colocados
default :
sentencias... después de una de las palabras
} reservadas case, se ejecutan las
sentencias que están dentro de la
palabra reservada default. La palabra
reservada default es opcional (es decir
puede aparecer como no).
Es importante tener presente que en Java se deberá usar la palabra reservada

break al final de cada bloque de sentencias si se desea que cada alternativa
(case) ejecute un grupo de sentencias sin que ejecute el grupo de sentencias de
las alternativas (case) que están a continuación.
También es importante mencionar que en Java la variable utilizada junto a la

palabra reservada switch sólo puede ser de tipo entero o de tipo caracter.
Si la variable es de tipo entero (definida con la palabra reservada int), se deberá

utilizar números enteros después de la palabra reservada case. En caso que la
variable sea de tipo caracter (definida con la palabra reservada char), se deberá
utilizar un caracter encerrado entre comillas simples después de la palabra
reservada case.
Cuando se diseñe un algoritmo que necesite utilizar estructuras de decisión, se

debe emplear correctamente los formatos establecidos, ya que estos constituyen
lo que denominamos un “estándar” o acuerdo.
Cuando se codifique un algoritmo recuerde que se tiene que seguir las reglas del
lenguaje de programación que usará, caso contrario, al momento de ejecutar un
programa, se dará con la sorpresa que tendrá errores de sintaxis.
Pag. 86
ESTRUCTURAS LÓGICAS DE REPETICIÓN
Definición:
Las Estructuras Lógicas de Repetición son construcciones que permiten repetir

determinadas partes de una solución, de tal forma que, en función de una condición o
el valor de una variable, se pueda repetir un conjunto de pasos un determinado
número de veces.
Las Estructuras Lógicas de Repetición son conocidas también como estructuras de

iteración o bucles.
Tipos:
1. Estructura lógica de repetición “DESDE”
Definición:
Una estructura de repetición “DESDE... FINDESDE” permite repetir

una instrucción, o un bloque de instrucciones, un número determinado
de veces o hasta que una condición se cumpla. Una estructura lógica de
repetición “DESDE... FINDESDE” con frecuencia se utiliza para
iteraciones sencillas en donde se repite un bloque de instrucciones un
cierto número de veces y después se detiene.
Este tipo de estructura es útil cuando se necesita repetir una instrucción

o bloque de instrucciones un cierto número de veces.
Pseudocódigo
DESDE i = valorInicial HASTA valorFinal INCREMENTA valor
instrucción 1
.
.
.
instrucción n
FINDESDE
Pag. 87
EXPLICACIÓN:
Esta estructura tiene tres partes:
1. Inicialización: DESDE i = valorInicial
Esta parte se ejecuta una sola vez al momento de iniciar la ejecución

de la estructura lógica de repetición DESDE... FINDESDE y
permite asignar un valor inicial a la variable “i” o la que se utilice
en vez de ésta. Esta variable funciona como un índice que permite
mantener el control sobre el número de veces que se repiten las
instrucciones ubicadas entre las reglas DESDE y FINDESDE.
2. Incremento: INCREMENTA valor

Cada vez que finaliza la ejecución de las instrucciones o bloque de
instrucciones ubicadas entre las reglas DESDE y FINDESDE, se
ejecuta esta parte y se INCREMENTA (aumenta) el valor de la
variable índice “i” según se indique en valor. También existe la
posibilidad de reducir el valor de la variable índice “i”; en este caso,
se utiliza la regla DECREMENTA en lugar de la regla
INCREMENTA.
3. Prueba: HASTA valorFinal
Una vez que se termina de INCREMENTAR o DECREMENTAR

la variable índice, se procede a ejecutar esta parte. Aquí se evalúa si
la variable índice es igual a valorFinal, es decir si ya llegó HASTA
valorFinal.
Si la variable índice no es igual a valorFinal, se volverá a ejecutar
las instrucciones o bloque de instrucciones ubicadas entre las reglas
DESDE y FINDESDE. En caso que la variable índice sea igual a
valorFinal, se finaliza la ejecución del DESDE y se continúa con la
ejecución de la instrucción ubicada después de la regla
FINDESDE.
El equivalente de esta estructura en diagrama de flujo se muestra a

continuación:
Pag. 88
Diagrama de Flujo
DESDE i HASTA z FALSO
INCREMENTA x
VERDADERO
...
instrucciones...
...
EXPLICACIÓN:
Las tres partes de esta estructura se representan en el diagrama de flujo a

través de las siguientes reglas:
DESDE i HASTA z
Aquí “i” es la variable índice y “z” es el valor que el índice “i” debe
alcanzar para finalizar la ejecución.
INCREMENTA x
Aquí “x” representa el valor que se incrementará a la variable índice
cada vez que se termine la ejecución de las instrucciones que
forman parte de la estructura.
Ambas reglas se encuentran dentro del símbolo que representa la regla o

pauta DESDE, la cual se muestra a continuación:
El fin de las instrucciones o bloque de instrucciones que forman parte de

la regla DESDE, se representa por el siguiente símbolo:
Este último símbolo es equivalente a la regla FINDESDE utilizada en

pseudocódigo.
Pag. 89
for ( i = valorInicial ; condición ; incremento) {

sentencias...
}
EXPLICACIÓN:
En Java, la regla DESDE está representada por la sentencia for.
Al igual que en pseudocódigo y diagrama de flujo, en Java esta

estructura está constituida por tres partes.
En pseudocódigo y diagrama de flujo se utiliza la regla HASTA

valorFinal, mientras que en Java se utiliza una condición lógica
(ejemplo: i >10).
Esta parte constituye la prueba en Java. Si la condición es verdadera, se

continúa con la ejecución de las sentencias o bloque de sentencias que
pertenecen a la estructura de repetición; en el caso que sea falso, se
finaliza la ejecución continuando con la siguiente sentencia.
Es importante indicar que el inicio y fin de la sentencia for se

representan con llaves ({ }).
2. Estructura lógica de repetición “MIENTRAS”
Definición:
Una estructura de repetición “MIENTRAS... FINMIENTRAS”, al igual

que una estructura lógica de repetición “DESDE... FINDESDE”, permite
repetir una instrucción o un bloque de instrucción mientras que una
condición se cumpla o ésta sea verdadera.

o bloque de instrucciones un número de veces no determinado.
Pag. 90
Pseudocódigo
instrucción 1
.
.
.
instrucción n
FINMIENTRAS
EXPLICACIÓN:
Cuando se ejecuta la estructura lógica de repetición MIENTRAS...

FINMIENTRAS lo primero que se realiza es la evaluación de la
condición lógica ubicada junto a la regla MIENTRAS.
Una vez evaluada la condición lógica, podemos obtener dos posibles

resultados:
Si el resultado de evaluar la condición lógica es

verdadera, se procede a ejecutar las
instrucciones que están dentro de la estructura
lógica de repetición MIENTRAS...
FINMIENTRAS y se evalúa, nuevamente, la
condición lógica.

falsa, no se ejecutan las instrucciones que están
dentro de la estructura lógica de repetición
MIENTRAS... FINMIENTRAS y se continúa
con la ejecución del algoritmo.
Esto significa que mientras la evaluación de la condición lógica resulte

verdadera, se ejecutará la estructura lógica de repetición MIENTRAS...
FINMIENTRAS y que sólo finalizará cuando la evaluación de la
condición lógica resulte falsa.
El equivalente de esta estructura en diagrama de flujo se muestra a

continuación. En la figura, se observa donde se ubica la condición lógica
y los flujos etiquetados con las reglas “VERDADERO” y “FALSO”.
Pag. 91
Diagrama de Flujo
FALSO
condición ?
VERDADERO
...
instrucciones...
...
while (condición) {
sentencias...
}
Pag. 92
EXPLICACIÓN:
En Java, la regla MIENTRAS está representada por la sentencia while.
En la sentencia while, al igual que en pseudocódigo y diagrama de flujo,

se utiliza una condición lógica (ejemplo: i >10) para verificar si se
ejecuta la estructura o no.
Esta condición lógica constituye la prueba en Java. Si la condición es

verdadera, se continúa con la ejecución de las sentencias o bloque de
sentencias que pertenecen a la estructura de repetición; en el caso que
sea falso, se finaliza la ejecución continuando con la siguiente sentencia.
Es importante indicar que el inicio y fin de la sentencia while se

3. Estructura lógica de repetición “HACER”
Definición:
Una estructura lógica de repetición “HACER... MIENTRAS”, al igual

que una estructura lógica de repetición “DESDE... FINDESDE” y una
estructura lógica de repetición “MIENTRAS... FINMIENTRAS”, permite
repetir una instrucción o un bloque de instrucciones mientras que una
condición se cumpla o sea verdadera.
La principal diferencia entre ambos consiste en que la estructura lógica

de repetición “MIENTRAS... FINMIENTRAS” prueba la condición antes
de ejecutar la instrucción o bloque de instrucciones, lo que hace posible
que dichas instrucciones no se ejecuten si la condición es falsa la
primera vez que se prueba la condición. La estructura lógica de
repetición “HACER... MIENTRAS” ejecuta al menos una vez las
instrucciones o bloque de instrucciones antes de probar la condición.

o bloque de instrucciones un número de veces no determinado, siendo
necesario ejecutar la instrucción o bloque de instrucciones por lo menos
una vez.
Pag. 93
Pseudocódigo
HACER
instrucción 1
.
.
.
instrucción n
EXPLICACIÓN:
Cuando se ejecuta la estructura lógica de repetición HACER...

MIENTRAS se procede a ejecutar las instrucciones que están dentro de la
misma. Al final, se realiza la evaluación de la condición lógica ubicada
junto a la regla MIENTRAS.
Una vez evaluada la condición lógica se puede obtener dos posibles

resultados:

verdadero, se procede a ejecutar, nuevamente,
las instrucciones que están dentro de la
estructura lógica de repetición HACER...
MIENTRAS y se evalúa, nuevamente la
condición lógica.

falso, se continúa con la ejecución del
algoritmo.
Esto significa que la estructura lógica de repetición HACER...

MIENTRAS se ejecuta por lo menos una vez antes de ser evaluada la
condición lógica. Si al evaluar la condición lógica ésta resulta verdadera,
se vuelve a ejecutar la estructura; caso contrario, finaliza la ejecución de la
estructura, continuando con la siguiente instrucción del algoritmo.
Pag. 94
El equivalente de está estructura en diagrama de flujo se muestra a

continuación. En la figura, se observa donde se ubica la condición lógica
y los flujos etiquetados con las reglas “VERDADERO” y “FALSO”.
Diagrama de Flujo
...
instrucciones
...
...
VERDADERO
condición ?
FALSO
do {
sentencias...
} while (condición) ;
Pag. 95
EXPLICACIÓN:
En Java, la regla HACER está representada por la sentencia do.
En la sentencia do, al igual que en pseudocódigo y diagrama de flujo, se

utiliza una condición lógica (ejemplo: i >10) al final de la estructura,
para verificar si se vuelve a ejecuta la estructura o no.
Esta condición lógica constituye la prueba en Java. Si la condición es

verdadera, se vuelve a ejecutar las sentencias o bloque de sentencias que
pertenecen a la estructura de repetición, en el caso que sea falso, se
finaliza la ejecución, continuando con la siguiente sentencia.
Es importante indicar que el inicio y fin de la sentencia do se

Pag. 96
Instrucciones de bifurcación:
Muchas veces es necesario cambiar o alterar el flujo normal de ejecución de una

solución a otra parte de la misma. Para esto, se utilizan las instrucciones de
bifurcación o salto.
1. Instrucción “TERMINAR”.
En Java, esta instrucción de bifurcación es conocida como la sentencia break y

tiene tres usos:
Permite finalizar una secuencia de sentencias en un switch

(específicamente en el case).
Se utiliza para salir de un bucle, sin analizar la condición y sin ejecutar el
resto de código del cuerpo del bucle.
Se emplea para proporcionar un mecanismo que permita cambiar el flujo
de ejecución a otra parte de la solución (equivalente a un goto en otros
lenguajes de programación).
2. Instrucción “CONTINUAR”
En Java, esta instrucción de bifurcación es conocida como la sentencia continue.

Esta sentencia permite salir anticipadamente de una iteracción de un bucle. Es
decir; cuando se encuentra la sentencia continue se ejecuta la siguiente
iteracción del bucle sin procesar el resto del código.
3. Instrucción “RETORNAR”
En Java, esta instrucción de bifurcación es conocida como la sentencia return.

Esta sentencia se utiliza para volver explícitamente de un método, es decir, esta
sentencia permite que el control de la ejecución de la solución vuelva al método
llamante.
Pag. 97
Mapa de Estructuras Lógicas detallado:
Utilizando las estructuras lógicas fundamentales y las instrucciones de bifurcación, se pueden

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

de Secuencia. de Decisión. de Repetición. de Bifurcación.
“LEER” “SI” “DESDE” “TERMINAR”
“ESCRIBIR” “SI / SINO” “MIENTRAS” “CONTINUAR”
“PROCESAR” “CUANDO” “HACER” “RETORNAR”
Pag. 98
ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS
MÉTODO DE LAS 6´D – ETAPAS Y PASOS
A continuación, se presentan las etapas del Método de las 6’D con sus respectivos pasos.
Dichas etapas y pasos han sido desarrollados en su totalidad en los primeros 22 problemas.
Sin embargo, para los siguientes problemas hasta el final del presente capítulo (capítulo II), y
para los problemas del siguiente capítulo (capítulo III), solo se ha incluido la Etapa 04 –
“Desarrollo de la solución”. Esto permite presentar una mayor cantidad de problemas con
sus respectivas codificaciones.
ENUNCIADO
DEL
PROBLEMA
Etapa 02 Etapa 03 Etapa 04
Definición Diseño Desarrollo

Solución Solución Solución
• Determinar la
información deseada
(salida). • Determinar el nombre del • Codificar el diseño de la
• Determinar los datos proyecto. solución del problema. Se
de entrada (entrada). • Definir los paquetes y utiliza el lenguaje de
• Establecer como se desarrollar el diagrama de programación Java.
solucionará el paquetes respectivo.
problema (proceso). Establecer la dependencia.
(Utilice UML).
• Definir las clases que serán
parte de la solución del
problema. (Utilice UML).
• Diseñar el algoritmo para el

método principal. Se utiliza
pseudocódigo.
En forma general, la Etapa 03 - “Diseño de la lógica” se divide en dos partes:

modelamiento (paso 1, 2 y 3) y algoritmo (paso 4), mientras que en la Etapa 04 -
“Desarrollo de la solución” se tiene la parte de codificación (paso 1). También se puede
utilizar esta división en el desarrollo de las soluciones.
Pag. 99
Pag. 100
Problema 01
Etapas para la solución de un problema:
Etapa 01 - Descripción del problema.
Desarrollar un proyecto que permita mostrar un mensaje por la pantalla. El mensaje a

mostrar será “Hola bienvenidos”.
Etapa 02 – Definición de la solución.
Resultado deseado: Mostrar mensaje “Hola bienvenidos”.
Datos necesarios: Ninguno.
Procesamiento: El mensaje será almacenado en una variable

(mensaje) y posteriormente mostrado.
Etapa 03 - Diseño de la lógica.
Para solucionar el problema se desarrollarán las especificaciones del proyecto en UML

y el algoritmo en pseudocódigo.
1. Nombre del Proyecto: ProyMensaje
2. Definición de Paquete y Clase.
Paquete y clase
DominioDeLaAplicacion
PrgMensaje
main()
Pag. 101
3. Diseño de algoritmo para el método principal
Algoritmo PrgMensaje - método main()
ENTRADA:
SALIDA: mensaje
INICIO Algoritmo para el método

main ( ) diseñado en
TEXTO mensaje
mensaje = “ Hola bienvenido ” pseudocódigo.
ESCRIBIR mensaje
FIN
Etapa 04 – Desarrollo de la Codificación.
La codificación se desarrolla utilizando el lenguaje de programación Java. Una vez que

se ejecute este programa, se visualiza en la pantalla el mensaje “Hola Bienvenido”.
Clase PrgMensaje
/* Este es el primer programa. Aunque es sencillo, podemos

apreciar los elementos básicos de un programa en Java.
*/
class PrgMensaje {
// La ejecución empieza en el método main.
String mensaje ;
mensaje = “ Hola bienvenido ” ;
System.out.print (mensaje) ;
}
}
Pag. 102
Análisis de la solución:
En primer lugar, se definió el nombre del proyecto, se estableció el nombre del paquete, el
nombre de la clase y el método main ( ), en el cual se codifica la solución.
A continuación, analizaremos el algoritmo del método main ( ) diseñado en pseudocódigo para la

solución del problema anterior.
La primera línea: ALGORTIMO PrgMensaje
Está referida al nombre del algoritmo. En este caso, el nombre es

PrgMensaje. Observe que la primera letra se escribe con mayúscula.
Luego tenemos: ENTRADA:

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

en el algoritmo es almacenar datos de salida. Observe que se ha
definido la variable mensaje como una variable de salida.
SALIDA: mensaje
Luego tenemos: INICIO
Esta palabra permite indicar el inicio de los pasos que constituyen la

solución al problema planteado.
A continuación: TEXTO mensaje
Esta línea está referida al paso 1 del algoritmo diseñado en

pseudocódigo. Aquí se declara que se utilizará una variable de
nombre mensaje cuyo tipo de dato es TEXTO o cadena.
Luego tenemos: mensaje = “ Hola bienvenidos ”

pseudocódigo. Aquí se asigna el valor “ Hola bienvenidos ” a la
variable mensaje. Recuerde que, para asignar un valor a una
variable, se utiliza el símbolo igual (=).
A continuación: ESCRIBIR mensaje
Pag. 103

pseudocódigo. A través de la palabra ESCRIBIR se muestra el
contenido de la variable mensaje. Es decir, se muestra “ Hola
bienvenidos ” , valor que fue asignado a la variable en el paso 2.
Finalmente: FIN
Esta palabra permite indicar el fin de los pasos que constituyen la

solución al problema planteado. Es decir, el final del algoritmo.
Los pasos que están entre las palabras INICIO… FIN constituyen la parte más importante
del algoritmo y es conocido como “cuerpo del algoritmo”.
Ahora, analicemos cada línea de la codificación del algoritmo en el lenguaje de programación

Java:
En primer lugar, observamos que el programa empieza con las siguientes líneas:
/* Este es el primer programa. Aunque es sencillo podemos

apreciar los elementos básicos de un programa en Java.
*/
Este es un comentario. Tal como la mayoría de lenguajes de programación, Java le

permite colocar comentarios en el código fuente de los programas. Los comentarios no
son ejecutados, y su propósito es describir o explicar el objetivo de un programa a
cualquiera que lea el código fuente. En nuestro caso, el comentario nos permite identificar
el programa. En problemas grandes se utilizan los comentarios para explicar para qué
sirve cada característica del programa y cómo éstas se ejecutan. Es decir, se puede
utilizar los comentarios para describir paso a paso lo que hace el programa.
En Java existen tres tipos de comentarios. El que se acaba de mostrar se llama

comentario de múltiples líneas. Este tipo de comentario comienza con una barra
seguida de un asterisco (/*) y termina donde aparece un asterisco seguido de una barra
(*/). Todo aquello que se escribe entre los dos símbolos de comentario de múltiples líneas
/*………. */ es ignorado al momento de ejecutar el programa. Los comentarios de
múltiples líneas pueden tener una o varias líneas de longitud.
Pag. 104
Observemos la siguiente línea de código:
Esta línea especifica el paquete al cual pertenecerá la clase que se creará con la palabra
reservada class.
El nombre del paquete está a continuación de la palabra reservada package. En este

caso, el nombre del paquete es “dominioDeLaAplicacion”.
En la siguiente línea de código:
class PrgMensaje {
Observe que en la línea de código anterior se utiliza la palabra reservada class, lo cual
nos indica que se declara una clase.
A continuación encontramos el nombre de la clase PrgMensaje. Finalmente, seguido del

nombre se coloca una llave de apertura ( { ), la cual indica el inicio del cuerpo de la
misma.
La siguiente línea del programa es:
// La ejecución empieza en el método main.
Este también es un comentario. Usa el segundo tipo de comentario disponible en Java y

se llama comentario de una sola línea. Los comentarios de una sola línea comienzan
con dos barras ( // ) y terminan al final de la línea.
Pag. 105
Esta línea de código es conocida como la firma del método main ( ) o método principal.
Toda clase en Java, que deseamos tenga la posibilidad de ejecutarse, deberá tener un
método main ( ) exactamente como ha sido escrito, debido a que Java diferencia las letras
mayúsculas de las letras minúsculas.
En resumen, podemos decir que para desarrollar un programa básico en Java necesitamos
definir un paquete, una clase y un método principal o método main ( ).
Recuerde que esto se realizó con las siguientes líneas de código:
class PrgMensaje {
}
}
String mensaje ;
A través de esta línea se declara el uso de la variable mensaje de tipo TEXTO o cadena.
En Java, todas las variables deben ser declaradas antes de ser utilizadas (lo que no es
necesario realizar en las herramientas utilizadas para diseñar algoritmos). Además,
también se debe especificar el tipo de dato que la variable puede almacenar.
En este caso, el tipo de la variable mensaje es TEXTO o cadena. En Java, para declarar
una variable de tipo TEXTO o cadena, se debe de anteponer al nombre de la variable la
palabra String.
Es importante mencionar que esta línea de código termina en punto y coma ( ; ). De

hecho, todas las sentencias en Java terminan en punto y coma.
mensaje = “ Hola bienvenido ” ;
A través de esta sentencia se asigna un valor a la variable. Es importante mencionar que

una variable, antes de ser utilizada, debe tener un valor asignado. En este caso, a la
variable mensaje se le asigna el valor “ Hola bienvenido ”. Para asignar valor a una
Pag. 106
variable, se utiliza el signo igual ( = ). En Java se crea una cadena cuando se encierra una
secuencia de caracteres entre comillas. De esta manera, “ Hola bienvenido ” es una
cadena.
System.out.print (mensaje) ;
Esta es una sentencia de salida por la consola. Hace que el valor de la variable mensaje
se visualice por la pantalla. De hecho, también uno puede visualizar cadenas y los
resultados de operaciones matemáticas.
Las dos últimas líneas del programa son:
}
}
La primera indica que el método main ( ) ha terminado y la segunda indica el final de la

clase.
De esto se deduce, que las siguientes líneas de código se utilizarán en todos los programas que
se desarrollen. Sólo variará el nombre del paquete y el nombre de la clase que, en este caso, es
dominioDeLaAplicacion y PrgMensaje respectivamente.
class PrgMensaje {
}
}
Pag. 107
Problema 02
Etapas para la solución de un problema:
Se requiere mostrar el resultado de sumar, multiplicar, restar y dividir los números

9121236 y 735.
Etapa 02 - Definición de la solución.
Resultado deseado: Mostrar el resultado de las operaciones

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

1. Nombre del Proyecto: ProyOperaciones.
2. Definición de Paquete y Clase.
Paquete y clase
DominioDeLaAplicacion
PrgOperaciones
main()
Pag. 108
3. Diseño de algoritmo para el método principal.
Algoritmo PrgOperaciones - método main()
ENTRADA:
SALIDA: suma, multi, resta,divi
INICIO
NUMERO num1=9121236, num2=735
NUMERO suma, multi, resta, divi
suma = num1 + num2

multi = num1 * num2
resta = num1 - num2
divi = num1 / num2
ESCRIBIR “La suma es ” + suma

ESCRIBIR “La multiplicación es ” + multi
ESCRIBIR “La resta es ” + resta
ESCRIBIR “La división es ” + divi
FIN
Etapa 04 - Desarrollo de la Codificación.
La codificación se desarrolla utilizando el lenguaje de programación Java.
Clase PrgOperaciones
package dominioDeLaAplicacion;
class PrgOperaciones {
// la ejecución empieza en main.

long num1=9121236, num2=735, suma, resta, multi;

double divi;
suma = num1 + num2;

resta = num1 – num2;
multi = num1 * num2;
divi = (double) (num1) / num2;
System.out.println (“La suma es: ” + suma);

System.out.println (“La resta es: ” + resta);
System.out.println (“La multiplicación es: ” + multi);
System.out.println (“La división es: ” + divi);
}
}
Pag. 109
Problema 03
Convertir y mostrar una cantidad de dinero, expresado en dólares, en su equivalente en

nuevos soles. Ingresar la cantidad en dólares y el tipo de cambio.
Resultado deseado: Mostrar el equivalente, en nuevos soles, de

una cantidad expresada en dólares.
Datos necesarios: El monto en dólares y el tipo de cambio.
Procesamiento: El monto en dólares y el tipo de cambio serán
ingresados por teclado y almacenados en dos
variables (dolares y tipo respectivamente).
Luego, se calculará el equivalente en nuevos
soles utilizando la siguiente operación:
soles = dolares * tipo
El resultado se almacenará en una variable

(soles) para luego ser mostrada por pantalla.

1. Nombre del Proyecto: ProyDolaresSoles.
2. Definición de Paquetes y desarrollo de Diagrama de Paquetes.
Diagrama de paquetes
Pag. 110
3. Definición de las Clases.
Clases Clases
dominioDeLaAplicacion biblioteca
Algoritmo PrgDolaresSoles - método main ( )
ENTRADA: dolares, tipo

SALIDA: soles
INICIO
NUMERO dolares, tipo, soles
LEER dolares, tipo
soles = dolares * tipo
ESCRIBIR soles
FIN
Pag. 111
Clase PrgDolaresSoles
import biblioteca.Lectura ;
class PrgDolaresSoles {
public static void main (String arg[]) {
double dolares, tipo, soles ;
System.out.print ( “ Ingrese una cantidad de dólares: ” ) ;

dolares = Lectura.leerDouble ( ) ;
System.out.print ( “ Ingrese tipo de cambio del dólar: ” ) ;

tipo = Lectura.leerDouble ( ) ;
soles = dolares * tipo ;

System.out.println ( “ Cantidad equivalente en soles es: ” + soles) ;
}
}
Pag. 112
Problema 04
Calcular la nota final que ha obtenido un alumno en el curso de programación

avanzada. Utilizar la siguiente fórmula: nf = (n1 + n2 + n3 + (n4 * 2)) / 5.
Ingresar las notas n1, n2, n3 y n4 a través del teclado.
Resultado deseado: Mostrar la nota final de un determinado

alumno.
Datos necesarios: Las notas del alumno (en este caso tenemos
4 notas).
Procesamiento: Las notas serán ingresadas por teclado y
almacenadas en variables (n1, n2, n3 y n4
respectivamente). Luego, se realizará el
cálculo de la nota final sobre la base de la
siguiente fórmula:
nf = ( n1 + n2 + n3 + ( n4 * 2) ) / 5

(nf) para luego ser mostrada por pantalla.

1. Nombre del Proyecto: ProyNotaFinal.
Pag. 113
Clases Clases
Algoritmo PrgNotaFinal - método main ( )
ENTRADA: n1, n2, n3, n4

SALIDA: 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
class PrgNotaFinal {
double n1 = 0, n2 = 0, n3 = 0, n4 = 0, nf = 0 ;
System.out.print ( “ Ingrese la nota 1 del alumno: ” ) ;

n1 = 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
Ingresar el sueldo de un obrero de la empresa “La Poderosa S.A.” y calcular su

respectivo descuento del 15% por concepto de impuestos y el 5% por concepto de
cafetería. Se deberá visualizar por pantalla el total de descuentos y el sueldo a cobrar.
Resultado deseado: Mostrar el total de descuento y el sueldo a

cobrar de un obrero de la empresa.
Datos necesarios: El sueldo total del obrero.
Procesamiento: El sueldo total será ingresado por teclado y
almacenado en una variable (sueldo). Luego,
se realizarán los cálculos del descuento y del
sueldo a cobrar del obrero, utilizando las
siguientes operaciones:
desc = sueldo * 0.2

pago = sueldo – desc
Los resultados se almacenarán en las

variables (desc y pago respectivamente) para
luego ser mostradas por pantalla.

1. Nombre del Proyecto: ProySueldoObrero.
Pag. 116
Clases Clases
Algoritmo PrgSueldoObrero - método main ( )
ENTRADA: sueldo
SALIDA: 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
class PrgSueldoObrero {
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
Convertir la temperatura de grados Celsius a grados Fahrenheit, de acuerdo a la

siguiente fórmula: F = (9/5) * C + 32.
Resultado deseado: Calcular y mostrar la temperatura en grados

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

(gradosFar) para luego ser mostrado por
pantalla.

1. Nombre del Proyecto: ProyTemperatura.
Pag. 119
Clases Clases
Algoritmo PrgTemperatura - método main ( )
ENTRADA: gradosCel
SALIDA: gradosFar
INICIO
NUMERO gradosCel = 0, gradosFar = 0
LEER gradosCel
gradosFar = ( 9 / 5 ) * gradosCel + 32
ESCRIBIR gradosFar
FIN
Pag. 120
Clase PrgTemperatura
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
Leer el costo de un artículo y su precio de venta. Calcular y mostrar su utilidad.
Resultado deseado: Calcular y mostrar la utilidad de un artículo.

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

(utilidad) para luego ser mostrado por
pantalla.

1. Nombre del Proyecto: ProyUtilidad.
Pag. 122
Clases Clases
Algoritmo PrgUtilidad - método main ( )
ENTRADA: costo, precioVta

SALIDA: utilidad
INICIO
NUMERO costo = 0, precioVta = 0, utilidad = 0
LEER costo, precioVta
utilidad = precioVta - costo
ESCRIBIR utilidad
FIN
Pag. 123
Clase PrgUtilidad
class PrgUtilidad {
double costo = 0, precioVta = 0, utilidad = 0 ;
System.out.print ( “ Ingrese el costo del artículo: ” ) ;

costo = Lectura.leerDouble ( ) ;
System.out.print ( “ Ingrese el precio de venta del artículo: ” ) ;

precioVta = Lectura.leerDouble ( ) ;
utilidad = precioVta - costo ;
System.out.println ( “ La utilidad del artículo es: s/. ” + utilidad + “ soles ” ) ;
Pag. 124
Problema 08
Calcular y mostrar la nota final (nf) de un alumno, sabiendo que se tienen sólo dos
notas. Si el alumno obtiene una nota final mayor a 13 se deberá visualizar un mensaje
de felicitaciones.
Resultado deseado: Mostrar nota final y un mensaje de

felicitaciones si la nota final es mayor a 13.
Datos necesarios: Las dos notas del alumno.
Procesamiento: Las notas se ingresarán por el teclado y serán
almacenadas en variables (nota1 y nota2),
luego se realizará el cálculo de la nota final:
nf = ((nota1 + nota2) / 2)
El resultado se almacena en una variable (nf).

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.

1. Nombre del Proyecto: ProyNotaFinal2.
Pag. 125
Clases Clases
Algoritmo PrgNotaFinal2 - método main ( )
ENTRADA: nota1, nota2

SALIDA: nf, mensaje
INICIO
NUMERO nota1 = 0, nota2 = 0, nf = 0
TEXTO mensaje = “ ”
LEER nota1, nota2
nf = (nota1 + nota2) / 2
SI ( nf > 13 )
ENTONCES
mensaje = “Felicitaciones”
FINSI
ESCRIBIR nf, mensaje
FIN
Pag. 126
Clase PrgNotaFinal2
class PrgNotaFinal2 {
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
Calcular y mostrar el sueldo de un trabajador conociendo el número de horas

trabajadas y su tarifa horaria, sabiendo que se debe descontar un 10% del sueldo por
concepto de impuestos si este es mayor de S/. 3000.
Resultado deseado: Mostrar el sueldo de un trabajador.

Datos necesarios: El total de horas trabajadas y la tarifa horaria.
Procesamiento: El total de horas trabajadas y la tarifa horaria
se ingresarán por teclado y se almacenarán
en variables (horas y tarifa), luego se
realizará el cálculo del sueldo utilizando la
siguiente operación:
sueldo = horas * tarifa

(sueldo). Si el sueldo resulta mayor que
S/.3000 entonces se calcula el sueldo a
cobrar restando el 10% del sueldo. El
resultado se almacena en la variable sueldo y
se muestra a través de la pantala.

1. Nombre del Proyecto: ProySueldoTrabajador.
Pag. 128
Clases Clases
Algoritmo PrgSueldoTrabajador - método main ( )
ENTRADA: horas, tarifa

SALIDA: 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
class PrgSueldoTrabajador {
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
Calcular y mostrar el monto total a pagar por la compra de varios artículos si se tiene
que agregar el IGV (Impuesto General a las Ventas). En caso que el monto total a
pagar incluido IGV sea mayor a S/.500 nuevos soles se aplica un descuento de 8%,
caso contrario el descuento será de 2%.
Resultado deseado: Mostrar monto total a pagar.

Datos necesarios: Monto total.
Procesamiento: El monto total será almacenado en una
variable (montoTotal). Se asume que el IGV
es 18%. Luego se realizará el cálculo del
monto total a pagar (monto total * 1.18) y se
almacena en una variable (montoPago). Si el
monto total resulta mayor a S/.500 nuevos
soles, se descuenta el 8%, sino sólo se
descontará el 2%.

1. Nombre del Proyecto: ProyArticulos.
Pag. 131
Clases Clases
Algoritmo PrgArticulos - método main ( )
ENTRADA: montoTotal
SALIDA: 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
class PrgArticulos {
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
Leer la categoría y el sueldo de un trabajador, y calcular el aumento correspondiente

teniendo en cuenta la siguiente tabla. Muestrar el nuevo sueldo del trabajador.
Categoría Aumento
1 25 %
2 15 %
3 10 %
4 05 %
Resultado deseado: Mostrar nuevo sueldo del trabajador.

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

1. Nombre del Proyecto: ProyAumentoSueldo.
Pag. 134
Clases Clases
Algoritmo PrgAumentoSueldo - método main ( )
ENTRADA: categoria, sueldo

SALIDA: nuevoSueldo
INICIO
NUMERO categoria = 0, sueldo = 0, nuevoSueldo = 0
LEER sueldo, categoria
CUANDO categoria SEA

CASO 1 :
nuevoSueldo = sueldo * 1.25
TERMINAR
CASO 2 :
TERMINAR
CASO 3 :
TERMINAR
CASO 4 :
TERMINAR
OTROS :
nuevoSueldo = sueldo
FINCUANDO
ESCRIBIR nuevoSueldo
FIN
Pag. 135
Clase PrgAumentoSueldo
class PrgAumentoSueldo {

double sueldo = 0, nuevoSueldo = 0 ;
int categoria = 0;
System.out.print ( “ Ingrese el sueldo del trabajador: ” ) ;

System.out.print ( “ Ingrese la categoría del trabajador: ” ) ;

categoria = Lectura.leerInt ( ) ;
switch (categoria) {
case 1:
nuevoSueldo = sueldo * 1.25 ;
break ;
case 2:
break ;
case 3:
break ;
case 4:
break ;
default:
nuevoSueldo = sueldo ;
}
System.out.println ( “ El nuevo sueldo del trabajador es: ” + nuevoSueldo ) ;

}
}
Pag. 136
Problema 12
Calcular y mostrar el costo total que representa un paciente para un hospital de

acuerdo al tipo de enfermedad, según los datos de la tabla. Adicionalmente deberá
considerarse que las mujeres tienen un incremento del 10% para el primer tipo de
enfermedad y los hombres tienen un aumento del 5% para el tercer tipo de enfermedad.
Enfermedad Tipo Costo / Paciente / Día

1 200
2 350
3 420
Resultado deseado: Mostrar el costo total de un paciente para un

hospital.
Datos necesarios: El tipo de enfermedad, el número de días de
permanencia del paciente y su sexo.
Procesamiento: El tipo de enfermedad, el número de días y el
sexo (1 si es hombre y 2 si es mujer) del
paciente se almacenarán en variables
(tipoEnfermedad, dias y sexo).
Dependiendo del tipo de enfermedad, se

procederá hacer el cálculo del costo que
representa para el hospital el paciente, de
acuerdo a la siguiente operación
costoTotal = ( costo * número de días).
Si se trata del primer tipo de enfermedad y el

paciente es mujer se le incrementará el 10%.
Por otro lado, si se trata del tercer tipo de
enfermedad y el paciente es hombre se
procederá a incrementar el 5%. El resultado
se almacena en una variable (costoTotal)
para luego ser mostrado.
Pag. 137

1. Nombre del Proyecto: ProyHospital.
Clases Clases
Pag. 138
Algoritmo PrgHospital - método main ( )
ENTRADA: tipoEnfermedad, dias, sexo

SALIDA: 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 :
TERMINAR
CASO 3 :
SI ( sexo = 1 )
ENTONCES
costoTotal = costoTotal * 1.05
FINSI
FINCUANDO
ESCRIBIR costoTotal
FIN
Pag. 139
Clase PrgHospital
class PrgHospital {

int tipoEnfermedad = 0, dias = 0, sexo = 0 ;
double costoTotal = 0 ;
System.out.print ( “ Ingrese el tipo de enfermedad: ” ) ;

tipoEnfermedad = Lectura.leerInt ( ) ;
System.out.print ( “ Ingrese el sexo del paciente [1=hombre, 2= Mujer]: ” ) ;
sexo = Lectura.leerInt ( ) ;
System.out.print ( “ Ingrese el número de días que ha estado el paciente: ” ) ;
dias = Lectura.leerInt ( ) ;
switch ( tipoEnfermedad) {
case 1 :
costoTotal = 200 * dias ;
if ( sexo == 2 ) {
costoTotal = costoTotal * 1.10 ;
}
break ;
case 2 :
break ;
case 3 :
if ( sexo == 1 ) {
costoTotal = costoTotal * 1.05 ;
}
}
System.out.println ( “ El costo total es: ” + costoTotal ) ;

}
}
Pag. 140
Problema 13

Ingresar tres notas de un alumno. Muestrar las notas ordenadas en forma ascendente.
Resultado deseado: Mostrar las tres notas en forma ascendente.

Datos necesarios: Las tres notas del alumno en cualquier orden.
Procesamiento: Las tres notas del alumno serán almacenadas
en variables (n1, n2 y n3). Se utilizarán tres
variables auxiliares para almacenar el orden
de las notas (menor, intermedio y mayor).
Finalmente, las variables auxiliares mayor,
intemedio y menor almacenarán las notas y
se mostrarán en orden ascendente.
1. Nombre del Proyecto: ProyOrdena.

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

Clases Clases
Pag. 141
Algoritmo PrgOrdena - método main ( )
ENTRADA: n1, n2, n3

SALIDA: menor, intermedio, mayor
INICIO
NUMERO n1 = 0, n2 = 0, n3 = 0, menor = 0, intermedio = 0

NUMERO mayor = 0
LEER n1, n2, n3
SI (n1 > n2)
ENTONCES
SI (n1 > n3)
ENTONCES
mayor = n1
SI (n2 > n3)

ENTONCES
intermedio = n2
menor = n3
SINO
intermedio = n3
menor = n2
FINSI
SINO
mayor = n3
intermedio = n1
menor = n2
FINSI
SINO
SI (n2 > n3)

ENTONCES
mayor = n2
SI (n1 > n3)

ENTONCES
intermedio = n1
menor = n3
SINO
intermedio = n3
menor = n1
FINSI
SINO
mayor = n3
intermedio = n2
menor = n1
FINSI
FINSI
ESCRIBIR menor, intermedio, mayor
FIN
Pag. 142
Clase PrgOrdena
class PrgOrdena {

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: ” ) ;
System.out.print ( “ Ingrese la tercera nota: ” ) ;
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
Un curso se evalúa de la siguiente forma: se toma cinco prácticas calificadas, se

determina el promedio de las cuatro notas más altas y se le da al estudiante una
categoría que puede ser A, B, C o D. Según la siguiente tabla:
Rango Categoria
Desde 17 a 20 A
Desde 14 a 16 B
Desde 10 a 13 C
Desde 00 a 09 D
Determinar la categoría del alumno.
Resultado deseado: Mostrar la categoría del alumno.
Datos necesarios: Las cinco notas del estudiante.
Procesamiento: Las cinco notas del estudiante se ingresan a

través del teclado y se almacenan en
variables (n1, n2, n3, n4 y n5). La menor de
estas notas se guardará en una variable
(notaMenor). La suma de las cinco notas se
guardará en una variable (sumaNotas). Se
realizará el cálculo del promedio del alumno
de la siguiente forma:
promedio = ( sumaNotas – notaMenor ) / 4 ).
El resultado es almacenado en la variable

(promedio), este resultado nos permitirá
obtener la categoría del alumno (categoria),
para luego ser mostrada por pantalla.
Pag. 144
1. Nombre del Proyecto: ProyCategoriaAlumno.
Clases Clases
Pag. 145
Algoritmo PrgCategoriaAlumno - método main ( )
ENTRADA: n1, n2, n3, n4, n5

SALIDA: categoria
INICIO
NUMERO n1 = 0, n2 = 0, n3 = 0, n4 = 0, n5 = 0, sumaNotas = 0
NUMERO notaMenor = 0, promedio = 0
TEXTO categoria = ‘ ’
LEER n1, n2, n3, n4, n5
sumaNotas = n1 + n2 + n3 + n4 + n5
notaMenor = n1
SI (notaMenor>n2) ENTONCES
notaMenor = n2
FINSI
SI (notaMenor > n3) ENTONCES
notaMenor = n3
FINSI
notaMenor = n4
FINSI
notaMenor = n5
FINSI
promedio = (sumaNotas - notaMenor) / 4
SI (promedio <= 20 AND promedio >= 17)
ENTONCES
categoria = ‘A’
SINO
ENTONCES
categoria = ‘B’
SINO
ENTONCES
categoria = ‘C’
SINO
SI (promedio<=10 AND promedio>=0)
ENTONCES
categoria = ‘D’
FINSI
FINSI
FINSI
FINSI
ESCRIBIR categoria
FIN
Pag. 146
Clase PrgCategoriaAlumno
class PrgCategoriaAlumno {
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: ” ) ;

System.out.print ( “ Ingrese la 2da. nota: ” ) ;
System.out.print ( “ Ingrese la 3ra. nota: ” ) ;
System.out.print ( “ Ingrese la 4ta. nota: ” ) ;
System.out.print ( “ Ingrese la 5ta. nota: ” ) ;
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 {
categoria = ‘B’ ;
} else {
categoria = ‘C’ ;
} else {
categoria = ‘D’ ;
}
}
}
}
System.out.println ( “ La categoría del alumno es: ” + categoria ) ;
}
}
Pag. 147
Problema 15
En una oficina de empleados, categorizan a los postulantes en función del sexo y de la

edad, de acuerdo a lo siguiente:
- Si la persona es de sexo femenino:
o Categoría FA si tienen menos de 23 años.
o Categoría FB en caso contrario.
- Si la persona es de sexo masculino:
o Categoría MA si tiene menos de 25 años.
o Categoría MB en caso contrario.
Resultado deseado: Mostrar la categoría del postulante.

Datos necesarios: El sexo y la edad del postulante.
Procesamiento: El sexo y la edad del postulante se ingresan a
variables (sexo y edad). Si es hombre o
mujer asignaremos su respectiva categoría
dependiendo de la edad del postulante.
El resultado es almacenado en una variable

(categoria) para luego ser mostrada por
pantalla.
1. Nombre del Proyecto: ProyCategoriaPostulante.
Pag. 148
Clases Clases
Algoritmo PrgCategoriaPostulante - método main ( )
ENTRADA: sexo, edad

SALIDA: categoria
INICIO
NUMERO edad = 0
TEXTO sexo = ‘F’, categoria = 0
LEER sexo, edad

CUANDO sexo SEA
CASO ‘f’:
CASO ‘F’:
SI (edad < 23) ENTONCES
categoria = “FA”
SINO
categoria = “FB”
FINSI
TERMINAR
CASO ‘m’:
CASO ‘M’:
SI (edad < 25) ENTONCES
categoria = “MA”
SINO
categoria = “MB”
FINSI
FINCUANDO
ESCRIBIR categoria
FIN
Pag. 149
Clase PrgCategoriaPostulante
class PrgCategoriaPostulante {
int edad = 0 ;
char sexo = ‘F’ ;
String categoria = “ ” ;
System.out.print ( “ Ingrese sexo del postulante [ F/M ]: ” ) ;

sexo = Lectura.leerChar ( ) ;
System.out.print ( “ Ingrese la edad del postulante: ” ) ;

edad = Lectura.leerInt ( ) ;
switch (sexo) {
case ‘f’ :
case ‘F’ :
if (edad < 23)
categoria = “FA” ;
else
categoria = “FB” ;
break ;
case ‘m’ :
case ‘M’ :
if (edad < 25)
categoria = “MA” ;
else
categoria = “MB” ;
}
System.out.println ( “ La categoría del postulante es: ” + categoria ) ;
}
}
Pag. 150
Problema 16
Calcular la nota final de todos los alumnos del curso utilizando la siguiente fórmula:
nf = ( n1 + n2 + n3 + ( n4 * 2 ) ) / 5
Ingresar las notas a través del teclado. Utilizar la estructura lógica MIENTRAS.
Resultado deseado: Mostrar la nota final de todos los alumnos de

un curso.
Datos necesarios: Las cuatro notas de cada uno de los alumnos
del curso.
Procesamiento: Las cuatro notas del alumno se ingresan a
variables (n1, n2, n3 y n4). Se realizará el
cálculo de la nota final en base a la fórmula:
nf = ( n1 + n2 + n3 + ( n4 * 2 ) ) / 5.

(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.
1. Nombre del Proyecto: ProyNotasAlumnos.
Pag. 151
Clases Clases
Algoritmo PrgNotasAlumnos - método main ( )
ENTRADA: numAlumnos, n1, n2, n3, n4

SALIDA: nf
INICIO
NUMERO i = 1, n1 = 0, n2 = 0, n3 = 0, n4 = 0, nf = 0
NUMERO numAlumnos = 1
LEER numAlumnos
MIENTRAS ( i <= numAlumnos )
LEER n1, n2, n3, n4
nf = ( n1 + n2 + n3 + ( n4 * 2 ) ) / 5
ESCRIBIR nf
i=i+1
FINMIENTRAS
FIN
Pag. 152
Clase PrgNotasAlumnos
class PrgNotasAlumnos {
int i = 1, numAlumnos = 0 ;
double n1= 0, n2 = 0, n3 = 0, n4 = 0, nf = 0 ;
System.out.println ( “Ingrese el número de alumnos: ” ) ;

numAlumnos = Lectura.leerInt ( ) ;
while ( i <= numAlumnos ) {
System.out.println ( “ Ingrese nota 1 del alumno [” + i + “]: ” ) ;




nf = ( n1 + n2 + n3 + ( n4 * 2 ) ) / 5 ;
System.out.println ( “ Nota final del alumno [” + i + “]: ” + nf ) ;
i ++ ;
}
}
}
Pag. 153
Problema 17
Calcular la nota final de todos los alumnos del curso utilizando la siguiente fórmula:
nf = ( n1 + n2 + n3 + ( n4 * 2 ) ) / 5.
Ingresar las notas a través del teclado. Utilizar la estructura lógica HACER.
Resultado deseado: Mostrar la nota final de todos los alumnos de

un curso.
del curso.
Procesamiento: Las cuatro notas del alumno se ingresan a
variables (n1, n2, n3 y n4). Se realizará el
cálculo de la nota final sobre la base de la
fórmula:
nf = ( n1 + n2 + n3 + ( n4 * 2 ) ) / 5.

(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.
1. Nombre del Proyecto: ProyNotasAlumnos2.
Pag. 154
Clases Clases
Algoritmo PrgNotasAlumnos2 - método main ( )
ENTRADA: n1, n2, n3, n4, continua

SALIDA: nf
INICIO
NUMERO i = 1, n1 = 0, n2 = 0, n3 = 0, n4 = 0, nf = 0
TEXTO continua = ‘ ’
HACER
LEER n1, n2, n3, n4
nf = ( n1 + n2 + n3 + ( n4 * 2 ) ) / 5
ESCRIBIR nf
LEER continua
i=i+1
MIENTRAS ( continua = ‘s’ OR continua = ‘S’ )
FIN
Pag. 155
Clase PrgNotasAlumnos2
class PrgNotasAlumnos2 {
int i = 1 ;
double n1 = 0, n2 = 0, n3 = 0, n4 = 0, nf = 0 ;
char continua = ‘ ’ ;
do {




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
Determinar la suma de sueldos de los obreros (categoría 1), la suma de sueldos de los
empleados (categoría 2) y la suma de sueldos de los gerentes (categoría 3) de una
determinada empresa. Adicionalmente, determinar cuál es el mayor y el menor sueldo
en la empresa.
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.
Datos necesarios: El sueldo y la categoría de cada uno de los
trabajadores de la empresa.
Procesamiento: El sueldo y la categoría de cada trabajador de
la empresa se ingresarán a través del teclado
y se almacenarán en las variables sueldo y
categoria. Cada vez que se ingrese el sueldo
de un trabajador se deberá verificar si es el
sueldo mayor. Si el sueldo ingresado resulta
ser el sueldo mayor, se almacenará en la
variable mayorSueldo. De igual forma, se
verificará si es el sueldo menor. Si el sueldo
ingresado resulta ser el sueldo menor, se
almacenará en la variable menorSueldo.
También se evaluará la categoría del

trabajador. Si resulta ser un obrero se suma
su sueldo a la variable sueldo1, si resulta ser
un empleado se suma su sueldo a la variable
sueldo2 y si resulta ser un gerente se suma
su sueldo a la varaiable sueldo3. Al finalizar
el ingreso de los datos de todos los
trabajadores de la empresa, se mostrará por
pantalla el sueldo mayor (mayorSueldo), el
sueldo menor (menorSueldo), la suma de
sueldos de los obreros (sueldo1), la suma de
sueldo de los empleados (sueldo2) y la suma
de los sueldos de los gerentes (sueldo3).
Pag. 157
1. Nombre del Proyecto: ProySueldoCategoria.
Clases Clases
Pag. 158
Algoritmo PrgSueldoCategoria - método main ( )
ENTRADA: sueldo, categoria

SALIDA: sueldo1, sueldo2, sueldo3, mayorSueldo, menorSueldo
INICIO
NUMERO sueldo = 0, categoria = 0, mayorSueldo = 0

NUMERO menorSueldo = 0, sueldo1 = 0, sueldo2 = 0
NUMERO sueldo3 = 0, i = 1
HACER
LEER categoria
SI (categoria <> 0) ENTONCES

LEER sueldo
SI (i = 1)
ENTONCES
i=0
mayorSueldo = sueldo
menorSueldo = sueldo
SINO
SI ( sueldo < menorSueldo )
ENTONCES
menorSueldo = sueldo
FINSI
SI (sueldo > mayorSueldo)

ENTONCES
mayorSueldo = sueldo
FINSI
FINSI
CUANDO categoria SEA

CASO 1:
sueldo1 = sueldo1 + sueldo
TERMINAR
CASO 2:
TERMINAR
CASO 3:
FINCUANDO
FINSI
MIENTRAS ( categoria <> 0 )
ESCRIBIR sueldo1, sueldo2, sueldo3

ESCRIBIR menorSueldo, mayorSueldo
FIN
Pag. 159
Clase PrgSueldoCategoria
class PrgSueldoCategoria {

int i = 1, categoria = 0 ;
double sueldo = 0, mayorSueldo = 0, menorSueldo = 0 ;
double sueldo1 = 0, sueldo2 = 0, sueldo3 = 0 ;
do {
System.out.println ( “ Ingrese la categoría del trabajador : ” ) ;
categoria = Lectura.leerInt ( ) ;
if ( categoria != 0 ) {
System.out.println ( “ Ingrese el sueldo del trabajador : ” ) ;
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:
break ;
case 3:
}
}
} while (categoria != 0 ) ;
System.out.println ( “ Suma de sueldos de obreros: ” + sueldo1 ) ;

System.out.println ( “ Suma de sueldos de empleados: ” + sueldo2 ) ;
System.out.println ( “ Suma de sueldos de gerentes: ” + sueldo3 ) ;
System.out.println ( “ El sueldo más bajo es: ” +menorSueldo ) ;
System.out.println ( “ El sueldo más alto es: ” + mayorSueldo ) ;
}
}
Pag. 160
Problema 19
Calcular y mostrar el número de alumnos que tienen promedio final menor que 10, los
alumnos que tiene promedio final entre 10 y 14, los alumnos que tienen promedio final
entre 15 y 18, y los alumnos que tienen promedio final mayor que 18. Ingresar las 4
notas de cada alumno y calcular su promedio final en base a la siguiente fórmula:
nf = ( n1 + n2 + n3 + ( n4 * 2 ) ) / 5.
Resultado deseado: Mostrar el número de alumnos con promedio

final menor que 10, el número de alumnos
con promedio final entre 10 y 14, el número
de alumnos con promedio final entre 15 y 18,
y el número de alumnos con promedio final
mayor que 18.
del curso.
Procesamiento: Las cuatro notas del alumno se ingresan y se
almacenan en las variables n1, n2, n3 y n4.
Se realiza el cálculo del promedio final en
base a la fomula:
nf = ( n1 + n2 + n3 + ( n4 * 2 ) ) / 5.
El resultado es almacenado en la variable nf,

para ser evaluada. Si el promedio final (nf) es
menor que 10 se aumenta 1 a la variable
total1. Si el promedio final (nf) está entre 10 y
14 se aumenta 1 a la variable total2. Si el
promedio final (nf) está entre 15 y 18 se
aumenta 1 a la variable total3 y si el
promedio final (nf) es mayor que 18 se
aumenta 1 a la variable total4.
Este proceso se repite para todos los alumnos

del curso con la finalidad de determinar su
promedio final (nf) y evaluar su rango.
Pag. 161
1. Nombre del Proyecto: ProyNotasRango.
Clases Clases
Pag. 162
Algoritmo PrgNotasRango - método main ( )
ENTRADA: numAlumnos, n1, n2, n3, n4

SALIDA: total1, total2, total3, total4
INICIO
NUMERO n1 = 0, n2 = 0, n3 = 0, n4 = 0, nf = 0, numAlumnos = 0
NUMERO i = 1, total1 = 0 , total2 = 0 , total3 = 0 , total4 = 0
LEER numAlumnos
MIENTRAS ( i <= numAlumnos )
HACER
LEER n1
MIENTRAS (n1 < 0 OR n1> 20)
HACER
LEER n2
MIENTRAS (n2 < 0 OR n2 > 20)
HACER
LEER n3
HACER
LEER n4
nf = (n1 + n2 + n3 + ( n4 * 2 ) ) / 5
SI (nf < 10.5)

ENTONCES
total1 = total1 + 1
FINSI
SI (nf >= 10.5 AND nf < 14.5)
ENTONCES
total2 = total2 + 1
FINSI
SI (nf >= 14.5 AND nf < 17.5)
ENTONCES
total3 = total3 + 1
FINSI
SI (nf >= 17.5)
ENTONCES
total4 = total4 + 1
FINSI
i=i+1
FINMIENTRAS
ESCRIBIR total1, total2, total3, total4
FIN
Pag. 163
Clase PrgNotasRango
class PrgNotasRango {

int i = 1, numAlumnos = 0 ;
double n1= 0, n2= 0, n3= 0, n4= 0, nf= 0, total1 = 0, total2 = 0, total3 = 0, total4 = 0 ;
System.out.println ( “ Ingrese el número de alumnos: ” ) ;

numAlumnos = Lectura.leerInt ( ) ;
while (i <= numAlumnos) {
do {
System.out.println ( “ Ingrese nota 1 del alumno [” + i + “]: ”);
} while ((n1 < 0 || n1 > 20) ;
do {
} while ((n2 < 0 || n2 > 20) ;
do {
} while (( n3 < 0 || n3 > 20 ) ;
do {
} 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
Elaborar una solución que permita controlar la venta de boletos en un determinado día en un
teatro de la capital, en base a la siguiente información:
• Al comenzar, se leerá una sola vez el precio de entrada para palco, platea y
mezanine.
• Por cada entrada vendida se leerá los siguientes datos: número de boleto y lugar
(puede ser platea, palco o mezanine).
• El programa terminará cuando el número de boleto sea igual a cero.
• Antes de finalizar, se deberá proporcionar la siguiente información:
• Número total de entradas vendidas durante el día.
• El total de soles recaudados en el día.
• Número de entradas vendidas para platea, palco y mezanine en el día.
Resultado deseado: El número total de entradas vendidas, el

monto total recaudado y el número de
entradas vendidas para platea, palco y
mezanine en un determinado día.
Datos necesarios: El costo del boleto para platea, palco y
mezanine en general, y por cada venta, el
número de boleto y el tipo de boleto (es decir,
si es para platea, palco o mezanine).
Procesamiento: El costo del boleto para platea, palco y
mezanine se ingresarán a través del teclado y
se almacenarán en las variables costoPla,
costoPal y costoMez respectivamente.
Cada vez que se venda un boleto se

ingresará el número y tipo de boleto, y se
almacenarán en las variables numBoleto y
tipo respectivamente. Luego se evaluará el
tipo de boleto. Si es un boleto para platea se
aumenta 1 a la variable totalPla, si es un
boleto para palco se aumenta 1 a la variable
totalPal y si es un boleto para mezanine se
aumenta 1 a la variable totalMez.
Al finalizar la venta de boletos se suma el
valor de las variables totalPla, totalPal y
totalMez para obtener el total de boletos
vendidos (totalVendidas). De igual forma,
cada variable (totalPla, totalPal y totalMez)
se multiplica por el costo del boleto
(costoPla, costoPal y costoMez) según
corresponda, para obtener la ganancia en
Pag. 165
platea (gananciaPla), palco (gananciaPal) y

mezanine (gananciaMez).
La ganancia total (totalGanancia) se obtiene
al sumar el valor de las variables ganaciaPla,
gananciaPal y gananciaMez.
1. Nombre del Proyecto: ProyTeatro.
Clases Clases
Pag. 166
Algoritmo PrgTeatro - método main ( )
ENTRADA: costoPla, costoPal, costoMez

SALIDA: totalVendidas, totalGanancia, totalPla, totalPal, totaMez
INICIO
NUMERO numBoleto = 0, tipo = 0, totalVendidas = 0

NUMERO totalPla = 0, totalPal = 0, totalMez = 0
NUMERO costoPla = 0, costoPal = 0, costoMez = 0
NUMERO totalGanancia =0, gananciaPla = 0, gananciaPal = 0
NUMERO ganaciaMez = 0
LEER costoPla, costoPal, costoMez
HACER
HACER
LEER numBoleto
MIENTRAS ( numBoleto < 0)
SI ( numBoleto <> 0 )
ENTONCES
HACER
LEER tipo
MIENTRAS (tipo < 1 OR tipo >3)
CUANDO tipo SEA

CASO 1 :
totalPla = totalPla + 1
TERMINAR
CASO 2
totalPal = totalPal + 1
TERMINAR
CASO 3
totalMez = totalMez + 1
FINCUANDO
MIENTRAS (numBoleto <> 0)
totalVendidas = totalPla + totalPal + totalMez

ganaciaPla = totalPla * costoPla
ganaciaPal = totalPal * costoPal
ganaciaMez = totalMez * costoMez
totalGanancia = gananciaPla + gananciaPal + gananciaMez
ESCRIBIR totalVendidas
ESCRIBIR totalGanancia
ESCRIBIR totalPla, totalPal, totalMez
FIN
Pag. 167
Clase PrgTeatro
class PrgTeatro {

int numBoleto = 0, tipo = 0, totalVendidas = 0, totalPla=0, totalPal=0, totalMez=0 ;
double totalGanancia=0, costoPla = 0, costoPal = 0, costoMez = 0 ;
double gananciaPla = 0, gananciaPal = 0, ganaciaMez = 0 ;
System.out.println ( “ Ingrese el costo de la entrada para platea: ” ) ;

costoPla = Lectura.leerDouble ( ) ;
System.out.println ( “ Ingrese el costo de la entrada para palco: ” ) ;
costoPal = Lectura.leerDouble ( ) ;
System.out.println ( “ Ingrese el costo de la entrada para mezanine: ” ) ;
costoMez = Lectura.leerDouble ( ) ;
do {
do {
System.out.println ( “ Ingrese el número de boleto: ” ) ;
numBoleto = Lectura.leerInt ( ) ;
} while (numBoleto < 0) ;
if ( numBoleto != 0) {
do {
System.out.println ( “ Ingrese el lugar ” ) ;
System.out.println ( “ [1] Platea, [2] Palco [3] Mezanine ” ) ;
tipo = Lectura.leerInt ( ) ;
} while (tipo < 1 || tipo > 3) ;
switch ( tipo) {
case 1 :
totalPla ++ ; break ;
case 2 :
totalPal ++ ; break ;
case 3 :
totalMez ++ ;
}
}
} while ( numBoleto != 0 ) ;
totalVendidas = totalPla + totalPal + totalMez ;

ganaciaPla = totalPla * costoPla ;
ganaciaPal = totalPal * costoPal ;
ganaciaMez = totalMez * costoMez ;
totalGanancia = gananciaPla + gananciaPal + gananciaMez ;
System.out.println ( “ Número total de entradas: ” + totalVendidas ) ;
System.out.println ( “ Total recaudado S/. ” + totalGanancia ) ;
System.out.println ( “ Total vendidas platea: ” + totalPla ) ;
System.out.println ( “ Total vendidas palco: ” + totalPal ) ;
System.out.println ( “ Total vendidas mezanine: ” + totalMez ) ;
}
}
Pag. 168
Problema 21
Los empleados de una fábrica trabajan en tres turnos; mañana, tarde y noche. Se
desea calcular el jornal diario de cada empleado teniendo en cuenta lo siguiente:
- La tarifa del turno mañana y tarde es de S/ 8.00 soles por hora.

- La tarifa del turno noche es de S/ 10.00 soles por hora.
- En caso de ser un día domingo, la tarifa se incrementa en 50% para los turnos
mañana y tarde y en 60% para el turno noche.
- Para el turno tarde se incrementa S/ 10.00 soles por concepto de movilidad.
Resultado deseado: Calcular y mostrar el jornal diario de cada

empleado.
Datos necesarios: El número de horas, el turno y el día que
trabajó el empleado.
Procesamiento: El número de horas, el turno y el día del
empleado se ingresan a través del teclado y
se almacenan en variables (horas, turno y
dia). Dependiendo del turno se obtiene la
tarifa para luego hacer el cálculo del jornal de
la siguiente forma:
jornal = horas * tarifa ;
El resultado es almacenado en una variable

(jornal) para luego ser mostrada por pantalla.
Este proceso se repite para cada uno de los

empleados de la fábrica.
Pag. 169
1. Nombre del Proyecto: ProyJornal.
Clases Clases
Pag. 170
Algoritmo PrgJornal - método main ( )
ENTRADA: numEmpleados, horas, turno, dia

SALIDA: jornal
INICIO
NUMERO numEmpleados = 0, i = 0, horas = 0, dia = 0, turno = 0
NUMERO tarifa = 0, jornal = 0
HACER
LEER numEmpleados
SI (numEmpleados <= 0) ENTONCES
ESCRIBIR “ Número empleados mayor a 0. ”
FINSI
MIENTRAS (numEmpleados <= 0)
MIENTRAS (i < numEmpleados)
i=i+1
HACER
LEER horas
SI (horas <= 0) ENTONCES
ESCRIBIR “ Número horas mayor a 0. ”
FINSI
MIENTRAS (horas <= 0)
HACER
LEER dia
SI (dia < 1 OR dia > 7)
ENTONCES
ESCRIBIR “ La opción no es válida. ”
FINSI
MIENTRAS (dia < 1 OR dia > 7)
HACER
LEER turno
CUANDO turno SEA:
CASO 1:
CASO 2:
SI (dia = 7)
ENTONCES
tarifa = 1.5 * 8
SINO
tarifa = 8
FINSI
TERMINAR
CASO 3:
SI (dia = 7)
ENTONCES
tarifa = 1.6 * 10
SINO
tarifa = 10
FINSI
TERMINAR
OTROS
ESCRIBIR “opción no válida”
FINCUANDO
MIENTRAS (turno <>1 AND turno <>2 AND turno <>3)
Pag. 171
Continúa… 4. Diseño de algoritmo para el método principal.
Algoritmo PrgJornal - método main ( )
SI (turno = 2)
ENTONCES
jornal = horas * tarifa + 10
SINO
jornal = horas * tarifa
FINSI
ESCRIBIR jornal
FINMIENTRAS
FIN
Clase PrgJornal
class PrgJornal {
int numEmpleados = 0, i = 0, horas = 0, dia = 0, turno = 0 ;

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

}
}
}
Pag. 173
Problema 22
Desarrollar una solución que permita obtener la siguiente información en un salón de

clase:
¿Cuántas alumnas están matriculadas en el curso?
¿Cuántos alumnos están matriculados en el curso?
¿Cuántas alumnas son menores de 20 años?
¿Cuántos alumnos son mayores de 18 años?
¿Cuántos alumnos están aprobados?
¿Cuántas alumnas están desaprobadas?
Resultado deseado: Número de alumnas matriculadas, menores

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

SALIDA: matriculadas, matriculados, menores, mayores, desaprobadas,
aprobados
INICIO
NUMERO i = 0, edad = 0, nota = 0, matriculadas = 0, matriculados = 0

NUMERO menores = 0, mayores = 0, desaprobadas = 0, aprobados = 0
TEXTO sexo = ‘F’, rpta = ‘ ’
HACER
i=i+1
HACER
LEER sexo
SI ( sexo <> ‘f’ AND sexo <> ‘F’ AND sexo <> ‘m’ AND sexo<> ‘M’ )
ENTONCES
ESCRIBIR “ El sexo no es válido. ”
FINSI
MIENTRAS ( sexo<> ‘f’ AND sevo<> ‘F’ AND sexo<> ‘m’ AND sexo<> ‘M’ )
HACER
LEER edad
SI (edad <= 0)
ENTONCES
ESCRIBIR “ La edad no es válida. ”
FINSI
MIENTRAS (edad <= 0)
HACER
LEER nota
SI (nota < 0 OR nota > 20)
ENTONCES
ESCRIBIR “ La nota no es válida. ”
FINSI
MIENTRAS (nota < 0 OR nota > 20)
CUANDO sexo SEA:
CASO ‘f’:
CASO ‘F’:
matriculadas = matriculadas + 1
SI (edad < 20)
ENTONCES
menores = menores + 1
FINSI
SI (nota < 11)
ENTONCES
desaprobadas = desaprobadas + 1
FINSI
TERMINAR
Pag. 176
Algoritmo PrgClase - método main ( )
CASO ‘m’:
CASO ‘M’:
matriculados = matriculados + 1
SI (edad > 18)

ENTONCES
mayores = mayores + 1
FINSI
SI (nota > 10)

ENTONCES
aprobados = aprobados + 1
FINSI
FINCUANDO
HACER
ESCRIBIR “¿Desea continuar[S/N]? ”
LEER rpta
SI ( rpta <> ‘s’ AND rpta <> ‘S’ AND rpta <> ‘n’ AND rpta <> ‘N’ )
ENTONCES
ESCRIBIR “ La opción no es válida. ”
FINSI
MIENTRAS ( rpta <> ‘s’ AND rpta <> ‘S’ AND rpta <> ‘n’ AND rpta <> ‘N’ )
MIENTRAS ( rpta <> ‘s’ OR rpta <> ‘S’ )
ESCRIBIR matriculadas
ESCRIBIR matriculados
ESCRIBIR menores
ESCRIBIR mayores
ESCRIBIR aprobados
ESCRIBIR desaprobadas
FIN
Pag. 177
Clase PrgClase
class PrgClase {

int i = 0, edad = 0, nota = 0, matriculadas = 0, matriculados = 0, menores = 0 ;
int mayores = 0, desaprobadas = 0, aprobados = 0 ;
char sexo = ‘F’, rpta = ‘ ’ ;
do {
i ++ ;
do {
System.out.println ( “ Ingrese sexo alumno [” + i + “] matriculado [F/M]: ” ) ;
sexo = Lectura.leerChar ( ) ;
if ( sexo != ‘f’ && sexo != ‘F’ && sexo != ‘m’ && sexo != ‘M’ )
System.out.println ( “ Sexo no válido. ”) ;
} while ( sexo != ‘f’ && sexo != ‘F’ && sexo != ‘m’ && sexo != ‘M’ ) ;
do {
System.out.println ( “ Ingrese la edad del alumno [” + i + “]: ” ) ;
edad = Lectura.leerInt ( ) ;
if (edad <= 0)
System.out.println ( “ Edad no válida. ” ) ;
} while (edad <= 0) ;

do {
System.out.println ( “ Ingrese la nota del alumno [” + i + “]: ” ) ;
nota = Lectura.leerInt ( ) ;
if (nota < 0 || nota > 20)

System.out.println( “ Nota no válida ” ) ;
} while (nota < 0 || nota > 20) ;
switch (sexo) {
case ‘f’ :
case ‘F’ :
matriculadas += 1 ;
if (edad < 20)

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

System.out.println ( “Hay ” + matriculados + “ alumno(s) matriculado(s). ”) ;
System.out.println ( “Hay ” + menores + “ alumna(s) menor(es) de 20 años. ” ) ;
System.out.println ( “Hay ” + mayores + “ alumno(s) mayor(es) de 18 años. ” ) ;
System.out.println ( “Hay ” + desaprobadas + “ alumna(s) desaprobada(s). ” ) ;
System.out.println ( “Hay ” + aprobados + “ alumno(s) aprobado(s). ” ) ;
}
}
Pag. 179
Pag. 180
Problema 23
Desarrollar una solución que permita ingresar un número por teclado. Mostrar el
número con las cifras invertidas, el número de cifras que tiene el número, la suma de
las cifras, el número de cifras pares e impares, y si el número es capicua o no.
Clase PrgNumCifras
class PrgNumCifras {
int num = 0, numInv = 0, res = 0, cont = 0, suma = 0, contPar = 0, contImp = 0, n ;

System.out.println ( “ Ingrese un número entero: ” ) ;
num = Lectura.leerInt ( ) ;
n = num ;
while ( n != 0 ) {
res = n % 10 ;
numInv = numInv * 10 + res ;
cont ++ ;
suma = suma + res ;
if ( res % 2 == 0 )
contPar ++ ;
else
contImp ++ ;
n = n / 10 ;
}
System.out.println ( “ El número invertido es : ” + numInv ) ;

System.out.println ( “ El número de cifras es : ” + cont ) ;
System.out.println ( “ La suma de las cifras es : ” + suma ) ;
System.out.println ( “ El número de cifras pares es : ” + contPar ) ;
System.out.println ( “ El número de cifras impares es : ” + contImp ) ;
if ( num == numInv )
System.out.println ( “ El número es capicua ” ) ;
else
System.out.println ( “ El número no es capicua ” ) ;
}
}
En base al análisis de la codificación desarrolle la Etapa 02 y la Etapa 03 del método.
Pag. 181
Problema 24
Desarrollar un programa que permita ingresar el día, el mes y el año de una determina
fecha. Determinar si la fecha ingresada es correcta y si el año es bisiesto o no.
Clase PrgVerificaFecha
/** Clase: PrgVerificaFecha.java

* Dada una fecha en dia, mes y año se determina si esta correcta la fecha y si
* es año bisiesto
* Un año es bisiesto si es múltiplo de 4, por ejemplo 1984, pero los años
* múltiplos de 100 sólo son bisiestos cuando a su vez son múltiplos de 400,
* por ejemplo 1800 no es bisiesto, mientras que 2000 si lo es.
*/
import biblioteca.Lectura;
class PrgVerificaFecha {
int dia, mes, año ;

boolean verifdia = false, bisiesto = false ;
String mess = “ ” ;
System.out.println ( “ Ingrese el número del día: ” ) ;

dia = Lectura.leerInt ( ) ;
System.out.println ( “ Ingrese el número del mes: ” ) ;
mes = Lectura.leerInt ( ) ;
System.out.println ( “ Ingrese el año: ” ) ;
año = Lectura.leerInt ( ) ;
// verifica año bisiesto

if ( año % 4 == 0 && año % 100 != 0 || año % 400 == 0 ) {
bisiesto = true ;
}
//verifica el dia
switch (mes) {
case 1 :
case 3 :
case 5 :
case 7 :
case 8 :
case 10 :
case 12 :
Pag. 182
If ( dia > 0 && dia <= 31 ) {

verifdia = true ;
}
break ;
case 4 :
case 6 :
case 9 :
case 11 :
if ( ( dia > 0) && ( dia <= 30 ) )
verifdia = true ;
break ;
case 2 :
if ( bisiesto ) {
if ( ( dia > 0 ) && ( dia <= 29 ) ) {
verifdia = true ;
} else {
if ( ( dia > 0 ) && ( dia <= 28 ) )
verifdia = true ;
}
}
break ;
}
//selecciona el nombre del mes
if ( verifdia && ( mes > 0 ) && ( mes <= 12 ) && ( año > 0 ) ) {
switch (mes) {
case 1 :
mess = “Enero” ;
break ;
case 2 :
mess = “Febrero” ;
break ;
case 3 :
mess = “Marzo” ;
break ;
case 4 :
mess = “Abril” ;
break ;
case 5 :
mess = “Mayo” ;
break ;
case 6 :
mess = “Junio” ;
break ;
case 7 :
mess = “Julio” ;
break ;
case 8 :
mess = “Agosto” ;
break ;
Pag. 183
case 10 :
mess = “Octubre” ;
break ;
case 11 :
mess = “Noviembre” ;
break;
case 12 :
mess = “Diciembre” ;
break ;
}
System.out.println ( dia + “ de ” + mess + “ de ” + año ) ;
if ( bisiesto ) {
System.out.println ( “ Es año bisiesto ” ) ;
} else {
System.out.println ( “ No es año bisiesto ” ) ;
}
} else {
System.out.println ( “ error en fecha ” ) ;
}
}
}
Pag. 184
Problema 25
Desarrollar un programa que permita ingresar un número arábico entre 1000 y 3000.
Determinar y mostrar el equivalente del número ingresado en número romano.
Clase PrgNumRomano
/** Clase: PrgNumRomano.java

* Dado un año en números arábigos, imprimirlo en números romanos dentro de
* rango de 1000 a 3000
* Programación Básica
*/
class PrgNumRomano {
int arabigo, resto, unidad, decena, centena, miles ;

String romano = “ ” ;
System.out.println ( “ Ingrese un número entre 1000 y 3000: ” ) ;

arabigo = Lectura.leerInt ( ) ;
if ( arabigo >= 1000 && arabigo <= 3000 ) {

miles = arabigo / 1000 ;
resto = arabigo % 1000 ;
centena = resto / 100 ;
resto = resto % 100 ;
decena = resto / 10 ;
unidad = resto % 10 ;
//formar el número romano. Obtener miles

switch ( miles ) {
case 1 :
romano = romano + “M” ;
break ;
case 2 :
romano = romano + “MM” ;
break ;
case 3 :
romano = romano + “MMM” ;
break ;
}
Pag. 185
Clase PrgNumRomano
//obtener centenas
switch ( centena ) {
case 1 :
romano = romano + “C” ;
break ;
case 2 :
romano = romano + “CC” ;
break ;
case 3 :
romano = romano + “CCC” ;
break ;
case 4 :
romano = romano + “CD” ;
break ;
case 5 :
romano = romano + “D” ;
break ;
case 6 :
romano = romano + “DC” ;
break ;
case 7 :
romano = romano + “DCC” ;
break ;
case 8 :
romano = romano + “DCCC” ;
break ;
case 9 :
romano = romano + “CM” ;
break ;
}
//obtener decenas
switch ( decena ) {
case 1 :
romano = romano + “X” ;
break ;
case 2 :
romano = romano + “XX” ;
break ;
case 3 :
romano = romano + “XXX” ;
break ;
case 4 :
romano = romano + “XL” ;
break ;
case 5 :
romano = romano + “L” ;
break ;
case 6 :
romano = romano + “LX” ;
break ;
Pag. 186
Clase PrgNumRomano
case 7 :
romano = romano + “LXX” ;
break ;
case 8 :
romano = romano + “LXXX” ;
break ;
case 9 :
romano = romano + “XC” ;
break ;
}
//obtener unidades
switch ( unidad ) {
case 1 :
romano = romano + “I” ;
break ;
case 2 :
romano = romano + “II” ;
break ;
case 3 :
romano = romano + “III” ;
break ;
case 4 :
romano = romano + “IV” ;
break ;
case 5 :
romano = romano + “V” ;
break ;
case 6 :
romano = romano + “VI” ;
break ;
case 7 :
romano = romano + “VII” ;
break ;
case 8 :
romano = romano + “VIII” ;
break ;
case 9 :
romano = romano + “IX” ;
break ;
}
// Mostrar número romano

System.out.println ( Arábigo + “ = ” + romano ) ;
} else {
System.out.println ( " Número ingresado no válido " ) ;
}
}
}
Pag. 187
Problema 26
Desarrollar un programa que permita ingresar un número entero menor que 100 y
permita mostrar su equivalente en letras.
Clase PrgNumALetras01
class PrgNumALetras01 {
String letra = “”, cero = “cero”, uno = “uno”, dos = “dos”, tres = “tres” ;
String cuatro = “cuatro”, cinco = “cinco”, seis = “seis”, siete = “siete” ;
String ocho = “ocho”, nueve = “nueve”, diez = “diez”, once = “once” ;
String doce = “doce”, trece = “trece”, catorce = “catorce”, quince = “quince” ;
String dieci = “dieci” ;
String veinte = “veinte”, veinti = “veinti”, y = “ y ”, treinta = “treinta” ;

String cuarenta = “cuarenta”, cincuenta = “cincuenta”, sesenta = “sesenta” ;
String setenta = “setenta”, ochenta = “ochenta”, noventa = “noventa” ;
int num, dec, uni ;
do {
System.out.println ( “Ingrese un número entero menor que 100: ” ) ;
if ( num < 0 || num > 99 )

System.out.println ( “Número ingresado no válido... Reintente!!! ” ) ;
} while ( num < 0 || num > 99 ) ;
dec = num / 10 ;
uni = num % 10 ;
switch ( uni ) {
case 0 :
letra = cero ;
break ;
case 1 :
letra = uno ;
break ;
Pag. 188
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 número ” + num + “ en letras es ” + letra ) ;
}
}
Pag. 190
Problema 27
En base al programa anterior, desarrollar otro programa que permita ingresar un

número entero menor que 1000 y permita mostrar su equivalente en letras.
class PrgNumALetras02 {

String letra = “”, cero = “cero”, uno = “uno”, dos = “dos”, tres = “tres”;
String cuatro = “cuatro”, cinco = “cinco”, seis = “seis”, siete = “siete”;
String ocho = “ocho”, nueve = “nueve”, diez = “diez”, once = “once”;
String doce = “doce”, trece = “trece”, catorce = “catorce”, quince = “quince”;
String dieci = “dieci”;
String veinte = “veinte”, veinti = “veinti”, y = “ y ”, treinta = “treinta”;

String cuarenta = “cuarenta”, cincuenta = “cincuenta”, sesenta = “sesenta”;
String setenta = “setenta”, ochenta = “ochenta”, noventa = “noventa”;
String cien = “cien”, ciento = “ciento ”, cientos = “cientos ”;

String quinientos = “quinientos ”, sete = “sete”, nove = “nove”;
int num, cen, resto, dec, uni;
do {
System.out.println ( “ Ingrese un número entero menor que 1000: ” ) ;
if ( num < 0 || num > 999 )
System.out.println ( “ Número ingresado no válido... Reintente!!! ” ) ;
} while ( num < 0 || num > 999 ) ;
cen = num / 100 ;
resto = num % 100 ;
dec = resto / 10 ;
uni = resto % 10 ;
switch ( uni ) {
case 0 :
letra = cero ;
break ;
case 1 :
letra = uno ;
break ;
Pag. 191
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 número ” + num + “ en letras es ” + letra ) ;
}
}
Pag. 194
MANEJO DE EXCEPCIONES
Cuando se está ejecutando un programa y ocurre un error, Java lanza una excepción que
cuando no se captura da lugar a un mensaje sobre lo ocurrido y detiene la ejecución del
programa (es importante establecer que las excepciones se lanzan, no ocurren). Ahora, si se
desea que la ejecución del programa no se detenga, se deberá capturar la excepción lanzada
y manejarla.
Las excepciones en Java son objetos de subclases de la clase Throwable.
Existen diversos errores que pueden ocasionar que se lance una excepción en un programa,
por ejemplo, una entrada incorrecta de datos (IOException), una división por cero
(ArithmeticException) o una conversión de datos no válida (NumberFormatException).
Para evitar que la ejecución de un programa se detenga debido a un error que lanza una
excepción, se debe utilizar la sentencia try para alertar al programa acerca del código que
puede ocasionar un error, y utilizar la sentencia catch para capturar y manejar cada una de
las excepciones que se puedan lanzar.
El formato de la sentencia try y catch es el siguiente:
Tipo de excepción
try { capturada por la sentencia
catch con la finalidad de
// Código de la aplicación.
manejarla.
…
…
…
…
…
} catch ( ) {
// Código de tratamiento de la excepción.

…
…
…
…
…
Significa: “Intentar ejecutar las sentencias ubicadas entre las

llaves del try y si ocurre un error y se lanza una excepción
capturarla con la sentencia catch y manejarla con las sentencias
ubicadas entre las llaves del catch”.
Pag. 195
Esto significa que durante la ejecución del programa

normalmente se ejecutarán las sentencias que están dentro de
las llaves de la sentencia try:
try {
// Código de la aplicación.
…
…
}
Si no ocurre un error, no se lanzará ninguna excepción, lo que

significa que las sentencias que están entre las llaves de la
sentencia catch no se ejecutarán.
Si ocurre un error, se lanzará una excepción, interrumpiéndose la

ejecución de las sentencias que están entre las llaves de la
sentencia try y se ejecutarán las sentencias que están entre las
llaves de la sentencia catch, siempre y cuando se haya
especificado capturar la excepción lanzada.
Como se ha indicado, existen diferentes tipos de excepciones por lo que es común observar
en un programa una sentencia try con varias sentencias catch. Cada sentencia catch
capturará y manejara un excepción.
try {
/* Código de la aplicación que se prevee que

puedan lanzar una excepción.*/
…
…
} catch ( ArithmeticException e ) {
/* Código de tratamiento de la excepción

ArithmeticException. */
…
…
} catch ( NumberFormatException e ) {
/* Código de tratamiento de la excepción

NumberFormatException. */
…
…
}
En el ejemplo anterior, se ha especificado capturar dos

excepciones en caso de que estás se lancen
(ArithmeticException y NumberFormatException).
Pag. 196
El manejo de excepciones ofrece una forma de escribir o codificar programas con una mayor
claridad y sencillez, separando explícitamente el código que maneja los errores del código
básico de una aplicación.
En la actualidad, se considera como “buen estilo de programación” el uso de las excepciones

en los programas.
Como ejemplo de excepciones se puede mencionar:
Excepción Descripción
Una condición aritmética

ArithmeticException
excepcional ocurrio.
Se intentó convertir una cadena

NumberFormatException con un formato inapropiado a un
número.
Problemas al realizar operaciones

IOException
de entrada y salida de datos.
Un arreglo fué accedido con un

ArrayIndexOutOfBoundException índice ilegal (fuera de los límites
permitidos).
Se intentó utilizar null donde se

NullPointerException
requería un objeto.
Pag. 197
Problema 28
Desarrollar una solución que permita ingresar dos números enteros. Mostrar el
resultado de dividir ambos números. Se debe tener en cuenta que existe la posibilidad
que el divisor sea igual a cero.
Clase PrgDivisionSinExcepcion
class PrgDivisionSinExcepcion {
int dividendo, divisor, rpta ;
System.out.println ( “ Ingrese el dividendo: ” ) ;

dividendo = Lectura.leerInt ( ) ;
System.out.println ( “ Ingrese el divisor: ” ) ;
divisor = Lectura.leerInt ( ) ;
rpta = dividendo / divisor ;

System.out.println ( “ El resultado de la división es: ” + rpta ) ;
}
}
Ejecute el siguiente programa e ingrese cero al divisor. Al momento de realizar la división se

lanzará la excepcion llamada ArithmeticException debido a que no se puede dividir un número
entero entre cero, finalizando la ejecución del programa. Para evitar que el programa finalice es
necesario manejar dicha excepción.
Intente incluir en el programa anterior el manejo de la excepción lanzada. Analice el siguiente

programa y anote sus conclusiones.
Pag. 198
Clase PrgDivisionConExcepcion
import biblioteca.Lectura;
class PrgDivisionConExcepcion {
int dividendo, divisor, rpta ;
System.out.println ( “ Ingrese el dividendo: ” ) ;

dividendo = Lectura.leerInt ( ) ;
System.out.println ( “ Ingrese el divisor: ” ) ;
divisor = Lectura.leerInt ( ) ;
try {
rpta = dividendo / divisor ;
System.out.println ( “ El resultado de la división es: ” + rpta ) ;
} catch ( ArithmeticException e ) {
System.out.println ( “ No se puede dividir un número entre cero ” ) ;
}
}
}
Pag. 199
Problema 29
Desarrollar una solución que permita ingresar la hora en el siguiente formato hh:mm:ss
donde “hh” es igual a la hora (de 00 a 23 horas), “mm” es igual a los minutos (de 00 a
59 minutos) y “ss” es igual a los segundos (de 00 a 59 segundos). Mostrar un mensaje
cuando la hora ingresada sea válida. Manejar excepciones.
Clase PrgHoraConExcepcion
class PrgHoraConExcepcion {
boolean valido ;
String hora, tmp ;
int hh, mm, ss ;
do {
System.out.println ( “ Ingrese la hora en el siguiente formato: hh:mm:ss ” ) ;
hora = Lectura.leerString ( ) ;
try {
tmp = hora.substring ( 0, 2 ) ;
hh = Integer.parseInt ( tmp ) ;
if ( hh < 0 || hh > 23 ) {
System.out.println ( “ Hora ingresada no válida ” ) ;
valido = true ;
} else {
tmp = hora.substring ( 3, 5 ) ;
mm = Integer.parseInt ( tmp ) ;
if (mm < 0 || mm > 59) {
System.out.println ( “ minuto ingresado no válido ” ) ;
valido = true ;
} else {
tmp = hora.substring ( 6 ) ;
ss = Integer.parseInt ( tmp ) ;
if (ss < 0 || ss > 59) {
System.out.println ( “ segundo ingresado no válido ” ) ;
valido = true ;
} else {
valido = false ;
}
}
}
Pag. 200
Clase PrgHoraConExcepcion
} catch ( NumberFormatException error ) {

System.out.println ( “Error... ” ) ;
valido = true ;
}
} while ( valido ) ;
System.out.println ( “ La hora se ingresó correctamente... ” ) ;
}
}
En este programa se captura la excepción NumberFormatException para prevenir que no se

intente convertir una cadena con un formato inapropiado a un número. Puede probar el programa
ingresando como hora lo siguiente:
23:10:xx
Es decir, en cualquier parte del formato indicado, ingrese letras en lugar de números.
Para poder entender la solución del programa sugiero que revise en el siguiente capítulo la clase
Integer (Clase Wrapper) y la clase String.
Pag. 201
Problema 30
Desarrollar una solución que permita ingresar la fecha en una variable de tipo texto o
cadena con el siguiente formato: dd/mm/aaaa. Validar que la fecha ingresada tenga el
formato especificado. Manejar excepciones.
Clase PrgFechaConExcepcion
class PrgFechaConExcepcion {
boolean valido = true ;

String fecha, tmp, puntos1, puntos2 ;
int dia, mes, año ;
do {
System.out.println ( “ Ingrese la fecha en el formato: dd/mm/aaaa ” ) ;

fecha = Lectura.leerString ( ) ;
fecha = fecha.trim ( ) ;
if ( fecha.length ( ) == 10 ) {
try {
tmp = fecha.substring ( 0, 2 ) ;
dia = Integer.parseInt ( tmp ) ;
tmp = fecha.substring ( 3, 5 ) ;
mes = Integer.parseInt ( tmp ) ;
tmp = fecha.substring ( 6 ) ;
año = Integer.parseInt ( tmp ) ;
puntos1 = fecha.substring ( 2, 3 ) ;
puntos2 = fecha.substring ( 5, 6 ) ;
if (puntos1.equals (“/”) && puntos2.equals (“/”) )

valido = false ;
else
valido = true ;
} catch (NumberFormatException error ) {

valido = true ;
}
Pag. 202
Clase PrgFechaConExcepcion
} else
valido = true ;
if ( valido )
System.out.println ( “ Error... Ingrese la fecha según formato!!! ” ) ;
System.out.println ( “ El formato esta correcto... ” ) ;

System.out.print ( “ Ahora Ud. continue el programa validando el valor ” ) ;
System.out.println ( “ de las variable dia, mes y año ” ) ;
// Continúa la validación de la fecha... ver problema 24 y 127.
}
}

ingresando como fecha lo siguiente:
23/xx/2005
Es decir, en cualquier parte del formato indicado, ingrese letras en lugar de números (inclusive en
el lugar del / ).
Pag. 203
Problema 31
Desarrollar una solución que permita ingresar dos números de tres digitos en una
variable de tipo texto o cadena con el siguiente formato: nnn//nnn. Validar que los
números sean de tres cifras y mostrar la división de los mismos. Manejar excepciones.
Clase PrgNumeroConExcepcion
class PrgNumeroConExcepcion {
boolean valido = true ;

String numeros, tmp, puntos1 ;
int num1, num2 ;
double resultado ;
do {
System.out.println ( “ Ingrese dos números con el formato: nnn//nnn ” ) ;

numeros = Lectura.leerString ( ) ;
numeros = numeros.trim ( ) ;
if ( numeros.length ( ) == 8 ) {
try {
tmp = numeros.substring ( 0, 3 ) ;
num1 = Integer.parseInt ( tmp ) ;
tmp = numeros.substring ( 5 ) ;
num2 = Integer.parseInt ( tmp ) ;
puntos1 = numeros.substring ( 3, 5 ) ;
if ( puntos1.equals ( “//” ) ) {
valido = false ;
resultado = num1 / num2 ;
System.out.println ( “ La división es: ” + resultado ) ;
} else {
valido = true ;
}
Pag. 204
Clase PrgNumeroConExcepcion
} catch ( NumberFormatException error ) {
System.out.println ( “ Formato no válido ” ) ;

valido = true ;
} catch ( ArithmeticException error ) {
System.out.println ( “ No se puede dividir un número entre cero ” ) ;

valido = false ;
} else {
valido = true ;
}
if ( valido ) {
System.out.println ( “ Error... Ingrese en el formato indicado!!! ” ) ;
}
}
}

ingresando como números lo siguiente:
aaa//123
Es decir, en cualquier parte del formato indicado, ingrese letras en lugar de números (inclusive en
el lugar de las // ).
También se captura la excepción ArithmeticException para prevenir que no se intente dividir los
números cuando el segundo número es cero. Puede probar el programa ingresando como números
lo siguiente:
123//000
Pag. 205
Pag. 206
DESARROLLO DE LAS CAPACIDADES LÓGICAS
Cuando un estudiante se inicia en el estudio de la programación, es necesario que

comprenda los conceptos fundamentales relacionados a las estructuras lógicas y las
estructuras de datos elementales, con la finalidad de utilizarlas en forma conjunta y lograr
desarrollar sus capacidades lógicas.
El desarrollo de las capacidades lógicas se logra con la práctica. Es decir, desarrollando

soluciones y codificándolas en un lenguaje de programación determinado, como por ejemplo
el lenguaje de programación Java, lenguaje de programación utilizado en el presente texto.
Existen problemas que por su naturaleza contribuyen de manera significativa a lograr este
objetivo, los cuales se desarrollan en esta última parte del presente capítulo. Es importante
analizar cada una de las soluciones propuestas siguiendo paso a paso el desarrollo de las
mismas y desarrollando a su vez las variaciones planteadas sobre los problemas.
Pag. 207
Pag. 208
Problema 32
Etapa 01 – Descripción del problema.
Desarrollar la codificación de una solución que permita mostrar la siguiente figura:
* * * * *
* * * * * Nota: En la figura mostrada el número de filas = 5. Asuma
* * * * * que el número de filas puede variar desde 2 hasta 20 y que
* * * * * entre los asteriscos no existen espacios en blanco.
* * * * *
Etapa 04 – Desarrollo de la codificación.
Clase PrgCuadrado01
import biblioteca.* ;
public class PrgCuadrado01 {
public static void main (String[] args) {

int totalFilas = 0, i = 0, j = 0 ;
do {
System.out.println ( “ Ingresar el número de filas de la figura ” ) ;
System.out.print ( “ Valores válidos desde 2 hasta 20: ” ) ;
totalFilas = Lectura.leerInt ( ) ;
if (totalFilas < 2 || totalFilas > 20 ) {

System.out.print ( “ Valor de fila no válido… Reintente!. ” ) ;
}
} while (totalFilas < 2 || totalFilas > 20 ) ;
for ( i = 1 ; i <= totalFilas; i++ ) {
for ( j = 1 ; j <= totalFilas; j++ ) {

// Se muestra un asterisco.
System.out.print ( “*”) ;
}
// Se realiza un salto de línea.

System.out.println ( ) ;
}
}
}
Pag. 209
Se ingresa el número de filas que va ha tener la figura y se almacena en la variable

totalFilas, la cual puede variar desde 2 hasta 20. Para nuestra explicación asumiremos que
el valor de totalFilas=5.
Entonces, la condición de la primera sentencia for va ser verdadera para valores de i=1
hasta i=totalFilas (en el caso de totalFilas=5; los valores válidos para i son i=1, i=2, i=3, i=4 e
i=5). Los valores válidos de i coinciden con el número de filas que nuestra figura va ha tener,
por lo cual podemos afirmar que para cada valor de i, corresponde una fila de la figura.
Para fila=5:
1ra fila ( i=1 ) * * * * *

2da fila ( i=2 ) * * * * * for ( i = 1 ; i <= totalFilas; i++ ) {
3ra fila ( i=3 ) * * * * *
4ta fila ( i=4 ) * * * * * }
5ta fila ( i=5 ) * * * * *
Ahora necesitamos mostrar un número determinado de asteriscos en cada una de las filas y
ese número de asteriscos a mostrar coincide con el número de filas de la figura (para
nuestro caso totalFilas=5).
Esta situación determina la existencia de la segunda sentencia for dentro de la primera

sentencia for (for interno).

…
}
…
}
Para cada una de las filas (en el caso de totalFilas=5; para i=1, i=2, i=3, i=4 e i=5), el for
interno se ejecuta la misma cantidad de veces que el número de filas de la figura y cada vez
que se ejecuta muestra un asterisco (en el caso de totalFilas=5, el for interno se ejecuta 5
veces y mostrará en total 5 asteriscos en cada una de las filas). Cada vez que finaliza el for
interno, la sentencia System.out.println ( ); nos permite hacer un salto de línea y continuar
con la ejecución de la solución siempre y cuando la condición del primer for sea verdadera.
Los siguientes 2 problemas son una variación de este problema. Analice sus respectivas
soluciones y desarrolle sus propias observaciones.
Pag. 210
Problema 33
1 2 3 4 5
1 2 3 4 5 Nota: En la figura mostrada el número de filas = 5. Asuma
1 2 3 4 5 que el número de filas puede variar desde 2 hasta 9 y que
1 2 3 4 5 entre los números no existen espacios en blanco.
1 2 3 4 5
Clase PrgCuadrado02

do {

System.out.println ( “ Valor de fila no válido… Reintente!. ” ) ;
}

// Se muestra el valor de la variable j.
System.out.print ( j ) ;
}

}
}
}
Pag. 211
Problema 34
1 1 1 1 1
2 2 2 2 2 Nota: En la figura mostrada el número de filas = 5. Asuma
3 3 3 3 3 que el número de filas puede variar desde 2 hasta 9 y que
4 4 4 4 4 entre los números no existen espacios en blanco.
5 5 5 5 5
Clase PrgCuadrado03

do {

}

// Se muestra el valor de la variable i.
System.out.print ( i ) ;
}

}
}
}
Pag. 212
Los últimos dos problemas son una variación del problema 32, en el cuál se desarrolla la
siguiente figura:
* * * * *
* * * * *
* * * * *
* * * * *
* * * * *
Con la finalidad de mejorar sus capacidades lógicas sugiero que desarrolle las siguientes
variaciones del problema:
1 2 3 4 5 5 4 3 2 1 5 5 5 5 5
6 7 8 9 0 5 4 3 2 1 4 4 4 4 4
1 2 3 4 5 5 4 3 2 1 3 3 3 3 3
6 7 8 9 0 5 4 3 2 1 2 2 2 2 2
1 2 3 4 5 5 4 3 2 1 1 1 1 1 1
Pag. 213
Problema 35
*
* * Nota: En la figura mostrada el número de filas = 5. Asuma
* * * que el número de filas puede variar desde 2 hasta 20 y que
* * * * entre los asteriscos no existen espacios en blanco.
* * * * *
Clase PrgTriangulo01
import biblioteca.*;
public class PrgTriangulo01 {
public static void main(String[] args) {

do {

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

}

}
}
}
Pag. 214

Entonces, la condición de la primera sentencia for va ser verdadera para valores de i=1
hasta i=totalFilas (en el caso de totalFilas=5; los valores válidos para i son i=1, i=2, i=3, i=4 e
i=5). Los valores válidos de i coinciden con el número de filas que nuestra figura va ha tener,
por lo cual podemos afirmar que para cada valor de i, corresponde una fila de la figura.
Para fila=5:
1ra fila ( i=1 ) *

2da fila ( i=2 ) * * for ( i = 1 ; i <= totalFilas; i++ ) {
3ra fila ( i=3 ) * * *
4ta fila ( i=4 ) * * * * }
5ta fila ( i=5 ) * * * * *
Ahora necesitamos mostrar un asterisco en la primera fila (i=1), 2 asteriscos en la segunda

fila (i=2) y asi sucesivamente hasta llegar a la última fila (para nuestro caso hasta la quinta
fila Æ i=5).
Esta situación determina la existencia de la segunda sentencia for dentro de la primera

sentencia for (for interno).

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

que para i=5, los valores válidos para j serían j=1, j=2, j=3, j=4 y j=5, por lo que el for interno
Pag. 215
se ejecutaría cinco veces y en cada una de las ejecuciones del for interno se mostraría un
asterisco (en consecuencia se mostrarían en total cinco asteriscos). Luego se hace un salto
de linea y se finaliza la ejecución.
Los siguientes 7 problemas son una variación de este problema. Analice sus respectivas
soluciones y desarrolle sus propias observaciones.
Pag. 216
Problema 36
1
1 2 Nota: En la figura mostrada el número de filas = 5. Asuma
1 2 3 que el número de filas puede variar desde 2 hasta 9 y que
1 2 3 4 entre los números no existen espacios en blanco.
1 2 3 4 5

do {

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

}

}
}
}
Pag. 217
Problema 37
1
5 5 5 5 5

do {

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

}

}
}
}
Pag. 218
Problema 38
5
5 4 3 2 1

do {

}
for ( i = totalFilas; i >= 1 ; i - - ) {
for ( j = totalFilas; j >= i ; j - - ) {

}

}
}
}
Pag. 219
Problema 39
5
1 1 1 1 1

do {

}
for ( i = totalFilas; i >= 1 ; i - - ) {
for ( j = totalFilas; j >= i ; j - - ) {

}

}
}
}
Pag. 220
Problema 40
1
1 2 3 4 5

int totalFilas = 0, i = 0, j = 0, k=0 ;
do {

}

for ( j = 1 ; j <= i ; j++ ) {
if ( k == totalFilas) {
k=1;
} else {
k ++ ;
}
System.out.print ( k ) ;
}
}
}
}
Pag. 221
Problema 41
1
1 2 3 4 5

do {

}

for ( j = 1 ; j <= i ; j++ ) {
if ( k == 9 ) {
k=0;
} else {
k ++ ;
}
}
}
}
}
Pag. 222
Problema 42
5
5 4 3 2 1

int totalFilas = 0, i = 0, j = 0, k=0 ;
do {

}

k=totalFilas+1;

for ( j = 1 ; j <= i ; j++ ) {
if ( k == 1 ) {
k = totalFilas ;
} else {
k--;
}
}
}
}
}
Pag. 223
Los últimos siete problemas son una variación del problema 35, en el cuál se desarrolla la
siguiente figura:
*
* *
* * *
* * * *
* * * * *
Con la finalidad de mejorar sus capacidades lógicas sugiero que desarrolle las siguientes
figuras y sus respectivas variaciones:
* * * * * * * * * * *
* * * * * * * * * *
* * * * * * * * *
* * * * * * * *
* * * * * * *
Pag. 224
Problema 43
* * * * *
* * * * Nota: En la figura mostrada el número de filas = 5. Asuma
* * entre los asteriscos no existen espacios en blanco.

do {

}
for ( i = 1 ; i <= totalFilas; i ++ ) {
for ( j = 1 ; j < i ; j ++ ) {
System.out.print ( “ ” ) ;
}
for ( j = i ; j <= totalFilas ; j ++ ) {
System.out.print ( “*” ) ;
}
}
}
}
Intente mejorar la solución anterior (en lugar de usar tres sentencias for utilice solo dos), sino
lo consigue analice la siguiente solución.
Pag. 225
Clase PrgTriangulo09Mejorado
public class PrgTriangulo09Mejorado {

do {

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

if ( i < = j ) {
} else {
}
}
}
}
}
Pag. 226
Problema 44
*
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.
* * * * *

do {

}
for ( j = totalFilas ; j > = 1 ; j - - ) {

if ( i < j ) {
} else {
}
}
}
}
}
Pag. 227
Intente mejorar la solución anterior de tal forma que cambie el for interno por el siguiente for:
for ( j = 1 ; j < = totalFilas ; j++ )

…
…
…
}
Sino lo consigue analice la siguiente solución:

do {

System.out.print ( “ Valor de fila no válido… Reintente!. ” ) ;
}
for ( j = 1 ; j < = totalFilas ; j++ ) {

if ( j <= totalFilas - i ) {
} else {
}
}
}
}
}
Es importante indicar que un mismo problema puede ser solucionado de diferentes maneras.
Pag. 228
Problema 45
*
* * Nota: En la figura mostrada el número de filas = 5. Asuma
* * * * entre los asteriscos existe un espacio en blanco.
* * * * *

do {
totalFilas = Lectura.leerInt() ;

}
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.
}
}
}
Pag. 229

El primer for (como en todos los casos anteriores) está justificado y se ejecuta la misma
cantidad de veces que el número de filas de la figura. Cada vez que se ejecuta el primer for
debemos asegurarnos de mostrar los asteriscos necesarios.
Para fila=5:
1ra fila ( i=1 ) *

2da fila ( i=2 ) * * for ( i = 1 ; i <= totalFilas ; i++ ) {
3ra fila ( i=3 ) * * *
4ta fila ( i=4 ) * * * * }
5ta fila ( i=5 ) * * * * *
Es necesario entonces mostrar un asterisco en la primera fila (i=1), un asterisco, un espacio

en blanco y otro asterisco en la segundo fila (i=2) y asi sucesivamente hasta llegar a la
última fila (para nuestro caso hasta la quinta fila Æ i=5). Pero si observamos bien la figura
tenemos que tener en cuenta la ubicación de los asteriscos en cada fila, lo cual nos complica
la lógica de nuestra solución.
Es necesario encontrar algunos parámetros para establecer una constante matemática (una
relación matemática) que nos permita mostrar adecuadamente la figura. Ahora, para realizar
un mejor análisis se va ha representar los espacios en blanco de la figura con un guión -
(esto para visualizar la cantidad de espacios en blanco necesarios en cada fila):
- - - - *
- - - * - * Nota: Los guiones representan espacios en blanco.
- - * - * - * Entre un guión y un asterisco no hay ningún
- * - * - * - * símbolo.
* - * - * - * - *
Ahora realizaremos una división imaginaria en la figura y separaremos los espacios en

blanco que están a la izquierda del primer asterisco de cada fila:
- - - - * Nota: Se determina que existe una relación en la

parte donde están los espacios en blanco. En la
- - - * - * primera fila (i=1) se muestran fila - 1 espacio en
- - * - * - * blanco y luego se muestra un espacio en blanco
- * - * - * - * menos cada vez que se muestra una nueva fila,
hasta llegar a la última fila donde no se muestra
* - * - * - * - * ningún espacio en blanco.
Pag. 230
En la parte que tiene los asteriscos y espacios en blanco entre los asteriscos, es necesario
buscar una relación matemática. Para esto, incluiremos un espacio en blanco al final de cada
una de las filas de la figura:
- - - - * - Nota: Se determina que existe una relación en la

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

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

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

2da fila ( i=2 ) * - * - for ( j = 1 ; j <= i ; j++ ) {
3ra fila ( i=3 ) * - * - * - }
4ta fila ( i=4 ) * - * - * - * -
5ta fila ( i=5 ) * - * - * - * - * -
Intente mejorar la solución anterior (en lugar de usar tres sentencias for utilice solo dos), sino
lo consigue analice la siguiente solución.
Pag. 231

int totalFilas = 0, i = 0, j = 0, cont = 0 ;
do {
totalFilas = Lectura.leerInt() ;

}

for ( j = 1 ; j < totalFilas * 2 ; j++ ) {
if ( ( j >= totalFilas – cont ) && ( j <= totalFilas + cont ) ) {
// Se muestra unasterisco y un espacio en blanco.
j ++ ;
} else {
}
}
cont ++ ;
}
}
}
Imagínese ahora al triángulo como si este fuera un rectángulo (complete con guiones los
espacios en blanco que tendría la figura si fuera un rectángulo). La variable i va ha representar
cada una de las filas, mientras que la variable j va ha representar cada una de las columnas.
- - - - * - - - - Nota: Los guiones representan espacios en blanco.

- - - * - * - - - Entre un guión y un asterisco no hay ningún
- - * - * - * - símbolo.
- * - * - * - * -
* - * - * - * - *
Pag. 232
El primer for controla el número de filas que se van ha mostrar (desde i=1 hasta i=totalFilas).
El segundo for (for interno) se ejecuta para cada una de la filas y controla el número de símbolos
(asteriscos o espacios en blanco) que se van a mostrar (en total se deben mostrar totalFilas * 2 –
1 símbolos). En el for interno hay una sentencia if que nos permite determinar el símbolo que se
va ha mostrar.

j ++ ;
} else {
}
Ahora, nuevamente intente mejorar la solución. Utilice el primer planteamiento desarrollado.

Analice nuevamente el siguiente gráfico:
- - - - * -
- - - * - * -
- - * - * - * -
- * - * - * - * -
* - * - * - * - * -

for ( j = 1 ; j <= totalFilas ; j++ ) {
if ( j > totalFilas - i ) {
} else {
}
}
}
También:

for ( j = 1 ; j <= totalFilas ; j++ ) {
if ( j <= totalFilas - i ) {
} else {
}
}
}
Pag. 233
Con la finalidad de mejorar sus capacidades lógicas sugiero que desarrolle todas las
variaciones posibles o que se pueda imaginar del presente problema.
Adicionalmente desarrolle las siguientes figuras y sus posibles variaciones:
* - * - * - * - * * * * * * * * * * *
* - * - * - * * * * * * * * * * *
* - * - * * * * * * * * * * *
* - * * * * * * * * * * *
* * * * * * * * * * *
Nota: Recuerde que los Nota: Observe que en la

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

for ( j = 1 ; j < totalFilas * 2 ; j++ ) {
} else {
}
}
cont ++ ;
}
Pag. 234
Problema 46
*
* *
* * * Nota: desarrollar la figura con la estructura de repetición
* * * * MIENTRAS (while). El lado del rombo debe tener un valor entre
2 y 10. En la figura el lado = 4.
* * *
* *
*
Clase PrgRombo01
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 ( );

System.out.println ( “\nValor fuera de rango. Ingrese entero entre [2,10]: ” ) ;
}
diagonal = totalFilas * 2 - 1 ;
Pag. 235
while ( i <= diagonal ) {

j=1;
while ( j <= diagonal ) {
if ( j < totalFilas - cont || j > totalFilas + cont )
else {
System.out.print ( “* ” ) ;
j ++ ;
}
j ++ ;
}
if ( i < totalFilas )
cont ++ ;
else
cont - - ;
i ++ ;
}
}
}
Analice la solución del problema y anote sus conclusiones. Intente resolverlo utilizando la
sentencia for de Java.
Pag. 236
Problema 47
1
2 2
3 3 3 Nota: la figura mostrada es un rombo de número. Ingresar un
4 4 4 4 valor entero desde 2 hasta 9 que representa el número de
3 3 3 elementos de la fila central. En la figura el dato = 4.
2 2
1
Clase PrgRombo02
public class PrgRombo02 {
int num = 0, diagonal = 0, cont = 0, n = 0, i = 1, j = 1 ;
System.out.println ( “ Programa que realiza un rombo de números ” ) ;

System.out.print ( “ Ingrese el número máximo de la figura entre [2,9]: ” ) ;
do {
if ( num < 2 || num > 9 ) {

System.out.println ( “\nValor fuera de rango. Ingrese enteros entre [2...9]: ” ) ;
}
} while ( num < 2 || num > 9 ) ;
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
}
if ( i < num )
cont ++ ;
else
cont - - ;
}
}
}
Modifique está solución utilizando la estructura de repetición while en lugar de la estructura for.
Con la finalidad de mejorar sus capacidades lógicas sugiero que desarrolle todas las
variaciones posibles o que se pueda imaginar del presente problema.
Adicionalmente desarrolle la siguiente figura y sus posibles variaciones:
1
2 3
4 5 6
7 8 9 1
2 3 4 5 6
7 8 9 1
2 3 4
5 6
7
A continuación se presentan diversas soluciones que permitirán contribuir con el desarrollo

de sus capacidades lógicas.
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
Problema 48
* * * * *
* *
Nota: En la figura mostrada el número de filas = 5. Asuma
* * que el número de filas puede variar desde 2 hasta 15.
* *
* * * * *
Clase PrgFiguraA
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 ) {

}
} while ( lado < 2 || lado > 15 ) ;
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.
} else {
}
}
}
}
}
Pag. 239
Problema 49
*
* * 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.
* *
* * * * *
Clase PrgFiguraB
public class PrgFiguraB {

int lado = 0 ;
System.out.println ( “ Programa que realiza un triángulo de asteriscos: ” ) ;

System.out.print ( “ Ingrese el lado del triángulo entre [2,20]: ” ) ;
do {
lado = Lectura.leerInt ( ) ;
if ( lado < 2 || lado > 20 ) {

}
} while ( lado < 2 || lado > 20 ) ;
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.
}
}
}
}
Pag. 240
Problema 50
*
* * 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.
* *
* * * * * * * * *
Clase PrgFiguraC
public class PrgFiguraC {

int base = 0, medio = 0 ;
System.out.println ( “ Programa que realiza un triángulo hueco de base impar \n ” ) ;
System.out.print ( “ Ingrese la base impar del triángulo entre [3,25]: ” ) ;
do {
base = Lectura.leerInt ( ) ;
if ( base < 3 || base > 25 || base % 2 == 0 ) {

System.out.println ( “\nValor fuera de rango. Ingrese impar entre [3,25]: ” ) ;
}
} while ( base < 3 || base > 25 || base % 2 == 0 ) ;
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.
}
}
}
}
Pag. 241
Problema 51
* * * * *
* * * Nota: el lado de la figura debe tener un valor impar entre 5 y 15.
* * * * * En la figura el lado = 5.
* * *
* * * * *
Clase PrgFiguraD
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 {
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 ) ;

for ( int col = 1 ; col <= lado ; col ++ ) {
if ( fil == 1 || fil == lado || fil == lado/2+1 || col == 1 || col == lado || col == lado / 2+1)
else
}
}
}
}
Pag. 242
Problema 52
* * * * *
* * * * Nota: el lado de la figura debe tener un valor impar entre 5 y 15.
* * * En la figura el lado = 5.
* * * *
* * * * *
Clase PrgFiguraE
public class PrgFiguraE {

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 {
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 ) ;
for ( int col = 1 ; col <= lado ; col ++ ) {
if ( fil == 1 || fil == lado || fil == col || col == 1 || col == lado || col == (lado –fil +1) )
else
}
}
}
}
Pag. 243
Problema 53
* * Nota: el lado de la figura debe ser un número par con un valor

* * desde 4 hasta 18. En la figura el lado = 4.
* * * *
* * * *
Clase PrgFiguraF
public class PrgFiguraF {

int alto = 0 ;
System.out.println ( “ Programa que realiza una figura similar a la letra U \n ” ) ;
System.out.print ( “ Ingrese el alto (número par) de la figura entre [4,18]: ” ) ;
do {
alto = Lectura.leerInt ( ) ;
if ( ( alto < 4 ) || ( alto > 18 ) || ( alto % 2 == 0 ) ) {
System.out.prinlnt ( “\nValor fuera de rango.Ingrese un número par entre [4,18]: ” ) ;
}
} while ( ( alto < 4 ) || ( alto > 18 ) || ( alto % 2 == 0 ) ) ;
for ( int fil = 1 ; fil <= alto ; fil ++ ) {

for ( int col = 1 ; col <= alto ; col ++ ) {
if ( fil <= ( alto / 2 ) )
if ( col == 1 || col == alto )
else
else
}
}
}
}
Pag. 244
Problema 54
* *
* * * * Nota: el lado de la figura debe tener un valor entre 2 y 15. En la
* * * * * * figura el lado = 5.
* * * * * * * *
* * * * * * * * * *
Clase PrgFiguraG
public class PrgFiguraG {
int lado = 0, mayor = 0, col = 0 ;
System.out.println ( “ Programa que realiza dos triángulos de asteriscos ”);
System.out.print ( “ frente a frente a sus hipotenusas \n ” ) ;
System.out.print ( “ Ingrese el lado del triángulo entre [2,15]: ” ) ;
do {
if ( lado < 2 || lado > 15 ) {
}
} while ( lado < 2 || lado > 15 ) ;

mayor = (2 * lado ) + 1 ;

col = 1 ;
while ( col <= mayor ) {
if ( col <= fil || mayor - fil < col )
else
col ++ ;
}
}
}
}
Pag. 245
Problema 55
* *
* * * * Nota: el lado de la figura debe tener un valor entre 2 y 15. En la
* * * * * * figura el lado = 5.
* * * * * * * *
* * * * * * * * * *
Clase PrgFiguraH
public class PrgFiguraH {

int base = 0, mayor = 0, col = 0;
System.out.println ( “ Programa que realiza dos triángulos de asteriscos, ” ) ;
System.out.print ( “ frente a frente a sus catetos \n ” ) ;
System.out.print ( “ Ingrese la base del triángulo entre [2,15]: ” ) ;
do {
if ( base < 2 || base > 15 ) {
}
} while ( base < 2 || base > 15 ) ;
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 ++ ;
}
}
}
}
Pag. 246
Problema 56
* * * * * * * * *
* * Nota: la base y la altura del cuadrado se ingresarán por teclado.
La base deberá ser mayor que la altura. En la figura la base=10
* * y altura=5.
* *
* * * * * * * * *
Clase PrgfiguraI
public class PrgFiguraI {

int base = 0, alto = 0;
System.out.println ( “ Programa que genera un rectángulo hueco de base > alto \n ” ) ;
System.out.println ( “ Para generar el rectángulo hueco en pantalla la base ” ) ;
System.out.print ( “ debe ser >2 y el alto>1 \n ” ) ;
System.out.print ( “ Ingrese la base del rectángulo: ” ) ;
do {
if ( base < 2 ) {
System.out.println ( “\nValor fuera de rango. Ingrese entero mayor a 2: ” ) ;
}
} while ( base < 2 ) ;
System.out.print ( “ Ingrese el alto del rectángulo...Debe ser menor a la base [“ + base + ”]: ” ) ;
do {
alto = Lectura.leerInt ( ) ;
if ( alto < 1 || alto >= base ) {
if ( alto == base ) {
System.out.print ( “\nEs un cuadrado. Ingrese entero mayor a 1 y menor ” ) ;
System.out.print ( “ a base [“ + base + ”]: ” ) ;
} else {
System.out.print ( “\nValor fuera de rango. Ingrese entero mayor a 1 y ” ) ;
System.out.print ( “ menor a base [“ + base + ”]: ” ) ;
}
}
} while ( ! ( alto >1 && alto < base ) ) ;
Pag. 247
for ( int fil = 1 ; fil <= alto ; fil ++ ) {
for ( int col = 1 ; col <= base ; col ++ ) {
if ( fil == 1 || fil == alto || col == 1 || col == base )
else
}
System.out.println ( “ ” ) ;
}
}
}
Pag. 248
Problema 57
Desarrollar la codificación de una solución que permita mostrar en pantalla la tabla de multiplicar
de los 12 primeros números naturales. Asegurese de establecer el espaciado correspondiente
para que no se muestre desordenada la tabla, de tal modo que quede de la siguiente forma:
Clase PrgFiguraJ
public class PrgFiguraJ {
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 ( “----” ) ;
}
}
}
}
}
}
Analice la solución y modifíquela de tal forma que el usuario ingrese la cantidad de números
que debe incluir la tabla de multiplicación. Asegúrese de establecer los valores válidos para
dicha tabla de multiplicar.
Pag. 250
Problema 58
Clase PrgFiguraK
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 )
else
System.out.print ( “***” ) ;
}
}
}
}
Analice la solución y modifíquela de tal forma que el usuario ingrese la cantidad de filas y
columnas que debe tener la figura. Asegúrese de establecer los valores válidos para dichos
datos.
Pag. 251
Problema 59
Clase PrgFiguraL
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 )
else {
if ( (( i==3 || i==8 ) && j>=3 && j<=8 ) || (( j==3 || j==8 ) && i>=3 && i<=8 ) )
else {
if ( ( i >=5 && i<=6 ) && ( j>=5 && j<=6 ) )
else
}
}
}
}
}
}
Analice la solución y modifíquela de tal forma que el usuario ingrese la cantidad de

cuadrados que debe tener la figura. Asegúrese de establecer los valores válidos para dicho
dato.
Pag. 252
Problema 60
Clase PrgFiguraM
public class PrgFiguraM {
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 ) )
else
}
}
}
}
Analice la solución y modifíquela de tal forma que el usuario ingrese la cantidad de filas y
columnas que debe tener la figura.
Pag. 253
Finalmente, sugiero que desarrolle las posibles variaciones de los siguientes problemas:
* * * * * * *
* - - - * * * * - *
* - - - * * - * * - - - *
* - - - * * - - * * - - - - - *
* * * * * * * * * * * * * * * * * * *
* * 1
* * * - * 2 - 3
* * * * - - - * 4 - 5 - 6
* * * * * - - - - - * 7 - 8 - 9 - 0
* * * * * * * * * * - - - - - - - * 1 - 2 - 3 - 4 - 5
* * * * * - - - - - * 6 - 7 - 8 - 9
* * * * - - - * 0 - 1 - 2
* * * - * 3 - 4
* * 5
Nota; Tenga presente que los guiones (-) en las figuras representan espacios en blanco.
Pag. 254
Pag. 255
Pag. 256
Capítulo
Clases Básicas Incorporadas en
3
el Lenguaje de Programación
Java
Temas:
Introducción.
El paquete del lenguaje Java: java.lang
Envoltorios de tipos de datos primitivos: Wrappers
• Introducción.
• Métodos.
• Problemas resueltos.
Funciones matemáticas: Clase Math

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

• Introducción.
• Métodos.
Otras clases en Java

CLASES BÁSICAS INCORPORADAS EN EL LENGUAJE DE PROGRAMACIÓN JAVA
CAPÍTULO III
CLASES BÁSICAS INCORPORADAS EN EL

LENGUAJE DE POGRAMACION JAVA
INTRODUCCIÓN
Un algoritmo constituye una lista completa de pasos secuenciales y una descripción de los
datos que dichos pasos deben manipular para resolver un determinado problema. La lista de
pasos se desarrolla utilizando las estructuras lógicas y las instrucciones o sentencias de
bifurcación y están contenidas en los métodos, mientras que los datos se almacenan en las
estructuras de datos.
MARCO DE TRABAJO
ENUNCIADO
DEL
PROBLEMA
Etapa 02
Definición
Solución Etapa 03
Diseño
Solución Etapa 04
Desarrollo
Solución
Pag. 259

DATOS
TAMBIÉN:
• Clases incorporadas en el lenguaje
de programación utilizado.
ALMACENADOS EN:
Los algoritmos son desarrollados dentro de los métodos. Es decir, todo programa en Java
está contenido en uno o mas métodos, siendo el método main( ), el método principal que
tiene como función iniciar la ejecución de una aplicación desarrollada en Java.
El lenguaje de programación Java contiene diversas clases preprogramadas, es decir,

contiene una gran variedad de clases, con métodos y atributos, que tienen diferentes
funciones y están agrupadas por medio de paquetes.
Pag. 260
El presente capítulo, trata sobre las clases básicas incorporadas en el lenguaje de

1
programación Java, agrupadas en el paquete java.lang.
2
Es importante mencionar que utilizando las clases preprogramadas de Java se puede
ahorrar mucho tiempo y esfuerzo de programación, construyendo fácilmente aplicaciones
profesionales.
1
Paquete: Conjunto de clases similares.
Un paquete permiten organizar las clases. Un paquete contiene clases que tienen funciones similares.
2
Clase: Colección de objetos del mismo tipo.
Una clase es una implantación de un “tipo de objeto”, especifica una estructura para almacenar los atributos y los
métodos operativos permisibles que se aplican a cada uno de sus objetos (comparten datos o atributos y métodos
comunes). El mundo real se modela mediante clases. Una clase es una abstracción y no referencia a ningún objeto
en particular.
Pag. 261
Pag. 262
EL PAQUETE DEL LENGUAJE JAVA
El paquete del lenguaje Java, conocido también como java.lang, es uno de los paquetes más
3
importantes de la API de Java, y contiene las clases que constituyen el corazón del lenguaje
de programación Java.
El paquete Java.lang debido a su importancia no requiere ser importado por las aplicaciones
para usar las clases que contiene, es decir, está automáticamente importado para todos los
programas, por lo que la siguiente sentencia no será necesaria:
import java.lang.* ;
El paquete java.lang contiene clases que encapsulan los tipos primitivos de datos, una clase
4
que proporciona los objetos para manipular la entrada y la salida estándar, clases para
5
manipular cadenas de caracteres, una clase que proporciona métodos correpondientes a las
funciones matemáticas, etc.
Entre las clases más importantes están las siguientes:
Boolean Double Object StringBuffer

Byte Float Package System
Character Integer Process Thread
Class Long Runtime Trowable
ClassLoader Math Short
Compiler Number String
3
API: Aplication Program Interface.
Una API es un conjunto de normas que determinan como debe usarse una determinada función de un lenguaje de
programación en una aplicación.
4
Objetos: Modelos de entes del mundo.
Un objeto de software es cualquier cosa, real o abstracta, acerca del cual almacenamos datos y los métodos que
controlan dichos datos.
5
Métodos: Desarrollo de algoritmos.
Los métodos especifican la forma en que se controlan los datos de un objeto y es donde se define el
comportamiento del mismo. En palabras sencillas; en los métodos se desarrollan o codifican los algoritmos.
Pag. 263
Entre las clases a tratar en el presente capítulo se tienen:
1. Clases que envuelven los tipos de datos primitivos, conocidas como las clases
6
wrappers (envoltorios). Cada una de estas clases (consideradas subclases ), a
7
excepción de la clase Character, se derivan de la clase abstracta Number
(considerada superclase).
• Boolean.
• Byte.
• Character.
• Double.
• Float.
• Integer.
• Long.
• Short.
2. Clase que proporciona métodos correspondientes a las funciones matemáticas

básicas.
• Math.
3. Clase que proporciona los objetos necesarios para manipular y tratar cadenas de
caracteres.
• String.
6
Herencia: Subclase y Superclase.
La Herencia es uno de los conceptos más importantes de la Programación Orientada a Objetos (POO). Utilizando la
herencia se puede derivar una nueva clase a partir de otra clase existente, donde la nueva clase derivada heredará
todos los atributos y métodos de la clase existente. La nueva clase se llama Clase Derivada (o subclase) y la clase
original se llama Clase Base (o superclase).
7
Clase Abstracta: Clase tratada como SuperClase.
Una Clase Abstracta es un tipo de clase de la cual no se pueden crear o instanciar objetos. En su lugar, se debe
derivar una nueva clase a partir de la clase abstracta, codificar los métodos que son declarados como abstractos en
la clase abstracta y crear o instanciar objetos a partir de la clase derivada. Las clases abstractas se utilizan para
forzar a los programadores a desarrollar algunos o todos los métodos de una clase.
Pag. 264
En Java, los métodos siempre están dentro de una clase. Algunos métodos pueden ser
invocados o ejecutados utilizando directamente el nombre de la clase en la cual están
definidos, tal es el caso de los métodos de la clase Math de Java. Estos métodos son
conocidos como métodos estáticos o de clase.
8
Por otro lado, otros métodos son invocados o ejecutados utilizando un objeto o instancia de
la clase en la cual están definidos, tal es el caso de los métodos de la clase String de Java.
Estos métodos son conocidos como métodos de instancia o de objeto.
8
Instancia: Representación concreta de una clase.
Una Instancia viene a ser lo mismo que un objeto. Crear un objeto o instanciar una clase se refiere a poder tener una
representación real de una clase.
Pag. 265
Pag. 266
ENVOLTORIOS DE LOS TIPOS DE DATOS PRIMITIVOS: CLASES WRAPPERS
INTRODUCCIÓN
Los tipos de datos primitivos (boolean, byte, char, double, float, int, long, short),
conocidos también como tipos de datos simples, son los únicos elementos del
lenguaje de programación Java que se representan internamente a través de valores,
tal y como se representan en un lenguaje de programación convencional. Esto
significa que los tipos de datos primitivos no son objetos y se sitúan fuera de la
9
jerarquía de clases de Java. Esto tiene algunas ventajas desde el punto de vista de
la eficiencia.
En ocasiones, interesa sacrificar parte de la eficiencia por flexibilidad, por lo que en

Java se han creado clases que permiten integrar los tipos de datos primitivos o
simples dentro de la jerarquía de clases. Dichas clases son conocidas como las
clases wrappers (envoltorios). Los wrappers son clases diseñadas para ser un
complemento de los tipos de datos primitivos y proporcionan métodos para realizar
diferentes tareas con los tipos de datos primitivos, tales como la conversión con
cadenas de caracteres, comprobación, traslación, entre otras.
Existe una clase wrapper para cada uno de los tipos de datos primitivos, que permiten
tratarlos como objetos. Dichas clases se muestran a continuación:
TIPO DE DATO CLASES

PRIMITIVO WRAPPERS
boolean Boolean
byte Byte
char Character
double Double
float Float
int Integer
Long Long
9
Jerarquía de clases: Forma de ordenar las clases.
La jerarquía de clases es una forma de ordenar las clases existentes en un lenguaje de Programación Orientado a
Objetos (POO). Una jerarquía de clases define conceptos abstractos en la parte superior de la jerarquía y conforme
se desciende en la jerarquía los conceptos se tornan cada vez más concretos. Java tiene su propia jerarquía de
clases, estando en la parte superior de la jerarquía, la clase Object (esta clase pertenece al paquete java.lang).
Pag. 267
TIPO DE DATO CLASES

PRIMITIVO WRAPPERS
Short Short
Cada uno de estas clases wrappers (a excepción de Character), tienen un método

que permite convertir desde una cadena (String) al tipo primitivo. Simplemente hay
que ejecutar el método de la clase wrappers adecuada y el String se convierte al tipo
de dato primitivo asociado.
JERARQUÍA DE CLASES Y HERENCIA
java.lang.Object
java.lang.Boolean java.lang.Character java.lang.Number
Byte Double Float Integer Long Short
Las clases Java, en general, tienen métodos estáticos y métodos de instancia. Para
ejecutar un método de instancia es necesario crear un objeto de la clase donde está
definido dicho método. Para crear un objeto en Java se usa la sentencia new (a
excepción de los objetos de algunas clases, como los objetos de la clase String que
no necesariamente se crean con dicha sentencia).
Por ejemplo, para crear un objeto de la clase Integer

utilizamos:
int i = 5;
Integer I = new Integer ( i );
Donde el objeto I, es un objeto de la clase Integer, que tiene

un valor igual a 5 y métodos para manipular dicho valor.
Pag. 268
MÉTODOS
Con la finalidad de resumir los métodos de las clases wrappers que permiten la
conversión, comprobación y traslación de datos, se utilizarán algunos objetos de
dichas clases. Se asume que los objetos han sido creados previamente. Dichos
objetos son:
CLASE AL QUE
OBJETO
PERTENECE
S String
I Integer
L Long
F Float
D Double
C Character
También se utilizarán algunas variables para lo cual se deberá asumir que dichas
variables han sido declaradas previamente. Las variables son:
TIPO DE DATO
VARIABLE
PRIMITIVO
i int
l long
f float
d double
b boolean
c char
Para referirnos a objetos se utilizará una letra en mayúscula, mientras que, para
referirnos a las variables se utilizará una letra minúscula.
Pag. 269
Conversión de tipo de dato primitivo a objeto String
Se puede convertir el valor de un tipo de dato primitivo o simple, a un valor de tipo

cadena contenido en un objeto String. Para realizar esta conversión, se puede utilizar
clases wrappers y variables, o utilizar objetos de las clases wrappers. Esto depende si
se tiene disponible la variable (con el tipo de dato primitivo) o el objeto de la clase
wrapper (que contiene el valor).
Conversión de tipo de dato primitivo a objeto String utilizando clases

wrappers y variables:
CLASES WRAPPERS Y
OBJETO STRING
VARIABLES
S = Integer.toString (i ) ;
S = Long.toString ( l ) ;
S = Float.toString ( f ) ;
S = Double.toString ( d ) ;
Observe que se utiliza el método toString ( ) para convertir el valor de una variable a
un valor de tipo cadena contenido en un objeto String. El método toString ( ) es un
método estático o de clase por que se utiliza directamente el nombre de la clase para
ejecutar el método.
Conversión de tipo de dato primitivo a objeto String utilizando

objetos wrappers:
OBJETO STRING OBJETOS WRAPPERS
S = I.toString ( ) ;
S = L.toString ( ) ;
S = F.toString ( ) ;
S = D.toString ( ) ;
Observe que se utiliza el método toString ( ) para convertir el valor contenido en el

objeto wrappers a un valor de tipo cadena contenido en un objeto String. A pesar que
el método toString ( ) es un método estático o de clase, también puede ejecutarse
utilizando un objeto.
Pag. 270
Todas las clases wrappers tienen en común el método estático o de clase toString ( ).
Esto se debe, a que este método no pertenece a dichas clases, sino que pertenece a
la clase Object.
La clase Object es la clase principal en la Jerarquía de Clases de Java (se puede

decir que es la clase padre de todas las clases). Todas las clases en Java pueden
utilizar los métodos definidos en la clase Object (debido fundamentalmente a la
herencia), y uno de los métodos definidos en esta clase, como ya se ha mencionado,
es el método toString ( ).
|
Conversión de objetos String a tipo de dato primitivo
Se puede convertir un objeto String a un tipo de dato primitivo, siempre y cuando el

objeto String contenga un dato equivalente al tipo de dato primitivo que se desea
convertir.
Conversión de objetos String a tipos de dato primitivo, utilizando

clases wrappers y objeto String:
VARIABLE WRAPPERS Y OBJETO STRING
Integer.valueOf (S) ;
i =
Integer.parseInt (S) ;
Long.valueOf (S) ;
l =
Long.parseLong (S) ;
Float.valueOf (S) ;
f =
Float.parseFloat (S) ;
Double.valueOf (S) ;
d =
Double.parseDouble (S) ;
Observe que se utiliza el método valueOf ( ) para convertir el valor contenido en el

objeto String S, a un dato de tipo primitivo o valor de una variable. Este método es un
método estático o de clase. También se tiene la posibilidad de utilizar los métodos
parseInt ( ), parseLong ( ), parseFloat ( ) y parseDouble ( ) para los wrappers Integer,
Long, Float y Double respectivamente.
Pag. 271
Conversión de objetos wrappers a tipos de datos primitivos
Se puede convertir un valor de tipo cadena contenido en un objeto String a un valor

de un tipo de dato primitivo o simple, siempre y cuando el objeto String contenga un
valor equivalente al valor del tipo de dato primitivo que se desea convertir.
Conversión de objetos wrappers a tipos de dato primitivo, utilizando

clases wrappers:
VARIABLE CLASES WRAPPERS
I.intValue ( ) ;
L.intValue ( ) ;
i =
F.intValue ( ) ;
D.intValue ( ) ;
I.longValue ( ) ;
L.longValue ( ) ;
l =
F.longValue ( ) ;
D.longValue ( ) ;
I.floatValue ( ) ;
L.floatValue ( ) ;
f =
F.floatValue ( ) ;
D.floatValue ( ) ;
I.doubleValue ( ) ;
L.doubleValue ( ) ;
d =
F.doubleValue ( ) ;
D.doubleValue ( ) ;
Observe que todas las clases wrappers tienen en común los métodos de instancia
intValue ( ), longValue ( ), floatValue ( ) y doubleValue ( ).
Todas las clases wrappers tienen en común los métodos de instancia intValue( ),
longValue( ), floatValue( ) y doubleValue( ). Estos métodos pertenecen en realidad a
la clase Number.
La clase Number es la superclase de las clases wrappers (a excepción de la clase

wrapper Character). Estas clases pueden utilizar los métodos definidos en la clase
Number a través de la herencia.
Pag. 272
Comprobaciones del valor Not-a-Number
Comprobación del valor Not-a-Number utilizando clases wrappers y

variables:
CLASES WRAPPERS Y
VARIABLE
VARIABLES
Float.isNaN ( f ) ;
b =
Double.isNaN ( d );
Comprobación del valor Not-a-Number utilizando clases wrappers y

variables:
VARIABLE OBJETOS WRAPPERS
F.isNaN ( ) ;
b =
D.isNaN ( );
Observe que se utiliza el método isNaN ( ) para determinar si la variable es o no un

número. El método devuelve true si el valor de la variable no es un número.
Los valores Not-a-Number proceden de indeterminaciones tales como por ejemplo el
resultado de la siguiente operación: 0.0 / 0.0.
Comprobaciones del valor infinito
Comprobación del valor infinito utilizando clases wrappers y

variables:
CLASES WRAPPERS Y
VARIABLE
VARIABLES
Float.isInfinite ( f ) ;
b =
Double.isInfinite ( d );
Pag. 273
Comprobación del valor infinito utilizando objetos wrappers:
VARIABLE OBJETOS WRAPPERS
F.isInfinite ( ) ;
b =
D.isInfinite ( );
Observe que se utiliza el método isInfinite ( ) para determinar si la variable es o no un

número infinito. El método devuelve true si el valor de la variable es un número
infinito.
Los valores Infinite proceden normalmente de la división por cero de un valor finito.
Por ejemplo el resultado de la siguiente operación: 10.5 / 0.0.
Comprobaciones de caracteres
Comprobación de caracteres utilizando la clase Character y variable

tipo char:
VARIABLE CLASE Character Y VARIABLE char
“Devuelve true si el
Character.isLowerCase (c) ; caracter es una
letra minúscula”.
Character.isUpperCase (c) ; caracter es una
letra mayúscula”.
b =
Character.isDigit (c) ; caracter es un
dígito decimal”.
Character.isSpace (c) ; caracter es un
espacio en blanco”.
Pag. 274
Traslación de caracteres
Traslación de caracteres utilizando la clase Character y variable tipo

char:
VARIABLE CLASE Character y VARIABLE char
“Convierte el
Character.toLowerCase (c); caracter a una letra
minúscula”.
c =
“Convierte el
Character.toUpperCase (c); caracter a una letra
mayúscula”.
Pag. 275
Problema 61
Desarrollar un programa en Java que permita convertir valores de diferentes tipos de

datos en valores de tipo cadena.
Clase PrgConvertirAString
class PrgConvertirAString {
boolean estado = true;

char letra = ‘z’;
int numEntero = 10;
long numEnteroLargo = 100000000;
float numReal = 15.5f;
double numRealDoble = 10000.98;
String cadena = “ ”;
cadena = String.valueOf ( estado ) ;

System.out.println ( “ Tipo boolean en String: ” + cadena ) ;
cadena = String.valueOf ( letra ) ;
System.out.println ( “ Tipo char en String: ” + cadena ) ;
cadena = String.valueOf ( numEntero ) ;
System.out.println ( “ Tipo int en String: ” + cadena ) ;
cadena = String.valueOf ( numEnteroLargo ) ;
System.out.println( “ Tipo long en String: ” + cadena ) ;
cadena = String.valueOf ( numReal ) ;
System.out.println ( “ Tipo float en String: ” + cadena ) ;
cadena = String.valueOf ( numRealDoble ) ;
System.out.println ( “ Tipo double en String: ” + cadena ) ;
}
}
Observe que es posible convertir cualquier tipo de dato a cadena (String) utilizando el método valueOf ( ) de
la clase String. En ciertas ocasiones esto es necesario ya que las cadenas pueden ser manipuladas. Analice
como se pueden manipular las variables de tipo cadena (String) más adelante en este mismo capítulo.
Pag. 276
Problema 62
Desarrollar un programa en Java que permita obtener la fecha del sistema y la

convierta en un valor de tipo cadena.
Clase PrgConvertirFecha
import java.util.Date ;
class PrgConvertirFecha {
Date hoy = new Date() ;

String cadena = “ ”;
cadena = hoy.toString ( ) ;
System.out.println ( “ Fecha: ” + cadena ) ;
}
}
La clase Date, es una clase propia de Java y está incluida en el paquete java.util. En este paquete podrá
encontrar clases de utilidad para sus aplicaciones. Este paquete está fuera del alcance del presente texto
(sugiero que investigue las clases que forman parte de este paquete).
El ejecutar esta aplicación se visualizará algo parecido a lo siguiente:
Fecha: Sat Mar 20 11:38:46 GMT-05:00 2004.
Observe como se convierte la fecha almacenada en un objeto (llamado hoy) de la clase Date en una cadena
(String) utilizando el método toString ( ) de la clase String. Esta cadena de texto podrá ser manipulada para
obtener otros datos, tales como, el día, el mes, el año actual o la hora del sistema. Analice como se pueden
manipular las variables de tipo cadena (String) más adelante en este mismo capítulo.
Pag. 277
Problema 63
Desarrollar un programa en Java que permita convertir una cadena en un número

entero y en un objeto de tipo Integer. Calcular y mostrar la suma de ambos valores.
Clase PrgCadenaAEntero
class PrgCadenaAEntero {
int numEntero = 0 ;
String cadena = “10" ;
numEntero = Integer.parseInt ( cadena ) ;

Integer objInteger = Integer.valueOf ( cadena ) ;
System.out.println ( “ Valores enteros: ” + numEntero + “ " + objInteger ) ;

System.out.println ( “ La suma es: ” + (numEntero + objInteger.intValue ( ) ) ) ;
}
}
Observe que es posible convertir una cadena (String) en un valor entero (int) o en un objeto de la clase
Integer. Recuerde, que deberá asegurarse que la cadena contenga un valor válido para que pueda ser
almacenado en un tipo de dato determinado.
Puede utilizar el método parseInt ( ) de la clase String para convertir una cadena en un número entero
(numEntero) y también el método valueOf ( ) de la clase Integer para convertir una cadena en un un objeto
(objInteger) de la clase Integer. El método intValue ( ) nos permite obtener el valor entero del objeto
(objInteger) de la clase Integer.
Como sugerencia desarrolle un programa en Java que realice lo mismo que este programa pero utilice una
variable long y la clase Long.
Pag. 278
Problema 64
Desarrollar un programa en Java que permita convertir una cadena en un número real y
en un objeto de tipo Double. Calcular y mostrar la suma de ambos valores.
Clase PrgCadenaAReal
class PrgCadenaAReal {
double numRealDoble = 0 ;
String cadena = “10.5” ;
numRealDoble = Double.parseDouble ( cadena ) ;

Double objDouble = Double.valueOf ( cadena ) ;
System.out.println ( “ Valores enteros: ” + numRealDoble + “ ” + objDouble ) ;

System.out.print ( “ La suma es: ” ) ;
System.out.println ( numRealDoble + objDouble.doubleValue ( ) ) ;
}
}
Observe que es posible convertir una cadena (String) en un valor entero (double) o en un objeto de la clase
Double. Recuerde, que deberá asegurarse que la cadena contenga un valor válido para que pueda ser
almacenado en un tipo de dato determinado.
Puede utilizar el método parseDouble ( ) de la clase Double para convertir una cadena en un número real
(numRealDoble) y también el método valueOf ( ) de la clase Double para convertir una cadena en un un
objeto (objDouble) de la clase Double. El método doubleValue ( ) nos permite obtener el valor real del objeto
(objDouble) de la clase Double.
Como sugerencia desarrolle un programa en Java que realice lo mismo que este programa pero utilice una
variable float y la clase Float.
Pag. 279
Pag. 280
FUNCIONES MATEMÁTICAS: CLASE MATH
INTRODUCCIÓN
La clase Math, es una clase que viene incorporada en el lenguaje de programación

Java, incluida en el paquete java.lang, la cual nos proporciona métodos y atributos,
para implementar diversas funciones mátemáticas.
java.lang.Object
java.lang.Math
El paquete java.lang es el paquete principal del lenguaje Java por lo cual no se

necesita importar ninguna clase incluida en dicho paquete. En consecuencia, no será
necesario importar el paquete java.lang cada vez que se necesite utilizar la clase
Math de Java.
La clase Math contiene métodos de cálculo básico, como exponencial, logaritmo, raiz
cuadrada y funciones trigonométricas. La clase Math a diferencia de otras clases es
10
una clase final . Esto significa que no puede ser instanciada (es decir; no se pueden
crear objetos de la clase Math). Los métodos de la clase Math son métodos estáticos
(llamados también métodos de clase) y para poder utilizarlos solo se debe colocar el
nombre de la clase, el operador punto y el nombre del método a utilizar.
Ejemplo:
Math.pow (a, b) ;
10
Clase Final: No puede ser una superclase.
Una clase final o declarada como final es una clase que no puede ser una superclase. Es decir, las clases finales no
pueden heredarse. Todos los métodos de una clase final son implícitamente finales.
Pag. 281
MÉTODOS
La clase Math presenta los siguientes atributos y métodos de clase:
Atributos de clase:
1. E.
2. PI.
Métodos de clase:
1. abs( ).
2. acos( ).
3. asin( ).
4. atan( ).
5. ceil( ).
6. cos( ).
7. exp( ).
8. floor( ).
9. log( ).
10. max( ).
11. min( ).
12. pow( ).
13. random( ).
14. round( ).
15. sin( ).
16. sqrt( ).
17. tan( ).
18. toDegrees( ).
19. toRadians( ).
Para trabajar con los métodos de clase, de la clase Math, no será necesario crear
previamente un objeto de dicha clase (esto se cumple para todas las clases que
implementen métodos de clase).
Para ejecutar un método de clase, de la clase Math, es necesario colocar la palabra

Math (que es el nombre de la clase), el operador punto (.) y el nombre del método de
clase que desea ejecutar.
Asimismo; para ejecutar un método de la clase Math debemos tener en cuenta que si,
el método necesita algunos datos, estos deben ser necesariamente proporcionados
en la cantidad y tipos requeridos. En caso que el método devuelva un resultado
deberá almacenarlo en una variable del mismo tipo que el resultado proporcionado o
mostrarlo a través de la pantalla.
A continuación se presenta una breve descripción del uso de cada uno de los
métodos de la clase Math:
Pag. 282
CLASE Math
ATRIBUTOS DE
DESCRIPCIÓN USO
CLASE
double e = Math.E ;
Almacena el valor de E. Es decir, nos
System.out.print( e) ;
proporciona la base de un logaritmo
E
natural. El valor es equivalente a
Resultado:
2.718281828459045.
e = 2.718281828459045.
double pi = Math.PI ;
Almacena el valor de PI. Es decir, System.out.print( pi) ;
PI almacena el valor equivalente a
3.141592653589793. Resultado:
pi = 3.141592653589793.
MÉTODOS DE
DESCRIPCIÓN USO
CLASE
abs (float)
int x = -5 ;
abs (double) Retorna el valor absoluto de un System.out.print( Math.abs( x)) ;
número (que puede ser float, double,
int, long) dado como parámetro. Resultado:
abs (int) x = 5.
abs (long)
double angulo = 45.0 * Math.PI/180.0;

double result ;
Retorna un valor double con el result = Math.acos( angulo ) ;
arcocoseno de un ángulo expresado System.out.print( result ) ;
acos (double) en radianes. El ángulo expresado en
radianes debe ser un valor double Resultado :
enviado al método como parámetro.
result = 0.6674572160283838
double angulo = 45.0 * Math.PI/180.0 ;

Retorna un valor double con el double result ;
arcoseno de un ángulo expresado en result = Math.asin( angulo ) ;
System.out.print( result ) ;
asin (double) radianes. El ángulo expresado en
radianes debe ser un valor double Resultado :
result = 0.9033391107665127
Retorna un valor double con el

arcotangente de un ángulo expresado double angulo = 45.0 * Math.PI/180.0 ;
double result ;
atan (double) en radianes. El ángulo expresado en result = Math.atan( angulo ) ;
radianes debe ser un valor double System.out.print( result ) ;
Pag. 283
MÉTODOS DE
DESCRIPCIÓN USO
CLASE
Resultado :
result = 0.6657737500283538
double n = 0.65 , result ;

Retorna un valor double con el valor result = Math.ceil( n ) ;
más corto no menor que el parámetro System.out.print( result ) ;
ceil (double)
dado. El parámetro dado debe ser
double. Resultado:
result = 1.0

Retorna un valor double con el coseno double result ;
de un ángulo expresado en radianes. result = Math.cos( angulo ) ;
cos (double) El ángulo expresado en radianes debe System.out.println( result ) ;
ser un valor double enviado al método Resultado :
como parámetro.
result = 0.8660254037844387
double exponente=1.0 , result ;

result = Math.exp(exponente) ;
Retorna un valor double con el valor
System.out.println(result) ;
exponencial de Euler del parámetro
exp (double)
dado. El parámetro dado sebe ser
Resultado:
double.
result = 2.7182818284590455
double n = 5.65 , result ;

result = Math.floor(n) ;
Retorna un valor double con el valor System.out.print(result) ;
floor (double) más grande no mayor que el
parámetro dado. El parámetro dado
Resultado:
debe ser double.
resutl = 5.0
double logaritmo = 3.0 , result ;

Retorna un valor double con el result = Math.log(logaritmo) ;
logaritmo natural (base e) de un System.out.println( result ) ;
log (double)
Resultado:
sebe ser double.
result = 1.0986122886681096
Retorna el valor del número mayor

(que puede ser float, double, int, long)
de dos números dados como
max (float, float) parámetros. double x = 10 , y = 15 , mayor ;
mayor = Math.max( x , y ) ;
System.out.print ( mayor ) ;
max (double, double)
Resultado:
Pag. 284
MÉTODOS DE
DESCRIPCIÓN USO
CLASE
max (int, int) mayor = 15.
max (long, long)
min (float, float)

double x = 10 , y = 15 , menor ;
menor = Math.min( x , y ) ;
min (double, double) Retorna el valor del número menor System.out.print ( menor ) ;
(que puede ser float, double, int, long)
de dos números dados como Resultado:
min (int, int) parámetros.
menor = 10.
min (long, long)
double x = 2 , y = 4 , result ;
Retorna un valor double con la result = Math.pow( x , y ) ;
potencia de un número (dado como System.out.print ( result ) ;
primer parámetro) elevado a otro
pow (double, double)
número (dado como segundo Resultado:
parámetro). Los dos parámetros
dados deben ser double. result = 16.
Retorna un valor double con un double num ;

número generado aleatoriamente (al num = Math.random( ) ;
random ()
azar) mayor o igual que 0.0 y menor System.out.print ( num ) ;
que 1.0.
round (float)
double x = 10.53 , result ;

Retorna un valor (que puede ser float result = Math.round( x ) ;
o double) con el valor redondeado del System.out.print ( result ) ;
puede ser un valor float o double. Resultado:
round (double)
result = 11.
Retorna un valor double con el seno

de un ángulo expresado en radianes. double angulo = 37.0 *
El ángulo expresado en radianes debe Math.PI/180.0; double result ;
sin (double)
ser un valor double enviado al método result = Math.sin(angulo) ;
como parámetro. System.out.println(result) ;
Resultado:
Pag. 285
MÉTODOS DE
DESCRIPCIÓN USO
CLASE
result = 0.6018150231520483
double x = 16 , result ;
Retorna un valor double con la raiz result = Math.sqrt( x ) ;
System.out.print ( result ) ;
cuadrada del parámetro dado. El
sqrt (double)
parámetro dado debe ser un valor
double. Resultado:
result = 4.

Retorna un valor double con la double result ;
tangente de un ángulo expresado en result = Math.tan(angulo);
tan (double) radianes. El ángulo expresado en System.out.println( result ) ;
radianes debe ser un valor double Resultado:
result = 1.3270448216204098
double angulo = Math.PI/3, result ;

Retorna un valor double. Permite result = Math.toDegrees(angulo) ;
convertir un ángulo expresado en System.out.println(result) ;
toDegrees (double) radianes (enviado como parámetro
double) en un ángulo expresado en Resultado:
sexagesimal.
result = 59.99999999999999
double angulo = 60, result ;

Retorna un valor double. Permite result = Math.toRadians(angulo) ;
convertir un ángulo expresado en System.out.println( result ) ;
toRadians (double) sexadecimal (enviado como parámetro
double) en un ángulo expresado en Resultado:
radianes.
result = 1.0471975511965976
A continuación, con la finalidad de mejorar la comprensión del tema tratado, se

presentan algunas soluciones a problemas planteados utilizando algunos de los
métodos de la clase Math. Analice cada una de las siguientes soluciones.
Pag. 286
Problema 65
Desarrollar un programa en Java que permita ingresar 3 números enteros a través del
teclado. Determinar y mostrar cuál de ellos es el número mayor.
Clase PrgNumeroMayor
class PrgNumeroMayor {
int num1, num2, num3, resultado ;
System.out.println ( “ Ingresar el primer número: ” ) ;

num1 = Lectura.leerInt( ) ;
System.out.println ( “ Ingresar el segundo número: ” ) ;

System.out.println ( “ Ingresar el tercer número: ” ) ;

resultado = Math.max ( num1, Math.max ( num2, num3 ) ) ;
System.out.println ( “ El número mayor es: ” + resultado ) ;

}
}
¿Que hay de nuevo en la codificación?
Observe el uso del método max ( ) de la clase Math:
Math.max ( num2, num3 )
Parámetros.
Nombre del método.
Operador punto.
Nombre de la Clase.
Pag. 287
El método max ( ) nos permite determinar el número mayor entre dos números (en nuestro caso el número
mayor entre num2 y num3).
Observe que en esta solución se emplea una estrategia mas simple para determinar el número mayor entre
tres números. El método max ( ) de la clase Math, retorna el valor del número mayor (puede ser un número
float, double, int o long) de dos números dados como parámetros. En nuestro ejemplo determinamos el
mayor de los dos últimos números ingresados y en la misma línea de código evaluamos el mayor de estos
dos números con el primer número ingresado, tal y como se muestra a continuación:
resultado = Math.max ( num1, Math.max ( num2, num3 ) ) ;
Es importante tener presente que el método max ( ) es un método que solo podemos utilizar con la clase
Math y su función es determinar el número mayor entre dos números dados como parámetros.
Pag. 288
Problema 66
Desarrollar un programa en Java que permita ingresar 3 números enteros a través del
teclado. Determinar y mostrar cuál de ellos es el número menor.
Clase PrgNumeroMenor
class PrgNumeroMenor {
int num1, num2, num3, resultado ;
System.out.println ( “ Ingresar el primer número: ” ) ;

System.out.println ( “Ingresar el segundo número: ” ) ;

System.out.println ( “Ingresar el tercer número: ” ) ;

resultado = Math.min ( num1, Math.min ( num2, num3 ) ) ;
System.out.println ( “ El número menor es: " + resultado ) ;

}
}
Observe el uso del método min ( ) de la clase Math: En la codificación de esta solución se emplea una nueva
estrategia para hallar el menor de tres números ingresados por teclado (anteriormente se utilizaban
sentencias if anidadas).
Observe que Math.min ( ) retorna el valor del número menor (que puede ser float, double, int, long) de dos
números dados como parámetros. En nuestro ejemplo hallamos el menor de los dos últimos números
ingresados, y en la misma línea evaluamos el menor de estos dos números con el primer número ingresado,
tal y como se muestra a continuación:
resultado = Math.min ( num1, Math.min ( num2, num3 ) ) ;
Pag. 289
Problema 67
Desarrollar un programa en Java que permita generar una cantidad determinada de

números aleatorios. Los números aleatorios generados deberán estar entre 1 y 6.
Mostrar el número generado aleatoriamente y la suma de dichos números.
Clase PrgNumerosAleatorios
class PrgNumerosAleatorios {
int x, cant, num, suma=0 ;
System.out.print ( “Ingresar la cantidad de números aleatorios a generar: ” ) ;

cant = Lectura.leerInt( ) ;
for ( x = 1; x <= cant; x++) {
num = 1 + (int) ( Math.random( ) * 6 ) ;

System.out.println ( “El número aleatorio generado es: ” + num ) ;
suma = suma + num ;

}
System.out.println ( “La suma de los números aleatorios es: ” + suma ) ;

}
}
Observe el uso del método random ( ) de la clase Math:
num = 1 + (int) (Math.random ( ) * 6 ) ;
En la codificación de esta solución se utiliza una sentencia for con la finalidad de generar la cantidad de
números aleatorios (al azar) que el usuario desee. Cada vez que se ejecuta la sentencia for, se genera y
muestra un número aleatorio (un número entre 1 y 6), el cual es acumulado en la variable suma. Finalizada la
ejecución de la sentencia for se muestra el contenido de dicha variable (es decir, se muestra la suma de los
números aleatorios generados).
Recuerde que para generar números aleatorios entre dos números (entre un intervalo o rango), utilizando el
método random ( ) de la clase Math, se emplea la siguiente fórmula:
Pag. 290
min + (int) ( Math.random( ) * (max – min + 1 ) ) ;
Para nuestro ejemplo tenemos:
1 + (int) ( Math.random( ) * ( 6 – 1 + 1 ) ) ;
1 + (int) ( Math.random( ) * ( 6 ) ) ;
Pag. 291
Problema 68

Mostrar los números aleatorios que son números pares.
Clase PrgNumAleatoriosPares
class PrgNumAleatoriosPares {
int x, cant, num, cont = 0 ;

do {
if (num % 2 == 0) {
cont++;
System.out.print ( num + “ \t ” ) ;
}
} while (cant != cont) ;

}
}
En la codificación de esta solución se utiliza una sentencia do con la finalidad de generar números aleatorios.
Si el número generado es par se le aumenta uno a la variable cont (que esta trabajando como contador de
números pares generados al azar) y se muestra el número generado.
Pag. 292
Problema 69

Mostrar los números aleatorios que son números impares.
Clase PrgNumAleatoriosImpares
class PrgNumAleatoriosImpares {
int x, cant, num, cont = 0 ;

do {
if ( num % 2 == 1 ) {
cont ++;
System.out.print ( num + “ \t ” ) ;
}
} while ( cant != cont ) ;

}
}
En la codificación de esta solución se utiliza una sentencia do con la finalidad de generar números aleatorios.
Si el número generado es impar se le aumenta uno a la variable cont (que esta trabajando como contador de
números impares generados al azar) y se muestra el número generado.
Pag. 293
Problema 70
Desarrollar un programa en Java que permita ingresar por teclado el radio de una
esfera. Calcular y mostrar el volumen de dicha esfera.
Clase PrgRadioEsfera
class PrgRadioEsfera {
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 ) ;

}
}
Observe el uso del método pow ( ) y del atributo PI de la clase Math:
volume = (4 / 3) * Math.PI * Math.pow ( radio, 3 ) ;
El método pow ( ) retorna un valor double con la potencia de un número (dado como primer parámetro)
elevado a otro número (dado como segundo parámetro). En nuestro caso el método pow ( ) eleva a la
potencia 3 el radio del círculo.
Para hallar el volumen de la esfera se tendrá que utilizar la fórmula v=4/3*PI*R3. La clase Math define un
atributo (constante) muy útil, que contiene en valor del número PI (Math.PI).
Pag. 294
Problema 71
Desarrollar un programa en Java que permita ingresar un número decimal. Mostrar el

número ingresado redondeado.
Clase PrgNumRedondeado
class PrgNumRedondeado {
double num, resultado ;
System.out.println ( “Ingrese un número decimal: ” ) ;

num = Lectura.leerDouble( ) ;
resultado = Math.round(num) ;
System.out.println ( “El número redondeado es: ” + resultado ) ;
}
}
Observe el uso del método round ( ) de la clase Math:
resultado = Math.round(num) ;
El método round ( ) permite redondear un número dado como parámetro.
En esta solución se ingresa un número y se almacena en la variable num. Luego, dicho número es
redondeado utilizando el método round ( ) y se almacena en la variable resultado.
Pag. 295
Problema 72
Desarrollar un programa en Java que permita ingresar un número entero y un

exponente. Mostrar el resultado de calcular la potencia de todos los números menores
que el número ingresado elevado al exponente ingresado.
Clase PrgNumPotencia
class PrgNumPotencia {
int cant, expo ;

double rpta ;
System.out.println ( “Ingresar un número entero: ” ) ;

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 ) ;
}
}
}
Observe el uso del método pow ( ) de la clase Math:
rpta = Math.pow ( x, expo ) ;
El método pow ( ) permite elevar a la potencia un número determinado. En la presente solución se utiliza una
sentencia for con la finalidad de elevar a la potencia todos los números menores que la variable cant y
mostrarlos por pantala. La variable cant y el exponente expo se ingresan por el teclado.
Recuerde y siempre tenga presente que el método pow ( ) de la clase Math, retorna un valor double, por lo
que dicho valor deberá ser almacenado en una variable del mismo tipo o deberá mostrarse por la pantalla.
Pag. 296
Problema 73
Desarrollar un programa en Java que permita ingresar un número entero. Mostrar el

resultado de calcular la raíz cuadrada de todos los números menores que el número
ingresado.
Clase PrgNumRaiz
class PrgNumRaiz {
int cant ;
double rpta ;
System.out.println ( “Ingrese un número entero: ” ) ;

for ( int x = 1; x < cant; x++ ) {
rpta = Math.sqrt (x) ;

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

Mostrar los números generados aleatoriamente elevados al cuadrado.
Clase PrgNumAleatorioCuad
class PrgNumAleatorioCuad {
int cant, num ;

double rpta ;

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 ) ;
}
}
}
Observe el uso de los métodos random ( ) y sqrt ( ) de la clase Math:
num = (int) ( 1 + ( Math.random() * 10 ) ) ;

rpta = Math.pow (num, 2) ;
En la presente solución se utiliza una sentencia for con la finalidad de obtener números aleatorios, elevarlos
al cuadrado y mostrarlos por pantalla. La variable cant se ingresa por el teclado.
Pag. 298
Problema 75
Desarrollar un programa en Java que permita determinar y mostrar el área de un

tríangulo en base a las longitudes de sus lados. Considerar el valor absoluto de la
diferencia entre el semiperimetro y cada uno de los lados. Utilizar las siguientes
fórmulas:
area = ( p * (|p-a|)*(|p-b|)*(|p-c|)) RAIZ (2).
p = (a+b+c) / 2.
Donde:
p = Semiperímetro.
a, b, c = Lados del triángulo.
Clase PrgTriangulo
class PrgTriangulo {
double a, b, c, p, tmp, area ;
System.out.println ( “Ingrese el valor del primer lado del triángulo (a): ” ) ;

a = Lectura.leerDouble( ) ;
System.out.println ( “Ingrese el valor del segundo lado del triángulo (b): ” ) ;

b = Lectura.leerDouble( ) ;
System.out.println ( “Ingrese el valor del terecr lado del triángulo (c): ” ) ;

c = Lectura.leerDouble( ) ;
p = (a + b + c) / 2 ;
tmp = ( p * (Math.abs(p - a)) * (Math.abs(p - c)) * (Math.abs(p - b) ) ) ;
area = Math.sqrt ( tmp ) ;
System.out.println ( “El área del triángulo es: ” + area ) ;

}
}
Pag. 299
Observe el uso de los métodos abs ( ) y sqrt ( ) de la clase Math:
tmp = ( p * (Math.abs(p - a)) * (Math.abs(p - c)) * (Math.abs(p - b) ) ) ;

area = Math.sqrt ( tmp ) ;
En esta solución se ingresan los valores de los tres lados de un triángulo y se obtiene el valor del
semiperímetro del triángulo.
Luego, se procede a calcular el área del triángulo en base a la siguiente fórmula:
area = ( p * (|p-a|)*(|p-b|)*(|p-c|)) RAIZ (2)
Primero, se hace uso del método abs ( ) de la clase Math para calcular el valor absoluto de la diferencia entre
el semiperímetro y cada uno de los lados del triángulo. Luego, se multiplican los valores resultantes con el
valor del semiperímetro del triángulo y finalmente, se obtiene la raíz cuadrada del valor resultante utilizando
el método sqrt ( ) de la clase Math.
Pag. 300
Problema 76
Desarrollar un programa en Java que permita determinar y mostrar el perímetro y el

área de un círculo. Utilizar las siguientes fórmulas:
perimetro = 2 * PI * radio.
area = PI * radio * radio.
Clase PrgCirculo
class PrgCirculo {
double radioCirculo, areaCirculo, perimetroCirculo ;
System.out.println ( “ Ingrese el valor del radio del círculo: ” ) ;

radioCirculo = Lectura.leerDouble( ) ;
areaCirculo = Math.PI * Math.pow (radioCirculo, 2) ;

perimetroCirculo = 2 * Math.PI * radioCirculo ;
System.out.println ( “ El área del círculo es: ” + areaCirculo ) ;

System.out.println ( “ El perímetro del círculo es : ” + perimetroCirculo ) ;
}
}
Pag. 301
Problema 77
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. = Nulo.
Entre 0 y 90 grados. = Agudo.
90 grados. = Recto.
Entre 90 y 180 grados. = Obtuso.
180 grados. = Llano.
Entre 180 grados y 360 grados. = Cóncavo.
360 grados. = Completo.
Clase PrgConversionAngulo
class PrgConversionAngulo {
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” ;
tipoAngulo = “Recto” ;
tipoAngulo = “Obtuso” ;
tipoAngulo = “Llano” ;
tipoAngulo = “Concavo” ;
tipoAngulo = “Completo” ;
anguloRadianes = Math.toRadians (anguloGrados) ;
System.out.println ( “ Tipo de ángulo: ” + tipoAngulo ) ;
System.out.println ( “ Ángulo expresado en radianes: ” + anguloRadianes ) ;
}
}
Pag. 302
Observe el uso del método toRadians ( ) de la clase Math:
anguloRadianes = Math.toRadians (anguloGrados) ;
Para el desarrollo de esta solución se hace uso de sentencias if múltiples con la finalidad de determinar el
tipo de ángulo ingresado por teclado. El tipo de ángulo es almacenado en una variable String (tipoAngulo) y
mostrado por pantalla.
Para realizar la conversión del ángulo ingresado en el sistema sexagesimal al sistema radial se utiliza el
método toRadians ( ) de la clase Math.
Pag. 303
Problema 78
Desarrollar un programa en Java que permita determinar y mostrar las raíces de una
ecuación de segundo grado. Tipo:
2
Ax + Bx + C = 0
Considerar que la solución puede tener raíces imaginarias. Utilizar la siguiente fórmula:
x = ( - B + - ( ( B ** 2 – 4 * A * C ) RAIZ ( 2 ) ) ) / 2 * A.
Clase PrgEcuacion2Grado
class PrgEcuacion2Grado {
int a, b, c ;
double tmp, x, x1, x2 ;
System.out.println ( “ Ingrese el coeficiente A: ” ) ;
a = Lectura.leerInt( ) ;
System.out.println ( “ Ingrese el coeficiente B: ” ) ;
b = Lectura.leerInt( ) ;
System.out.println ( “ Ingrese el coeficiente C: ” ) ;
c = Lectura.leerInt( ) ;
if (a == 0 && b == 0) {
System.out.println ( “ La ecuación no tiene solución ” ) ;
} else {
tmp = Math.pow (b, 2) - (4 * a * c) ;
if (tmp < 0) {
System.out.println ( “ La ecuación tiene raices imaginarias ” ) ;
} else {
if (a == 0) {
x = c / b * (-1) ;
System.out.println ( “ El valor para x es: ” + x ) ;
} else {
x1 = ( - b + Math.sqrt (tmp)) / (2 * a) ;
x2 = ( - b - Math.sqrt (tmp)) / (2 * a) ;
System.out.println ( “ El primer valor para x es: ” + x1 ) ;
System.out.println ( “ El segundo valor para x es: ” + x2 ) ;
}
}
}
}
}
Pag. 304
Observe el uso de los métodos pow ( ) y sqrt ( ) de la clase Math:
En esta solución se ingresan los coeficientes de una ecuación de segundo grado (a, b y c). Si los coeficientes
a y b son iguales a cero, se muestra un mensaje por la pantalla; “La ecuación no tiene solución”. Caso
contrario, se determina el valor de la discriminante, el cual se almacena en la variable tmp utilizando la
siguiente formula:
tmp = Math.pow (b, 2) - (4 * a * c) ;
En caso que el valor de tmp sea igual a cero, se muestra el siguiente mensaje por pantalla; “La ecuación
tiene raices imaginarias”. Caso contrario, si el coeficiente a es igual a cero la ecuación tendría una sola
solución, la cual se calcularía utilizando:
x = c / b * (-1) ;
Si el coeficiente a es diferente de cero la ecuación tendría dos soluciones, las cuales se calcularían
utilizando:
x1 = ( - b + Math.sqrt (tmp)) / (2 * a) ;
x2 = ( - b - Math.sqrt (tmp)) / (2 * a) ;
Pag. 305
Problema 79
Desarrollar un juego en Java que permita generar un número aleatorio. Se debe

intentar adivinar que número es el que generó la computadora. El rango de números
válidos en el juego es de 1 a 100, y cada vez que intente adivinar le indicará si el
número buscado es menor o es mayor.
Clase PrgJuego
class PrgJuego {
int maximo = 100, num, numAzar, inten = 1 ;
double tmp;
System.out.println ( “ Bienvenido al juego: ¿Que número es? ” ) ;
System.out.println ( “ ----------------------------------------------------” ) ;
System.out.println ( “ - La computadora genera un -” ) ;
System.out.println ( “ - numero aleatorio y ud. tratara -” ) ;
System.out.println ( “ - de adivinar que número es -” ) ;
System.out.println ( “ - Trate de adivinar el número en -” ) ;
System.out.println ( “ - el menor número de intentos -” ) ;
do {
System.out.println ( “ Ingrese un número entre 0..100: ” ) ;
num = Lectura.leerInt( ) ;
} while (num < 0 || num > 100 ) ;
tmp = maximo * Math.random( ) ;
numAzar = (int) Math.round(tmp) ;
while (num != numAzar) {
inten++ ;
if (num < numAzar)
System.out.println ( “ El número buscado es mayor ” ) ;
else
System.out.println ( “ El número buscado es menor ” ) ;
do {
System.out.println ( “ Ingrese otro número entre 0..100: ” ) ;
num = Lectura.leerInt( ) ;
} while (num < 0 || num > 100) ;
}
System.out.println ( “ Ud. encontró el número en: ” + inten + “ intento(s) ” ) ;
}
}
Pag. 306
¿Qué hay de nuevo en la codificación?
Observe el uso de los métodos random ( ) y round ( ) de la clase Math:
Utilizando el método random ( ) generamos un número aleatorio (al azar) entre el número 0 y el número 100,
utilizando la siguiente fórmula:
tmp = maximo * Math.random( ) ;
El número generado aleatoriamente es almacenado en la varable tmp. Luego es redondeado utilizando el

método round ( ) y convertido a un número entero utilizando la siguiente sentencia:
numAzar = (int) Math.round(tmp) ;
Este número generado al azar, almacenado en la variable numAzar, es comparado con un número
previamente ingresado por teclado y almacenado en la variable num. Si ambos son iguales, se mostrará un
mensaje indicando que el número numAzar fue encontrado. Si no son iguales, se mostrará un mensaje,
indicando si el número buscado es mayor o es menor (en relación al número ingresado) y se solicitará otro
número hasta encontrar el número que se generó en forma aleatoria.
Intente modificar la codificación de la solución. Utilice la sentencia do y optimice el código.
Pag. 307
Problema 80
Desarrollar un programa en Java que permita ingresar 6 números a traves del teclado.
Determinar y mostrar cuál de ellos es el número mayor y cuál es el número menor.
Clase PrgNumeroMayorMenor
class PrgNumeroMayorMenor {
int n1, n2, n3, n4, n5, n6 ;
double mayor, meno r;
System.out.println ( “ Ingrese el primer número: ” ) ;
n1 = Lectura.leerInt();
System.out.println ( “ Ingrese el segundo número: ” ) ;
n2 = Lectura.leerInt( ) ;
System.out.println ( “ Ingrese el tercer número: ” ) ;
System.out.println ( “ Ingrese el cuarto número: ” ) ;
System.out.println ( “ Ingrese el quinto número: ” ) ;
System.out.println ( “ Ingrese el sexto número: ” ) ;
mayor = Math.max (n1,n2) ;
mayor = Math.max (mayor,n3) ;
menor = Math.min (n1,n2) ;
menor = Math.min (menor,n3) ;
System.out.println ( “ El mayor número es: " + mayor ) ;
System.out.println ( “ El menor número es: " + menor ) ;
}
}
Modificar la codificación de la solución de tal forma que pueda optimizar el código. Utilice una sentencia for.
Pag. 308
Problema 81
Desarrollar un programa en Java que permita ingresar las notas de todos los alumnos
de un determinado salon de clase. Calcular y mostrar el promedio final de cada alumno
en base a la siguiente fórmula:
pf = ( pp + ep + ( ef * 2 ) ) / 4.
Donde:
pf = Promedio final.
pp = Promedio de prácticas.
Son 4 prácticas de las cuales se elimina la más baja
pp = ( p1 + p2 + p3 + p4 – notaMenor ) / 3
ep = Examen parcial.
ef = Examen final.
Clase PrgPromedioNotas
class PrgPromedioNotas {

double pf, pp, ep, ef, p1, p2, p3, p4, notaMenor ;
char opc ;
do {
System.out.println ( “ Ingrese la nota de la práctica 1: ” ) ;

p1 = Lectura.leerDouble( ) ;
System.out.println ( “ Ingrese la nota 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
Clase PrgPromedioNotas
pp = ( p1 + p2 + p3 + p4 – notaMenor ) / 3 ;
pf = ( pp + ep + ef ) / 3 ;
pf = Math.round (pf) ;
System.out.println ( “ El promedio final del alumno es: ” + pf ) ;

System.out.println ( “ Desea continuar (si=s/ no=n)?: ” ) ;
opc=Lectura.leerChar( ) ;
} while ( opc=='s' || opc=='S' ) ;
}
}
Modificar la codificación de la solución de tal forma que se elimine la práctica con la nota más baja y se
duplique la nota de la práctica más alta. Muestre el promedio de las notas redondeado a dos decimales.
Pag. 310
Problema 82
Desarrollar un programa en Java que permita ingresar un número cualquiera con parte
decimal y muestre la parte entera del número, el número redondeado sin decimales, y
el número redondeado a uno, dos y tres decimales.
Clase PrgRedondearNumero
class PrgRedondearNumero {
double numero ;
System.out.println ( “ Ingrese un número con decimales: ” ) ;

numero=Lectura.leerDouble( ) ;
System.out.println ( “ -----------------------------------” ) ;
System.out.println ( “ La parte entera del número es: ” ) ;
System.out.println ( Math.floor (numero) ) ;
System.out.println ( “ El número redondeado es: ” ) ;

System.out.println ( Math.floor (numero+0.5) ) ;
System.out.println ( “ El número redondeado a un decimal es: ” ) ;

System.out.println ( Math.floor (numero * 10 + 0.5 ) / 10 ) ;
System.out.println ( “ El número redondeado a dos decimales es: ” ) ;

System.out.println ( “ El número redondeado a tres decimales es: ” ) ;

}
}
Observe el uso del método floor ( ) de la clase Math:
El método floor ( ) retorna un valor double con el valor más grande no mayor que el parámetro dado. El
parámetro dado debe ser double. Nótese que si ingresamos un numero cuya parte decimal es mayor que 5
sólo retorna la parte entera para tal caso se le agrega 0.5 para que en el segundo cálculo tenga efecto de
redondeo perfecto. Observe como se redondea un número con uno, dos y tres decimales utilizando el
método floor ( ).
Pag. 311
Problema 83
Desarrollar un programa en Java que permite realizar un sorteo en base a un número

determinado de boletos.
Sugerencia:
Utilice el método random ( ) de la clase Math para
generar el número del boleto ganador.
Clase PrgSorteo
class PrgSorteo {
double num ;
int boletos, ganador ;
do {
System.out.println ( “ Ingrese el total de boletos: ” ) ;

boletos = Lectura.leerInt( ) ;
if (boletos > 0) {
do {
num = boletos * Math.random( ) ;

ganador = (int) Math.round(num) ;
} while (ganador == 0) ;
System.out.println ( “ El número ganador es: ” + ganador ) ;

}
} while ( boletos < 0 ) ;

}
}
Pag. 312
Problema 84
Desarrollar un programa en Java que permita calcular la suma de cuadrados y la suma

de cubos de los “n” primeros números. Se deberá ingresar un número por teclado y
mostrar los resultados.
Clase PrgSumaCuadradosCubos
class PrgSumaCuadradosCubos {
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
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.
Clase PrgSenCos
class PrgSenCos {
double anguloGrados, anguloRadianes, seno = 0, coseno = 0 ;
do{
System.out.println ( “ Ingrese un ángulo en grados entre 0 y 360: ” ) ;

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 ) ;
}
}
Observe el uso de los métodos toRadians ( ), sin ( ) y cos ( ) de la clase Math:
Es importante mencionar que Java trabaja con el sistema radial y para obtener las razones trigonométricas,
seno y coseno, de un ángulo ingresado por teclado hay que convertirlo primero al sistema radial. Para esto,
utilizamos el método toRadians ( ) de la clase Math. Este método retorna un valor double y permite convertir
un ángulo expresado en el sistema sexagesimal (enviado como parámetro double) en un ángulo expresado
Pag. 314
en radianes. Una vez convertido el ángulo en radianes podemos utilizar los métodos sin ( ) y cos ( ) de la
clase Math para obtener el seno y el coseno del ángulo ingresado por teclado.
Pag. 315
Problema 86
Desarrollar un programa en Java que permita ingresar un ángulo de inclinación de la

recta con respecto al eje x. Mostrar como resultado la pendiente de la recta.
Clase PrgTangente
class PrgTangente {
double anguloGrados, anguloRadianes, tangente = 0 ;
System.out.println ( “ Ingrese el ángulo de inclinación de la recta: ” ) ;

anguloRadianes = Math.toRadians(anguloGrados) ;
tangente = Math.tan(anguloRadianes) ;
System.out.println ( “ La pendiente de la resta es = ” + tangente ) ;
}
}
Observe el uso del método tan ( ) de la clase Math:
El método tan ( ) permite hallar la pendiente de una recta con respecto al eje X. Para ello, utiliza el ángulo de
inclinación de la recta, expresado en el sistema radial, tal y como se muestra:
tangente = Math.tan(anguloRadianes) ;
Pag. 316
Problema 87
Desarrollar un programa en Java que permita ingresar los catetos de un triángulo

perpendicular. Calcular y mostrar la hipotenusa del tríangulo.
Clase PrgHipotenusa
class PrgHipotenusa {
double cateto1, cateto2, hipotenusa ;
System.out.println ( “ Ingrese el primer cateto: ” ) ;

cateto1 = Lectura.leerDouble( ) ;
System.out.println ( “ Ingrese el segundo cateto: ”) ;

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

Ingrese el segundo cateto: 3
La hipotenusa del triángulo es: 3.605551275463989
Pag. 317
Problema 88
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.
Clase PrgPunto
class PrgPunto {
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) ;
}
}
Observe el uso de los métodos atan2 ( ) y toDegress ( ) de la clase Math:
anguloRadianes = Math.atan2(ordenada, abscisa) ;

anguloGrados = Math.toDegrees(anguloRadianes) ;
Sabemos que Math.atan ( ) retorna un valor double con el arcotangente de un ángulo expresado en radianes.
Dicho ángulo expresado en radianes debe ser un valor double enviado al método como parámetro.
Pag. 318
Pero en este caso, se ingresan por teclado la ordenada y la abcisa de un punto cualquiera en el sistema de
coordenadas, por lo que el método atan ( ) de la clase Math no nos serviría (este método necesita el valor de
un ángulo expresado en radianes y no los valores de las coordenadas de un punto).
En este caso, se utiliza el método atan2 ( ) de la clase Math. Este método nos permite obtener el valor del
arcotangente de un par ordenado.
Es importante mencionar que el método atan2 ( ) nos devuelve el arcotangente de un ángulo expresado en
radianes por lo cual se tendrá que convertir dicho ángulo al sistema sexagesimal, utilizando el método
toDegrees ( ) de la clase Math.
Pag. 319
Problema 89
Desarrollar un programa en Java que permita ingresar un número cualquiera. Calcular

y mostrar el número e elevado al número ingresado y el logaritmo natural (de base e)
del número ingresado.
Clase PrgExpLog
class PrgExpLog {
double num, exponencial, logaritmo ;
System.out.println ( “ Ingrese un número: ” ) ;

num=Lectura.leerDouble();
exponencial = Math.exp(num) ;
logaritmo = Math.log(num) ;
System.out.print ( “ El valor del número [e] elevado a [” + num ) ;

System.out.println ( “] es: ” + exponencial ) ;
System.out.print ( “ El valor del logaritmo [en base e] del número [” ) ;

System.out.println ( num + “] es: ” + logaritmo) ;
}
}
Observe el uso de los métodos exp ( ) y log ( ) de la clase Math:
exponencial = Math.exp(num) ;
logaritmo = Math.log(num) ;
En esta solución se hace necesario el uso del método exp ( ) para obtener el número e elevado al número
ingresado por teclado:
enum
También se hace necesario el uso del método log ( ) para obtener el logaritmo natural del número ingresado
en base e:
logenum
Pag. 320
Tenga presente que Java sólo resuelve logaritmos en base e y no en base 10.
A continuación se presentan algunas soluciones a problemas utilizando básicamente el

método random ( ) de la clase Math, desarrollados con la finalidad de mejorar su comprensión
del tema y sus capacidades lógicas.
Analizar cada uno de las soluciones y desarrolle sus propias conclusiones.
Pag. 321
Problema 90
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.
Clase PrgLanzarDados1
class PrgLanzarDados1 {
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 ) ) ;

suma1 = dado1 + dado2 ;
System.out.println ( “Dado1 : ” + dado1 ) ;

if ( suma1 == 7 || suma1 == 11 ) {
opc1 = “s” ;
estado = 1 ;
Pag. 322
} else
if ( suma1 == 2 || suma1 == 3 || suma1 == 12 ) {
opc1 = “s” ;
estado = 0 ;
} else {
do {


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
Modificar el programa del problema anterior, de tal forma que se muestre un mensaje
preguntando si desea volver a tirar los dados.
class PrgLanzarDados2 {
int dado1 = 0, dado2 = 0, suma1 = 0, suma2 = 0, estado = 0 ;

String opc1 = “ ”, opc2 = “ ” ;
char opc3 = ‘n’ ;
do {
opc1 = “ ” ;
opc2 = “ ” ;
do {



if ( suma1 == 7 || suma1 == 11 ) {
opc1 = “s” ;
estado = 1 ;
} else
if (suma1 == 2 || suma1 == 3 || suma1 == 12) {
opc1 = “s” ;
estado = 0 ;
} else {
Pag. 324
do {


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
Elaborar un programa que simule el lanzamiento de una moneda. Solicitar el número

de veces que se lanzará la moneda. Cuentar el número de veces que aparece cada
lado de la moneda. Mostrar los resultados.
Clase PrgLanzarMoneda
class PrgLanzarMoneda {
int moneda, cont1 = 0, cont2 = 0, cant ;
System.out.println ( “Cuántas veces desea Lanzar moneda ? ” ) ;

cant = Lectura.leerInt ( ) ;
for ( int x = 1; x <= cant; x++ ) {
moneda = ( int ) (1 + ( Math.random ( ) * 2 ) ) ;
if (moneda == 1)
cont1 ++ ;
else
cont2 ++ ;
System.out.println ( “La cantidad de veces que a salido la cara es : ” + cont1 ) ;

System.out.println ( “La cantidad de veces que a salido el sello es : ” + cont2 ) ;
}
}
Pag. 326
Problema 93
Elaborar un programa que simule el juego de tragamonedas, los números son: 1, 2, 3,

4, 5 ,6 y 7 opciones de ganar. El jugador gana cuando el número se repita tres veces.
Los números deberán ser generados aleatoriamente. El premio mayor se obtiene con el
número 7.
Clase PrgTragamoneda1
class PrgTragamoneda1 {
int valor1 = 0, valor2 = 0, valor3 = 0, monto = 0 ;

char s, opc1 ;
do {
System.out.println( “Presionar enter para empezar” ) ;

valor1 = ( 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
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] : ” ) ;
} while ( opc1 != ‘n’ ) ;

}
}
Pag. 328
Problema 94
Modificar el programa del problema anterior, de tal forma que se muestre la cantidad
acumulada del dinero ganado en el tragamoneda.
class PrgTragamoneda2 {
int valor1 = 0, valor2 = 0, valor3 = 0, monto = 0, acumonto = 0 ;

char s,opc1 ;
do {
System.out.println ( “Presionar enter para empezar” ) ;

valor1=( 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
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
Las computadoras están desempeñando un papel cada vez más importante en la

educación. Desarrolle un programa que ayude a un estudiante de primaria a aprender a
multiplicar. Utilice números aleatorios para producir dos enteros positivos de un solo
digito. El programa deberá preguntar ¿Cuánto es 6 por 7?, El estudiante deberá
ingresar la respuesta. El programa verificara si la respuesta es correcta. Si es correcta
mostrará un mensaje ¡Muy bien! y si es incorrecto mostrará el mensaje ¡No es correcto,
por favor intente otra vez!.
Clase PrgMultiplicacion
class PrgMultiplicacion {

int valor1 = 0, valor2 = 0, resul1 = 0, resul2 = 0 ;
char s, opc1 ;
do {
System.out.println ( “Aprendiendo a Multiplicar” ) ;
valor1 = ( int ) (1 + ( Math.random() * 9 ) ) ;

valor2 = ( int ) (1 + ( Math.random() * 9 ) ) ;
resul1 = valor1 * valor2 ;
System.out.println ( “¿Cuánto es ” + valor1 + “ por ” + valor2 + “ ?” ) ;

System.out.println ( “Ingresar resultado de la multiplicación : ” ) ;
resul2 = Lectura.leerInt ( ) ;
if ( resul1 == resul2 )
System.out.println ( “Respuesta correcta… Muy bien” ) ;
else
System.out.println ( “No es la respuesta correcta… Vuelva a intentarlo” ) ;
System.out.println ( “Desea volver a intentarlo [s/n] : ” ) ;

} while ( opc1 != ‘n’ ) ;

}
}
Pag. 331
Problema 96
Modificar el programa del problema anterior, de tal forma que se muestre un menú de
opciones donde permita sumar, restar, multiplicar y dividir dos números generados al
azar. Se permitirá al estudiante contestar la misma pregunta una y otra vez hasta que
responda correctamente.
Clase PrgMenuOperaciones1
class PrgMenuOperaciones1 {
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 ( ) ;

switch ( op ) {
case 1 :
resul1 = valor1 + valor2 ;
operacion = “Suma” ;
signo = ‘+’ ;
break ;
Pag. 332
case 2 :
resul1 = valor1 - valor2 ;
operacion = “Resta” ;
signo = ‘-’ ;
break ;
case 3 :
operacion = “Multiplicación” ;
signo = ‘*’ ;
break ;
case 4 :
resul1 = valor1 / valor2 ;
operacion = “División” ;
signo = ‘/’ ;
break ;
case 5 :
System.exit (0) ;
break ;
}
System.out.println ( “¿Cuánto es ” + valor1 + “ ” + signo + “ ” + valor2 + “ ?” ) ;
do {
System.out.println ( “Ingresar resultado de la ” + operacion + “ :” ) ;

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
Modificar el programa del problema anterior, de tal forma que se muestre un menú de
opciones donde permita sumar, restar, multiplicar y dividir dos números al azar. Mostrar
la cantidad de preguntas correctas y la cantidad de preguntas incorrectas.
class PrgMenuOperaciones2 {
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 ( ) ;

switch ( op ) {
case 1 :
resul1 = valor1 + valor2 ;
operacion = “Suma” ;
signo = ‘+’ ;
break ;
Pag. 334
case 2 :
resul1 = valor1 - valor2 ;
operacion = “Resta” ;
signo = ‘-’ ;
break ;
case 3 :
operacion = “Multiplicación” ;
signo = ‘*’ ;
break ;
case 4 :
resul1 = valor1 / valor2 ;
operacion = “División” ;
signo = ‘/’ ;
break ;
case 5 :
System.exit (0) ;
break ;
}
System.out.println ( “¿Cuánto es ” + valor1 + “ ” + signo + “ ” + valor2 + “ ?” ) ;
System.out.println ( “Ingresar resultado de la ” + operacion + “: ” ) ;

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
Elaborar un programa que permita adivinar cuál es el número entero generado al azar
entre 1 y 1000. El jugador ingresará una primera estimación, si la estimación del
jugador es incorrecta, el programa deberá indicar si el número ingresado fue más
grande o fué más pequeño que el número generado al azar. Cuando la respuesta sea
correcta se mostrará un mensaje de felicitaciones.
Clase PrgAdivinarNumero1
class PrgAdivinarNumero1 {
int valor = 0, num = 0 ;

char opc = ‘ ’ ;
do {
System.out.println ( “Adivine el número” ) ;
valor = ( int ) (1 + ( Math.random ( ) * 1000 ) ) ;
do {
System.out.println ( “Ingresar número : ” ) ;
if ( num < valor )
System.out.println ( “El número es demasiado chico. Pruebe otra vez” ) ;
else
if ( num > valor )
System.out.println ( “El número es demasiado grande. Pruebe otra vez” ) ;
else
System.out.println ( “Felicidades adivinaste el número ” ) ;
} while (num != valor ) ;

System.out.println ( “Desea Continuar [s/n]: ” ) ;
opc = Lectura.leerChar ( ) ;
} while ( opc != ‘n’ ) ;

}
}
Pag. 336
Problema 99
Modificar el programa del problema anterior, de tal forma que se pueda ingresar la
cantidad de intentos que se tiene para adivinar el número.
Clase PrgAdivinarNumero2
Import biblioteca.* ;
class PrgAdivinarNumero2 {
int valor = 0, num = 0, intentos, cont = 0 ;

char opc = ‘ ’ ;
do {
System.out.println ( “Adivine el número” ) ;
System.out.println ( “Ingrese la cantidad de intentos : ” ) ;
intentos=Lectura.leerInt ( ) ;
valor = ( int ) (1 + ( Math.random ( ) * 1000 ) ) ;
do {
System.out.println ( “Ingresar número : ” ) ;
if (cont >= intentos ) {
System.out.println ( “Deberías haberlo hecho mejor” ) ;
valor = num ;
}
else if ( num < valor )
System.out.println ( “El número es demasiado chico. Pruebe otra vez” ) ;
else if ( num > valor )

System.out.println ( “El número es demasiado grande. Pruebe otra vez ” ) ;
else
System.out.println ( “Felicidades adivinaste el número” ) ;
cont ++ ;
} while ( num != valor ) ;
System.out.println ( “Desea Continuar [s/n]: ” ) ;
opc=Lectura.leerChar ( ) ;
} while ( opc != ‘n’ ) ;
}
}
Pag. 337
Pag. 338
MANEJO DE CADENAS: CLASE STRING
INTRODUCCIÓN
Una cadena es un conjunto de caracteres, números y símbolos especiales

almacenados en una variable de tipo texto o cadena.
La clase String, es una clase que viene incorporada en el lenguaje de programación

Java, incluida en el paquete java.lang, la cual permite declarar y manipular variables
de tipo texto o cadena (en realidad no se declaran variables de tipo texto o cadena,
sino que se crean objetos de la clase String).
Ejemplo:
String nom = “Danae” ;
java.lang.Object
java.lang.String
El paquete java.lang es el paquete principal del lenguaje Java por lo cual no se

necesita importar ninguna clase incluida en dicho paquete. En consecuencia, no será
necesario importar el paquete java.lang cada vez que se necesite utilizar la clase
String de Java.
La clase String permite manipular las variables de tipo texto o cadena a través de los
métodos que implementa (la clase String tiene métodos de instancia y métodos de
clase). La clase String incluye métodos que permiten examinar los caracteres
individuales de una cadena para compararlos, para ubicarlos, para extraerlos como
subcadenas, y para crear copias de una cadena convirtiendo todos sus caracteres a
letra mayúscula o minúscula.
Las conversiones son realizadas a través del método toString ( ), método definido en
la clase Object, el cual puede ser utilizado por todas las clases Java a través de la
herencia.
Pag. 339
MÉTODOS
La clase String presenta los siguientes métodos:
Métodos de instancia:
1. charAt( ).
2. compareTo( ).
3. concat( ).
4. endsWith( ).
5. equals( ).
6. equalsIgnoreCase( ).
7. indexOf( ).
8. lastIndexOf( ).
9. length( ).
10. replace( ).
11. startsWith( ).
12. substring( ).
13. toCharArray( ).
14. toLowerCase( ).
15. trim( ).
16. toUpperCase( ).
Métodos de clase:
17. valueOf( ).
Para trabajar con los métodos de instancia de la clase String es necesario

previamente haber declarado y asignado un valor a una variable de tipo texto o
cadena. Para el caso de los métodos de clase esto no será necesario.
Para ejecutar un método de instancia de la clase String es necesario colocar el

nombre de la variable (que debe ser de tipo texto o cadena), el operador punto (.) y el
nombre del método de instancia que se desea ejecutar. Para el caso de los métodos
de clase deberá colocar la palabra String, el operador punto (.) y el nombre del
método de clase que se desea ejecutar.
Asimismo, para ejecutar cualquiera de los método de la clase String, se debe tener en
cuenta que si, el método necesita algunos datos, éstos deben ser necesariamente
proporcionados en la cantidad y tipos requeridos. En caso, que el método devuelva un
resultado, éste deberá almacenarse en una variable del mismo tipo o mostrarse a
través de la pantalla.
A continuación se presenta una breve descripción del uso de cada uno de los
métodos de la clase String:
Pag. 340
CLASE String
MÉTODOS DE
DESCRIPCIÓN USO
INSTANCIA
Devuelve el caracter que

encuentre en la posición indicada
String cad1 = “Hola Danae”;
por la variable entera o número
char x = cad1.charAt(5);
entero colocado como parámetro.
charAt(int)
Es importante mencionar que en
resultado:
Java, el primer caracter de una
x = ‘D’.
cadena se encuentra ubicado en la
posición 0 (cero).
Si la cadena es alfabéticamente
menor que la cadena colocada
como parámetro, el método String cad1 = “Hola Danae”;
devuelve un número entero menor String cad2 = “Hola Pedro”;
que cero. Si las dos cadenas son int x = cad1.compareTo(cad2);
compareTo(String)
alfabéticamente iguales devuelve
un número cero y si la cadena es Resultado:
alfabéticmente mayor que la x < 0 (cad1<cad2).
cadena colocada como parámetro,
el método devuelve un entero
mayor que cero.
String cad1, cad2, cadena;

cad1 = "Hola";
Este método permite juntar dos cad2 = " a todos";
concat(String) cadena = cad1.concat (cad2);
cadenas en una sola cadena.
Resultado :
cadena = "Hola a todos”

Devuelve true (verdadero) si el
String cad2 = “Danae”;
final de la cadena coincide con la
boolean x = cad1.endsWith(cad2);
endsWith(String) cadena colocada como parámetro.
Caso contrario devuelve false
Resultado:
(falso).
x = true.
String cad1 = “Danae”;

Devuelve true (verdadero) si la String cad2 = “Danae”;
cadena coincide con la cadena boolean x = cad1.equals(cad2);
equals(String)
colocada como parámetro. Caso
contrario devuelve false (falso). Resultado:
x = true.
Este método realiza la misma String cad1 = “DANAE”;

función que el método equals ( ) String cad2 = “Danae”;
equalsIgnoreCase(String) pero la comparación la realiza sin boolean x;
tener en cuenta las letras x = cad1.equalsIgnoreCase(cad2);
minúscula y mayúscula.
Resultado:
Pag. 341
MÉTODOS DE
DESCRIPCIÓN USO
INSTANCIA
x = true.

int x = cad1.indexOf(‘D’);
indexOf(char)
Resultado:
x = 5.

int x = cad1.indexOf(‘a’,6);
indexOf(char,int) Devuelve la posición de la cadena
en la que aparece por primera vez Resultado:
el caracter colocado como x = 8.
parámetro.
También se puede especificar un
segundo parámetro a partir del String cad1 = “Hola Danae”;
cual se empieza a buscar hacia int x = cad1.indexOf( “ana” );
indexOf(String)
delante.
Resultado:
x = 6.

int x = cad1.indexOf( “Dan”,3 );
indexOf(String, int)
Resultado:
x = 5.

int x = cad1.lastIndexOf(‘a’);
lastIndexOf(char)
Resultado:
x = 8.

int x = cad1.lastIndexOf(‘a’,5);
lastIndexOf(char,int) Devuelve la posición de la cadena
en la que aparece por última vez el Resultado:
caracter colocado como parámetro. x = 3.
También se puede especificar un
segundo parámetro a partir del String cad1 = “Hola Danae”;
cual se empieza a buscar hacia int x = cad1.lastIndexOf( “ana” );
lastIndexOf(String) atrás.
Resultado:
x = 8.

int x = cad1.lastIndexOf( “lo”,5 );
lastIndexOf(String,int)
Resultado:
x = 2.
Pag. 342
MÉTODOS DE
DESCRIPCIÓN USO
INSTANCIA
Devuelve la longitud de una int x = cad1.length();
length() cadena. Es decir, el número de
caracteres que tiene la cadena. Resultado:
x = 10.
Permite reemplazar todos los String cad1 = “Hola Danae”;

caracteres iguales al caracter String x = cad1.replace(‘a’, ‘o’);
replace(char,char) colocado como primer parámetro
con el caracter colocado como Resultado:
segundo parámetro. x = “Holo Donoe”.

Devuelve un valor true (verdadero) String cad2 = “Hola”;
si el comienzo de la cadena boolean x;
startsWith(String) coincide con la cadena colocada x = cad1.startsWith(cad2);
como parámetro, caso contrario
devuelve false (falso). Resultado:
x = true.

String x = cad1.substring(5);
substring(int) Devuelve una subcadena a partir
de la cadena especificada, Resultado:
empezando desde la posición x = “Danae”.
indicada en el primer parámetro
hasta el final o hasta una posición
anterior a la indicada en el String cad1 = “Hola Danae”;
segundo parámetro del método. String x = cad1.substring(6,9);
substring(int,int)
Resultado:
x = “ana”.

Convierte una cadena específica
char[ ] x = cad1.toCharArray();
en un vector de caracteres. (Los
toCharArray()
vectores serán tratados en el
Resultado:
capítulo IV).
x = {‘H’,‘o’,‘l’,‘a’,‘ ’, ‘D’, ‘a’, ‘n’, ‘a’,‘e’}.

String x = cad1.toLowerCase();
Convierte las letras de una cadena
toLowerCase()
en letras minúsculas.
Resultado:
x = “hola danae”.
String cad1 = “ Hola Danae ”;

Permite eliminar los espacios en String x = cad1.trim();
trim() blanco del inicio y del final de una
cadena. Resultado:
x = “Hola Danae”.
Pag. 343
MÉTODOS DE
DESCRIPCIÓN USO
INSTANCIA
String x = cad1.toUpperCase();
Convierte las letras de una cadena
toUpperCase()
en letras mayúsculas.
Resultado:
x = “HOLA DANAE”.
MÉTODO DE CLASE DESCRIPCIÓN USO
String.valueOf(boolean)
String.valueOf(int) double pi = 3.1416;
String.valueOf(long) Método de clase que permite String x = String.valueOf(pi);
String.valueOf(float) convertir los valores de otros tipos
String.valueOf(double) de datos o variables a una cadena.
String.valueOf(Object) resultado:
String.valueOf(char[ ]) x = “3.1416”.
String.valueOf(char[ ], int,int)
A continuación, con la finalidad de mejorar la comprensión del tema tratado, se

presentan algunas soluciones a problemas planteados utilizando algunos de los
métodos de la clase String. Analice cada una de las siguientes soluciones.
Pag. 344
Problema 100
Desarrollar un programa en Java que permita ingresar el nombre de un alumno. Mostrar

el nombre del alumno en letras mayúscula.
Clase PrgConvertirMayuscula
public class PrgConvertirMayuscula {
public static void main(String [ ] args) {
String nom ;
System.out.print ( “ Ingresar el nombre: ” ) ;

nom = Lectura.leerString( ) ;
nom = nom.toUpperCase( ) ;
System.out.println ( “ El nombre en Mayúscula es: ” + nom ) ;

}
}
Observe el uso del método toUpperCase ( ) de la clase String:
nom.toUpperCase ( ) ;
Nombre del método.
Operador punto.
Nombre de la variable
(objeto).
El método toUpperCase ( ) se utiliza con variables de tipo String y permite convertir en letras mayúsculas el
contenido de la variable que antecede al nombre del método y al operador punto (en nuestro caso la variable
nom). Como el método toUpperCase ( ) nos devuelve un valor de tipo String (el contenido de la variable en
letra mayúscula), podemos mostrar el resultado utilizando System.out.println o almacenarlo en una variable
(que puede ser la variable que contenía la cadena original), tal y como lo hemos realizado en nuestro
ejemplo:
Pag. 345
nom = nom.toUpperCase ( ) ;
Es importante tener presente que el método toUpperCase ( ) es un método que solo podemos utilizar con
variables de tipo String y su función es convertir el contenido de una variable en letras mayúscula.
Pag. 346
Problema 101

el nombre del alumno en letras minúsculas.
Clase PrgConvertirMinuscula
public class PrgConvertirMinuscula {
String nom ;
System.out.print ( “ Ingresar el nombre: ” ) ;

nom = nom.toLowerCase( ) ;
System.out.println ( “ El nombre en Minúscula es: ” + nom ) ;

}
}
Observe el uso del método toLowerCase ( ) de la clase String:
nom.toLowerCase ( ) ;
Nombre del método.
Operador punto.
Nombre de la variable
(objeto).
El método toLowerCase ( ) se utiliza con variables de tipo String y permite convertir en letras minúsculas el
contenido de la variable que antecede al nombre del método y al operador punto (en nuestro caso la variable
nom). Como el método toLowerCase ( ) nos devuelve un valor de tipo String (el contenido de la variable en
letra minúscula), podemos mostrar el resultado utilizando System.out.println o almacenarlo en una variable
(que puede ser la variable que contenía la cadena original), tal y como lo hemos realizado en nuestro
ejemplo:
Pag. 347
nom = nom.toLowerCase ( ) ;
Es importante tener presente que el método toLowerCase ( ) es un método que solo podemos utilizar con
variables de tipo String y su función es convertir el contenido de una variable en letras minúscula.
Pag. 348
Problema 102
Desarrollar un programa en Java que permita ingresar el primer nombre y el segundo

nombre de un alumno. Concatenar y Mostrar los nombres del alumno en letras
mayúsculas y letra minúsculas.
Clase PrgConcatenarNombres
public class PrgConcatenarNombres {
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: ” ) ;

nom1 = nom1.concat(espacio) ;
nombre = nom1.concat(nom2) ;
System.out.println ( “ El nombre en Mayúscula es: ”" + nombre.toUpperCase() ) ;

System.out.println ( “ El nombre en Minúscula es: ” + nombre.toLowerCase() ) ;
}
}
Observe el uso del método concat ( ) de la clase String:
nom = nom.concat (espacio) ;
El método concat ( ) se utiliza para juntar o concatenar el contenido de dos variables de tipo String (la misma
función cumple el signo “+ “cuando trabaja con variables de tipo String).
Es decir, el contenido de la variable nom1 y el contenido de la variable espacio se juntan (o concatenan) y el
resultado se almacena en la variable que antecede al signo = (en nuestro caso la misma variable nom1).
Luego el contenido de la variable nom1 se junta con el contenido de la variable nom2 y el resultado se
almacena en la variable nombre.
nom1 = nom1.concat (espacio) ;

nombre = nom1.concat(nom2) ;
Pag. 349
Esto permite juntar o concatenar los nombres del alumno con un espacio en blanco entre ellos en una única
variable de tipo String.
También podría visualizarse directamente el resultado de juntar o concatenar dos variables de tipo String
(cadenas) utilizando System.out.println, como se muestra a continuación:
System.out.println (nom1.concat (nom2) ) ;
Finalmente, se utilizan los métodos toUpperCase ( ) y toLowerCase ( ), explicados en los problemas

anteriores, directamente con System.out.println para mostrar el nombre del alumno en letra minúscula y en
letra mayúscula.
Pag. 350
Problema 103

el número de caracteres del nombre ingresado por teclado. Consistenciar el nombre del
alumno al momento de ingresarlo.
Clase PrgLongitudCadena
public class PrgLongitudCadena {
int cant ;
String nom ;
do {
System.out.println ( “ Ingresar el nombre: ” ) ;
nom = nom.trim( ) ;
if ( nom.length( ) < 2 ) {
System.out.println ( “ Nombre ingresado no válido… Reintente! ” ) ;
}
} while (nom.length( ) < 2 ) ;
cant = nom.length( ) ;
System.out.println ( “ La cantidad de caracteres del nombre es: ” + cant ) ;

}
}
Observe el uso del método trim ( ) de la clase String:
nom = nom.trim ( ) ;
El método trim ( ) permite eliminar los espacios en blanco que pueden existir al inicio y/o al final de una
cadena contenida en una variable (en nuestro caso la cadena contenida en la variable nom). Esto se realiza
como precaución, ya que el usuario puede haber presionado la barra espaciadora antes de ingresar el
nombre del alumno y esto se almacena en la variable como espacios en blanco.
También observe el uso del método length ( ) de la clase String:
Pag. 351
cant = nom.length ( ) ;
El método length ( ) se utiliza con variables de tipo String y nos permite contar la cantidad de caracteres que
almacena una variable (en nuestro caso, la cantidad de caracteres que almacena la variable nom). Como el
método length ( ) devuelve la cantidad de caracteres que tiene una variable (incluido los espacios en blanco),
podemos mostrar el resultado utilizando System.out.println(), utilizarlo en una condición lógica o almacenarlo
en una variable. En nuestro ejemplo lo utilizamos como condición lógica y para almacenarlo en una variable.
En la líneas de código mostradas a continuación, se consistencia el ingreso del nombre de tal forma que no
se permita ingresar un nombre que tenga menos de 2 caracteres (se asume que pueden haber nombres de 2
caracteres o mas, como por ejemplo; Lu, Ana, José, Pedro, que tienen 2, 3, 4, y 5 caracteres
respectivamente).
do {
nom = nom.trim ( ) ;
if ( nom.length ( ) < 2 ) {
System.out.println ( “Nombre ingresado no válido… Reintente! ” ) ;
}
} while (nom.length ( ) < 2) ;
Pag. 352
Problema 104

el nombre del alumno en letras mayúscula. Consistenciar el nombre del alumno al
momento de ingresarlo.
Clase PrgConvertirMayuscula2
public class PrgConvertirMayuscula2 {

String nom ;
do {
nom = nom.trim( ) ;
}
} while ( nom.length( ) < 2 ) ;
nom = nom.toUpperCase( ) ;
System.out.println ( “ El nombre en Mayúscula es: ” + nom ) ;
}
}
Observe el uso de los métodos trim ( ), length ( ) y toUpperCase ( ) de la clase String.
En la codificación de este programa, se debe eliminar los espacios en blanco que la variable nom pueda tener
al inicio y al final del dato que contiene, luego se consistencia que tenga por lo menos 2 caracteres y luego se
convierte el contenido de la variable nom en letra mayúscula, para finalmente mostrar su contenido por
pantalla.
En consecuencia, se puede afirmar que esta solución es más óptima que la solución presentada en el
problema 100.
Pag. 353
Problema 105

el primer caracter del nombre ingresado en mayúsculas.
Clase PrgPrimeroMayuscula
public class PrgPrimeroMayuscula {
String nom, cadena1= “”, cadena2= “” ;
do {
nom = nom.trim( ) ;
}
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 ) ;

}
}
Observe el uso del método substring ( ) de la clase String:
El método substring ( ) se utiliza de dos formas. La primera forma nos permite obtener una subcadena desde
una posición inicial hasta un caracter antes de la posición final indicada. La segunda forma nos permite
obtener una subcadena desde una posición determinada hasta el final de la cadena.
Imagínese que la variable nom contiene el nombre “danae”, tal y como se muestra a continuación:
Pag. 354
nom = “danae”.
Cuando manipulamos cadenas con el método substring ( ) debemos tener en cuenta que cada caracter de la
cadena tiene una determinada posición, empezando por la posición cero (0).
nom = “danae”.
posición 0
Entonces, si deseamos obtener la primera letra de la cadena utilizamos la siguiente sentencia:
Donde, el primer número del método substring ( ) indica la posición de la cadena nom desde donde va a
empezar la subcadena y el segundo número indica la posición final de la cadena (es importante mencionar
que se debe incluir hasta un caracter antes de la posición final indicada). Esto nos permite solo obtener el
primer caracter de nom (la letra “d”).
Suponiendo que se desee obtener la subcadena “ana” de la cadena “danae” contenida en la variable nom,
utilizaríamos la siguiente sentencia:
cadena1 = nom.substring (1,4) ;
Continuando con nuestro ejemplo, una vez obtenida la primera letra del nombre se convierte a mayúscula
utilizando:
cadena1 = cadena1.toUpperCase ( ) ;
Ahora es necesario obtener el resto del contenido de la variable nom. Esto lo realizamos utilizando:
cadena2 = nom.substring (1) ;
Esta es la segunda forma de utilizar el método substring ( ), donde el número (en nuestro caso el número 1),
indica la posición de la cadena nom donde va a comenzar la subcadena (la primera letra “a”) hasta el final de
la cadena.
Ahora en la variable cadena1 tenemos almacenada la letra “D” y en la variable cadena2 tenemos
almacenadas las letras “anae”. Para finalizar solo será necesario juntar o concatenar ambas variables en la
variable original nom, utilizando el método concat ( ).
nom = cadena1.concat (cadena2) ;
El resultado que se obtiene es el nombre ingresado con la primera letra en mayúscula.
Pag. 355
Problema 106

el primer caracter del nombre ingresado en mayúsculas y el resto en minúscula.
Clase PrgMayusculaMinuscula
public class PrgMayusculaMinuscula {
int cant ;
String nom, cadena1 = “” , cadena2 = “” ;
do {
nom = nom.trim( ) ;
if ( nom.length( ) < 2) {
}
cadena2 = cadena2.toLowerCase( ) ;
}
}
Observe el uso de los métodos trim ( ), length ( ), substring ( ) en sus dos formas, toUpperCase ( ),
toLowerCase ( ) y concat ( ) de la clase String.
En la codificación de este programa, se convierte en mayúscula la primera letra del nombre y el resto se
convierte en minúscula. Esto como precaución de que se ingrese todo el nombre en mayúscula o en forma
combinada entre letras mayúsculas y minúsculas. Finalmente siempre el nombre tendrá la primera letra en
mayúscula y el resto en letra minúscula.
En consecuencia, se puede afirmar que esta solución es más óptima que la solución presentada en el
problema 104.
Pag. 356
Problema 107
Desarrollar un programa en Java que permita ingresar el nombre completo de un

alumno (nombres y apellidos en una sola variable). Mostrar el primer caracter de cada
palabra del nombre en mayúsculas y el resto de cada palabra en minúscula.
Clase PrgNombreCompleto
public class PrgNombreCompleto {
int cant ;
String nom, cadena1 = “”,cadena2 = “”, caracter ;
do {
nom = nom.trim( ) ;
if ( nom.length( ) < 2) {
}
} while (nom.length( ) < 2) ;
for (int x=0; x<cant; x++) {
if ( x==0) {
} 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 ;
}
}
}
}
}
Pag. 357
Observe el uso del método equals ( ) de la clase String:
if (caracter.equals (“ “)) {
El método equals ( ) se utiliza con variables de tipo String y nos permite comparar el contenido de dos
cadenas (en nuestro caso la variable caracter con un espacio en blanco). Si al comparar el contenido de las
dos cadenas resulta que ambas variables son iguales, el método equals ( ) nos devuelve un valor verdadero
(true), en caso contrario nos devuelve un valor falso (false). Este valor devuelto se evalúa en la estructura de
decisión if.
Imagínese que la variable nom contiene el siguiente nombre:
nom = “danae alessandra flores bertolotti” ;
Nosotros desearíamos que la primera letra de cada nombre y de cada apellido de un alumno este en letra
mayúscula, mientras que el resto de las letras estén en letra minúscula.
Al inicio utilizamos parte de la solución del problema 105. Después obtenemos caracter por caracter y
evaluamos si el caracter obtenido es un espacio en blanco. Si el caracter resulta ser un espacio en blanco
entonces se almacena y se convierte en letra mayúscula la letra siguiente al espacio en blanco. El siguiente
esquema muestra como se debe almacenar parcialmente el nombre del ejemplo en la variable nom.
Danae a lessandra flores bertolotti.
cadena1 caracter cadena2
Después se concatenan las tres variables y se almacenan en la variable nom. El proceso se repite hasta
llegar al final de la cadena.
Ahora considere si entre los nombres existe más de un espacio en blanco. ¿Qué sucede? Modificando la
solución anterior para poder considerar la problemática anterior tendríamos la siguiente variación:
sw = false ;
for (int x=0; x<cant; x++) {
if (x==0) {
} else {
if (caracter.equals( “ ” ) ) {
sw = true ;
} else {
if (sw) {
Pag. 358
cadena1 = nom.substring(0,x) ;
caracter = caracter.toUpperCase( );
cadena2 = nom.substring(x+1) ;
nom = cadena1 + caracter + cadena2 ;
sw = false ;
}
}
}
}
En esta parte modificada de la solución se utiliza un centinela (o flag) que nos permite indicar el momento
preciso para realizar la conversión de la primera letra del nombre o apellido a letra mayúscula, sin
preocuparnos de la cantidad de espacios en blanco que pueda existir entre dos nombres.
Pag. 359
Problema 108
Desarrollar un programa en Java que permita ingresar los apellidos y nombres de un

obrero (en una sola variable). Mostrar el número de caracteres blancos o espacios en
blanco que existan.
Clase PrgLongitudCadenaBlanco
public class PrgLongitudCadenaBlanco {
int x,cant,cont=0 ;
String nom,caracter ;
do {
nom = nom.trim( ) ;
}
for (x=0;x<cant;x++) {
caracter = nom.substring(x,x+1) ;
cont ++ ;
}
}
System.out.println ( “ La cantidad de espacios: ” + cont ) ;
}
}
Observe el uso de los métodos trim ( ), length ( ), substring ( ) y equals ( ) de la clase String.
En la codificación de este programa, se evalúa caracter por caracter (de la variable nom). Si el caracter 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
Desarrollar un programa en Java que permita ingresar los apellidos y nombres de un

obrero (en una sola variable). Mostrar el número de caracteres del nombre ingresado
por teclado que no sean espacios en blanco.
Clase PrgLongitudCadenaNoBlanco
public class PrgLongitudCadenaNoBlanco {

int cant,x;
String nom, cadena = “”, caracter ;
do {
nom = nom.trim( ) ;
}
for (x=0; x<cant; x++) {
if ( !caracter.equals ( “ ” ) ) {
cadena = cadena.concat(caracter) ;
}
}
cant = cadena.length( ) ;
System.out.println ( “ La cantidad de caracteres sin contar espacios: ” + cant ) ;
}
}
En la codificación de este programa, se evalúa caracter por caracter (de la variable nom). Si el caracter no es
un espacio en blanco se junta o concatena con los caracteres de la variable cadena (al inicio no contiene
ningún caracter). Al final se obtiene la longitud de la variable cadena, que equivale a la cantidad de caracteres
de la variable nom diferentes a espacios en blanco.
Pag. 361
Problema 110
Desarrollar una solución que permita ingresar los apellidos y nombres de un obrero (en
una sola variable). Mostrar el número de caracteres que no son espacios en blanco y el
número de caracteres que son espacios en blanco.
Clase PrgLongitudCadenaBlancoNoBlanco
public class PrgLongitudCadenaBlancoNoBlanco {
int x, cant, cont = 0 ;
String nom, caracter ;
do {
nom = nom.trim( ) ;
}
fo r(x=0; x<cant; x++) {
cont ++ ;
}
}
System.out.println ( “ La cantidad de espacios: ” + cont ) ;
System.out.println ( “ La cantidad de caracteres sin contar espacios: ” + ( cant - cont ) ) ;
}
}
En la codificación de este programa, se emplea la misma estrategia que la utilizada en la solución del
problema 108, para obtener el número 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 número de caracteres
de la variable nom que no son espacios en blanco.
Pag. 362
Problema 111
Desarrollar una solución que permita ingresar el nombre de un alumno. Mostrar el

número de vocales que hay en el nombre ingresado.
Clase PrgTotalVocales1
public class PrgTotalVocales1 {
int cant, cont = 0, d = 0, x ;

String nom ;
char c = ‘ ’ ;
do {
nom = nom.trim( ) ;
if ( nom.length( ) == 0 ) {
}
} while (nom.length( ) == 0 ) ;

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

el número de vocales y el número de caracteres que no son vocales que hay en el
nombre ingresado.
Clase PrgTotalVocalesNoVocales
public class PrgTotalVocalesNoVocales {
int cant, cont = 0 , d = 0 , x ;

String nom ;
char c = ‘ ’ ;
do {
nom = nom.trim( ) ;
}
} while (nom.length( ) == 0 ) ;

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 solución anterior de tal forma que pueda determinar cuántas vocales almacenadas en la variable
nom son mayúsculas y cuántas son minúsculas. También puede modificar la solución de tal forma que
permita determinar cuántas consonantes contiene la variable nom. Recuerde utilizar los equivalentes en
código ASC de las consonantes en letra minúscula o en letra mayúscula.
Pag. 366
Problema 113
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.
Clase PrgCadenaSubcadena
public class PrgCadenaSubcadena {

String cad1, cad2, subcad ;
int total, i, cont = 0 ;
do {
System.out.println ( “ Ingresar una cadena: ” ) ;
cad1 = Lectura.leerString( ) ;
cad1 = cad1.trim( ) ;
if (cad1.length( ) == 0 ) {
System.out.println ( “ Cadena ingresada no válido... Reintente! ” ) ;
}
} while (cad1.length( ) == 0 ) ;
do {
System.out.println ( “ Ingresar una subcadena de la primera cadena: ” ) ;
cad2 = Lectura.leerString( ) ;
cad2 = cad2.trim( ) ;
if (cad2.length( ) == 0) {
System.out.println ( “ Cadena ingresada no válida... Reintente! ” ) ;
}
} while (cad2.length( ) == 0 ) ;
if (cad1.length( ) > cad2.length( ) ) {

total = cad1.length( ) - cad2.length( ) ;
for (i = 0; i <= total; i++) {
subcad = cad1.substring (i, i + cad2.length( ) ) ;
if (cad2.equals(subcad) ) {
cont ++ ;
}
}
System.out.println ( “ El número de veces que se repite ” ) ;
System.out.println ( “ la subcadena en la cadena es: ” + cont ) ;
Pag. 367
Continúa... Etapa 04 - Desarrollo de la codificación.
Clase PrgCadenaSubcadena
} else {
if (cad1.equals (cad2) ) {
System.out.println ( “ las cadenas son iguales ” ) ;
} else {
System.out.println ( “ la segunda cadena no debe tener una longitud ” ) ;
System.out.println ( “ mayor que la primera cadena ” ) ;
}
}
}
}
La parte central de la solución radica en las siguientes líneas de código:
if (cad1.length( ) > cad2.length( ) ) {

total = cad1.length( ) - cad2.length( ) ;
for (i = 0; i <= total; i++) {
subcad = cad1.substring(i, i + cad2.length( ) ) ;
if (cad2.equals (subcad)) {
cont ++ ;
}
}
System.out.println ( “ El número de veces que se repite ” );
System.out.println ( “ la subcadena en la cadena es: ” + cont ) ;
} else {
if (cad1.equals (cad2) ) {
System.out.println ( “ las cadenas son iguales ” ) ;
} else {
System.out.println ( “ la segunda cadena no debe tener una longitud ” ) ;
System.out.println ( “ mayor que la primera cadena ” ) ;
}
}
En primer lugar, se verifica que la primera cadena (cad1) tenga una longitud mayor que la segunda cadena
(cad2). Luego, se obtiene la diferencia entre las longitudes de cad1 y cad2, y se almacena en la variable total.
El límite para la evaluación del número de veces que se repite cad2 en cad1, es el caracter ubicado en la
posición total de cad2. Después, empezando desde el primer caracter de cad1 se extrae una subcadena
(subcad) del mismo tamaño que cad2 y se comparan para ver si son iguales utilizando el método equals ( ).
Si son iguales el contador cont aumenta en 1. Este proceso se repite utilizando el siguiente caracter de cad1.
Como ejemplo utilizaremos las siguientes cadenas:
cad1 = “Danae” cad2 = “ana”
En primer lugar determinamos que cad1 tiene una longitud mayor que cad2. Luego, calculamos el valor
de la variable total (total = 5-3 = 2).
Pag. 368
El límite para la evaluación del número de veces que se repite cad2 en cad1 es el caracter ubicado en la
posición 2 de cad2.
cad1 = “Danae”
0 12
Observe que cad2 tiene una

Límite para la longitud=3 por lo que la última
evaluación evaluación será:
cad2 = “ana” y subcad= “nae”

Primera evaluación:
cad2 = “ana” y subcad = “Dan”
Resultado: falso.
Segunda evaluación:
cad2 = “ana” y subcad = “ana”
Resultado: verdadero (cont =1).
Primera evaluación:
cad2 = “ana” y subcad = “nae”
Resultado: falso. Finalmente, se concluye que cad2
se repite una vez en cad1.
Pag. 369
Problema 114
Desarrollar un programa en Java que permita ingresar el nombre de dos alumnos.

Mostrar si los nombres ingresados son iguales o no.
Clase PrgNombresIguales
public class PrgNombresIguales {
String nom1, nom2 ;
do {
System.out.println ( “ Ingresar el nombre del primer alumno: ” ) ;
nom1 = nom1.trim( ) ;
if ( nom1.length( ) < 2 ) {
System.out.println("Nombre ingresado no válido… Reintente! ");
}
} while ( nom1.length( ) < 2 ) ;
do {
System.out.println ( “ Ingresar el nombre del segundo alumno: ” ) ;
nom2 = nom2.trim( ) ;
if ( nom2.length( ) < 2 ) {
}
} while ( nom2.length( ) < 2 ) ;
if ( nom1.equals (nom2) ) {
System.out.println ( “ Los nombres ingresados son iguales ” ) ;
} else {
System.out.println ( “ Los nombres ingresados son diferentes ” ) ;
}
}
}
Observe el uso de los métodos trim ( ), length ( ) y equals ( ) de la clase String.
Se comparan dos variables de tipo cadena (nom1 y nom2 respectivamente) y se determinan si ambas
cadenas son iguales o no.
Pag. 370
Problema 115
Desarrollar un programa en Java que permita ingresar los nombres de dos alumnos.
Mostrar los nombres ordenados alfabéticamente.
Clase PrgOrdenados1
public class PrgOrdenados1 {
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: ” ) ;

if (nombre1.compareTo(nombre2) < 0 ) {
nombreMenor = nombre1 ;
nombreMayor = nombre2 ;
} else {
}
System.out.println ( “ ------------------------------------------------- ” ) ;
System.out.println ( “ Nombres ordenados alfabéticamente ” ) ;
System.out.println (nombreMenor) ;
System.out.println (nombreMayor) ;
}
}
Observe el uso del método compareTo ( ) de la clase String:
nombre1.compareTo (nombre2) ;
El método compareTo ( ) permite comparar dos variables de tipo String. El método permite compareTo ( ) nos
devuelve un valor entero. Si el valor devuelto es igual a cero (0), entonces las cadenas son iguales, es decir;
las variables nombre1 y nombre2 contiene cadenas iguales. Si el valor devuelto es mayor que cero (0),
entonces la variable nombre1 es mayor que la variable nombre2. Finalmente, si el valor devuelto es menor
que cero, entonces la variable nombre1 es menor que la variable nombre2.
Pag. 371
Cuando se comparan dos cadenas, se realiza una comparación alfabética en la cual tienen significado las
letras mayúsculas, las letras minúsculas, los caracteres especiales y los espacios en blanco.
Por ejemplo; comparemos las siguientes cadenas:
nombre1 > nombre2

1. nombre1 = “Pedro” y nombre2 = “Luis”.
2. nombre1 = “Danae” y nombre2 = “Danae”. nombre1 = nombre2
3. nombre1 = “Carmen” y nombre2 = “Juan”. nombre1 < nombre2
En base a esto, mejore la solución de tal forma que se pueda realizar la consistencia de los nombres
ingresados.
Pag. 372
Problema 116
Desarrollar un programa en Java que permita ingresar los nombres de dos alumnos (no
permite el ingreso de solo espacios en blanco). Mostrar los nombres ordenados
alfabéticamente.
Clase PrgOrdenados2
String nombre1, nombre2, nombreMayor, nombreMenor ;
do {
System.out.println ( “ Ingrese el nombre de la primera persona: ” ) ;
nombre1 = Lectura.leerString( );
nombre1 = nombre1.trim( ) ;
if (nombre1.length( ) < 2 ) {
System.out.println ( “ Nombre ingresado no válido...Reintente!!! ” ) ;
}
} while (nombre1.length( ) < 2 ) ;
do {
System.out.println ( “ Ingrese el nombre de la segunda persona: ” ) ;
if ( nombre2.length( ) < 2 ) {
}
} while ( nombre2.length( ) < 2 ) ;
if ( nombre1.compareTo(nombre2) < 0 ) {
} else {
}
Pag. 373
Clase PrgOrdenados2
System.out.println ( “------------------------------------------------- ” ) ;
System.out.println ( “Nombres ordenados alfabéticamente ” ) ;
System.out.println ( “------------------------------------------------- ” ) ;
System.out.println (nombreMenor) ;
System.out.println (nombreMayor) ;
}
}
Mejore la codificación del programa, de tal forma que se contemple la posibilidad que los nombres ingresados
sean iguales.
Pag. 374
Problema 117
Desarrollar un programa en Java que permita ingresar los nombres de tres alumnos (los
nombres no deben ser iguales). Mostrar los nombres ordenados alfabéticamente.
Clase PrgOrdenados3
String nombre1, nombre2, nombre3 ;

String nom01 = “ ”, nom02 = “”, nom03 = “” ;
do {
if ( nombre1.length( ) == 0 ) {
}
} while ( nombre1.length( ) == 0 ) ;
do {
}
} while (nombre2.length( ) == 0 ) ;
do {
System.out.println ( “ Ingrese el nombre de la tercera persona: ” ) ;
}
Pag. 375
Clase PrgOrdenados3
if (nombre1.compareTo(nombre2) < 0 && nombre1.compareTo(nombre3) < 0 ) {

nom01 = nombre1 ;
nom02 = nombre2 ;
nom03 = nombre3 ;
} else {
nom02 = nombre3 ;
nom03 = nombre2 ;
}
}
if (nombre2.compareTo(nombre1) < 0 && nombre2.compareTo(nombre3) < 0) {
nom01 = nombre2 ;
nom02 = nombre1 ;
nom03 = nombre3 ;
} else {
nom02 = nombre3 ;
nom03 = nombre1 ;
}
}
if (nombre3.compareTo(nombre1) < 0 && nombre3.compareTo(nombre2) < 0 ) {
nom01 = nombre3 ;
nom02 = nombre1 ;
nom03 = nombre2 ;
} else {
nom02 = nombre2 ;
nom03 = nombre1 ;
}
}
System.out.println (nom01) ;
}
}
Desarrolle la siguiente prueba:
1. Ejecute el programa, ingrese los siguientes datos y compruebe lo que sucede:

nombre1 = “Armando”. nombre2 = “Armando”. nombre3 = “Beto”.
2. Luego ingrese los siguientes datos y compruebe nuevamente lo que sucede:

nombre1 = “Armando”. nombre2 = “Beto”. nombre3 = “Beto”.
3. Finalmente ingrese los siguientes datos. Compruebe lo que sucede:

nombre1 = “Armando”. nombre2 = “Armando”. nombre3 = “Armando”.
Modifique la codificación de la solución de tal forma que pueda mejorarla.
Pag. 376
Problema 118
Desarrollar un programa en Java que permita ingresar los nombres de tres alumnos (los
nombres pueden ser iguales). Mostrar los nombres ordenados alfabéticamente.
Clase PrgOrdenados4
String nombre1, nombre2, nombre3 ;

String nom01 = “”, nom02 = “”, nom03 = “”;
do {
if (nombre1.length( ) == 0 ) {
}
do {
if (nombre2.length( ) == 0) {
}
do {
}
} while (nombre3.length( ) == 0 ) ;
Pag. 377
Clase PrgOrdenados4
nom01 = nombre1 ;
nom02 = nombre2 ;
nom03 = nombre3 ;
} else {
nom02 = nombre3 ;
nom03 = nombre2 ;
}
} else {
nom01 = nombre3 ;
nom02 = nombre1 ;
nom03 = nombre2 ;
}
} else {
nom01 = nombre2 ;
nom02 = nombre1 ;
nom03 = nombre3 ;
} else {
nom02 = nombre3 ;
nom03 = nombre1 ;
}
} else {
nom01 = nombre3 ;
nom02 = nombre2 ;
nom03 = nombre1 ;
}
}
}
}
Desarrolle la siguiente prueba:

Ingrese los nombres con letras mayúsculas y minúsculas, por ejemplo:
nombre1 = “armando”. nombre2 = “Beto”. nombre3 = “Armando”.
Compruebe lo que sucede. Se ordenarán primero los nombres que comiencen con mayúscula y luego los
nombres que comiencen con minúscula.
Modifique el programa de tal forma que se cambie la primera letra del nombre ingresado a mayúscula.
Pag. 378
Problema 119
Desarrollar un programa en Java que permita ingresar los nombres de tres alumnos.
Asegúrese que los nombres ingresados empiecen con una letra mayúscula. Mostrar los
nombres ordenados alfabéticamente.
Clase PrgOrdenados5
String nombre1, nombre2, nombre3, letra, resto ;

String nom01 = “”, nom02 = “”, nom03 = “” ;
do {
} else {
nombre1 =
((nombre1.substring(0, 1)).toUpperCase()).concat(nombre1.substring(1)) ;
}
do {
} else {
nombre2 =
}
do {
Pag. 379
Clase PrgOrdenados5
} else {
nombre3 =
}
nom01 = nombre1 ;
nom02 = nombre2 ;
nom03 = nombre3 ;
} else {
nom02 = nombre3 ;
nom03 = nombre2 ;
}
} else {
nom01 = nombre3 ;
nom02 = nombre1 ;
nom03 = nombre2 ;
}
} else {
nom01 = nombre2 ;
nom02 = nombre1 ;
nom03 = nombre3 ;
} else {
nom02 = nombre3 ;
nom03 = nombre1 ;
}
} else {
nom01 = nombre3 ;
nom02 = nombre2 ;
nom03 = nombre1 ;
}
}
}
}
Mejore la solución desarrollando un programa que permita ingresar tres nombres de alumnos. Asegúrese que
los nombres ingresados empiecen con una letra mayúscula y que el resto de las letras de los nombres estén
en minúscula. Muestre los nombres ordenados alfabéticamente.
Luego, complemente la solución permitiendo el ingreso de los nombres de todos los alumnos de un
determinado salón de clase.
Pag. 380
Problema 120
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.
Clase PrgCadenaModifcada
public class PrgCadenaModifcada {
int cant ;
String nom, dato1, dato2, caracter, cadena= “” ;
System.out.print ( “ Ingresar el nombre de una persona: ” ) ;

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( ) ;
for (x=0; x<cant; x++ ) {

if ( dato1.equals(caracter) == true )
cadena = cadena + dato2 ;
else
cadena = cadena + caracter ;
}
System.out.println ( “ El resultado es: ” + cadena ) ;
}
}
Observe el uso del método equals ( ) de la clase String:
nombre1.equals (nombre2) ;
Pag. 381
El método equals ( ) devuelve true (verdadero) si la cadena coincide con la cadena colocada como parámetro
del método equals ( ), caso contrario devuelve false (falso).
Por lo que en este caso el método equals ( ) evalúa a la variable dato1 y a la variable caracter. La variable
caracter tuvo que declararse como String para poder ser utilizada por el método equals ( ) de esta forma:
caracter = nom.substring (x , x+1) ;
Un punto muy importante es el análisis de la siguiente línea de código:
if ( dato1.equals (caracter) == true )
La sentencia if puede evaluar una condición lógica, una variable booleana o el resultado de una operación.
En nuestro caso, el método equals ( ) devuelve true (verdadero) o false (falso), dependiendo del resultado de
la comparación entre las variables dato1 y caracter.
En base a esto, podemos afirmar que las siguientes sentencias en Java son equivalentes:
if ( dato1.equals (caracter) == true )
if ( dato1.equals (caracter) )
Resulta evidente que no es necesario realizar comparaciones booleanas dentro de las condiciones lógicas
utilizadas en la sentencia if (esto se hace extensivo a las sentencias do, while y for).
Pag. 382
Problema 121
Desarrollar un programa en Java que permita ingresar un número mayor de tres dígitos.
Convertir el número en cadena, luego intercambiar posiciones, el primer digito pasarlo
al último y el último digito pasarlo al primero. Mostrar el nuevo número.
Clase PrgIntercambioCadena
public class PrgIntercambioCadena {
int num, cant;
String dato1, dato2, dato3, cadena = "";
do {
System.out.print(" Ingresar un numero mayor de 3 dígitos: ");
num = Lectura.leerInt();
if (num < 100) {

System.out.println(" Número ingresado no válido… Reintente! ");
}
} while (num < 100);
cadena = String.valueOf(num);
cant = cadena.length();
dato1 = cadena.substring(0, 1);
dato2 = cadena.substring(1, cant - 1);
dato3 = cadena.substring(cant-1);
cadena = dato3 + dato2 + dato1;
System.out.println(" El resultado es: " + cadena);}
}
Observe el uso del método valueOf ( ) de la clase String:
String.valueOf (num) ;
El método valueOf ( ) se utiliza directamente con la clase String (y no con una variable de tipo
String). Este método permite convertir una variable de cualquier tipo a una variable de tipo String
o cadena. En nuestra solución convertimos la variable num a String con la finalidad de poder
manipular el contenido de la variable con métodos de la clase String. Una vez convertida la
variable num, se utiliza el método substring ( ) para intercambiar las posiciones deseadas.
Pag. 383
Problema 122

el nombre ingresado, de tal forma que se lea de izquierda a derecha (nombre mostrado
al revés).
Clase PrgInvertirCadena
public class PrgInvertirCadena {
int cant, x ;
String nom, caracter, cadena = “” ;
do {
nom = nom.trim( ) ;
}
} while ( nom.length( ) == 0 ) ;
cant = nom.length( );
for (x=cant-1; x>=0; x-- ) {

cadena = cadena.concat(caracter) ;
}
System.out.println ( “ El nombre al revés es: ” + cadena ) ;

}
}
Observe el uso del método concat ( ) de la clase String:
En este programa, declaramos la variable caracter como una cadena (String). Cada vez que se ejecuta la
sentencia for, se obtiene de la variable nom un caracter empezando desde el último y terminando en el
primero. Cada vez que se obtiene un caracter este se agrega a la variable cadena, de tal forma que al
finalizar la ejecución de la sentencia for se tiene almacenado en la variable cadena el nombre ingresado con
los caracteres finales al inicio y los caracteres iniciales al final.
Pag. 384
Otra manera de solucionar este problema es la siguiente:
for ( x = cant - 1; x >= 0; x - - ) {

caracter = nom.charAt (x) ;
cadena += caracter ;
}
Es importante indicar que para esta solución, la variable caracter debe declararse como char. Observe como
se utiliza el método charAt ( ) de la clase String, con la finalidad de obtener caracter por caracter de la
variable nom (empezando desde el último y terminando en el primero), para agregarlos a la variable cadena
utilizando el signo “+” (concatenación).
Pag. 385
Problema 123
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”.
Clase PrgCuentaLetras1
public class PrgCuentaLetras1 {
String nombre, letraIni = “”, letraFin = “” ;

int i, contP= 0, contA = 0 ;
for (i = 0; i <11; i++) {

do {
System.out.println ( “ Ingresar el nombre del alumno: ” ) ;
nombre = Lectura.leerString( ) ;
nombre = nombre.trim( ) ;
if ( nombre.length( ) == 0 ) {
System.out.println ( “ Nombre ingresado no válido... Reintente! ” ) ;
}
} while (nombre.length( ) == 0 ) ;
letraIni = nombre.substring(0,1) ;
letraFin = nombre.substring ( nombre.length( )-1,nombre.length( ) ) ;
if ( letraIni.equals( “P” ) ) {
contP++;
}
if ( letraFin.equals( “a” ) ) {
contA++;
}
}
System.out.println ( “ Nombres que comienzas con la letra P: ” + contP);
System.out.println ( “ Nombres que terminan con la letra a: ” + contA);
}
}
Mejore la solución desarrollando un programa que permita ingresar los nombres de todos los alumnos. Utilice
la estructura do… while. Asegúrese que los nombres ingresados empiecen con una letra mayúscula y que el
resto de las letras de los nombres estén en minúscula.
Pag. 386
Problema 124
Desarrollar un programa en Java que permita ingresar los nombres de todos los
empleados de una empresa. Mostrar el número de vocales que existen en cada uno de
los nombres ingresados.
Clase PrgTotalVocales2
public class PrgTotalVocales2 {
int cant, cont=0, opc, d=0, x ;
String nom ;
char c = ‘ ’ ;
do {
do {
nom = nom.trim( ) ;
System.out.println ( “ Nombre no válido… Reintente! ” ) ;
}
} while ( nom.length( ) == 0 ) ;
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 solución desarrollando un programa que considere el conteo de las vocales acentuadas y las
vocales en letra mayúscula. Como sugerencia investigue los códigos ASCII de las vocales acentuadas y las
vocales en letra mayúscula, y agréguelos en la sentencia switch ( ).
Pag. 388
Problema 125
productos de una determinada tienda. Mostrar como resultado las posiciones pares.
Clase PrgProductosTienda
class PrgProductosTienda {

int x, cantidad, cont = 0 ;
String producto, acum = “” ;
do {
System.out.println ( “ Ingresar la cantidad de productos: ” ) ;
cantidad = Lectura.leerInt( ) ;
if ( cantidad < 1 ) {
System.out.println ( “ Cantidad no válida… Reintente! ” ) ;
}
} while ( cantidad < 1 ) ;
do {
System.out.println ( “ Ingresar el nombre del producto: ” ) ;

producto = Lectura.leerString( ) ;
for ( x = 1; x <= producto.length(); x++ ) {
if ( x % 2 == 0 ) {
acum = acum + producto.substring(x - 1, x) ;
}
}
System.out.println ( “ Las posiciones pares del producto son: ” + acum ) ;
acum = “” ;
cont ++ ;
} while ( cantidad != cont ) ;
}
}
Pag. 389
Análisis de la solución
Ingresamos la cantidad de alumnos y la almacenamos en la variable cantidad, se valida el número de

alumnos ingresado, de tal forma que sea mayor a cero.
Luego, se utiliza una sentencia do para ingresar el nombre de cada uno de los productos y determinar sus
posiciones pares. Esto último se logra utilizando una sentencia for dentro de la sentencia do.
Observe el uso de los métodos length ( ) y substring ( ) de la clase String, y la forma como se utilizan las
estructuras lógicas para la solución del problema.
Pag. 390
Problema 126
alumnos de un salón de clase. Mostrar la longitud de cada nombre ingresado, el
nombre que tiene la mayor longitud y el nombre que tiene la menor longitud.
Clase PrgLongitudNombre
class PrgLongitudNombre {

int cantidad, cont = 0, longMayor = 0, longMenor = 100 ;
String alumno, nomMayor = “”, nomMenor = “” ;
do {
System.out.println ( “ Ingresar la cantidad de alumnos: ” ) ;
cantidad = Lectura.leerInt( ) ;
if ( cantidad < 1 ) {
System.out.println ( “ Cantidad no válida… Reintente! ” ) ;
}
} while ( cantidad < 1 ) ;
do {
System.out.println ( “ Ingresar el nombre del alumno: ” ) ;
alumno = Lectura.leerString( ) ;
System.out.println ( “ La Longitud es: ” + alumno.length( ) ) ;
if ( longMayor < alumno.length( ) ) {
longMayor = alumno.length( ) ;
nomMayor = alumno ;
}
if ( longMenor > alumno.length( ) ) {
longMenor = alumno.length( ) ;
nomMenor = alumno ;
}
cont ++ ;
} while ( cantidad != cont ) ;
System.out.println ( nomMenor + “ tiene de longitud ” + longMenor ) ;

System.out.println ( nomMayor + “ tiene de longitud ” + longMayor ) ;
}
}
Pag. 391
Análisis de la solución
Ingresamos la cantidad de alumnos y la almacenamos en la variable cantidad, se valida el número de

alumnos ingresado, de tal forma que sea mayor a cero.
Luego, se utiliza una sentencia do para ingresar el nombre de cada uno de los alumnos, y se determina la
longitud de cada nombre ingresado, el nombre con la mayor longitud y el nombre con la menor longitud.
Observe el uso de los métodos length ( ) de la clase String, y la forma como se utilizan las estructuras lógicas
para la solución del problema.
Pag. 392
Problema 127
Desarrollar un programa en Java que permita ingresar una fecha con el siguiente
formato “dd-mm-aaaa” y validarla.
Clase PrgFechaFormato
class PrgFechaFormato {

String fecha, dia, mes, anio ;
int num1 = 0, num2 = 0 ;
System.out.println ( “ Formato de la fecha es : dd-mm-aaaa ” ) ;
System.out.println ( “ Ingresar la fecha actual: ” ) ;

fecha = Lectura.leerString( ) ;
if ( fecha.length( ) <= 10 ) {
dia = fecha.substring(0, 2) ;
num1 = Integer.parseInt(dia) ;
mes = fecha.substring(3, 5) ;
num2 = Integer.parseInt(mes) ;
anio = fecha.substring(6, 10) ;
if ( ( dia.length() != 2 ) || ( num1 < 31 ) ) {
System.out.println ( “ El dia ingresado es incorrecto ” ) ;
} else {
if ( (mes.length() != 2 ) || ( num2 < 12 ) ) {
System.out.println ( “ El mes ingresado es incorrecto ” ) ;
} else {
if ( anio.length( ) != 4 ) {
System.out.println ( “ El año ingresado esta incorrecto ” ) ;
} else {
System.out.println ( “ La fecha ingresada es correcta ” ) ;
}
}
}
}
}
}
Intente mejorar la solución validando la fecha, de tal forma que el mes ingresado sólo sea válido si es que la
variable dia contiene el número de días válidos para dicho mes. Incluya la posibilidad que el mes de febrero
sea bisiesto.
Pag. 393
Problema 128
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
class PrgCompletarCadenaIzq {
String cadena ;
int longitud, tamaño, x ;
System.out.println ( “ La longitud especificada es: ” ) ;

longitud = Lectura.leerInt( ) ;
System.out.println ( “ Ingresar cadena: ” ) ;

cadena = Lectura.leerString( ) ;
if ( longitud > cadena.length( ) ) {

tamaño = longitud - cadena.length( ) ;
for ( x = 1; x <= tamaño; x++) {
cadena = cadena + “*” ;
}
}
System.out.println ( “ La nueva cadena es: ” + cadena ) ;

}
}
Pag. 394
Problema 129
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
class PrgCompletarCadenaDer {
String cadena ;
int longitud, tamaño, x ;
System.out.println ( “ La longitud especificada es: ” ) ;

longitud = Lectura.leerInt( ) ;
System.out.println ( “ Ingresar cadena: ” ) ;

cadena = Lectura.leerString( ) ;
if ( longitud > cadena.length( ) ) {

tamaño = longitud - cadena.length( ) ;
for ( x = 1; x <= tamaño; x++ ) {

cadena = “*” + cadena ;
}
}
System.out.println ( “ La nueva cadena es: ” + cadena ) ;

}
}
Pag. 395
Problema 130
Desarrollar un programa en Java que permita transformar un arreglo de caracteres en

una cadena, especificando la posición del arreglo donde va ha comenzar la cadena y su
longitud. Analizar la solución.
Clase PrgArregloCadena
class PrgArregloCadena {
char arregloA = { ‘D’, ‘a’, ‘n’, ‘a’, ‘e’ } ;

String cadena = String.valueOf (arregloA, 1, 3) ;
System.out.println ( “ La cadena es: ” + cadena ) ;
}
}
Observe el uso del método valueOf ( ) de la clase String:
String.valueOf ( char [ ], int, int ) ;
El método valueOf ( ) se utiliza directamente con la clase String (y no con una variable de tipo String). Este
método permite convertir un arreglo de caracteres o parte de él, en una variable de tipo String o cadena. En
nuestra solución convertimos parte del arreglo arregloA a un String con la finalidad de mostrar el contenido
de dicha variable.
Observe que en este método, en primer lugar, se especifica el arreglo de tipo char del cual se va ha obtener
la cadena. En segundo lugar, se indica la posición del arreglo desde el cual se van a tomar los datos y
finalmente, se indica la longitud o el número de caracteres que se van a obtener del arreglo. En el ejemplo,
se muestra como resultado la cadena “ana”.
Los arreglos serán tratados en el siguiente capítulo.
Pag. 396
OTRAS CLASES EN JAVA
En general, el lenguaje de programación Java incorpora una gran cantidad de clases en

paquetes organizados en su Jerarquía de Clases.
Es fundamental que se continúe investigando el uso de otras clases incorporadas en esta

jerarquía de clases con la finalidad de mejorar la calidad de las soluciones que se desarrollen.
En el CD, adjunto al presente texto, encontrará más información sobre otras clases de la
Jerarquía de Clases de Java.
Como ejemplo, se puede mencionar la clase DecimalFormat del paquete java.text.
Problema 131
Desarrollar un programa en Java que permita ingresar un número por teclado. Mostrar
el número ingresado con un formato determinado. Analizar la solución.
Clase PrgFormatoNumero
import java.text.* ;
class PrgFormatoNumero {

double num ;
DecimalFormat numFormato ;
System.out.println ( “Ingrese numero entero: ” ) ;

num = Lectura.leerDouble();
numFormato = new DecimalFormat ( “###.000" ) ;
System.out.println ( “El número con formato es : ” + df.format ( num ) ) ;

}
}
Observe que se declara un objeto de la clase DecimalFormat llamado numFormato, Luego este objeto es
creado utilizando el operador new, estableciendo el formato a utilizar en el método constructor. Luego con el
método format ( ) se procede a establecer el formato establecido para el número ingresado.
Pag. 397
Pag. 398
Capítulo
4
Estructura de Datos
Arreglos
Temas:
Introducción.
Estructura de Datos: Arreglos.

• Generalidades.
• Declaración, creación e inicialización.
• Ingreso y visualización de datos.
• Manejo básico de datos.
Desarrollo de soluciones utilizando arreglos:

• Formalización del método de las 6’D.
Desarrollo de soluciones utilizando múltiples

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

DATOS
TAMBIÉN:
• Clases incorporadas en el lenguaje
de programación utilizado.
ALMACENADOS EN:
• Estructuras de datos tipo arreglo.
El presente capítulo, trata sobre las estructuras de datos conocidas como arreglos y los
conceptos más importantes relacionados a éstos; como se utilizan en las herramientas para
diseñar algoritmos y como se emplean en un lenguaje de programación para codificar
Al desarrollar soluciones básicas, se utilizan las estructuras lógicas y las estructuras de datos
en forma simultánea. Las estructuras lógicas y las estructuras de datos que se utilicen en una
solución, van a depender en general de la complejidad del problema.
Pag. 402
ESTRUCTURA DE DATOS
ARREGLOS
Definición:
Los arreglos conocidos también como arrays, son estructuras de datos que permiten
almacenar más de un dato del mismo tipo a la vez. Es decir, un arreglo contiene un
conjunto de datos, todos del mismo tipo.
Se dice que un arreglo es una colección de datos relacionados a los que se hace
referencia por medio de un nombre en común (el nombre del arreglo).
Los arreglos o arrays pueden tener de una a varias dimensiones. Aquellas que tienen
una dimensión (llamadas arreglos unidimensionales) se les conoce como registro o
vector y aquellos que tienen dos dimensiones (llamados arreglos bidimensionales) se
les denomina tabla o matriz.
Un arreglo puede almacenar un conjunto limitado de datos. Cada dato perteneciente

al arreglo se almacena en una posición y puede ser mostrado, modificado o
eliminado.
Tipos:
Existen dos tipos de arreglos:
Arreglos Unidimensionales (registro o vector)
Estructuras de datos que permiten almacenar un conjunto de datos

de un mismo tipo (técnicamente dichos valores se almacenan en
celdas de memoria que están consecutivas). El acceso a uno de los
datos del arrreglo unidimensional se realiza mediante un índice.
Arreglos bidimensionales (tabla o matriz)
El arreglo bidimensional se considera como un vector de vectores.

Es, por consiguiente una estructura de datos que permite almacenar
un conjunto de datos, todos del mismo tipo, en el cual el orden de
cada uno de los datos es significativo, y en el que se necesita
especificar dos índices para poder acceder a cada uno de ellos.
Pag. 403
Ventajas:
• Los datos están almacenados en una sola estructura de datos siendo más fácil el
acceso a los mismos.
• Se utiliza un único nombre (nombre del arreglo) para referirse al conjunto de

datos almacenados en el arreglo. Esto nos permite reducir el uso de variables y
constantes.
• Los arreglos permiten almacenar datos de entrada y datos utilizados durante el

procesamiento.
• Al igual que otras estructuras de datos (como las variables y constantes), los
arreglos tienen un tiempo de vida, por lo que pueden ser considerados como
globales o locales.
Desventajas:
• Un arreglo no puede almacenar datos de diferente tipo. Se puede tener un

arreglo de números enteros, o un arreglo de cadenas, pero no se puede tener un
arreglo que contenga por ejemplo: cadenas y números enteros a la vez.
• Dependiendo del tipo de arreglo, unidimensional o bidimensional, se necesitará

uno o dos índices para acceder a los datos almacenados en el arreglo.
• Antes de crear un arreglo es necesario conocer el número exacto de datos que

se necesitan almacenar (esto no es tan cierto ya que existe una clase en Java,
denominada Vector, que pertenece al paquete java.util, que tiene métodos que
permiten crear un vector y redefinir su tamaño cada vez que sea necesario).
Pag. 404
Representación gráfica
Arreglos Unidimensionales:
Un arreglo unidimensional puede ser representado como un vector o como

un registro. A continuación se muestra la representación gráfica de un
arreglo unidimensional llamado nombre:
Como vector:
nombre = [ X 0, X 1, X 2, X 3,..., X i -1 ] i
Como registro:
nombre
X0 X1 X2 ... X I-1
i
0 1 2 ... i -1
Donde:
nombre = Nombre del vector.

X0...X i -1 = Datos almacenados en el vector.
i = Tamaño del vector.
Arreglos Bidimensionales
Un arreglo bidimensional puede ser representado como una matriz o como

una tabla. A continuación se muestra la representación gráfica de un arreglo
bidimensional llamado nombre:
Como matriz:
X 0,0 X 0,1 X 0,2 … X 0,j -1

X 1,0
X 2,0
nombre = .
.
.
X i-1,0 X i-1,j -1
(i, j)
Como tabla:
Pag. 405
nombre
Columnas
0 1 2 j-1
0 X 0,0 X 0,1 X 0,2 … X 0,j -1
1 X 1,0
Filas 2 X 2,0
i-1 X i-1,0 X i-1,j -1

(i, j)
Donde:
nombre = Nombre de la matriz.

X0,0...Xi-1, j -1 = Datos almacenados en la matriz.
i*j = Tamaño de la matriz.
En el presente texto, para referirnos a los arreglos unidimensionales se utilizará la

representación del arreglo como registro y para referirnos a los arreglos
bidimensionales se utilizará la representación del arreglo como tabla.
Por ejemplo; si se desea representar el almacenamiento de las notas finales de 10

alumnos de un salón de clase en un arreglo unidimensional (representado como un
vector), se realizaría de la siguiente manera:
notas
10 15 20 19 14 13 16 11 17 09
i =10
0 1 2 3 4 5 6 7 8 9
Donde:
notas = Nombre del arreglo.
i = Número de alumnos.
10, 15,...,09 = Son las notas finales de cada uno de los alumnos.
Para poder acceder a los datos almacenados en un arreglo unidimensional se

necesita un índice que indique a cual de todos los datos del arreglo se desea
acceder. Así, en el vector anterior, para poder acceder a la nota final del alumno 2 se
utilizaría el nombre del vector (notas), seguido de un índice igual a 1 entre corchetes
([1]), según se muestre a continuación:
Pag. 406
notas[1]
notas
10 15 20 19 14 13 16 11 17 09
i =10
0 1 2 3 4 5 6 7 8 9
También, por ejemplo; si se desea representar el almacenamiento de las notas del

examen parcial, del trabajo y del examen final de 10 alumnos de un salón de clase en
un arreglo bidimensional (representado como una tabla), se realizaría de la siguiente
manera:
notas Alumno 1 Alumno 2 … … … … … … … Alumno10
0 1 2 3 4 5 6 7 8 9
Nota EP 0 10 11 02 05 18 16 17 11 17 09
Nota Tra 1 12 14 12 11 16 17 12 18 10 08
Nota EF 2 03 11 15 05 12 17 02 11 09 11
(i =3, j=10)
Donde:
notas = Nombre del arreglo.
j = Número de alumnos.
i = Número de notas.
10,11,…,09 = Son las notas de Examen Parcial de c/u de los alumnos del salón de clase.
12,14,…,08 = Son las notas de Trabajo de c/u de los alumnos del salón de clase.
03,11,…,11 = Son las notas de Examen Final de c/u de los alumnos del salón de clase.
Para poder acceder a los datos almacenados en un arreglo bidimensional se

necesitan dos índices que indiquen a cual de todos los datos del arreglo se desea
acceder. Así, en la tabla anterior, para poder acceder a la nota del examen final (Nota
EF) del alumno 2 se utilizaría el nombre de la tabla (notas), seguido de dos índices
iguales a 2 y 1, entre corchetes ( [2] [1] ), según se muestra a continuación:
Pag. 407
notas Alumno 1 Alumno 2 … … … … … … … Alumno10
0 1 2 3 4 5 6 7 8 9
Nota EP 0 10 11 02 05 18 16 17 11 17 09
Nota Tra 1 12 14 12 11 16 17 12 18 10 08
Nota EF 2 03 11 15 05 12 17 02 11 09 11
(i =3, j=10)
Notas[2][1]
Declaración de Arreglos
Para declarar un arreglo es necesario, en primer lugar, definir un nombre para

referirnos al arreglo. Para definir un nombre de un arreglo se siguen las mismas
reglas utilizadas para la definición de nombres de variables y constantes.
En segundo lugar, se debe determinar que tipo de dato podrá almacenar un arreglo.
Un arreglo solo puede almacenar datos del mismo tipo. Los tipos de datos válidos
para declarar un arreglo son los mismos tipos de datos válidos definidos para declarar
variables y constantes.
En general, para declarar un arreglo se utiliza el siguiente formato:

TipoDeDato arreglo[ ]
TipoDeDato arreglo[ ][ ]
En Java:
TipoDeDato arreglo[ ] ;
TipoDeDato arreglo[ ][ ] ;
Donde TipoDeDato debe ser un tipo de arreglo o tipo de dato válido y

arreglo es el nombre del arreglo (puede existir más de un arreglo, los
cuales serán separados por comas).
Para declarar un arreglo unidimensional se utiliza solo un corchete de apertura y

cierre “[ ]” al final del nombre del arreglo, mientras que para declarar un arreglo
bidimensional se utilizan dos corchetes de apertura y cierre “[ ][ ]” al final del nombre
del arreglo.
Pag. 408
También se puede declarar un arreglo colocando los corchetes de apertura y cierre

después del tipo de dato y no después del nombre del arreglo, según se muestra a
continuación:

TipoDeDato[ ] arreglo
TipoDeDato[ ][ ] arreglo
En Java:
TipoDeDato[ ] arreglo ;
TipoDeDato[ ][ ] arreglo ;
Como ejemplo de declaración de arreglos válidos en Java podemos utilizar:
EJEMPLOS DESCRIPCIÓN
Se declara un arreglo unidimensional llamado edades en el

int edades[ ] ; cual se podrá almacenar datos de tipo NUMERO, solo parte
entera (int).
Se declara un arreglo unidimensional llamado nombres en el

String nombres[ ] ; cual se podrá almacenar datos de tipo TEXTO (String).
Se declara un arreglo bidimensional llamado notas, en el cual

double notas[ ][ ] ; se podrá almacenar datos de tipo NUMERO, parte entera y
parte decimal (double).
Creación de Arreglos
Para crear un arreglo, es necesario que el arreglo previamente haya sido declarado,
tal y como se explicó anteriormente.
Antes de crear un arreglo se debe determinar cual va ser el tamaño del mismo. Es
decir, cual va ser la cantidad total de datos que se podrá almacenar en el arreglo.
El tamaño de un arreglo puede especificarse en forma directa utilizando un número

entero o en forma indirecta utilizando una variable entera. En ambos casos, el tamaño
del arreglo siempre deberá especificarse como un número entero.
Para crear un arreglo se utiliza el siguiente formato:

CREAR arreglo[tamaño]
Pag. 409
CREAR arreglo[filas ][columnas]
En Java:
arreglo = new TipoDeDato [tamaño] ;
arreglo = new TipoDeDato [filas][columnas] ;

arreglo es el nombre del arreglo.
El operador new nos permite crear un arreglo. Cuando se crea un arreglo con el
operador new, se debe indicar el tamaño del arreglo, es decir cuantos datos podrá
almacenar.
Es importante mencionar que el tipo de dato utilizado para crear un arreglo deberá ser
el mismo tipo de dato con el cual se declaró el arreglo.
Para crear un arreglo unidimensional es necesario especificar solo un índice, mientras

que para crear un arreglo bidimensional es necesario especificar dos índices; uno
para referirnos al número total de filas y el otro para referirnos al número total de
columnas que va a tener el arreglo.
En Java, existe también una forma directa para declarar y crear arreglos, utilizando
el siguiente formato:
En Java:
TipoDeDato arreglo[ ] = new TipoDeDato [tamaño];
TipoDeDato arreglo[ ][ ] = new TipoDeDato [filas][columnas];

arreglo es el nombre del arreglo.
Utilizando este formato se declara y crea el arreglo en forma directa (esto es conocido
como “Definición de un arreglo”). Las consideraciones tratadas en los temas
“Declaración de arreglo” y “Creación de arreglos” son válidas al utilizar este formato.
Pag. 410
Una consideración importante antes de utilizar un arreglo en Java:
“En Java, no se realiza ninguna clase de comprobación del tamaño de los arreglos en forma
automática. Esto quiere decir que se puede desbordar el final de un arreglo (se lanza una
excepción de tipo ArrayIndexOutOfBoundException). Es necesario recordar y tener presente que
es responsabilidad directa del programador asegurarse que nunca suceda esto, ya que puede
ocasionar resultados no deseados, y que se finalice la ejecución del programa”.
Ejemplo de creación de arreglos válidos en Java (se asume que los arreglos han sido
declarados previamente):
EJEMPLO DESCRIPCION
Se crea un arreglo unidimensional

llamado edades, previamente
edades = new int [10] ; declarado, en el cual se podrá
almacenar 10 datos de tipo NUMERO
(int).
Se crea un arreglo unidimensional

llamado nombres, previamente
int total = 10 ;
declarado, en el cual se podrá
nombres = new String [total] ;
almacenar 10 datos de tipo TEXTO
(String).
int numAlu, numNot ; Se crea un arreglo bidimensional

numAlu = 10 ; llamado notas, previamente declarado,
numNot = 3 ; en el cual se podrá almacenar 30 datos
notas = new double [numNot][numAlu] ; de tipo NUMERO (double).
En el segundo ejemplo se utiliza una variable llamada total de tipo entero para
crear el arreglo unidimensional llamado nombres. En el ejemplo, se asigna
directamente el valor 10 a la variable total. Se podría modificar esta parte
para que el valor se ingrese a través del teclado, tal y como se muestra a
continuación:
EJEMPLOS
int total ;
System.out.print ( “Ingrese el numero total de alumno: ” );

total = Lectura.leerInt( ) ;
nombres = new String[total] ;
Pag. 411
En el tercer ejemplo se crea un arreglo bidimensional llamado notas

previamente declarado, en el cual se podrá almacenar 30 datos de tipo
NUMERO, parte entera y parte decimal (double en Java). Dichos datos
estarán organizados en 3 filas y 10 columnas.
También se podría haber declarado y creado los arreglos del ejemplo

anterior, en forma directa, tal y como se muestra a continuación;
EJEMPLOS
int edades [ ] = new int [10] ;
int total = 10 ;
String nombres [ ] = new String [total] ;
int numAlu, numNot ;

numAlu =10 ;
numNot = 3 ;
double notas[ ][ ] = new double [numNota[numAlu] ;
Inicialización de Arreglos
Cuando se crea un arreglo utilizando el operador new es recomendable, aunque no

necesario, inicializar todas las posiciones del mismo.
Inicializar todas las posiciones de un arreglo significa asignar un valor a cada posición
con la finalidad de evitar que se produzca un error si se intenta acceder a una
posición del arreglo que todavía no contiene un dato.
Generalmente, los arreglos numéricos (tipo NUMERO) se inicializan con cero (0), los
arreglos lógicos (tipo LOGICO) o booleanos se inicializan con false, los arreglos de
caracteres con ‘\0’ y los arreglos de objetos con null.
Ingreso de datos a un Arreglo
Después de crear un arreglo, inicialice o no el arreglo, se deberán ingresar datos.
Es necesario que se ingresen datos a todas las posiciones del arreglo. Si no se

ingresan datos a todas las posiciones del arreglo deberá asegurarse de inicializar el
arreglo o en su defecto de mantener un adecuado control de las posiciones que
tienen datos almacenados y aquellas que no. Recuerde que tratar de acceder a una
Pag. 412
posición del arreglo que no tiene un dato o que no ha sido inicializado, produce un
error que ocasiona que se interrumpa la ejecución del programa.
Para ingresar datos a todas las posiciones de un arreglo generalmente se utiliza la

estructura lógica de repetición DESDE (for en Java).
También se puede utilizar una forma directa que permite declarar, crear e ingresar
datos a un arreglo unidimensional, para esto se encierran los datos que se
almacenarán en el arreglo dentro de llaves, separadas por comas, tal y como se
muestra a continuación.
EJEMPLO
int edades[ ] = { 10,15,20,23,28,32,35,42,51,59 } ;
Cada uno de los valores entre las llaves deben ser del mismo tipo de dato y
debe coincidir también con el tipo de dato con el que se declara el arreglo
unidimensional.
En el ejemplo anterior, se declara y crea un arreglo unidimensional llamado

edades de tipo NUMERO (solo números enteros) con 10 valores.
No se ha utilizado el operador new (para crear el arreglo) y tampoco se ha

especificado el tamaño con el cual se ha creado el arreglo.
Para declarar y crear un arreglo unidimensional llamado letras de tipo TEXTO

(de solo una letra) con 4 valores, se utilizaría la siguiente sentencia:
EJEMPLO
char letras[ ] = { ‘A’, ‘B’, ‘C’, ‘D’ } ;
Pag. 413
Manejo de datos de un Arreglo
Una vez que se han ingresado los datos a todas las posiciones del arreglo, se pueden
manipular dichos datos con la finalidad de cumplir con el objetivo del programa o
proyecto de solución de un determinado problema.
En términos generales, el manejo de arreglos se puede agrupar en dos grandes

grupos:
1). Procesos que permiten cambiar o modificar el contenido del arreglo. Se pueden
dividir en:
• Proceso de modificación de datos.

• Proceso de eliminación de datos.
• Proceso de ordenación de datos.
Proceso de Modificación de Datos:

Permite modificar uno o más datos de un arreglo, que se ingresaron a través de
un proceso de ingreso de datos. Es importante tener en cuenta que antes de
modificar un dato se debe verificar que este existe dentro del arreglo, utilizando
para ello un proceso de búsqueda de datos.
Proceso de Eliminación de Datos:

Permite eliminar uno o más datos de un arreglo que se ingresaron a través de un
proceso de ingreso de datos. Es importante tener en cuenta que antes de
eliminar un dato se debe verificar que este existe dentro del arreglo, utilizando
para ello un proceso de búsqueda de datos y previniendo al usuario que si se
elimina el dato no podrá ser recuperado posteriormente.
Proceso de Ordenación de Datos:

Permite ordenar todos los datos de un arreglo en función de un criterio. Dicho
criterio establece la forma de ordenar los datos de un arreglo. La ordenación
puede ser en forma alfabética o numérica de mayor a menor o viceversa.
2). Proceso que permite visualizar o consultar el contenido del arreglo. Se pueden
dividir en:
• Proceso de visualización de datos.

• Proceso de búsqueda datos.
• Proceso de cálculo basado en datos del arreglo.
Pag. 414
Proceso de visualización de Datos:

Permite visualizar los datos que contiene un arreglo. Es importante mencionar
que para poder visualizar los datos de un arreglo, dichos datos deben haber sido
ingresados previamente. Dependiendo lo que se necesite visualizar se podrá
mostrar todos los datos del arreglo o solo una parte de ellos.
Proceso de búsqueda datos:

Permite buscar uno o más datos dentro de un arreglo. Si el dato buscado es
encontrado, indicará la posición del arreglo en donde está almacenado el dato
buscado. En este caso, se considera que la búsqueda fue exitosa.
Proceso de cálculo basado en datos del arreglo:

Nos permite realizar diferentes tipos de cálculo con los datos de un arreglo, tales
como suma de datos, promedio, etc.
Pag. 415
Pag. 416
DESARROLLO DE SOLUCIONES BÁSICAS UTILIZANDO ARREGLOS
Los arreglos pueden ser utilizados como parte de las soluciones a los problemas que se nos
plantean. Inclusive, siempre hemos definido un arreglo como parte de la estructura del
método principal, main( ) en Java, tal y como se muestra a continuación.
Arreglo de tipo String

denominado “arg”
Esto significa que se puede incluir algunos parámetros al momento de ejecutar un proyecto
de solución. Dichos parámetros se pasan al método main ( ) y se almacenan en el arreglo arg.
Analizar las siguientes sentencias:
Clase Suma
/* Clase que nos permite sumar varios números enteros , incluidos como parámetros */
class Suma {
int suma = 0 ;
for ( int i = 0, i < a.length ; i ++ ) {

suma += Integer.parseInt (arg [ i ] ) ;
}
System.out.println (suma) ;
}
}
Es importante mencionar que cuando se ejecute esta clase, usted deberá asegurarse de incluir una lista de
números, para que estos puedan ser sumados.
Analizando las siguientes sentencias:
for ( int i = 0 ; i < a.length ; i++ ) {

suma += Integer.parseInt ( arg [ i ] ) ;
}
En primer lugar, los arreglos en Java poseen un atributo que almacena la cantidad de datos que pueden
contener. Este atributo se denomina length.
Pag. 417
En segundo lugar, cuando necesitamos convertir un dato a un número entero, utilizamos el método
parseInt() de la clase Integer. En consecuencia, la lista de números se almacena en el arreglo arg de tipo
String. Utilizando la sentencia for podemos acceder a cada uno de los datos almacenados en el arreglo
arg[], lo convertimos a un dato tipo NUMERO utilizando Integer.parseInt(), y luego lo sumamos a la variable
suma. Al finalizar la sentencia for se tiene la suma de los números incluidos como parámetros en la
variable suma.
A continuación se presenta la codificación en Java de una solución que permite ingresar la

nota final de 10 alumnos, y calcula el promedio general de notas del salón de clase.
Clase PrgAlumno
public class PrgAlumno {
int suma = 0, nota ;

double promedio ;
for ( int i = 0; i < 10 ; i ++ ) {

System.out.print ( “ Ingrese la Nota Final del Alumno ” + ( i + 1 ) ) ;
nota = lectura.leerInt ( ) ;
suma = suma + nota ;
}
promedio = suma / 10 ;
System.out.print ( “ El promedio general de notas es ” + promedio ) ;
}
}
Observe que la solución anterior nos permite realizar el cálculo y la visualización del promedio general de
notas. Pero, al utilizar solo una variable (notas), no podemos almacenar a la vez las notas finales de los 10
alumnos.
(Recuerde que una variable solo nos permite almacenar un dato a la vez).
Pag. 418
A partir de este punto, se modificará el programa anterior, de tal forma que se incorporen
progresivamente los conceptos tratados en este capítulo, para finalmente formalizar el
Método de las 6’D.
Es importante destacar que para trabajar con arreglos se deben seguir los siguientes pasos:
Declarar el arreglo o arreglos que se van ha utilizar en la solución del problema,

definiendo un nombre adecuado para cada uno de ellos.
Crear el arreglo o arreglos con el tamaño necesario para poder almacenar todos
los datos.
Inicializar el arreglo o arreglos, o en su defecto, ingresar los datos necesarios al

arreglo o arreglos utilizados en la solución.
Estos tres pasos generalmente se desarrollarán en todas las soluciones. A partir de este
punto podemos realizar cualquier proceso con los datos almacenados en el arreglo o arreglos
definidos en la solución. Por lo tanto, el siguiente paso quedaría definido de la siguiente
manera:
Manejar los datos almacenados en el arreglo o arreglos utilizados en la solución

con la finalidad de proporcionar la información solicitada.
En la solución, se utilizará un arreglo unidimensional llamado notas que permitirá almacenar

las notas finales de 10 alumnos de un determinado salón de clase. El arreglo notas
almacenará datos de tipo NUMERO (número entero con parte decimal). Una vez
almacenadas las notas finales de los 10 alumnos se calculará y mostrará el promedio de las
mismas.
Clase PrgAlumnos
public class PrgAlumnos {
public static void main ( String [ ] args ) {
// Declaración de variables y arreglos.

int numAlu =10 ;
double sumaNotas=0, notas[ ] ;
// Creación del arreglo notas.

notas = new double [numAlu] ;
Pag. 419
Clase PrgAlumnos
// Proceso de ingreso de datos al arreglo notas[ ].

for ( int i = 0 ; i < numAlu ; i++) {
System.out.print ( “ Ingrese nota : ” ) ;
notas[i] = Lectura.leerDouble( ) ;
}
// Proceso de cálculo del promedio de notas finales.

for ( int i = 0 ; i < numAlu ; i++ ) {
sumaNotas = sumaNotas + notas[i] ;
}
System.out.print ( “El promedio es : ” + ( sumaNotas / numAlu ) ) ;
}
}
En la solución anterior, en primer lugar, se declara un arreglo unidimensional llamado notas[ ] (vector).
Dicho arreglo podrá almacenar datos numéricos (parte entera y decimal). En segundo lugar, se crea el
arreglo notas[ ] utilizando la siguiente sentencia:
// Creación del arreglo notas.

notas = new double [numAlu] ;
Observe que para crear el arreglo notas[ ] se utiliza la variable entera numAlu. La variable numAlu fue
declarada previamente con la sentencia int, y se le asignó un valor igual a 10. Esto nos permite crear un
arreglo llamado notas[ ] con un tamaño igual a 10. Es decir, en el arreglo notas[ ] se podrán almacenar 10
notas finales.
En tercer lugar, se ejecuta el proceso de ingreso de datos al arreglo notas[ ]. Para esto, se utiliza una
sentencia for. El uso de la sentencia for tiene como finalidad repetir 10 veces las sentencias que nos
permitirán el ingreso de los datos, las cuales están ubicadas dentro de la misma sentencia for. Los datos
que se ingresarán serán las notas finales de los 10 alumnos del salón de clase.
// Proceso de ingreso de datos al arreglo notas.

for ( int I = 0 ; i < numAlu ; i++) {
System.out.print ( “ Ingrese nota : " ) ;
}
La estructura lógica de repetición for permite que se repitan 10 veces las siguientes sentencias:
System.out.print ( “ Ingrese nota : " ) ;

Cada vez que la estructura lógica de repetición for se ejecuta, la variable i aumenta su valor en 1, siendo
valores válidos de i, desde 0 hasta 9 (es decir, para i=0, i=1, i=2, i=3, i=4, i=5, i=6, i=7, i=8, i=9).
Cuando i = 0 (la primera vez que se ejecuta la sentencia for), la nota ingresada se almacena en la primera
posición del arreglo notas[ ], es decir en notas[0]. Cuando i = 1 (la segunda vez que se ejecuta la sentencia
for), la nota ingresada se almacena en la segunda posición del arreglo notas[ ], es decir en notas[1], y así
sucesivamente hasta cuando i = 9 (la décima y última vez que se ejecuta la sentencia for), almacenando la
nota ingresada en la décima posición del arreglo notas[ ], es decir en notas[9].
Pag. 420
Finalizada la ejecución de la primera sentencia for, el arreglo notas[ ] deberá tener almacenadas las notas
finales de los 10 alumnos del salón de clase. Tal y como se muestra a continuación:
notas
10 15 20 19 14 13 16 11 17 09
i =10
0 1 2 3 4 5 6 7 8 9
Finalmente, se ejecuta el proceso de cálculo del promedio de las 10 notas finales. Para ello, se utiliza una
segunda sentencia for exactamente igual a la primera sentencia for. Cada vez que se ejecuta la segunda
sentencia for, se suma uno de los datos almacenados en el arreglo notas[ ] (empezando desde el primero i
= 0 hasta el último i = 9) a la variable sumaNotas (la variable sumaNotas actúa como acumulador).
Finalizada la ejecución de la sentencia for se muestra el promedio de las 10 notas finales.
Observe que el proceso de ingreso de datos y el proceso de cálculo del promedio de las 10 notas finales se
desarrollan utilizando 2 sentencias for exactamente iguales. Esto es recomendable como buena práctica de
programación ya que posteriormente cada proceso desarrollado se convertirá en un método de una clase
con una función determinada.
Pag. 421
Ahora, se modificará la solución anterior de tal forma que permita almacenar las notas finales
de todos los alumnos de un determinado salón de clase.
Clase PrgAlumnos
// Declaración de variables.
int numAlu ;
double sumaNotas = 0 ;
// Determinación del tamaño del arreglo.

System.out.print ( “ Ingrese el número de alumnos : ” ) ;
numAlu = Lectura.leerInt( ) ;
// Declaración y creación del arreglo notas.

double notas[] = new double [numAlu] ;

System.out.print ( “ Ingrese la nota final del alumno [” + ( i + 1) + “]: ” ) ;
}

}
System.out.print ( “ El promedio es : ” + ( sumaNotas / numAlu ) ) ;
}
}
En la solución anterior, se declara y crea el arreglo notas[ ] utilizando la siguiente sentencia:
// Declaración y creación del arreglo notas.

Observe que para crear el arreglo notas[ ] se utiliza la variable entera numAlu. La variable numAlu fue
declarada previamente con la sentencia int, y se le asignó un valor que fue ingresado por el usuario a
través del teclado. Esto nos permite crear un arreglo llamado notas[ ] con un tamaño equivalente al valor
almacenado en la variable numAlu. Es decir, en el arreglo notas[ ] se podrán almacenar las notas finales de
todos los alumnos de un salón de clase.
Pag. 422
Otra modificación que vale la pena destacar es la siguiente:
Esta sentencia esta ubicada dentro de la sentencia for y nos permite el ingreso de datos al arreglo llamado
notas[ ].

}
Utilizando dicha sentencia con la variable i (la cual aumenta su valor en 1 cada vez que se ejecuta la
sentencia for), se puede personalizar el mensaje que se le muestra al usuario al momento del ingreso de
las notas finales.
Cuando i = 0 (la primera vez que se ejecuta la sentencia for), se mostrará el siguiente mensaje:
Ingrese la nota final del alumno [1]:
La nota final ingresada se almacenará en la primera posición del arreglo notas[ ], es decir en notas[0].
Cuando i = 1 (la segunda vez que se ejecuta la sentencia for), se mostrará el siguiente mensaje:
Ingrese la nota final del alumno [2]:
La nota final ingresada se almacenará en la segunda posición del arreglo notas[ ], es decir en notas[1], y
así sucesivamente hasta ingresar la nota final del último alumno.
Pag. 423
Ahora, se modificará nuevamente la solución anterior, de tal forma que permita consistenciar
la entrada de datos. Se consistenciará el ingreso del número total de alumnos y de la nota
final de cada uno de ellos.
Clase PrgAlumnos
int numAlu ;
double sumaNotas = 0 ;
// Determinación del tamaño del arreglo con consistencia de datos.

do {
if ( numAlu <= 0 ) {
System.out.println ( “ El número de alumnos no es valido… Reintente! ” ) ;
}
} while ( numAlu < 0 ) ;
// Declaración y creación de arreglo.

// Proceso de ingreso de datos al arreglo notas[ ] con consistencia de datos.

do {
if ( notas[i] > 20 || notas[i] < 0 ) {
System.out.println ( “ Nota ingresada no es valida… Reintente! ” ) ;
}
} while ( notas[i] > 20 || notas[i] < 0 ) ;
}

for ( int I = 0 ; i < numAlu ; i++ ) {
}
System.out.print ( “ El promedio es : ” + ( sumaNotas / numAlu ) ) ;
}
}
Observe el uso de la sentencia do dentro de la sentencia for. Uno de los principales usos de la sentencia
do es la consistencia de datos. La consistencia de datos nos permite asegurarnos que el usuario ingrese
solo datos válidos antes de que estos se almacenen en las variables o en los arreglos.
Pag. 424
FORMALIZACIÓN DE LA SOLUCIÓN UTILIZANDO EL MÉTODO DE LAS 6’D
Problema 132
Desarrollar una solución que permita ingresar y almacenar las notas finales de todos los
alumnos de un determinado salón de clase. Determinar y mostrar el promedio de las
notas finales. Consistenciar el ingreso de datos.
Resultado deseado: Mostrar el promedio de las notas finales de

los alumnos de un determinado salón de
clase.
Datos necesarios: El número de alumnos y las notas finales de

cada uno de ellos.
Procesamiento: El número de alumnos se ingresa a través del

teclado y se almacena en una variable
(numAlu). Con el número de alumnos
ingresado se crea un arreglo (notas[ ]). Luego
se procede a ingresar las notas finales de
todos los alumnos y se almacenan en el
arreglo creado. Después, se realiza la suma
de todas las notas finales y el resultado se
almacena en una variable acumulador
(sumaNotas). Finalmente, se realiza el
cálculo del promedio, se almacena el
resultado en una variable (prom) y se
muestra por pantalla.
Pag. 425
1. Nombre del Proyecto: ProyAlumnos.
Clases Clases
Pag. 426
Algoritmo PrgAlumnos01 - método main ( )
ENTRADA: numAlu, notas[ ]

SALIDA: prom
INICIO
COMENTARIO “Declaración de variables”

NUMERO i, numAlu, sumaNotas = 0, notas[ ], prom
COMENTARIO “Determinación del tamaño del arreglo”

HACER
LEER numAlu
SI (numAlu <= 0 )
ENTONCES
ESCRIBIR “Número de alumnos no válido... Reintente!”
FINSI
MIENTRAS (numAlu <= 0 )
COMENTARIO “Creación del arreglo”

CREAR notas [numAlu]
COMENTARIO “Ingreso de datos al arreglo notas[ ].”

DESDE i = 0 HASTA i = numAlu - 1 INCREMENTA 1
HACER
LEER notas[i]
SI ( notas[i] > 20 || notas[i] < 0 )
ENTONCES
ESCRIBIR “Nota no válida... Reintente!”
FINSI
MIENTRAS ( notas[i] > 20 || notas[i] < 0 )
FINDESDE
COMENTARIO “Cálculo del promedio de notas finales”

sumaNotas = sumaNotas + notas[i]
FINDESDE
prom = sumaNotas / numAlu
ESCRIBIR prom
FIN
Pag. 427
Clase PrgAlumnos01
public class PrgAlumnos01 {
int i, numAlu ;
double sumaNotas = 0, prom ;

do {
System.out.println ( “ El número de alumnos no es válido… Reintente! ” ) ;
}
} while ( numAlu <= 0 ) ;
// Declaración y creación del arreglo.

double notas[ ] = new double [numAlu] ;
// Proceso de ingreso de datos al arreglo notas[ ] con consistencia de datos.

for ( i = 0 ; i < numAlu ; i++ ) {
do {
System.out.print ( “ Ingrese la nota final del alumno [ ” + ( i + 1) + “]: ” ) ;
if ( notas[i] > 20 || notas[i] < 0 ) {

System.out.println ( “ Nota ingresada no es válida… Reintente! ” ) ;
}
}

for ( i = 0 ; i < numAlu ; i++ ) {
}
prom = sumaNotas / numAlu ;

System.out.println ( “ El promedio es : ” + prom ) ;
}
}
Pag. 428
Problema 133
Desarrollar una solución que permita ingresar y almacenar las notas de todas las
prácticas de un alumno. Determinar el promedio de las prácticas sabiendo que se
elimina la práctica con la nota mas baja. Mostrar el promedio redondeado.
Consistenciar el ingreso de datos.
Resultado deseado: Mostrar el promedio redondeado de las notas

de las prácticas de un alumno.
Datos necesarios: El número de prácticas y las notas de las

prácticas del alumno.
Procesamiento: El número de prácticas se ingresa a través

del teclado y se almacena en una variable
(numPra). Con el número de prácticas se
crea un arreglo (notas[ ]). Luego se procede a
ingresar las notas de las prácticas del alumno
y se almacenan en el arreglo creado.
Después, se realiza la suma de todas las
notas de las prácticas y el resultado se
almacena en una variable de tipo acumulador
(sumaNotas). Luego, se determina la nota
más baja del alumno y se almacena en una
variable (notaMenor). Finalmente, se realiza
el cálculo del promedio ((sumaNotas –
notaMenor) / (numPra – 1)), se almacena el
resultado en una variable (promAlu), se
redondea y se muestra por pantalla.
Pag. 429
Clases Clases
Pag. 430
ENTRADA: numPra, notas[ ]

SALIDA: promAlu
INICIO

NUMERO i, numPra, sumaNotas = 0, notaMenor = 20
NUMERO notas[ ], promAlu

HACER
LEER numPra
SI (numPra <= 0 )
ENTONCES
ESCRIBIR “Número de prácticas no válido… Reintente!”
FINSI
MIENTRAS (numPra <= 0 )

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
FINSI
MIENTRAS ( notas[i] > 20 || notas[i] < 0 )
FINDESDE
COMENTARIO “Cálculo del promedio de notas de las prácticas”

sumaNotas = sumaNotas + notas[i]
FINDESDE

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
int i, numPra ;
double sumaNotas = 0, notaMenor = 20, promAlu ;

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

double notas[ ] = new double [numPra] ;
// Ingreso de datos al arreglo notas[ ] con consistencia de datos.

for ( i = 0 ; i < numPra ; i++ ) {
do {
System.out.print ( “ Ingrese la nota de la práctica [ ” + ( i + 1) + “]: ” ) ;
if ( notas[i] > 20 || notas[i] < 0 ) {
}
}
// Proceso de cálculo del promedio de notas de las prácticas.

for ( i = 0 ; i < numPra ; 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
Desarrollar una solución que permita ingresar y almacenar las notas de las tres
prácticas de todos los alumnos de un salón de clase. Determinar el promedio de cada
alumno sabiendo que se duplica su nota más alta. Mostrar el promedio redondeado.
Consistenciar el ingreso de datos.

de las tres prácticas de cada alumno.
Datos necesarios: El número de alumnos y las notas de las tres

prácticas de cada alumno.

(numAlu). Con el número de alumnos se crea
un arreglo (notas[ ][ ]). Luego se procede a
ingresar las notas de las tres prácticas de
cada alumno y se almacenan en el arreglo
creado.
Después, por cada alumno, se realiza la

suma de las notas de sus tres prácticas y el
resultado se almacena en una variable
acumulador (sumaNotas). Luego, se
determina su nota más alta y se almacena en
una variable (notaMayor). Finalmente, se
realiza el cálculo de su promedio
((sumaNotas + notaMayor) / 4), se almacena
el resultado en una variable (promAlu), se
redondea y se muestra por pantalla.
Pag. 433
Clases Clases
Pag. 434
ENTRADA: numAlu, notas[ ][ ]

SALIDA: promAlu
INICIO

NUMERO i, j, numAlu, sumaNotas = 0, notaMayor = 0
NUMERO notas[ ][ ], promAlu

HACER
LEER numAlu
SI (numAlu <= 0 )
ENTONCES
ESCRIBIR “Número de alumnos no válido… Reintente!”
FINSI

CREAR notas [numAlu][3]
COMENTARIO “Ingreso de datos al arreglo notas[ ][ ]”

DESDE j = 0 HASTA j = 2 INCREMENTA 1
HACER
LEER notas[i][j]
SI ( notas[i][j] > 20 || notas[i][j] < 0 )

ENTONCES
FINSI
MIENTRAS ( notas[i][j] > 20 || notas[i][j] < 0 )
FINDESDE
FINDESDE
COMENTARIO “Cálculo del promedio de notas por alumno”

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

ESCRIBIR promAlu
FINDESDE
FIN
Pag. 435
Clase PrgAlumnos03
int i, j, numAlu ;
double sumaNotas = 0, notaMayor = 0, promAlu ;

do {
}

double notas[ ][ ] = new double [numAlu][3] ;
// Ingreso de datos al arreglo notas[ ][ ] con consistencia de datos.

for ( i = 0 ; i < numAlu ; i++ ) {
System.out.println ( “ Alumno [ ” + ( i + 1) + “ ]: ” ) ;
for { i = 0 ; j < 3 ; j++ ) {
do {
System.out.print ( “ Ingrese la nota de la práctica [ ” + ( j + 1) + “]: ” ) ;
notas[i][j] = Lectura.leerDouble( ) ;
if ( notas[i][j] > 20 || notas[i][j] < 0 ) {
}
} while ( notas[i][j] > 20 || notas[i][j] < 0 ) ;
}
}
// Cálculo del promedio de notas por alumno.

for ( i = 0 ; i < numAlu ; i++ ) {
notaMayor = Math.max (notas[i][0], notas[i][1] ) ;
notaMayor = Math.max (notas[i][2], notaMayor ) ;
sumaNotas = notas[i][0] + notas[i][1] + notas[i][2] ;
promAlu = ( sumaNotas + notaMayor ) / 4 ;
System.out.println ( “ El promedio del alumno [ ” + ( i + 1 ) + “ ] es: ” + promAlu ) ;
}
}
}
Pag. 436
Problema 135
Desarrollar una solución que permita ingresar y almacenar las notas de las prácticas de
todos los alumnos de un salón de clase. Determinar el promedio de cada alumno
sabiendo que se duplica su nota más alta y se elimina su práctica con la nota mas baja.
Mostrar el promedio redondeado a dos decimales. Consistenciar el ingreso de datos.
Finalmente; determinar y mostrar el promedio simple de todas las notas de las prácticas
de los alumnos del salón de clase.
Resultado deseado: Mostrar el promedio redondeado a dos

decimales de las notas de las prácticas de
cada alumno y el promedio simple de todas
las notas de las prácticas de los alumnos.
Datos necesarios: El número de alumnos, el número de

prácticas y las notas de las prácticas de cada
alumno.
Procesamiento: El número de alumnos y el número de

prácticas se ingresa a través del teclado y se
almacenan en variables (numAlu y numPra
respectivamente). Con los datos ingresados
se crea un arreglo (notas[ ][ ]). Luego se
procede a ingresar las notas de las prácticas
de cada alumno y se almacenan en el arreglo
creado.

suma de las notas de las prácticas y el
resultado se almacenan en una variable de
tipo acumulador (sumaNotas). Luego, se
determina su nota más alta y se almacena en
una variable (notaMayor). También se
determina su nota mas baja y se almacena en
una variable (notaMenor). Finalmente, se
realiza el cálculo de su promedio
((sumaNotas + notaMayor - notaMenor) /
numPra), se almacena el resultado en una
variable (promAlu), se redondea y se
Pag. 437
Adicionalmente, se realiza la suma de las

notas de las prácticas de todos los alumnos
del salón de clase y el resultado se almacena
nuevamente en una variable de tipo
acumulador (sumaNotas). Se determina el
promedio simple, se almacena el resultado en
una variable (prom) y se muestra por
pantalla.
Clases Clases
Pag. 438
ENTRADA: numAlu, numPra, notas[ ][ ]

SALIDA: promAlu, prom
INICIO

NUMERO i, j, numAlu, numPra, sumaNotas = 0, notaMayor = 0
NUMERO notaMenor = 20, notas[ ][ ], promAlu, prom

HACER
LEER numAlu
SI (numAlu <= 0 )
ENTONCES
ESCRIBIR “Número de alumnos no válido.. Reintente!”
FINSI
HACER
LEER numPra
SI (numPra <= 0 )
ENTONCES
ESCRIBIR “Número de prácticas no válido.. Reintente!”
FINSI
MIENTRAS (numPra < 0 )

CREAR notas [numAlu][numPra]

DESDE j = 0 HASTA j = numPra - 1 INCREMENTA 1

HACER
LEER notas[i][j]
SI ( notas[i][j] > 20 || notas[i][j] < 0 )

ENTONCES
FINSI
MIENTRAS ( notas[i][j] > 20 || notas[i][j] < 0 )

FINDESDE
FINDESDE
Pag. 439
Algoritmo PrgAlumnos04 – método main ( )

notaMayor = 0
notaMenor = 20
sumaNotas = 0
notaMayor = notaMayor MAXIMO notas[i][j]
notaMenor = notaMenor MAXIMO notas[i][j]
sumaNotas = sumaNotas + notas[i][j]
FINDESDE
promAlu = (sumaNotas+notaMayor-notaMenor) / numPra
ESCRIBIR promAlu
FINDESDE
COMENTARIO “Cálculo del promedio simple de todas las notas”

sumaNotas = 0
FINDESDE
FINDESDE
prom = sumaNotas / ( numAlu * numPra )

prom = prom REDONDEA 2
ESCRIBIR prom
FIN
Pag. 440
Clase PrgAlumnos04
int i, j, numAlu, numPra ;
double sumaNotas = 0, notaMayor = 0, notaMenor = 20, promAlu, prom ;
/// Determinación del tamaño del arreglo con consistencia de datos.

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

double notas[ ][ ] = new double [numAlu][numPra] ;

for ( i = 0 ; i < numAlu ; i++ ) {
for { i = 0 ; j < numPra ; j++ ) {
do {
System.out.print ( “ Ingrese la nota de la práctica [ ” + ( j + 1) + “]: ” ) ;
if ( notas[i][j] > 20 || notas[i][j] < 0 ) {
}
} while ( notas[i][j] > 20 || notas[i][j] < 0 ) ;
}
}
Pag. 441
Clase PrgAlumnos04

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 ;
// Cálculo del promedio simple de todas las notas.

sumaNotas = 0 ;
for ( i = 0 ; i < numAlu ; i++ ) {
for { i = 0 ; j < numPra ; 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
Desarrollar una solución que permita ingresar y almacenar las notas del examen
parcial, promedio de trabajos y examen final de todos los alumnos de un salón de clase.
Consistenciar el ingreso de los datos. Determinar el promedio de cada alumno sabiendo
que se duplica la nota del examen final. Mostrar el promedio redondeado. También,
calcular y mostrar el promedio obtenido por los alumnos en el examen final.
Finalmente; determinar y mostrar el porcentaje de alumnos aprobados y el porcentaje
de alumnos desaprobados.

de cada alumno, el promedio obtenido por los
alumnos en el examen final y el porcentaje de
alumnos aprobados y desaprobados.
Datos necesarios: El número de alumnos y las notas del examen

parcial, promedio de trabajos y examen final
de cada alumno.

(numAlu). Con el número de alumnos se crea
un arreglo (notas[ ][ ]). Luego se procede a
ingresar las notas del examen parcial,
promedio de trabajos y examen final de cada
alumno y se almacenan en el arreglo creado.

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
Adicionalmente, se realiza la suma de las

notas del examen final de todos los alumnos
del salón de clase y el resultado se almacena
nuevamente en una variable acumulador
(sumaEF). Se determina el promedio simple,
Pag. 443
se almacena el resultado en una variable

(promEF), se redondea y se muestra por
pantalla. Finalmente, se realiza nuevamente
el cálculo del promedio de notas de cada
alumno (promAlu) y se determina la cantidad
de alumnos aprobados y la cantidades de
desaprobados, almacenando los resultados
en variables (aprobados y desaprobados
respectivamente), luego se realiza el calculo
del porcentaje de alumno aprobados y
desaprobados, se almacena el resultado en
variables (porceAprob y porceDesaprob
respectivamente), y se muestran por pantalla.
Clases Clases
Pag. 444
Algoritmo PrgAlumnos05- método main ( )
ENTRADA: numAlu, notas[ ][ ]

SALIDA: promAlu, promEF, porceAprob, porceDesaprob
INICIO

NUMERO i, numAlu, sumaNotas = 0, sumaEF = 0
NUMERO notas[ ][ ], promAlu, promEF, porceDesaprob
NUMERO aprobados = 0, desaprobados = 0, porceAprob

HACER
LEER numAlu
SI (numAlu <= 0 )
ENTONCES
ESCRIBIR “Número de alumnos no válido… Reintente!”
FINSI

CREAR notas [3][numAlu]

HACER
COMENTARIO “Examen Parcial”
LEER notas[0][i]
SI ( notas[0][i] > 20 || notas[0][i] < 0 )
ENTONCES
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
FINSI
Pag. 445
Algoritmo PrgAlumnos05- método main ( )
HACER
COMENTARIO “Examen Final”
LEER notas[2][i]
SI ( notas[2][i] > 20 || notas[2][i] < 0 )
ENTONCES
FINSI

FINDESDE

sumaNotas = notas[0][i] + notas[1][i] + notas[2][i] * 2
promAlu = sumaNotas / 4
ESCRIBIR promAlu
FINDESDE
COMENTARIO “Cálculo del promedio simple de examen final”

sumaEF = sumaEF + notas[2][i]
FINDESDE
promEF = sumaEF / numAlu
promEF = promEF REDONDEA 2
ESCRIBIR promEF
COMENTARIO “Cálculo de alumnos aprobados y desaprobados”

sumaNotas = notas[0][i] + notas[1][i] + notas[2][i] * 2
promAlu = sumaNotas / 4
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
int i, numAlu, aprobados = 0, desaprobados = 0 ;
double sumaNotas = 0, sumaEF = 0, promAlu, promEF, porceAprob, porceDesaprob ;

do {
}

double notas[ ][ ] = new double [3][numAlu] ;

for ( i = 0 ; i < numAlu ; i++ ) {
do {
System.out.print ( “ Ingrese la nota del examen parcial : ” ) ;
notas[0][i] = Lectura.leerDouble( ) ;
if ( notas[0][i] > 20 || notas[0][i] < 0 ) {
}
} while ( notas[0][i] > 20 || notas[0][i] < 0 ) ;
do {
System.out.print ( “ Ingrese la nota promedio de trabajos : ” ) ;
if ( notas[1][i] > 20 || notas[1][i] < 0 ) {
}
do {
System.out.print ( “ Ingrese la nota del examen final : ” ) ;
if ( notas[2][i] > 20 || notas[2][i] < 0 ) {
}
}
Pag. 447
Clase PrgAlumnos05

for ( i = 0 ; i < numAlu ; i++ ) {
sumaNotas = notas[0][i] + notas[1][i] + notas[2][i] * 2 ;
promAlu = sumaNotas / 4 ;
// Cálculo del promedio simple del examen final.

for ( i = 0 ; i < numAlu ; i++ ) {
sumaEF = sumaEF + notas[2][i] ;
}
promEF = sumaEF / numAlu ;
promEF = ( Math.round (promEF * 100) ) / 100.0 ;
System.out.println ( “ El promedio de las notas del examen final es : ” + promEF ) ;
// Cálculo de alumnos aprobados y desaprobados.

for ( i = 0 ; i < numAlu ; i++ ) {
sumaNotas = notas[0][i] + notas[1][i] + notas[2][i] * 2 ;
promAlu = sumaNotas / 4 ;
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
Desarrollar una solución que permita ingresar y almacenar el sueldo de todos los
trabajadores de una empresa. Calcular y mostrar el aumento de sueldo de cada uno de
los trabajadores (redondeado a dos decimales), de acuerdo a la siguiente tabla.
Consistenciar los datos ingresados.
Condición Aumento
sueldo < 410 20 %
sueldo >= 410 y sueldo <= 1600 10 %
sueldo > 1600 05 %
Resultado deseado: Mostrar el aumento de sueldo de cada uno de

los trabajadores de una empresa.
Datos necesarios: El número de trabajadores de la empresa y el

sueldo de cada uno de ellos.
Procesamiento: El número de trabajadores se ingresa a través

(numTrab). Con el número de trabajadores
se crea un arreglo (sueldos[ ]). Luego se
procede a ingresar los sueldos de cada
trabajador y se almacenan en el arreglo
creado.
Después, por cada trabajador, en base a su

sueldo se determina su aumento de sueldo.
Si el trabajador tiene un sueldo menor a
S/.410.00 nuevos soles se le aumenta el 20%
de su sueldo. Si el trabajador tiene un sueldo
mayor a S/.1,600.00 nuevos soles, se le
aumenta el 5% de su sueldo y en otros casos
el aumento es del 10% de su sueldo. El
aumento se almacena en una variable
(aumento), se redondea y se muestra por
pantalla.
Pag. 449
1. Nombre del Proyecto: ProyTrabajadores.
Clases Clases
Pag. 450
Algoritmo PrgTrabajadores01 - método main ( )
ENTRADA: numTrab, sueldos[ ]

SALIDA: aumento
INICIO

NUMERO i, numTrab, sueldos[ ], aumento = 0

HACER
LEER numTrab
SI (numTrab <= 0 )
ENTONCES
ESCRIBIR “Número de trabajadores no válido… ”
FINSI
MIENTRAS (numTrab <= 0 )

CREAR sueldos [numTrab]
COMENTARIO “Ingreso de datos al arreglo sueldos[ ]”

DESDE i = 0 HASTA i = numTrab - 1 INCREMENTA 1
HACER
LEER sueldos[i]
SI ( sueldos[i] <= 0 )
ENTONCES
ESCRIBIR “Sueldo ingresado no es válido... ”
FINSI
MIENTRAS ( sueldos[i] <= 0 )
FINDESDE
COMENTARIO “Cálculo del aumento de sueldo por trabajador”

SI ( sueldos[i] < 410 )
ENTONCES
aumento = sueldos[i] * 0.2
SINO
SI ( sueldos[i] > 1600 )
SINO
FINSI
FINSI
aumento = aumento REDONDEA 2
ESCRIBIR aumento
FINDESDE
FIN
Pag. 451
Clase PrgTrabajadores01
public class PrgTrabajadores01 {

int i, numTrab ;
double aumento = 0 ;

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

double sueldos[ ] = new double [numTrab] ;
// Ingreso de datos al arreglo sueldos[ ] con consistencia de datos.

for ( i = 0 ; i < numTrab ; i++ ) {
do {
System.out.print ( “ Ingrese el sueldo del trabajador [ ” + ( i + 1) + “ ]: ” ) ;
sueldos[i] = Lectura.leerDouble( ) ;
if ( sueldos[i] <= 0 ) {
System.out.println ( “ Sueldo ingresado no es válido… Reintente! ” ) ;
}
} while ( sueldos[i] <= 0 ) ;
}
// Cálculo del aumento de sueldo por trabajador.

for ( i = 0 ; i < numTrab ; i++ ) {
if ( sueldos[i] < 410 ) {
aumento = sueldos[i] * 0.2 ;
} else {
if ( sueldos[i] > 1600 ) {
} else {
}
}
aumento = ( Math.round (aumento * 100) ) / 100.0 ;
System.out.println ( “ Aumento del trabajador [ ” + ( i + 1) + “ ] es : ” + aumento ) ;
}
}
}
Pag. 452
Problema 138
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.
Resultado deseado: Mostrar el sueldo neto a cobrar por cada

trabajador de la empresa.


creado.

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
Pag. 453
Clases Clases
Pag. 454

SALIDA: sueldoNeto
INICIO

NUMERO i, numTrab, sueldos[ ], descuento = 0, aumento = 0
NUMERO sueldoNeto

HACER
LEER numTrab
SI (numTrab <= 0 )
ENTONCES
FINSI


HACER
LEER sueldos[i]
ENTONCES
FINSI
FINDESDE
COMENTARIO “Cálculo del sueldo neto de cada trabajador”

descuento = 0
aumento = 0
ENTONCES
descuento = sueldos[i] * 0.15
FINSI
FINSI
sueldoNeto = sueldos[i] – descuento + aumento
sueldoNeto = sueldoNeto REDONDEA 2
ESCRIBIR sueldoNeto
FINDESDE
FIN
Pag. 455

int i, numTrab ;
double aumento = 0, descuento = 0 ;

do {
}


for ( i = 0 ; i < numTrab ; i++ ) {
do {
}
}
// Cálculo del sueldo neto de cada trabjador.

for ( i = 0 ; i < numTrab ; i++ ) {
descuento = 0 ;
aumento = 0 ;
if ( sueldos[i] > 1600 )
descuento = sueldos[i] * 0.15 ;
if ( sueldos[i] < 1000 )
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
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.
Condición Aumento Descuento

sueldo < 410 20% 00 %
sueldo >= 410 y sueldo <= 1600 10% 08 %
sueldo > 1600 05% 15 %
Resultado deseado: Mostrar el sueldo neto a cobrar por cada

trabajador de la empresa, su aumento y su
respectivo descuento. También mostrar el
monto total que paga la empresa por
concepto de sueldos.


creado.

sueldo se determina su respectivo aumento y
descuento. Si el trabajador tiene un sueldo
menor a S/.410.00 nuevos soles se le
aumenta el 20% de su sueldo y no se le
realiza ningún descuento. Si el trabajador
tiene un sueldo mayor a S/.1,600.00 nuevos
soles, se le aumenta el 5% de su sueldo y se
le descuenta 15%. En otros casos el aumento
es del 10% de su sueldo y el descuento es de
Pag. 457
8%. El aumento se almacena en una variable

(aumento) y el descuento en otra variable
(descuento). Luego, se determina el sueldo
neto ((sueldo – descuento + aumento), se
almacena el resultado en una variable
(sueldoNeto), se redondea y se muestra por
pantalla. También se muestra el aumento y el
descuento calculado. El sueldo neto obtenido
se suma a una variable acumulador
(sueldoTotal).
Después de finalizar el cálculo del sueldo

neto de cada trabajador se muestra por
pantalla el contenido de la variable
acumulador sueldoTotal.
Pag. 458
Clases Clases

SALIDA: sueldoNeto, aumento, descuento, sueldoTotal
INICIO

NUMERO i, numTrab, sueldos[ ], aumento = 0, descuento = 0
NUMERO sueldoNeto, sueldoTotal = 0

HACER
LEER numTrab
SI (numTrab <= 0 )
ENTONCES
FINSI

Pag. 459

HACER
LEER sueldos[i]
ENTONCES
FINSI
FINDESDE
COMENTARIO “Cálculo del sueldo neto, aumento y descuento por

trabajador, y del total de sueldos ”

ENTONCES
descuento = 0
SINO

SINO
FINSI
FINSI
sueldoNeto = sueldos[i] – descuento + aumento

aumento = aumento REDONDEA 2
descuento = descuento REDONDEA 2
ESCRIBIR sueldoNeto, aumento, descuento

sueldoTotal = sueldoTotal + sueldoNeto
FINDESDE
ESCRIBIR sueldoTotal
FIN
Pag. 460
int i, numTrab ;
double aumento = 0, descuento = 0, sueldoNeto, sueldoTotal = 0 ;

do {

}


for ( i = 0 ; i < numTrab ; i++ ) {
do {

}
Pag. 461
// Cálculo del sueldo neto, aumento y descuento por trabajador, y del total de sueldos.
for ( i = 0 ; i < numTrab ; i++ ) {
if ( sueldos[i] < 410 ) {

descuento = 0 ;
} else {
if ( sueldos[i] > 1600 ) {
} else {
}
}
sueldoNeto = sueldos[i] + aumento – descuento ;

aumento = ( Math.round (aumento * 100) ) / 100.0 ;
descuento = ( Math.round (descuento * 100) ) / 100.0 ;

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
Desarrollar una solución que permita ingresar y almacenar las horas trabajadas y la
tarifa horaria de todos los trabajadores de una empresa. Calcular y mostrar el sueldo
neto de cada trabajador, sabiendo que se tiene que descontar el 10% por impuestos y
el 5% por seguro.
Resultado deseado: Mostrar el sueldo de cada trabajador de la

empresa.
Datos necesarios: El número de trabajadores de la empresa, y

las horas trabajadas y la tarifa horaria de
cada uno de ellos.

se crea un arreglo (sueldos[ ][ ]). Luego se
procede a ingresar las horas trabajadas y la
tarifa horaria de cada trabajador y se
almacenan en el arreglo creado.
Después, por cada trabajador, se determina

el sueldo neto ((horas trabajadas * tarifa
horaria * 1.15), se almacena el resultado en
una variable (sueldoNeto), se redondea y se
Pag. 463
Clases Clases
Pag. 464
ENTRADA: numTrab, sueldos[ ][ ]

SALIDA: sueldoNeto
INICIO

NUMERO i, numTrab, sueldos[ ][ ], sueldoNeto

HACER
LEER numTrab
SI (numTrab <= 0 )
ENTONCES
FINSI

CREAR sueldos [numTrab][2]
COMENTARIO “Ingreso de datos al arreglo sueldos[ ][ ]”

HACER
COMENTARIO “Ingreso de las horas trabajadas”
LEER sueldos[i][0]
SI ( sueldos[i][0] <= 0 )
ENTONCES
ESCRIBIR “Número de horas no válida... ”
FINSI
MIENTRAS ( sueldos[i][0] <= 0 )
HACER
COMENTARIO “Ingreso de la tarifa horaria”
LEER sueldos[i][1]
SI ( sueldos[i][1] <= 0 )
ENTONCES
ESCRIBIR “Tarifa horaria no válida... ”
FINSI
MIENTRAS ( sueldos[i][1] <= 0 )
FINDESDE
COMENTARIO “Cálculo del sueldo neto de cada trabajador”

sueldoNeto = sueldo[i][0] * sueldo[i][1] * 0.85
ESCRIBIR sueldoNeto
FINDESDE
FIN
Pag. 465
int i, numTrab ;
double sueldoNeto ;

do {

}

double sueldos[ ][ ] = new double [numTrab][2] ;
// Ingreso de datos al arreglo sueldos[ ][ ] con consistencia de datos.

for ( i = 0 ; i < numTrab ; i++ ) {
System.out.println ( “ Ingrese los datos del trabajador [ ” + ( i + 1) + “ ]: ” ) ;
do {
System.out.print ( “ Número de horas trabajadas: ” ) ;
sueldos[i][0] = Lectura.leerDouble( ) ;
if ( sueldos[i][0] <= 0 ) {
System.out.println ( “Número de horas trabajadas no válida… ” ) ;
}
} while ( sueldos[i][0] <= 0 ) ;
do {
System.out.print ( “ Tarifa horaria: ” ) ;
sueldos[i][1] = Lectura.leerDouble( ) ;
if ( sueldos[i][1] <= 0 ) {
System.out.println ( “ Tarifa horaria no válida… ” ) ;
}
} while ( sueldos[i][1] <= 0 ) ;
Pag. 466
// Cálculo del sueldo neto de cada trabajador.
for ( i = 0 ; i < numTrab ; i++ ) {
sueldoNeto = sueldos[i][0] * sueldos[i][1] * 0.85 ;

}
}
Pag. 467
Problema 141
Desarrollar una solución que permita ingresar y almacenar las horas trabajadas y la
tarifa horaria de todos los trabajadores de una empresa. Calcular y mostrar el sueldo de
cada trabajador, sabiendo que hasta 48 horas trabajadas se paga una tarifa normal y
sobre las 48 horas, se paga la tarifa con un recargo del 25%. Por otro lado, si el sueldo
es superior a S/.1,600.00 nuevos soles, al trabajador se le descuenta el 10% y si el
sueldo es superior a S/.3,500.00 nuevos soles, al trabajador se le descuenta el 15%.
Adicionalmente, se ha establecido un aumento a todos los trabajadores, equivalente al
15% del sueldo. Mostrar el sueldo total (sueldo bruto) y el sueldo a cobrar (sueldo neto)
de cada trabajador redondeado a dos decimales.
Resultado deseado: Mostrar el sueldo de cada trabajador de la

empresa.
Datos necesarios: El número de trabajadores de la empresa, y

las horas trabajadas y la tarifa horaria de
cada uno de ellos.

se crea un arreglo (sueldos[ ][ ]). Luego se
procede a ingresar las horas trabajadas y la
tarifa horaria de cada trabajador y se
Después, por cada trabajador, se determina

el sueldo bruto. Si el número de horas
trabajadas es mayor a 48 horas, el sueldo
bruto se determina de la siguiente forma:
( horas trabajadas – 48 ) * ( tarifa horaria *

1.25 ) + ( 48 * tarifa horaria)
En caso contrario se determina de la

siguiente forma:
( horas trabajadas * tarifa horaria )
El sueldo bruto se almacena en una variable

(sueldoBruto).
Pag. 468
Luego, por cada trabajador, se determina el

descuento y el aumento de sueldo. Si el
sueldo bruto es mayor a S/.3,500.00 nuevos
soles, se calcula el descuento del 15%. Si el
sueldo bruto es menor o igual a S/.3,500.00
nuevos soles y si el sueldo bruto es mayor a
S/.1600.00 nuevos soles, se calcula el
descuento del 10%. Caso contrario el
descuento es cero. En todos los casos el
descuento se almacena en una variable
(descuento). Después, se calcula el aumento
del 15% del sueldo y se almacena en la
variable (aumento). Finalmente se realiza el
calculo del sueldo neto (sueldoBruto +
aumento – descuento) y se almacena en una
variable (sueldoNeto). El sueldo neto y el
sueldo bruto se redondean a dos decimales y
se muestran por pantalla.
Pag. 469
Clases Clases
ENTRADA: numTrab, sueldos[ ][ ]

SALIDA: sueldoBruto, sueldoNeto
INICIO

NUMERO i, numTrab, sueldos[ ][ ], descuento
NUMERO sueldoNeto, sueldoBruto

HACER
LEER numTrab
SI (numTrab <= 0 )
ENTONCES
FINSI

CREAR sueldos [2][numTrab]
Pag. 470
COMENTARIO “Ingreso de datos al arreglo sueldos[ ][ ]”

HACER
COMENTARIO “Ingreso de las horas trabajadas”
LEER sueldos[0][i]
SI ( sueldos[0][i] <= 0 )
ENTONCES
ESCRIBIR “Número de horas no válida... ”
FINSI
MIENTRAS ( sueldos[0][i] <= 0 )
HACER
COMENTARIO “Ingreso de la tarifa horaria”
LEER sueldos[1][i]
SI ( sueldos[1][i] <= 0 )
ENTONCES
ESCRIBIR “Tarifa horaria no válida... ”
FINSI
MIENTRAS ( sueldos[1][i] <= 0 )
FINDESDE
COMENTARIO “Cálculo del sueldo bruto y neto por trabajador”

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
ESCRIBIR sueldoBruto, sueldoNeto

FINDESDE
FIN
Pag. 471
int i, numTrab ;
double sueldoNeto ;

do {

}

double sueldos[ ][ ] = new double[2][numTrab] ;
// Ingreso de datos al arreglo sueldos[ ][ ] con consistencia de datos.

for ( i = 0 ; i < numTrab ; i++ ) {
System.out.println ( “ Ingrese los datos del trabajador [ ” + ( i + 1) + “ ]: ” ) ;
do {
System.out.print ( “ Número de horas trabajadas: ” ) ;
sueldos[0][i] = Lectura.leerDouble( ) ;
if ( sueldos[0][i] <= 0 ) {
System.out.println ( “Número de horas trabajadas no válida… ” ) ;
}
} while ( sueldos[0][i] <= 0 ) ;
do {
System.out.print ( “ Tarifa horaria: ” ) ;
sueldos[1][i] = Lectura.leerDouble( ) ;
if ( sueldos[1][i] <= 0 ) {
System.out.println ( “ Tarifa horaria no válida… ” ) ;
}
} while ( sueldos[1][i] <= 0 ) ;
Pag. 472
// Cálculo del sueldo bruto y neto por trabajador.
for ( i = 0 ; i < numTrab ; i++ ) {
if ( sueldos[0][i] > 48 ) {
sueldoBruto = ( sueldos[0][i] – 48) * (sueldos[1][i] * 1.25) + (48 - sueldos[1][i] ) ;
} else {
sueldoBruto = sueldos[0][i] * sueldos[1][i] ) ;
}
if ( sueldoBruto > 3500 ) {

descuento = sueldoBruto * 0.15 ;
} else {
if ( sueldoBruto > 1600 ) {
descuento = sueldoBruto * 0.10 ;
} else {
descuento = 0 ;
}
}
aumento = sueldoBruto * 0.15 ;

sueldoNeto = sueldoBruto + aumento – descuento ;
sueldoBruto = ( Math.round (sueldoBruto * 100) ) / 100.0 ;

System.out.println ( “ Trabajador [ ” + ( i + 1) + “ ] ” ) ;
System.out.println ( “ Sueldo bruto : ” + sueldoBruto ) ;
System.out.println ( “ Sueldo neto : ” + sueldoNeto ) ;
}
}
Pag. 473
Problema 142
Desarrollar una solución que permita ingresar y almacenar el nombre de todos los
artículos de una bodega. Consistenciar la entrada de datos. Mostrar cada uno de los
nombre con su respectiva longitud.
Resultado deseado: Mostrar el nombre y la longitud del nombre de

todos los artículos de una bodega.
Datos necesarios: El número de artículos y el nombre de cada

uno de los artículos.
Procesamiento: El número de artículos se ingresa a través del

(numArt). Con el número de artículos se crea
un arreglo (articulos[ ]). Luego se procede a
ingresar el nombre de los artículos de la
bodega, se almacenan temporalmente en una
variable (sueldo), luego se eliminan los
espacios del inicio y final del nombre, y se
almacenan en el arreglo creado. Después,
para cada uno de los nombres, se determina
su longitud, se almacena en una variable
(tamaño) y se muestra por pantalla.
Pag. 474
Clases Clases
Algoritmo PrgArticulos01 - método main ( )
ENTRADA: numArt, nombres

SALIDA: tamaño
INICIO

NUMERO i, numArt, tamaño
TEXTO articulos[ ], nombre

HACER
LEER numArt
SI (numArt <= 0 )
ENTONCES
ESCRIBIR “Número de artículos no válido… ”
FINSI
MIENTRAS (numArt <= 0 )

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 artículo no válido...”
FINSI
MIENTRAS (LONGITUD articulos[i] < 3 )
FINDESDE
COMENTARIO “Cálculo de la longitud de los nombres”

tamaño = LONGITUD articulos[i]
ESCRIBIR articulos[i], tamaño
FINDESDE
FIN
Clase PrgArticulos01
public class PrgArticulos01 {
int i, numArt, tamaño ;
String nombre ;

do {
System.out.print ( “ Ingrese el número de artículos : ” ) ;
numArt = Lectura.leerInt( ) ;
if ( numArt <= 0 ) {
System.out.println ( “ El número de artículos no es válido… Reintente! ” ) ;
}
} while ( numArt <= 0 ) ;
Pag. 476

String articulos[ ] = new String [numArt] ;
// Ingreso de datos al arreglo artículos[ ] con consistencia de datos.

for ( i = 0 ; i < numArt ; i++ ) {
do {
System.out.print ( “ Ingrese el nombre del artículo [ ” + ( i + 1) + “]: ” ) ;
nombre = Lectura.leerString( ) ;
articulos[i] = nombre.trim( ) ;
if ( articulos[i].length( ) < 3 ) {
System.out.println ( “ El nombre ingresado no es válido… Reintente! ” ) ;
}
} while ( articulos[i].length( ) < 3 ) ;
// Cálculo de la longitud de los nombres.

for ( i = 0 ; i < numArt ; i++ ) {
tamaño = articulos[i].length( ) ;
System.out.println ( “ Artículo ” + articulos[i] + “ tiene una longitud de ” + tamaño ) ;
}
}
}
Pag. 477
Problema 143
artículos de una bodega. Consistenciar la entrada de datos. Mostrar la primera letra de
cada nombre en mayúscula y el resto en minúscula. Adicionalmente, mostrar la longitud
de cada uno de los nombres.
Resultado deseado: Mostrar la primera letra de todos los nombres

en letra mayúscula y el resto en letra
minúscula. Adicionalmente mostrar la longitud
de cada uno de los nombres de los artículos.


bodega, se eliminan los espacios del inicio y
final del nombre, y se almacenan en el arreglo
creado.
Después, para cada uno de los nombres, se

obtiene la primera letra, se almacena en una
variable (letra) y se convierte en mayúscula.
Luego, se obtiene las demás letras, se
almacenan en una variable (resto) y se
convierten en minúscula. También, se
determina la longitud del nombre y se
almacena en una variable (tamaño).
Finalmente, se muestra la primera letra del
nombre en mayúscula, las demás letras en
minúscula y la longitud del nombre por
pantalla.
Pag. 478
Clases Clases
Pag. 479
ENTRADA: numArt, articulos[ ]

SALIDA: letra, resto, tamaño
INICIO

NUMERO i, numArt, tamaño
TEXTO articulos[ ], letra, resto

HACER
LEER numArt
SI (numArt <= 0 )
ENTONCES
FINSI


HACER
LEER articulos[i]
articulos[i] = articulos[i] ELIMINAESPACIO INICIO, FIN
ENTONCES
FINSI
FINDESDE
COMENTARIO “ Manipulación del nombre de los artículos ”

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

resto = MINUSCULA resto
ESCRIBIR letra, resto, tamaño

FINDESDE
FIN
Pag. 480
int i, numArt, tamaño ;
String letra, resto ;

do {
}

// Ingreso de datos al arreglo articulos[ ] con consistencia de datos.

for ( i = 0 ; i < numArt ; i++ ) {
do {
articulos[i] = Lectura.leerString( ) ;
articulos[i] = articulos[i].trim( ) ;
}
}
// Manipulación del nombre de los artículos.

for ( i = 0 ; i < numArt ; i++ ) {
letra = articulos[i].substring(0,1) ;
letra = letra.toUpperCase( );
resto = articulos[i].substring(1) ;
resto = resto].toLowerCase( ) ;
System.out.println ( “ Artículo ” + letra + resto + “ tiene una longitud de ” + tamaño ) ;
}
}
}
Pag. 481
Problema 144
artículos de una bodega. Consistenciar la entrada de datos. Mostrar la primera letra y la
última letra de cada uno de los nombres en letra mayúscula y minúscula
respectivamente.

en letra mayúscula y el resto en letra
minúscula. Adicionalmente mostrar la longitud
de cada uno de los nombres de los artículos.


creado.

variable (letraIni) y se convierte en
mayúscula. Luego, se obtiene la última letra,
se almacenan en una variable (letraFin) y se
convierten en minúscula. Finalmente, se
muestra por pantalla, la primera letra del
nombre en mayúscula y la última letra del
nombre en minúscula.
Pag. 482
Clases Clases
Pag. 483

SALIDA: letraIni, letraFin
INICIO

NUMERO i, numArt
TEXTO articulos[ ], letraIni, letraFin

HACER
LEER numArt
SI (numArt <= 0 )
ENTONCES
FINSI


HACER
LEER articulos[i]
ENTONCES
FINSI
FINDESDE

letraIni = articulos[i] CARACTER INICIO
letraIni = MAYUSCULA letraIni
letraFin = articulos[i] CARACTER FIN

letraFin = MINUSCULA letraFin
ESCRIBIR letraIni, letraFin

FINDESDE
FIN
Pag. 484
int i, numArt ;
char letraIni, letraFin ;

do {
}


for ( i = 0 ; i < numArt ; i++ ) {
do {
}
}

for ( i = 0 ; i < numArt ; i++ ) {
letraIni = articulos[i].charAt(0) ;
letraIni = Character.toUpperCase(letraIni) ;
letraFin = articulos[i].charAt (articulos[i].length( ) -1) ;
LetraFin = Character.toLowerCase(letraFin) ;
System.out.println ( “ Artículo ” + articulos[i] ) ;
System.out.println ( “ Letra inicial : ” + letraIni + “. Letra final : ” + letraFin + “.” ) ;
}
}
}
Pag. 485
Problema 145
Desarrollar una solución que permita ingresar y almacenar el nombre, la sigla y la

descripción de todos los artículos de una bodega. Consistenciar la entrada de datos.
Mostrar la primera letra del nombre y la descripción en mayúscula y el resto en
minúscula. . También, mostrar las siglas del artículo en mayúscula.

y las descripciones en letra mayúscula y el
resto en letra minúscula. También mostrar las
siglas del artículo en minúscula.
Datos necesarios: El número de artículos y, el nombre, la

descripción y las siglas de cada uno de los
artículos.

ingresar el nombre, la descripción y las siglas
de los artículos de la bodega, se eliminan los
espacios del inicio y final de los mismos, y se

variable (letra), se obtiene las demás letras y
se almacenan en una variable (resto). Luego
se convierte a mayúscula la variable letra y a
minúscula la variable resto y se almacenan en
una variable (nombre). Luego, para cada una
de las descripciones se realiza lo mismo y el
resultado se almacenan en una variable
(descrip). También, se convierte a mayúscula
las siglas de cada artículo y se almacena en
una variable (siglas).
Finalmente, los resultados se muestran por
pantalla.
Pag. 486
Clases Clases
Pag. 487
ENTRADA: numArt, articulos[ ][ ]

SALIDA: nombre, descrip, siglas
INICIO

NUMERO i, numArt
TEXTO articulos[ ][ ], nombre, descrip, siglas

HACER
LEER numArt
SI (numArt <= 0 )
ENTONCES
FINSI

CREAR articulos [numArt][3]

HACER
COMENTARIO “ Ingreso del nombre de los artículos ”

LEER articulos[i][0]
articulos[i][0] = articulos[i][0] ELIMINAESPACIO INICIO
articulos[i][0] = articulos[i][0] ELIMINAESPACIO FIN
SI ( LONGITUD articulos[i][0] < 3 )
ENTONCES
FINSI
MIENTRAS (LONGITUD articulos[i][0] < 3 )
HACER
COMENTARIO “ Ingreso descripción de los artículos ”

ENTONCES
ESCRIBIR “Descripción de artículo no válida...”
FINSI
Pag. 488
HACER
COMENTARIO “ Ingreso siglas de los artículos ”


ENTONCES
ESCRIBIR “Sigla de artículo no válida...”
FINSI
FINDESDE
COMENTARIO “Manipulación del nombre de los artículos”

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
int i, numArt ;
String letra, resto, nombre, descrip, siglas ;

do {
}

String articulos[ ][ ] = new String [numArt][3] ;
// Ingreso de datos al arreglo artículos[ ][ ] con consistencia de datos.

for ( i = 0 ; i < numArt ; i++ ) {
do {
System.out.print ( “ Ingrese el nombre del artículo [ ” + ( i + 1) + “ ]: ” ) ;
articulos[i][0] = Lectura.leerString( ) ;
articulos[i][0] = articulos[i][0].trim( ) ;
if (articulos[i][0].length( ) < 3 ) {
System.out.println ( “ El nombre ingresado no es válido… ” ) ;
}
} while (articulos[i][0].length( ) < 3 ) ;
do {
System.out.print ( “ Ingrese la descripción del artículo [ ” + ( i + 1) + “ ]: ” ) ;
System.out.println ( “ La descripción ingresada no es válida… ” ) ;
}
Pag. 490
do {
System.out.print ( “ Ingrese la sigla del artículo [ ” + ( i + 1) + “ ]: ” ) ;
System.out.println ( “ La sigla ingresada no es válida… ” ) ;
}
// Manipulación del nombres, descripción y sigla de los artículos

for ( i = 0 ; i < numArt ; i++ ) {
letra = articulos[i][0].substring(0,1) ;
resto = articulos[i][0].substring(1) ;
nombre = letra.toUpperCase( ) + resto.toLowerCase( ) ;
letra = articulos[i][1].substring(0,1) ;
resto = articulos[i][1].substring(1) ;
descrip = letra.toUpperCase( ) + resto.toLowerCase( ) ;
siglas = articulos[i][2].toUpperCase( ) ;
System.out.println ( “ Artículo ” + ( i+1 ) ) ;

System.out.println ( “ ---------------------- ” ) ;
System.out.println ( “ Nombre: ” + nombre + “.” ) ;
System.out.println ( “ Descripción: ” + descrip + “.” ) ;
System.out.println ( “ Siglas: ” + siglas + “.” ) ;
}
}
}
Pag. 491
Pag. 492
DESARROLLO DE SOLUCIONES UTILIZANDO MÚLTIPLES ARREGLOS
Arreglos en paralelos
Cuando se plantean soluciones a diversos problemas es necesario utilizar variables, vectores

y matrices en forma simultánea para almacenar los datos. Es decir, en una solución se puede
utilizar algunas variables, un vector, dos vectores o muchos vectores. También, se puede
utilizar variables, un vector y una matriz, o dos vectores y una matriz. En términos generales
se puede afirmar que en una solución se utilizan variables, vectores y matrices en forma
simultánea y en el número que se necesiten. Esto va a depender de la complejidad y tipo de
problema que se necesite resolver.
Cuando en una solución se utiliza más de un arreglo y el orden en que se disponen los datos
entre los arreglos tiene un significado se les denomina vectores paralelos.
En la solución del problema 146 se utilizan algunas variables y dos vectores en forma
simultanea (en paralelo). En una de las variables (numTrab) se almacena el número de
trabajadores y con este valor se crean los dos vectores (los arreglos en paralelo deben tener
el mismo tamaño). En uno de los vectores (nombres[ ]) se almacenan los nombres de todos
los trabajadores y en el otro vector (sueldos[ ]) se almacenan sus respectivos sueldos. Se
puede observar que un dato almacenado en una posición de un vector esta relacionado con
el dato almacenado en la misma posición del otro vector. A continuación, se muestra el
planteamiento de la solución en forma gráfica. Es importante tener presente que los vectores
paralelos se grafican en forma vertical para comprender mejor la relación que existe entre
ellos.
nombres sueldos
Datos del mismo
trabajador.
0 0
1 1
2 2
: : : :
: : : :
numTrab - 1 : numTrab - 1 :
nombre de los sueldo de los
trabajadores trabajadores
Si en nombres[0] se almacena el nombre “Danae”, resulta lógico y necesario que en

sueldos[0] almacenemos su respectivo sueldo.
La pregunta lógica que se pueden formular sería la siguiente: ¿por qué en vez de crear dos
vectores en paralelo no creamos una matriz con dos columnas?, y la respuesta sería que en
una matriz solo se pueden almacenar datos del mismo tipo, mientras que usando dos
vectores en paralelo se pueden almacenar datos de diferente tipo. En el planteamiento de la
Pag. 493
solución anterior en uno de los vectores se almacenan datos de tipo TEXTO mientras que en
el otro vector se almacenan datos de tipo NUMERO.
En la solución del problema 147 se utilizan algunas variables y tres vectores en forma
simultanea (en paralelo). En una de las variables (numSoc) se almacena el número de socios
de un club y con este valor se crean los tres vectores. En uno de los vectores (nombres[ ]) se
almacenan los nombres de los socios, en otro vector (sexos[ ]) se almacena el sexo de cada
uno de los socios y en el tercer vector (edades[ ]) sus respectivas edades. Como ejemplo, se
puede observar, que todos los datos de la socia Danae están almacenados en la posición
cero de los vectores en paralelo. A continuación se muestra el planteamiento de la solución.
nombres sexos Edades
0 Danae 0 F 0 10
1 1 1
2 2 2
: : : : : :
: : : : : :
numSoc - 1 : numSoc - 1 : numSoc - 1 :
nombres de sexo de sueldo de
cada socios cada socio cada socio
En la solución del problema 148 se utilizan algunas variables, un vector y una matriz con dos
columnas en forma simultanea (en paralelo). A continuación se muestra el planteamiento de
la solución.
nombres precios
0 1
0 0
1 1
2 2
: : : : :
: : : : :
numArt - 1 : numArt - 1 : :
nombre de precio de compra precio de venta
cada artículos de cada artículos de cada artículos
Pag. 494
Problema 146
Desarrollar una solución que permita ingresar y almacenar el nombre y el sueldo de

todos los trabajadores de una empresa. Mostrar el nombre del trabajador que tiene el
sueldo más alto y el promedio del sueldo de todos los trabajadores redondeado a dos
decimales.
Resultado deseado: Mostrar el nombre del trabajador que tiene el

sueldo más alto y el promedio del sueldo de
todos los trabajadores.
Datos necesarios: El número de trabajadores y, el nombre y el

sueldo de cada trabajador.

se crean dos arreglos (nombres[] y
sueldos[]). Luego se procede a ingresar el
nombre de los trabajadores, se eliminan los
almacenan en uno de los arreglos creados
(nombres[ ]). También, se procede a ingresar
el sueldo de los trabajadores y se almacenan
en el otro arreglo creado (sueldos[ ]).
Después, se determina el sueldo mas alto

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

de todos los trabajadores sumando el sueldo
de cada trabajador a una variable acumulador
Pag. 495
(sumaSueldos) y dividiendo la suma total de

los sueldos entre el número de trabajadores.
El resultado se almacena en una variable
(sueldoPromedo), se redondea a dos
decimales y se muestra por pantalla.
Clases Clases
Pag. 496
ENTRADA: numTrab, nombres[ ], sueldos[ ]

SALIDA: nombres[ ], sueldoPromedio
INICIO

NUMERO i, numTrab, sueldos[ ]
NUMERO sueldoMayor = 0, sumaSueldos = 0, sueldoPromedio
TEXTO nombres[ ]

HACER
LEER numTrab
SI (numTrab <= 0 )
ENTONCES
FINSI
COMENTARIO “Creación de los arreglos”

CREAR nombres [numTrab]
COMENTARIO “Ingreso de nombres y sueldos de trabajadores”

HACER
COMENTARIO “ Ingreso de nombre de trabajadores ”

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

LEER sueldos[i]
ENTONCES
ESCRIBIR “Sueldo de trabajador no válido...”
FINSI
FINDESDE
Pag. 497
COMENTARIO “Determinando el nombre de los trabajador con el

sueldo mas alto”
SI ( i = 0 )
ENTONCES
sueldoMayor = sueldos[i]
SINO
SI ( sueldoMayor < sueldo[i] )
ENTONCES
sueldoMayor = sueldo[i]
FINSI
FINSI
FINDESDE

SI (sueldoMayor = sueldo[i] )
ENTONCES
ESCRIBIR nombres[i]
SINO
FINDESDE
COMENTARIO “Determinando el promedio del sueldo de todos los

trabajadores”
sumaSueldos = sumaSueldos + sueldos[i]
FINDESDE
sueldoPromedio = sumaSueldos / numTrab

sueldoPromedio = sueldoPromedio REDONDEA 2
ESCRIBIR sueldoPromedio
FIN
Pag. 498
int i, numTrab ;
double sueldoMayor = 0, sumaSueldos = 0, sueldoPromedio ;
// Determinación del tamaño de los arreglos con consistencia de datos.

do {
System.out.print ( “ Ingrese el número de trabajadores : ” ) ;
}

String nombres[ ] = new String [numTrab] ;
// Ingreso de nombres y sueldos de trabajadores con consistencia de datos.

for ( i = 0 ; i < numTrab ; i++ ) {
do {
System.out.print ( “ Ingrese el nombre del trabajador [ ” + ( i + 1) + “ ]: ” ) ;
nombres[i] = Lectura.leerString( ) ;
nombres[i] = nombres[i].trim( ) ;
if ( nombres[i].length( ) < 3 ) {
System.out.println ( “ El nombre del trabajador no es válido… ” ) ;
}
} while ( nombres[i].length( ) < 3 ) ;
do {
sueldos[i] = Lectura.leerString( ) ;
System.out.println ( “ El sueldo del trabajador no es válido… ” ) ;
}
} 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 más alto ” ) ;

for ( i = 0 ; i < numTrab ; i++ ) {
if ( sueldoMayor == sueldos[i] ) {
System.out.println ( “ ” + nombres[i] ) ;
}
}
// Determinando el promedio del sueldo de todos los trabajadores.

for ( i = 0 ; i < numTrab ; i++ ) {
sumaSueldos = sumaSueldos + sueldos[i] ;
}
sueldoPromedio = sumaSueldos / numTrab ;
sueldoPromedio = ( Math.round (sueldoPromedio * 100) ) / 100.0 ;
System.out.println ( “ El sueldo promedio de los trabajadores es: ” + sueldoPromedio ) ;
}
}
Pag. 500
Problema 147
Desarrollar una solución que permita ingresar y almacenar el nombre, el sexo y la edad
de todos los socios de un club. Indicar el número de socios mayores de edad que son
hombres y el número de socios cuyo nombre comienza con la letra “D”.
Resultado deseado: Mostrar el número de socios hombres

mayores de edad y el número de socios cuyo
nombre comienza con la letra “D”.
Datos necesarios: El número de socios y, el nombre, sexo y

edad de cada socio.
Procesamiento: El número de socios se ingresa a través del

(numSoc). Con el número de socios se crean
tres arreglos (nombres[],sexos[] y
edades[]). Luego se procede a ingresar el
nombre de los socios, se eliminan los
almacenan en uno de los arreglos creados
(nombres[]). Luego, se procede a ingresar el
sexo de los socios (M = Masculino y F = Femenino),
se convierte a mayúscula y se almacenan en
otro de los arreglos creado (sexos[]). Por
último, se ingresan las edades de los socios y
se almacenan en el tercer arreglo (edades[]).
Después, se determina el número de socios

hombres, mayores de edad. Para esto se
evalúan los datos de cada uno de los socios y
si resulta que es hombre (sexo = ‘M’) y es
mayor de edad (edad >= 18), entonces se
aumenta 1 a una variable de tipo contador
(totalMayoresHombres). Finalizada la
evaluación de los datos de todos los socios
se muestra el contenido de la variable
totalMayoresHombres.
Luego, se determina el número de socios

cuyo nombre comienza con la letra ‘D’. Para
esto se obtiene la primera letra del nombre de
Pag. 501
cada socio y se almacena en una variable

(letra), se convierte a mayúscula y se
compara con la letra ‘D’. Si letra = ‘D’,
entonces se aumenta 1 a otra variable tipo
contador (totalNombresD). Finalizada la
evaluación se muestra el contenido de la
variable totalNombresD.
1. Nombre del Proyecto: ProySocios.
Clases Clases
Pag. 502
Algoritmo PrgSocios01 - método main ( )
ENTRADA: numSoc, nombres[ ], sexos[ ], edades[ ]

SALIDA: totalMayoresHombres, totalNombresD
INICIO

NUMERO i, numSoc, edades[ ]
NUMERO totalMayoresHombres = 0, totalNombresD = 0
TEXTO nombres[ ], sexos[ ], letra

HACER
LEER numSoc
SI (numSoc <= 0 )
ENTONCES
ESCRIBIR “Número de socios no válido… ”
FINSI
MIENTRAS (numSoc <= 0 )

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
ENTONCES
ESCRIBIR “Nombre del socio no válido...”
FINSI
HACER
COMENTARIO “ Ingreso de sexo de socios ”

LEER sexos[i]
sexos[i] = MAYUSCULA sexos[i]
SI ( sexos[i] <> ‘M’ OR sexos[i] <> ’F’ )
ENTONCES
ESCRIBIR “Sexo de socio no válido...”
FINSI
MIENTRAS ( sexos[i] <> ‘M’ OR sexos[i] <> ’F’ )
Pag. 503
Algoritmo PrgSocios01 - método main ( )
HACER
COMENTARIO “ Ingreso de edad de socios ”

LEER edades[i]
SI ( edades[i] <= 0 )
ENTONCES
ESCRIBIR “Edad de socio no válida...”
FINSI
MIENTRAS ( edades[i] <= 0 )
FINDESDE
COMENTARIO “Determinando número de socios hombres mayores

de edad”
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”
letra = nombres[i] CARACTER 0

SI ( letra = ‘D’ )
ENTONCES
totalNombresD = totalNombresD + 1
FINSI
FINDESDE
ESCRIBIR totalNombresD
FIN
Pag. 504
Clase PrgSocios01
public class PrgSocios01 {
int i, numSoc, totalMayoresHombres = 0, totalNombresD = 0 ;
char letra ;

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

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) + “ ]: ” ) ;
System.out.println ( “ El nombre del socio no es válido… ” ) ;
}
do {
System.out.print ( “ Ingrese el sexo del trabajador [ ” + ( i + 1) + “ ]: ” ) ;
sexos[i] = Lectura.leerChar( ) ;
sexos[i] = Character.toUpperCase( sexos[i] ) ;
if ( sexos[i] != ‘M’ || sexos[i] != ‘F’ ) {

System.out.println ( “ El sexo del trabajador no es válido… ” ) ;
}
} while ( sexos[i] != ‘M’ || sexos[i] != ‘F’ ) ;
Pag. 505
Clase PrgSocios01
do {
System.out.print ( “ Ingrese la edad del socio [ ” + ( i + 1) + “ ]: ” ) ;
edades[i] = Lectura.leerInt( ) ;
if ( edades[i] <= 0 ) {
System.out.println ( “ La edad del socio no es válida… ” ) ;
}
} while ( edades[i] <= 0 ) ;
}
// Determinando el número de socios hombres mayores de edad.

for ( i = 0 ; i < numSoc ; i++ ) {
if ( edades[i] >= 18 && sexos[i] == ‘M’ ) {
totalMayoresHombres ++ ;
}
}
System.out.print ( “ El número de socios hombres mayores de edad es : ” ) ;

System.out.println ( totalMayoresHombres ) ;
// Determinando el número de socios cuyo nombre comienza con la letra D.

for ( i = 0 ; i < numSoc ; i++ ) {
letra = nombres[i].charAt(0) ;
letra = carácter.toUpperCase(letra) ;
if ( letra == ‘M’ ) {
totalNombresD ++ ;
}
System.out.print ( “ El número de socios cuyo nombre comienza con la letra D es : ” ) ;

System.out.println ( totalNombresD ) ;
}
}
Pag. 506
Problema 148
Desarrollar una solución que permita ingresar y almacenar el nombre, el precio de

compra y el precio de venta de todos los artículos de una bodega. Indicar el nombre de
cada artículo y su margen de utilidad.
Resultado deseado: Mostrar el nombre de cada artículo y su

margen de utilidad.
Datos necesarios: El número de artículos y, el nombre, el precio

de compra y el precio de venta de cada
artículo.

(numArt). Con el número de artículos se
crean dos arreglos, un vector y una matriz
con dos columnas (nombres[ ] y precios[ ][ ]).
Luego se procede a ingresar el nombre de los
artículos, se eliminan los espacios del inicio y
final de los mismos, y se almacenan en uno
de los arreglos creados (nombres[ ]). Luego,
se procede a ingresar el precio de compra y
el precio de venta, y se almacenan en el otro
arreglo creado (precios[ ][ ]). El precio de
compra se almacena en la primera columna
del arreglo y el precio de venta se almacena
en la segunda columna.
Después, se determina la utilidad de cada

artículo. Para esto, el precio de venta del
artículo se resta de su precio de compra, se
almacena el resultado en una variable
(utilidad) y se muestra el nombre del artículo
junto con su utilidad.
Pag. 507
Clases Clases
Pag. 508
ENTRADA: numArt, nombres[ ], precios[ ][ ]

SALIDA: nombres[ ], utilidad
INICIO

NUMERO i, numArt, precios[ ][ ], utilidad
TEXTO nombres[ ]

HACER
LEER numArt
SI (numArt <= 0 )
ENTONCES
FINSI

CREAR nombres [numArt]
CREAR precios [numArt][2]
COMENTARIO “Ingreso de nombre, precio de compra y precio de

venta de los artículos ”
HACER
COMENTARIO “ Ingreso de nombre de artículo ”

LEER nombres[i]
nombres[i] = nombres[i] ELIMINAESPACIO INICIO, FIN
ENTONCES
ESCRIBIR “Nombre del artículo no válido...”
FINSI
HACER
COMENTARIO “ Ingreso de precio de compra ”

LEER precios[i][0]
SI ( precios[i][0] <= 0 )
ENTONCES
ESCRIBIR “Precio de compra no válido...”
FINSI
MIENTRAS ( precios[i][0] <= 0 )
Pag. 509
HACER
COMENTARIO “ Ingreso de precio de venta ”

LEER precios[i][1]
SI ( precios[i][1] <= 0 )
ENTONCES
ESCRIBIR “Precio de venta no válido...”
FINSI
MIENTRAS ( precios[i][1] <= 0 )
FINDESDE
COMENTARIO “Determinando la utilidad de cada artículo ”

utilidad = precios[i][1] – precios[i][0]

ESCRIBIR nombres[i], utilidad
FINDESDE
FIN
Pag. 510
int i, numArt ;
double utilidad ;

do {
}

String nombres[ ] = new String [numArt] ;
double edades[ ] = new double [numArt][2] ;
// Ingreso de nombre, precio de compra y precio de venta de los artículos.

for ( i = 0 ; i < numArt ; i++ ) {
do {
System.out.print ( “ Ingrese el nombre del artículo [ ” + ( i + 1) + “ ]: ” ) ;
System.out.println ( “ El nombre del artículo no es válido… ” ) ;
}
do {
System.out.print ( “ Ingrese su precio de compra : ” ) ;
precios[i][0] = Lectura.leerDouble( ) ;
if ( precios[i][0] <= 0 ) {
System.out.println ( “ Precio de compra no válido… ” ) ;
}
} while ( precios[i][0] <= 0 ) ;
Pag. 511
do {
System.out.print ( “ Ingrese su precio de venta : ” ) ;
precios[i][1] = Lectura.leerDouble( ) ;
if ( precios[i][1] <= 0 ) {
System.out.println ( “ Precio de venta no válido… ” ) ;
}
} while ( precios[i][1] <= 0 ) ;
// Determinando la utilidad de cada artículo.

for ( i = 0 ; i < numArt ; i++ ) {
utilidad = precios[i][1] – precios[i][0] ;
System.out.print ( “ El artículo : ” + nombres[i] + “ tiene una utilidad de ” ) ;
System.out.println ( “ ” + utilidad + “.” ) ;
}
}
}
Pag. 512
Problema 149
Desarrollar una solución que permita ingresar y almacenar el nombre, el código y las
diferentes notas de los alumnos de un salón de clase. Indicar el nombre, el código y el
promedio de notas de cada alumno. Almacenar el promedio de notas de cada alumno.
Adicionalmente, indicar el nombre de los alumnos que obtuvieron el mayor promedio.
Resultado deseado: Mostrar el nombre, el código y el promedio de

notas de cada alumno. Adicionalmente,
indicar el nombre de los alumnos que
obtuvieron el mayor promedio.
Datos necesarios: El número de alumnos y, el nombre, el código

y las notas de cada alumno.
Procesamiento: El número de alumnos y el número de notas

se ingresa a través del teclado y se almacena
en variables (numAlu y numNot
respectivamente). Con el número de alumnos
y el número de notas se crean cuatro
arreglos, tres vectores y una matriz
(nombres[], codigos[], notas[][] y
promedios[][]). Luego se procede a ingresar
el nombre de los alumnos, y se almacenan en
uno de los arreglos creados (nombres[]).
Luego, se procede a ingresar el código de los
alumnos y se almacenan en otro arreglo
(codigos[]). Támbien se ingresan las notas
de cada alumno y se almacenan en otro de
los arreglos (notas[][]).
Después, se determina el promedio de cada

alumno y el promedio mayor. Para esto, se
suman las notas del alumno y se almacenan
en una variable (sumaNotas) y luego se
divide entre el número de notas (numNot). El
resultado se almacenada en otra variable
(promAlu), se redondea y esta a su vez se
almacena en el arreglo promedios[].
Después se muestra el nombre, el código y el
promedio de cada alumno. Luego se
determina el promedio mayor y se almacena
Pag. 513
en una variable (promAluMayor).

Finalmente, se muestran los nombres de
todos los alumnos que tienen promedio igual
a promAluMayor.
Clases Clases
Pag. 514
ENTRADA: numAlu, numNot, nombre[ ], codigos[ ], notas[ ][ ]

SALIDA: nombres[ ], codigos[ ], promedios[ ]
INICIO

NUMERO i, j, numAlu, nomNot, codigos[ ], notas[ ][ ], promedios[ ]
NUMERO sumaNotas = 0, promAlu = 0, promAluMayor = 0
TEXTO nombres[ ]

HACER
LEER numAlu
SI (numAlu <= 0 )
ENTONCES
ESCRIBIR “Número de alumnos no válido… ”
FINSI
HACER
LEER numNot
SI (numNot <= 0 )
ENTONCES
ESCRIBIR “Número de notas no válido… ”
FINSI
MIENTRAS (numNot <= 0 )

CREAR nombres [numAlu]
CREAR codigos [numAlu]
CREAR notas [numAlu][numNot]
CREAR promedios[numAlu]
COMENTARIO “Ingreso de nombre, codigo y notas de todos los

alumnos ”
HACER
LEER nombres[i]
nombres[i] = nombres[i] ELIMINAESPACIO INICIO,FIN
ENTONCES
ESCRIBIR “Nombre del alumno no válido...”
FINSI
Pag. 515
HACER
LEER codigos[i]
SI ( codigos[i] < 100000 OR codigos[i] > 999999 )
ENTONCES
ESCRIBIR “Código ingresado no válido...”
FINSI
MIENTRAS ( codigos[i] < 100000 OR codigos[i] > 999999 )
DESDE j = 0 HASTA j = numNot - 1 INCREMENTA 1
HACER
LEER notas[i][j]
SI ( notas[i][j] < 0 OR notas[i][j] > 20 )
ENTONCES
ESCRIBIR “Nota ingresada no válida...”
FINSI
MIENTRAS ( notas[i][j] < 0 OR notas[i][j] > 20 )
FINDESDE
FINDESDE
COMENTARIO “Determinando el promedio de cada alumno y el

promedio mayor ”
sumaNotas = 0
DESDE j = 0 HASTA j = numNot - 1 INCREMENTA 1
FINDESDE
promAlu = sumaNotas / numNot
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”
SI ( promedios[i] = promAluMayor )
ENTONCES
ESCRIBIR nombres[i]
FINSI
FINDESDE
FIN
Pag. 516
Clase PrgAlumnos06
int i, j, numAlu, numNot ;
double sumaNotas = 0, promAlu = 0, promAluMayor = 0 ;

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

String nombres[ ] = new String [numAlu] ;
long codigos[ ] = new long [numAlu] ;
double notas[ ][ ] = new double [numAlu][numNot] ;
double promedios[ ] = new double [numAlu] ;
// Ingreso de nombre, precio de compra y precio de venta de los artículos.

for ( i = 0 ; i < numAlu ; i++ ) {
do {
System.out.print ( “ Ingrese el nombre del alumno [ ” + ( i + 1) + “ ]: ” ) ;
System.out.println ( “ El nombre del alumno no es válido… ” ) ;
}
Pag. 517
Clase PrgAlumnos06
do {
System.out.print ( “ Ingrese su código : ” ) ;
codigos[i] = Lectura.leerLong( ) ;
if ( codigos[i] < 100000 || codigos[i] > 999999 ) {
System.out.println ( “ Precio de compra no válido… ” ) ;
}
} while ( codigos[i] < 100000 || codigos[i] > 999999 ) ;
for ( j = 0 ; j < numNot ; j++ ) {
do {
System.out.print ( “ Ingrese su nota ” + ( j + 1) + “ : ” ) ;
if (notas[i][j] < 0 || notas[i][j] > 20 ) {
System.out.println ( “ Nota ingresada no válida… ” ) ;
}
} while (notas[i][j] < 0 || notas[i][j] > 20 ) ;
}
}
// Determinando el promedio de cada alumno y el promedio mayor.

for ( i = 0 ; i < numAlu ; i++ ) {
sumaNotas = 0 ;
for ( j = 0 ; j < numNot ; j++ ) {
}
promAlu = sumaNotas / numNot ;
promAlu = ( Math.round (promAlu * 100) ) / 100.0 ;
promedios[i] = promAlu ;
System.out.print ( “ El alumno ” + nombres[i] + “ con código ” + codigos[i] ) ;
System.out.println ( “ tiene un promedio de ” + promedios[i] + “.” ) ;
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
artículos de una bodega. Consistenciar la entrada de datos. Mostrar los nombres
ordenados alfabéticamente, considerando la primera letra de cada nombre en
mayúscula y el resto en minúscula. Adicionalmente, mostrar la longitud de cada uno de
los nombres.
Resultado deseado: Mostrar los nombres ordenados

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


creado.
Después se ordenan los nombres utilizando el

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

SALIDA: letra, resto, tamaño
INICIO

NUMERO i, j, numArt, tamaño
TEXTO articulos[ ], letra, resto, x

HACER
LEER numArt
SI (numArt <= 0 )
ENTONCES
FINSI


HACER
LEER articulos[i]
ENTONCES
FINSI
FINDESDE
COMENTARIO “Método de Intercambio. Ordenación de datos ”

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

letra = articulos[i] SUBCADENA 0,1
resto = articulos[i] SUBCADENA 1

resto = MINUSCULA resto
ESCRIBIR letra, resto, tamaño
FINDESDE
FIN
int i, j, numArt, tamaño ;
String letra, resto, x ;

do {
}

Pag. 522

for ( i = 0 ; i < numArt ; i++ ) {
do {
}
}
// Método de Intercambio. Ordenación de datos.

for ( i = 0 ; i < numArt – 1 ; i++ ) {
for ( j = i + 1; j < numArt ; j++ ) {
if ( articulos[i].compareTo(articulos[j] ) > 0 ) {
x = articulos[i] ;
articulos[i] = articulos[j] ;
articulos[j] = x ;
}
}
}

for ( i = 0 ; i < numArt ; i++ ) {
letra = articulos[i].substring(0,1) ;
letra = letra.toUpperCase( );
resto = articulos[i].substring(1) ;
resto = resto].toLowerCase( ) ;
System.out.println ( “ Artículo ” + letra + resto + “ tiene una longitud de ” + tamaño ) ;
}
}
}
Pag. 523
Pag. 524
Capítulo
Introducción al Desarrollo de
Soluciones Orientadas a Objetos
5
Temas:
Introducción.
Conceptos básicos:
• Clase.
• Objeto.
• Atributo.
• Método.
• Ocultar Atributos de Instancia.
Método de las 6´D. Etapas y pasos.
Problema desarrollado.
INTRODUCCIÓN AL DESARROLLO DE SOLUCIONES ORIENTADAS A OBJETOS
CAPÍTULO V
INTRODUCCIÓN AL DESARROLLO DE SOLUCIONES

ORIENTADAS A OBJETOS
INTRODUCCIÓN
La clase constituye la base de la programación orientada a objetos y es el núcleo o unidad

fundamental de encapsulación en Java. Cualquier concepto que desee desarrollar en Java
debe ser encapsulado en una clase. Una clase se usa para crear objetos.
MARCO DE TRABAJO
ENUNCIADO
DEL
PROBLEMA
Etapa 02
Definición
Solución Etapa 03
Diseño
Solución Etapa 04
Desarrollo
Solución
Pag. 527
En los capítulos anteriores, se ha utilizado la clase en su forma más simple. Las clases
creadas se utilizaban simplemente para encapsular el método main(), lo que ha permitido
mostrar la base de la sintaxis de Java, las estructuras de datos, las estructuras lógicas, las
instrucciones de bifurcación, el manejo de excepciones y algunas de las clases incorporadas
en Java. Como se verá en el presente capítulo, las clases son mucho más poderosas que las
presentadas hasta ahora.
Observe la solución del siguiente problema utilizando el método de las 6’D:
Calcular el promedio final de un alumno. Utilice la siguiente fórmula: prom = (nota1 +

nota2 + nota3) / 3. Ingrese las notas nota1, nota2 y nota3 a través del teclado.
Resultado deseado: Mostrar la nota final de un determinado alumno.
Datos necesarios: Las notas del alumno (en esta caso tenemos 3
notas).
Procesamiento: La 3 notas serán ingresadas por teclado y

almacenadas en las variables nota1, nota2, y nota3.
Luego, se realizará el cálculo de la nota final sobre la
base de la siguiente fórmula:
prom = (nota1 + nota2 + nota3) / 3.
El resultado se almacenará en una variable (prom)

para luego ser mostradas por pantalla.
Nombre del Proyecto: ProyAlumno.
Pag. 528
Definición de Paquetes y desarrollo del Diagrama de Paquetes.
Definición de las Clases.
Clases Clases
Diseño del algoritmo para el método principal.
Algoritmo PrgAlumno - método main()
ENTRADA: nota1, nota2, nota3

SALIDA: prom
INICIO
NUMERO nota1, nota2, nota3, prom

LEER nota1, nota2, nota3
prom = ( nota1 + nota2 + nota3) / 3
ESCRIBIR prom
FIN
Pag. 529
Clase PrgAlumno
class PrgAlumno {
double nota1, nota2, nota3, prom ;
System.out.println ( “Ingrese la nota 1 del alumno: ” ) ;

nota1 = Lectura.leerDouble( ) ;


prom = ( nota1 + nota2 + nota3 ) / 3 ;
System.out.println ( “ El promedio obtenido por el alumno es ” + prom ) ;

}
}
En este proyecto ProyAlumno se crea un paquete dominioDeLaAplicación con una clase

PrgAlumno la cual se utiliza en su forma más simple. En la clase PrgAlumno se define un
método main() y dentro del mismo se codifica toda la solución.
Como se ha mencionado, las clases son mucho más poderosas que las presentadas hasta
ahora.
A partir de este punto, se ampliará el conocimiento sobre las clases. Para ello, se revisarán
algunos conceptos básicos y se presentarán, en forma progresiva, nuevos conceptos hasta
llegar al concepto de ocultamiento de atributos de instancia. Todos estos nuevos conceptos
presentados se incorporarán progresivamente en el ejemplo planteado. Al final, se formalizará
el método de solución, el Método de las 6D, para incluir los conceptos presentados.
Pag. 530
Pag. 531
Pag. 532
CONCEPTOS BÁSICOS
CLASE
Una clase es una implantación de un tipo de objeto. Especifica una estructura de datos
(atributos) y los métodos operativos permisibles que se aplican a cada uno de sus objetos. El
mundo real se modela mediante clases. Una clase es una abstracción y no referencia a
ningún objeto en particular. Una clase define un nuevo tipo de objeto.
En Java, una clase se declara utilizando la palabra reservada class. Las clases que se han
utilizado anteriormente son ejemplos muy limitados en los que no aparece su formato general.
El formato general de una clase en Java es el siguiente:
class NombreClase {
// ATRIBUTOS
tipo variableInstancia1 ;
tipo variableInstancia2 ;
// ...
tipo variableInstanciaN ;
// METODOS
tipo nombreMetodo1 (listaDeParámetros) {
// cuerpo del método1.
}
tipo nombreMetodo2 (listaDeParámetros) {

// cuerpo del método2.
}
//...
tipo nombreMetodoN (listaDeParámetros) {

// cuerpo del métodoN.
}
Los datos o variables definidos en una clase se llaman atributos. El código está contenido en
los métodos. En conjunto, los métodos y los atributos definidos dentro de una clase son los
miembros de la clase.
Pag. 533
Los atributos definidos dentro de una clase, permiten que los objetos o instancias de una
clase puedan almacenar datos.
Todos los métodos tienen el mismo formato que el método main() utilizado en los ejemplos
anteriores. Sin embargo, es importante mencionar, que muchos métodos no se especificarán
como public, static o public static.
En el formato general de una clase no se especifica un método main(). Esto debido

fundamentalmente a que todas las clases en Java no necesitan tener un método main(). Solo
necesitarán tener un método main() aquellas clases que tengan como función principal iniciar
la ejecución del proyecto.
En el proyecto de solución ProyAlumno se agregará una clase llamada Alumno. La

declaración de esta clase en Java es la siguiente:
class Alumno {
Ahora, el proyecto de solución ProyAlumno tiene definidas las clases PrgAlumno y

Alumno en el paquete dominioDeLaAplicacion.
Pag. 534
OBJETO
Objetos: Modelos de entes del mundo.
Un objeto de software es cualquier cosa real o abstracta acerca de la cual almacenamos

datos y los métodos que controlan dichos datos.
La definición de un objeto en Java comprende la declaración y la creación del mismo, y se

realiza utilizando la siguiente sentencia:
NombreClase nombreObjeto = new NombreClase ( ) ;
Donde;
• nombreObjeto es el nombre del objeto que se desea crear.
• nombreClase es el nombre de la clase que está siendo instanciada. El nombre de la

clase seguida por los paréntesis especifica el método constructor de la clase. Un
constructor define que ocurre cuando se crea un objeto de una clase. La mayoría
de las clases del mundo real definen explícitamente sus propios constructores
dentro de la definición de la clase. Si no se especifica explícitamente el constructor,
Java automáticamente utiliza un constructor por defecto (es decir, cuando se crea
un objeto no ocurre nada). En el ejemplo, la clase Alumno no define explícitamente
un constructor, es decir se utiliza el constructor por defecto. Más adelante se verá la
forma de definir métodos constructores en una clase.
• new es un operador en Java que permite crear un objeto.
En el proyecto de solución ProyAlumno se utilizará la clase Alumno para definir objetos

de tipo Alumno a través de la siguiente sentencia:
Alumno objAlumno = new Alumno ( ) ;
En dicha sentencia, se define el objeto objAlumno de la clase Alumno. Para definir otros
objetos de la clase Alumno solo se tendría que repetir la sentencia y cambiar el nombre
del objeto.
Es importante recordar que la definición de una clase sólo crea un molde, modelo o patrón a
partir del cual se pueden crear objetos, mientras que la definición de un objeto crea un objeto
real o una instancia de una clase.
Pag. 535
ATRIBUTO
Hasta este punto, se ha creado la clase Alumno sin atributos ni métodos. Ahora, es necesario
conocer algunos conceptos básicas sobre los atributos, para luego definirlos dentro de la
clase Alumno.
Los atributos, en principio, sirven para almacenar valores de los objetos que se instancian a
partir de una clase.
Los atributos se clasifican en dos categorías:
Atributos de Instancia.
Los atributos de instancia conocidos también como atributos de objeto, son
variables, arreglos u objetos que almacenan valores distintos para todos los objetos
de una misma clase.
Atributos de Clase.
Los atributos de clase son variables, areglos u objetos que almacenan el mismo
valor para todos los objetos de una misma clase.
En otras palabras, mientras que a partir de un atributo de instancia se crea una copia
por cada objeto que se instancia, a partir de un atributo de clase sólo se crea una copia
de ese atributo para todos los objetos que se instancien. Si no se especifica lo contrario
los atributos son de instancia y no de clase. Para declarar un atributo de clase se utiliza
la palabra reservada static.
Es decir, cada objeto tendrá sus propios valores para cada atributo de instancia
definido en su clase y existirá para todos los objetos un único valor por cada atributo de
clase definido en su clase.
La forma mínima de un atributo es la siguiente;
tipo nombreAtributo;
Donde :
• tipo especifica el tipo de dato que el atributo almacenará. Puede ser cualquier tipo
válido, incluido los tipos de Clase.
• nombreAtributo especifica el nombre del atributo, que puede ser cualquier

identificador válido diferente a los que se está utilizando en el mismo ámbito.
Pag. 536
En el proyecto de solución ProyAlumno, en la clase Alumno se definirá dos atributos de

instancia llamados nota1 y nota2.
class Alumno {
double nota1 ;
double nota2 ;
}
En la clase Alumno solo se han definido dos atributos, pero todavía no se han definido
método. Se agregarán algunos métodos a la clase Alumno mas adelante.
También, se definirá el objeto objAlumno de la clase Alumno, dentro del método main()
de la clase PrgAlumno, tal y como se especificó anteriormente a través de la siguiente
sentencia:
Cada vez que se define un objeto de una clase, se declara y crea un objeto que
contiene una copia de todos los atributos de instancia definidos para la clase.
En el proyecto de solución ProyAlumno, cada objeto que se defina de la clase Alumno

tendrá su propia copia de los atributos de instancia nota1 y nota2. En consecuencia, el
objeto objAlumno de la clase Alumno tendrá su propia copia de los atributos de
instancia nota1 y nota2 con un valor para cada uno de ellos, distinto al valor de las
copias de los atributos de instancia que otros objetos definidos puedan tener.
Cuando se desea acceder a la copia de los atributos de instancia de un objeto se utiliza

el operador punto (.). El operador punto relaciona el nombre del objeto con el nombre
de un atributo de instancia.
Por ejemplo, si se desea asignar el valor 15 y 19 a los atributos de instancia nota1 y

nota2 del objeto objAlumno, se utilizarían las siguientes sentencias:
objAlumno.nota1 = 15 ;
Estas sentencias permiten asignar a las copias de los atributos de instancia nota1 y
nota2 que están contenidas en el objeto objAlumno los valores 15 y 19
respectivamente.
Si se desea mostrar el valor del atributo de instancia nota1 del objeto objAlumno se
utilizaría la siguiente sentencia:
System.out.println ( “ La nota del alumno es: ” + objAlumno.nota1 ) ;
Pag. 537
Esta sentencia permite que se muestre el mensaje “La nota del alumno es:” y el valor
del atributo nota1 del objeto objAlumno.
En el proyecto de solución ProyAlumno, se necesita calcular y mostrar el promedio del

alumno, para lo cual se utilizarían las siguientes sentencias:
prom = ( objAlumno.nota1 + objAlumno.nota2 ) / 2 ;

System.out.println ( “El promedio final del alumno es: ” + prom ) ;
Estás sentencias permiten obtener el valor de los atributos nota1 y nota2 del objeto
objAlumno para calcular el promedio de las notas y almacenarlo en la variable prom,
para luego mostrar el mensaje “El promedio final del alumno es:” y el valor de la
variable prom calculada.
Según lo mencionado anteriormente, el proyecto de solución ProyAlumno se

desarrollaría de la siguiente manera:
class Alumno {
double nota1 ;
double nota2 ;
}
class PrgAlumno {
public static void main ( String args [ ] ) {
double prom ;
// Primero declaramos y creamos un objeto de la clase Alumno.

// Ahora asignamos valores a las variables de instancia del objeto creado.

// Finalmente, calculamos el promedio de notas del alumno objAlumno.

prom = ( objAlumno.nota1 + objAlumno.nota2 ) / 2 ;
System.out.println ( “ El promedio final del alumno es: ” + prom ) ;
}
}
Es importante recordar que ambas clases pertenecen al paquete

dominioDeLaAplicacion y que el proyecto de solución se denomina ProyAlumno. Al
ejecutar el proyecto, se ejecuta el método main() de la clase PrgAlumno y se obtiene el
siguiente resultado:
El promedio final del alumno es: 17
Pag. 538
Es común que en todo proyecto de solución solo exista un método main( ). Dicho
método main( ) inicia la ejecución del proyecto y está definido en una de las clases que
pertenecen al proyecto.
Ahora, se realizarán algunos cambios en el proyecto de solución ProyAlumno. Se

agregará un atributo de instancia en la definición de la clase Alumno, de tal forma, que
se definan los atributos de instancia nota1, nota2 y nota3. Es importante mencionar que
si existen varios atributos del mismo tipo en una misma clase, se puede separar sus
nombres mediante comas (,) y declararlos con una solo sentencia. Tal y como se
muestra a continuación:
class Alumno {
double nota1, nota2, nota3 ;
}
En base a esto, se modificará el método main() de la clase PrgAlumno para utilizar el

atributo de instancia nota3, de la siguiente manera:
class Alumno {
}
class PrgAlumno {
double prom ;

// Ahora asignamos valores a las variables de instancia del objeto creado.

// Finalmente, calculamos el promedio de notas del alumno objAlumno.

prom = ( objAlumno.nota1 + objAlumno.nota2 + objAlumno.nota3 ) / 3 ;
}
}
Aquí el objeto objAlumno de la clase Alumno creado en el método main( ) de la clase

PrgAlumno tiene su propia copia de los atributos de instancia nota1,nota2 y nota3.
Es importante mencionar que los cambios que se realicen en los atributos de instancia de un
objeto no afectan a los atributos de instancia de los otros objetos ya que cada objeto tiene un
Pag. 539
valor distinto para cada atributo de instancia independiente de los valores que pueden tener
los otros objetos. Esto se puede comprobar fácilmente definiendo más de un objeto en el
proyecto de solución ProyAlumno. Para esto, se definirán dos objetos más denominados
objAlumno02 y objAlumno03 en el método main( ) de la clase PrgAlumno. Luego, se les
asignará valores a cada copia de los atributos de instancia nota1, nota2 y nota3, para
finalmente calcular y mostrar el promedio de las notas de cada uno de los objeto de la clase
Alumno. Según lo mencionado anteriormente, el proyecto de solución ProyAlumno se
desarrollaría de la siguiente manera:
class Alumno {
}
class PrgAlumno {

double prom ;
// Primero declaramos y creamos tres objetos de la clase Alumno.

Alumno objAlumno02 = new Alumno ( ) ;
// Ahora asignamos valores a las variables de instancia del objeto objAlumno.

// También asignamos valores a las variables de instancia del objeto objAlumno02.
objAlumno02.nota1 = 11 ;
// y a las variables de instancia del objeto objAlumno03.
// Calculamos el promedio de notas del objeto objAlumno.

prom = ( objAlumno.nota1 + objAlumno.nota2 + objAlumno.nota3 ) / 3 ;
// También calculamos el promedio de notas del objeto objAlumno02.
prom = ( objAlumno02.nota1 + objAlumno02.nota2 + objAlumno02.nota3 ) / 3 ;
// Finalmente, calculamos el promedio de notas del objeto objAlumno03.
prom = ( objAlumno03.nota1 + objAlumno03.nota2 + objAlumno03.nota3 ) / 3 ;
}
}
Al ejecutar el proyecto (recuerde que cuando se ejecuta un proyecto en realidad se

ejecuta el método main( ) ), se obtiene el siguiente resultado:

Pag. 540
Y se puede comprobar que cada objeto de la clase Alumno tiene una copia de los
atributos de instancia nota1, nota2 y nota3, y que los valores de un objeto son
independientes de los otros valores que tienen los otros objetos.
Pag. 541
MÉTODO
Hasta este punto se ha creado la clase Alumno con tres variables de instancia y sin ningún
método. Ahora es necesario conocer algunas cosas básicas sobre los métodos para luego
poder definirlos dentro de la clase Alumno.
Un método representa un pequeño subprograma encapsulado dentro de una clase y

contribuye a definir el comportamiento típico de los objetos. Los métodos especifican la forma
en que se controlan los datos (atributos) de un objeto. Los métodos definen el
comportamiento de un objeto.
Los métodos se clasifican en dos categorías:
Métodos de Instancia.
Los métodos de instancia, conocidos también como métodos de objeto, son
métodos que pueden ser llamados a través de un objeto instanciado a partir de una
clase. Un método de instancia se ejecuta utilizando el siguiente formato:
nombreObjeto.nombreMétodoInstancia ( ) ;
Métodos de Clase.
Los métodos de clase son métodos que pueden ser llamados también a través de
un objeto instanciado a partir de una clase o utilizando directamente la clase.
Generalmente, para ejecutar un método de clase se utiliza el siguiente formato:
NombreClase.nombreMétodoClase ( ) ;
En otras palabras, mientras que para ejecutar un método de instancia se requiere crear
primero un objeto de la clase donde está definido el método, para ejecutar un método
de clase no se requiere crear un objeto ya que se puede hacer directamente utilizando
el nombre de la clase donde está definido el método. Para declarar un método de clase
se utiliza la palabra reservada static.
A través de métodos de clase se puede manipular solo atributos de clase. Mientras que
a través de métodos de instancia se puede manipular tanto atributos de clase como
atributos de instancia.
La forma mínima de un método es la siguiente;
tipo nombreMétodo ( listaDeParámetros ) {
// Cuerpo del método ;
Pag. 542
Donde :
• tipo especifica el tipo de dato devuelto por el método. Puede ser cualquier tipo
válido, incluido los tipos de clase. Si el método no devuelve ningún valor, el tipo
devuelto debe ser void. Los métodos que devuelven un tipo distinto de void,
devuelven un valor a la sentencia que ejecuta el método utilizando la siguiente
forma de la sentencia return:
return valor ;
Aquí valor es el dato que el método devuelve a la sentencia que lo ejecutó.

Generalmente la sentencia return se coloca al final del cuerpo del método.
• nombreMétodo especifica el nombre del método que puede ser cualquier

identificador válido diferente de los que se están utilizando en el mismo ámbito.
• listaDeParámetros es una secuencia de parejas de tipo e identificador separados

por comas. Los parámetros son variables que reciben el valor de los argumentos
que se pasan al método cuando este es ejecutado. Si el método no tiene
parámetros, entonces la lista de parámetros estará vacía.
Pag. 543
Metodo que no devuelven valor y no reciben parámetros
Talvez se tengan algunos problemas para comprender los conceptos que rodean a los
métodos, poco a poco conforme se modifique el proyecto de solución ProyAlumno se podrán
comprender mejor.
Ahora, se definirá un método dentro de la clase Alumno. El método se llamará

promedio( ), y permitirá calcular y mostrar el promedio de notas de un alumno. Aunque,
anteriormente, esto ya se había realizado en la clase PrgAlumno es perfectamente
válido haber pensado que esto era algo que había que hacer en la clase Alumno y no
en la clase PrgAlumno. Como el promedio de notas depende de las notas, tiene mucho
mas sentido que el cálculo lo realice la clase Alumno a través del método promedio( ),
el cual se desarrolla a continuación:
class Alumno {
void promedio ( ) {
System.out.print ( “ El promedio final del alumno es: ” ) ;
System.out.println ( (nota1 + nota2 + nota3 ) / 3 ) ;
}
}
class PrgAlumno {
double prom ;
// También asignamos valores a las variables de instancia del objeto objAlumno02.
// Calculamos el promedio de notas para cada alumno.
objAlumno.promedio ( ) ;
objAlumno02.promedio ( ) ;
}
}
Pag. 544
Al ejecutar el proyecto se obtiene el siguiente resultado, el cual es igual al resultado

anterior:

Las tres líneas siguientes, ubicadas dentro del método main( ) de la clase PrgAlumno,
permiten ejecutar el método promedio( ) definido en la clase Alumno:
Al igual que para acceder a las variables de instancia, para acceder a los métodos se utiliza el
operador punto (.). El operador punto relaciona el nombre del objeto con el nombre de un
método.
Analicemos la siguiente sentencia;
Esta sentencia es parte del método main( ) de la clase PrgAlumno y permite que se
ejecute el método promedio( ) del objeto objAlumno definido en la clase Alumno. Es
decir; se ejecuta el método promedio( ) utilizando el nombre de un objeto de la clase
Alumno seguido por el operador punto. Así, cuando se ejecuta;
• objAlumno.promedio ( ) ; Se calcula y visualiza el promedio de notas del objeto

objAlumno en base a los valores de su copia de los atributos
de instancia ( nota1 = 15, nota2 = 19 y nota3 = 11 ).
• objAlumno02.promedio ( ) ; Se calcula y visualiza el promedio de notas del objeto

objAlumno02 en base a los valores de su copia de los
atributos de instancia ( nota1 = 11, nota2 = 11 y nota3 = 11 ).
• objAlumno03.promedio ( ) ; Se calcula y visualiza el promedio de notas del objeto

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

esto no constituye la mejor forma o alternativa de desarrollar dicho método. Esto se debe, a
que en mucho casos, otras partes del método main( ) u otros métodos necesitarán que se
ejecute el método promedio( ) para que se realice el cálculo del promedio de notas, pero no
todos necesitarán que una vez calculado el promedio de notas este se visualice. Con la
finalidad de mejorar la implementación del método promedio( ), se puede realizar solo el
cálculo del promedio de notas y devolver dicho valor para que este pueda ser utilizado de
diferente forma.
A continuación se modificará el proyecto de solución ProyAlumno con la finalidad de

mejorar la implementación del método promedio( ):
class Alumno {
double promedio ( ) {
return ( nota1 + nota2 + nota3 ) / 3 ;
}
}
class PrgAlumno {
double prom ;


// También asignamos valores a las variables de instancia del objeto objAlumno02



prom = objAlumno.promedio ( ) ;
System.out.println ( “ La nota final de Luis es ” + prom + “.” ) ;
Pag. 547
prom = objAlumno02.promedio ( ) ;
prom = prom + 1 ;
System.out.println ( “ La nota final de María es ” + prom + “.” ) ;
System.out.println ( “ La nota final de Pedro es ” + objAlumno03.promedio ( ) + “.” ) ;

}
}
Para ejecutar, un método que devuelve un valor, se utiliza también el nombre del objeto, el
operador punto (.) y el nombre del método, pero debido a que el método devuelve un valor,
éste deberá ser asignado a una variable del mismo tipo que el valor devuelto por el método.
En el ejemplo tenemos la siguiente sentencia:
Esta sentencia es parte del método main( ) de la clase PrgAlumno y permite que se
ejecute el método promedio( ) del objeto objAlumno definido en la clase Alumno. Como
el método promedio( ) devuelve un valor, entonces el valor devuelto será almacenado
en la variable prom. Observe que la variable prom es del mismo tipo que el valor
devuelto por el método promedio( ).
Sentencia definida en el método Método definido en la clase Alumno.

main( ) de la clase PrgAlumno.
}
Una vez que prom ya tiene el valor devuelto por el método promedio( ) se puede
procesar dicho valor según sea necesario. En el primer caso, se muestra el valor de
prom, y en el segundo caso, antes de mostrar el valor de prom se le suma 1.
Pag. 548
Se obtiene el promedio de
notas y se muestra el
resultado:
Se obtiene el promedio de
notas, se aumenta 1 y se
muestra el resultado:
prom = prom + 1 ;
Es preciso mencionar, que se puede escribir estas sentencias de una manera más
eficiente. Observe la siguiente sentencia:
System.out.println ( “ La nota final de Pedro es ” + objAlumno03.promedio ( ) + “.” ) ;
Aquí no se hace uso de la variable prom. La ejecución del método promedio( ) se

realiza directamente en la sentencia println(). Es decir, al ejecutar println( ), se ejecuta a
su vez el método objAlumno3.promedio( ) y el valor devuelto se muestra a través de la
pantalla.
Existen dos puntos importantes relacionados con los métodos que devuelven valor:
1. El tipo de dato que un método devuelve (con la sentencia return), debe ser
compatible con el tipo de dato especificado por el método.
Especifica que se
debe devolver un No tiene
valor double. parámetros.
return (nota1 + nota2 + nota3 ) / 3 ;
}
2. La variable que recibe el valor devuelto por el método debe también ser
compatible con el tipo de dato especificado por el método.
Declarada como double. Lo cual es compatible con el

tipo de dato especificado por el método.
Pag. 549
Métodos que no devuelven valor y reciben parámetros
Ahora, se definirá un segundo método dentro de la clase Alumno. El método se llamará

setNotas( ) y permitirá asignar valores a las variables de instancia nota1, nota2 y
nota3. Esto debido, fundamentalmente, a que en problemas Java bien diseñados las
variables de instancia deberían ser accesibles sólo a través de los métodos definidos
por sus clases y no en forma directa.
El método setNotas( ) recibirá, a través de sus parámetros, las notas de un alumno y

las asignará a los atributos de instancia. Los parámetros generalizan el uso de un
método permitiendo trabajar con diversos datos y utilizarlo en diferentes situaciones.
class Alumno {
}
void setNotas ( double a, double b, double c ) {

nota1 = a ;
nota2 = b ;
nota3 = c ;
}
}
class PrgAlumno {
double prom ;

// Ahora asignamos valores a los atributos de instancia del objeto objAlumno.

objAlumno.setNotas ( 15,19,11 ) ;
// También asignamos valores a los atributos de instancia del objeto objAlumno02.

objAlumno02.setNotas ( 11,11,11 ) ;
// y a los atributos de instancia del objeto objAlumno03.

objAlumno03.setNotas ( 13,14,15 ) ;

Pag. 550
prom = prom + 1 ;
System.out.println ( “ La nota final de Pedro es ” + objAlumno03.promedio() + “.” );

}
}
Para ejecutar un método que tiene parámetros se utiliza el nombre del objeto, el
operado punto(.), el nombre del método a ejecutar y los argumentos necesarios.
En el ejemplo anterior tenemos:
Esta sentencia es parte del método main( ) de la clase PrgAlumno( ) y permite ejecutar
el método setNotas( ) del objeto objAlumno definido en la clase Alumno. Como el
método setNotas( ) tiene definido 3 parámetros es necesario que al momento de
ejecutar el método se incluya entre los paréntesis los 3 argumentos que se van ha
enviar al método.
Sentencia definida en el método Método definido en la clase Alumno.

main() de la clase PrgAlumno.
a = 15
objAlumno.setNotas (15,19,11 ) ;

nota1 = a ;
nota2 = b ;
nota3 = c ;
}
3 ARGUMENTOS 3 PARÁMETROS
Un argumento es un valor que se Un parámetro es una variable

envía a un método cuando este definida por un método, que
es ejecutado. recibe un valor cuando se ejecuta
dicho método.
Pag. 551
Existen dos puntos importantes relacionados con los métodos que tienen parámetros:
1. Un método que tiene parámetros debe recibir un valor por cada parámetro definido.
El valor recibido debe ser compatible con el tipo de dato definido por el parámetro al
cual será asignado:
No devuelve Especifica que se tiene definido

valor. 3 parámetros de tipo double.

nota1 = a ;
nota2 = b ;
nota3 = c ;
}
2. Cuando se ejecuta un método que tiene parámetros, se debe pasar al método un

valor por cada parámetro definido (es decir, se deben pasar los argumentos). Cada
argumento deberá ser compatible con el tipo de dato definido por el parámetro al
cual será asignado:
Especifica que se envían 3 valores

(argumentos) de tipo double al método
setNotas ( ).
objAlumno.setNotas(15,19,11);
Pag. 552
En conclusión, se puede afirmar lo siguiente:
1. Un método puede; no devolver valor y no tener definido parámetros.
No devuelve No tiene
valor. parámetros.
void promedio ( ) {
System.out.println ( ( nota1 + nota2 + nota3 ) / 3 ) ;
}
2. Un método puede; no devolver un valor y tener definido uno o más parámetros.
No devuelve Especifica que se tiene definido

valor. 3 parámetros de tipo double.

nota1 = a ;
nota2 = b ;
nota3 = c ;
}
3. Un método puede; devolver un valor y no tener definido parámetros.
Especifica que se
debe devolver un No tiene
valor double. parámetros.
return (nota1 + nota2 + nota3 ) / 3 ;
}
4. Un método puede; devolver un valor y tener definido uno o más parámetros. (Este
tipo de métodos no han sido tratados en el presente capítulo).
Pag. 553
Método constructor
En Java, la inicialización de objetos no se puede realizar en el momento en que estos son

definidos; Por lo cual, se tiene la característica de disponer de un método que permite
inicializar objetos inmediatamente después que se crean. Este método es conocido como el
método constructor.
Un constructor es un método especial que sirve para construir o inicializar objetos. Cada vez
que se crea un objeto se ejecuta en forma automática el método constructor. El método
constructor permite que se inicialicen la copia de los atributos de instancia de los objetos
inmediatamente después de su creación. El método constructor tiene el mismo nombre que la
clase en la cual está definido. Los métodos constructores pueden tener parámetros al igual
que otros métodos, pero no devuelven ningún valor, ni siguiera void.
Se modificará el proyecto de solución ProyAlumno, de tal forma que se defina solo el

objeto objAlumno de la clase Alumno en el método main() de la clase PrgAlumno (esto
con la finalidad de implementar nuevos conceptos en un proyecto de solución sencillo y
pequeño), y se incluirá un método constructor en la clase Alumno que permita inicializar
la copia de los atributos de instancia nota1, nota2 y nota3 para el objeto objAlumno:
class Alumno {
Alumno ( ) {
nota1 = 0 ;
nota2 = 0 ;
nota3 = 0 ;
}
}

nota1 = a ;
nota2 = b ;
nota3 = c ;
}
}
class PrgAlumno {

double prom ;
// Ahora asignamos valores a la copia de las variables de instancia del objeto creado.
// Calculamos y mostramos el promedio de notas.

}
}
Pag. 554
Cuando se ejecuta la siguiente sentencia:
Alumno objAlumno = new Alumno();
Se declara y crea el objeto objAlumno de la clase Alumno. Después que se crea el

objeto objAlumno se ejecuta en forma automática al método constructor Alumno( ). El
método constructor Alumno( ) permite inicializar la copia de los atributos de instancia
nota1, nota2 y nota3 del objeto objAlumno con el valor cero.
El método constructor puede tener definido parámetros. En ese caso, podemos enviar al
método constructor Alumno( ), los valores de la copia de los atributos de instancia nota1,
nota2 y nota3 del objeto creado y eliminar el método setNotas( ). Aunque esto es posible y
perfectamente válido, no se eliminará el método setNotas( ). El método constructor Alumno( )
se encargará de inicializar con el valor cero, a todas las copias de los atributos de instancia
de los objetos que se creen, mientras que el método setNotas( ) se encargará de modificar los
valores de las copias de los atributos de instancia de los objetos cuando esto sea necesario.
(Recuerde que el método constructor solo se ejecutará en forma automática inmediatamente
después de crear un objeto y si se requiere cambiar el valor de una copia de los atributos de
instancia del objeto después de haberlo creado, deberá realizarlo empleando otro método.
Para nuestro caso, dicho método es setNotas( ) ).
Pag. 555
OCULTAR ATRIBUTOS DE INSTANCIA
En Java, no es correcto que dos variables que están dentro del mismo ámbito tengan el
mismo nombre. Es decir, dos variables locales declaradas dentro del mismo método o dos
atributos, no pueden tener nombres iguales. Sin embargo, una variable local (declarada
dentro de un método) puede tener el mismo nombre que un atributo. Cuando una variable
local tiene el mismo nombre que un atributo, la variable local oculta al atributo.
Observe la codificación de la clase Alumno:
class Alumno {
Alumno ( ) {
nota1 = 0 ;
nota2 = 0 ;
nota3 = 0 ;
}
}

nota1 = a ;
nota2 = b ;
nota3 = c ;
}
}
Dentro del método setNotas( ), se han declarado 3 variables locales (parámetros) para
recibir las notas cuando se ejecute el método. Dichas variables locales fueron
declaradas con los nombres a, b y c, que no tienen ningún significado especial, ya que
dichos nombres de variables no reflejan el valor que almacenan. Estás variables locales
no fueron declaradas con los nombres nota1, nota2 y nota3 debido a que dichos
nombres ya eran utilizados por los atributos de instancia.
Si analiza la implementación del método setNotas( ) podrá observar que en dicho

método se utilizan las variables locales a, b y c, y también se utilizan los atributos de
instancia nota1, nota2 y nota3. Si se hubieran declarado las variables locales con los
nombres nota1, nota2 y nota3, no se podrían utilizar los atributos de instancia ya que
siempre que se utilicen los nombres nota1, nota2 y nota3, se asumiría que se hace
referencia a las variables locales y no a los atributos de instancia (ya que ambos
tendrían el mismo nombre). Cuando sucede esto, se dice que las variables locales
ocultan a los atributos de instancia.
Utilizando el operador this es posible nombrar a las variables locales igual que los atributos de
instancia. Para esto, cada vez que necesite referirse a las variables locales se utilizará el
Pag. 556
nombre de la variable local y cada vez que necesite referirse a los atributos de instancia se
utilizará el operador this seguido del operador punto (.) y el nombre del atributo.
Cuando se utiliza el operador this se indica que se está refiriendo al atributo de instancia y no
a una variable local.
Forma general del operador this:
this.nombreAtributoInstancia ;
Analizar la variación en la codificación de la clase Alumno:
class Alumno {
Alumno ( ) {
nota1 = 0 ;
nota2 = 0 ;
nota3 = 0 ;
}
}
void setNotas ( double nota1, double nota2, double nota3 ) {

this.nota1 = nota1 ;
}
}
Ahora, en el método setNotas( ), se utilizan los mismos nombres para las variables locales
(declarados como parámetros) y para los atributos de instancia. Al momento de referirnos a
los atributos de instancia anteponemos al nombre del mismo el operador this y el operador
punto (.)
Nos referimos al atributo

de instancia nota1.
This.nota1 = nota1;
Nos referimos a la variable

local nota1.
Pag. 557
Algunos programadores procurar no utilizar variables locales que oculten los atributos de
instancia. Por otro lado, otros programadores piensan que es una buena práctica utilizar los
mismos nombres por claridad y utilizar el operador this para referirse a los atributos de
instancia. A partir de ahora, se utilizará el operador this como una buena práctica de
programación.
Pag. 558
INGRESO DE DATOS A TRAVÉS DEL TECLADO
Ahora, se modificará el proyecto de solución ProyAlumno, de tal forma que los datos
sean ingresados a través del teclado de la computadora. Para ello, se utilizará la clase
Lectura presentada en capítulos anteriores. La clase Lectura pertenece al paquete
biblioteca:
class Alumno {
Alumno ( ) {
nota1 = 0 ;
nota2 = 0 ;
nota3 = 0 ;
}
return ( nota1 + nota2+nota3 ) / 3 ;
}
void setNotas ( double noat1, double nota2, double nota3 ) {

}
}
class PrgAlumno {

double n1, n2, n3, prom ;
// Ingresamos las notas.

System.out.println ( “ Ingrese la nota de prácticas del alumno: ” ) ;
System.out.println ( “ Ingrese la nota de examen final: ” ) ;
// Ahora enviamos las notas a la copia de los atributos de instancia del objeto.
objAlumno.setNotas ( n1,n2,n3 ) ;
}
}
package biblioteca ;
public class Lectura {
// Cuerpo de la clase Lectura definida en capítulos anteriores.

}
Pag. 559
Ahora, el proyecto de solución ProyAlumno tiene dos paquetes. Un paquete

denominado biblioteca que contiene a la clase Lectura y un paquete denominado
dominioDeLaAplicacion que contiene las clases PrgAlumno y Alumno.
Cada clase tiene funciones específicas que se detallan a continuación.
Clase PrgAlumno: Tiene el método main( ) que permite que el proyecto se

ejecute. Dentro del método main( ), se crea al objeto
objAlumno de la clase Alumno, se ingresan las notas
del alumno y se muestra el promedio.
Clase Alumno: Define los atributos de instancia para almacenar las

notas y los métodos que permiten manipular dichos
atributos de instancia. Uno de los métodos realiza el
cálculo del promedio.
Clase Lectura: Define métodos que facilitan el ingreso de datos

utilizando el teclado.
Pag. 560
MÉTODO DE LAS 6’D: Etapas y pasos
El proyecto de solución ProyAlumno, se ha modificado poco a poco con la finalidad de tratar

nuevos conceptos relacionados a la POO utilizando Java. Con la última solución desarrollada
para el proyecto ProyAlumno, se pretende dar un paso importante para acercarnos al
desarrollo de soluciones orientadas a objetos.
Es un buen momento para ajustar los pasos definidos en las etapas del método de las 6’D y
poder desarrollar un proyecto que permitan al lector familiarizarse con este tipo de soluciones.
Ajuste de los pasos definidos para las etapas del método
En la solución del problema anterior, se utilizó dos paquetes. Los mayores cambios los
desarrollamos en las 2 clases del paquete dominioDeLaAplicacion. En una clase se
desarrollará el método main( ) y se definirán objetos de la otra clase, mientras que en la otra
clase se definirán los atributos de instancia, métodos de instancia y método constructor válido
para los objetos.
En base a esto, el método de solución queda definido según se muestra a continuación:
ENUNCIADO
DEL
PROBLEMA
Etapa 02 Etapa 03 Etapa 04
Definición Diseño Desarrollo

Solución Solución Solución
• Definición del proyecto de • Diseño del diagrama de • Codificar el diseño de

solución. paquetes respectivo. la solución del
• Definición del algoritmo. Establecer la dependencia. problema utilizando el
• Definición del paquete (Utilice UML). lenguaje de
Aplicación. • Diseño de las clases que programación Java.
o Definición de clases serán parte del paquete
con sus atributos y Aplicación. (Utilice UML).
métodos.
• Definición del paquete
biblioteca.
o Uso de la clase
Lectura con sus • Diseño del algoritmo para
métodos definidos. los método definidos. Utilizar
pseudocódigo.
Pag. 561
Pag. 562
Con el propósito de describir los pasos definidos de las etapas del método 6’D, se volverá a
solucionar el problema anterior.
PROBLEMA 151
Calcular el promedio final de un alumno. Utilice la siguiente fórmula: prom = ( nota1 +

nota2 + nota3 ) / 3. Ingrese las notas nota1, nota2 y nota3 a través del teclado.
1. Definición del proyecto de solución.
Para solucionar el problema se creará un proyecto denominado ProyAlumno, dentro

del cual se definirá el paquete dominioDeLaAplicacion y se incluirá el paquete
biblioteca (el cual incluye la clase Lectura).
2. Definición del algoritmo.
Resultado deseado: Mostrar la nota final de un determinado alumno.
Datos necesarios: Las notas del alumno (en esta caso tenemos 3
notas).
Procesamiento: La 3 notas serán ingresadas por teclado y

almacenadas en las variables nota1, nota2, y nota3.
Luego, se realizará el cálculo de la nota final sobre la
base de la siguiente fórmula:
prom = ( nota1 + nota2 + nota3 ) / 3.
El resultado se almacenará en una variable (prom)
para luego ser mostradas por pantalla.
3. Definición del paquete Aplicación.
En el paquete dominioDeLaAplicacion definiremos dos clases.
La función de la primera clase será de procesamiento y almacenamiento de datos.

Como buena práctica de programación, en los métodos de esta clase, no se
realizará ingreso de datos, ni se mostrarán mensajes de ningún tipo. Pero, si se
utilizarán los mismos nombres para referirnos a variables locales y a los atributos
Pag. 563
de instancia. Por otro lado, solo podrán ser definidos como atributos de instancia
los datos de entrada.
Su definición será la siguiente:
Clase: Alumno.
Atributos: Como atributos de instancia definiremos las variables

de entrada nota1, nota2 y nota3.
Métodos: Necesitamos los siguientes métodos:
Método constructor para inicializar los atributos

de instancia (método Alumno()).
Método para modificar los valores de las notas

(método setNotas(), recibe los valores de las
notas ).
Método para calcular el promedio de las notas

(método promedio(), devuelve el valor del cálculo
del promedio de las notas).
La función de la segunda clase será el ingreso de los datos y mostrar los resultados
esperados. Como buena práctica de programación, en los métodos de esta clase,
no se realizará ningún tipo de cálculo y solo podrán ser definidos como atributos de
instancia objetos de la otra clase (para este caso, la clase Alumno).
Su definición será la siguiente:
Clase: PrgAlumno.
Atributos: Como atributos de instancia definiremos al objeto

objAlumno de la clase Alumno.
Métodos: Utilizamos el método main( ) para iniciar la ejecución

del proyecto, la creación del objeto objAlumno, el
ingreso de los datos y mostrar los resultados
esperados.
4. Definición del paquete biblioteca.
En el paquete biblioteca se tendrá la clase Lectura para poder utilizar sus métodos.
Pag. 564
Etapa 03 – Diseño de la lógica.
Diseño del Diagrama de Paquetes.
Diseño de las clases.
Clase de
Clases de dominioDeLaAplicacion
biblioteca
PrgAlumno Alumno Lectura
nota1 : double
nota2 : double leerString( ) : String
nota3 : double leerChar( ) : char
leerInt( ) : int
main( ) Alumno( ) leerLong( ) : long
setNotas(double, double, double) : void leerFloat( ) : float
promedio( ) : double leerDouble( ) : double
Diseño de algoritmos.
Algoritmo PrgAlumno
METODO MAIN( )
ENTRADA: n1, n2, n3

SALIDA: 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: nota1, nota2, nota3

RETORNO:
INICIO
ATRIBUTO.nota1 = nota1
FIN
METODO PROMEDIO
PARAMETRO:
RETORNO: prom
INICIO
NUMERO prom
prom = ( nota1 + nota2 +nota3 ) / 3
RETORNAR prom
FIN
Observe que en esta Etapa – Diseño de la lógica, se ha utilizado nuevas reglas

de pseudocódigo las cuales describimos a continuación:
CREAR OBJETO
Se utiliza para indicar la creación de un determinado objeto. El formato

completo se muestra a continuación a través de un ejemplo:
CREAR OBJETO objAlumno CLASE Alumno EJECUTA Alumno ( )
A través de esta instrucción se crea un objeto denominado objAlumno de

la clase Alumno y se ejecuta el método constructor especificado.
Pag. 566
EJECUTAR
Se utiliza para ejecutar un método. Hay que tener presente que si el método
es de clase se deberá anteponer el operador punto (.) y el nombre de la
clase antes de colocar el nombre del método que se desea ejecutar. Si el
método es de instancia se deberá anteponer el operador punto (.) y el
nombre del objeto antes de colocar el nombre del método que se desea
ejecutar.
EJECUTAR objAlumno.setNotas ( n1,n2,n3 )
Se ejecuta el método setNotas() del objeto objAlumno, y se le envían los

valores de la variables n1, n2 y n3.
prom = EJECUTAR objAlumno.promedio ( )
Se ejecuta el método promedio del objeto objAlumno. El método promedio

devuelve un resultado, el cual se almacena en la variable prom.
PARAMETRO
Se utiliza para especificar las variables que utilizamos para recibir los valores
enviados a un determinado método.
PARAMETRO: nota1, nota2, nota3
Se especifica que se utilizan las variables nota1, nota2 y nota3 para recibir
los valores que se envían al método al cual pertenece la instrucción.
RETORNO
Se utiliza para especificar la variable que utilizaremos para devolver o

retornar una respuesta de un determinado método.
RETORNO: prom
Se especifica que el valor almacenado en la variable prom será devuelto

como respuesta cuando se ejecuta el método al cual pertenece la
instrucción.
ATRIBUTO
Se utiliza para diferenciar un atributo de una variable local cuando ambos

tienen el mismo nombre y se utilizan en un mismo método.
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
Clase PrgAlumno
class PrgAlumno {

double n1, n2, n3, prom ;
// Ingresamos las notas.

System.out.println ( “ Ingrese la nota de prácticas del alumno: ” ) ;
System.out.println ( “ Ingrese la nota de examen final: ” ) ;
// Enviamos las notas a la copia de los atributos de instancia del objeto.

objAlumno.setNotas ( n1,n2,n3 ) ;
}
}
Clase Alumno
class Alumno {
Alumno ( ) {
nota1 = 0 ;
nota2 = 0 ;
nota3 = 0 ;
}
}
void setNotas ( double nota1, double nota2, double nota3 ) {

}
}
Pag. 568
OTROS CONCEPTOS
Finalmente, es importante mencionar, que deberá continuar investigando otros conceptos

importantes de la Programación Orientada a Objetos, tales como; Encapsulamieno, Herencia,
Polimorfismo, Interfaces Gráficas, Conexiones a BD, Servlets, entre otros. Dichos conceptos
avanzados permitirán elaborar soluciones robustas y profesionales, para luego poder iniciar
con una base adecuada su investigación en el desarrollo de soluciones J2EE (Java 2
Enterprise Edition) basadas en tecnología Internet.
Pag. 569
Pag. 570
APÉNDICE
APÉNDICE
Problemas propuestos
ENUNCIADO DE PROBLEMAS RESUELTOS
1. Desarrollar una solución que permita mostrar un mensaje por la pantalla. El

mensaje a mostrar será “Hola bienvenidos mi nombre es Danae”.
2. Desarrollar una solución que permita mostrar el nombre, apellido y el promedio

del alumno Julio César Arias Pimentel que ha obtenido las siguientes notas:
nota1=11, nota2=13 y nota3=15. Utilizar la siguiente fórmula:
Promedio: nf = (nota1 + nota2 + nota3) / 3.
3. Desarrollar una solución que permita mostrar el resultado de sumar, multiplicar,

restar y dividir los números 124 y 35.
4. Desarrollar una solución que permita ingresar el nombre de dos personas y

luego mostrar los nombres junto con un mensaje de bienvenida.
5. Desarrollar una solución que permita leer el costo de un artículo y su precio de

venta. Calcular y mostrar su utilidad.
6. Desarrollar una solución que permita ingresar el precio de un artículo y mostrar

el precio total a pagar incluyendo el IGV respectivo (Impuesto General a las
Ventas = 19%).
7. Desarrollar una solución que permita ingresar el precio de un artículo y su

respectivo descuento (expresado en %). Mostrar el precio total a pagar
incluyendo el IGV (Impuesto General a las Ventas = 19%).
Pag. 573
APÉNDICE
8. Desarrollar una solución que permita ingresar el lado de un cuadrado. Calcular

y mostrar el área del cuadrado.
9. Desarrollar una solución que permita calcular y mostrar el área de un triángulo

rectángulo. Ingresar la base y la altura del triángulo rectángulo.
10. Desarrollar una solución que permita calcular y mostrar el perímetro y el área
de un círculo. Ingresar el radio del círculo.
11. Desarrollar una solución que permita calcular y visualizar el perímetro y el área
de un rectángulo. Ingresar la base y la altura del rectángulo.
12. Desarrollar una solución que permita calcular el área de un triángulo en función
de las longitudes de sus lados. Mostrar el resultado obtenido.
¾ Area = ((p*(p - a)*(p - b)*(p - c)) RAIZ 2.
¾ Semiperímetro p = (a +b + c) / 2.
13. Desarrollar una solución que permita convertir y mostrar una cantidad de
dinero, expresado en dólares, en su equivalente en nuevos soles. Ingresar la
cantidad en dólares y el tipo de cambio.
14. Desarrollar una solución que permita convertir y mostrar una cantidad de soles
a Dólares y a Euros. Considerar como tipo de cambio; 1 Dólar = 3.352 soles, y
1 Dólar = 1.09 Euros.
15. Desarrollar una solución que permita leer un número y calcular el resto de
dividir el número entre 3. Mostrar el resto de la división.
Pag. 574
APÉNDICE
16. Desarrollar una solución que permita ingresar 2 números a través del teclado.
Calcular la suma, resta, multiplicación y división de dichos números. Mostrar el
resultado de las operaciones.
17. Desarrollar una solución que permita ingresar 2 números a través del teclado.
Calcular la suma, resta, multiplicación y división de dichos números.
Adicionalmente, calcular la potencia de 5 y la raíz cuadrada de cada uno de los
números ingresados. Mostrar el resultado de todas las operaciones.
18. Desarrollar una solución que permita ingresar las notas de un determinado
alumno y visualizar su promedio final. El promedio final se obtiene de la
siguiente fórmula: PF = (PL + EP + EF*2)/4. Donde PL = Promedio de
Laboratorio. EP = Examen Parcial y EF = Examen Final.
19. Desarrollar una solución que permita calcular la nota final que ha obtenido un
alumno en el curso de laboratorio de Programación Avanzada. Utilizar la
siguiente fórmula: nf = (n1 + n2 + n3 + (n4 * 2)) / 5. Ingresar las notas n1, n2,
n3 y n4 a través del teclado.
20. Desarrollar una solución que permita calcular la nota final que ha obtenido un
alumno en el curso de Algoritmo y Estructura de Datos, sabiendo que se
elimina la menor nota y se duplica la mayor nota. Ingresar las notas n1, n2, n3
y n4 a través del teclado.
21. Desarrollar una solución que permita ingresar la hora de ingreso y la hora de
salida de un obrero en la empresa que labora. Calcular el tiempo que
permaneció en la empresa. Ingresar la hora y los minutos de entrada y de
salida.
22. Desarrollar una solución que permita ingresar el sueldo de un obrero. Calcular
el aumento de sueldo del obrero por concepto de escolaridad (17%). Mostrar el
sueldo a cobrar.
Pag. 575
APÉNDICE
23. Desarrollar una solución que permita ingresar el sueldo de un obrero de la

empresa “La Poderosa S.A.”. Calcular su respectivo descuento del 14% por
concepto de impuestos y el 3% por concepto de cafetería. Mostrar el total de
descuentos y el sueldo a cobrar.
24. Desarrollar una solución que permita ingresar una cantidad expresada en
metros, y visualizar su equivalente en pulgadas y en pies (1 metro = 39.37
pulgadas, 1 pie = 12 pulgadas).
25. Desarrollar una solución que permita convertir una cantidad expresada en
metros a sus equivalentes en centímetros, pulgadas, pies y yardas. Considerar
la siguiente información:
¾ 1 metro = 100 cm.
¾ 1 pulgada = 2.54 cm.
¾ 1 pie = 12 pulgadas.
¾ 1 yarda = 3 pies.
26. Desarrollar una solución que permita calcular y visualizar la distancia que
existe entre dos puntos dados. Cada uno de los puntos está expresado en
coordenadas y éstos deben ser ingresados por el usuario: P1(x1, y1), P2(x2,
y2). La distancia entre los dos puntos se calcula a partir de la siguiente fórmula:
Distancia = ((x1-x2) **2 + (y1-y2) ** 2) RAIZ 2.
27. Desarrollar una solución que permita calcular el perímetro de un triángulo

dadas las coordenadas de los puntos P1, P2 y P3, los cuales corresponden a
los vértices de un triángulo. Utilizar la fórmula del problema anterior para
determinar la distancia entre cada uno de los puntos.
28. Desarrollar una solución que permita ingresar 2 números enteros positivos de
dos cifras. Intercambie las unidades de los dos números.
29. Desarrollar una solución que permita ingresar un número de 4 cifras.

Determinar la suma de las cifras del número ingresado.
Pag. 576
APÉNDICE
30. Desarrollar una solución que permita determinar si un número ingresado por
teclado es capicúa o no. Un número es capicúa si se lee igual de derecha a
izquierda o viceversa. (Ejemplo de número capicúa 4554).
31. Desarrollar una solución que permita invertir un número de cuatro dígitos. El
número deberá ser ingresado por teclado. (Ejemplo: se ingresa el número 3579
se debe visualizar el 9753).
32. Desarrollar una solución que permita convertir una temperatura expresada en
grados Celsius a su equivalente en grados Fahrenheit. Utilizar la siguiente
fórmula: F = (9 / 5) * C + 32.
33. Desarrollar una solución que permita calcular y visualizar el número de

segundos que hay en un determinado número de días.
34. Desarrollar una solución que permita ingresar una cantidad entera de dinero.
Mostrar el número de billetes de S/ 100, S/ 50, S/ 20, S/ 10, S/ 5 y S/ 1, que
existen en la cantidad de dinero ingresada..
35. Desarrollar una solución que permita realizar el cálculo del pago mensual del
sueldo de un empleado de una empresa. Dicho cálculo se realiza de la
siguientes manera: el sueldo básico se calcula en base al número total de
horas trabajadas basada en una tarifa horaria. Al sueldo básico se le aplica una
bonificación del 35% obteniéndose el sueldo bruto. Al sueldo bruto se le aplica
un descuento del 12% obteniéndose el sueldo neto. Mostrar el sueldo básico,
el sueldo bruto y el sueldo neto de un trabajador.
36. Desarrollar una solución que permita calcula el sueldo neto de un vendedor.
Dicho cálculo se realiza en base a un sueldo básico equivalente a S/ 465.00
nuevos soles, más una comisión del 18% por cada venta que el vendedor
realice. Mostrar el sueldo neto del vendedor sabiendo que hizo 5 ventas en el
mes.
Pag. 577
APÉNDICE
37. Desarrollar una solución que permita calcular el porcentaje de hombres y el

porcentaje de mujeres que están matriculados en un determinado curso.
38. Desarrollar una solución que permita leer la capacidad de un disco duro en
Gigabytes. Mostrar el equivalente en Megabytes, Kilobytes y Bytes.
¾ 1 Kilobyte= 1024 Bytes.
¾ 1 Megabyte= 1024 Kilobytes.
¾ 1 Gigabyte= 1024 Megabytes.
39. Desarrollar una solución que permita determinar con qué velocidad inicial partió
un automóvil de un determinado punto y qué distancia, conociendo su
velocidad final, su aceleración y el tiempo empleado en el recorrido. Considerar
las siguientes fórmulas:
2
e = Vot + at
Vf = Vo + at. donde:
Vf = Velocidad final.
Vo = Velocidad Inicial.
a = Aceleración.
e = Espacio recorrido.
t = Tiempo empleado en el recorrido.
40. Desarrollar una solución que permita determinar si una persona es o no mayor
de edad. Ingresar el nombre, apellidos, código y edad de la persona.
41. Desarrollar una solución que permita calcular y mostrar el área de un cuadrado.
Si el área del cuadrado resulta menor que 768, se deberá visualizar el mensaje
“Cuadrado pequeño”.
42. Desarrollar una solución que permita determinar cómo se clasifica un ángulo
ingresado por teclado. Los ángulos se clasifican de la siguiente manera:
¾ Ángulo = 0 Nulo.
¾ 0 < ángulo > 90 Agudo.
Pag. 578
APÉNDICE
¾ Ángulo = 90 Recto.
¾ 90 < ángulo > 180 Obtuso.
¾ Ángulo = 180 Llano.
¾ 180 < ángulo > 360 Cóncavo.
¾ Ángulo = 360 Completo.
43. Desarrollar una solución que permita calcular y mostrar la nota final (nf) de un
alumno, sabiendo que se tienen sólo dos notas. Si el alumno obtiene una nota
final mayor a 17 se deberá visualizar un mensaje de felicitaciones.
44. Desarrollar una solución que permita ingresar los votos obtenidos por cada
candidato en una elección democrática. Determinar la votación promedio y
mostrar los códigos de los candidatos que obtuvieron una votación inferior a la
votación promedio. Considerar que han participado 5 candidatos cuyos códigos
son ‘A’, ‘B’, ‘C’, ‘D’ y ‘E’.
45. Desarrollar una solución que permita calcular y mostrar el sueldo de un

trabajador conociendo el número de horas trabajadas y su tarifa horaria,
sabiendo que se debe descontar un 10% del sueldo por concepto de impuestos
si éste es mayor de S/. 3000.00.
46. Desarrollar una solución que permita calcular el sueldo de un trabajador

conociendo el número de horas trabajadas y su tarifa horaria, sabiendo que se
debe descontar un 12% del sueldo por concepto de impuestos si éste es mayor
de S/. 1860.00. Mostrar el sueldo y el descuento respectivo.
47. Desarrollar una solución que permita determinar el sueldo neto, el sueldo bruto
y el descuento de un trabajador de una empresa. La empresa paga a sus
vendedores por horas trabajadas. Hasta 40 horas trabajadas se paga una tarifa
normal y sobre las 48 horas, se paga la tarifa con un recargo del 20%. Por otro
lado, si el sueldo bruto es superior a S/.1650.00 el sueldo del trabajador está
sujeto a un descuento del 15%. Desarrollar una solución que permita
Pag. 579
APÉNDICE
48. Desarrollar una solución que permita calcular y mostrar la nota final de un
alumno. Si la nota final (nf) es menor a 13 se deberá mostrar el mensaje
“Alumno desaprobado”, caso contrario se mostrará el mensaje “Alumno
aprobado”. Fórmula: nf = (n1+n2+n3) / 3.
49. Desarrollar una solución que permita ingresar tres notas de un determinado
alumno. Mostrar las notas ordenadas en forma ascendente (de menor a
mayor).
50. Desarrollar una solución que permita que permita calcular el monto a pagar por
la compra de un producto, considerando un descuento del 27% por la compra
de 150 unidades.
51. Desarrollar una solución que permita calcular y mostrar el monto total a pagar
por la compra de varios artículos. Considerar que deberá agregar el IGV
respectivo. Si el monto total a pagar incluido IGV es mayor a S/. 1800.00
nuevos soles se aplica un descuento del 12%, caso contrario el descuento será
del 3%.
52. Desarrollar una solución que permita determinar que proveedor es más
conveniente para una empresa. La empresa desea adquirir cierta cantidad de
unidades de un producto para lo cual cuenta con una oferta de dos
proveedores, de acuerdo a lo especificado a continuación:
¾ Proveedor A: Costo unitario igual a $25.0 y 15% de
descuento para más de 50 unidades adquiridas.
¾ Proveedor B: Costo unitario igual a $27.5 y 10% de
descuento para mas de 35 unidades adquiridas.
53. Desarrollar una solución que permita determinar si un número es divisor de otro
número. Utilizar la expresión (num1 RESTO num2 > 0) donde “num1” y “num2”
son los números.
Pag. 580
APÉNDICE
54. Desarrollar una solución que permita ingresar un número entero. Mostrar si el
número ingresado es un número par o un número impar.
55. Desarrollar una solución que permita ingresar un número entero. Mostrar si el
número ingresado es un número negativo, un número par o un número múltiplo
de 7.
56. Desarrollar una solución que permita ingresar un número entero. Indicar lo
siguiente en base al número ingresado:
¾ Si el número es positivo o negativo.
¾ Si el número es par o impar.
¾ Si el número es múltiplo de 3 o no.
¾ Si el número es Menor que 500 o no.
57. Desarrollar una solución que permita determinar si un numero (num) es par,
impar o nulo. Utilizar lo siguiente: -1 elevado a la potencia del número
ingresado (-1 ** num). Mostrar un mensaje si el número es par, impar o nulo.
58. Desarrollar una solución que permita ingresar un número entre 1 y 12. Mostrar
el nombre del mes del año correspondiente. (Enero, Febrero,...etc).
59. Desarrollar un programa que permita ingresar un número entre 1 y 7. Mostrar el

nombre del día de la semana correspondiente. (Lunes, martes…etc).
60. Desarrollar una solución que permita ingresar la categoría y el sueldo de un

trabajador. Calcular el aumento correspondiente teniendo en cuenta la
siguiente tabla. Mostrar el nuevo sueldo del trabajador.
Categoría Aumento
1 35 %
2 25 %
3 15 %
Pag. 581
APÉNDICE
4 5%
61. Desarrollar una solución que permita calcular y mostrar el monto total a pagar
por un sándwich, sabiendo que, adicionalmente, hay que pagar el 6% por el
servicio y 7% por propinas. Considerar que se venden 4 tipos de sándwich, de
acuerdo a la siguiente tabla.
Tipo Costo
Moderado S/. 2.00
Mediano S/. 3.00
Extra Grande S/. 4.00
Full S/. 6.00
62. Desarrollar una solución que permita calcular y mostrar el costo total que
representa un paciente para un hospital de acuerdo al tipo de enfermedad,
según los datos de la tabla. Adicionalmente, debe considerar que los pacientes
menores de 18 años implican un costo adicional de 25 %.
Enfermedad Tipo Costo diario

1 120
2 380
3 620
según los datos de la tabla. Adicionalmente, debe considerar que las mujeres
tienen un incremento del 19% para el primer tipo de enfermedad y los hombres
tienen un aumento del 4% para el tercer tipo.

1 180
2 420
Pag. 582
APÉNDICE
3 513
64. Desarrollar una solución que permita determinar y mostrar si una persona que
está a punto de observar un programa de televisión esta apto o no. Considerar
la siguiente tabla:
Edad Categoría
18 -más Contenido para adultos.
11 -17 Mayores de 14.
0 –10 Apta para todos.
según los datos de la tabla. Adicionalmente, debe considerar que los pacientes
de sexo femenino menores de 14 años implican un costo adicional de 8%.

1 122
2 234
3 345
4 587
66. Desarrollar una solución que permita ingresar las notas obtenidas por un
alumno del curso de Matemática Básica III. Calcular su nota final (nf), de
acuerdo a la fórmula empleada por su profesor, según los datos de la tabla.
Mostrar la nota final (nf) del alumno y si está aprobado o no, considerando que
la nota mínima aprobatoria es 12 (doce).
Código Profesor Fórmula

1 nf = (n1 + n2 ) / 2
2 nf = (n1 + n2*2) / 3
3 nf = (n1*2 + n2) / 3
Pag. 583
APÉNDICE
67. Desarrollar una solución que permita determinar la categoría de cada

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

conociendo su base y altura. Si el área es menor que 100, se deberá visualizar
el mensaje “rectángulo pequeño” y si el área es mayor o igual que 1000 se
deberá visualizar el mensaje “rectángulo grande”.
71. Desarrollar una solución que permita calcular el área de un rectángulo

conociendo su base y altura. Si el área es menor que 100, se deberá visualizar
el mensaje “rectángulo pequeño”; si el área es mayor o igual a 100 y menor
que 1000, se visualizará el mensaje “rectángulo mediano”; y si el área es
mayor o igual que 1000, el mensaje será “rectángulo grande”.
72. Desarrollar una solución que permita ingresar el nombre del alumno, el tipo de
participante (profesor, alumno, externo) y el nivel del curso (básico, intermedio,
avanzado). En la tabla que se muestra a continuación se detallan los costos de
los cursos:
Básico Intermedio Avanzado

Profesor 35 40 45
Alumno 40 50 60
Externo 60 80 100
Mostrar los datos del recibo, tal y como se muestra en el siguiente ejemplo:
********************* RECIBO ******************

Alumno : Juan Pérez
Costo : (de acuerdo a la tabla)
Nivel : (de acuerdo al ingresado)
***************************************************
73. Desarrollar una solución que permita ingresar el sueldo de un trabajador.

Calcular y mostrar su aumento por incremento del costo de vida de acuerdo a
la siguiente tabla:
Pag. 585
APÉNDICE
Condición Aumento
Sueldo < 2000 23 %
2000 < =Sueldo < =3000 17 %
Sueldo > 3000 12 %
74. Desarrollar una solución que permita ingresar la temperatura promedio (tp) de
un día y permita mostrar el tipo de clima de acuerdo a la siguiente tabla:
Temperatura (tp) Tipo de Clima

TP<=9 Frió
9<TP<=17 Nublado
17<TP<=27 Caluroso
TP>27 Trópico
75. Desarrollar una solución que permita ingresar una fecha en el siguiente
formato: (dd/mm/aaaa). Calcular el número de días que tiene el mes y si el año
ingresado es bisiesto o no.
76. Desarrollar una solución que permita ingresar una fecha (dd/mm/aaaaa) y la
convierta al siguiente formato de fecha: “dd de NombreMes de aaaa”. Ejemplo:
Ingreso 12/05/2005. Se deberá mostrar: 12 de Mayo del 2005.
77. Desarrollar una solución que permita ingresar un número de 2 cifras. Mostrar el
equivalente del número ingresado en letras.
78. Desarrollar una solución que permita ingresar un número de 3 cifras. Mostrar el
equivalente del número ingresado en letras.
79. Desarrollar una solución que permita calcular el factorial de un número entero
positivo.
Pag. 586
APÉNDICE
80. Desarrollar una solución que permita ingresar tres números enteros. Mostrar el
número mayor.
81. Desarrollar una solución que permita mostrar la tabla de multiplicar de un

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

cualesquiera. Determinar cuántos números son negativos, ceros y positivos.
92. Desarrollar una solución que permita ingresar 100 números. Calcular y mostrar
la suma de los números pares, la suma de los números impares y la media de
todos los número ingresados.
93. Desarrollar una solución que permita ingresar un número entero. Determinar y
mostrar si el número ingresado es un número primo o no.
94. Desarrollar una solución que permita ingresar 50 números. Determinar la suma
de todos los números impares y la cantidad de números primos ingresados.
95. Desarrollar una solución que permita ingresar 10 números. Determinar y

mostrar la suma de todos los números pares y la suma de todos los números
primos.
96. Desarrollar un programa que genere cada uno de los siguientes gráficos:
* * * * * * * * * * *
* * * * * * * * * *
* * * * * * * * *
* * * * * * * *
* * * * * * *
97. Desarrollar un programa que genere cada uno de los siguientes gráficos:
Pag. 588
APÉNDICE
* - * - * - * - * * * * * * * * * * *
* - * - * - * * * * * * * * * * *
* - * - * * * * * * * * * * *
* - * * * * * * * * * * *
* * * * * * * * * * *
98. Desarrollar un programa que genere el siguiente gráfico:
1
2 3
4 5 6
7 8 9 1
2 3 4 5 6
7 8 9 1
2 3 4
5 6
7
99. Desarrollar un programa que permita leer una cadena. Mostrar la cadena
ingresada en forma triangular. Tal y como se muestra a continuación: Ejemplo;
Se ingresa la cadena “Danae”.
D
DA
DAN
DANA
DANAE
100. Desarrollar un programa que permita leer una cadena. Mostrar la cadena
ingresada en forma triangular. Tal y como se muestra a continuación:
Ejemplo; Se ingresa la cadena “Danae”.
DANAE
DANA
DAN
Pag. 589
APÉNDICE
DA
D
101. Desarrollar una solución que permita invertir un número cualquiera. El número
deberá ser ingresado por teclado.
102. Desarrollar una solución que permita ingresar un texto y permita determinar lo
siguiente:
¾ La cantidad de vocales.
¾ La cantidad de consonantes.
¾ La cantidad de espacios en blanco.
¾ La cantidad de símbolos.
103. Desarrollar una solución que permita calcular y mostrar la nota final de 10
alumno. Utilizar la siguiente fórmula: nf = (n1+n2+n3+(n4*2))/5. Ingresar las
notas a través del teclado.
104. Desarrollar una solución que permita ingresar las edades de 10 alumnos.
Calcular y mostrar lo siguiente:
¾ Suma de todas la edades.
¾ Promedio de edades.
¾ Promedio de edades pares.
¾ Edad máxima.
¾ Edad mínima.
105. Desarrollar una solución que permita calcular la nota final de todos los
alumnos. Utilizar la siguiente fórmula: nf = (n1 + n2 + n3 + (n4 * 2)) / 5.
Ingresar las notas a través del teclado. Se deberá utilizar la estructura lógica
MIENTRAS.
106. Desarrollar una solución que permita calcular la nota final de todos los
alumnos. Utilizar la siguiente fórmula: nf = (n1 + n2 + n3 + (n4 * 2)) / 5.
Pag. 590
APÉNDICE
Ingrese las notas a través del teclado. Se deberá utilizar la estructura lógica
HACER.
107. Desarrollar una solución para el siguiente problema. En un salón de clase se

ha realizado un examen con tres pruebas distintas. Se desea conocer el
promedio obtenido en cada una de las pruebas realizadas.
108. Desarrollar una solución para el siguiente problema. Se tiene una relación de
100 obreros y su sueldo. Determinar cuántos ganan menos de S/. 800.00,
entre S/. 800.00 y S/. 3,000.00 (Incluidos S/. 800.00 y S/. 3,000.00), y cuántos
más de S/.3,000.00.
109. Desarrollar una solución que permita determinar la suma de sueldos de los
obreros (categoría C), la suma de sueldos de los empleados (categoría B) y la
suma de sueldos de los gerentes (categoría A) de una determinada empresa.
Adicionalmente, determinar cuál es el mayor y el menor sueldo en la
empresa.
110. Desarrollar una solución para el siguiente problema. Se desea hacer una
estadística de las estaturas de los 1000 alumnos de un colegio, de acuerdo a
lo siguiente:
¾ Alturas hasta 1,60 metros.
¾ Alturas entre 1,60 metros y 1,70 metros.
¾ Alturas entre 1,70 metros y 1,80 metros.
¾ Alturas mayores de 1,80 metros.
111. Calcular y mostrar el número de alumnos que tienen promedio final menos de
11; los que tiene promedio final entre 11 y 14; aquellos que tienen promedio
final entre 15 y 17; y los que tienen promedio final mayor de 17. Ingresar 4
notas y calcular el promedio del alumno en base a la siguiente fórmula: nf =
(n1 + n2 + n3 + (n4 * 2)) / 5.
Pag. 591
APÉNDICE
112. Calcular la nota media de los alumnos de una clase considerando “n”
alumnos y “c” notas.
113. Un canillita vende 4 tipos de loterías según se muestra en el siguiente cuadro.

Calcular el total de loterías vendidas de cada tipo.
Tipo lotería Costo

1 2
2 4
3 6
4 8
114. En una empresa se decide hacer una colecta de dinero con la finalidad de
ayudar a uno de los empleados de la empresa que ha sufrido un accidente
automovilístico. Se determina que los gerentes contribuirán con S/ 35.00
soles, los profesionales con S/ 25.00 soles y el resto de empleados de
acuerdo a sus posibilidades. Determinar el total recaudado.
115. Desarrollar una solución que permita emitir la factura correspondiente a la

compra de varios artículos. El IGV a aplicar es el 19% y si el monto total de la
factura, incluido IGV, es mayor a S/. 3,000.00 nuevos soles se aplicará un
descuento del 12%.
116. Desarrollar una solución que permita desarrollar el siguiente menú con las
opciones solicitadas.
¾ [1] Ingreso de datos (base y altura de un rectángulo).
¾ [2] Proceso (determinar área y perímetro del rectángulo).
¾ [3] Resultado (Mostrar el valor de área y perímetro obtenidos).
¾ [4] Terminar.
117. Desarrollar una solución para el siguiente problema. Los empleados de una
fábrica trabajan en tres turnos; mañana, tarde y noche. Se desea calcular el
jornal diario de cada empleado teniendo en cuenta lo siguiente:
Pag. 592
APÉNDICE
¾ La tarifa del turno mañana y tarde es de S/ 8.00 soles por hora.

¾ La tarifa del turno noche es de S/ 10.00 soles por hora.
¾ En caso de ser un día domingo, la tarifa se incrementa en 50%
para los turnos mañana y tarde y en 60% para el turno noche.
¾ Para el turno tarde se incrementa S/ 10.00 soles por concepto de
movilidad.
118. Desarrollar una solución que permita controlar la venta de boletos en un

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

salón de clase:
¾ ¿Cuántas alumnas están matriculadas en el curso?
¾ ¿Cuántos alumnos están matriculados en el curso?
¾ ¿Cuántas alumnas son menores de 20 años?
¾ ¿Cuántos alumnos son mayores de 18 años?
¾ ¿Cuántos alumnos están aprobados?
¾ ¿Cuántas alumnas están desaprobadas?
Pag. 593
APÉNDICE
120. Desarrollar una solución que permita ingresar los nombres y las edades de ‘n’
alumnos. Determinar la suma de las edades, el nombre del alumno con la
mayor nota y el nombre del alumno con la menor nota.
121. Desarrollar una solución que permita determinar la nota final obtenida por
cada uno de los alumnos del curso de Álgebra del colegio “La Excelencia”
(considere 3 notas). Adicionalmente, deberá indicar el porcentaje de alumnos
aprobados, desaprobados, la nota final más baja y más alta. Ingresar la
cantidad de alumnos y las 3 notas de cada alumno.
122. Desarrollar una solución que permita determinar el costo de cada uno de los
artículos que se venden en la bodega “La China” (considere el precio de
venta y la utilidad obtenida por el artículo). Adicionalmente, deberá indicar el
promedio del costo de todos los artículos, el articulo más caro y el más
barato. Ingresar el nombre, el precio de venta y la utilidad de cada artículo.
123. Desarrollar una solución para el siguiente problema. En la fabrica “LA

CLONACION S.A.”. Trabajan miles de obreros y se desea determinar cuantos
tienen un salario menor a S/. 500.00, entre S/. 500.00 y S/. 2,200.00
(incluidos S/. 500.00 y S/. 2,200.00), y cuantos tienen un salario mayor a S/.
2,200.00.
representan los pacientes de un hospital de acuerdo al tipo de enfermedad,
según los datos de la tabla. Adicionalmente, deberá considerar que los
pacientes menores de 18 años implican un costo adicional de 35% y las
mujeres un costo adicional de 12%.

1 100
2 150
3 300
Pag. 594
APÉNDICE
4 450
125. Desarrollar una solución para el siguiente problema. El cine “Pantalla Láser”
cuenta con 3 salas y atiende en horarios de matinée, vermouth y noche.
Calcular el número de personas que ingresaron a cada una de las salas en
cada uno de los horarios en un determinado día. (Ingresar solo los siguientes
datos: Número de sala y el horario al cuál el cliente ingresa).
126. Desarrollar una solución para el siguiente problema. Una empresa cuenta con
cuatro almacenes de productos. ¿Cuál sería la ganancia por cada almacén si
el dueño de la empresa decide vender todos sus productos? (Ingresar solo
los siguientes datos: El precio de compra de cada producto, su precio de
venta, la cantidad existente y el almacén donde están ubicados).
127. Desarrollar una solución que permita determinar cuántas hamburguesas

fueron vendidas de cada tipo (considere 3 tipos) en cada uno de los 3 locales
de la empresa “El Rápido”. Deberá ingresar el tipo de hamburguesa y el local
en el que fue vendida.
128. Desarrollar una solución que permita determinar cuántos tipos de productos
de cada empresa de apoyo social fueron vendidos por la comunidad “La
buena Venta” durante el presente año (considere solo tres empresas de
apoyo social y asuma que cada empresa fabrica 3 tipos de producto:
chocolate, caramelo y gaseosa). Ingresar el producto vendido y la empresa
que lo fabricó.
129. Desarrollar una solución que permita determinar cuántos tipos de periódicos
de cada empresa fue vendido por José Luis Candado, quien ganó el premio al
mejor canillita 1999 otorgado por un diario de la capital, (considere solo tres
empresas periodísticas, y asuma que cada empresa desarrolla 3 tipos de
diario: popular, normal y especializado). Ingresar el tipo de diario vendido y la
empresa a la cuál pertenece.
Pag. 595
APÉNDICE
130. Desarrollar una solución que permita mostrar un menú con las siguientes
opciones:
¾ Determinar si un número es par o impar.
¾ Determinar si un número es primo o no.
¾ Salida.
131. Desarrollar una solución que permita mostrar un menú con las siguientes
opciones:
¾ Suma, resta y multiplicación de dos números.
¾ Determinar el número inverso de un número.
¾ Determinar el área y perímetro de un círculo.
¾ Salida.
132. Desarrollar una solución que permita ingresar las edades de 10 alumnos.
Determinar lo siguiente:
¾ La suma de todas las edades.
¾ La cantidad de edades impares.
¾ El promedio de edades.
¾ El promedio de edades pares.
¾ La edad mayor.
¾ La edad menor.
¾ El nombre de la alumna que tiene la mayor edad.
133. Desarrollar una solución que permita ingresar los nombres y sueldos de 5
empleados. Determinar lo siguiente:
¾ Sueldo promedio.
¾ Menor sueldo.
¾ Nombre del empleado con mayor sueldo.
¾ Cantidad de nombre que comiencen entre “c y p”.
134. Desarrollar una solución que permita ingresar los valores de una matriz de
4*4. Calcular la suma de la diagonal y la suma de la diagonal inversa.
Pag. 596
APÉNDICE
135. Desarrollar una solución que permita ingresar los valores de una matriz de
5*4. Intercambiar la primera columna por la tercera columna, así como
también intercambiar la segunda fila por la cuarta fila.
136. Desarrollar una solución que permita almacenar el nombre, la edad y el

estado civil de 15 empleados. Elaborar un listado con los datos de los
empleados cuya edad este ente 18 y 30 años, y otro listado con los datos de
todo los empleados solteros.
137. Desarrollar una solución que permita ingresar un número entero de cualquier
número de cifras. Determinar y mostrar el digito mayor del número ingresado.
Validar el número ingresado.
138. Desarrollar una solución que permita ingresar 10 nombres. Determinar el

número de nombres cuya primera letra es una letra ‘c’ o una letra ‘x’. También
determine el nombre que tiene el menor número de caracteres.
139. Desarrollar una solución que permita leer 10 apellidos. Determinar cuál es el
apellido mayor (alfabéticamente hablando).
140. Desarrollar una solución que permita leer 10 nombres. Determinar cuantos
nombres comienzan entre las letras ‘z’ y ‘p’. Utilizar un vector.
141. Desarrollar una solución que reciba la fecha con el siguiente formato: 09-30-
2004 (mm-dd-aaaa) y lo convierta a este otro formato: 30 de Septiembre del
2004.
142. Desarrollar una solución que reciba la fecha y hora con el siguiente formato:
“dd/mm/aaaa hh:mm:ss”. Ejemplo; 30/09/2004 18:10:10. Validar que la fecha
y la hora tenga el número de caracteres correctos, así como los símbolos
indicados. Mostrar los datos de la siguiente manera: Hoy es 30 de septiembre
y son las 18 y 10 de la tarde.
Pag. 597
APÉNDICE
143. Desarrollar una solución que permita leer 4 números de 3 cifras. Mostrar su
categoría. Si el número está entre 100 y 300 pertenece a la categoría A. Si el
número está entre 301 y 600 pertenece a la categoría B, y si el número está
entre 601 y 999 pertenece a la categoría C. Utilizar un vector y validar que el
número ingresado sea de 3 cifras.
144. Desarrollar una solución que permita leer los datos de ‘n’ alumnos. Los datos
de los alumnos son; nombre, fecha de nacimiento (dd/mm/aaaa) y nota.
Se solicita:
¾ Ingresar los datos haciendo las validaciones a la fecha (tamaño
de fecha y que contenga los símbolos “/”) y nota.
¾ Calcular y mostrar la edad de cada alumno .
¾ Hallar:
¾ Hallar la nota promedio de todos los alumnos ingresados.
¾ Nombre del alumno con mayor nota.
¾ Cantidad de alumnos cuyo nombre comience entre a y p.
¾ Crear un menú de opciones para acceder al programa.
145. Desarrollar una solución que permita leer los datos de 5 empleados. Los
datos de los empleados son; nombre, fecha de ingreso (dd/mm/aaaa) y
sueldo.
Se solicita:
¾ Ingresar los datos haciendo las validaciones a la fecha (tamaño
de fecha y que contenga los símbolos “/”) y sueldo.
¾ Calcular los años de servicio (que tiene trabajando).
¾ Hallar:
¾ Hallar el sueldo promedio.
¾ Nombre del empleado con menos años de servicio.
¾ Cantidad de empleado que ingresaron entre 1980 y 2004.
146. Desarrollar una solución que permita leer los datos de 5 alumnos. Los datos
de los alumnos son; nombre, tipo (Ingresantes, Regular o Egresado) y nota.
Pag. 598
APÉNDICE
Se solicita:
¾ Ingresar los datos haciendo las validaciones al tipo y nota.
¾ Por cada alumno mostrar la categoría:
¾ Si es ingresante y tiene entre 17-20 categoría IA.
¾ Si es ingresante y tiene entre 12-16 categoría IB.
¾ Si es regular y tiene entre 17-20 categoría RA.
¾ Si es egresado y tiene entre 17-20 categoría EA.
¾ Por cada alumno mostrar:
¾ Nombre en Mayúscula.
¾ Los 3 primeros caracteres del nombre.
¾ Cálculos:
¾ Hallar el promedio de los ingresantes y regulares.
¾ Nombre del alumno con mayor nota.
¾ Mayor nota de los ingresantes y de los Egresados.
¾ Crear una opción para continuar ejecutando el programa.
de los alumnos son; nombre, edad y sexo.
Se solicita:
¾ Ingresar los datos validando que en el sexo y la edad.
¾ Por cada alumno mostrar:
¾ Nombre al revés.
¾ Ultimo carácter.
¾ Las 3 ultima letras.
¾ Cálculos:
¾ Hallar la edad promedio.
¾ Nombre de la persona con mayor edad.
¾ Nombre de mujer con menos edad.
¾ Crear un menú para acceder al programa.
de los alumnos son; nombre, fecha de nacimiento (dd/mm/aaaa) y nota.
Pag. 599
APÉNDICE
Se solicita:
¾ Ingresar los datos validando la fecha de nacimiento y la nota.
¾ Mostrar por cada alumno la edad exacta (años y meses
cumplidos a la fecha de hoy).
¾ Cálculos:
¾ Nombre y la edad de la persona con mayor nota.
¾ Nombre de mujer con menos edad.
149. Desarrollar una solución que permita leer los datos de ‘n’ empleados. Los
datos de los empleados son; nombre, AFP (Integra, Unión y ProFuturo),
sueldo Básico y fecha de ingreso (dd-mm-aaaa).
Se solicita:
¾ Ingresar los datos validando AFP, sueldo y fecha de ingreso.
¾ Calcular y mostrar el sueldo Total por cada empleado ( sueldo
Total = sueldo Básico – descuentos):
¾ Si tiene 4 o más años de antigüedad se le descuenta 8%
más el descuento de la AFP.
¾ Si tiene menos de 4 años se le descuenta 10% más el
descuento de la AFP.
¾ El descuento de la AFP se ve en la siguiente tabla:
AFP Descuento
Integra 12%
Unión 13%
ProFuturo 14%
¾ Cálculos:
¾ Mostrar el nombre y el AFP de la persona con mayor
sueldo.
¾ Mostrar el nombre de la persona más nueva es decir con
menos años de ingreso.
Pag. 600
APÉNDICE
de los alumnos son; sexo (M/F), edad y nombre.
Se solicita:
¾ Ingresar los datos validando que en el sexo solo se ingrese ‘M’ o
‘F’, y la edad sea un número positivo.
¾ Mostrar lo siguiente por cada alumno:
¾ Si es mayor o menor de edad.
¾ Cantidad de vocales del nombre.
¾ Cálculos:
¾ Nombre de la persona con mayor edad.
¾ Nombre de hombre con menos edad.
Pag. 601
APÉNDICE
Pag. 602
APÉNDICE
Clase Lectura
package biblioteca;
import java.io.*;
/*
* Clase que permite capturar literales desde el teclado.
*
*/
public class Lectura {
/**
* Retorna el char capturado desde el teclado.
*/
public static char leerChar() {
char c = ' ';
char[] c1 = leerString().toCharArray();
if (c1.length == 1)
c = c1[0];
return c;
}
/**
* Retorna un literal double capturado desde el teclado.
*/
public static double leerDouble() {
try {
return Double.valueOf(leerString()).doubleValue();
} catch (NumberFormatException e) {
System.out.print("ERROR...\n Ingrese de nuevo: ");
return leerDouble();
}
}
/**
* Retorna un literal float capturado desde el teclado.
*/
public static float leerFloat() {
try {
return Float.valueOf(leerString()).floatValue();
return leerFloat();
}
}
Pag. 603
APÉNDICE
/**
* Retorna un literal int capturado desde el teclado.
*/
public static int leerInt() {
try {
return Integer.parseInt(leerString());
return leerInt();
}
}
/**
* Retorna un literal long capturado desde el teclado.
*/
public static long leerLong() {
try {
return Long.valueOf(leerString()).longValue();
return leerLong();
}
}
/**
* Retorna un literal short capturado desde el teclado.
*/
public static short leerShort() {
try {
return Short.valueOf(leerString()).shortValue();
return leerShort();
}
}
/**
* Retorna una cadena capturada desde el teclado.
*/
public static String leerString() {
BufferedReader in = new
BufferedReader(new InputStreamReader(System.in));
String cadena = "";
try {
cadena = in.readLine();
} catch (IOException e) {
System.out.println(e);
}
return cadena;
}
}
Pag. 604
APÉNDICE
Clase DecimalFormat
java.lang.Object
java.text.Format
java.text.NumberFormat
java.text.DecimalFormat
DecimalFormat es una clase concreta de NumberFormat que da formato a números

decimales. Tiene una gran variedad de opciones para dar formatos a números en cualquier
sistema, incluye soporte para dígitos Occidentales, Arábigos e Índicos. También soporta gran
variedad de formatos numéricos, como son: enteros, decimales, notación científica, formato
de moneda, etc.
Con la clase DecimalFormat se específica un formato de número con patrón. La clase

DecimalFormatSymbols permite modificar los símbolos de formato como separadores
decimales o el signo negativo entre otros.
Se puede utilizar la clase DecimalFormat para formatear números decimales en cadenas

específicas de la Localidad. Los programas almacenan y operan con números de una forma
independiente de la Localidad. Antes de mostrar o imprimir un número el programa debe
convertirlo a un String que esté en un formato sensible a la Localidad. Por ejemplo, en
Francia, el número 123456.78 debería ser formateado como 123 456,78, y en Alemania
debería aparecer como 123.456,78. Par poner en práctica esto podemos recurrir a 2
métodos:
NumberFormat formato ;
DecimalFormat df ;
Pag. 605
APÉNDICE
Si queremos dar formato a números:
formato = NumberFormat.getNumberInstance(currentLocale);
Si queremos dar formato a monedas:
formato = NumberFormat.getCurrencyInstance(currentLocale);
Luego aplicamos las características locales almacenadas en formato a df:

DecimalFormat df = (DecimalFormat)nf;
Esta clase permite controlar los ceros iniciales y finales, los sufijos y prefijos, separadores
(millares), y el separador decimal. Si se quiere cambiar un símbolo del formateo como el
separador decimal, se puede utilizar DecimalFormatSymbols en conjunción con la clase
DecimalFormat
Símbolos usados para formato

Símbolo Significado
0 Digito
# Digito, el cero se muestra como ausente
. Separador decimal
- Signo menos
, Separador de agrupación
E Para notación científica "0.###E0" muestra 1234 como "1.234E3"
; Para separar formatos positivos y negativos
% Multiplica por 100 y lo muestra como porcentaje
\u2030 Multiplica por 1000 y muestra como millares
¤ (\u00A4) Utilizado para mostrar símbolos monetarios
' Usado para mostrar caracteres especiales
Ejemplo:
Pag. 606
APÉNDICE
En el ejemplo siguiente usaremos distintos cadenas de texto para dar formato a un número
ingresado por teclado. Debemos tener en cuenta que:
• Para poner completar con ceros la parte decimal debemos poner tantos “0” como
dígitos decimales queremos que tenga nuestro número en la cadena de formato.
• Si queremos que un número que no tiene parte decimal muestre un ‘0’antes del
separador decimal debemos poner un ‘0’ en esa posición en nuestra cadena de
formato.
public static void main(java.lang.String[] args) {

double n;
String s;
DecimalFormat f;
System.out.print("Ingresa número a dar formato : ");
n = Lectura.leerDouble();
f = new DecimalFormat("###,###");
s = f.format(n);
System.out.println(s);
f = new DecimalFormat("###,###.00");
s = f.format(n);
f = new DecimalFormat("###,###.0000");
s = f.format(n);
f = new DecimalFormat("'U$' ###,##0.00");
s = f.format(n);
f = new DecimalFormat("'S/.'###,##0.00 Soles");
s = f.format(n);
f = new DecimalFormat("#,##0.####E0");
s = f.format(n);
f = new DecimalFormat("###,##0.00%");
s = f.format(n);
}
Pag. 607
APÉNDICE
En el siguiente ejemplo utilizamos la clase DecimalFormatSymbols, y reemplazamos el

símbolo de separación decimal por | y el separador de grupos por ^ asimismo los grupos los
hacemos de 4 dígitos (en vez de 3 como es regularmente) y por último, reemplazamos el
símbolo que representa números negativos (-) por n
public static void main(java.lang.String[] args) {

double n;
String s;
DecimalFormat f;
System.out.print("Ingresa número a dar formato : ");
n = Lectura.leerDouble();
//Ahora modificamos los símbolos usados como separadores decimales
//y de millares, asi como el símbolo usado para especificar un negativo.
//esto lo hacemos utilizando la clase DecimalFormatSymbols
DecimalFormatSymbols simbolosraros = new DecimalFormatSymbols();
simbolosraros.setDecimalSeparator('|');
simbolosraros.setGroupingSeparator('^');
simbolosraros.setMinusSign('n');
f = new DecimalFormat("###,##0.00", simbolosraros);
f.setGroupingSize(4);
s = f.format(n);
System.out.println("Alterando los símbolos : " + s);
}
Pag. 608
APÉNDICE
Clase Calendar
java.lang.Object
java.util.Calendar
Calendar es una clase base abstracta para conversiones entre un objeto Date y una gama de
enteros como YEAR(año), MONTH(mes), DAY(día), HOUR(hora), y así sucesivamente.
Subclases de la clase calendario interpretan una fecha de acuerdo con las reglas específicas
de un calendario determinado. Esta plataforma implementa una subclase concreta:
GregorianCalendar. Futuras subclases podrían representar los diferentes tipos de calendarios
lunares en muchos sitios del mundo.
Para inicializar un objeto Calendar con los valores de fecha y horas actuales utilizaremos el
método getInstance( ):
Calendar cal = Calendar.getInstance();
Los campos de un objeto calendario pueden ser manipulados usando 3 métodos:
set()
// cambiamos los campos YEAR, MONTH y DATE del calendario cal
// a los valores dados en año, mes y día.
cal.set (año, mes, día) ;
// cambiamos el valor del campo YEAR del calendario cal

// al valor guardado en año
cal.set (cal.YEAR,año) ;
// cambiamos los campos YEAR, MONTH , DATE, HOUR y MINUTE

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

Constante que representa el campo Hora del día
static int JANUARY , FEBRUARY, MARCH , etc…
Constantes que representan a los meses que corresponden del año.
static int MILLISECOND
Constante que representa el campo que indica los milisegundos de la hora
actual
static int MINUTE
Constante que representa el campo que indica los minutos de la hora actual.
static int MONDAY, TUESDAY, WEDNESDAY, etc…
Constantes que representan a los días que corresponden de la semana.
static int MONTH
Constante que representa el campo que indica el mes actual
static int PM
static int SECOND

Constante que representa el campo Indica o establece los segundo de la
hora actual
static int UNDECIMBER
indica el 13o mes del mes
static int WEEK_OF_MONTH
Constante que representa el campo Semana del mes
static int WEEK_OF_YEAR
Constante que representa el campo Semana del año
static int YEAR
Constante que representa el campo Año
Estas constantes nos sirven para especificar en los métodos, que se detallan a continuación,
cuales son los campos que queremos manipular, por ejemplo, si queremos agregar un minuto
al calendario actual debemos utilizar el método add, este método tiene como parámetros:
int Campo, int Cantidad ;
Entonces para agregar un minuto debemos especificarle al método que queremos manipular
el campo minuto y la cantidad que queremos agregar al valor almacenado en este campo
(supongamos ya definido un Calendar cal):
cal.add (cal.MINUTE,1) ;
Pag. 611
APÉNDICE
Sumario de métodos
abstract void add(int Campo, int Cantidad)
Date Arithmetic function.
boolean after(Object cuando)
Compara los tiempos, si la fecha actual de nuestro calendario es
superior a cuando, retorna verdadero
boolean before(Object cuando)
Compara los tiempos,, si la fecha actual de nuestro calendario es
inferior a cuando, retorna verdadero
void clear()
limpia los valores de todos los campos del calendario
void clear(int campo)
Limpia el valor del campo indicado
boolean equals(Object objeto)
Compara este calendario con el objeto dado, y si son iguales retorna
verdadero.
int get(int campo)
Obtiene el valor almacenado en el campo dado.
int getActualMaximum(int campo)
Retorna el valor máximo que puede obtener este campo con la fecha
del calendario actual. Por ejemplo, si campo=Calendar.DAY_OF_MONTH y
el mes actual es Abril, entonces el valor retornado será 30 (el máximo valor
int getActualMinimum(int campo)
Retorna el valor mínimo que puede obtener este campo con la fecha
del calendario actual.
int getFirstDayOfWeek()
Obtiene el primer día de la semana. Por ejemplo SUNDAY (0)
static Calendar getInstance()
Obtiene un calendario utilizando la zona actual y las reglas dadas
static Calendar getInstance(TimeZone zona)
Obtiene un calendario utilizando zona y las reglas dadas
Date getTime()
Obtiene la hora actual del calendario.
long getTimeInMillis()
Obtiene la hora actual del calendario en milisegundos
TimeZone getTimeZone()
Obtiene la zona horaria.
boolean isSet(int campo)
Pag. 612
APÉNDICE
Determina si el campo dado tiene un valor almacenado.

abstract void roll(int field, boolean up)
Time Field Rolling function.
void roll(int field, int amount)
set(int field, int value)
void setFirstDayOfWeek(int value)
Establece cual es primer día de la semana para el calendario actual.
Ej MONDAY
void setTime(Date fecha)
Establece la hora del calendario actual a fecha
void setTimeInMillis(long milisegundos)
Establece la hora del calendario actual utilizando los milisegundos
dados
void setTimeZone(TimeZone value)
Sets the time zone with the given time zone value.
String toString()
Retorna una representación de cadena del calendario actual
Pag. 613
APÉNDICE
Ejemplo:
Pag. 614
APÉNDICE
Pag. 615
APÉNDICE
Pag. 616
APÉNDICE
Clase GregorianCalendar
java.lang.Object
java.util.Calendar
java.util.GregorianCalendar
GregorianCalendar es una subclase concreta de la Clase Calendar y provee el calendario

Standard usado por la mayoría del mundo.
¿Qué es el Calendario Gregoriano?

El calendario Gregoriano surgirá de la reforma que el papa Gregorio XIII (1502-1585) ordenó
hacer para compensar las desviaciones del calendario juliano (pierde un día cada 128 años, y
por lo tanto cada año se hacía más notorio que la fecha de la Pascua de Resurrección se
atrasaba con respecto al equinoccio) y hacer coincidir el año civil con el año trópico. La tarea
recayó en una comisión, que dirigida por Cristóbal Clavio que basándose en los cálculos Luigi
Lilio (el auténtico artífice de la reforma), presentó el nuevo calendario al papa. Los cálculos
supusieron un día medio de 24 horas y un año medio de 365 días, 5 horas, 49 minutos y 20
segundos (26 segundos más que el año real). Para ello se alternarían años de 365 días, años
de 366 días. El calendario gregoriano intercala un año bisiesto cada cuatro años, pero no
cuenta como bisiestos los años seculares (los que terminan en doble cero: 1800, 1900, 2000),
excepto cuando las dos primeras cifras son múltiplo de 4, como el 2000. Esta excepción se
produce porque con los cálculos de Luigi Lilio se produce un error de un día 134 años, o lo
que es lo mismo 3 días cada 402 años. Había, pues, que suprimir tres días cada 402 años.
Como esta cifra está relativamente cerca de 400 se acordó que no fuesen bisiestos los años
terminados en doble cero (100, 200 y 300) pero sí el 400 y sus múltiplos. De esta manera se
produce un error de sólo un día cada 3323 años. No obstante, si se suprimiese un año
bisiesto cada 128 años, el error acumulado sería menor a un día cada 100.000 años.
El calendario se adoptó en 1582 y como en los 1.257 años de vigencia del calendario juliano
se habían acumulado 10 días de retraso, se estableció que el día siguiente al 4 de octubre de
1582 fuese el 15 de octubre de 1582. El año comienza el 1 de enero.
El calendario gregoriano consta de doce meses: enero (31 días), febrero (28 ó 29), marzo
(31), abril (30), mayo (31), junio (30), julio (31), agosto (31), septiembre (30), octubre (31),
Pag. 617
APÉNDICE
noviembre (30) y diciembre (31); y de una semana de siete días: lunes, martes, miércoles,
jueves, viernes, sábado y domingo; que es independiente del mes. Para el cómputo
eclesiástico el primer día de la semana es el domingo. Los días del mes se numeran
correlativamente.
El Calendario gregoriano Standard tiene 2 eras: AC y DC.
Realmente para trabajar con fechas en Java que puedan encontrarse entre ambos
calendarios lo recomendable es rescribir todo el proceso y operaciones necesarias a mano,
pero si las fechas van a estar dentro del calendario gregoriano, lo mejor es usar la clase
GregorianCalendar que trae un buen montón de métodos para operar con fechas en Java.
Ejemplo:
Pag. 618
APÉNDICE
Pag. 619
APÉNDICE
Pag. 620
APÉNDICE
Clase SimpleDateFormat
java.lang.Object
java.text.Format
java.text.DateFormat
Esta clase se utiliza para presentar las fechas como cadenas de texto con formato de acuerdo
a un patrón establecido.
Los patrones que se utilizan son:
Letra Significado Ejemplos

G Era AD
y Año 1996; 96
M Mes del año Julio; Jul; 07
w Semana del año 27
W Semana del mes 2
D Día del año 189
d Día del mes 10
F Día de la semana en el mes 2
E Día de la semana Jueves; Jue
a AM/PM PM
H Hora del día (0-23) 0
k Hora del día (1-24) 24
K Hora en AM/PM (0-11) 0
h Hora en AM/PM (1-12) 12
m Minuto de la hora 30
s Segundo del minuto 55
S Milisegundo 978
z Zona horaria GMT -5:00
Z Zona horaria -0500
Pag. 621
APÉNDICE
Los pasos a seguir son:
1.- Creación del formateador:
SimpleDateFormat s=new SimpleDateFormat("EEEEE,dd 'de' MMMM 'del' yyyy G zz");
2.- Aplicar el formato a una fecha y asignarlo a una cadena:
//asumimos que se tiene un onjeto calendar previamente creado e inicializado

String Cad=s.format(calendar.getTime()) ;
System.out.println(Cad) ; // jueves,20 de mayo del 2004 AD GMT-05:00
Pag. 622
Pag. 623
Pag. 624
BIBLIOGRAFÍA
Introducción a las Tecnologías de

Información.
1ra Edición - 2004.
FIA - USMP. Jefferson López Goycochea.
Método para la Solución de Problemas

Utilizando la Programación Orientada
A Objetos - Aspectos básicos.
1ra Edición - 2003.
FIA - USMP. Juan José Flores Cueto .
Metodología de la Programación.
Algoritmos, Diagrama de flujo y programas
2da Edición - 2003. Osvaldo Cairó Battistutti.
Java, Manual de referencia. Patrick Naughton / Herbert Schildt.
UML Gota a Gota.

1999. Martín Fowler / Kendall Scott.
Como Programar en Java.

1998. Deitel y Deitel.
Pag. 625
Pag. 626
NOTAS FINALES
Cualquier observación, sugerencia o recomendación relacionada al contenido del presente

texto podrá realizarla, enviándome un correo electrónico a la siguiente dirección:
jflores@usmp.edu.pe
De antemano, agradezco cualquier contribución que permita mejorar el material y contenido

del presente libro.
Pag. 627
Pag. 628

MODELO-DE-LAS-6D S - Flores Cueto Juan Jose

Cargado por

Información del documento

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

MODELO-DE-LAS-6D S - Flores Cueto Juan Jose

Cargado por

Copyright:

Formatos disponibles

MÉTODO DE LAS 6’D

UML – Pseudocódigo – Java

MÉTODO DE LAS 6’D

Ing. Juan José Flores Cueto.

“Fallar no te convierte en un fracaso,

Es importante destacar la participación de mis alumnos del curso de Algoritmo y Estructura de

Un agradecimiento especial a Isabel y a Jorge por participar desde el inicio hasta el

Finalmente, mi sincero agradecimiento a las autoridades de la Facultad de Ingeniería y

CAPÍTULO I: Método de las 6’D. Un enfoque algorítmico.

CAPÍTULO II: Estructuras fundamentales para la solución de problemas.

CAPÍTULO III: Clases básicas incorporadas en el lenguaje Java.

Introducción ........................................................................................................ 259

CAPÍTULO IV: Estructuras de datos arreglos.

Introducción ........................................................................................................ 401

Introducción ........................................................................................................ 527

BIBLIOGRAFÍA ................................................................................................... 625

El mercado exige que los profesionales de Computación y Sistemas conozcan la últimas

Ing. José Antonio Chang Escobedo.

Actualmente, existe una tendencia creciente en el uso de herramientas de desarrollo de

Los conceptos y temas fundamentales, necesarios para el desarrollo de soluciones utilizando

Se desarrolla la parte teórico formal del método de las 6’D. Se describen

En este capítulo, también se tratan los conceptos fundamentales sobre

Se desarrolla la estructura de datos más simple: la variable, y se

Las estructuras de datos, las estructuras lógicas y las instrucciones de

Se presentan 31 problemas desarrollados utilizando el método de las

También se presentan 30 problemas desarrollados sobre diferentes tipos

Se desarrollan los conceptos fundamentales sobre las clases básicas

Las clases Wrappers, son un complemento de los tipos de datos

La clase Math, proporciona métodos y atributos para implementar

La clase String, permite declarar y manipular variables de tipo texto o

También se hace una referencia a otras clases en Java que el lector

Se desarrolla la estructura de datos conocida como arreglos (arrays), su

En base al marco teórico se desarrollan soluciones para el ingreso,

Finalmente, se presentan los conceptos fundamentales sobre el manejo

Se desarrolla una introducción al desarrollo de soluciones orientadas a

Conforme se presenta cada uno de los conceptos mencionados, se va

Al final de este capítulo, se formaliza el método de las 6’D, redefiniendo

Es importante comentar que el presente capítulo, fue el primero en ser

Ing. Juan José Flores Cueto.

Método de las 6’D:

MÉTODO DE LAS 6’D

Durante el transcurso de nuestra vida nos enfrentamos a diversos problemas.

Algunos problemas, por su naturaleza, pueden ser resueltos utilizando una

Para resolver problemas estructurados utilizando la computadora es importante

El método propuesto y utilizado en el presente texto es el Método de las 6’D,

Con la finalidad de recordar el método, se ha definido que el nombre de cada una

MÉTODO DE LAS 6’D

En la siguiente figura se muestra el Método de las 6’D con sus respectivas

Descripción de la Etapa 01 – “Descripción del Problema”:

Etapa 01 En esta etapa, en primer lugar, es necesario identificar

Identificado el problema es necesario poder

 Identificación del problema.

Descripción de la Etapa 02 – “Definición de la Solución”:

Etapa 02 En esta etapa, es necesario estudiar a fondo el

Una vez entendido el problema, se está en condiciones

 Definir el resultado deseado.

Descripción de la Etapa 03 – “Diseño de la Solución”:

Etapa 03 Definida la solución, se procede a diseñar la lógica

 Definir un nombre para el proyecto.

Descripción de la Etapa 04 – “Desarrollo de la Solución”:

Etapa 04 Una vez previstas todas las posibilidades y alternativas

La codificación involucra traducir los diagramas, las

Descripción de la Etapa 05 – “Depuración y Pruebas”:

Identificación del problema.

Definir el resultado deseado.

Definir un nombre para el proyecto.

Identificación Definir el resultado Definir un Codificar el Realizar la Recopilar el

Paquete.- Los paquetes nos permiten organizar las clases de un modelo. Un

Clase.- Una clase, es simplemente, un modelo que se utiliza para describir

Objeto.- Un objeto es cualquier cosa, real o abstracta, acerca de la cual

Diagrama de paquetes.- Un diagrama de paquetes permite especificar y

Definir un nombre para el proyecto.

Definición de diagramas, relaciones y clases.

Una lista de pasos que deben ser ejecutados.

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

Descripción de los pasos que deben ser ejecutados (estructuras

Descripción de los datos que son manipulados por estos pasos

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

Todo algoritmo debe ser finito. Si se sigue un algoritmo, éste

Un algoritmo debe estar definido. Si se sigue un algoritmo dos

Un algoritmo puede o no tener datos de entrada.

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

Los datos de entrada y salida deben almacenarse en estructuras

El resultado que se obtenga debe satisfacer los requerimientos

Debe ser estructurado. Es decir, debe ser fácil de leer, entender,

Para indicar que la computadora lea un valor desde un dispositivo externo

REGLAS UTILIZADAS POR LAS HERRAMIENTAS