ORACLE Base de Datos

Fundamentals of the Java
Programming Language,
Java SE 6
Activity Guide
SL-110-SE6-ES Rev E.1
D61796CS10
Edition 1.0
D64160
Copyright © 2008, 2009, Oracle and/or its affiliates. All rights reserved.
Disclaimer
This document contains proprietary information, is provided under a license agreement containing restrictions on use and
disclosure, and is protected by copyright and other intellectual property laws. You may copy and print this document solely for
your own use in an Oracle training course. The document may not be modified or altered in any way. Except as expressly
permitted in your license agreement or allowed by law, you may not use, share, download, upload, copy, print, display,
perform, reproduce, publish, license, post, transmit, or distribute this document in whole or in part without the express
authorization of Oracle.
The information contained in this document is subject to change without notice. If you find any problems in the document,
please report them in writing to: Oracle University, 500 Oracle Parkway, Redwood Shores, California 94065 USA. This
document is not warranted to be error-free.
Sun Microsystems, Inc. Disclaimer
This training manual may include references to materials, offerings, or products that were previously offered by Sun
Microsystems, Inc. Certain materials, offerings, services, or products may no longer be offered or provided.Oracle and its
affiliates cannot be held responsible for any such references should they appear in the text provided.
Restricted Rights Notice

If this documentation is delivered to the U.S. Government or anyone using the documentation on behalf of the U.S.
Government, the following notice is applicable:
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.
Trademark Notice
Oracle and Java are registered trademarks of Oracle and/or its affiliates. Other names may be trademarks of their respective
owners.
AMD, Opteron, the AMD logo, and the AMD Opteron logo are trademarks or registered trademarks of Advanced Micro
Devices. Intel and Intel Xeon are trademarks or registered trademarks of Intel Corporation. All SPARC trademarks are used
under license and are trademarks or registered trademarks of SPARC International, Inc. UNIX is a registered trademark
licensed through X/Open Company, Ltd.
This page intentionally left blank.
This page intentionally left blank.
Contenido
Descripción de la tecnología Java™ ..............................................1-1
Objetivos............................................................................................. 1-1
Contenido de la práctica ................................................................... 1-2
Preguntas de repaso .......................................................................... 1-3
Resumen del ejercicio ........................................................................ 1-5
Análisis de un problema y diseño de la solución .........................2-1
Objetivos............................................................................................. 2-1
Ejercicio 1: análisis del dominio de un problema.......................... 2-4
Preparación ................................................................................ 2-4
Tarea: análisis ............................................................................ 2-4
Ejercicio 2: diseño de la solución ..................................................... 2-6
Tarea: diseño.............................................................................. 2-6
Desarrollo y comprobación de un programa Java........................3-1
Objetivos............................................................................................. 3-1
Ejercicio 1: modificación, compilación y ejecución de un
programa Java ................................................................................. 3-4
Preparación ................................................................................ 3-4
Tarea: compilación y ejecución de un programa Java ......... 3-4
Ejercicio 2: creación, compilación y ejecución de una clase
de Java............................................................................................... 3-6
Tarea: creación y comprobación de una clase de Java......... 3-6
v
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisión E.1
Declaración, inicialización y uso de variables .............................. 4-1
Objetivos............................................................................................. 4-1
Ejercicio 1: uso de variables de tipos primitivos en un
programa .......................................................................................... 4-5
Preparación ................................................................................ 4-5
Tarea: creación de una clase con variables............................ 4-5
Ejercicio 2: uso de operadores y conversión de tipos ................... 4-7
Preparación ................................................................................ 4-7
Tarea 1: cálculo de la edad utilizando operadores............... 4-7
Tarea 2: uso de la conversión de tipos para evitar la
pérdida de datos..................................................................... 4-8
Tarea 3: creación de un programa de conversión de
temperaturas........................................................................... 4-9
Resumen del ejercicio ...................................................................... 4-11
Creación y uso de objetos .............................................................. 5-1
Objetivos............................................................................................. 5-1
Ejercicio 1: creación y manipulación de objetos en Java .............. 5-4
Preparación ................................................................................ 5-4
Tarea 1: inicialización de instancias de los objetos .............. 5-4
Tarea 2: manipulación de referencias a objetos .................... 5-5
Ejercicio 2: uso de la clase String................................................... 5-6
Preparación ................................................................................ 5-6
Tarea: creación y uso de objetos String ............................... 5-6
Ejercicio 3: uso de la especificación del API de Java SE™ ........... 5-7
Tarea: estudio de la especificación del API de Java SE ....... 5-7
Uso de operadores y construcciones de toma de decisiones .... 6-1
Objetivos............................................................................................. 6-1
Ejercicio 1: uso de construcciones if e if/else........................... 6-5
Preparación ................................................................................ 6-5
Tarea 1: escritura de una clase que utilice sentencias
if/else................................................................................... 6-5
Tarea 2: escritura de otra clase que utilice sentencias
if/else................................................................................... 6-6
Ejercicio 2: uso de la sentencia Switch........................................... 6-7
Preparación ................................................................................ 6-7
Tarea: escritura de una clase que utilice la sentencia
switch ..................................................................................... 6-7
vi Programación Java para no Programadores

Uso de construcciones en bucle ....................................................7-1
Objetivos............................................................................................. 7-1
Ejercicio 1: uso del bucle while ....................................................... 7-4
Preparación ................................................................................ 7-4
Tarea 1: escritura de una clase que utilice un bucle while ..... 7-4
Tarea 2: escritura de otra clase que utilice un bucle while..... 7-5
Ejercicio 2: uso del bucle for............................................................ 7-7
Preparación ................................................................................ 7-7
Tarea 1: escritura de una clase que utilice el bucle for....... 7-7
Tarea 2: cambio de un bucle while por un bucle for......... 7-8
Ejercicio 3: uso del bucle do/while................................................. 7-9
Preparación ................................................................................ 7-9
Tarea: escritura de una clase que utilice el bucle do
/while ..................................................................................... 7-9
Desarrollo y uso de métodos ..........................................................8-1
Objetivos............................................................................................. 8-1
Ejercicio 1: uso de argumentos y valores de retorno .................... 8-4
Preparación ................................................................................ 8-4
Tarea: escritura de un método que utiliza argumentos
y valores de retorno ............................................................... 8-4
Ejercicio 2: uso de métodos sobrecargados .................................... 8-6
Preparación ................................................................................ 8-6
Tarea: desarrollo de una clase con un método
sobrecargado........................................................................... 8-6
Implementación de la encapsulación y los constructores...........9-1
Objetivos............................................................................................. 9-1
Ejercicio 1: escritura de clases encapsuladas.................................. 9-4
Preparación ................................................................................ 9-4
Tarea 1: implementación de la encapsulación en una clase......9-4
Tarea 2: acceso a los atributos encapsulados de una clase ....... 9-5
Ejercicio 2: uso de constructores ...................................................... 9-8
Preparación ................................................................................ 9-8
Tarea 1: creación y uso de constructores ............................... 9-8
Tarea 2: creación de constructores para inicializar
objetos ...................................................................................... 9-9
vii
Creación y uso de matrices (arrays) ............................................ 10-1
Objetivos........................................................................................... 10-1
Contenido de la práctica ................................................................. 10-2
Preguntas de repaso ........................................................................ 10-3
Ejercicio 1: creación y uso de arrays unidimensionales ............. 10-4
Preparación .............................................................................. 10-4
Tarea 1: creación de una clase con un array
unidimensional de tipos primitivos .................................. 10-4
unidimensional de objetos.................................................. 10-5
Ejercicio 2: uso de bucles y arrays ................................................. 10-7
Preparación .............................................................................. 10-7
Tarea: uso de un bucle para inicializar un array ................ 10-7
Ejercicio 3: análisis del array args[] ............................................ 10-8
Tarea: creación de un juego utilizando el array args [ ]......10-8
Ejercicio 4: creación y uso de arrays bidimensionales ................ 10-9
Preparación .............................................................................. 10-9
bidimensional ..................................................................... 10-10
Tarea 2: uso de un array bidimensional ............................ 10-10
Tarea 3: comprobación de una clase que contiene
un array bidimensional ..................................................... 10-12
Resumen del ejercicio .................................................................... 10-13
Implementación de la herencia..................................................... 11-1
Objetivos........................................................................................... 11-1
Contenido de la práctica ................................................................. 11-2
Preguntas de repaso ........................................................................ 11-3
Ejercicio 1: diseño de superclases y subclases ............................. 11-4
Tarea 1: identificación de superclases y subclases ............. 11-4
Ejercicio 2: creación y uso de superclases y subclases................ 11-6
Preparación .............................................................................. 11-6
Tarea: creación de clases ........................................................ 11-6
viii Programación Java para no Programadores

Práctica 1
Descripción de la tecnología Java™
Objetivos
La realización de esta práctica le permitirá responder a las preguntas de
repaso.
1-1
Contenido de la práctica
Esta práctica no contiene ningún ejercicio. Sólo tiene que responder a las
preguntas de repaso del módulo.
1-2 Programación Java para no Programadores

Preguntas de repaso
Preguntas de repaso
En esta sección, responderá a algunas preguntas relativas a los temas
tratados en el Módulo 1 del Manual del alumno.
Responda a las preguntas siguientes:

1. El lenguaje Java™ se considera un lenguaje de programación
independiente de la plataforma porque:
a. Puede compilarse en diferentes plataformas sin necesidad de
sufrir modificaciones.
b. No permite utilizar punteros para administrar la memoria.
c. Permite a los desarrolladores escribir las aplicaciones una vez y
ejecutarlas en varias plataformas.
d. Es multihilo.
2. Indique si la afirmación siguiente es verdadera o falsa:
Una aplicación se ejecuta dentro de un sistema operativo.
3. Cuál de los siguientes lenguajes guarda más similitudes con el
lenguaje Java:
a. C++
b. C
c. El lenguaje máquina
d. Fortran
4. El grupo de productos de la tecnología Java destinado al desarrollo
de aplicaciones para dispositivos de consumo es el _______. Elija una
de las respuestas siguientes para rellenar el espacio en blanco:
a. SDK de Java SE
b. SDK de Java ES
c. SDK de Java EE
d. SDK de Java ME
Descripción de la tecnología Java™ 1-3

Preguntas de repaso
5. Cuál de los siguientes componentes forma parte del SDK de Java SE:
a. El entorno de ejecución de Java (JRE)
b. La especificación de la máquina virtual de Java
c. Un compilador de C++
d. Un enlazador
6. ¿En qué fase del ciclo de vida de los productos crean los
desarrolladores las actualizaciones para sus productos?
a. Análisis
b. Mantenimiento
c. Final del ciclo de vida
d. Diseño
7. La fase de implementación del ciclo de vida de los productos suele
ser sinónimo de:
a. Vender el programa.
b. Ejecutar el programa.
c. Compilar el programa.
d. Realizar el mantenimiento del programa.

Resumen del ejercicio
Discusión: Dedique unos minutos a comentar las conclusiones o

