D64147

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 J ava 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.
v
Copyright 2008 Sun Microsystems, Inc. Todos los derechos reservados. Sun Services, Revisin G.2
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
vi Lenguaje de programacin Java
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
vii
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
viii Lenguaje de programacin Java
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
ix
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
x Lenguaje de programacin Java
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
xi
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
xii Lenguaje de programacin Java
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
xiii
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
xiv Lenguaje de programacin Java
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
Prlogo-xv
Prlogo
Acercadeestecurso
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 polimorsmo.
Ejecutar una aplicacin Java desde la lnea de comandos.
Usar tipos de datos y expresiones de Java.
Usar construcciones de control de ujo de Java.
Usar arrays y otros grupos de datos.
Implementar tcnicas de gestin de errores utilizando el manejo de
excepciones.
Crear interfaces grcas controladas por eventos utilizando los
componentes de interfaz grca 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.
Finalidad del curso
Prlogo-xvi Lenguaje de programacin Java
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 grcas, el procesamiento multihilo y la
comunicacin en red. El contenido de este curso es un requisito
indispensable para preparar el examen de Programador Certicado 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.
Descripcin del curso
Acerca de este curso Prlogo-xvii
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 grca 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 grcos del manual reejarn la interfaz grca
de Motif y Windows. El contenido del curso es aplicable a todas las
variantes de sistemas operativos Java.
Esquema del curso
Prlogo-xviii Lenguaje de programacin Java
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
Conceptos avanzados de programacin OO
Excepciones, colecciones y E/S
Desarrollo de interfaces grcas de usuario
Programacin Java avanzada
Introduccin
Programacin
orientada a objetos
Identicadores,
palabras clave y
tipos
Arrays
Diseo de clases
Conceptos
avanzados sobre
Colecciones y
E/S de consola Control de eventos
de la GUI
Aplicaciones
basadas en la GUI
E/S:
Hilos Funciones de red
Expresiones
y control del ujo
Excepciones
y aserciones
tipos genricos aspectos
y
de archivos
las clases
fundamentales
Contenido de los mdulos
Acerca de este curso Prlogo-xix
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: Identicadores, 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 ujo
En esta parte del curso se describen las expresiones (incluidos los
operadores) y la sintaxis de control del ujo 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 nales, 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
predenidas y las denidas por el usuario.
Prlogo-xx Lenguaje de programacin Java
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 grcas con el API Swing
Todas las interfaces grcas 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 grca
Crear un diseo de componentes de la interfaz grca 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 grca.
Mdulo 14: Aplicaciones basadas en la interfaz grca
En este mdulo se explican diversos elementos de la interfaz grca.
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.
Objetivos del curso
Acerca de este curso Prlogo-xxi
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 grca.
Describir las herramientas AWT (Abstract Window Toolkit) de Java.
Desarrollar un programa para aceptar la introduccin de datos desde
una interfaz grca.
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.
Temas no incluidos
Prlogo-xxii Lenguaje de programacin Java
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.
Est preparado?
Acerca de este curso Prlogo-xxiii
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 modicar archivos de texto con un editor de textos.
Utilizar un navegador web como Netscape.
Presentaciones
Prlogo-xxiv Lenguaje de programacin Java
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:
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
Acerca de este curso Prlogo-xxv
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 nal del curso debera ser capaz de alcanzar las metas
jadas 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 grca conceptos como el de un
determinado proceso. La ayuda visual suele constar de grcos,
imgenes animadas y vdeo.
Convenciones tipogrficas y smbolos
Prlogo-xxvi Lenguaje de programacin Java
Convenciones tipogrcas 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.
Acerca de este curso Prlogo-xxvii
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-xxviii Lenguaje de programacin Java
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 reere 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
1-1
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
.
Denir 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 signican mquina virtual
para la plataforma Java.
Aspectos relevantes
1-2 Lenguaje de programacin Java
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?
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
Otros recursos
Introduccin 1-3
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 Specication,
Second Edition. Addison-Wesley. 2000. [Tambin en la web:
http://java.sun.com/docs/books/jls/].
Lindholm and Yellin. The Java Virtual Machine Specication, 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.
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 grca (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.
Objetivos fundamentales de la tecnologa Java
Introduccin 1-5
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 abilidad del cdigo.
Es orientado a objetos para ayudar a visualizar el programa de
una forma ms cercana a la realidad.
Permite simplicar el cdigo.
Un lenguaje interpretado (genera cdigo directamente en bytes),
lo que proporciona las siguientes ventajas:
Rapidez de desarrollo: reduce el ciclo compilacin-enlace-carga-
prueba.
Portabilidad del cdigo: permite escribir cdigo que puede
ejecutarse en numerosos sistemas operativos sobre cualquier
JVM certicada.
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
Mquina virtual de Java
El documento The Java Virtual Machine Specication dene 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 especicacin de la JVM incluye las especicaciones de las plataformas
de hardware para las que se compila todo el cdigo de Java. Esta
especicacin 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 especicacin de JVM proporciona deniciones 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 ecientes. 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
especicados en el documento The Java Virtual Machine Specication
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.
Introduccin 1-7
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.
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.
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.
Compilacin
TestGreeting.java
TestGreeting.class
Carga
Cargador
de clases
Verificador
del cdigo
Intrprete
Tiempo de ejecucin
Hardware
Tiempo de
javac
java
desde el
disco
duro, la
red, u otra
fuente
ejecucin
de byte
Introduccin 1-9
En algunos entornos de ejecucin de Java, una parte del cdigo de byte
vericado 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).
Figura 1-2 Funcionamiento del JRE con un compilador JIT (Just-In-
Time)
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.
Compilacin
TestGreeting.java
TestGreeting.class
Cargador
de clases
Verificador del
cdigo de byte
Intrprete
Tiempo de ejecucin
Hardware
Tiempo de
javac
java
de cdigo
JIT
Generador
Carga
desde el
disco
duro, la
red, u otra
fuente
ejecucin
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.
Vericar el cdigo: a travs del vericador 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.
Introduccin 1-11
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
vericador 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
vericador de cdigos.
Proceso de vericacin
El vericador de cdigos efecta cuatro pasadas sobre el cdigo de
un programa. De esta forma se garantiza el cumplimiento de las
especicaciones de la JVM y la integridad del sistema. Si despus de las
cuatro pasadas el vericador no encuentra ningn error, signica que:
Las clases son conformes con el formato de archivos de clases de la
especicacin 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.
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 AplicacinTestGreeting.java
1 //
2 // Ejemplo de aplicacin de "Saludo"
3 //
4 public class TestGreeting {
5 public static void main (String[] args) {
6 Greeting hello = new Greeting();
7 hello.greet();
8 }
9 }
Cdigo 1-2 Clase Greeting.java
1 public class Greeting {
2 public void greet() {
3 System.out.println("hola");
4 }
5 }
Introduccin 1-13
Aplicacin TestGreeting
Cdigo 1-3 Lneas 1-3
1 //
2 // Ejemplo de aplicacin de "Saludo"
3 //
Las lneas 13 del programa son comentarios.
Cdigo 1-4 Lnea 4
4 public class TestGreeting {
La lnea 4 declara la clase llamada TestGreeting. Cuando se especica
un nombre de clase en un archivo de cdigo fuente, al compilar dicho
archivo se crea un archivo nombreclase.class. Si no se especica
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 Lnea 5
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.
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 args[0] args[1] . . .
Cdigo 1-6 Lnea 6
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 Lnea 7
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 Lneas 89
8 }
9 }
Las lneas 8 y 9 del programa, las dos llaves, cierran el mtodo main() y
la clase TestGreeting respectivamente.
Introduccin 1-15
Clase Greeting
Cdigo 1-9 Lnea 1
1 public class Greeting {
La lnea 1 declara la clase Greeting.
Cdigo 1-10 Lneas 24
2 public void greet() {
3 System.out.println(hola);
4 }
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.
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 denir 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).
Introduccin 1-17
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 congurado 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 denicin 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.
Errores producidos durante la ejecucin
Algunos de los errores generados al escribir java TestGreeting son:
Can't find class TestGreeting
Normalmente esto signica que el nombre especicado para la
clase en la lnea de comandos diere 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 signica 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.
Introduccin 1-19
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.
Figura 1-3 Entorno de ejecucin de Java
C
o
m
p
i
l
a
c
i
n
TestGreeting.java
TestGreeting.class
T
i
e
m
p
o

d
e

