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

MÉTODO DE LAS 6’D UML – Pseudocódigo – Java

(Enfoque algorítmico)

MÉTODO DE LAS 6’D UML – Pseudocódigo - Java

(Enfoque algorítmico)

Ing. Juan José Flores Cueto.

- 2005 -

U N I V E RS I D AD D E S AN M AR T I N DE P O R RE S

F a c u l ta d d e I ng e n i e r í a y Ar q u i t e c t ur a

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 Problemas resueltos del 132 al 145 ....................................................... 425 Desarrollo de soluciones utilizando múltiples arreglos. Arreglos paralelos .................................................................................. 493 Problemas resueltos del 146 al 150 ....................................................... 495

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.


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

Temas:

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

Modelamiento. Algoritmo. Programación.

Capítulo

1

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

Pag. 25

CAPÍTULO I

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

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


Pag. 26


Pag. 27

MÉTODO DE LAS 6’D En la siguiente figura se muestra el Método de las 6’D con sus respectivas etapas:

Descripción Problema

Definición Solución

Document.

Ingeniería Reversa

Etapa 01

Etapa 02

Etapa 06

Diseño Solución

DesarrolloSolución

Depuración Pruebas

n veces

Etapa 03

Etapa 04

Etapa 05


Pag. 28

ETAPAS Y PASOS

Descripción de la Etapa 01 – “Descripción del Problema”:

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

Descripción del Problema

METODO 6’D.

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 una tarea agotadora ya que generalmente existen muchas opiniones de cual es el problema central. Identificarlo es una de las tareas más importante que los analistas deben afrontar. Identificado el problema es necesario poder comprenderlo en su totalidad, es decir, comprender qué es exactamente lo que se desea que se resuelva. Finalmente se deberá escribir un enunciado claro, concreto y conciso del problema a resolver.

ENUNCIADO

PASOS:

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


Pag. 29

Descripción de la Etapa 02 – “Definición de la Solución”:

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

PASOS:

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 de sus partes para facilitar su comprensión y posterior solución. Esta es una regla que siempre deberá ser aplicada se utilice o no una computadora en la solución de un problema. Una vez entendido el problema, se está en condiciones de estudiarlo a fondo y plantear diversas alternativas que permitan solucionar el problema, para finalmente, seleccionar la alternativa mas adecuada.

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

METODO 6’D.


Pag. 30

Descripción de la Etapa 03 – “Diseño de la Solución”:

El resultado obtenido en esta etapa son los diagramas y los algoritmos que especifican cómo se debe hacer para solucionar el problema.

Diseño de la Solución

METODO 6’D.

Etapa 03

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

Desarrollo de Algoritmos.

PASOS:

DIAGRAMAS Y ALGORITMOS

Definida la solución, se procede a diseñar la lógica modelando y desarrollando algoritmos.

Para el modelado de la solución del problema se utiliza el Lenguaje Unificado de Modelado (Unified Modeling Language, UML), el cual es una herramienta usada para describir clases, objetos y sus relaciones.

Para el desarrollo de algoritmos se utiliza Pseudocódigos o Diagramas de Flujo (DF), los cuales son herramientas utilizadas para diseñar los algoritmos de los diferentes métodos de una clase.

Finalizado el desarrollo de los algoritmos es necesario verificar si se ha incluido soluciones para todas las formas en que se presente el problema. A este tipo de prueba se le denomina “Prueba de escritorio”.


Pag. 31

Descripción de la Etapa 04 – “Desarrollo de la Solución”:

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

Desarrollo de la Solución

METODO 6’D.

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

PASOS:

PROGRAMAS

Codificar el proyecto.

Desarrollar comentarios internos en los programas de computadora.

Desarrollar copias de seguridad de los programas de computadora.


Pag. 32

Descripción de la Etapa 05 – “Depuración y Pruebas”:

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

Depuración y Pruebas

METODO 6’D.

Etapa 05 Luego que se codifiquen los programas y/o clases, deben ser probados mediante la ejecución de los mismos (esto es conocido como corrida del programa). Al realizarse ésta, pueden surgir diferentes tipos de errores, siendo los errores de lógica y sintaxis los más comunes. Hay que corregir el programa; anular, modificar o crear nuevas sentencias, volver a probar el programa y continuar con la corrección y pruebas hasta conseguir el resultado deseado.

Realizar la depuración y verificar la correcta escritura de los programas.

Realizar pruebas de sintaxis. Realizar pruebas de lógica.

PASOS:

PRUEBAS


Pag. 33

Descripción de la Etapa 06 – “Documentación”:

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

Documentación

METODO 6’D.

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

ManualesManualesManualesManuales

Recopilar el material generado en cada una de las etapas anteriores.

Generar el manual del programa. Generar el manual del usuario.


Pag. 34

Adicionalmente es posible realizar “Ingeniería Reversa” entre las Etapas 03, 04 y 05:

METODO 6’D.

La ingeniería reversa nos permite crear o actualizar el modelo preliminar realizado en la ETAPA 03 “Diseño de la solución” a partir del código del programa realizado en la ETAPA 04 “Desarrollo de la solución” y corregido en la ETAPA 05 “Depuración y pruebas”. Es decir, a través de la Ingeniería Reversa es posible programar o codificar algunas partes (hasta su correcto funcionamiento) que no estén especificadas en la Etapa 03 “Diseño de la Solución”. A partir de esta solución se actualizan los diagramas de la Etapa 03 y se continúa con el proceso hasta llegar a la solución deseada.

• Exportar proyecto (archivos class o java) al disco de la PC, si está trabajando con un IDE.

• Importar proyecto (archivos class o java) a una herramienta CASE y realizar la ingeniería reversa.

• Organizar el modelo obtenido en la herramienta CASE.

PASOS:

n veces

Diseño Solución

Desarrollo Solución

DepuraciónPruebas

Etapa 03

Etapa 04

Etapa 05

Ingeniería Reversa

DIAGRAMAS ACTUALIZADOS

MÉ

TOD

O D

E LA

S 6

’D –

Un

Enf

oque

Alg

orítm

ico.

P

ag. 3

5

RES

UM

EN D

EL M

ÉTO

DO

Res

umen

de

las

etap

as y

los

paso

s de

l mét

odo:

Id

entif

icac

ión

del p

robl

ema.

Des

crip

ción

ge

nera

l de

l pr

oble

ma.

Enun

ciad

o cl

aro

y pr

ecis

o de

l pro

blem

a.

MET

OD

O 6

’D.

Etap

a 01

Et

apa

02

Etap

a 03

Et

apa

04

Etap

a 05

Des

crip

ción

Prob

lem

a D

efin

ició

n So

luci

ón

Doc

umen

t. D

iseñ

o So

luci

ónD

esar

rollo

So

luci

ónD

epur

ació

n Pr

ueba

s

Etap

a 06

D

efin

ir el

re

sulta

do

dese

ado.

Det

erm

inar

lo

s da

tos

que

se d

eben

in

gres

ar

o ge

nera

r pa

ra

obte

ner

el

resu

ltado

des

eado

.

Det

erm

inar

la f

orm

a en

qu

e lo

s da

tos

será

n pr

oces

ados

pa

ra

trans

form

arlo

s en

info

rmac

ión.

D

efin

ir un

no

mbr

e pa

ra

el p

roye

cto.

Def

inic

ión

de

diag

ram

as,

rela

cion

es

y cl

ases

.

Des

arro

llo d

e Al

gorit

mos

.

C

odifi

car

el

proy

ecto

.

Des

arro

llar

com

enta

rios

inte

rnos

en

lo

s pr

ogra

mas

de

co

mpu

tado

ra.

D

esar

rolla

r co

pias

de

se

gurid

ad d

e lo

s pr

ogra

mas

de

co

mpu

tado

ra.

R

ealiz

ar

la

depu

raci

ón

y ve

rific

ar

la

corr

ecta

esc

ritur

a de

lo

s pr

ogra

mas

.

Rea

lizar

pru

ebas

de

sin

taxi

s.

R

ealiz

ar p

rueb

as

de ló

gica

.

R

ecop

ilar

el

mat

eria

l ge

nera

do

en c

ada

una

de la

s et

apas

ant

erio

res.

Gen

erar

el m

anua

l de

l pro

gram

a.

G

ener

ar e

l man

ual

del u

suar

io.

Ing.

Jua

n Jo

sé F

lore

s C

ueto

.

P

ag. 3

6

RES

ULT

AD

O D

E LA

S ET

APA

S D

EL M

ÉTO

DO

Res

ulta

do d

e la

s et

apas

del

Mét

odo:

MMaa nn

uu aall ee

ss

EN

UN

CIA

DO

ESP

EC

IFIC

AC

ION

ES

DIA

GR

AM

AS Y

A

LGO

RIT

MO

S

PR

OG

RA

MAS

PR

UE

BAS

MET

OD

O 6

’D.

Etap

a 01

Et

apa

02

Etap

a 03

Et

apa

04

Etap

a 05

Des

crip

ción

Pr

oble

ma

Def

inic

ión

Solu

ción

D

ocum

ent.

Dis

eño

Solu

ción

Des

arro

llo

Solu

ción

D

epur

ació

nPr

ueba

s

Etap

a 06


Pag. 37

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.

DefiniciónSolución

Etapa 02

Diseño Solución


Etapa 03

Etapa 04

ENUNCIADO

Etapa 01

MARCO DE TRABAJO

Descripción Problema


Pag. 38

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

MODELAMIENTO El modelamiento se refiere a la forma como se representa la solución de un problema del mundo real en términos de un modelo. 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:

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

Nombre del paquete.

NombrePaquete


Pag. 40

representa a ningún objeto en particular. En UML, una clase se representa de la siguiente forma:

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:

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

NombreClase(NombrePaquete al que pertenece)

Atributos

Métodos

Nombre de la clase y del paquete al cual pertenece la clase.

Lista de atributos de la clase.

Lista de métodos de la clase.

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

Diagramas de Casos de Uso

Diagramas de Colaboración

Diagramas de Componentes

Diagramas deDistribución

Diagramas de Objeto

Diagramas de Estado

Diagramas de Secuencia

Diagramas de Clase

Paquete

Diagramas de Actividad

Modelo

NombreClase : nombreObjeto


Pag. 41

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:

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

Relación de dependencia unidireccional.


Pag. 42

Diseño Solución

Etapa 03

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

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

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

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.


Pag. 44


Pag. 45

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

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

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

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

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

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

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


Pag. 48

Elementos o símbolos básicos:

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

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

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

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

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


Pag. 49

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

LEER LEER x

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

ESCRIBIR ESCRIBIR “Hola” ESCRIBIR x ESCRIBIR x + z

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

COMENTARIO COMENTARIO “Variables”

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

NUMERO NUMERO x

Permite declarar una variable de tipo numérico.

TEXTO TEXTO mensaje

Permite declarar una variable de tipo texto o cadena.

CARACTER CARACTER letra

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

LÓGICO LÓGICO aprobado

Permite declarar una variable de tipo lógico.

VERDADERO aprobado = VERDADERO

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

FALSO aprobado = FALSO

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

GRUPO 2

SI

SI (condición) ENTONCES

instrucciones... FINSI

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


Pag. 50


SI / SINO

SI (condición) ENTONCES

instrucciones... SINO

instrucciones... FINSI

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

CUANDO

CUANDO (variable) SEA CASO (valor 1) :

instrucciones...

CASO (valor 2) : instrucciones...

CASO (valor n) : instrucciones...

OTROS instrucciones.. FINCUANDO

Permite especificar una estructura de decisión múltiple “CUANDO... FINCUANDO”. Las estructuras lógicas serán tratadas en el capítulo II.

DESDE

DESDE i = valorInicial HASTA valorFinal instrucción 1

. . .

instrucción n FINDESDE

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

MIENTRAS

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

FINMIENTRAS

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

HACER

HACER instrucción 1 . . . instrucción n

MIENTRAS (condición)

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

TERMINAR TERMINAR

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

CONTINUAR CONTINUAR

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


Pag. 51


GRUPO 3

COSENO x = COSENO n

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

SENO x = SENO n

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

LONGITUD x = LONGITUD n

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

FILA x = FILA n

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

COLUMNA x = COLUMNA n

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

MAYÚSCULA x = MAYÚSCULA n

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

MINUSCULA x = MINUSCULA n

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

GRUPO 4

RESTO x = z RESTO n

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

DIVIDIR x = z DIVIDIR n

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

RAIZ x = z RAIZ n

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


Pag. 52


POTENCIA x = z POTENCIA n

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

MAXIMO x = z MAXIMO n

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

MINIMO x = z MINIMO n

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

CARACTER x = z CARACTER n

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

ALEATORIO x = z ALEATORIO n

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

GRUPO 5

SUBCADENA x = z SUBCADENA n1, n2

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

ELIMINAESPACIO x = z ELIMINAESPACIO n1, n2

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

GRUPO 6

CREAR

CREAR vector[n]

CREAR matriz[n1][n2]

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

CREAR CREAR objeto

Permite crear un objeto de una determinada clase

EJECUTAR EJECUTAR algoritmo

Permite ejecutar otro algoritmo.


Pag. 53

Diseño Solución

Etapa 03


PARAMETRO PARAMETRO listaVariables

Permite especificar si un algoritmo recibe datos o valores.

RETORNAR RETORNAR variable

Permite especificar si un algoritmo 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”: 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. 54

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

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[ ] ) { } } 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

… sentencias; …

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


Pag. 56

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

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

DesarrolloSolución

Etapa 04


Pag. 58

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.

Capítulo

2

ESTRUCTURAS FUNDAMENTALES PARA LA SOLUCIÓN DE PROBLEMAS

Pag. 61

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.


Etapa 02

Diseño Solución


Etapa 03

Etapa 04

ENUNCIADO DEL

PROBLEMA

MARCO DE TRABAJO


Pag. 62

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.

DECLARACIÓN Y DEFINICIÓN DE DATOS

LISTA DE PASOS

DESCRIPCIÓN DE DATOS

SENTENCIAS

ALMACENADOS EN: • Estructuras de datos tipo variables.

SE DESARROLLAN UTILIZANDO: • Estructuras lógicas de secuencia. • Estructuras lógicas de decisión. • Estructuras lógicas de repetición. • Instrucciones de bifucación.


Pag. 63

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

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.

En pseudocódigo y diagrama de flujo: variable = valor

En Java: variable = valor ;

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


suma = 7 + 5


Pag. 65

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

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

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

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

int Entero 4 bytes -2.147.483.648 2.147.483.647

long Entero largo 8 bytes -9.223.372.036.854.775.808 9.223.372.036.854.775.807

float Real en coma flotante de simple precisión 4 bytes ±3,4*10-38 … ±3,4*1038

double Real con coma flotante de doble precisión. 8 bytes ±1,7*10-308 … ±1,7*10308

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

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 ; // La siguiente línea genera error. numRealFloat = numRealDouble ; System.out.println ( numRealFloat ) ;

} }

Observación: No se puede almacenar un número real grande (double) en una variable real (float).


Pag. 70

Clase PrgTipoDato03



boolean estado = true ; char caracter ; // La siguiente línea genera error. caracter = estado ; System.out.println ( caracter ) ;

} }

Observación: No se puede almacenar un valor lógico (boolean) en una variable caracter (char).


Pag. 71

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;

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.

Clase PrgTipoDato04



int numEntero = 5 ; long numEnteroGrande ; // La siguiente línea no genera error. numEnteroGrande = numEntero ; // Se visualiza 5 System.out.println ( numEnteroGrande ) ;

} }


Pag. 72

Observación: Al ejecutar esta aplicación el compilador utiliza la conversión implícita y convierte la letra ‘a’ en un valor real (double) equivalente a su código ASCII, por lo que se visualiza 97.0 (la letra a en código ASCII es 97).

La conversión implícita de datos se realiza al mezclar variables de distinto tipo en expresiones matemáticas o al ejecutar instrucciones o sentencias de asignación. En ambos casos, es necesario que el lado izquierdo de la expresión tenga un tipo de dato más amplio que el resultado de evaluar el lado derecho:

numReal = numEntero + 5 ; 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

Clase PrgTipoDato05



char caracter = ‘a’ ; double numReal ; // La siguiente línea no genera error. numReal = caracter ; // Se visualiza 97.0 System.out.println ( numReal ) ;

} }

Lado izquierdo de la expresión


Pag. 73

el tipo de dato al que se desea convertir el resultado de una expresión. Ejemplo;

Observación: Al ejecutar esta aplicación el compilador utiliza la conversión explícita (casting) para poder almacenar el resultado de una división de numeros reales (double) en una variable entera (int).

Finalmente, en el capítulo III se tratán las clases Wrappers que envuelven los tipos de datos simples y también permiten realizar operaciones de conversión, entre otras.

Clase PrgTipoDato06



double num1 = 20, num2 = 3 ; int div ; // La siguiente línea genera error. div = num1 / num2 ; System.out.println ( div ) ;

} }

Clase PrgTipoDato07



double num1 = 20, num2 = 3 ; int div ; // La siguiente línea no genera error. div = ( int ) ( num1 / num2 ) ; // Se visualiza 6. System.out.println ( div ) ;

} }


Pag. 74


Pag. 75

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

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

“Hola Mundo”


Pag. 77

- La clase;

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

CLASE MÉTODO DESCRIPCIÓN

leerString()

Permite ingresar una cadena de texto.

leerChar()

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

leerInt()

Permite ingresar un número entero.

leerLong()

Permite ingresar un número entero largo.

leerFloat()

Permite ingresar un número con parte decimal.

Lectura.class

leerDouble()

Permite ingresar un 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. Esta clase es una implementación mejorada de la clase Math21 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. 78

3. Estructura para operaciones aritméticas y de cálculo

Definición:

Las operaciones aritméticas y de cálculo se refieren a la forma o mecanismos que se emplean para poder procesar los datos ingresados y obtener la información necesaria.

Representación: Para representar las operaciones aritméticas se utilizan los mismos signos que se emplean en la aritmética tradicional (+, -, *, /). Suma: + Resta: - Multiplicación: * División: / Las operaciones lógicas se representan de la siguiente manera: En pseudocódigo y diagrama de flujo: Y lógico: 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

INICIO Instrucciones ... FIN

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


Pag. 79

Diagrama de Flujo

Instrucciones ...

Al conjunto de pasos que forman parte de un algoritmo se les denomina instrucciones.

Formato para codificar algoritmos:

Lenguaje de Programación Java

class NombreClase {

public static void main (String a[]) {

.... // sentencias ....

} }

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

EXPLICACIÓN:

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

EXPLICACIÓN: Todas las instrucciones que son parte de la solución del problema aparecerán entre el siguiente símbolo:

Dentro del símbolo se indicará si es el inicio o el fin de la solución con las reglas INICIO o FIN.

INICIO

FIN


Pag. 80

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

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

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


Pag. 81

Diagrama de Flujo



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

FALSO

VERDADERO condición ?

... instrucciones...

...

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

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


Pag. 82

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

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

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


Pag. 83

Diagrama de Flujo



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

VERDADERO

... instrucciones

...

FALSO condición ?

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

... instrucciones

...

EXPLICACIÓN: Si la condición resulta verdadera, se ejecutan las sentencias que se encuentran entre las llaves { } ubicadas después de la palabra reservada if. 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. 84

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

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

FINCUANDO

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


Pag. 85

Diagrama de Flujo

variable ?

instrucciones

instrucciones

instrucciones

instrucciones

valor 1 valor 2 valor n OTROS

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



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

}

Es importante tener presente que en Java se deberá usar la palabra reservada break al final de cada bloque de sentencias si se desea que cada alternativa (case) ejecute un grupo de sentencias sin que ejecute el grupo de sentencias de las alternativas (case) que 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.

EXPLICACIÓN: Si el valor de la variable es igual a uno de los valores colocados después de la palabra reservada case (valor 1, valor 2, etc), se ejecutan las sentencias que están dentro del mismo hasta llegar al final (es decir hasta la llave) a no ser que encuentre una palabra reservada break entre las sentencias que se ejecutan. Si el valor de la variable no es igual a ninguno de los valores colocados después de una de las palabras reservadas case, se ejecutan las sentencias que están dentro de la palabra reservada default. La palabra reservada default es opcional (es decir puede aparecer como no).


Pag. 87

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

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

Diagrama de Flujo

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.

INCREMENTA x

DESDE i HASTA z

VERDADERO

FALSO


...


Pag. 90



for ( i = valorInicial ; condición ; incremento) { sentencias... }

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

2. Estructura lógica de repetición “MIENTRAS” Definición:

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


Pag. 91


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. Si el resultado de evaluar la condición lógica es falsa, no se ejecutan las instrucciones que están dentro de la estructura lógica de repetición MIENTRAS... FINMIENTRAS y se continúa con la ejecución del algoritmo.

Esto significa que mientras la evaluación de la condición lógica resulte verdadera, se ejecutará la estructura lógica de repetición MIENTRAS... FINMIENTRAS y que sólo finalizará cuando la evaluación de la condición lógica resulte falsa.

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


Pag. 92

Diagrama de Flujo



while (condición) { sentencias... }

FALSO

condición ?

VERDADERO


...


Pag. 93

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

3. Estructura lógica de repetición “HACER” Definición:

Una estructura lógica de repetición “HACER... MIENTRAS”, al igual que una estructura lógica de repetición “DESDE... FINDESDE” y una estructura lógica de repetición “MIENTRAS... FINMIENTRAS”, permite repetir una instrucción o un bloque de instrucciones mientras que una condición se cumpla o sea verdadera. La principal diferencia entre ambos consiste en que la estructura lógica de repetición “MIENTRAS... FINMIENTRAS” prueba la condición antes de ejecutar la instrucción o bloque de instrucciones, lo que hace posible que dichas instrucciones no se ejecuten si la condición es falsa la primera vez que se prueba la condición. La estructura lógica de repetición “HACER... MIENTRAS” ejecuta al menos una vez las instrucciones o bloque de instrucciones antes de probar la condición. Este tipo de estructura es útil cuando se necesita repetir una instrucción o bloque de instrucciones un número de veces no determinado, siendo necesario ejecutar la instrucción o bloque de instrucciones por lo menos una vez.


Pag. 94


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:

Si el resultado de evaluar la condición lógica es verdadero, se procede a ejecutar, nuevamente, las instrucciones que están dentro de la estructura lógica de repetición HACER... MIENTRAS y se evalúa, nuevamente la condición lógica. Si el resultado de evaluar la condición lógica es falso, se continúa con la ejecución del algoritmo.

Esto significa que la estructura lógica de repetición HACER... MIENTRAS se ejecuta por lo menos una vez antes de ser evaluada la condición lógica. Si al evaluar la condición lógica ésta resulta verdadera, se vuelve a ejecutar la estructura; caso contrario, finaliza la ejecución de la estructura, continuando con la siguiente instrucción del algoritmo.


Pag. 95

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



do { sentencias... } while (condición) ;

FALSO

condición ? VERDADERO

... instrucciones

...

...


Pag. 96

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


Pag. 97

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

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:

“DESDE”

“MIENTRAS”

“HACER”

Estructuras Lógicas.

Estructuras Lógicas de Secuencia.

Estructuras Lógicas de Decisión.

Estructuras Lógicas de Repetición.

Instrucciones de Bifurcación.

“SI”

“SI / SINO”

“CUANDO”

“LEER”

“ESCRIBIR”

“PROCESAR”

“TERMINAR”

“CONTINUAR”

“RETORNAR”

ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS

Pag. 99

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.

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.

• Determinar la información deseada (salida).

• Determinar los datos de entrada (entrada).

• Establecer como se solucionará el problema (proceso).

• Determinar el nombre del

proyecto. • Definir los paquetes y

desarrollar el diagrama de paquetes respectivo. Establecer la dependencia. (Utilice UML).

• Definir las clases que serán parte de la solución del problema. (Utilice UML).

• Diseñar el algoritmo para el

método principal. Se utiliza pseudocódigo.

• Codificar el diseño de la

solución del problema. Se utiliza el lenguaje de programación Java.


Diseño Solución


ENUNCIADO DEL

PROBLEMA Etapa 02 Etapa 03 Etapa 04


Pag. 100


Pag. 101

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

main()

PrgMensaje


Pag. 102

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

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

INICIO

TEXTO mensaje mensaje = “ Hola bienvenido ” ESCRIBIR mensaje

FIN

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

Clase PrgMensaje

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

// La ejecución empieza en el método main. public static void main ( String arg [ ] ) {

String mensaje ; mensaje = “ Hola bienvenido ” ; System.out.print (mensaje) ;

} }

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


Pag. 103

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 ”

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

A continuación: ESCRIBIR mensaje


Pag. 104

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

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

Los pasos que están entre las palabras INICIO… FIN constituyen la parte más importante del algoritmo y es conocido como “cuerpo del algoritmo”.

Ahora, analicemos cada línea de la codificación del algoritmo en el lenguaje de programación Java: En primer lugar, observamos que el programa empieza con las siguientes líneas:

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

/* Este es el primer programa. Aunque es sencillo podemos apreciar los elementos básicos de un programa en Java. */


Pag. 105

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

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.


package dominioDeLaAplicacion ;

class PrgMensaje {

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



Pag. 106

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:


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.


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

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

String mensaje ;

mensaje = “ Hola bienvenido ” ;


Pag. 107

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.


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.

System.out.print (mensaje) ;

} }

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


Pag. 108

Problema 02 Etapas para la solución de un problema:

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

Resultado deseado: 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

main()

PrgOperaciones


Pag. 109

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

Algoritmo PrgOperaciones - método main() ENTRADA: SALIDA: suma, multi, resta,divi

INICIO

NUMERO num1=9121236, num2=735 NUMERO suma, multi, resta, divi suma = num1 + num2 multi = num1 * num2 resta = num1 - num2 divi = num1 / num2 ESCRIBIR “La suma es ” + suma ESCRIBIR “La multiplicación es ” + multi ESCRIBIR “La resta es ” + resta ESCRIBIR “La división es ” + divi

FIN

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

Clase PrgOperaciones package dominioDeLaAplicacion; class PrgOperaciones {

// la ejecución empieza en main. public static void main ( String arg[ ] ) {

long num1=9121236, num2=735, suma, resta, multi; double divi; suma = num1 + num2; resta = num1 – num2; multi = num1 * num2; divi = (double) (num1) / num2; System.out.println (“La suma es: ” + suma); System.out.println (“La resta es: ” + resta); System.out.println (“La multiplicación es: ” + multi); System.out.println (“La división es: ” + divi);

} }


Pag. 110

Problema 03

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

Resultado deseado: Mostrar el equivalente, en nuevos soles, de

una cantidad expresada en dólares. 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. 111

3. Definición de las Clases.

Clases dominioDeLaAplicacion

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


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

Problema 04

Etapa 01 - Descripción del problema. Calcular la nota final que ha obtenido un alumno en el curso de programación avanzada. Utilizar la siguiente fórmula: nf = (n1 + n2 + n3 + (n4 * 2)) / 5. Ingresar las notas n1, n2, n3 y n4 a través del teclado.

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

Resultado deseado: 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

El resultado se almacenará en una variable (nf) para luego ser mostrada por pantalla.


1. Nombre del Proyecto: ProyNotaFinal.




Pag. 114



Clases biblioteca


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


Clase PrgNotaFinal


import biblioteca.Lectura ; 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 ( ) ; System.out.print ( “ Ingrese la nota 2 del alumno: ” ) ; n2 = Lectura.leerDouble ( ) ; System.out.print ( “ Ingrese la nota 3 del alumno: ” ) ; n3 = Lectura.leerDouble ( ) ; System.out.print ( “ Ingrese la nota 4 del alumno: ” ) ; n4 = Lectura.leerDouble ( ) ; nf = ( n1 + n2 + n3 + ( n4 * 2)) / 5 ; System.out.print ( “ El promedio obtenido por el alumno es : ” ) ; System.out.println ( nf ) ;

} }


Pag. 116

Problema 05

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

Resultado deseado: Mostrar el total de descuento y el sueldo a

cobrar de un obrero de la empresa. 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. 117



Clases biblioteca


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

Etapa 04 - Desarrollo de la Codificación.

La codificación se desarrolla utilizando el lenguaje de programación Java.

Clase PrgSueldoObrero


import biblioteca.Lectura ; 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. 119

Problema 06

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

Resultado deseado: Calcular y mostrar la temperatura en grados

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



Clases biblioteca


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


Clase PrgTemperatura

package dominioDeLaAplicacion ; import biblioteca.Lectura ; class PrgTemperatura {

public static void main ( String arg[] ) {

double gradosCel = 0, gradosFar = 0 ; System.out.print ( “ Ingrese la temperatura en grados Celsius: " ) ; gradosCel = Lectura.leerDouble ( ) ; gradosFar = ( 9 / 5 ) * gradosCel + 32 ; System.out.println ( “ La temperatura en grados Fahrenheit es: " + gradosFar) ;

}

}


Pag. 122

Problema 07

Etapa 01 - Descripción del problema.

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

Resultado deseado: 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. 123



Clases biblioteca


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


Clase PrgUtilidad


import biblioteca.Lectura ; 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. 125

Problema 08

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

Resultado deseado: Mostrar nota final y un mensaje de

felicitaciones si la nota final es mayor a 13. 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. 126



Clases biblioteca


Algoritmo PrgNotaFinal2 - método main ( )

ENTRADA: nota1, nota2 SALIDA: nf, mensaje

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

mensaje = “Felicitaciones” FINSI ESCRIBIR nf, mensaje

FIN


Pag. 127


Clase PrgNotaFinal2


import biblioteca.Lectura ; 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. 128

Problema 09

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

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

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


1. Nombre del Proyecto: ProySueldoTrabajador.




Pag. 129



Clases biblioteca


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


Clase PrgSueldoTrabajador


import biblioteca.Lectura ; 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. 131

Problema 10

Etapa 01 - Descripción del problema. Calcular y mostrar el monto total a pagar por la compra de varios artículos si se tiene que agregar el IGV (Impuesto General a las Ventas). En caso que el monto total a pagar incluido IGV sea mayor a S/.500 nuevos soles se aplica un descuento de 8%, caso contrario el descuento será de 2%.


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



Clases biblioteca


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


Clase PrgArticulos


import biblioteca.Lectura ; 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. 134

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


Clases

dominioDeLaAplicacion Clases

biblioteca


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 : nuevoSueldo = sueldo * 1.15 TERMINAR CASO 3 : nuevoSueldo = sueldo * 1.10 TERMINAR CASO 4 : nuevoSueldo = sueldo * 1.05 TERMINAR OTROS :

nuevoSueldo = sueldo FINCUANDO ESCRIBIR nuevoSueldo

FIN


Pag. 136


Clase PrgAumentoSueldo package dominioDeLaAplicacion ; import biblioteca.Lectura ; class PrgAumentoSueldo {


double sueldo = 0, nuevoSueldo = 0 ; int categoria = 0; System.out.print ( “ Ingrese el sueldo del trabajador: ” ) ; sueldo = Lectura.leerDouble ( ) ; System.out.print ( “ Ingrese la categoría del trabajador: ” ) ; categoria = Lectura.leerInt ( ) ; switch (categoria) {

case 1: nuevoSueldo = sueldo * 1.25 ; break ;




default: nuevoSueldo = sueldo ;

} System.out.println ( “ El nuevo sueldo del trabajador es: ” + nuevoSueldo ) ;

} }


Pag. 137

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


1. Nombre del Proyecto: ProyHospital.





Clases biblioteca


Pag. 139


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 : costoTotal = 350 * dias

TERMINAR CASO 3 :

costoTotal = 420 * dias SI ( sexo = 1 ) ENTONCES

costoTotal = costoTotal * 1.05 FINSI

FINCUANDO ESCRIBIR costoTotal

FIN


Pag. 140


Clase PrgHospital package dominioDeLaAplicacion ; import biblioteca.Lectura ; 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 :

costoTotal = 350 * dias ; break ;

case 3 :

costoTotal = 420 * dias ; if ( sexo == 1 ) {

costoTotal = costoTotal * 1.05 ; }

} System.out.println ( “ El costo total es: ” + costoTotal ) ;

} }


Pag. 141

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.

Etapa 03 - Diseño de la lógica.

1. Nombre del Proyecto: ProyOrdena.

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




Clases biblioteca


Pag. 142


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


Clase PrgOrdena package dominioDeLaAplicacion ; import biblioteca.Lectura ; 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: ” ) ; n2 = Lectura.leerInt ( ) ; System.out.print ( “ Ingrese la tercera nota: ” ) ; n3 = Lectura.leerInt ( ) ; if (n1 > n2) {

if (n1 > n3) { mayor = n1 ; if (n2 > n3) {

intermedio = n2 ; menor = n3 ;

} else { intermedio = n3 ; menor = n2 ;

} } else {

mayor = n3 ; intermedio = n1 ; menor = n2 ;

} } else {

if (n2 > n3) { mayor = n2 ; if ( n1 > n3) {

intermedio = n1 ; menor = n3 ;

} else { intermedio = n3 ; menor = n1 ;

} } else {

mayor = n3 ; intermedio = n2 ; menor = n1 ;

} } System.out.println ( menor + “ ” + intermedio + “ ” + mayor ) ;

} }


Pag. 144

Problema 14

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

Rango 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. Etapa 02 - Definición de la solución.

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


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




Clases biblioteca


Pag. 146


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


FINSI


FINSI

promedio = (sumaNotas - notaMenor) / 4

SI (promedio <= 20 AND promedio >= 17) ENTONCES

categoria = ‘A’ SINO

SI (promedio <= 16 AND promedio >= 14) ENTONCES categoria = ‘B’ SINO SI (promedio <= 13 AND promedio >= 10) ENTONCES categoria = ‘C’ SINO SI (promedio<=10 AND promedio>=0) ENTONCES categoria = ‘D’ FINSI FINSI FINSI

FINSI ESCRIBIR categoria

FIN


Pag. 147


Clase PrgCategoriaAlumno package dominioDeLaAplicacion ; import biblioteca.Lectura ; 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: ” ) ; n1 = Lectura.leerDouble ( ) ; System.out.print ( “ Ingrese la 2da. nota: ” ) ; n2 = Lectura.leerDouble ( ) ; System.out.print ( “ Ingrese la 3ra. nota: ” ) ; n3 = Lectura.leerDouble ( ) ; System.out.print ( “ Ingrese la 4ta. nota: ” ) ; n4 = Lectura.leerDouble ( ) ;

System.out.print ( “ Ingrese la 5ta. nota: ” ) ; n5 = Lectura.leerDouble ( ) ;

sumaNotas = n1 + n2 + n3 + n4 + n5 ; notaMenor = n1 ; if (notaMenor > n2) notaMenor = n2 ; if (notaMenor > n3) notaMenor = n3 ; if (notaMenor > n4) notaMenor = n4 ; if (notaMenor > n5)

notaMenor = n5 ;

promedio = (sumaNotas - notaMenor) / 4 ;

if (promedio <= 20 && promedio >= 17) { categoria = ‘A’ ; } else { if (promedio <= 16 && promedio >= 14) { categoria = ‘B’ ; } else { if (promedio <= 13 && promedio >= 10) { categoria = ‘C’ ; } else { if (promedio <= 10 && promedio >= 0) { categoria = ‘D’ ; } } } } System.out.println ( “ La categoría del alumno es: ” + categoria ) ;

} }


Pag. 148

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

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


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



Pag. 149



Clases biblioteca


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


Clase PrgCategoriaPostulante

package dominioDeLaAplicacion ; import biblioteca.Lectura ; 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. 151

Problema 16

Etapa 01 - Descripción del problema. Calcular la nota final de todos los alumnos del curso utilizando la siguiente fórmula:

nf = ( n1 + n2 + n3 + ( n4 * 2 ) ) / 5

Ingresar las notas a través del teclado. Utilizar la estructura lógica MIENTRAS. Etapa 02 - Definición de la solución.

Resultado deseado: 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

través del teclado y se almacenan en variables (n1, n2, n3 y n4). Se realizará el cálculo de la nota final en base a la fórmula:

nf = ( n1 + n2 + n3 + ( n4 * 2 ) ) / 5. El resultado es almacenado en la variable (nf) para luego ser mostrada. Esto se repite para todos los alumnos del curso, con la finalidad de poder mostrar la nota final de cada uno de ellos.


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



Pag. 152



Clases biblioteca


Algoritmo PrgNotasAlumnos - método main ( ) ENTRADA: numAlumnos, n1, n2, n3, n4 SALIDA: nf

INICIO NUMERO i = 1, n1 = 0, n2 = 0, n3 = 0, n4 = 0, nf = 0 NUMERO numAlumnos = 1 LEER numAlumnos MIENTRAS ( i <= numAlumnos )

LEER n1, n2, n3, n4 nf = ( n1 + n2 + n3 + ( n4 * 2 ) ) / 5 ESCRIBIR nf i = i + 1

FINMIENTRAS

FIN


Pag. 153


Clase PrgNotasAlumnos package dominioDeLaAplicacion ; import biblioteca.Lectura ; 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 + “]: ” ) ; n1 = Lectura.leerDouble ( ) ; System.out.println ( “ Ingrese nota 2 del alumno [” + i + “]: ” ) ; n2 = Lectura.leerDouble ( ) ; System.out.println ( “ Ingrese nota 3 del alumno [” + i + “]: ” ) ; n3 = Lectura.leerDouble ( ) ; System.out.println ( “ Ingrese nota 4 del alumno [” + i + “]: ” ) ; n4 = Lectura.leerDouble ( ) ; nf = ( n1 + n2 + n3 + ( n4 * 2 ) ) / 5 ; System.out.println ( “ Nota final del alumno [” + i + “]: ” + nf ) ; i ++ ;

} }

}


