TUTOR -Conceptos Fundamentales de Java SE 7 - Guía de Actividades

Conceptos fundamentales de Java SE 7

Guía de actividades

D67234CS20

Edición 2.0

Noviembre de 2011

D81768

Oracle University and FUNDACIÓN UNIVERSITARIA

TECNOLOGICO COMFENALCO CARTAGENA use onlyฺ

Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ

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. Disposición de marca comercial registrada Oracle y Java son marcas comerciales registradas de Oracle y/o sus filiales. Todos los demás nombres pueden ser marcas comerciales de sus respectivos propietarios.

Autores

Jill Moritz, Kenneth Somerville, Cindy Church

Colaboradores y revisores técnicos

Mike Williams, Tom McGinn, Matt Heimer, Joe Darcy, Brian Goetz, Alex Buckley, Adam Messenger,Steve Watts

Este libro se ha publicado con la ayuda de: Oracle Tutor



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ

Copyright © 2011, Oracle y/o sus filiales. Todos los derechos reservados.

Conceptos fundamentales de Java SE 7 - Tabla de contenidos

i

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ácticas de la lección 2................................................................................................................. 2-2 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ácticas de la lección 3................................................................................................................. 3-2 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ácticas de la lección 4................................................................................................................. 4-2 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

Prácticas para la lección 5: Declaración, inicialización y uso de variables .............................. 5-1 Prácticas de la lección 5................................................................................................................. 5-2 Práctica 5-1: Declaración de variables de campo en una clase .................................................... 5-3 Práctica 5-2: Uso de operadores y conversión de tipo para evitar la pérdida de datos ................ 5-6

Prácticas para la lección 6: Trabajar con objetos ........................................................................ 6-1 Prácticas de la lección 6................................................................................................................. 6-2 Práctica 6-1: Creación y manipulación de objetos Java ................................................................ 6-3 Práctica 6-2: Uso de la clase StringBuilder .................................................................................... 6-7 Práctica 6-3: Examen de la especificación de la API de Java ....................................................... 6-11

Prácticas para la lección 7: Uso de operadores y construcciones de decisión ....................... 7-1 Prácticas de la lección 7................................................................................................................. 7-2 Práctica 7-1: Escritura de una clase que utiliza la sentencia if/else......................................... 7-3 Práctica 7-2: Escritura de una clase que utiliza la sentencia Switch ........................................... 7-6

Prácticas para la lección 8: Creación y uso de matrices............................................................. 8-1 Prácticas de la lección 8................................................................................................................. 8-2 Práctica 8-1: Creación de una clase con una matriz unidimensional de tipos primitivos .............. 8-3 Práctica 8-2: Creación y trabajo con una ArrayList........................................................................ 8-7 Práctica 8-3: Uso de los argumentos de tiempo de ejecución y análisis de la matriz args.......... 8-12

Prácticas para la lección 9: Uso de construcciones de bucle .................................................... 9-1 Prácticas de la lección 9................................................................................................................. 9-2 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



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ


Conceptos fundamentales de Java SE 7 - Tabla de contenidos

ii

Prácticas para la lección 11: Uso de encapsulación y constructores ....................................... 11-1 Prácticas de la lección 11............................................................................................................... 11-2 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ácticas de la lección 12............................................................................................................... 12-2 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ácticas de la lección 13............................................................................................................... 13-2 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



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ


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

Capítulo 1 - Página 1


Capítulo 1



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




Prácticas de la lección 1

Visión general de las prácticas No hay ninguna práctica para la lección 1.



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ


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



Capítulo 2



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ





Visión general de las prácticas 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.)



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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 la siguiente tabla. Si necesita más ayuda, puede utilizar los pasos detallados que aparecen a continuación de la tabla.

2.

Paso Descripción Opciones o valores

a. Abra una ventana de comandos de DOS y vaya a:

D:\labs\les02

b. Compruebe el contenido de este listado de directorio para buscar:

CalcAverage.java

c. Defina la variable PATH para que incluya: D:\Program Files\Java\jdk1.7.0\bin

d. Compile el archivo de origen CalcAverage.java. Para ello, escriba:

javac CalcAverage.java

a. En el menú Start de Windows, seleccione Start > Run. Introduzca cmd en el campo Open

y haga clic en OK. En el símbolo del sistema, introduzca cd D:\labs\les02. Pulse Intro.



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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.

d. Si no aparece, agregue este directorio a la variable PATH del sistema introduciendo lo

siguiente en el símbolo del sistema. Pulse Intro.

Para confirmar que PATH se ha cambiado correctamente, escriba PATH en el siguiente símbolo del sistema. Debe aparecer jdk1.7.0\bin al final de la cadena PATH.

e. Compile el archivo .java. Para ello, escriba javac CalcAverage.java. Pulse Intro. Después de algunos segundos, el símbolo del sistema volverá a aparecer.

3. Ejecute el programa CalcAverage.java. 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. Confirme que el archivo se ha compilado correctamente. Muestre el contenido del directorio y busque:

CalcAverage.class

b. Ejecute el programa CalcAverage. Se le solicitará que introduzca tres enteros separados por espacios. Introdúzcalos y pulse Intro para ver la media de los tres enteros.

java CalcAverage



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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.

Escriba tres enteros separados por espacios y pulse Intro.

De esta forma se compila y ejecuta un programa Java con sólo una consola de DOS o una ventana de terminal.



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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.

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.


a. Menú principal File > New Project…

b. Asistente New Project: paso Choose Project

Categories: Java

Projects: Java Project with Existing Sources

Haga clic en Next.



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ





c. Asistente New Project: paso Name and Location

Project Name: Practice02

Desactive la casilla de control Set as Main Project.

Haga clic en Next.

d. Asistente New Project: paso Existing Sources

Source Package Folders: busque y 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), seleccione “Java” en la columna Categories. Seleccione “Java Project with Existing Sources” en la columna Projects. Haga clic en Next.



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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.

d. En el paso Existing Sources del asistente, agregue D:\labs\les02 al panel Source

Package Folders. Para ello, haga clic en Add Folder y examine el directorio que desee. Haga clic en Finish.



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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 parte superior izquierda de NetBeans. Haga clic en el separador Projects si necesita ver la ventana Projects. Aquí verá el nombre del proyecto y el nodo raíz. Amplíe los nodos que aparecen debajo para buscar CalcAverage.java.

4. Modifique las propiedades de este proyecto para definir la propiedad Source/Binary Format en JDK 7. Esto permitirá utilizar cualquier nueva función de lenguaje de Java SE 7 sin obtener un mensaje de error de NetBeans. La siguiente tabla proporciona los principales pasos. Si necesita más detalles, siga los pasos que aparecen a continuación de la tabla.


a. Menú principal File > Project Properties (Practice02)

b. Ventana Project Properties | Categoría Sources

Campo Source/Binary Format = JDK 7

c. Ventana Project Properties | Categoría Libraries

Confirme que Java 7 aparece como la 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.



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




b. Seleccione Sources en la columna Categories. Defina el campo Source/Binary Format en “JDK 7”.

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.



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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

d. Haga clic en OK para guardar los cambios realizados en el paso b en las propiedades

del proyecto.

5. Para determinar o cambiar la plataforma Java por defecto para NetBeans, seleccione Tools > Java Platforms en el menú principal. Esta ventana muestra todas las versiones de JDK que se han instalado correctamente en esta máquina. En este caso, sólo se ha instalado JDK 7 (es decir, JDK 1.7), por lo que está marcado como la plataforma por defecto en la columna Platforms. En la parte derecha, aparece la ubicación del directorio de la instalación de JDK 7. Cierre la ventana Java Platform Manager cuando termine de examinarla. Oracle University and FUNDACIÓN UNIVERSITARIA


Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




