Fundacion Proydesad61748cs10 Ag

FUNDACION PROYDESA (FUNDACION@PROYDESAฺORG) has a non-transferable license to use this Student Guideฺ
Java Programming Language,

Java SE 6
Activity Guide
SL-275-SE6-ES Rev G.2
D61748CS10
Edition 1.0
D64148
Unauthorized reproduction or distribution prohibited. Copyright© 2010, Oracle and/or its affiliates.
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
Acerca de este libro ......................................................... Prólogo-xvii
Objetivos de las prácticas................................................. Prólogo-xvii
Realización de los ejercicios.............................................Prólogo-xviii
Convenciones....................................................................... Prólogo-xix
Convenciones tipográficas........................................ Prólogo-xix
Otras convenciones..................................................... Prólogo-xx
Introducción......................................................................................1-1
Objetivos............................................................................................. 1-1
Ejercicio 1: Exploración de errores de programa Java™ .............. 1-2
Preparación ................................................................................ 1-2
Tarea: Corrección de errores de compilación y tiempo
ejecución .................................................................................. 1-3
Ejercicio 2: Creación de un programa de prueba (nivel 1)........... 1-4
Preparación ................................................................................ 1-4
Tarea 1: Copia de la clase Account ........................................ 1-5
Tarea 2: Creación de la clase TestAccount .......................... 1-6
Tarea 3: Compilación de la clase TestAccount ................... 1-6
Tarea 4: Ejecución del programa TestAccount ................... 1-6
Ejercicio 2: Creación de un programa de prueba (nivel 2)........... 1-7
Preparación ................................................................................ 1-7
Tarea 1: Copia de la clase Account ........................................ 1-8
Tarea 2: Creación de la clase TestAccount .......................... 1-8
Tarea 3: Compilación de la clase TestAccount ................... 1-9
Tarea 4: Ejecución del programa TestAccount ................... 1-9
Ejercicio 2: Creación de un programa de prueba (nivel 3)......... 1-10
Preparación .............................................................................. 1-10
Tarea 1: Copia de la clase Account ...................................... 1-11
Tarea 2: Creación de la clase TestAccount ........................ 1-11
Tarea 3: Compilación de la clase TestAccount ................. 1-12
Tarea 4: Ejecución del programa TestAccount ................. 1-12
Resumen del ejercicio ...................................................................... 1-13
Unauthorized reproduction or distribution prohibited. Copyright© 2010, Oracle and/or its affiliates. v
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisión G.2
Programación orientada a objetos................................................. 2-1
Objetivos............................................................................................. 2-1
Ejercicio 1: Uso de la documentación de API de Java .................. 2-2
Preparación ................................................................................ 2-2
Tarea: Uso de la documentación de API de Java ................. 2-2
Ejercicio 2: Exploración de la encapsulación, versión 1
(nivel 1) ............................................................................................. 2-3
Preparación ................................................................................ 2-4
Tarea 1: Eliminación de la clase Account.............................. 2-4
Tarea 2: Creación de la clase Account ................................... 2-4
Tarea 3: Creación de la clase TestAccount2 ........................ 2-5
Tarea 4: Compilación de la clase TestAccount2 ................. 2-5
Tarea 5: Ejecución del programa TestAccount2 ................. 2-5
(nivel 2) ............................................................................................. 2-6
Preparación ................................................................................ 2-6
Tarea 1: Eliminación de la clase Account.............................. 2-7
Tarea 2: Creación de la clase Account ................................... 2-7
Tarea 3: Creación de la clase TestAccount2 ........................ 2-7
Tarea 4: Compilación de la clase TestAccount2 ................. 2-8
Tarea 5: Ejecución del programa TestAccount2 ................. 2-8
(nivel 3) ............................................................................................. 2-9
Preparación ................................................................................ 2-9
Tarea 1: Eliminación de la clase Account............................ 2-10
Tarea 2: Creación de la clase Account ................................. 2-10
Tarea 3: Creación de la clase TestAccount2 ...................... 2-10
Tarea 4: Compilación de la clase TestAccount2 ............... 2-11
Tarea 5: Ejecución del programa TestAccount2 ............... 2-11
(nivel 1) ........................................................................................... 2-12
Preparación .............................................................................. 2-13
Tarea 1: Modificación de la clase Account.......................... 2-13
Tarea 2: Modificación de la clase TestAccount................. 2-13
Tarea 3: Compilación de la clase TestAccount.................. 2-13
(nivel 2) ........................................................................................... 2-15
Preparación .............................................................................. 2-15
Tarea 3: Compilación de la clase TestAccount.................. 2-16
viUnauthorized reproduction orLenguaje

distribution de programación
prohibited. Java™
Copyright© 2010, Oracle and/or its affiliates.
(nivel 3) ........................................................................................... 2-17
Preparación .............................................................................. 2-17
Ejercicio 4: Creación de paquetes de Java..................................... 2-20
Preparación .............................................................................. 2-21
Tarea 1: Creación de los paquetes de Java .......................... 2-21
Tarea 2: Desplazamiento y modificación de la clase
Account................................................................................. 2-22
Tarea 3: Desplazamiento de la clase TestAccount............ 2-22
Identificadores, palabras clave y tipos...........................................3-1
Objetivos............................................................................................. 3-1
Ejercicio 1: Investigación de asignación de referencias ................ 3-2
Preparación ................................................................................ 3-2
Tarea 1: Creación de la clase TestMyPoint .......................... 3-3
Tarea 2: Compilación de la clase TestMyPoint ................... 3-4
Tarea 3: Ejecución del programa TestMyPoint ................... 3-4
Ejercicio 2: Creación de cuentas de cliente (nivel 1)...................... 3-5
Preparación ................................................................................ 3-6
Tarea 1: Creación de la clase Customer................................. 3-6
Tarea 2: Copia de la clase TestBanking................................ 3-7
Tarea 3: Compilación de la clase TestBanking ................... 3-7
Tarea 4: Ejecución del programa TestBanking ................... 3-7
Ejercicio 2: Creación de cuentas de cliente (nivel 2)...................... 3-8
Preparación ................................................................................ 3-8
Tarea 1: Creación de la clase Customer................................. 3-9
Tarea 4: Ejecución del programa TestBanking ................. 3-10
Ejercicio 2: Creación de cuentas de cliente (nivel 3).................... 3-11
Preparación .............................................................................. 3-11
Tarea 1: Creación de la clase Customer............................... 3-12
Tarea 2: Copia de la clase TestBanking.............................. 3-13
Tarea 3: Compilación de la clase TestBanking ................. 3-13
Unauthorized reproduction or distribution prohibited. Copyright© 2010, Oracle and/or its affiliates. vii
Expresiones y control del flujo....................................................... 4-1
Objetivos............................................................................................. 4-1
Ejercicio 1: Uso de bucles y sentencias de ramificación ............... 4-2
Preparación ................................................................................ 4-3
Tarea 1: Creación de la clase FooBarBaz............................... 4-3
Tarea 2: Compilación de la clase FooBarBaz........................ 4-4
Tarea 3: Ejecución del programa FooBarBaz........................ 4-4
Sugerencias ................................................................................ 4-4
Ejercicio 2: Uso de sentencias condicionales en la clase
Account (nivel 1)............................................................................. 4-5
Preparación ................................................................................ 4-6
Tarea 1: Modificación de la clase Account ............................ 4-6
Tarea 2: Eliminación de la clase TestBanking actual ........... 4-6
Tarea 4: Compilación de la clase TestBanking.................... 4-7
Account (nivel 2)............................................................................. 4-8
Preparación ................................................................................ 4-8
Tarea 1: Modificación de la clase Account............................ 4-9
Tarea 2: Eliminación de la clase TestBanking actual ........... 4-9
Account (nivel 3)........................................................................... 4-10
Preparación .............................................................................. 4-10
Tarea 2: Eliminación de la clase TestBanking actual ......... 4-11
Tarea 4: Compilación de la clase TestBanking.................. 4-11
Ejercicio 3: Uso de bucles anidados (avanzado).......................... 4-13
Preparación .............................................................................. 4-13
Tarea 1: Creación del método isSubString ...................... 4-14
Tarea 2: Compilación de la clase TestIsSubString......... 4-14
Tarea 3: Ejecución del programa TestIsSubString......... 4-14
Sugerencias ............................................................................. 4-15
Matrices ............................................................................................ 5-1
Objetivos............................................................................................. 5-1
Ejercicio 1: Uso de matrices primitivas (nivel 2) ........................... 5-2
Preparación ................................................................................ 5-2
Tarea 1: Creación de la clase TestArrays............................. 5-3
Tarea 2: Compilación de la clase TestArrays...................... 5-3
viii
Unauthorized reproduction orLenguaje
prohibited. Java™
Tarea 3: Ejecución del programa TestArrays...................... 5-3
Sugerencia .................................................................................. 5-4
Ejercicio 1: Uso de matrices primitivas (nivel 3) ........................... 5-5
Preparación ................................................................................ 5-5
Tarea 1: Creación de la clase TestArrays............................. 5-6
Tarea 2: Compilación de la clase TestArrays...................... 5-7
Tarea 3: Ejecución del programa TestArrays...................... 5-7
Ejercicio 2: Uso de matrices para representar asociaciones
de uno a varios (nivel 1)................................................................. 5-8
Preparación ................................................................................ 5-9
Tarea 1: Creación de la clase Bank.......................................... 5-9
de uno a varios (nivel 2)............................................................... 5-11
Tarea 1: Creación de la clase Bank........................................ 5-12
Tarea 2: Eliminación de la clase TestBanking actual ....... 5-12
de uno a varios (nivel 3)............................................................... 5-14
Tarea 1: Creación de la clase Bank........................................ 5-15
Diseño de clases ..............................................................................6-1
Objetivos............................................................................................. 6-1
Ejercicio 1: Creación de subclases de cuenta bancaria (nivel 1) .. 6-2
Preparación ................................................................................ 6-3
Tarea 2: Creación de la clase SavingsAccount.................... 6-4
Tarea 3: Creación de la clase CheckingAccount.................. 6-4
Ejercicio 1: Creación de subclases de cuenta bancaria (nivel 2) .. 6-7
Preparación ................................................................................ 6-7
Tarea 2: Creación de la clase SavingsAccount.................... 6-8
Tarea 3: Creación de la clase CheckingAccount.................. 6-9
Unauthorized reproduction or distribution prohibited. Copyright© 2010, Oracle and/or its affiliates. ix
Ejercicio 1: Creación de subclases de cuenta bancaria
(nivel 3) ........................................................................................... 6-12
Preparación .............................................................................. 6-12
Tarea 2: Creación de la clase SavingsAccount.................. 6-13
Tarea 3: Creación de la clase CheckingAccount................ 6-14
Ejercicio 2: Creación de una colección heterogénea de
cuentas de cliente (nivel 1)........................................................... 6-17
Preparación .............................................................................. 6-18
Tarea 1: Modificación de la clase Customer........................ 6-18
Tarea 2: Copia y rellenado de la clase CustomerReport .. 6-18
Tarea 3: Copia de la clase TestReport................................ 6-19
Tarea 4: Compilación de la clase TestReport.................... 6-19
Tarea 5: Ejecución del programa TestReport.................... 6-19
Ejercicio 3: Creación de un programa por lotes (avanzado)...... 6-26
Preparación .............................................................................. 6-27
Tarea 1: Modificación de la clase SavingsAccount .......... 6-27
Tarea 2: Creación de la clase AccumulateSavingsBatch 6-27
Tarea 4: Compilación de la clase TestBatch...................... 6-28
Tarea 5: Ejecución del programa TestBatch...................... 6-28
x Unauthorized reproduction orLenguaje

prohibited. Java™
Conceptos avanzados sobre las clases.........................................7-1
Objetivos............................................................................................. 7-1
Ejercicio 1: Aplicación de miembros estáticos a un diseño
(nivel 1) ............................................................................................. 7-2
Preparación ................................................................................ 7-3
Tarea 1: Modificación de la clase Bank .................................. 7-3
Tarea 2: Modificación de la clase CustomerReport ............ 7-3
Tarea 3: Eliminación de la clase TestReport actual............ 7-4
Tarea 4: Copia de la clase TestReport.................................. 7-4
Tarea 5: Compilación de la clase TestReport...................... 7-4
Tarea 6: Ejecución del programa TestReport...................... 7-4
(nivel 2) ............................................................................................. 7-5
Tarea 2: Modificación de la clase CustomerReport ............ 7-7
Tarea 3: Eliminación de la clase TestReport actual............ 7-7
Tarea 4: Copia de la clase TestReport.................................. 7-7
(nivel 3) ............................................................................................. 7-8
Tarea 2: Modificación de la clase CustomerReport .......... 7-10
Tarea 3: Eliminación de la clase TestReport actual.......... 7-11
Ejercicio 2: Uso de interfaces y clases abstractas (nivel 1).......... 7-12
Preparación .............................................................................. 7-13
Tarea 1: Creación de la interfaz Pet ...................................... 7-13
Tarea 2: Creación de las clases de Animal........................... 7-14
Tarea 3: Creación de la clase TestAnimals ........................ 7-14
Tarea 4: Compilación de la clase TestAnimals ................. 7-15
Tarea 5: Ejecución del programa TestAnimals ................. 7-15
Preparación .............................................................................. 7-16
Tarea 4: Compilación de la clase TestAnimals ................. 7-20
Preparación .............................................................................. 7-21
Unauthorized reproduction or distribution prohibited. Copyright© 2010, Oracle and/or its affiliates. xi
Tarea 4: Compilación de la clase TestAnimals.................. 7-26
Excepciones y aserciones .............................................................. 8-1
Objetivos............................................................................................. 8-1
Ejercicio: Creación de excepciones propias (nivel 1) .................... 8-2
Tarea 1: Creación de la clase OverdraftException........... 8-4
Tarea 3: Modificación de la clase CheckingAccount .......... 8-4
Tarea 1: Creación de la clase OverdraftException........... 8-7
Tarea 3: Modificación de la clase CheckingAccount .......... 8-8
Tarea 1: Creación de la clase OverdraftException......... 8-10
Tarea 3: Modificación de la clase CheckingAccount ........ 8-11
Uso de colecciones y tipos genéricos........................................... 9-1
Objetivos............................................................................................. 9-1
Ejercicio 1: Uso de colecciones para representar asociaciones
(nivel 1) ............................................................................................. 9-2
Preparación ................................................................................ 9-3
Tarea 2: Modificación de la clase Customer.......................... 9-3
(nivel 2) ............................................................................................. 9-5
Preparación ................................................................................ 9-5
Tarea 2: Modificación de la clase Customer.......................... 9-6
xiiUnauthorized reproduction orLenguaje

prohibited. Java™
(nivel 3) ............................................................................................. 9-8
Preparación ................................................................................ 9-8
Principios básicos de E/S..............................................................10-1
E/S de consola y E/S de archivos .................................................11-1
Objetivos........................................................................................... 11-1
Ejercicio 1: Lectura de un archivo de datos (nivel 1) .................. 11-2
Preparación .............................................................................. 11-4
Tarea 1: Creación de un directorio data.............................. 11-4
Tarea 2: Copia del archivo de recursos ................................ 11-5
Tarea 3: Creación de la clase DataSource........................... 11-5
Tarea 4: Eliminación de clases innecesarias ........................ 11-5
Tarea 7: Ejecución del proyecto BankPrj............................ 11-6
Ejercicio 1: Lectura de un archivo de datos (nivel 2) .................. 11-7
Preparación .............................................................................. 11-7
Tarea 1: Creación de un directorio data.............................. 11-8
Tarea 2: Copia del archivo de recursos ................................ 11-8
Tarea 3: Creación de la clase DataSource........................... 11-8
Tarea 4: Eliminación de clases innecesarias ........................ 11-9
Tarea 7: Ejecución del proyecto BankPrj.......................... 11-10
Ejercicio 1: Lectura de un archivo de datos (nivel 3) ................ 11-11
Preparación ............................................................................ 11-11
Tarea 1: Creación de un directorio data............................ 11-12
Tarea 2: Copia del archivo de recursos .............................. 11-12
Tarea 3: Creación de la clase DataSource......................... 11-13
Tarea 4: Eliminación de clases innecesarias ...................... 11-15
Tarea 5: Copia de la clase TestReport.............................. 11-15
Tarea 6: Compilación de la clase TestReport.................. 11-15
Resumen del ejercicio .................................................................... 11-17
Creación de interfaces gráficas con la API Swing ......................12-1
Objetivos........................................................................................... 12-1
Ejercicio 1: Creación de la GUI ChatClient - Parte 1 (nivel 1). 12-2
Preparación .............................................................................. 12-3
Tarea 1: Creación de la clase ChatClient........................... 12-3
Unauthorized reproduction or distribution prohibited. Copyright© 2010, Oracle and/or its affiliates. xiii
Tarea 2: Compilación de la clase ChatClient.................... 12-4
Tarea 3: Ejecución del programa ChatClient.................... 12-4
Tarea 3: Terminación del programa ChatClient
en ejecución........................................................................... 12-4
Ejercicio 1: Creación de la GUI ChatClient - Parte 1
(nivel 2) ........................................................................................... 12-5
Preparación .............................................................................. 12-5
en ejecución........................................................................... 12-7
(nivel 3) ........................................................................................... 12-8
Preparación .............................................................................. 12-8
Tarea 2: Compilación de la clase ChatClient.................. 12-11
Tarea 3: Ejecución del programa ChatClient.................. 12-11
en ejecución......................................................................... 12-11
Ejercicio 2: Creación de la GUI Bank ATM - Parte 1
(avanzado).................................................................................... 12-12
Preparación ............................................................................ 12-13
Tarea 1: Copia de la clase ATMClient................................ 12-13
Tarea 2: Modificación de la clase ATMClient ................... 12-14
Tarea 3: Compilación de la clase ATMClient.................... 12-14
Tarea 4: Ejecución del programa ATMClient.................... 12-14
Sugerencias ............................................................................ 12-15
Control de los eventos generados por la interfaz gráfica.......... 13-1
Objetivos........................................................................................... 13-1
(nivel 1) ........................................................................................... 13-2
Preparación .............................................................................. 13-2
Tarea 1: Modificación de la clase ChatClient ................... 13-3
Sugerencias .............................................................................. 13-3
(nivel 2) ........................................................................................... 13-4
Preparación .............................................................................. 13-4
xiv
prohibited. Java™
(nivel 3) ........................................................................................... 13-6
Preparación .............................................................................. 13-6
(avanzado)...................................................................................... 13-9
Preparación ............................................................................ 13-10
Tarea 1: Modificación de la clase ATMClient ................... 13-10
Tarea 2: Compilación de la clase ATMClient.................... 13-10
Aplicaciones basadas en la interfaz gráfica ................................14-1
Objetivos........................................................................................... 14-1
Ejercicio: Creación de la GUI ChatClient - Parte 3 (nivel 1).... 14-2
Preparación .............................................................................. 14-3
Preparación .............................................................................. 14-4
Preparación .............................................................................. 14-6
Tarea 3: Ejecución del programa ChatClient.................. 14-10
Subprocesos...................................................................................15-1
Objetivos........................................................................................... 15-1
Ejercicio: Programación multisubproceso (nivel 1) .................... 15-2
Preparación .............................................................................. 15-2
Tarea 1: Creación de la clase PrintMe ................................. 15-3
Tarea 2: Creación de la clase TestThreeThreads ............. 15-3
Tarea 3: Compilación de la clase TestThreeThreads ...... 15-3
Tarea 4: Ejecución del programa TestThreeThreads ...... 15-4
Preparación .............................................................................. 15-5
Tarea 2: Creación de la clase TestThreeThreads ............. 15-6
Tarea 3: Compilación de la clase TestThreeThreads ...... 15-7
Tarea 4: Ejecución del programa TestThreeThreads ...... 15-7
Unauthorized reproduction or distribution prohibited. Copyright© 2010, Oracle and/or its affiliates. xv
Preparación .............................................................................. 15-8
Tarea 2: Creación de la clase TestThreeThreads ........... 15-10
Tarea 3: Compilación de la clase TestThreeThreads..... 15-11
Tarea 4: Ejecución del programa TestThreeThreads .... 15-11
Funciones de red ........................................................................... 16-1
Objetivos........................................................................................... 16-1
Ejercicio: Creación de un cliente de socket (nivel 1) ................... 16-2
Preparación .............................................................................. 16-4
Tarea 3: Ejecución del proyecto ChatRoomPrj ................... 16-5
Preparación .............................................................................. 16-6
Tarea 3: Ejecución del proyecto ChatRoomPrj ................... 16-8
Preparación .............................................................................. 16-9
Tarea 1: Modificación de la clase ChatClient ................. 16-10
Tarea 3: Ejecución del proyecto ChatRoomPrj ................. 16-12
xvi
prohibited. Java™
Prólogo de prácticas
Acerca de este libro
Objetivos de las prácticas