e
j
e
c
u
c
i
n
Greeting.class
Greeting.java
JVM
UNIX
DOS JavaOS
JVM JVM
javac
java
Tambin compila
Tambin carga
Puede ejecutarse en varias plataformas
2-1
Mdulo 2
Programacinorientadaaobjetos
Objetivos
para:
Denir los conceptos de modelado: abstraccin, encapsulacin y
paquete.
Explicar por qu es posible reutilizar el cdigo de las aplicaciones
Java.
Denir los conceptos de clase, miembro, atributo, mtodo, constructor y
paquete.
Utilizar los modicadores 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.
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?
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
Dena la expresin programacin orientada a objetos.
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
Ingeniera de software
Programacin orientada a objetos 2-3
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.
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 ujos 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 grco (X-Windows y Open Look).
Cdigo mquina (finales de los 40)
Lenguajes de alto nivel (aos 50) Sistemas operativos (aos 60)
Bibliotecas / API funcionales (aos 60principios de los 80)
Lenguajes de programacin OO (aos 80)
Kits de desarrollo / Infraestructuras / API de objetos (aos 90)
Fortran LISP C UNIX Microsoft Windows MacOS
NASTRAN X-Windows
COBOL
TCP/IP ISAM OpenLook
SELF Smalltalk Common Lisp Object System Eiffel
AWT / J.F.C./Swing Jini JavaBeans JDBC Java 2 SDK
C++ Java
OS/360
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 diculta la tarea de modicar la
implementacin de la biblioteca sin tocar el cdigo cliente porque ese
cdigo normalmente est ligado a los aspectos especcos de las
estructuras de datos.
A nales 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 exibilidad
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.
Fase de anlisis y diseo
Un proyecto de desarrollo de software se compone de cinco fases
fundamentales: denicin de los requisitos, anlisis, diseo,
implementacin y pruebas. Todas ellas son importantes, pero es
fundamental dedicar el tiempo suciente para las fases de anlisis y
diseo.
Durante la fase de anlisis se dene qu objetivos debe perseguir el
sistema. Esto se consigue deniendo 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 identican 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 dene 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 (Unied
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.
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 ota 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 uvial.
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 grca 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
etes.
Tomando estos requisitos como base, puede crear un diseo de alto nivel:
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 grca.
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 simplicacin y la abstraccin. La simplicacin 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 dene el conjunto de
elementos (atributos) que denen 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 polimorsmo.
Nota: El primero de ellos se trata en la seccin Encapsulacin en la
pgina 2-15. La herencia y el polimorsmo se explican en el Mdulo 6.
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 identicador admitido. Hay varias palabras clave que pueden
usarse como <modificador>, pero, por ahora, utilice nicamente public.
Este modicador 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 Ejemplo de declaracin de una clase
1 public class Vehiculo {
2 private double cargaMax;
3 public void setCargaMax(double valor) {
4 cargaMax = valor;
5 }
6 }
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 public class Ejemplo {
2 private int x;
3 private float y = 10000.0F;
4 private String name = "Hotel Medioda";
5 }
<nombre> es el nombre del atributo que se va a declarar y puede ser
cualquier identicador 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.
Declaracin de mtodos
Para denir 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 identicador 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 modicador 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 reere 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 identicador.
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 modica el valor de peso con el
parmetro newPeso. No devuelve ningn valor. Este mtodo utiliza
una sentencia condicional para impedir que el cdigo cliente dena el
peso de Perro con un nmero negativo o con cero.
Cdigo 2-2 Ejemplo de mtodos
1 public class Perro {
2 private int peso;
3 public int getPeso() {
4 return peso;
5 }
6 public void setPeso(int newPeso) {
7 if ( newPeso > 0 ) {
8 peso = newPeso;
9 }
10 }
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 denicin 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 dene el valor de la variable peso. No obstante, no se
admite el valor -42 como peso (lnea 9), as que el mtodo setPeso no
modica la variable peso.
Cdigo 2-3 Ejemplo de llamadas a mtodos
1 public class PruebaPerro {
2 public static void main(String[] args) {
3 Perro d = new Perro();
4 System.out.println("El peso del perro d es "
5 + d.getPeso());
6 d.setPeso(42);
8 + d.getPeso());
9 d.setPeso(-42);
11 + d.getPeso());
12 }
13 }
La salida es:
El peso del perro d es 0
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.
Figura 2-2 Diagrama UML de la clase MyDate
Una implementacin sencilla permite el acceso directo a estos atributos,
por ejemplo:
public class MyDate {
public int day;
public int month;
public int year;
}
Por tanto, el cdigo cliente accede directamente a estos atributos y genera
errores, por ejemplo (d se reere 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)
MyDate
+day : int
+month : int
+year : int
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.
Figura 2-3 Forma de ocultar las variables de instancia de la clase
MyDate
Estos mtodos permiten a la clase modicar los datos internos, pero, sobre
todo, vericar 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)
+setDay(int) : boolean
+setYear(int) : boolean
+setMonth(int) : boolean
+getDay()
+getMonth()
+getYear()
MyDate
-day : int
-month : int
-year : int
Verifica los das del mes.
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
signicativo 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.
Figura 2-4 La encapsulacin aporta mayor exibilidad para representar
los datos
+setDay(int) : boolean
+setYear(int) : boolean
+setMonth(int) : boolean
+getDay() : int
+getMonth() : int
+getYear() : int
MyDate
-date : long
-isDayValid(int) : boolean
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 modicadores 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 public class Perro {
2 private int peso;
3
4 public Perro() {
5 peso = 42;
6 }
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.
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.
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 denicin 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 package transporte.informes;
2
3 import transporte.dominio.*;
4 import java.util.List;
5 import java.io.*;
6
7 public class InformeCapacidadVehiculo {
8 private List vehiculos;
9 public void generarInforme(Writer output) {
10 // cdigo para generar el informe
11 }
12 }
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:
Figura 2-5 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 grca 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.
Vehculo
Barcaza Camin
Empresa
posee 0..*
transporte
dominio
GUI
informes
Sentencia package
Sentencia package
El lenguaje Java proporciona la sentencia package como una forma de
agrupar clases relacionadas. Esta sentencia se utiliza con la siguiente
sintaxis:
package <nombre_paq_superior>[.<nombre_paq_subordinado>]*;
Es posible indicar que las clases de un archivo fuente pertenecen a un
determinado paquete utilizando la sentencia package, por ejemplo:
1 package transporte.dominio;
2
3 // Clase Vehiculo del subpaquete dominio que hay
dentro del
4 // paquete transporte.
5 public class Vehiculo {
6 ...
7 }
La declaracin de paquetes, si existe, debe situarse al comienzo del
archivo fuente. Puede ir precedida de un espacio en blanco y comentarios,
pero nada ms. Slo se permite una declaracin de paquetes, que ser la
que gobierne todo el archivo fuente. Si un archivo fuente Java no contiene
ninguna declaracin de paquete, las clases declaradas en el archivo
pertenecern al paquete predeterminado (sin nombre).
Los nombres de paquetes forman una jerarqua y se separan mediante
puntos. Lo normal es que los elementos de estos nombres se escriban
enteramente en minsculas. Sin embargo, el nombre de las clases suele
empezar por una letra mayscula y se escribe en mayscula la primera
letra de cada palabra que se agrega a n de diferenciar las distintas
palabras dentro del nombre de clase. stas y otras convenciones sobre
la nomenclatura se explican en Convenciones de codicacin 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).
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 package transporte.informes;
2
3 import transporte.dominio.*;
5 import java.io.*;
6
7 public class InformeCapacidadVehiculo {
8 private Empresa empresaParaInforme;
9 ...
10 }
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;
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.
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.
Figura 2-6 Estructura de directorios de los paquetes de clases
transporte/
dominio/
GUI/
informes/
Vehiculo.class
Barcaza.class
Camion.class
InformeCapacidadVehiculo.class
Empresa.class
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).
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).
ProyectosJava/
TransporteProy/
src/
docs/
transporte/
dominio/
GUI/
informes/
classes/
transporte/
dominio/
GUI/
informes/
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
modicar 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 conictos de nombres con otras clases del ncleo
del JDK u otras clases que se hayan instalado de esa misma forma.
Resumen de la terminologa
Resumen de la terminologa
A continuacin se denen algunos de los trminos presentados en este
mdulo:
Clase: forma de denir 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
Los documentos de las clases contienen las secciones siguientes:
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
3-1
Mdulo 3
Identicadores, palabrasclaveytipos
Objetivos
para:
Utilizar comentarios en el cdigo fuente.
Diferenciar entre identicadores vlidos y no vlidos.
Reconocer las palabras clave utilizadas en Java.
Enumerar los ocho tipos primitivos existentes.
Denir valores literales para tipos numricos y textuales.
Denir 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.
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?
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
Comentarios
Identicadores, palabras clave y tipos 3-3
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/
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 ujo. 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;
}
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;
}
Identificadores
Identicadores
En el lenguaje Java, un identicador es un nombre asignado a una variable,
una clase o un mtodo. Los identicadores 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 identicadores 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 identicadores 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 identicador no puede ser una palabra clave, pero puede contener una
palabra clave como parte de su nombre. Por ejemplo thisOne es un
identicador vlido, pero this no lo es porque this es una palabra clave
reservada para el lenguaje Java.
Nota: Los identicadores 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
identicador.
Palabras clave en programacin Java
Palabras clave en programacin Java
Las palabras clave son palabras reservadas que tienen un signicado
especial para el compilador de Java. Sirven para identicar 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.
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 Specication (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.
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
Tipos bsicos del lenguaje Java
El lenguaje Java incorpora numerosos tipos de datos. stos se clasican
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 dene ocho tipos de datos primitivos que se enmarcan en
cuatro categoras:
Lgicos: boolean
Textuales: char
Enteros: byte, short, int y long
Reales en coma otante: 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.
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:
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;
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 [].
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:
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.
En la Tabla 3-2 guran el tamao y el intervalo de valores
correspondientes a los cuatro tipos de enteros. La representacin del
intervalo de valores se dene en la especicacin del lenguaje Java
como un complemento a 2 y es independiente de la plataforma.
2 ste es el formato decimal del entero 2.
077 El 0 inicial indica un valor octal.
0xBAAC El prejo 0x indica que es un valor hexadecimal.
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 prejo 0x indica que es un valor hexadecimal.
Tabla 3-2 Tipos de datos enteros: tamao y rango de valores
Longitud del entero Nombre o tipo Rango
8 bits byte De -2
7
a 2
7
-1
16 bits short De -2
15
a 2
15
-1
32 bits int De -2
31
a 2
31
-1
64 bits long De -2
63
a 2
63
-1
Reales en coma flotante: double y float
Las variables de tipos reales en coma otante se declaran con las palabras
clave float o double. La lista siguiente contiene ejemplos de nmeros
en coma otante. Un literal numrico es un nmero real en coma otante
si incluye un separador decimal y un exponente (la letra E o e), o
bien si va seguido de la letra F o f (oat) o de la letra D o d (double).
stos son algunos ejemplos de literales en coma otante:
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 otante 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 otante est denido en el documento
The Java Language Specication 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.
Nota: Los literales en coma otante se consideran double a menos que se
declaren expresamente como float.
3.14 Valor en coma otante sencillo (double) en
notacin estndar
6.02E23 Valor en coma otante largo
2.718F Valor corto de precisin simple (float)
123.4E+306D Valor largo double con D redundante
Tabla 3-3 Tamao de los tipos de datos en coma otante
Longitud Nombre o tipo
32 bits float
64 bits double
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 public class Assign {
2 public static void main (String args []) {
3 // declara variables con tipos enteros
4 int x, y;
5 // declara y asigna un valor en coma flotante
6 float z = 3.414f;
7 // declara y asigna un valor de tipo double
8 double w = 3.1415;
9 // declara y asigna un valor boolean
10 boolean truth = true;
11 // declara una variable de tipo char
12 char c;
13 // declara una variable de tipo String
14 String str;
15 // declara y asigna un valor a una variable String
16 String str1 = "hasta la vista";
17 // asigna un valor a la variable char
18 c = 'A';
19 // asigna un valor a la variable String
20 str = "Hola!";
21 // asigna valores a las variables int
22 x = 6;
23 y = 1000;
24 }
25 }
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;
// No se puede especificar un valor de tamao double en una
variable declarada como float. Requiere conversin de
tipos.
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 denir una clase MyDate:
1 public class MyDate {
2 private int day = 1;
3 private int month = 1;
4 private int year = 2000;
5 public MyDate(int day, int month, int year) { ... }
6 public String toString() { ... }
7 }
En el cdigo siguiente se muestra un ejemplo de uso de MyDate:
1 public class TestMyDate {
3 MyDate today = new MyDate(22, 7, 1964);
4 }
5 }
La variable today contiene una referencia al objeto MyDate.
Construccin e inicializacin de objetos
Ya hemos visto cmo ejecutar una llamada a new Xyz() a n 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.
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);
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.
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:
Figura 3-3 Inicializacin explcita
my_birth
????
my_birth
????
day
month
year
0
0
0
my_birth
????
day
month
year
1
1
2000
Ejecucin del constructor
La parte nal 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:
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.
Figura 3-5 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.
my_birth
????
day
month
year
22
7
1964
my_birth
0x01abcdef
day
month
year
22
7
1964
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 signicado 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 reeren
al mismo objeto, como se observa en la Figura 3-6.
Figura 3-6 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
Figura 3-7 La variable t hace referencia a un objeto nuevo
x
7
y
7
s
0x01234567
t
0x01234567
22 7 1964
x
7
y
7
s
0x01234567
t
0x12345678
22 7 1964
22 12 1964
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 public class PassTest {
2
3 // Mtodos para cambiar los valores actuales
4 public static void changeInt(int value) {
5 value = 55;
6 }
7 public static void changeObjectRef(MyDate ref) {
8 ref = new MyDate(1, 1, 2000);
9 }
10 public static void changeObjectAttr(MyDate ref) {
11 ref.setDay(4);
12 }
13
14 public static void main(String args[]) {
15 MyDate date;
16 int val;
17
18 // Asigna el entero
19 val = 11;
20 // Intenta cambiarlo
Paso por valor
21 changeInt(val);
22 // Cul es el valor actual?
23 System.out.println("El valor entero es: " + val);
24
25 // Asigna la fecha
26 date = new MyDate(22, 7, 1964);
27 // Intenta cambiarla
28 changeObjectRef(date);
30 System.out.println("Mi fecha: " + date);
31
32 // Ahora se cambia el atributo de da
33 // mediante la referencia al objeto
34 changeObjectAttr(date);
36 System.out.println("Mi fecha: " + date);
37 }
38 }
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.
Referencia this
Referencia this
La palabra clave this se utiliza con dos nes:
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
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 }
Convenciones de codificacin en el lenguaje Java
Convenciones de codicacin 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 signicado
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).
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 codicacin 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
denicin 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
codicacin del lenguaje Java de Sun, consulte la pgina web siguiente:
http://java.sun.com/docs/codeconv/html/CodeConvTOC.doc.html
4-1
Mdulo 4
Expresionesycontrol del ujo
Objetivos
para:
Diferenciar las variables de instancia de las variables locales.
Describir la forma de inicializar las variables de instancia.
Identicar 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.
Identicar 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
ujo 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.
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 armativo, 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 ujo
(por ejemplo en los bucles o las tomas de decisiones)?
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
Variables
Expresiones y control del ujo 4-3
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 denicin de clase.
Las variables que se denen 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 denen 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 denen 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.
Variables
Las variables locales se crean cuando el programa empieza a ejecutar
el mtodo y se destruyen cuando naliza dicha ejecucin. sta es la
razn por la que las variables locales a veces se denominan temporales
o automticas. Las variables que se denen 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 public class EjemploAmbito {
2 private int i=1;
3
4 public void primerMetodo() {
5 int i=4, j=5;
6 this.i = i + j;
7 segundoMetodo(7);
8 }
9 public void segundoMetodo(int i) {
10 int j=8;
11 this.i = i + j;
12 }
13 }
1 public class PruebaAmbito {
3 EjemploAmbito ambito = new EjemploAmbito();
4 ambito.primerMetodo();
5 }
6 }
Nota: Este cdigo sirve nicamente para ilustrar las reglas de denicin de
mbitos. No es recomendable reutilizar los nombres de esta manera.
Variables
En la Figura 4-1 puede verse de forma grca el mbito establecido para
las variables en el Cdigo 4-1.
Figura 4-1 Diagrama de mbito de las variables del Cdigo 4-1
main
primerMetodo
i
j
segundoMetodo
i
j
this
this
mbito
Espacio de memoria dinmica
EjemploAmbito
i 1
4
5
7
8
Pila de ejecucin
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 denidas 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 guran
los valores predeterminados de las variables de instancia con tipos
primitivos y de referencia.
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.
Tabla 4-1 Valores predeterminados de los tipos primitivos
Variable Valor
byte 0
short 0
int 0
long 0L
float 0.0F
double 0.0D
char '\u0000'
boolean false
Todos los tipos de referencia null
Variables
Principio de inicializacin antes de uso
Aunque las variables denidas 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
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 signica asociativos de izquierda a derecha; D-I
signica asociativos de derecha a izquierda).
Nota: El operador instanceof es exclusivo del lenguaje Java y se
describe en el Mdulo 6.
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 = *= /= %= += -= <<= >>= >>>=
&= ^= |=
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 && (denido como AND) y || (denido 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.
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 grcos, cientcos o de control. La
posibilidad de operar directamente sobre los binarios puede contribuir a
ahorrar memoria, mejorar sustancialmente la eciencia en ciertos clculos
y simplicar 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.
Figura 4-2 Ejemplos de operadores de bits
0 0 0 1 1 1 1 1
1 1 1 0 0 0 0 0
~
0 0 0 0 1 1 1 1
0 0 0 1 1 1 1 1
0 0 0 0 0 1 1 1
&
0 0 0 0 1 1 1 1
0 0 0 1 1 1 1 1 |
0 0 1 1 1 1 1 1
0 0 0 0 1 1 1 1
0 0 0 1 1 1 1 1
0 0 0 0 0 1 1 1
^
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 especicado por
el segundo operando. Por ejemplo:
128 >> 1 devuelve 128/2
1
= 64
256 >> 4 devuelve 256/2
4
= 16
-256 >> 4 devuelve -256/2
4
= -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 signicado 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
especicado por el segundo operando, por ejemplo:
128 << 1 devuelve 128*2
1
= 256
16 << 2 devuelve 16*2
2
= 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.
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 <<.
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.
0 1 0 0 1 1
1 1
0
0 0
1 1 1
1 1 1 1 1
0 0
0 0 0
0 0 0 0 0 0 0 0 0 0 0 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
0 0 0 0
1357 =
-1357 =
1357 >> 5 =
-1357 >> 5 =
1357 >>> 5 =
-1357 >>> 5 =
1357 << 5 =
-1357 << 5 =
1 1 1 1 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
1 1 0 0 1 1 1 1 1 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
0 0 1 1 1 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 0 1 1 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0
1 1 1 1 1
0 0 1 1 1 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 0
1 1 1 1 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
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 conrme 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; // Incorrecto, necesita
// conversin de tipos
int squashed = (int) 99L; // Correcto, pero...
int squashed = 99; // literal entero
// predeterminado
El tipo de destino deseado se escribe entre parntesis y se utiliza como
prejo de la expresin que deba modicarse. 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.
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; // 6 es un tipo int, correcto
int valormenor = 99L; // 99L es un tipo long, incorrecto
double z = 12.414F; // 12.414F es un tipo float, correcto
float z1 = 12.414; // 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.
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...");
}
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.
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 otante,
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.
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 congura 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 ujo de control descienda por los diferentes bloques
case. Por ejemplo, si el modeloAutomovil es DELUXE, entonces se llama
al mtodo agregarAireAcondicionado. A continuacin, el ujo 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.
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 verican la condicin del
bucle antes de ejecutar el cuerpo de la construccin. Los bucles do
verican la condicin del bucle despus de ejecutar el cuerpo de la
construccin. Esto signica 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 dene 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.
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 innitos.
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.
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 nal
del cuerpo del bucle y luego devolver el control a la sentencia de
control del bucle.
<etiqueta> : <sentencia>
La etiqueta identica cualquier sentencia vlida a la que deba
transferirse el control. En el caso de una sentencia break etiquetada,
la etiqueta puede identicar cualquier sentencia. Si se trata de una
sentencia continue etiquetada, la etiqueta debe identicar una
construccin de bucle.
Sentencia break
He aqu un ejemplo de bucle con una sentencia break sin etiquetar:
1 do {
2 sentencia;
3 if ( condicin ) {
4 break;
5 }
6 sentencia;
7 } while ( expr_prueba );
Sentencia continue
ste es un ejemplo de bucle con una sentencia continue sin etiquetar:
1 do {
2 sentencia;
3 if ( condicin ) {
4 continue;
5 }
6 sentencia;
Sentencias de bucle
Uso de sentencias breakcon etiquetas
ste es un ejemplo de bucle con una sentencia break etiquetada:
1 outer:
2 do {
3 sentencia1;
4 do {
5 sentencia2;
6 if ( condicin ) {
7 break outer;
8 }
9 sentencia3;
11 sentencia4;
Uso de sentencias continuecon etiquetas
He aqu un ejemplo de bucle con una sentencia continue etiquetada:
1 test:
2 do {
3 sentencia1;
4 do {
5 sentencia2;
6 if ( condicin ) {
7 continue test;
8 }
9 sentencia3;
11 sentencia4;
5-1
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 denir, inicializar y usar arrays en el
lenguaje Java.
Aspectos relevantes
Aspectos relevantes
?
!
Discusin: Las pregunta siguiente es importante en relacin con el
Cul es el propsito de los arrays?
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
Declaracin de arrays
Arrays 5-3
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.
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 public char[] crearArray() {
2 char[] s;
3
4 s = new char[26];
5 for ( int i=0; i<26; i++ ) {
6 s[i] = (char) (A + i);
7 }
8
9 return s;
10 }
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.
Figura 5-1 Creacin de un array con tipos primitivos de caracteres
main
crearArray s
this
char[]
A
Pila de ejecucin
B
C
D
Z
Creacin de arrays
Arrays 5-5
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 public Point[] crearArray() {
2 Point[] p;
3
4 p = new Point[10];
5 for ( int i=0; i<10; i++ ) {
6 p[i] = new Point(i, i+1);
7 }
8
9 return p;
10 }
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.
Figura 5-2 Creacin de un array de tipos primitivos de caracteres con
objetos Point
main
crearArray p
this
Point[]
Pila de ejecucin
Point
x
y
0
1
Point
x
y
1
2
Point
x
y
2
3
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)
};
Arrays multidimensionales
Arrays 5-7
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];
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 exibilidad 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:
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];
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.
Redimensionamiento de arrays
Arrays 5-9
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.
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 // array original
2 int[] miArray = { 1, 2, 3, 4, 5, 6 };
3
4 // nuevo array ms largo
5 int[] copia = { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 };
6
7 // copia todos los elementos de miArray en el array
8 // copia, empezando por el ndice 0
9 System.arraycopy(miArray, 0, copia, 0,
10 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.
6-1
Mdulo 6
Diseodeclases
Objetivos
para:
Denir los conceptos de herencia, polimorsmo, sobrecarga, sobrescritura
y llamada a mtodos virtuales.
Usar los modicadores 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.
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?
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
Subclases
Diseo de clases 6-3
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.
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() {...}
}
Empleado
+nombre : String = ""
+salario : double
+fechaNacimiento : Date
+getDetails() : String
Gerente
+salario : double
+departamento : String
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 denir una clase sobre la base de una clase
denida con anterioridad. En la Figura 6-2 puede verse un diagrama UML
donde la clase Gerente es una subclase de Empleado.
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 denicin 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;
}
Gerente
+departamento : String
Empleado
+salario : double
Subclases
Diseo de clases 6-5
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.
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).
Gerente
+departamento : String = ""
Empleado
+salario : double
Director
+vehiculoEmpresa : double
Ingeniero Secretario
+aumentarComision()
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.
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 modicador de acceso expresamente
denido como parte de su declaracin. Este tipo de acceso signica
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 modicador 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 modicador 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 modicador protected.
Tabla 6-1 Criterios de acceso
Modicador
La misma
clase
El mismo
paquete
Subclase Universal
private S
predeterminado S S
protected S S S
public S S S S
Sobrescritura de mtodos
Diseo de clases 6-7
Adems de poder agregar atributos para generar clases nuevas a partir de
una clase existente, es posible modicar el comportamiento de la clase
original.
Si se dene 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 denicin, porque
lo hereda de la clase Empleado. Pero el mtodo original ha sido sustituido,
sobrescrito, por la versin de la clase subordinada.
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.
Diseo de clases 6-9
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 reere 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 denido 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.
Polimorfismo
Polimorsmo
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 signica 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 polimrca 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 especcas 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.
Polimorfismo
Diseo de clases 6-11
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 polimorsmo 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 = new Empleado[1024];
personal[0] = new Gerente();
personal[1] = new Empleado();
personal[2] = new Ingeniero();
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
scales de ese empleado. Si se utilizan las caractersticas polimrcas,
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 denidos en la clase Empleado.
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).
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:
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
suciente 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
suciente si sta es la nica diferencia. Las listas de argumentos
de los mtodos sobrecargados deben ser distintas.
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 denir 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).
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 Ejemplo de sobrecarga de constructores
1 public class Empleado {
2 private static final double SALARIO_BASE = 15000.00;
3 private String nombre;
4 private double salario;
5 private Date fechaNacimiento;
6
7 public Empleado(String nombre, double salario, Date FdeNac) {
8 this.nombre = nombre;
9 this.salario = salario;
10 this.fechaNacimiento = FdeNac;
11 }
12 public Empleado(String nombre, double salario) {
13 this(nombre, salario, null);
14 }
15 public Empleado(String nombre, Date FdeNac) {
16 this(nombre, SALARIO_BASE, FdeNac);
17 }
18 public Empleado(String nombre) {
19 this(nombre, SALARIO_BASE);
20 }
21 // ms cdigo de Empleado...
22 }
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.
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 dene 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
denidos en el Cdigo 6-4 de la pgina 6-17, entonces se deniran 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.
1 public class Gerente extends Empleado {
2 private String departamento;
3
4 public Gerente(String nombre, double salario, String depto) {
5 super(nombre, salario);
6 departamento = depto;
7 }
8 public Gerente(String nombre, String depto) {
9 super(nombre);
11 }
12 public Gerente(String depto) { // Este cdigo da error: no hay super()
14 }
15 }
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 nal 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.
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,
Identicadores, 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:
1 public class Object {
2 public Object() {}
3 }
1 public class Empleado extends Object {
2 private String nombre;
3 private double salario = 15000.00;
4 private Date fechaNacimiento;
5
6 public Empleado(String n, Date FdeNac) {
7 // super() implcito;
8 nombre = n;
9 fechaNacimiento = FdeNac;
10 }
11 public Empleado(String n) {
Construccin e inicializacin de objetos: ampliacin de conceptos
12 this(n, null);
13 }
14 }
1 public class Gerente extends Empleado {
2 private String departamento;
3
4 public Gerente(String n, String d) {
5 super(n);
6 departamento = d;
7 }
8 }
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"
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 reeren 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
reeren 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.
Clase Object
Ejemplo de cdigo con equals
En este ejemplo, la clase MyDate se ha modicado para incluir un
mtodo equals que compara los atributos de ao, mes y da.
2 private int day;
3 private int month;
4 private int year;
5
6 public MyDate(int day, int month, int year) {
7 this.day = day;
8 this.month = month;
9 this.year = year;
10 }
11
12 public boolean equals(Object o) {
13 boolean result = false;
14 if ( (o != null) && (o instanceof MyDate) ) {
15 MyDate d = (MyDate) o;
16 if ( (day == d.day) && (month == d.month)
17 && (year == d.year) ) {
18 result = true;
19 }
20 }
21 return result;
22 }
23
24 public int hashCode() {
25 return (day ^ month ^ year);
26 }
27 }
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 class TestEquals {
3 MyDate date1 = new MyDate(14, 3, 1976);
4 MyDate date2 = new MyDate(14, 3, 1976);
5
Clase Object
6 if ( date1 == date2 ) {
7 System.out.println("date1 es idntica a date2");
8 } else {
9 System.out.println("date1 no es idntica a date2");
10 }
11
12 if ( date1.equals(date2) ) {
13 System.out.println("date1 es igual que date2");
14 } else {
15 System.out.println("date1 no es igual que date2");
16 }
17
18 System.out.println("set date2 = date1;");
19 date2 = date1;
20
21 if ( date1 == date2 ) {
22 System.out.println("date1 es idntica a date2");
23 } else {
24 System.out.println("date1 no es idntica a date2");
25 }
26 }
27 }
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());
Clase Object
La clase Object dene 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 nes de depuracin.
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 eciencia. A n 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
signica que, una vez inicializado el valor primitivo en su envoltorio,
no hay forma de cambiar ese valor.
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
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
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 dicultar 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.
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.
7-1
Mdulo 7
Conceptosavanzadossobrelasclases
Objetivos
para:
Crear variables, mtodos e inicializadores estticos.
Crear clases, mtodos y variables nales.
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.
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?
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
Palabra clave static
Conceptos avanzados sobre las clases 7-3
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).
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 public class Counter {
2 private int serialNumber;
3 public static int counter = 0;
4
5 public Counter() {
6 counter++;
7 serialNumber = counter;
8 }
9 }
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.
c1 : Count
Count
serialNumber=1
-serialNumber : int
+counter : int = 0
c2 : Count
serialNumber=2
instanceOf instanceOf
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 public class OtraClase {
2 public void incrementNumber() {
3 Count1.counter++;
4 }
5 }
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 public class Count2 {
3 private static int counter = 0;
4
5 public static int getTotalCount() {
6 return counter;
7 }
8
9 public Count2() {
10 counter++;
11 serialNumber = counter;
12 }
Debe acceder a los mtodos estticos utilizando el nombre de la clase en
lugar de una referencia al objeto, de la forma siguiente:
1 public class TestCounter {
3 System.out.println("El nmero del contador es "
4 + Count2.getTotalCount());
5 Count2 count1 = new Count2();
6 System.out.println("El nmero del contador es "
7 + Count2.getTotalCount());
8 }
9 }
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.
4
5 public static int getSerialNumber() {
6 return serialNumber; // ERROR DE COMPILACIN
7 }
8 }
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 rma en una
jerarqua de clases simplemente signica 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.
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.
2 public static int counter;
3 static {
4 counter = Integer.getInteger("myApp.Count4.counter").intValue();
5 }
6 }
1 public class TestStaticInit {
3 System.out.println("counter = "+ Count4.counter);
4 }
5 }
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 dene 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
Palabra clave final
Palabra clave final
En esta seccin se describen las clases, los mtodos y las variables nales.
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 denida a de la clase
String y no una cadena de una posible subclase modicada 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 modicarse y es fundamental para
mantener la coherencia del objeto.
Es posible optimizar los mtodos declarados como nales. 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
denida correctamente:
public class Banco {
private static final
double TASA_INTERES_PREDETERMINADA=3.2;
// ms declaraciones
}
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 nales vacas
Una variable nal 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 denirse una vez. Si la variable nal
vaca es local, puede denirse en cualquier momento en el cuerpo del
mtodo, pero slo puede denirse 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
}
Tipos enumerados
Tipos enumerados
Una prctica habitual en programacin es tener un nmero nito 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.
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 Ejemplo de la antigua versin de tipos enumerados
1 package naipes.domain;
2
3 public class NaipeBaraja {
4
5 // tipo seudoenumerado
6 public static final int PALO_PICAS = 0;
7 public static final int PALO_CORAZONES = 1;
8 public static final int PALO_TREBOLES = 2;
9 public static final int PALO_DIAMANTES = 3;
10
11 private int palo;
12 private int rango;
13
14 public NaipeBaraja(int palo, int rango) {
15 this.palo = palo;
16 this.rango = rango;
17 }
18
19 public int getPalo() {
20 return palo;
21 }
Nota: El atributo rango tambin es un buen candidato para crear un tipo
enumerado, pero este cdigo no usa tipos enumerados para mayor
brevedad.
Tipos enumerados
Por otra parte, la interfaz grca 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 Mtodo getNamePalo
22 public String getNamePalo() {
23 String name = "";
24 switch ( palo ) {
25 case PALO_PICAS:
26 name = "Picas";
27 break;
28 case PALO_CORAZONES:
29 name = "Corazones";
30 break;
31 case PALO_TREBOLES:
32 name = "Treboles";
33 break;
34 case PALO_DIAMANTES:
35 name = "Diamantes";
36 break;
37 default:
38 System.err.println("Palo no vlido.");
39 }
40 return name;
41 }
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 Programa TestNaipeBaraja
1 package naipes.tests;
2
3 import naipes.domain.NaipeBaraja;
4
5 public class TestNaipeBaraja {
7
8 NaipeBaraja naipe1
9 = new NaipeBaraja(NaipeBaraja.PALO_PICAS, 2);
10 System.out.println("el naipe1 es: " + naipe1.getRango()
11 + " de " + naipe1.getNameRango());
12
13 // Puede crear un naipe de un palo inventado.
14 NaipeBaraja naipe2 = new NaipeBaraja(47, 2);
17 }
18 }
19
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.
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 especicar 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 prejo a las
constantes de los tipos enumerados int con una cadena (en este
caso, PALO_) para evitar conictos 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
nito de valores que reciben los nombres simblicos incluidos en la
denicin del tipo. Por ejemplo, Palo.PICAS es del tipo Palo.
Cdigo 7-4 Tipo enumerado Palo
2
3 public enum Palo {
4 PICAS,
5 CORAZONES,
6 TREBOLES,
7 DIAMANTES
8 }
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 Clase NaipeBaraja con el tipo Palo
2
3 public class NaipeBaraja {
4
5 private Palo palo;
6 private int rango;
7
8 public NaipeBaraja(Palo palo, int rango) {
9 this.palo = palo;
10 this.rango = rango;
11 }
12
13 public Palo getPalo() {
14 return palo;
15 }
16 public String getNamePalo() {
17 String name = "";
18 switch ( palo ) {
19 case PICAS:
20 name = "Picas";
21 break;
22 case CORAZONES:
23 name = "Corazones";
24 break;
25 case TREBOLES:
26 name = "Treboles";
27 break;
28 case DIAMANTES:
29 name = "Diamantes";
30 break;
31 default:
32 // No es necesario comprobar si hay errores ya que
33 // el enum Palo es finito.
34 }
35 return name;
36 }
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 Programa TestNaipeBaraja
2
4 import naipes.domain.Palo;
5
8
10 = new NaipeBaraja(Palo.PICAS, 2);
13
14 // NaipeBaraja naipe2 = new NaipeBaraja(47, 2);
15 // Esto no se compilar.
16 }
17 }
Tipos enumerados
Tipos enumerados avanzados
Lamentablemente, la clase NaipeBaraja sigue necesitando un mtodo
getNamePalo para mostrar en la interfaz grca 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 Tipo Palo con un atributo
2
3 public enum Palo {
4 PICAS ("Picas"),
5 CORAZONES ("Corazones"),
6 TREBOLES ("Treboles"),
7 DIAMANTES ("Diamantes");
8
9 private final String name;
10
11 private Palo(String name) {
12 this.name = name;
13 }
14
15 public String getName() {
16 return name;
17 }
18 }
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.
Tipos enumerados
Por ltimo, el Cdigo 7-8 muestra el programa de prueba modicado,
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 Programa TestNaipeBaraja con mtodos Palo
2
4 import naipes.domain.Palo;
5
8
10 = new NaipeBaraja(Palo.PICAS, 2);
12 + " de " + naipe1.getPalo().getName());
13
14 // NuevoNaipeBaraja naipe2 = new NuevoNaipeBaraja(47, 2);
16 }
17 }
Importaciones estticas
Importaciones estticas
Si necesita acceder a los miembros estticos de una clase, ser necesario
calicar 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 calicarlos
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
prejo de espacio de nombres Palo.
Cdigo 7-9 Programa TestNaipeBaraja con importaciones estticas
2
4 import static naipes.domain.Palo.*;
5
8
9 NaipeBaraja naipe1 = new NaipeBaraja(PICAS, 2);
11 + " de " + naipe1.getPalo().getName());
12
13 // NuevoNaipeBaraja naipe2 = new NuevoNaipeBaraja(47,
2);
15 }
16 }
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.
Clases abstractas
Clases abstractas
Volviendo al ejemplo de la empresa de transporte, imagine que el sistema
necesita generar un informe semanal donde gure toda la ota 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 ota
de vehculos y genera el informe de Combustible Necesario.
La Figura 7-2 ilustra el modelo UML de la compaa y su coleccin ota
de vehculos (la asociacin flota).
Figura 7-2 Modelo UML de la ota de la empresa
El programa TransporteMain muestra la inicializacin de una ota de
ejemplo.
1 public class TransporteMain {
3 Empresa c = new Empresa();
4
5 // llena la empresa con una flota de vehculos
6 c.addVehiculo( new Camion(10000.0) );
8 c.addVehiculo( new Barcaza(500000.0) );
10 c.addVehiculo( new Barcaza(750000.0) );
11
12 InformeCombustibleNecesario informe = new
InformeCombustibleNecesario(c);
13 informe.generateText(System.out);
14 }
15 }
Vehculo
Barcaza Camin
Empresa
flota
0..*
transporte
dominio
TransporteMain Usa
InformeCombustibleNecesario Usa
informes
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 eciencia de consumo del vehculo (en kilmetros
por litro).
Problema
Los clculos para determinar la eciencia 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.
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).
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 public abstract class Vehiculo {
2 public abstract double calcEficienciaConsumo();
3 public abstract double calcDistanciaViaje();
4 }
Barcaza
Vehculo
+calcEficienciaConsumo() : double
+calcDistanciaViaje() : double
Camin
+Camion(cargaMax : double)
{abstract}
constructores
mtodos
+Barcaza(cargaMax : double)
constructores
mtodos
Clases abstractas
La clase Camion debe crear una implementacin:
1 public class Camion extends Vehiculo {
2 public Camion(double cargaMax) {...}
3 public double calcEficienciaConsumo() {
4 // calcula el consumo de combustible de un camin
5 }
6 public double calcDistanciaViaje() {
7 // calcula la distancia de este viaje por autopista
8 }
9 }
La clase Barcaza debe crear una implementacin:
1 public class Barcaza extends Vehiculo {
2 public Barcaza(double cargaMax) {...}
3 public double calcEficienciaConsumo() {
4 // calcula el consumo de combustible de una barcaza
5 }
6 public double calcDistanciaViaje() {
7 // calcula la distancia de este viaje por vas fluviales
8 }
9 }
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.
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 deniendo 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 modicadores en el cdigo o no. Igualmente,
todos los atributos son public, static y final. En otras palabras,
slo se pueden declarar atributos constantes.
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).
Figura 7-4 ClaseAvion e implementacin de la interfaz ObjetoVolador
1 public interface ObjetoVolador {
2 public void despegar();
3 public void aterrizar();
4 public void volar();
5 }
1 public class Avion implements ObjetoVolador {
2 public void despegar() {
3 // acelerar hasta despegar
4 // subir el tren de aterrizaje
5 }
6 public void aterrizar() {
7 // bajar el tren de aterrizaje
8 // decelerar y desplegar flaps hasta tocar tierra
9 // frenar
10 }
11 public void volar() {
12 // mantener los motores en marcha
13 }
14 }
+despegar()
+aterrizar()
+volar()
interfaz
ObjetoVolador
+despegar()
+aterrizar()
+volar()
Avin
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.
Figura 7-5 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.
+despegar()
+aterrizar()
+volar()
interfaz
ObjetoVolador
+despegar()
+aterrizar()
+volar()
Avion
+despegar()
+aterrizar()
+volar()
Ave
+despegar()
+aterrizar()
+volar()
Superman
+hacerNido()
+ponerHuevos()
+saltarEdificio()
+detenerBala()
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.
Figura 7-6 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).
Vehiculo
Animal
+comer()
Kriptoniano
+despegar()
+aterrizar()
+volar()
interfaz
ObjetoVolador
+despegar()
+aterrizar()
+volar()
Avion
+despegar()
+aterrizar()
+volar()
Ave
+despegar()
+aterrizar()
+volar()
Superman
+hacerNido()
+ponerHuevos()
+saltarEdificio()
+detenerBala()
+comer() +comer()
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.
Figura 7-7 Jerarqua de clases del ejemplo de aeropuerto
El cdigo del aeropuerto podra parecerse al siguiente:
1 public class Aeropuerto {
3 Aeropuerto aeropuertoCiudad = new Aeropuerto();
4 Helicoptero helicoptero = new Helicoptero();
5 Hidroavion hAvion = new Hidroavion();
6
7 aeropuertoLondres.darPermisoAterrizar(helicoptero);
8 aeropuertoLondres.darPermisoAterrizar(hAvion);
9 }
10
11 private void darPermisoAterrizar(ObjetoVolador v) {
12 v.aterrizar();
13 }
14 }
Vehiculo
Animal
+comer()
Kriptoniano
+despegar()
+aterrizar()
+volar()
interfaz
ObjetoVolador
+despegar()
+aterrizar()
+volar()
Avion
+despegar()
+aterrizar()
+volar()
Ave
+despegar()
+aterrizar()
+volar()
Superman
+hacerNido()
+ponerHuevos()
+saltarEdificio()
+detenerBala()
+comer() +comer()
Helicoptero Hidroavion
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.
Figura 7-8 Ejemplo de varias implementaciones
Ahora escriba la clase Puerto para dar permisos de atraque:
1 public class Puerto {
3 Puerto puertoBarcelona = new Puerto();
4 Barcaza barcaza = new Barcaza();
5 Hidroavion hAvion = new Hidroavion();
6
7 puertoBarcelona.darPermisoAtracar(barcaza);
8 puertoBarcelona.darPermisoAtracar(hAvion);
9 }
10 private void darPermisoAtracar(Nautico n) {
11 n.atracar();
12 }
13 }
+despegar()
+aterrizar()
+volar()
interfaz
ObjetoVolador
+despegar()
+aterrizar()
+volar()
Avion
+atracar()
+navegar()
interfaz
Nautico
Hidroavion
+atracar()
+navegar()
Helicoptero
Vehiculo
Barcaza
+atracar()
+navegar()
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).
Identicar 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.
8-1
Mdulo 8
Excepcionesyaserciones
Objetivos
para:
Denir excepciones.
Usar las sentencias try, catch y finally.
Describir categoras de excepciones.
Identicar 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.
Aspectos relevantes
8-2 Languaje de programacin Java
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?
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
Excepciones y aserciones
Excepciones y aserciones 8-3
Excepciones y aserciones
Las excepciones son un mecanismo utilizado por numerosos lenguajes de
programacin para describir lo que debe hacerse cuando ocurre algo
inesperado. En general, algo inesperado suele ser algn tipo de error,
por ejemplo, la llamada a un mtodo con argumentos no vlidos, el
fallo de una conexin de red o la solicitud de apertura de un archivo
que no existe.
Las aserciones son una forma de vericar 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 vericar
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 nal se entrega al cliente.
sta es una diferencia importante entre aserciones y excepciones.
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 verique 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 nal 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 nalizar 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 nalice
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 nalizar 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.
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 conar 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 Ejemplo de un programa que genera una excepcin
1 public class AddArguments {
3 int sum = 0;
4 for ( int i = 0; i < args.length; i++ ) {
5 sum += Integer.parseInt(args[i]);
6 }
7 System.out.println("Sum = " + sum);
8 }
9 }
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)
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 modicado que utiliza una
sentencia try-catch para detectar la excepcin, en este caso
java.lang.NumberFormatException.
Cdigo 8-2 Ejemplo de un programa que maneja una excepcin
1 public class AddArguments2 {
3 try {
4 int sum = 0;
7 }
9 } catch (NumberFormatException nfe) {
10 System.err.println("Uno de los argumentos de la lnea de "
11 + "comandos no es un entero.");
12 }
13 }
14 }
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.
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 Programa AddArguments mejorado
1 public class AddArguments3 {
3 int sum = 0;
5 try {
7 } catch (NumberFormatException nfe) {
8 System.err.println("[" + args[i] + "] no es un entero"
9 + " y no se incluir en la suma.");
10 }
11 }
13 }
14 }
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
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.
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 dene 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 try {
2 startFaucet();
3 waterLawn();
4 } catch (BrokenPipeException e) {
5 logProblem(e);
6 } finally {
7 stopFaucet();
8 }
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.
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 denidos 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.
Figura 8-1 Subclases y excepciones
Throwable
Error
Exception
RuntimeException
IOException
ArithmeticException
NullPointerException
IllegalArgumentException
FileNotFoundException
VirtualMachineError
AssertionError
StackOverflowError
OutOfMemoryError
EOFException
SQLException
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, reeja 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.
Excepciones comunes
Excepciones comunes
El lenguaje Java proporciona varias excepciones predenidas. 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 otante) 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:
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 denir 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 signica 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 signica 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.
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.
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 especcas 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 public class PruebaA {
2 public void metodoA() throws IOException {
3 // realiza algn clculo
4 }
5 }
1 public class PruebaB1 extends PruebaA {
2 public void metodoA() throws EOFException {
4 }
5 }
1 public class PruebaB2 extends PruebaA {
2 public void metodoA() throws Exception {
4 }
5 }
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.
Creacin de excepciones personalizadas
Las excepciones que dene 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 denida por el
usuario que contiene un constructor, algunas variables y mtodos.
1 public class ServerTimedOutException extends Exception {
2 private int port;
3
4 public ServerTimedOutException(String message, int port) {
5 super(message);
6 this.port = port;
7 }
8
9 public int getPort() {
10 return port;
11 }
12 }
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.
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
denida por el usuario como ServerTimedOutException) de la manera
siguiente:
1 public void connectMe(String serverName)
2 throws ServerTimedOutException {
3 boolean successful;
4 int portToConnect = 80;
5
6 successful = open(serverName, portToConnect);
7
8 if ( ! successful ) {
9 throw new ServerTimedOutException("Imposible conectar",
10 portToConnect);
11 }
12 }
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;
}
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 nalizar 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 vericar 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 vericar
que se cumplan sus propias expectativas internas.
Algunos ejemplos de usos adecuados son las invariantes internas, las
invariantes del ujo de control, las postcondiciones y las invariantes
de clase.
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 if (x > 0) {
2 // hacer esto
3 } else {
4 // hacer aquello
5 }
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 if (x > 0) {
2 // hacer esto
3 } else {
4 assert (x == 0);
5 // hacer aquello a menos que x sea negativo
6 }
Invariantes del ujo de control
Las invariantes del ujo de control reejan suposiciones similares a las de
las invariante internas, pero tienen que ver con la direccin que sigue el
ujo 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 vericarse
agregando una sentencia de asercin similar a sta:
1 switch ( palo ) {
2 case Palo.TREBOLES: // ...
3 break;
4 case Palo.DIAMANTES: // ...
5 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 nalizar un mtodo. Un ejemplo sencillo de
prueba de postcondicin sera vericar 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.
Aserciones
Una invariante de clase es aquella que puede comprobarse al nal 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.
9-1
Mdulo 9
API CollectionsyGenerics
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.
Otros recursos
Otros recursos
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 y Generics 9-3
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 especco y si
se permiten los duplicados.
Set: una coleccin sin orden especco, 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 especicar 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.
API Collections
La Figura 9-1 muestra un diagrama UML de las principales interfaces y
clases de implementacin del API Collections.
Figura 9-1 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 simplicacin 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/
Collection
<<interface>>
Set
<<interface>>
List
<<interface>>
HashSet
ArrayList LinkedList
+add
+size
+remove
+isEmpty
+contains
+iterator
+add
+get
+remove
+set
+indexOf
+listIterator
TreeSet
<<interface >>
SortedSet
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.
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 Programa EjemploSet
1 import java.util.*;
2 public class EjemploSet {
4 Set set = new HashSet();
5 set.add("one");
6 set.add("second");
7 set.add("3rd");
8 set.add(new Integer(4));
9 set.add(new Float(5.0F));
10 set.add("second"); // duplicado, no se agrega
11 set.add(new Integer(4)); // duplicado, no se agrega
12 System.out.println(set);
13 }
14 }
Tabla 9-1 Implementaciones genricas de Collection
Hash Table
Resizable
Array
Balanced
Tree
Linked List
Hash Table +
Linked List
Set HashSet TreeSet LinkedHashSet
List ArrayList LinkedList
Deque ArrayDeque LinkedList
Map HashMap TreeMap LinkedHashMap
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 nal.
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 Programa EjemploList
2 public class EjemploList {
4 List list = new ArrayList();
5 list.add("one");
6 list.add("second");
7 list.add("3rd");
8 list.add(new Integer(4));
9 list.add(new Float(5.0F));
10 list.add("second"); // duplicado, se agrega
11 list.add(new Integer(4)); // duplicado, se agrega
12 System.out.println(list);
13 }
14 }
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.
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 signicativo.
Interfaz Map
Interfaz Map
A veces los mapas se denominan arrays asociativos. Los objetos Map
describen las asignaciones de claves a valores. Por denicin, 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 especco de cada iterador.
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 Programa EjemploMap
2 public class EjemploMap {
4 Map map = new HashMap();
5 map.put("one","1st");
6 map.put("second", new Integer(2));
7 map.put("third","3rd");
8 // Sobrescribe la asignacin anterior
9 map.put("third","III");
10 // Devuelve el conjunto de las claves
11 Set set1 = map.keySet();
12 // Devuelve la vista Collection de los valores
13 Collection collection = map.values();
14 // Devuelve el conjunto de las asignaciones de claves a valores
15 Set set2 = map.entrySet();
16 System.out.println(set1 + "\n" + collection + \n + set2);
17 }
18 }
El programa generara la siguiente salida:
[second, one, third]
[2, 1st, III]
[second=2, one=1st, third=III]
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.
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 denir 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 clasicar por orden cronolgico, mientras que una lista
con elementos de tipo Integer se clasicar 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;
10 this.primerApellido = primerApellido;
11 this.IDestudiante = IDestudiante;
12 this.Media = Media;
13 }
14 public String Nombre() { return Nombre; }
15 public String primerApellido() { return primerApellido; }
16 public int IDestudiante() { return IDestudiante; }
17 public double Media() { return Media; }
18 // Implementa el mtodo compareTo.
19 public int compareTo(Object o) {
20 double f = Media-((Estudiante)o).Media;
21 if (f == 0,0)
22 return 0; // 0 significa que son iguales
23 else if (f<0,0)
24 return -1; // un valor negativo significa menos que o antes de
25 else
26 return 1; // un valor positivo significa ms que o despus de
27 }
28 }
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 Programa ListaEstudiantes
2 public class ComparableTest {
4 TreeSet estudianteSet = new TreeSet();
5 estudianteSet.add(new Estudiante("Miguel", "Herraiz",101, 4,0));
6 estudianteSet.add(new Estudiante("Juan", "Lino",102, 2,8));
7 estudianteSet.add(new Estudiante("Jaime", "Marcos",103, 3,6));
8 estudianteSet.add(new Estudiante("Clara", "Genio",104, 2,3));
9 Object[] estudianteArray = estudianteSet.toArray();
10 Estudiante s;
11 for(Object obj : estudianteArray){
12 s = (Estudiante) obj;
13 System.out.printf("Nombre = %s %s ID = %d Media = %.1f\n",
14 s.Nombre(), s.primerApellido(), s.IDestudiante(), s.Media());
15 }
16 }
17 }
La salida generada por el programa ListaEstudiantes es
Nombre = Clara Genio ID = 104 Media = 2,3
Nombre = Juan Lino ID = 102 Media = 2,8
Nombre = Jaime Marcos ID = 103 Media = 3,6
Nombre = 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 especicado. La siguiente seccin ofrece una
explicacin detallada del uso de la interfaz Comparator.
Interfaz Comparator
La interfaz Comparator ofrece una mayor exibilidad 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
exibilidad 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)
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 Clase Estudiante
1 class Estudiante {
2 String Nombre, primerApellido;
3 int IDestudiante=0;
4 double Media=0,0;
5 public Estudiante(String Nombre, String primerApellido,
6 int IDestudiante, double Media) {
7 if (Nombre == null || primerApellido == null || IDestudiante == 0
||
8 Media == 0,0) throw new IllegalArgumentException();
9 this.Nombre = Nombre;
10 this.primerApellido = primerApellido;
11 this.IDestudiante = IDestudiante;
12 this.Media = Media;
13 }
14 public String Nombre() { return Nombre; }
15 public String primerApellido() { return primerApellido; }
16 public int IDestudiante() { return IDestudiante; }
17 public double Media() { return Media; }
18 }
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 Ejemplo de implementacin de la interfaz Comparator
2 public class CompNombre implements Comparator {
3 public int compare(Object o1, Object o2) {
4 return
5 (((Estudiante)o1).Nombre.compareTo(((Estudiante)o2).Nombre));
6 }
7 }
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.
Cdigo 9-8 Otro ejemplo de implementacin de la interfaz Comparator.
2 public class CompNota implements Comparator {
3 public int compare(Object o1, Object o2) {
4 if (((Estudiante)o1).Media == ((Estudiante)o2).Media)
5 return 0;
6 else if (((Estudiante)o1).Media < ((Estudiante)o2).Media)
7 return -1;
8 else
9 return 1;
10 }
11 }
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 Programa conComparatorTest.
2 public class ComparatorTest {
4 Comparator c = new CompNombre();
5 TreeSet estudianteSet = new TreeSet(c);
6 estudianteSet.add(new Estudiante("Miguel", "Herraiz",101, 4,0));
7 estudianteSet.add(new Estudiante("Juan", "Lino",102, 2,8));
8 estudianteSet.add(new Estudiante("Jaime", "Marcos",103, 3,6));
9 estudianteSet.add(new Estudiante("Clara", "Genio",104, 2,3));
10 Object[] estudianteArray = estudianteSet.toArray();
11 Estudiante s;
12 for(Object obj : estudianteArray){
13 s = (Estudiante) obj;
14 System.out.printf("Nombre = %s %s ID = %d Media = %.1f\n",
15 s.Nombre(), s.primerApellido(), s.IDestudiante(), s.Media());
16 }
17 }
18 }
Este programa generara la siguiente salida:
Nombre = Jaime Marcos ID = 103 Media = 3,6
Nombre = Juan Lino ID = 102 Media = 2,8
Nombre = Clara Genio ID = 104 Media = 2,3
Nombre = Miguel Herraiz ID = 101 Media = 4,0
Si el Cdigo 9-9 se modicase para utilizar un objeto CompNota, los
estudiantes se ordenaran segn su nota media.
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();
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
2 public class EjemploSetGen {
4 Set<String> set = new HashSet<String>();
5 set.add("one");
7 set.add("3rd");
8 // Esta lnea genera un error de compilacin
9 set.add(new Integer(4));
10 // Duplicado, no se agrega
12 System.out.println(set);
13 }
14 }
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. Dene 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
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
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 }
Genricos
Este programa produce la siguiente salida:
El delantero es henry
El lateral derecho es ronaldo
El portero es cech
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.
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);
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
de constructor
public ArrayList
(int capacity)
public ArrayList
(int capacity)
Declaracin
de mtodo
public void add(Object o)
public Object get(int index)
public void add(E o)
public E get(int index)
Ejemplos de
declaraciones
de variables
ArrayList list1;
ArrayList list2;
ArrayList <String> a3;
ArrayList <Date> a4;
Ejemplos de
declaraciones
de instancias
list1 = new ArrayList(10);
list2 = new ArrayList(10);
a3= new ArrayList<String> (10);
a4= new ArrayList<Date> (10);
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.
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.
Figura 9-4 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.*;
3
4 public class ProbarSeguridadTipo {
5
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 }
Cuenta
CuentaCorriente CuentaAhorro
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
3
4 public class ProbarInvarianza {
5
7 List<Cuenta> la;
9 List<CuentaAhorro> ls = new ArrayList<CuentaAhorro>();
10
11 //si lo siguiente fuese posible...
12 la = lc;
13 la.add(new CuentaCorriente("Fred"));
14
15 //lo siguiente tambin debera ser posible...
16 la = ls;
17 la.add(new CuentaCorriente("Fred"));
18
19 //por tanto...
20 CuentaAhorro sa = ls.get(0); //vaya!!
21 }
22 }
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 polimorsmo tradicional y, a primera vista,
parece restar exibilidad a las colecciones genricas.
Respuesta de la covarianza
Considere el cdigo que aparece en el Cdigo 9-17.
Cdigo 9-17 Uso de tipos covariantes
3
4 public class ProbarCovarianza {
5
6 public static void printNames(List <? extends Cuenta> lea) {
7 for (int i=0; i < lea.size(); i++) {
8 System.out.println(lea.get(i).getName());
9 }
10 }
11
14 List<CuentaAhorro> ls = new ArrayList<CuentaAhorro>();
15
16 printNames(lc);
17 printNames(ls);
18
19 //pero...
20 List<? extends Object> leo = lc; //Bien
21 leo.add(new CuentaCorriente("Fred"));//Error de compilacin!
22 }
23 }
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.
Genricos: refactorizacin de cdigo no genrico existente
Genricos: refactorizacin de cdigo no genrico
existente
Con las colecciones genricas, es posible especicar 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
2 public class GenericsWarning {
4 List list = new ArrayList();
5 list.add(0, new Integer(42));
6 int total = (Integer) list.get(0);
7 }
8 }
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:
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 modicar 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>();
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
modicar 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 List list<Estudiante> = new ArrayList<Estudiante>();
2 // agregue algunos elementos
3 Iterator<Estudiante> elements = list.iterator();
4 while (elements.hasNext()) {
5 System.out.println(elements.next());
6 }
Iteradores
La Figura 9-5 muestra un diagrama de las interfaces Iterator genricas
para el API Collections.
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.
Iterator<E>
interface
ListIterator<E>
interface
+hasNext() : boolean
+next() : E
+remove()
+hasPrevious() : boolean
+previous() : E
+add(element : E)
+set(element : E)
Bucle formejorado
Bucle formejorado
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 public void deleteAll(Collection<NameList> c) {
2 for (Iterator<NameList> i=c.iterator(); i.hasNext();)
{
3 NameList nl = i.next();
4 nl.deleteItem();
5 }
6 }
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 public void deleteAll(Collection<NameList> c) {
2 for (NameList nl: c) {
3 nl.deleteItem();
4 }
5 }
Bucle formejorado
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 List<Asignatura> asignaturas=...;
2 List<Profesor> profesores=...;
3 List<Curso> listaCursos = new ArrayList<Curso>();
4 for (Asignatura asig: asignaturas) {
5 for (Profesor prof: profesores) {
6 listaCursos.add(new Curso(asig, prof));
7 }
8 }
10-1
Mdulo 10
PrincipiosbsicosdeE/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 ujos y
optar correctamente por uno u otro.
Otros recursos
Otros recursos
2006.
Bates, Sierra. Head First Java, First Edition. OReilly Media. 2003.
Argumentos de la lnea de comandos
Principios bsicos de E/S 10-3
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 especicar la informacin
de conguracin 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 public class TestArgs {
3 for (int i = 0; i < args.length; i++) {
4 System.out.println("args[" + i + "] is: " + args[i]);
5 }
6 }
7 }
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 .
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.
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 especicar 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 ujo 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 import java.util.Properties;
2
3 public class TestProperties {
5 Properties props = System.getProperties();
6 props.list(System.out);
7 }
8 }
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
Principios bsicos del flujo de E/S
Principios bsicos del ujo de E/S
Un ujo es una secuencia de datos procedentes de una fuente en direccin
a un sumidero. Normalmente, un programa representa un extremo de ese
ujo, mientras que el otro extremo lo constituye otro nodo (por ejemplo,
un archivo).
Las fuentes y sumideros tambin se denominan ujos de entrada y ujos de
salida, respectivamente. Es posible leer un ujo de entrada, pero no
escribir en l. Por el contrario, es posible escribir en un ujo de salida,
pero no leerlo. La Tabla 10-1 muestra las principales clases de ujos.
Datos contenidos en los flujos
La tecnologa Java admite dos tipos de datos en los ujos: bytes sin
formato (raw) o caracteres Unicode. Normalmente, el trmino ujo hace
referencia a ujos de bytes y los trminos lector (reader) y escritor (writer)
hacen referencia a ujos de caracteres.
Ms concretamente, los ujos de entrada de caracteres se implementan
con subclases de la clase Reader y los ujos de salida de caracteres se
implementan con subclases de la clase Writer. Los ujos de entrada de
bytes se implementan con subclases de la clase InputStream, mientras
que los ujos de salida de bytes se implementan con subclases de la
clase OutputStream.
Tabla 10-1 Clases fundamentales de ujos
Flujo Flujos de bytes Flujos de caracteres
Flujos fuente InputStream Reader
Flujos sumidero OutputStream Writer
Flujos de bytes
Flujos de bytes
En las prximas secciones se describen los principales ujos de bytes.
Mtodos InputStream
Los tres mtodos siguientes proporcionan acceso a los datos del ujo 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
ujo o un -1, que indica la condicin de n de archivo. Los otros dos
mtodos leen el ujo 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 ecacia, lea siempre los datos en el bloque ms grande
posible que resulte prctico o utilice ujos en bfer.
void close()
Cuando haya terminado con un ujo, cirrelo. Si dispone de una pila
de ujos, utilice ujos ltrados para cerrar el ujo de la parte superior
de la pila. Con ello se cerrarn tambin los ujos inferiores.
int available()
Este mtodo indica el nmero de bytes inmediatamente disponibles
para su lectura en el ujo. Es posible que una operacin de lectura real
despus de esta llamada devuelva ms bytes.
long skip(long n)
Este mtodo descarta el nmero especicado de bytes del ujo.
boolean markSupported()
void mark(int readlimit)
void reset()
Flujos de bytes
Estos mtodos pueden utilizarse para realizar operaciones de exploracin
en un ujo, si ste las admite. El mtodo markSupported() devuelve
true si los mtodos mark() y reset() funcionan con ese ujo en
concreto. El mtodo mark(int) indica que ha de marcarse la posicin
actual del ujo y que es preciso asignar un bfer con suciente capacidad
para albergar como mnimo el nmero de bytes especicado en el
argumento. El parmetro del mtodo mark(int) especica el nmero
de bytes que pueden releerse llamando a reset(). Tras varias
operaciones read() consecutivas, la llamada al mtodo reset()
devuelve el ujo de entrada al punto marcado. Si se sobrepasa la
capacidad del bfer, reset() no tienen ningn signicado.
Mtodos OutputStream
Los mtodos siguientes escriben en el ujo de salida:
void write(int)
void write(byte[] buffer)
void write(byte[] buffer, int offset, int length)
Al igual que con los ujos 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 ujo de salida acumula escrituras antes de conrmarlas.
El mtodo flush() permite forzar las escrituras.
Flujos de caracteres
En las prximas secciones se describen los principales ujos 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 ujo o un -1, que indica la condicin de n 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 ecacia, 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 ujo de entrada.
Mtodos Writer
Los mtodos siguientes escriben en el escritor:
void write(int c)
void write(char[] cbuf)
void write(char[] cbuf, int offset, int length)
void write(String string)
void write(String string, int offset, int length)
Al igual que los ujos de salida, los escritores incluyen los mtodos close
y flush.
void close()
void flush()
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 (ujos de un proceso o de un hilo [proceso ligero] a otro;
la tubera del ujo de salida de un hilo est conectada a la tubera
del ujo de entrada de otro hilo)
Es posible crear nuevas clases de ujos 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 ujos de nodos.
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 import java.io.*;
2
3 public class PruebaFlujosNodos {
Tabla 10-2 Tipos de ujos de nodos
Tipo Flujos de caracteres Flujos de bytes
Archivo FileReader
FileWriter
FileInputStream
FileOutputStream
Memoria:
array
CharArrayReader
CharArrayWriter
ByteArrayInputStream
ByteArrayOutputStream
Memoria:
cadena
StringReader
StringWriter
N/D
Tubera PipedReader
PipedWriter
PipedInputStream
PipedOutputStream
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 ujos lnea por lnea. Se denomina BufferedReader y
pertenece a un tipo de ujos conocidos como ujos de procesamiento.
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 import java.io.*;
2 public class PruebaFlujosBufer {
4 try {
5 FileReader input = new FileReader(args[0]);
6 BufferedReader bufInput = new BufferedReader(input);
7 try {
8 FileWriter output = new FileWriter(args[1]);
9 BufferedWriter bufOutput= new BufferedWriter(output);
10 try {
11 String line;
12 // lee la primera lnea
13 line = bufInput.readLine();
14 while ( line != null ) {
15 // escribe la lnea en el archivo de salida
16 bufOutput.write(line, 0, line.length());
17 bufOutput.newLine();
18 // lee la lnea siguiente
19 line = bufInput.readLine();
20 }
21 } finally {
22 bufOutput.close();
23 }
24 } finally {
25 bufInput.close();
26 }
29 }
30 }
31 }
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 ecaz. La lnea 7 concatena el objeto
lector del archivo en un ujo lector en bfer. El usuario manipula el ujo
del extremo exterior de la concatenacin (bufInput), que a su vez
manipula el ujo del extremo interior (input).
Concatenacin de flujos de E/S
Concatenacin de ujos de E/S
Es inusual que un programa utilice un solo objeto ujo, ya que lo normal
es que concatene varios ujos para procesar los datos. La Figura 10-1
muestra un ejemplo de ujo de entrada; en este caso y por motivos
de ecacia, un ujo de archivos se guarda en el bfer y despus se
convierte en elementos de datos (primitivos de Java).
Figura 10-1 Ejemplo de ujos de entrada concatenados
La Figura 10-2 muestra un ejemplo de ujo de salida; en este caso,
los datos se escriben, se guardan en el bfer y nalmente se escriben
en un archivo.
Figura 10-2 Ejemplo de ujos de salida concatenados
Fuente
Programa
FileInputStream
BufferedInputStream
DataInputStream
de datos
Sumidero
Programa
FileOutputStream
BufferedOutputStream
DataOutputStream
de datos
Flujos de procesamiento
Flujos de procesamiento
Un ujo de procesamiento realiza una especie de conversin en otro ujo.
Tambin se conoce como ujo ltrado. Un ujo de entrada ltrado se crea
con una conexin a un ujo de entrada existente. El objetivo de esta
operacin es que, al intentar leer el objeto ujo de entrada ltrado, se
suministren los caracteres que inicialmente provenan del otro objeto ujo
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 ujos
de procesamiento incorporados que incluye el paquete java.io.
Nota: Los ujos FilterXyz son clases abstractas y no pueden utilizarse
directamente, pero s colocarse en subclases para implementar ujos de
procesamiento propios.
Es fcil crear nuevos ujos de procesamiento, como veremos en la
prxima seccin.
Nota: La serializacin de objetos se describe ms adelante en este mdulo.
Tabla 10-3 Lista de ujos de procesamiento por tipo
Tipo Flujos de caracteres 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
Clases bsicas de flujos de bytes
Clases bsicas de ujos de bytes
La Figura 10-3 muestra la jerarqua de clases de ujos de bytes de entrada
del paquete java.io. En las siguientes secciones se describen algunas de
las clases de ujos de bytes ms habituales.
Figura 10-3 Jerarqua de clases InputStream
La Figura 10-4 muestra la jerarqua de clases de ujos de bytes de salida
del paquete java.io.
Figura 10-4 Jerarqua de clases OutputStream
InputStream
FileInputStream
ObjectInputStream
PipedInputStream
StringBufferInputStream
FilterInputStream
ByteArrayInputStream
DataInputStream
PushbackInputStream
BufferedInputStream
LineNumberInputStream
SequenceInputStream
OutputStream
FileOutputStream
ObjectOutputStream
FilterOutputStream
ByteArrayOutputStream
DataOutputStream
PrintStream PrintStream
PipedOutputStream
Clases FileInputStream y FileOutputStream
Las clases FileInputStream y FileOutputStream son ujos de nodos y,
como su nombre indica, utilizan archivos en disco. Los constructores
de estas clases permiten especicar la ruta del archivo al que estn
conectadas. Para construir un ujo del tipo FileInputStream, el archivo
asociado debe existir y ser legible. Si se construye un ujo 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 ujos ltrados de las clases BufferedInputStream y
BufferedOutputStream sirven para aumentar la ecacia 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
ujos 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()
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 ujos 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 ujos.
Escribir un objeto en un ujo implica principalmente consignar los valores
de todos los campos del objeto. Si los campos son tambin objetos,
estos objetos deben escribirse igualmente en el ujo.
Nota: Si los campos se declaran transitorios (transient) o estticos
(static), sus valores no se escriben en el ujo, como se explica en la
prxima seccin.
La lectura de un objeto de un ujo 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 ujo, 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 ujos.
Nota: Si se trata de un ujo de socket de red, los objetos se serializan antes
de enviarse y se deserializan a su recepcin en otro host o proceso.
La Figura 10-5 presenta un esquema de los posibles ujos de entrada y de
las clases lector que pueden concatenarse.
Figura 10-5 Combinaciones de concatenacin de entrada: revisin
La Figura 10-6 presenta un esquema de los posibles ujos de salida y de
las clases escritor que pueden concatenarse.
Figura 10-6 Combinaciones de concatenacin de salida: revisin
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 especca 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 ujo 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 grco 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 grco 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.
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 public class MyClass implements Serializable {
2 public transient Thread myThread;
3 private String customerID;
4 private int total;
5 }
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 systemsafe universal character set transformation
format). La palabra clave transient impide la serializacin de los datos.
1 public class MyClass implements Serializable {
2 public transient Thread myThread;
3 private transient String customerID;
4 private int total;
5 }
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 ujos 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 import java.io.*;
2 import java.util.Date;
3
4 public class SerializeDate {
Serializacin
5
6 SerializeDate() {
7 Date d = new Date ();
8
9 try {
10 FileOutputStream f =
11 new FileOutputStream ("date.ser");
12 ObjectOutputStream s =
13 new ObjectOutputStream (f);
14 s.writeObject (d);
15 s.close ();
17 e.printStackTrace ();
18 }
19 }
20
22 new SerializeDate();
23 }
24 }
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 ujo 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 ujo.
Cdigo 10-7 Clase DeSerializeDate
1 import java.io.*;
2 import java.util.Date;
3
4 public class DeSerializeDate {
5
6 DeSerializeDate () {
7 Date d = null;
8
9 try {
10 FileInputStream f =
11 new FileInputStream ("date.ser");
Serializacin
12 ObjectInputStream s =
13 new ObjectInputStream (f);
14 d = (Date) s.readObject ();
15 s.close ();
16 } catch (Exception e) {
18 }
19
20 System.out.println(
21 "Deserialized Date object from date.ser");
22 System.out.println("Date: "+d);
23 }
24
26 new DeSerializeDate();
27 }
28 }
La deserializacin del objeto se produce en la lnea 14, cuando se llama al
mtodo readObject().
Clases bsicas de flujos de caracteres
Clases bsicas de ujos de caracteres
La Figura 10-7 muestra la jerarqua de clases de ujos de caracteres
Reader del paquete java.io. En las siguientes secciones se describen
algunas de las clases de ujos de caracteres ms habituales.
Figura 10-7 Jerarqua de clases Reader
La Figura 10-8 muestra la jerarqua de clases de ujos de caracteres
Writer del paquete java.io.
Figura 10-8 Jerarqua de clases Writer
Reader
BufferedReader
CharArrayReader
PipedReader
FilterReader
StringReader
FileReader InputStreamReader
LineNumberReader
PushbackReader
Writer
BufferedWriter
CharArrayWriter
PrintWriter
PipedWriter
FilterWriter
StringWriter
FileWriter OutputStreamWriter
Mtodos InputStreamReader y OutputStreamWriter
Las versiones ms importantes de lectores y escritores son
InputStreamReader y OutputStreamWriter. Estas clases sirven de
interfaz entre los ujos de bytes y los lectores y escritores de caracteres.
Cuando se construye un ujo InputStreamReader o
OutputStreamWriter, se denen 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
ujo, las reglas de conversin alternan entre los bytes que utilizan la
codicacin de caracteres predeterminada de la plataforma y el formato
Unicode. En los pases anglfonos se utiliza la codicacin de bytes de
la norma ISO (International Organization for Standardization) 8859-1.
Es posible especicar otra codicacin de bytes utilizando un formato
de codicacin compatible. Si tiene la documentacin instalada, puede
buscar la lista de los formatos de codicacin 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
exibilidad 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 codicacin 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
codicacin de caracteres explcita, como la siguiente:
InputStreamReader ir
= new InputStreamReader(System.in, "ISO-8859-1");
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 codicacin
Latin-1 asignado al formato ASCII.
Clases FileReader y FileWriter
Las clases FileReader y FileWriter son ujos de nodos equivalentes en
caracteres Unicode a las clases FileInputStream y FileOutputStream.
Clases BufferedReader y BufferedWriter
Los ujos de caracteres ltrados de las clases BufferedReader y
BufferedWriter sirven para aumentar la ecacia de las operaciones
de E/S.
Clases StringReader y StringWriter
Las clases StringReader y StringWriter son ujos 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 grca. 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 ujos
que circulan por tuberas deben disponer de un extremo de entrada y
de otro de salida.
11-1
Mdulo 11
E/SdeconsolayE/Sdearchivos
Objetivos
para:
Leer datos de la consola.
Escribir datos en la consola.
Describir los archivos y la E/S de archivos.
Otros recursos
Otros recursos
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 y E/S de archivos 11-3
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 reere a la ventana de terminal que haya abierto la aplicacin
Java.
La variable System.in es un objeto InputStream que, en principio,
se reere al teclado del usuario.
La variable System.err es un objeto PrintStream que, en principio,
se reere a la ventana de terminal que haya abierto la aplicacin
Java.
Es posible redirigir estos ujos 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 nal.
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 nal de la salida.
void println(boolean)
void println(char)
void println(double)
void println(float)
void println(int)
void println(long)
void println(char[])
void println(Object)
Existe tambin un conjunto de mtodos sobrecargados asociado,
denominado print, que no agrega el carcter de salto de lnea.
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 {
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 try {
15 // Leer cada lnea de entrada y reproducirla
16 s = in.readLine();
17 while ( s != null ) {
18 System.out.println("Leer: " + s);
20 }
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 // Cerrar el Reader del bfer.
23 in.close();
La lnea 23 cierra el ujo de entrada situado en el extremo exterior
para liberar cualquier recurso del sistema relacionado con la creacin
de estos objetos de ujo.
24 } catch (IOException e) { // Capturar cualquier
excepcin.
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.
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.
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.
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 otante. El cdigo %gutiliza
la notacin cientca.
%n Introduce un carcter de salto de lnea en la cadena o el
ujo.
%% Introduce el carcter % en la cadena o el ujo.
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 import java.io.*;
2 import java.util.Scanner;
3 public class ScanTest {
4 public static void main(String [] args) {
5 Scanner s = new Scanner(System.in);
6 String param = s.next();
7 System.out.println("parmetro 1" + param);
8 int value = s.nextInt();
9 System.out.println("segundo parmetro" + value);
10 s.close();
11 }
12 }
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 ujos. Para
obtener ms informacin, consulte la pgina del enlace siguiente:
http://java.sun.com/docs/books/tutorial/essential/io/scanning.html
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 ujos 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 identicar 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 dene 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.
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()
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 import java.io.*;
2 public class ReadFile {
3 public static void main (String [] args) {
4 // Crea el archivo
5 File file = new File(args[0]);
6
7 try {
8 // Crea un Reader en bfer
9 // para leer cada lnea del archivo.
10 BufferedReader in
11 = new BufferedReader(new FileReader(file));
12 String s;
13
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.
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
17 while (s != null) {
18 System.out.println("Lectura: " + s);
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.
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 {
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
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 ujo de datos de entrada y
se enva al archivo, lnea a lnea.
Nota: Debe utilizarse la secuencia Control-d (que representa el n de
archivo) en lugar de Control-c, ya que sta ltima naliza la mquina
virtual de Java antes de que el programa cierre el ujo de archivo de
la forma adecuada.
26 // Cierra el Reader del bfer
27 in.close();
28 out.close();
29
31 // Captura cualquier otra excepcin de ES.
33 }
34 }
35 }
En las lneas 27 y 28 se cierran los ujos de entrada y salida. En las lneas
30-33 se manejan otras excepciones de E/S que se hayan podido generar.
12-1
Mdulo 12
Creacindeinterfacesgracasconel API
Swing
Objetivos
para:
Describir la tecnologa Swing de JFC.
Denir Swing.
Identicar los paquetes de Swing.
Describir los elementos que componen una interfaz grca:
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 grca usando componentes Swing.
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.
2006.
Bates, Sierra. Head First Java, Second Edition. OReilly Media. 2005.
Otros recursos
Creacin de interfaces gracas con el API Swing 12-3
Qu es Java Foundation Classes (JFC)?
JFC, o Java Foundation Classes, es un conjunto de paquetes utilizados
para la creacin de interfaces grcas 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.
Grcos 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 grcos 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 amplicadores de pantallas, los sistemas
transformacin de texto en voz, etc.
Desplazamiento de objetos: la transferencia de datos utilizando los
objetos de la interfaz grca (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.
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 otantes.
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 modicar 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 reere 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 signica
escribir las clases necesarias para denir 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 congurar el estilo de interfaz (pluggable look-and-
feel) 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 UNIXaparecer 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.
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 denir 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.
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 dicultades 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.
M
V
C
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 modelo-
delegado.
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.
Componente
Objeto
de IU
Administrador
de IU M
Paquetes de Swing
Paquetes de Swing
Swing posee un extenso conjunto de paquetes muy prcticos que lo
convierten en un API potente y exible. En la Tabla 12-1 gura el
nombre de cada paquete y su nalidad.
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 denicin 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 Proporciona clases e interfaces para
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.
Paquetes de Swing
javax.swing.plaf.basic Proporciona objetos de interfaz
grca creados segn el estilo
Basic.
javax.swing.plaf.metal Proporciona objetos de interfaz
grca creados segn el estilo
Java.
javax.swing.plaf.multi Proporciona objetos de interfaz
grca que combinan varios
estilos.
javax.swing.plaf.synth Proporciona objetos de interfaz
para estilos modicables en los
que toda la representacin
grca se delega.
javax.swing.text Proporciona clases e interfaces para
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.
Tabla 12-1 Paquetes de Swing (Continuacin)
Nombre del paquete Finalidad
Composicin de una interfaz grfica basada en Java
Composicin de una interfaz grca basada en Java
Las interfaces grcas 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 grca. 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 grca 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 sosticados que proporcionan mayor control sobre la
interfaz.
Composicin de una interfaz grfica basada en Java
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.
Figura 12-3 Composicin de una interfaz
Contenedor
Componentes
Contenedores Swing
Contenedores Swing
Los contenedores Swing pueden clasicarse 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.
Componentes Swing
Componentes Swing
Las interfaces basadas en Swing utilizan dos tipos de clases: clases de
interfaz grca y clases de soporte. Las clases de interfaz grca 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 grca.
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 clasicarse en los grupos siguientes:
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.
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.
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.
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)
Propiedades especficas de los componentes
En esta seccin se explican las propiedades especcas de los
componentes utilizando JComboBox como ejemplo. JComboBox hereda
todas las propiedades de JComponent y dene otras ms concretas. En
la Tabla 12-3 guran algunas propiedades especcas de JComboBox.
Tabla 12-3 Propiedades especcas de los componentes
Propiedades Mtodos
Cantidad mxima de
las
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)
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 deniendo
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 grca 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
conguraciones 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 especicar la posicin del componente. Si no se especica,
se coloca automticamente en el centro. Cualquier espacio sobrante lo
usa el componente de la zona central.
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 import java.awt.*;
2 import javax.swing.*;
3
4 public class EjemploZonas {
5 private JFrame f;
6 private JButton bn, bs, bw, be, bc;
7
8 public EjemploZonas() {
9 f = new JFrame("Border Layout");
10 bn = new JButton("Button 1");
11 bc = new JButton("Button 2");
12 bw = new JButton("Button 3");
13 bs = new JButton("Button 4");
14 be = new JButton("Button 5");
15 }
16
17 public void launchFrame() {
18 f.add(bn, BorderLayout.NORTH);
19 f.add(bs, BorderLayout.SOUTH);
20 f.add(bw, BorderLayout.WEST);
21 f.add(be, BorderLayout.EAST);
22 f.add(bc, BorderLayout.CENTER);
23 f.setSize(400,200);
24 f.setVisible(true);
25 }
26
28 EjemploZonas guiWindow2 = new EjemploZonas();
29 guiWindow2.launchFrame();
30 }
31 }
Administrador de diseo FlowLayout
FlowLayout coloca los componentes en una la. 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 especicar el espacio vertical y horizontal
que debe haber entre los componentes. Si no se especica, se utiliza
una distancia predeterminada de cinco unidades en ambas direcciones.
La Figura 12-7 contiene un ejemplo de colocacin en la. 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
3
4 public class EjemploFila {
5 private JFrame f;
6 private JButton b1;
11
12 public EjemploFila() {
13 f = new JFrame("Ejemplo GUI");
14 b1 = new JButton("Button 1");
19 }
20
22 f.setLayout(new FlowLayout());
23 f.add(b1);
24 f.add(b2);
25 f.add(b3);
26 f.add(b4);
27 f.add(b5);
28 f.pack();
30 }
31
33 EjemploFila guiWindow = new EjemploFila();
34 guiWindow.launchFrame();
35 }
36
37 } // 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.
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.
Administrador de diseo GridLayout
GridLayout coloca los componentes en las y columnas. Cada
componente ocupa la misma cantidad de espacio en el contenedor.
Al crear el diseo de la cuadrcula, es preciso especicar el nmero
de las y columnas. Si no se especica, el administrador crea una la
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
3
4 public class EjemploCuadricula {
5 private JFrame f;
6 private JButton b1, b2, b3, b4, b5;
7
8 public EjemploCuadricula() {
9 f = new JFrame("Ejemplo Cuadricula");
15 }
16
18 f.setLayout (new GridLayout(3,2));
19
20 f.add(b1);
21 f.add(b2);
22 f.add(b3);
23 f.add(b4);
24 f.add(b5);
25
26 f.pack();
28 }
29
31 EjemploCuadricula grid = new EjemploCuadricula();
32 grid.launchFrame();
33 }
34 }
Administrador de diseo GridBagLayout
GridBagLayout organiza los componentes en las y columnas, de forma
similar a la del diseador de cuadrculas, pero, para mayor exibilidad,
incluye opciones para cambiar el tamao y especicar la posicin de
los componentes. Es un diseo utilizado para crear interfaces complejas.
Las restricciones aplicadas a los componentes se especican 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
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 grcas del IDE NetBeans.
Para obtener ms informacin, consulte:
http://java.sun.com/docs/books/tutorial/uiswing/layout/group.html.
Creacin de interfaces grficas de usuario
Creacin de interfaces grcas de usuario
Las interfaces grcas 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 grcas. 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 grcas 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 grca 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 denida como Hello World.
Cdigo 12-4 Aplicacin HelloWorldSwing
2 public class HelloWorldSwing {
3 private static void createAndShowGUI() {
4 JFrame frame = new JFrame("HelloWorldSwing");
5 // Define la ventana.
6 frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
7 JLabel label = new JLabel("Hello World");
8 // Agrega la etiqueta
9 frame.add(label);
10 frame.setSize(300,200);
11 // Muestra la ventana en la pantalla
12 frame.setVisible(true);}
13
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 grca 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.
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 denir el marco y agregar la etiqueta.
a. setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE): este
mtodo dene el comportamiento de JFrame cuando se
inicia una operacin de cierre. Hay cuatro formas posibles
de manejar esta situacin.
JFrame
JLabel
BorderLayout
FrameTitle
1. DO_NOTHING_ON_CLOSE: no realiza ninguna accin cuando
se inicia la operacin de cierre. Esta constante se dene
en WindowsConstants.
2. HIDE_ON_CLOSE: llama a cualquier posible objeto
WindowListener y oculta el marco. Esta constante se
dene en WindowConstants.
3. DISPOSE_ON_CLOSE: llama a cualquier posible objeto
WindowListener, oculta el marco y lo cierra. Esta constante
se dene en WindowConstants.
4. EXIT_ON_CLOSE: cierra la aplicacin. Esta constante se
dene 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
denen cinco mtodos sobrescritos diferentes.
2. Mtodos para asegurar la eciencia de la interfaz en cuanto a la
ejecucin de hilos.
Conseguir que la interfaz grca se represente en la pantalla de
una forma eciente implica varias tareas. stas pueden denirse
de la forma siguiente:
a. Ejecucin del cdigo de la aplicacin.
Esto implica iniciar la aplicacin de la interfaz grca y ejecutar
el cdigo para representarla en pantalla.
b. Control de los eventos generados desde la interfaz.
Los componentes de una interfaz grca pueden generar
diferentes eventos. Por ejemplo, cada vez que se selecciona un
botn, se genera un evento. Para controlarlo es preciso denir
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
eciente y gil de respuesta. Este tipo de actividades se
gestionan a travs de esta tarea.
Para manejar estas tareas de una forma ecaz, 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 dene un mtodo run que deben
implementar todas las clases que utilicen esa interfaz. El
mtodo invokeLater programa la tarea de creacin de la
interfaz grca de forma que el hilo de control de eventos
ejecute el mtodo run de forma asncrona una vez que
hayan nalizado todos los eventos pendientes.
13-1
Mdulo 13
Control deloseventosgeneradospor la
interfazgrca
Objetivos
para:
Denir el concepto de eventos y su manejo.
Examinar el modelo de eventos de Java SE.
Describir el comportamiento de la interfaz grca.
Determinar la accin del usuario que ha originado un evento.
Desarrollar receptores de eventos.
Describir la concurrencia en interfaces grcas basadas en el API
Swing y las caractersticas de la clase SwingWorker.
Otros recursos
Otros recursos
2006.
Bates, Sierra. Head First Java, Second Edition. OReilly Media. 2005.
Qu es un evento
Control de los eventos generados por la interfaz grca 13-3
Qu es un evento
Cuando el usuario realiza una accin en la interfaz grca (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
grca, JVM crea un objeto evento que se enva al controlador de eventos
correspondiente a ese botn mediante una llamada al mtodo
actionPerformed.
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 modicador 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 identica la accin
y el comando asociado.
JFrame
JPanel
JButton
El usuario hace clic en el botn
Un controlador de eventos
actionPerformed(ActionEvent e) {
...
}
ActionEvent
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.
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.
Figura 13-2 Modelo de delegacin de eventos con varios receptores
Los eventos son objetos que slo se notican a los receptores registrados.
Cada evento tiene su correspondiente receptor, que indica qu mtodos
deben estar denidos en una clase adecuada para recibir ese tipo de
evento. La clase que implementa la interfaz dene esos mtodos y
puede estar registrada como receptor de eventos.
Los eventos procedentes de componentes que no tienen ningn receptor
registrado no se propagan.
JFrame
JPanel
JButton
El usuario hace clic en un botn
Otro controlador de eventos
Un controlador de eventos
...
}
...
}
ActionEvent
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
3
4 public class TestBoton {
5 private JFrame f;
6 private JButton b;
7
8 public TestBoton() {
9 f = new JFrame("Test");
10 b = new JButton("Pulsar");
11 b.setActionCommand("ButtonPressed");
12 }
13
15 b.addActionListener(new ButtonHandler());
16 f.add(b,BorderLayout.CENTER);
17 f.pack();
19 }
20
22 TestBoton guiApp = new TestBoton();
23 guiApp.launchFrame();
24 }
25 }
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 import java.awt.event.*;
2
3 public class ButtonHandler implements ActionListener {
4 public void actionPerformed(ActionEvent e) {
5 System.out.println("Se ha realizado una accin");
6 System.out.println("El comando del botn es: "
7 + e.getActionCommand());
8 }
9 }
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 dene 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.
Comportamiento de la interfaz grfica
Comportamiento de la interfaz grca
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 grcas segn el modelo UML.
Figura 13-3 Jerarqua de clases de eventos de la interfaz grca
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
denicin de uno o varios mtodos. La llamada a estos mtodos se realiza
cuando se producen determinados eventos. En la Tabla 13-1 guran estas
categoras e interfaces.
j
a
v
a
.
u
t
i
l
.
E
v
e
n
t
O
b
j
e
c
t
j
a
v
a
.
a
w
t
.
A
W
T
E
v
e
n
t
ActionEvent
AdjustmentEvent
ComponentEvent
TextEvent
ContainerEvent
FocusEvent
InputEvent
WindowEvent
KeyEvent
MouseEvent
java.awt.event
ItemEvent
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)
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)
Tabla 13-1 Categoras de eventos, mtodos e interfaces (Continuacin)
Categora Nombre de la interfaz Mtodos
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
4
5 public class TwoListener
6 implements MouseMotionListener, MouseListener {
7 private JFrame f;
8 private JTextField tf;
9
10 public TwoListener() {
11 f = new JFrame("Ejemplo de dos receptores");
12 tf = new JTextField(30);
13 }
14
16 JLabel label = new JLabel("Hacer clic y arrastrar el ratn");
17 // Agregar componentes al marco
18 f.add(label, BorderLayout.NORTH);
19 f.add(tf, BorderLayout.SOUTH);
20 // Agregar este objeto como listener
21 f.addMouseMotionListener(this);
22 f.addMouseListener(this);
23 // Definir el tamao del marco y hacerlo visible
24 f.setSize(300, 200);
26 }
27
28 // stos son eventos de MouseMotionListener
29 public void mouseDragged(MouseEvent e) {
30 String s = "Arrastre del ratn: X = " + e.getX()
31 + " Y = " + e.getY();
32 tf.setText(s);
33 }
34
35 public void mouseEntered(MouseEvent e) {
36 String s = "El ratn ha entrado";
37 tf.setText(s);
38 }
39
40 public void mouseExited(MouseEvent e) {
41 String s = "El ratn ha salido";
42 tf.setText(s);
43 }
44
45 // Mtodo de MouseMotionListener no utilizado.
46 // Todos los mtodos de un listener deben estar presentes en la
47 // clase, aunque no se utilicen.
48 public void mouseMoved(MouseEvent e) { }
49
50 // Mtodos de MouseListener no utilizados.
51 public void mousePressed(MouseEvent e) { }
52 public void mouseClicked(MouseEvent e) { }
53 public void mouseReleased(MouseEvent e) { }
54
56 TwoListener two = new TwoListener();
57 two.launchFrame();
58 }
59 }
Una serie de puntos mostrados en el Cdigo 13-3 de la pgina 13-10 se
describen en los prrafos siguientes.
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.
El mecanismo de recepcin de eventos permite hacer una llamada a
un mtodo addXxxListener() tantas veces como sea necesario y
especicar 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
denido. En general, si el orden de llamada es importante, signica que
los mtodos estn relacionados. En este caso, registre nicamente el
primer receptor de eventos y haga que ste llame directamente a los otros.
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
reere a las interfaces MouseListener y WindowListener.
Por ejemplo, la interfaz MouseListener declara los mtodos siguientes:
public void mouseClicked(MouseEvent event)
public void mouseEntered(MouseEvent event)
public void mouseExited(MouseEvent event)
public void mousePressed(MouseEvent event)
public void 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
4
5 public class MouseClickHandler extends MouseAdapter {
6
7 // Slo necesitamos el mtodo mouseClicked, as que usamos
8 // un adaptador para no tener que escribir
9 // todos los mtodos de control de eventos
10
11 public void mouseClicked(MouseEvent e) {
12 // Realiza acciones al pulsar el botn del ratn...
13 }
14 }
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
4 public class TestInner {
5 private JFrame f;
7
8 public TestInner() {
9 f = new JFrame("Ejemplo de clases internas");
11 }
12
13 class MyMouseMotionListener extends MouseMotionAdapter {
15 String s = "Arrastre del ratn: X = "+ e.getX()
16 + " Y = " + e.getY();
17 tf.setText(s);
18 }
19 }
20
23 // Agrega componentes al marco
26 // Agrega un Listener que utiliza una clase interna
27 f.addMouseMotionListener(new MyMouseMotionListener());
28 f.addMouseListener(new MouseClickHandler());
29 // Define el tamao del marco y lo hace visible
30 f.setSize(300, 200);
32 }
33
35 TestInner obj = new TestInner();
36 obj.launchFrame();
37 }
38 }
Control de eventos mediante clases annimas
Es posible incluir una denicin de clase completa dentro del mbito
de una expresin. Esta frmula permite denir 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
4
5 public class TestAnonymous {
6 private JFrame f;
8
9 public TestAnonymous() {
10 f = new JFrame("Ejemplo de clases annimas");
12 }
13
16 // Agrega componentes al marco
19 // Agrega un Listener que utiliza una clase annima
20 f.addMouseMotionListener(new MouseMotionAdapter() {
22 String s = "Arrastre del ratn: X = "+ e.getX()
23 + " Y = " + e.getY();
24 tf.setText(s);
25 }
26 }); // <- observar el parntesis de cierre
27 f.addMouseListener(new MouseClickHandler()); // No se muestra
28 // Define el tamao del marco y lo hace visible
29 f.setSize(300, 200);
31 }
32
34 TestAnonymous obj = new TestAnonymous();
35 obj.launchFrame();
36 }
37 }
Nota: La compilacin de una clase annima genera un archivo del tipo
TestAnonymous$1.class.
Concurrencia en Swing
Concurrencia en Swing
Las aplicaciones que contienen una interfaz grca necesitan varios
hilos para manejar esa interfaz de una forma eciente.
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 grca 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.
14-1
Mdulo 14
Aplicacionesbasadasenlainterfazgrca
Objetivos
para:
Explicar cmo construir una barra de mens, un men y opciones de
men en una interfaz grca Java.
Saber cambiar el color y el tipo de letra de un componente.
Aspectos relevantes
Aspectos relevantes
?
!
Ahora ya sabe cmo congurar una interfaz grca Java para
obtener resultados grcos y permitir la interaccin del usuario.
Sin embargo, slo se han descrito algunos de los componentes
que se utilizan para construir interfaces grcas. Qu otros
componentes seran tiles en una interfaz grca?
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
Cmo se crea un men para el marco de la interfaz grca?
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
Creacin de un men
Aplicaciones basadas en la interfaz grca 14-3
Creacin de un men
JMenu diere 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 otantes 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.
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 modicarse en funcin del estado del programa para que
aparezcan mens diferentes segn la situacin.
Cdigo 14-1 JMenuBar
10 f = new JFrame("JMenuBar");
11 mb = new JMenuBar();
12 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.
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 f = new JFrame("Menu");
15 m1 = new JMenu("File");
16 m2 = new JMenu("Edit");
17 m3 = new JMenu("Help");
18 mb.add(m1);
19 mb.add(m2);
20 mb.add(m3);
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.
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 mi1 = new JMenuItem("New");
29 mi2 = new JMenuItem("Save");
30 mi3 = new JMenuItem("Load");
31 mi4 = new JMenuItem("Quit");
32 mi1.addActionListener(this);
36 m1.add(mi1);
37 m1.add(mi2);
38 m1.add(mi3);
39 m1.addSeparator();
40 m1.add(mi4);
Este cdigo genera la salida siguiente:
Figura 14-3 Componente JMenuItem
En general, para denir el comportamiento de un men se agrega un
elemento ActionListener al objeto JMenuItem.
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");
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);
...........
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.
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 denir 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 predenidos
se encuentra en la pgina de la documentacin relativa a la clase Color.
Otra solucin consiste en construir un objeto Color especco y denir 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);
15-1
Mdulo 15
Hilos
Objetivos
para:
Denir 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 dicultades 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.
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?
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
Hilos
Hilos 15-3
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.
Figura 15-1 Partes de un hilo
CPU
Cdigo
Datos
Hilo o
contexto de ejecucin
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
denen su contexto vienen especicados 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 public class ThreadTester {
3 HelloRunner r = new HelloRunner();
4 Thread t = new Thread(r);
5 t.start();
6 }
7 }
8
9 class HelloRunner implements Runnable {
10 int i;
11
12 public void run() {
13 i = 0;
14
15 while (true) {
16 System.out.println(Hola + i++);
17 if ( i == 50 ) {
18 break;
Hilos
Hilos 15-5
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).
Figura 15-2 Creacin de hilos
CPU
Cdigo
Datos
Clase
Instancia r
Thread t
}
Nuevo hilo
de HelloRunner
HelloRunner
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 signica que es posible planicar su ejecucin por parte
de la mquina virtual de Java (JVM). Esto no signica 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 planicacin 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.
Hilos
Hilos 15-7
Un objeto Thread puede pasar por diferentes estados a lo largo de su ciclo
de vida, como se muestra en la Figura 15-3.
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 planicacin de hilos
1 public class Runner implements Runnable {
3 while (true) {
4 // hacer numerosas tareas
5 // ...
6 // Dar a otros hilos una oportunidad
7 try {
8 Thread.sleep(10);
9 } catch (InterruptedException e) {
10 // El periodo de espera de este hilo ha
11 // sido interrumpido por otro hilo
12 }
13 }
14 }
15 }
Ejecutable
Nuevo
Muerto
En
Planificador
Bloqueado
Desbloqueado Evento bloqueado
run() Finaliza
start()
ejecucin
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
nalice 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 naliza, no puede volverse a
ejecutar.
Es posible detener los hilos utilizando un indicador que determina que el
mtodo run debe nalizar.
1 public class Runner implements Runnable {
2 private boolean timeToQuit=false;
3
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 public class ThreadController {
2 private Runner r = new Runner();
3 private Thread t = new Thread(r);
4
5 public void startThread() {
6 t.start();
7 }
8
Hilos
Hilos 15-9
9 public void stopThread() {
10 // usar una instancia especfica de Runner
11 r.stopRunning();
12 }
13 }
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 public class NameRunner implements Runnable {
3 while (true) {
4 // numerosas tareas
5 }
6 // Mostar en pantalla el nombre del hilo actual
7 System.out.println("El hilo");
8 + Thread.currentThread().getName()
9 + " ha terminado");
10 }
11 }
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 nalizado 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 dene 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 naliza 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:
El hilo que se reactiva tiene mayor prioridad.
El hilo en ejecucin se bloquea por alguna otra razn.
Hilos 15-11
Mtodo join
El mtodo join hace que el hilo actual espere hasta que nalice el hilo en
el que se ha realizado la llamada a join. Por ejemplo:
2 Thread t = new Thread(new Runner());
3 t.start();
4 ...
5 // Realizar tareas en paralelo con el otro hilo durante un tiempo
6 ...
7 // Esperar aqu hasta que termine el hilo en ejecucin
8 try {
9 t.join();
11 // t ha vuelto antes de tiempo
12 }
13 ...
14 // Ahora continuar en este hilo
15 ...
16 }
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 naliza 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.
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 public class MyThread extends Thread {
3 while ( true ) {
4 // hace numerosas tareas
5 try {
6 Thread.sleep(100);
8 // periodo de inactividad interrumpido
9 }
10 }
11 }
12
14 Thread t = new MyThread();
15 t.start();
16 }
17 }
Hilos 15-13
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 modique 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 preera 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.
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 public class MiPila {
2 int idx = 0;
3 char [] data = new char[6];
4
5 public void push(char c) {
6 data[idx] = c;
7 idx++;
8 }
9
10 public char pop() {
11 idx--;
12 return data[idx];
13 }
14 }
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.
Hilos 15-15
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 conguracin 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.
Una forma de hacerlo sera impedir que el hilo a interrumpa su ejecucin
hasta que nalice 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 modicado:
public class MiPila {
...
public void push(char c) {
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).
Figura 15-4 Uso de la sentencia synchronized antes de un hilo
Objeto this
synchronized (this) {
data[idx] = c;
idx++;
}
}
Hilo antes de la sentencia synchronized(this)
Cdigo o
comportamiento
Datos o
estado
Hilos 15-17
En la Figura 15-5 puede verse un ejemplo de uso de la sentencia
synchronized despus de un hilo.
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.
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.
Objeto this
data[idx] = c;
idx++;
}
}
Hilo despus de la sentencia synchronized(this)
Cdigo o
comportamiento
Datos o
estado
Objeto this
public char pop() {
idx--;
return data[idx];
}
}
Otro hilo que intenta
En espera del
Indicador de bloqueo ausente
bloqueo del objeto
Cdigo o
comportamiento
Datos o
estado
ejecutar synchronized(this)
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 nal 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 transeran 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 simplican el manejo de bloques sincronizados bastante
ms que las utilidades equivalentes en algunos otros sistemas.
Hilos 15-19
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 denicin 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 modicador 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 modicador
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.
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.
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 n de su bloque synchronized. Como ninguno puede
proseguir, ninguno puede pasar el nal 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.
Bloqueado en el
grupo de bloqueo
del objeto
Ejecutable
Nuevo
Muerto
En Planificador
Bloqueado
run() Finaliza
Bloqueo adquirido Sincronizado
start()
ejecucin
Interaccin de los hilos: waity notify
Hilos 15-21
Interaccin de los hilos: waity 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 notica 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.
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.
Hilos 15-23
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 nal.
Figura 15-8 Diagrama de estados de un hilo con wait y notify
Bloqueado en el
grupo de espera
del objeto
notify() o
Bloqueado en el
grupo de bloqueo
del objeto
Ejecutable
Nuevo
Muerto
En
Planificador
Bloqueado
run() Finaliza
Bloqueo adquirido Sincronizado
interrupt()
wait()
[Ha de tener el bloqueo]/
Libera el bloqueo
start()
ejecucin
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 noticacin del objeto que controla ese grupo. No disee nunca
cdigo donde los hilos deban recibir noticacin sobre situaciones
diferentes en el mismo grupo de espera.
Ejemplo de interaccin de hilos
Hilos 15-25
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();
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 package mod13;
2
3 public class Producer implements Runnable {
4 private SyncStack theStack;
5 private int num;
7
8 public Producer (SyncStack s) {
9 theStack = s;
10 num = counter++;
11 }
12
14 char c;
15
16 for (int i = 0; i < 200; i++) {
17 c = (char)(Math.random() * 26 +A);
18 theStack.push(c);
19 System.out.println(Productor + num + : + c);
20 try {
21 Thread.sleep((int)(Math.random() * 300));
23 // hacer caso omiso
24 }
25 }
26 } // FIN del mtodo run
27
28 } // 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 identicador para el cual se ejecuta el hilo productor.
Hilos 15-27
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;
7
8 public Consumer (SyncStack s) {
9 theStack = s;
10 num = counter++;
11 }
12
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));
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 identicador 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.
Clase SyncStack
El bfer de un objeto SyncStack recin construido debera estar vaco.
Puede utilizar el cdigo siguiente para construir la clase:
public class SyncStack {
private List<Character> buffer
= new ArrayList<Character>(400);
public synchronized char pop() {
// cdigo de extraccin (pop) aqu
}
public synchronized void push(char c) {
// cdigo de introduccin (push) aqu
}
}
No hay constructores. Se considera una buena prctica incluir un
constructor, pero aqu se ha omitido para mayor brevedad.
Mtodo pop
Veamos ahora los mtodos push y pop. Deben estar sincronizados
(synchronized) para proteger el bfer compartido. Asimismo, si la pila
est vaca en el mtodo pop, el hilo que se est ejecutando debe esperar.
Cuando la pila del mtodo push deja de estar vaca, los hilos en espera
reciben la noticacin correspondiente. El Cdigo 15-4 contiene un
ejemplo del mtodo pop.
Cdigo 15-4 Mtodo pop
1 public synchronized char pop() {
2 char c;
3 while (buffer.size() == 0) {
4 try {
5 this.wait();
7 // hacer caso omiso...
8 }
9 }
10 c = buffer.remove(buffer.size()-1);
11 return c;
12 }
Hilos 15-29
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 n 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 noticar a los hilos en espera que la pila ya no
est vaca. Esta noticacin se realiza con respecto al objeto stack.
El Cdigo 15-4 muestra cmo se utiliza el mtodo push.
Cdigo 15-5 Mtodo push
1 public synchronized void push(char c) {
2 this.notify();
3 buffer.add(c);
4 }
5
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 package mod13;
2
4
5 public class SyncStack {
6 private List<Character> buffer
7 = new ArrayList<Character>(400);
8
9 public synchronized char pop() {
10 char c;
11 while (buffer.size() == 0) {
12 try {
13 this.wait();
15 // hacer caso omiso...
16 }
17 }
18 c = buffer.remove(buffer.size()-1);
19 return c;
20 }
21
22 public synchronized void push(char c) {
23 this.notify();
24 buffer.add(c);
25 }
26 }
Hilos 15-31
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 package mod13;
2
3 public class SyncTest {
4
6
7 SyncStack stack = new SyncStack();
8
9 Producer p1 = new Producer(stack);
10 Thread prodT1 = new Thread (p1);
11 prodT1.start();
12
13 Producer p2 = new Producer(stack);
14 Thread prodT2 = new Thread (p2);
15 prodT2.start();
16
17 Consumer c1 = new Consumer(stack);
18 Thread consT1 = new Thread (c1);
19 consT1.start();
20
21 Consumer c2 = new Consumer(stack);
22 Thread consT2 = new Thread (c2);
23 consT2.start();
24 }
25 }
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
Productor1: V
Consumidor2: V
Consumidor1: N
Productor2: V
Productor2: U
Consumidor2: U
Consumidor2: V
Productor1: F
Consumidor1: F
Productor2: M
Consumidor2: M
Consumidor2: T
16-1
Mdulo 16
Conexinenred
Objetivos
para:
Desarrollar cdigo para congurar 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.
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?
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
Conexin en red
Conexin en red 16-3
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 ujos. Un socket puede contener dos ujos:
un ujo de entrada y un ujo de salida. Un proceso enva datos a otro
por la red escribiendo en el ujo de salida asociado al socket. Un
proceso lee los datos que ha escrito otro proceso leyndolos en el ujo
de entrada asociado al socket.
Una vez congurada la conexin de red, el uso de los ujos asociados a
esa conexin es similar al uso de cualquier otro ujo.
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
En este modulo se describen las conexiones de red TCP/IP. La Figura 16-1
muestra un ejemplo de conexin en red.
Figura 16-1 Ejemplo de diagrama de conexiones en red
client.bar.com
client.baz.com
server.foo.com
18000
18002
3000
Conexin en red
Conexin en red 16-5
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 denir la nalidad 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 especco 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 predenidos 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 especica los nmeros de puerto del servidor, que se utilizan
para identicar 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
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.
Figura 16-2 Conexiones de sockets TCP/IP
En la Figura 16-2:
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
ServerSocket
Flujo de salida
Flujo de entrada
Socket.close()
Cliente
Socket (host, n de puerto)
Flujo de salida
Flujo de entrada
Socket.close()
Registrarse en
este servicio
Esperar
conexin
(intento de conexin) Socket()
ServerSocket.accept()
(n de puerto)
Servidor TCP/IP mnimo
Conexin en red 16-7
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 simplica considerablemente el procedimiento de
conexin al servidor.
1 import java.net.*;
2 import java.io.*;
3
4 public class ServidorSimple {
6 ServerSocket s = null;
7
8 // Registra el servicio en el puerto 5432
9 try {
10 s = new ServerSocket(5432);
13 }
14
15 // Ejecuta ininterrumpidamente el bucle de recepcin/aceptacin
16 while (true) {
17 try {
18 // Espera aqu y recibe una conexin
19 Socket s1 = s.accept();
20
21 // Obtiene el flujo de salida asociado al socket
22 OutputStream s1out = s1.getOutputStream();
23 BufferedWriter bw = new BufferedWriter(
24 new OutputStreamWriter(s1out));
25
26 // Enva la cadena
27 bw.write(Bienvenido a la red\n);
28
29 // Cierra la conexin, pero no el socket del servidor
30 bw.close();
31 s1.close();
34 }
35 }
36 }
37 }
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 import java.net.*;
2 import java.io.*;
3
4 public class ClienteSimple {
6 try {
7 // Establece la conexin con el servidor en el puerto 5432
8 // aqu se utiliza el host local
9 Socket s1 = new Socket(127.0.0.1, 5432);
10
11 // Obtiene un flujo de entrada del socket
12 InputStream is = s1.getInputStream();
13 // Lo adorna con un flujo de entrada de datos
14 DataInputStream dis = new DataInputStream(is);
15
16 // Lee la entrada y la presenta en pantalla
17 System.out.println(dis.readUTF());
18
19 // Al terminar, basta con cerrar el flujo y la conexin
20 br.close();
21 s1.close();
22 } catch (ConnectException connExc) {
23 System.err.println(Imposible conectar.);
25 // ignorar
26 }
27 }
28 }
A-1
Apndice A
ElementosdeprogramacinJavaavanzada
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.
Introduccin a la arquitectura de dos y de tres capas
A-2 Lenguaje de programacin Java
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 denida.
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 trco 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 ecacia las cuestiones de
escalabilidad, rendimiento y particionamiento lgico.
Arquitectura de tres capas
Elementos de programacin Java avanzada A-3
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 trco 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.
Figura A-1 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 grca (capa de presentacin), escribira la interfaz grca
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 denir todas las reglas empresariales con las que
manipular los datos. Los cambios de poltica empresarial pueden
afectar a esta capa sin inuir 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.
Datos
Funcionalidad/lgica
empresarial
Presentacin
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 especco 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.
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.
Aplicacin
frontal
(cliente)
Servidor de base
(back-end)
Base
Solicitud SQL
Respuesta SQL
de datos
de datos
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.
Figura A-3 Arquitectura centrada en aplicaciones
Aplicacin
(frontal)
(Capa intermedia)
Lgica de negocio
Base de datos
Servidor de
(back-end)
Consulta SQL
Respuesta SQL
base de datos
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 especicacin 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.
Figura A-4 Capas de una aplicacin JDBC
Aplicacin Java
Administrador de
controladores JDBC
API JDBC
Controlador JDBC,
protocolos tipo n
SGBD
Bases
controladores
JDBC
API de
controlador de
SGBD
de datos
Controladores JDBC
Las aplicaciones Java utilizan el API JDBC para conectarse a una base de
datos mediante un controlador de base de datos. Casi todos los motores
de base de datos llevan asociados distintos tipos de controladores JDBC.
JavaSoft ha denido 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.
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 especco 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.
Aplicacin
Administrador de controladores JDBC
Puente JDBC-ODBC
Administrador de controladores ODBC
Bibliotecas de controladores ODBC
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 exibilidad 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 dene 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.
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 Capas de una arquitectura RMI
Cliente RMI
Stubs
Capa de
referencia remota
Capa de
Servidor RMI
Esqueleto
Capa de
referencia remota
Capa de
virtual
Conexin
Conexin
de red
Aplicacin Aplicacin
transporte transporte
RMI
La capa de transporte crea y mantiene las conexiones fsicas entre el
cliente y el servidor. Administra el ujo 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:
1. Denicin 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 especicacin que dene cmo interaccionan los objetos
distribuidos. La especicacin CORBA est controlada por el Object
Management Group (OMG), un consorcio abierto de ms de 700
compaas que trabajan conjuntamente para denir 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 Denition
Language, lenguaje de denicin 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.
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 denir
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:
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
exibilidad 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 beneciarse del
uso de la tecnologa RMI, siempre que la direccin de la empresa no
la considere una tecnologa inmadura.
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 especicacin JavaBeans 1.00-A
dene cinco servicios principales:
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 noticar 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 denir 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 denen 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.
Mtodos
Los mtodos son operaciones que permiten interaccionar con un bean.
Los beans reciben noticacin 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
especicacin 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 denen (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 denir la informacin del bean. De forma
predeterminada, se crea un objeto BeanInfo cuando la introspeccin se
ejecuta en el bean (Figura A-7).
Figura A-7 Ejemplo de interaccin de beans
Contenedor A Contenedor B
Bean 1
Bean 2
Bean 3
Bean 4
Bean 5
Bean 6
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.
Modicar 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.
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 rmar
digitalmente cada entrada en un archivo JAR para autenticar 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 modicar fcilmente
para adaptarla a un archivo JAR. El archivo JAR del servidor se identica
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>
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
identicar 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 signicado y con
qu declaraciones se pueden utilizar.
Ejemplo
El siguiente ejemplo se utiliza en las pruebas de javadoc:
1 /*
2 * This is an example using javadoc tags.
3 */
4
5 package mypack;
6
8
9 /**
10 * This class contains a bunch of documentation tags.
11 * @author Bryan Basham
12 * @version 0.5(beta)
13 */
14 public class DocExample {
15
16 /** A simple attribute tag. */
17 private int x;
18
19 /**
20 * This variable a list of stuff.
21 * @see #getStuff()
22 */
23 private List stuff;
24
25 /**
26 * This constructor initializes the x attribute.
27 * @param x_value the value of x
28 */
29 public DocExample(int x_value) {
30 this.x = x_value;
31 }
32
33 /**
34 * This method return some stuff.
35 * @throws IllegalStateException if no stuff is found
36 * @return List the list of stuff
37 */
38 public List getStuff()
39 throws IllegalStateException {
40 if ( stuff == null ) {
41 throw new java.lang.IllegalStateException("ugh, no stuff");
42 }
43 return stuff;
44 }
45 }
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
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 Ejemplo con la opcin private
B-1
Apndice B
Guadeconsultarpidasobreel lenguajeUML
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.
Otros recursos
B-2 Lenguaje de programacin Java
Otros recursos
complementaria sobre los temas descritos en este apndice:
Booch, Grady, James Rumbaugh e Ivar Jacobson. The Unied
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 Unied Modeling Language
Specication, 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/.
Principios bsicos del lenguaje UML
Gua de consulta rpida sobre el lenguaje UML B-3
El lenguaje UML (Unied Modeling Language, lenguaje unicado de
modelado) es un lenguaje grco para modelar sistemas informticos.
UML no es un lenguaje de programacin, sino un conjunto de diagramas
que pueden utilizarse para especicar, 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 edicio. El lenguaje UML contiene diagramas que ayudan a lo
largo de todo el proceso de desarrollo de una aplicacin, desde la
identicacin de los requisitos hasta el diseo, pasando por su
codicacin, 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 unicar 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
especicacin 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 (Unied Software Development Process, proceso
unicado 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 ecaces de anlisis y diseo con el lenguaje UML, el
mtodo USDP y patrones de software.
El lenguaje UML dene 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 ujos
de trabajo de identicacin 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 especcos y
los enlaces entre ellas. Es una
instantnea de los objetos del
sistema en un momento dado.
Los diagramas de objetos
permiten claricar o validar el
diagrama de clases.
Actividades Un diagrama de actividades es
bsicamente un organigrama con
smbolos nuevos. Representa el
ujo de actividades de un proceso
o algoritmo.
Los diagramas de actividades
permiten modelar sistemas
empresariales reales durante el
ujo de trabajo de
identicacin 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.
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
signicativos.
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
congurar un sistema
distribuido. Los componentes
de software pueden mostrarse
dentro de los nodos fsicos para
ilustrar cmo van a instalarse.
Tabla B-1 Tipos de diagramas UML (Continuacin)
Nombre del
diagrama
Descripcin Uso
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 especcos 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.
Figura B-1 Ejemplo de paquete
Package name
Subpackage
i
m
p
o
r
t
i
m
p
o
r
t
Company Vehicle
RiverBarge Truck
0..* owns
Package dependency Model elements
Package container
shipping
domain
GUI
reports
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;
public class Vehiculo {
// 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 echa discontinua que va de un paquete a otro
indica que el paquete situado en la cola de la echa utiliza (importa)
elementos del paquete situado en la punta de la echa. Por ejemplo,
informes utiliza elementos del paquete dominio de esta manera:
package transporte.informes;
import transporte.dominio.*;
public class InformeCapacidadVehiculo {
// 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.
Elementos generales
Estereotipos
Los creadores del lenguaje UML se dieron cuenta de que no podan
construir un lenguaje de modelado que satisciera 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 identicador 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 identicadores
de estereotipos pueden adornar las relaciones. Hay ms de cien
estereotipos estndar, pero tambin es posible crear estereotipos
personalmente para modelar la semntica propia.
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.
Figura B-3 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 reere. Si de la
nota no sale ningn enlace, su contenido se aplica al diagrama en general.
interface
Set
Stereotype tag
Vehicle3
-load : double
-maxLoad : double
+getLoad() : double
+getMaxLoad() : double
+addBox(weight : double) : boolean
weight in newtons
weight in kilograms
Annotation
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 especica que los objetos Jugador deben almacenarse
en una base de datos persistente. La restriccin siguiente especica que
el capitn y el segundo capitn tambin deben ser miembros de la
plantilla del equipo. La ltima restriccin especica el nmero mnimo
de jugadores por sexo.
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.
Figura B-5 Ejemplo de valores etiquetados
***
*
0
.
.
1
{persistent}
{Female players not fewer than 3
and male players not fewer than 4}
{member}
Player
Team
Constraint
r
o
s
t
e
r
c
a
p
t
a
i
n
c
o
-
c
a
p
t
a
i
n
{version=1.3}
CalcGUI.java
{processors=4}
Tagged value
Server
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 gura 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.
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 identicarse 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 Conrmar ingreso cliente.
Customer
Teller
Customer
ATM
Customer
Banking System
System name Actor node
Actor node
the customer
requests a balance
include
extend
the customer
asks for balance
extend
Checking
Deposit for
Customer
Determine
Balance
ATM Login
actor
BankTeller
ATM Withdrawal
Dependency
System boundary
Use case
node
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.
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.
Vehicle
-load : double = 0.0
-maxLoad : double
+getLoad() : double
+getMaxLoad() : double
+addBox(weight : double) : boolean
InputStream
interface
Company
Set {abstract}
1 2 3
4
Diagramas de clases
La Figura B-8 muestra los elementos de un nodo de clase.
Figura B-8 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 especica 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 especica 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 especica valor de retorno, no se devuelve ningn valor
(void). El nombre de los mtodos abstractos se escribe en cursiva.
Vehicle
- load : double = 0.0
- maxLoad : double
- destinations [1..*] : String
constructor
+ Vehicle(max_load : double)
accessor
+ getLoad() : double
+ getMaxLoad() : double
mutator
+ setMaxLoad(max : double)
business logic
+ addBox(weight : double) : boolean
# calcEngineEfficiency() : double
# calcTripDistance() : double
Access
modes
Abstract
methods
(in italics)
Attribute
name
Method
name
Parameter
name
Parameter
type
Return
type
Attribute
type
Attribute
multiplicity
Attribute
initial value
Class name
Attributes
Methods
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.
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.
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 static int counter = 0;
private int instanceNumber;
public static int getTotalCount() {
return counter;
}
public int getMyNumber() {
return instanceNumber;
}
}
Tabla B-2 Modos de acceso definidos en UML y smbolos correspondientes
Modo de acceso Smbolo
Privado -
Paquete privado ~
Protegido #
Pblico +
Count
-counter : int = 0
-instanceNumber : int
getTotalCount() : int
+getMyNumber() : int
Class scope
Diagramas de clases
Herencia
La Figura B-10 muestra la herencia de clases mediante la echa de
relacin de generalizacin.
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
}
interest_rate : double)
Account
-balance : double
constructors
+Account(init_balance : double)
methods
+getBalance() : double
+deposit(amt : double)
+withdraw(amt : double) : boolean
SavingsAccount
-interestRate : double
constructors
+SavingsAccount(init_balance : double,
CheckingAccount
constructors
+CheckingAccount(init_balance : double)
+CheckingAccount(init_balance : double,
methods
+withdraw(amt : double) : boolean
Generalization
arrow
Generalization
arrow
protect : SavingsAccount)
Diagramas de clases
Implementacin de una interfaz
La Figura B-11 muestra cmo utilizar la echa de realizacin para modelar
una clase que implementa una interfaz.
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
}
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
interface
HashMap
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.
Figura B-12 Asociaciones y roles de clases
En este diagrama, Imparte es el nombre de la asociacin y lleva una echa
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..*).
Multiplicity Multiplicity
Association name
Association roles
Association direction
Instructor Course
1 0..*
teacher class
Teaches
Diagramas de clases
En lenguaje de programacin Java, las asociaciones suelen representarse
en forma de un atributo de la clase al nal de la relacin (especicada
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.
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, denida 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.
Figura B-13 Ejemplo de agregacin y composicin
Division
L
e
a
g
u
e
Team
Schedule Game
1..* 1..*
1..* 1
Composition Aggregation
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.
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 especicar si ha
abandonado el partido.
Figura B-15 Clase de asociacin compleja
Association class
Division
Registration
Player
**
Team
Game
Association class
o
p
p
o
n
e
n
t
2
o
p
p
o
n
e
n
t
1
Result
-score : int
-forfeit : boolean
Diagramas de clases
El lenguaje Java puede utilizarse de maneras diferentes para representar
una clase de asociacin. Una manera es codicar la clase de asociacin
como clase Java estndar. Por ejemplo, Inscripcin puede codicarse
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 codicar 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...
}
Diagramas de clases
Otros elementos de una asociacin
Las asociaciones contienen diversas partes ms. Esta seccin presenta
las restricciones y los elementos calicadores.
Una restriccin de asociacin permite aumentar la semntica de dos o
ms asociaciones al introducir una echa 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.
Figura B-16 Otros elementos de una asociacin
Un calicador 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 identica 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 calicador (fecha,
franja horaria y nmero de campo) estara asignado a un ndice entero.
Division
L
e
a
g
u
e
Schedule Game
1..* *
1..* 0..1
Association qualifier
Association
constraint
index:int
A three dimensional array of:
event date, time slot, and field number
***
*
0
.
.
1
{member}
Player
Team
r
o
s
t
e
r
c
a
p
t
a
i
n
c
o
-
c
a
p
t
a
i
n
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 conguracin 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 denicin de clase. Adems, un
diagrama de objetos no muestra necesariamente todos los objetos
asociados; slo tiene que ser representativo.
Figura B-17 Ejemplo de diagrama de objetos
: League
type=SOCCER
: Division
schoolSize=SMALL
t1 : Team
name=Camden Windjammers
rank=1
record=<5,2>
t2 : Team
name=Rockport Seals
rank=4
record=<1,6>
t3 : Team
name=Portland Panthers
rank=2
record=<4,3>
t4 : Team
name=Bangor Bangles
rank=3
record=<2,5>
Object name
Object links
Object attributes
Anonymous object
Object class
La Figura B-18 muestra dos objetos, c1 y c2, acompaados de sus datos
de instancia. Hacen referencia al nodo de clase Count. La echa 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.
Figura B-18 Ejemplo de diagrama de objetos
Count
cl : Count
serialNumber=1
c2 : Count
serialNumber=2
-counter : int = 0
-serialNumber : int
instanceOf instanceOf
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.
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, vericar 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 echa 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.
Internet User
Actor
Link
Named
object
Anonymous
object Message
:Login
Servlet
:Login
Service
user
:User
:RDBMS
1:login 1.1:user:=login
1
.
1
.
1
:
S
E
L
E
C
T
.
.
.
1
.
1
.
2
:
c
r
e
a
t
e
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 modicaciones en la base de datos
con una sola transaccin.
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.
Path stereotype Object constraint
sessionBean
tnx
:UserTransaction
:Statement :Statement
customerDB
:Connection
inventorDB
:Connection
client
3.1:create 5.1:create
local
1:create
2:begin()
7:rollback()
10:destroy
{transient}
{transient}
{transient}
g
lo
b
a
l
3
:
c
r
e
a
t
e
S
t
a
t
e
m
e
n
t
(
)
l
o
c
a
l
4
:
e
x
e
c
u
t
e
U
p
d
a
t
e
(
.
.
.
)
lo
c
a
l
6
:
e
x
e
c
u
t
e
U
p
d
a
t
e
(
.
.
.
)
9
:
c
lo
s
e
(
)
g
lo
b
a
l
5
:
c
r
e
a
t
e
S
t
a
t
e
m
e
n
t
(
)
8
:
c
l
o
s
e
(
)
Diagramas de secuencia
Un diagrama de secuencia representa una secuencia cronolgica de
mensajes intercambiados entre varios objetos para reejar un
comportamiento determinado. Permite comprender el ujo 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.
Figura B-21 Ejemplo de diagrama de secuencia controlado por el usuario
Internet User
Anonymous
class role
Object
created
Named
class role Message
Return
(with value)
Activation
box
Lifeline
:Login
Servlet
:Login
Service
user
:User
:RDBMS
create
user:=login
"login"
SELECT * FROM User
WHERE user_name=?
Observe las echas de mensaje entre el servlet y el objeto service.
La echa es perfectamente horizontal, lo que indica que el mensaje
se implementa probablemente con la llamada del mtodo local.
Observe tambin que la echa 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.
Figura B-22 Diagrama de secuencia
Anonymous role
Object destroyed
Return
(Implicit)
sessionBean
:Statement
:Statement
inventorDB
:Connection
customerDB
:Connection
tnx
:UserTransaction
external
DBMS
{transient}
{transient}
{transient}
create
create
create
SQL Update
SQL Insert command
begin()
rollback()
close() destroy
destroy
close() destroy
createStatement
executeUpdate("INSERT INTO CustomerOrder(...)")
createStatement
executeUpdate("UPDATE ItemInventory SET...")
SQLException("Update failed.")
Este ejemplo muestra algunos detalles suplementarios sobre los
diagramas de secuencia. En primer lugar, la echa de retorno no
siempre es importante. Est implcita al nal 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 echa 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 n 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 echa:
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 denicin 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 nal. Por denicin,
ningn estado puede pasar al estado inicial y el estado nal no puede
pasar a ningn otro estado.
Figura B-23 Ejemplo de diagrama de estados
No hay ningn modo predenido para implementar un diagrama de
estados. En el caso de un comportamiento complejo, quiz sera
interesante considerar el uso del patrn de diseo State.
State node
Transition Initial state Final state
Blocked
Dead New
unblocked
Scheduler
blocking event
Running Runnable
start()
run() completes
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 nal: estado activo al nalizar la transicin.
La Figura B-24 muestra una transicin en detalle.
Figura B-24 Ejemplo de transicin de estado
Source state
Target state
Event trigger Guard condition
Running
[must have lock]/
Blocked in
objects
wait pool
wait()
releases lock
Action
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 naliza en un solo estado nal.
Figura B-25 Actividades y transiciones
Translate to HTML
Parse XML file
Render HTML in browser
Transition
Stop state
Start state
Activity
La Figura B-26 muestra las ramicaciones 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.
Figura B-26 Ramicaciones y bucles
n=inventory.getCount(p)
p=o.getNextProduct()
Verify availability
o.putOnBackOrder(p) inventory.setCount(p,n-1)
Guard
Branch
else
else [n>0]
[o.hasMoreProducts()]
La Figura B-27 muestra un diagrama de actividades ms complejo.
Figura B-27 Ejemplo de diagrama de actividades
Request Products
Wait for confirmation
Customer WebSalesAgent Warehouse
Schedule backorder Package products
Ship order
Verify availability
Charge credit card
Return confirmation
Close order
Object
flow
Fork
Join
Swimlanes
o:Order
[in progress]
o:Order
[pending]
o:Order
[sent]
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.
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).
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.
Figura B-29 Ejemplo de diagrama de componentes
Component
Applet.java calculator.jar
1 2 3
calculator.html calculator.jar
CalcGUI.class CalcApplet.class CalcModel.class
CalcGUI.java CalcApplet.java
{version=1.0} {version=1.3} {version=2.1}
CalcModel.java
Dependency
SCM version
Nota: SCM signica 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 echa orientada hacia el conector
depende de que el componente advierta esa interfaz.
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.
Catalog
Business
Delegate
Catalog
Home Stub
Catalog
EJB Home
Catalog
Remote Stub
Catalog
EJB Object
Catalog
Bean
catalog.jsp
CatalogHome CatalogHome
CatalogRemote CatalogRemote
CatalogRemote
Interface connector
Remote method calls
across a network using IIOP
Diagramas de distribucin
Diagramas de distribucin
Un diagrama de distribucin representa la red de elementos de recursos
de procesamiento y la conguracin 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.
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
congurar las capas lgicas de la arquitectura de una aplicacin en
una red fsica.
Client
serial port
Hardware node
Dependency Component
Node name
Communication protocol
HTTP
TCP/IP
Printer
Web Server
Apache
index.html
<HTML>
</HTML>
Browser
C-1
Apndice C
ComponentesSwing
Objetivos
para:
Describir el aspecto de cada componente Swing.
Ejemplos de componentes Swing
C-2 Lenguaje de programacin Java
Ejemplos de componentes Swing
Este apndice muestra ejemplos de numerosos componentes Swing junto
con una breve descripcin de cada uno.
Componentes Swing C-3
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 grca. 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 denir cuadros de
dilogo. Los cuadros de dilogo dependen
de los marcos y pueden utilizarse para
obtener informacin del usuario y conrmar
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.
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
Los paneles son contenedores
en los que es posible insertar
varios componentes. Tambin
presentan una supercie 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.
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 chas tambin
resultan prcticos cuando hay
limitaciones de espacio.
Constan de varias chas que
comparten el mismo espacio,
pero slo una es visible a la
vez. Si desea ver una cha, el
usuario debe seleccionarla.
Para crear paneles con
chas se utiliza la clase
javax.swing.JTabbedPane.
Tabla C-2 Contenedores genricos (Continuacin)
JInternalFrame y JLayeredPane son ejemplos de contenedores
especiales. Estos contenedores desempean un papel especco 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 especicar 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 especica con
un valor entero. Para crear paneles
de capas se utiliza la clase
javax.swing.JLayeredPane. Por
comodidad, es posible emplear
las capas estndar denidas en
esta clase: DEFAULT_LAYER
(capa inferior), PALETTE_LAYER,
MODAL_LAYER,
POPUP_LAYER y
DRAG_LAYER (capa superior).
Cuando se utilizan clases contenedor, es preciso tener en cuenta las reglas
siguientes:
Los componentes de la interfaz grca 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 grca. 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 grca 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 n 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 dene llamando al mtodo setDefaultCloseOperation
en la instancia de JFrame.
Botones
Botones
Se consideran botones los botones normales, las casillas de vericacin y
los botones de opcin. La creacin de botones grcos es fcil si se utiliza
un objeto Icon que dena la imagen que debe aparecer. La clase
JCheckBox es til para los botones de casilla de vericacin. 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 vericacin 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
vericacin tiene un valor de estado booleano que puede
estar activado (true) o desactivado (false). Al hacer clic en la
casilla de vericacin, su estado pasa de activado a
desactivado o de desactivado a activado. Para crear casillas de
vericacin 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.
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 especicar el
nmero de las 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.
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.
Tabla C-5 Componentes de texto (Continuacin)
Componentes de presentacin de informacin no modificables
Componentes de presentacin de informacin no
modicables
Los componentes de presentacin de informacin no modicables 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 modicables
Las etiquetas permiten mostrar
texto en la pantalla. Son
componentes no modicables.
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.
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
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 vericacin
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.
Componentes de presentacin con formato
Los componentes de presentacin con formato guran 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
Las tablas se utilizan para mostrar
y modicar 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 JFileChooserpermite a los
usuarios navegar por el sistema de
archivos y seleccionar un archivo.
El selector de archivos contiene
mtodos de ltrado que pueden
utilizarse para ltrar los tipos de
archivos que se van a mostrar y
mtodos que permiten personalizar
la vista presentada por el selector.
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 especicar
el modelo de seleccin de color
en el constructor.
Tabla C-8 Componentes de presentacin con formato (Continuacin)
Esta seccin describe otros componentes Swing que suelen utilizarse en
una interfaz grca, 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
JComboBox adopta dos formas:
modicable y no modicable. La
forma predeterminada es no
modicable y muestra un botn y
una lista desplegable de valores. La
forma modicable 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.
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 echa arriba,
una echa 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 nito, es decir, tienen
un valor mximo y otro mnimo.
Si la posibilidad de especicar
nmeros precisos es importante,
el deslizador puede ir acompaado
de un campo de texto con formato.
Tabla C-9 Otros controles bsicos (Continuacin)

D64147

Încărcat de

Informații document

Descriere originală:

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

D64147

Încărcat de

Drepturi de autor:

Formate disponibile

Java Programming Language,

S-ar putea să vă placă și