Pag. 154

Problema 17

Etapa 01 - Descripción del problema. Calcular la nota final de todos los alumnos del curso utilizando la siguiente fórmula:

nf = ( n1 + n2 + n3 + ( n4 * 2 ) ) / 5.

Ingresar las notas a través del teclado. Utilizar la estructura lógica HACER. Etapa 02 - Definición de la solución.

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

través del teclado y se almacenan en variables (n1, n2, n3 y n4). Se realizará el cálculo de la nota final sobre la base de la fórmula:

nf = ( n1 + n2 + n3 + ( n4 * 2 ) ) / 5. El resultado es almacenado en la variable (nf) para luego ser mostrada. Esto se repite para todos los alumnos del curso con la finalidad de poder mostrar la nota final de cada uno de ellos.


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



Pag. 155



Clases biblioteca


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


Clase PrgNotasAlumnos2 package dominioDeLaAplicacion ; import biblioteca.Lectura ;

class PrgNotasAlumnos2 {


int i = 1 ; double n1 = 0, n2 = 0, n3 = 0, n4 = 0, nf = 0 ; char continua = ‘ ’ ; do {

System.out.println ( “ Ingrese nota 1 del alumno [” + i + “]: ” ) ; n1 = Lectura.leerDouble ( ) ; System.out.println ( “ Ingrese nota 2 del alumno [” + i + “]: ” ) ; n2 = Lectura.leerDouble ( ) ; System.out.println ( “ Ingrese nota 3 del alumno [” + i + “]: ” ) ; n3 = Lectura.leerDouble ( ) ; System.out.println ( “ Ingrese nota 4 del alumno [” + i + “]: ” ) ; n4 = Lectura.leerDouble ( ) ; nf = ( n1 + n2 + n3 + ( n4 * 2 ) ) / 5 ; System.out.println ( “ Nota final del alumno [” + i + “]: ” + nf ) ; System.out.println ( “ Desea continuar (s/n): ” ) ; continua = Lectura.leerChar ( ) ; i++ ;

} while ( continua == ‘s’ || continua == ‘S’ ) ; }

}


Pag. 157

Problema 18

Etapa 01 - Descripción del problema. Determinar la suma de sueldos de los obreros (categoría 1), la suma de sueldos de los empleados (categoría 2) y la suma de sueldos de los gerentes (categoría 3) de una determinada empresa. Adicionalmente, determinar cuál es el mayor y el menor sueldo en la empresa. Etapa 02 - Definición de la solución.

Resultado deseado: 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. 158


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




Clases biblioteca


Pag. 159


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: sueldo2 = sueldo2 + sueldo TERMINAR

CASO 3: sueldo3 = sueldo3 + sueldo

FINCUANDO FINSI

MIENTRAS ( categoria <> 0 ) ESCRIBIR sueldo1, sueldo2, sueldo3 ESCRIBIR menorSueldo, mayorSueldo

FIN


Pag. 160


Clase PrgSueldoCategoria package dominioDeLaAplicacion ; import biblioteca.Lectura ; 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 : ” ) ; sueldo = Lectura.leerDouble ( ) ; if ( i == 1) {

i = 0 ; mayorSueldo = sueldo ; menorSueldo = sueldo ;

} else { if (sueldo < menorSueldo ) {

menorSueldo = sueldo ; } if (sueldo > mayorSueldo ) {

mayorSueldo = sueldo ; }

} switch (categoria) {

case 1: sueldo1 = sueldo1 + sueldo ; break ;

case 2: sueldo2 = sueldo2 + sueldo ; break ;

case 3: sueldo3 = sueldo3 + sueldo ;

} }

} while (categoria != 0 ) ; System.out.println ( “ Suma de sueldos de obreros: ” + sueldo1 ) ; System.out.println ( “ Suma de sueldos de empleados: ” + sueldo2 ) ; System.out.println ( “ Suma de sueldos de gerentes: ” + sueldo3 ) ; System.out.println ( “ El sueldo más bajo es: ” +menorSueldo ) ; System.out.println ( “ El sueldo más alto es: ” + mayorSueldo ) ;

} }


Pag. 161

Problema 19

Etapa 01 - Descripción del problema. Calcular y mostrar el número de alumnos que tienen promedio final menor que 10, los alumnos que tiene promedio final entre 10 y 14, los alumnos que tienen promedio final entre 15 y 18, y los alumnos que tienen promedio final mayor que 18. Ingresar las 4 notas de cada alumno y calcular su promedio final en base a la siguiente fórmula:

nf = ( n1 + n2 + n3 + ( n4 * 2 ) ) / 5. Etapa 02 - Definición de la solución.

Resultado deseado: 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.

Datos necesarios: Las cuatro notas de cada uno de los alumnos 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. 162


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




Clases biblioteca


Pag. 163


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 MIENTRAS (n3 < 0 OR n3 > 20) HACER

LEER n4 MIENTRAS (n4 < 0 OR n4 > 20) nf = (n1 + n2 + n3 + ( n4 * 2 ) ) / 5 SI (nf < 10.5) ENTONCES

total1 = total1 + 1 FINSI SI (nf >= 10.5 AND nf < 14.5) ENTONCES

total2 = total2 + 1 FINSI SI (nf >= 14.5 AND nf < 17.5) ENTONCES

total3 = total3 + 1 FINSI SI (nf >= 17.5) ENTONCES

total4 = total4 + 1 FINSI i = i + 1

FINMIENTRAS ESCRIBIR total1, total2, total3, total4

FIN


Pag. 164


Clase PrgNotasRango package dominioDeLaAplicacion ; import biblioteca.Lectura ; 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 + “]: ” ) ; n1 = Lectura.leerDouble ( ) ;

} while ((n1 < 0 || n1 > 20) ; do {

System.out.println ( “ Ingrese nota 2 del alumno [” + i + “]: ” ) ; n2 = Lectura.leerDouble ( ) ;

} while ((n2 < 0 || n2 > 20) ; do {


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

Problema 20

Etapa 01 - Descripción del problema. Elaborar una solución que permita controlar la venta de boletos en un determinado día en un teatro de la capital, en base a la siguiente información:

• Al comenzar, se leerá una sola vez el precio de entrada para palco, platea y mezanine.

• Por cada entrada vendida se leerá los siguientes datos: número de boleto y lugar (puede ser platea, palco o mezanine).

• El programa terminará cuando el número de boleto sea igual a cero. • Antes de finalizar, se deberá proporcionar la siguiente información:

• Número total de entradas vendidas durante el día. • El total de soles recaudados en el día. • Número de entradas vendidas para platea, palco y mezanine en el día.


Resultado deseado: 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. 166

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. 2. Definición de Paquetes y desarrollo del Diagrama de Paquetes.




Clases biblioteca


Pag. 167


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


Clase PrgTeatro package dominioDeLaAplicacion ; import biblioteca.Lectura ; 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. 169

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


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




Clases biblioteca


Pag. 171


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

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

package dominioDeLaAplicacion ; import biblioteca.Lectura ; 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. 173

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

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


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




Clases biblioteca


Pag. 176


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


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


Clase PrgClase

package dominioDeLaAplicacion ; import biblioteca.Lectura ; 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. 179


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


Pag. 181

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

package dominioDeLaAplicacion ; import biblioteca.Lectura ; 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. 182

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

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


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

Clase PrgVerificaFecha

If ( dia > 0 && dia <= 31 ) { verifdia = true ; } break ;

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


Pag. 184

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

} }


Pag. 185

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

package dominioDeLaAplicacion ; /** Clase: PrgNumRomano.java * Dado un año en números arábigos, imprimirlo en números romanos dentro de * rango de 1000 a 3000 * Programación Básica */ import biblioteca.Lectura ; class PrgNumRomano {


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

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

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

Problema 26


Desarrollar un programa que permita ingresar un número entero menor que 100 y permita mostrar su equivalente en letras.


Clase PrgNumALetras01

package dominioDeLaAplicacion ; import biblioteca.Lectura ; 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: ” ) ; num = Lectura.leerInt ( ) ; if ( num < 0 || num > 99 ) System.out.println ( “Número ingresado no válido... Reintente!!! ” ) ; } while ( num < 0 || num > 99 ) ; dec = num / 10 ; uni = num % 10 ; switch ( uni ) { case 0 : letra = cero ; break ; case 1 : letra = uno ; break ;


Pag. 189


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


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

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.



package dominioDeLaAplicacion ; import biblioteca.Lectura ; 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: ” ) ; num = Lectura.leerInt ( ) ; if ( num < 0 || num > 999 ) System.out.println ( “ Número ingresado no válido... Reintente!!! ” ) ; } while ( num < 0 || num > 999 ) ;

cen = num / 100 ; resto = num % 100 ; dec = resto / 10 ; uni = resto % 10 ;

switch ( uni ) { case 0 : letra = cero ; break ; case 1 : letra = uno ; break ;


Pag. 192


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


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


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

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:

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

try {

// Código de la aplicación. … … … … …

} catch ( ) {

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

}

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


Pag. 196

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:

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.

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

try {

// Código de la aplicació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. */ … …

}


Pag. 197

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

Excepción Descripción

ArithmeticException

Una condición aritmética excepcional ocurrio.

NumberFormatException

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

IOException

Problemas al realizar operaciones de entrada y salida de datos.

ArrayIndexOutOfBoundException

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

NullPointerException

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


Pag. 198

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

package dominioDeLaAplicacion ; import biblioteca.Lectura ; 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. 199

Clase PrgDivisionConExcepcion

package dominioDeLaAplicacion; 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. 200

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

package dominioDeLaAplicacion ; import biblioteca.Lectura ; 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. 201

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

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

package dominioDeLaAplicacion ; import biblioteca.Lectura ; 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. 203

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

} }

En este programa se captura la excepción NumberFormatException para prevenir que no se intente convertir una cadena con un formato inapropiado a un número. Puede probar el programa ingresando como fecha lo siguiente:

23/xx/2005

Es decir, en cualquier parte del formato indicado, ingrese letras en lugar de números (inclusive en el lugar del / ). Para poder entender la solución del programa sugiero que revise en el siguiente capítulo la clase Integer (Clase Wrapper) y la clase String.


Pag. 204

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

package dominioDeLaAplicacion ; import biblioteca.Lectura ; 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. 205

Clase PrgNumeroConExcepcion

} catch ( NumberFormatException error ) {

System.out.println ( “ Formato no válido ” ) ; valido = true ;

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

}

} else { valido = true ;

}

if ( valido ) { System.out.println ( “ Error... Ingrese en el formato indicado!!! ” ) ;

}

} while ( valido ) ;

} }

En este programa se captura la excepción NumberFormatException para prevenir que no se intente convertir una cadena con un formato inapropiado a un número. Puede probar el programa ingresando como números lo siguiente:

aaa//123

Es decir, en cualquier parte del formato indicado, ingrese letras en lugar de números (inclusive en el lugar de las // ). También se captura la excepción ArithmeticException para prevenir que no se intente dividir los números cuando el segundo número es cero. Puede probar el programa ingresando como números lo siguiente:

123//000

Para poder entender la solución del programa sugiero que revise en el siguiente capítulo la clase Integer (Clase Wrapper) y la clase String.


Pag. 206


Pag. 207

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


Pag. 209

Problema 32

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

Clase 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 ( ) ;

} }

}

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

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.


Pag. 210

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

Para fila=5: 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.

1ra fila ( i=1 ) * * * * * 2da fila ( i=2 ) * * * * * 3ra fila ( i=3 ) * * * * * 4ta fila ( i=4 ) * * * * * 5ta fila ( i=5 ) * * * * *

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

}

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

… } …

}


Pag. 211

Problema 33


Clase PrgCuadrado02






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



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


} }

}

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

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


Pag. 212

Problema 34


Clase PrgCuadrado03









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


} }

}

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



Pag. 213

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

Problema 35


Clase PrgTriangulo01

package dominioDeLaAplicacion;

import biblioteca.*; public class PrgTriangulo01 {

public static void main(String[] args) {





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



} }

}

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



Pag. 215

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

Para fila=5:

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

1ra fila ( i=1 ) * 2da fila ( i=2 ) * * 3ra fila ( i=3 ) * * * 4ta fila ( i=4 ) * * * * 5ta fila ( i=5 ) * * * * *

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

}

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

… } …

}


Pag. 216

se ejecutaría cinco veces y en cada una de las ejecuciones del for interno se mostraría un asterisco (en consecuencia se mostrarían en total cinco asteriscos). 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. 217

Problema 36










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



} }

}

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



Pag. 218

Problema 37










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



} }

}

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



Pag. 219

Problema 38









} while (totalFilas < 2 || totalFilas > 9 ) ; for ( i = totalFilas; i >= 1 ; i - - ) {

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



} }

}

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



Pag. 220

Problema 39









} while (totalFilas < 2 || totalFilas > 9 ) ; for ( i = totalFilas; i >= 1 ; i - - ) {

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



} }

}

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



Pag. 221

Problema 40






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 ) ;

} System.out.println ( ) ;

} }

}

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



Pag. 222

Problema 41










for ( j = 1 ; j <= i ; j++ ) { if ( k == 9 ) {

k = 0 ; } else {

k ++ ; } System.out.print ( k ) ;


} }

}

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



Pag. 223

Problema 42






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



} while (totalFilas < 2 || totalFilas > 9 ) ; k=totalFilas+1; for ( i = 1 ; i <= totalFilas; i++ ) {

for ( j = 1 ; j <= i ; j++ ) { if ( k == 1 ) {

k = totalFilas ; } else {

k - - ; } System.out.print ( k ) ;


} }

}

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



Pag. 224

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

Problema 43




import biblioteca.* ; public class PrgTriangulo09 {





} while (totalFilas < 2 || totalFilas > 20 ) ; for ( i = 1 ; i <= totalFilas; i ++ ) {

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

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

System.out.print ( “*” ) ; } System.out.println ( ) ;

} }

}

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

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



Pag. 226

Clase PrgTriangulo09Mejorado


import biblioteca.* ; public class PrgTriangulo09Mejorado {






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

if ( i < = j ) { System.out.print ( “*” ) ;

} else { System.out.print ( “ ” ) ;

} } System.out.println ( ) ;

} }

}


Pag. 227

Problema 44

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




import biblioteca.* ; public class PrgTriangulo10 {






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

if ( i < j ) { System.out.print ( “ ” ) ;

} else { System.out.print ( “*” ) ;


} }

}

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

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.


Pag. 228

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:



import biblioteca.* ; public class PrgTriangulo10Mejorado {




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


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

if ( j <= totalFilas - i ) { System.out.print ( “ ” ) ;

} else { System.out.print ( “*” ) ;


} }

}

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


Pag. 229

Problema 45







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 ) {


} while (totalFilas < 2 || totalFilas > 20 ) ; for ( i = 1 ; i <= totalFilas ; i++ ) {

for ( j = i ; j < totalFilas ; j++ ) { // Se muestra un espacio en blanco. System.out.print ( “ ”) ;

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

// Se muestra un asterisco y un espacio en blanco. System.out.print ( “* ”) ;

} // Se realiza un salto de linea. System.out.println ( ) ;

} }

}

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

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


Pag. 230

Análisis de la solución: Se ingresa el número de filas que va ha tener la figura y se almacena en la variable totalFilas, la cual puede variar desde 2 hasta 20. Para nuestra explicación asumiremos que el valor de totalFilas=5. 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:

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): 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:

1ra fila ( i=1 ) * 2da fila ( i=2 ) * * 3ra fila ( i=3 ) * * * 4ta fila ( i=4 ) * * * * 5ta fila ( i=5 ) * * * * *

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

}

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

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

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

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

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

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:

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

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

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

1ra fila ( i=1 ) - - - - 2da fila ( i=2 ) - - - 3ra fila ( i=3 ) - - 4ta fila ( i=4 ) - 5ta fila ( i=5 )

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

}

1ra fila ( i=1 ) * - 2da fila ( i=2 ) * - * - 3ra fila ( i=3 ) * - * - * - 4ta fila ( i=4 ) * - * - * - * - 5ta fila ( i=5 ) * - * - * - * - * -

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

}


Pag. 232



import biblioteca.*; public class PrgTriangulo11Mejorado {


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

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


} while (totalFilas < 2 || totalFilas > 20 ) ; for ( i = 1 ; i <= totalFilas ; i++ ) {

for ( j = 1 ; j < totalFilas * 2 ; j++ ) { if ( ( j >= totalFilas – cont ) && ( j <= totalFilas + cont ) ) {

// Se muestra unasterisco y un espacio en blanco. System.out.print ( “* ”) ; j ++ ;

} else { // Se muestra un espacio en blanco. System.out.print ( “ ”) ;

} } cont ++ ; System.out.println ( ) ;

} }

}

Análisis de la solución: Imagínese ahora al triángulo como si este fuera un rectángulo (complete con guiones los espacios en blanco que tendría la figura si fuera un rectángulo). La variable i va ha representar cada una de las filas, mientras que la variable j va ha representar cada una de las columnas.

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

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


Pag. 233

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

if ( ( j >= totalFilas – cont ) && ( j <= totalFilas + cont ) ) { // Se muestra un asterisco y un espacio en blanco. System.out.print ( “* ”) ; j ++ ;


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

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

if ( j > totalFilas - i ) { // Se muestra un asterisco y un espacio en blanco. System.out.print ( “* ”) ;



} También:

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

if ( j <= totalFilas - i ) { // Se muestra un espacio en blanco. System.out.print ( “ ”) ;

} else { // Se muestra un asterisco y un espacio en blanco. System.out.print ( “* ”) ;


}

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


Pag. 234

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:

// Se muestra la última parte de la solución: for ( i = 1 ; i <= totalFilas ; i++ ) {

for ( j = 1 ; j < totalFilas * 2 ; j++ ) { if ( ( j >= totalFilas – cont ) && ( j <= totalFilas + cont ) ) {



} } cont ++ ; System.out.println ( ) ;

}

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

Nota: Recuerde que los guiones representan espacios en blanco.

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


Pag. 235

Problema 46



Clase PrgRombo01


import biblioteca.* ; public class PrgRombo01 {

public static void main (String args[]) { int totalFilas = 0, diagonal = 0, cont = 0, i = 1, j = 1 ; System.out.println ( “ Programa que realiza un rombo de *s con la estructura \“WHILE\” \n” ) ; System.out.print ( “ Ingrese el lado del rombo entre [2,10]: ” ) ;

do { totalFilas = Lectura.leerInt ( ); if (totalFilas < 2 || totalFilas > 10 ) { System.out.println ( “\nValor fuera de rango. Ingrese entero entre [2,10]: ” ) ; } } while (totalFilas < 2 || totalFilas > 10 ) ;

System.out.println ( ) ; diagonal = totalFilas * 2 - 1 ;

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

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.


Pag. 236

while ( i <= diagonal ) { j = 1 ; while ( j <= diagonal ) { if ( j < totalFilas - cont || j > totalFilas + cont )

// Se muestra un espacio en blanco. System.out.print ( “ ” ) ; else {

// Se muestra un asterisco y un espacio en blanco. System.out.print ( “* ” ) ;

j ++ ; }

j ++ ; }

if ( i < totalFilas ) cont ++ ; else cont - - ;

System.out.println ( ) ; i ++ ; } } }

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


Pag. 237

Problema 47



Clase PrgRombo02

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

}

} while ( num < 2 || num > 9 ) ; System.out.println ( ) ; diagonal = 2 * num - 1 ;

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

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


Pag. 238

for ( i = 1 ; i <= diagonal ; i ++ ) { n = cont + 1 ; for ( j = 1 ; j <= diagonal ; j ++ ) { if ( j >= num - cont && j <= num + cont ) {

// Se muestra el contenido de la variable n y un espacio en blanco. System.out.print ( n + “ ” ) ; j ++ ; } else

// Se muestra un espacio en blanco. System.out.print ( “ ” ) ; }

if ( i < num ) cont ++ ; else

cont - - ; System.out.println ( ) ; } } }

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

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

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.

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


Pag. 239

Problema 48



Clase PrgFiguraA

package dominioDeLaAplicacion ; import biblioteca.* ; public class PrgFiguraA {

public static void main(String args[]) { int lado = 0; System.out.println ( “ Programa que realiza un cuadrado hueco\n ” ) ; System.out.print ( “ Ingrese lado del cuadrado entre [2,15]: ” ) ; do {

lado = Lectura.leerInt ( ); if ( lado < 2 || lado > 15 ) { System.out.println ( “\nValor fuera de rango. Ingrese entero entre [2,15]: ” ) ; } } while ( lado < 2 || lado > 15 ) ; System.out.println ( ) ; for( int fil = 1 ; fil <= lado ; fil ++ ) { for( int col = 1 ; col <= lado ; col ++ ) { if ( ( 1 < fil && fil < lado ) && ( 1 < col && col < lado ) ) {

// Se muestran dos espacios en blanco. System.out.print ( “ ” ) ; } else {

// Se muestra un asterisco y un espacio en blanco. System.out.print ( “* ” ) ;

} }

System.out.println ( ) ; } } }

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

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


Pag. 240

Problema 49



Clase PrgFiguraB

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

System.out.println ( ) ; } } }

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

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.


Pag. 241

Problema 50



Clase PrgFiguraC

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

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

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.


Pag. 242

Problema 51



Clase PrgFiguraD

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

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

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


Pag. 243

Problema 52



Clase PrgFiguraE

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

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

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


Pag. 244

Problema 53



Clase PrgFiguraF

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

}

} while ( ( alto < 4 ) || ( alto > 18 ) || ( alto % 2 == 0 ) ) ; System.out.println ( ) ; for ( int fil = 1 ; fil <= alto ; fil ++ ) { for ( int col = 1 ; col <= alto ; col ++ ) { if ( fil <= ( alto / 2 ) ) if ( col == 1 || col == alto ) System.out.print ( “* ” ) ; else System.out.print ( “ ” ) ; else System.out.print ( “* ” ) ; } System.out.println ( ) ; } } }

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

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.


Pag. 245

Problema 54



Clase PrgFiguraG


import biblioteca.* ; public class PrgFiguraG {

public static void main (String args[]) { int lado = 0, mayor = 0, col = 0 ; System.out.println ( “ Programa que realiza dos triángulos de asteriscos ”); System.out.print ( “ frente a frente a sus hipotenusas \n ” ) ; System.out.print ( “ Ingrese el lado del triángulo entre [2,15]: ” ) ;

do { lado = Lectura.leerInt ( ) ; if ( lado < 2 || lado > 15 ) { System.out.println ( “\nValor fuera de rango. Ingrese entero entre [2,15]: ” ) ; } } while ( lado < 2 || lado > 15 ) ;

System.out.println ( ) ; mayor = (2 * lado ) + 1 ; for ( int fil = 1 ; fil <= lado ; fil ++ ) { col = 1 ; while ( col <= mayor ) { if ( col <= fil || mayor - fil < col ) System.out.print ( “* ” ) ; else System.out.print ( “ ” ) ; col ++ ; } System.out.println ( ) ; } } }

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

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


Pag. 246

Problema 55



Clase PrgFiguraH


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

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

* * * * * * * * * *

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


Pag. 247

Problema 56



Clase PrgfiguraI

package dominioDeLaAplicacion ; import biblioteca.* ; public class PrgFiguraI { public static void main (String args[]) { int base = 0, alto = 0; System.out.println ( “ Programa que genera un rectángulo hueco de base > alto \n ” ) ; System.out.println ( “ Para generar el rectángulo hueco en pantalla la base ” ) ; System.out.print ( “ debe ser >2 y el alto>1 \n ” ) ; System.out.print ( “ Ingrese la base del rectángulo: ” ) ; do { base = Lectura.leerInt ( ) ; if ( base < 2 ) { System.out.println ( “\nValor fuera de rango. Ingrese entero mayor a 2: ” ) ;

}

} while ( base < 2 ) ; System.out.print ( “ Ingrese el alto del rectángulo...Debe ser menor a la base [“ + base + ”]: ” ) ; do { alto = Lectura.leerInt ( ) ; if ( alto < 1 || alto >= base ) { if ( alto == base ) { System.out.print ( “\nEs un cuadrado. Ingrese entero mayor a 1 y menor ” ) ; System.out.print ( “ a base [“ + base + ”]: ” ) ; } else { System.out.print ( “\nValor fuera de rango. Ingrese entero mayor a 1 y ” ) ; System.out.print ( “ menor a base [“ + base + ”]: ” ) ; }

}

} while ( ! ( alto >1 && alto < base ) ) ;

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

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.


Pag. 248

System.out.println ( ) ; for ( int fil = 1 ; fil <= alto ; fil ++ ) { for ( int col = 1 ; col <= base ; col ++ ) { if ( fil == 1 || fil == alto || col == 1 || col == base ) System.out.print ( “* ” ) ; else System.out.print ( “ ” ) ; } System.out.println ( “ ” ) ; } } }


Pag. 249

Problema 57

Etapa 01 – Descripción del problema. Desarrollar la codificación de una solución que permita mostrar en pantalla la tabla de multiplicar de los 12 primeros números naturales. Asegurese de establecer el espaciado correspondiente para que no se muestre desordenada la tabla, de tal modo que quede de la siguiente forma:

Etapa 04 – Desarrollo de la codificación.

Clase PrgFiguraJ


public class PrgFiguraJ {

public static void main (String[] args) { for ( int i = -1 ; i <= 12 ; i ++ ) { for ( int j = -1 ; j <= 12 ; j++) { if ( i >= 1 && j >= 1 ) { if ( i * j < 10 ) // condiciones para dar el correcto. System.out.print ( “ ” + ( i * j ) + “ ” ) ; // espaciado en los productos. else { if ( i * j < 100 ) System.out.print ( “ ” + ( i * j ) + “ ” ) ; else System.out.print ( ( i * j ) + “ ” ) ; } } else { if ( j == -1 && i == -1 ) // condiciones para dar el correcto System.out.print ( “ * ” ) ; // espaciado en la prim. Fila y la else { // prim. Columna


Pag. 250

if ( i == -1 && j > 0 ) if ( j < 10 ) System.out.print ( “ ” + j + “ ” ) ; else System.out.print ( “ ” + j + “ ” ) ; if ( j == -1 && i > 0 ) { if ( i < 10 ) System.out.print ( “ ” + i + “ ” ) ; else System.out.print ( i + “ ” ) ; } if ( j == 0 && i != 0 ) System.out.print ( “ i ” ) ; if ( i == 0 ) System.out.print ( “----” ) ; } } } System.out.println ( ) ; }

} }

Analice la solución y modifíquela de tal forma que el usuario ingrese la cantidad de números que debe incluir la tabla de multiplicación. Asegúrese de establecer los valores válidos para dicha tabla de multiplicar.


Pag. 251

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 ) System.out.print ( “ ” ) ; else System.out.print ( “***” ) ; } System.out.println ( ) ; } }

}

Analice la solución y modifíquela de tal forma que el usuario ingrese la cantidad de filas y columnas que debe tener la figura. Asegúrese de establecer los valores válidos para dichos datos.


Pag. 252

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 ) System.out.print ( “* ” ) ; else { if ( (( i==3 || i==8 ) && j>=3 && j<=8 ) || (( j==3 || j==8 ) && i>=3 && i<=8 ) ) System.out.print ( “* ” ) ; else { if ( ( i >=5 && i<=6 ) && ( j>=5 && j<=6 ) ) System.out.print ( “* ” ) ; else System.out.print ( “ ” ) ; } } } System.out.println ( ) ; }

} }

Analice la solución y modifíquela de tal forma que el usuario ingrese la cantidad de cuadrados que debe tener la figura. Asegúrese de establecer los valores válidos para dicho dato.


Pag. 253

Problema 60



Clase PrgFiguraM


public class PrgFiguraM {

public static void main (String args[]) { int fil = 27, col = 24 ; for ( int i = 1 ; i <= fil ; i ++ ) { for ( int j = 1 ; j <= col ; j ++ ) { if ( ( ( j == 4 || j == 21 ) && ( i >= 4 && i <= 24 ) ) || ( ( i == 4 || i==24 ) && ( j >= 4 && j <=20 ) ) || ( i >= 8 && i <= 20 ) && ( j >= 8 && j <= 17 ) ) System.out.print ( “ ” ) ; else System.out.print ( “* ” ) ; } System.out.println ( ) ; } }

}

Analice la solución y modifíquela de tal forma que el usuario ingrese la cantidad de filas y columnas que debe tener la figura.


Pag. 254

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


Pag. 256

Clases Básicas Incorporadas en 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. • Problemas resueltos.

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

Otras clases en Java

Capítulo

3

CLASES BÁSICAS INCORPORADAS EN EL LENGUAJE DE PROGRAMACIÓN JAVA

Pag. 259

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.


Etapa 02

Diseño Solución


Etapa 03

Etapa 04

ENUNCIADO DEL

PROBLEMA

MARCO DE TRABAJO


Pag. 260

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.


LISTA DE PASOS


SENTENCIAS

ALMACENADOS EN: • Estructuras de datos tipo variables.

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

de programación utilizado.


Pag. 261

El presente capítulo, trata sobre las clases básicas incorporadas en el lenguaje de programación Java, agrupadas en el paquete1 java.lang. Es importante mencionar que utilizando las clases 2 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. 262


Pag. 263

EL PAQUETE DEL LENGUAJE JAVA El paquete del lenguaje Java, conocido también como java.lang, es uno de los paquetes más importantes de la API3 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 que proporciona los objetos4 para manipular la entrada y la salida estándar, clases para manipular cadenas de caracteres, una clase que proporciona métodos5 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. 264

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 wrappers (envoltorios). Cada una de estas clases (consideradas subclases 6 ), a excepción de la clase Character, se derivan de la clase abstracta 7 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. 265

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. Por otro lado, otros métodos son invocados o ejecutados utilizando un objeto o instancia8 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. 266


Pag. 267

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 jerarquía de clases9 de Java. Esto tiene algunas ventajas desde el punto de vista de la eficiencia. En ocasiones, interesa sacrificar parte de la eficiencia por flexibilidad, por lo que en Java se han creado clases que permiten integrar los tipos de datos primitivos o simples dentro de la jerarquía de clases. Dichas clases son conocidas como las clases wrappers (envoltorios). Los wrappers son clases diseñadas para ser un complemento de los tipos de datos primitivos y proporcionan métodos para realizar diferentes tareas con los tipos de datos primitivos, tales como la conversión con cadenas de caracteres, comprobación, traslación, entre otras. Existe una clase wrapper para cada uno de los tipos de datos primitivos, que permiten tratarlos como objetos. Dichas clases se muestran a continuación:

TIPO DE DATO PRIMITIVO

CLASES WRAPPERS

boolean Boolean

byte Byte

char Character

double Double

float Float

int Integer

Long Long

9 Jerarquía de clases: Forma de ordenar las clases. La jerarquía de clases es una forma de ordenar las clases existentes en un lenguaje de Programación Orientado a Objetos (POO). Una jerarquía de clases define conceptos abstractos en la parte superior de la jerarquía y conforme se desciende en la jerarquía los conceptos se tornan cada vez más concretos. Java tiene su propia jerarquía de clases, estando en la parte superior de la jerarquía, la clase Object (esta clase pertenece al paquete java.lang).


Pag. 268

TIPO DE DATO PRIMITIVO

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

java.lang.Object

java.lang.Number java.lang.Boolean java.lang.Character

Integer Long Float Double Byte Short


Pag. 269

MÉTODOS

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

OBJETO CLASE AL QUE PERTENECE

S String

I Integer

L Long

F Float

D Double

C Character

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

VARIABLE TIPO DE DATO PRIMITIVO

i int

l long

f float

d double

b boolean

c char

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


Pag. 270

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:

OBJETO STRING CLASES WRAPPERS Y 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. 271

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

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

VARIABLE WRAPPERS Y OBJETO STRING

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

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

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

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

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


Pag. 272

Conversión de objetos wrappers a tipos de datos primitivos Se puede convertir un valor de tipo cadena contenido en un objeto String a un valor de un tipo de dato primitivo o simple, siempre y cuando el objeto String contenga un valor equivalente al valor del tipo de dato primitivo que se desea convertir.

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

VARIABLE CLASES WRAPPERS

i =

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

l =

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

f =

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

d =

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

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

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


Pag. 273

Comprobaciones del valor Not-a-Number

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

VARIABLE CLASES WRAPPERS Y VARIABLES

b =

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

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

VARIABLE OBJETOS WRAPPERS

b =

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

Observe que se utiliza el método isNaN ( ) para determinar si la variable es o no un número. El método devuelve true si el valor de la variable no es un número.

Los valores Not-a-Number proceden de indeterminaciones tales como por ejemplo el resultado de la siguiente operación: 0.0 / 0.0.

Comprobaciones del valor infinito

Comprobación del valor infinito utilizando clases wrappers y variables:

VARIABLE CLASES WRAPPERS Y VARIABLES

b =

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


Pag. 274

Comprobación del valor infinito utilizando objetos wrappers:

VARIABLE OBJETOS WRAPPERS

b =

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

Observe que se utiliza el método isInfinite ( ) para determinar si la variable es o no un número infinito. El método devuelve true si el valor de la variable es un número infinito.

Los valores Infinite proceden normalmente de la división por cero de un valor finito. Por ejemplo el resultado de la siguiente operación: 10.5 / 0.0.

Comprobaciones de caracteres

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

VARIABLE CLASE Character Y VARIABLE char

Character.isLowerCase (c) ;

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

Character.isUpperCase (c) ;

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

Character.isDigit (c) ;

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

b =

Character.isSpace (c) ;

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


Pag. 275

Traslación de caracteres

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

VARIABLE CLASE Character y VARIABLE char

Character.toLowerCase (c);

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

Character.toUpperCase (c);

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


Pag. 276

Problema 61

Etapa 01 - Descripción del problema. Desarrollar un programa en Java que permita convertir valores de diferentes tipos de datos en valores de tipo cadena.


Clase PrgConvertirAString


class PrgConvertirAString { public static void main ( String arg [ ] ) {

boolean estado = true; char letra = ‘z’; int numEntero = 10; long numEnteroLargo = 100000000; float numReal = 15.5f; double numRealDoble = 10000.98; String cadena = “ ”; cadena = String.valueOf ( estado ) ; System.out.println ( “ Tipo boolean en String: ” + cadena ) ; cadena = String.valueOf ( letra ) ; System.out.println ( “ Tipo char en String: ” + cadena ) ; cadena = String.valueOf ( numEntero ) ; System.out.println ( “ Tipo int en String: ” + cadena ) ; cadena = String.valueOf ( numEnteroLargo ) ; System.out.println( “ Tipo long en String: ” + cadena ) ; cadena = String.valueOf ( numReal ) ; System.out.println ( “ Tipo float en String: ” + cadena ) ; cadena = String.valueOf ( numRealDoble ) ; System.out.println ( “ Tipo double en String: ” + cadena ) ;

} }

Observe que es posible convertir cualquier tipo de dato a cadena (String) utilizando el método valueOf ( ) de la clase String. En ciertas ocasiones esto es necesario ya que las cadenas pueden ser manipuladas. Analice como se pueden manipular las variables de tipo cadena (String) más adelante en este mismo capítulo.


Pag. 277

Problema 62

Etapa 01 - Descripción del problema. Desarrollar un programa en Java que permita obtener la fecha del sistema y la convierta en un valor de tipo cadena.


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

Problema 63

Etapa 01 - Descripción del problema. Desarrollar un programa en Java que permita convertir una cadena en un número entero y en un objeto de tipo Integer. Calcular y mostrar la suma de ambos valores.


Clase PrgCadenaAEntero


class PrgCadenaAEntero { public static void main ( String arg [ ] ) {

int numEntero = 0 ; String cadena = “10" ; numEntero = Integer.parseInt ( cadena ) ; Integer objInteger = Integer.valueOf ( cadena ) ; System.out.println ( “ Valores enteros: ” + numEntero + “ " + objInteger ) ; System.out.println ( “ La suma es: ” + (numEntero + objInteger.intValue ( ) ) ) ;

} }

Observe que es posible convertir una cadena (String) en un valor entero (int) o en un objeto de la clase Integer. Recuerde, que deberá asegurarse que la cadena contenga un valor válido para que pueda ser almacenado en un tipo de dato determinado. Puede utilizar el método parseInt ( ) de la clase String para convertir una cadena en un número entero (numEntero) y también el método valueOf ( ) de la clase Integer para convertir una cadena en un un objeto (objInteger) de la clase Integer. El método intValue ( ) nos permite obtener el valor entero del objeto (objInteger) de la clase Integer. Como sugerencia desarrolle un programa en Java que realice lo mismo que este programa pero utilice una variable long y la clase Long.


Pag. 279

Problema 64

Etapa 01 - Descripción del problema. Desarrollar un programa en Java que permita convertir una cadena en un número real y en un objeto de tipo Double. Calcular y mostrar la suma de ambos valores.


Clase PrgCadenaAReal


class PrgCadenaAReal { public static void main ( String arg [ ] ) {

double numRealDoble = 0 ; String cadena = “10.5” ; numRealDoble = Double.parseDouble ( cadena ) ; Double objDouble = Double.valueOf ( cadena ) ; System.out.println ( “ Valores enteros: ” + numRealDoble + “ ” + objDouble ) ; System.out.print ( “ La suma es: ” ) ; System.out.println ( numRealDoble + objDouble.doubleValue ( ) ) ;

} }