Este libro le proporcionará los conocimientos necesarios para:
● Escribir un programa Java™ usando los elementos fundamentales
del lenguaje: tipos primitivos, tipos de referencia, operadores
aritméticos, operadores relacionales, sentencias condicionales e
sentencias iterativas.
● Escribir un programa Java usando conceptos y principios adecuados
de programación orientada a objetos: encapsulación, herencia,
interfaces, polimorfismo, asociación de objetos y multiplicidad de
asociaciones.
● Escribir un programa Java sólido usando control de excepciones,
colecciones genéricas y control de concurrencia.
● Escribir un programa Java avanzado usando las interfaces de
programación de aplicaciones (API) de la interfaz gráfica de usuario
(GUI), las API de entrada/salida (E/S) y las API de red.
Este libro contiene los ejercicios de las prácticas correspondientes a cada

módulo del Manual del alumno.
Prólogo de prácticas-xvii
Unauthorized reproduction orCopyright 2008
distribution Sun Microsystems,
prohibited. Copyright©Inc. Todos
2010, los derechos
Oracle and/or its reservados.
affiliates. Sun Services, Revisión G.2
Realización de los ejercicios
Realización de los ejercicios
Puede realizar cualquiera de las tres versiones de una práctica.
Para determinar cuál le interesa, consulte las siguientes descripciones
de los niveles:
● Nivel 1: versión de la práctica que tiene menos ayuda. Cada tarea se
describe en el párrafo correspondiente, pero el alumno debe decidir
cómo efectúa la tarea.
● Nivel 2: versión de la práctica con un poco más de ayuda.
Aunque en cada paso se describe lo que debe hacer, el alumno
debe determinar qué comandos y opciones utiliza.
● Nivel 3: versión más fácil de la práctica, porque en cada paso se
indica exactamente lo que debe introducir en el sistema. Este nivel
también incluye las soluciones de las tareas para los tres niveles.
Además, hay varios módulos con prácticas avanzadas. Estas prácticas son
opcionales. Son prácticas concebidas para alumnos más avanzados que
pueden realizar fácilmente las prácticas básicas.
Prólogo de prácticas-xviii Lenguaje de programación Java™
Convenciones
Convenciones
En este curso se usan convenciones para representar varios elementos y
recursos de formación alternativos.
Convenciones tipográficas
Se utiliza Courier para indicar nombres de comandos, archivos, código
de programación y mensajes del sistema que aparecen en la pantalla,
por ejemplo:
Utilice ls-a para ver la lista de todos los archivos.
system% Tiene correo.
También se utiliza Courier con los constructores de programación,

como nombres de clases, métodos y palabras clave, por ejemplo:
El método getServletInfo se utiliza para obtener información
sobre el autor.
La clase java.awt.Dialog contiene el constructor Dialog.
Se aplica Courier en negrita a los números y caracteres que debe

introducir el usuario, por ejemplo:
Para ver la lista de archivos de este directorio, escriba:
# ls
También se usa Courier en negrita en las líneas de código de

programación que se citan en una descripción textual, por ejemplo:
1 import java.io.*;
2 import javax.servlet.*;
3 import javax.servlet.http.*;
La interfaz javax.servlet se importa para poder acceder a los métodos de su
ciclo de vida (línea 2).
Se aplica Courier en cursiva a las variables y los espacios de reserva

de la línea de comandos que se sustituyen por un nombre o valor real,
por ejemplo:
Para eliminar un archivo, utilice el comando rm nombre de
archivo.
Acerca de este libro Prólogo de prácticas-xix
Convenciones
Se usa Courier en cursiva y negrita para representar variables
cuyos valores debe introducir el alumno durante un ejercicio, por ejemplo:
Escriba chmod a+rwx nombre de archivo para conceder derechos
de lectura, escritura y ejecución sobre nombre de archivo a todos,
grupos y usuarios.
La fuente Palatino en cursiva se utiliza con títulos de libros, palabras o

términos nuevos o que se desea enfatizar, por ejemplo:
Consulte el capítulo 6 del Manual del usuario.
Se denominan opciones de clase.
Otras convenciones
En los ejemplos del lenguaje Java se emplean estas otras convenciones:
● Los nombres de método no van seguidos de paréntesis, salvo cuando
se incluye una lista de parámetros oficiales o reales, por ejemplo:
“El método doIt...” designa cualquier método denominado doIt.
“El método doIt()...” indica un método doIt que no admite
argumentos.
● Sólo se producen saltos de línea cuando hay separaciones (comas),
conjunciones (operadores) o espacios en blanco en el código.
El código interrumpido se sangra cuatro espacios bajo el código
inicial.
● Cuando en el sistema operativo Solaris™ (SO Solaris) se utiliza un
comando distinto al empleado en la plataforma Microsoft Windows,
se muestran ambos comandos, por ejemplo:
En Solaris:
$ cd $SERVER_ROOT/bin
En Windows:
C:\> cd %SERVER_ROOT%\bin
Prólogo de prácticas-xx Lenguaje de programación Java™
Práctica 1
Introducción
Objetivos
Las personas que realicen la práctica aprenderán a:
● Diagnosticar errores simples de compilación y tiempo de ejecución
● Crear un programa de prueba para una clase existente
Práctica 1-1
2010, los derechos
Ejercicio 1: Exploración de errores de programa Java™
En este ejercicio verá la fuente de varios programas Java sencillos y
corregirá sus errores de compilación y tiempo de ejecución.
Este ejercicio contiene las siguientes secciones:

● “Tarea: Corrección de errores de compilación y tiempo ejecución”
Preparación
No se precisa preparación para este ejercicio.
Referencia a herramientas: Referencias a herramientas usadas en este

ejercicio:
● Desarrollo en Java: Clases de Java: Apertura de clases de Java
● Desarrollo en Java: Clases de Java: Modificación de clases de Java:
Compilación de clases de Java
Ejecución de programas de Java
Para este ejercicio va a trabajar en el proyecto TestProject del

directorio exercises/01_intro/exercise1.
Demostración: La demostración de este ejercicio se encuentra en el

1 directorio demos/01_intro/exercise1.
2
3
Práctica 1-2 Lenguaje de programación Java™
Tarea: Corrección de errores de compilación y tiempo
ejecución
En esta tarea hay cuatro programas Java que contienen errores. Pueden ser
errores de compilación o de tiempo de ejecución. La tarea consiste en
diagnosticar y solucionar estos errores para que los programas se ejecuten.
Realice los pasos siguientes con los archivos Test1.java, Test2.java,

Test3.java y Test4.java:
Referencia a herramientas: Desarrollo en Java: Clases de Java: Apertura

de clases de Java
1. Abra el archivo Java.
Referencia a herramientas: Desarrollo en Java: Clases de Java:

Modificación de clases de Java: Compilación de clases de Java
2. Compile el archivo Java.
3. Si se produce un error de compilación, identifique su origen y
soluciónelo.
4. Repita los pasos 2 y 3 hasta que no queden errores.

Modificación de clases de Java: Ejecución de programas de Java
5. Ejecute el programa Java.
6. Si se produce un error de tiempo de ejecución, identifique su origen
y soluciónelo.
7. Repita los pasos 2 y 3 hasta que no queden errores.
Introducción Práctica 1-3
Ejercicio 2: Creación de un programa de prueba (nivel 1)
En este ejercicio va a crear un programa de prueba (también denominado
test harness) para practicar con una clase suministrada. Las instrucciones
son de nivel 1 e incluyen más indicaciones.
La Figura 1-1 muestra la definición de la clase Account utilizando un

diagrama de clases de Unified Modeling Language (UML).
Account
«constructores»
+Account(initBalance:double)
«métodos»
+getBalance():double
+deposit(amt:double):void
+withdraw(amt:double):void
Figura 1-1 Clase de cuenta bancaria

● “Tarea 1: Copia de la clase Account”
● “Tarea 2: Creación de la clase TestAccount”
● “Tarea 3: Compilación de la clase TestAccount”
● “Tarea 4: Ejecución del programa TestAccount”
Preparación

ejercicio:
● Desarrollo en Java: Proyectos de aplicaciones de Java: Creación de
proyectos
Copia de clases de Java
● Desarrollo en Java: Clases de Java: Creación de clases de Java

2
3
Tarea 1: Copia de la clase Account

En esta tarea, va a crear el proyecto BankPrj y a copiar la clase Account
ya suministrada al proyecto.
Referencia a herramientas: Desarrollo en Java: Proyectos de aplicaciones

de Java: Creación de proyectos
1. Cree el proyecto de aplicación de Java BankPrj con las
características siguientes:
Nombre de proyecto: BankPrj
Ubicación del proyecto: projects
Carpeta del proyecto: projects/BankPrj
Definir como proyecto principal: No
Crear clase principal: No

Modificación de clases de Java: Copia de clases de Java
2. Copie el archivo fuente Account.java suministrado del directorio
resources/01_intro/exercise2 al paquete fuente del proyecto
BankPrj.
Tarea 2: Creación de la clase TestAccount
En esta tarea seguirá los pasos indicados a continuación para crear una
nueva clase de Java TestAccount.
Referencia a herramientas: Desarrollo en Java: Clases de Java: Creación

de clases de Java
1. Cree una nueva clase de Java en el proyecto BankPrj con las
siguientes características:
Nombre de clase: TestAccount
Proyecto: BankPrj
Ubicación: Source Packages
Paquete: default package
2. Edite el archivo fuente de la clase TestAccount para añadir un
método main. El método main de la clase TestAccount crea un
objeto Account con un saldo inicial de 100. Deposita 50 y después
retira 147 del objeto Account. Por último, debe imprimir el saldo del
objeto Account en el flujo de salida estándar.
Tarea 3: Compilación de la clase TestAccount

Compile la clase TestAccount y realice los cambios necesarios para
corregir los errores de compilación.
Tarea 4: Ejecución del programa TestAccount

Ejecute el programa TestAccount. Si hay errores en tiempo de ejecución,
realice los cambios necesarios en la clase TestAccount, recompílela y
ejecute de nuevo el programa.
La salida del programa TestAccount debe ser similar a la siguiente:
Final account balance is: 3.0
En este ejercicio va a crear un programa de prueba (clase de prueba) para
practicar con una clase suministrada. Las instrucciones son de nivel 1 e
incluyen más indicaciones.

Preparación

ejercicio:
proyectos

2
3

1. Cree el proyecto de aplicación de Java BankPrj con las características
siguientes:

BankPrj.


de clases de Java
1. Cree una clase de Java con las siguientes características:
Proyecto: BankPrj
2. Añada el método main.
3. Declare una variable en el método main. La variable tiene el tipo
Account y el nombre acct. Inicialice la variable creando una
instancia de la clase Account con un saldo inicial de 100.
4. Utilice el método deposit para añadir 50 a la cuenta.
5. Utilice el método withdraw para restar 147 a la cuenta.
6. Utilice el método getBalance para recuperar el nuevo saldo de la
cuenta y use el método System.out.println para mostrar el saldo
en el flujo de salida estándar.


En este ejercicio va a crear un programa de prueba (clase de prueba) para
practicar con una clase suministrada. Las instrucciones son de nivel 3 e
incluyen más indicaciones con fragmentos de código.

Preparación

ejercicio:
proyectos

2
3

1. Cree el proyecto de aplicación de Java BankPrj con las

BankPrj.


de clases de Java
1. Cree una clase de Java con las siguientes características:
Proyecto: BankPrj
2. Añada el método main a la clase TestAccount:
public class TestAccount {
public static void main(String[] args) {
// código aquí
}
}
3. Declare una variable de tipo Account e inicialícela creando una
instancia de la clase Account con un saldo inicial de 100.
Account acct = new Account(100.0);
4. Utilice el método deposit para añadir 50 a la cuenta.
acct.deposit(50.0);
5. Utilice el método withdraw para restar 147 a la cuenta.
acct.withdraw(147.0);
6. Utilice el método getBalance para recuperar el nuevo saldo de la
cuenta y use el método System.out.println para mostrar el saldo
System.out.println(“Final account balance is ” + acct.getBalance());


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

experiencias extraídas del ejercicio.
!
?
● Experiencias
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
● Interpretaciones
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
● Conclusiones
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
● Aplicaciones
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
Práctica 2
Programación orientada a objetos
Objetivos
● Usar la documentación de API de Java para investigar una clase
● Explorar la ocultación y encapsulación de la información
● Usar paquetes para organizar las clases
Práctica 2-1
2010, los derechos
Ejercicio 1: Uso de la documentación de API de Java
Ejercicio 1: Uso de la documentación de API de Java
En este ejercicio va a explorar la documentación de API de la plataforma
Java™, Standard Edition 6 (Java SE 6) para explorar los métodos de una
clase.

● “Tarea: Uso de la documentación de API de Java”
Preparación
Debe tener abierta una ventana del navegador de web.
Tarea: Uso de la documentación de API de Java

Realice los pasos siguientes para usar la documentación de API de Java:
1. Abra la página web con la especificación de la API de la plataforma
Java™ Standard Edition 6.
Nota – La documentación de API para la plataforma Java SE 6 se

encuentra en http://java.sun.com/javase/6/docs/api.
2. Seleccione el paquete java.text en la lista de paquetes del panel del

ángulo superior izquierdo del conjunto de marcos de la API.
3. Seleccione la clase NumberFormat en la lista de clases del panel
inferior izquierdo.
4. Lea la información sobre la clase en la parte superior de la venta de
documentación del panel derecho del conjunto de marcos. Revise los
métodos format y parse.
Ejercicio 2: Exploración de la encapsulación, versión 1 (nivel 1)
(nivel 1)
En este ejercicio va a explorar la finalidad de la encapsulación de objetos
apropiada. Creará una clase en dos pasos para demostrar el uso de la
ocultación de información. En esta versión va a crear una clase Account
con miembros de datos públicos. Después va a crear un programa de
prueba que demuestra el riesgo de usar directamente los datos públicos.
La Figura 2-1 muestra el diagrama UML de la clase Account que va a

crear en este ejercicio. Esta clase tiene un miembro de datos público
(o variable de instancia) llamado balance, que mantiene el valor
monetario de la cuenta bancaria del cliente.
Account
+balance : double
«constructores»
Figura 2-1 Diagrama UML de la clase Account sin ocultación
Sólo hay una regla de negocio que se aplica a la clase Account: El saldo de
la cuenta bancaria nunca debe descender por debajo de cero. En este ejercicio, va
a descubrir que la clase Account no puede asegurar esta regla de negocio.

● “Tarea 1: Eliminación de la clase Account”
● “Tarea 2: Creación de la clase Account”
● “Tarea 3: Creación de la clase TestAccount2”
● “Tarea 4: Compilación de la clase TestAccount2”
● “Tarea 5: Ejecución del programa TestAccount2”
Programación orientada a objetos Práctica 2-3
Preparación

ejercicio:
● Desarrollo en Java: Otros archivos: Eliminación de archivos
Para este ejercicio va a trabajar en el proyecto BankPrj del directorio

projects.

1 directorio demos/02_OOP/exercise2.
2
3
Tarea 1: Eliminación de la clase Account
Referencia a herramientas: Desarrollo en Java: Otros archivos:

Eliminación de archivos
En esta tarea va a eliminar la clase Account copiada en la práctica 1.
Tarea 2: Creación de la clase Account

En esta tarea, va a crear la clase Account de acuerdo con el diagrama
UML de la Figura 2-1. Esta clase debe tener las características siguientes:
Nombre de clase: Account
Proyecto: BankPrj
Después de crear la clase Account, añada la variable de instancia

balance y un constructor de acuerdo con el diagrama UML de
Figura 2-1. Inicialice la variable de instancia balance con el parámetro
del constructor.
Tarea 3: Creación de la clase TestAccount2
En esta tarea va a crear la clase TestAccount2 con las características
siguientes:
Nombre de clase: TestAccount2
Proyecto: BankPrj
Esta clase actúa como un programa para crear un objeto Account con un
saldo inicial de 100. El programa de prueba añade 47 y después resta 150.
Por último, el programa de prueba debe imprimir el saldo del objeto en el
flujo de salida estándar.
Tarea 4: Compilación de la clase TestAccount2

En esta tarea va a compilar la clase TestAccount2 y realizar los cambios
necesarios para corregir los errores de compilación.
Tarea 5: Ejecución del programa TestAccount2

En esta tarea va a ejecutar el programa TestAccount2.
La salida debe ser similar a la siguiente:

Final account balance is -3.0
(nivel 2)
apropiada. Las instrucciones son de nivel 2 e incluyen más indicaciones.

Preparación

ejercicio:

projects.

2
3


clase de Java denominada TestAccount.
1. Cree la clase Account con las siguientes características:
Proyecto: BankPrj
2. Añada la variable de instancia balance.
3. Añada un constructor que defina la variable de instancia balance en
el argumento de saldo inicial pasado al constructor.

clase de Java denominada TestAccount2.
1. Cree la clase TestAccount2 con las siguientes características:
Proyecto: BankPrj
2. Añada el método main:
a. Declare una variable dentro del método main con el tipo
Account y el nombre acct. Además, en la misma sentencia,
inicialice la variable acct como una nueva instancia de
Account pasando 100.00 al constructor como saldo inicial.
b. Utilice el operador de suma para añadir 47 al saldo del objeto
de cuenta.
c. Utilice el operador de resta para restar 150 al saldo del objeto de
cuenta.
d. Utilice el método System.out.println para mostrar el saldo

En esta tarea va a compilar las clases TestAccount2 y Account, y a
realizar los cambios necesarios para corregir los errores de compilación.


(nivel 3)
apropiada. Las instrucciones son de nivel 3 e incluyen más indicaciones
con fragmentos de código.

Preparación

ejercicio:

projects.

2
3


clase de Java denominada TestAccount.
1. Cree la clase Account con las siguientes características:
Proyecto: BankPrj
2. Añada la variable de instancia balance.
public double balance;
3. Añada un constructor que defina el saldo en el argumento de saldo
inicial pasado al constructor.
public Account(double initBalance) {
balance = initBalance;
}

clase de Java denominada TestAccount2.
1. Cree la clase TestAccount2 con las siguientes características:
Proyecto: BankPrj
2. Añada el método main:
// código aquí
}
3. Declare una variable dentro del método main con el tipo Account y
el nombre acct. Además, en la misma sentencia, inicialice la variable
acct como una nueva instancia de Account pasando 100.00 al
constructor como saldo inicial.
Account acct = new Account(100.0);
4. Utilice el operador de suma para añadir 47 al saldo del objeto de
cuenta.
acct.balance = acct.balance + 47.0;
5. Utilice el operador de resta para restar 150 al saldo del objeto de
cuenta.
acct.balance = acct.balance - 150.0;
6. Utilice el método System.out.println para mostrar el saldo en el
flujo de salida estándar.
System.out.println(“Final account balance is ” + acct.balance);

En esta tarea va a compilar las clases TestAccount2 y Account, y a
realizar los cambios necesarios para corregir los errores de compilación.


(nivel 1)
apropiada. Va a modificar la clase Account para ocultar su miembro
de datos y suministrar métodos públicos para manipular el saldo.
Después, utilizará el programa de prueba que ha creado en la práctica 1
para comprobar si se cumple la regla de negocio (el saldo no debe descender
por debajo de cero).
La Figura 2-2 muestra el diagrama UML de la clase Account que ha

creado. El diseño de la clase Account oculta la variable de instancia
balance y suministra métodos públicos para manipular el saldo de la
cuenta. El método deposit añade dinero a la cuenta. El método withdraw
retira dinero de la cuenta. El método getBalance devuelve el valor actual
de la variable de instancia balance.
Account
-balance : double
«constructores»
«métodos»
Figura 2-2 Diagrama UML de la clase Account con ocultación de

información
Recuerde que aún debe respetarse una regla de negocio: El saldo de la

cuenta bancaria nunca debe descender por debajo de cero. Esta regla de negocio
debe cumplirse en el método withdraw.

● “Tarea 1: Modificación de la clase Account”
● “Tarea 2: Modificación de la clase TestAccount”
Preparación

ejercicio:

projects.

2
3
Tarea 1: Modificación de la clase Account

En esta tarea va a modificar el archivo fuente de la clase Account.
Esta clase debe cumplir el diagrama UML de la Figura 2-2.
Tarea 2: Modificación de la clase TestAccount

En esta tarea va a modificar la clase TestAccount para depositar 47 y
retirar 150 del objeto Account.

En esta tarea va a compilar las clases TestAccount y Account.
En esta tarea va a ejecutar el programa TestAccount. La salida debe ser
similar a la siguiente:
Final account balance is 147.0
El comando de retirada de 150 no ha surtido efecto porque habría hecho

que el saldo cayera por debajo de cero. Sin embargo, el objeto Account no
ha indicado al programa que el comando de retirada ha fallado, sino que
ha omitido el comando. Solucionará este problema en futuros ejercicios.
(nivel 2)
apropiada. Las instrucciones son de nivel 2 e incluyen más indicaciones.

