Manu Java PDF

Java Programming Language,
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.
This page intentionally left blank.
This page intentionally left blank.
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
Programacin orientada a objetos................................................. 2-1

Objetivos............................................................................................. 2-1
Ingeniera de software....................................................................... 2-3
Fase de anlisis y diseo ......................................................... 2-5
Ejemplo de anlisis y diseo .................................................. 2-6
Abstraccin ............................................................................... 2-7
Clases como prototipos de objetos ......................................... 2-7
Declaracin de clases en Java ........................................................... 2-8
Declaracin de atributos ................................................................... 2-9
Declaracin de mtodos.................................................................. 2-10
Ejemplo .................................................................................... 2-11
Acceso a los miembros del objeto .................................................. 2-12
Forma de ocultar la informacin ................................................... 2-13
Encapsulacin................................................................................... 2-15
Declaracin de constructores ......................................................... 2-16
Constructor predeterminado................................................. 2-17
Organizacin de los archivos fuente ............................................. 2-18
Paquetes de software....................................................................... 2-19
Sentencia package ........................................................................... 2-20
Sentencia import ............................................................................. 2-21
Disposicin de los directorios y los paquetes .............................. 2-23
Desarrollo ................................................................................ 2-24
Compilacin con la opcin -d............................................... 2-24
Implementacin....................................................................... 2-25
Resumen de la terminologa........................................................... 2-26
Uso de la documentacin sobre el API de Java ........................... 2-27
Identificadores, palabras clave y tipos .......................................... 3-1
Objetivos............................................................................................. 3-1
Comentarios........................................................................................ 3-3
Signos de punto y coma, bloques y espacio en blanco ................. 3-4
Identificadores .................................................................................... 3-6
Palabras clave en programacin Java.............................................. 3-7
Tipos bsicos del lenguaje Java........................................................ 3-8
Tipos primitivos ........................................................................ 3-8
Lgicos: boolean ...................................................................... 3-8
Textuales: char.......................................................................... 3-9
Textuales: String ..................................................................... 3-9
Enteros: byte, short, int y long......................................... 3-10
Reales en coma flotante: double y float ........................... 3-11
Variables, declaraciones y asignaciones ....................................... 3-12
Tipos de referencia usados en Java ............................................... 3-14
vi
Lenguaje de programacin Java

Construccin e inicializacin de objetos....................................... 3-15

Asignacin y organizacin de la memoria ......................... 3-16
Inicializacin explcita de los atributos................................ 3-16
Ejecucin del constructor ....................................................... 3-17
Asignacin de una variable ................................................... 3-17
La historia no acaba aqu ....................................................... 3-17
Asignacin de referencias ............................................................... 3-18
Paso por valor................................................................................... 3-19
Referencia this................................................................................ 3-21
Convenciones de codificacin en el lenguaje Java ...................... 3-22
Expresiones y control del flujo .......................................................4-1
Objetivos............................................................................................. 4-1
Variables.............................................................................................. 4-3
Variables y mbito .................................................................... 4-3
Inicializacin de las variables................................................. 4-6
Principio de inicializacin antes de uso................................ 4-7
Operadores.......................................................................................... 4-8
Orden de precedencia de los operadores .............................. 4-8
Operadores lgicos .................................................................. 4-9
Operadores lgicos de bits..................................................... 4-10
Operadores de desplazamiento a la derecha >> y >>>..... 4-11
Operador de desplazamiento a la izquierda << ................. 4-11
Ejemplos de operadores de desplazamiento....................... 4-12
Concatenacin de cadenas con + ......................................... 4-13
Conversin de tipos ................................................................ 4-13
Promocin y conversin de expresiones ............................. 4-14
Sentencias condicionales................................................................. 4-15
Sentencias if, else sencillas................................................. 4-15
Sentencias if, else complejas .............................................. 4-15
Sentencia switch ................................................................... 4-17
Sentencias de bucle .......................................................................... 4-19
Bucles for ................................................................................ 4-19
Bucle while.............................................................................. 4-20
Bucle do/while ....................................................................... 4-20
Construcciones especiales de control de bucles ................. 4-21
Arrays ................................................................................................5-1
Objetivos............................................................................................. 5-1
Declaracin de arrays ........................................................................ 5-3
Creacin de arrays ............................................................................. 5-4
Creacin de arrays de referencia ............................................ 5-5
Inicializacin de arrays...................................................................... 5-6
Arrays multidimensionales .............................................................. 5-7
Lmites de los arrays.......................................................................... 5-8
Uso del bucle for mejorado .................................................... 5-8
Redimensionamiento de arrays ....................................................... 5-9
Copia de arrays ................................................................................ 5-10
vii
Diseo de clases.............................................................................. 6-1

Objetivos............................................................................................. 6-1
Subclases.............................................................................................. 6-3
Herencia sencilla ....................................................................... 6-5
Control del acceso .............................................................................. 6-6
Sobrescritura de mtodos ................................................................. 6-7
Los mtodos sobrescritos no pueden ser menos accesibles 6-8
Llamada a mtodos sobrescritos............................................ 6-9
Polimorfismo .................................................................................... 6-10
Llamada a mtodos virtuales ................................................ 6-10
Colecciones heterogneas ...................................................... 6-11
Argumentos polimrficos...................................................... 6-12
Operador instanceof .................................................................... 6-13
Conversin de objetos ........................................................... 6-14
Sobrecarga de mtodos ................................................................... 6-15
Mtodos que usan argumentos variables............................ 6-16
Sobrecarga de constructores........................................................... 6-17
Los constructores no se heredan........................................... 6-18
Llamada a los constructores de las clases de nivel superior.....
6-18
Construccin e inicializacin de objetos: ampliacin de conceptos .
6-20
Ejemplos de construccin e inicializacin ........................... 6-20
Clase Object..................................................................................... 6-22
El mtodo equals ................................................................... 6-22
Mtodo toString................................................................... 6-24
Clases envoltorio .............................................................................. 6-26
Conversin automtica de tipos primitivos en objetos:
autoboxing ............................................................................ 6-27
Conceptos avanzados sobre las clases ........................................ 7-1
Objetivos............................................................................................. 7-1
Palabra clave static......................................................................... 7-3
Atributos de clase...................................................................... 7-3
Mtodos de clase ....................................................................... 7-4
Inicializadores estticos............................................................ 7-6
Palabra clave final........................................................................... 7-7
Clases finales.............................................................................. 7-7
Mtodos finales ......................................................................... 7-7
Variables finales ........................................................................ 7-7
Tipos enumerados.............................................................................. 7-9
Creacin de tipos enumerados en versiones anteriores de Java
7-10
El nuevo tipo enumerado ...................................................... 7-13
Tipos enumerados avanzados.............................................. 7-16
viii

Importaciones estticas ................................................................... 7-18

Clases abstractas............................................................................... 7-19
Problema .................................................................................. 7-20
Solucin .................................................................................... 7-21
Interfaces ........................................................................................... 7-23
Ejemplo del objeto volador.................................................... 7-24
Ejemplo de mltiples interfaces............................................ 7-28
Usos de las interfaces.............................................................. 7-29
Excepciones y aserciones...............................................................8-1
Objetivos............................................................................................. 8-1
Excepciones y aserciones .................................................................. 8-3
Excepciones......................................................................................... 8-4
Ejemplo de una excepcin ....................................................... 8-5
Sentencia try-catch......................................................................... 8-6
Mecanismo de apilamiento de llamadas ............................... 8-8
Clusula finally ..................................................................... 8-9
Categoras de excepciones .............................................................. 8-10
Excepciones comunes ...................................................................... 8-12
La regla de la gestin o la declaracin .......................................... 8-13
Sobrescritura de mtodos y excepciones ...................................... 8-15
Creacin de excepciones personalizadas...................................... 8-16
Generacin de excepciones definidas por el usuario........ 8-17
Manejo de excepciones definidas por el usuario............... 8-18
Aserciones ......................................................................................... 8-19
Usos recomendados de las aserciones ................................. 8-19
Control de la evaluacin de las aserciones durante el tiempo
de ejecucin........................................................................... 8-22
API Collections y Generics..............................................................9-1
Objetivos............................................................................................. 9-1
Otros recursos..................................................................................... 9-2
API Collections ................................................................................... 9-3
Implementaciones de Collection...................................................... 9-5
Ejemplo con Set........................................................................ 9-5
Ejemplo con List...................................................................... 9-6
Interfaz Map......................................................................................... 9-8
Ejemplo con Map........................................................................ 9-9
Clases coleccin tradicionales ........................................................ 9-10
Ordenacin de colecciones ............................................................. 9-11
Interfaz Comparable............................................................... 9-11
Interfaz Comparator............................................................... 9-13
Genricos........................................................................................... 9-16
Ejemplo de una variable Set genrica ................................. 9-17
Ejemplo de mapa genrico..................................................... 9-18
Genricos: examen de los parmetros de tipo ............................. 9-20
Parmetros de tipo comodn ................................................ 9-22
ix
Genricos: refactorizacin de cdigo no genrico existente ...... 9-25

Iteradores........................................................................................... 9-27
Bucle for mejorado ......................................................................... 9-29
Principios bsicos de E/S ............................................................. 10-1
Objetivos........................................................................................... 10-1
Otros recursos................................................................................... 10-2
Argumentos de la lnea de comandos........................................... 10-3
Propiedades del sistema.................................................................. 10-4
Clase Properties............................................................................ 10-5
Principios bsicos del flujo de E/S ................................................ 10-6
Datos contenidos en los flujos............................................... 10-6
Flujos de bytes .................................................................................. 10-7
Mtodos InputStream........................................................... 10-7
Mtodos OutputStream......................................................... 10-8
Flujos de caracteres .......................................................................... 10-9
Mtodos Reader...................................................................... 10-9
Mtodos Writer................................................................... 10-10
Flujos de nodos............................................................................... 10-11
Ejemplo sencillo..................................................................... 10-11
Flujos en bfer ................................................................................ 10-13
Concatenacin de flujos de E/S ................................................... 10-14
Flujos de procesamiento................................................................ 10-15
Clases bsicas de flujos de bytes.................................................. 10-16
Clases FileInputStream y FileOutputStream............. 10-17
Clases BufferedInputStream y BufferedOutputStream .....
10-17
Clases PipedInputStream y PipedOutputStream ........ 10-17
Clases DataInputStream y DataOutputStream............. 10-17
Clases ObjectInputStream y ObjectOutputStream.... 10-18
Serializacin .................................................................................... 10-21
Serializacin y grficos de objetos ...................................... 10-21
Escritura y lectura de un flujo de objetos .......................... 10-22
Clases bsicas de flujos de caracteres.......................................... 10-25
Mtodos InputStreamReader y OutputStreamWriter 10-26
Conversin de bytes y de caracteres .................................. 10-26
Utilizacin de otras codificaciones de caracteres ............. 10-26
Clases FileReader y FileWriter..................................... 10-27
Clases BufferedReader y BufferedWriter ................... 10-27
Clases StringReader y StringWriter ............................ 10-27
Clases PipedReader y PipedWriter................................. 10-27
E/S de consola y E/S de archivos................................................. 11-1
Objetivos........................................................................................... 11-1
Otros recursos................................................................................... 11-2

E/S de consola.................................................................................. 11-3

Escritura en salida estndar................................................... 11-3
Lectura de la entrada estndar.............................................. 11-4
Salida en formato simple ...................................................... 11-6
Entrada en formato simple ................................................... 11-7
Archivos y E/S de archivos............................................................ 11-8
Creacin de un objeto File nuevo ....................................... 11-8
Pruebas y utilidades ligadas al objeto File........................ 11-9
E/S de flujos de archivo....................................................... 11-10
Creacin de interfaces graficas con el API Swing ......................12-1
Objetivos........................................................................................... 12-1
Otros recursos................................................................................... 12-2
Estilo de interfaz adaptable ................................................... 12-4
Arquitectura de Swing ........................................................... 12-5
Paquetes de Swing ........................................................................... 12-7
Composicin de una interfaz grfica basada en Java ................. 12-9
Contenedores Swing...................................................................... 12-11
Contenedores de nivel superior.......................................... 12-11
Componentes Swing...................................................................... 12-12
Jerarqua de componentes Swing ....................................... 12-13
Propiedades de los componentes Swing .................................... 12-14
Propiedades comunes de los componentes....................... 12-14
Propiedades especficas de los componentes.................... 12-15
Administradores de diseo .......................................................... 12-16
Administrador de diseo BorderLayout ......................... 12-16
Administrador de diseo FlowLayout.............................. 12-18
Administrador de diseo BoxLayout................................ 12-19
Administrador de diseo CardLayout.............................. 12-20
Administrador de diseo GridLayout.............................. 12-21
Administrador de diseo GridBagLayout ....................... 12-22
Administrador de diseo GroupLayout............................ 12-23
Creacin de interfaces grficas de usuario................................. 12-24
Construccin programtica ................................................. 12-24
Control de los eventos generados por la interfaz grfica ..........13-1
Objetivos........................................................................................... 13-1
Otros recursos................................................................................... 13-2
Qu es un evento.............................................................................. 13-3
Modelo de eventos de Java SE ....................................................... 13-5
Modelo de delegacin ............................................................ 13-5
Ejemplo de receptor de eventos ............................................ 13-6
Comportamiento de la interfaz grfica......................................... 13-8
Categoras de eventos............................................................. 13-8
Ejemplo complejo.................................................................. 13-10
Mltiples receptores de eventos ......................................... 13-12
Desarrollo de receptores de eventos ........................................... 13-14
Adaptadores de eventos ...................................................... 13-14
xi
Control de eventos mediante clases internas.................... 13-15

Control de eventos mediante clases annimas................. 13-16
Concurrencia en Swing ................................................................. 13-18
Aplicaciones basadas en la interfaz grfica................................ 14-1
Objetivos........................................................................................... 14-1
Aspectos relevantes ......................................................................... 14-2
Creacin de un men ...................................................................... 14-3
Creacin de una barra de mens con JMenuBar ............... 14-4
Creacin de un men con JMenu ......................................... 14-5
Creacin de una opcin de men con JMenuItem............ 14-6
Creacin de un componente JCheckboxMenuItem .......... 14-7
Control de los aspectos visuales .................................................... 14-8
Colores ...................................................................................... 14-8
Hilos ................................................................................................ 15-1
Objetivos........................................................................................... 15-1
Hilos ................................................................................................... 15-3
Creacin del hilo ..................................................................... 15-4
Inicio del hilo .......................................................................... 15-6
Planificacin de la ejecucin de los hilos............................. 15-6
Fin de los hilos......................................................................... 15-8
Control bsico de los hilos ............................................................ 15-10
Comprobacin del estado de los hilos ............................... 15-10
Acceso a la prioridad de los hilos ....................................... 15-10
Hilos en espera ...................................................................... 15-10
Otras formas de crear hilos........................................................... 15-12
Seleccin de la forma de crear hilos .................................. 15-13
Uso de la palabra clave synchronized ...................................... 15-14
Problema ................................................................................ 15-14
Indicador de bloqueo de objetos......................................... 15-16
Liberacin del indicador de bloqueo ................................. 15-18
Uso de synchronized: conclusiones ................................ 15-19
Estados de los hilos............................................................... 15-20
Interbloqueo........................................................................... 15-20
Interaccin de los hilos: wait y notify...................................... 15-21
Ejemplo ................................................................................... 15-21
Problema ................................................................................ 15-21
Solucin .................................................................................. 15-21
Interaccin entre los hilos ............................................................. 15-22
Mtodos wait y notify....................................................... 15-22
Estados de los hilos............................................................... 15-23
Modelo de control de la sincronizacin............................ 15-24
Ejemplo de interaccin de hilos ................................................... 15-25
Hilo Producer...................................................................... 15-26
Hilo Consumer....................................................................... 15-27
xii

Clase SyncStack.................................................................. 15-28

Ejemplo de SyncTest........................................................... 15-31
Conexin en red .............................................................................16-1
Objetivos........................................................................................... 16-1
Conexin en red ............................................................................... 16-3
Sockets ...................................................................................... 16-3
Configuracin de la conexin................................................ 16-3
Direccionamiento de la conexin.......................................... 16-5
Nmeros de puerto................................................................. 16-5
Modelo de conexin en red de Java ..................................... 16-6
Servidor TCP/IP mnimo ............................................................... 16-7
Cliente TCP/IP mnimo .................................................................. 16-8
Elementos de programacin Java avanzada ................................ A-1
Objetivos............................................................................................ A-1
Introduccin a la arquitectura de dos y de tres capas ................. A-2
Arquitectura de tres capas ............................................................... A-3
Definicin del cliente-servidor de tres capas ....................... A-3
Interfaz de base de datos.................................................................. A-4
Introduccin al API JDBC ............................................................ A-6
Descripcin general del API JDBC ........................................ A-6
Controladores JDBC ................................................................ A-7
Puente JDBC-ODBC................................................................. A-7
Sistemas distribuidos........................................................................ A-8
RMI...................................................................................................... A-9
Arquitectura RMI..................................................................... A-9
Creacin de una aplicacin RMI.......................................... A-10
CORBA ............................................................................................. A-11
Lenguaje IDL de Java ........................................................... A-12
Comparacin entre RMI y CORBA ..................................... A-13
Modelo de componentes JavaBeans ......................................... A-14
Arquitectura de beans .......................................................... A-15
Introspeccin de un bean ...................................................... A-16
Ejemplo de interaccin de beans.......................................... A-17
Kit de desarrollo BDK ........................................................... A-17
Archivos JAR ................................................................................... A-18
Uso de la herramienta javadoc.................................................... A-19
Etiquetas de documentacin ................................................ A-19
Ejemplo .................................................................................... A-20
Gua de consulta rpida sobre el lenguaje UML........................... B-1
Objetivos............................................................................................. B-1
Otros recursos.....................................................................................B-2
Principios bsicos del lenguaje UML ..............................................B-3
Elementos generales ..........................................................................B-6
Paquetes......................................................................................B-6
Estereotipos................................................................................B-8
xiii
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
Acerca de este curso

Finalidad del curso
Este curso le proporcionar los conocimientos necesarios para:
Crear aplicaciones que aprovechen funciones de programacin

orientada a objetos de Java tales como la encapsulacin, la herencia y
el polimorfismo.
Ejecutar una aplicacin Java desde la lnea de comandos.
Usar tipos de datos y expresiones de Java.
Usar construcciones de control de flujo de Java.
Usar arrays y otros grupos de datos.
Implementar tcnicas de gestin de errores utilizando el manejo de

excepciones.
Crear interfaces grficas controladas por eventos utilizando los

componentes de interfaz grfica de Java: paneles, botones, etiquetas,
campos de texto y cuadros de texto.
Implementar la funcionalidad de E/S para leer y escribir datos y

archivos de texto.
Crear programas multihilo.
Crear un cliente TCP/IP sencillo que se comunique mediante

sockets.
Prlogo-xv
Finalidad del curso

El principal objetivo del curso Lenguaje de programacin Java es
proporcionarle los conocimientos y la experiencia prctica necesarios para
utilizar un lenguaje de programacin orientada a objetos (OO) en la
creacin de aplicaciones Java avanzadas. A lo largo del mismo, aprender
aspectos fundamentales del lenguaje Java tales como la sintaxis de
programacin y los conceptos elementales de la programacin orientada a
objetos, as como aspectos ms complejos del entorno de ejecucin Java
como son el uso de interfaces grficas, el procesamiento multihilo y la
comunicacin en red. El contenido de este curso es un requisito
indispensable para preparar el examen de Programador Certificado en
Plataforma Java (SCJP). Para obtener informacin sobre el examen,
visite el sitio web:
http://www.sun.com/training/certification/java/
Tenga presente que hacer el curso SL-275 no basta para pasar el examen
de inmediato. Necesitar dedicar varios meses a aplicar estas tcnicas en
la creacin de programas reales. Conviene que revise tambin los
objetivos del examen y otras reas de estudio no tratadas en este curso.
Los objetivos del examen SCJP pueden encontrarse en las pginas web
citadas anteriormente.
Prlogo-xvi

Descripcin del curso
Descripcin del curso

En este curso se explica el entorno de ejecucin de Java y la sintaxis de
este lenguaje de programacin. Tambin se describen los conceptos de
programacin orientada a objetos (OO) aplicados al lenguaje Java. Segn
se vaya avanzando en el temario, se irn introduciendo aspectos
avanzados de la plataforma Java.
El curso est dirigido a personas con conocimientos previos sobre
programacin en Java o en otros lenguajes. Es la continuacin del curso
SL-110: Programacin Java para no Programadores.
Aunque Java es un lenguaje independiente del sistema operativo, la
interfaz grfica de usuario (GUI) que genera s puede depender del
sistema operativo donde se ejecute el cdigo. En este curso los ejemplos
de cdigo se basan en los sistemas operativos Solaris y Microsoft
Windows, por lo que los grficos del manual reflejarn la interfaz grfica
de Motif y Windows. El contenido del curso es aplicable a todas las
variantes de sistemas operativos Java.
Prlogo-xvii
Esquema del curso
Esquema del curso

Este esquema le permitir ver los progresos que va realizando con
respecto a los objetivos del curso.
Conceptos bsicos sobre programacin Java

Introduccin
Identificadores,
palabras clave y
tipos
Programacin
orientada a objetos
Expresiones
Arrays
y control del flujo
Conceptos avanzados de programacin OO

Conceptos
Diseo de clases
avanzados sobre
las clases
Excepciones, colecciones y E/S

Excepciones
Colecciones y
tipos genricos
y aserciones
E/S:
aspectos
fundamentales
Desarrollo de interfaces grficas de usuario

E/S de consola
y
de archivos
Control de eventos
Aplicaciones
de la GUI
basadas en la GUI
Programacin Java avanzada

Hilos
Prlogo-xviii
Funciones de red

Contenido de los mdulos
Mdulo 1: Introduccin
Este mdulo ofrece una introduccin general al lenguaje Java y sus
caractersticas fundamentales. Tambin presenta una aplicacin Java
sencilla.
Mdulo 2: Programacin orientada a objetos

En este mdulo se introducen los conceptos bsicos de la
programacin orientada a objetos (OO) y se explica su
implementacin utilizando el lenguaje Java.
Mdulo 3: Identificadores, palabras clave y tipos

El lenguaje Java contiene numerosas construcciones de
programacin similares a las del lenguaje C. Este mdulo contiene
una descripcin general de las construcciones disponibles y la
sintaxis necesaria para utilizarlas. Tambin incluye el enfoque bsico
empleado en programacin OO para la asociacin de datos mediante
tipos de datos agregados.
Mdulo 4: Expresiones y control del flujo

En esta parte del curso se describen las expresiones (incluidos los
operadores) y la sintaxis de control del flujo en los programas Java.
Mdulo 5: Arrays
En este mdulo se explica cmo declarar, crear, inicializar y copiar
arrays en Java.
Mdulo 6: Diseo de clases

Este mdulo profundiza en los conceptos del Mdulo 2 y trata
aspectos avanzados como las subclases, la sobrecarga y la
sobrescritura.
Mdulo 7: Conceptos avanzados sobre las clases

Con este mdulo se completa la explicacin del modelo de
programacin OO de Java a travs de conceptos como los miembros
estticos, las variables finales, las clases abstractas y las interfaces.
Mdulo 8: Excepciones y aserciones

Las excepciones proporcionan un mecanismo para detectar errores
en tiempo de ejecucin. En este mdulo se examinan las excepciones
predefinidas y las definidas por el usuario.
Prlogo-xix
Mdulo 9: API Collections y Generics

En esta parte se examina el API Collections y el uso de tipos
genricos en programacin Java.
Mdulo 10: Principios bsicos de E/S

En este mdulo se describen las clases disponibles para leer y
escribir datos y texto. Incluye una explicacin sobre la serializacin
de objetos.
Mdulo 11: E/S de consola y E/S de archivos

En este mdulo se introducen aspectos tiles para la implementacin
de aplicaciones de gran tamao basadas en texto, como pueden ser
las de E/S de consola y archivos.
Mdulo 12: Creacin de interfaces grficas con el API Swing

Todas las interfaces grficas de usuario que se crean en lenguaje Java
se desarrollan sobre el concepto de marcos y paneles. Este mdulo
ofrece una introduccin al diseo de componentes de la interfaz y
contenedores con Swing.
Mdulo 13: Control de eventos generados por la interfaz grfica

Crear un diseo de componentes de la interfaz grfica en un marco
no basta. Es necesario escribir cdigo que maneje los eventos
generados durante el uso de la interfaz, lo que incluye, por ejemplo,
acciones como pulsar un botn o introducir un carcter en la
interfaz. En este mdulo se explica cmo escribir controladores de
eventos de la interfaz grfica.
Mdulo 14: Aplicaciones basadas en la interfaz grfica

En este mdulo se explican diversos elementos de la interfaz grfica.
Mdulo 15: Hilos

Los hilos (threads) son un tema complejo. En este mdulo se explica el
procesamiento de hilos en relacin con la programacin Java y se
incluye un ejemplo sencillo de comunicacin y sincronizacin de hilos.
Mdulo 16: Conexin en red

Este mdulo contiene una introduccin al paquete de programacin
Java para red y presenta un modelo de cliente/servidor TCP/IP.
Prlogo-xx

Objetivos del curso
Objetivos del curso

Las personas que realicen el curso aprendern a:
Describir las caractersticas fundamentales del lenguaje.
Compilar y ejecutar una aplicacin Java.
Usar documentacin en lnea sobre Java en formato de hipertexto.
Describir las construcciones y los elementos de la sintaxis del

lenguaje.
Describir el paradigma de programacin orientada a objetos.
Usar las caractersticas de programacin OO del lenguaje Java.
Usar excepciones.
Usar el API Collections.
Realizar operaciones de escritura y lectura en archivos.
Desarrollar una interfaz grfica.
Describir las herramientas AWT (Abstract Window Toolkit) de Java.
Desarrollar un programa para aceptar la introduccin de datos desde

una interfaz grfica.
Describir el control de eventos.
Usar el paquete java.io.
Describir los conceptos bsicos del procesamiento multihilo.
Desarrollar aplicaciones Java multihilo.
Desarrollar programas de cliente y servidor Java con TCP/IP.
Prlogo-xxi
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.
Diseo y anlisis de aplicaciones orientadas a objetos, tratado en el

curso OO-226): Anlisis y Diseo OO con UML
Conceptos generales de programacin, tratado en el curso SL-110:

Programacin Java para no Programadores
Consulte el catlogo de los servicios de Formacin Sun para obtener

informacin detallada sobre los cursos y la inscripcin.
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:
Crear y compilar programas en C o C++.
Crear y modificar archivos de texto con un editor de textos.
Utilizar un navegador web como Netscape.
Prlogo-xxiii
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
Cargo, funcin y responsabilidad
Experiencia relacionada con los temas de este curso
Razones para inscribirse en el curso
Expectativas con respecto al curso

Cmo utilizar el material del curso
Cmo utilizar el material del curso

Para que pueda sacar el mximo provecho a este curso, el temario incluye
un mdulo didctico que consta de lo siguiente:
Finalidad: al final del curso debera ser capaz de alcanzar las metas
fijadas y cumplir todos los objetivos.
Objetivos: despus de cubrir una parte del contenido del curso,

debera estar en disposicin de cumplir los objetivos. Los objetivos
permiten alcanzar la meta y lograr nuevos objetivos.
Clase terica: el profesor ofrece informacin relacionada con el

objetivo del mdulo. Esta informacin ayuda a adquirir los
conocimientos necesarios para realizar correctamente las actividades.
Actividades: las actividades son de diversa ndole y pueden incluir

ejercicios, autoevaluaciones, discusiones y demostraciones. Las
actividades contribuyen a facilitar el dominio de una materia.
Material visual de apoyo: el profesor puede utilizar este tipo de

ayuda para explicar de forma grfica conceptos como el de un
determinado proceso. La ayuda visual suele constar de grficos,
imgenes animadas y vdeo.
Prlogo-xxv
Convenciones tipogrficas y smbolos

En este curso se usan convenciones para representar varios elementos y
recursos de formacin alternativos.
Iconos
Otros recursos: Hace referencia a otras fuentes en las que se proporciona
informacin adicional sobre los temas descritos en el mdulo.
Discusin: Indica que es aconsejable entablar un debate general o en

grupos reducidos sobre el tema tratado.
Nota: Indica la existencia de informacin adicional que puede ayudar al

alumno, pero que no es crucial para entender el concepto que se est
explicando. El alumno debera ser capaz de entender el concepto o de
realizar la tarea sin esta informacin. En las notas se incluyen los mtodos
abreviados del teclado y los ajustes menores del sistema, entre otros.
Atencin: Indica que existe el riesgo de causar lesiones personales por
causas no elctricas, o daos irreversibles en los datos, el software o
el sistema operativo. Advierte de un posible riesgo (del que no se
tiene certeza), que depende de la accin que realice el usuario.
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
Otras convenciones
En los ejemplos del lenguaje Java se emplean estas otras convenciones:
Los nombres de mtodos no van seguidos de parntesis a menos que

se muestre una lista de parmetros formales o reales, por ejemplo:
El mtodo doIt... hace referencia a cualquier mtodo denominado
doIt.
El mtodo doIt()... se refiere a un mtodo doIt que no admite
argumentos.
Slo se producen saltos de lnea cuando existen separaciones (comas),

conjunciones (operadores) o espacios en blanco en el cdigo. El cdigo
interrumpido se sangra cuatro espacios debajo del cdigo inicial.
Si en el entorno Solaris se utiliza un comando distinto del empleado

en Microsoft Windows, se muestran ambos comandos, por ejemplo:
En Solaris:
$ cd $SERVER_ROOT/bin
En Windows:
C:\> cd %SERVER_ROOT%\bin
Prlogo-xxviii

Mdulo 1
Introduccin
Objetivos
El estudio de este mdulo le proporcionar los conocimientos necesarios
para:
Describir las caractersticas fundamentales de la tecnologa Java.
Escribir, compilar y ejecutar una aplicacin Java sencilla.
Describir la funcin de la mquina virtual de Java (JVM)1.
Definir el concepto de reciclaje de memoria dinmica

(garbage collection).
Enumerar las tres tareas que la plataforma Java realiza para

controlar la seguridad del cdigo.
Este mdulo proporciona una descripcin general de la tecnologa Java,

lo que incluye la mquina virtual de Java, el reciclaje de memoria
dinmica, las funciones de seguridad y la herramienta JVM para
servicios de depuracin.
1.
Los trminos mquina virtual de Java y JVM significan mquina virtual

para la plataforma Java.
1-1
Aspectos relevantes
Aspectos relevantes
!
?
Discusin: Las preguntas siguientes son importantes en relacin con el

material presentado en el mdulo:
Java es un lenguaje de programacin completo o slo es til para

escribir programas destinados a la web?
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
Para qu otro lenguaje de programacin?

_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
Por qu la plataforma Java representa una mejora con respecto a

otras plataformas de lenguajes?
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
1-2

Otros recursos
Otros recursos
Otros recursos: Los documentos siguientes proporcionan informacin
complementaria sobre los temas tratados en este mdulo:
Gosling, Joy, Bracha, and Steele. The Java Language Specification,

Second Edition. Addison-Wesley. 2000. [Tambin en la web:
http://java.sun.com/docs/books/jls/].
Lindholm and Yellin. The Java Virtual Machine Specification, Second

Edition. Addison-Wesley. 1999. [Tambin en la web:
http://java.sun.com/docs/books/vmspec/].
Yellin, Frank. Low-Level Security in Java, white paper. [En la web].

Disponible: http://java.sun.com/sfaq/verifier.html.
Introduccin
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
La sintaxis del lenguaje Java es similar a la de C++. Es posible utilizar Java

para crear cualquier tipo de aplicacin que pudiera crearse con otro
lenguaje.
Como entorno de desarrollo, la tecnologa Java proporciona una amplia
variedad de herramientas: un compilador, un intrprete, un generador de
documentos, una herramienta para empaquetar archivos de clases y
muchas ms.
El lenguaje Java suele mencionarse en el contexto de las aplicaciones
World Wide Web (web) y los navegadores que son capaces de ejecutar
programas llamados applets (miniaplicaciones). Los applets son programas
escritos en lenguaje Java que residen en los servidores web y que se
ejecutan a travs de un navegador que los descarga en un sistema cliente.
Suelen ser de pequeo tamao para reducir el tiempo de descarga y la
llamada para ejecutarlos se realiza desde una pgina web HTML
(Hypertext Markup Language).
Las aplicaciones Java son programas autnomos que no requieren la
presencia de un navegador de web para ejecutarse. Normalmente son
programas genricos que se ejecutan en cualquier mquina donde se
encuentre instalado el entorno de ejecucin de Java (JRE).
Existen dos grandes entornos de implementacin. El primero es el JRE
suministrado a travs del kit de desarrollo de software (SDK) Java 2, que
contiene el juego completo de archivos de clases para todos los paquetes
Java, lo que incluye las clases bsicas del lenguaje, las clases de
componentes de la interfaz grfica (GUI) y un API avanzado de
colecciones (Collections) entre otros. El otro entorno de implementacin
fundamental es el propio navegador del usuario. La mayora de los
navegadores comercializados proporcionan un intrprete y un entorno de
ejecucin de Java.
1-4

Objetivos fundamentales de la tecnologa Java

Java proporciona lo siguiente:
Un lenguaje en el que resulta fcil programar porque:
Resuelve carencias de otros lenguajes como las relativas a la

aritmtica de punteros y la gestin de la memoria, que afectan a
la solidez y fiabilidad del cdigo.
Es orientado a objetos para ayudar a visualizar el programa de

una forma ms cercana a la realidad.
Permite simplificar el cdigo.
Un lenguaje interpretado (genera cdigo directamente en bytes),

lo que proporciona las siguientes ventajas:
Rapidez de desarrollo: reduce el ciclo compilacin-enlace-cargaprueba.
Portabilidad del cdigo: permite escribir cdigo que puede

ejecutarse en numerosos sistemas operativos sobre cualquier
JVM certificada.
Una forma de que los programas ejecuten mltiples procesos de

forma simultnea.
Una manera de cambiar los programas de forma dinmica durante el

tiempo de ejecucin permitindoles descargar mdulos de cdigo.
Una forma de garantizar la seguridad mediante la comprobacin de

los mdulos de cdigo cargados.
La arquitectura de Java utiliza los siguientes elementos para cumplir los

objetivos enumerados:
La JVM
El reciclaje de memoria
El JRE
JVM Tool Interface: interfaz de herramientas de JVM
Introduccin
1-5
Mquina virtual de Java

El documento The Java Virtual Machine Specification define la mquina
virtual de Java como:
Una mquina imaginaria que se implementa como una emulacin de software
sobre una mquina real y acta como puente entre el cdigo binario de Java
y la plataforma. El cdigo de la JVM se guarda en archivos .class, cada
uno de los cuales contiene cdigo de una clase pblica como mximo.
La especificacin de la JVM incluye las especificaciones de las plataformas
de hardware para las que se compila todo el cdigo de Java. Esta
especificacin es la que permite que el software de Java pueda ser
independiente de la plataforma, porque la compilacin se realiza para
una mquina genrica conocida como la JVM. Es posible emular esta
mquina genrica en software para que se ejecute en diferentes sistemas
informticos del mercado o implementarla en hardware.
El compilador lee el cdigo fuente de la aplicacin Java y genera bytecodes
o cdigo de byte. El cdigo de byte son instrucciones de cdigo en
formato mquina para JVM. Cada intrprete de Java, independientemente
de que sea una herramienta de desarrollo de aplicaciones Java o un
navegador de web, tiene una implementacin de la JVM.
La especificacin de JVM proporciona definiciones concretas para la
implementacin de los siguientes elementos: un juego de instrucciones
(equivalente al de una CPU o unidad de procesamiento central), un juego
de registros, el formato de archivo de clases, una pila de tiempo de
ejecucin, un rea de almacenamiento y reciclaje de la memoria dinmica,
una zona de memoria, un mecanismo de comunicacin de errores
graves y funciones de temporizacin de alta precisin.
El formato del cdigo de la mquina virtual consta de cdigos de byte
pequeos y eficientes. Los programas presentados este cdigo deben
atenerse a la disciplina de tipos de datos adecuada. La mayor parte de
la comprobacin de tipos se realiza durante la compilacin.
Cualquier intrprete de Java compatible debe ser capaz de ejecutar
cualquier archivo de clases que cumpla los requisitos de formato
especificados en el documento The Java Virtual Machine Specification
para este tipo de archivos.
El diseo de JVM permite crear implementaciones para numerosos
entornos operativos. Por ejemplo, Sun Microsystems proporciona
implementaciones de JVM para Solaris, Linux y Microsoft Windows.
1-6

Reciclaje de memoria dinmica

Muchos lenguajes de programacin permiten asignar la memoria
de forma dinmica durante el tiempo de ejecucin. El proceso de
asignacin de la memoria vara en funcin de la sintaxis del lenguaje,
pero siempre implica devolver un puntero a la direccin de inicio de
un bloque de memoria.
Cuando la memoria asignada deja de ser necesaria (el puntero que hace
referencia a ella ha abandonado su referente), el programa o el entorno de
ejecucin debera liberarla.
En C, C++ y otros lenguajes, el programador es el responsable de liberar
la memoria. Esto puede ser una tarea complicada en ocasiones, porque
no siempre se sabe con antelacin cundo debe quedar libre. Los
programas que no liberan la memoria pueden bloquearse en un momento
dado porque ya no queda memoria en el sistema para asignar.
Cuando esto ocurre, se dice que el programa pierde memoria.
El lenguaje Java descarga al programador de la responsabilidad de liberar
la memoria. Proporciona un hilo en el nivel del sistema que hace el
seguimiento de cada asignacin de memoria. Durante los ciclos de
inactividad de la JVM, el mecanismo de reciclaje busca la memoria en
desuso y la libera.
Esta operacin se realiza de forma automtica mientras dura el programa
Java, lo que elimina la necesidad de liberar la memoria y, con ello, el
riesgo de prdidas. No obstante, los modelos de reciclaje de la memoria
pueden variar considerablemente en cada implementacin de JVM.
Introduccin
1-7
Entorno de ejecucin de Java

En la Figura 1-1 se ilustra el entorno de ejecucin de Java (JRE) y la forma
en que maneja la seguridad del cdigo.
Compilacin
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
Funcionamiento del JRE
Los archivos de cdigo fuente de Java se compilan en el sentido de que

se convierten en un conjunto de cdigos de un byte a partir del formato
de texto en el que se escriben. Los cdigos de byte se guardan en
archivos .class.
Durante el tiempo de ejecucin, los cdigos de byte que componen un
programa Java se cargan, comprueban y ejecutan a travs de un
intrprete. En el caso de los applets, es posible descargar los cdigos
de byte para luego interpretarlos a travs de la JVM integrada en el
navegador. El intrprete tiene dos funciones: ejecuta dichos cdigos y
efecta las llamadas apropiadas al hardware de la plataforma.
1-8


En algunos entornos de ejecucin de Java, una parte del cdigo de byte
verificado se compila adaptndolo al cdigo mquina nativo y se ejecuta
directamente en la plataforma de hardware. Esto permite al cdigo del
programa Java ejecutarse a velocidades prximas a las del lenguaje C o
C++ con una pequea demora en el tiempo de carga para permitir que el
cdigo se compile en forma de cdigo mquina (vase la Figura 1-2).
Tiempo de ejecucin
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
Funcionamiento del JRE con un compilador JIT (Just-InTime)
Nota: Sun Microsystems ha mejorado la JVM agregando tecnologas que

aumentan el rendimiento. Una de ellas es la llamada mquina virtual
Java HotSpot, con la que es posible conseguir que el lenguaje Java
se ejecute a la misma velocidad que el cdigo C++ compilado.
Introduccin
1-9
Tareas de JVM
En esta seccin se examinan en mayor profundidad las tres tareas
fundamentales de la mquina virtual de Java:
Cargar el cdigo: a travs del cargador de clases.
Verificar el cdigo: a travs del verificador de cdigos de byte.
Ejecutar el cdigo: a travs del intrprete de tiempo de ejecucin.
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

Verificador de los cdigos de byte

El cdigo del software Java se somete a distintas comprobaciones antes de
ejecutarse en una mquina. La JVM lo hace pasar a travs de un
verificador de cdigos de byte que busca posibles fragmentos de
cdigo ilcito, es decir, cdigo que falsea punteros, infringe los derechos
de acceso a los objetos o intenta cambiar los tipos de los objetos.
Nota: Todos los archivos de clases importados desde la red pasan por el
verificador de cdigos.
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:
Las clases son conformes con el formato de archivos de clases de la

especificacin de JVM.
No se han producido intentos de infringir las reglas de acceso.
El cdigo no provoca desbordamiento ni falta de operandos en la

pila.
Todos los tipos de parmetros de los cdigos operativos son correctos.
No se han realizado conversiones de datos irregulares tales como la

conversin de enteros en referencias a objetos.
Introduccin
1-11
Aplicacin Java sencilla

Como en el caso de cualquier otro lenguaje de programacin, Java se
utiliza para crear aplicaciones. Los ejemplos de Cdigo 1-1 y Cdigo 1-2
contienen una aplicacin Java sencilla creada para enviar un saludo a
travs de la pantalla.
Cdigo 1-1
1
2
3
4
5
6
7
8
9
//
// 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
public class Greeting {

public void greet() {
System.out.println("hola");
}
}

Aplicacin TestGreeting
Cdigo 1-3
1
2
3
Lneas 1-3
//
// Ejemplo de aplicacin de "Saludo"
//
Las lneas 13 del programa son comentarios.

Cdigo 1-4
4
Lnea 4
public class TestGreeting
La lnea 4 declara la clase llamada TestGreeting. Cuando se especifica

un nombre de clase en un archivo de cdigo fuente, al compilar dicho
archivo se crea un archivo nombreclase.class. Si no se especifica
ningn directorio de destino que pueda usar el compilador, el archivo
de clase se situar en el mismo directorio en el que se encuentre el
archivo fuente. En este caso, el compilador crea un archivo llamado
TestGreeting.class. Este archivo contiene el cdigo compilado de la
clase pblica TestGreeting.
Cdigo 1-5
5
Lnea 5
public static void main (String args[]) {
La lnea 5 es el punto donde empieza a ejecutarse el programa. El

intrprete de Java debe encontrar esta sentencia exactamente tal y como
se muestra o deniega la ejecucin.
Otros lenguajes de programacin, entre los que destacan C y C++,
tambin utilizan la declaracin main() como punto de partida de la
ejecucin. A continuacin se describen las distintas partes de esta
declaracin. Los detalles se explican ms adelante en este curso.
Si el programa recibe argumentos en su lnea de comandos, stos se
pasan al mtodo main() en un array de String llamado args. En este
ejemplo no se ha utilizado ningn argumento.
A continuacin se explica cada elemento de la lnea 5:
public: al mtodo main() puede acceder cualquier componente de

Java, incluido el intrprete.
Introduccin
1-13
static: esta palabra clave indica al compilador que el mtodo

main() puede utilizarse en el contexto de la clase TestGreeting.
No se necesita ninguna instancia de la clase para ejecutar mtodos
estticos.
void: esta palabra clave indica que el mtodo main() no devuelve

ningn valor. Esto es importante porque el lenguaje Java realiza una
cuidadosa comprobacin de tipos para asegurarse de que los
mtodos a los que se ha llamado devuelvan los tipos de datos con
los que se han declarado.
String args[]: este mtodo declara el nico parmetro del mtodo

main, args, y utiliza como tipo un array String. Cuando se llama a
este mtodo, el parmetro args contiene los argumentos introducidos
en la lnea de comandos detrs del nombre de clase, por ejemplo:
java TestGreeting
Cdigo 1-6
6
args[0] args[1] . . .
Lnea 6
Greeting hello = new Greeting();
En esta lnea se muestra cmo crear un objeto al que hace referencia la

variable hello. La sintaxis new Greeting indica al intrprete de Java
que construya un nuevo objeto de la clase Greeting.
Cdigo 1-7
7
Lnea 7
hello.greet();
En la lnea 7 se muestra una llamada a un mtodo de un objeto.

Esta llamada indica al objeto hello que enve un saludo (greet).
La implementacin de este mtodo puede verse en las lneas 35 del
archivo Greeting.java.
Cdigo 1-8
8
9
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
public class Greeting {
La lnea 1 declara la clase Greeting.

Cdigo 1-10 Lneas 24
2
3
4
public void greet() {

System.out.println(hola);
}
En estas lneas se muestra la declaracin de un mtodo. El mtodo se ha

declarado public, lo que permite al programa TestGreeting acceder a
l. No devuelve ningn valor, por lo que se utiliza void como tipo de
retorno.
El mtodo greet enva un mensaje en forma de cadena de texto a la
salida estndar. El mtodo println() se utiliza para escribir dicho
mensaje en la salida.
Cdigo 1-11 Lnea 5
5
Esta lnea cierra la declaracin de la clase Greeting.
Introduccin
1-15
Compilacin y ejecucin del programa TestGreeting

Despus de crear el archivo de cdigo fuente TestGreeting.java,
complelo mediante la lnea siguiente:
javac TestGreeting.java
Si el compilador no devuelve ningn mensaje, el nuevo archivo
TestGreeting.class se almacena en el mismo directorio que el archivo
fuente, a menos que se especifique otra cosa. El archivo Greeting.java se
ha compilado en Greeting.class. El compilador realiza esta operacin
automticamente porque la clase TestGreeting utiliza la clase Greeting.
Para ejecutar la aplicacin TestGreeting, utilice el intrprete de Java.
Los archivos ejecutables de las herramientas de Java (javac, java,
javadoc, etc.) estn situados en el directorio bin.
java TestGreeting
Nota: Debe definir la variable de entorno PATH de forma que encuentre

java y javac. Asegrese de que incluya raz_java/bin (donde
raz_java representa el directorio raz donde est instalado el
software de la tecnologa Java).
1-16

Solucin de errores de compilacin

En las prximas secciones se describen los errores que pueden aparecer al
compilar el cdigo de los programas.
Errores producidos durante la compilacin

A continuacin se citan algunos errores que suelen producirse durante la
compilacin, junto con ejemplos de los mensajes presentados por el
compilador o por el programa en ejecucin. Los mensajes pueden
variar en funcin de la versin de Java 2 SDK que est utilizando.
javac: Command not found

La variable PATH no se ha configurado adecuadamente para incluir
el compilador javac. El compilador javac est situado en el
directorio bin, debajo del directorio donde se encuentra instalado
el software del JDK (Java Development Kit).
Greeting.java:4:cannot resolve symbol

symbol : method printl (java.lang.String)
location: class java.io.PrintStream
System.out.printl("hola");
^
El nombre del mtodo println se ha escrito de forma incorrecta.
Nombres de clases y archivos

Si el archivo .java contiene una clase pblica, el nombre del
archivo debe ser igual que el nombre de la clase. Por ejemplo,
la definicin de la clase en el ejemplo anterior es:
public class TestGreeting
Por tanto, el nombre del archivo fuente debe ser
TestGreeting.java. Si ha denominado al archivo
TestGreet.java, recibir el siguiente mensaje de error:
TestGreet.java:4: Public class TestGreeting must be
defined in a file called "TestGreeting.java".
Cantidad de clases utilizadas

Slo debe declarar una clase no esttica de nivel superior en cada
archivo fuente y el nombre de la clase debe ser idntico al del
archivo. Si declara varias clases pblicas, aparecer el mismo
mensaje que en el punto anterior por cada clase pblica cuyo
nombre no sea idntico al del archivo.
Introduccin
1-17
Errores producidos durante la ejecucin

Algunos de los errores generados al escribir java TestGreeting son:
Can't find class TestGreeting

Normalmente esto significa que el nombre especificado para la
clase en la lnea de comandos difiere del nombre del archivo
nombrearchivo.class . En el lenguaje Java, existe diferencia entre
maysculas y minsculas.
Por ejemplo:
public class TestGreet {
crea una clase TestGreet.class, que no tiene el nombre esperado
por el compilador (TestGreeting.class).
Exception in thread "main" java.lang.NoSuchMethodError:

main
Esto significa que la clase que se ha pedido al intrprete que ejecute
no tiene ningn mtodo main esttico. Puede que haya un mtodo
main, pero es posible que no se haya declarado con la clave esttica
o puede que se haya declarado con parmetros inadecuados,
por ejemplo:
public static void main(String args) {
En este ejemplo, args no es un array de cadenas, sino una sola
cadena.
public static void main() {
En este ejemplo, el programador ha olvidado incluir una lista de
parmetros.
1-18

Compilacin
En la Figura 1-3 puede verse el proceso de compilacin de Java y su

posterior ejecucin en la JVM. Existen muchas implementaciones de la
JVM segn las distintas plataformas de hardware y sistemas operativos.
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
Entorno de ejecucin de Java
Introduccin
1-19
Mdulo 2
Programacin orientada a objetos

Objetivos
para:
Definir los conceptos de modelado: abstraccin, encapsulacin y

paquete.
Explicar por qu es posible reutilizar el cdigo de las aplicaciones

Java.
Definir los conceptos de clase, miembro, atributo, mtodo, constructor y

paquete.
Utilizar los modificadores de acceso privado y pblico (private y

public) de la forma ms apropiada para las normas de
encapsulacin.
Llamar a un mtodo de un determinado objeto.
Utilizar la documentacin en lnea de las API de Java.
ste es el primero de tres mdulos en los que se describe el paradigma

de programacin orientada a objetos (OO) y las caractersticas de este
tipo de programacin aplicadas al lenguaje Java.
2-1
Aspectos relevantes
Aspectos relevantes
!
?

Qu sabe del anlisis y el diseo de software?

_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
Qu sabe del diseo y la reutilizacin del cdigo?

_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
Qu aspectos del lenguaje Java lo convierten en un lenguaje de

programacin OO?
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
Defina la expresin programacin orientada a objetos.

_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
2-2

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.
Kits de desarrollo / Infraestructuras / API de objetos (aos 90)

Java 2 SDK
AWT / J.F.C./Swing
Jini
JavaBeans
JDBC
Lenguajes de programacin OO (aos 80)

SELF
Smalltalk
Common Lisp Object System
Eiffel
C++
Java
Bibliotecas / API funcionales (aos 60principios de los 80)

NASTRAN
TCP/IP
ISAM
Lenguajes de alto nivel (aos 50)

Fortran
LISP
COBOL
X-Windows
OpenLook
Sistemas operativos (aos 60)

OS/360
UNIX
MacOS
Microsoft Windows
Cdigo mquina (finales de los 40)

Figura 2-1
Breve historia de la ingeniera de software
Al principio dedicaron sus esfuerzos a crear lenguajes que ocultaran

la complejidad del lenguaje mquina y agregaron llamadas a
procedimientos en el sistema operativo para manejar operaciones
comunes tales como la apertura, lectura o escritura de archivos.
Otros desarrolladores agruparon en diferentes bibliotecas conjuntos de
funciones y procedimientos comunes que abarcaban desde el clculo de
la cargas estructurales para ingeniera (NASTRAN), hasta la transmisin
de caracteres y flujos de bytes entre los equipos conectados a una red
(TCP/IP), el acceso a los datos a travs de un mtodo de acceso secuencial
indexado (ISAM) o la creacin de ventanas y otros objetos de interfaz
de usuario en un monitor grfico (X-Windows y Open Look).

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

Fase de anlisis y diseo

Un proyecto de desarrollo de software se compone de cinco fases
fundamentales: definicin de los requisitos, anlisis, diseo,
implementacin y pruebas. Todas ellas son importantes, pero es
fundamental dedicar el tiempo suficiente para las fases de anlisis y
diseo.
Durante la fase de anlisis se define qu objetivos debe perseguir el
sistema. Esto se consigue definiendo todos los elementos implicados
(usuarios, dispositivos y otros sistemas que interaccionan con el sistema
propuesto) y las actividades que dicho sistema debe llevar a cabo. En esta
fase se identifican tambin los objetos de dominio (tanto fsicos como
conceptuales) que el sistema propuesto manejar, as como el
comportamiento de tales objetos y las interacciones entre ellos. Estos
comportamientos implementan las actividades de las que el sistema
propuesto debe hacerse cargo. La descripcin de estas actividades
debera ser lo bastante detallada como para crear los criterios que se
tomarn como base en la fase de pruebas.
Durante la fase de diseo se define cmo alcanzar el sistema esos
objetivos. En esta fase se crea un modelo de los elementos implicados,
las actividades, los objetos y los comportamientos del sistema propuesto.
Para esta parte utilizar la herramienta de modelado UML (Unified
Modeling Language).
Nota: UML es un lenguaje vasto y complejo. Usted utilizar slo una
pequea parte de l. El Apndice B contiene una referencia a los
componentes de UML utilizados en este curso. Tambin indica cmo
implementar el cdigo de Java desde un diagrama de clases de UML.

2-5
Ejemplo de anlisis y diseo

En este mdulo se utiliza como ejemplo una aplicacin de una empresa
de transporte. Deben tomarse en consideracin un conjunto bsico de
requisitos.
El software debe aplicarse a una sola compaa de transporte.
La compaa cuenta con una flota de vehculos que transporta cajas.
El peso de las cajas es el nico factor importante que debe tenerse en

cuenta al cargar un vehculo.
La empresa posee dos tipos de vehculos: camiones y barcazas de

transporte fluvial.
Las cajas se pesan utilizando el kilogramo como unidad de medida,

pero los algoritmos para calcular la potencia de motor necesaria
deber contabilizar la carga total del vehculo medida en newtons.
Nota: Un newton es una medida de fuerza (o peso) equivalente a 9,8 veces

la masa del objeto en kilogramos.
Deber utilizar una interfaz grfica para hacer el seguimiento de las

cajas que se van agregando a los vehculos.
Tambin deber generar varios informes a partir de los registros de

fletes.
Tomando estos requisitos como base, puede crear un diseo de alto nivel:
2-6
Los objetos siguientes deben estar representados en el sistema: una

empresa y dos tipos de vehculos.
Una compaa es la suma de mltiples objetos que son los vehculos.
Tambin existen otros objetos funcionales: los informes y las

pantallas de la interfaz grfica.

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.
Clases como prototipos de objetos

Al igual que un diseador crea prototipos de dispositivos que podrn
utilizarse en repetidas ocasiones para construir los dispositivos reales,
una clase es un prototipo de software que puede utilizarse para instanciar
(es decir crear) muchos objetos diferentes. La clase define el conjunto de
elementos (atributos) que definen los objetos, as como el conjunto de
comportamientos o funciones (llamados mtodos) que manejan el objeto
o ejecutan las interacciones entre objetos relacionados. Juntos, los
atributos y mtodos se denominan miembros. Por ejemplo, un objeto
vehculo en la aplicacin de transporte debe llevar el control de su
carga mxima y su carga real y utilizar mtodos para agregar una caja
(de un cierto peso) al vehculo.
El lenguaje Java incorpora tres conceptos clave de la programacin OO:
encapsulacin, herencia y polimorfismo.
Nota: El primero de ellos se trata en la seccin Encapsulacin en la
pgina 2-15. La herencia y el polimorfismo se explican en el Mdulo 6.

2-7
Declaracin de clases en Java
Declaracin de clases en Java

La declaracin de clases en Java adopta la forma siguiente:
<modificador>* class <nombre_clase> {
<declaracin_atributo>*
<declaracin_constructor>*
<declaracin_mtodo>*
}
<nombre_clase> es el nombre de la clase que se va a declarar y puede ser
cualquier identificador admitido. Hay varias palabras clave que pueden
usarse como <modificador>, pero, por ahora, utilice nicamente public.
Este modificador declara que la clase es pblica, es decir, de acceso
universal. El cuerpo de la clase declara el conjunto de atributos,
constructores y mtodos asociados a la clase. En el Cdigo 2-1 se
muestra un ejemplo de declaracin de una clase.
Cdigo 2-1
1
2
3
4
5
6
2-8
Ejemplo de declaracin de una clase
public class Vehiculo {

private double cargaMax;
public void setCargaMax(double valor) {
cargaMax = valor;
}
}

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
public class Ejemplo {

private int x;
private float y = 10000.0F;
private String name = "Hotel Medioda";
}
<nombre> es el nombre del atributo que se va a declarar y puede ser

cualquier identificador admitido. Es posible usar varios valores como
<modificador>, pero, por ahora, utilice slo public o private. La clave
private indica que slo pueden acceder al atributo todos los mtodos
pertenecientes a esta clase. El <tipo> de atributo puede ser cualquier
tipo primitivo (int, float, etc.) o cualquier clase.

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

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
public class Perro {

private int peso;
public int getPeso() {
return peso;
}
public void setPeso(int newPeso) {
if ( newPeso > 0 ) {
peso = newPeso;
}
}
}

2-11
Acceso a los miembros del objeto
Acceso a los miembros del objeto

En el ejemplo siguiente ver la siguiente lnea de cdigo en el mtodo
PruebaPerro.main:
d.setPeso(42);
Esta lnea indica al objeto d (en realidad una variable, d, que contiene una
referencia a un objeto del tipo Perro) que ejecute su mtodo setPeso. Esto
se denomina notacin de punto. El operador punto (.) permite acceder a los
atributos y mtodos que componen los miembros no privados de una clase.
Dentro de la definicin de los mtodos, no es necesario usar la notacin
de punto para acceder a los miembros locales. Por ejemplo, el mtodo
setPeso de la clase Perro no utiliza la notacin de punto para acceder al
atributo peso.
En el Cdigo 2-3 se muestra el comportamiento de los mtodos de Perro.
Cuando se crea el objeto Perro, se inicializa la variable de la instancia
peso con el valor 0. Por tanto, el mtodo getPeso devuelve 0. La lnea 6
de este cdigo establece el peso en 42, que es un argumento vlido, y el
mtodo setPeso define el valor de la variable peso. No obstante, no se
admite el valor -42 como peso (lnea 9), as que el mtodo setPeso no
modifica la variable peso.
Cdigo 2-3
1
2
3
4
5
6
7
8
9
10
11
12
13
Ejemplo de llamadas a mtodos
public class PruebaPerro {

public static void main(String[] args) {
Perro d = new Perro();
System.out.println("El peso del perro d es "
+ d.getPeso());
d.setPeso(42);
+ d.getPeso());
d.setPeso(-42);
+ d.getPeso());
}
}
La salida es:
El peso del perro d es 0
2-12

Forma de ocultar la informacin

Imagine que tiene una clase llamada MyDate que incluye los atributos
siguientes: day, month y year. La Figura 2-2 contiene un diagrama de
una posible implementacin de la clase MyDate.
MyDate
+day : int
+month : int
+year : int
Figura 2-2
Diagrama UML de la clase MyDate
Una implementacin sencilla permite el acceso directo a estos atributos,

por ejemplo:
public class
public int
public int
public int
}
MyDate {
day;
month;
year;
Por tanto, el cdigo cliente accede directamente a estos atributos y genera

errores, por ejemplo (d se refiere al objeto MyDate):
d.day = 32;
// da no vlido
d.month = 2; d.day = 30;
// posible pero incorrecto
d.day = d.day + 1;
// no hay comprobacin de comportamiento cclico (wrap
around)

2-13

Para resolver el problema, oculte los datos de atributos hacindolos
privados y proporcione otros mtodos de acceso como getXyz(), a veces
denominados getters, y setXyz(), a veces llamados setters. En la Figura 2-3
se ilustra otro diagrama UML de la clase MyDate donde se ocultan las
variables de instancia detrs de los mtodos de acceso get y set.
MyDate
-day : int
-month : int
-year : int
+getDay()
+getMonth()
+getYear()
+setDay(int) : boolean
+setMonth(int) : boolean
+setYear(int) : boolean
Verifica los das del mes.
Figura 2-3
Forma de ocultar las variables de instancia de la clase

MyDate
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
La encapsulacin aporta mayor flexibilidad para representar

los datos

2-15
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
public class Perro {

private int peso;
public Perro() {
peso = 42;
}
La clase Perro tiene una sola variable de instancia peso. El constructor

(sin parmetros) inicializa peso con el valor 42.
Tambin es posible declarar constructores con parmetros. Este aspecto se
trata ms adelante en el curso.
2-16

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
Organizacin de los archivos fuente
Organizacin de los archivos fuente

Los archivos fuente de Java tienen el siguiente formato:
[<declaracin_paquete>]
<declaracin_importacin>*
<declaracin_clase>+
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
Ejemplo de diagrama UML de paquetes Java
Existen muchas formas de agrupar las clases en paquetes con sentido

lgico. No existe una forma correcta o errnea de hacerlo, pero una
tcnica habitual es agrupar las clases por similitud semntica.
Por ejemplo, un sistema de software de transporte debera contener una
serie de objetos de dominio (como la empresa, los vehculos, las cajas,
los destinos, etc.), un conjunto de informes y un grupo de paneles de la
interfaz grfica que sirvan para crear la aplicacin de introduccin de
datos principal. Los subsistemas GUI e informes dependen del paquete
dominio. Los paquetes UML pueden ser tiles para modelar subsistemas
u otras agrupaciones de elementos en funcin de las necesidades.
Los dems paquetes estn incluidos en el paquete de nivel superior,
llamado transporte.

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
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
import java.io.*;
private Empresa empresaParaInforme;
...
}
Cuando se declara un paquete, no es necesario importar el paquete en s,

ni ninguno de los elementos que contiene. Recuerde que la sentencia
import se utiliza para poner las clases de otros paquetes a disposicin
de la clase actual.
import indica la clase a la que se quiere acceder. Por ejemplo, si slo
quiere incluir la clase Writer (del paquete java.io) en el espacio de
nombres actual, utilizar:
import java.io.Writer;

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.*;
Nota: La sentencia import permite utilizar los nombres de clase en un

formato abreviado dentro del cdigo fuente, eso es todo. Este tipo de
sentencias no hacen que el compilador cargue ningn dato adicional en la
memoria de trabajo. En este sentido, import se diferencia bastante de la
sentencia #include de C o C++. La sentencia import, con o sin carcter
comodn (*), no tiene ningn efecto en el archivo de clase de salida,
ni tampoco en el rendimiento del programa durante la ejecucin.
Asimismo, es improbable que su uso provoque diferencias de rendimiento
durante la compilacin.
2-22

Disposicin de los directorios y los paquetes

Los paquetes se almacenan en un rbol de directorios cuyas ramas son los
nombres de los paquetes. Por ejemplo, el archivo Empresa.class se
encontrar en la estructura de directorios que aparece en la Figura 2-6.
transporte/
dominio/
Empresa.class
Vehiculo.class
Barcaza.class
Camion.class
GUI/
informes/
InformeCapacidadVehiculo.class
Figura 2-6
Estructura de directorios de los paquetes de clases

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
Ejemplo de una estructura de directorios para proyectos de

desarrollo
Compilacin con la opcin -d

Normalmente, el compilador de Java sita los archivos de clases en el
mismo directorio que los archivos fuente. Es posible enviar los archivos
de clases a otro directorio utilizando la opcin -d del comando javac. La
forma ms sencilla de compilar los archivos de los paquetes es trabajar en
el directorio situado un nivel por encima del comienzo del paquete (en
este ejemplo, el directorio src).
2-24


Para compilar todos los archivos del paquete transporte.dominio de
forma que todas las clases compiladas vayan al directorio de paquete
correcto dentro de TransporteProy/class/, escriba lo siguiente:
cd ProyectosJava/TransporteProy/src
javac -d ../classes transporte/dominio/*.java
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
Nota: En algunas plataformas, basta hacer doble clic en el icono de un

archivo JAR ejecutable para que se inicie el programa correspondiente.
Implementacin de las bibliotecas

Algunas veces es necesario implementar el cdigo de las bibliotecas en
un archivo JAR. En tales casos, es posible copiar el archivo JAR en el
subdirectorio ext del directorio lib situado bajo el directorio principal
del JRE. Acte con precaucin al hacerlo porque, si implementa las clases
de esta forma, normalmente reciben privilegios de seguridad completos.
Esto puede ocasionar problemas durante la ejecucin del programa en
el caso de que existan conflictos de nombres con otras clases del ncleo
del JDK u otras clases que se hayan instalado de esa misma forma.

2-25
Resumen de la terminologa
Resumen de la terminologa
A continuacin se definen algunos de los trminos presentados en este
mdulo:
2-26
Clase: forma de definir nuevos tipos de objetos en el lenguaje de

programacin Java. La clase puede considerarse como un prototipo,
un modelo del objeto que se est describiendo.
Objeto: instancia (ejemplar) real creada a partir de una clase. Un

objeto es lo que se obtiene cada vez que se genera una instancia
de una clase utilizando new. Los objetos tambin se conocen como
instancias.
Atributo: elemento que suministra datos sobre un objeto. Los

atributos almacenan informacin relativa a los objetos. Los atributos
tambin se conocen como miembros dato, variables de instancia o campos
de datos.
Mtodo: elemento funcional de un objeto. Los mtodos tambin se

conocen como funciones o procedimientos.
Constructor: elemento similar al mtodo utilizado para inicializar

(o crear) un objeto nuevo. Los constructores tienen el mismo
nombre que la clase.
Paquete: grupo de clases, subpaquetes o una combinacin de ambos.

Uso de la documentacin sobre el API de Java

Existen diferentes archivos en formato HTML que sirven de documentacin
sobre el API suministrado. La organizacin de estos documentos es
jerrquica, de modo que la pgina inicial muestra la lista de todos los
paquetes en forma de hipervnculos. Cuando seleccione el vnculo de un
determinado paquete, aparecer la lista de todas las clases que contiene ese
paquete. Si selecciona el vnculo de una clase, se abrir una pgina con
informacin sobre esa clase. En la Figura 2-8 se muestra una de las clases.
Figura 2-8
Documentacin del API de Java

2-27

Los documentos de las clases contienen las secciones siguientes:
2-28
La jerarqua de la clase
Una descripcin de la clase y su propsito
La lista de atributos
La lista de constructores
La lista de mtodos
Una lista detallada de atributos con sus descripciones
Una lista detallada de constructores con sus descripciones y las listas

de parmetros formales
Una lista detallada de mtodos con sus descripciones y las listas de

parmetros formales

Mdulo 3
Identificadores, palabras clave y tipos

Objetivos
para:
Utilizar comentarios en el cdigo fuente.
Diferenciar entre identificadores vlidos y no vlidos.
Reconocer las palabras clave utilizadas en Java.
Enumerar los ocho tipos primitivos existentes.
Definir valores literales para tipos numricos y textuales.
Definir los trminos variable de tipos primitivos y variable de referencia.
Declarar variables de tipo clase.
Construir un objeto utilizando new.
Describir la inicializacin predeterminada.
Describir la importancia de una variable de referencia.
Evaluar las consecuencias de asignar variables de tipos de clase.
En este mdulo se explican algunos componentes bsicos de los

programas Java, entre ellos la variables, las palabras clave, los tipos
primitivos y los tipos de clase.
3-1
Aspectos relevantes
Aspectos relevantes
!
?

Conoce los tipos primitivos usados en la tecnologa Java?

_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
Puede describir la diferencia entre las variables que contienen

valores de tipos primitivos y las que contienen referencias a objetos?
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
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
Signos de punto y coma, bloques y espacio en blanco

En el lenguaje Java, una sentencia se compone de una o varias lneas
de cdigo que se cierran con un signo de punto y coma (;).
Por ejemplo:
totals = a + b + c + d + e + f;
Equivale a
totals = a + b + c
+ d + e + f;
Un bloque, a veces denominado sentencia compuesta, es un conjunto
de sentencias delimitadas por llaves de apertura y cierre ({ }). Los
bloques proporcionan algunas ventajas que se describen en el Mdulo 4,
Expresiones y control del flujo. Por ahora, piense en los bloques
como en conjuntos de sentencias agrupadas.
He aqu algunos ejemplos de bloques o grupos de sentencias:
// sentencia en un bloque
{
x = y + 1;
y = x + 1;
}
// definicin de una clase contenida en un bloque
public class MyDate {
private int day;
private int month;
private int year;
}
// un bloque de sentencias puede estar anidado en
// otro bloque
while ( i < large ) {
a = a + i;
// bloque anidado
if ( a == max ) {
b = b + a;
a = 0;
}
i = i + 1;
}
3-4


Es posible incluir espacios en blanco entre los elementos del cdigo.
Se admite cualquier cantidad de espacio. Normalmente se incluye
en forma de tabuladores, espacios y saltos de lnea para mejorar la
calidad y la organizacin del cdigo fuente. Compare:
{int x;x=23*54;}
Con:
{
int x;
x = 23 * 54;
}

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
El cdigo fuente de la tecnologa Java se escribe con el juego de caracteres

Unicode de 16 bits en lugar de texto ASCII de 8 bits, por lo que admite
muchas ms letras de las que componen el abecedario ingls (a-z y AZ).
Aunque los identificadores pueden usar caracteres no pertenecientes al
juego ASCII, tenga presente lo siguiente:
Unicode puede admitir caracteres diferentes que tienen el mismo

aspecto.
Los nombres de clases slo deberan escribirse en caracteres ASCII

porque la mayora de los sistemas de archivos no admiten caracteres
Unicode.
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

Palabras clave en programacin Java
Palabras clave en programacin Java

Las palabras clave son palabras reservadas que tienen un significado
especial para el compilador de Java. Sirven para identificar el nombre
de un determinado tipo de datos o un constructor del programa.
La Tabla 3-1 con tiene una lista de las palabras clave utilizadas en el
lenguaje Java.
Tabla 3-1 Palabras clave en programacin Java
abstract
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:
Los literales true, false y null se escriben en minsculas, no en

maysculas como en el lenguaje C++. Tcnicamente son literales, no
palabras clave, pero esta distincin es puramente acadmica.
No existe ningn operador sizeof; no puede realizarse el acceso

directo a la memoria, por lo que la informacin carecera de valor.
Las palabras clave goto y const no se utilizan en programacin

Java.

3-7
Tipos bsicos del lenguaje Java

El lenguaje Java incorpora numerosos tipos de datos. stos se clasifican
en dos grandes categoras: tipos de clase y tipos primitivos. Los tipos
primitivos son simples valores, no objetos. Los tipos de clase se utilizan
para tipos ms complejos, incluidos todos los que declara el propio
programador. Los tipos de clase se utilizan para crear objetos.
Tipos primitivos
El lenguaje Java define ocho tipos de datos primitivos que se enmarcan en
cuatro categoras:
Lgicos: boolean
Textuales: char
Enteros: byte, short, int y long
Reales en coma flotante: double y float
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;
Nota: No existe conversin de tipos entre enteros y booleanos. Algunos

lenguajes, principalmente C y C++, permiten interpretar los valores
numricos como lgicos. No es el caso de Java. En este lenguaje, cuando
se necesita un tipo boolean, slo pueden utilizarse valores booleanos.
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????
Un carcter Unicode concreto, ????, que se sustituye

exactamente por cuatro dgitos hexadecimales.
Por ejemplo, \u03A6 es la letra griega fi [].
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
Enteros: byte, short, int y long

Hay cuatro tipos de datos enteros en Java. Cada uno de ellos se declara
utilizando una de las siguientes palabras clave byte, short, int o long.
Puede representar los literales de los tipos enteros utilizando una notacin
decimal, octal o hexadecimal, como se muestra a continuacin:
2
ste es el formato decimal del entero 2.
077
El 0 inicial indica un valor octal.
0xBAAC
El prefijo 0x indica que es un valor hexadecimal.
Todos los tipos numricos en Java representan nmeros con signo.

Los literales enteros son del tipo int, a menos que vayan explcitamente
seguidos de la letra L, lo que indicara que se trata de un valor long. Da
igual escribir la L en mayscula o minscula. No obstante, no se recomienda
la l minscula porque resulta difcil diferenciarla del nmero 1.
He aqu las versiones largas (long) de los literales citados anteriormente.
2L
La L indica que el valor decimal 2 se representa

como un entero largo.
077L
El 0 inicial indica un valor octal.
0xBAACL
El prefijo 0x indica que es un valor hexadecimal.
En la Tabla 3-2 figuran el tamao y el intervalo de valores

correspondientes a los cuatro tipos de enteros. La representacin del
intervalo de valores se define en la especificacin del lenguaje Java
como un complemento a 2 y es independiente de la plataforma.
Tabla 3-2 Tipos de datos enteros: tamao y rango de valores
3-10
Longitud del entero
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

Reales en coma flotante: double y float

Las variables de tipos reales en coma flotante se declaran con las palabras
clave float o double. La lista siguiente contiene ejemplos de nmeros
en coma flotante. Un literal numrico es un nmero real en coma flotante
si incluye un separador decimal y un exponente (la letra E o e), o
bien si va seguido de la letra F o f (float) o de la letra D o d (double).
stos son algunos ejemplos de literales en coma flotante:
3.14
Valor en coma flotante sencillo (double) en

notacin estndar
6.02E23
Valor en coma flotante largo
2.718F
Valor corto de precisin simple (float)
123.4E+306D
Valor largo double con D redundante
Nota: El nmero 23 despus de la E en el segundo ejemplo es

implcitamente positivo. Ese ejemplo es equivalente a 6.02E+23.
Los literales en coma flotante se consideran del tipo double de forma
predeterminada. Es posible declarar literales del tipo float agregando F o
f al valor.
El formato de un nmero en coma flotante est definido en el documento
The Java Language Specification de acuerdo con la norma IEEE (Institute of
Electrical and Electronics Engineers) 754 y utilizando los tamaos
indicados en la Tabla 3-3. Este formato es independiente de la plataforma.
Tabla 3-3 Tamao de los tipos de datos en coma flotante
Longitud
Nombre o tipo
32 bits
float
64 bits
double
Nota: Los literales en coma flotante se consideran double a menos que se

declaren expresamente como float.

3-11
Variables, declaraciones y asignaciones

En el programa siguiente se explica cmo declarar y asignar valores a
variables con tipos int, float, boolean, char y String:
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
public class Assign {

public static void main (String args []) {
// declara variables con tipos enteros
int x, y;
// declara y asigna un valor en coma flotante
float z = 3.414f;
// declara y asigna un valor de tipo double
double w = 3.1415;
// declara y asigna un valor boolean
boolean truth = true;
// declara una variable de tipo char
char c;
// declara una variable de tipo String
String str;
// declara y asigna un valor a una variable String
String str1 = "hasta la vista";
// asigna un valor a la variable char
c = 'A';
// asigna un valor a la variable String
str = "Hola!";
// asigna valores a las variables int
x = 6;
y = 1000;
}
}
Las lneas siguientes contienen ejemplos de asignaciones no vlidas:

y = 3.1415926;
// 3.1415926 no es un tipo int
// Necesita conversin de tipos y el decimal se truncar.
w = 175,000;
// El signo de coma (,) no puede aparecer;
truth = 1;
// ste es un error de programacin frecuente entre
programadores habituados a C / C++
z = 3.14156;
3-12


// No se puede especificar un valor de tamao double en una
variable declarada como float. Requiere conversin de
tipos.

3-13
Tipos de referencia usados en Java
Tipos de referencia usados en Java

Como hemos indicado, hay ocho tipos de datos primitivos en Java:
boolean, char, byte, short, int, long, float y double. El resto de los
tipos hacen referencia a objetos en lugar de a datos primitivos. Las
variables que hacen referencia a objetos se denominan variables de
referencia. Por ejemplo, puede definir una clase MyDate:
1
2
3
4
5
6
7

private int day = 1;
private int month = 1;
private int year = 2000;
public MyDate(int day, int month, int year) { ... }
public String toString() { ... }
}
En el cdigo siguiente se muestra un ejemplo de uso de MyDate:

1
2
3
4
5
public class TestMyDate {

MyDate today = new MyDate(22, 7, 1964);
}
}
La variable today contiene una referencia al objeto MyDate.
3-14

Construccin e inicializacin de objetos

Ya hemos visto cmo ejecutar una llamada a new Xyz() a fin de asignar
espacio para un objeto nuevo. Ahora veremos cmo colocar argumentos
entre los parntesis, por ejemplo new MyDate(22, 7, 1964).
El uso de la palabra clave new produce el siguiente resultado:
1.
En primer lugar se asigna e inicializa el espacio del nuevo objeto como

0 o vaco (null). En programacin Java, esta fase es indivisible para
garantizar que no habr objetos que contengan valores aleatorios.
2.
En segundo lugar se realiza cualquier inicializacin explcita.
3.
En tercer lugar se ejecuta un constructor, que es un mtodo especial.

Los argumentos del parntesis pasados a new se pasan al constructor
(22, 7, 1964).
4.
Por ltimo, el valor resultante de la operacin new es una referencia

al nuevo objeto en el espacio de memoria dinmica. Esta referencia
se guarda en la variable de referencia.

3-15
Asignacin y organizacin de la memoria

En el cuerpo de los mtodos, la declaracin siguiente asigna espacio de
almacenamiento nicamente para la referencia mostrada en la Figura 3-1:
MyDate my_birth = new MyDate(22, 7, 1964);
my_birth
Figura 3-1
????
Declaracin de la referencia al objeto
La palabra clave new del ejemplo siguiente implica la asignacin e

inicializacin del espacio de almacenamiento, como se ilustra en la
Figura 3-2.
my_birth
????
day
month
year
Figura 3-2
Uso de la palabra clave new
Inicializacin explcita de los atributos

Si introduce expresiones de asignacin sencillas en las declaraciones de
miembros, puede inicializar los miembros de forma explcita durante la
construccin del objeto.
Como puede verse en la Figura 3-3, los tres atributos de la clase MyDate
del ejemplo se han inicializado de forma expresa:
my_birth
day
month
year
2000
Figura 3-3
3-16
????
Inicializacin explcita

Ejecucin del constructor

La parte final de la inicializacin de un objeto nuevo es llamar al
constructor. ste permite sobrescribir la inicializacin predeterminada.
Es posible realizar clculos, as como pasar argumentos al proceso
de construccin para que el cdigo que solicita la construccin del
nuevo objeto pueda controlar el objeto creado.
En el ejemplo de la Figura 3-4 puede verse la llamada al constructor:
my_birth
????
day
22
month
year
1964
Figura 3-4
Llamada al constructor
Asignacin de una variable

Asignacin con la que se establece la variable de referencia my_birth de
forma que haga referencia al objeto recin creado, como se muestra en la
Figura 3-5.
my_birth
0x01abcdef
day
22
month
year
Figura 3-5
1964
Asignacin de la variable de referencia
La historia no acaba aqu

En realidad, construir e inicializar objetos es ms complejo de lo que aqu
se explica. El tema se trata con mayor profundidad en el Mdulo 6.

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
Dos variables hacen referencia al mismo objeto
Si se reasigna la variable t, se crea el nuevo objeto MyDate (con el

valor 22 de diciembre de1964) y t hace referencia a este nuevo objeto,
como se muestra en la Figura 3-7. El cdigo aparecera como:
t = new MyDate(22, 12, 1964); // reasigna la variable
x
0x01234567
22
1964
22 12 1964
0x12345678
Figura 3-7 La variable t hace referencia a un objeto nuevo
t
3-18

Paso por valor
Paso por valor

El lenguaje Java pasa los argumentos nicamente por valor, es decir, no se
puede cambiar el valor del argumento del mtodo que hace la llamada
desde el mtodo que recibe la llamada.
No obstante, cuando se pasa una instancia de un objeto en forma de
argumento a un mtodo, el valor del argumento no es el objeto en s, sino
una referencia al objeto. Es posible cambiar el contenido de ese objeto en el
mtodo que recibe la llamada, pero no en la referencia al objeto.
Para muchos, esto parece una operacin de paso por referencia y su
comportamiento tiene cosas en comn con el del paso por referencia.
Sin embargo, no es exactamente as por dos razones. La primera es que
la capacidad para cambiar el elemento pasado a un mtodo slo se aplica
a los objetos, no a los valores de tipos primitivos. La segunda es el que
el valor asociado a una variable de tipo objeto es la referencia al objeto
y no el objeto en s. sta es una distincin importante en otros aspectos y,
si se entiende con claridad, explica perfectamente la idea de que el
lenguaje Java pasa los argumentos por valor.
El siguiente ejemplo de cdigo ilustra este concepto:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class PassTest {

// Mtodos para cambiar los valores actuales
public static void changeInt(int value) {
value = 55;
}
public static void changeObjectRef(MyDate ref) {
ref = new MyDate(1, 1, 2000);
}
public static void changeObjectAttr(MyDate ref) {
ref.setDay(4);
}
public static void main(String args[]) {
MyDate date;
int val;
// Asigna el entero
val = 11;
// Intenta cambiarlo

3-19
Paso por valor

21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
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);
System.out.println("Mi fecha: " + date);
// Ahora se cambia el atributo de da
// mediante la referencia al objeto
changeObjectAttr(date);
System.out.println("Mi fecha: " + date);
}
}
La salida en pantalla de este cdigo es la siguiente:

java PassTest
El valor entero es: 11
Mi fecha: 22-7-1964
Mi fecha: 4-7-1964
El mtodo changeObjectRef no cambia el objeto MyDate, sino que es el
mtodo changeObjectAttr el que cambia el atributo de da (day) del
objeto MyDate.
3-20

Referencia this
Referencia this
La palabra clave this se utiliza con dos fines:
Resolver la ambigedad entre las variables de instancia y los

parmetros.
Pasar el objeto actual como parmetro a otro mtodo.
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
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
Convenciones de codificacin en el lenguaje Java

Para escribir cdigo en lenguaje Java se utilizan las siguientes convenciones:
Paquetes: los nombres de paquetes se escriben en minsculas.

package transporte.objetos
Clases: los nombres de clases deberan ser sustantivos escritos en

letras maysculas y minsculas, con la primera letra de cada palabra
en mayscula.
class LibroContabilidad
Interfaces: los nombres de interfaces siguen la mismas normas que los

nombres de las clases.
interface Contabilidad
Mtodos: los mtodos deberan ser verbos escritos en letras

maysculas y minsculas, y con la inicial en minscula. Dentro de
cada nombre de mtodo, las palabras se separan con letras en
maysculas. Conviene limitar el uso de signos de subrayado.
cuadrarLibro()
Variables: deberan escribirse en maysculas y minsculas, con la

inicial en minscula. Las palabras se separan mediante letras en
mayscula. Conviene limitar el uso de signos de subrayado y evitar
el uso del signo de dlar ($) porque este carcter tiene un significado
especial para las clases internas.
clienteActual
El nombre de las variables tiene que ser explicativo para que indique a
cualquier lector el propsito de su uso. Trate de no utilizar nombres de
un solo carcter salvo para variables temporales desechables (por
ejemplo, i, j y k utilizadas como variables de control de bucles).
3-22
Constantes: las constantes primitivas deben escribirse enteramente en

maysculas y separando las palabras mediante signos de subrayado.
Las constantes de objeto pueden utilizar una combinacin de
maysculas y minsculas.
TOTAL_NOMINA
CANTIDAD_MAXIMA
Estructuras de control: cuando las sentencias forman parte de una

estructura de control del flujo, como es el caso de if-else o for, es
preciso escribirlas entre llaves ({ }), aunque sean sentencias sencillas.
if ( condicin ) {
sentencia1;
} else {
sentencia2;
}

Espacios: slo debe colocarse una sentencia por lnea y utilizar

sangras de dos o cuatro espacios para facilitar la lectura del cdigo.
El nmero de espacios puede variar en funcin de las
convenciones de codificacin utilizadas.
Comentarios: utilice comentarios para explicar los segmentos de

cdigo que no resultan obvios. Debe utilizar el delimitador //
para los comentarios normales y marcar las secciones de comentario
de gran tamao usando /* . . . */ como delimitadores. Los
comentarios de documentacin se delimitan mediante los caracteres
/** . . . */ y sirven a javadoc como texto de entrada para
generar la documentacin HTML del cdigo.
// Comentario en una sola lnea.
/* Los comentarios pueden ser ms largos y
ocupar varias lneas. */
/** Comentario destinado a documentacin.
* @see la clase Another para ms informacin.
*/
Nota: La palabra @see es una etiqueta especial de javadoc que produce

el efecto de un vnculo vase tambin y hace referencia a una clase o un
mtodo. Para obtener ms informacin sobre javadoc, consulte la
definicin del sistema de documentacin explicada en el documento
The Design of Distributed Hyperlinked Programming Documentation, cuya
autora es Lisa Friendly. Puede encontrarlo en la siguiente direccin:
http://java.sun.com/docs/javadoc-paper.html
Asimismo, si precisa ms informacin sobre las convenciones de
codificacin del lenguaje Java de Sun, consulte la pgina web siguiente:
http://java.sun.com/docs/codeconv/html/CodeConvTOC.doc.html

3-23
3-24

Mdulo 4
Expresiones y control del flujo

Objetivos
para:
Diferenciar las variables de instancia de las variables locales.
Describir la forma de inicializar las variables de instancia.
Identificar y corregir errores de compilacin del tipo Possible

reference before assignment (posible referencia antes de
asignacin).
Reconocer, describir y utilizar los operadores del lenguaje Java.
Diferenciar entre asignaciones vlidas y no vlidas de los tipos

primitivos.
Identificar expresiones del tipo boolean y las reglas para usarlas en

las construcciones de control.
Reconocer la compatibilidad de asignaciones y las conversiones de

tipos necesarias en los tipos fundamentales.
Utilizar las construcciones if, switch, for, while y do y las formas

etiquetadas de break y continue como estructuras de control del
flujo en los programas.
En este mdulo se describe el uso de variables, operadores y expresiones

aritmticas, y se explican las diferentes estructuras de control que
gobiernan la direccin de ejecucin del cdigo.
4-1
Aspectos relevantes
Aspectos relevantes
!
?

Qu tipos de variables resultan tiles para los programadores?

_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
Puede haber varias clases que tengan variables con el mismo

nombre? Y, en caso afirmativo, cul es su mbito de accin?
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
Qu tipos de estructuras de control se utilizan en otros lenguajes?

Qu mtodos utilizan estos lenguajes para controlar el flujo
(por ejemplo en los bucles o las tomas de decisiones)?
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
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
Ejemplo de mbito de las variables
1
2
3
4
5
6
7
8
9
10
11
12
13
public class EjemploAmbito {

private int i=1;
1
2
3
4
5
6
public class PruebaAmbito {

EjemploAmbito ambito = new EjemploAmbito();
ambito.primerMetodo();
}
}
public void primerMetodo() {

int i=4, j=5;
this.i = i + j;
segundoMetodo(7);
}
public void segundoMetodo(int i) {
int j=8;
this.i = i + j;
}
}
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
Espacio de memoria dinmica
segundoMetodo
this
j
primerMetodo
EjemploAmbito
5
this
main
mbito
Figura 4-1
Diagrama de mbito de las variables del Cdigo 4-1

4-5
Variables
Inicializacin de las variables

Para poder usar una variable en un programa Java, es preciso inicializarla
antes. En el caso de las variables de pila de ejecucin, es fcil para el
compilador comprobar si el cdigo asigna un valor a la variable antes
intentar usarlo: la referencia this y los parmetros de los mtodos tienen
valores asignados cuando empieza a ejecutarse el mtodo. Es posible
comprobar las variables locales definidas en el mtodo examinando
nicamente el cdigo de ese mtodo. Por tanto, el compilador slo
permite al cdigo del mtodo leer el valor de una variable cuando
existe la certeza de que tiene uno asignado.
En el caso de los atributos de objetos situados en la memoria dinmica, no
es posible realizar esta comprobacin: cmo puede el compilador saber si
un cliente de nuestra clase llama a un mtodo de tipo set para actuar
sobre un objeto antes de que otro cliente cualquiera llame a un mtodo
de tipo get para actuar sobre ese mismo objeto? La nica forma
razonable de resolver este problema es obligar a asignar un valor inicial
directamente en el constructor. Si el programador no proporciona un valor
predeterminado, lo proporcionar el compilador. En la Tabla 4-1 figuran
los valores predeterminados de las variables de instancia con tipos
primitivos y de referencia.
Tabla 4-1 Valores predeterminados de los tipos primitivos
Variable
Valor
byte
short
int
long
0L
float
0.0F
double
0.0D
char
'\u0000'
boolean
false
Todos los tipos de referencia
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
Principio de inicializacin antes de uso

Aunque las variables definidas fuera de los mtodos se inicializan
automticamente, las variables locales deben inicializarse de forma manual
antes de usarlas. El compilador seala un error si detecta una situacin
en la que una variable puede utilizarse antes de su inicializacin.
public void hacerCalculo() {
int x = (int)(Math.random() * 100);
int y;
int z;
if (x > 50) {
y = 9;
}
z = y + x; // Posible uso antes de inicializacin
}
0

4-7
Operadores
Operadores
En esta seccin se describen los operadores utilizados en el lenguaje Java.
Orden de precedencia de los operadores

Los operadores del lenguaje Java son parecidos en estilo y funcin a los de
C y C++. La Tabla 4-2 contiene una lista de operadores por orden
de precedencia (I-D significa asociativos de izquierda a derecha; D-I
significa asociativos de derecha a izquierda).
Tabla 4-2 Operadores y orden de precedencia
Precedencia
Operadores
D-I
++ -- + - ~ ! (<tipo_dato>)
I-D
* / %
I-D
+ -
I-D
<< >> >>>
I-D
< > <= >= instanceof
I-D
== !=
I-D
&
I-D
I-D
I-D
&&
I-D
||
D-I
<expr_booleana> ? <expr1> : <expr2>
D-I
= *= /= %=
&= ^=
|=
+=
-=
<<= >>=
>>>=
Nota: El operador instanceof es exclusivo del lenguaje Java y se

describe en el Mdulo 6.
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.
Operadores lgicos de cortocircuito

Los operadores && (definido como AND) y || (definido como OR) evalan
expresiones lgicas en cortocircuito. Observe este ejemplo:
MiFecha d = reserva.getFechaSalida();
if ((d != null) && (d.day > 31)) {
// hacer algo con d
}
La expresin booleana que forma el argumento de la sentencia if ()
es vlida y totalmente segura. La razn es que la segunda subexpresin
no se evala si la primera subexpresin es false porque, cuando la
primera subexpresin es falsa, la expresin completa siempre es falsa,
independientemente de cmo se evale la segunda subexpresin.
Asimismo, si se utiliza el operador || y la primera expresin devuelve
true, la segunda expresin no se evala porque ya se sabe que toda la
expresin es verdad.

4-9
Operadores
Operadores lgicos de bits

Las operaciones de manipulacin de bits, que incluyen operaciones
lgicas y de desplazamiento, realizan operaciones de bajo nivel
directamente en las representaciones binarias utilizadas en los enteros.
Estas operaciones no se utilizan mucho en sistemas de tipo empresarial,
pero pueden ser vitales en sistemas grficos, cientficos o de control. La
posibilidad de operar directamente sobre los binarios puede contribuir a
ahorrar memoria, mejorar sustancialmente la eficiencia en ciertos clculos
y simplificar considerablemente las operaciones con conjuntos de bits,
tales como las de lectura o escritura en puertos de E/S paralelos.
El lenguaje Java admite operaciones de bits sobre tipos de datos enteros.
Se efectan mediante los operadores ~, &, ^ y | para las respectivas
operaciones NOT (complemento), AND, XOR y OR de nivel de bit
(bitwise).
La Figura 4-2 contiene ejemplos de los operadores de bits sobre nmeros
binarios del tamao de un byte.
0 0 1 0 1 1 0 1
~ 0 1 0 0 1 1 1 1
& 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
Ejemplos de operadores de bits

Operadores
Operadores de desplazamiento a la derecha >> y >>>

El lenguaje Java proporciona dos operadores de desplazamiento a la
derecha. El operador >> realiza un desplazamiento a la derecha aritmtico
o con signo. El resultado de este desplazamiento es que el primer
operando se divide por 2 elevado al nmero de veces especificado por
el segundo operando. Por ejemplo:
128 >> 1 devuelve 128/21 = 64
256 >> 4 devuelve 256/24 = 16
-256 >> 4 devuelve -256/24 = -16
El operador >> da como resultado la copia del bit de signo durante el
desplazamiento.
El operador de desplazamiento a la derecha lgico o sin signo >>> funciona
sobre el patrn de bits en lugar de sobre el significado aritmtico de un
valor y siempre coloca ceros (0) en los bits de ms peso, por ejemplo:
1010 ... >> 2 da como resultado 111010 ...
1010 ... >>> 2 da como resultado 001010 ...
Operador de desplazamiento a la izquierda <<

El operador << efecta un desplazamiento a la izquierda. Como resultado,
el primer operando se multiplica por dos elevado al nmero de veces
especificado por el segundo operando, por ejemplo:
128 << 1 devuelve 128*21 = 256
16 << 2 devuelve 16*22 = 64
Los tres operadores de desplazamiento reducen su mdulo de operando
derecho 32 en correspondencia a un tipo int y el mdulo 64 en
correspondencia a un operando izquierdo de tipo long. Por tanto,
cualquier expresin int x, x >>> 32 hace que x permanezca
invariable y no coloca ningn 0 como cabra esperar.
Los operadores de desplazamiento slo pueden utilizarse con tipos
enteros. El desplazamiento a la derecha sin signo efectuado por >>>
slo es efectivo con valores int o long. Si se utiliza con un valor short
o byte, el valor se convierte (con extensin de signo) en un valor int
antes de que se aplique >>>. En este punto, el desplazamiento sin signo
normalmente se ha convertido en un desplazamiento con signo.

4-11
Operadores
Ejemplos de operadores de desplazamiento

La Figura 4-3 contiene los patrones binarios de un nmero positivo y
otro negativo, as como los patrones binarios resultantes de las tres
operaciones de desplazamiento: >>, >>> y <<.
1357 =
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
Ejemplos de operadores de desplazamiento
Nota: El cdigo generado por estos ejemplos (incluida la salida en

pantalla del patrn binario completo) puede encontrarse en el archivo
examples/mod04_stmts/TestShift.java.
4-12

Operadores
Concatenacin de cadenas con +

El operador + realiza una concatenacin de objetos String para generar
un nuevo objeto String.
String saludo = "Dr. ";
String nombre = "Pedro" + " " + "Moreno";
String tratamiento = saludo + " " + nombre;
El resultado de la ltima lnea es:
Dr. Pedro Moreno
Si uno de los argumentos del operador + es un objeto String, el otro
argumento se convierte en objeto String. Todos los objetos pueden
convertirse en objeto String de forma automtica, pero el resultado puede
ser bastante crptico. El objeto que no es del tipo String se convierte en
una cadena equivalente utilizando la funcin miembro toString().
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
El tipo de destino deseado se escribe entre parntesis y se utiliza como

prefijo de la expresin que deba modificarse. Aunque puede no ser
necesario, es aconsejable escribir toda la expresin de conversin
de tipos entre parntesis. De lo contrario, la precedencia de los
elementos de la operacin puede crear problemas.

4-13
Operadores
Nota: Tambin es posible convertir tipos de variables con tipos de

referencia (vase el Mdulo 6).
Promocin y conversin de expresiones

Es posible promover las variables transformndolas en una forma
ms larga (por ejemplo transformar un tipo int en long) cuando no hay
riesgo de perder informacin.
long valgrande = 6;
int valormenor = 99L;
double z = 12.414F;
float z1 = 12.414;
// 6 es un tipo int, correcto

// 99L es un tipo long, incorrecto
// 12.414F es un tipo float, correcto

// 12.414 es double, incorrecto
En general, puede considerar que las expresiones son compatibles con la

asignacin de tipos si el tipo de la variable es, al menos, tan grande (valor
mximo) como el tipo de la expresin.
En el caso de los operadores binarios, como el operador +, cuando los
dos operandos tienen tipos numricos primitivos, el tipo resultante
se determina como el tipo ms largo de los dos operandos o int.
Por tanto, todas las operaciones binarias sobre tipos numricos dan
como resultado, como mnimo, un tipo int y puede que un tipo ms
largo si existen operandos con tipos long, float o double en la
expresin. Esto podra dar como resultado un desbordamiento o una
falta de precisin cuando se asigne el resultado a una variable.
Por ejemplo, el siguiente fragmento de cdigo:
short a, b, c;
a = 1;
b = 2;
c = a + b;
Provoca un error porque eleva cada tipo short a la categora de int
antes de operar con l. No obstante, si c se declara como int, o se efecta
una conversin de tipos de la forma siguiente:
c = (short)(a + b);
Entonces el cdigo funciona.
4-14

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.
Sentencias if, else sencillas

La sintaxis bsica de una sentencia if es:
if ( <expresin_booleana> )
<sentencia_o_bloque>
Por ejemplo:
if ( x < 10 )
System.out.println("Ya has acabado?");
No obstante, se recomienda situar todas las sentencias de consecuencia en
un bloque. Por ejemplo:
if ( x < 10 ) {
}
Sentencias if, else complejas

Si se necesita una clusula else, es preciso usar la sentencia if-else:
else
Por ejemplo:
if ( x < 10 ) {
} else {
System.out.println("Sigo trabajando...");
}

4-15
En caso de necesitar una serie de comprobaciones condicionales, es
posible encadenar una secuencia de sentencias if-else-if:
else if ( <expresin_booleana> )
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

Sentencia switch
La sintaxis de la sentencia switch es:
switch ( <expresin> ) {
case <constante1>:
<sentencia_o_bloque>*
[break;]
case <constante2>:
[break;]
default:
[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
Cdigo 4-2
Ejemplo 1 de sentencia switch
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
Ejemplo 2 de sentencia switch
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> )
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++ ) {
}
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> )
Por ejemplo:
int i = 0;
while ( i < 10 ) {
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
while ( <expr_prueba> );
Por ejemplo:
int i = 0;
do {
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
Construcciones especiales de control de bucles

Es posible utilizar las sentencias siguientes para controlar en mayor
medida las sentencias de bucles:
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;

4-21
Sentencias de bucle
Uso de sentencias break con etiquetas

ste es un ejemplo de bucle con una sentencia break etiquetada:
1
2
3
4
5
6
7
8
9
10
11
12
outer:
do {
sentencia1;
do {
sentencia2;
if ( condicin ) {
break outer;
}
sentencia3;
sentencia4;
Uso de sentencias continue con etiquetas

He aqu un ejemplo de bucle con una sentencia continue etiquetada:
1
2
3
4
5
6
7
8
9
10
11
12
4-22
test:
do {
sentencia1;
do {
sentencia2;
if ( condicin ) {
continue test;
}
sentencia3;
sentencia4;

Mdulo 5
Arrays
Objetivos
para:
Declarar y crear arrays de tipos primitivos, tipos de clase o de array.
Explicar por qu se inicializan los elementos de un array.
Explicar cmo se inicializan los elementos de un array.
Determinar el nmero de elementos en un array.
Crear arrays multidimensionales.
Escribir cdigo para copiar los valores de un array en otro.
En este mdulo se explica cmo definir, inicializar y usar arrays en el

lenguaje Java.
5-1
Aspectos relevantes
Aspectos relevantes
!
?
Discusin: Las pregunta siguiente es importante en relacin con el

Cul es el propsito de los arrays?
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
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
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
public char[] crearArray() {

char[] s;
s = new char[26];
for ( int i=0; i<26; i++ ) {
s[i] = (char) (A + i);
}
return s;
}
Este cdigo genera un array en el espacio de memoria dinmica con las

letras del alfabeto ingls en maysculas. El aspecto del array en la
memoria dinmica se muestra en la Figura 5-1.
Pila de ejecucin
char[]
A
B
C
D
crearArray
s
this
main
Figura 5-1
5-4
Creacin de un array con tipos primitivos de caracteres

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.
Creacin de arrays de referencia

Es posible crear arrays de objetos. La sintaxis utilizada es la misma:
p = new Point[10];
Esta lnea crea un array de 10 referencias de tipo Point, pero no crea
10 objetos Point. stos se crean por separado de la forma siguiente:
1
2
3
4
5
6
7
8
9
10
public Point[] crearArray() {

Point[] p;
p = new Point[10];
for ( int i=0; i<10; i++ ) {
p[i] = new Point(i, i+1);
}
return p;
}
Este cdigo genera un array en la memoria dinmica de forma que cada

elemento del array se llena con una referencia a un objeto Point. El
aspecto del array en la memoria dinmica se muestra en la Figura 5-2.
Pila de ejecucin
Point
Point[]
x
y
0
1
Point
x
y
crearArray
Point
this
main
Figura 5-2
1
2
x
y
2
3
Creacin de un array de tipos primitivos de caracteres con

objetos Point
Arrays
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];
Dado que este tipo de inicializacin es tediosa y el array de arrays

rectangular es la forma ms comn de array multidimensional, existe
un sistema abreviado para crear arrays bidimensionales. Por ejemplo,
puede utilizar el cdigo siguiente para crear un array de cuatro arrays
formados por cinco enteros cada uno:
int[][] dosDimen = new int[4][5];
Arrays
5-7
Lmites de los arrays
Lmites de los arrays

En el lenguaje Java, todos los ndices de arrays empiezan en 0. El nmero
de elementos de un array se almacena como parte del objeto array en el
atributo length. Si se intenta acceder a un valor fuera de los lmites
durante la ejecucin, se genera una excepcin.
Utilice el atributo length para iterar sobre los elementos de un array
como se muestra en el ejemplo de Cdigo 5-1.
Cdigo 5-1 Uso de los lmites del array para iterar sobre sus elementos
public void printElements(int[] list) {
for ( int i = 0; i < list.length; i++ ) {
System.out.println(list[i]);
}
}
El uso del atributo length facilita el mantenimiento del programa
porque evita la necesidad de conocer el nmero de elementos del array
en el momento de la compilacin.
Uso del bucle for mejorado

Iterar sobre los elementos de un array es una tarea muy habitual. En la
plataforma Java 2, Standard Edition (J2SE) versin 5.0 se ha introducido
un bucle for con mejoras para facilitar la iteracin de arrays. Su uso se
muestra en el Cdigo 5-2.
Cdigo 5-2 Uso del bucle for mejorado para la iteracin de arrays
public void printElements(int[] list) {
for ( int element : list ) {
System.out.println(element);
}
}
Esta versin del bucle puede interpretarse como: por cada elemento de la
lista haz. El compilador maneja el cdigo de iteracin. El ejemplo del
Cdigo 5-2 es equivalente al del Cdigo 5-1.
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
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);
En este punto, el array copia tiene el contenido siguiente: 1, 2, 3, 4, 5, 6, 4,

3, 2, 1.
Nota: El mtodo System.arraycopy copia referencias, no objetos, al
manejar arrays de objetos. Los objetos en s no cambian.
5-10

Mdulo 6
Diseo de clases
Objetivos
para:
Definir los conceptos de herencia, polimorfismo, sobrecarga, sobrescritura

y llamada a mtodos virtuales.
Usar los modificadores de acceso protected y el valor

predeterminado (acceso de paquete).
Describir los conceptos de sobrecarga de constructores y mtodos.
Describir la operacin completa de construccin e inicializacin.
ste es el segundo de tres mdulos en los que se describe el paradigma

de programacin orientada a objetos (OO) y las caractersticas de este
tipo de programacin aplicadas al lenguaje Java.
6-1
Aspectos relevantes
Aspectos relevantes
!
?
Discusin: La pregunta siguiente es importante en relacin con el

Cmo se implementa la herencia de objetos en el lenguaje Java?
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
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
+salario : double
+departamento : String
Figura 6-1
Diagramas de las clases Empleado y Gerente
En los ejemplos del Cdigo 6-1 y el Cdigo 6-2 se muestran posibles

implementaciones de las clases Empleado y Gerente segn estn
modeladas en la Figura 6-1.
Cdigo 6-1
Posible implementacin de la clase Empleado
public class Empleado {

public String nombre = "";
public double salario;
public Date fechaNacimiento;
public String getDetails() {...}
}
Cdigo 6-2
Posible implementacin de la clase Gerente
public class Gerente {

public String nombre = "";
public double salario;
public Date fechaNacimiento;
public String departamento;
public String getDetails() {...}
}
Diseo de clases
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
+salario : double
Gerente
+departamento : String
Figura 6-2
Diagramas de modelado de las clases Empleado y Gerente

mediante herencia
El ejemplo del Cdigo 6-3 contiene una implementacin de la clase

Gerente que hereda su definicin de la clase Empleado segn se ha
modelado en la Figura 6-2.
Cdigo 6-3
Otra implementacin de la clase Gerente
public class Gerente extends Empleado {

public String departamento;
}
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
+salario : double
Gerente
Ingeniero
Secretario
+departamento : String = ""
Director
+vehiculoEmpresa : double
+aumentarComision()
Figura 6-3
Ejemplo de rbol de herencia
La clase Empleado contiene tres atributos (nombre, salario y

fechaNacimiento), as como un mtodo (getDetails). La clase Gerente
hereda todos estos miembros y aade un atributo ms, departamento,
adems de usar el mtodo getDetails. La clase Director hereda
todos los miembros de Empleado y Gerente, pero adems agrega el
atributo vehiculoEmpresa y un nuevo mtodo, aumentarComision.
Asimismo, las clases Ingeniero y Secretario heredan los miembros de la
clase Empleado y podran tener otros miembros especficos (no se muestran).
Diseo de clases
6-5
Control del acceso
Control del acceso

Las variables y los mtodos pueden situarse en uno de estos cuatro
niveles de acceso: public, protected, predeterminado o private. Las
clases pueden tener los niveles de acceso public o predeterminado.
En la Tabla 6-1 se describen los niveles de acceso.
Tabla 6-1 Criterios de acceso
Modificador
La misma
clase
El mismo
paquete
private
predeterminado
protected
public
Subclase
Universal
Una variable o un mtodo marcados como private slo permiten el

acceso a otros mtodos que sean miembros de la misma clase a la que
pertenezcan la variable o el mtodo en cuestin.
Una variable, un mtodo o una clase ofrecen el modo de acceso
predeterminado si no tienen ningn modificador de acceso expresamente
definido como parte de su declaracin. Este tipo de acceso significa
que puede acceder a ellos cualquier mtodo perteneciente a las clases
que sean miembros del mismo paquete que el destino. Esto se llama a
veces nivel de acceso de paquete.
Una variable o un mtodo marcado con el modificador protected en
realidad es ms accesible que otro dotado de control de acceso
predeterminado. A los mtodos o variables en modo protected pueden
acceder los mtodos pertenecientes a las clases que son miembros
del mismo paquete y cualquier mtodo de cualquier subclase. Es
aconsejable usar el acceso protegido cuando es apropiado para una
subclase de una clase, pero no para las clases no relacionadas.
Las variables y mtodos marcados con el modificador public
proporcionan acceso universal.
Nota: Se ofrece acceso protegido a las subclases que residen en un paquete
distinto al de la clase que posee el modificador protected.
6-6

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:
protected String nombre;
protected double salario;
protected Date fechaNacimiento;
public String getDetails() {
return Nombre: + nombre + \n
+ Salario: + salario;
}
}
protected String departamento;
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
6-7
Los mtodos sobrescritos no pueden ser menos

accesibles
Recuerde que, para que un mtodo pueda sustituir al de una clase de
nivel superior, su nombre y el orden de sus argumentos deben ser
idnticos a los del mtodo de la superclase. Asimismo, el mtodo
sustitutivo no puede ser menos accesible que el mtodo al que sustituye.
Analice este fragmento de cdigo incorrecto:
public class Padre {
public void hacerAlgo() {}
}
public class Hijo extends Padre {
private void hacerAlgo() {} // no vlido
}
public class UsoAmbos {
public void hacerOtraCosa() {
Padre p1 = new Padre();
Padre p2 = new Hijo();
p1.hacerAlgo();
p2.hacerAlgo();
}
}
La semntica del lenguaje Java dice que p2.metodo() debe provocar la
ejecucin de la versin del mtodo correspondiente a Hijo, pero, como el
mtodo se ha declarado private, p2 (declarado como Padre) no puede
acceder a l. Por tanto, se no se ha respetado la semntica del lenguaje.
6-8

Llamada a mtodos sobrescritos

Un mtodo de una subclase puede llamar a un mtodo de una superclase
utilizando la palabra clave super.
La palabra super se refiere a la superclase de la clase en la que se ha
utilizado esta clave. Se usa para hacer referencia a las variables miembro o
a los mtodos de la superclase.
Se consigue utilizando la palabra clave super de la forma siguiente:
private String nombre;
private double salario;
private Date fechaNacimiento;
return "Nombre: " + nombre + "\nSalario: " + salario;
}
}
private String departamento;
// llama al mtodo de la superclase
return super.getDetails()
+ "\nDepartamento: " + departamento;
}
}
Una llamada con el formato super.metodo() llama al comportamiento
completo, incluido cualquier efecto secundario del mtodo al que se
llamara si el objeto hubiera sido una clase de nivel superior. El mtodo no
tiene por qu estar definido en la clase de nivel inmediatamente superior,
puede heredarse de alguna clase situada ms arriba en la jerarqua.
Nota: En el ejemplo anterior, las variables miembro se han declarado
como private. No es necesario pero, en general, es una buena prctica
de programacin.
Diseo de clases
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
Llamada a mtodos virtuales

Supongamos que es cierto lo siguiente:
Empleado e = new Empleado();
Gerente m = new Gerente();
Si hace una llamada a e.getDetails() y a m.getDetails(), est
llamando a diferentes comportamientos. El objeto Empleado ejecuta la
versin de getDetails() asociada a la clase Empleado y el objeto
Gerente ejecuta la versin de getDetails() asociada a la clase Gerente.
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]
personal = new Empleado[1024];

= new Gerente();
= new Empleado();
= new Ingeniero();
Diseo de clases
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
Nota: Recuerde que, aunque es aceptable, la expresin extends Object

es redundante. Se ha incluido aqu a modo de recordatorio.
Si recibe un objeto utilizando una referencia del tipo Empleado, puede que
resulte ser un Gerente o un Ingeniero. Puede comprobarlo utilizando
instanceof de la forma siguiente:
public void hacerAlgo(Empleado e) {
if ( e instanceof Gerente ) {
// Procesar un Gerente
} else if ( e instanceof Ingeniero ) {
// Procesar un Ingeniero
} else {
// Procesar cualquier otro tipo de Empleado
}
}
Nota: En C++ es posible hacer algo similar utilizando la informacin de

tipos de tiempo de ejecucin (RTTI).
Diseo de clases
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
Las conversiones en direccin ascendente dentro de la jerarqua de

clases siempre estn permitidas y, de hecho, no precisan el operador
de conversin. Se pueden hacer mediante una simple asignacin.
En el caso de las conversiones en direccin descendente, el compilador

debe poder considerar que la conversin es, al menos, posible.
Por ejemplo, no se permitir ningn intento de convertir una
referencia a Gerente en una referencia a Ingeniero, porque el
Ingeniero no es un Gerente. La clase de destino de la conversin
tiene que ser una subclase del tipo de referencia actual.
Si el compilador permite la conversin, el tipo de objeto se

comprueba durante el tiempo de ejecucin. Por ejemplo, si se
omite la comprobacin instanceof en el cdigo y el objeto que se
va a convertir en realidad no es del tipo en el que se va a convertir, se
producir un error de tiempo de ejecucin (excepcin). Las
excepciones son una forma de error de tiempo de ejecucin que
se tratan ms adelante en el mdulo.

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:
Las listas de argumentos deben ser diferentes.

Las listas de argumentos de la sentencia de llamada deben diferir lo
suficiente como para poder determinar sin ambigedad cul es el
mtodo al que se debe llamar. Es posible aplicar las promociones
normales para el alargamiento de tipos (por ejemplo, de float a
double), pero esto puede provocar confusin el determinadas
condiciones.
Los tipos de retorno pueden ser diferentes.

El tipo de retorno de los mtodos puede ser diferente, pero no es
suficiente si sta es la nica diferencia. Las listas de argumentos
de los mtodos sobrecargados deben ser distintas.
Diseo de clases
6-15
Mtodos que usan argumentos variables

Existe una variante de la sobrecarga que se produce cuando es preciso
usar un mtodo que utiliza cierto nmero de argumentos del mismo tipo.
Supongamos que necesita crear un mtodo que calcule el promedio de
una serie de enteros. Podra definir los mtodos siguientes:
public class Estadistica {
public float average(int x1, int x2) {}
public float average(int x1, int x2, int x3) {}
public float average(int x1, int x2, int x3, int x4) {}
}
Es posible llamar a estos mtodos de la manera siguiente:
float gradePointAverage = stats.average(4, 3, 4);
float averageAge = stats.average(24, 32, 27, 18);
Estos tres mtodos sobrecargados comparten la misma funcionalidad.
Sera conveniente poder concentrar todos estos mtodos en uno solo.
J2SE versin 5.0 ahora proporciona una funcin, llamada varargs o
argumentos variables, que permite escribir un mtodo ms genrico:
public class Estadistica {
public float average(int... nums) {
int sum = 0;
for ( int x : nums ) {
sum += x;
}
return ((float) sum) / nums.length;
}
}
La llamada a este nuevo mtodo de argumentos variables se realiza de
la misma forma que la del conjunto de mtodos sobrecargados. Observe
que el argumento nums en realidad es un objeto array de tipo int[].
Esto permite al mtodo iterar sobre los elementos y obtener el nmero
de elementos (es decir, la longitud del array).
6-16

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
Ejemplo de sobrecarga de constructores

private static final double SALARIO_BASE = 15000.00;
private double salario;
public Empleado(String nombre, double salario, Date FdeNac) {
this.nombre = nombre;
this.salario = salario;
this.fechaNacimiento = FdeNac;
}
public Empleado(String nombre, double salario) {
this(nombre, salario, null);
}
public Empleado(String nombre, Date FdeNac) {
this(nombre, SALARIO_BASE, FdeNac);
}
public Empleado(String nombre) {
this(nombre, SALARIO_BASE);
}
// ms cdigo de Empleado...
}
La palabra clave this en un constructor debe ser la primera lnea
de cdigo del constructor. Puede haber ms cdigo de inicializacin
despus de la llamada this, pero no antes.
Diseo de clases
6-17
Los constructores no se heredan

Aunque las subclases heredan todos los mtodos y variables de sus
superclases, no heredan sus constructores.
Las clases slo pueden obtener un constructor de dos maneras:
debe escribirlo el programador o, si ste no lo escribe, debe usar el
constructor predeterminado. Siempre se llama al constructor de nivel
superior adems de llamar al constructor subordinado. Este concepto
se describe con ms detalle ms adelante en el mdulo.
Llamada a los constructores de las clases de nivel

superior
Al igual que los mtodos, los constructores pueden llamar a los
constructores no privados de la superclase inmediatamente anterior.
A menudo se define un constructor con determinados argumentos y se
quiere usar esos mismos argumentos para controlar la construccin de la
parte superior de un objeto. Puede llamar a un determinado constructor
de una superclase como parte de la inicializacin de una subclase
utilizando la palabra clave super en la primera lnea del constructor de
la subclase. Para controlar la llamada de ese constructor concreto, es
preciso suministrar los argumentos adecuados a super(). Cuando no
hay ninguna llamada a super con argumentos, se llama implcitamente
al constructor de la superclase que tenga cero argumentos. En ese caso,
si no hay ningn constructor de nivel superior que tenga cero
argumentos, se produce un error de compilacin.
La llamada a super() puede adoptar cualquier cantidad de argumentos
adecuados para los distintos constructores disponibles en la clase
superior, pero debe ser la primera sentencia del constructor.
Si suponemos que la clase Empleado tiene el conjunto de constructores
definidos en el Cdigo 6-4 de la pgina 6-17, entonces se definiran los
siguientes constructores en Gerente. El constructor de la lnea 12 no es
vlido porque el compilador introduce una llamada implcita a la
clase super() y en la clase Empleado no se ha suministrado ningn
constructor sin argumentos.
6-18

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

public Gerente(String nombre, double salario, String depto) {
super(nombre, salario);
departamento = depto;
}
public Gerente(String nombre, String depto) {
super(nombre);
}
public Gerente(String depto) { // Este cdigo da error: no hay super()
}
}
Si se utilizan, es preciso colocar super o this en la primera lnea del
constructor. Si escribe un constructor que no contiene ninguna llamada a
super(...) ni a this(...), el compilador introduce una llamada al
constructor de la superclase de forma automtica y sin argumentos.
Otros constructores pueden llamar tambin a super(...) o this(...),
con lo que se hace una llamada a una cadena de constructores. Lo
que ocurre al final es que el constructor de la clase de nivel superior
(o quizs varios de ellos) se ejecuta antes que ningn otro constructor
subordinado de la cadena.
Diseo de clases
6-19
Construccin e inicializacin de objetos: ampliacin de conceptos
Construccin e inicializacin de objetos: ampliacin de

conceptos
La inicializacin de objetos es un proceso bastante complejo. En la
seccin Construccin e inicializacin de objetos en el Mdulo 3,
Identificadores, palabras clave y tipos, se ofreci una explicacin bsica.
En esta seccin, veremos la totalidad del proceso.
En primer lugar se reserva la memoria del objeto completo y se asignan
los valores predeterminados para las variables de instancia. En segundo
lugar, se llama al constructor de nivel superior, que sigue estos pasos
de forma recursiva a lo largo de todo el rbol de herencia de clases:
1.
Enlazar los parmetros del constructor.
2.
Si hay una llamada explcita a this(), hacer la llamada de forma

recursiva y luego ir directamente al Paso 5.
3.
Llamar recursivamente a la sentencia super(...) explcita o

implcita, salvo en el caso de la clase Object, que no tiene
ninguna superclase.
4.
Ejecutar los inicializadores de variables de instancia explcitos.
5.
Ejecutar el cuerpo del constructor actual.
Ejemplos de construccin e inicializacin

Por ejemplo, utilice el cdigo siguiente para las clases Gerente y
Empleado:
6-20
1
2
3
public class Object {

public Object() {}
}
1
2
3
4
5
6
7
8
9
10
11
public class Empleado extends Object {

private double salario = 15000.00;
public Empleado(String n, Date FdeNac) {
// super() implcito;
nombre = n;
fechaNacimiento = FdeNac;
}
public Empleado(String n) {

Construccin e inicializacin de objetos: ampliacin de conceptos

12
13
14
1
2
3
4
5
6
7
8
this(n, null);
}
}
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
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:
// 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
Ejemplo de cdigo con equals

En este ejemplo, la clase MyDate se ha modificado para incluir un
mtodo equals que compara los atributos de ao, mes y da.
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

private int day;
private int month;
private int year;
public MyDate(int day, int month, int year) {
this.day
= day;
this.month = month;
this.year = year;
}
public boolean equals(Object o) {
boolean result = false;
if ( (o != null) && (o instanceof MyDate) ) {
MyDate d = (MyDate) o;
if ( (day == d.day) && (month == d.month)
&& (year == d.year) ) {
result = true;
}
}
return result;
}
public int hashCode() {
return (day ^ month ^ year);
}
}
Mtodo hashCode implementa un XOR de bits de los atributos de fecha.
Esto hace que el cdigo hash de los objetos iguales de MyDate tenga el
mismo valor y ofrece la posibilidad de que fechas diferentes devuelvan
valores diferentes.
El programa siguiente compara dos objetos MyDate que no son idnticos
pero son iguales en cuanto a la comparacin de ao-mes-da.
1
2
3
4
5
class TestEquals {
MyDate date1 = new MyDate(14, 3, 1976);
MyDate date2 = new MyDate(14, 3, 1976);
Diseo de clases
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
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
Los objetos de clase envoltorio se construyen pasando el valor que debe

encapsularse al constructor adecuado, como se ilustra en el Cdigo 6-5.
Cdigo 6-5
Ejemplos de conversin de primitivos en clases envoltorio
int pInt = 420;

Integer wInt = new Integer(pInt); // esto se denomina
boxing
int p2 = wInt.intValue(); // esto se denomina unboxing
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);
Conversin automtica de tipos primitivos en objetos:

autoboxing
Si necesita cambiar los tipos de datos primitivos en su objeto equivalente
(operacin denominada boxing), necesita utilizar las clases envoltorio.
Igualmente, para obtener el tipo de dato primitivo a partir de la referencia
del objeto (lo que se denomina unboxing), tambin necesita usar los
mtodos de las clases envoltorio. Todas estas operaciones de conversin
pueden complicar el cdigo y dificultar su comprensin. En la versin 5.0
de J2SE se ha introducido una funcin de conversin automtica
denominada autoboxing que permite asignar y recuperar los tipos
primitivos sin necesidad de usar clases envoltorio.
El ejemplo del Cdigo 6-6 contiene dos casos sencillos de conversin y
recuperacin automtica de primitivos (autoboxing y autounboxing).
Comprese con el ejemplo del Cdigo 6-5 de la pgina 6-26.
Cdigo 6-6
Ejemplos de autoboxing de primitivos
int pInt = 420;

Integer wInt = pInt; // esto se denomina autoboxing
int p2 = wInt; // esto se denomina autounboxing
El compilador de J2SE versin 5.0 ahora crear el objeto envoltorio
automticamente cuando se asigne un primitivo a una variable del tipo de
clase envoltorio. Asimismo, el compilador extraer el valor primitivo
cuando realice la asignacin de un objeto envoltorio a una variable de
tipos primitivos.
Esto puede hacerse al pasar parmetros a mtodos o, incluso, dentro de
las expresiones aritmticas.
Diseo de clases
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
Conceptos avanzados sobre las clases

Objetivos
para:
Crear variables, mtodos e inicializadores estticos.
Crear clases, mtodos y variables finales.
Crear y usar tipos enumerados.
Usar la sentencia de importacin esttica.
Crear clases y mtodos abstractos.
Crear y usar una interfaz.
Este mdulo profundiza en las caractersticas de programacin OO del

lenguaje Java.
7-1
Aspectos relevantes
Aspectos relevantes
!
?

Cmo se crea una constante?

_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
Cmo se declara un dato que comparten todas las instancias de una

determinada clase?
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
Cmo se impide la creacin de una subclase a partir de una clase o

la sobrescritura de un mtodo?
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
7-2

Palabra clave static

La palabra static declara miembros (atributos, mtodos y clases anidadas)
que estn asociados a una clase en vez de a una instancia de la clase.
En las secciones siguientes se explican los usos ms comunes de la palabra
clave static: variables de clase y mtodos de clase.
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
Diagrama UML de la clase Count y dos instancias nicas
El modo compartido se consigue marcando la variable con la palabra

static. Este tipo de variables a veces se denominan variables de clase
para distinguirlas de los miembros o las variables de instancia, que no
se comparten.
1
2
3
4
5
6
7
8
9
public class Counter {

private int serialNumber;
public static int counter = 0;
public Counter() {
counter++;
serialNumber = counter;
}
}
En este ejemplo, a cada objeto que se crea se le asigna un nmero de

serie exclusivo que empieza desde 1 y contina en sentido ascendente.
Todas las instancias comparten la variable counter por lo que, cuando
el constructor de un objeto incrementa counter, el siguiente objeto que
se crea recibe el valor incrementado.

7-3

Las variables static guardan cierto parecido con las variables globales de
otros lenguajes. Java no tiene variables globales, pero una variable esttica es
una sola variable a la que puede acceder cualquier instancia de la clase.
Si una variable static no se marca como private, es posible acceder a
ella desde fuera de la clase. Para hacerlo, no se necesita ninguna instancia
de la clase, basta hacer referencia a ella mediante el nombre de la clase.
1
2
3
4
5
public class OtraClase {

public void incrementNumber() {
Count1.counter++;
}
}
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
public class Count2 {

private static int counter = 0;
public static int getTotalCount() {
return counter;
}
public Count2() {
counter++;
serialNumber = counter;
}
Debe acceder a los mtodos estticos utilizando el nombre de la clase en

lugar de una referencia al objeto, de la forma siguiente:
1
2
3
4
5
6
7
8
9
7-4
public class TestCounter {

System.out.println("El nmero del contador es "
+ Count2.getTotalCount());
Count2 count1 = new Count2();
System.out.println("El nmero del contador es "
+ Count2.getTotalCount());
}
}


La salida del programa TestCounter es:
El nmero del contador es 0
El nmero del contador es 1
Dado que puede llamar a un mtodo static sin necesidad de tener una
instancia de la clase a la que pertenece, no existe ningn valor this.
Como consecuencia, un mtodo static no puede acceder a ninguna
variable salvo a las variables locales, los atributos static y sus
parmetros. Cualquier intento de acceder a atributos que no sean
estticos provoca un error de compilacin.
Los atributos no estticos se limitan a una instancia y slo se puede
acceder a ellos mediante referencias a esa instancia.
1
2
3
4
5
6
7
8

public static int getSerialNumber() {
return serialNumber; // ERROR DE COMPILACIN
}
}
Cuando use mtodos estticos, debe tener en cuenta lo siguiente:
No es posible sobrescribir un mtodo static pero s puede

ocultarse.
Para poder sobrescribir un mtodo, tiene que ser no esttico. La
existencia de dos mtodos estticos con la misma firma en una
jerarqua de clases simplemente significa que son dos mtodos
de clase independientes. Si se aplica un mtodo de clase a una
referencia de objeto, el mtodo llamado ser el correspondiente a
la clase para la que se haya declarado la variable.
El mtodo main() es un mtodo static porque JVM no crea

ninguna instancia de la clase cuando lo ejecuta. Por tanto, si tiene
datos de miembros, debe crear un objeto para acceder a ellos.

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

public static int counter;
static {
counter = Integer.getInteger("myApp.Count4.counter").intValue();
}
}
1
2
3
4
5
public class TestStaticInit {

System.out.println("counter = "+ Count4.counter);
}
}
En el cdigo de la lnea 4 de la clase Count4 se ha utilizado un mtodo
esttico de la clase Integer getInteger(String), el cual devuelve un
objeto Integer que representa el valor de una propiedad del sistema. Esta
propiedad, denominada myApp.Count4.counter, se define en la lnea de
comandos con la opcin -D. El mtodo intValue del objeto Integer
devuelve el valor como un tipo int.
El resultado es el siguiente:
java -DmyApp.Count4.counter=47 TestStaticInit
counter = 47
7-6

Palabra clave final
Palabra clave final

En esta seccin se describen las clases, los mtodos y las variables finales.
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
Palabra clave final
Nota: Si se marca una variable con un tipo de referencia (es decir,

cualquier tipo de clase) como final, esa variable no puede hacer
referencia a ningn otro objeto. No obstante, s es posible cambiar el
contenido del objeto, porque slo es final la referencia en s.
Variables finales vacas

Una variable final vaca es aquella que no se inicializa en su declaracin.
La inicializacin se pospone. Este tipo de variables deben asignarse en
un constructor, pero slo pueden definirse una vez. Si la variable final
vaca es local, puede definirse en cualquier momento en el cuerpo del
mtodo, pero slo puede definirse una vez. En el siguiente fragmento de
cdigo puede ver cmo se utiliza una de estas variables en una clase:
public class Customer {
private final long customerID;
public Customer() {
customerID = createID();
}
public long getID() {
return customerID;
}
private long createID() {
return ... // genera nuevo ID
}
... // ms declaraciones
}
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
Creacin de tipos enumerados en versiones anteriores

de Java
El Cdigo 7-1 contiene un ejemplo de la forma en que se creaban los
tipos enumerados antes de la versin 5.0 de J2SE, es decir, creando
constantes con valores enteros para los nombres simblicos de los
valores enumerados.
Cdigo 7-1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
Ejemplo de la antigua versin de tipos enumerados
package naipes.domain;
public class NaipeBaraja {
// tipo seudoenumerado
public static final int
PALO_PICAS
= 0;
PALO_CORAZONES
= 1;
PALO_TREBOLES
= 2;
PALO_DIAMANTES = 3;
private int palo;

private int rango;
public NaipeBaraja(int palo, int rango) {
this.palo = palo;
this.rango = rango;
}
public int getPalo() {
return palo;
}
Nota: El atributo rango tambin es un buen candidato para crear un tipo

enumerado, pero este cdigo no usa tipos enumerados para mayor
brevedad.
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
public String getNamePalo() {

String name = "";
switch ( palo ) {
case PALO_PICAS:
name = "Picas";
break;
case PALO_CORAZONES:
name = "Corazones";
break;
case PALO_TREBOLES:
name = "Treboles";
break;
case PALO_DIAMANTES:
name = "Diamantes";
break;
default:
System.err.println("Palo no vlido.");
}
return name;
}

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 {
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);
}
}
No obstante, cuando se ejecute el programa, se dar cuenta de que el

segundo objeto naipe no es vlido y no se muestra adecuadamente:
> java naipes.tests.TestNaipeBaraja
el naipe1 es: 2 de Picas
Palo no vlido.
naipe2 es: 2 de
La expresin Palo no vlido. es el mensaje de error enviado por el
mtodo getNamePalo en la lnea 38 del Cdigo 7-2.
7-12

Tipos enumerados
Esta modalidad de tipo enumerado presenta varios problemas:
No mantiene la seguridad de los tipos: puesto que el atributo palo

es simplemente un tipo int, es posible pasarlo a cualquier otro valor
int donde se necesite especificar el palo. Adems, se podran aplicar
incluso operaciones aritmticas a dos palos, lo que no tiene sentido.
No hay espacio de nombres: es preciso agregar un prefijo a las

constantes de los tipos enumerados int con una cadena (en este
caso, PALO_) para evitar conflictos con otros tipos enumerados int.
Por ejemplo, si utilizase un tipo enumerado int para el valor de
rango, seguramente creara un conjunto de constantes RANGO_XYZ
de tipo int.
Inestabilidad: dado que los tipos enumerados int son constantes

durante el tiempo de compilacin, se compilan en los clientes que los
utilizan. Si se agrega una nueva constante entre dos constantes
existentes o se cambia su orden, es preciso recompilar los clientes.
Si no se hace as, seguirn ejecutndose, pero su comportamiento
ser indeterminado.
Salida en pantalla poco informativa: dado que se trata de valores

enteros, todo lo que se ve cuando aparecen en pantalla es un
nmero, lo cual dice poco del valor o el tipo al que representan.
sta es la razn por la que la clase NaipeBaraja necesita el
mtodo getNamePalo.
El nuevo tipo enumerado

La versin 5.0 de Java SE incluye una modalidad de tipos enumerados
que mantiene la seguridad de los tipos (typesafe enum). En el Cdigo 7-4
se muestra un tipo enumerado para representar los palos de una baraja
de cartas. Piense en el tipo Palo como en una clase con un conjunto
finito de valores que reciben los nombres simblicos incluidos en la
definicin del tipo. Por ejemplo, Palo.PICAS es del tipo Palo.
Cdigo 7-4
1
2
3
4
5
6
7
8
Tipo enumerado Palo
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
Clase NaipeBaraja con el tipo Palo
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
import naipes.domain.Palo;
NaipeBaraja naipe1
= new NaipeBaraja(Palo.PICAS, 2);
// NaipeBaraja naipe2 = new NaipeBaraja(47, 2);
// Esto no se compilar.
}
}

7-15
Tipos enumerados
Tipos enumerados avanzados

Lamentablemente, la clase NaipeBaraja sigue necesitando un mtodo
getNamePalo para mostrar en la interfaz grfica un nombre que resulte
fcil de leer al usuario. Si el programa mostrarse el verdadero valor de
Palo, mostrara el nombre simblico del valor del tipo. Por ejemplo,
Palo.PICAS aparecera como PICAS. Esto resulta ms reconocible para
el usuario que 0, pero no tanto como Picas.
Por otro lado, el nombre del palo no debera formar parte de la clase
NaipeBaraja sino, ms bien, del tipo Palo. La nueva modalidad de tipos
enumerados permite usar atributos y mtodos, igual que en las clases
normales. El Cdigo 7-7 muestra una versin mejorada del primer tipo
Palo (Cdigo 7-4 de la pgina 7-13) con un atributo nombre y un mtodo
getName. Observe cmo se oculta la informacin de la forma adecuada
con el atributo private y el mtodo de acceso public.
Cdigo 7-7
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
Tipo Palo con un atributo
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;
}
}
Un constructor enum siempre debera utilizar acceso privado. Los

argumentos del constructor se suministran despus de cada valor
declarado. Por ejemplo, en la lnea 4, la cadena "Picas" es el
argumento del constructor enum para el valor PICAS. Los tipos
enumerados pueden tener cualquier cantidad de atributos y mtodos.
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
Programa TestNaipeBaraja con mtodos Palo
import naipes.domain.Palo;
NaipeBaraja naipe1
= new NaipeBaraja(Palo.PICAS, 2);
+ " de " + naipe1.getPalo().getName());
// NuevoNaipeBaraja naipe2 = new NuevoNaipeBaraja(47, 2);
}
}

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
Programa TestNaipeBaraja con importaciones estticas
import static naipes.domain.Palo.*;
NaipeBaraja naipe1 = new NaipeBaraja(PICAS, 2);
+ " de " + naipe1.getPalo().getName());
// NuevoNaipeBaraja naipe2 = new NuevoNaipeBaraja(47,
}
}
Atencin: Procure distanciar el uso de estas importaciones. Si abusa de

ellas, puede hacer que el programa se convierta en un cdigo ilegible y
difcil de mantener ya que contaminar su espacio de nombres con todos
los miembros estticos que importe. Las personas que lean el cdigo
(incluido usted mismo transcurridos unos meses) no sabrn de qu clase
procede cada miembro esttico. La importacin de todos los miembros
estticos de una clase puede afectar muy negativamente a la legibilidad.
Si slo necesita uno o dos miembros, imprtelos de forma individual. Si se
usa con prudencia, la importacin esttica puede facilitar la lectura del
cdigo, ya que elimina la repeticin estndar de los nombres de clases.
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
Modelo UML de la flota de la empresa
El programa TransporteMain muestra la inicializacin de una flota de

ejemplo.
1
public class TransporteMain {
2
3
Empresa c = new Empresa();
4
5
// llena la empresa con una flota de vehculos
6
c.addVehiculo( new Camion(10000.0) );
7
8
c.addVehiculo( new Barcaza(500000.0) );
9
10
c.addVehiculo( new Barcaza(750000.0) );
11
12
InformeCombustibleNecesario informe = new
InformeCombustibleNecesario(c);
13
informe.generateText(System.out);
14
}
15 }

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
mtodos
Figura 7-3
Modelo UML de la clase abstracta Vehiculo
La Figura 7-3 presenta un modelo UML de la solucin. Vehiculo es una

clase abstracta con dos mtodos abstractos de acceso public.
Nota: UML utiliza letras en cursiva para indicar elementos abstractos en
los diagramas de clases. Tambin se pueden marcar las clases abstractas
con el indicador {abstract} en la seccin de nombre.
El compilador de Java impide instanciar clases abstractas. Por ejemplo, la
sentencia new Vehiculo() no es vlida.
La declaracin de la clase Vehiculo es:
1
2
3
4
public abstract class Vehiculo {

public abstract double calcEficienciaConsumo();
public abstract double calcDistanciaViaje();
}

7-21
Clases abstractas
La clase Camion debe crear una implementacin:
1
2
3
4
5
6
7
8
9
public class Camion extends Vehiculo {

public Camion(double cargaMax) {...}
public double calcEficienciaConsumo() {
// calcula el consumo de combustible de un camin
}
public double calcDistanciaViaje() {
// calcula la distancia de este viaje por autopista
}
}
La clase Barcaza debe crear una implementacin:

1
2
3
4
5
6
7
8
9
public class Barcaza extends Vehiculo {

public Barcaza(double cargaMax) {...}
public double calcEficienciaConsumo() {
// calcula el consumo de combustible de una barcaza
}
public double calcDistanciaViaje() {
// calcula la distancia de este viaje por vas fluviales
}
}
No obstante, las clases abstractas pueden tener atributos de datos, mtodos

concretos y constructores. Por ejemplo, la clase Vehiculo podra incluir
los atributos carga y cargaMax y un constructor para inicializarlos. Es
aconsejable marcar estos constructores como protected en lugar de
public, porque slo tiene sentido que la llamada a estos constructores
se efecte mediante las subclases de la clase abstracta. Declararlos como
protegidos hace que resulte ms obvio para el programador que el
constructor no debera recibir la llamada de clases arbitrarias.
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
Ejemplo del objeto volador

Imagine un grupo de objetos que comparten la misma habilidad:
pueden volar. Puede construir una interfaz pblica llamada
ObjetoVolador que admite tres operaciones: despegar, aterrizar y
volar. (vase la Figura 7-4).
interfaz
ObjetoVolador
+despegar()
+aterrizar()
+volar()
Avin
+despegar()
+aterrizar()
+volar()
Figura 7-4
7-24
ClaseAvion e implementacin de la interfaz ObjetoVolador
1
2
3
4
5
public interface ObjetoVolador {

public void despegar();
public void aterrizar();
public void volar();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class Avion implements ObjetoVolador {

public void despegar() {
// acelerar hasta despegar
// subir el tren de aterrizaje
}
public void aterrizar() {
// bajar el tren de aterrizaje
// decelerar y desplegar flaps hasta tocar tierra
// frenar
}
public void volar() {
// mantener los motores en marcha
}
}

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()
Mltiples implementaciones de la interfaz ObjetoVolador
Un Avion es un Vehiculo y puede volar. Un Ave es un Animal y puede

volar. Estos ejemplos muestran que una clase puede heredar elementos
de una clase, pero tambin de otra interfaz.

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()
Mezcla de herencia e implementacin
El cdigo siguiente describe la clase Ave:

public class Ave extends Animal implements ObjetoVolador {
public void despegar() { /* implementacin de despegar */ }
public void aterrizar()
{ /* implementacin de aterrizar */ }
public void volar()
{ /* implementacin de volar */ }
public void hacerNido(){ /* comportamiento de nidificacin */ }
public void ponerHuevos() { /* implementacin de puesta de huevos */
}
public void comer() { /* sobrescritura de la accin de comer */ }
}
La clusula extends debe especificarse antes que la clusula implements.
La clase Ave puede suministrar sus propios mtodos (hacerNido y
ponerHuevos), as como sobrescribir los mtodos de la clase Animal (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
Jerarqua de clases del ejemplo de aeropuerto
El cdigo del aeropuerto podra parecerse al siguiente:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class Aeropuerto {

Aeropuerto aeropuertoCiudad = new Aeropuerto();
Helicoptero helicoptero = new Helicoptero();
Hidroavion hAvion = new Hidroavion();
aeropuertoLondres.darPermisoAterrizar(helicoptero);
aeropuertoLondres.darPermisoAterrizar(hAvion);
}
private void darPermisoAterrizar(ObjetoVolador v) {
v.aterrizar();
}
}

7-27
Interfaces
Ejemplo de mltiples interfaces

Una clase puede implementar varias interfaces. El Hidroavion no slo
puede volar, sino tambin navegar. La clase Hidroavion ampla la
clase Avion, con lo que hereda esa implementacin de la interfaz
ObjetoVolador. La clase Hidroavin tambin implementa la interfaz
Nautico. Su modelo se muestra en la Figura 7-8.
interfaz
ObjetoVolador
+despegar()
+aterrizar()
+volar()
Vehiculo
Barcaza
Avion
+atracar()
+navegar()
interfaz
+despegar()
+aterrizar()
+volar()
Nautico
+atracar()
+navegar()
Hidroavion
Helicoptero
+atracar()
+navegar()
Figura 7-8
Ejemplo de varias implementaciones
Ahora escriba la clase Puerto para dar permisos de atraque:

1
2
3
4
5
6
7
8
9
10
11
12
13
7-28
public class Puerto {

Puerto puertoBarcelona = new Puerto();
Barcaza barcaza = new Barcaza();
Hidroavion hAvion = new Hidroavion();
puertoBarcelona.darPermisoAtracar(barcaza);
puertoBarcelona.darPermisoAtracar(hAvion);
}
private void darPermisoAtracar(Nautico n) {
n.atracar();
}
}

Interfaces
El hidroavin puede despegar del aeropuerto de Londres y atracar en el
puerto de Barcelona.
Usos de las interfaces

Las interfaces se utilizan para:
Declarar mtodos que sern implementados por una o varias clases.
Dar a conocer la interfaz de programacin de un objeto sin revelar el

verdadero cuerpo de la clase (esto puede ser til al distribuir un
paquete de clases a otros desarrolladores).
Identificar las similitudes entre clases no relacionadas sin tener que

establecer ninguna relacin entre ellas.
Simular la herencia mltiple declarando una clase que implemente

varias interfaces.

7-29
Mdulo 8
Excepciones y aserciones
Objetivos
para:
Definir excepciones.
Usar las sentencias try, catch y finally.
Describir categoras de excepciones.
Identificar excepciones comunes.
Desarrollar programas para manejar sus propias excepciones.
Usar aserciones.
Distinguir usos apropiados e inapropiados de las aserciones.
Habilitar aserciones durante el tiempo de ejecucin.
Este mdulo cubre las utilidades de manejo de errores incorporadas al

lenguaje de programacin Java.
8-1
Aspectos relevantes
Aspectos relevantes
!
?

Cmo se resuelven los errores de tiempo de ejecucin en la mayora

de los lenguajes de programacin?
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
Si hace suposiciones sobre la forma en que funciona su cdigo y

tales suposiciones son errneas, qu puede ocurrir?
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
Siempre es necesario o deseable consumir recursos de la CPU

probando aserciones en programas en produccin?
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
8-2
Languaje de programacin Java

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.
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.
Ejemplo de una excepcin

En el Cdigo 8-1 se muestra un programa que agrega todos los
argumentos de la lnea de comandos.
Cdigo 8-1
1
2
3
4
5
6
7
8
9
Ejemplo de un programa que genera una excepcin
public class AddArguments {

int sum = 0;
for ( int i = 0; i < args.length; i++ ) {
sum += Integer.parseInt(args[i]);
}
System.out.println("Sum = " + sum);
}
}
Este programa funciona bien si todos los argumentos de la lnea de

comandos son enteros. Por ejemplo:
java AddArguments 1 2 3 4
Sum = 10
El programa falla si alguno de los argumentos no es un entero:
java AddArguments 1 dos 3.0 4
Exception in thread "main" java.lang.NumberFormatException:
For input string: "dos"at
java.lang.NumberFormatException.forInputString(NumberFormat
Exception.java:48)
at java.lang.Integer.parseInt(Integer.java:447)
at java.lang.Integer.parseInt(Integer.java:497)
at AddArguments.main(AddArguments.java:5)
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
Ejemplo de un programa que maneja una excepcin
public class AddArguments2 {

try {
int sum = 0;
}
} catch (NumberFormatException nfe) {
System.err.println("Uno de los argumentos de la lnea de "
+ "comandos no es un entero.");
}
}
}
Este programa captura la excepcin y luego se cierra con un mensaje de
error:
java AddArguments2 1 dos 3.0 4
Uno de los argumentos de la lnea de comandos no es un entero.
8-6

Sentencia try-catch
Gestin precisa de las excepciones

La sentencia try-catch puede utilizarse en bloques pequeos de cdigo.
En el Cdigo 8-3 se muestra el uso de esta sentencia en el interior del
bucle for. Esto permite al programa descartar slo aquellos argumentos
de la lnea de comandos que no sean enteros. El cdigo muestra una
degradacin ms suave del comportamiento que la del programa
AddArguments2.
Cdigo 8-3
1
2
3
4
5
6
7
8
9
10
11
12
13
14
Programa AddArguments mejorado
public class AddArguments3 {

int sum = 0;
try {
} catch (NumberFormatException nfe) {
System.err.println("[" + args[i] + "] no es un entero"
+ " y no se incluir en la suma.");
}
}
}
}
Este programa detecta la excepcin de cada argumento no entero de la
lnea de comandos y genera un mensaje de aviso. De todos modos,
el programa procede a sumar todos los enteros vlidos:
java AddArguments3 1 dos 3.0 4
[dos] no es un entero y no se incluir en la suma.
[3.0] no es un entero y no se incluir en la suma.
Sum = 5
8-7
Sentencia try-catch
Uso de mltiples clusulas catch

Puede haber mltiples bloques catch despus de un bloque try, cada
uno los cuales puede manejar una tipo de excepcin diferente. El
Cdigo 8-4 muestra la sintaxis cuando se utilizan varias clusulas catch.
Cdigo 8-4
Ejemplo de uso de varias clusulas 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.
Mecanismo de apilamiento de llamadas

Si una sentencia enva una excepcin que no se gestiona en el mtodo que
la rodea, la excepcin se enva al mtodo que ha efectuado la llamada.
Si tampoco la gestiona el mtodo de llamada, se vuelve a enviar al
mtodo inmediatamente anterior, y as sucesivamente. Si, cuando la
excepcin llega al mtodo main(), ste tampoco la gestiona, la
excepcin interrumpe el programa de forma irregular.
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();
}
En el ejemplo anterior, la llave del agua (faucet) se cierra con

independencia de que se produzca o no una excepcin al abrir la llave
o regar el csped. El cdigo escrito entre llaves despus de try se
denomina cdigo protegido.
Las nicas situaciones que impiden que se ejecute la clusula finally son
los cierres o cadas de la mquina virtual (por ejemplo, si se ejecuta el
mtodo System.exit, o bien se cierra o se apaga la mquina). Esto implica
que el flujo de control puede desviarse de la ejecucin secuencial normal.
Por ejemplo, si se incluye una sentencia return dentro del cdigo del
bloque try, el cdigo de la clusula finally se ejecuta antes de return.
8-9
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

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:
El valor Error indica un problema grave del que es difcil

recuperarse, si no imposible. Un ejemplo es cuando se agota la
memoria del sistema. No se espera que un programa pueda
manejar semejantes situaciones.
El valor RuntimeException indica un problema de diseo o

implementacin. Es decir, refleja situaciones que no deberan
producirse si el programa estuviese funcionando con normalidad.
Por ejemplo, una excepcin NullPointerException nunca
debera generarse si el programador recuerda asociar variables
de referencia a los objetos nuevos o existentes en el espacio de
memoria dinmica. Dado que un programa que est diseado e
implementado correctamente nunca genera este tipo de excepcin,
lo normal es no prever su gestin. Esto provoca el envo de un
mensaje durante el tiempo de ejecucin y garantiza que se
realizar alguna accin para corregir el problema en lugar de
ocultarlo donde el programador crea que nadie lo notara.
Otras excepciones indican la existencia de un problema de tiempo

de ejecucin que suele estar causado por efectos del entorno y
puede gestionarse. Entre los ejemplos se incluyen casos de archivos
no encontrados o de direcciones URL no vlidas (el usuario ha
escrito la direccin de una pgina web incorrecta), que pueden
producirse fcilmente si el usuario se ha equivocado al escribir un
nombre. Dado que suelen generarse por un error de los usuarios,
lo ms aconsejable es gestionarlas.
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
Acceder al sistema de archivos local.
Abrir un socket para un host que es diferente de aquel que ha

dado servicio al applet.
Ejecutar otro programa en un entorno de ejecucin.

La regla de la gestin o la declaracin

Para facilitar la escritura de un cdigo estable, el lenguaje Java exige que,
si se produce una excepcin comprobada (es decir, una subclase de
Exception pero no de RuntimeException) en un determinado punto del
cdigo, el mtodo que contiene ese punto debe definir explcitamente
qu accin debe realizarse si se produce el problema.
Puede hacer lo siguiente para cumplir este requisito:
Gestionar la excepcin utilizando el bloque try-catch-finally.

Hacer que el mtodo donde se ha generado la excepcin la gestione
colocando el origen del problema dentro de un bloque try-catch.
La clusula catch debe designar la clase de excepcin esperada o
una superclase. Esto significa manejar la situacin, aunque la
clusula catch est vaca.
Declarar excepciones que un mtodo puede generar.

Hacer que el mtodo de llamada indique que no gestiona la
excepcin y que sta se volver a enviar a su mtodo de llamada.
Esto significa declarar la excepcin y pasar claramente la
responsabilidad de declaracin o gestin al mtodo de llamada.
El cuerpo de un mtodo puede incluir una clusula throws para
declarar que puede generar una excepcin de la forma siguiente:
void trouble() throws IOException {...}
Tras la palabra clave throws se incluye una lista de excepciones que
el mtodo puede devolver a su mtodo de llamada. Aunque aqu
slo se muestra una excepcin, puede usar una lista de elementos
separados por coma si el mtodo tiene la posibilidad de generar
mltiples excepciones, como en este caso:
void trouble() throws IOException, OtraException {...}
No necesita declarar errores ni excepciones de tiempo de ejecucin. Todas

las subclases de RuntimeException y Error son no comprobadas y no
es necesario incluirlas en la clusula throws de la declaracin del mtodo.
8-13

El programador puede optar por gestionar las excepciones de tiempo
de ejecucin. Normalmente, la mayora de las excepciones de tiempo
de ejecucin indican un defecto en la lgica de programacin. Es mejor
descubrir estos defectos durante las pruebas y corregirlas antes de
poner el cdigo en produccin. Por tanto, no hay necesidad de incluir
clusulas catch para excepciones de tiempo de ejecucin. Existen
algunas excepciones importantes a esta regla. Por ejemplo, es til
capturar una excepcin NumberFormatException al analizar una
cadena introducida por un usuario.
La decisin de manejar o declarar una excepcin depende de si el
programador se considera ms o menos apto para gestionarla que el
mtodo de llamada.
Nota: Dado que, al igual que otras clases, las de excepciones se organizan
en jerarquas y que es posible usar una clase cuando se espera una
subclase, cabe la opcin de capturar grupos de excepciones y gestionarlas
con el mismo cdigo de captura. Por ejemplo, aunque hay varios tipos de
excepciones IOException (EOFException, FileNotFoundException,
etc.), si se captura IOException, es posible capturar tambin las
instancias de sus subclases.
8-14

Sobrescritura de mtodos y excepciones
Sobrescritura de mtodos y excepciones

Cuando se sobrescribe un mtodo que genera excepciones, el mtodo que
sobrescribe puede declarar slo excepciones que sean la misma clase o
una subclase de las excepciones. Por ejemplo, si el mtodo de la
superclase genera una excepcin IOException, el mtodo que realiza
la sobrescritura puede generar una excepcin IOException o
FileNotFoundException (subclase de IOException), pero no una
excepcin Exception (superclase de IOException). Es posible declarar
menos o ms excepciones especficas en la clusula throws.
En el ejemplo siguiente se declaran tres clases: PruebaA, PruebaB1 y
PruebaB2. PruebaA es la superclase de PruebaB1 y PruebaB2.
1
2
3
4
5
public class PruebaA {

public void metodoA() throws IOException {
// realiza algn clculo
}
}
1
2
3
4
5
public class PruebaB1 extends PruebaA {

public void metodoA() throws EOFException {
}
}
1
2
3
4
5
public class PruebaB2 extends PruebaA {

public void metodoA() throws Exception {
}
}
La clase PruebaB1 se compila porque EOFException es una subclase de

IOException. Sin embargo, la clase PruebaB2 no se compila porque
Exception es una superclase de IOException.
Est permitido declarar mtodos de sobrescritura que generen menos
excepciones que el mtodo de la superclase, incluso que no generen
ninguna excepcin. El nuevo conjunto restringido de excepciones
determinar los lmites de las excepciones que podran generar las
posibles subclases que se creen.
8-15
Creacin de excepciones personalizadas

Las excepciones que define el propio usuario se crean ampliando la clase
Exception. Las clases Exception contienen todo lo que pueda contener
una clase normal. He aqu el ejemplo de una excepcin definida por el
usuario que contiene un constructor, algunas variables y mtodos.
1
2
3
4
5
6
7
8
9
10
11
12
public class ServerTimedOutException extends Exception {

private int port;
public ServerTimedOutException(String message, int port) {
super(message);
this.port = port;
}
public int getPort() {
return port;
}
}
Nota: Utilice el mtodo getMessage, heredado de la clase Exception,

para ver la razn por la que se ha creado la excepcin.
Para generar una excepcin personalizada, utilice la sintaxis siguiente:
throw new ServerTimedOutException("Imposible conectar",
80);
Siempre debe instanciar la excepcin en la misma lnea en la que la
genera porque es posible que, en el momento de crearla, se le asocie
informacin sobre el nmero de lnea.
8-16

Generacin de excepciones definidas por el usuario

Imagine que est creando un programa cliente-servidor. En el cdigo
cliente, tratar de establecer conexin con el servidor y esperar recibir
respuesta de ste en el plazo de cinco segundos. Si el servidor no
responde, el cdigo podr generar una excepcin (por ejemplo, una
definida por el usuario como ServerTimedOutException) de la manera
siguiente:
1
2
3
4
5
6
7
8
9
10
11
12
public void connectMe(String serverName)

throws ServerTimedOutException {
boolean successful;
int portToConnect = 80;
successful = open(serverName, portToConnect);
if ( ! successful ) {
throw new ServerTimedOutException("Imposible conectar",
portToConnect);
}
}
8-17
Manejo de excepciones definidas por el usuario

Para capturar una excepcin personalizada, utilice la sentencia try:
1
public void findServer() {
2
try {
3
connectMe(defaultServer);
4
} catch (ServerTimedOutException e) {
5
System.out.println("El servidor no responde, buscando servidor
alternativo");
6
try {
7
connectMe(alternativeServer);
8
} catch (ServerTimedOutException e1) {
9
System.out.println("Error: " + e1.getMessage() +
10
" conectando con el puerto " +
e1.getPort());
11
}
12
}
13
}
Nota: Es posible anidar los bloques try y catch, como se muestra en el

ejemplo anterior.
Tambin se puede procesar una excepcin de forma parcial y luego
generarla, por ejemplo:
try {
connectMe(defaultServer);
} catch (ServerTimedOutException e) {
System.out.println(Error detectado y reenviado);
throw e;
}
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.
Usos recomendados de las aserciones

Las aserciones pueden aportar datos valiosos sobre las suposiciones y
expectativas que maneja el programador. Por este motivo, resultan
especialmente tiles cuando otros programadores trabajan con el
cdigo para operaciones de mantenimiento.
En general, las aserciones deberan utilizarse para verificar la lgica
interna de un solo mtodo o un pequeo grupo de mtodos
fuertemente vinculados entre s. No deberan utilizarse para
comprobar si el cdigo se utiliza correctamente, sino para verificar
que se cumplan sus propias expectativas internas.
Algunos ejemplos de usos adecuados son las invariantes internas, las
invariantes del flujo de control, las postcondiciones y las invariantes
de clase.
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
}
Si parte de la premisa de que x tiene el valor 0, y que nunca puede ser

un valor negativo, y resulta que s adopta un valor negativo, el cdigo
har algo imprevisto. Casi con toda seguridad se comportar de forma
incorrecta. Y lo que es peor, dado que el cdigo no se detiene ni comunica
el problema, no lo detectar hasta mucho despus, cuando el dao
causado sea an mayor. En tales casos, resulta muy difcil determinar
el origen del problema.
Para estas situaciones, la adicin de una asercin al abrir el bloque
else ayuda a garantizar la veracidad de la premisa y permite ver
rpidamente el error cuando sta no se cumple o cuando alguien
cambia el cdigo y la premisa deja de ser cierta. Una vez introducida
la asercin, el cdigo debera ser parecido a ste:
1
2
3
4
5
6
if (x > 0) {
// hacer esto
} else {
assert (x == 0);
// hacer aquello a menos que x sea negativo
}
Invariantes del flujo de control

Las invariantes del flujo de control reflejan suposiciones similares a las de
las invariante internas, pero tienen que ver con la direccin que sigue el
flujo de ejecucin, ms que con el valor o las relaciones de las variables.
Por ejemplo, es posible que piense que ha enumerado cada valor posible
de la variable de control en una sentencia switch y que, por tanto,
nunca se ejecutar una sentencia default. Esto debera verificarse
agregando una sentencia de asercin similar a sta:
1
2
3
4
5
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 }
Postcondiciones e invariantes de clase

Las postcondiciones son suposiciones sobre el valor o las relaciones que
presentan las variables al finalizar un mtodo. Un ejemplo sencillo de
prueba de postcondicin sera verificar que despus de un mtodo de
desapilamiento (pop) de una pila, sta contiene un elemento menos de los
que tena antes de llamar al mtodo, a menos que la pila ya estuviese
vaca. El cdigo para hacerlo se escribira as:
1
public Object pop() {
2
int size = this.getElementCount();
3
if (size == 0) {
4
throw new RuntimeException(Intento de desapilar una pila
vaca);
5
}
6
7
Object result = /* cdigo para recuperar el elemento desapilado */
;
8
9
// probar la postcondicin
10
assert (this.getElementCount() == size - 1);
11
12
return result;
13 }
Observe que, si el mtodo pop no generase una excepcin en caso de
recibir una llamada para actuar sobre una pila vaca, sera ms difcil
expresar esta asercin, porque el tamao original cero seguira siendo cero
en el resultado final. Observe tambin que, en la prueba de precondicin,
es decir, aquella que determina si se ha llamado al mtodo para actuar
sobre una pila vaca, no se utiliza ninguna asercin. Esto es porque, si se
produce tal situacin, no se debe a un error de la lgica local del mtodo,
sino a la forma en que se est utilizando el objeto. En general, estas pruebas
sobre el comportamiento externo no deberan utilizar aserciones, sino
simples excepciones. Esto garantiza que la prueba se realizar siempre y
que no se inhabilitar, como puede ocurrir con las aserciones.
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.
Usos inapropiados de las aserciones

No utilice las aserciones para comprobar los parmetros de un mtodo
public. Es el mtodo el que debera comprobar cada parmetro y generar
la excepcin apropiada, por ejemplo, IllegalArgumentException o
NullPointerException. La razn por la que no debera usar aserciones
para comprobar parmetros es porque es posible desactivarlas a pesar de
que el programador quiera seguir realizando la comprobacin.
En las pruebas de las aserciones, no utilice mtodos que puedan provocar
efectos secundarios, ya que dichas pruebas pueden desactivarse en el
momento de la ejecucin. Si su aplicacin depende de estos efectos
secundarios, se comportar de forma diferente cuando las pruebas de
asercin se desactiven.
Control de la evaluacin de las aserciones durante el

tiempo de ejecucin
Una de las principales ventajas de las aserciones frente a las excepciones
es que las comprobaciones de asercin pueden desactivarse durante el
tiempo de ejecucin. Al hacerlo, se elimina la carga de procesamiento que
conlleva comprobar las aserciones y el cdigo se ejecuta con la misma
rapidez con que lo hara si no contuviese aserciones. Esto es mejor que
usar la compilacin condicional por dos razones. En primer lugar, no
obliga a utilizar una fase de compilacin diferente para entornos de
produccin. En segundo lugar, es posible reactivar las aserciones en un
momento dado para determinar si han dejado de ser vlidas debido a
algn efecto imprevisto del entorno.
Las aserciones estn desactivadas de forma predeterminadas.
Para activarlas, utilice cualquiera de estas formas:
java -enableassertions MiPrograma
java -ea MiPrograma
Es posible controlar las aserciones en paquetes, jerarquas de paquetes o
clases independientes. Para obtener informacin al respecto, consulte la
documentacin de: docs/guide/language/assert.html, que encontrar
en el directorio de instalacin del software JDK.
8-22

Mdulo 9
API Collections y Generics

Objetivos
Este mdulo le proporcionar los conocimientos necesarios para:
Describir las implementaciones genricas de las interfaces

fundamentales de la infraestructura Collections.
Examinar la interfaz Map.
Examinar las clases coleccin tradicionales.
Crear un orden natural o personalizado mediante las interfaces

Comparable y Comparator.
Utilizar colecciones genricas.
Emplear parmetros de tipo en clases genricas.
Refactorizar cdigo no genrico existente.
Escribir un programa para iterar una coleccin.
Examinar el bucle for mejorado.
9-1
Otros recursos
Otros recursos
9-2
Arnold, Gosling, Holmes. The Java Programming Language, Fourth

Edition. Prentice-Hall. 2005.
Zakhour, Hommel, Royal, Rabinovitch, Risser, Hoeber. The Java

Tutorial: A Short Course on the Basics, Fourth Edition. Prentice-Hall.
2006.

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:
Collection: un grupo de objetos que se denominan elementos.

Las implementaciones determinan si hay un orden especfico y si
se permiten los duplicados.
Set: una coleccin sin orden especfico, que no admite duplicados.
List: una coleccin ordenada que admite duplicados.
Antes de la plataforma Java SE 5.0, las colecciones mantenan referencias a

los objetos de tipo Object. Ello permite almacenar cualquier objeto en
la coleccin. Tambin requiere el uso de la conversin apropiada para
poder utilizar el objeto despus de recuperarlo de la coleccin. Sin
embargo, con la plataforma SE 5.0 y superior, es posible utilizar
caractersticas de coleccin genricas para especificar los tipos de
objeto que pueden almacenarse en una coleccin. As no es necesario
convertir el objeto en el momento de la recuperacin. Las colecciones
genricas se explican con ms detalle en Genricos en la pgina 9-16.

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
Interfaz Collection y la jerarqua de clases
HashSet es un ejemplo de una clase que proporciona una implementacin

de la interfaz Set. La interfaz SortedSet es una ampliacin de la interfaz
Set. Las clases que implementan SortedSet imponen una ordenacin
completa de los elementos. TreeSet implementa la interfaz SortedSet.
Las clases ArrayList y LinkedList proporcionan una implementacin
de la interfaz List.
Nota: Esta explicacin del API Collections es una simplificacin del
API completa (que incluye muchos ms mtodos e interfaces y varias
clases abstractas intermedias). Para ms informacin, consulte
Introduction to the Collections Framework en la siguiente pgina web:
http://developer.java.sun.com/developer/onlineTraining
/collections/
9-4

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
Las siguientes subsecciones muestran ejemplos del uso de HashSet y

ArrayList.
Ejemplo con Set

En el siguiente ejemplo, que aparece en el Cdigo 9-1, el programa declara
una variable (set) de tipo Set que se inicializa como objeto HashSet
nuevo. A continuacin, agrega algunos elementos e imprime la variable
set como salida estndar. Las lneas 10 y 11 del Cdigo 9-1 intentan
agregar valores duplicados a set. Como no es posible agregar valores
duplicados a una variable Set, los mtodos add devuelven false.
Cdigo 9-1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
Programa EjemploSet
import java.util.*;
public class EjemploSet {
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
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.
Ejemplo con List

En el siguiente ejemplo, que aparece en el Cdigo 9-2, el programa declara
una variable (list) de tipo List que se asigna a un objeto ArrayList
nuevo. A continuacin, agrega algunos elementos e imprime la lista
como salida estndar. Como las listas admiten los duplicados, los mtodos
add en las lneas 10 y 11 del Cdigo 9-2 devuelven true.
Cdigo 9-2
1
2
3
4
5
6
7
8
9
10
11
12
13
14
Programa EjemploList
import java.util.*;
public class EjemploList {
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);
}
}
Este programa generara la siguiente salida:

[one, second, 3rd, 4, 5.0, second, 4]
Los elementos aparecen en el orden en el que se agregaron.
9-6

Nota: El API Collections contiene numerosas implementaciones tiles

concretas de las interfaces Collection, Set y List. Consulte la
documentacin del API para familiarizarse con dichas implementaciones.
Algunas incluso implementan comportamientos hbridos, como
LinkedHashMap, que utiliza hashing para realizar bsquedas rpidas y
tambin mantiene una lista interna con doble vnculo para poder devolver
objetos generados por un iterador con un orden significativo.

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.
values: devuelve una variable Collection con todos los valores

contenidos en el mapa.
La Figura 9-2 muestra el API de la interfaz Map, sus subinterfaces y

algunas de las clases de implementacin ms conocidas.
Figura 9-2
API de la interfaz Map
La interfaz Map no ampla la interfaz Collection porque representa

asignaciones y no una coleccin de objetos. La interfaz SortedMap
ampla la interfaz Map. Algunas de las clases que implementan la
interfaz Map son HashMap, TreeMap, IdentityHashMap y WeakHashMap.
El orden que presentan los iteradores de estas implementaciones
de coleccin de mapas es especfico de cada iterador.
9-8

Interfaz Map
Ejemplo con Map

En el ejemplo mostrado en el Cdigo 9-3, el programa declara una
variable map de tipo Map y la asigna a un objeto HashMap nuevo. A
continuacin, agrega unos elementos al mapa mediante la operacin put.
Para demostrar que los mapas no admiten claves duplicadas, el programa
intenta agregar un valor nuevo con una clave ya existente. El resultado es
que el valor nuevo sustituye al valor agregado anteriormente para la
clave. A continuacin, el programa utiliza las operaciones de
visualizacin de colecciones keySet, values y entrySet para recuperar
el contenido del mapa.
Cdigo 9-3
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
Programa EjemploMap
import java.util.*;
public class EjemploMap {
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
Clases coleccin tradicionales
Clases coleccin tradicionales

Las clases coleccin de JDK versiones 1.0 y 1.1 an existen en la versin
actual de JDK con la misma interfaz, pero se han actualizado para
poder interactuar con la versin nueva del API Collections.
9-10
La clase Vector implementa la interfaz List.
La clase Stack es una ampliacin de Vector que agrega las

operaciones habituales de apilado: push, pop y peek.
Hashtable es una implementacin de Map.
La clase Properties es una ampliacin de Hashtable que slo

utiliza cadenas (String) para claves y valores.
Cada una de estas colecciones tiene un mtodo elements que

devuelve un objeto Enumeration. La interfaz Enumeration es
similar a la interfaz Iterator, pero no es compatible con ella.
Por ejemplo, hasNext se ha sustituido por hasMoreElements en
la interfaz Enumeration.

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
Ejemplo de implementacin de la interfaz Comparable
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
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 {
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());
}
}
}

La salida generada por el programa ListaEstudiantes es
Nombre
Nombre
Nombre
Nombre
=
=
=
=
Clara Genio ID = 104 Media = 2,3

Juan Lino ID = 102 Media = 2,8
Jaime Marcos ID = 103 Media = 3,6
Miguel Herraiz ID = 101 Media = 4,0
Observe que los estudiantes se comparan segn su nota media. Esto

ocurre porque al ordenar los elementos de la coleccin TreeSet,
TreeSet comprueba si los objetos se encuentran en su orden natural y,
en ese caso, utiliza el mtodo compareTo para compararlos.
Algunas colecciones, como TreeSet, se ordenan. La implementacin de
TreeSet necesita saber cmo ordenar los elementos. Si los elementos
tienen un orden natural, TreeSet emplea el orden natural. En caso
contrario, es necesario ayudarle. Por ejemplo, la clase TreeSet incluye
el siguiente constructor, que admite Comparator como parmetro.
TreeSet(Comparator comparator)
Este constructor crea un conjunto de rbol vaco, ordenado segn el
parmetro Comparator especificado. La siguiente seccin ofrece una
explicacin detallada del uso de la interfaz Comparator.
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
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
String Nombre() { return Nombre; }

String primerApellido() { return primerApellido;
int IDestudiante() { return IDestudiante; }
double Media() { return Media; }
}
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
Ejemplo de implementacin de la interfaz Comparator
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

Cdigo 9-8
1
2
3
4
5
6
7
8
9
10
11
Otro ejemplo de implementacin de la interfaz Comparator.
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 {
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
=
=
=
=
Jaime Marcos ID = 103 Media = 3,6

Juan Lino ID = 102 Media = 2,8
Clara Genio ID = 104 Media = 2,3
Miguel Herraiz ID = 101 Media = 4,0
Si el Cdigo 9-9 se modificase para utilizar un objeto CompNota, los
estudiantes se ordenaran segn su nota media.

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>();
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.
Ejemplo de una variable Set genrica

En el siguiente ejemplo, el programa declara una variable (set) de tipo
Set<String> y la asigna a un objeto HashSet<String> nuevo. A
continuacin, agrega unos elementos de tipo String e imprime el conjunto
como salida estndar. La lnea 8 produce un error de compilacin (porque un
nmero entero no es una cadena). El Cdigo 9-13 muestra la implementacin
de Set con tipos genricos. Esto es comparable a la implementacin no
genrica de Set mostrada en el Cdigo 9-1 de la pgina 9-5.
Cdigo 9-13 Ejemplo de una variable Set genrica
1
2
3
4
5
6
7
8
9
10
11
12
13
14
import java.util.*;
public class EjemploSetGen {
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
Ejemplo de mapa genrico

La clase RepositorioMapasJugadores del Cdigo 9-14 muestra una
manera ms prctica de utilizar las colecciones genricas. El programa
crea un repositorio de jugadores. Declara la variable (jugadores) de
tipo HashMap<String, String>, que almacena los jugadores segn su
posicin y nombre. Define dos mtodos, put() y get(), para agregar
los elementos al repositorio de mapas y para recuperarlos del
repositorio, respectivamente.
Cdigo 9-14 Implementacin de un mapa genrico
1
import java.util.*;
2
3
public class RepositorioMapasJugadores {
4
HashMap<String, String> jugadores;
5
6
public RepositorioMapasJugadores() {
7
jugadores = new HashMap<String, String> ();
8
}
9
10
public String get(String posicion) {
11
String jugador = jugadores.get(posicion);
12
return jugador;
13
}
14
15
public void put(String posicion, String nombre) {
16
jugadores.put(posicion, nombre);
17
}
18
19
20
RepositorioMapasJugadores equipodeensueo = new
RepositorioMapasJugadores();
21
22
equipodeensueo.put("delantero", "henry");
23
equipodeensueo.put("lateral derecho", "ronaldo");
24
equipodeensueo.put("portero", "cech");
25
System.out.println("El delantero es " +
equipodeensueo.get("delantero"));
26
System.out.println("El lateral derecho es " +
equipodeensueo.get("lateral derecho"));
27
System.out.println("El portero es " +
equipodeensueo.get("portero"));
28
}
29 }
9-18

Genricos
Este programa produce la siguiente salida:
El delantero es henry
El lateral derecho es ronaldo
El portero es cech

9-19
Genricos: examen de los parmetros de tipo

Esta seccin examina el uso de los parmetros de tipo en (la clase, el
constructor y las declaraciones de mtodo de) las clases genricas.
La Tabla 9-2 muestra una comparacin entre la versin no genrica
(anterior a la plataforma Java SE 5.0) y la versin genrica (a partir de
la plataforma Java SE 5.0) de la clase ArrayList.
Tabla 9-2 Comparacin de las clases ArrayList no genricas y genricas
Categora
Clase no genrica
Clase genrica
Declaracin
de clase
public class ArrayList

extends AbstractList
implements List
public class ArrayList<E>

extends AbstractList<E>
implements List <E>
Declaracin
public ArrayList
de constructor (int capacity)
public ArrayList
(int capacity)
Declaracin
de mtodo
public void add(E o)
public void add(Object o)
public Object get(int index) public E get(int index)

Ejemplos de
declaraciones
de variables
ArrayList list1;
ArrayList <String> a3;
ArrayList list2;
ArrayList <Date> a4;
Ejemplos de
declaraciones
de instancias
list1 = new ArrayList(10);
a3= new ArrayList<String> (10);
list2 = new ArrayList(10);
a4= new ArrayList<Date> (10);
La principal diferencia es la introduccin del parmetro de tipo E.

En la siguiente declaracin e instanciacin de ArrayList, el tipo
String sustituye a la variable de tipo paramtrica E.
ArrayList <String> a3 = new ArrayList <String> (10);
En la siguiente declaracin e instanciacin de ArrayList, el tipo
Date sustituye a la variable de tipo paramtrica E.
ArrayList <Date> a3 = new ArrayList <Date> (10);
9-20


La Figura 9-3 muestra un diagrama UML de las principales interfaces y
clases de implementacin del API Collections genrica.
Figura 9-3
API Collections genrica
Nota: La variable de tipo E en cada declaracin de interfaz representa el

tipo de los elementos incluidos en la coleccin.
Es habitual utilizar letras maysculas como parmetros de tipo. Las
bibliotecas de Java emplean:
E para colecciones de elementos.
K y V para pares formados por una clave y un valor.
T para todos los dems tipos.

9-21
Parmetros de tipo comodn

Las explicaciones ofrecidas en esta seccin utilizan la jerarqua de herencia
de la clase Cuenta que aparece en la Figura 9-4.
Cuenta
CuentaAhorro
Figura 9-4
CuentaCorriente
Clase Cuenta y sus subclases
En esta seccin se describen los parmetros de tipo comodn.
Garanta de seguridad de tipo

Examine el cdigo que aparece en el Cdigo 9-15.
Cdigo 9-15 Cdigo para ilustrar la garanta de seguridad de tipo
1
import com.mibanco.domain.*;
2
import java.util.*;
3
4
public class ProbarSeguridadTipo {
5
6
7
List<CuentaCorriente> lc = new ArrayList<CuentaCorriente>();
8
9
lc.add(new CuentaCorriente("Fred")); // Bien
10
lc.add(new CuentaAhorro("Fred")); // Error de compilacin!
11
12
// por tanto...
13
CuentaCorriente ca = lc.get(0);
// No hay riesgo, no
necesita conversin
14
}
15 }
9-22


Si no es posible agregar tipos de objeto inapropiados a las colecciones
genricas, se garantiza que los objetos recuperados de la coleccin
pueden asignarse de forma directa y segura a las variables del mismo
tipo que el parmetro de tipo utilizado.
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 java.util.*;
public class ProbarInvarianza {
List<Cuenta> la;
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 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());
}
}
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

Genricos: refactorizacin de cdigo no genrico existente
Genricos: refactorizacin de cdigo no genrico

existente
Con las colecciones genricas, es posible especificar tipos genricos sin
argumentos de tipo, denominados tipos bsicos. Esta caracterstica
garantiza la compatibilidad con el cdigo no genrico.
En el momento de la compilacin, se elimina toda la informacin genrica
del cdigo genrico. Lo que queda es un tipo bsico. Esto permite la
interoperabilidad con el cdigo tradicional, ya que los archivos de
clase generados por el cdigo genrico y por el cdigo tradicional
seran los mismos. Durante la ejecucin, ArrayList<String> y
ArrayList<Integer> se traducen como ArrayList, lo cual es un tipo
bsico.
El uso del nuevo compilador Java SE 5.0 o posterior con cdigo no
genrico ms antiguo generar una advertencia. El Cdigo 9-18 muestra
una clase que genera una advertencia durante la compilacin.
Cdigo 9-18 Clase que emite una advertencia
1
2
3
4
5
6
7
8
import java.util.*;
public class GenericsWarning {
List list = new ArrayList();
int total = (Integer) list.get(0);
}
}
Si compila la clase GenericsWarning con el siguiente comando:

javac GenericsWarning.java
observar la siguiente advertencia:
Note: GenericsWarning.java uses unchecked or unsafe
operations.
Note: Recompile with -Xlint:unchecked for details.
En cambio, si compila la clase con el siguiente comando:
javac -Xlint:unchecked GenericsWarning.java
observar esta advertencia:

9-25
Genricos: refactorizacin de cdigo no genrico existente

GenericsWarning.java:5: warning: [unchecked] unchecked call
to add(int,E) as a member of the raw type java.util.List
^
1 warning
Aunque la clase se compila correctamente y las advertencias pueden
ignorarse, es aconsejable modificar el cdigo para que sea compatible con
los genricos. Para resolver esta advertencia en la clase
GenericsWarning, es necesario cambiar la lnea 4 para que quede as:
List<Integer> list = new ArrayList<Integer>();
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
List list<Estudiante> = new ArrayList<Estudiante>();

// agregue algunos elementos
Iterator<Estudiante> elements = list.iterator();
while (elements.hasNext()) {
System.out.println(elements.next());
}

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
Diagrama UML: interfaces de iterador genricas
El mtodo remove permite al cdigo eliminar el elemento actual de la

iteracin (el elemento devuelto por el mtodo next o previous ms
reciente). Si la coleccin subyacente no admite la eliminacin, se
genera una excepcin de tipo UnsupportedOperationException.
Al utilizar ListIterator, es habitual desplazarse por la lista en una sola
direccin: hacia delante con next o hacia atrs con previous. Si utiliza
previous inmediatamente despus de next, recibir el mismo elemento.
Lo mismo ocurrir si emplea next justo despus de previous.
El mtodo set cambia el elemento de la coleccin al que hace referencia el
cursor del iterador. El mtodo add inserta el elemento nuevo en la
coleccin inmediatamente antes del cursor del iterador. Por tanto, si
emplea previous despus de add, devolver el elemento que acaba
de agregar. Sin embargo, el uso de next no se ver afectado. Si la
coleccin subyacente no admite el uso de set ni de add, se generar
una excepcin de tipo UnsupportedOperationException.
9-28

Bucle for mejorado
Bucle for mejorado

El Cdigo 9-20 muestra el uso de un iterador en combinacin con un
bucle for tradicional para iterar una coleccin.
Cdigo 9-20 Uso de un iterador con un bucle for tradicional
1
2
{
3
4
5
6
public void deleteAll(Collection<NameList> c) {

for (Iterator<NameList> i=c.iterator(); i.hasNext();)
NameList nl = i.next();
nl.deleteItem();
}
}
En el Cdigo 9-20, el mtodo deleteAll utiliza la variable i tres

veces en el bucle for. Esto crea oportunidades para la introduccin
de errores en el cdigo.
Tambin es posible iterar una coleccin mediante un bucle for mejorado.
Con el bucle for mejorado, desplazarse por una coleccin resulta sencillo,
comprensible y seguro. El bucle for mejorado elimina el uso de mtodos
iteradores distintos y minimiza el nmero de veces que aparece la
variable iterator. El Cdigo 9-21 muestra el mtodo deleteAll con
el bucle for mejorado.
Cdigo 9-21 Iteracin mediante el bucle for mejorado en las colecciones
1
2
3
4
5
public void deleteAll(Collection<NameList> c) {

for (NameList nl: c) {
nl.deleteItem();
}
}

9-29
Bucle for mejorado

Gracias a la funcionalidad del bucle for mejorado, el desplazamiento por
los bucles for anidados resulta ms sencillo y fcil de entender en
comparacin con el bucle for tradicional. Ello se debe en parte a que
el uso de los bucles for mejorados reduce la ambigedad de las
variables utilizadas en los bucles anidados. El Cdigo 9-22 contiene
un ejemplo de bucles for mejorados anidados.
Cdigo 9-22 Anidamiento de bucles for mejorados
1
2
3
4
5
6
7
8
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
Principios bsicos de E/S

Objetivos
para:
Escribir un programa que utilice argumentos de la lnea de

comandos y propiedades del sistema.
Examinar la clase Properties.
Construir y utilizar correctamente flujos de nodos y de procesamiento.
Serializar y deserializar objetos.
Distinguir entre lectores (readers) y escritores (writers) en los flujos y

optar correctamente por uno u otro.
10-1
Otros recursos
Otros recursos
10-2


2006.
Bates, Sierra. Head First Java, First Edition. OReilly Media. 2003.

Argumentos de la lnea de comandos
Argumentos de la lnea de comandos

Cuando se inicia un programa Java desde una ventana de terminal, es
posible suministrarle ninguno, uno o varios argumentos de la lnea de
comandos. Estos argumentos permiten al usuario especificar la informacin
de configuracin de la aplicacin. Los argumentos de la lnea de
comandos son cadenas: pueden ser tokens autnomos, como arg1, o
cadenas entrecomilladas, como "another arg".
La secuencia de argumentos sigue al nombre de la clase del programa y se
almacena en un array de objetos String pasados al mtodo esttico main.
El Cdigo 10-1 muestra un ejemplo:
Cdigo 10-1 Prueba de argumentos de la lnea de comandos
1
2
3
4
5
6
7
public class TestArgs {

for (int i = 0; i < args.length; i++) {
System.out.println("args[" + i + "] is: " + args[i]);
}
}
}
Este programa presenta todos los argumentos de la lnea de comandos
pasados al programa TestArgs. Por ejemplo:
java TestArgs arg1 arg2 "another arg"
args[0] is: arg1
args[1] is: arg2
args[2] is: another arg
Nota: Si una aplicacin requiere el uso de argumentos de la lnea de

comandos de un tipo diferente a String, por ejemplo valores numricos,
la aplicacin deber convertir los argumentos de String en sus tipos
respectivos utilizando clases envoltorio (wrapper), como el mtodo
Integer. parseInt, que permite convertir en el tipo int el argumento de
String que representa al nmero entero .

10-3
Propiedades del sistema
Propiedades del sistema

Las propiedades del sistema constituyen otro mecanismo para
parametrizar un programa en tiempo de ejecucin. Una propiedad es
una asignacin entre el nombre de una propiedad y su valor, siendo
ambos cadenas. La clase Properties representa este tipo de asignacin.
El mtodo System.getProperties devuelve el objeto propiedades del
sistema. El mtodo System.getProperty(String) devuelve el valor de
cadena de la propiedad designada en el parmetro String. Hay otro
mtodo, System.getProperty(String, String), que permite
suministrar un valor de cadena predeterminado (el segundo parmetro),
valor que se devuelve si la propiedad designada no existe.
Nota: Cada implementacin JVM debe suministrar un conjunto
predeterminado de parmetros. (Para obtener ms informacin sobre el
mtodo System.getProperties, consulte la documentacin.) Adems,
el proveedor de una determinada implementacin JVM puede
suministrar otros.
En las clases envoltorio tambin hay mtodos estticos encargados de
convertir valores de propiedad: Boolean.getBoolean(String),
Integer.getInteger(String) y Long.getLong(String). El argumento
de cadena es el nombre de la propiedad. Si la propiedad no existe, se
devuelve false o null.
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 {
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
Principios bsicos del flujo de E/S
Principios bsicos del flujo de E/S

Un flujo es una secuencia de datos procedentes de una fuente en direccin
a un sumidero. Normalmente, un programa representa un extremo de ese
flujo, mientras que el otro extremo lo constituye otro nodo (por ejemplo,
un archivo).
Las fuentes y sumideros tambin se denominan flujos de entrada y flujos de
salida, respectivamente. Es posible leer un flujo de entrada, pero no
escribir en l. Por el contrario, es posible escribir en un flujo de salida,
pero no leerlo. La Tabla 10-1 muestra las principales clases de flujos.
Tabla 10-1 Clases fundamentales de flujos
Flujo
Flujos de bytes
Flujos de caracteres
Flujos fuente
InputStream
Reader
Flujos sumidero
OutputStream
Writer
Datos contenidos en los flujos

La tecnologa Java admite dos tipos de datos en los flujos: bytes sin
formato (raw) o caracteres Unicode. Normalmente, el trmino flujo hace
referencia a flujos de bytes y los trminos lector (reader) y escritor (writer)
hacen referencia a flujos de caracteres.
Ms concretamente, los flujos de entrada de caracteres se implementan
con subclases de la clase Reader y los flujos de salida de caracteres se
implementan con subclases de la clase Writer. Los flujos de entrada de
bytes se implementan con subclases de la clase InputStream, mientras
que los flujos de salida de bytes se implementan con subclases de la
clase OutputStream.
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

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
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
Memoria (como arrays u objetos String)
Tuberas (flujos de un proceso o de un hilo [proceso ligero] a otro;

la tubera del flujo de salida de un hilo est conectada a la tubera
del flujo de entrada de otro hilo)
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 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 {

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 {
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();
}
}
}
}
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
Concatenacin de flujos de E/S
Concatenacin de flujos de E/S

Es inusual que un programa utilice un solo objeto flujo, ya que lo normal
es que concatene varios flujos para procesar los datos. La Figura 10-1
muestra un ejemplo de flujo de entrada; en este caso y por motivos
de eficacia, un flujo de archivos se guarda en el bfer y despus se
convierte en elementos de datos (primitivos de Java).
Fuente
de datos
Programa
FileInputStream
BufferedInputStream
DataInputStream
Figura 10-1 Ejemplo de flujos de entrada concatenados

La Figura 10-2 muestra un ejemplo de flujo de salida; en este caso,
los datos se escriben, se guardan en el bfer y finalmente se escriben
en un archivo.
Sumidero
de datos
Programa
FileOutputStream
BufferedOutputStream
DataOutputStream
Figura 10-2 Ejemplo de flujos de salida concatenados
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 bytes
Uso del bfer
BufferedReader
BufferedWriter
BufferedInputStream
Filtrado
FilterReader
FilterWriter
FilterInputStream
FilterOutputStream
Conversin entre bytes y

caracteres
InputStreamReader
OutputStreamWriter
*Serializacin de objetos
ObjectInputStream
ObjectOutputStream
Conversin de datos
DataInputStream
DataOutputStream
Recuento
LineNumberReader
LineNumberInputStream
Exploracin
PushbackReader
PushbackInputStream
Impresin
PrintWriter
PrintStream
Nota: Los flujos FilterXyz son clases abstractas y no pueden utilizarse

directamente, pero s colocarse en subclases para implementar flujos de
procesamiento propios.
Es fcil crear nuevos flujos de procesamiento, como veremos en la
prxima seccin.
Nota: La serializacin de objetos se describe ms adelante en este mdulo.

10-15
Clases bsicas de flujos de bytes

La Figura 10-3 muestra la jerarqua de clases de flujos de bytes de entrada
del paquete java.io. En las siguientes secciones se describen algunas de
las clases de flujos de bytes ms habituales.
FileInputStream
ObjectInputStream
PipedInputStream
DataInputStream
InputStream
SequenceInputStream
PushbackInputStream
FilterInputStream
BufferedInputStream
StringBufferInputStream
LineNumberInputStream
ByteArrayInputStream
Figura 10-3 Jerarqua de clases InputStream

La Figura 10-4 muestra la jerarqua de clases de flujos de bytes de salida
del paquete java.io.
FileOutputStream
ObjectOutputStream
DataOutputStream
OutputStream
FilterOutputStream
PrintStream
PipedOutputStream
ByteArrayOutputStream
Figura 10-4 Jerarqua de clases OutputStream
10-16

Clases FileInputStream y FileOutputStream

Las clases FileInputStream y FileOutputStream son flujos de nodos y,
como su nombre indica, utilizan archivos en disco. Los constructores
de estas clases permiten especificar la ruta del archivo al que estn
conectadas. Para construir un flujo del tipo FileInputStream, el archivo
asociado debe existir y ser legible. Si se construye un flujo del tipo
FileOutputStream, el archivo de salida se sobrescribe si ya existe.
FileInputStream infile
= new FileInputStream("miarchivo.dat");
FileOutputStream outfile
= new FileOutputStream("resultados.dat");
ClasesBufferedInputStreamyBufferedOutputStream
Los flujos filtrados de las clases BufferedInputStream y
BufferedOutputStream sirven para aumentar la eficacia de las
operaciones de E/S.
Clases PipedInputStream y PipedOutputStream

Las tuberas se encargan de garantizar la comunicacin entre dos hilos.
Un objeto PipedInputStream de un hilo recibe sus datos de un objeto
complementario PipedOutputStream de otro hilo. Para ser vlidos, los
flujos que circulan por tuberas deben disponer de un extremo de entrada
y de otro de salida.
Clases DataInputStream y DataOutputStream

Los flujos filtrados DataInputStream y DataOutputStream permiten leer
y escribir tipos primitivos Java y algunos formatos especiales mediante flujos.
Los mtodos siguientes son aplicables a los diferentes datos primitivos.
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.
Clases ObjectInputStream y ObjectOutputStream

Las clases ObjectInputStream y ObjectOutputstream permiten leer
objetos Java y escribirlos en flujos.
Escribir un objeto en un flujo implica principalmente consignar los valores
de todos los campos del objeto. Si los campos son tambin objetos,
estos objetos deben escribirse igualmente en el flujo.
Nota: Si los campos se declaran transitorios (transient) o estticos
(static), sus valores no se escriben en el flujo, como se explica en la
prxima seccin.
La lectura de un objeto de un flujo supone leer el tipo de objeto, crear
un objeto vaco del mismo tipo y rellenarlo con los datos escritos.
El almacenamiento persistente de los objetos se puede garantizar si,
como flujo, se utilizan archivos (u otros espacios de almacenamiento
persistentes).
El API de Java proporciona un mecanismo estndar que automatiza por
completo el proceso de escritura y de lectura de objetos en flujos.
Nota: Si se trata de un flujo de socket de red, los objetos se serializan antes
de enviarse y se deserializan a su recepcin en otro host o proceso.
10-18


La Figura 10-5 presenta un esquema de los posibles flujos de entrada y de
las clases lector que pueden concatenarse.
Figura 10-5 Combinaciones de concatenacin de entrada: revisin

10-19

La Figura 10-6 presenta un esquema de los posibles flujos de salida y de
las clases escritor que pueden concatenarse.
Figura 10-6 Combinaciones de concatenacin de salida: revisin
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.
Serializacin y grficos de objetos

Cuando se serializa un objeto, slo se conservan sus campos; los mtodos
y constructores no forman parte del flujo serializado. Si un campo sirve de
referencia a un objeto, los campos del objeto al que se hace referencia
tambin se serializan si la clase del objeto lo permite. El grfico del objeto
es el rbol o estructura de los campos de ese objeto, subobjetos incluidos.
Algunas clases de objetos no son serializables porque los datos que
representan contienen referencias a recursos transitorios del sistema
operativo, como las clases java.io.FileInputStream y
java.lang.Thread. Si un objeto serializable contiene una referencia a
un elemento que no lo es, se anula toda la operacin de serializacin y
se genera una excepcin del tipo NotSerializableException.
Si el grfico del objeto contiene una referencia a un objeto no serializable,
el objeto puede serializarse de todas formas si la referencia se marca con
la palabra clave transient.

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
public class MyClass implements Serializable {

public transient Thread myThread;
private String customerID;
private int total;
}
El modificador de acceso al campo (public, protected, default o private)

no tiene ningn efecto en el campo de datos que se est serializando. Los
datos se escriben en el flujo en formato de bytes y con cadenas representadas
con caracteres FSF-UTF (file system safe universal character set transformation
format). La palabra clave transient impide la serializacin de los datos.
1
2
3
4
5
public class MyClass implements Serializable {

public transient Thread myThread;
private transient String customerID;
private int total;
}
Nota: Los valores almacenados en campos estticos no se serializan.

Cuando se deserializa el objeto, los valores de los campos estticos adoptan
los valores almacenados en las variables de la clase correspondiente.
Escritura y lectura de un flujo de objetos

Escribir y leer objetos en flujos son procesos sencillos. Esta seccin ofrece
ejemplos de ambos procesos.
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 ();
e.printStackTrace ();
}
}
new SerializeDate();
}
}
La serializacin comienza en la lnea 14 cuando se llama al objeto

writeObject().
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) {
}
System.out.println(
"Deserialized Date object from date.ser");
System.out.println("Date: "+d);
}
new DeSerializeDate();
}
}
La deserializacin del objeto se produce en la lnea 14, cuando se llama al

mtodo readObject().
10-24

Clases bsicas de flujos de caracteres

La Figura 10-7 muestra la jerarqua de clases de flujos de caracteres
Reader del paquete java.io. En las siguientes secciones se describen
algunas de las clases de flujos de caracteres ms habituales.
BufferedReader
LineNumberReader
CharArrayReader
StringReader
Reader
InputStreamReader
FileReader
PipedReader
FilterReader
PushbackReader
Figura 10-7 Jerarqua de clases Reader

La Figura 10-8 muestra la jerarqua de clases de flujos de caracteres
Writer del paquete java.io.
BufferedWriter
CharArrayWriter
StringWriter
Writer
OutputStreamWriter
FileWriter
PrintWriter
PipedWriter
FilterWriter
Figura 10-8 Jerarqua de clases Writer

10-25
Mtodos InputStreamReader y OutputStreamWriter

Las versiones ms importantes de lectores y escritores son
InputStreamReader y OutputStreamWriter. Estas clases sirven de
interfaz entre los flujos de bytes y los lectores y escritores de caracteres.
Cuando se construye un flujo InputStreamReader o
OutputStreamWriter, se definen reglas de conversin que alternan
entre las representaciones Unicode de 16 bits y las propias de las
plataformas de que se trate.
Conversin de bytes y de caracteres

De forma predeterminada, al construir un lector o escritor conectado a un
flujo, las reglas de conversin alternan entre los bytes que utilizan la
codificacin de caracteres predeterminada de la plataforma y el formato
Unicode. En los pases anglfonos se utiliza la codificacin de bytes de
la norma ISO (International Organization for Standardization) 8859-1.
Es posible especificar otra codificacin de bytes utilizando un formato
de codificacin compatible. Si tiene la documentacin instalada, puede
buscar la lista de los formatos de codificacin admitidos en la pgina:
http://java.sun.com/javase/6/docs/technotes/guides/intl/
encoding.doc.html.
Con este esquema de conversin, la tecnologa Java aprovecha toda la
flexibilidad del juego de caracteres de la plataforma local, pero no pierde
su independencia con respecto a sta gracias al uso interno de Unicode.
Utilizacin de otras codificaciones de caracteres

Si necesita leer datos con una codificacin de caracteres que no es la
local (por ejemplo, en una conexin de red con un tipo diferente de
mquina), puede construir un cdigo InputStreamReader con una
codificacin de caracteres explcita, como la siguiente:
InputStreamReader ir
= new InputStreamReader(System.in, "ISO-8859-1");
10-26

Nota: Si va a leer caracteres en una conexin en red, utilice esta frmula.

De no hacerlo, el programa siempre intentar convertir los caracteres que
lee como si utilizaran la representacin local, lo cual seguramente no es
el caso. La norma ISO 8859-1 corresponde al esquema de codificacin
Latin-1 asignado al formato ASCII.
Clases FileReader y FileWriter

Las clases FileReader y FileWriter son flujos de nodos equivalentes en
caracteres Unicode a las clases FileInputStream y FileOutputStream.
Clases BufferedReader y BufferedWriter

Los flujos de caracteres filtrados de las clases BufferedReader y
BufferedWriter sirven para aumentar la eficacia de las operaciones
de E/S.
Clases StringReader y StringWriter

Las clases StringReader y StringWriter son flujos de caracteres de
nodos que leen o escriben en objetos String de la tecnologa Java.
Supongamos que ha escrito una serie de clases de informes con mtodos
que aceptan un parmetro Writer (destino del texto del informe).
Dado que el mtodo realiza llamadas a una interfaz genrica, el
programa puede pasar un objeto FileWriter o un objeto StringWriter;
el cdigo del mtodo no tiene importancia. El primer objeto se emplea
para escribir el informe en un archivo. El segundo podra servir para
escribir el informe en memoria con una cadena (String) que debe
aparecer en el rea de texto de la interfaz grfica. En ambos casos, el
cdigo de escritura del informe es el mismo.
Clases PipedReader y PipedWriter

Las tuberas se encargan de garantizar la comunicacin entre dos hilos.
Un objeto PipedReader de un hilo recibe sus datos de un objeto
complementario PipedWriter de otro hilo. Para ser vlidos, los flujos
que circulan por tuberas deben disponer de un extremo de entrada y
de otro de salida.

10-27
Mdulo 11
E/S de consola y E/S de archivos

Objetivos
para:
Leer datos de la consola.
Escribir datos en la consola.
Describir los archivos y la E/S de archivos.
11-1
Otros recursos
Otros recursos
11-2
Arnold, Gosling, Holmes. The Java Programming Language,

Fourth Edition. Prentice-Hall. 2005.

2006.
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:
La variable System.out es un objeto PrintStream que inicialmente

se refiere a la ventana de terminal que haya abierto la aplicacin
Java.
La variable System.in es un objeto InputStream que, en principio,

se refiere al teclado del usuario.
La variable System.err es un objeto PrintStream que, en principio,

se refiere a la ventana de terminal que haya abierto la aplicacin
Java.
Es posible redirigir estos flujos de datos (streams) utilizando los

mtodos estticos: System.setOut, System.setIn y System.setErr.
Por ejemplo, podra redirigir un error estndar a un archivo.
Escritura en salida estndar

Es posible dirigir los datos a la salida estndar a travs del mtodo
System.out.println(String). PrintStream presenta el argumento
de cadena en la consola y agrega un carcter de salto de lnea al final.
Existen otros mtodos para presentar en la pantalla el resto de los tipos:
primitivos, un bfer de caracteres y un objeto arbitrario. Todos estos
mtodos agregan una carcter de salto de lnea al final de la salida.
void
void
void
void
void
void
void
void
println(boolean)
println(char)
println(double)
println(float)
println(int)
println(long)
println(char[])
println(Object)
Existe tambin un conjunto de mtodos sobrecargados asociado,

denominado print, que no agrega el carcter de salto de lnea.

11-3
E/S de consola
Lectura de la entrada estndar

El ejemplo del Cdigo 11-1 muestra la tcnica que debera usar para leer la
informacin de tipos String generada en la consola a partir de la entrada
estndar:
Cdigo 11-1 Programa KeyboardInput
1
import java.io.*;
2
3
public class KeyboardInput {
4
5
String s;
6
// Crear un Reader en bfer para leer
7
// cada lnea procedente del teclado.
8
InputStreamReader ir
9
= new InputStreamReader(System.in);
10
BufferedReader in = new BufferedReader(ir);
11
System.out.println("Unix: Escriba ctrl-d para
salir." +
12
"\nWindows: Escriba ctrl-z para salir."
13
La lnea 5 declara una variable de tipo String, s, que el programa utiliza
para almacenar cada lnea leda de la entrada estndar. Las lneas 810
rodean System.in de dos objetos que procesan el flujo de bytes procedente
de la entrada estndar para obtener su valor. InputStreamReader (ir) lee
los caracteres y convierte los bytes sin formato en caracteres Unicode.
BufferedReader (in) proporciona el mtodo readLine, que permite al
programa leer la entrada estndar lnea a lnea.
Nota: La secuencia Control-d de la plataforma UNIX indica la condicin fin
de archivo. En el entorno Windows de Microsoft, utilice la secuencia de teclas
Control-z seguida de la tecla Intro para indicar el fin del archivo (EOF).
El cdigo de KeyboardInput contina:
14
15
16
17
18
19
20
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
// Cerrar el Reader del bfer.

in.close();
La lnea 23 cierra el flujo de entrada situado en el extremo exterior

para liberar cualquier recurso del sistema relacionado con la creacin
de estos objetos de flujo.
24
} catch (IOException e) { // Capturar cualquier
excepcin.
25
26
}
27
}
28 }
Por ltimo, el programa maneja cualquier excepcin de E/S que se
produzca.
Nota: La llamada al mtodo close en la lnea 23 en realidad debera
efectuarse en una clusula finally. No se ha hecho as en este ejemplo
para mayor brevedad.

11-5
E/S de consola
Salida en formato simple

La versin 5 del lenguaje Java incorpora una funcin printf similar a la de
C. Suministra una salida del programa en formato estndar. Esto permite a
los programadores realizar migraciones a partir de cdigo antiguo.
printf puede utilizarse con la sintaxis habitual de C y C++.
System.out.printf("%s %5d %f%n",nombre,id,salario);
Esta funcin de formato tambin est disponible en la clase String del
mtodo format. Es posible generar la misma salida de la forma siguiente.
String s = String.format("%s %5d %f%n",nombre,id,salario);
System.out.print(s);
La Tabla 11-1 presenta algunos cdigos de formato comunes.
Tabla 11-1 Cdigos de formato comunes
Cdigo
Descripcin
%s
Formatea el argumento como una cadena, normalmente

llamando al mtodo toString en el objeto.
%d %o %x
Formatea un entero como un valor decimal, octal o

hexadecimal.
%f %g
Formatea un nmero de coma flotante. El cdigo %g utiliza

la notacin cientfica.
%n
Introduce un carcter de salto de lnea en la cadena o el

flujo.
%%
Introduce el carcter % en la cadena o el flujo.
Es posible utilizar %n como carcter de salto de lnea en lugar de \n para

no depender de la plataforma.
Nota: Para obtener ms informacin sobre la funcionalidad de printf y
los cdigos de formato, lea la informacin correspondiente a la clase
java.util.Formatter en la documentacin del API.
11-6

E/S de consola
Entrada en formato simple

La clase Scanner proporciona funciones de entrada formateada.
Forma parte del paquete java.util. Ofrece mtodos para obtener
valores primitivos, cadenas y bloques mientras espera la introduccin
de datos del usuario. El Cdigo 11-2 muestra un ejemplo.
Cdigo 11-2 Ejemplo de clase Scanner
1
2
3
4
5
6
7
8
9
10
11
12
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();
}
}
En la lnea 5 del Cdigo 11-2 se crea una referencia a Scanner pasando

directamente los datos de entrada de la consola. La lnea 6 hace que se
recupere el valor de cadena de la entrada dada utilizando el mtodo next
de Scanner. En la lnea 8 se utiliza el mtodo nextInt para obtener
el valor entero de la entrada suministrada. En la lnea 10 se cierra la
entrada de datos del usuario.
Nota: Es posible usar la clase Scanner para dividir la entrada formateada
en diferentes elementos de tipos primitivos y String. Tambin se
pueden utilizar expresiones regulares para analizar los flujos. Para
obtener ms informacin, consulte la pgina del enlace siguiente:
http://java.sun.com/docs/books/tutorial/essential/io/scanning.html

11-7
Archivos y E/S de archivos

La tecnologa Java incluye un conjunto muy completo de flujos de E/S que
se describen en el captulo anterior. En esta seccin se examinan varias
tcnicas sencillas para realizar operaciones de lectura y escritura con los
archivos poniendo nfasis en los datos de caracteres, lo que incluye:
Creacin de objetos File
Manipulacin de objetos File
Lectura y escritura en flujos de archivos
Creacin de un objeto File nuevo

La clase File proporciona varias utilidades para manejar archivos y
obtener informacin sobre ellos. En Java, un directorio es simplemente
un archivo ms. Es posible crear un objeto File que represente un
directorio y luego utilizarlo para identificar otros archivos, como se
muestra en el tercer punto de esta lista.
File miArchivo;
miArchivo = new File("miarchivo.txt");
miArchivo = new File("MisDocs", "miarchivo.txt");
File miDir = new File("MisDocs");

miArchivo = new File(miDir, "miarchivo.txt");
El constructor elegido suele variar en funcin de los otros objetos

archivo a los que se pueda acceder. Por ejemplo, si slo utiliza un
archivo en su aplicacin, utilice el primer constructor. No obstante, si
utiliza varios archivos de un directorio comn, puede resultar ms
fcil usar el segundo o el tercer constructor.
La clase File define mtodos independientes de la plataforma que sirven
para manipular archivos mantenidos por un sistema de archivos nativo.
No obstante, esto no permite acceder al contenido de los archivos.
Nota: Es posible usar un objeto File en lugar de una cadena como
argumento del constructor de los objetos FileReader y FileWriter. Esto
proporciona independencia con respecto a las convenciones utilizadas por
el sistema de archivos y, en general, es la prctica ms recomendada.
11-8

Pruebas y utilidades ligadas al objeto File

Despus de crear un objeto File, puede usar los mtodos de las
secciones siguiente para obtener informacin sobre el archivo.
Nombres de archivo
Los mtodos siguientes devuelven nombres de archivo:
String getName()
String getPath()
String getAbsolutePath()
String getParent()
boolean renameTo(File nuevoNombre)
Utilidades de directorio
Los mtodos siguientes proporcionan utilidades relacionadas con los
directorios:
boolean mkdir()
String[] list()
Informacin general sobre los archivos y utilidades asociadas

Los mtodos siguientes devuelven informacin general sobre los archivos:
long lastModified()
long length()
boolean delete()
Pruebas relativas a los archivos

Los mtodos siguientes devuelven informacin sobre los atributos de los
archivos:
boolean exists()
boolean canWrite()
boolean canRead()
boolean isFile()

11-9
boolean isDirectory()
boolean isAbsolute()
boolean isHidden()
E/S de flujos de archivo

El kit de desarrollo de Java SE ofrece dos maneras de leer archivos:
La clase FileReader se utiliza para leer caracteres.
La clase BufferedReader permite usar el mtodo readLine.
El kit de desarrollo de Java SE admite dos formas de escritura de archivos:
La clase FileWriter se utiliza para escribir caracteres.
La clase PrintWriter permite usar los mtodos print y println.
Ejemplo de lectura de un archivo

En el Cdigo 11-3 se lee un archivo de texto y se enva cada lnea a la
salida estndar, que muestra el archivo en la pantalla.
Cdigo 11-3 Lectura de un archivo
1
2
3
4
5
6
7
8
9
10
11
12
13
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;
La lnea 5 crea un nuevo objeto File basado en el primer argumento

de la lnea de comandos. Las lneas 10 y 11 crean un lector (Reader) en
el bfer que envuelve un lector de archivos. El cdigo genera una
excepcin FileNotFoundException si el archivo no existe.
11-10


En el Cdigo 11-4 se lee un archivo de texto y se enva cada lnea a la
salida estndar, con lo que el archivo se muestra en la pantalla.
Cdigo 11-4 Salida de un archivo en pantalla
14
try {
15
// Lee cada lnea del archivo
16
s = in.readLine();
17
while (s != null) {
18
System.out.println("Lectura: " + s);
19
s = in.readLine();
20
}
21
} finally {
22
// Cierra el Reader del bfer
23
in.close();
24
}
25
26
} catch (FileNotFoundException e1) {
27
// Si el archivo no existe
28
System.err.println("Archivo no encontrado: " +
file);
29
30
} catch (IOException e2) {
31
// Captura cualquier otra excepcin de ES.
32
e2.printStackTrace();
33
}
34
35
}
36 }
En el Cdigo 11-4, el bucle while de las lneas 1720 es exactamente igual
al del programa KeyboardInput (Cdigo 11-1 de la pgina 11-4). Lee cada
lnea de texto en el lector del bfer y la enva a la salida estndar.
La lnea 23 cierra el lector del bfer, que a su vez cierra el lector de
archivos al que rodea.
El cdigo de manejo de excepciones en las lneas 2628 captura cualquier
excepcin FileNotFoundException que pueda generar el constructor
FileReader. Las lneas 3033 manejan otras posibles excepciones de E/S
generadas por los mtodos readLine y close.

11-11
Ejemplo de envo de la salida a un archivo

En el Cdigo 11-5 se leen las lneas de entrada del teclado y se enva cada
lnea a un archivo.
Cdigo 11-5 Ejemplo de salida a archivo
1
import java.io.*;
2
3
public class WriteFile {
4
5
// Crea el archivo
6
File file = new File(args[0]);
7
8
try {
9
// Crea un Reader en el bfer
10
InputStreamReader isr
11
= new InputStreamReader(System.in);
12
BufferedReader in
13
= new BufferedReader(isr);
14
// Crea un Writer para enviar los datos al
archivo.
15
PrintWriter out
16
= new PrintWriter(new FileWriter(file));
17
String s;
Como en el Cdigo 11-4 de la pgina 11-11, la lnea 6 del Cdigo 11-5
crea un objeto File basado en el primer argumento de la lnea de
comandos. Las lneas 1011 crean un lector de caracteres del flujo binario
(System.in). Las lneas 1213 crean un lector en el bfer para leer la
entrada estndar. En las lneas 1516, un escritor (Writer) de impresin
envuelve al escritor de archivo creado para el archivo definido en la lnea 6.
18
System.out.print("Introduzca el texto del
archivo. ");
19
System.out.println("[Escriba ctrl-d para
terminar.]");
20
21
// Lee cada lnea de entrada
22
while ((s = in.readLine()) != null) {
23
out.println(s);
24
}
25
11-12


En las lneas 1819 se indica al usuario que introduzca las lneas de
texto que deban escribirse en el archivo y que pulse las teclas Control-d
para terminar. En las lneas 2224 se lee el flujo de datos de entrada y
se enva al archivo, lnea a lnea.
Nota: Debe utilizarse la secuencia Control-d (que representa el fin de
archivo) en lugar de Control-c, ya que sta ltima finaliza la mquina
virtual de Java antes de que el programa cierre el flujo de archivo de
la forma adecuada.
26
27
28
29
30
31
32
33
34
35
// Cierra el Reader del bfer

in.close();
out.close();
// Captura cualquier otra excepcin de ES.
}
}
}
En las lneas 27 y 28 se cierran los flujos de entrada y salida. En las lneas

30-33 se manejan otras excepciones de E/S que se hayan podido generar.

11-13
Mdulo 12
Creacin de interfaces graficas con el API

Swing
Objetivos
para:
Describir la tecnologa Swing de JFC.
Definir Swing.
Identificar los paquetes de Swing.
Describir los elementos que componen una interfaz grfica:

contenedores, componentes y administradores de diseo.
Examinar las propiedades de los contenedores de nivel superior,

genricos y especiales.
Examinar componentes.
Examinar los administradores de diseo.
Describir el modelo Swing monohilo.
Crear una interfaz grfica usando componentes Swing.
12-1
Otros recursos
Otros recursos
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:
Tutorial de JFC/Swing en las pginas de tutoriales gratuitos situadas

en la siguiente direccin:
http://java.sun.com/docs/books/tutorial/
El cdigo de la demo SwingSet
La documentacin del API

Empiece por estudiar el paquete javax.swing y contine hasta
llegar a los subpaquetes.
12-2


2006.
Bates, Sierra. Head First Java, Second Edition. OReilly Media. 2005.

Otros recursos
Qu es Java Foundation Classes (JFC)?

JFC, o Java Foundation Classes, es un conjunto de paquetes utilizados
para la creacin de interfaces grficas de usuario (GUI) que forman parte
de la plataforma Java SE y se han convertido en API (interfaces de
programacin de aplicaciones) esenciales para JDK 1.2. Como
consecuencia, algunas de las fronteras entre JFC y el ncleo del JDK se
han difuminado, pero en lo que respecta a los objetivos de este curso,
JFC incluye lo siguiente:
El conjunto de componentes Swing: Swing es un API formado por

una serie de componentes que sustituyen a los de las herramientas
AWT originales ms otros componentes avanzados.
Grficos 2D: el API Java 2D permite realizar actividades avanzadas

de dibujo, manipulaciones complejas de los colores, manejo de
formas y transformaciones (rotacin, corte, deformacin de objetos,
etc.) y tratar el texto como formas que puedan manipularse.
Los grficos 2D no se explican en este curso.
Estilo de interfaz adaptable. Esta funcin permite elegir la

apariencia y el comportamiento que tendrn los componentes Swing.
El mismo programa puede representarse con la interfaz de Windows,
Motif y Metal.
Acceso para discapacitados: cada vez es ms frecuente que las

instituciones gubernamentales exijan para sus departamentos
programas informticos que faciliten el acceso a personas
discapacitadas. Los componentes Swing facilitan la programacin
en este sentido a travs los API de accesibilidad. Proporciona
interfaces para otras tecnologas asociativas tales como los
lectores y amplificadores de pantallas, los sistemas
transformacin de texto en voz, etc.
Desplazamiento de objetos: la transferencia de datos utilizando los

objetos de la interfaz grfica (tanto de un elemento a otro de un
programa como entre distintos programas) es, desde hace aos, una
caracterstica comn de cualquier interfaz moderna. Desde el punto
de vista del usuario, este tipo de transferencias puede realizarse
de dos maneras, usando las opciones cortar y pegar o desplazando
los objetos con la accin de arrastrar y soltar. Las diferentes
versiones del JDK admiten ambas formas de comunicacin.
Adaptacin a entornos internacionales: las clases JFC permiten

usar diferentes juegos de caracteres como son los del japons, el
chino o el coreano. Esto brinda a los desarrolladores la posibilidad de
crear programas que permitan a usuarios de todo el mundo
interaccionar con las aplicaciones en su propio idioma.
Creacin de interfaces graficas con el API Swing

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.
Estilo de interfaz adaptable

Es la posibilidad de configurar el estilo de interfaz (pluggable look-andfeel) para crear aplicaciones que se ejecuten en cualquier plataforma
como si se hubieran desarrollado para esa plataforma. As, un programa
ejecutado en Microsoft Windows aparecer como si se hubiese
desarrollado para ese entorno, mientras que ese mismo programa
ejecutado en UNIX aparecer como si se hubiese desarrollado para UNIX.
Los programadores pueden crear sus propios componentes Swing
personalizados, con cualquier estilo de interfaz que ellos decidan disear.
Esto aumenta la uniformidad de las aplicaciones y los applets
implementados en diferentes plataformas. La interfaz de una aplicacin
completa puede cambiar de un estilo a otro en el momento de la ejecucin.
La adaptacin de estilos de interfaz que proporcionan los componentes
Swing es posible gracias a la arquitectura subyacente. En la siguiente
seccin se describe la arquitectura de Swing y se explica cmo facilita la
adaptabilidad de los estilos de interfaz.
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.
Modelo: almacena los datos utilizados para definir el componente.
Vista: es la representacin visual del componente. Viene determinada

por los datos contenidos en el modelo.
Controlador: maneja el comportamiento de los componentes cuando

un usuario interacciona con ellos. Este comportamiento puede
incluir cualquier actualizacin del modelo o la vista.
M
C
Figura 12-1 Arquitectura MVC
En teora, estos tres tipos de arquitectura (Modelo, Vista, Controlador)

deberan estar representados por diferentes tipos de clases. En la prctica,
esto comporta muchas dificultades debido a las dependencias existentes
entre la vista y el controlador. La funcin del controlador depende
considerablemente de la implementacin de la vista, porque el usuario
interacciona con ella. En otras palabras, es difcil escribir un controlador
genrico que sea independiente de dicha implementacin. Este problema
se resuelve mediante la arquitectura de modelo-delegado.

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
Figura 12-2 Arquitectura de modelo-delegado

El objeto de IU de la Figura 12-2 se conoce como delegado de IU. Con esta
arquitectura es posible delegar algunas responsabilidades del componente
en un objeto de IU independiente. Esto explica por qu los componentes
Swing facilitan el uso de estilos de interfaz adaptables. Los componentes
hacen responsables de su apariencia al objeto de IU independiente. Por
tanto, el objeto de IU del estilo de interfaz instalado es el encargado de
determinar el aspecto y el comportamiento de los componentes.
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
Proporciona una serie de

componentes ligeros tales como
JButton, JFrame y JCheckBox,
entre otros.
javax.swing.border
Proporciona las clases e interfaces

necesarias para dibujar bordes
especiales tales como lneas, bordes
en relieve, en forma de grabado,
etc.
javax.swing.event
Contiene la definicin de los

eventos generados por los
componentes Swing.
javax.swing.undo
Permite a los programadores

introducir las acciones
deshacer/repetir en aplicaciones
tales como los editores de texto.
javax.swing.colorchooser
Contiene clases e interfaces

utilizadas por el componente
JColorChooser.
javax.swing.filechooser
Contiene clases e interfaces

utilizadas por el componente
JFileChooser.
javax.swing.table
Proporciona clases e interfaces para

manejar JTable.
javax.swing.tree

manejar JTree.
javax.swing.plaf
Proporciona una interfaz y

numerosas clases abstractas que
Swing utiliza para ofrecer las
funciones de adaptacin del
estilo de interfaz.

12-7
Paquetes de Swing
Tabla 12-1 Paquetes de Swing (Continuacin)
Nombre del paquete
Finalidad
javax.swing.plaf.basic
Proporciona objetos de interfaz

grfica creados segn el estilo
Basic.
javax.swing.plaf.metal

grfica creados segn el estilo
Java.
javax.swing.plaf.multi

grfica que combinan varios
estilos.
javax.swing.plaf.synth

para estilos modificables en los
que toda la representacin
grfica se delega.
javax.swing.text

manejar componentes de texto
editables y no editables.
javax.swing.text.html
Proporciona la clase
HTMLEditorKit y las clases
asociadas necesarias para crear
editores de texto HTML.
javax.swing.text.html.parser Proporciona el analizador de

HTML predeterminado junto
con las clases asociadas.
12-8

Composicin de una interfaz grfica basada en Java

Las interfaces grficas basadas en el API Swing se componen de los
siguientes elementos:
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

En la Figura 12-3 puede verse el uso de los componentes, los contenedores
y los administradores de diseo en la composicin de un ejemplo de
interfaz basada en Swing.
Componentes
Contenedor
Figura 12-3 Composicin de una interfaz
12-10

Contenedores Swing
Contenedores Swing
Los contenedores Swing pueden clasificarse en tres grandes categoras:
Contenedores de nivel superior
Contenedores genricos
Contenedores especiales

Son los que se sitan en la parte superior de la jerarqua de contenedores
de Swing. Existen tres contenedores de nivel superior: JFrame, JWindow
y JDialog. Existe tambin una clase especial, JApplet, que, aunque no
es estrictamente un contenedor de nivel superior, merece una mencin
porque debera utilizarse como elemento de nivel superior de cualquier
applet que utilice componentes de Swing. En la Figura 12-4 se muestra la
jerarqua de elementos derivados de los contenedores de nivel superior.
Figura 12-4 Jerarqua de los contenedores de nivel superior

Las clases JApplet, JFrame, JDialog y JWindow derivan respectivamente
de las clases Applet, Frame, Dialog y Window. Es importante tenerlo
en cuenta porque el resto de contenedores y componentes de Swing
derivan de clases JComponent.

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
Componentes de visualizacin de informacin no editable
Mens
Componentes de pantalla con formato
Otros controles bsicos

Componentes Swing
Jerarqua de componentes Swing

En la Figura 12-5 se muestran las relaciones de jerarqua de los
componentes Swing.
Figura 12-5 Jerarqua de componentes Swing

Nota: Las clases de control de eventos de los componentes Swing son
ejemplos de clases de soporte.

12-13
Propiedades de los componentes Swing

En esta seccin se describen las propiedades de los componentes Swing.
Propiedades comunes de los componentes

Todos los componentes Swing poseen algunas propiedades en comn
porque todas ellas derivan de la clase JComponent. La Tabla 12-2
contiene un subconjunto de las propiedades comunes que todos los
componentes Swing heredan de JComponent.
Tabla 12-2 Propiedades comunes de los componentes
Propiedad
Mtodos
Borde
Border getBorder()
void setBorder(Border b)
Color de fondo y de
primer plano
void setBackground(Color bg)

void setForeground(Color bg)
Tipo de letra
void setFont(Font f)
Opacidad
void setOpaque(boolean isOpaque)
Tamao mximo
y mnimo
void setMaximumSize(Dimension d)
void setMinimumSize(Dimension d)
Alineacin
void setAlignmentX(float ax)

void setAlignmentY(float ay)
Tamao preferido
void setPreferredSize(Dimension ps)
Nota: Algunas propiedades, como las de tamao preferido, sirven de

informacin al administrador de diseo. Aunque un componente puede
proporcionar datos de utilidad al administrador de diseo, sta puede
hacer caso omiso de tal informacin y utilizar otra para representar el
componente.
12-14

Propiedades especficas de los componentes

En esta seccin se explican las propiedades especficas de los
componentes utilizando JComboBox como ejemplo. JComboBox hereda
todas las propiedades de JComponent y define otras ms concretas. En
la Tabla 12-3 figuran algunas propiedades especficas de JComboBox.
Tabla 12-3 Propiedades especficas de los componentes
Propiedades
Mtodos
Cantidad mxima de
filas
void setMaximumRowCount(int cantidad)
Modelo
void setModel(ComboBoxModel cbm)
ndice seleccionado
int getSelectedIndex()
Elemento seleccionado
Object getSelectedItem()
Cantidad de elementos
int getItemCount()
Mecanismo de
representacin
(renderer)
void setRenderer(ListCellRenderer ar)
Editable
void setEditable(boolean indicador)

12-15
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:
El redimensionamiento de objetos de la interfaz grfica por parte

del usuario.
El uso de distintos tipos y tamaos de letra que hacen diferentes

sistemas operativos o su personalizacin por parte del usuario.
Los requisitos de disposicin del texto que tienen las diferentes

configuraciones internacionales (de izquierda a derecha, de derecha a
izquierda, vertical).
Para manejar estas situaciones, los administradores de diseo organizan

los componentes segn unas normas predeterminadas. Por ejemplo, la
norma de GridLayout es colocar los componentes del contenedor en
una cuadrcula con celdas de tamao similar, empezando desde la
parte superior izquierda, continuando hacia la derecha y luego hacia
la parte inferior hasta que la cuadrcula est llena. En las secciones
siguientes se describen algunos de los administradores de diseo que
puede utilizar. En cada seccin se destacan las directrices utilizadas
por el administrador en cuestin.
Administrador de diseo BorderLayout

BorderLayout organiza los componentes en cinco zonas diferentes:
CENTER, NORTH, SOUTH, EAST y WEST (centro, norte, sur, este y
oeste, respectivamente). Este administrador de diseo limita a uno el
nmero de componentes que pueden agregarse a cada zona.
Es necesario especificar la posicin del componente. Si no se especifica,
se coloca automticamente en el centro. Cualquier espacio sobrante lo
usa el componente de la zona central.
12-16

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).
Figura 12-6 Ejemplo de BorderLayout

El cdigo siguiente contiene un ejemplo de BorderLayout. En l se
agregan cinco botones al componente JFrame.
Cdigo 12-1 Ejemplo de BorderLayout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
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
23
24
25
26
27
28
29
30
31
f.setSize(400,200);
f.setVisible(true);
}
EjemploZonas guiWindow2 = new EjemploZonas();
guiWindow2.launchFrame();
}
}
Administrador de diseo FlowLayout

FlowLayout coloca los componentes en una fila. En su forma
predeterminada, coloca los componentes de izquierda a derecha
(LEFT_TO_RIGHT). Esta orientacin puede cambiarse con la propiedad
ComponentOrientation para que sea RIGHT_TO_LEFT, es decir, de
derecha a izquierda. Es posible especificar el espacio vertical y horizontal
que debe haber entre los componentes. Si no se especifica, se utiliza
una distancia predeterminada de cinco unidades en ambas direcciones.
La Figura 12-7 contiene un ejemplo de colocacin en fila. Al igual que
en el ejemplo de diseo en zonas, se han agregado cinco componentes
JButton al marco (JFrame).
Figura 12-7 Ejemplo de FlowLayout

El cdigo siguiente contiene un ejemplo de uso de FlowLayout. En l
se agregan cinco botones al componente JFrame.
Cdigo 12-2 Ejemplo de FlowLayout
1
2
3
4
5
6
7
8
9
10
11
12-18
import java.awt.*;
public class EjemploFila {
private JFrame f;
private JButton b1;
private JButton b2;
private JButton b3;
private JButton b4;
private JButton b5;

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");
}
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);
}
EjemploFila guiWindow = new EjemploFila();
guiWindow.launchFrame();
}
} // fin de la clase EjemploFila
Administrador de diseo BoxLayout

BoxLayout organiza los componentes en disposicin vertical u horizontal.
El constructor de BoxLayout utiliza un parmetro llamado axis (eje)
que debe utilizarse para indicar la direccin en la que se alinearn los
componentes. Este parmetro puede adoptar los siguientes valores:
X_AXIS: los componentes se organizan horizontalmente, de

izquierda a derecha.
Y_AXIS: los componentes se organizan verticalmente, de arriba

abajo.
LINE_AXIS: los componentes se colocan en la misma direccin que

las palabras de una lnea.
PAGE_AXIS: los componentes se colocan en la misma direccin que

las lneas de una pgina.

12-19
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.
Figura 12-8 Ejemplo de BoxLayout
Administrador de diseo CardLayout

CardLayout organiza los componentes como una baraja de cartas. Cada
carta acepta un nico componente para su representacin en pantalla.
Este nico componente se convierte en un contenedor, con lo que es
posible representar mltiples componentes dentro de una carta. Slo
puede verse una carta cada vez. En la Figura 12-9 se ilustra el uso de
este administrador de diseo.
Figura 12-9 Ejemplo de CardLayout

En el ejemplo de la Figura 12-9, los botones Button1, Button2 y Button3 se
colocan en Carta1 y los botones Button4 y Button5 se colocan en Carta2.
Se ha utilizado un cuadro combinado para elegir la carta de debe aparecer
en la pantalla.
12-20

Administrador de diseo GridLayout

GridLayout coloca los componentes en filas y columnas. Cada
componente ocupa la misma cantidad de espacio en el contenedor.
Al crear el diseo de la cuadrcula, es preciso especificar el nmero
de filas y columnas. Si no se especifica, el administrador crea una fila
y una columna. Tambin se puede indicar la distancia horizontal y vertical
entre los componentes. En la Figura 12-10 se muestra el uso
de GridLayout. Al igual que la disposicin en zonas ilustrada en la
Figura 12-6 de la pgina 12-17, se han agregado cinco componentes
JButtons al componente JFrame.
Figura 12-10 Ejemplo de GridLayout

El cdigo contiene un ejemplo de uso de GridLayout. En l se agregan
cinco botones al componente JFrame.
Cdigo 12-3 Ejemplo de GridLayout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import java.awt.*;
public class EjemploCuadricula {
private JFrame f;
private JButton b1, b2, b3, b4, b5;
public EjemploCuadricula() {
f = new JFrame("Ejemplo Cuadricula");
}
f.setLayout (new GridLayout(3,2));

12-21
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);
}
EjemploCuadricula grid = new EjemploCuadricula();
grid.launchFrame();
}
}
Administrador de diseo GridBagLayout

GridBagLayout organiza los componentes en filas y columnas, de forma
similar a la del diseador de cuadrculas, pero, para mayor flexibilidad,
incluye opciones para cambiar el tamao y especificar la posicin de
los componentes. Es un diseo utilizado para crear interfaces complejas.
Las restricciones aplicadas a los componentes se especifican mediante
la clase GridBagConstraints. Algunas restricciones de esta clase son
gridwidth, gridheight, gridx, gridy, weightx y weighty. En la
Figura 12-11 se incluye un ejemplo de uso de GridBagLayout. En l
se han agregado cinco componentes JButton al componente JFrame.
Como puede verse, los componentes son de distinto tamao y estn
situados en lugares concretos.
Figura 12-11 Ejemplo de GridBagLayout
12-22

Administrador de diseo GroupLayout

A los administradores de diseo ya citados se ha agregado GroupLayout
en la versin 6 de Java. Se ha aadido para mayor comodidad de los
desarrolladores de herramientas. Es el diseador utilizado en la
herramienta de generacin de interfaces grficas del IDE NetBeans.
Para obtener ms informacin, consulte:
http://java.sun.com/docs/books/tutorial/uiswing/layout/group.html.

12-23
Creacin de interfaces grficas de usuario

Las interfaces grficas basadas en Java pueden crearse utilizando una de
las siguientes tcnicas:
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 con una herramienta de generacin de interfaces grficas

Esta tcnica se basa en el uso de una herramienta de generacin
de interfaces. Los desarrolladores de interfaces grficas utilizan
un enfoque visual para desplazar y colocar los contenedores y
componentes en el rea de trabajo. Esta herramienta permite ubicar
y redimensionar todos estos elementos utilizando un dispositivo
sealador como puede ser el ratn del PC. Con cada paso, la
herramienta genera automticamente las clases Java necesarias
para reproducir la interfaz.
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
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);}


14
15
javax.swing.SwingUtilities.invokeLater(new Runnable() {
16
//Planifica la intervencin del hilo de gestin de
eventos (event-dispatching thread):
17
//creacin y representacin de la interfaz grfica de
esta aplicacin.
18
public void run() {createAndShowGUI();}
19
});
20
}
21 }
En la Figura 12-12 puede verse la interfaz grfica que genera este cdigo.
El diseo predeterminado utilizado para JFrame es BorderLayout.
Por tanto, el componente JLabel se coloca en el centro del contenedor.
Observe que la etiqueta ocupa todo el marco, ya que, segn el diseo
BorderLayout, el componente central ocupa todo el espacio que sobre
en el contenedor.
JFrame
JLabel
FrameTitle
BorderLayout
Figura 12-12 Resultado de HelloWorldString
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.
Mtodos para definir el marco y agregar la etiqueta.

a.
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.
DO_NOTHING_ON_CLOSE: no realiza ninguna accin cuando

se inicia la operacin de cierre. Esta constante se define
en WindowsConstants.
2.
HIDE_ON_CLOSE: llama a cualquier posible objeto

WindowListener y oculta el marco. Esta constante se
define en WindowConstants.
3.
DISPOSE_ON_CLOSE: llama a cualquier posible objeto

WindowListener, oculta el marco y lo cierra. Esta constante
se define en WindowConstants.
4.
EXIT_ON_CLOSE: cierra la aplicacin. Esta constante se

define en la clase JFrame.
b.
setVisible(true): cuando se crea JFrame por primera vez,

se crea un marco invisible. Para hacer que sea visible, el
parmetro de setVisible tiene que ser true. JFrame hereda
este mtodo de java.awt.Component.
c.
add(Component c): este mtodo agrega los componentes

al contenedor. JFrame hereda este mtodo de la clase
java.awt.Component. En la clase java.awt.Component se
definen cinco mtodos sobrescritos diferentes.
Mtodos para asegurar la eficiencia de la interfaz en cuanto a la

ejecucin de hilos.
Conseguir que la interfaz grfica se represente en la pantalla de
una forma eficiente implica varias tareas. stas pueden definirse
de la forma siguiente:
a.
Ejecucin del cdigo de la aplicacin.

Esto implica iniciar la aplicacin de la interfaz grfica y ejecutar
el cdigo para representarla en pantalla.
b.
Control de los eventos generados desde la interfaz.

Los componentes de una interfaz grfica pueden generar
diferentes eventos. Por ejemplo, cada vez que se selecciona un
botn, se genera un evento. Para controlarlo es preciso definir
receptores de eventos (listeners). Esta tarea enva el evento a
los receptores de eventos adecuados para su manejo.
c.
Manejo de procesos de larga duracin:

Determinadas actividades requieren mucho tiempo y pueden
ejecutarse como procesos de fondo para que la interfaz sea
eficiente y gil de respuesta. Este tipo de actividades se
gestionan a travs de esta tarea.
12-26


Para manejar estas tareas de una forma eficaz, el API Swing utiliza
hilos (threads) que son procesos ligeros. Estos hilos se encargan de
llevar a cabo todas estas tareas por separado y de forma simultnea
y es importante que el programador los utilice. El entorno Swing
proporciona un conjunto de mtodos de utilidades en la clase
SwingUtilities.
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
Control de los eventos generados por la

interfaz grfica
Objetivos
para:
Definir el concepto de eventos y su manejo.
Examinar el modelo de eventos de Java SE.
Describir el comportamiento de la interfaz grfica.
Determinar la accin del usuario que ha originado un evento.
Desarrollar receptores de eventos.
Describir la concurrencia en interfaces grficas basadas en el API

Swing y las caractersticas de la clase SwingWorker.
13-1
Otros recursos
Otros recursos
13-2


2006.
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
El usuario hace clic en el botn
JButton
ActionEvent
Un controlador de eventos
actionPerformed(ActionEvent e) {
...
}
Figura 13-1 La accin del usuario genera un evento
Fuentes de los eventos

La fuente de un evento es aquella que genera el evento. Por ejemplo,
pulsar un botn del ratn sobre un componente JButton genera una
instancia de ActionEvent que tiene ese botn como fuente. La instancia
de ActionEvent es un objeto que contiene informacin sobre el evento
que acaba de producirse. ActionEvent contiene:
getActionCommand, que devuelve el nombre del comando asociado

a la accin.
getModifiers, que devuelve cualquier modificador implicado en la

accin.
getWhen, que devuelve el cdigo de tiempo del momento en el que

se ha producido el evento.
paramString, que devuelve una cadena donde se identifica la accin

y el comando asociado.
Control de los eventos generados por la interfaz grfica

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 eventos de Java SE

En esta seccin se describe el modelo de delegacin de eventos
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
El usuario hace clic en un botn
Un controlador de eventos
JButton
ActionEvent
...
}
Otro controlador de eventos

...
}
Figura 13-2 Modelo de delegacin de eventos con varios receptores

Los eventos son objetos que slo se notifican a los receptores registrados.
Cada evento tiene su correspondiente receptor, que indica qu mtodos
deben estar definidos en una clase adecuada para recibir ese tipo de
evento. La clase que implementa la interfaz define esos mtodos y
puede estar registrada como receptor de eventos.
Los eventos procedentes de componentes que no tienen ningn receptor
registrado no se propagan.

13-5
Ejemplo de receptor de eventos

Por ejemplo, el Cdigo 13-1 muestra la forma de crear un marco (JFrame)
sencillo que slo contiene un botn (JButton).
Cdigo 13-1 Ejemplo TestBoton
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
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");
}
b.addActionListener(new ButtonHandler());
f.add(b,BorderLayout.CENTER);
f.pack();
f.setVisible(true);
}
TestBoton guiApp = new TestBoton();
guiApp.launchFrame();
}
}
La clase ButtonHandler mostrada en el Cdigo 13-2 es la clase del

controlador en el que se delega el evento.
Cdigo 13-2 Ejemplo de ButtonHandler
1
2
3
4
5
6
7
8
9
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());
}
}


El Cdigo 13-2 de la pgina 13-6 tiene las siguientes caractersticas:
La clase JButton hereda el mtodo

addActionListener(ActionListener) de
javax.swing.AbstractButton, que es la superclase de JButton.
La interfaz ActionListener define un nico mtodo,

actionPerformed, que recibe un evento de accin (ActionEvent).
Una vez creado, un objeto JButton puede contener un objeto

registrado como receptor de los eventos de la clase ActionEvent a
travs del mtodo addActionListener(). La instancia del
receptor de eventos se genera a partir de una clase que implementa
la interfaz ActionListener.
Cuando se hace clic en el objeto JButton, se enva un evento

ActionEvent. Este evento se recibe a travs del mtodo
actionPerformed() de cualquier interfaz ActionListener que
est registrada en el botn a travs de su mtodo
addActionListener().
El mtodo getActionCommand() de la clase ActionEvent devuelve

el nombre del comando asociado a la accin. En la lnea 11, el comando
de accin de este botn se ha definido como ButtonPressed.
Nota: Hay otras formas de determinar por qu se ha recibido un evento.

En concreto, el mtodo getSource(), documentado en la clase bsica
java.util.EventObject, suele ser til porque permite obtener la
referencia al objeto que ha enviado el evento.
Los eventos no se controlan de forma accidental. Los objetos programados
para recibir determinados eventos en un determinado componente de la
GUI se registran a s mismos con ese componente.
Cuando se produce un evento, slo los objetos que se han registrado

reciben un mensaje comunicndoles que se ha producido dicho
evento.
El modelo de delegacin es conveniente para distribuir el trabajo

entre objetos.
Los eventos no tienen por qu estar relacionados con los componentes de

Swing. Este modelo permite utilizar la arquitectura JavaBeans.

13-7
Comportamiento de la interfaz grfica

En esta seccin se describen las categoras de eventos.
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
Figura 13-3 Jerarqua de clases de eventos de la interfaz grfica

Por cada categora de eventos, la clase de los objetos que quiera recibir los
eventos debe implementar una interfaz. A su vez, esa interfaz exige la
definicin de uno o varios mtodos. La llamada a estos mtodos se realiza
cuando se producen determinados eventos. En la Tabla 13-1 figuran estas
categoras e interfaces.
Tabla 13-1 Categoras de eventos, mtodos e interfaces
Categora
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


Tabla 13-1 Categoras de eventos, mtodos e interfaces (Continuacin)
Categora
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 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);
}
JLabel label = new JLabel("Hacer clic y arrastrar el ratn");
// Agregar componentes al marco


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
46
47
48
49
50
51
52
53
54
55
56
57
58
59
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) { }
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
Implementacin de varias interfaces

La clase se declara en las lneas 5 y 6 mediante la sentencia siguiente:
implements MouseMotionListener, MouseListener
Es posible declarar varias interfaces separndolas mediante comas.
Recepcin de eventos de varias fuentes

Si realiza la llamada a los mtodos siguientes en las lneas 20 y 21:
f.addMouseListener(this);
f.addMouseMotionListener(this);
Ambos tipos de eventos hacen que la llamada se efecte en la clase
TwoListener. Un objeto puede recibir eventos de tantas fuentes como
sea necesario. La clase del objeto slo tiene que implementar las
interfaces necesarias.
Obtencin de informacin sobre el evento

Los argumentos de los eventos con los que se hace la llamada a mtodos
de control tales como mouseDragged() contienen informacin
potencialmente importante sobre el evento original. Para averiguar qu
informacin hay disponible para cada categora de evento, examine la
documentacin de la clase apropiada en el paquete java.awt.event.
Mltiples receptores de eventos

El sistema de recepcin de eventos de AWT permite asociar varios
receptores de eventos al mismo componente. En general, si decide
escribir un programa que realiza mltiples acciones basadas en un mismo
evento, debe incluir el cdigo correspondiente a ese comportamiento en
su mtodo de control. No obstante, algunas veces el diseo de un
programa hace que varias partes no relacionadas entre s del mismo
programa tengan que reaccionar ante el mismo evento. Esto puede
ocurrir si, por ejemplo, se agrega un sistema de ayuda contextual a un
programa existente.
13-12


El mecanismo de recepcin de eventos permite hacer una llamada a
un mtodo addXxxListener() tantas veces como sea necesario y
especificar tantos receptores de eventos como requiera el diseo. Todos los
receptores registrados llaman a los mtodos de control correspondientes
cuando se produce el evento.
Nota: El orden con el que se hace la llamada a estos mtodos no est
definido. En general, si el orden de llamada es importante, significa que
los mtodos estn relacionados. En este caso, registre nicamente el
primer receptor de eventos y haga que ste llame directamente a los otros.

13-13
Desarrollo de receptores de eventos

En esta seccin, examinaremos las distintas opciones disponibles
para disear e implementar receptores de eventos.
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)
Para mayor comodidad, el lenguaje Java proporciona clases adaptadoras

que implementan aquellas interfaces que contienen ms de un mtodo.
Los mtodos de este tipo de clases estn vacos.
Es posible ampliar una clase adaptadora y sobrescribir nicamente
aquellos mtodos que necesite, como se muestra en el Cdigo 13-4.
Cdigo 13-4 Ejemplo de la clase MouseClickHandler
1
2
3
4
5
6
7
8
9
10
11
12
13
14
13-14
import java.awt.*;
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...
}
}

Control de eventos mediante clases internas

En las lneas 26 y 1218 del Cdigo 13-5 se muestra la forma de
crear controladores de eventos como clases internas. El uso de clases
internas para manejar eventos permite acceder a los datos privados de
la clase externa (lnea 16).
Cdigo 13-5 Ejemplo de la clase TestInner
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
import java.awt.*;
public class TestInner {
private JFrame f;
public TestInner() {
f = new JFrame("Ejemplo de clases internas");
}
class MyMouseMotionListener extends MouseMotionAdapter {
String s = "Arrastre del ratn: X = "+ e.getX()
+ " Y = " + e.getY();
tf.setText(s);
}
}
// Agrega componentes al marco
// 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.setVisible(true);
}
TestInner obj = new TestInner();
obj.launchFrame();
}
}
13-15
Control de eventos mediante clases annimas

Es posible incluir una definicin de clase completa dentro del mbito
de una expresin. Esta frmula permite definir lo que se denomina una
clase interna annima y crear la instancia al mismo tiempo. Las clases
internas se utilizan con frecuencia en el manejo de eventos, como se
muestra en el ejemplo del Cdigo 13-6.
Cdigo 13-6 Ejemplo de la clase TestAnonymous
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
13-16
import java.awt.*;
public class TestAnonymous {
private JFrame f;
public TestAnonymous() {
f = new JFrame("Ejemplo de clases annimas");
}
// Agrega componentes al marco
// Agrega un Listener que utiliza una clase annima
f.addMouseMotionListener(new MouseMotionAdapter() {
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.setVisible(true);
}
TestAnonymous obj = new TestAnonymous();
obj.launchFrame();
}
}

Nota: La compilacin de una clase annima genera un archivo del tipo

TestAnonymous$1.class.

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.
Los hilos responsables de ejecutar el cdigo de la aplicacin son los

denominados hilos actuales.
Los hilos responsables de manejar los eventos generados por los

distintos componentes se denominan hilos de control de eventos.
Los hilos responsables de ejecutar tareas de larga duracin se

denominan hilos de segundo plano (workers). Entre algunas de
estas tareas se incluyen la espera de algn recurso compartido, la
espera de datos del usuario, el bloqueo de E/S del disco o la red
u operaciones de alta carga computacional de la CPU o la memoria.
Estas tareas pueden realizarse como procesos de fondo sin que
ello afecte al rendimiento de la interfaz.
Puede utilizar instancias de la clase SwingWorker para representar

estos hilos de segundo plano. La clase SwingWorker ampla la clase
Object e implementa la interfaz RunnableFuture.
SwingWorker proporciona los siguientes mtodos de utilidad:
Para posibilitar la interaccin y coordinacin entre las tareas de los

hilos de segundo plano y las de otros hilos, la clase SwingWorker
incluye propiedades como progress y state, que facilitan la
comunicacin entre los hilos.
Para ejecutar tareas sencillas en segundo plano puede utilizarse el

mtodo doInBackground.
Para ejecutar tareas que producen resultados intermedios, dichos

resultados pueden publicarse en una interfaz grfica mediante los
mtodos publish y process.
Los procesos de segundo plano pueden cancelarse mediante el

mtodo cancel.
Nota: La descripcin completa del uso de la clase SwingWorker queda

fuera de los objetivos de este mdulo. Para obtener ms informacin
al respecto, consulte las pginas de la siguiente direccin:
http://java.sun.com/docs/books/tutorial/uiswing/concurrency
/index.html.
13-18

Mdulo 14
Aplicaciones basadas en la interfaz grfica

Objetivos
para:
Explicar cmo construir una barra de mens, un men y opciones de

men en una interfaz grfica Java.
Saber cambiar el color y el tipo de letra de un componente.
14-1
Aspectos relevantes
Aspectos relevantes
!
?

Ahora ya sabe cmo configurar una interfaz grfica Java para

obtener resultados grficos y permitir la interaccin del usuario.
Sin embargo, slo se han descrito algunos de los componentes
que se utilizan para construir interfaces grficas. Qu otros
componentes seran tiles en una interfaz grfica?
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
Cmo se crea un men para el marco de la interfaz grfica?

_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
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.
Cree un objeto JMenuBar y defnalo dentro de un contenedor de

mens, como JFrame.
2.
Cree uno o varios objetos JMenu y agrguelos al objeto barra de mens.
3.
Cree uno o varios objetos JMenuItem y agrguelos al objeto men.
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.
Nota: Con AWT es posible designar un men como men de ayuda.

Para ello se utiliza el mtodo setHelpMenu. Este mtodo no se
implementa en Swing y los mens de ayuda se agregan igual que
las dems opciones de men.

14-3
Creacin de un men
Creacin de una barra de mens con JMenuBar

Un componente JMenuBar es una barra de mens, es decir, un men
horizontal. Slo se puede agregar a un objeto JFrame y constituye la
raz de todos los rboles de mens. El objeto JFrame muestra un solo
componente JMenuBar a la vez. Sin embargo, el componente JMenuBar
puede modificarse en funcin del estado del programa para que
aparezcan mens diferentes segn la situacin.
Cdigo 14-1 JMenuBar
10
11
12
f = new JFrame("JMenuBar");
mb = new JMenuBar();
f.setJMenuBar(mb);
La salida siguiente es la que genera el cdigo en Microsoft Windows.
Figura 14-1 Componente JMenuBar
Nota: El aspecto de la ventana vara ligeramente de un sistema operativo

a otro.
El componente JMenuBar no admite receptores de eventos. El
procesamiento de todos los eventos que puedan surgir en una barra
de mens corre a cargo de los mens agregados a la barra.
14-4

Creacin de un men
Creacin de un men con JMenu

El componente JMenu crea un men desplegable bsico que puede
aadirse a un componente JMenuBar o a otro objeto JMenu.
Cdigo 14-2 JMenuBar con opciones de nivel superior JMenu
13
14
15
16
17
18
19
20
21
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);
El cdigo genera la salida siguiente:
Figura 14-2 Componente JMenu

A un objeto JMenu se le puede aadir un elemento ActionListener,
pero no es habitual. Normalmente los mens se utilizan para mostrar
y controlar las opciones de men descritas a continuacin.

14-5
Creacin de un men
Creacin de una opcin de men con JMenuItem

Los componentes JMenuItem son los nodos de texto de las hojas de un
rbol de mens. Se aaden a un men para completarlo, como muestra
el ejemplo siguiente.
Cdigo 14-3 JMenuItem agregados a un men
28
29
30
31
32
33
34
35
36
37
38
39
40
mi1 = new JMenuItem("New");

mi2 = new JMenuItem("Save");
mi3 = new JMenuItem("Load");
mi4 = new JMenuItem("Quit");
mi1.addActionListener(this);
m1.add(mi1);
m1.add(mi2);
m1.add(mi3);
m1.addSeparator();
m1.add(mi4);
Este cdigo genera la salida siguiente:
Figura 14-3 Componente JMenuItem

En general, para definir el comportamiento de un men se agrega un
elemento ActionListener al objeto JMenuItem.
14-6

Creacin de un men
Creacin de un componente JCheckboxMenuItem

El componente JCheckboxMenuItem es una opcin de men que se puede
activar o desactivar, como muestra el ejemplo siguiente.
Demostracin:JCheckboxMenuItem
19 f = new JFrame("CheckboxMenuItem");
20 mb = new JMenuBar();
21 m1 = new JMenu("File");
22 m2 = new JMenu("Edit");
23 m3 = new JMenu("Help");
24 mb.add(m1);
25 mb.add(m2);
26 mb.add(m3);
27 f.setJMenuBar(mb);
...........
43 mi5 = new JCheckBoxMenuItem("Persistent");
44 mi5.addItemListener(this);
45 m1.add(mi5);
El cdigo genera la salida siguiente:
Figura 14-4 Componente JCheckboxMenuItem

El componente JCheckboxMenuItem debe controlarse con la interfaz
ItemListener.

14-7
Control de los aspectos visuales
Control de los aspectos visuales

Es posible controlar los colores que se utilizan para el primer plano y el
fondo de los componentes AWT.
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
para:
Definir el concepto de hilo (thread).
Crear diferentes hilos en un programa Java controlando el cdigo y

los datos usados por cada hilo.
Controlar la ejecucin de un hilo y escribir cdigo independiente de

la plataforma con hilos.
Describir las dificultades que pueden surgir cuando varios hilos

comparten los mismos datos.
Usar wait y notify para establecer la comunicacin entre hilos.
Usar synchronized para proteger la integridad de los datos.
Este mdulo cubre el procesamiento multihilo, que permite a un

programa ejecutar mltiples tareas al mismo tiempo.
15-1
Aspectos relevantes
Aspectos relevantes
!
?
Discusin: Las pregunta siguiente es importante en relacin con el

Cmo se consigue que los programas ejecuten mltiples tareas de
forma simultnea?
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
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:
Una CPU virtual.
El cdigo que ejecuta la CPU.
Los datos con los que trabaja el cdigo.
Un proceso es un programa en ejecucin. Uno o varios hilos constituyen un

proceso. Un hilo se compone de la CPU, el cdigo y los datos, como se
ilustra en la Figura 15-1.
CPU
Hilo o
contexto de ejecucin
Cdigo Datos
Figura 15-1 Partes de un hilo
Hilos
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.
Creacin del hilo

En esta seccin se explica la forma de crear un hilo y usar los argumentos
del constructor para suministrar el cdigo y los datos que utiliza el hilo
durante su ejecucin.
El constructor de Thread utiliza como argumento una instancia de
Runnable. Esta instancia se crea a partir de una clase que implementa
la interfaz Runnable (es decir, proporciona un mtodo public void
run()).
Por ejemplo:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
15-4
public class ThreadTester {

HelloRunner r = new HelloRunner();
Thread t = new Thread(r);
t.start();
}
}
class HelloRunner implements Runnable {
int i;
public void run() {
i = 0;
while (true) {
System.out.println(Hola + i++);
if ( i == 50 ) {
break;

Hilos
19
20
21
22
}
}
}
}
En primer lugar, el mtodo main construye una instancia r de la clase

HelloRunner. La instancia r tiene sus propios datos, en este caso, el
entero i. Dado que la instancia, r, se ha pasado al constructor de la
clase Thread, el entero i de r es el dato con el que el hilo debe trabajar
durante su ejecucin. El hilo siempre empieza a ejecutarse en el mtodo
run de la instancia de Runnable que se haya cargado (en este caso r).
Los entornos de programacin multihilo permiten crear mltiples
hilos basados en la misma instancia de Runnable. Puede hacerlo de la
siguiente manera:
Thread t1 = new Thread(r);
Thread t2 = new Thread(r);
En este caso, ambos hilos comparten los datos y el cdigo.
En resumen, la referencia a un hilo se efecta a travs de una instancia de
un objeto Thread. El hilo empieza a ejecutarse al principio del mtodo
run de la instancia de Runnable que se encuentre cargada. Los datos con
los que trabaja el hilo se obtienen de la instancia concreta de Runnable,
que se pasa al constructor de ese Thread (Figura 15-2).
Nuevo hilo
Thread t
CPU
Clase
HelloRunner
Cdigo Datos
Instancia r
de HelloRunner
Figura 15-2 Creacin de hilos
Hilos
15-5
Hilos
Inicio del hilo

Los hilos recin creados no empiezan a ejecutarse de forma automtica.
Es necesario llamar a su mtodo start. Por ejemplo, puede ejecutar
el comando siguiente, como en la lnea 5 del ejemplo anterior:
t.start();
La llamada a start pone la CPU virtual encapsulada en el hilo en estado
ejecutable, lo que significa que es posible planificar su ejecucin por parte
de la mquina virtual de Java (JVM). Esto no significa necesariamente que
el hilo se ejecute de inmediato.
Planificacin de la ejecucin de los hilos

En programacin Java, la ejecucin de los hilos es apropiativa y no por
asignacin de cuantos de tiempo (time-sliced), con la que cada hilo
recibira una misma cantidad de tiempo de la CPU. Es un error habitual
creer que apropiativo es otra forma de decir asignacin de tiempos.
El modelo de planificacin apropiativa se basa en que, aunque puede
haber muchos hilos ejecutables, en la prctica slo se ejecuta uno. Este hilo
se ejecuta hasta que deja de ser ejecutable o hasta que otro hilo de mayor
prioridad se pone en estado ejecutable. En el ltimo caso, el hilo de mayor
prioridad se apropia del derecho de ejecucin e interrumpe al de menor
prioridad.
Un hilo puede dejar de ser ejecutable (es decir, quedar bloqueado) for
diferentes motivos. Por ejemplo, el cdigo del hilo puede ejecutar una
llamada a Thread.sleep() para pedir al hilo que se detenga durante un
determinado periodo de tiempo. Tambin puede que el hilo tenga que
esperar un recurso y no pueda continuar hasta que dicho recurso est
disponible.
Todos los hilos ejecutables se guardan en grupos formados en funcin de
la prioridad. Cuando un hilo bloqueado se vuelve ejecutable, vuelve a
colocarse en el grupo adecuado. Los hilos del grupo (no puede estar
vaco) que tenga mayor prioridad reciben tiempo de la CPU.
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
Figura 15-3 Diagrama de estados fundamentales de los hilos

Aunque el hilo entre en estado ejecutable (runnable), no siempre empieza
a ejecutarse de inmediato. En las mquinas con una CPU, slo puede
realizarse una accin en cada momento. En los prrafos siguientes se
explica cmo se asignan los recursos de la CPU cuando hay varios
hilos ejecutables.
Dado que los hilos de Java no se ejecutan por asignacin de cuantos
de tiempo, debe asegurarse de que el cdigo de sus hilos d a los otros
hilos la oportunidad de ejecutarse de vez en cuando. Esto puede
conseguirse ejecutando la llamada sleep con diferentes intervalos,
como se muestra en el Cdigo 15-1.
Cdigo 15-1 Ejemplo de planificacin de hilos
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class Runner implements Runnable {

public void run() {
while (true) {
// hacer numerosas tareas
// ...
// Dar a otros hilos una oportunidad
try {
Thread.sleep(10);
} catch (InterruptedException e) {
// El periodo de espera de este hilo ha
// sido interrumpido por otro hilo
}
}
}
}
Hilos
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.
Fin de los hilos

Cuando un hilo termina de ejecutarse y finaliza, no puede volverse a
ejecutar.
Es posible detener los hilos utilizando un indicador que determina que el
mtodo run debe finalizar.
1
public class Runner implements Runnable {
2
private boolean timeToQuit=false;
3
4
public void run() {
5
while ( ! timeToQuit ) {
6
// seguir trabajando hasta recibir la orden de
salir
7
}
8
// dejar todo en orden antes de que termine run()
9
}
10
11
public void stopRunning() {
12
timeToQuit=true;
13
}
14 }
1
2
3
4
5
6
7
8
15-8
public class ThreadController {

private Runner r = new Runner();
private Thread t = new Thread(r);
public void startThread() {
t.start();
}

Hilos
9
10
11
12
13
public void stopThread() {

// usar una instancia especfica de Runner
r.stopRunning();
}
}
Dentro de un determinado fragmento de cdigo, es posible obtener una

referencia al hilo actual utilizando el mtodo esttico currentThread de
Thread. Por ejemplo:
1
2
3
4
5
6
7
8
9
10
11
public class NameRunner implements Runnable {

public void run() {
while (true) {
// numerosas tareas
}
// Mostar en pantalla el nombre del hilo actual
System.out.println("El hilo");
+ Thread.currentThread().getName()
+ " ha terminado");
}
}
Hilos
15-9
Control bsico de los hilos

En esta seccin se explica cmo controlar los hilos.
Comprobacin del estado de los hilos

Un hilo puede entrar en un estado desconocido. Puede utilizar el mtodo
isAlive para determinar si es un proceso an viable. El trmino Alive
(vivo) no implica que se est ejecutando. El mtodo devuelve true
cuando un hilo se ha iniciado pero no ha finalizado su tarea.
Acceso a la prioridad de los hilos

El mtodo getPriority se utiliza para determinar la prioridad que tiene
un hilo en un momento dado. El mtodo setPriority sirve para
establecer la prioridad del hilo. La prioridad se define mediante un
valor entero. La clase Thread incluye las constantes siguientes:
Thread.MIN_PRIORITY
Thread.NORM_PRIORITY
Thread.MAX_PRIORITY
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
El hilo que se reactiva tiene mayor prioridad.
El hilo en ejecucin se bloquea por alguna otra razn.

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

Thread t = new Thread(new Runner());
t.start();
...
// Realizar tareas en paralelo con el otro hilo durante un tiempo
...
// Esperar aqu hasta que termine el hilo en ejecucin
try {
t.join();
// t ha vuelto antes de tiempo
}
...
// Ahora continuar en este hilo
...
}
Tambin se puede llamar al mtodo join utilizando un valor de tiempo
de espera expresado en milisegundos. Por ejemplo:
void join(long timeout);
En este ejemplo, el mtodo join interrumpe el hilo actual durante los
milisegundos indicados en timeout o bien hasta que finaliza el hilo en el
que se ha efectuado la llamada.
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
15-11
Otras formas de crear hilos

Hasta ahora, hemos visto la forma de crear contextos de hilos con una
clase independiente que implementa la interfaz Runnable. Pero hay otros
mtodos posibles. La clase Thread implementa la interfaz Runnable en s.
Por tanto, es posible crear un hilo generando una subclase que se
derive de Thread en lugar de implementar Runnable.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
15-12
public class MyThread extends Thread {

public void run() {
while ( true ) {
// hace numerosas tareas
try {
Thread.sleep(100);
// periodo de inactividad interrumpido
}
}
}
Thread t = new MyThread();
t.start();
}
}

Seleccin de la forma de crear hilos

Una vez sabido que hay varias formas de crear hilos, cmo decidir
cul es la ms conveniente? Cada enfoque tienes sus ventajas, que se
describen en esta seccin.
A continuacin se describen las ventajas de implementar la interfaz
Runnable:
Desde el punto de vista del diseo orientado a objetos, la clase

Thread es estrictamente una CPU virtual encapsulada y, como tal,
slo debera generar subclases (ampliarse) cuando se modifique o
ample el comportamiento de ese modelo de CPU. Por este motivo,
y por la importancia que tiene diferenciar entre la CPU, el cdigo y
las partes de datos de un hilo en ejecucin, hemos utilizado este
enfoque en el presente mdulo.
Dado que la tecnologa Java slo admite el modelo de herencia

sencilla, no es posible ampliar otras clases, como Applet, si ya se ha
ampliado Thread. En algunas situaciones, esto obliga a adoptar la
prctica de implementar Runnable.
Puesto que hay momentos en los que se ver obligado a

implementar Runnable, puede que prefiera mantener la coherencia y
hacerlo siempre de esa forma.
La ventaja de ampliar Thread es que el cdigo tiende a ser ms sencillo.

Nota: Aunque es posible utilizar ambas tcnicas, es importante sopesar
las razones por las que optara por ampliar Thread. Recomendamos
hacerlo nicamente cuando se cambie o ample el comportamiento de un
hilo, no cuando se implemente un mtodo run.
Hilos
15-13
Uso de la palabra clave synchronized

En esta seccin se describe el uso de la palabra clave synchronized.
Esta palabra proporciona al programador de Java un mecanismo para
controlar hilos que comparten datos.
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
public class MiPila {

int idx = 0;
char [] data = new char[6];
public void push(char c) {
data[idx] = c;
idx++;
}
public char pop() {
idx--;
return data[idx];
}
}
La clase no hace ningn esfuerzo por manejar el desbordamiento ni

la falta de elementos en la pila y la capacidad de la pila est limitada.
No obstante, estos aspectos no son relevantes en lo que respecta a esta
explicacin.
El comportamiento de este modelo exige que el valor de ndice contenga
el subndice de array de la siguiente celda vaca de la pila. El uso del
mecanismo predecremento, posincremento genera esta informacin.
Imaginemos ahora que dos hilos contienen una referencia a una sola
instancia de esta clase. Uno de los hilos introduce datos en la pila y
el otro, de forma ms o menos independiente, retira datos de la pila.
En principio, los datos se agregan y suprimen correctamente. No obstante,
existe un problema potencial.
15-14


Supongamos que el hilo a est agregando caracteres y el hilo b los est
suprimiendo. El hilo a acaba de depositar un carcter, pero an no ha
incrementado el contador del ndice. Por alguna razn, este hilo es
sustituido por otro que se apropia del derecho de ejecucin. En este
momento, el modelo de datos representado por el objeto deja de ser
coherente.
buffer |p|q|r| | | |
idx = 2
^
Para mantener la coherencia, es necesario que idx = 3 o que el carcter no
se haya agregado an.
Si el hilo a reanuda la ejecucin, puede que no se produzcan errores,
pero imaginemos que el hilo b estaba esperando a suprimir un carcter.
Mientras el hilo a est esperando a tener otra oportunidad de ejecutarse,
el hilo b obtiene la ocasin de suprimir un carcter.
Se produce una situacin de falta de coherencia de los datos de entrada
del mtodo pop y, sin embargo, dicho mtodo procede a reducir el valor
del ndice.
idx = 1
^
En la prctica, esto hace que no se tenga en cuenta el carcter r. A
continuacin, devuelve el carcter q. Hasta ahora, el comportamiento ha
sido como si la letra r no se hubiese agregado, por lo que es difcil
detectar que hay un problema. Pero observe lo que ocurre cuando el hilo
original, a, reanuda la ejecucin.
El hilo a reinicia la ejecucin en el punto donde la dej, en el mtodo push,
y procede a incrementar el valor del ndice. Ahora tenemos lo siguiente:
idx = 2
^
Esta configuracin implica que el carcter q es vlido y que la celda que
contiene la r es la siguiente celda vaca. En otras palabras, q se lee como si
se hubiese colocado dos veces en la pila y la letra r no aparece nunca.
Esto es un ejemplo de un problema general que surge cuando hay varios
hilos que comparten los datos a los que acceden. Es preciso disponer de un
mecanismo que garantice que esos datos compartidos mantengan la
integridad antes de que cualquiera de los hilos empiece a utilizarlos para
una determinada tarea.
Hilos
15-15

Una forma de hacerlo sera impedir que el hilo a interrumpa su ejecucin
hasta que finalice la seccin crtica del cdigo. Este planteamiento es
habitual en programacin en cdigo mquina de bajo nivel, pero suele
ser inadecuado en sistemas multiusuario.
Otro enfoque, que es el utilizado por la tecnologa Java, es proporcionar
un mecanismo para tratar los datos con delicadeza. Este enfoque
proporciona un hilo atomizado capaz de acceder a los datos con
independencia de que se interrumpa mientras est realizando el acceso.
Indicador de bloqueo de objetos

En la tecnologa Java, cada objeto tiene un indicador asociado. Se puede
pensar en este indicador como en un indicador de bloqueo. La palabra clave
synchronized facilita la interaccin con este indicador y proporciona
acceso exclusivo al cdigo que afecta a los datos compartidos. A
continuacin se muestra el mismo fragmento de cdigo modificado:
public class MiPila {
...
synchronized(this) {
data[idx] = c;
idx++;
}
}
...
}
Cuando el hilo llega a la sentencia synchronized, examina el objeto
pasado como argumento y trata de obtener el indicador de bloqueo de
ese objeto antes de continuar (vase la Figura 15-4).
Objeto this
Cdigo o
comportamiento
Datos o
estado
Hilo antes de la sentencia synchronized(this)

synchronized (this) {
data[idx] = c;
idx++;
}
}
Figura 15-4 Uso de la sentencia synchronized antes de un hilo
15-16


En la Figura 15-5 puede verse un ejemplo de uso de la sentencia
synchronized despus de un hilo.
Objeto this
Cdigo o
comportamiento
Datos o
estado
Hilo despus de la sentencia synchronized(this)

data[idx] = c;
idx++;
}
}
Figura 15-5 Uso de la sentencia synchronized despus de un hilo

Es importante tener en cuenta que esta accin no protege los datos. Si el
mtodo pop del objeto de datos compartidos no est protegido por
synchronized y otro hilo hace una llamada a pop, sigue existiendo el riesgo
de perder la coherencia de los datos. Todos los mtodos que acceden a los
datos deben sincronizarse con respecto al mismo indicador de bloqueo
para que ste sea efectivo.
En la Figura 15-6 se observa lo que ocurre si pop est protegido por la
sentencia synchronized y otro hilo intenta ejecutar el mtodo pop de
un objeto mientras el hilo original retiene el indicador de bloqueo del
objeto sincronizado.
Objeto this
Indicador de bloqueo ausente
Cdigo o
comportamiento
Datos o
estado
Otro hilo que intenta

ejecutar synchronized(this)
public char pop() {

En espera del
bloqueo del objeto
idx--;
return data[idx];
}
}
Figura 15-6 Hilo tratando de ejecutar synchronized

Cuando el hilo trata de ejecutar la sentencia synchronized(this), trata
de conseguir el indicador de bloqueo que tiene el objeto this. Como no
lo consigue, no puede continuar la ejecucin. Seguidamente, el hilo se
une a un grupo de hilos en espera que estn asociados al indicador de
bloqueo de ese objeto. Cuando el indicador se devuelve al objeto, se
entrega el bloqueo a uno de los hilos que estn esperndolo y ese hilo
contina su ejecucin.
Hilos
15-17
Liberacin del indicador de bloqueo

Si un hilo est esperando el indicador de bloqueo de un objeto, no puede
reanudar su ejecucin hasta que el indicador est disponible. Por tanto,
es importante que el hilo que retiene el bloqueo devuelva el indicador
cuando deja de necesitarlo.
En ese momento, el objeto recobra el indicador de forma automtica.
Cuando el hilo que retiene el bloqueo pasa el final del bloque de cdigo
de la sentencia synchronized por la que se obtuvo el bloqueo, ste se
libera. El lenguaje Java garantiza que el bloqueo siempre se devuelva
de forma automtica, incluso aunque una excepcin, una sentencia de
interrupcin o una sentencia de retorno transfieran la ejecucin del
cdigo a otra parte situada fuera de un bloque sincronizado. Asimismo,
si un hilo ejecuta bloques anidados de cdigo que estn sincronizados
con respecto al mismo objeto, el indicador de ese objeto se libera
correctamente al salir del bloque externo de la secuencia y se hace caso
omiso del primer bloque interno.
Estas reglas simplifican el manejo de bloques sincronizados bastante
ms que las utilidades equivalentes en algunos otros sistemas.
15-18

Uso de synchronized: conclusiones

El mecanismo de sincronizacin slo funciona si todo el acceso a los
datos sensibles se produce dentro de los bloques sincronizados.
Los datos protegidos por los bloques sincronizados deberan marcarse
como private. Si no se hace as, ser posible acceder a los datos sensibles
desde cdigo situado fuera de la definicin de la clase. Semejante
situacin permitira a otros programadores sortear la proteccin y
daar los datos durante el tiempo de ejecucin.
Un mtodo compuesto enteramente de cdigo perteneciente a un
bloque sincronizado con respecto a la instancia this podra incluir la
palabra clave synchronized en su cabecera. Los dos fragmentos de
cdigo siguientes son equivalentes:
synchronized(this) {
// Cdigo del mtodo push
}
}
public synchronized void push(char c) {
// Cdigo del mtodo push
}
Por que usar una tcnica en lugar de la otra?
Si se utiliza synchronized como modificador de un mtodo, todo el
mtodo se convierte en un bloque sincronizado. Esto podra hacer que
el indicador de bloqueo quedase retenido ms tiempo del necesario.
No obstante, marcar el mtodo de esta manera permite a los usuarios del
mtodo saber, a partir de la documentacin generada por la utilidad
javadoc, que se est produciendo la sincronizacin. Esto puede ser
importante al disear cdigo para evitar el interbloqueo (que se describe
en la siguiente seccin). La utilidad javadoc propaga el modificador
synchronized por los archivos de documentacin que genera, pero no
puede hacer los mismo con la sentencia synchronized(this), que se
encuentra en el interior del bloque del mtodo.
Hilos
15-19
Estados de los hilos

La sincronizacin es un estado especial de los hilos. En la Figura 15-7
puede verse el diagrama de transicin de estados de un hilo.
Bloqueado
Nuevo
Muerto
Desbloqueado
start()
Ejecutable
Evento bloqueado
Planificador
Bloqueo adquirido
En
ejecucin
run() Finaliza
Sincronizado
Bloqueado en el
grupo de bloqueo
del objeto
Figura 15-7 Diagrama de estado de un hilo con sincronizacin
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

Interaccin de los hilos: wait y notify
Interaccin de los hilos: wait y notify

Los distintos hilos se crean para realizar determinadas tareas que no
guardan relacin entre s. Sin embargo, los trabajos que realizan se
relacionan de alguna manera y podra ser necesario programar
algunas interacciones entre ellos.
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
15-21
Interaccin entre los hilos

En esta seccin se explica cmo interaccionan los hilos.
Mtodos wait y notify

La clase java.lang.Object proporciona dos mtodos para posibilitar la
comunicacin entre hilos: wait y notify. Si un hilo hace una llamada a
wait referida a un objeto de comunicacin (Rendezvous) x, ese hilo
detiene su ejecucin hasta que otro hilo genera una llamada a notify
para ese mismo objeto x.
En el ejemplo anterior, el taxista que espera en el vehculo se representa
mediante el hilo taxista que ejecuta una llamada taxi.wait y su
necesidad de utilizar los servicios del taxi se convierte en el hilo usted que
ejecuta una llamada taxi.notify().
Para que un hilo efecte una llamada a wait o notify con referencia a un
objeto, el hilo debe poseer el bloqueo de ese objeto concreto. En otras
palabras, las llamadas a wait y notify slo pueden realizarse desde el
interior de un bloque sincronizado y en la instancia donde se efecta
la llamada. En el ejemplo que nos ocupa, necesitar un bloque que
empiece con la sentencia synchronized(taxi) para posibilitar las
llamadas taxi.wait o taxi.notify().
Descripcin de los grupos

Cuando un hilo ejecuta cdigo sincronizado que contiene una llamada
wait referida a un determinado objeto, ese hilo se coloca en el grupo
de espera de ese objeto. Asimismo, el hilo que llama a wait libera el
indicador de bloqueo de ese objeto de forma automtica. Es posible
llamar a diferentes mtodos wait.
wait()
wait(long timeout)
Cuando se ejecuta una llamada a notify referida a un determinado
objeto, un hilo arbitrario se traslada desde el grupo de espera del objeto
a un grupo de bloqueo, donde los hilos permanecen hasta que se libera
el bloqueo de ese objeto. El mtodo notifyAll traslada todos los hilos
del grupo de espera de ese objeto al grupo de bloqueo. Un hilo slo
puede obtener el indicador de bloqueo del objeto desde el grupo de
bloqueo, lo que le permite continuar ejecutndose en el punto donde
se encontraba al llamar a wait.
15-22


En muchos sistemas que implementan el mecanismo wait-notify,
el hilo que se reactiva es el que haya esperado durante ms tiempo.
La tecnologa Java no garantiza que esto sea as.
Es posible hacer una llamada a notify aunque no haya ningn hilo
esperando. Si se llama al mtodo notify con referencia a un objeto
cuando no hay ningn hilo en el grupo de espera aguardando el
indicador de bloqueo de ese objeto, la llamada no tiene ningn efecto.
Las llamadas a notify no se almacenan.
Estados de los hilos

El grupo de espera tambin es un estado especial de los hilos. En la
Figura 15-8 puede verse el diagrama de transicin de los estados de un
hilo hasta el final.
Bloqueado
Nuevo
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
Figura 15-8 Diagrama de estados de un hilo con wait y notify
Hilos
15-23
Modelo de control de la sincronizacin

La coordinacin entre dos hilos que necesitan acceso a datos comunes
puede ser compleja. Es necesario garantizar que ningn hilo deje datos
compartidos en un estado incongruente cuando existe la posibilidad de
que otro hilo acceda a esos datos. Tambin es importante asegurar que el
programa no producir situaciones de interbloqueo porque un hilo no
pueda liberar un bloqueo que otro hilo est esperando.
En el ejemplo del taxi, el cdigo se basaba en la existencia de un objeto de
comunicacin, el taxi, sobre el que se ejecutaban los mtodos wait y
notify. Si alguien estuviese esperando un autobs, se necesitara un
objeto autobs independiente al que aplicar la llamada a notify.
Recuerde que todos los hilos del mismo grupo de espera deben recibir la
oportuna notificacin del objeto que controla ese grupo. No disee nunca
cdigo donde los hilos deban recibir notificacin sobre situaciones
diferentes en el mismo grupo de espera.
15-24

Ejemplo de interaccin de hilos

El cdigo de esta seccin contiene un ejemplo de interaccin de hilos que
muestra el uso de los mtodos wait y notify para resolver un problema
clsico de productor-consumidor.
Empezaremos por echar un vistazo al esquema del objeto stack (pila) y
los datos sobre los hilos que acceden a l. A continuacin examinaremos
los datos relativos a la pila y el mecanismo utilizado para protegerlos
e implementar la comunicacin entre los hilos en funcin del estado de
la pila.
La clase pila del ejemplo, denominada SyncStack para distinguirla de
la clase central java.util.Stack, ofrece la siguiente API pblica:
public synchronized void push(char c);
public synchronized char pop();
Hilos
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;
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));
// 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
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
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
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
}
// 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

char c;
while (buffer.size() == 0) {
try {
this.wait();
// hacer caso omiso...
}
}
c = buffer.remove(buffer.size()-1);
return c;
}


La llamada a wait se efecta con respecto al objeto pila que muestra cmo
se establece la comunicacin con un objeto concreto. No se puede extraer
nada de la pila cuando est vaca, por lo que cualquier hilo que quiera
hacerlo deber esperar a que contenga datos.
La llamada a wait se coloca en un bloque try-catch porque una llamada
a interrupt puede poner fin al tiempo de espera del hilo. Asimismo, el
mtodo wait debe estar dentro de un bucle para este ejemplo. Si, por
algn motivo (como una interrupcin) el hilo se reactiva y descubre que la
pila sigue estando vaca, deber volver a entrar en estado de espera.
El mtodo pop de la pila est sincronizado por dos motivos. En primer
lugar, extraer un carcter de la pila afecta al buffer de datos compartidos.
En segundo lugar, la llamada a this.wait() debe estar incluida dentro
de un bloque que est sincronizado con respecto al objeto pila, que est
representado por la palabra this.
El mtodo push utiliza this.notify() para liberar un hilo del grupo de
espera del objeto pila. Una vez liberado el hilo, ste puede obtener el
bloqueo sobre la pila y continuar ejecutando el mtodo pop, que extrae
un carcter del bfer de la pila.
Nota: En el bloque de pop, la llamada al mtodo wait se realiza antes de
que se extraigan caracteres de la pila. Esto es porque la extraccin no
puede realizarse a menos que haya algn carcter disponible.
Tambin conviene considerar la comprobacin de errores. Puede que haya
observado que no se ha incluido ningn cdigo de forma explcita para
impedir errores por falta de contenido en la pila. No es necesario porque
la nica forma de extraer los caracteres de la pila es mediante el mtodo
pop y este mtodo hace que el hilo que se est ejecutando entre en estado
de espera (wait) si no hay ningn carcter disponible. Por tanto, es
innecesaria la comprobacin de errores.
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
15-29

El Cdigo 15-4 muestra cmo se utiliza el mtodo push.
Cdigo 15-5 Mtodo push
1
2
3
4
5

this.notify();
buffer.add(c);
}
La llamada a this.notify() sirve para liberar un nico hilo que ha

llamado a wait porque la pila estaba vaca. Realizar la llamada a notify
antes de que cambien los datos compartidos no tiene ninguna consecuencia.
El bloqueo del objeto stack se libera nicamente al salir del bloque
sincronizado, por lo que los hilos que estn esperando ese bloqueo pueden
obtenerlo mientras el mtodo pop est cambiando los datos de la pila.
Para tener una visin de conjunto, el Cdigo 15-6 nos muestra la clase
SyncStack completa.
Cdigo 15-6 Clase SyncStack
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
15-30
package mod13;
import java.util.*;
public class SyncStack {
private List<Character> buffer
= new ArrayList<Character>(400);
char c;
while (buffer.size() == 0) {
try {
this.wait();
// hacer caso omiso...
}
}
c = buffer.remove(buffer.size()-1);
return 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 {
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();
}
}
He aqu un ejemplo de la salida del cdigo java mod13.SyncTest.

Los resultados varan cada vez que se ejecuta el cdigo.
Productor2: F
Consumidor1: F
Productor2: K
Consumidor2: K
Productor2: T
Productor1: N
Hilos
15-31

Productor1: V
Consumidor2: V
Consumidor1: N
Productor2: V
Productor2: U
Consumidor2: U
Consumidor2: V
Productor1: F
Consumidor1: F
Productor2: M
Consumidor2: M
Consumidor2: T
15-32

Mdulo 16
Conexin en red
Objetivos
para:
Desarrollar cdigo para configurar la conexin en red.
Comprender el protocolo TCP/IP.
Utilizar las clases ServerSocket y Socket para implementar

clientes y servidores TCP/IP.
En este mdulo se explica el uso de sockets y su programacin en Java 2

SDK. La programacin de los sockets se comunica con otros programas
que se ejecutan en ordenadores de la misma red.
16-1
Aspectos relevantes
Aspectos relevantes
!
?
Discusin: La pregunta siguiente es importante en relacin con el

Cmo se establece un enlace de comunicacin entre una mquina
cliente y un servidor de la red?
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
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
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
Figura 16-1 Ejemplo de diagrama de conexiones en red
16-4

Conexin en red
Conexin en red con la tecnologa Java

En esta seccin se describe el concepto de conexin en red con la
tecnologa Java.
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
16-5
Conexin en red
Modelo de conexin en red de Java

En lenguaje de programacin Java, las conexiones de sockets TCP/IP se
implementan con clases del paquete java.net. La Figura 16-2 muestra
qu ocurre en el lado servidor y en el lado cliente.
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()
Figura 16-2 Conexiones de sockets TCP/IP

En la Figura 16-2:
16-6
El servidor asigna un nmero de puerto. Cuando el cliente solicita

una conexin, el servidor abre la conexin de socket con el mtodo
accept().
El cliente establece conexin con el host en el puerto n de puerto.
El cliente y el servidor se comunican utilizando un flujo de

entrada y un flujo de salida.

Servidor TCP/IP mnimo
Servidor TCP/IP mnimo

Las aplicaciones del servidor TCP/IP dependen de las clases de red
ServerSocket y Socket del lenguaje de programacin Java. La clase
ServerSocket simplifica considerablemente el procedimiento de
conexin al servidor.
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
import java.net.*;
import java.io.*;
public class ServidorSimple {
ServerSocket s = null;
// Registra el servicio en el puerto 5432
try {
s = new ServerSocket(5432);
}
// 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();
}
}
}
}
Conexin en red
16-7
Cliente TCP/IP mnimo
Cliente TCP/IP mnimo

El lado cliente de una aplicacin TCP/IP se basa en la clase Socket.
Tambin esta vez, gran parte del trabajo que implica establecer conexiones
corre a cargo de la clase Socket. El cliente se conecta al servidor de la
seccin Servidor TCP/IP mnimo en la pgina 16-7 y despus presenta
todo lo que el servidor ha enviado a la consola.
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
16-8
import java.net.*;
import java.io.*;
public class ClienteSimple {
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.);
// ignorar
}
}
}

Apndice A
Elementos de programacin Java avanzada

Objetivos
El estudio de este apndice le proporcionar los conocimientos necesarios
para:
Comprender las arquitecturas de dos y tres capas para sistemas

distribuidos.
Comprender la funcin del lenguaje Java como interfaz de usuario

para aplicaciones de base de datos.
Utilizar el API JDBC.
Comprender los mtodos de intercambio de datos utilizando agentes

de objeto.
Explicar el modelo de componentes JavaBeans.
Describir y utilizar las herramientas javadoc y jar.
A-1
Introduccin a la arquitectura de dos y de tres capas
Introduccin a la arquitectura de dos y de tres capas

Los sistemas cliente-servidor se componen de dos o ms equipos que
comparten tareas asociadas a una aplicacin completa. En una situacin
ideal, cada equipo ejecuta una lgica que responde a su diseo y
funcin definida.
La implementacin cliente-servidor ms utilizada es la de dos capas,
es decir, una aplicacin cliente que se comunica con un motor de base
de datos que se ejecuta en otro equipo. Los programas cliente envan
sentencias SQL (Structured Query Language, lenguaje de consulta
estructurado) al servidor de base de datos. El servidor devuelve los
resultados y el cliente se encarga de gestionar los datos.
El modelo bsico cliente-servidor de dos capas se utiliza para aplicaciones
que pueden ejecutarse con numerosas bases de datos de uso frecuente,
como ORACLE, Sybase e Informix.
Sin embargo, en este modelo cliente-servidor se pierde rendimiento.
El software cliente acaba siendo ms grande y complejo porque se
hace cargo de la mayor parte de la lgica. El uso de la lgica en el
servidor se limita a operaciones de bases de datos. En estos casos el
cliente recibe el nombre de cliente grueso.
Los clientes gruesos tienden a generar un trfico de red intenso para
acceder a bases de datos remotas. Esto funciona bien con topologas
de intranet y redes de rea local (LAN), pero requiere muchos recursos
de espacio en disco y memoria en el escritorio. Adems, no todos los
servidores de base de datos ofrecen la misma lgica y cada uno posee
una API que los programadores deben utilizar para optimizar y
ampliar el rendimiento. El cliente-servidor de tres capas, que se
describe a continuacin, maneja con mayor eficacia las cuestiones de
escalabilidad, rendimiento y particionamiento lgico.
A-2

Arquitectura de tres capas
Arquitectura de tres capas

La arquitectura de software cliente-servidor ms avanzada es la de tres
capas. Un cliente-servidor de tres capas exige inicialmente una curva de
desarrollo mucho ms pronunciada, sobre todo cuando tiene que ser
compatible con distintas plataformas y entornos de red. La contrapartida
es un trfico de red reducido, un excelente rendimiento de Internet e
intranet y ms control sobre la ampliacin y el crecimiento del sistema.
Definicin del cliente-servidor de tres capas

La Figura A-1 muestra un diagrama de una arquitectura de tres capas
genrica.
Presentacin
Figura A-1
Funcionalidad/lgica
empresarial
Datos
Arquitectura de tres capas genrica
Los tres componentes o capas de un entorno cliente-servidor de tres capas

son presentacin, funcionalidad o lgica de negocio y datos. Estn separados de
manera que el software de cualquiera de las capas pueda sustituirse por
una implementacin distinta sin que las dems capas se vean afectadas.
Por ejemplo, si quisiera sustituir una pantalla de caracteres por una
interfaz grfica (capa de presentacin), escribira la interfaz grfica
con una API o una interfaz establecida para acceder a los mismos
programas de funciones que con la pantalla de caracteres. La lgica de
negocio permite definir todas las reglas empresariales con las que
manipular los datos. Los cambios de poltica empresarial pueden
afectar a esta capa sin influir en las bases de datos propiamente dichas.
La tercera capa o capa de datos incluye los sistemas, aplicaciones y
datos existentes encapsulados para aprovechar esta arquitectura con
un mnimo esfuerzo de programacin transicional.

A-3
Interfaz de base de datos

El lenguaje de programacin Java ofrece amplias ventajas a los ingenieros
de software a la hora de crear aplicaciones cliente para sistemas de bases
de datos. Gracias a su funcin Write Once, Run Anywhere, el
lenguaje Java presenta grandes ventajas para su implementacin en
una amplia gama de equipos y sistemas operativos. Los programadores
no tienen que escribir cdigo especfico de una plataforma para
aplicaciones cliente ni siquiera en entornos de varias plataformas.
Con las mltiples clases de desarrollo frontales que admite la tecnologa
Java, es posible interaccionar con bases de datos mediante el API JDBC.
Esta API permite conectar con bases de datos de fondo (back-end) en las
que realizar consultas cuyos resultados gestiona la interfaz de usuario
(front-end).
En un modelo de dos capas, la base de datos reside en el servidor. El
cliente ejecuta una aplicacin frontal que abre un socket de comunicacin
a travs de la red. El socket proporciona una va de comunicacin entre la
aplicacin cliente y el servidor de fondo. En la siguiente ilustracin, los
programas cliente envan solicitudes de consulta de base de datos SQL al
servidor de base de datos. El servidor devuelve los resultados al cliente,
que les da formato para presentarlos. Esta arquitectura se muestra en la
Figura A-2.
Aplicacin
frontal
(cliente)
Solicitud SQL
Respuesta SQL
Servidor de base
de datos
(back-end)
Base
de datos
Figura A-2
Arquitectura centrada en base de datos
Los mecanismos que se utilizan con frecuencia para manipular datos

suelen estar integrados como procedimientos almacenados. Los activadores
ejecutan procedimientos almacenados automticamente cuando se dan
determinadas condiciones en el transcurso de las operaciones de la base
de datos. La principal desventaja de este modelo es que todas las reglas
empresariales se implementan en la aplicacin cliente, lo que prolonga
los tiempos de ejecucin en el lado cliente y aumenta la reescritura del
cdigo cliente.
A-4


En el modelo de tres capas, la lgica de presentacin y control est
integrada en la capa cliente (front-end). Se comunica con un servidor
intermedio que proporciona una capa para abstraerse de las aplicaciones
de fondo (back-end). Esta capa intermedia gestiona las reglas
empresariales que manejan los datos con las condiciones imperantes
en las aplicaciones y tambin puede aceptar conexiones de varios clientes
con uno o varios servidores de base de datos y distintos protocolos de
comunicacin. La capa intermedia ofrece a las aplicaciones una interfaz
independiente de la base de datos y le da mayor solidez a la interfaz
de usuario. La Figura A-3 muestra esta arquitectura.
Consulta SQL
Lgica de negocio
Aplicacin
(frontal) Respuesta SQL (Capa intermedia)
Servidor de
base de datos
(back-end)
Base de datos
Figura A-3
Arquitectura centrada en aplicaciones

A-5
Introduccin al API JDBC

La posibilidad de crear aplicaciones slidas independientes de la
plataforma y applets basados en web estimul a los desarrolladores a
crear soluciones de conectividad frontal. Los proveedores de bases de
datos y de herramientas de base de datos emplearon la tecnologa
JavaSoft para crear un mecanismo independiente del SGBD (sistema de
gestin de base de datos) que permitiera a los desarrolladores escribir
aplicaciones cliente capaces de funcionar con todas las bases de datos.
Este desarrollo dio como resultado la interfaz de programacin de
aplicaciones Java Database Connectivity (API JDBC).
Descripcin general del API JDBC

JDBC propone una interfaz estndar para acceder a bases de datos
relacionales. Diseada segn la especificacin ODBC (Open Database
Connectivity, conectividad abierta de base de datos), el paquete JDBC
contiene una serie de clases y mtodos para enviar sentencias SQL,
actualizaciones de tablas y llamadas a procedimientos almacenados.
La Figura A-4 muestra una aplicacin frontal con lenguaje de
programacin Java que utiliza el API JDBC para interaccionar con el
administrador de controladores JDBC. El administrador de controladores
JDBC utiliza el API de controladores JDBC para cargar el controlador
JDBC correcto. Los controladores JDBC, disponibles en distintos
proveedores de bases de datos, se comunican con el SGBS subyacente.
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
Capas de una aplicacin JDBC

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
Aplicacin JDBC que utiliza el puente ODBC
La interfaz del puente JDBC-ODBC se presenta como un conjunto de

bibliotecas dinmicas compartidas en C. ODBC proporciona un
conjunto de bibliotecas del lado cliente y un controlador especfico para el
sistema operativo del cliente. Estas llamadas ODBC se realizan como
llamadas C y el cliente debe tener una copia local del controlador ODBC y
de las bibliotecas cliente asociadas. Todo ello restringe su uso en
aplicaciones web.

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
Capas de una arquitectura RMI

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.
Creacin de una aplicacin RMI

En esta seccin se explica cmo crear, compilar y ejecutar una
aplicacin RMI. Los siguientes pasos conforman el proceso:
A-10
1.
Definicin de interfaces para clases remotas
2.
Creacin y compilacin de clases de implementacin para las

clases remotas
3.
Creacin de clases stub y esqueleto con el comando rmic
4.
Creacin y compilacin de la aplicacin servidor
5.
Inicio del registro RMI y la aplicacin servidor
6.
Creacin y compilacin de un programa cliente que acceda a los

objetos remotos
7.
Comprobacin del cliente

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
Lenguaje IDL de Java

El lenguaje IDL de Java aade la funcionalidad CORBA al lenguaje de
programacin Java, lo que permite ofrecer una conectividad e
interoperabilidad homologadas. Permite que las aplicaciones Java
distribuidas invoquen operaciones de manera transparente en servicios
de red remotos haciendo uso del lenguaje IDL y el protocolo IIOP
estndares del sector.
El lenguaje IDL Java no es una implementacin del IDL del grupo OMG.
En realidad es un agente CORBA que utiliza el lenguaje IDL para definir
interfaces. El compilador idltojava genera stubs cliente porttiles y
esqueletos servidor. El cliente CORBA interacciona con otro objeto que
se ejecuta en un servidor remoto al acceder a un objeto de referencia
por medio de su servicio de nombres. Al igual que el registro RMI, el
servicio de nombres es una aplicacin que se ejecuta como proceso en
segundo plano en un servidor remoto. Mantiene una tabla de servicios
designados y de referencias a objetos remotos que se utilizan para resolver
las solicitudes del cliente.
Los pasos para crear un objeto CORBA se resumen a continuacin:
A-12
1.
Creacin de la interfaz del objeto con el lenguaje IDL
2.
Conversin de la interfaz en objetos stub y esqueleto con el

compilador javatoidl
3.
Implementacin del objeto esqueleto mediante la creacin del objeto

servidor CORBA
4.
Compilacin y ejecucin del objeto servidor enlazndolo al servicio

de nombres
5.
Creacin y compilacin de un objeto cliente que invoque los

mtodos del objeto servidor
6.
Compilacin y ejecucin del objeto cliente accediendo al objeto

servidor mediante el servicio de nombres CORBA

CORBA
Comparacin entre RMI y CORBA

La principal ventaja de la llamada RMI estriba en que es totalmente
orientada a objetos. Por su parte, CORBA ofrece un mecanismo
bsicamente procedimental para conectar objetos distribuidos.
Analicemos su modelo de comandos. Este modelo ofrece una excelente
flexibilidad y facilidad de mantenimiento, pero no se puede implementar
correctamente entre dos sistemas CORBA porque precisa el
desplazamiento de los objetos (estado y comportamiento) del cliente al
servidor. La llamada RMI s permite hacerlo gracias al cdigo de byte
independiente de la plataforma.
Una de las grandes ventajas que suele destacarse al hablar de CORBA es
su independencia del lenguaje. Lo cierto es que RMI ofrece la misma
funcionalidad con la interfaz nativa Java.
Los servicios CORBA estn disponibles para problemas verticales y
horizontales de muy diversa ndole, ya que en general se entienden bien y
estn maduros. Las transacciones y la seguridad son ejemplos de
funciones de importancia potencial.
La independencia de CORBA con respecto al lenguaje aade bastante
complejidad al ciclo de desarrollo y prohbe funciones de reciclaje de
memoria dinmica que s admite la tecnologa RMI.
En muchos casos, la eleccin entre RMI y CORBA depender de motivos
polticos o de entorno ms que de cuestiones puramente tcnicas. Una
empresa que ya dispone de la funcionalidad CORBA necesitara
una razn muy apremiante para introducir una nueva tecnologa,
especialmente si el cambio supone una gran inversin por servicios
redundantes. Sin embargo, un sistema nuevo s puede beneficiarse del
uso de la tecnologa RMI, siempre que la direccin de la empresa no
la considere una tecnologa inmadura.

A-13
Modelo de componentes JavaBeans

La arquitectura JavaBeans es una tecnologa de integracin, una
infraestructura de componentes que permite que los objetos componentes
reutilizables (denominados beans) se comuniquen entre s y con la
infraestructura.
Un bean Java es un componente de software independiente y reutilizable
que se puede manipular visualmente en una herramienta de construccin.
Los beans pueden ser objetos visibles, como componentes AWT, u objetos
invisibles, como colas y pilas. Las herramientas de construccin o de
integracin administran beans para crear applets y aplicaciones. El
modelo de componentes que indica la especificacin JavaBeans 1.00-A
define cinco servicios principales:
A-14
Introspeccin: este proceso revela las propiedades, mtodos y

eventos con los que es compatible un componente JavaBeans.
Se utiliza durante el tiempo de ejecucin mientras se crea el bean
con una herramienta de desarrollo visual.
Comunicacin: el mecanismo de control de eventos crea un evento

que sirve como mensaje para otros componentes.
Persistencia: es un medio para almacenar el estado de un

componente. La manera ms simple de lograr persistencia es
aprovechar la serializacin de objetos en Java, aunque guardar el
estado del bean depende de cada navegador o aplicacin que lo
utilice.
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.
Personalizacin: una de las principales caractersticas del bean es que

es reutilizable. La infraestructura de beans ofrece varias maneras de
personalizar los beans existentes para convertirlos en otros nuevos.

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
Ejemplo de interaccin de beans

Ejemplo de interaccin de beans

En la Figura A-7 de la pgina A-16, los contenedores A y B tienen seis
beans. Un bean puede interaccionar con otros que estn en el mismo
contenedor y con beans que estn en un contenedor diferente. En este
ejemplo, el bean 1 interacciona con el bean 4. No se comunica con los
beans 2 y 3, que residen en el mismo contenedor. Esto ilustra que un
bean se puede comunicar con cualquier otro y que no est limitado a
comunicarse con los que estn en el mismo contenedor. Sin embargo,
el bean 4 se comunica con el 5, que est en el mismo contenedor. El bean
fuente 1 enva un evento al bean destino 4, lo que provoca que reciba
mensajes en su receptor de eventos. Todas las dems interacciones
entre contenedores y dentro de ellos se explican de la misma manera.
Kit de desarrollo BDK

El kit de desarrollo de Java para componentes JavaBeans (BDK, Beans
Development Kit) es una aplicacin Java desarrollada por JavaSoft que
permite a los desarrolladores de la tecnologa Java crear componentes
reutilizables con el modelo bean. Es un sistema completo que contiene
cdigo fuente para todos los ejemplos y la documentacin. El kit BDK
se suministra con un ejemplo de constructor de beans y una aplicacin
de personalizacin denominada BeanBox. BeanBox es un contenedor
de prueba que sirve para lo siguiente:
Cambiar de tamao y mover beans.
Modificar beans con hojas de propiedades.
Personalizar beans con una aplicacin de personalizacin.
Conectar beans entre s.
Colocar beans en una ventana de composicin.
Guardar beans mediante serializacin.
Restablecer beans.
El kit BDK se suministra con un conjunto de 12 beans de ejemplo que

abarcan todos los aspectos del API JavaBeans.

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

Uso de la herramienta javadoc

La documentacin del cdigo es importante para el resultado de las
futuras tareas de mantenimiento con aplicaciones autnomas, adems
de ser fundamental para el uso de las API. En esta seccin se describe
brevemente la herramienta javadoc, las etiquetas de comentario y el
uso de la herramienta.
Es probable que ya haya utilizado en alguna ocasin la documentacin de
Java 2 SDK. Veamos cmo puede generar pginas HTML de
documentacin para sus proyectos.
> javadoc -private -d ../doc/api banking banking.domain banking.reports
Por lo general, para generar la documentacin de una API utilizara la
opcin -public (o la omitira, ya que es la predeterminada). Sin embargo,
es frecuente utilizar la opcin -private para generar la documentacin
que comparte el equipo de personas de un proyecto de aplicacin.
Nota: Para obtener ms informacin sobre este tema, consulte la
documentacin en lnea.
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;
/**
* 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;
}
}


El siguiente comando genera el resultado que se muestra en la Figura A-8:
> javadoc -d doc/api/public DocExample.java
Figura A-8
Ejemplo con la opcin public

A-21

El siguiente comando genera el resultado que se muestra en la Figura A-9:
> javadoc -private -d doc/api/private DocExample.java
Figura A-9
A-22
Ejemplo con la opcin private

Apndice B
Gua de consulta rpida sobre el lenguaje UML

Objetivos
para:
Comprender los principios bsicos del lenguaje UML.
Describir los elementos generales del lenguaje UML.
Describir diagramas de casos de uso.
Describir diagramas de clases.
Describir diagramas de objetos.
Describir diagramas de colaboracin.
Describir diagramas de secuencia.
Describir diagramas de estados.
Describir diagramas de actividades.
Describir diagramas de componentes.
Describir diagramas de distribucin.
B-1
Otros recursos
Otros recursos
complementaria sobre los temas descritos en este apndice:
Booch, Grady, James Rumbaugh e Ivar Jacobson. The Unified

Modeling Language User Guide. Reading: Addison Wesley Longman,
Inc., 1999.
Folwer, Martin, con Kendall Scott. UML Distilled (2nd ed). Reading:
Addison Wesley Longman, Inc., 2000.
The Object Management Group. OMG Unified Modeling Language

Specification, versin 1.4, septiembre de 2001,
[http://www.omg.org/technology/documents/formal/uml.htm],
disponible el 22 de abril de 2004.
Nota: Otros recursos disponibles en lnea sobre el lenguaje UML en:

http://www.omg.org/uml/.
B-2

Principios bsicos del lenguaje UML

El lenguaje UML (Unified Modeling Language, lenguaje unificado de
modelado) es un lenguaje grfico para modelar sistemas informticos.
UML no es un lenguaje de programacin, sino un conjunto de diagramas
que pueden utilizarse para especificar, construir, visualizar y documentar
diseos de software. Los ingenieros de software utilizan los diagramas
UML para construir y explicar sus diseos de software del mismo modo
que un arquitecto utiliza planos para construir y explicar su concepcin
de un edificio. El lenguaje UML contiene diagramas que ayudan a lo
largo de todo el proceso de desarrollo de una aplicacin, desde la
identificacin de los requisitos hasta el diseo, pasando por su
codificacin, prueba e implementacin.
El lenguaje UML fue creado a principios de los aos 90 por tres maestros
del mundo del modelado de objetos: Grady Booch, James Rumbaugh
e Ivar Jacobson. Su objetivo era unificar los principales mtodos que
haban desarrollado hasta entonces para crear una nueva norma de
modelado de software. Actualmente, es el lenguaje de modelado
ms extendido y el grupo OMG garantiza su mantenimiento. La
especificacin UML est disponible en el sitio web del grupo OMG
en http://www.omg.org/uml/.
UML no es un proceso de anlisis y diseo, sino un conjunto de
herramientas que se utilizan durante un proceso. Suele emplearse con
procesos como USDP (Unified Software Development Process, proceso
unificado de desarrollo de software). El curso de Sun Microsystems
OO-226: Anlisis y diseo OO con UML es un curso de cinco das que
ensea mtodos eficaces de anlisis y diseo con el lenguaje UML, el
mtodo USDP y patrones de software.

B-3

El lenguaje UML define nueve tipos estndar de diagramas. La Tabla B-1
contiene una lista de estos diagramas con una breve descripcin de
las caractersticas y el uso de cada uno.
Tabla B-1 Tipos de diagramas UML
Nombre del
diagrama
Descripcin
Uso
Casos de uso
Un diagrama de casos de uso es un

diagrama sencillo que indica quin
utiliza el sistema y los procesos
que ejecuta con l.
Los diagramas de casos de uso

permiten documentar los flujos
de trabajo de identificacin y
anlisis de requisitos. Con el
diagrama de casos de uso debe
ser posible llevar un
seguimiento del trabajo
realizado a lo largo de todo el
ciclo de desarrollo.
Clases
Un diagrama de clases muestra un

conjunto de las clases del sistema,
as como las asociaciones y
relaciones de herencia entre ellas.
Los nodos de clase tambin
pueden contener una lista de
atributos y operaciones.
Los diagramas de clases

permiten mostrar la estructura
del sistema y los elementos que
hay que programar. La mayora
de las herramientas de casos
del lenguaje UML pueden
generar cdigo basndose en el
diagrama de clases.
Objetos
Un diagrama de objetos muestra

instancias de objetos especficos y
los enlaces entre ellas. Es una
instantnea de los objetos del
sistema en un momento dado.
Los diagramas de objetos

permiten clarificar o validar el
diagrama de clases.
Actividades
Un diagrama de actividades es
bsicamente un organigrama con
smbolos nuevos. Representa el
flujo de actividades de un proceso
o algoritmo.
Los diagramas de actividades

permiten modelar sistemas
empresariales reales durante el
flujo de trabajo de
identificacin de requisitos.
Colaboracin
Los diagramas de colaboracin y

los diagramas de secuencia
muestran procesos desde un punto
de vista orientado a objetos. La
principal diferencia entre ambos es
que la disposicin del diagrama de
colaboracin presta ms atencin a
los objetos que a la secuencia.
Los diagramas de colaboracin

permiten centrarse en los
objetos de una secuencia.
Suelen ser ms difciles de leer
que los diagramas de
secuencia.
B-4


Tabla B-1 Tipos de diagramas UML (Continuacin)
Nombre del
diagrama
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.
Los diagramas de secuencia

permiten asignar
responsabilidades a clases, ya
que analizan cmo stas
pueden trabajar juntas para
implementar los procesos en el
sistema. Este aspecto es
fundamental.
Estados
Un diagrama de estados muestra

cmo cambia su estado de
comportamiento un objeto
determinado al desencadenarse
diversos eventos.
Los diagramas de estados

permiten comprender los
objetos que cambian su estado
de comportamiento de modos
significativos.
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.
Los diagramas de componentes

permiten mostrar cmo encajan
en el sistema los componentes
orientados y no orientados a
objetos. Tambin se trata de un
modo excelente de examinar la
estructura informtica superior
del sistema.
Distribucin
Un diagrama de distribucin
muestra los nodos fsicos del
sistema.
Los diagramas de distribucin

permiten mostrar el modo de
configurar un sistema
distribuido. Los componentes
de software pueden mostrarse
dentro de los nodos fsicos para
ilustrar cmo van a instalarse.

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
Asignacin a paquetes de tecnologa Java

La asignacin de paquetes UML a paquetes de tecnologa Java implica
que las clases contienen la declaracin de paquete del paquete
transporte.dominio. Por ejemplo, en el archivo Vehiculo.java:
package transporte.dominio;
// declaraciones
}
La Figura B-1 de la pgina B-6 tambin muestra una jerarqua sencilla
de paquetes. El paquete transporte contiene los subpaquetes GUI,
informes y dominio. La flecha discontinua que va de un paquete a otro
indica que el paquete situado en la cola de la flecha utiliza (importa)
elementos del paquete situado en la punta de la flecha. Por ejemplo,
informes utiliza elementos del paquete dominio de esta manera:
// declaraciones
}
Nota: En la Figura B-1 de la pgina B-6, los paquetes transporte.GUI

y transporte.informes tienen el nombre dentro del recuadro del
paquete y no en la cabecera. Esto ocurre nicamente cuando el
diagrama no revela ninguno de los elementos de ese paquete.

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
Las notas pueden contener anotaciones sobre el diagrama en general,

sobre un nodo o enlace concreto o incluso sobre un elemento de un nodo.
La lnea de puntos une la nota con el elemento al que se refiere. Si de la
nota no sale ningn enlace, su contenido se aplica al diagrama en general.
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
Ejemplo de valores etiquetados

B-9
Diagramas de casos de uso
Diagramas de casos de uso

Un diagrama de casos de uso representa las funciones que ofrece el
sistema a los usuarios externos. Se compone de actores, nodos de caso de
uso y sus relaciones. Los actores pueden ser personas u otros sistemas.
La Figura B-6 muestra un sencillo diagrama de casos de uso de un banco.
Los nodos de actor pueden representarse con una figura humana (como en
los tres actores Cliente) o con un nodo de clase (consulte Nodos de clase
en la pgina B-11) y el estereotipo actor. Es posible emplear una
jerarqua de actores.
Actor node
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
Ejemplo de diagrama de casos de uso
Los nodos de caso de uso se representan con una elipse etiquetada.

La etiqueta indica el resumen de actividades que realiza el sistema
con ese actor. Los nodos de caso de uso se agrupan en un recuadro
de sistema, que suele identificarse en el ngulo superior izquierdo.
La relacin El actor utiliza el sistema para se expresa con la lnea continua
que une al actor con el nodo de caso de uso.
Los nodos de caso de uso pueden depender de otros casos de uso.
Por ejemplo, el caso de uso Extraccin cajero utiliza el caso de uso
Acceso cajero.
Los nodos tambin pueden ampliar otros casos de uso para ofrecer
funciones optativas. Por ejemplo, el caso de uso Mostrar saldo podra
utilizarse para ampliar el caso de uso Confirmar ingreso cliente.
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
Varios nodos de clase
Un nodo de clase slo puede ser el nombre de la clase, como en los

ejemplos 1, 2 y 3 de la Figura B-7. El ejemplo 1 es una clase concreta para
la que no se ha modelado ningn miembro, el ejemplo 2 es una clase
abstracta (nombre en cursiva), el ejemplo 3 es una interfaz y el ejemplo 4
es una clase concreta para la que se han modelado miembros.

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
Elementos de un nodo de clase
Un nodo de clase completo se compone de tres compartimentos

fundamentales:
El primer compartimento es para el nombre de la clase.
El segundo compartimento, situado bajo la primera barra, es para el

conjunto de atributos.
Cada atributo se especifica con cinco elementos: modo de acceso,
nombre, multiplicidad, tipo de datos y valor inicial. Todos
los elementos de un atributo son optativos, excepto el elemento
nombre.
El conjunto de mtodos situado bajo la segunda barra es el tercer

compartimento.
Cada mtodo se especifica con cuatro elementos: modo de acceso,
nombre, lista de parmetros (lista de nombres y tipos de
parmetros delimitados por comas) y tipo de retorno. Todos los
elementos de un mtodo son optativos, excepto el elemento nombre.
Si no se especifica valor de retorno, no se devuelve ningn valor
(void). El nombre de los mtodos abstractos se escribe en cursiva.
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
La Figura B-9 muestra un ejemplo de nodo de clase con elementos que

tienen mbito de clase (o estticos). Este aspecto se indica subrayando el
elemento. Por ejemplo, counter es un atributo de datos esttico y
getTotalCount es un mtodo esttico.
Count
Class scope
-counter : int = 0
-instanceNumber : int
getTotalCount() : int
+getMyNumber() : int
Figura B-9
Ejemplo de nodo de clase con elementos estticos
La clase Count podra escribirse en lenguaje de programacin Java de este

modo:
public class Count {
private int instanceNumber;
public static int getTotalCount() {
return counter;
}
public int getMyNumber() {
return instanceNumber;
}
}

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
Figura B-10 Relacin de herencia de clases

La herencia de clases se aplica en lenguaje Java con la palabra clave
extends. Por ejemplo:
public class Cuenta {
// miembros
}
public class CuentaAhorro extends Cuenta {
// miembros
}
public class CuentaCorriente extends Cuenta {
// miembros
}
B-14

Diagramas de clases
Implementacin de una interfaz

La Figura B-11 muestra cmo utilizar la flecha de realizacin para modelar
una clase que implementa una interfaz.
interface
Map
+put(key : Object, value : Object) : Object
+get(key : Object) : Object
+remove(key : Object) : Object
+clear()
+containsKey(key : Object) : boolean
+isEmpty() : boolean
+size() : int
+keySet() : Set
Realization arrow
HashMap
Figura B-11 Ejemplo de clase que implementa una interfaz

Una interfaz se implementa en lenguaje Java con la palabra clave
implements. Por ejemplo:
public interface Map {
// lugar de la declaracin
}
public class HashMap implements Map {
// lugar de las definiciones
}

B-15
Diagramas de clases
Asociacin, rol y multiplicidad

La Figura B-12 muestra un ejemplo de asociacin. Una asociacin es el lazo
que se establece entre dos tipos de objetos e implica que el cdigo de un
objeto puede pasar al otro.
Association name
Association direction
Multiplicity
Instructor
Multiplicity
0..*
Teaches
teacher
Course
class
Association roles
Figura B-12 Asociaciones y roles de clases

En este diagrama, Imparte es el nombre de la asociacin y lleva una flecha
hacia la derecha. Esta asociacin puede interpretarse como Un profesor
imparte un curso. Tambin es posible asignar roles a cada extremo de la
asociacin. En la Figura B-12, el rol de monitor indica que el profesor es el
monitor de un curso determinado. Todos estos elementos son optativos si
la asociacin es obvia.
Este ejemplo tambin muestra el nmero de objetos implicados en cada
rol de la asociacin. Es lo que se denomina multiplicidad. En este ejemplo,
slo hay un profesor por clase, ya que hay un 1 junto a Profesor en la
asociacin. Adems, cada profesor puede impartir cero o ms cursos,
lo que se indica con 0..* junto a Curso. La multiplicidad puede omitirse
en un rol determinado si siempre es 1. La expresin cero o ms (0..*)
puede abreviarse con un asterisco (*).
Los valores de multiplicidad pueden expresarse de la siguiente manera:
Un intervalo de valores: por ejemplo, 2..10 (un mnimo de 2 y un

mximo de 10)
Un conjunto de valores discontinuos: por ejemplo, 2,4,6,8,10
Un conjunto de valores o intervalos discontinuos: por ejemplo,

1..3,6,8..11
Sin embargo, los valores de multiplicidad ms habituales son exactamente

uno (1 o campo vaco), cero o uno (0..1), cero o ms (*) o uno o ms
(1..*).
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
Figura B-13 Ejemplo de agregacin y composicin
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
Figura B-14 Clase de asociacin simple

La Figura B-15 muestra una clase de asociacin que utilizan dos
asociaciones y que tiene dos atributos privados. Este ejemplo indica
que un objeto Partido est asociado a dos equipos adversarios y que
cada equipo tendr un tanteo y un indicador para especificar si ha
abandonado el partido.
Association class
Team
Result
opponent2
*
opponent1
-score : int
-forfeit : boolean
Game
Figura B-15 Clase de asociacin compleja

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
Otros elementos de una asociacin

Las asociaciones contienen diversas partes ms. Esta seccin presenta
las restricciones y los elementos calificadores.
Una restriccin de asociacin permite aumentar la semntica de dos o
ms asociaciones al introducir una flecha de dependencia entre ellas y
etiquetar esta dependencia con una restriccin. Por ejemplo, en la
Figura B-16, el capitn y el segundo capitn de un equipo tambin
son miembros de la plantilla del equipo.
League
1..*
1..*
Division
*
captain
*
co-captain
Association qualifier
index:int
Team
Schedule
{member}
roster
Association
constraint
0..1
Player
0..1
Game
A three dimensional array of:

event date, time slot, and field number
Figura B-16 Otros elementos de una asociacin

Un calificador de asociacin ofrece un mecanismo de modelado para
indicar que el objeto de un extremo de la asociacin puede buscar a
otro que se encuentra en el otro extremo. Por ejemplo, un determinado
partido de un calendario se identifica de forma nica con los
elementos siguientes:
La fecha del evento: sbado, 12 de agosto de 2000
La franja horaria: de 11:00 a.m. a 12:30 p.m.
El nmero de un campo: nmero de campo 2
Una implementacin particular sera un array tridimensional (por

ejemplo, Partido[][][]) en el que cada elemento calificador (fecha,
franja horaria y nmero de campo) estara asignado a un ndice entero.

B-21
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>
Figura B-17 Ejemplo de diagrama de objetos
B-22

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
Figura B-18 Ejemplo de diagrama de objetos

B-23
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
Figura B-19 Diagrama de colaboracin controlado por el usuario

El servlet emplea un objeto de la clase LoginService para buscar el
nombre de usuario, verificar la contrasea y crear el objeto User. Los
enlaces entre los objetos muestran las dependencias y colaboraciones
entre ellos. Los mensajes entre los objetos se indican mediante mensajes
sobre los enlaces. Los mensajes se indican con una flecha que sigue la
direccin del mensaje, y una cadena de texto declara el tipo de mensaje.
El texto de esta cadena de mensaje no tiene limitaciones. Los mensajes
tambin estn etiquetados con un nmero de secuencia que informa
del orden de las llamadas de los mensajes.
B-24

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}
Figura B-20 Diagrama de colaboracin

Los enlaces pueden etiquetarse con un estereotipo para indicar si el
objeto es global o local con respecto a la secuencia de llamadas. En este
ejemplo, los objetos Connection son globales y los objetos Statement y
Transaction son locales.
Tambin es posible etiquetar los objetos con una restriccin para indicar si
son transitorios.

B-25
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
SELECT * FROM User

WHERE user_name=?
Activation
box
Lifeline
create
Message
Return
(with value)
user
:User
Object
created
Named
class role
Figura B-21 Ejemplo de diagrama de secuencia controlado por el usuario
B-26

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
executeUpdate("INSERT INTO CustomerOrder(...)")
SQL Insert command
createStatement
create
Return
(Implicit)
{transient}
executeUpdate("UPDATE ItemInventory SET...")
:Statement
SQL Update
SQLException("Update failed.")
rollback()
close() destroy
close() destroy
destroy
Object destroyed
Figura B-22 Diagrama de secuencia

B-27
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
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
Figura B-23 Ejemplo de diagrama de estados

No hay ningn modo predefinido para implementar un diagrama de
estados. En el caso de un comportamiento complejo, quiz sera
interesante considerar el uso del patrn de diseo State.

B-29
Transiciones
Una transicin consta de cinco elementos:
Estado inicial: estado que cambia con la transicin.
Activador del evento: evento cuya recepcin en el objeto que se

encuentra en el estado inicial permite que se desencadene la
transicin, siempre que se cumpla la condicin de proteccin.
Condicin de proteccin: expresin booleana que sirve para

determinar si debe efectuarse la transicin de estado cuando se
produce el evento activador.
Accin: clculo u operacin realizada en el objeto que cambia de

estado.
Estado final: estado activo al finalizar la transicin.
La Figura B-24 muestra una transicin en detalle.

Source state
Event trigger
Guard condition
Action
Running
wait()
[must have lock]/

releases lock
Target state
Blocked in
objects
wait pool
Figura B-24 Ejemplo de transicin de estado
B-30

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
Render HTML in browser
Stop state
Figura B-25 Actividades y transiciones

B-31
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)
Figura B-26 Ramificaciones y bucles
B-32

La Figura B-27 muestra un diagrama de actividades ms complejo.
Swimlanes
Customer
WebSalesAgent
Warehouse
Request Products
Fork
o:Order
[in progress]
Wait for confirmation

Verify availability
Object
flow
o:Order
Charge credit card
[pending]
Return confirmation
Join
Schedule backorder
Package products
Ship order
Close order
o:Order
[sent]
Figura B-27 Ejemplo de diagrama de actividades

B-33
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
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
Figura B-28 Ejemplo de nodos de componente

La Figura B-29 muestra las dependencias de empaquetar una pgina
HTML que contiene un applet. La pgina HTML depende del archivo
JAR, que a su vez se ha construido a partir de un conjunto de archivos de
clase. Los archivos de clase se compilan a partir de los archivos fuente
correspondientes. Es posible utilizar un valor etiquetado para indicar
los nmeros de la versin de control de los archivos fuente.
calculator.html
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
Figura B-29 Ejemplo de diagrama de componentes

B-35
Nota: SCM significa Source Control Management (Sistemas de control de

versiones).
La Figura B-30 muestra otro diagrama de componentes. En este diagrama,
varios componentes disponen de un conector de interfaces. El
componente vinculado al conector implementa la interfaz designada.
El componente que tiene una flecha orientada hacia el conector
depende de que el componente advierta esa interfaz.
Interface connector
catalog.jsp
CatalogHome
CatalogHome
Catalog
Home Stub
Catalog
Business
Delegate
Catalog
EJB Home
Catalog
Bean
Remote method calls

across a network using IIOP
CatalogRemote
Catalog
Remote Stub
CatalogRemote
CatalogRemote
Catalog
EJB Object
Figura B-30 Diagrama de componentes con interfaces

En este ejemplo de tecnologa J2EE, la capa web incluye un archivo
denominado catalog.JSP, que a su vez utiliza un delegado de negocio
JavaBeans para comunicarse con la capa de tecnologa Enterprise
JavaBeans (EJB). Cada Enterprise Bean (bean de negocio) debe incluir
dos interfaces. La interfaz Home permite al cliente crear nuevos beans de
negocio en el servidor EJB. La interfaz remota permite al cliente llamar a
los mtodos de lgica de negocio del Enterprise Bean (remoto). El
delegado de negocio se comunica con el bean "catalog" a travs de objetos
stub locales que implementan las interfaces Home y remota correctas.
Estos objetos se comunican a travs de una red con el protocolo IIOP
(Internet Inter ORB Prococol, protocolo Inter-ORB de Internet) y esqueletos
remotos. En terminologa EJB, estos objetos se denominan EJBHome y
EJBObject. Se comunican directamente con el bean "catalog" que
implementa la lgica de negocio verdadera.
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
Figura B-31 Ejemplo de diagrama de distribucin

El cliente ejecuta un navegador de web que se comunica con un servidor
web Apache. Por lo tanto, el componente navegador depende del
componente Apache. Igualmente, la aplicacin Apache depende de los
archivos HTML que sirve. La mquina cliente tambin est conectada a
la impresora local a travs de un puerto paralelo.
Un diagrama de distribucin puede utilizarse para mostrar cmo
configurar las capas lgicas de la arquitectura de una aplicacin en
una red fsica.

B-37
Apndice C
Componentes Swing
Objetivos
para:
Describir el aspecto de cada componente Swing.
C-1
Ejemplos de componentes Swing
Ejemplos de componentes Swing

Este apndice muestra ejemplos de numerosos componentes Swing junto
con una breve descripcin de cada uno.
C-2


La Tabla C-1 describe brevemente los contenedores de nivel superior.
Tabla C-1 Contenedores de nivel superior
Contenedor
Interfaz de usuario
Un marco es la ventana bsica de la mayora

de las aplicaciones de interfaz grfica. Se
compone de un borde y un ttulo, pero es
posible aadirle otros componentes y
dibujar en su interior. Tambin se le
pueden agregar mens. Para crear marcos
se utiliza la clase javax.swing.JFrame.
JDialog se emplea para crear ventanas de

dilogo. El API contiene versiones diferentes
de constructores para definir cuadros de
dilogo. Los cuadros de dilogo dependen
de los marcos y pueden utilizarse para
obtener informacin del usuario y confirmar
acciones importantes. Igualmente, permiten
presentar en pantalla advertencias, errores,
preguntas y mensajes para el usuario.
El contenedor JWindow es similar a JFrame,
pero carece de borde y de barra de ttulo.
No hay ningn servicio de administracin de
ventanas.
El contenedor JApplet se utiliza para crear

una interfaz de usuario que se ejecuta en un
navegador de web. Normalmente, los
contenedores JApplet estn integrados en
una pgina web y pueden emplearse para
reproducir animaciones. A este contenedor
pueden aadrsele otros componentes y
mens y tambin es posible dibujar en l.
Componentes Swing
C-3
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
Los paneles son contenedores

en los que es posible insertar
varios componentes. Tambin
presentan una superficie de
dibujo. A diferencia de los
contenedores JFrame, no son
de nivel superior. Los paneles
deben estar incluidos en
contenedores de nivel
superior. Para crear paneles se
utiliza la clase
javax.swing.JPanel. sta
ampla JComponent, no
java.awt.Panel.
Los paneles desplazables son
muy tiles cuando el espacio es
limitado. Se emplean para
mostrar componentes o
imgenes grandes. Contienen
dos barras de desplazamiento,
un encabezado de fila y un
encabezado de columna. Para
crear paneles desplazables se
utiliza la clase
javax.swing.JScrollpane.
C-4

Tabla C-2 Contenedores genricos (Continuacin)
Contenedor
Interfaz de usuario
Una barra de herramientas es

un grupo de botones con
iconos que facilitan el acceso a
funciones de uso frecuente.
Pueden considerarse como
mtodos abreviados de las
acciones de los mens.
Para crear barras de
herramientas se utiliza la clase
javax.swing.JToolbar.
Los paneles divisibles
muestran dos o ms
componentes separados por
un divisor. Los componentes
pueden mostrarse uno al lado
del otro o uno sobre otro. La
cantidad de espacio asignada a
cada componente puede
ajustarse arrastrando el
divisor. Para crear paneles
divisibles se utiliza la clase
javax.swing.JSplitPane.
Los paneles con fichas tambin
resultan prcticos cuando hay
limitaciones de espacio.
Constan de varias fichas que
comparten el mismo espacio,
pero slo una es visible a la
vez. Si desea ver una ficha, el
usuario debe seleccionarla.
Para crear paneles con
fichas se utiliza la clase
javax.swing.JTabbedPane.
Componentes Swing
C-5
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
Los marcos internos no son

contenedores de nivel superior.
Contienen caractersticas similares a
JFrame, ya que se pueden arrastrar,
cambiar de tamao, convertir en
icono y maximizar. Los marcos
internos se crean con la clase
javax.swing.JInternalFrame,
que se aade a JDesktopPane, y
ste, a su vez, se inserta en un
contenedor JFrame. Al igual que
con los marcos estndar, al
contenedor JInternalFrame
pueden aadrsele componentes.
Los paneles de capas permiten
agregar componentes a la
profundidad necesaria. La
profundidad se especifica con
un valor entero. Para crear paneles
de capas se utiliza la clase
javax.swing.JLayeredPane. Por
comodidad, es posible emplear
las capas estndar definidas en
esta clase: DEFAULT_LAYER
(capa inferior), PALETTE_LAYER,
MODAL_LAYER,
POPUP_LAYER y
DRAG_LAYER (capa superior).
C-6

Cuando se utilizan clases contenedor, es preciso tener en cuenta las reglas
siguientes:
Los componentes de la interfaz grfica se muestran nicamente

cuando estn incluidos en una jerarqua de contencin. Una jerarqua
de contencin es un rbol de componentes con un contenedor de
nivel superior en la raz.
En un rbol de contencin slo puede aparecer una instancia del

objeto componente de la interfaz grfica. Si un componente de un
contenedor se aade a otro contenedor, se desplaza a este ltimo y se
elimina del primero.
Cada contenedor de nivel superior dispone de un panel de

contenido que, en trminos generales, contiene (directa o
indirectamente) los componentes visibles de la interfaz grfica de ese
contenedor de nivel superior.
A un contenedor de nivel superior es posible aadirle una barra de

mens. Por convencin, sta se coloca dentro del contenedor de nivel
superior, pero fuera del panel de contenido. Algunos estilos de
interfaz, como el de Macintosh, permiten colocar la barra de mens
en otro lugar ms acorde con la interfaz, como la parte superior de la
pantalla.
Estos cuatro contenedores (incluido JApplet) utilizan una interfaz

especial denominada RootPaneContainer, pero este mdulo no tiene
como fin examinarlo en detalle.
Principios bsicos del contenedor JFrame

El contenedor JFrame es el contenedor Swing de nivel superior ms
utilizado. JFrame permite elegir una de cuatro reacciones para el botn
de men de cierre de ventana (Close Window). Estas reacciones son las
siguientes:
DO_NOTHING_ON_CLOSE
HIDE_ON_CLOSE
DISPOSE_ON_CLOSE
EXIT_ON_CLOSE
La opcin se define llamando al mtodo setDefaultCloseOperation

en la instancia de JFrame.
Componentes Swing
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
Los objetos JButton se crean con un simple argumento

String dirigido al constructor, en cuyo caso muestran el
texto como etiqueta. Al hacer clic en un objeto JButton, se
genera un evento del tipo ActionEvent. Es aconsejable
definir la propiedad del comando de accin del botn de
modo que el evento ActionEvent transporte una
determinada cadena de comandos. Si se crea un objeto
JButton con texto, el texto de la etiqueta se utiliza de forma
predeterminada como cadena de comandos de accin. Sin
embargo, si se crea un botn nicamente grfico o si la cadena
de comandos de accin predeterminada (la etiqueta de texto
del botn) no es necesaria, el comando de accin puede
definirse explcitamente con el mtodo setActionCommand.
Las casillas de verificacin son similares a los objetos
JButton en que pueden inicializarse con un sencillo
argumento String dirigido al constructor, en cuyo caso
muestran el texto como etiqueta. Sin embargo, su modelo
de seleccin es diferente por convencin. Una casilla de
verificacin tiene un valor de estado booleano que puede
estar activado (true) o desactivado (false). Al hacer clic en la
casilla de verificacin, su estado pasa de activado a
desactivado o de desactivado a activado. Para crear casillas de
verificacin se utiliza la clase javax.swing.JCheckBox.
Individualmente, cada objeto JRadioButton se limita a
activarse y desactivarse cada vez que se selecciona, igual
que los objetos JCheckBox. Para lograr que los botones de
opcin se excluyan mutuamente, deben aadirse a una
instancia del grupo ButtonGroup. Un grupo de botones es
un gestor que se encarga de que slo haya un botn
seleccionado en cada momento. Para crear un grupo de
botones, utilice la clase ButtonGroup.
C-8

Los componentes de texto Swing se dividen en tres categoras generales:
Controles de texto: JTextField y JPasswordField (para que el

usuario introduzca informacin)
reas de texto sin formato: JTextArea (muestra texto sin formato y

tambin permite la introduccin de varias lneas de informacin por
parte del usuario)
reas de texto con formato: JEditorPane y JTextPane (muestran

texto con formato)
La Tabla C-5 describe estos componentes y muestra su interfaz de usuario.

Tabla C-5 Componentes de texto
Componente
Interfaz de usuario
Las reas de texto se emplean

normalmente para recopilar ms de
una lnea de informacin del
usuario. Para crear reas de texto se
utiliza la clase
javax.swing.JTextArea. En el
proceso es posible especificar el
nmero de filas y columnas y el
contenido inicial. Las reas de texto
slo muestran texto sin formato.
Los campos de texto tambin se
utilizan para captar informacin del
usuario. Son similares a las reas de
texto, pero slo aceptan una lnea de
texto. Para crear campos de texto se
utiliza la clase
javax.swing.JTextField.
Componentes Swing
C-9
Tabla C-5 Componentes de texto (Continuacin)
Componente
Interfaz de usuario
Los paneles de edicin son

componentes de texto con formato.
Adems de texto sin formato,
permiten mostrar y editar texto en
formato RTF y HTML. Suelen
emplearse para mostrar la ayuda en
formato HTML. Para crear paneles
de edicin se utiliza la clase
javax.swing.JEditorPane.
La clase javax.swing.JTextPane
es heredera de
javax.swing.JEditorPane.
Adems de suministrar todas las
caractersticas de JEditorPane, la
clase JTextPane tambin permite
integrar componentes.
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

Componentes de presentacin de informacin no modificables
Componentes de presentacin de informacin no

modificables
Los componentes de presentacin de informacin no modificables sirven para
aadir informacin complementaria sobre los componentes. Slo
pueden utilizarse como componentes de presentacin. La Tabla C-6
describe algunos de ellos.
Tabla C-6 Componentes de presentacin no modificables
Componente
Interfaz de usuario
Las etiquetas permiten mostrar

texto en la pantalla. Son
componentes no modificables.
Para crear etiquetas se utiliza la
clase javax.swing.JLabel. Las
etiquetas tambin pueden
utilizarse para presentar imgenes.
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
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
Una barra de mens contiene los

nombres de uno o varios mens
desplegables. Al hacer clic en los
nombres, se abren opciones de men y
submens. Para crear mens se
utilizan las clases javax.swing.JMenu
y javax.swing.JMenuItem. Las
opciones de men pueden
seleccionarse con teclas de acceso y
de mtodo abreviado y tambin
pueden llevar casillas de verificacin
y botones de opcin.
Un men emergente es un men que
no est asociado a la barra de mens.
Estos menus se conocen a veces como
mens contextuales. Para crear mens
emergentes se utiliza la clase
JPopupMenu.
C-12

Componentes de presentacin con formato

Los componentes de presentacin con formato figuran entre los componentes
Swing de mayor complejidad. En esta categora se incluyen, entre otros,
tablas, rboles, selectores de colores y selectores de archivos. La Tabla C-8
describe estos componentes y muestra su interfaz de usuario.
Tabla C-8 Componentes de presentacin con formato
Componente
Interfaz de usuario
Las tablas se utilizan para mostrar

y modificar informacin en forma
de cuadrcula. Para crear
tablas se utiliza la
clasejavax.swing.JTable.
JTable no almacena los datos, slo
los muestra en un modelo de tabla.
JTree permite mostrar informacin
de forma jerarquizada. Los datos
para construir la presentacin
proceden de una instancia de
TreeModel. Los datos tambin
pueden adoptar forma de coleccin
de elementos, como una tabla hash
(clculo de claves) o un vector.
JTree no almacena realmente los
datos, sino que los presenta en
una instancia de TreeModel.
La clase JFileChooser permite a los
usuarios navegar por el sistema de
archivos y seleccionar un archivo.
El selector de archivos contiene
mtodos de filtrado que pueden
utilizarse para filtrar los tipos de
archivos que se van a mostrar y
mtodos que permiten personalizar
la vista presentada por el selector.
Componentes Swing
C-13

Tabla C-8 Componentes de presentacin con formato (Continuacin)
Componente
Interfaz de usuario
JColorChooser permite al usuario

manipular y seleccionar un color.
Hay tres formas de seleccionar un
color: muestras, tono, saturacin y
brillo (HSB) o verde, rojo y azul
(RGB). La clase JColorChooser
contiene varios constructores que
permiten crear el panel selector
de colores. El constructor
predeterminado crea un panel cuyo
color inicial es el blanco. Otro
constructor toma el color inicial
como parmetro. Una solucin
alternativa consiste en especificar
el modelo de seleccin de color
en el constructor.
C-14


Esta seccin describe otros componentes Swing que suelen utilizarse en
una interfaz grfica, como cuadros combinados, listas, deslizadores y
controles numricos. Un control JComboBox permite al usuario elegir
entre varias opciones. La clase JComboBox dispone de un prctico
constructor que admite un array de objetos como opciones iniciales.
Despus es posible aadir y eliminar opciones con los mtodos addItem
y removeItem, respectivamente. Una lista JList presenta elementos en
una o varias columnas. Es posible elegir uno o varios elementos de la
pantalla haciendo clic o navegando con los comandos del teclado.
Con JSlider, el usuario hace clic con el ratn y arrastra el deslizador
para introducir un valor numrico. Si el espacio en pantalla es limitado,
un control numrico puede ser una alternativa al deslizador.
La Tabla C-9 describe estos componentes y muestra su interfaz de usuario.
Tabla C-9 Otros controles bsicos
Componente
Interfaz de usuario
JComboBox adopta dos formas:

modificable y no modificable. La
forma predeterminada es no
modificable y muestra un botn y
una lista desplegable de valores. La
forma modificable presenta un
campo de edicin de texto con un
botn de seleccin. Es posible
introducir un valor en el campo de
texto o utilizar el botn para acceder
a una lista desplegable de opciones.
Componentes Swing
C-15

Tabla C-9 Otros controles bsicos (Continuacin)
Componente
Interfaz de usuario
Las listas pueden contener barras de

desplazamiento si el nmero de
opciones es demasiado largo para
el rea de pantalla asignada. Las
listas tambin pueden ser
redimensionables. La clase JList es
fcil de utilizar en circunstancias
sencillas y, si es necesario, es capaz de
crear su propio modelo ListModel.
Para ello, los datos se introducen en
un vector (Vector) o un array de
objetos (Objects) y se llama al
constructor JList utilizando los
datos como argumento.
Los controles numricos tambin
permiten introducir un valor.
JSpinner tiene tres
subcomponentes: una flecha arriba,
una flecha abajo y un editor. El
editor puede ser cualquier clase
JComponent, pero de forma
predeterminada se implementa
como panel con un campo de
texto con formato.
Los valores del deslizador cubren
un intervalo finito, es decir, tienen
un valor mximo y otro mnimo.
Si la posibilidad de especificar
nmeros precisos es importante,
el deslizador puede ir acompaado
de un campo de texto con formato.
C-16


Manu Java PDF

Enviado por

Dados do documento

Descrição original:

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Manu Java PDF

Enviado por

Direitos autorais:

Formatos disponíveis

Java Programming Language,

This page intentionally left blank.

This page intentionally left blank.

Programacin orientada a objetos................................................. 2-1

Lenguaje de programacin Java

Construccin e inicializacin de objetos....................................... 3-15

Diseo de clases.............................................................................. 6-1

Lenguaje de programacin Java

Importaciones estticas ................................................................... 7-18

Genricos: refactorizacin de cdigo no genrico existente ...... 9-25

Lenguaje de programacin Java

E/S de consola.................................................................................. 11-3

Control de eventos mediante clases internas.................... 13-15

Lenguaje de programacin Java

Clase SyncStack.................................................................. 15-28

Lenguaje de programacin Java

Acerca de este curso

Crear aplicaciones que aprovechen funciones de programacin

Ejecutar una aplicacin Java desde la lnea de comandos.

Usar tipos de datos y expresiones de Java.

Usar construcciones de control de flujo de Java.

Usar arrays y otros grupos de datos.

Implementar tcnicas de gestin de errores utilizando el manejo de

Crear interfaces grficas controladas por eventos utilizando los

Implementar la funcionalidad de E/S para leer y escribir datos y

Crear programas multihilo.

Crear un cliente TCP/IP sencillo que se comunique mediante

Finalidad del curso

Lenguaje de programacin Java

Descripcin del curso

Descripcin del curso

Acerca de este curso

Esquema del curso

Esquema del curso

Conceptos bsicos sobre programacin Java

y control del flujo

Conceptos avanzados de programacin OO

Excepciones, colecciones y E/S

Desarrollo de interfaces grficas de usuario

Programacin Java avanzada

Lenguaje de programacin Java

Contenido de los mdulos

Contenido de los mdulos

Mdulo 2: Programacin orientada a objetos

Mdulo 3: Identificadores, palabras clave y tipos

Mdulo 4: Expresiones y control del flujo

Mdulo 6: Diseo de clases

Mdulo 7: Conceptos avanzados sobre las clases

Mdulo 8: Excepciones y aserciones

Acerca de este curso

Contenido de los mdulos

Mdulo 9: API Collections y Generics

Mdulo 10: Principios bsicos de E/S

Mdulo 11: E/S de consola y E/S de archivos

Mdulo 12: Creacin de interfaces grficas con el API Swing

Mdulo 13: Control de eventos generados por la interfaz grfica

Mdulo 14: Aplicaciones basadas en la interfaz grfica

Mdulo 15: Hilos

Mdulo 16: Conexin en red

Lenguaje de programacin Java

Objetivos del curso

Objetivos del curso