Curso Java Basico

COGNOS
Unauthorized reproduction or distribution prohibitedฺ Copyright© 2014, Oracle and/or its affiliatesฺ
ble
fe r a
ans
n - t r
no
Conceptos fundamentales
a
de Java SE 7 has
m ) deฺ
i l ฺ c o
G ui
g mdeaactividades
e n t
6 @
Guía
S t ud
a l le1 this
( r aฺc use
a lle se to
e l o C licen
a rc
M
Raul
D67234CS20
Edición 2.0
Noviembre de 2011
D81768
COGNOS
Copyright © 2011, Oracle y/o sus filiales. Todos los derechos reservados.
Exención de responsabilidad
Este documento contiene información propiedad de Oracle Corporation y se encuentra protegido por el copyright y otras leyes
sobre la propiedad intelectual. Usted sólo podrá realizar copias o imprimir este documento para uso exclusivo por usted en los
cursos de formación de Oracle. Este documento no podrá ser modificado ni alterado en modo alguno. Salvo que la legislación del
copyright lo considere un uso excusable o legal o "fair use", no podrá utilizar, compartir, descargar, cargar, copiar, imprimir,
mostrar, representar, reproducir, publicar, conceder licencias, enviar, transmitir ni distribuir este documento total ni parcialmente sin
autorización expresa por parte de Oracle.
La información contenida en este documento puede someterse a modificaciones sin previo aviso. Si detecta cualquier problema en
el documento, le agradeceremos que nos lo comunique por escrito a: Oracle University, 500 Oracle Parkway, Redwood Shores,
California 94065 EE. UU. No se garantiza que este documento se encuentre libre de errores.
Aviso sobre restricción de derechos
Si este software o la documentación relacionada se entrega al Gobierno de EE.UU. o a cualquier entidad que adquiera licencias en
nombre del Gobierno de EE.UU. se aplicará la siguiente disposición:
U.S. GOVERNMENT RIGHTS

The U.S. Government’s rights to use, modify, reproduce, release, perform, display, or disclose these training materials are restricted
by the terms of the applicable Oracle license agreement and/or the applicable U.S. Government contract.
ble
Disposición de marca comercial registrada
fe r a
Oracle y Java son marcas comerciales registradas de Oracle y/o sus filiales. Todos los demás nombres pueden ser marcas
an s
comerciales de sus respectivos propietarios.
n - t r
a no
Autores
h a s
Jill Moritz, Kenneth Somerville, Cindy Church
m ) deฺ
i l ฺ c o
G ui
Colaboradores y revisores técnicos
m a ent
Mike Williams, Tom McGinn, Matt Heimer, Joe @ g udGoetz, Alex Buckley,
Darcy, Brian
t
6 S
Adam Messenger,Steve Watts
a l le1 this
Este libro se ha publicado conalaฺc
ayuda de:seOracle Tutor
( r u
a lle se to
e l o C licen
a rc
M
Raul
COGNOS
Tabla de Contenidos
Prácticas para la lección 1: Introducción ...................................................................................... 1-1
Prácticas de la lección 1................................................................................................................. 1-2
Prácticas para la lección 2: Introducción a la tecnología Java................................................... 2-1
Práctica 2-1: Ejecución de un programa Java mediante la línea de comandos ............................ 2-3
Práctica 2-2: Ejecución de un programa Java mediante NetBeans IDE........................................ 2-6
Prácticas para la lección 3: Consideraciones sobre los objetos................................................ 3-1
Práctica 3-1: Análisis de un problema mediante el análisis orientado a objetos ........................... 3-3
Práctica 3-2: Diseño de una solución de programación................................................................. 3-5
Prácticas para la lección 4: Introducción al lenguaje Java ......................................................... 4-1
Práctica 4-1: Visualización y adición de código en un programa Java existente........................... 4-3
Práctica 4-2: Creación y compilación de una clase Java............................................................... 4-6
Práctica 4-3: Exploración del depurador ........................................................................................ 4-12
ble
Prácticas para la lección 5: Declaración, inicialización y uso de variables .............................. 5-1 fe r a
an s
Práctica 5-1: Declaración de variables de campo en una clase .................................................... 5-3
n - t r
Práctica 5-2: Uso de operadores y conversión de tipo para evitar la pérdida de datos ................ 5-6
a no
h a s
Prácticas para la lección 6: Trabajar con objetos ........................................................................ 6-1
m ) deฺ
i l ฺ o
G ui
Práctica 6-1: Creación y manipulación de objetos Java ................................................................
c
Práctica 6-2: Uso de la clase StringBuilder ....................................................................................
6-3
6-7
Práctica 6-3: Examen de la especificación de la API de mJavaa .......................................................
e n t 6-11
g
@y construcciones d
tu de decisión ....................... 7-1
Prácticas para la lección 7: Uso de operadores
1 6 S
is if/else......................................... 7-2
lleutiliza lathsentencia
Prácticas de la lección 7.................................................................................................................
a
Práctica 7-1: Escritura de una clase
r c
ฺ queuutiliza
aclase que
se la sentencia Switch........................................... 7-3
Práctica 7-2: Escritura de una
l e ( t o 7-6
l se y uso de matrices............................................................. 8-2
o
Prácticas de lla
Ca 8:eCreación
Prácticas para la lección
n
lección 8.................................................................................................................
8-1
r
Práctica e Creaciónlidec una clase con una matriz unidimensional de tipos primitivos .............. 8-3
c8-1:
a
M 8-2: Creación y trabajo con una ArrayList........................................................................ 8-7
Práctica
a u lPráctica 8-3: Uso de los argumentos de tiempo de ejecución y análisis de la matriz args.......... 8-12
R Prácticas para la lección 9: Uso de construcciones de bucle .................................................... 9-1
Práctica 9-1: Escritura de una clase que utiliza un bucle for ....................................................... 9-3
Práctica 9-2: Escritura de una clase que utiliza un bucle while................................................... 9-4
Práctica de comprobación 9-3: Conversión de un bucle while en un bucle for ........................ 9-6
Práctica 9-4: Uso de bucles for para procesar una ArrayList ...................................................... 9-8
Práctica 9-5: Escritura de una clase que utiliza un bucle for anidado para procesar
una matriz bidimensional................................................................................................................ 9-11
Práctica de comprobación 9-6: Adición de un método de búsqueda al programa ClassMap ....... 9-14
Prácticas para la lección 10: Trabajar con métodos y sobrecarga de métodos ....................... 10-1
Prácticas de la lección 10............................................................................................................... 10-2
Práctica 10-1: Escritura de un método que utiliza argumentos y valores de retorno .................... 10-3
Práctica de comprobación 10-2: Escritura de una clase que contiene un
método sobrecargado..................................................................................................................... 10-6
Conceptos fundamentales de Java SE 7 - Tabla de contenidos

i
COGNOS
Prácticas para la lección 11: Uso de encapsulación y constructores ....................................... 11-1

Práctica 11-1: Implantación de la encapsulación en una clase ..................................................... 11-3
Práctica de comprobación 11-2: Adición de validación a la clase DateThree ............................... 11-7
Práctica 11-3: Creación de constructores para inicializar objetos ................................................. 11-11
Prácticas para la lección 12: Descripción de conceptos orientados a objetos avanzados..... 12-1

Práctica 12-1: Creación y uso de superclases y subclases ........................................................... 12-3
Práctica 12-2: Uso de una interfaz Java ........................................................................................ 12-11
Prácticas para la lección 13: Manejo de errores........................................................................... 13-1
Práctica 13-1: Uso de un bloque try/catch para manejar una excepción................................. 13-3
Práctica 13-2: Captura y devolución de una excepción personalizada ......................................... 13-9
ble
fe r a
an s
n - t r
o
s an
) ha eฺ
c o m uid
ฺ
ail ent G
m
g tud
@
16 is S
l l e
a e th
ฺ c
ra o us
e (
a ll se t
e l o C licen
a rc
M
Raul
Conceptos fundamentales de Java SE 7 - Tabla de contenidos

ii
COGNOS
ble
fe r a
ans
n - t r
no 1:
a
Introducción has
m ) deฺ
i l ฺ c o
G uiCapítulo 1
g ma dent
1 6 @ Stu
c a lle this
( r aฺ use
a lle se to
e l o C licen
a rc
M
Raul
Prácticas para la lección 1: Introducción

Capítulo 1 - Página 1
COGNOS
Prácticas de la lección 1
Visión general de las prácticas

No hay ninguna práctica para la lección 1.
ble
fe r a
ans
n - t r
o
s an
) ha eฺ
c o m uid
ฺ
ail ent G
m
g tud
@
16 is S
l l e
a e th
ฺ c
ra o us
e (
a ll se t
e l o C licen
a rc
M
Raul
Prácticas para la lección 1: Introducción

COGNOS
ble
fe r a
ans
n - t r
no 2:
a
Introducción ha alas
tecnología m ) deฺ
Java
ilฺ nt G c o ui
a
@ gm t2ude
Capítulo
l l e 16 is S
ฺ c a e th
e ( ra o us
a ll se t
e l o C licen
a rc
M
Raul
Prácticas para la lección 2: Introducción a la tecnología Java

COGNOS

En estas prácticas, ejecutará un programa Java, primero mediante el uso de la línea de
comandos de DOS y, a continuación, desde el entorno de desarrollo integrado (IDE) NetBeans.
En las prácticas de este curso, se asume que está instalado el siguiente software:
• JDK 1.7.0
• Especificación de la API de Java (instalada de forma local)
• Especificación de Java SE7 (instalada de forma local)
• NetBeans EE Edition, 7.0.1 (sólo servidor de GlassFish; no se utiliza el servidor
Tomcat.)
ble
fe r a
ans
n - t r
o
s an
) ha eฺ
c o m uid
ฺ
ail ent G
m
g tud
@
16 is S
l l e
a e th
ฺ c
ra o us
e (
a ll se t
e l o C licen
a rc
M
Raul

COGNOS
Práctica 2-1: Ejecución de un programa Java mediante la línea de

comandos
Visión general
En esta práctica, compilará y ejecutará un programa Java en la línea de comandos. Ya se ha
creado un programa de tecnología Java. En algunos casos, puede que primero necesite definir
la variable PATH para la sesión de DOS antes de ejecutar el programa. A continuación, se
incluyen las instrucciones para definir PATH.
Supuestos
El entorno de desarrollo de Java SE 7 está instalado en la computadora.
Tarea: Compilación y ejecución de un programa Java

En esta tarea compilará y ejecutará un programa Java.
1. Compile el programa CalcAverage.java. Los principales pasos para esta tarea aparecen en
ble
la siguiente tabla. Si necesita más ayuda, puede utilizar los pasos detallados que aparecen
fe r a
a continuación de la tabla.
ans
2. n - t r
n o
Paso Descripción a
s o valores
Opciones
h a
) deฺ
a. Abra una ventana de comandos de DOS D:\labs\les02
y vaya a: c o m ui
i l ฺ G
b. Compruebe el contenido de este listado
g ma dCalcAverage.java
e nt
de directorio para buscar:
1 6 @ Stu
c. Defina la variable PATH
a llepara que
t h s
iincluya: D:\Program Files\Java\jdk1.7.0\bin
ฺ c e
d. (
Compile el archivo
e t us
ra deoorigen javac CalcAverage.java
l l
CalcAverage.java.
a nse Para ello, escriba:
o C
c
a. rEn licede Windows, seleccione Start > Run. Introduzca cmd en el campo Open
eell menú Start
M a y haga clic en OK. En el símbolo del sistema, introduzca cd D:\labs\les02. Pulse
u l
Ra Intro.

COGNOS
b. Compruebe el contenido del directorio. Para ello, escriba dir en el símbolo del sistema.
Pulse Intro para ver los resultados que aparecen.
c. Confirme que la variable PATH del sistema apunta a la ubicación de la carpeta correcta
de los ejecutables de Java (el compilador y el ejecutable en tiempo de ejecución).
Escriba PATH en el símbolo del sistema y pulse Intro. Debe aparecer D:\Program
Files\Java\jdk1.7.0\bin en alguna ubicación de la cadena PATH, como se
muestra a continuación.
ble
fe r a
t r a ns
d. Si no aparece, agregue este directorio a la variable PATH del sistema introduciendo
o n - lo
siguiente en el símbolo del sistema. Pulse Intro.
a n
a s
m ) h deฺ
Para confirmar que PATH se ha cambiado correctamente,
i l ฺ ui PATH en el
co Gescriba
siguiente símbolo del sistema. Debe aparecer
g majdk1.7.0\bin
e n t al final de la cadena PATH.
@
e. Compile el archivo .java. Para ello, escriba
6 t
javac
S udCalcAverage.java. Pulse Intro.
Después de algunos segundos,
a l le1el símbolo
t h is del sistema volverá a aparecer.
( r aฺc use
a e to
lleCalcAverage.java.
3. Ejecute el programa
o C e n s Los principales pasos para esta tarea aparecen en
c e l
la siguiente tabla.
l Si
i cnecesita más ayuda, puede utilizar los pasos detallados que aparecen
M ar
a continuación de la tabla.
ul Paso Ventana/Descripción de la página
Ra
Opciones o valores
a. Confirme que el archivo se ha CalcAverage.class
compilado correctamente. Muestre
el contenido del directorio y busque:
b. Ejecute el programa CalcAverage. java CalcAverage
Se le solicitará que introduzca tres
enteros separados por espacios.
Introdúzcalos y pulse Intro para ver
la media de los tres enteros.

COGNOS
a. Busque la clase compilada, CalcAverage.class. Para ello, vuelva a mostrar el

contenido del directorio. Escriba dir y pulse Intro.
b. Llame al ejecutable en tiempo de ejecución java para ejecutar el programa

CalcAverage. No necesita utilizar la extensión .class de la clase. Escriba java
CalcAverage y pulse Intro. El programa le solicitará que introduzca tres enteros.
ble
fe r a
Escriba tres enteros separados por espacios y pulse Intro. ans
n - t r
a no
h a s
m ) deฺ
i l ฺ c o
G ui
g ma dent
De esta forma se compila y ejecuta un programa
1 6 tu sólo una consola de DOS o una
@ JavaScon
ventana de terminal.
c a lle this
( r aฺ use
a lle se to
e l o C licen
a rc
M
Raul

COGNOS
Práctica 2-2: Ejecución de un programa Java mediante NetBeans IDE
Visión general
En esta práctica, compilará y ejecutará un programa Java mediante NetBeans IDE. Además,
explorará algunas funciones de IDE que permiten desarrollar programas de forma más rápida y
sencilla que si utilizara una línea de comandos.
Supuestos
NetBeans 7.0.1 IDE está instalado en la computadora.
Tareas
1. Haga clic dos veces en el icono NetBeans del escritorio de la computadora.
2. Cuando se abra NetBeans, desactive la casilla de control Show On Startup y cierre Start
Page.
ble
fe r a
ans
n - t r
o
s an
) ha eฺ
c o m uid
ฺ
ail ent G
m
g tud
@
16 is S
l l e
a e th
ฺ c
ra o us
e (
a ll se t
e l o C licen
a rc
M
Raul
3. Cree un proyecto de NetBeans que incluya el archivo CalcAverage.java en la carpeta de

origen del proyecto. Los principales pasos para esta tarea aparecen en la siguiente tabla.
Si necesita más ayuda, puede utilizar los pasos detallados que aparecen a continuación de
la tabla.
Paso Ventana/Descripción de la página Opciones o valores

a. Menú principal File > New Project…
b. Asistente New Project: paso Categories: Java
Choose Project Projects: Java Project with Existing Sources
Haga clic en Next.

COGNOS

c. Asistente New Project: paso Name Project Name: Practice02
and Location Desactive la casilla de control Set as Main
Project.
Haga clic en Next.
d. Asistente New Project: paso Source Package Folders: busque y

Existing Sources seleccione D:\labs\les02.
Haga clic en Finish.
e. Ventana de petición de datos Suprima los archivos de clase existentes de
la carpeta del paquete. El nuevo proyecto
aparece en la ventana Projects de NetBeans.
a. Seleccione File > New Project en el menú principal de NetBeans. Se abre el asistente
New Project.
b. En el paso Choose Project del asistente (que aparece en la columna de la izquierda),
ble
seleccione “Java” en la columna Categories. Seleccione “Java Project with Existing
fe r a
Sources” en la columna Projects. Haga clic en Next.
ans
n - t r
o
s an
) ha eฺ
c o m uid
ฺ
ail ent G
m
g tud
@
16 is S
l l e
a e th
ฺ c
ra o us
e (
a ll se t
e l o C licen
a rc
M
Raul

COGNOS
c. En el paso Name and Location del asistente, introduzca “Practice02” como nombre del
proyecto y desactive la casilla de control Set as Main Project. Haga clic en Next.
ble
fe r a
ans
n - t r
a no
h a s
m ) deฺ
d. En el paso Existing Sources del asistente, agregue
l ฺ c o u i
D:\labs\les02 al panel Source
i G
Package Folders. Para ello, haga clic en AddaFolder y texamine el directorio que desee.
Haga clic en Finish.
@ gm tuden
l l e 16 is S
ฺ c a e th
e ( ra o us
a ll se t
e l o C licen
a rc
ul M
Ra

COGNOS
e. Ahora aparecerá el mensaje “The specified package folders contain compiled class files”.
Haga clic en Delete para suprimir el archivo CalcAverage.class que se ha generado en la
práctica anterior al compilar el archivo CalcAverage.java en la consola de DOS.
NetBeans generará un nuevo archivo de clase en esta práctica.
El contenido del proyecto aparece ahora en la ventana Projects en el panel de la

ble
parte superior izquierda de NetBeans. Haga clic en el separador Projects si necesita
fe r a
ver la ventana Projects. Aquí verá el nombre del proyecto y el nodo raíz. Amplíe los
ans
nodos que aparecen debajo para buscar CalcAverage.java.
n - t r
a no
h a s
m ) deฺ
i l ฺ c o
G ui
g ma dent
1 6 @ Stu
c a lle this
( r aฺ use
alle nsede teste o
4. Modifique lasC propiedades proyecto para definir la propiedad Source/Binary Format
en JDKe7.lo l ic e
Esto permitirá utilizar cualquier nueva función de lenguaje de Java SE 7 sin
r c
a un mensaje de error de NetBeans. La siguiente tabla proporciona los principales
obtener
u l M
pasos. Si necesita más detalles, siga los pasos que aparecen a continuación de la tabla.
Ra Paso Ventana/Descripción de la página Opciones o valores
a. Menú principal File > Project Properties (Practice02)
b. Ventana Project Properties | Campo Source/Binary Format = JDK 7
Categoría Sources
c. Ventana Project Properties | Confirme que Java 7 aparece como la

Categoría Libraries plataforma Java.
d. Ventana Project Properties Haga clic en OK.
a. Seleccione File > Project Properties (Practice02) en el menú principal. (También puede
hacer clic con el botón derecho en el nodo de proyecto Practice02 en la ventana
Projects y seleccionar Properties). Se abre la ventana Project Properties.

COGNOS
b. Seleccione Sources en la columna Categories. Defina el campo Source/Binary Format

en “JDK 7”.
ble
fe r a
ans
n - t r
o
s an
) ha eฺ
c o m uid
ฺ
ail ent G
m
g tud
@
16 is S
l l e
a e th
ฺ c
ra o us
e (
a ll se t
e l o C licen
a rc
M
Raul Nota: NetBeans permite especificar la versión de la plataforma Java más antigua con la
que debe ser compatible el código generado. Por ejemplo, si no hubiera cambiado este
valor a JDK 7, aparecerían mensajes de error al utilizar cualquiera de los cambios en el
lenguaje principales incluidos en JDK 7. NetBeans le advertiría de que el código puede ser
incompatible con una versión anterior.
Recuerde que cuando compiló y ejecutó este archivo java en el símbolo del sistema, tuvo que
definir manualmente PATH para que apuntara a la instalación de JDK 7. Al utilizar un IDE,
automáticamente define un entorno de tiempo de ejecución de JDK por defecto para cada
proyecto de NetBeans.

COGNOS
c. Confirme que el valor de Java Platform para el proyecto Practice02 es JDK 7. Seleccione
el nodo Libraries en la columna Categories. A la derecha, JDK 7 aparece como la
plataforma Java para este proyecto. Observe que podría haber seleccionado una
plataforma (versión de JDK) diferente (siempre que se hayan instalado correctamente
otras plataformas en esta máquina).
ble
fe r a
ans
n - t r
a no
h a s
m ) deฺ
l ฺ c o u i
i G
del proyecto. g ma denent el paso b en las propiedades
d. Haga clic en OK para guardar los cambios realizados
1 6 @ S tu para NetBeans, seleccione

