Académique Documents
Professionnel Documents
Culture Documents
Java SE 6
Student Guide
SL-275-SE6-ES Rev G.2
D61748CS10
Edition 1.0
D64147
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. Governments 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.
Contenido
Acerca de este curso ......................................................... Prlogo-xv
Finalidad del curso ............................................................. Prlogo-xv
Descripcin del curso ........................................................Prlogo-xvii
Esquema del curso ........................................................... Prlogo-xviii
Contenido de los mdulos................................................. Prlogo-xix
Objetivos del curso.............................................................. Prlogo-xxi
Temas no incluidos ............................................................Prlogo-xxii
Est preparado? ...............................................................Prlogo-xxiii
Presentaciones ...................................................................Prlogo-xxiv
Cmo utilizar el material del curso .................................Prlogo-xxv
Convenciones tipogrficas y smbolos...........................Prlogo-xxvi
Iconos .........................................................................Prlogo-xxvi
Convenciones tipogrficas.................................... Prlogo-xxvii
Otras convenciones .............................................. Prlogo-xxviii
Introduccin......................................................................................1-1
Objetivos............................................................................................. 1-1
Aspectos relevantes ........................................................................... 1-2
Otros recursos..................................................................................... 1-3
Qu es la tecnologa Java............................................................... 1-4
Objetivos fundamentales de la tecnologa Java ............................. 1-5
Mquina virtual de Java.......................................................... 1-6
Reciclaje de memoria dinmica............................................... 1-7
Entorno de ejecucin de Java .................................................. 1-8
Tareas de JVM..................................................................... 1-10
Cargador de clases .................................................................. 1-10
Verificador de los cdigos de byte ...................................... 1-11
Aplicacin Java sencilla................................................................... 1-12
Aplicacin TestGreeting.................................................... 1-13
Clase Greeting ...................................................................... 1-15
Compilacin y ejecucin del programa TestGreeting... 1-16
Solucin de errores de compilacin .................................... 1-17
v
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
vi
vii
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
viii
xii
Notas ...........................................................................................B-8
Restricciones ..............................................................................B-9
Valores etiquetados ..................................................................B-9
Diagramas de casos de uso.............................................................B-10
Diagramas de clases.........................................................................B-11
Nodos de clase.........................................................................B-11
Herencia ...................................................................................B-14
Implementacin de una interfaz.......................................... B-15
Asociacin, rol y multiplicidad............................................ B-16
Agregacin y composicin ................................................... B-18
Clases de asociacin................................................................B-19
Otros elementos de una asociacin ..................................... B-21
Diagramas de objetos ......................................................................B-22
Diagramas de colaboracin ............................................................B-24
Diagramas de secuencia..................................................................B-26
Diagramas de estados......................................................................B-29
Transiciones ............................................................................ B-30
Diagramas de actividades...............................................................B-31
Diagramas de componentes ...........................................................B-35
Diagramas de distribucin .............................................................B-37
Componentes Swing .......................................................................C-1
Objetivos............................................................................................ C-1
Ejemplos de componentes Swing ................................................... C-2
Contenedores de nivel superior...................................................... C-3
Contenedores genricos ................................................................... C-4
Contenedores especiales .................................................................. C-6
Botones ............................................................................................... C-8
Componentes de texto...................................................................... C-9
Componentes de presentacin de informacin no modificables......
C-11
Mens ............................................................................................... C-12
Componentes de presentacin con formato................................ C-13
Otros controles bsicos................................................................... C-15
xiv
Prlogo
Prlogo-xv
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
Prlogo-xvi
Prlogo-xvii
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
Identificadores,
palabras clave y
tipos
Programacin
orientada a objetos
Expresiones
Arrays
avanzados sobre
las clases
Colecciones y
tipos genricos
y aserciones
E/S:
aspectos
fundamentales
Control de eventos
Aplicaciones
de la GUI
basadas en la GUI
Prlogo-xviii
Funciones de red
Mdulo 1: Introduccin
Este mdulo ofrece una introduccin general al lenguaje Java y sus
caractersticas fundamentales. Tambin presenta una aplicacin Java
sencilla.
Mdulo 5: Arrays
En este mdulo se explica cmo declarar, crear, inicializar y copiar
arrays en Java.
Prlogo-xix
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
Prlogo-xx
Usar excepciones.
Prlogo-xxi
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
Temas no incluidos
Temas no incluidos
En este curso no se tratan los temas indicados a continuacin. Muchos de
ellos forman parte de otros cursos ofrecidos por los Servicios de
Formacin Sun.
Prlogo-xxii
Est preparado?
Est preparado?
Para poder sacar provecho de estas clases, debera haber estudiado el curso
SL-110: Programacin Java para no Programadores, o bien saber:
Prlogo-xxiii
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
Presentaciones
Presentaciones
Despus de esta introduccin sobre el curso, ha llegado el momento
de presentarse al profesor y los dems alumnos. Para ello, indique lo
siguiente:
Prlogo-xxiv
Nombre
Empresa
Finalidad: al final del curso debera ser capaz de alcanzar las metas
fijadas y cumplir todos los objetivos.
Prlogo-xxv
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
Iconos
Otros recursos: Hace referencia a otras fuentes en las que se proporciona
informacin adicional sobre los temas descritos en el mdulo.
Prlogo-xxvi
Convenciones tipogrficas
El tipo de letra que se utiliza en los nombres de comandos, archivos y
directorios, el cdigo de programacin y los mensajes del sistema que
aparecen en la pantalla es Courier, por ejemplo:
Utilice ls -al para ver la lista completa de archivos.
system% Ha recibido correo.
Courier es tambin el tipo de letra que se utiliza en las construcciones de
la programacin, como en los nombres de clases, mtodos y palabras
clave, por ejemplo:
El mtodo getServletInfo se utiliza para obtener informacin
sobre el autor.
La clase java.awt.Dialog contiene el constructor Dialog.
Los nmeros y caracteres que introduce el usuario aparecen en Courier
negrita, por ejemplo:
Para ver la lista de archivos de este directorio, escriba:
# ls
Courier negrita tambin se utiliza en las lneas del cdigo de
programacin a las que se hace referencia en una descripcin de texto,
por ejemplo:
1 import java.io.*;
2 import javax.servlet.*;
3 import javax.servlet.http.*;
La interfaz javax.servlet se importa para permitir el acceso a
los mtodos durante su ejecucin (lnea 2).
Las variables y los ejemplos de argumentos de la lnea de comandos que
se reemplazan por un nombre o valor real aparecen en Courier cursiva,
por ejemplo:
Para eliminar un archivo, utilice el comando rm nombrearchivo.
Para sealar las variables cuyos valores debe introducir el alumno durante
un ejercicio se utiliza Courier cursiva y negrita, por ejemplo:
Escriba chmod a+rwx nombrearchivo para otorgar derechos de
lectura, escritura y ejecucin sobre nombrearchivo a todo el mundo,
a los grupos y los usuarios.
El uso de Palatino cursiva indica que se trata de ttulos de libros, palabras o
trminos nuevos o palabras en las que se quiere hacer nfasis, por ejemplo:
Consulte el Captulo 6 del Manual del usuario.
Se denominan opciones de clase.
Prlogo-xxvii
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
Otras convenciones
En los ejemplos del lenguaje Java se emplean estas otras convenciones:
Prlogo-xxviii
Mdulo 1
Introduccin
Objetivos
El estudio de este mdulo le proporcionar los conocimientos necesarios
para:
1.
1-1
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
Aspectos relevantes
Aspectos relevantes
!
?
1-2
Otros recursos
Otros recursos
Otros recursos: Los documentos siguientes proporcionan informacin
complementaria sobre los temas tratados en este mdulo:
Introduccin
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
1-3
Qu es la tecnologa Java
Qu es la tecnologa Java
La tecnologa Java es:
Un lenguaje de programacin
Un entorno de desarrollo
Un entorno de aplicaciones
Un entorno de implantacin
1-4
La JVM
El reciclaje de memoria
El JRE
Introduccin
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
1-5
1-6
Introduccin
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
1-7
Tiempo de ejecucin
java
TestGreeting.java
javac
Carga
desde el
disco
duro, la
red, u otra
fuente
Cargador
de clases
Verificador
del cdigo
de byte
Intrprete
TestGreeting.class
Tiempo de
ejecucin
Hardware
Figura 1-1
1-8
Compilacin
java
TestGreeting.java
javac
Carga
desde el
disco
duro, la
red, u otra
fuente
Cargador
de clases
Verificador del
cdigo de byte
Intrprete
TestGreeting.class
Tiempo de
ejecucin
Generador
de cdigo
JIT
Hardware
Figura 1-2
Introduccin
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
1-9
Tareas de JVM
En esta seccin se examinan en mayor profundidad las tres tareas
fundamentales de la mquina virtual de Java:
Cargador de clases
El cargador de clases obtiene todas las clases necesarias para la ejecucin
de un programa. Para mayor seguridad, lo hace separando los espacios de
nombres de las clases del sistema de archivos local y los espacios de
nombres procedentes de la red. Esto reduce la posibilidad de entrada
de troyanos, porque las clases locales se cargan primero.
Una vez cargadas todas las clases, se determina la distribucin de la
memoria del archivo ejecutable. En este momento, se asignan las
direcciones concretas de memoria a las referencias simblicas y se
crea la tabla de bsqueda. Dado que la distribucin de la memoria se
produce en el momento de la ejecucin, el intrprete de Java introduce
un mecanismo de proteccin contra accesos no autorizados a zonas
restringidas del cdigo.
1-10
Proceso de verificacin
El verificador de cdigos efecta cuatro pasadas sobre el cdigo de
un programa. De esta forma se garantiza el cumplimiento de las
especificaciones de la JVM y la integridad del sistema. Si despus de las
cuatro pasadas el verificador no encuentra ningn error, significa que:
Introduccin
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
1-11
//
// Ejemplo de aplicacin de "Saludo"
//
public class TestGreeting {
public static void main (String[] args) {
Greeting hello = new Greeting();
hello.greet();
}
}
Cdigo 1-2
1
2
3
4
5
1-12
AplicacinTestGreeting.java
Clase Greeting.java
Aplicacin TestGreeting
Cdigo 1-3
1
2
3
Lneas 1-3
//
// Ejemplo de aplicacin de "Saludo"
//
Lnea 4
Lnea 5
Introduccin
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
1-13
Cdigo 1-6
6
args[0] args[1] . . .
Lnea 6
Lnea 7
hello.greet();
Lneas 89
}
}
Las lneas 8 y 9 del programa, las dos llaves, cierran el mtodo main() y
la clase TestGreeting respectivamente.
1-14
Clase Greeting
Cdigo 1-9
1
Lnea 1
Introduccin
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
1-15
1-16
Introduccin
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
1-17
1-18
Compilacin
TestGreeting.java
javac
Tambin compila
Tiempo de ejecucin
TestGreeting.class
Figura 1-3
java
Greeting.java
Greeting.class
Tambin carga
JVM
Puede ejecutarse en varias plataformas
UNIX
DOS
JVM
JVM
JavaOS
Introduccin
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
1-19
Mdulo 2
2-1
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
Aspectos relevantes
Aspectos relevantes
!
?
2-2
Ingeniera de software
Ingeniera de software
La ingeniera de software es una disciplina compleja y, a menudo,
difcil de controlar. Durante la segunda mitad del siglo anterior, los
informticos, ingenieros de software y diseadores de sistemas
dedicaron sus esfuerzos a crear sistemas de software ms sencillos
mediante el uso de cdigo reutilizable. En la Figura 2-1 se ofrece una
breve historia de la ingeniera de software.
AWT / J.F.C./Swing
Jini
JavaBeans
JDBC
Smalltalk
Eiffel
C++
Java
TCP/IP
ISAM
LISP
COBOL
X-Windows
OpenLook
UNIX
MacOS
Microsoft Windows
2-3
Ingeniera de software
Muchas de estas bibliotecas manejan los datos en forma de estructuras de
registros abiertas, como es el caso de las estructuras struct del lenguaje C.
El principal problema de las estructuras de registros es que el diseador
de la biblioteca no puede ocultar la implementacin de los datos
utilizada en los procedimientos. Esto dificulta la tarea de modificar la
implementacin de la biblioteca sin tocar el cdigo cliente porque ese
cdigo normalmente est ligado a los aspectos especficos de las
estructuras de datos.
A finales de los 80, la programacin orientada a objetos se populariz
con la llegada de C++. Una de las grandes ventajas de la programacin
OO era su capacidad para ocultar determinados aspectos de la
implementacin de la biblioteca para que las actualizaciones no afectasen
al cdigo cliente (suponiendo que no se produjesen cambios en las
interfaces). Otra ventaja importante era que los procedimientos estaban
asociados a la estructura de datos. La combinacin de atributos de datos
y procedimientos (llamados mtodos) se conoce como clase.
En la actualidad, el equivalente de las bibliotecas de funciones son las
bibliotecas de clases o los kits de herramientas (toolkits). Esas bibliotecas
proporcionan clases para realizar muchas de las operaciones que realizan
las bibliotecas de funciones, pero, gracias al uso de las subclases, los
programadores del cdigo cliente pueden ampliar estas herramientas con
facilidad para utilizarlas en sus propias aplicaciones. Las infraestructuras
de programacin proporcionan interfaces (API) que los distintos
proveedores pueden implementar para brindar la cantidad de flexibilidad
y rendimiento que necesite cada desarrollador en sus aplicaciones.
La tecnologa Java es una plataforma que se mantiene en continua
expansin a travs de diferentes API e infraestructuras de programacin
tales como Java Foundation Classes/Swing (J.F.C./Swing) y sus
bibliotecas, la arquitectura de JavaBeans (arquitectura de componentes
de Java) y el API JDBC (Java DataBase Connectivity). La lista de API de
Java es larga y sigue en aumento.
2-4
Ingeniera de software
2-5
Ingeniera de software
Tomando estos requisitos como base, puede crear un diseo de alto nivel:
2-6
Ingeniera de software
Abstraccin
El diseo de software ha ido avanzado desde construcciones de bajo nivel,
como es la escritura en cdigo mquina, hasta niveles mucho ms altos.
Existen dos fuerzas interrelacionadas que han impulsado este proceso:
la simplificacin y la abstraccin. La simplificacin tuvo lugar cuando
los primeros diseadores de lenguajes de programacin crearon
construcciones de alto nivel tales como las sentencias condicionales IF
y los bucles FOR a partir del lenguaje de mquina. La abstraccin es el
mecanismo que oculta los datos privados de la implementacin tras
las interfaces pblicas.
El concepto de abstraccin condujo al uso de subrutinas (funciones)
en lenguajes de alto nivel y, posteriormente, al emparejamiento de
funciones y datos en objetos. A niveles ms altos, la abstraccin dio
lugar al desarrollo de infraestructuras de programacin y API.
2-7
2-8
Declaracin de atributos
Declaracin de atributos
La declaracin de atributos de los objetos se realiza de la forma siguiente:
<modificador>* <tipo> <nombre> [ = <valor_inicial>];
Ejemplo:
1
2
3
4
5
2-9
Declaracin de mtodos
Declaracin de mtodos
Para definir los mtodos, el lenguaje Java utiliza un enfoque similar al de
otros lenguajes, en concreto C y C++. La declaracin adopta el siguiente
formato bsico:
<modificador>* <tipo_retorno> <nombre> ( <argumentos>* ) {
<sentencia>*
}
El <nombre> puede ser cualquier identificador admitido, con algunas
restricciones derivadas de los nombres que ya se estn utilizando.
El segmento <modificador> es opcional y puede tener numerosos
valores, entre ellos, public, protected y private. El modificador de
acceso public indica que es posible llamar a este mtodo desde otro
cdigo. El mtodo private indica que slo pueden acceder a l otros
mtodos de la clase. El mtodo protected se describe ms adelante en
este curso.
<tipo_retorno> indica el tipo de valor que devuelve el mtodo. Si el
mtodo no devuelve ningn valor, debe declararse void. La tecnologa
Java es estricta en lo que se refiere a los valores de retorno. Si la
declaracin indica que el mtodo debe devolver, por ejemplo, un entero
(int), el mtodo debe devolver un entero desde todas las rutas de retorno
posibles y slo acepta llamadas en contextos que esperen el tipo int.
Para devolver un valor dentro de un mtodo debe utilizarse la
sentencia return.
La lista <argumentos> permite pasar argumentos al mtodo. Los
elementos de la lista deben ir separados por comas y cada elemento
debe constar de un tipo y un identificador.
2-10
Declaracin de mtodos
Ejemplo
El Cdigo 2-2 muestra dos mtodos para la clase Perro. El mtodo
getPeso devuelve el valor del atributo peso y no utiliza parmetros.
Los valores de los mtodos se devuelven utilizando la sentencia
return (lnea 4). El mtodo setPeso modifica el valor de peso con el
parmetro newPeso. No devuelve ningn valor. Este mtodo utiliza
una sentencia condicional para impedir que el cdigo cliente defina el
peso de Perro con un nmero negativo o con cero.
Cdigo 2-2
1
2
3
4
5
6
7
8
9
10
11
Ejemplo de mtodos
2-11
La salida es:
El peso del perro d es 0
El peso del perro d es 42
El peso del perro d es 42
2-12
Figura 2-2
MyDate {
day;
month;
year;
2-13
Figura 2-3
Estos mtodos permiten a la clase modificar los datos internos, pero, sobre
todo, verificar la validez de los cambios solicitados. Por ejemplo:
MyDate d = new MyDate();
d.setDay(32);
// da no vlido, devuelve false
d.setMonth(2); d.setDay(30);
// posible pero incorrecto, setDay devuelve false
d.setDay(d.getDay() + 1);
// esta lnea devuelve false si se produce comportamiento
cclico (wrap around)
2-14
Encapsulacin
Encapsulacin
La encapsulacin es la forma de ocultar ciertos elementos de la
implementacin de una clase y, al mismo tiempo, proporcionar una
interfaz pblica para el software cliente. Es una forma ms de ocultar
los datos, ya que la informacin de los atributos es un elemento
significativo de la implementacin de las clases.
Por ejemplo, el programador de la clase MyDate podra optar por volver
a implementar la representacin interna de una fecha como el nmero
de das transcurridos desde el comienzo de una determinada poca.
Esto podra facilitar las comparaciones de fechas y el clculo de los
intervalos entre fechas. Como el programador ha encapsulado los
atributos dentro de una interfaz pblica, puede realizar este cambio
sin que afecte al cdigo cliente. En la Figura 2-4 se muestra esta
variacin de la clase MyDate.
MyDate
-date : long
+getDay() : int
+getMonth() : int
+getYear() : int
+setDay(int) : boolean
+setMonth(int) : boolean
+setYear(int) : boolean
-isDayValid(int) : boolean
Figura 2-4
2-15
Declaracin de constructores
Declaracin de constructores
Un constructor es un conjunto de instrucciones diseadas para inicializar
una instancia. Los parmetros del constructor se pasan de la misma forma
que los de los mtodos. La declaracin bsica tiene el siguiente formato:
[<modificador>] <nombre_clase> ( <argumentos>* ) {
<sentencia>*
}
El nombre del constructor siempre debe ser idntico al de la clase. Si se
utilizan, los nicos modificadores vlidos (<modificador>) para los
constructores son public, protected y private.
La lista de <argumentos> es la misma que en el caso de las declaraciones
de mtodos.
Nota: Los constructores no son mtodos. No tienen valores de retorno ni
se heredan.
Por ejemplo:
1
2
3
4
5
6
2-16
Declaracin de constructores
Constructor predeterminado
Cada clase tiene al menos un constructor. Si no se escribe ninguno, el
lenguaje Java se encarga de suministrarlo. En ese caso, el constructor no
tiene argumentos y su cuerpo est vaco.
El constructor predeterminado permite crear instancias de los objetos con
new Xyz(). En caso de que no se utilice, es preciso suministrar un
constructor para cada clase.
Nota: Si se agrega la declaracin de un constructor a una clase que no tena
ningn constructor explcito, se pierde el constructor predeterminado. A
partir de ese momento, y a menos que el constructor agregado no tenga
argumentos, las llamadas a new Xyz() generarn errores de compilacin.
2-17
Nota: El signo ms (+) indica uno o ms. Para que pueda utilizarse, un
archivo fuente debe contener al menos la definicin de una clase.
El orden de estos elementos es importante. Es decir, las sentencias
de importacin deben preceder a las declaraciones de clases y, si se
utiliza una declaracin de paquetes, sta debe preceder a la de clases
e importaciones.
El nombre del archivo fuente debe ser el mismo que el de la declaracin
de clase pblica de ese archivo. Por otra parte, el archivo fuente puede
incluir varias declaraciones de clases, pero slo una puede declararse como
pblica (public). Si un archivo fuente no contiene ninguna declaracin
de clase pblica, entonces no existen restricciones en cuanto al nombre
de archivo. No obstante, es recomendable tener un archivo fuente por
cada declaracin de clase y el nombre de dicho archivo debe ser
idntico al de la clase.
Por ejemplo, el archivo InformeCapacidadVehiculo.java debera tener
un contenido similar a ste:
1
2
3
4
5
6
7
8
9
10
11
12
2-18
package transporte.informes;
import transporte.dominio.*;
import java.util.List;
import java.io.*;
public class InformeCapacidadVehiculo {
private List vehiculos;
public void generarInforme(Writer output) {
// cdigo para generar el informe
}
}
Paquetes de software
Paquetes de software
La mayora de los sistemas de software son de grandes dimensiones.
Es habitual agrupar las clases en paquetes para facilitar la administracin
del sistema. UML incluye el concepto de paquete en su lenguaje de
modelado. Los paquetes pueden contener clases u otros paquetes
que forman una jerarqua. En la Figura 2-5 puede verse un ejemplo de
una estructura de paquetes:
transporte
dominio
GUI
Empresa
informes
posee
0..*
Camin
Figura 2-5
Vehculo
Barcaza
2-19
Sentencia package
Sentencia package
El lenguaje Java proporciona la sentencia package como una forma de
agrupar clases relacionadas. Esta sentencia se utiliza con la siguiente
sintaxis:
package <nombre_paq_superior>[.<nombre_paq_subordinado>]*;
Es posible indicar que las clases de un archivo fuente pertenecen a un
determinado paquete utilizando la sentencia package, por ejemplo:
1
package transporte.dominio;
2
3
// Clase Vehiculo del subpaquete dominio que hay
dentro del
4
// paquete transporte.
5
public class Vehiculo {
6
...
7
}
La declaracin de paquetes, si existe, debe situarse al comienzo del
archivo fuente. Puede ir precedida de un espacio en blanco y comentarios,
pero nada ms. Slo se permite una declaracin de paquetes, que ser la
que gobierne todo el archivo fuente. Si un archivo fuente Java no contiene
ninguna declaracin de paquete, las clases declaradas en el archivo
pertenecern al paquete predeterminado (sin nombre).
Los nombres de paquetes forman una jerarqua y se separan mediante
puntos. Lo normal es que los elementos de estos nombres se escriban
enteramente en minsculas. Sin embargo, el nombre de las clases suele
empezar por una letra mayscula y se escribe en mayscula la primera
letra de cada palabra que se agrega a fin de diferenciar las distintas
palabras dentro del nombre de clase. stas y otras convenciones sobre
la nomenclatura se explican en Convenciones de codificacin en el
lenguaje Java en la pgina 3-22.
Nota: Si no se incluye ninguna sentencia package en el archivo, todas las
clases declaradas en ese archivo pertenecen al paquete predeterminado
(que es un paquete sin nombre).
2-20
Sentencia import
Sentencia import
Esta sentencia tiene la siguiente sintaxis:
import
<nombre_paq>[.<nombre_paq_subordinado>].<nombre_clase>;
o bien
import <nombre_paq>[.<nombre_paq_subordinado>].*;
Cuando vaya a utilizar paquetes, use la sentencia import para indicar al
compilador el lugar donde se encuentran las clases. De hecho, el nombre
del paquete (por ejemplo, transporte.dominio) forma parte del nombre
de las clases contenidas en ese paquete. As, puede referirse a la clase
Empresa como transporte.dominio.Empresa en todo el archivo, o bien
utilizar la sentencia import junto con el nombre de la clase Empresa.
Nota: Las sentencias import deben preceder a cualquier declaracin de
clase del archivo.
En el ejemplo siguiente se muestra un fragmento de archivo donde se
utiliza la sentencia import.
1
2
3
4
5
6
7
8
9
10
package transporte.informes;
import transporte.dominio.*;
import java.util.List;
import java.io.*;
public class InformeCapacidadVehiculo {
private Empresa empresaParaInforme;
...
}
2-21
Sentencia import
Si quiere acceso a todas las clases del paquete, utilice el asterisco *. Por
ejemplo, para acceder a todas las clases del paquete java.io, escriba:
import java.io.*;
2-22
transporte/
dominio/
Empresa.class
Vehiculo.class
Barcaza.class
Camion.class
GUI/
informes/
InformeCapacidadVehiculo.class
Figura 2-6
2-23
Desarrollo
Es habitual tener que trabajar en varios proyectos de desarrollo al mismo
tiempo. Existen muchas formas de organizar los archivos de desarrollo.
En esta seccin se describe una de ellas.
En la Figura 2-7 puede verse un ejemplo de jerarqua de directorios creada
para un proyecto de desarrollo. El aspecto fundamental de esta jerarqua
es que los archivos fuente de cada proyecto estn separados de los
archivos compilados (.class).
ProyectosJava/
TransporteProy/
src/
transporte/
dominio/
GUI/
informes/
docs/
classes/
transporte/
dominio/
GUI/
informes/
Figura 2-7
2-24
Implementacin
Es posible implementar una aplicacin en una mquina cliente sin
modificar la variable de entorno CLASSPATH del usuario. Normalmente,
la mejor forma de hacerlo es crear un archivo Java ejecutable (JAR). Para
crear este archivo, debe crear un archivo temporal donde se indique el
nombre de la clase que contiene el mtodo main necesario para la
ejecucin, por ejemplo:
Main-Class: mipaquete.MiClase
A continuacin, cree el archivo JAR de la forma habitual, aunque
deber agregar una opcin para que el contenido del archivo temporal
se copie en el archivo META-INF/MANIFEST.MF. Para ello, utilice la
opcin m, como en este ejemplo:
jar cmf tempfile MiPrograma.jar
Por ltimo, el programa puede ejecutarse simplemente con un comando
como ste:
java -jar /ruta/al/archivo/MiPrograma.jar
2-25
Resumen de la terminologa
Resumen de la terminologa
A continuacin se definen algunos de los trminos presentados en este
mdulo:
2-26
Figura 2-8
2-27
2-28
La jerarqua de la clase
La lista de atributos
La lista de constructores
La lista de mtodos
Mdulo 3
3-1
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
Aspectos relevantes
Aspectos relevantes
!
?
3-2
Comentarios
Comentarios
Existen tres formas vlidas de introducir comentarios:
// comentario en una lnea
/* comentario en una
* o varias lneas
*/
/** el comentario de documentacin
* tambin puede abarcar ms de una lnea
*/
Los comentarios de documentacin situados inmediatamente antes de
una declaracin (de una variable, un mtodo o una clase) indican que
ese comentario debera incluirse en cualquier documentacin que se
genere de forma automtica (por ejemplo, los archivos HTML generados
por el comando javadoc) para que sirvan de explicacin del elemento
declarado.
Nota: El formato de estos comentarios y el uso de la herramienta
Javadoc se describen en la documentacin del SDK de Java 2. Vaya a
la siguiente direccin:
http://java.sun.com/j2se/1.5.0/docs/guide/javadoc/
3-3
3-4
3-5
Identificadores
Identificadores
En el lenguaje Java, un identificador es un nombre asignado a una variable,
una clase o un mtodo. Los identificadores empiezan por una letra, el
signo de subrayado (_) o el smbolo del dlar ($). Los caracteres
posteriores pueden ser dgitos. No tienen longitud mxima y existe
diferencia entre maysculas y minsculas.
He aqu algunos identificadores vlidos:
identificador
nombreUsuario
nombre_usuario
_variable_sistema
$transaccion
Un identificador no puede ser una palabra clave, pero puede contener una
palabra clave como parte de su nombre. Por ejemplo thisOne es un
identificador vlido, pero this no lo es porque this es una palabra clave
reservada para el lenguaje Java.
Nota: Los identificadores que contienen el signo de dlar ($) son poco
frecuentes en general, aunque lenguajes como BASIC y los sistemas
VAX/VMS hacen un amplio uso de ellos. Puesto que no son habituales,
seguramente es mejor evitar su uso, a menos que exista alguna
convencin local o alguna razn de peso para incluir este signo en el
identificador.
3-6
continue
for
new
switch
assert
default
goto
package
synchronized
boolean
do
if
private
this
break
double
implements
protected
throw
byte
else
import
public
throws
case
enum
instanceof
return
transient
catch
extends
int
short
try
char
final
interface
static
void
class
finally
long
strictfp
volatile
const
float
native
super
while
Nota: Aunque parezca que true y false son palabras clave, en realidad
son valores literales booleanos, segn se explica en el documento The Java
Language Specification (seccin 3.10.3). Igualmente, null es, de hecho, el
literal null (seccin 3.10.7).
Es necesario hacer algunas consideraciones importantes sobre las palabras
clave:
3-7
Tipos primitivos
El lenguaje Java define ocho tipos de datos primitivos que se enmarcan en
cuatro categoras:
Lgicos: boolean
Textuales: char
Lgicos: boolean
Los valores lgicos se representan mediante el tipo boolean, que puede
contener uno de estos dos valores: true (verdadero) o false (falso). Estos
dos valores se utilizan para representar uno de dos posibles estados,
como activado/desactivado o s/no. El tipo boolean admite dos valores
literales: true y false. El ejemplo de cdigo siguiente contiene la
declaracin e inicializacin de una variable de tipo boolean:
// declara la variable verdad como booleana y
// le asigna el valor true
boolean verdad = true;
3-8
Textuales: char
Los distintos caracteres se representan mediante el tipo char. Un valor
char representa un carcter Unicode de 16 bits sin signo. Es necesario
escribir los literales char entre apstrofos (' '). Por ejemplo:
a
La letra a
\t
Un tabulador
\u????
Textuales: String
El tipo String es un tipo de clase, no primitivo, y se utiliza para
representar cadenas de caracteres. Los caracteres utilizados en la
secuencia son Unicode y la notacin de barra invertida (\) usada para
el tipo char se aplica tambin a String. Al revs de lo que ocurre en C
y C++, la cadenas de caracteres no deben cerrarse con \0.
Los literales String se escriben entre comillas:
"El astuto zorro se lanza sobre el perro."
He aqu algunos ejemplos de declaracin e inicializacin de variables del
tipo char y String:
// declara e inicializa una variable char
char ch = A;
// declara dos variables char
char ch1,ch2;
// declara dos variables String y las inicializa
String greeting = "Buenos das \n";
String errorMessage = "No se ha encontrado el registro.";
// declara dos variables String
String str1,str2;
3-9
077
0xBAAC
077L
0xBAACL
3-10
Nombre o tipo
Rango
8 bits
byte
De -27 a 27 -1
16 bits
short
De -215 a 215 -1
32 bits
int
De -231 a 231 -1
64 bits
long
De -263 a 263 -1
6.02E23
2.718F
123.4E+306D
Nombre o tipo
32 bits
float
64 bits
double
3-11
3-12
3-13
3-14
2.
3.
4.
3-15
????
Declaracin de la referencia al objeto
????
day
month
year
Figura 3-2
month
year
2000
Figura 3-3
3-16
????
Inicializacin explcita
????
day
22
month
year
1964
Figura 3-4
Llamada al constructor
0x01abcdef
day
22
month
year
Figura 3-5
1964
Asignacin de la variable de referencia
3-17
Asignacin de referencias
Asignacin de referencias
En programacin Java, una variable declarada con un tipo de clase se
conoce como tipo de referencia, porque hace referencia a un tipo no
primitivo. Esto tiene algunas implicaciones en cuanto al significado de
la asignacin. Observe ese fragmento de cdigo:
int x = 7;
int y = x;
MyDate s = new MyDate(22, 7, 1964);
MyDate t = s;
Se han creado cuatro variables: dos con tipos primitivos int y otras
dos que hacen referencia al objeto MyDate. El valor de x es 7 y ese
valor se copia en y. Tanto x como y son variables independientes y los
cambios que se realicen en una de ellas no afectarn a la otra.
En el caso de las variables s y t, slo existe el objeto MyDate, que
contiene la fecha del 22 de julio de 1964. Tanto s como t se refieren
al mismo objeto, como se observa en la Figura 3-6.
x
0x01234567
0x01234567
Figura 3-6
22
1964
0x01234567
22
1964
22 12 1964
0x12345678
Figura 3-7 La variable t hace referencia a un objeto nuevo
t
3-18
3-19
changeInt(val);
// Cul es el valor actual?
System.out.println("El valor entero es: " + val);
// Asigna la fecha
date = new MyDate(22, 7, 1964);
// Intenta cambiarla
changeObjectRef(date);
// Cul es el valor actual?
System.out.println("Mi fecha: " + date);
// Ahora se cambia el atributo de da
// mediante la referencia al objeto
changeObjectAttr(date);
// Cul es el valor actual?
System.out.println("Mi fecha: " + date);
}
}
3-20
Referencia this
Referencia this
La palabra clave this se utiliza con dos fines:
El texto del Cdigo 3-1 proporciona una definicin de clase donde pueden
verse estos usos. La clase MyDate declara variables de instancias, lneas 2
4. Uno de los parmetros destinados a uno de los constructores (lneas 610)
tambin se denomina day. Por tanto, en ese contexto, la palabra this
resuelve la ambigedad (lnea 7). El mtodo addDays crea un nuevo objeto
de fecha (lnea 18). En esta llamada al constructor, el mtodo utiliza la
palabra this como argumento para hacer referencia al objeto actual.
Cdigo 3-1 Uso de la palabra clave this
1
public class MyDate {
2
private int day = 1;
3
private int month = 1;
4
private int year = 2000;
5
6
public MyDate(int day, int month, int year) {
7
this.day
= day;
8
this.month = month;
9
this.year = year;
10
}
11
public MyDate(MyDate date) {
12
this.day
= date.day;
13
this.month = date.month;
14
this.year = date.year;
15
}
16
17
public MyDate addDays(int moreDays) {
18
MyDate newDate = new MyDate(this);
19
newDate.day = newDate.day + moreDays;
20
// No implementado an: cdigo de bsqueda cclica
(wrap around)...
21
return newDate;
22
}
23
public String toString() {
24
return "" + day + "-" + month + "-" + year;
25
}
26 }
3-21
3-22
3-23
3-24
Mdulo 4
4-1
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
Aspectos relevantes
Aspectos relevantes
!
?
4-2
Variables
Variables
En esta seccin se explica la forma de declarar, delimitar el mbito e
inicializar las variables en el lenguaje Java.
Variables y mbito
Hemos explicado dos formas de describir las variables: variables de tipos
primitivos y variables de tipos de referencia. Tambin hemos visto dos
lugares en los que pueden declararse las variables: en el interior de un
mtodo, o fuera del mtodo, pero dentro de una definicin de clase.
Las variables que se definen dentro de un mtodo se denominan locales,
aunque algunas veces tambin reciben el nombre de variables automticas,
temporales o de pila. Es preciso inicializar las variables de forma explicita
antes de usarlas por primera vez. Los parmetros de los mtodos y los
constructores tambin son variables locales, pero las inicializa el cdigo de
llamada.
Las variables que se definen fuera de los mtodos se crean cuando el
objeto se construye mediante la llamada new Xxx(). Hay dos tipos de
variables dentro de esta categora. El primero es una variable de clase que
se declara utilizando la palabra clave static. Las variables marcadas
como static se crean cuando se carga la clase y siguen existiendo
mientras sta se mantenga cargada. El segundo tipo es una variable de
instancia que se declara sin la palabra clave static. Las variables de
instancia existen mientras exista el objeto asociado. Las variables de
instancia a veces se conocen como variables miembro porque son
miembros de los objetos creados a partir de la clase. La variable static se
describe con detalle ms adelante en este mismo curso. Las variables
miembro y las variables de clase se inicializan automticamente en el
momento de crearse.
Las variables correspondientes a parmetros de mtodos definen los
argumentos que se pasan en las llamadas a mtodos. Cada vez que
se hace una llamada a un mtodo, se crea una variable que slo dura
hasta que se termina de ejecutar el mtodo.
4-3
Variables
Las variables locales se crean cuando el programa empieza a ejecutar
el mtodo y se destruyen cuando finaliza dicha ejecucin. sta es la
razn por la que las variables locales a veces se denominan temporales
o automticas. Las variables que se definen dentro de una funcin
miembro son locales para esa funcin, por lo que es posible usar el
mismo nombre de variable en distintas funciones miembro para
hacer referencia a distintas variables. Esto se ilustra en el ejemplo del
Cdigo 4-1 de la pgina 4-4.
Cdigo 4-1
1
2
3
4
5
6
7
8
9
10
11
12
13
1
2
3
4
5
6
Nota: Este cdigo sirve nicamente para ilustrar las reglas de definicin de
mbitos. No es recomendable reutilizar los nombres de esta manera.
4-4
Variables
En la Figura 4-1 puede verse de forma grfica el mbito establecido para
las variables en el Cdigo 4-1.
Pila de ejecucin
segundoMetodo
this
j
primerMetodo
EjemploAmbito
5
this
main
mbito
Figura 4-1
4-5
Variables
Valor
byte
short
int
long
0L
float
0.0F
double
0.0D
char
'\u0000'
boolean
false
null
Nota: Una referencia con valor null no hace referencia a ningn objeto.
El intento de usar el objeto de referencia genera una excepcin. Las
excepciones son errores que se producen durante el tiempo de
ejecucin y se describen con posterioridad en este mdulo.
4-6
Variables
4-7
Operadores
Operadores
En esta seccin se describen los operadores utilizados en el lenguaje Java.
Operadores
D-I
++ -- + - ~ ! (<tipo_dato>)
I-D
* / %
I-D
+ -
I-D
I-D
I-D
== !=
I-D
&
I-D
I-D
I-D
&&
I-D
||
D-I
D-I
= *= /= %=
&= ^=
|=
+=
-=
<<= >>=
>>>=
4-8
Operadores
Operadores lgicos
La mayora de los operadores de Java se han tomado de otros lenguajes y
se comportan de la forma esperada.
Los operadores relacionales y lgicos devuelven un resultado booleano
(boolean). El valor 0 no se interpreta automticamente como false y
los valores distintos de cero tampoco se consideran automticamente
como true.
int i = 1;
if (i)
// genera un error de compilacin
if (i != 0) // Correcto
Los operadores boolean admitidos son !, &, ^ y | para las operaciones
algebraicas booleanas correspondientes a NOT, AND, XOR y OR
respectivamente. Cada una de ellas devuelve un resultado boolean.
Los operadores && y || equivalen a los operadores & y | pero evalan
en cortocircuito.
4-9
Operadores
& 0 1 0 0 1 1 1 1
1 0 1 1 0 0 0 0
0 0 0 0 1 1 0 1
0 0 1 0 1 1 0 1
0 0 1 0 1 1 0 1
^ 0 1 0 0 1 1 1 1
| 0 1 0 0 1 1 1 1
0 1 1 0 0 0 1 0
0 1 1 0 1 1 1 1
Figura 4-2
4-10
Operadores
4-11
Operadores
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 1 0 0 1 1 0 1
-1357 = 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 0 1 0 1 1 0 0 1 1
1357 >> 5 = 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 1 0
-1357 >> 5 = 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 0 1 0 1
1357 >>> 5 = 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 1 0
-1357 >>> 5 = 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 0 1 0 1
1357 << 5 =
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 1 0 0 1 1 0 1 0 0 0 0 0
-1357 << 5 = 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 0 1 0 1 1 0 0 1 1 0 0 0 0 0
Figura 4-3
4-12
Operadores
Conversin de tipos
La conversin de tipos consiste en asignar un valor de un tipo a una
variable de otro tipo. Si los dos tipos son compatibles, el software de Java
realiza la conversin de forma automtica. Por ejemplo, siempre es
posible asignar un valor int a una variable de tipo long.
Cuando existe la posibilidad de perder informacin en una asignacin,
el compilador le pide que confirme la asignacin con una conversin
de tipos. Por ejemplo, puede comprimir un valor long en una variable
int de la forma siguiente:
long valorGrande = 99L;
int squashed = valorGrande;
// Incorrecto, necesita
// conversin de tipos
int squashed = (int) valorGrande;
// Correcto
int squashed = 99L;
int squashed = (int) 99L;
int squashed = 99;
// Incorrecto, necesita
// conversin de tipos
// Correcto, pero...
// literal entero
// predeterminado
4-13
Operadores
4-14
Sentencias condicionales
Sentencias condicionales
Las sentencias condicionales permiten ejecutar partes del programa de
forma selectiva en funcin del valor de determinadas expresiones. El
lenguaje Java incluye las sentencias if y switch para bifurcaciones en
dos o ms direcciones respectivamente.
4-15
Sentencias condicionales
En caso de necesitar una serie de comprobaciones condicionales, es
posible encadenar una secuencia de sentencias if-else-if:
if ( <expresin_booleana> )
<sentencia_o_bloque>
else if ( <expresin_booleana> )
<sentencia_o_bloque>
Por ejemplo:
int cantidad = getCantidad(); // mtodo definido en la
clase
if (cantidad < 0) {
System.out.println("Error: el valor de cantidad es negativo.");
} else if (cantidad > getCantidadMax()) {
System.out.println("Error: el valor de cantidad es
demasiado alto.");
} else {
System.out.println("Habr " + cantidad +
" personas para comer hoy.");
}
El lenguaje Java se diferencia de C y C++ porque las sentencias if()
adoptan expresiones booleanas, no valores numricos. No es posible
realizar conversiones entre tipos boolean y tipos numricos. Si tiene:
if (x) // x es int
Utilice:
if (x != 0)
La clusula else de la sentencia es opcional y es posible omitirla si no
debe realizarse ninguna accin cuando la condicin evaluada es falsa.
4-16
Sentencias condicionales
Sentencia switch
La sintaxis de la sentencia switch es:
switch ( <expresin> ) {
case <constante1>:
<sentencia_o_bloque>*
[break;]
case <constante2>:
<sentencia_o_bloque>*
[break;]
default:
<sentencia_o_bloque>*
[break;]
}
En la sentencia switch (<expresin>), el valor de <expresin> debe
ser compatible con un tipo entero. La promocin se produce con los tipos
byte, short o char. No se permiten las expresiones de coma flotante,
long, ni las referencias a objetos (incluidos los tipos String).
Nota: Tambin se pueden utilizar tipos enumerados en los elementos
<expresin> y <constanteN>. Vase la seccin Tipos enumerados en el
Mdulo 7.
La etiqueta default opcional indica el segmento de cdigo que debe
ejecutarse cuando el valor de la variable o la expresin no coincide con
ninguno de los valores case. Si no se ha incluido break como ltima
sentencia del segmento de cdigo de una determinada sentencia case,
la ejecucin contina en el segmento de cdigo de la siguiente
sentencia case sin comprobar el valor de la expresin de case.
Es posible utilizar una sentencia return en lugar de break. Asimismo,
si la sentencia switch est en un bucle, el uso de una sentencia
continue tambin provocara la salida de la construccin switch.
Nota: Nueve de cada diez sentencias switch requieren el uso de
rupturas en cada bloque case. El olvido de la sentencia break es la
causa de la mayora de los errores de programacin de cdigos en los
que se utilizan construcciones con switch.
Puede ver el ejemplo de una sentencia switch en el Cdigo 4-2 de la
pgina 4-18.
4-17
Sentencias condicionales
Cdigo 4-2
switch ( modeloAutomovil) {
case DELUXE:
agregarAireAcondicionado();
agregarRadio();
agregarRuedas();
agregarMotor();
break;
case ESTANDAR:
agregarRadio();
agregarRuedas();
agregarMotor();
break;
default:
agregarRuedas();
agregarMotor();
}
El Cdigo 4-2 configura un objeto coche basado en el modeloAutomovil.
Si modeloAutomovil es la constante de tipo entero DELUXE, entonces se
agrega al vehculo el aire acondicionado, adems de la radio y, por
supuesto, las ruedas y el motor. No obstante, si modeloAutomovil slo
es ESTANDAR, nicamente se le agrega una radio, las ruedas y el motor.
Por ltimo, todos los modelos de automvil tienen ruedas y motor de
forma predeterminada.
En el fragmento del Cdigo 4-3 puede ver otro ejemplo de sentencia
switch.
Cdigo 4-3
switch ( modeloAutomovil) {
case DELUXE:
agregarAireAcondicionado();
case ESTANDAR:
agregarRadio();
default:
agregarRuedas();
agregarMotor();
}
El Cdigo 4-3 resuelve las llamadas redundantes a los mtodos
permitiendo que el flujo de control descienda por los diferentes bloques
case. Por ejemplo, si el modeloAutomovil es DELUXE, entonces se llama
al mtodo agregarAireAcondicionado. A continuacin, el flujo de
control pasa a la siguiente sentencia case y llama al mtodo
agregarRadio, tras lo cual pasa a la sentencia default y llama a los
mtodos agregarRuedas y agregarMotor.
4-18
Sentencias de bucle
Sentencias de bucle
Las construcciones en bucle permiten ejecutar bloques de sentencias de
forma repetida. El lenguaje Java admite tres tipos de construcciones de
bucle: for, while y do. Los bucles for y while verifican la condicin del
bucle antes de ejecutar el cuerpo de la construccin. Los bucles do
verifican la condicin del bucle despus de ejecutar el cuerpo de la
construccin. Esto significa que for y while podran no llegar a
ejecutar el cuerpo del bucle ni siquiera una vez, mientras que do
ejecuta el cuerpo del bucle al menos en una ocasin.
Bucles for
La sintaxis del bucle for es:
for ( <expr_inicial>; <expr_prueba>; <expr_alter> )
<sentencia_o_bloque>
Por ejemplo:
for ( int i = 0; i < 10; i++ )
System.out.println(i + " al cuadrado es " + (i*i));
No obstante, se recomienda situar todas las sentencias del bucle en un
bloque. Por ejemplo:
for ( int i = 0; i < 10; i++ ) {
System.out.println(i + " al cuadrado es " + (i*i));
}
En el ejemplo anterior, el valor int i se declara y define dentro del bloque
for. La variable i slo es accesible dentro del mbito de ese bloque for
concreto.
Nota: El lenguaje Java permite utilizar la coma como separador en
las estructuras de bucles for(). Por ejemplo,
for (i = 0, j = 0; j < 10; i++, j++) { } es una sintaxis
vlida que inicializa las variables i y j con el valor 0 y las va
incrementando despus de ejecutar el cuerpo del bucle.
4-19
Sentencias de bucle
Bucle while
La sintaxis del bucle while es como sigue:
while ( <expr_prueba> )
<sentencia_o_bloque>
Por ejemplo:
int i = 0;
while ( i < 10 ) {
System.out.println(i + " al cuadrado es " + (i*i));
i++;
}
Asegrese de que la variable de control del bucle se haya inicializado de
la forma adecuada antes de que empiece a ejecutarse el cuerpo del bucle.
Es preciso actualizar la variable de control correctamente para evitar
bucles infinitos.
Bucle do/while
La sintaxis del bucle do/while es como sigue:
do
<sentencia_o_bloque>
while ( <expr_prueba> );
Por ejemplo:
int i = 0;
do {
System.out.println(i + " al cuadrado es " + (i*i));
i++;
} while ( i < 10 );
Como en el caso de los bucles while, asegrese de que la variable de
control del bucle se inicialice correctamente, se actualice en el cuerpo del
bucle y se compruebe de la forma adecuada.
La construccin con for se utiliza en aquellos casos en que el bucle debe
ejecutarse un nmero determinado de veces. Las construcciones while y
do se utilizan cuando el nmero de ejecuciones no est establecido de
antemano.
4-20
Sentencias de bucle
break [<etiqueta>];
La sentencia break se utiliza para salir prematuramente de las
sentencias switch, las sentencias de bucles y los bloques
etiquetados.
continue [<etiqueta>];
La sentencia continue se utiliza para saltar directamente al final
del cuerpo del bucle y luego devolver el control a la sentencia de
control del bucle.
<etiqueta> : <sentencia>
La etiqueta identifica cualquier sentencia vlida a la que deba
transferirse el control. En el caso de una sentencia break etiquetada,
la etiqueta puede identificar cualquier sentencia. Si se trata de una
sentencia continue etiquetada, la etiqueta debe identificar una
construccin de bucle.
Sentencia break
He aqu un ejemplo de bucle con una sentencia break sin etiquetar:
1
2
3
4
5
6
7
do {
sentencia;
if ( condicin ) {
break;
}
sentencia;
} while ( expr_prueba );
Sentencia continue
ste es un ejemplo de bucle con una sentencia continue sin etiquetar:
1
2
3
4
5
6
7
do {
sentencia;
if ( condicin ) {
continue;
}
sentencia;
} while ( expr_prueba );
4-21
Sentencias de bucle
outer:
do {
sentencia1;
do {
sentencia2;
if ( condicin ) {
break outer;
}
sentencia3;
} while ( expr_prueba );
sentencia4;
} while ( expr_prueba );
4-22
test:
do {
sentencia1;
do {
sentencia2;
if ( condicin ) {
continue test;
}
sentencia3;
} while ( expr_prueba );
sentencia4;
} while ( expr_prueba );
Mdulo 5
Arrays
Objetivos
El estudio de este mdulo le proporcionar los conocimientos necesarios
para:
5-1
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
Aspectos relevantes
Aspectos relevantes
!
?
5-2
Declaracin de arrays
Declaracin de arrays
Los arrays se usan normalmente para agrupar objetos del mismo tipo.
Permiten hacer referencia al grupo de objetos a travs de un nombre
comn.
Es posible declarar arrays de cualquier tipo, ya sea de tipos primitivos o
de clase:
char[] s;
Point[] p; // donde Point es una clase
Al declarar arrays con los corchetes a la izquierda, stos se aplican a todas
las variables situadas a la derecha de los corchetes.
En el lenguaje Java, un array es un objeto incluso cuando est compuesto
de tipos primitivos y, como en el caso de otros tipos de clase, la
declaracin no crea el objeto en s. Por el contrario, la declaracin de
un array crea una referencia que puede utilizarse para hacer referencia
a un array. La memoria utilizada por los elementos del array se asigna
de forma dinmica mediante una sentencia new o mediante un
inicializador del array.
Los arrays se declaran escribiendo corchetes despus del nombre de la
variable:
char s[];
Point p[];
Este formato es estndar en C, C++ y Java. Su uso puede conducir a
formas complejas de declaracin que pueden ser difciles de leer.
El resultado es que puede considerar la declaracin como una expresin
que tiene la parte de tipos a la izquierda y el nombre de la variable a la
derecha. Aqu veremos el uso de ambos formatos, pero deber optar
por uno de ellos cuando escriba su propio cdigo. Las declaraciones
no indican el tamao concreto del array.
Arrays
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
5-3
Creacin de arrays
Creacin de arrays
Como en el caso de los dems objetos, los arrays pueden crearse
utilizando la palabra clave new. Por ejemplo, para crear un array de
un tipo primitivo (char), utilice:
s = new char[26];
La primera lnea crea un array de 26 valores char. Despus de su
creacin, los elementos del array se inicializan con el valor
predeterminado (\u0000 en el caso de los caracteres). Es necesario
llenar el array con algn valor para que sea til, por ejemplo:
1
2
3
4
5
6
7
8
9
10
char[]
A
B
C
D
crearArray
s
this
main
Figura 5-1
5-4
Creacin de arrays
El subndice que indexa los distintos elementos del array siempre empieza
a partir de 0 y debe mantenerse dentro del rango de valores admitido:
mayor o igual que 0 y menor que la longitud del array. Cualquier intento
de acceder a un elemento del array fuera de estos lmites provocar un
error de tiempo de ejecucin.
Point
Point[]
x
y
0
1
Point
x
y
crearArray
Point
this
main
Figura 5-2
1
2
x
y
2
3
Arrays
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
5-5
Inicializacin de arrays
Inicializacin de arrays
Cuando se crea un array, se inicializa cada uno de sus elementos. En el
caso del array s de tipo char declarado en la seccin anterior, cada valor
se inicializa con el carcter null (\u0000). En el caso del array p, cada
valor se inicializa con null, lo que indica que an no hace referencia a
ningn objeto Point. Tras la asignacin p[0] = new Point(), el
primer elemento del array hace referencia a un objeto Point real.
Nota: Inicializar todas las variables, incluidos los elementos de los arrays,
es fundamental para la seguridad del sistema. No deben utilizarse
variables sin inicializar.
El lenguaje Java permite utilizar una frmula abreviada para crear arrays
con valores iniciales:
String[] names = {
"Julia",
"Juan",
"Alfredo"
};
Este cdigo equivale a escribir:
String[] names;
names = new String[3];
names[0] = "Julia";
names[1] = "Juan";
names[2] = "Alfredo";
Puede utilizar la frmula abreviada para cada tipo de elemento, por
ejemplo:
MyDate[] dates = {
new MyDate(22, 7, 1964),
new MyDate(1, 1, 2000),
new MyDate(22, 12, 1964)
};
5-6
Arrays multidimensionales
Arrays multidimensionales
Java no proporciona arrays multidimensionales de la misma forma que
lo hacen otros lenguajes. Dado que es posible declarar un array para
obtener cualquier tipo de base, existe la opcin de crear arrays de arrays,
arrays de arrays de arrays y as sucesivamente. En el ejemplo siguiente
se utiliza un array bidimensional:
int[][] dosDimen = new int [4][];
dosDimen[0] = new int[5];
dosDimen[1] = new int[5];
El objeto que se crea con la primera llamada a new es un array que
contiene cuatro elementos. Cada elemento es una referencia vaca (null)
a un elemento de tipo array de enteros ( int) y cada elemento debe
inicializarse por separado para que seale a su correspondiente array.
Nota: Aunque el formato de la declaracin permite escribir los corchetes a
la izquierda o la derecha del nombre de la variable, esta flexibilidad no es
extrapolable a otros aspectos de la sintaxis del array. Por ejemplo, el
formato new int[][4] no es vlido.
Gracias a esta separacin, es posible crear arrays de arrays no rectangulares.
Es decir, existe la posibilidad de inicializar los elementos de dosDimen
como sigue:
dosDimen[0]
dosDimen[1]
dosDimen[2]
dosDimen[3]
=
=
=
=
new
new
new
new
int[2];
int[4];
int[6];
int[8];
Arrays
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
5-7
5-8
Redimensionamiento de arrays
Redimensionamiento de arrays
No es posible cambiar el tamao de los arrays una vez creados.
No obstante, s se puede utilizar la misma variable de referencia para
sealar a un array completamente nuevo:
int[] miArray = new int[6];
miArray = new int[10];
En este caso, el primer array en la prctica se pierde, a menos que exista
otra referencia a l en otro lugar.
Arrays
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
5-9
Copia de arrays
Copia de arrays
El lenguaje Java proporciona un mtodo especial en la clase System
(arraycopy()) para copiar arrays. Por ejemplo, el mtodo
arraycopy() puede utilizarse como sigue:
1
2
3
4
5
6
7
8
9
10
// array original
int[] miArray = { 1, 2, 3, 4, 5, 6 };
// nuevo array ms largo
int[] copia = { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 };
// copia todos los elementos de miArray en el array
// copia, empezando por el ndice 0
System.arraycopy(miArray, 0, copia, 0,
miArray.length);
5-10
Mdulo 6
Diseo de clases
Objetivos
El estudio de este mdulo le proporcionar los conocimientos necesarios
para:
6-1
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
Aspectos relevantes
Aspectos relevantes
!
?
6-2
Subclases
Subclases
En programacin, a menudo se crea un modelo de algo (por ejemplo, un
empleado) y luego es necesario crear una versin ms especializada del
modelo original. Por ejemplo, puede querer crear un modelo para un
gerente. Un gerente es un empleado, pero con caractersticas adicionales.
En la Figura 6-1 se ilustran los diagramas de clases UML que modelan las
clases Empleado y Gerente.
Empleado
+nombre : String = ""
+salario : double
+fechaNacimiento : Date
+getDetails() : String
Gerente
+nombre : String = ""
+salario : double
+fechaNacimiento : Date
+departamento : String
+getDetails() : String
Figura 6-1
Diseo de clases
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
6-3
Subclases
Este ejemplo ilustra la duplicacin de datos entre las clases Gerente y
Empleado. Asimismo, podra haber una serie de mtodos igualmente
aplicables a estas dos clases. Por tanto, necesitamos una forma de
crear una clase nueva a partir de una clase existente, lo que recibe el
nombre de creacin de subclases.
En los lenguajes orientados a objetos, se proporcionan mecanismos
especiales que permiten definir una clase sobre la base de una clase
definida con anterioridad. En la Figura 6-2 puede verse un diagrama UML
donde la clase Gerente es una subclase de Empleado.
Empleado
+nombre : String = ""
+salario : double
+fechaNacimiento : Date
+getDetails() : String
Gerente
+departamento : String
Figura 6-2
6-4
Subclases
Herencia sencilla
En el lenguaje Java slo una clase puede ser extensin de otra. Esta
restriccin se denomina herencia sencilla. Las ventajas relativas de la
herencia sencilla y mltiple son objeto de amplias discusiones entre
los programadores de lenguajes OO. En el Mdulo 7, Conceptos
avanzados sobre las clases se examina un aspecto del lenguaje que
proporciona la mayora de las ventaja de la herencia mltiple sin
ninguno de sus inconvenientes, son las denominadas interfaces.
En la Figura 6-3 se observa la clase Empleado inicial y tres subclases:
Ingeniero, Gerente y Secretario. A su vez, Gerente tiene una subclase
denominada Director.
Empleado
+nombre : String = ""
+salario : double
+fechaNacimiento : Date
+getDetails() : String
Gerente
Ingeniero
Secretario
Director
+vehiculoEmpresa : double
+aumentarComision()
Figura 6-3
Diseo de clases
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
6-5
La misma
clase
El mismo
paquete
private
predeterminado
protected
public
Subclase
Universal
6-6
Sobrescritura de mtodos
Sobrescritura de mtodos
Adems de poder agregar atributos para generar clases nuevas a partir de
una clase existente, es posible modificar el comportamiento de la clase
original.
Si se define un mtodo en una subclase de tal forma que su nombre,
el tipo de retorno y la lista de argumentos son idnticos a los de la
superclase (la clase de nivel superior), se dice que el nuevo mtodo
sobrescribe al antiguo.
Nota: En J2SE versin 5.0, las reglas de comparacin y coincidencia han
cambiado ligeramente. El tipo de retorno del mtodo nuevo ahora puede
ser una subclase del mtodo heredado. La explicacin sobre los tipos
de retornos covariantes queda fuera de los objetivos de este curso.
Observe estos ejemplos de mtodos en las clases Empleado y Gerente:
public class Empleado {
protected String nombre;
protected double salario;
protected Date fechaNacimiento;
public String getDetails() {
return Nombre: + nombre + \n
+ Salario: + salario;
}
}
public class Gerente extends Empleado {
protected String departamento;
public String getDetails() {
return Nombre: + nombre + \n
+ Salario: + salario + \n
+ Gerente de: + departamento;
}
}
La clase Gerente contiene un mtodo getDetails por definicin, porque
lo hereda de la clase Empleado. Pero el mtodo original ha sido sustituido,
sobrescrito, por la versin de la clase subordinada.
Diseo de clases
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
6-7
Sobrescritura de mtodos
6-8
Sobrescritura de mtodos
Diseo de clases
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
6-9
Polimorfismo
Polimorfismo
Describir un Gerente indicando que es un Empleado no es slo una forma
cmoda de describir la relacin entre estas dos clases. Recuerde que el
Gerente contiene todos los miembros (atributos y mtodos) de la
superclase Empleado. Esto significa que cualquier operacin que sea
legtima con un Empleado tambin ser legtima con un Gerente. Si el
Empleado tiene el mtodo getDetails, el Gerente tambin lo tiene.
Puede parecer ilgico crear un Gerente y asignar deliberadamente a una
variable de Empleado la referencia a esa clase. No obstante, es posible
hacerlo y hay razones por las que puede interesarle conseguir este efecto.
Un objeto slo tiene una forma (aquella que se le asigna cuando se
construye). Sin embargo, una variable es polimrfica porque puede
hacer referencia a objetos de distintas formas.
El lenguaje Java, como la mayora de los lenguajes de programacin OO,
en realidad permite hacer referencia a un objeto con una variable que
es uno de los tipos de una superclase. Por tanto, es posible decir:
Empleado e = new Gerente(); //vlido
Utilizando la variable e tal cual, puede acceder nicamente a las partes
del objeto que son componentes de Empleado; las partes especficas de
Gerente estn ocultas. Esto es porque, por lo que respecta al compilador,
e es un Empleado, no un Gerente. Por lo tanto, no se permite lo siguiente:
// Intento no permitido de asignar un atributo de Gerente
e.departamento = "Ventas";
// la variable se declara como un tipo de Empleado
// a pesar de que el objeto Gerente tiene ese atributo
6-10
Polimorfismo
Lo que no resulta tan obvio es lo que ocurre si tenemos el cdigo siguiente:
Empleado e = new Gerente();
e.getDetails();
O algo parecido, como un argumento de un mtodo general o un
elemento de una coleccin heterognea.
De hecho, se obtiene el comportamiento asociado al objeto al que hace
referencia la variable durante el tiempo de ejecucin. El comportamiento
no est determinado por el tipo de la variable en el momento de la
compilacin. Este es un aspecto del polimorfismo y un aspecto importante
de los lenguajes orientados a objetos. Este comportamiento a menudo
recibe el nombre de llamada a mtodos virtuales.
En el ejemplo anterior, el mtodo e.getDetails() ejecutado procede del
tipo real del objeto, un Gerente. Si est habituado a programar en C++,
es importante hacer una distincin entre Java y dicho lenguaje. En C++,
slo obtiene este comportamiento si marca el mtodo como virtual
en el cdigo fuente. En lenguajes puramente orientados a objetos, esto
no es habitual. C++ lo hace de esta manera para incrementar la
velocidad de ejecucin.
Colecciones heterogneas
Es posible crear colecciones de objetos que tienen una clase comn.
Este tipo de colecciones se denominan homogneas. Por ejemplo:
MyDate[] dates = new MyDate[2];
dates[0] = new MyDate(22, 12, 1964);
dates[1] = new MyDate(22, 7, 1964);
El lenguaje Java incluye una clase Object que permite crear colecciones
de todos los tipos de elementos porque todas las clases amplan la
clase Object. Estas colecciones se denominan heterogneas.
Una coleccin heterognea es aquella que se compone de elementos
dispares. En los lenguajes OO, es posible crear colecciones de
numerosos elementos. Todas ellas tienen una clase de origen comn:
la clase Object. Por ejemplo:
Empleado []
personal[0]
personal[1]
personal[2]
Diseo de clases
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
6-11
Polimorfismo
Es posible escribir incluso un mtodo de ordenacin que coloque los
empleados por orden de edad o salario, con independencia de que
algunos de esos empleados sean gerentes.
Nota: Cada clase es una subclase de Object, de forma que es posible usar
un array de Object como contenedor para cualquier combinacin de
objetos. Los nicos elementos que no pueden agregarse a un array de
Object son las variables de tipos primitivos. Sin embargo, es posible
crear objetos a partir de datos primitivos utilizando clases envoltorio,
como se explica en la seccin Clases envoltorio en la pgina 6-26.
Argumentos polimrficos
Es posible escribir mtodos que acepten un objeto genrico (en este caso,
la clase Empleado) y funcionen adecuadamente con los objetos de
cualquier subclase de dicho objeto. Por ejemplo, podra generarse un
mtodo en una clase de aplicacin que tome un empleado y lo compare
con un determinado umbral de salario para determinar las obligaciones
fiscales de ese empleado. Si se utilizan las caractersticas polimrficas,
es posible hacerlo como sigue:
public class ServicioImpuestos {
public TipoImpositivo hallarTipoImpositivo(Empleado e) {
// hace los clculos y devuelve el tipo impositivo para e
}
}
// Mientras tanto, en otra parte de la clase de aplicacin
ServicioImpuestos svcImp = new ServicioImpuestos();
Gerente m = new Gerente();
TipoImpositivo t = svcImp.hallarTipoImpositivo(m);
Esto es vlido porque un Gerente es un Empleado. No obstante, el
mtodo hallarTipoImpositivo slo tiene acceso a los miembros
(variables y mtodos) que estn definidos en la clase Empleado.
6-12
Operador instanceof
Operador instanceof
Dado que es posible pasar objetos de un lugar a otro utilizando
referencias a sus superclases, a veces conviene saber de qu objetos
reales se dispone. ste es el propsito del operador instanceof.
Supongamos que la jerarqua de clases se ampla de la forma siguiente:
public class Empleado extends Object
public class Gerente extends Empleado
public class Ingeniero extends Empleado
Diseo de clases
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
6-13
Operador instanceof
Conversin de objetos
En casos en los que se ha recibido una referencia a una clase de nivel
superior y se ha comprobado mediante el operador instanceof que
el objeto es una subclase concreta, es posible acceder a toda la
funcionalidad del objeto convirtiendo la referencia.
public void hacerAlgo(Empleado e) {
if ( e instanceof Gerente ) {
Gerente m = (Gerente) e;
System.out.println(ste es el gerente de
+ m.getDepartamento());
}
// resto de la operacin
}
Si no realiza la conversin, el intento de ejecutar e.getDepartamento()
fracasar porque el compilador no puede localizar ningn mtodo
llamado getDepartamento en la clase Empleado.
Si no realiza la comprobacin con instanceof, corre el riesgo de que falle
la conversin. En general, cualquier intento de convertir una referencia a
un objeto se somete a diferentes comprobaciones:
6-14
Sobrecarga de mtodos
Sobrecarga de mtodos
En algunos casos, puede que quiera escribir en la misma clase varios
mtodos que realizan la misma tarea bsica pero con diferentes argumentos.
Piense en un mtodo sencillo destinado a enviar una representacin
textual de su argumento. Este mtodo se podra llamar println().
Ahora suponga que necesita un mtodo de impresin distinto para
imprimir cada uno de los tipos int, float y String. Esto es razonable
porque cada tipo de datos necesita un formato diferente y, posiblemente,
un tratamiento distinto. Podra crear tres mtodos denominados
printInt(), printFloat() y printString() respectivamente. Pero esto
resulta tedioso.
Java y otros lenguajes de programacin permiten reutilizar un mismo
nombre de mtodo para varios mtodos. Esto slo funciona si las
circunstancias bajo las que se hace la llamada permiten distinguir cul
es el mtodo necesario. En el caso de los tres mtodos de impresin,
esta distincin se basa en el nmero de argumentos y su tipo.
Si se reutiliza el nombre de mtodo, se obtienen los mtodos siguientes:
public void println(int i)
public void println(float f)
public void println(String s)
Cuando se escribe el cdigo para llamar a uno de estos mtodos, se
elige el mtodo adecuado en funcin del tipo de argumento o
argumentos que se suministran.
Se aplican dos reglas a los mtodos sobrecargados:
Diseo de clases
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
6-15
Sobrecarga de mtodos
6-16
Sobrecarga de constructores
Sobrecarga de constructores
Cuando se instancia un objeto, el programa puede ser capaz de suministrar
varios constructores basndose en los datos del objeto que se est creando.
Por ejemplo, un sistema de nminas podra ser capaz de crear un objeto
Empleado si conoce todos los datos bsicos sobre la persona: nombre,
salario base y fecha de nacimiento. Puede que, en alguna ocasin, el sistema
no conozca el salario base o la fecha de nacimiento.
El Cdigo 6-4 contiene un ejemplo de cuatro constructores sobrecargados
para la clase Empleado. El primer constructor (lneas 711) inicializa todas
las variables de instancia. En el segundo (lneas 1214), no se incluye la
fecha de nacimiento. La referencia this se utiliza como forma de envo
de llamada a otro constructor (siempre dentro de la misma clase), en
este caso, el primer constructor. Por su parte, el tercer constructor
(lneas 1517) llama al primer constructor pasando la constante de clase
SALARIO_BASE. El cuarto constructor (lneas 1820) llama al segundo
constructor pasando SALARIO_BASE, que, a su vez, llama al primer
constructor pasando null en lugar de la fecha de nacimiento.
Cdigo 6-4
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
6-17
Sobrecarga de constructores
6-18
Sobrecarga de constructores
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Diseo de clases
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
6-19
2.
3.
4.
5.
6-20
1
2
3
1
2
3
4
5
6
7
8
9
10
11
this(n, null);
}
}
public class Gerente extends Empleado {
private String departamento;
public Gerente(String n, String d) {
super(n);
departamento = d;
}
}
stos son los pasos para construir la clase new Gerente("Juan Lopez",
"Ventas"):
0 Inicializacin bsica
0.1 Asignar la memoria para el objeto Gerente completo
0.2 Inicializar todas las variables de instancia con sus valores
predeterminados
1 Llamar al constructor: Gerente("Juan Lopez", "Ventas")
1.1 Enlazar los parmetros del constructor: n="Juan Lopez", d="Ventas"
1.2 No hay llamada explcita a this()
1.3 Llamar a super(n) para obtener Empleado(String)
1.3.1 Enlazar los parmetros del constructor: n="Juan Lopez"
1.3.2 Llamar a this(n, null) para obtener Empleado(String, Date)
1.3.2.1 Enlazar los parmetros del constructor: n="Juan Lopez",
FdeNac=null
1.3.2.2 No hay llamada this() explcita
1.3.2.3 Llamar a super() para obtener Object()
1.3.2.3.1 No es necesario el enlace
1.3.2.3.2 No hay llamada a this()
1.3.2.3.3 No hay llamada a super() (Object es la raz)
1.3.2.3.4 No hay inicializacin de variables explcitas de Object
1.3.2.3.5 No hay cuerpo de mtodo para llamar
1.3.2.4 Inicializar variables explcitas de Empleado:
salario=15000.00;
1.3.2.5 Ejecutar cuerpo: nombre="Juan Lopez"; fecha=null;
1.3.3 - 1.3.4 Pasos omitidos
1.3.5 Ejecutar cuerpo: no hay cuerpo en Empleado(String)
1.4 No hay inicializadores explcitos para Gerente
1.5 Ejecutar cuerpo: departamento="Ventas"
Diseo de clases
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
6-21
Clase Object
Clase Object
La clase Object es la raz de todas las clases en el lenguaje Java. Si se
declara una clase sin clusula extends, el compilador agrega
automticamente el cdigo extends Object a la declaracin, por ejemplo:
public class Empleado {
// ms cdigo aqu
}
Equivale a:
public class Empleado extends Object {
// ms cdigo aqu
}
Esto permite sobrescribir varios mtodos heredados de la clase Object.
En las secciones siguientes se describen dos mtodos importantes de
Object.
El mtodo equals
El operador == realiza una comparacin para determinar la equivalencia
de dos trminos. Es decir, para dos valores de referencia x e y dados, x==y
devuelve true si, y slo si, x e y se refieren al mismo objeto.
La clase Object del paquete java.lang contiene el mtodo
public boolean equals(Object obj), que compara dos objetos para
comprobar su igualdad. Si no se sobrescribe, el mtodo equals() de un
objeto devuelve true nicamente si las dos referencias comparadas se
refieren al mismo objeto. No obstante, la intencin de equals() es
comparar el contenido de dos objetos siempre que es posible. sta es la
razn por la que se sobrescribe con frecuencia. Por ejemplo, el mtodo
equals() en la clase String devuelve true nicamente si el argumento
no es null y es un objeto String que representa la misma secuencia de
caracteres que el objeto String con el que se ha llamado al mtodo.
Nota: Debera sobrescribir el mtodo hashCode cada vez que sobrescriba
equals. Una implementacin sencilla podra usar un XOR de bits en los
cdigos hash de los elementos cuya equivalencia se quiera comprobar.
6-22
Clase Object
1
2
3
4
5
class TestEquals {
public static void main(String[] args) {
MyDate date1 = new MyDate(14, 3, 1976);
MyDate date2 = new MyDate(14, 3, 1976);
Diseo de clases
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
6-23
Clase Object
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
if ( date1 == date2 ) {
System.out.println("date1 es idntica a date2");
} else {
System.out.println("date1 no es idntica a date2");
}
if ( date1.equals(date2) ) {
System.out.println("date1 es igual que date2");
} else {
System.out.println("date1 no es igual que date2");
}
System.out.println("set date2 = date1;");
date2 = date1;
if ( date1 == date2 ) {
System.out.println("date1 es idntica a date2");
} else {
System.out.println("date1 no es idntica a date2");
}
}
}
La ejecucin de este programa de comparacin genera la salida siguiente:
date1 no es idntica a date2
fecha1 es igual que date2
set date2 = date1;
date1 es idntica a date2
Mtodo toString
El mtodo toString convierte un objeto en una representacin de cadena
o String. El compilador hace referencia a l cuando se produce una
conversin automtica de cadenas. Por ejemplo, la llamada
System.out.println():
Date now = new Date();
System.out.println(now);
Equivale a:
System.out.println(now.toString());
6-24
Clase Object
La clase Object define un mtodo toString que devuelve el nombre de
la clase y su direccin de referencia (normalmente de escasa utilidad).
Muchas clases sobrescriben toString para proporcionar informacin de
mayor utilidad. Por ejemplo, todas las clases envoltorio (que se explican a
continuacin) sobrescriben toString para suministrar una forma de
cadena para el valor que representan. Incluso las clases que representan
elementos sin una forma string a menudo implementan toString para
devolver la informacin de estado del objeto con fines de depuracin.
Diseo de clases
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
6-25
Clases envoltorio
Clases envoltorio
El lenguaje Java no considera los tipos de datos primitivos como objetos.
Por ejemplo, los datos numricos, booleanos y de caracteres se tratan de
forma primitiva para mantener la eficiencia. A fin de poder manejar los
tipos primitivos como objetos, Java proporciona las llamadas clases
envoltorio. Estos elementos quedan envueltos por un objeto que se crea
en torno a ellos. Cada tipo primitivo en Java tiene una clase envoltorio
asociada en el paquete java.lang. Cada clase envoltorio encapsula
un nico valor primitivo. (Vase la Tabla 6-2.)
Nota: Las clases envoltorio implementan objetos inmutables. Esto
significa que, una vez inicializado el valor primitivo en su envoltorio,
no hay forma de cambiar ese valor.
Tabla 6-2 Clases envoltorio
Tipo de datos primitivos
Clase envoltorio
boolean
Boolean
byte
Byte
char
Character
short
Short
int
Integer
long
Long
float
Float
double
Double
6-26
Clases envoltorio
Las clases envoltorio son tiles para convertir datos primitivos debido a la
gran cantidad de mtodos disponibles con este tipo de clases, por ejemplo:
int x = Integer.valueOf(str).intValue();
or:
int x = Integer.parseInt(str);
Diseo de clases
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
6-27
Clases envoltorio
Atencin: No abuse de la funcin de autoboxing. El rendimiento se ve
afectado cada vez que se utiliza la conversin o recuperacin automtica
de primitivos. La combinacin de primitivos y objetos envoltorio en
expresiones aritmticas dentro de un bucle cerrado podra tener efectos
negativos sobre el rendimiento y la velocidad de transmisin de datos de
las aplicaciones.
6-28
Mdulo 7
7-1
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
Aspectos relevantes
Aspectos relevantes
!
?
7-2
Atributos de clase
A veces resulta til tener una variable compartida por todas las
instancias de una clase. Esta variable podra utilizarse, por ejemplo,
como base para la comunicacin entre instancias o para llevar el control
del nmero de instancias que se han creado (vase la Figura 7-1).
Count
+counter : int = 0
-serialNumber : int
instanceOf
instanceOf
c1 : Count
c2 : Count
serialNumber=1
serialNumber=2
Figura 7-1
7-3
Mtodos de clase
A veces, cuando no hay disponible ninguna instancia de un determinado
objeto, es necesario acceder al cdigo del programa. Los mtodos
marcados con la palabra static pueden utilizarse de esta forma y
algunas veces se denominan mtodos de clase.
1
2
3
4
5
6
7
8
9
10
11
12
7-4
7-5
Inicializadores estticos
Una clase puede contener cdigo en bloques estticos que no forman parte
de los mtodos normales. El cdigo de los bloques estticos se ejecuta una
vez que se ha cargado la clase. Si una clase contiene varios bloques
estticos, stos se ejecutan por orden de aparicin en la clase.
1
2
3
4
5
6
1
2
3
4
5
7-6
Clases finales
El lenguaje Java permite aplicar la palabra clave final a las clases.
Cuando se hace, no es posible generar subclases a partir de una clase.
Por ejemplo, la clase java.lang.String es una clase final. Esto se
hace por razones de seguridad, porque garantiza que, si un mtodo
hace referencia a una cadena, ser una cadena definida a de la clase
String y no una cadena de una posible subclase modificada de
String que podra haberse cambiado.
Mtodos finales
Es posible marcar los distintos mtodos como final. Los mtodos
marcados con la palabra final no pueden sobrescribirse. Por razones
de seguridad, un mtodo debe sealarse como final si contiene una
implementacin que no debera modificarse y es fundamental para
mantener la coherencia del objeto.
Es posible optimizar los mtodos declarados como finales. El compilador
puede generar cdigo que efecte una llamada directa al mtodo en lugar
de hacer la habitual llamada al mtodo virtual, que implica bsquedas
durante el tiempo de ejecucin. El compilador puede optimizar los
mtodos marcados como static o private de la misma forma que si se
hubiesen marcado como final, ya que en ninguno de los casos puede
aplicarse el enlace dinmico.
Variables finales
Si una variable se marca como final, se convierte en una constante.
Cualquier intento de cambiar el valor en este tipo de variables provoca
un error de compilacin. ste es un ejemplo de una variable final
definida correctamente:
public class Banco {
private static final
double TASA_INTERES_PREDETERMINADA=3.2;
// ms declaraciones
}
7-7
7-8
Tipos enumerados
Tipos enumerados
Una prctica habitual en programacin es tener un nmero finito de
nombres simblicos que representan los valores de un atributo. Por
ejemplo, sera posible crear un conjunto de smbolos que representasen
los palos de una baraja de cartas: PICAS, CORAZONES, TREBOLES y
DIAMANTES. Esta forma de representacin se suele denominar tipo
enumerado.
Nota: No debe confundirse el trmino tipo enumerado con la clase
java.util.Enumeration. No guardan ninguna relacin entre s.
7-9
Tipos enumerados
package naipes.domain;
public class NaipeBaraja {
// tipo seudoenumerado
public static final int
public static final int
public static final int
public static final int
PALO_PICAS
= 0;
PALO_CORAZONES
= 1;
PALO_TREBOLES
= 2;
PALO_DIAMANTES = 3;
7-10
Tipos enumerados
Por otra parte, la interfaz grfica de usuario tendr que mostrar cadenas
en lugar de enteros para representar los palos de la baraja. En el
Cdigo 7-2 se muestra el mtodo getNamePalo de la clase NaipeBaraja.
Observe las lneas 37 y 38. Este cdigo se utiliza cuando el atributo
palo contiene un valor entero no vlido.
Cdigo 7-2
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
Mtodo getNamePalo
7-11
Tipos enumerados
El fragmento de Cdigo 7-3 contiene el programa TestNaipeBaraja, que
crea dos objetos naipe y luego indica su rango y palo. Este programa
permite ver el principal problema causado por el uso de la antigua
versin de los tipos enumerados. El constructor NaipeBaraja recibe dos
argumentos: un entero para el palo y un segundo entero para el rango.
La primera llamada al constructor NaipeBaraja (lnea 9) utiliza una
constante apropiada para el nombre simblico, pero la segunda llamada
a ese constructor (lnea 14) utiliza un valor entero arbitrario. Ambas
llamadas al constructor son vlidas desde la perspectiva del compilador.
Cdigo 7-3
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
Programa TestNaipeBaraja
package naipes.tests;
import naipes.domain.NaipeBaraja;
public class TestNaipeBaraja {
public static void main(String[] args) {
NaipeBaraja naipe1
= new NaipeBaraja(NaipeBaraja.PALO_PICAS, 2);
System.out.println("el naipe1 es: " + naipe1.getRango()
+ " de " + naipe1.getNameRango());
// Puede crear un naipe de un palo inventado.
NaipeBaraja naipe2 = new NaipeBaraja(47, 2);
System.out.println("el naipe2 es: " + naipe2.getRango()
+ " de " + naipe2.getNameRango());
}
}
7-12
Tipos enumerados
Esta modalidad de tipo enumerado presenta varios problemas:
package naipes.domain;
public enum Palo {
PICAS,
CORAZONES,
TREBOLES,
DIAMANTES
}
7-13
Tipos enumerados
El Cdigo 7-5 muestra cmo la clase NaipeBaraja utiliza el tipo Palo
para el tipo de datos del atributo palo.
Cdigo 7-5
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
7-14
package naipes.domain;
public class NaipeBaraja {
private Palo palo;
private int rango;
public NaipeBaraja(Palo palo, int rango) {
this.palo = palo;
this.rango = rango;
}
public Palo getPalo() {
return palo;
}
public String getNamePalo() {
String name = "";
switch ( palo ) {
case PICAS:
name = "Picas";
break;
case CORAZONES:
name = "Corazones";
break;
case TREBOLES:
name = "Treboles";
break;
case DIAMANTES:
name = "Diamantes";
break;
default:
// No es necesario comprobar si hay errores ya que
// el enum Palo es finito.
}
return name;
}
Tipos enumerados
Esto resuelve el problema de seguridad de los tipos que presentaba la
antigua versin de tipos enumerados. El Cdigo 7-6 muestra el programa
de prueba actualizado. Si se quita el signo de comentario en la lnea 14,
dara como resultado un error de compilacin porque el valor entero
47 no es del tipo Palo.
Cdigo 7-6
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
Programa TestNaipeBaraja
package naipes.tests;
import naipes.domain.NaipeBaraja;
import naipes.domain.Palo;
public class TestNaipeBaraja {
public static void main(String[] args) {
NaipeBaraja naipe1
= new NaipeBaraja(Palo.PICAS, 2);
System.out.println("el naipe1 es: " + naipe1.getRango()
+ " de " + naipe1.getNameRango());
// NaipeBaraja naipe2 = new NaipeBaraja(47, 2);
// Esto no se compilar.
}
}
7-15
Tipos enumerados
package naipes.domain;
public enum Palo {
PICAS
("Picas"),
CORAZONES
("Corazones"),
TREBOLES
("Treboles"),
DIAMANTES ("Diamantes");
private final String name;
private Palo(String name) {
this.name = name;
}
public String getName() {
return name;
}
}
7-16
Tipos enumerados
Por ltimo, el Cdigo 7-8 muestra el programa de prueba modificado,
que utiliza el nuevo mtodo getName en el tipo Palo. En la lnea 12,
el mtodo getPalo devuelve un valor de Palo y el mtodo getName
devuelve el atributo nombre de ese valor de Palo.
Cdigo 7-8
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package naipes.tests;
import naipes.domain.NaipeBaraja;
import naipes.domain.Palo;
public class TestNaipeBaraja {
public static void main(String[] args) {
NaipeBaraja naipe1
= new NaipeBaraja(Palo.PICAS, 2);
System.out.println("el naipe1 es: " + naipe1.getRango()
+ " de " + naipe1.getPalo().getName());
// NuevoNaipeBaraja naipe2 = new NuevoNaipeBaraja(47, 2);
// Esto no se compilar.
}
}
7-17
Importaciones estticas
Importaciones estticas
Si necesita acceder a los miembros estticos de una clase, ser necesario
calificar las referencias con la clase de la que proceden. Esto se aplica
tambin a los valores de los tipos de enumeracin. La lnea 10 del
Cdigo 7-8 de la pgina 7-17 muestra el acceso al valor PICAS del tipo
Palo mediante la notacin de punto Palo.PICAS.
La versin 5.0 de J2SE proporciona una funcin de importacin esttica
que permite acceder a los miembros estticos sin tener que calificarlos
con el nombre de la clase. En el Cdigo 7-9 se muestra el uso de las
importaciones estticas. La lnea 4 indica al compilador que incluya los
valores del tipo enumerado (o cualquier miembro esttico de ese tipo)
en la tabla de smbolos cuando compile este programa. Como
consecuencia, la lnea 9 puede usar PICAS sin necesidad de poner el
prefijo de espacio de nombres Palo.
Cdigo 7-9
1
2
3
4
5
6
7
8
9
10
11
12
13
2);
14
15
16
package naipes.tests;
import naipes.domain.NaipeBaraja;
import static naipes.domain.Palo.*;
public class TestNaipeBaraja {
public static void main(String[] args) {
NaipeBaraja naipe1 = new NaipeBaraja(PICAS, 2);
System.out.println("el naipe1 es: " + naipe1.getRango()
+ " de " + naipe1.getPalo().getName());
// NuevoNaipeBaraja naipe2 = new NuevoNaipeBaraja(47,
// Esto no se compilar.
}
}
7-18
Clases abstractas
Clases abstractas
Volviendo al ejemplo de la empresa de transporte, imagine que el sistema
necesita generar un informe semanal donde figure toda la flota de
vehculos de la compaa y las necesidades de combustible para los
prximos viajes. Supongamos que el Sistema de Transporte tiene una
clase TransporteMain que suministra informacin para la lista de la flota
de vehculos y genera el informe de Combustible Necesario.
La Figura 7-2 ilustra el modelo UML de la compaa y su coleccin flota
de vehculos (la asociacin flota).
transporte
TransporteMain Usa
dominio
Empresa
informes
InformeCombustibleNecesario Usa
Figura 7-2
0..*
Vehculo
flota
Camin
Barcaza
7-19
Clases abstractas
El cdigo del informe debera escribirse de la siguiente manera:
1
public class InformeCombustibleNecesario {
2
private Empresa empresa;
3
4
public InformeCombustibleNecesario(Empresa empresa) {
5
this.empresa = empresa;
6
}
7
8
public void generateText(PrintStream output) {
9
Vehiculo1 v;
10
double combustible;
11
double total_combustible = 0.0;
12
13
for ( int i = 0; i < empresa.getTamanoFlota(); i++ ) {
14
v = empresa.getVehiculo(i);
15
16
// Calcula el combustible necesario para este viaje
17
combustible = v.calcDistanciaViaje() / v.calcEficienciaConsumo();
18
19
output.println("El Vehculo " + v.getName() + " necesita "
20
+ combustible + " litros de combustible.");
21
total_combustible += combustible;
22
}
23
output.println("La cantidad total de combustible necesario es " +
total_combustible + " litros.");
24
}
25 }
Los requisitos de combustible se calculan dividiendo la distancia del viaje
(en kilmetros) por la eficiencia de consumo del vehculo (en kilmetros
por litro).
Problema
Los clculos para determinar la eficiencia de consumo de un camin
en comparacin con la de una barcaza pueden variar sustancialmente.
La clase Vehiculo no puede suministrar estos dos mtodos, pero sus
subclases (Camion y Barcaza) s pueden.
7-20
Clases abstractas
Solucin
El lenguaje Java permite disear las clases de modo que los mtodos
declarados en las superclases no proporcionen ninguna implementacin.
Este tipo de mtodos se denominan mtodos abstractos. La implementacin
del mtodo viene proporcionada por las subclases. Una clase que tenga
uno o varios mtodos abstractos se denomina clase abstracta (vase la
Figura 7-3).
Vehculo
{abstract}
+calcEficienciaConsumo() : double
+calcDistanciaViaje() : double
Camin
Barcaza
constructores
+Camion(cargaMax : double)
constructores
+Barcaza(cargaMax : double)
mtodos
+calcEficienciaConsumo() : double
+calcDistanciaViaje() : double
mtodos
+calcEficienciaConsumo() : double
+calcDistanciaViaje() : double
Figura 7-3
7-21
Clases abstractas
La clase Camion debe crear una implementacin:
1
2
3
4
5
6
7
8
9
7-22
Interfaces
Interfaces
La interfaz pblica de una clase es un contrato entre el cdigo cliente y
la clase que proporciona el servicio. Cada mtodo se implementa
mediante clases concretas. Sin embargo, una clase abstracta puede
diferir la implementacin declarando el mtodo como abstracto y una
interfaz Java declara slo el contrato, no la implementacin.
Una clase concreta implementa una interfaz definiendo todos los
mtodos declarados por ella. Puede haber muchas clases que
implementen la misma interfaz, pero no necesitan compartir la misma
jerarqua. Asimismo, una sola clase puede implementar varias interfaces.
Esto se describe en las secciones siguientes.
Al igual que los nombres de clases abstractas, los nombres de interfaz
se utilizan como tipos de variables de referencia. Se produce el enlace
dinmico habitual. Las referencias se convierten en (y desde) tipos
de interfaz, y el operador instanceof se utiliza para determinar si la
clase de un objeto implementa una interfaz.
Nota: Todos los mtodos declarados en una interfaz son pblicos
(public) y abstractos (abstract), con independencia de que
mencionemos estos modificadores en el cdigo o no. Igualmente,
todos los atributos son public, static y final. En otras palabras,
slo se pueden declarar atributos constantes.
7-23
Interfaces
ObjetoVolador
+despegar()
+aterrizar()
+volar()
Avin
+despegar()
+aterrizar()
+volar()
Figura 7-4
7-24
1
2
3
4
5
1
2
3
4
5
6
7
8
9
10
11
12
13
14
Interfaces
Puede haber muchas clases que implementen la interfaz ObjetoVolador,
como se muestra en la Figura 7-5. Un Avion, un ave o Superman pueden
volar.
interfaz
ObjetoVolador
+despegar()
+aterrizar()
+volar()
Avion
Ave
+despegar()
+aterrizar()
+volar()
Figura 7-5
+despegar()
+aterrizar()
+volar()
+hacerNido()
+ponerHuevos()
Superman
+despegar()
+aterrizar()
+volar()
+saltarEdificio()
+detenerBala()
7-25
Interfaces
Suena como una herencia mltiple, pero no lo es. El peligro de la herencia
mltiple es que una clase podra heredar dos implementaciones diferentes
del mismo mtodo. Esto no es posible con las interfaces, porque una
declaracin de mtodo de una interfaz no proporciona ninguna
implementacin, como puede verse en la Figura 7-6.
Animal
interfaz
ObjetoVolador
+comer()
+despegar()
+aterrizar()
+volar()
Vehiculo
Kriptoniano
Avion
+despegar()
+aterrizar()
+volar()
Figura 7-6
Ave
+despegar()
+aterrizar()
+volar()
+hacerNido()
+ponerHuevos()
+comer()
Superman
+despegar()
+aterrizar()
+volar()
+saltarEdificio()
+detenerBala()
+comer()
7-26
Interfaces
Supongamos que va a crear un sistema de software de control de
aeronaves. Deber dar permiso de aterrizaje y despegue a objetos
voladores de todo tipo. Su modelo se muestra en la Figura 7-7.
Animal
interfaz
ObjetoVolador
+comer()
+despegar()
+aterrizar()
+volar()
Vehiculo
Kriptoniano
Avion
Ave
+despegar()
+aterrizar()
+volar()
Hidroavion
+despegar()
+aterrizar()
+volar()
+hacerNido()
+ponerHuevos()
+comer()
Superman
+despegar()
+aterrizar()
+volar()
+saltarEdificio()
+detenerBala()
+comer()
Helicoptero
Figura 7-7
7-27
Interfaces
ObjetoVolador
+despegar()
+aterrizar()
+volar()
Vehiculo
Barcaza
Avion
+atracar()
+navegar()
interfaz
+despegar()
+aterrizar()
+volar()
Nautico
+atracar()
+navegar()
Hidroavion
Helicoptero
+atracar()
+navegar()
Figura 7-8
7-28
Interfaces
El hidroavin puede despegar del aeropuerto de Londres y atracar en el
puerto de Barcelona.
7-29
Mdulo 8
Excepciones y aserciones
Objetivos
El estudio de este mdulo le proporcionar los conocimientos necesarios
para:
Definir excepciones.
Usar aserciones.
8-1
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
Aspectos relevantes
Aspectos relevantes
!
?
8-2
Excepciones y aserciones
Excepciones y aserciones
Las excepciones son un mecanismo utilizado por numerosos lenguajes de
programacin para describir lo que debe hacerse cuando ocurre algo
inesperado. En general, algo inesperado suele ser algn tipo de error,
por ejemplo, la llamada a un mtodo con argumentos no vlidos, el
fallo de una conexin de red o la solicitud de apertura de un archivo
que no existe.
Las aserciones son una forma de verificar ciertos supuestos sobre la lgica
de un programa. Por ejemplo, si cree que, en un determinado punto,
el valor de una variable siempre ser positivo, una asercin puede
comprobar si esto es verdad. Las aserciones suelen utilizarse para verificar
supuestos sobre la lgica local dentro de un mtodo y no para comprobar
si se cumplen las expectativas externas.
Un aspecto importante de las aserciones es que pueden suprimirse
enteramente al ejecutar el cdigo. Esto permite habilitar las aserciones
durante el desarrollo del programa, pero evitar la ejecucin de las pruebas
en el tiempo de ejecucin, cuando el producto final se entrega al cliente.
sta es una diferencia importante entre aserciones y excepciones.
Excepciones y aserciones
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
8-3
Excepciones
Excepciones
El lenguaje Java proporciona dos grandes categoras de excepciones,
conocidas como comprobadas y no comprobadas.
Las excepciones comprobadas son aquellas que se espera que el
programador gestione en el programa y se generan por condiciones
externas que pueden afectar a un programa en ejecucin. Dentro de este
tipo se encuentran, por ejemplo, la solicitud de archivos que no se
encuentran o los fallos de la red.
Las excepciones no comprobadas pueden proceder de errores del cdigo o
situaciones que, en general, se consideran demasiado difciles para que el
programa las maneje de forma razonable. Se denominan no comprobadas
porque no se pide al programador que las verifique ni que haga nada
cuando se producen. Las excepciones que probablemente son el resultado
de defectos del cdigo se denominan excepciones de tiempo de ejecucin.
Un ejemplo de este tipo de excepciones es el intento de acceder a un
elemento ms all del final de un array.
Las excepciones que se derivan de problemas del entorno de los que es
difcil recuperarse se denominan errores. En esta categora se incluye el
agotamiento de la memoria. Los errores tambin son excepciones no
comprobadas.
La clase Exception es la clase bsica para representar las excepciones
comprobadas y no comprobadas. En lugar de finalizar la ejecucin del
programa, es mejor escribir cdigo para manejar la excepcin y continuar.
La clase Error es la clase bsica utilizada para condiciones de error
graves, no comprobadas, de las que es de esperar que el programa no
intente recuperarse. En la mayora de los casos, debera dejar que finalice
la ejecucin del programa al encontrar este tipo de errores, aunque puede
tratar de preservar la mayor parte del trabajo realizado por el usuario.
La clase RuntimeException es la clase bsica utilizada para las
excepciones no comprobadas que pueden derivarse de los defectos del
programa. En la mayora de los casos, debera dejar finalizar el programa
cuando se produce una excepcin de este tipo. De nuevo, es aconsejable
tratar de preservar la mayor parte posible del trabajo del usuario.
Cuando se produce una excepcin en un programa, el mtodo que detecta
el error puede encargarse de manejarlo o puede reenviar la excepcin al
mtodo que lo ha llamado para indicar que se ha producido un error. Por
su parte, el mtodo de llamada tiene las mismas opciones: manejar la
excepcin o reenviarla al programa que lo ha llamado Si una excepcin
alcanza el punto superior de un hilo (thread), ese hilo se cancela. Este
mecanismo da al programador la opcin de escribir un controlador
(handler) para resolver la excepcin en un punto adecuado del cdigo.
8-4
Excepciones
Es posible determinar las excepciones comprobadas que reenva un
mtodo examinando el API. Algunas veces, puede que encuentre
documentacin que describa una o varias excepciones no comprobadas,
pero normalmente esto es innecesario y no debe confiar en dicha
informacin.
Excepciones y aserciones
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
8-5
Sentencia try-catch
Sentencia try-catch
El lenguaje Java proporciona un mecanismo para averiguar qu excepcin
se ha generado y cmo debe resolverla el programa. En el Cdigo 8-2
se muestra un programa AddArguments modificado que utiliza una
sentencia try-catch para detectar la excepcin, en este caso
java.lang.NumberFormatException.
Cdigo 8-2
1
2
3
4
5
6
7
8
9
10
11
12
13
14
8-6
Sentencia try-catch
Excepciones y aserciones
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
8-7
Sentencia try-catch
try {
// cdigo que podra generar una o varias excepciones
} catch (MiException e1) {
// cdigo que debe ejecutarse si se enva MiException
} catch (MiOtraException e2) {
// cdigo que debe ejecutarse si se enva MiOtraException
} catch (Exception e3) {
// cdigo que debe ejecutarse si se enva cualquier otra
// excepcin
}
Si dispone de varias clusulas para un bloque try, el orden de las clusulas
catch es importante. Esto es porque una excepcin enviada desde el
bloque try ser manejada por la primera clusula catch que pueda
manejarla. En este ejemplo, la clusula catch de Exception se pone en
primer lugar, lo que significa que manejara todas las excepciones, y nunca
se llamara a las clusulas catch de MiException o MiOtraException.
8-8
Sentencia try-catch
Imagine un caso en el que el mtodo main() llama a otro mtodo
denominado primero(), y ste, a su vez, llama a otro denominado
segundo(). Si se produce una excepcin en el mtodo segundo() y no se
gestiona all, se vuelve a enviar al primero(). Imagine que en el mtodo
primero() hay una clusula catch para ese tipo de excepcin. En este
caso, se efecta el control de la excepcin y no va ms all. Sin embargo,
si el mtodo primero() no tiene ninguna clusula catch para este tipo
de excepcin, se comprueba el siguiente mtodo de la pila de llamadas,
main(). Si la excepcin no se gestiona en main(), se enva a la salida
estndar y el programa deja de ejecutarse.
Clusula finally
La clusula finally define un bloque de cdigo que siempre se ejecuta,
con independencia de que se capture la excepcin o no. El siguiente
ejemplo de cdigo y su descripcin se han extrado del documento Low
Level Security in Java (seguridad de bajo nivel en Java), de Frank Yellin:
1
2
3
4
5
6
7
8
try {
startFaucet();
waterLawn();
} catch (BrokenPipeException e) {
logProblem(e);
} finally {
stopFaucet();
}
Excepciones y aserciones
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
8-9
Categoras de excepciones
Categoras de excepciones
Antes hemos hablado de tres grandes categoras de excepciones. En esta
seccin se examina la jerarqua de clases que representa tales categoras.
La clase java.lang.Throwable acta como la clase de nivel superior
para todos los objetos que pueden enviarse y capturarse utilizando los
mecanismos de control de excepciones. Los mtodos definidos en la clase
Throwable recuperan el mensaje de error asociado a la excepcin y
presentan en pantalla el proceso de la pila de llamadas con el punto en
el que se produjo. Hay tres subclases de la excepcin Throwable: Error,
RuntimeException y Exception, que se muestran en la Figura 8-1.
StackOverflowError
VirtualMachineError
OutOfMemoryError
Error
AssertionError
Throwable
ArithmeticException
RuntimeException
NullPointerException
IllegalArgumentException
Exception
SQLException
EOFException
IOException
FileNotFoundException
Figura 8-1
8-10
Subclases y excepciones
Categoras de excepciones
Para describir una determinada excepcin, no debera usar la clase
Throwable, sino una de las excepciones de subclases. A continuacin
se describe el propsito de cada excepcin:
Excepciones y aserciones
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
8-11
Excepciones comunes
Excepciones comunes
El lenguaje Java proporciona varias excepciones predefinidas. Algunas de
las ms comunes son:
NullPointerException
Es un intento de acceder a un atributo o mtodo de un objeto
asociado a una variable que no hace referencia a ningn objeto. Por
ejemplo, cuando la variable no se ha inicializado o no se ha
instanciado ningn objeto.
Empleado emp = null;
System.out.println( emp.getName() );
FileNotFoundException
Esta excepcin se genera por un intento de leer datos de un archivo
que no existe.
NumberFormatException
Esta excepcin es un intento de analizar una cadena en un nmero
(entero o real de coma flotante) que tiene un formato de nmero no
vlido.
ArithmeticException
sta se genera al dividir un entero entre cero.
int i = 0;
int j = 12 / i;
SecurityException
Normalmente se genera en navegadores. La clase SecurityManager
enva una excepcin por aquellos applets que intentan realizar
una operacin que podra ser peligrosa para el host o sus archivos.
stos son algunos ejemplos de operaciones que pueden generar
excepciones de seguridad:
8-12
Excepciones y aserciones
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
8-13
8-14
1
2
3
4
5
1
2
3
4
5
Excepciones y aserciones
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
8-15
8-16
Excepciones y aserciones
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
8-17
8-18
Aserciones
Aserciones
Las aserciones admiten dos tipos de sintaxis:
assert <expresin_booleana> ;
assert <expresin_booleana> ; <expresin_detallada> ;
En ambos casos, si la expresin booleana se evala como false, se genera
un error de asercin (AssertionError). Este error no debera capturarse
y el programa debera finalizar de forma anmala.
Si se utiliza el segundo formato, la segunda expresin, que puede ser de
cualquier tipo, se convierte en un tipo String y se utiliza para complementar
el mensaje que aparece en la pantalla cuando se notifica la asercin.
Nota: Dado que la palabra clave assert es relativamente nueva, el
mecanismo de asercin puede interrumpir el cdigo escrito para la versin
1.3 o versiones anteriores del JDK si ste usa la palabra assert como
etiqueta o nombre de variable. Puede utilizar la opcin -source 1.3 para
indicar al comando javac que compile el cdigo para la versin 1.3.
Excepciones y aserciones
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
8-19
Aserciones
Invariantes internas
Las invariantes internas se dan cuando se cree que una situacin se va a
producir en todos los casos o en ningn caso y se escribe el cdigo de
acuerdo con esta conviccin. Observe este ejemplo de cdigo:
1
2
3
4
5
if (x > 0) {
// hacer esto
} else {
// hacer aquello
}
if (x > 0) {
// hacer esto
} else {
assert (x == 0);
// hacer aquello a menos que x sea negativo
}
8-20
switch ( palo ) {
case Palo.TREBOLES: // ...
break;
case Palo.DIAMANTES: // ...
break;
Aserciones
6
case Palo.CORAZONES: // ...
7
break;
8
case Palo.PICAS: // ...
9
break;
10
default: assert false : "Palo desconocido en la
baraja";
11
break;
12 }
Excepciones y aserciones
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
8-21
Aserciones
Una invariante de clase es aquella que puede comprobarse al final de
cada llamada a un mtodo de una clase. En el caso de una clase Pila,
una condicin invariante es aquella en que el nmero de elementos
nunca es negativo.
8-22
Mdulo 9
9-1
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
Otros recursos
Otros recursos
Otros recursos: Los documentos siguientes proporcionan informacin
complementaria sobre los temas tratados en este mdulo:
9-2
API Collections
API Collections
Una coleccin es un solo objeto que administra un grupo de objetos.
Los objetos de la coleccin se llaman elementos. Las colecciones suelen
trabajar con numerosos tipos de objetos, todos los cuales son de un
mismo tipo (todos descienden de un mismo tipo de nivel superior).
El API Collections contiene interfaces que asignan los objetos a uno de los
siguientes grupos:
9-3
API Collections
La Figura 9-1 muestra un diagrama UML de las principales interfaces y
clases de implementacin del API Collections.
<<interface>>
Collection
+add
+remove
+size
+isEmpty
+contains
+iterator
<<interface>>
<<interface>>
Set
List
<<interface >>
HashSet
SortedSet
+add
+remove
+get
+set
+indexOf
+listIterator
TreeSet
ArrayList
Figura 9-1
LinkedList
9-4
Implementaciones de Collection
Implementaciones de Collection
Existen varias implementaciones genricas de las interfaces fundamentales
(Set, List, Map y Deque) en la infraestructura Collections. La Tabla 9-1
muestra algunas implementaciones concretas de dichas interfaces.
Tabla 9-1 Implementaciones genricas de Collection
Hash Table
Set
Resizable
Array
HashSet
Balanced
Tree
Linked List
TreeSet
LinkedHashSet
List
ArrayList
LinkedList
Deque
ArrayDeque
LinkedList
Map
HashMap
TreeMap
Hash Table +
Linked List
LinkedHashMap
Programa EjemploSet
import java.util.*;
public class EjemploSet {
public static void main(String[] args) {
Set set = new HashSet();
set.add("one");
set.add("second");
set.add("3rd");
set.add(new Integer(4));
set.add(new Float(5.0F));
set.add("second");
// duplicado, no se agrega
set.add(new Integer(4)); // duplicado, no se agrega
System.out.println(set);
}
}
9-5
Implementaciones de Collection
Este programa podra generar la siguiente salida:
[one, second, 5.0, 3rd, 4]
Tenga presente que los elementos no aparecen en el mismo orden en el
que se agregaron.
Nota: En la lnea 13, el programa imprime el objeto set como salida
estndar. Esto funciona porque la clase HashSet anula el mtodo
heredado toString y crea una secuencia separada por comas con los
elementos delimitados por los corchetes inicial y final.
Programa EjemploList
import java.util.*;
public class EjemploList {
public static void main(String[] args) {
List list = new ArrayList();
list.add("one");
list.add("second");
list.add("3rd");
list.add(new Integer(4));
list.add(new Float(5.0F));
list.add("second");
// duplicado, se agrega
list.add(new Integer(4)); // duplicado, se agrega
System.out.println(list);
}
}
9-6
Implementaciones de Collection
9-7
Interfaz Map
Interfaz Map
A veces los mapas se denominan arrays asociativos. Los objetos Map
describen las asignaciones de claves a valores. Por definicin, los
objetos Map no admiten claves duplicadas y una clave slo puede
asignarse a un valor.
La interfaz Map proporciona tres mtodos que permiten ver el contenido
de un mapa como colecciones:
entrySet: devuelve una variable Set que contiene todos los pares
formados por una clave y un valor.
keySet: devuelve una variable Set con todas las claves del mapa.
Figura 9-2
9-8
Interfaz Map
Programa EjemploMap
import java.util.*;
public class EjemploMap {
public static void main(String args[]) {
Map map = new HashMap();
map.put("one","1st");
map.put("second", new Integer(2));
map.put("third","3rd");
// Sobrescribe la asignacin anterior
map.put("third","III");
// Devuelve el conjunto de las claves
Set set1 = map.keySet();
// Devuelve la vista Collection de los valores
Collection collection = map.values();
// Devuelve el conjunto de las asignaciones de claves a valores
Set set2 = map.entrySet();
System.out.println(set1 + "\n" + collection + \n + set2);
}
}
El programa generara la siguiente salida:
[second, one, third]
[2, 1st, III]
[second=2, one=1st, third=III]
9-9
9-10
Ordenacin de colecciones
Ordenacin de colecciones
Las interfaces Comparable y Comparator resultan tiles para ordenar
colecciones. La interfaz Comparable define un orden natural para
las clases que la implementan. La interfaz Comparator se emplea para
especificar la relacin de orden. Tambin permite anular el orden natural.
Estas interfaces resultan tiles para ordenar los elementos de una coleccin.
Interfaz Comparable
La interfaz Comparable pertenece al paquete java.lang. Cuando se
declara una clase, la implementacin de JVM no tiene manera de
determinar el orden que debe aplicarse a los objetos de la clase.
La interfaz Comparable permite definir el orden de los objetos de
cualquier clase. Es posible ordenar las colecciones que contienen
objetos de clases que implementan la interfaz Comparable.
Algunos ejemplos de clases de Java que implementan la interfaz
Comparable son Byte, Long, String, Date y Float. Las clases numricas
emplean una implementacin numrica, la clase String utiliza una
implementacin alfabtica y la clase Date emplea una implementacin
cronolgica. Al pasar una lista de tipo ArrayList que contiene elementos
de tipo String al mtodo esttico sort de la clase Collections, se
genera una lista en orden alfabtico. Una lista que contiene elementos
de tipo Date se clasificar por orden cronolgico, mientras que una lista
con elementos de tipo Integer se clasificar por orden numrico.
Para escribir tipos Comparable personalizados, es necesario implementar
el mtodo compareTo de la interfaz Comparable. El Cdigo 9-4 muestra
cmo implementar la interfaz Comparable. La clase Estudiante
implementa la interfaz Comparable para que los objetos de esta clase
puedan compararse entre s segn su nota media (en una escala del 1 al 4).
Cdigo 9-4
1
class Estudiante implements Comparable {
2
String Nombre, primerApellido;
3
int IDestudiante=0;
4
double Media=0,0;
5
public Estudiante(String Nombre, String primerApellido, int
IDestudiante,
6
double Media) {
7
if (Nombre == null || primerApellido == null || IDestudiante == 0
8
|| Media == 0,0) {throw new IllegalArgumentException();}
9
this.Nombre = Nombre;
9-11
Ordenacin de colecciones
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
this.primerApellido = primerApellido;
this.IDestudiante = IDestudiante;
this.Media = Media;
}
public String Nombre() { return Nombre; }
public String primerApellido() { return primerApellido; }
public int IDestudiante() { return IDestudiante; }
public double Media() { return Media; }
// Implementa el mtodo compareTo.
public int compareTo(Object o) {
double f = Media-((Estudiante)o).Media;
if (f == 0,0)
return 0;
// 0 significa que son iguales
else if (f<0,0)
return -1;
// un valor negativo significa menos que o antes de
else
return 1;
// un valor positivo significa ms que o despus de
}
}
El programa ListaEstudiantes del Cdigo 9-5 prueba la
implementacin de la interfaz Comparable creada en el Cdigo 9-4 de la
pgina 9-11. El programa ListaEstudiantes crea cuatro objetos
Estudiante y los imprime. Como los objetos Estudiante se agregan al
conjunto ordenado TreeSet, los objetos se ordenan.
Cdigo 9-5
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
9-12
Programa ListaEstudiantes
import java.util.*;
public class ComparableTest {
public static void main(String[] args) {
TreeSet estudianteSet = new TreeSet();
estudianteSet.add(new Estudiante("Miguel", "Herraiz",101, 4,0));
estudianteSet.add(new Estudiante("Juan", "Lino",102, 2,8));
estudianteSet.add(new Estudiante("Jaime", "Marcos",103, 3,6));
estudianteSet.add(new Estudiante("Clara", "Genio",104, 2,3));
Object[] estudianteArray = estudianteSet.toArray();
Estudiante s;
for(Object obj : estudianteArray){
s = (Estudiante) obj;
System.out.printf("Nombre = %s %s ID = %d Media = %.1f\n",
s.Nombre(), s.primerApellido(), s.IDestudiante(), s.Media());
}
}
}
Ordenacin de colecciones
La salida generada por el programa ListaEstudiantes es
Nombre
Nombre
Nombre
Nombre
=
=
=
=
Interfaz Comparator
La interfaz Comparator ofrece una mayor flexibilidad a la hora de
ordenar. Por ejemplo, en el caso de la clase Estudiante descrita
anteriormente, los estudiantes slo se ordenaron mediante una
comparacin de sus notas medias. No fue posible ordenarlos por
nombre o algn otro criterio. Esta seccin muestra cmo aumentar la
flexibilidad de la ordenacin con la interfaz Comparator.
La interfaz Comparator forma parte del paquete java.util. Se utiliza
para comparar los objetos segn el orden personalizado en lugar del
orden natural. Por ejemplo, permite ordenar los objetos segn un
orden distinto del orden natural. Tambin se emplea para ordenar
objetos que no implementan la interfaz Comparable.
Para escribir un comparador Comparator personalizado, es necesario
agregar una implementacin del mtodo compare a la interfaz:
int compare(Object o1, Object o2)
9-13
Ordenacin de colecciones
Este mtodo compara dos argumentos de orden y devuelve un entero
negativo si el primer argumento es menor que el segundo. Si ambos son
iguales, devuelve un cero y si el primer argumento es mayor que el
segundo, devuelve un entero positivo. El Cdigo 9-6 muestra la
versin de la clase Estudiante.
Cdigo 9-6
1
2
3
4
5
6
7
||
8
9
10
11
12
13
14
15
16
17
18
Clase Estudiante
class Estudiante {
String Nombre, primerApellido;
int IDestudiante=0;
double Media=0,0;
public Estudiante(String Nombre, String primerApellido,
int IDestudiante, double Media) {
if (Nombre == null || primerApellido == null || IDestudiante == 0
Media == 0,0) throw new IllegalArgumentException();
this.Nombre = Nombre;
this.primerApellido = primerApellido;
this.IDestudiante = IDestudiante;
this.Media = Media;
}
public
public
public
public
}
Es posible crear varias clases para comparar a los estudiantes por Nombre,
primerApellido, IDestudiante o Media. La clase CompNombre del
Cdigo 9-7 implementa la interfaz Comparator para comparar a los
estudiantes por Nombre.
Cdigo 9-7
1
2
3
4
5
6
7
import java.util.*;
public class CompNombre implements Comparator {
public int compare(Object o1, Object o2) {
return
(((Estudiante)o1).Nombre.compareTo(((Estudiante)o2).Nombre));
}
}
La clase CompNota del Cdigo 9-8 de la pgina 9-15 implementa la
interfaz Comparator para comparar a los estudiantes segn su nota
media.
9-14
Ordenacin de colecciones
Cdigo 9-8
1
2
3
4
5
6
7
8
9
10
11
import java.util.*;
public class CompNota implements Comparator {
public int compare(Object o1, Object o2) {
if (((Estudiante)o1).Media == ((Estudiante)o2).Media)
return 0;
else if (((Estudiante)o1).Media < ((Estudiante)o2).Media)
return -1;
else
return 1;
}
}
La clase ComparatorTest del Cdigo 9-9 prueba el comparador
CompNombre. En la lnea 4, observe que el comparador de nombre se
pasa como parmetro a TreeSet.
Cdigo 9-9
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
Programa conComparatorTest.
import java.util.*;
public class ComparatorTest {
public static void main(String[] args) {
Comparator c = new CompNombre();
TreeSet estudianteSet = new TreeSet(c);
estudianteSet.add(new Estudiante("Miguel", "Herraiz",101, 4,0));
estudianteSet.add(new Estudiante("Juan", "Lino",102, 2,8));
estudianteSet.add(new Estudiante("Jaime", "Marcos",103, 3,6));
estudianteSet.add(new Estudiante("Clara", "Genio",104, 2,3));
Object[] estudianteArray = estudianteSet.toArray();
Estudiante s;
for(Object obj : estudianteArray){
s = (Estudiante) obj;
System.out.printf("Nombre = %s %s ID = %d Media = %.1f\n",
s.Nombre(), s.primerApellido(), s.IDestudiante(), s.Media());
}
}
}
Este programa generara la siguiente salida:
Nombre
Nombre
Nombre
Nombre
=
=
=
=
9-15
Genricos
Genricos
Las clases coleccin utilizan los tipos Object para admitir diferentes tipos de
entradas y salidas. Es necesario convertir el tipo de objeto explcitamente para
poder recuperar un objeto. Ello no garantiza la seguridad del tipo.
Aunque la infraestructura de colecciones existente admite las colecciones
homogneas (es decir, colecciones con un tipo de objeto, por ejemplo
Date), no haba ningn mecanismo para evitar la insercin de otros
tipos de objetos en la coleccin. Para poder recuperar un objeto, casi
siempre haba que convertirlo.
Este problema se ha resuelto con la funcionalidad de los genricos. Dicha
funcionalidad se ha introducido con la plataforma Java SE 5.0. Proporciona
informacin para el compilador sobre el tipo de coleccin utilizado. As, la
comprobacin del tipo se resuelve de forma automtica en el momento de la
ejecucin. Esto elimina la conversin explcita de los tipos de datos para su
uso en la coleccin. Gracias al autoboxing de los tipos primitivos, es posible
utilizar tipos genricos para escribir cdigo ms sencillo y comprensible.
Antes de los tipos genricos, el cdigo podra ser similar al mostrado en el
Cdigo 9-10:
Cdigo 9-10 Uso de colecciones no genricas
ArrayList list = new ArrayList();
list.add(0, new Integer(42));
int total = ((Integer)list.get(0)).intValue();
En el Cdigo 9-10, se necesita una clase envoltorio Integer para la
conversin del tipo mientras se recupera el valor del nmero entero
de list. En el momento de la ejecucin, el programa debe controlar el
tipo para list.
Al aplicar los tipos genricos, ArrayList debe declararse como
ArrayList<Integer> para informar al compilador sobre el tipo de
coleccin que se va a utilizar. Al recuperar el valor, no se necesita
una clase envoltorio Integer. El uso de tipos genricos con el cdigo
original del Cdigo 9-10 se muestra en el Cdigo 9-11:
Cdigo 9-11 Uso de colecciones genricas
ArrayList<Integer> list = new ArrayList<Integer>();
list.add(0, new Integer(42));
int total = list.get(0).intValue();
9-16
Genricos
La funcin de autoboxing encaja muy bien con el API de tipos genricos.
Con autoboxing, el cdigo de ejemplo podra escribirse tal como se
muestra en el Cdigo 9-12.
Cdigo 9-12 Uso de autoboxing con colecciones
ArrayList<Integer> list = new ArrayList<Integer>();
list.add(0, 42);
int total = list.get(0);
El Cdigo 9-12 utiliza la declaracin e instanciacin genricas para
declarar y crear una instancia de tipo ArrayList con objetos de tipo
Integer. Por tanto, al agregar un tipo que no sea Integer a la lista de
arrays se genera un error de compilacin.
Nota: Los tipos genricos se habilitan de forma predeterminada desde
la plataforma Java SE 5.0. Es posible deshabilitar los tipos genricos
mediante la opcin -source 1.4 del comando javac.
import java.util.*;
public class EjemploSetGen {
public static void main(String[] args) {
Set<String> set = new HashSet<String>();
set.add("one");
set.add("second");
set.add("3rd");
// Esta lnea genera un error de compilacin
set.add(new Integer(4));
// Duplicado, no se agrega
set.add("second");
System.out.println(set);
}
}
9-17
Genricos
9-18
Genricos
Este programa produce la siguiente salida:
El delantero es henry
El lateral derecho es ronaldo
El portero es cech
9-19
Clase no genrica
Clase genrica
Declaracin
de clase
Declaracin
public ArrayList
de constructor (int capacity)
public ArrayList
(int capacity)
Declaracin
de mtodo
ArrayList list1;
ArrayList list2;
Ejemplos de
declaraciones
de instancias
9-20
Figura 9-3
9-21
CuentaAhorro
Figura 9-4
CuentaCorriente
9-22
Reto de la invarianza
Considere el cdigo contenido en el Cdigo 9-16.
Cdigo 9-16 Invarianza de la asignacin de colecciones de tipos
diferentes
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import com.mibanco.domain.*;
import java.util.*;
public class ProbarInvarianza {
public static void main(String[] args) {
List<Cuenta> la;
List<CuentaCorriente> lc = new ArrayList<CuentaCorriente>();
List<CuentaAhorro> ls = new ArrayList<CuentaAhorro>();
//si lo siguiente fuese posible...
la = lc;
la.add(new CuentaCorriente("Fred"));
//lo siguiente tambin debera ser posible...
la = ls;
la.add(new CuentaCorriente("Fred"));
//por tanto...
CuentaAhorro sa = ls.get(0); //vaya!!
}
}
De hecho, la=lc es ilegal. Por tanto, a pesar de que CuentaCorriente
es una Cuenta, ArrayList<CuentaCorriente> no equivale a
ArrayList<Cuenta>.
Para que la garanta de seguridad de tipo siempre sea vlida, debe ser
imposible asignar una coleccin de un tipo a una coleccin de un tipo
distinto, incluso si el segundo tipo es una subclase del primero.
Esto va en contra del polimorfismo tradicional y, a primera vista,
parece restar flexibilidad a las colecciones genricas.
9-23
Respuesta de la covarianza
Considere el cdigo que aparece en el Cdigo 9-17.
Cdigo 9-17 Uso de tipos covariantes
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import com.mibanco.domain.*;
import java.util.*;
public class ProbarCovarianza {
public static void printNames(List <? extends Cuenta> lea) {
for (int i=0; i < lea.size(); i++) {
System.out.println(lea.get(i).getName());
}
}
public static void main(String[] args) {
List<CuentaCorriente> lc = new ArrayList<CuentaCorriente>();
List<CuentaAhorro> ls = new ArrayList<CuentaAhorro>();
printNames(lc);
printNames(ls);
//pero...
List<? extends Object> leo = lc; //Bien
leo.add(new CuentaCorriente("Fred"));//Error de compilacin!
}
}
Los comodines ofrecen una cierta flexibilidad al trabajar con colecciones
genricas. El mtodo printNames se declara con un argumento que incluye
un comodn. El comodn "?" de List <? extends Cuenta> podra
interpretarse como "cualquier tipo de lista de elementos desconocidos que
sean de tipo Cuenta o de una subclase de Cuenta". El lmite superior
(Cuenta) indica que los elementos de la coleccin pueden asignarse de
forma segura a una variable Cuenta. Por tanto, las dos colecciones de
los subtipos Cuenta pueden pasarse al mtodo printNames.
Esta respuesta de covarianza est designada para su lectura, no para que
se escriba en ella. Debido al principio de la invarianza, es ilegal agregar a
una coleccin que contenga un comodn con la palabra clave extends.
9-24
import java.util.*;
public class GenericsWarning {
public static void main(String[] args) {
List list = new ArrayList();
list.add(0, new Integer(42));
int total = (Integer) list.get(0);
}
}
9-25
9-26
Iteradores
Iteradores
Es posible explorar (iterar) una coleccin mediante un iterador. La interfaz
Iterator bsica permite explorar hacia delante en cualquier coleccin.
En el caso de la iteracin en un conjunto, el orden no es determinista.
El orden de la iteracin en una lista avanza hacia delante por los
elementos de la lista. Un objeto List tambin admite un iterador
ListIterator, que permite explorar la lista hacia atrs e insertar o
modificar los elementos de la lista.
Nota: El orden del conjunto es determinista si el conjunto es una instancia
de una clase que garantiza el orden. Por ejemplo, si el conjunto es una
instancia de TreeSet, que implementa SortedSet, el orden del conjunto
es determinista.
El Cdigo 9-19 muestra el uso de un iterador:
Cdigo 9-19 Uso de iteradores
1
2
3
4
5
6
9-27
Iteradores
La Figura 9-5 muestra un diagrama de las interfaces Iterator genricas
para el API Collections.
interface
Iterator<E>
+hasNext() : boolean
+next() : E
+remove()
interface
ListIterator<E>
+hasPrevious() : boolean
+previous() : E
+add(element : E)
+set(element : E)
Figura 9-5
9-28
9-29
9-30
List<Asignatura> asignaturas=...;
List<Profesor> profesores=...;
List<Curso> listaCursos = new ArrayList<Curso>();
for (Asignatura asig: asignaturas) {
for (Profesor prof: profesores) {
listaCursos.add(new Curso(asig, prof));
}
}
Mdulo 10
10-1
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
Otros recursos
Otros recursos
Otros recursos: Los documentos siguientes proporcionan informacin
complementaria sobre los temas tratados en este mdulo:
10-2
Bates, Sierra. Head First Java, First Edition. OReilly Media. 2003.
10-3
10-4
Clase Properties
Clase Properties
Un objeto de la clase Properties contiene una asignacin entre
nombres de propiedades (String) y valores (String). Tiene dos
mtodos principales para recuperar el valor de una propiedad:
getProperty(String) y getProperty(String, String); el segundo
permite especificar un valor predeterminado que se devuelve si la
propiedad designada no existe.
El conjunto entero de nombres de propiedades puede iterarse con el
mtodo propertyNames. Llamando a getProperty con cada nombre, se
pueden recuperar todos los valores.
Finalmente, es posible almacenar y recuperar conjuntos de propiedades
de cualquier flujo de E/S con los mtodos store y load.
El Cdigo 10-2 enumera el conjunto completo de propiedades que existen
cuando se ejecuta el programa:
Cdigo 10-2 Recuperacin de las propiedades del sistema
1
2
3
4
5
6
7
8
import java.util.Properties;
public class TestProperties {
public static void main(String[] args) {
Properties props = System.getProperties();
props.list(System.out);
}
}
El cdigo de la lnea 6 recupera el conjunto de propiedades del sistema,
mientras que la lnea 7 imprime las propiedades con el mtodo list de la
clase Properties.
java -DmyProp=theValue TestProperties
ste es un extracto de la salida:
java.runtime.name=Java(TM) SE Runtime Environment
sun.boot.library.path=C:\jse\jdk1.6.0\jre\bin
java.vm.version=1.6.0-b105
java.vm.vendor=Sun Microsystems Inc.
java.vm.name=Java HotSpot(TM) Client VM
file.encoding.pkg=sun.io
user.country=US
myProp=theValue
10-5
Flujos de bytes
Flujos de caracteres
Flujos fuente
InputStream
Reader
Flujos sumidero
OutputStream
Writer
10-6
Flujos de bytes
Flujos de bytes
En las prximas secciones se describen los principales flujos de bytes.
Mtodos InputStream
Los tres mtodos siguientes proporcionan acceso a los datos del flujo de
entrada:
int read()-{}int read(byte[] buffer)
int read(byte[] buffer, int offset, int length)
El primer mtodo devuelve un valor int, que contiene un byte ledo en el
flujo o un -1, que indica la condicin de fin de archivo. Los otros dos
mtodos leen el flujo en un array de bytes y devuelven el nmero de
bytes ledos. Los dos argumentos int del tercer mtodo indican un
subintervalo del array destino que es preciso rellenar.
Nota: En aras de la eficacia, lea siempre los datos en el bloque ms grande
posible que resulte prctico o utilice flujos en bfer.
void close()
Cuando haya terminado con un flujo, cirrelo. Si dispone de una pila
de flujos, utilice flujos filtrados para cerrar el flujo de la parte superior
de la pila. Con ello se cerrarn tambin los flujos inferiores.
int available()
Este mtodo indica el nmero de bytes inmediatamente disponibles
para su lectura en el flujo. Es posible que una operacin de lectura real
despus de esta llamada devuelva ms bytes.
long skip(long n)
Este mtodo descarta el nmero especificado de bytes del flujo.
boolean markSupported()
void mark(int readlimit)
void reset()
10-7
Flujos de bytes
Estos mtodos pueden utilizarse para realizar operaciones de exploracin
en un flujo, si ste las admite. El mtodo markSupported() devuelve
true si los mtodos mark() y reset() funcionan con ese flujo en
concreto. El mtodo mark(int) indica que ha de marcarse la posicin
actual del flujo y que es preciso asignar un bfer con suficiente capacidad
para albergar como mnimo el nmero de bytes especificado en el
argumento. El parmetro del mtodo mark(int) especifica el nmero
de bytes que pueden releerse llamando a reset(). Tras varias
operaciones read() consecutivas, la llamada al mtodo reset()
devuelve el flujo de entrada al punto marcado. Si se sobrepasa la
capacidad del bfer, reset() no tienen ningn significado.
Mtodos OutputStream
Los mtodos siguientes escriben en el flujo de salida:
void write(int)
void write(byte[] buffer)
void write(byte[] buffer, int offset, int length)
Al igual que con los flujos de entrada, intente siempre escribir los datos en
el bloque ms grande posible que resulte prctico.
void close()
Cierre los flujos de salida cuando haya terminado de utilizarlos. Si dispone
de una pila y cierra el flujo superior, con l se cerrarn todos los dems.
void flush()
A veces un flujo de salida acumula escrituras antes de confirmarlas.
El mtodo flush() permite forzar las escrituras.
10-8
Flujos de caracteres
Flujos de caracteres
En las prximas secciones se describen los principales flujos de caracteres.
Mtodos Reader
Los tres mtodos siguientes proporcionan acceso a los datos de caracteres
del lector:
int read()
int read(char[] cbuf)
int read(char[] cbuf, int offset, int length)
El primer mtodo devuelve un valor int, que contiene un carcter
Unicode ledo en el flujo o un -1, que indica la condicin de fin de
archivo. Los otros dos mtodos leen un array de caracteres y devuelven
el nmero de bytes ledos. Los dos argumentos int del tercer mtodo
indican un subintervalo del array destino que es preciso rellenar.
Nota: En aras de la eficacia, utilice el bloque ms grande posible que
resulte prctico.
void close()
boolean ready()
long skip(long n)
boolean markSupported()
void mark(int readAheadLimit)
void reset()
Estos mtodos son anlogos a las versiones del flujo de entrada.
10-9
Flujos de caracteres
Mtodos Writer
Los mtodos siguientes escriben en el escritor:
void
void
void
void
void
write(int c)
write(char[]
write(char[]
write(String
write(String
cbuf)
cbuf, int offset, int length)
string)
string, int offset, int length)
Al igual que los flujos de salida, los escritores incluyen los mtodos close
y flush.
void close()
void flush()
10-10
Flujos de nodos
Flujos de nodos
En el kit JDK de Java, hay tres tipos fundamentales de nodos (Tabla 10-2):
Archivos
Es posible crear nuevas clases de flujos de nodos, pero para ello hay que
gestionar llamadas de funciones nativas a un controlador de dispositivos
y la operacin no es porttil. La Tabla 10-2 muestra los flujos de nodos.
Tabla 10-2 Tipos de flujos de nodos
Tipo
Flujos de caracteres
Flujos de bytes
Archivo
FileReader
FileWriter
FileInputStream
FileOutputStream
Memoria:
array
CharArrayReader
CharArrayWriter
ByteArrayInputStream
ByteArrayOutputStream
Memoria:
cadena
StringReader
StringWriter
N/D
Tubera
PipedReader
PipedWriter
PipedInputStream
PipedOutputStream
Ejemplo sencillo
El Cdigo 10-3 lee los caracteres del archivo mencionado en el
primer argumento de la lnea de comandos y los escribe en el
archivo designado en el segundo. De este modo, copia el archivo.
As es como puede llamarse al programa:
java PruebaFlujosNodos archivo1 archivo2
Cdigo 10-3 Programa PruebaFlujosNodos
1
2
3
4
import java.io.*;
public class PruebaFlujosNodos {
public static void main(String[] args) {
10-11
Flujos de nodos
5
try {
6
FileReader input = new FileReader(args[0]);
7
try {
8
FileWriter output = new FileWriter(args[1]);
9
try {
10
char[]
buffer = new char[128];
11
int
charsRead;
12
13
// lee el primer bfer
14
charsRead = input.read(buffer);
15
while ( charsRead != -1 ) {
16
// escribe el bfer en el archivo de
salida
17
output.write(buffer, 0, charsRead);
18
19
// lee el bfer siguiente
20
charsRead = input.read(buffer);
21
}
22
23
} finally {
24
output.close();}
25
} finally {
26
input.close();}
27
} catch (IOException e) {
28
e.printStackTrace();
29
}
30
}
31 }
Por fcil que haya resultado, gestionar el bfer es una tarea tediosa y
susceptible de errores. Sin embargo, hay una clase que gestiona el bfer y
permite leer los flujos lnea por lnea. Se denomina BufferedReader y
pertenece a un tipo de flujos conocidos como flujos de procesamiento.
10-12
Flujos en bfer
Flujos en bfer
El Cdigo 10-4 realiza la misma funcin que el programa del Cdigo 10-3
de la pgina 10-11, pero utiliza BufferedReader y BufferedWriter.
Cdigo 10-4 Programa PruebaFlujosBufer
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
import java.io.*;
public class PruebaFlujosBufer {
public static void main(String[] args) {
try {
FileReader input = new FileReader(args[0]);
BufferedReader bufInput = new BufferedReader(input);
try {
FileWriter output = new FileWriter(args[1]);
BufferedWriter bufOutput= new BufferedWriter(output);
try {
String line;
// lee la primera lnea
line = bufInput.readLine();
while ( line != null ) {
// escribe la lnea en el archivo de salida
bufOutput.write(line, 0, line.length());
bufOutput.newLine();
// lee la lnea siguiente
line = bufInput.readLine();
}
} finally {
bufOutput.close();
}
} finally {
bufInput.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
Este programa se desarrolla del mismo modo que el anterior. En lugar de
leer un bfer, lee una lnea cada vez y utiliza la variable line para
conservar la cadena (String) devuelta por el mtodo readLine (lneas de
la 14 a la 20), lo cual resulta ms eficaz. La lnea 7 concatena el objeto
lector del archivo en un flujo lector en bfer. El usuario manipula el flujo
del extremo exterior de la concatenacin (bufInput), que a su vez
manipula el flujo del extremo interior (input).
10-13
Fuente
de datos
Programa
FileInputStream
BufferedInputStream
DataInputStream
Sumidero
de datos
Programa
FileOutputStream
BufferedOutputStream
DataOutputStream
10-14
Flujos de procesamiento
Flujos de procesamiento
Un flujo de procesamiento realiza una especie de conversin en otro flujo.
Tambin se conoce como flujo filtrado. Un flujo de entrada filtrado se crea
con una conexin a un flujo de entrada existente. El objetivo de esta
operacin es que, al intentar leer el objeto flujo de entrada filtrado, se
suministren los caracteres que inicialmente provenan del otro objeto flujo
de entrada. De este modo, es posible dar a los datos sin formato una
forma ms prctica para la aplicacin. La Tabla 10-3 muestra los flujos
de procesamiento incorporados que incluye el paquete java.io.
Tabla 10-3 Lista de flujos de procesamiento por tipo
Tipo
Flujos de caracteres
Flujos de bytes
BufferedReader
BufferedWriter
BufferedInputStream
BufferedOutputStream
Filtrado
FilterReader
FilterWriter
FilterInputStream
FilterOutputStream
InputStreamReader
OutputStreamWriter
*Serializacin de objetos
ObjectInputStream
ObjectOutputStream
Conversin de datos
DataInputStream
DataOutputStream
Recuento
LineNumberReader
LineNumberInputStream
Exploracin
PushbackReader
PushbackInputStream
Impresin
PrintWriter
PrintStream
10-15
SequenceInputStream
PushbackInputStream
FilterInputStream
BufferedInputStream
StringBufferInputStream
LineNumberInputStream
ByteArrayInputStream
FilterOutputStream
BufferedOutputStream
PrintStream
PipedOutputStream
ByteArrayOutputStream
10-16
ClasesBufferedInputStreamyBufferedOutputStream
Los flujos filtrados de las clases BufferedInputStream y
BufferedOutputStream sirven para aumentar la eficacia de las
operaciones de E/S.
Mtodos DataInputStream
Los mtodos DataInputStream son los siguientes:
byte readByte()
long readLong()
double readDouble()
10-17
Mtodos DataOutputStream
Los mtodos DataOutputStream son los siguientes:
void writeByte(byte)
void writeLong(long)
void writeDouble(double)
Los mtodos DataInputStream se emparejan con los mtodos
DataOutputStream.
Estos flujos poseen mtodos de lectura y escritura de cadenas, pero no
los utilizan, ya que se han rechazado y sustituido por los lectores y
escritores que se describen ms adelante.
10-18
10-19
10-20
Serializacin
Serializacin
Almacenar un objeto en algn tipo de espacio de almacenamiento
permanente recibe el nombre de persistencia. Se dice que un objeto
tiene capacidad de persistencia cuando puede almacenarse en un disco o
cinta o enviarse a otra mquina para guardarlo en memoria o en disco.
Los objetos no persistentes existen nicamente durante la ejecucin de
la mquina virtual Java.
La serializacin es un mecanismo para guardar un objeto en forma de
secuencia de bytes y, cuando se precisa ms adelante, reconstruir la
secuencia en una copia del objeto.
Para que los objetos de una clase especfica sean serializables, la clase
debe implementar la interfaz java.io.Serializable. Esta interfaz no
tiene mtodos y slo sirve como marcador o indicador de que la clase
que implementa la interfaz puede serializarse.
10-21
Serializacin
El Cdigo 10-5 muestra un ejemplo de una clase que implementa la
interfaz Serializable.
Cdigo 10-5 Ejemplo de la interfaz Serializable
1
2
3
4
5
Escritura
El fragmento de cdigo que contiene el Cdigo 10-6 enva una instancia
de un objeto java.util.Date a un archivo.
Cdigo 10-6 Clase SerializeDate
1
2
3
4
10-22
import java.io.*;
import java.util.Date;
public class SerializeDate {
Serializacin
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
SerializeDate() {
Date d = new Date ();
try {
FileOutputStream f =
new FileOutputStream ("date.ser");
ObjectOutputStream s =
new ObjectOutputStream (f);
s.writeObject (d);
s.close ();
} catch (IOException e) {
e.printStackTrace ();
}
}
public static void main (String args[]) {
new SerializeDate();
}
}
Lectura
Leer un objeto es tan fcil como escribirlo, pero con una salvedad: el
mtodo readObject() devuelve el flujo como tipo Object y, por lo tanto,
debe convertirse en el nombre de clase correcto antes de la ejecucin de
los mtodos de esa clase. El Cdigo 10-7 ilustra el procedimiento de
deserializacin de los datos de un flujo.
Cdigo 10-7 Clase DeSerializeDate
1
2
3
4
5
6
7
8
9
10
11
import java.io.*;
import java.util.Date;
public class DeSerializeDate {
DeSerializeDate () {
Date d = null;
try {
FileInputStream f =
new FileInputStream ("date.ser");
10-23
Serializacin
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
ObjectInputStream s =
new ObjectInputStream (f);
d = (Date) s.readObject ();
s.close ();
} catch (Exception e) {
e.printStackTrace ();
}
System.out.println(
"Deserialized Date object from date.ser");
System.out.println("Date: "+d);
}
public static void main (String args[]) {
new DeSerializeDate();
}
}
10-24
LineNumberReader
CharArrayReader
StringReader
Reader
InputStreamReader
FileReader
PipedReader
FilterReader
PushbackReader
OutputStreamWriter
FileWriter
PrintWriter
PipedWriter
FilterWriter
10-25
10-26
10-27
Mdulo 11
11-1
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
Otros recursos
Otros recursos
Otros recursos: Los documentos siguientes proporcionan informacin
complementaria sobre los temas tratados en este mdulo:
11-2
Bates, Sierra. Head First Java, First Edition. OReilly Media. 2003.
E/S de consola
E/S de consola
La mayora de las aplicaciones necesitan interaccionar con el usuario.
Tal interaccin a menudo se lleva a cabo enviando texto a la consola
(normalmente mediante el teclado) y leyendo el texto de salida que
sta genera (normalmente en la ventana de terminal).
Java JDK permite realizar las operaciones de E/S de consola con tres
variables pblicas y estticas de la clase java.lang.System:
println(boolean)
println(char)
println(double)
println(float)
println(int)
println(long)
println(char[])
println(Object)
11-3
E/S de consola
11-4
try {
// Leer cada lnea de entrada y reproducirla
s = in.readLine();
while ( s != null ) {
System.out.println("Leer: " + s);
s = in.readLine();
}
E/S de consola
En la lnea 16 se lee la primera lnea de texto de la entrada estndar. El
bucle while (lneas 17 20) hace que se imprima la lnea actual y se lea
la lnea siguiente de manera iterativa. Es posible escribir este cdigo de
forma ms sucinta (pero tambin ms crptica) de la forma siguiente:
while ( (s = in.readLine()) != null ) {
System.out.println("Leer: " + s);
}
Dado que el mtodo readLine puede generar una excepcin de E/S,
es preciso rodear todo este cdigo de un bloque try-catch.
21
22
23
11-5
E/S de consola
Descripcin
%s
%d %o %x
%f %g
%n
%%
11-6
E/S de consola
import java.io.*;
import java.util.Scanner;
public class ScanTest {
public static void main(String [] args) {
Scanner s = new Scanner(System.in);
String param = s.next();
System.out.println("parmetro 1" + param);
int value = s.nextInt();
System.out.println("segundo parmetro" + value);
s.close();
}
}
11-7
File miArchivo;
miArchivo = new File("miarchivo.txt");
11-8
Nombres de archivo
Los mtodos siguientes devuelven nombres de archivo:
String getName()
String getPath()
String getAbsolutePath()
String getParent()
Utilidades de directorio
Los mtodos siguientes proporcionan utilidades relacionadas con los
directorios:
boolean mkdir()
String[] list()
long lastModified()
long length()
boolean delete()
boolean exists()
boolean canWrite()
boolean canRead()
boolean isFile()
11-9
boolean isDirectory()
boolean isAbsolute()
boolean isHidden()
import java.io.*;
public class ReadFile {
public static void main (String [] args) {
// Crea el archivo
File file = new File(args[0]);
try {
// Crea un Reader en bfer
// para leer cada lnea del archivo.
BufferedReader in
= new BufferedReader(new FileReader(file));
String s;
11-10
11-11
11-12
11-13
Mdulo 12
Definir Swing.
Examinar componentes.
12-1
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
Otros recursos
Otros recursos
Otros recursos: Los documentos siguientes proporcionan informacin
complementaria sobre los temas tratados en este mdulo:
El uso de toda la funcionalidad de JFC/Swing requiere ms horas de
prctica y estudio. He aqu algunas referencias para ampliar los
conocimientos sobre esta materia:
12-2
Bates, Sierra. Head First Java, Second Edition. OReilly Media. 2005.
Otros recursos
12-3
Otros recursos
Qu es Swing
Swing es un API formado por un conjunto de componentes mejorados
que sustituyen a los de las herramientas AWT originales ms una serie de
componentes avanzados. Estos componentes permiten crear interfaces de
usuario con el tipo de funcionalidad que se espera de las aplicaciones
modernas. Entre ellos se incluyen rboles de elementos, tablas,
editores de texto avanzados y barras de herramientas flotantes.
Swing incluye tambin caractersticas especiales. Por ejemplo, permite
escribir un programa que adopte el estilo de interfaz (look and feel) de la
plataforma de base o que utilice un estilo de interfaz comn desarrollado
especialmente para el lenguaje Java (Metal). De hecho, puede crear una
interfaz con un estilo totalmente personalizado o modificar un estilo ya
existente e incorporarlo a su programa, bien en el propio cdigo o bien
mediante la seleccin de un estilo de interfaz concreto en el momento de
la ejecucin.
Nota: La expresin estilo de interfaz aparecer con frecuencia en este
mdulo. Es una traduccin libre de la expresin inglesa look-and-feel,
que se refiere al aspecto (look) que presentan los componentes y a la
forma en que reaccionan (feel) frente a acciones del usuario tales como
hacer clic con el ratn. Escribir cdigo para un estilo de interfaz significa
escribir las clases necesarias para definir una determinada apariencia y un
determinado comportamiento ante la introduccin de datos. La escritura
de estilos de interfaz no se incluye dentro de los objetivos de este mdulo.
12-4
Otros recursos
Arquitectura de Swing
Los componentes Swing se disean sobre la base de la arquitectura MVC
(modelo, vista y controlador). No sigue estrictamente los patrones de
MVC, pero tiene sus races en ellos.
Arquitectura MVC
Segn las premisas de MVC, el modelado de cualquier componente tiene
tres partes. En la Figura 12-1 se ilustra este tipo de arquitectura.
M
C
Figura 12-1 Arquitectura MVC
12-5
Otros recursos
Arquitectura de modelo-delegado
Los componentes Swing siguen un patrn de diseo de modelo-delegado.
En l, la vista y el controlador se funden en un objeto compuesto como
consecuencia de la estrecha dependencia que guardan entre s. El objeto
modelo se trata como un objeto diferente, como en la arquitectura MVC.
La Figura 12-2 de la pgina 12-6 ilustra la arquitectura de modelodelegado.
Componente
Objeto
de IU
Administrador
de IU
12-6
Paquetes de Swing
Paquetes de Swing
Swing posee un extenso conjunto de paquetes muy prcticos que lo
convierten en un API potente y flexible. En la Tabla 12-1 figura el
nombre de cada paquete y su finalidad.
Tabla 12-1 Paquetes de Swing
Nombre del paquete
Finalidad
javax.swing
javax.swing.border
javax.swing.event
javax.swing.undo
javax.swing.colorchooser
javax.swing.filechooser
javax.swing.table
javax.swing.tree
javax.swing.plaf
12-7
Paquetes de Swing
Tabla 12-1 Paquetes de Swing (Continuacin)
Nombre del paquete
Finalidad
javax.swing.plaf.basic
javax.swing.plaf.metal
javax.swing.plaf.multi
javax.swing.plaf.synth
javax.swing.text
javax.swing.text.html
Proporciona la clase
HTMLEditorKit y las clases
asociadas necesarias para crear
editores de texto HTML.
12-8
Contenedores
Se sitan en la parte superior de las jerarquas de elementos de la
interfaz grfica. Todos los componentes de una GUI se agregan a
estos contenedores. JFrame, JDialog, JWindow y JApplet son los
contenedores de nivel superior.
Componentes
Todos los componentes de la interfaz grfica se derivan de la
clase JComponent, por ejemplo, JComboBox, JAbstractButton y
JTextComponent.
Administradores de diseo
Son los responsables de determinar la posicin de los componentes
en un contenedor. BorderLayout, FlowLayout y GridLayout son
algunos ejemplos de estos administradores. Existen otros ms
complejos y sofisticados que proporcionan mayor control sobre la
interfaz.
12-9
Administradores de diseo
Figura 12-3 Composicin de una interfaz
12-10
Contenedores Swing
Contenedores Swing
Los contenedores Swing pueden clasificarse en tres grandes categoras:
Contenedores genricos
Contenedores especiales
12-11
Componentes Swing
Componentes Swing
Las interfaces basadas en Swing utilizan dos tipos de clases: clases de
interfaz grfica y clases de soporte. Las clases de interfaz grfica son de
carcter visual, descienden de JComponent y se denominan clases J. Las
clases de soporte proporcionan servicios y realizan funciones esenciales
para las clases de interfaz, pero no generan ninguna salida grfica.
Los componentes Swing proporcionan, sobre todo, elementos para
manejar texto, botones, etiquetas, listas, paneles, recuadros, barras de
desplazamiento, paneles de desplazamiento, mens, tablas y rboles. En
general, estos componentes pueden clasificarse en los grupos siguientes:
12-12
Botones
Componentes de texto
Mens
Componentes Swing
12-13
Mtodos
Borde
Border getBorder()
void setBorder(Border b)
Color de fondo y de
primer plano
Tipo de letra
void setFont(Font f)
Opacidad
Tamao mximo
y mnimo
void setMaximumSize(Dimension d)
void setMinimumSize(Dimension d)
Alineacin
Tamao preferido
12-14
Mtodos
Cantidad mxima de
filas
Modelo
ndice seleccionado
int getSelectedIndex()
Elemento seleccionado
Object getSelectedItem()
Cantidad de elementos
int getItemCount()
Mecanismo de
representacin
(renderer)
Editable
12-15
Administradores de diseo
Administradores de diseo
El administrador de diseo determina el tamao y la posicin de los
componentes dentro de un contenedor. Como alternativa al uso de estos
administradores, es posible asignar una posicin absoluta mediante
coordenadas de pxeles. La posicin absoluta se obtiene definiendo
la propiedad de diseo de un contenedor con el valor null. El
posicionamiento absoluto no puede trasladarse de una plataforma a otra.
Aspectos como el tamao de los tipos de letra y las pantallas hacen
que una posicin que sea correcta segn sus coordenadas, sea
potencialmente inservible en otras plataformas.
Al contrario que el posicionamiento absoluto, los administradores de
diseo tienen mecanismos para resolver las siguientes situaciones:
12-16
Administradores de diseo
BorderLayout es el diseo predeterminado para los objetos JFrame,
JDialog y JApplet. En la Figura 12-6 de la pgina 12-17 puede verse
una pantalla donde se utiliza un diseo de zonas. La pantalla muestra
cinco botones (JButton) que se han agregado a un marco (JFrame).
import java.awt.*;
import javax.swing.*;
public class EjemploZonas {
private JFrame f;
private JButton bn, bs, bw, be, bc;
public EjemploZonas() {
f = new JFrame("Border Layout");
bn = new JButton("Button 1");
bc = new JButton("Button 2");
bw = new JButton("Button 3");
bs = new JButton("Button 4");
be = new JButton("Button 5");
}
public void
f.add(bn,
f.add(bs,
f.add(bw,
f.add(be,
f.add(bc,
launchFrame() {
BorderLayout.NORTH);
BorderLayout.SOUTH);
BorderLayout.WEST);
BorderLayout.EAST);
BorderLayout.CENTER);
12-17
Administradores de diseo
23
24
25
26
27
28
29
30
31
f.setSize(400,200);
f.setVisible(true);
}
public static void main(String args[]) {
EjemploZonas guiWindow2 = new EjemploZonas();
guiWindow2.launchFrame();
}
}
12-18
import java.awt.*;
import javax.swing.*;
public class EjemploFila {
private JFrame f;
private JButton b1;
private JButton b2;
private JButton b3;
private JButton b4;
private JButton b5;
Administradores de diseo
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
public EjemploFila() {
f = new JFrame("Ejemplo GUI");
b1 = new JButton("Button 1");
b2 = new JButton("Button 2");
b3 = new JButton("Button 3");
b4 = new JButton("Button 4");
b5 = new JButton("Button 5");
}
public void launchFrame() {
f.setLayout(new FlowLayout());
f.add(b1);
f.add(b2);
f.add(b3);
f.add(b4);
f.add(b5);
f.pack();
f.setVisible(true);
}
public static void main(String args[]) {
EjemploFila guiWindow = new EjemploFila();
guiWindow.launchFrame();
}
} // fin de la clase EjemploFila
12-19
Administradores de diseo
En la Figura 12-8 se muestra un ejemplo de diseo BoxLayout. Al igual
que en el ejemplo de diseo en zonas, se han agregado cinco componentes
JButton a JFrame. En este caso se ha usado el parmetro Y-AXIS para
alinear los componentes.
12-20
Administradores de diseo
import java.awt.*;
import javax.swing.*;
public class EjemploCuadricula {
private JFrame f;
private JButton b1, b2, b3, b4, b5;
public EjemploCuadricula() {
f = new JFrame("Ejemplo Cuadricula");
b1 = new JButton("Button 1");
b2 = new JButton("Button 2");
b3 = new JButton("Button 3");
b4 = new JButton("Button 4");
b5 = new JButton("Button 5");
}
public void launchFrame() {
f.setLayout (new GridLayout(3,2));
12-21
Administradores de diseo
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
f.add(b1);
f.add(b2);
f.add(b3);
f.add(b4);
f.add(b5);
f.pack();
f.setVisible(true);
}
public static void main(String args[]) {
EjemploCuadricula grid = new EjemploCuadricula();
grid.launchFrame();
}
}
12-22
Administradores de diseo
12-23
Construccin programtica
Esta tcnica consiste en utilizar cdigo de programacin para crear la
interfaz. Resulta til para aprender los diferentes aspectos de la
creacin de interfaces grficas. Por otra parte, es muy laboriosa si
debe usarse en entornos de produccin.
Construccin programtica
En esta seccin se describe la creacin de una interfaz grfica sencilla
que muestra en la pantalla el saludo Hello World. En las lneas del
Cdigo 12-4 se crea un contenedor JFrame denominado
HelloWorldSwing. Posteriormente se agrega un componente JLabel
cuya propiedad Accessible Name est definida como Hello World.
Cdigo 12-4 Aplicacin HelloWorldSwing
1
2
3
4
5
6
7
8
9
10
11
12
13
12-24
import javax.swing.*;
public class HelloWorldSwing {
private static void createAndShowGUI() {
JFrame frame = new JFrame("HelloWorldSwing");
// Define la ventana.
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
JLabel label = new JLabel("Hello World");
// Agrega la etiqueta
frame.add(label);
frame.setSize(300,200);
// Muestra la ventana en la pantalla
frame.setVisible(true);}
JFrame
JLabel
FrameTitle
BorderLayout
Mtodos fundamentales
En esta seccin se explican los principales mtodos utilizados en el
Cdigo 12-4 de la pgina 12-24. Pueden dividirse en dos categoras:
1.
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE): este
mtodo define el comportamiento de JFrame cuando se
inicia una operacin de cierre. Hay cuatro formas posibles
de manejar esta situacin.
12-25
2.
1.
2.
3.
4.
b.
c.
b.
c.
12-26
SwingUtilites.invokeLater(new Runnable()):
En el lenguaje Java, los hilos se crean utilizando la interfaz
Runnable. Esta interfaz define un mtodo run que deben
implementar todas las clases que utilicen esa interfaz. El
mtodo invokeLater programa la tarea de creacin de la
interfaz grfica de forma que el hilo de control de eventos
ejecute el mtodo run de forma asncrona una vez que
hayan finalizado todos los eventos pendientes.
12-27
Mdulo 13
13-1
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
Otros recursos
Otros recursos
Otros recursos: Los documentos siguientes proporcionan informacin
complementaria sobre los temas tratados en este mdulo:
13-2
Bates, Sierra. Head First Java, Second Edition. OReilly Media. 2005.
Qu es un evento
Qu es un evento
Cuando el usuario realiza una accin en la interfaz grfica (pulsar el botn
del ratn o presionar una tecla), se genera un evento. Los eventos son
objetos que describen lo que ha ocurrido. Existen numerosas clases de
eventos diferentes para describir las distintas categoras de acciones de los
usuarios.
En la Figura 13-1 se muestra una vista abstracta del modelo de delegacin
de eventos. Cuando un usuario hace clic en un botn de la interfaz
grfica, JVM crea un objeto evento que se enva al controlador de eventos
correspondiente a ese botn mediante una llamada al mtodo
actionPerformed.
JFrame
JPanel
JButton
ActionEvent
Un controlador de eventos
actionPerformed(ActionEvent e) {
...
}
13-3
Qu es un evento
Controladores de eventos
Un controlador de eventos (handler) es un mtodo que recibe un objeto
evento, lo descifra y procesa la interaccin del usuario.
13-4
Modelo de delegacin
El modelo de delegacin de eventos se implement con la versin 1.1 del
kit de desarrollo de Java (JDK). Con este modelo, los eventos se envan
al componente desde el que se ha originado el evento, pero depende
de cada componente su propagacin a una o ms clases registradas
denominadas receptores de eventos (listeners). Estos receptores contienen
controladores que reciben el evento y lo procesan. De esta forma, el
controlador de eventos puede estar situado en un objeto independiente
del componente. Los receptores de eventos son clases que implementan
la interfaz EventListener. En la Figura 13-2 se ilustra el modelo de
delegacin de eventos.
JFrame
JPanel
Un controlador de eventos
JButton
ActionEvent
actionPerformed(ActionEvent e) {
...
}
13-5
import javax.swing.*;
import java.awt.*;
public class TestBoton {
private JFrame f;
private JButton b;
public TestBoton() {
f = new JFrame("Test");
b = new JButton("Pulsar");
b.setActionCommand("ButtonPressed");
}
public void launchFrame() {
b.addActionListener(new ButtonHandler());
f.add(b,BorderLayout.CENTER);
f.pack();
f.setVisible(true);
}
public static void main(String args[]) {
TestBoton guiApp = new TestBoton();
guiApp.launchFrame();
}
}
13-6
import java.awt.event.*;
public class ButtonHandler implements ActionListener {
public void actionPerformed(ActionEvent e) {
System.out.println("Se ha realizado una accin");
System.out.println("El comando del botn es: "
+ e.getActionCommand());
}
}
13-7
Categoras de eventos
El mecanismo descrito para recibir eventos de los componentes se ha
ilustrado en el contexto de un nico tipo de evento. Muchas de las clases
de eventos residen en el paquete java.awt.event, pero existen otras en
otros lugares del API. En la Figura 13-3 puede verse una jerarqua de
clases de eventos de las interfaces grficas segn el modelo UML.
java.awt.AWTEvent
java.util.EventObject
java.awt.event
ActionEvent
FocusEvent
AdjustmentEvent
KeyEvent
InputEvent
ComponentEvent
MouseEvent
ContainerEvent
ItemEvent
WindowEvent
TextEvent
Nombre de la interfaz
Mtodos
Accin
ActionListener
actionPerformed(ActionEvent)
Elemento
ItemListener
itemStateChanged(ItemEvent)
Ratn
MouseListener
mousePressed(MouseEvent)
mouseReleased(MouseEvent)
mouseEntered(MouseEvent)
mouseExited(MouseEvent)
mouseClicked(MouseEvent)
Movimiento
del ratn
MouseMotionListener
mouseDragged(MouseEvent)
mouseMoved(MouseEvent)
13-8
Nombre de la interfaz
Mtodos
Tecla
KeyListener
keyPressed(KeyEvent)
keyReleased(KeyEvent)
keyTyped(KeyEvent)
Activacin
FocusListener
focusGained(FocusEvent)
focusLost(FocusEvent)
Ajuste
AdjustmentListener
adjustmentValueChanged
(AdjustmentEvent)
Componente
ComponentListener
componentMoved(ComponentEvent)
componentHidden(ComponentEvent)
componentResized(ComponentEvent)
componentShown(ComponentEvent)
Ventana
WindowListener
windowClosing(WindowEvent)
windowOpened(WindowEvent)
windowIconified(WindowEvent)
windowDeiconified(WindowEvent)
windowClosed(WindowEvent)
windowActivated(WindowEvent)
windowDeactivated(WindowEvent)
Contenedor
ContainerListener
componentAdded(ContainerEvent)
componentRemoved(ContainerEvent)
Estado de
ventana
WindowStateListener
windowStateChanged(WindowEvent e)
Activacin
de ventana
WindowFocusListener
windowGainedFocus(WindowEvent e)
windowLostFocus(WindowEvent e)
Rueda del
ratn
MouseWheelListener
mouseWheelMoved(MouseWheelEvent e)
Mtodos de
entrada
InputMethodListener
caretPositionChanged
(InputMethodEvent e)
inputMethodTextChnaged
(InputMethodEvent e)
Jerarqua
HierarchyListener
hierarchyChanged(HierarchyEvent e)
Lmites de la
jerarqua
HierarchyBoundsListener
ancestorMoved(HierarchyEvent e)
ancestorResized(HierarchyEvent e)
AWT
AWTEventListener
eventDispatched(AWTEvent e)
Texto
TextListener
textValueChanged(TextEvent)
13-9
Ejemplo complejo
En esta seccin se examina un ejemplo de cdigo Java ms complejo.
En l se hace el seguimiento del movimiento del ratn cuando se
presiona su botn (arrastre del ratn). Tambin se detecta el movimiento
del ratn cuando no se pulsan sus botones (movimiento del ratn).
Los eventos provocados por el movimiento del ratn (con o sin presionar
un botn) pueden ser recogidos por objetos de una clase que implementa
la interfaz MouseMotionListener. Esta interfaz requiere dos mtodos,
mouseDragged() y mouseMoved(). Aunque slo est interesado en el
movimiento de arrastre, debe suministrar ambos mtodos, si bien el
cuerpo del mtodo mouseMoved() puede dejarse vaco.
Para incorporar otros eventos del ratn, incluidos los de la pulsacin
del botn, es preciso implementar la interfaz MouseListener. Esta
interfaz contiene varios eventos, incluidos mouseEntered, mouseExited,
mousePressed, mouseReleased y mouseClicked.
Cuando se produce un evento del ratn o el teclado, la informacin
sobre la posicin del ratn o sobre la tecla que se ha pulsado se
encuentra en el evento generado. En el ejemplo de control de eventos
incluido en el Cdigo 13-2 de la pgina 13-6 haba una clase llamada
ButtonHandler que manejaba los eventos. En el Cdigo 13-3, los
eventos se controlan dentro de una clase llamada TwoListener.
Cdigo 13-3 Ejemplo de la clase TwoListener
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
13-10
import javax.swing.*;
import java.awt.event.*;
import java.awt.*;
public class TwoListener
implements MouseMotionListener, MouseListener {
private JFrame f;
private JTextField tf;
public TwoListener() {
f = new JFrame("Ejemplo de dos receptores");
tf = new JTextField(30);
}
public void launchFrame() {
JLabel label = new JLabel("Hacer clic y arrastrar el ratn");
// Agregar componentes al marco
f.add(label, BorderLayout.NORTH);
f.add(tf, BorderLayout.SOUTH);
// Agregar este objeto como listener
f.addMouseMotionListener(this);
f.addMouseListener(this);
// Definir el tamao del marco y hacerlo visible
f.setSize(300, 200);
f.setVisible(true);
}
// stos son eventos de MouseMotionListener
public void mouseDragged(MouseEvent e) {
String s = "Arrastre del ratn: X = " + e.getX()
+ " Y = " + e.getY();
tf.setText(s);
}
public void mouseEntered(MouseEvent e) {
String s = "El ratn ha entrado";
tf.setText(s);
}
public void mouseExited(MouseEvent e) {
String s = "El ratn ha salido";
tf.setText(s);
}
// Mtodo de MouseMotionListener no utilizado.
// Todos los mtodos de un listener deben estar presentes en la
// clase, aunque no se utilicen.
public void mouseMoved(MouseEvent e) { }
// Mtodos de MouseListener no utilizados.
public void mousePressed(MouseEvent e) { }
public void mouseClicked(MouseEvent e) { }
public void mouseReleased(MouseEvent e) { }
public static void main(String args[]) {
TwoListener two = new TwoListener();
two.launchFrame();
}
}
Una serie de puntos mostrados en el Cdigo 13-3 de la pgina 13-10 se
describen en los prrafos siguientes.
13-11
13-12
13-13
Adaptadores de eventos
Implementar todos los mtodos en cada una de las interfaces
Listener exige gran cantidad de trabajo, particularmente en lo que se
refiere a las interfaces MouseListener y WindowListener.
Por ejemplo, la interfaz MouseListener declara los mtodos siguientes:
public
public
public
public
public
void
void
void
void
void
mouseClicked(MouseEvent event)
mouseEntered(MouseEvent event)
mouseExited(MouseEvent event)
mousePressed(MouseEvent event)
mouseReleased(MouseEvent event)
13-14
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class MouseClickHandler extends MouseAdapter {
// Slo necesitamos el mtodo mouseClicked, as que usamos
// un adaptador para no tener que escribir
// todos los mtodos de control de eventos
public void mouseClicked(MouseEvent e) {
// Realiza acciones al pulsar el botn del ratn...
}
}
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class TestInner {
private JFrame f;
private JTextField tf;
public TestInner() {
f = new JFrame("Ejemplo de clases internas");
tf = new JTextField(30);
}
class MyMouseMotionListener extends MouseMotionAdapter {
public void mouseDragged(MouseEvent e) {
String s = "Arrastre del ratn: X = "+ e.getX()
+ " Y = " + e.getY();
tf.setText(s);
}
}
public void launchFrame() {
JLabel label = new JLabel("Hacer clic y arrastrar el ratn");
// Agrega componentes al marco
f.add(label, BorderLayout.NORTH);
f.add(tf, BorderLayout.SOUTH);
// Agrega un Listener que utiliza una clase interna
f.addMouseMotionListener(new MyMouseMotionListener());
f.addMouseListener(new MouseClickHandler());
// Define el tamao del marco y lo hace visible
f.setSize(300, 200);
f.setVisible(true);
}
public static void main(String args[]) {
TestInner obj = new TestInner();
obj.launchFrame();
}
}
Control de los eventos generados por la interfaz grfica
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
13-15
13-16
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class TestAnonymous {
private JFrame f;
private JTextField tf;
public TestAnonymous() {
f = new JFrame("Ejemplo de clases annimas");
tf = new JTextField(30);
}
public void launchFrame() {
JLabel label = new JLabel("Hacer clic y arrastrar el ratn");
// Agrega componentes al marco
f.add(label, BorderLayout.NORTH);
f.add(tf, BorderLayout.SOUTH);
// Agrega un Listener que utiliza una clase annima
f.addMouseMotionListener(new MouseMotionAdapter() {
public void mouseDragged(MouseEvent e) {
String s = "Arrastre del ratn: X = "+ e.getX()
+ " Y = " + e.getY();
tf.setText(s);
}
}); // <- observar el parntesis de cierre
f.addMouseListener(new MouseClickHandler()); // No se muestra
// Define el tamao del marco y lo hace visible
f.setSize(300, 200);
f.setVisible(true);
}
public static void main(String args[]) {
TestAnonymous obj = new TestAnonymous();
obj.launchFrame();
}
}
13-17
Concurrencia en Swing
Concurrencia en Swing
Las aplicaciones que contienen una interfaz grfica necesitan varios
hilos para manejar esa interfaz de una forma eficiente.
13-18
Mdulo 14
14-1
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
Aspectos relevantes
Aspectos relevantes
!
?
14-2
Creacin de un men
Creacin de un men
JMenu difiere de otros componentes en que no es posible aadirlo a
contenedores normales y dejar que el administrador de diseo le asigne
formato. Los mens slo se pueden aadir a un contenedor de mens. En
esta seccin se describe el procedimiento siguiente para crear un men:
1.
2.
3.
Nota: Los mens emergentes son una excepcin a esta regla porque
se presentan en ventanas flotantes y, por lo tanto, no requieren un
diseo determinado.
14-3
Creacin de un men
f = new JFrame("JMenuBar");
mb = new JMenuBar();
f.setJMenuBar(mb);
14-4
Creacin de un men
f = new JFrame("Menu");
mb = new JMenuBar();
m1 = new JMenu("File");
m2 = new JMenu("Edit");
m3 = new JMenu("Help");
mb.add(m1);
mb.add(m2);
mb.add(m3);
f.setJMenuBar(mb);
14-5
Creacin de un men
14-6
Creacin de un men
14-7
Colores
Para definir los colores de un componente se utilizan dos mtodos:
setForeground()
setBackground()
Ambos mtodos utilizan un argumento que es una instancia de la clase
java.awt.Color. Pueden utilizarse colores constantes, denominados
Color.red, Color.blue, etc. La gama completa de colores predefinidos
se encuentra en la pgina de la documentacin relativa a la clase Color.
Otra solucin consiste en construir un objeto Color especfico y definir el
color con una combinacin de tres enteros expresados en bytes (0255),
uno por cada color primario: rojo, azul y verde. Por ejemplo:
Color purple = new Color(255, 0, 255);
JButton b = new JButton(Purple);
b.setBackground(purple);
14-8
Mdulo 15
Hilos
Objetivos
El estudio de este mdulo le proporcionar los conocimientos necesarios
para:
15-1
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
Aspectos relevantes
Aspectos relevantes
!
?
15-2
Hilos
Hilos
Una forma simple de ver un PC sera considerarlo como un dispositivo
dotado de una CPU que realiza los clculos, una memoria que contiene
el programa ejecutado por la CPU y una memoria que contiene los datos
con los que opera el programa. Segn esta perspectiva, slo se lleva a cabo
un trabajo. Una forma ms completa de ver los sistemas informticos
modernos incluye la posibilidad de realizar ms de un trabajo al
mismo tiempo.
No debe preocuparse ahora de cmo se consigue el rendimiento para el
procesamiento multitarea, tenga en cuenta nicamente las implicaciones
desde el punto de vista de la programacin. Llevar a cabo varios trabajos
es como tener varios sistemas de computacin. En lo que respecta a
este mdulo, un hilo, o contexto de ejecucin, es el encapsulamiento de
una CPU virtual con su propio cdigo y datos de programa. La clase
java.lang.Thread permite crear y controlar los hilos.
Nota: A lo largo del mdulo, utilizaremos el trmino Thread para
referirnos a la clase java.lang.Thread e hilo para referirnos a los
contextos de ejecucin.
Un hilo o contexto de ejecucin se compone de tres partes fundamentales:
CPU
Hilo o
contexto de ejecucin
Cdigo Datos
Hilos
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
15-3
Hilos
Varios hilos pueden compartir el mismo cdigo, con independencia de los
datos. Esto ocurre cuando ejecutan cdigo desde distintas instancias de la
misma clase.
De la misma forma, varios hilos pueden compartir los mismos datos, con
independencia del cdigo. Esto ocurre cuando comparten el acceso a un
mismo objeto.
En programacin Java, la CPU virtual se encapsula como una instancia de
la clase Thread. Cuando se construye un hilo, el cdigo y los datos que
definen su contexto vienen especificados por el objeto que se pasa a su
constructor.
15-4
Hilos
19
20
21
22
}
}
}
}
Nuevo hilo
Thread t
CPU
Clase
HelloRunner
Cdigo Datos
Instancia r
de HelloRunner
Hilos
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
15-5
Hilos
15-6
Hilos
Un objeto Thread puede pasar por diferentes estados a lo largo de su ciclo
de vida, como se muestra en la Figura 15-3.
Bloqueado
Muerto
Nuevo
Desbloqueado
Evento bloqueado
start()
Ejecutable
Planificador
En
ejecucin
run() Finaliza
Hilos
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
15-7
Hilos
El Cdigo 15-1 de la pgina 15-7 muestra el uso del bloque try y catch.
Thread.sleep() y otros mtodos que detienen la ejecucin de los hilos
durante un tiempo pueden ser interrumpidos. Los hilos pueden llamar al
mtodo interrupt de otro hilo, lo que seala al hilo detenido con una
excepcin InterruptedException.
sleep es un mtodo static de la clase Thread, ya que acta sobre el hilo
actual y se hace referencia a l como Thread.sleep(x). El argumento
del mtodo sleep indica la cantidad mnima de milisegundos que el
hilo debe estar inactivo. La ejecucin del hilo no se reanuda hasta que
finalice este periodo, a menos que sea interrumpido, en cuyo caso
reanudar la ejecucin antes.
15-8
Hilos
9
10
11
12
13
Hilos
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
15-9
Hilos en espera
Existen mecanismos para bloquear la ejecucin de un hilo de forma
temporal. Luego, es posible reanudarla como si nada hubiese ocurrido.
El hilo da la apariencia de haber ejecutado una instruccin con mucha
lentitud.
Mtodo Thread.sleep()
El mtodo sleep proporciona una forma de detener un hilo durante un
periodo de tiempo. Tenga presente que el hilo no necesariamente reanuda
su ejecucin en el momento en que finaliza el periodo de espera. La razn
es que puede haber otro hilo en ejecucin en ese momento y no se
detendr a menos que se produzca una de las siguientes situaciones:
15-10
Mtodo join
El mtodo join hace que el hilo actual espere hasta que finalice el hilo en
el que se ha realizado la llamada a join. Por ejemplo:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
Mtodo Thread.yield()
El mtodo Thread.yield() se utiliza para dar a otros hilos ejecutables la
oportunidad de ejecutarse. Si hay otros hilos ejecutables, yield sita el
hilo que hace la llamada en el grupo de ejecutables y permite a otro hilo
del grupo ejecutarse. Si no hay otros hilos ejecutables, yield no hace
nada.
La llamada sleep da a otros hilos de menor prioridad la opcin de
ejecutarse. El mtodo yield ofrece a otros hilos ejecutables la
oportunidad de ejecutarse.
Hilos
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
15-11
15-12
Hilos
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
15-13
Problema
Imaginemos una clase que representa una pila. En principio, esta clase
podra aparecer como:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15-14
Hilos
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
15-15
Cdigo o
comportamiento
Datos o
estado
15-16
Cdigo o
comportamiento
Datos o
estado
Cdigo o
comportamiento
Datos o
estado
Hilos
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
15-17
15-18
Hilos
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
15-19
Muerto
Desbloqueado
start()
Ejecutable
Evento bloqueado
Planificador
Bloqueo adquirido
En
ejecucin
run() Finaliza
Sincronizado
Bloqueado en el
grupo de bloqueo
del objeto
Interbloqueo
En programas donde hay varios hilos compitiendo por acceder a
diferentes recursos, puede producirse una situacin conocida como
interbloqueo. Se produce cuando un hilo est esperando a adquirir un
bloqueo retenido por otro hilo, pero el otro hilo est esperando a su
vez otro bloqueo retenido por el primer hilo. En esta situacin, ninguno
de los dos hilos puede proseguir la ejecucin hasta que el otro haya
pasado el fin de su bloque synchronized. Como ninguno puede
proseguir, ninguno puede pasar el final de su bloque.
El lenguaje Java ni detecta ni intenta evitar esta situacin. Es
responsabilidad del programador asegurarse de que no pueda producirse
un interbloqueo. Una regla habitual para impedir que se produzca es:
si dispone de mltiples objetos a los que quiere proporcionar acceso
sincronizado, tome una decisin global sobre el orden en el que obtendr
los bloqueos y respete ese orden a lo largo del programa. Libere los
bloqueos en orden inverso a aquel con el que se han obtenido.
15-20
Ejemplo
Imaginemos la existencia de dos hilos, uno de ellos es usted y el otro un
taxista. Usted necesita tomar un taxi a un determinado destino y el taxista
quiere hacer una carrera. Por tanto, los dos tienen una tarea que cumplir.
Problema
Usted espera entrar en el taxi y descansar cmodamente hasta que el
taxista le comunique que han llegado a su destino. Sera muy molesto,
tanto para usted como para el taxista, preguntar cada 2 segundos: ya
hemos llegado? Entre una carrera y otra, el taxista quiere echar un sueo
en el coche hasta que haya otro pasajero que pida sus servicios, pero
no quiere tener que despertar cada 5 minutos para comprobar si hay
algn pasajero en la parada de taxis. Por tanto, ambos hilos preferiran
realizar su tarea de la forma ms relajada posible.
Solucin
Usted y el taxista necesitan disponer de alguna forma de comunicar sus
necesidades el uno al otro. Mientras usted est ocupado recorriendo la
calle hacia la parada de taxis, el taxista duerme plcidamente en el
vehculo. Cuando notifica al taxista que quiere utilizar sus servicios, el
taxista despierta y empieza a conducir, mientras que usted se relaja.
Cuando llegan a su destino, el taxista le indica que debe salir del
vehculo e ir a trabajar. A continuacin el taxista tiene que esperar y
vuelve echarse una siesta hasta que llegue otro cliente.
Hilos
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
15-21
15-22
Muerto
Desbloqueado
start()
Ejecutable
Evento bloqueado
En
ejecucin
Planificador
Bloqueo adquirido
Sincronizado
Bloqueado en el
grupo de bloqueo
del objeto
run() Finaliza
wait()
[Ha de tener el bloqueo]/
Libera el bloqueo
notify() o
interrupt()
Bloqueado en el
grupo de espera
del objeto
Hilos
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
15-23
15-24
Hilos
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
15-25
Hilo Producer
El hilo producer (productor) genera nuevos caracteres que deben
colocarse en la pila. En el Cdigo 15-2 se muestra la clase Producer.
Cdigo 15-2 Clase Produce
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
package mod13;
public class Producer implements Runnable {
private SyncStack theStack;
private int num;
private static int counter = 1;
public Producer (SyncStack s) {
theStack = s;
num = counter++;
}
public void run() {
char c;
for (int i = 0; i < 200; i++) {
c = (char)(Math.random() * 26 +A);
theStack.push(c);
System.out.println(Productor + num + : + c);
try {
Thread.sleep((int)(Math.random() * 300));
} catch (InterruptedException e) {
// hacer caso omiso
}
}
} // FIN del mtodo run
} // FIN de la clase Producer
Este ejemplo genera 200 caracteres aleatorios por pares y los introduce en
la pila con una demora aleatoria de 0-300 milisegundos entre cada
introduccin. Cada carcter introducido se enva a la consola, junto con
un identificador para el cual se ejecuta el hilo productor.
15-26
Hilo Consumer
El hilo consumer (consumidor) retira los caracteres de la pila. En el
Cdigo 15-3 se muestra el uso de la clase Consumer.
Cdigo 15-3 Clase Consumer
1
package mod13;
2
3
public class Consumer implements Runnable {
4
private SyncStack theStack;
5
private int num;
6
private static int counter = 1;
7
8
public Consumer (SyncStack s) {
9
theStack = s;
10
num = counter++;
11
}
12
13
public void run() {
14
char c;
15
for (int i = 0; i < 200; i++) {
16
c = theStack.pop();
17
System.out.println(Consumidor + num + : +
c);
18
19
try {
20
Thread.sleep((int)(Math.random() * 300));
21
} catch (InterruptedException e) {
22
// hacer caso omiso
23
}
24
}
25
} // FIN del mtodo run
26
27 } // FIN de la clase Consumer
Este ejemplo extrae 200 caracteres de la pila con una demora aleatoria de
0-300 segundos entre cada intento. Cada carcter escrito en maysculas se
enva a la consola junto con un identificador que seala cul es el hilo
consumer que se est ejecutando.
Ahora examinemos la construccin de la clase Stack. Va a crear una
pila de tamao aparentemente ilimitado utilizando la clase ArrayList.
Con este diseo, sus hilos slo tienen que comunicarse en funcin de
que la pila est vaca o no.
Hilos
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
15-27
Clase SyncStack
El bfer de un objeto SyncStack recin construido debera estar vaco.
Puede utilizar el cdigo siguiente para construir la clase:
public class SyncStack {
private List<Character> buffer
= new ArrayList<Character>(400);
public synchronized char pop() {
// cdigo de extraccin (pop) aqu
}
public synchronized void push(char c) {
// cdigo de introduccin (push) aqu
}
}
No hay constructores. Se considera una buena prctica incluir un
constructor, pero aqu se ha omitido para mayor brevedad.
Mtodo pop
Veamos ahora los mtodos push y pop. Deben estar sincronizados
(synchronized) para proteger el bfer compartido. Asimismo, si la pila
est vaca en el mtodo pop, el hilo que se est ejecutando debe esperar.
Cuando la pila del mtodo push deja de estar vaca, los hilos en espera
reciben la notificacin correspondiente. El Cdigo 15-4 contiene un
ejemplo del mtodo pop.
Cdigo 15-4 Mtodo pop
1
2
3
4
5
6
7
8
9
10
11
12
15-28
Mtodo push
El mtodo push es similar a pop. Afecta al bfer compartido y tambin
debe estar sincronizado. Asimismo, dado que push agrega un carcter al
bfer, es responsable de notificar a los hilos en espera que la pila ya no
est vaca. Esta notificacin se realiza con respecto al objeto stack.
Hilos
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
15-29
15-30
package mod13;
import java.util.*;
public class SyncStack {
private List<Character> buffer
= new ArrayList<Character>(400);
public synchronized char pop() {
char c;
while (buffer.size() == 0) {
try {
this.wait();
} catch (InterruptedException e) {
// hacer caso omiso...
}
}
c = buffer.remove(buffer.size()-1);
return c;
}
public synchronized void push(char c) {
this.notify();
buffer.add(c);
}
}
Ejemplo de SyncTest
Es preciso ensamblar el cdigo de producer, consumer y stack en clases
completas. Se necesitar efectuar una serie de pruebas para ver el
funcionamiento conjunto de todos estos componentes. Preste especial
atencin a la forma en que SyncTest crea nicamente un objeto stack
compartido por todos los hilos. En el Cdigo 15-7 se muestra la clase
SyncTest.
Cdigo 15-7 Clase SyncTest
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
package mod13;
public class SyncTest {
public static void main(String[] args) {
SyncStack stack = new SyncStack();
Producer p1 = new Producer(stack);
Thread prodT1 = new Thread (p1);
prodT1.start();
Producer p2 = new Producer(stack);
Thread prodT2 = new Thread (p2);
prodT2.start();
Consumer c1 = new Consumer(stack);
Thread consT1 = new Thread (c1);
consT1.start();
Consumer c2 = new Consumer(stack);
Thread consT2 = new Thread (c2);
consT2.start();
}
}
Hilos
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
15-31
15-32
Mdulo 16
Conexin en red
Objetivos
El estudio de este mdulo le proporcionar los conocimientos necesarios
para:
16-1
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
Aspectos relevantes
Aspectos relevantes
!
?
16-2
Conexin en red
Conexin en red
En esta seccin se describe el concepto de conexin en red mediante
sockets.
Sockets
Socket es el nombre con que se designan, en un modelo de programacin
concreto, los extremos de un enlace de comunicacin entre procesos.
Dada la popularidad de dicho modelo de programacin, el trmino
socket se ha aplicado a otros modelos, incluida la tecnologa Java.
Cuando varios procesos se comunican a travs de una red, la tecnologa
Java utiliza el modelo de flujos. Un socket puede contener dos flujos:
un flujo de entrada y un flujo de salida. Un proceso enva datos a otro
por la red escribiendo en el flujo de salida asociado al socket. Un
proceso lee los datos que ha escrito otro proceso leyndolos en el flujo
de entrada asociado al socket.
Una vez configurada la conexin de red, el uso de los flujos asociados a
esa conexin es similar al uso de cualquier otro flujo.
Configuracin de la conexin
Para establecer una conexin, debe haber una mquina que ejecute
un programa que espera conexin y otra que intente conectar con la
primera. Este principio se asemeja a un sistema telefnico, en el que un
interlocutor debe realizar la llamada mientras el otro espera a recibirla.
Conexin en red
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
16-3
Conexin en red
En este modulo se describen las conexiones de red TCP/IP. La Figura 16-1
muestra un ejemplo de conexin en red.
client.bar.com
18000
server.foo.com
3000
client.baz.com
18002
16-4
Conexin en red
Direccionamiento de la conexin
Cuando se realiza una llamada telefnica, hay que saber qu nmero
marcar. Cuando se establece una conexin en red, es necesario conocer la
direccin o el nombre de la mquina remota. Adems, una conexin en
red requiere un nmero de puerto, que podra considerarse como el
nmero de una extensin telefnica. Una vez conectado al ordenador
correcto, debe definir la finalidad concreta de la conexin. Por lo tanto,
del mismo modo que puede utilizar el nmero de una extensin
telefnica para hablar con el departamento de contabilidad, puede
emplear un nmero de puerto especfico para comunicarse con el
programa de contabilidad.
Nmeros de puerto
Los nmeros de puerto de los sistemas TCP/IP son nmeros de 16 bits
cuyos valores oscilan entre 065535. En la prctica, los nmeros de puerto
inferiores a 1024 estn reservados para servicios predefinidos y no se
deben utilizar si no es para comunicarse con uno de esos servicios
(como telnet, correo Simple Mail Transport Protocol [SMTP], ftp, etc.).
El sistema operativo del host es el encargado de asignar a los clientes
nmeros de puerto no utilizados, mientras que el programador es
quien especifica los nmeros de puerto del servidor, que se utilizan
para identificar un servicio determinado.
Cliente y servidor deben estar de acuerdo de antemano sobre el
puerto que van a emplear. Si los nmeros de puerto que usan las dos
partes del sistema no concuerdan, la comunicacin no tiene lugar.
Conexin en red
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
16-5
Conexin en red
Servidor
ServerSocket
(n de puerto)
ServerSocket.accept()
Registrarse en
este servicio
Esperar
conexin
Socket()
Flujo de salida
Cliente
Socket (host,
n de puerto)
(intento de conexin)
Flujo de salida
Flujo de entrada
Flujo de entrada
Socket.close()
Socket.close()
16-6
import java.net.*;
import java.io.*;
public class ServidorSimple {
public static void main(String args[]) {
ServerSocket s = null;
// Registra el servicio en el puerto 5432
try {
s = new ServerSocket(5432);
} catch (IOException e) {
e.printStackTrace ();
}
// Ejecuta ininterrumpidamente el bucle de recepcin/aceptacin
while (true) {
try {
// Espera aqu y recibe una conexin
Socket s1 = s.accept();
// Obtiene el flujo de salida asociado al socket
OutputStream s1out = s1.getOutputStream();
BufferedWriter bw = new BufferedWriter(
new OutputStreamWriter(s1out));
// Enva la cadena
bw.write(Bienvenido a la red\n);
// Cierra la conexin, pero no el socket del servidor
bw.close();
s1.close();
} catch (IOException e) {
e.printStackTrace ();
}
}
}
}
Conexin en red
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
16-7
16-8
import java.net.*;
import java.io.*;
public class ClienteSimple {
public static void main(String args[]) {
try {
// Establece la conexin con el servidor en el puerto 5432
// aqu se utiliza el host local
Socket s1 = new Socket(127.0.0.1, 5432);
// Obtiene un flujo de entrada del socket
InputStream is = s1.getInputStream();
// Lo adorna con un flujo de entrada de datos
DataInputStream dis = new DataInputStream(is);
// Lee la entrada y la presenta en pantalla
System.out.println(dis.readUTF());
// Al terminar, basta con cerrar el flujo y la conexin
br.close();
s1.close();
} catch (ConnectException connExc) {
System.err.println(Imposible conectar.);
} catch (IOException e) {
// ignorar
}
}
}
Apndice A
A-1
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
A-2
Funcionalidad/lgica
empresarial
Datos
A-3
Solicitud SQL
Respuesta SQL
Servidor de base
de datos
(back-end)
Base
de datos
Figura A-2
A-4
Servidor de
base de datos
(back-end)
Base de datos
Figura A-3
A-5
Aplicacin Java
API JDBC
API de
controladores
JDBC
Administrador de
controladores JDBC
Controlador JDBC,
controlador de
protocolos tipo n
SGBD
Figura A-4
A-6
Bases
de datos
Controladores JDBC
Las aplicaciones Java utilizan el API JDBC para conectarse a una base de
datos mediante un controlador de base de datos. Casi todos los motores
de base de datos llevan asociados distintos tipos de controladores JDBC.
JavaSoft ha definido cuatro tipos de controladores. Si desea obtener
ms informacin, consulte
http://java.sun.com/products/jdbc/jdbc.drivers.html.
Puente JDBC-ODBC
El puente JDBC-ODBC es un controlador JDBC que traduce las llamadas
JDBC a operaciones ODBC. Este puente permite que todos los SGBD
compatibles con ODBC interaccionen con aplicaciones Java. La Figura A-5
muestra las capas de una aplicacin JDBC con puente ODBC.
Aplicacin
Administrador de controladores JDBC
Puente JDBC-ODBC
Administrador de controladores ODBC
Bibliotecas de controladores ODBC
Figura A-5
A-7
Sistemas distribuidos
Sistemas distribuidos
Hay tecnologas Java para crear entornos de sistemas distribuidos. Dos
de ellas, de amplia difusin, son la llamada a mtodos remotos (RMI) y la
arquitectura de agente de solicitudes de objetos (CORBA). La tecnologa RMI
es anloga a la llamada a procedimiento remoto (RPC) y es la preferida de los
programadores de Java. CORBA ofrece flexibilidad en entornos de
desarrollo heterogneo.
La funcin RMI permite que un programa que se ejecuta en un equipo
cliente haga llamadas de mtodo a un objeto situado en un servidor
remoto. Ofrece al programador la posibilidad de distribuir los sistemas en
un entorno de red. El diseo orientado a objetos exige que todas las tareas
las ejecute el objeto ms apropiado para cada una. La funcin RMI va
ms all al permitir que la tarea se ejecute en el equipo ms adecuado.
La llamada a mtodos remotos define un conjunto de interfaces remotas
que se pueden utilizar para crear objetos remotos. Un cliente puede llamar
a mtodos de un objeto remoto con la misma sintaxis que utiliza para
llamar a mtodos de un objeto local. El API RMI proporciona clases que
gestionan toda la comunicacin subyacente y los requisitos de referencias
de parmetros para acceder a mtodos remotos.
En todas las arquitecturas de sistemas distribuidos, un proceso de
aplicacin o un servidor de objetos (daemon) se anuncia registrndose en un
servicio de nombres en el equipo local (nodo). En el caso del API RMI,
un daemon de servicio de nombres denominado registro RMI se ejecuta
en un puerto RMI que, de forma predeterminada, escucha a travs del
puerto IP 1099 de ese host. El registro RMI contiene una tabla interna
de referencias de objetos remotos. Por cada objeto remoto, la tabla
contiene un nombre de registro y una referencia a ese objeto. Es posible
almacenar varias instancias del mismo objeto instancindolo y
enlazndolo varias veces al registro con nombres distintos.
A-8
RMI
RMI
Cuando un cliente RMI enlaza un objeto remoto a travs del registro,
recibe una referencia local al objeto remoto instanciado mediante su
interfaz y se comunica con el objeto utilizando esa referencia. Pueden
existir referencias locales al mismo objeto remoto en varios clientes;
las variables y mtodos que contiene el objeto remoto se comparten.
El applet empieza por importar los paquetes RMI adecuados y crear
una referencia al objeto remoto. Una vez que establece ese vnculo,
el applet puede llamar a los mtodos del objeto remoto como si
estuvieran disponibles de manera local.
Arquitectura RMI
La arquitectura RMI se compone de tres capas: la capa de transporte,
la de referencia remota y la capa stubs/esqueleto. La Figura A-6
muestra estas capas.
Figura A-6
Aplicacin
Aplicacin
Cliente RMI
Servidor RMI
Stubs
Esqueleto
Capa de
referencia remota
Conexin
virtual
Capa de
referencia remota
Capa de
transporte
Conexin
de red
Capa de
transporte
A-9
RMI
La capa de transporte crea y mantiene las conexiones fsicas entre el
cliente y el servidor. Administra el flujo de datos que pasa por las
capas de referencia remota (RRL) en el lado cliente y el lado servidor.
La capa de referencia remota proporciona un protocolo de referencia
independiente para crear una red virtual entre cliente y servidor.
Establece las conexiones con la capa de transporte inferior y la capa
stubs/esqueleto superior.
Un stub es un proxy del lado cliente que representa al objeto remoto.
El cliente interacciona con el stub mediante interfaces. Ante el cliente,
el stub aparece con la forma de un objeto local. El esqueleto del lado
servidor acta como una interfaz entre la capa RRL y el objeto
implementado en el lado servidor.
A-10
1.
2.
3.
4.
5.
6.
7.
CORBA
CORBA
CORBA es una especificacin que define cmo interaccionan los objetos
distribuidos. La especificacin CORBA est controlada por el Object
Management Group (OMG), un consorcio abierto de ms de 700
compaas que trabajan conjuntamente para definir estndares
abiertos para los sistemas distribuidos. Para obtener ms informacin,
consulte la pgina siguiente:
http://www.omg.org
Los objetos CORBA se pueden escribir en casi todos los lenguajes de
programacin, como C y C++. Estos objetos tambin pueden existir en
casi todas las plataformas, incluidas Solaris, Microsoft Windows,
openVMS, Digital UNIX, HP-UX y muchas ms. En otras palabras,
una aplicacin Java ejecutada en una plataforma Microsoft Windows
puede interaccionar en red con objetos C++ de un sistema UNIX.
La independencia del lenguaje es posible gracias a la construccin de
interfaces con objetos mediante el lenguaje IDL (Interface Definition
Language, lenguaje de definicin de interfaz). ste permite describir todos
los objetos CORBA de la misma manera; el nico requisito es un puente
entre el lenguaje nativo (C/C++, COBOL, Java) y el lenguaje IDL.
En el ncleo de CORBA est el agente de solicitudes de objetos (ORB). Este
agente es el componente principal para la transmisin de informacin
entre el cliente y el servidor de la aplicacin CORBA. El agente ORB
gestiona las solicitudes de organizacin, establece conexin con el
servidor, enva los datos y ejecuta las solicitudes en el lado servidor.
El mismo proceso tiene lugar cuando el servidor desea devolver los
resultados de la operacin. Los agentes ORB de distintos proveedores
se comunican en red (utilizando TCP/IP, aunque no en todos los casos)
mediante el protocolo IIOP (Internet Inter ORB Protocol, protocolo Inter-ORB
de Internet), que es parte de la norma CORBA 2.0.
A-11
CORBA
A-12
1.
2.
3.
4.
5.
6.
CORBA
A-13
A-14
Propiedades: son los atributos del bean a los que se hace referencia
por nombre. Estas propiedades se suelen leer y escribir llamando a
mtodos del bean creados con este propsito. Algunos tipos de
propiedades afectan a los beans adyacentes, no slo al bean en que
se origina la propiedad.
Arquitectura de beans
Un bean est representado por una interfaz visible para el usuario.
El entorno debe conectarse a esta interfaz si quiere interaccionar con
el bean. Los beans constan de tres interfaces generales: eventos,
propiedades y mtodos. Dado que los beans dependen de su estado,
deben tener persistencia en el tiempo.
Eventos
Los eventos de un bean son un mecanismo para enviar mensajes
asncronos entre beans, y entre beans y contenedores. El bean utiliza
un evento para notificar a otro bean que realice una accin o para
informarle de un cambio de estado. El evento permite que los beans
se comuniquen cuando ocurre algo de inters; para ello, utilizan el
modelo de eventos introducido en el paquete JDK versin 1.1. El modelo
de eventos utilizado en Java 2 SDK es el mismo que el de la versin 1.1.
La comunicacin se divide en tres partes: el objeto evento, el receptor
del evento y la fuente del evento.
La arquitectura JavaBeans se comunica bsicamente haciendo uso de
interfaces de receptores de eventos que amplan EventListener.
Los desarrolladores de beans pueden disear sus propios tipos de eventos
e interfaces de receptores de eventos y lograr que los beans acten
como fuente si implementan los mtodos addXXXListener(EventObject
e) y removeXXXListener(EventObject e), donde XXX es el nombre
del tipo de evento. A continuacin, pueden definir otros beans como
destino de eventos implementando la interfaz XXXListener. El
sourceBean y el targetBean se unen llamando a
sourceBean.addXXXListener(targetBean).
Propiedades
Las propiedades definen las caractersticas del bean. Pueden cambiarse
durante el tiempo de ejecucin mediante los mtodos get y set que
llevan asociados.
Las propiedades pueden utilizarse para enviar comunicaciones sncronas
bidireccionales entre beans. Los beans tambin admiten cambios de
propiedad asncronos entre s utilizando una comunicacin de eventos
especial.
A-15
Mtodos
Los mtodos son operaciones que permiten interaccionar con un bean.
Los beans reciben notificacin de eventos cuando los llama el mtodo
fuente del evento correspondiente. Algunos mtodos estn especializados
y se ocupan de propiedades y eventos. Estos mtodos deben seguir
convenciones especiales de asignacin de nombre establecidas en la
especificacin de los beans. Hay otros mtodos que no estn relacionados
con eventos ni propiedades. Todos los mtodos pblicos de un bean
son accesibles para la infraestructura de beans y se pueden utilizar
para conectar un bean con otros beans.
Introspeccin de un bean
El proceso de introspeccin JavaBeans revela las propiedades, mtodos y
eventos de un bean. Las clases bean tienen propiedades si hay mtodos
que definen (set) u obtienen (get) un tipo de propiedad.
La interfaz BeanInfo, incluida en el API JavaBeans, permite a los
diseadores de beans revelar propiedades, eventos, mtodos y cualquier
informacin general sobre un bean. La interfaz BeanInfo ofrece varios
mtodos para acceder a la informacin del bean, aunque el desarrollador
tambin puede incluir archivos de descripcin privados que la clase
BeanInfo utiliza para definir la informacin del bean. De forma
predeterminada, se crea un objeto BeanInfo cuando la introspeccin se
ejecuta en el bean (Figura A-7).
Bean 1
Bean 4
Bean 2
Bean 5
Bean 3
Bean 6
Contenedor A
Figura A-7
A-16
Contenedor B
Restablecer beans.
A-17
Archivos JAR
Archivos JAR
JAR (archivo Java) es un formato de archivo independiente de la
plataforma que rene muchos archivos en uno. Es posible agrupar varios
applets Java y sus componentes (archivos .class, imgenes y sonidos)
en un archivo JAR y despus descargarlo a un navegador en una sola
transaccin HTTP (Hypertext Transfer Protocol), lo que aumenta
notablemente la velocidad de descarga. El formato JAR tambin puede
comprimirse para reducir el tamao del archivo y mejorar an ms la
velocidad de descarga. Adems, el autor del applet puede firmar
digitalmente cada entrada en un archivo JAR para autentificar su origen.
Es completamente compatible con versiones anteriores del cdigo del
applet y se puede ampliar.
La etiqueta applet de una pgina HTML se puede modificar fcilmente
para adaptarla a un archivo JAR. El archivo JAR del servidor se identifica
con el parmetro archive, que contiene el directorio del archivo JAR
con respecto a la ubicacin de la pgina HTML; por ejemplo:
<applet code="Animator.class"
archive="jars/animator.jar"
width="460" height="160" >
<param name="foo" value="bar">
</applet>
A-18
Etiquetas de documentacin
La herramienta javadoc analiza los archivos fuente en busca de lneas de
comentario que empiecen por /** y terminen por */. La herramienta
utiliza estos signos para documentar la declaracin a la que precede el
comentario.
La primera frase del comentario se denomina frase resumen y debe ser una
descripcin completa y concisa de la declaracin. El texto que sigue a la
frase resumen puede utilizarse para facilitar detalles sobre la declaracin,
como la informacin de uso. Pueden incluirse etiquetas HTML en
cualquier parte del texto, como la etiqueta <P> para separar prrafos,
<UL> para generar listas y <B> (etc.) para dar formato al texto.
Adems, javadoc utiliza etiquetas en el bloque de comentario para
identificar los elementos especiales de la declaracin, como el valor de
retorno de un mtodo. La tabla del encabezado anterior muestra un
conjunto de las etiquetas javadoc ms comunes, su significado y con
qu declaraciones se pueden utilizar.
A-19
Ejemplo
El siguiente ejemplo se utiliza en las pruebas de javadoc:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
A-20
/*
* This is an example using javadoc tags.
*/
package mypack;
import java.util.List;
/**
* This class contains a bunch of documentation tags.
* @author Bryan Basham
* @version 0.5(beta)
*/
public class DocExample {
/** A simple attribute tag. */
private int x;
/**
* This variable a list of stuff.
* @see #getStuff()
*/
private List stuff;
/**
* This constructor initializes the x attribute.
* @param x_value the value of x
*/
public DocExample(int x_value) {
this.x = x_value;
}
/**
* This method return some stuff.
* @throws IllegalStateException if no stuff is found
* @return List the list of stuff
*/
public List getStuff()
throws IllegalStateException {
if ( stuff == null ) {
throw new java.lang.IllegalStateException("ugh, no stuff");
}
return stuff;
}
}
Figura A-8
A-21
Figura A-9
A-22
Apndice B
B-1
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
Otros recursos
Otros recursos
Otros recursos: Los documentos siguientes proporcionan informacin
complementaria sobre los temas descritos en este apndice:
Folwer, Martin, con Kendall Scott. UML Distilled (2nd ed). Reading:
Addison Wesley Longman, Inc., 2000.
B-2
B-3
Descripcin
Uso
Casos de uso
Clases
Objetos
Actividades
Un diagrama de actividades es
bsicamente un organigrama con
smbolos nuevos. Representa el
flujo de actividades de un proceso
o algoritmo.
Colaboracin
B-4
Descripcin
Uso
Secuencia
Un diagrama de secuencia
presenta un proceso desde un
punto de vista orientado a objetos
mostrando cmo lo ejecuta un
conjunto de procesos o actores.
Estados
Componentes
Un diagrama de componentes
muestra los principales
componentes de software de un
sistema y cmo pueden integrarse.
Pueden contener componentes de
software no orientados a objetos,
como cdigo de procedimientos
tradicionales y documentos web.
Distribucin
Un diagrama de distribucin
muestra los nodos fsicos del
sistema.
B-5
Elementos generales
Elementos generales
En general, los diagramas UML representan conceptos con smbolos
(tambin denominados nodos) y relaciones entre conceptos con rutas
(tambin denominadas enlaces) que conectan los smbolos entre s. Estos
nodos y enlaces son especficos de cada diagrama. Por ejemplo, en los
diagramas de clases, los nodos representan clases de objetos y los enlaces
asociaciones entre clases y relaciones de generalizacin (herencia).
Hay otros elementos que completan estos diagramas, entre ellos:
paquetes, estereotipos, notas, restricciones y valores etiquetados.
Paquetes
En lenguaje UML, los paquetes permiten organizar los elementos de
modelado en grupos. Los paquetes UML constituyen un mecanismo de
agrupacin genrico y no deben asociarse directamente a paquetes de
tecnologa Java, aunque s pueden utilizarse para modelar paquetes Java.
La Figura B-1 muestra un diagrama de paquetes que contiene un grupo
de clases en un diagrama de clases.
Package container
shipping
Package name
domain
GUI
i
mp
or
t
Subpackage
Company
owns
0..*
Vehicle
por
reports
im
Truck
Package dependency
Figura B-1
B-6
RiverBarge
Model elements
Ejemplo de paquete
Elementos generales
B-7
Elementos generales
Estereotipos
Los creadores del lenguaje UML se dieron cuenta de que no podan
construir un lenguaje de modelado que satisficiera las necesidades de
todos los lenguajes de programacin y todos los modelados, as que
incorporaron en el lenguaje varios mecanismos que permitiesen a los
modeladores crear su propia semntica para los elementos de su modelo
(nodos y enlaces). La Figura B-2 muestra el uso de un identificador para el
estereotipo interface que declara que el nodo de clase Set es una
declaracin de la interfaz Java. Al igual que los nodos, los identificadores
de estereotipos pueden adornar las relaciones. Hay ms de cien
estereotipos estndar, pero tambin es posible crear estereotipos
personalmente para modelar la semntica propia.
Stereotype tag
interface
Set
Figura B-2
Ejemplo de estereotipo
Notas
Los creadores del lenguaje UML tambin incorporaron un mtodo
para introducir notas en los diagramas. La Figura B-3 muestra una
nota sencilla.
Annotation
Vehicle3
-load : double
-maxLoad : double
+getLoad() : double
+getMaxLoad() : double
+addBox(weight : double) : boolean
Figura B-3
weight in newtons
weight in kilograms
Ejemplo de nota
B-8
Elementos generales
Restricciones
Las restricciones permiten modelar algunas condiciones aplicables a
un nodo o un enlace. La Figura B-4 muestra varias restricciones. La
primera restriccin especifica que los objetos Jugador deben almacenarse
en una base de datos persistente. La restriccin siguiente especifica que
el capitn y el segundo capitn tambin deben ser miembros de la
plantilla del equipo. La ltima restriccin especifica el nmero mnimo
de jugadores por sexo.
{persistent}
Constraint
0..1
Player
roster
*
captain
*
co-captain
{member}
Team
{Female players not fewer than 3
and male players not fewer than 4}
Figura B-4
Ejemplo de restricciones
Valores etiquetados
La Figura B-5 muestra varios ejemplos de valores etiquetados que
permiten aadir nuevas propiedades a los nodos de un diagrama.
Tagged value
CalcGUI.java
{version=1.3}
Server
{processors=4}
Figura B-5
B-9
System name
System boundary
Banking System
ATM Login
Customer
include
ATM Withdrawal
extend
the customer
requests a balance
Teller
Customer
Determine
Balance
ATM
Customer
actor
BankTeller
Checking
Deposit for
Customer
extend
Dependency
Use case
node
the customer
asks for balance
Actor node
Figura B-6
B-10
Diagramas de clases
Diagramas de clases
Un diagrama de clases representa la estructura esttica de un sistema.
Estos diagramas se componen de clases y sus relaciones.
Nodos de clase
La Figura B-7 muestra varios nodos de clase. No es necesario modelar todos
los aspectos de una clase cada vez que sta se utiliza en un diagrama.
1
2
Company
3
InputStream
interface
{abstract}
Set
4
Vehicle
-load : double = 0.0
-maxLoad : double
+getLoad() : double
+getMaxLoad() : double
+addBox(weight : double) : boolean
Figura B-7
B-11
Diagramas de clases
La Figura B-8 muestra los elementos de un nodo de clase.
Attribute
name
Attribute Attribute
type
multiplicity
Attribute
initial value
Class name
Vehicle
- load : double = 0.0
- maxLoad : double
- destinations [1..*] : String
Attributes
constructor
+ Vehicle(max_load : double)
Access
modes
accessor
+ getLoad() : double
+ getMaxLoad() : double
Methods
mutator
+ setMaxLoad(max : double)
Abstract
methods
(in italics)
business logic
+ addBox(weight : double) : boolean
# calcEngineEfficiency() : double
# calcTripDistance() : double
Method
name
Figura B-8
Parameter
name
Parameter
type
Return
type
B-12
Diagramas de clases
Los atributos o mtodos pueden agruparse con estereotipos. Por ejemplo, por
motivos de claridad, es posible separar entre s los mtodos accedente,
mutador y de lgica de negocio. Adems, como no existe notacin UML
especfica para constructores, puede utilizarse el estereotipo constructor
para sealar los constructores en el compartimento de mtodos.
La Tabla B-2 muestra los smbolos de modo de acceso UML vlidos.
Tabla B-2 Modos de acceso definidos en UML y smbolos correspondientes
Modo de acceso
Smbolo
Privado
Paquete privado
Protegido
Pblico
-counter : int = 0
-instanceNumber : int
getTotalCount() : int
+getMyNumber() : int
Figura B-9
B-13
Diagramas de clases
Herencia
La Figura B-10 muestra la herencia de clases mediante la flecha de
relacin de generalizacin.
Account
-balance : double
constructors
+Account(init_balance : double)
Generalization
arrow
methods
+getBalance() : double
+deposit(amt : double)
+withdraw(amt : double) : boolean
SavingsAccount
Generalization
arrow
CheckingAccount
-interestRate : double
constructors
+SavingsAccount(init_balance : double,
interest_rate : double)
constructors
+CheckingAccount(init_balance : double)
+CheckingAccount(init_balance : double,
protect : SavingsAccount)
methods
+withdraw(amt : double) : boolean
B-14
Diagramas de clases
Realization arrow
HashMap
B-15
Diagramas de clases
Association direction
Multiplicity
Instructor
Multiplicity
0..*
Teaches
teacher
Course
class
Association roles
B-16
Diagramas de clases
En lenguaje de programacin Java, las asociaciones suelen representarse
en forma de un atributo de la clase al final de la relacin (especificada
por el indicador de direccin). Si la multiplicidad es superior a uno,
es necesario colocar los elementos en una serie o un array.
Adems, en la Figura B-12 de la pgina B-16 la asociacin entre un
profesor y un curso puede representarse en la clase Profesor del
modo siguiente:
public class Profesor {
private Curso[] classes = new Curso[MAXIMUM];
}
o de este otro:
public class Profesor {
private List classes = new ArrayList();
}
La segunda representacin es preferible si no se conoce el nmero
mximo de cursos que imparte un determinado profesor.
B-17
Diagramas de clases
Agregacin y composicin
Una agregacin es una asociacin en la que un objeto contiene un grupo de
partes que conforman el objeto completo (consulte la Figura B-13). Por
ejemplo, un coche es una agregacin de motor, ruedas, carrocera y chasis.
La composicin es una especializacin de la agregacin en la que las
partes no pueden existir independientemente del objeto completo.
Por ejemplo, una persona es una composicin de cabeza, dos brazos,
dos piernas y tronco. Si se elimina cualquiera de estas partes sin
intervencin quirrgica, la persona morir.
En el ejemplo de la Figura B-13, una liga deportiva, definida como
un acontecimiento deportivo que se organiza todos los aos en la
misma temporada, es una composicin de divisiones y calendarios.
Una divisin es una agregacin de equipos. Un equipo puede existir
independientemente de una determinada temporada. En otras palabras,
puede existir durante varias temporadas (ligas) seguidas. Por lo tanto,
el equipo puede seguir existiendo aunque se elimine una divisin.
Por su parte, un partido slo puede existir en el contexto del
calendario particular de una liga determinada.
Composition
Division
1..*
Team
League
1..*
Aggregation
Schedule
1..*
Game
B-18
Diagramas de clases
Clases de asociacin
Una asociacin entre dos clases puede tener propiedades y
comportamiento propios. Las clases de asociacin se utilizan para
modelar esta caracterstica. Por ejemplo, la Figura B-14 muestra que
quiz los jugadores tengan que inscribirse en una divisin particular
de una liga deportiva. La clase de asociacin est conectada al enlace
de asociacin mediante una lnea discontinua.
Division
Player
Registration
Association class
opponent1
-score : int
-forfeit : boolean
Game
B-19
Diagramas de clases
El lenguaje Java puede utilizarse de maneras diferentes para representar
una clase de asociacin. Una manera es codificar la clase de asociacin
como clase Java estndar. Por ejemplo, Inscripcin puede codificarse
de este modo:
public class Inscripcion {
private Division division;
private Jugador jugador;
// datos de inscripcin
// mtodos...
}
public class Division {
// datos
public Inscripcion retrieveInscripcion(Jugador p) {
// busca informacin de inscripcin del jugador
return new Inscripcion(this, p, ...);
}
// mtodos...
}
Otra tcnica consiste en codificar los atributos de la clase de asociacin
directamente en una de las clases asociadas. Por ejemplo, la clase
Partido puede incluir la informacin de tanteo de este modo:
public class Partido {
// primer adversario y detalles del tanteo
private Equipo adversario1;
private int adversario1_tanteo;
private boolean adversario1_abandono;
// segundo adversario y detalles del tanteo
private Equipo adversario2;
private int adversario2_tanteo;
private boolean adversario2_abandono;
// mtodos...
}
B-20
Diagramas de clases
League
1..*
1..*
Division
*
captain
*
co-captain
Association qualifier
index:int
Team
Schedule
{member}
roster
Association
constraint
0..1
Player
0..1
Game
B-21
Diagramas de objetos
Diagramas de objetos
Un diagrama de objetos representa la estructura esttica de un sistema en
un momento dado. Estos diagramas se componen de nodos de objeto,
asociaciones y, a veces, nodos de clase.
La Figura B-17 muestra una jerarqua de objetos que representa un
conjunto de equipos de una misma divisin en una liga de ftbol. Este
diagrama presenta una configuracin de objetos en un punto preciso del
sistema. Los nodos de objeto slo indican los atributos de instancia, ya
que los mtodos son elementos de la definicin de clase. Adems, un
diagrama de objetos no muestra necesariamente todos los objetos
asociados; slo tiene que ser representativo.
Object name
Object links
Object class
t1 : Team
name=Camden Windjammers
rank=1
record=<5,2>
Anonymous object
t2 : Team
: League
type=SOCCER
: Division
name=Rockport Seals
rank=4
record=<1,6>
schoolSize=SMALL
t3 : Team
name=Portland Panthers
rank=2
record=<4,3>
Object attributes
t4 : Team
name=Bangor Bangles
rank=3
record=<2,5>
B-22
Diagramas de objetos
La Figura B-18 muestra dos objetos, c1 y c2, acompaados de sus datos
de instancia. Hacen referencia al nodo de clase Count. La flecha de
dependencia indica que el objeto es una instancia de la clase Count. Los
objetos no incluyen el atributo counter porque tiene mbito de clase.
Count
-counter : int = 0
-serialNumber : int
instanceOf
instanceOf
cl : Count
c2 : Count
serialNumber=1
serialNumber=2
B-23
Diagramas de colaboracin
Diagramas de colaboracin
Un diagrama de colaboracin representa un comportamiento determinado
que comparten varios objetos. Estos diagramas se componen de objetos, sus
enlaces y los mensajes intercambiados que reflejan el comportamiento.
La Figura B-19 muestra un diagrama de colaboracin en el que un actor
inicia una secuencia de acceso en una aplicacin web mediante un servlet.
Anonymous
object
Actor
Message
..
T.
EC
1:
1.
1.
1:login
:RDBMS
L
SE
1.1:user:=login
:Login
Servlet
Link
at
re
2:
1.
1.
Internet User
:Login
Service
user
:User
Named
object
B-24
Diagramas de colaboracin
La Figura B-20 muestra un diagrama de colaboracin ms elaborado.
En este diagrama, un objeto client inicia una accin en un bean de sesin.
A continuacin, ste efecta dos modificaciones en la base de datos
con una sola transaccin.
client
customerDB
:Connection
3:c
re
ate
lob
al
ate
m
ate
teS
me
ea
:cr
nt(
3.1:create
sessionBean
...)
l
te(
a
a
c
d
lo
Up
ute
:Statement
c
xe e()
4:e clos
:
8
{transient}
local
Path stereotype
inventorDB
:Connection
t()
en
St
al
lob
5.1:create
6:e
9:c xecu
lo
los te
ca
e() Up
l
da
te(
1:create
...)
2:begin()
7:rollback()
10:destroy
tnx
:UserTransaction
:Statement
{transient}
Object constraint
{transient}
B-25
Diagramas de secuencia
Diagramas de secuencia
Un diagrama de secuencia representa una secuencia cronolgica de
mensajes intercambiados entre varios objetos para reflejar un
comportamiento determinado. Permite comprender el flujo de mensajes y
eventos que tiene lugar en un proceso o una colaboracin determinados.
En realidad, un diagrama de secuencia es slo una vista organizada en
el tiempo de un diagrama de colaboracin, como muestra la Figura B-19
de la pgina B-24.
La Figura B-21 muestra un diagrama de secuencia en el que un actor inicia
una secuencia de acceso en una aplicacin web mediante un servlet.
Este diagrama es equivalente al diagrama de colaboracin de la
Figura B-19 de la pgina B-24. Un aspecto importante de este tipo de
diagrama es que el transcurso del tiempo se representa de arriba a abajo.
El diagrama de secuencia muestra las interacciones temporales entre un
conjunto de objetos o roles. Los roles pueden ser explcitos o annimos y
suelen estar asociados a una clase. Los roles tambin pueden ser actores.
Anonymous
class role
Internet User
:Login
Servlet
:Login
Service
:RDBMS
"login"
user:=login
Activation
box
Lifeline
create
Message
Return
(with value)
user
:User
Object
created
Named
class role
B-26
Diagramas de secuencia
Observe las flechas de mensaje entre el servlet y el objeto service.
La flecha es perfectamente horizontal, lo que indica que el mensaje
se implementa probablemente con la llamada del mtodo local.
Observe tambin que la flecha de mensaje entre el actor y el servlet
est inclinada, lo que indica que el mensaje se intercambia entre
componentes de equipos diferentes. Puede tratarse, por ejemplo, de
un mensaje HTTP del navegador de web del usuario al contenedor
web que gestiona el servlet de acceso.
La Figura B-22 muestra un diagrama de secuencia ms elaborado. Este
diagrama es equivalente al diagrama de colaboracin de la Figura B-20 de
la pgina B-25.
Anonymous role
customerDB
:Connection
sessionBean
create
external
DBMS
inventorDB
:Connection
tnx
:UserTransaction
begin()
{transient}
{transient}
createStatement
create
:Statement
createStatement
create
Return
(Implicit)
{transient}
:Statement
SQL Update
SQLException("Update failed.")
rollback()
close() destroy
close() destroy
destroy
Object destroyed
B-27
Diagramas de secuencia
Este ejemplo muestra algunos detalles suplementarios sobre los
diagramas de secuencia. En primer lugar, la flecha de retorno no
siempre es importante. Est implcita al final de la barra de activacin.
Adems, los diagramas de secuencia pueden mostrar explcitamente la
creacin y destruccin de objetos. Cada rol lleva asociada una lnea de
tiempo que se extiende verticalmente desde la base del nodo de objeto.
Los roles situados en la parte superior del diagrama existan antes que
el mensaje de entrada (en el rol del extremo izquierdo). Los roles que
tienen una flecha de mensaje orientada al comienzo del nodo de rol con
el mensaje create se crean durante la ejecucin de la secuencia. La
destruccin de un objeto se representa con una gran aspa que pone fin a
la lnea de tiempo del rol.
Nota: Los diagramas de secuencia tambin pueden mostrar mensajes
asncronos. Este tipo de mensaje utiliza una lnea continua con una
punta de flecha:
B-28
Diagramas de estados
Diagramas de estados
Un diagrama de estados representa los estados y las respuestas de una
clase ante activadores externos e internos. Tambin puede utilizarse para
representar el ciclo de vida de un objeto. La definicin de un estado
de objeto depende del tipo de objeto y del nivel de profundidad que se
desee modelar.
Nota: Los diagramas de estados se conocen con varios nombres distintos,
como diagramas statechart y diagramas de transicin de estado.
La Figura B-23 muestra un ejemplo de diagrama de estados. Todos los
diagramas de estados deben disponer de un estado inicial (estado del
objeto en el momento de su creacin) y un estado final. Por definicin,
ningn estado puede pasar al estado inicial y el estado final no puede
pasar a ningn otro estado.
State node
Initial state
Transition
Final state
Blocked
New
Dead
unblocked
blocking event
start()
run() completes
Runnable
Scheduler
Running
B-29
Diagramas de estados
Transiciones
Una transicin consta de cinco elementos:
Event trigger
Guard condition
Action
Running
wait()
Target state
Blocked in
objects
wait pool
B-30
Diagramas de actividades
Diagramas de actividades
Un diagrama de actividades representa las actividades o acciones de
un proceso sin tener en cuenta los objetos que las realizan.
La Figura B-25 muestra los elementos de un diagrama de actividades.
Un diagrama de actividades es similar a un organigrama. Contiene
actividades separadas por transiciones. Cada diagrama de actividades
comienza por un solo estado inicial y finaliza en un solo estado final.
Start state
Parse XML file
Activity
Translate to HTML
Transition
Stop state
B-31
Diagramas de actividades
La Figura B-26 muestra las ramificaciones y bucles de los diagramas
de actividades. El diagrama modela la actividad de nivel superior de
la Comprobacin de disponibilidad de los productos de un pedido
de compra. El nodo de la rama superior forma un bucle simple. La
proteccin de la transicin situada debajo de la rama es true si en el
pedido hay ms productos que procesar. La transicin else detiene
esta actividad.
Branch
Verify availability
else
[o.hasMoreProducts()]
p=o.getNextProduct()
Guard
n=inventory.getCount(p)
else
o.putOnBackOrder(p)
[n>0]
inventory.setCount(p,n-1)
B-32
Diagramas de actividades
La Figura B-27 muestra un diagrama de actividades ms complejo.
Swimlanes
Customer
WebSalesAgent
Warehouse
Request Products
Fork
o:Order
[in progress]
Object
flow
o:Order
[pending]
Return confirmation
Join
Schedule backorder
Package products
Ship order
Close order
o:Order
[sent]
B-33
Diagramas de actividades
En el ejemplo de la Figura B-27 de la pgina B-33 se utilizan pasillos
para aislar al actor de un conjunto determinado de actividades. Estos
actores pueden incluir personas, sistemas o entidades empresariales.
Este diagrama tambin ilustra la posibilidad de modelar actividades
concurrentes. Por ejemplo, el cliente inicia la compra de uno o varios
productos en el sitio web de la empresa. Despus espera mientras el
programa AgenteVentasWeb empieza a tramitar el pedido de compra.
La barra separadora divide una sola transicin en dos o ms transiciones.
La barra de unin correspondiente contiene el mismo nmero de
transiciones entrantes.
B-34
Diagramas de componentes
Diagramas de componentes
Un diagrama de componentes representa la organizacin y las
dependencias entre los componentes de la implementacin de un
software.
La Figura B-28 muestra tres tipos de iconos que pueden representar
componentes de software. El ejemplo 1 es un icono genrico, el ejemplo 2
es un icono que representa un archivo fuente y el ejemplo 3 es un icono
que representa un archivo que contiene cdigo ejecutable (o de objeto).
1
2
Applet.java
3
calculator.jar
Component
calculator.jar
Dependency
CalcApplet.class
CalcGUI.class
CalcModel.class
CalcApplet.java
CalcGUI.java
CalcModel.java
{version=1.0}
{version=1.3}
{version=2.1}
SCM version
B-35
Diagramas de componentes
CatalogHome
CatalogHome
Catalog
Home Stub
Catalog
Business
Delegate
Catalog
EJB Home
Catalog
Bean
CatalogRemote
Catalog
Remote Stub
CatalogRemote
CatalogRemote
Catalog
EJB Object
B-36
Diagramas de distribucin
Diagramas de distribucin
Un diagrama de distribucin representa la red de elementos de recursos
de procesamiento y la configuracin de los componentes informticos de
cada elemento fsico.
Un diagrama de distribucin se compone de nodos fsicos, componentes
informticos, dependencias de software y relaciones de comunicacin.
La Figura B-31 muestra un ejemplo en el que la mquina cliente se
comunica con un servidor web mediante el protocolo TCP/IP.
Hardware node
Client
Communication protocol
HTTP
TCP/IP
Browser
Web Server
index.html
Apache
<HTML>
</HTML>
serial port
Printer
Dependency
Component
Node name
B-37
Apndice C
Componentes Swing
Objetivos
El estudio de este apndice le proporcionar los conocimientos necesarios
para:
C-1
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
C-2
Interfaz de usuario
Componentes Swing
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
C-3
Contenedores genricos
Contenedores genricos
Los contenedores genricos son contenedores intermedios que se utilizan
en diversas circunstancias, por ejemplo: JPanel, JScrollPane, JToolBar,
JSplitPane y JTabbedPane. Todos estos componentes amplan la clase
JComponent. La Tabla C-2 contiene una breve descripcin de los
contenedores genricos.
Tabla C-2 Contenedores genricos
Contenedor
Interfaz de usuario
C-4
Contenedores genricos
Tabla C-2 Contenedores genricos (Continuacin)
Contenedor
Interfaz de usuario
Componentes Swing
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
C-5
Contenedores especiales
Contenedores especiales
JInternalFrame y JLayeredPane son ejemplos de contenedores
especiales. Estos contenedores desempean un papel especfico en
una interfaz de usuario. Los marcos internos estn concebidos para
funcionar dentro de paneles de escritorio. No son de nivel superior,
como JFrame. El contenedor JLayeredPane ayuda a especificar la
profundidad del componente, lo cual resulta til para presentar la
interfaz de usuario cuando se solapan componentes.
La Tabla C-3 describe brevemente los contenedores especiales.
Tabla C-3 Contenedores especiales
Contenedores
Interfaz de usuario
C-6
Contenedores especiales
Cuando se utilizan clases contenedor, es preciso tener en cuenta las reglas
siguientes:
DO_NOTHING_ON_CLOSE
HIDE_ON_CLOSE
DISPOSE_ON_CLOSE
EXIT_ON_CLOSE
Componentes Swing
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
C-7
Botones
Botones
Se consideran botones los botones normales, las casillas de verificacin y
los botones de opcin. La creacin de botones grficos es fcil si se utiliza
un objeto Icon que defina la imagen que debe aparecer. La clase
JCheckBox es til para los botones de casilla de verificacin. La clase
JRadioButton se comporta de modo que, al activar un botn de opcin,
se desactivan todos los dems botones del grupo. La Tabla C-4 describe
estos componentes y muestra su interfaz de usuario.
Tabla C-4 Botones
Componente
Interfaz de
usuario
C-8
Componentes de texto
Componentes de texto
Los componentes de texto Swing se dividen en tres categoras generales:
Interfaz de usuario
Componentes Swing
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
C-9
Componentes de texto
Tabla C-5 Componentes de texto (Continuacin)
Componente
Interfaz de usuario
javax.swing.JPasswordField es
un campo de introduccin de texto
especial para contraseas. Por
motivos de seguridad, el campo de
contrasea muestra los caracteres en
forma de asterisco *. El valor de
un campo de contrasea se guarda
como array de caracteres, no como
cadena. Al igual que cualquier otro
objeto campo de texto, el campo de
contrasea enva un evento de
accin cuando el usuario pulsa la
tecla Intro.
C-10
Interfaz de usuario
La clase javax.swing.JToolTip
es til para mostrar informacin
sobre los componentes.
JComponent incluye un mtodo
denominado setToolTipText
que pueden utilizar todos los
componentes para crear la
cadena que debe mostrarse.
La clase
javax.swing.JProgressBar
es de gran ayuda para indicar el
progreso de tareas extensas.
Componentes Swing
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
C-11
Mens
Mens
Los mens se comportan de forma similar a las listas, excepto en que, por
convencin, suelen aparecer en barras de mens o en mens emergentes.
Una barra de mens puede contener uno o varios mens (llamados
mens desplegables) y su colocacin depende del sistema operativo
(normalmente estn situados en la parte superior de una ventana).
Los mens emergentes aparecen cuando el usuario activa un botn del
ratn o una secuencia de teclas propios de una plataforma, por ejemplo,
cuando pulsa el botn derecho del ratn o pasa el cursor por un
componente contextual. La Tabla C-7 describe estos componentes y
muestra su interfaz de usuario.
Tabla C-7 Componentes de men
Componente
Interfaz de usuario
C-12
Interfaz de usuario
Componentes Swing
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
C-13
Interfaz de usuario
C-14
Interfaz de usuario
Componentes Swing
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
C-15
Interfaz de usuario
C-16