Observe que es posible convertir una cadena (String) en un valor entero (double) o en un objeto de la clase Double. Recuerde, que deberá asegurarse que la cadena contenga un valor válido para que pueda ser almacenado en un tipo de dato determinado. Puede utilizar el método parseDouble ( ) de la clase Double para convertir una cadena en un número real (numRealDoble) y también el método valueOf ( ) de la clase Double para convertir una cadena en un un objeto (objDouble) de la clase Double. El método doubleValue ( ) nos permite obtener el valor real del objeto (objDouble) de la clase Double. Como sugerencia desarrolle un programa en Java que realice lo mismo que este programa pero utilice una variable float y la clase Float.


Pag. 280


Pag. 281

FUNCIONES MATEMÁTICAS: CLASE MATH INTRODUCCIÓN

La clase Math, es una clase que viene incorporada en el lenguaje de programación Java, incluida en el paquete java.lang, la cual nos proporciona métodos y atributos, para implementar diversas funciones mátemáticas.

JERARQUÍA DE CLASES Y HERENCIA 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 una clase final10. 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.

java.lang.Object

java.lang.Math


Pag. 282

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

CLASE Math

ATRIBUTOS DE CLASE DESCRIPCIÓN USO

E

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

double e = Math.E ; System.out.print( e) ; Resultado: e = 2.718281828459045.

PI

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

double pi = Math.PI ; System.out.print( pi) ; Resultado: pi = 3.141592653589793.

MÉTODOS DE CLASE DESCRIPCIÓN USO

abs (float)

abs (double)

abs (int)

abs (long)

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

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

acos (double)

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

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

asin (double)

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

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

atan (double)

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

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


Pag. 284


Resultado : result = 0.6657737500283538

ceil (double)

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

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

cos (double)

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

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

exp (double)

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

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

floor (double)

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

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

log (double)

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

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

max (float, float)

max (double, double)

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

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


Pag. 285


max (int, int)

max (long, long)

mayor = 15.

min (float, float)

min (double, double)

min (int, int)

min (long, long)

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

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

pow (double, double)

Retorna un valor double con la potencia de un número (dado como primer parámetro) elevado a otro número (dado como segundo parámetro). Los dos parámetros dados deben ser double.

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

random ()

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

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

round (float) round (double)

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

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

sin (double)

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

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


Pag. 286


result = 0.6018150231520483

sqrt (double)

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

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

tan (double)

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

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

toDegrees (double)

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

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

toRadians (double)

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

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

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


Pag. 287

Problema 65

Etapa 01 - Descripción del problema. Desarrollar un programa en Java que permita ingresar 3 números enteros a través del teclado. Determinar y mostrar cuál de ellos es el número mayor.


Clase PrgNumeroMayor


import biblioteca.Lectura ; 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: ” ) ; num2 = Lectura.leerInt( ) ; System.out.println ( “ Ingresar el tercer número: ” ) ; num3 = Lectura.leerInt( ) ; resultado = Math.max ( num1, Math.max ( num2, num3 ) ) ; System.out.println ( “ El número mayor es: ” + resultado ) ;

} }

¿Que hay de nuevo en la codificación? Observe el uso del método max ( ) de la clase Math:

Math.max ( num2, num3 ) Nombre de la Clase.

Operador punto.

Nombre del método.

Parámetros.


Pag. 288

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

Problema 66

Etapa 01 - Descripción del problema. Desarrollar un programa en Java que permita ingresar 3 números enteros a través del teclado. Determinar y mostrar cuál de ellos es el número menor.


Clase PrgNumeroMenor


import biblioteca.Lectura ; class PrgNumeroMenor {


int num1, num2, num3, resultado ; System.out.println ( “ Ingresar el primer número: ” ) ; num1 = Lectura.leerInt( ) ; System.out.println ( “Ingresar el segundo número: ” ) ; num2 = Lectura.leerInt( ) ; System.out.println ( “Ingresar el tercer número: ” ) ; num3 = Lectura.leerInt( ) ; resultado = Math.min ( num1, Math.min ( num2, num3 ) ) ; System.out.println ( “ El número menor es: " + resultado ) ;

} }

¿Que hay de nuevo en la codificación? Observe el uso del método min ( ) de la clase Math: En la codificación de esta solución se emplea una nueva estrategia para hallar el menor de tres números ingresados por teclado (anteriormente se utilizaban sentencias if anidadas). Observe que Math.min ( ) retorna el valor del número menor (que puede ser float, double, int, long) de dos números dados como parámetros. En nuestro ejemplo hallamos el menor de los dos últimos números ingresados, y en la misma línea evaluamos el menor de estos dos números con el primer número ingresado, tal y como se muestra a continuación:

resultado = Math.min ( num1, Math.min ( num2, num3 ) ) ;


Pag. 290

Problema 67

Etapa 01 - Descripción del problema. Desarrollar un programa en Java que permita generar una cantidad determinada de números aleatorios. Los números aleatorios generados deberán estar entre 1 y 6. Mostrar el número generado aleatoriamente y la suma de dichos números.


Clase PrgNumerosAleatorios


import biblioteca.Lectura ; 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 ) ;

} }

¿Que hay de nuevo en la codificación? Observe el uso del método random ( ) de la clase Math:

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


Pag. 291

min + (int) ( Math.random( ) * (max – min + 1 ) ) ;

Para nuestro ejemplo tenemos:

1 + (int) ( Math.random( ) * ( 6 – 1 + 1 ) ) ;

1 + (int) ( Math.random( ) * ( 6 ) ) ;


Pag. 292

Problema 68

Etapa 01 - Descripción del problema. Desarrollar un programa en Java que permita generar una cantidad determinada de números aleatorios. Los números aleatorios generados deberán estar entre 1 y 10. Mostrar los números aleatorios que son números pares.


Clase PrgNumAleatoriosPares


import biblioteca.Lectura ; class PrgNumAleatoriosPares {


int x, cant, num, cont = 0 ; System.out.print ( “Ingresar la cantidad de números aleatorios a generar: ” ) ; cant = Lectura.leerInt( ) ; do { num = 1 + (int) ( Math.random( ) * 10 ) ; if (num % 2 == 0) { cont++; System.out.print ( num + “ \t ” ) ; } } while (cant != cont) ;

} }

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


Pag. 293

Problema 69

Etapa 01 - Descripción del problema. Desarrollar un programa en Java que permita generar una cantidad determinada de números aleatorios. Los números aleatorios generados deberán estar entre 1 y 10. Mostrar los números aleatorios que son números impares.


Clase PrgNumAleatoriosImpares


import biblioteca.Lectura ; class PrgNumAleatoriosImpares {


int x, cant, num, cont = 0 ; System.out.print ( “Ingresar la cantidad de números aleatorios a generar: ” ) ; cant = Lectura.leerInt( ) ; do { num = 1 + (int) ( Math.random( ) * 10 ) ; if ( num % 2 == 1 ) { cont ++; System.out.print ( num + “ \t ” ) ; } } while ( cant != cont ) ;

} }

¿Que hay de nuevo en la codificación? En la codificación de esta solución se utiliza una sentencia do con la finalidad de generar números aleatorios. Si el número generado es impar se le aumenta uno a la variable cont (que esta trabajando como contador de números impares generados al azar) y se muestra el número generado.


Pag. 294

Problema 70

Etapa 01 - Descripción del problema. Desarrollar un programa en Java que permita ingresar por teclado el radio de una esfera. Calcular y mostrar el volumen de dicha esfera.


Clase PrgRadioEsfera


import biblioteca.Lectura ; 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 ) ;

} }

¿Que hay de nuevo en la codificación? Observe el uso del método pow ( ) y del atributo PI de la clase Math:

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


Pag. 295

Problema 71

Etapa 01 - Descripción del problema. Desarrollar un programa en Java que permita ingresar un número decimal. Mostrar el número ingresado redondeado.


Clase PrgNumRedondeado


import biblioteca.Lectura ; 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 ) ;

} }

¿Que hay de nuevo en la codificación? Observe el uso del método round ( ) de la clase Math:

resultado = Math.round(num) ; El método round ( ) permite redondear un número dado como parámetro. En esta solución se ingresa un número y se almacena en la variable num. Luego, dicho número es redondeado utilizando el método round ( ) y se almacena en la variable resultado.


Pag. 296

Problema 72

Etapa 01 - Descripción del problema. Desarrollar un programa en Java que permita ingresar un número entero y un exponente. Mostrar el resultado de calcular la potencia de todos los números menores que el número ingresado elevado al exponente ingresado.


Clase PrgNumPotencia


import biblioteca.Lectura ; class PrgNumPotencia {


int cant, expo ; double rpta ; System.out.println ( “Ingresar un número entero: ” ) ; cant = Lectura.leerInt( ) ; System.out.println ( “Ingresar el exponente: ” ) ; expo = Lectura.leerInt( ) ; for ( int x = 1; x < cant; x++) { rpta = Math.pow ( x, expo ) ; System.out.println ( “El Exponencial de ” + x + “ es: ” + rpta ) ; }

} }

¿Que hay de nuevo en la codificación? Observe el uso del método pow ( ) de la clase Math:

rpta = Math.pow ( x, expo ) ; El método pow ( ) permite elevar a la potencia un número determinado. En la presente solución se utiliza una sentencia for con la finalidad de elevar a la potencia todos los números menores que la variable cant y mostrarlos por pantala. La variable cant y el exponente expo se ingresan por el teclado. Recuerde y siempre tenga presente que el método pow ( ) de la clase Math, retorna un valor double, por lo que dicho valor deberá ser almacenado en una variable del mismo tipo o deberá mostrarse por la pantalla.


Pag. 297

Problema 73

Etapa 01 - Descripción del problema. Desarrollar un programa en Java que permita ingresar un número entero. Mostrar el resultado de calcular la raíz cuadrada de todos los números menores que el número ingresado.


Clase PrgNumRaiz


import biblioteca.Lectura ; class PrgNumRaiz {


int cant ; double rpta ; System.out.println ( “Ingrese un número entero: ” ) ; cant = Lectura.leerInt( ) ; for ( int x = 1; x < cant; x++ ) { rpta = Math.sqrt (x) ; System.out.println ( “La raíz cuadrada de ” + x + “ es: ” + rpta ) ; }

} }

¿Que hay de nuevo en la codificación? Observe el uso del método sqrt ( ) de la clase Math:

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


Pag. 298

Problema 74

Etapa 01 - Descripción del problema. Desarrollar un programa en Java que permita generar una cantidad determinada de números aleatorios. Los números aleatorios generados deberán estar entre 1 y 10. Mostrar los números generados aleatoriamente elevados al cuadrado. Etapa 04 - Desarrollo de la Codificación.

Clase PrgNumAleatorioCuad


import biblioteca.Lectura ; class PrgNumAleatorioCuad {


int cant, num ; double rpta ; System.out.print ( “Ingresar la cantidad de números aleatorios a generar: ” ) ; cant = Lectura.leerInt( ) ; for ( int x = 1; x <= cant; x++ ) { num = (int) ( 1 + ( Math.random() * 10 ) ) ; rpta = Math.pow (num, 2) ; System.out.println ( num + “ elevado al cuadrado es: ” + rpta ) ; }

} }

¿Que hay de nuevo en la codificación? Observe el uso de los métodos random ( ) y sqrt ( ) de la clase Math:

num = (int) ( 1 + ( Math.random() * 10 ) ) ; rpta = Math.pow (num, 2) ;

En la presente solución se utiliza una sentencia for con la finalidad de obtener números aleatorios, elevarlos al cuadrado y mostrarlos por pantalla. La variable cant se ingresa por el teclado.


Pag. 299

Problema 75

Etapa 01 - Descripción del problema. Desarrollar un programa en Java que permita determinar y mostrar el área de un tríangulo en base a las longitudes de sus lados. Considerar el valor absoluto de la diferencia entre el semiperimetro y cada uno de los lados. Utilizar las siguientes fórmulas:

area = ( p * (|p-a|)*(|p-b|)*(|p-c|)) RAIZ (2). p = (a+b+c) / 2.

Donde:

p = Semiperímetro. a, b, c = Lados del triángulo.


Clase PrgTriangulo


import biblioteca.Lectura ; 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. 300

¿Que hay de nuevo en la codificación? Observe el uso de los métodos abs ( ) y sqrt ( ) de la clase Math:

tmp = ( p * (Math.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. 301

Problema 76

Etapa 01 - Descripción del problema. Desarrollar un programa en Java que permita determinar y mostrar el perímetro y el área de un círculo. Utilizar las siguientes fórmulas:

perimetro = 2 * PI * radio. area = PI * radio * radio.


Clase PrgCirculo


import biblioteca.Lectura ; 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. 302

Problema 77

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

0 grados. = 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


import biblioteca.Lectura ; class PrgConversionAngulo {

public static void main ( String arg [ ] ) { double anguloGrados, anguloRadianes ; String tipoAngulo = “” ; System.out.println ( “ Ingrese un ángulo en grados (entre 0 y 360): ” ) ; anguloGrados = Lectura.leerDouble( ) ;

if (anguloGrados == 0) tipoAngulo = “Nulo” ; if (anguloGrados > 0 && anguloGrados < 90) tipoAngulo = “Agudo” ; if (anguloGrados == 90) tipoAngulo = “Recto” ; if (anguloGrados > 90 && anguloGrados < 180) tipoAngulo = “Obtuso” ; if (anguloGrados == 180) tipoAngulo = “Llano” ; if (anguloGrados > 180 && anguloGrados < 360) tipoAngulo = “Concavo” ; if (anguloGrados == 360) tipoAngulo = “Completo” ;

anguloRadianes = Math.toRadians (anguloGrados) ; System.out.println ( “ Tipo de ángulo: ” + tipoAngulo ) ; System.out.println ( “ Ángulo expresado en radianes: ” + anguloRadianes ) ;

} }


Pag. 303

¿Que hay de nuevo en la codificación? Observe el uso del método toRadians ( ) de la clase Math:

anguloRadianes = Math.toRadians (anguloGrados) ; Para el desarrollo de esta solución se hace uso de sentencias if múltiples con la finalidad de determinar el tipo de ángulo ingresado por teclado. El tipo de ángulo es almacenado en una variable String (tipoAngulo) y mostrado por pantalla. Para realizar la conversión del ángulo ingresado en el sistema sexagesimal al sistema radial se utiliza el método toRadians ( ) de la clase Math.


Pag. 304

Problema 78

Etapa 01 - Descripción del problema. Desarrollar un programa en Java que permita determinar y mostrar las raíces de una ecuación de segundo grado. Tipo:

Ax2 + 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


import biblioteca.Lectura ; class PrgEcuacion2Grado {

public static void main ( String arg [ ] ) { int a, b, c ; double tmp, x, x1, x2 ;

System.out.println ( “ Ingrese el coeficiente A: ” ) ; a = Lectura.leerInt( ) ; System.out.println ( “ Ingrese el coeficiente B: ” ) ; b = Lectura.leerInt( ) ; System.out.println ( “ Ingrese el coeficiente C: ” ) ; c = Lectura.leerInt( ) ;

if (a == 0 && b == 0) { System.out.println ( “ La ecuación no tiene solución ” ) ; } else { tmp = Math.pow (b, 2) - (4 * a * c) ; if (tmp < 0) { System.out.println ( “ La ecuación tiene raices imaginarias ” ) ; } else { if (a == 0) {

x = c / b * (-1) ; System.out.println ( “ El valor para x es: ” + x ) ;

} else { x1 = ( - b + Math.sqrt (tmp)) / (2 * a) ; x2 = ( - b - Math.sqrt (tmp)) / (2 * a) ; System.out.println ( “ El primer valor para x es: ” + x1 ) ; System.out.println ( “ El segundo valor para x es: ” + x2 ) ;

} } }

} }


Pag. 305

¿Que hay de nuevo en la codificación? Observe el uso de los métodos pow ( ) y sqrt ( ) de la clase Math: En esta solución se ingresan los coeficientes de una ecuación de segundo grado (a, b y c). Si los coeficientes a y b son iguales a cero, se muestra un mensaje por la pantalla; “La ecuación no tiene solución”. Caso contrario, se determina el valor de la discriminante, el cual se almacena en la variable tmp utilizando la siguiente formula:

tmp = Math.pow (b, 2) - (4 * a * c) ; En caso que el valor de tmp sea igual a cero, se muestra el siguiente mensaje por pantalla; “La ecuación tiene raices imaginarias”. Caso contrario, si el coeficiente a es igual a cero la ecuación tendría una sola solución, la cual se calcularía utilizando:

x = c / b * (-1) ;

Si el coeficiente a es diferente de cero la ecuación tendría dos soluciones, las cuales se calcularían utilizando:

x1 = ( - b + Math.sqrt (tmp)) / (2 * a) ; x2 = ( - b - Math.sqrt (tmp)) / (2 * a) ;


Pag. 306

Problema 79

Etapa 01 - Descripción del problema. Desarrollar un juego en Java que permita generar un número aleatorio. Se debe intentar adivinar que número es el que generó la computadora. El rango de números válidos en el juego es de 1 a 100, y cada vez que intente adivinar le indicará si el número buscado es menor o es mayor.


Clase PrgJuego


import biblioteca.Lectura ; class PrgJuego {

public static void main ( String arg [ ] ) { int maximo = 100, num, numAzar, inten = 1 ; double tmp;

System.out.println ( “ Bienvenido al juego: ¿Que número es? ” ) ; System.out.println ( “ ----------------------------------------------------” ) ; System.out.println ( “ - La computadora genera un -” ) ; System.out.println ( “ - numero aleatorio y ud. tratara -” ) ; System.out.println ( “ - de adivinar que número es -” ) ; System.out.println ( “ - Trate de adivinar el número en -” ) ; System.out.println ( “ - el menor número de intentos -” ) ;

do { System.out.println ( “ Ingrese un número entre 0..100: ” ) ; num = Lectura.leerInt( ) ; } while (num < 0 || num > 100 ) ;

tmp = maximo * Math.random( ) ; numAzar = (int) Math.round(tmp) ;

while (num != numAzar) { inten++ ; if (num < numAzar) System.out.println ( “ El número buscado es mayor ” ) ; else System.out.println ( “ El número buscado es menor ” ) ; do { System.out.println ( “ Ingrese otro número entre 0..100: ” ) ; num = Lectura.leerInt( ) ; } while (num < 0 || num > 100) ; } System.out.println ( “ Ud. encontró el número en: ” + inten + “ intento(s) ” ) ;

} }


Pag. 307

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

Problema 80

Etapa 01 - Descripción del problema. Desarrollar un programa en Java que permita ingresar 6 números a traves del teclado. Determinar y mostrar cuál de ellos es el número mayor y cuál es el número menor.


Clase PrgNumeroMayorMenor


import biblioteca.Lectura ; class PrgNumeroMayorMenor {

public static void main ( String arg [ ] ) { int n1, n2, n3, n4, n5, n6 ; double mayor, meno r;

System.out.println ( “ Ingrese el primer número: ” ) ; n1 = Lectura.leerInt(); System.out.println ( “ Ingrese el segundo número: ” ) ; n2 = Lectura.leerInt( ) ; System.out.println ( “ Ingrese el tercer número: ” ) ; n3 = Lectura.leerInt( ) ; System.out.println ( “ Ingrese el cuarto número: ” ) ; n4 = Lectura.leerInt( ) ; System.out.println ( “ Ingrese el quinto número: ” ) ; n5 = Lectura.leerInt( ) ; System.out.println ( “ Ingrese el sexto número: ” ) ; n6 = Lectura.leerInt( ) ;

mayor = Math.max (n1,n2) ; mayor = Math.max (mayor,n3) ; mayor = Math.max (mayor,n4) ; mayor = Math.max (mayor,n5) ; mayor = Math.max (mayor,n6) ; menor = Math.min (n1,n2) ; menor = Math.min (menor,n3) ; menor = Math.min (menor,n4) ; menor = Math.min (menor,n5) ; menor = Math.min (menor,n6) ; System.out.println ( “ El mayor número es: " + mayor ) ; System.out.println ( “ El menor número es: " + menor ) ;

} }

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


Pag. 309

Problema 81

Etapa 01 - Descripción del problema. Desarrollar un programa en Java que permita ingresar las notas de todos los alumnos de un determinado salon de clase. Calcular y mostrar el promedio final de cada alumno en base a la siguiente fórmula:

pf = ( pp + ep + ( ef * 2 ) ) / 4. Donde:

pf = Promedio final. pp = Promedio de prácticas.

Son 4 prácticas de las cuales se elimina la más baja pp = ( p1 + p2 + p3 + p4 – notaMenor ) / 3

ep = Examen parcial. ef = Examen final.


Clase PrgPromedioNotas


import biblioteca.Lectura ; 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 de la práctica 2: ” ) ; p2 = Lectura.leerDouble( ) ; System.out.println ( “ Ingrese la nota de la práctica 3: ” ) ; p3 = Lectura.leerDouble( ) ; System.out.println ( “ Ingrese la nota de la práctica 4: ” ) ; p4 = Lectura.leerDouble( ) ; System.out.println ( “ Ingrese la nota del examen parcial: ” ) ; ep = Lectura.leerDouble( ) ; System.out.println ( “ Ingrese la nota del examen final: ” ) ; ef = Lectura.leerDouble( ) ; notaMenor = Math.min (p1,p2) ; notaMenor = Math.min (notaMenor,p3) ; notaMenor = Math.min (notaMenor,p4) ;


Pag. 310


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

Problema 82

Etapa 01 - Descripción del problema. Desarrollar un programa en Java que permita ingresar un número cualquiera con parte decimal y muestre la parte entera del número, el número redondeado sin decimales, y el número redondeado a uno, dos y tres decimales.


Clase PrgRedondearNumero


import biblioteca.Lectura ; 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 ( Math.floor (numero * 100 + 0.5 ) / 100 ) ; System.out.println ( “ El número redondeado a tres decimales es: ” ) ; System.out.println ( Math.floor (numero * 1000 + 0.5 ) / 1000 ) ;

} }

¿Qué hay de nuevo en la codificación? Observe el uso del método floor ( ) de la clase Math: El método floor ( ) retorna un valor double con el valor más grande no mayor que el parámetro dado. El parámetro dado debe ser double. Nótese que si ingresamos un numero cuya parte decimal es mayor que 5 sólo retorna la parte entera para tal caso se le agrega 0.5 para que en el segundo cálculo tenga efecto de redondeo perfecto. Observe como se redondea un número con uno, dos y tres decimales utilizando el método floor ( ).


Pag. 312

Problema 83

Etapa 01 - Descripción del problema. Desarrollar un programa en Java que permite realizar un sorteo en base a un número determinado de boletos.

Sugerencia: Utilice el método random ( ) de la clase Math para generar el número del boleto ganador.


Clase PrgSorteo


import biblioteca.Lectura ; 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. 313

Problema 84

Etapa 01 - Descripción del problema. Desarrollar un programa en Java que permita calcular la suma de cuadrados y la suma de cubos de los “n” primeros números. Se deberá ingresar un número por teclado y mostrar los resultados.


Clase PrgSumaCuadradosCubos


import biblioteca.Lectura ; 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. 314

Problema 85

Etapa 01 - Descripción del problema. Desarrollar un programa en Java que permita ingresar un ángulo no mayor de 360 grados ni menor de 0 grados. Mostrar como resultado el seno y el coseno del ángulo ingresado.


Clase PrgSenCos


import biblioteca.Lectura ; class PrgSenCos {


double anguloGrados, anguloRadianes, seno = 0, coseno = 0 ; do{ System.out.println ( “ Ingrese un ángulo en grados entre 0 y 360: ” ) ; anguloGrados = Lectura.leerDouble( ) ; if (anguloGrados < 0 || anguloGrados > 360 ){ System.out.println ( “El dato ingresado es incorrecto, intente otra vez: ” ); } }while(anguloGrados < 0 || anguloGrados > 360) ;

anguloRadianes = Math.toRadians( anguloGrados ) ; seno = Math.sin( anguloRadianes ) ; coseno = Math.cos( anguloRadianes ) ; System.out.println ( “ El sen [” + anguloGrados + “ ] = ” + seno ) ; System.out.println ( “ y el cos [” + anguloGrados + “ ] = ” + coseno ) ;

} }

¿Qué hay de nuevo en la codificación? Observe el uso de los métodos toRadians ( ), sin ( ) y cos ( ) de la clase Math: Es importante mencionar que Java trabaja con el sistema radial y para obtener las razones trigonométricas, seno y coseno, de un ángulo ingresado por teclado hay que convertirlo primero al sistema radial. Para esto, utilizamos el método toRadians ( ) de la clase Math. Este método retorna un valor double y permite convertir un ángulo expresado en el sistema sexagesimal (enviado como parámetro double) en un ángulo expresado


Pag. 315

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

Problema 86

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


Clase PrgTangente


import biblioteca.Lectura ; class PrgTangente {


double anguloGrados, anguloRadianes, tangente = 0 ; System.out.println ( “ Ingrese el ángulo de inclinación de la recta: ” ) ; anguloGrados = Lectura.leerDouble( ) ; anguloRadianes = Math.toRadians(anguloGrados) ; tangente = Math.tan(anguloRadianes) ; System.out.println ( “ La pendiente de la resta es = ” + tangente ) ;

} }

¿Qué hay de nuevo en la codificación? Observe el uso del método tan ( ) de la clase Math: El método tan ( ) permite hallar la pendiente de una recta con respecto al eje X. Para ello, utiliza el ángulo de inclinación de la recta, expresado en el sistema radial, tal y como se muestra:

tangente = Math.tan(anguloRadianes) ;


Pag. 317

Problema 87

Etapa 01 - Descripción del problema. Desarrollar un programa en Java que permita ingresar los catetos de un triángulo perpendicular. Calcular y mostrar la hipotenusa del tríangulo.


Clase PrgHipotenusa


import biblioteca.Lectura ; 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. 318

Problema 88

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


Clase PrgPunto


import biblioteca.Lectura ; 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) ;

} }

¿Qué hay de nuevo en la codificación? Observe el uso de los métodos atan2 ( ) y toDegress ( ) de la clase Math:

anguloRadianes = Math.atan2(ordenada, abscisa) ; anguloGrados = Math.toDegrees(anguloRadianes) ;

Sabemos que Math.atan ( ) retorna un valor double con el arcotangente de un ángulo expresado en radianes. Dicho ángulo expresado en radianes debe ser un valor double enviado al método como parámetro.


Pag. 319

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

Problema 89

Etapa 01 - Descripción del problema. Desarrollar un programa en Java que permita ingresar un número cualquiera. Calcular y mostrar el número e elevado al número ingresado y el logaritmo natural (de base e) del número ingresado.


Clase PrgExpLog


import biblioteca.Lectura ; 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) ;

} }

¿Qué hay de nuevo en la codificación? Observe el uso de los métodos exp ( ) y log ( ) de la clase Math:

exponencial = Math.exp(num) ; logaritmo = Math.log(num) ;

En esta solución se hace necesario el uso del método exp ( ) para obtener el número e elevado al número ingresado por teclado:

enum También se hace necesario el uso del método log ( ) para obtener el logaritmo natural del número ingresado en base e:

logenum


Pag. 321

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

Problema 90

Etapa 01 - Descripción del problema. Un jugador lanza dos dados, cada uno de los cuales tiene 6 caras, las caras contienen 1, 2, 3, 4 ,5 y 6 puntos. Una vez que los dados quedan en reposo, se suman los puntos de las dos caras que quedan hacia arriba. Si la suma es 7 o 11 en el primer lanzamiento, el jugador gana. Si la suma es 2, 3 o 12 en el primer lanzamiento (resultado que en los casinos reciben el nombre de “craps”), el jugador pierde (es decir, la casa gana). Si la suma es 4, 5, 6, 8, 9, 10 en el primer lanzamiento, esto suma se convierte en el punto del jugador. Para ganar, el jugador debe seguir tirando los dados hasta “lograr su punto”. El jugador perderá si tira un 7 antes de lograr su punto. Etapa 04 - Desarrollo de la Codificación.

Clase PrgLanzarDados1


import biblioteca.* ; 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 ) ) ; dado2 = ( int ) (1 + ( Math.random ( ) * 6 ) ) ; suma1 = dado1 + dado2 ; System.out.println ( “Dado1 : ” + dado1 ) ; System.out.println ( “Dado2 : ” + dado2 ) ; if ( suma1 == 7 || suma1 == 11 ) { opc1 = “s” ; estado = 1 ;


Pag. 323



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

} }


Pag. 324

Problema 91

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



import biblioteca.* ; class PrgLanzarDados2 {


int dado1 = 0, dado2 = 0, suma1 = 0, suma2 = 0, estado = 0 ; String opc1 = “ ”, opc2 = “ ” ; char opc3 = ‘n’ ; do { opc1 = “ ” ; opc2 = “ ” ; do { System.out.println ( “Lanzar dados” ) ; Lectura.leerString ( ) ; dado1 = ( int ) (1 + ( Math.random ( ) * 6 ) ) ; dado2 = ( int ) (1 + ( Math.random ( ) * 6 ) ) ; suma1 = dado1 + dado2 ; System.out.println ( “Dado1 : ” + dado1 ) ; System.out.println ( “Dado2 : ” + dado2 ) ; if ( suma1 == 7 || suma1 == 11 ) { opc1 = “s” ; estado = 1 ; } else if (suma1 == 2 || suma1 == 3 || suma1 == 12) { opc1 = “s” ; estado = 0 ; } else {


Pag. 325



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

} }


Pag. 326

Problema 92

Etapa 01 - Descripción del problema. Elaborar un programa que simule el lanzamiento de una moneda. Solicitar el número de veces que se lanzará la moneda. Cuentar el número de veces que aparece cada lado de la moneda. Mostrar los resultados. Etapa 04 - Desarrollo de la Codificación.

Clase PrgLanzarMoneda


import biblioteca.* ; 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. 327

Problema 93

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

Clase PrgTragamoneda1


import biblioteca.* ; class PrgTragamoneda1 {


int valor1 = 0, valor2 = 0, valor3 = 0, monto = 0 ; char s, opc1 ; do { System.out.println( “Presionar enter para empezar” ) ; Lectura.leerString ( ) ; valor1 = ( int ) (1 + ( Math.random ( ) * 7 ) ) ; valor2 = ( int ) (1 + ( Math.random ( ) * 7 ) ) ; valor3 = ( int ) (1 + ( Math.random ( ) * 7 ) ) ; System.out.println ( valor1 + “ ” + valor2 + “ ” + valor3 ) ; if ( valor1 == valor2 && valor1 == valor3 ) { s = (char) valor1 ; switch (s) { case 1 : monto = 100 ; break ; case 2 : monto = 200 ; break ; case 3 : monto = 300 ; break ;


Pag. 328



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

} }


Pag. 329

Problema 94

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



import biblioteca.* ; class PrgTragamoneda2 {


int valor1 = 0, valor2 = 0, valor3 = 0, monto = 0, acumonto = 0 ; char s,opc1 ; do { System.out.println ( “Presionar enter para empezar” ) ; Lectura.leerString ( ) ; valor1=( int ) (1 + ( Math.random ( ) * 7 ) ) ; valor2=( int ) (1 + ( Math.random ( ) * 7 ) ) ; valor3=( int ) (1 + ( Math.random ( ) * 7 ) ) ; System.out.println ( valor1 + “ ” + valor2 + “ ” + valor3 ) ; if ( valor1 == valor2 && valor1 == valor3 ) { s= (char) valor1 ; switch ( s ) { case 1 : monto=100 ; break ; case 2 : monto=200 ; break ;


Pag. 330



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

Problema 95

Etapa 01 - Descripción del problema. Las computadoras están desempeñando un papel cada vez más importante en la educación. Desarrolle un programa que ayude a un estudiante de primaria a aprender a multiplicar. Utilice números aleatorios para producir dos enteros positivos de un solo digito. El programa deberá preguntar ¿Cuánto es 6 por 7?, El estudiante deberá ingresar la respuesta. El programa verificara si la respuesta es correcta. Si es correcta mostrará un mensaje ¡Muy bien! y si es incorrecto mostrará el mensaje ¡No es correcto, por favor intente otra vez!. Etapa 04 - Desarrollo de la Codificación.

Clase PrgMultiplicacion


import biblioteca.* ; class PrgMultiplicacion {


int valor1 = 0, valor2 = 0, resul1 = 0, resul2 = 0 ; char s, opc1 ; do { System.out.println ( “Aprendiendo a Multiplicar” ) ; Lectura.leerString ( ) ; valor1 = ( int ) (1 + ( Math.random() * 9 ) ) ; valor2 = ( int ) (1 + ( Math.random() * 9 ) ) ; resul1 = valor1 * valor2 ; System.out.println ( “¿Cuánto es ” + valor1 + “ por ” + valor2 + “ ?” ) ; System.out.println ( “Ingresar resultado de la multiplicación : ” ) ; resul2 = Lectura.leerInt ( ) ; if ( resul1 == resul2 ) System.out.println ( “Respuesta correcta… Muy bien” ) ; else System.out.println ( “No es la respuesta correcta… Vuelva a intentarlo” ) ; System.out.println ( “Desea volver a intentarlo [s/n] : ” ) ; opc1 = Lectura.leerChar ( ) ; } while ( opc1 != ‘n’ ) ;

} }


Pag. 332

Problema 96

Etapa 01 - Descripción del problema. Modificar el programa del problema anterior, de tal forma que se muestre un menú de opciones donde permita sumar, restar, multiplicar y dividir dos números generados al azar. Se permitirá al estudiante contestar la misma pregunta una y otra vez hasta que responda correctamente. Etapa 04 - Desarrollo de la Codificación.

Clase PrgMenuOperaciones1


import biblioteca.* ; 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 ( ) ; valor1=( int ) (1 + ( Math.random ( ) * 9 ) ) ; valor2=( int ) (1 + ( Math.random ( ) * 9 ) ) ; switch ( op ) { case 1 : resul1 = valor1 + valor2 ; operacion = “Suma” ; signo = ‘+’ ; break ;


Pag. 333



case 2 : resul1 = valor1 - valor2 ; operacion = “Resta” ; signo = ‘-’ ;

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

}


Pag. 334

Problema 97

Etapa 01 - Descripción del problema. Modificar el programa del problema anterior, de tal forma que se muestre un menú de opciones donde permita sumar, restar, multiplicar y dividir dos números al azar. Mostrar la cantidad de preguntas correctas y la cantidad de preguntas incorrectas. Etapa 04 - Desarrollo de la Codificación.



import biblioteca.* ; 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 ( ) ; valor1 = ( int ) (1 + ( Math.random ( ) * 9 ) ) ; valor2 = ( int ) (1 + ( Math.random ( ) * 9 ) ) ; switch ( op ) { case 1 : resul1 = valor1 + valor2 ; operacion = “Suma” ; signo = ‘+’ ; break ;


Pag. 335



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

} }


Pag. 336

Problema 98

Etapa 01 - Descripción del problema. Elaborar un programa que permita adivinar cuál es el número entero generado al azar entre 1 y 1000. El jugador ingresará una primera estimación, si la estimación del jugador es incorrecta, el programa deberá indicar si el número ingresado fue más grande o fué más pequeño que el número generado al azar. Cuando la respuesta sea correcta se mostrará un mensaje de felicitaciones. Etapa 04 - Desarrollo de la Codificación.

Clase PrgAdivinarNumero1


import biblioteca.* ; 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 : ” ) ; num = Lectura.leerInt ( ) ; if ( num < valor ) System.out.println ( “El número es demasiado chico. Pruebe otra vez” ) ; else if ( num > valor ) System.out.println ( “El número es demasiado grande. Pruebe otra vez” ) ; else System.out.println ( “Felicidades adivinaste el número ” ) ; } while (num != valor ) ; System.out.println ( “Desea Continuar [s/n]: ” ) ; opc = Lectura.leerChar ( ) ; } while ( opc != ‘n’ ) ;

} }


Pag. 337

Problema 99

Etapa 01 - Descripción del problema. Modificar el programa del problema anterior, de tal forma que se pueda ingresar la cantidad de intentos que se tiene para adivinar el número. Etapa 04 - Desarrollo de la Codificación.

Clase PrgAdivinarNumero2


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 : ” ) ; num = Lectura.leerInt ( ) ; if (cont >= intentos ) { System.out.println ( “Deberías haberlo hecho mejor” ) ; valor = num ; } else if ( num < valor ) System.out.println ( “El número es demasiado chico. Pruebe otra vez” ) ; else if ( num > valor ) System.out.println ( “El número es demasiado grande. Pruebe otra vez ” ) ; else System.out.println ( “Felicidades adivinaste el número” ) ; cont ++ ; } while ( num != valor ) ; System.out.println ( “Desea Continuar [s/n]: ” ) ; opc=Lectura.leerChar ( ) ; } while ( opc != ‘n’ ) ;

} }


Pag. 338


Pag. 339

MANEJO DE CADENAS: CLASE STRING INTRODUCCIÓN

Una cadena es un conjunto de caracteres, números y símbolos especiales almacenados en una variable de tipo texto o cadena. La clase String, es una clase que viene incorporada en el lenguaje de programación Java, incluida en el paquete java.lang, la cual permite declarar y manipular variables de tipo texto o cadena (en realidad no se declaran variables de tipo texto o cadena, sino que se crean objetos de la clase String). Ejemplo:

String nom = “Danae” ;

JERARQUÍA DE CLASES Y HERENCIA 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.

java.lang.Object

java.lang.String


Pag. 340

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

CLASE String

MÉTODOS DE INSTANCIA DESCRIPCIÓN USO

charAt(int)

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

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

compareTo(String)

Si la cadena es alfabéticamente menor que la cadena colocada como parámetro, el método devuelve un número entero menor que cero. Si las dos cadenas son alfabéticamente iguales devuelve un número cero y si la cadena es alfabéticmente mayor que la cadena colocada como parámetro, el método devuelve un entero mayor que cero.