5. Para determinar o cambiar la plataforma
Tools > Java Platforms en c ela
Java
lle principal.
menú t h isEsta ventana muestra todas las versiones
por defecto
r
de JDK que se han instalado
( aฺ correctamente
u se en esta máquina. En este caso, sólo se ha
JDKto
defecto en laC alledecir,
instalado JDK 7 (es
columna n s e
Platforms.
1.7), por lo que está marcado como la plataforma por
En la parte derecha, aparece la ubicación del directorio
l o e
licJDK 7. Cierre la ventana Java Platform Manager cuando termine de
a rce
de la instalación
examinarla.
de
ul M
Ra

COGNOS
ble
fe r a
ans
n - t r
a no
h a s
m ) deฺ
6. Para ver y editar el código del archivo CalcAverage.java,i l ฺ c hagaGclicuidos veces en la ventana
o
Projects. Se abre en el panel Editor. Observe m a entde color que utiliza el editor.
la codificación
(Por ejemplo, las palabras clave están en @ g ud más
azul, los literales
t de cadena están en rojo). Esto
e 1 6
facilita el trabajo con el código y su lectura. Puede
s S obtener información sobre el uso
l
a etl
del editor en las siguientes prácticas. h i
ฺ c
e
a
7. En la ventana Projects,(rhaga clic con
t o usel botón derecho en CalcAverage.java y seleccione
Compile File. all
o C e n se
r c el lic
a
ul M
Ra

COGNOS
8. Suponiendo que no tenga errores de compilación, puede hacer clic en la ventana Files y
ampliar Practice02 > build > classes para buscar el archivo .class.
ble
fe r a
ans
n - t r
no
Nota: si ha realizado algún cambio en el archivo java, el botón Save estará activado. Por
a
defecto, la compilación se realiza automáticamente al guardar.
h a s
9. m
Vuelva a hacer clic en la ventana Projects. Haga clic con el
o
) derecho
botón
i d eฺ en el archivo y
seleccione Run File. La salida del programa aparece u Output. Introduzca los
ilฺcen lanventana
Gsalida
delamensaje
tres valores enteros en la línea situada debajom t
de y pulse Intro para ver
g d e
el resultado.
1 6 @ Stu
c a lle this
( r aฺ use
a lle se to
e l o C licen
a rc
ul M
R a
Ahora sabe cómo ejecutar un programa Java sencillo mediante el uso del símbolo del
sistema de DOS y NetBeans IDE.
10. Cierre el proyecto Practice02 en NetBeans. En la ventana Projects, haga clic con el botón
derecho en Practice02 y seleccione Close en el menú contextual.

COGNOS
ble
fe r a
ans
n - t r
o
s an
) ha eฺ
c o m uid
ฺ
ail ent G
m
g tud
@
16 is S
l l e
a e th
ฺ c
ra o us
e (
a ll se t
e l o C licen
a rc
M
Raul

COGNOS
ble
fe r a
ans
n - t r
no 3:
a
Consideraciones
h a s sobre
los objetosm ) deฺ
ilฺ nt G c o ui
a
@ gm t3ude
Capítulo
l l e 16 is S
ฺ c a e th
e ( ra o us
a ll se t
e l o C licen
a rc
M
Raul
Prácticas para la lección 3: Consideraciones sobre los objetos

COGNOS

En estas prácticas, primero analizará un problema mediante un análisis orientado a objetos y, a
continuación, diseñará una posible solución mediante el uso de una notación de tipo UML. Las
soluciones de estas prácticas se encuentran en D:\labs\soln\les03.
ble
fe r a
ans
n - t r
o
s an
) ha eฺ
c o m uid
ฺ
ail ent G
m
g tud
@
16 is S
l l e
a e th
ฺ c
ra o us
e (
a ll se t
e l o C licen
a rc
M
Raul

COGNOS
Práctica 3-1: Análisis de un problema mediante el análisis orientado a

objetos
Visión general
En esta práctica, analizará un caso práctico y utilizará el análisis orientado a objetos para
mostrar los objetos, los atributos y las operaciones del caso práctico.
Preparación
Lea el siguiente caso práctico y, a continuación, modele el sistema mediante la selección de los
objetos con sus atributos y operaciones.
Caso práctico
Una liga de fútbol necesita un sistema para realizar un seguimiento de los equipos y jugadores.
En cualquier momento, los administradores desean poder consultar una lista de los partidos
jugados y sus resultados, una lista de los equipos clasificados por partidos ganados y una lista
ble
de jugadores de cada equipo clasificados por goles marcados.
fe r a
ans
Tareas
n - t r
no
Su tarea es crear un análisis orientado a objetos para una aplicación de tecnología Java que
a
h a s
realice un seguimiento de las puntuaciones. El programa debe realizar un seguimiento de:
• ) deฺ
La lista de jugadores de cada equipo clasificados por goles marcados
m
• La lista de partidos jugados con sus resultados
i l ฺ c o
G ui
• ma dent
La lista de equipos de la liga clasificados por partidos ganados
g
1 6 @ Stu
Indicación: puede pensar en los objetos
a lle ejemplo,is
comohsustantivos,
t en los atributos como adjetivos y
en las operaciones como verbos.
r c
aฺ eseusustantivo
Como
se "jugador" es un sustantivo, el nombre del
jugador es un adjetivo que (describe o y "sumar un gol" es un verbo.
l l e t
temporadas. lo
Ca capaz
La aplicación debe ser
e n sdeegenerar estadísticas para los equipos, los jugadores y las
lic
rceel editor de
1. aAbra texto seleccionando Start > Programs > Accessories > Notepad.
u l M
Ra 2. Guarde el archivo como D:\labs\les03\oo-analysis.txt.

COGNOS
3. Para empezar, clasifique las clases de nivel superior incluidas en este problema. Puede
mostrarlas en el editor de texto y utilizar las líneas discontinuas para separar los
objetos, los atributos y las operaciones, como se muestra en la captura de pantalla.
ble
fe r a
ans
n - t r
a no
4. (Opcional) Puede utilizar la herramienta UMLet si lo desea. Haga
h a sclic dos veces en el
icono UMLet o
en el escritorio de Windows para iniciarm i d eฺ
)el programa.
Solución a ilฺc nt Gu
g m de
Player Team Game
1 6 @ S tuLeague Goal
id id l e i s
al idteameonethscore *Team(s) id
name name r a ฺ c s *Game(s) *Team
( u
a lle se to team
number *Player(s) two score *Player
*Team
l o C en *Goal time
rce Get lrankedic

a
ul M
player Get results Get game results
Get ranked teams
Ra El asterisco (*) indica atributos que también son objetos.

COGNOS
Práctica 3-2: Diseño de una solución de programación
Visión general
En esta práctica, continuará con la práctica 3-1 con el uso de la notación de tipo UML para
representar las clases que ha identificado.
Supuestos
Ha completado la identificación de objetos, atributos y operaciones de la práctica 3-1.
Tareas
Su tarea es crear un diseño para cada una de las clases del sistema anterior para realizar un
seguimiento de las puntuaciones de la liga de fútbol. Recuerde:
• Utilizar el estilo camelCase para asignar un nombre a las clases, las variables de
atributo y los métodos.
• Identificar un rango válido de valores para cada atributo (donde se conozca el rango).
ble
• Utilizar corchetes para indicar un atributo que represente una recopilación de valores
fe r a
(players[ ] ).
ans
• Utilizar paréntesis para identificar los métodos. n - t r
1. Abra D:\labs\les03\oo-analysis.txt y guárdelo como a no
D:\labs\les03\oo-design.txt. h a s
m ) deฺ
i l ฺ o
2. Utilice las clases, variables y operaciones que ha identificado ueni lacaptura
c La siguiente
G
práctica anterior y
m a
desarrolle nombres de método para las operaciones.
n t de pantalla es
un ejemplo.
@ g tude
l l e 16 is S
ฺ c a e th
e ( ra o us
a ll se t
e l o C licen
a rc
ul M
R a

COGNOS
3. (Opcional) Puede utilizar la herramienta UMLet si lo desea. Haga clic dos veces en el
icono UMLet en el escritorio de Windows para iniciar el programa.

ble
fe r a
ans
n - t r
a no
Solución
h a s
m ) deฺ
Player Team Game i l ฺ c LeagueGui
o Goal
m a ent
id id id
@ g tud teams[ ] id
name name
e 6
team one S
1team twoisscore
score games[ ] team
number players[ ] l l
a goals[ h
t] player
team
r a ฺ c s e time
( u
a lle se to
e l o CgetRankedPlayers()
l i c en getResults() getGameResults()
a rc getRankedTeams()
ul MNota: aunque no aparece en la solución, debe agregar/eliminar métodos para cada atributo
Ra de recopilación y métodos get/set para el resto de atributos. En este punto del curso no
hemos analizado estos métodos.
Las soluciones pueden tener un aspecto diferente al de la solución sugerida. El objetivo de esta
lección es ayudarle a seguir pensando en cuanto a objetos, atributos y operaciones. Durante el
curso, tendrá otra oportunidad para practicar el modelado de una solución de programación.

COGNOS
ble
fe r a
ans
n - t r
no 4:
a
Introducción h s
alalenguaje Java
m ) deฺ
i l ฺ c o
G uiCapítulo 4
g ma dent
1 6 @ Stu
c a lle this
( r aฺ use
a lle se to
e l o C licen
a rc
M
Raul
Prácticas para la lección 4: Introducción al lenguaje Java

COGNOS

En estas prácticas, examinará y modificará los programas Java existentes y los ejecutará para
probar el programa. Las soluciones de estas prácticas se encuentran en
D:\labs\soln\les04.
ble
fe r a
ans
n - t r
o
s an
) ha eฺ
c o m uid
ฺ
ail ent G
m
g tud
@
16 is S
l l e
a e th
ฺ c
ra o us
e (
a ll se t
e l o C licen
a rc
M
Raul

COGNOS
Práctica 4-1: Visualización y adición de código en un programa Java

existente
Visión general
En esta práctica, se le proporciona un programa Java terminado. Lo abrirá, examinará las
líneas de código, lo modificará, lo compilará y, por último, lo probará mediante su ejecución.
Supuestos
• Quotation.java y QuotationTest.java aparecen en la carpeta para esta práctica:
D:\labs\les04
Tareas
1. Cree un nuevo proyecto a partir de un origen Java existente, como en la práctica 2-2. Los
principales pasos aparecen en la siguiente tabla. Si necesita más información, consulte la
práctica 2-2, pasos 3 y 4.
ble
Paso Ventana/Descripción de la página Opciones o valores fe r a
ans
a. Menú File > New Project
n - t r
b. Asistente New Project | Paso no
Categories: Java
a
Choose Project
h a s
Projects: Java Project with Existing Sources
m ) deฺNext
l ฺ c o u i
c. Asistente New Java Project with i
aProject Name: G
t Practice04
Existing Sources | Paso Name andgm Nextden
Location
1 6 @ Stu
d. Asistente New Java a
c lle withthis Add Folder: D:\labs\les04
Project
r
Existing Sources
( aฺ| Paso uExisting
se Finish
Sourceslle
a nse t o
o C
el lice
e. Ventana Project Properties | Source/Binary Format: JDK 7
a rc Categoría Source OK
ul M
Nota: la ventana Projects se debe parecer a la que se muestra a continuación cuando se
R a amplíe el nodo <default package>:
2. Haga clic dos veces en el archivo Quotation.java en la ventana Projects para abrirlo
para su edición.

COGNOS
3. Identifique el campo y el método incluidos en la clase con la siguiente tabla:
Miembro Variable o nombre

Variable de campo:
Nombre del método:
Solución: Variable de campo: quote; nombre del método: display.

4. En el método display, escriba el código para mostrar el campo quote. Indicación: utilice
el método System.out.println mostrado en la Guía del alumno para esta lección.
Asegúrese de terminar la línea de código con un punto y coma.
Nota: conforme escriba el código, observará que la función de ayuda de código de
NetBeans proporciona comentarios y ayuda cada vez que deja de escribir. Por ejemplo, si
deja de escribir en algún punto del código, ya que éste no se compilará correctamente,
aparecerá un signo de exclamación de color rojo en el margen izquierdo. Si deja de escribir
después de introducir el punto (“.”) que sigue a System o out, le proporcionará ayuda ble
sensible al contexto en una lista de métodos y campos que serían válidos para una clase fe r a
concreta a la izquierda del punto. Puede seleccionar un valor de la lista en lugar de ans
escribirlo. n - t r
o
s an
Solución: ) ha eฺ
c o m uid
System.out.println(quote); ฺ
ail ent G
m
g tud
@
16 is S
l l e
a e th
ฺ c
ra o us
e (
a ll se t
e l o C licen
a rc
ul M
Ra
5. Haga clic en el botón Save para guardar y compilar Quotation.java.

6. Abra el archivo QuotationTest.java en el editor y examine el método main. Crea una
instancia de la clase Quotation y, a continuación, llama al método display.

COGNOS
7. Ejecute la clase QuotationTest. Para ello, haga clic con el botón derecho en
QuotationTest.java en la ventana Projects y seleccione Run File. La salida del método
display aparece en la ventana Output.
Nota: ha podido omitir el paso Compile porque al seleccionar Run File, NetBeans compila
primero la clase seleccionada para su ejecución y, además, cualquier clase a la que se
haga referencia con esa clase (Quotation.java).
8. Edite el archivo Quotation.java ahora para cambiar el valor por defecto del campo
quote.
9. Vuelva a ejecutar QuotationTest para verificar la salida.
10. En el panel Editor, cierre Quotation.java y QuotationTest.java. ble
fe r a
ans
n - t r
o
s an
) ha eฺ
c o m uid
ฺ
ail ent G
m
g tud
@
16 is S
l l e
a e th
ฺ c
ra o us
e (
a ll se t
e l o C licen
a rc
M
Raul

COGNOS
Práctica 4-2: Creación y compilación de una clase Java
Visión general
En esta práctica, creará una clase Java y la compilará. Además, creará otra clase Java para
probar la clase anterior.
Supuestos
Ninguno.
Tareas
1. Cree una nueva clase Java en el proyecto Practice04 con el asistente de NetBeans. Los
principales pasos para esta tarea aparecen en la siguiente tabla. Si necesita más ayuda,
puede utilizar los pasos detallados que aparecen a continuación de la tabla.

ble
a. Menú File > New File
fe r a
b. Ventana New File | Paso Choose Categories: Java
ans
File Type File Types: Java Class n - t r
a no
Next
c. Ventana New Java Class | Paso Class Name: h a s
m ) deฺ
Shirt
Name and Location Finish
i l ฺ c o
G ui
maFile.dent
a. En el menú principal, seleccione File > New
g
b. Se abre el asistente New File y estará
1 6 tu 1 “Choose File Type”. Seleccione Java
@en elSpaso
a l le this
en la columna Categories. Seleccione Java Class en la columna File Types. Haga clic en
Next.
( r aฺc use
a lle se to
e l o C licen
a rc
ul M
Ra

COGNOS
ble
fe r a
ans
n - t r
a no
h a s
“Shirt” para Class Name. Haga clic en Finish. ฺco
m) and
c. En la ventana New Java Class, estará en el paso 2 “Name
i eฺ Introduzca
Location”.
d
a il nt Gu
@ gm tude
l l e 16 is S
ฺ c a e th
e ( ra o us
a ll se t
e l o C licen
a rc
ul M
Ra

COGNOS
ble
fe r a
ans
n - t r
a no
h a s
m ) deฺ
i l ฺ c o
G ui
g ma dent
1 6 @ Stu
El archivo de origen Java a le
del la nuevath
is
clase ahora aparece en el editor y está
r
preparado para incluir
c
ฺ losusdetalles.
atodos e
( toJava para la clase Shirt mostrada en esta lección de la
a lle del scódigo
2. Introduzca la sintaxis e
o C licen
Guía del lalumno.
e
a rc puede encontrar el código de la solución para la clase Shirt en
Solución:
ul MD:\labs\soln\les04.
Ra 3. Haga clic en el botón Save para guardar y compilar la clase Shirt. Los iconos de color rojo
del margen izquierdo desaparecerán después de guardar si no existe ningún error de
compilación. Si es necesario, corrija los errores que aparecen en la ventana Output y
vuelva a guardar.
Nota: el panel Navigator (esquina inferior izquierda de NetBeans) de la clase Shirt ahora
muestra la vista Members de la clase. Observe la codificación de color que distingue entre
campos y métodos. Ambos se consideran "miembros" de la clase.

COGNOS
4. Siga las instrucciones del paso 1 para crear una nueva clase. Ésta será una clase Test, por
lo que necesitará un método main. Para organizar el cambio, la siguiente tabla muestra las
sustituciones en las instrucciones del paso 1 que debe realizar en el asistente New Class.
Para obtener más información, consulte las capturas de pantalla de la siguiente tabla.

ble
a. Ventana New File | Paso Choose File File Types: Java Main Class
fe r a
Type
ans
b. Ventana New File | Paso Name and Nombre: ShirtTest
n - t r
Location
a no
a. En el paso Choose File Type, seleccione Java Main Class en
h a slugar de Java Class.
m ) deฺ
i l ฺ c o
G ui
g ma dent
1 6 @ Stu
c a lle this
( r aฺ use
a lle se to
e l o C licen
a rc
M
Raul

COGNOS
b. En el paso Name and Location, introduzca ShirtTest como nombre.

5. Sustituya el comentario To Do: del método main por las dos líneas de código que
aparecen en el método main de la clase ShirtTest mostrada en esta lección de la Guía del
alumno.
ble
Solución: puede encontrar el código de la solución para la clase ShirtTest en
fe r a
D:\labs\soln\les04.
ans
n - t r
a no
h a s
m ) deฺ
i l ฺ c o
G ui
g ma dent
1 6 @ Stu
c a lle this
( r aฺ use
6. Guarde y compilea lellecódigo e to clic en Save.
haciendo
s
C en haciendo clic con el botón derecho en ShirtTest.java en la
7. Ejecute lalo ic la salida del método displayInformation en la ventana
clase ShirtTest
e
rc Projects.lBusque
a
ventana
ul MOutput.
Ra

COGNOS
8. Busque los archivos de clase generados por NetBeans al ejecutar el programa. Haga clic
en el separador Files para abrir la ventana Files y busque Shirt.class y ShirtTest.class
como se muestra a continuación.
ble
fe r a
9.
t r a ns
Abra (o céntrese en) el archivo Shirt.java. Modifique los valores de ShirtID y price.
o n - en la
10. Vuelva a ejecutar la clase ShirtTest. Verifique que los valores modificados aparecen
ventana Output.
s an
) ha eฺ
c o m uid
ฺ
ail ent G
m
g tud
@
16 is S
l l e
a e th
ฺ c
ra o us
e (
a ll se t
e l o C licen
a rc
ul M
Ra

COGNOS
Práctica 4-3: Exploración del depurador
Visión general
Prácticamente todos los IDE de Java proporcionan un depurador. Tienden a ofrecer las mismas
funciones principales y a trabajar de forma muy similar. En esta práctica, depurará el programa
ShirtTest mediante el depurador de NetBeans. Definirá puntos de ruptura, examinará valores
de campo y los modificará conforme avance por cada línea del código.
Supuestos
Ninguno.
Tareas
1. Defina un punto de ruptura en la clase ShirtTest. Haga clic en el margen izquierdo del
editor, junto a la siguiente línea de código:
myShirt = new Shirt();
ble
Un cuadrado de color rosa aparece en el margen e indica un punto de ruptura.
fe r a
ans
n - t r
a no
h a s
m ) deฺ
i l
2. Ejecute el depurador. Para ello, haga clic con el botón ฺ cderechoGenueli archivo ShirtTest de la
o
ventana Projects y seleccione Debug File. ma n t
g e
udde ruptura. En el panel Editor, ahora
6
3. El depurador inicia el programa y se para @ t
en el punto
S
1 una flecha
verá un icono diferente que apunta
a l lecon t h is verde a una línea de código.
r c
aฺ use
(
a lle se to
e l o C licen
a rc
ul M
Ra Esta línea de código aún no se ha ejecutado.
4. Se han producido otros cambios en la ventana de NetBeans.
• Aparece una nueva barra de herramientas que contiene los botones que se utilizan al
realizar la depuración.
− Mueva el cursor sobre los botones de la barra de herramientas para leer un

consejo que explica lo que hace cada botón. Los botones se describen a
continuación.
− El primer botón, Finish Debugger Session, para la sesión de depuración.
− El segundo botón, Pause, pausa la ejecución del depurador.
− El tercer botón, Continue, continúa con la ejecución, ya sea hasta el siguiente
punto de ruptura o hasta el final del programa.

COGNOS
− El cuarto botón, Step Over, mueve el programa a la siguiente línea de código

de la clase actual (en este caso, la clase ShirtTest).
− El quinto botón, Step Over Expression, permite desplazarse en una
expresión completa a la siguiente línea de código de la clase actual.
− El sexto botón, Step Into, permite desplazarse a otra clase a la que se hace
referencia en esta línea de código actual.
− El séptimo botón, Step Out, permite salir de una clase a la que se ha

accedido.
− El último botón, Run to Cursor, desplaza la ejecución a la línea de código en
la que aparece el cursor.
• El panel de la parte inferior de la ventana cambia para mostrar la salida de depuración
y las variables, además de otra información útil durante una sesión de depuración.
ble
fe r a
ans
n - t r
a no
h a sobjeto para
− En el panel Variables, verá todas las variables que están visibles la clase
actual. Recuerde que la ejecución se para antes de que
m ) el
e ฺ de la clase Shirt
i l ฺ G uiden este panel.