Preparación

ejercicio:

projects.

2
3
En esta tarea seguirá los pasos indicados a continuación para modificar la
clase Account.
1. Cambie la variable de instancia balance de public a private.
2. Añada el método deposit que toma una cantidad (del tipo double)
y la añade al saldo. Guarde el nuevo saldo en la variable de
instancia.
3. Añada el método withdraw que toma una cantidad (del tipo double)
y la resta al saldo. Guarde el nuevo saldo en la variable de instancia.
Esta operación puede definir el saldo en un valor inferior a cero si
la cantidad retirada es superior al saldo actual. Debe utilizar una
sentencia condicional para verificar que la cantidad no sea superior
al saldo antes de efectuar la resta. La sentencia condicional tiene este
aspecto:
if ( <boolean_test> ) {
<statement_when_true>*
} else {
<statement_when_false>*
}
4. Añada el método getBalance para devolver la variable de instancia
balance.

clase TestAccount.
1. Cambie la cantidad en la llamada al método deposit a 47.0.
2. Cambie la cantidad en la llamada al método withdraw a 150.0.


(nivel 3)
apropiada. Las instrucciones son de nivel 3 e incluyen más indicaciones
con fragmentos de código.

Preparación

ejercicio:

projects.

2
3
clase Account.
1. Cambie la variable de instancia balance de public a private.
private double balance;
2. Añada el método deposit que toma una cantidad (del tipo double)
y la añade al saldo. Guarde el nuevo saldo en la variable de instancia
balance.
public void deposit(double amt) {
balance = balance + amt;
}
3. Añada el método withdraw que toma una cantidad (del tipo double)
y la resta al saldo. Guarde el nuevo saldo en la variable de instancia
balance.
public void withdraw(double amt) {
if ( amt <= balance ) {
balance = balance - amt;
}
}
4. Añada el método getBalance para devolver la variable de instancia
balance.
public double getBalance() {
return balance;
}

clase TestAccount.
1. Cambie la cantidad en la llamada al método deposit a 47.0.
acct.deposit(47,0);
2. Cambie la cantidad en la llamada al método withdraw a 150.0.
acct.withdraw(150,0);

Ejercicio 4: Creación de paquetes de Java
En este ejercicio va a situar las clases Account y TestAccount en
paquetes distintos.
La Figura 2-3 muestra un diagrama UML de los paquetes que va a crear

en este ejercicio. La clase Account se sitúa en el paquete
com.mybank.domain, mientras que la clase TestAccount se coloca en el
paquete com.mybank.test.
com.mybank
prueba dominio
TestAccount Account
-balance : double
+main(args:String[])
«constructores»
«métodos»
Figura 2-3 Estructura de paquetes del proyecto bancario

● “Tarea 1: Creación de los paquetes de Java”
● “Tarea 2: Desplazamiento y modificación de la clase Account”
● “Tarea 3: Desplazamiento de la clase TestAccount”
Preparación

ejercicio:
● Desarrollo en Java: Paquetes de Java: Creación de paquetes de Java
● Desarrollo en Java: Clases de Java: Desplazamiento de clases de Java
(sin refactorización)

projects.

2
3
Tarea 1: Creación de los paquetes de Java
Referencia a herramientas: Desarrollo en Java: Paquetes de Java: Creación

de paquetes de Java
En esta tarea va a crear dos paquetes de origen de Java en el proyecto

BankPrj con los nombres siguientes:
com.mybank.domain
com.mybank.test
Tarea 2: Desplazamiento y modificación de la clase
Account
En esta tarea, va a realizar los pasos siguientes para desplazar la clase
Account y añadir la sentencia de paquete correspondiente a la clase:

Desplazamiento de clases de Java (sin refactorización)
1. Desplace el archivo fuente de la clase Account al paquete
com.mybank.domain.
2. Añada la siguiente sentencia de paquete encima de la clase
Account:
package com.mybank.domain;
Tarea 3: Desplazamiento de la clase TestAccount

En esta tarea, va a realizar los pasos siguientes para desplazar la clase
TestAccount y añadir las sentencias de paquete y de importación
adecuadas a la clase:
1. Desplace el archivo fuente de la clase TestAccount al paquete
com.mybank.test.
2. Añada la siguiente sentencia de paquete encima de la clase
TestAccount:
package com.mybank.test;
3. Añada la siguiente sentencia de importación bajo la sentencia de
paquete de la clase TestAccount:
import com.mybank.domain.Account;


En esta tarea va a ejecutar el programa TestAccount. El código no ha
cambiado, así que la salida debe ser similar a la siguiente:

!
?
● Experiencias
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
● Conclusiones
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
● Aplicaciones
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
Práctica 3
Identificadores, palabras clave y tipos
Objetivos
● Explorar la asignación de variables de referencia
● Usar una variable de referencia para codificar una asociación de
objetos
Práctica 3-1
2010, los derechos
Ejercicio 1: Investigación de asignación de referencias
En este ejercicio va a investigar las variables de referencia, la creación de
objetos y la asignación de variables de referencia.
La Figura 3-1 muestra un diagrama de clase para la clase MyPoint que se

suministra en el directorio del ejercicio. Tenga en cuenta que las variables
de instancia x e y son públicas, lo que le permite acceder a estos miembros
de datos directamente en el programa de prueba. Además, el método
toString se utiliza cuando se imprime el objeto usando el método
System.out.println.
MyPoint
+x : int
+y : int
+toString() : String
Figura 3-1 Diagrama UML de la clase MyPoint
La tarea consiste en crear un programa de prueba que explore referencias

a objetos.

● “Tarea 1: Creación de la clase TestMyPoint”
● “Tarea 2: Compilación de la clase TestMyPoint”
● “Tarea 3: Ejecución del programa TestMyPoint”
Preparación

ejercicio:
● Desarrollo en Java: Proyectos de aplicaciones de Java: Apertura de
proyectos
Para este ejercicio va a trabajar en el proyecto PointProject del
directorio exercises/03_types/exercise1.

1 directorio demos/03_types/exercise1.
2
3
Tarea 1: Creación de la clase TestMyPoint

de Java: Apertura de proyectos
Lleve a cabo los pasos siguientes:

1. Abra el proyecto PointProject del directorio
exercises/03_types/exercise1.
2. Cree la clase TestMyPoint con las características siguientes:
Nombre de clase: TestMyPoint
Proyecto: PointProject
3. Cree el método main y lleve a cabo los pasos siguientes en el método
main:
a. Declare dos variables del tipo MyPoint llamadas start y end.
Asigne a ambas variables un nuevo objeto MyPoint.
b. Defina los valores x e y de start en 10. Defina el valor x de end
en 20 y el valor y en 30.
c. Imprima ambas variables de punto. Utilice código similar a:
System.out.println("Start point is " + start);
d. Para asegurarse de que utiliza correctamente la clase MyPoint,
quizá desee compilar y ejecutar ahora TestMyPoint (véase
“Tarea 2: Compilación de la clase TestMyPoint” y “Tarea 3:
Ejecución del programa TestMyPoint”). Si lo hace, la salida
será similar a:
Start point is [10,10]
End point is [20,30]
Identificadores, palabras clave y tipos Práctica 3-3
e. Declare una nueva variable del tipo MyPoint y llámela stray.
Asigne a stray el valor de referencia de la variable existente
end.
f. Imprima stray y end.
g. Asigne nuevos valores a los miembros x (como 47) e y
(como 50) de la variable stray.
h. Imprima stray, end y start.
Tarea 2: Compilación de la clase TestMyPoint

En esta tarea va a compilar la clase TestMyPoint.
Tarea 3: Ejecución del programa TestMyPoint

En esta tarea va a ejecutar el programa TestMyPoint.

Stray point is [20,30]

Stray point is [47,50]

Los valores resultantes con end reflejan el cambio realizado en stray,

indicativo de que ambas variables hacen referencia al mismo objeto
MyPoint. No obstante, start no ha variado, lo que indica que es
independiente de las otras dos variables.
Ejercicio 2: Creación de cuentas de cliente (nivel 1)
En este ejercicio va a ampliar el proyecto bancario con la clase Customer.
La Figura 3-2 muestra el diagrama UML de la clase Customer y su

relación con la clase Account. Esta relación puede interpretarse así:
Un cliente tiene una cuenta.
com.mybank.domain
has-a 1
Customer Account
-firstName : String -balance : double
-lastName : String
«constructores»
-account : Account
«constructores»
«métodos»
+Customer(f:String, l:String)
«métodos» +deposit(amt:double):void
+getFirstName():String +withdraw(amt:double):void
+getLastName():String
+getAccount():Account
+setAccount(acct:Account):void
Figura 3-2 Diagrama UML de la clase Customer

● “Tarea 1: Creación de la clase Customer”
● “Tarea 2: Copia de la clase TestBanking”
● “Tarea 3: Compilación de la clase TestBanking”
● “Tarea 4: Ejecución del programa TestBanking”
Preparación

ejercicio:

projects.

2
3
Tarea 1: Creación de la clase Customer

En esta tarea, va a crear la clase Customer de acuerdo con el diagrama
UML de la Figura 3-2. Esta clase tiene las características siguientes:
Nombre de clase: Customer
Proyecto: BankPrj
Paquete: com.mybank.domain
En el constructor, inicialice las variables de instancia firstName y

lastName con los parámetros del constructor.
Tarea 2: Copia de la clase TestBanking
En esta tarea va a copiar el archivo TestBanking.java del directorio
resources/03_types/exercise2 al paquete de origen
com.mybank.test del proyecto BankPrj.
Tarea 3: Compilación de la clase TestBanking

En esta tarea va a compilar la clase TestBanking. Si hay errores de
compilación, debe corregirlos modificando la clase Customer como
corresponda y después compilar de nuevo la clase TestBanking.
Tarea 4: Ejecución del programa TestBanking

En esta tarea va a ejecutar el programa TestBanking. La salida debe ser
Creating the customer Jane Smith.
Creating her account with a 500.00 balance.
Withdraw 150.00
Deposit 22.50
Withdraw 47.62
Customer [Smith, Jane] has a balance of 324.88
Las instrucciones son de nivel 2 e incluyen más indicaciones.

Preparación

ejercicio:

projects.

2
3
En esta tarea va a crear la clase Customer.

1. Cree la clase Customer con las características siguientes:
Proyecto: BankPrj
2. Declare tres variables de instancia privadas: firstName, lastName y
account.
3. Declare un constructor público que reciba dos parámetros (f y l) que
llenen las variables de instancia del objeto.
4. Declare dos accedentes públicos para las variables de instancia del
objeto; los métodos getFirstName y getLastName devuelven la
variable de instancia adecuada.
5. Declare el método getAccount para recuperar la variable de
instancia account.
6. Declare el método setAccount para asignar la variable de instancia
account.


Withdraw 150.00
Deposit 22.50
Withdraw 47.62
Las instrucciones son de nivel 3 e incluyen más indicaciones con
fragmentos de código.

Preparación

ejercicio:

projects.

2
3
En esta tarea va a crear la clase Customer.

1. Cree la clase Customer con las características siguientes:
Proyecto: BankPrj
2. Declare tres variables de instancia privadas: firstName, lastName y
account.
private String firstName;
private String lastName;
private Account account;
3. Declare un constructor público que reciba dos parámetros (f y l) que
llenen las variables de instancia del objeto.
public Customer(String f, String l) {
firstName = f;
lastName = l;
}
4. Declare dos accedentes públicos para las variables de instancia del
objeto; los métodos getFirstName y getLastName devuelven la
variable de instancia adecuada.
public String getFirstName() {
return firstName;
}
public String getLastName() {
return lastName;
}
5. Declare el método getAccount para recuperar la variable de
instancia account.
public Account getAccount() {
return account;
}
6. Declare el método setAccount para asignar la variable de instancia
account.
public void setAccount(Account acct) {
account = acct;
}


Withdraw 150.00
Deposit 22.50
Withdraw 47.62

!
?
● Experiencias
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
● Conclusiones
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
● Aplicaciones
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
Práctica 4
Expresiones y control del flujo
Objetivos
● Usar un sencillo bucle for
● Usar sentencias condicionales en lógica de negocio
● (Opcional) Usar bucles anidados para implementar una operación de
búsqueda de cadenas
Práctica 4-1
2010, los derechos
Ejercicio 1: Uso de bucles y sentencias de ramificación
En este ejercicio va a utilizar un sencillo bucle entero y sentencias de
ramificación para jugar un juego ficticio de foo bar baz.
Cree un programa que realice un bucle de 1 a 50 e imprima cada valor

en una línea distinta. Además, imprima foo para cada múltiplo de tres,
bar para cada múltiplo de cinco y baz para cada múltiplo de siete.
Por ejemplo:
Código 4-1 Salida (parcial) del programa FooBarBaz

1
2
3 foo
4
5 bar
6 foo
7 baz
8
9 foo
10 bar
11
12 foo
13
14 baz
15 foo bar
16
y así sucesivamente.

● “Tarea 1: Creación de la clase FooBarBaz”
● “Tarea 2: Compilación de la clase FooBarBaz”
● “Tarea 3: Ejecución del programa FooBarBaz”
Preparación

ejercicio:
proyectos
Para este ejercicio va a trabajar en el proyecto LoopProject del

directorio exercises/04_stmts/exercise1.

1 directorio demos/04_stmts/exercise1.
2
3
Tarea 1: Creación de la clase FooBarBaz

1. Abra el proyecto LoopProject del directorio
exercises/04_stmts/exercise1.
2. Cree la clase FooBarBaz con las características siguientes:
Nombre de clase: FooBarBaz
Proyecto: LoopProject
3. Declare el método main.
Expresiones y control del flujo Práctica 4-3
4. Utilice un bucle for para iterar de 1 a 50 en el método main.
a. Imprima el número actual.
b. Utilice tres sentencias if para probar si el número actual es
divisible por tres, cinco o siete; en caso afirmativo, imprima
foo, bar y baz según corresponda.
Tarea 2: Compilación de la clase FooBarBaz

En esta tarea va a compilar el programa FooBarBaz.
Tarea 3: Ejecución del programa FooBarBaz

En esta tarea va a ejecutar el programa FooBarBaz.
La salida debe ser similar al Código 4-1 en la página L4-2.
Sugerencias
Estas indicaciones pueden ayudarle a resolver el ejercicio:
● Utilice el método System.out.print para imprimir una cadena o
un valor sin necesidad de imprimir un carácter de nueva línea.
Puede utilizar múltiples métodos print para imprimir una única
línea de texto. Puede utilizar un único método println, sin
argumentos, para imprimir un carácter de nueva línea.
● El operador % calcula un resto entero.
Ejercicio 2: Uso de sentencias condicionales en la clase Account (nivel 1)
Account (nivel 1)
En este ejercicio va a modificar el método withdraw para que devuelva
un valor booleano especificando si la operación ha tenido éxito.
La Figura 4-1 nuestra el diagrama UML de la clase del proyecto bancario.

La clase Account ahora incluye un cambio de diseño en los métodos
deposit y withdraw, que en este caso deben devolver un valor booleano
para indicar el éxito (true) o el fallo (false) de la operación.
com.mybank.domain
has-a 1
Customer Account
-firstName : String -balance : double
-lastName : String
«constructores»
-account : Account
«constructores»
«métodos»
+Customer(f:String, l:String)
«métodos» +deposit(amt:double):boolean
+getFirstName():String +withdraw(amt:double):boolean
+getLastName():String
+getAccount():Account
+setAccount(acct:Account):void
Figura 4-1 Diagrama UML de la clase del proyecto bancario

● “Tarea 2: Eliminación de la clase TestBanking actual”
Preparación

ejercicio:
● Desarrollo en Java: Clases de Java: Ejecución de programas de Java

projects.

2
3

En esta tarea va a modificar el archivo fuente de la clase Account. Esta
clase debe cumplir el diagrama UML de la Figura 4-1. En concreto, los
métodos deposit y withdraw deben devolver un valor booleano como
se ha descrito anteriormente en este ejercicio.
Tarea 2: Eliminación de la clase TestBanking actual

En esta tarea va a eliminar la clase TestBanking actual del paquete

En esta tarea va a copiar la nueva versión del archivo TestBanking.java
del directorio resources/04_stmts/ al paquete com.mybank.test del
proyecto BankPrj.
En esta tarea va a compilar la clase TestBanking.

Withdraw 150.00: true
Deposit 22.50: true
Withdraw 400.00: false
Account (nivel 2)
En este ejercicio va a modificar el método withdraw para que devuelva un
valor booleano especificando si la operación ha tenido éxito.

Preparación

ejercicio:

projects.

2
3
En esta tarea seguirá los pasos indicados a continuación para modificar
la clase Account.
1. Modifique el método deposit. Como las cuentas no tienen límite
superior, este método siempre debe devolver true para indicar que
siempre tiene éxito.
2. Modifique el método withdraw. Como las cuentas no pueden tener
un valor inferior a cero, el método debe verificar si la cantidad
retirada es inferior al saldo actual. En ese caso, la operación
de retirada tiene éxito y debe devolver true; de lo contrario,
la operación falla y el método debe devolver false.


proyecto BankPrj.


Deposit 22.50: true
Account (nivel 3)
En este ejercicio va a modificar el método withdraw para que devuelva un
valor booleano especificando si la operación ha tenido éxito.

Preparación

ejercicio:

projects.

2
3
clase Account.
1. Modifique el método deposit. Como las cuentas no tienen límite
superior, este método siempre debe devolver true para indicar que
siempre tiene éxito.
public boolean deposit(double amt) {
return true;
}
2. Modifique el método withdraw. Como las cuentas no pueden tener
un valor inferior a cero, el método debe verificar si la cantidad
retirada es inferior al saldo actual. En ese caso, la operación
de retirada tiene éxito y debe devolver true; de lo contrario,
la operación falla y el método debe devolver false.
public boolean withdraw(double amt) {
boolean result = false; // supone fallo de la operación
result = true; // éxito de la operación
}
return result;
}


proyecto BankPrj.

Deposit 22.50: true
Ejercicio 3: Uso de bucles anidados (avanzado)
En este ejercicio va a usar bucles anidados para implementar una
operación de búsqueda de cadenas.

● “Tarea 1: Creación del método isSubString”
● “Tarea 2: Compilación de la clase TestIsSubString”
● “Tarea 3: Ejecución del programa TestIsSubString”
Nota – Esta clase incluye varios ejercicios avanzados, que son optativos
y sólo debe realizarlos si ha terminado todos los ejercicios anteriores de
este módulo.
Preparación

ejercicio:
proyectos
Para este ejercicio, va a trabajar en el proyecto AdvancedLoopProject

del directorio exercises/04_stmts/exercise3.