6. Para ver y editar el código del archivo CalcAverage.java, haga clic dos veces en la ventana Projects. Se abre en el panel Editor. Observe la codificación de color que utiliza el editor. (Por ejemplo, las palabras clave están en azul, los literales de cadena están en rojo). Esto facilita el trabajo con el código y su lectura. Puede obtener más información sobre el uso del editor en las siguientes prácticas.

7. En la ventana Projects, haga clic con el botón derecho en CalcAverage.java y seleccione Compile File.



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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.

Nota: si ha realizado algún cambio en el archivo java, el botón Save estará activado. Por defecto, la compilación se realiza automáticamente al guardar.

9. Vuelva a hacer clic en la ventana Projects. Haga clic con el botón derecho en el archivo y seleccione Run File. La salida del programa aparece en la ventana Output. Introduzca los tres valores enteros en la línea situada debajo del mensaje de salida y pulse Intro para ver el resultado.

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.



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ






Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ


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



Capítulo 3



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ





Visión general de las prácticas 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.



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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 de jugadores de cada equipo clasificados por goles marcados.

Tareas Su tarea es crear un análisis orientado a objetos para una aplicación de tecnología Java que realice un seguimiento de las puntuaciones. El programa debe realizar un seguimiento de:

• La lista de jugadores de cada equipo clasificados por goles marcados

• La lista de partidos jugados con sus resultados

• La lista de equipos de la liga clasificados por partidos ganados

Indicación: puede pensar en los objetos como sustantivos, en los atributos como adjetivos y en las operaciones como verbos. Como ejemplo, "jugador" es un sustantivo, el nombre del jugador es un adjetivo que describe ese sustantivo y "sumar un gol" es un verbo.

La aplicación debe ser capaz de generar estadísticas para los equipos, los jugadores y las temporadas.

1. Abra el editor de texto seleccionando Start > Programs > Accessories > Notepad.

2. Guarde el archivo como D:\labs\les03\oo-analysis.txt.



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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.

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

Solución

Player Team Game League Goal

id name number *Team

id name *Player(s)

id team one scoreteam two score *Goal

*Team(s) *Game(s)

id *Team *Player time

Get ranked player Get results

Get game results Get ranked teams

El asterisco (*) indica atributos que también son objetos.



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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

• Utilizar corchetes para indicar un atributo que represente una recopilación de valores (players[ ] ).

• Utilizar paréntesis para identificar los métodos.

1. Abra D:\labs\les03\oo-analysis.txt y guárdelo como D:\labs\les03\oo-design.txt.

2. Utilice las clases, variables y operaciones que ha identificado en la práctica anterior y desarrolle nombres de método para las operaciones. La siguiente captura de pantalla es un ejemplo.



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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.

Solución

Player Team Game League Goal

id name number team

id name players[ ]

id team one score team two score goals[ ]

teams[ ] games[ ]

id team player time

getRankedPlayers() getResults() getGameResults() getRankedTeams()

Nota: aunque no aparece en la solución, debe agregar/eliminar métodos para cada atributo 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.



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ


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



Capítulo 4



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ





Visión general de las prácticas 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.



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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.


a. Menú File > New Project

b. Asistente New Project | Paso Choose Project

Categories: Java


Next

c. Asistente New Java Project with Existing Sources | Paso Name and Location

Project Name: Practice04

Next

d. Asistente New Java Project with Existing Sources | Paso Existing Sources

Add Folder: D:\labs\les04

Finish

e. Ventana Project Properties | Categoría Source

Source/Binary Format: JDK 7

OK

Nota: la ventana Projects se debe parecer a la que se muestra a continuación cuando se 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.



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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 sensible al contexto en una lista de métodos y campos que serían válidos para una clase concreta a la izquierda del punto. Puede seleccionar un valor de la lista en lugar de escribirlo.

Solución:

System.out.println(quote);

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.



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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.



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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.


a. Menú File > New File

b. Ventana New File | Paso Choose File Type

Categories: Java

File Types: Java Class

Next

c. Ventana New Java Class | Paso Name and Location

Class Name: Shirt

Finish

a. En el menú principal, seleccione File > New File.

b. Se abre el asistente New File y estará en el paso 1 “Choose File Type”. Seleccione Java en la columna Categories. Seleccione Java Class en la columna File Types. Haga clic en Next.



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




c. En la ventana New Java Class, estará en el paso 2 “Name and Location”. Introduzca

“Shirt” para Class Name. Haga clic en Finish.



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




El archivo de origen Java de la nueva clase ahora aparece en el editor y está preparado para incluir todos los detalles.

2. Introduzca la sintaxis del código Java para la clase Shirt mostrada en esta lección de la Guía del alumno.

Solución: puede encontrar el código de la solución para la clase Shirt en D:\labs\soln\les04.

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.



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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.


a. Ventana New File | Paso Choose File Type

File Types: Java Main Class

b. Ventana New File | Paso Name and Location

Nombre: ShirtTest

a. En el paso Choose File Type, seleccione Java Main Class en lugar de Java Class.



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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.

Solución: puede encontrar el código de la solución para la clase ShirtTest en D:\labs\soln\les04.

6. Guarde y compile el código haciendo clic en Save.

7. Ejecute la clase ShirtTest haciendo clic con el botón derecho en ShirtTest.java en la ventana Projects. Busque la salida del método displayInformation en la ventana Output.



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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.

9. Abra (o céntrese en) el archivo Shirt.java. Modifique los valores de ShirtID y price.

10. Vuelva a ejecutar la clase ShirtTest. Verifique que los valores modificados aparecen en la ventana Output.



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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

Un cuadrado de color rosa aparece en el margen e indica un punto de ruptura.

2. Ejecute el depurador. Para ello, haga clic con el botón derecho en el archivo ShirtTest de la ventana Projects y seleccione Debug File.

3. El depurador inicia el programa y se para en el punto de ruptura. En el panel Editor, ahora verá un icono diferente que apunta con una flecha verde a una línea de código.

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.



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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

− En el panel Variables, verá todas las variables que están visibles para la clase

actual. Recuerde que la ejecución se para antes de que el objeto de la clase Shirt se instancie. Por lo tanto, no puede ver la variable myShirt en este panel.

5. Haga clic en el botón Step Over para pasar a la siguiente línea de código.

6. La flecha ahora apunta a la línea de código que llama al método displayInformation en el objeto myShirt. En la ventana Values, verá la variable myShirt. Amplíela para ver todos los campos de este objeto Shirt.

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.



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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.

9. En la columna Value, haga clic dos veces en el valor de cada campo y edítelo para cambiar el valor. Asegúrese de que utiliza el valor correcto para el tipo de dato esperado y delimite cada tipo de dato de caracteres con las comillas indicadas. Después de editar el campo final, haga clic en el botón de separador para que se acepte el texto introducido en el buffer de edición.

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.



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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.

Ahora ha visto algunas de las funciones utilizadas con más frecuencia de un depurador de IDE típico. Puede que desee utilizar el depurador en las prácticas restantes para diagnosticar y corregir los problemas que pueda experimentar en sus programas.

14. Cierre el proyecto Practice04 en NetBeans. En la ventana Projects, haga clic con el botón derecho en Practice04 y seleccione Close en el menú contextual.



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ






Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ


Prácticas para la lección 5: Declaración, inicialización y uso de variables



Capítulo 5



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ





Visión general de las prácticas 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.



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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.


a. Paso Choose Project Categories: Java


b. Paso Name and Location Project Name: Practice05

c. Paso Existing Sources Add Folder: D:\labs\les05