experiencias extraídas de las prácticas.
!
?
● Experiencias
● Interpretaciones
● Conclusiones
● Aplicaciones
Descripción de la tecnología Java™ 1-5

Práctica 2
Análisis de un problema y diseño de la

solución
Objetivos
La realización de esta práctica le permitirá:
● Responder a las preguntas de repaso.
● Analizar problemas utilizando el análisis orientado a objetos (OO).
● Diseñar clases con las que crear objetos.
2-1
En esta práctica, responderá a las preguntas de repaso y realizará dos
ejercicios.
Los ejercicios consistirán en:

● Enumerar los objetos, atributos y operaciones de un dominio en un
caso propuesto como ejemplo.
● Modelar un objeto utilizando una notación de tipo UML.

Preguntas de repaso
Preguntas de repaso
1. Cuál de los términos siguientes hace referencia al ámbito de un
problema o un sistema:
a. El contexto del problema
b. El dominio del problema
c. El contexto del sistema
d. El área del problema
2. ¿Cuál de los términos siguientes representa dos características
diferentes de un objeto:
a. Métodos y operaciones
b. El dominio del problema
c. Atributos y operaciones
d. Variables y datos
3. Cuál de los elementos siguientes sirve de criterio para comprobar la
validez de un objeto con respecto al dominio de un problema:
a. Relevancia para el dominio del problema
b. Orden de las operaciones
c. Tipo de atributo
d. Si la clase tiene una superclase
4. Cuáles de las siguientes afirmaciones son ciertas:
a. Una clase es una instancia de un objeto.
b. Un objeto es un prototipo de una clase.
c. Un objeto y una clase son exactamente lo mismo.
d. Un objeto es una instancia de una clase.
e. Un atributo no puede actuar como referencia de otro objeto.
Análisis de un problema y diseño de la solución 2-3

Ejercicio 1: análisis del dominio de un problema

Este ejercicio se basa en un pequeño caso de estudio. En él deberá
identificar los objetos, sus atributos y las operaciones que intervienen en
el dominio del sistema.
Preparación
Lea el caso siguiente y modele el sistema eligiendo los objetos, sus
atributos y las operaciones necesarias.
Caso de estudio
En una liga de fútbol intervienen muchos jugadores. Cada año contiene
tres temporadas y es preciso formar equipos para cada temporada de la
liga. Cada equipo se compone de 15 jugadores. En cada temporada se
hace el seguimiento de los goles marcados por cada jugador. También se
lleva un registro de los partidos disputados entre los diferentes equipos,
los resultados finales y la posición de cada equipo en el ranking en
función de los partidos ganados y perdidos.
Tarea: análisis
Deberá realizar un análisis orientado a objetos para el desarrollo de una
aplicación Java que haga el seguimiento de los resultados de la liga de
fútbol. El programa deberá llevar el registro de:
● Las lista de jugadores en cada equipo.
● El número de goles marcado por cada jugador.
● Los partidos celebrados en cada temporada, incluidos los equipos
que han jugado entre sí, y el marcador final.
La aplicación debería ser capaz de generar estadísticas relativas a los

equipos, los jugadores y las temporadas.
Para finalizar el análisis, lleve a cabo estos pasos:

1. Cree una lista de los objetos potenciales.
2. Aplique las reglas descritas en el módulo para determinar si todos
esos objetos son válidos.
3. Cree una lista de atributos y operaciones para cada uno de los
objetos.

Notas

Ejercicio 2: diseño de la solución

En este ejercicio, utilizará la notación UML para representar las clases.
Tarea: diseño
Deberá realizar el diseño de cada una de las clases creadas en el sistema
anterior para hacer el seguimiento de los resultados de la liga de fútbol.
No olvide:
● Utilizar la escritura abreviada para asignar el nombre a las clases, las
variables de los atributos y los métodos.
● Identificar un rango válido de valores para cada atributo (cuando
haya un rango).
● Utilizar paréntesis para identificar los métodos.

Notas


!
?
● Experiencias
● Conclusiones
● Aplicaciones

Práctica 3
Desarrollo y comprobación de un programa

Java
Objetivos
● Escribir, modificar, compilar y ejecutar clases de Java.
3-1
ejercicios.
● En el primer ejercicio, compilará y ejecutará una clase de Java
existente.
● En el segundo, escribirá, compilará y ejecutará su primera clase en
Java.

Preguntas de repaso
Preguntas de repaso
1. Cuál de las opciones siguientes forma parte de la sintaxis de
declaración de clases:
a. Argumentos de la clase
b. Identificador del método
c. Modificador
d. //
2. Indique cuál de las siguientes afirmaciones describe mejor el método
main:
a. El método main es el punto de partida para todos los applets
Java.
b. El método main normalmente tiene un tipo de retorno int.
c. El método main es obligatorio en todas las clases de Java.
d. main es un método especial que la máquina virtual de Java
reconoce como punto de partida para cualquier programa Java
que se ejecute desde un indicador o una línea de comandos.
3. Indique si las afirmaciones siguientes son verdaderas o falsas:
a. El comando java ejecuta una clase o archivo de código de byte.
b. Cada llave de apertura en un programa Java debe tener su
correspondiente llave de cierre.
c. */ es un delimitador válido para iniciar un comentario.
d. El comando javac lee las definiciones de clase e interfaz
escritas en lenguaje Java y las compila para convertirlas en
archivos de clase formados por código de byte.
Desarrollo y comprobación de un programa Java 3-3

Ejercicio 1: modificación, compilación y ejecución de un programa Java
Ejercicio 1: modificación, compilación y ejecución de un

programa Java
Se ha creado un programa Java para el ejercicio. Deberá abrirlo, examinar
las líneas de código, modificarlo, compilarlo y ejecutarlo para comprobar
si es correcto.
Preparación
Asegúrese de que el directorio
SL110/exercises/03_getstarted/exercise1 contenga los archivos
QuotationTest.java y Quotation.java.
Tarea: compilación y ejecución de un programa Java

En esta tarea, deberá modificar un programa Java, guardarlo, compilarlo y
verificarlo.
Lleve a cabo los pasos siguientes:

1. Abra un editor de texto.
2. Abra el archivo Quotation.java situado en el directorio
SL110/exercises/03_getstarted/exercise1.
3. Examine la clase Quotation e identifique su variable miembro.
4. En el método display, escriba código para mostrar en pantalla el
valor de esa variable.
5. Guarde y cierre el archivo Quotation.java.
6. Abra el archivo QuotationTest.java situado en el directorio
SL110/exercises/03_getstarted/exercise1 y examine su
método main. El método main crea una instancia de la clase Quotation
y ejecuta el método display de Quotation. Cierre el archivo.
7. Abra la ventana de terminal y vaya al directorio
8. Compile el archivo Quotation.java utilizando el comando javac.
Por ejemplo:
javac Quotation.java

Ejercicio 1: modificación, compilación y ejecución de un programa Java
9. Si es necesario, modifique el archivo Quotation.java para corregir

cualquier error de compilación generado en el paso anterior.
Guarde el archivo y vuelva a compilarlo.
10. Compile el archivo QuotationTest.java con el comando javac.
Por ejemplo: javac QuotationTest.java
11. Examine el directorio
SL110/exercises/03_getstarted/exercise1 para verificar si las
operaciones de compilación han creado los siguientes archivos
de clase:
● Quotation.class
● QuotationTest.class.
12. Ejecute el archivo QuotationTest.class utilizando el comando
java y verifique la salida. Por ejemplo: java QuotationTest
13. Abra el archivo Quotation.java, cambie el valor predeterminado
de la variable miembro del archivo Quotation.java por un valor
de su elección y guarde el archivo.
14. Compile el archivo Quotation.java.
15. Ejecute el archivo QuotationTest.class y compruebe si ha
cambiado la salida.

Ejercicio 2: creación, compilación y ejecución de una clase de Java
Ejercicio 2: creación, compilación y ejecución de una clase

de Java
En este ejercicio, creará una clase de Java y la compilará. Luego creará otra
clase para comprobar la clase anterior.
Tarea: creación y comprobación de una clase de Java

En esta tarea, creará dos clases y las compilará. También ejecutará el
archivo de una clase.

1. Vaya al directorio SL110/exercises/03_getstarted/exercise2.
2. Abra un editor e introduzca la sintaxis Java de la clase Shirt que
aparece en el Código 3-1 de la página 3-8 en el Manual del alumno.
3. Guarde y cierre el archivo.
4. Abra un editor e introduzca la clase ShirtTest que aparece en el
Código 3-2 de la página 3-14 en el Manual del alumno.
5. Guarde y cierre el archivo.
6. Abra una ventana de terminal y sitúese en el directorio de este
módulo.
7. Escriba el comando necesario para compilar la clase Shirt y
convertirla en un archivo de código de byte ejecutable. Por ejemplo:
javac Shirt.java
8. Compruebe si se ha creado el archivo Shirt.class en el directorio
9. Escriba el comando necesario para compilar la clase ShirtTest y
convertirla en un archivo de código de byte ejecutable.
javac ShirtTest.java
10. Compruebe si se ha creado el archivo ShirtTest.class en el
directorio SL110/exercises/03_getstarted/exercise2.
11. Escriba el comando necesario para ejecutar el archivo
ShirtTest.class y examine la salida del programa.
java ShirtTest
12. Vuelva a abrir el archivo Shirt.java en el editor.
13. Modifique los valores de las variables miembro ShirtID y price.

Ejercicio 2: creación, compilación y ejecución de una clase de Java
14. Guarde y cierre el archivo Shirt.java.

15. Recompile el archivo Shirt.java en la ventana de terminal.
javac Shirt.java
16. Ejecute el archivo ShirtTest.class en la ventana de terminal.
java Shirt
17. Examine la salida del programa y verifique si difiere de la salida
obtenida en el paso 9.


!
?
● Experiencias
● Conclusiones
● Aplicaciones

Práctica 4
Declaración, inicialización y uso de variables
Objetivos
● Realizar la declaración de variables en una clase.
● Efectuar conversiones de tipos y utilizar operadores en un programa
Java.
4-1
ejercicios.
● En el primer ejercicio, creará una clase de Java que contiene
declaraciones de variables.
● En el segundo ejercicio, escribirá un programa Java en el que
utilizará operadores y realizará conversión de tipos.

Preguntas de repaso
Preguntas de repaso
a. El lenguaje Java contiene ocho tipos primitivos.
b. En programación Java, las variables intgrade e intGrade son
iguales.
c. byte, short, int y long son cuatro tipos primitivos enteros del
lenguaje Java.
d. Las variables de tipos booleanos pueden contener los valores
true, false y nil.
2. Qué respuesta describe mejor la siguiente declaración de variable:
final double PI = 3.14159;
a. Es la asignación de valor para un tipo primitivo entero.
b. El nombre de la variable es una palabra clave reservada del
lenguaje Java.
c. La variable es una constante.
d. El nombre de la variable no es correcto, no sigue las reglas de la
nomenclatura en Java.
3. Cuáles de las operaciones siguientes ilustran correctamente la
precedencia de operadores en el cálculo siguiente:
X = 1 + 2 * 5 -8 +6 / 7 * 4;
a. (1 + 2) * (5 - 8) + (6 / (7 * 4))
b. 1 + (2 * 5) - 8 + ((6 / 7) * 4)
c. (1 + 2) * (5 - ((8 + 6) / (7 * 4)))
d. 1 + (2 * (5 - 8)) + ((6 / 7) * 4)
Declaración, inicialización y uso de variables 4-3