String cad1 = “Hola Danae”; String cad2 = “Hola Pedro”; int x = cad1.compareTo(cad2); Resultado: x < 0 (cad1<cad2).

concat(String)

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

String cad1, cad2, cadena; cad1 = "Hola"; cad2 = " a todos"; cadena = cad1.concat (cad2); Resultado : cadena = "Hola a todos”

endsWith(String)

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

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

equals(String)

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

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

equalsIgnoreCase(String)

Este método realiza la misma función que el método equals ( ) pero la comparación la realiza sin tener en cuenta las letras minúscula y mayúscula.

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


Pag. 342


x = true.

indexOf(char)

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

indexOf(char,int)

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

indexOf(String)

String cad1 = “Hola Danae”; int x = cad1.indexOf( “ana” ); Resultado: x = 6.

indexOf(String, int)

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

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

lastIndexOf(char)

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

lastIndexOf(char,int)

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

lastIndexOf(String)

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

lastIndexOf(String,int)

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

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


Pag. 343


length()

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

String cad1 = “Hola Danae”; int x = cad1.length(); Resultado: x = 10.

replace(char,char)

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

String cad1 = “Hola Danae”; String x = cad1.replace(‘a’, ‘o’); Resultado: x = “Holo Donoe”.

startsWith(String)

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

String cad1 = “Hola Danae”; String cad2 = “Hola”; boolean x; x = cad1.startsWith(cad2); Resultado: x = true.

substring(int)

String cad1 = “Hola Danae”; String x = cad1.substring(5); Resultado: x = “Danae”.

substring(int,int)

Devuelve una subcadena a partir de la cadena especificada, empezando desde la posición indicada en el primer parámetro hasta el final o hasta una posición anterior a la indicada en el segundo parámetro del método.

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

toCharArray()

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

String cad1 = “Hola Danae”; char[ ] x = cad1.toCharArray(); Resultado: x = {‘H’,‘o’,‘l’,‘a’,‘ ’, ‘D’, ‘a’, ‘n’, ‘a’,‘e’}.

toLowerCase()

Convierte las letras de una cadena en letras minúsculas.

String cad1 = “Hola Danae”; String x = cad1.toLowerCase(); Resultado: x = “hola danae”.

trim()

Permite eliminar los espacios en blanco del inicio y del final de una cadena.

String cad1 = “ Hola Danae ”; String x = cad1.trim(); Resultado: x = “Hola Danae”.


Pag. 344


toUpperCase()

Convierte las letras de una cadena en letras mayúsculas.

String cad1 = “Hola Danae”; String x = cad1.toUpperCase(); Resultado: x = “HOLA DANAE”.

MÉTODO DE CLASE DESCRIPCIÓN USO

String.valueOf(boolean) String.valueOf(int) String.valueOf(long) String.valueOf(float) String.valueOf(double) String.valueOf(Object) String.valueOf(char[ ]) String.valueOf(char[ ], int,int)

Método de clase que permite convertir los valores de otros tipos de datos o variables a una cadena.

double pi = 3.1416; String x = String.valueOf(pi); resultado: x = “3.1416”.

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


Pag. 345

Problema 100

Etapa 01 – Descripción del problema. Desarrollar un programa en Java que permita ingresar el nombre de un alumno. Mostrar el nombre del alumno en letras mayúscula. Etapa 04 – Desarrollo de la codificación.

Clase PrgConvertirMayuscula


import biblioteca.* ; public class PrgConvertirMayuscula {

public static void main(String [ ] args) {

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

} }

¿Qué hay de nuevo en la codificación? Observe el uso del método toUpperCase ( ) de la clase String:

nom.toUpperCase ( ) ; 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:

Nombre de la variable (objeto).

Operador punto.

Nombre del método.


Pag. 346

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

Problema 101

Etapa 01 – Descripción del problema. Desarrollar un programa en Java que permita ingresar el nombre de un alumno. Mostrar el nombre del alumno en letras minúsculas. Etapa 04 – Desarrollo de la codificación.

Clase PrgConvertirMinuscula


import biblioteca.* ; public class PrgConvertirMinuscula {


String nom ; System.out.print ( “ Ingresar el nombre: ” ) ; nom = Lectura.leerString( ) ; nom = nom.toLowerCase( ) ; System.out.println ( “ El nombre en Minúscula es: ” + nom ) ;

} }

¿Qué hay de nuevo en la codificación? Observe el uso del método toLowerCase ( ) de la clase String:

nom.toLowerCase ( ) ; 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:

Nombre de la variable (objeto).

Operador punto.

Nombre del método.


Pag. 348

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

Problema 102

Etapa 01 – Descripción del problema. Desarrollar un programa en Java que permita ingresar el primer nombre y el segundo nombre de un alumno. Concatenar y Mostrar los nombres del alumno en letras mayúsculas y letra minúsculas. Etapa 04 – Desarrollo de la codificación.

Clase PrgConcatenarNombres


import biblioteca.* ; 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: ” ) ; nom2 = Lectura.leerString( ) ; nom1 = nom1.concat(espacio) ; nombre = nom1.concat(nom2) ; System.out.println ( “ El nombre en Mayúscula es: ”" + nombre.toUpperCase() ) ; System.out.println ( “ El nombre en Minúscula es: ” + nombre.toLowerCase() ) ;

} }

¿Qué hay de nuevo en la codificación? Observe el uso del método concat ( ) de la clase String:

nom = nom.concat (espacio) ; El método concat ( ) se utiliza para juntar o concatenar el contenido de dos variables de tipo String (la misma función cumple el signo “+ “cuando trabaja con variables de tipo String). Es decir, el contenido de la variable nom1 y el contenido de la variable espacio se juntan (o concatenan) y el resultado se almacena en la variable que antecede al signo = (en nuestro caso la misma variable nom1). Luego el contenido de la variable nom1 se junta con el contenido de la variable nom2 y el resultado se almacena en la variable nombre.

nom1 = nom1.concat (espacio) ; nombre = nom1.concat(nom2) ;


Pag. 350

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

Problema 103

Etapa 01 – Descripción del problema. Desarrollar un programa en Java que permita ingresar el nombre de un alumno. Mostrar el número de caracteres del nombre ingresado por teclado. Consistenciar el nombre del alumno al momento de ingresarlo. Etapa 04 – Desarrollo de la codificación.

Clase PrgLongitudCadena


import biblioteca.* ; public class PrgLongitudCadena {


int cant ; String nom ; do {

System.out.println ( “ Ingresar el nombre: ” ) ; nom = Lectura.leerString( ) ; nom = nom.trim( ) ; if ( nom.length( ) < 2 ) {

System.out.println ( “ Nombre ingresado no válido… Reintente! ” ) ; }

} while (nom.length( ) < 2 ) ; cant = nom.length( ) ; System.out.println ( “ La cantidad de caracteres del nombre es: ” + cant ) ;

} }

¿Qué hay de nuevo en la codificación? Observe el uso del método trim ( ) de la clase String:

nom = nom.trim ( ) ; El método trim ( ) permite eliminar los espacios en blanco que pueden existir al inicio y/o al final de una cadena contenida en una variable (en nuestro caso la cadena contenida en la variable nom). Esto se realiza como precaución, ya que el usuario puede haber presionado la barra espaciadora antes de ingresar el nombre del alumno y esto se almacena en la variable como espacios en blanco. También observe el uso del método length ( ) de la clase String:


Pag. 352

cant = nom.length ( ) ; El método length ( ) se utiliza con variables de tipo String y nos permite contar la cantidad de caracteres que almacena una variable (en nuestro caso, la cantidad de caracteres que almacena la variable nom). Como el método length ( ) devuelve la cantidad de caracteres que tiene una variable (incluido los espacios en blanco), podemos mostrar el resultado utilizando System.out.println(), utilizarlo en una condición lógica o almacenarlo en una variable. En nuestro ejemplo lo utilizamos como condición lógica y para almacenarlo en una variable. En la líneas de código mostradas a continuación, se consistencia el ingreso del nombre de tal forma que no se permita ingresar un nombre que tenga menos de 2 caracteres (se asume que pueden haber nombres de 2 caracteres o mas, como por ejemplo; Lu, Ana, José, Pedro, que tienen 2, 3, 4, y 5 caracteres respectivamente).

do { System.out.println ( “ Ingresar el nombre: ” ) ; nom = Lectura.leerString( ) ; nom = nom.trim ( ) ; if ( nom.length ( ) < 2 ) {

System.out.println ( “Nombre ingresado no válido… Reintente! ” ) ; }

} while (nom.length ( ) < 2) ;


Pag. 353

Problema 104

Etapa 01 – Descripción del problema. Desarrollar un programa en Java que permita ingresar el nombre de un alumno. Mostrar el nombre del alumno en letras mayúscula. Consistenciar el nombre del alumno al momento de ingresarlo. Etapa 04 – Desarrollo de la codificación.

Clase PrgConvertirMayuscula2


import biblioteca.* ; public class PrgConvertirMayuscula2 {


String nom ;

do { System.out.println ( “ Ingresar el nombre: ” ) ; nom = Lectura.leerString( ) ; nom = nom.trim( ) ; if ( nom.length( ) < 2 ) {


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

Problema 105

Etapa 01 – Descripción del problema. Desarrollar un programa en Java que permita ingresar el nombre de un alumno. Mostrar el primer caracter del nombre ingresado en mayúsculas. Etapa 04 – Desarrollo de la codificación.

Clase PrgPrimeroMayuscula


import biblioteca.* ; public class PrgPrimeroMayuscula {


String nom, cadena1= “”, cadena2= “” ; do {



} while (nom.length( ) < 2 ) ; cadena1 = nom.substring(0,1) ; cadena1 = cadena1.toUpperCase( ) ; cadena2 = nom.substring(1) ; nom = cadena1.concat(cadena2) ;

System.out.println ( “ El nombre del alumno es: ” + nom ) ;

} }

¿Qué hay de nuevo en la codificación? Observe el uso del método substring ( ) de la clase String:

cadena1 = nom.substring(0,1) ; cadena2 = nom.substring(1) ;

El método substring ( ) se utiliza de dos formas. La primera forma nos permite obtener una subcadena desde una posición inicial hasta un caracter antes de la posición final indicada. La segunda forma nos permite obtener una subcadena desde una posición determinada hasta el final de la cadena. Imagínese que la variable nom contiene el nombre “danae”, tal y como se muestra a continuación:


Pag. 355

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”. Entonces, si deseamos obtener la primera letra de la cadena utilizamos la siguiente sentencia:

cadena1 = nom.substring(0,1) ; Donde, el primer número del método substring ( ) indica la posición de la cadena nom desde donde va a empezar la subcadena y el segundo número indica la posición final de la cadena (es importante mencionar que se debe incluir hasta un caracter antes de la posición final indicada). Esto nos permite solo obtener el primer caracter de nom (la letra “d”). Suponiendo que se desee obtener la subcadena “ana” de la cadena “danae” contenida en la variable nom, utilizaríamos la siguiente sentencia:

cadena1 = nom.substring (1,4) ; Continuando con nuestro ejemplo, una vez obtenida la primera letra del nombre se convierte a mayúscula utilizando:

cadena1 = cadena1.toUpperCase ( ) ; Ahora es necesario obtener el resto del contenido de la variable nom. Esto lo realizamos utilizando:

cadena2 = nom.substring (1) ; Esta es la segunda forma de utilizar el método substring ( ), donde el número (en nuestro caso el número 1), indica la posición de la cadena nom donde va a comenzar la subcadena (la primera letra “a”) hasta el final de la cadena. Ahora en la variable cadena1 tenemos almacenada la letra “D” y en la variable cadena2 tenemos almacenadas las letras “anae”. Para finalizar solo será necesario juntar o concatenar ambas variables en la variable original nom, utilizando el método concat ( ).

nom = cadena1.concat (cadena2) ; El resultado que se obtiene es el nombre ingresado con la primera letra en mayúscula.

posición 0


Pag. 356

Problema 106

Etapa 01 – Descripción del problema. Desarrollar un programa en Java que permita ingresar el nombre de un alumno. Mostrar el primer caracter del nombre ingresado en mayúsculas y el resto en minúscula. Etapa 04 – Desarrollo de la codificación.

Clase PrgMayusculaMinuscula


import biblioteca.* ; public class PrgMayusculaMinuscula {


int cant ; String nom, cadena1 = “” , cadena2 = “” ; do {

System.out.println ( “ Ingresar el nombre: ” ) ; nom = Lectura.leerString( ) ; nom = nom.trim( ) ; if ( nom.length( ) < 2) {


} while (nom.length( ) < 2 ) ; cadena1 = nom.substring(0,1) ; cadena1 = cadena1.toUpperCase( ) ; cadena2 = nom.substring(1) ; cadena2 = cadena2.toLowerCase( ) ; nom = cadena1.concat(cadena2) ; System.out.println ( “ El nombre del alumno es: ” + nom ) ;

} }

Observe el uso de los métodos trim ( ), length ( ), substring ( ) en sus dos formas, toUpperCase ( ), toLowerCase ( ) y concat ( ) de la clase String. En la codificación de este programa, se convierte en mayúscula la primera letra del nombre y el resto se convierte en minúscula. Esto como precaución de que se ingrese todo el nombre en mayúscula o en forma combinada entre letras mayúsculas y minúsculas. Finalmente siempre el nombre tendrá la primera letra en mayúscula y el resto en letra minúscula. En consecuencia, se puede afirmar que esta solución es más óptima que la solución presentada en el problema 104.


Pag. 357

Problema 107

Etapa 01 – Descripción del problema. Desarrollar un programa en Java que permita ingresar el nombre completo de un alumno (nombres y apellidos en una sola variable). Mostrar el primer caracter de cada palabra del nombre en mayúsculas y el resto de cada palabra en minúscula. Etapa 04 – Desarrollo de la codificación.

Clase PrgNombreCompleto


import biblioteca.* ; public class PrgNombreCompleto {

public static void main(String [ ] args) { int cant ; String nom, cadena1 = “”,cadena2 = “”, caracter ;

do { System.out.println ( “ Ingresar el nombre: ” ) ; nom = Lectura.leerString( ) ; nom = nom.trim( ) ;

if ( nom.length( ) < 2) { System.out.println ( “ Nombre ingresado no válido… Reintente! ” ) ;

} } while (nom.length( ) < 2) ;

cant = nom.length( ) ; for (int x=0; x<cant; x++) {

if ( x==0) { cadena1 = nom.substring(0,1) ; cadena1 = cadena1.toUpperCase( ) ; cadena2 = nom.substring(1) ; cadena2 = cadena2.toLowerCase( ) ; nom = cadena1.concat(cadena2) ;

} else { caracter = nom.substring(x, x+1) ; if (caracter.equals ( “ ” ) ) {

cadena1 = nom.substring(0,x+1) ; caracter = nom.substring(x+1, x+2) ; caracter = caracter.toUpperCase( ); cadena2 = nom.substring(x+2) ; nom = cadena1 + caracter + cadena2 ;

} }

} System.out.println ( “ El nombre del alumno es: ” + nom ) ;

} }

¿Qué hay de nuevo en la codificación?


Pag. 358

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. Después se concatenan las tres variables y se almacenan en la variable nom. El proceso se repite hasta llegar al final de la cadena. Ahora considere si entre los nombres existe más de un espacio en blanco. ¿Qué sucede? Modificando la solución anterior para poder considerar la problemática anterior tendríamos la siguiente variación:

cant = nom.length( ) ; sw = false ; for (int x=0; x<cant; x++) {

if (x==0) { cadena1 = nom.substring(0,1) ; cadena1 = cadena1.toUpperCase( ) ; cadena2 = nom.substring(1) ; cadena2 = cadena2.toLowerCase( ) ; nom = cadena1.concat(cadena2) ;

} else { caracter = nom.substring(x, x+1) ; if (caracter.equals( “ ” ) ) {

sw = true ; } else {

if (sw) {

A

cadena1 caracter cadena2


Pag. 359

cadena1 = nom.substring(0,x) ; caracter = nom.substring(x, x+1) ; caracter = caracter.toUpperCase( ); cadena2 = nom.substring(x+1) ; nom = cadena1 + caracter + cadena2 ; sw = false ;

} }

} }

En esta parte modificada de la solución se utiliza un centinela (o flag) que nos permite indicar el momento preciso para realizar la conversión de la primera letra del nombre o apellido a letra mayúscula, sin preocuparnos de la cantidad de espacios en blanco que pueda existir entre dos nombres.


Pag. 360

Problema 108

Etapa 01 – Descripción del problema. Desarrollar un programa en Java que permita ingresar los apellidos y nombres de un obrero (en una sola variable). Mostrar el número de caracteres blancos o espacios en blanco que existan. Etapa 04 – Desarrollo de la codificación.

Clase PrgLongitudCadenaBlanco


import biblioteca.* ; public class PrgLongitudCadenaBlanco {


int x,cant,cont=0 ; String nom,caracter ; do {



} while (nom.length( ) < 2 ) ; cant = nom.length( ) ; for (x=0;x<cant;x++) { caracter = nom.substring(x,x+1) ; if (caracter.equals ( “ ” ) ) { cont ++ ; } } System.out.println ( “ La cantidad de espacios: ” + cont ) ;

} }

Observe el uso de los 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. 361

Problema 109

Etapa 01 – Descripción del problema. Desarrollar un programa en Java que permita ingresar los apellidos y nombres de un obrero (en una sola variable). Mostrar el número de caracteres del nombre ingresado por teclado que no sean espacios en blanco. Etapa 04 – Desarrollo de la codificación.

Clase PrgLongitudCadenaNoBlanco


import biblioteca.* ; public class PrgLongitudCadenaNoBlanco {


int cant,x; String nom, cadena = “”, caracter ;

do {



} while (nom.length( ) < 2 ) ;

cant = nom.length( ) ; for (x=0; x<cant; x++) { caracter = nom.substring(x,x+1) ; if ( !caracter.equals ( “ ” ) ) { cadena = cadena.concat(caracter) ; } } cant = cadena.length( ) ; System.out.println ( “ La cantidad de caracteres sin contar espacios: ” + cant ) ;

} }

Observe el uso de los métodos trim ( ), length ( ), substring ( ) y equals ( ) de la clase String. En la codificación de este programa, se evalúa caracter por caracter (de la variable nom). Si el caracter no es un espacio en blanco se junta o concatena con los caracteres de la variable cadena (al inicio no contiene ningún caracter). Al final se obtiene la longitud de la variable cadena, que equivale a la cantidad de caracteres de la variable nom diferentes a espacios en blanco.


Pag. 362

Problema 110

Etapa 01 – Descripción del problema. Desarrollar una solución que permita ingresar los apellidos y nombres de un obrero (en una sola variable). Mostrar el número de caracteres que no son espacios en blanco y el número de caracteres que son espacios en blanco. Etapa 04 – Desarrollo de la codificación.

Clase PrgLongitudCadenaBlancoNoBlanco


import biblioteca.* ; public class PrgLongitudCadenaBlancoNoBlanco {


int x, cant, cont = 0 ; String nom, caracter ;

do { System.out.println ( “ Ingresar el nombre: ” ) ; nom = Lectura.leerString( ) ; nom = nom.trim( ) ; if ( nom.length( ) < 2 ) {


} while (nom.length( ) < 2 ) ;

cant = nom.length( ) ;

fo r(x=0; x<cant; x++) { caracter = nom.substring(x,x+1) ; if (caracter.equals ( “ ” ) ) { cont ++ ; } }

System.out.println ( “ La cantidad de espacios: ” + cont ) ; System.out.println ( “ La cantidad de caracteres sin contar espacios: ” + ( cant - cont ) ) ;

} }

En la 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. 363

Problema 111

Etapa 01 – Descripción del problema. Desarrollar una solución que permita ingresar el nombre de un alumno. Mostrar el número de vocales que hay en el nombre ingresado. Etapa 04 – Desarrollo de la codificación.

Clase PrgTotalVocales1


import biblioteca.* ; public class PrgTotalVocales1 {


int cant, cont = 0, d = 0, x ; String nom ; char c = ‘ ’ ; do {

System.out.println ( “ Ingresar el nombre: ” ) ; nom = Lectura.leerString( ) ; nom = nom.trim( ) ; if ( nom.length( ) == 0 ) {


} while (nom.length( ) == 0 ) ; cant = nom.length( ) ; nom = nom.toLowerCase( ) ; for (x=0; x<cant; x++) { c = nom.charAt(x) ; d = (int) (c) ; switch (c) { case 97 : // a case 101 : // e case 105 : // i case 111 : // o case 117 : cont ++ ; // u

} } System.out.println ( “ El Total de Vocales es: ” + cont ) ;

} }


Pag. 364

¿Qué hay de nuevo en la codificación? Observe el uso del método charAt ( ) de la clase String:

nom.charAt (x) ; El método charAt ( ) se utiliza con variables de tipo String y nos permite obtener un caracter de una cadena. En nuestro caso, obtenemos un caracter de la variable nom y lo almacenamos en una variable de tipo char (el método charAt ( ) devuelve un caracter).

c = nom.charAt (x) ; El caracter obtenido es evaluado para determinar si es o no una vocal. Esta evaluación se realiza a través de los códigos ASC correspondientes a las vocales (es importante mencionar que la evaluación de una variable de tipo char se puede realizar utilizando los códigos ASC equivalentes a los caracteres especiales, letras y números). Antes de iniciar la evaluación de cada uno de los caracteres de la variable nom, se utiliza el método toLowerCase ( ) para asegurarnos de convertir a letras minúsculas todos los caracteres de la variable nom y luego utilizar los códigos ASC equivalentes a las vocales en minúscula. Modifique la solución anterior de tal forma que pueda determinar cuantas vocales almacenadas en la variable son a, e, i, o y u (en forma independiente).


Pag. 365

Problema 112

Etapa 01 – Descripción del problema. Desarrollar un programa en Java que permita ingresar el nombre de un alumno. Mostrar el número de vocales y el número de caracteres que no son vocales que hay en el nombre ingresado. Etapa 04 – Desarrollo de la codificación.

Clase PrgTotalVocalesNoVocales


import biblioteca.* ; public class PrgTotalVocalesNoVocales {


int cant, cont = 0 , d = 0 , x ; String nom ; char c = ‘ ’ ; do {



} while (nom.length( ) == 0 ) ; cant = nom.length( ) ; nom = nom.toLowerCase( ) ; for (x=0; x<cant; x++) { c = nom.charAt(x) ; d = (int) (c) ; switch (c) { case 97 : // a case 101 : // e case 105 : // i case 111 : // o case 117 : cont ++ ; // u

} } System.out.println ( “ El Total de Vocales es: ” + cont ) ; System.out.println ( “ El Total de caracteres que no son vocales es: ” + (cant – cont) ) ;

} }


Pag. 366

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

Problema 113

Etapa 01 – Descripción del problema. Desarrollar un programa en Java que permita ingresar dos cadenas. Contar y mostrar cuantas veces se repite la segunda cadena en la primera cadena ingresada. Etapa 04 – Desarrollo de la codificación.

Clase PrgCadenaSubcadena


import biblioteca.* ; 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. 368

Continúa... Etapa 04 - Desarrollo de la codificación.

Clase PrgCadenaSubcadena

} else { if (cad1.equals (cad2) ) {

System.out.println ( “ las cadenas son iguales ” ) ; } else {

System.out.println ( “ la segunda cadena no debe tener una longitud ” ) ; System.out.println ( “ mayor que la primera cadena ” ) ;

} }

} }

Observe el uso de los métodos trim ( ), length ( ), substring ( ) y equals ( ) de la clase String. La parte central de la solución radica en las siguientes líneas de código:

if (cad1.length( ) > cad2.length( ) ) { total = cad1.length( ) - cad2.length( ) ; for (i = 0; i <= total; i++) {

subcad = cad1.substring(i, i + cad2.length( ) ) ; if (cad2.equals (subcad)) {

cont ++ ; }

} System.out.println ( “ El número de veces que se repite ” ); System.out.println ( “ la subcadena en la cadena es: ” + cont ) ;

} else { if (cad1.equals (cad2) ) {

System.out.println ( “ las cadenas son iguales ” ) ; } else {

System.out.println ( “ la segunda cadena no debe tener una longitud ” ) ; System.out.println ( “ mayor que la primera cadena ” ) ;

} }

En primer lugar, se verifica que la primera cadena (cad1) tenga una longitud mayor que la segunda cadena (cad2). Luego, se obtiene la diferencia entre las longitudes de cad1 y cad2, y se almacena en la variable total. El límite para la evaluación del número de veces que se repite cad2 en cad1, es el caracter ubicado en la posición total de cad2. Después, empezando desde el primer caracter de cad1 se extrae una subcadena (subcad) del mismo tamaño que cad2 y se comparan para ver si son iguales utilizando el método equals ( ). Si son iguales el contador cont aumenta en 1. Este proceso se repite utilizando el siguiente caracter de cad1. Como ejemplo utilizaremos las siguientes cadenas:

cad1 = “Danae” cad2 = “ana” En primer lugar determinamos que cad1 tiene una longitud mayor que cad2. Luego, calculamos el valor de la variable total (total = 5-3 = 2).


Pag. 369

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

0 1 2

Límite para la evaluación

Observe que cad2 tiene una longitud=3 por lo que la última evaluación será: cad2 = “ana” y subcad= “nae”

Finalmente, se concluye que cad2 se repite una vez en cad1.


Pag. 370

Problema 114

Etapa 01 – Descripción del problema. Desarrollar un programa en Java que permita ingresar el nombre de dos alumnos. Mostrar si los nombres ingresados son iguales o no. Etapa 04 – Desarrollo de la codificación.

Clase PrgNombresIguales


import biblioteca.* ; public class PrgNombresIguales {


String nom1, nom2 ;

do { System.out.println ( “ Ingresar el nombre del primer alumno: ” ) ; nom1 = Lectura.leerString( ) ; nom1 = nom1.trim( ) ; if ( nom1.length( ) < 2 ) {

System.out.println("Nombre ingresado no válido… Reintente! "); }

} while ( nom1.length( ) < 2 ) ;

do { System.out.println ( “ Ingresar el nombre del segundo alumno: ” ) ; nom2 = Lectura.leerString( ) ; nom2 = nom2.trim( ) ; if ( nom2.length( ) < 2 ) {


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

Problema 115

Etapa 01 – Descripción del problema. Desarrollar un programa en Java que permita ingresar los nombres de dos alumnos. Mostrar los nombres ordenados alfabéticamente. Etapa 04 – Desarrollo de la codificación.

Clase PrgOrdenados1


import biblioteca.* ; 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: ” ) ; nombre2 = Lectura.leerString( ) ; if (nombre1.compareTo(nombre2) < 0 ) {

nombreMenor = nombre1 ; nombreMayor = nombre2 ;

} else { nombreMenor = nombre2 ; nombreMayor = nombre1 ;

} System.out.println ( “ ------------------------------------------------- ” ) ; System.out.println ( “ Nombres ordenados alfabéticamente ” ) ; System.out.println ( “ ------------------------------------------------- ” ) ; System.out.println (nombreMenor) ; System.out.println (nombreMayor) ;

} }

¿Qué hay de nuevo en la codificación? Observe el uso del método compareTo ( ) de la clase String:

nombre1.compareTo (nombre2) ; El método compareTo ( ) permite comparar dos variables de tipo String. El método permite compareTo ( ) nos devuelve un valor entero. Si el valor devuelto es igual a cero (0), entonces las cadenas son iguales, es decir; las variables nombre1 y nombre2 contiene cadenas iguales. Si el valor devuelto es mayor que cero (0), entonces la variable nombre1 es mayor que la variable nombre2. Finalmente, si el valor devuelto es menor que cero, entonces la variable nombre1 es menor que la variable nombre2.


Pag. 372

Cuando se comparan dos cadenas, se realiza una comparación alfabética en la cual tienen significado las letras mayúsculas, las letras minúsculas, los caracteres especiales y los espacios en blanco. Por ejemplo; comparemos las siguientes cadenas:

1. nombre1 = “Pedro” y nombre2 = “Luis”. 2. nombre1 = “Danae” y nombre2 = “Danae”. 3. nombre1 = “Carmen” y nombre2 = “Juan”.

En base a esto, mejore la solución de tal forma que se pueda realizar la consistencia de los nombres ingresados.

nombre1 > nombre2

nombre1 = nombre2

nombre1 < nombre2


Pag. 373

Problema 116

Etapa 01 – Descripción del problema. Desarrollar un programa en Java que permita ingresar los nombres de dos alumnos (no permite el ingreso de solo espacios en blanco). Mostrar los nombres ordenados alfabéticamente. Etapa 04 – Desarrollo de la codificación.

Clase PrgOrdenados2 package dominioDeLaAplicacion ;



String nombre1, nombre2, nombreMayor, nombreMenor ; do {

System.out.println ( “ Ingrese el nombre de la primera persona: ” ) ; nombre1 = Lectura.leerString( ); nombre1 = nombre1.trim( ) ; if (nombre1.length( ) < 2 ) {

System.out.println ( “ Nombre ingresado no válido...Reintente!!! ” ) ; }

} while (nombre1.length( ) < 2 ) ; do {

System.out.println ( “ Ingrese el nombre de la segunda persona: ” ) ; nombre2 = Lectura.leerString( ) ; nombre2 = nombre2.trim( ) ;

if ( nombre2.length( ) < 2 ) {


} while ( nombre2.length( ) < 2 ) ; if ( nombre1.compareTo(nombre2) < 0 ) {

nombreMenor = nombre1 ; nombreMayor = nombre2 ;

} else { nombreMenor = nombre2 ; nombreMayor = nombre1 ;

}


Pag. 374


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

Problema 117

Etapa 01 – Descripción del problema. Desarrollar un programa en Java que permita ingresar los nombres de tres alumnos (los nombres no deben ser iguales). Mostrar los nombres ordenados alfabéticamente. Etapa 04 – Desarrollo de la codificación.

Clase PrgOrdenados3




String nombre1, nombre2, nombre3 ; String nom01 = “ ”, nom02 = “”, nom03 = “” ; do {

System.out.println ( “ Ingrese el nombre de la primera persona: ” ) ; nombre1 = Lectura.leerString( ) ; nombre1 = nombre1.trim( ) ; if ( nombre1.length( ) == 0 ) {


} while ( nombre1.length( ) == 0 ) ; do {

System.out.println ( “ Ingrese el nombre de la segunda persona: ” ) ; nombre2 = Lectura.leerString( ) ; nombre2 = nombre2.trim( ) ; if ( nombre2.length( ) == 0 ) {


} while (nombre2.length( ) == 0 ) ; do {

System.out.println ( “ Ingrese el nombre de la tercera persona: ” ) ; nombre3 = Lectura.leerString( ) ; nombre3 = nombre3.trim( ) ; if ( nombre3.length( ) == 0 ) {


} while ( nombre3.length( ) == 0 ) ;


Pag. 376


Clase PrgOrdenados3

if (nombre1.compareTo(nombre2) < 0 && nombre1.compareTo(nombre3) < 0 ) { nom01 = nombre1 ; if (nombre2.compareTo(nombre3) < 0 ) {

nom02 = nombre2 ; nom03 = nombre3 ;

} else { nom02 = nombre3 ; nom03 = nombre2 ;

} } if (nombre2.compareTo(nombre1) < 0 && nombre2.compareTo(nombre3) < 0) {

nom01 = nombre2 ; if (nombre1.compareTo(nombre3) < 0 ) {



} } if (nombre3.compareTo(nombre1) < 0 && nombre3.compareTo(nombre2) < 0 ) {




} } System.out.println ( “ ------------------------------------------------- ” ) ; System.out.println ( “ Nombres ordenados alfabéticamente ” ) ; System.out.println ( “ ------------------------------------------------- ” ) ; System.out.println (nom01) ; System.out.println (nom02) ; System.out.println (nom03) ;

} }

Desarrolle la siguiente prueba:

1. Ejecute el programa, ingrese los siguientes datos y compruebe lo que sucede: nombre1 = “Armando”. nombre2 = “Armando”. nombre3 = “Beto”. 2. Luego ingrese los siguientes datos y compruebe nuevamente lo que sucede: nombre1 = “Armando”. nombre2 = “Beto”. nombre3 = “Beto”. 3. Finalmente ingrese los siguientes datos. Compruebe lo que sucede:

nombre1 = “Armando”. nombre2 = “Armando”. nombre3 = “Armando”. Modifique la codificación de la solución de tal forma que pueda mejorarla.


Pag. 377

Problema 118

Etapa 01 – Descripción del problema. Desarrollar un programa en Java que permita ingresar los nombres de tres alumnos (los nombres pueden ser iguales). Mostrar los nombres ordenados alfabéticamente. Etapa 04 – Desarrollo de la codificación.

Clase PrgOrdenados4




String nombre1, nombre2, nombre3 ; String nom01 = “”, nom02 = “”, nom03 = “”; do {

System.out.println ( “ Ingrese el nombre de la primera persona: ” ) ; nombre1 = Lectura.leerString( ) ; nombre1 = nombre1.trim( ) ; if (nombre1.length( ) == 0 ) {



System.out.println ( “ Ingrese el nombre de la segunda persona: ” ) ; nombre2 = Lectura.leerString( ) ; nombre2 = nombre2.trim( ) ; if (nombre2.length( ) == 0) {



System.out.println ( “ Ingrese el nombre de la tercera persona: ” ) ; nombre3 = Lectura.leerString( ) ; nombre3 = nombre3.trim( ) ; if ( nombre3.length( ) == 0 ) {


} while (nombre3.length( ) == 0 ) ;


Pag. 378


Clase PrgOrdenados4

if ( nombre1.compareTo(nombre2) < 0 ) { if ( nombre1.compareTo(nombre3) < 0 ) {




} } else {

nom01 = nombre3 ; nom02 = nombre1 ; nom03 = nombre2 ;

} } else {

if ( nombre2.compareTo(nombre3) < 0 ) { nom01 = nombre2 ; if ( nombre1.compareTo(nombre3) < 0 ) {



} } else {


} } System.out.println ( “ ------------------------------------------------- ” ) ; System.out.println ( “ Nombres ordenados alfabéticamente ” ) ; System.out.println ( “ ------------------------------------------------- ” ) ; System.out.println (nom01) ; System.out.println (nom02) ; System.out.println (nom03) ;

} }

Desarrolle la siguiente prueba: Ingrese los nombres con letras mayúsculas y minúsculas, por ejemplo:

nombre1 = “armando”. nombre2 = “Beto”. nombre3 = “Armando”. Compruebe lo que sucede. Se ordenarán primero los nombres que comiencen con mayúscula y luego los nombres que comiencen con minúscula. Modifique el programa de tal forma que se cambie la primera letra del nombre ingresado a mayúscula.


Pag. 379

Problema 119

Etapa 01 – Descripción del problema. Desarrollar un programa en Java que permita ingresar los nombres de tres alumnos. Asegúrese que los nombres ingresados empiecen con una letra mayúscula. Mostrar los nombres ordenados alfabéticamente. Etapa 04 – Desarrollo de la codificación.

Clase PrgOrdenados5




String nombre1, nombre2, nombre3, letra, resto ; String nom01 = “”, nom02 = “”, nom03 = “” ; do {

System.out.println ( “ Ingrese el nombre de la primera persona: ” ) ; nombre1 = Lectura.leerString( ) ; nombre1 = nombre1.trim( ) ; if ( nombre1.length( ) == 0 ) {

System.out.println ( “ Nombre ingresado no válido...Reintente!!! ” ) ; } else {

nombre1 = ((nombre1.substring(0, 1)).toUpperCase()).concat(nombre1.substring(1)) ;

} } while ( nombre1.length( ) == 0 ) ; do {

System.out.println ( “ Ingrese el nombre de la segunda persona: ” ) ; nombre2 = Lectura.leerString( ) ; nombre2 = nombre2.trim( ) ; if ( nombre2.length( ) == 0 ) {

System.out.println ( “ Nombre ingresado no válido...Reintente!!! ” ) ; } else {

nombre2 = ((nombre2.substring(0, 1)).toUpperCase()).concat(nombre2.substring(1)) ;

} } while ( nombre2.length( ) == 0 ) ; do {

System.out.println ( “ Ingrese el nombre de la tercera persona: ” ) ; nombre3 = Lectura.leerString( ) ; nombre3 = nombre3.trim( ) ;


Pag. 380


Clase PrgOrdenados5

if ( nombre3.length( ) == 0 ) { System.out.println ( “ Nombre ingresado no válido...Reintente!!! ” ) ;

} else { nombre3 = ((nombre3.substring(0, 1)).toUpperCase()).concat(nombre3.substring(1)) ;

} } while ( nombre3.length( ) == 0 ) ; if ( nombre1.compareTo(nombre2) < 0 ) {




} } else {


} } else {




} } else {


} } System.out.println ( “ Nombres ordenados alfabéticamente ” ) ; System.out.println (nom01) ; System.out.println (nom02) ; System.out.println (nom03) ;

} }

Mejore la solución desarrollando un programa que permita ingresar tres nombres de alumnos. Asegúrese que los nombres ingresados empiecen con una letra mayúscula y que el resto de las letras de los nombres estén en minúscula. Muestre los nombres ordenados alfabéticamente. Luego, complemente la solución permitiendo el ingreso de los nombres de todos los alumnos de un determinado salón de clase.


Pag. 381

Problema 120

Etapa 01 – Descripción del problema. Desarrollar un programa en Java que permita ingresar el nombre de una persona, un caracter que este contenido en el nombre ingresado y otro caracter por el cual se reemplazará el primer caracter ingresado. Mostrar el nombre modificado. Etapa 04 – Desarrollo de la codificación.