d. Ventana Project Properties Defina la propiedad Source/Binary Format en JDK 7

Nota: si necesita un recordatorio más detallado de cómo crear un nuevo proyecto, consulte la práctica 2-2, pasos 3 y 4.

Solución: la ventana Projects debería mostrar cuatro archivos de origen Java bajo el nodo <default package>.



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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 File Type

Categories: Java

File Types: Java Class

Next

c. Ventana New Java Class | Paso Name and Location

Class Name: Customer

Finish

4. Con Customer.java abierto para la edición en el panel Editor, declare e inicialice los campos descritos en la siguiente tabla. Si necesita más ayuda, en la siguiente tabla se proporcionan pasos más detallados.

Nombre de campo Tipo de dato Valor por defecto

customerID int <opción seleccionada>

status char <opción seleccionada>

‘N’ para nuevo, ‘O’ para antiguo

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



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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.

Nota: todos los ejemplos y las prácticas de este curso necesitan una clase de prueba. En la mayoría de los casos, se proporciona la clase de prueba. Sin embargo, en algunos casos, puede crear la clase.

8. Compruebe la salida para asegurarse de que contiene los valores que ha asignado.



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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 En esta tarea, utilizará operadores para calcular la edad en días, minutos, segundos y milisegundos.

1. Seleccione File > New File en el menú para crear una nueva clase Java denominada Person.

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 tiempo

Tipo de dato Información adicional

Años int Inicializar en 1

Días int No inicializar

Minutos long No inicializar

Segundos long No inicializar

Milisegundos long No inicializar



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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 b. Imprima todas las edades en varias unidades, cada una en una línea independiente con

un mensaje adecuado. Por ejemplo, “You are 3156000 seconds old”.

Solución:

public void calculateAge () {

ageDays = ageYears * 365;

ageSeconds = ageDays * 24 * 60 * 60;

ageMinutes = ageSeconds / 60;

ageMilliseconds = ageSeconds * 1000;

System.out.println ("You are " + ageDays + " days old.");

System.out.println("You are " + ageMinutes +

" minutes old.");

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.



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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 * itemPrice) e imprímalo. Asegúrese de convertir el tipo de itemQuantity o itemPrice en long para que el almacenamiento temporal utilizado para incluir el resultado de la multiplicación sea lo suficientemente grande para contener un valor long.

Solución:

public void calculateTotal(){

orderValue = (long)itemQuantity * itemPrice;

System.out.println(“Order total: “+ orderValue);

}

9. Guarde Order.java y, a continuación, pruébelo mediante la ejecución de OrderTest.java. Verifique el resultado con una calculadora.

Solución: el resultado debe ser 5555000000000

10. Edite el archivo Order.java para eliminar la conversión de tipo realizada en el método calculateTotal.

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.



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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

}

}

14. Compile la clase Temperature y pruébela con la clase TemperatureTest. Confirme que obtiene el mismo resultado ejecutando el programa que al hacer este cálculo con una calculadora.

15. Pruebe el programa con varios valores de temperatura.

16. Cuando termine de probar con diferentes valores, cierre el proyecto Practice05.



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ






Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ


Prácticas para la lección 6: Trabajar con objetos



Capítulo 6



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ





Visión general de las prácticas 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.



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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.

1. Cree un nuevo proyecto a partir del origen existente denominado Practice06. Defina la carpeta Source Package Folders para que apunte a D:\labs\les06. Recuerde que también debe cambiar la propiedad Source/Binary Format. Si necesita más información, consulte la práctica 2-2, pasos 3 y 4.

2. Abra el archivo Customer.java en el editor y examine los campos de miembro y el método. Puede utilizar la información de campo para completar esta práctica.

3. Cree la clase CustomerTest como un tipo “Java Main Class”. Puesto que esta clase la ejecuta el ejecutable de Java, debe contener un método main. NetBeans IDE proporciona 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).



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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

c. La clase CustomerTest aparece en el editor de texto.



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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

cust1

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

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.


a. Asigne valores a los campos de miembro de uno de los objetos Customer.

Ejemplo: cust1.customerID = 1;

b. Repita los pasos para el otro objeto Customer, pero utilice valores diferentes para los campos.

c. Llame al método displayCustomerInfo de cada objeto.

Utilice la variable de referencia de objetos para cualificar el método, como en el paso a.

a. Asigne valores a todos los campos de miembro de uno de los objetos Customer. Utilice la variable de referencia de objeto para cualificar el nombre del campo, como se indica a continuación: cust1.customerID = 1;

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



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




7. Ejecute el archivo CustomerTest.java. Compruebe la salida para asegurarse de que cada objeto Customer muestra los distintos valores que ha asignado.

Manipulación de referencias de objeto En esta sección, asignará el valor de una referencia de objeto a otra.

8. Edite el método main de CustomerTest para asignar una referencia de objeto a otra justo 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 clase Customer:

cust2 = cust1;

9. Guarde y ejecute el archivo CustomerTest.java. Compruebe la salida de los métodos displayCustomerInfo para ambos objetos. Ambas referencias de objeto ahora apuntan al mismo objeto en la memoria, por lo que las dos salidas del método displayCustomerInfo deben ser idénticas.



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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.

Solución de ejemplo:

public class PersonTwo {

public StringBuilder name = new StringBuilder(8);

public StringBuilder phoneNumber = new StringBuilder();

}

3. Cree un nuevo método denominado “displayPersonInfo”.

4. En el cuerpo del método displayPersonInfo, rellene y muestre el objeto name. Asegúrese de que el número total de caracteres en el nombre excede la capacidad inicial del objeto (8). La siguiente tabla proporciona los principales pasos para esta tarea. Encontrará instrucciones más detalladas a continuación de la tabla.


a. Agregue un nombre al objeto StringBuilder.

Utilice el método append de la clase StringBuilder.

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

Utilice el método toString de la clase StringBuilder.

d. Muestre la capacidad del objeto name con una etiqueta adecuada.

Utilice el método capacity de la clase 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”);



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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.


public void displayPersonInfo(){

name.append(“Fernando”);

name.append(“ “);

name.append(“Gonzalez”);

// Display the name object

System.out.println(“Name: + name.toString());

// Display the capacity

System.out.println(“Name object capacity: “ +

name.capacity());

}

e. Haga clic en Save para compilar. Ejecute el archivo PersonTwoTest.java. La salida debe tener un aspecto similar al de la siguiente captura de pantalla. Observe que la capacidad ha aumentado desde la configuración inicial de 8 para poder incluir el nombre completo.



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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 10 dígitos al objeto phoneNumber.

Ejemplo: “5551234567”

b. Inserte un guión (“-“) después de los tres primeros caracteres de phoneNumber.

Utilice el método insert que toma un valor int para el desplazamiento e inserta un valor String. (Utilice el número de desplazamiento 3).

c. Inserte otro guión después de los siete primeros caracteres de phoneNumber.

Recordatorio: la inserción anterior ha desplazado los caracteres restantes en un índice.

d. Muestre el objeto phoneNumber. Utilice el método toString de la clase StringBuilder.

a. Utilice el método append de la clase StringBuilder para agregar un valor String de diez números.

b. Inserte un guión (“-“) en la posición de desplazamiento 3. Esto coloca el guión en la 4a posición del objeto String, desplazando el resto de caracteres en una posición. La sintaxis para este método se muestra a continuación: <object reference>.insert(int offset, String str);

Ejemplo: tenga en cuenta la siguiente cadena,

“5551234567”

La posición de desplazamiento 3 se produce en el número 1. (Los números de índice empiezan en el 0). Si el guión se inserta en la posición de desplazamiento 3, desplaza el número que está actualmente en esa posición y el resto de números a la siguiente posición de desplazamiento.

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



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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: <object reference>.substring(int start, int end);