Preguntas de repaso
4. Examine el código siguiente y seleccione la salida correcta después

de la ejecución:
int a = 5;
int b = ++a;
System.out.println("a = "+ a + "y b = "+ b);
a. a = 5yb = 5
b. a = 5yb = 6
c. a = 6yb = 6
d. a = 6yb = 5

Ejercicio 1: uso de variables de tipos primitivos en un programa
Ejercicio 1: uso de variables de tipos primitivos en un

programa
En este ejercicio, creará una clase que contiene declaraciones de variables.
Preparación
SL110/exercises/04_variables/exercise1 contenga el archivo
CustomerTest.java.
Tarea: creación de una clase con variables

En esta tarea, compilará y ejecutará una clase Customer con varias
variables.
Lleve a cabo los pasos siguientes para crear la clase Customer:

1. Vaya al directorio SL110/exercises/04_variables/exercise1.
2. Abra un editor de texto y cree un archivo llamado Customer.java
en este directorio.
3. En el archivo Customer.java, escriba una clase llamada Customer
(cliente) que cree y asigne a las variables valores predeterminados
para suministrar la información siguiente (utilice constantes
cuando sea apropiado):
● El ID de un cliente
● El estado del cliente: “N” para nuevo y “O” para antiguo (old)
● El total de compras del año
4. Cree un método en la clase denominada displayCustomerInfo que
utilice el método System.out.println para imprimir cada valor
en la pantalla con su correspondiente etiqueta (por ejemplo,
"Total de compras:").
5. Compile y ejecute el programa utilizando el archivo de clase
CustomerTest suministrado.

Ejercicio 1: uso de variables de tipos primitivos en un programa
Nota: Todos los ejemplos y ejercicios de este curso necesitan una clase
test. En la mayoría de los casos, esta clase ya viene dada. En algunas
situaciones, será usted quien la cree.
6. Compruebe la salida del programa para asegurarse de que contenga

los valores que ha asignado.

Ejercicio 2: uso de operadores y conversión de tipos

El objetivo de este ejercicio es ayudarle a practicar el uso de los
operadores y la conversión de tipos.
Incluye tres tareas. En cada una de ellas deberá crear un programa Java,
compilarlo y probarlo.
Este ejercicio consta de las siguientes tareas:

● “Tarea 1: cálculo de la edad utilizando operadores”
● “Tarea 2: uso de la conversión de tipos para evitar la pérdida de
datos”
● “Tarea 3: creación de un programa de conversión de temperaturas”
Preparación
SL110/exercises/04_variables/exercise2 contenga los archivos
PersonTest.java, OrderTest.java y TemperatureTest.java.
Tarea 1: cálculo de la edad utilizando operadores

En esta tarea, utilizará los operadores para calcular edades expresadas en
minutos y milisegundos.
Siga estos pasos para crear una clase Person que calcule varias edades:
1. Abra una ventana de terminal y vaya al directorio
SL110/exercises/04_variables/exercise.
2. Abra un editor de texto y cree una clase Person en un archivo.
3. Agregue el código siguiente a la clase Person:
a. Cree variables miembro para almacenar la edad en años, días,
minutos, segundos y milisegundos.
b. Defina un valor inicial de 1 para la variable que almacena la
edad en años.

Nota: Asegúrese de asignar los tipos de datos correctos para cada variable
y utilice nombres que resulten significativos para todas las variables.
c. Cree un método calculateAge en la clase Person.

d. En el método, calcule la edad en días, minutos, segundos y
milisegundos, y asigne los nuevos valores a las
correspondientes variables miembro.
e. Haga que el método muestre en pantalla todas las edades
expresadas en diferentes unidades, cada una en una línea
distinta y con el mensaje adecuado. Por ejemplo: “Tienes
31536000 segundos de edad”.
f. Guarde y cierre el archivo Person.java.
g. Compile los archivos Person.java y PersonTest.java.
Resuelva cualquier error de compilación que se haya producido
y recompile.
h. Verifique el programa utilizando la clase PersonTest.
i. Lleve a cabo algunas pruebas definiendo age con los valores 1,
24 y 80 en la clase Person.
Nota: Para un año, el resultado debería ser: Tienes 365 días de edad. Tienes
31536000 segundos de edad. Tienes 525600 minutos de edad. Tienes
31536000000 milisegundos de edad. Para 24 años, el resultado debería ser:
Tienes 8760 días de edad. Tienes 756864000 segundos de edad. Tienes
12614400 minutos de edad. Tienes 756864000000 milisegundos de edad.
Tarea 2: uso de la conversión de tipos para evitar la

pérdida de datos
En esta tarea, utilizará la conversión de tipos para impedir que se
produzcan pérdidas de datos en sus programas.

1. Cree una clase llamada Order que contenga tres variables miembro
como las siguientes:
a. long orderValue=0
b. int itemQuantity=10000000
c. int itemPrice=555500

2. Cree un método calculateTotal que calcule el valor total de los

pedidos y lo muestre en la pantalla. Asegúrese de aplicar la
conversión de tipos al resultado de la multiplicación antes de
almacenarlo en orderValue.
3. Guarde y cierre el archivo Order.java.
4. Compile los archivos Order.java y OrderTest.java.
5. Pruebe el programa ejecutando el archivo OrderTest.class.
Compruebe el resultado de orderValue haciendo la operación con
una calculadora.
6. Abra Order.java y suprima la conversión de tipos realizada en el
método calculateTotal. Guarde y cierre el archivo.
7. Recompile el archivo Order.java y vuelva a ejecutar la clase
OrderTest.
8. Compare el resultado actual de orderValue con el obtenido en el
paso 5.
9. Pruebe el programa sustituyendo el valor de las variables de tipo
entero definidas en la clase Order por:
a. Tipos int de un dígito
b. Tipos int de cinco dígitos
c. Tipos int de nueve dígitos
Compruebe si obtiene con el programa el mismo resultado que
obtiene al realizar cada operación con la calculadora.
Tarea 3: creación de un programa de conversión de

temperaturas
En esta tarea, deberá escribir un programa para convertir grados
Fahrenheit en grados Celsius.
Escriba código para llevar a cabo estos pasos:

1. Cree una clase Temperature con una variable miembro que
almacene la temperatura en valores Fahrenheit. Declare la variable con
un tipo de datos apropiado como, por ejemplo, int, float o double.
2. Cree un método llamado calculateCelsius.
3. En el método calculateCelsius, utilice la información siguiente
para convertir los valores de temperatura Fahrenheit en Celsius.
● Para realizar la conversión de Fahrenheit en Celsius, reste 32,
multiplique por 5 y divida entre 9.

4. Pruebe el programa utilizando la clase TemperatureTest.
5. Compruebe si obtiene con el programa el mismo resultado que
obtiene al realizar la operación con la calculadora.
6. Verifique el programa utilizando diferentes valores de temperatura.

!
?
● Experiencias
● Conclusiones
● Aplicaciones


Práctica 5
Creación y uso de objetos
Objetivos
● Crear y manejar objetos.
● Usar la clase String.
● Usar el API de Java SE™.
5-1
En esta práctica, responderá a las preguntas de repaso y realizará tres
ejercicios.
● En el primer ejercicio, creará y manejará objetos de Java.
● En el segundo, creará y utilizará objetos String.
● En el tercero, se familiarizará con la especificación del API de Java.

Preguntas de repaso
Preguntas de repaso
1. ¿Cuál de las siguientes líneas de código instancia un objeto Boat y lo
asigna a una referencia de objeto sailBoat?
a. Boat sailBoat = new Boat();
b. Boat sailBoat;
c. Boat = new Boat()
d. Boat sailBoat = Boat();
2. Lea el código siguiente e identifique el resultado correcto entre las
opciones dadas a continuación:
Clothing myHat = new Hat();
Clothing mySock = new Sock();
myHat = mySock;
a. La variable myHat ahora contiene un objeto Sock.
b. La variable myHat contiene la misma dirección que la variable
mySock.
c. Las variables Sock y Hat son las mismas.
d. La variable myHat se mantiene sin cambios.
3. ¿Cuáles de las siguientes afirmaciones son ciertas?
a. El operador punto (.) crea una nueva instancia de un objeto.
b. La clase String permite guardar una secuencia de caracteres.
c. La especificación del API de Java contiene documentación para
todas las clases contenidas en los productos Java.
d. Los tipos String constituyen una excepción porque son la
única clase que permite crear objetos sin usar la palabra clave
new.
Creación y uso de objetos 5-3

Ejercicio 1: creación y manipulación de objetos en Java

En este ejercicio, deberá crear instancias de una clase y operar con ellas de
diferentes maneras.
El ejercicio consta de las siguientes tareas:

● “Tarea 1: inicialización de instancias de los objetos”
● “Tarea 2: manipulación de referencias a objetos”
Preparación
SL110/exercises/05_objects/exercise1 contenga el archivo
Customer.java.
Tarea 1: inicialización de instancias de los objetos

Se le ha suministrado la clase Customer. En esta tarea, deberá crear,
compilar y ejecutar una clase CustomerTest. En la clase CustomerTest,
creará objetos de la clase Customer y definirá los valores de sus
variables miembro.

1. Vaya al directorio SL110/exercises/05_objects/exercise1 y
abra el archivo Customer.java.
2. Examine la clase Customer, sus variables miembro y su método.
3. Cree la nueva clase CustomerTest y guárdela como
CustomerTest.java.
4. Cree el método main en la clase CustomerTest.
5. En el método main, haga lo siguiente:
a. Declare dos instancias de la clase Customer.
b. Inicialice las dos instancias de la clase Customer utilizando el
operador new.
c. Asigne valores a las variables miembro de la instancia de
Customer. Vuelva a hacer lo mismo con el segundo objeto de
Customer pero utilizando otros valores. Por ejemplo:
cObject1.customerID=1;

d. Llame al método displayCustomerInfo por cada uno de los

objetos de Customer.
6. Guarde, compile y ejecute el programa.
7. Compruebe la salida para asegurarse de que cada objeto de
Customer muestre los diferentes valores asignados.
Tarea 2: manipulación de referencias a objetos