2
3
Tarea 1: Creación del método isSubString
En esta tarea abrirá el proyecto AdvancedLoopProject del directorio
exercises/04_stmts/exercise3, abrirá la clase TestIsSubString
y creará el método isSubString. El método busca una cadena específica
dentro de otra cadena, y debe devolver true si la primera cadena se halla
en la segunda. Por ejemplo: isSubString("cat", "The cat in the
hat.") es true, pero isSubString("bat", "The cat in the hat.")
es false.
Además, verifique si se cumplen las siguientes condiciones delimitadoras:

● isSubString("The", "The cat in the hat.") es true
● isSubString("hat.", "The cat in the hat.") es true
Esto es fácil de hacer con el método indexOf de la clase String.

Puede determinar si una cadena s es una subcadena de la cadena x
evaluando la expresión x.indexOf(s) != -1. Sin embargo, el objetivo de
este ejercicio es practicar el uso de los bucles, por lo cual debe solucionar
el problema utilizando sólo el método charAt y bucles anidados.
Tarea 2: Compilación de la clase TestIsSubString

En esta tarea va a compilar la clase TestIsSubString.
Tarea 3: Ejecución del programa TestIsSubString

En esta tarea va a ejecutar el programa TestIsSubString. La salida del
programa debe ser similar al ejemplo mostrado en ‘‘Tarea 1: Creación del
método isSubString’’ en la página L4-14.
Sugerencias
Estas indicaciones pueden ayudarle a resolver el ejercicio.
● Utilice el método charAt(int index) de la clase String para
recuperar un carácter específico de una cadena; el índice empieza
por cero. Por ejemplo: "cat".charAt(0) es c, "cat".charAt(1)
es a y "cat".charAt(2) es t.
● El método length devuelve el número de caracteres de la cadena;
por ejemplo, "cat".length() es 3.

!
?
● Experiencias
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
● Conclusiones
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
● Aplicaciones
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
Práctica 5
Matrices
Objetivos
● Declarar, crear y manipular matrices primitivas unidimensionales
● Usar una matriz para representar una relación de uno a varios
objetos
Práctica 5-1
2010, los derechos
Ejercicio 1: Uso de matrices primitivas (nivel 2)
En este ejercicio va a declarar, crear y manipular matrices unidimensionales
de tipos primitivos.

● “Tarea 1: Creación de la clase TestArrays”
● “Tarea 2: Compilación de la clase TestArrays”
● “Tarea 3: Ejecución del programa TestArrays”
Preparación

ejercicio:
proyectos
Para este ejercicio va a trabajar en el proyecto ArrayProject del

directorio exercises/05_arrays/exercise1.

1 directorio demos/05_arrays/exercise1.
2
3
Tarea 1: Creación de la clase TestArrays
1. Abra el proyecto ArrayProject del directorio
exercises/05_arrays/exercise1.
2. Cree la clase TestArrays con las características siguientes:
Nombre de clase: TestArrays
Proyecto: ArrayProject
3. Añada el método main. En el método main, declare dos variables
llamadas array1 y array2. Deben ser del tipo int[] (matriz de
int).
4. Empleando la notación de llaves, {}, inicialice array1 como los ocho
primeros números primos: 2, 3, 5, 7, 11, 13, 17 y 19.
5. Muestre el contenido de array1. Quizá prefiera usar el método
printArray (véase ‘‘Sugerencia’’ en la página L5-4) para mostrar
estas matrices de enteros.
6. Asigne la variable array2 igual a la variable array1. Modifique el
elemento indizado par de array2 para que sea igual al valor del
índice (por ejemplo, array2[0] = 0; array2[2] = 2; y así
sucesivamente). Imprima array1.
Tarea 2: Compilación de la clase TestArrays

En esta tarea va a compilar la clase TestArrays.
Tarea 3: Ejecución del programa TestArrays

En esta tarea va a ejecutar el programa TestArrays. La salida debe ser
array1 is <2, 3, 5, 7, 11, 13, 17, 19>
array1 is <0, 3, 2, 7, 4, 13, 6, 19>
Discusión: ¿Qué ha sucedido con array1?

!
?
Matrices Práctica 5-3
Sugerencia
El método printArray puede ayudarle a resolver este ejercicio:
public static void printArray(int[] array) {
System.out.print(’<’);
for ( int i = 0; i < array.length; i++ ) {
// imprimir un elemento
System.out.print(array[i]);
// imprimir una coma delimitadora si no es el último
elemento
if ( (i + 1) < array.length ) {
System.out.print(", ");
}
}
System.out.print(’>’);
}
Nota – También puede utilizar el método java.util.Arrays.toString

para generar una representación de cadena de una matriz. Por ejemplo:
System.out.println(Arrays.toString(array1));
En este ejercicio va a declarar, crear y manipular matrices unidimensionales
de tipos primitivos.

● “Tarea 1: Creación de la clase TestArrays”
● “Tarea 2: Compilación de la clase TestArrays”
● “Tarea 3: Ejecución del programa TestArrays”
Preparación

ejercicio:
proyectos
Para este ejercicio va a trabajar en el directorio


2
3
Tarea 1: Creación de la clase TestArrays
1. Abra el proyecto ArrayProject del directorio
2. Cree la clase TestArrays con las características siguientes:
Nombre de clase: TestArrays
Proyecto: ArrayProject
3. Añada el método main. En el método main(), declare dos variables
llamadas array1 y array2. Deben ser del tipo int[] (matriz de int).
public class TestArrays {
int[] array1;
int[] array2;
// insertar código aquí
}
}
4. Empleando la notación de llaves, {}, inicialice array1 como los ocho
primeros números primos: 2, 3, 5, 7, 11, 13, 17 y 19.
int[] array1 = { 2, 3, 5, 7, 11, 13, 17, 19 };
int[] array2;
5. Muestre el contenido de array1. Quizá prefiera usar el método
printArray (véase ‘‘Sugerencia’’ en la página L5-4) para mostrar
estas arrays de enteros.
System.out.print("array1 is ");
printArray(array1);
System.out.println();
6. Asigne la variable array2 igual a la variable array1. Modifique el
elemento indizado par de array2 para que sea igual al valor del
índice (por ejemplo, array2[0] = 0; array2[2] = 2; y así
sucesivamente). Imprima array1.
array2 = array1;
// modify array2
array2[0] = 0;
array2[2] = 2;
array2[4] = 4;
array2[6] = 6;
// imprimir array 1
System.out.print("array1 is ");
printArray(array1);
System.out.println();
Tarea 2: Compilación de la clase TestArrays
En esta tarea va a compilar la clase TestArrays.
Tarea 3: Ejecución del programa TestArrays

En esta tarea va a ejecutar el programa TestArrays. La salida debe ser
array1 is <2, 3, 5, 7, 11, 13, 17, 19>
array1 is <0, 3, 2, 7, 4, 13, 6, 19>
Ejercicio 2: Uso de matrices para representar asociaciones de uno a varios (nivel 1)
de uno a varios (nivel 1)
En este ejercicio va a usar matrices para implementar la asociación entre
un banco y sus múltiples clientes.
La Figura 5-1 nuestra el diagrama UML de la clase del proyecto bancario.

La tarea consiste en crear la clase Bank. El objeto bank lleva un
seguimiento de la relación entre el banco y sus clientes. Esta asociación
de uno a varios se implementa con una matriz de objetos de cliente.
También necesitará mantener una variable de instancia con valor entero
que lleve el seguimiento del número de clientes actuales del banco.
com.mybank.domain
Bank
-customers : Customer[]
-numberOfCustomers : int
«constructores»
+Bank()
«métodos»
+addCustomer(f:String, l:String)
+getNumOfCustomers():int
+getCustomer(index:int):Customer
serves
has-a 1
Customer Account
0..*
Figura 5-1 Diagrama UML de la clase del proyecto bancario

● “Tarea 1: Creación de la clase Bank”
Preparación

ejercicio:

projects.

2
3
Tarea 1: Creación de la clase Bank

En esta tarea, va a crear la clase Bank de acuerdo con el diagrama UML
de la Figura 5-1 en la página L5-8. Esta clase tiene las características
siguientes:
Nombre de clase: Bank
Proyecto: BankPrj

En esta tarea va a eliminar la clase TestBanking actual del paquete de
origen com.mybank.test del proyecto BankPrj.
resources/05_arrays al paquete de origen com.mybank.test del
proyecto BankPrj.


Customer [1] is Simms, Jane
Customer [2] is Bryant, Owen
Customer [3] is Soley, Tim
Customer [4] is Soley, Maria

Preparación

ejercicio:

projects.

2
3
1. Cree la clase Bank con las características siguientes:
Proyecto: BankPrj
2. Añada dos variables de instancia a la clase Bank: customers (una
matriz de objetos Customer) y numberOfCustomers (un entero que
lleva un seguimiento del próximo índice de matriz de customers).
3. Añada un constructor público que inicialice la matriz customers con
un tamaño máximo apropiado (al menos superior a cinco).
4. Añada el método addCustomer. Este método debe construir un
nuevo objeto Customer a partir de los parámetros (nombre y
apellido) y colocarlo en la matriz customers. También debe
incrementar la variable de instancia numberOfCustomers.
5. Añada el método accedente getNumOfCustomers, que devuelve la
variable de instancia numberOfCustomers.
6. Añada el método getCustomer. Este método devuelve el cliente
asociado con el parámetro index especificado.


proyecto BankPrj.


Preparación

ejercicio:

projects.

2
3
1. Cree la clase Bank con las características siguientes:
Proyecto: BankPrj
public class Bank {
}
2. Añada dos variables de instancia a la clase Bank: customers (una
matriz de objetos Customer) y numberOfCustomers (un entero que
lleva un seguimiento del próximo índice de matriz de customers).
public class Bank {
private Customer[] customers;
private int numberOfCustomers;
// insertar métodos aquí
}
3. Añada un constructor público que inicialice la matriz customers con
un tamaño máximo apropiado (al menos superior a cinco).
public Bank() {
customers = new Customer[10];
numberOfCustomers = 0;
}
4. Añada el método addCustomer. Este método debe construir un
nuevo objeto Customer a partir de los parámetros (nombre y
apellido) y colocarlo en la matriz customers. También debe
incrementar la variable de instancia numberOfCustomers.
public void addCustomer(String f, String l) {
int i = numberOfCustomers++;
customers[i] = new Customer(f, l);
}
5. Añada el método accedente getNumOfCustomers, que devuelve la
variable de instancia numberOfCustomers.
public int getNumOfCustomers() {
return numberOfCustomers;
}
6. Añada el método getCustomer. Este método devuelve el cliente
asociado con el parámetro index especificado.
public Customer getCustomer(int customer_index) {
return customers[customer_index];
}


proyecto BankPrj.



!
?
● Experiencias
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
● Conclusiones
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
● Aplicaciones
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
Práctica 6
Diseño de clases
Objetivos
● Crear subclases con herencia y sobrescritura de métodos
● Crear una colección heterogénea y usar polimorfismo
Práctica 6-1
2010, los derechos
Ejercicio 1: Creación de subclases de cuenta bancaria (nivel 1)
(nivel 1)
En este ejercicio va a crear dos subclases de la clase Account en el
proyecto bancario: SavingsAccount y CheckingAccount. Estos tipos de
cuentas tienen las siguientes reglas de negocio:
● La cuenta de ahorro (savings) obtiene intereses. El banco permite a
los clientes guardar dinero en una cuenta de ahorro que acumula
intereses mensuales aplicando la fórmula siguiente: saldo = saldo +
(tipo de interés * saldo)
● La cuenta corriente (checking) permite al cliente realizar cuantos
ingresos y reembolsos desee. Para proteger a sus clientes, el banco les
permite una cantidad fija de protección de descubierto. Esta protección
permite que el saldo de un cliente descienda a menos de cero, pero no
por debajo de la protección de descubierto. La protección de
descubierto de la cuenta va reduciéndose conforme se utiliza.
La Figura 6-1 muestra el diagrama UML de la clase para un diseño que

cumple las reglas de negocio antes descritas.
com.mybank.domain
Account
#balance : double
«constructores»
#Account(initBalance:double)
«métodos»
+deposit(amt:double):boolean
+withdraw(amt:double):boolean
SavingsAccount CheckingAccount
-interestRate : double -overdraftAmount : double
«constructores» «constructores»
+SavingsAccount(initBalance:double, +CheckingAccount(initBalance:double,
interestRate:double) overdraft:double)
+CheckingAccount(initBalance:double)
«métodos»
+withdraw(amt:double):boolean
Figura 6-1 Dos subclases de la clase Account
● “Tarea 2: Creación de la clase SavingsAccount”
● “Tarea 3: Creación de la clase CheckingAccount”
Preparación

ejercicio:

projects.

1 directorio demos/06_class1/exercise1.
2
3
Diseño de clases Práctica 6-3
En esta tarea va a modificar la clase Account del paquete de origen
com.mybank.domain del proyecto BankPrj. Esta clase debe respetar
el diagrama UML de la Figura 6-1 en la página L6-2; en particular,
la variable de instancia balance y el constructor de clase Account ahora
están protegidos (como indica el carácter # que sustituye al carácter -).
Tarea 2: Creación de la clase SavingsAccount

En esta tarea va a crear el archivo fuente de la clase SavingsAccount
del paquete de origen com.mybank.domain del proyecto BankPrj con las
Nombre de clase: SavingsAccount
Proyecto: BankPrj
Amplía: Account
Esta clase debe respetar el diagrama UML de la Figura 6-1 en la

página L6-2 y las normas de negocio definidas en la introducción al
‘‘Ejercicio 1: Creación de subclases de cuenta bancaria (nivel 1)’’ en la
página L6-2.
Tarea 3: Creación de la clase CheckingAccount

En esta tarea va a crear el archivo fuente de la clase CheckingAccount
del paquete de origen com.mybank.domain del proyecto BankPrj con las
Nombre de clase: CheckingAccount
Proyecto: BankPrj
Amplía: Account
Esta clase debe respetar el diagrama UML de la Figura 6-1 en la

página L6-2 y las normas de negocio definidas en la introducción al
‘‘Ejercicio 1: Creación de subclases de cuenta bancaria (nivel 1)’’ en la
página L6-2.

resources/06_class1 al paquete de origen com.mybank.test del
proyecto BankPrj. La nueva clase TestBanking define objetos
CheckingAccount y SavingsAccount para diferentes clientes.


Creating her Savings Account with a 500.00 balance and 3% interest.
Creating the customer Owen Bryant.
Creating his Checking Account with a 500.00 balance and no overdraft
protection.
Creating the customer Tim Soley.
Creating his Checking Account with a 500.00 balance and 500.00 in
overdraft protection.
Creating the customer Maria Soley.
Maria shares her Checking Account with her husband Tim.
Retrieving the customer Jane Smith with her savings account.

Deposit 22.50: true
Customer [Simms, Jane] has a balance of 324.88
Retrieving the customer Owen Bryant with his checking account with no
Deposit 22.50: true
Customer [Bryant, Owen] has a balance of 324.88
Retrieving the customer Tim Soley with his checking account that has
Deposit 22.50: true
Customer [Soley, Tim] has a balance of 0.0
Retrieving the customer Maria Soley with her joint checking account with
husband Tim.
Deposit 150.00: true
Customer [Soley, Maria] has a balance of 150.0
La cuenta de ahorro de Jane y la cuenta corriente de Owen funcionan

esencialmente como una cuenta bancaria básica. En cambio, la cuenta
corriente conjunta de Tim y Maria tiene 500 de protección de descubierto.
Las transacciones de Tim alcanzan esa protección, de manera que su saldo
final es 0,00. El nivel de protección de descubierto de su cuenta es de
424,88. Por último, María deposita 150 en esta cuenta conjunta, elevando
el saldo de 0,00 a 150,00. Después intenta retirar 750 y no puede, porque
ni el saldo ni la protección de descubierto pueden cubrir la cantidad
solicitada.
(nivel 2)
proyecto bancario: SavingsAccount y CheckingAccount.
Esta sección se divide en las siguientes:

Preparación

ejercicio:

projects.

2
3
com.mybank.domain del proyecto BankPrj.

1. Cambie la variable de instancia balance de private a protected.
2. Cambie el constructor Account de public a protected.

En esta tarea va a crear el archivo fuente de la clase SavingsAccount en
el paquete de origen com.mybank.domain del proyecto BankPrj.

1. Cree el archivo fuente de la clase SavingsAccount en el paquete de
origen com.mybank.domain del proyecto BankPrj con las
Proyecto: BankPrj
Amplía: Account
2. Añada la variable de instancia interestRate a la clase
SavingsAccount.
3. Añada un constructor público que reciba dos argumentos:
initBalance y interestRate. Pase el parámetro initBalance
al constructor super. Guarde el parámetro interestRate en la
variable de instancia.
En esta tarea va a crear el archivo fuente de la clase CheckingAccount
en el paquete de origen com.mybank.domain del proyecto BankPrj.

1. Cree el archivo fuente de la clase CheckingAccount en el paquete
de origen com.mybank.domain del proyecto BankPrj con las
Proyecto: BankPrj
Amplía: Account
2. Añada la variable de instancia overdraftAmount a la clase
CheckingAccount.
initBalance y overdraftAmount. Pase el parámetro initBalance
al constructor super. Guarde el parámetro overdraftAmount en la
4. Añada un constructor público que reciba sólo un argumento:
initBalance. Llame al primer constructor con el parámetro
initBalance y utilice el valor predeterminado 0.0 para el
parámetro overdraftAmount.
5. Sobrescriba el método withdraw para usar la variable
overdraftAmount. Este es el seudocódigo para el método
withdraw:
if balance < amount
then
overdraftNeeded = amount - balance
if overdraftAmount < overdraftNeeded
then transaction fails
else
balance = 0
decrement overdraftAmount by overdraftNeeded
else
decrement balance by amount



protection.

Deposit 22.50: true
Deposit 22.50: true
Deposit 22.50: true
husband Tim.
(nivel 3)
proyecto bancario: SavingsAccount y CheckingAccount.

Preparación

ejercicio:

projects.

2
3
com.mybank.domain del proyecto BankPrj.

1. Cambie la variable de instancia balance de private a protected.
protected double balance;
2. Cambie el constructor Account de public a protected.
protected Account(double initBalance) {
balance = initBalance;
}

En esta tarea va a crear el archivo fuente de la clase SavingsAccount en

1. Cree el archivo fuente de la clase SavingsAccount en el paquete
de origen com.mybank.domain del proyecto BankPrj con las
Proyecto: BankPrj
Amplía: Account
public class SavingsAccount extends Account {
}
2. Añada la variable de instancia interestRate a la clase
SavingsAccount.
private double interestRate;
initBalance y interestRate. Pase el parámetro initBalance al
constructor super. Guarde el parámetro interestRate en la variable
de instancia.
public SavingsAccount(double initBalance, double interestRate) {
super(initBalance);
this.interestRate = interestRate;
}

En esta tarea va a crear el archivo fuente de la clase CheckingAccount en

1. Cree el archivo fuente de la clase CheckingAccount en el paquete de
Proyecto: BankPrj
Amplía: Account
public class CheckingAccount extends Account {
}
2. Añada la variable de instancia overdraftAmount a la clase
CheckingAccount.
private double overdraftAmount;
initBalance y overdraftAmount. Pase el parámetro initBalance
al constructor super. Guarde el parámetro overdraftAmount en la
public CheckingAccount(double initBalance, double overdraftAmount) {
super(initBalance);
this.overdraftAmount = overdraftAmount;
}
4. Añada un constructor público que reciba sólo un argumento:
initBalance. Llame al primer constructor con el parámetro
initBalance y utilice el valor predeterminado 0.0 para el
parámetro overdraftAmount.
public CheckingAccount(double initBalance) {
this(initBalance, 0.0);
}
5. Sobrescriba el método withdraw para usar la variable
overdraftAmount.
public boolean withdraw(double amount) {
boolean result = true;
if ( balance < amount ) {
double overdraftNeeded = amount - balance;
if ( overdraftAmount < overdraftNeeded ) {
result = false;
} else {
balance = 0.0;
overdraftAmount -= overdraftNeeded;
}
} else {
balance -= amount;
}
return result;
}



protection.

Deposit 22.50: true
Deposit 22.50: true
Deposit 22.50: true
husband Tim.
Ejercicio 2: Creación de una colección heterogénea de cuentas de cliente (nivel 1)
cuentas de cliente (nivel 1)
En este ejercicio va a crear una matriz heterogénea para representar la
agregación de clientes a cuentas. Es decir, un cliente determinado puede
tener varias cuentas de distintos tipos.
La Figura 6-2 muestra el diagrama UML de clase de las relaciones entre el

banco, clientes y cuentas. Lo que ha cambiado es que un objeto Customer
ahora puede tener varias cuentas, que pueden ser de distintos tipos,
subclases de la clase Account.
com.mybank.domain
serves 0..* has-a 0..*

Bank Customer Account
Figura 6-2 Cliente con una o más cuentas distintas
La tarea consiste en modificar la clase Customer para que admita una

colección heterogénea de objetos Account.

● “Tarea 1: Modificación de la clase Customer”
● “Tarea 2: Copia y rellenado de la clase CustomerReport”
● “Tarea 3: Copia de la clase TestReport”
● “Tarea 4: Compilación de la clase TestReport”
● “Tarea 5: Ejecución del programa TestReport”
Preparación

ejercicio:

projects.

2
3
Tarea 1: Modificación de la clase Customer

En esta tarea va a modificar la clase Customer del paquete de origen
com.mybank.domain del proyecto BankPrj. Modifique la clase
Customer para manipular la asociación con múltiples cuentas, igual que
en el ejercicio 2 de la práctica 5. Ha de incluir los métodos públicos:
addAccount(Account), getAccount(int) y getNumOfAccounts().
Tarea 2: Copia y rellenado de la clase CustomerReport

1. Cree el paquete de origen com.mybank.report en el proyecto
BankPrj.
2. Copie el archivo CustomerReport.java del directorio
resources/06_class1 al paquete de origen com.mybank.report
del proyecto BankPrj.
3. Rellene el código CustomerReport.java. Encontrará bloques
de comentarios que empiezan y terminan con /*** ... ***/.
Estos comentarios indican la ubicación del código que debe
suministrar.
Tarea 3: Copia de la clase TestReport

En esta tarea va a copiar el archivo TestReport.java del directorio
proyecto BankPrj.
Tarea 4: Compilación de la clase TestReport

En esta tarea va a compilar la clase TestReport.
Tarea 5: Ejecución del programa TestReport

En esta tarea va a ejecutar el programa TestReport. La salida debe ser
CUSTOMERS REPORT
================
Customer: Simms, Jane

Savings Account: current balance is 500.0
Checking Account: current balance is 200.0
Customer: Bryant, Owen

Customer: Soley, Tim

Customer: Soley, Maria


Preparación

ejercicio:

projects.

2
3

1. Añada dos variables de instancia a la clase Customer: accounts (una
matriz de objetos Account) y numberOfAccounts (un entero que
lleva un seguimiento del próximo índice de matriz de accounts).
Esto sustituye a la variable de referencia sencilla account, que debe
eliminarse.
2. Modifique el constructor para inicializar la matriz accounts.
3. Añada el método addAccount. Este método recibe un
solo parámetro, un objeto Account, y lo almacena en la matriz
accounts. También debe incrementar la variable de instancia
numberOfAccounts. Este método sustituye al método setAccount,
que debe eliminarse.
4. Añada el método accedente getNumOfAccounts, que devuelve la
variable de instancia numberOfAccounts.
5. Añada el método getAccount. Este método devuelve la cuenta
asociada al parámetro index especificado. Este método sustituye
al método getAccount anterior, que debe eliminarse.

BankPrj.
suministrar.
a. Utilice el operador instanceof para probar qué tipo de
cuenta es y definir account_type en un valor apropiado,
como Savings Account o Checking Account.
b. Imprima el tipo de cuenta y el saldo.

proyecto BankPrj.


similar a la que aparece en la página L6-19.

Preparación

ejercicio:

projects.

2
3

1. Añada dos variables de instancia a la clase Customer: accounts (una
matriz de objetos Account) y numberOfAccounts (un entero que
lleva un seguimiento del próximo índice de matriz de accounts).
Esto sustituye a la variable de referencia sencilla account, que debe
eliminarse.
private Account[] accounts;
private int numberOfAccounts;
2. Modifique el constructor para inicializar la matriz accounts.
firstName = f;
lastName = l;
// inicializar array accounts
accounts = new Account[10];
numberOfAccounts = 0;
}
3. Añada el método addAccount. Este método recibe un
solo parámetro, un objeto Account, y lo almacena en la matriz
accounts. También debe incrementar la variable de instancia
numberOfAccounts. Este método sustituye al método setAccount,
que debe eliminarse.
public void addAccount(Account acct) {
int i = numberOfAccounts++;
accounts[i] = acct;
}
4. Añada el método accedente getNumOfAccounts, que devuelve la
variable de instancia numberOfAccounts.
public int getNumOfAccounts() {
return numberOfAccounts;
}
5. Añada el método getAccount. Este método devuelve la cuenta
asociada al parámetro index especificado. Este método sustituye
al método getAccount anterior, que debe eliminarse.
public Account getAccount(int account_index) {
return accounts[account_index];
}
BankPrj.
suministrar.
a. Utilice el operador instanceof para probar qué tipo de cuenta
es y definir account_type en un valor apropiado, como
Savings Account o Checking Account.
if ( account instanceof SavingsAccount ) {
account_type = "Savings Account";
} else if ( account instanceof CheckingAccount ) {
account_type = "Checking Account";
} else {
account_type = "Unknown Account Type";
}
b. Imprima el tipo de cuenta y el saldo.
System.out.println(" " + account_type + ": current balance is "
+ account.getBalance());