Nota: los índices para los caracteres en la clase StringBuilder, como los índices de matriz, están basados en cero. El primer carácter de StringBuilder está en la posición (o índice) 0.

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 es exclusivo (se trata del índice del carácter situado justo a la derecha del último carácter de la subcadena).


// Assumes the first name “Fernando”

System.out.println(“First name: “ + name.substring(0,8));

8. Guarde y vuelva a ejecutar el archivo PersonTwoTest.java. Compruebe la salida y realice los ajustes necesarios a los números de índice para obtener el valor de nombre correcto.



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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

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.



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




4. Responda a las siguientes preguntas sobre la clase Math:

a. ¿Cuántos métodos tiene la clase Math?__________________________

b. ¿Cuántos campos tiene la clase Math?_____________________________

Respuesta:

a.) 54

b.) 2

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.



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ


Prácticas para la lección 7: Uso de operadores y construcciones de decisión



Capítulo 7



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ





Visión general de las prácticas 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.



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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 En esta tarea, creará una clase DateTwo que evalúe un campo numérico para determinar el día de la semana que corresponde a ese número. Para ello, utilizará una construcción if/else.

1. Cree un nuevo proyecto desde los orígenes existentes denominado Practice07. Defina la carpeta Source Package Folders para que apunte a D:\labs\les07. Recuerde que también debe cambiar la propiedad Source/Binary Format. Si necesita más información, consulte la práctica 2-2, pasos 3 y 4.

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



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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 para inspeccionar el valor de dayNumber.

En cada bloque if, muestre el día de la semana correspondiente.

b. Visualice un mensaje de error si encuentra un número no válido.

Esta debe ser la última condición que 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

}else if (condition2) {

// print corresponding day

}else if (condition3)

…

}else {

// if none of the conditions is true

}

b. Si dayNumber no es igual a un número entre 1 y 7 (incluidos), se imprimirá un mensaje de error. Estará incluido en el bloque else final.

4. Guarde, compile y ejecute la clase mediante la ejecución de la clase DateTwoTest. Compruebe la salida en la ventana Output.

5. Repita el paso 4 varias veces asignando valores diferentes al campo de miembro DateTwo.

Escritura de otra clase que utiliza sentencias if/else

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



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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 {

System.out.println(“Early Morning”);

}

}

8. Guarde, compile y ejecute el programa mediante la ejecución de la clase ClockTest.

9. Repita el paso 8 varias veces asignando valores diferentes a la variable de miembro currentTime.

Nota: un cero inicial indica un valor octal. Por lo tanto, el programa no se compila si define currentTime en 0800. Necesita especificar currentTime como 800 para 8:00 AM para compilar el programa correctamente.



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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.

3. Cree un nuevo método en esta clase Month denominado displayMonth. El método utiliza una construcción switch para inspeccionar el valor del campo monthNumber y mostrar el nombre correspondiente del mes. El método displayMonth también debe mostrar un mensaje de error si se utiliza un número no válido.

Indicación: la sintaxis de una sentencia switch es:

switch (<variable>){

case <value1>:

// do something

break;

case <value2>:

// do something

break;

… // more cases

default:

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




Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ


Prácticas para la lección 8: Creación y uso de matrices



Capítulo 8



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ





Visión general de las prácticas 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.



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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

Supuestos El archivo VacationScaleTest.java aparece en la carpeta de prácticas de esta lección, D:\labs\les08.

Tareas


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.



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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 vacationDays para alinear un número de años de servicio con el número de días de vacaciones correcto. (Consulte la tabla anterior).

El valor es igual al número de días de vacaciones.

El índice de elemento es igual al número de años de servicio.

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 días de vacaciones adecuado de los que se indican en la tabla anterior de la sección Visión general. Por ejemplo, a un empleado con 0 años de servicio le corresponden 10 días de vacaciones. Por lo tanto, vacationDays[0] = 10. A un empleado con 1 año de servicio le corresponden 15 días de vacaciones. Por lo tanto, vacationDays[1] = 15.

Solución:

public void setVacationScale(){

vacationDays = new int[7];

vacationDays[0] = 10;





// … and so on through element 6

}

4. Cree un método público denominado displayVacationDays que muestre el número de 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]



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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 ArrayIndexOutOfBounds. La ventana Output debe tener un aspecto similar al de la siguiente captura de pantalla:

Esta excepción se devuelve cuando se intenta acceder a un índice de una matriz no existente. Observe que el número de índice que ha causado la excepción aparece en el mensaje de error: el índice número 10. Recuerde que esta matriz tiene 7 elementos, indexados por números, del 0 al 6. ¿Por qué el programa intenta acceder al índice 10?

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.



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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.



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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 New > Java Main Class. Deje el método main vacío por ahora. Puede agregar el código más adelante.

2. Cree una nueva clase Java denominada NamesList.

3. En la clase NamesList, declare un campo ArrayList público denominado listOfNames. No instancie el campo listOfNames.

Nota: cuando escriba la palabra ArrayList, el editor indica una advertencia en el margen de esta línea. No reconoce la clase ArrayList. Debe importar la clase para que esté visible para el compilador.

4. Coloque el cursor sobre el icono de advertencia en el margen para ver la descripción de la advertencia. Pulse Alt+Intro para ver y seleccionar de una lista de indicaciones para resolver este problema. Seleccione Add import for java.util.ArrayList como se muestra aquí:

La sentencia de importación se coloca en la parte superior de la clase NamesList (sobre la declaración de clase).



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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.

Paso Descripción del código Opciones o valores

a. Instancie el objeto listOfNames. Utilice la palabra clave new. No especifique el tamaño.

b. Agregue un nombre (nombre y apellido) al objeto listOfNames.

Utilice el método add.

Ejemplo: listOfNames.add(“Joe Smith”);

c. Repita el paso b tres veces para agregar un total de cuatro nombres al objeto listOfNames.

d. Imprima la lista de nombres con una etiqueta adecuada.

Puede imprimir simplemente el objeto. (listOfNames)

e. Imprima el tamaño de la ArrayList listOfNames.

Utilice el método size del objeto listOfNames.

a. Utilice la palabra clave new para instanciar listOfNames. Ejemplo:

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



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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

}


7. Abra la clase NamesListTest en el editor. En el método main:

8. Instancie un objeto NamesList denominado “names” con la palabra clave new.

a. Llame al método setList del objeto names.

9. Guarde y compile el programa. Ejecute la clase NamesListTest para probar el programa.

Manipulación de ArrayList

10. Agregue otro método nuevo a la clase NamesList denominado manipulateList. Codifique el método como se describe en la siguiente tabla. Encontrará pasos más detallados a continuación de la tabla.


a. Elimine uno de los nombres de la lista.

Utilice el método remove(Object obj) del 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 listOfNames.

Utilice el método size de ArrayList.

d. Agregue el nombre que ha eliminado a la lista en una ubicación diferente.

Utilice el método add(int index, Object obj) del objeto ArrayList.

Indicación: los números de índice están basados en cero.



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ





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 una etiqueta adecuada.

d. Utilice el método add de ArrayList para agregar el nombre que ha eliminado a ArrayList, pero en una ubicación diferente de la anterior.

Nota: el método add está “sobrecargado”. Es decir, tiene dos firmas de método diferentes. Uno de los métodos add toma un elemento Object y lo agrega al final de ArrayList. El otro método toma un número de índice y un elemento Object. Inserta Object antes del número de índice de referencia, desplazando el resto de elementos de lista un número de índice. Utilice el último método add. A continuación se muestra un ejemplo: listOfNames.add(1, “Joe Smith”);