En esta tarea, asignará el valor de una referencia de objeto a otra
referencia de objeto. Lleve a cabo los pasos siguientes:
1. Abra el archivo CustomerTest.java creado y ejecutado en la tarea
anterior.
2. En el método main, vaya a la línea donde se efectúa la llamada al
método displayCustomerInfo para ambas instancias de Customer.
3. Asigne una referencia de objeto a otra referencia de objeto antes
de llamar al método displayCustomerInfo para ambas instancias.
Por ejemplo: cObject2=cObject1 (suponiendo que cObject1 y
cObject2 sean las dos instancias de la clase Customer).
4. Guarde, compile y ejecute el programa.
5. Compruebe la salida de los métodos displayCustomerInfo de
ambos objetos.

Ejercicio 2: uso de la clase String
Ejercicio 2: uso de la clase String

El objetivo de este ejercicio es crear e inicializar objetos String e imprimir
su contenido.
Preparación
SL110/exercises/05_objects/exercise2 contenga el archivo
PersonTwoTest.java. Éste será su directorio de trabajo.
Tarea: creación y uso de objetos String

En esta tarea, deberá escribir una clase llamada PersonTwo que cree e
inicialice dos variables de tipo String y muestre sus valores en la
pantalla. Siga estos pasos para crear la clase:
1. Sitúese en el directorio de trabajo.
2. Declare una clase llamada PersonTwo que cree e inicialice dos
variables:
● La primera variable almacena una cita pronunciada por
alguien.
● La segunda variable almacena el nombre de la persona que dijo
la cita.
3. Utilice un método llamado displayQuote para mostrar en pantalla
la cita y el nombre de la persona que la pronunció.
4. Compile su clase.
5. Ejecute su clase utilizando la clase PersonTwoTest suministrada.

Ejercicio 3: uso de la especificación del API de Java SE™
Ejercicio 3: uso de la especificación del API de Java SE™

El objetivo de este ejercicio es familiarizarle con la especificación del API
de Java SE.
Tarea: estudio de la especificación del API de Java SE
Nota: El propósito de este ejercicio es ayudarle a familiarizarse con la

documentación y la forma de buscar clases y métodos. No se espera
que comprenda toda la información que va a examinar. A medida que
vaya avanzando en el curso, la documentación del API irá cobrando
más sentido para usted.
Para ver la especificación del API de Java 6.0:

1. Vaya a la dirección siguiente:
http://java.sun.com/javase/6/docs/
2. Desde el sitio indicado, busque la especificación del API.
3. Utilizando la especificación del API como referencia, haga lo
siguiente:
a. Localice la clase Math del paquete java.lang.
¿Cuántos métodos contiene esta clase?
b. ¿A qué clase hacen referencia todas las clases que hay al inicio
de la página?
Pista: ¿qué clase es la superclase de todas las clases?
4. Busque la clase String. Identifique los métodos de la clase String
que permiten comparar dos cadenas de caracteres.


!
?
● Experiencias
● Conclusiones
● Aplicaciones

Práctica 6
Uso de operadores y construcciones de

toma de decisiones
Objetivos
● Utilizar las sentencias if e if/else en un programa Java.
● Usar la sentencia switch en un programa Java.
6-1
ejercicios.
● En el primer ejercicio, creará construcciones if e if/else.
● En el segundo ejercicio, creará construcciones switch.

Preguntas de repaso
Preguntas de repaso
1. ¿Qué finalidad tiene el bloque else en una sentencia if-else?
a. Contener el resto del código de un método.
b. Contener el código que se ejecuta cuando la expresión de una
sentencia if es false.
c. Comprobar si una expresión es falsa (false).
2. ¿Cuál de las sentencias siguientes es adecuada para comprobar un
valor en una construcción switch?
a. La sentencia switch comprueba si los valores son mayores o
menores que un único valor.
b. La sentencia switch verifica una sola variable.
c. La sentencia switch comprueba el valor de un tipo de datos
float, double o boolean.
3. ¿Qué operadores relacionales y condicionales se mencionan en el
párrafo siguiente?
Si son las 8:00 de la mañana, es hora de ir a trabajar y tomar un café.
Si han pasado ya las 12 del mediodía, es el momento de almorzar o
tomarse un té. Si son las 5:00 de la tarde o pasada esa hora, es el
momento de volver a casa.
a. ==, >, =>
b. ==, &&, <
c. ==, &&, >
d. ==, ||, >
Uso de operadores y construcciones de toma de decisiones 6-3

Preguntas de repaso
4. Lea el fragmento de código siguiente e identifique las opciones

correctas:
1 String clothing1;
2 String clothing2;
3 clothing1 = "socks";
4 clothing2 = "pants";
5 if (clothing1 == clothing2)
a. La línea 5 comprueba si las cadenas String indicadas por las
referencias clothing1 y clothing2 son iguales.
b. La línea 5 comprueba las referencias de los objetos String en la
memoria, no su contenido.
c. Al sustituir la línea 5 por la sentencia
if (clothing1.equals(clothing2)), las secuencias de
caracteres a las que hacen referencia clothing1 y clothing2
son iguales.
d. La línea 5 siempre devuelve true.

Ejercicio 1: uso de construcciones if e if/else

El objetivo de este ejercicio es crear clases que utilicen las construcciones
if e if/else.
Preparación
SL110/exercises/06_decision/exercise1 contenga los archivos
DateTwoTest.java y ClockTest.java. Éste será su directorio de trabajo.
Este ejercicio incluye dos tareas. En cada una de ellas deberá crear
una clase y utilizar las sentencias if/else cuando sean aplicables.
Las tareas son:
● “Tarea 1: escritura de una clase que utilice sentencias if/else”
● “Tarea 2: escritura de otra clase que utilice sentencias if/else”
Tarea 1: escritura de una clase que utilice sentencias

if/else
En esta tarea deberá escribir una clase llamada DateTwo que utilice
las sentencias if/else para mostrar el día de la semana en función del
valor de una variable. Siga estos pasos para escribir la clase:
1. Sitúese en el directorio de trabajo. Cree una clase llamada DateTwo
con una variable miembro denominada dayNumber. Asigne a
dayNumber un valor situado entre 1 y 7, donde:
● El número 1 representa el lunes (primer día de la semana).
● El número 7 representa el domingo (último día de la semana).
2. En la clase DateTwo, cree un método denominado displayDay que
utilice construcciones if/else para comprobar el valor de
dayNumber y muestre en la pantalla el correspondiente día de la
semana. El método displayDay también debería presentar un
mensaje de error si se encuentra un número no admitido.
3. Guarde, compile y ejecute su clase utilizando el archivo de clase
DateTwoTest suministrado.
4. Repita el paso 3 varias veces asignando diferentes valores a la
variable dayNumber de DateTwo en el archivo DateTwoTest.java.

Tarea 2: escritura de otra clase que utilice sentencias

if/else
En esta tarea deberá escribir una clase llamada Clock que utilice las
sentencias if/else para mostrar en qué parte del día nos encontramos
en función de la hora que marque el reloj. Utilice la tabla siguiente
como referencia.
Hora del día Parte del día
De 8:01 a 12:00 Mañana

De 12:01:00 a 17:00:00 Tarde
De 17:01 a 24:00 Tarde-noche
De 00:01:00 a 08:00:00 Madrugada
Siga estos pasos para escribir la clase:

2. Cree una clase llamada Clock (reloj) con una variable denominada
currentTime que contenga la hora del día.
3. En la clase Clock, cree un método displayPartOfDay que utilice
las construcciones if/else para mostrar la parte del día asociada
al valor de la variable currentTime. Por ejemplo, si el valor de
la variable currentTime es igual a 1504, el programa debería
presentar la palabra “Tarde”.
4. Compile y ejecute el programa utilizando el archivo de clase
ClockTest.
variable currentTime de Clock en el archivo ClockTest.java.
Nota: Si se antepone un cero al valor de la variable, quiere decir que es un

valor octal. Por tanto, el programa no se compilará si se define
currentTime con la cifra 0800. Es preciso especificar currentTime como
800 para la hora 8:00 AM a fin de que el programa se compile
adecuadamente. No se han realizado pruebas con valores que queden
fuera del intervalo situado entre 100 y 2400.

Ejercicio 2: uso de la sentencia Switch
Ejercicio 2: uso de la sentencia Switch

El objetivo de este ejercicio es practicar el uso de la construcción switch
en programas de toma de decisiones. En este ejercicio, deberá crear un
programa que presente el nombre del mes en función del número de
mes indicado.
Preparación
SL110/exercises/06_decision/exercise2 contenga el archivo
MonthTest.java. Éste será su directorio de trabajo.
Tarea: escritura de una clase que utilice la sentencia

switch
En esta tarea creará una clase llamada Month que utilice sentencias switch
para indicar el nombre del mes en función del valor numérico de una
variable.

1. En el directorio de trabajo, cree una clase llamada Month (mes) y
guarde el archivo con el nombre Month.java.
2. En la clase Month, cree una variable llamada monthNumber. Asigne a
la variable un valor situado entre 1 y 12, donde el número 1
representa el mes de enero y el 12 el mes de diciembre.
3. En la clase Month, cree un método llamado displayMonth que utilice
una construcción switch para evaluar el valor de la variable
monthNumber y presentar en la pantalla el nombre del mes
correspondiente. El método displayMonth también debería
presentar un mensaje de error si se utiliza un número no válido.
4. Guarde y compile el archivo.
5. Ejecute el programa utilizando el archivo de clase MonthTest.
variable monthNumber de Month en el archivo MonthTest.java.


!
?
● Experiencias
● Conclusiones
● Aplicaciones

Práctica 7
Uso de construcciones en bucle
Objetivos
● Utilizar los bucles while y do/while en un programa Java.
● Usar bucles for en un programa Java.
7-1
ejercicios.
● En el primero de ellos, creará construcciones de bucle while.
● En el segundo, creará construcciones de bucle for.
● En el tercero, creará construcciones de bucle do/while.

Preguntas de repaso
Preguntas de repaso
1. Rellene el espacio en blanco de la frase siguiente con una de
las opciones dadas a continuación. Las/los ________________
permiten evaluar y volver a evaluar una decisión para ejecutar
una o varias veces un bloque de código.
a. clases
b. objetos
c. bucles
d. métodos
2. Qué tipo de bucle permite declarar una variable como parte de su
construcción:
a. El bucle do/while
b. El bucle while
c. El bucle while anidado
d. El bucle for
3. Cuál de los siguientes tipos de bucles es un bucle iterativo que se
procesa de una a muchas veces:
a. El bucle while
b. El bucle while anidado
c. El bucle do/while
d. El bucle for
4. Indique si la afirmación siguiente es verdadera o falsa:
Para evaluar una secuencia de sentencias un número predefinido
de veces conviene usar el bucle for.
Uso de construcciones en bucle 7-3

Ejercicio 1: uso del bucle while

El objetivo de este ejercicio es crear clases que utilicen construcciones en
bucle con while.
Preparación
Asegúrese de que el directorio SL110/exercises/07_loops/exercise1
contenga los archivos CounterTest.java y SequenceTest.java. Éste
será su directorio de trabajo.
Este ejercicio incluye dos tareas. En cada una de ellas deberá crear una
clase y utilizar los bucles while cuando proceda. Las tareas son:
● “Tarea 1: escritura de una clase que utilice un bucle while”
● “Tarea 2: escritura de otra clase que utilice un bucle while”
Tarea 1: escritura de una clase que utilice un bucle while