Clase PrgCadenaModifcada


import biblioteca.* ; public class PrgCadenaModifcada {


int cant ; String nom, dato1, dato2, caracter, cadena= “” ; System.out.print ( “ Ingresar el nombre de una persona: ” ) ; nom = Lectura.leerString( ) ; System.out.print ( “ Ingrese el caracter que se va buscar: ” ) ; dato1 = Lectura.leerString( ) ; System.out.print ( “ Ingrese el caracter por el cual se va reemplazar: ” ) ; dato2 = Lectura.leerString( ) ; cant = nom.length( ) ; for (x=0; x<cant; x++ ) { caracter = nom.substring(x,x+1) ; if ( dato1.equals(caracter) == true ) cadena = cadena + dato2 ; else cadena = cadena + caracter ; } System.out.println ( “ El resultado es: ” + cadena ) ;

} }

¿Qué hay de nuevo en la codificación? Observe el uso del método equals ( ) de la clase String:

nombre1.equals (nombre2) ;


Pag. 382

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

Problema 121

Etapa 01 – Descripción del problema. Desarrollar un programa en Java que permita ingresar un número mayor de tres dígitos. Convertir el número en cadena, luego intercambiar posiciones, el primer digito pasarlo al último y el último digito pasarlo al primero. Mostrar el nuevo número. Etapa 04 – Desarrollo de la codificación.

Clase PrgIntercambioCadena


import biblioteca.* ; public class PrgIntercambioCadena {

public static void main(String [ ] args) { int num, cant; String dato1, dato2, dato3, cadena = ""; do { System.out.print(" Ingresar un numero mayor de 3 dígitos: "); num = Lectura.leerInt(); if (num < 100) { System.out.println(" Número ingresado no válido… Reintente! "); } } while (num < 100); cadena = String.valueOf(num); cant = cadena.length(); dato1 = cadena.substring(0, 1); dato2 = cadena.substring(1, cant - 1); dato3 = cadena.substring(cant-1); cadena = dato3 + dato2 + dato1; System.out.println(" El resultado es: " + cadena);}

}

¿Qué hay de nuevo en la codificación? Observe el uso del método valueOf ( ) de la clase String:

String.valueOf (num) ; El método valueOf ( ) se utiliza directamente con la clase String (y no con una variable de tipo String). Este método permite convertir una variable de cualquier tipo a una variable de tipo String o cadena. En nuestra solución convertimos la variable num a String con la finalidad de poder manipular el contenido de la variable con métodos de la clase String. Una vez convertida la variable num, se utiliza el método substring ( ) para intercambiar las posiciones deseadas.


Pag. 384

Problema 122

Etapa 01 – Descripción del problema. Desarrollar un programa en Java que permita ingresar el nombre de un alumno. Mostrar el nombre ingresado, de tal forma que se lea de izquierda a derecha (nombre mostrado al revés). Etapa 04 – Desarrollo de la codificación.

Clase PrgInvertirCadena


import biblioteca.* ; public class PrgInvertirCadena {


int cant, x ; String nom, caracter, cadena = “” ; do {



} while ( nom.length( ) == 0 ) ; cant = nom.length( ); for (x=cant-1; x>=0; x-- ) { caracter = nom.substring(x,x+1) ; cadena = cadena.concat(caracter) ; } System.out.println ( “ El nombre al revés es: ” + cadena ) ;

} }

¿Qué hay de nuevo en la codificación? Observe el uso del método concat ( ) de la clase String: En este programa, declaramos la variable caracter como una cadena (String). Cada vez que se ejecuta la sentencia for, se obtiene de la variable nom un caracter empezando desde el último y terminando en el primero. Cada vez que se obtiene un caracter este se agrega a la variable cadena, de tal forma que al finalizar la ejecución de la sentencia for se tiene almacenado en la variable cadena el nombre ingresado con los caracteres finales al inicio y los caracteres iniciales al final.


Pag. 385

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

Problema 123

Etapa 01 – Descripción del problema. Desarrollar un programa en Java que permita ingresar los nombres de 10 alumnos y permita visualizar la cantidad de nombres que empiezan con la letra “P” y la cantidad de nombres que terminan con la letra “a”. Etapa 04 – Desarrollo de la codificación.

Clase PrgCuentaLetras1


import biblioteca.* ; 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. 387

Problema 124

Etapa 01 – Descripción del problema. Desarrollar un programa en Java que permita ingresar los nombres de todos los empleados de una empresa. Mostrar el número de vocales que existen en cada uno de los nombres ingresados. Etapa 04 – Desarrollo de la codificación.

Clase PrgTotalVocales2


import biblioteca.* ; public class PrgTotalVocales2 {

public static void main(String [ ] args) { int cant, cont=0, opc, d=0, x ; String nom ; char c = ‘ ’ ;

do { do {


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

} while ( nom.length( ) == 0 ) ;

cant = nom.length( ) ; nom = nom.toLowerCase( ) ; for ( x=0; x<cant; x++ ) {

c = nom.charAt(x) ; d = (int) (c) ; switch(c) {

case 97 : // a case 101 : // e case 105 : // i case 111 : // o case 117 : cont ++ ; // u

} } System.out.println ( “ El Total de Vocales del nombre ingresado es: ” + cont ) ; System.out.println ( “ Desea ingresar otro nombre (Sí = 1, No = 2): ” ) ; opc =Lectura.leerInt( ) ;

} while ( opc != 1 ) ; }

}


Pag. 388

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

Problema 125

Etapa 01 - Descripción del problema. Desarrollar un programa en Java que permita ingresar los nombres de todos los productos de una determinada tienda. Mostrar como resultado las posiciones pares.


Clase PrgProductosTienda


import biblioteca.Lectura ; 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. 390

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

Problema 126

Etapa 01 - Descripción del problema. Desarrollar un programa en Java que permita ingresar los nombres de todos los alumnos de un salón de clase. Mostrar la longitud de cada nombre ingresado, el nombre que tiene la mayor longitud y el nombre que tiene la menor longitud.


Clase PrgLongitudNombre


import biblioteca.Lectura ; 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. 392

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

Problema 127

Etapa 01 - Descripción del problema. Desarrollar un programa en Java que permita ingresar una fecha con el siguiente formato “dd-mm-aaaa” y validarla.


Clase PrgFechaFormato


import biblioteca.Lectura ; 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. 394

Problema 128

Etapa 01 - Descripción del problema. Desarrollar un programa en Java que permita completar por la izquierda (utilizando asteriscos) una determinada cadena en base a una longitud especificada. Ejemplo: Se ingresa: Longitud = 10 Cadena = “Danae” Resultado: Cadena = “Danae*****”


Clase PrgCompletarCadenaIzq


import biblioteca.Lectura ; 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. 395

Problema 129

Etapa 01 - Descripción del problema. Desarrollar un programa en Java que permita completar por la derecha (utilizando asteriscos) una determinada cadena en base a una longitud especificada. Ejemplo: Se ingresa: Longitud = 10 Cadena = “Danae” Resultado: Cadena = “*****Danae”


Clase PrgCompletarCadenaDer


import biblioteca.Lectura ; 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. 396

Problema 130

Etapa 01 - Descripción del problema. Desarrollar un programa en Java que permita transformar un arreglo de caracteres en una cadena, especificando la posición del arreglo donde va ha comenzar la cadena y su longitud. Analizar la solución.


Clase PrgArregloCadena


import biblioteca.Lectura ; class PrgArregloCadena {


char arregloA = { ‘D’, ‘a’, ‘n’, ‘a’, ‘e’ } ; String cadena = String.valueOf (arregloA, 1, 3) ; System.out.println ( “ La cadena es: ” + cadena ) ;

} }

¿Qué hay de nuevo en la codificación? Observe el uso del método valueOf ( ) de la clase String:

String.valueOf ( char [ ], int, int ) ; El método valueOf ( ) se utiliza directamente con la clase String (y no con una variable de tipo String). Este método permite convertir un arreglo de caracteres o parte de él, en una variable de tipo String o cadena. En nuestra solución convertimos parte del arreglo arregloA a un String con la finalidad de mostrar el contenido de dicha variable. Observe que en este método, en primer lugar, se especifica el arreglo de tipo char del cual se va ha obtener la cadena. En segundo lugar, se indica la posición del arreglo desde el cual se van a tomar los datos y finalmente, se indica la longitud o el número de caracteres que se van a obtener del arreglo. En el ejemplo, se muestra como resultado la cadena “ana”. Los arreglos serán tratados en el siguiente capítulo.


Pag. 397

OTRAS CLASES EN JAVA En general, el lenguaje de programación Java incorpora una gran cantidad de clases en paquetes organizados en su Jerarquía de Clases. Es fundamental que se continúe investigando el uso de otras clases incorporadas en esta jerarquía de clases con la finalidad de mejorar la calidad de las soluciones que se desarrollen. En el CD, adjunto al presente texto, encontrará más información sobre otras clases de la Jerarquía de Clases de Java. Como ejemplo, se puede mencionar la clase DecimalFormat del paquete java.text. Problema 131

Etapa 01 - Descripción del problema. Desarrollar un programa en Java que permita ingresar un número por teclado. Mostrar el número ingresado con un formato determinado. Analizar la solución.


Clase PrgFormatoNumero


import biblioteca.Lectura ; 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. 398

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. • Problemas resueltos.

Desarrollo de soluciones utilizando múltiples arreglos: • Arreglos en paralelo. • Problemas resueltos.

Capítulo

4

ESTRUCTURAS DE DATOS – Arreglos.

Pag. 401

CAPÍTULO IV

ESTRUCTURA DE DATOS – ARREGLOS INTRODUCCIÓN Un algoritmo constituye una lista completa de pasos secuenciales y una descripción de datos necesarios para resolver un determinado problema. 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.


Etapa 02

Diseño Solución


Etapa 03

Etapa 04

ENUNCIADO DEL

PROBLEMA

MARCO DE TRABAJO


Pag. 402

El presente capítulo, trata sobre las estructuras de datos conocidas como arreglos y los conceptos más importantes relacionados a éstos; como se utilizan en las herramientas para diseñar algoritmos y como se emplean en un lenguaje de programación para codificar programas de computadora. Al desarrollar soluciones básicas, se utilizan las estructuras lógicas y las estructuras de datos en forma simultánea. Las estructuras lógicas y las estructuras de datos que se utilicen en una solución, van a depender en general de la complejidad del problema.


LISTA DE PASOS


SENTENCIAS

ALMACENADOS EN: • Estructuras de datos tipo variables. • Estructuras de datos tipo arreglo.

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

de programación utilizado.


Pag. 403

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

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

i

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

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:

X 0 X 1 X 2 ... X I-1

0 1 2 ... i -1

Donde: nombre = Nombre del vector. X0...X i -1 = Datos almacenados en el vector. i = Tamaño del vector.


Pag. 406

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:

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:

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 2 X 2,0

Filas

i-1 X i-1,0 X i-1,j -1 (i, j)

notas 10 15 20 19 14 13 16 11 17 09

i =10 0 1 2 3 4 5 6 7 8 9

Donde: nombre = Nombre de la matriz. X0,0...Xi-1, j -1 = Datos almacenados en la matriz. i * j = Tamaño de la matriz.

Donde: notas = Nombre del arreglo. i = Número de alumnos. 10, 15,...,09 = Son las notas finales de cada uno de los alumnos.


Pag. 407

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:

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:

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

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.


Pag. 408

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.

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]


Pag. 409

También se puede declarar un arreglo colocando los corchetes de apertura y cierre después del tipo de dato y no después del nombre del arreglo, según se muestra a continuación:

En pseudocódigo y diagrama de flujo: TipoDeDato[ ] arreglo TipoDeDato[ ][ ] arreglo

En Java:

TipoDeDato[ ] arreglo ; TipoDeDato[ ][ ] arreglo ;

Como ejemplo de declaración de arreglos válidos en Java podemos utilizar:

Creación de Arreglos Para crear un arreglo, es necesario que el arreglo previamente haya sido declarado, tal y como se explicó anteriormente.

Antes de crear un arreglo se debe determinar cual va ser el tamaño del mismo. Es decir, cual va ser la cantidad total de datos que se podrá almacenar en el arreglo. El tamaño de un arreglo puede especificarse en forma directa utilizando un número entero o en forma indirecta utilizando una variable entera. En ambos casos, el tamaño del arreglo siempre deberá especificarse como un número entero.

Para crear un arreglo se utiliza el siguiente formato:

En pseudocódigo y diagrama de flujo: CREAR arreglo[tamaño]

EJEMPLOS DESCRIPCIÓN

int edades[ ] ;

Se declara un arreglo unidimensional llamado edades en el cual se podrá almacenar datos de tipo NUMERO, solo parte entera (int).

String nombres[ ] ; Se declara un arreglo unidimensional llamado nombres en el cual se podrá almacenar datos de tipo TEXTO (String).

double notas[ ][ ] ;

Se declara un arreglo bidimensional llamado notas, en el cual se podrá almacenar datos de tipo NUMERO, parte entera y parte decimal (double).


Pag. 410

CREAR arreglo[filas ][columnas] En Java:

arreglo = new TipoDeDato [tamaño] ; arreglo = new TipoDeDato [filas][columnas] ;

Donde TipoDeDato debe ser un tipo de arreglo o tipo de dato válido y arreglo es el nombre del arreglo.

El operador new nos permite crear un arreglo. Cuando se crea un arreglo con el operador new, se debe indicar el tamaño del arreglo, es decir cuantos datos podrá almacenar. Es importante mencionar que el tipo de dato utilizado para crear un arreglo deberá ser el mismo tipo de dato con el cual se declaró el arreglo. Para crear un arreglo unidimensional es necesario especificar solo un índice, mientras que para crear un arreglo bidimensional es necesario especificar dos índices; uno para referirnos al número total de filas y el otro para referirnos al número total de columnas que va a tener el arreglo. En Java, existe también una forma directa para declarar y crear arreglos, utilizando el siguiente formato:

En Java: TipoDeDato arreglo[ ] = new TipoDeDato [tamaño]; TipoDeDato arreglo[ ][ ] = new TipoDeDato [filas][columnas];

Donde TipoDeDato debe ser un tipo de arreglo o tipo de dato válido y arreglo es el nombre del arreglo.

Utilizando este formato se declara y crea el arreglo en forma directa (esto es conocido como “Definición de un arreglo”). Las consideraciones tratadas en los temas “Declaración de arreglo” y “Creación de arreglos” son válidas al utilizar este formato.


Pag. 411

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):

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:

EJEMPLO DESCRIPCION

edades = new int [10] ;

Se crea un arreglo unidimensional llamado edades, previamente declarado, en el cual se podrá almacenar 10 datos de tipo NUMERO (int).

int total = 10 ; nombres = new String [total] ;

Se crea un arreglo unidimensional llamado nombres, previamente declarado, en el cual se podrá almacenar 10 datos de tipo TEXTO (String).

int numAlu, numNot ; numAlu = 10 ; numNot = 3 ; notas = new double [numNot][numAlu] ;

Se crea un arreglo bidimensional llamado notas, previamente declarado, en el cual se podrá almacenar 30 datos de tipo NUMERO (double).

EJEMPLOS int total ; System.out.print ( “Ingrese el numero total de alumno: ” ); total = Lectura.leerInt( ) ; nombres = new String[total] ;


Pag. 412

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;

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

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] ;


Pag. 413

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.

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 int edades[ ] = { 10,15,20,23,28,32,35,42,51,59 } ;

EJEMPLO char letras[ ] = { ‘A’, ‘B’, ‘C’, ‘D’ } ;


Pag. 414

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

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


Pag. 417

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. Esto significa que se puede incluir algunos parámetros al momento de ejecutar un proyecto de solución. Dichos parámetros se pasan al método main ( ) y se almacenan en el arreglo arg. Analizar las siguientes sentencias:

Clase Suma /* Clase que nos permite sumar varios números enteros , incluidos como parámetros */ package dominioDeLaAplicacion ; class Suma {


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: En primer lugar, los arreglos en Java poseen un atributo que almacena la cantidad de datos que pueden contener. Este atributo se denomina length.

public static void main ( String arg[ ] ) { }

Arreglo de tipo String denominado “arg”

for ( int i = 0 ; i < a.length ; i++ ) { suma += Integer.parseInt ( arg [ i ] ) ;

}


Pag. 418

En segundo lugar, cuando necesitamos convertir un dato a un número entero, utilizamos el método parseInt() de la clase Integer. En consecuencia, la lista de números se almacena en el arreglo arg de tipo String. Utilizando la sentencia for podemos acceder a cada uno de los datos almacenados en el arreglo arg[], lo convertimos a un dato tipo NUMERO utilizando Integer.parseInt(), y luego lo sumamos a la variable suma. Al finalizar la sentencia for se tiene la suma de los números incluidos como parámetros en la variable suma.

A continuación se presenta la codificación en Java de una solución que permite ingresar la nota final de 10 alumnos, y calcula el promedio general de notas del salón de clase.

Clase PrgAlumno package dominioDeLaAplicacion ; import biblioteca.* ; public class PrgAlumno {

public static void main ( String arg [ ] ) { int suma = 0, nota ; double promedio ; for ( int i = 0; i < 10 ; i ++ ) {

System.out.print ( “ Ingrese la Nota Final del Alumno ” + ( i + 1 ) ) ; nota = lectura.leerInt ( ) ; suma = suma + nota ;

} promedio = suma / 10 ; System.out.print ( “ El promedio general de notas es ” + promedio ) ;

} }

Observe que la solución anterior nos permite realizar el cálculo y la visualización del promedio general de notas. Pero, al utilizar solo una variable (notas), no podemos almacenar a la vez las notas finales de los 10 alumnos. (Recuerde que una variable solo nos permite almacenar un dato a la vez).


Pag. 419

A partir de este punto, se modificará el programa anterior, de tal forma que se incorporen progresivamente los conceptos tratados en este capítulo, para finalmente formalizar el Método de las 6’D. Es importante destacar que para trabajar con arreglos se deben seguir los siguientes pasos:

Declarar el arreglo o arreglos que se van ha utilizar en la solución del problema, definiendo un nombre adecuado para cada uno de ellos.

Crear el arreglo o arreglos con el tamaño necesario para poder almacenar todos

los datos.

Inicializar el arreglo o arreglos, o en su defecto, ingresar los datos necesarios al arreglo o arreglos utilizados en la solución.

Estos tres pasos generalmente se desarrollarán en todas las soluciones. A partir de este punto podemos realizar cualquier proceso con los datos almacenados en el arreglo o arreglos definidos en la solución. Por lo tanto, el siguiente paso quedaría definido de la siguiente manera:

Manejar los datos almacenados en el arreglo o arreglos utilizados en la solución con la finalidad de proporcionar la información solicitada.

En la solución, se utilizará un arreglo unidimensional llamado notas que permitirá almacenar las notas finales de 10 alumnos de un determinado salón de clase. El arreglo notas almacenará datos de tipo NUMERO (número entero con parte decimal). Una vez almacenadas las notas finales de los 10 alumnos se calculará y mostrará el promedio de las mismas.

Clase PrgAlumnos package dominioDeLaAplicacion ; import biblioteca.* ; public class PrgAlumnos {

public static void main ( String [ ] args ) { // Declaración de variables y arreglos. int numAlu =10 ; double sumaNotas=0, notas[ ] ; // Creación del arreglo notas. notas = new double [numAlu] ;


Pag. 420

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

La estructura lógica de repetición for permite que se repitan 10 veces las siguientes sentencias: 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].

// Creación del arreglo notas. notas = new double [numAlu] ;

// Proceso de ingreso de datos al arreglo notas. for ( int I = 0 ; i < numAlu ; i++) { System.out.print ( “ Ingrese nota : " ) ; notas[i] = Lectura.leerDouble( ) ; }

System.out.print ( “ Ingrese nota : " ) ; notas[i] = Lectura.leerDouble( ) ;


Pag. 421

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

notas 10 15 20 19 14 13 16 11 17 09

i =10 0 1 2 3 4 5 6 7 8 9


Pag. 422

Ahora, se modificará la solución anterior de tal forma que permita almacenar las notas finales de todos los alumnos de un determinado salón de clase.

Clase PrgAlumnos

package dominioDeLaAplicacion ; import biblioteca.* ; public class PrgAlumnos {


// Declaración de variables. int numAlu ; double sumaNotas = 0 ; // Determinación del tamaño del arreglo. System.out.print ( “ Ingrese el número de alumnos : ” ) ; numAlu = Lectura.leerInt( ) ; // Declaración y creación del arreglo notas. double notas[] = new double [numAlu] ; // Proceso de ingreso de datos al arreglo notas[ ]. for ( int i = 0 ; i < numAlu ; i++ ) {

System.out.print ( “ Ingrese la nota final del alumno [” + ( i + 1) + “]: ” ) ; notas[i] = Lectura.leerDouble( ) ;

} // Proceso de cálculo del promedio de notas finales. for ( int i = 0 ; i < numAlu ; i++ ) {

sumaNotas = sumaNotas + notas[i] ; } System.out.print ( “ El promedio es : ” + ( sumaNotas / numAlu ) ) ;

} }

En la solución anterior, se declara y crea el arreglo notas[ ] utilizando la siguiente sentencia: 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.

// Declaración y creación del arreglo notas. double notas[] = new double [numAlu] ;


Pag. 423

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

System.out.print ( “ Ingrese la nota final del alumno [” + ( i + 1) + “]: ” ) ;

// Proceso de ingreso de datos al arreglo notas[ ]. for ( int i = 0 ; i < numAlu ; i++ ) {

System.out.print ( “ Ingrese la nota final del alumno [” + ( i + 1) + “]: ” ) ; notas[i] = Lectura.leerDouble( ) ;

}

Ingrese la nota final del alumno [1]:

Ingrese la nota final del alumno [2]:


Pag. 424

Ahora, se modificará nuevamente la solución anterior, de tal forma que permita consistenciar la entrada de datos. Se consistenciará el ingreso del número total de alumnos y de la nota final de cada uno de ellos.

Clase PrgAlumnos package dominioDeLaAplicacion ; import biblioteca.* ; public class PrgAlumnos {

public static void main(String[] args) { // Declaración de variables. int numAlu ; double sumaNotas = 0 ; // Determinación del tamaño del arreglo con consistencia de datos. do {

System.out.print ( “ Ingrese el número de alumnos : ” ) ; numAlu = Lectura.leerInt( ) ; if ( numAlu <= 0 ) {

System.out.println ( “ El número de alumnos no es valido… Reintente! ” ) ; }

} while ( numAlu < 0 ) ; // Declaración y creación de arreglo. double notas[] = new double [numAlu] ; // Proceso de ingreso de datos al arreglo notas[ ] con consistencia de datos. for ( int i = 0 ; i < numAlu ; i++ ) {

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

System.out.println ( “ Nota ingresada no es valida… Reintente! ” ) ; }

} while ( notas[i] > 20 || notas[i] < 0 ) ; } // Proceso de cálculo del promedio de notas finales. for ( int I = 0 ; i < numAlu ; i++ ) {

sumaNotas = sumaNotas + notas[i] ; } System.out.print ( “ El promedio es : ” + ( sumaNotas / numAlu ) ) ;

} }

Observe el uso de la sentencia do dentro de la sentencia for. Uno de los principales usos de la sentencia do es la consistencia de datos. La consistencia de datos nos permite asegurarnos que el usuario ingrese solo datos válidos antes de que estos se almacenen en las variables o en los arreglos.


Pag. 425

FORMALIZACIÓN DE LA SOLUCIÓN UTILIZANDO EL MÉTODO DE LAS 6’D Problema 132

Etapa 01 - Descripción del problema. Desarrollar una solución que permita ingresar y almacenar las notas finales de todos los alumnos de un determinado salón de clase. Determinar y mostrar el promedio de las notas finales. Consistenciar el ingreso de datos. Etapa 02 - Definición de la solución.

Resultado deseado: Mostrar el promedio de las notas finales de

los alumnos de un determinado salón de clase.

Datos necesarios: El número de alumnos y las notas finales de

cada uno de ellos.

Procesamiento: El número de alumnos se ingresa a través del teclado y se almacena en una variable (numAlu). Con el número de alumnos ingresado se crea un arreglo (notas[ ]). Luego se procede a ingresar las notas finales de todos los alumnos y se almacenan en el arreglo creado. Después, se realiza la suma de todas las notas finales y el resultado se almacena en una variable acumulador (sumaNotas). Finalmente, se realiza el cálculo del promedio, se almacena el resultado en una variable (prom) y se muestra por pantalla.


Pag. 426


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




Clases biblioteca


Pag. 427


Algoritmo PrgAlumnos01 - método main ( ) ENTRADA: numAlu, notas[ ] SALIDA: prom INICIO

COMENTARIO “Declaración de variables” NUMERO i, numAlu, sumaNotas = 0, notas[ ], prom COMENTARIO “Determinación del tamaño del arreglo” HACER

LEER numAlu

SI (numAlu <= 0 ) ENTONCES

ESCRIBIR “Número de alumnos no válido... Reintente!” FINSI

MIENTRAS (numAlu <= 0 ) COMENTARIO “Creación del arreglo” CREAR notas [numAlu] COMENTARIO “Ingreso de datos al arreglo notas[ ].” DESDE i = 0 HASTA i = numAlu - 1 INCREMENTA 1

HACER

LEER notas[i] SI ( notas[i] > 20 || notas[i] < 0 ) ENTONCES

ESCRIBIR “Nota no válida... Reintente!” FINSI

MIENTRAS ( notas[i] > 20 || notas[i] < 0 )

FINDESDE COMENTARIO “Cálculo del promedio de notas finales” DESDE i = 0 HASTA i = numAlu - 1 INCREMENTA 1

sumaNotas = sumaNotas + notas[i] FINDESDE prom = sumaNotas / numAlu ESCRIBIR prom

FIN


Pag. 428


Clase PrgAlumnos01

package dominioDeLaAplicacion ; import biblioteca.* ; public class PrgAlumnos01 {

public static void main(String[] args) { // Declaración de variables. int i, numAlu ; double sumaNotas = 0, prom ; // Determinación del tamaño del arreglo con consistencia de datos. do {


System.out.println ( “ El número de alumnos no es válido… Reintente! ” ) ; }

} while ( numAlu <= 0 ) ; // Declaración y creación del arreglo. double notas[ ] = new double [numAlu] ; // Proceso de ingreso de datos al arreglo notas[ ] con consistencia de datos. for ( i = 0 ; i < numAlu ; i++ ) {

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

System.out.println ( “ Nota ingresada no es válida… Reintente! ” ) ; }

} while ( notas[i] > 20 || notas[i] < 0 ) ; } // Proceso de cálculo del promedio de notas finales. for ( i = 0 ; i < numAlu ; i++ ) {

sumaNotas = sumaNotas + notas[i] ; } prom = sumaNotas / numAlu ; System.out.println ( “ El promedio es : ” + prom ) ;

} }


Pag. 429

Problema 133

Etapa 01 - Descripción del problema. Desarrollar una solución que permita ingresar y almacenar las notas de todas las prácticas de un alumno. Determinar el promedio de las prácticas sabiendo que se elimina la práctica con la nota mas baja. Mostrar el promedio redondeado. Consistenciar el ingreso de datos. Etapa 02 - Definición de la solución.

Resultado deseado: Mostrar el promedio redondeado de las notas

de las prácticas de un alumno.

Datos necesarios: El número de prácticas y las notas de las prácticas del alumno.

Procesamiento: El número de prácticas se ingresa a través

del teclado y se almacena en una variable (numPra). Con el número de prácticas se crea un arreglo (notas[ ]). Luego se procede a ingresar las notas de las prácticas del alumno y se almacenan en el arreglo creado. Después, se realiza la suma de todas las notas de las prácticas y el resultado se almacena en una variable de tipo acumulador (sumaNotas). Luego, se determina la nota más baja del alumno y se almacena en una variable (notaMenor). Finalmente, se realiza el cálculo del promedio ((sumaNotas – notaMenor) / (numPra – 1)), se almacena el resultado en una variable (promAlu), se redondea y se muestra por pantalla.


Pag. 430






Clases biblioteca


Pag. 431


Algoritmo PrgAlumnos02 - método main ( ) ENTRADA: numPra, notas[ ] SALIDA: promAlu INICIO

COMENTARIO “Declaración de variables” NUMERO i, numPra, sumaNotas = 0, notaMenor = 20 NUMERO notas[ ], promAlu COMENTARIO “Determinación del tamaño del arreglo” HACER

LEER numPra SI (numPra <= 0 ) ENTONCES

ESCRIBIR “Número de prácticas no válido… Reintente!” FINSI

MIENTRAS (numPra <= 0 ) COMENTARIO “Creación del arreglo” CREAR notas [numPra] COMENTARIO “Ingreso de datos al arreglo notas[ ].” DESDE i = 0 HASTA i = numPra - 1 INCREMENTA 1

HACER LEER notas[i] SI ( notas[i] > 20 || notas[i] < 0 ) ENTONCES


MIENTRAS ( notas[i] > 20 || notas[i] < 0 ) FINDESDE COMENTARIO “Cálculo del promedio de notas de las prácticas” DESDE i = 0 HASTA i = numPra - 1 INCREMENTA 1

sumaNotas = sumaNotas + notas[i] FINDESDE DESDE i = 0 HASTA i = numPra - 1 INCREMENTA 1

SI ( notaMenor > notas[i] ) ENTONCES

notaMenor = notas[i] FINSI

FINDESDE promAlu = ( sumaNotas - notaMenor ) / ( numPra - 1 ) promAlu = promAlu REDONDEA 0 ESCRIBIR promAlu

FIN


Pag. 432


Clase PrgAlumnos02



// Declaración de variables. int i, numPra ; double sumaNotas = 0, notaMenor = 20, promAlu ; // Determinación del tamaño del arreglo con consistencia de datos. do {

System.out.print ( “ Ingrese el número de prácticas del alumno : ” ) ; numPra = Lectura.leerInt( ) ; if ( numPra <= 0 ) {

System.out.println ( “ El número de prácticas no es válido… Reintente! ” ) ; }

} while ( numPra <= 0 ) ; // Declaración y creación del arreglo. double notas[ ] = new double [numPra] ; // Ingreso de datos al arreglo notas[ ] con consistencia de datos. for ( i = 0 ; i < numPra ; i++ ) {

do { System.out.print ( “ Ingrese la nota de la práctica [ ” + ( i + 1) + “]: ” ) ; notas[i] = Lectura.leerDouble( ) ; if ( notas[i] > 20 || notas[i] < 0 ) {


} while ( notas[i] > 20 || notas[i] < 0 ) ; } // Proceso de cálculo del promedio de notas de las prácticas. for ( i = 0 ; i < numPra ; i++ ) {

sumaNotas = sumaNotas + notas[i] ; } for ( i = 0 ; i < numPra ; i++ ) {

if ( notaMenor > notas [i] ) notaMenor = notas[i] ;

} promAlu = sumaNotas / numAlu ; promAlu = Math.round (promAlu) ; System.out.println ( “ El promedio es : ” + promAlu ) ;

} }


Pag. 433

Problema 134

Etapa 01 - Descripción del problema. Desarrollar una solución que permita ingresar y almacenar las notas de las tres prácticas de todos los alumnos de un salón de clase. Determinar el promedio de cada alumno sabiendo que se duplica su nota más alta. Mostrar el promedio redondeado. Consistenciar el ingreso de datos. Etapa 02 - Definición de la solución.


de las tres prácticas de cada alumno.

Datos necesarios: El número de alumnos y las notas de las tres prácticas de cada alumno.

Procesamiento: El número de alumnos se ingresa a través del

teclado y se almacena en una variable (numAlu). Con el número de alumnos se crea un arreglo (notas[ ][ ]). Luego se procede a ingresar las notas de las tres prácticas de cada alumno y se almacenan en el arreglo creado.

Después, por cada alumno, se realiza la suma de las notas de sus tres prácticas y el resultado se almacena en una variable acumulador (sumaNotas). Luego, se determina su nota más alta y se almacena en una variable (notaMayor). Finalmente, se realiza el cálculo de su promedio ((sumaNotas + notaMayor) / 4), se almacena el resultado en una variable (promAlu), se redondea y se muestra por pantalla.


Pag. 434






Clases biblioteca


Pag. 435


Algoritmo PrgAlumnos03 - método main ( ) ENTRADA: numAlu, notas[ ][ ] SALIDA: promAlu INICIO

COMENTARIO “Declaración de variables” NUMERO i, j, numAlu, sumaNotas = 0, notaMayor = 0 NUMERO notas[ ][ ], promAlu COMENTARIO “Determinación del tamaño del arreglo” HACER

LEER numAlu SI (numAlu <= 0 ) ENTONCES

ESCRIBIR “Número de alumnos no válido… Reintente!” FINSI

MIENTRAS (numAlu <= 0 ) COMENTARIO “Creación del arreglo” CREAR notas [numAlu][3] COMENTARIO “Ingreso de datos al arreglo notas[ ][ ]” DESDE i = 0 HASTA i = numAlu - 1 INCREMENTA 1

DESDE j = 0 HASTA j = 2 INCREMENTA 1 HACER

LEER notas[i][j] SI ( notas[i][j] > 20 || notas[i][j] < 0 ) ENTONCES


MIENTRAS ( notas[i][j] > 20 || notas[i][j] < 0 ) FINDESDE

FINDESDE COMENTARIO “Cálculo del promedio de notas por alumno” DESDE i = 0 HASTA i = numAlu - 1 INCREMENTA 1

notaMayor = notas[i][0] MAXIMO notas[i][1] notaMayor = notas[i][2] MAXIMO notaMayor sumaNotas = notas[i][0] + notas[i][1] + notas[i][2] promAlu = ( sumaNotas + notaMayor ) / 4 promAlu = promAlu REDONDEA 0 ESCRIBIR promAlu

FINDESDE

FIN


Pag. 436


Clase PrgAlumnos03


public static void main(String[] args) { // Declaración de variables. int i, j, numAlu ; double sumaNotas = 0, notaMayor = 0, promAlu ; // Determinación del tamaño del arreglo con consistencia de datos. do {



} while ( numAlu <= 0 ) ; // Declaración y creación del arreglo. double notas[ ][ ] = new double [numAlu][3] ; // Ingreso de datos al arreglo notas[ ][ ] con consistencia de datos. for ( i = 0 ; i < numAlu ; i++ ) {

System.out.println ( “ Alumno [ ” + ( i + 1) + “ ]: ” ) ; for { i = 0 ; j < 3 ; j++ ) {

do { System.out.print ( “ Ingrese la nota de la práctica [ ” + ( j + 1) + “]: ” ) ; notas[i][j] = Lectura.leerDouble( ) ; if ( notas[i][j] > 20 || notas[i][j] < 0 ) {


} while ( notas[i][j] > 20 || notas[i][j] < 0 ) ; }

} // Cálculo del promedio de notas por alumno. for ( i = 0 ; i < numAlu ; i++ ) {

notaMayor = Math.max (notas[i][0], notas[i][1] ) ; notaMayor = Math.max (notas[i][2], notaMayor ) ; sumaNotas = notas[i][0] + notas[i][1] + notas[i][2] ; promAlu = ( sumaNotas + notaMayor ) / 4 ; promAlu = Math.round (promAlu) ; System.out.println ( “ El promedio del alumno [ ” + ( i + 1 ) + “ ] es: ” + promAlu ) ;

}

} }


Pag. 437

Problema 135

Etapa 01 - Descripción del problema. Desarrollar una solución que permita ingresar y almacenar las notas de las prácticas de todos los alumnos de un salón de clase. Determinar el promedio de cada alumno sabiendo que se duplica su nota más alta y se elimina su práctica con la nota mas baja. Mostrar el promedio redondeado a dos decimales. Consistenciar el ingreso de datos. Finalmente; determinar y mostrar el promedio simple de todas las notas de las prácticas de los alumnos del salón de clase. Etapa 02 - Definición de la solución.

Resultado deseado: Mostrar el promedio redondeado a dos

decimales de las notas de las prácticas de cada alumno y el promedio simple de todas las notas de las prácticas de los alumnos.

Datos necesarios: El número de alumnos, el número de

prácticas y las notas de las prácticas de cada alumno.

Procesamiento: El número de alumnos y el número de

prácticas se ingresa a través del teclado y se almacenan en variables (numAlu y numPra respectivamente). Con los datos ingresados se crea un arreglo (notas[ ][ ]). Luego se procede a ingresar las notas de las prácticas de cada alumno y se almacenan en el arreglo creado.

Después, por cada alumno, se realiza la suma de las notas de las prácticas y el resultado se almacenan en una variable de tipo acumulador (sumaNotas). Luego, se determina su nota más alta y se almacena en una variable (notaMayor). También se determina su nota mas baja y se almacena en una variable (notaMenor). Finalmente, se realiza el cálculo de su promedio ((sumaNotas + notaMayor - notaMenor) / numPra), se almacena el resultado en una variable (promAlu), se redondea y se muestra por pantalla.


Pag. 438

Adicionalmente, se realiza la suma de las notas de las prácticas de todos los alumnos del salón de clase y el resultado se almacena nuevamente en una variable de tipo acumulador (sumaNotas). Se determina el promedio simple, se almacena el resultado en una variable (prom) y se muestra por pantalla.






Clases biblioteca


Pag. 439


Algoritmo PrgAlumnos04 - método main ( ) ENTRADA: numAlu, numPra, notas[ ][ ] SALIDA: promAlu, prom INICIO

COMENTARIO “Declaración de variables” NUMERO i, j, numAlu, numPra, sumaNotas = 0, notaMayor = 0 NUMERO notaMenor = 20, notas[ ][ ], promAlu, prom COMENTARIO “Determinación del tamaño del arreglo” HACER