e. Utilice una etiqueta adecuada al imprimir el contenido recién modificado del objeto listOfNames.

f. Utilice una etiqueta adecuada al imprimir el nuevo tamaño del objeto listOfNames.


listOfNames.remove (“Joe Smith”);

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.



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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 Jose Gonzalez estaba en la posición de índice 1.

A continuación, Joe Smith se agregó a la posición de índice 1, desplazando a Jose Gonzalez a la posición de índice 2.



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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:

int randomNum = 0;

int guess;

3. Agregue código al método main para aceptar un argumento simple de cualquier número en el rango de 1 a 5, ambos incluidos, o la palabra "help". Los principales pasos se describen en el siguiente pseudocódigo, seguido de unas indicaciones útiles. Si necesita más ayuda, realice los pasos situados a continuación del pseudocódigo y las indicaciones. Recuerde que la solución también la puede encontrar en D:\labs\soln\les08.

4. Pseudocódigo del método main:

if length of args array == 0 or value of args[0] = “help” print a Correct Usage message else randomNum = a generated random number 1 - 5 guess = integer value of args[0] 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.



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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;

int guess;

if(args.length == 0 || args[0].compareTo(“help”) == 0){

System.out.println

(“Usage: java GuessingGame [argument]”);

System.out.println();

System.out.println

(“Enter a number from 1 – 5 as your guess.”);

}else {

randomNum = ((int)(Math.random()*5) +1);

guess = Integer.parseInt(args[0]);

if(guess < 1 || guess > 5){

System.out.println

(“Invalid argument: Enter a number from 1 - 5”);

}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




Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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

8. En la ventana Project Properties, seleccione la categoría Run. Cambie Main Class a GuessingGame e introduzca un número del 1 al 5 en el campo Arguments. Haga clic en OK.

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.



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ





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.



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ






Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ


Prácticas para la lección 9: Uso de construcciones de bucle



Capítulo 9



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ





Visión general de las prácticas 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.



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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.

2. Cree una nueva clase Java denominada "Counter". Declare e inicialice un campo public final int denominado MAX_COUNT. Asigne el valor 100 a este campo.

Indicación: utilice la palabra clave final para designarlo como un campo constante.

3. Cree un método denominado displayCount que realice las siguientes acciones:

• Contar desde 1 hasta el valor de la constante MAX_COUNT mediante el uso de un bucle for. Aumente el valor de la variable de bucle en 1.

• Mostrar el valor de una variable de bucle si ésta se puede dividir entre 12. Muéstrelo en una línea única, con una separación de un espacio.

Indicaciones

• Ejemplo de un bucle: for (int i= 1; i < 10; i++) // loops 9 times

• Utilice el operador modular (%) para comprobar la divisiblidad entre 12. Si se puede dividir entre 12, el resultado de la operación modular será cero.

• Utilice el método System.out.print para mantener todos los valores mostrados en 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



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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 firstNumber y secondNumber, respectivamente. Declare también un elemento public final int denominado SEQUENCE_LIMIT. Defina su valor en 100.

2. Cree un método denominado displaySequence. Utilice los siguientes pasos principales para codificar el método. Si necesita más ayuda, se proporcionan instrucciones detalladas en los siguientes pasos:

a. Imprima el valor de firstNumber y secondNumber para iniciar la secuencia. Separe todos los números de la secuencia con un espacio.

b. Calcule la suma de firstNumber y secondNumber y asigne la suma a nextNumber.

c. Cree un bucle while con las siguientes características:

− expresión booleana: repita si el valor de nextNumber es menor o igual que SEQUENCE_LIMIT.

− bloque de código: − Imprima el valor de nextNumber. − Asigne el valor de secondNumber a firstNumber y el valor de

nextNumber a secondNumber. − 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.



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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

// Print the first two numbers

System.out.print(firstNumber + “ “);

System.out.print(secondNumber + “ “);

// Calculate the next number

nextNumber = firstNumber + secondNumber;

while(nextNumber <= SEQUENCE_LIMIT){

// Print the next number of the sequence

System.out.print(nextNumber + “ “);

firstNumber = secondNumber; // new first number

secondNumber = nextNumber; // new second number

// Calculate the next potential number


} // end of while

// Finish it off with a carriage return


} // end of method

} // end of class

3. Guarde y compile el programa. Ejecute la clase SequenceTest para realizar la prueba.



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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.

Tareas

1. Cree una nueva clase Java denominada "ChallengeSequence". Copie todo el código que esté entre los corchetes (de clase) externos de la clase Sequence y péguelo dentro de los corchetes externos de la clase ChallengeSequence.

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.

Copie la sección resaltada



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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


for(int count = 2; count < SEQUENCE_COUNT; count++){

// Start at 2 and loop until you get to 9 (8 numbers)

System.out.print(nextNumber + “ “);

firstNumber = secondNumber;

secondNumber = nextNumber;


}


}

4. Guarde y compile el programa. Ejecute la clase ChallengeSequenceTest para probar el código. La salida debe mostrar la siguiente serie:

0 1 1 2 3 5 8 13 21 34



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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

• VacationScaleTwoTest.java

• NamesListTwo.java

Uso de un bucle for con la clase VacationScaleTwo

1. Abra la clase VacationScaleTwo en el editor. Esto es similar a la clase VacationScale que escribió para las prácticas de la lección 8, excepto en que se utiliza una ArrayList para almacenar los días de vacaciones en lugar de una matriz.

2. Agregue un nuevo método denominado displayVacationDays. Las principales instrucciones para esta tarea aparecen en la siguiente tabla. Encontrará instrucciones más detalladas a continuación de la tabla.


a. Utilice un bucle for para pasar por los elementos de la ArrayList vacationDays.

Utilice el método size de ArrayList en la expresión booleana que determina el final del bucle.

b. En el bucle, muestre cada valor de la ArrayList y su posición en la lista con una etiqueta adecuada.

Utilice el método get de la ArrayList junto con System.out.println para mostrar el 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));



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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 8. Sólo tiene un método, setList. Este método inicializa ArrayList y, a continuación, imprime el tamaño de la lista.

5. Agregue un nuevo método a la clase NamesListTwo denominado displayNames. Utilice un bucle mejorado for en este método para procesar la ArrayList. Las principales instrucciones para esta tarea aparecen en la siguiente tabla. Encontrará instrucciones más detalladas a continuación de la tabla.


a. Muestre un mensaje de introducción para describir la lista siguiente.

b. Inicie el bucle for mejorado (recuerde que una ArrayList está definida para incluir elementos de tipo Object).

for (Object name : listOfNames)

c. En el bloque for, muestre el elemento actual de ArrayList.

Use the name reference

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.



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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.

8. Guarde y compile el programa. Ejecute la clase NamesListTwoTest para realizar la prueba.

9. Debe ver una salida del programa similar a la siguiente captura de pantalla:



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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

Fila 2 1,0 1,1 1,2 1,3

Fila 3 2,0 2,1 2,2 2,3

Supuestos En esta práctica, se asume que el archivo ClassMapTest.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 “ClassMap”.

2. En la clase, declare dos campos públicos de la siguiente forma:

public String[][] deskArray;

public String name;