En esta tarea, deberá escribir una clase llamada Counter (contador) y
utilizar un bucle while para presentar en pantalla el valor de una variable
(count) que va adoptando valores en incrementos de uno. Siga estos
pasos para crear la clase:
1. Abra la ventana de terminal y sitúese en el directorio de trabajo.
Utilice un editor para crear una clase llamada Counter que contenga
tres variables miembro denominadas MAX_COUNT, step y count.
Asigne el valor 50 a MAX_COUNT, y el valor 1 a count y step.
Asegúrese de declarar MAX_COUNT como variable final.
2. Cree un método public displayCount en la clase que no acepte
ningún argumento y devuelva void. Por ejemplo:
public void displayCount(){
3. En este método, cree un bucle while con las siguientes
características:
a. Expresión booleana: repetir si el valor de count es menor o igual
que el valor de MAX_COUNT.
b. Bloque de código:
● Imprimir en la pantalla el valor de la variable count.
● Incrementar el valor de count con el valor indicado en step.
Por ejemplo: count=count + step;

4. Guarde y compile el archivo Counter.java.

5. Compile el archivo CounterTest.java suministrado en el directorio
de trabajo. Ejecute el archivo de clase CounterTest.
6. Compruebe si la clase creada presenta en la pantalla todos los
números del 1 al 50.
7. Puede modificar el valor de la variable step para cambiar el
resultado de la clase Counter. Lleve a cabo los pasos siguientes:
a. Abra el archivo CounterTest.java para modificarlo.
b. Antes de la llamada al método displayCount, asigne el valor 2
a la variable step de la clase Counter. Utilice el objeto de la
clase Counter para acceder a la variable step.
c. Lleve a cabo los pasos 3 - 4 y verifique la salida. El resultado
debería ser: 1 3 5 7.............49
8. Repita el paso 6 asignando el valor 3 a la variable step. Ésta es la
variable miembro de la clase Counter.
Tarea 2: escritura de otra clase que utilice un bucle

while
En esta tarea escribirá una clase llamada Sequence1 que presente
una secuencia de dígitos iniciada por los número 0 y 1. Los sucesivos
números de la secuencia serán la suma de los dos números anteriores.
Por ejemplo: 0 1 1 2 3 5 8 13 21...... Este tipo de secuencia se denomina
también serie Fibonacci.

1. Sitúese en el directorio de trabajo y abra un editor.
2. Cree una clase llamada Sequence1 con tres variables denominadas
firstNumber, secondNumber y nextNumber. Asigne los valores 0 y 1
a las variables firstNumber y secondNumber respectivamente.
3. Cree un método public denominado displaySequence con ningún
tipo de retorno y sin argumentos. El método debe realizar las
siguientes acciones:
a. Imprimir en la pantalla el valor de firstNumber y
secondNumber para iniciar la secuencia.
b. Calcular la suma de firstNumber y secondNumber, y asignar el
resultado a la variable nextNumber.

4. Cree un bucle while en el método con las siguientes características:

● Expresión booleana: repetir el valor de nextNumber si es menor o
igual que 100.
● Bloque de código:
● Mostrar en la pantalla el valor de la variable nextNumber.
● Asignar el valor de secondNumber a firstNumber y el
valor de nextNumber a la variable secondNumber.
● Recalcular el valor de nextNumber de forma que sea la
suma de los valores de firstNumber y secondNumber.
5. Guarde y compile el archivo Sequence1.java.
6. Compile el archivo SequenceTest.java suministrado en el directorio
de trabajo y ejecute el archivo de clase SequenceTest.
7. Verifique la salida. El resultado debería ser: 0 1 1 2 3 5 8 13 21 34 55 89

Ejercicio 2: uso del bucle for

El objetivo de este ejercicio es usar el bucle for en una clase.
Preparación
contenga los archivos CounterTwoTest.java y Sequence2Test.java.
Éste será su directorio de trabajo.
Este ejercicio incluye dos tareas. En cada una de ellas deberá crear una
clase y utilizar el bucle for cuando proceda.
● “Tarea 1: escritura de una clase que utilice el bucle for”
● “Tarea 2: cambio de un bucle while por un bucle for”
Tarea 1: escritura de una clase que utilice el bucle for

En esta tarea, escribirá una clase que contabilice una serie de números
(del 1 hasta una constante) y presente todos los números de la secuencia
que sean divisibles entre 12.

2. Escriba una clase llamada CounterTwo que contenga una variable
miembro denominada MAX_COUNT. Asigne el valor 100 a la variable.
3. Cree un método public llamado displayCount que no tenga
argumentos ni tipo de retorno, y que haga lo siguiente:
● Efectúe un recuento de números del 1 al valor de la constante
MAX_COUNT utilizando un bucle for. Vaya amentando el
valor de la variable del bucle en incrementos de 1.
● Muestre en la pantalla el valor de la variable del bucle si es
divisible entre 12.
4. Guarde la clase con el nombre de archivo CounterTwo.java y
compílela.
5. Compile el archivo CounterTwoTest.java y ejecútelo para
verificar la salida. El resultado debería ser similar al siguiente:
12 24 36 48 60 72 84 96

Tarea 2: cambio de un bucle while por un bucle for

En esta tarea, modificará la clase creada en la Tarea 2 del Ejercicio 1 para
sustituir el bucle while por un bucle for.

1. Cree una clase Sequence2 similar a la clase Sequence1 de la Tarea 2
realizada en el Ejercicio 1 y guárdela como Sequence2.java en el
directorio de trabajo.
2. Cree otra variable miembro final llamada SEQUENCE_COUNT y
asígnele el valor 10. El resto de las variables miembro deben
permanecer iguales.
3. En el método displaySequence, sustituya el bucle while por un
bucle for de forma que sólo se muestren los 10 primeros valores de
la serie Fibonacci. El resultado debería ser: 0 1 1 2 3 5 8 13 21 34.
4. Guarde y compile el archivo Sequence2.java.
5. Compile el archivo Sequence2Test.java suministrado, ejecútelo y
verifique la salida.

Ejercicio 3: uso del bucle do/while
Ejercicio 3: uso del bucle do/while

El objetivo de este ejercicio es escribir un clase que utilice un bucle
do/while.
Preparación
contenga el archivo DiceTest.java. Éste será su directorio de trabajo.
Tarea: escritura de una clase que utilice el bucle

do/while
En esta tarea, deberá escribir una clase que simule un sencillo juego de
lanzamiento de dos dados. Siga estos pasos para escribir la clase:
2. Escriba una clase llamada Dice (dado) que contenga dos variables
miembro, diceNumber1 y diceNumber2, para almacenar los
números de los dados.
3. Cree un método public llamado throwDice sin argumentos ni tipo
de retorno, y agregue un bucle do/while que haga lo siguiente:
● Bloque de código: generar un número aleatorio entre 1 y 6 y
asignarlo a la variable diceNumber1. Repetir la operación
con la variable diceNumber2. Por ejemplo:
diceNumber1=(int)(Math.random()*6) +1;
Mostrar en la pantalla el valor de las variables diceNumber1
y diceNumber2.
● Expresión booleana: repetir si diceNumber1 es igual que
diceNumber2.
4. Guarde y compile la clase Dice.
5. Utilice el archivo DiceTest.java para comprobar el resultado de la
clase Dice.
6. Verifique si aparecen en la pantalla los valores de diceNumber1 y
diceNumber2.


!
?
● Experiencias
● Conclusiones
● Aplicaciones

Práctica 8
Desarrollo y uso de métodos
Objetivos
● Crear métodos y usarlos en un programa Java.
● Usar la sobrecarga de métodos en un programa Java.
8-1
ejercicios.
● En el primero de ellos, creará métodos y efectuará la llamada para su
ejecución.
● En el segundo, aplicará la sobrecarga de métodos.

Preguntas de repaso
Preguntas de repaso
1. Indique cuáles de las siguientes afirmaciones son ciertas:
a. Una clase sólo puede contener la declaración de un método.
b. La forma más básica de método es aquella que tiene un tipo de
retorno pero carece de argumentos.
c. Todos los métodos de llamada pueden ser métodos worker y
todos los métodos worker pueden ser métodos de llamada.
d. Los métodos sobrecargados tienen el mismo número de
argumentos.
2. Cuál de los siguientes tipos de argumentos acepta el método main:
a. Un objeto String
b. Un tipo int
c. Un array de referencias a objetos String
d. Un array de objetos String
3. ¿Qué método corresponde a la siguiente llamada?
myPerson.printValues (100, 147.7F, "lavender");
a. public void printValues (int pantSize, float
ageInYears)
b. public void printValues (pantSize, float
ageInYears, favoriteColor)
c. public void printValues (int pantSize, float
ageInYears, String favoriteColor)
d. public void printValues (float ageInYears, String
favoriteColor, int pantSize)
Desarrollo y uso de métodos 8-3

Ejercicio 1: uso de argumentos y valores de retorno

El objetivo de este ejercicio es escribir una clase con un método que
llame a un método worker de otra clase.
Deberá crear una pequeña aplicación que instancie tres objetos shirt
(camisa) y aplique un precio distinto a cada uno.
A continuación, la aplicación instanciará un objeto receipt (recibo)

que indique el precio total de la compra a medida que se vayan
agregando camisas al pedido.
Preparación
SL110/exercises/08_methods/exercise1 contenga los archivos
Order.java y Shirt.java. Éste será su directorio de trabajo.
Tarea: escritura de un método que utiliza argumentos

y valores de retorno
En esta tarea, deberá escribir una clase de prueba (test) que agregue varios
objetos Shirt a un objeto Order y muestre en la pantalla el importe
total del pedido en dólares. Siga estos pasos para escribir la clase:
2. Abra el archivo Shirt.java y examine sus variables miembro y el
método que contiene.
3. Abra el archivo Order.java y examine sus variables miembro y el
método que contiene.
4. Escriba una clase nueva llamada OrderTest que contenga un
método main.
5. En el método main:
a. Cree e inicialice un objeto Order y un objeto Shirt. La clase
Order (Order.java) y la clase Shirt (Shirt.java) se han
suministrado en el directorio exercise1.
b. Declare una variable de tipo double, denomínela totalCost
(coste total) e inicialícela con el valor 0.0.
c. Asigne a Shirt 14.00 como valor de precio (price).

d. Llame al método addShirt de la clase Order utilizando la

instancia Order para agregar la instancia shirt al pedido.
Guarde el valor de retorno del método addShirt en la variable
totalCost. El método addShirt hace lo siguiente:
public double addShirt (Shirt s)
Agrega una camisa (shirt) a una lista de camisas de un pedido.
Parámetros:
s: es la referencia a un objeto Shirt.
Devuelve:
El importe total del pedido.
e. Muestre en la pantalla el valor total del pedido. Por ejemplo:
El importe total del pedido es: 14.00
6. Compile y ejecute el programa. Compruebe si aparece en la pantalla
el valor total del pedido.
7. En el método main de la clase OrderTest, cree más objetos Shirt,
asigne valores a sus variables price y agregue los nuevos objetos
Shirt al pedido llamando al método addShirt.
8. Guarde y compile el archivo OrderTest.java.
9. Ejecute la clase OrderTest y verifique si se muestra correctamente el
valor total del pedido.

Ejercicio 2: uso de métodos sobrecargados

El objetivo de este ejercicio es aplicar la sobrecarga de métodos.
En él, creará métodos sobrecargados en una clase, efectuará llamadas a

esos métodos y los verificará.
Preparación
SL110/exercises/08_methods/exercise2 contenga el archivo
CustomerTest.java. Éste será su directorio de trabajo.
Tarea: desarrollo de una clase con un método

sobrecargado
En esta tarea, deberá escribir una clase Customer (cliente) con un método
sobrecargado llamado setCustomerInfo.

2. Cree una clase llamada Customer y guarde el archivo como
Customer.java en el directorio de trabajo.
3. En la clase Customer, agregue dos métodos sobrecargados llamados
setCustomerInfo.
En función de cómo se haga la llamada al método
setCustomerInfo, éste realizará una de las siguientes operaciones:
● Establecer el ID, el nombre, la dirección y el número de teléfono
de un objeto Customer (éstos son los datos imprescindibles
para un cliente nuevo).
● Establecer 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.
4. Cree un método display para mostrar los valores de todas las
variables miembro de la clase Customer.
5. Guarde y cierre el archivo Customer.java.
6. Abra el archivo llamado CustomerTest.java para comprobar los
métodos sobrecargados de la clase Customer.

7. En el método main de la clase CustomerTest, escriba el código

necesario para realizar las tareas siguientes:
a. Cree dos referencias a diferentes objetos Customer.
b. Utilice cada variación del método setCustomerInfo para
proporcionar la información de cada objeto Customer.
c. Muestre en la pantalla el contenido de cada objeto Customer.
8. Guarde y compile el archivo CustomerTest.java.
9. Ejecute la clase CustomerTest y compruebe el resultado.


!
?
● Experiencias
● Conclusiones
● Aplicaciones

Práctica 9
Implementación de la encapsulación y los

constructores
Objetivos
● Usar el concepto de encapsulación en una clase de Java.
● Implementar constructores en una clase.
9-1
ejercicios.
● En el primero, deberá implementar la encapsulación en una clase de
Java.
● En el segundo, accederá a los atributos encapsulados de una clase.
● En el tercero, deberá implementar constructores en una clase de Java.

Preguntas de repaso
Preguntas de repaso
1. Cuál de las frases siguientes define el concepto de interfaz:
a. Forma en que una clase lleva a cabo sus tareas dentro de un
método.
b. Operaciones y atributos de un objeto.
c. Forma en que otros objetos interaccionan con un objeto.
d. Declaración de atributos privados.
a. Es posible acceder a los miembros private de un objeto a través
de métodos public.
b. No es posible sobrecargar los constructores.
3. El ámbito de una variable se refiere a:
a. El ciclo de vida de la variable.
b. Lugar del programa donde puede utilizarse la variable, también
conocido como extensión de la variable.
c. Forma en que otros objetos interaccionan con un objeto.
d. Modo de acceso de la variable: private o public.
4. ¿Cuál es el constructor predeterminado de la clase siguiente?
public class Penny {
String name = "lane";
}
a. Penny()
b. public Penny()
c. class()
d. String()
Implementación de la encapsulación y los constructores 9-3

Ejercicio 1: escritura de clases encapsuladas

El objetivo de este ejercicio es escribir una clase que utilice la
encapsulación para ocultar datos a otros objetos.
En este ejercicio, deberá crear una clase llamada DateOne y modificar sus
atributos para implementar la encapsulación y examinar la salida.
Consta de dos tareas:

● “Tarea 1: implementación de la encapsulación en una clase”
● “Tarea 2: acceso a los atributos encapsulados de una clase”
Preparación
SL110/exercises/09_encapconstr/exercise1 contenga los archivos
DateOneTest.java, DateTwoTest.java y DateThreeTest.java. Éste
será su directorio de trabajo.
Tarea 1: implementación de la encapsulación en una

clase
En esta tarea creará una clase que contenga atributos private y tratará de
acceder a ellos en otra clase.

2. Cree una clase llamada DateOne que contenga tres variables
miembro de tipo int llamadas: day, month y year. Asigne el modo
de acceso public a todas las variables. Guarde la clase con el
nombre DateOne.java.
3. Abra el archivo DateOneTest.java suministrado en el directorio de
trabajo y escriba lo siguiente en su método main:
a. Cree e inicialice un objeto de tipo DateOne.
b. Asigne diferentes valores numéricos a las variables miembro de
la instancia de DateOne.
c. Muestre en pantalla el valor de las citadas variables de la
instancia de DateOne.

4. Guarde y compile el archivo DateOneTest.java.

5. Ejecute el archivo de la clase DateOneTest y examine el resultado.
6. Cree una clase nueva llamada DateTwo que incluya tres variables
miembro, como DateOne, y guárdela con el nombre DateTwo.java.
7. Cambie el modificador de acceso de las tres variables de DateTwo a
private.
8. Abra el archivo DateTwoTest.java suministrado en el directorio de
trabajo y lleve a cabo los mismos pasos que en el paso 3, pero, en este
caso, cree una instancia de DateTwo en lugar de crearla de la clase
DateOne. El resto de las líneas de código seguirán siendo iguales.
9. Guarde y compile DateTwoTest.java.
10. Examine los errores de compilación y averigüe la razón por la que se
han producido.
Tarea 2: acceso a los atributos encapsulados de una

clase
En esta tarea, creará una clase con atributos private que puedan manejarse
desde otra clase.

1. Cree una clase llamada DateThree y guárdela en un archivo con el
nombre DateThree.java.
2. La clase DateThree tiene las mismas variables miembro privadas
que la clase DateTwo.
3. Agregue los métodos siguientes a la clase DateThree:
a. Métodos get y set para las tres variables miembro.
Por ejemplo:
public void setDay(int d) {
day = d;
}
public int getDay() {
return day;
}

b. Método setDate: acepta tres argumentos de tipo int y asigna

su valor respectivamente a las variables day, month y year
de la clase DateThree. Antes de asignar los parámetros a las
variables, valídelos para asegurarse de que el día (day) no
supere los valores 30, 31, 28 o 29 (en función del mes), el
mes (month) sea un valor entre 1 y 12, y el año (year) se sitúe
entre los valores 1000 y 10000. Por ejemplo, el 31 de febrero
no tendría que ser un valor aceptable. Deberían aparecer
mensajes de error en caso de que falle la validación.
Nota: Utilice las sentencias switch case e if else para efectuar estas
comprobaciones.
● Método displayDate: muestra en pantalla la fecha con el

formato siguiente: Today’s Date is: 10/25/2006
4. Guarde y compile DateThree.java.
5. Abra el archivo DateThreeTest.java suministrado en el directorio
de trabajo y haga lo siguiente en el método main:
a. Cree e inicialice una instancia de la clase DateThree.
b. Introduzca una llamada a los métodos setDay, setMonth y
setYear, y páseles valores válidos en forma de argumentos.
c. Muestre en pantalla los valores de las variables de DateThree
utilizando sus métodos getDay, getMonth y getYear.
Por ejemplo:
System.out.println(“ The date is “ +
dateObj.getMonth()+ “ / “ dateObj.getDay() +” /” +
dateObj.getYear());
// dateObj es una instancia de la clase DateThree
6. Guarde y compile el archivo DateThreeTest.java.
7. Ejecute la clase DateThreeTest y examine el resultado.
8. Vuelva a abrir el archivo DateThreeTest.java.
9. Al final del método main, agregue un fragmento de código que haga
lo siguiente:
a. Llamar al método setDate utilizando la instancia de la clase
DateThree y pasarle valores válidos en forma de argumentos.
b. Llamar al método displayDate utilizando la instancia de la
clase DateThree.

10. Guarde, compile y ejecute el archivo DateThreeTest.java.

11. Examine la salida y compruebe si aparece algún mensaje de error.
12. En el archivo DateThreeTest.java, modifique el valor de los
argumentos pasados al método setDate y repita los pasos 10 y 11.
Discusión: Puede comentar las condiciones de error que podrían

generarse al definir los valores de mes, día y año en el método setDate.
! Pida a los alumnos que prueben la clase DateThree en todos esos casos y
?
verifiquen los mensajes de error.

Ejercicio 2: uso de constructores

El objetivo de este ejercicio es implementar constructores en una clase.
Deberá crear constructores sobrecargados en una clase y utilizarlos para

inicializar objetos de esa clase.
El ejercicio consta de dos tareas:

● “Tarea 1: creación y uso de constructores”
● “Tarea 2: creación de constructores para inicializar objetos”
Preparación
SL110/exercises/09_encapconstr/exercise2 contenga los archivos
DateFourTest.java y RectangleTest.java. Éste será su directorio de
trabajo.
Tarea 1: creación y uso de constructores

En esta tarea, deberá escribir una clase DateFour con constructores y
crear objetos a partir de esa clase para utilizar los constructores de la
forma apropiada.

2. Cree una clase llamada DateFour de forma similar a la clase
DateThree del Ejercicio 1 y guarde el archivo como DateFour.java
en el directorio de trabajo.
3. Agregue al archivo DateFour.java un constructor sin argumentos
que asigne el valor 1 a las variables month y day, y el valor 2007 a
la variable year.
4. Cambie el nombre del método setDate para convertirlo en un
constructor que acepte, verifique y defina los valores de month, day
y year.
5. Guarde y compile el archivo DateFour.java.

6. Abra el archivo DateFourTest.java. En el método main, cree

objetos de DateFour llamados d1 y d2, donde d1 se crea
utilizando el constructor sin argumentos y d2 se crea usando el
constructor de tres argumentos.
7. En la clase DateFourTest, llame al método display para mostrar en
la pantalla los valores de day, month y year correspondientes a los
objetos d1 y d2.
8. Compile el archivo DateFourTest.java, ejecútelo y verifique la
salida.
El resultado de la clase DateFourTest debería ser similar al
siguiente:
Today’s Date is: 1/1/2007
Today’s Date is: 3/9/1967
Tarea 2: creación de constructores para inicializar

objetos
En esta tarea, creará una clase y utilizará constructores para inicializar
objetos. Siga estos pasos para crear la clase:
1. Cree una clase Rectangle (rectángulo) y guarde el archivo con el
nombre Rectangle.java.
2. Cree dos variables privadas de tipo int con los nombres width
(anchura) y height (altura).
3. Agregue los constructores siguientes a Rectangle.java:
● Un constructor sin argumentos que imprima en la pantalla el
mensaje “Default rectangle created: width=25, height=10” y
defina width como 25 y height como 10.
● Un constructor que adopte dos argumentos enteros, w y h, y
asigne a width el valor w y a height el valor h únicamente si
estos dos argumentos (w y h) son mayores que 0 y menores que
30. En caso de que el valor de w o h esté fuera de los límites,
aparecerá un mensaje de error. Asimismo aparecerá en la
pantalla un mensaje para indicar que se ha creado un
rectángulo de las dimensiones siguientes: width=w y height=h.
4. Cree un método llamado getArea que calcule y devuelva el área del
rectángulo. El área se calcula como height* width.

5. Cree un método llamado draw y haga lo siguiente en él:

a. Cree un bucle for anidado para dibujar un rectángulo
utilizando asteriscos (*).
b. El número de asteriscos utilizados para dibujarlo debería
coincidir con los valores de altura y anchura especificados para
el rectángulo.
6. Guarde y compile el archivo Rectangle.java.
7. Modifique el archivo RectangleTest.java suministrado para crear
instancias de Rectangle llamadas r1 y r2, de forma que:
● r1 se cree mediante el constructor sin argumentos.
● r1 se dibuje inmediatamente después de su creación.
● r2 se cree utilizando el constructor con argumentos.
● Se dibuje r2 y su área aparezca en la pantalla.
8. Guarde y compile el archivo RectangleTest.java y compruebe el
código del rectángulo.
El resultado de la clase RectangleTest debería ser similar al
siguiente:
Default rectangle created: width=25, height=10
This is the first rectangle:
*************************
*************************
*************************
*************************
*************************
*************************
*************************
*************************
*************************
*************************
Rectangle created: width=20, height=7
This is the second rectangle:
********************
********************
********************
********************
********************
********************
********************
The area is 140.


experiencias extraídas del ejercicio.
!
?
● Experiencias
● Conclusiones
● Aplicaciones

Práctica 10
Creación y uso de matrices (arrays)
Objetivos
● Crear y utilizar un array unidimensional.
● Usar arrays en un bucle.
● Interpretar argumentos de tiempo de ejecución.
● Crear y usar arrays bidimensionales.
10-1
En esta práctica, responderá a las preguntas de repaso y realizará cuatro
ejercicios.
● En el primer ejercicio, creará y utilizará arrays unidimensionales de
tipos primitivos y de objetos.
● En el segundo, utilizará bucles de varias maneras para inicializar un
array.
● En el tercero, utilizará el array args[] del método main.
● En el cuarto, creará y utilizará arrays bidimensionales.

Preguntas de repaso
Preguntas de repaso
1. El código siguiente representa la sintaxis correcta para _____
un array
identificador_array = new tipo [longitud];
a. Declarar
b. Definir los valores del array
c. Instanciar
d. Declarar, instanciar y definir un array de valores
a. La sintaxis para declarar, instanciar y definir un array de
valores es:
tipo [] identificador_array =
{lista_de_valores_o_expresiones_separados_por_comas};
b. La sintaxis para definir los valores de un array es:
identificador_array[índice] = valor;
3. Dada la siguiente declaración de un array, determine si las afirmaciones
siguientes son verdaderas o falsas.
int [ ] autoMobile = new int [13];
a. autoMobile[0] es la referencia al primer elemento del array.
b. autoMobile[13] es la referencia al último elemento del array.
c. Hay 13 enteros en el array autoMobile.
4. Un array bidimensional es parecido a _______:
a. Una lista de la compra
b. Una lista de tareas
c. Una matriz
d. Un gráfico de barras que contiene las dimensiones de varias
cajas
Creación y uso de matrices (arrays) 10-3

Ejercicio 1: creación y uso de arrays unidimensionales

El objetivo de este ejercicio es escribir clases que utilicen arrays
unidimensionales de tipos de datos primitivos y de objetos.
Consta de dos tareas:

● “Tarea 1: creación de una clase con un array unidimensional de tipos
primitivos”
● “Tarea 2: creación de una clase con un array unidimensional de
objetos”
Preparación
Asegúrese de que el directorio SL110/exercises/10_arrays/exercise1
contenga los archivos VacationScaleTest.java y Shirt.java. Éste será
su directorio de trabajo.

unidimensional de tipos primitivos
El número de días de vacaciones que recibe un empleado de la empresa
DirectClothing, Inc. se basa en el número de años que ese empleado ha
trabajado para la compañía. A continuación se indica la escala de
asignación de vacaciones que utiliza DirectClothing, Inc.
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 o más años 25
En esta tarea, deberá escribir una clase llamada VacationScale que

contenga un array de siete elementos. Considere que el número de
años trabajados es relativo a la posición del elemento en el array.
Cada elemento contiene el número de días de vacaciones
correspondiente la cantidad de años trabajados.


1. Abra la ventana de terminal y vaya al directorio
SL110/exercises/10_arrays/exercise1.
2. Escriba una clase llamada VacationScale que contenga una
variable miembro de tipo int[] denominada vacationDays
(días de vacaciones). Cada elemento contendrá el número de días
de vacaciones correspondiente al índice especificado en el array.
Por ejemplo, el índice 0 representa 0 años de servicio, por lo que
vacationDays[0] contendrá el número 10. Asimismo, el índice 4
representa 4 años de servicio, así que vacationDays[4] contendrá
el número 20.
3. Cree un método public llamado setVacationScale que no tenga
argumentos ni tipo de retorno: inicialice el array vacationDays con
un tamaño de siete y defina valores en todos sus elementos.
4. Cree un método public llamado displayVacationDays que no
devuelva ningún valor, acepte un argumento int (yearsOfService)
y presente el número de días de vacaciones que recibe el empleado.
Por ejemplo, si se pasa el valor 1 a displayVacationDays,
aparecerá en pantalla el número 15.
Pista: puede usar una variable entre corchetes al recuperar los
valores de un array. Por ejemplo:
vacationDays[yearsOfService]
5. Compile y ejecute su clase utilizando la clase VacationScaleTest
suministrada. La salida de su programa debería ser similar a ésta:
Your vacation is: 15

unidimensional de objetos
En esta tarea, escribirá un programa que cree y asigne valores a un array
de objetos Shirt. Lleve a cabo los pasos siguientes:
1. Sitúese en el directorio SL110/exercises/10_arrays/exercise1.
2. Escriba una clase llamada ShirtArrayTest que:
● Cree tres objetos Shirt y defina sus valores mediante un
constructor. El constructor de la clase Shirt es:
public Shirt(int shirtID, String description, char
colorcode, double price, int quantityInStock)

● Coloque cada referencia al objeto Shirt en un array.

● Utilice el array para mostrar en la pantalla los valores del objeto
Shirt utilizando el método displayInformation de dicho
objeto.
3. Compile y ejecute su clase ShirtArrayTest. Examine el resultado.

Ejercicio 2: uso de bucles y arrays
Ejercicio 2: uso de bucles y arrays

El objetivo de este ejercicio es usar un bucle para inicializar un array.
Preparación
contenga el archivo VacationScaleTwoTest.java. Éste será su directorio
de trabajo.
Tarea: uso de un bucle para inicializar un array

En esta tarea, reescribirá el método setVacationScale de la clase
VacationScale para usar un bucle. La clase VacationScale se creó en
el ejercicio anterior. Siga estos pasos para modificar el método:
2. Copie el archivo VacationScale.java del directorio
SL110/exercises/mod10_arrays/exercise1 en el directorio
actual y cambie el nombre de la copia por VacationScaleTwo.java.
3. Edite el archivo VacationScaleTwo.java y cambie el nombre de la
clase por VacationScaleTwo.
4. Reescriba el método displayVacationDays y utilice un bucle
para iterar sobre el array vacationDays y mostrar los valores
almacenados en cada elemento de este array. El método no
debería aceptar ningún argumento.
5. Compile y ejecute su clase utilizando la clase
VacationScaleTwoTest suministrada.
Nota: Para llevar a cabo esta tarea, modifique el paso 4 a fin de utilizar el
bucle for mejorado y verifique la salida.

Ejercicio 3: análisis del array args[]
Ejercicio 3: análisis del array args[]

El objetivo de este ejercicio es usar el array args[] dentro del método
main para crear un juego de adivinación de números.
En este ejercicio, creará una clase que acepte como argumento un número
entre 1 y 5 introducido durante el tiempo de ejecución. También
deberá generar un número aleatorio de 1 a 5 en la clase y comparar el
valor del argumento con el del número generado aleatoriamente.
Tarea: creación de un juego utilizando el array args [ ]

En esta tarea, escribirá un juego que acepte un argumento y presente
un mensaje asociado. Siga estos pasos para escribir el juego:
1. Sitúese en el directorio
SL110/exercises/mod10_arrays/exercise3.
2. Escriba una clase GuessingGame (juego de adivinación) con un
método main que acepte un argumento: cualquier número
situado entre 1 y 5 o la palabra “help”.
3. Si la clase GuessingGame recibe la palabra “help” como argumento,
mostrará en la pantalla la información de uso del programa.
4. Si se introducen los números 1, 2, 3, 4 o 5:
a. Genere un número aleatorio del 1 al 5 utilizando el siguiente
fragmento de código:
randomNum =((int)(Math.random()*5)+1);
b. Compare el argumento con este número aleatorio. Si el valor
del argumento y el número aleatorio son iguales, muestre
un mensaje al usuario para indicarle que ha adivinado el
número correcto. Si el valor del argumento y el número
aleatorio no coinciden, muestre el número aleatorio y pida
al usuario que vuelva a intentarlo.
5. Si se introduce un número incorrecto (menor que 1 o mayor que 5),
muestre al usuario un mensaje para indicarle que el valor
introducido no es válido.
6. Guarde el archivo con el nombre GuessingGame.java.
7. Compile la clase. Ejecútela varias veces y examine la salida
suministrando un argumento distinto cada vez.

Ejercicio 4: creación y uso de arrays bidimensionales

El objetivo de este ejercicio es crear un array bidimensional y acceder a él.
Este ejercicio utiliza como ejemplo un aula. El aula tiene 12 pupitres

dispuestos en una cuadrícula rectangular formada por 3 filas y
4 columnas. A los alumnos se les va asignando el primer pupitre que
se encuentre vacío en la fila.
En la Figura 10-1 se muestra el plano del aula en forma de cuadrícula.

Cada celda representa un pupitre y contiene las coordenadas de la
posición del pupitre en el plano de la sala.
XXXXX Col 1 Col 2 Col 3 Col 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
Figura 10-1 Cuadrícula rectangular que representa el plano del aula
En este ejercicio, creará una clase de Java que represente el plano de

un aula, asigne a cada alumno la posición de un pupitre, muestre el
plano de pupitres del aula y busque la ubicación de un pupitre
asignado a un alumno.
Preparación
contenga el archivo ClassMapTest.java. Éste será su directorio de
trabajo.
El ejercicio consta de tres tareas:

● “Tarea 1: creación de una clase con un array bidimensional”
● “Tarea 2: uso de un array bidimensional”
● “Tarea 3: comprobación de una clase que contiene un array
bidimensional”


bidimensional
En esta tarea, creará una clase que contenga un array bidimensional como
variable miembro. Es un array de tipo String y tiene un tamaño de [3][4].
Cada elemento del array representa un pupitre (desk) cuya posición

coincide con su índice en el array. Por ejemplo, desk[2][1] representa el
pupitre situado en la fila 3 y la columna 2. Consulte la Figura 10-1 para
mayor claridad. Cada elemento del array almacena el nombre del alumno
que tiene asignado ese pupitre en el aula.

1. Convierta SL110/exercises/10_arrays/exercise4 en su
directorio de trabajo.
2. Cree una clase llamada ClassMap y guárdela como ClassMap.java.
3. En la clase, declare dos variables miembro, roomNo de tipo int y
deskArray de tipo String[][].
4. Cree un constructor con argumento que acepte un valor id de tipo
int. En el constructor:
a. Asigne el valor del argumento a la variable RoomNo.
b. Inicialice el tamaño de deskArray con los valores [3][4].
5. Guarde la clase ClassMap.
Tarea 2: uso de un array bidimensional

En esta tarea, deberá escribir ciertos métodos en la clase ClassMap que
atraviesen el array deskArray para:
● Asignar pupitres a los alumnos.
● Mostrar la disposición del aula.
● Buscar la ubicación del pupitre de un alumno en el aula.


1. Cree un método denominado setDesk que acepte un argumento
String y no devuelva ningún valor. El argumento contendrá el
nombre del alumno.
2. En el método setDesk, escriba código para realizar las siguientes
tareas:
a. Recorrer el array deskArray para identificar el primer pupitre
vacante que contenga. Para hacerlo, puede utilizar un bucle
for anidado. Por ejemplo:
for (int row=0;row<3;row++){
for (int col=0;col<4;col++){
if (deskArray[row][col]==null){
b. Asignar el nombre del alumno al elemento vacante.
c. Mostrar en la pantalla la posición del pupitre de ese alumno y
salir de los bucles.
Nota: Puede utilizar la sentencia break para salir de los bucles.
3. Cree un método public llamado displayDeskMap sin argumentos

ni tipo de retorno. En el método, escriba el código necesario para
recorrer deskArray e imprimir en la pantalla los nombres de cada
elemento del array de manera que aparezcan en forma de cuadrícula.
4. Cree un método denominado searchDesk que acepte un argumento
String y no devuelva ningún valor. El argumento representa el
nombre del alumno cuyo pupitre debe buscarse en el array
deskArray.
5. En el método searchDesk, escriba código para hacer lo siguiente:
a. Crear un bucle for anidado que recorra el array deskArray.
b. Si el elemento del array no es null, comparar el valor del
argumento del método con el del elemento. Por ejemplo:
if (deskArray[row][col] !=null &&
deskArray[row][col].equals(name)==true){
c. Mostrar en la pantalla la posición del pupitre si los nombres
coinciden.
d. Mostrar un mensaje de error si no se encuentra el nombre en el
array deskArray.
e. Utilizar la sentencia break para salir de los bucles cuando sea
necesario.
6. Guarde y cierre el archivo ClassMap.java.

Tarea 3: comprobación de una clase que contiene un

array bidimensional
1. Abra el archivo ClassMapTest.java suministrado en el directorio
de trabajo.
2. Examine el método main y compruebe si se ha efectuado la llamada
a todos los métodos de la clase ClassMap.
3. Compile el archivo ClassMapTest.java, ejecútelo y verifique el
resultado.


!
?
● Experiencias
● Conclusiones
● Aplicaciones

Práctica 11
Implementación de la herencia
Objetivos
● Diseñar superclases y subclases.
● Implementar superclases y subclases.
11-1
ejercicios.
● En el primero, deberá diseñar una jerarquía de clases a partir de un
ejemplo propuesto.
● En el segundo, creará la jerarquía de clases y la utilizará.

Preguntas de repaso
Preguntas de repaso
a. En programación Java, una superclase puede heredar elementos
de sus subclases.
b. Un objeto es un concepto abstracto.
2. ¿Cuál de las siguientes palabras clave de Java indica herencia?
a. La palabra implements
b. La palabra inherits
c. La palabra extends
d. La palabra imports
3. ¿Qué función cumple la palabra clave import?
a. Informa a la máquina virtual de las clases que utiliza el
programa.
b. Informa a la máquina virtual de que se está utilizando un
archivo gráfico en el programa.
c. Facilita la lectura del programa al permitir el uso de nombres
abreviados para hacer referencia a las clases del API de Java.
d. Indica al compilador que se está compilando un programa que
utiliza clases del API de Java.
4. ¿De qué paquete del API de Java se importan de forma implícita las
clases String, Math e Integer?
a. El paquete java.awt
b. El paquete java.applet
c. El paquete java.lang
d. El paquete java.io
Implementación de la herencia 11-3

Ejercicio 1: diseño de superclases y subclases

El objetivo de este ejercicio es comprender las características de un
problema planteado y diseñar una jerarquía de clases.
Tarea 1: identificación de superclases y subclases

En esta tarea, deberá diseñar una superclase y subclases utilizando la
información del ejemplo siguiente.
Publishing, Inc. tiene empleados que ocupan diferentes cargos. Los cargos
son los siguientes: redactores técnicos, ilustradores gráficos, gerentes y
editores.
Publishing, Inc. le pide que cree un programa para llevar el control de la

información relativa a cada uno de sus trabajadores. Esta información se
compone de los datos siguientes: el nombre del trabajador, su cargo, el ID
de empleado (en un intervalo de 1 a 10.0000) y el nivel (1, 2 o 3). Además:
● Los gerentes deben tener una lista de los empleados a su cargo.
● Los redactores técnicos, ilustradores y editores deben tener una lista
de las competencias que poseen.
● Los editores deben tener un valor que indique si prefieren realizar la
edición en formato electrónico o en papel.
● Todas las subclases deben incluir un método para mostrar la
información según el tipo de empleado.
Para diseñar las subclases y superclases:

1. Cree una jerarquía de clases que muestre las relaciones entre las
superclases y subclases relativas a los empleados de Publishing, Inc.
Utilice la frase “es un(a)” para verificar la jerarquía creada.
2. Modele la jerarquía usando diagramas de clases similares a los
empleados en este módulo.
Demuestre la encapsulación de cada una de las clases de su diseño

incluyendo en él los métodos get y set.

Notas

Ejercicio 2: creación y uso de superclases y subclases
Ejercicio 2: creación y uso de superclases y subclases

El objetivo de este ejercicio es crear e implementar la jerarquía de clases
diseñada en el ejercicio anterior.
Preparación
SL110/exercises/11_hierarchy/exercise2 contenga el archivo
EmployeeTest.java. Éste será su directorio de trabajo.
Tarea: creación de clases

En esta tarea, deberá desarrollar subclases y superclases para la jerarquía
de clases de empleados. Siga estos pasos para crear las clases:
1. Vaya al directorio inheritance.
2. Cree archivos de clases para cada una de las clases esbozadas en la
primera parte del ejercicio.
3. Cree métodos en cada una de las subclases para mostrar en la
pantalla la información sobre el trabajador.
4. Cree métodos get y set, según lo especificado en el diseño, y utilice
construcciones de toma de decisión para asegurarse de que no se
hayan definido datos incorrectos.
5. (Opcional) Trate de utilizar métodos de las clases String y
Character para asegurarse de que ni los nombres ni los cargos
definidos contengan caracteres numéricos.
6. Declare la variable employeeID como static a fin de que cada ID
generado sea exclusivo de un empleado.
7. Guarde y compile todos los archivos de clases con los nombres
Employee (empleado), Manager (gerente), Editor,
TechnicalWriter (redactor técnico) y TechnicalIllustrator
(ilustrador).
8. Compile el archivo EmployeeTest.java, ejecútelo y verifique la
salida.


!
?
● Experiencias
● Conclusiones
● Aplicaciones


ORACLE Base de Datos

Caricato da

Informazioni sul documento

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

ORACLE Base de Datos

Caricato da

Copyright:

Formati disponibili

Fundamentals of the Java

SL-110-SE6-ES Rev E.1

Sun Microsystems, Inc. Disclaimer

Restricted Rights Notice

U.S. GOVERNMENT RIGHTS

vi Programación Java para no Programadores

viii Programación Java para no Programadores

Descripción de la tecnología Java™

1-2 Programación Java para no Programadores

Responda a las preguntas siguientes:

Descripción de la tecnología Java™ 1-3

1-4 Programación Java para no Programadores

Resumen del ejercicio

Discusión: Dedique unos minutos a comentar las conclusiones o

Descripción de la tecnología Java™ 1-5

Análisis de un problema y diseño de la

Los ejercicios consistirán en:

2-2 Programación Java para no Programadores

Análisis de un problema y diseño de la solución 2-3

Ejercicio 1: análisis del dominio de un problema

La aplicación debería ser capaz de generar estadísticas relativas a los

Para finalizar el análisis, lleve a cabo estos pasos:

2-4 Programación Java para no Programadores

Análisis de un problema y diseño de la solución 2-5

Ejercicio 2: diseño de la solución

2-6 Programación Java para no Programadores

Análisis de un problema y diseño de la solución 2-7

Resumen del ejercicio

Discusión: Dedique unos minutos a comentar las conclusiones o

2-8 Programación Java para no Programadores

Desarrollo y comprobación de un programa

3-2 Programación Java para no Programadores

Desarrollo y comprobación de un programa Java 3-3

Ejercicio 1: modificación, compilación y ejecución de un

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

Lleve a cabo los pasos siguientes:

3-4 Programación Java para no Programadores

9. Si es necesario, modifique el archivo Quotation.java para corregir

Desarrollo y comprobación de un programa Java 3-5

Ejercicio 2: creación, compilación y ejecución de una clase

Tarea: creación y comprobación de una clase de Java

Lleve a cabo los pasos siguientes:

3-6 Programación Java para no Programadores

14. Guarde y cierre el archivo Shirt.java.

Desarrollo y comprobación de un programa Java 3-7

Resumen del ejercicio

Discusión: Dedique unos minutos a comentar las conclusiones o

3-8 Programación Java para no Programadores

Declaración, inicialización y uso de variables

4-2 Programación Java para no Programadores

Declaración, inicialización y uso de variables 4-3

4. Examine el código siguiente y seleccione la salida correcta después

4-4 Programación Java para no Programadores

Ejercicio 1: uso de variables de tipos primitivos en un

Tarea: creación de una clase con variables

Lleve a cabo los pasos siguientes para crear la clase Customer:

Declaración, inicialización y uso de variables 4-5

6. Compruebe la salida del programa para asegurarse de que contenga

4-6 Programación Java para no Programadores

Ejercicio 2: uso de operadores y conversión de tipos

Este ejercicio consta de las siguientes tareas:

Tarea 1: cálculo de la edad utilizando operadores

Declaración, inicialización y uso de variables 4-7

c. Cree un método calculateAge en la clase Person.