ESCRIBIR “Número de alumnos no válido.. Reintente!” FINSI

MIENTRAS (numAlu <= 0 ) HACER

LEER numPra SI (numPra <= 0 ) ENTONCES

ESCRIBIR “Número de prácticas no válido.. Reintente!” FINSI

MIENTRAS (numPra < 0 ) COMENTARIO “Creación del arreglo” CREAR notas [numAlu][numPra] COMENTARIO “Ingreso de datos al arreglo notas[ ][ ]” DESDE i = 0 HASTA i = numAlu - 1 INCREMENTA 1

DESDE j = 0 HASTA j = numPra - 1 INCREMENTA 1

HACER LEER notas[i][j] SI ( notas[i][j] > 20 || notas[i][j] < 0 ) ENTONCES


MIENTRAS ( notas[i][j] > 20 || notas[i][j] < 0 )

FINDESDE FINDESDE


Pag. 440


Algoritmo PrgAlumnos04 – método main ( )

COMENTARIO “Cálculo del promedio de notas por alumno” DESDE i = 0 HASTA i = numAlu - 1 INCREMENTA 1

notaMayor = 0 notaMenor = 20 sumaNotas = 0 DESDE j = 0 HASTA j = numPra - 1 INCREMENTA 1

notaMayor = notaMayor MAXIMO notas[i][j] notaMenor = notaMenor MAXIMO notas[i][j] sumaNotas = sumaNotas + notas[i][j]

FINDESDE promAlu = (sumaNotas+notaMayor-notaMenor) / numPra promAlu = promAlu REDONDEA 2 ESCRIBIR promAlu

FINDESDE COMENTARIO “Cálculo del promedio simple de todas las notas” sumaNotas = 0 DESDE i = 0 HASTA i = numAlu - 1 INCREMENTA 1

DESDE j = 0 HASTA j = numPra - 1 INCREMENTA 1 sumaNotas = sumaNotas + notas[i][j]

FINDESDE FINDESDE prom = sumaNotas / ( numAlu * numPra ) prom = prom REDONDEA 2 ESCRIBIR prom

FIN


Pag. 441


Clase PrgAlumnos04 package dominioDeLaAplicacion ; import biblioteca.* ; public class PrgAlumnos04 {


// Declaración de variables. int i, j, numAlu, numPra ; double sumaNotas = 0, notaMayor = 0, notaMenor = 20, promAlu, prom ; /// Determinación del tamaño del arreglo con consistencia de datos. do {



} while ( numAlu <= 0 ) ; do {

System.out.print ( “ Ingrese el número de prácticas : ” ) ; numPra = Lectura.leerInt( ) ; if ( numPra <= 0 ) {

System.out.println ( “ El número de prácticas no es válido… Reintente! ” ) ; }

} while ( numPra < 0 ) ; // Declaración y creación del arreglo. double notas[ ][ ] = new double [numAlu][numPra] ; // Ingreso de datos al arreglo notas[ ][ ] con consistencia de datos. for ( i = 0 ; i < numAlu ; i++ ) {

System.out.println ( “ Alumno [ ” + ( i + 1) + “ ]: ” ) ; for { i = 0 ; j < numPra ; j++ ) {

do { System.out.print ( “ Ingrese la nota de la práctica [ ” + ( j + 1) + “]: ” ) ; notas[i][j] = Lectura.leerDouble( ) ; if ( notas[i][j] > 20 || notas[i][j] < 0 ) {


} while ( notas[i][j] > 20 || notas[i][j] < 0 ) ; }

}


Pag. 442


Clase PrgAlumnos04

// Cálculo del promedio de notas por alumno. for ( i = 0 ; i < numAlu ; i++ ) {

notaMayor = 0 ; notaMenor = 20 ; sumaNotas = 0 ; for { i = 0 ; j < numPra ; j++ ) {

notaMayor = Math.max (notas[i][j], notaMayor) ; notaMenor = Math.max (notas[i][j], notaMenor ) ; sumaNotas = sumaNotas + notas[i][j] ;

} promAlu = ( sumaNotas + notaMayor - notaMenor) / numPra ; promAlu = ( Math.round (prom * 100) ) / 100.0 ; System.out.println ( “ El promedio del alumno [ ” + ( i + 1 ) + “ ] es: ” + promAlu ) ;

}

// Cálculo del promedio simple de todas las notas. sumaNotas = 0 ; for ( i = 0 ; i < numAlu ; i++ ) {

for { i = 0 ; j < numPra ; j++ ) { sumaNotas = sumaNotas + notas[i][j] ;

}

} prom = ( sumaNotas + notaMayor - notaMenor) / ( numAlu * numPra ) ; prom = ( Math.round (prom * 100) ) / 100.0 ; System.out.println ( “ El promedio simple de las notas es : ” + prom ) ;

} }


Pag. 443

Problema 136

Etapa 01 - Descripción del problema. Desarrollar una solución que permita ingresar y almacenar las notas del examen parcial, promedio de trabajos y examen final de todos los alumnos de un salón de clase. Consistenciar el ingreso de los datos. Determinar el promedio de cada alumno sabiendo que se duplica la nota del examen final. Mostrar el promedio redondeado. También, calcular y mostrar el promedio obtenido por los alumnos en el examen final. Finalmente; determinar y mostrar el porcentaje de alumnos aprobados y el porcentaje de alumnos desaprobados. Etapa 02 - Definición de la solución.


de cada alumno, el promedio obtenido por los alumnos en el examen final y el porcentaje de alumnos aprobados y desaprobados.

Datos necesarios: El número de alumnos y las notas del examen

parcial, promedio de trabajos y examen final de cada alumno.

Procesamiento: El número de alumnos se ingresa a través del

teclado y se almacena en una variable (numAlu). Con el número de alumnos se crea un arreglo (notas[ ][ ]). Luego se procede a ingresar las notas del examen parcial, promedio de trabajos y examen final de cada alumno y se almacenan en el arreglo creado.

Después, por cada alumno, se realiza la suma de la nota del examen parcial, promedio de trabajos y examen final (multiplicado por 2), y el resultado se almacena en una variable de tipo acumulador (sumaNotas). Luego, se determina su promedio ((sumaNotas notaMenor) / 4), se almacena el resultado en una variable (promAlu), se redondea y se muestra por pantalla. Adicionalmente, se realiza la suma de las notas del examen final de todos los alumnos del salón de clase y el resultado se almacena nuevamente en una variable acumulador (sumaEF). Se determina el promedio simple,


Pag. 444

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


biblioteca


Pag. 445


Algoritmo PrgAlumnos05- método main ( ) ENTRADA: numAlu, notas[ ][ ] SALIDA: promAlu, promEF, porceAprob, porceDesaprob INICIO

COMENTARIO “Declaración de variables” NUMERO i, numAlu, sumaNotas = 0, sumaEF = 0 NUMERO notas[ ][ ], promAlu, promEF, porceDesaprob NUMERO aprobados = 0, desaprobados = 0, porceAprob COMENTARIO “Determinación del tamaño del arreglo” HACER


ESCRIBIR “Número de alumnos no válido… Reintente!” FINSI

MIENTRAS (numAlu <= 0 ) COMENTARIO “Creación del arreglo” CREAR notas [3][numAlu] COMENTARIO “Ingreso de datos al arreglo notas[ ][ ]” DESDE i = 0 HASTA i = numAlu - 1 INCREMENTA 1

HACER COMENTARIO “Examen Parcial” LEER notas[0][i] SI ( notas[0][i] > 20 || notas[0][i] < 0 ) ENTONCES


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


MIENTRAS ( notas[1][i] > 20 || notas[1][i] < 0 )


Pag. 446


Algoritmo PrgAlumnos05- método main ( )

HACER

COMENTARIO “Examen Final” LEER notas[2][i] SI ( notas[2][i] > 20 || notas[2][i] < 0 ) ENTONCES


MIENTRAS ( notas[2][i] > 20 || notas[2][i] < 0 )

FINDESDE COMENTARIO “Cálculo del promedio de notas por alumno” DESDE i = 0 HASTA i = numAlu - 1 INCREMENTA 1

sumaNotas = notas[0][i] + notas[1][i] + notas[2][i] * 2 promAlu = sumaNotas / 4 promAlu = promAlu REDONDEA 0 ESCRIBIR promAlu

FINDESDE

COMENTARIO “Cálculo del promedio simple de examen final” DESDE i = 0 HASTA i = numAlu - 1 INCREMENTA 1

sumaEF = sumaEF + notas[2][i] FINDESDE promEF = sumaEF / numAlu promEF = promEF REDONDEA 2 ESCRIBIR promEF COMENTARIO “Cálculo de alumnos aprobados y desaprobados” DESDE i = 0 HASTA i = numAlu - 1 INCREMENTA 1

sumaNotas = notas[0][i] + notas[1][i] + notas[2][i] * 2 promAlu = sumaNotas / 4 promAlu = promAlu REDONDEA 0 SI ( promAlu < 11 ) ENTONCES

desaprobados = desaprobados + 1 SINO

Aprobados = aprobados + 1 FINSI

FINDESDE porceAprob = ( aprobados * 100 ) / numAlu porceAprob = porceAprob REDONDEA 2 porceDesaprob = 100 - porceAprob ESCRIBIR porceAprob + “ % ” ESCRIBIR porceDesaprob + “ % ”

FIN


Pag. 447




// Declaración de variables. int i, numAlu, aprobados = 0, desaprobados = 0 ; double sumaNotas = 0, sumaEF = 0, promAlu, promEF, porceAprob, porceDesaprob ; // Determinación del tamaño del arreglo con consistencia de datos. do {



} while ( numAlu <= 0 ) ; // Declaración y creación del arreglo. double notas[ ][ ] = new double [3][numAlu] ; // Ingreso de datos al arreglo notas[ ][ ] con consistencia de datos. for ( i = 0 ; i < numAlu ; i++ ) {

System.out.println ( “ Alumno [ ” + ( i + 1) + “ ]: ” ) ; do {

System.out.print ( “ Ingrese la nota del examen parcial : ” ) ; notas[0][i] = Lectura.leerDouble( ) ; if ( notas[0][i] > 20 || notas[0][i] < 0 ) {


} while ( notas[0][i] > 20 || notas[0][i] < 0 ) ; do {

System.out.print ( “ Ingrese la nota promedio de trabajos : ” ) ; notas[1][i] = Lectura.leerDouble( ) ; if ( notas[1][i] > 20 || notas[1][i] < 0 ) {


} while ( notas[1][i] > 20 || notas[1][i] < 0 ) ; do {

System.out.print ( “ Ingrese la nota del examen final : ” ) ; notas[2][i] = Lectura.leerDouble( ) ; if ( notas[2][i] > 20 || notas[2][i] < 0 ) {


} while ( notas[2][i] > 20 || notas[2][i] < 0 ) ; }


Pag. 448


Clase PrgAlumnos05

// Cálculo del promedio de notas por alumno. for ( i = 0 ; i < numAlu ; i++ ) {

sumaNotas = notas[0][i] + notas[1][i] + notas[2][i] * 2 ; promAlu = sumaNotas / 4 ; promAlu = Math.round (promAlu) ; System.out.println ( “ El promedio del alumno [ ” + ( i + 1 ) + “ ] es: ” + promAlu ) ;

}

// Cálculo del promedio simple del examen final. for ( i = 0 ; i < numAlu ; i++ ) {

sumaEF = sumaEF + notas[2][i] ; } promEF = sumaEF / numAlu ; promEF = ( Math.round (promEF * 100) ) / 100.0 ; System.out.println ( “ El promedio de las notas del examen final es : ” + promEF ) ;

// Cálculo de alumnos aprobados y desaprobados. for ( i = 0 ; i < numAlu ; i++ ) {

sumaNotas = notas[0][i] + notas[1][i] + notas[2][i] * 2 ; promAlu = sumaNotas / 4 ; promAlu = Math.round (promAlu) ; if ( promAlu < 11 ) {

desaprobados ++ ; } else {

aprobados ++ ; }

} porceAprob = ( aprobados * 100 ) / numAlu ; porceAprob = ( Math.round (porceAprob * 100) ) / 100.0 ; porceDesaprob = 100 – porceAprob ; System.out.println ( “ El porcentaje de alumnos aprobados es : ” + porceAprob + “ % ” ) ; System.out.print ( “ El porcentaje de alumnos desaprobados es : ” ) ; System.out.println ( porceDesaprob + “ % ” ) ;

} }


Pag. 449

Problema 137

Etapa 01 - Descripción del problema. Desarrollar una solución que permita ingresar y almacenar el sueldo de todos los trabajadores de una empresa. Calcular y mostrar el aumento de sueldo de cada uno de los trabajadores (redondeado a dos decimales), de acuerdo a la siguiente tabla. Consistenciar los datos ingresados.

Condición Aumento sueldo < 410 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

del teclado y se almacena en una variable (numTrab). Con el número de trabajadores se crea un arreglo (sueldos[ ]). Luego se procede a ingresar los sueldos de cada trabajador y se almacenan en el arreglo creado.

Después, por cada trabajador, en base a su sueldo se determina su aumento de sueldo. Si el trabajador tiene un sueldo menor a S/.410.00 nuevos soles se le aumenta el 20% de su sueldo. Si el trabajador tiene un sueldo mayor a S/.1,600.00 nuevos soles, se le aumenta el 5% de su sueldo y en otros casos el aumento es del 10% de su sueldo. El aumento se almacena en una variable (aumento), se redondea y se muestra por pantalla.


Pag. 450


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




Clases biblioteca


Pag. 451


Algoritmo PrgTrabajadores01 - método main ( ) ENTRADA: numTrab, sueldos[ ] SALIDA: aumento INICIO

COMENTARIO “Declaración de variables” NUMERO i, numTrab, sueldos[ ], aumento = 0 COMENTARIO “Determinación del tamaño del arreglo” HACER

LEER numTrab SI (numTrab <= 0 ) ENTONCES

ESCRIBIR “Número de trabajadores no válido… ” FINSI

MIENTRAS (numTrab <= 0 ) COMENTARIO “Creación del arreglo” CREAR sueldos [numTrab] COMENTARIO “Ingreso de datos al arreglo sueldos[ ]” DESDE i = 0 HASTA i = numTrab - 1 INCREMENTA 1

HACER LEER sueldos[i] SI ( sueldos[i] <= 0 ) ENTONCES

ESCRIBIR “Sueldo ingresado no es válido... ” FINSI

MIENTRAS ( sueldos[i] <= 0 ) FINDESDE COMENTARIO “Cálculo del aumento de sueldo por trabajador” DESDE i = 0 HASTA i = numTrab - 1 INCREMENTA 1

SI ( sueldos[i] < 410 ) ENTONCES

aumento = sueldos[i] * 0.2 SINO

SI ( sueldos[i] > 1600 ) aumento = sueldos[i] * 0.05

SINO aumento = sueldos[i] * 0.10

FINSI FINSI aumento = aumento REDONDEA 2 ESCRIBIR aumento

FINDESDE

FIN


Pag. 452


Clase PrgTrabajadores01 package dominioDeLaAplicacion ; import biblioteca.* ; public class PrgTrabajadores01 {


// Declaración de variables. int i, numTrab ; double aumento = 0 ; // Determinación del tamaño del arreglo con consistencia de datos. do {

System.out.print ( “ Ingrese el número de trabajadores de la empresa : ” ) ; numTrab = Lectura.leerInt( ) ; if ( numTrab <= 0 ) {

System.out.println ( “ El número de trabajadores no es válido… Reintente! ” ) ; }

} while ( numTrab <= 0 ) ; // Declaración y creación del arreglo. double sueldos[ ] = new double [numTrab] ; // Ingreso de datos al arreglo sueldos[ ] con consistencia de datos. for ( i = 0 ; i < numTrab ; i++ ) {

do { System.out.print ( “ Ingrese el sueldo del trabajador [ ” + ( i + 1) + “ ]: ” ) ; sueldos[i] = Lectura.leerDouble( ) ; if ( sueldos[i] <= 0 ) {

System.out.println ( “ Sueldo ingresado no es válido… Reintente! ” ) ; }

} while ( sueldos[i] <= 0 ) ; } // Cálculo del aumento de sueldo por trabajador. for ( i = 0 ; i < numTrab ; i++ ) {

if ( sueldos[i] < 410 ) { aumento = sueldos[i] * 0.2 ;

} else { if ( sueldos[i] > 1600 ) {

aumento = sueldos[i] * 0.05 ; } else {

aumento = sueldos[i] * 0.10 ; }

} aumento = ( Math.round (aumento * 100) ) / 100.0 ; System.out.println ( “ Aumento del trabajador [ ” + ( i + 1) + “ ] es : ” + aumento ) ;

} }

}


Pag. 453

Problema 138

Etapa 01 - Descripción del problema. Desarrollar una solución que permita ingresar y almacenar el sueldo de todos los trabajadores de una empresa. A todos los empleados cuyo sueldo sea mayor a S/.1600.00 nuevos soles se le deberá descontar 15% por impuestos y a todos los trabajadores cuyo sueldo sea menor a S/.1000.00 nuevos soles se le deberá aumentar el 10% por concepto de refrigerio y movilidad. Mostrar el sueldo neto a cobrar por cada trabajador redondeado a dos decimales. Consistenciar los datos ingresados. Etapa 02 - Definición de la solución.

Resultado deseado: Mostrar el sueldo neto a cobrar por cada

trabajador de la empresa.

Datos necesarios: El número de trabajadores de la empresa y el sueldo de cada uno de ellos.


del teclado y se almacena en una variable (numTrab). Con el número de trabajadores se crea un arreglo (sueldos[ ]). Luego se procede a ingresar los sueldos de cada trabajador y se almacenan en el arreglo creado.

Después, por cada trabajador, en base a su sueldo se determina su descuento o su aumento. Si el trabajador tiene un sueldo mayor a S/.1,600.00 nuevos soles se le descontará el 15% de su sueldo por impuestos y se almacena en una variable (descuento). Si el trabajador tiene un sueldo menor a S/.1000.00 nuevos soles, se le aumenta el 10% de su sueldo por concepto de refrigerio y movilidad, y se almacena en una variable (aumento). Luego, se determina el sueldo neto ((sueldo – descuento + aumento), se almacena el resultado en una variable (sueldoNeto), se redondea y se muestra por pantalla.


Pag. 454






Clases biblioteca


Pag. 455


Algoritmo PrgTrabajadores02 - método main ( ) ENTRADA: numTrab, sueldos[ ] SALIDA: sueldoNeto INICIO

COMENTARIO “Declaración de variables” NUMERO i, numTrab, sueldos[ ], descuento = 0, aumento = 0 NUMERO sueldoNeto COMENTARIO “Determinación del tamaño del arreglo” HACER



MIENTRAS (numTrab <= 0 ) COMENTARIO “Creación del arreglo” CREAR sueldos [numTrab] COMENTARIO “Ingreso de datos al arreglo sueldos[ ]” DESDE i = 0 HASTA i = numTrab - 1 INCREMENTA 1

HACER LEER sueldos[i] SI ( sueldos[i] <= 0 ) ENTONCES


MIENTRAS ( sueldos[i] <= 0 ) FINDESDE COMENTARIO “Cálculo del sueldo neto de cada trabajador” DESDE i = 0 HASTA i = numTrab - 1 INCREMENTA 1

descuento = 0 aumento = 0 SI ( sueldos[i] > 1600 ) ENTONCES

descuento = sueldos[i] * 0.15 FINSI SI ( sueldos[i] < 1000 )

aumento = sueldos[i] * 0.10 FINSI sueldoNeto = sueldos[i] – descuento + aumento sueldoNeto = sueldoNeto REDONDEA 2 ESCRIBIR sueldoNeto

FINDESDE

FIN


Pag. 456



public static void main(String[] args) { // Declaración de variables. int i, numTrab ; double aumento = 0, descuento = 0 ; // Determinación del tamaño del arreglo con consistencia de datos. do {




do { System.out.print ( “ Ingrese el sueldo del trabajador [ ” + ( i + 1) + “ ]: ” ) ; sueldos[i] = Lectura.leerDouble( ) ; if ( sueldos[i] <= 0 ) {


} while ( sueldos[i] <= 0 ) ; } // Cálculo del sueldo neto de cada trabjador. for ( i = 0 ; i < numTrab ; i++ ) {

descuento = 0 ; aumento = 0 ; if ( sueldos[i] > 1600 )

descuento = sueldos[i] * 0.15 ; if ( sueldos[i] < 1000 )

aumento = sueldos[i] * 0.10 ; sueldoNeto = sueldos[i] – descuento + aumento ; sueldoNeto = ( Math.round (sueldoNeto * 100) ) / 100.0 ; System.out.print ( “ El sueldo neto del trabajador [ ” + ( i + 1) + “ ] es : ” ) ; System.out.println ( sueldoNeto ) ;

} }

}


Pag. 457

Problema 139

Etapa 01 - Descripción del problema. Desarrollar una solución que permita ingresar y almacenar el sueldo de todos los trabajadores de una empresa. Calcular y mostrar el sueldo neto de cada trabajador, su aumento y su respectivo descuento en base a la tabla mostrada (redondear dichas cantidades a dos decimales). Adicionalmente, mostrar el monto total que paga la empresa por concepto de sueldos. Consistenciar los datos ingresados.

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.

Datos necesarios: El número de trabajadores de la empresa y el

sueldo de cada uno de ellos.

Procesamiento: El número de trabajadores se ingresa a través del teclado y se almacena en una variable (numTrab). Con el número de trabajadores se crea un arreglo (sueldos[ ]). Luego se procede a ingresar los sueldos de cada trabajador y se almacenan en el arreglo creado.

Después, por cada trabajador, en base a su sueldo se determina su 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. 458

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



Clases biblioteca


Algoritmo PrgTrabajadores03 - método main ( ) ENTRADA: numTrab, sueldos[ ] SALIDA: sueldoNeto, aumento, descuento, sueldoTotal INICIO

COMENTARIO “Declaración de variables” NUMERO i, numTrab, sueldos[ ], aumento = 0, descuento = 0 NUMERO sueldoNeto, sueldoTotal = 0 COMENTARIO “Determinación del tamaño del arreglo” HACER



MIENTRAS (numTrab <= 0 ) COMENTARIO “Creación del arreglo” CREAR sueldos [numTrab]


Pag. 460


Algoritmo PrgTrabajadores03 - método main ( ) COMENTARIO “Ingreso de datos al arreglo sueldos[ ]” DESDE i = 0 HASTA i = numTrab - 1 INCREMENTA 1

HACER

LEER sueldos[i] SI ( sueldos[i] <= 0 ) ENTONCES


MIENTRAS ( sueldos[i] <= 0 )

FINDESDE COMENTARIO “Cálculo del sueldo neto, aumento y descuento por

trabajador, y del total de sueldos ” DESDE i = 0 HASTA i = numTrab - 1 INCREMENTA 1

SI ( sueldos[i] < 410 ) ENTONCES

aumento = sueldos[i] * 0.2 descuento = 0

SINO SI ( sueldos[i] > 1600 )

aumento = sueldos[i] * 0.05 descuento = sueldos[i] * 0.15

SINO aumento = sueldos[i] * 0.10 descuento = sueldos[i] * 0.08

FINSI

FINSI sueldoNeto = sueldos[i] – descuento + aumento sueldoNeto = sueldoNeto REDONDEA 2 aumento = aumento REDONDEA 2 descuento = descuento REDONDEA 2 ESCRIBIR sueldoNeto, aumento, descuento sueldoTotal = sueldoTotal + sueldoNeto

FINDESDE ESCRIBIR sueldoTotal

FIN


Pag. 461



public static void main(String[] args) { // Declaración de variables. int i, numTrab ; double aumento = 0, descuento = 0, sueldoNeto, sueldoTotal = 0 ; // Determinación del tamaño del arreglo con consistencia de datos. do {




do {

System.out.print ( “ Ingrese el sueldo del trabajador [ ” + ( i + 1) + “ ]: ” ) ; sueldos[i] = Lectura.leerDouble( ) ; if ( sueldos[i] <= 0 ) {


} while ( sueldos[i] <= 0 ) ;

}


Pag. 462


Clase PrgTrabajadores03

// Cálculo del sueldo neto, aumento y descuento por trabajador, y del total de sueldos. for ( i = 0 ; i < numTrab ; i++ ) {

if ( sueldos[i] < 410 ) {

aumento = sueldos[i] * 0.2 ; descuento = 0 ;

} else { if ( sueldos[i] > 1600 ) {

aumento = sueldos[i] * 0.05 ; descuento = sueldos[i] * 0.15 ;

} else { aumento = sueldos[i] * 0.10 ; descuento = sueldos[i] * 0.08 ;

} } sueldoNeto = sueldos[i] + aumento – descuento ; sueldoNeto = ( Math.round (sueldoNeto * 100) ) / 100.0 ; aumento = ( Math.round (aumento * 100) ) / 100.0 ; descuento = ( Math.round (descuento * 100) ) / 100.0 ; System.out.print ( “ El sueldo neto del trabajador [ ” + ( i + 1) + “ ] es : ” ) ; System.out.println ( sueldoNeto ) ; System.out.println ( “ Su aumento es : ” + aumento ) ; System.out.println ( “ Su descuento es : ” + descuento ) ; sueldoTotal = sueldoTotal + sueldoNeto ;

}

System.out.println ( “ Monto total pagado por concepto de sueldos : ” + sueldoTotal ) ;

} }


Pag. 463

Problema 140

Etapa 01 - Descripción del problema. Desarrollar una solución que permita ingresar y almacenar las horas trabajadas y la tarifa horaria de todos los trabajadores de una empresa. Calcular y mostrar el sueldo neto de cada trabajador, sabiendo que se tiene que descontar el 10% por impuestos y el 5% por seguro. Etapa 02 - Definición de la solución.

Resultado deseado: Mostrar el sueldo de cada trabajador de la empresa.

Datos necesarios: El número de trabajadores de la empresa, y

las horas trabajadas y la tarifa horaria de cada uno de ellos.


del teclado y se almacena en una variable (numTrab). Con el número de trabajadores se crea un arreglo (sueldos[ ][ ]). Luego se procede a ingresar las horas trabajadas y la tarifa horaria de cada trabajador y se almacenan en el arreglo creado.

Después, por cada trabajador, se determina el sueldo neto ((horas trabajadas * tarifa horaria * 1.15), se almacena el resultado en una variable (sueldoNeto), se redondea y se muestra por pantalla.


1. Nombre del Proyecto: ProyTrabajadores.


Pag. 464

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




Clases biblioteca


Pag. 465


Algoritmo PrgTrabajadores04 - método main ( ) ENTRADA: numTrab, sueldos[ ][ ] SALIDA: sueldoNeto INICIO

COMENTARIO “Declaración de variables” NUMERO i, numTrab, sueldos[ ][ ], sueldoNeto COMENTARIO “Determinación del tamaño del arreglo” HACER



MIENTRAS (numTrab <= 0 ) COMENTARIO “Creación del arreglo” CREAR sueldos [numTrab][2] COMENTARIO “Ingreso de datos al arreglo sueldos[ ][ ]” DESDE i = 0 HASTA i = numTrab - 1 INCREMENTA 1

HACER COMENTARIO “Ingreso de las horas trabajadas” LEER sueldos[i][0] SI ( sueldos[i][0] <= 0 ) ENTONCES

ESCRIBIR “Número de horas no válida... ” FINSI

MIENTRAS ( sueldos[i][0] <= 0 ) HACER

COMENTARIO “Ingreso de la tarifa horaria” LEER sueldos[i][1] SI ( sueldos[i][1] <= 0 ) ENTONCES

ESCRIBIR “Tarifa horaria no válida... ” FINSI

MIENTRAS ( sueldos[i][1] <= 0 ) FINDESDE COMENTARIO “Cálculo del sueldo neto de cada trabajador” DESDE i = 0 HASTA i = numTrab - 1 INCREMENTA 1

sueldoNeto = sueldo[i][0] * sueldo[i][1] * 0.85 ESCRIBIR sueldoNeto

FINDESDE

FIN


Pag. 466




// Declaración de variables. int i, numTrab ; double sueldoNeto ; // Determinación del tamaño del arreglo con consistencia de datos. do {



} while ( numTrab <= 0 ) ; // Declaración y creación del arreglo. double sueldos[ ][ ] = new double [numTrab][2] ; // Ingreso de datos al arreglo sueldos[ ][ ] con consistencia de datos. for ( i = 0 ; i < numTrab ; i++ ) {

System.out.println ( “ Ingrese los datos del trabajador [ ” + ( i + 1) + “ ]: ” ) ; do {

System.out.print ( “ Número de horas trabajadas: ” ) ; sueldos[i][0] = Lectura.leerDouble( ) ; if ( sueldos[i][0] <= 0 ) {

System.out.println ( “Número de horas trabajadas no válida… ” ) ; }

} while ( sueldos[i][0] <= 0 ) ; do {

System.out.print ( “ Tarifa horaria: ” ) ; sueldos[i][1] = Lectura.leerDouble( ) ; if ( sueldos[i][1] <= 0 ) {

System.out.println ( “ Tarifa horaria no válida… ” ) ; }

} while ( sueldos[i][1] <= 0 ) ;

}


Pag. 467



// Cálculo del sueldo neto de cada trabajador. for ( i = 0 ; i < numTrab ; i++ ) {

sueldoNeto = sueldos[i][0] * sueldos[i][1] * 0.85 ; System.out.print ( “ El sueldo neto del trabajador [ ” + ( i + 1) + “ ] es : ” ) ; System.out.println ( sueldoNeto ) ;

}

} }


Pag. 468

Problema 141

Etapa 01 - Descripción del problema. Desarrollar una solución que permita ingresar y almacenar las horas trabajadas y la tarifa horaria de todos los trabajadores de una empresa. Calcular y mostrar el sueldo de cada trabajador, sabiendo que hasta 48 horas trabajadas se paga una tarifa normal y sobre las 48 horas, se paga la tarifa con un recargo del 25%. Por otro lado, si el sueldo es superior a S/.1,600.00 nuevos soles, al trabajador se le descuenta el 10% y si el sueldo es superior a S/.3,500.00 nuevos soles, al trabajador se le descuenta el 15%. Adicionalmente, se ha establecido un aumento a todos los trabajadores, equivalente al 15% del sueldo. Mostrar el sueldo total (sueldo bruto) y el sueldo a cobrar (sueldo neto) de cada trabajador redondeado a dos decimales. Etapa 02 - Definición de la solución.

Resultado deseado: Mostrar el sueldo de cada trabajador de la

empresa.

Datos necesarios: El número de trabajadores de la empresa, y las horas trabajadas y la tarifa horaria de cada uno de ellos.


del teclado y se almacena en una variable (numTrab). Con el número de trabajadores se crea un arreglo (sueldos[ ][ ]). Luego se procede a ingresar las horas trabajadas y la tarifa horaria de cada trabajador y se almacenan en el arreglo creado.

Después, por cada trabajador, se determina el sueldo bruto. Si el número de horas trabajadas es mayor a 48 horas, el sueldo bruto se determina de la siguiente forma: ( horas trabajadas – 48 ) * ( tarifa horaria * 1.25 ) + ( 48 * tarifa horaria) En caso contrario se determina de la siguiente forma: ( horas trabajadas * tarifa horaria ) El sueldo bruto se almacena en una variable (sueldoBruto).


Pag. 469

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



Clases biblioteca


Algoritmo PrgTrabajadores05 - método main ( ) ENTRADA: numTrab, sueldos[ ][ ] SALIDA: sueldoBruto, sueldoNeto INICIO

COMENTARIO “Declaración de variables” NUMERO i, numTrab, sueldos[ ][ ], descuento NUMERO sueldoNeto, sueldoBruto COMENTARIO “Determinación del tamaño del arreglo” HACER



MIENTRAS (numTrab <= 0 ) COMENTARIO “Creación del arreglo” CREAR sueldos [2][numTrab]


Pag. 471


Algoritmo PrgTrabajadores05 - método main ( )

COMENTARIO “Ingreso de datos al arreglo sueldos[ ][ ]” DESDE i = 0 HASTA i = numTrab - 1 INCREMENTA 1

HACER COMENTARIO “Ingreso de las horas trabajadas” LEER sueldos[0][i] SI ( sueldos[0][i] <= 0 ) ENTONCES

ESCRIBIR “Número de horas no válida... ” FINSI

MIENTRAS ( sueldos[0][i] <= 0 ) HACER

COMENTARIO “Ingreso de la tarifa horaria” LEER sueldos[1][i] SI ( sueldos[1][i] <= 0 ) ENTONCES

ESCRIBIR “Tarifa horaria no válida... ” FINSI

MIENTRAS ( sueldos[1][i] <= 0 ) FINDESDE COMENTARIO “Cálculo del sueldo bruto y neto por trabajador” DESDE i = 0 HASTA i = numTrab - 1 INCREMENTA 1

SI ( sueldos[0][i] > 48 ) ENTONCES

sueldoBruto = (sueldos[0][i] – 48) * (sueldos[1][i] * 1.25) + (48 * sueldos[1][i])

SINO sueldoBruto = sueldos[0][i] * sueldos[1][i]

FINSI SI ( sueldoBruto > 3500 ) ENTONCES

descuento = sueldoBruto * 0.15 SINO

SI (suesldoBruto > 1600 ) ENTONCES

descuento = sueldoBruto * 0.10 SINO

descuento = 0 FINSI

FINSI aumento = sueldoBruto * 0.15 sueldoNeto = sueldoBruto + aumento – descuento sueldoBruto = sueldoBruto REDONDEA 2 sueldoNeto = sueldoNeto REDONDEA 2 ESCRIBIR sueldoBruto, sueldoNeto

FINDESDE

FIN


Pag. 472



public static void main(String[] args) { // Declaración de variables. int i, numTrab ; double sueldoNeto ; // Determinación del tamaño del arreglo con consistencia de datos. do {



} while ( numTrab <= 0 ) ; // Declaración y creación del arreglo. double sueldos[ ][ ] = new double[2][numTrab] ; // Ingreso de datos al arreglo sueldos[ ][ ] con consistencia de datos. for ( i = 0 ; i < numTrab ; i++ ) {

System.out.println ( “ Ingrese los datos del trabajador [ ” + ( i + 1) + “ ]: ” ) ; do {

System.out.print ( “ Número de horas trabajadas: ” ) ; sueldos[0][i] = Lectura.leerDouble( ) ; if ( sueldos[0][i] <= 0 ) {

System.out.println ( “Número de horas trabajadas no válida… ” ) ; }

} while ( sueldos[0][i] <= 0 ) ; do {

System.out.print ( “ Tarifa horaria: ” ) ; sueldos[1][i] = Lectura.leerDouble( ) ; if ( sueldos[1][i] <= 0 ) {

System.out.println ( “ Tarifa horaria no válida… ” ) ; }

} while ( sueldos[1][i] <= 0 ) ;

}


Pag. 473


Clase PrgTrabajadores05 // Cálculo del sueldo bruto y neto por trabajador. for ( i = 0 ; i < numTrab ; i++ ) {

if ( sueldos[0][i] > 48 ) {

sueldoBruto = ( sueldos[0][i] – 48) * (sueldos[1][i] * 1.25) + (48 - sueldos[1][i] ) ; } else {

sueldoBruto = sueldos[0][i] * sueldos[1][i] ) ; } if ( sueldoBruto > 3500 ) {

descuento = sueldoBruto * 0.15 ; } else {

if ( sueldoBruto > 1600 ) { descuento = sueldoBruto * 0.10 ;

} else { descuento = 0 ;

} } aumento = sueldoBruto * 0.15 ; sueldoNeto = sueldoBruto + aumento – descuento ; sueldoBruto = ( Math.round (sueldoBruto * 100) ) / 100.0 ; sueldoNeto = ( Math.round (sueldoNeto * 100) ) / 100.0 ; System.out.println ( “ Trabajador [ ” + ( i + 1) + “ ] ” ) ; System.out.println ( “ Sueldo bruto : ” + sueldoBruto ) ; System.out.println ( “ Sueldo neto : ” + sueldoNeto ) ; System.out.println ( ) ;

} }

}


Pag. 474

Problema 142

Etapa 01 - Descripción del problema. Desarrollar una solución que permita ingresar y almacenar el nombre de todos los artículos de una bodega. Consistenciar la entrada de datos. Mostrar cada uno de los nombre con su respectiva longitud. Etapa 02 - Definición de la solución.

Resultado deseado: Mostrar el nombre y la longitud del nombre de

todos los artículos de una bodega.

Datos necesarios: El número de artículos y el nombre de cada uno de los artículos.

Procesamiento: El número de artículos se ingresa a través del

teclado y se almacena en una variable (numArt). Con el número de artículos se crea un arreglo (articulos[ ]). Luego se procede a ingresar el nombre de los artículos de la bodega, se almacenan temporalmente en una variable (sueldo), luego se eliminan los espacios del inicio y final del nombre, y se almacenan en el arreglo creado. Después, para cada uno de los nombres, se determina su longitud, se almacena en una variable (tamaño) y se muestra por pantalla.


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



Pag. 475



Clases biblioteca


Algoritmo PrgArticulos01 - método main ( ) ENTRADA: numArt, nombres SALIDA: tamaño INICIO

COMENTARIO “Declaración de variables” NUMERO i, numArt, tamaño TEXTO articulos[ ], nombre COMENTARIO “Determinación del tamaño del arreglo” HACER

LEER numArt SI (numArt <= 0 ) ENTONCES

ESCRIBIR “Número de artículos no válido… ” FINSI