3. Cree un nuevo método denominado setClassMap. En este método, inicialice deskArray 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.



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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 for(int col=0; col<4; col++){ // start of column loop if(deskArray[row][col]==null){ deskArray[row][col] = name; System.out.println (name +” desk is at position: Row:” + row + ” Column:”+col);

flag = true; break; // drop out of column loop } // end of if } // end of inner/column for loop if (flag == true){ break; // drop out of row loop } // end of if } // end of row for loop if (flag == false){ System.out.println(“All desks occupied.”); } // 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



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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.

8. Ejecute la clase ClassMapTest para probar el programa.

9. Si no va a realizar la práctica 9-6 (una práctica de comprobación opcional), cierre el proyecto Practice09 en NetBeans ahora.



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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.

2. En el método searchDesk, realice lo siguiente:

a. Cree un bucle anidado for para recorrer deskArray.

b. Si el elemento de matriz no es null, compare el valor del campo name con el valor del elemento. Por ejemplo: if(deskArray[row][col] != null && deskArray[row][col].equals(name)){

c. Imprima la posición de la mesa si los nombres son iguales.

d. Imprima un mensaje de error si el nombre no se encuentra en deskArray.

e. Utilice la sentencia break para saltar fuera de los bucles o salir de ellos cuando sea necesario.



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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

if (flag == true){

break;

} // end of if

} // end of row loop

if (flag == false){

System.out.println(“Desk not allocated for: ”+name);

} // end of if

} // end of method

3. En la clase ClassMapTest, anule los comentarios de las líneas de código que definen el valor name del objeto myClassMap y llaman al método searchDesk (esta combinación se produce dos veces).

4. Guarde y compile el programa. Ejecute la clase ClassMapTest para probar el programa.

5. Ésta es la conclusión de las prácticas de la lección 9. Cierre el proyecto Practice09 ahora.



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ






Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ


Prácticas para la lección 10: Trabajar con métodos y sobrecarga de métodos



Capítulo 10



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ





Visión general de las prácticas 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.



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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 En esta práctica, se asume que los siguientes archivos aparecen en la carpeta de prácticas de esta lección, D:\labs\les10:

• Order.java

• Shirt.java

Tareas


2. Abra la clase Shirt y examine los campos de miembro y el método que contiene.

3. Abra la clase Order y examine los campos de miembro y el método.

4. Cree una nueva clase Java Main Class denominada “OrderTest”.

5. Agregue código al método principal que agregue una camisa a un nuevo pedido y muestre el importe total del pedido. Los principales pasos para esta tarea aparecen en la siguiente tabla. En la siguiente tabla se proporciona ayuda más detallada.


a. Cree e inicialice dos objetos. Tipo de objeto: Shirt

Tipo de objeto: Order

b. Declare e inicialice una variable local de tipo doble.

Nombre de variable: totalCost

Valor: 0.0

c. Asigne un valor al campo price del objeto Shirt.

Valor: 14.99

d. Llame al método addShirt del objeto Order.

Argumento de método: objeto Shirt

Retorno de método: asígnelo a totalCost

e. Muestre el valor de retorno con una etiqueta adecuada.

Salida de ejemplo:

“Total amount for the order is $14.00”



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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:


Order order = new Order();

Shirt shirt = new Shirt();

double totalCost = 0.0;

shirt.price = 14.99;

totalCost = order.addShirt(shirt);

System.out.println("Total amount for the order is $" + totalCost);

}

6. Guarde y compile el programa. Pruebe el proceso del pedido mediante la ejecución de la clase OrderTest.

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.



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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

System.out.println("Total amount for the order is $" + totalCost);

}

8. Guarde y compile el programa y, una vez más, ejecute la clase OrderTest para probarlo. Asegúrese de que el importe mostrado es el total de todas las camisas.



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




Práctica de comprobación 10-2: Escritura de una clase que contiene un método sobrecargado 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, 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

1. Cree una nueva clase Java denominada "Customer". Declare los siguientes campos e inicialícelos como se muestra en la siguiente tabla:

Campo Tipo Valor inicial

customerID int 0

name String “-name required-“

address String “-address required-“

phoneNumber String “-phone required-“

eMail String “-email optional-“

2. Instrucciones principales: en la clase Customer, agregue dos métodos sobrecargados denominados setCustomerInfo. Según la forma en la que se llame al método setCustomerInfo, realiza una de las siguientes acciones:

• Define el ID, el nombre, la dirección y el número de teléfono de un objeto Customer. (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.




Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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”,”[email protected]”);

c1.display();

c2.display();

}

6. Una vez más, guarde y compile el programa. Ejecute la clase CustomerTest para probar el programa. Asegúrese de que la salida es diferente para cada método de visualización.



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ






Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ


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



Capítulo 11



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ





Visión general de las prácticas 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.



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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 En esta práctica, se asume que los siguientes archivos aparecen en la carpeta de prácticas de esta lección, D:\labs\les11 y, por lo tanto, en el proyecto Practice11.

• DateOneTest.java

• DateTwoTest.java

• DateThreeTest.java

Implantación de la encapsulación en una clase

1. Cree un nuevo proyecto denominado “Practice11”. Consulte la práctica 2-2, pasos 3 y 4, si necesita ayuda.

2. Cree una nueva clase Java denominada "DateOne". Declare tres campos de miembro de tipo int denominados: day, month y year. Proporcione acceso público a todos los campos de miembro.

3. Abra la clase DateOneTest. En el método main, realice lo siguiente:

a. Cree e inicialice un objeto de tipo DateOne.

b. Asigne diferentes valores numéricos a los campos de miembro del objeto DateOne.

c. Muestre el valor de los campos de miembro del objeto DateOne. Concaténelos en una cadena única con el formato de fecha que desee.

Nota: el carácter de barra invertida (\) es un carácter especial en el lenguaje Java denominado “carácter de escape”. Si desea utilizarlo como parte del formato de fecha, utilice dos barras invertidas juntas para que una de ellas aparezca en la cadena. Ejemplo: day + “\\” + month tiene como resultado una barra invertida única entre el día y el mes. No 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);

}




Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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 referencia a los campos del objeto DateTwo.

Coloque el cursor sobre cualquiera de los iconos rojos para examinar el mensaje de advertencia. Se indica que day tiene un acceso privado en DateTwo (mensaje similar para cada campo). Aunque NetBeans permite hacer clic en Save sin emitir un error de compilador, sólo guarda el archivo. No compila el código ni crea el archivo DateTwoTest.class.

Acceso a los atributos encapsulados de una clase En esta tarea, creará una clase con atributos privados pero los activará para que se puedan manipular desde otra clase.

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;

}



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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.

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 Javadoc en None para optimizar el código del método. Haga clic en Refactor para cerrar la ventana y crear los métodos.



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




13. Abra la clase DateThreeTest.

14. En el método main, declare un objeto de tipo DateThree denominado “date”. Cree una instancia de la clase DateThree.

15. Con la referencia de objeto DateThree, llame a los métodos setMonth, setDay y setYear del objeto DateThree para definir los tres valores de una fecha. Ejemplo:

date.setMonth(10);

date.setDay(16);

date.setYear(2011);

16. Complete el método main mostrando la fecha completa en el formato que desee. Por ejemplo:

System.out.println(The date is: ”+ date.getMonth() +

“/” + date.getDay() + “/” + date.getYear());

17. Guarde y compile el programa. Ejecute la clase DateThreeTest para realizar la prueba.



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




Práctica de comprobación 11-2: Adición de validación a la clase DateThree 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, 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 int. Estos valores se asignan a los campos day, month y year respectivamente, como en el siguiente ejemplo:

public void setDate(int d, int m, int y)

Realice la validación indicada en la siguiente tabla antes de asignar los valores de argumento a los campos. Los pasos detallados se proporcionan a continuación de la tabla.


a. Valores válidos del campo year Entre 1000 y 10000

b. Valores válidos del campo month 1 – 12

c. Valores válidos del campo day 30, 31, 28, 29

Depende del mes

Nota

Utilice una sentencia switch case para determinar el valor month. Utilice sentencias if/else para realizar la validación. Muestre un mensaje de error si el valor no es válido.