co myShirt
se instancie. Por lo tanto, no puede ver la variable
m a ent
5. Haga clic en el botón Step Over para pasar
@ g ud línea de código.
a la siguiente
t
6
e1código S
6. La flecha ahora apunta a la líneallde
a t h is llama al método displayInformation
que
en el objeto myShirt. En la
r a c
ฺ use verá la variable myShirt. Amplíela para ver
ventana Values,
todos los campos de ( toShirt.
a lleestesobjeto
e
e l o C licen
a rc
ul M
Ra
En este punto, el método displayInformation aún no se ha ejecutado. Si lo desea,
puede cambiar los valores de los campos del objeto en este momento con la ventana
Variables. Sin embargo, puede desplazarse al objeto myShirt y cambiar los valores
durante la ejecución del método displayInformation.
7. Haga clic en el botón Step Into para acceder al método displayInformation.

COGNOS
8. El icono de flecha apunta a la primera línea de código ejecutable de

displayInformation de la clase Shirt. En la ventana Variables, amplíe this para ver
los campos de este objeto.
ble
fe r a
ans
n - t r
a no
h a s
m ) deฺ
9. En la columna Value, haga clic dos veces en el valor deocada
ilฺc npara
cambiar el valor. Asegúrese de que utiliza el valoracorrecto G uitipoy de
campo edítelo para
m t el dato esperado y
@ t u deindicadas.
delimite cada tipo de dato de caracteres conglas comillas Después de editar el
e 1 6 sS
campo final, haga clic en el botón de separador para que se acepte el texto introducido en
el buffer de edición. l
al e th i
ฺ c
ra o us
e (
a ll se t
e l o C licen
a rc
ul M
Ra
10. Haga clic en el botón Step Out para volver a la siguiente línea de código de la clase
ShirtTest. El método displayInformation se habrá terminado.

COGNOS
11. Observe que las variables de campo de objeto myShirt reflejan los cambios realizados en
el método.
12. Haga clic en el botón Continue para terminar la ejecución y finalizar la sesión de
depuración.
13. Haga clic en el separador Output para ver la salida.
bl e
Ahora ha visto algunas de las funciones utilizadas con más frecuencia de un depurador de IDEera
ys
típico. Puede que desee utilizar el depurador en las prácticas restantes para diagnosticar n
f
corregir los problemas que pueda experimentar en sus programas. -tr a
o n
14. Cierre el proyecto Practice04 en NetBeans. En la ventana Projects, haga
derecho en Practice04 y seleccione Close en el menú contextual.as
a nclic con el botón
m ) h deฺ
i l ฺ co Gui
g ma dent
1 6 @ Stu
c a lle this
( r aฺ use
a lle se to
e l o C licen
a rc
M
Raul

COGNOS
ble
fe r a
ans
n - t r
o
s an
) ha eฺ
c o m uid
ฺ
ail ent G
m
g tud
@
16 is S
l l e
a e th
ฺ c
ra o us
e (
a ll se t
e l o C licen
a rc
M
Raul

COGNOS
ble
fe r a
ans
n - t r
no 5:
a
a s
Declaración, inicialización
h y
) ฺ
uso de c om uide
variables
a ilฺ nt G
@ gm t5ude
Capítulo
l l e 16 is S
ฺ c a e th
e ( ra o us
a ll se t
e l o C licen
a rc
M
Raul
Prácticas para la lección 5: Declaración, inicialización y uso de variables

COGNOS

En estas prácticas, creará varias clases Java que declaran, inicializan y manipulan variables de
campo. Las soluciones de estas prácticas se encuentran en D:\labs\soln\les05.
ble
fe r a
ans
n - t r
o
s an
) ha eฺ
c o m uid
ฺ
ail ent G
m
g tud
@
16 is S
l l e
a e th
ฺ c
ra o us
e (
a ll se t
e l o C licen
a rc
M
Raul

COGNOS
Práctica 5-1: Declaración de variables de campo en una clase
Visión general
En esta práctica, creará una clase que contiene varios campos. Declarará los campos, los
inicializará y probará la clase mediante la ejecución del programa CustomerTest.
Supuestos
En esta práctica, se asume que el archivo de origen Java CustomerTest aparece en la carpeta
de prácticas de esta lección: D:\labs\les05
Tareas
1. Cierre cualquier proyecto que esté abierto en NetBeans. En la ventana Projects, haga clic
con el botón derecho en el nombre del proyecto y seleccione Close en el menú contextual.
2. Cree un nuevo proyecto a partir de un origen Java existente mediante el uso de los valores
de la siguiente tabla cuando complete el asistente New Project.
ble
fe r a
ans
a. Paso Choose Project Categories: Java n - t r
a no
Projects: Java Project with Existing Sources
b. Paso Name and Location a s
Project Name:hPractice05
c. Paso Existing Sources o i eฺ
m) D:\labs\les05
d
Gu Source/Binary Format
Addc Folder:
a ilฺ lanpropiedad
t
d. Ventana Project Properties
@ gm entuJDK
Defina
de7
e
Nota: si necesita un recordatoriollmás
16detallado
i s S
4.ฺ c a t h de cómo crear un nuevo proyecto, consulte
la práctica 2-2, pasos 3 ya
( r u se
lle Projects
Solución: la ventana
a e o mostrar cuatro archivos de origen Java bajo el nodo
tdebería
o C licen
<default package>. s
e l
a rc
ul M
Ra

COGNOS
3. Cree una nueva clase Java. La siguiente tabla proporciona los principales pasos. Si
necesita más ayuda, consulte la práctica 4-2, paso 1.

a. Menú File > New File
b. Ventana New File | Paso Choose Categories: Java
File Type File Types: Java Class

Next
c. Ventana New Java Class | Paso Class Name: Customer
Name and Location Finish
ble
fe r a
ans
n - t r
a no
h a s
m ) deฺ
i l ฺ c o
G ui
m a ent declare e inicialice los
4. Con Customer.java abierto para la edición en
campos descritos en la siguiente tabla. @
Si
g el panel Editor,
ud ayuda, en la siguiente tabla se
necesitatmás
6 S
a l le1 this
proporcionan pasos más detallados.
Nombre de campo (raฺ

c Tiposede dato
e t o u Valor por defecto
customerID all int e <opción seleccionada>
o C e n s
statusel lic char <opción seleccionada>
a r c ‘N’ para nuevo, ‘O’ para antiguo
ul M
Ra totalPurchases double 0.0
a. La sintaxis para declarar e inicializar variables es la siguiente:
modifier type variable = <value>;
b. Suponga que todos los campos son public.
c. Incluya un comentario al final de cada línea que describa el campo.
Solución: se muestra una posible solución para la declaración e inicialización de
customerID. El resto son similares.
public int customerID = 0; // Default ID for a customer
5. Agregue un método en la clase Customer denominado displayCustomerInfo. Este
método utiliza el método System.out.println para imprimir cada campo en la pantalla
con una etiqueta correspondiente (como, por ejemplo, “Las compras son: “).

COGNOS
Solución:
public void displayCustomerInfo () {
System.out.println(“Customer ID: “ + customerID);
// continue in a similar fashion for all other fields
}
6. Haga clic en Save para compilar la clase.
Nota: observará que el indicador de error de color rojo situado junto a la clase
CustomerTest en la ventana Projects desaparecerá después de guardar la clase Customer.
El motivo es que la clase CustomerTest hace referencia al método
displayCustomerInfo, que no existía antes de guardar el archivo. NetBeans ha
reconocido un error de compilación potencial en la clase CustomerTest debido a que falta
un método.
7. Ejecute la clase CustomerTest para probar el código. Si aparece una advertencia que
indica que existen errores de compilación en el proyecto, haga clic en Run Anyway. ble
fe r a
ans
n - t r
a no
h a s
m ) deฺ
i l ฺ c o
G ui
g ma dent
1 6 @ Stu
c a lle this
( r ay ฺlas prácticas
u se de este curso necesitan una clase de prueba. En
Nota: todos los ejemplos
a lcasos, to
le seeproporciona
la mayoría de los
o C e n s la clase de prueba. Sin embargo, en algunos
r c el
casos, puede
lic
crear la clase.
a
8. Compruebe la salida para asegurarse de que contiene los valores que ha asignado.
ul M
Ra

COGNOS
Práctica 5-2: Uso de operadores y conversión de tipo para evitar la

pérdida de datos
Visión general
En esta práctica, utilizará operadores y realizará conversiones de tipo. Este ejercicio tiene tres
secciones. En cada sección creará una clase Java, la compilará y la probará.
Supuestos
Los siguientes archivos de origen Java aparecen en la carpeta de prácticas de esta lección:
D:\labs\les05
• PersonTest.java
• OrderTest.java
• TemperatureTest.java
Cálculo de la edad con operadores ble

En esta tarea, utilizará operadores para calcular la edad en días, minutos, segundos y fe r a
milisegundos.
t r a ns
o n - Person.
1. Seleccione File > New File en el menú para crear una nueva clase Java denominada
s an
) ha eฺ
c o m uid
ฺ
ail ent G
m
g tud
@
16 is S
l l e
a e th
ฺ c
ra o us
e (
a ll se t
e l o C licen
a rc
ul M
Ra
2. Con el editor, agregue los siguientes campos para almacenar la edad en años, días,
minutos, segundos y milisegundos. Proporcione nombres significativos para todos los
campos. La siguiente tabla proporciona información más detallada:
Unidad de Tipo de dato Información adicional

tiempo
Años int Inicializar en 1
Días int No inicializar
Minutos long No inicializar
Segundos long No inicializar
Milisegundos long No inicializar

COGNOS
Indicación: puede declarar varias variables del mismo tipo en una línea. Para ello, separe
las variables con una coma. Asegúrese de terminar la línea con un punto y coma, como lo
haría en otra línea de código.
3. Cree un nuevo método público en esta clase denominado calculateAge.
a. El método debe calcular la edad en días, minutos, segundos y milisegundos mediante la

asignación del valor al campo correspondiente. La siguiente tabla proporciona los
cálculos:
Unidad de tiempo Calculado por:
Días Año * 365
Segundos Días * 24 * 60 * 60
Minutos Segundos / 60
Milisegundos Segundos * 1000
ble
fe r a
b. Imprima todas las edades en varias unidades, cada una en una línea independiente con
ans
un mensaje adecuado. Por ejemplo, “You are 3156000 seconds old”.
n - t r
Solución:
a no
public void calculateAge () {
h a s
ageDays = ageYears * 365; m ) deฺ
i l ฺ c60; Gui
o
ageSeconds = ageDays * 24 * 60
m a ent
*
@
ageMinutes = ageSeconds / 60; g t ud
1 6 S
ageMilliseconds =le
a l is * 1000;
ageSeconds
t h
( r aฺc use
a lle se to ("You are " + ageDays + " days old.");
System.out.println
l C en
oSystem.out.println("You
r c e l i c are " + ageMinutes +
ul Ma " minutes old.");
R a System.out.println("You are " + ageSeconds +

" seconds old.");
System.out.println("You are " + ageMilliseconds +
" milliseconds old.");
}
4. Guarde para compilar la clase y, a continuación, ejecute el archivo PersonTest.java.
5. Realice varias pruebas. Para ello, defina el valor de la edad como 1, 24 y 80 en la clase
Person.
Solución:
Para un año, los resultados serían: You are 365 days old. You are 31536000 seconds old.
You are 525600 minutes old. You are 31536000000 milliseconds old.

COGNOS
Uso de la conversión para evitar la pérdida de datos

En esta sección utilizará la conversión para asegurarse de que no se produce una pérdida de
datos en sus programas.
6. Cree una nueva clase Java denominada Order.
7. Agregue tres campos a la clase Order como se indica a continuación:
Nombre de campo Tipo de dato Valor inicializado

orderValue long 0L (cero L)
itemQuantity int 10_000_000
itemPrice int 555_500
Nota: los caracteres de subrayado utilizados para inicializar los valores int mejoran la
legibilidad del código. No tienen ningún efecto en el valor numérico real del campo. El
compilador los elimina. Ésta es una de las nuevas funciones del lenguaje de Java 7.
8. Cree un método calculateTotal que calcule el valor total del pedido (itemQuantity * ble
itemPrice) e imprímalo. Asegúrese de convertir el tipo de itemQuantity o itemPrice fe r a
en long para que el almacenamiento temporal utilizado para incluir el resultado de la ans
multiplicación sea lo suficientemente grande para contener un valor long. n - t r
n o
Solución:
s a
public void calculateTotal(){ h a
) deฺ
c o m ui
orderValue = (long)itemQuantity *
i l ฺ itemPrice;
G
a “+enorderValue);
t
System.out.println(“Order total:
g m
}
6 @ S t ud
a l le1 this
ฺc use pruébelo mediante la ejecución de
9. Guarde Order.java y,raacontinuación,
( toresultado con una calculadora.
OrderTest.java.
a lleVerifique
s e el
Solución:
e l oel C c
resultado
l i endebe ser 5555000000000
10.M arcel archivo Order.java para eliminar la conversión de tipo realizada en el método
Edite
ul calculateTotal.
Ra 11. Compile y vuelva a ejecutar OrderTest para ver la pérdida de datos resultante que se
produce sin convertir el tipo.
Creación de un programa de temperatura

En esta sección, escribirá un programa para convertir la temperatura de Fahrenheit a Celsius.
12. Cree una nueva clase Java denominada Temperature. Agregue un campo de miembro a la
clase Temperature que almacene la temperatura en Fahrenheit. Declare la variable de
campo con un tipo de dato apropiado, como int, float o double.

COGNOS
13. Cree un método calculateCelsius. Convierta la temperatura de Fahrenheit a Celsius.

Para ello, reste 32, multiplique por 5 y divida entre 9. Asegúrese de observar las reglas de
prioridad al escribir esta expresión.
Indicación: las reglas de prioridad se muestran aquí para su comodidad.
• Operadores dentro de un par de paréntesis
• Operadores de aumento y disminución

• Operadores de multiplicación y división, evaluados de izquierda a derecha
• Operadores de suma y resta, evaluados de izquierda a derecha
Solución: ésta es una posible solución.
public class Temperature {
public float fahrenheitTemp = 78.9F;
public void calculateCelsius() {

System.out.println ((fahrenheitTemp – 32) * 5 / 9);
ble
}
fe r a
ans
}
n - t r
a no
h a s cálculo
14. Compile la clase Temperature y pruébela con la clase TemperatureTest. Confirme que
obtiene el mismo resultado ejecutando el programa que al hacer
m ) este
e ฺ con una
calculadora.
i l ฺ co Guid
ma dent
15. Pruebe el programa con varios valores de temperatura.
g
16. Cuando termine de probar con diferentes
1 6 tu el proyecto Practice05.
@valores,Scierre
c a lle this
( r aฺ use
a lle se to
e l o C licen
a rc
ul M
Ra

COGNOS
ble
fe r a
ans
n - t r
o
s an
) ha eฺ
c o m uid
ฺ
ail ent G
m
g tud
@
16 is S
l l e
a e th
ฺ c
ra o us
e (
a ll se t
e l o C licen
a rc
M
Raul

COGNOS
ble
fe r a
ans
n - t r
no 6:
a
) deฺ has
Trabajar con objetos
c o m ui
i l ฺ G Capítulo 6
g ma dent
1 6 @ Stu
c a lle this
( r aฺ use
a lle se to
e l o C licen
a rc
M
Raul
Prácticas para la lección 6: Trabajar con objetos

COGNOS

En estas prácticas, creará y manipulará los objetos de tecnología Java y, además, creará y
utilizará los objetos String y StringBuilder. En el último ejercicio, se familiarizará con la
especificación de la API de Java. Las soluciones de estas prácticas se encuentran en
D:\labs\soln\les06.
ble
fe r a
ans
n - t r
o
s an
) ha eฺ
c o m uid
ฺ
ail ent G
m
g tud
@
16 is S
l l e
a e th
ฺ c
ra o us
e (
a ll se t
e l o C licen
a rc
M
Raul

COGNOS
Práctica 6-1: Creación y manipulación de objetos Java
Visión general
En esta práctica, creará instancias de una clase y manipulará estas instancias de varias
formas. Esta práctica consta de dos secciones. En la primera sección, creará e inicializará
instancias de objeto. En la segunda sección, manipulará referencias de objetos.
Supuestos
El archivo Customer.java aparece en la carpeta de prácticas de esta lección:
D:\labs\les06
Inicialización de instancias de objeto

Se le proporcionará una clase Customer. En esta práctica, creará, compilará y ejecutará una
clase CustomerTest. En esta clase de prueba, creará objetos de la clase Customer y definirá
valores para los campos de miembro.
ble
1. Cree un nuevo proyecto a partir del origen existente denominado Practice06. Defina la
fe r a
carpeta Source Package Folders para que apunte a D:\labs\les06. Recuerde que
ans
también debe cambiar la propiedad Source/Binary Format. Si necesita más información,
n - t r
consulte la práctica 2-2, pasos 3 y 4.
a no
h a s
m ) deฺ
i l ฺ c o
G ui
g ma dent
1 6 @ Stu
c a lle this
( r aฺ use
2. Abra el archivo a lle se to en el editor y examine los campos de miembro y el
o C utilizar
Customer.java
l
método. Puede
e l i c enla información de campo para completar esta práctica.
a
3. Cree
rcla clase CustomerTest como un tipo “Java Main Class”. Puesto que esta clase la
ul Mejecuta el ejecutable de Java, debe contener un método main. NetBeans IDE proporciona
Ra el esqueleto de una clase main.
a. Haga clic con el botón derecho en el proyecto Practice06 de la ventana Projects y
seleccione New > Java MainClass del menú emergente. (Éste es un método abreviado
para crear nuevas clases Java).

COGNOS
b. Asigne el nombre CustomerTest a la clase y haga clic en Finish.

ble
fe r a
ans
n - t r
o
s an
) ha eฺ
c o m uid
ฺ
ail ent G
m
g tud
@
16 is S
c. l l e
a eneeltheditor de texto.
La clase CustomerTest aparece
ฺ c
ra o us
e (
a ll se t
e l o C licen
arc
M
Raul

COGNOS
4. En el método main de CustomerTest, agregue código para declarar e inicializar dos

instancias de la clase Customer. La siguiente tabla proporciona las principales
instrucciones para esta tarea. Si necesita más ayuda, consulte los pasos detallados que
aparecen a continuación de la tabla.

a. Declare dos campos de tipo cust1

Customer. cust2
b. Inicialice las dos instancias. Utilice el operador new.
a. En el cuerpo del método main, declare dos campos de tipo Customer de la siguiente
forma:
Customer cust1, cust2;
b. Inicialice cada una de las variables con la siguiente sintaxis:
<variable name> = new <class name>();
ble
5. Termine de codificar el método main como se indica en la siguiente tabla. Encontrará
instrucciones más detalladas a continuación de la tabla. fe r a
t r a ns
Paso Ventana/Descripción de la página -
Opciones o valores
o n
a. Asigne valores a los campos de Ejemplo:
s an
miembro de uno de los objetos ha eฺ
cust1.customerID
) = 1;
Customer. m
co Guid
i l ฺ
ma dent
b. Repita los pasos para el otro objeto
Customer, pero utilice valores
diferentes para los campos. 6@
g tu
1 S
c. Llame al método
c a lle this Utilice la variable de referencia de objetos
( r aฺ usdeecada para cualificar el método, como en el paso a.
displayCustomerInfo
objeto. lle
a e to
a. Asigne o C aetodos
valores
s
n los campos de miembro de uno de los objetos Customer. Utilice
e l l i c
cvariable de referencia de objeto para cualificar el nombre del campo, como se indica a
a rlacontinuación:
ul M
Ra b.
cust1.customerID = 1;
Asigne diferentes valores a cada campo de miembro del otro objeto Customer.
c. Llame al método displayCustomerInfo de cada objeto. Ejemplo:
cust1.displayCustomerInfo();
6. Haga clic en Save para compilar.

COGNOS
7. Ejecute el archivo CustomerTest.java. Compruebe la salida para asegurarse de que

cada objeto Customer muestra los distintos valores que ha asignado.
ble
Manipulación de referencias de objeto
fe r a
En esta sección, asignará el valor de una referencia de objeto a otra.
t r a ns
8. Edite el método main de CustomerTest para asignar una referencia de objeto o n -
a otra justo
s an
antes de la primera línea de código que llama al método displayCustomerInfo. Por
ejemplo, suponiendo que cust1 y cust2 son instancias de la h a
clase
) deฺ Customer:
cust2 = cust1;
c o m ui
i l ฺ
a Compruebe G
t la salida de los métodos
9. Guarde y ejecute el archivo CustomerTest.java.
g m e n
displayCustomerInfo para ambos objetos.
6 @ Ambas
S t udreferencias de objeto ahora apuntan
al mismo objeto en la memoria, por
displayCustomerInfo deben a l e1loidénticas.
lser que lassdos salidas del método
t h i
r c
aฺ use
(
a lle se to
e l o C licen
a rc
ul M
Ra

COGNOS
Práctica 6-2: Uso de la clase StringBuilder
Visión general
En esta práctica creará, inicializará y manipulará objetos StringBuilder.
Supuestos
El archivo PersonTwoTest.java aparece en la carpeta de prácticas de esta lección:

D:\labs\les06
Creación y uso de objetos String

1. Cree una nueva clase Java denominada "PersonTwo".
2. Declare e instancie los dos campos de miembro de tipo StringBuilder para incluir el
nombre y el número de teléfono de la persona, respectivamente. Para el campo name,
inicialice la capacidad del objeto StringBuilder en 8. Utilice nombres de campo
significativos. ble
fe r a
Solución de ejemplo:
ans
public class PersonTwo {
n - t r
public StringBuilder name = new StringBuilder(8);
a no
public StringBuilder phoneNumber = new StringBuilder();
h a s
}
m ) deฺ
3. Cree un nuevo método denominado “displayPersonInfo”. i l ฺ c o
G ui
m a ent
@ g
4. En el cuerpo del método displayPersonInfo, rellene
t ueldnombre
y muestre el objeto name.
Asegúrese de que el número total de
e 1 6
caracteres
s Sen excede la capacidad inicial
l l t h i
Encontrará instruccionesra ฺcadetalladas
del objeto (8). La siguiente tabla
más
proporciona
us e a
los principales
continuación de
pasos
la
para esta tarea.
tabla.
e ( t o
Paso all nse de la página
Ventana/Descripción
C Opciones o valores
o
a. celAgregueliun e
c nombre al objeto Utilice el método append de la clase
a r StringBuilder.
u l M StringBuilder.
Ra b. Agregue dos o más valores al objeto

name.
un espacio: “ “
un apellido
Nota: el número total de caracteres
agregados debe ser mayor que 8.
c. Muestre el valor String del objeto Utilice el método toString de la clase
name. StringBuilder.
d. Muestre la capacidad del objeto Utilice el método capacity de la clase
name con una etiqueta adecuada. StringBuilder.
e. Compile y ejecute el programa. Ejecute el archivo PersonTwoTest.java.
a. Utilice el método append de la clase StringBuilder para agregar un nombre.
Ejemplo:
name.append(“Fernando”);

COGNOS
b. Utilice el mismo método en dos llamadas independientes para agregar primero un

espacio (“ “) y, a continuación, un apellido. Asegúrese de que el número total de
caracteres agregados al objeto name es mayor que 8.
Nota: puede realizar la misma acción mediante el uso de un objeto String y la
concatenación de valores adicionales. Sin embargo, puede que esto no sea eficaz porque
se crea un nuevo objeto String con cada concatenación. La capacidad del objeto String no
se puede aumentar porque los objetos String son inmutables.

c. Utilice el método System.out.println para mostrar el valor de nombre completo.
Puede embeber el método toString del objeto name en el método
System.out.println.
System.out.println(“Name: “ + name.toString());
d. Muestre la capacidad del objeto name con el método capacity. El objeto
StringBuilder ha aumentado dinámicamente la capacidad para incluir todos los
valores que ha agregado.
ble
public void displayPersonInfo(){ fe r a
ans
name.append(“Fernando”);
n - t r
name.append(“ “);
name.append(“Gonzalez”); a no
h a s
// Display the name object
m ) deฺ
i l ฺ c
System.out.println(“Name: + name.toString()); o
G ui
// Display the capacity
g ma dent
1 6 @ Stu
System.out.println(“Name object capacity: “ +
lle this
name.capacity());
c a
aฺ compilar.
seEjecute el archivo PersonTwoTest.java. La salida
}
( r u
le esimilar
e. Haga clic en Save para
unl aspecto
debe tener a
to al de la siguiente captura de pantalla. Observe que la
s
o Chaliaumentado
en desde la configuración inicial de 8 para poder incluir el nombre
c e l
capacidad c
a rcompleto.
ul M
Ra

COGNOS
5. Rellene y manipule el objeto phoneNumber. Aquí puede agregar una cadena de dígitos y
utilizar el método insert para insertar los guiones en varias ubicaciones de índice,
consiguiendo así el formato “nnn-nnn-nnnn”. La siguiente tabla proporciona las principales
instrucciones para esta tarea. Encontrará instrucciones más detalladas a continuación de la
tabla.

a. Agregue un valor String de Ejemplo: “5551234567”
10 dígitos al objeto phoneNumber.
b. Inserte un guión (“-“) después de los Utilice el método insert que toma un valor
tres primeros caracteres de int para el desplazamiento e inserta un
phoneNumber. valor String. (Utilice el número de
desplazamiento 3).
c. Inserte otro guión después de los Recordatorio: la inserción anterior ha
siete primeros caracteres de desplazado los caracteres restantes en un e
phoneNumber. índice.
r a bl
s fe
d. Muestre el objeto phoneNumber. Utilice el método toString de la clase
- t r an
StringBuilder.
no n
a. a
Utilice el método append de la clase StringBuilder para agregar un valor String de
s
diez números. h a
) deฺ
b.
c o m
Inserte un guión (“-“) en la posición de desplazamiento 3. Esto coloca el guión en la
ui
l ฺ
4a posición del objeto String, desplazando el resto de caracteres en una posición. La
i G
ma dent
sintaxis para este método se muestra a continuación:
g
6 @ Stu
<object reference>.insert(int offset, String str);
1
Ejemplo: tenga en cuenta a
e
lallsiguienteth is
cadena,
r c
aฺ use
“5551234567” (
e e to
a lldesplazamiento
l o Cen el 0).eSinsel guión se3 inserta
La posición de se produce en el número 1. (Los números de índice
r c e queliestá
empiezan c en la posición de desplazamiento 3, desplaza
Maposición de desplazamiento.
el número actualmente en esa posición y el resto de números a la siguiente
a ul
R c. Inserte un guión en la posición de desplazamiento 7 (donde se encuentra actualmente el
número 4).
d. Utilice System.out.println para mostrar la salida del método toString del objeto
StringBuilder.
Solución:
phoneNumber.append("5551234567");
phoneNumber.insert(3, "-");
phoneNumber.insert(7, "-");
System.out.println("Phone number: " +
phoneNumber.toString());

COGNOS
6. Haga clic en Save para compilar. Ejecute el archivo PersonTwoTest.java. Compruebe la

salida del método displayPersonInfo. Asegúrese de que los guiones aparecen entre el
tercer y el cuarto dígito y entre el sexto y el séptimo dígito.
7. Utilice el método substring de la clase StringBuilder para obtener el valor de

nombre en el objeto name. Utilice el método substring que toma el índice de inicio y el
índice de finalización para la subcadena. Muestre el valor mediante System.out.println.
Sintaxis:
ble
<object reference>.substring(int start, int end);
fe r a
Nota: los índices para los caracteres en la clase StringBuilder, como los índices de
ans
matriz, están basados en cero. El primer carácter de StringBuilder está en la posición (o
n - t r
índice) 0.
a no
haess exclusivo
Mientras que el índice de inicio del método substring es inclusivo (es el índice real
del primer carácter que desea que se devuelva), el índice)final
m d e ฺ (se trata del
lฺco t Gu
índice del carácter situado justo a la derecha del último i
carácter de la subcadena).
a i
g m den
// Assumes the first name6“Fernando”
1 @ S tu
System.out.println(“First
a lle name:
t h is “ + name.substring(0,8));
r c
aฺel archivo e
sPersonTwoTest.java.
e (
8. Guarde y vuelva a ejecutar
t o u Compruebe la salida y
realice los ajustesl l
a nse
necesarios a los números de índice para obtener el valor de nombre
correcto. o C e
c e l l i c
M ar
ul
Ra

COGNOS
Práctica 6-3: Examen de la especificación de la API de Java
Visión general
En esta práctica, examinará la especificación de la API de Java para familiarizarse con la
documentación y con la búsqueda de clases y métodos. No espere comprender todo lo que
vea. Conforme vaya avanzando en este curso, comprenderá mejor la documentación de la API
de Java.
Supuestos
La especificación de la API de Java SE 7 está instalada de forma local en su máquina.
Tareas
1. Para ver la especificación de la API de Java SE7 (también denominada “javadocs”), haga
clic dos veces en el acceso directo del escritorio (denominado “Java JDK7 1.7.0 API
Docs”).
ble
fe r a
ans
n - t r
o
s an
) ha eฺ
c o m uid
ฺ
ail ent G
m
g tud
@
16 is S
l l e
a e th
ฺ c
ra o us
e (
a ll se t
e l o C licen
a rc
M
Raul
La página de inicio de la documentación Java está formada por tres marcos, como se
muestra anteriormente. Permite navegar por la jerarquía de clases de la API por nombre de
clase o por paquete. (Nota: aprenderá más sobre los paquetes más adelante en este
curso).
2. Con el marco Packages, seleccione el paquete java.lang. El marco All Classes ahora
cambia para mostrar sólo las clases de ese paquete.
3. Busque la clase Math y haga clic en ella para mostrar la documentación en el marco
principal.

COGNOS
ble
fe r a
ans
n - t r
a no
h a s
m ) deฺ
i l ฺ c o
G ui
m a ent
@
4. Responda a las siguientes preguntas sobre g
la claseu
t d
Math:
6 S
a le1 Math?__________________________
a. ¿Cuántos métodos tiene la lclase
t h is
b. ¿Cuántos campos tiene
r c
aฺ la clase e
sMath?_____________________________
( u
Respuesta: a lle se to
a.) 54 elo
C en
r c lic
a
ul M
b.) 2
Ra 5. Seleccione otras clases en el panel Classes para responder a esta pregunta: ¿A qué clase
se refiere cada clase en la parte superior de la página? Indicación: ¿Qué clase es la
superclase de todas las clases? ______________________________________________
Respuesta: Objeto
6. Busque la clase String e identifique los métodos de esta clase. ¿Qué métodos permiten
comparar dos cadenas?_____________________________________________
Respuesta: compareTo y compareToIgnoreCase
7. Cierre el proyecto Practice06 en NetBeans.