MIENTRAS (numArt <= 0 ) COMENTARIO “Creación del arreglo” CREAR articulos [numArt]


Pag. 476


Algoritmo PrgArticulos01 - método main ( ) COMENTARIO “Ingreso de datos al arreglo articulos [ ]” DESDE i = 0 HASTA i = numArt - 1 INCREMENTA 1

HACER LEER nombre articulos[i] = nombre ELIMINAESPACIO INICIO, FIN SI ( LONGITUD articulos[i] < 3 ) ENTONCES

ESCRIBIR “Nombre de artículo no válido...” FINSI

MIENTRAS (LONGITUD articulos[i] < 3 ) FINDESDE COMENTARIO “Cálculo de la longitud de los nombres” DESDE i = 0 HASTA i = numArt - 1 INCREMENTA 1

tamaño = LONGITUD articulos[i] ESCRIBIR articulos[i], tamaño

FINDESDE

FIN


Clase PrgArticulos01 package dominioDeLaAplicacion ; import biblioteca.* ; public class PrgArticulos01 {

public static void main(String[] args) { // Declaración de variables. int i, numArt, tamaño ; String nombre ; // Determinación del tamaño del arreglo con consistencia de datos. do {

System.out.print ( “ Ingrese el número de artículos : ” ) ; numArt = Lectura.leerInt( ) ; if ( numArt <= 0 ) {

System.out.println ( “ El número de artículos no es válido… Reintente! ” ) ; }

} while ( numArt <= 0 ) ;


Pag. 477


Clase PrgArticulos01

// Declaración y creación del arreglo. String articulos[ ] = new String [numArt] ; // Ingreso de datos al arreglo artículos[ ] con consistencia de datos. for ( i = 0 ; i < numArt ; i++ ) {

do {

System.out.print ( “ Ingrese el nombre del artículo [ ” + ( i + 1) + “]: ” ) ; nombre = Lectura.leerString( ) ; articulos[i] = nombre.trim( ) ; if ( articulos[i].length( ) < 3 ) {

System.out.println ( “ El nombre ingresado no es válido… Reintente! ” ) ; }

} while ( articulos[i].length( ) < 3 ) ; } // Cálculo de la longitud de los nombres. for ( i = 0 ; i < numArt ; i++ ) {

tamaño = articulos[i].length( ) ; System.out.println ( “ Artículo ” + articulos[i] + “ tiene una longitud de ” + tamaño ) ;

} }

}


Pag. 478

Problema 143

Etapa 01 - Descripción del problema. Desarrollar una solución que permita ingresar y almacenar el nombre de todos los artículos de una bodega. Consistenciar la entrada de datos. Mostrar la primera letra de cada nombre en mayúscula y el resto en minúscula. Adicionalmente, mostrar la longitud de cada uno de los nombres. Etapa 02 - Definición de la solución.

Resultado deseado: Mostrar la primera letra de todos los nombres

en letra mayúscula y el resto en letra minúscula. Adicionalmente mostrar la longitud de cada uno de los nombres de los artículos.

Datos necesarios: El número de artículos y el nombre de cada

uno de los artículos.

Procesamiento: El número de artículos se ingresa a través del teclado y se almacena en una variable (numArt). Con el número de artículos se crea un arreglo (articulos[ ]). Luego se procede a ingresar el nombre de los artículos de la bodega, se 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. 479






Clases biblioteca


Pag. 480


Algoritmo PrgArticulos02 - método main ( ) ENTRADA: numArt, articulos[ ] SALIDA: letra, resto, tamaño INICIO

COMENTARIO “Declaración de variables” NUMERO i, numArt, tamaño TEXTO articulos[ ], letra, resto COMENTARIO “Determinación del tamaño del arreglo” HACER



MIENTRAS (numArt <= 0 ) COMENTARIO “Creación del arreglo” CREAR articulos [numArt] COMENTARIO “Ingreso de datos al arreglo articulos [ ]” DESDE i = 0 HASTA i = numArt - 1 INCREMENTA 1

HACER LEER articulos[i] articulos[i] = articulos[i] ELIMINAESPACIO INICIO, FIN SI ( LONGITUD articulos[i] < 3 ) ENTONCES


MIENTRAS (LONGITUD articulos[i] < 3 ) FINDESDE COMENTARIO “ Manipulación del nombre de los artículos ” DESDE i = 0 HASTA i = numArt - 1 INCREMENTA 1

letra = articulos[i] SUBCADENA 0,1 letra = MAYUSCULA letra resto = articulos[i] SUBCADENA 1 resto = MINUSCULA resto tamaño = LONGITUD articulos[i] ESCRIBIR letra, resto, tamaño

FINDESDE

FIN


Pag. 481



public static void main(String[] args) { // Declaración de variables. int i, numArt, tamaño ; String letra, resto ; // Determinación del tamaño del arreglo con consistencia de datos. do {



} while ( numArt <= 0 ) ; // Declaración y creación del arreglo. String articulos[ ] = new String [numArt] ; // Ingreso de datos al arreglo articulos[ ] con consistencia de datos. for ( i = 0 ; i < numArt ; i++ ) {

do { System.out.print ( “ Ingrese el nombre del artículo [ ” + ( i + 1) + “]: ” ) ; articulos[i] = Lectura.leerString( ) ; articulos[i] = articulos[i].trim( ) ; if ( articulos[i].length( ) < 3 ) {


} while ( articulos[i].length( ) < 3 ) ; } // Manipulación del nombre de los artículos. for ( i = 0 ; i < numArt ; i++ ) {

letra = articulos[i].substring(0,1) ; letra = letra.toUpperCase( ); resto = articulos[i].substring(1) ; resto = resto].toLowerCase( ) ; tamaño = articulos[i].length( ) ; System.out.println ( “ Artículo ” + letra + resto + “ tiene una longitud de ” + tamaño ) ;

} }

}


Pag. 482

Problema 144

Etapa 01 - Descripción del problema. Desarrollar una solución que permita ingresar y almacenar el nombre de todos los artículos de una bodega. Consistenciar la entrada de datos. Mostrar la primera letra y la última letra de cada uno de los nombres en letra mayúscula y minúscula respectivamente. Etapa 02 - Definición de la solución.


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.




Después, para cada uno de los nombres, se obtiene la primera letra, se almacena en una variable (letraIni) y se convierte en mayúscula. Luego, se obtiene la última letra, se almacenan en una variable (letraFin) y se convierten en minúscula. Finalmente, se muestra por pantalla, la primera letra del nombre en mayúscula y la última letra del nombre en minúscula.


Pag. 483






Clases biblioteca


Pag. 484


Algoritmo PrgArticulos03 - método main ( ) ENTRADA: numArt, articulos[ ] SALIDA: letraIni, letraFin INICIO

COMENTARIO “Declaración de variables” NUMERO i, numArt TEXTO articulos[ ], letraIni, letraFin COMENTARIO “Determinación del tamaño del arreglo” HACER






MIENTRAS (LONGITUD articulos[i] < 3 ) FINDESDE COMENTARIO “ Manipulación del nombre de los artículos ” DESDE i = 0 HASTA i = numArt - 1 INCREMENTA 1

letraIni = articulos[i] CARACTER INICIO letraIni = MAYUSCULA letraIni letraFin = articulos[i] CARACTER FIN letraFin = MINUSCULA letraFin ESCRIBIR letraIni, letraFin

FINDESDE

FIN


Pag. 485



public static void main(String[] args) { // Declaración de variables. int i, numArt ; char letraIni, letraFin ; // Determinación del tamaño del arreglo con consistencia de datos. do {



} while ( numArt <= 0 ) ; // Declaración y creación del arreglo. String articulos[ ] = new String [numArt] ; // Ingreso de datos al arreglo artículos[ ] con consistencia de datos. for ( i = 0 ; i < numArt ; i++ ) {



} while ( articulos[i].length( ) < 3 ) ; } // Manipulación del nombre de los artículos. for ( i = 0 ; i < numArt ; i++ ) {

letraIni = articulos[i].charAt(0) ; letraIni = Character.toUpperCase(letraIni) ; letraFin = articulos[i].charAt (articulos[i].length( ) -1) ; LetraFin = Character.toLowerCase(letraFin) ; System.out.println ( “ Artículo ” + articulos[i] ) ; System.out.println ( “ Letra inicial : ” + letraIni + “. Letra final : ” + letraFin + “.” ) ; System.out.println ( ) ;

} }

}


Pag. 486

Problema 145

Etapa 01 - Descripción del problema. Desarrollar una solución que permita ingresar y almacenar el nombre, la sigla y la descripción de todos los artículos de una bodega. Consistenciar la entrada de datos. Mostrar la primera letra del nombre y la descripción en mayúscula y el resto en minúscula. . También, mostrar las siglas del artículo en mayúscula. Etapa 02 - Definición de la solución.


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.


teclado y se almacena en una variable (numArt). Con el número de artículos se crea un arreglo (articulos[ ]). Luego se procede a ingresar el nombre, la descripción y las siglas de los artículos de la bodega, se eliminan los espacios del inicio y final de los mismos, y se almacenan en el arreglo creado.

Después, para cada uno de los nombres, se obtiene la primera letra, se almacena en una variable (letra), se obtiene las demás letras y se almacenan en una variable (resto). Luego se convierte a mayúscula la variable letra y a minúscula la variable resto y se almacenan en una variable (nombre). Luego, para cada una de las descripciones se realiza lo mismo y el resultado se almacenan en una variable (descrip). También, se convierte a mayúscula las siglas de cada artículo y se almacena en una variable (siglas). Finalmente, los resultados se muestran por pantalla.


Pag. 487






Clases biblioteca


Pag. 488


Algoritmo PrgArticulos04 - método main ( ) ENTRADA: numArt, articulos[ ][ ] SALIDA: nombre, descrip, siglas INICIO

COMENTARIO “Declaración de variables” NUMERO i, numArt TEXTO articulos[ ][ ], nombre, descrip, siglas COMENTARIO “Determinación del tamaño del arreglo” HACER



MIENTRAS (numArt <= 0 ) COMENTARIO “Creación del arreglo” CREAR articulos [numArt][3] COMENTARIO “Ingreso de datos al arreglo articulos [ ]” DESDE i = 0 HASTA i = numArt - 1 INCREMENTA 1

HACER

COMENTARIO “ Ingreso del nombre de los artículos ” LEER articulos[i][0] articulos[i][0] = articulos[i][0] ELIMINAESPACIO INICIO articulos[i][0] = articulos[i][0] ELIMINAESPACIO FIN SI ( LONGITUD articulos[i][0] < 3 ) ENTONCES


MIENTRAS (LONGITUD articulos[i][0] < 3 ) HACER

COMENTARIO “ Ingreso descripción de los artículos ” LEER articulos[i][1] articulos[i][1] = articulos[i][1] ELIMINAESPACIO INICIO articulos[i][1] = articulos[i][1] ELIMINAESPACIO FIN SI ( LONGITUD articulos[i][1] < 3 ) ENTONCES

ESCRIBIR “Descripción de artículo no válida...” FINSI

MIENTRAS (LONGITUD articulos[i][1] < 3 )


Pag. 489


Algoritmo PrgArticulos04 - método main ( )

HACER

COMENTARIO “ Ingreso siglas de los artículos ” LEER articulos[i][2] articulos[i][2] = articulos[i][2] ELIMINAESPACIO INICIO articulos[i][2] = articulos[i][2] ELIMINAESPACIO FIN SI ( LONGITUD articulos[i][2] < 3 ) ENTONCES

ESCRIBIR “Sigla de artículo no válida...” FINSI

MIENTRAS (LONGITUD articulos[i][2] < 3 )

FINDESDE COMENTARIO “Manipulación del nombre de los artículos” DESDE i = 0 HASTA i = numArt - 1 INCREMENTA 1

letra = articulos[i][0] SUBCADENA 0,1 resto = articulos[i][0] SUBCADENA 1 nombre = MAYUSCULA letra + MINUSCULA resto letra = articulos[i][1] SUBCADENA 0,1 resto = articulos[i][1] SUBCADENA 1 descrip = MAYUSCULA letra + MINUSCULA resto siglas = MAYUSCULA articulos[i][2] ESCRIBIR nombre, descrip, siglas

FINDESDE

FIN


Pag. 490



public static void main(String[] args) { // Declaración de variables. int i, numArt ; String letra, resto, nombre, descrip, siglas ; // Determinación del tamaño del arreglo con consistencia de datos. do {



} while ( numArt <= 0 ) ; // Declaración y creación del arreglo. String articulos[ ][ ] = new String [numArt][3] ; // Ingreso de datos al arreglo artículos[ ][ ] con consistencia de datos. for ( i = 0 ; i < numArt ; i++ ) {

do { System.out.print ( “ Ingrese el nombre del artículo [ ” + ( i + 1) + “ ]: ” ) ; articulos[i][0] = Lectura.leerString( ) ; articulos[i][0] = articulos[i][0].trim( ) ; if (articulos[i][0].length( ) < 3 ) {

System.out.println ( “ El nombre ingresado no es válido… ” ) ; }

} while (articulos[i][0].length( ) < 3 ) ; do {

System.out.print ( “ Ingrese la descripción del artículo [ ” + ( i + 1) + “ ]: ” ) ; articulos[i][1] = Lectura.leerString( ) ; articulos[i][1] = articulos[i][1].trim( ) ; if (articulos[i][1].length( ) < 3 ) {

System.out.println ( “ La descripción ingresada no es válida… ” ) ; }

} while (articulos[i][1].length( ) < 3 ) ;


Pag. 491


Clase PrgArticulos04

do {

System.out.print ( “ Ingrese la sigla del artículo [ ” + ( i + 1) + “ ]: ” ) ; articulos[i][2] = Lectura.leerString( ) ; articulos[i][2] = articulos[i][2].trim( ) ; if (articulos[i][2].length( ) < 3 ) {

System.out.println ( “ La sigla ingresada no es válida… ” ) ; }

} while (articulos[i][2].length( ) < 3 ) ; } // Manipulación del nombres, descripción y sigla de los artículos for ( i = 0 ; i < numArt ; i++ ) {

letra = articulos[i][0].substring(0,1) ; resto = articulos[i][0].substring(1) ; nombre = letra.toUpperCase( ) + resto.toLowerCase( ) ; letra = articulos[i][1].substring(0,1) ; resto = articulos[i][1].substring(1) ; descrip = letra.toUpperCase( ) + resto.toLowerCase( ) ; siglas = articulos[i][2].toUpperCase( ) ; System.out.println ( “ Artículo ” + ( i+1 ) ) ; System.out.println ( “ ---------------------- ” ) ; System.out.println ( “ Nombre: ” + nombre + “.” ) ; System.out.println ( “ Descripción: ” + descrip + “.” ) ; System.out.println ( “ Siglas: ” + siglas + “.” ) ; System.out.println ( ) ;

}

} }


Pag. 492


Pag. 493

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

0 0 1 1 2 2 : : : : : : : :

numTrab - 1 : numTrab - 1 : nombre de los

trabajadores sueldo de los

trabajadores Si en nombres[0] se almacena el nombre “Danae”, resulta lógico y necesario que en sueldos[0] almacenemos su respectivo sueldo. La pregunta lógica que se pueden formular sería la siguiente: ¿por qué en vez de crear dos vectores en paralelo no creamos una matriz con dos columnas?, y la respuesta sería que en una matriz solo se pueden almacenar datos del mismo tipo, mientras que usando dos vectores en paralelo se pueden almacenar datos de diferente tipo. En el planteamiento de la

Datos del mismo trabajador.


Pag. 494

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

cada socios sexo de

cada socio sueldo de

cada socio En la solución del problema 148 se utilizan algunas variables, un vector y una matriz con dos columnas en forma simultanea (en paralelo). A continuación se muestra el planteamiento de la solución.

nombres precios 0 1

0 0 1 1 2 2 : : : : : : : : : :

numArt - 1 : numArt - 1 : : nombre de

cada artículos precio de compra

de cada artículos precio de venta

de cada artículos


Pag. 495

Problema 146

Etapa 01 - Descripción del problema. Desarrollar una solución que permita ingresar y almacenar el nombre y el sueldo de todos los trabajadores de una empresa. Mostrar el nombre del trabajador que tiene el sueldo más alto y el promedio del sueldo de todos los trabajadores redondeado a dos decimales. Etapa 02 - Definición de la solución.

Resultado deseado: Mostrar el nombre del trabajador que tiene el

sueldo más alto y el promedio del sueldo de todos los trabajadores.

Datos necesarios: El número de trabajadores y, el nombre y el

sueldo de cada trabajador.

Procesamiento: El número de trabajadores se ingresa a través del teclado y se almacena en una variable (numTrab). Con el número de trabajadores se crean dos arreglos (nombres[] y sueldos[]). Luego se procede a ingresar el nombre de los trabajadores, se eliminan los espacios del inicio y final de los mismos, y se almacenan en uno de los arreglos creados (nombres[ ]). También, se procede a ingresar el sueldo de los trabajadores y se almacenan en el otro arreglo creado (sueldos[ ]).

Después, se determina el sueldo mas alto entre todos los trabajadores comparando el sueldo de cada trabajador con el contenido de una variable (sueldoMayor), inicializada con cero. Si el contenido de la variable sueldoMayor resulta menor que el sueldo de un trabajador, el sueldo de dicho trabajador pasa a ser el sueldo mayor y se almacena en la variable sueldoMayor. Una vez determinado el sueldo mayor se muestra el nombre de todos los trabajadores cuyo sueldo es igual al sueldoMayor. Luego, se determina el promedio del sueldo de todos los trabajadores sumando el sueldo de cada trabajador a una variable acumulador


Pag. 496

(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 biblioteca


Pag. 497


Algoritmo PrgTrabajadores06 - método main ( ) ENTRADA: numTrab, nombres[ ], sueldos[ ] SALIDA: nombres[ ], sueldoPromedio INICIO

COMENTARIO “Declaración de variables” NUMERO i, numTrab, sueldos[ ] NUMERO sueldoMayor = 0, sumaSueldos = 0, sueldoPromedio TEXTO nombres[ ] COMENTARIO “Determinación del tamaño del arreglo” HACER



MIENTRAS (numTrab <= 0 ) COMENTARIO “Creación de los arreglos” CREAR nombres [numTrab] CREAR sueldos [numTrab] COMENTARIO “Ingreso de nombres y sueldos de trabajadores” DESDE i = 0 HASTA i = numTrab - 1 INCREMENTA 1

HACER COMENTARIO “ Ingreso de nombre de trabajadores ” LEER nombres[i] nombres[i] = nombres[i] ELIMINAESPACIO INICIO,FIN SI ( LONGITUD nombres[i] < 3 ) ENTONCES

ESCRIBIR “Nombre del trabajador no válido...” FINSI

MIENTRAS ( LONGITUD nombres[i] < 3 ) HACER

COMENTARIO “ Ingreso de sueldo de trabajadores ” LEER sueldos[i] SI ( sueldos[i] <= 0 ) ENTONCES

ESCRIBIR “Sueldo de trabajador no válido...” FINSI

MIENTRAS ( sueldos[i] <= 0 ) FINDESDE


Pag. 498


Algoritmo PrgTrabajadores06 - método main ( ) COMENTARIO “Determinando el nombre de los trabajador con el

sueldo mas alto” DESDE i = 0 HASTA i = numArt - 1 INCREMENTA 1

SI ( i = 0 ) ENTONCES

sueldoMayor = sueldos[i] SINO

SI ( sueldoMayor < sueldo[i] ) ENTONCES

sueldoMayor = sueldo[i] FINSI

FINSI FINDESDE DESDE i = 0 HASTA i = numArt - 1 INCREMENTA 1

SI (sueldoMayor = sueldo[i] ) ENTONCES

ESCRIBIR nombres[i] SINO

FINDESDE COMENTARIO “Determinando el promedio del sueldo de todos los

trabajadores” DESDE i = 0 HASTA i = numArt - 1 INCREMENTA 1

sumaSueldos = sumaSueldos + sueldos[i] FINDESDE sueldoPromedio = sumaSueldos / numTrab sueldoPromedio = sueldoPromedio REDONDEA 2 ESCRIBIR sueldoPromedio

FIN


Pag. 499



public static void main(String[] args) { // Declaración de variables. int i, numTrab ; double sueldoMayor = 0, sumaSueldos = 0, sueldoPromedio ; // Determinación del tamaño de los arreglos con consistencia de datos. do {

System.out.print ( “ Ingrese el número de trabajadores : ” ) ; numTrab = Lectura.leerInt( ) ; if ( numTrab <= 0 ) {


} while ( numTrab <= 0 ) ; // Declaración y creación del arreglo. String nombres[ ] = new String [numTrab] ; double sueldos[ ] = new double [numTrab] ; // Ingreso de nombres y sueldos de trabajadores con consistencia de datos. for ( i = 0 ; i < numTrab ; i++ ) {

do { System.out.print ( “ Ingrese el nombre del trabajador [ ” + ( i + 1) + “ ]: ” ) ; nombres[i] = Lectura.leerString( ) ; nombres[i] = nombres[i].trim( ) ; if ( nombres[i].length( ) < 3 ) {

System.out.println ( “ El nombre del trabajador no es válido… ” ) ; }

} while ( nombres[i].length( ) < 3 ) ; do {

System.out.print ( “ Ingrese el sueldo del trabajador [ ” + ( i + 1) + “ ]: ” ) ; sueldos[i] = Lectura.leerString( ) ; if ( sueldos[i] <= 0 ) {

System.out.println ( “ El sueldo del trabajador no es válido… ” ) ; }

} while (sueldos[i] <= 0 ) ; }


Pag. 500



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

Problema 147

Etapa 01 - Descripción del problema. Desarrollar una solución que permita ingresar y almacenar el nombre, el sexo y la edad de todos los socios de un club. Indicar el número de socios mayores de edad que son hombres y el número de socios cuyo nombre comienza con la letra “D”. Etapa 02 - Definición de la solución.

Resultado deseado: Mostrar el número de socios hombres

mayores de edad y el número de socios cuyo nombre comienza con la letra “D”.

Datos necesarios: El número de socios y, el nombre, sexo y

edad de cada socio.

Procesamiento: El número de socios se ingresa a través del teclado y se almacena en una variable (numSoc). Con el número de socios se crean tres arreglos (nombres[],sexos[] y edades[]). Luego se procede a ingresar el nombre de los socios, se eliminan los espacios del inicio y final de los mismos, y se almacenan en uno de los arreglos creados (nombres[]). Luego, se procede a ingresar el sexo de los socios (M = Masculino y F = Femenino), se convierte a mayúscula y se almacenan en otro de los arreglos creado (sexos[]). Por último, se ingresan las edades de los socios y se almacenan en el tercer arreglo (edades[]). Después, se determina el número de socios hombres, mayores de edad. Para esto se evalúan los datos de cada uno de los socios y si resulta que es hombre (sexo = ‘M’) y es mayor de edad (edad >= 18), entonces se aumenta 1 a una variable de tipo contador (totalMayoresHombres). Finalizada la evaluación de los datos de todos los socios se muestra el contenido de la variable totalMayoresHombres. Luego, se determina el número de socios cuyo nombre comienza con la letra ‘D’. Para esto se obtiene la primera letra del nombre de


Pag. 502

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. 2. Definición de Paquetes y desarrollo del Diagrama de Paquetes.




Clases biblioteca


Pag. 503


Algoritmo PrgSocios01 - método main ( ) ENTRADA: numSoc, nombres[ ], sexos[ ], edades[ ] SALIDA: totalMayoresHombres, totalNombresD INICIO

COMENTARIO “Declaración de variables” NUMERO i, numSoc, edades[ ] NUMERO totalMayoresHombres = 0, totalNombresD = 0 TEXTO nombres[ ], sexos[ ], letra COMENTARIO “Determinación del tamaño del arreglo” HACER

LEER numSoc SI (numSoc <= 0 ) ENTONCES

ESCRIBIR “Número de socios no válido… ” FINSI

MIENTRAS (numSoc <= 0 ) COMENTARIO “Creación de los arreglos” CREAR nombres [numSoc] CREAR sexos [numSoc] CREAR edades [numSoc] COMENTARIO “Ingreso de nombres, sexo y edad de los socios ” DESDE i = 0 HASTA i = numSoc - 1 INCREMENTA 1

HACER COMENTARIO “ Ingreso de nombre de socios ” LEER nombres[i] nombres[i] = nombres[i] ELIMINAESPACIO INICIO, FIN SI ( LONGITUD nombres[i] < 3 ) ENTONCES

ESCRIBIR “Nombre del socio no válido...” FINSI

MIENTRAS ( LONGITUD nombres[i] < 3 ) HACER

COMENTARIO “ Ingreso de sexo de socios ” LEER sexos[i] sexos[i] = MAYUSCULA sexos[i] SI ( sexos[i] <> ‘M’ OR sexos[i] <> ’F’ ) ENTONCES

ESCRIBIR “Sexo de socio no válido...” FINSI

MIENTRAS ( sexos[i] <> ‘M’ OR sexos[i] <> ’F’ )


Pag. 504


Algoritmo PrgSocios01 - método main ( ) HACER

COMENTARIO “ Ingreso de edad de socios ” LEER edades[i] SI ( edades[i] <= 0 ) ENTONCES

ESCRIBIR “Edad de socio no válida...” FINSI

MIENTRAS ( edades[i] <= 0 ) FINDESDE COMENTARIO “Determinando número de socios hombres mayores

de edad” DESDE i = 0 HASTA i = numSoc - 1 INCREMENTA 1

SI ( edades[i] >= 18 AND sexos[i] = ‘M’ ) ENTONCES

totalMayorHombres = totalMayorHombres + 1 FINSI

FINDESDE ESCRIBIR totalMayorHombres COMENTARIO “Determinando el promedio del sueldo de todos los

trabajadores” DESDE i = 0 HASTA i = numSoc - 1 INCREMENTA 1

letra = nombres[i] CARACTER 0 letra = MAYUSCULA letra SI ( letra = ‘D’ ) ENTONCES

totalNombresD = totalNombresD + 1 FINSI

FINDESDE ESCRIBIR totalNombresD

FIN


Pag. 505


Clase PrgSocios01 package dominioDeLaAplicacion ; import biblioteca.* ; public class PrgSocios01 {

public static void main(String[] args) { // Declaración de variables. int i, numSoc, totalMayoresHombres = 0, totalNombresD = 0 ; char letra ; // Determinación del tamaño de los arreglos con consistencia de datos. do {

System.out.print ( “ Ingrese el número de socios : ” ) ; numSoc = Lectura.leerInt( ) ; if ( numSoc <= 0 ) {

System.out.println ( “ El número de socios no es válido… Reintente! ” ) ; }

} while ( numSoc <= 0 ) ; // Declaración y creación del arreglo. String nombres[ ] = new String [numSoc] ; char sexos[ ] = new char [numSoc] ; int edades[ ] = new int [numSoc] ; // Ingreso de nombre, sexo y edad de los socios con consistencia de datos. for ( i = 0 ; i < numSoc ; i++ ) {

do { System.out.print ( “ Ingrese el nombre del socio [ ” + ( i + 1) + “ ]: ” ) ; nombres[i] = Lectura.leerString( ) ; nombres[i] = nombres[i].trim( ) ; if ( nombres[i].length( ) < 3 ) {

System.out.println ( “ El nombre del socio no es válido… ” ) ; }


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


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

Problema 148

Etapa 01 - Descripción del problema. Desarrollar una solución que permita ingresar y almacenar el nombre, el precio de compra y el precio de venta de todos los artículos de una bodega. Indicar el nombre de cada artículo y su margen de utilidad. Etapa 02 - Definición de la solución.

Resultado deseado: Mostrar el nombre de cada artículo y su

margen de utilidad.

Datos necesarios: El número de artículos y, el nombre, el precio de compra y el precio de venta de cada artículo.


teclado y se almacena en una variable (numArt). Con el número de artículos se crean dos arreglos, un vector y una matriz con dos columnas (nombres[ ] y precios[ ][ ]). Luego se procede a ingresar el nombre de los artículos, se eliminan los espacios del inicio y final de los mismos, y se almacenan en uno de los arreglos creados (nombres[ ]). Luego, se procede a ingresar el precio de compra y el precio de venta, y se almacenan en el otro arreglo creado (precios[ ][ ]). El precio de compra se almacena en la primera columna del arreglo y el precio de venta se almacena en la segunda columna. Después, se determina la utilidad de cada artículo. Para esto, el precio de venta del artículo se resta de su precio de compra, se almacena el resultado en una variable (utilidad) y se muestra el nombre del artículo junto con su utilidad.


Pag. 508






Clases biblioteca


Pag. 509


Algoritmo PrgArticulos06 - método main ( ) ENTRADA: numArt, nombres[ ], precios[ ][ ] SALIDA: nombres[ ], utilidad INICIO

COMENTARIO “Declaración de variables” NUMERO i, numArt, precios[ ][ ], utilidad TEXTO nombres[ ] COMENTARIO “Determinación del tamaño del arreglo”

HACER LEER numArt SI (numArt <= 0 ) ENTONCES


MIENTRAS (numArt <= 0 ) COMENTARIO “Creación de los arreglos” CREAR nombres [numArt] CREAR precios [numArt][2] COMENTARIO “Ingreso de nombre, precio de compra y precio de

venta de los artículos ” DESDE i = 0 HASTA i = numArt - 1 INCREMENTA 1

HACER COMENTARIO “ Ingreso de nombre de artículo ” LEER nombres[i] nombres[i] = nombres[i] ELIMINAESPACIO INICIO, FIN SI ( LONGITUD nombres[i] < 3 ) ENTONCES

ESCRIBIR “Nombre del artículo no válido...” FINSI MIENTRAS ( LONGITUD nombres[i] < 3 )

HACER

COMENTARIO “ Ingreso de precio de compra ” LEER precios[i][0] SI ( precios[i][0] <= 0 ) ENTONCES

ESCRIBIR “Precio de compra no válido...” FINSI

MIENTRAS ( precios[i][0] <= 0 )


Pag. 510


Algoritmo PrgArticulos06 - método main ( ) HACER

COMENTARIO “ Ingreso de precio de venta ” LEER precios[i][1] SI ( precios[i][1] <= 0 ) ENTONCES

ESCRIBIR “Precio de venta no válido...” FINSI

MIENTRAS ( precios[i][1] <= 0 )

FINDESDE COMENTARIO “Determinando la utilidad de cada artículo ” DESDE i = 0 HASTA i = numArt - 1 INCREMENTA 1

utilidad = precios[i][1] – precios[i][0] ESCRIBIR nombres[i], utilidad

FINDESDE

FIN


Pag. 511



public static void main(String[] args) { // Declaración de variables. int i, numArt ; double utilidad ; // Determinación del tamaño de los arreglos con consistencia de datos. do {



} while ( numArt <= 0 ) ; // Declaración y creación del arreglo. String nombres[ ] = new String [numArt] ; double edades[ ] = new double [numArt][2] ; // Ingreso de nombre, precio de compra y precio de venta de los artículos. for ( i = 0 ; i < numArt ; i++ ) {

do { System.out.print ( “ Ingrese el nombre del artículo [ ” + ( i + 1) + “ ]: ” ) ; nombres[i] = Lectura.leerString( ) ; nombres[i] = nombres[i].trim( ) ; if ( nombres[i].length( ) < 3 ) {

System.out.println ( “ El nombre del artículo no es válido… ” ) ; }


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


Clase PrgArticulos06 do {

System.out.print ( “ Ingrese su precio de venta : ” ) ; precios[i][1] = Lectura.leerDouble( ) ; if ( precios[i][1] <= 0 ) {

System.out.println ( “ Precio de venta no válido… ” ) ; }

} while ( precios[i][1] <= 0 ) ;

} // Determinando la utilidad de cada artículo. for ( i = 0 ; i < numArt ; i++ ) {

utilidad = precios[i][1] – precios[i][0] ; System.out.print ( “ El artículo : ” + nombres[i] + “ tiene una utilidad de ” ) ; System.out.println ( “ ” + utilidad + “.” ) ;

}

} }


Pag. 513

Problema 149

Etapa 01 - Descripción del problema. Desarrollar una solución que permita ingresar y almacenar el nombre, el código y las diferentes notas de los alumnos de un salón de clase. Indicar el nombre, el código y el promedio de notas de cada alumno. Almacenar el promedio de notas de cada alumno. Adicionalmente, indicar el nombre de los alumnos que obtuvieron el mayor promedio. Etapa 02 - Definición de la solución.

Resultado deseado: Mostrar el nombre, el código y el promedio de

notas de cada alumno. Adicionalmente, indicar el nombre de los alumnos que obtuvieron el mayor promedio.

Datos necesarios: El número de alumnos y, el nombre, el código

y las notas de cada alumno.

Procesamiento: El número de alumnos y el número de notas se ingresa a través del teclado y se almacena en variables (numAlu y numNot respectivamente). Con el número de alumnos y el número de notas se crean cuatro arreglos, tres vectores y una matriz (nombres[], codigos[], notas[][] y promedios[][]). Luego se procede a ingresar el nombre de los alumnos, y se almacenan en uno de los arreglos creados (nombres[]). Luego, se procede a ingresar el código de los alumnos y se almacenan en otro arreglo (codigos[]). Támbien se ingresan las notas de cada alumno y se almacenan en otro de los arreglos (notas[][]). Después, se determina el promedio de cada alumno y el promedio mayor. Para esto, se suman las notas del alumno y se almacenan en una variable (sumaNotas) y luego se divide entre el número de notas (numNot). El resultado se almacenada en otra variable (promAlu), se redondea y esta a su vez se almacena en el arreglo promedios[]. Después se muestra el nombre, el código y el promedio de cada alumno. Luego se determina el promedio mayor y se almacena


Pag. 514

en una variable (promAluMayor). Finalmente, se muestran los nombres de todos los alumnos que tienen promedio igual a promAluMayor.






Clases biblioteca


Pag. 515


Algoritmo PrgAlumnos06 - método main ( ) ENTRADA: numAlu, numNot, nombre[ ], codigos[ ], notas[ ][ ] SALIDA: nombres[ ], codigos[ ], promedios[ ] INICIO

COMENTARIO “Declaración de variables” NUMERO i, j, numAlu, nomNot, codigos[ ], notas[ ][ ], promedios[ ] NUMERO sumaNotas = 0, promAlu = 0, promAluMayor = 0 TEXTO nombres[ ] COMENTARIO “Determinación del tamaño del arreglo” HACER


ESCRIBIR “Número de alumnos no válido… ” FINSI

MIENTRAS (numAlu <= 0 ) HACER

LEER numNot SI (numNot <= 0 ) ENTONCES

ESCRIBIR “Número de notas no válido… ” FINSI

MIENTRAS (numNot <= 0 ) COMENTARIO “Creación de los arreglos” CREAR nombres [numAlu] CREAR codigos [numAlu] CREAR notas [numAlu][numNot] CREAR promedios[numAlu] COMENTARIO “Ingreso de nombre, codigo y notas de todos los

alumnos ” DESDE i = 0 HASTA i = numAlu - 1 INCREMENTA 1

HACER

LEER nombres[i] nombres[i] = nombres[i] ELIMINAESPACIO INICIO,FIN SI ( LONGITUD nombres[i] < 3 ) ENTONCES

ESCRIBIR “Nombre del alumno no válido...” FINSI

MIENTRAS ( LONGITUD nombres[i] < 3 )


Pag. 516


Algoritmo PrgAlumnos06 - método main ( ) HACER

LEER codigos[i] SI ( codigos[i] < 100000 OR codigos[i] > 999999 ) ENTONCES

ESCRIBIR “Código ingresado no válido...” FINSI

MIENTRAS ( codigos[i] < 100000 OR codigos[i] > 999999 ) DESDE j = 0 HASTA j = numNot - 1 INCREMENTA 1

HACER LEER notas[i][j] SI ( notas[i][j] < 0 OR notas[i][j] > 20 ) ENTONCES

ESCRIBIR “Nota ingresada no válida...” FINSI

MIENTRAS ( notas[i][j] < 0 OR notas[i][j] > 20 ) FINDESDE

FINDESDE COMENTARIO “Determinando el promedio de cada alumno y el

promedio mayor ” DESDE i = 0 HASTA i = numAlu - 1 INCREMENTA 1

sumaNotas = 0 DESDE j = 0 HASTA j = numNot - 1 INCREMENTA 1

sumaNotas = sumaNotas + notas[i][j] FINDESDE promAlu = sumaNotas / numNot promAlu = promAlu REDONDEA 2 promedio[i] = promAlu ESCRIBIR nombres[i], codigos[i], promedios[i]

SI ( i = 0 ) ENTONCES

promAluMayor = promAlu SINO

SI ( promAluMayor < promAlu ) ENTONCES

promAluMayor = promAlu FINSI

FINSI FINDESDE

COMENTARIO “Mostrando los alumnos con el promedio mayor” DESDE i = 0 HASTA i = numAlu - 1 INCREMENTA 1

SI ( promedios[i] = promAluMayor ) ENTONCES

ESCRIBIR nombres[i] FINSI

FINDESDE

FIN


Pag. 517



public static void main(String[] args) { // Declaración de variables. int i, j, numAlu, numNot ; double sumaNotas = 0, promAlu = 0, promAluMayor = 0 ; // Determinación del tamaño de los arreglos con consistencia de datos. do {



} while ( numAlu <= 0 ) ; do {

System.out.print ( “ Ingrese el número de notas por alumno : ” ) ; numNot = Lectura.leerInt( ) ; if ( numNot <= 0 ) {

System.out.println ( “ El número de notas no es válido… Reintente! ” ) ; }

} while ( numNot <= 0 ) ; // Declaración y creación del arreglo. String nombres[ ] = new String [numAlu] ; long codigos[ ] = new long [numAlu] ; double notas[ ][ ] = new double [numAlu][numNot] ; double promedios[ ] = new double [numAlu] ; // Ingreso de nombre, precio de compra y precio de venta de los artículos. for ( i = 0 ; i < numAlu ; i++ ) {