a. En el método setDate, agregue la siguiente sentencia if/else para comprobar la 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;

}



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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:

this.month = m;

if (d > 0 && d < 32){

this.day = d;

} else {

System.out.println(d + “ is an invalid day for “

+ month);

this.day = 0;

}

break;

//(switch statement continues in step c)



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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 {

System.out.println(“Invalid day. “ +

“Day cannot be 29 unless the year is a leap year.”);

this.day = 0;

} // end of inner if/else

} // end of outer if/else

break;

case 4:

case 6:

case 9:

case 11:

this.month = m;

if(d > 0 && d < 31){

this.day = d;

} else {

System.out.println(“Invalid day. Must be 1 to 30.”);

this.day = 0;

}

break;

default:

System.out.println(m + “ is an invalid month.”);

this.month = 0;

break;

} // end switch



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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 para realizar las siguientes pruebas:

• Prueba con valores válidos para month, day y year

• Prueba con un valor no válido para month: 14

• Prueba con un valor no válido para day: 35

• Prueba con un valor no válido para year: 200

Ejemplo para la primera prueba: date.setDate(30,12,2011);

date.displayDate();

4. Guarde y compile el programa y ejecute la clase DateThreeTest. Debería ver una salida similar a la siguiente:

Compare la salida con el código para cotejar los mensajes con la prueba concreta ejecutada.



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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.

Paso Descripción Opciones o valores

a. Sintaxis para declarar un constructor no-args.

public <class_name>()

b. Inicialice los campos privados. width = 25 height = 10

c. Imprima un mensaje. “Default rectangle created: width = 25, height = 10"

a. En la clase Rectangle, declare un constructor public no-args de la siguiente forma:

public Rectangle(){

}

b. Asigne el campo width al valor 25 y el campo height al valor 10.

c. Utilice System.out.println para mostrar el mensaje que aparece en el paso b de la tabla anterior.

3. Agregue un segundo constructor que acepte dos argumentos int: w y h (para “width” y “height”). La siguiente tabla proporciona los principales pasos para completar este 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 después de validar los valores de argumento.

h y w deben ser > 0 y < 30.

b. Muestre un mensaje para cada condición.

Mensaje de error si los números no son 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.



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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

}

}

4. Cree un método getArea que calcule y devuelva el área del rectángulo (width * height).

Solución:

public int getArea(){

return width * height;

}

5. Cree un método draw que imprima la forma rectangular, como lo determinan el ancho y la altura, en una serie de filas con asteriscos (*). En los siguientes pasos se proporcionan instrucciones más detalladas:

a. Cree un bucle anidado for para dibujar el rectángulo con asteriscos.

b. El bucle externo for itera con las filas del rectángulo. El número de filas corresponde al valor del campo height.

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




Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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

Rectangle r2 = new Rectangle(15,5);

System.out.println(“Area of r2 is: “+r2.getArea());

r2.draw();

}

8. Guarde y compile el programa. Ejecute la clase RectangleTest para realizar la prueba. La salida se debe parecer a la siguiente:



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ






Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ


Prácticas para la lección 12: Descripción de conceptos orientados a objetos avanzados



Capítulo 12



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ





Visión general de las prácticas 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.



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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 En esta sección, diseñará subclases y superclases con la información que se detalla a continuación.

El departamento de marketing de la compañía Duke’s Choice cuenta con empleados en distintos puestos de trabajo. Algunos de estos puestos son: Technical Writer, Graphic Illustrator, Manager y Editor.

El departamento de marketing le solicita que cree un programa para realizar un seguimiento de la información sobre los trabajadores. Esta información incluye el nombre del trabajador, el cargo, el ID de empleado y el nivel (1, 2 o 3). Además:

• Los empleados con el cargo Manager deben tener una lista de los empelados a los que gestionan.

• Los empleados con los cargos Technical Writer, Graphic Illustrator y Editor deben tener una lista de las habilidades que posean.

• Los empleados con el cargo Editor deben disponer de un valor para indicar si prefieren realizar la edición de forma electrónica o en papel.

• Debe haber una forma de mostrar toda la información sobre un tipo de empleado determinado.

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



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




• 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 que sea necesario.

• Modelado: modele la jerarquía de clases con un diagrama de clases similar al que ha visto en esta lección.

Solución:



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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 según corresponda.

d. Amplíe el nodo JDK 1.5 and later. Debajo de este nodo, anule la selección de Add @Override Annotation.

e. Haga clic en OK para guardar el cambio y cerrar la ventana Options.



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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 comparten todas las instancias de la clase. El campo static se utiliza aquí para almacenar un valor entero que se incrementa mediante el método calculateEmployeeID para generar el siguiente valor de ID. Todas las instancias de Employee y sus subclases acceden al campo employeeIDCounter y lo incrementan, lo que asegura que no se generen ID de empleado duplicados.

En una aplicación de negocio real, esta técnica no sería lo suficientemente segura como para garantizar la creación de ID únicos. En su lugar, probablemente sería una base de datos la que generara los ID. Sin embargo, esta técnica es suficiente para nuestra sencilla aplicación.

d. Cree el método calculateEmployeeID. No toma argumentos y no devuelve ningún valor. En el cuerpo de este método, incremente employeeIDCounter y, a continuación, defina el valor nuevo en el campo employeeID (utilice el método set del campo).

e. Cree el método displayInformation. No toma argumentos y no devuelve ningún valor. En este método, imprima el valor de los campos de la clase con una etiqueta adecuada.