COGNOS
ble
fe r a
ans
n - t r
no 7:
a
a
Uso de operadores
h s y
m ) de
construcciones
o i d eฺdecisión
ilฺ nt G c u
a
@ gm t7ude
Capítulo
l l e 16 is S
ฺ c a e th
e ( ra o us
a ll se t
e l o C licen
a rc
M
Raul
Prácticas para la lección 7: Uso de operadores y construcciones de decisión

COGNOS

En estas prácticas, creará construcciones if e if/else, además de una construcción switch.
Las soluciones de estas prácticas se encuentran en D:\labs\soln\les07.
ble
fe r a
ans
n - t r
o
s an
) ha eฺ
c o m uid
ฺ
ail ent G
m
g tud
@
16 is S
l l e
a e th
ฺ c
ra o us
e (
a ll se t
e l o C licen
a rc
M
Raul

COGNOS
Práctica 7-1: Escritura de una clase que utiliza la sentencia if/else
Visión general
En esta práctica, creará clases que utilicen construcciones if e if/else. Existen dos
secciones en esta práctica. En la primera sección, creará la clase DateTwo que utiliza
sentencias if / else para mostrar el día de la semana según el valor de una variable. En la
segunda sección, creará la clase Clock que utiliza sentencias if / else para mostrar la
parte del día, según la hora del día.
Supuestos
Los siguientes archivos aparecen en la carpeta de prácticas de esta lección, D:\labs\les07:
• ClockTest.java
• DateTwoTest.java
Escritura de una clase que utiliza una sentencia if/else bl e

En esta tarea, creará una clase DateTwo que evalúe un campo numérico para determinar el díafe r a
n s
n - tra
de la semana que corresponde a ese número. Para ello, utilizará una construcción if/else.
carpeta Source Package Folders para que apunte a D:\labs\les07. a no Defina la

1. Cree un nuevo proyecto desde los orígenes existentes denominado Practice07.
Recuerde que
h a s más información,
también debe cambiar la propiedad Source/Binary Format. Si necesita
consulte la práctica 2-2, pasos 3 y 4. m ) deฺ
i l ฺ c o
G ui
g ma dent
1 6 @ Stu
c a lle this
( r aฺ use
a lle se to
e l o C licen
a rc
M
Rau2.l Cree una nueva clase Java denominada "DateTwo". Declare e inicialice un campo de
miembro para esta clase denominada dayNumber. El valor asignado debe ser un número
entre 1 y 7 (incluidos) donde el número 1 representa el lunes (inicio de la semana) y el 7
representa el domingo (fin de la semana).
Indicación: utilice el tipo de dato int.

COGNOS
3. Cree un método displayDay en la clase DateTwo. Las principales instrucciones para esta
tarea aparecen en la siguiente tabla. Encontrará instrucciones más detalladas a
continuación de la tabla.

a. Utilice una construcción if/else En cada bloque if, muestre el día de la
para inspeccionar el valor de semana correspondiente.

dayNumber.
b. Visualice un mensaje de error si Esta debe ser la última condición que
encuentra un número no válido. compruebe.
a. El siguiente pseudocódigo le ayudará a escribir el cuerpo del método displayDay.
Cada condición if debe comprobar el valor de dayNumber. Indicación: Utilice el signo
==. En los bloques if, imprima el día de la semana (“Lunes”, “Martes”, etc.).
if (condition1) {
// print corresponding day
ble
}else if (condition2) {
fe r a
ans
// print corresponding day
n - t r
no
}else if (condition3)
…
s a
}else { h a
) deฺ
// if none of the conditions is true
c o m ui
i l ฺ G
ma1 yd7 e(incluidos),
nt
}
b. Si dayNumber no es igual a un númerogentre se imprimirá un mensaje
@ t u
l l e 16 else
de error. Estará incluido en el bloque
i s S
final.
4. Guarde, compile y ejecute la ฺ c a mediante
clase e h
t la ejecución de la clase DateTwoTest.
Compruebe la salida en a
(rla ventana s
uOutput.
l l e t o
5. Repita el paso
o C e n se asignando valores diferentes al campo de miembro
4avarias veces
DateTwo.
r c el lic
a
l M de otra clase que utiliza sentencias if/else
uEscritura
Ra En esta tarea, escribirá una clase denominada "Clock" que utiliza sentencias if/else para
mostrar la parte del día, según la hora del día. Utilice la siguiente tabla como guía.
Hora del día Parte del día
Desde las 8:01 hasta las 12:00 Morning
Desde las 12:01 hasta las 17:00 Afternoon
Desde las 17:01 hasta las 24:00 Evening
Desde las 0:01 hasta las 8:00 Early Morning
6. Cree una nueva clase Java denominada “Clock” que contenga un campo int denominado
currentTime. Inicialice este campo para incluir la hora del día. (Ejemplo: 400 = 04:00,
1505 = 15:05).

COGNOS
7. En la clase Clock, cree un método displayPartOfDay. Muestre la parte del día asociado
al valor del campo currentTime. Por ejemplo, si el campo currentTime equivale a
2100, debe aparecer “Evening”. No necesita comprobar los valores que estén fuera del
rango de 1 a 2400.
Indicación: utilice una construcción if/else similar a la utilizada en la tarea anterior.
Solución:
public void displayPartOfDay() {

if(currentTime >= 801 && currentTime <= 1200){
System.out.println(“Morning”);
}else if(currentTime >= 1201 && currentTime <= 1700){
System.out.println(“Afternoon”);
}else if(currentTime >= 1701 && currentTime <= 2400){
System.out.println(“Evening”);
}else {
ble
System.out.println(“Early Morning”);
fe r a
}
ans
}
n - t r
8. a no
Guarde, compile y ejecute el programa mediante la ejecución de la clase ClockTest.
a
9. Repita el paso 8 varias veces asignando valores diferentes a lahvariable
s de miembro
m ) deฺ
currentTime.
i l ฺ c o
G ui
g ma delcomo
Nota: un cero inicial indica un valor octal. Por lo tanto,
currentTime en 0800. Necesita especificar currentTime e nt 800 para
programa no se compila si define
8:00 AM para
@ t u
compilar el programa correctamente.
l l e 16 is S
ฺ c a e th
e ( ra o us
a ll se t
e l o C licen
a rc
ul M
Ra

COGNOS
Práctica 7-2: Escritura de una clase que utiliza la sentencia Switch
Visión general
En esta práctica, creará una clase denominada "Month" que utiliza sentencias switch para
mostrar el nombre del mes según el valor numérico de un campo.
Supuestos
El archivo MonthTest.java aparece en la carpeta de prácticas de esta lección,
D:\labs\les07.
Tareas
1. Cree una nueva clase Java denominada "Month".
2. Declare un campo int en la clase Month denominado monthNumber. Asigne un valor al
campo que esté entre 1 y 12 (incluidos), donde 1 representa el mes de enero y 12
representa el mes de diciembre. ble
fe r a
3. Cree un nuevo método en esta clase Month denominado displayMonth. El método utiliza
ans
una construcción switch para inspeccionar el valor del campo monthNumber y mostrar el
n - t r
nombre correspondiente del mes. El método displayMonth también debe mostrar un o
mensaje de error si se utiliza un número no válido.
s an
Indicación: la sintaxis de una sentencia switch es: ) ha eฺ
c o m uid
switch (<variable>){
ฺ
ail ent G
case <value1>:
// do something @g
m
6 S t ud
break;
a l le1 this
case <value2>:
r a ฺc use
(
a ll se to
//edo something
l C en
o… //
break;
e
rc default: lic cases
more
a
ul M
Ra // possibly error checking
break;
} // end of switch
Solución: consulte el archivo de soluciones en la carpeta D:\labs\soln\les07.
4. Guarde, compile y ejecute el programa mediante la ejecución de la clase MonthTest.
5. Repita el paso 4 varias veces asignando valores diferentes al campo monthName.

COGNOS
ble
fe r a
ans
n - t r
no 8:
a
s matrices
hade
Creación y uso
m ) deฺ
i l ฺ c o
G ui
Capítulo 8
g ma dent
1 6 @ Stu
c a lle this
( r aฺ use
a lle se to
e l o C licen
a rc
M
Raul
Prácticas para la lección 8: Creación y uso de matrices

COGNOS

En estas prácticas, creará y rellenará matrices y ArrayLists. Además, utilizará los métodos de la
clase ArrayList para manipular los valores. En el último ejercicio, creará y utilizará una matriz
bidimensional. Las soluciones de estas prácticas se encuentran en D:\labs\soln\les08.
ble
fe r a
ans
n - t r
o
s an
) ha eฺ
c o m uid
ฺ
ail ent G
m
g tud
@
16 is S
l l e
a e th
ฺ c
ra o us
e (
a ll se t
e l o C licen
a rc
M
Raul

COGNOS
Práctica 8-1: Creación de una clase con una matriz unidimensional de

tipos primitivos
Visión general
En esta práctica, creará una matriz que contenga el número de días que recibe un empleado en
la compañía Duke’s Choice según el número de años durante los que un empleado ha
trabajado en Duke’s Choice. La siguiente tabla muestra la escala de vacaciones de Duke’s
Choice:
Número de años trabajados Número de días de vacaciones
Hasta 1 año 10
1, 2 o 3 años 15
4 o 5 años 20
6 años o más 25
ble
fe r a
Supuestos
t r a ns
o n
El archivo VacationScaleTest.java aparece en la carpeta de prácticas de esta lección,
-
D:\labs\les08.
s an
) ha eฺ
Tareas
c o m uid
1. Cree un nuevo proyecto a partir del origen existente
ฺ
aildenominadot G Practice08. Defina la
carpeta Source Package Folders para queg m
apunte a d e n
D:\labs\les08. Recuerde que
@ t u
16 is S
también debe cambiar la propiedad Source/Binary
consulte la práctica 2-2, pasos 3llye4.
Format. Si necesita más información,
ฺ c a e th
e ( ra o us
a ll se t
e l o C licen
a rc
ul M
Ra
2. Cree una nueva clase Java denominada VacationScale. Declare pero no inicialice dos
campos públicos en esta clase, de la siguiente forma:
• Matriz int denominada vacationDays
• Matriz int denominada yearsOfService
Indicación: utilice los corchetes ([ ]) situados junto al tipo de dato para indicar que este
campo es una matriz.

COGNOS
3. Cree un nuevo método en la clase VacationScale denominado setVacationScale. La

siguiente tabla proporciona los principales pasos para esta tarea. Encontrará pasos más
detallados a continuación de la tabla.

a. Inicialice la matriz vacationDays. Defina el tamaño de la matriz en 7.
b. Rellene cada elemento de la matriz El valor es igual al número de días de

vacationDays para alinear un vacaciones.
número de años de servicio con el El índice de elemento es igual al número de
número de días de vacaciones años de servicio.
correcto. (Consulte la tabla anterior).
a. Utilice la palabra clave new para inicializar la matriz vacationDays. Proporcione el
tamaño de la matriz entre corchetes, como se muestra a continuación.
vacationDays = new int[7];
b. Asigne a cada elemento de la matriz, empezando por vacationDays[0], el número de
ble
días de vacaciones adecuado de los que se indican en la tabla anterior de la sección
fe r a
Visión general. Por ejemplo, a un empleado con 0 años de servicio le corresponden 10
ans
días de vacaciones. Por lo tanto, vacationDays[0] = 10. A un empleado con 1 año
n - t r
de servicio le corresponden 15 días de vacaciones. Por lo tanto, vacationDays[1] = o
15.
s an
Solución: ) ha eฺ
c o m uid
public void setVacationScale(){ ฺ
ail ent G
vacationDays = new int[7];
vacationDays[0] = 10; @g
m
6 S t ud
vacationDays[1] =le
l 1 is
c a
15;
t h
vacationDays[2]
( r aฺ = u15;
=
se
15;
lle se to= 20;

vacationDays[3]
a
e l o// C… and
l i c n
vacationDays[4]
eso
ar}c
on through element 6
a u4.l MCree un método público denominado displayVacationDays que muestre el número de

R
días de vacaciones de un empleado con los años de servicio indicados en el campo
yearsOfService. Utilice una construcción if/else para comprobar un número de
yearsOfService no válido (un número negativo) y mostrar, en este caso, un mensaje de
error.
Indicación: puede utilizar una variable con corchetes para representar el número de índice
de matriz. Por ejemplo:
vacationDays[yearsOfService]

COGNOS
Ejemplo:
public void displayVacationDays(){
if(yearsOfService >= 0){
System.out.println(“Days of Vacation: “ +
vacationDays[yearsOfService]);
}else {
System.out.println(“Invalid years of service”);
}
}
5. Guarde y compile el programa. Ejecute la clase VacationScaleTest para probar el
programa.
Nota: el programa, como está escrito actualmente, devuelve una excepción (un error).
Puede corregir el problema en los siguientes pasos.
6. La excepción devuelta por Java Virtual Machine (JVM) es una excepción ble
ArrayIndexOutOfBounds. La ventana Output debe tener un aspecto similar al de la fe r a
siguiente captura de pantalla: ans
n - t r
a no
h a s
m ) deฺ
i l ฺ c o
G ui
g ma dent
1 6 @ Stu
c a lle this
( r aฺ use
Esta excepción a
e ecuando
selldevuelve to se intenta acceder a un índice de una matriz no
existente.lo C que
Observe e s
nel número de índice que ha causado la excepción aparece en el
mensajee l
rc deporerror: i c
el índice número 10. Recuerde que esta matriz tiene 7 elementos,
a
ul M
indexados números, del 0 al 6. ¿Por qué el programa intenta acceder al índice 10?
Ra Respuesta:
Si observa el método displayVacationDays, verá que el campo yearsOfService
se utiliza como el índice de matriz (como un argumento del método
System.out.println).
Por supuesto, es posible que un empleado pueda tener más de 6 años de servicio (el
número de índice más alto de la matriz). Es necesario modificar el método
displayVacationDays para poder contar más de 6 años de servicio.
7. Cambie la construcción if/else para que también se compruebe un valor
yearsOfService que sea mayor o igual que 6. Todos los años de servicio que sean
mayores o iguales que 6 recibirán el mismo número de días de vacaciones.
Indicación: para cualquier valor de yearsOfService entre 0 y 5 (incluidos), puede
mostrar el valor de la matriz cuyo índice corresponda a ese valor. Para un valor de
yearsOfService que sea 6 o mayor, utilice el valor al que hace referencia el último
índice de matriz.

COGNOS
Solución:
if (yearsOfService >= 0 && yearsOfService < 6) {
System.out.println(“Days of vacation: “ +
vacationDays[yearsOfService]);
} else if (yearsOfService >= 6) {
System.out.println(“Days of vacation: “ +
vacationDays[6]);
} else {
System.out.println(“Invalid years of service”);
}
8. Guarde y compile el programa y, a continuación, vuelva a probarlo ejecutando la clase
VacationScaleTest. Ahora debe visualizar los tres valores de prueba de yearsOfService
mostrados en la ventana Output.
ble
fe r a
ans
n - t r
o
s an
) ha eฺ
c o m uid
ฺ
ail ent G
m
g tud
@
16 is S
l l e
a e th
ฺ c
ra o us
e (
a ll se t
e l o C licen
a rc
M
Raul

COGNOS
Práctica 8-2: Creación y trabajo con una ArrayList
Visión general
En esta práctica, creará las clases NamesList y NamesListTest para experimentar con el
relleno y la manipulación de ArrayLists. Existen dos secciones en esta práctica. En la primera
sección, creará dos clases y, a continuación, agregará un método a la clase NamesList para
rellenar la lista y mostrar su contenido. En la segunda sección, puede agregar un método para
manipular los valores de la lista.
Supuestos
Ninguno.
Creación y relleno de una ArrayList

1. Cree una nueva clase Java Main Class denominada NamesListTest. Recordatorio: haga
clic con el botón derecho en el nombre del proyecto en la ventana Projects y seleccione
ble
New > Java Main Class. Deje el método main vacío por ahora. Puede agregar el código
más adelante. fe r a
ans
2. Cree una nueva clase Java denominada NamesList.
n - t r
3. En la clase NamesList, declare un campo ArrayList público denominado
a no
listOfNames. No instancie el campo listOfNames.
h a s
Nota: cuando escriba la palabra ArrayList, el editor indica
o m i d eฺ en el margen
)una advertencia
de esta línea. No reconoce la clase ArrayList. Debe ilฺcimportar
G uclase para que esté
la
a t
visible para el compilador.
@ gm tuden
4. Coloque el cursor sobre el icono de 1
e 6 s Sen el margen para ver la descripción de la
advertencia
advertencia. Pulse Alt+Intro parallver
a h i de una lista de indicaciones para
y seleccionar
t
c
aฺ uAdd
resolver este problema. Seleccione
r se import for java.util.ArrayList como se muestra
(
aquí:
a lle se to
e l o C licen
a rc
ul M
Ra
La sentencia de importación se coloca en la parte superior de la clase NamesList (sobre la

declaración de clase).

COGNOS
5. Agregue un nuevo método a la clase NamesList denominada setList. Codifique el método

como se describe en la siguiente tabla. Encontrará pasos más detallados a continuación de
la tabla. ble
fe r a
Paso Descripción del código
t ns
Opciones o valores
r a
a. Instancie el objeto listOfNames. Utilice la palabra clave new. No
o n -
especifique el
tamaño. a n
b. Agregue un nombre (nombre y Utilice el métodohadd.a s
m ) deฺ
i l ฺ c G ui
apellido) al objeto listOfNames. Ejemplo:olistOfNames.add(“Joe Smith”);
c. Repita el paso b tres veces para m a ent
agregar un total de cuatro @ g t ud
6 S
a l le1 this
nombres al objeto listOfNames.
d. Imprima la listaa deฺc
nombres secon Puede imprimir simplemente el objeto.
( r u
a lle se to
una etiqueta adecuada. (listOfNames)
e.
o C lielcetamaño
Imprima
ellistOfNames.
n de la ArrayList Utilice el método size del objeto
a rc listOfNames.
ul Ma. Utilice la palabra clave new para instanciar listOfNames. Ejemplo:

R a listOfNames = new ArrayList();
b. Llame al método add del objeto listOfNames. Transfiera un valor String que contenga
un nombre y un apellido, separados por un espacio. (Consulte el ejemplo de la tabla
anterior).
c. Repita el paso b tres veces más utilizando un nombre diferente en cada llamada al
método.
d. Utilice System.out.println para imprimir todos los nombres del objeto
listOfNames. Utilice una etiqueta adecuada y concatene el objeto listOfNames a
dicha etiqueta.
System.out.println(“Names list: “ + listOfNames);
e. Utilice System.out.println para imprimir el tamaño (número de elementos) del
objeto listOfNames. Utilice el método size del objeto listOfNames y concatene una
etiqueta adecuada.
System.out.println(“Size of ArrayList: “ + listOfNames.size());

COGNOS
Solución:
public void setList(){
listOfNames = new ArrayList();
listOfNames.add(“Joe Smith”);
listOfNames.add(“Mary Palmer”);
listOfNames.add(“Jose Gonzalez”);
listOfNames.add(“Linda Baker”);
System.out.println(“Names list: “ + listOfNames);

System.out.println(“Size of ArrayList: “ +
listOfNames.size());
}
ble
7. Abra la clase NamesListTest en el editor. En el método main:
fe r a
8. Instancie un objeto NamesList denominado “names” con la palabra clave new.
ans
a. Llame al método setList del objeto names. n - t r
n o
9. Guarde y compile el programa. Ejecute la clase NamesListTest para a
sprobar el programa.
h a
) deฺ
c o m ui
i l ฺ G
g ma dent
1 6 @ Stu
c a lle this
Manipulación de ArrayList ( r aฺ use
alle nuevo e to
10. Agregue otroC
o método
e n s a la clase NamesList denominado manipulateList.
c e
Codifique l el l
método iccomo se describe en la siguiente tabla. Encontrará pasos más
a r
detallados a continuación de la tabla.
u l M
Ra Paso Descripción del código Opciones o valores
a. Elimine uno de los nombres de la Utilice el método remove(Object obj) del
lista. objeto ArrayList.
Indicación: un literal String es un objeto.
b. Imprima el contenido del objeto
listOfNames con una etiqueta
adecuada.
c. Imprima el tamaño del objeto Utilice el método size de ArrayList.
listOfNames.
d. Agregue el nombre que ha eliminado Utilice el método add(int index, Object
a la lista en una ubicación diferente. obj) del objeto ArrayList.
Indicación: los números de índice están
basados en cero.

COGNOS
Paso Descripción del código Opciones o valores

e. Imprima el contenido del objeto
listOfNames.
f. Imprima el tamaño del objeto
listOfNames.
a. Elimine uno de los nombres de ArrayList. Para ello, utilice el método remove y
transfiera el nombre completo, incluido entre comillas.
− Nota: este método se define como la obtención de un elemento Object como
argumento. Un literal String, como el nombre completo incluido entre comillas, es
un objeto.
listOfNames.remove(“Joe Smith”);
b. Utilice System.out.println para imprimir el objeto listOfNames. Utilice una
etiqueta adecuada.
c. Utilice System.out.println para imprimir el tamaño actual de ArrayList. Utilice
ble
una etiqueta adecuada.
fe r a
d. Utilice el método add de ArrayList para agregar el nombre que ha eliminado a
ans
ArrayList, pero en una ubicación diferente de la anterior.
n - t r
no
Nota: el método add está “sobrecargado”. Es decir, tiene dos firmas de método
a
a s
diferentes. Uno de los métodos add toma un elemento Object y lo agrega al final de
h
) deฺ
ArrayList. El otro método toma un número de índice y un elemento Object. Inserta
m
i l ฺ c o
G ui
Object antes del número de índice de referencia, desplazando el resto de elementos
un ejemplo: g ma dent
de lista un número de índice. Utilice el último método add. A continuación se muestra
1 6 @ Stu
c a lle this
listOfNames.add(1, “Joe Smith”);
e.
aฺ use
Utilice una etiqueta adecuada al imprimir el contenido recién modificado del objeto
( r
listOfNames.
a lle adecuadae to al imprimir el nuevo tamaño del objeto listOfNames.
f. Utilice una etiqueta
ode C en s
Solución
c e l i c
ejemplo:
l
a rlistOfNames.remove
u l M (“Joe Smith”);
Ra
System.out.println(“Names list after removing element: “
+ listOfNames);
listOfNames.add(1, “Joe Smith”);
System.out.println(“Names list after adding element: “
+ listOfNames);
11. En el método main de la clase NamesListTest, llame al método manipulateList del
objeto names.
Nota: puede que necesite hacer clic en Save para que el compilador pueda resolver la
referencia a manipulateList.

COGNOS
12. Guarde y compile el programa.

13. Ejecute la clase NamesListTest para probar el programa. La salida debe tener un aspecto
similar al de la siguiente captura, en función del nombre que ha eliminado y agregado y del
número de índice utilizado en el método add.
Nota: en el ejemplo anterior, Joe Smith estaba ubicado anteriormente en la posición de

índice 0 y Mary Palmer en la posición de índice 1.
Después de eliminar a Joe Smith, Mary Palmer se ha movido a la posición de índice 0 y e
Jose Gonzalez estaba en la posición de índice 1.
r a bl
A continuación, Joe Smith se agregó a la posición de índice 1, desplazando a Jose s fe
Gonzalez a la posición de índice 2.
- t r an
on
s an
) ha eฺ
c o m uid
ฺ
ail ent G
m
g tud
@
16 is S
l l e
a e th
ฺ c
ra o us
e (
a ll se t
e l o C licen
a rc
M
Raul

COGNOS
Práctica 8-3: Uso de los argumentos de tiempo de ejecución y análisis

de la matriz args
Visión general
En esta práctica, escribirá un juego de adivinanzas que acepte un argumento y muestre un
mensaje asociado. Puede crear una clase que acepte un argumento de tiempo de ejecución
entre 1 y 5, ambos incluidos. También puede generar aleatoriamente un número entre 1 y 5 en
la clase y comparar el valor de un argumento con el número generado aleatoriamente.
Supuestos
Ninguno.
Tareas
1. Cree una nueva clase Java Main Class denominada GuessingGame.
2. En este método main, declare dos variables int como se muestra a continuación: ble
fe r a
int randomNum = 0;
ans
int guess;
n - t r
3. no
Agregue código al método main para aceptar un argumento simple de cualquier número
a
a s
en el rango de 1 a 5, ambos incluidos, o la palabra "help". Los principales pasos se
h
) deฺ
describen en el siguiente pseudocódigo, seguido de unas indicaciones útiles. Si necesita
m
i l ฺ c o
G ui
más ayuda, realice los pasos situados a continuación del pseudocódigo y las indicaciones.
ma dent
Recuerde que la solución también la puede encontrar en D:\labs\soln\les08.
g
4. Pseudocódigo del método main:
1 6 @ Stu
if length of args array
a is value of args[0] = “help”
lle == 0thor
r c
aฺ Usage semessage
print a Correct
( u
else
a lle se to
l C en= a generated random number 1 - 5
orandomNum
rc e guess li=cinteger value of args[0]
a
ul M
Ra if argument < 1 or > 5
print an error message (invalid argument)
else
if argument == randomNum
print congratulations message
else
print a “Sorry; try again” message
Indicaciones
• Utilice el método compareTo de la clase String (los elementos de la matriz args
son siempre String) para que coincidan con args[0] en “help”.
• Para generar el número aleatorio del 1 al 5, utilice el siguiente fragmento de código:
randomNum = ((int)(Math.random()*5)+1);
• Convierta el argumento de tiempo de ejecución en un int antes de asignarlo a la
variable guess. Utilice el método Integer.parseInt para realizar la conversión.

COGNOS
Pasos detallados
a. Si el primer argumento de la matriz args es igual a “help” o si la matriz args está vacía,
muestre la sintaxis del programa. Por ejemplo:
“Usage: java GuessingGame [argument]”
“Enter a number from 1 to 5 as your guess”
b. Si se introduce 1, 2, 3, 4 o 5:
− Genere un número aleatorio (como se describe en la indicación anterior).

− Convierta arg[0] en int y asígnelo a la variable guess.
guess = Integer.parseInt(args[0]);
− Compare guess con randomNum mediante una construcción anidada if/else.
− Si coinciden, aparecerá un mensaje de felicitación.
− Indique también cuál era el número aleatorio y sugiera que vuelvan a intentarlo.
Solución:
public static void main(String[] args){
int randomNum = 0; ble
fe r a
int guess;
ans
if(args.length == 0 || args[0].compareTo(“help”) == 0){
n - t r
o
an
System.out.println
s
(“Usage: java GuessingGame [argument]”);
ha eฺ
System.out.println(); )
m uid
System.out.println
ฺ c o
m ail ent G
(“Enter a number from 1 – 5 as your guess.”);
}else { @ g tud
l l e 16 is S
randomNum = ((int)(Math.random()*5) +1);
ฺ c a e th
ra o us
guess = Integer.parseInt(args[0]);
e (
a ll se <t 1 || guess > 5){
o C licenSystem.out.println
if(guess
e l
a rc
M (“Invalid argument: Enter a number from 1 - 5”);
Raul }else {
if(guess == randomNum){
System.out.println
(“Great guess! You got it right!”);
}else {
System.out.println
(“Sorry. The number was “ + randomNum +
“. Try again.”);
}//end of innermost if/else
} // end of first nested if/else
}// end of outer if/else
}// end of main method

COGNOS
6. Ejecute la clase GuessingGame para probarlo.

Nota: ya que no hay ningún parámetro de tiempo de ejecución transferido a la matriz
args, debe obtener el mensaje de sintaxis que se muestra aquí.
Nota: al utilizar un IDE, no tendrá acceso a la línea de comandos para proporcionar los
parámetros de tiempo de ejecución. Por lo tanto, puede introducir “guess” (parámetro de
tiempo de ejecución) como una propiedad de tiempo de ejecución y, a continuación,
ejecutar el proyecto completo en lugar de ejecutar únicamente un archivo individual.
7. Haga clic con el botón derecho en la ventana Projects y seleccione Properties en el menú.
ble
8. En la ventana Project Properties, seleccione la categoría Run. Cambie Main Class a
fe r a
GuessingGame e introduzca un número del 1 al 5 en el campo Arguments. Haga clic en
ans
OK.
n - t r
o
s an
) ha eฺ
c o m uid
ฺ
ail ent G
m
g tud
@
16 is S
l l e
a e th
ฺ c
ra o us
e (
a ll se t
e l o C licen
a rc
M
Raul
9. Ejecute ahora el proyecto haciendo clic en el botón Run de la barra de herramientas
principal.
10. Debe recibir el mensaje “Great guess…” o “Sorry. …Try again.”. Siga haciendo clic en el
botón Run para ver los diferentes números aleatorios generados y cómo responde el
programa comparándolos con sus adivinanzas.

COGNOS

Con esto terminan las prácticas de la lección 8. En las prácticas de la siguiente lección
tendrá la oportunidad de trabajar con matrices bidimensionales.
ble
fe r a
ans
n - t r
o
s an
) ha eฺ
c o m uid
ฺ
ail ent G
m
g tud
@
16 is S
l l e
a e th
ฺ c
ra o us
e (
a ll se t
e l o C licen
a rc
M
Raul

COGNOS
ble
fe r a
ans
n - t r
o
s an
) ha eฺ
c o m uid
ฺ
ail ent G
m
g tud
@
16 is S
l l e
a e th
ฺ c
ra o us
e (
a ll se t
e l o C licen
a rc
M
Raul

COGNOS
ble
fe r a
ans
n - t r
no 9:
a
a s
Uso de construcciones
h
de bucle m ) deฺ
ilฺ nt G c o ui
a
@ gm t9ude
Capítulo
l l e 16 is S
ฺ c a e th
e ( ra o us
a ll se t
e l o C licen
a rc
M
Raul
Prácticas para la lección 9: Uso de construcciones de bucle

COGNOS

En estas prácticas, utilizará bucles for y while para procesar datos en matrices o ArrayLists.
Aquí se incluyen dos prácticas de comprobación para los usuarios que tengan tiempo adicional
y deseen ponerse a prueba. Las soluciones de estas prácticas se encuentran en
D:\labs\soln\les09.
ble
fe r a
ans
n - t r
o
s an
) ha eฺ
c o m uid
ฺ
ail ent G
m
g tud
@
16 is S
l l e
a e th
ฺ c
ra o us
e (
a ll se t
e l o C licen
a rc
M
Raul

COGNOS
Práctica 9-1: Escritura de una clase que utiliza un bucle for
Visión general
En esta práctica, creará la clase Counter que utiliza un bucle for simple para imprimir una
secuencia de números.
Supuestos
El archivo CounterTest.java aparece en la carpeta de prácticas de esta lección,
D:\labs\les09.
Tareas
1. Cree un nuevo proyecto a partir del origen existente denominado Practice09. Defina la
carpeta Source Package Folders para que apunte a D:\labs\les09. Recuerde que
también debe cambiar la propiedad Source/Binary Format. Si necesita más información,
consulte la práctica 2-2, paso 3.
ble
2. Cree una nueva clase Java denominada "Counter". Declare e inicialice un campo public fe r a
n s
final int denominado MAX_COUNT. Asigne el valor 100 a este campo.
n - tra
Indicación: utilice la palabra clave final para designarlo como un campoo
a n constante.
3. Cree un método denominado displayCount que realice las siguientes
h a s acciones:
• Contar desde 1 hasta el valor de la constante MAX_COUNT
o m i d eฺ el uso de un
) mediante
bucle for. Aumente el valor de la variable de bucle
a ilฺc enn1.t Gu
• Mostrar el valor de una variable de bucle g m
si ésta se e
d puede dividir entre 12. Muéstrelo
en una línea única, con una separación @
6 des un u
Stespacio.
l l e 1 i
Indicaciones
ฺ c a e th
• Ejemplo de un bucle:
e ( ra o us
for (int i=
a ll ise< t10; i++) // loops 9 times
1;
• UtiliceoelC
operador e nmodular (%) para comprobar la divisiblidad entre 12. Si se puede
e l l i c
c entre 12, el resultado de la operación modular será cero.
a rdividir
ul M• Utilice el método System.out.print para mantener todos los valores mostrados en
Ra la misma línea.
Solución:
public void displayCount(){
for(int count = 1; count <= MAX_COUNT; count++){
if (count % 12 == 0) {
System.out.print(count + “ ”);
} // end if
} // end for
} // end method
4. Guarde y compile el programa. Pruébelo mediante la ejecución de la clase CounterTest.
5. Debe recibir la siguiente lista de números como una salida:
12 24 36 48 60 72 84 96

COGNOS
Práctica 9-2: Escritura de una clase que utiliza un bucle while
Visión general
En esta práctica, escribirá una clase denominada Sequence que muestra una secuencia que
empieza por los números 0 y 1. Los números sucesivos de la secuencia son la suma de los dos
números anteriores. Por ejemplo: 0 1 1 2 3 5 8 13 21… Esta secuencia también se denomina

sucesión de Fibonacci.
Supuestos
El archivo SequenceTest.java aparece en la carpeta de prácticas de esta lección,
D:\labs\les09 y, por lo tanto, en el proyecto.
Tareas
1. Cree una nueva clase Java denominada “Sequence” con tres campos denominados
firstNumber, secondNumber y nextNumber. Asigne los valores de 0 y 1 a los campos ble
firstNumber y secondNumber, respectivamente. Declare también un elemento public
fe r a
final int denominado SEQUENCE_LIMIT. Defina su valor en 100.
t r a ns
2. Cree un método denominado displaySequence. Utilice los siguientes pasos o n -principales
para codificar el método. Si necesita más ayuda, se proporcionan instrucciones
s a n detalladas
en los siguientes pasos:
) ha eฺ
a. Imprima el valor de firstNumber y secondNumber
c o m uid la secuencia. Separe
para iniciar
todos los números de la secuencia con un espacio. i l ฺ G
g
b. Calcule la suma de firstNumber y secondNumber ma deny tasigne la suma a nextNumber.
1 6
c. Cree un bucle while con las siguientes S tu
@ características:
a llesi el valor
t h isde nextNumber es menor o igual que
− expresión booleana:
r crepita
aฺ use
SEQUENCE_LIMIT.(
e e to
− bloque dea llcódigo:s de nextNumber.
C eelnvalor
−lo Imprima
rce− Asigne licel valor de secondNumber a firstNumber y el valor de
a
ul M nextNumber a secondNumber.
Ra −Vuelva a calcular el valor de nextNumber para que sea la suma de
firstNumber y secondNumber.
d. Después del bucle while, utilice el método System.out.println para crear una nueva línea.
Instrucciones detalladas:
a. Antes de que empiece el bucle while, utilice el método System.out.print para
imprimir firstNumber y secondNumber, concatenando un espacio al final de cada
variable de las sentencias print.
b. Defina nextNumber igual a firstNumber + secondNumber.
c. Inicie un bucle while que evalúe la siguiente expresión al determinar si se debe volver a
crear un bucle:
while(nextNumber <= SEQUENCE_LIMIT)
− En el bloque while, realice lo siguiente:
− Imprima el campo nextNumber. Agregue un espacio al final.

COGNOS
− Defina firstNumber igual a secondNumber y secondNumber igual a

nextNumber.
− Defina nextNumber igual a firstNumber + secondNumber.
d. Fuera del bloque de bucle while, utilice System.out.println para crear una nueva
línea para el mensaje “Build Successful…” que aparece después de la secuencia.
Solución:
public class Sequence{
public int firstNumber = 0;
public int secondNumber = 1;
public int nextNumber;
public final int SEQUENCE_LIMIT = 100;
public void displaySequence(){

ble
// Print the first two numbers
fe r a
System.out.print(firstNumber + “ “);
ans
System.out.print(secondNumber + “ “);
n - t r
// Calculate the next number
a no
nextNumber = firstNumber + secondNumber;
h a s
m ) deฺ
i l ฺ
while(nextNumber <= SEQUENCE_LIMIT){ c o
G ui
// Print the next
g manumber e n
oft the sequence
6 @ S t ud
System.out.print(nextNumber + “ “);
firstNumber1 is
lle =thsecondNumber; // new first number
c a
( r aฺ use = nextNumber; // new second
secondNumber number
a lle // e to
Calculate the next potential number
o C l}ic//enends
e l
a rc of while
M
aul
// Finish it off with a carriage return
R System.out.println();
} // end of method
} // end of class
3. Guarde y compile el programa. Ejecute la clase SequenceTest para realizar la prueba.

COGNOS
Práctica de comprobación 9-3: Conversión de un bucle while en un

bucle for
Esta práctica es opcional. Consulte con el instructor las recomendaciones sobre las prácticas
opcionales que debe realizar. Realice esta práctica sólo si está seguro de que tiene tiempo
suficiente para realizar todas las prácticas no opcionales.
Visión general
En esta práctica, creará una nueva clase, ChallengeSequence, según la clase Sequence
creada en la última práctica. Modificará el método displaySequence para utilizar un bucle
for en lugar de un bucle while.
Supuestos
Esta práctica asume que ha completado la práctica 9-2. También supone que el archivo
ChallengeSequenceTest.java aparece en la carpeta de prácticas para esta lección,
D:\labs\les09 y, por lo tanto, en el proyecto.
ble
fe r a
Tareas
t r a ns
1. Cree una nueva clase Java denominada "ChallengeSequence". Copie todo elncódigo
o - que
a n
esté entre los corchetes (de clase) externos de la clase Sequence y péguelo dentro de los
corchetes externos de la clase ChallengeSequence.
h a s
m ) deฺ
i l ฺ c o
G ui
g ma dent
1 6 @ Stu
c a lle this
( r aฺ use
a lle se to Copie la sección
l C
o lice n resaltada
rc e
a
ul M
Ra
2. Cree un campo final adicional denominado SEQUENCE_COUNT y asígnele un valor de 10.

Asegúrese de no cambiar ninguno de los otros nombres de campo.

COGNOS
3. En el método displaySequence, convierta el bucle while en un bucle for para que

sólo aparezcan los primeros 10 valores de la sucesión Fibonacci.
Indicaciones
• Recuerde que los dos primeros números de la secuencia aparecen después de que
empiece el bucle. El bucle for debe mostrar los ocho valores restantes.
• Existen varias formas de manejar las discrepancias entre el valor SEQUENCE_COUNT y

el número de valores que necesitan aparecer en el bucle. Un enfoque es ajustar el
recuento inicial en el bucle.
Posible solución:
public void displaySequence(){
System.out.print(firstNumber + “ “);
System.out.print(secondNumber + “ “);
ble
for(int count = 2; count < SEQUENCE_COUNT; count++){
fe r a
// Start at 2 and loop until you get to 9 (8 numbers)
ans
System.out.print(nextNumber + “ “);
n - t r
firstNumber = secondNumber;
a no
secondNumber = nextNumber;
h a s
) deฺ
m
}
i l ฺ c o
G ui
System.out.println();
g ma dent
}
1 6 @ Stu
is ChallengeSequenceTest para probar el
lle lathclase
4. Guarde y compile el programa.aEjecute
r c
aฺ la siguiente
código. La salida debe mostrar se serie:
( u
0 1 1 2 3al5le8 13 e 21to
34
C n s
c e lo lice
M ar
ul
Ra

COGNOS
Práctica 9-4: Uso de bucles for para procesar una ArrayList
Visión general
En esta práctica, creará dos nuevos métodos en dos clases diferentes. Uno de los métodos
utiliza un bucle for tradicional para mostrar los valores en una ArrayList. El otro método
utiliza un bucle mejorado for para mostrar los valores de ArrayList. Esta práctica consta de
dos secciones:
• Uso de un bucle for con la clase VacationScaleTwo
• Uso de un bucle for mejorado con la clase NamesListTwo
Supuestos
En esta práctica, se asume que los siguientes archivos aparecen en la carpeta de prácticas de
esta lección, D:\labs\les09 y, por lo tanto, en el proyecto:
• VacationScaleTwo.java
ble
• VacationScaleTwoTest.java
fe r a
• NamesListTwo.java
ans
n - t r
Uso de un bucle for con la clase VacationScaleTwo
a no
1. Abra la clase VacationScaleTwo en el editor. Esto es similar a la a
h s VacationScale que
clase
escribió para las prácticas de la lección 8, excepto en que se)utiliza una
o m i d eฺArrayList para
almacenar los días de vacaciones en lugar de una matriz.
a ilฺc nt Gu
m de
2. Agregue un nuevo método denominado displayVacationDays.
gsiguiente Las principales
instrucciones para esta tarea aparecen 6 @
en la
S t u tabla. Encontrará instrucciones más
1
lle this
detalladas a continuación de la tabla.
c a
Paso r
Descripción
( aฺ del código
u se Opciones o valores
a. Utilicea
un
e
ll buclesfor t o
e para pasar por Utilice el método size de ArrayList en la
l o
los
C
elementos e n de la ArrayList expresión booleana que determina el final del
c e l
r vacationDays. i c bucle.
a
ul Mb. En el bucle, muestre cada valor de Utilice el método get de la ArrayList junto
Ra la ArrayList y su posición en la con System.out.println para mostrar el
lista con una etiqueta adecuada. valor.
a. En el método displayVacationDays, agregue un bucle for con los siguientes
criterios:
for(int years = 0; years < vacationDays.size(); years++)
b. En el bloque de bucle for, utilice System.out.println para imprimir el valor de cada
elemento de ArrayList. Utilice el método get de ArrayList, transfiriendo la variable
years como un argumento. Hace referencia al número de índice actual de la lista
vacationDays.
System.out.println(“The vacation for “ + years +
“ years of service is: “ + vacationDays.get(years));

COGNOS
3. Guarde y compile el programa y, a continuación, ejecute la clase VacationScaleTwoTest

para probarlo. Debe ver una salida similar a la siguiente:
Uso de un bucle for mejorado con la clase NamesListTwo

4. Abra la clase NamesListTwo en el editor. Esto es similar a la clase NamesList de la lección
ble
8. Sólo tiene un método, setList. Este método inicializa ArrayList y, a continuación,
fe r a
imprime el tamaño de la lista.
t r a ns
5. Agregue un nuevo método a la clase NamesListTwo denominado displayNames.
o n - Utilice
un bucle mejorado for en este método para procesar la ArrayList.a Las nprincipales
h a s
instrucciones para esta tarea aparecen en la siguiente tabla. Encontrará instrucciones más
detalladas a continuación de la tabla.
m ) deฺ
Paso Descripción del código i l ฺ c o
G ui o valores
Opciones
m a ent
a. Muestre un mensaje de introducción
@ g t ud
6
e1 this
para describir la lista siguiente. S
a l l
b.
(recuerde que ( r aฺcmejorado
Inicie el bucle for
una ArrayListu se está for (Object name : listOfNames)
a
definida le incluir
lpara e o
telementos de
o C e n s
r c eltipo
lic
Object).
c.a En el bloque for, muestre el Use the name reference
u l M elemento actual de
Ra
ArrayList.
a. Utilice el método System.out.println para imprimir el mensaje:

“Names in the ArrayList: ”
b. Inicie el bucle for mejorado de la siguiente forma:
for (Object name : listOfNames)
Nota: la variable name es una referencia al elemento actual en la ArrayList

listOfNames para cada iteración del bucle for.
c. En el bloque de bucle for, utilice System.out.println para imprimir la referencia
name.

COGNOS
Solución:
public void displayNames(){
System.out.println(“Names in the ArrayList: ”);
for(Object name : listOfNames){
System.out.println(name);
}
}
6. Cree una nueva clase Java Main Class denominada NamesListTwoTest.
7. En el método main, realice lo siguiente:
a. Declare e inicialice una variable local de tipo NamesListTwo denominada names.
NamesListTwo names = new NamesListTwo();
b. Llame al método setList del objeto names.
c. Llame al método displayNames del objeto names. e
8. Guarde y compile el programa. Ejecute la clase NamesListTwoTest para realizar la prueba. r a bl
n s fe
9. Debe ver una salida del programa similar a la siguiente captura de pantalla:
n - tra
a no
h a s
m ) deฺ
i l ฺ c o
G ui
g ma dent
1 6 @ Stu
c a lle this
( r aฺ use
a lle se to
e l o C licen
a rc
ul M
Ra

COGNOS
Práctica 9-5: Escritura de una clase que utiliza un bucle for anidado
para procesar una matriz bidimensional
Visión general
En esta práctica, creará y procesará una matriz bidimensional mediante el uso de un bucle for
anidado (un bucle en otro bucle). Esta práctica está basada en el escenario de un aula. Un aula
tiene 12 escritorios organizados en una cuadrícula rectangular compuesta de tres filas y cuatro
columnas. Se asigna a los estudiantes una mesa en la primera posición vacante, recorriendo
cada fila.
La siguiente tabla muestra el mapa de la clase como una cuadrícula. Cada celda representa
una mesa. Cada celda contiene las coordenadas de la posición de la mesa en el mapa de la
clase.
XXXX Columna 1 Columna 2 Columna 3 Columna 4
Fila 1 0,0 0,1 0,2 0,3
ble
Fila 2 1,0 1,1 1,2 1,3
fe r a
Fila 3 2,0 2,1 2,2 2,3
ans
n - t r
a no
Supuestos
h a s
En esta práctica, se asume que el archivo ClassMapTest.java)aparecee
m d ฺ la carpeta de
en
o i
prácticas de esta lección, D:\labs\les09 y, por lo tanto,
a ilฺc nt Gu
en el proyecto.
Tareas @ gm tude
1. Cree una nueva clase Java denominada l l e 16 “ClassMap”.
i s S
ฺ c a et h
2. En la clase, declare dos
e ( a
r opúblicos
campos
t us de la siguiente forma:
all nsedeskArray;
public String[][]
C
c e lo String
public
l i c e name;
3. Cree
M ar un nuevo método denominado setClassMap. En este método, inicialice deskArray
Raul para que tenga tres filas y cuatro columnas:
deskArray = new String[3][4];
4. Cree un nuevo método denominado setDesk. Este método asigna un nuevo estudiante
(identificado por el campo name definido por ClassMapTest) a una mesa vacía en el mapa
de la clase. Defina el método según los siguientes pasos:
a. Recorra deskArray para identificar su primer elemento vacante. Utilice un bucle
anidado for para este objetivo. Por ejemplo:
for(int row=0; row<3; row++){
for(int col=0; col<4; col++){
if(deskArray[row][col]==null){
b. Si encuentra un valor null en deskMap (es decir, si encuentra una mesa vacía), asigne
el valor del campo name al elemento vacante.

COGNOS
c. En el bucle for interno (el que itera en las columnas de una fila), defina una variable
boolean local (flag) en true si ha asignado el nombre a un elemento. Compruebe el
valor de la variable flag en la última línea del bucle for externo. Si es true, no es
necesario continuar pasando por el resto de filas, por lo que debe utilizar break para
saltar fuera del bucle for.
Del mismo modo, puede comprobar el valor de flag después del cierre del bucle for
externo. Si el valor aún es false, significa que todas las mesas están ocupadas (no se
ha encontrado ningún valor nulo). Imprima un mensaje que indique que todas las
mesas están ocupadas.
d. Imprima la posición de la mesa del estudiante y salga de los bucles. Utilice una sentencia
break para saltar fuera del bucle en ejecución.
Solución:
public void setDesk() {
boolean flag= false;
for(int row=0; row<3; row++){ // start of row loop
ble
for(int col=0; col<4; col++){ // start of column loop
fe r a
if(deskArray[row][col]==null){
ans
deskArray[row][col] = name;
n - t r
o
an
System.out.println
s
(name +” desk is at position: Row:”
ha eฺ
+ row + ” Column:”+col);
)
m uid
flag = true;
ฺ c o
ail ent G
break; // drop out of column loop
m
} // end of if
@ g tud
l l e 16 is S
} // end of inner/column for loop
c a e th
if (flag == true){
ฺ
( ra o us
break; // drop out of row loop
e
a ll se t
} // end of if
e l o C licen
} // end of row for loop
arc if (flag == false){

M
aul
System.out.println(“All desks occupied.”);
R } // end of if
} // end of method
Nota: probará este código más adelante.

5. Cree un nuevo método denominado displayDeskMap. En este método, recorra
deskArray de la misma forma que lo hizo en el último paso. Para cada elemento de la
matriz, imprima el nombre en ese elemento (o imprima “null”). La salida debe tener el
formato de una cuadrícula.
Indicación: utilice una combinación de llamadas al método print y println para
conseguir el formato de cuadrícula. La cuadrícula se debe parecer a la siguiente:
Ann Bond Cindy Donald
null null null null
null null null null

COGNOS
Solución:
public void displayDeskMap() {
for(int row = 0; row < 3; row++){
for(int col = 0; col < 4; col++){
System.out.print(“ “+ deskArray[row][col] +” “);
}
System.out.println(); // carriage return between rows
}
}
7. Abra la clase ClassMapTest y examine el código en el método main. Primero llama a
setClassMap para inicializar la matriz. A continuación, asigna un valor al campo name del
objeto myClassMap y llama a setDesk. Esto lo hace cuatro veces, con un valor name
diferente cada vez. Por último, llama a displayDeskMap.
ble
8. Ejecute la clase ClassMapTest para probar el programa. fe r a
ans
n - t r
a no
h a s
m ) deฺ
i l ฺ c o
G ui
g ma dent
1 6 @ Stu
c a lle this
( r aฺ use
a
9. Si no va a realizarlllaepráctica
e to (una práctica de comprobación opcional), cierre el
9-6
o C licen
proyecto lPractice09
s
enNetBeans ahora.
rc e
a
ul M
Ra

COGNOS
Práctica de comprobación 9-6: Adición de un método de búsqueda al

programa ClassMap
Esta práctica es opcional. Consulte con el instructor las recomendaciones sobre qué
prácticas opcionales debe realizar.
Visión general
En esta prácticas, puede agregar otro método a la clase ClassMap. Este método busca en
deskArray un nombre concreto.
Supuestos
En esta práctica, se asume que ha completado la práctica 9-5.
Tareas
1. En la clase ClassMap, agregue otro método nuevo denominado searchDesk.
ble
2. En el método searchDesk, realice lo siguiente:
fe r a
a. Cree un bucle anidado for para recorrer deskArray.
t r a ns
b. Si el elemento de matriz no es null, compare el valor del campo name con
o n - el valor del
elemento. Por ejemplo:
a n
if(deskArray[row][col] != null && s
ha eฺ
deskArray[row][col].equals(name)){ )
m uid
ฺ c o
a l ent Gen deskArray.
c. Imprima la posición de la mesa si los nombres ison iguales.
d. Imprima un mensaje de error si el nombrem no se encuentra
@ g tud
e 1 6 sS
e. Utilice la sentencia break para saltar fuera de los bucles o salir de ellos cuando sea
necesario. l
al e th i
ฺ c
ra o us
e (
a ll se t
e l o C licen
a rc
ul M
Ra

COGNOS
Solución:
public void searchDesk() {
boolean flag= false;
for(int row=0; row<3; row++){
for(int col=0; col<4; col++){
if(deskArray[row][col] != null &&

deskArray[row][col].equals(name)){
System.out.println
(name +” Desk Position: Row: ”+row+” Column: “
+col);
flag = true;
break;
} // end of if
} // end of column loop
ble
if (flag == true){
fe r a
break;
ans
} // end of if
n - t r
} // end of row loop
a no
if (flag == false){
h a s
m
System.out.println(“Desk not allocated for: ”+name);) deฺ
} // end of if i l ฺ c o
G ui
} // end of method g ma dent
6 @ Sdetulas líneas de código que definen el
3. En la clase ClassMapTest, anule los1comentarios
valor name del objeto myClassMap a lle y llaman
t h isal método searchDesk (esta combinación se
produce dos veces). r c
aฺ use
( toEjecute la clase ClassMapTest para probar el programa.
4. Guarde y compilea lelleprograma.
s e
e l o C licen
a rc
ul M
Ra
5. Ésta es la conclusión de las prácticas de la lección 9. Cierre el proyecto Practice09 ahora.

COGNOS
ble
fe r a
ans
n - t r
o
s an
) ha eฺ
c o m uid
ฺ
ail ent G
m
g tud
@
16 is S
l l e
a e th
ฺ c
ra o us
e (
a ll se t
e l o C licen
a rc
M
Raul

COGNOS
ble
fe r a
ans
n - t r
no 10:
a
a s
Trabajar con métodos
h y
) ฺ
ide
com deumétodos
sobrecarga
a ilฺ nt G
@ gm t10ude
Capítulo
l l e 16 is S
ฺ c a e th
e ( ra o us
a ll se t
e l o C licen
a rc
M
Raul
Prácticas para la lección 10: Trabajar con métodos y sobrecarga de métodos

COGNOS

En estas prácticas, creará y utilizará métodos con argumentos. En un ejercicio de
comprobación, creará un método sobrecargado. Las soluciones de estas prácticas se
encuentran en D:\labs\soln\les10.
ble
fe r a
ans
n - t r
o
s an
) ha eฺ
c o m uid
ฺ
ail ent G
m
g tud
@
16 is S
l l e
a e th
ฺ c
ra o us
e (
a ll se t
e l o C licen
a rc
M
Raul

COGNOS
Práctica 10-1: Escritura de un método que utiliza argumentos y

valores de retorno
Visión general
En esta práctica, creará una clase para realizar un pedido de más de una camisa y, a
continuación, mostrar el valor total del pedido de camisas.
Supuestos
esta lección, D:\labs\les10:
• Order.java
• Shirt.java
Tareas
1. Cree un nuevo proyecto a partir del origen existente denominado Practice10. Defina la ble
carpeta Source Package Folders para que apunte a D:\labs\les10. Recuerde que fe r a
también debe cambiar la propiedad Source/Binary Format. Si necesita más información, ans
consulte la práctica 2-2, pasos 3 y 4. n - t r
2. a no
Abra la clase Shirt y examine los campos de miembro y el método que contiene.
h a s
) deฺ
3. Abra la clase Order y examine los campos de miembro y el método.
m
c o
4. Cree una nueva clase Java Main Class denominadalฺ“OrderTest”.
i G ui
5. Agregue código al método principal que agregue g mauna dcamisa
e nt a un nuevo pedido y muestre
el importe total del pedido. Los principales
1 6 tu esta tarea aparecen en la siguiente
@pasosSpara
lle thayuda
tabla. En la siguiente tabla se proporciona
a is más detallada.
r c
aฺ del código
se
Paso Descripción
e ( t o u Opciones o valores
a. ll sdos
Cree eainicialice e objetos. Tipo de objeto: Shirt
o C e n
r c el lic Tipo de objeto: Order
Mb.a Declare e inicialice una variable local Nombre de variable: totalCost

u l
Ra
de tipo doble. Valor: 0.0
c. Asigne un valor al campo price del Valor: 14.99
objeto Shirt.
d. Llame al método addShirt del Argumento de método: objeto Shirt
objeto Order. Retorno de método: asígnelo a totalCost
e. Muestre el valor de retorno con una Salida de ejemplo:
etiqueta adecuada. “Total amount for the order is $14.00”

COGNOS
Detalles adicionales:
La documentación del método addShirt es la siguiente:
Agrega una camisa a la lista de camisas de un pedido
Sintaxis:
public double addShirt (Shirt shirt)

Parámetros:
shirt : referencia de objeto a un objeto Shirt
Devuelve:
Importe total actual del pedido
Solución:
ble
Order order = new Order();
fe r a
Shirt shirt = new Shirt();
ans
double totalCost = 0.0; n - t r
a no
shirt.price = 14.99;
h a s
totalCost = order.addShirt(shirt); m)
o i d eฺ
ilฺcforntthe
G uorder is $" +
System.out.println("Total amount
a
m de
totalCost);
@ g tu
}
1 6 S
6. Guarde y compile el programa. aPruebe
is del pedido mediante la ejecución de la
lle eltproceso
h
clase OrderTest. r c
aฺ use
(
a lle se to
e l o C licen
a rc
ul M
Ra
7. En el método main de OrderTest, cree objetos Shirt adicionales, asigne valores al

campo price de cada nuevo objeto Shirt y agregue los objetos Shirt al pedido
mediante la llamada al método addShirt.
Nota: recuerde que el método addShirt agrega el precio de un objeto de argumento shirt
al campo totalPrice del objeto Order. Por lo tanto, el valor totalPrice aumenta
conforme se van agregando camisas. Sólo necesita capturar el valor de retorno de la
llamada al método addShirt final para obtener el valor totalCost.

COGNOS
Solución:
public static void main(String[] args) {
Order order = new Order();
Shirt shirt = new Shirt(),
shirt2 = new Shirt(),
shirt3 = new Shirt();

double totalCost = 0.0;
shirt.price = 14.99;
shirt2.price = 23.55;
shirt3.price = 49.99;
order.addShirt(shirt);
order.addShirt(shirt2);
totalCost = order.addShirt(shirt3);
ble
System.out.println("Total amount for the order is $" +
fe r a
totalCost);
ans
}
n - t r
o
8. an
Guarde y compile el programa y, una vez más, ejecute la clase OrderTest para probarlo.
s
ha eฺ
Asegúrese de que el importe mostrado es el total de todas las camisas.
)
c o m uid
ฺ
ail ent G
m
g tud
@
16 is S
l l e
a e th
ฺ c
ra o us
e (
a ll se t
e l o C licen
a rc
M
Raul

COGNOS
Práctica de comprobación 10-2: Escritura de una clase que contiene

un método sobrecargado
Visión general
En esta práctica, escribirá una clase Customer con un método sobrecargado denominado
setCustomerInfo.
Supuestos
En esta práctica, se asume que el archivo CustomerTest.java aparece en la carpeta de
prácticas de esta lección, D:\labs\les10 y, por lo tanto, en el proyecto Practice10.
Tareas e
1. Cree una nueva clase Java denominada "Customer". Declare los siguientes campos e r a bl
inicialícelos como se muestra en la siguiente tabla: ns fe
- t r a
Campo Tipo o n
Valor inicial
customerID int 0 s an
) ha eฺ
name String
m uid
“-name required-“
c o
address String ฺ
il nt Grequired-“
a“-address
m
g “-phone de required-“
phoneNumber String
@ t u
6 s S“-email optional-“
String le1 i
eMail
c a l t h
( r aฺ use
denominadosC alle nseentola clase
2. Instrucciones principales:
setCustomerInfo.
Customer, agregue dos métodos sobrecargados
Según la forma en la que se llame al método
c e lo licerealiza una de las siguientes acciones:
setCustomerInfo,
M
•
arDefine el ID, el nombre, la dirección y el número de teléfono de un objeto Customer.
ul
Ra •
(Esta es la información mínima necesaria para un nuevo cliente).
Define el ID, el nombre, la dirección, el número de teléfono y la dirección de correo
electrónico de un objeto Customer.
Instrucciones detalladas:
• Las dos firmas del método deben ser:
public void setCustomerInfo(int Id, String nm, String addr,
String phNum)
public void setCustomerInfo(int Id, String nm, String addr,
String phNum, String email)
• En cada método, asigne cada argumento del método al campo correspondiente.
3. Cree un método display para mostrar los valores de todos los campos de miembro de la
clase Customer.

COGNOS
5. Abra la clase CustomerTest. Modifique el método main de la siguiente forma para que se
pueda utilizar para probar los métodos sobrecargados de la clase Customer.
• Cree dos referencias de objeto en diferentes objetos Customer.
• Utilice cada variación del método setCustomerInfo para proporcionar información
para cada objeto Customer.
• Muestre el contenido de cada objeto Customer.

Solución:
Customer c1 = new Customer(),
c2 = new Customer();
c1.setCustomerInfo(1,”Harry”,”234 Maple St”,
”505-123-4545”);
c2.setCustomerInfo(2,”Sally”,”567 Oak St”,
”505-123-2323”,”sally@gmail.com”);
ble
c1.display();
fe r a
c2.display();
ans
} n - t r
n o
a
6. Una vez más, guarde y compile el programa. Ejecute la clase CustomerTest para probar el
s de visualización.
h a
programa. Asegúrese de que la salida es diferente para cada método
) deฺ
c o m ui
i l ฺ G
g ma dent
1 6 @ Stu
c a lle this
( r aฺ use
a lle se to
e l o C licen
a rc
ul M
Ra

COGNOS
ble
fe r a
ans
n - t r
o
s an
) ha eฺ
c o m uid
ฺ
ail ent G
m
g tud
@
16 is S
l l e
a e th
ฺ c
ra o us
e (
a ll se t
e l o C licen
a rc
M
Raul

COGNOS
ble
fe r a
ans
n - t r
no 11:
a
a s
Uso de encapsulación
h y
) e ฺ
ilฺ nt G com uid
constructores
a
@ gm t11ude
Capítulo
l l e 16 is S
ฺ c a e th
e ( ra o us
a ll se t
e l o C licen
a rc
M
Raul
Prácticas para la lección 11: Uso de encapsulación y constructores

COGNOS

En estas prácticas, experimentará con el acceso a los campos y su encapsulación y creará y
utilizará constructores sobrecargados. Aquí se incluye una práctica de comprobación para los
usuarios que tengan tiempo adicional y deseen afrontar un reto. Las soluciones de estas
prácticas se encuentran en D:\labs\soln\les11.
ble
fe r a
ans
n - t r
o
s an
) ha eฺ
c o m uid
ฺ
ail ent G
m
g tud
@
16 is S
l l e
a e th
ฺ c
ra o us
e (
a ll se t
e l o C licen
a rc
M
Raul

COGNOS
Práctica 11-1: Implantación de la encapsulación en una clase
Visión general
En esta práctica, creará una clase que contenga atributos privados e intentará acceder a ellos
en otra clase. Esta práctica consta de dos secciones.
• Implantación de la encapsulación en una clase

• Acceso a los atributos encapsulados de una clase
Supuestos
esta lección, D:\labs\les11 y, por lo tanto, en el proyecto Practice11.
• DateOneTest.java
• DateTwoTest.java
• DateThreeTest.java
ble
Implantación de la encapsulación en una clase fe r a
ans
1. Cree un nuevo proyecto denominado “Practice11”. Consulte la práctica 2-2, pasos 3 y 4, si
n - t r
necesita ayuda.
a no
2. Cree una nueva clase Java denominada "DateOne". Declare tresa
h s de miembro de
campos
tipo int denominados: day, month y year. Proporcione acceso
m ) deฺ a todos los
público
campos de miembro.
i l ฺ co Gui
3. Abra la clase DateOneTest. En el método main,
g marealice e t
lonsiguiente:
a. Cree e inicialice un objeto de tipo 6 @ S t ud
le1 tahlosiscampos de miembro del objeto DateOne.
DateOne.
b. Asigne diferentes valores a
c l
numéricos
c. Muestre el valor de ( r aฺcampos
los u sdeemiembro del objeto DateOne. Concaténelos en una
le el formato
cadena únicalcon
a e to de fecha que desee.
oC
Nota: el carácter de barra
ede s
n invertida (\) es un carácter especial en el lenguaje Java
c e
denominado
l l i c
“carácter escape”. Si desea utilizarlo como parte del formato de fecha,
a r
utilice dos barras invertidas juntas para que una de ellas aparezca en la cadena. Ejemplo:
ul Mday + “\\” + month tiene como resultado una barra invertida única entre el día y el mes. No
Ra hay restricciones para utilizar una barra inclinada.
Solución:
public static void main(String args[]){
DateOne date = new DateOne();
date.day = 16;
date.month = 10;
date.year = 2011;
System.out.println(“DateOne: “+date.day+ ”/” +date.month+
”/” +date.year);
}

COGNOS
5. Ejecute la clase DateOneTest para probar el programa.

6. Cree otra nueva clase Java denominada “DateTwo” similar a DateOne con tres campos de
miembro (day, month y year).
7. Defina el modificador de acceso para los campos de miembro en private.
8. Abra la clase DateTwoTest y realice los mismos pasos que en el paso 3. Sin embargo, en
este caso, cree una instancia de la clase DateTwo en lugar de la clase DateOne. El resto
de líneas de código permanecen igual.
Nota: NetBeans le advierte con un icono de error situado junto a cada línea que hace ble
referencia a los campos del objeto DateTwo.
fe r a
ans
n - t r
a no
h a s
m ) deฺ
i l ฺ c o
G ui
m a ent
Coloque el cursor sobre cualquiera de los @ g u
iconos rojos
t dpara examinar el mensaje de
6
advertencia. Se indica que day tiene1un acceso S
privado en DateTwo (mensaje similar para
cada campo). Aunque NetBeans a l e thacer
lpermite h is clic en Save sin emitir un error de compilador,
sólo guarda el archivo.(No a ฺ
r ou c
compila s
el e
código ni crea el archivo DateTwoTest.class.
e
all encapsulados t
C
Acceso a los atributos
o e n se de una clase
e l l i c
a rcdesdecreará
En esta tarea, una clase con atributos privados pero los activará para que se puedan
ul M
manipular otra clase.
Ra 9. Cree una nueva clase Java denominada “DateThree” y agregue los tres mismos campos
privados de la clase DateTwo.
10. Agregue un método public get para el campo day. Este método debe devolver un int.
En el cuerpo del método, devuelva el campo day. Ejemplo:
public int getDay(){
return day;
}
11. Agregue un método public set para el campo day. Este método devuelve void, pero
toma un argumento de tipo int. En el cuerpo del método, asigne el argumento al campo
day. Ejemplo:
public void setDay(int day){
this.day = day;
}

COGNOS
12. Agregue un método get y set similar para los campos month y year. Lea la siguiente
indicación para ahorrar tiempo.
Indicación
La mayoría de los IDE crean automáticamente los métodos get y set para los campos
privados de una clase. Esto forma parte de una función denominada “refactorización”. En
NetBeans, puede aprovechar esta función seleccionando (resaltando) uno de los campos
privados y haciendo clic con el botón derecho en él. Seleccione Refactor > Encapsulate
Fields en el menú contextual.
ble
fe r a
ans
n - t r
o
s an
Se abre la ventana Encapsulate Fields. Active las casillas de control de los métodos get y
set para los campos restantes. Puede que también desee definir la configuración de
) ha eฺ
Javadoc en None para optimizar el código del método. Haga clic en Refactor para cerrar
la ventana y crear los métodos.
c o m uid
ฺ
ail ent G
m
g tud
@
16 is S
l l e
a e th
ฺ c
ra o us
e (
a ll se t
e l o C licen
a rc
M
Raul

COGNOS
13. Abra la clase DateThreeTest. ble

14. En el método main, declare un objeto de tipo DateThree denominado “date”. Cree una fe r a
ans
instancia de la clase DateThree.
n - t r
no
15. Con la referencia de objeto DateThree, llame a los métodos setMonth, setDay y
a
h a s
setYear del objeto DateThree para definir los tres valores de una fecha. Ejemplo:
date.setMonth(10);
m ) deฺ
date.setDay(16);
i l ฺ c o
G ui
date.setYear(2011);
g ma dent
16. Complete el método main mostrando 6
1 la@ S tu en el formato que desee. Por
fecha completa
ejemplo:
c a lle this
(
System.out.println(Ther aฺ udate se is: ”+ date.getMonth() +
a lle se to + “/” + date.getYear());
“/” + date.getDay()
17. Guarde ylo
C en
compile ielcprograma. Ejecute la clase DateThreeTest para realizar la prueba.
r c e l
M a
u l
Ra

COGNOS
Práctica de comprobación 11-2: Adición de validación a la clase

DateThree
Visión general
En esta práctica, agregará un método setDate a la clase DateThree que realiza la validación
en los valores de la parte de fecha que se transfieren al método.
Supuestos
En esta práctica, se asume que ha completado la práctica 11-1.
Tareas
1. En la clase DateThree, agregue un método setDate que tome tres argumentos de tipo ble
int. Estos valores se asignan a los campos day, month y year respectivamente, como
fe r a
en el siguiente ejemplo:
ans
n - t r
no
public void setDate(int d, int m, int y)
a
Realice la validación indicada en la siguiente tabla antes de asignar los valores de
s
a
argumento a los campos. Los pasos detallados se proporcionan a continuación de la tabla.
h
Paso Descripción del código o m ) Opciones
i d eฺ o valores
ilฺc1000 G u
a t
a. Valores válidos del campo year
@ gm tuden
Entre y 10000
b. 6 s S1 – 12
Valores válidos del campo month
e 1
c. a l day thi 30, 31, 28, 29
l
Valores válidos delccampo
( r aฺ use Depende del mes
l l
a nse e t o
Nota
o C
l sentencia eswitch case para determinar el valor month. Utilice sentencias
e
Utilice una
c l i c
M ar para realizar la validación. Muestre un mensaje de error si el valor no es válido.
if/else
ul a. En el método setDate, agregue la siguiente sentencia if/else para comprobar la
Ra validez del argumento year. Nota: El campo year se define en 0 en el caso de un
argumento year no válido. Comprobará un valor de year 0 más adelante.
if (y > 1000 && y < 10000){
this.year = y;
} else {
System.out.println(y + “ is not a valid year.”);
this.year = 0;
}

COGNOS
b. Cree una sentencia switch que evalúe el argumento month. Los meses 1, 3, 5, 7, 8, 10
y 12 tienen 31 días. Compruebe estos valores primero en la sentencia switch. Si el
argumento month es igual a cualquiera de estos casos, asigne el argumento month al
campo month y, a continuación, incluya una sentencia if/else para probar el valor del
argumento day. Debe estar entre 1 y 31, ambos incluidos. Si no lo está, muestre un
mensaje de error y defina el campo day en 0.
Ejemplo:
switch (m) {
case 1:
case 3:
case 5:
case 7:
case 8:
case 10:
case 12: ble
fe r a
this.month = m;
ans
if (d > 0 && d < 32){
n - t r
o
an
this.day = d;
} else {
s
ha eฺ
)
System.out.println(d + “ is an invalid day for “
m uid
+ month);
ฺ c o
this.day = 0;
m ail ent G
}
@ g tud
break;
l l e 16 is S
ฺ c a e th
//(switch statement continues in step c)
e ( ra o us
a ll se t
e l o C licen
a rc
M
Raul

COGNOS
c. Utilice la siguiente lógica para completar la sentencia switch. En el elemento case

block correspondiente al mes de febrero (case 2), también debe probar si el argumento
day es 29 para un año bisiesto. La lógica de los meses restantes es similar a lo que ha
escrito para los meses de 31 días.
...
case 2:
this.month = m;
if(d > 0 && d < 29) {
this.day = d;
} // check if year is a leap year when d==29 and m==2
else if (d == 29){
if(((y % 4 == 0) && !(y % 100 == 0)) || (y % 400 == 0)){
this.day = d;
} else {
ble
System.out.println(“Invalid day. “ +
fe r a
“Day cannot be 29 unless the year is a leap year.”);
ans
this.day = 0;
n - t r
o
an
} // end of inner if/else
} // end of outer if/else s
ha eฺ
break; )
m uid
ฺ c o
ail ent G
case 4:
case 6: m
g tud
case 9: @
16 is S
case 11: l l e
a e th
ฺ c
ra o us
this.month = m;
e (
ll se t
if(d > 0 && d < 31){
a
e l o C licen
this.day = d;
arc } else {
M
aul
System.out.println(“Invalid day. Must be 1 to 30.”);
R }
this.day = 0;
break;
default:
System.out.println(m + “ is an invalid month.”);
this.month = 0;
break;
} // end switch

COGNOS
2. Agregue un método denominado displayDate. En este método, primero compruebe los

valores de cero de day, month o year. Si cualquiera de ellos tiene un valor de 0, imprima
un mensaje que indique que la fecha no es válida. De lo contrario, muestre la fecha con el
formato de fecha que desee. Ejemplo:
public void displayDate(){
if(day == 0 || month == 0 || year == 0){

System.out.println(“Invalid date.”);
}
else {
System.out.println(“Date is: “ + month +”/”+
day +”/”+ year);
}
}
3. Abra la clase DateThreeTest y, con los métodos setDate y displayDate, escriba código ble
para realizar las siguientes pruebas: fe r a
ans
• Prueba con valores válidos para month, day y year
n - t r
• Prueba con un valor no válido para month: 14
a no
• Prueba con un valor no válido para day: 35
h a s
• Prueba con un valor no válido para year: 200
m ) deฺ
Ejemplo para la primera prueba:
i l ฺ c o
G ui
date.setDate(30,12,2011);
g ma dent
date.displayDate();
1 6 @ Stu
is DateThreeTest. Debería ver una salida
le lathclase
4. Guarde y compile el programaaylejecute
similar a la siguiente:
r c
aฺ use
(
a lle se to
e l o C licen
a rc
ul M
Ra
Compare la salida con el código para cotejar los mensajes con la prueba concreta
ejecutada.

COGNOS
Práctica 11-3: Creación de constructores para inicializar objetos
Visión general
En esta práctica, creará una clase y utilizará constructores para inicializar objetos.
Supuestos
En esta práctica, se asume que el archivo RectangleTest.java aparece en la carpeta de

prácticas de esta lección, D:\labs\les11 y, por lo tanto, en el proyecto Practice11.
Tareas
1. Cree una nueva clase Java denominada "Rectangle". Agregue dos campos private de
tipo int y asígneles el nombre width y height.
2. Agregue un constructor sin argumentos (un “constructor no-args”). La siguiente tabla
proporciona los principales pasos para crear este constructor. Si necesita más ayuda, siga
las instrucciones detalladas que aparecen a continuación de la tabla. ble
fe r a
Paso Descripción Opciones o valores
ans
a. Sintaxis para declarar un public <class_name>() n - t r
constructor no-args.
a no
b. Inicialice los campos privados. width = 25
h a s
height = 10 )
o m i d eฺwidth = 25, height = 10"
c. Imprima un mensaje.
a ilฺc nt Gu
“Default rectangle created:
a. En la clase Rectangle, declare un constructor

@ gm tpublic
u de no-args de la siguiente forma:
public Rectangle(){
l l e 16 is S
}
ฺ c a e th
b. Asigne el campo width
e ( ra alovalor
t us25 y el campo height al valor 10.
C all nse
c. Utilice System.out.println para mostrar el mensaje que aparece en el paso b de la
tablalo
anterior. e
rceun segundo lic constructor que acepte dos argumentos int: w y h (para “width” y
a
3. Agregue
ul M“height”). La siguiente tabla proporciona los principales pasos para completar este
Ra constructor. Si necesita más ayuda, siga las instrucciones detalladas que aparecen a
continuación de la tabla.

a. Defina height en h y width en w h y w deben ser > 0 y < 30.
después de validar los valores de
argumento.
b. Muestre un mensaje para cada Mensaje de error si los números no son
condición. válidos.
Mensaje que indica que se ha creado un
rectángulo (muestra el ancho y la altura).
a. En el constructor, agregue una sentencia if/else para asegurarse de que los valores
transferidos al constructor están en un rango aceptable del 1 al 29. Si ambos argumentos
son válidos, asigne el argumento al campo de miembro correspondiente.

COGNOS
b. Después de asignar los valores, imprima un mensaje que indique que se ha creado un
rectángulo con los valores designados. Incluya los valores width y height en el
mensaje. Si los valores de argumento no son válidos, muestre un mensaje de error.
Solución:
public Rectangle(int w, int h){
if(w > 0 && w < 30 && h > 0 && h < 30){

width = w;
height = h;
System.out.println("Rectangle created: width = "
+width+ " and height = "+height);
}
else {
System.out.println(“Invalid width and/or height. “+
“Each must be positive and less than 30.”);
ble
}
fe r a
}
t r a ns
4. Cree un método getArea que calcule y devuelva el área del rectángulo (width
o n -* height).
s an
Solución:
) ha eฺ
public int getArea(){
c o m uid
return width * height;
ฺ
ail ent G
m
g tud
}
@
1la6forma irectangular,
S
5. Cree un método draw que imprima l l e
aasteriscos t h s como lo determinan el ancho y la
r a c
altura, en una serie de filasฺcon s e (*). En los siguientes pasos se proporcionan
(
instrucciones más detalladas: o
e et u
a. Cree un C allanidado
bucle n s for para dibujar el rectángulo con asteriscos.
l o e
lic for itera con las filas del rectángulo. El número de filas corresponde al
b. rEl
a cebucle externo
ul M valor del campo height.
R a c. El bucle interno for itera con las columnas de cada fila. El número de columnas
corresponde al valor del campo width.
Solución:
public void draw(){
for(int rowCounter=0;rowCounter<height;rowCounter++){
for(int colCounter=0;colCounter<width;colCounter++){
System.out.print(“*”);
} // end of each row
System.out.println(); // create a new line
} // end of all rows
} // end of draw method

COGNOS
7. Abra la clase RectangleTest. En el método main, declare y cree dos objetos Rectangle, r1
y r2:
• r1 se crea con el constructor no-args.
• r1 se dibuja inmediatamente después de crearlo (utilice el método draw).
• r2 se crea con el constructor con argumentos.
• r2 se dibuja y se imprime el área.
Solución:
public static void main(String args[]){
// Rectangle with default values (no args)
Rectangle r1 = new Rectangle();
r1.draw();
//Rectangle from args constructor
ble
Rectangle r2 = new Rectangle(15,5);
fe r a
System.out.println(“Area of r2 is: “+r2.getArea());
ans
r2.draw();
n - t r
}
a no
a
8. Guarde y compile el programa. Ejecute la clase RectangleTest para
h srealizar la prueba. La
salida se debe parecer a la siguiente:
m ) deฺ
i l ฺ c o
G ui
g ma dent
1 6 @ Stu
c a lle this
( r aฺ use
a lle se to
e l o C licen
a rc
ul M
Ra

COGNOS
ble
fe r a
ans
n - t r
o
s an
) ha eฺ
c o m uid
ฺ
ail ent G
m
g tud
@
16 is S
l l e
a e th
ฺ c
ra o us
e (
a ll se t
e l o C licen
a rc
M
Raul

COGNOS
ble
fe r a
ans
n - t r
a no 12:
Descripción de h a s
conceptos
orientadoso ma
) objetos
i d eฺ
a ilฺc nt Gu
avanzados
g tude m
1 @
6 s S 12
Capítulo
a l l e t h i
r c
aฺ use
(
a lle se to
e l o C licen
a rc
M
Raul
Prácticas para la lección 12: Descripción de conceptos orientados a objetos avanzados

COGNOS

En estas prácticas, diseñará y creará una jerarquía de clases para el sistema de seguimiento
de empleados del departamento de marketing de la compañía Duke’s Choice. Además, creará
una interfaz y la implantará en las clases creadas. Las soluciones de estas prácticas se
encuentran en D:\labs\soln\les12.
ble
fe r a
ans
n - t r
o
s an
) ha eฺ
c o m uid
ฺ
ail ent G
m
g tud
@
16 is S
l l e
a e th
ฺ c
ra o us
e (
a ll se t
e l o C licen
a rc
M
Raul

COGNOS
Práctica 12-1: Creación y uso de superclases y subclases
Visión general
En esta práctica, diseñará y creará una jerarquía de clases para formar la base de un sistema
de seguimiento de empleados en el departamento de marketing de la compañía Duke’s Choice.
Esta práctica consta de dos secciones. En la primera sección, creará un modelo de diseño
simple para la jerarquía de clases. En la segunda sección, creará las clases reales y las
probará.
Supuestos
En esta práctica, se asume que el siguiente archivo aparece en la carpeta de prácticas de esta
lección, D:\labs\les12:
• EmployeeTest.java
Diseño de la jerarquía de clases

ble
En esta sección, diseñará subclases y superclases con la información que se detalla a
continuación. fe r a
ans
El departamento de marketing de la compañía Duke’s Choice cuenta con empleados en
n - t r
distintos puestos de trabajo. Algunos de estos puestos son: Technical Writer, Graphic o
Illustrator, Manager y Editor.
s an
ha eฺ
El departamento de marketing le solicita que cree un programa para realizar un seguimiento de
)
c o m uid
la información sobre los trabajadores. Esta información incluye el nombre del trabajador, el
ฺ
ail ent G
cargo, el ID de empleado y el nivel (1, 2 o 3). Además:
• m
g tud
Los empleados con el cargo Manager deben tener una lista de los empelados a los
que gestionan. @
16 is S
• l l e
a e th
Los empleados con los cargos Technical Writer, Graphic Illustrator y Editor deben
ฺ c
tener una lista de las habilidades que posean.
ra o us
e (
• ll se t
Los empleados con el cargo Editor deben disponer de un valor para indicar si prefieren
a
o C licen
realizar la edición de forma electrónica o en papel.
• e l
Debe haber una forma de mostrar toda la información sobre un tipo de empleado
a rc
determinado.
l M
Rau1. Cree una jerarquía de clases de relaciones de superclases y subclases para los empleados
del departamento de marketing. Dibuje el diagrama en una hoja de papel, o bien, si lo
prefiere, utilice la herramienta UMLet en el escritorio.
Indicaciones
• Utilice la frase “es un/una”: pregúntese si todos los tipos de trabajos o algunos de
ellos coinciden en algunos atributos (campos) y operaciones (métodos). Por ejemplo,
los distintos tipos de trabajos mencionados anteriormente también se pueden
considerar empleados (en el sentido general) ya que comparten determinados campos
y operaciones. Por tanto, una persona con el cargo Manager “es un” empleado.
Asimismo, una persona con el cargo Editor “es un” empleado.

COGNOS
• Considere la posibilidad de crear una superclase temporal: si observa que

determinados tipos de empleados tienen campos u operaciones en común que no
comparten con otros tipos de empleados (por ejemplo, una lista de habilidades),
aunque son todos empleados, tenga en cuenta la posibilidad de crear una superclase
común para estos empleados: se heredaría de la superclase de nivel superior de
empleado.
• Visualización de la información: recuerde que muchos de los campos que se

mostrarían serían comunes a todos estos empleados (por ejemplo, el nombre, el cargo
y el ID de empleado). Puede mostrar esta información común a partir de la superclase
de nivel superior. En la subclase, solo tiene que completar la información mostrada por
la superclase con los campos que son únicos para ese tipo de empleado concreto.
− Nota: esto se logra mediante la sustitución del método de la superclase y la
llamada al método sustituido desde el método de la subclase, que añade más
código para mostrar campos adicionales.
• Encapsulación: muestre la encapsulación de las clases del diseño mediante la
inclusión de los métodos get y set en cada campo privado, según el tipo de acceso
ble
que sea necesario.
fe r a
• Modelado: modele la jerarquía de clases con un diagrama de clases similar al que ha
ans
visto en esta lección.
n - t r
o
Solución: s an
) ha eฺ
c o m uid
ฺ
ail ent G
m
g tud
@
16 is S
l l e
a e th
ฺ c
ra o us
e (
a ll se t
e l o C licen
a rc
ul M
Ra

COGNOS
Creación de las clases

2. En NetBeans, cree un proyecto nuevo a partir de los orígenes existentes denominado
Practice12. Defina Source Package Folders para que apunte a D:\labs\les12.
Recuerde definir la propiedad Binary Source Format del proyecto. Si necesita más
información, consulte la práctica 2-2, pasos 3 y 4.
3. Antes de empezar a crear las clases, cambie una propiedad de NetBeans IDE. La
propiedad Add @Override Annotation del editor resulta útil a la hora de crear
documentación Java para la aplicación. Esta propiedad se aplica cuando se sustituye un
método en la superclase. Puesto que no se va a crear documentación Java en este curso,
desactive esta propiedad ya que únicamente desvaría la atención de nuestro objetivo. Para
realizar este cambio, realice los pasos siguientes:
a. Seleccione Tools > Options en el menú principal.
b. En la ventana Options, haga clic en el botón Editor de la barra de herramientas y, a
continuación, haga clic en el separador Hints.
c. Cambie Language a Java. Las indicaciones de la columna de la izquierda cambian ble
según corresponda. fe r a
ans
d. Amplíe el nodo JDK 1.5 and later. Debajo de este nodo, anule la selección de Add
@Override Annotation. n - t r
o
e. an
Haga clic en OK para guardar el cambio y cerrar la ventana Options.
s
) ha eฺ
c o m uid
ฺ
ail ent G
m
g tud
@
16 is S
l l e
a e th
ฺ c
ra o us
e (
a ll se t
e l o C licen
arc
M
Raul

COGNOS
4. Cree la clase Employee que se muestra en el diagrama anterior. En los siguientes pasos
se proporciona más información.
a. Los campos que se muestran en el diagrama deben ser privados. Asegúrese de utilizar
el mismo patrón de nomenclatura que ha utilizado anteriormente (camelCase).
b. Utilice la función Refactor de NetBeans para encapsular los campos (cree métodos get y
set para todos los campos). Cambie el modificador de acceso del método
setEmployeeID a private.
− Nota: los ID de empleado se calculan para asegurar la unicidad y debe restringir el
acceso de escritura público a este campo para que los ID sean siempre únicos.
Los valores de ID sólo los define el método calculateEmployeeID.
c. Agregue otro campo, el cual no se muestra en el diagrama, denominado
employeeIDCounter. Conviértalo en un campo protected static int e
inicialícelo en 0 (cero).
Nota
Un campo static es un campo de clase. Sólo hay un valor para este campo que
ble
comparten todas las instancias de la clase. El campo static se utiliza aquí para
fe r a
almacenar un valor entero que se incrementa mediante el método
ans
calculateEmployeeID para generar el siguiente valor de ID. Todas las instancias de
n - t r
que asegura que no se generen ID de empleado duplicados. a no
Employee y sus subclases acceden al campo employeeIDCounter y lo incrementan, lo
h a s
) deฺ
En una aplicación de negocio real, esta técnica no sería lo suficientemente segura como
m
i l ฺ o
G ui
para garantizar la creación de ID únicos. En su lugar, probablemente sería una base de
c
datos la que generara los ID. Sin embargo, esta técnica es suficiente para nuestra sencilla
aplicación. g ma dent
6 @ Stu
d. Cree el método calculateEmployeeID. No toma argumentos y no devuelve ningún
1
c a lle this
valor. En el cuerpo de este método, incremente employeeIDCounter y, a continuación,
( r aฺ use
defina el valor nuevo en el campo employeeID (utilice el método set del campo).
e. Cree el método
a e to
lledisplayInformation. No toma argumentos y no devuelve ningún
valor. EnC s
en imprima el valor de los campos de la clase con una etiqueta
o estelimétodo,
e l
adecuada. c
a rc :
ul M
Solución
Ra public class Employee {

protected static int employeeIDCounter = 0;
private int employeeID;
private String name;
private String jobTitle;
private int level;
public void calculateEmployeeID() {

employeeIDCounter++; // inc so employeeID is unique
setEmployeeID(employeeIDCounter);
}
public void displayInformation() {

System.out.println("Name: " + getName());

COGNOS
System.out.println("Job Title:" + getJobTitle());

System.out.println("Employee ID: " +
getEmployeeID());
System.out.println("Level: " + getLevel());
}
// The set and get methods are not shown here

}
f. Haga clic en Save para compilar la clase.
5. Cree la clase Manager del diagrama. En los siguientes pasos se proporciona más
información.
a. Una vez creado el nuevo archivo de clase Java, agregue la siguiente expresión
(mostrada en negrita a continuación) a la declaración de clase para indicar que se trata
de una subclase de Employee: e
public class Manager extends Employee { r a bl
s fe
b. Declare e instancie el campo employeeList como ArrayList privada (en lugar de la
matriz del tipo Employee indicada en el diagrama). Es más sencillo trabajar de esta - t r an
forma en lugar de utilizar una matriz. no n
s a
private ArrayList employeeList = new ArrayList();
c. Agregue la sentencia import necesaria para importar la) clase. eฺ h a
c o m uid
java.util.ArrayList. ฺ
ail eizquierdo
t G para que NetBeans
Indicación: haga clic en el icono de error en el m margen n
agregue la sentencia de importación. @g ud
6 S t
d. Agregue un método setEmployee
a l l e1 público
t h i s para agregar un único empleado a
employeeList. El método
r ฺc toma
aagregar u eun argumento
sobjeto de tipo Employee. Utilice el método add
de ArrayList para ( to el Employee al objeto employeeList.
a llesetEmployee(Employee
s e
o C
public void
e n emp){
r c el employeeList.add(emp);
lic
a }
ul MPregunta: ¿Qué validación puede que sea necesario realizar en este método en una
Ra aplicación real?
e. Agregue un método getEmployees público que devuelva únicamente el valor de
employeeList.
public ArrayList getEmployees(){
return employeeList;
}

COGNOS
f. Agregue un método displayInformation para sustituir el método en la clase

Employee. En este método, llame al método displayInformation de la superclase y,
a continuación, muestre información adicional específica de la clase Manager.
i. Declare el método con exactamente la misma firma que el método de la
superclase (que devuelva un valor nulo y no acepte argumentos). NetBeans
muestra un icono de un círculo verde en el margen una vez que haya introducido
la declaración del método. Esto indica que el método sustituye al método de la

superclase. Al hacer clic en el círculo verde, se abre la clase Employee en el
editor para mostrar el método ascendiente. En ocasiones, esto puede resultar
útil.
ii. En el bloque de método, llame al método de la superclase mediante la palabra
clave super como referencia a la clase Employee.
iii. Muestre el siguiente mensaje: “Manager has the following employees: “
iv. A continuación, itere con employeeList mediante un bucle for mejorado.
Recuerde que employeeList es una ArrayList que contiene elementos
Object. El compilador no sabe que dichos elementos Object son objetos de
ble
Employee. Por tanto, para obtener el campo name de cada objeto para
fe r a
mostrarlo, debe convertir el valor Object en un Employee (un empleado “es un”
ans
objeto). Declare una variable local en la parte superior del método del tipo
Employee. Aquí se incluye el valor convertido. El código de este método se n - t r
indica a continuación: a no
h a s
public void displayInformation(){
m ) deฺ
Employee emp;
l ฺ c o u i
// Invoke the ancestor methoda i G
g m dent
super.displayInformation();
System.out.println 16
@ Stu
a is
lle thethfollowing
(“The manager
a ฺ c has
s e employees: “);
l e (r to u
l
a nobj se : employeeList){
o C
for(Object
e
r c el ic Cast the object as an Employee
l//
M a emp = (Employee)obj;
a ul // print the name, indented by a tab

R System.out.println(“\t“ + emp.getName());
}
}
g. Guarde y compile el programa.
6. Cree la clase SkilledEmployee del diagrama. Esta clase también debe ampliar Employee.
a. Utilice una ArrayList en lugar de una matriz String al declarar el campo skillList.
Instancie el campo en una ArrayList vacía.
private ArrayList skillList = new ArrayList();
b. Agregue la sentencia import necesaria de importación para la clase ArrayList.
c. Agregue un método setSkill público para agregar una única habilidad a skillList.
El método toma un argumento de tipo String. Utilice el método add de ArrayList
para agregar el objeto String al objeto skillList.

COGNOS
d. Agregue un método getSkills público que devuelva el valor de skillList.

e. Sustituya el método displayInformation como lo hizo en la clase Manager. Después
de llamar al método de la superclase, muestre el siguiente mensaje: “Employee has the
following skills: “. Itere con skillList mediante un bucle for mejorado, mostrando
cada habilidad y con un sangrado realizado con el tabulador como lo hizo en la clase
Manager.
− Nota: el objeto skillList contiene objetos String. En este caso, puede

imprimir directamente la referencia de Object desde la ArrayList sin convertirla
en un objeto String. Esto se debe a que todos los elementos Object tienen un
método toString al que llama el método println, lo que da como resultado la
visualización del valor String (es decir, la habilidad).
f. Haga clic en Save para compilar el programa.
− Nota: consulte el archivo de soluciones de la clase SkilledEmployee en caso de
que necesite ayuda.
7. Cree la clase Editor como una subclase de SkilledEmployee.
b le
a. Declare el campo prefersPaperEditing como private boolean. (Se inicializafen e r a
el valor false por defecto). n s
b. Agregue un método setPrefersPaperEditing que tome un argumento n - tra
boolean y
devuelva void. Asigne el argumento al campo privado. a no
c. Agregue un método getEditingPreference que devuelva h a s valor String. Utilice
un
una construcción if/else para comprobar el valor de
o m i d eฺ
)prefersPaperEditing y
ฺ c
il nt G
defina el valor de retorno en “Paper” o “Electronic”. u
d. Sustituya el método displayInformation m acomo elo hizo en la clase Manager. Para
ello, llame en primer lugar al método @ de
gla superclase
t u d y, a continuación, muestre el valor
1 6 S
c a lle this
de retorno de this.getEditingPreference() con una etiqueta adecuada.
e. Haga clic en Save para
( r aฺ compilar
u seleprograma.
− Nota: consulte
a e to de soluciones de la clase Editor en caso de que necesite
lle elsarchivo
ayuda.
l o C en
8. Creerc e licrestantes del diagrama: GraphicIllustrator y TechnicalWriter. Estas dos
las dos clases
a
ul Madicionales ni sustituir el método displayInformation.
clases amplían la clase SkilledEmployee. No es necesario agregar campos o métodos
Ra 9. Guarde y compile el programa.

10. Abra la clase EmployeeTest en el editor y examine el código.
Nota
Si existen indicadores de error, compruébelos para asegurarse de que ha escrito todos los
nombres de método tal y como aparecen en la clase. Si aún existen indicadores de error
después de realizar cambios, intente volver a hacer clic en el botón Save, o bien, intente
hacer clic en una línea de EmployeeTest que indique un error. Esto recuerda al
comprobador de sintaxis de NetBeans que intente resolver las referencias una vez más.

COGNOS
11. Ejecute la clase EmployeeTest para probar el programa. Debería ver una salida similar a la
siguiente captura de pantalla:
ble
fe r a
ans
n - t r
o
s an
) ha eฺ
c o m uid
ฺ
ail ent G
m
g tud
@
16 is S
l l e
a e th
ฺ c
ra o us
e (
a ll se t
e l o C licen
a rc
M
Raul

COGNOS
Práctica 12-2: Uso de una interfaz Java
Visión general
En esta práctica, creará una interfaz llamada Printable y la implantará en la jerarquía de clases
que ha creado en la práctica 12-1. Además, examinará y ejecutará otra pequeña aplicación que
utilice la misma interfaz Printable para comprender mejor las ventajas del uso de las interfaces.
Supuestos
esta lección, D:\labs\les12:
• Printer.java
• Country.java
• Region.java
• Company.java
• CompanyTest.java ble
fe r a
Tareas ans
n - t r
1. Cree una interfaz Java nueva con el asistente File de NetBeans. o
s an
a. Haga clic con el botón derecho en Practice12 en la ventana Projects.
b. Seleccione New > Java Interface en el menú emergente. ) ha eฺ
c o mse muestra.
uid
c. Introduzca Printable en el campo Class Name i l ฺ como G
g ma dent
1 6 @ Stu
c a lle this
( r aฺ use
a lle se to
e l o C licen
a rc
ul M
Ra
d. Haga clic en Finish.


COGNOS
2. En la interfaz Printable, declare un método public abstract denominado print. Debe

devolver void y no aceptar argumentos.
public abstract void print();
3. Haga clic en Save.
4. Implante la interfaz Printable en la clase Employee.
Nota: recuerde que el resto de las clases de esta jerarquía son subclases de Employee y,
por tanto, también implantan Printable mediante la herencia.
public class Employee implements Printable {
5. El comprobador de sintaxis muestra ahora un icono de error en el margen de esta línea.
Mueva el cursor sobre el icono de error para ver el posible error de compilación que
reconoce.
ble
fe r a
ans
n - t r
a no
Explicación: las clases no abstractas que implantan una interfaz deben implantar también
los métodos abstractos de la interfaz. En este caso, el único método abstracto de Printable
es print. h a s
m ) deฺ
6. Cambie el nombre del método displayInformation
i l ฺ c o
a print.
G ui
7. Realice el mismo cambio (displayInformation
g ma a print) e n t en las siguientes clases para
asegurarse de que también implantan el@
6 t ud Además, debe cambiar el nombre
método print.
S
del método de superclase llamado
a l l een1 la primera
t h i s línea del nuevo método print. (Ya no se
( r aฺc use
denomina displayInformation).
• Manager
a lle se to
• C en
SkilledEmployee
l o
c e
• rEditor lic
a
u8.l MAbra la clase Printer en el editor y examine el único método que incluye: printToScreen.
Ra Observe que este método toma un argumento de tipo Printable. Las clases que
implanten Printable se aceptarían como argumentos. Este método llama al método print
del objeto Printable.
public void printToScreen(Printable p){
p.print();
}
9. En el método main de la clase EmployeeTest, realice los cambios siguientes:
• Declare y cree una instancia de la clase Printer.
• En todas las invocaciones del método displayInformation, comente la línea y, en
su lugar, llame al método printToScreen del objeto Printer. Transfiera una
referencia al objeto Printable como se muestra a continuación:
//myManager.displayInformation();
myPrinter.printToScreen(myManager);

COGNOS

11. Ejecute la clase EmployeeTest y examine la salida. Debería ser idéntica a la salida que vio
antes de implantar la interfaz.
Análisis
Una de las ventajas del uso de interfaces es que puede extraer una funcionalidad utilizada en
distintas aplicaciones y diferentes jerarquías de clases. Esta funcionalidad se mueve a la

interfaz y, de esta forma, se puede utilizar allá donde sea necesaria. Por ejemplo, en esta
práctica, la capacidad de mostrar campos de clase con etiquetas y formato se ha movido a la
interfaz Printable.
Ahora probará las ventajas con distintas aplicaciones mediante la ejecución de una aplicación
diferente que también implante Printable. La jerarquía de clases Company muestra información
sobre la gestión de nivel superior de Duke’s Choice así como de la gestión regional y de las
divisiones. El código es muy similar al que vio en la jerarquía Employee.
12. Cierre todas las clases en las que ha estado trabajando y abra las siguientes clases en el
editor:
ble
• Company
fe r a
• Region
ans
• Country n - t r
• CompanyTest a no
h a s de Region y
) deฺ en la jerarquía
13. En primer lugar, examine la clase Company. Se trata de la superclase
m
Country. Observe que implanta la misma interfaz Printable
Employee. i l ฺ c o
G ui
que ha utilizado
m a ent
g ud
14. Examine también las clases Region, Country y CompanyTest.
@ t
6 S
15. Ejecute la clase CompanyTest para
a l le1ver lathsalida
is de esta aplicación.
( r aฺc use
a lle se to
e l o C licen
a rc
ul M
Ra

COGNOS

Ha recibido una introducción a las interfaces Java, una de las herramientas más valiosas del
lenguaje Java. Este tema se trata con mayor detalle en la clase Programación Java SE7.
ble
fe r a
ans
n - t r
o
s an
) ha eฺ
c o m uid
ฺ
ail ent G
m
g tud
@
16 is S
l l e
a e th
ฺ c
ra o us
e (
a ll se t
e l o C licen
a rc
M
Raul

COGNOS
ble
fe r a
ans
n - t r
no 13:
a
has
Manejo de errores
) deฺ
c o m ui
i l ฺ G Capítulo 13
g ma dent
1 6 @ Stu
c a lle this
( r aฺ use
a lle se to
e l o C licen
a rc
M
Raul
Prácticas para la lección 13: Manejo de errores

COGNOS

En estas prácticas, experimentará con el manejo de excepciones comprobadas. En la primera
práctica, manejará una excepción devuelta por una de las Java Foundation Classes. En la
segunda práctica, capturará y devolverá una clase de excepción personalizada. Las soluciones
de estas prácticas se encuentran en D:\labs\soln\les13.
ble
fe r a
ans
n - t r
o
s an
) ha eฺ
c o m uid
ฺ
ail ent G
m
g tud
@
16 is S
l l e
a e th
ฺ c
ra o us
e (
a ll se t
e l o C licen
a rc
M
Raul

COGNOS
Práctica 13-1: Uso de un bloque try/catch para manejar una

excepción
Visión general
En esta práctica, utilizará la documentación de la API de Java para examinar la clase
SimpleDateFormat y buscar la excepción devuelta por el método parse. A continuación, creará

una clase que llame al método parse con un bloque try/catch para manejar la excepción.
Supuestos
En esta práctica, se asume que el siguiente archivo aparece en la carpeta de prácticas de esta
lección, D:\labs\les13:
• DateTest.java
Tareas
1. En NetBeans, cree un proyecto nuevo a partir de los orígenes existentes denominado ble
Practice13. Defina la carpeta Source Package Folders para que apunte a fe r a
D:\labs\les13. Recuerde definir la propiedad Binary Source Format del proyecto. Si ans
necesita más información, consulte la práctica 2-2, pasos 3 y 4. n - t r
a no
Existen muchos archivos en este proyecto, pero sólo la clase DateTest es relevante para
esta práctica. h a s
m ) deelฺacceso directo del
2. Abra la documentación de especificación de la API de Java
escritorio. i l ฺ c o
G ui
mediante
m a ent
@ g
3. Busque la clase SimpleDateFormat en el paquete java.text.
t ud duranteEstala aplicación
clase le permite
seleccionar un formato de fecha estándar
e 1 6 que
s S
se utilizará del formato
y el análisis. Por ejemplo, puede l l
a basado
aplicar t h i
formato a la salida de String de un objeto Date y
r a
analizar (o crear) un objeto ฺ c
Date s e en una representación String con formato de la
( u
fecha.
a lle se to
e l o C licen
a rc
ul M
Ra

COGNOS
4. Los siguientes pasos le guiarán para examinar la documentación de SimpleDateFormat.

a. Busque el método parse y haga clic en él. Como puede ver, este método tiene dos
argumentos. En esta práctica, llamará a un método parse más simple que pertenece a
la superclase, DateFormat, en lugar de utilizar el método parse que aparece aquí. El
método de la superclase no es private y, por tanto, está disponible para un objeto
SimpleDateFormat.
b. En la sección Specified by, haga clic en el enlace parse que se muestra a continuación
para acceder a la documentación de DateFormat para este método.
ble
fe r a
ans
n - t r
a no
h a s
m ) deฺ
i l ฺ c o
G ui
c. La documentación Java muestra ahora unm a parse
método
e n t de dos argumentos similar en
@
la clase DateFormat. Desplácese hacia g ud el método parse de un argumento
arriba thasta
6 S
a l le1método.
situado directamente sobre este
t h is
r c
aฺ use
(
a lle se to
e l o C licen
a rc
ul M
Ra
d. Observe que este método parse acepta un único argumento String y devuelve un
objeto Date. Si las hay, ¿qué excepciones se devuelven?

COGNOS
e. ¿Es ParseException una excepción comprobada (que se debe capturar o devolver)?

Haga clic en el enlace ParseException para ver la jerarquía de clases. ¿Es una subclase
de Exception? En caso afirmativo, se trata de una excepción comprobada y se debe
manejar en el programa.
f. Haga clic dos veces en el botón Back del explorador para volver a la documentación de ble
SimpleDateFormat. fe r a
g. Busque el método format. El método format acepta tres argumentos. Una vez más, ans
hay una versión más simple de este método definida en la clase DateFormat que utiliza n - t r
no
en esta práctica. Haga clic en el enlace format situado bajo la cabecera Specified by
a
para ver la documentación de DateFormat de este método.
h a s
h. m ) deฺ
Desplácese hacia abajo para buscar el método format de un argumento. Observe que
i l ฺ c o ui
acepta un único argumento de objeto Date y devuelve un valor String. ¿Devuelve este
G
ma dent
método format alguna excepción? (Respuesta: No).
g
5. En NetBeans, cree una nueva clase Java
1 6 S tu “DateManipulator”. Proporcione las
@denominada
le enthlaistabla siguiente. Encontrará más instrucciones
declaraciones de campo que se lindican
a
detalladas a continuación de
r c
aฺ use
la tabla.
(
e e todel código
Paso a llDescripción
s Opciones o valores
a.
C
lDeclare n
o liuncecampo de tipo Date. Nombre: myDate
r c e
Mb.a Declare e instancie un campo de tipo Nombre: simpleDF
u l SimpleDateFormat con la
Ra especificación del formato por defecto en
Formato por defecto: “MM/dd/yyyy”
el constructor.
c. Agregue las sentencias de importación java.util.Date
necesarias. java.text.SimpleDateFormat
a. Declare un campo de tipo Date con el nombre de variable myDate.
b. Declare un campo de tipo SimpleDateFormat denominado simpleDF. Utilice el
operador new para instanciar (crear un objeto) el campo SimpleDateFormat en la misma
línea que la declaración. Especifique el formato por defecto para este objeto. Para ello,
transfiera la cadena de formato al constructor de objetos tal y como se muestra a
continuación.
SimpleDateFormat simpleDF =new SimpleDateFormat(“MM/dd/yyyy”);

COGNOS
c. Haga clic en los iconos de error que aparecen junto a estas líneas de código. Seleccione
la opción para agregar las sentencias import necesarias. Existen dos posibles objetos
Date que se pueden importar. Elija java.util.Date.
6. Agregue un método público denominado parseDate que acepte un argumento String
denominado dateString y devuelva void.
Nota: este método crea una instancia de objeto Date mediante la llamada al método
parse. Aplica formato al objeto Date de acuerdo con el formato por defecto del objeto
SimpleDateFormat y muestra la cadena de resultado. Asimismo, muestra el formato de
fecha nativo del objeto Date para su comparación. Además, el método maneja
ParseException mediante un bloque try / catch.
7. Siga los pasos principales que se muestran en la tabla siguiente para trabajar en el código
del método parseDate. Encontrará pasos más detallados a continuación de la tabla.

a. Declare una variable String local. Nombre: formattedDateString
bl e
b. Llame al método parse del objeto Transfiera dateString como el argumentofe r a
n s
-tra myDate.
SimpleDateFormat. String.
Por el momento, ignore el signo de aln
Asigne el valor de retorno o campo
error.
s an
c. Muestre un mensaje que indique
) ha eฺ
que el método parse es correcto.
c o m uid
d. Muestre el objeto date con formato a
ฺ
il neltobjeto
Imprima G Date con una etiqueta
nativo.
m
g adecuada. de
@ t u
e. Llame al método format
l l e 1del6objetois SAsigne el valor de retorno a
SimpleDateFormat ฺ c a la e th formattedDateString.
con
ramyDate
transferencia(de s
ucomo
e
all delnmétodo.t o
argumento
o C e se
lMuestrelilac cadena de fecha con
rce
f.
M a formato con una etiqueta adecuada.

l
u g.
Ra
Incluya el código anterior en un try{
bloque try. // lines of code here
}
h. Capture ParseException y muestre catch (ParseException ex) {
el objeto de excepción. // display the ex object here
}
i. Agregue la sentencia de importación java.text.ParseException
que falta.
a. Declare una variable String local denominada formattedDateString. Se utilizará
para contener la representación String del objeto Date con formato.

COGNOS
b. Llame al método parse del objeto simpleDF con la transferencia del argumento
dateString del método al método parse. Este método devuelve un objeto Date, por lo
que debe asignar el valor de retorno a myDate. Seguramente observe un icono de error
en el margen izquierdo para esta línea de código. Coloque el cursor sobre él para ver el
mensaje de advertencia. Agregará un bloque try/catch más tarde para corregir este
problema.
c. Utilice System.out.println para imprimir el mensaje “Parse successful”.

d. De nuevo, utilice System.out.println para imprimir myDate junto con el mensaje
“Date with native format: “. (Indicación: Java Virtual Machine llamará al método
toString del objeto Date).
e. Llame al método format del objeto simpleDF. Transfiera myDate como argumento al
método. Asigne el valor de retorno a formattedDateString.
formattedDateString = simpleDF.format(myDate);
f. Muestre formattedDateString con una etiqueta adecuada. Sugerencia “Formatted
date: “ + formattedDateString.
ble
g. Ahora corregirá el error relacionado con el bloque try/catch que falta. Incluya las
fe r a
líneas de código anteriores en un bloque try.
ans
−
Indicación: haga clic con el botón derecho en cualquier parte del editor y
n - t r
seleccione Format para corregir el sangrado del código.
a no
h a s
h. En la siguiente línea después de la llave de cierre del bloque try, agregue un bloque
) deฺ
catch que capture ParseException y muestre el objeto de excepción en la pantalla.
m
ฺ c o ui
i. Haga clic con el botón derecho en el icono de error en el margen izquierdo y permita que
i l G
ma dent
NetBeans proporcione la sentencia de importación que falta (java.text.ParseException).
g
Solución:
1 6 @ Stu
public void parseDate(String
a l is
le thmyDate){
try{
r c
aฺ use
( to
a lle =ssimpleDF.parse(dateString);
String formattedDateString;
e
e l o CSystem.out.println("Parse
myDate
l i c en
arc
successful");
ul M System.out.println("Date with native format: "
R a + myDate);
formattedDateString = simpleDF.format(myDate);
System.out.println("Formatted date: "
+ formattedDateString);
}catch (ParseException ex) {
System.out.println(ex);
}
}
9. Abra la clase DateTest y examínela. Sustituya la fecha entre las comillas en la llamada al
método parseDate. Utilice el formato “MM/dd/yyyy”, tal y como se especifica en el
comentario.

COGNOS
11. Ejecute DateTest y compruebe la salida. Si la fecha tiene el formato correcto, la excepción
ParseException no aparecerá en la salida. Sin embargo, debería ver la diferencia entre el
formato de fecha nativo y el efecto de la clase SimpleDateFormat en el formato de la
misma fecha.
12. Ahora, cambie el valor del argumento del método parseDate en DateTest para que se
revierta a una cadena vacía (“”). Guarde y compile el programa.
13. Vuelva a ejecutar la clase DateTest. Esta vez, se devolverá la excepción ParseException y
debería ver el mensaje del objeto de excepción en la salida.
ble
fe r a
ans
n - t r
a no
h a s
m
Nota: observará que el mensaje “Parse successful” no aparece.
ฺ
) Estadevisualización
o i
u al método parse.
a ilฺc de
concreta se produjo en la línea inmediatamente después
tlaG
llamada
catch y el resto de las líneas de código@del bloquetu denonsefue

gm el programa
Cuando el método parse devolvió la excepción, inmediatamente al bloque
ejecutaron.
16 is S
try
l l e
a e th
ฺ c
ra o us
e (
a ll se t
e l o C licen
a rc
ul M
Ra

COGNOS
Práctica 13-2: Captura y devolución de una excepción personalizada
Visión general
En esta práctica, utilizará una excepción personalizada denominada “InvalidSkillException”. La
utilizará con la aplicación de seguimiento de empleados diseñada y creada en las prácticas
12-1 y 12-2. Devolverá la excepción InvalidSkillException en un método y la capturará en el
método de llamada.
Se proporciona un nuevo juego de archivos de origen Java para la jerarquía Employee para su
uso en esta práctica.
Supuestos
esta lección y, por tanto, en el proyecto Practice13:
• Editor.java
• Employee.java e
• EmployeeTest.java r a bl
s fe
• GraphicIllustrator.java
- t r an
• InvalidSkillException.java
no n
• Manager.java
s a
• Printable.java h
) deฺa
• Printer.java
c o m ui
i l ฺ G
• SkilledEmployee.java
g ma dent
• TechnicalWriter.java
1 6 @ Stu
Tareas c a lle this
Suponga que hay una lista (de r ฺ deuhabilidades
atipos se válidas que se pueden asociar a un rol de
trabajo concreto en el a l l e
sistema e
de t o
seguimiento de empleados. En el método setSkill (que
pertenece a lalo C n s
e de habilidadestransferido
clase SkilledEmployee), necesario realizar algún tipo de validación para
c e l i c
r Si la habilidad no es válida, el método devolverá
determinar si el argumento al método es válido para el cargo del
M a
empleado. una excepción
a u l
InvalidSkillException. El método de llamada de la clase EmployeeTest debe capturar esta
R excepción.
Nota: en nuestro ejemplo sencillo, la validación del método setSkill se simplificará de
manera significativa y no representa el tipo de validación sólida y exhaustiva que se
llevaría a cabo en una aplicación “real”. Nuestro objetivo aquí es centrarnos en la captura y
la devolución de excepciones.
1. Abra la clase InvalidSkillException y examine el código. Es muy sencillo. Lo único que
convierte a esta función en una excepción es que amplía Exception. Verá un constructor
no-args público así como un constructor público que acepta un argumento String. El
argumento es el mensaje que se mostrará al imprimir este objeto Exception.
2. Abra la clase SkilledEmployee y modifique el método setSkill tal y como se describe en
los pasos siguientes. La solución para el método setSkill se muestra en los pasos
siguientes en caso de que necesite más ayuda.
a. Agregue una cláusula throws a la declaración del método para que devuelva una
excepción InvalidSkillException.

COGNOS
b. Como la primera línea de código del método, declare una variable boolean denominada
“valid” e inicialícela en true.
c. Utilice una construcción if/else para definir el valor de la variable valid en false si
el argumento skill es null o tiene una longitud inferior a 5. De lo contrario, defina
valid = true.
d. Utilice otra construcción if/else para probar el valor de la variable valid.
−
Si es true, agregue la habilidad a skillList.
−
Si es false, devuelva new InvalidSkillException con el constructor que
toma un argumento String para el mensaje de excepción.
− El mensaje debería mostrar el argumento skill que ha causado la excepción y
concatenarlo a un literal de cadena que indique que se trata de un valor no válido
para un empleado con ese cargo en concreto. Muestre también el cargo del
empleado con el uso de this.getJobTitle().
Solución:
public void setSkill(String skill) throws
ble
InvalidSkillException {
fe r a
Boolean valid = true;
ans
n - t r
if(skill == null | skill.length() < 5){
o
valid = false;
s an
}
) ha eฺ
else {
c o m uid
valid = true; ฺ
ail ent G
} m
g tud
if (!valid) { @
16 is S
l l e
a e th
ฺ c
throw new InvalidSkillException(skill +
ra o us
(
“ is not valid for the “ +
e
a ll se t
this.getJobTitle() + “ job.”);
e l o C licen
}
arc else {
M
Raul }
skillList.add(skill);
}
4. Abra la clase EmployeeTest. Ahora debería ver iconos de error de color rojo en el margen
de izquierdo para todas las líneas de código que llaman al método setSkill. Haga clic en
uno de los iconos de error para leer la descripción del error y ver las opciones que ofrece
para ayudarle a resolver el problema.

COGNOS
Al compilar la clase SkilledEmployee, informó a NetBeans del hecho de que el método

setSkill devuelve una excepción InvalidSkillException. El compilador la comprueba
(recuerde que se trata de una “excepción comprobada”) y espera que la capture o la
devuelva de nuevo cuando llame a setSkill. Ninguna de las opciones sugeridas
funcionarán correctamente en este caso concreto, por lo que debe agregar el bloque
try/catch.
5. Incluya los juegos de llamadas al método setSkill en un bloque try/catch. En el

bloque catch, muestre el objeto de excepción. Deberá agregar bloques try/catch para
myEditor, myGI y myTW.
Ejemplo: las dos llamadas para el objeto myEditor pueden ir en un único bloque.
try{
myEditor.setSkill(“typing”);
myEditor.setSkill(“technical editing”);
}
catch(InvalidSkillException ex){ ble
System.out.println(ex); fe r a
ans
}
n - t r
6. no
Cambie el argumento String en una de las llamadas a setSkill a un argumento String
a
abreviado (menos de 5 caracteres) para que se considere no válido y se devuelva la
excepción. h a s
m ) deฺ
c o
7. Guarde y compile el programa. Ejecute la clase EmployeeTest
l ฺ yu i
examine la salida.
a i t G
@ gm tuden
l l e 16 is S
ฺ c a e th
e ( ra o us
a ll se t
e l o C licen
a rc
ul M
Ra
Nota: la captura de una excepción InvalidSkillException no ha evitado la ejecución del

resto del método. Sólo ha evitado el almacenamiento de una habilidad no válida para este
empleado. Esta forma de manejar las excepciones comprobadas ofrece además la
oportunidad de escribir la información de error en un archivo log o de solicitar al usuario
que vuelva a introducir la habilidad (en el caso de una interfaz de usuario distinta de la que
se utiliza aquí).

COGNOS
ble
fe r a
ans
n - t r
o
s an
) ha eฺ
c o m uid
ฺ
ail ent G
m
g tud
@
16 is S
l l e
a e th
ฺ c
ra o us
e (
a ll se t
e l o C licen
a rc
M
Raul


Curso Java Basico

Diunggah oleh

Informasi Dokumen

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

Curso Java Basico

Diunggah oleh

Hak Cipta:

Format Tersedia

COGNOS

autorización expresa por parte de Oracle.

Aviso sobre restricción de derechos

U.S. GOVERNMENT RIGHTS

Conceptos fundamentales de Java SE 7 - Tabla de contenidos

Prácticas para la lección 11: Uso de encapsulación y constructores ....................................... 11-1

Prácticas de la lección 12............................................................................................................... 12-2

Conceptos fundamentales de Java SE 7 - Tabla de contenidos

Prácticas para la lección 1: Introducción

Visión general de las prácticas

Prácticas para la lección 1: Introducción

Prácticas para la lección 2: Introducción a la tecnología Java

Visión general de las prácticas

Prácticas para la lección 2: Introducción a la tecnología Java

Práctica 2-1: Ejecución de un programa Java mediante la línea de

Tarea: Compilación y ejecución de un programa Java

Prácticas para la lección 2: Introducción a la tecnología Java

Prácticas para la lección 2: Introducción a la tecnología Java

a. Busque la clase compilada, CalcAverage.class. Para ello, vuelva a mostrar el

b. Llame al ejecutable en tiempo de ejecución java para ejecutar el programa

Prácticas para la lección 2: Introducción a la tecnología Java

Práctica 2-2: Ejecución de un programa Java mediante NetBeans IDE

3. Cree un proyecto de NetBeans que incluya el archivo CalcAverage.java en la carpeta de

Paso Ventana/Descripción de la página Opciones o valores

Prácticas para la lección 2: Introducción a la tecnología Java

Paso Ventana/Descripción de la página Opciones o valores

d. Asistente New Project: paso Source Package Folders: busque y

Prácticas para la lección 2: Introducción a la tecnología Java

Prácticas para la lección 2: Introducción a la tecnología Java

El contenido del proyecto aparece ahora en la ventana Projects en el panel de la

c. Ventana Project Properties | Confirme que Java 7 aparece como la

Prácticas para la lección 2: Introducción a la tecnología Java

b. Seleccione Sources en la columna Categories. Defina el campo Source/Binary Format

Prácticas para la lección 2: Introducción a la tecnología Java

1 6 @ S tu para NetBeans, seleccione

Prácticas para la lección 2: Introducción a la tecnología Java

Prácticas para la lección 2: Introducción a la tecnología Java

Prácticas para la lección 2: Introducción a la tecnología Java

Prácticas para la lección 2: Introducción a la tecnología Java

Prácticas para la lección 3: Consideraciones sobre los objetos

Visión general de las prácticas

Prácticas para la lección 3: Consideraciones sobre los objetos

Práctica 3-1: Análisis de un problema mediante el análisis orientado a

Prácticas para la lección 3: Consideraciones sobre los objetos

rce Get lrankedic

Prácticas para la lección 3: Consideraciones sobre los objetos

Práctica 3-2: Diseño de una solución de programación

Prácticas para la lección 3: Consideraciones sobre los objetos

icono UMLet en el escritorio de Windows para iniciar el programa.

Prácticas para la lección 3: Consideraciones sobre los objetos

Prácticas para la lección 4: Introducción al lenguaje Java

Visión general de las prácticas

Prácticas para la lección 4: Introducción al lenguaje Java

Práctica 4-1: Visualización y adición de código en un programa Java

líneas de código, lo modificará, lo compilará y, por último, lo probará mediante su ejecución.

Prácticas para la lección 4: Introducción al lenguaje Java

3. Identifique el campo y el método incluidos en la clase con la siguiente tabla:

Miembro Variable o nombre

Solución: Variable de campo: quote; nombre del método: display.

5. Haga clic en el botón Save para guardar y compilar Quotation.java.

Prácticas para la lección 4: Introducción al lenguaje Java

Prácticas para la lección 4: Introducción al lenguaje Java

Práctica 4-2: Creación y compilación de una clase Java

Paso Ventana/Descripción de la página Opciones o valores