proyecto BankPrj.


similar a la que aparece en la página L6-19.
Ejercicio 3: Creación de un programa por lotes (avanzado)
En este ejercicio, va a crear un programa por lotes para acumular interés
en cada cuenta de ahorro de forma mensual.
Nota – Es un ejercicio avanzado, que es optativo y sólo debe realizarlo si

ha terminado todos los ejercicios anteriores de este módulo.
La Figura 6-3 muestra las dependencias entre la clase usada por el

programa TestBatch.
TestBatch
AccumulateSavingsBatch CustomerReport
-bank : Bank -bank : Bank
«métodos» «métodos»
+doBatch():void +generateReport():void
+setBank(bank:Bank):void +setBank(bank:Bank):void
SavingsAccount
-interestRate : double
«constructores»
+SavingsAccount(initBalance:double,
interestRate:double)
«métodos»
+accumulateInterest():void
Figura 6-3 Dependencias de clase del programa TestBatch

● “Tarea 1: Modificación de la clase SavingsAccount”
● “Tarea 2: Creación de la clase AccumulateSavingsBatch”
● “Tarea 4: Compilación de la clase TestBatch”
● “Tarea 5: Ejecución del programa TestBatch”
Preparación

ejercicio:

projects.
Tarea 1: Modificación de la clase SavingsAccount

La cuenta de ahorro (savings) obtiene intereses. El banco permite a los
clientes guardar dinero en una cuenta de ahorro que acumula intereses
mensuales aplicando la fórmula siguiente: saldo = saldo + (saldo* (tipo de
interés / 12)).
En esta tarea va a añadir el método accumulateInterest para realizar la

operación.
Tarea 2: Creación de la clase AccumulateSavingsBatch

1. Cree la clase AccumulateSavingsBatch con las características
siguientes:
Nombre de clase: AccumulateSavingsBatch
Proyecto: BankPrj
Paquete: com.mybank.batch
La clase debe cumplir la especificación definida en Figura 6-3 en la
página L6-26.
2. Añada la variable de instancia bank del tipo Bank.
3. Añada un método setBank para definir el parámetro del método en
la variable de instancia bank.
4. Añada el método doBatch siguiendo estas indicaciones:
for each Customer in the Bank do
for each Account in the Customer do
if the Account is a SavingsAccount,
then call the accumulateInterest method

En esta tarea va a copiar el archivo TestBatch.java del directorio
proyecto BankPrj.
Tarea 4: Compilación de la clase TestBatch

En esta tarea va a compilar la clase TestBatch.
Tarea 5: Ejecución del programa TestBatch

En esta tarea va a ejecutar el programa TestBatch. La salida debe ser
CUSTOMERS REPORT
================




ACCUMULATE SAVINGS BATCH EXECUTED
CUSTOMERS REPORT
================





!
?
● Experiencias
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
● Conclusiones
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
● Aplicaciones
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
Práctica 7
Conceptos avanzados sobre las clases
Objetivos
● Aplicar miembros de clase estática para resolver una decisión de
diseño
● Crear clases abstractas e interfaces, y explorar las propiedades
polimórficas de estos tipos de componentes
Práctica 7-1
2010, los derechos
Ejercicio 1: Aplicación de miembros estáticos a un diseño (nivel 1)
(nivel 1)
En este ejercicio va a aplicar miembros de clase estática para resolver una
decisión de diseño. El proyecto bancario utiliza actualmente una clase
concreta para representar el concepto de banco, que contiene el conjunto
de clientes del banco. El equipo del proyecto considera que es un diseño
arriesgado, porque se podría instanciar múltiples objetos Bank con la
posibilidad de contener diferentes conjuntos de clientes.
El equipo de diseño ha decidido convertir la clase Bank en una clase de

utilidad. Una clase de utilidad es un tipo de clase que no se instancia y
cuyos miembros son todos estáticos. La Figura 7-1 figura muestra el
nuevo diseño de la clase Bank. La tarea consiste en programar estos
cambios en la clase Bank y en todas las clases que utilizan la clase Bank.
com.mybank.domain
Bank
-customers : Customer[]
-numberOfCustomers : int
«constructores»
-Bank()
«métodos»
+addCustomer(f:String, l:String)
+getNumOfCustomers():int
+getCustomer(index:int):Customer
serves
has-a 1
Customer Account
0..*
Figura 7-1 Diagrama UML de la clase de utilidad Bank

● “Tarea 1: Modificación de la clase Bank”
● “Tarea 2: Modificación de la clase CustomerReport”
● “Tarea 3: Eliminación de la clase TestReport actual”
Preparación

ejercicio:
proyectos

projects.

2
3
Tarea 1: Modificación de la clase Bank

En esta tarea va a abrir el proyecto BankPrj del directorio projects y
a modificar la clase Bank del paquete de origen com.mybank.domain del
proyecto BankPrj. Todos los miembros (tanto variables de instancia
como métodos) deben transformarse en estáticos, como ilustra la
Figura 7-1 en la página L7-2. Además, traslade el código de inicialización
de variables original del constructor a un bloque estático o a las
declaraciones de variable estática.
Tarea 2: Modificación de la clase CustomerReport

En esta tarea va a crear el archivo fuente de la clase CustomerReport en
el paquete de origen com.mybank.report del proyecto BankPrj. La clase
CustomerReport actualizada utiliza la clase Bank como clase de utilidad.
Conceptos avanzados sobre las clases Práctica 7-3
Tarea 3: Eliminación de la clase TestReport actual
En esta tarea va a eliminar la clase TestReport actual del paquete de

proyecto BankPrj.


similar a la de pruebas anteriores, como en el ejercicio 2 de la tarea 5 de la
práctica 6 (nivel 1).
(nivel 2)

cuyos miembros son todos estáticos. La Figura 7-1 en la página L7-2 figura
muestra el nuevo diseño de la clase Bank. La tarea consiste en programar
estos cambios en la clase Bank y en todas las clases que utilizan la clase
Bank.

Preparación

ejercicio:
proyectos

projects.

2
3

En esta tarea va a modificar la clase Bank del paquete de origen
com.mybank.domain del proyecto BankPrj. Todos los miembros
(tanto variables de instancia como métodos) deben transformarse en
estáticos, como ilustra la Figura 7-1 en la página L7-2.

1. Abra el proyecto BankPrj del directorio projects si lo ha
cerrado.
2. Abra la clase Bank del paquete de origen com.mybank.domain del
proyecto BankPrj.
3. Cambie todas las variables de instancia a estáticas.
4. Traslade el código de inicialización de variables original del
constructor a un bloque estático o a las declaraciones de variable
estática.
5. Cambie el constructor para que sea privado y elimine el cuerpo del
constructor.
6. Cambie todos los métodos a estáticos.

1. Elimine la variable de instancia bank y los métodos getBank y
setBank.
2. Modifique el método generateReport para utilizar los métodos
estáticos del nuevo diseño de clase de utilidad Bank.


proyecto BankPrj.


(nivel 3)

cuyos miembros son todos estáticos. La Figura 7-1 en la página L7-2 figura
muestra el nuevo diseño de la clase Bank. La tarea consiste en programar
estos cambios en la clase Bank y en todas las clases que utilizan la clase
Bank.

Preparación

ejercicio:
proyectos

projects.

2
3

En esta tarea va a modificar la clase Bank del paquete de origen
com.mybank.domain del proyecto BankPrj. Todos los miembros
(tanto variables de instancia como métodos) deben transformarse en
estáticos, como ilustra la Figura 7-1 en la página L7-2.

1. Abra el proyecto BankPrj del directorio projects si lo ha cerrado.
2. Abra la clase Bank del paquete de origen com.mybank.domain del
proyecto BankPrj.
3. Cambie todas las variables de instancia a estáticas.
private static Customer[] customers;
private static int numberOfCustomers;
4. Traslade el código de inicialización de variables original del
constructor a un bloque estático o a las declaraciones de variable
estática.
static {
customers = new Customer[10];
numberOfCustomers = 0;
}
5. Cambie el constructor para que sea privado y elimine el cuerpo del
constructor.
private Bank() {
// este constructor no debe llamarse nunca
}
6. Cambie todos los métodos a estáticos.
public static void addCustomer(String f, String l) {
int i = numberOfCustomers++;
customers[i] = new Customer(f, l);
}
public static int getNumOfCustomers() {
return numberOfCustomers;
}
public static Customer getCustomer(int customer_index) {
return customers[customer_index];
}


1. Elimine la variable de instancia bank y los métodos getBank y
setBank.
2. Modifique el método generateReport para utilizar los métodos
estáticos del nuevo diseño de clase de utilidad Bank.
public void generateReport() {
// Imprimir encabezado del informe

System.out.println("CUSTOMERS REPORT");
System.out.println("================");
// Para cada cliente...

for ( int cust_idx = 0;
cust_idx < Bank.getNumOfCustomers();
cust_idx++ ) {
Customer customer = Bank.getCustomer(cust_idx);
// y así sucesivamente
}
}

proyecto BankPrj.


Ejercicio 2: Uso de interfaces y clases abstractas (nivel 1)
En este ejercicio va a crear clases abstractas e interfaces, y a explorar las
propiedades polimórficas de estos tipos de componentes. Creará una
jerarquía de animales que tienen como raíz la clase abstracta Animal.
Varias clases de animales implementan una interfaz llamada Pet.
La Figura 7-2 muestra el diagrama UML de las clases de animales que va
a crear.
Animal
{abstract} «interfaz»
Pet
#legs : int
«constructores» +getName():String
#Animal(legs:int) +setName(n:String):void
+play()
«métodos»
+walk():void
+eat():void
Spider Cat Fish

-name : String -name : String
«constructores» «constructores» «constructores»
+Spider() +Cat(n:String) +Fish()
«métodos» +Cat() «métodos»
+eat():void «métodos» +getName():String
+getName():String +setName(n:String):void
+setName(n:String):void +play():void
+play():void +walk():void
+eat():void +eat():void
Figura 7-2 Jerarquía de Animal y Pet

● “Tarea 1: Creación de la interfaz Pet”
● “Tarea 2: Creación de las clases de Animal”
● “Tarea 3: Creación de la clase TestAnimals”
● “Tarea 4: Compilación de la clase TestAnimals”
● “Tarea 5: Ejecución del programa TestAnimals”
Preparación

ejercicio:
proyectos
Para este ejercicio va a trabajar en el proyecto InterfaceProject del

directorio exercises/07_class2/exercise2.

2
3
Tarea 1: Creación de la interfaz Pet

1. Abra el proyecto InterfaceProject del directorio
exercises/07_class2/exercise2.
2. Cree la interfaz Pet con las características siguientes:
Nombre de clase: Pet
Proyecto: InterfaceProject
La interfaz Pet debe cumplir el diagrama UML de la Figura 7-1 en la

página L7-2.
Tarea 2: Creación de las clases de Animal
1. Cree la clase Animal con las características siguientes:
Nombre de clase: Animal
La clase Animal debe cumplir el diagrama UML de la Figura 7-1 en la

página L7-2. Los métodos action (walk y eat) imprimen una sentencia
en salida estándar que refleja el animal. Por ejemplo, el método walk de la
clase Animal podría indicar algo como This animal walks on 4 legs,
donde 4 es el valor de la variable de instancia legs.
2. Cree las clases Spider, Cat y Fish en los paquetes de origen del
proyecto InterfaceProject para respetar el diagrama UML de la
Figura 7-1 en la página L7-2.
Tarea 3: Creación de la clase TestAnimals

1. En esta tarea va a crear la clase TestAnimals con las características
siguientes:
Nombre de clase: TestAnimals
2. Añada el método main para crear y manipular instancias de las
clases antes creadas.
Empiece con:
Fish d = new Fish();
Cat c = new Cat("Fluffy");
Animal a = new Fish();
Animal e = new Spider();
Pet p = new Cat();
Experimente con:
● Llamadas a los métodos de cada objeto
● Conversión de objetos
● Uso de polimorfismo
● Uso de super para llamar a todos los métodos de superclase
Tarea 4: Compilación de la clase TestAnimals

En esta tarea va a compilar la clase TestAnimals.
Tarea 5: Ejecución del programa TestAnimals

En esta tarea va a ejecutar el programa TestAnimals.
En este ejercicio va a crear clases abstractas e interfaces, y a explorar las
propiedades polimórficas de estos tipos de componentes. Creará una
jerarquía de animales que tienen como raíz la clase abstracta Animal.
Varias clases de animales implementarán una interfaz llamada Pet.
Utilice la Figura 7-2 en la página L7-12 como referencia. Experimentará
con variaciones de estos animales, sus métodos y polimorfismo.

Preparación

ejercicio:
proyectos


2
3

página L7-2.

1. Cree la clase Animal.
a. Cree la clase Animal con las características siguientes:
b. Declare una variable de instancia con valor entero, protegida y
denominada legs, que registre el número de patas del animal.
c. Defina un constructor protegido que inicialice la variable de
instancia legs.
d. Declare un método abstracto eat.
e. Declare un método concreto walk que imprima algo sobre el
modo de caminar de los animales (incluya el número de patas).
2. Cree la clase Spider.
a. Cree la clase Spider con las características siguientes:
Nombre de clase: Spider
Amplía: Animal
b. Defina un constructor no-arg que llame al constructor de
superclase para especificar que todas las arañas tienen ocho
patas.
c. Implemente el método eat.
3. Cree la clase Cat.
a. Cree la clase Cat con las características siguientes:
Nombre de clase: Cat
Amplía: Animal
Implementa: Pet
b. Esta clase debe incluir una variable de instancia String para
almacenar el hombre de la mascota.
c. Defina un constructor que reciba un parámetro String que
especifique el nombre del gato. Este constructor también debe
llamar al constructor de superclase para especificar que todos
los gatos tienen cuatro patas.
d. Defina otro constructor que no reciba parámetros.
Este constructor debe llamar al constructor anterior
(utilizando la palabra clave this) y pasar una cadena vacía
como argumento.
e. Implemente los métodos de interfaz Pet.
f. Implemente el método eat.
4. Cree la clase Fish.
a. Cree la clase Fish con las características siguientes:
Nombre de clase: Fish
Amplía: Animal
Implementa: Pet
c. Defina un constructor no-arg que llame al constructor de
superclase para especificar que los peces no tienen patas.
d. Implemente los métodos de interfaz Pet.
e. Sobrescriba el método walk. Este método debe llamar al método
super y ambos imprimir el mensaje de que los peces no andan.

siguientes:
Empiece con:
Fish d = new Fish();
Pet p = new Cat();
Experimente con:
● Llamadas a los métodos de cada objeto
● Conversión de objetos
● Uso de polimorfismo
● Uso de super para llamar a todos los métodos de superclase


Va a crear una jerarquía de animales que tienen como raíz la clase
abstracta Animal. Varias clases de animales implementan una interfaz
llamada Pet. Utilice la Figura 7-2 en la página L7-12 como referencia.
Experimentará con variaciones de estos animales, sus métodos y
polimorfismo.

Preparación

ejercicio:
proyectos


2
3

página L7-2.
public interface Pet {
public String getName();
public void setName(String n);
public void play();
}

1. Cree la clase Animal.
a. Cree la clase Animal con las características siguientes:
a. Declare una variable de instancia con valor entero, protegida y
denominada legs, que registre el número de patas del animal.
protected int legs;
b. Defina un constructor protegido que inicialice la variable de
instancia legs.
protected Animal(int legs) {
this.legs = legs;
}
c. Declare un método abstracto eat.
public abstract void eat();
d. Declare un método concreto walk que imprima algo sobre el
modo de caminar de los animales (incluya el número de patas).
public void walk() {
System.out.println("This animal walks on " + legs + " legs.");
}
2. Cree la clase Spider.
a. Cree la clase Spider con las características siguientes:
Nombre de clase: Spider
Amplía: Animal
a. La clase Spider amplía la clase Animal.
public class Spider extends Animal {
// más código aquí
}
b. Defina un constructor no-arg que llame al constructor de
superclase para especificar que todas las arañas tienen ocho
patas.
public Spider() {
super(8);
}
c. Implemente el método eat.
public void eat() {
System.out.println("The spider eats a fly.");
}
3. Cree la clase Cat.
a. Cree la clase Cat con las características siguientes:
Nombre de clase: Cat
Amplía: Animal
Implementa: Pet
private String nombre;
c. Defina un constructor que reciba un parámetro String que
especifique el nombre del gato. Este constructor también debe
llamar al constructor de superclase para especificar que todos
los gatos tienen cuatro patas.
public Cat(String n) {
super(4);
name = n;
}
d. Defina otro constructor que no reciba parámetros.
Este constructor debe llamar al constructor anterior
(utilizando la palabra clave this) y pasar una cadena vacía
como argumento.
public Cat() {
this("");
}
e. Implemente los métodos de interfaz Pet.
public String getName() {
return name;
}
public void setName(String n) {
name = n;
}
public void play() {
System.out.println(name + " likes to play with string.");
}
public void eat() {
System.out.println("Cats like to eat spiders and mice.");
}
4. Cree la clase Fish.
a. Cree la clase Fish con las características siguientes:
Nombre de clase: Fish
Amplía: Animal
Implementa: Pet
private String nombre;
c. Defina un constructor no-arg que llame al constructor de
superclase para especificar que los peces no tienen patas.
public Fish() {
super(0); // esta línea debe ir aquí
}
d. Implemente los métodos de interfaz Pet.
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void play() {
System.out.println("Fish swim in their tanks all day.");
}
e. Sobrescriba el método walk. Este método debe llamar al método
super y ambos imprimir el mensaje de que los peces no andan.
public void walk() {
super.walk();
System.out.println("Fish, of course, can’t walk; they swim.");
}
public void eat() {
System.out.println("Fish eat pond scum.");
}

siguientes:
He aquí un ejemplo de programa de prueba:
public class TestAnimals {
Fish f = new Fish();
Pet p = new Cat();
// Demostrar distintas implementaciones de una interfaz

f.play();
c.play();
// Demostrar llamada a métodos virtuales

e.eat();
e.walk();
// Demostrar llamada a métodos super

a.walk();
}
}