Solución :

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



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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: public class Manager extends Employee {

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 forma en lugar de utilizar una matriz. private ArrayList employeeList = new ArrayList();

c. Agregue la sentencia import necesaria para importar la clase. java.util.ArrayList.

Indicación: haga clic en el icono de error en el margen izquierdo para que NetBeans agregue la sentencia de importación.

d. Agregue un método setEmployee público para agregar un único empleado a employeeList. El método toma un argumento de tipo Employee. Utilice el método add de ArrayList para agregar el objeto Employee al objeto employeeList.

public void setEmployee(Employee emp){

employeeList.add(emp);

}

Pregunta: ¿Qué validación puede que sea necesario realizar en este método en una aplicación real?

e. Agregue un método getEmployees público que devuelva únicamente el valor de employeeList.

public ArrayList getEmployees(){

return employeeList;

}



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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 Employee. Por tanto, para obtener el campo name de cada objeto para mostrarlo, debe convertir el valor Object en un Employee (un empleado “es un” 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 indica a continuación:

public void displayInformation(){

Employee emp;

// Invoke the ancestor method

super.displayInformation();

System.out.println

(“The manager has the following employees: “);

for(Object obj : employeeList){

// Cast the object as an Employee

emp = (Employee)obj;

// print the name, indented by a tab

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.



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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.

a. Declare el campo prefersPaperEditing como private boolean. (Se inicializa en el valor false por defecto).

b. Agregue un método setPrefersPaperEditing que tome un argumento boolean y devuelva void. Asigne el argumento al campo privado.

c. Agregue un método getEditingPreference que devuelva un valor String. Utilice una construcción if/else para comprobar el valor de prefersPaperEditing y defina el valor de retorno en “Paper” o “Electronic”.

d. Sustituya el método displayInformation como lo hizo en la clase Manager. Para ello, llame en primer lugar al método de la superclase y, a continuación, muestre el valor de retorno de this.getEditingPreference() con una etiqueta adecuada.

e. Haga clic en Save para compilar el programa.

− Nota: consulte el archivo de soluciones de la clase Editor en caso de que necesite ayuda.

8. Cree las dos clases restantes del diagrama: GraphicIllustrator y TechnicalWriter. Estas dos clases amplían la clase SkilledEmployee. No es necesario agregar campos o métodos adicionales ni sustituir el método displayInformation.


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.



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




11. Ejecute la clase EmployeeTest para probar el programa. Debería ver una salida similar a la siguiente captura de pantalla:



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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 En esta práctica, se asume que los siguientes archivos aparecen en la carpeta de prácticas de esta lección, D:\labs\les12:

• Printer.java

• Country.java

• Region.java

• Company.java

• CompanyTest.java

Tareas

1. Cree una interfaz Java nueva con el asistente File de NetBeans.

a. Haga clic con el botón derecho en Practice12 en la ventana Projects.

b. Seleccione New > Java Interface en el menú emergente.

c. Introduzca Printable en el campo Class Name como se muestra.

d. Haga clic en Finish.



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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.

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.

6. Cambie el nombre del método displayInformation a print.

7. Realice el mismo cambio (displayInformation a print) en las siguientes clases para asegurarse de que también implantan el método print. Además, debe cambiar el nombre del método de superclase llamado en la primera línea del nuevo método print. (Ya no se denomina displayInformation).

• Manager

• SkilledEmployee

• Editor

8. Abra la clase Printer en el editor y examine el único método que incluye: printToScreen. 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);



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ





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:

• Company

• Region

• Country

• CompanyTest

13. En primer lugar, examine la clase Company. Se trata de la superclase de Region y Country. Observe que implanta la misma interfaz Printable que ha utilizado en la jerarquía Employee.

14. Examine también las clases Region, Country y CompanyTest.

15. Ejecute la clase CompanyTest para ver la salida de esta aplicación.



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ





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.



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ


Prácticas para la lección 13: Manejo de errores



Capítulo 13



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ





Visión general de las prácticas 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.



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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 Practice13. Defina la carpeta Source Package Folders para que apunte a D:\labs\les13. 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.

Existen muchos archivos en este proyecto, pero sólo la clase DateTest es relevante para esta práctica.

2. Abra la documentación de especificación de la API de Java mediante el acceso directo del escritorio.

3. Busque la clase SimpleDateFormat en el paquete java.text. Esta clase le permite seleccionar un formato de fecha estándar que se utilizará durante la aplicación del formato y el análisis. Por ejemplo, puede aplicar formato a la salida de String de un objeto Date y analizar (o crear) un objeto Date basado en una representación String con formato de la fecha.



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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.

c. La documentación Java muestra ahora un método parse de dos argumentos similar en

la clase DateFormat. Desplácese hacia arriba hasta el método parse de un argumento situado directamente sobre este método.

d. Observe que este método parse acepta un único argumento String y devuelve un

objeto Date. Si las hay, ¿qué excepciones se devuelven?



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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

SimpleDateFormat.

g. Busque el método format. El método format acepta tres argumentos. Una vez más, hay una versión más simple de este método definida en la clase DateFormat que utiliza en esta práctica. Haga clic en el enlace format situado bajo la cabecera Specified by para ver la documentación de DateFormat de este método.

h. Desplácese hacia abajo para buscar el método format de un argumento. Observe que acepta un único argumento de objeto Date y devuelve un valor String. ¿Devuelve este método format alguna excepción? (Respuesta: No).

5. En NetBeans, cree una nueva clase Java denominada “DateManipulator”. Proporcione las declaraciones de campo que se indican en la tabla siguiente. Encontrará más instrucciones detalladas a continuación de la tabla.


a. Declare un campo de tipo Date. Nombre: myDate

b. Declare e instancie un campo de tipo SimpleDateFormat con la especificación del formato por defecto en el constructor.

Nombre: simpleDF

Formato por defecto: “MM/dd/yyyy”

c. Agregue las sentencias de importación necesarias.

java.util.Date

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



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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

b. Llame al método parse del objeto SimpleDateFormat.

Por el momento, ignore el signo de error.

Transfiera dateString como el argumento String.

Asigne el valor de retorno al campo myDate.

c. Muestre un mensaje que indique que el método parse es correcto.

d. Muestre el objeto date con formato nativo.

Imprima el objeto Date con una etiqueta adecuada.

e. Llame al método format del objeto SimpleDateFormat con la transferencia de myDate como argumento del método.

Asigne el valor de retorno a formattedDateString.

f. Muestre la cadena de fecha con formato con una etiqueta adecuada.

g. Incluya el código anterior en un bloque try.

try{

// lines of code here

}

h. Capture ParseException y muestre el objeto de excepción.

catch (ParseException ex) {

// display the ex object here

}

i. Agregue la sentencia de importación que falta.

java.text.ParseException

a. Declare una variable String local denominada formattedDateString. Se utilizará para contener la representación String del objeto Date con formato.



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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.

g. Ahora corregirá el error relacionado con el bloque try/catch que falta. Incluya las líneas de código anteriores en un bloque try.

− Indicación: haga clic con el botón derecho en cualquier parte del editor y seleccione Format para corregir el sangrado del código.

h. En la siguiente línea después de la llave de cierre del bloque try, agregue un bloque catch que capture ParseException y muestre el objeto de excepción en la pantalla.

i. Haga clic con el botón derecho en el icono de error en el margen izquierdo y permita que NetBeans proporcione la sentencia de importación que falta (java.text.ParseException).

Solución:

public void parseDate(String myDate){

try{

String formattedDateString;

myDate = simpleDF.parse(dateString);

System.out.println("Parse successful");

System.out.println("Date with native format: "

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




Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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.

Nota: observará que el mensaje “Parse successful” no aparece. Esta visualización concreta se produjo en la línea inmediatamente después de la llamada al método parse. Cuando el método parse devolvió la excepción, el programa fue inmediatamente al bloque catch y el resto de las líneas de código del bloque try no se ejecutaron.



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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 En esta práctica, se asume que los siguientes archivos aparecen en la carpeta de prácticas de esta lección y, por tanto, en el proyecto Practice13:

• Editor.java

• Employee.java

• EmployeeTest.java

• GraphicIllustrator.java

• InvalidSkillException.java

• Manager.java

• Printable.java

• Printer.java

• SkilledEmployee.java

• TechnicalWriter.java

Tareas Suponga que hay una lista de tipos de habilidades válidas que se pueden asociar a un rol de trabajo concreto en el sistema de seguimiento de empleados. En el método setSkill (que pertenece a la clase SkilledEmployee), es necesario realizar algún tipo de validación para determinar si el argumento de habilidad transferido al método es válido para el cargo del empleado. Si la habilidad no es válida, el método devolverá una excepción InvalidSkillException. El método de llamada de la clase EmployeeTest debe capturar esta 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.



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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

InvalidSkillException {

Boolean valid = true;

if(skill == null | skill.length() < 5){

valid = false;

}

else {

valid = true;

}

if (!valid) {

throw new InvalidSkillException(skill +

“ is not valid for the “ +

this.getJobTitle() + “ job.”);

}

else {

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.



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ




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

System.out.println(ex);

}

6. Cambie el argumento String en una de las llamadas a setSkill a un argumento String abreviado (menos de 5 caracteres) para que se considere no válido y se devuelva la excepción.

7. Guarde y compile el programa. Ejecute la clase EmployeeTest y examine la salida.

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



Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ






Una

utho

rized

repr

oduc

tion

or d

istri

butio

n pr

ohib

itedฺ

Cop

yrig

ht 2

012,

Ora

cle

and/

or it

s af

filia

tesฺ

TUTOR -Conceptos Fundamentales de Java SE 7 - Guía de Actividades

Documents

Transcript of TUTOR -Conceptos Fundamentales de Java SE 7 - Guía de Actividades