do { System.out.print ( “ Ingrese el nombre del alumno [ ” + ( i + 1) + “ ]: ” ) ; nombres[i] = Lectura.leerString( ) ; nombres[i] = nombres[i].trim( ) ; if ( nombres[i].length( ) < 3 ) {

System.out.println ( “ El nombre del alumno no es válido… ” ) ; }

} while ( nombres[i].length( ) < 3 ) ;


Pag. 518


Clase PrgAlumnos06 do {

System.out.print ( “ Ingrese su código : ” ) ; codigos[i] = Lectura.leerLong( ) ;

if ( codigos[i] < 100000 || codigos[i] > 999999 ) { System.out.println ( “ Precio de compra no válido… ” ) ;

} } while ( codigos[i] < 100000 || codigos[i] > 999999 ) ; for ( j = 0 ; j < numNot ; j++ ) {

do { System.out.print ( “ Ingrese su nota ” + ( j + 1) + “ : ” ) ; notas[i][j] = Lectura.leerDouble( ) ;

if (notas[i][j] < 0 || notas[i][j] > 20 ) { System.out.println ( “ Nota ingresada no válida… ” ) ;

} } while (notas[i][j] < 0 || notas[i][j] > 20 ) ;

} } // Determinando el promedio de cada alumno y el promedio mayor. for ( i = 0 ; i < numAlu ; i++ ) {

sumaNotas = 0 ; for ( j = 0 ; j < numNot ; j++ ) {

sumaNotas = sumaNotas + notas[i][j] ; } promAlu = sumaNotas / numNot ; promAlu = ( Math.round (promAlu * 100) ) / 100.0 ; promedios[i] = promAlu ; System.out.print ( “ El alumno ” + nombres[i] + “ con código ” + codigos[i] ) ; System.out.println ( “ tiene un promedio de ” + promedios[i] + “.” ) ; System.out.println ( ) ;

if ( i == 0 ) { promAluMayor = promAlu ;

} else { if ( promAluMayor < promAlu ) {

promAluMayor = promAlu ; }

} } // Mostrando los alumnos con el promedio mayor. System.out.println ( “ Alumnos que tienen el mayor promedio : ” ) ; for ( i = 0 ; i < numAlu ; i++ ) {

if ( promedios[i] == promAluMayor ) { System.out.println ( nombres[i] ;

} }

} }


Pag. 519

Problema 150

Etapa 01 - Descripción del problema. Desarrollar una solución que permita ingresar y almacenar el nombre de todos los artículos de una bodega. Consistenciar la entrada de datos. Mostrar los nombres ordenados alfabéticamente, considerando la primera letra de cada nombre en mayúscula y el resto en minúscula. Adicionalmente, mostrar la longitud de cada uno de los nombres. Etapa 02 - Definición de la solución.

Resultado deseado: Mostrar los nombres ordenados

alfabéticamente, considerando la primera letra de cada nombres en letra mayúscula y el resto en letra minúscula. Adicionalmente mostrar la longitud de cada uno de los nombres de los artículos.




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






Clases biblioteca


Pag. 521


Algoritmo PrgArticulos07 - método main ( ) ENTRADA: numArt, articulos[ ] SALIDA: letra, resto, tamaño INICIO

COMENTARIO “Declaración de variables” NUMERO i, j, numArt, tamaño TEXTO articulos[ ], letra, resto, x COMENTARIO “Determinación del tamaño del arreglo” HACER






MIENTRAS (LONGITUD articulos[i] < 3 ) FINDESDE COMENTARIO “Método de Intercambio. Ordenación de datos ” DESDE i = 0 HASTA i = numArt - 2 INCREMENTA 1

DESDE j = i + 1 HASTA i = numArt - 1 INCREMENTA 1

SI ( articulos[i] > articulos[j] ) ENTONCES

x = articulos[i] articulos[i] = articulos[j] articulos[i] = x

FINSI FINDESDE

FINDESDE


Pag. 522


Algoritmo PrgArticulos07 - método main ( ) COMENTARIO “ Manipulación del nombre de los artículos ” DESDE i = 0 HASTA i = numArt - 1 INCREMENTA 1

letra = articulos[i] SUBCADENA 0,1 letra = MAYUSCULA letra resto = articulos[i] SUBCADENA 1 resto = MINUSCULA resto tamaño = LONGITUD articulos[i] ESCRIBIR letra, resto, tamaño

FINDESDE

FIN




// Declaración de variables. int i, j, numArt, tamaño ; String letra, resto, x ; // Determinación del tamaño del arreglo con consistencia de datos. do {



} while ( numArt <= 0 ) ; // Declaración y creación del arreglo. String articulos[ ] = new String [numArt] ;


Pag. 523


Clase PrgArticulos07 // Ingreso de datos al arreglo artículos[ ] con consistencia de datos. for ( i = 0 ; i < numArt ; i++ ) {



} while ( articulos[i].length( ) < 3 ) ; } // Método de Intercambio. Ordenación de datos. for ( i = 0 ; i < numArt – 1 ; i++ ) {

for ( j = i + 1; j < numArt ; j++ ) { if ( articulos[i].compareTo(articulos[j] ) > 0 ) {

x = articulos[i] ; articulos[i] = articulos[j] ; articulos[j] = x ;

} }

} // Manipulación del nombre de los artículos. for ( i = 0 ; i < numArt ; i++ ) {

letra = articulos[i].substring(0,1) ; letra = letra.toUpperCase( ); resto = articulos[i].substring(1) ; resto = resto].toLowerCase( ) ; tamaño = articulos[i].length( ) ; System.out.println ( “ Artículo ” + letra + resto + “ tiene una longitud de ” + tamaño ) ;

} }

}


Pag. 524

Introducción al Desarrollo de Soluciones Orientadas a Objetos

Temas:

Introducción.

Conceptos básicos:

• Clase.

• Objeto.

• Atributo.

• Método.

• Ocultar Atributos de Instancia.

Método de las 6´D. Etapas y pasos.

Problema desarrollado.

Capítulo

5

INTRODUCCIÓN AL DESARROLLO DE SOLUCIONES ORIENTADAS A OBJETOS

Pag. 527

CAPÍTULO V


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.


Etapa 02

Diseño Solución


Etapa 03

Etapa 04

ENUNCIADO DEL PROBLEMA

MARCO DE TRABAJO


Pag. 528

En los capítulos anteriores, se ha utilizado la clase en su forma más simple. Las clases creadas se utilizaban simplemente para encapsular el método main(), lo que ha permitido mostrar la base de la sintaxis de Java, las estructuras de datos, las estructuras lógicas, las instrucciones de bifurcación, el manejo de excepciones y algunas de las clases incorporadas en Java. Como se verá en el presente capítulo, las clases son mucho más poderosas que las presentadas hasta ahora. Observe la solución del siguiente problema utilizando el método de las 6’D:

Etapa 01 - Descripción del problema. Calcular el promedio final de un alumno. Utilice la siguiente fórmula: prom = (nota1 + nota2 + nota3) / 3. Ingrese las notas nota1, nota2 y nota3 a través del teclado.


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

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


Definición de las Clases.

Clases


biblioteca

Diseño del algoritmo para el método principal.

Algoritmo PrgAlumno - método main()

ENTRADA: nota1, nota2, nota3 SALIDA: prom INICIO

NUMERO nota1, nota2, nota3, prom LEER nota1, nota2, nota3 prom = ( nota1 + nota2 + nota3) / 3 ESCRIBIR prom

FIN


Pag. 530


Clase PrgAlumno

package dominioDeLaAplicacion ; import biblioteca.Lectura ; class PrgAlumno {


double nota1, nota2, nota3, prom ; System.out.println ( “Ingrese la nota 1 del alumno: ” ) ; nota1 = Lectura.leerDouble( ) ; System.out.println ( “Ingrese la nota 2 del alumno: ” ) ; nota2 = Lectura.leerDouble( ) ; System.out.println ( “Ingrese la nota 3 del alumno: ” ) ; nota3 = Lectura.leerDouble( ) ; prom = ( nota1 + nota2 + nota3 ) / 3 ; System.out.println ( “ El promedio obtenido por el alumno es ” + prom ) ;

} }

En este proyecto ProyAlumno se crea un paquete dominioDeLaAplicación con una clase PrgAlumno la cual se utiliza en su forma más simple. En la clase PrgAlumno se define un método main() y dentro del mismo se codifica toda la solución. Como se ha mencionado, las clases son mucho más poderosas que las presentadas hasta ahora. A partir de este punto, se ampliará el conocimiento sobre las clases. Para ello, se revisarán algunos conceptos básicos y se presentarán, en forma progresiva, nuevos conceptos hasta llegar al concepto de ocultamiento de atributos de instancia. Todos estos nuevos conceptos presentados se incorporarán progresivamente en el ejemplo planteado. Al final, se formalizará el método de solución, el Método de las 6D, para incluir los conceptos presentados.


Pag. 531


Pag. 532


Pag. 533

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

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

class Alumno { }

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:

Ahora, el proyecto de solución ProyAlumno tiene definidas las clases PrgAlumno y Alumno en el paquete dominioDeLaAplicacion.


Pag. 535

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:

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:

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.

Alumno objAlumno = new Alumno ( ) ;

NombreClase nombreObjeto = new NombreClase ( ) ;


Pag. 536

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;

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.

tipo nombreAtributo;


Pag. 537

En el proyecto de solución ProyAlumno, en la clase Alumno se definirá dos atributos de instancia llamados nota1 y 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:

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:

objAlumno.nota1 = 15 ; objAlumno.nota2 = 19 ;

class Alumno { double nota1 ; double nota2 ; }

Alumno objAlumno = new Alumno ( ) ;

System.out.println ( “ La nota del alumno es: ” + objAlumno.nota1 ) ;


Pag. 538

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

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:

package dominioDeLaAplicacion ; class Alumno { double nota1 ; double nota2 ; } package dominioDeLaAplicacion ; class PrgAlumno { public static void main ( String args [ ] ) {

double prom ; // Primero declaramos y creamos un objeto de la clase Alumno. Alumno objAlumno = new Alumno ( ) ; // Ahora asignamos valores a las variables de instancia del objeto creado. objAlumno.nota1 = 15 ; objAlumno.nota2 = 19 ; // Finalmente, calculamos el promedio de notas del alumno objAlumno. prom = ( objAlumno.nota1 + objAlumno.nota2 ) / 2 ; System.out.println ( “ El promedio final del alumno es: ” + prom ) ;

} }

El promedio final del alumno es: 17

prom = ( objAlumno.nota1 + objAlumno.nota2 ) / 2 ; System.out.println ( “El promedio final del alumno es: ” + prom ) ;


Pag. 539

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

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

package dominioDeLaAplicacion ; class Alumno { double nota1, nota2, nota3 ; } package dominioDeLaAplicacion ; class PrgAlumno { public static void main ( String args [ ] ) {

double prom ; // Primero declaramos y creamos un objeto de la clase Alumno. Alumno objAlumno = new Alumno ( ) ; // Ahora asignamos valores a las variables de instancia del objeto creado. objAlumno.nota1 = 15 ; objAlumno.nota2 = 19 ; objAlumno.nota3 = 11 ; // Finalmente, calculamos el promedio de notas del alumno objAlumno. prom = ( objAlumno.nota1 + objAlumno.nota2 + objAlumno.nota3 ) / 3 ; System.out.println ( “ El promedio final del alumno es: ” + prom ) ;

} }

class Alumno { double nota1, nota2, nota3 ; }


Pag. 540

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:

Al ejecutar el proyecto (recuerde que cuando se ejecuta un proyecto en realidad se ejecuta el método main( ) ), se obtiene el siguiente resultado:

package dominioDeLaAplicacion ; class Alumno { double nota1, nota2, nota3 ; } package dominioDeLaAplicacion ; class PrgAlumno { public static void main ( String args [ ] ) {

double prom ; // Primero declaramos y creamos tres objetos de la clase Alumno. Alumno objAlumno = new Alumno ( ) ; Alumno objAlumno02 = new Alumno ( ) ; Alumno objAlumno03 = new Alumno ( ) ; // Ahora asignamos valores a las variables de instancia del objeto objAlumno. objAlumno.nota1 = 15 ; objAlumno.nota2 = 19 ; objAlumno.nota3 = 11 ; // También asignamos valores a las variables de instancia del objeto objAlumno02. objAlumno02.nota1 = 11 ; objAlumno02.nota2 = 11 ; objAlumno02.nota3 = 11 ; // y a las variables de instancia del objeto objAlumno03. objAlumno03.nota1 = 13 ; objAlumno03.nota2 = 14 ; objAlumno03.nota3 = 15 ; // Calculamos el promedio de notas del objeto objAlumno. prom = ( objAlumno.nota1 + objAlumno.nota2 + objAlumno.nota3 ) / 3 ; System.out.println ( “ El promedio final del alumno es: ” + prom ) ; // También calculamos el promedio de notas del objeto objAlumno02. prom = ( objAlumno02.nota1 + objAlumno02.nota2 + objAlumno02.nota3 ) / 3 ; System.out.println ( “ El promedio final del alumno es: ” + prom ) ; // Finalmente, calculamos el promedio de notas del objeto objAlumno03. prom = ( objAlumno03.nota1 + objAlumno03.nota2 + objAlumno03.nota3 ) / 3 ; System.out.println ( “ El promedio final del alumno es: ” + prom ) ;

} }

El promedio final del alumno es: 15 El promedio final del alumno es: 11 El promedio final del alumno es: 14


Pag. 541

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

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:

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:

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 ;

]

nombreObjeto.nombreMétodoInstancia ( ) ;

NombreClase.nombreMétodoClase ( ) ;


Pag. 543

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

Metodo que no devuelven valor y no reciben parámetros Talvez se tengan algunos problemas para comprender los conceptos que rodean a los métodos, poco a poco conforme se modifique el proyecto de solución ProyAlumno se podrán comprender mejor.

Ahora, se definirá un método dentro de la clase Alumno. El método se llamará promedio( ), y permitirá calcular y mostrar el promedio de notas de un alumno. Aunque, anteriormente, esto ya se había realizado en la clase PrgAlumno es perfectamente válido haber pensado que esto era algo que había que hacer en la clase Alumno y no en la clase PrgAlumno. Como el promedio de notas depende de las notas, tiene mucho mas sentido que el cálculo lo realice la clase Alumno a través del método promedio( ), el cual se desarrolla a continuación:

package dominioDeLaAplicacion ; class Alumno { double nota1, nota2, nota3 ;

void promedio ( ) { System.out.print ( “ El promedio final del alumno es: ” ) ; System.out.println ( (nota1 + nota2 + nota3 ) / 3 ) ; } } package dominioDeLaAplicacion ; class PrgAlumno {

public static void main ( String args [ ] ) {

double prom ;

// Primero declaramos y creamos tres objetos de la clase Alumno. Alumno objAlumno = new Alumno ( ) ; Alumno objAlumno02 = new Alumno ( ) ; Alumno objAlumno03 = new Alumno ( ) ;

// Ahora asignamos valores a las variables de instancia del objeto objAlumno. objAlumno.nota1 = 15 ; objAlumno.nota2 = 19 ; objAlumno.nota3 = 11 ;

// También asignamos valores a las variables de instancia del objeto objAlumno02. objAlumno02.nota1 = 11 ; objAlumno02.nota2 = 11 ; objAlumno02.nota3 = 11 ;

// y a las variables de instancia del objeto objAlumno03. objAlumno03.nota1 = 13 ; objAlumno03.nota2 = 14 ; objAlumno03.nota3 = 15 ;

// Calculamos el promedio de notas para cada alumno. objAlumno.promedio ( ) ; objAlumno02.promedio ( ) ; objAlumno03.promedio ( ) ;

} }


Pag. 545

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

El promedio final del alumno es: 15 El promedio final del alumno es: 11 El promedio final del alumno es: 14

objAlumno.promedio ( ) ; objAlumno02.promedio ( ) ; objAlumno03.promedio ( ) ;

objAlumno.promedio ( ) ;


Pag. 546

Ahora, se analizará la definición del método promedio( ) de la clase Alumno;

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.

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.

void promedio ( ) { System.out.print ( “ El promedio final del alumno es: ” ) ; System.out.println ( (nota1 + nota2 + nota3 ) / 3 ) ; }

No devuelve valor.

No tiene parámetros.

void promedio ( ) { System.out.print ( “ El promedio final del alumno es: ” ) ; System.out.println ( ( nota1 + nota2 + nota3 ) / 3 ) ; }


Pag. 547

Métodos que devuelven valor y no reciben parámetros

Aunque en el método promedio( ) se realiza el cálculo y visualización del promedio de notas, esto no constituye la mejor forma o alternativa de desarrollar dicho método. Esto se debe, a que en mucho casos, otras partes del método main( ) u otros métodos necesitarán que se ejecute el método promedio( ) para que se realice el cálculo del promedio de notas, pero no todos necesitarán que una vez calculado el promedio de notas este se visualice. Con la finalidad de mejorar la implementación del método promedio( ), se puede realizar solo el cálculo del promedio de notas y devolver dicho valor para que este pueda ser utilizado de diferente forma.

A continuación se modificará el proyecto de solución ProyAlumno con la finalidad de mejorar la implementación del método promedio( ):

package dominioDeLaAplicacion ; class Alumno { double nota1, nota2, nota3 ; double promedio ( ) { return ( nota1 + nota2 + nota3 ) / 3 ; } } package dominioDeLaAplicacion ; class PrgAlumno { public static void main ( String args [ ] ) {

double prom ; // Primero declaramos y creamos tres objetos de la clase Alumno. Alumno objAlumno = new Alumno ( ) ; Alumno objAlumno02 = new Alumno ( ) ; Alumno objAlumno03 = new Alumno ( ) ; // Ahora asignamos valores a las variables de instancia del objeto objAlumno. objAlumno.nota1 = 15 ; objAlumno.nota2 = 19 ; objAlumno.nota3 = 11 ; // También asignamos valores a las variables de instancia del objeto objAlumno02 objAlumno02.nota1 = 11 ; objAlumno02.nota2 = 11 ; objAlumno02.nota3 = 11 ; // y a las variables de instancia del objeto objAlumno03. objAlumno03.nota1 = 13 ; objAlumno03.nota2 = 14 ; objAlumno03.nota3 = 15 ; // Calculamos el promedio de notas para cada alumno. prom = objAlumno.promedio ( ) ; System.out.println ( “ La nota final de Luis es ” + prom + “.” ) ;


Pag. 548

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

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.

prom = objAlumno.promedio ( ) ;

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 ( ) + “.” ) ;

} }

Sentencia definida en el método main( ) de la clase PrgAlumno. prom = objAlumno.promedio ( ) ;

Método definido en la clase Alumno. double promedio ( ) {

return ( nota1 + nota2 + nota3 ) / 3 ;

}


Pag. 549

Es preciso mencionar, que se puede escribir estas sentencias de una manera más eficiente. Observe la siguiente sentencia:

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.

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.

double promedio ( ) { return (nota1 + nota2 + nota3 ) / 3 ;

}

Especifica que se debe devolver un valor double.


prom = objAlumno.promedio ( ) ;

Declarada como double. Lo cual es compatible con el tipo de dato especificado por el método.

Se obtiene el promedio de notas y se muestra el resultado:

prom = objAlumno.promedio ( ) ; System.out.println ( “ La nota final de Luis es ” + prom + “.” ) ;

Se obtiene el promedio de notas, se aumenta 1 y se muestra el resultado:

prom = objAlumno02.promedio ( ) ; prom = prom + 1 ; System.out.println ( “ La nota final de María es ” + prom + “.” ) ;

System.out.println ( “ La nota final de Pedro es ” + objAlumno03.promedio ( ) + “.” ) ;


Pag. 550

Métodos que no devuelven valor y reciben parámetros

Ahora, se definirá un segundo método dentro de la clase Alumno. El método se llamará setNotas( ) y permitirá asignar valores a las variables de instancia nota1, nota2 y nota3. Esto debido, fundamentalmente, a que en problemas Java bien diseñados las variables de instancia deberían ser accesibles sólo a través de los métodos definidos por sus clases y no en forma directa. El método setNotas( ) recibirá, a través de sus parámetros, las notas de un alumno y las asignará a los atributos de instancia. Los parámetros generalizan el uso de un método permitiendo trabajar con diversos datos y utilizarlo en diferentes situaciones.

package dominioDeLaAplicacion ; class Alumno { double nota1, nota2, nota3 ; double promedio ( ) { return ( nota1 + nota2 + nota3 ) / 3 ; } void setNotas ( double a, double b, double c ) { nota1 = a ; nota2 = b ;

nota3 = c ; } } package dominioDeLaAplicacion ; class PrgAlumno { public static void main ( String args [ ] ) {

double prom ; // Primero declaramos y creamos tres objetos de la clase Alumno. Alumno objAlumno = new Alumno ( ) ; Alumno objAlumno02 = new Alumno ( ) ; Alumno objAlumno03 = new Alumno ( ) ; // Ahora asignamos valores a los atributos de instancia del objeto objAlumno. objAlumno.setNotas ( 15,19,11 ) ; // También asignamos valores a los atributos de instancia del objeto objAlumno02. objAlumno02.setNotas ( 11,11,11 ) ; // y a los atributos de instancia del objeto objAlumno03. objAlumno03.setNotas ( 13,14,15 ) ; // Calculamos el promedio de notas para cada alumno. prom = objAlumno.promedio ( ) ; System.out.println ( “ La nota final de Luis es ” + prom + “.” ) ; prom = objAlumno02.promedio ( ) ;


Pag. 551

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.

objAlumno.setNotas ( 15,19,11 ) ;

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() + “.” );

} }

a = 15

Sentencia definida en el método main() de la clase PrgAlumno. objAlumno.setNotas (15,19,11 ) ;

Método definido en la clase Alumno. void setNotas ( double a, double b, double c ) {

nota1 = a ; nota2 = b ; nota3 = c ;

}

3 ARGUMENTOS Un argumento es un valor que se envía a un método cuando este es ejecutado.

3 PARÁMETROS Un parámetro es una variable definida por un método, que recibe un valor cuando se ejecuta dicho método.


Pag. 552

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:

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:

objAlumno.setNotas(15,19,11);

Especifica que se envían 3 valores (argumentos) de tipo double al método setNotas ( ).

void setNotas ( double a, double b, double c ) { nota1 = a ; nota2 = b ; nota3 = c ;

}

Especifica que se tiene definido 3 parámetros de tipo double.

No devuelve valor.


Pag. 553

En conclusión, se puede afirmar lo siguiente:

1. Un método puede; no devolver valor y no tener definido parámetros.

2. Un método puede; no devolver un valor y tener definido uno o más parámetros.

3. Un método puede; devolver un valor y no tener definido parámetros.

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

No devuelve valor.


void promedio ( ) { System.out.print ( “ El promedio final del alumno es: ” ) ; System.out.println ( ( nota1 + nota2 + nota3 ) / 3 ) ; }

double promedio ( ) { return (nota1 + nota2 + nota3 ) / 3 ;

}

Especifica que se debe devolver un valor double.


void setNotas ( double a, double b, double c ) { nota1 = a ; nota2 = b ; nota3 = c ;

}

Especifica que se tiene definido 3 parámetros de tipo double.

No devuelve valor.


Pag. 554

Método constructor En Java, la inicialización de objetos no se puede realizar en el momento en que estos son definidos; Por lo cual, se tiene la característica de disponer de un método que permite inicializar objetos inmediatamente después que se crean. Este método es conocido como el método constructor. Un constructor es un método especial que sirve para construir o inicializar objetos. Cada vez que se crea un objeto se ejecuta en forma automática el método constructor. El método constructor permite que se inicialicen la copia de los atributos de instancia de los objetos inmediatamente después de su creación. El método constructor tiene el mismo nombre que la clase en la cual está definido. Los métodos constructores pueden tener parámetros al igual que otros métodos, pero no devuelven ningún valor, ni siguiera void.

Se modificará el proyecto de solución ProyAlumno, de tal forma que se defina solo el objeto objAlumno de la clase Alumno en el método main() de la clase PrgAlumno (esto con la finalidad de implementar nuevos conceptos en un proyecto de solución sencillo y pequeño), y se incluirá un método constructor en la clase Alumno que permita inicializar la copia de los atributos de instancia nota1, nota2 y nota3 para el objeto objAlumno:

package dominioDeLaAplicacion ; class Alumno { double nota1, nota2, nota3 ; Alumno ( ) { nota1 = 0 ; nota2 = 0 ;

nota3 = 0 ; } double promedio ( ) { return ( nota1 + nota2 + nota3 ) / 3 ; } void setNotas ( double a, double b, double c ) { nota1 = a ; nota2 = b ;

nota3 = c ; } } package dominioDeLaAplicacion ; class PrgAlumno { public static void main ( String args [ ] ) {

double prom ; // Primero declaramos y creamos un objeto de la clase Alumno. Alumno objAlumno = new Alumno ( ) ; // Ahora asignamos valores a la copia de las variables de instancia del objeto creado. objAlumno.setNotas ( 15,19,11 ) ;

// Calculamos y mostramos el promedio de notas. prom = objAlumno.promedio ( ) ; System.out.println ( “ La nota final de Luis es ” + prom + “.” ) ;

} }


Pag. 555

Cuando se ejecuta la siguiente sentencia:

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

Alumno objAlumno = new Alumno();


Pag. 556

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:

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


nota3 = 0 ; } double promedio ( ) { return ( nota1 + nota2 + nota3 ) / 3 ; } void setNotas ( double a, double b, double c ) { nota1 = a ; nota2 = b ;

nota3 = c ; } }


Pag. 557

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:

Analizar la variación en la codificación de la clase Alumno:

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


nota3 = 0 ; } double promedio ( ) { return ( nota1 + nota2 + nota3 ) / 3 ; } void setNotas ( double nota1, double nota2, double nota3 ) { this.nota1 = nota1 ; this.nota2 = nota2 ;

this.nota3 = nota3 ; } }

this.nombreAtributoInstancia ;

This.nota1 = nota1;

Nos referimos a la variable local nota1.

Nos referimos al atributo de instancia nota1.


Pag. 558

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

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:


nota3 = 0 ; } double promedio ( ) { return ( nota1 + nota2+nota3 ) / 3 ; } void setNotas ( double noat1, double nota2, double nota3 ) { this.nota1 = nota1 ; this.nota2 = nota2 ;

this.nota3 = nota3 ; } } package dominioDeLaAplicacion ; import biblioteca.* ; class PrgAlumno { public static void main ( String args [ ] ) {

double n1, n2, n3, prom ; Alumno objAlumno = new Alumno ( ) ; // Ingresamos las notas. System.out.println ( “ Ingrese la nota de prácticas del alumno: ” ) ; n1 = Lectura.leerInt ( ) ; System.out.println ( “ Ingrese la nota del examen parcial: ” ) ; n2 = Lectura.leerInt ( ) ; System.out.println ( “ Ingrese la nota de examen final: ” ) ; n3 = Lectura.leerInt ( ) ; // Ahora enviamos las notas a la copia de los atributos de instancia del objeto. objAlumno.setNotas ( n1,n2,n3 ) ;


} } package biblioteca ; public class Lectura { // Cuerpo de la clase Lectura definida en capítulos anteriores. }


Pag. 560

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

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:

• Definición del proyecto de solución.

• Definición del algoritmo. • Definición del paquete

Aplicación. o Definición de clases

con sus atributos y métodos.

• Definición del paquete biblioteca.

o Uso de la clase Lectura con sus métodos definidos.

• Diseño del diagrama de paquetes respectivo. Establecer la dependencia. (Utilice UML).

• Diseño de las clases que serán parte del paquete Aplicación. (Utilice UML).

• Diseño del algoritmo para

los método definidos. Utilizar pseudocódigo.

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


Diseño Solución

DesarrolloSolución

ENUNCIADO DEL

PROBLEMA Etapa 02 Etapa 03 Etapa 04


Pag. 562


Pag. 563

Con el propósito de describir los pasos definidos de las etapas del método 6’D, se volverá a solucionar el problema anterior.

PROBLEMA 151

Etapa 01 - Descripción del problema. Calcular el promedio final de un alumno. Utilice la siguiente fórmula: prom = ( nota1 + nota2 + nota3 ) / 3. Ingrese las notas nota1, nota2 y nota3 a través del teclado.


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

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

Etapa 03 – Diseño de la lógica.

Diseño del Diagrama de Paquetes.


Diseño de las clases.

Clases de dominioDeLaAplicacion Clase de biblioteca

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

dominioDeLaAplicacion biblioteca

main( )

PrgAlumno

leerString( ) : String leerChar( ) : char leerInt( ) : int leerLong( ) : long leerFloat( ) : float leerDouble( ) : double

Lectura

Alumno( ) setNotas(double, double, double) : void promedio( ) : double

Alumno

nota1 : double nota2 : double nota3 : double


Pag. 566

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 ATRIBUTO.nota2 = nota2 ATRIBUTO.nota3 = nota3 FIN

METODO PROMEDIO PARAMETRO: RETORNO: prom INICIO NUMERO prom prom = ( nota1 + nota2 +nota3 ) / 3 RETORNAR prom FIN

Observe que en esta Etapa – Diseño de la lógica, se ha utilizado nuevas reglas de pseudocódigo las cuales describimos a continuación: CREAR OBJETO

Se utiliza para indicar la creación de un determinado objeto. El formato completo se muestra a continuación a través de un ejemplo:

CREAR OBJETO objAlumno CLASE Alumno EJECUTA Alumno ( ) A través de esta instrucción se crea un objeto denominado objAlumno de la clase Alumno y se ejecuta el método constructor especificado.


Pag. 567

EJECUTAR Se utiliza para ejecutar un método. Hay que tener presente que si el método es de clase se deberá anteponer el operador punto (.) y el nombre de la clase antes de colocar el nombre del método que se desea ejecutar. Si el método es de instancia se deberá anteponer el operador punto (.) y el nombre del objeto antes de colocar el nombre del método que se desea ejecutar.

EJECUTAR objAlumno.setNotas ( n1,n2,n3 ) Se ejecuta el método setNotas() del objeto objAlumno, y se le envían los valores de la variables n1, n2 y n3.

prom = EJECUTAR objAlumno.promedio ( ) Se ejecuta el método promedio del objeto objAlumno. El método promedio devuelve un resultado, el cual se almacena en la variable prom.

PARAMETRO Se utiliza para especificar las variables que utilizamos para recibir los valores enviados a un determinado método.

PARAMETRO: nota1, nota2, nota3 Se especifica que se utilizan las variables nota1, nota2 y nota3 para recibir los valores que se envían al método al cual pertenece la instrucción.

RETORNO

Se utiliza para especificar la variable que utilizaremos para devolver o retornar una respuesta de un determinado método.

RETORNO: prom Se especifica que el valor almacenado en la variable prom será devuelto como respuesta cuando se ejecuta el método al cual pertenece la instrucción.

ATRIBUTO

Se utiliza para diferenciar un atributo de una variable local cuando ambos tienen el mismo nombre y se utilizan en un mismo método.

ATRIBUTO.nota1 = nota1 Para referirnos al atributo nota1 utilizamos la regla ATRIBUTO, la cual antecede al operador punto (.) y al nombre del atributo, tal y como se muestra en el ejemplo anterior.


Pag. 568


Clase PrgAlumno

package dominioDeLaAplicacion ; import biblioteca.Lectura ; class PrgAlumno { public static void main ( String args [ ] ) {

double n1, n2, n3, prom ; Alumno objAlumno = new Alumno ( ) ; // Ingresamos las notas. System.out.println ( “ Ingrese la nota de prácticas del alumno: ” ) ; n1 = Lectura.leerInt ( ) ; System.out.println ( “ Ingrese la nota del examen parcial: ” ) ; n2 = Lectura.leerInt ( ) ; System.out.println ( “ Ingrese la nota de examen final: ” ) ; n3 = Lectura.leerInt ( ) ; // Enviamos las notas a la copia de los atributos de instancia del objeto. objAlumno.setNotas ( n1,n2,n3 ) ;


} }

Clase Alumno


nota3 = 0 ; } double promedio ( ) { return ( nota1 + nota2 + nota3 ) / 3 ; } void setNotas ( double nota1, double nota2, double nota3 ) { this.nota1 = nota1 ; this.nota2 = nota2 ;

this.nota3 = nota3 ; } }


Pag. 569

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

APÉNDICE

APÉNDICE

Pag. 573

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

APÉNDICE

Pag. 574

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.

APÉNDICE

Pag. 575

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.

APÉNDICE

Pag. 576

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.

APÉNDICE

Pag. 577

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.

APÉNDICE

Pag. 578

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:

e = Vot + at2

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.

APÉNDICE

Pag. 579

Á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

APÉNDICE

Pag. 580

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.

APÉNDICE

Pag. 581

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 %

APÉNDICE

Pag. 582

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

APÉNDICE

Pag. 583

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

APÉNDICE

Pag. 584

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

APÉNDICE

Pag. 585

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:

APÉNDICE

Pag. 586

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.

APÉNDICE

Pag. 587

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:

1 + 1 /3 2 + 1 /5 2 + 1 /7 2 + 1 /9 2 + . . .

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.

APÉNDICE

Pag. 588

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:

* * * * * * * * * * *

* * * * * * * * * *

* * * * * * * * *

* * * * * * * *

* * * * * * *

APÉNDICE

Pag. 589

98. Desarrollar un programa que genere el siguiente gráfico:

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

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

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

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

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

* * * * * * * * * * *

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

APÉNDICE

Pag. 590

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.

APÉNDICE

Pag. 591

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.

APÉNDICE

Pag. 592

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:

APÉNDICE

Pag. 593

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?

APÉNDICE

Pag. 594

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

APÉNDICE

Pag. 595

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.

APÉNDICE

Pag. 596

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.

APÉNDICE

Pag. 597

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.

APÉNDICE

Pag. 598

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.

APÉNDICE

Pag. 599

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.

APÉNDICE

Pag. 600

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.


APÉNDICE

Pag. 601


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.


APÉNDICE

Pag. 602

APÉNDICE

Pag. 603

Clase Lectura

package biblioteca; import java.io.*; /* * Clase que permite capturar literales desde el teclado. * */

public class Lectura {

/** * Retorna el char capturado desde el teclado. */ public static char leerChar() { char c = ' '; char[] c1 = leerString().toCharArray(); if (c1.length == 1) c = c1[0]; return c; } /** * Retorna un literal double capturado desde el teclado. */ public static double leerDouble() { try { return Double.valueOf(leerString()).doubleValue(); } catch (NumberFormatException e) { System.out.print("ERROR...\n Ingrese de nuevo: "); return leerDouble(); } } /** * Retorna un literal float capturado desde el teclado. */ public static float leerFloat() { try { return Float.valueOf(leerString()).floatValue(); } catch (NumberFormatException e) { System.out.print("ERROR...\n Ingrese de nuevo: "); return leerFloat(); } }

APÉNDICE

Pag. 604

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

}

APÉNDICE

Pag. 605

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 ;

APÉNDICE

Pag. 606

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:

APÉNDICE

Pag. 607

En el ejemplo siguiente usaremos distintos cadenas de texto para dar formato a un número ingresado por teclado. Debemos tener en cuenta que:

• Para poner completar con ceros la parte decimal debemos poner tantos “0” como dígitos decimales queremos que tenga nuestro número en la cadena de formato.

• Si queremos que un número que no tiene parte decimal muestre un ‘0’antes del separador decimal debemos poner un ‘0’ en esa posición en nuestra cadena de formato.

public static void main(java.lang.String[] args) { double n; String s; DecimalFormat f; System.out.print("Ingresa número a dar formato : "); n = Lectura.leerDouble(); f = new DecimalFormat("###,###"); s = f.format(n); System.out.println(s); f = new DecimalFormat("###,###.00"); s = f.format(n); System.out.println(s); f = new DecimalFormat("###,###.0000"); s = f.format(n); System.out.println(s); f = new DecimalFormat("'U$' ###,##0.00"); s = f.format(n); System.out.println(s); f = new DecimalFormat("'S/.'###,##0.00 Soles"); s = f.format(n); System.out.println(s); f = new DecimalFormat("#,##0.####E0"); s = f.format(n); System.out.println(s); f = new DecimalFormat("###,##0.00%"); s = f.format(n); System.out.println(s); }

APÉNDICE

Pag. 608

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); }

APÉNDICE

Pag. 609

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) ;

APÉNDICE

Pag. 610

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

APÉNDICE

Pag. 611

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) ;

APÉNDICE

Pag. 612

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)

APÉNDICE

Pag. 613

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

APÉNDICE

Pag. 614

Ejemplo:

APÉNDICE

Pag. 615

APÉNDICE

Pag. 616

APÉNDICE

Pag. 617

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),

APÉNDICE

Pag. 618

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:

APÉNDICE

Pag. 619

APÉNDICE

Pag. 620

APÉNDICE

Pag. 621

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

APÉNDICE

Pag. 622

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

Pag. 624

Pag. 625

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

Pag. 627

NOTAS FINALES Cualquier observación, sugerencia o recomendación relacionada al contenido del presente texto podrá realizarla, enviándome un correo electrónico a la siguiente dirección:

[email protected] De antemano, agradezco cualquier contribución que permita mejorar el material y contenido del presente libro.

Pag. 628

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

Documents

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