!
?
● Experiencias
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
● Conclusiones
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
● Aplicaciones
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
Práctica 8
Excepciones y aserciones
Objetivos
Las personas que realicen esta práctica podrán crear una excepción de
aplicación y aplicar la regla de declarar o gestionar a las clases de cuenta.
Práctica 8-1
2010, los derechos
Ejercicio: Creación de excepciones propias (nivel 1)
En este ejercicio va a crear una excepción de descubierto denominada
OverdraftException que lanza el método withdraw de la clase
Account. En el diseño anterior, los métodos deposit y withdraw
devuelven un indicador booleano para señalar si la operación ha tenido
éxito o no. Este diseño tiene varios fallos, uno de los cuales es que el valor
de retorno false no devuelve al cliente que hace la llamada ninguna
indicación del motivo por el que la operación no ha tenido éxito. En el
nuevo diseño utilizará excepciones para indicar el fallo de la operación.
La Figura 8-1 muestra el diagrama UML de clase en este nuevo diseño.

En términos UML, la dependencia «enviar» indica que el método de la
operación de origen (el método withdraw) puede lanzar una excepción
OverdraftException.
com.mybank.domain
Account
«excepción»
#balance : double Exception
{from java.lang}
«constructores»
#Account(initBalance:double)
«constructores»
«métodos» +Exception(msg:String)
+deposit(amt:double):void «métodos»
+withdraw(amt:double):void +getMessage():String
«enviar»
«excepción»
CheckingAccount
OverdraftException
-overdraftAmount : double
-deficit : double
«constructores»
«constructores»
+CheckingAccount(initBalance:double,
overdraft:double) +OverdraftException(msg:String,
deficit:double)
+CheckingAccount(initBalance:double)
«métodos»
«métodos»
+withdraw(amt:double):boid «enviar» +getDeficit():double
Figura 8-1 El método withdraw lanza OverdraftException
● “Tarea 1: Creación de la clase OverdraftException”
● “Tarea 3: Modificación de la clase CheckingAccount”
Preparación

ejercicio:

projects.

1 directorio demos/08_except/exercise1.
2
3
Excepciones y aserciones Práctica 8-3
Tarea 1: Creación de la clase OverdraftException
En esta tarea va a crear la clase OverdraftException en el paquete de
Nombre de clase: OverdraftException
Proyecto: BankPrj
Amplía: Exception
Esta clase debe cumplir el diagrama UML de la Figura 8-1 en la

página L8-2.

En esta tarea va a modificar el archivo fuente de la clase Account en el
paquete de origen com.mybank.domain del proyecto BankPrj. Esta clase
debe cumplir el diagrama UML de la Figura 8-1 en la página L8-2.
En concreto, los métodos deposit y withdraw no deben devolver un
indicador booleano.
Tarea 3: Modificación de la clase CheckingAccount

En esta tarea va a modificar el archivo fuente de la clase
CheckingAccount del paquete de origen com.mybank.domain del
proyecto BankPrj. Esta clase debe cumplir el diagrama UML de la
Figura 8-1 en la página L8-2.

resources/08_except al paquete de origen com.mybank.test del
proyecto BankPrj.


Customer [Simms, Jane] has a checking balance of 200.0 with a 500.00
Checking Acct [Jane Simms] : withdraw 150.00
Checking Acct [Jane Simms] : deposit 22.50
Exception: Insufficient funds for overdraft protection Deficit: 470.0
Customer [Simms, Jane] has a checking balance of 0.0
Customer [Bryant, Owen] has a savings balance of 200.0

Savings Acct [Owen Bryant] : withdraw 100.00
Savings Acct [Owen Bryant] : deposit 25.00
Savings Acct [Owen Bryant] : withdraw 175.00
Exception: Insufficient funds Deficit: 50.0
Customer [Bryant, Owen] has a savings balance of 125.0
Account.

Preparación

ejercicio:

projects.

2
3
1. Cree la clase OverdraftException en el paquete de origen
com.mybank.domain del proyecto BankPrj con las características
siguientes:
Proyecto: BankPrj
Amplía: Exception
2. Añada una variable de instancia privada llamada deficit que
mantenga double.
3. Añada un constructor público que reciba dos argumentos: mensaje y
deficit. El parámetro de mensaje debe pasarse al constructor de
superclase. El parámetro deficit inicializa la variable de instancia
deficit.
4. Añada un accedente público llamado getDeficit.

paquete de origen com.mybank.domain del proyecto BankPrj.

1. Modifique el método deposit para que no devuelva un valor
(es decir, void). Esta operación nunca debe fallar, así que no necesita
lanzar excepciones.
2. Modifique el método withdraw para que no devuelva
un valor (es decir, void). Declare que este método lanza
OverdraftException. Modifique el código para lanzar una
nueva excepción que especifique Insufficient funds (fondos
insuficientes) y el déficit (la cantidad solicitada menos el saldo
actual).
En esta tarea va a modificar el archivo fuente de la clase
CheckingAccount del paquete de origen com.mybank.domain
del proyecto BankPrj. Modifique el método withdraw para que no
devuelva un valor (es decir, void). Declare que este método lanza
OverdraftException. Modifique el código para lanzar una excepción
cuando la cantidad de overdraftProtection no baste para cubrir el
déficit; utilice el mensaje Insufficient funds for overdraft
protection para esta excepción.


proyecto BankPrj.


En esta tarea va a ejecutar el programa TestBanking.
La salida debe ser similar a la que aparece en la página L8-5.
Account.

Preparación

ejercicio:

projects.

2
3
1. Cree la clase OverdraftException en el paquete de origen
com.mybank.domain del proyecto BankPrj con las características
siguientes:
Proyecto: BankPrj
Amplía: Exception
public class OverdraftException extends Exception {
}
2. Añada una variable de instancia privada llamada deficit que
mantenga double.
private final double deficit;
3. Añada un constructor público que reciba dos argumentos: mensaje y
deficit. El parámetro de mensaje debe pasarse al constructor de
superclase. El parámetro deficit inicializa la variable de instancia
deficit.
public OverdraftException(String msg, double deficit) {
super(msg);
this.deficit = deficit;
}
4. Añada un accedente público llamado getDeficit.
public double getDeficit() {
return deficit;
}

1. Modifique el método deposit para que no devuelva un valor
(es decir, void). Esta operación nunca debe fallar, así que no necesita
lanzar excepciones.
public void deposit(double amt) {
}
2. Modifique el método withdraw para que no devuelva un
valor (es decir, void). Declare que este método lanza
OverdraftException. Modifique el código para lanzar
una nueva excepción que especifique Insufficient funds
(fondos insuficientes) y el déficit (la cantidad solicitada menos el
saldo actual).
public void withdraw(double amt) throws OverdraftException {
} else {
throw new OverdraftException("Insufficient funds", amt - balance);
}
}

En un editor de texto, modifique el archivo fuente de la clase
CheckingAccount en el directorio src/com/mybank/domain/. Esta clase
Modifique el método withdraw para que no devuelva un valor (es decir,

void). Declare que este método lanza OverdraftException. Modifique
el código para lanzar una excepción si es necesario. Deben manejarse dos
casos. Primero, hay un déficit sin protección de descubierto; utilice el
mensaje No overdraft protection para esta excepción. Segundo, la
cantidad de overdraftProtection no basta para cubrir el déficit; utilice
el mensaje Insufficient funds for overdraft protection para esta
excepción.
public void withdraw(double amount) throws OverdraftException {
if ( balance < amount ) {
double overdraftNeeded = amount - balance;
if ( overdraftAmount < overdraftNeeded ) {
throw new OverdraftException("Insufficient funds for overdraft
protection",
overdraftNeeded);
} else {
balance = 0.0;
overdraftAmount -= overdraftNeeded;
}
} else {
balance = balance - amount;
}
}


proyecto BankPrj.


En esta tarea va a ejecutar el programa TestBanking.
La salida debe ser similar a la que aparece en la página L8-5.

!
?
● Experiencias
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
● Conclusiones
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
● Aplicaciones
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
Práctica 9
Uso de colecciones y tipos genéricos
Objetivos
● Usar una colección genérica para administrar una asociación de uno
a varios
Práctica 9-1
2010, los derechos
Ejercicio 1: Uso de colecciones para representar asociaciones (nivel 1)
Ejercicio 1: Uso de colecciones para representar
asociaciones (nivel 1)
En este ejercicio va a usar colecciones genéricas para representar
asociaciones de clases en el modelo de dominio del proyecto bancario.
En el diseño anterior se usaron matrices para implementar la

multiplicidad en las relaciones entre el banco sus clientes, y entre los
clientes y sus cuentas. Este diseño tiene varias limitaciones importantes,
la principal es que la matriz, una vez creada, tiene un tamaño fijo.
API Collections se creó para solucionar ésta y otras limitaciones.
La Figura 9-1 muestra el modelo de dominio del proyecto bancario con las
asociaciones de clases: un banco presta servicio a muchos clientes y un
cliente tiene muchas cuentas. La Figura 9-1 también muestra el diseño
detallado de las clases Bank y Customer que utilizan una lista List
genérica para mantener estos vínculos.
com.mybank.domain
serves 0..* has-a 0..*

Bank Customer Account
Bank Customer
-customers : List<Customer> -accounts : List<Account>
-firstName : String
«constructores»
-lastName : String
-Bank()
«métodos» «constructores»
+addCustomer(f:String, l:String) +Customer(f:String, l:String)
+getNumOfCustomers():int «métodos»
+getCustomer(index:int):Customer +addAccount(acct:Account)
+getNumOfAccounts():int
+getAccount(index:int):Account
Figura 9-1 Modelo de dominio del proyecto bancario con detalles de las
clases Bank y Customer
Preparación

ejercicio:

projects.

1 directorio demos/09_collections/exercise.
2
3

En esta tarea va a modificar el archivo fuente de la clase Bank en el

En esta tarea va a modificar el archivo fuente de la clase Customer del
Uso de colecciones y tipos genéricos Práctica 9-3

CUSTOMERS REPORT
================





Preparación
No se precisa preparación para este ejercicio. Referencia a herramientas: Referencias a herramientas usadas en este
ejercicio:

projects.

2
3

1. Modifique la declaración de la variable de instancia customers para
que sea del tipo List<Customer>, y deseche la variable de instancia
numberOfCustomers.
2. Modifique el bloque estático para inicializar la variable de instancia
customers de manera que sea un nuevo objeto ArrayList.
3. Modifique el método addCustomer para que utilice el método add.
4. Modifique el método getCustomer para que utilice el método get.
5. Modifique el método getNumOfCustomers para que utilice el
método size.


1. Modifique la declaración de la variable de instancia accounts para
que sea del tipo List<Account>, y deseche la variable de instancia
numberOfAccounts.
2. Modifique el constructor para inicializar la variable de instancia
accounts de manera que sea un nuevo objeto ArrayList.
3. Modifique el método addAccount para que utilice el método add.
4. Modifique el método getAccount para que utilice el método get.
método size.

CUSTOMERS REPORT
================





Preparación

ejercicio:

projects.

2
3

1. Añada las dos sentencias de importación para incluir las clases de
colecciones que utilizará en la clase Bank.
import java.util.List;
import java.util.ArrayList;
2. Modifique la declaración de la variable de instancia customers para
que sea del tipo List<Customer>, y deseche la variable de instancia
numberOfCustomers.
private static List<Customer> customers;
3. Modifique el bloque estático para inicializar la variable de instancia
customers de manera que sea un nuevo objeto ArrayList.
static {
customers = new ArrayList<Customer>(10);
}
4. Modifique el método addCustomer para que utilice el método add.
public static void addCustomer(String f, String l) {
customers.add(new Customer(f, l));
}
5. Modifique el método getCustomer para que utilice el método get.
public static Customer getCustomer(int customer_index) {
return customers.get(customer_index);
}
método size.
public static int getNumOfCustomers() {
return customers.size();
}

1. Añada las dos sentencias de importación para incluir las clases de
colecciones que utilizará en la clase Bank.
import java.util.List;
import java.util.ArrayList;
2. Modifique la declaración de la variable de instancia accounts para
que sea del tipo List<Account>, y deseche la variable de instancia
numberOfAccounts.
private List<Account> accounts;
3. Modifique el constructor para inicializar la variable de instancia
accounts de manera que sea un nuevo objeto ArrayList.
firstName = f;
lastName = l;
// inicializar variable de instancia accounts
accounts = new ArrayList<Account>(10);
}
4. Modifique el método addAccount para que utilice el método add.
public void addAccount(Account acct) {
accounts.add(acct);
}
5. Modifique el método getAccount para que utilice el método get.
public Account getAccount(int account_index) {
return accounts.get(account_index);
}
método size.
public int getNumOfAccounts() {
return accounts.size();
}

CUSTOMERS REPORT
================





!
?
● Experiencias
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
● Conclusiones
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
● Aplicaciones
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
Práctica 10
Principios básicos de E/S
No hay ejercicios para este módulo.
Práctica 10-1
2010, los derechos
Práctica 11
E/S de consola y E/S de archivos
Objetivos
● Leer un archivo de datos mediante la API Scanner
● Usar una colección genérica para administrar una asociación de uno
a varios
Práctica 11-1
2010, los derechos
Ejercicio 1: Lectura de un archivo de datos (nivel 1)
En este ejercicio va a crear una clase que lee datos de cliente y de cuenta
en un archivo plano.
La Figura 11-1 muestra el diagrama UML de la clase DataSource que va a

crear para el programa TestReport.
TestReport
DataSource CustomerReport
{from com.mybank.data}
-dataFile : Archivo
«constructores»
+DataSource(dataFilePath:String)
«excepción»
«métodos» IOException
«enviar»
+loadData():void {from java.io}
«leer»
test.dat
Figura 11-1 La clase DataSource carga datos de cliente de un archivo

plano
El Código 11-1 muestra un ejemplo del formato del archivo de datos de

cliente. La primera línea contiene un valor entero, que determina el
número de clientes que hay en el archivo de datos. Un registro de cliente
contiene el nombre, el apellido y el número de cuentas, separados por
caracteres de tabulación. Cada registro de cuenta contiene un código de
un solo carácter que determina el tipo de cuenta y los datos de dicho
registro.
Código 11-1 Formato de datos del archivo

<number-of-customers>
<first-name> <last-name> <number-of-accounts>

<account-type-code> <datum1> <datum2>
El Código 11-2 muestra un ejemplo del formato del archivo de datos
de cliente. Este archivo de datos contiene cuatro registros de cliente.
El primero corresponde a Jane Simms, que tiene dos cuentas bancarias.
La segunda es una cuenta de ahorro, con un saldo inicial de 500.00 y un
tipo de interés del 5% (0.05). La segunda es una cuenta corriente, con un
saldo inicial de 200.00 y una protección de descubierto de 400.00.
Código 11-2 Ejemplo de archivo de datos de prueba

4
Jane Simms 2
S 500.00 0.05
C 200.00 400.00
Owen Bryant 1
C 200.00 0.00
Tim Soley 2
S 1500.00 0.05
C 200.00 0.00
Maria Soley 1
S 150.00 0.05

● “Tarea 1: Creación de un directorio data”
● “Tarea 2: Copia del archivo de recursos”
● “Tarea 3: Creación de la clase DataSource”
● “Tarea 4: Eliminación de clases innecesarias”
● “Tarea 7: Ejecución del proyecto BankPrj”
E/S de consola y E/S de archivos Práctica 11-3
Preparación

ejercicio:
● Desarrollo en Java: Otros archivos: Creación de carpetas
● Desarrollo en Java: Proyectos de aplicaciones de Java: Definición de
argumentos
● Desarrollo en Java: Proyectos de aplicaciones de Java: Configuración
de la clase principal
● Desarrollo en Java: Proyectos de aplicaciones de Java: Ejecución de
proyectos

projects.

1 directorio demos/11_fileio/exercise.
2
3
Tarea 1: Creación de un directorio data
Referencia a herramientas: Desarrollo en Java: Otros archivos: Creación

de carpetas
En este proyecto creará un directorio data en el proyecto BankPrj.
Tarea 2: Copia del archivo de recursos
En esta tarea va a copiar el archivo test.dat del directorio
resources/11_fileio al directorio data.
Tarea 3: Creación de la clase DataSource

En esta tarea va a crear la clase DataSource en el paquete de origen
com.mybank.data del proyecto BankPrj con las características
siguientes:
Nombre de clase: DataSource
Proyecto: BankPrj
Paquete: com.mybank.data
Esta clase debe cumplir el diagrama UML de la Figura 11-1 en la

página L11-2. El método loadData debe utilizar los métodos de
utilidad de Bank (addCustomer y getCustomer) para rellenar los clientes
incluidos en el archivo de datos. Además, la clase Customer tiene el
método addAccount para agregar las cuentas del archivo de datos.
Tarea 4: Eliminación de clases innecesarias

En esta tarea va a eliminar las siguientes clases de Java que ya no se
utilizan:
TestReport
TestAccount
TestAccount2
TestBatch
TestBanking

En esta tarea va a copiar la clase TestReport del directorio
resources/11_fileio al paquete de origen com.mybank.test
En esta tarea va a compilar la clase TestReport. Si hay errores de
compilación, realice los cambios necesarios en la clase y recompílela.
Tarea 7: Ejecución del proyecto BankPrj

En esta tarea va a definir la clase TestReport como clase principal del
proyecto BankPrj y a ejecutar el proyecto BankPrj con un argumento
data/test.dat.

de Java: Definición de argumentos
1. Defina el argumento del proyecto BankPrj en data/test.dat.

de Java: Configuración de la clase principal
2. Defina la clase principal del proyecto BankPrj en
com.mybank.test.TestReport.

de Java: Ejecución de proyectos
3. Ejecute el proyecto BankPrj. La salida debe ser similar a la
siguiente:
Lectura del archivo de datos: ../data/test.dat
CUSTOMERS REPORT
================





Preparación

ejercicio:
argumentos
proyectos
projects.

2
3

En este proyecto creará un directorio data en el proyecto BankPrj.


1. Cree la clase DataSource en el paquete de origen
siguientes:
Proyecto: BankPrj
2. Añada la variable de instancia dataFile a la clase DataSource.
3. Añada un constructor público que reciba un argumento de cadena
dataFilePath e inicialice la variable de instancia dataFile.
4. Añada un método público, loadData, que rellene los objetos de
cliente de Bank y los objetos de cuenta de cada cliente. Este es el
seudocódigo para este método:
read <number-of-customers>
for each customer record
read <first-name> and <last-name>
add customer to Bank
read <number-of-accounts>
for each account
read <account-type-code>
switch on <account-type-code>
Savings:
read <initial-balance> and <interest-rate)
create account and add account to customer
Checking:
read <initial-balance> and <overdraft-amount)
create account and add account to customer

En esta tarea va a eliminar las siguientes clases de Java que ya no se
utilizan:
TestReport
TestAccount
TestAccount2
TestBatch
TestBanking


data/test.dat.



siguiente:
CUSTOMERS REPORT
================





Preparación

ejercicio:
argumentos
proyectos
projects.

2
3

Cree un directorio data en el proyecto BankPrj.
1. Con el proyecto BankPrj abierto, haga clic en la ficha Files.
2. Haga clic con el botón secundario en el árbol de archivos BankPrj.
3. Seleccione New -> Other.
4. Seleccione Other en el panel Categories.
5. Seleccione Folder en el panel File Types.
6. Haga clic en Next.
7. Introduzca datos como nombre de carpeta.
8. Haga clic en Finish.

1. Cree la clase DataSource en el paquete de origen
siguientes:
Proyecto: BankPrj
package com.mybank.data;
// insertar aquí sentencias de importación
public class DataSource {
}
2. Añada una sentencia de importación para importar los nombres de
clase necesarios:
import com.mybank.domain.*;
import java.io.File;
import java.io.IOException;
import java.util.Scanner;
3. Añada la variable de instancia dataFile a la clase DataSource.
private File dataFile;
4. Añada un constructor público que reciba un argumento de cadena
dataFilePath e inicialice la variable de instancia dataFile.
public DataSource(String dataFilePath) {
this.dataFile = new File(dataFilePath);
}
5. Añada un método público, loadData, que rellene los objetos de
cliente de Bank y los objetos de cuenta de cada cliente, como sigue:
public void loadData() throws IOException {
// Variables de fuente de datos
Scanner input = new Scanner(dataFile);
// Variables de dominio
Customer customer;
int numOfCustomers = input.nextInt();
for ( int idx = 0; idx < numOfCustomers; idx++ ) {
// Crear objeto de cliente
String firstName = input.next();
String lastName = input.next();
Bank.addCustomer(firstName, lastName);
customer = Bank.getCustomer(idx);
// Crear cuentas de cliente
int numOfAccounts = input.nextInt();
while ( numOfAccounts-- > 0 ) {
// Crear un tipo de cuenta específico
char accountType = input.next().charAt(0);
switch ( accountType ) {
// Cuenta de ahorro
case ’S’: {
float initBalance = input.nextFloat();
float interestRate = input.nextFloat();
customer.addAccount(new SavingsAccount(initBalance,
interestRate));
break;
}
// Checking account
case ’C’: {
float initBalance = input.nextFloat();
float overdraftProtection = input.nextFloat();
customer.addAccount(new CheckingAccount(initBalance,
overdraftProtection));
break;
}
} // FIN de cambio
} // FIN de bucle de creación de cuentas
} // FIN de bucle de creación de clientes
}
En esta tarea va a eliminar las siguientes clases de Java que ya no se utilizan:
TestReport
TestAccount
TestAccount2
TestBatch
TestBanking



