Programacion en Java - Angel Esteban Grupo Eidos

Se tratan diferentes aspectos de Java, desde las aplicaciones hasta los applets a través de numerosos ejemplos. Como herramientas de desarrollo se utilizan Microsoft Visual J++ 6 y JBuilder. La versión tratada del lenguaje es la estándar de Sun Microsystems. Se pretende adiestrar sobre: • Programación Orientada

a Objetos. • Construcción de

aplicaciones Java. • Creación de applets Java. • Tratamiento de eventos y

construcción de interfaces de usuario.

• Utilización de Visual J++ 6.

• Programación multihilo. • Acceso a ficheros y

conexiones a través de Internet.

El único requisito es conocer algún lenguaje de programación

PPRROOGGRRAAMMAACCIIÓÓNN EENN JJAAVVAA ÁÁNNGGEELL EESSTTEEBBAANN

Desarrollo de software

ADVERTENCIA LEGAL

Todos los derechos de esta obra están reservados a Grupo EIDOS Consultoría y Documentación Informática, S.L.

El editor prohíbe cualquier tipo de fijación, reproducción, transformación, distribución, ya sea mediante venta y/o alquiler y/o préstamo y/o cualquier otra forma de cesión de uso, y/o comunicación pública de la misma, total o parcialmente, por cualquier sistema o en cualquier soporte, ya sea por fotocopia, medio mecánico o electrónico, incluido el tratamiento informático de la misma, en cualquier lugar del universo.

El almacenamiento o archivo de esta obra en un ordenador diferente al inicial está expresamente prohibido, así como cualquier otra forma de descarga (downloading), transmisión o puesta a disposición (aún en sistema streaming).

La vulneración de cualesquiera de estos derechos podrá ser considerada como una actividad penal tipificada en los artículos 270 y siguientes del Código Penal.

La protección de esta obra se extiende al universo, de acuerdo con las leyes y convenios internacionales.

Esta obra está destinada exclusivamente para el uso particular del usuario, quedando expresamente prohibido su uso profesional en empresas, centros docentes o cualquier otro, incluyendo a sus empleados de cualquier tipo, colaboradores y/o alumnos.

Si Vd. desea autorización para el uso profesional, puede obtenerla enviando un e-mail [email protected] o al fax (34)-91-5017824.

Si piensa o tiene alguna duda sobre la legalidad de la autorización de la obra, o que la misma ha llegado hasta Vd. vulnerando lo anterior, le agradeceremos que nos lo comunique al e-mail [email protected] o al fax (34)-91-5017824). Esta comunicación será absolutamente confidencial.

Colabore contra el fraude. Si usted piensa que esta obra le ha sido de utilidad, pero no se han abonado los derechos correspondientes, no podremos hacer más obras como ésta.

© Ángel Esteban, 2000 © Grupo EIDOS Consultaría y Documentación Informática, S.L., 2000

ISBN 84-88457-18-9

Programación en Java Ángel Esteban

Responsable editorial Paco Marín ([email protected]) Autoedición Magdalena Marín ([email protected]) Ángel Esteban ([email protected])

Coordinación de la edición Antonio Quirós ([email protected])

Grupo EIDOS C/ Téllez 30 Oficina 2 28007-Madrid (España) Tel: 91 5013234 Fax: 91 (34) 5017824 www.grupoeidos.com/www.eidos.es www.LaLibreriaDigital.com

mailto:[email protected]






http://www.grupoeidos.com/www.eidos.es

http://www.lalibreriadigital.com/

Índice

ÍNDICE................................................................................................................................................... 5 INTRODUCCIÓN A LA POO........................................................................................................... 11

¿QUÉ ES LA POO?.............................................................................................................................. 11 OBJETOS............................................................................................................................................. 12 MENSAJES .......................................................................................................................................... 13 CLASES............................................................................................................................................... 14 HERENCIA .......................................................................................................................................... 14 MÉTODOS........................................................................................................................................... 15 POLIMORFISMO .................................................................................................................................. 16 SOBRECARGA..................................................................................................................................... 16 LA LEY DE DEMETER ......................................................................................................................... 16 MODELO DE OBJETOS......................................................................................................................... 17 RELACIONES ENTRE CLASES .............................................................................................................. 17 VENTAJAS E INCONVENIENTES DE LA POO ....................................................................................... 18 UN EJEMPLO SENCILLO ...................................................................................................................... 19

INTRODUCCIÓN AL LENGUAJE JAVA ...................................................................................... 21 INTRODUCCIÓN .................................................................................................................................. 21 BREVE HISTORIA DEL LENGUAJE ....................................................................................................... 22 DESCRIPCIÓN DEL LENGUAJE............................................................................................................. 22 PROGRAMAS EN JAVA: APPLETS Y APLICACIONES ............................................................................ 25 SIMILITUDES Y DIFERENCIAS ENTRE JAVA Y C++ ............................................................................. 26 VERSIONES DEL LENGUAJE ................................................................................................................ 26 ENTORNOS DE DESARROLLO.............................................................................................................. 27 CARACTERÍSTICAS DE LA PLATAFORMA JAVA 2 ............................................................................... 29

SINTAXIS DEL LENGUAJE JAVA................................................................................................. 33 INTRODUCCIÓN .................................................................................................................................. 33 IDENTIFICADORES.............................................................................................................................. 33 PALABRAS CLAVE .............................................................................................................................. 35 LITERALES ......................................................................................................................................... 36

Enteros........................................................................................................................................... 36 Coma flotante................................................................................................................................. 37 Booleanos ...................................................................................................................................... 37 Caracteres...................................................................................................................................... 37 Cadenas ......................................................................................................................................... 38 El literal null.................................................................................................................................. 38

OPERADORES ..................................................................................................................................... 38 SEPARADORES.................................................................................................................................... 39 COMENTARIOS ................................................................................................................................... 39 TIPOS DE DATOS EN JAVA .................................................................................................................. 40

Enteros........................................................................................................................................... 40 Coma flotante................................................................................................................................. 41 Booleanos ...................................................................................................................................... 41 Carácter......................................................................................................................................... 41 Cadenas ......................................................................................................................................... 41 Arrays ............................................................................................................................................ 42

EMPAQUETAR TIPOS PRIMITIVOS ....................................................................................................... 43 CONVERSIÓN DE TIPOS DE DATOS...................................................................................................... 44 BLOQUES Y ÁMBITOS ......................................................................................................................... 45

Bloques .......................................................................................................................................... 45 Ámbitos .......................................................................................................................................... 46

EXPRESIONES ..................................................................................................................................... 46 CLASIFICACIÓN DE OPERADORES ...................................................................................................... 48

Aritméticos..................................................................................................................................... 48 Operadores sobre enteros........................................................................................................... 48 Operadores sobre reales............................................................................................................. 50

Booleanos ...................................................................................................................................... 50 Relacionales................................................................................................................................... 51 Cadena........................................................................................................................................... 51 Asignación ..................................................................................................................................... 52

PRECEDENCIA DE LOS OPERADORES .................................................................................................. 52 CONTROL DE FLUJO............................................................................................................................ 53

If-else ............................................................................................................................................. 53 Switch............................................................................................................................................. 54 For ................................................................................................................................................. 55 While .............................................................................................................................................. 56 Do-while: ....................................................................................................................................... 57 Break, continue y etiquetas............................................................................................................ 57 Return ............................................................................................................................................ 59 Try, catch, finally y throws: ........................................................................................................... 59

POO EN JAVA: OBJETOS................................................................................................................ 61 INTRODUCCIÓN .................................................................................................................................. 61 OBJETOS............................................................................................................................................. 61 CREACIÓN DE OBJETOS ...................................................................................................................... 62

Declaración ................................................................................................................................... 62 Instanciación.................................................................................................................................. 63 Inicialización ................................................................................................................................. 64

UTILIZACIÓN DE OBJETOS.................................................................................................................. 64

7

DESTRUCCIÓN DE OBJETOS................................................................................................................ 66 POO EN JAVA: CLASES................................................................................................................... 69

CLASES............................................................................................................................................... 69 DECLARACIÓN DE LA CLASE.............................................................................................................. 70

Superclase de la clase.................................................................................................................... 70 Interfaces de la clase ..................................................................................................................... 70 Modificadores de la clase.............................................................................................................. 71

CUERPO DE LA CLASE. DECLARACIÓN DE ATRIBUTOS ...................................................................... 72 Modificadores ................................................................................................................................ 72 Tipo................................................................................................................................................ 74 Nombre variable ............................................................................................................................ 75

CUERPO DE LA CLASE. IMPLEMENTACIÓN DE MÉTODOS ................................................................... 75 Declaración del método................................................................................................................. 75 Declaración de variables............................................................................................................... 80 Implementación del método........................................................................................................... 80

HERENCIA .......................................................................................................................................... 82 Sustituir la implementación de un método..................................................................................... 84 Ampliar la implementación de un método ..................................................................................... 85 Métodos que una clase heredada no puede redefinir .................................................................... 85 Métodos que una clase heredada tiene que redefinir .................................................................... 86

CLASES ABSTRACTAS......................................................................................................................... 86 POO EN JAVA: OTROS CONCEPTOS .......................................................................................... 89

INTRODUCCIÓN .................................................................................................................................. 89 INTERFACES ....................................................................................................................................... 89

Declaración del interfaz ................................................................................................................ 90 Cuerpo del interfaz ........................................................................................................................ 90

EXCEPCIONES..................................................................................................................................... 91 PAQUETES .......................................................................................................................................... 94 PRINCIPALES PAQUETES DEL LENGUAJE JAVA................................................................................... 98 LA CLASE OBJECT............................................................................................................................ 100

POO EN JAVA: UN EJEMPLO. RESUMEN DE CONCEPTOS................................................ 103 INTRODUCCIÓN ................................................................................................................................ 103 DESCRIPCIÓN DEL PROBLEMA.......................................................................................................... 103 UTILIZANDO EL JDK 1.3.................................................................................................................. 104 CREANDO LAS CLASES ..................................................................................................................... 105

APLICACIONES JAVA................................................................................................................... 111 INTRODUCCIÓN ................................................................................................................................ 111 INTRODUCCIÓN A VISUAL J++ 6...................................................................................................... 112 INTRODUCCIÓN A JBUILDER 3.5 ...................................................................................................... 117 EL MÉTODO MAIN().......................................................................................................................... 122 LA CLASE SYSTEM ........................................................................................................................... 125 LA CLASE RUNTIME ......................................................................................................................... 128 ALGUNAS CONSIDERACIONES SOBRE VISUAL J++ 6 ....................................................................... 130 CONSIDERACIONES SOBRE JBUILDER.............................................................................................. 135

INTERFACES DE USUARIO EN JAVA: COMPONENTES AWT ........................................... 145 INTRODUCCIÓN ................................................................................................................................ 145 EL AWT (ABSTRACT WINDOW TOOLKIT) ...................................................................................... 145 UTILIZANDO LOS COMPONENTES DEL AWT.................................................................................... 148

Frame........................................................................................................................................... 148 Cursor.......................................................................................................................................... 149

MenuBar ...................................................................................................................................... 150 Menu ............................................................................................................................................ 150 MenuItem ..................................................................................................................................... 150 CheckboxMenuItem ..................................................................................................................... 150 Dialog .......................................................................................................................................... 152 FileDialog.................................................................................................................................... 153 Container ..................................................................................................................................... 153 Button........................................................................................................................................... 154 Label ............................................................................................................................................ 156 List, Choice.................................................................................................................................. 157 TextField, TextArea ..................................................................................................................... 158 Checkbox, CheckboxGroup ......................................................................................................... 160 ScrollPane.................................................................................................................................... 162

INTERFACES DE USUARIO EN JAVA: GESTORES DE DISEÑO Y EVENTOS................. 165 INTRODUCCIÓN ................................................................................................................................ 165 GESTORES DE DISEÑO ...................................................................................................................... 165

FlowLayout .................................................................................................................................. 167 BorderLayout............................................................................................................................... 167 CardLayout .................................................................................................................................. 168 GridLayout................................................................................................................................... 170 GridBagLayout ............................................................................................................................ 171

TRATAMIENTO DE EVENTOS EN JAVA.............................................................................................. 173 INTERFACES DE USUARIO EN JAVA: COMPONENTES SWING / CONTENEDORES... 189

INTRODUCCIÓN ................................................................................................................................ 189 JFC Y SWING ................................................................................................................................... 190 COMPONENTES SWING FRENTE A COMPONENTES AWT.................................................................. 191 CONTENEDORES DE ALTO NIVEL...................................................................................................... 192

JFrame......................................................................................................................................... 197 JDialog, JOptionPane ................................................................................................................. 199 JApplet ......................................................................................................................................... 208

CONTENEDORES INTERMEDIOS........................................................................................................ 208 JPanel .......................................................................................................................................... 209 JTabbedPane ............................................................................................................................... 212 JToolBar ...................................................................................................................................... 216 JLayeredPane .............................................................................................................................. 217

INTERFACES DE USUARIO EN JAVA: COMPONENTES ATÓMICOS DE SWING ......... 223 INTRODUCCIÓN ................................................................................................................................ 223 COMPONENTES ATÓMICOS............................................................................................................... 223 COMPONENTES PARA OBTENER INFORMACIÓN ............................................................................... 225

JButton......................................................................................................................................... 225 JCheckbox.................................................................................................................................... 227 JRadioButton ............................................................................................................................... 229 JComboBox.................................................................................................................................. 231 JMenu .......................................................................................................................................... 233 JSlider.......................................................................................................................................... 238

COMPONENTES PARA MOSTRAR INFORMACIÓN............................................................................... 242 JLabel .......................................................................................................................................... 242 JToolTip....................................................................................................................................... 245 JProgressBar ............................................................................................................................... 245

COMPONENTES QUE MUESTRAN INFORMACIÓN ESTRUCTURADA.................................................... 247 JColorChooser............................................................................................................................. 247 JFileChooser................................................................................................................................ 252

9

INTERFACES DE USUARIO EN JAVA: OTRAS CARACTERÍSTICAS DE SWING........... 257 INTRODUCCIÓN ................................................................................................................................ 257 EL GESTOR DE DISEÑO BOXLAYOUT ............................................................................................... 257 ESTABLECIENDO EL LOOK & FEEL.................................................................................................. 262

APPLETS DE JAVA: INTRODUCCIÓN A LOS APPLETS....................................................... 269 CONCEPTOS PREVIOS ....................................................................................................................... 269

Internet......................................................................................................................................... 269 URLs y direcciones IP ................................................................................................................. 270 Clientes y Servidores Web ........................................................................................................... 271 HTML........................................................................................................................................... 272 HTTP ........................................................................................................................................... 272

INTRODUCCIÓN A LOS APPLETS DE JAVA......................................................................................... 272 EL CICLO DE VIDA DE LOS APPLETS ................................................................................................. 282 SEGURIDAD EN LOS APPLETS ........................................................................................................... 285 TRUSTED/UNTRUSTED APPLETS ...................................................................................................... 289 DIFERENCIAS ENTRE APPLETS Y APLICACIONES .............................................................................. 289 LA ETIQUETA APPLET....................................................................................................................... 290

Codebase ..................................................................................................................................... 291 Code............................................................................................................................................. 291 Alt................................................................................................................................................. 291 Name............................................................................................................................................ 291 Width, Height............................................................................................................................... 291 Align............................................................................................................................................. 291 Vspace, Hspace............................................................................................................................ 292 <PARAM>................................................................................................................................... 292 Etiquetas HTML alternativas ...................................................................................................... 292

APPLETS DE JAVA: UTILIZANDO LOS APPLETS ................................................................. 293 INTERACCIÓN DE LOS APPLETS CON EL NAVEGADOR WEB .............................................................. 293 EVENTOS, GRÁFICOS Y FUENTES EN LOS APPLETS........................................................................... 303 COMPRESIÓN DE APPLETS................................................................................................................ 322 COMPONENTES SWING Y APPLETS................................................................................................... 325 LA CLASE JAPPLET .......................................................................................................................... 327

ASPECTOS AVANZADOS DE JAVA: PROCESOS.................................................................... 331 INTRODUCCIÓN ................................................................................................................................ 331 PROCESOS Y MULTIPROCESO ........................................................................................................... 331 HOLA MUNDO CON HILOS ................................................................................................................ 332 PARALELISMO.................................................................................................................................. 333 UTILIZANDO PROCESOS. EL INTERFAZ RUNNABLE.......................................................................... 337 COORDINANDO LOS PROCESOS ........................................................................................................ 344

Sin derecho preferente................................................................................................................. 344 Con derecho preferente ............................................................................................................... 344

ASPECTOS AVANZADOS DE JAVA: CANALES Y SOCKETS............................................... 345 INTRODUCCIÓN A LOS CANALES ...................................................................................................... 345 CANALES ESTÁNDAR DE ENTRADA/SALIDA..................................................................................... 346 CANALES DE JAVA.IO ....................................................................................................................... 348 CANALES DE TRANSMISIÓN (DATA SINK STREAMS) .......................................................................... 350 CANALES DE PROCESO (PROCESSING STREAMS)............................................................................... 352

Canales de Filtrado ..................................................................................................................... 353 Canales de buffer......................................................................................................................... 353 Canal de Concatenación.............................................................................................................. 354 Canales de conversión de tipos ................................................................................................... 354

Serialización de Objetos .............................................................................................................. 356 Canal Contador de Líneas........................................................................................................... 357 Canales de impresión .................................................................................................................. 358 Canales de vuelta atrás ............................................................................................................... 359

APLICACIONES CLIENTE/SERVIDOR EN JAVA................................................................................... 359

Introducción a la POO

¿Qué es la POO? Las siglas POO se corresponden con Programación Orientada a Objetos, aunque muchas veces las podemos encontrar escritas en inglés OOP (Object Oriented Programming).

En este primer capítulo de este curso vamos a tratar de explicar de forma sencilla los principales conceptos y términos que se utilizan dentro de este tipo de programación, es decir, dentro de la Programación Orientada a Objetos. No vamos a entrar en sesudas divagaciones filosóficas respecto a la POO, sino que vamos a definir lo más claramente posible cada uno de los elementos clave que aparecen en la POO para después poder aplicarlos al lenguaje que nos ocupa, es decir, al lenguaje Java.

Este tema es muy necesario debido a que el lenguaje Java, como veremos en el siguiente capítulo, es un lenguaje que se basa en la Programación Orientada a Objetos, por lo tanto para conocer el lenguaje Java, es necesario conocer la Programación Orientada a Objetos.

La Programación Orientada a Objetos trata de utilizar una visión real del mundo dentro de nuestros programas. La visión que se tiene del mundo dentro de la POO es que se encuentra formado por objetos.

Para comprender bien la POO debemos olvidar un poco la Programación Estructurada, que si nos fijamos bien es algo artificial, la POO es una forma de abordar los problemas más natural. Aquí natural significa más en contacto con el mundo real que nos rodea, de esta forma si queremos resolver un problema determinado, debemos identificar cada una de las partes del problema con objetos presentes en el mundo real.

Programación en Java © Grupo EIDOS

12

En esta definición de POO ya estamos haciendo referencia al elemento clave de la misma: el objeto. El objeto va a ser la modelización de los objetos que nos encontramos en el mundo real, estos objetos los vamos a utilizar en nuestros programas para dar la solución al problema que nos ocupe en cada caso.

Objetos Como ya hemos adelantado un objeto es la pieza básica de la POO, es una representación o modelización de un objeto real perteneciente a nuestro mundo, por ejemplo, podemos tener un objeto perro que represente a un perro dentro de nuestra realidad, o bien un objeto factura, cliente o pedido.

Los objetos en la vida real tienen todos, dos características: estado y comportamiento. El estado de un objeto viene definido por una serie de parámetros que lo definen y que lo diferencian de objetos del mismo tipo. En el caso de tener un objeto perro, su estado estaría definido por su raza, color de pelo, tamaño, etc. Y el comportamiento viene definido por las acciones que pueden realizar los objetos, por ejemplo, en el caso del perro su comportamiento sería: saltar, correr, ladrar, etc. El comportamiento permite distinguir a objetos de distinto tipo, así por ejemplo el objeto perro tendrá un comportamiento distinto a un objeto gato.

Si tomamos un ejemplo que tiene que ver más con el mundo de la informática se pueden ver más claros estos dos conceptos. Si tenemos un objeto pantalla que representa la pantalla de nuestro ordenador, el estado de la misma estaría definido por los siguientes parámetros: encendida o apagada, tamaño, resolución, número de colores, etc.; y su comportamiento podría ser: imprimir, encender, apagar, etc.

Los parámetros o variables que definen el estado de un objeto se denominan atributos o variables miembro y las acciones que pueden realizar los objetos se denominan métodos o funciones miembro, y para indicar variables miembro y funciones miembro se utiliza el término general miembro.

Si lo comparamos con la programación estructurada podríamos hacer la siguiente aproximación: los atributos o variables miembro serían variables y los métodos o funciones miembro procedimientos y funciones.

A partir de ahora y a lo largo de todo el presente curso vamos a utilizar únicamente la nomenclatura de atributos y métodos.

Los atributos de un objeto deben encontrarse ocultos al resto de los objetos, es decir, no se va a poder acceder directamente a los atributos de un objeto para modificar su estado o consultarlo. Para acceder a los atributos de un objeto se deben utilizar métodos. Es decir, los métodos exponen toda la funcionalidad del objeto, mientras que los detalles del estado interno del objeto permanecen ocultos. Incluso algunos métodos también pueden permanecer ocultos.

El hecho de ocultar la implementación interna de un objeto, es decir, como está construido y de que se compone se denomina encapsulación. La encapsulación es uno de los beneficios y particularidades del paradigma de la Programación Orientada a Objetos.

Normalmente un objeto ofrece una parte pública que será utilizada por otros objetos para interactuar entre sí, pero también permanece una parte oculta para encapsular los detalles de la implementación del objeto.

Ya se ha dicho que un objeto está compuesto de atributos y métodos. Como la caja negra de un avión, el objeto recubre la información que almacena y solamente podemos obtener la información e indicarle que realiza acciones por medio de lo que comúnmente se denomina interfaz del objeto, que estará constituido por los métodos públicos.

© Grupo EIDOS 1. Introducción a la POO

13

Los datos y la implementación queda oculta a los demás objetos que interaccionan en el programa, lo que favorece enormemente la protección de los datos y las estructuras internas contra las modificaciones externas al objeto. De este modo es mucho más sencillo localizar errores en los programas puesto que cada objeto está altamente especializado, y sólo se encarga de su tarea. Como se puede observar, esto consigue una mayor modularidad, que facilita además el diseño en equipo de programas y la reutilización de clases (componentes) creados por otros desarrolladores.

Hemos indicado que la encapsulación es un beneficio que nos aporta la POO, es un beneficio porque permite abstraernos de la utilización de los objetos, es decir, a mí me interesa realizar una determinada tarea con un objeto (por ejemplo imprimir una pantalla o rellenar una factura), pero a mí no me interesa como realiza este proceso internamente el objeto que estoy utilizando. En este momento entra en juego otro concepto importante de la POO y que es la abstracción.

La abstracción indica la capacidad de ignorar determinados aspectos de la realidad con el fin de facilitar la realización de una tarea. Nos permite ignorar aquellos aspectos de la realidad que no intervienen en el problema que deseamos abordar, y también nos permite ignorar los aspectos de implementación de los objetos en los pasos iniciales, con lo cual sólo necesitamos conocer qué es lo que hace un objeto, y no cómo lo hace, para definir un objeto y establecer las relaciones de éste con otros objetos.

Un objeto lo podríamos representar como dos circunferencias, una interna que permanece oculta al mundo exterior y que contendría todos los detalles de la implementación del objeto, y otra circunferencia concéntrica externa, que representa lo que el objeto muestra al mundo exterior y le permite utilizar para interactuar con él. En la Figura 1 se puede ver dicha representación.

La encapsulación ofrecida a través de objetos tienen varios beneficios, entre los que destacan la modularidad y la ocultación de la información.

Mediante la modularidad podemos escribir código de manera independiente de cómo se encuentren construidos los diferentes objetos que vamos a utilizar. Y ocultando la información se permite realizar cambios en el código interno de los objetos sin que afecte a otros objetos que los utilicen o dependan de ellos. No es necesario entender la implementación interna de un objeto para poder utilizarlo.

Figura 1

Mensajes Los mensajes son la forma que tienen de comunicarse distintos objetos entre sí. Un objeto por sí sólo no es demasiado útil, sino que se suele utilizar dentro de una aplicación o programa que utiliza otros objetos.

El comportamiento de un objeto está reflejado en los mensajes a los que dicho objeto puede responder. Representan las acciones que un determinado objeto puede realizar.


14

Un mensaje enviado a un objeto representa la invocación de un determinado método sobre dicho objeto, es decir, la ejecución de una operación sobre el objeto. Es la manera en la que un objeto utiliza a otro, el modo en el que dos objetos se comunican, ya que la ejecución de ese método retornará el estado del objeto invocado o lo modificará.

Los mensajes se utilizan para que distintos objetos puedan interactuar entre sí y den lugar a una funcionalidad más compleja que la que ofrecen por separado. Un objeto lanzará o enviará un mensaje a otro objeto si necesita utilizar un método del segundo objeto. De esta forma si el objeto A quiere utilizar un método del objeto B, le enviará un mensaje al objeto A.

Para enviar un mensaje se necesitan tres elementos: el objeto al que se le va a enviar el mensaje, el nombre del método que se debe ejecutar y los parámetros necesarios para el método en cuestión.

Clases Una clase es un molde o prototipo que define un tipo de objeto determinado. Una clase define los atributos y métodos que va a poseer un objeto. Mediante las clases podremos crear o instanciar objetos de un mismo tipo, estos objetos se distinguirán unos de otros a través de su estado, es decir, el valor de sus atributos.

La clase la vamos a utilizar para definir la estructura de un objeto, es decir, estado (atributos) y comportamiento (métodos). La clase es un concepto abstracto que generalmente no se va a utilizar directamente en nuestros programas o aplicaciones. Lo que vamos a utilizar van a ser objetos concretos que son instancias de una clase determinada.

La clase es algo genérico y abstracto, es similar a una idea. Cuando decimos piensa en un coche todos tenemos en mente la idea general de un coche, con puertas, ruedas, un volante, etc., sin embargo cuando decimos "ese coche que está aparcado ahí fuera", ya se trata de un coche determinado, con una matrícula, de un color, con un determinado número de puertas, y que podemos tocar y utilizar si es necesario. Sin embargo como ya hemos dicho la clase es la idea que define al objeto concreto.

Un ejemplo que se suele utilizar para diferenciar y relacionar clases y objetos es el ejemplo del molde de galletas. El molde para hacer galletas sería una clase, y las galletas que hacemos a partir de ese molde ya son objetos concretos creados a partir de las características definidas por el molde.

Una vez implementada una clase podremos realizar instancias de la misma para crear objetos que pertenezcan a esa clase.

Las clases ofrecen el beneficio de la reutilización, utilizaremos la misma clase para crear distintos objetos. Y luego veremos que una vez que tenemos una clase podremos aprovecharla heredando de ella para complicarla o especializarla para una labor concreta.

Si comparamos las clases y objetos de la POO con la programación estructurada tradicional, se puede decir que las clases son los tipos de datos y los objetos las variables de esos tipos de datos. De esta forma si tenemos el tipo entero, en la POO diríamos que es la clase entero, y si tenemos una variable de tipo entero, en la POO diríamos que tenemos un objeto de la clase entero.

Herencia La herencia es un mecanismo mediante el cual podemos reutilizar clases ya definidas. Es decir, si tenemos una clase botón que define un tipo de objeto que se corresponde con un botón que tiene un


15

texto, que se puede pulsar, etc., si queremos definir una nueva clase llamada botón de color, no tenemos que rescribir todo el código y crear una clase completamente nueva, sino lo que haremos será heredar de la clase botón, utilizar lo que nos ofrezca esta clase y añadirle lo que sea necesario para la nueva funcionalidad deseada.

La herencia dentro de la POO es un mecanismo fundamental que se puede definir también como una transmisión de las características de padres a hijos. Entendiendo aquí características como métodos y atributos de una clase. La clase hija puede añadir atributos, métodos y redefinir los métodos de la clase padre.

Podemos ver la herencia como una sucesiva especialización de las clases. La clase de la que se hereda se suele denominar clase padre o superclase, y la clase que hereda se denomina clase hija o subclase.

El mecanismo de herencia es muy potente, puesto que nos permite agregar funcionalidades nuevas a una clase ya existente, reutilizando todo el código que ya se tenga disponible de la clase padre, es decir, se heredarán sus atributos y métodos, como ya habíamos indicado con anterioridad. En las clases hijas podemos redefinir el comportamiento de la clase padre.

Para verificar que la herencia entre dos clases es correcta y coherente, debemos hacernos la pregunta de "¿es un?" o "¿es un tipo de?". Por ejemplo, en el caso que comentábamos del botón, tenemos una clase BotonColor que hereda de la clase Boton. Esta herencia contesta perfectamente a la pregunta definida antes: ¿un botón de color es un botón?, evidentemente sí.

Mediante el mecanismo de herencia podemos definir superclases denominadas clases abstractas que definen comportamientos genéricos. De esta clase pueden heredar otras clases que ya implementan de forma más concreta estos comportamientos. De esta forma podremos crear jerarquías de clases.

Así por ejemplo podemos tener una clase bicicleta, que será más o menos genérica. De esta clase pueden heredar la clase bicicleta de montaña, bicicleta de carreras y tandem, que ya ofrecen una clase más especializada que la clase padre.

Los métodos que se heredan de la clase padre no tienen porqué utilizarse sin realizar ningún cambio, se puede llevar a cabo lo que se denomina la sobrescritura de métodos. Podemos heredar un método de la clase padre, pero en la clase hija le podemos dar una implementación diferente para que se adecue a la nueva clase.

La herencia puede ser simple si la clase hija hereda de una única clase padre o múltiple si hereda de varias clases padre, más adelante veremos que el tipo de herencia que soporta Java es una herencia simple. Algunas veces la herencia múltiple puede llegar a ser confusa.

Métodos Como ya hemos dicho anteriormente los métodos son las acciones que se pueden realizar con los objetos. También se podría definir un método como la implementación de un mensaje, al fin y al cabo, un mensaje es la llamada o invocación de un método de un objeto.

Existen dos métodos especiales dentro de la POO que se denominan constructor y destructor.

El método constructor se ejecuta automáticamente cada vez que se crea un objeto de la clase en cuestión, sobre el objeto que acaba de crearse, inmediatamente después de haberse asignado memoria a dicho objeto. Algunos lenguajes proporcionan un constructor por defecto, pero generalmente lo correcto es que lo defina el diseñador de la clase y que en él se lleven a cabo las inicializaciones y todas aquellas operaciones que se necesiten para poder usar el objeto.


16

El método destructor se invoca automáticamente inmediatamente antes de liberar la memoria del objeto en cuestión, o lo que es lo mismo, antes de que se salga del ámbito de la declaración del objeto, por lo que se ha de emplear para que la destrucción del objeto se efectúe correctamente y contendrá operaciones tales como liberación de memoria asignada dinámicamente dependiente del objeto, grabación de todos o parte de los atributos del objeto en un fichero o base de datos y operaciones similares.

Polimorfismo El término polimorfismo expresa la posibilidad de que el mismo mensaje, enviado a objetos distintos, ejecute métodos distintos. Esto significa que podemos definir dentro de dos clases distintas dos operaciones con el mismo nombre y aspecto externo, pero con distintas implementaciones para cada clase.

En el momento de emplear estas operaciones, el lenguaje es capaz de ejecutar el código correspondiente dependiendo de la clase del objeto sobre el que se ejecuta la operación. Esto permite definir un interfaz común, un aspecto externo idéntico, para una serie de clases.

De esta forma podemos definir un método suma() para la clase Enteros y otro método suma() para la clase Matrices. El mensaje será el mismo, pero la implementación de los métodos será distinta ya que no es lo mismo sumar enteros que matrices.

Sobrecarga La sobrecarga de métodos se produce cuando una clase tiene métodos con el mismo nombre pero que difieren o bien en el número o en el tipo de los parámetros que reciben dichos métodos.

Un ejemplo de sobrecarga los podemos tener en el método imprimir(), mediante este método vamos a imprimir en pantalla y realizar un salto de línea. Este método acepta como parámetro una variable de tipo entero o una variable de tipo cadena de caracteres, incluso si no indicamos ningún parámetro realizaría un salto de línea.

La ley de Demeter En lo que respecta a la implementación de métodos de una clase, existe una ley que nos da una serie de pautas para realizar una Programación Orientada a Objetos correcta, esta ley es la Ley de Demeter.

La Ley de Demeter, enunciada por Karl Lieberherr, determina el acceso o visibilidad de los objetos en la implantación de un método, y se rige por el siguiente principio: en la implantación de un método se puede tener acceso a los siguientes objetos:

• Atributos de su clase.

• Los parámetros que se pasan al método.

• Objetos temporales creados dentro del método.

Existen dos formas de la Ley de Demeter, la flexible y la estricta, la flexible permite acceder a los atributos de la clase padre o superclase y la estricta indica que este acceso se debe lograr mediante la utilización de métodos de acceso de la clase padre.


17

Modelo de objetos El modelo de objetos es un conjunto de principios que se deben dar para que se puedan modelar objetos computacionales (objetos dentro de nuestro código y programas) a partir de objetos de la realidad de manera que éstos reflejen los posibles comportamientos presentes en la realidad y compongan un modelo computacional válido.

Es decir, definido e identificado un problema se trata de realizar una representación lógica de los objetos que forman parte del problema en el mundo real, de esta forma podremos utilizar en nuestro programa estos objetos para dar la solución a través de nuestro código.

El modelo de objetos que definen un problema de la realidad se basa en los siguientes principios: abstracción, encapsulación, herencia y polimorfismo. Todos estos conceptos básicos de la POO ya han sido discutidos en este tema en mayor o menor medida.

Por lo tanto antes de empezar a construir un programa para una tarea específica, es necesario construir y diseñar su modelo de objetos. Existen diversas técnicas de modelización, pero el objetivo de este curso no es el de explicarlas, así que no entraremos en más detalles.

Relaciones entre clases Una clase por sí sola no ofrece una funcionalidad demasiado interesante, como ya veremos a lo largo del curso, el lenguaje Java se encuentra formado por un gran número de clases que forman parte de una compleja y completa jerarquía. Cada una de las clases está especializada en una función o tarea específica, es decir, se da una gran modularidad, cada clase tiene su cometido.

Por lo tanto para ofrecer una mayor funcionalidad y realizar tareas más complejas es necesario que exista una relación entre distintas clases. Un ejemplo podría ser las piezas del motor de un coche. Las piezas por si solas no realizan ninguna tarea de importancia, cuando realmente se saca provecho de ellas es cuando se relacionan entre sí y se construye con ellas un motor. A su vez este motor puede ser incorporado dentro de un coche, que estará compuesto a su vez de más objetos o piezas. Como vemos la correspondencia entre los objetos del mundo real y los objetos del mundo computacional es bastante obvia en algunos casos.

Básicamente una clase se puede relacionar con otra de tres formas diferentes. Las relaciones que podemos distinguir son:

• Relación de composición: una clase puede estar compuesta de otras clases. Esto se consigue implementando los atributos de la clase como objetos de otra clase. Una clase hace uso de otra a través de sus atributos, una clase se encuentra formada por varias clases. Por ejemplo la clase Coche tiene atributos que son de la clase Puerta, Rueda, Motor, etc.

• Relación de uso: una clase se relaciona con otra a través de los mensajes que le envía. Esto se consigue pasándose una instancia de la clase como uno de los parámetros del método invocado por el mensaje. Es decir, si tenemos la clase Pantalla con el método dibujar() y queremos dibujar un objeto de la clase Rectangulo, deberíamos realizar lo siguiente objPantalla.dibujar(Rectangulo), es decir, el parámetro que se le pasa al método dibujar() de la clase Pantalla es un objeto de la clase Rectangulo.

• Relación de herencia: este tipo de relación entre clases ya la conocemos y consiste en que una clase hija hereda de una clase padre o superclase pudiendo utilizar así toda la funcionalidad ofrecida por la clase padre y añadir nuevas funcionalidades. En esta forma de relación se


18

consigue la reutilización del código y una progresiva especialización a través de una jerarquía de clases.

Ventajas e inconvenientes de la POO En este apartado vamos a comentar que ventajas nos ofrece el paradigma de la POO, también mostraremos algunas de sus desventajas. Como ventajas o aportaciones podemos destacar las siguientes:

• Facilita la reutilización del software. A través de la herencia se nos permite utilizar en un objeto las operaciones implementadas para otros sin esfuerzo adicional. Por otro lado la encapsulación nos facilita el uso de objetos que no hemos definido ni implementado. Se pude considerar que la encapsulación y el polimorfismo son las herramientas más potentes del paradigma de la POO.

• Facilita la construcción de programas portables. Es posible diseñar una capa de objetos que se comunique con la máquina o el sistema operativo, y sobre ésta los objetos que dan funcionalidad a la aplicación. Una migración a otra arquitectura sólo requerirá cambios en dicha capa, y la encapsulación nos garantiza que los cambios se van a limitar a esos objetos. Java refuerza más esta característica de la portabilidad, ya que, como veremos en el próximo capítulo, el lenguaje Java es independiente de la plataforma en la que se ejecuta.

• Facilita el mantenimiento. El encapsulamiento nos garantiza que las modificaciones realizadas en un objeto tendrán un efecto limitado. Si un elemento de datos se accede directamente y en un momento dado cambia de tipo o formato, habrá que localizar todos los puntos en los que se accede a dicho elemento y modificarlos en consecuencia. Si este elemento de datos está encapsulado en un objeto y siempre es accedido mediante las operaciones disponibles, un cambio como el indicado se limitará al objeto, del que sólo habrá que cambiar el elemento de datos y las operaciones del objeto que lo utilizan. Lo recomendable es desconocer la implementación interna del objeto, nosotros necesitaremos utilizar un objeto que ofrece una serie de funcionalidades, pero no nos interesa de que forma nos ofrece las mismas.

• Provoca que las tareas de análisis, diseño e implementación sean más intuitivas, ya que se manejan objetos, concepto con el que todos estamos familiarizados, y estructuradas, ya que podemos asignar las tareas de diseño e implementación en el ámbito de objetos. Se debe recordar que los objetos en nuestros diseños van a representar objetos presentes en el mundo real.

No todos son beneficios, la POO ofrece también una serie de desventajas, aunque más que desventajas o inconvenientes podemos decir que presenta una serie de dificultades, las cuales se comentan a continuación:

• Curvas de aprendizaje largas, debido principalmente a que implica un cambio mentalidad, y no sólo el aprender un nuevo lenguaje.

• Dificultad en determinar las características de un objeto. Debido a que un objeto no se define aisladamente, sino que depende de las relaciones con otros objetos, el establecimiento de nuevas relaciones puede implicar un cambio en la definición del objeto y viceversa. Por todo ello es conveniente iterar, esto es, repetir el proceso de definición de objetos y de identificación de relaciones, tantas veces como sean necesarias para alcanzar un modelo estable. En muchos casos resulta complicado llegar a un modelo de objetos definitivo con el que se pueda abordar el problema planteado de forma completa.


19

• Jerarquías de herencia complejas: en muchos casos se tiende a utilizar de forma desmedida el mecanismo de herencia, ofreciendo en algunos casos unas jerarquías de herencia difíciles de seguir y abordar.

Un ejemplo sencillo No hace falta decir que el tema que nos ocupa es un tema eminentemente teórico, pero aun así vamos a incluir un breve y sencillo ejemplo con el que se pretende mostrar de forma sencilla como se puede construir un modelo de objetos, identificando los objetos que intervienen en el problema a resolver, definiendo los atributos de la clase, los métodos, relaciones entre las diferentes clases, etc.

En este caso vamos a abandonar los típicos ejemplos de la clase Coche y similares y vamos a mostrar un ejemplo más lúdico. En nuestro ejemplo vamos a tener la clase VideoJuego, es decir, vamos a crear el juego de matamarcianos conocido por todos.

No vamos a profundizar demasiado en todos los atributos y métodos de las clases, sino que vamos a mostrar únicamente los más relevantes.

En el primer paso vamos a identificar las clases necesarias para abordar nuestro problema, en este caso, la creación de un juego de matamarcianos. Primero tengamos en cuenta las especificaciones:

• En el juego tenemos dos tipos de enemigos: marcianos y venusianos.

• El protagonista del juego es un terrícola.

• El terrícola dispone de un arma para defenderse de los enemigos, un lanza cohetes.

Como se puede observar no vamos a tener demasiadas complicaciones a la hora definir el modelo de objetos de nuestro programa.

Se pueden distinguir seis clases: VideoJuego, Enemigo, Marciano, Venusiano, Terricola y LanzaCohetes.

La clase VideoJuego sería la clase principal y contendría al resto de las clases. Por lo tanto entre la clase VideoJuego y el resto de las clases existe una relación de composición. Esta clase tendría como atributos posibles: Enemigos, Heroes y Armas; y como métodos: comenzarPartida(), interrumpirPartida(), reanudarPartida() y finalizarPartida(), la finalidad de cada uno de ellos está bastante clara.

La clase Enemigo en realidad va a ser una clase abstracta, ya que no vamos a instanciar objetos de esta clase. La clase Enemigo va a ser la clase padre de la clase Marciano y Venusiano, y lo que se consigue con esta clase es agrupar todo el comportamiento que es común a los enemigos que aparecen en el juego. Esta clase tiene los siguientes atributos: Color, NumeroOjos y NumeroPiernas. Estos atributos serán comunes a las clases Marciano y Venusiano. Existe una relación de herencia entre la clase Enemigo y las clases Marciano y Venusiano.

La clase Enemigo podría tener los siguientes métodos: mover(), atacar() y disparar(). Estos métodos también serán heredados por la clase hijas mencionadas. Las clases hijas tienen dos opciones, si la implementación de los métodos anteriores que realiza la clase padre es la adecuada, los heredarán y utilizarán sin más, pero si las clases hijas quieren realizar modificaciones o ampliaciones sobre los métodos heredados deberán implementarlos y por lo tanto sobrescribirlos aportando un comportamiento diferente.


20

Las clases Marciano y Venusiano pueden además de sobrescribir los métodos heredados de la clase Enemigo, aportar nuevos métodos y nuevos atributos. La clase Marciano añade el atributo Visible, es decir, nuestro amigo tiene la capacidad de hacerse invisible, y la clase Venusiano añade el atributo NumeroCabezas.

La clase Terricola representa al héroe de nuestro juego y tiene los atributos: NumeroVidas y Municion, ambos requieren poca explicación. Esta clase implementa el método disparar(), que recibe como parámetro un objeto de la clase LanzaCohetes, la relación entre ambas clases es una relación de uso.

La clase LanzaCohetes que representa el arma que va a utilizar la clase Terricola y tienen el atributo NumeroCohetes, y posee el método lanzarCohete().

Podríamos entrar en más detalles e ir afinando más en la identificación de objetos, podríamos definir también la clase Cohete, que representaría a los cohetes lanzados por una instancia de la clase LanzaCohetes. Pero no vamos a entrar en más detalles y vamos a dejar de definir más clases, quedándonos con las vistas hasta ahora.

En la Figura 2 se trata de mostrar un esquema de todas las clases que implementan el problema propuesto y la relación existente entre cada una de ellas. Cada clase se representa por una circunferencia y las relaciones existentes mediante flechas.

Figura 2

Introducción al lenguaje Java

Introducción En este capítulo vamos a comentar las características principales del lenguaje Java, también comentaremos algunos conceptos interesantes que aporta el lenguaje.

Como su nombre indica este capítulo es introductorio, por lo tanto algunos de los conceptos los explicaremos de forma breve y en los sucesivos capítulos profundizaremos en los temas más interesantes.

Por lo tanto en este capítulo todavía no vamos a ver ni una sola línea de código en Java, antes debemos tener claro una serie de puntos acerca del lenguaje.

También comentaremos tres herramientas de desarrollo que podemos utilizar para realizar nuestros desarrollos en Java, se trata de las siguientes:

• JDK (Java Development Kit): herramienta ofrecida por Sun MicroSystems, implementa la versión última y oficial de Java.

• Microsoft Visual J++ 6.0: incluida dentro de Visual Studio 6, ofrece la versión 1.1 de Java.

• Borland JBuilder 3.5: potente entorno de desarrollo que implementa la versión de Java perteneciente a Java 2.

Que el lector no tema por las distintas versiones de Java, en el apartado correspondiente se aclaran las distintas versiones existentes.


22

Breve historia del lenguaje Los orígenes de Java se remontan al año 1990, cuando un equipo de la compañía Sun Microsystems investigaba, bajo la dirección del ingeniero James Gosling, en el diseño y elaboración de software para pequeños dispositivos electrónicos de consumo.

En un primer momento se pensó en la utilización de lenguajes de programación como C o C++, pero para poder compilar un programa en estos lenguajes es preciso adaptarlo a las características de la plataforma en la que debe funcionar, esta situación constituía un gran inconveniente para las compañías dedicadas a la construcción de dispositivos electrónicos, pues cada pocas semanas aparecen en el mercado versiones más potentes y baratas de los chips utilizados, y por lo tanto, el software que se había diseñado para un chip determinado debía modificarse y adaptarse para explotar las características de los chips de reciente aparición.

Se hace patente la necesidad de introducir un nuevo lenguaje de programación, que permita desarrollar programas independientes del tipo de plataforma. Los dispositivos que se pretenden fabricar son calculadoras, relojes, equipos de música, cafeteras, etc.…, que no tienen una gran capacidad computacional, por lo que el nuevo lenguaje debe ser capaz de generar programas pequeños y rápidos, además de ser fiables y robustos.

La primera versión de este nuevo lenguaje se denominó Oak (roble), pero más tarde Sun descubrió que este nombre estaba ya registrado, y lo tuvieron que cambiar, el nuevo nombre fue Java (una de las versiones sobre el significado del nombre es que Java es un término popularmente empleado en California para designar café de buena calidad).

A comienzos de 1993 aparecieron nuevas herramientas gráficas para facilitar la comunicación y navegación por Internet, se concibió la idea de aplicar técnicas de documentos con enlaces de tipo hipertextual para facilitar la navegación por Internet, y se desarrolló el primer browser (navegador Web o visualizador) de lo que se comenzó a denominar World Wide Web. Esta herramienta era denominada Mosaic.

El equipo de James Gosling se planteó como objetivo la utilización de Java como lenguaje en el que escribir aplicaciones que pudiesen funcionar a través de Internet. Como resultado de su trabajo se desarrolló un nuevo navegador completamente escrito en Java, llamado HotJava. Este navegador permitía la integración de pequeñas aplicaciones en el interior de las páginas Web. El desarrollo de HotJava hizo patente que las características de Java se adaptan perfectamente a las peculiaridades de Internet.

A partir de su primera y sencilla versión Java ha ido creciendo progresiva y espectacularmente para pasar a ofrecer un potente y complejo lenguaje con el que se pueden abarcar una gran cantidad de campos.

Descripción del lenguaje En este apartado vamos a resaltar las características principales del lenguaje Java y comentaremos una serie de términos y conceptos que se hacen indispensables para comprender lo que nos ofrece el lenguaje de programación que nos ocupa.

Java es un lenguaje de programación orientado a objetos de propósito general, de ahí la necesidad de estudiar el capítulo anterior dedicado íntegramente a la Programación Orientada a Objetos. Según indican desde Sun Microsystems, Java es un lenguaje creado para realizar una programación en Internet rápida y fácil, rápida y fácil si ya poseemos conocimientos previos de C++ y de programación

© Grupo EIDOS 2. Introducción al lenguaje Java

23

orientada a objetos. Por lo tanto si el lector ya ha programado en C++ la curva de aprendizaje del lenguaje Java se suavizará considerablemente.

Aunque no se debe considerar a Java como una herramienta exclusiva y únicamente para la programación en Internet, ya que su uso, lejos de restringirse a este campo, puede y debe extenderse a problemas y situaciones de todo tipo, por lo tanto para evitar confusiones el lenguaje Java se podría definir mejor de la siguiente forma: Java es un lenguaje de programación orientado a objetos, de propósito general que presenta características especiales que lo hacen idóneo para su uso en Internet.

Una de estas características son los applets. Un applet es un programa dinámico e interactivo que se puede ejecutar dentro de una página Web que se carga en un navegador Web, y otra característica para la utilización de Java en Internet son los servlets. Un servlets es una aplicación Java que se ejecuta sobre un servidor y que atiende una serie de peticiones realizadas desde un cliente que será un navegador Web. A diferencia de los applets los servlets no presentan interfaz gráfico.

Java toma prestadas características y sintaxis de diferentes lenguajes de programación. La sintaxis básica de Java está sacada del lenguaje C/C++ aunque al contrario de estos lenguajes Java es un lenguaje fuertemente tipado.

De Smalltalk Java toma conceptos como el recolector de basura (garbage collector, concepto que se explicará más adelante) y un sólido modelo de orientación a objetos, como iremos comprobando a lo largo del presente curso. De Objective-C, Java toma el concepto de interfaz, en el capítulo correspondiente veremos como define e implementa Java los interfaces.

El mecanismo de herencia que posee Java, se denomina herencia simple, esto quiere decir que cada clase Java sólo puede tener una superclase o clase padre. En otros lenguajes de programación como C++, las clases pueden heredar de diferentes superclases, esto se denomina herencia múltiple, la cual no emplea Java. Pero Java posee un mecanismo que le permite simular la herencia múltiple, este mecanismo se consigue a través de los interfaces.

Como ya adelantábamos, el concepto de interfaz lo toma Java del lenguaje Objective-C. Un interfaz es una colección de nombres de métodos sin definiciones reales que indican que una clase tiene un conjunto de comportamientos, además de los que la clase hereda de sus superclases. Por lo tanto un interfaz es una lista de métodos sin ninguna implementación, la palabra reservada implements es utilizada en la declaración de una clase para indicar que implementa los métodos de un interfaz determinado. Más tarde, en el curso, retomaremos el concepto de interfaz.

Al ser un lenguaje de Programación Orientada a Objetos, la unidad básica dentro de la programación en Java va a ser la clase y el objeto. Java está compuesto por un gran número de clases que se agrupan y clasifican en paquetes, en el capítulo dedicado a la POO con Java veremos como se estructura la jerarquía de clases que presenta el lenguaje.

Pero a pesar de estar compuesto de clases, en Java nos encontramos también con una serie de tipos de datos predefinidos similares a C o C++, estos tipos, denominados tipos primitivos son: int, byte, short, char, long, boolean, float y double. Por lo tanto en Java podremos definir variables de estos tipos de datos, en este caso se empleará la denominación variable en lugar de objeto, ya que los tipos primitivos no son clases. En el próximo capítulo volveremos a retomar los tipos primitivos.

Java presenta una completa y compleja jerarquía de clases, esto le hace un lenguaje muy potente, ya que para cada tarea a realizar existe una clase determinada que se encuentra especializada para realizar una función específica.

Se puede considerar que por un lado tenemos el lenguaje Java, que es con el que escribimos nuestras clases y compilamos, y por otro se encuentra la Máquina Virtual de Java, JVM (Java Virtual


24

Machine). Para garantizar que los programas son independientes de la plataforma (capacidad del programa de trasladarse con facilidad de un sistema computacional a otro) hay una sola arquitectura a la que todos los programas Java son compilados, es decir, cuando se compila un programa Java en una plataforma Windows/Intel, se obtiene la misma salida compilada que en un sistema Macintosh o Unix. El compilador compila no a una plataforma determinada, sino a una plataforma abstracta llamada Máquina Virtual de Java.

La especificación de la Máquina Virtual de Java define la JVM como: una máquina imaginaria que se implementa emulando por software una máquina real. El código para la Máquina Virtual de Java se almacena en ficheros .class, cada uno de los cuales contiene al menos el código de una clase pública, en el capítulo dedicado a la POO con Java comentaremos en detalle la visibilidad de las clases (públicas o privadas).

Por lo tanto, cuando se escribe una aplicación Java o un applet Java (después veremos estos dos tipos de programas que se pueden construir en Java), se está escribiendo un programa diseñado para ejecutarse en la Máquina Virtual de Java. La Máquina Virtual de Java requiere un código binario especial para ejecutar los programas Java, este código no debe tener instrucciones relacionadas específicamente con la plataforma.

Los archivos binarios Java, que se obtienen al compilar el código fuente, son independientes de la plataforma y pueden ejecutarse en múltiples plataformas sin necesidad de volver a compilar el fuente. Los archivos binarios Java se encuentran en una forma especial llamada bytecode, que son un conjunto de instrucciones muy parecidas al código máquina, pero que no son específicas para ningún procesador.

El compilador Java toma el programa Java y en lugar de generar código máquina específico para los archivos fuente, genera un bytecode. Para ejecutar un programa Java, se debe ejecutar un programa llamado intérprete de bytecode, el cual a su vez ejecuta el programa Java deseado. En el caso de los applets el intérprete se encuentra integrado en el navegador Web con capacidad para Java y es ejecutado automáticamente. El concepto de independencia de la plataforma es ilustrado en la Figura 3.

Figura 3


25

La desventaja de utilizar los bytecodes es la velocidad, estos programas tienen una menor velocidad de ejecución, ya que previamente a ejecutarse sobre el sistema, deben ser procesados por el intérprete.

Aunque según van apareciendo nuevas versiones del lenguaje Java la velocidad de ejecución se va mejorando, se alcanzará la máxima velocidad y eficacia cuando aparezcan los chips Java. Se trata de una versión hardware del intérprete Java presente en los programas navegadores con capacidad para este lenguaje, es decir, es una implementación hardware de la Máquina Virtual de Java. Estos chips serán los encargados de traducir el código Java sobre la marcha, por lo tanto no será necesaria la etapa intermedia de interpretación de los bytecodes, como se veía en la figura, con lo que se aumentará de forma considerable la velocidad de ejecución. En un principio Sun MicroSystems tiene pensado comercializar estos chips en una especie de tarjeta, que se insertará en un slot del ordenador.

Una polémica entorno a Java se produjo cuando Microsoft lanzó su versión del lenguaje, a través de su herramienta de desarrollo Visual J++. Desde esta herramienta corremos el peligro de generar código Java que sí sea dependiente de la plataforma, en este caso de la plataforma Windows, y si estamos utilizando el lenguaje Java es porque nos interesa su característica de independencia de la plataforma, por lo tanto hay que ser cuidadosos en este aspecto.

Java incluye características de seguridad para reforzar su empleo en Internet. Un problema de seguridad potencial tiene que ver con los applets de Java, que son código ejecutable que opera en la máquina local del usuario que se conecta a la página Web en la que se encuentran los applets. Java emplea verificación de código y acceso limitado al sistema de archivos para garantizar que el código no dañe nada en la máquina local. En el tema y apartados correspondientes comentaremos las restricciones de seguridad que presentan los applets.

Debido a que en Java no existen punteros, la asignación y liberación de recursos tiene algunas particularidades. El recolector de basura (garbage collector) es otro de los aciertos del lenguaje Java, se trata de un hilo de ejecución (thread) que se encarga de rastrear en tiempo de ejecución cada objeto que se ha creado, advierte cuándo desaparece la última referencia a él y libera el objeto por el programador. Es decir, en Java la asignación de memoria es dinámica y automática, cuando se crea un nuevo objeto se destina la cantidad de memoria necesaria, y una vez que se ha dejado de utilizar ese objeto el recolector de basura lo localiza y se apropia de la memoria que empleaba el objeto. Por lo tanto no es necesario realizar ninguna liberación explícita de memoria.

Programas en Java: applets y aplicaciones Los programas Java comprenden dos grupos principales: applets y aplicaciones. Un applet (denominado por algunos autores miniaplicación) es un programa dinámico e interactivo que se ejecuta dentro de una página Web, desplegada por un navegador Web con capacidad para Java como puede ser Navigator de Netscape o el Internet Explorer de Microsoft, por lo tanto los applets para ejecutarse dependen de un navegador Web habilitado para Java. Los applets es uno de los principales motivos que han hecho al lenguaje Java tan popular, sin embargo no son tan potentes como las aplicaciones.

Las aplicaciones Java son programas más generales que los applets. No requieren un navegador para ejecutarse sólo necesitan de un intérprete de Java para la plataforma en la que se ejecutarán, y pueden emplearse para realizar todo tipo de aplicaciones posibles. Una de las primeras aplicaciones Java que se realizaron fue el navegador Web HotJava. Una aplicación Java consiste en una o más clases, lo único que se necesita para ejecutar una aplicación es tener una clase que funcione como punto de arranque para el resto del programa.


26

Para ejecutar una aplicación Java en un sistema es necesario ejecutar primero la Máquina Virtual, es decir, el intérprete de Java, que permitirá la ejecución de la aplicación, ya que traduce los bytecodes en código nativo. Este paso intermedio a la ejecución de la aplicación Java puede ser molesto, por ello algunos constructores de software han anunciado que pronto incorporarán la Máquina Virtual de Java a sus sistemas operativos, de esta forma las aplicaciones Java se ejecutarán de una manera muy similar a las aplicaciones de otros lenguajes (C, C++, Pascal, etc.…), todas las llamadas a la Máquina Virtual serán transparentes al usuario y serán manejadas por el sistema operativo. Esto es similar a lo que ocurre cuando un navegador carga un applet y lo ejecuta en la Máquina Virtual de forma automática.

Similitudes y diferencias entre Java y C++ Se debe indicar que existen pocas diferencias entre Java y C++, al menos en cuanto al aspecto del código fuente al menos. Las diferencias, gratas en algunos puntos e ingratas en otros, comenzamos a avistarlas cuando profundizamos en el lenguaje. Podremos rentabilizar la inversión de tiempo y esfuerzo invertidos en aprender C++ y controlar la programación orientada a objetos. Todos estos conocimientos serán aprovechables por el programador en Java, sin embargo no es cierto que para conocer Java se debe estudiar previamente C/C++, Java es un lenguaje por sí mismo.

Las cadenas de Java no son punteros a cadenas de caracteres como en C/C++, ya que Java no soporta punteros. Este modo de concebir las cadenas libera al programador de la engorrosa manipulación de cadenas de C/C++. Para manejar cadenas en una aplicación Java disponemos del tipo de dato String, que no es más que una clase definida en el sistema.

Los archivos .class funcionan en cualquier máquina, ya que el intérprete encargado de ejecutarlos está codificado de forma nativa en el sistema receptor de la aplicación. Para lograr lo anteriormente expuesto Java es interpretado, por lo que la velocidad de los ejecutables (que realmente no lo son) es menor que la que lograríamos con el mismo código en C++ (de 10 a 20 veces mayor). Esto no debe preocuparnos, ya que diferentes tecnologías consiguen disminuir esta diferencia llegado, en algunos casos, a igualar la velocidad de C++. De entre estas tecnologías destaca la compilación Just-in-time, que permite la conversión en tiempo de ejecución a instrucciones nativas de la máquina en la que se estén ejecutando los bytecodes.

Dispondremos de una inmensa jerarquía de clases diseñadas para la creación de aplicaciones en la Web. Jerarquía probada y en constante crecimiento. Sun Microsystems facilita gratuitamente una copia del JDK del producto (acorde al sistema operativo bajo el que funcionará), con todos los elementos necesarios para crear aplicaciones con Java. La distribución del intérprete no es necesaria si estamos distribuyendo una miniaplicación (applet) enlazada a una página Web, ya que el navegador correspondiente sería capaz de realizar una compilación Just-in-Time del applet. En caso de no ser así y sí necesitar el intérprete, éste sería de libre distribución.

Otra diferencia notable es que Java no soporta la herencia múltiple, es decir, no puede heredar de varias clases, sin embargo C++ si soporta heredar de varias clases padre. Se puede decir que Java ofrece una Programación Orientada a Objetos simplificada en este aspecto.

Versiones del lenguaje La última versión del lenguaje Java es lo que se denomina Plataforma Java 2 (Java 2 Platform) que se corresponde con las dos últimas versiones de la herramienta de desarrollo de Sun Microsystems, es decir, con el JDK (Java Development Kit) 1.2 y el JDK 1.3, este último de muy reciente aparición. Anteriormente había una correspondencia entre la versión del lenguaje Java y la versión de la herramienta JDK, así la versión 1.1 de Java se correspondía con la versión 1.1 del JDK.


27

Ahora vamos a comentar las correspondencias entre las versiones de Java y las distintas herramientas de desarrollo de las que vamos a tratar en este curso. Aunque desde este momento se debe aclarar que este curso no está enfocado a la utilización de ninguna herramienta de desarrollo de terceros como Borland JBuilder o Microsoft Visual J++, sino que se trata la versión estándar del lenguaje, es decir, la que ofrece Sun con su JDK, y en este caso se trata del JDK 1.3, aunque todo lo que vamos a ver es aplicable también al JDK 1.2.

La herramienta de desarrollo de Java de la compañía Microsoft, Visual J++ 6.0, soporta la versión 1.1 del lenguaje. Esta herramienta puede interesarnos si lo que vamos a utilizar es la versión 1.1 de Java, esto no es ninguna contradicción, ya que la propia Sun sigue ofreciendo una versión del JDK para la versión 1.1 de Java, se trata del JDK 1.1.8. La versión 1.1 de Java sigue estando vigente debido a la rápida evolución que está sufriendo el lenguaje.

Algunos de los ejemplos ofrecidos en el curso no funcionarán dentro de Visual J++ ya que se corresponderán con nuevas características de Java, de todas formas esta situación se le indicará al lector cuando se produzca.

La herramienta de desarrollo Borland JBuilder 3.5, de la compañía Inprise, implementa la Plataforma Java 2, equiparándose a la herramienta de Sun JDK 1.2. Si el lector quiere utilizar la última versión de Java es recomendable que utilice JBuilder 3.5. Además en diversos estudios comparativos entra distintas herramientas de desarrollo del lenguaje Java, Borland JBulider ha sido casi siempre la mejor considerada.

El lenguaje Java todavía no ha tenido una versión definitiva ni estable, cosa que supone un grave inconveniente para los sufridos desarrolladores, que tenemos que estar actualizándonos continuamente. Según se ha comunicado desde Sun Microsystems, la versión Java 2 Platform es la versión definitiva del lenguaje, esperemos que esto sea cierto, ya que desde mediados/finales del año 1996 se han sucedido un gran número de versiones, y el seguimiento y aprendizaje del lenguaje resulta verdaderamente agotador y desconcertante.

Entornos de desarrollo Como ya hemos dicho a lo largo de este capítulo vamos a comentar en el curso tres herramientas de desarrollo distintas para utilizar en la realización de nuestros programas en Java, aunque siempre utilizando el estándar del lenguaje Java.

La herramienta de desarrollo oficial de Java es el JDK (Java Development Kit). La herramienta JDK la podemos obtener de forma gratuita desde el sitio Web que posee Sun Microsystems dedicado por completo al lenguaje Java, http://java.sun.com.

Las versiones actuales de este producto son la 1.1.8, la 1.2 y la 1.3, correspondiéndose la primera con la versión 1.1 de Java y las dos últimas con la última versión denominada Java 2 Platform. Debido a que muchos fabricantes todavía no soportan la versión nueva de Java y también debido a que la nueva versión es bastante reciente, coexisten las dos versiones del lenguaje.

Sun Microsystems no nos lo pone fácil con las nomenclaturas de versiones y de productos, y si acudimos a su sitio Web para descargar el JDK, vemos que no aparece la versión 1.2 ni la 1.3. Esto es debido a que el JDK se encuentra incluido en lo que se denomina Java 2 SDK (Software Development Kit). De esta forma si deseamos la versión 1.2 del JDK veremos descargar el producto Java 2 SDK Standard Edition v 1.2, y si lo que deseamos es tener el JDK 1.3 debemos conseguir el Java 2 SDK Standard Edition v 1.3. A los efectos del presente curso las dos versiones del Java 2 SDK son válidas.


28

El código que generemos en los ejemplos y las características del lenguaje que vamos a utilizar a lo largo de todo el curso se corresponden todas con el JDK de Sun Microsystems, es decir, vamos a utilizar Java estándar. Por lo tanto el único software completamente necesario para seguir el curso satisfactoriamente es el Java 2 SDK Standard Edition.

El entorno de desarrollo ofrecido por Sun es bastante pobre, ya que se basa en modo comando, es decir, no ofrece un entorno gráfico, el código lo escribiremos con un editor de texto y luego lo podremos compilar, ejecutar, depurar, etc., con una serie de programas incluidos en el JDK, pero siempre desde la línea de comandos.

Pero para mostrar el panorama actual de herramientas de desarrollo de Java se ha decido incluir dos entornos de desarrollo más. Además estos entornos son más amables de utilizar que el ofrecido por Sun, ofreciendo cada uno de ellos un interfaz gráfico que permite que el desarrollo de aplicaciones Java sea más sencillo y rápido.

Una de estas herramientas de desarrollo que vamos a comentar en este curso es, como ya hemos adelantado, Microsoft Visual J++ 6.0. Esta herramienta forma parte de la suite de herramientas de Microsoft Visual Studio 6.0.

Microsoft Visual J++ 6.0 ofrece un entorno de desarrollo amigable. Sin embargo, como ya habíamos comentado anteriormente, el JDK ofrece un entorno de desarrollo bastante árido, el editor que se propone es el Edit de MS-DOS o cualquier otro editor de texto que no genere un formato para el texto. El entorno de compilación y depuración es bastante pobre y además se basa completamente en la línea de comandos de MS-DOS.

El mayor inconveniente que presenta Visual J++ 6.0 es que en algunos casos puede generar código Java que no pertenece al estándar del lenguaje. Pero en este curso se va a tratar el lenguaje Java estándar no la implementación particular de Microsoft. Se podría decir que vamos a ver el lenguaje Java 100% de Sun.

Aunque no utilicemos la implementación que realiza Microsoft del lenguaje, nos podemos beneficiar del entorno de desarrollo que ofrece Microsoft, que como ya hemos dicho es mucho más fácil de utilizar y más amigable que el ofrecido por Sun.

A lo largo del curso comentaremos en detalle Visual J++ 6.0 y cómo debemos utilizarlo para generar código Java completamente estándar.

Pero el mayor inconveniente que presenta Visual J++ 6.0 es que recoge únicamente hasta l versión 1.1 del lenguaje Java, esto en algunos casos puede ser suficiente, pero veremos que en otros no, sobre todo si queremos utilizar las nuevas características de Java 2, como pueden ser la utilización de componentes avanzados (Swing) para construir interfaces de usuario o el acceso a datos mejorado que ofrece a través de JDBC 2.0.

Otro punto en contra de Visual J++ es que ofrece un entorno gráfico, pero no es todo lo gráfico que se podría desear, es decir, no permite construir interfaces de usuario al modo de otras herramientas como pueden ser Visual Basic o Delphi, dónde podemos arrastran controles o elementos del interfaz de usuario y situarlos en el lugar deseado, sino que todo lo debemos hacer a través de programación sin que Visual J++ genera una única línea de código fuente.

Podemos decir que el segundo entorno de desarrollo utilizado en este curso Borland JBuilder 3.5 soluciona las dos deficiencias que plantea Visual J++. Por un lado ofrece la versión del lenguaje correspondiente a la Java 2 Platform(Plataforma Java 2) y un entorno de desarrollo que permite la creación visual de interfaces de usuario con generación de código Java incluida.


29

De todas formas en los sucesivos capítulos veremos con más detenimiento cada uno de estos entornos de desarrollo.

Características de la plataforma Java 2 Este apartado muestra de forma general las características que incluye el lenguaje Java en su última versión y que han ido evolucionando desde la versión 1.0. El contenido de este apartado es a modo informativo, el lector no tiene porque comprender los términos que se van a utilizar en este apartado.

Este apartado puede ser útil a lectores que ya conozcan algunas de las versiones anteriores del lenguaje y también nos sirve para observar las nuevas características que ha ido implementando el lenguaje.

• Internacionalización: permite el desarrollo de applets localizables, es decir, un mecanismo de localización sensible a la hora y fecha locales. Se incluye también la utilización de caracteres Unicode. Unicode tiene la capacidad de representar unos 65.000 caracteres, un número bastante amplio para incluir los caracteres de la mayoría de los lenguajes hablados hoy en día.

• Seguridad y firma de applets: el API (aquí entendemos como API un conjunto de clases más o menos complejo que cumplen una funcionalidad común) de seguridad de Java está diseñado para permitir a los desarrolladores incorporar funcionalidades de seguridad a sus aplicaciones. Contiene APIs para firma digital y tratamiento de mensajes. Existen interfaces para la gestión de claves, tratamiento de certificados y control de accesos. También posee APIs específicos para el mantenimiento de certificados X.509 v3 y para otros formatos de certificado. Además se ofrecen herramientas para firmar ficheros JAR (Java Archive).

• Ampliaciones del AWT: el AWT (Abstract Window Toolkit) es un API encargado de construir el GUI (Graphical User Interface, interfaz de usuario gráfico). El AWT de la versión 1.0 fue diseñado para construir sencillos interfaces de usuario por lo tanto se hizo necesario el ampliar el AWT en la versión 1.1. Estas ampliaciones tratan de resolver las principales deficiencias del AWT , además, representan un comienzo en la creación de una infraestructura más rica para el desarrollo de complicados interfaces de usuario, esto incluye: APIs para la impresión, componentes scroll, menúes popup, portapapeles (copiar/pegar), cursores para cada componente, un modelo de eventos nuevo basado en la delegación de eventos (Delegation Event Model), ampliaciones en el tratamiento de imágenes y gráficos, y un tratamiento de fuentes más flexible de cara a la característica de internacionalización.

• JavaBeans: inicialmente se puede definir un JavaBean como un componente software reutilizable, que puede ser manipulado visualmente en una herramienta de desarrollo. Consta de una colección de una o más clases Java que suelen encontrarse en un único fichero JAR (Java Archive). Un JavaBean sirve como un objeto independiente y reusable. El API de los JavaBeans define un modelo de componentes software para Java. Este modelo, desarrollado de forma coordinada entre las compañías Sun, Borland Inprise y otras, es una especificación de como codificar estos componentes para que puedan ser utilizados en diferentes entornos de programación. Un ejemplo de la utilización de los JavaBeans la ofrece la herramienta de desarrollo de Java JBuilder, de la compañía Borland Inprise (también ofrece una herramienta llamada BeansExpress que permite una fácil construcción de JavaBeans). Esta herramienta posee un gran número de JavaBeans como pueden ser los diferentes componentes para la construcción interfaces de usuario (botones, listas, paneles, ventanas, botones de selección, barras de menú, etc.…). Al igual que estos componentes son utilizados por el entorno JBuilder, se pueden incluir dentro de cualquier herramienta de desarrollo que respete y reconozca las características de los JavaBeans. Si creamos un componente con las


30

especificaciones de los JavaBeans, ocultando los detalles de implementación y solamente mostrando las propiedades, métodos y eventos públicos conseguiremos las siguientes ventajas:

1. Pueden ser utilizados por otros desarrolladores usando un interfaz estándar.

2. Se pueden situar dentro de las tablas de componentes de diferentes herramientas de desarrollo.

3. Se pueden comercializar por separado como si se tratara de un producto.

4. Pueden ser actualizado con un impacto mínimo sobre los sistemas en los que se encuentre.

5. Es un componente escrito en Java puro, por lo tanto es independiente de la plataforma.

• Ficheros JAR (Java ARchive): este formato de fichero presenta muchos ficheros dentro de uno, y además permite la compresión de los mismos. Varios applets y sus componentes requeridos (ficheros .class, imágenes y sonidos) pueden encontrarse dentro de un fichero JAR y por lo tanto cargados por un navegador en una sola petición HTTP. Este formato de ficheros es parecido a los ficheros Cabinet de Microsoft.

• Mejoras en Swing: Swing es el otro API existente para crear interfaces de usuario gráficos, ofrece muchos más componentes que el API AWT. Además los componentes Swing permiten modificar su aspecto y comportamiento.

• Ampliaciones de Entrada/Salida: el paquete java.io ha sido ampliado con flujos de caracteres, que son parecidos a los flujos de bytes excepto en que contienen caracteres Unicode de 16 bits en lugar de 8 bits. Los flujos de caracteres simplifican la escritura de programas que no dependen de una codificación de caracteres determinada, y son más fácil de internacionalizar.

• El Paquete java.math: este paquete ofrece dos nuevas clases BigInteger y BigDecimal, para el tratamiento de operaciones numéricas. Un paquete, que definiremos en detalle más adelante, podemos decir que es un conjunto de clases relacionadas entre sí. Los paquetes es una manera de organizar y clasificar las clases que posee el lenguaje Java.

• JDBC 2.0: JDBC es un API para ejecutar sentencias SQL (Structured Query Language), que ofrece un interfaz estándar para el acceso a bases de datos. Ofrece un acceso uniforme a un amplio número de bases de datos. El código de este API está completamente escrito en Java, de hecho se encuentra en el paquete java.sql, por lo tanto ofrece también independencia de la plataforma. Está basado y es muy similar a ODBC (Open Database Connectivity). Usando JDBC es muy sencillo enviar sentencias SQL a cualquier base de datos relacional, gracias al API de JDBC no es necesario escribir un programa que acceda a una base de datos Sybase, otro programa que acceda a una base de datos Oracle u otro que acceda a una base de datos Informix, el mismo programa servirá para ejecutar las sentencias SQL sobre todas estas bases de datos. Básicamente JDBC permite: establecer una conexión con una base de datos, enviar sentencias SQL y procesar los resultados. En la versión 2.0 de JDBC se ha mejorado el acceso a datos haciéndolo más potente a través de la creación de diferentes tipos de cursores para acceder a los datos.

• JFC (Java Foundation Classes): con este nombre se agrupan un gran número de clases especializadas en la construcción de interfaces de usuario. Dentro de JFC se encuentran las APIs ya mencionadas para la construcción de interfaces de usuario, es decir, Swing y AWT. Además incluye características de accesibilidad que permiten utilizar tecnologías tales como lectores de pantalla o dispositivos Braille, utilización de gráficos en 2 dimensiones, soporte


31

para arrastrar y soltar (Drag and Drop), posibilidad de modificar el aspecto y comportamiento de los componentes gráficos (pluggable Look and Feel), etc.

• Servlets: los servlets son aplicaciones Java que se ejecutan en servidores Web y que permiten construir páginas Web de forma dinámica. También permiten obtener información de los formularios enviados por los clientes. Son una tecnología que realiza funciones similares a los scripts CGI (Common Gateway Interface) y a las páginas ASP (Active Server Pages).

Sintaxis del lenguaje Java

Introducción Este capítulo no podría faltar tampoco en nuestro curso de Java, este es el típico capítulo que tienen todos los cursos o libros que traten un lenguaje de programación.

En este capítulo vamos a tratar la sintaxis del lenguaje Java. Los alumnos que ya conozcan C o C++ verán que la sintaxis es muy similar, de todas formas recomiendo a todos la lectura de este capítulo. Este capítulo es necesario para saber como escribir el código Java, en el próximo capítulo veremos como implementar los mecanismos de la POO a través de Java.

Veremos que muchos de los elementos del lenguaje Java son comunes al resto de los lenguajes existentes.

Identificadores Los identificadores son literales que representan nombres únicos para ser asignados a objetos, variables, clases y métodos, de este modo el compilador puede identificarlos unívocamente. Estos nombres sirven al programador, si éste les da sentido.

Por ejemplo, si vamos a implementar una clase para manejo del fichero de clientes, sería recomendable que la misma se llamara algo así como ClientManager, o ManejadordeCliente, no tendría sentido, aunque es totalmente válido llamarla Aj23.


34

Existen de todos modos algunas limitaciones a la hora de dar nombres a los identificadores, que son las mismas que en la mayoría de los lenguajes.

Los identificadores tienen que comenzar por una letra, un subrayado o un símbolo de dólar, tras este carácter, se pueden utilizar combinaciones de los ya mencionados y números del 0 al 9. No pueden utilizarse, como es lógico, las palabras clave del lenguaje como identificadores (que mostraremos más adelante). Aunque estos identificadores pueden ser cualquier longitud, para el compilador sólo son significativos los primeros 32 caracteres.

Se debe tener cuidado al escribir los identificadores, porque Java distingue entre mayúsculas y minúsculas, de este modo, Nombre y nombre son dos variables diferentes.

Java permite el uso de cualquier carácter del código Unicode para definir identificadores, de esta forma, el identificador Año es totalmente válido en Java.

A la hora de nombrar los identificadores, Java presenta una serie de normas de estilo de uso generalizado, lo que significa que se pueden adoptar o rechazar sin que ello influya en lo más mínimo en el comportamiento del código, pero se debe advertir que la mayor parte del código Java existente utiliza estas normas.

En Java se utiliza el word-mixing (EsteEsUnEjemploDeWordMixing), la primera letra se escribe en mayúscula (ManejadorDeClientes, por ejemplo) para las clases, y no se utilizan los signos subrayado ni dólar como primer carácter de un identificador. Esta última norma, tiene su explicación: las librerías de C que se utilizan en Java, suelen utilizar los caracteres de subrayado y dólar como primeros caracteres de sus identificadores, por lo que evitándolos, nos evitamos problemas de conflictos de duplicidad. Otro dato de interés a este respecto es que a las clases no se les pone ninguna identificación delante, ya que en Java todo son clases.

Los nombres de variables, objetos y métodos en Java, aunque se utiliza word-mixing, comienzan con una minúscula, por ejemplo: toUpper().

Aun cuando esta es una sugerencia y no una norma, es conveniente seguirla, ya que así está notada toda la jerarquía de clases de Java, y al distinguir el lenguaje entre mayúsculas y minúsculas, ni podemos escribir estos nombres de otro modo ni debemos dar a nuestros identificadores de variables y métodos nombres con la primera letra en mayúsculas (para mantener la consistencia con el estilo de los creadores del Java).

Sin embargo, en el caso de las variables (aquí y en adelante el termino variable se refiere al nombre de los objetos o de las variables de los tipos primitivos de Java), a muchos programadores nos gusta notar el tipo al que pertenecen, clarificando así el código. De este modo, si una variables es de tipo cadena (string) al nombre le precedería la letra "s". Por ejemplo, sNombre es el identificador de una variable que contiene una cadena.

En la Tabla 1, se ofrece una sugerencia para los prefijos de nombres de variables atendiendo a su tipo. Por supuesto, que esto es sólo una indicación y no una norma que se tenga que seguir.

Identificadores de variables

Prefijo Tipo Ejemplo

a array aElementos

b boolean bCancelar

© Grupo EIDOS 3. Sintaxis del lenguaje Java

35

c char cInicial

d double dDistancia

f float fInterés

i integer iColumna

l long lCantidad

s string sNombre

Tabla 1

Para los identificadores de variables que se refieren a objetos, utilizaremos tres letras como prefijo, intentando que estas tres letras indiquen de la forma más clara posible el nombre de la clase a la que el objeto pertenece.

Por ejemplo, si instanciamos un objeto de la clase Frame, el prefijo podría ser "frm", seguido del nombre que queramos darle a la variable, por ejemplo, frmClientes.

Palabras clave Las palabras clave son identificadores reservados por el lenguaje. Aunque el alumno sea programador de C o C++, le sugerimos que lea con detenimiento la siguiente tabla, ya que Java tiene un número mayor de palabras reservadas que C y C++.

Palabras Clave

abstract continue for new switch

boolean default goto null synchronized

break do if package this

byte double implements private threadsafe

byvalue else import protected throw

case extends instanceof public transient

catch false int return True

char final interface short Try

class finally long static Void

const float native super while

Tabla 2


36

Además de estas, existen algunas palabras reservadas, ahora no se utilizan pero es posible que se conviertan en palabras clave en un futuro. Son las siguientes:

cast, future, generic, goto, inner, operator, outer, rest, var

Literales Llamamos literales a aquellos elementos de un programa que no pueden variar. Se les llama también constantes.

Los literales pueden ser: números, caracteres y cadenas. Los literales numéricos se dividen en: enteros, coma flotante y booleanos (álgebra de Boole). De hecho, los literales booleanos están incluidos en Java dentro de los numéricos por su herencia del C, ya que en C verdadero es 1 y falso 0. Los literales de caracteres no son ASCII sino Unicode, por ello un carácter en Java necesita 16 bits para ser representado, en lugar de 8 como ocurre en otros lenguajes.

Los literales dan en Java lugar a cada uno de los tipos básicos, anteponiéndoles la palabra reservada correspondiente a la hora de declararlos.

Enteros Los enteros, dependiendo de la precisión que el número pueda tener se dividen en los siguientes tipos primarios:

• byte 8 bits complemento a dos

• short 16 bits complemento a dos

• int 32 bits complemento a dos

• long 64 bits complemento a dos

Los enteros se almacenan por defecto internamente como tipo int, que es un valor de 32 bits con signo. Si fuese necesario que un literal entero se almacenase como de tipo long, puede hacerse añadiendo una l o L al final del literal, lo que hace que el número se guarde internamente como un valor de 64 bits. Así, el número 42 se representaría como de tipo int, mientras que 42L, sería un long.

Estos, pueden representarse en tres formatos diferentes: decimal, octal y hexadecimal. Dependiendo de la base del sistema numérico en la que se deseen representar.

Los enteros en su representación decimal, no necesitan ninguna notación especial. Para hexadecimal (base 16) se antepone el prefijo 0x o 0X, y para base 8 (sistema octal) se antepone un 0 inicial. Así, el número decimal 42 en Java puede representarse como indica la Tabla 3.

Decimal Hexadecimal Octal

42 0x2A 052

Tabla 3


37

Coma flotante Al igual que los literales enteros pueden ser de cuatro tipos diferentes, los reales en coma flotante –números con parte entera y parte decimal–, pueden ser de dos tipos: float y double. Los primeros se almacenan en 32 bits, mientras que los segundos se almacenan en 64 bits. La única diferencia, es su capacidad de precisión, debida la mayor cantidad de información que necesitan para representarlos.

Por defecto, los literales en coma flotante son del tipo double, a diferencia de los enteros, donde no se toma como predeterminado el de mayor precisión. Pero si se desea expresar uno de estos literales en tipo float, basta con añadir una f o F al final del literal (para forzar tipo a double se añade una d o D, pero puesto que este es ya tipo predeterminado, esto sólo sirve en caso de querer dar mayor claridad al código).

Ambos (float y double) pueden representarse en notación estándar (3,14159) o científica (314159e-5).

• float 32 bits IEEE 754

• double 64 bits IEEE 754

Booleanos El tipo booleano se ha implementado en Java para representar los valores de verdadero y falso, que en C se representan con un literal entero (0 falso y 1 o cualquier cosa que no sea 0, verdadero). Se utiliza para ello dos palabras reservadas: true y false.

• true verdadero

• false falso

Caracteres Los caracteres, que se refieran un único carácter Unicode, se representan al igual que en C, entre comillas simples. También pueden incluirse caracteres de control no imprimibles. En la Tabla 4 se ofrecen estos caracteres.

Descripción Representación

Barra invertida \\

Continuación \

Retroceso \b

Retorno de carro \r

Alimentación formularios \f

Tabulador horizontal \t


38

Línea nueva \n

Comillas simples \’

Comillas dobles \"

Carácter unicode \udddd

Carácter octal \ddd

Tabla 4

Ejemplos de literales de carácter: a \n \u0042

Cadenas Un literal de cadena es un conjunto de caracteres agrupados. Se representan entre comillas dobles.

Java, cada vez que encuentra un literal de tipo cadena, crea una nueva instancia de la clase String, a diferencia del lenguaje C, donde un string es un array de caracteres. En Java podemos también, si así lo deseamos, crear un array de caracteres, pero el lenguaje proporciona el tipo String para estos menesteres.

Por ejemplo: "Mi mamá me mima, mi mamá me ama"

El literal null El literal null se corresponde con el tipo null, quien tiene un solo valor: la referencia nula.

Operadores Los operadores en Java, como se verá tienen también gran influencia del C, de hecho, son casi los mismos, y funcionan casi exactamente igual. Los veremos más con detenimiento en el apartado de expresiones y operadores.

Operadores (según tipo)

Unarios ++ -- - ~

Binarios + - * / % Aritméticos

De bits & | ^ << >> >>>

Relacionales < > <= >= = = !=

Booleanos & | ^ && || ! = = != ?:


39

Cadenas +

Asignación = += -= *= /= %= &= |= ^=

Tabla 5

Separadores Sólo hay un par de secuencias con otros caracteres que pueden aparecer en el código Java; son los separadores simples, que van a definir la forma y función del código. Los separadores admitidos en Java son los que se detallan en la Tabla 6

Separadores

( ) paréntesis Para contener listas de parámetros en la definición y llamada a métodos. También para definir precedencia en expresiones, contener expresiones para control de flujo y rodear a las conversiones de tipo.

{ } llaves Para contener los valores de matrices inicializadas automáticamente. También se utiliza para definir un bloque de código, para clases, métodos y ámbitos locales.

[ ] corchetes Para declarar tipos matriz así como para referenciar los valores de la matriz.

; punto y coma Separador de sentencias.

, coma Separa identificadores consecutivos en una declaración de variables. También se utiliza para encadenar sentencias dentro de una sentencia for.

. punto Para separar nombres de paquete de subpaquetes y clases. También se utiliza para separar una variable o método de una variable de referencia.

Tabla 6

Comentarios Los comentarios pueden ser considerados como un caso especial dentro de los elementos de la sintaxis del lenguaje, ya que aunque estos sean reconocidos por el compilador, éste los ignora. Las razones son tan obvias, que no vamos a entrar en detalles.

En Java existen tres tipos de comentarios (los dos del C y uno distinto).

Tipos de Comentarios

// comentario Se ignoran todos los caracteres desde // hasta fin de línea


40

/* comentario */

Se ignoran todos los caracteres entre /* y */

/** comentario */

Comentario de documentación (funciona como el anterior)

Tabla 7

Merece especial atención el comentario de documentación. Cuando se emplea este tipo de comentarios, podemos utilizar una herramienta especial llamada JavaDoc (desarrollada por Sun e incluida en la herramienta JDK) para convertir automáticamente el texto que se encuentra abarcado por este tipo de comentarios en documentación de nuestro código fuente. De este modo, la documentación de nuestro código está dentro del propio código, y podemos crearla al tiempo que lo escribimos o modificamos.

Esta herramienta además reconoce ciertos tokens dentro de esta área para dar formato al texto de documentación que se va a crear, pero no vamos a profundizar más en ello.

Tipos de datos en Java Como ya comentamos al hablar de los literales, cada uno de ellos se refiere a un tipo básico de datos, aunque en Java hay algunos tipos de datos que no tienen representación como literales. Estos son los arrays (o matrices) y las clases.

Quizás sea discutible considerar las clases como tipos de datos, pero si retomamos el capítulo dedicado a POO, nos daremos cuenta de que al fin y al cabo, cuando creamos una clase lo que estamos creando no es más que un sistema algebraico: definiendo elementos y operaciones sobre dichos elementos; que es al fin y al cabo, lo que hacemos con los enteros, con los números reales o con las cadenas, es decir con los tipos de datos preestablecidos por el lenguaje.

Ya comentábamos que una clase se podía asemejar a un tipo de datos y un objeto de la clase a una variable de ese tipo de datos.

Veamos, aunque sea muy someramente, ya que los hemos explicado al hablar de los literales, cada uno de los tipos de datos que Java como lenguaje nos proporciona. Aunque previamente, y para poder poner ejemplos de declaración de tipos, debemos indicar la sintaxis de la sentencia de declaración. Esta es (se debe observar que en Java, al igual que en C, las sentencias finalizan con un punto y coma ";"):

<tipo> <idetificador1> [= <valor1>] [, <identificadorN> [=<valorN>]];

o bien, con asignación múltiple:

<tipo> <idetificador1>,... ,<identificadorN> = <valor>;

Enteros Véase el apartado de Enteros en Literales


41

Tipos de datos Enteros

Tipo Tamaño Ejemplo

byte 8 bits Byte edad;

short 16 bits Short alturaEdificio = 614;

int 32 bits Int miCantidad = 3456740, tuCantidad = 645780;

long 64 bits Long distanciaInical, distanciaFinal = 86868688;

Tabla 8

Coma flotante Véase el apartado de Coma flotante en Literales

Tipos de datos de Coma Flotante

Tipo Tamaño Ejemplo

float 32 bits float presión;

double 64 bits double distanciaEstelar;

Tabla 9

Booleanos boolean seguir;boolean cancelarProceso = true, abandonarAplicación = false;

Véase el apartado de Booleanos en Literales

Carácter char inicial;char miInicial = ´F´;

Véase el apartado de Caracteres en Literales

Cadenas String miNombre = "Pep Rubirá"String comillasDobles = "/""


42

Se deben hacer las siguientes consideraciones:

• En este caso, la inicial del nombre de tipo (String, que como ya comentamos es una clase) está en mayúsculas, esto, como ya dijimos es fundamental, ya que Java distingue entre mayúsculas y minúsculas, por lo que si hubiésemos escrito el tipo de dato como "string", el compilador nos reportaría un error al no encontrar ninguna clase que tuviese este nombre.

• En la definición de datos de tipo carácter las comillas son simples y en la de tipo String son dobles.

• Para crear una cadena de caracteres donde se incluyan las comillas, utilizamos la secuencia de escape correspondiente.

Véase el apartado de Cadenas en Literales.

Arrays En Java, los arrays son objetos, son creados dinámicamente y pueden ser asignados a variables de tipo Object, por lo que todos los métodos de la clase Object (esta clase la trataremos en un próximo capítulo) pueden ser invocados desde un array.

Un array tiene un número entero de elementos que lo componen, y nos referimos a ellos por su índice, que obviamente es un entero. Si un array tiene n elementos, el índice varía entre 0 y n-1 ambos inclusive.

Un array puede tener 0 elementos, decimos entonces que el array está vacío. Del mismo modo, un array puede tener una o más dimensiones. En cualquier caso, una vez creado el array éste no puede cambiar de tamaño, es estático (existe en Java la clase Vector, que permite trabajar con "arrays" dinámicos).

Todos los elementos de un array tienen que ser del mismo tipo, aunque estos pueden ser arrays, en tal caso, debe llegar un momento en que los elementos de estos elementos sean datos de otro tipo.

Un array se "fabrica" en dos tiempos: el de declaración y el de creación. En el primero sólo se indican el tipo y las dimensiones de éste, esta información es procesada por el compilador. En el segundo tiempo se crea el array en memoria, para lo que se utiliza el operador new (este operador lo veremos en siguiente capítulo para la creación de objetos), es entonces cuando indicamos el número de elementos que va a contener.

Java no permite por lo tanto declarar arrays al estilo de C, donde al tiempo que se declara un array se indica el número de elementos (int n[10] no es válido en Java). Esto es así porque Java no utiliza punteros, sino objetos para crear variables de tipo array, lo que permite entre otras cosas comprobar los límites del array cada vez que se va acceder a él, y reportar un error si se intenta sobrepasar sus límites, en lugar de dejar colgada la aplicación y el sistema operativo, como ocurre en C.

La declaración de arrays en Java es casi igual que en C, salvo que los corchetes pueden utilizarse tras el nombre de la variable (como en C) o tras el tipo de la variable. También pueden definirse los elementos de un array en la declaración del mismo. Veamos algunos ejemplos de declaración de arrays en el Código fuente 1.

int iNumeros[]; // Declara un array de enteroschar cAlafabeto[]; // Declara un array de caracteres


43

float fTemp[]; // Declara un array de floatsfloat[] fTemp; // Equivalente a la anteriorlong lTabla[][]; // Array de dos dimensioneschar cAlfabeto []= new char[27] // Declara y construye in array de 27 elementosfloat fTemp [][] = new float [10][3] // Declara un array de 2 dimensiones:// una con 10 elementos y la otra con 3 elementosint iPrimos = { 1,3,5,7 } // Declara un array de 4 elementos y le da valores

Código fuente 1

Esto mismo podría haber hecho como indica el Código fuente 2.

int iPrimos[];iPrimos = new int[4];iPrimos[0] = 1;iPrimos[1] = 3;iPrimos[2] = 5;iPrimos[3] = 7;

Código fuente 2

Sin embargo, en las especificaciones de Sun para la versión 1.1 de Java, se ha ampliado levemente la forma en cómo se pueden inicializar los arrays.

Ahora se permite inicializar los contenidos de un array al utilizar el operador new. Lo que flexibiliza la creación de arrays. El Código fuente 3es ahora correcto.

String[] martians = new String[] { "Gidney", "Cloyd" };

Código fuente 3

Empaquetar tipos primitivos Aunque Java es un lenguaje casi 100% orientado a objetos, internamente trabaja con dos tipos de entidades: tipos primitivos y objetos. La forma en como maneja los tipos numérico, booleano y carácter es muy similar a como lo hacen otros lenguajes procedurales como puedan ser C o Pascal, a diferencia de otros lenguajes como SmallTalk para quien todo son objetos.

La única razón de que exista esta diferencia en Java, es que el manejo de tipos primitivos es más eficiente que el de los objetos; y por lo tanto se puede conseguir un mayor rendimiento del sistema.

Sin embargo, muchos de los componentes del lenguaje Java sólo pueden trabajar con objetos, es decir tienen que recibir una instancia que directa o indirectamente provenga de la clase Object, que es la raíz de la jerarquía de clases de Java. Para resolver este conflicto, el lenguaje Java dispone de una serie de clases que empaquetan los tipos primitivos.

El paquete java.lang (se debe recordar que un paquete es una forma de organizar y agrupar clases relacionadas, en los capítulos siguientes trataremos más en detalle los paquetes) contiene las clases de que se dispone en Java para empaquetar los tipos primitivos.


44

Clase Tipo primitivo que empaqueta

Integer Int

Long Long

Float Float

Double Double

Boolean Boolean

Tabla 10

Si se observa la tabla anterior, nos damos cuenta que no existen clases empaquetadoras para los tipos primitivos byte y short, lo que realmente no supone ningún problema, ya que estos dos tipos pueden tratarse como objetos utilizando la clase Integer.

Si echamos un vistazo a la jerarquía de clases del Java, se observará que todas las clases empaquetadoras descienden de la superclase Number.

Conversión de tipos de datos Java al igual que C admite el moldeado de tipo (casting) o conversión de tipos, lo que nos permite convertir un tipo de dato en otro. Lo que se suele utilizar principalmente para cambiar el tipo de dato devuelto por una función para que coincida con el tipo de dato esperado por otra a la que se lo vamos a pasar como parámetro.

Para realizar el moldeado de tipo (casting), se coloca el tipo desea entre paréntesis a la izquierda del valor que vamos a convertir.

El típico ejemplo que muestra esto es el de conversión del valor devuelto por el método read() del sistema estándar de entrada. Este método devuelve un dato de tipo int, y normalmente deseamos almacenarlo como un tipo char, lo convertiremos como muestra el Código fuente 4.

char c;............................................c = (char) System.in.read();

Código fuente 4

A la hora de convertir unos datos a otros, puede perderse información dependiendo de la capacidad de almacenamiento que uno y otro tipo de dato tengan. Por lo que debe tener muy en cuenta la información que hemos dado a este respecto en esta sección.

Si deseamos convertir un tipo de dato cuya capacidad de almacenamiento es de 64 bits (por ejemplo un long) en otro de menor capacidad (por ejemplo un int, con 32 bits), es muy posible que en la conversión perdamos información. Esto ocurrirá si los bits altos (aquellos que están a la izquierda en


45

una representación binaria del número) del dato long tenían información (lo que ocurre con toda seguridad para números muy grandes).

Otro caso distinto de pérdida de información es el que ocurre cuando se moldea un double para convertirlo en un long. Aunque la capacidad de almacenamiento de ambos sea de 64 bits, el tipo double tiene parte entera y parte fraccionaria, mientras que el long sólo tiene parte entera.

Todo esto se debe tener muy presente cuando se vaya a realizar una conversión de tipo, ya que estos errores a veces son difíciles de detectar y nos pueden dar más de un quebradero de cabeza.

En la Tabla 11 presentamos las conversiones en las que no puede haber pérdida de información (conversiones seguras).

Moldeado sin Pérdida de Información

Tipo fuente Tipo Destino

byte short, char, int, long, float, double

short int, long, float, double

char int, long, float, double

int long, float, double

long float, double

float Double

Tabla 11

Bloques y ámbitos

Bloques Al igual que C, Java utiliza las llaves ({} la primera de inicio y la otra de fin de bloque) para determinar los bloques dentro de un programa. Todo lo que se encuentra entre estas dos llaves se considera un bloque. Los bloques son parte de la sintaxis del lenguaje.

Los bloques pueden y suelen anidarse; utilizándose la sangría para clarificar el contenido de un bloque. De este modo, el bloque más externo se sitúa al margen izquierdo del fichero de código fuente, y cada vez que se anida un bloque se indenta (sangra) el texto que lo contienen un número determinado de columnas, normalmente tres o cuatro.

El sangrado no tiene ninguna utilidad para el compilador, pero sin ella la lectura del código por parte del programador es casi imposible.


46

Ámbitos Los bloques además, definen los ámbitos de las variables. El ámbito se refiere a la longevidad de las variables.

Una variable existe sólo dentro del bloque donde ha sido declarada, eliminándola el compilador una vez que se sale de dicho bloque. Esto es cierto para todos los tipos de datos de Java. Si el dato es un objeto, y su clase tiene un destructor asociado (distinto al destructor por defecto, que es interno y Java lo maneja por sí solo) este es invocado al salir la variable de ámbito.

Cuando una variable sale de ámbito, es eliminada y la memoria que ésta ocupaba es liberada por el recolector de basura (garbage collector).

Expresiones Una expresión no es más que una secuencia de elementos que puede ser evaluada por el compilador. Una llamada a una función, una asignación, un cálculo aritmético o lógico son algunos ejemplos de expresiones.

Las expresiones suelen dividirse según su tipo, es decir según el tipo del valor que devuelven al ser resueltas, en: aritméticas y lógicas. Dentro de cada una de ellas existen subdivisiones.

El compilador las analiza y, si está bien construido, las simplifica todo lo posible, evaluándose en tiempo de ejecución.

Algunos ejemplos de expresiones aparecen en el Código fuente 5.

System.out.println( "Hola" + c );a = 21;b = a + b + c + 15;c = (a + b) * (y-7);d = 2 / 3 + 4 * 5d = a && b;e = (a && b) || c

Código fuente 5

Las expresiones se analizan de izquierda a derecha, salvo que existan paréntesis, en tal caso (como ocurre en matemáticas), los fragmentos de la expresión encerrados entre paréntesis son evaluados antes. Si no hubiese paréntesis, hay algunos fragmentos que son evaluados antes que otros, dependiendo de la precedencia (importancia) de los operadores que se encuentran entre los operandos, pero a igual nivel de precedencia, se mantiene la evaluación de izquierda a derecha (sobre precedencia de operadores, consultar el apartado Precedencia de los operadores). En cualquier caso, se recomienda efusivamente para aclarar el código y eliminar posibles errores, utilizar siempre paréntesis para determinar qué fragmentos de la expresión se van a evaluar primero.

En el caso de la expresión de ejemplo cuyo resultado se asigna a la variable d, podemos interpretarla de varias maneras, ya que de no saber en qué sentido se evalúan las expresiones y cual es la precedencia de los operadores, el resultado es imprevisible. De todos modos, adelantamos que esta expresión en Java equivale a lo que muestra el Código fuente 6.


47

d = (2 / 3) + (4 * 5)

Código fuente 6

Este ejemplo ilustra claramente la conveniencia de utilizar los paréntesis al declarar expresiones.

En Java, a diferencia de otros lenguajes de programación, al evaluar una expresión lógica, podemos hacer que esta sea evaluada de forma perezosa o no perezosa, dependiendo del operador que utilicemos.

Una expresión, se evalúa de forma perezosa cuando tras conseguir el resultado buscado, el evaluador no continúa evaluando el resto de las expresiones por la derecha. Veamos un ejemplo.

Supongamos que las siguientes funciones devuelven los valores a continuación indicados:

• Hora() Devuelve la hora actual en formato numérico (0-24 hrs)

• DíasMes() Devuelve el día del mes en formato numérico (1-31)

• Año() Devuelve el año en curso en formato numérico (0-...)

Siendo los operadores tal como se describen:

• || OR no exclusivo

• && AND

Entonces, la siguiente expresión lógica (que puede estar dentro de una instrucción de bifurcación condicional if):

Hora() >= 12 || (DíaMes() > 15 && Año() == 1997)

Se evaluará como indica la Tabla 12.

Evaluación Perezosa

Hora() DíaMes() Año() Forma de evaluarse

14 Al ser true el resultado la función Hora(), la expresión es verdadera, por lo que no es necesario invocar las funciones DíaMes() ni Año().

10 10 Al ser false el resultado devuelto por Hora(), es necesario invocar DíaMes(), pero como su resultado es también false, no es necesario invocar Año(), ya que el resultado de la expresión es false.

10 25 1997

Al ser false el resultado de Hora(), es necesario invocar DíaMes(), y como su resultado es true, el resultado de la expresión depende del valor devuelto por Año(), por lo que es necesario invocar esta función, y en este caso, al ser éste true, el resultado de la expresión es true.


48

10 25 1998 Este caso es idéntico al anterior, pero al ser false el resultado de Año(), el resultado de la expresión es false.

Tabla 12

Sin embargo, en ciertos casos deseamos que la expresión se evalúe completamente, normalmente porque deseamos que todas las funciones que la componen sean invocadas y realicen su cometido. Para estos casos, Java dispone de operadores que fuerzan al evaluador a recorrer toda la expresión. Estos son: &, | y ^.

Puesto que es muy común que las expresiones contengan operadores, ahora vamos a entrar en más detalle sobre los operadores que Java nos proporciona.

Clasificación de operadores En este apartado veremos, organizados según el tipo, los distintos operadores que el lenguaje Java incorpora. El programador de C y/o C++, comprobará que son prácticamente los mismos, aunque Java permite mayor flexibilidad en algunos de ellos y añade algún otro.

Aritméticos

Operadores sobre enteros

Estos operadores pueden aplicarse a todos los tipos de datos enteros: byte, short, int, long. Se dividen en:

• Unarios: utilizan un solo operando para realizar la operación.

• Binarios: utilizan dos operandos para realizar la operación.

• Relacionales: se comparan dos operandos.

Operadores Aritméticos para Números Enteros

Op. Descripción

++ Incremento. Añade una unidad al valor actual de la variable. (1)

-- Decremento. Sustrae una unidad al valor actual de la variable. (1)

- Negación. Equivale a multiplicar por –1 el valor de la variable.

Unarios

~ Complemento a nivel de bits. (2)


49

+ Adición

- Sustracción

* Multiplicación

/ División

% Módulo

<< Desplazamiento a la izquierda. (3)

>> Desplazamiento a la derecha. (3)

>>> Desplazamiento a la derecha con relleno de ceros. (3)

& AND a nivel de bits.

| OR a nivel de bits.

Binarios

^ XOR a nivel de bits.

< Menor que

> Mayor que

<= Menor o igual que

>= Mayor o igual que

= = Igual que

Relacionales

! = Distinto que

Tabla 13

Tanto los operadores unarios como los binarios, independientemente del tipo de los operandos sobre los que se realice la operación, devuelven un int para todos los casos, excepto que uno de los operandos sea un long, en cuyo caso el valor devuelto es de tipo long.

(1) Estos operadores pueden utilizarse en forma de prefijo (++variable) o forma de sufijo (varible++). En el primer caso el incremento (o decremento) de la variable se realiza antes de evaluar la expresión, y en segundo se realiza tras evaluar la expresión.

(2) Este operador conmuta el número a nivel de bits, es decir, todos los bits que estaban a 0 pasan a ser 1, y todos los bits que estaban a 1 pasan a 0.

(3) Estos operadores desplazan los bits a la derecha o izquierda el número de posiciones especificado como segundo operando.


50

Operadores sobre reales

Estos operadores trabajan sobre número de coma flotante, es decir, los tipos: float y double. Lo dicho anteriormente acerca de los operadores sobre enteros es aplicable a los operadores sobre números reales salvo que el resultado de la expresión será de tipo float si ambos operandos son de este tipo y en caso contrario el tipo devuelto será double.

Operadores Aritméticos para Números Reales

Op. Descripción

++ Incremento. Añade una unidad al valor actual de la variable.

Unarios -- Decremento. Sustrae una unidad al valor actual de la

variable.

+ Adición

- Sustracción

* Multiplicación

/ División

Binarios

% Módulo

< Menor que

> Mayor que



= = Igual que

Relacionales

! = Distinto que

Tabla 14

Booleanos

Operadores Booleanos

Operador Descripción

& AND (no perezoso)

| OR (no perezoso)


51

^ XOR (no perezoso)

&& AND (perezoso)

|| OR (perezoso)

! NOT (negación)

= = Igualdad

!= Distinto a

?: Condicional (op. ternario)

Tabla 15

Son aquellos que efectúan operaciones sobre datos de tipo booleano, y como es lógico, el tipo de dato que devuelven es booleano.

Relacionales

< Menor que

> Mayor que



= = Igual que

Relacionales

! = Distinto que

Tabla 16

Cadena En Java existe un solo operador que utilice cadenas como operandos, este es el operador binario +, este operador concatena cadenas. En el Código fuente 7 vemos un ejemplo.

String str1, str2, str3;str1 = "En lugar de la Mancha";str2 = "de cuyo nombre no quiero acordarme";str3 = str1 + " " + str2;

Código fuente 7

Tras aplicar el operador de concatenación de cadenas, el valor la variable str3 es:


52

"En lugar de la Mancha de cuyo nombre no quiero acordarme"

Asignación Estos operadores, salvo el operador de asignación simple (=) se utilizan para escribir menos, y por lo tanto, su forma simplificada es exactamente equivalente a su forma extendida.

Operadores de Asignación

Op. Descripción Equivalencia

= Simple

+= Adición var1 = var1 + var2 var1 += var2

–= Sustracción var1 = var1 – var2 var1 –= var2

*= Multiplicación var1 = var1 * var2 var1 *= var2

/= División var1 = var1 \ var2 var1 \= var2

%= Módulo var1 = var1 % var2 var1 %= var2

&= AND var1 = var1 & var2 var1 &= var2

|= OR var1 = var1 | var2 var1 |= var2

^= XOR var1 = var1 ^ var2 var1 ^= var2

Tabla 17

Precedencia de los operadores A continuación se presenta todos los operadores que hemos visto, según su orden de precedencia de mayor a menor, es decir, según su importancia a la hora de ser evaluados.

Esto quiere decir, que salvo que se agrupen expresiones mediante el uso de paréntesis, aquellos operadores que tengan mayor orden de precedencia, serán evaluados primero.

• [] ()

• ++ --

• ! ~ instanceof

• / %

• + -

• << >> >>>


53

• < > <= >= = = !=

• & ^ |

• && ||

• ? :

• = += –= *= /= %= &= |= ^=

Control de flujo Las sentencias de control de flujo nos permiten que ciertas partes de un programa no se ejecuten (condicionales) o que se ejecuten más de una vez (bucles).

Sin ellas, los programas Java se ejecutarían de arriba abajo, se procesarían todas sus líneas y una sola vez cada una de ellas.

Las condiciones permiten bifurcar el flujo de la aplicación y en Java se dispone de las sentencias if-else y switch, los bucles permiten repetir un fragmento de código un número determinado de veces, y las sentencias disponibles en Java para realiza bucles son: for, while y do-while.

Todas estas sentencias funcionan exactamente igual que sus homónimas de C, por lo que si el alumno las conoce, puede saltárselas tranquilamente.

Java dispone además de otras dos sentencias que permiten hacer saltos: break y continue.

If-else La sintaxis de esta estructura es la siguiente:

if (<ExprBooleana>)sentencia1;

[else [if (<ExprBooleana>) ]sentencia2;]

Aunque también pueden utilizarse bloques en lugar de sentencias, del siguiente modo:

if (<ExprBooleana>) {sentencias;

}[else [if (<ExprBooleana>) ] {

sentencias;}]

<ExprBooleana> puede ser cualquier expresión que, al ser evaluada, devuelva un resultado de tipo Booleano.

Como esta estructura es la más común a través de todos los lenguajes, asumimos que es conocida de sobra, y no entraremos en los detalles de su funcionamiento.


54

Switch La sintaxis de esta estructura es la siguiente:

switch( <Expresión> ) {case <Constante1>:

sentencias;[break;]

[case <Constante2>:sentencias;[break;]........................

][default:

sentencias;[break;]]

}

En esta sentencia, el resultado de la evaluación de <Expresión> es comparado con cada una de las constantes (<Constante1>, <Constante2>,.....) hasta que se encuentra una que coincida, en ese momento se ejecutan todas las sentencias que se encuentran dentro de ese case, hasta encontrar un break, por lo que si no hay un break al final del case, los cases siguientes también se ejecutarán. <Expresión> debe pertenecer a alguno de los tipos primitivos de Java, no puede ser una clase.

Si no se encontrara coincidencia alguna, y existiera la cláusula default, estas sentencias serán ejecutadas hasta encontrar un break. De todos modos, como esta cláusula, caso de existir, siempre se pone la última, no es necesario incluir el break.

Esta rama puede simularse mediante el uso de la rama if-else, pero switch ha sido diseñada específicamente para escoger un resultado de entre un grupo de resultados posibles, y es de suponer que el código que se genera es más eficiente que el que se generaría si usáramos para el mismo propósito una estructura if-else.

Veamos un ejemplo simple de switch, en el Código fuente 8.

switch( iDíaSemana ) {case 1:

sDia = "lunes";break;

case 2:sDia = "martes";break;

case 3:sDia = "miércoles";break;

case 4:sDia = "jueves";break;

case 5:sDia = "viernes";break;

case 6:sDia = "sábado";break;

case 7:sDia = "domingo";break;


55

default:sDia = "No se qué día es";

}

Código fuente 8

En el Código fuente 9 vemos otro ejemplo en el que no utilizamos una sentencia break tras cada case.

int iMes;int iDías;long nAño;. . .switch (iMes) {

case 1:case 3:case 5:case 7:case 8:case 10:case 12:

iDías = 31;break;

case 4:case 6:case 9:case 11:

iDías = 30;break;

case 2:if ( ((lAño % 4 == 0) && !(lAño % 100 == 0)) || (lAño % 400 == 0) )

iDías = 29;else

iDías = 28;break;

default:iDias = 0;

}

Código fuente 9

For La sintaxis del bucle for es la siguiente:

for ( [<ExprInicializa>]; [<ExprCondición>]; [<ExprIteración>])sentencia;

O bien:

for ( <ExprInicializa>; <ExprCondición>; <ExprIteración>){sentencias;

}

Aunque estas tres expresiones pueden utilizarse para el propósito que se desee, normalmente se utilizan para los siguientes fines:

• ExprInicializa: en esta expresión se inicializa la variable(s) que va a controlar el bucle.


56

• ExprCondición: esta expresión controla cuando finalizan las iteraciones del bucle.

• ExprIteración: esta expresión indica cómo cambia la variable de control del bucle.

Se debe señalar que las expresiones son todas optativas, y aunque se pueda escribir un bucle sin ninguna de ellas, no tiene mucho sentido hacerlo. Si así se hiciera, se tendría que mantener los puntos y comas que separan las tres expresiones.

Cada una de estas expresiones que se definen en la cabecera del bucle pueden ser simples o expresiones compuestas separadas por comas. Veamos un ejemplo de cada una de ellas:

Vemos, en el Código fuente 10, expresiones simples.

for (x = 1; x <= 10; x++)System.out.println( x );

Código fuente 10

La cabecera de este bucle for puede leerse del siguiente modo: "Para x igual a uno, y mientras que x sea menor o igual que diez, incrementa x en una unidad".

El Código fuente 11, nos muestra expresiones compuestas.

for (x = 1, t = 30; x <= 10 && t-=x != 20; x++, t -= 2 ){............................}

Código fuente 11

La cabecera de este bucle for puede leerse del siguiente modo: "Para x igual a uno, y t igual a treinta, mientras que x sea menor o igual que diez y mientras x menos t sea distinto de 20, incrementa x en una unidad y disminuye t en dos unidades".

Debido a la potencia y la versatilidad que esta forma de concebir los bucles for ofrece, a veces el programador siente el deseo de agrupar varias expresiones y parte de lo que serían las sentencias del cuerpo del bucle en la cabecera del mismo, haciéndola compleja y de difícil lectura. Recomendamos huir de este estilo de programación por lo complicado que puede ser posteriormente entender un código escrito de este modo. Resulta más apropiado escribir un poco más de código si con ello conseguimos claridad, y dejar que el compilador haga las optimizaciones que considere oportunas, en lugar de enredarlo todo en un esfuerzo de incrementar la velocidad de nuestra aplicación o de demostrar a los demás o a nosotros mismos cuan inteligentes somos.

While Las principales diferencias entre el bucle for y el bucle while son que en éste no se inicializan los valores de control ni se dispone de la expresión de iteración.

La sintaxis de este bucle es la siguiente:


57

while (CondBooleana)sentencia;

O bien:

while (CondBooleana){sentencias;

}

La sentencia o sentencias definidas en el cuerpo de un bucle while se repiten mientras que la condición de su cabecera sea verdadera. Es por esto que esta condición tiene que ser una expresión cuyo resultado sea de tipo booleano.

Debido a que este tipo de bucles se encuentra en todos los lenguajes, no vamos a entrar en más detalles acerca de su funcionamiento.

Do-while: La sintaxis de este bucle es la siguiente:

dosentencia;

while (CondBooleana);

O bien

do {sentencias;

}while (CondBooleana);

Como puede verse, este bucle es casi idéntico al bucle while, salvo que en este caso, la expresión booleana se evalúa tras haberse realizado la primera iteración del bucle. Debido al parecido de este con el anterior, y por las mismas razones ya expuestas al hablar del bucle while, no vamos a entrar en más detalles.

Break, continue y etiquetas Java dispone de las sentencias break y continue y las etiquetas para realizar saltos. El caso de la sentencia return, es especial y lo trataremos al final de este apartado.

Ya hemos visto el uso de la sentencia break cuando tratamos la sentencia switch. Sin embargo, break puede utilizarse en cualquier sitio de la aplicación, aunque sólo tiene sentido dentro de la sentencia switch o dentro de los bucles.

break, hace que el flujo de la aplicación salte al estamento siguiente al que se está ejecutando en el momento de ser encontrado.

Veamos un ejemplo de uso de esta sentencia dentro de un bucle, en el Código fuente 12.

for( i = 1; i <= 10; i++ ) {


58

if (i == 5 ) break;System.out.println( i );

}

Código fuente 12

Este bucle pinta solamente los números del 1 al 4. Ya que break se ejecuta cuando i == 5, lo que hace que el flujo de la aplicación pase control instrucción que se encuentra inmediatamente tras el bucle.

La sentencia continue es similar a break, pero en lugar de transferir el flujo de la aplicación fuera del bucle, continue lo lleva a la cabecera del bucle. Por lo tanto, y como es lógico, esta instrucción sólo puede utilizarse dentro de bucles.

En el Código fuente 13 podemos ver un ejemplo del uso de esta sentencia.

for( i = 1; i <= 10; i++ ) {if (i == 5 ) continue;System.out.println( i );

}

Código fuente 13

Este bucle muestra todos los números del 1 al 10 excepto el número 5. Ya que continue se ejecuta cuando i == 5, lo que hace que se salten todas las sentencias por debajo de continue y que el flujo de la aplicación vuelva a la cabecera del bucle.

Aunque goto es una palabra reservada, en Java los saltos no están permitidos. Esto como ya hemos comentado en alguna ocasión, es debido a que los arquitectos de este lenguaje han intentado eliminar todos aquellos recursos que puedan dar lugar a un mal estilo de programación. Y está aceptado por toda la comunidad de teóricos de la programación que los saltos a una etiqueta son totalmente desaconsejables.

Sin embargo, Java permite asociar una etiqueta cuando se va a realizar un salto, para de este modo clarificar el código. La etiqueta se asocia con las instrucciones break y continue, que son las únicas sentencias de salto que Java contempla. Se dice en estos casos que se ha hecho un break etiquetado o un continue etiquetado.

En cualquier caso esta técnica es sólo aconsejable cuando se está trabajando con bucles anidados y se quiere salir de ellos a distintos niveles. No ayudando a la legibilidad del código en ningún otro supuesto teórico.

Para realizar un salto a una etiqueta, primero debemos definir la etiqueta, lo que se hace escribiendo un literal que va a ser la etiqueta seguida del operador dos puntos (:) antes de una sentencia de Java. Y desde cualquier punto se puede hacer un break con el formato:

break <etiqueta>

Veamos un ejemplo (en el Código fuente 14) del uso de las etiquetas en el entorno para el que fueron pensadas.

uno: for( ){


59

dos: for( ){continue; // seguiría en el bucle internobreak; // se saldría del bucle internocontinue uno; // seguiría en el bucle principalbreak uno; // se saldría del bucle principal

}}

Código fuente 14

Return Esta instrucción es un caso especial, ya que aunque permite realizar un salto, no es una instrucción de salto propiamente dicha.

Esta sentencia tiene la siguiente sintaxis:

return <valor>;

Cuando return es encontrado en el programa, el flujo salta fuera del método donde fue encontrado, no ejecutándose ninguna otra instrucción por debajo de esta y devuelve el control al método que lo invocó. Si el método donde se encuentra return es el principal, la aplicación termina.

Esta sentencia permite devolver un valor al método que llama a otro tras la ejecución de un proceso determinado. Lo que en Java es muy importante, porque los métodos, si se especifica que tienen que devolver un dato de un tipo determinado (cualquiera excepto void), tienen que contener una instrucción return que devuelva un valor coincidente con la declaración del tipo del método. En otro caso un mensaje de advertencia será reportado por el compilador. Un programa Java no puede compilarse si este contiene errores o advertencias.

Try, catch, finally y throws: Estas sentencias de control de flujo son: try-catch-finally y throws. Permiten el manejo de excepciones en Java.

Cuando un error ocurre dentro de un método, el método puede lanzar (throws) una excepción para indicar a quien lo invocó que un error ha ocurrido y cual ha sido el error. El método que ha llamado al que ha lanzado la excepción, puede entonces utilizar try, catch y finally para capturar y manejar la excepción.

Del uso estas sentencias hablaremos en profundidad en el capítulo correspondiente.

POO en Java: objetos

Introducción A lo largo de este capítulo, y en los dos que le siguen, vamos a abordar tanto la sintaxis de la POO en Java como otros elementos del lenguaje que se encuentran íntimamente relacionados con las clases. En el capítulo anterior vimos la sintaxis general del lenguaje, y los capítulos siguientes veremos como utilizando esa sintaxis se implementa toda la teoría de la Programación Orientada a Objetos vista en el primer capítulo de este curso.

Se debe señalar, como ya hemos comentado con anterioridad, que las piezas clave del lenguaje Java, como lenguaje de POO que es, son las clases y los objetos. Java se apoya sobre una completa y compleja jerarquía de clases predefinidas del lenguaje, pero en esta serie de capítulos, referenciados como POO en Java, además de comentar la estructura de la jerarquía de clases existente, mostraremos como crear nuestras propias clases, para poder reutilizarlas en nuestros programas como si formaran parte de la jerarquía de clases estándar presentes en el lenguaje Java.

A continuación vamos a ir viendo como utilizar objetos y clases dentro del lenguaje Java y ya comenzaremos a aprender a escribir nuestro código Java.

Objetos Como ya hemos comentado en varias ocasiones, los objetos son las piezas fundamentales de cualquier lenguaje de programación que sea orientado a objetos, por lo tanto vamos a tratar en un primer lugar los objetos en Java. Lo haremos a lo largo de varios apartados, para pasar después a explicar como crear nuestros propios tipos de objetos, es decir, como implementar nuestras propias clases.


62

En un programa Java vamos a estar creando objetos de distintos tipos de clases, estos objetos interactúan entre sí a través del mecanismo de mensajes, es decir, invocando métodos.

Una vez creado el objeto realizará la función que se le haya encomendado: ejecutar una animación, formar parte de un interfaz de usuario, enviar o recibir información a través de la red, etc. Cuando el objeto ha terminado su trabajo para el cual fue creado es destruido por el recolector de basura para liberar recursos que podrán ser reutilizados por otros objetos.

A la vista de lo anterior podemos decir que un objeto tiene un ciclo de vida, y que en este ciclo de vida podemos distinguir tres fases o etapas:

1. Creación.

2. Utilización.

3. Destrucción.

En los siguientes apartados vamos a tratar cada una de las etapas del ciclo de vida de un objeto y como las implementamos desde el lenguaje Java.

Creación de objetos En este apartado se va a tratar la primera fase del ciclo de vida de un objeto.

El proceso de crear un objeto a partir de una clase se divide en tres pasos: declaración, instanciación e inicialización. Vamos a ver cada uno de ellos.

Declaración La sintaxis para declarar un objeto en Java es la siguiente:

<tipo> <nombre>;

Donde:

<tipo> es el nombre de clase, es decir, el tipo de dato que se va a crear.

<nombre> es el nombre de la variable con el que nos referiremos al objeto.

Por ejemplo, vemos el Código fuente 15.

String sNombre;Date dHoy;

Código fuente 15

Como se puede observar, no hay ninguna diferencia entre estas declaraciones y las declaraciones de los tipos primitivos, es decir las que muestra el Código fuente 16.

© Grupo EIDOS 4. POO en Java: objetos

63

int iEdad;char cInicial;

Código fuente 16

Y esto, en un lenguaje de POO, es lo lógico. Como ya comentamos al hablar de tipos y conversión de datos (en el capítulo anterior), cuando creamos una nueva clase, estamos sencillamente creando un nuevo tipo de datos.

Hasta el momento, no hay ningún objeto por sitio alguno, de hecho, las variables sNombre y dHoy, todavía no contienen objetos, es decir, no se ha creado todavía ningún objeto ni de clase String ni de clase Date, ¿entonces qué hemos hecho?. Pues simplemente le hemos indicado al compilador que la variable sNombre es de tipo String, es decir que en algún punto del programa va a contener un objeto de la clase String, y que la variable dHoy es de tipo Date, es decir que en algún punto del programa va a contener un objeto de la clase Date.

De este modo, si más adelante intentamos instanciar un objeto de una clase distinta a la declarada, el compilador detectará el error y lo reportará, impidiendo que finalice este proceso.

Terminado con el primer paso vamos con el segundo dentro del proceso de creación de objetos.

Instanciación Para instanciar una clase, en Java se utiliza el operador new. Si el alumno es programador de C++, el operador new le resultará familiar. Pero debe tener cuidado, porque en Java no funciona del modo en como lo hace en C++. Mientras que en C++ new se utiliza para crear un objeto dinámicamente en memoria, y devuelve un puntero al objeto creado, en Java este operador devuelve una referencia al propio objeto (se debe recordar que en Java no existen los punteros).

El operador new invoca al constructor (de ellos hablaremos la fase de inicialización) de la clase y le pasa los parámetros de inicialización si los hubiere. El operador new crea el objeto y el constructor lo inicializa.

La sintaxis del operador new es la siguiente:

[<Variable> =] new <Constructor>( [<par1>, <par2>, ..., <parN>] )

De este modo, para crear un objeto de la clase String, haríamos lo que muestra el Código fuente 17.

sNombre = new String();

Código fuente 17

Y para crear uno de la clase Date, lo que nos muestra el Código fuente 18.

dHoy = new Date( );

Código fuente 18


64

Evidentemente, si a la izquierda de la expresión no hubiéramos puesto una variable, la referencia devuelta por el operador new se habría perdido; del mismo modo, si el tipo de variable no coincidiera con el tipo devuelto por el operador, el compilador reportaría un error indicando que los tipos no concuerdan.

Inicialización Ya tenemos un objeto de la clase String y otro de la clase Date creados, pero ¿Qué contienen estos objetos? dicho de otro modo ¿Cuál es su valor?.

En el caso de sNombre, la cadena es una cadena vacía y en el caso de dHoy, la hora a la cual fue el objeto creado. Sin embargo, en casi todas las ocasiones, cuando al crear un objeto, solemos querer darle un valor. Esto es lo que se llama inicialización del objeto. Este proceso lo realiza el constructor de la clase.

Un constructor no es más que un método con el mismo nombre que la clase y que puede o no recibir una serie de parámetros que se utilizan para inicializar el objeto. Gracias a la sobrecarga de métodos (concepto que debe conocer el alumno del primer capítulo) es posible, y muy útil, disponer de varios constructores. Existe un constructor especial, llamado constructor por defecto, que es aquel que no recibe ningún argumento o parámetro.

En el Código fuente 19 aparecen algunas inicializaciones posibles para los objetos anteriormente creados.

sNombre = new String( "Albert Einstein" );sNombre = new String( "1234" );dHoy = new Date( 2000, 6, 1 );dHoy = new Date( 2001, 1, 1 );

Código fuente 19

Como hemos comentado, para poder inicializar los objetos de distintos modos, las clases suelen proporcionar varios constructores. Así, en Java, la clase String, dispone de siete constructores distintos, y la clase Date de seis.

La declaración y la instanciación también las podemos realizar en una única línea de código, como se puede observar en el Código fuente 20.

Date dHoy = new Date( 2000, 1, 1 );String sNombre = new String( "Albert Einstein" );

Código fuente 20

Utilización de objetos Una vez creado el objeto debemos ver los mecanismos que existen para poder utilizarlo. En este apartado se va a explicar cómo se acceden a los datos y métodos de un objeto, que por otra parte, es el modo estándar en la POO. El operador de envío de mensaje en Java, es el punto (.), es decir, es el


65

operador para lanzar o invocar un método de un objeto. Siendo la sintaxis genérica de envío de mensaje la siguiente:

objeto.mensaje

Y para acceder a los atributos de un objeto (o variables miembro) es:

objeto.atributo

Y para los métodos (o funciones miembro) es:

objeto.método( [parámetros] )

Veamos algunos ejemplos en el Código fuente 21. Para ello, vamos a construir un nuevo objeto, utilizando la clase Rectangle contenida en el paquete java.awt de la librería de clases de Java, más delante en siguientes capítulos comentaremos con detenimiento en que consisten los paquetes y los principales que ofrece Java, de momento se debe indicar que un paquete es una forma de organizar clases, al igual que organizamos ficheros en un directorio en nuestro disco duro.

// Instanciación del objeto rctCaja con unas dimensiones://x, y, alto, anchoRectangle rctCaja = new Rectangle( 100, 100, 200, 200 );System.out.println( "x = " + rctCaja.x ); // Consultar xSystem.out.println( "y = " + rctCaja.x ); // Consultar ySystem.out.println( "Alto = " + rctCaja.height ); // Consultar AltoSystem.out.println( "Ancho = " + rctCaja.width); // Consular Ancho

Código fuente 21

En el Código fuente 21 se utiliza el siguiente código System.out.println() que puede despistar a algunos lectores, de momento únicamente comentaremos que de esta forma conseguimos imprimir algo por pantalla, en el capítulo en el que se comentan las aplicaciones Java, entraremos en más detalles.

Para cambiar un valor simplemente haríamos lo que muestra Código fuente 22.

rctCaja.x = 150;

Código fuente 22

O para realizar un cálculo (Código fuente 23).

area = rctCaja.height * rctCaja.width;

Código fuente 23

Para acceder a un método, empleamos el mismo operador, como se puede ver en el Código fuente 24.


66

rctCaja.resize( 150, 250 );

Código fuente 24

Si el método devolviese un valor podríamos almacenarlo en una variable como muestra el Código fuente 25.

String sCaja;Caja = rctCaja.toString();//Representación del rectángulo como cadena

Código fuente 25

Destrucción de objetos Al igual que existe un método constructor para crear objetos existe un método destructor para liberarlos. Del mismo modo que el constructor es llamado por el operador new cuando el objeto es creado, el destructor, si existe, es invocado también. El nombre del método destructor debe ser finalize().

Del hecho de que el destructor es llamado cuando el objeto va a ser eliminado de memoria, se deduce que el destructor no es llamado cuando el objeto sale fuera de ámbito, sino cuando va a ser destruido por el recolector de basura (garbage collector).

Como ya hemos comentado, cuando una variable sale de ámbito, y un objeto siempre está referenciado por una variable, ésta es marcada para ser eliminada de memoria, y el recolector la eliminará cuando pueda hacerlo, ya que es una tarea que se desarrolla en background (en un segundo plano), y de forma incremental.

Esto implica que no podemos saber cuando el método de finalización de un objeto va a ser invocado, lo que es parcialmente cierto, aunque existe la posibilidad de forzar que ocurra el proceso de finalización llamando al método runFinalization() de la clase System (de momento simplemente diremos que esta clase representa al sistema en ejecución) lo que se hace como muestra el Código fuente 26.

System.runFinalization();

Código fuente 26

Este método llama a todos los métodos finalize() de todos los objetos que están esperando al recolector de basura. Pero no existe un modo automático para asegurarse de que el destructor va a ser llamado al salir el objeto de ámbito.

En cualquier caso, y por el tipo de tareas que los destructores realizan, esto no tiene la menor importancia, ya que los destructores suelen encargarse de liberar los recursos capturados por el objeto (lo que normalmente se hace en el constructor), cerrar ficheros abiertos, cerrar sockets utilizados, liberar memoria, etc.


67

Por otro lado, una clase no tiene por qué tener un destructor, pero si lo tiene, éste tiene que reunir las siguientes características:

• El nombre del método tiene que ser finalize(). Ya que el destructor es invocado por el recolector de basura, éste no puede saber cómo se llama el método de la clase a menos que se establezca una forma de hacerlo, y lo que se ha hecho es darle un nombre fijo. El que se ha escogido en Java es finalize(), aunque podrían haber escogido otro cualquiera. También se podría haber hecho como en C++, que el destructor tiene el mismo nombre de la clase precedido por la virgulilla ("~").

• No puede recibir ningún parámetro. Puesto que el recolector de basura no puede saber qué parámetros desea recibir el destructor, y puesto que cuando el destructor va a ser invocado es posible que algunos o todos los parámetros que desea recibir no estén en disponibles.

• No puede haber más que un destructor. Esto es conclusión directa de lo anterior, ya que al no tener parámetros, no puede existir la sobrecarga.

• No puede devolver valor alguno. Es decir, el método tiene que ser de tipo void. Por el mismo motivo que el recolector de basura es quien invoca al destructor, éste no puede devolver valor alguno, ya que aun cuando devolviese un valor este no podría ser recogido por proceso alguno porque el objeto ya ha salido de ámbito.

Para ser correctos, hay que decir que el destructor siempre existe, ya que la clase Object, de la que heredan todas las otras clases en Java, dispone del método finalize(), éste es un método que no hace nada, por lo que si creamos una clase que hereda directamente de la clase Object no es necesario llamar al destructor de la clase padre.

Sin embargo, en otras ocasiones, al heredar de otras clases en las que existe un método finalize() que desempeña una tarea necesaria para la correcta finalización del objeto, es necesario que tras realizar la labor oportuna en el método finalize() de su clase, llame al método finalize() de la clase padre para que éste pueda realizar su labor.

La sintaxis de un destructor es como sigue:

void finalize() {// Tarea de finalización}

Se puede observar que como los destructores no pueden devolver ningún valor, el tipo que devuelve este método es void, de todas formas en el apartado dedicado a los métodos en el próximo capítulo lo veremos en mayor detalle.

Una vez comentado como podemos tratar los objetos en Java vamos a pasar a comentar en el siguiente capítulo la segunda pieza clave de la POO, las clases.

POO en Java: clases

Clases Hasta ahora hemos creado objetos a partir de clases existentes, pero como es lógico, se pueden crear nuevas clases e instanciar objetos de las clases definidas por nosotros mismos.

Una clase de forma genérica se compone de: la declaración de la clase y del cuerpo de la clase, el cual, a su vez se divide en la sección de declaración (opcionalmente también la inicialización) de los atributos (variables miembro) y la sección de declaración e implementación de los métodos (funciones miembro).

De este modo, la plantilla de una clase quedaría de la siguiente manera:

declaraciónDeLaClase {declaraciónDeLosAtributosdeclaraciónDeLosMétodos

}

Siendo el cuerpo de la clase la amplia sección encerrada entre las dos llaves.

Una clase puede o no contener atributos y/o métodos, pero al menos tiene que contener uno de los dos componentes.

En los siguientes apartados, a lo largo del presente capítulo, iremos viendo cada una de las secciones que compone la construcción de una clase en Java.


70

Declaración de la clase La declaración de una clase implica indicar el nombre que va a tener la clase junto con otras características que puede presentar la clase. La sintaxis de la declaración de la clase es la siguiente:

class <NombreClase> {..........}

Como se puede ver, la declaración de una clase se compone, al menos, de la palabra clave class y del nombre de la clase. El nombre de la clase tiene que ser un identificador (véase el apartado Identificadores del primer capítulo) válido en Java.

Aunque esta mínima declaración suele ser suficiente en algunos casos, es posible indicar, al declarar una clase, alguna otra información adicional. La sintaxis de una declaración completa de la clase sería la siguiente:

[<Modificador(es)>] class <NombreClase> [extends <NombreSuperClase>][implements <NombreInterface1> [, <NombreInterface2>, ... ]] {........................}

A continuación vamos a ir comentando cada una de las características adicionales que podemos indicar a la hora de declarar una clase y que aparece en la sintaxis mostrada arriba.

Superclase de la clase En Java, para hacer que una clase herede de otra (véase para más detalles el apartado Herencia de este mismo capítulo), se utiliza la palabra reservada extends antes del nombre de la superclase de la cual deriva. La sintaxis es como sigue:

class <NombreClase> extends <NombreSuperClase>{..........................}

En Java, todas las clases heredan directa o indirectamente de la clase Object (para más información sobre la clase Object acudir al apartado del mismo nombre dentro del siguiente capítulo), ya que esta clase se encuentra en la raíz de la jerarquía de clases. Si no se especifica que una clase hereda de otra, Java asume que hereda directamente de la clase Object.

Únicamente podremos heredar de una clase, ya que Java no implementa el mecanismo de herencia múltiple.

Interfaces de la clase Si la clase implementara algún interfaz (véase el apartado Interfaces del capítulo siguiente), este o estos, se especifican en la declaración de la clase.

En pocas palabras, un interfaz es un conjunto de constantes y métodos sin implementar, que la clase que lo utiliza, tiene que implementar (codificar si se prefiere). De todas formas trataremos los interfaces en más detalle más adelante en el siguiente capítulo.

© Grupo EIDOS 5. POO en Java: clases

71

La sintaxis para declarar una clase que utiliza interfaces es la siguiente:

class <NombreClase> implements <NombreInterface1>[,<NombreInterface2>, ... ]{..........................}

Por convención, la cláusula implements se especifica después de la cláusula extends, si la hubiere.

Como se puede observar se pueden implementar uno o más interfaces.

Modificadores de la clase Existen varios modificadores que son aplicables a la clase, en caso de tener que especificar alguno, este se sitúa al principio de la declaración, según la siguiente sintaxis:

<Modificador> class <NombreClase> {........................}

Los modificadores nos dan información adicional de la forma en la que la clase va a ser tratada.

Los modificadores posibles que se pueden anteponer a la clase son los siguientes:

• public: este es un modificador de acceso que indica que la clase es accesible de forma pública, es decir, a la clase se puede acceder y ser instanciada desde cualquier otra clase. Si no indicamos este modificador la clase sólo podrá ser accesible para clases dentro del mismo paquete (para información sobre los paquetes en Java acudir al apartado Paquetes en el capítulo siguiente).

• abstract: este modificador indica que la clase es abstracta y por lo tanto no es instanciable, es decir, no vamos a poder crear objetos de esta clase. Las clases abstractas las utilizaremos para representar una clase que se encuentra en la raíz de una jerarquía de clases y recoge algunas características que son comunes a todas las clases hijas, pero que difieren en su implementación, para más información sobre clases abstractas consultar el apartado que posee el mismo nombre.

• final: si aplicamos este modificador a una clase indicaremos que la clase no puede ser subclasificable, es decir, ninguna clase podrán heredar de ella y por lo tanto nunca podrá ser una clase padre. Una clase la declararemos como final por cuestiones de seguridad, para asegurarnos que ninguna clase hereda de ella para modificar comportamientos, y también por cuestiones de diseño de nuestra jerarquía de clases, para limitar en que momento se debe detener el mecanismo de herencia.

Una vez comentados todos los elementos que forman parte de la declaración de una clase, se puede ver que los únicos elementos necesarios para declarar una clase son la palabra del lenguaje class y el nombre de la clase.

Si no se especifican los elementos opcionales, los valores por defecto que el compilador asumen son los siguientes: no-final, no-public, no-abstract, subclase de Object y no implementa interfaz alguno.

El cuerpo de la clase se compone de atributos y métodos, analizaremos cada uno de estos componentes en los siguientes apartados.


72

Cuerpo de la clase. Declaración de atributos En este apartado abordaremos el primero de los elementos que podemos definir dentro del cuerpo de una clase, es decir, los atributos de la clase.

La sintaxis general para declaración de los atributos de la clase es la siguiente:

<Modificador (es)> <tipo> <nombreVariable>

Veamos cada uno de los elementos de la declaración:

Modificadores Dentro de los modificadores que le podemos aplicar a un atributo se puede distinguir un grupo de ellos que se denomina modificadores de acceso. Estos modificadores de acceso son excluyentes entre sí e indican la forma de acceso a los atributos de una clase desde otras clases. Los modificadores de acceso posibles son los siguientes:

• public: con este modificador de acceso indicamos que todas las clases tienen acceso a este atributo. Se suelen declarar como públicos los atributos cuyo acceso a los mismos no puede producir resultados no deseables. Aunque los atributos de una clase pueden ser public, esto está totalmente desaconsejado en la POO, los atributos deben ser accedidos solamente desde dentro de la clase y para manejarlos de la clase debe proporcionar un conjunto de métodos, denominados métodos de acceso.

• private: este modificador de acceso es todo lo contrario a public. Un atributo declarado como private sólo es accesible desde dentro de la clase en la que está declarado. Es el nivel de acceso más restrictivo de todos.

• Modificador por defecto o package: es el modificador de acceso predeterminado, es decir, si no indicamos un modificador de acceso para un atributo, se aplicará por defecto este tipo de acceso. Este tipo de atributos es accesible desde las clases que se encuentren dentro del mismo paquete (ver apartado Paquetes en el siguiente capítulo) en el que se encuentra la clase en la que se declara el atributo. Ya que este tipo de acceso es el predeterminado no es necesaria una palabra reservada.

• protected: los atributos con este modificador son accesibles desde las clases hijas de la clase en la que se encuentran declarados los atributos, y también es accesible desde las clases que se encuentren dentro del mismo paquete.

En Tabla 18 se muestra los diferentes niveles de acceso de un atributo, y quién puede acceder en cada caso.

Modificador La propia

clase Clase hija Paquete Resto del

mundo

private X

protected X X X

public X X X X


73

Por defecto o package

X X

Tabla 18

Además de los modificadores de acceso un atributo puede presentar otros modificadores denominados modificadores de contenido, que en este caso no son excluyentes, y que son los dos que indican a continuación:

• static: un atributo con el modificador de contenido static mantiene su contenido para todas las instancias de la clase que se hagan, así como para las clases hijas que de ella se hereden. A estos atributos se les denomina atributos de clase o variables de la clase, como contraposición a los atributos de instancia. Mientras que los atributos de instancia se inicializan para cada nueva instancia que se haga de la clase, es decir, existe una copia por cada instancia de la clase, de los atributos de la clase existe una sola instancia, independientemente del número de instanciaciones que de la clase se realicen. De este modo, todos los objetos comparten un lugar de almacenamiento común.

Debido a la particularidad de este modificador de contenido vamos a comentarlo más con detenimiento a través de un ejemplo.

El ejemplo más típico de atributo de la clase es un contador del número de objetos existentes de la clase. Para ello, sólo hay que incrementar el contador desde el constructor de la clase y decrementarlo desde el destructor.

El código podría ser algo como lo que muestra el Código fuente 27.

class Cuenteo {//atributo de clasestatic long lObj = 0;

// Constructor, incrementa el valorCuenteo(){

lObj++;}// Destructor, decrementa el valorvoid finalize(){

lObj--;}// Obtener el número de objetos existenteslong GetObj(){

//devolvemos el valorreturn lObj;

}}

Código fuente 27

Otra cualidad más de los atributos static es que no es necesario instanciar un objeto de la clase para acceder a ellos. Lo cual resulta muy práctico, sobre todo cuando se trabaja con ciertas clases.

Cuando hacemos System.out.println(), lo hacemos sin crear previamente un objeto de la clase System. Cuando lo lógico sería lo que muestra el Código fuente 28.


74

System oSystem = new System();

oSystem.out.println( "Hola" )

Código fuente 28

No lo hacemos así, sino que llamamos directamente al método println() del atributo out de la clase System sin instanciar previamente un objeto de esa clase. Esto es posible porque out es un atributo static de la clase System.

Una vez comentado el modificador de contenido static vamos a pasar al segundo de estos modificadores.

• final: este modificador indica que el atributo es una constante., es decir, el valor de este atributo no puede ser modificado. Por convenio los atributos que son constantes se escriben todos en mayúsculas. Un ejemplo del uso de este tipo de atributos se puede observar en el Código fuente 29.

class MiClase{final float PI = 3.14159;// resto de la implementación de la clase

}

Código fuente 29

Una vez vistos los modificadores de acceso y los de contenido, vamos a ver el resto de modificadores que se le pueden aplicar a un atributo de la clase.

• transient: por defecto, los atributos forman parte de la información persistente del objeto. Los atributos persistentes se salvan cuando se graba en un archivo el objeto, pero no ocurre así con aquellas declaradas como transient (transitorias).

• volatile: este modificador indica al compilador que no debe realizar optimizaciones sobre este atributo. No se suele utilizar.

Ahora podríamos rescribir la sintaxis de la declaración de un atributo indicando todos los modificadores de la siguiente forma:

[public | protected | private] [static] [final] [transient][volatile] <tipo> <nombreVariable>

Y aquí termina la sección dedicada a los modificadores que se pueden utilizar en la declaración de atributos de la clase.

Tipo Indica el tipo del atributo es decir, la clase o tipo primitivos a los que pertenece.


75

Nombre variable Aquí indicamos el nombre con el que vamos a identificar al atributo, y puede ser cualquier identificador válido en Java, para más información sobre identificadores consultar el capítulo dedicado a la sintaxis del lenguaje Java.

Un ejemplo simple podría ser el que muestra el Código fuente 30.

class Caja {int iTop, iLeft, iBottom, iRight;...........................

}

Código fuente 30

Cuerpo de la clase. Implementación de métodos Los métodos proporcionan la operatividad y el comportamiento de la clase. De forma similar a la implementación de una clase, la implementación de un método se divide en dos partes: la declaración del método y el cuerpo del método.

declaraciónDelMétodo{declaración de variablescuerpoDelMétodo

}

Por otro lado, un método puede recibir parámetros en su llamada, por lo que los componentes de un método quedarían del siguiente modo:

declaraciónDelMétodo( [listaParámetros] ) {declaración de variablesimplementación}

En las siguientes secciones vamos a ver cada uno de los componentes que forman parte de la implementación de un método.

Declaración del método Del mismo modo que la declaración de la clase o de sus atributos proporcionan información al compilador acerca de estos componentes, la declaración de un método proporciona una información similar, la cual es utilizada por el compilador para hacer las comprobaciones necesarias sobre la correcta utilización del mismo en el resto del código.

La sintaxis de la declaración de un método es la siguiente:

<Modificador (es)> <tipoDeRetorno> <nombreMétodo>([<listaParámetros>])[throws <listaExcepciones>]{}


76

Si detallamos los modificadores del método:

[public | protected | private] [static] [final] [abstract] [native][synchronized] <tipoReturn> <nombreMétodo> ([<listaParámetros>])[throws <listaExcepciones>]{ }

Y la sintaxis mínima necesaria para realizar la declaración de un método es:

<tipoDeRetorno> <nombreMétodo> ([<listaParámetros>]){}

Algunos de los elementos que aparecen en la declaración general de un método son iguales que los que aparecían en la declaración de atributos y tienen el mismo significado, vamos a comentar cada uno de ellos.

En un primer lugar tenemos los modificadores de acceso. Los modificadores de acceso de un método son los mismos que aparecían en los atributos, es decir, public, private, protected y el modificador por defecto o package, y además tienen el mismo significado.

También los métodos presentan los modificadores de contenido static y final. Un método static es aquel cuya implementación es la misma para todos los objetos de la clase, y además un método static no puede acceder a los atributos de instancia de la clase, sólo tiene acceso a los atributos static de la clase (atributos de clase). Los métodos static pueden ser invocados sin necesidad de instanciar un objeto de la clase.

Un ejemplo del modificador static lo encontramos en la clase Math, en la que todos sus métodos son estáticos, y por lo tanto nos permite realizar operaciones matemáticas sin tener que crear un objeto de esta clase. Por ejemplo veamos el Código fuente 31.

Math.sin( 18 ); // Devuelve el seno de 18Math.abs( -37 ); // Devuelve el valor absoluto de –37

Código fuente 31

Aunque nada nos impide crear un objeto de la clase y acceder a sus métodos a través del objeto.

El modificador de contenido final en la declaración de métodos tiene un significado distinto que en la declaración de atributos. Cuando el modificador se aplica a un método, indica que éste no puede reemplazarse cuando se hereda de la clase, es decir, las clases hijas no pueden sobrescribir el método de la clase padre o superclase.

Otro modificador que presenta la declaración de métodos es abstract, este modificador ya no aparece en la declaración de atributos, sino que aparecía en la declaración de clases. Un método abstract no tiene implementación, es decir, es un método con el cuerpo vacío y que debe encontrarse en una clase abstract. La implementación de los métodos abstractos se realizará en las clases hija de la clase abstracta que contenga dichos métodos, para más información sobre el tema consultar el apartado Clases Abstractas dentro de este mismo capítulo.

Un modificador sólo aplicable a métodos es native. Este modificador indica que el método ha sido escrito en código nativo, es decir, en un lenguaje dependiente de la plataforma como puede ser C o C++. Por ello, estos métodos constan tan sólo de la declaración, no teniendo cuerpo.


77

native long Cálculo();

Código fuente 32

Estos métodos residen en archivos externos de código fuente en el lenguaje nativo correspondiente y es necesario seguir unas normas determinadas para poder integrarlos con el resto de la aplicación Java, pero estas son características avanzadas del lenguaje que se escapan de los objetivos del presente curso.

El último modificador utilizado para la declaración de métodos es synchronized. Si indicamos que un método es de tipo synchronized, la Máquina Virtual de Java se comportará de la siguiente forma: cuando un proceso esté accediendo a ese método, los demás procesos que deseen acceder al mismo método deberán esperar en una cola hasta que el proceso en curso termine.

Puesto que Java permite que varios procesos se estén ejecutando al mismo tiempo, debe proporcionar los medios para crearlos, destruirlos y fabricarlos fiables. Para esto último sirve este modificador.

Si, por ejemplo, escribimos un método que sabemos de antemano que puede ser llamado por varios procesos concurrentemente, en la mayor parte de los casos deberemos impedir que más de un proceso acceda al método (o a parte de él) mientras que otro proceso lo está haciendo.

A continuación y para tener una visión general de todos los modificadores, se incluye una tabla que muestra en que casos se puede aplicar cada uno de los modificadores.

Aplicabilidad de los Modificadores

Clase Método Atributo

Predeterminado (package) Sí Sí Sí

public Sí Sí Sí

protected No Sí Sí

private No Sí Sí

static No Sí Sí

final Sí Sí Sí

synchronized No Sí No

native No Sí No

abstract Sí Sí No

Tabla 19

Una vez indicados los modificadores del método se debe indica el tipo del valor de retorno del método. En Java, un método puede devolver un valor o no devolver nada. En el primer caso, al


78

declarar el método se tiene que especificar el tipo de dato que se va a devolver, en el segundo caso, hay que declararlo como de tipo void.

Para devolver el valor deseado, se utiliza la sentencia return seguida del valor, el cual puede ser el resultado de una expresión de cualquier tipo, lo que obviamente incluye el contenido de un dato de la clase o una variable, o bien un tipo primitivo (true, null, int, etc.).

Un método que no sea declarado como void, debe contener en su implementación una sentencia return para devolver el valor correspondiente, que debe ser del mismo tipo que el indicado en la declaración del método. Un ejemplo podría ser el que muestra el Código fuente 33.

public boolean estaVacio(){if (items.size()==0)

return true;else

return false;}

Código fuente 33

Una vez indicados los modificadores y el tipo del valor de retorno del método, lo siguiente que debemos facilitar es el nombre del método, el nombre puede ser es cualquier identificador válido en Java.

Respecto al nombre de los métodos hay una serie de consideraciones:

• Puesto que Java soporta sobrecarga de métodos, varios métodos dentro de la misma clase pueden tener el mismo nombre.

• Si un método tiene el mismo nombre que la clase, es considerado el constructor de la clase.

• Los métodos de las clases hijas, pueden redefinir los de las clases padres, pero en tal caso, ambos tienen que tener el mismo nombre, el mismo valor de retorno y la misma lista de parámetros (más información en el apartado Herencia).

A continuación del nombre del método aparece la lista de parámetros que puede recibir el método. Si el método no recibe ningún parámetro sólo se indican los paréntesis. En el Código fuente 34 se muestra la declaración de un método con parámetros.

void MiVentana( int iTop, int iLeft, int iBottom, int iRight, sTítulo,booleanBarraEstado ){<implementación>}

Código fuente 34

Como se puede observar, los argumentos que un método recibe son parejas de <tipo> <nombreVariable>, separados por comas.

Este método recibe cuatro argumentos de tipo numérico entero, que son las coordenadas de la ventana, un argumento de tipo cadena que es el título de la ventana y un argumento lógico (booleano) que


79

indica si la ventana tiene o no barra de estado. Veamos ahora algunas otras consideraciones acerca de los argumentos en Java:

• En Java, cualquier tipo de dato válido puede ser pasado como argumento a un método: tipos primitivos, objetos, arrays, etc.

• A diferencia de C, en Java, no se puede pasar una función (método en el caso de Java) como argumento a un método, pero se puede pasar el objeto e invocar el método deseado.

• Cuando los nombres de los parámetros que recibe un método son iguales a los de los atributos de la clase, los parámetros son ocultados por los atributos, siendo necesario anteponer la palabra reservada this a los atributos para poder referirse a ellas (más adelante retomaremos la palabra reservada this), this representa una referencia a la clase actual.

class Caja{int iTop, iLeft, iBottom, iRight;Caja( iTop, iLeft, iBottom, iRight ){

this.iTop = iTop;this.iLeft = iLeft;this.iBottom = iBottom;this.iRight = iRight;

}}

Código fuente 35

• De lo dicho anteriormente, se puede deducir que no se permite que el nombre de un argumento

sea igual al de las variables locales al método. Y obviamente, no se permite la duplicidad de nombres de argumentos para el mismo método.

• En Java, los argumentos se pasan por valor, no por referencia, esto quiere decir, que para los datos de tipos primitivos, lo que se pasa es el valor de la variable, y para los datos de tipo referencia (como son los objetos) se pasa la referencia, pero ésta no puede ser cambiada. De este modo, si lo que se desea es cambiar un valor, es necesario pasar como argumento al método un objeto que contenga ese valor en un atributo, y que incluya algún mecanismo para poder modificarlo, ya sea porque el atributo es público y se puede acceder a él directamente, o porque el objeto dispone de un método para poder alterar el atributo.

Después de la lista de parámetros del método podemos utiliza la cláusula throws. Esta cláusula se utiliza para lanzar los errores (excepciones) que puedan producirse en el método. A continuación de esta cláusula aparece el nombre de las las clases de las excepciones que se pueden lanzar, separadas entre comas. El tratamiento de excepciones lo veremos con detenimiento en el apartado correspondiente en el próximo capítulo.

Un ejemplo de la utilización de la cláusula throws lo podemos ver en el Código fuente 36.

public void borraFichero() throws IOException{}

Código fuente 36


80

Declaración de variables Esta sección, al igual que la siguiente, ya formaría parte del cuerpo del método.

Tras la sección de declaración del método, se pueden declarar las variables que el método vaya a necesitar. Estas son locales al método y tanto su visibilidad como su longevidad están inscritas dentro del cuerpo del método. Estas variables también se denominan objetos locales.

Los variables locales son creadas cada vez que el método es invocado y destruidas al terminar éste y son sólo conocidas por el método, sin embargo los atributos existen mientras exista el objeto y son conocidas (al menos) por todos los métodos de la clase.

En el Código fuente 37 se puede observar la declaración de variables locales en un método.

class Caja{// Variables miembro de la claseint iTop, iLeft, iBottom, iRight;// ConstructorCaja( iTop, iLeft, iBottom, iRight ){

....................}// Extraer el área de la cajalong Area(){

long lArea; // Variable locallArea = iTop * iLeft;return lArea;

}}

Código fuente 37

Implementación del método Implementar un método es simplemente escribir el código necesario para que el método realice la función para la que ha sido creado.

Hay tres palabras clave del lenguaje que merecen una mención especial a la hora de implementar un método, estas palabras son: this, super y return.

• this: con esta palabra, podemos referirnos a los miembros de la clase. Como ya vimos representa una referencia a la clase actual. Dentro de la implementación de un método utilizaremos this para deshacer la ambigüedad que se produzca entre los nombres de los atributos de la clase y el nombre de los parámetros del método, como ya vimos anteriormente. Para más información acerca de this, véase el apartado Herencia. Un ejemplo del uso de this se muestra en el Código fuente 38.

class HSBColor {//atributos de la claseint hue, saturation, brightness;//constructorHSBColor (int hue, int saturation, int brightness) {

this.hue = hue;this.saturation = saturation;


81

this.brightness = brightness;}

}

Código fuente 38

• super: si un método de una clase hija redefine (sobrescribe) un método de su clase padre, se

puede referir al método redefinido anteponiendo super. Esta palabra reservada también se puede utilizar para acceder a los atributos de la clase padre, cuando estos sean redefinidos por atributos de la clase hija. Para más información acerca de super, véase el apartado Herencia.

• return: la palabra clave return permite devolver un valor desde un método, este valor puede ser cualquier tipo de dato válido de Java. Veamos un ejemplo del uso de return en el Código fuente 39.

class Test {void nada( String s ) {

System.out.println( "Cadena: " + s );}int entero( int i ) {

return i * i;}boolean lógico( boolean b ) {

return ! b;}String cadena( String s ) {

if( s.length ) == 0return null;

elsereturn s.toUpper();

}}

Código fuente 39

A la vista del Código fuente 39 se deben realizar los siguientes comentarios:

• Los métodos devuelven un valor consecuente con la declaración formal que se ha hecho de los mismos. En caso de que no se hiciera así, el compilador reportaría un error en la coincidencia de los tipos y no permitiría generar la clase correspondiente.

• El primer método al ser declarado de tipo void, no contiene la sentencia return.

• En el caso de que un método tenga que devolver un objeto, el tipo de dato del objeto devuelto tiene que ser o una subclase de la clase indicada o la propia clase indicada, reportándose el error de tipos no coincidentes en cualquier otro caso.

Una clase puede tener tantos métodos con el mismo nombre como se desee, siempre que el número y/o tipo de argumentos que cada método recibe sea diferente. Como el compilador guarda durante el proceso de compilación los parámetros junto con el nombre del método, sabe a quién va dirigida en cada caso la llamada. Esta capacidad presente en la POO se denomina sobrecarga

En Java existe sobrecarga de métodos, pero no de operadores, como en C++.


82

Herencia En este apartado vamos a retomar los conceptos sobre la herencia en la Programación Orientada a objetos, y vamos a comentar como implementa el lenguaje Java el mecanismo de herencia.

En Java, como en todo lenguaje de POO se pueden heredar unas clases de otras. A la clase heredada se le llama, subclase o clase hija, y a la clase de la que se hereda superclase o clase padre. De hecho, en Java todas las clases heredan, ya sea explícita o implícitamente, de la clase Object (esta clase se verá con detenimiento en el apartado correspondiente del siguiente capítulo).

Al heredar, la clase heredada toma directamente el comportamiento de su superclase, pero puesto que ésta puede derivar de otra, y esta de otra, etc., una clase toma indirectamente el comportamiento de todas las clases de la rama del árbol de la jerarquía de clases a la que pertenece.

Se heredan los atributos y los métodos, por lo tanto, ambos pueden ser redefinidos en las clases hijas, aunque lo más común es redefinir métodos. Gracias a la herencia, las clases se van convirtiendo en más especializadas.

Muchas veces las clases, especialmente aquellas que se encuentran próximas a la raíz en el árbol de la jerarquía de clases, son abstractas, es decir, sólo existen para proporcionar una base para la creación de clases más específicas, y por lo tanto no puede instanciarse objetos de ellas; son las clases abstractas (en otros lenguajes de POO se denominan clases virtuales).

Veamos ahora algunas de las particularidades de la herencia en Java:

• En Java una clase no puede tener más que una clase padre o superclase, es decir, no se admite la herencia múltiple.

• Java proporciona un gran control a la hora de manejar la herencia de clases, indicando qué se puede heredar y qué no, qué se puede redefinir y qué no así como qué hay que redefinir.

• Se heredan los atributos y métodos public y protected.

• Se heredan los atributos y métodos declarados con el acceso por defecto (package), siempre que la clase hija se encuentre dentro del mismo paquete que la clase padre.

• No se heredan aquellos atributos y métodos que la subclase declara con el mismo nombre que en la superclase. Aunque se puede acceder a los atributos y métodos de la superclase mediante el uso de la palabra clave super, como veremos a continuación.

• No se heredan los atributos y métodos private.

Cuando una clase hereda de otra se indica al declarar la clase, y para ello se utiliza la palabra clave de Java extends.

La sintaxis es la siguiente (para consultar la sintaxis completa de la declaración de una clase, véase en apartados anteriores):

class <NombreClase> extends <NombreSuperClase>{..........................}

Por ejemplo, veamos el Código fuente 40.


83

class Marco extends Area{<codificación de la clase>}

Código fuente 40

Con la palabra reservada this, podemos referirnos a los atributos y métodos de la clase, permite diferenciar entre los argumentos de los métodos y los atributos de la clase con el mismo nombre.

De hecho, siempre que dentro del cuerpo de un método nos refiramos a cualquier miembro de la clase, ya sea un atributo o método, podemos anteponer this, aunque en caso de no existir duplicidad, el compilador asume que nos referimos a un miembro (método o atributo) de la clase. Aquí bajo la denominación miembro se engloba a métodos y atributos.

Algunos programadores prefieren utilizar this para dejar claro que se está haciendo referencia a un miembro de la clase.

Al contrario que this, super permite hacer referencia a miembros de la clase padre (o a los ancestros anteriores, que no hayan sido ocultados por la clase padre) que se hayan redefinido en la clase hija.

Si un método de una clase hija redefine un miembro, ya sea atributo o método, de su clase padre, es posible hacer referencia al miembro redefinido anteponiendo super.

El siguiente ejemplo demuestra el uso de this y super, a la hora de redefinir o sobrescribir atributos y métodos de la clase padre.

Si tenemos la clase padre UnaClase (Código fuente 41), y heredamos de ella la clase OtraClase que sobrescribe tanto el atributo de la clase padre como el método (Código fuente 42).

class UnaClase {boolean bVariable;void Metodo() {

bVariable = true;}

}

Código fuente 41

class OtraClase extends UnaClase {boolean bVariable;

void Metodo() {this.bVariable = false;super.Metodo();System.out.println(bVariable);System.out.println(super.bVariable);

}}

Código fuente 42


84

Entonces, el resultado de llamar a OtraClase.Método() será el siguiente:

falsetrue

Ya que el método Metodo() de la clase hija llama al método de igual nombre, el cual pone a true el valor de su variable, y el de la clase hija pone a false el de la suya, aunque ambos métodos y variables tengan el mismo nombre, podemos distinguirlos al referirnos a ellos utilizando o no, según sea el caso, la palabra super.

De hecho, el Código fuente 43, también podría haberse escrito como muestra el Código fuente 44

this.bVariable = false;

Código fuente 43

bVariable = false;

Código fuente 44

Ya que en ausencia del identificador this, el compilador asume que nos referimos al atributo de la clase.

Se debe observar que por los mismos motivos, la línea que aparece en el Código fuente 45, equivale a la instrucción que muestra el Código fuente 46.

super.Método();

Código fuente 45

super.bVariable = true;

Código fuente 46

Cuando una clase hereda de otra puede bien ampliar el comportamiento o bien sustituir el comportamiento de los métodos de la clase padre. Veamos ambas posibilidades y algunos otros aspectos relacionados con este tema.

Sustituir la implementación de un método Es muy común que en una clase se quiera cambiar completamente el comportamiento de un método de la clase de la que se hereda. Algunos métodos tienen que ser sustituidos por otros para un correcto funcionamiento de la clase heredada.


85

Para sustituir un método de una clase superior por otro en la clase heredada, basta con crear un método en la clase hija con el mismo nombre que el que deseamos sustituir e implementar el comportamiento deseado. Veamos, por ejemplo el Código fuente 47.

class A {void hacerAlgo() {

// hacer lo que sea}

}

class B extends A {void hacerAlgo() {

// aquí hacemos otra cosa}

}

Código fuente 47

Ampliar la implementación de un método En otras ocasiones, lo que se desea no es cambiar el comportamiento de un método de la superclase, sino ampliarlo. El caso más común es el de los constructores, donde suele llamarse al constructor de la superclase pasándole los parámetros que éste requiere y utilizándose el resto de parámetros para inicializar los valores de la subclase.

Como es lógico, cuando se amplia la funcionalidad de un método, se tiene que preservar la funcionalidad antigua y añadirle la nueva. Para ello, se invoca desde el método de la clase heredada (subclase o clase hija) al método del mismo nombre de la superclase, lo que se hace con la palabra reservada super.

class Padre {void elMétodo( int param1 ) {

// hacer lo que sea}

}

class Hija extends Padre {void elMétodo( int param1, param2 ) {// llamamos al método de la clase padresuper.elMetodo( param1 );// aquí hacemos otra cosa más

}}

Código fuente 48

En los constructores es casi imperativo (a menos que hubiera que hacer transformaciones con los parámetros que el método recibe) llamar antes de hacer ninguna otra cosa, al constructor de la superclase.

Métodos que una clase heredada no puede redefinir No se pueden sustituir los siguientes métodos (ya sea para ampliarlos o para reemplazarlos):


86

• Métodos declarados como final. Por definición, un método declarado como final no puede ser modificado en las clases heredadas. Si se intentara, el compilador generaría un error.

• Métodos declarados como static: Un método static es un método de la clase, y lógicamente no puede ser sustituido.

Métodos que una clase heredada tiene que redefinir En Java se pueden declarar métodos que existen sólo para ser redefinidos, estos son los métodos definidos con el modificador abstract. Las clases que hereden de una clase con métodos abstract deben obligatoriamente redefinir los métodos abstractos, ya que sino no tendrían ningún contenido. En el siguiente apartado se comenta con detenimiento las clases abstractas.

Clases abstractas En este apartado vamos a comentar el concepto de clase abstracta y como es implementado el mismo en el lenguaje Java.

De forma general podemos definir una clase abstracta como una clase que no es instanciable, y que se utiliza en el diseño de una jerarquía de clases.

Si una clase contiene uno o más métodos abstractos, tiene que ser definida como abstracta. Los métodos abstractos no tienen contenido alguno, no tienen cuerpo, por lo que estas clases se utilizan solamente con fines de diseño, no de implementación, como ya habíamos indicado anteriormente no se pueden instanciar objetos de una clase abstracta.

Cuando un método es abstracto, éste, al no tener contenido, tiene que ser redefinido e implementado en las clases hijas de la clase abstracta, es decir, una clase abstracta se suele situar en la raíz de una jerarquía de clases.

Las clases abstractas suelen definir conceptos genéricos que no deben concretar en ningún objeto. En el mundo real podemos encontrar una clase abstracta como la clase Comida, sería una clase abstracta ya que nunca vemos objetos Comida, comemos objetos Manzana, Fresa, Filete, Sopa, etc. La clase Comida representa el concepto abstracto de las cosas que podemos comer, pero nunca vamos poder a comer un objeto Comida.

De forma similar, en la Programación Orientada a Objetos, hay veces en las que necesitamos modelizar un concepto abstracto (como en el caso de Comida) sin tener que crear una instancia de ello. Por ejemplo la clase Number de Java representa el concepto abstracto de los números. Tiene sentido modelizar y definir el concepto de número en un programa, pero no tiene sentido crear un objeto genérico de número.

La clase Number va a ser la clase padre de las clases Integer y Float, estas dos otras clases ya implementan un tipo específico de números. Por lo tanto una clase abstracta puede ser únicamente subclasificada, es decir, se puede heredar de ella, pero no se puede instanciar. La clase abstracta Number estaría declarada como indica el Código fuente 49.

Como ya hemos indicado una clase abstracta puede contener métodos abstractos (y también métodos no abstractos), que no van a contener ninguna implementación, por lo tanto mediante estos métodos podremos definir el comportamiento que van a tener las clases que hereden de la clase abstracta.


87

abstract class Number{..........}

Código fuente 49

Las clases hijas de la clase abstracta deberán implementar (redefinir) obligatoriamente todos los métodos abstractos de la clase padre.

Hay sin embargo tres tipos de métodos que no pueden hacerse abstractos:

• Constructores: como es lógico, un constructor no puede ser abstracto ya que éste tiene que inicializar el objeto.

• Estáticos: los métodos static no pueden ser abstractos porque no pueden ser redefinidos en las clases hijas.

• Privados: los métodos abstractos tienen que ser redefinidos en las clases hijas, pero por definición, los métodos private no son visibles desde las clases heredadas por lo que esta labor se hace imposible.

A continuación se muestra un ejemplo del uso de clases abstractas. Tenemos una clase abstracta denominada ObjetoGrafico, que representa un objeto que podemos dibujar. Esta clase ofrece dos atributos, x e y que indican la posición en la que se encuentra el objeto a dibujar; también ofrece dos métodos, el método moverA(), que no es abstracto y que permite desplazar el objeto a un lugar determinado, y un segundo método que si es abstracto y que de llama dibujar(), y su función es la de dibujar la figura.

El método moverA() se implementa en la clase abstracta, ya que desplazar un objeto gráfico a una posición se hace siempre igual con independencia del tipo de objeto. Sin embargo, el método dibujar() será distinto en cada tipo de objeto gráfico o figura, no se dibuja igual una circunferencia que un rectángulo.

El código de la clase ObjetoGrafico aparece en el Código fuente 50.

abstract class ObjetoGrafico{int x,y;..........void moverA(int nuevaX, int nuevaY){

//implementación del método}abstract void dibujar();

}

Código fuente 50

De la clase ObjetoGrafico heredan otras dos clases: Rectangulo y Circunferencia. Por lo tanto la jerarquía de clases quedaría como muestra la Figura 4.

Las clases Rectangulo y Circunferencia, al heredar de ObjetoGrafico, deben redefinir o sobrescribir el método abstracto dibujar() para que tenga un contenido.


88

Figura 4

El aspecto que pueden tener las clases Rectangulo y Circunferencia es el que se muestra en el Código fuente 51.

class Rectangulo extends ObjetoGrafico{void dibujar(){//implementación del método}

}

class Circunferencia extends ObjetoGrafico{void dibujar(){

//implementación del método}}

Código fuente 51

POO en Java: otros conceptos

Introducción Este es el último capítulo de los dedicados a la forma en la que el lenguaje Java implementa el paradigma de la Programación Orientada a Objetos. En los capítulos anteriores hemos visto el tratamiento e implementación que el lenguaje Java hace de los objetos y clases, y en este capítulo vamos a ver el concepto de interfaz y excepción.

Además comentaremos un concepto propio del lenguaje: los paquetes, describiendo de forma breve los paquetes principales que ofrece Java.

Terminaremos realizando una descripción de la clase raíz de la jerarquía de clases de Java, es decir, la clase Object.

Interfaces Un interfaz en Java es un conjunto de constantes y de métodos que no poseen una implementación, un interfaz define un comportamiento o un protocolo. Vamos a ver el concepto de interfaz a través de un ejemplo.

Un interfaz podrá ser RobarCasa, en este interfaz se define el protocolo o comportamiento necesario para robar una casa. Este interfaz tiene los métodos accederCasa(), buscarBotin() y abandonarCasa(). Estos tres métodos indican a grandes rasgos los pasos para robar una casa.


90

El primero de los métodos, consiste en conseguir entran en la casa, este método no tiene ninguna implementación, al igual que todos métodos que formen parte de un interfaz, ya que cada ladrón tendrá un procedimiento determinado: forzar la puerta, entrar por la ventana, etc. Lo mismo ocurre con los otros dos métodos.

De esta forma la clase que implemente el interfaz obligatoriamente debe dar un contenido determinado a todos los métodos indicados por el interfaz. En el caso del ejemplo anterior podemos tener dos clases LadronPiso y LadronChalet, que van a implementar el interfaz RobarCasa.

Cada uno de estos dos tipos de ladrones implementará de forma distinta el interfaz, ya que no es lo mismo entran a robar en un piso décimo que en una casa de campo, pero lo que si está claro es el protocolo que van a utilizar en todos los casos los ladrones que implementen el interfaz RobarCasa: acceder a la casa, buscar los objetos de valor y huir con ellos.

Se podría pensar que el interfaz se puede sustituir por una clase abstracta y que las clases que implementan el comportamiento heredaran de ella, como ya habíamos visto en el apartado anterior. Pero esto no es adecuado en la mayoría de los casos, ya que por ejemplo, la clase LadronPiso puede ser una clase que herede de la clase Persona y no podríamos hacer que heredará también de la clase Robo, ya que en Java no se permite la herencia múltiple.

Una vez comentado el concepto de interfaz e ilustrado con ejemplos en la vida real, vamos a ver como definimos en Java un interfaz.

La definición de un interfaz tiene dos partes o secciones: la declaración del interfaz y el cuerpo del interfaz.

Declaración del interfaz La declaración de un interfaz tiene la siguiente sintaxis general:

[public] interface NombreInterfaz [extends <NombreInterface1> [,<NombreInterface2>, ... ]]{}

Un interfaz se puede declarar como público con el modificador public, para que lo pueda implementar cualquier clase, pero sino indicamos nada (por defecto package), sólo se podrá utilizar en las clases que se encuentren en el mismo paquete que el interfaz.

La palabra reservada interface indica que lo que estamos definiendo es un interfaz. A continuación aparece el nombre del interfaz que puede ser cualquier identificador válido del lenguaje Java.

A continuación se indican los interfaces de los que se hereda, en el caso de los interfaces si que se permite la herencia múltiple, como se puede observar. Un interfaz hereda todos los métodos y constantes de sus interfaces padre. Para heredar de los interfaces padre se sigue utilizando la palabra reservada extends.

Cuerpo del interfaz En el cuerpo del interfaz nos encontramos la definición de los métodos y constantes del interfaz.

© Grupo EIDOS 6. POO en Java: otros conceptos

91

Los métodos declarados en el interfaz son implícitamente abstractos, ya que no ofrecen ningún tipo de implementación, esta implementación la realizarán las clases que implementen el interfaz. Por lo tanto no es necesario utilizar la palabra reservada abstract con los métodos de un interfaz.

Los atributos que se definen en un interfaz son implícitamente constantes, y es como si se aplicaran los modificadores public static final. Aunque no es necesario utilizarlos, y como regla de estilo los modificadores static y final nunca aparecen en la declaración de los atributos (en este caso constantes) de un interfaz.

Un ejemplo de código de un interfaz lo tenemos en el Código fuente 52 que representa el comportamiento de un reloj despertador.

public interface Despetador{//atributos del interfazpublic long UN_SEGUNDO=1000;public long UN_MINUTO=60000;//método del interfazpublic void despertar();}

Código fuente 52

La clase Reloj implementaría este interfaz dándole un contenido al método despertar().

Excepciones En el presente apartado vamos a comentar el mecanismo de errores y recuperación de los mismos que nos ofrece el lenguaje Java.

Una excepción lo podemos definir como un suceso excepcional que se produce durante la ejecución de un programa y que interrumpe el flujo normal de las instrucciones del programa.

Existen distintos tipos de errores que pueden causar excepciones, desde problemas en el hardware a problemas en la programación, al acceder por ejemplo a un elemento de un array que no existe.

En Java, cuando se produce un error en un método, el método crea un objeto excepción y se lo pasará al entorno de ejecución. Este objeto contendrá información acerca del error que se ha producido.

El entorno de ejecución es el responsable de encontrar el código que trate el error que se ha producido. En la terminología del lenguaje Java, crear un objeto excepción y pasárselo al entorno de ejecución se denomina lanzar una excepción.

Los candidatos a manejar o tratar el error que se ha producido son los métodos que se encuentran en la pila de llamadas del método en el que se ha producido el error, es decir, los métodos que se han invocado antes. El entorno de ejecución va buscando hacia atrás en la pila de llamadas desde el método en el que se ha producido el error, hasta que encuentra el método que tiene el tratamiento de la excepción adecuado.

Un tratamiento de excepción adecuado se produce cuando la excepción que se trata es del mismo tipo que la que se ha lanzado al producirse el error. Cuando se trata la excepción en la terminología Java se dice que se ha atrapado la excepción.


92

Si el entorno de ejecución no encuentra ningún método que trate la excepción se detendrá la ejecución del programa.

En Java un método en el que se pueden dar excepciones, tiene dos posibilidades, o atrapar la excepción o lanzarla.

Un método atrapará una excepción ofreciendo un manejador de la excepción. Más adelante mostraremos como se implementan en Java. Por el contrario, si un método no atrapa una excepción deberá lanzarla, para que sea atrapada por otro método.

Java tiene diferentes tipos de excepciones, excepciones de entrada/salida, en tiempo de ejecución e incluso podemos crear nuestras propias excepciones.

Las excepciones en tiempo de ejecución son aquellas que se producen durante la ejecución del programa, es decir, en su entorno de ejecución. Este tipo de excepciones incluye: errores aritméticos, de punteros, acceso a índices, etc. Estas excepciones no son obligatorias tratarlas, sin embargo hay otras, que no son de tiempo de ejecución, y que el compilador si obliga a tratarlas, es decir, el método debe lanzarlas o atraparlas. Estas excepciones se denominan excepciones verificadas.

A continuación vamos a explicar como lanzar nuestras excepciones dentro de un método.

Si queremos lanzar una excepción en un método utilizaremos la sentencia throw. Esta sentencia requiere un único argumento: un objeto que descienda de la clase Throwable. La sintaxis de esta sentencia es:

throw SubClaseThrowable

Para indicar que un método puede lanzar una excepción se utiliza la cláusula throws, ya que Java nos obliga a atrapar la excepción, o bien a lanzarla, como es el caso. La cláusula se sitúa a continuación de la lista de parámetros del método.

Un ejemplo de un método que genera una excepción e indica que la va a lanzar es el que muestra el Código fuente 53.

public Object pop() throws EmptyStackException{Object obj;if (size==0)

//si la pila esta vacía se crea una instancia de la excepciónthrow new EmptyStackException();

//se desapila el elemento de la pilaobj=objectAt(size-1);setObjectAt(size-1,null);size--;return obj; //se devuelve el elemento desapilado}

Código fuente 53

En el ejemplo anterior el método pop() desapila un elemento de una estructura de datos pila, pero si la pila está vacía crea una instancia de la clase EmptyStackException y la lanza.

En esta caso la excepción la hemos lanzado nosotros mismos, pero hay otras ocasiones en las que invocamos a un método de un objeto determinado, y este método es el que va a lanzar la excepción, en este caso, en el método nuestro en el que le estemos llamando deberemos utilizar la cláusula throws


93

para indicar que la excepción no la vamos a tratar y que nuestro método también la va a lanzar. Así por ejemplo, si queremos llamar al método pop() desde otro método distinto, y éste nuevo método lanza la excepción del método pop(), escribiremos el Código fuente 54.

public miMetodo() throws EmptyStackException{Object objeto;objeto=pop();}

Código fuente 54

Ya hemos visto como lanzar excepciones, ahora debemos ver como atraparlas.

En Java para atrapar y tratar excepciones se utilizan las palabras reservadas try, catch y finally, formando parte de un bloque que va a ser el manejador de la excepción.

Para tratar excepciones, el primer paso es declarar un bloque try que englobe a todas las sentencias susceptibles de producir una excepción. Si se produce alguna excepción en los métodos comprendidos dentro del bloque try, se ejecutará el manejador de excepciones asociado al bloque try.

try{ //sentencias que pueden lanzar excepciones}

El manejador de excepciones asociado a un bloque try se indica mediante uno o más bloques catch. La sintaxis de la sentencia catch es:

catch(SubClaseTrowable nombreVariable){[//sentencias que manejan la excepción]}

En su forma más sencilla el bloque catch puede ir vacío, sin ninguna sentencia. Los parámetros de catch declaran una variable del tipo de excepción que se desea atrapar. Mediante la variable de la excepción se recogerá el objeto correspondiente a la excepción que se ha producido y se utilizará para consultar la información que ofrece.

Podemos utilizar para un mismo bloque try varios bloques catch, de esta forma podremos indicar diferentes tipos de excepciones a tratar. Se debe ir desde la excepción más particular a la más general, para que no se oculten entre sí, cuando se produzca la excepción se ejecutará el bloque catch que corresponda al tipo de excepción en cada caso. De esta forma la sintaxis de los bloques try y catch quedaría:

try {. . .

} catch (SubClaseTrowable nombreVariable) {. . .} catch (SubClaseTrowable nombreVariable) {. . .}

Como hemos visto a un bloque try le deben corresponder uno o más bloques catch, y hay veces en las que también le puede corresponder un bloque finally, aunque no de forma obligatoria.


94

En un bloque finally escribiremos todo el código de limpieza (liberar objetos, ficheros, etc.) en el caso de que se produzca una excepción, finally nos asegura que todas las sentencias de su bloque se ejecutarán cuando se produzca la excepción, una vez tratada por el bloque catch correspondiente.

En el Código fuente 55 ofrecemos un esquema de código que relaciona estos tres tipos de bloques, así un bloque try tendrá uno o más bloques catch y uno o ningún bloques finally.

try {. . .} catch (SubClaseTrowable nombreVariable) {. . .} [catch (SubClaseTrowable nombreVariable) {. . .}[....]finally{

.....}

Código fuente 55

En siguientes capítulos volveremos a retomar el tema de las excepciones en diversos ejemplos, ya que es una práctica común en la programación en Java.

Paquetes El término paquete dentro de la programación en Java ya lo hemos mencionado en algunos momentos del curso, ha llegado la hora de ver los paquetes en profundidad.

Los paquetes es una forma de clasificar y organizar clases e interfaces, para evitar conflictos de nombres, para localizar una clase de forma más sencilla y rápida y para controlar el acceso (modificador de acceso por defecto) a las clases.

Las clases que conforman la jerarquía de clases de Java se encuentran organizadas y son miembros de distintos paquetes, de esta forma las clases básicas del lenguaje están en el paquete java.lang, las clases de entrada/salida en el paquete java.io, etc. Es decir, cada paquete contiene una serie de clases e interfaces relacionados.

Para crear un paquete simplemente deberemos situar la línea que muestra el Código fuente 56 al principio del fichero fuente de la clase o interfaz que queremos que pertenezca al paquete.

package nombrepaquete;public class MiClase{}

Código fuente 56

Deberemos incluir la sentencia package en cada fichero fuente de las clases e interfaces que formen parte de un paquete determinado. Si en un fichero fuente se definen varias clases, todas ellas pertenecerán al paquete indicado por la sentencia package.


95

Si no utilizamos una sentencia package al principio del fichero fuente se considera que las clases o interfaces pertenecen al paquete por defecto, que es un paquete sin nombre.

Los paquetes nos permiten tener distintas clases con el mismo nombre si se encuentran en paquetes diferentes, el compilador distingue las clases a través de los paquetes.

Para la nomenclatura de paquetes existe un convenio establecido, las compañías desarrolladoras de software utilizan su nombre de dominio en Internet como nombre de paquete. Normalmente se sigue la siguiente nomenclatura: com.compañia.paquete, como se puede observar no se utilizan letras mayúsculas. Así por ejemplo, un paquete de clases gráficas desarrollado por la empresa Grupo EIDOS sería: com.eidos.graficos.

Podemos decir que el nombre completo de una clase se compone de: el nombre del paquete del que forma parte y el propio nombre de la clase. De esta forma si la clase Circunferencia forma parte del paquete del ejemplo anterior, su nombre completo sería: com.eidos.graficos.Circunferencia.

Si hacemos referencia a esta clase de la siguiente forma: Circunferencia, decimos que estamos utilizando la nomenclatura reducida.

Dentro del código fuente de una clase nos podremos referir a otra clase utilizando la nomenclatura reducida si la clase que estamos definiendo se encuentra en el mismo paquete que la que estamos referenciando en nuestro código. Pero para poder hacer referencia a una clase que se encuentra en un paquete distinto con esta nomenclatura reducida deberemos importar la clase desde su paquete correspondiente.

Para importar una clase en un paquete deberemos utilizar la sentencia import antes de la declaración de cualquier interfaz o clase, y facilitando el nombre completo de la clase que queremos importar. La sintaxis de esta sentencia es:

import nombrepaquete.NombreClase

Si necesitamos importar varias clases de varios paquetes irán las diferentes sentencias import unas debajo de otras, como muestra el Código fuente 57.

import com.eidos.graficos.Rectangulo;import com.eidos.graficos.Triangulo;import java.awt.Button;

Código fuente 57

Para importar un paquete con todas sus clases, es decir, el paquete completo, utilizaremos en lugar del nombre de la clase, un asterisco (*), como indica el Código fuente 58.

import com.eidos.graficos.*;import java.awt.*;

Código fuente 58

No hay ningún tipo de eficiencia a la hora de importar una única clase de un paquete o el paquete completo.


96

Si el paquete contiene subpaquetes, mediante la notación * no se importan los subpaquetes, sino que tenemos que indicarlo de la siguiente forma:

//se importan todas las clases del paquete pero no sus subpaquetesimport com.eidos.graficos.*;//para importar el paquete 2dimport com.eidos.graficos.2d.*;

Código fuente 59

Por defecto, cuando creamos un fichero fuente, de forma implícita se importa por completo el paquete java.lang, este paquete contiene las clases básicas del lenguaje Java. De esta forma cada fichero fuente es como si tuviera la sentencia import (Código fuente 60).

import java.lang.*;

Código fuente 60

Además del paquete java.lang, el sistema en tiempo de ejecución del lenguaje Java importa el paquete por defecto (sin nombre) y el paquete actual.

El nombre de los paquetes no es arbitrario, sino que tiene una correspondencia física en el sistema de archivos. Vamos a comentar esta afirmación detenidamente.

El nombre de un fichero fuente en Java se construye con el nombre de la clase pública definido en el y la extensión .java. Es decir, en un fichero fuente sólo podremos definir una única clase como public, y además el nombre de esta clase debe coincidir exactamente (mayúsculas y minúsculas) con el nombre del fichero en la que se encuentra definida. De esta forma la clase pública Rectangulo debe estar definida en un fichero fuente llamado Rectangulo.java. Al compilar el fichero fuente se generará el fichero .class correspondiente, en este caso sería Rectangulo.class.

Y el nombre del paquete en el que se encuentre la clase tiene una correspondencia con la estructura de directorios en la que se encuentra el fichero fuente. De esta forma, si la clase Rectangulo se encuentra en el paquete com.eidos.graficos, el fichero fuente, Rectangulo.java, debe encontrarse en el camino com\eidos\graficos. Ahora bien, es necesario identificar desde dónde se comienza a tomar la ruta para que se localice el fichero fuente que representa a una clase que pertenece a un determinado paquete.

El compilador debe ser capaz de localizar todos los paquetes, tanto los estándar del lenguaje Java como los definidos por los programadores, es decir, el compilador debe conocer dónde comienza la estructura de directorios definida por los paquetes y en la cual se localizan las clases. Esto se consigue mediante el ClassPath (ruta o camino de clase).

El ClassPath contendrá todas las rutas en las que comienzan las estructuras de directorios en las que están contenidas las clases. De forma predeterminada, todas las clases estándar de Java se indican en el ClassPath, este camino dependerá del entorno de desarrollo que hayamos elegido para construir nuestros programas Java. Vamos a comentar la forma en la que utilizan el ClassPath los distintos entornos de desarrollo que hemos elegido para el presente curso (JDK, Visual J++ y JBuilder).

En la versión 1.1 del lenguaje Java las clases estándar de Java se encontraban en un fichero llamado classes.zip.


97

En el caso de la herramienta de Microsoft Visual J++ 6.0 las clases se encuentran localizadas en diversos ficheros ZIP que se encuentran en el camino: directorioWindows\Java\Packages.

Por lo tanto estas dos herramientas añaden estas rutas al ClassPath al instalarse.

Sin embargo en la versión 2 del lenguaje Java el JDK 1.3 no requiere utilizar la variable ClassPath para indicar las clases estándar del lenguaje, el ClassPath sólo será utilizado para indicar clases adicionales, por ejemplo, clases desarrolladas por nosotros.

El ClassPath lo podemos establecer de dos formas diferentes, a través las opciones de compilación del entorno de desarrollo, o bien a través de una variable de entorno del sistema denominada CLASSPATH. En la variable de entorno CLASSPATH se especifica, separadas entre punto y como (;), las rutas a las diferentes clases Java que deseamos localizar para poder utilizarlas en nuestro código.

Para indicar la variable de entorno ClassPath directamente acudiremos al fichero AUTOEXEC.BAT en el caso de encontrarnos en sistemas operativos Windows 95/98 y añadiremos la línea correspondiente. CLASSPATH=ruta_clases_1;ruta_clases_2;... ;ruta_clases_n. Si estamos en sistemas operativos Windows NT/2000 seleccionaremos la opción Panel de Control/Sistema/Entorno, y dentro de ésta añadiremos una variable de entorno CLASSPATH si no existe, y si existe la modificaremos indicando el camino adecuado para las clases.

Como ya hemos indicado, la herramienta JDK 1.3 de Sun no requiere que se establezca el ClassPath para las clases estándar, pero si es necesario para utilizar otras clases, como pueden ser clases creadas por nosotros o por terceros, en este caso estableceremos la variable de entorno CLASSPATH manualmente, como indicábamos en el párrafo anterior,

Para indicar el camino a las clases desde Visual J++ debemos acudir a la opción Proyecto|Propiedades de Proyecto y seleccionar la pestaña Ruta de acceso a clases. Crearemos una nueva ruta pulsando el botón Nueva, en ese momento debemos especificar el camino en el que se encuentran las clases que queremos utilizar. En la figura 1 se puede ver la pantalla que nos permite gestionar las rutas de acceso a las clases.

Figura 5


98

Principales paquetes del lenguaje Java En este apartado se van a describir brevemente los paquetes más importantes que ofrece el lenguaje Java. Estos paquetes contienen las clases principales y que más vamos a usar de la jerarquía de clases del lenguaje. Algunos de estos paquetes no los trataremos en el curso, ya que ofrecen características avanzadas de Java para las que necesaitaríamos otro curso de la extensión de este mismo o superior.

• java.lang: este paquete contiene las clases básicas del lenguaje, este paquete no es necesario importarlo, ya que como dijimos anteriormente, es importado automáticamente por el entorno de ejecución. El resto de los paquetes del lenguaje Java si es necesario importarlos, cuando deseemos utilizar sus clases, esto lo haremos mediante la sentencia import. En este paquete se encuentra la clase Object, que sirve como raíz para la jerarquía de clases de Java, esta clase la comentaremos en el apartado siguiente. Otras clases importantes comprendidas en este paquete son System, que representa al sistema en el que se está ejecutando la aplicación, Thread, que representa un hilo de ejecución y Exception que representa a las excepciones de forma general. De todas formas a lo largo del siguiente capítulo trataremos en más profundidad estas clases.

• java.applet: en este paquete se encuentran todas las clases que son necesarias para construir los programas Java más populares, los applets. En algunos casos los applets también se denominan miniaplicaciones, término no del todo correcto, un applet puede ser una compleja aplicación, aunque muchas veces los applets que vemos en Internet parecen estar sólo destinados a tareas estéticas para las páginas Web. La clase principal es la clase Applet que representa a un programa que se ejecuta en el entorno de una página Web mostrada por un navegador. En este curso hay un capítulo completamente dedicado a los applets de Java.

• java.awt: en este paquete se encuentran uno de los grupos de clases relacionadas con la construcción de interfaces de usuario, es decir, clases que nos permiten construir ventanas, botones, cajas de texto, etc. AWT son las iniciales de Abstract Window Toolkit, algo así como herramientas abstractas para ventanas. Los interfaces de usuario se podrán mostrar igualmente en aplicaciones Java y applets Java. Algunas de las clases que podemos encontrar en este paquete son Button, TextField, Frame, GridLayout, Label, etc., todas ellas útiles para crear interfaces de usuario. En este paquete encontramos un subpaquete especializado en el tratamiento de eventos, y es el que vamos a comentar a continuación.

• java.awt.event: este subpaquete del paquete java.awt, es el encargado de proporcionar todas las clases que permiten realizar el tratamiento de eventos en Java. Existe una completa jerarquía de clases para representar cada uno de los eventos que se puedan producir a partir de la interacción del usuario con el interfaz de usuario. En el capítulo correspondiente trataremos ampliamente el tema de los eventos dentro de la programación en Java. En este paquete podemos encontrar clases como ActionEvent, que representa el evento que se produce cuando pulsamos un botón o MouseEvent que representa eventos del ratón.

• java.io; este paquete reúne todas las clases relacionadas con la entrada/salida, ya sea para manipular ficheros, leer o escribir en pantalla, en memoria, etc. Este paquete ofrece clase como FileReader, que representa un fichero del que se quiere leer, ByteArrayOutputStream, representa un array que se quiere escribir en memoria. La entrada/salida en Java tiene una serie de complejidades y particularidades que se tratarán en el capítulo correspondiente.

• java.net: aquí encontramos una serie de clases que tienen que ver directamente con la programación en Internet, como puede ser utilizar sockets, obtener información de URLs (Uniform Resource Locator), manipular direcciones IP (Internet Protocol). Es decir, este paquete tiene las clases que se encuentran relacionadas con la programación a través de la red.


99

En este paquete podemos encontrar las clases como: URL, que representa una localización de un recurso dentro de Internet, o Socket, que representa una conexión del lado del cliente con un servicio determinado a través de la red. A través de este paquete podremos construir aplicaciones dentro de la arquitectura cliente servidor.

• java.sql: a través de este paquete se nos ofrecen todas las clases necesarias para programar en Java el acceso a bases de datos, a este conjunto de clases se le suele denominar API JDBC. El paquete java.sql se sale de los objetivos de este curso. Aunque podemos comentar que en este paquete se ofrecen clases como pueden ser Connection, que representa una conexión con la base de datos, Statement, representa una sentencia SQL, Driver, representa el driver utilizado para establecer la conexión con la base de datos.

• javax.swing: este paquete reúne el segundo conjunto de clases que se utilizan para construir interfaces de usuario. Los componentes que se engloban dentro de este paquete se denominan componentes Swing, y suponen una alternativa mucho más potente que AWT para construir interfaces de usuario muchos más complejos. Este paquete es nuevo en Java 2 y tiene un gran número de clases: JFrame, JButton, JLabel, JOptionPane, JPanel, JApplet, etc. Este paquete añade nuevos componentes para la construcción de interfaces de usuario que no se encontraban presentes en el paquete java.awt, además se ofrecen nuevas características como son el aspecto y comportamiento para distintos sistemas, ventanas de diálogo configurables, componentes estructurados (JTable y JTree), capacidades para las funciones deshacer (undo), potentes manipulaciones de texto, etc. Los componentes Swing se denominan componentes ligeros ya que se encuentran completamente escritos en Java sin utilizar ningún código nativo y no depende su aspecto ni comportamiento del sistema operativo en el que se utilicen. Este paquete se encuentra englobado en lo que se denomina JFC (Java Foundation Classes).

• javax.swing.event: este paquete contiene una serie de clases e interfaces relacionados con los nuevos eventos ofrecidos por los componentes Swing, como puede ser MenuListerner o TreeSelectionListener.

• java.util: como su nombre indica este paquete ofrece una serie de clases que se utilizan como utilidades para el lenguaje. Algunas de estas clases son: Date, para el tratamiento de fechas, Random, para la generación de números aleatorios, Enumeration, para tratar un conjunto de objetos.

• java.beans: como ya se había comentado, en capítulos anteriores, los JavaBeans son componentes software que permiten a los desarrolladores escribir y ofrecer componentes Java que pueden ser utilizados por otras herramientas de desarrollo. Este paquete nos ofrece los medios necesarios para desarrollar JavaBeans.

• java.rmi: Remote Method Invocation (invocación remota de métodos, RMI) , permite crear objetos cuyos métodos pueden ser invocados por otros objetos ejecutándose en otras máquinas virtuales, incluso máquinas virtuales ejecutándose en otro host.

• java.text: este paquete ofrece herramientas para la internacionalización de texto, tales como formato de fecha y formato numérico.

• java.security: este paquete y sus subpaquetes ofrecen interfaces básicos para operaciones relativas a la seguridad, tales como autenticación, autorización, firma de datos y encriptación.

• java.math: este paquete ofrece herramientas para manipulaciones matemáticas.

• javax.accessibility: define una serie de contratos entre interfaces de usuario y tecnologías de rehabilitación.


100

A lo largo de los diferentes capítulos del curso iremos detallando algunas de las clases más importantes de estos paquetes.

Además de los paquetes que hemos comentado, existen una serie de subpaquetes que ofrecen unas funcionalidades más específicas y que pasamos a exponer a continuación.

• java.awt.dnd: este paquete ofrece las clases necesarias para implementar mecanismos Drag and Drop dentro de interfaces de usuario, es decir, permiten arrastrar y soltar componentes del interfaz de usuario para de esta forma intercambiar información.

• java.awt.font: ofrece clases e interfaces para tratar y manipular fuentes.

• java.awt.image: paquete especializado en el tratamiento y creación de imágenes.

• java.awt.print: soporte para realizar tareas de impresión.

• java.util.jar: ofrece clases para escribir y leer ficheros en formato JAR (Java ARchive).

• java.util.zip: ofrece clases para escribir y leer ficheros en formato ZIP.

• javax.sound.midi: presenta clases e interfaces para entrada/salida y síntesis de datos en en formato MIDI (Musical Instrument Digital Interface).

• javax.swing.border: ofrece clases e interfaces para dibujar bordes entorno a componentes Swing.

• javax.swing.plaf: mediante este paquete se ofrecen las clases e interfaces para implementar el mecanismo pluggable look and feel, es decir, el aspecto y comportamiento configurable de los componentes Swing.

• javax.swing.table: permite manipular el componente Swing JTable, del paquete javax.swing, que representa la estructura de una tabla.

• javax.swing.table: otro subpaquete del paquete javax.swing, en este caso permite manipular componentes de texto, tanto editables como no editables.

• javax.swing.tree: permite manipular el componente Swing JTree, del paquete javax.swing, que representa una estructura de árbol.

• javax.swing.undo: ofrece soporte para la funcionalidad deshacer/rehacer de aplicaciones tales como editores de texto

Como se puede comprobar Java ofrece una completa jerarquía de clases organizadas a través de paquetes.

La clase Object Se ha añadido este apartado dedicado a la clase Object debido a su importancia dentro de la jerarquía de clases de Java, y representa el comportamiento básico que todos los objetos deben tener.

Como ya hemos comentado en alguna ocasión, la clase Object, se encuentra en la raíz de toda la jerarquía de clases que forman el lenguaje Java; y por lo tanto, toda clase escrita en Java desciende de


101

esta clase, ya sea de forma directa, o indirectamente, ya que hereda de otra, la cual a su vez hereda de otra, y así sucesivamente hasta llegar a la clase Object.

En aquellas clases en las que se no incluye la palabra extends en su declaración Java asume que la clase padre es Object. Con lo cual se hereda directamente de la clase raíz Object. A continuación vamos a comentar los distintos métodos que presenta la clase Object, ya que estos métodos los contendrán todas las clases del lenguaje Java.

Constructor: Object()

Éste es el constructor de la clase y simplemente crea una nueva instancia de la clase Object.

Método clone()

Éste método, permite obtener un duplicado del objeto. Es decir, crea un nuevo objeto de la misma clase e inicializa todos los atributos del objeto clonado asignándoles el mismo valor que el que tenían en el objeto original.

Método equals()

Indica si dos objetos son iguales. Para cualesquiera valores de x e y, x.equals(y) devolverá true sí y sólo si x e y se refieren al mismo objeto.

Método finalize()

Éste método es llamado por el recolector de basura. No hace nada, y por lo tanto para darle alguna tarea, debe ser redefinido o sobreescrito.

Método getClass()

Determina la clase de un objeto en tiempo de ejecución.

Método hashCode()

Proporciona el código hash de un objeto, y se proporciona para darle utilidad a las hashtables.

Método notify()

Reactiva una tarea que se encuentra en estado de espera.

Método notifyAll()

Reactiva todas las tareas que se encuentren en estado de espera.

Método toString()

Crea una cadena de texto que representa al objeto, de forma que una persona pueda identificar el objeto.

Método wait()

Pone en modo de espera una tarea.

POO en Java: un ejemplo. Resumen de conceptos

Introducción Este capítulo propone un sencillo ejemplo en el que se retoman y utilizan muchos de los conceptos de la POO aplicados al lenguaje Java, y que hemos explicado en los tres capítulos anteriores.

Además trataremos la herramienta de desarrollo de Sun Microsystems JDK (Java Development Kit) 1.3. Utilizaremos el JDK 1.3 para generar (compilar) nuestras clases e interfaces del ejemplo.

En el siguiente capítulo trataremos las aplicaciones Java con detenimiento.

Descripción del problema El ejemplo que vamos a presentar se trata de un videojuego que va a consistir únicamente en mostrar una serie de mensajes en pantalla, como se podrá comprobar no se trata de nada espectacular, pero muestra algunos de los conceptos principales de la POO aplicados al lenguaje Java.

En este videojuego debemos dirigir a una serie de extraterrestres que tienen como misión la de invadir el planeta tierra..

A continuación se comentan las distintas clases que se van a utilizar en el ejemplo y la función de cada una de ellas.


104

• Extraterrestre: clase abstracta que representa a los extraterrestres de forma general. Nunca vamos a instanciar objetos de esta clase, sino que vamos a tener dos tipos de extraterrestres que van a heredar de esta clase.

• Selenita: es un tipo de extraterrestre concreto, por lo tanto heredará de la clase Extraterrestre.

• Venusiano: es otro tipo de extraterrestre que hereda también de la clase Extraterrestre.

• DominarPlaneta: se trata de un interfaz (comportamiento) que implementarán de forma distinta cada uno de los dos tipos de extraterrestres.

• VideoJuego: es la clase principal o la clase de arranque y se va a encargar de poner el videojuego en funcionamiento instanciando los objetos de las clases correspondientes y lanzando métodos sobre ellos.

Vamos a ver a continuación como implementar las distintas clases e interfaces y como utilizar de forma sencilla la herramienta de desarrollo JDK 1.3.

Utilizando el JDK 1.3 Ya hemos comentado en capítulos anteriores y en este mismo capítulo, que el JDK 1.3 es la última versión del entorno de desarrollo que propone Sun Microsystems, los creadores del lenguaje Java, por lo tanto esta es la única herramienta de desarrollo en Java necesaria para seguir el presente curso. Aunque también comentaremos (ya hemos visto algo de ellas) otras dos herramientas, una de Microsoft (en el siguiente capítulo), Visual J++ 6.0 y otra de Borland, JBuilder 3.5.

El JDK 1.3 recoge la última versión del lenguaje Java, es decir, lo que se denomina Java 2 o también la plataforma Java 2. Este software es gratuito y lo podemos obtener del sitio Web de Sun http://java.sun.com. Aunque curiosamente no lo encontraremos como JDK 1.3, sino que se incluye dentro de otro software denominado Java 2 SDK (Software Development Kit) Standard Edition 1.3.0.

Una vez que hemos descargado el Java 2 SDK 1.3.0 procedemos a su instalación, que consiste en ejecutar el fichero que hemos descargado (j2sdk1_3_0-win.exe, en la versión Windows) y seguir los sencillos pasos que nos indica el programa de instalación.

Por otro lado podemos descargar también la documentación del Java 2 SDK 1.3.0, ya que supone una referencia muy útil, tanto para expertos como para novatos del lenguaje Java. En esta documentación se detallan todas las clases e interfaces de cada uno de los paquetes que forman parte de la especificación del lenguaje Java.

El software se instala por defecto en el directorio jdk 1.3. Puede ser útil incluir en él la variable PATH de Windows la ruta c:\jdk1.3\bin para poder ejecutar y compilar nuestras clases Java de forma rápida y sencilla.

El JDK 1.3 funciona en forma de comandos, por ejemplo si queremos compilar una clase determinada escribiremos lo que muestra el Código fuente 61 en nuestra línea de comandos.

javac NombreClase.java

Código fuente 61

© Grupo EIDOS 7. POO en Java: un ejemplo. Resumen de conceptos

105

Para escribir el código de nuestras clases utilizaremos un editor de textos como puede ser el bloc de notas de Windows o cualquier otro editor que no introduzca caracteres especiales.

Cada clase pública debe definirse en un fichero de código fuente Java distinto, en nuestro caso vamos a tener cinco ficheros .java, ya que todas nuestras clases van a ser públicas. Además el fichero de código fuente debe tener el mismo nombre que la clase pública definida en el mismo, y debe coincidir en mayúsculas y minúsculas.

Las herramientas más interesantes que ofrece el JDK y que podemos ejecutar desde la línea de comandos son las siguientes:

• java: es la máquina virtual de Java, es decir, el intérprete que vamos a utilizar para ejecutar nuestras aplicaciones Java.

• javac: es el compilador del código fuente de Java, generará los bytecodes correspondientes (en forma de fichero .class) y nos indicará si el código fuente es correcto.

• javadoc: mediante esta utilidad se puede generar documentación de forma automática a partir de los comentarios de nuestro código fuente.

• jar: utilidad que permite manejar los ficheros JAR (Java archive), ficheros comprimidos de Java.

• appletviewer: es el visor de applets, ejecuta los applets fuera del contexto de un navegador Web.

Estas herramientas las iremos utilizando y comentando según se vaya desarrollando el curso.

Vamos a pasar a la implementación de las clases de nuestro ejemplo en el siguiente apartado.

Creando las clases Vamos a comenzar por la clase abstracta Extraterrestre, que como ya hemos dicho va a representar a los extraterrestres de manera genérica. Esta clase se va componer de los siguientes elementos:

• Tres atributos que, para cumplir con la normativa de la POO, se declararán como privados y que van a describir un extraterrestre. Estos atributos son del tipo primitivo de Java int y de la clase String.

• Varios métodos de acceso para obtener y manipular los diferentes atributos de la clase.

• Un constructor que inicializa los valores de los atributos de la clase.

• Y otros métodos típicos de extraterrestres.

Veamos el Código fuente 62 de la clase Extraterrestre.

public abstract class Extraterrestre{//atributos privadosprivate int piernas;private int ojos;


106

private String color;

//constructorpublic Extraterrestre(int piernas, int ojos, String color){

this.piernas=piernas;this.ojos=ojos;this.color=color;

}//métodospublic void atacarTerricola(){

System.out.println("Terrícola capturado");}public void teletransportar(String lugar){

System.out.println("Ahora estoy en:"+lugar);}//métodos de accesopublic int devuelvePiernas(){

return piernas;}public void asignaPiernas(int piernas){

this.piernas=piernas;}public int devuelveOjos(){

return ojos;}public void asignaOjos(int ojos){

this.ojos=ojos;}public String devuelveColor(){

return color;}public void asignaColor(String color){

this.color=color;}

}

Código fuente 62

Como se puede ver es una clase pública y abstracta y que hereda de la clase Object, ya que no hemos indicado que herede de otra clase. También se puede observar que en los métodos de acceso para diferenciar a los parámetros de los atributos de utiliza la palabra reservada this. El fichero fuente tiene el nombre Extraterrestre.java y al compilarlo con el comando javac del JDK 1.3 obtenemos el fichero .class correspondiente. Si se produce algún error en la compilación no se generará el fichero .class correspondiente y el JDK nos lo notificará por pantalla, como se muestra en la Figura 6.

Pasemos ahora a la clase Venusiano. Esta clase hereda de la clase Extraterrestre, y por lo tanto presentará los mismos métodos públicos que los de su clase padre. Esta nueva clase añade un atributo y presenta un constructor sin parámetros, pero dentro de este constructor se llama al constructor de la clase padre a través de la palabra reservada super, para indicar las características de los venusianos.

Veamos el Código fuente 63 de la clase Venusiano.

public class Venusiano extends Extraterrestre{//añade atributoprivate int cabezas;

//constructor sin argumentos, todos los venusianos son igualespublic Venusiano(){

//debemos llamar al constructor de la clase padresuper(4,4,"Verde");


107

this.cabezas=2;}public void atacarTerricola(){

//si no queremos sobreescribir completamente el método de la//clase padresuper.atacarTerricola();//los venusianos vienen para experimentarSystem.out.println("Experimentar con terrícola");

}}

Código fuente 63

Figura 6

Como se puede comprobar esta clase sobrescribe, no de forma total, el método atacarTerricola() de la clase Extraterrestre, se vuelve a hacer uso de la palabra reservada super.

El interfaz DominarPlaneta presenta varios métodos que se pueden utilizar en este tipo de comportamiento, por lo tanto toda clase que quiera implementar este interfaz está obligada a dar un contenido a los métodos que define. El interfaz DominarPlaneta tiene el Código fuente 64.

public interface DominarPlaneta{

public abstract void aniquilarPoblacion(String planeta);

public abstract void proclamarGobierno(String planeta);

public abstract void controlarRecursos(String planeta);

}

Código fuente 64

Un interfaz se compilará de la misma forma que una clase.


108

La siguiente clase es la clase Selenita, que hereda también de la clase Extraterrestre y además como no vienen en son de paz implementan el interfaz DominarPlaneta, pero uno de los métodos no desean implementarlo, por lo que se deja el cuerpo del método vacío. Esta clase añade un nuevo atributo y nuevos métodos. Veamos su código, en el Código fuente 65, al igual que hemos hecho con el resto de las clases.

public class Selenita extends Extraterrestre implements DominarPlaneta{//añade atributoprivate String armamento;public void atacarTerricola(){

//si no queremos sobreescribir completamente el método de la//clase padresuper.atacarTerricola();//los venusianos vienen aniquilar la raza humanaSystem.out.println("Aniquilar terrícola");dispararArma();

}//añade métodopublic void dispararArma(){

if (armamento.equals("cañón láser")){System.out.println("BOUMMM");

}else{

System.out.print("Bzzzzzz");}

}

//constructor con parámetro, cada selenita puede tener un arma//diferentepublic Selenita(String armamento){

super(2,1,"Azul");this.armamento=armamento;

}//añade método de accesopublic void asignarArmamento(String armamento){

this.armamento=armamento;}//métodos del interfazpublic void proclamarGobierno(String planeta){

System.out.println("Eliminar gobernantes del planeta:"+planeta);System.out.println("Gobernamos sobre el planeta "+planeta);

}public void aniquilarPoblacion(String planeta){

System.out.println("Utilización de armas nucleares sobre el planeta"+planeta);

}//no interesa este métodopublic void controlarRecursos(String planeta){}

}

Código fuente 65

La última clase de nuestro ejemplo es la clase VideoJuego, esta clase va a ser la clase principal y se va a encargar de instanciar los distintos objetos de las clases Selenita y Venusiano que pertenecen al videojuego.

Esta clase presenta un único método, el método main(), que veremos en detalle en el próximo capítulo, únicamente adelantaremos que es el método de arranque de una clase y es necesario si queremos ejecutar una clase que representa una aplicación Java.


109

Veamos el código de la clase VideoJuego (Código fuente 66).

public class VideoJuego{public static void main(String args[]){

//Un venusiano:Venusiano alien=new Venusiano();System.out.println("Es de color: "+alien.devuelveColor());alien.teletransportar("Soria");alien.atacarTerricola();System.out.println();//Un selenitaSelenita alien2=new Selenita("cañón láser");alien2.teletransportar("Madrid");alien2.atacarTerricola();//utilizamos el interfaz que implementa el selenita:alien2.aniquilarPoblacion("Tierra");System.out.println();

}}

Código fuente 66

Una vez compilada esta clase vamos a ejecutarla para observar el resultado de la utilización de los dos objetos de nuestro juego, el objeto de la clase Venusiano y el objeto de la clase Selenita.

Para ejecutar una clase utilizamos el intérprete que ofrece el JDK, se trata del comando java. Para ejecutar una clase se debe escribir en la línea de comandos la instrucción que muestra el Código fuente 67.

java NombreClase

Código fuente 67

El resultado de ejecutar la clase VideoJuego es el que muestra la Figura 7.

Figura 7

El código fuente completo de este ejemplo se puede obtener aquí.

En el próximo capítulo se tratan las aplicaciones Java con detenimiento.

Aplicaciones Java

Introducción Hasta ahora hemos definido primero conceptos de Programación Orientada a Objetos, luego vimos las particularidades del lenguaje Java, su sintaxis y también como implementa los mecanismos de la POO, por lo tanto ya estamos en disposición de comenzar a realizar programas Java.

En este capítulo vamos a comentar todos los aspectos de uno de los tipos de programas que se puede realizar con el lenguaje Java, las aplicaciones Java. No se debe olvidar que Java ofrece dos tipos de programas: applets y aplicaciones. En este curso se ha dedicado un capítulo para cada tipo de programa.

En el presente capítulo también vamos comentar y explicar como utilizar las herramientas de desarrollo Microsoft Visual J++ 6.0 y Borland JBuilder 3.5. Pero siempre teniendo en cuenta que vamos a generar código estándar del lenguaje Java.

Las aplicaciones Java son aplicaciones de propósito general al igual que existen en otros lenguajes como C++ o Visual Basic, lo único que las distingue es que no vamos a generar un ejecutable como en los otros lenguajes de programación, sino que, como ya sabrá el lector, generamos ficheros de clase que se encuentran en bytecode y que son independientes de la plataforma.

A la hora de ejecutar nuestra aplicación Java será necesario disponer del intérprete de Java adecuado para el sistema operativo en el que nos encontremos.

Se ha creído conveniente explicar antes las aplicaciones Java que los applets Java, debido a que un applet se puede considerar un tipo particular de aplicación.


112

En los siguientes apartados vamos a ir comentando el proceso para crear una aplicación y también nos adentraremos en algunos aspectos del lenguaje Java, según sea necesario.

Introducción a Visual J++ 6 En este curso no se pretende realizar un tutorial completo de la herramienta de desarrollo de Microsoft Visual J++ 6 ni tampoco de la herramienta JBuilder 3.5 de Borland, sino que vamos a comentar aquellos aspectos que sean de un mayor interés para la programación en Java (JBuilder 3.5 lo trataremos en el apartado correspondiente).

En este apartado vamos a comentar los pasos a seguir para poder realizar una sencilla aplicación Java dentro de Visual J++.

MS Visual J++ 6 se encuentra formando parte de la suite de herramientas de desarrollo Microsoft Visual Studio 6, otras herramientas que podemos encontrar en este paquete son Visual C++ 6, Visual Basic 6, Visual InterDev 6...

Una vez arrancado el entorno de desarrollo, seleccionando la opción correspondiente del menú de Inicio, aparece la ventana de Nuevo Proyecto, que se puede observar en la Figura 8. Se puede comprobar también que aparecen otras opciones correspondientes en este caso a Visual InterDev, esto es debido a que en mi equipo de pruebas tengo instalada esta herramienta, por lo tanto esta pantalla puede variar según los componentes que se tengan instalados de Visual Studio.

Nosotros, como es evidente, nos vamos a ocupar de los Proyectos de Visual J++. Dentro de la carpeta Proyectos de Visual J++ existen otras tres subcarpetas, en este capítulo vamos a tratar la primera, la subcarpeta Aplicaciones.

Figura 8

Seleccionamos la carpeta Aplicaciones, y se nos mostrarán tres tipos de aplicaciones distintas que podemos realizar con Visual J++: Aplicación Windows, Aplicación de consola y Asistente para aplicaciones. Vamos a comentar cada una de ellas:

• Aplicación Windows: si seleccionamos este tipo de aplicación, el entorno de desarrollo de forma automática nos creará un formulario que será el arranque de la aplicación. En este caso

© Grupo EIDOS 8. Aplicaciones Java

113

el interfaz que muestra el entorno de desarrollo es muy similar al de Visual Basic, es decir, un formulario sobre el que vamos añadiendo los controles seleccionados en la barra de herramientas correspondiente. Pero en Java y con Visual J++ no resulta tan sencillo, ya que en este tipo de aplicaciones no se utilizan las clases de interfaz de usuario estándar de Java, es decir, las clases del AWT (Abstract Window Toolkit) o componentes Swing, sino que se utilizan unas clases propietarias de Microsoft denominadas WFC (Windows Foundation Clases). Como ya comentamos al principio de este capítulo, vamos a realizar programas que sean 100% Java, por lo tanto no utilizaremos las clases contenidas en WFC y tampoco utilizaremos este tipo de aplicación Java. En la Figura 9 se puede ver lo amigable que resulta el entorno ofrecido por Visual J++. Lamentamos desanimar al alumno, pero si queremos generar código Java puro, en nuestro entorno de desarrollo nunca veremos este tipo de aplicaciones.

Figura 9

• Aplicación de consola: este tipo de aplicación es la que vamos a utilizar para realizar nuestras

aplicaciones Java. Representa una aplicación Java y nos ofrece un código muy básico que nos sirve de esquema para la aplicación y que comentaremos más adelante. En este caso, no disponemos de ningún formulario ni de ninguna barra de herramientas que nos permita ir añadiendo los diferentes controles a nuestra aplicación, aquí todo lo tendremos que hacer a través de código. En la Figura 10 se muestra el aspecto del entorno de desarrollo cuando se selecciona este tipo de aplicación, como se puede ver no es tan amigable como el caso anterior (por ejemplo, la barra de herramientas con las clases WFC se encuentra desactivada), pero estaremos generando código 100% Java, que es lo que nos interesa.

Figura 10


114

• Asistente para aplicaciones: esta opción no es una aplicación en sí, sino que es un asistente

que nos guía a través de sucesivos pasos para construir dos tipos de aplicaciones: aplicación basada en formularios y Aplicación basada en formularios con datos. Este asistente nos generará el código necesario y nos irá preguntando en cada paso nuestras preferencias, por ejemplo, información para la conexión de datos, si es necesaria una barra de menú, etc. También nos permite general para la aplicación un fichero ejecutable. Como se intuye, el código que se genera va a utilizar las clases de Microsoft, es decir, las WFC, por lo tanto, tampoco vamos a utilizar este asistente. En la Figura 11 se puede observar uno de los pasos del asistente.

Figura 11

Hemos empezado a hablar de los proyectos dentro de Visual J++ pero todavía no hemos comentado que es exactamente un proyecto y que elementos forman parte del mismo. A continuación iniciamos esta tarea.

Un proyecto dentro de Visual J++ va a ser un contenedor que va a agrupar desde el punto de vista organizativo todas las clases que creemos para una aplicación.

Físicamente un proyecto se corresponde con un directorio en nuestro sistema de archivos, es decir, si tenemos el proyecto llamado Pruebas, existirá un directorio Pruebas que contendrá todos los ficheros que formen parte del proyecto. Fundamentalmente un proyecto va a contener ficheros fuente de Java, es decir, ficheros .java.

Un proyecto se engloba en una entidad de nivel superior denominada solución. Una solución tiene la función de guardar referencias a proyectos, es decir, es una solución vamos a tener distintos proyectos.

Una solución no se corresponde físicamente con un directorio, como ocurría en el caso de los proyectos, sino que se trata de un fichero .SLN que apunta a todos los proyectos que contiene. Podemos agregar a una solución tantos proyectos como queramos.


115

Una vez creado un proyecto, seleccionando la opción Proyectos en J++|Aplicaciones|Aplicación de consola, el entorno de desarrollo genera el Código fuente 68 para nosotros, con una serie de comentarios.

/*** Esta clase puede tomar un número variable de parámetros* en la línea de comandos. La ejecución del programa comienza* con el método main(). La llamada al constructor de clase no tiene lugar a menosque se cree un objeto del tipo 'Class1'* en el método main().*/public class Class1{

/*** Punto de entrada principal para la aplicación.** @param args Matriz de parámetros pasados a la aplicación* mediante la línea de comandos.*/public static void main (String[] args){

// TODO: Agregar aquí el código de inicialización}

}

Código fuente 68

Como se puede observar, de forma automática se crea una clase pública denominada Class1, y dentro de esta clase se declara un método llamado main(), que va a ser el método de arranque de la clase y el protagonista de nuestro nuevo apartado.

Como el lector habrá podido observar, delante de uno de los comentarios se añade la cadena TODO:, si a un comentario le añadimos esta cadena, aparecerá como una tarea pendiente de realizar en la lista de tareas. Esto resulta muy útil cuando dejemos en nuestro código secciones o sentencias pendientes de codificación, después consultando la lista de tareas sabremos que tenemos pendiente de realizar.

Para ver la lista de tareas ( que se puede observar en la Figura 12) debemos seleccionar la opción de menú Ver|Otras Ventanas|Lista de tareas.

Figura 12

Además de añadir tareas a través de comentarios especiales de código, también las podremos añadir a través de la lista de tareas de forma directa pulsando sobre la primera fila. La gestión de tareas a través de la lista de tareas es bastante útil y muy fácil de utilizar.

Una vez que hemos creado una aplicación y ya la tenemos disponible, vamos a realizar con ella una tarea muy sencilla. Vamos a mostrar el típico saludo Hola Mundo a través de la pantalla.


116

Como ya veremos en el siguiente apartado, el método main() se ejecuta siempre, por lo tanto vamos a utilizar este método para mostrar el mensaje. Si eliminamos los comentarios generados por Visual J++, el código completo sería como el Código fuente 69.

public class Class1{public static void main (String[] args){

System.out.println("Hola Mundo");}

}

Código fuente 69

Al escribir la sentencia anterior se habrá podido comprobar dos de las grandes ayudas que nos ofrece Visual J++ al programador. Por un lado tenemos el intellisense, este mecanismo se habrá observado al situar el punto delante de System. Este mecanismo nos ofrece una lista de los atributos y métodos que tenemos disponibles, también nos informa de los parámetros que debemos pasarle a un método, etc.

La segunda ayuda es la comprobación de sintaxis que se va realizando, si se escribe alguna sentencia errónea, Visual J++ lo indicará subrayándola en rojo.

Ahora vamos a pasar a ejecutar nuestra sencilla aplicación. Para ello debemos pulsar el botón de play en el entorno de desarrollo. Si lo ejecutamos de esta forma prácticamente no nos da tiempo a ver el resultado. También podemos ejecutar nuestra aplicación invocando directamente al intérprete de Java desde la línea de comandos de MS-DOS.

El intérprete de Java que ofrece Visual J++ se denomina Jview (es el equivalente al comando java del JDK), y para utilizarlo desde la línea de comandos utilizaremos la sintaxis:

jview NombreClase

De esta forma se ejecuta una clase determinada. Si ahora nos desplazamos dónde se ha generado el fichero .class de nuestra aplicación y escribiremos jview Class1, se ejecutará nuestra clase y veremos el resultado (Figura 13). Si se intenta ejecutar una clase de una aplicación Java que no posee un método main() se producirá un error y no se ejecutará.

Si queremos lanzar nuestra aplicación a través del intérprete Jview, antes deberemos compilarla para que se generen los ficheros .class correspondientes, que son los que contendrán los bytecodes.

Figura 13


117

Para compilar una clase seleccionamos la opción de menú Generar|Generar NombreProyecto. Podemos seleccionar generar todas las clases de un proyecto o bien todas las clases de todos los proyectos incluidos en la solución de Visual J++.

A la hora de generar los ficheros .class se nos informa de los errores que se hayan encontrado en nuestro código, si se producen errores, no se generarán los ficheros .class de las clases que los contengan.

Los errores detectados durante el proceso de generación (compilación) de la clase aparecerán en la lista de tareas, junto con su descripción. Si pulsamos sobre un error, el cursor se desplazará a la línea del editor de código en la que se encuentra dicho error.

Vamos a comentar que es lo que sucede en nuestro ejemplo cuando ejecutamos nuestra clase, ya sea desde el entorno de Visual J++ o desde la línea de comandos con Jview. En ambos casos se invoca al intérprete jview, aunque en el primer caso quede oculto porque la llamada la realiza el entorno Visual J++ por nosotros. Al intérprete se le debe facilitar el nombre de la clase principal de la aplicación, en este caso sólo tenemos la clase Class1. Una vez indicada la clase a ejecutar el intérprete comienza su trabajo y va ejecutando nuestro código línea a línea, comenzado por el método main().

En nuestro ejemplo sólo se ejecuta el método main(), ya que en realidad nuestra clase no hace nada, no posee ningún atributo ni ningún método más que el método main(), lo normal es que, como veremos en el siguiente apartado el método main() se encargue de crear una instancia de la propia clase y llame a algunos métodos de la misma para realizar alguna función.

A lo largo del presente capítulo y de los siguientes iremos descubriendo y comentando las diferentes características y ayudas que nos ofrece el entorno de desarrollo Visual J++ 6.

Introducción a JBuilder 3.5 En este apartado vamos a comentar la herramienta de desarrollo en Java Boland JBuilder 3.5. Realizaremos la misma acción que en el apartado anterior, es decir, construir la sencilla aplicación Hola Mundo.

Avisamos desde aquí que la herramienta JBuilder 3.5 tiene unos requerimientos bastantes altos en lo que a hardware se refiere. Es necesario como mínimo un procesador Pentium II y 128 MB de RAM, y su versión para Windows es necesario Windows NT 4.0 Server o superior.

Al igual que ocurría con Visual J++, JBuilder utiliza los proyectos para organizar y contener ficheros fuente de Java. Vamos a crear el proyecto que va a contener nuestra sencilla aplicación de ejemplo, para ellos seleccionamos la opción Archivo|Nuevo proyecto, y en ese momento se iniciará el asistente de proyectos.

JBuilder incluye un asistente para proyectos que simplifica la creación de los mismos. Este asistente configura automáticamente el marco de trabajo del proyecto y permite la introducción de datos como pueden ser la ubicación del proyecto en disco, el autor y una descripción del mismo.

En el primer paso del asistente de proyectos indicamos el nombre del proyecto y la localización del mismo. También podemos indicar si queremos que se genere una página HTML que va a contener las notas relativas al proyecto. Este primer paso se puede ver en la Figura 14.


118

Figura 14

Si pulsamos siguiente aparecerá un formulario como el de la Figura 15, en el que podremos indicar el título y autor del proyecto, a que empresa pertenece y también una descripción del mismo.

Figura 15

Si pulsamos Finalizar habremos terminado con este asistente y podremos comprobar que JBuilder ha creado un fichero HTML con el mismo nombre del proyecto. Si damos doble click sobre él veremos una página HTML con los datos indicados en el asistente del proyecto. Esta página la podemos editar desde la vista Fuente y modificar y añadir la información que queramos, esta página HTML sirve como documentación para el proyecto.

Cuando nos situamos en la vista Fuente, podemos ver el código HTML y en el panel inferior de la derecha, denominado panel de estructura, podemos ver la estructura del documento HTML.

Ahora debemos añadir la clase que nos muestre el mensaje Hola Mundo por la pantalla, al igual que hacíamos en el apartado anterior.

Para añadir una clase al proyecto seleccionamos la opción de menú Archivo|Clase nueva y en ese momento se iniciará la ejecución del asistente de clases.


119

Figura 16

Este asistente nos permite indicar una serie de características que va a tener nuestra nueva clase. Los datos que podemos indicar al asistente, que aparece en la Figura 17, se dividen en dos grupos, información de la clase y opciones de la misma.

Figura 17

En la información de la clase encontramos lo siguiente:

• El paquete al que pertenece nuestra clase.

• El nombre de la clase, que si es pública deberá coincidir con el nombre del fichero fuente de Java.

• La clase base, es decir, la clase de la que heredamos. En la lista desplegable aparecen tres clases: la clase Object, que es la clase raíz de todas las clases de Java, la clase Component que


120

es la raíz de los componentes AWT y la clase JComponent que es la raíz de los componentes Swing. Los componentes AWT y Swing los trataremos en próximos capítulos cuando abordemos la construcción de interfaces de usuario en Java.

Y en opciones podemos indicar lo siguiente:

• Pública: nuestra clase si es pública se podrá instanciar y utilizar desde cualquier otra clase.

• Generar función Main: se generará el método main() que es el método de arranque de la clase y lo veremos con el detenimiento que se merece en el siguiente apartado.

• Generar constructor por defecto: nos genera el constructor por defecto de nuestra clase.

• Modificar métodos abstractos: con esta opción se generarán implementaciones vacías de los métodos abstractos de la clase padre de la que se hereda.

En nuestro caso vamos a indicar que la clase es pública, que hereda de la clase Object, es decir, de la que heredan todas las clases de Java directa o indirectamente, también seleccionaremos que se genere la función Main. Nuestra clase se va a llamar HolaMundo y no forma parte de ningún paquete. Al pulsar Aceptar el asistente ha creado el fichero fuente de Java correspondiente (HolaMundo.java) y ha generado el Código fuente 70.

/*** Título: Ejemplo sencillo con JBulider<p>* Descripción: Proyecto que muestra el mensaje Hola Mundo<p>* Copyright: Copyright (c) Angel Esteban<p>* Empresa: Grupo EIDOS<p>* @author Angel Esteban* @version 1.0*/public class HolaMundo {

public static void main(String[] args) {}

}

Código fuente 70

Ahora vamos a añadir la sentencia en el método main() que va a mostrar el mensaje por pantalla, como se puede observar JBuilder ofrece una ayuda similar al Intellisense de Visual J++, en este caso se denomina CodeInsight.

System.out.print("Hola Mundo");

Código fuente 71

Ahora debemos compilar nuestra clase para generar el fichero .class correspondiente, para ello acudimos a la opción de menú Proyecto|Ejecutar Make de "HolaMundo.java", al seleccionar esta opción se compilará nuestra clase HolaMundo, sólo nos falta ejecutar nuestra aplicación d ejemplo, para ello pulsaremos en la barra de herramientas el botón verde en forma de "play", en ese momento aparece una pantalla (Figura 18) que nos pregunta las propiedades de ejecución del proyecto.


121

Figura 18

En esta pantalla debemos indicar la clase principal del proyecto, es decir, la clase que se va a ejecutar, para ello pulsaremos el botón Asignar y seleccionaremos la clase HolaMundo y pulsamos Aceptar.

El resultado de la ejecución de la aplicación lo veremos en el panel inferior, este panel es denominado panel de mensajes y se puede observar en la Figura 19.

Figura 19

Si observamos el directorio en el que se encuentra el proyecto vemos los ficheros que se han generado durante nuestro proceso de creación de la aplicación. Por un lado tenemos un fichero .jpr que es el fichero de proyecto y que contiene todas las referencias del proyecto. También parece una página HTML que es la página de documentación del proyecto, que ya hemos comentado con anterioridad.

Además de estos ficheros aparecen dos directorios, el directorio classes y el directorio scr. El directorio classes contiene todos los ficheros de bytecode, es decir, los ficheros de clases .class y el directorio src contiene los ficheros de código fuente, es decir, los ficheros .java.

Al igual que sucedía con Visual J++ podemos ejecutar las clases generadas por JBuilder también desde la línea de comandos. JBuilder contiene la versión 1.2 del JDK (Java Development Kit), por lo tanto para ejecutar las clases utilizaremos la herramienta java que posee el JDK 1.2. El JDK se encuentra en el directorio c:\JBuilder35\jdk1.2.2.


122

El método main() Una clase por sí sola no es nada, es decir, es un conjunto de definiciones de atributos, constantes y métodos, pero hasta que no se instancia un objeto de la clase, no tiene una existencia real. Es similar al tipo de datos entero, con el tipo de datos no podemos hacer operaciones, pero cuando creamos una variable de ese tipo ya si que podremos operar con ella.

La aplicación que construyamos finalmente tendrá una clase principal que será la que utilizaremos como parámetro cuando llamemos al intérprete de Java que interpretará y ejecutará nuestra aplicación. Ahora bien, como ya hemos comentado una clase sin instanciar en muchos casos nos sirve de bien poco, por lo tanto debe existir un mecanismo que de forma automática cuando ejecutemos una aplicación cree una instancia de su clase principal.

Todas las aplicaciones Java deben tener un método main(), este es el método de arranque de la clase, este método debe a parecer en la clase principal de la aplicación. De esta forma al iniciar la ejecución de la aplicación lo primero que se hace es iniciar la ejecución del método main() y es en este método el lugar en el que debemos crear una instancia de la clase principal de la aplicación o bien de otras clases que va a utilizar la aplicación.

Por ejemplo, si la clase principal de nuestra aplicación se llama Mensajes, esta clase debe implementar el método main(), en el que además de realizar las tareas que se estimen necesarias, se deberá crear una instancia de la clase Mensajes. También es posible realizar instancias de otras clases secundarias de la aplicación que vayamos a utilizar.

Para que quede más clara la finalidad el método main() vamos a retomar el ejemplo de los los apartados anteriores y lo vamos a rescribir para que nuestra clase defina el método saludo() y tengamos que crear una instancia de la misma para poder utilizarla. El nuevo código sería el Código fuente 72.

public class Class1{public void saludo(){

System.out.println("Hola Mundo");}public static void main (String[] args){

Class1 objClass1=new Class1();objClass1.saludo();

}}

Código fuente 72

En este caso además del método main(), nuestra clase ofrece el método saludo(). En la primera línea del método main() creamos una instancia de nuestra clase Class1, es decir, un objeto de la clase Class1. Como se puede observar aunque no definamos un constructor, lo podemos utilizar, lo que utilizamos es el constructor por defecto, que lo poseen todas las clases.

Ahora si que estamos utilizando la POO de forma más clara, creando un objeto de nuestra propia clase y lanzándole un método que hemos definido.

Vamos a fijarnos ahora en la declaración del método main(). El método main() siempre debe declararse como público, estático y que no devuelve parámetros, es decir, posee los modificadores public static void.


123

El método main() se debe declarar público para que pueda ser llamado siempre desde cualquier lugar, de esta forma es llamado por el intérprete.

Es estático porque no se lanza sobre una instancia de la clase, es decir, no hace falta crear un objeto de la clase para lanzar el método main() sobre el, de hecho, si pudiéramos ver la llamada que realiza el intérprete con el método main() para que arranque la ejecución de una clase sería algo así: Clase.main().

El método main() recibe como parámetro un array de cadenas de caracteres, llamado args normalmente (aunque se puede utilizar cualquier nombre de objeto válido), que representan los argumentos de la línea de comandos que le podemos pasar a la clase a la hora de ejecutarse.

El primer argumento, que se encuentra lógicamente en el índice cero, hace referencia primer parámetro que le siga al nombre de la clase que estamos ejecutando con el intérprete, y así sucesivamente, cada parámetro en la línea de comandos se separa con un espacio en blanco.

Para manejar los parámetros de entrada, vamos a modificar el ejemplo anterior y vamos a sobrecargar el método saludo(), es decir, vamos a seguir utilizando el mismo nombre de método pero pasándole un parámetro. Este parámetro va a ser un objeto de la clase String (cadena de caracteres) que va a ser el nombre de la persona a la que queremos saludar.

El nombre lo pasamos a través de la línea de comandos como un argumento, que lo recuperaremos en nuestra clase a través del primer elemento del parámetro args del método main().

El código resultante es el Código fuente 73.


System.out.println("Hola Mundo");}

public void saludo(String nombre){System.out.println("Hola "+nombre+" que tal...");

}

public static void main (String[] args){Class1 objClass1=new Class1();objClass1.saludo(args[0]);

}}

Código fuente 73

Y a continuación, en la Figura 20, se ven tres ejemplos de ejecución de nuestra aplicación, uno de ellos nos da un error, ya que no le hemos indicado el parámetro del nombre y nuestro método está intentando acceder a él sin que exista, nos da una excepción de array fuera de índices. Visual J++ nos dará entonces la oportunidad de depurar nuestra clase, cosa que de momento no vamos a hacer.

Para evitar el error anterior, podemos verificar en nuestra clase que la longitud del array de cadenas args es mayor que cero. Si es mayor que cero, utilizamos saludo() con el nombre recuperándolo del argumento número cero, y en caso contrario utilizamos saludo() sin parámetros.

El código sería algo como lo que muestra el Código fuente 74.


124

Figura 20


System.out.println("Hola Mundo");}public void saludo(String nombre){

System.out.println("Hola "+nombre+" que tal...");}public static void main (String[] args){

Class1 objClass1=new Class1();if(args.length!=0)

objClass1.saludo(args[0]);else

objClass1.saludo();}

}

Código fuente 74

O también tenemos la posibilidad de atrapar la excepción ArrayIndexOutOfBoundsException, es decir, la excepción que se produce al intentar acceder al índice de un elemento que no existe dentro de un array.

En el bloque try intentaríamos llamar a saludo() con el parámetro nombre, y en el catch, que se ejecuta si se produce la excepción, llamamos a saludo() sin parámetros. Este nuevo código se observa en el Código fuente 75.


System.out.println("Hola Mundo");}public void saludo(String nombre){

System.out.println("Hola "+nombre+" que tal...");}public static void main (String[] args){

Class1 objClass1=new Class1();try{

objClass1.saludo(args[0]);}catch(ArrayIndexOutOfBoundsException ex){


125

objClass1.saludo();}

}}

Código fuente 75

Las aplicaciones Java son más flexibles que el otro tipo de programas Java, es decir, los applets, ya que no ofrecen restricciones de seguridad, como veremos en el capítulo correspondiente, y además permiten acceder al sistema en el que se están ejecutando manteniendo la portabilidad gracias a la clase System, que es la que vamos a comentar en el apartado siguiente.

La clase System A la clase System sólo podemos acceder si el programa Java que estamos realizando es una aplicación, los applets Java no pueden acceder a esta clase.

La clases System nos permite acceder a una serie de información y de recursos pertenecientes al sistema sobre el cual se está ejecutando nuestra aplicación. Se pueden realizar llamadas directas al sistema, aunque estas se desaconsejan, ya que entonces perderíamos la característica de independencia de la plataforma del lenguaje Java.

Para conservar la independencia de la plataforma se ofrece la clase System, es como un intermediario entre el sistema operativo sobre el que se está ejecutando nuestra aplicación, y la propia aplicación Java.

La clase System ya la hemos utilizado en algunos ejemplos de nuestro curso, sobre todo para mostrar información en la pantalla, a través de su atributo out. Pero para utilizar la clase System no hemos tenido que instanciar ningún objeto de la clase, esto es así debido a que sus atributos y métodos son estáticos, es decir, los podemos utilizar sin tener que instanciar un objeto de la clase.

Posiblemente unos de los elementos más utilizados de la clase System dentro de las aplicaciones Java sean los canales de entrada/salida estándar. La clase System ofrece tres canales de entrada/salida estándar a través de tres atributos estáticos, que son los siguientes:

• System.in: representa el canal de entrada estándar, normalmente se utiliza para leer la entrada del usuario realizada desde el teclado.

• System.err: representa el canal de error estándar. Si se produce un error se muestra el mensaje en este canal. Este canal suele ser la pantalla. Si retomamos la última versión del ejemplo del apartado anterior, podremos utilizar el atributo err de la clase System para información de la excepción que se ha producido en el bloque try. Para ello podemos añadir al principio del bloque catch el Código fuente 76.

System.err.println("Se ha producido la excepción: "+ex);

Código fuente 76

• System.out: representa el canal de salida estándar, ya lo hemos utilizado en ejemplos

anteriores y suele ser la pantalla.


126

A través de la clase System tenemos acceso a un conjunto de propiedades del sistema, que están definidas como pares nombre/valor. Cuando se inicia el entorno de ejecución de una aplicación las propiedades del sistema se inicializan, para reflejar los valores actuales de todas ellas.

Las propiedades que se ofrecen por defecto son las que se muestran en la Tabla 20.

Propiedad Explicación

"file.separator" Separador de ficheros

"java.class.path" Ruta de clases

"java.class.version" Versión de las clases de Java

"java.home" Directorio de instalación de Java

"java.vendor" Vendedor de Java

"java.vendor.url" URL del vendedor

"java.version" Versión de Java

"line.separator" Separador de líneas

"os.arch" Arquitectura del sistema operativo

"os.name" Nombre del sistema operativo

"os.version" Versión del sistema operativo

"path.separator" Separador de rutas

"user.dir" Directorio de trabajo actual del usuario

"user.home" Directorio de trabajo del usuario

"user.name" Nombre de la cuenta del usuario

Tabla 20

Las aplicaciones Java tienen acceso a todas ellas, pueden leer o escribir en ellas, mientras que el acceso de los applets Java es mucho más limitado como veremos en el capítulo dedicado a los mismos.

Para leer las propiedades del sistema se dispone de dos métodos de la clase System, getProperty() y getProperties(). Con el primer método obtenemos el valor de una propiedad determinada, indicando como parámetro el nombre de la propiedad de la cual se quiere recuperar el valor. Si la propiedad no existe se devuelve null.

El método getProperties(), no tiene parámetros, y nos devuelve todas las propiedades del sistema a través de un objeto de la clase Properties. La clase Properties que nos permite manipular las propiedades del sistema, se encuentra formando parte del paquete java.util. Para mostrar las todas las propiedades del sistema, se ha implementado un método cuyo código es el Código fuente 77.


127

public void propiedades(){System.getProperties().list(System.out);

}

Código fuente 77

El objeto que se devuelve de la clase Properties posee un método llamado list() que escribe todas las propiedades en el canal de salida que se le indique por parámetro, es este caso se ha elegido la salida estándar, es decir, la pantalla, y el resultado que he obtenido en mi equipo de pruebas es el siguiente:

-- listing properties --user.dir=C:\Work\Proyecto7line.separator=java.vendor.url=http://www.microsoft.com/path.separator=;user.home=C:\WINNT\Javajava.version=1.1java.class.path=C:\WINNT\java\trustlib\;C:\WINNT\java...java.home=C:\WINNT\Javacom.ms.applet.enable.serversockets=falsecom.ms.windir=C:\WINNTos.version=4.0com.ms.sysdir=C:\WINNT\System32java.class.version=45.3os.name=Windows NTos.arch=x86awt.toolkit=com.ms.awt.Wtoolkituser.language=esuser.timezone=ECTuser.name=aestebanawt.appletWarning=Advertencia: ventana de subprogramauser.region=ESbrowser=ActiveX Scripting Hostjava.vendor=Microsoft Corp.file.encoding.pkg=sun.iofile.separator=\file.encoding=Cp1252http.agent=Mozilla/4.0 (compatible; MSIE 4.01; W...

Como se puede comprobar hay muchas propiedades que no aparecen en la tabla anterior, esto es debido a que aquí se muestran propiedades específicas de la plataforma Windows, que es la plataforma sobre la que he realizado los ejemplos. Por lo tanto, para que la aplicación sea completamente portable, es recomendable utilizar únicamente las propiedades del sistema especificadas en la tabla.

Para crear y añadir nuestras propias propiedades del sistema utilizaremos el método setProperties() de la clase System. A este método se le debe pasar como parámetro un objeto Properties que se ha inicializado para contener las diferentes propiedades. Aunque estos cambios en las propiedades no son persistentes entre diferentes aplicaciones Java.

En el capítulo dedicado a la descripción del lenguaje Java, comentábamos que Java realizaba las tareas de liberación de memoria de forma automática a través de un hilo de ejecución paralelo denominado recolector de basura. Sin embargo a través de la clase System podemos forzar la terminación de nuestros objetos.


128

Antes de que un objeto sea tratado por el recolector de basura, el entorno de ejecución de Java le da la oportunidad al objeto de que libere él sus propios recursos a través del método finalize() del objeto. Para forzar la llamada a este método se lanza el método runFinalization() de la clase System, al lanzar este método se llamará a todos los métodos finalize() de los objetos que estén pendientes de destruirse.

El recolector de basura se ejecutará siempre que el entorno de ejecución considere necesario y le sea posible, pero si queremos forzar la ejecución del recolector de basura lanzaremos el método gc() (garbage collector) de la clase System.

La clase System ofrece una serie de métodos que se pueden utilizar para diversas tareas, uno de estos métodos es arraycopy(), este método permite copiar el contenido de un array en otro, la sintaxis de este método es:

arraycopy(arrayOrigen, indiceOrigen, arrayDestino, indiceDestino,numeroElementos)

Como se puede ver debemos especificar los dos arrays, el de destino y el de origen, y las posiciones en la que se inicia la copia en cada uno de ellos, y por último el número de elementos que se desea copiar de un array a otro.

Otro método que englobado bajo el epígrafe de funcionalidades varias que ofrece la clase System es currentTimeMillis(), que devuelve la hora y fecha actual en milisegundos desde el 1 de Enero de 1970.

El último método que vamos a comentar de la clase System es el método exit(). Al lanzar este método terminamos con la ejecución de la aplicación actual. A este método se le pasa un parámetro que será un entero indicando el estado de finalización, por convenio si se ha producido una finalización errónea se le pasa –1, en caso contrario 0.

La clase Runtime Todas las aplicaciones Java poseen una instancia de la clase Runtime que permite interactuar a la aplicación con el entorno en el que se está ejecutando. Esta clase representa el entorno de ejecución de nuestra aplicación que comprende la Máquina Virtual de Java y el sistema operativo sobre el que se está ejecutando.

De forma general esta clase ofrece dos funcionalidades, por un lado la comunicación con los componentes del entorno de ejecución, es decir, invocar funciones y obtener información, y por otro lado la interacción con capacidades dependientes del sistema operativo.

Se debe tener cuidado al utilizar la clase Runtime, ya que podemos perder la portabilidad entre diferentes sistemas. Por lo general no se suele utilizar esta clase.

Para obtener el entorno de ejecución actual se utiliza el método getRuntime() de la clase Runtime.

Vamos a ver un ejemplo que permite lanzar la ejecución de la calculadora de Windows.

Para lanzar la ejecución de un proceso externo dentro de una aplicación Java se lanza el método exec() de la clase Runtime sobre el objeto devuelto por el método getRuntime(). Al método exec() se le pasa como parámetros el nombre de la aplicación que se desea ejecutar.

El método exec() devuelve un objeto de la clase Process, que representa un proceso externo en tiempo de ejecución y a través de este objeto se puede controlar la ejecución del proceso externo. Para esperar a que el proceso termine su ejecución se lanza el método waitFor() de la clase Process, al lanzar este


129

método se parará la ejecución de la aplicación Java principal hasta que finalice su ejecución el proceso externo.

En nuestro caso no nos interesa esperar a que el proceso que lanzamos finalice, así que el código de nuestra aplicación Java que ejecuta la calculadora de Windows sería como se muestra en el Código fuente 78.

public class Class1{public void calculadora(){

try{Runtime.getRuntime().exec("calc.exe");

}catch(java.io.IOException ex){}

}public static void main (String[] args){

Class1 objClass1=new Class1();objClass1.calculadora();

}}

Código fuente 78

A la vista de este código se deben hacer algunos comentarios. Primero, el método exec() de la clase Runtime lanza una excepción de la clase IOException que debemos atrapar en un bloque try-catch o bien lanzar con la cláusula throws, en este caso se ha elegido atraparla. Segundo, la clase IOException se encuentra dentro del paquete java.io (paquete con las clases especializadas en la entrada/salida) y como no lo hemos importado debemos hacer referencia a esta clase a través de su nombre completo.

Al ejecutar esta aplicación, una vez que se ha lanzado la ejecución de la calculadora, la aplicación se sigue ejecutando y finaliza la ejecución de la misma, destruyendo todos los procesos asociados, en este caso se incluye también la calculadora, es decir, al final no podemos utilizarla.

Una solución al problema anterior es la de utilizar el método waitFor() de la clase Process, para que la aplicación Java no finalice hasta que no se cierre la calculadora. El método calculadora() quedaría como indica el Código fuente 79.

public void calculadora(){try{

Process proceso=Runtime.getRuntime().exec("calc.exe");proceso.waitFor();

}catch(InterruptedException ex){}catch(java.io.IOException ex){}

}

Código fuente 79

A la vista de este código se deben realizar una serie de comentarios. Para poder tener una referencia al proceso que representa a la calculadora debemos asignárselo a un objeto de la clase Process. Aquí no creamos ningún objeto Process, sino que recuperamos uno ya existente que es creado por el método exec() de la clase Runtime.


130

Como se puede observar en el código además de atrapar la excepción IOException se debe atrapar la excepción InterruptedException, esta nueva excepción es lanzada por el método waitFor() de la clase Process.

Algunas consideraciones sobre Visual J++ 6 En este apartado se van a comentar una serie de puntos interesantes acerca de la herramienta de desarrollo que estamos utilizando para programar en Java. Como ya hemos repetido, y no nos cansaremos de hacerlo, vamos a utilizar Visual J++ de forma que se genere código 100% Java, sin ningún añadido de Microsoft, es decir, nuestro código fuente compilará de la misma forma en Visual J++ que en la herramienta de Sun JDK (Java Development Kit).

Antes de nada vamos a comentar los elementos más importantes que podemos observar en el entorno de desarrollo de Visual J++.

En la parte derecha de la pantalla parece el Explorador de proyectos. Desde esta ventana podemos ver la estructura de nuestra solución, es decir, cuantos proyectos contiene y que ficheros contiene cada uno de los proyectos de la solución. En esta ventana podemos crear carpetas, borrar ficheros, cambiar el nombre a los proyectos, cortar, pegar, etc., todo al estilo del explorador de Windows.

Debajo de la ventana de proyectos aparece la ventana de Propiedades, que en ningún momento vamos a utilizar, ya que se encarga de mostrar las propiedades de los componentes WFC (Windows Foundation Classes). Así que esta ventana la podemos cerrar.

Al lado izquierdo nos encontramos con otra ventana que posee tres pestañas, la más interesante y la que vamos a poder utilizar es la pestaña de Esquema de clases. En esta ventana se muestra de forma gráfica toda la jerarquía y la estructura de la clase seleccionada en el Explorador de proyectos.

La estructura de la clase seleccionada se muestra como un árbol con distintos nodos (Figura 21). En un primer nivel se muestra un nodo con el nombre de la clase, otro nodo con el nombre del paquete en el que nos encontramos y otro llamado Importaciones, que contiene todos los paquetes que importa nuestra clase.

Si abrimos el nodo que posee el nombre de la clase, parecerá toda la información sobre la estructura de la clase: las clases de las que hereda, directa o indirectamente, los atributos y métodos que se heredan, y los atributos y métodos propios.

Cada elemento que aparece en el Esquema de clases tiene un icono para distinguir el tipo de acceso (público, privado, paquete) y el tipo de elemento. En la Figura 21 aparece un ejemplo de clase en la que se muestra su esquema.

El Esquema de clases es una utilidad muy potente, ya que nos permite ver de una simple pasada toda la estructura de la clase seleccionada, además la representación gráfica elegida ayuda mucho a la hora de identificar cada elemento.

Otra utilidad que se ofrece dentro de Visual J++ y que permite ver la estructura de las clases es el Examinador de objetos. Para acceder a la ventana del Examinador de objetos seleccionaremos la opción de menú: Ver|Otras ventanas|Examinador de objetos. El aspecto de esta ventana se puede ver en la Figura 22.


131

Figura 21

Desde el Examinador de objetos se ofrece toda la estructura de las clases de Java, desde la vista de paquete hasta la primera clase en la jerarquía de herencia. También nos ofrece las clases propias de Microsoft y extensiones de Sun, es nuestro caso sólo nos van a interesar las clases que se encuentren dentro de los paquetes que comiencen por java. Dejamos al lector que investigue esta útil herramienta, ya que nos proporciona una visión general de la estructura de clases de Java.

En la zona central del entorno de desarrollo nos encontramos la ventana de código, que como su nombre indica es dónde escribimos el código fuente de nuestras clases. El editor de código nos ofrece muchas facilidades que ya hemos comentado: intellisense, verificación de sintaxis, resaltar palabras reservadas, etc.

Debajo del editor de código encontramos la ventana Lista de tareas, que ya hemos comentado anteriormente y que utilizaremos para mostrar las tareas pendientes y desde ella también se nos indicarán los errores de compilación de nuestra clase.

A modo de resumen de lo visto hasta ahora de Visual J++, en la Figura 23 se muestra el entorno de forma general y las diferentes partes del mismo.


132

Figura 22

Figura 23

El entorno que nos ofrece Visual J++ es bastante amigable si lo comparamos con el ofrecido por el JDK de Sun. Una de las bonanzas que ofrece la herramienta de Microsoft es el entorno de depuración, que es precisamente la característica de la que nos vamos a ocupar ahora mismo.

Dentro de la barra de herramientas estándar existe un menú llamado Depuración, que tiene una gran cantidad de opciones: paso a paso por instrucciones, paso a paso por procedimientos, establecimiento de puntos de ruptura, ejecutar hasta el cursor, etc., es decir, todo deseable para un entorno de depuración completo.


133

Se ofrece también la posibilidad de Agregar inspección, esta opción la vamos a utilizar para ir visualizando en la ventana de inspección los valores de la expresión que indiquemos. Por ejemplo si deseamos utilizar esta opción en la clase que veíamos en un apartado anterior, que consistía en mostrar un saludo por la pantalla, saludando al nombre que nos pasaban por parámetro, debemos situar un punto de interrupción al comienzo del método main() y pulsando con el botón derecho sobre la ventana de código fuente seleccionamos la opción del menú contextual llamada Agregar inspección.

En este caso vamos a agregar a la inspección la expresión args[0], al seleccionar agregar inspección aparece la ventana de inspección para poder escribir la expresión. Si ejecutamos nuestra clase desde Visual J++, se detendrá la ejecución de nuestra aplicación en el punto de interrupción y podremos consultar en la ventana Inspección el valor de nuestra expresión que en este caso es, como aparece en la Figura 24, Error:array access out of range, ya que no nos han pasado el argumento. Para detener la depuración pulsaremos el botón de Stop de la barra de herramientas.

Figura 24

Si deseamos repetir la depuración pero esta vez pasando un argumento a nuestra aplicación lo haremos de la siguiente forma: accedemos a la opción de menú Proyecto|Propiedades de proyecto, y podremos observar las hojas de propiedades que parecen en la Figura 25.

En nuestro caso vamos a seleccionar la opción Personalizar y vamos a añadir al final de los argumentos que utiliza Visual J++ para lanzar nuestra aplicación, el nombre al que queremos saludar, es decir, la caja de texto argumentos quedaría así /p /cp:p "<JAVAPACKAGES>" Class1 Pepe. Si volvemos a ejecutar nuestra aplicación la ventana de inspección mostrará el valor "Pepe".

Figura 25


134

Si al depurar nuestra aplicación Java se produce algún error, la herramienta Visual J++ entrará en modo de interrupción. Aparecerá una flecha verde que nos indicará dónde se ha producido el error, y tendremos acceso a tres ventanas, dos de ellas llamadas Automático y Locales, nos permiten consultar los valores de los atributos de los diferentes objetos de la aplicación. Y una tercera ventana llamada Inmediato nos permite ejecutar expresiones válidas. Para abandonar el modo de interrupción pulsaremos el botón de Play o el de Stop, según creamos conveniente. En la Figura 26 se puede observar el aspecto de la ventana Locales. Y en la Figura 27 se puede observar el aspecto de la ventana Inmediato en la que se ha consultado algunos atributos de la clase actual, en este caso el título y anchura de la ventana, y también si el tamaño de la ventana es modificable.

Figura 26

Figura 27

Como vemos la herramienta Visual J++ es bastante amigable y fácil de utilizar, pero ofrece un par de deficiencias bastante importantes.

La primera de ellas y la más grave es que soporta únicamente la versión 1.1 del lenguaje Java, es decir, es compatible con el JDK 1.1 pero no con el JDK 1.3, por lo tanto se puede considerar que es una herramienta un poco desfasada y además no contempla la posibilidad de utilizar nuevas versiones del JDK, característica que si presenta la herramienta de desarrollo JBuilder 3.5. De esta forma, podemos utilizar Visual J++ 6 si no vamos a utilizar las características ofrecidas por la plataforma Java 2.

La segunda deficiencia es que no ofrece una herramienta que permita construir un interfaz de usuario gráfico (GUI Graphical User Interface) de forma sencilla al estilo de Visual Basic o Delphi, es decir, arrastrando y soltando componentes.


135

Consideraciones sobre JBuilder Este apartado tiene la misma función que el anterior, pero aplicado a JBuilder, es decir, vamos a realizar un comentario de las características más interesantes de la herramienta así como una descripción general del entorno.

Este entorno es más complejo que Visual J++ ya que ofrece un mayor número de funciones.

El entorno de desarrollo JBuilder proporciona una visión única en la que se permite realizar la gestión de ficheros y proyectos, diseño visual y compilación y depuración de aplicaciones.

El entorno de JBuilder consta de una ventana general que contiene varios paneles que permiten realizar todas estas funciones, esta ventana recibe el nombre de visualizador de aplicaciones, en la Figura 28 se puede observar cada uno de los paneles y elementos de del visualizador de aplicaciones.

Figura 28

Vamos a comentar brevemente cada uno de los elementos señalados en la Figura 28.

• Panel de proyectos: muestra el contenido del proyecto seleccionado en la lista desplegable de proyectos.

• Panel de estructura: contiene iconos, opciones de clasificación y mensajes de error. El panel de estructura muestra la estructura del archivo seleccionado en el panel de contenido. Para un archivo Java esta estructura aparece en forma de un árbol que muestra todos los métodos y atributos definidos en el archivo de código fuente. A través de este panel podemos ver las clases padre de forma muy sencilla. En el caso de ser el fichero una página HTML vemos la estructura del documento HTML en el que se muestran las etiquetas.

• Panel de contenido: en este panel se muestran los ficheros abiertos, cada fichero abierto dispone de una pestaña en la parte superior que muestra el nombre del fichero, así como pestañas en la parte inferior para las distintas vistas disponibles.


136

• Panel de mensajes: en este panel se muestran los mensajes de los subsistemas, tales como diseñadores, resultados de búsquedas, procesos de compilación, depuración o ejecución.

• Barra de estado: ofrece información actualizada de cualquier proceso y sus resultados. Existen dos barras de estado, la principal y la de archivo. La principal se muestra en la parte inferior de la ventana del visualizador de aplicaciones, y la de archivo aparece en la parte inferior de cada fichero abierto en la ventana de código fuente del panel de contenido y muestra información específica del fichero actual.

JBuilder presenta un gran número de asistentes. Si seleccionamos la opción de menú Archivo|Nuevo, aparece la galería de objetos, cada uno de estos objetos tiene su asistente correspondiente, el asistente de creación de nuevas clases y de nuevos proyectos ya los vimos en el anterior apartado dedicado a JBuilder. En la Figura 29 se puede observar la galería de objetos.

Figura 29

Si seleccionamos por ejemplo el objeto Aplicación, se lanzará el asistente para aplicaciones. Este asistente nos va a ayudar a construir una aplicación que muestra una ventana.

En la primera pantalla de este asistente indicamos el paquete al que pertenece la aplicación y el nombre de la clase que va a representar la aplicación (Figura 30). También podemos indicar que se generen comentarios de forma automática.

Si pulsamos el botón Siguiente podemos especificar una serie de opciones (Figura 31) que se aplican a una clase denominada clase de marco. Esta clase va a heredar de la clase JFrame (componente Swing que representa una ventana), ya que se va a tratar de una aplicación representada por una ventana.


137

Figura 30

Figura 31

Las opciones que se aplican a la clase de marco, estas opciones son: la posibilidad de añadir una barra de herramientas, una barra de menú y una barra de estado. También se permite generar la típica ventana Acerca de y centrar la ventana en la pantalla.

También podemos indicar el nombre de la clase y el título que va aparecer en la ventana.

Si pulsamos el botón Finalizar comprobaremos que el asistente ha añadido tres nuevas clases a nuestro proyecto. La clase principal que va a representar a la aplicación, una clase que hereda de la clase JFrame que se corresponde con la ventana principal de la aplicación y otra clase más que hereda dela clase JDialog (un componente Swing que representa una ventana de diálogo) y que se corresponde con el diálogo Acerca de.

En el panel de proyectos también se puede observar que se han añadido varias imágenes (fichero .gif) que se corresponden con las utilizadas para la barra de herramientas de nuestra aplicación.

Ahora si pulsamos el botón de ejecución se compilarán todas las clases y podremos ver nuestra aplicación que presentará un aspecto similar al de la Figura 32.


138

Figura 32

Para cada proyecto contenido en JBuilder podemos definir una serie de propiedades a través de la opción Proyecto|Propiedades de proyecto. Las propiedades del proyecto controlan y definen los siguientes aspectos: vías de acceso, ejecución, depuración, compilación, generación y estilo de código. Vamos a comentar cada unas de las pestañas que nos permiten configurar el proyecto.

• Vías de acceso: podemos indicar las rutas a los ficheros fuente que se utilizan y a las los ficheros de clase que se generan, también a la documentación y a las rutas de las clases adicionales que son necesarias para el proyecto y que no pertenecen a las estándar de la plataforma Java 2, como pueden ser clases de terceras partes o clases desarrolladas por nosotros mismos. En esta pestaña podemos indicar la versión del JDK de Sun que vamos a utilizar, siendo esta característica muy interesante ya que permite actualizar JBuilder con futuras versiones del lenguaje de Sun. El aspecto de esta pantalla se puede ver en la Figura 33.

Figura 33


139

• Ejecutar: permite especificar el entorno de ejecución del proyecto actual. Esta pantalla a su

vez contiene varias pestañas que permiten configurar las aplicaciones, applets y páginas JSP (Java Server Pages). Para la aplicación podemos indicar que parámetros queremos utilizar, estos parámetros los recogeremos a través del parámetro args[] del método main() (como ya hemos visto anteriormente), también se pueden indicar los parámetros que necesitemos pasar al intérprete de Java o Máquina Virtual (MV). Y para los applets podemos definir también los parámetros correspondientes. La forma en que utilizan los parámetros los applets lo veremos con detenimiento en el capítulo correspondiente. Y la opción de configuración de las páginas JSP (similares a las páginas ASP de Microsoft pero implementadas en Java) se sale del contenido de este curso, simplemente comentaremos que permite configurar los parámetros del servidor que va a alojar las páginas JSP. De forma general podemos indicar si queremos compilar el proyecto antes de ejecutarlo o compilarlo antes de depurarlo.

Figura 34

• Depurar (Figura 35): en esta pestaña podemos definir una serie de parámetros que se tendrán

en cuenta a la hora de depurar el proyecto. Para ejecutar un proyecto en modo de depuración pulsaremos el botón de la barra de herramientas que se encuentra al lado del play de ejecución. Para introducir un punto de interrupción en nuestro código fuente simplemente pulsamos con el botón derecho del ratón sobre la línea correspondiente y seleccionamos la opción Conmutar punto de interrupción. Una vez establecido el punto de interrupción podemos configurar sus propiedades e indicar si queremos detener la ejecución de la aplicación o no. Al iniciar la depuración de un proyecto determinado, el depurador aparecerá en el panel inferior, el que se había denominado panel de mensajes.

• Compilador(Figura 36): en este apartado se configuran las opciones por defecto del compilador, como puede ser mostrar advertencias, excluir una clase determinada, mostrar métodos que ya se han desaconsejado, etc. Como opciones generales podemos indicar si queremos guardar en disco los ficheros antes de compilar.


140

Figura 35

Figura 36

• Generar (Figura 37): permite configurar el compilador IDL utilizado para generar los

esqueletos de las clases necesarias para CORBA. Este es un tema avanzado de Java que no vamos a tratar en nuestro curso.


141

Figura 37

• Estilo de código (Figura 38): en esta opción podemos indicar a JBuilder como queremos que

genere el código automático. Podemos indicarle la forma de utilizar las llaves de bloques de instrucciones, como crear las clases adaptadoras para los eventos (los eventos y las clases adaptadoras los trataremos en el tema de interfaces de usuario dedicado a los eventos) y la visibilidad de los atributos de las clases que crea.

Figura 38


142

Una de las ventajas más interesantes que tiene JBuilder es que ofrece la posibilidad de crear los interfaces de usuario en modo de diseño arrastrando y soltando los componentes. En este aspecto JBuilder demuestra ser una herramienta mucho más potente que Visual J++ o el JDK. Vamos a comentar brevemente el diseñador que nos ofrece esta herramienta.

Con la ayuda de las herramientas de diseño visual de JBuilder podemos crear de forma rápida y sencilla el interfaz de usuario de una aplicación o de un applet de Java. Para construir el interfaz de usuario utilizaremos distintos componentes que seleccionaremos de la paleta de componentes, una vez seleccionado el elemento deseado podemos definir los valores sus propiedades y también el código necesario para los eventos.

En la Figura 39 se muestra un esquema de la vista de diseño dentro del entorno de JBuilder.

Figura 39

• Diseñador: es la superficie de diseño utilizada para colocar y modificar los paneles y otros

componentes del interfaz de usuario como pueden ser botones, etiquetas, listas, cajas de texto, áreas de texto, etc., para acceder al diseñador únicamente se debe seleccionar la pestaña Diseño de la parte inferior del panel de contenido. Este diseñador se puede utilizar para clases que hereden de la clase Continer, como puede ser JFrame, JPanel, JDialog o JApplet (las clases utilizadas en la construcción de interfaces de usuario las veremos con detenimiento en los capítulos dedicados al tema). JBuilder mantiene la sincronización entre el diseño visual y el código fuente de Java, al cambiar el diseño en diseñador de interfaces se actualiza automáticamente el código fuente, y viceversa al cambiar el código fuente el cambio se refleja en el diseñador de interfaces.

• Paleta de componentes: está situada encima del diseñador de interfaces y contiene componentes visuales y no visuales, estos componentes varían según la edición de JBuilder, en este caso se trata de la versión empresarial (Enterprise).

• Árbol de componentes: se localiza en el panel de estructura y ofrece una vista estructurada de todos los componentes que contiene el fichero fuente y de las relaciones que existen entre ellos.

• Inspector: esta ventana se utiliza para inspeccionar y definir los valores de las propiedades (atributos) de los componentes y los métodos para el tratamiento de eventos. Los cambios


143

realizados en el inspector se reflejan en el diseño. Para ver el inspector de un componente basta con seleccionar el componente deseado.

Para ver el diseñador de interfaces de JBuilder en acción simplemente podemos crear una nueva aplicación con el asistente que ya habíamos visto anteriormente, ya que la clase generada hereda de la clase JFrame, que es un contenedor.

Además de todas estas facilidades comentadas para la creación de interfaces, JBuilder ofrece un diseñador de menús. Para utilizar el diseñador de menús tenemos que acceder a la vista de diseño (la aplicación creada por el asistente puede servir) y añadir un componente menú (JMenuBar) desde la paleta de componentes. El menú no se verá en el diseñador, pero haciendo doble clic sobre el componente de menú en el árbol de componentes, aparecerá el diseñador de menús, como se puede observar en la Figura 40.

Figura 40

El diseñador de menús es muy fácil de utilizar y muy intuitivo, podemos ir añadiendo elementos de menú de manera sencilla.

De momento no vamos a añadir más comentarios ni explicaciones sobre JBuilder, a lo largo del curso la volveremos a retomar al igual que haremos con Visual J++ y el JDK, para terminar este capítulo se deben destacar los aspectos positivos y negativos de JBuilder.

Los dos aspectos o características más positivas de JBuilder es la posibilidad de diseñar interfaces de usuario de forma visual y que implementa la última versión del lenguaje Java, permitiendo la posibilidad de actualizar la versión del lenguaje de forma rápida y sencilla.

Y el aspecto más negativo es la excesiva memoria que requiere el producto así como los requerimientos de sistema operativo (Windows NT Server o superior) y los numerosos (por lo menos en mi caso) "cuelgues" de la herramienta, así como los diversos problemas de refresco de las ventanas y de los interfaces en general de la herramienta.

Interfaces de usuario en Java: componentes AWT

Introducción A lo largo de este capítulo y los siguientes, vamos a abordar la construcción de interfaces de usuario en el lenguaje Java, se ha querido crear varios capítulos para tratar este tema debido a su relevancia.

El interfaz de usuario tiene una gran importancia ya que es lo que realmente va a ver y utilizar el usuario. Un interfaz de usuario debe ser coherente, fácil de utilizar, intuitivo, atractivo, amigable, rápido, etc., pero sobretodo lo más importante es que el usuario pueda utilizarlo correctamente y se sienta dentro de un entorno amigable.

No vamos a teorizar sobre la construcción de interfaces de usuario, sino que vamos a explicar simplemente como crear sencillos interfaces dentro del lenguaje Java. Trataremos las bases de la creación de interfaces de usuario comentando las clases más relevantes que Java pone a nuestra disposición.

Este capítulo está dedicado a la utilización de componentes AWT.

El AWT (Abstract Window Toolkit) El AWT es un conjunto de clases que Java pone a nuestra disposición para la creación de interfaces de usuario, como pueden ser botones, listas, cajas de texto, ventanas, etc. Todas estas clases se


146

encuentran en el paquete JAVA.AWT. El otro conjunto de clases que ofrece Java para la construcción de interfaces de usuario se denomina Swing y lo veremos en próximos capítulos.

El AWT está presente desde la primera versión del lenguaje Java, y todavía se sigue utilizando, tanto en la versión 2 del lenguaje como en la 1.1, debido a esto lo hemos incluido en nuestro curso. Los componentes Swing no se pueden utilizar dentro de Visual J++ pero sí con JBuilder.

Pero el AWT además de proporcionar clases que permiten la construcción de interfaces de usuario, también ofrece un subpaquete llamado java.awt.event que contiene las clases especializadas en el tratamiento de eventos, como puede ser la pulsación de un botón, la selección de un elemento de una lista, cerrar una ventana etc.

En este capítulo sólo vamos a tratar la utilización de componentes AWT, en el siguiente veremos con detenimiento el tratamiento de eventos que realiza Java, y también los gestores de diseño que nos permiten tener un mayor control sobre la posición de los distintos componentes y elementos del interfaz.

Mediante los programas Java se pueden construir interfaces de usuario muy completos, similares a los que podríamos construir con otros lenguajes de programación como Visual Basic, aunque ya avisamos, no de forma tan sencilla.

Para poder realizar interfaces que dispongan de botones, menús, etiquetas, campos de texto, listas y otros componentes se diseñó el Abstract Window Toolkit (AWT). El AWT ofrece lo siguiente:

• Un conjunto completo de accesorios de interfaz de usuario y otros componentes como ventanas, menús, botones, casillas de verificación, campos de texto, barras de desplazamiento y listas desplegables.

• Soporte para contenedores de interfaces de usuario para que tengan a otros contenedores dentro de él o accesorios como pueden ser botones, listas, cajas de texto, etc.

• Un sistema de eventos para administrar los eventos del sistema y los del usuario cuando interacciona con componentes del AWT. Lo que vamos a ver de eventos y gestores de diseño en el próximo capítulo se aplica tanto a componentes AWT como a componentes Swing.

• Mecanismos para distribuir los componentes de forma que permitan un diseño de interfaz de usuario independiente de la plataforma.

La idea fundamental que sostiene el AWT es que una ventana Java es un conjunto de componentes anidados que empiezan desde la ventana exterior hasta el más pequeño de los componentes que forman parte del interfaz. Esta anidación de componentes dentro de contenedores crea una jerarquía de componentes desde la casilla de verificación más pequeña hasta la ventana general de la pantalla.

Esta jerarquía determina la distribución de elementos en la pantalla y dentro de otros elementos además del orden en el que se muestran. Los componentes principales con los que puede trabajar el AWT son los siguientes:

• Contenedores (Container): componentes AWT genéricos que incluyen a otros componentes. La forma más común de éstos es la clase Panel, que representa a un contenedor que puede desplegarse en pantalla, y también la clase Window que representa de forma genérica las ventanas . Los applets, como veremos en el capítulo correspondiente, son un tipo de panel, de hecho, la clase Applet es una subclase o clase hija de la clase Panel.

© Grupo EIDOS 9. Interfaces de usuario en Java: componentes AWT

147

• Lienzos (Canvas): es una superficie de dibujo que permite dibujar imágenes y realizar otras operaciones gráficas.

• Componentes de interfaz de usuario: incluyen botones, listas, menús de aparición súbita, casillas de verificación, campos de texto y otros elementos comunes de un interfaz de usuario.

• Componentes de construcción de ventana: incluyen ventanas, cuadros, barras de menú y diálogos.

Como ya habíamos comentado, las clases del AWT se encuentran organizadas en el paquete JAVA.AWT, para recordar un poco el término diremos que los paquetes Java son una manera de agrupar clases e interfaces relacionadas, permiten que grupos modulares de clases estén disponibles sólo cuando se necesiten.

Volviendo al AWT, sus diferentes clases conforman una jerarquía y la raíz para la mayoría de los componentes AWT es la clase Component, que ofrece características comunes para todos los componentes. La muestra una jerarquía parcial de las clases AWT.

Uno de los principales problemas con los que nos podemos encontrar es la portabilidad del interfaz de usuario, es decir, conseguir que la misma información (ventanas, controles, imágenes y otros objetos) guarden sus proporciones en todas las plataformas en las que el sistema tiene que ejecutarse. Dicho de otro modo, que la apariencia de lo que se ve sea la misma en distintos entornos.

La solución, sin ser nada fácil, es muy similar a la que se utiliza para escribir código portable. Para hacer que las aplicaciones funcionen bajo distintas plataformas, en lugar de compilar el código fuente de las mismas al código máquina de un microprocesador concreto, se compila a un pseudo-código, y se ejecuta en una máquina virtual, es necesario escribir una máquina virtual para cada entorno, pero una vez hecho esto, todos los programas escritos para ese compilador podrán ser ejecutados en todas aquellas plataformas para las que exista máquina virtual. Del mismo modo, es necesario crear una interfaz independiente del medio para poder portar las aplicaciones sin perder el aspecto que les imprimió su creador.

Figura 41


148

Java resuelve este problema utilizando lo sus creadores han dado en llamar "Gestores de diseño" (Layout Managers), que trataremos con detenimiento en el capítulo correspondiente.

Utilizando los componentes del AWT En este apartado vamos a comentar algunos de los componentes básicos que podemos encontrar dentro del AWT. Vamos a realizar una sencilla aplicación a la que vamos a ir añadiendo diferentes componentes.

Frame Lo primero que vamos a añadir a nuestra aplicación es una ventana, una ventana se representa mediante la clase Frame.

La clase Frame es un tipo de contenedor, por lo que es un descendiente de la clase Container, y además es una ventana, por lo que hereda directamente de la clase Window.

Para que nuestra aplicación posea una ventana tenemos dos opciones, creamos un atributo que sea un objeto de la clase Frame o bien nuestra aplicación hereda de la clase Frame. Vamos a elegir la segunda opción, ahora nuestra aplicación va a heredar todo el comportamiento de la clase Frame. El código con el que vamos a empezar es el que muestra el Código fuente 80.

import java.awt.*;public class Ventana extends Frame{

public static void main (String[] args){}

}

Código fuente 80

El Código fuente 80 merece el siguiente comentario. Para utilizar las clases de creación de interfaces de usuario con los componentes del AWT debemos importar el paquete JAVA.AWT, como hacemos en este caso.

Vamos a añadir un constructor a nuestra clase para que al crear un objeto se instancie de una forma determinada, es decir, con un título y dimensiones determinadas. El constructor podría ser como indica el Código fuente 81.

public Ventana(String titulo,int x, int y){super(titulo);setSize(x,y);show();

}

Código fuente 81


149

En el constructor de nuestra clase Ventana, llamamos con super() al constructor de la clase padre, en este caso la clase Frame. El constructor de la clase Frame se encuentra sobrecargado, y en una de sus versiones acepta como parámetro el título de la ventana.

Una vez lanzado el constructor se utiliza el método setSize() de la clase Frame para establecer las dimensiones de la ventana, y por último se muestra dicha ventana con el método show() de la clase Frame.

Una vez que ya tenemos constructor, podemos utilizar nuestra clase dentro del método main() de nuestra aplicación como muestra el Código fuente 82.

public static void main (String[] args){Ventana miVentana=new Ventana("Una ventana",300,150);

}

Código fuente 82

Si ejecutamos la aplicación podremos ver un objeto de nuestra clase Ventana, más o menos debe ser como el que aparece en la Figura 42.

Figura 42

Como el lector habrá comprobado, la ventana no se puede cerrar, más tarde en el siguiente capítulo veremos como implementar este comportamiento ala hora de tratar los eventos en el lenguaje Java.

Cursor Si queremos modificar el aspecto del cursor del ratón en nuestra ventana utilizaremos el método setCursor(). Este método establece el aspecto que va a tener el cursor del ratón al moverse en el área de la ventana. Como parámetro recibe un objeto de la clase Cursor.

Esta clase representa al cursor del ratón. En el Código fuente 83 se muestra como utilizar este método, el constructor de la clase Cursor recibe como parámetro el tipo de cursor que se quiere crear. Los tipos de cursores se encuentran definidos como constantes de la clase Cursor.

miVentana.setCursor(new Cursor(Cursor.HAND_CURSOR));

Código fuente 83


150

MenuBar Para añadir una barra de menú a nuestra ventana utilizaremos el método setMenuBar() de la clase Frame. Este método recibe como parámetro un objeto de la clase MenuBar, que representa una barra de menú.

Menu Una vez creado el objeto MenuBar vamos a ir añadiéndole los menús que sean necesarios, para ello utilizaremos el método add() de la clase MenuBar. Este método recibe como parámetro objetos de la clase Menu.

MenuItem A su vez cada menú (objeto de la clase Menu) va a tener elementos de menú, que se van añadiendo con el método add() de la clase Menu. A este método se le debe pasar como parámetro objetos de la clase MenuItem, que representarán cada uno de los elementos de menú.

CheckboxMenuItem En nuestro ejemplo vamos a crear un nuevo método llamado añadeMenu(), que va a añadir a nuestra clase Ventana una barra de menú con dos menús, y uno de los elementos de menús va a ser una casilla de verificación. Este tipo de elemento de menú especial se representa mediante la clase CheckboxMenuItem.

Vamos a modificar el constructor de nuestra clase Ventana para que llame al método añadeMenu(). Finalmente el código quedaría como aparece en el Código fuente 84.

import java.awt.*;public class Ventana extends Frame{public Ventana(String titulo,int x, int y){

super(titulo);setSize(x,y);añadeMenu();show();

}public void añadeMenu(){

//barra de menúMenuBar mb;//menúsMenu m1, m2;//elementos de menúMenuItem mi1_1, mi1_2;CheckboxMenuItem mi2_1;//se crea y establece la barra de menúmb = new MenuBar();setMenuBar(mb);//se crea y añade el primer menúm1 = new Menu("Menú 1", true);mb.add(m1);//se añade los elementos de menú al primer menúmi1_1 = new MenuItem("Menú item 1_1");m1.add(mi1_1);


151

mi1_2 = new MenuItem("Menú item 1_2");m1.add(mi1_2);//se crea y añade el segundo menúm2 = new Menu("Menú 2");mb.add(m2);//se crea y añade el elemento de menú del segundo menúmi2_1 = new CheckboxMenuItem("Menú item 2_1");m2.add(mi2_1);


Ventana miVentana=new Ventana("Una ventana",300,150);}

}

Código fuente 84

Y el resultado de la ejecución de la aplicación es el que aparece en la Figura 43.

Figura 43

Todas las clases adicionales utilizadas en este ejemplo: MenuBar, Menu, MenuItem y CheckboxMenuItem pertenecen todas ellas al paquete JAVA.AWT. Estas clases presentan una jerarquía separada del resto de las clases del AWT, todas ellas heredan de MenuComponent, su jerarquía se muestra en la Figura 44.

Figura 44


152

Otro tipo de ventanas que podemos crear con el AWT son los diálogos, este tipo de ventanas se distinguen del resto en que son dependientes de otra ventana, al destruir la ventana principal se destruyen todos los diálogos que dependan de ella y cuando se minimiza la ventana principal, todos los diálogos dependientes desaparecen de la pantalla.

Dialog Los diálogos se representan mediante la clase Dialog, que ofrece además una subclase llamada FileDialog que permite al usuario abrir y guardar ficheros.

Un diálogo puede ser modal, es decir, hasta que no se cierre no se permite interactuar al usuario con la ventana de la que depende.

Vamos a añadir a nuestra aplicación un método que muestre un diálogo modal que dependa de la ventana creada anteriormente en este mismo apartado. Este método se llama muestraDialogo() y posee el Código fuente 85.

public void muestraDialogo(String titulo,int x,int y){Dialog dialogo=new Dialog(this,titulo,true);dialogo.setSize(x,y);dialogo.show();

}

Código fuente 85

Como se puede observar el método muestraDialogo() recibe tres parámetros, el título de la ventana de diálogo y las dimensiones de la misma. En la primera línea creamos un objeto de la clase Dialog, el constructor de esta clase, en una de sus versiones, recibe tres parámetros, la referencia a la ventana a la que va a estar relacionada, el título y un valor booleano que indica si el diálogo es de tipo modal o no. La ventana del que depende el diálogo es nuestra propia clase, debido a esto utilizamos la referencia this.

La llamada al método muestraDialogo() la podemos situar dentro del método main(), una vez creado un objeto de la clase Ventana. El resultado de la ejecución de la aplicación se puede observar en la Figura 45.

Figura 45

Como se puede observar, al ser un diálogo modal, no podemos acceder al objeto de la clase Ventana.


153

FileDialog Si queremos mostrar un diálogo para la elección de un fichero utilizaremos la clase FileDialog. Esta clase hereda de la clase vista anteriormente, Dialog.

Para mostrar un diálogo de este nuevo tipo se va a utilizar el método muestraDialogoFichero() cuyo código es el Código fuente 86.

public void muestraDialogoFichero(int x, int y){FileDialog dialogo=new FileDialog(this);dialogo.setSize(x,y);dialogo.show();

}

Código fuente 86

El constructor de la clase FileDialog que se ha utilizado, recibe como parámetro la referencia a la ventana a la que se encuentra asociado este diálogo, que sigue siendo una instancia de nuestra clase Ventana. El aspecto de la ejecución de nuestra aplicación es el que aparece en la Figura 46.

Figura 46

Como se puede comprobar, este tipo de diálogo va a ser siempre modal, y al pulsar cualquiera de los botones se cierra el diálogo.

Una vez comentadas algunas clases del AWT vamos a definir el concepto de contenedor de una forma un poco más extensa y relacionándolo con lo que hemos visto hasta ahora.

Container Un objeto de la clase Container (que dicho sea de paso, es abstracta) es un componente que puede contener otros componentes. Permite almacenar elementos GUI (controles, otros contenedores, etc.), y es sobre estos elementos contenidos sobre los que actúa el gestor de diseño asociado al objeto Container, para distribuirlos sobre la superficie abarcada por el Container según las indicaciones del programador.


154

Pero además, los gestores de diseño permiten que esta distribución, o mejor dicho, la apariencia de la distribución de los componentes, se mantenga similar a través de los distintos entornos gráficos en los que se va a ejecutar la aplicación Java. En el siguiente capítulo, dentro del apartado dedicado a los gestores de diseño veremos los diferentes tipos y como utilizarlos en cada caso.

De la clase Container derivan las siguientes:

• Panel: No es más que una particularización de la clase Container. Tampoco tiene representación gráfica y generalmente se utiliza para gestionar una agrupación lógica de elementos. El caso más típico es el del teclado de una calculadora.

• Window: Esta clase permite la definición de "ventanas" como áreas independientes capaces de contener otros elementos, no tienen título, ni barra de menú, ni botones de tamaño, cierre, etc. De este modo esta clase puede utilizarse para construir ventanas que se adapten a las peculiaridades de cada uno de entornos para los que se va a construir una máquina Java (JVM). De esta clase, heredan las siguientes.

• Frame: Esta es clase que utilizamos para construir lo que normalmente entendemos por ventanas o "forms" en algunos lenguajes.

• Dialog: Esta clase se utiliza para crear cajas de diálogo.

• FileDialog: Esta es un caso especial de la clase Dialog, de la cual hereda. Puesto que las tareas de manejo de ficheros (guardar, guardar como y abrir) son muy comunes en todos los entornos, esta clase proporciona cajas de diálogo para realizar estas y otras tareas relacionadas.

Button Ya hemos visto algunos contenedores y también la creación de menús, ahora vamos a añadir un botón a nuestra ventana. Los botones se encuentran representados por la clase Button. Para añadir el botón vamos a definir un atributo llamado boton dentro de nuestra clase Ventana, es decir, en la declaración de atributos escribiremos algo como lo que aparece en el Código fuente 87.

public Button boton;

Código fuente 87

El botón lo vamos a instanciar y añadir en el constructor de la clase Ventana, añadiendo para ello las el Código fuente 88.

boton=new Button("Un botón");this.add(boton);

Código fuente 88

Como se puede ver en el código, el constructor de la clase Button, en una de sus dos versiones, recibe como parámetro la etiqueta que va a mostrar el botón, pero además de instanciar el botón, se debe añadir a la ventana.


155

Se debe recordar que la clase Frame es un tipo de contenedor, y para añadir elementos a un componente contenedor se debe utilizar el método add() de la clase Container. Se utiliza la referencia this para indicar que el botón se va a añadir a nuestra ventana, aunque en realidad no es necesario, se ha puesto para una mayor claridad. El método add() en esta versión (está sobrecargado) recibe como parámetro la instancia del componente que se quiere añadir al contenedor.

Si probamos nuestra aplicación, vemos que se ha añadido el botón, pero es un botón enorme que ocupa toda la superficie de nuestra ventana. Para solucionar este problema vamos a utilizar un gestor de diseño. Los gestores de diseño (LayoutManagers) los trataremos más adelante en el siguiente capítulo, de momento simplemente vamos a añadir una línea de código para evitar el problema anterior. El nuevo código del constructor es el Código fuente 89.

public Ventana(String titulo,int x, int y){super(titulo);setSize(x,y);añadeMenu();setLayout(new FlowLayout());boton=new Button("Un botón");this.add(boton);show();

}

Código fuente 89

La nueva línea la vamos a comentar de forma somera, como ya hemos dicho más adelante explicaremos los gestores de diseño. La línea de código que hemos añadido permite establecer un tipo de gestor de diseño para evitar el efecto de la extensión del botón en toda la superficie del contenedor. El aspecto final de nuestra ventana es el de la Figura 47.

Figura 47

Un objeto botón genera un evento cada vez que lo pulsamos, generalmente lo vamos a utilizar para que el usuario con su pulsación nos indique que desea que se realice una acción determinada. Los eventos los veremos más en detalle en el próximo capítulo. Ahora si pulsamos el botón no pasará nada, el evento se lanza pero no hay nadie que lo trate.

La clase Button ofrece el método setLabel() para asignar la cadena que se le pasa como argumento a la etiqueta del botón.

Al igual que añadimos botones a nuestra aplicación podemos añadir etiquetas, cajas de texto, áreas de texto, listas, etc. Vamos a ir viendo cada uno de estos elementos.


156

Label Las etiquetas son texto estático que se suele utilizar para mostrar información y dar indicaciones al usuario. En Java las etiquetas se representan con la clase Label. En nuestro ejemplo vamos a añadir tres etiquetas, pero en lugar de añadirlas directamente a nuestra ventana las vamos a añadir a un objeto de la clase Panel, para agrupar todas ellas bajo un gestor de diseño diferente al establecido para la ventana. Para añadir las etiquetas vamos a crear un nuevo método llamado añadeEtiquetas(), cuyo código se puede ver en el Código fuente 90.

public void añadeEtiquetas(){Panel panel=new Panel();panel.setLayout(new GridLayout(0,1,1,1));Label label1=new Label();label1.setText("Etiqueta 1");Label label2=new Label("Etiqueta 2");label2.setAlignment(Label.CENTER);Label label3=new Label("Etiqueta 3");panel.add(label1);panel.add(label2);panel.add(label3);add(panel);validate();

}

Código fuente 90

En la primera línea instanciamos el objeto de la clase Panel que va a contener las etiquetas, y a continuación le asignamos un gestor de diseño. Luego se van creando las etiquetas, como se puede ver en el constructor utilizado, se le pasa como parámetro el texto que van a mostrar las diferentes etiquetas. Utilizamos el método setAligment() de la clase Label para alinear el texto de la etiqueta, utilizando como parámetro una constante definida por la clase Label, por defecto el texto de las etiquetas se encuentra alineado a la izquierda.

Después añadimos las etiquetas al objeto de clase Panel creado, ya que es un tipo de contenedor, utilizamos el método add(). Una vez añadidas las etiquetas al panel, debemos añadir el panel a nuestra ventana, al igual que hacíamos con el botón.

El método validate() que aparece al final de nuestro código es utilizado para que la ventana muestre los cambios que se han realizado sobre ella, ya que el panel que contiene las etiquetas se ha añadido después de mostrar la ventana. El método validate() pertenece a la clase Container, y su función es la de actualizar el aspecto de los contenedores. El aspecto que debe tener nuestra aplicación es el de la Figura 48.

Figura 48


157

Los métodos más relevantes de la clase Label son setText() y getText() que asignan y devuelven el texto de la etiqueta, respectivamente.

List, Choice Otro elemento del AWT son las listas y las listas desplegables, en ambos casos se trata de un conjunto de elementos que podemos seleccionar de entre varias opciones. Las listas se encuentran representadas por la clase List y las listas desplegables se encuentran representadas por la clase Choice.

Como viene siendo costumbre vamos a crear un método que añada los dos tipos de lista a nuestra aplicación, este método se denomina añadeListas(). Y lo implementamos como indica el Código fuente 91.

public void añadeListas(){List lista1=new List(3, true);Choice lista2=new Choice();lista1.add("Elemento 1");lista1.add("Elemento 2");lista1.add("Elemento 3");lista1.add("Elemento 4");lista1.add("Elemento 5");add(lista1);lista2.addItem("Elemento 1");lista2.addItem("Elemento 2");lista2.addItem("Elemento 3");lista2.addItem("Elemento 4");lista2.addItem("Elemento 5");add(lista2);validate();

}

Código fuente 91

Lo que procede a continuación es comentar el código anterior. El constructor de la clase List recibe dos parámetros en la versión del método utilizada, por un lado le indicamos el número de elementos que queremos que sean visibles, y por otro lado le indicamos si se permite la selección múltiple, es decir, si se tiene la posibilidad de seleccionar varios elementos a la vez. El constructor de la clase Choice, no está sobrecargado y no recibe ningún parámetro.

Una vez instanciado un objeto de la clase List vamos a ir añadiendo cada uno de los elementos que va a contener con el método add() de la clase List, y a continuación añadimos la lista a la ventana con el método add().

Con el objeto Choice realizamos la misma tarea. Al igual que en el ejemplo de las etiquetas, es necesario lanzar el método validate() de la clase Container. El método añadeListas() lo llamaremos, al igual que ocurría en los ejemplos anteriores, en el método main() de nuestra clase.

Para simplificar el aspecto de nuestra aplicación, vamos a eliminar de nuestro constructor la creación del botón. En la Figura 49 se puede ver el nuevo aspecto de la aplicación.

Las diferencias entre los objetos List y Choice son evidentes, el objeto List permite seleccionar varios elementos y definir el número de elementos que se desea que permanezcan visibles, sin embargo el objeto Choice, sólo permite seleccionar un objeto y tener uno sólo visible.


158

Figura 49

De los métodos que ofrece la clase List se destacan los siguientes:

• int getItemCount(): devuelve el número de elementos de una lista.

• replaceItem(String,int): reemplaza el elemento cuyo índice se especifica en el segundo parámetro por el texto indicado en el primer parámetro. El primer elemento de la lista posee el índice cero.

• removeAll(): elimina todos los elementos de la lista.

• remove(int): elimina el elemento de la lista cuyo índice coincida con el especificado.

• String getSelectedItem(): devuelve el elemento que se encuentra seleccionado.

• String[] getSelectedItems(): devuelve los elementos que se encuentran seleccionados.

• boolean isIndexSelected(int): indica si el elemento cuyo índice se pasa por parámetro se encuentra seleccionado o no.

Y de la clase Choice podemos destacar los siguientes:

• int getItemCount(): devuelve el número de elementos de una lista.

• String getItem(int): devuelve el elemento cuyo índice coincide con el se pasa por parámetro.

• select(int): selecciona el elemento cuyo índice coincide con el que se pasa por parámetro.

TextField, TextArea Ahora vamos a pasar a ver las cajas de texto y las áreas de texto. Normalmente estos dos tipos de controles se utilizan para obtener una entrada del usuario. La diferencia principal entre ambos es que las cajas de texto poseen una única línea, y las áreas de texto permiten tener más de una, reconociendo los saltos de línea, además muestra barras de scroll si el texto no es visible completamente en el área de texto.

El AWT representa las áreas de texto mediante la clase TextArea y las cajas de texto mediante la clase TextField. Estas dos clases que heredan de la clase TextComponent las vamos a ver a continuación.


159

Al igual que en el caso de las listas, al ser dos componentes muy parecidos vamos a implementar un método llamado añadeTexto() que va a añadir a nuestra ya conocida aplicación una caja de texto y un área de texto. El método añadeTexto() es como se muestra en el Código fuente 92.

public void añadeTexto(){TextField caja=new TextField("Texto",10);TextArea area=new TextArea(5,10);area.setText("Primera línea.\n");area.append("Segunda línea.\n");area.append("Tercera línea que es más larga que las anteriores.\n");add(caja);add(area);validate();

}

Código fuente 92

El constructor de la clase TextField recibe como argumentos en una de sus versiones, ya que se encuentra sobrecargado, el texto que va a parecer en la caja de texto y el tamaño de la caja de texto. El constructor utilizado para instanciar el objeto TextArea recibe como parámetros dos enteros que indican el número de filas y de columnas del área de texto.

Para asignarle texto al objeto TextArea y al objeto TextField se utiliza el método setText() pasando como parámetro un objeto de la clase String que va a representar el texto que va a contener el área o campo de texto.

La clase TextArea ofrece el método append() para ir añadiendo al final del texto existente en el área de texto el nuevo texto que se le pasa por parámetro. Se puede observar que para indicar un salto de línea utilizamos el carácter de escape especial \n. Por último añadimos la caja de texto y el área de texto a nuestra ventana y llamamos al método validate(), al igual que en los casos anteriores.

Si llamamos al método añadeTexto() de nuestra clase Ventana, se obtendrá el resultado mostrado en la Figura 50.

Figura 50

A continuación vamos a comentar los métodos más interesantes de la clase TextComponent, y que por lo tanto heredan las clases TextArea y TextField:

• String getSelectedText(): devuelve el texto que se encuentra seleccionado.

• boolean isEditable(): devuelve verdadero si es posible editar el texto.


160

• selectAll(): selecciona todo el texto.

• select(int,int): selecciona el texto comprendido entre los índices indicados como parámetros. Cero es el primer carácter.

• setCaretPosition(int): indica cual va a ser la posición del cursor (el caret) dentro del texto.

• int getCaretPosition(): devuelve la posición en la que se encuentra el cursor dentro del texto.

• setEditable(boolean): indicamos si el texto se va a poder modificar o no, dependiendo del argumento booleano que le facilitemos.

• String getText(): devuelve el texto que posea el componente.

La clase TextField añade una serie de métodos a los que hereda de la clase TextComponent, los más interesantes son:

• setEchoChar(char): establece en la caja de texto un carácter de eco, que ocultará el contenido real del texto de la caja, se suele utilizar el carácter ‘*’.

• char getEchoChar(): devuelve el carácter de eco que tiene asignada la caja de texto.

Por su parte la clase TextArea añade los siguientes métodos:

• insertText(String, int): inserta el texto especificado, en la posición indicada

• replaceText(String, int, int): reemplaza el texto comprendido entre las posiciones indicadas por el texto especificado.

Checkbox, CheckboxGroup Los siguientes componentes del AWT que vamos a tratar son las opciones o casillas de verificación. Estos componentes poseen dos estados: activado o desactivado (verdadero o falso) y se utilizan para que el usuario elija entre una serie de opciones disponibles. La clase que representa a las opciones es Checkbox.

Hay dos tipos de opciones, las que son independientes y se pueden activar y desactivar sin tener en cuenta al resto, y las que forman parte de un grupo de opciones y sólo puede estar activada una de las opciones agrupadas. Para agrupar las opciones vamos a hacer uso de la clase CheckboxGroup. Esta clase nos asegura que de todos los objetos Checkbox que contenga, sólo uno de ellos puede estar activado en un mismo momento.

Vamos a añadir seis de opciones, tres de ellas independientes y otras tres agrupadas y por lo tanto dependientes y excluyentes entre sí. Los dos conjuntos de opciones las vamos a añadir en dos objetos de la clase Panel, y a su vez añadiremos estos dos objetos a nuestra ventana.

Al igual que en todos los casos anteriores vamos a mostrar el código del método (Código fuente 93) que añade a nuestra aplicación los nuevos componentes y acto seguido comentaremos dicho código.

public void añadeOpciones(){Panel p1, p2;//casillas de verificación


161

Checkbox cb1, cb2, cb3; //opciones excluyentesCheckbox cb4, cb5, cb6;//objeto que va a contener al grupo de opcionesCheckboxGroup cbg;//Primer panel con las casillas independientes//se crean las opcionescb1 = new Checkbox();cb1.setLabel("Opción 1");cb2 = new Checkbox("Opción 2",true);cb3 = new Checkbox("Opción 3");cb3.setState(true);p1 = new Panel();p1.setLayout(new FlowLayout());p1.add(cb1);p1.add(cb2);p1.add(cb3); //Segundo panel con las opciones agrupadascbg = new CheckboxGroup();cb4 = new Checkbox("Opción 4", cbg, true);cb5 = new Checkbox("Opción 5", cbg, false);cb6 = new Checkbox("Opción 6", cbg, false);p2 = new Panel();p2.setLayout(new FlowLayout());p2.add(cb4);p2.add(cb5);p2.add(cb6);//utilizamos otro gestor de diseño para la ventanasetLayout(new GridLayout(0, 2));//se añaden los paneles add(p1);add(p2);validate();

}

Código fuente 93

En este código se han utilizado varias versiones del constructor de la clase Checkbox para instanciar los objetos correspondientes, vamos a ver cada una de ellas.

El primer constructor es el más sencillo y no posee ningún tipo de argumentos, el segundo constructor ofrece un parámetro para indicar mediante un objeto de la clase String la etiqueta que va a acompañar a la opción y otro parámetro para indicar el estado de la opción activada o desactivada (true o false), y el tercer constructor permite asignar la etiqueta de la opción correspondiente.

Para activar una opción utilizamos el método setState() de la clase Checkbox, a este método le pasamos un valor booleano para indicar si va a estar activada o no la opción. Una vez creadas las opciones y configuradas de forma correcta, creamos el panel que las va a contener instanciando un objeto de la clase Panel al que aplicaremos un gestor de diseño con el método setLayout(), y a continuación añadimos los objetos Checkbox mediante el método add() de la clase Container.

Para crear el segundo grupo de opciones y para que permanezcan agrupadas de forma excluyente es necesario instanciar un objeto de la clase CheckboxGroup. Este objeto se utilizará como parámetro en otra nueva versión del constructor de la clase Checkbox. En este nuevo constructor vamos a indicar la etiqueta que acompaña a la opción, el grupo al que pertenece y su estado. Sólo uno de estos objetos Checkbox puede crearse como activado, ya que pertenecen todos al mismo objeto CheckboxGroup.

Creamos el nuevo panel y añadimos los objetos Checkbox correspondientes, se aplica un gestor de diseño a nuestra ventana y se añaden los dos paneles que contienen las opciones. El aspecto de la aplicación es el de la Figura 51.


162

Figura 51

ScrollPane El último de los componentes que vamos a tratar del AWT es la clase ScrollPane. Esta clase hereda de Container, y por lo tanto es un tipo de contenedor, y como todo contenedor se va a utilizar para albergar otros componentes. La particularidad que ofrece este tipo de contenedor es que muestra barras de desplazamiento horizontal y vertical que nos permiten desplazar el contenido de este contenedor.

Vamos a crear un objeto de la clase ScrollPane en nuestra ventana, para que contenga a su vez un objeto de la clase Panel que contiene cuatro botones en una fila, de esta forma podremos ver las barras de desplazamiento horizontal. El código que nos permite hacer esto es el Código fuente 94.

public void añadePanelScroll(){ScrollPane panel=new ScrollPane(ScrollPane.SCROLLBARS_AS_NEEDED);Panel otroPanel=new Panel();otroPanel.setLayout(new GridLayout(1,4));otroPanel.add(new Button("botón 1"));otroPanel.add(new Button("botón 2"));otroPanel.add(new Button("botón 3"));otroPanel.add(new Button("botón 4"));panel.add(otroPanel);add(panel);validate();

}

Código fuente 94

El constructor de la clase ScrollPane recibe como argumento una constante de la clase ScrollPane que indica cuando se van a mostrar las barras de scroll o de desplazamiento, en este caso indicamos que se muestren sólo cuando sea necesario. El resto del código es bastante claro, creamos un panel que va a contener los botones y vanos añadiendo los distintos botones.

Como se puede observar, al crear los botones no los guardamos en ninguna variable, esto lo hacemos así porque no vamos a utilizarlos más, podemos crear así los componentes del AWT a los que después no es necesario hacer referencia.

Si lanzamos sobre una instancia de nuestra clase Ventana el método añadePanelScroll() tenemos el resultado de la Figura 52.


163

Figura 52

Interfaces de usuario en Java: gestores de diseño y eventos

Introducción A lo largo de este capítulo, vamos a continuar con la creación de interfaces de usuario en Java, pero en este caso no vamos a hablar de componentes como en el capítulo anterior, sino que vamos a tratar dos características del interfaz de usuario en los programas Java, los gestores de diseño y los eventos.

Lo que vamos a ver en este capítulo es aplicable tanto a componentes AWT como a componentes Swing (que los veremos en el siguiente capítulo), aunque muchas de las clases que implementan los gestores de diseño y el tratamiento de eventos se encuentran dentro del paquete JAVA.AWT y del subpaquete java.awt.events.

Los eventos y gestores de diseño específicos de los componentes Swing los veremos en los próximos capítulos en los que se abordará Swing, en éste veremos lo común a los dos tipos de componentes.

Gestores de diseño Los gestores de diseño (Layout Managers) tienen una gran importancia en el leguaje Java, para poder incorporar controles en una ventana (ya sea de una aplicación o de un applet), es necesario que estos estén contenidos en un gestor de diseño, de otro modo no funcionarán correctamente.

Comencemos por lo tanto, viendo qué es un gestor de diseño desde tres puntos de vista diferentes:


166

• Desde el punto de vista del lenguaje, como ya hemos comentado, un gestor de diseño es un "estilo de visualización", es decir, es el mecanismo que el lenguaje incorpora para conseguir crear aplicaciones que tengan la misma apariencia a través de las diferentes plataformas en las que éstas pueden ejecutarse.

• Desde el punto de vista de la jerarquía de clases de Java, un gestor de diseño es un interfaz, y deriva directamente de la clase Object, que es la que se encuentra en la raíz de la jerarquía de clases. Sin embargo, es a través de la clase Container como podemos establecer el o los gestores de diseño que la ventana va a utilizar para implementar los componentes que ésta manejará. El gestor de diseño es parte del Container, de hecho, siempre que se crea un Container, se puede especificar con cual o cuales de los gestores de diseño disponibles en Java se quiere trabajar, o dicho de otro modo, qué gestor de diseño se asignará al contenedor.

• Desde el punto de vista operativo, un Gestor de diseño es una propiedad del contenedor, que puede almacenar cualquier tipo de objeto que derive de la clase Container (normalmente bien controles o bien otros gestores de diseño). El Container actúa de intermediario entre la ventana y los componentes que él almacena pasándoles a estos los mensajes que a él le llegan desde la ventana.

El modo de interactuar con un gestor de diseño es muy simple: basta con especificar con cual de los disponibles queremos trabajar y añadirle componentes. Veamos esto de una forma más detenida.

Puesto que existen diferentes gestores de diseño incluidos en el lenguaje Java y puesto que además podemos construir nuestros propios gestores de diseño, se hace necesario indicar con cual de los disponibles deseamos trabajar. Lo que se hace pasándole al método setLayout() de la clase Container un objeto del tipo deseado de gestor de diseño con el que se desea trabajar. Veamos, por ejemplo, la línea de código que muestra el Código fuente 95.

this.setLayout(new FlowLayout());

Código fuente 95

El operador new devuelve un gestor de diseño del tipo FlowLayout, éste objeto es recogido por el método setLayout() de la clase Container, quien a partir de ahora ya sabe con qué gestor deseamos trabajar.

La clase Container dispone del método add(), que permite añadir componentes. Como ya hemos comentado, a un objeto de la clase Container le podemos añadir bien controles o bien otros gestores de diseño. Para ello algo tan simple como lo que aparece en el Código fuente 96.

this.add( new Button( "Uno" ) );

Código fuente 96

A continuación vamos a comentar los distintos gestores de diseño que podemos encontrar dentro del paquete JAVA.AWT. En los distintos ejemplos se han utilizado botones para poner de manifiesto las diferentes distribuciones que los distintos gestores de diseño hacen del espacio ya que el gestor es invisible.

Los cinco gestores de diseño son los que se comentan a continuación.

© Grupo EIDOS 10. Interfaces de usuario en Java: gestores de diseño y eventos

167

FlowLayout El gestor de diseño FlowLayout, además de ser el gestor de diseño por defecto de los applets (que los trataremos en el capítulo correspondiente), es también el más simple de todos.

Este gestor, distribuye los controles de izquierda a derecha llenando el ancho del contenedor de arriba a abajo. Es decir, cuando acaba con una fila de controles, sigue con la siguiente, actuando con los controles como lo hace un editor de textos con las palabras. Es decir, los controles fluyen (Flow).

Para ver cada uno de los ejemplos de los distintos tipos de gestores de diseño vamos a volver a utilizar la aplicación de ejemplo del capítulo anterior, es decir, nuestra clase Ventana. Implementaremos un método para cada tipo de gestor de diseño. En la Figura 53 se puede ver el ejemplo del gestor Flow-Layout.

Figura 53

Y el método, que será llamado desde el método main() y que permite mostrar la ventana de la Figura 53 es el que se muestra en el Código fuente 97.

public void gestorFlowLayout(){setLayout( new FlowLayout() );for( int n = 0; n <= 15; n++ )

add( new Button( Integer.toString(n) ) );validate();

}

Código fuente 97

Como se puede observar, se utiliza primero el método setLayout() pasándole por parámetro una instancia del gestor de diseño que se va a utilizar en nuestra ventana. En el bucle se van añadiendo botones a la ventana, en este caso se utiliza el método add() de la clase Container, en la versión que ya conocemos, es decir pasándole por parámetro la instancia del componente AWT que queremos añadir. Como se ha puede comprobar, los componentes se van incorporando al contenedor atendiendo al orden en el que los vamos añadiendo.

BorderLayout Este gestor, distribuye los componentes en cinco zonas: norte, sur, este, oeste y deja una amplia zona central para el resto de los componentes. Si a alguna de estas áreas no se le asigna un componente, el área vacía será ocupada por alguna de las áreas restantes.


168

Al igual que con el gestor anterior, vamos a ver en la Figura 54 el aspecto que muestra y a continuación veremos y comentaremos el código de nuestra clase Ventana que nos permite crear este gestor de diseño.

Figura 54

Y el método correspondiente de la clase Ventana es el que muestra el Código fuente 98.

public void gestorBorderLayout(){setLayout( new BorderLayout() );add("North",new Button("Norte"));add("South", new Button("Sur"));add(BorderLayout.EAST,new Button("Este"));add(BorderLayout.WEST,new Button("Oeste"));add("Center",new Button("Centro"));validate();

}

Código fuente 98

Aquí se puede observar que el método setLayout() se sigue utilizando de la misma forma que para el gestor anterior, pero vemos que el método add() antepone un parámetro al componente que vamos añadir, este parámetro es para indicar la posición del componente dentro del contenedor. También se puede observar que hay dos formas de indicar la posición del componente, o con una cadena indicando la situación (North, Center, South...) o con una constante definida por la clase BorderLayout.

CardLayout Este tercer gestor permite manejar varias "fichas intercambiables", de forma tal que sólo una esté visible a la vez y ocupando todo el área del contenedor. Es similar a los controles de pestaña o "tabs" de Windows.

El problema que este gestor de diseño tiene es que la implementación que en Java se ha hecho de él, no es completa, y las fichas (o tarjetas si se prefiere) no tienen la correspondiente pestaña asociada, por lo que no existe una forma preestablecida de interactuar con los controles para cambiar de unas fichas a otras; siendo necesario crear este mecanismo programáticamente con los inconvenientes de pérdida de tiempo y esfuerzo que esto supone. En el capítulo siguiente veremos que los componentes Swing ofrecen una clase llamada JTabbedPane que representa un componente en el que se pueden elegir las distintas fichas (paneles) a través de los paneles que presenta.

En la Figura 55 se puede observar el aspecto de nuestra aplicación.


169

Figura 55

Y el código correspondiente se puede ver en el Código fuente 99.

public void gestorCardLayout(){CardLayout gestor=new CardLayout();setLayout(gestor);add("1",new Button("Card 1"));add("2",new Button("Card 2"));add("3",new Button("Card 3"));add("4",new Button("Card 4"));add("5",new Button("Card 5"));validate();

}

Código fuente 99

El lector puede que esté un poco confundido, debido a que en el código se añaden cinco botones, pero sin embargo al ejecutar la aplicación sólo podemos ver el primero, esto es así porque las demás fichas con los botones correspondientes se encuentran debajo de la primera. La clase CardLayout ofrece una serie de métodos para mostrar las distintas fichas que conforman el gestor de diseño. Estos métodos son:

• first(Container): nos movemos a la primera ficha. A este método le pasamos por parámetro el contenedor sobre el que se ha aplicado el gestor de diseño. En el ejemplo anterior deberíamos añadir la siguiente línea: gestor.first(this).

• next(Container): nos movemos a la siguiente ficha, si estamos en la última, volveremos a la primera, es decir, la disposición del orden de las fichas es circular. Al igual que en el método anterior, debemos pasar por parámetro el contenedor que al que se le ha aplicado el gestor de diseño.

• previous(Container): nos movemos a la ficha anterior, si estamos en la primera ficha, nos moveremos a la última.

• last(Container): nos movemos a la última ficha.

• show(Container, String): mostramos una ficha específica, la ficha se indica mediante un parámetro que va a ser un objeto de la clase String, y que coincidirá con la cadena asignada a la ficha que queremos mostrar. Esta cadena se asigna a la ficha a la hora de añadirla al gestor de diseño, como se puede observar en el método add(). Por ejemplo, si queremos mostrar la tercera ficha, teniendo en cuenta el ejemplo anterior, se escribiría: gestor.show(this,"3").


170

Si observamos el método gestorCardLayout(), comprobamos que el gestor de diseño se ha asignado de una forma un poco diferente, en este caso se ha creado un variable llamada gestor que va a contener la referencia al gestor de diseño de la clase CardLayout. Esto se ha hecho así para poder tener una referencia del gestor de diseño sobre la que podemos lanzar los métodos de la clase CardLayout vistos anteriormente.

Los componentes se añaden a las fichas utilizando una versión del método add() que tiene como primer parámetro el objeto String que identifica la ficha a la que se va añadir el elemento, según se van añadiendo los diferentes componentes se van añadiendo fichas al gestor de diseño, no es obligatorio especificar el nombre que va a identificar a la ficha, es decir podemos utilizar al método add() con un único parámetro que va a ser el componente a añadir.

GridLayout Este gestor permite distribuir componentes basándose en una rejilla (grid) bidimensional, haciendo que cada componente utilice una celda de la rejilla.

Para este gestor de diseño debemos indicar el número de filas y columnas que va a presentar. Sin embargo, los componentes que se añaden al gestor no pueden especificarse bidimensionalmente, sino que es obligatorio añadirlos ordinalmente, es decir, primero el primero, después el segundo en la rejilla, y así sucesivamente.

Veamos la figura que muestra este gestor de diseño (Figura 56).

Figura 56

Como se puede apreciar en el ejemplo aquí expuesto, el flujo de los componentes ha ido de izquierda a derecha y de arriba a abajo hasta completarse la rejilla (grid). Y el código del método correspondiente se puede ver en el Código fuente 100.

public void gestorGridLayout(){setLayout(new GridLayout(4,3));add(new Button("Primero"));add(new Button("Segundo"));add(new Button("Tercero"));add(new Button("Cuarto"));add(new Button("Quinto"));add(new Button("Sexto"));add(new Button("Séptimo"));add(new Button("Octavo"));add(new Button("Noveno"));add(new Button("Décimo"));


171

validate();}

Código fuente 100

El constructor de la clase GridLayout es diferente del resto de gestores, se debe especificar dos parámetros que indican el número de filas y columnas, respectivamente, que va a presentar el gestor de diseño.

GridBagLayout El quinto gestor de diseño es el más potente, y es también el más complicado de manejar.

Esta clase, trabaja en conjunción con otra llamada GridBagConstraints, que se encarga de almacenar todos los parámetros de visualización necesarios para que los componentes puedan presentarse de una forma versátil y flexible.

Quizás una de las mayores ventajas que incorpora este gestor es la posibilidad de que un componente abarque más de una celda, lo que le da una gran potencia. Pero esta es sólo una de las muchas ventajas que este gestor incorpora.

En la Figura 57 se puede ver el aspecto de un gestor de diseño GridBagLayout.

Figura 57

Y como viene siendo ya costumbre, se muestra el código del método correspondiente, en el Código fuente 101.

public void gestorGridBagLayout(){GridBagLayout gestor=new GridBagLayout();GridBagConstraints constantes=new GridBagConstraints();Button boton;setLayout(gestor);//primer botón en la posición (0,0) (columna,fila)//se extiende hasta la última filaboton=new Button("Primero");constantes.gridwidth=1;constantes.gridheight=GridBagConstraints.REMAINDER;constantes.fill=GridBagConstraints.BOTH;constantes.gridx=0;constantes.gridy=0;gestor.setConstraints(boton,constantes);add(boton);


172

//segundo botón en la posición (1,0)boton=new Button("Segundo");constantes.gridx= GridBagConstraints.RELATIVE;constantes.gridheight=1;gestor.setConstraints(boton,constantes);add(boton);//tercer botón en la posición (2,0), se extiende dos columnasboton = new Button("Tercero");constantes.gridx=2;constantes.gridwidth=2;gestor.setConstraints(boton,constantes);add(boton);//cuarto botón en la posición (4,0)boton=new Button("Cuarto");constantes.gridx=4;constantes.gridwidth=1gestor.setConstraints(boton,constantes);add(boton);//quinto botón en la posición (5,0), se extiende 3 filasboton = new Button("Quinto");constantes.gridx=5;constantes.gridheight=3;gestor.setConstraints(boton,constantes);add(boton);//sexto botón, en la posición (1,1), se extiende 4 columnasboton=new Button("Sexto");constantes.gridx=1;constantes.gridy++;constantes.gridheight=1;constantes.gridwidth=4;gestor.setConstraints(boton,constantes);add(boton);//séptimo botón en la posición (1,2)boton=new Button("Séptimo");constantes.gridy++;constantes.gridx=1;constantes.gridwidth=1;gestor.setConstraints(boton,constantes);add(boton);//octavo botón situado en la posición (2,2) se extiende 3 columnasboton = new Button("Octavo");constantes.gridx=2;constantes.gridwidth=3;gestor.setConstraints(boton, constantes );add(boton);//noveno botón en la posición (1,3) se extiende hasta la última//columnaboton = new Button("Noveno");constantes.gridx=1;constantes.gridy++;constantes.gridwidth=GridBagConstraints.REMAINDER;gestor.setConstraints(boton,constantes);add(boton);validate();

}

Código fuente 101

Creamos el gestor de diseño GridBagLayout y también un objeto GridBagConstraints, el objeto GirdBagConstraints, que en el código hemos llamado constantes, indica al gestor de diseño GridBagLayout cómo se debe comportar.

Al gestor de diseño le indicamos el objeto GridBagConstraints que tiene asociado a través del método setConstraints() de la clase GridBagLayout. A este método se le pasa como parámetros el componente


173

que se va añadir y se le va a aplicar lo definido por el objeto GridBagConstraints, y el propio objeto GridBagConstraints.

El objeto GridBagConstraints lo podemos utilizar para ir añadiendo distintos componentes al contenedor al que se le ha asignado el gestor de diseño, en nuestro ejemplo hemos ido reutilizando y modificando los aspectos que nos convenían en cada caso.

Para definir el comportamiento que debe tener cada control al añadirse al contenedor, la clase GridBagConstraints tiene una serie de atributos que permiten un gran control sobre cómo se sitúa cada componente en el contenedor al que se le ha asignado el gestor de diseño GridBagLayout.

Los atributos más relevantes de la clase GridBagConstraints son los siguientes:

• gridx, gridy: especifica las coordenadas en las que se va a situar el componente, de esta forma la primera columna sería gridx=0 y la primera fila gridy=0. Para indicar que el componente se va a situar a la derecha (para gridx) o debajo (para gridy) del último componente que se ha añadido al contenedor utilizaremos la constante RELATIVE de la clase GridBagConstraints, además, este es el valor por defecto.

• gridwidth, gridheight: a través de estos dos atributos indicamos cuantas columnas y cuantas filas, respectivamente, va a ocupar el componente. El valor por defecto en ambos casos es uno. Para especificar que el componente se extienda hasta la última columna (para gridwidth) o hasta la última fila (para gridheight) se utiliza la constante REMAINDER de la clase GridBagConstraints.

• fill: cuando el área en la que se va a mostrar el componente es mayor que el tamaño especificado del componente, podemos determinar mediante este atributo si se va a redimensionar el componente. Este atributo acepta como valores válidos varias constantes de la clase GridBagConstraints. Por defecto el valor de esta propiedad es NONE, es decir, no se redimiensionan los componentes, si queremos que se redimensione de forma horizontal o de forma vertical utilizaremos las constantes HORIZONTAL y VERTICAL, respectivamente. Y si queremos que se redimensione el componente de forma completa utilizaremos la constante BOTH.

En el Código fuente 101 se puede observar la utilización de todos estos atributos, para seguir el código se deben tener en cuenta los comentarios y fijarnos en el aspecto que ofrece al final nuestro contenedor.

Con este gestor de diseño finalizamos el apartado dedicado a los mismos, ahora vamos a pasar a un apartado que tiene una gran importancia dentro del tema de la construcción de interfaces de usuario, es el apartado dedicado al tratamiento de eventos en Java.

Veremos como reaccionar ante eventos generados por la interacción del usuario con el interfaz de usuario, como pueden ser pulsaciones de botón, selección de elementos de menú, selección de listas, cambios en cajas de texto, cierre de una ventana, movimientos del ratón, etc.

Tratamiento de eventos en Java En apartados y capítulos anteriores hemos estado viendo como construir interfaces de usuario a partir de los componentes ofrecidos por el paquete JAVA.AWT, pero estos componentes por sí solos no hacen mucho, para tener un interfaz de usuario completo es necesario que el usuario se comunique con nuestra aplicación, y esta comunicación se produce a través del interfaz de usuario mediante el tratamiento de eventos.


174

Como veremos a lo largo de este apartado, el lenguaje Java dentro de su paquete java.awt.event nos ofrece una completa jerarquía de clases cuya función es la de representar los distintos tipos de eventos que podemos tratar desde un interfaz de usuario.

El modelo de eventos que ofrece Java es denominado modelo de delegación de eventos (Delegation Event Model). Los diferentes tipos de eventos se encuentran encapsulados dentro de una jerarquía de clases que tienen como raíz a la clase java.util.EventObject.

La idea fundamental del modelo de eventos de Java es que un evento se propaga desde un objeto "fuente" (source) hacia un objeto "oyente" (listener) invocando un método en el oyente al que se le pasa como parámetro una instancia de la clase del evento que representa el tipo de evento generado. Este método será el que trate al evento y actúe en consecuencia.

Los eventos son representados por toda una jerarquía de clases de eventos. Esta jerarquía de eventos se muestra en la Figura 58, cada una de las líneas significa que la clase que se encuentra en la parte inferior de la línea hereda de la clase que se encuentra en la parte superior. Se debe aclarar que las clases en las que no aparece el nombre de su paquete pertenecen todas al paquete dedicado a los eventos, java.awt.event.

Figura 58

Como ya hemos adelantado, en el tratamiento de eventos dentro del lenguaje Java hay dos entidades bien diferenciadas y que son las necesarias para que se produzca el tratamiento de eventos en Java: la fuente del evento y el oyente del mismo. La fuente va a ser el componente que genere el evento y el oyente el componente o clase que lo trate.

Desde el punto de vista de la jerarquía de clases de Java, un oyente es un objeto que implementa un interfaz java.util.EventListener específico, de esta clase raíz es de la que heredan todos los interfaces del tipo <Evento>Listener. Implementará el interfaz que se corresponda con el tipo de evento que se desea tratar en el oyente. Un interfaz EventListener define uno o más métodos que serán invocados por la fuente del evento en respuesta a un tipo de evento específico.


175

Las características que debe tener un oyente es que debe implementar el interfaz que se corresponda con el evento que desea tratar y debe registrarse como oyente de la fuente de eventos que va a disparar los eventos a tratar. Cualquier tipo de objeto se puede registrar como un "oyente" de eventos. Estos oyentes sólo reciben notificaciones de los eventos en los que están interesados, es decir, los eventos que provienen de la fuente para cual se han registrado.

Una fuente de eventos es un objeto que origina o "dispara" eventos. La fuente define los eventos que van a se emitidos ofreciendo una serie de métodos de la forma add<Tipo de Evento>(), que son usados para registrar oyentes específicos para esos eventos. A los métodos add<Tipo de Evento>() se les pasa por parámetro una instancia del oyente que va a tratar los eventos que genere la fuente.

Todos estos conceptos que estamos introduciendo acerca del tratamiento de eventos en Java, se verá mucho más claro cuando se muestren algunos ejemplos más adelante.

Así por ejemplo, si tenemos el siguiente GUI: un botón y una caja de texto dentro de una ventana, y queremos que al pulsar el botón aparezca un mensaje en la caja de texto, el oyente será la ventana que contiene al botón y a la caja de texto, y la fuente será el botón que lanzará el evento correspondiente.

Este modelo de eventos ofrece las siguientes características:

• Ofrece un estructura robusta para soportar programas Java complejos.

• Es simple y fácil de aprender.

• Ofrece una clara separación entre el código de la aplicación y del interfaz de usuario, en lo que al tratamiento de eventos se refiere.

• Facilita la creación de un código de tratamiento de eventos robusto y menos propenso a errores.

Un oyente en lugar de implementar un interfaz, puede utilizar una clase que herede de una clase adaptadora de eventos del paquete java.awt.event. Las clases adaptadoras permiten sobrescribir solamente los métodos del interfaz en los que se esté interesado. Así por ejemplo, si queremos atrapar un click del ratón, en lugar de implementar el interfaz MouseListener, heredamos de la clase adaptadora de los eventos de ratón, es decir de la clase MouseAdapter, solamente deberemos sobrescribir el método mouseClicked().

Esto es posible debido a que las clases adaptadoras implementan el interfaz correspondiente y simplemente tienen implementaciones vacías de todos los métodos del interfaz EventListener. De esta forma se consigue un código más claro y limpio. Estas clases se suelen utilizar cuando se quiere hacer uso de un interfaz muy complejo del que sólo interesan un par de métodos.

Dentro de la jerarquía de clases de Java hay una serie de clases para representar todos los eventos y otra serie de interfaces que definen una serie de métodos que deben implementar las clases que van a tratar los eventos, es decir, lo que hemos llamado oyentes. Otras clases que también hemos comentado y que se utilizan dentro del tratamiento de eventos en Java son las clases adaptadoras. Las clases adaptadoras las utilizaremos para simplificar nuestro código, ya que implementan de forma vacía todos los métodos de un interfaz de tratamiento de eventos determinado.

Cada conjunto de eventos tiene asociado un interfaz, y como ya hemos dicho cada uno de estos interfaces declara una serie de métodos para cada uno de los eventos lógicos asociados al tipo de evento de que se trate.


176

Cada componente del AWT genera un tipo de eventos distinto, que está representado mediante una clase en el paquete java.awt.event.

En la Tabla 21 y en la Tabla 22 se indica que eventos lanza cada clase perteneciente a los componentes del AWT. En las filas aparecen las clases de los componentes y en las columnas las clases de los eventos que pueden lanzar.

ActionEvent Adjustment

Event ComponentEvent

Container-Event

FocusEvent

Button X X X

Canvas X X

Checkbox X X

CheckBoxMenu-Item

Choice X X

Component X X

Container X X X

Dialog X X X

Frame X X X

Label X X

List X X X

MenuItem X

Panel X X X

Scrollbar X X X

Scrollpane X X X

TextArea X X

TextComponent X X

TextField X X X

Window X X X

Tabla 21


177

ItemEvent KeyEvent MouseEvent TextEvent WindowsEvent

Button X X

Canvas X X

Checkbox X X X

CheckBoxMenu-Item

X

Choice X X X

Component X X

Container X X

Dialog X X X

Frame X X X

Label X X

List X X X

MenuItem

Panel X X

Scrollbar X X

Scrollpane X X

TextArea X X X

TextComponent X X X

TextField X X X

Window X X X

Tabla 22

Los interfaces que definen los métodos de cada evento van a ser utilizados por los oyentes, o bien implementándolos directamente o bien a través de las clases adaptadoras. Y las clases de los eventos se van a utilizar para obtener información del evento que se ha producido, el cual se pasará como parámetro a los métodos del interfaz correspondiente.

En la Tabla 23 se muestra una relación de interfaces con sus métodos correspondientes y la clase adaptadora que le corresponde.


178

Interfaz Métodos Clase Adaptadora

ActionListener actionPerformed(ActionEvent) --- AdjustmentListener adjustmentValueChanged(AdjustmentEvent) --- ComponentListener componentHidden(ComponentEvent)

componentMoved(ComponentEvent) componentResized(ComponentEvent) componentShown(ComponentEvent)

ComponentAdapter

ContainerListener componentAdded(ContainerEvent) componentRemoved(ContainerEvent)

ContainerAdapter

FocusListener focusGained(FocusEvent) focusLost(FocusEvent) FocusAdapter

ItemListener ItemStateChanged(ItemEvent) --- KeyListener KeyPressed(KeyEvent) keyReleased(KeyEvent)

keyTyped(KeyEvent) KeyAdapter

MouseListener mouseClicked(MouseEvent) mouseEntered(MouseEvent) mouseExited(MouseEvent) mousePressed(MouseEvent) mouseReleased(MouseEvent)

MouseAdapter

MouseMotionListener mouseDragged(MouseEvent) mouseMoved(MouseEvent)

MouseMotionAdapter

TextListener textValueChanged(TextEvent) --- WindowListener windowActivated(WindowEvent)

windowClosed(WindowEvent) windowClosing(WindowEvent) windowDeactivated(WindowEvent) windowDeiconified(WindowEvent) windowIconified(WindowEvent) windowOpened(WindowEvent)

WindowAdapter

Tabla 23

Como se puede apreciar en la tabla anterior, los interfaces que únicamente poseen un método no tienen clase adaptadora correspondiente, ya que no tiene ningún sentido, siempre que utilizamos un interfaz con un único método vamos a implementarlo.

A continuación vamos a comentar los pasos genéricos que se deben seguir a la hora de realizar el tratamiento de eventos en Java. Aunque los pasos son genéricos, para poder hacer referencia a un interfaz concreto vamos a suponer que queremos realizar el tratamiento de eventos que se corresponde con la pulsación de un botón. Lo primero es importar el paquete java.awt.event:

import java.awt.event.*;

Código fuente 102


179

A continuación escribiremos la declaración de la clase para que implemente el interfaz adecuado (listener interface).

Por ejemplo si se está tratando de atrapar un evento ActionEvent (es decir, una pulsación de un botón) generado por un botón, será necesario implementar el interfaz ActionListener.

public class MiClase extends ClasePadre implements ActionListener{

Código fuente 103

Debemos determinar que componentes van a generar los eventos. Se registra cada uno de ellos con el tipo adecuado de oyente, si tenemos en cuenta el ejemplo anterior del botón, se debería escribir lo que indica el Código fuente 104.

objetoBoton.addActionListener(this);

Código fuente 104

Una vez hecho esto debemos crear las implementaciones de todos los métodos del interfaz que la clase debe implementar.

public void actionPerformed(ActionEvent evento){

//cuerpo del método

}

Código fuente 105

Una vez comentado el tratamiento de eventos en Java de forma más o menos teórica vamos a comentar una serie de ejemplos para aplicar la teoría a la práctica. Estos ejemplos además nos van a servir para repasar distintos puntos del lenguaje Java comentados hasta ahora.

Vamos a realizar una aplicación que vamos a ir modificando y complicando para mostrar las diferentes facetas del tratamiento de eventos en Java.

No vamos a tratar todos los interfaces, sólo vamos a tratar tres de los más representativos, el que se encarga de las pulsaciones de botones, ActionListener, el que se encarga del ratón, MouseListener, y el que se encarga de las ventanas, WindowListener, estos tres nos ofrecen ejemplos bastante prácticos. También veremos los adaptadores MouseAdapter y WindowAdapter.

Primero vamos a comenzar creando una aplicación sencilla que va a consistir simplemente en una ventana que nos va a indicar si se encuentra minimizada o no, y cuando pulsemos sobre el aspa de cerrar la ventana esta se cierre y finalice la ejecución de la aplicación.

En la Figura 59 se puede ver el aspecto que tendría esta aplicación.


180

Figura 59

El código de esta aplicación de ejemplo es el que aparece en el Código fuente 106.

import java.awt.*;//paquete necesario para el tratamiento de eventosimport java.awt.event.*;public class Ventana extends Frame implements WindowListener{

//constructor de nuestra clasepublic Ventana(String titulo){

//constructor de la clase padresuper(titulo);//tamaño de la ventanasetSize(150,150);//se muestra la ventanashow();//se registra nuestra clase como oyenteaddWindowListener(this);

}public void windowClosed(WindowEvent evento){

System.out.println("La ventana se ha cerrado");//finaliza la aplicaciónSystem.exit(0);

}public void windowIconified(WindowEvent evento){

System.out.println("Estoy minimizada");}public void windowDeiconified(WindowEvent evento){

System.out.println("No estoy minimizada");}public void windowClosing(WindowEvent evento){

//se cierra la ventanadispose();

}public void windowDeactivated(WindowEvent evento){}public void windowActivated(WindowEvent evento){}public void windowOpened(WindowEvent evento){}public static void main (String[] args){

Ventana miVentana=new Ventana("Eventos");}

}

Código fuente 106

Vamos a comentar algunos puntos importantes acerca del código anterior. Vamos a comentar algunas consideraciones de carácter general, en primer lugar, al ser una aplicación debe tener un método


181

main() de arranque, y como hemos dicho que es una ventana, hereda de la clase Frame. Como se puede observar hemos creado también un método constructor para nuestra clase Ventana.

En lo concerniente al tratamiento de eventos, como se puede ver importamos el paquete correspondiente e indicamos que nuestra clase implementa el interfaz WindowListener. En el constructor de nuestra clase indicamos quien va a ser el oyente de nuestra clase, es decir, quien va a tratar los eventos, en este caso el oyente es nuestra misma clase. Para ello utilizamos la línea de código que aparece en el Código fuente 107.

addWindowListener(this);

Código fuente 107

Es decir, indicamos que el oyente de los eventos de la ventana va a ser nuestra propia clase, es decir, estamos registrando nuestra clase como oyente mediante la referencia this. Al ser nuestra clase fuente y oyente de los eventos, también debe implementar el interfaz que define los métodos que se van a ejecutar atendiendo al evento que se produzca. En nuestro caso hay tres métodos que no nos interesan, pero como implementamos el interfaz WindowListener debemos implementarlos aunque no tengan contenido.

Los métodos windowIconified() y windowDeiconified() se ejecutarán cuando se minimice la ventana y cuando se restaure, respectivamente, el método windowClosing() se ejecuta en el momento de cerrar la ventana y el método windowClosed() cuando ya se ha cerrado.

El resto del código es bastante sencillo y considero que no necesita una mayor explicación.

Como ya hemos comentado hay tres métodos del interfaz WindowListener que no nos interesan y que por lo tanto nos gustaría suprimir, en este momento entran en juego las clases adaptadoras. Como ya debe saber el alumno, las clases adaptadoras realizan una implementación vacía de todos los métodos del interfaz con el que se corresponden, y al heredar de ellas utilizaremos únicamente los métodos del interfaz correspondiente que nos interese.

En nuestro caso no podemos heredar de una clase adaptadora, ya que heredamos de la clase Frame y la herencia múltiple no se permite en Java. Por lo tanto deberemos crear y definir una nueva clase que herede de la clase adaptadora del interfaz WindowListener, es decir, que herede de la clase WindowAdapter.

Por lo tanto si queremos hacer uso de la clase adaptadora WindowAdapter, el código de nuestra aplicación se debe modificar como indica el Código fuente 108.

import java.awt.*;import java.awt.event.*;//nuestra clase ya no implementa el interfaz WindowListenerpublic class Ventana extends Frame{

public Ventana(String titulo){super(titulo);setSize(150,150);show();//se registra como oyente la clase que hereda la clase adaptadoraaddWindowListener(new AdaptadorVentana(this));

}


182

public static void main (String[] args){Ventana miVentana=new Ventana("Eventos");

}}//clase que hereda de la clase adaptadoraclass AdaptadorVentana extends WindowAdapter{

//atributo que se utiliza como referencia a la clase//que es la fuente del evento que queremos tratarprivate Ventana fuente;//constructor de nuestra clase adaptadora//recibe como parámetro la clase fuente del eventopublic AdaptadorVentana(Ventana fuente){

this.fuente=fuente;}//contiene la implementación de los métodos que nos intersan//del interfaz WindowListenerpublic void windowClosed(WindowEvent evento){

System.out.println("La ventana se ha cerrado");System.exit(0);




fuente.dispose();}

}

Código fuente 108

Los mayores cambios se aprecian en que existe una nueva clase que va a ser la encargada de tratar los eventos, en este caso si que existe una separación clara entre clase fuente y clase oyente. El oyente sería la clase AdaptadorVentana y la clase fuente sería la clase principal Ventana. Nuestra clase Ventana, al ser sólo fuente de eventos no va a implementar el interfaz WindowListener y por lo tanto únicamente va a tener en su cuerpo el método constructor y el método main().

Otra cosa que cambia también en el código de nuestra aplicación es la forma en la que se registra el oyente. Se sigue utilizando el método addWindowListener() pero en este caso se pasa por parámetro una instancia de la clase adaptadora que hemos creado nosotros.

addWindowListener(new AdaptadorVentana(this));

Código fuente 109

Ahora vamos a detenernos en la clase AdaptadorVentana. Esta clase hereda de la clase WindowAdapter y posee un atributo denominado fuente que es de la clase Ventana.

Este atributo es necesario para tener una referencia a la clase fuente del evento. Esta referencia es necesaria ,en este caso, dentro del método windowClosing(), a la hora de cerrar la ventana.


183

public void windowClosing(WindowEvent evento){fuente.dispose();

}

Código fuente 110

Para conseguir la referencia a la fuente del evento se pasa una instancia de la clase Ventana actual al constructor de la clase adaptadora. De esta forma la clase adaptadora puede manipular y acceder al objeto de clase Ventana.

public AdaptadorVentana(Ventana fuente){this.fuente=fuente;

}

Código fuente 111

Como se puede comprobar esta nueva clase contiene todos los métodos que nos interesan del interfaz WindowListener.

Si queremos tratar distintos eventos mediante clases adaptadoras, deberemos crear una clase que herede de la clase adaptadora de cada tipo de evento, siempre que exista una clase adaptadora para el evento en cuestión.

También existe la posibilidad de utilizar la clases adaptadoras como clases internas (inner classes). Una clase interna es una clase definida dentro de otra. El beneficio que podemos obtener de estas clases adaptadoras, es que no tenemos porque llevar la referencia de la clase fuente. La clase interna va a tener acceso a todos los métodos y atributos de la clase en la que está declarada, aunque estos sean privados. Realmente una clase interna se sale fuera de los principios de la POO, pero puede ser bastante práctica.

El nuevo código tendría el aspecto que muestra el Código fuente 112.

import java.awt.*;import java.awt.event.*;public class Ventana extends Frame{

public Ventana(String titulo){super(titulo);setSize(150,150);show();//ya no se indica la referencia de la clase fuenteaddWindowListener(new AdaptadorVentana());


Ventana miVentana=new Ventana("Eventos");}//clase adaptadora internaclass AdaptadorVentana extends WindowAdapter{

//Ya no es necesario el atributo fuentepublic void windowClosed(WindowEvent evento){


}


184

public void windowIconified(WindowEvent evento){System.out.println("Estoy minimizada");

}public void windowDeiconified(WindowEvent evento){


//llamamos directamente al método dispose()dispose();

}}//se cierra la clase interna

}

Código fuente 112

Y para rizar el rizo, vamos a ofrecer una posibilidad distinta a la hora de tratar los eventos en Java, se puede utilizar una clase interna anónima, el código sería el Código fuente 113.

import java.awt.*;import java.awt.event.*;public class Ventana extends Frame{

public Ventana(String titulo){super(titulo);setSize(150,150)show();//Utilizamos una clase interna anónimaaddWindowListener(new WindowAdapter(){

//métodos de la clase anónimapublic void windowClosed(WindowEvent evento){



System.out.println("Estoy minimizada");}

public void windowDeiconified(WindowEvent evento){System.out.println("No estoy minimizada");

}public void windowClosing(WindowEvent evento){

dispose();}

});//se cierra la clase interna anónima}public static void main (String[] args){

Ventana miVentana=new Ventana("Eventos");}

}

Código fuente 113

A la vista del código se puede ver que se trata de instanciar una clase sin indicar un objeto que contenga una referencia a la misma, ya que en realidad esta clase sólo se va a utilizar para el tratamiento de eventos y no se va a querer hacer una referencia a ella.

El mecanismo es muy sencillo, se utiliza el nombre de la clase adaptadora correspondiente, WindowAdapter en nuestro caso, y se implementan los métodos que se consideren necesarios, por lo demás funciona exactamente igual a una clase interna.


185

Una vez comentados las distintas opciones que tenemos a la hora de tratar los eventos, ahora vamos a añadir a nuestra aplicación un botón para que al pulsarlo escriba un mensaje en la pantalla. En este caso deberemos implementar el interfaz ActionListener, ya que este interfaz no posee una clase adaptadora, al tener un único método llamado actionPerformed(). El nuevo aspecto de nuestra aplicación de ejemplo se puede observar en la Figura 60.

Figura 60

Y el nuevo código es el Código fuente 114.

import java.awt.*;import java.awt.event.*;//implementamos el interfaz para tratar la pulsación del botónpublic class Ventana extends Frame implements ActionListener{

private Button boton;public Ventana(String titulo){

super(titulo);setSize(150,150);setLayout(new FlowLayout());boton=new Button("Púlsame");add(boton);show();addWindowListener(new AdaptadorVentana());//oyente del botón, en este caso la clase Ventanaboton.addActionListener(this);

}public void actionPerformed(ActionEvent evento){

System.out.println("Buenas tardes");}public static void main (String[] args){

Ventana miVentana=new Ventana("Eventos");}class AdaptadorVentana extends WindowAdapter{public void windowClosed(WindowEvent evento){





dispose();}

}}

Código fuente 114


186

Como se puede observar la fuente del evento en este nuevo caso va a ser por un lado, el botón y su oyente la clase Ventana, y por otro lado la fuente de eventos va a ser la clase Ventana y el oyente la clase interna AdaptadorVentana. Las líneas utilizadas para añadir el botón se encuentran en el constructor, la única línea digna de mención es la que registra el oyente del botón (Código fuente 115).

boton.addActionListener(this);

Código fuente 115

La clase Ventana al implementar el interfaz ActionListener debe facilitar el método actionPerformed(), que se ejecutará al pulsar el botón. Al pulsar el botón veremos en pantalla el saludo "Buenas tardes".

public void actionPerformed(ActionEvent evento){

System.out.println("Buenas tardes");

}

Código fuente 116

Para finalizar el presente capítulo modificaremos de nuevo nuestra aplicación, añadiendo un área de texto, en la que se escribirá si el puntero del ratón se encuentra en el área de texto, o por el contrario ha salido.

Aquí vamos a tratar un nuevo tipo de evento, en este caso los eventos del ratón, y lo vamos a realizar a través de la clase adaptadora MouseAdapter. La clase MouseAdapter es la clase adaptadora del interfaz MouseListener. Utilizamos la clase adaptadora, porque sólo nos van a interesar un par de métodos del interfaz MouseListener.

El nuevo aspecto de la aplicación de ejemplo es el de la Figura 61. Y el código actualizado de la aplicación es el que aparece en el Código fuente 117.

Figura 61

import java.awt.*;import java.awt.event.*;


187

public class Ventana extends Frame implements ActionListener{private Button boton;private TextArea area;public Ventana(String titulo){

super(titulo);setLayout(new FlowLayout());boton=new Button("Púlsame");area=new TextArea();add(boton);add(area);show();pack();addWindowListener(new AdaptadorVentana());boton.addActionListener(this);//El oyente del ratón es una nueva clase internaarea.addMouseListener(new AdaptadorRaton());


System.out.println("Buenas tardes");}public static void main (String[] args){

Ventana miVentana=new Ventana("Eventos");}//clase adaptadora para los eventos del ratónclass AdaptadorRaton extends MouseAdapter{public void mouseEntered(MouseEvent evento){

area.setText("El ratón ha entrado");}

public void mouseExited(MouseEvent evento){area.setText("El ratón ha salido");

}}class AdaptadorVentana extends WindowAdapter{public void windowClosed(WindowEvent evento){




System.out.println("No estoy minimizada");}

public void windowClosing(WindowEvent evento){dispose();

}}}

Código fuente 117

En esta última versión de la aplicación de prueba tenemos una nueva fuente de eventos, que va a ser el área de texto, y un nuevo oyente que es la clase adaptadora AdaptadorRaton. La clase Ventana ofrece un nuevo atributo que va a representar el área de texto.

Para registrar el oyente del área de texto se utiliza el método addMouseListener(), a este método se le pasa una instancia de la clase adaptadora que va a tratar los eventos del ratón, en este caso se trata de la clase AdaptadorRaton. Esta clase implementa los métodos mouseEntered() y mouseExited() que se lanzarán cuando en ratón entre en el área de texto o salga del mismo, respectivamente.

Como se puede apreciar cada oyente se encarga de los eventos para los cuales se ha registrado, sin tener en cuenta el resto de los que se produzca y sin interferir entre sí.

Interfaces de usuario en Java: componentes Swing / contenedores

Introducción A lo largo de los siguientes tres capítulos vamos a tratar el segundo tipo de componentes que ofrece Java para construir interfaces de usuario, es decir, los componentes Swing incluidos en el paquete javax.swing.

Muchos de los conceptos vistos en capítulos anteriores, como pueden ser los eventos o los gestores de diseño siguen siendo válidos para los componentes Swing, así por ejemplo, los gestores de diseño que utilizan los componentes Swing son los mismos que los vistos en los componentes AWT, de hecho se debe importar el paquete JAVA.AWT para utilizarlos, pero Swing aporta un nuevo gestor de diseño (que veremos en el siguiente capítulo, también dedicado por completo al extenso mundo de los componentes Swing) que se encuentra en el paquete javax.swing.

Lo mismo sucede con los eventos, los componentes Swing utilizan las clases de los eventos incluidas en el paquete java.awt.event, y además añaden nuevos eventos que se pueden encontrar en el paquete javax.swing.event.

Como hemos dicho vamos a tener tres capítulos dedicados a Swing. Swing es bastante extenso y aun utilizando tres capítulos no lo vamos a ver completamente, sería necesario un curso de la misma extensión de éste (o más) para tratar Swing de forma completa.

En este primer capítulo vamos a introducir una serie de conceptos de Swing y también se va a tratar un tipo de componentes Swing, los contenedores Swing.


190

En el segundo capítulo trataremos el otro gran grupo de componentes Swing, los componentes atómicos. Y en el último de esta serie de capítulos trataremos otras características de Swing como son el nuevo gestor de diseño que incorpora (implementado por la clase BoxLayout) y la característica Pluggable Look & Feel, es decir, aspecto y comportamiento configurables.

JFC y Swing JFC (Java Foundation Classes) es el nombre que recibe el conjunto de un gran número de características cuya función primordial es la de permitir la construcción de complejos interfaces de usuario. El primer anuncio de JFC se realizó en la conferencia de desarrolladores JavaOne y se definió mediante las características que iba a ofrecer:

• Componentes Swing: comprenden todos los componentes utilizados para interfaces de usuario desde botones, barras de menú, diálogos y ventanas hasta cajas de texto, barras de progreso, paneles con pestañas y listas. A lo largo de este capítulo describiremos algunos de los componentes Swing, no todos ya que Swing ofrece un gran número de clases agrupadas en 15 paquetes distintos.

• Soporte para Pluggable Look and Feel: es decir, soporte para una apariencia y comportamiento configurables. Permite a cualquier programa que utilice componentes Swing definir un tipo de apariencia y comportamiento (Look and Feel). Así por ejemplo una misma aplicación puede presentar una apariencia y comportamiento al estilo de Java o bien tipo Windows. En el apartado correspondiente volveremos a retomar esta característica y la trataremos en detalle.

• API de accesibilidad: permite a tecnologías de rehabilitación tales como lectores de pantalla y displays Braille obtener información acerca del interfaz de usuario. El API de accesibilidad se encuentra formando parte de las características avanzadas del lenguaje Java y por lo tanto no lo vamos a tratar en este curso.

• API Java 2D: al igual que ocurría con la característica o funcionalidad anterior, se trata de un conjunto de clases especializadas, en este caso, en el tratamiento de gráficos en dos dimensiones, imágenes y texto. El API Java 2D se escapa también del alcance y pretensiones de este curso.

• Soporte para arrastrar y soltar (Drag and Drop): permite la posibilidad de arrastrar y soltar componentes entra aplicaciones Java y aplicaciones en otros lenguajes.

En muchos casos se utilizan indistintamente los términos JFC y Swing sin hacer ningún tipo de distinción, Swing fue el nombre en clave que recibió el proyecto de Sun encargado de desarrollar los nuevos componentes para la construcción de interfaces de usuario. La denominación swing aparece también en los paquetes correspondientes.

Los componentes Swing se encuentran disponibles de dos formas distintas, como parte de la plataforma Java 2, tanto en la herramienta JDK 1.2 o como en el JDK 1.3, y como una extensión del JDK 1.1 (versión de Java 1.1) denominada JFC 1.1. En nuestro caso vamos a utilizar la versión que se encuentran integrada con la plataforma Java 2.

© Grupo EIDOS 11. Interfaces de usuario en Java: componentes Swing / contenedores

191

Componentes Swing frente a componentes AWT En este apartado vamos a comentar las diferencias entre los dos grupos de componentes que ofrece Java para la creación de interfaces de usuario, y el porqué de la existencia de dos grupos distintos de componentes.

Los componentes AWT aparecieron en la versión 1.0 del JDK y eran los únicos componentes que se encontraban disponibles para desarrollar interfaces de usuario. Los componentes AWT se utilizan principalmente en las versiones 1.0 y 1.1 del lenguaje (que coincidían con las versiones de la herramienta JDK), aunque la plataforma Java 2 soporta perfectamente los componentes AWT como hemos podido comprobar en capítulos anteriores.

Desde Sun nos recomiendan que utilicemos si es posible los componentes Swing en lugar de los componentes AWT.

Los componentes Swing los podemos identificar porque los nombres de sus clases suelen ir precedidos por la letra J. Así por ejemplo, la clase Button del AWT, tiene su clase correspondiente en Swing denominada JButton. Los componentes AWT se encuentran en el paquete JAVA.AWT y los Swing en el paquete javax.swing.

La mayor diferencia entre los componentes AWT y los componentes Swing, es que los componentes Swing se encuentran implementados sin utilizar ningún tipo de código nativo. Los componentes Swing se denominan componentes ligeros (lightweight) y los componentes AWT componentes pesados (heavyweight).

Otra diferencia importante es la gran potencia y funcionalidad que ofrecen los componentes Swing. incluso los componentes Swing más sencillos ofrecen una serie de posibilidades que los componentes AWT no recogen, algunas de estas ventajas de los componentes Swing frente a los AWT son las que se enumeran a continuación:

• Los botones Swing pueden mostrar imágenes y/o texto.

• Es posible situar bordes en torno a los componentes Swing.

• Los componentes Swing no tienen porque ser rectangulares, por ejemplo, los botones pueden ser redondos.

• Las tecnologías de rehabilitación pueden obtener información de los componentes Swing de forma sencilla.

Swing nos permite especificar el aspecto y comportamiento (look and feel) del interfaz de usuario de nuestra aplicación (más adelante veremos como), sin embargo los componentes AWT tienen el aspecto y comportamiento de la plataforma nativa sobre la que se ejecutan.

Vamos a comentar brevemente algunas de las razones por las que nos puede interesar utilizar componentes Swing en lugar de componentes AWT.

• El rico conjunto de componentes que ofrece Swing: botones con imágenes, barras de herramientas, imágenes, elementos de menú, selectores de color, etc.

• La arquitectura Pluggable Look & Feel, es decir, aspecto y comportamiento configurable y seleccionable para los elementos del interfaz de usuario.

• Posiblemente en un futuro se ampliarán los componentes Swing disponibles.


192

Parece hasta ahora que con los componentes Swing todo son ventajas, e incluso que ni siquiera debemos plantearnos que tipo de componentes debemos utilizar para construir interfaces de usuario, siempre elegiremos componentes Swing. Pero este razonamiento no es correcto, ya que en la práctica no resulta tan sencillo.

Se debe señalar que, desgraciadamente, todavía no existen navegadores Web que soporten Swing, más claro todavía, los navegadores Web actuales, incluso en sus últimas versiones, no implementan la máquina virtual correspondiente a la plataforma Java 2. Por lo tanto si queremos construir applets que puedan ejecutarse en cualquier navegador deberemos construir su interfaz gráfica mediante componentes AWT, aunque en uno de los temas dedicados a los applets veremos un pequeño parche que utilizaremos para que los navegadores soporten componentes Swing.

Contenedores de alto nivel Bajo esta nomenclatura se agrupan una serie de clases que se corresponden con componentes Swing que realizan la función de contenedores de otros componentes y que constituyen la raíz en la jerarquía de contenedores. Los componentes de alto nivel se basan en los siguientes principios:

• Swing ofrece tres clases que representan a componentes de alto nivel: JFrame (ventana), JDialog (diálogo) y JApplet. También dentro de los componentes Swing encontramos una cuarta clase denominada JWindow que representa una ventana sin controles ni título y que se encuentra siempre por encima de cualquier ventana, es el equivalente a la clase Window de los componentes AWT. A lo largo de este capítulo iremos viendo como en los componentes Swing encontramos equivalentes de los componentes AWT.

• Para aparecer en pantalla todo componente de interfaz de usuario debe formar parte de una jerarquía de contenedores. Cada jerarquía de contenedores posee un contenedor de alto nivel como raíz.

• Cada contenedor de alto nivel posee un panel de contenido (content pane) que contiene los componentes visibles del contenedor de alto nivel del interfaz de usuario correspondiente.

• Opcionalmente se puede añadir una barra de menú a un contenedor de alto nivel. La barra de menú se sitúa en el contenedor de alto nivel, pero fuera del panel de contenido.

Veamos un sencillo ejemplo que muestra un contenedor de alto nivel. Se trata de un objeto de la clase JFrame que contiene una barra de menú (JMenuBar) de color azul y una etiqueta (JLabel) de color amarillo. En la Figura 62 se puede ver el aspecto del contenedor.

Figura 62


193

Y el código fuente completo de este ejemplo es el que aparece en el Código fuente 118.

import java.awt.*;import javax.swing.*;public class ContenedorAltoNivel {

public static void main(String s[]) {//se crea la ventana raíz de la jerarquía de contenedoresJFrame ventana = new JFrame("Contenedor de alto nivel");//se crea la etiquetaJLabel etiquetaAmarilla = new JLabel("");etiquetaAmarilla.setOpaque(true);etiquetaAmarilla.setBackground(Color.yellow);etiquetaAmarilla.setPreferredSize(new Dimension(200, 180));//se crea la barra de menúJMenuBar barraMenuCyan = new JMenuBar();barraMenuCyan.setOpaque(true);barraMenuCyan.setBackground(Color.cyan);barraMenuCyan.setPreferredSize(new Dimension(200, 20));//se añaden la etiqueta y la barra de menú a la ventanaventana.setJMenuBar(barraMenuCyan);ventana.getContentPane().add(etiquetaAmarilla, BorderLayout.CENTER);//se muestra la ventanaventana.pack();ventana.setVisible(true);

}}

Código fuente 118

A la vista de este código podemos realizar los siguientes comentarios. Se han importado los paquetes JAVA.AWT y javax.swing. El paquete JAVA.AWT es necesario para utilizar las clases Dimension, Color y BorderLayout, como se puede observar aunque utilicemos componentes Swing vamos a necesitar de los componentes AWT.

También podemos comprobar la forma en la que se añade un componente a un panel de contenido de un contenedor de alto nivel como puede ser un objeto de la clase JFrame, y también como añadir una barra de menú, en este mismo apartado veremos en más detalle el código que realiza estas funciones.

La jerarquía de contenedores del ejemplo queda como muestra el esquema de la Figura 63

Figura 63


194

Veamos un ejemplo más para ilustrar las jerarquías de contenedores. Para ello nos debemos fijar en la Figura 64.

Figura 64

En este ejemplo se han utilizado los siguientes componentes Swing:

• Una ventana principal (JFrame).

• Un panel (JPanel).

• Un botón (JButton).

• Una etiqueta (JLabel).

Al panel se le ha añadido un borde mediante la clase BorderFactory para mostrar el agrupamiento de forma más clara entre el botón y la etiqueta. El código fuente de este ejemplo es el que aparece en el Código fuente 119.

import javax.swing.*;import java.awt.*;public class Ventana{

public static void main(String[] args) {//se establece el Look & Feeltry {

UIManager.setLookAndFeel(UIManager.getCrossPlatformLookAndFeelClassName());

} catch (Exception e) { }//se crean los componentesJFrame ventana = new JFrame("Ventana");JLabel etiqueta = new JLabel(" Soy una etiqueta");JButton boton = new JButton("Soy un botón");

JPanel panel = new JPanel();//se asigna un borde y un gestor de diseño al panelpanel.setBorder(BorderFactory.createLineBorder(Color.red,5));panel.setLayout(new GridLayout(0, 1));

//se añaden al panel el botón y la etiquetapanel.add(boton);panel.add(etiqueta);

//se añade el panel al panel de contenido de la ventanaventana.getContentPane().add(panel, BorderLayout.CENTER);

//se muestra la ventanaventana.pack();ventana.setVisible(true);

}}

Código fuente 119


195

Este código adelanta algo que veremos en detalle en el apartado correspondiente, cómo asignar un aspecto y comportamiento (Look & Feel) determinado a nuestro interfaz de usuario, esto aparece en las primeras líneas del método main() y en este caso se establece el aspecto y comportamiento de Java.

Vamos a pasar a describir las funciones que presentan cada uno de los componentes Swing utilizados en el ejemplo.

En este ejemplo la ventana representada mediante la clase JFrame es el contenedor de alto nivel, igualmente podría tratarse de otro componente de alto nivel como podría ser un objeto de la clase JApplet o JDialog.

El panel es un contenedor intermedio, su propósito es el de simplificar la situación del botón y la etiqueta, para que sea visible se le ha asignado un borde de color rojo. Otros contenedores intermedios pueden ser paneles con pestañas (JTabbedPane) y paneles de scroll (JScrollPane), que juegan un papel más visible e interactivo dentro del interfaz de usuario.

Y por último y el botón y la etiqueta se denominan componentes atómicos, son componentes que no contienen otros componentes Swing, como ocurría con los anteriores, sino que tienen entidad suficiente para presentar por sí mismos información al usuario. A menudo los componentes atómicos tienen como función obtener información del usuario. Swing ofrece un gran número de componentes atómicos (en este capítulo veremos algunos de ellos) como pueden ser listas desplegables (JComboBox), cajas de texto (JTextField) o tablas (JTable).

En la Figura 65 se muestra el diagrama con la jerarquía de contenedores que presenta este ejemplo.

Figura 65

Como se puede observar en la Figura 65, incluso el programa Swing más sencillo presenta múltiples niveles en su jerarquía de contenedores, además, como ya hemos dicho la raíz de esta jerarquía siempre es un contenedor de alto nivel.

Cada contenedor de alto nivel indirectamente contiene un contenedor intermedio llamado panel de contenido (content pane), y normalmente el panel de contenido contiene, directa o indirectamente, todos los componentes visibles de la ventana del interfaz de usuario. La excepción a esta regla son las barras de menú, que se sitúan en un lugar especial fuera del panel de contenido, como vimos en el primer ejemplo de este apartado.


196

Para añadir un componente a un contenedor se utiliza una de las distintas formas del método add(), como ya vimos en el tema dedicado a los componentes AWT.

Como regla general, una aplicación Java con un interfaz de usuario basado en componentes Swing, tiene al menos una jerarquía de contenedores con un objeto de la clase JFrame como raíz de la misma. Por ejemplo, si una aplicación tiene una ventana principal y dos diálogos, la aplicación presentará tres jerarquías de contenedores, y por lo tanto tres contenedores de alto nivel. Una de las jerarquías de contenedores tiene a un objeto de la clase JFrame como raíz, y cada una de las otras dos jerarquías un objeto de la clase JDialog como raíz.

Un applet basado en Swing tiene al menos una jerarquía de contenedores y su raíz es un objeto de la clase JApplet. Por ejemplo un applet que muestra un diálogo tiene dos jerarquías de contenedores, los componentes en la ventana del navegador tienen como raíz un objeto JApplet, y los que se encuentran en el diálogo tienen como raíz de su jerarquía de componentes un objeto de la clase JDialog.

Hasta ahora hemos visto un par de ejemplos que por un lado nos han mostrado como funcionan las jerarquías de contenedores, y por otro, nos ha mostrado como utilizar algunos de los componentes Swing, aunque más adelante veremos algunos de ellos con más detalle.

Para obtener una referencia al panel de contenido de un componente de alto nivel debemos utilizar el método getContentPane(), que devuelve un objeto de la clase Container. Por defecto el panel de contenido es un contenedor intermedio que hereda de la clase JComponent y que tiene como gestor de diseño un BorderLayout.

Una vez que tenemos una referencia al panel de contenido podremos añadir los componentes que consideremos necesarios utilizando una sentencia similar a la que muestra el Código fuente 120.

ventana.getContentPane().add(componente,BorderLayout.CENTER);

Código fuente 120

Todos los contenedores de alto nivel pueden tener, en teoría, una barra de menú, sin embargo en la práctica las barras de menú se utilizan únicamente en ventanas y en raras ocasiones en applets. Para añadir una barra de menú a un contenedor de alto nivel, crearemos un objeto de la clase JMenuBar, añadiremos los elementos de menú que se consideren necesarios y por último se lanzará sobre el contenedor de alto nivel el método setMenuBar(), pasándole por parámetro el objeto JMenuBar correspondiente.

ventana.setMenuBar(objMenuBar);

Código fuente 121

Todo contenedor de alto nivel además de poseer un panel de contenido, poseen otro panel llamado panel raíz (root pane). Normalmente este panel intermedio no se suele utilizar, su función es la de gestionar el panel de contenido y la barra de menú junto con otros dos contenedores.

Estos dos contenedores son el panel de capas (layered pane) y el panel de cristal (glass pane). El panel de capas contiene directamente la barra de menú y el panel de contenido, y además permite ordenar los componentes que se vayan añadir con detenimiento (Z-order), es decir, permite organizar los


197

componentes del interfaz de usuario en capas. Esto puede ser útil para mostrar menús de aparición súbita (popup menus) por encima de otros componentes.

El panel de cristal suele permanecer oculto y se encuentra por encima de todos los elementos del panel raíz. Este panel es útil para interceptar eventos o pintar sobre un área que ya contiene otros componentes, se utiliza sobre todo para interceptar eventos de entrada que suceden sobre el contenedor de alto nivel. En la Figura 66 se puede ver un esquema que muestra la disposición de los distintos paneles que podemos encontrar en un componente de alto nivel.

Figura 66

A continuación vamos a comentar los distintos componentes de alto nivel: JFrame, JDialog y JApplet.

JFrame Ya hemos visto este componente Swing realizando las labores de contenedor de alto nivel, un objeto de la clase JFrame representa a una ventana con bordes, título y botones que permiten cerrar y maximizar la ventana.

Las aplicaciones Java que poseen interfaz de usuario al menos utilizan un JFrame, y también lo hacen a veces los applets.

Veamos la utilización de la clase JFrame mediante un sencillo ejemplo. Se trata de una ventana que contiene una etiqueta y que al pulsar el cierre de la misma se finalizará la ejecución de la aplicación. Su código es el Código fuente 122.

import java.awt.*;import java.awt.event.*;import javax.swing.*;public class Ventana{

public static void main(String s[]) {JFrame ventana = new JFrame("Ventana Sencilla");ventana.addWindowListener(new WindowAdapter() {

public void windowClosing(WindowEvent e) {System.exit(0);

}});JLabel etiqueta = new JLabel("Soy una etiqueta");etiqueta.setPreferredSize(new Dimension(175, 100));


198

ventana.getContentPane().add(etiqueta, BorderLayout.CENTER);ventana.pack();ventana.setVisible(true);

}}

Código fuente 122

Y el aspecto de la ventana es el que vemos en la Figura 67.

Figura 67

En la primera línea del método main() se utiliza el constructor de la clase JFrame que nos permite indicar el título de la ventana mediante una cadena que pasamos como parámetro, otra versión de este constructor es sin argumentos.

A continuación se añade un oyente para los eventos de la ventana, en este caso se implementa únicamente el método windowClosing() para finalizar la ejecución de la aplicación. En las siguientes líneas se crea y añade una etiqueta (JLabel) al panel de contenido de la ventana.

Por último se lanzan los métodos pack() y setVisible() sobre la instancia de la clase JFrame. El método pack() de un tamaño a la ventana de forma que todos sus contenidos tengan el tamaño especificado o superior, una alternativa al método pack() es le método setSize() en el que se puede especificar de forma explícita las dimensiones de la ventana. Al método setVisible() se le pasa el parámetro true para que muestre la ventana en la pantalla.

Por defecto cuando se pulsa el botón de cierre de la ventana, la ventana se oculta, sin la necesidad de utilizar ningún tratamiento de eventos, para cambiar este comportamiento se puede utilizar el método setDefaultCloseOperation() o bien implementar un tratamiento de eventos similar al del ejemplo.

El parámetro que se le pasa al método setDefaultCloseOperation() debe ser una de las siguientes constantes:

• DO_NOTHING_ON_CLOSE: en este caso cuando se pulsa el botón de cierre de la ventana no ocurre nada, la ventana sigue visible.

• HIDE_ON_CLOSE: es el valor por defecto, cuando se pulsa el botón de cierre la ventana se oculta, pero sigue existiendo, teniendo la posibilidad de mostrarse la ventana de nuevo si así lo indicamos en el programa.

• DISPOSE_ON_CLOSE: al cerrar la ventana se elimina de la memoria y de la pantalla, es decir, en este caso se liberan todos los recursos que estaban siendo utilizados por la ventana.


199

La clase JFrame hereda de la clase java.awt.Frame y por lo tanto hereda todos los métodos de la clase Frame, como pueden ser setSize(), pack(), setTitle(), setVisible() y getTitle(). Además de los métodos de la clase java.awt.Frame, la clase JFrame tiene los siguientes métodos propios:

• void setDefaultCloseOperation(int): asigna el tipo de operación que va a realizar la ventana cuando el usuario pulse el botón de cierre de la ventana. Ya hemos visto las posibles acciones.

• int getDefaultCloseOperation(): devuelve la operación de cierre por defecto asignada a la ventana.

• void setContentPane(Container): asigna a la ventana un panel de contenido, que va a ser el que contenga todos los componentes visibles del interfaz de usuario de la ventana. Este método permite utilizar nuestro propio panel de contenido, lo normal es utilizar un objeto de la clase JPanel para crear el panel de contenido, en el Código fuente 123 se puede observar como se crea un objeto JPanel que luego va a ser el panel de contenido de una ventana.

JPanel panelContenido=new JPanel();panelContenido.setLayout(new BorderLayout());panelContenido.add(componente,BorderLayout.CENTER);panelContenido.add(otroComponente,BorderLayout.SOUTH);ventana.setContentPane(panelContenido);

Código fuente 123

• Container getContentPane(): devuelve el panel de contenido de la ventana, este método se

suele utilizar para una vez que tenemos una referencia al panel de contenido de la ventana añadir componentes a la misma.

• void setMenuBar(MenuBar): asigna a la ventana una barra de menú determinada representada por un objeto de la clase MenuBar.

• JMenuBar getMenuBar(): devuelve la barra de menú que tiene asignada la ventana.

• void setGlassPane(Component): permite asignar un panel de cristal a la ventana.

• Component getGlassPane(): devuelve el panel de cristal de la ventana.

JDialog, JOptionPane Vamos a pasar ahora a comentar el segundo tipo de contenedores de alto nivel, los diálogos, que son un tipo de ventana más limitada que las ventanas representadas por la clase JFrame. Hay varias clases que ofrecen diálogos:

• JOptionPane: permiten crear sencillos diálogos estándar.

• ProgressMonitor: muestra un diálogo que muestra el progreso de una operación.

• JColorChooser: ofrece un diálogo estándar para la selección de colores.

• JFileChooser: ofrece un diálogo estándar para la selección de un fichero.


200

• JDialog: permite crear directamente diálogos completamente personalizados.

Como se indica al principio de esta sección nosotros únicamente nos vamos a encargar de las clase JOptionPane y JDialog.

Todo diálogo es dependiente de una ventana determinada, si la ventana se destruye también sus lo harán sus diálogos asociados. Cuando la ventana se transforma en icono sus diálogos desaparecen de la pantalla, cuando se maximiza la ventana los diálogos vuelven a aparecer.

Los diálogos pueden ser modales, cuando un diálogo modal se encuentra visible se bloquea la entrada del usuario en todas las demás ventanas del programa. Los diálogos que ofrece la clase JOptionPane son modales, para crear un diálogo no modal se debe hacer uso de la clase JDialog que permitirá indicar si el diálogo que se crea va a ser modal o no.

La clase JDialog hereda de a clase AWT java.awt.Dialog, añade a la clase Dialog un panel raíz (root pane) y soporte para la operación por defecto de cierre. Como se puede observar son las mismas características que ofrecía la clase JFrame sobre la clase Frame del AWT.

Cuando se utiliza la clase JOptionPane en realidad también estamos haciendo uso de la clase JDialog de forma indirecta, ya que la clase JOptionPane es un contenedor que puede crear de forma automática una instancia de la clase JDialog y añadirse al panel de contenido de ese diálogo. A continuación vamos a comentar las distintas características de la clase JOptionPane.

Mediante la clase JOptionPane podemos crear distintos tipos de diálogos, JOptionPane ofrece soporte para mostrar diálogos estándar, indicar los iconos, especificar el título y texto del diálogo y los textos de los botones que aparecen.

En cuanto a los iconos que se muestran en el diálogo facilitado por JOptionPane, podemos utilizar iconos personalizados, no utilizar ningún tipo de icono, o utilizar uno de los cuatro iconos estándar que ofrece la clase JOptionPane, estos iconos son los de pregunta, información, advertencia y error. El aspecto de estos iconos variará según el Look & Feel (aspecto y comportamiento) que se aplique.

Para mostrar diálogos modales sencillos se utilizará directamente uno de los métodos showXXXDialog() de la clase JOptionPane. Este conjunto de métodos son métodos estáticos y por lo tanto se lanzarán sobre una instancia concreta de la clase, sino que se lanzaran de forma directa sobre la clase.

Si lo que necesitamos es controlar el comportamiento del diálogo cuando se cierre o si el diálogo no debe ser modal entonces instanciaremos un objeto de la clase JOptionPane y lo añadiremos a un objeto de la clase JDialog. Veamos a continuación los principales métodos showXXXDialog() de la clase JOptionPane.

El primero de estos métodos es el método showMessageDialog(), que muestra un diálogo modal con un botón de aceptar. Se puede especificar el mensaje, el icono y el título que muestra el diálogo. Este método se encuentra sobrecargado y ofrece tres versiones distintas:

• void showMessageDialog(Component componentePadre, Object mensaje): el primer parámetro indica el componente padre del que depende, puede ser una ventana, un componente dentro de una ventana o nulo y el segundo el mensaje que se muestra, suele ser una cadena de texto que podemos dividir en varias líneas utilizando el carácter de nueva línea (\n).

• void showMessageDialog(Component componentePadre, Object mensaje, String título, int tipoMensaje): en este caso se especifica también el título, que será una cadena, y el tipo de


201

mensaje a mostrar. Este último parámetro determinará el icono que se va a mostrar en el diálogo, para ello se utilizan una serie de constantes definidas en la clase JOptionPane, estas constantes son: PLAIN_MESSAGE (sin icono), ERROR_MESSAGE (icono de error), INFORMATION_MESSAGE (icono de información), WARNING_MESSAGE (icono de advertencia) y QUESTION_MESSAGE (icono de pregunta).

• void showMessageDialog(Component componentePadre, Object mensaje, String título, int tipoMensaje, Icon icono): en esta última versión del método podemos indicar un icono personalizado para que se muestre en el diálogo.

Veamos algunos ejemplos con el método showMessageDialog(). Podemos añadir las distintas sentencias de creación de diálogos que vamos a ver ahora al ejemplo de la sección anterior en la que tratábamos la clase JFrame, la instancia de la clase JFrame, llamada ventana va a ser el componente padre de los diálogos.

Si añadimos la línea que muestra el Código fuente 124, a nuestra clase Ventana de la sección anterior, obtendremos el resultado que aparece en la Figura 68.

JOptionPane.showMessageDialog(ventana,"Esto es un mensaje","Título",JOptionPane.WARNING_MESSAGE);

Código fuente 124

Figura 68

Otras variaciones sobre la sentencia anterior se muestran a continuación con sus correspondientes resultados.

JOptionPane.showMessageDialog(ventana,"Esto es un mensaje");

Código fuente 125

En este caso se muestra el título y tipo de mensaje por defecto.

Figura 69


202

ImageIcon icono = new ImageIcon("icono.gif");JOptionPane.showMessageDialog(ventana,"Esto es un mensaje","Título",

JOptionPane.INFORMATION_MESSAGE,icono);

Código fuente 126

En este otro caso indicamos un icono personalizado para que se muestre en el diálogo.

Figura 70

JOptionPane.showMessageDialog(ventana,"Esto es un mensaje","Título",JOptionPane.ERROR_MESSAGE);

Código fuente 127

Figura 71

Como se puede comprobar en todos los ejemplos, si pulsamos el botón etiquetado como OK, el diálogo se cerrará.

Otro método de la clase JOptionPane que muestra un diálogo es el método showConfirmaDialog(). En este caso este método muestra un diálogo de confirmación, para que el usuario seleccione entre los botones correspondientes. Este método, al igual que el anterior, se encuentra sobrecargado y por lo tanto ofrece tres versiones distintas, que pasamos a comentar a continuación.

• int showConfirmDialog(Component componentePadre, Object mensaje): este método muestra un diálogo modal con los botones, que representan las opciones disponibles, si, no y cancelar, y además con el título por defecto.

• int showConfirmDialog(Component componentePadre, Object mensaje, String título, int tipoOpción): en este caso podemos especificar el título del diálogo de confirmación y el tipo de opciones que se van a mostrar, para esto último utilizaremos las siguientes constantes ofrecidas por la clase JOptionPane: DEFAULT_OPTION, YES_NO_OPTION, YES_NO_CANCEL_OPTION y OK_CANCEL_OPTION.


203

• int showConfirmDialog(Component componentePadre, Object mensaje, String título, int tipoOpción, int tipoMensaje): en esta versión del método podemos indicar además el tipo de mensaje que se muestra en el diálogo, de la misma forma que lo hacíamos en el método showMessageDialog().

• int showConfirmDialog(Component componentePadre, Object mensaje, String título, int tipoOpción, int tipoMensaje, Icon icono): en esta última versión especificamos un icono personalizado que se va a mostrar en el diálogo de conformación correspondiente.

Como se puede observar en todas las versiones del método showConfirmDialog() se devuelve un entero (int), este entero va a recoger la selección que ha realizado el usuario, es decir, indicará el botón que ha sido pulsado. El entero que devuelve este método se corresponde con uno de los valores de las siguientes constantes de la clase JOptionPane: YES_OPTION, NO_OPTION, CANCEL_ OPTION, OK_OPTION y CLOSED_OPTION (el usuario cierra el diálogo sin pulsar ninguna de las opciones disponibles).

Al igual que ocurría con el método anterior, vamos a ver ejemplos de utilización del método show-ConfirmDialog.

JOptionPane.showConfirmDialog(ventana,"¿Desea formatear el disco?");

Código fuente 128

En este caso se muestra el diálogo de confirmación por defecto.

Figura 72

JOptionPane.showConfirmDialog(ventana,"¿Desea formatear el disco?","Confirmeoperación",

JOptionPane.YES_NO_OPTION,JOptionPane.WARNING_MESSAGE);

Código fuente 129

Figura 73


204

El siguiente método que vamos a tratar de la clase JOptionPane va a ser el método showOptionDialog().

Este método es mucho más potente que los vistos anteriormente, ya que permite una mayor personalización del diálogo. La función de este método es la de mostrar un diálogo modal con los botones, iconos, mensaje y títulos especificados para que el usuario seleccione entre las distintas opciones que se le ofrecen, con este método podremos indicar los botones que queremos aparezcan en el diálogo.

El método showOptionDialog() se diferencia del método showConfirmDialog() principalmente en que permite especificar las etiquetas de los botones que aparecen y además permite especificar la opción seleccionada por defecto.

La sintaxis de este método es la siguiente:

int showOptionDialog(Component componentePadre, Object mensaje,String título, int tipoOpción,

int tipoMensaje, Icon icono, Object[]opciones, Object valorInicial)

Vamos a comentar los distintos parámetros de este nuevo método. Los tres primeros parámetros son los mismos que los vistos en el método showMessageDialog() y además tienen el mismo significado. En el tipo de opción se especifica el conjunto de opciones que se van a presentar al usuario, y por lo tanto se corresponderán con las constantes vistas en el método showConfirmDialog().

Los dos siguientes parámetros, tipo de mensaje y el icono personalizado, tiene el mismo cometido que el método showMessageDialog(). El siguiente parámetro es un array de objetos que se va a corresponder con un array de cadenas que se van a mostrar en cada uno de los botones del diálogo, es decir, podemos utilizar nuestras propias etiquetas pera mostrar en los botones. El último parámetro indica cual es la opción que se encuentra seleccionada por defecto.

Como se puede observar en la sintaxis del método showOptionDialog() se devuelve un entero (int), este entero tiene la misma función que el que devolvía el método showConfirDialog(), es decir, va a recoger la selección que ha realizado el usuario, es decir, indicará el botón que ha sido pulsado. Se debe indicar que aunque utilicemos etiquetas personalizadas para nuestros botones, se siguen devolviendo los mismos valores de las constantes, así por ejemplo un diálogo del tipo YES_NO_OPTION siempre devolverá los valores: YES_OPTION, NO_OPTION o CLOSED_OPTION.

Ahora se va a mostrar ejemplos de uso del método showOptionDialog(). Estos ejemplos son únicamente unas cuentas sentencias que podemos incluir, como ocurría con los métodos anteriores, en nuestra ya conocida clase Ventana.

Object[] opciones={"Vale", "Ni hablar"};ImageIcon icono = new ImageIcon("icono.gif");JOptionPane.showOptionDialog(ventana,"¿Desea formatear el disco?","Confirmeoperación",

JOptionPane.YES_NO_OPTION,JOptionPane.WARNING_MESSAGE,icono, opciones, opciones[1]);

Código fuente 130


205

Se muestra un diálogo con las opciones si/no pero con unas etiquetas de botones personalizadas, así como con un icono personalizado, además es el segundo botón el que se encuentra seleccionado por defecto.

Figura 74

El último método que vamos a ver de la clase JOptionPane es el método showInputDialog(), este método va a permitir obtener información de entrada del usuario a través del diálogo, ya sea a través de una caja de texto o a través de un una lista de opciones. El diálogo que se muestra va a tener dos botones, uno de aceptar y otro de cancelar, si el usuario pulsa el botón de aceptar indicará que ha introducido una información que podemos recuperar. Este método se encuentra sobrecargado, y ofrece las siguientes versiones:

• Object showInputDialog(Component componentePadre, Object mensaje): muestra un diálogo con el mensaje correspondiente que requiere una entrada del usuario a través de una caja de texto.

• Object showInputDialog(Component componentePadre, Object mensaje, String título, int tipoMensaje): en esta caso nos permite especificar un título y un tipo de mensaje (ya conocemos las constantes correspondientes).

• Object showInputDialog(Component componentePadre, Object mensaje, String título, int tipoMensaje, Icon icono, Object opciones, Object opciónSeleccionada): en este método se permite indicar un icono personalizado y un conjunto de opciones en forma de lista desplegable para que el usuario seleccione una de ellas además se permite seleccionar una opción por defecto.

• String showInputDialog(Object mensaje): en este caso no se indica nada más que el mensaje que se va a mostrar al usuario, sin utilizar ningún componente padre, por lo que el diálogo se situará en el centro de la pantalla, ya que en los otros casos se centra siempre con respecto al componente padre, aunque de todas forma sigue bloqueando a la ventana que lo ha generado.

Como se puede comprobar siempre se devuelve un objeto de la clase String, que se va a corresponder con una cadena que va a representar la información indicada por el usuario, ya sea a través de una caja de texto una de una lista de opciones disponibles. En los siguientes ejemplos se muestra la utilización del método showInputDialog().

En este caso se va a recoger el dato facilitado por el usuario y mostrarlo en la salida estándar de la aplicación.

String respuesta=JOptionPane.showInputDialog(ventana,"¿Cuál es tu nombre?");System.out.println("El nombre del usuario es: "+respuesta);

Código fuente 131


206

Figura 75

Object[] valores={"Rojo","Verde","Azul","Negro","Amarillo"};ImageIcon icono = new ImageIcon("icono.gif");Object respuesta=JOptionPane.showInputDialog(ventana,"¿Cuál es tu color favorito?",

"Selección decolor",JOptionPane.QUESTION_MESSAGE,

icono,valores,valores[2]);System.out.println("El color favorito del usuario es el: "+respuesta);

Código fuente 132

En este caso se muestra una lista con las opciones disponibles, para que el usuario seleccione la que desee. También se ha utilizado un icono personalizado.

Figura 76

Hasta ahora hemos visto los métodos que nos ofrece la clase JOptionPane para mostrar distintos tipos de diálogo. Estos diálogos tienen en común una serie de características: al pulsar alguno de los botones que contienen se cierran, también se cierran cuando el usuario pulsa el cierre del diálogo y por último son todos modales. En algunos casos estos diálogos nos servirán, ya que su comportamiento se puede adecuar a nuestras necesidades, pero en otros casos esto puede no ser así.

En algunos casos nos puede interesar validar la información ofrecida por el usuario en un diálogo, o también nos puede interesar utilizar un diálogo que no sea modal. En estos casos en los que deseamos personalizar al máximo los diálogos utilizaremos la clase JDialog conjuntamente con la clase JOptionPane. Para ello necesitamos crear una instancia de la clase JOptionPane para añadirla al objeto JDialog correspondiente.

La clase JOptionPane presenta múltiples constructores que permiten especificar el mensaje que se va a mostrar, el tipo de mensaje, el tipo de opciones, el icono personalizado, las opciones disponibles y la opción seleccionada por defecto.

Una vez creado el objeto JOptionPane, deberemos crear el objeto JDialog que lo va a contener, algunos de los constructores ofrecidos por la clase JDialog son:


207

• JDialog(): crea un diálogo no modal, sin título definido y sin ninguna ventana propietaria.

• JDialog(Frame ventanaPropietaria): se indica la ventana a la que se encuentra asociado el diálogo.

• JDialog(Frame ventanaPropietaria, boolean modal): se indica si el diálogo va a ser modal o no.

• JDialog(Frame ventanaPropietaria, boolean modal, String título): se especifica además el título que va a tener el diálogo.

Si ya tenemos instanciados el objeto JOptionPane y el objeto JDialog, únicamente nos queda asignar al diálogo (JDialog) su contenido (JOptionPane), para ello utilizamos el método setContentPane() de la clase JDialog, y que es común, como ya hemos comentado, a todos los contenedores de alto nivel.

A continuación se muestra este proceso con un ejemplo que consiste en una sencilla aplicación Java que muestra una ventana y un diálogo asociada a la misma.

import java.awt.*;import java.awt.event.*;import javax.swing.*;public class Dialogo{

public static void main(String s[]) {JFrame ventana = new JFrame("Ventana Sencilla");

ventana.setSize(175,100);ventana.setVisible(true);JOptionPane contenido=new JOptionPane("Esto es un mensaje",

JOptionPane.INFORMATION_MESSAGE,JOptionPane.YES_NO_CANCEL_OPTION);JDialog dialogo=new JDialog(ventana,"Esto es un diálogo",true);

dialogo.setContentPane(contenido);dialogo.setLocationRelativeTo(ventana);dialogo.pack();dialogo.setVisible(true);

}}

Código fuente 133

El resultado es un diálogo modal como el de la Figura 77.

Figura 77

Como se puede comprobar la pulsación de los botones del diálogo no tiene el efecto que tenían anteriormente, si queremos que realicen alguna operación cuando se pulsen, deberemos hacerlo a través de una gestión de eventos a través del código de nuestra aplicación. Aunque si pulsamos el


208

cierre del diálogo éste se sigue cerrando, ya que la operación tiene asignada por defecto para el cierre es HIDE_ON_CLOSE, es decir, ocultarse en el cierre, como ocurría con la clase JFrame.

En el código se puede observar que se utiliza el método setLocationRealtiveTo(), este método centra el diálogo de forma relativa al componente que le pasamos por parámetro.

Otros métodos de la clase JDialog son los siguientes:

• Container getContentPane(): devuelve el panel de contenido del diálogo.

• int getDefaultCloseOperation(): devuelve la operación de cierre por defecto que tiene asignada el diálogo.

• void setDefaultCloseOperation(int operacion): asigna una operación de cierre por defecto al diálogo.

JApplet Este es el tercero de los contenedores de alto nivel. Esta clase hereda de la clase java.applet.Applet, es por lo tanto la versión Swing de la clase Applet.

La clase JApplet aporta dos características esenciales a los applets, ofrece soporte para tecnologías de rehabilitación y ofrece un panel raíz, con todo lo que ello supone, es decir, añadir componentes al panel de contenido, posibilidad de tener una barra de menú, etc.

Todavía no hemos visto con detenimiento la utilización de applets, únicamente los hemos definido de manera sencilla, por lo tanto en el presente capítulo no vamos a comentar nada más de la clase JApplet, será en los capítulos dedicados a los applets dónde se trate la misma.

Contenedores intermedios Los contenedores intermedios son contenedores Swing, que aunque no son contenedores de alto nivel, su labor principal es la de contener otros componentes. Estos contenedores se siguen basando en la jerarquía de contenedores de Swing que ya hemos visto anteriormente.

Swing ofrece una serie de contenedores de propósito general:

• JPanel: es le más flexible y utilizado de todos ellos. Se utiliza normalmente para agrupar componentes, se le puede asignar gestores de diseño y bordes. Los paneles de contenido de los contenedores de alto nivel suelen ser de la clase JPanel.

• JScrollPane: ofrece una vista de scroll de un componente, suele contener componentes grandes o que pueden crecer. Se utilizan debido a las limitaciones del tamaño de la pantalla.

• JSplitPane: este panel agrupa dos componentes, uno al lado del otro. El usuario puede ajustar la línea divisora que separa ambos componentes arrastrándola. El aspecto es similar al que ofrece, por ejemplo, el explorador de Windows, la vista del árbol de directorios se encuentra separada de la vista de contenidos de un directorio.


209

• JTabbedPane: contiene muchos componentes pero sólo puede mostrar un conjunto de ellos a la vez, el usuario puede ir cambiando entre los distintos conjuntos de manera sencilla. Un ejemplo podrían ser las distintas pestañas de una hoja de propiedades.

• JToolBar: grupa una serie de componentes (normalmente botones) en una fila o en una columna, pueden permitir al usuario arrastrar la barra a distintos lugares. Un ejemplo pueden ser las barras de herramientas de un procesador de textos como MS Word.

Además también existen los siguientes contenedores intermedios que se encuentran más especializados:

• JInternalFrame: permite mostrar una ventana dentro de otra. Parece una ventana y ofrece toda su funcionalidad pero debe parecer siempre dentro de otra ventana (contenedor de alto nivel) que la contiene.

• JLayeredPane: este panel ofrece una tercera dimensión, la profundidad, para poder posicionar componentes de esta forma. Esta tercera dimensión se denomina también Z-order. Al añadir un componente a un panel de este tipo se especifica su profundidad mediante un entero, cuanto mayor sea el entero especificado mayor será la profundidad en la que se sitúa el componente.

• JRootPane: esta clase representa el panel raíz de un contenedor de alto nivel, como ya vimos en el apartado anterior el panel raíz esta formado por las siguientes partes: panel de capas, panel de contenido, panel de cristal y barra de menú.

A continuación vamos a comentar algunos de estos paneles intermedios, no vamos a tratar todos ya nos excederíamos en la extensión del presente curso, no se debe olvidar que Swing tienen un gran número de componentes.

JPanel Esta clase permite construir paneles de propósito general para contener componentes Swing. Por defecto un panel no muestra nada en pantalla a excepción de su fondo, también por defecto los paneles son opacos, aunque se pueden hacer transparentes mediante el método setOpaque() pasándole el valor false por parámetro.

La clase JPanel es la versión Swing de la clase Panel de AWT. La clase JPanel permite asignar un gestor de diseño al panel para indicar la forma en la que se van añadiendo los distintos componentes al mismo, por defecto el gestor de diseño de un objeto JPanel es un FlowLayout.

Swing utiliza los mismos gestores de diseño que vimos para los componentes AWT, de hecho se debe importar el paquete JAVA.AWT para poder utilizarlos, pero se añade un nuevo gestor mediante la clase BoxLayout, que veremos en el apartado correspondiente.

Para añadir componentes lo haremos de la misma forma que veíamos en los paneles AWT, es decir, con las distintas versiones de los métodos add(). En el Código fuente 134 se muestra la forma de utilizar esta clase.

import java.awt.*;import java.awt.event.*;import javax.swing.*;public class Panel{


210

public static void main(String s[]) {JFrame ventana = new JFrame("Ventana Sencilla");JPanel panel=new JPanel();panel.setLayout(new BorderLayout());JLabel etiqueta1 = new JLabel("Soy una etiqueta",JLabel.CENTER);etiqueta1.setPreferredSize(new Dimension(175, 100));JLabel etiqueta2 = new JLabel("Soy otra etiqueta",JLabel.CENTER);etiqueta2.setPreferredSize(new Dimension(175, 100));panel.add(etiqueta1, BorderLayout.NORTH);panel.add(etiqueta2, BorderLayout.SOUTH);ventana.getContentPane().add(panel, BorderLayout.CENTER);ventana.pack();ventana.setVisible(true);

}}

Código fuente 134

Se trata simplemente de añadir dos etiquetas a un panel (JPanel) y añadir este panel al panel de contenido de una ventana (JFrame), el resultado se puede apreciar en la Figura 78.

Figura 78

La clase JPanel hereda de la clase JComponent, y debido a ello permite utilizar una nueva funcionalidad ofrecida por Swing, los bordes.

Cada objeto de la clase JComponent puede tener uno o más bordes. Los bordes no son realmente componentes, sino que se utilizan para delimitar visualmente una serie de componentes de otros. Para asignar un borde a un componente, en este caso un objeto de la clase JPanel, se utiliza el método setBorder().

Para crear los distintos bordes que ofrece Swing se suele utilizar la clase BorderFactory. Esta clase ofrece un gran número de métodos que permiten crear distintos tipos de bordes: de líneas, elevados, hundidos, marcados, con títulos, una combinación de dos bordes, etc.

En el Código fuente 135 se puede observar como se asigna distintos bordes a distintos paneles dentro de una ventana.

import java.awt.*;import java.awt.event.*;


211

import javax.swing.*;public class Panel{

public static void main(String s[]) {JFrame ventana = new JFrame("Ventana Sencilla");ventana.getContentPane().setLayout(new GridLayout(7,1));((JPanel)ventana.getContentPane()).setBorder(

BorderFactory.createEmptyBorder(10,10,10,10));JPanel panel1=new JPanel();JLabel etiqueta1 = new JLabel("Borde tipo línea",JLabel.CENTER);panel1.setBorder(BorderFactory.createLineBorder(Color.black));panel1.add(etiqueta1);ventana.getContentPane().add(panel1);JPanel panel2=new JPanel();JLabel etiqueta2 = new JLabel("Borde elevado",JLabel.CENTER);panel2.setBorder(BorderFactory.createRaisedBevelBorder());panel2.add(etiqueta2);ventana.getContentPane().add(panel2);JPanel panel3=new JPanel();JLabel etiqueta3 = new JLabel("Borde hundido",JLabel.CENTER);panel3.setBorder(BorderFactory.createLoweredBevelBorder());panel3.add(etiqueta3);ventana.getContentPane().add(panel3);JPanel panel4=new JPanel();JLabel etiqueta4 = new JLabel("Borde decorado",JLabel.CENTER);panel4.setBorder(BorderFactory.createMatteBorder(5,5,5,5,Color.red));panel4.add(etiqueta4);ventana.getContentPane().add(panel4);JPanel panel5=new JPanel();JLabel etiqueta5 = new JLabel("Borde con título",JLabel.CENTER);panel5.setBorder(BorderFactory.createTitledBorder(

BorderFactory.createLineBorder(Color.blue),"Título"));panel5.add(etiqueta5);ventana.getContentPane().add(panel5);JPanel panel6=new JPanel();JLabel etiqueta6 = new JLabel("Borde grabado",JLabel.CENTER);panel6.setBorder(BorderFactory.createEtchedBorder());panel6.add(etiqueta6);ventana.getContentPane().add(panel6);JPanel panel7=new JPanel();JLabel etiqueta7 = new JLabel("Borde compuesto",JLabel.CENTER);panel7.setBorder(BorderFactory.createCompoundBorder(

BorderFactory.createLineBorder(Color.yellow),BorderFactory.createRaisedBevelBorder()));

panel7.add(etiqueta7);panel7.setPreferredSize(new Dimension(175,50));ventana.getContentPane().add(panel7);ventana.pack();ventana.setVisible(true);

}}

Código fuente 135

Y el resultado se muestra en la Figura 79.

El Código fuente 135 merece una serie de comentarios. El primero de ellos es referente al tipo de borde utilizado en el panel de contenido, como se puede observar al recuperar el panel de contenido para asignarle un borde vacío se ha tenido que hacer un "cast" con la clase JPanel, este borde vacío se ha utilizado para crear un margen entre el panel de contenido y el contenedor, en este caso una instancia de la clase JFrame.


212

Figura 79

Al panel de contenido de la ventana se le ha asignado un gestor de diseño GridLayout con siete filas y una única columna. Algunos de los métodos de la clase BorderFactory se encuentran sobrecargados, para permitir una mayor personalización de los distintos tipos de bordes que queremos asignar.

A cada panel se le ha asignado un borde distinto y se le ha añadido una etiqueta (JLabel) con la descripción del tipo de borde correspondiente.

JTabbedPane Gracias a este contenedor intermedio podemos tener distintos componentes, normalmente otros paneles, compartiendo un mismo espacio. El usuario puede visualizar los componentes que desea ver seleccionando la pestaña correspondiente.

Para crear un contenedor de este tipo primero debemos instanciar el objeto correspondiente de la clase JTabbedPane, luego se van creando los distintos componentes y se van añadiendo al contenedor mediante el método addTab().

Antes de seguir con esta nueva clase vamos a verla en acción mediante un sencillo ejemplo. El ejemplo consiste simplemente en un objeto JTabbedPane al que se le van añadiendo distintos paneles, cada uno con sus componentes. El código se puede ver en el Código fuente 136.

import java.awt.*;import java.awt.event.*;import javax.swing.*;


213

public class PanelTab{public static void main(String s[]) {

JFrame ventana = new JFrame("Ventana Sencilla");ImageIcon icono = new ImageIcon("icono.gif");JTabbedPane panelTab = new JTabbedPane();//tratamiento de eventos para el cierre de la ventanaventana.addWindowListener(new WindowAdapter() {


}});//se van creando paneles con componentes y se añaden al objeto

JTabbedPaneJPanel panel1=new JPanel();panel1.add(new JButton("Botón",icono));//se crea una nueva pestaña con el nuevo componentepanelTab.addTab("Uno",icono,panel1,"Soy la primera pestaña");panelTab.setSelectedIndex(0);JPanel panel2=new JPanel();panel2.add(new JLabel("Soy una etiqueta",JLabel.CENTER));panelTab.addTab("Dos",icono,panel2,"Soy la segunda pestaña");JPanel panel3=new JPanel();panel3.add(new JLabel("Soy otra etiqueta",JLabel.CENTER));panel3.setBorder(BorderFactory.createLineBorder(Color.red));panelTab.addTab("Tres",icono,panel3,"Soy la tercera pestaña");JPanel panel4=new JPanel();panel4.add(new JToggleButton("Otro botón",icono));panelTab.addTab("Cuatro",icono,panel4,"Soy la cuarta pestaña");JPanel panel5=new JPanel();panel5.add(new JSlider(JSlider.HORIZONTAL,0,30,10));panelTab.addTab("Cinco",icono,panel5,"Soy la última pestaña");//se le da un tamaño al contenedor de pestañaspanelTab.setPreferredSize(new Dimension(400,200));//se añade a la ventanaventana.getContentPane().add(panelTab);ventana.pack();ventana.setVisible(true);

}}

Código fuente 136

Y el resultado de este código se puede apreciar en la Figura 80.

Figura 80


214

Si se prueba el ejemplo anterior se puede comprobar que no se ha escrito ningún código para realizar el tratamiento de eventos, la clase JTabbedPane realiza este tratamiento (mostrar los componentes de la pestaña seleccionada) de forma automática.

En el ejemplo se ha utilizado un constructor de la clase JTabbedPane que no utiliza ningún parámetro, pero existe otro constructor que permite, mediante una constante que recibe como parámetro, especificar la localización de las pestañas. Estas constantes se encuentran definidas en la clase JTabbedPane y son las siguientes TOP, BOTTOM, LEFT y RIGHT. Así si modificamos el ejemplo anterior cambiando el constructor utilizado para el panel JTabbedPane mediante la línea de código que aparece en el Código fuente 137.

JTabbedPane panelTab = new JTabbedPane(JTabbedPane.BOTTOM);

Código fuente 137

Obtenemos el resultado que vemos en la Figura 81.

Figura 81

Para añadir una nueva pestaña ya sabemos que debemos utilizar el método addTab(), este método presenta las siguientes versiones:

• addTab(String texto, Component componente): el primer argumento indica el texto que va a parecer en la pestaña y el componente que va a contener.

• addTab(String texto, Icon icono, Component componente): en este caso además se indica el icono que se va a mostrar en la pestaña.

• addTab(String texto, Icon icono, Component componente, String ayuda): en la última versión del método addTab() se permite especificar el texto que aparecerá a modo de ayuda (tooltip) cuando situemos el puntero del ratón sobre la pestaña.

En el ejemplo se ha utilizado el método setSelectedIndex() para indicar la pestaña que por defecto se encuentra seleccionada, que será la que mostrará sus componentes. Las pestañas comienzan a numerarse en cero.


215

Para manipular las pestañas la clase JTabbedPane ofrece los siguientes métodos:

• insertTab(String texto, Icon icono, Component componente, String ayuda, int índice): inserta una nueva pestaña en la posición indicada por el parámetro índice.

• removeTabAt(int índice): elimina la pestaña cuya posición coincida con la indicada.

• remove(Component componente): elimina la pestaña que contenga el componente especificado como argumento.

• removeAll(): elimina todas las pestañas.

• int indexOfTab(String texto): devuelve el índice de la pestaña que posea el texto indicado por parámetro.

• int getSelectedIndex(): devuelve el índice de la pestaña seleccionada actualmente.

También es posible modificar la apariencia de las pestañas del panel JTabbedPane. Podemos indicar el icono que va a mostrar la pestaña según se encuentre habilitada o deshabilitada, también el color de fondo y el del texto de la pestaña.

Así si una vez creado el panel de nuestro ejemplo añadimos las líneas de código que se muestran en el Código fuente 138 y obtenemos el resultado que aparece en la Figura 82.

//color de fondo cuando no está seleccionada la pestañapanelTab.setBackgroundAt(0,Color.red);//color del textopanelTab.setForegroundAt(0,Color.green);ImageIcon otroIcono = new ImageIcon("icono2.gif");//icono que se muestra cuando la pestaña está desactivadapanelTab.setDisabledIconAt(0,otroIcono);//se modifica el títulopanelTab.setTitleAt(2,"Otro texto");JPanel panelNuevo=new JPanel();panelNuevo.add(new JTextArea(5,30));//se cambia el componente que posee la pestañapanelTab.setComponentAt(3,panelNuevo);

Código fuente 138

Figura 82


216

Curioso resultado ya que no se muestra el icono que se utiliza para indicar que la pestaña está deshabilitada.

Si utilizamos cualquiera de los métodos anteriores ,que tiene como parámetro el índice de la pestaña, y la pestaña no existe se producirá una excepción.

JToolBar Esta clase representa una barra de herramientas, normalmente este tipo de contenedor va a contener botones con iconos dentro de una fila o columna. Estos botones cumplen las mismas funciones que las opciones de menú.

Por defecto el usuario puede arrastrar la barra de herramientas y situarla en los diferentes bordes del contenedor o bien como una ventana independiente. Para que este funcionamiento de arrastre de la barra sea correcto, el contenedor en el que se sitúa la barra de herramientas debe tener un gestor de diseño BorderLayout. Normalmente la barra de herramientas se añade en el norte del gestor de diseño y el componente al que afecta en el centro, no debe existir ningún componente más en el centro del contenedor.

En el Código fuente 139 se puede observar como se utiliza un objeto de la clase JToolBar. En nuestro caso vamos a tener una ventana (JFrame) que va a tener un panel de contenido al que se va a añadir la barra de herramientas (JToolBar) y un área de texto (JTextArea). Como se puede ver la barra de herramientas puede contener otros tipos de componentes, no sólo botones.

import java.awt.*;import java.awt.event.*;import javax.swing.*;public class BarraHerramientas{

public static void main(String s[]) {JFrame ventana = new JFrame("Ventana con barra de herramientas");//tratamiento de eventos para el cierre de la ventanaventana.addWindowListener(new WindowAdapter() {


}});//iconosImageIcon icono1=new ImageIcon("icono1.gif");ImageIcon icono2=new ImageIcon("icono2.gif");ImageIcon icono3=new ImageIcon("icono3.gif");//botonesJButton boton1=new JButton(icono1);JButton boton2=new JButton(icono2);JButton boton3=new JButton(icono3);//lista con elementosJComboBox combo=new JComboBox();combo.addItem("uno");combo.addItem("dos");combo.addItem("tres");//caja de textoJTextField caja=new JTextField("caja de texto");//barra de herramientasJToolBar barra=new JToolBar();//se añaden los botonesbarra.add(boton1);barra.add(boton2);barra.add(boton3);


217

//se añade el separador a la barra de herramientasbarra.addSeparator();barra.add(combo);barra.add(caja);//se añade la barra al panel de contenidoventana.getContentPane().add(barra,BorderLayout.NORTH);//se crea un área de textoJTextArea areaTexto = new JTextArea(5,30);//se añade a un panel de scrollJScrollPane scrollPane = new JScrollPane(areaTexto);//se añade el panel de scroll al panel de contenidoventana.getContentPane().add(scrollPane,BorderLayout.CENTER);//se asigna un tamaño preferido a la vetana((JPanel)ventana.getContentPane()).setPreferredSize(new Dimension(400,

100));ventana.pack();ventana.setVisible(true);

}}

Código fuente 139

El resultado se muestra en la Figura 83.

Figura 83

Como se puede comprobar en el código anterior, para añadir un separador a la barra de herramientas se utiliza el método addSeparator(). Si queremos que la barra de herramientas permanezca fija se puede lanzar sobre el objeto de la clase JToolBar el método setFloatable() pasando como argumento el valor false.

Para posicionar los distintos elementos que contiene, la clase JToolBar utiliza el gestor de diseño BoxLayout, que veremos más adelante en el apartado dedicado al mismo.

JLayeredPane Este contenedor ofrece una tercera dimensión que permite posicionar los componentes que contiene especificando una profundidad. La profundidad de un determinado componente se especifica mediante un entero, cuanto mayor sea este entero mayor será la profundidad del componente correspondiente. Si los componentes que contiene el panel de capas se superponen los componentes que se encuentran a una mayor profundidad se muestran encima de los de una menor profundidad.

Vimos que los contenedores de alto nivel de Swing contienen un panel de raíz que a su vez contiene un panel de capas (layered pane), normalmente no se suele utilizar el JLayeredPane del JRootPane, sino que se crea un objeto JLayeredPane distinto para utilizarlo dentro de otro panel. Esto mismo ocurre en nuestro ejemplo, que se sitúa un objeto de la clase JLayeredPane dentro del panel de contenido de una ventana (JFrame).


218

Para añadir un componente a un JLayeredPane se utiliza el método add(), en este método se debe indicar la profundidad del componente, es decir, la capa en la que se encuentra. En el siguiente ejemplo se van añadiendo a una instancia de la clase JLayeredPane etiquetas con color de fondo a distintas profundidades. Veamos el Código fuente 140.

import java.awt.*;import java.awt.event.*;import javax.swing.*;public class PanelCapas{

static private String[] textosCapa = { "Amarillo(0)", "Magenta (1)","Azul (2)", "Rojo (3)","Verde (4)" };

static private Color[] coloresCapa = { Color.yellow, Color.magenta,Color.blue, Color.red,Color.green };

public static void main(String s[]) {JFrame ventana = new JFrame("Ventana con panel de capas");JLayeredPane panelCapas=new JLayeredPane();//tratamiento de eventos para el cierre de la ventanaventana.addWindowListener(new WindowAdapter() {


}});//punto de origenPoint origen = new Point(10, 20);//separación entre etiquetasint separacion = 35;//se van creando las etiquetas de color a distinta profundidadfor (int i = 0; i < textosCapa.length; i++) {

JLabel etiqueta =creaEtiqueta(textosCapa[i],coloresCapa[i],origen);

//se añade la etiqueta al panel de capaspanelCapas.add(etiqueta,new Integer(i));origen.x += separacion;origen.y += separacion;}

//se indica un tamaño para le panelpanelCapas.setPreferredSize(new Dimension(300, 310));//se añade el panel creado al panel de contenido de la ventanaventana.getContentPane().add(panelCapas);ventana.pack();ventana.setVisible(true);

}//método para la creación de etiquetas con un texto y un color en un punto//de origen.private static JLabel creaEtiqueta(String texto,Color color,Point origen) {

JLabel etiqueta = new JLabel(texto);//se alinea el texto en la etiquetaetiqueta.setVerticalAlignment(JLabel.TOP);etiqueta.setHorizontalAlignment(JLabel.CENTER);etiqueta.setOpaque(true);etiqueta.setBackground(color);//se asigna un borde a la etiquetaetiqueta.setBorder(BorderFactory.createLineBorder(Color.black));etiqueta.setBounds(origen.x, origen.y, 140, 140);return etiqueta;

}}

Código fuente 140


219

El aspecto de esta ventana es el de la Figura 84.

Figura 84

Como se puede comprobar a la vista del código se han creado dos arrays que contienen por un lado los textos de las etiquetas y por otro los colores de las etiquetas. Se ha utilizado un bucle for para ir recorriendo estos arrays y crear las etiquetas mediante el método crearEtiqueta(). Como se puede ver el método y los atributos utilizado son estáticos, ya que los utilizamos directamente en el método main() si lanzarlos sobre una instancia de una clase.

Dentro de una capa, es decir, a una profundidad determinada, se puede especificar la posición de un componente. Es posible por lo tanto definir la posición de un componente respecto al resto de componentes dentro de la misma capa, para ello existe una versión del método add() que posee un tercer parámetro para indicar esta posición dentro de la capa.

El valor de esta posición va desde -1 hasta n-1, dónde n es el número de componentes dentro de la capa. Al contrario que las capas, cuanto menor es el número mayor es la profundidad del componente dentro de la capa. Utilizar -1 es equivalente a utilizar n-1, indica la posición más en el fondo. Si utilizamos 0 el componente se encontrará por encima del resto.

Si al ejemplo anterior le añadimos las líneas que muestra el Código fuente 141, una vez creadas las etiquetas en las distintas capas.

ImageIcon icono = new ImageIcon("imagen.gif");JLabel nuevaEtiqueta=new JLabel(icono);nuevaEtiqueta.setBounds(180,75,icono.getIconWidth(),icono.getIconHeight());panelCapas.add(nuevaEtiqueta,new Integer(2),0);

Código fuente 141


220

Lo que se hace es añadir una nueva etiqueta con un icono en la capa 2 de modo que quede por encima de la etiqueta de color que ya existía en esa misma capa. El nuevo aspecto del panel de capas es el que aparece en la Figura 85.

Figura 85

También es posible mover un componente de una capa a otra, para ello se utiliza el método setLayer(). Así si queremos mover la etiqueta con el icono a la capa 4 escribiremos lo que indica el Código fuente 142.

panelCapas.setLayer(nuevaEtiqueta,4,0);

Código fuente 142

El último argumento del método setLayer() es la posición del componente dentro de la nueva capa.

Para mover un componente dentro de una capa a la primera posición se utiliza el método moveToFront(), y para enviarlo al fondo el método moveToBack(), ambos métodos tiene como parámetro el componente al que se quiere cambiar de posición dentro de una capa. Si utilizamos el método moveToBack() en nuestro código anterior como indica el Código fuente 143, el nuevo aspecto del ejemplo es el de la Figura 86.

panelCapas.moveToBack(nuevaEtiqueta);

Código fuente 143


221

Con este último tipo de contenedor intermedio damos por terminado este apartado y este capítulo, en el siguiente capítulo seguimos tratando componentes Swing, en este caso los componentes atómicos, y también veremos otras aportaciones de Swing.

Figura 86

Interfaces de usuario en Java: componentes atómicos de Swing

Introducción Dentro de este capítulo vamos a tratar un gran grupo de componentes Swing, los componentes atómicos, no vamos a tratar todos ellos, ya que son muy numerosos y necesitaríamos como mínimo un par de capítulos más.

Veremos que estos componentes atómicos se agrupan a su vez en tres categorías, veremos ejemplos representativos de cada una de estas categorías.

Componentes atómicos Este grupo de componentes se corresponde con aquellos componentes cuya función es presentar o recibir información, en lugar de contener otros componentes, aunque es posible encontrar componentes atómicos que son la combinación de distintos componentes. Un ejemplo de componente atómico podría ser un botón, una caja de texto, una casilla de verificación, etc.

Todos los componentes atómicos heredan de la clase JComponent, debido a esto todos ellos soportan características estándar de los componentes Swing, como pueden ser bordes y tooltips.

Los componentes atómicos se subclasifican atendiendo a la labor que realizan.

Componentes que cuya misión principal es la de obtener información relativa a la entrada del usuario.


224

• JButton: un botón común.

• JCheckBox: una casilla de verificación.

• JRadioButton: un botón de opción que suelen utilizarse en grupos.

• JMenuItem: un elemento de un menú.

• JCheckBoxMenuItem: un elemento de menú que contiene una casilla de verificación.

• JRadioButtonMenuItem: un elemento de menú que contiene un botón de opción.

• JMenuBar: una barra de menú.

• JMenu: una opción de menú.

• JToggleButton: representa un botón con dos estados (pulsado/no pulsado).

• JComboBox: una lista desplegable.

• JList: una lista con elementos.

• JSlider: permite seleccionar al usuario un valor dentro de un rango determinado.

• JTextField: una caja de texto en la que el usuario puede escribir.

Componentes que existen únicamente para mostrar información:

• JLabel: etiqueta que puede mostrar texto, un icono o ambos.

• JProgressBar: barra que muestra el progreso de un proceso.

• JToolTip: muestra una breve descripción de un componente, aunque veremos en los distintos ejemplos que nunca vamos a utilizar directamente esta clase.

Componentes que muestran una información estructurada o que permiten editarla:

• JColorChooser: permite realizar la selección de un color determinado.

• JFileChooser: permite seleccionar ficheros y directorios.

• JTable: muestra la información en formato de tabla.

• JTextComponent: de esta clase heredan distintas clases especializadas en el tratamiento de textos.

• JTree: muestra datos organizados de forma jerárquica.

A lo largo de los siguientes apartados se van a mostrar algunos de estos componentes con sus respectivos ejemplos.

© Grupo EIDOS 12. Interfaces de usuario en Java: componentes atómicos de Swing

225

Componentes para obtener información Vamos a comenzar con algunos de los componentes atómicos de Swing cuya misión es la de obtener información a través de la entrada del usuario.

JButton Esta clase hereda de la clase AbstractButton, al igual que lo hacen otras clases como pueden ser JCheckbox, JMenuItem o JToggleButton. Por lo tanto la clase JButton posee una serie de funcionalidades que son comunes a todas las clases que heredan de la clase AbstractButton.

Un botón puede contener texto o imágenes o ambos elementos. El texto que contiene un botón se puede alinear con respecto a la imagen, también se pueden especificar teclas de teclado alternativas, que se indicarán mediante el subrayado de la letra del texto correspondiente.

Cuando un botón se encuentra deshabilitado el Look and Feel correspondiente genera de forma automática el aspecto del botón. Sin embargo, se puede indicar una imagen para que se muestre cuando el botón se encuentre deshabilitado.

Para ver la clase JButton en acción vamos a utilizar un ejemplo muy sencillo que consiste en mostrar tres botones con imágenes y ayudas (tooltips), la pulsación de dos de los tres botones activará o desactivará el botón central.

En el Código fuente 144 se muestra el código que crea estos botones y los añade a una ventana (JFrame), y además registra los oyentes de eventos correspondientes. Se han utilizado tres métodos a demás del método main(). El método creaBotones() instancia todas las instancias de los botones y los configura convenientemente, el método añadeBotones() añade los botones al panel de contenido de la ventana y el método actionPerformed() se encarga de los eventos de pulsación de los botones.

import java.awt.*;import java.awt.event.*;import javax.swing.*;public class Botones extends JFrame implements ActionListener{

private JButton botonIzq;private JButton botonDer;private JButton botonCentro;private ImageIcon iconoIzq=new ImageIcon("icono3.gif");private ImageIcon iconoDer=new ImageIcon("icono1.gif");private ImageIcon iconoCentro=new ImageIcon("icono2.gif");public Botones (){

super("Ventana con botones");this.addWindowListener(new WindowAdapter() {


}});

}public void creaBotones(){

//se instancia el botón indicando la imagenbotonIzq=new JButton("Desactiva botón central",iconoIzq);//se da formato al textobotonIzq.setVerticalTextPosition(AbstractButton.CENTER);botonIzq.setHorizontalTextPosition(AbstractButton.LEFT);//se indica la tecla asociada al botónbotonIzq.setMnemonic(KeyEvent.VK_D);


226

//se indica el comando de acción que se utiliza cuando se pulsa elbotón

botonIzq.setActionCommand("desactiva");//se asigna un tooltipbotonIzq.setToolTipText("Desactivo el botón central");botonIzq.setEnabled(false);botonDer=new JButton("Activa botón central",iconoDer);botonDer.setVerticalTextPosition(AbstractButton.CENTER);botonDer.setHorizontalTextPosition(AbstractButton.RIGHT);botonDer.setMnemonic(KeyEvent.VK_A);botonDer.setActionCommand("activa");botonDer.setToolTipText("Activo el botón central");botonCentro=new JButton("Botón central",iconoCentro);botonCentro.setEnabled(false);botonCentro.setToolTipText("No hago nada");//se registran los oyentes, que son la misma clase.botonIzq.addActionListener(this);botonDer.addActionListener(this);

}public void añadeBotones(){

//creamos un panel para añadir los botonesJPanel panelContenido=new JPanel();panelContenido.add(botonIzq);panelContenido.add(botonCentro);panelContenido.add(botonDer);//establecemos este panel como panel de contenido de la ventanasetContentPane(panelContenido);


if (evento.getActionCommand().equals("desactiva")){//se desactiva el botón central y se actualiza//el estado de los otros botonesbotonCentro.setEnabled(false);botonIzq.setEnabled(false);botonDer.setEnabled(true);

}else{//se activa el botón centralbotonCentro.setEnabled(true);botonIzq.setEnabled(true);botonDer.setEnabled(false);

}}public static void main(String s[]) {

Botones ventana = new Botones();ventana.creaBotones();ventana.añadeBotones();ventana.pack();ventana.setVisible(true);

}}

Código fuente 144

El aspecto que muestra la ventana se puede apreciar en la Figura 87.

Figura 87


227

Se puede comprobar si pulsamos las teclas Alt+D o Alt+A tienen el mismo efecto que pulsar el botón correspondiente, además esta combinación de teclas aparece descrita en el tooltip.

Podemos indicar el botón activo por defecto de un contenedor de alto nivel mediante el método setDefaultButton() de la clase JRootPane. El botón activo por defecto aparece destacado del resto y si el usuario pulsa la tecla Enter es equivalente a pulsar este botón. Podemos modificar el ejemplo anterior para que el botón activo por defecto sea el botón de la derecha.

getRootPane().setDefaultButton(botonDer);

Código fuente 145

Otra característica que nos ofrece la clase JButton es la posibilidad de utilizar etiquetas HTML dentro del texto del botón, para ello se debe poner la etiqueta <html> al inicio del texto, y a continuación se pueden utilizar las etiquetas HTML que se consideren necesarias para dar el formato conveniente al texto.

Así por ejemplo, si retomamos nuestro código anterior y modificamos las líneas en las que se crean los botones, escribiendo el Código fuente 146.

botonIzq=new JButton("<html><b><i><u>D</u>esactiva botón central</i><b>",iconoIzq);..........botonDer=new JButton("<html><font color='red' size='4'>"+

"<u>A</u>ctiva botón central</font>",iconoDer);...........botonCentro=new JButton("<html><small><i>Botón central</i></small>",iconoCentro);

Código fuente 146

Obtenemos la Figura 88.

Figura 88

Como se puede apreciar aunque los botones se encuentran desactivas, ahora el texto no aparece en color gris atenuado. Además hemos tenido que utilizar la etiqueta de subrayado de HTML (<u></u>) para indicar la tecla que se corresponde con cada botón.

JCheckbox Esta clase representa a las casillas de verificación, también se pueden utilizar estas casillas de verificación dentro de elementos de menú, mediante la clase JCheckBoxMenuItem. Debido a que la clase JCheckBox hereda de la clase AbstractButton, presenta una serie de características comunes a


228

todos los tipos de botones, que ya hemos visto en la sección anterior con la clase JButton. Estas características son la posibilidad de utilizar imágenes, tooltips, teclas alternativas, etc.

Las casillas de verificación se suelen agrupar y es posible seleccionar, una, algunas o ninguna de ellas. En el siguiente ejemplo se muestra la utilización de la clase JCheckBox para configurar el aspecto de un botón. Se dispone de tres casillas de verificación, una para indicar que el botón va a tener un icono, otra para indicar que tiene un tooltip y otra para indicar que tiene texto. El código se muestra en el Código fuente 147.

import java.awt.*;import java.awt.event.*;import javax.swing.*;public class Casillas extends JFrame implements ItemListener{

//cada una de las casillasprivate JCheckBox chkIcono;private JCheckBox chkTexto;private JCheckBox chkToolTip;//el botón del que indicamos el aspectoprivate JButton boton;//panel de las casillasprivate JPanel panelCasillas;//panel del botónprivate JPanel panelBoton;private ImageIcon icono=new ImageIcon("icono2.gif");public Casillas (){

super("Ventana con casillas de verificación");this.addWindowListener(new WindowAdapter() {public void windowClosing(WindowEvent e) {

System.exit(0);}});getContentPane().setLayout(new GridLayout(1,2));

}

public void creaCasillas(){panelCasillas=new JPanel();panelCasillas.setLayout(new GridLayout(3,1));

chkIcono=new JCheckBox("Icono");chkIcono.setMnemonic(KeyEvent.VK_I);chkIcono.setSelected(true);chkIcono.addItemListener(this);panelCasillas.add(chkIcono);

chkTexto=new JCheckBox("Texto");chkTexto.setMnemonic(KeyEvent.VK_T);chkTexto.setSelected(true);chkTexto.addItemListener(this);panelCasillas.add(chkTexto);chkToolTip=new JCheckBox("Tooltip");chkToolTip.setMnemonic(KeyEvent.VK_L);chkToolTip.setSelected(true);chkToolTip.addItemListener(this);panelCasillas.add(chkToolTip);getContentPane().add(panelCasillas);

}public void creaBoton(){

panelBoton=new JPanel();panelBoton.setLayout(new FlowLayout());boton=new JButton("Soy un botón",icono);boton.setToolTipText("Soy un botón");panelBoton.add(boton);getContentPane().add(panelBoton);

}


229

public void itemStateChanged(ItemEvent evento) {Object fuente=evento.getSource();int estado=evento.getStateChange();if (fuente==chkIcono){

if(estado==ItemEvent.DESELECTED)boton.setIcon(null);

elseboton.setIcon(icono);

}if (fuente==chkTexto){

if(estado==ItemEvent.DESELECTED)boton.setText("");

elseboton.setText("Soy un botón");

}if (fuente==chkToolTip){

if(estado==ItemEvent.DESELECTED)boton.setToolTipText("");

elseboton.setToolTipText("Soy un botón");


Casillas ventana = new Casillas();ventana.creaCasillas();ventana.creaBoton();ventana.pack();ventana.setVisible(true);

}}

Código fuente 147

Y el resultado es el de la Figura 89.

Figura 89

Como se puede observar la clase JButton lanza un evento del tipo ItemEvent cuando se modifica el estado de un objeto. En el método itemStateChanged() debemos averiguar primero la fuente del evento, es decir, la casilla que ha visto modificado su estado, y a continuación si la casilla en cuestión ha sido seleccionada o no.

JRadioButton Los botones de opción se suelen encontrar en grupos en los que, por convención, únicamente uno de los botones puede encontrarse seleccionado a un mismo tiempo. También podemos utilizar botones de opciones en elementos de menú mediante la clase JRadioButtonMenuItem.


230

La clase JRadioButton también tiene como superclase o clase padre a la clase AbstractButton, por lo tanto presentará el comportamiento común a todas las clases que heredan de AbstractButton, por ejemplo podemos indicar que un objeto JRadioButton muestre una imagen o un tooltip.

Para esta clase vamos a mostrar un ejemplo que ofrecerá un dibujo de un animal distinto según el botón de opción que se encuentre seleccionado en cada momento. Para agrupar los botones se utiliza la clase ButtonGroup.

Nuestro ejemplo va a contener tres botones de opción agrupados para mostrar tres dibujos distintos. En el Código fuente 148 se va a mostrar el fuente correspondiente.

import java.awt.*;import java.awt.event.*;import javax.swing.*;public class Opciones extends JFrame implements ActionListener{

//cada una de las Opcionesprivate JRadioButton opGato;private JRadioButton opCerdo;private JRadioButton opConejo;//imagenprivate JLabel imagen;//panel de las Opcionesprivate JPanel panelOpciones;//panel de la imagenprivate JPanel panelImagen;public Opciones (){

super("Ventana con opciones");this.addWindowListener(new WindowAdapter() {public void windowClosing(WindowEvent e) {

System.exit(0);}});getContentPane().setLayout(new GridLayout(1,2));

}

public void creaOpciones(){panelOpciones=new JPanel();panelOpciones.setLayout(new GridLayout(3,1));

opGato=new JRadioButton("Gato");opGato.setMnemonic(KeyEvent.VK_G);opGato.addActionListener(this);opGato.setActionCommand("gato.gif");panelOpciones.add(opGato);opCerdo=new JRadioButton("Cerdo");opCerdo.setMnemonic(KeyEvent.VK_C);opCerdo.setSelected(true);opCerdo.addActionListener(this);opCerdo.setActionCommand("cerdo.gif");panelOpciones.add(opCerdo);opConejo=new JRadioButton("Conejo");opConejo.setMnemonic(KeyEvent.VK_J);opConejo.addActionListener(this);opConejo.setActionCommand("conejo.gif");panelOpciones.add(opConejo);//se agrupan las opcionesButtonGroup grupo=new ButtonGroup();grupo.add(opGato);grupo.add(opCerdo);grupo.add(opConejo);getContentPane().add(panelOpciones);

}public void creaImagen(){

panelImagen=new JPanel();


231

panelImagen.setLayout(new BorderLayout());imagen = new JLabel(new ImageIcon("cerdo.gif"));imagen.setPreferredSize(new Dimension(177, 122));panelImagen.add(imagen,BorderLayout.CENTER);getContentPane().add(panelImagen);


String comando=evento.getActionCommand();imagen.setIcon(new ImageIcon(comando));

}public static void main(String s[]) {

Opciones ventana = new Opciones();ventana.creaOpciones();ventana.creaImagen();ventana.pack();ventana.setVisible(true);

}}

Código fuente 148

El resultado se puede comprobar en la Figura 90.

Figura 90

La clase JRadioButton, en lo que a tratamiento de eventos se refiere, funciona igual que la clase JButton, el botón que se pulse (seleccione) va a lanzar un evento de la clase ActionEvent, para diferenciar entre los distintos botones se utiliza el ActionCommand del evento ActionEvent. Para mostrar la imagen se utiliza una etiqueta (JLabel) con un icono (ImageIcon).

JComboBox Esta clase representa una lista desplegable de opciones, que puede ser editable o no. Cuando el usuario pulsa la lista, el objeto JComboBox muestra un menú de elementos para elegir.

Una lista desplegable editable es similar a una caja de texto (JTextField) con un pequeño botón. El usuario puede escribir un valor en la caja de texto o elegir un valor del menú.

En nuestro caso vamos a ver un ejemplo de una lista desplegable no editable. El ejemplo va a tener la misma funcionalidad que el utilizado para la clase JRadioButton, es decir, vamos a tener distintas opciones que van a mostrar un dibujo determinado.

El código fuente completo del ejemplo es el Código fuente 149, y el resultado se muestra en la Figura 91.


232

import java.awt.*;import java.awt.event.*;import javax.swing.*;public class Combo extends JFrame implements ActionListener{

//lista desplegableprivate JComboBox listaOpciones;//opciones de la listaString[] opciones={"Gato","Cerdo","Conejo"};//imagenprivate JLabel imagen;public Combo(){

super("Ventana con lista desplegable");this.addWindowListener(new WindowAdapter() {


}});

}public void creaCombo(){

listaOpciones=new JComboBox(opciones);listaOpciones.setSelectedIndex(0);getContentPane().add(listaOpciones,BorderLayout.NORTH);listaOpciones.addActionListener(this);

}public void creaImagen(){

imagen = new JLabel(new ImageIcon("gato.gif"));imagen.setPreferredSize(new Dimension(177, 122));getContentPane().add(imagen,BorderLayout.CENTER);


JComboBox fuente=(JComboBox)evento.getSource();//se obtiene el elemento seleccionadoString seleccion=(String)fuente.getSelectedItem();//se cambia la imagenimagen.setIcon(new ImageIcon(seleccion+".gif"));


Combo ventana = new Combo();ventana.creaCombo();ventana.creaImagen();ventana.pack();ventana.setVisible(true);

}}

Código fuente 149

Figura 91


233

Al seleccionar un elemento del objeto JComBox se lanza un evento ActionEvent, es decir, el mismo evento que se lanza cuando se pulsa un botón.

El constructor utilizado para instanciar un objeto de la clase JComboBox recibe como argumento un array de cadenas (String), que representa las opciones que muestra la lista desplegable.

Para indicar la opción seleccionada por defecto utilizamos el método setSelectedIndex() sobre el objeto de la clase JComboBox, y para obtener la opción seleccionada y así mostrar la imagen correspondiente se utiliza el método getSelectedItem() de la clase JComboBox.

JMenu Un menú permite elegir al usuario entre múltiples opciones disponibles. Los menús parecen normalmente dentro de barras de menú o como menús contextuales (menú popup).

Un elemento de menú hereda también de la clase AbstractButton, como muchas de las clases que hemos visto hasta ahora, veamos en la Figura 92, la jerarquía que presentan los distintos componentes Swing relacionados con la creación de menús.

Figura 92

A continuación se comentan cada una de estas clases.

• JMenuBar: representa la barra de menú que va a contener los distintos elementos de menú, que serán objetos de la clase JMenu.

• JMenu: es una opción de menú determinada, que contiene varios elementos de menú, que serán objetos de la clase JMenuItem, y también puede contener submenús, es decir, objetos de la clase JMenu.

• JMenuItem: es un elemento de menú.

• JCheckBoxMenuItem: elemento de menú que posee una casilla de verificación.


234

• JRadioButtonMenuItem: elemento de menú que posee un botón de opción.

• JSeparator: elemento de menú especial que ofrece una separación entre elementos de menú de una misma opción de menú.

• JPopupMenu: representa un menú contextual o de aparición súbita, contiene elementos de menú (JMenuItem).

En el Código fuente 150 se muestra la utilización de todas estas clases, además se va mostrando en un área de texto (JTextArea) los distintos eventos que van generando los distintos componentes de menú junto con la fuente que ha producido dichos eventos. Como ocurre en estos casos primero se muestra el código fuente del ejemplo.

import java.awt.*;import java.awt.event.*;import javax.swing.*;public class Menus extends JFrame implements ActionListener, ItemListener{

JMenuBar barraMenu;JMenu menu, submenu;JMenuItem elementoMenu;JRadioButtonMenuItem rbElementoMenu;JCheckBoxMenuItem cbElementoMenu;JTextArea texto;JScrollPane panelScroll;public Menus(){

super("Ventana con múltiples menús");this.addWindowListener(new WindowAdapter() {


}});

}public void creaMenu(){

//Se crea la barra de menúbarraMenu = new JMenuBar();setJMenuBar(barraMenu);

//se crea el primer menúmenu = new JMenu("Un Menú");

menu.setMnemonic(KeyEvent.VK_E);barraMenu.add(menu);//unos cuantos elementos de menú

elementoMenu=new JMenuItem("Elemento de menú de texto",KeyEvent.VK_E);elementoMenu.addActionListener(this);menu.add(elementoMenu);//se asigna tecla de acceso rápidoelementoMenu.setAccelerator(KeyStroke.getKeyStroke(

KeyEvent.VK_1, ActionEvent.ALT_MASK));

elementoMenu=new JMenuItem("Texto e icono",newImageIcon("icono2.gif"));

elementoMenu.setMnemonic(KeyEvent.VK_T);elementoMenu.addActionListener(this);menu.add(elementoMenu);

elementoMenu=new JMenuItem(new ImageIcon("icono2.gif"));elementoMenu.setMnemonic(KeyEvent.VK_D);elementoMenu.addActionListener(this);menu.add(elementoMenu);//se añade un separadormenu.addSeparator();//un grupo de elementos de menú de botones de opción.ButtonGroup grupo=new ButtonGroup();rbElementoMenu=new JRadioButtonMenuItem("Botón de opción");


235

rbElementoMenu.setSelected(true);rbElementoMenu.setMnemonic(KeyEvent.VK_O);grupo.add(rbElementoMenu);rbElementoMenu.addActionListener(this);menu.add(rbElementoMenu);rbElementoMenu= new JRadioButtonMenuItem("Otro botón de opción");rbElementoMenu.setMnemonic(KeyEvent.VK_B);grupo.add(rbElementoMenu);rbElementoMenu.addActionListener(this);menu.add(rbElementoMenu);

//Un grupo de casillas de verificaciónmenu.addSeparator();cbElementoMenu=new JCheckBoxMenuItem("Casilla de verificación");cbElementoMenu.setMnemonic(KeyEvent.VK_C);cbElementoMenu.addItemListener(this);menu.add(cbElementoMenu);

cbElementoMenu=new JCheckBoxMenuItem("Otro más");cbElementoMenu.setMnemonic(KeyEvent.VK_M);cbElementoMenu.addItemListener(this);menu.add(cbElementoMenu);//un submenú

menu.addSeparator();submenu=new JMenu("Un submenú");submenu.setMnemonic(KeyEvent.VK_S);elementoMenu=new JMenuItem("Un elemento de menú del submenú");elementoMenu.setAccelerator(KeyStroke.getKeyStroke(

KeyEvent.VK_2, ActionEvent.ALT_MASK));elementoMenu.addActionListener(this);submenu.add(elementoMenu);elementoMenu= new JMenuItem("Otro elemento de menú");elementoMenu.addActionListener(this);submenu.add(elementoMenu);menu.add(submenu);//Segúndo menú de la barra de menúmenu = new JMenu("Otro Menú");menu.setMnemonic(KeyEvent.VK_M);barraMenu.add(menu);

}public void creaTexto(){

texto= new JTextArea(10, 50);texto.setEditable(false);panelScroll= new JScrollPane(texto);getContentPane().add(panelScroll, BorderLayout.CENTER);


JMenuItem fuente=(JMenuItem)(evento.getSource());String mensaje= "ActionEvent detectado.\n"

+ " Fuente del evento: " + fuente.getText()+"\n";texto.append(mensaje);

}public void itemStateChanged(ItemEvent evento) {

String estado="";JMenuItem fuente =(JMenuItem)(evento.getSource());if (evento.getStateChange()==ItemEvent.SELECTED)

estado="Seleccionado";else

estado="No seleccionado";String mensaje="ItemEvent detectado.\n"

+ " Fuente del evento: " + fuente.getText()+"\n"+ " Nuevo estado: "+estado+"\n";

texto.append(mensaje);}public static void main(String s[]) {

Menus ventana = new Menus();ventana.creaMenu();ventana.creaTexto();ventana.pack();


236

ventana.setVisible(true);}

}

Código fuente 150

Y a continuación un ejemplo de ejecución.

Figura 93

En la Figura 94 se puede ver más clara toda la estructura del menú.

Figura 94

Los elementos de menú lanzan eventos ActionEvent, y los elementos de menú del tipo JCheckBoxMenuItem lanzan eventos de la clase ItemEvent.

El área de texto (JTextArea) encargada de ir mostrando los eventos que se producen se añade a un panel de scroll (ScrollPane).

Como se puede ver se han añadido dos teclas rápidas mediante el método setAccelerator().


237

Un contextual o de aparición súbita (popup) se encuentra representado por la clase JPopupMenu y debe registrarse un oyente de ratón en cada componente que tenga asociado el menú popup, el oyente debe detectar que el usuario a pulsado el botón derecho del ratón para mostrar el menú contextual correspondiente.

El oyente que se ocupa de mostrar el menú contextual lanza el método show() sobre la instancia correspondiente de la clase JPopupMenu. El método show() recibe como parámetros el componente al que se asocia el menú y las coordenadas de la pantalla en la que se quiere mostrar el menú contextual.

Vamos a modificar el ejemplo anterior en el que utilizábamos la barra de menú y vamos a añadir un menú contextual (JPopupMenu) que se asociará al área de texto (JTextArea) en la que se muestran los eventos lanzados por los distintos elementos de menú.

Se va añadir un nuevo atributo a nuestra clase, llamado menuPopup que pertenece a la clase JPopupMenu. También se va a añadir un nuevo método llamado creaPopup() y cuyo código se muestra en el Código fuente 151.

public void creaPopup(){menuPopup=new JPopupMenu();//se crean y añadden los distinos elementos de menú de la misma maneraelementoMenu=new JMenuItem("Primer elemento del popup",KeyEvent.VK_P);elementoMenu.addActionListener(this);menuPopup.add(elementoMenu);elementoMenu=new JMenuItem("Segundo del popup",new

ImageIcon("icono2.gif"));elementoMenu.setMnemonic(KeyEvent.VK_S);elementoMenu.addActionListener(this);menuPopup.add(elementoMenu);menuPopup.addSeparator();cbElementoMenu=new JCheckBoxMenuItem("Tercer elemento");cbElementoMenu.setMnemonic(KeyEvent.VK_T);cbElementoMenu.addItemListener(this);menuPopup.add(cbElementoMenu);//se crea el oyente y se registra para el área de textoPopupListener oyente=new PopupListener();texto.addMouseListener(oyente);

}

Código fuente 151

Este método se puede lanzar una vez utilizado el método creaTexto().

Como se puede observar se crea una instancia de un objeto de la clase PopupListener, esta clase es una clase interna que hereda de la clase MouseAdapter y que va a ser el oyente de nuestro menú contextual y el que va a mostrarlo. El código de esta clase adaptadora interna es el Código fuente 152.

class PopupListener extends MouseAdapter{public void mousePressed(MouseEvent evento){

menuPopup.show(evento.getComponent(),evento.getX(),evento.getY());}

}

Código fuente 152


238

Y un ejemplo de la utilización del menú contextual se puede observar en la Figura 9.

Figura 9

Como se puede comprobar a la vista de la figura anterior, seguimos recogiendo los eventos de los distintos elementos de menú, incluso del menú contextual.

Pero si el lector prueba este ejemplo comprobará que el menú contextual parecerá también cuando se pulse el botón izquierdo del ratón, y no sólo cuando se pulse el botón derecho, que sería lo deseable. La clase MouseEvent ofrece el método isPopupTrigger() para averiguar si debemos mostrar el menú popup o no.

El método isPopupTrigger() devolverá verdadero si la pulsación del ratón se corresponde con un evento que debe mostrar un menú contextual, en el caso de Windows se corresponde con el botón derecho del ratón. Así nuestro código fuente del adaptador del ratón quedaría como se muestra en el Código fuente 10.

class PopupListener extends MouseAdapter{public void mousePressed(MouseEvent evento){

if (evento.isPopupTrigger()){

menuPopup.show(evento.getComponent(),evento.getX(),evento.getY());}

}}

Código fuente 10

La sorpresa es que ahora no se muestra nunca el menú contextual, no con le botón derecho ni con el botón derecho del ratón, la verdad no he conseguido discernir porque no aparece. No vamos a mostrar de nuevo como quedaría todo el código fuente completo del ejemplo modificado, pero en el siguiente enlace se puede obtener.

JSlider Este componente permite al usuario seleccionar un valor numérico entre un rango determinado, este componente se utiliza para restringir los valores que puede ofrecer el usuario y así evitar errores y el tratamiento de los mismos.


239

Para mostrar el funcionamiento de este componente Swing se ha utilizado un ejemplo en el que según se indique en el selector (JSlider) se dará un tamaño determinado a un botón (JButton), el botón se redimensionará según se indique en el selector.

Ahora vamos a ver el código, en el Código fuente 154, y más tarde lo comentaremos.

import java.awt.*;import java.awt.event.*;import javax.swing.*;//eventos nuevos de Swingimport javax.swing.event.*;public class Selector extends JFrame implements ChangeListener{

//selector de valoresprivate JSlider selector;private JButton boton;public Selector(){

super("Ventana con selector (JSlider)");this.addWindowListener(new WindowAdapter() {


}});

}

public void creaSelector(){selector=new JSlider(JSlider.HORIZONTAL,0,300,50);selector.addChangeListener(this);selector.setMajorTickSpacing(100);selector.setMinorTickSpacing(10);selector.setPaintTicks(true);selector.setPaintLabels(true);getContentPane().add(selector,BorderLayout.NORTH);


boton=new JButton("Soy un botón");JPanel panel=new JPanel();panel.setLayout(new FlowLayout());panel.add(boton);getContentPane().add(panel,BorderLayout.CENTER);boton.setSize(50,50);

}public void stateChanged(ChangeEvent evento){

JSlider fuente=(JSlider)evento.getSource();if (!fuente.getValueIsAdjusting()){

boton.setSize((int)fuente.getValue(),(int)fuente.getValue());}


Selector ventana = new Selector();ventana.creaSelector();ventana.creaBoton();ventana.setSize(310,310);ventana.setVisible(true);

}}

Código fuente 154

Un ejemplo de la ejecución de esta sencilla aplicación la tenemos en la Figura 96.


240

Figura 96

A la vista del código se pueden hacer los siguientes comentarios y apreciaciones.

El constructor utilizado para crear el objeto de la clase JSlider, posee un argumento para indicar la orientación del selector correspondiente, se corresponde con las constantes HORIZONTAL y VERTICAL de la clase JSlider. Los siguientes argumentos, especifican respectivamente, el valor mínimo, el valor máximo y el valor seleccionado inicialmente del objeto JSlider. Si no indicamos estos valores, el valor mínimo del selector será 0, el máximo 100 y el seleccionado inicialmente 50.

Para configurar inicialmente el objeto de la clase JSlider, hemos utilizado una serie de métodos:

• setMajorTickSpacing(int espaciado): este método nos permite indicar las separaciones mayores entre el máximo y el mínimo del selector.

• setMinorTickSpacing(int espaciado); este método indica las separaciones menores entre el rango indicado para el componente Swing JSlider.

• setPaintTicks(boolean): mediante este método indicamos si deseamos o no que parezcan las separaciones del objeto JSlider.

• setPaintLabels(boolean): nos permite indicar si queremos que se pinten las diferentes etiquetas del rango.

Para registrar el oyente del selector hemos utilizado el método addChangeListener(), ya que la clase JSlider lanza eventos de la clase ChangeEvent. Este es un nuevo tipo de evento que se incluye en el paquete javax.swing.event y se lanza cuando se modifica el valor actual de un objeto de la clase JSlider.

El método que debe implementar un oyente de eventos ChangeEvent es el método stateChanged(). En el ejemplo anterior hemos visto que se ha utilizado el método getValueIsAdjusting() de la clase JSlider, este método devuelve verdadero mientras se esté seleccionando el valor del objeto JSlider, de esta forma no se redimensionará el botón hasta que el usuario no haya finalizado de arrastrar el tirador del selector, es decir, cuando el usuario ha finalizado con el proceso de selección.


241

Las etiquetas que aparecen en el selector las podemos personalizar con la ayuda del método setLabelTable() de la clase JSlider y de un objeto de la clase Hashtable. Para utilizar la clase Hashtable debemos importar el paquete

Primero crearemos un objeto que representa una tabla hash y mediante el método put() vamos indicando la posición que queremos que ocupe la etiqueta y el objeto JLabel que va a mostrar el texto correspondiente. Veamos, en el Código fuente 155, un sencillo código que podemos añadir a nuestro ya conocido ejemplo para mostrar cuatro etiquetas personalizadas.

public void creaSelector(){selector=new JSlider(JSlider.HORIZONTAL,0,300,50);selector.addChangeListener(this);selector.setMajorTickSpacing(100);selector.setPaintTicks(true);//tabla de etiquetasHashtable etiquetas=new Hashtable();etiquetas.put(new Integer(0),new JLabel("Minúsculo"));etiquetas.put(new Integer(100),new JLabel("Pequeño"));etiquetas.put(new Integer(200),new JLabel("Mediano"));etiquetas.put(new Integer(300),new JLabel("Grande"));//asignamos las etiquetas al selectorselector.setLabelTable(etiquetas);selector.setPaintLabels(true);getContentPane().add(selector,BorderLayout.NORTH);

}

Código fuente 155

Si utilizamos esta nueva versión del método creaSelector() obtenemos el resultado que se muestra en la Figura 97.

Figura 97


242

Con la clase JSlider se da por terminado el apartado dedicado al grupo de componentes Swing cuya función es la de recoger la entrada del usuario, a continuación vamos a comentar algunos componentes atómicos cuya función es la de simplemente mostrar información al usuario, algunos de los representantes de este grupo que vamos a tratar a continuación ya los conoceremos de ejemplos anteriores, como ocurre con el componente JLabel.

Componentes para mostrar información Se ofrecen distintos ejemplos de componentes Swing encargados de mostrar información.

JLabel Ya hemos utilizado numerosas veces este útil y sencillo componente de Swing, como ya sabemos su labor es la de mostrar una información al usuario, ya sea textual o con imágenes o con ambos elementos.

En el siguiente ejemplo se muestra la utilización de la clase JLabel creando cuatro objetos distintos de esta clase, se ha añadido un borde a cada etiqueta para que se distingan claramente unas de otras. El código es el que aparece en el Código fuente 156.

import java.awt.*;import java.awt.event.*;import javax.swing.*;public class Etiquetas extends JFrame{

private JLabel etiqueta1;private JLabel etiqueta2;private JLabel etiqueta3;private JLabel etiqueta4;private ImageIcon icono;public Etiquetas(){

super("Ventana con etiquetas");this.addWindowListener(new WindowAdapter() {


}});

}

public void creaEtiquetas(){icono=new ImageIcon("icono2.gif");etiqueta1=new JLabel("Imagen y texto",icono,JLabel.CENTER);etiqueta1.setVerticalTextPosition(JLabel.BOTTOM);etiqueta1.setHorizontalTextPosition(JLabel.CENTER);etiqueta1.setBorder(BorderFactory.createLineBorder(Color.red));etiqueta2=new JLabel("Sólo texto");etiqueta2.setHorizontalAlignment(JLabel.RIGHT);etiqueta2.setVerticalAlignment(JLabel.TOP);etiqueta2.setBorder(BorderFactory.createLineBorder(Color.blue));etiqueta3=new JLabel(icono);etiqueta3.setBorder(BorderFactory.createLineBorder(Color.green));etiqueta4=new JLabel("Imagen y texto",icono,JLabel.CENTER);etiqueta4.setVerticalTextPosition(JLabel.TOP);etiqueta4.setHorizontalTextPosition(JLabel.CENTER);etiqueta4.setBorder(BorderFactory.createLineBorder(Color.pink));

}public void añadeEtiquetas(){

getContentPane().setLayout(new GridLayout(1,4,5,5));


243

getContentPane().add(etiqueta1);getContentPane().add(etiqueta2);getContentPane().add(etiqueta3);getContentPane().add(etiqueta4);


Etiquetas ventana = new Etiquetas();ventana.creaEtiquetas();ventana.añadeEtiquetas();ventana.pack();ventana.setVisible(true);

}}

Código fuente 156

Y el resultado se puede comprobar en la Figura 98.

Figura 98

Como se puede observar en el ejemplo anterior es posible especificar la alineación del texto respecto a la imagen que contiene la etiqueta utilizando el método setVerticalTextPosition() y setHorizontalTextPostion(), y mediante las constantes LEFT, CENTER, RIGHT, TOP y BOTTOM. El valor por defecto es centrado (CENTER).

También se puede indicar la alineación de los componentes dentro de la etiqueta con los métodos setHorizontalAlignment() y setVerticalAlignment().

Al igual que sucedía con la clase JButton, con los componentes JLabel podemos utilizar código HTML para indicar el formato del texto que se va a mostrar. Veamos un ejemplo, en el Código fuente 157, que hace uso de esta característica. El aspecto de las etiquetas es el que muestra la Figura 99.

import java.awt.*;import java.awt.event.*;import javax.swing.*;public class Etiquetas extends JFrame{

private JLabel etiqueta1;private JLabel etiqueta2;private JLabel etiqueta3;private JLabel etiqueta4;private ImageIcon icono;public Etiquetas(){

super("Ventana con etiquetas");this.addWindowListener(new WindowAdapter() {


}});

}

public void creaEtiquetas(){icono=new ImageIcon("icono2.gif");


244

etiqueta1=new JLabel("<html><font size='4' color='red'><b><i>"+"Imagen y texto</b></i></font>",icono,JLabel.CENTER);

etiqueta1.setVerticalTextPosition(JLabel.BOTTOM);etiqueta1.setHorizontalTextPosition(JLabel.CENTER);etiqueta1.setBorder(BorderFactory.createLineBorder(Color.red));etiqueta2=new JLabel("<html><ul><li>Elemento 1<li>Elemento2</ul>");etiqueta2.setBorder(BorderFactory.createLineBorder(Color.blue));etiqueta3=new JLabel("<html><table border='1'><tr><td>Celda 1</td>"+"<td>Celda2</td></tr><tr><td align='center' colspan='2'>Celda

3</td>"+"</tr></table>", JLabel.CENTER);

etiqueta3.setBorder(BorderFactory.createLineBorder(Color.green));etiqueta4=new JLabel("<html><h2><i>Imagen y texto</i></h2><hr>",

icono,JLabel.CENTER);etiqueta4.setVerticalTextPosition(JLabel.TOP);etiqueta4.setHorizontalTextPosition(JLabel.CENTER);etiqueta4.setBorder(BorderFactory.createLineBorder(Color.pink));

}public void añadeEtiquetas(){

getContentPane().setLayout(new GridLayout(4,1,15,15));getContentPane().add(etiqueta1);getContentPane().add(etiqueta2);getContentPane().add(etiqueta3);getContentPane().add(etiqueta4);


Etiquetas ventana = new Etiquetas();ventana.creaEtiquetas();ventana.añadeEtiquetas();ventana.setSize(300,450);ventana.setVisible(true);

}}

Código fuente 157

Figura 99


245

JToolTip Dentro del grupo de componentes atómicos de Swing encargados exclusivamente de mostrar información, también podemos encontrar la clase JToolTip, esta clase representa las pequeñas ayudas que se muestran en forma de pequeño texto explicativo (tooltip) cuando nos situamos sobre un componente determinado.

Aunque realmente no vamos a utilizar nunca directamente la clase JToolTip, sino que utilizaremos los métodos setToolTipText() y getTootTipText() de la clase JComponent, ya hemos visto la utilización de estos métodos en ejemplos anteriores, con el primero asignamos un tooltip a un componente Swing y con el segundo obtenemos el tooltip que tiene asignando un componente Swing determinado.

JProgressBar Este componente Swing muestra gráficamente el progreso de una operación determinada, la barra de progreso va mostrando el porcentaje de tarea que se ha realizado, nos va informando de la evolución de un proceso.

Al crear una instancia de la clase JProgressBar podemos indicar la orientación que va a tener la barra de progreso, para ello se utilizan las constantes HORIZONTAL y VERTICAL de la clase JProgressBar. También podemos indicar el máximo y el mínimo de la barra de progreso. Los máximos y mínimos los podemos manipular con los métodos getMinumum()/setMinimum() y getMaximum()/setMaximum().

Para incrementar el valor actual de la barra de progreso, que se corresponde con el proceso actual, disponemos del método setValue().

A continuación se ofrece un sencillo ejemplo que consiste en ir pulsando un botón que incrementará por cada pulsación el valor actual de la barra de progreso. Al llegar al máximo se emitirá un sonido y después se volverá la barra de progreso a su estado inicial.

El código que presenta este ejemplo es el Código fuente 158.

import java.awt.*;import java.awt.event.*;import javax.swing.*;public class BarraProgreso extends JFrame implements ActionListener{

private JProgressBar barra;//valor que se va incrementandoprivate int valor;private JButton boton;public BarraProgreso(){

super("Ventana con barra de progreso");this.valor=0;this.addWindowListener(new WindowAdapter() {


}});

}

public void creaBarra(){//una barra de mínimo 0 y máximo 100barra=new JProgressBar(JProgressBar.HORIZONTAL,0,100);//valor inicial


246

barra.setValue(0);//indicamos que aparecen las etiquetas del progresobarra.setStringPainted(true);getContentPane().add(barra,BorderLayout.NORTH);


boton=new JButton("Incrementar");JPanel panel=new JPanel();panel.setLayout(new FlowLayout());panel.add(boton);boton.addActionListener(this);getContentPane().add(panel,BorderLayout.CENTER);

}public void actionPerformed(ActionEvent event){

//se incrementa el valorvalor=valor+10;if (valor>barra.getMaximum()){

//hemos sobrepasado el máximo de la barra de progresobarra.setValue(barra.getMinimum());valor=barra.getMinimum();

}else{

barra.setValue(valor);if(valor==barra.getMaximum())

//se emite un pitido al llegar al máximoToolkit.getDefaultToolkit().beep();


BarraProgreso ventana = new BarraProgreso();ventana.creaBarra();ventana.creaBoton();ventana.setSize(200,200);ventana.setVisible(true);

}}

Código fuente 158

Un ejemplo de ejecución este código se ofrece en la Figura 100.

Figura 100

Como se puede comprobar en el ejemplo, la barra de progreso muestra el tanto por ciento (%) de la operación realizada, este tanto por ciento lo calcula teniendo en cuenta el valor actual y sus valores


247

máximo y mínimo. Para que se muestre el etiqueta del tanto por ciento se ha utilizado el método setStringPainted() pasándole como argumento el valor true.

Podemos mostrar en la barra de progreso cualquier texto mediante el método setString() de la clase JProgressBar y así variar el comportamiento por defecto de la barra de progreso.

Para obtener el tanto por ciento de la tarea realizada (completada) representada por la barra de progreso disponemos del método getPercentComplete().

Este es el último de los componentes Swing pertenecientes al grupo de componentes encargados de mostrar información, los siguientes componentes pertenecen al grupo de los componentes atómicos que muestran también una información pero de una forma más compleja y estructurada, además en algunos casos permiten editar esta información.

Componentes que muestran información estructurada En este último apartado se van a tratar dos componentes JColorChooser y JFileChooser que permiten seleccionar un color determinado y un fichero del sistema de ficheros, respectivamente.

JColorChooser Este componente Swing además de ofrecer una información estructurada, como pueden ser los distintos colores, nos permite seleccionar un elemento determinado de esa información.

La clase JColorChooser representa un componente Swing atómico, pero bastante complejo y completo que permite seleccionar colores de distintas formas. Además este componente permite mostrar de forma sencilla un diálogo que permite seleccionar también un color. Veremos dos ejemplos de las dos formas que podemos utilizar el componente JColorChooser: como si se tratara de otro componente más o como un diálogo.

En el Look & Feel de Java (en el apartado correspondiente hablaremos de los distintos Look & Feel y como establecerlos) una instancia de la clase JColorChooser muestra el siguiente aspecto: se encuentra dividido en dos partes, un panel con pestañas (JTabbedPane) y un panel con la muestra de la selección (preview). El panel de selección con pestañas encuentra en la parte superior y presenta tres pestañas, cada una de ellas permite una forma distinta de seleccionar los colores.

El panel de muestra se encuentra en la parte inferior y va mostrando el color seleccionado en cada momento del panel de selección.

Para poder tratar la selección actual el componente JColorChooser hace uso de una clase llamada ColorSelectionModel que se encuentra en el subpaquete de Swing denominado javax.swing.color-chooser.

El modelo de selección de color (instancia de la clase ColorSelectionModel), lanza un evento de la clase ChangeEvent (este evento vimos que también era lanzado por el componente JSlider) cada vez que se cambia la selección del color en el selector de color (JColorChooser).

Si queremos detectar los cambios de selección de color del componente JColorChooser debemos registrar el oyente correspondiente al evento ChageEvent, pero no se debe hacer directamente sobre el componente JColorChooser, sino sobre su ColorSelectionModel. Para obtener la instancia de la clase ColorSelectionModel correspondiente a un objeto de la clase JColorChooser, debemos lanzar sobre el objeto JColorChooser el método getSelectionModel().


248

Pasemos ahora a ver un código de ejemplo que utiliza un objeto de la clase JColorChooser para configurar el color del texto de una etiqueta.

import java.awt.*;import java.awt.event.*;import javax.swing.*;import javax.swing.event.*;import javax.swing.colorchooser.*;public class SelectorColor extends JFrame implements ChangeListener{

private JLabel etiqueta;private JColorChooser selectColor;public SelectorColor() {

super("Selector de color");this.addWindowListener(new WindowAdapter() {


}});

}

public void creaEtiqueta(){//Configuramos la etiqueta sobre la que se aplica la selección de

coloretiqueta= new JLabel("La Plataforma Java 2",JLabel.CENTER);

etiqueta.setForeground(Color.green);etiqueta.setBackground(Color.white);etiqueta.setOpaque(true);etiqueta.setFont(new Font("SansSerif", Font.BOLD, 24));etiqueta.setPreferredSize(new Dimension(80,45));//panel con borde que va a contener la etiquetaJPanel etiquetaPanel = new JPanel(new BorderLayout());etiquetaPanel.add(etiqueta, BorderLayout.CENTER);etiquetaPanel.setBorder(BorderFactory.createTitledBorder("etiqueta"));getContentPane().add(etiquetaPanel, BorderLayout.CENTER);

}public void creaSelectorColor(){

selectColor= new JColorChooser(etiqueta.getForeground());//se obtiene el modelo de seleción de color para registrar el oyente//de los eventos ChangeEventselectColor.getSelectionModel().addChangeListener(this);selectColor.setBorder(BorderFactory.createTitledBorder

("Selecciona el color del texto"));getContentPane().add(selectColor,BorderLayout.SOUTH);

}public void stateChanged(ChangeEvent e) {

etiqueta.setForeground(selectColor.getColor());}public static void main(String[] args) {

SelectorColor ventana = new SelectorColor();ventana.creaEtiqueta();ventana.creaSelectorColor();ventana.pack();ventana.setVisible(true);

}}

Código fuente 159

El aspecto del ejemplo es el de la Figura 101


249

Figura 101

Como se puede comprobar en el ejemplo el constructor utilizado de la clase JColorChooser recibe como parámetro un color, este es el color seleccionado inicialmente dentro del selector de color. En nuestro caso le hemos indicado el color de la letra de la etiqueta sobre la que se va a aplicar las distintas selecciones de color.

El método stateChanged(), que se lanzará cada vez que se cambie la selección de color del selector de color, recupera el color actual mediante el método getColor() de la clase JColorChooser, y se lo aplica al texto de la etiqueta mediante el método setForeground().

En la ejecución del ejemplo se puede observar las tres formas distintas de seleccionar el color que permite el componente JColorChooser, en la Figura 102 se puede ver otra selección distinta, utilizando el formato de color RGB.

En este caso el componente JColorChooser lo hemos tratado como otro componente atómico más, añadiéndolo al panel de contenido de la ventana, pero también podemos mostrarlo como un diálogo, para ello podemos utilizar el método estático showDialog() de la clase JColorChooser.

La sintaxis de este método es:

JColorChooser.showDialog(Component padre, String título, Colorcolor)


250

Figura 102

El primer argumento de este método es el componente padre del diálogo (el componente del que depende), el segundo el título del diálogo y el tercero el color seleccionado por defecto en el diálogo de selección de color.

Ahora vamos a modificar el ejemplo anterior para realizar una función similar pero utilizando el selector de colores como un diálogo modal. Para mostrar el diálogo vamos a utilizar un botón (JButton) y el evento ActionEvent.

En este nuevo supuesto no se utiliza la clase ColorSelectionModel, sino que el color seleccionado lo obtenemos directamente cuando el usuario pulse el botón de OK del diálogo. Esto se ve mucho más claro en el código fuente del ejemplo

import java.awt.*;import java.awt.event.*;import javax.swing.*;public class DialogoSelectorColor extends JFrame implements ActionListener{

private JLabel etiqueta;private JButton boton;public DialogoSelectorColor() {

super("Selector de color con diálogo");this.addWindowListener(new WindowAdapter() {


}


251

});}

public void creaEtiqueta(){//Configuramos la etiqueta sobre la que se aplica la selección de

coloretiqueta= new JLabel("La Plataforma Java 2",JLabel.CENTER);

etiqueta.setForeground(Color.green);etiqueta.setBackground(Color.white);etiqueta.setOpaque(true);etiqueta.setFont(new Font("SansSerif", Font.BOLD, 24));etiqueta.setPreferredSize(new Dimension(80,45));//panel con borde que va a contener la etiquetaJPanel etiquetaPanel = new JPanel(new BorderLayout());etiquetaPanel.add(etiqueta, BorderLayout.CENTER);etiquetaPanel.setBorder(BorderFactory.createTitledBorder("etiqueta"));getContentPane().add(etiquetaPanel, BorderLayout.CENTER);


JPanel panel=new JPanel();panel.setLayout(new FlowLayout());boton=new JButton("Selección de color");panel.add(boton);boton.addActionListener(this);getContentPane().add(panel,BorderLayout.SOUTH);

}public void actionPerformed(ActionEvent evento) {

Color color=JColorChooser.showDialog(this,"Selecciona un color",etiqueta.getForeground());

if (color!=null) etiqueta.setForeground(color);}public static void main(String[] args) {

DialogoSelectorColor ventana = new DialogoSelectorColor();ventana.creaEtiqueta();ventana.creaBoton();ventana.setSize(400,180);ventana.setVisible(true);

}}

Código fuente 160

El nuevo aspecto de nuestro ejemplo se muestra en la Figura 103.

Figura 103

Y al pulsar el botón de selección de color aparece la Figura 104.


252

Figura 104

Si el usuario cancela la selección de color, ya sea cerrando el diálogo o pulsando el botón de cancelación, no se devolverá ningún color, sino que se devolverá el valor null (nulo).

En la figura 18 se puede observar que además de los botones OK y Cancel aparece el botón Reset, al pulsar este botón el color seleccionado actualmente en el diálogo será el que se había indicado inicialmente, es decir, el color que se indica en el método showDialog().

JFileChooser Este es el último componente atómico de Swing que vamos a ver. El componente JFileChooser es similar al visto anteriormente, podemos crearlo como un componente más y añadirlo a un panel o bien mostrarlo como un diálogo modal.

Este componente nos permite navegar por el sistema de ficheros y seleccionar un fichero o directorio. Normalmente se utilizan estos componentes como diálogos modales. Pero la clase JFileChooser únicamente muestra el interfaz que nos permite seleccionar los ficheros, pero el tratamiento de los mismos corre de nuestra cuenta, es decir, el tratamiento de los ficheros debemos implementarlo en nuestra aplicación.

La clase JFileChooser ofrece dos métodos para mostrar los dos tipos de selectores de ficheros distintos, el que se utiliza para abrir ficheros y el que se utiliza para grabar ficheros, estos métodos son showOpenDialog() y showSaveDialog(). Ambos métodos reciben como argumento un objeto Component que representa el padre del diálogo de selección de ficheros. Estos métodos no son estáticos como ocurría con el componente ColorChooser, sino que se deben lanzar sobre una instancia de la clase JFileChooser.


253

Tanto el método showOpenDialog() como showSaveDialog() devuelven un valor entero que se corresponde con las constantes que indican el resultado de la selección del usuario, indican si el usuario a pulsado el botón de cancelación (CANCEL_OPTION) o no (APPROVE_OPTION), ambas constantes de encuentran definidas en la clase JFileChooser.

El aspecto que muestra el diálogo para la apertura de fichero es muy similar al del diálogo para guardar ficheros.

A continuación vamos a mostrar un sencillo ejemplo que posee dos botones y un área de texto (JTextArea), según el botón que se pulse se mostrará un diálogo de selección de ficheros distinto, para abrir ficheros y para guardar ficheros. En el área de texto se irán mostrando las selecciones de ficheros o cancelaciones realizadas por el usuario. El código fuente completo es el Código fuente 161.

import java.awt.*;import java.awt.event.*;import javax.swing.*;import java.io.*;public class DialogoSelectorFichero extends JFrame implements ActionListener{

private JTextArea resultado;private JButton botonAbrir;private JButton botonGuardar;private JFileChooser selectorFichero;public DialogoSelectorFichero() {

super("Diálogo para la selección de ficheros");this.addWindowListener(new WindowAdapter() {


}});selectorFichero=new JFileChooser();

}

public void creaBotones(){ImageIcon iconoAbrir = new ImageIcon("abrir.gif");botonAbrir=new JButton("Abrir un fichero...", iconoAbrir);ImageIcon iconoGuardar = new ImageIcon("guardar.gif");botonGuardar=new JButton("Guardar un fichero...", iconoGuardar);botonAbrir.addActionListener(this);botonGuardar.addActionListener(this);JPanel panelBotones=new JPanel();panelBotones.add(botonAbrir);panelBotones.add(botonGuardar);getContentPane().add(panelBotones,BorderLayout.NORTH);

}public void creaResultado(){

resultado = new JTextArea(5,20);resultado.setMargin(new Insets(5,5,5,5));resultado.setEditable(false);JScrollPane panelResultado = new JScrollPane(resultado);getContentPane().add(panelResultado,BorderLayout.CENTER);

}public void actionPerformed(ActionEvent evento) {

if (evento.getSource()==botonAbrir){int valorDevuelto= selectorFichero.showOpenDialog(this);if (valorDevuelto== JFileChooser.APPROVE_OPTION) {

File fichero = selectorFichero.getSelectedFile();resultado.append("Abierto: " + fichero.getName()+"\n");

} elseresultado.append("Apertura cancelada por el

usuario\n");}else{

int valorDevuelto= selectorFichero.showSaveDialog(this);


254

if (valorDevuelto== JFileChooser.APPROVE_OPTION) {File fichero = selectorFichero.getSelectedFile();

resultado.append("Guardado: " + fichero.getName()+"\n");} else

resultado.append("Operación de grabado cancelada"+"por el usuario\n");

}}public static void main(String[] args) {

DialogoSelectorFichero ventana = new DialogoSelectorFichero();ventana.creaBotones();ventana.creaResultado();ventana.pack();ventana.setVisible(true);

}}

Código fuente 161

El aspecto de nuestra ventana es el de la Figura 105.

Figura 105

Y la del diálogo de selección de ficheros para su apertura, es la Figura 106.

Figura 106


255

Como se puede comprobar en el ejemplo, para obtener el fichero que se ha seleccionado se utiliza el método getSelectedFile(), que devuelve un objeto de la clase File. A través de este objeto podemos manipular ficheros, en una aplicación real se utilizaría para guardar o abrir ficheros.

El constructor de la clase JFileChooser puede recibir como argumento un objeto File o String para indicar el directorio inicial. El directorio inicial también se puede especificar mediante el método setCurrentDirectory() al que se le pasa como argumento un objeto de la clase File.

Cada vez que se muestra el diálogo para la selección de ficheros guarda el directorio actual de la selección anterior, es decir, va recordando las rutas de las selecciones anteriores. Además permite la creación de nuevos directorios.

Este ha sido el componente Swing atómico que cierra este capítulo, en el siguiente capítulo trataremos el nuevo gestor de diseño de Swing y la característica Pluggable Look & Feel.

Interfaces de usuario en Java: otras características de Swing

Introducción Este capítulo cierra el ciclo de capítulos dedicado a Swing, este capítulo no va a ser tan extenso como los anteriores ya que trataremos dos aspectos muy determinados, el nuevo gestor de diseño de Swing, representado por la clase BoxLayout y la característica especial que ofrece Swing denominada Pluggable Look & Feel.

El gestor de diseño BoxLayout La clase BoxLayout, que podemos encontrar en el paquete javax.swing, representa a un nuevo gestor de diseño ofrecido por Swing.

Este gestor de diseño organiza los componentes en una pila, uno encima del otro y también de izquierda a derecha uno al lado del otro. Se puede decir que es una versión ampliada del gestor de diseño FlowLayout que ofrece AWT.

Antes de seguir comentando este gestor de diseño ofrecido por Swing, vamos a ver con un sencillo ejemplo la forma en la que distribuye los componentes en el panel al que se aplica. El código fuente de este ejemplo es el Código fuente 162.


258

import javax.swing.*;import java.awt.event.*;public class BoxLayoutSencillo{

public static void main(String s[]) {JFrame ventana = new JFrame("Ventana con BoxLayout");ventana.addWindowListener(new WindowAdapter() {


}});JPanel panelContenido=new JPanel();panelContenido.setLayout(new

BoxLayout(panelContenido,BoxLayout.Y_AXIS));panelContenido.add(new JButton("Soy un botón"));panelContenido.add(new JButton("Soy un botón más"));panelContenido.add(new JButton("Otro botón"));panelContenido.add(new JButton("Soy el último"));ventana.setContentPane(panelContenido);ventana.pack();ventana.setVisible(true);

}}

Código fuente 162

Y el aspecto que ofrece es el de la Figura 107.

Figura 107

En el ejemplo anterior podemos comprobar la forma de crear un gestor de diseño para distribuir los componentes de arriba a abajo. El constructor de la clase BoxLayout posee dos argumentos, el panel (JPanel) sobre el que se va a aplicar el gestor de diseño y la orientación en la que se van a distribuir los componentes dentro de dicho panel. Este último parámetro es un entero que se corresponde con las siguientes constantes definidas en la clase BoxLayout:

• X_AXIS: los componentes se distribuyen de izquierda a derecha.

• Y_AXIS: los componentes se distribuyen de arriba a abajo.

Si retomamos el ejemplo anterior y cambiamos la constante BoxLayout.Y_AXIS por BoxLayout.X_ AXIS, se obtiene el resultado que muestra la Figura 108.

Figura 108

© Grupo EIDOS 13. Interfaces de usuario en Java: otras características de Swing

259

Conjuntamente con la clase BoxLayout, se suele utilizar la clase Box, esta clase ofrece una serie de métodos para controlar de una forma más precisa la forma en la que se distribuyen los componentes dentro de un panel al que se le ha aplicado este gestor de diseño BoxLayout. En el Código fuente 163 se pueden ver en acción dos de estos métodos, que son métodos estáticos de la clase Box.

import javax.swing.*;import java.awt.event.*;import java.awt.*;public class DosBoxLayout{



}});JPanel panelSuperior=new JPanel();panelSuperior.setBorder(BorderFactory.createLineBorder(Color.red));panelSuperior.setLayout(new

BoxLayout(panelSuperior,BoxLayout.Y_AXIS));panelSuperior.add(new JLabel("Esto es una etiqueta"));panelSuperior.add(Box.createRigidArea(new Dimension(0,5)));panelSuperior.add(new JTextArea(5,30));JPanel panelInferior=new JPanel();panelInferior.setBorder(BorderFactory.createLineBorder(Color.green));panelInferior.setLayout(new

BoxLayout(panelInferior,BoxLayout.X_AXIS));panelInferior.add(Box.createHorizontalGlue());panelInferior.add(new JButton("Botón 1"));panelInferior.add(Box.createRigidArea(new Dimension(10,0)));panelInferior.add(new JButton("Botón 2"));ventana.getContentPane().add(panelSuperior,BorderLayout.NORTH);ventana.getContentPane().add(panelInferior,BorderLayout.CENTER);ventana.pack();ventana.setVisible(true);

}}

Código fuente 163

El interfaz que genera este código es el de la Figura 109.

Figura 109


260

A la vista del código se puede decir que este interfaz está compuesto por dos paneles los que se han aplicado un gestor de diseño BoxLayout distinto, uno de arriba a abajo y otro de izquierda a derecha. Se ha aplicado un borde a cada uno de estos dos paneles para distinguirlos más claramente.

En el primer panel se ha utilizado el método createRigidArea() de la clase Box para crear una separación fija (área rígida) invisible entre la etiqueta (JLabel) y el área de texto (JTextArea). En este caso se ha indicado una separación vertical de cinco pixels.

En el segundo panel se utiliza otro método de la clase Box, el método createHorizontalGlue(), este método provoca que los dos botones que se añadan a continuación se desplacen hacia la derecha, es decir, este método rellena el espacio sobrante y desplaza a los componentes hacia la derecha. El método createHorizontalGlue() crea un área invisible que crece horizontalmente para rellenar todo el espacio libre disponible dentro del contenedor.

En este panel inferior también se utiliza el método createRigidArea() para separar los dos botones diez pixels, en este caso se ha utilizado un área sólo con componente horizontal. Si la llamada al método createHorizontalGlue() la hubiéramos realizado en el lugar en la que se encuentra la llamada al método createRigidArea(), el resultado hubiera sido la Figura 110.

Figura 110

A la vista de la imagen se puede decir que el área se ha extendido entre los dos botones, enviando al segundo botón a la derecha del todo.

La clase Box ofrece también el método createVerticalGlue(), en este caso el área invisible se extiende de forma vertical enviando los componentes dentro del panel hacia la zona inferior.

El gestor de diseño BoxLayout respeta el tamaño máximo de los componentes que contiene y también la alineación establecida por los mismos, aunque para que no existan problemas de alineación todos los componentes deben tener la misma. Si modificamos el primer ejemplo visto en este apartado como indica el Código fuente 164, se obtiene la Figura 111.

import java.awt.event.*;import java.awt.*;public class BoxLayoutSencillo{



}});JPanel panelContenido=new JPanel();


261

JButton boton1=new JButton("Soy un botón");boton1.setAlignmentX(Component.CENTER_ALIGNMENT);JButton boton2=new JButton("Soy un botón más");JButton boton3=new JButton("Otro botón");boton3.setAlignmentX(Component.RIGHT_ALIGNMENT);JButton boton4=new JButton("Soy el último");boton4.setAlignmentX(Component.CENTER_ALIGNMENT);panelContenido.setLayout(new

BoxLayout(panelContenido,BoxLayout.Y_AXIS));panelContenido.add(boton1);panelContenido.add(boton2);panelContenido.add(boton3);panelContenido.add(boton4);ventana.setContentPane(panelContenido);ventana.pack();ventana.setVisible(true);

}}

Código fuente 164

Figura 111

La alineación se respetará en este otro ejemplo.

import javax.swing.*;import java.awt.event.*;import java.awt.*;public class BoxLayoutSencillo{



}});JPanel panelContenido=new JPanel();JButton boton1=new JButton("Soy un botón");boton1.setAlignmentX(Component.CENTER_ALIGNMENT);JButton boton2=new JButton("Soy un botón más");boton2.setAlignmentX(Component.CENTER_ALIGNMENT);JButton boton3=new JButton("Otro botón");boton3.setAlignmentX(Component.CENTER_ALIGNMENT);JButton boton4=new JButton("Soy el último");boton4.setAlignmentX(Component.CENTER_ALIGNMENT);panelContenido.setLayout(new

BoxLayout(panelContenido,BoxLayout.Y_AXIS));panelContenido.add(boton1);panelContenido.add(boton2);panelContenido.add(boton3);panelContenido.add(boton4);


262

ventana.setContentPane(panelContenido);ventana.pack();ventana.setVisible(true);

}}

Código fuente 165

Cuyo resultado es la Figura 112.

Figura 112

Estableciendo el Look & Feel En el capítulo anterior comentábamos que una característica que ofrece Swing es el aspecto y comportamiento configurable de sus componentes, lo que se denomina Pluggable Look & Feel, es decir, a nuestra aplicación Java le podemos asignar un aspecto específico. Incluso, como veremos un poco más adelante, podemos establecer y cambiar en tiempo de ejecución de nuestra aplicación su Look & Feel.

Cuando no se indica ningún Look & Feel determinado Swing utiliza el Look & Feel por defecto, que es el Look & Feel de Java, también denominado Metal (fue el código que se le dio al proyecto que lo desarrolló). Se pueden distinguir cuatro Look & Feel estándar distintos:

• Java (Metal): se trata del Look & Feel por defecto y es el que se ha estado utilizando en todos los ejemplos de los componentes Swing, ya que en nuestros ejemplos no hemos especificado ningún Look & Feel. Se corresponde con la implementación de la clase javax.swing.plaf.metal.MetalLookAndFeel. Este Look & Feel lo podemos utilizar en cualquier plataforma.

• Windows: es aspecto que presentan los sistemas Windows y lo encontramos implementado en la clase com.sun.java.swing.plaf.windows.WindowsLookAndFeel. A diferencia del anterior Look & Feel, éste únicamente puede ser utilizado en plataformas Windows.

• Motif: representa el aspecto CDE/Motif, que es el aspecto que tienen las plataformas de Sun. Este Look & Feel es implementado por la clase com.sun.java.swing.plaf.motif.MotifLook-AndFeel, y al igual que el Look & Feel de Java puede ser utilizado en cualquier plataforma.

• Mac: este último Look & Feel es el correspondiente a los sistemas Macintosh. Se encuentra en al clase javax.swing.plaf.mac.MacLookAndFeel. Al igual que ocurría con el Look & Feel de Windows, este Look & Feel está restringido a una plataforma específica, esta plataforma es la plataforma Mac OS.


263

Todas estas clases que implementan un Look & Feel determinado, tienen la característica común que todas ellas heredan de la clase abstracta javax.swing.LookAndFeel.

Para indicar un Look & Feel determinado en una aplicación Java utilizaremos la clase UIManager (gestor de interfaz gráfico) que se encuentra en el paquete javax.swing.

La clase UIManager ofrece un método estático llamado setLookAndFeel(), que recibe como parámetro una cadena que especifica la clase que se corresponde con el Look & Feel que deseamos asignar a nuestra aplicación Java.

El método setLookAndFeel() de la clase UIManager lanza una excepción de la clase UnsupportedLookAndFeelException, que se encuentra también dentro del paquete javax.swing, cuando el Look & Feel que queremos utilizar no es soportado por la plataforma actual, deberemos atrapar por lo tanto esta excepción cuando invoquemos el método setLookAndFeel().

De esta forma si queremos que nuestra aplicación posea el Look & Feel de Motif deberemos incluir el Código fuente 166 dentro del método main() de la aplicación.

try {UIManager.setLookAndFeel("com.sun.java.swing.plaf.motif.MotifLookAndFeel");

} catch (Exception e) { }new AplicacionSwing();

Código fuente 166

Pero el Look & Feel, como ya hemos adelantado al comienzo de este apartado, se puede establecer una vez que la aplicación ya se ha iniciado y el interfaz de usuario es visible, es decir, podemos establecer el Look & Feel de la aplicación en tiempo de ejecución. En este caso además de utilizar el método setLookAndFeel() de la clase UIManager, deberemos utilizar el método estático updateComponentTreeUI() de la clase SwingUtilities, presente también en el paquete javax.swing. El método updateComponentTreeUI() recibe como argumento un objeto de la clase Component que representa el contenedor de alto nivel sobre el que se quiere actualizar su Look & Feel.

El método updateComponentTreeUI() de la clase SwingUtilities debe utilizarse para cada uno de los contenedores de alto nivel del interfaz de usuario de la aplicación, para que de esta forma todos actualicen su Look & Feel en tiempo de ejecución. Además es recomendable lanzar el método pack() sobre cada uno de los contenedores de alto nivel del interfaz de usuario, para que se redimensionen todos los componentes según su nuevo Look & Feel. La utilización de este método, conjuntamente con el método setLookAndFee() se puede ver en el Código fuente 167.

try {UIManager.setLookAndFeel(lf);SwingUtilities.updateComponentTreeUI(contenedor);this.pack(contenedor);

} catch (Exception excepcion) {System.out.println("No se pudo asignar el Look & Feel");

}

Código fuente 167

En este caso se supone que sólo existe un contenedor de alto nivel.


264

La clase UIManager, además del método setLookAndFeel(), nos ofrece otros dos métodos que pueden resultar de utilidad, estos métodos son getSystemLookAndFeelClassName() y getCrossPlatformLooAndFeelClassName(). Ambos métodos devuelven una cadena, en el primer caso se corresponde con el nombre de la clase del Look & Feel de la plataforma sobre la que se está ejecutando la aplicación, y el segundo caso se corresponde con el nombre de la clase que ofrece el Look & Feel de Java, que es el Look & Feel que se garantiza funcionará correctamente para todas las plataformas.

Por lo tanto estos dos métodos se pueden utilizar como argumento para el método setLookAndFeel(), así por ejemplo si deseamos aplicar el Look & Feel de la plataforma sobre la que se ejecuta la aplicación, utilizaríamos el Código fuente 168.

try {UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());

} catch (Exception e) { }

Código fuente 168

Para mostrar la característica Pluggable Look & Feel de Swing se va a utilizar un sencillo ejemplo que consiste una aplicación con una ventana (JFrame) que permite especificar el Look & Feel en tiempo de ejecución.

LA ventana de la aplicación del ejemplo, además de contener diversos componentes Swing, contiene cinco botones de opción (JOptionButton) agrupados, y que al seleccionar cada uno de ellos se aplicará sobre la aplicación el Look & Feel que representa cada opción. Es decir, existen cinco botones de opción, cuatro de ellos para cada uno de los distintos Look & Feel (Java, Windows, Motif y Mac) y otro para seleccionar el Look & Feel de la plataforma sobre la que se ejecuta la aplicación.

Antes de seguir comentando más detalles de esta aplicación de ejemplo, vamos a mostrar el aspecto que tendría esta aplicación. Al ejecutar la aplicación el aspecto que muestra es el de la Figura 113, y se corresponde con el Look & Feel de Java.

Figura 113


265

Al iniciarse su ejecución dentro del constructor de la aplicación, se establece el Look & Feel mediante el nombre de la clase devuelto por el método getCrossPlatformLookAndFeelClassName() de la clase UIManager, debido a esto al arrancar la aplicación comienza a ejecutarse utilizando el Look & Feel de Java. El código fuente perteneciente al constructor de nuestra clase se puede observar en el Código fuente 169.

public LF(){super("Pluggable Look & Feel");this.addWindowListener(new WindowAdapter() {


}});

try {

UIManager.setLookAndFeel(UIManager.getCrossPlatformLookAndFeelClassName());} catch (Exception e) { }

getContentPane().setLayout(new BoxLayout(getContentPane(),BoxLayout.Y_AXIS));}

Código fuente 169

En el constructor además de establecer el Look & Feel de Java se establece el gestor de diseño que va a utilizar el panel de contenido de la ventana. El gestor de diseño que se utiliza es BoxLayout, descrito en el apartado anterior, en su variante de distribución de componentes de arriba a abajo (BoxLayout.Y_AXIS).

De la figura anterior también se puede comprobar que la opción seleccionada por defecto se corresponde lógicamente con el Look & Feel que presenta la aplicación inicialmente.

Podemos ir asignando a la aplicación los distintos Look & Feel seleccionando la opción correspondiente. A continuación se muestran otras dos figuras, cada una con otro nuevo Look & Feel. La primera corresponde al Look & Feel de Windows y la segunda al Look & Feel de Motif.

Figura 114


266

Figura 115

En mi caso no he podido utilizar el Look & Feel de Mac, ya que he utilizado una plataforma Windows para ejecutar la aplicación de ejemplo, por lo tanto éste Look & Feel no estará disponible, y además en mi caso particular el Look & Feel del sistema (Look & Feel de la plataforma actual) será por lo tanto el de Windows.

No vamos hacer como en otros ejemplos de este curso, en los que se ha ofrecido el código completo del ejemplo, sólo vamos a mostrar y comentar aquellos fragmentos que resultan más interesantes (sobre todo desde el punto de vista de la característica Pluggable Look & Feel), ya que el código fuente de la aplicación de ejemplo es bastante sencillo y se utilizan componentes Swing vistos en los capítulos anteriores.

Empezamos ofreciendo la declaración de nuestra clase (Código fuente 170).

public class LF extends JFrame implements ActionListener{

Código fuente 170

Como se puede ver es una sencilla ventana que va a contener una serie de componentes Swing. No vamos a detenernos en la creación de los distintos componentes del interfaz de usuario, pero si que es interesante mostrar como se crean las opciones que permiten seleccionar el Look & Feel de la aplicación. Para crear las opciones que representan los distintos LooK & Feel se ha utilizado el método creaOpciones(), cuyo código ofrecemos en el Código fuente 171.

public void creaOpciones(){panelOpciones=new JPanel();panelOpciones.setLayout(new GridLayout(1,5,5,5));

opWindows=new JRadioButton("Windows");opWindows.setMnemonic(KeyEvent.VK_W);


267

opWindows.addActionListener(this);panelOpciones.add(opWindows);

opJava=new JRadioButton("Java/Metal");opJava.setMnemonic(KeyEvent.VK_J);opJava.addActionListener(this);panelOpciones.add(opJava);opJava.setSelected(true);opMotif=new JRadioButton("Motif");opMotif.setMnemonic(KeyEvent.VK_M);opMotif.addActionListener(this);panelOpciones.add(opMotif);opMac=new JRadioButton("Mac");opMac.setMnemonic(KeyEvent.VK_C);opMac.addActionListener(this);panelOpciones.add(opMac);opSistema=new JRadioButton("Sistema");opSistema.setMnemonic(KeyEvent.VK_S);opSistema.addActionListener(this);panelOpciones.add(opSistema);

panelOpciones.setBorder(BorderFactory.createLoweredBevelBorder());//se agrupan las opcionesButtonGroup grupo=new ButtonGroup();grupo.add(opWindows);grupo.add(opJava);grupo.add(opMotif);grupo.add(opMac);grupo.add(opSistema);getContentPane().add(panelOpciones);

}

Código fuente 171

La pulsación de cada opción será tratada dentro del método actionPerformed() que realmente, conjuntamente con el constructor de la clase, es dónde utilizamos métodos y clases relacionados directamente con el mecanismo Pluggable Look & Feel.

A continuación se ofrece el código fuente perteneciente al método actionPerformed(). Será en este método dónde se establezca el Look & Feel seleccionado a través de los distintos botones de opción.

public void actionPerformed(ActionEvent evento){Object fuente=evento.getSource();String lf="";if (fuente==opWindows)

lf="com.sun.java.swing.plaf.windows.WindowsLookAndFeel";else if(fuente==opJava)

lf="javax.swing.plaf.metal.MetalLookAndFeel";else if(fuente==opMotif)

lf="com.sun.java.swing.plaf.motif.MotifLookAndFeel";else if(fuente==opMac)

lf="javax.swing.plaf.mac.MacLookAndFeel";else if(fuente==opSistema)

lf=UIManager.getSystemLookAndFeelClassName();try {

UIManager.setLookAndFeel(lf);SwingUtilities.updateComponentTreeUI(this);this.pack();

} catch (UnsupportedLookAndFeelException excepcion) {texto.append("Look & Feel no

soportado.\n"+excepcion+"\n");} catch (ClassNotFoundException excepcion){


268

texto.append("Clase no encontrada.\n"+excepcion+"\n");} catch (InstantiationException excepcion){

texto.append("Excepción deinstanciación.\n"+excepcion+"\n");

} catch(IllegalAccessException e){texto.append("Excepción de acceso.\n"+e+"\n");

}}

Código fuente 172

Como se puede comprobar a la vista del código anterior, se decidimos atrapar la excepción UnsupportedLookAndFeelException, se nos obligará a atrapar tres excepciones más. Por lo demás, si se tiene en cuenta lo explicado hasta el momento, el código de este método es bastante sencillo, lo único que se hace es establecer el Look & Feel que se corresponde con la opción pulsada. Si ocurre una excepción se muestra en el área de texto (JTextArea) de la aplicación.

Si en mi caso particular, utilizando una plataforma Windows, selecciono la opción correspondiente al Look & Feel de Mac, obtendré una excepción lanzada por el método setLooAndFeel(), esto se puede observar en la Figura 116.

Figura 116

El fichero fuente de Java perteneciente a este ejemplo se puede obtener aquí.

Con este apartado damos por terminado la construcción de interfaces en Java y también los componentes Swing, aunque en uno de los capítulos dedicados a los applets volveremos a tratar un componente Swing, el contenedor de alto nivel representado por la clase JApplet.

Como se habrá podido comprobar Swing es bastante extenso y potente, tan extenso que sería posible dedicar un curso completo dedicado a Swing. Con estos tres capítulos hemos pretendido mostrar los aspectos más destacados de Swing, sin tener la intención de abarcar todo, ya que como hemos dicho nos dará para un curso completo más.

En el siguiente capítulo comenzaremos a ver el otro tipo de aplicaciones que podemos realizar con Java, los applets.

Applets de Java: introducción a los Applets

Conceptos previos A lo largo del presente capítulo vamos a hacer referencia a una serie de términos relacionados con los applets de Java que conviene tener claros, por ello hemos incluido este apartado, muchos de estos conceptos pueden que sean conocidos para todos, pero es mejor partir de una serie de definiciones que compartamos todos.

Internet Internet es un conjunto de redes cuyo origen se remonta al año 1969 en Estados Unidos. En un principio Internet se creó con fines militares durante La Guerra Fría. Era un proyecto del Departamento de Defensa de Estados Unidos.

En un principio este proyecto se denominó ARPANET (Advanced Research Projects Agency-ARPA). El objetivo para el que se había creado el proyecto era mantener una infraestructura robusta de diferentes ordenadores conectados entre sí.

Si se suprimía algún nodo de la red, la red debería seguir funcionando, es decir, no existía ningún nodo central o principal. Estas características son debidas al origen militar de la red, de esta forma, si algunas de las partes de la red se destruían debido a un ataque militar, el resto de la red puede seguir funcionando.


270

De este inicio militar Internet paso a ser utilizado dentro del campo académico, se utilizaba en universidades para proyectos de investigación.

Del ámbito académico Internet pasó a ser de dominio público, para todo tipo de actividades, culturales, comerciales, lúdicas, filosóficas, etc.

La fama y popularidad de Internet se consiguió y llegó a través de la World Wide Web. La Web o la Gran Telaraña Mundial se basa en el protocolo de Transferencia de Hipertexto HTTP (Hypertext Transport Protocol).

La Web nació en el CERN (European Center for Nuclear Research) de la mano de Tim Berners-Lee como intento de crear un sistema hipermedia, basado en enlaces hipertextuales, para la compartición de información científica entre los integrantes del laboratorio del CERN, de una manera clara y sencilla aprovechando los recursos que ofrecía Internet en aquella época.

A finales de 1995 la Web se había convertido en el servicio más solicitado y famoso de Internet.

URLs y direcciones IP Una URL (Uniform Resource Locator) es el mecanismo que se utiliza en Internet para localizar e identificar de forma única un recurso dentro de Internet. La sintaxis general de una URL se compone de tres partes:

protocolo://<nombre del dominio>/<nombre del recurso>

El campo protocolo especifica el protocolo de Internet que se va a utilizar para transferir los datos del recurso entre el cliente y el servidor. Existen varios protocolos en Internet como pueden ser: FTP (File Transfer Protocolo) para la transferencia de ficheros; HTTP (HyperText Transfer Protocol) protocolo para la transferencia de hipertexto; Telnet, Gopher, etc.

A continuación del protocolo aparece los dos puntos (:), la doble barra (//) y el nombre del dominio. El nombre del dominio es la forma de identificar una máquina de forma única en Internet, este nombre de dominio puede ser la dirección IP, en el formato de tétrada punteada (201.234.123.87) o bien su traducción correspondiente a un nombre más descriptivo, como puede ser www.eidos.es.

Una dirección IP es un número de 32 bits para identificar de forma única una máquina conectada a Internet. Se divide en grupos de 8 bits y se identifica con su número en notación decimal separado cada uno de ellos por puntos, a este formato se le denomina tétrada punteada.

Debido a que recordar direcciones IP puede ser difícil y poco manejable se suelen identificar con nombres de máquinas, así la dirección IP 206.26.48.100 se corresponde con el nombre de la máquina java.sun.com que resulta más fácil de recordar y significativo. Un mismo nombre puede tener diferentes direcciones IP, en Internet esta correspondencia entre direcciones IP y nombres la gestionan servidores de nombres que se encargan de traducir los nombres fáciles de recordar a sus direcciones de 32 bits.

Acompañando el nombre del dominio puede aparecer precedido de dos puntos un número de puerto.

Los números de puerto se utilizan para identificar de forma única los distintos procesos dentro de una máquina en la red. A cada servidor se le asigna un número de puerto conocido. El rango del número de puerto es 0-65535, ya que se trata de números de 16 bits, los números de puerto del rango 0-1023 se encuentran restringidos ya que se utilizan para servicios conocidos como pueden ser HTTP

© Grupo EIDOS 14. Applets de Java: introducción a los Applets

271

(HyperText Transfer Protocol) en el puerto 80, FTP (File Transfer Protocol) en el puerto 21, telnet en el puerto 23 y otros servicios del sistema.

Cada dirección IP es un conjunto de puertos a los que los clientes se pueden conectar a través de Internet.

La última parte de la URL indica dónde se encuentra localizado el recurso dentro del servidor, es decir, es el camino del fichero demandado en la URL. El servidor verificará esta parte de la URL para identificar que página HTML, imagen, directorio o aplicación se está demandando. Cada elemento que forma el camino del recurso se para con una barra (/).

Clientes y Servidores Web La arquitectura Cliente/Servidor podemos verla como una forma de abordar los problemas.

Dentro de la red el sistema cliente es la estación de trabajo y el servidor es una versión de mayor tamaño capaz de almacenar gran cantidad de datos y ejecutar grandes aplicaciones.

Cuando un ordenador se comunica con otro a través de Internet, en dicha comunicación se usa el modelo cliente/servidor. Los recursos de Internet los proporcionan unas máquinas denominadas servidores, que dan el servicio a las peticiones de los clientes.

Los clientes son los ordenadores que acceden a estos recursos a través de aplicaciones cliente.

Básicamente, un servidor atiende y trata peticiones de varios clientes. En el entorno de Internet la arquitectura cliente/servidor es bastante común y se encuentra muy extendida. Normalmente un servidor se ejecuta un una máquina diferente de la del cliente, aunque no siempre es así. La interacción entre cliente y servidor normalmente comienza en el lado del cliente. El cliente realiza una petición de un objeto o transacción del servidor, el servidor deberá tratar la petición o denegarla. Si la petición es tratada, el objeto se le enviará al cliente.

En el entorno de la World Wide Web los servidores se denominan servidores Web y los clientes se denominan navegadores Web.

Un servidor Web es el encargado de publicar o poner a disposición de una serie de clientes unos recursos. Estos recursos pueden variar desde una página HTML a un script CGI para la consulta de una tabla en una base de datos, o bien desde una página HTML con diferentes applets a una página ASP que realiza el mantenimiento de una tabla, o incluso un servicio de correo.

A la hora de pensar en un servidor Web no debemos limitar sus funciones a la del servicio Web propiamente dicho, es decir, a la publicación de páginas HTML.

Los navegadores Web realizan peticiones de documentos que se encuentran en servidores Web, permitiendo así visualizar los documentos de la World Wide Web. Algunos de los clientes más populares son Netscape Navigator y Microsoft Internet Explorer.

El proceso de visualización de un documento en la Web comienza cuando el navegador Web envía una petición al servidor Web. El navegador Web envía información, sobre sí mismo y sobre el fichero que está demandando, al servidor Web en cabeceras de petición del protocolo HTTP.

El servidor Web recibe y consulta las cabeceras HTTP para obtener toda información relevante, tal como el nombre del fichero que se indica en la petición, y envía el fichero con las cabeceras de


272

respuesta del protocolo HTTP. Entonces el navegador Web utiliza las cabeceras de respuesta HTTP para determinar como mostrar o tratar el fichero que le envía el servidor Web.

HTML HTML es la abreviatura de HyperText Markup Language , y es el lenguaje que todos los programas navegadores usan para presentar información en la World Wide Web (WWW).

Este es un lenguaje muy sencillo que se basa en el uso de etiquetas, consistentes en un texto ASCII encerrado dentro de un par de paréntesis angulares(<..>). El texto incluido dentro de los paréntesis nos dará una explicación de la utilidad de la etiqueta. Así por ejemplo la etiqueta <TABLE> nos permitirá definir una tabla.

Las etiquetas podrán incluir una serie de atributos o parámetros, en su mayoría opcionales, que nos permitirán definir diferentes posibilidades o características de la misma. Estos atributos quedarán definidos por su nombre (que será explicativo de su utilidad) y el valor que toman separados por un signo de igual. En el caso de que el valor que tome el atributo tenga más de una palabra deberá expresarse entre comillas, en caso contrario no será necesario. Así por ejemplo la etiqueta <TABLE border="2"> nos permitirá definir una tabla con borde de tamaño 2.

Entre otras cosas, el manejo de estas etiquetas nos permitirá:

• Definir la estructura lógica del documento HTML.

• Aplicar distintos estilos al texto (negrita, cursiva, ...).

• La inclusión de hiperenlaces, que nos permitirán acceder a otros documentos relacionados con el actual.

• La inclusión de imágenes y ficheros multimedia (gráficos, vídeo, audio).

HTTP Como ya se ha comentado anteriormente, el protocolo HTTP (HiperText Transfer Protocol) es el utilizado para la transferencia de hipertexto entre el servidor Web y el navegador.

Introducción a los applets de Java

Una vez comentados una serie de conceptos relacionados con los applets de Java, vamos a pasar a tratar los applets propiamente dichos.

Como ya sabrá el lector a estas alturas, los programas Java comprenden dos grupos principales: applets y aplicaciones. Un applet es un programa dinámico e interactivo que se ejecuta dentro de una página Web, desplegada por un navegador con capacidad para Java como puede ser los navegadores Navigator de Netscape o el Internet Explorer de Microsoft, por lo tanto los applets para ejecutarse dependen de un navegador Web que soporte para Java. Los applets es uno de los principales motivos que han hecho al lenguaje Java tan popular.


273

Un applet es un objeto dentro de la jerarquía de clases de Java, es una subclase de la clase Panel, y se encuentra en el paquete java.applet, este paquete además de contener la clase Applet contiene tres interfaces AudioClip, AppletStub y AppletContext.

Para poder incluir un applet dentro de una página Web, se deben seguir los siguientes pasos: después de crear una clase con el applet y compilarla dando como resultado un archivo de clase (.CLASS), se debe crear una página Web que contenga al applet, para ello se debe hacer uso del lenguaje HTML (HyperText Markup Language) que dispone de una serie de etiquetas especiales para incluir applets en las páginas Web. Estas etiquetas las comentaremos en el apartado correspondiente dentro de este mismo capítulo.

Después de tener un applet y la página Web que hace referencia al mismo, se debe hacer disponible para la World Wide Web. Los applets Java se pueden colocar en un servidor Web de la misma manera que los archivos HTML, no se necesita software de servidor especial para hacer los applets disponibles en la Web, todo lo que se necesita es ubicar el fichero HTML y los archivos de clase compilados del applet en el servidor Web, también se deberán incluir junto al fichero .class del applet, todos los ficheros de clase que utilice el applet y que no se encuentren dentro las clases estándar de Java contenidas en de la Máquina Virtual.

Cuando un navegador Web se dispone a visualizar una página Web que contiene un applet o varios, el navegador carga además de la clase, en la que se encuentra el applet, todas las clases que utilice el mismo, y se ejecuta en la máquina local del cliente; a partir de ahora cada vez que se haga referencia a la "máquina local", se está hablando de la máquina dónde se ejecuta el navegador y carga el applet a través de Internet.

Los applets se descargan utilizando el mismo protocolo que se utiliza para transferir las páginas Web, es decir el protocolo de transferencia de hipertexto HTTP (HyperText Transfer Protocol).

Cabe destacar que los applets poseen una serie de capacidades que las aplicaciones no poseen, esto es debido a que los applets tienen su propia clase llamada Applet, y disponen de tres interfaces AppletStub, AppletContext y AudioClip, que les ofrecen apoyo para las siguientes tareas:

• Los applets pueden reproducir sonidos.

• Los applets pueden realizar la carga de documentos HTML, ya que se pueden comunicar con el navegador Web gracias al interfaz AppletContext.

• Pueden invocar métodos públicos de otros applets en la misma página Web, es decir, varios applets de pueden comunicar entre sí de forma muy sencilla.

• Se ejecutan dentro de una página Web cargada por un navegador.

Todas estas características de los que se han esbozado en estos puntos, se comentarán y tratarán de forma más detenida en los distintos apartados de este tema.

Antes de seguir hablando de los applets como si fuera algo abstracto o difícil de realizar, vamos a comentar una serie de pasos básicos para crear nuestro primer applet utilizando la herramienta de Microsoft Visual J++ 6.

Al arrancar Visual J++ en la pestaña de Nuevo seleccionamos la carpeta Páginas Web y dentro de esta opción elegimos Subprograma en HTML, esta es una curiosa forma que se ha elegido para nombrar a los applets. Algunos autores hacen referencia a los applets mediante los términos de miniaplicaciones o subprogramas.


274

Le damos un nombre a nuestro proyecto y pulsamos Abrir, en este momento Visual J++ generará un fichero fuente de Java llamado Applet1.java, que contiene la estructura de un applet de ejemplo, y además genera un fichero HTML llamado Page1.htm, que va a ser la página Web que haga referencia al applet antes mencionado.

Para empezar desde cero y evitar confusiones, vamos a eliminar todo el código que aparece en el fichero fuente del applet y vamos a comenzar a escribir nosotros mismos nuestro primer applet.

En un primer lugar debemos importar el paquete que contiene a la clase Applet, ya hemos comentado en este mismo apartado que un applet es un tipo de panel especial que se va a mostrar en el entorno de un navegador Web dentro de una página HTML.

import java.applet.*;

Código fuente 173

A continuación debemos declarar nuestra clase. Debido a que vamos a crear un applet, nuestra clase heredará de la clase Applet. Antes de seguir cambiaremos el nombre de nuestro fichero fuente para cambiar el nombre de la clase del applet, en mi caso lo he llamado AppletSencillo, y la declaración de la clase se muestra en el Código fuente 174.

public class AppletSencillo extends Applet{}

Código fuente 174

Nuestro applet no va hacer mucho, simplemente vamos a mostrar un mensaje en la superficie del applet, para ello vamos a sobrescribir el método paint() de la clase Applet. Más adelante en este capítulo comentaremos el ciclo de vida de los applets y que implica sobrescribir el método paint(), también trataremos la clase Graphics y veremos como mostrar gráficos en un applet, de momento sólo debemos saber que el parámetro de la clase Graphics que recibe el método paint() representa a la superficie del applet.

Para mostrar el mensaje "Hola Mundo", implementamos el método paint() como indica el Código fuente 175.

public void paint(java.awt.Graphics g){g.drawString("Hola Mundo",10,10);

}

Código fuente 175

De esta forma el código completo de nuestra clase es el Código fuente 176.

import java.applet.*;public class AppletSencillo extends Applet{

public void paint(java.awt.Graphics g){


275

g.drawString("Hola Mundo",10,10);}

}

Código fuente 176

Como se puede ver en el código, un applet no presenta ningún método main(), como ocurría con las aplicaciones. En la aplicaciones era necesario porque era el método de arranque de la clase y era dónde se instanciaba un objeto la clase de la aplicación. Sin embargo esto no pasa en los applets, como se puede ver nosotros no creamos ninguna instancia de la clase de nuestro applet, ahora bien, alguien debe hacerlo, este alguien es el navegador Web.

El navegador Web crea una instancia de la clase de nuestro applet a través de la máquina virtual (MV) que contiene, cuando encuentra la etiqueta HTML que hace referencia al applet crea de forma automática una instancia del mismo.

Ahora compilamos nuestro applet. Al compilar el applet se genera el fichero .class correspondiente, al igual que ocurría con las aplicaciones.

Una vez compilado y generado nuestro applet tenemos que ver la forma de ejecutarlo, pero antes de ejecutarlo debemos modificar la página Web Page1.htm para que haga referencia a nuestro applet, ya que nosotros hemos cambiado el nombre del mismo, y la página Web sigue haciendo referencia a la clase Applet1.

Para modificar la página Web hacemos doble click sobre ella en el Explorador de proyectos y en ese momento se abre la página Web en el área que teníamos reservada para el editor de código. El aspecto que ofrece el entorno de desarrollo se puede ver en la Figura 117.

Figura 117

El editor reservado para la página Web presenta tres vistas diferente de la página HTML: Diseño, Código y Vista rápida. En la parte de diseño podemos insertar elementos HTML o modificar los existentes, de forma similar a como lo podemos hacer con otros editores HTML más avanzados y sofisticados como puede ser Microsoft FrontPage, en esta vista podemos ver el aspecto que tiene el applet dentro de la página HTML, en este caso no estamos viendo nuestro applet sino el que había creado de ejemplo Visual J++.


276

Si seleccionamos el área que representa al applet y pulsamos con el botón derecho del ratón podemos seleccionar la opción de menú Propiedades. Al seleccionar esta opción del menú contextual podemos modificar las propiedades del applet desde una ventana de propiedades que aparece en el entorno y que se suele encontrar debajo del explorador de proyectos.

En la ventana de Propiedades vamos a modificar la propiedad code del applet, esta propiedad debe indicar el nombre de la clase del applet que queremos mostrar en la página Web. Por lo tanto el valor de esta propiedad va a ser AppletSencillo, también vamos a modificar las propiedades width y height que indican las dimensiones del applet, yo he indicado el valor 100 para ambas propiedades. También podemos modificar las dimensiones del applet seleccionando y arrastrando el ratón, modificando de esta forma su tamaño.

Una vez realizadas estas modificaciones sobre las propiedades, ya podemos ver nuestro applet en el lugar en el que aparecía el applet de ejemplo creado por Visual J++. Como se puede ver en la Figura 118, la vista Diseño muestra el applet en un estado similar al que presentaría en ejecución, y como era deseado y esperado muestra el mensaje Hola Mundo.

Figura 118

En la vista Código vemos el código HTML de la página Web (Figura 119), aunque el applet lo seguimos viendo en modo de ejecución, para ver el código HTML que se corresponde con la inclusión del applet en la página Web seleccionamos el applet, pulsamos con el botón derecho del ratón y seleccionamos la opción de menú Ver siempre como texto, de esta forma podemos ver los valores de la etiqueta <APPLET>. Esta etiqueta la discutiremos en el apartado dedicado a los applets y el código HTML.

Figura 119


277

La última vista, Vista rápida, se muestra la página Web de la forma en la que se mostraría en un navegador que soporte Java, esta vista si que muestra la verdadera ejecución del applet, no como ocurría en la vista de diseño, aunque al ser un applet tan sencillo en ambas vistas ofrece el mismo aspecto.

Por lo tanto si en la vista rápida vemos nuestro applet de forma correcta, es como si ya lo hubiésemos probado en un navegador, pero de todas formas recomiendo ejecutar el applet directamente sobre un navegador Web.

Para ejecutar el applet pulsamos directamente el botón representado por una tecla "play" en el entorno de desarrollo, es decir, al igual que ejecutábamos una aplicación. En ese momento se ejecuta el applet, pero no mediante un navegador Web, sino mediante una herramienta del entorno Visual J++ denominada Visor de subprograma. El aspecto de este visor se puede ver en la Figura 120, y la función del mismo es el de desplegar applets, además ofrece un menú que no permite interactuar con el applet a través de una serie de opciones como: Recargar, Iniciar, etc.

Figura 120

Pero si queremos ejecutar el applet desde el entorno de Visual J++ 6 y que además arranque de forma automática el navegador Web para que se ejecute el applet en su interior, debemos acudir a las propiedades del proyecto y en la pestaña Inicio, en la lista desplegable Cuando se ejecute el proyecto, cargar:, seleccionamos la página HTML que hace referencia a nuestro applet.

De esta forma cuando ejecutemos el proyecto, se lanzará el navegador Web (Internet Explorer) y cargará la página Web que hace referencia a nuestro applet, y se ejecutará por lo tanto el applet como se puede comprobar en la Figura 121.

Esta es la forma más recomendable para probar un applet desde el entorno de desarrollo, pero existe otra forma. Simplemente localizamos en el Explorador de Windows la página Web que hace referencia a nuestro applet y hacemos doble click sobre ella, de esta forma se lanzará el navegador Web y cargará la página en cuestión.

Ahora vamos a pasar a construir este mismo applet pero desde el entorno de desarrollo de la herramienta JBuilder 3.5. Para ello creamos un nuevo proyecto utilizando (si queremos) el asistente de proyectos. Una vez creado el proyecto desde el menú de opciones seleccionamos la opción Archivo/ Nuevo y seleccionaremos de la galería de objetos el applet, en ese momento se lanzará el asistente de creación de un nuevo applet.


278

Figura 121

El primer paso de este asistente, que se puede ver en la Figura 122, permite indicar a que paquete va a pertenecer nuestra clase y el nombre de la misma. En la opción clase base podemos elegir la clase Applet de la que queremos heredar, existen dos clases: Applet del paquete java.applet y JApplet del paquete javax.swing. JApplet es un componente Swing que hereda de la clase java.applet.Applet, es la versión Swing de los applets, la clase javax.swing.JApplet la veremos en próximos capítulos. En el ejemplo nuestro applet se llama AppletEjemplo y hereda de la clase java.applet.Applet.

En el primer paso del asistente para applets también podemos indicar si queremos que se generen comentarios, si queremos que se ejecute como una aplicación cuando proceda y si deseamos que se generen todos los métodos del ciclo de vida de los applets, estos métodos los veremos en el apartado dedicado al ciclo de vida de los applets.

Figura 122

En la figura 7, se definen los parámetros el applet, en nuestro ejemplo el applet no va a tener ninguno, ya que consiste únicamente en escribir un mensaje en la superficie del applet.


279

Figura 123

En el último paso se nos permite especificar los parámetros de configuración de applet en la página HTML, es decir, el nombre de la clase, las dimensiones y la alineación. También podemos indicar si queremos o no que se genere de forma automática la página HTML que va a contener nuestro applet, de la página podemos especificar su nombre y título.

Figura 124

Al pulsar finalizar se generará el fichero fuente del applet y la página HTML que lo contiene. Ahora accedemos al código fuente y añadimos el método paint() con el mismo código que vimos anteriormente para Visual J++. Una vez compilado el applet podemos pulsar el botón "play" para la ejecución del mismo.


280

En ese momento aparece la pantalla de configuración del proyecto para ejecutar el applet (Figura 125), esta pantalla que aparece únicamente la primera vez, nos permite asignar la clase principal del applet, al igual que ocurría con las aplicaciones Java, también es posible definir las dimensiones del applet y los parámetros, pero estos datos ya los hemos indicado anteriormente en el asistente para la creación de applets.

Figura 125

Una vez indicada la información necesaria para ejecutar el applet JBuilder inicia la ejecución del mismo en una herramienta propia de JBuilder, comparable al appletviewer del JDK o al visor de subprograma del Visual J++. El aspecto del visor de applets de JBuilder se puede comprobar en la Figura 126.

Figura 126


281

Ya hemos visto como crear y ejecutar un applet con Visual J++ y JBuilder, ahora sólo nos queda hacer lo mismo con la herramienta de Sun JDK. Para ello crearemos el fichero fuente de Java que va a contener el código del applet que sería el Código fuente 177.

import java.applet.*;public class AppletSencillo extends Applet{

public void paint(java.awt.Graphics g){g.drawString("Hola Mundo",10,10);

}}

Código fuente 177

Compilamos el código con la herramienta javac y creamos una página HTML que haga referencia a la clase de nuestro applet. Al hacer doble clic sobre la página, ya podríamos ver el applet en nuestro navegador Web, pero también podemos utilizar la herramienta appletviewer que se ofrece con el JDK. Para ejecutar nuestro applet con el appletviewer únicamente deberemos escribir la instrucción en la línea de comandos, como se muestra en el Código fuente 178.

appletviewer pagina.html

Código fuente 178

Y el aspecto del appletviewer es el de la Figura 127.

Figura 127

Desde el menú Applet del appletviewer podemos invocar los distintos métodos del ciclo de vida de los applets, que veremos en detalle más adelante en este mismo capítulo.

Al principio de este apartado comentábamos que para hacer disponibles los applets en la Web, necesitamos de un servidor Web, ahora bien, para probarlos, es decir, en tiempo de desarrollo de los mismos, puede no ser necesario. Así con nuestro sencillo applet lo probaríamos en una máquina local y una vez que hemos comprobado que funciona lo copiaríamos al servidor Web que corresponda.


282

Este ha pretendido ser el primer contacto con los applets, hemos realizado un applet muy sencillo y lo hemos realizado desde tres herramientas distintas: Microsoft Visual J++ 6, Borland JBuilder 3.5 y el JDK 1.3 de Sun. También hemos visto las diferentes formas que tenemos de ejecutarlo.

En los siguientes apartados profundizaremos más en todo lo relacionado con los applets.

El ciclo de vida de los applets Los applets podemos decir que presentan un ciclo de vida, es decir, durante su ejecución pasan por diferentes estados.

El ciclo de vida de vida de los applets es controlado por cuatro métodos de la clase Applet, estos métodos son init(), start(), stop() y destroy().

Cuando se carga una página Web que contiene un applet, éste pasa por varias etapas durante el tiempo que aparece en pantalla, el applet realiza unas tareas muy diferentes durante cada una de estas etapas.

Si queremos que en una etapa del ciclo de vida de un applet se realice una tarea determinada deberemos sobrescribir el método adecuado. No siempre es necesario sobrescribir todos los métodos del ciclo de vida de un applet.

A continuación se comenta cuando se ejecutan cada uno de los métodos del ciclo de vida de un applet.

El método init() es llamado una única vez por la Máquina Virtual de Java (JVM) del navegador cuando el applet se carga por primera vez, antes de ser mostrado al usuario, es en este método donde se deben inicializar los objetos, construir los interfaces de usuario, etc.

El método start() es llamado cada vez que la página Web que contiene el applet es mostrada en la pantalla del usuario.

Al método stop() se le llama cada vez que el usuario carga otra página Web, es decir, cuando se abandona la página que contiene al applet.

El último método, destroy(), es llamado una única vez, justo antes de ser eliminado el applet, cuando se abandona el navegador.

Este método es invocado automáticamente para realizar cualquier limpieza que sea necesaria, por lo general no es necesario sobrescribir este método, sólo será necesario cuando se tengan recursos específicos que necesiten ser liberados.

Es durante esta etapa final de salida, cuando la Máquina Virtual de Java completa algunas funciones de recolección de basura para asegurar que los recursos que empleó el applet sean borrados de la memoria y de que el applet sea completamente destruido cuando se salga de él.

Como se ha podido observar en el ciclo de vida de un applet los métodos init() y destroy() se lanzarán solamente una vez cada uno, y sin embargo los métodos start() y stop() se lanzarán las veces que sean necesarios, según interactúe el usuario con el navegador.

La Figura 128 muestra la relación entre los métodos del ciclo de vida del applet y los acontecimientos que los marcan:


283

Figura 128

Vamos a realizar un seguimiento a través del ciclo de vida de un applet, para lo cual vamos a apoyarnos en una clase Ventana, que va a ser muy sencilla y cuyo código es el Código fuente 179.

import java.awt.*;import java.awt.event.*;public class Ventana extends Frame{public Ventana(String titulo){

super(titulo);setSize(150,150);show();addWindowListener(new AdaptadorVentana(this));

}}class AdaptadorVentana extends WindowAdapter{

private Ventana fuente;public AdaptadorVentana(Ventana fuente){

this.fuente=fuente;}public void windowClosing(WindowEvent evento){

fuente.dispose();}

}

Código fuente 179

Si algún alumno tiene problemas para entender el código anterior, le remito al capítulo dedicado al interfaz de usuario en Java.

La clase Ventana la vamos a utilizar en nuestro applet para crear una ventana cada vez que se ejecuta un método del ciclo de vida de un applet. Para diferenciar las ventanas, a cada una de ellas le pasamos a su constructor el nombre del método del ciclo de vida que las ha llamado. Es decir, cada ventana tendrá un título distinto.

El código del applet es el Código fuente 180.

import java.applet.*;public class CicloVida extends Applet{public void init(){

Ventana ventana=new Ventana("init()");}


284

public void start(){Ventana ventana=new Ventana("start()");

}public void stop(){

Ventana ventana=new Ventana("stop()");}public void destroy(){

Ventana ventana=new Ventana("destroy()");}}

Código fuente 180

En este caso cada clase se encuentra en un fichero fuente, es decir, existen los ficheros Ventana.java y CicloVida.java.

Si ejecutamos nuestro applet pulsando play (en cualquiera de los entornos: Visual J++ o JBuilder), como ya vimos en el apartado anterior, o bien con el appletviewer o directamente con te navegador Web deben aparecer dos ventanas, una creada por el método init() y otra por el método start().

Una vez que hemos cargado el applet, si cerramos el navegador aparecen momentáneamente otras dos ventanas, creadas esta vez por el método stop() y destroy(), ya que además de descargar el applet se cierra el navegador. Hasta aquí todo es correcto y sucede tal y como habíamos explicado anteriormente.

Un ejemplo de ejecución del applet se puede ver en la Figura 129.

Figura 129

Continuamos con la ejecución de nuestro applet. Pero si cargamos una página distinta, además de ejecutarse el método stop() se ejecuta el método destroy(), cosa que en absoluto es correcta, sólo se debería ejecutar el método stop(), ya que el navegador no se ha cerrado.

Y si volvemos a la página del applet (pulsando la flecha hacia atrás del navegador) además de ejecutarse el método start() también se ejecuta el método init(), situación que también es incorrecta.

Esto no es debido a que nuestro applet esté mal construido, sino que es debido a una implementación distinta dentro de la máquina virtual del navegador Web. En mi caso he detectado este fallo en el navegador Internet Explorer en su versión 5.0.


285

Si probamos este mismo applet cargando la página que lo contiene desde el navegador Netscape Navigator en su versión 4.5 el applet funciona correctamente, es decir, al cambiar de página se ejecuta únicamente el método stop() y al volver a la página el método start().

Realizo estos comentarios, sólo para las versiones señaladas de los navegadores, que son además los que se han utilizado para las pruebas de los applets que aparecen en este curso.

Estos cuatro métodos que componen el ciclo de vida de un applet se ejecutan, como hemos podido comprobar, de forma automática y siguiendo un orden determinado.

Otro método que también se ejecuta de forma automática es el método paint(). Este método, que ya hemos comentado someramente en el apartado anterior, tiene la función de pintar o mostrar la apariencia del applet en la pantalla. Este método es otro método de la clase Applet que podemos sobrescribir si lo necesitamos, igual que ocurría con los métodos del ciclo de vida de los applets.

Con respecto al ciclo de vida del applet el método paint() se ejecuta por primera vez inmediatamente después del método start() y luego cada vez que se necesita "repintar" la pantalla, es decir, cada vez que se refresca la superficie que comprende al área contenida por el applet. La máquina virtual lanzará el método paint() cada vez que el applet desaparezca total o parcialmente de la pantalla.

El método paint() recibe como parámetro un objeto de la clase Graphics, que pertenece al paquete java.awt. La instancia del objeto de la clase Graphics representa la superficie del applet, y lo vamos a utilizar para escribir y dibujar en la superficie del mismo. En el apartado correspondiente veremos como dibujar de forma básica en la superficie de nuestro applet.

El método paint() también se ejecuta cuando se llama al método repaint() de la clase Applet.

Seguridad en los applets Java incluye características de seguridad para reforzar su empleo en Internet. Un problema de seguridad potencial tiene que ver con los applets de Java, que son código ejecutable que opera en la máquina local del usuario que se conecta a la página Web en la que se encuentran los applets. Java emplea verificación de código y acceso limitado al sistema de archivos para garantizar que el código no dañe nada en la máquina local.

Se debe tener claro que el applet reside en el servidor Web, pero cuando se carga la página Web que lo contiene, las clases del applet se transfieren hasta la máquina cliente, que es dónde se inicia la ejecución del applet.

En este apartado, como su nombre indica, vamos a comentar los mecanismos de seguridad que ofrece Java a la hora de ejecutar los applets en la máquina cliente o máquina local, y que restricciones de seguridad impone.

Existen dos módulos software encargados del análisis de la seguridad y de la imposición de restricciones, estos módulos son el ClassLoader y el Security Manager.

El ClassLoader (clase abstracta del paquete java.lang) tiene las siguientes funciones: por un lado colocar las clases que integran cada applet en un espacio de nombres único y estanco, de forma que es imposible para un applet acceder o manipular recursos de otros applets.

Por otro lado analiza los bytecodes que componen la representación binaria intermedia del código del applet para asegurar que son conformes a las normas de Java y no realizan operaciones peligrosas,


286

como conversiones de tipos ilegales, accesos a índices inexistentes de arrays, paso de parámetros incorrectos, etc. Todas estas funciones las lleva a cabo un verificador de código (bytecode verifier).

Las comprobaciones que realiza el verificador de código (para más información sobre el proceso de verificación, consultar la siguiente dirección de Internet: http://www.javasoft.com/sfaq/verifier.html) se ven facilitadas por la filosofía de diseño de Java. Así, por ejemplo, Java carece de punteros, por lo que es imposible hacer referencia a una posición de memoria explícita. Además, el intérprete comprueba siempre que el acceso a un array se realiza a través de un índice dentro de un rango válido.

Cuando se carga desde un servidor a nuestra máquina local una página Web que contiene algún applet, el código del applet es verificado por el segundo módulo de seguridad para garantizar que el applet sólo emplea llamadas y métodos válidos del sistema. Si el applet pasa la verificación se le permite ser ejecutado, pero a los applets no se les da acceso al sistema de archivos de la máquina local.

El objeto responsable de evitar que los applets realicen una operación potencialmente peligrosa es el SecurityManager (gestor de seguridad, clase abstracta del paquete java.lang). Si el SecurityManager determina que la operación está permitida, deja que el programa siga con su ejecución.

Cuando una aplicación Java se ejecuta, no hay SecurityManager. Esto es debido a que se espera que cualquier aplicación que el usuario ejecuta es segura para ese usuario. De todas formas podemos escribir e instalar propio SecurityManager para nuestras aplicaciones, por lo tanto en un principio las aplicaciones Java no tiene ningún tipo de restricción.

Cada navegador de páginas Web con capacidad para Java tiene un objeto SecurityManager que comprueba si se producen violaciones de las restricciones de seguridad de los applets. Cada vez que una clase Java hace una petición de acceso a un recurso del sistema, la instancia de la clase SecurityManager comprueba la petición realizada, si no se tiene permiso para efectuar el acceso éste se deniega y en caso contrario se le concede y se sigue normalmente con la ejecución del applet.

Cuando el SecurityManager detecta una violación crea y lanza un objeto SecurityException y se detiene la ejecución del applet. Normalmente, el constructor de una SecurityException muestra un mensaje de advertencia que indica que se ha producido una excepción de seguridad.

En la Figura 130, se puede ver de forma ordenada todo el proceso que se sigue para comprobar que el applet es seguro, desde que el applet se empieza a cargar desde Internet hasta que empieza a ejecutarse en la máquina cliente:

Figura 130


287

La clase SecurityManager posee una serie de métodos para realizar las siguientes acciones que refuerzan su política de seguridad:

• Determinar si una petición de conexión, a través de la red, desde una máquina en un puerto específico puede ser aceptada.

• Comprobar si un hilo de ejecución puede manipular otro hilo de ejecución diferente.

• Comprobar si se puede establecer una conexión vía socket con una máquina remota en un puerto específico.

• Impedir la creación de un nuevo objeto de la clase ClassLoader.

• Impedir la creación de un nuevo objeto de la clase SecurityManager, ya que podría sobrescribir la política de seguridad existente.

• Comprobar que un fichero puede ser borrado.

• Comprobar si un programa puede ejecutar otro programa en el sistema local.

• Impedir que un programa termine con la ejecución de la Máquina Virtual de Java.

• Comprobar si se puede acceder a una librería dinámica.

• Comprobar si se puede escuchar en un determinado puerto para esperar peticiones de conexión.

• Determinar si un programa puede cargar paquetes Java específicos.

• Determinar si un programa puede crear nuevas clases en un paquete Java específico.

• Identificar a que propiedades del sistema se puede acceder.

• Comprobar si se puede leer un fichero.

• Comprobar si se puede escribir datos en un fichero.

• Comprobar si un programa puede crear su propia implementación de los sockets para la red.

• Establecer si un programa puede crear una ventana de alto nivel. Cualquier ventana que se cree incluirá algún tipo de advertencia visual.

Después de explicar los mecanismos de los que dispone Java para verificar que un applet es seguro, se va a pasar a detallar las restricciones de seguridad que poseen los applets (para más información sobre la seguridad de Java se puede consultar la siguiente dirección: http://www.javasoft.com/sfaq/:

• Los applets no pueden cargar librerías o definir métodos nativos. Si un applet pudiera definir una llamada a un método nativo le daría acceso a la máquina en la que se ejecuta.

• Los applets no pueden detener la ejecución de la Máquina Virtual de Java.

• No pueden leer ni escribir en el sistema de archivos de la máquina del navegador. No se pueden abrir ni crear ficheros en la máquina del cliente, ni tampoco crear o leer directorios. Si


288

se intenta crear o abrir un objeto java.io.File o java.io.FileInputStream o java.io.FileOutput-Stream en la máquina del cliente dará lugar a una excepción de seguridad.

• Un applet no puede hacer conexiones a través de la red, sólo se puede conectar con el servidor desde el que se cargó el applet.

• No pueden conectarse a puertos del cliente.

• Los applets no pueden actuar como servidores de la red esperando para aceptar conexiones de sistemas remotos.

• Los applets que se quieran comunicar entre sí deben estar en la misma página Web, en la misma ventana del navegador, y además deben ser originarios del mismo servidor.

• No pueden instanciar un objeto de las clases ClassLoader o SecurityManager.

• No pueden acceder o cargar clases de paquetes llamados java que no sean los paquetes estándar del API de Java.

• No pueden ejecutar ningún programa en el sistema local del cliente.

• No pueden leer todas las propiedades del sistema en el que se cargaron. En particular, no puede leer ninguna de las siguientes propiedades del sistema: user.name (nombre de la cuenta del usuario), user.home (directorio home del usuario), java.home (directorio de instalación de Java), user.dir (directorio de trabajo actual del usuario) y java.class.path (directorio en el que se encuentran las clases de Java).

• Los applets tampoco pueden definir ninguna propiedad del sistema.

• Las ventanas que abren los applets tienen un aspecto diferente, aparece la advertencia de que se trata de una ventana abierta o creada por un applet.

• Los applets no pueden instanciar objetos COM (Component Object Model) o comunicarse con ellos, esto es para preservar la seguridad, ya que los objetos COM son poco seguros y permiten realizar operaciones peligrosas en la máquina local.

Los applets se pueden cargar de dos maneras, la forma en que un applet entra en el sistema afecta a lo que se le va a permitir hacer. Si un applet se carga a través de la red, entonces es cargado por el ClassLoader y está sujeto a las restricciones impuestas por el SecurityManager.

Pero si un applet reside en el disco local del cliente, y en un directorio que está en el java.class.path (propiedad de la clase System, que indica en que lugar se encuentran las clases de Java) entonces es cargado por el FileLoader del sistema. Las diferencias principales con los anteriores son las siguientes:

• Pueden leer y escribir ficheros.

• Pueden cargar librerías en la máquina del cliente.

• Pueden ejecutar procesos, es decir, pueden ejecutar cualquier programa en la máquina del cliente.

• Pueden parar la ejecución de la Máquina Virtual de Java.

• No son pasados por el verificador de bytecode.


289

Esta relajación de la seguridad es debido a que se supone que los applets cargados del sistema local son más fiables que los que se cargan a través de la red de forma anónima.

También se relajará la seguridad de los applets en el caso de que éstos se encuentren firmados digitalmente a través de un certificado.

El único "agujero" en la seguridad de un applet es que éste puede reservar mucha cantidad de memoria creando continuamente una gran cantidad de objetos, por ejemplo, un applet podría crear un gran número de ventanas agotando el sistema GUI (Graphical User Interface) de la máquina, iniciar la ejecución de muchos hilos de ejecución paralelos o cargar desde la red una gran cantidad de datos, este tipo de ataque se denomina ataque de negación de servicio (denial of service attack).

Este ataque consume muchos recursos del sistema y puede disminuir la velocidad de la máquina o de la conexión a la red de forma considerable. Aunque este ataque es molesto no puede causar un daño real al sistema, se considera que este ataque está fuera del modelo de seguridad de Java.

Trusted/Untrusted applets Cuando decimos que un applet es trusted (de confianza), este applet podrá saltarse las restricciones de seguridad que vienen impuestas a los applets; pero si es untrusted (no es de confianza) tendrá que ajustarse a las restricciones.

Un applet de Java se ejecuta dentro de un entorno ofrecido por la Máquina Virtual que evita que el applet realice acciones sobre nuestro sistema que pueden ser potencialmente peligrosas desde el punto de vista de la seguridad. La Máquina Virtual de Java deberá discernir si debe permitir que el applet se salte las restricciones de seguridad o que por el contrario las cumpla escrupulosamente, es decir, debe distinguir si un applet es trusted o untrusted.

Por defecto todos applets que cargamos a través de Internet son untrusted, por lo tanto se deben ceñir a las restricciones de seguridad impuestas por la Máquina Virtual.

Para que un applet sea trusted debe ir firmado digitalmente o bien las clases del applet deben estar situadas en el CLASSPATH. De esta forma, si nosotros hemos creado nuestro applet, y nuestra variable de entorno CLASSPATH tiene el valor c:\Java\clases deberemos situar los ficheros de clase del applet en el directorio c:\Java\clases. Esto sólo es recomendable para applets que hayamos desarrollado nosotros o alguna persona de confianza.

Diferencias entre applets y aplicaciones A continuación se comentan las diferencias entre las aplicaciones y los applets de Java. Las aplicaciones son programas individuales que se ejecutan utilizando sólo el intérprete de Java, los applets sin embargo se ejecutan desde un navegador de páginas Web, o desde un visor de applets.

Una referencia a un applet se introduce en una página Web empleando una etiqueta HTML especial. Cuando un navegador carga la página, carga el applet desde el servidor Web y lo ejecuta en el sistema local.

Ya que los applets se ejecutan dentro de un navegador, tienen la ventaja de la estructura que éste les ofrece: una ventana, un contexto de manejo de eventos y gráficos y el interfaz de usuario que la rodea.


290

Sin embargo, todas estas ventajas que tienen los applets sobre las aplicaciones, se ven ensombrecidas por las restricciones impuestas a los applets. Ya que los applets pueden desplegarse desde cualquier parte y ejecutarse en un sistema cliente, las restricciones son necesarias para prevenir que un applet cause daños al sistema o rupturas de seguridad.

Sin estas restricciones los applets podrían escribirse para contener virus, gusanos, etc.… y podrían propagarse por toda la red en cuestión de horas. Sin embargo las aplicaciones de forma explícita no ofrecen estas restricciones de seguridad.

La etiqueta applet En este apartado vamos a comentar las características que ofrece el lenguaje HTML para la integración de los applets dentro de páginas Web. Puesto que los applets están diseñados para usarse en conjunción con la WWW (World Wide Web), es necesario contar con una manera estándar de llamar a los applets dentro de un navegador Web.

Esto lo permiten un juego de etiquetas HTML (Hypertext Markup Language) que se creó para especificar toda la información necesaria para ejecutar un applet. Así, el código HTML puede emplearse para hacer lo siguiente:

• Especificar el directorio del applet.

• Indicar la ubicación del código que emplea el applet.

• Especificar el tamaño en pantalla del applet.

• Ofrecer alternativas para los navegadores que no tengan capacidad para Java.

• Pasar parámetros al applet.

Después de crear el applet y escribir su código, debe añadirse a una página HTML para poder ejecutarse dentro de un navegador. Para ello se debe utilizar la etiqueta <APPLET> del lenguaje HTML. La etiqueta <APPLET> posee los siguientes atributos que a continuación se muestran en la Figura 131, los que son opcionales se encuentran encerrados entre corchetes.

Figura 131


291

En su forma más elemental, utilizando sólo los atributos CODE, WIDTH y HEIGHT, la etiqueta <APPLET> crea un espacio del tamaño deseado en el que se cargará y ejecutará el applet. A continuación se pasa a describir los atributos de la etiqueta <APPLET>.

Codebase Este atributo opcional especifica la dirección URL base del applet, es decir, el directorio o carpeta que contiene el código del applet. Si este atributo no es especificado se utiliza el URL del documento HTML.

Code Este atributo requerido ofrece el nombre del fichero .CLASS que contiene el applet. Si no se utiliza el atributo CODEBASE, el archivo se busca en el mismo directorio del archivo HTML que referencia al applet.

Alt Este atributo opcional especifica el texto que debe ser mostrado en pantalla en el caso de que el navegador utilizado para ver las páginas HTML no tenga capacidad para Java.

Name Esta atributo de carácter opcional especifica un nombre para el applet. Esto hace posible que los applets de una misma página Web se puedan comunicar entre sí, haciendo referencia a su nombre.

Width, Height Estos atributos requeridos definen el ancho y alto (en pixels) del applet, sin tener en cuenta los diálogos o ventanas que pueda mostrar el applet.

Align Este atributo de naturaleza opcional especifica la alineación del applet. Los posibles valores de este atributo son los que se enumeran a continuación:

• TEXTTOP: alinea la parte superior del applet con la parte superior del texto más alto en la línea.

• TOP: alinea el applet con el elemento más alto en la línea, el cual puede ser otro applet, una imagen, o la parte superior del texto.

• ABSMIDDLE: alinea el centro del applet con el centro del elemento más grande de la línea.

• MIDDLE: alinea el centro del applet con el centro de la línea base del texto.


292

• BASELINE: alinea la parte inferior del applet con la línea base del texto.

• ABSBOTTON: alinea la parte inferior del applet con el elemento más bajo en la línea.

Vspace, Hspace Estos atributos opcionales especifican el número de pixels que debe haber encima y debajo del applet (VSPACE) y a cada lado del applet (HSPACE), es decir, los márgenes del applet.

Fuera ya de los atributos de la etiqueta <APPLET> pueden aparecer otras etiquetas que se comentan a continuación:

<PARAM> Esta etiqueta permite especificar parámetros de un applet. Los applets leen los valores de los parámetros con el método getParameter() de la clase Applet.

Los parámetros para los applets son como los argumentos de la línea de comandos para las aplicaciones. Permiten que el usuario pueda personalizar algunas de las operaciones o características del applet. Al definir parámetros se aumenta la flexibilidad del applet, el applet podrá ejecutarse en diferentes situaciones sin necesidad de modificar su código y volver a compilarlo.

Al definir un parámetro para un applet mediante la etiqueta <PARAM> se debe tener en cuenta que es lo que se va a permitir al usuario configurar del applet, como se debe llamar el parámetro, que tipo de valor va a tener el parámetro y cual es su valor por defecto.

Además de ofrecer parámetros al usuario para que pueda configurar el applet, se le debe indicar como se pueden utilizar estos parámetros. Por lo tanto se debe implementar el método getParameterInfo() de la clase Applet para que devuelva toda la información y ayuda referente a los parámetros del applet. Los navegadores pueden utilizar esta información para ayudar a los usuarios e indicar que valores puede dar a los parámetros.

Etiquetas HTML alternativas Si el navegador que carga la página en la que se encuentra el applet no reconoce la etiqueta <APPLET> al no tener capacidad para Java, entonces utiliza estas etiquetas alternativas cuando muestre el documento HTML. Los navegadores con capacidad para Java ignoran todas estas etiquetas alternativas.

Applets de Java: utilizando los applets

Interacción de los applets con el navegador web Cuando realizamos la introducción a los applets, en el capítulo anterior, comentamos que los applets pueden realizar una serie de operaciones apoyándose en el navegador Web. En este apartado vamos a comentar con ejemplos una serie de características que ofrecen los applets y que en cierta medida son exclusivas, y por lo tanto no las presentan las aplicaciones.

Lo primero que vamos a comentar acerca de las capacidades de los applets, es la posibilidad que tienen éstos de comunicarse entre sí en una misma página Web.

Para realizar una comunicación entre diferentes applets de deben tener en cuenta dos restricciones de seguridad:

• Los applets deben estar en la misma página Web, en la misma ventana del navegador.

• Los applets deben ser originarios del mismo servidor.

Un applet para comunicarse con otro puede hacerlo refiriéndose al nombre del applet con el que se quiere comunicar, para ello se usa el método getApplet() del interfaz AppletContext. Este interfaz se corresponde con el entorno o contexto en el que se encuentra un applet, es decir, el documento que contiene al applet y los otros applets contenidos en el mismo documento.

El contexto del applet se obtiene utilizando el método getAppletContext() de la clase Applet, este método devuelve un objeto que representa el contexto en el que se encuentra el applet.


294

Los métodos del interfaz AppletContext pueden ser usados para obtener información relativa al entorno del applet. El método getApplet(), a partir de un nombre que se le pasa como parámetro, nos devuelve una instancia de la clase Applet que representa al applet que posee el nombre que se le ha pasado como parámetro a getApplet() y que se encuentra dentro del entorno correspondiente al AppletContext. Si el applet no existe nos devolverá un nulo.

También se puede utilizar otro método del interfaz AppletContext, llamado getApplets(), que devolverá una enumeración (objeto de tipo java.util.Enumeration) de todos los applets existentes en el documento representado por el correspondiente AppletContext.

Para darle un nombre a cada applet se debe utilizar dentro del documento HTML el atributo name de la etiqueta <APPLET>, así por ejemplo si queremos identificar con el nombre pepe a un applet representado por la clase Ejemplo escribiríamos lo que vemos en el Código fuente 181.

<applet code="Ejemplo.class" width="450" height="200" name="pepe">

Código fuente 181

Vamos a ver todo esto mediante un ejemplo sencillo que va a consistir en un par de applets, representados por las clases Remitente y Destinatario. Estos dos applets se van a enviar un mensaje entre sí.

La clase Destinatario va a facilitar un método público llamado enviarMensaje() que permite a la clase Remitente enviar un mensaje. El código de la clase Destinatario, es el que muestra el Código fuente 182.

import java.applet.*;import java.awt.*;public class Destinatario extends Applet{

private TextField mensaje;public void init(){

mensaje=new TextField(20);add(mensaje);

}public void enviarMensaje(String men){

mensaje.setText(men);}

}

Código fuente 182

Como se puede ver el método enviarMensaje() permite asignar texto a la caja de texto del applet que actúa como destinatario. El código es bastante sencillo y no ofrece ninguna complicación.

Ahora vamos a ver el segundo applet, el que actúa de remitente. Este applet si que va a hacer uso del interfaz AppletContext.

Este applet ofrece una caja de texto y un botón, en la caja de texto escribiremos el mensaje que queremos que aparezca en la caja de texto del applet de destino, y al pulsar el botón invocaremos el método enviarMensaje() de la clase Destinatario. El código de la clase Remitente aparece en el Código fuente 183.

© Grupo EIDOS 15. Applets de Java: utilizando los applets

295

import java.applet.*;import java.awt.*;import java.awt.event.*;public class Remitente extends Applet implements ActionListener{private Button boton;private TextField mensaje;public void init(){

boton=new Button("Enviar mensaje");mensaje=new TextField(20);add(mensaje);add(boton);boton.addActionListener(this);


//se obtiene el contexto del appletAppletContext contexto=getAppletContext();//se obtiene la referencia al otro applet a través de su nombreApplet destinatario=contexto.getApplet("destino");//se invoca el método que nos interesa del applet Destinatario((Destinatario)destinatario).enviarMensaje(mensaje.getText());

}}

Código fuente 183

Especial atención merece el método actionPerformed(), que se ejecutará al pulsar el botón de envío de mensaje del applet. En este método se obtiene primero el contexto del applet, es decir un objeto AppletContext. A continuación se obtiene una referencia al applet que nos interesa, en este caso el applet se llama destino. Y por último se invoca el método deseado del applet, para poder invocarlo debemos realizar un casting (conversión de clases), ya que la clase Applet no dispone del método obtenerMensaje(), este método pertenece a nuestra clase Destinatario.

En el código HTML de la página Web que contiene a los dos applets debemos asignar a la propiedad name de la etiqueta APPLET, que hace referencia al applet Destinatario, el valor destino, ya que es la cadena que le pasamos por parámetro al método getApplet(). El código HTML se muestra en el Código fuente 184.

<HTML><HEAD><META NAME="GENERATOR" Content="Microsoft Visual Studio"><META HTTP-EQUIV="Content-Type" content="text/html"><TITLE>Document Title</TITLE></HEAD><BODY><APPLET code="Destinatario" width="250" height="30" name="destino"></APPLET><hr><APPLET code="Remitente" width="300" height="130"></APPLET></BODY></HTML>

Código fuente 184

En la Figura 132 se puede ver un ejemplo de la ejecución de estos dos applets cooperantes entre sí.


296

Figura 132

Antes habíamos comentado que el interfaz AppletContext ofrece dos métodos para tener referencias a los applets dentro de una misma página Web, los métodos getApplet() y getApplets(). En el ejemplo anterior hemos visto un ejemplo que utiliza el método getApplet(), ahora vamos a ver un nuevo ejemplo que utiliza el método getApplets().

Vamos a crear un applet que muestre el nombre de las clases de todos los applets que se encuentren en la página Web actual, evidentemente este applet también debe estar incluido en la página.

Para mostrar el nombre de las clases, nuestro applet va a utilizar un objeto de la clase TextArea. Al pulsar el botón que ofrece el applet se procederá a obtener las referencias a los applets, para así poder mostrar el nombre de la clase de cada uno de ellos. El código de este applet se indica en el Código fuente 185.

import java.applet.*;import java.awt.*;import java.awt.event.*;import java.util.*;public class ListaApplets extends Applet implements ActionListener{

private TextArea listado;private Button boton;

public void init(){setLayout(new BorderLayout());listado=new TextArea(5,30);boton=new Button("Listar Applets");add("North",listado);add("South",boton);boton.addActionListener(this);


listarApplets();}public void listarApplets(){

AppletContext contexto=getAppletContext();String nombreClase="";listado.setText("");//obtenemos la referencia a todos los applets de la páginaEnumeration applets=contexto.getApplets();//recorremos la lista de appletswhile (applets.hasMoreElements()){


297

//obtenemos la referencia al appletObject applet=applets.nextElement();//recuperamos el nombre de la clase del appletnombreClase=applet.getClass().getName();//añadimos el nombre de la clase al área de textolistado.append(nombreClase+"\n");

}}}

Código fuente 185

Como se puede observar se importa el paquete java.util, este paquete es necesario para poder utilizar la clase Enumeration. Esta clase la utilizamos al ejecutar el método getApplets() del interfaz AppletContext.

El método getApplets() nos devuelve un objeto de la clase Enumeration que contiene todos los applets que existen en la página Web actual.

La clase Enumeration es una clase de utilidad que posee únicamente dos métodos hasMoreElements() y nextElement(). El primero de ellos devuelve un valor booleano y se utiliza para comprobar si existen más elementos en la enumeración, mientras que el segundo de los métodos devuelve el siguiente elemento de la enumeración.

El método nextElement() devuelve siempre un objeto de la clase Object, ya que un objeto de la clase Enumeration puede contener cualquier tipo de objeto.

Si situamos este nuevo applet en la misma página Web que contenía los dos anteriores y lo ejecutamos mostrará el aspecto de la Figura 133.

Figura 133

Otra posibilidad que nos ofrecen los applets es la de cargar páginas en el navegador, es decir, podemos indicar al navegador que muestre una página determinada. Para ello también nos vamos a apoyar en el interfaz AppletContext, este interfaz ofrece el método showDocument() para realizar esta tarea. Este método recibe como parámetro un objeto de la clase URL. La clase URL representa una URL (Uniform Resource Locator) y se encuentra dentro del paquete java.net. Este paquete contiene una serie de clases especializadas en la utilización de recursos y comunicaciones en Internet.

A continuación vamos a realizar un applet que muestre una ventana en la que podemos indicar la URL que deseamos cargar en el navegador.

Vamos a crear, además de la clase del applet, una clase llamada VentanaURL que va a representar la ventana que muestra el applet, antes de seguir con la exposición de este ejemplo vamos a ver el código fuente completo en el Código fuente 186.


298

import java.applet.*;import java.awt.*;import java.awt.event.*;import java.net.*;public class MuestraDocumento extends Applet{

private VentanaURL ventana;public void init(){

ventana=new VentanaURL(getAppletContext());}}class VentanaURL extends Frame implements ActionListener{

//caja de texto que contiene la URLprivate TextField textoURL;private Button boton;private AppletContext contexto;

//el constructor tiene el parámetro contexto para que le pasemos//el contexto del appletpublic VentanaURL(AppletContext contexto){

super("Mostrar Documento");this.contexto=contexto;boton=new Button("Muestra URL");textoURL=new TextField(20);setLayout(new GridLayout(1,2,5,5));add(textoURL);add(boton);pack();show();boton.addActionListener(this);addWindowListener(new AdaptadorVentana());


String cadenaURL=textoURL.getText();URL url=null;//se crea la URL, y es necesario atrapar una excepcion//que lanza su constructortry{

url=new URL(cadenaURL);}catch(MalformedURLException ex){

textoURL.setText("Error en la URL");}//se muestra la URL en el navegadorif (url!=null)

contexto.showDocument(url);}class AdaptadorVentana extends WindowAdapter{public void windowClosing(WindowEvent evento){

dispose();}}}

Código fuente 186

Como se puede ver la clase MuestraDocumento no hace mucho, el applet simplemente crea en su método init() una instancia de la clase VentanaURL, a la que le pasa por parámetro el contexto del applet, ya que la clase que va a realizar la operación de mostrar la URL va a ser la clase VentanaURL, por lo tanto vamos a pasar a comentar la clase VentanaURL.

En el constructor de la clase VentanaURL creamos el interfaz de usuario, registramos los oyentes necesarios para la pulsación del botón y para el cierre de la ventana. Además se inicializa el atributo contexto con el contexto que se ha obtenido en el applet.


299

Al pulsar el botón se procede a recuperar la URL de la caja de texto y a continuación se muestra en el navegador. Es necesario crear una instancia de la clase URL, ya que el método showDocument() recibe un objeto de esta clase como parámetro. Al crear la URL se debe atrapar la excepción que lanza su constructor, esta excepción es de la clase MalformedURLException, esta clase al igual que la clase URL se encuentra en el paquete java.net.

El método showDocument() lo lanzamos sobre el atributo contexto, que como ya hemos comentado es el contexto que nos proporciona el applet.

Si probamos este applet con Internet Explorer 5, volvemos a tener el problema de la ejecución del método destroy() al abandonar la página Web, este problema ya lo comentábamos en el capítulo anterior en el apartado dedicado al ciclo de vida de los applets. Como hemos dicho con IE 5 se ejecuta el método destroy() por lo tanto perdemos el contexto del applet y no podemos volver a cargar otra URL, es decir, el applet funciona sólo la primera vez. Sin embargo con Netscape Navigator 4.5 el funcionamiento es correcto y podemos cargar tantas URLs como queramos.

Este applet, al consistir únicamente en una ventana, podemos insertarlo en la página Web con dimensiones cero. En la Figura 134 se puede ver un ejemplo de la ejecución de este applet.

Figura 134

Otra característica que ofrecen los applets y que se encuentra íntimamente relaciona con el navegador Web es la posibilidad de mostrar mensajes en la línea de estado del navegador. Para esto se vuelve a utilizar un método del interfaz AppletContext, en este caso showStatus(). El método showStatus() recibe como parámetro la cadena de texto que queremos mostrar en la línea de estado del navegador Web.

Antes de continuar se debe aclarar que la línea de estado del navegador Web se encuentra en la zona inferior del mismo y es dónde se indica en que estado se encuentra el documento cargado actualmente.

Para ilustrar la utilización de este nuevo método vamos a realizar un applet que consiste en una caja de texto, en la que introduciremos el texto que queremos aparezca en la línea de estado del navegador, y un botón con el que indicaremos que queremos asignar el texto correspondiente.

El código de este sencillo applet es el Código fuente 187.


300

import java.applet.*;import java.awt.*;import java.awt.event.*;public class LineaEstado extends Applet implements ActionListener{

private Button boton;private TextField texto;

public void init(){boton=new Button("Muestra Estado");texto=new TextField(20);setLayout(new GridLayout(1,2,5,5));add(texto);add(boton);boton.addActionListener(this);


AppletContext contexto=getAppletContext();contexto.showStatus(texto.getText());

}}

Código fuente 187

Y un ejemplo de la ejecución del mismo se puede observar en la Figura 135.

Figura 135

Hasta ahora se han comentado funciones de los applets que tienen que ver con el navegador Web directamente, como el propio título del apartado indica, pero también vamos a incluir en este mismo apartado un par de funciones de los applets, que aunque ya no tengan que ver directamente con el navegador, pueden resultar interesantes.

La primera de estas funciones ya la habíamos comentado con anterioridad y consiste en el paso de parámetros al applet desde la página Web. Este paso de parámetros se realiza mediante la etiqueta <PARAM>.

Para recuperar el parámetro desde el applet utilizamos el método getParameter() de la clase Applet, pasándole por parámetro una cadena que se corresponde con el nombre del parámetro.

El Código fuente 188 se corresponde con el de un applet que recoge un parámetro llamado nombre, y muestra un saludo en la pantalla.


301

import java.applet.*;import java.awt.*;public class Parametros extends Applet{

private String parametro="";public void init(){

parametro=getParameter("nombre");if (parametro==null)

parametro= "persona desconocida";}public void paint(Graphics g){

g.drawString("Buenos días "+parametro,10,20);}}

Código fuente 188

Como se puede observar en el código, el método init() es el encargado de recuperar el parámetro y es en el método paint() dónde se muestra el saludo utilizando el atributo del applet que posee el valor ofrecido por el parámetro.

En la Figura 136 se muestra la ejecución de este applet, en las dos situaciones, con parámetro y sin el.

Figura 136

Y el código HTML de la página de la Figura 136 es el Código fuente 189.

<HTML><HEAD><META NAME="GENERATOR" Content="Microsoft Visual Studio"><META HTTP-EQUIV="Content-Type" content="text/html"><TITLE>Document Title</TITLE></HEAD><BODY><APPLET code="Parametros" height="50" name="destino" width="250"><PARAM name="nombre" value="Pepe"></APPLET><hr>


302

<APPLET code="Parametros" height="50" name="destino" width="250"></APPLET></BODY></HTML>

Código fuente 189

La siguiente, y última función de los applets que vamos a comentar en este apartado, es la reproducción se sonidos. Para reproducir sonidos disponemos del interfaz AudioClip que lo podemos encontrar dentro del paquete java.applet, pero para utilizar un objeto de este tipo debemos antes asignarle el fichero de sonido que representa.

El interfaz AudioClip ofrece tres métodos que nos permiten manipular un fichero de sonido, éstos son play(), loop() y stop(). El método play() ejecuta el fichero de sonido, es decir, reproduce el sonido, el método loop() también lo reproduce pero en un bucle infinito, y stop() detiene la ejecución del sonido.

Vamos a ver esto con el ejemplo de un applet que permite reproducir un sonido, pararlo y ejecutarlo en un bucle, primero se muestra el código (Código fuente 190) y a continuación lo comentamos.

import java.awt.*;import java.applet.*;import java.awt.event.*;import java.net.*;public class Sonidos extends Applet implements ActionListener{

private AudioClip sonido;private Button ejecutar,bucle,parar;

public void init(){setLayout(new GridLayout(3,1,10,10));ejecutar=new Button("Play");bucle=new Button("Loop");parar=new Button("Stop");add(ejecutar);add(bucle);add(parar);ejecutar.addActionListener(this);bucle.addActionListener(this);parar.addActionListener(this);//obtenemos el camino hasta el lugar dónde se encuentra el appletURL codeBase=getCodeBase();//cargamos el fichero de sonidosonido=getAudioClip(codeBase,getParameter("sonido"));


AppletContext contexto=getAppletContext();if (evento.getSource()==ejecutar){

contexto.showStatus("Reproducir sonido");sonido.play();

}else if (evento.getSource()==parar){

contexto.showStatus("Detener sonido");sonido.stop();

}else{

contexto.showStatus("Reproducir sonido en un bucle");sonido.loop();

}}}

Código fuente 190


303

Como se puede comprobar a la vista del código, en este caso tenemos tres fuentes de eventos y un mismo oyente, por lo que en el método actionPerformed() se debe identificar la fuente del evento, para ello utilizamos el método getSource() de la clase java.util.EventObject, de esta clase heredan todas las clase que representan a los eventos. Este método nos devuelve la referencia al objeto que ha producido el evento, por lo tanto debemos comparar el valor devuelto con cada uno de los objetos que son fuente de eventos, es decir, con cada uno de los objetos Button.

En el método init() del applet además de crear el interfaz de usuario (Figura 137) y registrar los oyentes correspondientes, cargamos el fichero de sonido. Pero antes necesitamos obtener la ruta hasta nuestro applet, esto se consigue mediante el método getCodeBase() de la clase Applet que nos devuelve un objeto de la clase URL que contiene la dirección hasta nuestro applet. A continuación utilizamos el método getAudioClip() de la clase Applet, el cual permite cargar en el objeto AudioClip correspondiente el fichero de sonido que le especificamos por parámetro.

Como se habrá observado, el nombre del fichero de sonido lo pasamos mediante un parámetro del applet (etiqueta <PARAM>) y lo recuperamos con el método getParameter() de la clase Applet.

Figura 137

Eventos, gráficos y fuentes en los applets En este apartado vamos a tratar las clases Graphics, FontMetrics y Font, es decir, vamos a tratar la parte gráfica de los applets, algo que habíamos comentado de forma muy breve al utilizar el método paint().

También se va a comentar algunos aspectos del tratamiento de eventos dentro de los applets y se mostrarán algunos tipos de eventos que no habíamos visto hasta ahora. Todo ello se irá mostrando y comentando a través de numerosos ejemplos de applets.

Pasemos a la parte gráfica de nuestro apartado.

El objeto de la clase Graphics que recibe como parámetro el método paint() de la clase Applet representa a la superficie del applet y todo lo que se dibuje o escriba en el se mostrará en el applet. Aunque el método paint() lo estamos utilizando en la clase Applet, se debe señalar que este método se hereda de la clase Container, y por lo tanto lo presentan todos los objetos que realicen funciones de contenedor.

La superficie del applet en el navegador Web Internet Explorer 5 se representa mediante el color gris por defecto, pero en el navegador Netscape Navigator 4.5 se representa mediante el color blanco por defecto.

El método de la clase Graphics que hemos estado utilizando en diferentes momentos en este capítulo ha sido drawString(). Este método mostrará la cadena de caracteres que le pasemos por parámetro y en la posición que le indiquemos. El origen de coordenadas en la superficie del applet se encuentra en la parte superior izquierda.


304

Vamos a realizar un applet que vaya mostrando las coordenadas sobre las que se encuentra en ese momento el cursor del ratón dentro del applet, además estas coordenadas se muestran justamente al lado del cursor, es decir, en la propia coordenada en la que se encuentra.

Nuestro applet va a tener una clase interna que va a ser una clase adaptadora que hereda de la clase MouseMotionAdapter, es decir, va a ser la clase oyente de los movimientos del ratón en nuestro applet. Este ejemplo es interesante también porque vemos un evento que no habíamos tratado hasta ahora, el evento de los movimientos del ratón.

El método que vamos a utilizar y sobrescribir de la clase MouseMotionAdapter es mouseMoved() . Como su propio nombre indica este método se ejecutará cuando se mueva el ratón. En este método recogemos los valores actuales de las coordenadas y se los asignamos a los atributos coordX y coordY de nuestro applet, estos atributos han sido declarados para representar a las coordenadas x e y del ratón dentro de nuestro applet. En la última línea del método mouseMoved() se llama al método repaint() para que se actualice y repinte la superficie de nuestro applet.

Los valores de las coordenadas se obtienen utilizando los métodos getX() y getY() de la clase MouseEvent.

En el método paint() escribiremos el valor de las coordenadas en la coordenada exacta, pero antes de seguir comentando más acerca de este applet de ejemplo veamos su código, en el Código fuente 191.

import java.awt.*;import java.applet.*;import java.awt.event.*;public class Coordenadas extends Applet{

int coordX, coordY;public void init(){

//se inicializan las coordenadascoordX=-1;coordY=-1;//registramos el oyente de los movimientos del ratónaddMouseMotionListener(new AdaptadorMovimientosRaton());

}public void paint(Graphics g){

//se comprueba que las coordenadas son correctasif (coordX!=-1)

//se escribe la coordenada en la posición en la//que está el ratóng.drawString("("+coordX+","+coordY+")",coordX,coordY);

}//clase adaptadora interna que trata los movimientos del ratón

class AdaptadorMovimientosRaton extends MouseMotionAdapter{public void mouseMoved(MouseEvent evento){

coordX=evento.getX();coordY=evento.getY();//se vuelve a pintar el appletrepaint();

}}

}

Código fuente 191

En el método paint() mostramos las coordenadas en las que se encuentra el cursor del ratón mediante el ya conocido método drawString() de la clase Graphics.


305

Pero si probamos este applet comprobamos que no funciona correctamente, ya que cuando salimos de la superficie del applet las coordenadas se quedan pintadas en la superficie del applet. Para evitar este efecto debemos modificar el código del applet para tener en cuenta también los eventos de la entrada y salida del ratón en nuestro applet.

Para ello hemos creado una clase interna que herede a la clase adaptadora MouseAdapter y que implemente los métodos mouseExited() y mouseEntered(). Al applet Coordenadas se le añade un nuevo atributo de tipo booleano llamado fuera, para saber en que situación estamos. El nuevo código del applet se muestra en el Código fuente 192.

import java.awt.*;import java.applet.*;import java.awt.event.*;public class Coordenadas2 extends Applet{

int coordX, coordY;//indica si el ratón está fuera del appletboolean fuera;

public void init(){coordX=-1;coordY=-1;fuera=false;addMouseMotionListener(new AdaptadorMovimientosRaton());addMouseListener(new AdaptadorRaton());


//se comprueba si el ratón se encuentra en la//superficie del appletif(!fuera){

if(coordX!=-1)g.drawString("("+coordX+","+coordY+")",coordX,coordY);showStatus("");

}else

showStatus("El ratón ha salido");}class AdaptadorMovimientosRaton extends MouseMotionAdapter{public void mouseMoved(MouseEvent evento){

coordX=evento.getX();coordY=evento.getY();repaint();

}}class AdaptadorRaton extends MouseAdapter{public void mouseExited(MouseEvent evento){

//el ratón ha salidofuera=true;repaint();

}public void mouseEntered(MouseEvent evento){

//el ratón ha entradofuera=false;repaint();

}

}}

Código fuente 192


306

En este código se muestra un mensaje en la línea de estado del navegador, pero no se utiliza el interfaz AppletContext, sino que directamente se utiliza el método showStatus() de la clase Applet, el resultado es el mismo que veíamos en el apartado anterior.

Con esta nueva versión del applet ya no se produce el efecto comentado anteriormente, cuando desde el método mouseExited() se invoca al método paint() del applet mediante repaint(), el atributo fuera tiene el valor true, por lo tanto en el método paint() no escribe nada y se eliminan las coordenadas de la superficie del applet.

En este punto es necesario realizar una aclaración. Cuando modificamos el código fuente de un applet que ya hemos ejecutado en el navegador, si lo volvemos a probar, en muchos casos, los cambios realizados no se reflejan, esto es debido a que el applet se encuentra en la memoria caché del navegador y se está utilizando la versión anterior de nuestro fichero de clase. En este caso la solución es cerrar el navegador y volver a abrirlo para probar el nuevo applet.

En la Figura 138 se puede observar un ejemplo de ejecución de este applet.

Figura 138

Si cambiamos todas las sentencias repaint() por la siguiente paint(getGraphics()), podemos pensar que el efecto es el mismo, es decir, la llamada al método paint(). Si realizamos este cambio y ejecutamos el applet de nuevo vemos un efecto distinto, las coordenadas que escribimos nunca se borran, como se puede observar en la Figura 139.

El método getGraphics() de la clase Component nos devuelve el objeto Graphics que se corresponde con la superficie del componente gráfico correspondiente, en este caso la superficie del applet.

Figura 139


307

Este efecto se produce porque no hemos definido correctamente lo que significa llamar al método repaint(), habíamos dicho que el método repaint() llamaba al método paint() del applet, pero esto no es correcto, ya que la llamada no es directa, sino que el método repaint() llama antes al método update() de la clase Component y después de llamar al método update() llama al método paint(). La función que realiza el método update() antes de llamar al método paint() es la de limpiar o borrar toda la superficie que se encuentre representada por la clase Graphics.

Por lo tanto si antes de todas las sentencias paint(getGraphics()) añadimos la sentencia update(getGraphics()) el efecto será el idéntico al que se producía al lanzar el método repaint().

Vamos a seguir comentando la utilización del objeto Graphics en los applets en conjunción con el tratamiento de eventos dentro de los mismos. En este caso se va a mostrar un ejemplo de un applet que consiste en escribir en la superficie del mismo la cadena "¡click!" en las coordenadas en las que se haya producido la pulsación del ratón.

Para ello vamos a utilizar una clase adaptadora que herede de la clase MouseAdapter, y el método que nos va a interesar va a ser el método mousePressed(). Este método se ejecutará cuando se pulse el botón del ratón. El código de este applet es el que se muestra en el Código fuente 193.

import java.awt.*;import java.applet.*;import java.awt.event.*;public class AppletClick extends Applet{

private int coordX,coordY;public void init(){

coordX=-1;coordY=-1;addMouseListener(new AdaptadorRaton(this));


if (coordX!=-1)g.drawString("¡Click!",coordX,coordY);

}//métodos de accesopublic void modificaX(int x){

coordX=x;}public void modificaY(int y){

coordY=y;}}class AdaptadorRaton extends MouseAdapter{

private AppletClick fuente;public AdaptadorRaton(AppletClick fuente){

this.fuente=fuente;}//detectamos la pulsación en el ratónpublic void mousePressed(MouseEvent evento){

fuente.modificaX(evento.getX());fuente.modificaY(evento.getY());fuente.repaint();

}}

Código fuente 193


308

Como se puede comprobar, al no utilizar una clase interna debemos ofrecer un par de métodos de acceso para que la clase AdaptadorRaton pueda modificar los atributos coordX y coordY de la clase AppletClick, van a ser estos dos atributos los que representen la coordenada en la que se debe escribir la cadena. Además debemos llevar la referencia de la clase fuente del evento, para ello la clase AdaptadorRaton tiene como atributo un objeto de la clase AppletClick.

En este caso no es necesario controlar que el ratón salga de la superficie de nuestro applet, ya que el evento de la pulsación del ratón siempre se va a producir en el interior del mismo.

El aspecto de este applet en ejecución es el de la Figura 140.

Figura 140

Podemos realizar una modificación sobre el código anterior para que la cadena "¡Click!" sólo aparezca en el momento de la pulsación del botón y no permanezca pintada en al superficie del applet. Para ello debemos implementar el método mouseReleased(). El método mouseReleased() se ejecutará cuando se suelte el botón del ratón, es decir, un click de ratón ejecutará primero el método mousePressed() y a continuación el método mouseReleased().

En el método mouseReleased() asignamos el valor –1 a los atributos de la clase AppletClick que representan las coordenadas del ratón y a continuación se llama al método repaint(). El código del método mouseReleased() se muestra en el Código fuente 194.

public void mouseReleased(MouseEvent evento){fuente.modificaX(-1);fuente.modificaY(-1);fuente.repaint();

}

Código fuente 194

Creo que ya hemos visto bastante de momento sobre el método drawString() de la clase Graphics, el método paint() y el tratamiento de eventos sobre la superficie del applet, por lo tanto a continuación nos vamos a centrar más en los distintos métodos de la clase Graphics. De esta clase comentaremos desde los métodos que nos permiten modificar el aspecto del applet a los que nos permiten dibujar distintas figuras e insertar ficheros de imágenes. También trataremos los tipos de fuente dentro de los applets.


309

En todos los ejemplos anteriores cuando escribimos una cadena en la superficie del applet ésta parece en negro, si queremos que aparezca en un color determinado el texto, utilizaremos el método setColor() de la clase Graphics, de esta forma todo lo que se pinte en el objeto Graphics del applet aparecerá con el color especificado como parámetro en el método setColor().

El método setColor() recibe como parámetro un objeto de la clase Color que va a representar el color que se quiere asignar al objeto Graphics correspondiente.

La clase Color se encuentra dentro del paquete java.awt y representa como su nombre indica los colores. Esta clase ofrece una serie de constantes para representar colores estándar: rojo, azul, amarillo, etc. Así para asignar el color azul a un objeto Graphics escribiremos lo que indica el Código fuente 195.

g.setColor(Color.blue);

Código fuente 195

Pero si queremos asignar un color personalizado por nosotros mismos, deberemos crear un objeto de la clase Color y pasárselo por parámetro al método setColor(). Para indicar un color personalizado, el constructor de la clase Color acepta como parámetros tres enteros en los rangos 0-255 siguiendo por lo tanto la definición de colores según la norma RGB. Cada uno de los enteros indica la intensidad de color rojo, verde y azul, respectivamente. De esta forma, si queremos asignar un color personalizado tenemos que escribir una sentencia similar a la que muestra el Código fuente 196.

g.setColor(new Color(200,4,100));

Código fuente 196

Para asignar un color al fondo del applet utilizamos el método setBackGround(), pero este método no lo ofrece la clase Graphics, sino que se encuentra en la clase Applet. Al método setBackGround() le pasamos por parámetro un objeto de la clase Color, al igual que hacíamos con el método anterior.

setBackground(new Color(12,134,100));

Código fuente 197

Hemos modificado el color de fondo del applet y el color de los elementos gráficos que van a aparecer en el mismo, ahora vamos a modificar el tipo de letra.

Para modificar el tipo de letra utilizaremos el método setFont() de la clase Graphics. Este método recibe como parámetro un objeto de la clase Font que se corresponde con la letra que se desea utilizar.

La clase Font se encuentra en el paquete java.awt y tiene un constructor que nos permite especificar el tipo o nombre de la letra, el aspecto que va a tener (normal, cursiva o negrita) y el tamaño de la misma. Así si queremos asignar a nuestro applet una letra de tipo Courier en negrita y de tamaño 20 píxeles escribiremos el Código fuente 198.


310

g.setFont(new Font("Courier",Font.BOLD,20));

Código fuente 198

Para definir los diferentes aspectos de las fuentes la clase Font ofrece una serie de constantes, Font.BOLD para la fuente en negrita, Font.ITALIC para la letra cursiva y Font.PLAIN para que muestre el aspecto normal.

Para mostrar un ejemplo sencillo de todo lo visto hasta el momento vamos a realizar el famoso applet "Hola Mundo", pero modificando los colores y el tipo de letra. El código de este applet es el Código fuente 199.

import java.awt.*;import java.applet.*;public class HolaMundo extends Applet{public void init(){

setBackground(Color.pink);}public void paint(Graphics g){

g.setColor(new Color(200,4,100));g.setFont(new Font("TimesRoman",Font.ITALIC,20));g.drawString("Hola Mundo",20,20);

}}

Código fuente 199

Y el aspecto de esta nueva versión del applet "Hola Mundo" se puede comprobar en la Figura 141.

Figura 141

La clase Font ofrece una serie de métodos que nos permiten consultar las características de la fuente actual. Estos métodos son:

• getName(): devuelve una cadena que indica el nombre de la fuente.

• getSize(): devuelve el tamaño de la fuente actual como un entero.


311

• getStyle(): devuelve el aspecto de la fuente actual mediante un entero que se corresponde con los valores de las constantes de la clase Font. Font.PLAIN fuente normal tiene el valor 0, Font.BOLD fuente negrita tiene el valor 1, Font.ITALIC tiene el valor 2 y la combinación de negrita y cursiva devolverá el valor 3.

• isPlain(): devuelve verdadero si el aspecto de la fuente es normal.

• isBold(): devuelve verdadero si el aspecto de la fuente es negrita.

• isItalic(): devuelve verdadero si el aspecto de la fuente es cursiva.

Para obtener información acerca de las fuentes en el paquete java.awt encontramos también la clase FontMetrics. Esta clase ofrece una serie de métodos que permiten consultar una serie características de las fuentes que tiene asignadas actualmente la clase Graphics y que tiene que ver con las métricas de la fuente.

Para obtener una instancia de un objeto de la clase FontMetrics lanzaremos el método getFontMetrics() de la clase Graphics sobre el objeto Graphics del que se quiere consultar la información de su letra.

Algunos de los métodos de la clase FontMetrics son getHeight() y getCharWidth(), que nos indican la altura de la letra y la anchura de un carácter determinado, respectivamente, en pixeles. Como se puede deben ver estos métodos ofrecen una información más detallada y específica de las métricas de la fuente que los métodos de la clase Font. Otros métodos de esta clase son:

• stringWidth(): se le pasa una cadena por parámetro y devuelve la anchura de la cadena en pixeles.

• getAscent(): devuelve la distancia entre la línea base de la fuente y la parte superior de los caracteres.

• getDescent(): devuelve la distancia entre la línea base de la fuente y la parte inferior de los caracteres, esto se aplica a caracteres como p y q que caen más bajo de la línea base.

• getLeading(): devuelve el interlineado de la fuente.

El siguiente ejemplo es un applet que permite configurar el mensaje "Hola Mundo", ofrece un interfaz de usuario para realizar esta tarea, además mediante este interfaz de usuario vamos a comentar el tratamiento de nuevos eventos, como son el de selección de una lista desplegable, la entrada de texto en un caja de texto y el de la selección de una casilla de verificación. Para la construcción del interfaz se ha utilizado el gestor de diseño GridLayout, BorderLayout y el anidamiento de objetos Panel.

Se podría considerar que este applet es un ejemplo que además de mostrar lo que hemos explicado sobre el tratamiento de fuentes y color, también ofrece un resumen de muchos de los puntos vistos en anteriores apartados y capítulos, por lo que puede resultar bastante interesante.

Este applet va a ser algo complicado, por lo tanto vamos a cambiar un poco la filosofía que veníamos utilizando hasta ahora en la explicación de los ejemplos, en lugar de mostrar todo el código y luego comentarlo, vamos a desglosarlo y comentarlo más minuciosamente, aunque para una mayor claridad al final de la exposición mostraremos el código completo.

El primer punto que vamos a tratar va a ser la construcción del interfaz de usuario. Para que sea más claro primero vamos a mostrar el aspecto del applet, a continuación comentamos un poco su estructura y a continuación se procederá a facilitar el código fuente. El interfaz de usuario que presenta el applet


312

va a ser el de la Figura 142, que como se puede ver está formado por un objeto TextField, varios objetos Label, dos objetos Checkbox y dos objetos Choice.

Figura 142

En realidad todos los componentes AWT utilizados se encuentran incluidos dentro de un objeto Panel, y es este objeto Panel, conteniendo todos los componentes, el que se añade al applet. Se han utilizado diversos paneles auxiliares, con diferentes gestores de diseño, para ir colocando los componentes del interfaz de usuario.

El panel principal, denominado en el código panelInterfaz, presenta un gestor de diseño de la clase GridLayout de 2 filas y una columna. En la primera fila se añade un panel representado por el objeto panel1, que contendrá los controles que indican el tamaño y aspecto de la fuente, y en la segunda fila un panel representado por el objeto panel3. A su vez estos dos paneles incluyen en su interior otros gestores de diseño y otros paneles.

En la Figura 143 se puede ver un esquema en el que se identifican cada uno de los paneles y como se encuentran divididos.

Figura 143

El código que permite construir este interfaz de usuario lo tenemos en el método creaInterfaz(). Todos los componentes AWT utilizados para crear el interfaz han sido declarados como atributos de nuestro applet.

public void creaInterfaz(){//panel que contiene todo el interfazpanelInterfaz=new Panel();panelInterfaz.setLayout(new GridLayout(2,1));//panel que contiene los controles de tamaño y aspecto de la fuente


313

panel1=new Panel();panel1.setLayout(new GridLayout(1,3,5,1));//panel que contiene la caja de texto con el tamaño de la fuentepanel2=new Panel();panel2.setLayout(new BorderLayout());tamaño=new TextField(10);panel2.add("North",new Label("Tamaño"));panel2.add("South",tamaño);panel1.add(panel2);negrita=new Checkbox("Negrita");panel1.add(negrita);cursiva=new Checkbox("Cursiva");panel1.add(cursiva);panelInterfaz.add(panel1);//panel que contiene las dos listas desplegablespanel3=new Panel();panel3.setLayout(new GridLayout(1,2,5,1));//panel que contiene la lista con los tipos de letrapanel4=new Panel();panel4.setLayout(new GridLayout(2,1));panel4.add(new Label("Tipo Letra:"));tipoLetra=new Choice();tipoLetra.addItem("Courier");tipoLetra.addItem("Arial");tipoLetra.addItem("TimesRoman");panel4.add(tipoLetra);panel3.add(panel4);//panel que contiene la lista con los colorespanel5=new Panel();panel5.setLayout(new GridLayout(2,1));panel5.add(new Label("Color Letra:"));colorLetra=new Choice();colorLetra.addItem("rojo");colorLetra.addItem("azul");colorLetra.addItem("verde");panel5.add(colorLetra);panel3.add(panel5);panelInterfaz.add(panel3);add(panelInterfaz);}

Código fuente 200

A la vista del código fuente del método creaInterfaz() y el esquema de la Figura 143, damos por concluida la primera parte de la explicación.

Al añadir el panel panelInterfaz al applet, el resto de la superficie del applet queda reservada para contener la cadena de texto a la que se va a ir modificando su aspecto según lo indiquemos en los controles del interfaz de usuario.

Ahora debemos centrarnos en el tratamiento de eventos. En nuestro applet tenemos cinco fuentes de eventos, la caja de texto, las dos casillas de verificación y las dos listas desplegables, pero vamos a tener un único oyente, nuestro applet.

La caja de texto va a lanzar un evento del tipo TextEvent cada vez que se modifique, ya que queremos que se cambie el tamaño de las letras mientras que lo indicamos en la caja de texto. Este evento puede ser atrapado y tratado por un oyente que implemente el interfaz TextListener. El interfaz TextListener tiene un único método, llamado textValueChanged() y que se ejecutará cuando se modifique el contenido de la caja de texto. Por lo tanto el applet deberá implementar el interfaz TextListener.


314

Cuando cambiamos el valor de un objeto Checkbox o un objeto Choice se lanza un evento de la clase ItemEvent. Este evento será tratado por un oyente que implemente el interfaz ItemListener. El interfaz ItemListener, al igual que el anterior, tiene un único método llamado itemStateChanged() que se ejecutará cuando se seleccione un elemento de la lista o se modifique el valor de la casilla de verificación. Por lo tanto nuestro applet además de implementar el interfaz TextListener debe implementar el interfaz ItemListener.

La declaración de nuestra subclase de clase Applet quedaría como indica el Código fuente 201.

public class Fuentes extends Applet implements ItemListener, TextListener{}

Código fuente 201

En el método itemStateChanged() deberemos distinguir en que situación estamos, ya que este método se puede ejecutar desde cuatro fuentes diferentes, las dos casillas de verificación o las dos listas desplegables, realizando en cada caso un proceso distinto, cada uno de estos procesos los comentaremos más adelante.

El tratamiento de cualquiera de las cinco situaciones distintas que se puedan dar en el lanzamiento de un evento, es decir, modificación del contenido de la caja de texto, modificación de cualquiera de las dos casillas de verificación y selección de un elemento de cualquiera de las dos listas, ocasionarán una llamada al método repaint(), y consecuentemente una llamada al método paint(), que es precisamente el método que pasamos a comentar a continuación.

En el método paint() lo que vamos a hacer va a ser asignar al objeto Graphics de nuestro applet los valores que se hayan indicado en el interfaz de usuario y que tienen que ver con el color de la letra, tamaño, tipo y aspecto. Por lo tanto es necesario definir en nuestro applet cuatro atributos que representen cada uno de estos valores. Y en los métodos para el tratamiento de eventos, es decir en los métodos textValueChanged() y itemStateChanged(), lo que deberemos hacer antes de llamar al método repaint() es actualizar el valor del atributo correspondiente.

El método paint() simplemente emplea los valores de los atributos del applet para dibujar en pantalla el mensaje Hola Mundo. El código de este método es el Código fuente 202.

public void paint(Graphics g){g.setFont(new Font(tipo,aspecto,tam));g.setColor(color);g.drawString("Hola Mundo",10,180);

}

Código fuente 202

Aquí se pueden apreciar los atributos que se han definido para nuestra clase Fuentes. El atributo tipo de la clase String contendrá el valor que se ha seleccionado en la lista desplegable que contiene los tipos de letra disponibles, el atributo aspecto del tipo primitivo int contiene el valor de la combinación de las casillas de verificación que indican si la letra va ser en negrita y/o en cursiva.

El atributo tam del tipo primitivo int contiene el valor de la caja de texto que indica el tamaño de la fuente, y por último el atributo color que es un objeto de la clase Color, va a contener el color indicado en la lista desplegable correspondiente. Si bien el resto de los valores de los atributos se asigna de


315

forma más o menos directa, en el caso del atributo color debemos emplear un método auxiliar llamado devuelveColor() que permite realizar la traducción del color especificado en la lista de colores con los disponibles en la clase Color como constantes de la misma. El código de este método es el Código fuente 203.

public Color devuelveColor(String col){if (col.equals("rojo"))

return Color.red;else if (col.equals("azul"))

return Color.blue;else return Color.green;

}

Código fuente 203

En el método init() del applet se deben inicializar los todos estos atributos, además de esta inicialización se lanza el método creaInterfaz() y se registra el oyente para las cinco fuentes de eventos ya comentadas. El código del método init() es el Código fuente 204.

public void init(){creaInterfaz();tam=20;tipo="Arial";color=Color.green;aspecto=Font.PLAIN;tipoLetra.addItemListener(this);colorLetra.addItemListener(this);tamaño.addTextListener(this);negrita.addItemListener(this);cursiva.addItemListener(this);

}

Código fuente 204

Ya sólo nos queda entrar en detalle en los métodos que tratan los eventos. El método textValueChanged() recupera el valor de la caja de texto correspondiente, lo transforma al tipo primitivo int y se lo asigna al atributo tam de la clase Fuentes. La conversión de cadena de caracteres a tipo int se realiza mediante el método estático parseInt() de la clase Integer, si se produce algún error en la transformación se lanza la excepción NumberFormatException, si se produce esta excepción no se modifica el valor del atributo tam.

public void textValueChanged(TextEvent evento){int t;try{

t=Integer.parseInt(tamaño.getText());tam=t;repaint();

}catch (NumberFormatException ex){}

}

Código fuente 205


316

El método itemStateChanged() debe utilizar el método getSource() sobre el objeto evento de la clase ItemEvent que recibe como parámetro, para averiguar la fuente del evento, ya que, como ya hemos comentado, hay cuatro fuentes posibles.

Si el origen del evento es cualquiera de los dos objetos Choice se recupera el valor de la lista desplegable mediante el método getSelectedItem() de la clase Choice, y se le asigna al atributo correspondiente. Y si el origen del evento es uno de los objetos Checkbox se modifica el atributo aspecto sumándole o restándole, según el estado del objeto Checkbox, el valor que se corresponde con la casilla verificada, es decir, Font.BOLD o Font.ITALIC. El código de este método se puede observar en el Código fuente 206.

public void itemStateChanged(ItemEvent evento){if(evento.getSource()==tipoLetra){

tipo=tipoLetra.getSelectedItem();}else if(evento.getSource()==colorLetra){

color=devuelveColor(colorLetra.getSelectedItem());}else if(evento.getSource()==negrita){

if (negrita.getState())aspecto=aspecto+Font.BOLD;

elseaspecto=aspecto-Font.BOLD;

}else if (evento.getSource()==cursiva){

if (cursiva.getState())aspecto=aspecto+Font.ITALIC;

elseaspecto=aspecto-Font.ITALIC;

}repaint();

}

Código fuente 206

Una vez comentado cada fragmento del código del applet Fuentes, en el Código fuente 207, se muestra el código completo del mismo para tener una visión más general.

import java.awt.*;import java.applet.*;import java.awt.event.*;public class Fuentes extends Applet implements ItemListener, TextListener{

private Choice tipoLetra, colorLetra;private Checkbox negrita, cursiva;private TextField tamaño;private Panel panelInterfaz, panel1, panel2,panel3,panel4,panel5;private String tipo;private int tam;private Color color;private int aspecto;public void init(){

creaInterfaz();tam=20;tipo="Arial";color=Color.green;aspecto=Font.PLAIN;


317

tipoLetra.addItemListener(this);colorLetra.addItemListener(this);tamaño.addTextListener(this);negrita.addItemListener(this);cursiva.addItemListener(this);

}public void itemStateChanged(ItemEvent evento){

if(evento.getSource()==tipoLetra){tipo=tipoLetra.getSelectedItem();

}else if(evento.getSource()==colorLetra){

color=devuelveColor(colorLetra.getSelectedItem());}else if(evento.getSource()==negrita){

if (negrita.getState())aspecto=aspecto+Font.BOLD;

elseaspecto=aspecto-Font.BOLD;

}else if (evento.getSource()==cursiva){

if (cursiva.getState())aspecto=aspecto+Font.ITALIC;

elseaspecto=aspecto-Font.ITALIC;

}repaint();

}public void textValueChanged(TextEvent evento){

int t;try{

t=Integer.parseInt(tamaño.getText());tam=t;repaint();

}catch (NumberFormatException ex){}

}public Color devuelveColor(String col){

if (col.equals("rojo"))return Color.red;

else if (col.equals("azul"))return Color.blue;

else return Color.green;}public void paint(Graphics g){

g.setFont(new Font(tipo,aspecto,tam));g.setColor(color);g.drawString("Hola Mundo",10,180);

}public void creaInterfaz(){//panel que contiene todo el interfazpanelInterfaz=new Panel();panelInterfaz.setLayout(new GridLayout(2,1));//panel que contiene los controles de tamaño y aspecto de la fuentepanel1=new Panel();panel1.setLayout(new GridLayout(1,3,5,1));//panel que contiene la caja de texto con el tamaño de la fuentepanel2=new Panel();panel2.setLayout(new BorderLayout());tamaño=new TextField(10);panel2.add("North",new Label("Tamaño"));panel2.add("South",tamaño);panel1.add(panel2);negrita=new Checkbox("Negrita");panel1.add(negrita);cursiva=new Checkbox("Cursiva");panel1.add(cursiva);panelInterfaz.add(panel1);


318

//panel que contiene las dos listas desplegablespanel3=new Panel();panel3.setLayout(new GridLayout(1,2,5,1));//panel que contiene la lista con los tipos de letrapanel4=new Panel();panel4.setLayout(new GridLayout(2,1));panel4.add(new Label("Tipo Letra:"));tipoLetra=new Choice();tipoLetra.addItem("Courier");tipoLetra.addItem("Arial");tipoLetra.addItem("TimesRoman");panel4.add(tipoLetra);panel3.add(panel4);//panel que contiene la lista con los colorespanel5=new Panel();panel5.setLayout(new GridLayout(2,1));panel5.add(new Label("Color Letra:"));colorLetra=new Choice();colorLetra.addItem("rojo");colorLetra.addItem("azul");colorLetra.addItem("verde");panel5.add(colorLetra);panel3.add(panel5);panelInterfaz.add(panel3);add(panelInterfaz);}}

Código fuente 207

En el siguiente enlace se puede encontrar el fichero de código fuente del applet.

En la Figura 144 se ofrece un ejemplo de la ejecución del applet. Y con esto se da por concluida la explicación de este applet de ejemplo. Lo que veremos a continuación serán los diferentes métodos que nos ofrece la clase Graphics para realizar figuras.

Figura 144

Hasta ahora sólo hemos visto un método que nos permita dibujar algo en la superficie del applet, el método drawString(), pero la clase Graphics ofrece una serie de métodos que nos permiten dibujar diferentes tipos de figuras como pueden ser circunferencias, rectángulos, todo tipo de polígonos, etc.


319

La clase Graphics tiene una serie de métodos del tipo drawXXX() donde XXX será el tipo de figura que se desea dibujar. Algunos de estos métodos del tipo drawXXX() tienen su equivalente método fillXXX(), estos métodos dibujan la misma figura pero la rellenan de color. Por ejemplo el método drawRect(), que dibuja un rectángulo, tiene su equivalente fillRect(), que dibuja un rectángulo de color, según el color que se haya especificado al objeto Graphics.

Todos estos métodos de dibujo reciben una serie de parámetros del tipo entero int que se corresponde con las coordenadas y dimensiones de las figuras. El Código fuente 208 dibujaría un rectángulo de anchura 125 y altura 180 en la posición (35,15) .

public void paint(Graphics g){g.drawRect(35,15,125,180);

}

Código fuente 208

El siguiente applet de ejemplo permite elegir de una lista desplegable la figura que se desea dibujar en la superficie del mismo. Al producirse la selección se dibuja en el applet la figura correspondiente.

El tratamiento de eventos en este applet es muy sencillo simplemente debemos implementar el interfaz ItemListener, ya que es el encargado de atrapar los eventos que provienen de la selección de una lista. En el método itemStateChanged() vamos a recoger el nombre de la figura seleccionada y se lo vamos a asignar a un atributo de nuestra clase llamado seleccion y que va a ser un objeto de la clase String. El atributo seleccion contiene el nombre de la figura que se desea dibujar.

El método itemStatedChanged() también realizará una llamada al método repaint() para que se ejecute el método paint() del applet. En el método paint() dibujaremos la figura correspondiente atendiendo al valor del atributo seleccion.

El código completo de este applet se puede ver en el Código fuente 209.

import java.awt.*;import java.applet.*;import java.awt.event.*;public class Figuras extends Applet implements ItemListener{

private Choice figuras;private String seleccion;

public void init(){setLayout(new BorderLayout());figuras=new Choice();figuras.addItem("línea");figuras.addItem("rectángulo");figuras.addItem("cuadrado");figuras.addItem("rectángulo redondeado");figuras.addItem("rectángulo 3D");figuras.addItem("arco");figuras.addItem("elipse");figuras.addItem("círculo");figuras.addItem("polígono");add("South",figuras);seleccion="";figuras.addItemListener(this);

}public void itemStateChanged(ItemEvent evento){

seleccion=figuras.getSelectedItem();


320

repaint();}public void paint(Graphics g){

if (seleccion.equals("línea"))// coordenadas origen, coordenadas fing.drawLine(35,15,90,200);

else if (seleccion.equals("rectángulo"))//coordenadas,anchura,alturag.drawRect(35,15,125,180);

else if (seleccion.equals("cuadrado"))g.drawRect(35,15,125,125);

else if (seleccion.equals("rectángulo redondeado"))//coordenadas,anchura,altura,arco de la esquinag.drawRoundRect(35,15,125,180,20,20);

else if (seleccion.equals("rectángulo 3D"))//coordenadas,anchura,altura,elevacióng.draw3DRect(35,15,125,185,true);

else if (seleccion.equals("arco"))//coordenadas,anchura,altura,ángulo inicio, gradosg.drawArc(35,15,160,160,90,180);

else if (seleccion.equals("elipse"))//coordenadas,anchura, alturag.drawOval(35,15,160,100);

else if (seleccion.equals("círculo"))g.drawOval(35,15,100,100);

else if (seleccion.equals("polígono")){//coordenadas x, coordenadas y, número de puntosint coordX[]={39,94,97,142,53,58,26};int coordY[]={33,74,36,70,108,80,106};int puntos=coordX.length;g.drawPolygon(coordX,coordY,puntos);

}}}

Código fuente 209

En este enlace se puede obtener el código del ejemplo.

En este ejemplo se han utilizado los diferentes métodos drawXXX() de la clase Graphics, cada uno de ellos se acompaña de un comentario en el que se indica el significado de los parámetros. Un ejemplo de la ejecución del applet anterior se puede observar en la Figura 145.

Figura 145


321

Es posible copiar un área rectangular de un objeto Graphics a una posición diferente, para ello se utiliza el método copyArea() de la clase Graphics. Este método recibe los siguientes parámetros: coordenadas de origen, anchura y altura del área a copiar, coordenadas de destino. Así por ejemplo, si deseamos copiar un área cuadrada de 100 pixeles a 100 pixeles a su derecha escribiremos lo que muestra el Código fuente 210.

g.copyArea(0,0,100,100,100,0);

Código fuente 210

Para borrar un área rectangular de un objeto Graphics se utiliza el método clearRect() de la misma clase. Este método recibe como parámetro las coordenadas y la anchura y altura del área a borrar, es decir, tiene los mismos parámetros que el método drawRect().

Para terminar este apartado comentaremos el método drawImage() de la clase Graphics. Este método permite mostrar en la superficie del applet el contenido de un fichero de imagen. Como parámetros recibe un objeto de la clase Image, las coordenadas en las que va a mostrarse la imagen y una referencia a la clase que va a contener a la imagen y la va a mostrar.

La clase Image se encuentra en el paquete java.awt y representa una imagen. Para crear un objeto Image se utilizará el método getImage() de la clase Applet. Este método devuelve el objeto Image que se corresponde con el nombre del fichero de imagen que se le pasa por parámetro. Para obtener el nombre completo del fichero de imagen se debe utilizar el método ya conocido getCodeBase() de la clase Applet.

El Código fuente 211 se corresponde con un applet que muestra una imagen que se encuentra enmarcada mediante un rectángulo con las esquinas redondeadas.

import java.applet.*;import java.awt.*;import java.net.URL;public class Imagen extends Applet{

Image imagen;public void init(){

URL codeBase=getCodeBase();//creamos el objeto imagenimagen=getImage(codeBase,"arma.gif");


//tamaño de la imagenint anchura=imagen.getWidth(this);int altura=imagen.getHeight(this);//se dibuja el rectángulog.drawRoundRect(52,52,anchura+10,altura+10,30,30);//se dibuja la imageng.drawImage(imagen,57,57,anchura,altura,this);

}}

Código fuente 211


322

Para obtener el tamaño de la imagen utilizamos los método getWidth() y getHeight() de la clase Image. Estos dos métodos tienen un parámetro que será una referencia a la clase que muestra la imagen, en este caso es el mismo applet, por lo que se utiliza this. El aspecto de este applet es el de la Figura 146

Figura 146

Compresión de applets Como ya hemos comentado los applets pueden estar formados por diferentes clases. Cuando cargamos uno de estos applets en una página Web, se establece una conexión para cada una de la clases de los applets con el servidor Web que contiene las mismas.

De esta forma si hay una página Web con muchos applets o con un applet muy complejo que para su ejecución necesita de un gran número de clases, se incrementarán los tiempos de espera en la carga de los mismos, ya que cada vez que se carga un fichero .CLASS es necesaria una nueva conexión a través de la red, esto es, si el applet tiene veinte clases entonces serán necesarias veinte peticiones HTTP (HyperText Transfer Protocol) que el navegador debe realizar.

Esto supone una gran pérdida de tiempo, ya que además de conectarse veinte veces al mismo servidor Web, los ficheros .CLASS no se encuentran comprimidos con utilidades de compresión como PKZIP o similares.

Para reducir los tiempos de descarga de los applets se ha creado un mecanismo para enviar los applets a través de la Web dentro de un sólo fichero que contiene todos los ficheros de las clases necesarias y todos los recursos que utilice el applet como pueden ser imágenes o sonidos.

De esta forma el navegador sólo necesita realizar una sola conexión con el servidor Web, ya que todos los ficheros necesarios se encuentran en un único fichero. Además de introducir en un mismo archivo todos los ficheros necesarios, se comprimen éstos de forma individual, así se reduce de forma considerable el tiempo de carga.

Esta solución la implementan dos mecanismos diferentes, pero que esencialmente hacen lo mismo: ficheros CAB (cabinet files) y ficheros JAR (Java archive). La gran diferencia entre ficheros CAB y ficheros JAR es el formato de los ficheros y los algoritmos de compresión. Los ficheros CAB usan el formato de los ficheros cabinet de Microsoft, que ha sido utilizado por los productos y paquetes de instalación de Microsoft durante bastante tiempo.


323

En este apartado vamos a comentar ambos mecanismos y también vamos a comentar que herramientas tenemos a nuestra disposición para comprimir ficheros de clase.

Para la creación de ficheros cabinet disponemos de la herramienta Microsoft SDK for Java 3.2, esta herramienta la obtenemos del Web de Microsoft, ya que desgraciadamente Visual J++ no nos ofrece ninguna herramienta para empaquetar ficheros de clase.

Los ficheros cabinet se basan en el sistema de compresión Lempei-Ziv, como parte fundamental de este formato está la herramienta de compresión Diamond, que provee una compresión eficiente para los datos de programas de instalación y aplicaciones para Internet. Con la herramienta Diamond se pueden almacenar varios ficheros en un único fichero cabinet, y comprimir cada uno de ellos. Diamond es utilizado por la herramienta llamada CABARC (CABinet ARChiver), y esta será la herramienta que usaremos para la creación del fichero cabinet que, como se ha comentado, contendrá todos los ficheros de las clases utilizadas por los applets.

La herramienta CABARC la encontramos dentro de Microsoft SDK for Java 3.2.

La herramienta CABARC tiene múltiples opciones, pero las más relevantes son: n para la creación de un nuevo fichero cabinet y l para listar los contenidos del fichero cabinet. De esta forma para crear el fichero cabinet llamando clases.cab con todos los ficheros .CLASS del directorio actual se debe escribir lo siguiente en la línea de comandos:

cabarc n clases.cab *.class

Para asegurarnos que los ficheros que han sido añadidos al fichero clases.cab son los correctos, se puede escribir lo que indica el Código fuente 212.

cabarc l clases.cab

Código fuente 212

Para poder utilizar el fichero clases.cab dentro de la página Web, se debe utilizar un parámetro de la etiqueta <APPLET> llamado CABBASE.

<APPLET CODE="AppletInicio.class" WIDTH=0 HEIGHT=0 ><PARAM NAME="cabbase" VALUE="clases.cab"></APPLET>

Código fuente 213

El único navegador que soporta ficheros cabinet es Internet Explorer. El formato genérico que presentan los ficheros .CAB es el que se puede apreciar en la Figura 147.

Otra utilidad adicional que presentan los ficheros .CAB, es la posibilidad de firmarlos digitalmente. De esta forma, cuando un usuario cargue el applet se le preguntará si acepta la firma digital. Si acepta el applet ya no estará sujeto a las restricciones de seguridad, es decir, se podrá conectar a cualquier máquina de Internet, podrá acceder al sistema local de ficheros, podrá instanciar y usar objetos COM, etc. La firma digital asegura la integridad (el código no ha sido alterado ni manipulado después de su publicación) y la autenticidad (indicando el lugar del que proviene el código).


324

Figura 147

Para realizar una firma digital es necesario tener un certificado, para conseguir un certificado válido (SPC, Software Publisher Certificate) es necesario contactar con una autoridad de certificación (CA, Certification Authorities) algunas de ellas son: GTE, VeriSing Inc., etc. La persona que pide el certificado debe identificarse con sus credenciales y garantizar que el código (en nuestro caso los applets) no contiene virus ni elementos maliciosos que puedan dañar el sistema del usuario.

El segundo tipo de empaquetado que podemos realizar es a través del formato JAR, este formato es más estándar que el anterior, ya que lo soportan tanto los navegadores Web Netscape Navigator e Internet Explorer, además es el formato propuesto por Sun.

Los ficheros JAR se comprimen atendiendo al formato ZIP. Los ficheros JAR también permiten la firma de código.

Para crear ficheros JAR Sun nos ofrece la herramienta Java Archive Tool, esta herramienta se ofrece junto el kit de desarrollo JDK (Java Developers Kit) de Sun.

Para crear un fichero JAR con todos los ficheros del directorio actual deberemos escribir lo siguiente en la línea de comandos, dónde fichero.jar contendrá todos los ficheros comprimidos.

jar cf fichero.jar *

Para que un applet contenido en un fichero JAR se pueda incluir en una página Web es necesario escribir el código HTML que se muestra en el Código fuente 214.

<APPLET CODE="ClaseApplet.Class" WIDTH=120 HEIGHT=120ARCHIVE="Fichero.jar"></APPLET>

Código fuente 214

En este caso se utiliza una propiedad de la etiqueta APPLET llamada ARCHIVE. En definitiva debemos utilizar ficheros CAB y/o JAR debido a que:

• Ofrecen una compresión eficiente.

• Supone un beneficio inmediato y significante para los usuarios de nuestra página Web ya que permite una reducción en el tiempo de carga e inicialización de los applets.


325

Componentes Swing y applets En todos los ejemplos utilizados en este capítulo y en el anterior hemos utilizado componentes AWT dentro de objetos de la clase Applet, para construir interfaces de usuario dentro de nuestros applets, también podríamos haber utilizado componentes Swing conjuntamente con la clase javax.swing.JApplet, pero si lo hubiéramos hecho posiblemente al cargar nuestro applet en el navegador no nos habría funcionado.

El problema consiste en que en las MV (maquinas virtuales) que poseen los navegadores Netscape o Explorer no poseen la última versión del lenguaje Java, como ejemplo cabe reseñar que Internet Explorer 5 o Netscape Navigator 4.5 no permiten la ejecución de estos applets, mejor dicho, no ocurre nada cuando se ejecuta una página que invoca a uno de estos applets. La máquina virtuales de estos dos navegadores se corresponden con la versión 1.1 del lenguaje Java, es decir, no soportan Java 2.

Lo mismo ocurrirá con el visor de applets de Visual J++, sin embargo el visor de applets del JBuilder y del JDK (appletviewer) si que implementan la última versión del lenguaje Java, la plataforma Java 2.

La solución para poder utilizar applets Swing (JApplet) en un navegador Web consiste en instalar un software (a modo de parche) que podemos encontrar en el sitio Web de Sun y que se denomina Java Plug-in. Este añadido permite ejecutar applets implementados en Swing, que heredarán de la clase JApplet, esta clase del paquete javax.swing la comentaremos en el siguiente apartado.

El Plug-in lo podemos obtener en la dirección http://java.sun.com/products/plugin/, a la hora de obtener el Plug-in deberemos indicar el tipo de plataforma en el que vamos a utilizarlo. También existen varias versiones del Plug-in en nuestro caso nos interesa la última que se corresponde con el JDK 1.3, por lo tanto seleccionaremos el software Java Plug-in 1.3.

La instalación del Plug-in en un sistema operativo Windows no tiene ningún tipo de complicación, simplemente deberemos ejecutar el fichero que hemos obtenido de Sun y seguir las instrucciones correspondientes incluso el hecho de que se tenga que utilizar diferentes navegadores Internet Explorer o Netscape Navigator no va a resultar ningún problema, ya que se instala en el sistema operativo independientemente del navegador que se utilice.

Solo a la hora de crear la página Web que vaya a hacer la llamada al applet es la que va a ser diferente dependiendo del tipo de navegador. Otra cosa importante es que a diferencia de los applets que no utilizan Swing, con este tipo de applets no vamos a utilizar la etiqueta <APPLET> en el código HTML en ningún caso, puesto que en realidad lo que estamos haciendo es una llamada a un componente ActiveX (proporcionado por el Java Plug-in) que se encarga de su visualización. Debido a esto la etiqueta utilizada es <OBJECT> o <EMBED> dependiendo de si el navegador Web es Internet Explorer o Netscape Navigator respectivamente.

Así por ejemplo si tenemos la clase SwingApplet, que es la clase que representa a un applet, si queremos incluirla en una página HTML, escribiríamos el código HTML que aparece en el Código fuente 215.

<APPLET code="SwingApplet.class" align="baseline" width="200" height="200"></APPLET>

Código fuente 215

Pero si esta clase es un applet de Swing, es decir, hereda de la clase JApplet, deberemos escribir el Código fuente 216, suponiendo que el navegador Web que va a cargar la página, es Internet Explorer.


326

<OBJECT classid="clsid:8AD9C840-044E-11D1-B3E9-00805F499D93"width="200" height="200" align="baseline">

<PARAM NAME="code" VALUE="SwingApplet.class"><PARAM NAME="type" VALUE="application/x-java-applet;version=1.3"><PARAM NAME="scriptable" VALUE="true"></OBJECT>

Código fuente 216

Pero si el navegador Web es Netscape Navigator escribiremos el Código fuente 217.

<EMBED type="application/x-java-applet;version=1.3" width="200"height="200" align="baseline" code="SwingApplet.class"</EMBED>

Código fuente 217

Y lo más recomendable es no presuponer nada sobre el navegador Web que va a ejecutar el applet, y utilizar el código HTML que se muestra en el Código fuente 218, que es una mezcla de los dos anteriores, para que funcione el applet correctamente tanto con el navegador Web Internet Explorer como con el navegador Web Netscape Navigator.

<OBJECT classid="clsid:8AD9C840-044E-11D1-B3E9-00805F499D93"width="200" height="200" align="baseline">

<PARAM NAME="code" VALUE="SwingApplet.class"><PARAM NAME="type" VALUE="application/x-java-applet;version=1.3"><PARAM NAME="scriptable" VALUE="true"><COMMENT><EMBED type="application/x-java-applet;version=1.3" width="200"height="200" align="baseline" code="SwingApplet.class"</EMBED></COMMENT></OBJECT>

Código fuente 218

En la Figura 148 se puede ver un ejemplo de ejecución de este applet de Swing, cuyo código fuente es el Código fuente 219.

import java.awt.*;import javax.swing.*;public class SwingApplet extends JApplet {

JButton boton;public void init() {

getContentPane().setLayout(new FlowLayout());boton = new JButton("Soy un applet de Swing");getContentPane().add(boton);

}}

Código fuente 219


327

Figura 148

Si el lector a probado en su equipo este ejemplo, habrá comprobado lo lento y tedioso que resulta ejecutar los applets que utilizan Swing a través del Plug-in de Java, además esto se debe considerar como un parche a medias, ya que el Plug-in de Java los único que permite es poder utilizar los componentes de Swing, pero no el resto de características de la versión 2 del lenguaje Java.

De momento, hasta que no exista un navegador Web que implemente en su máquina virtual de Java la versión Java 2, es recomendable no abusar del uso de applets de Swing.

La clase JApplet En el uno de los capítulos dedicados a los componentes Swing, más concretamente a los contenedores Swing, ya introdujimos esta clase. Se trata de un contenedor Swing de alto nivel que se muestra dentro de páginas Web a través de navegadores, es por lo tanto la versión Swing de la clase java.applet.Applet, además la clase JApplet es clase hija de la clase java.applet.Applet.

Básicamente un objeto de la clase javax.swing.JApplet va a tener las mismas funciones que un objeto de la clase java.applet.Applet, ya que como ya hemos dicho, se trata de la versión Swing de los applets de Java. A continuación vamos a comentar algunas de las diferencias que existen entre estas dos clases y que novedades aporta la clase JApplet sobre la clase Applet, muchas de estas novedades se desprenden de las características comunes que presentan los componentes Swing.

La clase JApplet pertenece al paquete de los componentes Swing javax.swing, no pertenece a un paquete específico como si lo hace la clase Applet.

Al ser un contenedor Swing de alto nivel, la clase JApplet posee un panel raíz (root pane) al igual que sucedía con la clase JFrame. Como resultados más destacables de esta característica tenemos que es


328

posible añadir una barra de menú a un applet y que para añadir componentes al mismo debemos hacer uso de su panel de contenido (content pane).

De las afirmaciones anteriores se extraen las siguientes apreciaciones a la hora de utilizar objetos de la clase JApplet:

• Los componentes se añaden al panel de contenido del applet, no directamente al applet, es decir, haremos uso del método getContentPane() para obtener el panel de contenido, y sobre este panel de contenido lanzaremos los métodos add() que sean necesarios para añadir los distintos componentes que va a contener nuestro applet.

• El gestor de diseño se aplicará sobre el panel de contenido del applet, no sobre el applet.

• El gestor de diseño por defecto de los applets de Swing (JApplet) es el gestor BorderLayout, a diferencia de la clase Applet que presentaba como gestor de diseño por defecto al gestor FlowLayout.

Además, como todo componente Swing, la clase JApplet soporta la característica Pluggable Look & Feel, es decir, a nuestros applets de Swing podemos darles el aspecto que deseemos entre los diferentes Look & Feel (Mosaic, Java, Mac y Windows).

Como vemos la clase JApplet ofrece a los applets convencionales, la funcionalidad que poseen los contenedores de alto nivel de Swing.

Por lo demás casi todo lo visto para la clase Applet se puede aplicar a la clase JApplet.

De esta forma si tomamos el ejemplo utilizado para mostrar la característica Pluggable Look & Feel, en el tema llamado Interfaces de usuario en Java: Otras características de Swing, podemos modificarlo para que funcione como un objeto de la clase JApplet.

No vamos a mostrar de forma completa el código, sino sólo los fragmentos que cambian. En primer lugar la cabecera de la clase es la que se muestra en el Código fuente 220. Y el constructor se debe eliminar.

public class LF extends JApplet implements ActionListener{

Código fuente 220

El método main() de arranque de la aplicación, se debe sustituir por el método init(), que inicializará el applet y que posee el Código fuente 221.

public void init(){try {

UIManager.setLookAndFeel(UIManager.getCrossPlatformLookAndFeelClassName());} catch (Exception e) { }

getContentPane().setLayout(new BoxLayout(getContentPane(),BoxLayout.Y_AXIS));creaMenu();creaTexto();creaBotones();creaSelector();creaCombo();creaEtiqueta();


329

creaOpciones();}

Código fuente 221

En el método actioPerformed() se debe eliminar la llamada al método pack(). El resto del código es exactamente igual al de la aplicación.

Si ejecutamos este applet con el visor de applets de JDK (herramienta appletviewer), obtenemos el resultado que muestra la Figura 149.

Figura 149

El código completo del ejemplo se puede obtener en este enlace.

Con los applets de Swing damos por finalizada la parte del curso dedicada al segundo tipo de programas que podemos realizar en Java, los applets.

Aspectos avanzados de Java: procesos

Introducción En este capítulo y en el siguiente vamos a tratar algunos aspectos y características avanzadas del lenguaje Java. Como características avanzadas se han seleccionado las siguientes:

• La posibilidad de multiproceso en Java, es decir, la posibilidad de tener distintos hilos de ejecución paralelos. Veremos la clase Thread y el interfaz Runnable.

• Utilización de canales de entrada salida, para leer y escribir información en diversos medios, desde la memoria a ficheros en disco. Ilustraremos los canales con numerosos ejemplos.

• Aplicaciones cliente/servidor en Java a través del mecanismo de los sockets, es decir, a través de conexiones en Internet. Comentaremos las clases Socket y ServerSocket.

Procesos y multiproceso El ser humano y toda criatura viva posee la capacidad del multiproceso. Para regir correctamente sus acciones reflejas, los seres humanos mantienen una serie de procesos simultáneos y que en perfecta armonía hacen posible su desarrollo como ser vivo.

El latido del corazón, la digestión, la respiración, son algunos de los procesos que de forma simultánea, y perfectamente coordinada, tienen lugar diariamente en nuestro cuerpo. Como ya ha ocurrido en multitud de ocasiones el ser humano ha emulado lo que ya estaba presente en la naturaleza (véanse las alas de un avión a imagen de las alas de las aves como muestra de lo dicho), y a igual que


332

procesos humanos los programas de software necesitan de los procesos para acomodarse a los requerimientos actuales de los usuarios.

Hace unos años, un procesador de textos debía paralizar el sistema del usuario mientras preparaba el documento para la impresión y lo imprimía. El programa se apoyaba en el tamaño del buffer de la impresora para retornar el control del ordenador al usuario con mayor o menor celeridad. Los procesadores de textos de la generación anterior a la actual ya salvaban esta incomodidad permitiendo el proceso en segundo plano de la tarea de impresión.

La época en que todo el tiempo de la CPU de un ordenador personal era propiedad de un único proceso, ya pasó. Ahora no solamente múltiples procesos se están ejecutando en un mismo instante de tiempo, sino que también multitud de programas realizan diversos cometidos simultáneamente en el equipo del usuario.

Hola mundo con hilos Vamos a rescribir el applet que realizábamos en un capítulo anterior y que mostraba en pantalla el saludo Hola Mundo, para que utilicemos la técnica de multihilo en Java. El código se muestra en el Código fuente 222.

import java.awt.*;import java.applet.*;public class HolaMundoHilo extends Applet implements Runnable{

Thread oHilo;public void start(){

if( oHilo == null ){oHilo = new Thread(this);oHilo.start();

}}public void run(){

// Lo que tengamos que hacer}public void stop(){

if( oHilo != null ){oHilo.stop();oHilo = null;

}}public void paint( Graphics g ){

g.drawString( "!Hola Mundo¡", 0, 10 );}}

Código fuente 222

Si comparamos éste con el antiguo, vemos unas mínimas diferencias, a saber:

1. Hacemos que la clase principal de nuestra applet incorpore el interfaz Runnable. La interfaz Runnable habilita los mecanismos necesarios para la ejecución de un proceso, en este caso la declaración del método run().

2. Dotamos a la clase de una variable que será la encargada de almacenar el proceso del applet. Indicamos para esta tarea que nuestra variable será de la clase Thread (hilo de proceso,

© Grupo EIDOS 16. Aspectos avanzados de Java: procesos

333

proceso). Thread es una clase definida en el paquete java.lang por lo que no es necesario importarlo ya que este paquete es automáticamente importado para todos los fuentes.

3. Añadimos el método start(), en él crearemos el hilo de proceso para la applet, y enviaremos el mensaje start() sobre él para que se inicie su ejecución. Una vez finalizada la construcción del objeto Thread ligándolo al applet, se deposita en el objeto oHilo para futuras referencias. En la línea siguiente se pone en funcionamiento el proceso por medio del envío del mensaje start() sobre oHilo. Una vez que el proceso es puesto en marcha, éste se encarga de llamar al método run() de la clase (se debe recordar que en el paso uno hicimos las modificaciones oportunas para importar el interfaz Runnable). Dentro del método run() será donde situaremos el código de aquello que deseamos realice nuestro proceso.

Si run() es el punto de entrada del proceso, stop() es el de salida. En el método stop() del applet tras comprobarse que oHilo no está vacío, se envía sobre él el mensaje stop() y se vacía la variable de su contenido, asignándola el valor null. En caso de que se retorne a dicha página el método start() del applet será el encargado de crear nuevamente el proceso, reiniciando todo el ciclo.

Aunque como se puede observar en el código del applet nuestro proceso no hace nada, simplemente se ha añadido para mostrar una pequeña introducción a la programación multiproceso en Java.

Paralelismo Por diferentes motivos, el paralelismo, que habilitan los procesos, es un elemento a tener muy en cuenta a la hora de escribir el código de un proceso. Hemos de adecuar nuestra mente monoproceso a una mente multiproceso en la que diferentes procesos, o incluso múltiples ocurrencias del mismo proceso pueden estar ejecutándose a un tiempo.

Con un problema similar, aunque a menor escala, se encuentra el programador que ha de migrar sus aplicaciones desde un entorno monousuario hacia uno multiusuario. Exponemos el típico problema que se plantea en el que un punto de venta con varios operadores despachando artículos. Dos dependientes, A y B, realizan la venta de una cafetera del mismo modelo. Una de las acciones del programa es descontar de la tabla de existencias el artículo despachado. Podríamos optar por un código similar al Código fuente 223.

oExistencias.nCantidad --;

Código fuente 223

Imaginemos que al comenzar había 20 cafeteras, sí ambas actualizaciones son coincidentes en el tiempo, y el programa no fue concebido para ejecutarse en un entorno multiusuario, pudiera producirse la circunstancia en que los dos puntos de venta tomaran 20 como base de la línea que decrementa, perdiéndose una de las actualizaciones.

En este caso la solución es sencilla, bien por medio de la seguridad que una base de datos aporta a este tipo de transacciones, bien porque nosotros manualmente bloqueemos la fila donde se va a producir la actualización.

Podemos pensar que el problema, después de todo, no es tan grave, pero pensemos en el Código fuente 224, que bien pudiera formar parte del proceso que dispensa dinero en un cajero automático.


334

if( nSaldo > 0 ){// Se realizan diversas operaciones tomando como base nSaldo// ..nSaldo -= nInvertido;

}

Código fuente 224

Si sabemos que el proceso que contiene dicho código puede ejecutarse varías veces, puede darse el caso de que dos o más lleguen a la comparación al mismo tiempo... y ya tenemos problema a la vista puesto que nSaldo - nInvertido será idéntico en ambos procesos, uno de los decrementos se pierde. Imaginemos que el sistema ha autorizado dos trasferencias de 100.000 dólares es una cuenta cuyo nSaldo era de 112.003 dólares.

Podríamos estar pensando que reduciendo más y más el área del ejemplo podríamos llegar a eliminar el problema. Esto no es posible sin operaciones atómicas (este tipo de operaciones parecen suceder todas a un mismo tiempo, es decir, no pudiendo ser interrumpidas por otro proceso durante la ejecución del primero).

Pero éste es un problema soluble. La librería de Java fue concebida desde el principio con los procesos en mente, por lo que no deberemos preocuparnos de la pulcritud de las clases estándar. Además se aportan todos los elementos dentro del lenguaje para que los procesos que nosotros creemos, se comporten correctamente en un ambiente multiproceso. Vamos a aproximarnos al tema que nos ocupará por medio de la prueba y error, que aunque tedioso en algunos casos es uno de los mejores métodos para enfrentarse a un lenguaje de programación.

Observemos el Código fuente 225.

public CuentaProcesos{int nValor;public void agregame(){

nValor ++;}public int cuantos(){

return nValor;}

}

Código fuente 225

Olvidemos por el momento como se crean los procesos, pensemos que en el sistema se han creado una serie de ellos a partir de la clase CuentaProcesos y se están ejecutando. El incremento de nValor no es una operación atómica.

Requiere tres pasos: obtener el valor actual de nValor, agregarle uno y asignarlo a nValor. Al no ser una operación atómica no esta sincronizada y, por tanto, no es segura. Esta falta de seguridad puede provocar fallos a la hora de llevar la cuenta de procesos, cometido de la hilo que hemos codificado. Una palabra clave, synchronized, viene a resolver nuestro problema.

public CuentaProcesos{int nValor;


335

public synchronized void agregame(){nValor ++;

}public int cuantos(){

return nValor;}

}

Código fuente 226

Con synchronized informamos a la máquina virtual de Java que el método sólo podrá ejecutarse por un proceso al mismo tiempo. Los procesos esperarán a que uno termine para que otro empiece, pero esto tiene un serio inconveniente en grandes métodos synchronized. Estos pueden provocar importantes cuellos de botella en el sistema al esperar que les llegue el turno de ejecución. En el caso de las variables, Java las define como sincronizadas por defecto. En el raro caso de que no deseemos sincronización para variables deberemos indicar el modificador volatile para las mismas.

El método cuantos() no ha de ser synchronized ya que tan sólo retorna el valor de una variable del objeto. Veamos ahora el Código fuente 227.

public class Dimension{private int nAlto, nAncho;public int nAlto(){

return nAlto;}public nAncho(){

return nAncho;}// ... métodos para fijar nAlto y nAncho

}public ImprimeDimension{public void print( Dimension d ){

System.out.println( "El ancho es " + d.nAncho() +" y el alto es " + d.nAlto()+" para el objeto dimensión" );

}}

Código fuente 227

Similares en cometido al método cuantos() de la clase CuentaProcesos, son en la clase Dimension los métodos nAlto() y nAncho(). No necesitan ser synchronized ya que tan solo retornan variables del objeto (recuérdese que Java las define como synchronized por defecto). Es cometido y responsabilidad de la parte de código que llama a nAncho() y nAlto() saber si ha de sincronizarse o no. Aunque la operación del método print() es simple, no es atómica. El método print() lee dos valores y los imprime.

Precisamente entre la ejecución de nAlto() y nAncho() podría suceder que otro proceso cambiara los valores, falseándose los resultados mostrados. Cuando se trabaja con procesos es de vital importancia no suponer que nada se ha ejecutado entre dos partes de nuestro programa, incluso entre dos partes de una misma expresión. Debemos tener siempre presenta la pregunta ¿qué sucederá si dos procesos ejecutan esta línea al mismo tiempo?, igualmente veamos si la operación que se está realizando es atómica o no.

Veamos una versión más segura de ImprimeDimension que nos permite ser más precisos a la hora de especificar que parte del método deseamos que esté protegido.


336

public ImprimeDimension2{public void print( Dimension d ){

int nAnchoAux, nAltoAux;// Todo el bloque ocurre de forma atómicasynchronized(this){nAnchoAux = d.nAncho();nAltoAux = d.nAlto();

}System.out.println( "El ancho es " + nAnchoAux +

" y el alto es " + nAltoAux +" para el objeto dimensión" );}}

Código fuente 228

Ahora hemos visto otra de las posibilidades que nos da la sentencia synchronized. A esta sentencia podemos enviarle un parámetro que indique el objeto a bloquear si más de un proceso intenta la ejecución del código encerrado entre llaves. De este modo liberamos al sistema de caer en cuellos de botella de los anteriormente indicados. Ahora los programadores tenemos la potestad de indicar qué partes de un método son seguras y qué parte no necesitan serlo, pudiéndose, por tanto, ejecutarse a un mismo tiempo.

Aunque hemos dado un paso importante nadie impide que otro proceso cambie el valor de Dimension d. Para impedir este comportamiento indeseable remitiremos a synchronized el objeto d, asegurando de este modo que nada ni nadie podrá modificar el valor de Dimension d durante la obtención de los valores nAlto y nAncho.

public ImprimeDimension3{public void print( Dimension d ){

int nAnchoAux, nAltoAux;// Todo el bloque ocurre de forma atómica// y solamente un proceso puede cambiar dsynchronized(d){

nAnchoAux = d.nAncho();nAltoAux = d.nAlto();

}System.out.println( "El ancho es " + nAnchoAux+

" y el alto es " + nAltoAux+" para el objeto dimensión" );}}

Código fuente 229

Con esta leve pero efectiva modificación hemos completado la seguridad que estaba en nuestras manos, siempre y cuando asumamos que la forma de obtener Dimension d es segura. Esta asunción es totalmente fiable siempre que se trate de clases del sistema. Pero fuimos nosotros los que codificamos la clase Dimension y es nuestra responsabilidad codificar un método seguro para cambiar los valores nAlto y nAncho. Podemos asegurar esto codificando un único método que fije ambos valores.

public class Dimension2{private int nAncho, nAlto;// Los métodos para obtener nAlto y nAncho...


337

public synchronized void fijarAltoAncho(nAlto, nAncho){nAlto = nAltoNuevo;nAncho = nAnchoNuevo;

}}

Código fuente 230

Haciendo synchronized el único método con el que se pueden alterar los contenidos de nAncho y nAlto protegemos el código ante cualquier actualización concurrente que pudiera suceder.

Con synchronized garantizamos que sólo un método de este tipo se estará ejecutando a un mismo tiempo. Esta garantía es posible debido a que una de las características de synchronized es precisamente que sólo un método synchronized puede estar ejecutándose para la misma clase en el mismo instante de tiempo.

Utilizando procesos. El interfaz runnable Para realizar un proceso en Java se debe seguir los siguientes pasos:

1. Heredamos de la clase Thread.

public class MiThreadHeredado extend Thread{public void run(){

// Lo que deseemos que ejecute MiThreadHeredado}}

Código fuente 231

2. No tenemos nada más que un descendiente de Thread con las nuevas características que le

hayamos indicado. Pero para que todo se ponga en funcionamiento, debemos crear una ocurrencia real en el ámbito de ejecución de Java para que, sea lo que fuere, lo que programamos en el método run() se active.

oMTH = new MiThreadHeredado();

Código fuente 232

3. Una vez creado el objeto, tan sólo nos queda echarlo a andar. Esto lo conseguimos enviando el

mensaje start() sobre el objeto recién creado. El método start(), codificado dentro de la librería estándar de Java, será el encargado de enviar sobre sí mismo (el objeto que estamos creando, this) el mensaje run() que ejecutará el método homónimo. El método run() ejecutado será él que codificamos con aquello con lo que deseábamos particularizar la nueva clase.

oMTH.start()

Código fuente 233


338

Algunas tareas adicionales que habitualmente desearemos ejecutar sobre un proceso serán pararlo temporal o definitivamente y reanudar su ejecución tras una parada temporal. Para paralizar temporalmente la ejecución de un proceso utilizaremos el mensaje suspend(). Cuando deseemos reanudar la ejecución de un proceso parado con suspend() utilizamos resume().

oMTH.suspend();// lo que necesitemos hacer mientras oMTH no se está ejecutandooMTH.resume();

Código fuente 234

Cuando indicamos que un método es synchronized, Java realiza automáticamente esta desactivación y posteriormente la activación. Todos los objetos que estén haciendo uso del código del método en cuestión recibirán el correspondiente mensaje suspend(), exceptuando el que tenga la atención de la máquina virtual de Java en ese instante. Una vez concluya la ejecución del método que debe ser sincronizado (fue definido como synchronized) todos los procesos que fueron temporalmente paralizados recibirán el mensaje resume().

Esta tarea sería ardua si tuviéramos que realizarla manualmente. Gracias a que Java fue diseñado desde un principio para ser un entorno multiproceso podemos despreocuparnos ahora de estas pequeñeces.

Para una parada definitiva haremos uso del método stop().

¿Qué ocurre si necesitamos que la nueva clase que vamos a definir tome ciertas características de, por ejemplo, la clase Impresora que no hereda de Thread?; ¿podemos en Java heredar de dos clases a la vez?; ¿cómo podemos resolver este pequeño inconveniente con lo que ya sabemos?.

Efectivamente la respuesta negativa a la segunda pregunta nos pone en la pista para dar una respuesta correcta a la tercera pregunta. Y esta respuesta no ha de ser otra que los interfaces, de los que ya se ha hablado en capítulos anteriores a lo largo del presente curso. Contestando de este modo la tercera pregunta, la respuesta a la primera pregunta es clara: deberemos aprender a utilizar la interfaz Runnable.

Sustituyamos el primer paso que comentábamos anteriormente por este otro:

1. Debemos implementar el interfaz Runnable.

public class MiNuevaImpresora extend Impresora implements Runnable{public void run(){

// Lo que deseemos que caracterice a MiNuevaImpresora}}

Código fuente 235

Ahora deberemos crear un proceso. Pero deberemos remitir al constructor de la clase Thread un objeto de la clase MiNuevaImpresora, que va a ser la clase que va a contener el método run() que ejecutará el proceso correspondiente.


339

Thread oHiloParaMNI;MiNuevaImpresora oMNI;oMNI = new MiNuevaImpresora();oHiloParaMNI = new Thread( oMNI );oHiloParaMNI.start()// Ejecutará el método run() de la clase de oMNI

Código fuente 236

Tras declarar un objeto de la clase Thread, otro de la clase MiNuevaImpresora y construir el objeto oMNI a partir de las especificaciones de la clase MiNuevaImpresora procedemos a crear el proceso vinculándolo al objeto oMNI. Este último paso no nos debe dejar indiferentes por dos motivos básicos: primero porque es fundamental para poder implementar clases que se desarrollen dentro de un proceso y que hereden sus características de otra clase diferente a Thread, segundo ya que es de suma importancia para comprender como funciona la característica de las interfaces en Java.

Gracias a que indicamos que la clase MiNuevaImpresora implementaba la interfaz Runnable disponemos del método run() para una clase que no heredó de Thread, o mejor dicho, nos obligamos a codificar un método run() para dicha clase. Cuando se ejecute el método start() parte del proceso consistirá en enviar el mensaje run() sobre el objeto que fue remitido como parámetro (recuérdese que oMNI fue remitido como argumento en el momento de crear el oHiloParaMNI).

Este objeto oMNI será guardado en una variable interna del objeto Thread, llamémosla por ejemplo oOwner, cuando se esté ejecutando el método start(), éste comprobará si oOwner es un objeto, en caso afirmativo se enviará sobre él el mensaje run().

Apoyándonos en los dos siguientes códigos vamos a mostrar un ejemplo algo más completo que el anterior.

El primero de los códigos fuente corresponde al archivo SencilloEjRunnable.java y contiene la definición de la clase SencilloEjRunnable que implementa la interfaz Runnable. En el ejemplo, y en aras de una mejor didáctica, el método run() de esta clase tan sólo muestra un mensaje con el nombre del proceso en la consola (pantalla).

public class SencilloEjRunnable implements Runnable{public void run(){

System.out.println( "En el hilo llamado'" +Thread.currentThread().getName() + "'" );

}}

Código fuente 237

Pero si SencilloEjRunnable no hereda de Thread....¿Cómo se averigua el nombre del Thread sobre el que se ejecuta?. Si SencilloEjRunnable fuera una clase que hubiera heredado de Thread la respuesta sería clara: el objeto Thread sería el mismo, this. Pero al no ser una clase que herede de Thread, sino una que implementa la interfaz Runnable, hemos de poder referirnos de alguna manera al objeto Thread dentro del marco del cual se está ejecutando SencilloEjRunnable.

Por medio del método estático currentThread() lanzado sobre el objeto genérico, identificado por Thread, accedemos al objeto que refleja al proceso en cuestión. Una vez que tenemos dicho objeto


340

enviamos sobre éste el mensaje getName(), existente para la clase Thread, que nos devuelve el nombre del hilo de ejecución.

El Código fuente 238 corresponde al archivo PruebaSER.java y contiene la definición de la clase PruebaSER. Estamos utilizando una aplicación de consola, por lo que definimos un método main(). Como ya sabemos, en este método main() situamos la lógica que deseamos realice nuestra aplicación al ser lanzada. En PruebaSER la tarea a realizar será la creación indefinida de procesos que sigan el modelo definido en la clase SencilloEjRunnable.

public class PruebaSER{public static void main( String argv[] ){

SencilloEjRunnable oSER;

oSER = new SencilloEjRunnable();

while( true ){

Thread oH = new Thread(oSER);

if (oH==null)

System.out.println( "new Thread() falló.");

else

System.out.println( "new Thread() correcto.");

oH.start();

// Espera a que la hilo finalice su método run()

try{

oH.join();

} catch( InterruptedException ex) {}}

}}

Código fuente 238

Tras declarar la clase el método main(), y crear el objeto oSER, que representa una instancia de la clase SencilloEjRunnable nos introducimos en el bucle infinito. Creamos el proceso para el objeto oSER y lo almacenamos en el objeto oH. Posteriormente visualizamos un mensaje en la consola indicando si el proceso de construcción del objeto Thread fue satisfactorio o no.

Acto seguido ponemos a funcionar el proceso e indirectamente también nuestra clase SencilloEjRun-nable, se debe recordar, que el método run() de SencilloEjRunnable será ejecutado por el método start() del hilo recién creado. El objeto oSER fue remitido como parámetro en la construcción del objeto oH, acción por la que fueron vinculados.

Como última acción el bucle se introduce en una espera por medio del envío del mensaje join() sobre el proceso. El método join() espera a que el proceso termine. El programa queda a la espera de que el método run() del proceso finalice. Cuando esto suceda una excepción InterruptedException será enviada.


341

Es importante detenerse a evaluar las implicaciones que puede tener un join() infinito en cada caso. No tenemos ninguna seguridad del tiempo que tomará un método run() en completarse. En el ejemplo es inmediato puesto que lo único que hace es imprimir un literal en pantalla. Si necesitamos hacer un join() temporizado también disponemos de esta posibilidad ya que el mensaje admite como parámetro la temporización en milisegundos y opcionalmente nanosegundos.

En la Figura 150 podemos ver parte de la salida que produce esta aplicación.

Figura 150

Si ejecutamos este código para detenerlo deberemos abortar su ejecución, ya que hemos construido un bucle infinito.

Se propone en este segundo ejemplo una variación sencilla respecto a la clase PruebaSER. Esta variación reside únicamente en que el nombre que tendrá el proceso lo fijamos nosotros en lugar de permitir que sea Java quien lo nombre. Para esta tarea sólo hemos de indicar el nombre que deseamos como parámetro en la línea del fuente donde se construye el proceso.

Thread oH = new Thread( oSER, nCuenta + " hilos lanzados.");

Código fuente 239

La variable nCuenta es un contador que almacena el número de proceso que se llevan lanzados. Dicha variable debe de incrementarse, lógicamente, dentro del bucle. La ventaja de poder nombrar como deseemos es obvia, identificaremos de modo mucho más fácil un proceso al que seamos nosotros quienes demos nombre.

Sabemos como parar un proceso por medio del método stop(). Pero Si necesitamos realizar alguna acción cuando pare un proceso ¿Cómo debemos estar a la escucha de esta eventualidad?. La respuesta se encuentra ligada a la manipulación de excepciones, pues es por medio de ellas como nos enteramos que un proceso a muerto. Cuando se lanza el método stop() sobre un proceso, éste lanza una excepción del tipo ThreadDeath. Nuestro cometido es habilitar la correspondiente construcción try-catch que atienda esta excepción.

public class Prueba{public static void main( String argv[] ){

SencilloEjRunnable oSER;


342

oSER = new SencilloEjRunnable();Thread oH = new Thread(oSER);try{

oH.start();//...// El código que en alguna situación enviará stop()//...

}catch( ThreadDeath oTD ){

// lo que deseamos hacer cuando se detenga el hilo// por medio de stop()throw oTD;

}}}

Código fuente 240

Es importante indicar que esta construcción sólo resuelve la captura del final de un hilo si éste es parado por medio de stop(). Un hilo puede pararse por otros motivos diferentes a la ejecución del método stop(), por ejemplo lanzando alguna excepción. Si necesitamos ejecutar algún código sea cual sea el camino por el que finalice una hilo, lo situaremos en la cláusula finally de la construcción try-catch.

Vamos a ver un ejemplo más de la utilización de hilos de ejecución, en este caso va a ser un ejemplo más vistoso, se trata de crear un applet que realice las funciones de un reloj, es decir, va a mostrar la hora actual del sistema y se va a ir actualizando cada segundo. La clase de este ejemplo se va a denominar RelojApplet, esta clase hereda de la clase Applet e implementa el interfaz Runnable. Su código fuente es el Código fuente 241.

import java.awt.*;import java.util.Calendar;import java.util.Date;import java.text.DateFormat;import java.applet.*;import java.awt.event.*;//implementamos el interfaz Runnable porque tenemos un hilo de ejecuciónpublic class RelojApplet extends Applet implements Runnable {

private Thread relojThread=null;private boolean pulsado;

public void init(){pulsado=true;addMouseListener(new AdaptadorRaton());

}public void start() {

if (relojThread == null) {relojThread = new Thread(this, "reloj");

//se inicia el hilo de ejecución//que ejecutará el método run()relojThread.start();

}}public void run() {

Thread miThread = Thread.currentThread();while (relojThread == miThread) {

repaint();try {

//realizamos una pausa de 1 segundo (1000 milisegundos)relojThread.sleep(1000);


343

//Thread.sleep(1000);}catch (InterruptedException e){ }

}//finaliza el hilo de ejecución

}public void paint(Graphics g) {

//para obtener la hora actualCalendar calendario = Calendar.getInstance();

Date fecha = calendario.getTime();//formato de la horaDateFormat formatoFecha = DateFormat.getTimeInstance();

g.setFont(new Font("Arial",Font.ITALIC+Font.BOLD,14));g.drawString(formatoFecha.format(fecha), 5, 10);

}

public void stop() {//se destruye el hilo de ejecuciónrelojThread = null;

}class AdaptadorRaton extends MouseAdapter{

//al pulsar sobre el applet se parará o reanudará el hilopublic void mousePressed(MouseEvent evento){

AppletContext contexto=getAppletContext();if (pulsado){

relojThread.suspend();contexto.showStatus("Hilo en pausa");

}else{relojThread.resume();contexto.showStatus("Hilo en ejecución");

}pulsado=!pulsado;

}}

}

Código fuente 241

Como se puede apreciar en el método run() se realiza una pausa de un segundo, ya que como es lógico el reloj se actualizará cada segundo, para ello se lanza el método repaint(), que llamará paint(). El método paint() del applet únicamente recupera la hora actual y le aplica el formato deseado, a continuación se dibuja la cadena en la superficie del applet, que va a representa la hora actual.

Al pulsar con el ratón sobre la superficie del applet se parará o se iniciará el hilo de ejecución, atendiendo al valor del atributo de tipo booleano pulsado, que hace las veces de interruptor. En la Figura 151 se puede ver un ejemplo de ejecución de este applet.

Figura 151


344

Coordinando los procesos El planificador de procesos de un sistema operativo que los permita, debe poner orden a la ejecución de los mismos. Igualmente ha de fijar prioridades a la solicitud de los tiempos-máquina solicitados por cada uno de los procesos implicados en la realización de una serie de tareas en un instante determinado.

Para esta tarea se han realizado abordajes diferentes dando lugar a dos tipos fundamentales de coordinación de procesos: Sin derecho preferente y con derecho preferente

Sin derecho preferente En este tipo de planificadores la decisión de ceder el control a otro proceso recae sobre el hilo en ejecución. Por este motivo la cortesía es el factor clave en este tipo de planificadores, para un reparto equitativo del tiempo. Es ideal para aplicaciones críticas o en tiempo real en las que un proceso no puede estar detenido por mucho tiempo porque haya muchos otros ejecutándose al mismo tiempo.

Con derecho preferente En las aplicaciones modernas se ha implantado otro tipo de distribuidor. En estos nuevos planificadores es tarea del mismo decidir que proceso se ejecuta en cada instante. Esta característica facilita enormemente la codificación de programas con procesos. Actualmente también podemos definir una escala de prioridades, para que el planificador ceda más o menos tiempo en función de ésta. El planificador de Java puede ser informado de la prioridad de un hilo por medio del método setPriority() de la clase Thread. Remitiendo al mismo un valor comprendido entre las constantes MIN_PRIORITY (de valor 1) y MAX_PRIORITY (de valor 10).

Aspectos avanzados de Java: canales y Sockets

Introducción a los canales La comunicación de Java con el "exterior" se realiza a través de canales o flujos, que no son más que caminos que usan los programas para comunicarse con otros programas o con cualquier dispositivo de entrada o salida, y por los que se transmite la información.

Gracias a esta manera de enviar información, el origen y el destino de los datos no necesitan conocerse, ni saber qué va a hacer cada uno de ellos con los datos, ni qué tipo de datos se envía, ni por qué medio se está transmitiendo la información. Esto es así debido a que todas las operaciones de lectura y escritura se realizan sobre el canal. Así, leeríamos igual de un canal que viniera de un fichero que de uno que llegara desde Internet. Esta independencia permitiría que si en un programa cambiase la fuente de los datos, sólo habría que especificar el nuevo canal y no haría falta cambiar la forma en que se tratan los datos.

Esta independencia que nos dan los canales tiene sus límites, pues, en algún momento, tendremos que decirle al programa dónde queremos que nos escriba los datos o de dónde los queremos leer. Es más, hay canales para el tipo de datos que enviamos o recibimos, ya sean caracteres unicode o bytes; dentro de esa división hay otra dependiendo del origen o destino de los datos: memoria, fichero, ...; y finalmente hay otra clasificación según el tipo de operación que realizan los canales con los datos: los que realizan alguna operación y los que no hacen nada con los datos.


346

Como vemos, esa supuesta independencia que nos dan los canales es sólo a la hora de tratarlos, ya que cuando tenemos que crearlos la cosa se complica un poco y aquí sí que tenemos que saber por dónde van a ir los datos, qué tipo de datos vamos a tratar y lo que vamos a hacer con ellos.

Al tratar con canales de datos (en inglés streams, que literalmente serían corrientes de datos), debemos tener en cuenta dos cosas:

• Cuando accedemos a un canal se bloquean los demás procesos. Para evitar que el canal bloquee la ejecución, lo normal será colocarlo en un hilo de ejecución separado.

• Si se produce algún error mientras se opera con un canal, se lanzará una excepción del tipo IOException, por lo tanto tenemos que tratar estas posibles excepciones introduciendo la operación con el canal en un bloque try-catch.

Ahora que ya sabemos lo que es un canal de datos, vamos a empezar por los más sencillos que seguro ya hemos usado en distintos ejemplos: los canales estándar. Luego continuaremos con los canales especializados del paquete java.io.

Canales estándar de entrada/salida Los canales estándar vienen definidos en la clase System y ya los hemos usado aunque no supiéramos que se consideraban canales. Los canales estándar nos comunican, por defecto, con la pantalla y el teclado. La salida o entrada de estos canales se puede redirigir, pero en el caso de que queramos hacerlo, será mejor usar uno de los canales especializados que veremos en el paquete java.io .

La clase System implementa tres canales de comunicación:

• Salida estándar (System.out): es la salida por pantalla que ya hemos usado desde nuestras aplicaciones. No la usamos desde los applets ya que en ellos no escribimos directamente en la pantalla (no está permitido). Los métodos más habituales son print() y println().

// Muestra ‘Hola’. Deja el cursor al final del textoSystem.out.print("Hola");// Muestra ‘Adiós’ y salta de líneaSystem.out.println("Adiós");

Código fuente 242

• Errores estándar (System.err): es un canal especial cuya única diferencia con la salida estándar

es que no puede ser redirigido: los datos siempre saldrán por pantalla. Por lo demás es igual que System.out y comparte sus métodos.

System.err.println("¡Esto es un error!");

Código fuente 243

© Grupo EIDOS 17. Aspectos avanzados de Java: canales y Sockets

347

• Entrada estándar (System.in): es la entrada por teclado. El método más usado es read() con el que leeríamos caracteres hasta que le especifiquemos en una condición. El método read() tiene un comportamiento que merece ser explicado.

El método read() devuelve un entero. Para estudiar su funcionamiento, vamos a ver un ejemplo muy simple: un programa que lee del teclado y luego nos muestra por pantalla lo que hemos escrito.

import java.io.*;class LecturaEstandar{public static void main(String args[]) throws IOException{

int caracter;

System.out.println("Escribe lo que quieras.

Para terminar, pulsa ENTER");

System.out.println();

while ( (caracter = System.in.read()) != 13 )

System.out.println(caracter);}}

Código fuente 244

A la vista de la ejecución de este programa nos podemos preguntar dónde guarda los caracteres que vamos introduciendo, ya que no hemos definido ningún array de enteros y sin embargo nos muestra todos los caracteres.

Lo que ocurre cuando llamamos a read() es que se crea un canal de entrada que sólo se lee cuando pulsamos la tecla ENTER (en la entrada por teclado no hay fin de fichero). Una vez que lo hemos pulsado, read() leerá el canal secuencialmente, comprobando la condición para dejar de leer. Mientras lee el canal, va mostrando los caracteres por la pantalla, de uno en uno.

En la Figura 152 se puede ver un ejemplo del resultado.

Figura 152

Si cambiásemos la condición para dejar de leer y le forzáramos a terminar al escribir ‘A’, la condición sería la que se muestra en el Código fuente 245.


348

while ((caracter = System.in.read()) != 65) // Código ASCII de ‘A’

Código fuente 245

Al ejecutarlo ahora veríamos lo que se muestra en la Figura 153

Figura 153

Esta vez nos deja escribir (llenar el canal) hasta que pulsamos ENTER. Una vez pulsado, es cuando se analizan los datos que hay en el canal, y vemos que sólo lee las cuatro ‘a’ ya que al llegar a la ‘A’, se cumple la condición de salida del bucle e ignora el resto de los datos que hay en el canal.

Con estos tres canales podemos realizar operaciones básicas, pero no es suficiente para manejar ficheros, leer de Internet, filtrar datos, etc.... Para estas operaciones más específicas usaremos los canales que nos proporciona el paquete java.io.

Canales de java.io Las clases que ofrece el paquete java.io para manejar los distintos tipos de canales se dividen en el tipo de dato que manejan, ya sean caracteres o bytes. La diferencia entre los dos tipos es que Java usa caracteres Unicode de 16 bits y los bytes tienen 8 bits. Normalmente no hay diferencia al usar uno u otro, ya que si usamos un sistema operativo que use caracteres tradicionales de 8 bits, Java, al leer un carácter, leerá 8 bits y no 16. Esto lo hace casi siempre, pero en algunos casos sí puede guardar un carácter de 16 bits cuando nosotros queremos guardar uno de 8. Por esto, lo más recomendable es trabajar con canales de bytes a no ser que estemos seguros de que queremos usar caracteres Unicode.

Como los canales de byte y de carácter se comportan prácticamente igual, solo que unos tratando bytes y los otros tratando caracteres, sería más lógico clasificar los canales por la forma de tratar los datos. Atendiendo a esto, tenemos otros dos tipos de canales:

• Canales de transmisión (Data Sink Streams): son canales que no realizan ninguna operación con los datos que leen o escriben en el canal. Se limitan a transmitir los datos.

• Canales de proceso (Processing Streams): son canales que sí realizan alguna operación con los datos antes de que los reciba el programa. Estos canales actúan sobre un canal de transmisión, es decir, el canal de transmisión establece el flujo de datos y el canal de proceso trabaja sobre los datos que hay en ese canal. Algunos procesos son: filtrado, concatenación de canales, conversión de datos, recuento de líneas, etc...


349

Todas las clases son subclases (clases hijas) de InputStream y de OutputStream que definen un canal cualquiera de entrada y otro de salida. Gracias a estas superclases, el tratamiento de los canales es prácticamente igual, salvando las peculiaridades de cada uno en particular. Estas clases tienen unos métodos comunes para todos los canales. Los más importantes son read() y write() para leer y escribir, pero implementan otros que no todos los canales pueden usar satisfactoriamente. Este uso de métodos comunes es lo que permite la independencia del canal a la hora del tratamiento: podemos usar read() en todos los canales de entrada y write() en los de salida. Luego quedan las operaciones especiales que tenga cada canal que será por lo que le hemos elegido: no vale cualquier canal para cualquier cosa.

Los métodos read() de InputStream son:

• int read()

• int read(byte cadena[])

• int read(byte cadena[], int comienzo, int longitud)

El primer método lee un byte y nos devuelve su valor en forma de entero. El segundo lee una cadena de bytes hasta que no haya más datos disponibles y la guarda en la variable cadena. Devuelve el número de bytes leídos. El tercero lee una cadena de bytes desde comienzo hasta que lea los bytes especificados en longitud o no tenga más datos para leer, y los guarda en cadena. Devuelve el número de bytes leídos.

Los mismos métodos están disponibles para leer caracteres. Los métodos write() de OutputStream son similares:

• write(int c)

• write(char cadena[])

• write(char cadena[], int comienzo, int longitud)

Estos métodos no creo que necesiten explicación.

La jerarquía de clases la vemos en las siguientes imágenes. Aquí están separadas por tipo de dato que manejan, si leen o escriben y las operaciones que realicen con los datos (canales de transmisión en gris y canales de proceso en el color de fondo).

Canales que manejan caracteres (Figura 154 y Figura 155)

Figura 154


350

Figura 155

Canales que manejan bytes (Figura 156 y Figura 157).

Figura 156

Figura 157

Pasemos, ahora, a explicar los distintos tipos de canales.

Canales de transmisión (Data Sink Streams) Los canales de transmisión se usan para leer o escribir cadenas de caracteres, ficheros o pipes. Los pipes son un tipo de canal especial que veremos luego. En la Tabla 24 se muestran los canales de transmisión.


351

Origen/Destino Canales de Carácter Canales de Byte

Memoria CharArrayReader, CharArrayWriter

ByteArrayInputStream, ByteArrayOutputStream

StringReader, StringWriter

StringBufferInputStream

Pipe PipedReader, PipedWriter

PipedInputStream, PipedOutputStream

Fichero FileReader, FileWriter

FileInputStream, FileOutputStream

Tabla 24

Como podemos ver, por cada canal de carácter hay uno de byte y por cada canal de lectura hay uno de escritura (con excepción de StringBufferInputStream).

Los canales que escriben o leen de la memoria se crean sobre un array o una cadena existente.

Para ver como funcionan los canales que trabajan con ficheros, llamados canales de fichero, veamos el Código fuente 246 que los copia.

import java.io.*;public class CopiaFichero{public static void main(String args[]) throws IOException{

FileReader entrada = new FileReader("entrada.txt");

FileWriter salida = new FileWriter("salida.txt");

int caracter;

while ((caracter=entrada.read()) != -1)

salida.write(caracter);

entrada.close();

salida.close();}}

Código fuente 246

Este programa va a leer el fichero ENTRADA.TXT y lo va a copiar en SALIDA.TXT. ENTRADA.TXT debe existir y puede ser cualquier fichero de texto (un TXT, un BAT, etc...).

La lectura del fichero de entrada finaliza cuando se ha alcanzado el final del fichero, esto se identifica mediante el valor –1.

Aquí vemos que el uso de los métodos read() y write() no depende de que el canal sea de una clase o de otra. Si leyéramos un String de la memoria y lo escribiéramos en el disco, sólo tendríamos que cambiar el canal, no el método de lectura. Cambiando el Código fuente 247.


352

FileReader entrada = new FileReader("entrada.txt");

Código fuente 247

Por el Código fuente 248.

String cadena="Esta cadena es un ejemplo";StringReader entrada = new StringReader(cadena);

Código fuente 248

Tendremos un programa que lee de la memoria y escribe en un fichero. Y sólo hemos cambiado el canal.

Los canales pipe son un tipo especial algo complejo que se usa para pasar información de un hilo de ejecución a otro controlando toda la sincronización automáticamente. Para usar los pipe hay que crear uno de entrada y otro de salida y relacionarlos, como muestra el Código fuente 249

PipedInputStream entrada = new PipedInputStream();PipedOutputStream salida = new PipedOutputStream(entrada);

Código fuente 249

De estos canales no vamos a ver ningún ejemplo porque son bastante complejos y se sale de las expectativas del curso.

Canales de proceso (Processing Streams) Los canales de proceso realizan alguna operación con los datos antes de recuperar o de introducir los datos en el canal. Estos canales actúan sobre un canal de transmisión que les proporciona los datos.

Proceso Canales de Carácter Canales de Byte

Buffering BufferedReader, BufferedWriter

BufferedInputStream, BufferedOutputStream

Filtrado FilterReader, FilterWriter

FilterInputStream, FilterOutputStream

Conversión entre Bytes y Caracteres

InputStreamReader, OutputStreamWriter

Unión de Canales, concatenación

SequenceInputStream


353

Serialización de Objetos

ObjectInputStream, ObjectOutputStream

Conversión de Tipos DataInputStream, DataOutputStream

Contador de Líneas LineNumberReader LineNumberInputStream

Vuelta Atrás PushbackInputStream

Impresión PrintWriter PrintStream

Tabla 25

Estos canales, al crearse a partir de uno de transmisión, se usan sobre todo para optimización de accesos o para añadir funcionalidades extra.

Vamos a comentar estos canales.

Canales de Filtrado Son unas clases abstractas de las que heredan los canales de buffering, conversión de tipos, contador de líneas, vuelta atrás e impresión.

Canales de buffer Son uno de los tipos de canales más importantes, ya que optimizan el acceso a los datos guardándolos en memoria, limitando así los accesos a la fuente de los mismos. Son los únicos canales que utilizan adecuadamente los métodos mark() y reset() de la superclase InputStream, el método mark() marca una posición en el canal y el método reset() vuelve a ella aunque nos hayamos movido.

Vamos a ver un ejemplo que usa un BufferedReader para leer el código HTML de una página Web y un FileWriter para guardarla en disco. Por cierto, esta página se puede abrir en el explorador.

import java.net.*; // En este paquete está la definición de la URLimport java.io.*;public class LeerUrl{public static void main(String args[]) throws Exception{

URL eidos = new URL("http://www.eidos.es/");FileWriter salida = new FileWriter("salida.htm");BufferedReader entrada = new BufferedReader(new InputStreamReader (eidos.openStream()));int caracter;while ((caracter=entrada.read()) != -1)

salida.write(caracter);entrada.close();salida.close();

}}

Código fuente 250


354

La forma de usar los canales de proceso es a partir de un canal de transmisión, pero en este caso estamos usando InputStreamReader, que hemos dicho que es un canal de proceso. Esto es porque InputStreamReader proporciona datos: es un canal como los de transmisión pero que pasa los bytes a caracteres al leerlos y convierte los caracteres en bytes al escribirlos. Es el único canal que se comporta como uno de transmisión.

También se pueden anidar canales. Por ejemplo, definir un canal PrintWriter a partir de entrada, que es un canal BufferedReader creado a partir de un InputStreamReader. Con esto conseguimos la funcionalidad de los tres canales en uno.

Este ejemplo funcionaría igual si no usáramos BufferedReader, pero el acceso al canal es mejor usándolo. Además, los canales de buffer se van a usar mayoritariamente para optimizar las operaciones de lectura y escritura, no porque sean estrictamente necesarios.

También podemos apreciar que la forma de leer es siempre la misma aunque cambiemos de canal. Este programa está hecho con canales de carácter, pero se puede hacer igualmente con canales de byte: BufferdedInputStream y FileOutputStream.

Canal de Concatenación El canal de concatenación une varios canales en uno sólo. Como parámetros acepta dos canales de transmisión del tipo InputStream, o bien una lista de estos del tipo Enumeration, que es un interfaz especial para hacer listas de datos. Vamos a ver un ejemplo, en el Código fuente 251, de concatenación de dos canales.

import java.io.*;public class UnirFicheros{public static void main(String args[]) throws IOException{

FileInputStream entrada1 = new FileInputStream("hola.txt");FileInputStream entrada2 = new FileInputStream("adios.txt");SequenceInputStream ficheros =new SequenceInputStream(entrada1, entrada2);int c;while ((c = ficheros.read()) != -1)

System.out.write(c);ficheros.close();

}}

Código fuente 251

Este programa abre dos canales que leen de los ficheros de texto HOLA.TXT y ADIOS.TXT, y los une en un solo canal SequenceInputStream cuyo contenido se muestra en la pantalla.

Canales de conversión de tipos Hasta ahora hemos leído los datos como carácter o byte. Para leer o escribir datos de otros tipos tenemos los canales DataInputStream y DataOutputStream con los que podemos grabar datos de tipo boolean, short, int, long, float y double, además de char y byte.


355

Para comprobar su funcionamiento, tenemos este ejemplo que graba un fichero con datos de tipo int y String, separados por un tabulador. Luego leemos de ese fichero, sacando la información por pantalla y haciendo un total de uno de sus campos.

import java.io.*;public class PruebaTipos{

public static void main(String[] args) throws IOException{PruebaTipos obj = new PruebaTipos();obj.escribeDatos();obj.leeDatos();

}public void escribeDatos() throws IOException{

DataOutputStream salida = new DataOutputStream(new FileOutputStream("datos.dat"));int[] precios = { 3000, 5000, 7000, 6500, 750 };int[] unidades = { 12, 8, 13, 29, 50 };String[] descripcion = { "Camisetas","Bañadores","Pantalones",

"Zapatillas","Calcetines" };for (int i = 0; i < precios.length; i ++){

salida.writeInt(precios[i]);salida.writeChar('\t');salida.writeInt(unidades[i]);salida.writeChar('\t');salida.writeBytes(descripcion[i]);salida.writeChar('\n');

}salida.close();

}public void leeDatos() throws IOException{

DataInputStream entrada = new DataInputStream(new FileInputStream("datos.dat"));int precio;int unidad;String desc;int total = 0;try{

while (true){precio = entrada.readInt();entrada.readChar(); // Ignoramos el tabuladorunidad = entrada.readInt();entrada.readChar(); // Ignoramos el tabuladordesc = entrada.readLine();System.out.println("Has pedido " +

unidad + " unidades de " +desc + " a " + precio + " pts.");total = total + unidad * precio;

}}catch (EOFException e) {}System.out.println("Por un total de: " + total + " Pts.");entrada.close();

}}

Código fuente 252

Lo primero que hacemos es crearnos un canal de salida capaz de tratar tipos a partir de un canal de fichero. Una vez que definimos los datos, los grabamos en columnas (separando los elementos por tabuladores). Creamos el fichero en disco y lo leemos. Si observamos datos.dat veremos que no distinguimos las cantidades: ya no las guarda como caracteres o bytes reconocibles.


356

El segundo método de la clase, crea un canal de entrada para leer tipos a partir de un fichero. Definimos los campos que contiene el archivo y los leemos ignorando el tabulador que los separa (lo leemos sin hacer nada con él).

En el bucle de lectura encontramos algo nuevo: ya no leemos hasta encontrar el final de los datos, sino que tenemos el código de lectura en un bucle infinito dentro de un bloque try-catch. Esto se hace así porque tenemos que leer varios datos diferentes. En este caso no podríamos repetir el bucle de lectura que hemos estado usando siempre, ya que no podemos asignar el resultado de una lectura a un solo dato. En todos los casos hemos estado usando el Código fuente 253.

while ((c = ficheros.read()) != -1)

Código fuente 253

Con un canal de tipos, no podemos recoger la lectura en una sola variable puesto que tenemos que leer varias (en nuestro caso el precio, la descripción y la cantidad). La manera de poder leerlo todo es poner el proceso de lectura en un bucle infinito dentro de un bloque try-catch, del que sólo se saldrá cuando se alcance el final del fichero y se lance la excepción de fin de fichero que recogemos sin hacer nada.

Si compilamos este ejemplo, el compilador nos dará el siguiente mensaje: String readLine() ha sido desaprobado por el autor de java.io.DataInputStream. Este mensaje indica que no es recomendable utilizar este método ya que se ha quedado obsoleto, nosotros lo hemos utilizado y dejado en nuestro código por simplicidad, ya que sino tendríamos que utilizar un canal más del tipo BufferedReader.

En la Figura 158 se puede observar la ejecución de este ejemplo.

Figura 158

Serialización de Objetos Ya hemos visto cómo escribir o leer tipos de datos en un canal, pero entre esos tipos no están los objetos. La serialización de objetos consiste en poder enviar objetos a un canal y luego reconstruir el objeto y el valor de sus atributos en el otro extremo del canal. Para reconstruir un objeto se tiene que importar el paquete donde está definido en el destino.

Para ver cómo funciona, tenemos el Código fuente 254 que escribe un objeto de tipo Date en un canal y luego lo recupera mostrándonos los valores que tenía cuando se creó.


357

import java.io.*;import java.util.Date;public class Serializacion{public static void main(String args[]) throws Exception{

FileOutputStream fichero = new FileOutputStream("salida.dat");ObjectOutput salida = new ObjectOutputStream(fichero);salida.writeObject("Hoy");salida.writeObject(new Date());salida.flush();salida.close();while (System.in.read() != 13);FileInputStream fichero1 = new FileInputStream("salida.dat");ObjectInputStream entrada = new ObjectInputStream(fichero1);String hoy = (String)entrada.readObject();Date fecha = (Date)entrada.readObject();System.out.println(hoy);System.out.println(fecha);entrada.close();

}}

Código fuente 254

En la primera parte, creamos un canal de serialización a partir de uno de fichero. Podemos definir el tipo del canal como ObjectOutput ya que es una superclase de ObjectOutputStream, aunque también podríamos haber puesto directamente ObjectOutputStream, como haremos con el canal de entrada. Luego escribimos dos objetos: uno de la clase String y otro de la clase Date. Cuando llamamos al constructor de Date sin parámetros, nos crea un objeto con la fecha y la hora actuales. Una vez escritos, lo guardamos en disco y cerramos el canal.

Esperamos a que se pulse la tecla ENTER para apreciar el cambio de hora desde que se creó el objeto Date hasta que mostramos su valor.

La segunda parte es muy parecida a la primera: creamos un canal de lectura a partir de uno de fichero. Para leer los objetos usamos el método readObject() de la clase ObjectInputStream. Tenemos que definir un objeto del tipo que vamos a leer y hacer un casting a ese tipo en el readObject(). Los objetos se leen en el orden en que fueron escritos. Una vez leídos, los mostramos comprobando que la hora que vemos es la de creación.

Nosotros también podemos serializar nuestras propias clases sólo con que estas implementen el interfaz Serializable. Afortunadamente, este interfaz está vacío y sólo actúa a modo de etiqueta.

public class MiClase implements Serializable

Código fuente 255

Solamente con esta línea, todos los objetos de esta clase serán serializables.

Canal Contador de Líneas En Java hay un canal especial que reconoce los números de línea: LineNumberReader. Este canal sólo se debe usar en canales de carácter. Java mantiene LineNumberInputStream por compatibilidad con


358

versiones anteriores. LineNumberInputStream no se debe usar porque un canal de bytes puede tener cualquier tipo de dato y no podemos dar por supuesto que vaya a llevar sólo caracteres. Este canal es muy sencillo de usar, como vamos a ver en el Código fuente 256.

import java.io.*;public class ContarLineas{public static void main(String args[]) throws IOException{

FileReader fichero = new FileReader("entrada.txt");LineNumberReader entrada = new LineNumberReader(fichero);String s;while ((s=entrada.readLine())!=null){

System.out.print("Linea "+(entrada.getLineNumber())+": ");System.out.print(s);System.out.println();

}}}

Código fuente 256

La creación del canal es como la de todos los de proceso. ENTRADA.TXT debe existir y es un fichero de texto. Para leer usamos el método ReadLine() que tienen todos los canales de entrada. El método de LineNumberReader que nos proporciona el número de línea en el que estamos es getLineNumber(). Leemos hasta que la cadena que devuelve readLine() sea nula (aquí no se alcanza el final de fichero).

Un ejemplo de ejecución del Código fuente 256 se puede observar en la Figura 159.

Figura 159

Canales de impresión Estos canales sólo proporcionan métodos de impresión a otros canales. Nos permiten mostrar los datos en una gran cantidad de formatos. Son unos canales muy sencillos de usar, por lo que a menudo se verá un canal de impresión creado a partir de cualquier otro canal para facilitar su uso. Sus métodos principales son print() y println(), que están sobrecargados para soportar cualquier tipo de dato. Estos métodos son los que usan System.out y System.err.


359

Canales de vuelta atrás Este tipo de canal implementa la posibilidad de retroceder en la lectura de un canal. Hasta ahora los canales que hemos visto se tratan con avances secuenciales, exceptuando el uso de los métodos mark() y reset(), que sólo funcionan bien en los canales con buffer. Con PushbackReader y PushbackInputStream podemos retroceder tantos caracteres o bytes como podamos meter en el buffer de PushbackReader y PushbackInputStream. Esto significa que podemos leer datos varias veces, ya que después de retroceder, leeremos otra vez los mismos datos.

Como lenguaje orientado a objetos que es Java, hemos visto cómo separa todos los elementos a la hora de tratar con datos de fuentes externas. Esto le proporciona una potencia considerable a la hora de añadir nuevas funcionalidades o nuevos dispositivos de lectura o escritura: en definitiva, nuevos canales.

El uso de canales está bastante restringido en los applets, ya que desde éstos no podemos acceder a ningún fichero que esté en la máquina del usuario, y no podemos cargar ni ejecutar ningún programa. Por lo tanto, todos estos apartados dedicados a los canales están pensados para aplicaciones, así mismo se refleja en los ejemplos que se adjuntan.

Aplicaciones cliente/servidor en Java Dentro del entorno de las aplicaciones Java vamos a tratar un tema de gran interés: la arquitectura cliente/servidor. Más concretamente se va a comentar dentro de este apartado las herramientas que ofrece Java para poder realizar aplicaciones dentro del entorno de la arquitectura cliente/servidor.

Las comunicaciones en Internet se realizan a través de un protocolo llamado TCP/IP ( Transmission Control Protocol/Internet Protocol). TCP/IP es un conjunto de protocolos de comunicaciones que permite a diferentes máquinas conectadas a Internet comunicarse entre sí. El protocolo TCP/IP ofrece comunicaciones fiables mediante servicios orientados a la conexión (protocolo TCP) y no fiables a través de servicios no orientados a la conexión (protocolo UDP, User Datagram Protocol).

Un servicio orientado a la conexión significa que permite intercambiar un gran volumen de datos de una manera correcta, es decir, se asegura que los datos llegan en el orden en el que se mandaron y no existen duplicados, además tiene mecanismos que le permiten recuperarse ante errores.

Las comunicaciones en Internet utilizando el protocolo TCP/IP se realizan a través de circuitos virtuales de datos llamados sockets. Un socket básicamente es una "tubería" que se crea para comunicar a dos programas. Cada programa posee un extremo de la tubería. La clase Socket del paquete java.net provee una implementación independiente de la plataforma del lado cliente de una conexión entre un programa cliente y un programa servidor a través de un socket. El lado del servidor es implementado por la clase ServerSocket.

Por lo tanto para iniciar la conexión desde el lado del cliente se debe instanciar un objeto de la clase Socket, el constructor utilizado de esta clase tiene como parámetros la dirección IP (Internet Protocol) o el nombre de la máquina a la que se quiere conectar y el número de puerto en el que el servidor está esperando las peticiones de los clientes.

Una dirección IP es un número de 32 bits para identificar de forma única una máquina conectada a Internet. Se divide en grupos de 8 bits y se identifica con su número en notación decimal separado cada uno de ellos por puntos, a este formato se le denomina tétrada punteada. Java permite manejar direcciones IP a través de la clase InetAddress, que se encuentra también en el paquete java.net.


360

Debido a que recordar direcciones IP puede ser difícil y poco manejable se suelen identificar con nombres de máquinas, así la dirección IP 206.26.48.100 se corresponde con el nombre de la máquina java.sun.com que resulta más fácil de recordar y significativo. Un mismo nombre puede tener diferentes direcciones IP, en Internet esta correspondencia entre direcciones IP y nombres la gestionan servidores de nombres que se encargan de traducir los nombres fáciles de recordar a sus direcciones de 32 bits. En un programa Java para obtener el nombre de una dirección IP se utiliza el método getHostName() de la clase InetAddress.

Una vez comentado el concepto de dirección IP vamos a retomar la explicación justo en el punto en el que se había dejado. Después de crear el socket, a continuación se deberán obtener los canales de entrada y de salida del socket. Los canales los acabamos de comentar en apartados anteriores.

Para obtener los canales de entrada y de salida del socket se utilizan los métodos getInputStream() y getOutputStream() de la clase Socket, una vez que se tienen los canales, el de entrada lo podremos tratar, por ejemplo, como un objeto de la clase DataInputStream y el de salida como un objeto de la clase PrintStream.

Cuando ya disponemos de los canales de entrada y salida del socket, ya estamos en disposición de poder comunicarnos con el servidor, es decir, la aplicación Java que posee el servicio que queremos utilizar y que tiene el socket del lado del servidor. De todas formas, el servidor se comentará más adelante dentro de este mismo apartado.

Si lo que queremos es recibir información desde el servidor a través del socket creado, se leerá del flujo de entrada del socket. Para ello se entra en un bucle del tipo mientras cuya condición es "mientras se siga recibiendo información a través del flujo de entrada del socket". El cuerpo del bucle mientras se encargará de tratar esta información de forma adecuada y utilizarla para la tarea que resulte necesaria.

Si deseamos enviar información al servidor lo haremos a través del flujo de salida del socket, escribiendo en él la información deseada.

Todo el proceso de comunicaciones se encuentra encerrado en un bloque try{...}catch(...){...} para atrapar los errores que se produzcan. En este caso se deberán atrapar excepciones de entrada/salida, es decir, IOException.

Una vez que se ha terminado el proceso de comunicación entre la aplicación cliente y el servidor, se procede a cerrar los canales de entrada y salida del socket, y también el propio socket (siempre se debe hacer en este orden).

El siguiente esquema que se muestra es el que suelen presentar los clientes en general:

• Abrir un socket.

• Abrir el canal de entrada y el canal de salida del socket.

• Leer del canal de entrada y escribir en el canal de salida, atendiendo al protocolo del servidor.

• Cerrar los canales.

• Cerrar el socket.

El tercer paso es el que más suele variar de un cliente a otro, dependiendo del servidor, los demás suelen ser iguales.


361

Para construir la segunda aplicación implicada en este proceso de comunicación, es decir, la aplicación que realiza la función de servidor, se deberá instanciar un objeto de la clase ServerSocket. Esta es, como ya se había indicado anteriormente, una clase del paquete java.net que provee una implementación independiente de la plataforma del lado servidor de una conexión cliente/servidor a través de un socket.

El constructor del socket del servidor, ServerSocket(), necesita como parámetro un número de puerto en el que debe ponerse a escuchar las peticiones de los clientes, es decir, mediante este número de puerto se identificará el servicio que se debe prestar. Si el puerto especificado está ya ocupado se lanzará una excepción a la hora de crear el socket de servidor.

Cuando se ha creado el socket de servidor a continuación se lanza sobre este socket el método accept() de la clase ServerSocket.

El método accept() del socket del servidor se bloquea (espera) hasta que un cliente inicia una petición de conexión en el puerto en el que el servidor está escuchando.

Cuando el método accept() establece con éxito una conexión con el cliente devuelve un nuevo objeto de la clase Socket al que se le asigna un nuevo puerto local, dejando libre el puerto en el que el servidor espera las peticiones de los clientes.

Este socket se utiliza como parámetro para el constructor de la clase encargada de tratar al cliente. Esta clase que implementa el interfaz Runnable, posee un objeto representa un hilo de ejecución paralelo que es el verdadero encargado de servir al cliente, es decir, es un objeto de la clase Thread.

Múltiples peticiones de los clientes pueden llegar al mismo puerto. Estas peticiones de conexión se encolan en el puerto, de esta forma el servidor debe aceptar las conexiones secuencialmente. Sin embargo los clientes pueden ser servidos simultáneamente a través del uso de hilos de ejecución. Un hilo para procesar cada una de las conexiones de los clientes.

Para cada uno de los clientes que se conectan al servidor se instancia un objeto que implementa el interfaz Runnable y que inicia un nuevo hilo de ejecución a través de un objeto de la clase Thread. Una vez que el servidor ha instanciado un hilo de ejecución para tratar al cliente que se acaba de conectar, vuelve a escuchar en el mismo puerto en el que estaba anteriormente esperando la llegada de conexiones de otros clientes. De esta forma mientras el objeto de la clase Thread se ocupa de servir a un cliente, el servidor puede a la misma vez seguir esperando conexiones de otros clientes, ya que se trata de hilos de ejecución paralelos. Un esquema general que suelen tener los servidores es el siguiente:

mientras (true) {aceptar una conexión.crear un hilo de ejecución que se encargue de servir al cliente.

}

En el caso de que exista algún error en las aceptaciones de conexión de los clientes se saldrá del bucle mientras y se cerrará el socket del servidor, y se deberá notificar este error.

La clase que se encarga de servir al cliente, como ya se ha mencionado anteriormente, deberá implementar el interfaz Runnable, por lo tanto deberá implementar el método run() de este interfaz. Dentro del método run() se implementa el protocolo de comunicación que existe entre el cliente y el servidor.

Dentro de este método podremos obtener los canales de entrada y de salida del socket en el que está conectado el cliente, para ello utiliza los métodos getInputStream() y getOutputStream() de la clase Socket. En este momento se inicia la comunicación con el cliente, atendiendo al protocolo de


362

comunicaciones determinado se escribirá en el flujo de salida o se leerá del flujo de entrada del socket la información necesaria, ya sean caracteres o bytes. Una vez servido por completo el cliente se cerrarán el socket y se finalizará la ejecución del hilo.

Si se ha produce algún error en el método run() se dará por terminada la comunicación con el cliente, se indicará el error a las aplicaciones cliente y servidor y se dispondrá a cerrar los canales de entrada y de salida y el socket, y finalmente se detendrá la ejecución del hilo.

En este apartado hemos visto de forma general la arquitectura cliente/servidor dentro del lenguaje Java, se han visto unos esquemas genéricos que podrán ser utilizados para cualquier aplicación cliente/servidor. Pero para que no quede todo en mera teoría que suele ser un poco aburrida y fácil de olvidar, en el siguiente apartado vamos a ver un ejemplo sencillo.

Este ejemplo se puede considerar como un pequeño resumen de todo lo visto en estos dos últimos capítulos, ya que vamos a utilizar multihilos, canales de entrada/salida y sockets. Además se utiliza un applet, una aplicación y también existe tratamiento de eventos, por lo tanto podemos ir un poco más allá y considerar que es un ejemplo sencillo que resume de forma escueta todo el presente curso.

Nuestro ejemplo va estar constituido por un cliente y un servidor, el cliente va a ser un applet y el servidor una aplicación. El cliente va a realizar una petición muy sencilla, (que se puede considerar absurda, pero para el ejemplo nos sirve) la hora y fecha del servidor.

El applet va a tener una caja de texto en la que va a mostrar la hora y fecha que le devuelva la aplicación servidor. También ofrece un botón, la pulsación de este botón implica una petición del cliente al servidor.

En al método actionPerformed() se establece la conexión con el servidor y se obtiene el canal de entrada, del que se obtendrá la fecha y hora. El código del applet cliente es como se muestra en el Código fuente 257.

import java.applet.*;import java.awt.*;import java.awt.event.*;import java.io.*;import java.net.*;public class Cliente extends Applet implements ActionListener{private Button boton;private TextField resultado;//canal de entradaprivate BufferedReader entrada;//socket del clienteprivate Socket socket;public void init(){

resultado=new TextField(40);add(resultado);boton=new Button("Obtener Fecha");add(boton);boton.addActionListener(this);


try{//creamos el socket y nos conectamos al servidorsocket=new Socket(InetAddress.getLocalHost(),6789);//obtenemos el canal de entradaentrada=new BufferedReader(new InputStreamReader(socket.getInputStream()));resultado.setText(entrada.readLine());//se cierran los canales y el socket


363

entrada.close();socket.close();

}catch(UnknownHostException ex){resultado.setText("Error al establecer la conexión: "+ex);

}catch(IOException ex){resultado.setText("Error de E/S: "+ex);

}}}

Código fuente 257

El código es bastante sencillo y respeta el esquema que comentamos para los clientes genéricos, pero en este caso no se utiliza ningún canal de salida, ya que no enviamos ningún dato a la aplicación servidor. Para leer del canal de entrada se utiliza el método readLine() de la clase BufferedReader.

La aplicación servidor consta de dos clases en dos ficheros fuente distintos. La primera clase llamada Servidor es el servidor propiamente dicho, y su función es la de crear un objeto ServerSocket en el puerto 6789. A este servidor se conecta el applet anteriormente comentado. El servidor estará a la escucha para saber cuando se ha conectado un cliente, y cuando se conecta se crea una instancia de la segunda clase de esta aplicación.

La clase Servidor hereda de la clase Frame para dar una representación gráfica a nuestra aplicación. Además en la ventana se muestra el número de clientes que se han servidor hasta el momento, cada vez que pulsemos el botón del applet se creará una nueva petición. El código de esta clase se muestra en el Código fuente 258.

import java.awt.*;import java.awt.event.*;import java.io.*;import java.net.*;public class Servidor extends Frame{

private ServerSocket sock;private Label servidos;

public static void main(String args[]){Socket s=null;Servidor serv=new Servidor();//el servidor se pone a escuchar en el socket//que ha creadoboolean escuchando=true;int numCliente=0;while(escuchando){

//espera hasta que un cliente comienza una conexión//en el puerto especificadotry {

s=serv.sock.accept();numCliente++;serv.servidos.setText("Clientes Servidos= "+numCliente);

}catch (IOException e) {System.out.println("Fallo en la aceptación de llamadas: "+

e.getMessage());//fuerza la salida del whilecontinue;

}//se crea un objeto de la clase que va a tratar la clientenew TrataCliente(s,numCliente);

}//se cierra el sockettry{

serv.sock.close();


364

}catch(IOException err){System.out.println("Error al cerrar el socket");System.exit(-1);

}//se cierra la ventana del servidorserv.dispose();System.exit(0);

}//constructorpublic Servidor(){

super(" Ejemplo Servidor");//se crea el socket del servidor en un puerto que no esté ocupadotry{

sock=new ServerSocket(6789);}catch(IOException err){

System.out.println("Error:\n Problemas al crear el socket: "+err);System.exit(-1);

}setSize(200,110);show();addWindowListener(new AdaptadorVentana());servidos=new Label("Clientes Servidos=0");setLayout(new BorderLayout());add("Center",servidos);System.out.println("Iniciado el servidor en el puerto: "

+sock.getLocalPort());}class AdaptadorVentana extends WindowAdapter{public void windowClosing(WindowEvent evento){

try{sock.close();

}catch(IOException ex){System.out.println("Error al cerrar el socket: "+ex);

}dispose();System.out.println("Apagando el servidor...");System.exit(0);

}}}

Código fuente 258

La segunda clase de la aplicación se llama TrataCliente y tiene como función servir al cliente que se ha conectado y realizado la petición, es decir, es la clase que calcula la hora del servidor y se la envía por el canal de salida correspondiente al cliente que se encuentre conectado.

La clase TrataCliente implementa el interfaz Runnable por lo que contiene el método run(), es precisamente en este método el lugar en el que se va a tratar la petición del cliente. Por cada cliente conectado se tendrá un hilo de ejecución distinto, y este se creará a través del atributo hilo, que pertenece a la clase Thread.

En el método run() se crea un canal de salida de la clase PrintWriter, a partir del canal de salida del socket establecido entre el cliente y el servidor, para enviar la fecha y hora al cliente que haya realizado la petición. Su código completo es el que vemos en el Código fuente 259.

import java.io.*;import java.awt.*;import java.net.*;import java.util.*;


365

public class TrataCliente implements Runnable{//socket creado para comunicarse con el clienteprivate Socket sock=null;//Flujo de salida del socket por el que se envía//la fecha y hora actual al clienteprivate PrintWriter salida;//Hilo de ejecuciónprivate Thread hilo=null;//constructor que crea el hilo y lo ejecutapublic TrataCliente(Socket s, int id){

sock=s;hilo=new Thread(this,"Cliente "+id);hilo.start();System.out.println("Iniciado el proceso: "+hilo.getName());

}public void run(){

try{//es el canal de salida del socket// lo que debe leer el clientesalida=new PrintWriter(sock.getOutputStream());salida.println(new Date());

}catch(Exception e){System.out.println("Error en la transmisión del fichero");System.exit(-1);

}finalizar();

}public void finalizar() {

//se cierra el canal de salida y el sockettry{

salida.close();sock.close();

}catch(IOException err){System.out.println("Error al cerrar el socket");

}System.out.println("Finalizado el proceso: "+hilo.getName());System.out.println();//se finaliza y destruye el hilo de ejecuciónhilo.stop();hilo=null;

}}

Código fuente 259

Un ejemplo de una ejecución de este último ejemplo es el que se puede apreciar en la figura 10.

Figura 160


366

Para probar correctamente este ejemplo, la aplicación servidor y el applet cliente se deben encontrar en la misma máquina, es decir, ambos se deben hallar en el mismo servidor Web.

Si quiere ver más textos en este formato, visítenos en: http://www.lalibreriadigital.com. Este libro tiene soporte de formación virtual a través de Internet, con un profesor a su disposición, tutorías, exámenes y un completo plan formativo con otros textos. Si desea inscribirse en alguno de nuestros cursos o más información visite nuestro campus virtual en: http://www.almagesto.com. Si quiere información más precisa de las nuevas técnicas de programación puede suscribirse gratuitamente a nuestra revista Algoritmo en: http://www.algoritmodigital.com. No deje de visitar nuestra reviata Alquimia en http://www.eidos.es/alquimia donde podrá encontrar artículos sobre tecnologías de la sociedad del conocimiento. Si quiere hacer algún comentario, sugerencia, o tiene cualquier tipo de problema, envíelo a la dirección de correo electrónico [email protected]. © Grupo EIDOS http://www.eidos.es

http://www.lalibreriadigital.com/

http://www.almagesto.com/

http://www.algoritmodigital.com/

http://www.eidos.es/alquimia


http://www.eidos.es/

Programacion en Java - Angel Esteban Grupo Eidos

Documents

Transcript of Programacion en Java - Angel Esteban Grupo Eidos