data/test.dat.



siguiente:
CUSTOMERS REPORT
================





!
?
● Experiencias
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
● Conclusiones
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
● Aplicaciones
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
Práctica 12
Creación de interfaces gráficas con la API Swing
Objetivos
● Crear una interfaz gráfica de usuario (GUI) para el proyecto
ChatRoom
● (Opcional ) Crear una interfaz gráfica de usuario (GUI) para el
proyecto bancario
Práctica 12-1
2010, los derechos
Ejercicio 1: Creación de la GUI ChatClient - Parte 1 (nivel 1)
(nivel 1)
En este ejercicio creará una GUI para una aplicación de charla virtual
llamada chat room. Utilizará un diseño complejo para colocar
correctamente en el marco diversos componentes de la GUI.
La Figura 12-1 muestra el diseño que debe intentar conseguir para la GUI.
Componente JTextArea Componente Button Send
Componente JTextField Componente Button Quit

Figura 12-1 Diseño de GUI para la aplicación ChatClient
Como puede verse en la Figura 12-1, esta GUI consta de cuatro

componentes. El componente principal es el área de texto JTextArea.
El componente inferior es un campo de texto JTextField. En el lado
derecho hay dos componentes de botón Button.

● “Tarea 1: Creación de la clase ChatClient”
● “Tarea 2: Compilación de la clase ChatClient”
● “Tarea 3: Ejecución del programa ChatClient”
● “Tarea 3: Terminación del programa ChatClient en ejecución”
Preparación

ejercicio:
proyectos
● Desarrollo en Java: Clases de Java: Terminación de procesos en
ejecución
Con este ejercicio, primero creará el proyecto ChatRoomPrj en el

directorio projects y después trabajará en dicho proyecto durante todos
los demás ejercicios que forman parte del proyecto ChatRoomPrj.

1 directorio demos/12_gui/exercise1.
2
3
Tarea 1: Creación de la clase ChatClient

En esta tarea va a crear la clase ChatClient en el paquete de origen del
proyecto ChatRoomPrj para implementar el diseño de GUI de la
Figura 12-1 en la página 12-2.

1. Cree el proyecto de aplicación de Java ChatRoomPrj con las
Nombre de proyecto: ChatRoomPrj
Carpeta del proyecto: projects/ChatRoomPrj
Creación de interfaces gráficas con la API Swing Práctica 12-3
2. Cree la clase ChatClient en el paquete de origen del proyecto
ChatRoomPrj con las características siguientes:
Nombre de clase: ChatClient
Proyecto: ChatRoomPrj
La clase ChatClient debe implementar el diseño de la GUI de la

Tarea 2: Compilación de la clase ChatClient

En esta tarea va a compilar la clase ChatClient.
Tarea 3: Ejecución del programa ChatClient

En esta tarea va a ejecutar el programa ChatClient. Debe ver la GUI
mostrada en la Figura 12-1 en la página 12-2. Si el diseño de la GUI no es
idéntico al de la figura, edite el código para que el diseño coincida
exactamente con esta figura.
Tarea 3: Terminación del programa ChatClient en

ejecución

Terminación de procesos en ejecución
En esta tarea va a terminar el programa ChatClient en ejecución.
(nivel 2)
llamada chat room. Utilizará un diseño complejo para colocar correctamente
en el marco diversos componentes de la GUI.

Preparación

ejercicio:
proyectos
ejecución


2
3

2. Cree la clase ChatClient con las características siguientes:
3. Añada cuatro variables de instancia a la clase ChatClient para
alojar los componentes de la GUI.
4. Añada un constructor público que inicialice cada una de las cuatro
variables de instancia de componente de la GUI: El área de texto
debe tener 10 filas de alto y 50 columnas de ancho; el campo de texto
debe tener 50 columnas de ancho; el botón de envío debe mostrar la
palabra Send en la pantalla, y el botón de salida debe mostrar la
palabra Quit.
5. Cree un método launchFrame que construya el diseño de los
componentes. No dude en utilizar paneles anidados y cualquier
administrador de diseño que le ayude a crear el diseño de la GUI
antes ilustrado.
6. Cree el método main. Este método instancia un nuevo objeto
ChatClient y después llama al método launchFrame.

mostrada en la Figura 12-1 en la página 12-2. Si el diseño de la GUI no es

ejecución

(nivel 3)
llamada chat room. Utilizará un diseño complejo para colocar correctamente
en el marco diversos componentes de la GUI.

Preparación

ejercicio:
proyectos
ejecución


2
3

2. Cree la clase ChatClient con las características siguientes:
3. Importe los paquetes java.awt y javax.swing.
import java.awt.*;
import javax.swing.*;
public class ChatClient {
}
4. Añada cuatro variables de instancia a la clase ChatClient para
alojar los componentes de la GUI.
private JTextArea output;
private JTextField input;
private JButton sendButton;
private JButton quitButton;
5. Añada un constructor público que inicialice cada una de las cuatro
variables de instancia de componente de la GUI: El área de texto
debe tener 10 filas de alto y 50 columnas de ancho; el campo de texto
debe tener 50 columnas de ancho; el botón de envío debe mostrar la
palabra Send en la pantalla, y el botón de salida debe mostrar la
palabra Quit.
public ChatClient() {
output = new JTextArea(10,50);
input = new JTextField(50);
sendButton = new JButton("Send");
quitButton = new JButton("Quit");
}
6. Cree un método launchFrame que construya el diseño de los
componentes. No dude en utilizar paneles anidados y cualquier
administrador de diseño que le ayude a crear el diseño de la GUI
antes ilustrado.
public void launchFrame() {
JFrame frame = new JFrame("Chat Room");
// Usar diseño de borde para el marco

frame.setLayout(new BorderLayout());
frame.add(output, BorderLayout.WEST);
frame.add(input, BorderLayout.SOUTH);
// Crear panel de botones

JPanel p1 = new JPanel();
p1.setLayout(new GridLayout(2,1));
p1.add(sendButton);
p1.add(quitButton);
// Agregar panel de botones en el centro

frame.add(p1, BorderLayout.CENTER);
frame.pack();
frame.setVisible(true);
}
7. Cree el método main. Este método instancia un nuevo objeto
ChatClient y después llama al método launchFrame.
ChatClient c = new ChatClient();
c.launchFrame();
}

mostrada en la Figura 12-1 en la página 12-2. Si el diseño de la GUI no
es idéntico al de la figura, edite el código para que el diseño coincida

ejecución

Ejercicio 2: Creación de la GUI Bank ATM - Parte 1 (avanzado)
(avanzado)
En este ejercicio va a crear una GUI de cajero automático (ATM) para el
proyecto bancario. Utilizará un diseño complejo para colocar
correctamente en el marco diversos componentes de la GUI.

ha terminado el ejercicio anterior de este módulo.
Panel de botones de acción Componente JTextArea de salida
Componente JTextField de entrada de datos

Panel de teclado numérico Componente JTextField de mensajes
Figura 12-2 Diseño de GUI para el proyecto bancario

● “Tarea 1: Copia de la clase ATMClient”
● “Tarea 2: Modificación de la clase ATMClient”
● “Tarea 3: Compilación de la clase ATMClient”
● “Tarea 4: Ejecución del programa ATMClient”
Preparación

ejercicio:
proyectos

projects.

2
3
Tarea 1: Copia de la clase ATMClient

1. Cree el paquete de origen com.mybank.gui en el proyecto BankPrj.
2. Copie el archivo de plantilla ATMClient.java del directorio
resources/12_gui al paquete de origen com.mybank.gui del
proyecto BankPrj. Este código de plantilla proporciona el método
main, que inicializa un conjunto de clientes bancarios y después
inicia la GUI ATM.
Tarea 2: Modificación de la clase ATMClient
En esta tarea va a modificar la clase ATMClient para implementar la
pantalla de la GUI ATM, ilustrada en la Figura 12-2 en la página 12-12.
Los componentes de la GUI deben tener las características siguientes:
● El campo de texto de mensajes debe tener 75 caracteres de ancho
(denominado columnas en la documentación de la API) y ser de sólo
lectura, lo que significa que el usuario no puede escribir en el campo.
● El campo de texto de entrada de datos debe tener 10 caracteres
de ancho y ser de sólo lectura. Los botones del teclado numérico
servirán al usuario para introducir los datos que aparecerán en el
campo de entrada de datos. Esta acción se codificará en el próximo
módulo.
● El área de salida de texto debe tener 75 caracteres de ancho y 10 de
alto (denominado filas en la documentación de la API) y ser de sólo
lectura.
Nota – En este ejercicio se limitará a crear el diseño de la pantalla del

cajero automático. En el módulo siguiente creará el código mediante el
cual los botones responden a las acciones de los usuarios.
Tarea 3: Compilación de la clase ATMClient

En esta tarea va a compilar la clase ATMClient.
Tarea 4: Ejecución del programa ATMClient

1. Defina la clase principal del proyecto BankPrj en ATMClient.
2. Ejecute el proyecto BankPrj. Debe ver la GUI mostrada en la
Sugerencias
Estas indicaciones pueden ayudarle a resolver el ejercicio.
● Para que un componente sea de sólo lectura, use el método
setEnabled(false).
● Puede utilizar un diseño de cuadrícula para crear un diseño vertical
incluyendo un 1 en los parámetros rows del constructor
GridLayout(int rows, int columns).
● Puede utilizar un diseño de cuadrícula para crear un diseño
horizontal incluyendo un 1 en los parámetros columns del
constructor GridLayout(int columns, int columns).

!
?
● Experiencias
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
● Conclusiones
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
● Aplicaciones
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
Práctica 13
Control de los eventos generados por la
interfaz gráfica
Objetivos
● Crear los controladores de eventos de la interfaz gráfica (GUI) para
el proyecto ChatRoom
● (Opcional) Crear los controladores de eventos de la interfaz gráfica
para el proyecto bancario
Práctica 13-1
2010, los derechos
(nivel 1)
En este ejercicio implementará los controladores de eventos básicos para
la aplicación chat room. En esta fase de desarrollo de la GUI ChatClient
debe crear los siguientes receptores de eventos:
● Un receptor ActionListener que copie el texto del campo de
introducción de texto en el área de salida de texto cuando se pulse
el botón Send.
● Un receptor ActionListener que copie el texto del campo de
introducción de texto en el área de salida de texto cuando se pulse
el botón Intro en el campo de introducción de texto.
● Un receptor ActionListener que cierre el programa cuando se
pulse el botón Quit. (Sugerencia: use System.exit(0).)
● Un receptor WindowListener que cierre el programa cuando se
pulse el objeto de cierre en el marco.

● “Tarea 1: Modificación de la clase ChatClient”
Preparación

ejercicio:
Para este ejercicio va a trabajar en el proyecto ChatRoomPrj del

directorio projects.

1 directorio demos/13_events/exercise1.
2
3
Tarea 1: Modificación de la clase ChatClient
En esta tarea va a modificar la clase ChatClient del paquete de origen
del proyecto ChatRoomPrj. Esta clase debe implementar los receptores
de eventos indicados en la introducción a este ejercicio.


En esta tarea va a ejecutar el programa ChatClient. Pruebe el
comportamiento de los receptores de eventos que añada.
Sugerencias
Siga estas indicaciones en este ejercicio:
● Los receptores (clases internas) deben acceder a las variables de
instancia de la clase que los contiene para hacer referencia a
componentes como el área de salida de texto y el campo de
introducción de texto. Recuerde que en la práctica anterior convirtió
los componentes en variables de instancia.
● No olvide importar el paquete java.awt.event.
● Para obtener el texto de un área JTextArea o un campo
JTextField, puede utilizar el método getText; para definir el texto,
use el método setText o append.
Control de los eventos generados por la interfaz gráfica Práctica 13-3
(nivel 2)
debe crear los receptores de eventos indicados en el ‘‘Ejercicio 1: Creación
de la GUI ChatClient - Parte 2 (nivel 1)’’ en la página L13-2:

Preparación

ejercicio:


2
3
de eventos indicados en la introducción al ‘‘Ejercicio 1: Creación de la GUI
ChatClient - Parte 2 (nivel 1)’’ en la página L13-2.

1. Importe el paquete java.awt.event.
2. Añada el receptor ActionListener para el botón Send. Este receptor
debe extraer el texto del campo de texto y mostrar dicho texto en el
área de texto. Utilice una clase interna para este receptor.
3. Añada el receptor ActionListener para el campo de texto.
Puede usar el mismo receptor que en el paso 2.
4. Añada el método WindowListener al marco de la GUI. Este receptor
debe cerrar el programa ChatClient. Utilice una clase interna para
este receptor.
5. Añada el receptor ActionListener para el botón Quit. Este receptor
debe cerrar el programa ChatClient. Utilice una clase interna
anónima para este receptor.


(nivel 3)
debe crear los receptores de eventos indicados en el ‘‘Ejercicio 1: Creación
de la GUI ChatClient - Parte 2 (nivel 1)’’ en la página L13-2:

Preparación

ejercicio:


2
3
de eventos indicados en la introducción al ‘‘Ejercicio 1: Creación de la GUI
ChatClient - Parte 2 (nivel 1)’’ en la página L13-2.
1. Importe el paquete java.awt.event.
import java.awt.event.*;
// su código aquí
}
2. Añada el receptor ActionListener para el botón Send. Este receptor
debe extraer el texto del campo de texto y mostrar dicho texto en el
área de texto. Utilice una clase interna para este receptor.
private void launchFrame() {
// aquí código de inicialización de componente de GUI
sendButton.addActionListener(new SendHandler());
// más código
}
private class SendHandler implements ActionListener {

public void actionPerformed(ActionEvent e) {
String text = input.getText();
output.setText(output.getText()+text+"\n");
input.setText("");
}
}
3. Añada el receptor ActionListener para el campo de texto.
Puede usar el mismo receptor que en el paso 2.
input.addActionListener(new SendHandler());
// más código
}
En esta solución se ha reutilizado la clase interna SendHandler
para eliminar código redundante.
4. Añada el método WindowListener al marco de la GUI. Este receptor
debe cerrar el programa ChatClient. Utilice una clase interna para
este receptor.
frame.addWindowListener(new CloseHandler());
// más código
}
private class CloseHandler extends WindowAdapter {

public void windowClosing(WindowEvent e) {
System.exit(0);
}
}
5. Añada el receptor ActionListener para el botón Quit. Este receptor
debe cerrar el programa ChatClient. Utilice una clase interna
anónima para este receptor.
quitButton.addActionListener(new ActionListener() {
System.exit(0);
}
});
// más código
}
En esta solución no se ha reutilizado el receptor CloseHandler,
porque el botón Quit necesita un receptor ActionListener en lugar
de WindowListener. ¿Cómo se podría responder a ambos receptores
con la clase CloseHandler?


(avanzado)
En este ejercicio va a modificar la clase ATMClient del proyecto
BankPrj agregando las funciones de control de eventos necesarias.

ha terminado el ejercicio anterior de este módulo.
El cajero automático simulado debe comportarse así:

1. Aparece la pantalla del cajero.
En esta fase, los botones de acción deben estar deshabilitados y el
área de salida de texto debe mostrar el texto siguiente: Enter your
customer ID into the key pad and press the ENTER button
(Introduzca su ID de cliente con el teclado y pulse el
botón Intro).
2. El usuario introduce el ID con los botones numéricos. Cada número
aparece en el campo de texto de entrada de datos.
Cuando se selecciona el botón Intro, la aplicación recupera el objeto
de cliente especificado y presenta el texto siguiente en el área de
salida de texto: Welcome FIRST-NAME LAST-NAME (Bienvenido,
nombre apellido) si se ha encontrado el cliente, de lo contrario
muestra: Customer ID was not found (ID de cliente no
encontrado). Por último, si se ha encontrado el cliente, se habilitan
los botones de acción.
3. El usuario selecciona uno de los botones de acción.
Si la acción es un ingreso o un reembolso, se pide al usuario que
especifique la cantidad. El usuario puede introducir la cantidad con
los botones del teclado numérico, que volverán a mostrar cifras en el
campo de entrada de datos. Cuando se selecciona el botón Intro, el
programa ejecuta la acción con la cantidad introducida en el campo
de entrada de texto. Por último, el resulto de la operación debe
aparecer en el área de salida de texto. Al final de la operación, la GUI
debe volver a iniciar el ciclo de funcionamiento del cajero.

● “Tarea 1: Modificación de la clase ATMClient”
● “Tarea 2: Compilación de la clase ATMClient”
Preparación

ejercicio:
proyectos

projects.

2
3
Tarea 1: Modificación de la clase ATMClient

En esta tarea va a modificar la clase ATMClient del paquete de origen del
proyecto BankPrj. Esta clase debe basarse en los receptores de eventos
necesarios para implementar el comportamiento adecuado.
Tarea 2: Compilación de la clase ATMClient

En esta tarea va a compilar la clase ATMClient.

En esta tarea va a ejecutar el proyecto BankPrj.
A continuación se muestra un ejemplo de transacción en cajero
automático para Owen Bryant:
Enter your customer ID into the key pad and press the ENTER button
(Introduzca su ID de cliente con el teclado y pulse el botón Intro).
Welcome Owen Bryant
Your account balance is: 200.0

Enter the amount to deposit into the key pad and press the ENTER button.
Your deposit of 100.0 was successful.
Enter the amount to withdraw into the key pad and press the ENTER button.
Your withdrawal of 250.0 was successful.

!
?
● Experiencias
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
● Conclusiones
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
● Aplicaciones
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
Práctica 14
Aplicaciones basadas en la interfaz gráfica
Objetivos
Las personas que realicen la práctica aprenderán a agregar menús a la
GUI del proyecto ChatRoom.
Práctica 14-1
2010, los derechos
Ejercicio: Creación de la GUI ChatClient - Parte 3 (nivel 1)
Ejercicio: Creación de la GUI ChatClient - Parte 3
(nivel 1)
En este ejercicio ampliará la GUI para una aplicación de charla virtual
llamada chat room. La GUI de ChatClient se completa con un
componente JComboBox, otro JScrollPane y dos menús.
Figura 14-1 Diseño de GUI para la aplicación ChatClient
Debe añadir las cuatro características siguientes a la GUI:

● Añada el componente JComboBox de nombre de usuario bajo los
botones Send y Quit. Este componente le permite seleccionar un
nombre que se envía con cada línea de charla a la que se acceda.
Ha de modificar los receptores del botón Send y JTextField para
incluir el nombre de usuario en el componente de salida JTextArea.
Añada varias opciones de nombre de usuario, incluido su nombre
completo y algunos seudónimos, como 1337dud3 o Java Geek.
● Incluya el componente JTextArea en un componente JScrollPane.
Añada una barra de desplazamiento vertical, pero ninguna
horizontal. Defina el desplazamiento automático del texto a la parte
inferior del área JTextArea cuando el usuario introduzca texto en la
ventana de charla de texto.
● Añada el menú File. Este menú debe incluir un menú Quit que cierre
el programa.
● Añada el menú Help. Este menú debe incluir una opción de menú
About que abra un cuadro de diálogo sencillo, con un comentario
sobre el programa y sobre el desarrollador, usted.

Preparación

ejercicio:


1 directorio demos/14_guiapps/exercise1.
2
3

del proyecto ChatRoomPrj. La clase debe implementar el diseño de la
GUI de la Figura 14-1 en la página L14-2.


mostrada en la Figura 14-1 en la página L14-2. Si el diseño de la GUI no es
Aplicaciones basadas en la interfaz gráfica Práctica 14-3
(nivel 2)
componente JComboBox y dos menús.

Preparación

ejercicio:


2
3

1. Añada el componente JComboBox de nombre de usuario bajo los
2. Amplíe los receptores del botón Send y JTextField para incluir el
nombre de usuario en el componente de salida JTextArea.
3. Incluya el componente JTextArea en un componente JScrollPane.
Añada una barra de desplazamiento vertical, pero ninguna
horizontal. Defina el desplazamiento automático del texto a la parte
inferior del área JTextArea cuando el usuario introduzca texto en la
ventana de charla de texto.
4. Añada el menú File. Este menú debe incluir un menú Quit que cierre
el programa.
5. Añada el menú Help. Este menú debe incluir una opción de menú


mostrada en la Figura 14-1 en la página L14-2. Si el diseño de la GUI no es
(nivel 3)
componente JComboBox y dos menús.

Preparación

ejercicio:


2
3

1. Añada el componente JComboBox de nombre de usuario bajo los
// código anterior aquí
private JComboBox usernames;
public ChatClient() {
// more GUI components initialized
usernames = new JComboBox();
usernames.addItem("Jane Doe");
usernames.addItem("1337dud3");
usernames.addItem("Java Geek");
}
}
2. Añada la variable de instancia aboutDialog de tipo
javax.swing.JDialog a la clase ChatClient.
3. Añada la variable de instancia frame de tipo
javax.swing.JFrame a la clase ChatClient.
4. Modifique la declaración y la inicialización de la variable frame en
el método launchFrame así:
frame = new JFrame("Chat Room");
5. Amplíe los receptores del botón Send y JTextField para incluir el
nombre de usuario en el componente de salida JTextArea.
output.append(usernames.getSelectedItem() + ": " + text + "\n");
input.setText("");
}
}
6. Añada un componente JScrollPane al proyecto y el componente
JTextArea a JScrollPane. Añada una barra de desplazamiento
vertical, pero ninguna horizontal.
// Agregar declaración
private JScrollPane textPane;
// Put JTextArea into JScrollPane and define scroll bars

textPane = new JScrollPane(output,
ScrollPaneConstants.VERTICAL_SCROLLBAR_AS_NEEDED,
ScrollPaneConstants.HORIZONTAL_SCROLLBAR_NEVER);
// Agregar JScrollPane al diseño

frame.add(textPane, BorderLayout.WEST);
7. Defina el desplazamiento automático del texto a la parte inferior de
JTextArea cuando el usuario introduzca texto en la ventana de
charla de texto.
// Agregar a SendHandler para habilitar AutoScroll
output.setCaretPosition(output.getDocument().getLength()-1);
8. Añada el menú File. Este menú debe incluir un menú Quit que cierre
el programa.
// Crear barra de menús y menú File
JMenuBar mb = new JMenuBar();
JMenu file = new JMenu("File");
JMenuItem quitMenuItem = new JMenuItem("Quit");
quitMenuItem.addActionListener(new ActionListener() {
System.exit(0);
}
});
file.add(quitMenuItem);
mb.add(file);
frame.setJMenuBar(mb);
}
9. Añada el menú Help. Este menú debe incluir una opción de menú
// aquí código de barra de menús anterior
// Agregar menú Help a barra de menús
JMenu help = new JMenu("Help");
JMenuItem aboutMenuItem = new JMenuItem("About");
aboutMenuItem.addActionListener(new AboutHandler());
help.add(aboutMenuItem);
mb.add(help);
}
private class AboutHandler implements ActionListener {

// Crear cuadro de diálogo About cuando se solicite
if ( aboutDialog == null ) {
aboutDialog = new AboutDialog(frame, "About", true);
}
aboutDialog.setVisible(true);
}
}
private class AboutDialog extends JDialog implements ActionListener

{
public AboutDialog(Frame parent, String title, boolean modal) {
super(parent,title,modal);
add(new JLabel("The ChatClient is a neat tool that allows you
to talk " +
"to other ChatClients via a
ChatServer"),BorderLayout.NORTH);
JButton b = new JButton("OK");
add(b,BorderLayout.SOUTH);
b.addActionListener(this);
pack();
}
// Ocultar cuadro de diálogo al pulsar botón OK
setVisible(false);
}
}

mostrada en la Figura 14-1 en la página L14-2. Si el diseño de la GUI no
es idéntico al de la figura, edite el código para que el diseño coincida

!
?
● Experiencias
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
● Conclusiones
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
● Aplicaciones
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
Práctica 15
Subprocesos
Objetivos
Las personas que realicen la práctica aprenderán a crear una aplicación
multisubproceso sencilla.
Práctica 15-1
2010, los derechos
Ejercicio: Programación multisubproceso (nivel 1)
En este ejercicio creará un programa mulithilo para familiarizarse con los
conceptos del procesamiento multisubproceso.
El objetivo de esta práctica es crear tres subprocesos y ejecutarlos

simultáneamente. Mientras se ejecutan, imprimen sus nombres en el flujo
de salida estándar. Si observa lo que se imprime, verá cómo se ejecutan
los subprocesos y en qué orden.

● “Tarea 1: Creación de la clase PrintMe”
● “Tarea 2: Creación de la clase TestThreeThreads”
● “Tarea 3: Compilación de la clase TestThreeThreads”
● “Tarea 4: Ejecución del programa TestThreeThreads”
Preparación

ejercicio:
proyectos
Para este ejercicio, va a trabajar en el proyecto ThreadProject del

directorio exercises/15_threads.

1 directorio demos/15_threads.
2
3
Tarea 1: Creación de la clase PrintMe
1. Abra el proyecto ThreadProject del directorio
exercises/15_threads.
2. Cree una clase PrintMe en el paquete de origen del proyecto
ThreadProject con las características siguientes:
Nombre de clase: PrintMe
Proyecto: ThreadProject
Implementa: Ejecutable
La clase implementa la interfaz Runnable. El método runde la clase

realiza las acciones siguientes 10 veces: imprime el nombre del subproceso
actual y después espera 2 segundos.
Tarea 2: Creación de la clase TestThreeThreads

En esta tarea va a crear una clase TestThreeThreads en el paquete de
origen del proyecto ThreadProject con las características siguientes:
Nombre de clase: TestThreeThreads
El método principal de la clase crea tres subprocesos utilizando la clase

ejecutable PrintMe. Asigne un nombre único a cada subproceso usando el
método setName. Inicie cada subproceso.
Tarea 3: Compilación de la clase TestThreeThreads

En esta tarea va a compilar la clase TestThreeThreads.
Subprocesos Práctica 15-3
Tarea 4: Ejecución del programa TestThreeThreads
En esta tarea va a ejecutar el programa TestThreeThreads. Debería ver
un resultado similar al siguiente:
T3 - Moe
T2 - Curly
T1 - Larry
T1 - Larry
T3 - Moe
T2 - Curly
T1 - Larry
T3 - Moe
T2 - Curly
T1 - Larry
T3 - Moe
T2 - Curly
T1 - Larry
T3 - Moe
T2 - Curly
T1 - Larry
T3 - Moe
T2 - Curly
T1 - Larry
T3 - Moe
T2 - Curly
T1 - Larry
T3 - Moe
T2 - Curly
T1 - Larry
T3 - Moe
T2 - Curly
T1 - Larry
T3 - Moe
T2 - Curly
Ejecute varias veces este programa. Con cada ejecución puede ver
distintos resultados.
Discusión: ¿Sabe explicar el comportamiento del programa?

!
?

Preparación

ejercicio:
proyectos


2
3
2. Cree la clase PrintMe con las características siguientes:
Esta clase debe implementar la interfaz Runnable.
3. Cree el método run para ejecutar en bucle las acciones siguientes
10 veces: imprimir el nombre del subproceso actual y después
esperar 2 segundos.

origen del proyecto ThreadProject.

1. Cree la clase TestThreeThreads con las características siguientes:
2. Cree el método main.
a. Cree tres objetos Thread y pase una instancia de la clase
PrintMe a cada constructor.
b. Asigne un nombre único a cada subproceso usando el método
setName.
c. Inicie cada subproceso.

un resultado similar al de la ‘‘Tarea 4: Ejecución del programa
TestThreeThreads’’ en la página L15-4.

Preparación

ejercicio:
proyectos


2
3
2. Cree la clase PrintMe con las características siguientes:
Esta clase debe implementar la interfaz Runnable.
class PrintMe implements Runnable {
}
3. Cree el método run para ejecutar en bucle las acciones siguientes
10 veces: imprimir el nombre del subproceso actual y después
esperar 2 segundos.
public void run() {
for(int x = 0; x < 10; x++) {
System.out.println(Thread.currentThread().getName());
try {
Thread.sleep(2000);
} catch(Exception e) {}
}
}
origen del proyecto ThreadProject.

1. Cree la clase TestThreeThreads con las características siguientes:
public class TestThreeThreads {
}
2. Cree el método main.
a. Cree tres objetos Thread y pase una instancia de la clase
PrintMe a cada constructor.
Runnable prog = new PrintMe();
Thread t1 = new Thread(prog);

}
b. Asigne un nombre único a cada subproceso usando el método
setName.
t1.setName("T1 - Larry");
t2.setName("T2 - Curly");
t3.setName("T3 - Moe");
c. Inicie cada subproceso.
t1.start();
t2.start();
t3.start();

un resultado similar al de la ‘‘Tarea 4: Ejecución del programa
TestThreeThreads’’ en la página L15-4.

!
?
● Experiencias
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
● Conclusiones
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
● Aplicaciones
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
Práctica 16
Funciones de red
Objetivos
Las personas que realicen la práctica aprenderán a crear un cliente de GUI
para conectar a un servidor remoto mediante el protocolo TCP/IP
(Protocolo de control de transmisión/Protocolo de Internet).
Práctica 16-1
2010, los derechos
Ejercicio: Creación de un cliente de socket (nivel 1)
En este ejercicio creará código para conectar el cliente de chat room al
servidor de charla.
El servidor de charla se encarga de enviar los mensajes recibidos de un

cliente a todos los clientes conectados (incluido el remitente original).
La Figura 16-1 muestra un diagrama de la arquitectura de varios clientes
conectados al único servidor de charla. En este modelo, Alfredo escribe
Es genial en el componente JTextField del mensaje. A continuación,
el cliente de Alfredo anexa su nombre Alfredo: al mensaje y lo envía al
servidor a través del flujo de salida (paso 1). El servidor recibe el mensaje
y lo reenvía a cada cliente conectado (pasos 2–4); el orden de los mensajes
reenviados es irrelevante.
cliente: PC/Win95
1 "Alfredo: Es genial"
ChatClient
Alfredo
servidor
cliente: SparcSol9
ChatServer
ChatClient 2 "Alfredo: Es genial"

Elena
cliente: PC/WinXP
ChatClient
Ana
Figura 16-1 El servidor de charla envía cualquier mensaje a todos los

clientes conectados
El cliente de charla (su aplicación) se debe modificar para efectuar dos
comportamientos: Debe enviar los mensajes del usuario al servidor y
mostrar los mensajes que reciba del servidor en el componente de salida
JTextArea. La Figura 16-2 ilustra un diseño detallado de los elementos de
la aplicación ChatClient. Va a agregar el método doConnect a la clase
ChatClient para iniciar la conexión de socket con el servidor de charla.
«interfaz»
Runnable
RemoteReader es una clase anidada
que lee mensajes de la variable de
instancia serverIn en ChatClient. +run():void
RemoteReader servidor
ChatClient
-serverIn : BufferedReader
-serverOut : PrintWriter ChatServer
«métodos»
-doConnect():void
SendHandler
«métodos»
+actionPerformed(e:ActionEvent):void
SendHandler es una clase anidada

que envía mensajes de la variable de
instancia serverOut en ChatClient.
Figura 16-2 Diseño detallado de la aplicación ChatClient

● “Tarea 3: Ejecución del proyecto ChatRoomPrj”
Funciones de red Práctica 16-3
Preparación

ejercicio:
● Proyectos de aplicaciones de Java: Configuración de la clase
principal
de las opciones VM
proyectos


1 directorio demos/16_network.
2
3

del proyecto ChatRoomPrj. Implemente la comunicación cliente-servidor
basada en el diseño detallado de la Figura 16-2 en la página L16-3.

Tarea 3: Ejecución del proyecto ChatRoomPrj
1. Defina la clase principal del proyecto ChatRoomPrj en
ChatClient.

de Java: Configuración de las opciones VM
2. Defina las siguientes propiedades del sistema para el proyecto
ChatRoomPrj:
-DserverIP=<server-host>
-DserverPort=2000
Nota – Pregunte al profesor el valor de server-host.
3. Ejecute el proyecto ChatRoomPrj.

Si el programa se conecta al servidor correctamente, el área de
salida de texto mostrará un mensaje del servidor con una frase de
contraseña secreta. Cuando envíe dicha frase al servidor, activará en
el servidor un evento que reproduce una canción. Este evento
indicará que su aplicación funciona correctamente.
¡Buena suerte y que se divierta!
servidor de charla.

Preparación

ejercicio:
principal
de las opciones VM
proyectos


2
3

1. Importe los paquetes java.nety java.io.
2. Añada variables de instancia para alojar los flujos de entrada y salida
de la conexión de socket. Según su implementación, quizá necesite
más variables de instancia.
3. Agregue el método doConnect para iniciar la conexión de
socket TCP/IP con el servidor. Pregunte al profesor el nombre host
(o dirección IP) y el número de puerto de la aplicación del servidor.
a. Inicialice la información de IP y puerto del servidor.
b. Cree la conexión con el servidor de charla.
c. Prepare el flujo de entrada y almacénelo en una variable de
instancia.
d. Prepare el flujo de salida y almacénelo en una variable de
instancia.
e. Ejecute el subproceso de lectura.
f. Use una cláusula catch para capturar las excepciones.
4. Modifique el método launchFrame para llamar al método
doConnect.
5. Modifique la clase anidada SendHandler para enviar el texto del
mensaje (y el nombre del usuario) al flujo de salida del socket.
Borre el código que mostraba el mensaje en el área de salida de texto.
6. Cree la clase anidada RemoteReader que implementa la interfaz
Runnable. El método run debe leer línea a línea el flujo de entrada
del socket en un bucle infinito.

1. Defina la clase principal del proyecto ChatRoomPrj en
ChatClient.

ChatRoomPrj:
-DserverPort=2000

Si el programa se conecta al servidor correctamente, el área de
salida de texto mostrará un mensaje del servidor con una frase de
contraseña secreta. Cuando envíe dicha frase al servidor, activará
en el servidor un evento que reproduce una canción. Este evento
indicará que su aplicación funciona correctamente.
servidor de charla.

Preparación

ejercicio:
principal
de las opciones VM
proyectos


2
3

1. Importe los paquetes java.nety java.io.
import java.net.*;
import java.io.*;
2. Añada variables de instancia para alojar los flujos de entrada y salida

de la conexión de socket. Según su implementación, quizá necesite
más variables de instancia.
private Socket connection = null;
private BufferedReader serverIn = null;
private PrintStream serverOut = null;
}
3. Agregue el método doConnect para iniciar la conexión de
socket TCP/IP con el servidor. Pregunte al profesor el nombre host
(o dirección IP) y el número de puerto de la aplicación del servidor.
private void doConnect() {
a. Inicialice la información de IP y puerto del servidor.
// Inicializar información de IP y puerto de servidor
String serverIP = System.getProperty("serverIP", "127.0.0.1");
String serverPort = System.getProperty("serverPort", "2000");
Nota – Podría haber codificado de forma rígida la dirección IP y el número

de puerto del servidor en la llamada al constructor Socket mostrada a
continuación. El código de este paso demuestra cómo convertir estos
valores en dinámicos durante la ejecución. Las propiedades del sistema
serverIP y serverPort se pueden asignar en el comando java con la
opción -D, así:
java -DserverIP=myhost.example.com
-DserverPort=47 ChatClient
b. Cree la conexión con el servidor de charla.
try {
connection = new Socket(serverIP, Integer.parseInt(serverPort));
c. Prepare el flujo de entrada y almacénelo en una variable de
instancia.
InputStream is = connection.getInputStream();
InputStreamReader isr = new InputStreamReader(is);
serverIn = new BufferedReader(isr);
d. Prepare el flujo de salida y almacénelo en una variable de
instancia.
serverOut = new PrintStream(connection.getOutputStream());
e. Ejecute el subproceso de lectura.
Thread t = new Thread(new RemoteReader());
t.start();
f. Use una cláusula catch para capturar las excepciones.
} catch (Exception e) {
System.err.println("Unable to connect to server!");
e.printStackTrace ();
} // FIN del bloque try-catch
} // FIN del método doConnect
4. Modifique el método launchFrame para llamar al método
doConnect.
doConnect();
}
5. Modifique la clase anidada SendHandler para enviar el texto
del mensaje (y el nombre del usuario) al flujo de salida del socket.
Borre el código que mostraba el mensaje en el área de salida de texto.
text = usernames.getSelectedItem() + ": " + text + "\n";
serverOut.print(text);
input.setText("");
} // FIN del método actionPerformed
} // FIN de la clase anidada SendHandler
6. Cree la clase anidada RemoteReader que implementa la interfaz
Runnable. El método run debe leer línea a línea el flujo de entrada
del socket en un bucle infinito.
private class RemoteReader implements Runnable {
public void run() {
try {
while (true) {
String nextLine = serverIn.readLine();
output.append(nextLine + "\n");
output.setCaretPosition(output.getDocument().getLength()-1);
}
} catch (Exception e) {
System.err.println("Error while reading from server.");
e.printStackTrace ();
}
} // FIN del método run
} // FIN de la clase anidada RemoteReader


1. Defina la clase principal del proyecto ChatRoomPrj en ChatClient.

ChatRoomPrj:
-DserverPort=2000

Si el programa se conecta al servidor correctamente, el área de salida
de texto mostrará un mensaje del servidor con una frase de contraseña
secreta. Cuando envíe dicha frase al servidor, activará en el servidor
un evento que reproduce una canción. Este evento indicará que su
aplicación funciona correctamente.


!
?
● Experiencias
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
● Conclusiones
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
● Aplicaciones
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________

Fundacion Proydesad61748cs10 Ag

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Fundacion Proydesad61748cs10 Ag

Uploaded by

Copyright:

Available Formats

FUNDACION PROYDESA (FUNDACION@PROYDESAฺORG) has a non-transferable license to use this Student Guideฺ

Java Programming Language,

SL-275-SE6-ES Rev G.2

Sun Microsystems, Inc. Disclaimer

Restricted Rights Notice

U.S. GOVERNMENT RIGHTS

viUnauthorized reproduction orLenguaje

x Unauthorized reproduction orLenguaje

xiiUnauthorized reproduction orLenguaje

Objetivos de las prácticas

Este libro contiene los ejercicios de las prácticas correspondientes a cada

También se utiliza Courier con los constructores de programación,

Se aplica Courier en negrita a los números y caracteres que debe

También se usa Courier en negrita en las líneas de código de

Se aplica Courier en cursiva a las variables y los espacios de reserva

La fuente Palatino en cursiva se utiliza con títulos de libros, palabras o

Este ejercicio contiene las siguientes secciones:

Referencia a herramientas: Referencias a herramientas usadas en este

Para este ejercicio va a trabajar en el proyecto TestProject del

Demostración: La demostración de este ejercicio se encuentra en el

Realice los pasos siguientes con los archivos Test1.java, Test2.java,

Referencia a herramientas: Desarrollo en Java: Clases de Java: Apertura

Referencia a herramientas: Desarrollo en Java: Clases de Java:

Referencia a herramientas: Desarrollo en Java: Clases de Java:

La Figura 1-1 muestra la definición de la clase Account utilizando un

Figura 1-1 Clase de cuenta bancaria

Este ejercicio contiene las siguientes secciones:

Referencia a herramientas: Referencias a herramientas usadas en este

Demostración: La demostración de este ejercicio se encuentra en el

Tarea 1: Copia de la clase Account

Referencia a herramientas: Desarrollo en Java: Proyectos de aplicaciones

Referencia a herramientas: Desarrollo en Java: Clases de Java:

Referencia a herramientas: Desarrollo en Java: Clases de Java: Creación

Tarea 3: Compilación de la clase TestAccount

Tarea 4: Ejecución del programa TestAccount

La salida del programa TestAccount debe ser similar a la siguiente:

Final account balance is: 3.0

Este ejercicio contiene las siguientes secciones:

Referencia a herramientas: Referencias a herramientas usadas en este

Demostración: La demostración de este ejercicio se encuentra en el

Referencia a herramientas: Desarrollo en Java: Proyectos de aplicaciones

Referencia a herramientas: Desarrollo en Java: Clases de Java:

Tarea 2: Creación de la clase TestAccount

Referencia a herramientas: Desarrollo en Java: Clases de Java: Creación

Tarea 3: Compilación de la clase TestAccount

Tarea 4: Ejecución del programa TestAccount

La salida del programa TestAccount debe ser similar a la siguiente:

Final account balance is: 3.0

Este ejercicio contiene las siguientes secciones:

Referencia a herramientas: Referencias a herramientas usadas en este

Demostración: La demostración de este ejercicio se encuentra en el

Referencia a herramientas: Desarrollo en Java: Proyectos de aplicaciones

Referencia a herramientas: Desarrollo en Java: Clases de Java:

Tarea 2: Creación de la clase TestAccount

Referencia a herramientas: Desarrollo en Java: Clases de Java: Creación

Tarea 3: Compilación de la clase TestAccount

Tarea 4: Ejecución del programa TestAccount

La salida del programa TestAccount debe ser similar a la siguiente:

Final account balance is: 3.0

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

Este ejercicio contiene las siguientes secciones:

Tarea: Uso de la documentación de API de Java

Nota – La documentación de API para la plataforma Java SE 6 se

2. Seleccione el paquete java.text en la lista de paquetes del panel del