Your SlideShare is downloading. ×
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Manual Java
Upcoming SlideShare
Loading in...5
×

Thanks for flagging this SlideShare!

Oops! An error has occurred.

×
Saving this for later? Get the SlideShare app to save on your phone or tablet. Read anywhere, anytime – even offline.
Text the download link to your phone
Standard text messaging rates apply

Manual Java

7,250

Published on

3 Comments
4 Likes
Statistics
Notes
No Downloads
Views
Total Views
7,250
On Slideshare
0
From Embeds
0
Number of Embeds
1
Actions
Shares
0
Downloads
518
Comments
3
Likes
4
Embeds 0
No embeds

Report content
Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
No notes for slide

Transcript

  • 1. JAVA 1
  • 2. 1................................................................................................................... introduccion 2................................................................................................................... origen de java 3................................................................................................................... caracteristicas de java 11.................................................................................................................hot java 11.................................................................................................................java para aplicaciones corporativas 17.................................................................................................................programacion en java 20.................................................................................................................control de flujo 23.................................................................................................................clases 24.................................................................................................................variables y metodos de instancia 25.................................................................................................................alcance de objetos y reciclado de memoria 26.................................................................................................................herencia 27.................................................................................................................control de acceso 27.................................................................................................................variables y metodos estaticos 28.................................................................................................................this y super 29.................................................................................................................clases abstractas 30.................................................................................................................interfaces 31.................................................................................................................metodos nativos 32.................................................................................................................paquetes 33.................................................................................................................referencias 33.................................................................................................................punteros y referencias c++ 34.................................................................................................................referencias en java 36.................................................................................................................referencias y arrays 37.................................................................................................................referencias y listas 39.................................................................................................................punteros c/c++ y referencias java 40.................................................................................................................una minima aplicacion en java 41.................................................................................................................compilacion y ejecucion de quot;hola mundoquot; 43.................................................................................................................el visor de applets de sun 44.................................................................................................................arquitectura de appletviewer 44.................................................................................................................metodos de appletviewer 47.................................................................................................................funciones de menu de appletviewer 49.................................................................................................................un applet basico en java 51.................................................................................................................compilacion de un applet 51.................................................................................................................la marca applet de html 53.................................................................................................................atributos de applet 54.................................................................................................................paso de parametros a applet 56.................................................................................................................tokens en parametros de llamada 58.................................................................................................................el parametro archive 59.................................................................................................................depuracion general 60.................................................................................................................ciclo de vida de un applet 60.................................................................................................................proteccion de applets 61.................................................................................................................escribir applets en java 64.................................................................................................................la aplicacion fecha 66.................................................................................................................el depurador de java 71.................................................................................................................la clase math 72.................................................................................................................la clase character 72.................................................................................................................la clase float 73.................................................................................................................la clase double 74.................................................................................................................la clase integer 75.................................................................................................................la clase long 75.................................................................................................................la clase boolean 76.................................................................................................................la clase string 78.................................................................................................................la clase stringbuffer 80.................................................................................................................uso de conversiones 81.................................................................................................................introduccion a awt 81.................................................................................................................interface de usuario 82.................................................................................................................estructura del awt 82.................................................................................................................componentes y contenedores 86.................................................................................................................componentes 86.................................................................................................................botones 90.................................................................................................................etiquetas 91.................................................................................................................listas 93.................................................................................................................campos de texto 94.................................................................................................................areas de texto 96.................................................................................................................canvas 97.................................................................................................................barras de desplazamiento 99.................................................................................................................diseño de componentes propios 103...............................................................................................................creación de aplicaciones con awt 2
  • 3. 103...............................................................................................................crear el marco de la aplicación 105...............................................................................................................inicializar fuentes, colores y recursos 107...............................................................................................................crear menus y barras de menus 109...............................................................................................................dialogos y ventanas 111...............................................................................................................paneles 113...............................................................................................................layouts 120...............................................................................................................crear un layout 123...............................................................................................................control de eventos 123...............................................................................................................la clase event 124...............................................................................................................tipos de evento 128...............................................................................................................generación y propagación de eventos 130...............................................................................................................metodos de control de eventos 131...............................................................................................................action_event 132...............................................................................................................mejorar el diseño de interfaces 133...............................................................................................................cambio de fuentes de caracteres 134...............................................................................................................colores de fondo y texto 135...............................................................................................................fijar el tamaño preferido 136...............................................................................................................uso de inserts 137...............................................................................................................habilitar y desabilitar componentes 138...............................................................................................................boton grafico 140...............................................................................................................contenedores 143...............................................................................................................objetos graficos 144...............................................................................................................lineas 145...............................................................................................................rectangulos 148...............................................................................................................circulos, elipses 151...............................................................................................................funciones graficas 153...............................................................................................................fractales 155...............................................................................................................lineas flotantes 157...............................................................................................................poligonos 157...............................................................................................................metodos para imagenes 158...............................................................................................................doble buffering de graficos 161...............................................................................................................nuevas clases para dibujos 162...............................................................................................................la clase mediatraker 165...............................................................................................................sonido en java 167...............................................................................................................entrada por raton 168...............................................................................................................manejo de excepciones 169...............................................................................................................generar excepciones en java 170...............................................................................................................excepciones predefinidas 172...............................................................................................................crear excepciones propias 172...............................................................................................................capturar excepciones 175...............................................................................................................propagacion de excepciones 178...............................................................................................................threads y multithearding 178...............................................................................................................flujo en programas 180...............................................................................................................creacion y control de threads 183...............................................................................................................arrancar y parar threads 184...............................................................................................................suspender y reanudar threads 185...............................................................................................................estados de un thread 188...............................................................................................................scheduling 189...............................................................................................................prioridades, demonios 190...............................................................................................................ejemplo de animacion 192...............................................................................................................comunicacion entre threads 197...............................................................................................................codigo nativo 197...............................................................................................................escribir codigo java 198...............................................................................................................crear el fichero de cabecera 199...............................................................................................................crear el fichero de stubs 200...............................................................................................................escribir la funcion c 201...............................................................................................................crear la libreria dinamica 201...............................................................................................................ejecutar el programa 203...............................................................................................................entrada y salida standard 205...............................................................................................................ficheros en java 207...............................................................................................................streams de entrada 210...............................................................................................................streams de salida 214...............................................................................................................ficheros de acceso aleatorio 216...............................................................................................................comunicaciones en java 216...............................................................................................................comunicaciones en unix 217...............................................................................................................sockets 218...............................................................................................................uso de sockets 3
  • 4. 219...............................................................................................................la clase url 220...............................................................................................................dominios de comunicaciones 222...............................................................................................................modelo de comunicaciones con java 222...............................................................................................................apertura de sockets 223...............................................................................................................creacion de streams 225...............................................................................................................cierre de sockets 225...............................................................................................................minimo cliente smtp 226...............................................................................................................servidor de eco 227...............................................................................................................cliente/servidor tcp/ip 229...............................................................................................................servidor simple de http 233...............................................................................................................ejecutar tcp/ip en windows 95 236...............................................................................................................clases utiles en comunicaciones 240...............................................................................................................arquitectura modelo/vista/controlador 242...............................................................................................................observador y observable 243...............................................................................................................utilizar observador y observable 246...............................................................................................................ejemplo de aplicacion mvc 4
  • 5. El uso principal que se hace de Internet e incluso de las redes internas (corporativas) es correo electrónico (e-mail), aunque actualmente hay un auge sorprendente de la navegación web. Los documentos web pueden contener variedad de texto, gráficos de todas clases y proporcionar enlaces hipertexto hacia cualquier lugar de la red. Los navegadores utilizan documentos escritos en lenguaje HTML. La combinación actual de navegadores HTML/WWW están limitados pues, a texto y gráficos. Si se quiere reproducir un sonido o ejecutar un programa de demostración, primero hemos de bajarnos (download) el fichero en cuestión y luego utilizar un programa en nuestro ordenador capaz de entender el formato de ese fichero, o bien cargar un módulo (plug-in) en nuestro navegador para que pueda interpretar el fichero que hemos bajado. Hasta ahora, la única forma de realizar una página web con contenido interactivo, era mediante la interfaz CGI (Common Gateway Interface), que permite pasar parámetros entre formularios definidos en lenguaje HTML y programas escritos en Perl o en C. Esta interfaz resulta muy incómoda de programar y es pobre en sus posibilidades. El lenguaje Java y los navegadores con soporte Java, proporcionan una forma diferente de hacer que ese navegador sea capaz de ejecutar programas. Con Java se puede reproducir sonido directamente desde el navegador, se pueden visitar home pages con animaciones, se puede enseñar al navegador a manejar nuevos formatos de ficheros, e incluso, cuando se pueda transmitir video por las líneas telefónicas, nuestro navegador estará preparado para mostrar esas imágenes. Utilizando Java, se pueden eliminar los inconvenientes de la interfaz CGI y también se pueden añadir aplicaciones que vayan desde experimentos científicos interactivos de propósito educativo a juegos o aplicaciones especializadas para la televenta. Es posible implementar publicidad interactiva y periódicos personalizados. Por ejemplo, alguien podría escribir un programa Java que implementara una simulación química interactiva (una cadena de adn). Utilizando un navegador con soporte Java, un usuario podría recibir fácilmente esa simulación e interaccionar con ella, en lugar de conseguir simplemente un dibujo estático y algo de texto. Lo recibido cobra vida. Además, con Java podemos estar seguros de que el código que hace funcionar el experimento químico no contiene ningún trozo de código malicioso que dañe al sistema. El código que intente actuar destructivamente o que contenga errores, no podrá traspasar los muros defensivos colocados por las características de seguridad y robustez de Java. Además, Java proporciona una nueva forma de acceder a las aplicaciones. El software viaja transparentemente a través de la red. No hay necesidad de instalar las aplicaciones, ellas mismas vienen cuando se necesitan. Por ejemplo, la mayoría de los navegadores del Web pueden procesar un reducido número de formatos gráficos (típicamente GIF y JPEG). Si se encuentran con otro tipo de formato, el navegador estándar no tiene capacidad para 5
  • 6. procesarlo, tendría que ser actualizado para poder aprovechar las ventajas del nuevo formato. Sin embargo, un navegador con soporte Java puede enlazar con el servidor que contiene el algoritmo que procesa ese nuevo formato y mostrar la imagen. Por lo tanto, si alguien inventa un nuevo algoritmo de compresión para imágenes, el inventor sólo necesita estar seguro de que hay una copia en código Java de ese algoritmo instalada en el servidor que contiene las imágenes que quiere publicar. Es decir, los navegadores con soporte Java se actualizan a sí mismos sobre la marcha, cuando encuentran un nuevo tipo de fichero o algoritmo. ORIGEN DE JAVA Sun Microsystems, líder en servidores para Internet, uno de cuyos lemas desde hace mucho tiempo es quot;the network is the computerquot; (lo que quiere dar a entender que el verdadero ordenador es la red en su conjunto y no cada máquina individual), es quien ha desarrollado el lenguaje Java, en un intento de resolver simultáneamente todos los problemas que se le plantean a los desarrolladores de software por la proliferación de arquitecturas incompatibles, tanto entre las diferentes máquinas como entre los diversos sistemas operativos y sistemas de ventanas que funcionaban sobre una misma máquina, añadiendo la dificultad de crear aplicaciones distribuidas en una red como Internet. He podido leer más de cinco versiones distintas sobre el origen, concepción y desarrollo de Java, desde la que dice que este fue un proyecto que rebotó durante mucho tiempo por distintos departamentos de Sun sin que nadie le prestara ninguna atención, hasta que finalmente encontró su nicho de mercado en la aldea global que es Internet; hasta la más difundida, que justifica a Java como lenguaje de pequeños electrodomésticos. Hace algunos años, Sun Microsystems decidió intentar introducirse en el mercado de la electrónica de consumo y desarrollar programas para pequeños dispositivos electrónicos. Tras unos comienzos dudosos, Sun decidió crear una filial, denominada FirstPerson Inc., para dar margen de maniobra al equipo responsable del proyecto. El mercado inicialmente previsto para los programas de FirstPerson eran los equipos domésticos: microondas, tostadoras y, fundamentalmente, televisión interactiva. Este mercado, dada la falta de pericia de los usuarios para el manejo de estos dispositivos, requería unos interfaces mucho más cómodos e intuitivos que los sistemas de ventanas que proliferaban en el momento. Otros requisitos importantes a tener en cuenta eran la fiabilidad del código y la facilidad de desarrollo. James Gosling, el miembro del equipo con más experiencia en lenguajes de programación, decidió que las ventajas aportadas por la eficiencia de C++ no compensaban el gran coste de pruebas y depuración. Gosling había estado trabajando en su tiempo libre en un lenguaje de programación que él había llamado Oak, el cual, aún partiendo de la sintaxis de C++, intentaba remediar las deficiencias que iba observando. Los lenguajes al uso, como C o C++, deben ser compilados para un chip, y si se cambia el chip, todo el software debe compilarse de nuevo. Esto encarece mucho los desarrollos y el problema es especialmente acusado en el campo de la electrónica de consumo. La aparición de un chip más barato y, generalmente, más eficiente, conduce inmediatamente a los 6
  • 7. fabricantes a incluirlo en las nuevas series de sus cadenas de producción, por pequeña que sea la diferencia en precio ya que, multiplicada por la tirada masiva de los aparatos, supone un ahorro considerable. Por tanto, Gosling decidió mejorar las características de Oak y utilizarlo. El primer proyecto en que se aplicó este lenguaje recibió el nombre de proyecto Green y consistía en un sistema de control completo de los aparatos electrónicos y el entorno de un hogar. Para ello se construyó un ordenador experimental denominado *7 (Star Seven). El sistema presentaba una interfaz basada en la representación de la casa de forma animada y el control se llevaba a cabo mediante una pantalla sensible al tacto. En el sistema aparecía Duke, la actual mascota de Java. Posteriormente se aplicó a otro proyecto denominado VOD (Video On Demand) en el que se empleaba como interfaz para la televisión interactiva. Ninguno de estos proyectos se convirtió nunca en un sistema comercial, pero fueron desarrollados enteramente en un Java primitivo y fueron como su bautismo de fuego. Una vez que en Sun se dieron cuenta de que a corto plazo la televisión interactiva no iba a ser un gran éxito, urgieron a FirstPerson a desarrollar con rapidez nuevas estrategias que produjeran beneficios. No lo consiguieron y FirstPerson cerró en la primavera de 1994. Pese a lo que parecía ya un olvido definitivo, Bill Joy, cofundador de Sun y uno de los desarrolladores principales del Unix de Berkeley, juzgó que Internet podría llegar a ser el campo de juego adecuado para disputar a Microsoft su primacía casi absoluta en el terreno del software, y vio en Oak el instrumento idóneo para llevar a cabo estos planes. Tras un cambio de nombre y modificaciones de diseño, el lenguaje Java fue presentado en sociedad en agosto de 1995. Lo mejor será hacer caso omiso de las historias que pretenden dar carta de naturaleza a la clarividencia industrial de sus protagonistas; porque la cuestión es si independientemente de su origen y entorno comercial, Java ofrece soluciones a nuestras expectativas. Porque tampoco vamos a desechar la penicilina aunque haya sido su origen fruto de la casualidad. CARACTERISTICAS DE JAVA Las características principales que nos ofrece Java respecto a cualquier otro lenguaje de programación, son: Es SIMPLE: Java ofrece toda la funcionalidad de un lenguaje potente, pero sin las características menos usadas y más confusas de éstos. C++ es un lenguaje que adolece de falta de seguridad, pero C y C++ son lenguajes más difundidos, por ello Java se diseñó para ser parecido a C++ y así facilitar un rápido y fácil aprendizaje. Java elimina muchas de las características de otros lenguajes como C++, para mantener reducidas las especificaciones del lenguaje y añadir características muy útiles como el garbage collector (reciclador de memoria dinámica). No es necesario preocuparse de liberar memoria, el reciclador se encarga de ello y como es un thread de baja prioridad, 7
  • 8. cuando entra en acción, permite liberar bloques de memoria muy grandes, lo que reduce la fragmentación de la memoria. Java reduce en un 50% los errores más comunes de programación con lenguajes como C y C++ al eliminar muchas de las características de éstos, entre las que destacan: • aritmética de punteros • no existen referencias • registros (struct) • definición de tipos (typedef) • macros (#define) • necesidad de liberar memoria (free) Aunque, en realidad, lo que hace es eliminar las palabras reservadas (struct, typedef), ya que las clases son algo parecido. Además, el intérprete completo de Java que hay en este momento es muy pequeño, solamente ocupa 215 Kb de RAM. Es ORIENTADO A OBJETOS: Java implementa la tecnología básica de C++ con algunas mejoras y elimina algunas cosas para mantener el objetivo de la simplicidad del lenguaje. Java trabaja con sus datos como objetos y con interfaces a esos objetos. Soporta las tres características propias del paradigma de la orientación a objetos: encapsulación, herencia y polimorfismo. Las plantillas de objetos son llamadas, como en C++, clases y sus copias, instancias. Estas instancias, como en C++, necesitan ser construidas y destruidas en espacios de memoria. Java incorpora funcionalidades inexistentes en C++ como por ejemplo, la resolución dinámica de métodos. Esta característica deriva del lenguaje Objective C, propietario del sistema operativo Next. En C++ se suele trabajar con librerías dinámicas (DLLs) que obligan a recompilar la aplicación cuando se retocan las funciones que se encuentran en su interior. Este inconveniente es resuelto por Java mediante una interfaz específica llamada RTTI (RunTime Type Identification) que define la interacción entre objetos excluyendo variables de instancias o implementación de métodos. Las clases en Java tienen una representación en el runtime que permite a los programadores interrogar por el tipo de clase y enlazar dinámicamente la clase con el resultado de la búsqueda. Es DISTRIBUIDO: Java se ha construido con extensas capacidades de interconexión TCP/IP. Existen librerías de rutinas para acceder e interactuar con protocolos como http y ftp. Esto permite a los programadores acceder a la información a través de la red con tanta facilidad como a los ficheros locales. 8
  • 9. La verdad es que Java en sí no es distribuido, sino que proporciona las librerías y herramientas para que los programas puedan ser distribuidos, es decir, que se corran en varias máquinas, interactuando. Es ROBUSTO: Java realiza verificaciones en busca de problemas tanto en tiempo de compilación como en tiempo de ejecución. La comprobación de tipos en Java ayuda a detectar errores, lo antes posible, en el ciclo de desarrollo. Java obliga a la declaración explícita de métodos, reduciendo así las posibilidades de error. Maneja la memoria para eliminar las preocupaciones por parte del programador de la liberación o corrupción de memoria. También implementa los arrays auténticos, en vez de listas enlazadas de punteros, con comprobación de límites, para evitar la posibilidad de sobreescribir o corromper memoria resultado de punteros que señalan a zonas equivocadas. Estas características reducen drásticamente el tiempo de desarrollo de aplicaciones en Java. Además, para asegurar el funcionamiento de la aplicación, realiza una verificación de los byte-codes, que son el resultado de la compilación de un programa Java. Es un código de máquina virtual que es interpretado por el intérprete Java. No es el código máquina directamente entendible por el hardware, pero ya ha pasado todas las fases del compilador: análisis de instrucciones, orden de operadores, etc., y ya tiene generada la pila de ejecución de órdenes. Java proporciona, pues: • Comprobación de punteros • Comprobación de límites de arrays • Excepciones • Verificación de byte-codes Es de ARQUITECTURA NEUTRAL: Para establecer Java como parte integral de la red, el compilador Java compila su código a un fichero objeto de formato independiente de la arquitectura de la máquina en que se ejecutará. Cualquier máquina que tenga el sistema de ejecución (run-time) puede ejecutar ese código objeto, sin importar en modo alguno la máquina en que ha sido generado. Actualmente existen sistemas run-time para Solaris 2.x, SunOs 4.1.x, Windows 95, Windows NT, Linux, Irix, Aix, Mac, Apple y probablemente haya grupos de desarrollo trabajando en el porting a otras plataformas. 9
  • 10. El código fuente Java se quot;compilaquot; a un código de bytes de alto nivel independiente de la máquina. Este código (byte-codes) está diseñado para ejecutarse en una máquina hipotética que es implementada por un sistema run-time, que sí es dependiente de la máquina. En una representación en que tuviésemos que indicar todos los elementos que forman parte de la arquitectura de Java sobre una plataforma genérica, obtendríamos una figura como la siguiente: En ella podemos ver que lo verdaderamente dependiente del sistema es la Máquina Virtual Java (JVM) y las librerías fundamentales, que también nos permitirían acceder 10
  • 11. directamente al hardware de la máquina. Además, habrá APIs de Java que también entren en contacto directo con el hardware y serán dependientes de la máquina, como ejemplo de este tipo de APIs podemos citar: • Java 2D: gráficos 2D y manipulación de imágenes • Java Media Framework : Elementos críticos en el tiempo: audio, video... • Java Animation: Animación de objetos en 2D • Java Telephony: Integración con telefonía • Java Share: Interacción entre aplicaciones multiusuario • Java 3D: Gráficos 3D y su manipulación Es SEGURO: La seguridad en Java tiene dos facetas. En el lenguaje, características como los punteros o el casting implícito que hacen los compiladores de C y C++ se eliminan para prevenir el acceso ilegal a la memoria. Cuando se usa Java para crear un navegador, se combinan las características del lenguaje con protecciones de sentido común aplicadas al propio navegador. El lenguaje C, por ejemplo, tiene lagunas de seguridad importantes, como son los errores de alineación. Los programadores de C utilizan punteros en conjunción con operaciones aritméticas. Esto le permite al programador que un puntero referencie a un lugar conocido de la memoria y pueda sumar (o restar) algún valor, para referirse a otro lugar de la memoria. Si otros programadores conocen nuestras estructuras de datos pueden extraer información confidencial de nuestro sistema. Con un lenguaje como C, se pueden tomar números enteros aleatorios y convertirlos en punteros para luego acceder a la memoria: printf( quot;Escribe un valor entero: quot; ); scanf( quot;%uquot;,&puntero ); printf( quot;Cadena de memoria: %snquot;,puntero ); Otra laguna de seguridad u otro tipo de ataque, es el Caballo de Troya. Se presenta un programa como una utilidad, resultando tener una funcionalidad destructiva. Por ejemplo, en UNIX se visualiza el contenido de un directorio con el comando ls. Si un programador deja un comando destructivo bajo esta referencia, se puede correr el riesgo de ejecutar código malicioso, aunque el comando siga haciendo la funcionalidad que se le supone, después de lanzar su carga destructiva. Por ejemplo, después de que el caballo de Troya haya enviado por correo el /etc/shadow a su creador, ejecuta la funcionalidad de ls persentando el contenido del directorio. Se notará un retardo, pero nada inusual. El código Java pasa muchos tests antes de ejecutarse en una máquina. El código se pasa a través de un verificador de byte-codes que comprueba el formato de los fragmentos de código y aplica un probador de teoremas para detectar fragmentos de código ilegal -código que falsea punteros, viola derechos de acceso sobre objetos o intenta cambiar el tipo o clase de un objeto-. 11
  • 12. Si los byte-codes pasan la verificación sin generar ningún mensaje de error, entonces sabemos que: • El código no produce desbordamiento de operandos en la pila • El tipo de los parámetros de todos los códigos de operación son conocidos y correctos • No ha ocurrido ninguna conversión ilegal de datos, tal como convertir enteros en punteros • El acceso a los campos de un objeto se sabe que es legal: public, private, protected • No hay ningún intento de violar las reglas de acceso y seguridad establecidas El Cargador de Clases también ayuda a Java a mantener su seguridad, separando el espacio de nombres del sistema de ficheros local, del de los recursos procedentes de la red. Esto limita cualquier aplicación del tipo Caballo de Troya, ya que las clases se buscan primero entre las locales y luego entre las procedentes del exterior. Las clases importadas de la red se almacenan en un espacio de nombres privado, asociado con el origen. Cuando una clase del espacio de nombres privado accede a otra clase, primero se busca en las clases predefinidas (del sistema local) y luego en el espacio de nombres de la clase que hace la referencia. Esto imposibilita que una clase suplante a una predefinida. En resumen, las aplicaciones de Java resultan extremadamente seguras, ya que no acceden a zonas delicadas de memoria o de sistema, con lo cual evitan la interacción de ciertos virus. Java no posee una semántica específica para modificar la pila de programa, la memoria libre o utilizar objetos y métodos de un programa sin los privilegios del kernel del sistema operativo. Además, para evitar modificaciones por parte de los crackers de la red, implementa un método ultraseguro de autentificación por clave pública. El Cargador de Clases puede verificar una firma digital antes de realizar una instancia de un objeto. Por tanto, ningún objeto se crea y almacena en memoria, sin que se validen los privilegios de acceso. Es decir, la seguridad se integra en el momento de compilación, con el nivel de detalle y de privilegio que sea necesario. Dada, pues la concepción del lenguaje y si todos los elementos se mantienen dentro del estándar marcado por Sun, no hay peligro. Java imposibilita, también, abrir ningún fichero de la máquina local (siempre que se realizan operaciones con archivos, éstas trabajan sobre el disco duro de la máquina de donde partió el applet), no permite ejecutar ninguna aplicación nativa de una plataforma e impide que se utilicen otros ordenadores como puente, es decir, nadie puede utilizar nuestra máquina para hacer peticiones o realizar operaciones con otra. Además, los intérpretes que incorporan los navegadores de la Web son aún más restrictivos. Bajo estas condiciones (y dentro de la filosofía de que el único ordenador seguro es el que está apagado, desenchufado, dentro de una cámara acorazada en un bunker y rodeado por mil soldados de los cuerpos especiales del ejército), se puede considerar que Java es un lenguaje seguro y que los applets están libres de virus. 12
  • 13. Respecto a la seguridad del código fuente, no ya del lenguaje, JDK proporciona un desemsamblador de byte-code, que permite que cualquier programa pueda ser convertido a código fuente, lo que para el programador significa una vulnerabilidad total a su código. Utilizando javap no se obtiene el código fuente original, pero sí desmonta el programa mostrando el algoritmo que se utiliza, que es lo realmente interesante. La protección de los programadores ante esto es utilizar llamadas a programas nativos, externos (incluso en C o C++) de forma que no sea descompilable todo el código; aunque así se pierda portabilidad. Esta es otra de las cuestiones que Java tiene pendientes. Es PORTABLE: Más allá de la portabilidad básica por ser de arquitectura independiente, Java implementa otros estándares de portabilidad para facilitar el desarrollo. Los enteros son siempre enteros y además, enteros de 32 bits en complemento a 2. Además, Java construye sus interfaces de usuario a través de un sistema abstracto de ventanas de forma que las ventanas puedan ser implantadas en entornos Unix, Pc o Mac. Es INTERPRETADO: El intérprete Java (sistema run-time) puede ejecutar directamente el código objeto. Enlazar (linkar) un programa, normalmente, consume menos recursos que compilarlo, por lo que los desarrolladores con Java pasarán más tiempo desarrollando y menos esperando por el ordenador. No obstante, el compilador actual del JDK es bastante lento. Por ahora, que todavía no hay compiladores específicos de Java para las diversas plataformas, Java es más lento que otros lenguajes de programación, como C++, ya que debe ser interpretado y no ejecutado como sucede en cualquier programa tradicional. Se dice que Java es de 10 a 30 veces más lento que C, y que tampoco existen en Java proyectos de gran envergadura como en otros lenguajes. La verdad es que ya hay comparaciones ventajosas entre Java y el resto de los lenguajes de programación, y una ingente cantidad de folletos electrónicos que supuran fanatismo en favor y en contra de los distintos lenguajes contendientes con Java. Lo que se suele dejar de lado en todo esto, es que primero habría que decidir hasta que punto Java, un lenguaje en pleno desarrollo y todavía sin definición definitiva, está maduro como lenguaje de programación para ser comparado con otros; como por ejemplo con Smalltalk, que lleva más de 20 años en cancha. La verdad es que Java para conseguir ser un lenguaje independiente del sistema operativo y del procesador que incorpore la máquina utilizada, es tanto interpretado como compilado. Y esto no es ningún contrasentido, me explico, el código fuente escrito con cualquier editor se compila generando el byte-code. Este código intermedio es de muy bajo nivel, pero sin alcanzar las instrucciones máquina propias de cada plataforma y no tiene nada que ver con el p-code de Visual Basic. El byte-code corresponde al 80% de las instrucciones de la aplicación. Ese mismo código es el que se puede ejecutar sobre cualquier plataforma. Para ello hace falta el run-time, que sí es completamente dependiente de la máquina y del sistema operativo, que interpreta dinámicamente el byte-code y añade el 20% de instrucciones que faltaban para su ejecución. Con este sistema es fácil crear aplicaciones 13
  • 14. multiplataforma, pero para ejecutarlas es necesario que exista el run-time correspondiente al sistema operativo utilizado. Es MULTITHREADED: Al ser multithreaded (multihilvanado, en mala traducción), Java permite muchas actividades simultáneas en un programa. Los threads (a veces llamados, procesos ligeros), son básicamente pequeños procesos o piezas independientes de un gran proceso. Al estar los threads contruidos en el lenguaje, son más fáciles de usar y más robustos que sus homólogos en C o C++. El beneficio de ser miltithreaded consiste en un mejor rendimiento interactivo y mejor comportamiento en tiempo real. Aunque el comportamiento en tiempo real está limitado a las capacidades del sistema operativo subyacente (Unix, Windows, etc.), aún supera a los entornos de flujo único de programa (single-threaded) tanto en facilidad de desarrollo como en rendimiento. Cualquiera que haya utilizado la tecnología de navegación concurrente, sabe lo frustrante que puede ser esperar por una gran imagen que se está trayendo. En Java, las imágenes se pueden ir trayendo en un thread independiente, permitiendo que el usuario pueda acceder a la información en la página sin tener que esperar por el navegador. Es DINAMICO: Java se beneficia todo lo posible de la tecnología orientada a objetos. Java no intenta conectar todos los módulos que comprenden una aplicación hasta el tiempo de ejecución. Las librería nuevas o actualizadas no paralizarán las aplicaciones actuales (siempre que mantengan el API anterior). Java también simplifica el uso de protocolos nuevos o actualizados. Si su sistema ejecuta una aplicación Java sobre la red y encuentra una pieza de la aplicación que no sabe manejar, tal como se ha explicado en párrafos anteriores, Java es capaz de traer automáticamente cualquiera de esas piezas que el sistema necesita para funcionar. 14
  • 15. Java, para evitar que los módulos de byte-codes o los objetos o nuevas clases, haya que estar trayéndolos de la red cada vez que se necesiten, implementa las opciones de persistencia, para que no se eliminen cuando de limpie la caché de la máquina. HOTJAVA HotJava, en pocas palabras, es un navegador con soporte Java (Java-enabled), desarrollado en Java. Como cualquier navegador de Web, HotJava puede decodificar HTML estándar y URLs estándares, aunque no soporta completamente el estándar HTML 3.0. La ventaja sobre el resto de navegadores, sin soporte Java, es que puede ejecutar programas Java sobre la red. La diferencia con Netscape, es que tiene implementado completamente los sistemas de seguridad que propone Java, esto significa que puede escribir y leer en el disco local, aunque esto hace disminuir la seguridad, ya que se pueden grabar en nuestro disco programas que contengan código malicioso e introducirnos un virus, por ejemplo. No obstante, el utilizar esta característica de HotJava es decisión del usuario. JAVA PARA APLICACIONES CORPORATIVAS Java actualmente está en boca de todos, Java e Intranet son las palabras de moda. Pero, surge la pregunta de si esta es una buena tecnología para desarrollar aplicaciones corporativas. Y la respuesta es afirmativa y voy a proponer argumentos para esa afirmación. En donde la red sea algo crítico, Java facilita tremendamente la vida de la programación corporativa. Durante años, las grandes empresas se han convencido de que la quot;redquot; corporativa es la arteria por donde fluye la sangre que mantiene vivo su negocio. Desde el gran servidor de sus oficinas centrales, hasta los servidores de las delegaciones, las estaciones de trabajo de los programadores y la marabunta de PCs, la información va fluyendo de unos a otros. Para muchas compañías, la Red es la Empresa. Si esta red no se mantiene sana, los pedidos no llegan, el inventario no se actualiza, el software no se desarrolla adecuadamente, los clientes no están satisfechos y, fundamentalmente, el dinero no entra. La necesidad de diagnosticar y reducir la arterioesclerosis de la red, hace que se estén inyectando continuamente nuevas metodologías que subsanen este grave problema. 15
  • 16. ¿Es Java la medicina? Está claro que cuando vemos un cepillo animado limpiando los dientes, cubos moviéndose en 3-D, o una banda de gatos locos en applets de Java, nos convencemos de que es el lenguaje idóneo para Internet. Pero, qué pasa con las aplicaciones corporativas, ¿sería una buena tecnología allí donde la red es el punto crítico? Vamos a intentar responder comparando las capacidades de Java contra la lista de necesidades de la red corporativa. Desarrollo rápido de aplicaciones Hace años, se decía que los programadores pronto desaparecerían. Los generadores automáticos de programas, eliminarían a los generadores humanos y el mundo sería un lugar mejor para vivir. Desafortunadamente, quienes decían esto no tuvieron en cuenta una acelerada demanda de software de calidad para muy diferentes aplicaciones. Sin embargo, la tecnología de objetos pronto vino a intentar facilitar la tarea, adoptando el modelo de quot;generar parte de un programaquot;, así, generando la parte básica de un programa (los objetos), se podría conectar con otras partes para proporcionar diferentes utilidades al usuario. El lenguaje C++ es una buena herramienta, pero no cumple totalmente la premisa. Visual Basic y NextStep, se acercan cada vez más al poder de los objetos. Java facilita la creación de entornos de desarrollo-aplicaciones de modo similar, pero además es flexible, poderoso y efectivo. Los programadores ahora disponen de herramientas de programación de calidad beta, que apuntan hacia esa meta, como son el Java WorkShop de SunSoft, el entorno Java de Borland, el Café de Symantec, y pronto, herramientas más sofisticadas como Netcode o FutureTense. Esto proporciona una gran progresión a los entornos de desarrollo Java. Aplicaciones efectivas y eficientes Las aplicaciones que se crean en grandes empresas deben ser más efectivas que eficientes; es decir, conseguir que el programa funcione y el trabajo salga adelante es más importante que el que lo haga eficientemente. Esto no es una crítica, es una realidad de la programación corporativa. Al ser un lenguaje más simple que cualquiera de los que ahora están en el cajón de los programadores, Java permite a éstos concentrarse en la mecánica de la aplicación, en vez de pasarse horas y horas incorporando APIs para el control de las ventanas, controlando minuciosamente la memoria, sincronizando los ficheros de cabecera y corrigiendo los agónicos mensajes del linker. Java tiene su propio toolkit para interfaces, maneja por sí mismo la memoria que utilice la aplicación, no permite ficheros de cabecera separados (en aplicaciones puramente Java) y solamente usa enlace dinámico. Muchas de las implementaciones de Java actuales son puros intérpretes. Los byte-codes son interpretados por el sistema run-time de Java, la Máquina Virtual Java (JVM), sobre el ordenador del usuario. Aunque ya hay ciertos proveedores que ofrecen compiladores nativos Just-In-Time (JIT). Si la Máquina Virtual Java dispone de un compilador instalado, las secciones (clases) del byte-code de la aplicación se compilarán hacia la arquitectura nativa del ordenador del usuario. Los programas Java en ese momento rivalizarán con el rendimiento de programas en C++. Los compiladores JIT no se utilizan en la forma tradicional de un compilador; los programadores no compilan y distribuyen binarios Java a 16
  • 17. los usuarios. La compilación JIT tiene lugar a partir del byte-code Java, en el sistema del usuario, como una parte (opcional) del entorno run-time local de Java. Muchas veces, los programadores corporativos, ansiosos por exprimir al máximo la eficiencia de su aplicación, empiezan a hacerlo demasiado pronto en el ciclo de vida de la aplicación. Java permite algunas técnicas innovadoras de optimización. Por ejemplo, Java es inherentemente multithreaded, a la vez que ofrece posibilidades de multithread como la clase Thread y mecanismos muy sencillos de usar de sincronización; Java en sí utiliza threads. Los desarrolladores de compiladores inteligentes pueden utilizar esta característica de Java para lanzar un thread que compruebe la forma en que se está utilizando la aplicación. Más específicamente, este thread podría detectar qué métodos de una clase se están usando con más frecuencia e invocar a sucesivos niveles de optimización en tiempo de ejecución de la aplicación. Cuanto más tiempo esté corriendo la aplicación o el applet, los métodos estarán cada vez más optimizados (Guava de Softway es de este tipo). Si un compilador JIT está embebido en el entorno run-time de Java, el programador no se preocupa de hacer que la aplicación se ejecute óptimamente. Siempre he pensado que en los Sistemas Operativos tendría que aplicarse esta filosofía; un optimizador progresivo es un paso más hacia esta idea. Portabilidad para programador y programa En una empresa de relativo tamaño hay una pléyade diferente de ordenadores. Probablemente nos encontremos con estaciones de trabajo Sun para el desarrollo de software, hordas de PCs para cada empleado, algún Mac en el departamento de documentación, una estación de trabajo HP en administración y una estación SGI en la sala de demos. Desarrollar aplicaciones corporativas para un grupo tan diferente de plataformas en excesivamente complejo y caro. Hasta ahora era complicado convencer a los programadores de cada arquitectura que utilizasen un API común para reducir el coste de las aplicaciones. Con un entorno run-time de Java portado a cada una de las arquitecturas de las plataformas presentes en la empresa y una buena librería de clases (quot;packagesquot; en Java), los programadores pueden entenderse y encontrar muy interesante trabajar con Java. Esta posibilidad hará tender a los programadores hacia Java, justo donde otros intentos anteriores con entornos universales (como Galaxy o XVT) han fracasado. Estos APIs eran simplemente inadecuados, no orientados a redes y, verdaderamente, pesados. Una vez que los programas estén escritos en Java, otro lado interesante del asunto es que los programadores también son portables. El grupo de programadores de la empresa puede ahora enfrentarse a un desarrollo para cualquiera de las plataformas. La parte del cliente y del servidor de una aplicación estarán ahora escritas en el mismo lenguaje. Ya no será necesario tener un grupo que desarrolle en Solaris en del departamento de I+D, programadores trabajando sobre Visual Basic en el departamento de documentación y programadores sobre GNU en proyectos especiales; ahora todos ellos podrán estar juntos y formar el grupo de software de la empresa. 17
  • 18. Costos de desarrollo En contraste con el alto coste de los desarrollos realizados sobre estaciones de trabajo, el coste de creación de una aplicación Java es similar al de desarrollar sobre un PC. Desarrollar utilizando un software caro para una estación de trabajo (ahora barata) es un problema en muchas empresas. La eficiencia del hardware y el poco coste de mantenimiento de una estación de trabajo Sun, por ejemplo, resulta muy atractivo para las empresas; pero el coste adicional del entorno de desarrollo con C++ es prohibitivo para la gran mayoría de ellas. La llegada de Java e Intranet reducen considerablemente estos costes. Las herramientas Java ya no están en el entorno de precios de millones de pesetas, sino a los niveles confortables de precio de las herramientas de PCs. Y con el crecimiento cada día mayor de la comunidad de desarrolladores de software freeware y shareware que incluso proporcionan el código fuente, los programadores corporativos tienen un amplio campo donde moverse y muchas oportunidades de aprender y muchos recursos a su disposición. El éxito que Internet ha proporcionado a los equipos de software corporativos es un regalo. El precio del software es ahora el mismo para un poderoso equipo corriendo Unix que para un PC. Incluso Netscape tiene al mismo precio la versión Unix de su servidor Web SuiteSpot que la versión PC/NT. Esta es la filosofía de precios que parece ser será la que se siga con las herramientas basadas en Java. Mantenimiento y soporte Un problema bien conocido que ocurre con el software corporativo es la demanda de cuidados y realimentación. Java no es, ciertamente, la cura para la enfermedad del mantenimiento, pero tiene varias características que harán la vida del enfermero más fácil. Uno de los componentes del JDK es javadoc. Si se usan ciertas convenciones en el código fuente Java (como comenzar un comentario con /** y terminarlo con */), javadoc se puede fácilmente generar páginas HTML con el contenido de esos comentarios, que pueden visualizarse en cualquier navegador. La documentación del API de Java ha sido creada de este modo. Esto hace que el trabajo de documentar el código de nuevas clases Java sea trivial. Otro gran problema del desarrollador corporativo es la creación y control de makefiles. Leerse un makefile es como estar leyendo la historia de empresa. Normalmente se pasan de programador a programador, quitando la información que no es esencial, siempre que se puede. Esto hace que muchos de los makefiles de las aplicaciones contengan docenas de librerías, una miríada de ficheros de cabecera y ultra-confusos macros. Es como mirar en el estómago de la ballena de Jonás. Java reduce las dependencia de complejos makefiles drásticamente. Primero, no hay ficheros de cabecera. Java necesita que todo el código fuente de una clase se encuentre en un solo fichero. Java tiene la inteligencia de make en el propio lenguaje para simplificar la compilación de byte-codes. Por ejemplo: 18
  • 19. public class pepe { // Fichero: pepe.java Guitarra flamenca ; } public class guitarra { // Fichero: guitarra.java } % javac -verbose pepe.java [parsed pepe.java in 720ms] [loaded C:JAVABIN..classesjavalangObject.class in 220ms] [checking class pepe] [parsed .Guitarra.java in 50ms] [wrote pepe.class] [checking class Guitarra] [wrote .Guitarra.class] [done in 2300ms] El compilador Java se da cuenta de que necesita compilar el fichero guitarra.java. Ahora vamos a forzarlo a que recompile pepe.java sin cambiar guitarra.java, podremos comprobar que el compilador de byte-code Java no recompila innecesariamente el fichero guitarra.java. % javac -verbose pepe.java [parsed pepe.java in 440ms] [loaded C:JAVABIN..classesjavalangObject.class in 160ms] [checking class pepe] [loaded .Guitarra.java in 0ms] [wrote pepe.class] [done in 1860ms] Ahora, si modificamos guitarra.java (añadiendo, por ejemplo, otro miembro a la clase) y compilamos pepe.java, el compilador Java se dará cuenta de que debe recompilar tanto pepe.java como guitarra.java % javac -verbose pepe.java [parsed pepe.java in 710ms] [loaded C:JAVABIN..classesjavalangObject.class in 220ms] [checking class pepe] [parsed .Guitarra.java in 0ms] [wrote pepe.class] [checking class Guitarra] [wrote .Guitarra.class] [done in 2640ms] En el libro Just Java de Peter van der Linden hay un capítulo excelente acerca del compilador de Java, si tienes oportunidad, no dejes de leerlo. Aprendizaje Si la empresa está llena de programadores de C++ con alguna experiencia en el manejo de librería gráficas, aprenderán rápidamente lo esencial de Java. Si el equipo de ingenieros no conoce C++, pero maneja cualquier otro lenguaje de programación orientada a objetos, les llevará pocas semanas dominar la base de Java. Lo que sí que no es cierto es que haya que aprender C++ antes de aprender Java. Si los ingenieros de la empresa no conocen ningún lenguaje orientado a objetos, sí que tienen que aprender los fundamentos de esta tecnología antes de nada, y luego aplicarlos a 19
  • 20. la programación con Java. El análisis y diseño orientado a objetos debe ser comprendido antes de intentar nada con Java. Los programadores de Java sin un fondo de conocimientos de OOA/D producirán código pobre. Además, los libros sobre Java crecen como la espuma, ya hay más de 25 publicados, y si buscas quot;Progamming in Javaquot; en la Red, encontrarás 312 Web sites, y 30 más dedicados a quot;Learning Javaquot;. Y si esto, evidentemente, no es el sustituto de un instructor humano, hay ya varias empresas que ofrecen enseñanza de Java, entre ellas, Sun. Resumen En base a los argumentos que acabamos de exponer, ¿podría una empresa utilizar Java para sus aplicaciones críticas? En este instante, sería suficiente un acercamiento a Java. Porque más importante que la elección de Java o cualquier otro lenguaje de programación es un buen diseño de la arquitectura de la aplicación. Diseñar la aplicación para que esté distribuida entre servidores y clientes, y la línea de partida debe ser el diseño modular. Algunas sugerencias para adoptar Java como tecnología corporativa, serían: 1. Usar Java en el desarrollo de la interface del cliente; Java es suficientemente estable para desarrollar una interface portable. Utilizar herramientas de programación más estables en los servidores, porque son la parte crítica. 2. Portar o crear un servidor no-crítico en Java, de forma que tanto cliente como servidor estén escritos en Java. 3. Utilizar Java en proyectos de envergadura tanto en el cliente como en el servidor, para valorar la efectividad de Java. Intranet está creciendo actualmente más rápido que Internet. Las organizaciones corporativas están adoptando la metodología Internet para proporcionar soluciones a sus usuarios y clientes. Java tiene todas las cartas para ser una herramienta de inestimable valor en el desarrollo de aplicaciones corporativas. 20
  • 21. Ahora que ya hemos visto a grandes rasgos lo que Java puede ofrecernos, y antes de entrar a saco en la generación de nuestro primer código Java, vamos a echar un vistazo al lenguaje Java en sí. Lo básico resultará muy familiar a los que tengan conocimientos de C/C++. Los programadores con experiencia en otros lenguajes procedurales reconocerán la mayor parte de las construcciones. Esperemos que este capítulo no resulte demasiado intenso, no obstante, sí debe estar presente, porque más de una vez recurriremos a él como referencia. En posteriores capítulos profundizaremos sobre aspectos de la programación en Java por los que aquí pasaremos de puntillas e iremos presentando ejemplos de código de cada uno de esos aspectos de la programación en Java. PROGRAMACION EN JAVA Cuando se programa en Java, se coloca todo el código en métodos, de la misma forma que se escriben funciones en lenguajes como C. Comentarios En Java hay tres tipos de comentarios: // comentarios para una sola línea /* comentarios de una o más líneas */ /** comentario de documentación, de una o más líneas */ Los dos primeros tipos de comentarios son los que todo programador conoce y se utilizan del mismo modo. Los comentarios de documentación, colocados inmediatamente antes de una declaración (de variable o función), indican que ese comentario ha de ser colocado en la documentación que se genera automáticamente cuando se utiliza la herramienta de Java, javadoc. Dichos comentarios sirven como descripción del elemento declarado permitiendo generar una documentación de nuestras clases escrita al mismo tiempo que se genera el código. En este tipo de comentario para documentación, se permite la introducción de algunos tokens o palabras clave, que harán que la información que les sigue aparezca de forma diferente al resto en la documentación. Identificadores Los identificadores nombran variables, funciones, clases y objetos; cualquier cosa que el programador necesite identificar o usar. En Java, un identificador comienza con una letra, un subrayado (_) o un símbolo de dólar ($). Los siguientes caracteres pueden ser letras o dígitos. Se distinguen las mayúsculas de las minúsculas y no hay longitud máxima. 21
  • 22. Serían identificadores válidos: identificador nombre_usuario Nombre_Usuario _variable_del_sistema $transaccion y su uso sería, por ejemplo: int contador_principal; char _lista_de_ficheros; float $cantidad_en_Ptas; Palabras clave Las siguientes son las palabras clave que están definidas en Java y que no se pueden utilizar como indentificadores: 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 Palabras Reservadas Además, el lenguaje se reserva unas cuantas palabras más, pero que hasta ahora no tienen un cometido específico. Son: cast future generic inner operator outer rest var Literales Un valor constante en Java se crea utilizando una representación literal de él. Java utiliza cinco tipos de elementos: enteros, reales en coma flotante, booleanos, caracteres y cadenas, que se pueden poner en cualquier lugar del código fuente de Java. Cada uno de estos literales tiene un tipo correspondiente asociado con él. Enteros: byte 8 bits complemento a dos short 16 bits complemento a dos int 32 bits complemento a dos long 64 bits complemento a dos Por ejemplo: 21 077 0xDC00 Reales en coma flotante: float 32 bits IEEE 754 double 64 bits IEEE 754 Por ejemplo: 3.14 2e12 3.1E12 22
  • 23. Booleanos: true false Caracteres: Por ejemplo: a t u???? [????] es un número unicode Cadenas: Por ejemplo: quot;Esto es una cadena literalquot; Arrays Se pueden declarar en Java arrays de cualquier tipo: char s[]; int iArray[]; Incluso se pueden construir arrays de arrays: int tabla[][] = new int[4][5]; Los límites de los arrays se comprueban en tiempo de ejecución para evitar desbordamientos y la corrupción de memoria. En Java un array es realmente un objeto, porque tiene redefinido el operador []. Tiene una función miembro: length. Se puede utilizar este método para conocer la longitud de cualquier array. int a[][] = new int[10][3]; a.length; /* 10 */ a[0].length; /* 3 */ Para crear un array en Java hay dos métodos básicos. Crear un array vacío: int lista[] = new int[50]; o se puede crear ya el array con sus valores iniciales: String nombres[] = { quot;Juanquot;,quot;Pepequot;,quot;Pedroquot;,quot;Mariaquot; }; Esto que es equivalente a: String nombres[]; nombres = new String[4]; nombres[0] = new String( quot;Juanquot; ); nombres[1] = new String( quot;Pepequot; ); nombres[2] = new String( quot;Pedroquot; ); nombres[3] = new String( quot;Mariaquot; ); No se pueden crear arrays estáticos en tiempo de compilación: int lista[50]; // generará un error en tiempo de compilación Tampoco se puede rellenar un array sin declarar el tamaño con el operador new: int lista[]; for( int i=0; i < 9; i++ ) lista[i] = i; 23
  • 24. Es decir, todos los arrays en Java son estáticos. Para convertir un array en el equivalente a un array dinámico en C/C++, se usa la clase vector, que permite operaciones de inserción, borrado, etc. en el array. Operadores Los operadores de Java son muy parecidos en estilo y funcionamiento a los de C. En la siguiente tabla aparecen los operadores que se utilizan en Java, por orden de precedencia: . [] () ++ -- ! ~ instanceof * / % + - << >> >>> < > <= >= == != & ^ | && || ? : = op= (*= /= %= += -= etc.) , Los operadores numéricos se comportan como esperamos: int + int = int Los operadores relacionales devuelven un valor booleano. Para las cadenas, se pueden utilizar los operadores relacionales para comparaciones además de + y += para la concatenación: String nombre = quot;nombrequot; + quot;Apellidoquot;; El operador = siempre hace copias de objetos, marcando los antiguos para borrarlos, y ya se encargará el garbage collector de devolver al sistema la memoria ocupada por el objeto eliminado. 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: () - paréntesis. Para contener listas de parámetros en la definición y llamada a métodos. También se utiliza para definir precedencia en expresiones, contener expresiones para control de flujo y rodear 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. También se utiliza cuando se referencian valores de matriz. ; - punto y coma. Separa sentencias. 24
  • 25. , - 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. CONTROL DE FLUJO Muchas de las sentencias de control del flujo del programa se han tomado del C: Sentencias de Salto if/else if( Boolean ) { sentencias; } else { sentencias; } switch switch( expr1 ) { case expr2: sentencias; break; case expr3: sentencias; break; default: sentencias; break; } Sentencias de Bucle Bucles for for( expr1 inicio; expr2 test; expr3 incremento ) { sentencias; } El siguiente trocito de código Java que dibuja varias líneas en pantalla alternando sus colores entre rojo, azul y verde. Este fragmento sería parte de una función Java (método): int contador; for( contador=1; contador <= 12; contador++ ) { switch( contador % 3 ) { case 0: setColor( Color.red ); break; case 1: setColor( Color.blue ); break; 25
  • 26. case 2: setColor( Color.green ); break; } g.drawLine( 10,contador*10,80,contador*10 ); } También se soporta el operador coma (,) en los bucles for for( a=0,b=0; a < 7; a++,b+=2 ) Bucles while while( Boolean ) { sentencias; } Bucles do/while do { sentencias; }while( Boolean ); Excepciones try-catch-throw try { sentencias; } catch( Exception ) { sentencias; } Java implementa excepciones para facilitar la construcción de código robusto. Cuando ocurre un error en un programa, el código que encuentra el error lanza una excepción, que se puede capturar y recuperarse de ella. Java proporciona muchas excepciones predefinidas. Control General del Flujo break [etiqueta] continue [etiqueta] return expr; etiqueta: sentencia; En caso de que nos encontremos con bucles anidados, se permite el uso de etiquetas para poder salirse de ellos, por ejemplo: uno: for( ) { dos: for( ) { continue; // seguiría en el bucle interno continue uno; // seguiría en el bucle principal break uno; // se saldría del bucle principal } } En el código de una función siempre hay que ser consecuentes con la declaración que se haya hecho de ella. Por ejemplo, si se declara una función para que devuelva un entero, es imprescindible que se coloque un return final para salir de esa función, independientemente 26
  • 27. de que haya otros en medio del código que también provoquen la salida de la función. En caso de no hacerlo se generará un Warning, y el código Java no se puede compilar con Warnings. int func() { if( a == 0 ) return 1; return 0; // es imprescindible porque se retorna un entero } CLASES Las clases son lo más simple de Java. Todo en Java forma parte de una clase, es una clase o describe como funciona una clase. El conocimiento de las clases es fundamental para poder entender los programas Java. Todas las acciones de los programas Java se colocan dentro del bloque de una clase o un objeto. Todos los métodos se definen dentro del bloque de la clase, Java no soporta funciones o variables globales. Esto puede despistar a los programadores de C++, que pueden definir métodos fuera del bloque de la clase, pero esta posibilidad es más un intento de no separarse mucho y ser compatible con C, que un buen diseño orientado a objetos. Así pues, el esqueleto de cualquier aplicación Java se basa en la definición de una clase. Todos los datos básicos, como los enteros, se deben declarar en las clases antes de hacer uso de ellos. En C la unidad fundamental son los ficheros con código fuente, en Java son las clases. De hecho son pocas las sentencias que se pueden colocar fuera del bloque de una clase. La palabra clave import (equivalente al #include) puede colocarse al principio de un fichero, fuera del bloque de la clase. Sin embargo, el compilador reemplazará esa sentencia con el contenido del fichero que se indique, que consistirá, como es de suponer, en más clases. Tipos de Clases Hasta ahora sólo se ha utilizado la palabra clave public para calificar el nombre de las clases que hemos visto, pero hay tres modificadores más. Los tipos de clases que podemos definir son: abstract Una clase abstract tiene al menos un método abstracto. Una clase abstracta no se instancia, sino que se utiliza como clase base para la herencia. final Una clase final se declara como la clase que termina una cadena de herencia. No se puede heredar de una clase final. Por ejemplo, la clase Math es una clase final. 27
  • 28. public Las clases public son accesibles desde otras clases, bien sea directamente o por herencia. Son accesibles dentro del mismo paquete en el que se han declarado. Para acceder desde otros paquetes, primero tienen que ser importadas. synchronizable Este modificador especifica que todos los métodos definidos en la clase son sincronizados, es decir, que no se puede acceder al mismo tiempo a ellos desde distintos threads; el sistema se encarga de colocar los flags necesarios para evitarlo. Este mecanismo hace que desde threads diferentes se puedan modificar las mismas variables sin que haya problemas de que se sobreescriban. VARIABLES Y METODOS DE INSTANCIA Una clase en Java puede contener variables y métodos. Las variables pueden ser tipos primitivos como int, char, etc. Los métodos son funciones. Por ejemplo, en el siguiente trozo de código podemos observarlo: public MiClase { int i; public MiClase() { i = 10; } public void Suma_a_i( int j ) { i = i + j; } } La clase MiClase contiene una variable (i) y dos métodos, MiClase que es el constructor de la clase y Suma_a_i( int j ). Ambito de una variable Los bloques de sentencias compuestas en Java se delimitan con dos llaves. Las variables de Java sólo son válidas desde el punto donde están declaradas hasta el final de la sentencia compuesta que la engloba. Se pueden anidar estas sentencias compuestas, y cada una puede contener su propio conjunto de declaraciones de variables locales. Sin embargo, no se puede declarar una variable con el mismo nombre que una de ámbito exterior. El siguiente ejemplo intenta declarar dos variables separadas con el mismo nombre. En C y C++ son distintas, porque están declaradas dentro de ámbitos diferentes. En Java, esto es ilegal. Class Ambito { int i = 1; // ámbito exterior { // crea un nuevo ámbito int i = 2; // error de compilación } } 28
  • 29. Métodos y Constructores Los métodos son funciones que pueden ser llamadas dentro de la clase o por otras clases. El constructor es un tipo específico de método que siempre tiene el mismo nombre que la clase. Cuando se declara una clase en Java, se pueden declarar uno o más constructores opcionales que realizan la inicialización cuando se instancia (se crea una ocurrencia) un objeto de dicha clase. Utilizando el código de ejemplo anterior, cuando se crea una nueva instancia de MiClase, se crean (instancian) todos los métodos y variables, y se llama al constructor de la clase: MiClase mc; mc = new MiClase(); La palabra clave new se usa para crear una instancia de la clase. Antes de ser instanciada con new no consume memoria, simplemente es una declaración de tipo. Después de ser instanciado un nuevo objeto mc, el valor de i en el objeto mc será igual a 10. Se puede referenciar la variable (de instancia) i con el nombre del objeto: mc.i++; // incrementa la instancia de i de mc Al tener mc todas las variables y métodos de MiClase, se puede usar la primera sintaxis para llamar al método Suma_a_i() utilizando el nuevo nombre de clase mc: mc.Suma_a_i( 10 ); y ahora la variable mc.i vale 21. Finalizadores Java no utiliza destructores (al contrario que C++) ya que tiene una forma de recoger automáticamente todos los objetos que se salen del alcance. No obstante proporciona un método que, cuando se especifique en el código de la clase, el reciclador de memoria (garbage collector) llamará: // Cierra el canal cuando este objeto es reciclado protected void finalize() { close(); } ALCANCE DE OBJETOS Y RECICLADO DE MEMORIA Los objetos tienen un tiempo de vida y consumen recursos durante el mismo. Cuando un objeto no se va a utilizar más, debería liberar el espacio que ocupaba en la memoria de forma que las aplicaciones no la agoten (especialmente las grandes). En Java, la recolección y liberación de memoria es responsabilidad de un thread llamado automatic garbage collector (recolector automático de basura). Este thread monitoriza el alcance de los objetos y marca los objetos que se han salido de alcance. Veamos un ejemplo: 29
  • 30. String s; // no se ha asignado todavia s = new String( quot;abcquot; ); // memoria asignada s = quot;defquot;; // se ha asignado nueva memoria // (nuevo objeto) Más adelante veremos en detalle la clase String, pero una breve descripción de lo que hace esto es; crear un objeto String y rellenarlo con los caracteres quot;abcquot; y crear otro (nuevo) String y colocarle los caracteres quot;defquot;. En esencia se crean dos objetos: Objeto String quot;abcquot; Objeto String quot;defquot; Al final de la tercera sentencia, el primer objeto creado de nombre s que contiene quot;abcquot; se ha salido de alcance. No hay forma de acceder a él. Ahora se tiene un nuevo objeto llamado s y contiene quot;defquot;. Es marcado y eliminado en la siguiente iteración del thread reciclador de memoria. HERENCIA La Herencia es el mecanismo por el que se crean nuevos objetos definidos en términos de objetos ya existentes. Por ejemplo, si se tiene la clase Ave, se puede crear la subclase Pato, que es una especialización de Ave. class Pato extends Ave { int numero_de_patas; } La palabra clave extends se usa para generar una subclase (especialización) de un objeto. Una Pato es una subclase de Ave. Cualquier cosa que contenga la definición de Ave será copiada a la clase Pato, además, en Pato se pueden definir sus propios métodos y variables de instancia. Se dice que Pato deriva o hereda de Ave. Además, se pueden sustituir los métodos proporcionados por la clase base. Utilizando nuestro anterior ejemplo de MiClase, aquí hay un ejemplo de una clase derivada sustituyendo a la función Suma_a_i(): import MiClase; public class MiNuevaClase extends MiClase { public void Suma_a_i( int j ) { i = i + ( j/2 ); } } Ahora cuando se crea una instancia de MiNuevaClase, el valor de i también se inicializa a 10, pero la llamada al método Suma_a_i() produce un resultado diferente: MiNuevaClase mnc; mnc = new MiNuevaClase(); mnc.Suma_a_i( 10 ); En Java no se puede hacer herencia múltiple. Por ejemplo, de la clase aparato con motor y de la clase animal no se puede derivar nada, sería como obtener el objeto toro mecánico a partir de una máquina motorizada (aparato con motor) y un toro (aminal). En realidad, lo que se pretende es copiar los métodos, es decir, pasar la funcionalidad del toro de verdad al 30
  • 31. toro mecánico, con lo cual no sería necesaria la herencia múltiple sino simplemente la compartición de funcionalidad que se encuentra implementada en Java a través de interfaces. CONTROL DE ACCESO Cuando se crea una nueva clase en Java, se puede especificar el nivel de acceso que se quiere para las variables de instancia y los métodos definidos en la clase: public public void CualquieraPuedeAcceder(){} Cualquier clase desde cualquier lugar puede acceder a las variables y métodos de instacia públicos. protected protected void SoloSubClases(){} Sólo las subclases de la clase y nadie más puede acceder a las variables y métodos de instancia protegidos. private private String NumeroDelCarnetDeIdentidad; Las variables y métodos de instancia privados sólo pueden ser accedidos desde dentro de la clase. No son accesibles desde las subclases. friendly (sin declaración específica) void MetodoDeMiPaquete(){} Por defecto, si no se especifica el control de acceso, las variables y métodos de instancia se declaran friendly (amigas), lo que significa que son accesibles por todos los objetos dentro del mismo paquete, pero no por los externos al paquete. Es lo mismo que protected. Los métodos protegidos (protected) pueden ser vistos por las clases derivadas, como en C+ +, y también, en Java, por los paquetes (packages). Todas las clases de un paquete pueden ver los métodos protegidos de ese paquete. Para evitarlo, se deben declarar como private protected, lo que hace que ya funcione como en C++ en donde sólo se puede acceder a las variables y métodos protegidos de las clases derivadas. VARIABLES Y METODOS ESTATICOS En un momento determinado se puede querer crear una clase en la que el valor de una variable de instancia sea el mismo (y de hecho sea la misma variable) para todos los objetos instanciados a partir de esa clase. Es decir, que exista una única copia de la variable de instancia. Se usará para ello la palabra clave static. class Documento extends Pagina { static int version = 10; } 31
  • 32. El valor de la variable version será el mismo para cualquier objeto instanciado de la clase Documento. Siempre que un objeto instanciado de Documento cambie la variable version, ésta cambiará para todos los objetos. De la misma forma se puede declarar un método como estático, lo que evita que el método pueda acceder a las variables de instancia no estáticas: class Documento extends Pagina { static int version = 10; int numero_de_capitulos; static void annade_un_capitulo() { numero_de_capitulos++; // esto no funciona } static void modifica_version( int i ) { version++; // esto si funciona } } La modificación de la variable numero_de_capitulos no funciona porque se está violando una de las reglas de acceso al intentar acceder desde un método estático a una variable no estática. Todas las clases que se derivan, cuando se declaran estáticas, comparten la misma página de variables; es decir, todos los objetos que se generen comparten la misma zona de memoria. Las funciones estáticas se usan para acceder solamente a variables estáticas. class UnaClase { int var; UnaClase() { var = 5; } UnaFuncion() { var += 5; } } En el código anterior, si se llama a la función UnaFuncion a través de un puntero a función, no se podría acceder a var, porque al utilizar un puntero a función no se pasa implícitamente el puntero al propio objeto (this). Sin embargo, sí se podría acceder a var si fuese estática, porque siempre estaría en la misma posición de memoria para todos los objetos que se creasen de UnaClase. this Y super Al acceder a variables de instancia de una clase, la palabra clave this hace referencia a los miembros de la propia clase. Volviendo al ejemplo de MiClase, se puede añadir otro constructor de la forma siguiente: public class MiClase { int i; public MiClase() { i = 10; } 32
  • 33. // Este constructor establece el valor de i public MiClase( int valor ) { this.i = valor; // i = valor } public void Suma_a_i( int j ) { i = i + j; } } Aquí this.i se refiere al entero i en la clase MiClase. Si se necesita llamar al método padre dentro de una clase que ha reemplazado ese método, se puede hacer referencia al método padre con la palabra clave super: import MiClase; public class MiNuevaClase extends MiClase { public void Suma_a_i( int j ) { i = i + ( j/2 ); super.Suma_a_i( j ); } } En el siguiente código, el constructor establecerá el valor de i a 10, después lo cambiará a 15 y finalmente el método Suma_a_i() de la clase padre (MiClase) lo dejará en 25: MiNuevaClase mnc; mnc = new MiNuevaClase(); mnc.Suma_a_i( 10 ); CLASES ABSTRACTAS Una de las características más útiles de cualquier lenguaje orientado a objetos es la posibilidad de declarar clases que definen como se utiliza solamente, sin tener que implementar métodos. Esto es muy útil cuando la implementación es específica para cada usuario, pero todos los usuarios tienen que utilizar los mismos métodos. Un ejemplo de clase abstracta en Java es la clase Graphics: public abstract class Graphics { public abstract void drawLine( int x1,int y1,int x2, int y2 ); public abstract void drawOval( int x,int y,int width, int height ); public abstract void drawArc( int x,int y,int width, int height,int startAngle,int arcAngle ); . . . } Los métodos se declaran en la clase Graphics, pero el código que ejecutará el método está en algún otro sitio: public class MiClase extends Graphics { public void drawLine( int x1,int y1,int x2,int y2 ) { <código para pintar líneas -específico de la arquitectura-> } } 33
  • 34. Cuando una clase contiene un método abstracto tiene que declararse abstracta. No obstante, no todos los métodos de una clase abstracta tienen que ser abstractos. Las clases abstractas no pueden tener métodos privados (no se podrían implementar) ni tampoco estáticos. Una clase abstracta tiene que derivarse obligatoriamente, no se puede hacer un new de una clase abstracta. Una clase abstracta en Java es lo mismo que en C++ virtual func() = 0; lo que obliga a que al derivar de la clase haya que implementar forzosamente los métodos de esa clase abstracta. INTERFACES Los métodos abstractos son útiles cuando se quiere que cada implementación de la clase parezca y funcione igual, pero necesita que se cree una nueva clase para utilizar los métodos abstractos. Los interfaces proporcionan un mecanismo para abstraer los métodos a un nivel superior. Un interface contiene una colección de métodos que se implementan en otro lugar. Los métodos de una clase son public, static y final. La principal diferencia entre interface y abstract es que un interface proporciona un mecanismo de encapsulación de los protocolos de los métodos sin forzar al usuario a utilizar la herencia. Por ejemplo: public interface VideoClip { // comienza la reproduccion del video void play(); // reproduce el clip en un bucle void bucle(); // detiene la reproduccion void stop(); } Las clases que quieran utilizar el interface VideoClip utilizarán la palabra implements y proporcionarán el código necesario para implementar los métodos que se han definido para el interface: class MiClase implements VideoClip { void play() { <código> } void bucle() { <código> } void stop() { <código> } Al utilizar implements para el interface es como si se hiciese una acción de copiar-y-pegar del código del interface, con lo cual no se hereda nada, solamente se pueden usar los métodos. 34
  • 35. La ventaja principal del uso de interfaces es que una clase interface puede ser implementada por cualquier número de clases, permitiendo a cada clase compartir el interfaz de programación sin tener que ser consciente de la implementación que hagan las otras clases que implementen el interface. class MiOtraClase implements VideoClip { void play() { <código nuevo> } void bucle() { <código nuevo> } void stop() { <código nuevo> } METODOS NATIVOS Java proporciona un mecanismo para la llamada a funciones C y C++ desde nuestro código fuente Java. Para definir métodos como funciones C o C++ se utiliza la palabra clave native. public class Fecha { int ahora; public Fecha() { ahora = time(); } private native int time(); static { System.loadLibrary( quot;timequot; ); } } Una vez escrito el código Java, se necesitan ejecutar los pasos siguientes para poder integrar el código C o C++: • Utilizar javah para crear un fichero de cabecera (.h) • Utilizar javah para crear un fichero de stubs, es decir, que contiene la declaración de las funciones • Escribir el código del método nativo en C o C++, es decir, rellenar el código de la función, completando el trabajo de javah al crear el fichero de stubs • Compilar el fichero de stubs y el fichero .c en una librería de carga dinámica (DLL en Windows '95 o libXX.so en Unix) • Ejecutar la aplicación con el appletviewer Más adelante trataremos en profundidad los métodos nativos, porque añaden una gran potencia a Java, al permitirle integrar a través de librería dinámica cualquier algoritmo desarrollado en C o C++, lo cual, entre otras cosas, se utiliza como método de protección contra la descompilación completa del código Java. 35
  • 36. PAQUETES La palabra clave package permite agrupar clases e interfaces. Los nombres de los paquetes son palabras separadas por puntos y se almacenan en directorios que coinciden con esos nombres. Por ejemplo, los ficheros siguientes, que contienen código fuente Java: Applet.java, AppletContext.java, AppletStub.java, AudioClip.java contienen en su código la línea: package java.applet; Y las clases que se obtienen de la compilación de los ficheros anteriores, se encuentran con el nombre nombre_de_clase.class, en el directorio: java/applet Import Los paquetes de clases se cargan con la palabra clave import, especificando el nombre del paquete como ruta y nombre de clase (es lo mismo que #include de C/C++). Se pueden cargar varias clases utilizando un asterisco. import java.Date; import java.awt.*; Si un fichero fuente Java no contiene ningún package, se coloca en el paquete por defecto sin nombre. Es decir, en el mismo directorio que el fichero fuente, y la clase puede ser cargada con la sentencia import: import MiClase; Paquetes de Java El lenguaje Java proporciona una serie de paquetes que incluyen ventanas, utilidades, un sistema de entrada/salida general, herramientas y comunicaciones. En la versión actual del JDK, los paquetes Java que se incluyen son: java.applet Este paquete contiene clases diseñadas para usar con applets. Hay una clase Applet y tres interfaces: AppletContext, AppletStub y AudioClip. java.awt El paquete Abstract Windowing Toolkit (awt) contiene clases para generar widgets y componentes GUI (Interfaz Gráfico de Usuario). Incluye las clases Button, Checkbox, Choice, Component, Graphics, Menu, Panel, TextArea y TextField. java.io El paquete de entrada/salida contiene las clases de acceso a ficheros: FileInputStream y FileOutputStream. 36
  • 37. java.lang Este paquete incluye las clases del lenguaje Java propiamente dicho: Object, Thread, Exception, System, Integer, Float, Math, String, etc. java.net Este paquete da soporte a las conexiones del protocolo TCP/IP y, además, incluye las clases Socket, URL y URLConnection. java.util Este paquete es una miscelánea de clases útiles para muchas cosas en programación. Se incluyen, entre otras, Date (fecha), Dictionary (diccionario), Random (números aleatorios) y Stack (pila FIFO). REFERENCIAS Java se asemeja mucho a C y C++. Esta similitud, evidentemente intencionada, es la mejor herramienta para los programadores, ya que facilita en gran manera su transición a Java. Desafortunadamente, tantas similitudes hacen que no nos paremos en algunas diferencias que son vitales. La terminología utilizada en estos lenguajes, a veces es la misma, pero hay grandes diferencias subyacentes en su significado. C tiene tipos de datos básicos y punteros. C++ modifica un poco este panorama y le añade los tipos referencia. Java también especifica sus tipos primitivos, elimina cualquier tipo de punteros y tiene tipos referencia mucho más claros. Todo este maremágnum de terminología provoca cierta consternación, así que vamos a intentar aclarar lo que realmente significa. Conocemos ya ampliamente todos los tipos básicos de datos: datos base, integrados, primitivos e internos; que son muy semejantes en C, C++ y Java; aunque Java simplifica un poco su uso a los desarrolladores haciendo que el chequeo de tipos sea bastante más rígido. Además, Java añade los tipos boolean y hace imprescindible el uso de este tipo booleano en sentencias condicionales. PUNTEROS Y REFERENCIAS C++ Punteros C y C++ permiten la declaración y uso de punteros, que pueden ser utilizados en cualquier lugar. Esta tremenda flexibilidad resulta muy útil, pero también es la causa de que podamos colgar todo el sistema. La intención principal en el uso de los punteros es comunicarnos más directamente con el hardware, haciendo que el código se acelere. Desafortunadamente, este modelo de tan bajo nivel hace que perdamos robustez y seguridad en la programación y hace muy difíciles 37
  • 38. tareas como la liberación automática de memoria, la defragmentación de memoria, o realizar programación distribuida de forma clara y eficiente. Referencias en C++ Las referencias se incorporaron a C++ en un intento de manejar punteros de C de forma más limpia y segura. Sin embargo, como no elimina los punteros, la verdad es que su propósito lo consigue a medias. Es más, podríamos decir que con las referencias C++, el lenguaje se vuelve más complicado y no es más poderoso que antes. Las referencias deben ser inicializadas cuando se declaran y no se pueden alterar posteriormente. Esto permite incrementar la eficiencia en tiempo de ejecución sobre la solución basada en punteros, pero es más por las deficiencias de los punteros que por las ventajas de las referencias. REFERENCIAS EN JAVA Las referencias en Java no son punteros ni referencias como en C++. Este hecho crea un poco de confusión entre los programadores que llegan por primera vez a Java. Las referencias en Java son identificadores de instancias de las clases Java. Una referencia dirige la atención a un objeto de un tipo específico. No tenemos por qué saber cómo lo hace ni necesitamos saber qué hace ni, por supuesto, su implementación. Pensemos en una referencia como si se tratase de la llave electrónica de la habitación de un hotel. Vamos a utilizar precisamente este ejemplo del Hotel para demostrar el uso y la utilización que podemos hacer de las referencias en Java. Primero crearemos la clase Habitacion, implementada en el fichero Habitacion.java, mediante instancias de la cual construiremos nuestro Hotel: public class Habitacion { private int numHabitacion; private int numCamas; public Habitacion() { habitacion( 0 ); } public Habitacion( int numeroHab ) { habitacion( numeroHab ); } public Habitacion( int numeroHab,int camas ) { habitacion( numeroHab ); camas( camas ); } public synchornized int habitacion() { return( numHabitacion ); } public synchronized void habitacion( int numeroHab ) { 38
  • 39. numHabitacion = numeroHab; } public synchronized int camas() { return( camas ); } public syncronized void camas( int camas ) { numCamas = camas; } } El código anterior sería el corazón de la aplicación. Vamos pues a construir nuestro Hotel creando Habitaciones y asignándole a cada una de ellas su llave electrónica; tal como muestra el código siguiente, Hotel1.java: public class Hotel1 { public static void main( String args[] ) { Habitacion llaveHab1; // paso 1 Habitacion llaveHab2; llaveHab1 = new Habitacion( 222 ); // pasos 2, 3, 4 y 5 llaveHab2 = new Habitacion( 1144,3 ); // ^^^^^^^^^ ^^^^^^^^^^^^^^ ^^^^^^ // A B y D C } } Para explicar el proceso, dividimos las acciones en los cinco pasos necesarios para poder entrar en nuestra habitación. Aunque no se incluye, podemos también considerar el caso de que necesitemos un cerrajero, para que cuando perdamos la llave, nos abra la puerta; y que en nuestro caso sería el garbage collector, que recicla la habitación una vez que se hayan perdido todas las llaves. El primer paso es la creación de la llave, es decir, definir la variable referencia, por defecto nula. El resto de los pasos se agrupan en una sola sentencia Java. La parte B en el código anterior indica al gerente del Hotel que ya dispone de una nueva habitación. La parte C llama al decorador de interiores para que quot;vistaquot; la habitación según un patrón determinado, para que no desentonen unas habitaciones con otras y no se pierdan las señas de identidad del hotel. El código electrónico que nos permitirá acceder a la habitación se genera en la parte D, una vez conocido el interior de la habitación y se programa en la llave en la parte A. Si dejamos el ejemplo real a un lado y nos vamos a lo que ocurre en la ejecución del código, vemos que el operador new busca espacio para una instancia de un objeto de una clase determinada e inicializa la memoria a los valores adecuados. Luego invoca al método constructor de la clase, proporcionándole los argumentos adecuados. El operador new devuelve una referencia a sí mismo, que es inmediatamente asignada a la variable referencia. 39
  • 40. Podemos tener múltiples llaves para una misma habitación: . . . Habitacion llaveHab3,llaveHab4; llaveHab3 = llaveHab1; llaveHab4 = llavehab2; De este modo conseguimos copias de las llaves. Las habitaciones en sí mismas no se han tocado en este proceso. Así que, ya tenemos dos llaves para la habitación 222 y otras dos para la habitación 1144. Una llave puede ser programada para que funcione solamente con una habitación en cualquier momento, pero podemos cambiar su código electrónico para que funcione con alguna otra habitación; por ejemplo, para cambiar una habitación anteriormente utilizada por un empedernido fumador por otra limpia de olores y con vistas al mar. Cambiemos pues la llave duplicada de la habitación del fumador (la 222) por la habitación con olor a sal marina, 1144: . . . llaveHab3 = llaveHab2; Ahora tenemos una llave para la habitación 222 y tres para la habitación 1144. Mantendremos una llave para cada habitación en la conserjería, para poder utilizarla como llave maestra, en el caso de que alguien pierda su llave propia. Alguien con la llave de una habitación puede hacer cambios en ella, y los compañeros que tengan llave de esa misma habitación, no tendrán conocimiento de esos cambios hasta que vuelvan a entrar en la habitación. Por ejemplo, vamos a quitar una de las camas de la habitación, entrando en ella con la llave maestra: . . . llaveHab2.camas( 2 ); Ahora cuando los inquilinos entren en la habitación podrán comprobar el cambio realizado: . . . llaveHab4.printData(); REFERENCIAS Y ARRAYS Como en C y C++, Java dispone de arrays de tipos primitivos o de clases. Los arrays en C y C++ son básicamente un acompañante para los punteros. En Java, sin embargo, son ciudadanos de primera clase. Vamos a expandir nuestro hotel creando todo un ala de habitaciones, Hotel2.java. Crearemos un juego de llaves maestras y luego construiremos las habitaciones: public class Hotel2 { // Número de habitaciones por ala public static final int habPorAla = 12; public static void main( String args[] ) { Habitacion llavesMaestras[]; // paso 1 llavesMaestras = new Habitacion[ habPorAla ]; // pasos 2-5 // ^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ 40
  • 41. // A B, C, D y E int numPiso = 1; for( int i=0; i < habPorAla; i++ ) // pasos 6-9 llavesMaestras[ i ] = new Habitacion( numPiso * 100 + i, ( 0 == (i%2)) ? 2 : 1 ); for( int i=0; i < habPorAla; i++ ) // pasos 10-11 llavesMaestras[i].printData(); } } Cada paso en el ejemplo es semejante al que ya vimos antes. El paso 1 especifica que el juego de llaves maestras es un grupo de llaves de habitaciones. Los pasos 2 a 5 son, en este caso, la parte principal. En lugar de crear una habitación, el gerente ordena construir un grupo contiguo de habitaciones. El número de llaves se especifica entre corchetes y todas se crean en blanco. Los pasos 6 a 9 son idénticos a los pasos 2 a 5 del ejemplo anterior, excepto en que en este caso todas las llaves pasan a formar parte del juego maestro. Los números de piso se dan en miles para que cuando se creen las habitaciones, todas tengan el mismo formato. También todas las habitaciones de número par tienen una sola cama, mientras que las habitaciones impares tendrán dos camas. Los pasos 10 y 11 nos permiten obtener información de cada una de las habitaciones. REFERENCIAS Y LISTAS Hay gente que piensa que como Java no dispone de punteros, resulta demasiado complejo construir listas enlazadas, árboles binarios y grafos. Vamos a demostrar que quien así piense está bastante equivocado. Retomemos el ejemplo de los arrays, y en vez de éstos vamos a usar una lista doblemente enlazada. El paquete de la lista simple se compone de dos clases. Cada elemento de la lista es un NodoListaEnlazada, NodoListaEnlazada.java: public class NodoListaEnlazada { private NodoListaEnlazada siguiente; private NodoListaEnlazada anterior; private Object datos; // . . . } Cada NodoListaEnlazada contiene una referencia a su nodo precedente en la lista y una referencia al nodo que le sigue. También contiene una referencia genérica a cualquier clase que se use para proporcionar acceso a los datos que el usuario proporcione. La lista enlazada, ListaEnlazada.java, contiene un nodo principio-fin y un contador para el número de nodos en la lista: public class ListaEnlazada { public NodoListaEnlazada PrincipioFin; private int numNodos; // . . . } 41
  • 42. El nodo especial PrincipioFin es sencillo, para simplificar el código. El contador se usa para optimizar los casos más habituales. Revisemos pues el código de nuestro Hotel, ahora Hotel3.java, que será prácticamente el mismo que en el caso de los arrays: public class Hotel3 { // Número de habitaciones por ala public static final int habPorAla = 12; public static void main( String args[] ) { ListaEnlazada llaveMaestra; // paso 1 llaveMaestra = new ListaEnlazada(); // pasos 2-5 int numPiso = 1; for( int i=0; i < habPorAla; i++ ) // pasos 6-9 llaveMaestra.insertAt( i, new Habitacion( numPiso * 100 + i, ( 0 == (i%2)) ? 2 : 1 ); for( int i=0; i < habPorAla; i++ ) // pasos 10-12 ( (Habitacion)llaveMaestra.getAt(i) ).printData(); } } El paso 1 es la llave maestra de la lista. Está representada por una lista genérica; es decir, una lista de llaves que cumple la convención que nosotros hemos establecido. Podríamos acelerar el tiempo de compilación metiendo la lista genérica ListaEnlazada dentro de una ListaEnlazadaHabitacion. Los pasos 2 a 5 son equivalentes a los del primer ejemplo. Construimos e inicializamos una nueva ListaEnlazada, que usaremos como juego de llaves maestras. Los pasos 6 a 9 son funcionalmente idénticos a los del ejemplo anterior con arrays, pero con diferente sintaxis. En Java, los arrays y el operador [] son internos del lenguaje. Como Java no soporta la sobrecarga de operadores por parte del usuario, tenemos que usarlo siempre en su forma normal. La ListaEnlazada proporciona el método insertAt() que coge el índice en la lista, donde el nuevo nodo ha de ser insertado, como primer argumento. El segundo argumento es el objeto que será almacenado en la lista. Obsérvese que no es necesario colocar moldeo alguno para hacer algo a una clase descendiente que depende de uno de sus padres. Los pasos 10 a 12 provocan la misma salida que los pasos 10 y 11 del ejemplo con arrays. El paso 10 coge la llave del juego que se indica en el método getAt(). En este momento, el sistema no sabe qué datos contiene la llave, porque el contenido de la habitación es genérico. Pero nosotros sí sabemos lo que hay en la lista, así que informamos al sistema haciendo un moldeado a la llave de la habitación (este casting generará un chequeo en tiempo de ejecución por el compilador, para asegurarse de que se trata de una Habitacion). El paso 12 usa la llave para imprimir la información. 42
  • 43. PUNTEROS C/C++ Y REFERENCIAS JAVA Ahora que ya sabemos un poco más sobre las referencias en Java, vamos a compararlas con los punteros de C y C++. Los punteros en C y C++ están orientados hacia un modelo físico de funcionamiento. Es decir, que el modelo de punteros se mapea directamente sobre el modelo hardware. Este modelo asume cosas como el no movimiento, lo que hace que mecanismos como la liberación automática resulten mucho menos eficientes o simplemente imposibles. Cosas como la distribución en redes y la persistencia de objetos son muy difíciles de conseguir en C y C++. Aunque no hay implementaciones en Java, por ahora, para la persistencia y la distribución, la característica opaca de las referencias en Java hace que el soporte para estas prestaciones sea mucho más simple. C y C++ permiten el uso de punteros de tal forma que podemos corromper el sistema, cosa que no puede suceder con las referencias en Java. Cualquier intento de hacer esto sería abortado por el compilador o por el sistema en ejecución (lanzando una excepción). C y C+ + dejan la protección de memoria al sistema operativo, que solamente tiene el recurso de generar un error del sistema cuando un puntero accede a una posición no válida. Por el contrario, con el uso de las referencias, Java nos protege contra nuestras propias tendencias autodestructivas. 43
  • 44. Como cualquier otro lenguaje, Java se usa para crear aplicaciones. Pero, también Java tiene la particularidad especial de poder crear aplicaciones muy especiales, son los applets, que es una mini (let) aplicación (app) diseñada para ejecutarse en un navegador. Vamos a ver en detalle lo mínimo que podemos hacer en ambos casos. UNA MINIMA APLICACION EN JAVA La aplicación más pequeña posible es la que simplemente imprimir un mensaje en la pantalla. Tradicionalmente, el mensaje suele ser quot;Hola Mundo!quot;. Esto es justamente lo que hace el siguiente fragmento de código: // // Aplicación HolaMundo de ejemplo // class HolaMundoApp { public static void main( String args[] ) { System.out.println( quot;Hola Mundo!quot; ) ; } } HolaMundo Vamos ver en detalle la aplicación anterior, línea a línea. Esas líneas de código contienen los componenetes mínimos para imprimir Hola Mundo! en la pantalla. // // Aplicación HolaMundo de ejemplo // Estas tres primera líneas son comentarios. Hay tres tipos de comentarios en Java, // es un comentario orientado a línea. class HolaMundoApp { Esta línea declara la clase HolaMundoApp. El nombre de la clase especificado en el fichero fuente se utiliza para crear un fichero nombredeclase.class en el directorio en el que se compila la aplicación. En nuestro caso, el compilador creará un fichero llamado HolaMundoApp.class. public static void main( String args[] ) { Esta línea especifica un método que el intérprete Java busca para ejecutar en primer lugar. Igual que en otros lenguajes, Java utiliza una palabra clave main para especificar la primera función a ejecutar. En este ejemplo tan simple no se pasan argumentos. public significa que el método main puede ser llamado por cualquiera, incluyendo el intérprete Java. static es una palabra clave que le dice al compilador que main se refiere a la propia clase HolaMundoApp y no a ninguna instancia de la clase. De esta forma, si alguien intenta hacer otra instancia de la clase, el método main no se instanciaría. 44
  • 45. void indica que main no devuelve nada. Esto es importante ya que Java realiza una estricta comprobación de tipos, incluyendo los tipos que se ha declarado que devuelven los métodos. args[] es la declaración de un array de Strings. Estos son los argumentos escritos tras el nombre de la clase en la línea de comandos: %java HolaMundoApp arg1 arg2 ... System.out.println( quot;Hola Mundo!quot; ); Esta es la funcionalidad de la aplicación. Esta línea muestra el uso de un nombre de clase y método. Se usa el método println() de la clase out que está en el paquete System. El método println() toma una cadena como argumento y la escribe en el stream de salida estándar; en este caso, la ventana donde se lanza la aplicación. } } Finalmente, se cierran las llaves que limitan el método main() y la clase HolaMundoApp. COMPILACION Y EJECUCION DE HolaMundo Vamos a ver a continuación como podemos ver el resultado de nuestra primera aplicación Java en pantalla. Generaremos un fichero con el código fuente de la aplicación, lo compilaremos y utilizaremos el intérprete java para ejecutarlo. Ficheros Fuente Java Los ficheros fuente en Java terminan con la extensión quot;.javaquot;. Crear un fichero utilizando cualquier editor de texto ascii que tenga como contenido el código de las ocho líneas de nuestra mínima aplicación, y salvarlo en un fichero con el nombre de HolaMundoApp.java. Para crear los ficheros con código fuente Java no es necesario un procesador de textos, aunque puede utilizarse siempre que tenga salida a fichero de texto plano o ascii, sino que es suficiente con cualquier otro editor. Compilación El compilador javac se encuentra en el directorio bin por debajo del directorio java, donde se haya instalado el JDK. Este directorio bin, si se han seguido las instrucciones de instalación, debería formar parte de la variable de entorno PATH del sistema. Si no es así, tendría que revisar la Instalación del JDK. El compilador de Java traslada el código fuente Java a byte-codes, que son los componentes que entiende la Máquina Virtual Java que está incluida en los navegadores con soporte Java y en appletviewer. Una vez creado el fichero fuente HolaMundoApp.java, se puede compilar con la línea siguiente: %javac HolaMundoApp.java Si no se han cometido errores al teclear ni se han tenido problemas con el path al fichero fuente ni al compilador, no debería aparecer mensaje alguno en la pantalla, y cuando vuelva a aparecer el prompt del sistema, se debería ver un fichero HolaMundoApp.class nuevo en el directorio donde se encuentra el fichero fuente. 45
  • 46. Si ha habido algún problema, en Problemas de compilación al final de esta sección, hemos intentado reproducir los que más frecuentemente se suelen dar, se pueden consultar por si pueden aportar un poco de luz al error que haya aparecido. Ejecución Para ejecutar la aplicación HolaMundoApp, hemos de recurrir al intérprete java, que también se encuentra en el directorio bin, bajo el directorio java. Se ejecutará la aplicación con la línea: %java HolaMundoApp y debería aparecer en pantalla la respuesta de Java: %Hola Mundo! El símbolo % representa al prompt del sistema, y lo utilizaremos para presentar las respuestas que nos ofrezca el sistema como resultado de la ejecución de los comandos que se indiquen en pantalla o para indicar las líneas de comandos a introducir. Problemas de compilación A continuación presentamos una lista de los errores más frecuentes que se presentan a la hora de compilar un fichero con código fuente Java, nos basaremos en errores provocados sobre nuestra mínima aplicación Java de la sección anterior, pero podría generalizarse sin demasiados problemas. %javac: Command not found No se ha establecido correctamente la variable PATH del sistema para el compilador javac. El compilador javac se encuentra en el directorio bin, que cuelga del directorio java, que cuelga del directorio donde se haya instalado el JDK (Java Development Kit). %HolaMundoApp.java:3: Method printl(java.lang.String) not found in class java.io.PrintStream. System.out.printl( quot;HolaMundo!); ^ Error tipográfico, el método es println no printl. %In class HolaMundoApp: main must be public and static Error de ejecución, se olvidó colocar la palabra static en la declaración del método main de la aplicación. %Can´t find class HolaMundoApp Este es un error muy sutil. Generalmente significa que el nombre de la clase es distinto al del fichero que contiene el código fuente, con lo cual el fichero nombre_fichero.class que se genera es diferente del que cabría esperar. Por ejemplo, si en nuestro fichero de código fuente de nuestra aplicación HolaMundoApp.java colocamos en vez de la declaración actual de la clase HolaMundoApp, la línea: class HolaMundoapp { se creará un fichero HolaMundoapp.class, que es diferente del HolaMundoApp.class, que es el nombre esperado de la clase; la diferencia se encuentra en la a minúscula y mayúscula. 46
  • 47. EL VISOR DE APPLETS DE SUN (appletviewer) El visualizador de applets (appletviewer) es una aplicación que permite ver en funcionamiento applets, sin necesidad de la utilización de un navegador World-Wide-Web como HotJava, Microsoft Explorer o Nescape. En adelante, recurriremos muchas veces a él, ya que el objetivo del tutorial es el lenguaje Java. Applet La definición más extendida de applet, muy bien resumida por Patrick Naughton, indica que un applet es quot;una pequeña aplicación accesible en un servidor Internet, que se transporta por la red, se instala automáticamente y se ejecuta in situ como parte de un documento webquot;. Claro que así la definición establece el entorno (Internet, Web, etc.). En realidad, un applet es una aplicación pretendidamente corta (nada impide que ocupe más de un gigabyte, a no ser el pensamiento de que se va a transportar por la red y una mente sensata) basada en un formato gráfico sin representación independiente: es decir, se trata de un elemento a embeber en otras aplicaciones; es un componente en su sentido estricto. Un ejemplo en otro ámbito de cosas podría ser el siguiente: Imaginemos una empresa, que cansada de empezar siempre a codificar desde cero, diseña un formulario con los datos básicos de una persona (nombre, dirección, etc.). Tal formulario no es un diálogo por sí mismo, pero se podría integrar en diálogos de clientes, proveedores, empleados, etc. El hecho de que se integre estática (embebido en un ejecutable) o dinámicamente (intérpretes, DLLs, etc.) no afecta en absoluto a la esencia de su comportamiento como componente con que construir diálogos con sentido autónomo. Pues bien, así es un applet. Lo que ocurre es que, dado que no existe una base adecuada para soportar aplicaciones industriales Java en las que insertar nuestras miniaplicaciones (aunque todo se andará), los applets se han construido mayoritariamente, y con gran acierto comercial (parece), como pequeñas aplicaciones interactivas, con movimiento, luces y sonido... en Internet. Llamadas a Applets con appletviewer Un applet es una mínima aplicación Java diseñada para ejecutarse en un navegador Web. Por tanto, no necesita preocuparse por un método main() ni en dónde se realizan las llamadas. El applet asume que el código se está ejecutando desde dentro de un navegador. El appletviewer se asemeja al mínimo navegador. Espera como argumento el nombre del fichero html que debe cargar, no se le puede pasar directamente un programa Java. Este fichero html debe contener una marca que especifica el código que cargará el appletviewer: <HTML> <APPLET CODE=HolaMundo.class WIDTH=300 HEIGHT=100> </APPLET> </HTML> El appletviewer crear un espacio de navegación, incluyendo un área gráfica, donde se ejecutará el applet, entonces llamará a la clase applet apropiada. En el ejemplo anterior, el appletviewer cargará una clase de nombre HolaMundo y le permitirá trabajar en su espacio gráfico. 47
  • 48. ARQUITECTURA DE APPLETVIEWER El appletviewer representa el mínimo interfaz de navegación. En la figura se muestran los pasos que seguiría appletviewer para presentarnos el resultado de la ejecución del código de nuestra clase. Esta es una visión simplificada del appletviewer. La función principal de esta aplicación es proporcionar al usuario un objeto de tipo Graphics sobre el que dibujar, y varias funciones para facilitar el uso del objeto Graphics. Ciclo de vida de un Applet Cuando un applet se carga en el appletviewer, comienza su ciclo de vida, que pasaría por las siguientes fases: • Se crea una instancia de la clase que controla el applet. En el ejemplo de la figura anterior, sería la clase HolaMundo. • El applet se incializa. • El applet comienza a ejecutarse. • El applet empieza a recibir llamadas. Primero recibe una llamada init (inicializar), seguida de un mensaje start (empezar) y paint (pintar). Estas llamadas pueden ser recibidas asíncronamente. METODOS DE APPLETVIEWER Vamos a utilizar como excusa la función asociada al appletviewer de los siguientes métodos para adentrarnos en su presentación, aunque a lo largo de secciones posteriores, 48
  • 49. volveremos a referirnos a ellos, porque también son los métodos propios de la clase Applet. init() El método init() se llama cada vez que el appletviewer carga por primera vez la clase. Si el applet llamado no lo sobrecarga, init() no hace nada. Fundamentalmente en este método se debe fijar el tamaño del applet, aunque en el caso de Netscape el tamaño que vale es el que se indique en la línea del fichero html que cargue el applet. También se deben realizar en este método las cargas de imágenes y sonidos necesarios para la ejecución del applet. Y, por supuesto, la asignación de valores a las variables globales a la clase que se utilicen. En el caso de los applet, este método únicamente es llamado por el sistema al cargar el applet. start() start() es la llamada para arrancar el applet cada vez que es visitado. La clase Applet no hace nada en este método. Las clases derivadas deben sobrecargarlo para comenzar la animación, el sonido, etc. Esta función es llamada automáticamente cada vez que la zona de visualización en que está ubicado el applet se expone a la visión, a fin de optimizar en uso de los recursos del sistema y no ejecutar algo que no puede ser apreciado (aunque el programador puede variar este comportamiento y hacer que un applet siga activo aun cuando esté fuera del área de visión). Esto es, imaginemos que cargamos un applet en un navegador minimizado; el sistema llamará al método init(), pero no a start(), que sí será llamado cuando restauremos el navegador a un tamaño que permita ver el applet. Naturalmente, start() se puede ejecutar varias veces: la primera tras init() y las siguientes (porque init() se ejecuta solamente una vez) tras haber aplicado el método stop(). stop() stop() es la llamada para detener la ejecución del applet. Se llama cuando el applet desaparece de la pantalla. La clase Applet tampoco hace nada en este método, que debería ser sobrecargado por las clases derivadas para detener la animación, el sonido, etc. Esta función es llamada cuando el navegador no incluye en su campo de visión al applet; por ejemplo, cuando abandona la página en que está insertado, de forma que el programador puede paralizar los threads que no resulten necesarios respecto de un applet no visible, y luego recuperar su actividad mediante el método start(). destroy() El método destroy() se llama cuando ya no se va a utilizar más el applet, cuando se necesita que sean liberados todos los recursos dispuestos por el applet, por ejemplo, cuando se cierra el navegador. La clase Applet no hace nada en este método. Las clases derivadas deberían sobrecargarlo para hacer 49
  • 50. una limpieza final. Los applet multithread deberían utilizar destroy() para detener los threads que quedasen activos. El appletviewer también contiene la clase Component (componente), que usa dos métodos para ayudas al applet a escribir en el espacio gráfico que el appletviewer le proporciona para su ejecución. paint( Graphics g ) Es la función llamada cada vez que el área de dibujo del applet necesita ser refrescada. La clase Applet simplemente dibuja un rectángulo gris en el área, es la clase derivada, obviamente, la que debería sobrecargar este método para representar algo inteligente en la pantalla. Cada vez que la zona del applet es cubierta por otra ventana, se desplaza el applet fuera de la visión o el applet cambia de posición debido a un redimensionamiento del navegador, el sistema llama automáticamente a este método, pasando como argumento un objeto de tipo Graphics que delimita la zona a ser pintada; en realidad se pasa una referencia al contexto gráfico en uso, y que representa la ventana del applet en la página web. update( Graphics g ) Esta es la función que realmente se llama cuando se necesita una actualización de la pantalla. La clase Applet simplemente limpia el área y llama al método paint(). Esta funcionalidad es suficiente para la mayoría de los casos; aunque, de cualquier forma, las clases derivadas pueden sustituir esta funcionalidad para sus propósitos especiales. Es decir, en las situaciones detalladas anteriormente que dañan la zona de exposición del applet, el sistema llama al método paint(), pero en realidad la llamada se realiza al método update(), cuyo comportamiento establecido en la clase Component es llamar al método paint(), tras haber rellenado la zona del applet con su color de fondo por defecto. Pudiera parecer así que se trata de un método de efecto neutro, pero si la función paint() cambiara el color del fondo, podríamos percibir un flick de cambio de colores nada agradable. Por tanto, habrá que cuidarse por lo común, de eliminar este efecto de limpia primero, sobrecargando el método update(), para que llame únicamente a paint(). Otra solución sería insertar el código de pintado en una sobrecarga del método update() y escribir un método paint() que sólo llame a update(). La última solución pasaría por usar el mismo método setBackground( Color ), en el método init() para así evitar el efecto visual sin tener que sobrecargar el método update(). Estas son las mismas razones que aconsejan usar el método resize() inserto en init(), para evitar el mismo desagradable efecto. repaint Llamando a este método se podrá forzar la actualización de un applet, la llamada a update(). Pero hay que tener cierto cuidado, porque AWT posee cierta inteligencia (combinación casi siempre nefasta), de forma que si se 50
  • 51. llama a update() mediante repaint() con una frecuencia muy corta, AWT ignorará las llamadas a update() que estime oportuno, pues considera a esta función como un bien escaso. Sinopsis La llamada a appletviewer es de la forma: appletviewer [-debug] urls... El appletviewer toma como parámetro de ejecución, o bien el nombre del un fichero html conteniendo el tag (marca) <APPLET>, o bien un URL hacia un fichero HTML que contenga esa marca. Si el fichero html no contiene un tag <APPLET> válido, el appletviewer no hará nada. El appletviewer no muestra otras marcas html. La única opción válida que admite la llamada a appletviewer es -debug, que arranca el applet en el depurador de Java, jdb. Para poder ver el código fuente en el depurador, se tiene que compilar el fichero .java con la opción -g. Ejemplo de uso En el ejemplo de llamada al appletviewer siguiente, hacemos que se ejecute el applet básico que crearemos en la sección siguiente y que lanzaremos desde un fichero html del mismo nombre que nuestro fichero de código fuente Java. %appletviewer HolaMundo.html Esta llamada lanzaría la ejecución de HolaMundo.class en el appletviewer, abriéndose en pantalla la ventana siguiente: FUNCIONES DE MENU DE APPLETVIEWER El appletviewer tiene un único menú mostrado en la imagen siguiente y que vamos a explicar en cada una de sus opciones, ya que lo usaremos a menudo cuando vayamos avanzando en nuestros conocimientos de Java. 51
  • 52. • Restart La función Restart llama al método stop() y seguidamente llama de nuevo a start(), que es el método que ha lanzado inicialmente la ejecución del applet. Se puede utilizar Restart para simular el movimiento entre páginas en un documento html. • Reload La función Reload llama al método stop() y luego al método destroy() en el applet actual. A continuación carga una nueva copia del applet y la arranca llamando al método start(). • Clone La función Clone crea una copia del applet actual en una ventana de appletviewer nueva. En realidad es un appletviewer idéntico con el mismo URL. • Tag La función Tag muestra en una ventana hija del appletviewer el código html cargado para su ejecución. Es similar a la función View Source que figura en la mayoría de los navegadores, Netscape, Internet Explorer y HotJava incluidos. • Info La función Info lee los comentarios de documentación contenidos en el fichero html y muestra la información de los parámetros (si la hay). • Properties El appletviewer tiene las funciones básicas de presentación de un navegador y la función Properties (propiedades de la red) permite cambiar o establecer el modo de seguridad o fijar los servidores de proxy o firewall. 52
  • 53. • Close La función Close llama al método destroy() de la ventana actual del appletviewer, teminando su ejecución. • Quit La función Quit llama al método destroy() de cada una de las copias del appletviewer que se encuentren lanzadas, concluyendo la ejecución de todas ellas y terminando entonces el appletviewer. UN APPLET BASICO EN JAVA Vamos a comenzar la creación del código fuente del un applet que satisfaga nuestras necesidades. Recordamos que Java utiliza la extensión .java para designar los ficheros fuente. HolaMundo A continuación está el código fuente del applet HolaMundo, que es la versión applet de la mínima aplicación Java que antes habíamos escrito. Guardar este código en un fichero fuente Java como HolaMundo.java. // // Applet HolaMundo de ejemplo // import java.awt.Graphics; import java.applet.Applet; public class HolaMundo extends Applet { public void paint( Graphics g ) { g.drawString( quot;Hola Mundo!quot;,25,25 ) ; } } Componentes básicos de un Applet El lenguaje Java implementa un modelo de Programación Orientada a Objetos. Los objetos sirven de bloques centrales de construcción de los programas Java. De la misma forma que otros lenguajes de programación, Java tiene variables de estado y métodos. Veamos como se descompone un applet en sus piezas/objetos: /* Sección de importaciones */ public class NombreDelNuevoApplet extends Applet { /* Aquí se declaran las variables de estado (public y private) */ 53
  • 54. /* Los métodos para la interacción con los objetos se declaran y definen aquí */ public void MetodoUno( parámetros ) { /* Aquí viene para cada método, el código Java que desempeña la tarea. Qué código se use depende del applet */ } } Para HolaMundo, se importan las dos clases que necesita. No hay variables de estado, y sólo se tiene que definir un método para que el applet tenga el comportamiento esperado. Clases incluidas El comando import carga otras clases dentro de nuestro código fuente. El importar una clase desde un paquete de Java hace que esa clase importada esté disponible para todo el código incluido en el fichero fuente Java que la importa. Por ejemplo, en el applet HolaMundo se importa la clase java.awt.Graphics, y podremos llamar a los métodos de esta clase desde cualquier método de nuestro programa que se encuentre en el fichero HolaMundo.java. Esta clase define una área gráfica y métodos para poder dibujar dentro de ella. La función paint() declara a g como un objeto de tipo Graphics; luego, paint() usa el método drawString() de la clase Graphics para generar su salida. La clase Applet Se puede crear una nueva clase, en este caso HolaMundo, extendiendo la clase básica de Java: Applet. De esta forma, se hereda todo lo necesario para crear un applet. Modificando determinados métodos del applet, podemos lograr que lleve a cabo las funciones que deseamos. import java.applet.Applet; . . . public class HolaMundo extends Applet { Métodos de Applet La parte del applet a modificar es el método paint(). En la clase Applet, se llama al método paint() cada vez que el método arranca o necesita ser refrescado, pero no hace nada. En nuestro caso, lo que hacemos es: public void paint( Graphics g ) { g.drawString( quot;Hola Mundo!quot;,25,25 ); } De acuerdo a las normas de sobrecarga, se ejecutará este último paint() y no el paint() vacío de la clase Applet. Luego, aquí se ejecuta el método drawString(), que le dice al applet cómo debe aparecer un texto en el área de dibujo. Otros métodos básicos para dibujar son: drawLine( int x1,int y1,int x2,int y2 ) drawRect( int x,int y,int ancho,int alto ) 54
  • 55. drawOval( int x,int y,int ancho,int alto ) Tanto para drawRect() como para drawOval(), las coordenadas (x,y) son la esquina superior izquierda del rectángulo (para drawOval, el óvalo es encajado en el rectángulo que lo circunscribe). COMPILACION DE UN APPLET Ahora que tenemos el código de nuestro applet básico y el fichero fuente Java que lo contiene, necesitamos compilarlo y obtener un fichero .class ejecutable. Se utiliza el compilador Java, javac, para realizar la tarea. El comando de compilación será: %javac HolaMundo.java Eso es todo. El compilador javac generará un fichero HolaMundo.class que podrá ser llamado desde cualquier navegador con soporte Java y, por tanto, capaz de ejecutar applets Java. Llamada a Applets ¿Qué tienen de especial HotJava, Microsoft Explorer o Netscape con respecto a otros navegadores? Con ellos se puede ver html básico y acceder a todo el texto, gráfico, sonido e hipertexto que se pueda ver con cualquier otro navegador. Pero además, pueden ejecutar applets, que no es html estándar. Ambos navegadores entienden código html que lleve la marca <APPLET>: <APPLET CODE=quot;SuCodigo.classquot; WIDTH=100 HEIGHT=50> </APPLET> Esta marca html llama al applet SuCodigo.class y establece su ancho y alto inicial. Cuando se acceda a la página Web donde se encuentre incluida la marca, se ejecutará el byte-code contenido en SuCodigo.class, obteniéndose el resultado de la ejecución del applet en la ventana del navegador, con soporte Java, que estemos utilizando. Prueba de un Applet El JDK, Kit de Desarrollo de Java, incluye el visor de applets básico, appletviewer, que puede utilizarse para la visualización rápida y prueba de nuestros applets, tal como se ha visto ya. La ejecución de un applet sobre appletviewer se realiza a través de la llamada: %appletviewer fichero.html En nuestro caso el fichero con el código html que ejecutará nuestro applet HolaMundo es HolaMundo.html que generará la salida que se mostraba en la sección sobre el Ejemplo de uso de appletviewer. LA MARCA APPLET DE HTML Dado que los applets están mayormente destinados a ejecutarse en navegadores Web, había que preparar el lenguaje HTML para soportar Java, o mejor, los applets. El esquema de marcas de HTML, y la evolución del estándar marcado por Netscape hicieron fácil la adición de una nueva marca que permitiera, una vez añadido el correspondiente código gestor en los navegadores, la ejecución de programas Java en ellos. 55
  • 56. La sintaxis de las etiquetas <APPLET> y <PARAM> es la que se muestra a continuación y que iremos explicando en párrafos posteriores: <APPLET CODE= WIDTH= HEIGTH= [CODEBASE=] [ALT=] [NAME=] [ALIGN=] [VSPACE=] [HSPACE=]> <PARAM NAME= VALUE= > </APPLET> Atributos obligatorios: CODE : Nombre de la clase principal WIDTH : Anchura inicial HEIGHT : Altura inicial Atributos opcionales: CODEBASE : URL base del applet ALT : Texto alternativo NAME : Nombre de la instancia ALIGN : Justificación del applet VSPACE : Espaciado vertical HSPACE : Espaciado horizontal Los applets se incluyen en las páginas Web a través de la marca <APPLET>, que para quien conozca html resultará muy similar a la marca <IMG>. Ambas necesitan la referencia a un fichero fuente que no forma parte de la página en que se encuentran embebidos. IMG hace esto a través de SRC=parámetro y APPLET lo hace a través CODE=parámetro. El parámetro de CODE indica al navegador dónde se encuentra el fichero con el código Java compilado .class. Es una localización relativa al documento fuente. Por razones que no entiendo muy bien, pero posiblemente relacionadas con los packages y classpaths, si un applet reside en un directorio diferente del que contiene a la página en que se encuentra embebido, entonces no se indica un URL a esta localización, sino que se apunta al directorio del fichero .class utilizando el parámetro CODEBASE, aunque todavía se puede usar CODE para proporcionar el nombre del fichero .class. Al igual que IMG, APPLET tiene una serie de parámetros que lo posicionan en la página. WIDTH y HEIGHT especifican el tamaño del rectángulo que contendrá al applet, se indican en pixels. ALIGN funciona igual que con IMG (en los navegadores que lo soportan), definiendo cómo se posiciona el rectángulo del applet con respecto a los otros elementos de la página. Los valores posibles a especificar son: LEFT, RIGHT, TOP, TEXTTOP, MIDDLE, ABSMIDDLE, BASELINE, BOTTOM y ABSBOTTOM. Y, finalmente, lo mismo que con IMG, se puede especificar un HSPACE y un VSPACE en pixels para indicar la cantidad de espacio vacío que habrá de separación entre el applet y el texto que le rodea. 56
  • 57. APPLET tiene una marca ALT. La utilizaría un navegador que entendiese la marca APPLET, pero que por alguna razón, no pudiese ejecutarlo. Por ejemplo, si un applet necesita escribir en el disco duro de nuestro ordenador, pero en las características de seguridad tenemos bloqueada esa posibilidad, entonces el navegador presentaría el texto asociado a ALT. ALT no es utilizado por los navegadores que no entienden la marca APPLET, por ello se ha definido la marca </APPLET>, que finaliza la descripción del applet. Un navegador con soporte Java ignorará todo el texto que haya entre las dos marcas <APPLET> y </APPLET>, sin embargo, un navegador que no soporte Java ignorará las marcas y presentará el texto que se encuentre entre ellas. ATRIBUTOS DE APPLET Los atributos que acompañan a la etiqueta <APPLET>, algunos son obligatorios y otros son opcionales. Todos los atributos, siguiendo la sintaxis de html, se especifican de la forma: atributo=valor. Los atributos obligatorios son: CODE Indica el fichero de clase ejecutable, que tiene la extensión .class. No se permite un URL absoluto, como ya se ha dicho, aunque sí puede ser relativo al atributo opcional CODEBASE. WIDTH Indica la anchura inicial que el navegador debe reservar para el applet en pixels. HEIGHT Indica la altura inicial en pixels. Un applet que disponga de una geometría fija no se verá redimensionado por estos atributos. Por ello, si los atributos definen una zona menor que la que el applet utiliza, únicamente se verá parte del mismo, como si se visualiza a través de una ventana, eso sí, sin ningún tipo de desplazamiento. Los atributos opcionales que pueden acompañar a la marca APPLET comprenden los que se indican a continuación: CODEBASE Se emplea para utilizar el URL base del applet. En caso de no especificarse, se utilizará el mismo que tiene el documento. ALT 57
  • 58. Como ya se ha dicho, funciona exactamente igual que el ALT de la marca <IMG>, es decir, muestra un texto alternativo, en este caso al applet, en navegadores en modo texto o que entiendan la etiqueta APPLET pero no implementen una máquina virtual Java. NAME Otorga un nombre simbólico a esta instancia del applet en la página que puede ser empleado por otros applets de la misma página para localizarlo. Así, un applet puede ser cargado varias veces en la misma página tomando un nombre simbólico distinto en cada momento. ALIGN Se emplea para alinear el applet permitiendo al texto fluir a su alrededor. Puede tomas los siguientes valores: LEFT, RIGHT, TOP, TEXTTOP, MIDDLE, ABSMIDDLE, BASELINE, BOTTOM y ABSBOTTOM. VSPACE Indica el espaciado vertical entre el applet y el texto, en pixels. Sólo funciona cuando se ha indicado ALIGN = LEFT o RIGHT. HSPACE Funciona igual que el anterior pero indicando espaciamiento horizontal, en pixels. Sólo funciona cuando se ha indicado ALIGN = LEFT o RIGHT. Es probable encontrar en algunas distribuciones otras etiquetas para la inclusión de applets, como <APP>. Esto se debe a que estamos ante la tercera revisión de la extensión de HTML para la incrustación de applets y ha sido adoptada como la definitiva. Por ello, cualquier otro medio corresponde a implementaciones obsoletas que han quedado descartadas. PASO DE PARAMETROS A APPLETS El espacio que queda entre las marcas de apertura y cierre de la definición de un applet, se utiliza para el paso de parámetros al applet. Para ello se utiliza la marca PARAM en la página HTML para indicar los parámetros y el método getParameter() de la clase java.applet.Applet para leerlos en el código interno del applet. La construcción puede repetirse cuantas veces se quiera, una tras otra. Los atributos que acompañan a la marca PARAM son los siguientes: NAME Nombre del parámetro que se desea pasar al applet. VALUE Valor que se desea transmitir en el parámetro que se ha indicado antes. 58
  • 59. Texto HTML Texto HTML que será interpretado por los navegadores que no entienden la marca APPLET en sustitución del applet mismo. Para mostar esta posibilidad vamos a modificar nuestro applet básico HolaMundo para que pueda saludar a cualquiera. Lo que haremos será pasarle al applet el nombre de la persona a quien queremos saludar. Generamos el código para ello y lo guardamos en el fichero HolaTal.java import java.awt.Graphics; import java.applet.Applet; public class HolaTal extends Applet { String nombre; public void init() { nombre = getParameter( quot;Nombrequot; ); } public void paint( Graphics g ) { g.drawString( quot;Hola quot;+nombre+quot;!quot;,25,25 ); } } Si compilamos el ejemplo obtendremos el fichero HolaTal.class que incluiremos en nuestra página Web. Vamos a generar el fichero HolaTal.html, en el que incluiremos nuestro applet, y que debería tener el siguiente contenido: <HTML> <APPLET CODE=HolaTal.class WIDTH=300 HEIGHT=100> <PARAM NAME=quot;Nombrequot; VALUE=quot;Agustinquot;> </APPLET> </HTML> Por supuesto, que puedes sustituir mi nombre por el tuyo. Este cambio no afectará al código Java, no será necesario recompilarlo para que te salude a ti el applet. Los parámetros no se limitan a uno solo. Se puede pasar al applet cualquier número de parámetros y siempre hay que indicar un nombre y un valor para cada uno de ellos. El método getParameter() es fácil de entender. El único argumento que necesita es el nombre del parámetro cuyo valor queremos recuperar. Todos los parámetros se pasan como Strings, en caso de necesitar pasarle al applet un valor entero, se ha de pasar como String, recuperarlo como tal y luego convertirlo al tipo que deseemos. Tanto el argumento de NAME como el de VALUE deben ir colocados entre dobles comillas (quot;) ya que son String. El hecho de que las marcas <APPLET> y <PARAM> sean ignoradas por los navegadores que no entienden Java, es inteligentemente aprovechado a la hora de definir un contenido alternativo a ser mostrado en este último caso. Así la etiqueta es doble: <APPLET atributos> parámetros contenido alternativo </APPLET> 59
  • 60. Nuestro fichero para mostrar el applet de ejemplo lo modificaremos para que pueda ser visualizado en cualquier navegador y en unos casos presente la información alternativa y en otros, ejcute nuestro applet: <HTML> <APPLET CODE=HolaTal.class WIDTH=300 HEIGHT=100> <PARAM NAME=quot;Nombrequot; VALUE=quot;Agustinquot;> No verás lo bueno hasta que consigas un navegador <I>Java Compatible</I> </APPLET> </HTML> TOKENS EN PARAMETROS DE LLAMADA Ya de forma un poco más avanzada vamos a ver como también se pueden pasar varios parámetros en la llamada utilizando separadores, o lo que es lo mismo, separando mediante delimitadores los parámetros, es decir, tokenizando la cadena que contiene el valor del parámetro, por ejemplo: <PARAM NAME=Nombre VALUE=quot;Agustin|Antonioquot;> En este caso el separador es la barra vertical quot;|quot;, que delimita los dos tokens, pero también podemos redefinirlo y utilizar cualquier otro símbolo como separador: <PARAM NAME=Separador VALUE=quot;#quot;> <PARAM NAME=Nombre VALUE=quot;Agustin#Antonioquot;> Si ahora intentamos cambiar de color de fondo en que aparecen los textos en el applet, utilizando el mismo método, podríamos tener: <PARAM NAME=Nombre VALUE=quot;Agustin|Antonioquot;> <PARAM NAME=Color VALUE=quot;green|redquot;> Es más, podríamos hacer que parpadeasen los mensajes en diferentes colores, cambiando el color de fondo y el del texto: <PARAM NAME=Nombre1 VALUE=quot;Agustin|green|yellowquot;> <PARAM NAME=Nombre2 VALUE=quot;Antonio|red|whitequot;> Para recoger los parámetros pasados en este último caso, bastaría con hacer un pequeño bucle de lectura de los parámetros que deseamos: for( int i=1; ; i++ ) p = getParameter( quot;Nombrequot;+i ); if( p == null ) break; . . . } incluso podríamos utilizar un fichero para pasar parámetros al applet. La llamada sería del mismo tipo: <PARAM NAME=Fichero VALUE=quot;FicheroDatosquot;> y el FicheroDatos debería tener un contenido, en este caso, que sería el siguiente: Agustin fondoColor=green textoColor=yellow fuente=Courier fuenteTam=14 60
  • 61. Antonio fondoColor=red textocolor=white E incluso ese FicheroDatos, podríamos hacer que se encontrase en cualquier URL, de forma que utilizando el método getContent() podríamos recuperar el contenido del fichero que contiene los parámetros de funcionamiento del applet: String getContent( String url ) { URL url = new URL( null,url ); return( (String).url.getContent() ); } Para recuperar los parámetros que están incluidos en la cadena que contiene el valor podemos utilizar dos métodos: StringTokenizer( string,delimitadores ) treamTokenizer( streamentrada ) Así en la cadena Agustin|Antonio si utilizamos el método: StringTokenizer( cadena,quot;|quot; ); obtenemos el token Agustin, el delimitador quot;|quot; y el token Antonio. El código del método sería el que se muestra a continuación: // Capturamos el parámetro p = getParameter( quot;pquot; ); // Creamos el objeto StringTokenizer st = new StringTokenizer( p,quot;|quot; ); // Creamos el almacenamiento cads = new String[ st.countTokens() ]; // Separamos los tokens de la cadena del parámetro for( i=0; i < cads.length; i++ ) cadenas[i] = st.nextToken(); En el caso de que utilicemos un fichero como verdadera entrada de parámetros al applet y el fichero se encuentre en una dirección URL, utilizamos el método StreamTokenizer() para obtener los tokens que contiene ese fichero: // Creamos el objeto URL para acceder a él url = new URL( quot;http://www.prueba.es/Ficheroquot; ); // Creamos el canal de entrada ce = url.openStream(); // Creamos el objeto StreamTokenizer st = new StreamTokenizer( ce ); // Capturamos los tokens st.nextToken(); 61
  • 62. EL PARAMETRO ARCHIVE Una de las cosas que se achacan a Java es la rapidez. El factor principal en la percepción que tiene el usuario de la velocidad y valor de los applets es el tiempo que tardan en cargarse todas las clases que componen el applet. Algunas veces tenemos que estar esperando más de un minuto para ver una triste animación, ni siquiera buena. Y, desafortunadamente, esta percepción de utilidad negativa puede recaer también sobre applets que realmente sí son útiles. Para entender el porqué de la necesidad de un nuevo método de carga para acelerarla, necesitamos comprender porqué el método actual es lento. Normalmente un applet se compone de varias clases, es decir, varios ficheros .class. Por cada uno de estos ficheros .class, el cargador de clases debe abrir una conexión individual entre el navegador y el servidor donde reside el applet. Así, si un applet se compone de 20 ficheros .class, el navegador necesitará abrir 20 sockets para transmitir cada uno de los ficheros. La sobrecarga que representa cada una de estas conexiones es relativamente significante. Por ejemplo, cada conexión necesita un número de paquetes adicionales que incrementan el tráfico en la Red. Me imagino que ya el lector habrá pensado la solución al problema: poner todos los ficheros en uno solo, con lo cual solamente sería necesaria una conexión para descargar todo el código del applet. Bien pensado. Esto es lo mismo que han pensado los dos grandes competidores en el terreno de los navegadores, Netscape y Microsoft. Desafortunadamente, las soluciones que han implementado ambas compañías no son directamente compatibles. Microsoft, en su afán de marcar diferencia, crea su propio formato de ficheros CAB. La solución de Netscape es utilizar el archiconocido formato ZIP. Por suerte, nosotros podemos escribir nuestro código HTML de forma que maneje ambos formatos, en caso necesario. Esto es así porque podemos especificar cada uno de estos formatos de ficheros especiales en extensiones separadas de la marca <APPLET>. No vamos a contar la creación de ficheros CAB; quien esté interesado puede consultar la documentación de Java que proporciona Microsoft con su SDK para Java, que es bastante exhaustiva al respecto. Una vez que disponemos de este fichero, podemos añadir un parámetro CABBASE a la marca <APPLET>: <APPLET NAME=quot;Holaquot; CODE=quot;HolaMundoquot; WIDTH=50 HEIGHT=50 > <PARAM NAME=CODEBASE VALUE=quot;http://www.ejemplo.es/classesquot;> <PARAM NAME=CABBASE VALUE=quot;hola.cabquot;> </APPLET> El VALUE del parámetro CABBASE es el nombre del fichero CAB que contiene los ficheros .class que componen el conjunto de applet. Crear un archivo ZIP para utilizarlo con Netscape es muy fácil. Se deben agrupar todos los ficheros .class necesarios en un solo fichero .zip. Lo único a tener en cuenta es que solamente hay que almacenar los ficheros .class en el archivo; es decir, no hay que comprimir. 62
  • 63. Si se está utilizando pkzip, se haría: Pkzip -e0 archivo.zip listaFicherosClass El parámetro de la línea de comandos es el número cero, no la quot;Oquot; mayúscula. Para utilizar un fichero .zip hay que indicarlo en la marca ARCHIVE de la sección <APPLET>: <APPLET NAME=quot;Holaquot; CODE=quot;HolaMundoquot; WIDTH=50 HEIGHT=50 CODEBASE VALUE=quot;http://www.ejemplo.es/classesquot; ARCHIVE=quot;hola.zipquot;> </APPLET> Pero hay más. Podemos crear ambos tipos de ficheros y hacer que tanto los usuarios de Netscape Navigator como los de Microsoft Internet Explorer puedan realizar descargas rápidas del código del applet. No hay que tener en cuenta los usuarios de otros navegadores, o de versiones antiguas de estos dos navegadores, porque ellos todavía podrán seguir cargando los ficheros a través del método lento habitual. Para compatibilizarlo todo, ponemos las piezas anteriores juntas: <APPLET NAME=quot;Holaquot; CODE=quot;HolaMundoquot; WIDTH=50 HEIGHT=50 CODEBASE VALUE=quot;http://www.ejemplo.es/classesquot; ARCHIVE=quot;hola.zipquot;> <PARAM NAME=CABBASE VALUE=quot;hola.cabquot;> <PARAM NAME=CODEBASE VALUE=quot;http://www.ejemplo.es/classesquot;> <PARAM NAME=CABBASE VALUE=quot;hola.cabquot;> </APPLET> Ahora que se puede hacer esto con ficheros .cab y .zip, JavaSoft ha definido un nuevo formato de ficheros, que incorporará en del JDK 1.1, para incluir juntos todos los ficheros de imágenes, sonido y class. JavaSoft llama a esto formato JAR (Java Archive). La marca <APPLET> de HTML se modificará para manejar este nuevo formato JAR a través del parámetro ARCHIVES. Y dejamos al lector el trabajo de poner los tres formatos juntos bajo el mismo paraguas de la marca <APPLET>. DEPURACION GENERAL Compilar y ejecutar el programa HolaMundo.java a través del fichero HolaMundo.html no debería suponer ningún problema, pero alguna vez nos encontraremos frente a programas más difíciles y se necesitará el truco de depuración al que se recurre en el desarrollo de programas en cualquier lenguaje. System.out.println Una de las herramientas de depuración más efectivas en cualquier lenguaje de programación es simplemente la salida de información por pantalla. El comando System.out.println imprime la cadena que se le especifique en la ventana de texto en la que se invocó al navegador. La forma de usarlo se muestra a continuación: public void paint( Graphics g ) { g.drawString( quot;Hola Mundo!quot;,25,25 ); System.out.println( quot;Estamos en paint()quot; ); } 63
  • 64. CICLO DE VIDA DE UN APPLET Para seguir el ciclo de vida de un applet, supondremos que estamos ejecutando en nuestro navegador el applet básico HolaMundo, a través de la página HTML que lo carga y corre. Lo primero que aparece son los mensajes quot;initializing... starting...quot;, como resultado de la carga del applet en el navegador. Una vez cargado, lo que sucede es: Se crea una instancia de la clase que controla al applet El applet se inicializa a si mismo Comienza la ejecución del applet Cuando se abandona la página, por ejemplo, para ir a la siguiente, el applet detiene la ejecución. Cuando se regresa a la página que contiene el applet, se reanuda la ejecución. Si se utiliza la opción del navegador de Reload, es decir, volver a cargar la página, el applet es descargado y vuelto a cargar. El applet libera todos los recursos que hubiese acaparado, detiene su ejecución y ejecuta su finalizador para realizar un proceso de limpieza final de sus trazas. Después de esto, el applet se descarga de la memoria y vuelve a cargarse volviendo a comenzar su inicialización. Finalmente, cuando se concluye la ejecución del navegador, o de la aplicación que está visualizando el applet, se detiene la ejecución del applet y se libera toda la memoria y recursos ocupados por el applet antes de salir del navegador. PROTECCION DE APPLETS Como curiosidad, más que como algo verdaderamente útil, podemos proteger nuestros applets de forma muy sencilla, o por lo menos evitar que nadie pueda ocultar en sus páginas HTML que nosotros somos los legales autores de un applet. El método es muy sencillo y se basa en la utilización de un parámetro del cual comprobamos su existencia, por ejemplo: <PARAM NAME=copyright VALUE=quot;Applet de Prueba, A.Froufe (C)1996, Todos los derechos reservadosquot;> y en el código Java de nuestro applet, comprobaríamos que efectivamente el parámetro copyright existe y ese es su contenido: if( !getParameter( quot;copyrightquot;).equals( quot;...quot; ) throw( new Exception( quot;Violacion del Copyrightquot; ) ); donde quot;...quot; es el texto completo del valor del parámetro. Pero también podemos hacerlo de forma más elegante: copyright = getParameter( quot;copyrightquot; ); // System.out.println( copyright.hashCode() ); if( copyright != -913936799 ) throw( new Exception( quot;Violacion del Copyrightquot; ) ); 64
  • 65. en donde la sentencia comentada nos proporciona el valor del copyright para poder introducirlo en la comparación de la presencia o no del parámetro en la llamada al applet. Habría que declarar y definir correctamente tipos y variables, pero la idea básica es la que expuesta. ESCRIBIR APPLETS JAVA Para escribir applets Java, hay que utilizar una serie de métodos, algunos de los cuales ya se hay sumariado al hablar de los métodos del appletviewer, que es el visualizador de applets de Sun. Incluso para el applet más sencillo necesitaremos varios métodos. Son los que se usan para arrancar (start) y detener (stop) la ejecución del applet, para pintar (paint) y actualizar (update) la pantalla y para capturar la información que se pasa al applet desde el fichero HTML a través de la marca APPLET. init() Esta función miembro es llamada al crearse el applet. Es llamada sólo una vez. La clase Applet no hace nada en init(). Las clases derivadas deben sobrecargar este método para cambiar el tamaño durante su inicialización, y cualquier otra inicialización de los datos que solamente deba realizarse una vez. Deberían realizarse al menos las siguientes acciones: • Carga de imágenes y sonido • El resize del applet para que tenga su tamaño correcto • Asignación de valores a las variables globales Por ejemplo: public void init() { if( width < 200 || height < 200 ) resize( 200,200 ); valor_global1 = 0; valor_global2 = 100; // cargaremos imágenes en memoria sin mostrarlas // cargaremos música de fondo en memoria sin reproducirla } destroy() Esta función miembro es llamada cuando el applet no se va a usar más. La clase Applet no hace nada en este método. Las clases derivadas deberían sobrecargarlo para hacer una limpieza final. Los applet multithread deberán usar destroy() para quot;matarquot; cuanquier thread del applet que quedase activo. 65
  • 66. start() Llamada para activar el applet. Esta función miembro es llamada cuando se visita el applet. La clase Applet no hace nada en este método. Las clases derivadas deberían sobrecargarlo para comenzar una animación, sonido, etc. public void start() { estaDetenido = false; // comenzar la reproducción de la música musicClip.play(); } También se puede utilizar start() para eliminar cualquier thread que se necesite. stop() Llamada para detener el applet. Se llama cuando el applet desaparece de la pantalla. La clase Applet no hace nada en este método. Las clases derivadas deberían sobrecargarlo para detener la animación, el sonido, etc. public void stop() { estaDetenido = true; if( /* ¿se está reproduciendo música? */ ) musicClip.stop(); } resize( int width,int height ) El método init() debería llamar a esta función miembro para establecer el tamaño del applet. Puede utilizar las variables ancho y alto, pero no es necesario. Cambiar el tamaño en otro sitio que no sea init() produce un reformateo de todo el documento y no se recomienda. En el navegador Netscape, el tamaño del applet es el que se indica en la marca APPLET del HTML, no hace caso a lo que se indique desde el código Java del applet. width Variable entera, su valor es el ancho definido en el parámetro WIDTH de la marca HTML del APPLET. Por defecto es el ancho del icono. height Variable entera, su valor es la altura definida en el parámetro HEIGHT de la marca HTML del APPLET. Por defecto es la altura del icono. Tanto width como height están siempre disponibles para que se puede chequear el tamaño del applet. Podemos retomar el ejemplo de init(): public void init() { if( width < 200 || height < 200 ) resize( 200,200 ); ... 66
  • 67. paint( Graphics g ) Se llama cada vez que se necesita refrescar el área de dibujo del applet. La clase Applet simplemente dibuja una caja con sombreado de tres dimensiones en el área. Obviamente, la clase derivada debería sobrecargar este método para representar algo inteligente en la pantalla. Para repintar toda la pantalla cuando llega un evento Paint, se pide el rectángulo sobre el que se va a aplicar paint() y si es más pequeño que el tamaño real del applet se invoca a repaint(), que como va a hacer un update(), se actualizará toda la pantalla. Podemos utilizar paint() para imprimir nuestro mensaje de bienvenida: void public paint( Graphics g ) { g.drawString( quot;Hola Java!quot;,25,25 ); // Dibujaremos la imágenes que necesitemos } update( Graphics g ) Esta es la función que se llama realmente cuando se necesita actualizar la pantalla. La clase Applet simplemente limpia el área y llama al método paint(). Esta funcionalidad es suficiente en la mayoría de los casos. De cualquier forma, las clases derivadas pueden sustituir esta funcionalidad para sus propósitos. Podemos, por ejemplo, utilizar update() para modificar selectivamente partes del área gráfica sin tener que pintar el área completa: public void update( Graphics g ) { if( estaActualizado ) { g.clear(); // garantiza la pantalla limpia repaint(); // podemos usar el método padre: super.update() } else // Información adicional g.drawString( quot;Otra informaciónquot;,25,50 ); } repaint() A esta función se la debería llamar cuando el applet necesite ser repintado. No debería sobrecargarse, sino dejar que Java repinte completamente el contenido del applet. Al llamar a repaint(), sin parámetros, internamente se llama a update() que borrará el rectángulo sobre el que se redibujará y luego se llama a paint(). Como a repaint() se le pueden pasar parámetros, se puede modificar el rectángulo a repintar. getParameter( String attr ) Este método carga los valores parados al applet vía la marca APPLET de HTML. El argumento String es el nombre del parámetro que se quiere obtener. Devuelve el valor que se le haya asignado al parámetro; en caso de que no se le haya asignado ninguno, devolverá null. 67
  • 68. Para usar getParameter(), se define una cadena genérica. Una vez que se ha capturado el parámetro, se utilizan métodos de cadena o de números para convertir el valor obtenido al tipo adecuado. public void init() { String pv; pv = getParameter( quot;velocidadquot; ); if( pv == null ) velocidad = 10; else velocidad = Integer.parseInt( pv ); } getDocumentBase() Indica la ruta http, o el directorio del disco, de donde se ha recogido la página HTML que contiene el applet, es decir, el lugar donde está la hoja en todo Internet o en el disco. getCodeBase() Indica la ruta http, o el directorio del disco, de donde se ha cargado el código bytecode que forma el applet, es decir, el lugar donde está el fichero .class en todo Internet o en el disco. print( Graphics g ) Para imprimir en impresora, al igual que paint() se puede utilizar print(), que pintará en la impresora el mapa de bits del dibujo. LA APLICACION FECHA (Aproximación a OOP) Veamos ahora una aplicación un poco más útil que HolaMundo, presentaremos en pantalla la fecha y hora del sistema. Aprovecharemos también para realizar un introducción muy sencilla a los conceptos fundamentales de la programación orientada a objetos, clases y objetos, a través de esta simple aplicación. import java.util.Date; class FechaApp { public static void main( String args[] ) { Date hoy = new Date(); System.out.println( hoy ); } } Esta aplicación es una versión modificada de HolaMundoApp de la que difiere porque se importa la clase Date, la aplicación se llama ahora FechaApp en vez de HolaMundoApp, se crea un objeto Date y el mensaje de salida a pantalla es diferente. Almacenaremos esta nueva aplicación en el fichero FechaApp.java. La línea de código: class FechaApp { 68
  • 69. es el inicio del bloque de la declaración de nuestra clase. Ya hemos dicho que todas las funciones y variables en Java, existen dentro de una clase o un objeto, Java no soporta funciones o variables globales. Por tanto, la declaración de la clase se convierte en el esqueleto de cualquier aplicación Java. La clase, el bloque básico de un lenguaje orientado a objetos como Java, es la plantilla que usamos para describir los datos y el entorno asociado a las instancias de esa clase. Cuando se instancia una clase, se crea un objeto del tipo definido por la clase y exactamente igual que cualquier otra instancia realizada de la misma clase. Los datos asociados a la clase u objeto son las variables y el entorno asociado con la clase u objeto son los métodos. Un ejemplo de clase es la clase que representa un rectángulo. Esta clase contiene las variables que indican las coordenadas del origen del rectángulo y su ancho y alto. La clase puede contener un método para calcular el área de ese rectángulo. Ahora podemos instanciarlo para muy diferentes propósitos, es decir, podemos tener objetos rectángulo específicos, así podremos obtener información de las dimensiones de nuestro dormitorio o de las dimensiones de la ventana en donde se está visualizando esta página. class NombreDeLaClase { . . . } Esta es la forma general de definición de una clase en Java, donde la palabra clave class inicia la definición de la clase NombreDeLaClase. Las variables y métodos de la clase han de ir colocados entre las llaves que delimitan el bloque de definición de la clase. FechaApp no tiene variables y solamente tiene un método llamado main(). Este método, main(), es el cerebro de cualquier aplicación Java. Cuando se ejecuta una aplicación Java utilizando el intérprete Java, se debe especificar el nombre de la clase que se desea ejecutar. El intérprete entonces, invoca al método main() definido dentro de esa clase, que debe controlar el flujo del programa, pedir al sistema los recursos que necesite y ejecutar cualquier otro método necesario para completar la funcionalidad de la aplicación. La definición del método main() debe estar precedida por tres modificadores: • public indica que el método main() puede ser llamado por cualquier objeto • static indica que el método main() es un método estático, es decir, un método propio de la clase • void indica que el método main() no devolverá ningún valor El método main() en Java es similar a la función main() de C y C++. Cuando se ejecuta un programa escrito en C o C++, arranca llamando en primer lugar a la función main(), que llamará a las demás funciones necesarias en la ejecución del programa. De forma similar, en el lenguaje Java, cuando se ejecuta una clase con el intérprete Java, el sistema comienza llamando al método main() de la clase, que llamará a los demás métodos necesarios para completar la ejecución de la aplicación. Si se intenta ejecutar una clase con el intérprete Java que no contenga el método main(), el intérprete generará un mensaje de error. 69
  • 70. El método main() acepta como argumento un array de Strings: public static void main( Strings args[] ) { Este array de Strings es el mecanismo a través del cual el sistema puede pasar información a la aplicación. Cada una de las cadenas String es un argumento de línea de comandos. Permiten pasar información a la aplicación, para variar su ejecución, sin necesidad de recompilarla. Por ejemplo, si desarrollamos una aplicación de ordenación, podríamos permitir al usuario seleccionar el método, ascendente o descendente, en la línea de comandos de ejecución de la aplicación. -descendente Nuestra aplicación FechaApp ignora los argumentos de la línea de comandos, así que no nos extendemos más, pero volveremos sobre ello más adelante. No obstante, los programadores de C y C++ deben tener en cuenta que en Java el número y tipo de argumentos de la línea de comandos es diferente a los que se pasan a la función main() en C y C++. La aplicación FechaApp es el programa más simple que podemos hacer que realice algo interesante, pero por su misma sencillez no necesita ninguna clase adicional. Sin embargo, la mayoría de los programas que escribamos serán más complejos y necesitarán que escribamos otras clases y utilizar las que nos proporciona Java como soporte. Nuestra aplicación FechaApp utiliza dos clases, la clase System y la clase Date, que nos proporciona el entorno de desarrollo de Java. La clase System proporciona un acceso al sistema independiente del hardware sobre el que estemos ejecutando la aplicación y la clase Date proporciona un acceso a las funciones de Fecha independientemente del sistema en que estemos ejecutando la aplicación. El depurador de Java (jdb) El depurador de Java, jdb es un depurador de línea de comandos, similar al que Sun proporciona en sus Sistemas, dbx. Es complicado de utilizar y un tanto críptico, por lo que, en principio, tiene escasa practicidad y es necesaria una verdadera emergencia para tener que recurrir a él. Trataremos por encima los comandos que proporciona el jdb, pero sin entrar en detalles de su funcionamiento, porque no merece la pena. Casi es mejor esperar a disponer de herramientas visuales para poder depurar con cierta comodidad nuestro código Java. Para poder utilizar el depurador, las aplicaciones Java deben estar compiladas con la opción de depuración activada, -g. Posteriormente se puede lanzar appletviewer con la opción de depuración, debug, y habremos puesto en marcha jdb. Depurar HolaMundo Hemos modificado nuestro applet de ejemplo para utilizarlo en nuestra sesión de ejemplo con el depurador. Se compilaría con el comando: %javac -g hm.java 70
  • 71. y el contenido de nuestro applet HolaMundo modificado y guardado en el fichero hm.java sería el siguiente: // // Applet HolaMundo de ejemplo, para depurar // import java.awt.Graphics; import java.applet.Applet; public class hm extends Applet { int i; public void paint( Graphics g ) { i = 10; g.drawString( quot;Hola Mundo!quot;,25,25 ); } } Una vez compilado, iniciamos la sesión lanzando el visor de applets de Sun con la opción de depuración, utilizando el comando: %appletviewer -debug hm.html El fichero hm.html contiene las líneas mínimas para poder activar el applet, estas líneas son las que reproducimos: <html> <applet code=hm.class width=100 height=100> </applet> </html> Se inicia pues la sesión con el depurador y vamos a ir reproduciendo lo que aparece en la pantalla a medida que vamos introduciendo comandos: %appletviewer -debug hm.html Loading jdb... 0xee301bf0:class(sun.applet.AppletViewer) > Comando help El comando help proporciona una lista de los comandos que están disponibles en la sesión de jdb. Esta lista es la que sigue, en donde hemos aprovechado la presencia de todos los comandos para comentar la acción que cada uno de ellos lleva a cabo. >help ** command list ** threads [threadgroup] -- lista threads thread <thread id> -- establece el thread por defecto suspend [thread id(s)] -- suspende threads (por defecto, todos) resume [thread id(s)] -- continúa threads (por defecto, todos) where [thread id]|all -- muestra la pila de un thread threadgroups -- lista los grupos de threads threadgroup <name> -- establece el grupo de thread actual print <id> [id(s)] -- imprime un objeto o campo dump <id> [id(s)] -- imprime toda la información del objeto 71
  • 72. locals -- imprime las variables locales de la pila actual classes -- lista las clases conocidas methods <class id> -- lista los métodos de una clase stop in <class id>.<method> -- fija un punto de ruptura en un método stop at <class id>:<line> -- establece un punto de ruptura en una línea up [n frames] -- ascender en la pila de threads down [n frames] -- descender en la pila de threads clear <class id>:<line> -- eliminar un punto de ruptura step -- ejecutar la línea actual cont -- continuar la ejecución desde el punto de ruptura catch <class id> -- parar por la excepción especificada ignore <class id> -- ignorar la excepción especificada list [line number] -- imprimir código fuente use [source file path] -- ver o cambiar la ruta del fichero fuente memory -- informe del uso de la memoria load <classname> - carga la clase Java a ser depurada run <args> - comienza la ejecución de la clase cargada !! - repite el último comando help (or ?) - lista los comandos exit (or quit) - salir del depurador > Comando threadgroups El comando threadgroups permite ver la lista de threads que se están ejecutando. Los grupos system y main deberían estar siempre corriendo. >threadgroups 1.(java.lang.ThreadGroup)0xee300068 system 2.(java.lang.ThreadGroup)0xee300a98 main> Comando threads El comando threads se utiliza para ver la lista completa de los threads que se están ejecutando actualmente. >threads Group system: 1.(java.lang.Thread)0xee300098 clock handler cond 2.(java.lang.Thread)0xee300558 Idle thread run 3.(java.lang.Thread)0xee3005d0 sync Garbage Collector cond 4.(java.lang.Thread)0xee300620 Finalizer thread cond 5.(java.lang.Thread)0xee300a20 Debugger agent run 6.(java.tools.debug.BreakpointHandler)0xee300b58) Breakpoint handler cond Group main: 7.(java.lang.Thread)0xee300048 main suspended > 72
  • 73. Comando run El comando run es el que se utiliza para arrancar el appletviewer en la sesión de depuración. Lo teclearemos y luego volveremos a listar los threads que hay en ejecución. >run run sun.applet.AppletViewer hm.html running... main[1]threads threads Group sun.applet.AppletViewer.main: 1.(java.lang.Thread)0xee3000c0 AWT-Motif running 2.(sun.awt.ScreenUpdater)0xee302ed0 ScreenUpdater cond. Waiting Group applet-hm.class: 3.(java.lang.Thread)0xee302f38 Thread-6 cond. Waiting main[1] El visor de applets de Sun aparecerá en la pantalla y mostrará el conocido mensaje de saludo al Mundo. Ahora vamos a rearrancar el appletviewer con un punto de ruptura, para detener la ejecución del applet, y podamos seguir mostrando los comandos disponibles en el jdb. main[1]exit %appletviewer -debug hm.html Loading jdb... 0xee3009c8:class(sun.applet.AppletViewer) >stop in hm.paint Breakpoint set in hm.paint >run run sun.applet.AppletViewer hm.html running... Breakpoint hit: hm.paint(hm.java:9) AWT-Motif[1] Comando where El comando where mostrará la pila de ejecución del applet. AWT-Motif[1]where [1]hm.paint(hm.java:9) [2]sun.awt.motif.MComponentPeer.paint(MComponenetPeer.java:109) [3]sun.awt.motif.MComponentPeer.handleExpose(MComponenetPeer.java:170) AWT-Motif[1] Comando use El comando use nos informa del camino donde jdb va a buscar los ficheros fuentes que contienen el código Java de las clases que se están depurando. Por defecto, utilizará el camino que se especifique en la variable de entorno CLASSPATH. AWT-Motif[1]use /usr/local/java/classes: AWT-Motif[1] Comando list El comando list mostrará el código fuente actual al comienzo del punto de ruptura que hayamos fijado. 73
  • 74. AWT-Motif[1]list 9 public void paint( Graphics g ) { 10 => i = 10; 11 g.drawString( quot;Hola Mundo!quot;,25,25 ) ; 12 } 13 } AWT-Motif[1] Comando dump El comando dump nos permitirá ahora ver el valor del objeto g pasado desde el appletviewer. AWT-Motif[1]dump g g = (sun.awt.motif.X11Graphics)0xee303df8 { int pData = 1342480 Color foreground = (java.awt.Color)0xee302378 Font font = (java.awt.Font)0xee302138 int originX = 0 int originY = 0 float scaleX = 1 float scaleY = 1 Image image = null } AWT-Motif[1] Comando step El comando step nos porporciona el método para ejecutar la línea actual, que estará siendo apuntada por el indicador si hemos utilizado el comando list. AWT-Motif[1]step Breakpoint hit: hm.paint(hm.java:11) AWT-Motif[1]list 9 public void paint( Graphics g ) { 10 i = 10; 11 => g.drawString( quot;Hola Mundo!quot;,25,25 ); 12 } 13 } AWT-Motif[1] 74
  • 75. En cualquier lenguaje orientado a objetos, las clases definen cualquier objeto que se pueda manipular. Java tiene muchas clases útiles, no solamente aquellas que se utilizan para gráficos y sonido, usadas en la construcción de applets mucho más complejos. LA CLASE Math La clase Math representa la librería matemática de Java. Las funciones que contiene son las de todos los lenguajes, parece que se han metido en una clase solamente a propósito de agrupación, por eso se encapsulan en Math, y lo mismo sucede con las demás clases que corresponden a objetos que tienen un tipo equivalente (Character, Float, etc.). El constructor de la clase es privado, por los que no se pueden crear instancias de la clase. Sin embargo, Math es public para que se pueda llamar desde cualquier sitio y static para que no haya que inicializarla. Funciones matemáticas Si se importa la clase, se tiene acceso al conjunto de funciones matemáticas estándar: Math.abs( x ) para int, long, float y double Math.sin( double ) Math.cos( double ) Math.tan( double ) Math.asin( double ) Math.acos( double ) Math.atan( double ) Math.atan2( double,double ) Math.exp( double ) Math.log( double ) Math.sqrt( double ) Math.ceil( double ) Math.floor( double ) Math.rint( double ) Math.pow( a,b ) Math.round( x ) para double y float Math.random() devuelve un double Math.max( a,b ) para int, long, float y double Math.min( a,b ) para int, long, float y double Math.E para la base exponencial Math.PI para PI He aquí un ejemplo, Mates.java, de uso de algunas funciones de la clase Math: class Mates { public static void main( String args[] ) { int x; double rand,y,z; float max; rand = Math.random(); x = Math.abs( -123 ); y = Math.round( 123.567 ); z = Math.pow( 2,4 ); max = Math.max( (float)1e10,(float)3e9 ); 75
  • 76. System.out.println( rand ); System.out.println( x ); System.out.println( y ); System.out.println( z ); System.out.println( max ); } LA CLASE Character Al trabajar con caracteres se necesitan muchas funciones de comprobación y traslación. Estas funciones están empleadas en la clase Character. De esta clase sí que se pueden crear instancias, al contrario que sucede con la clase Math. Declaraciones La primera sentencia creará una variable carácter y la segunda un objeto Character: char c; Character C; Comprobaciones booleanas Character.isLowerCase( c ) Character.isUpperCase( c ) Character.isDigit( c ) Character.isSpace( c ) En este caso, si tuviésemos un objeto Character C, no se podría hacer C.isLowerCase, porque no se ha hecho un new de Character. Estas funciones son estáticas y no conocen al objeto, por eso hay que crealo antes. Traslaciones de caracteres char c2 = Character.toLowerCase( c ); char c2 = Character.toUpperCase( c ); Traslaciones de carácter/dígito int i = Character.digit( c,base ); char c = Character.forDigit( i,base ); Métodos de la clase Character C = new Character( 'J' ); char c = C.charValue(); String s = C.toString(); LA CLASE Float Cada tipo numérico tiene su propia clase de objetos. Así el tipo float tiene el objeto Float. De la misma forma que con la clase Character, se han codificado muchas funciones útiles dentro de los métodos de la clase Float. 76
  • 77. Declaraciones La primera sentencia creará una variable float y la segunda un objeto Float: float f; Float F; Valores de Float Float.POSITIVE_INFINITY Float.NEGATIVE_INFINITY Float.NaN Float.MAX_VALUE Float.MIN_VALUE Conversiones de Clase/Cadena String s = Float.toString( f ); f = Float.valueOf( quot;3.14quot; ); Comprobaciones boolean b = Float.isNaN( f ); boolean b = Float.isInfinite( f ); La función isNaN() comprueba si f es un No-Número. Un ejemplo de no-número es raiz cuadrada de -2. Conversiones de Objetos Float F = new Float( Float.PI ); String s = F.toString(); int i = F.intValue(); long l = F.longValue(); float F = F.floatValue(); double d = F.doubleValue(); Otros Métodos int i = F.hashCode(); boolean b = F.equals( Object obj ); int i = Float.floatToIntBits( f ); float f = Float.intBitsToFloat( i ); LA CLASE Double Cada tipo numérico tiene su propia clase de objetos. Así el tipo double tiene el objeto Double. De la misma forma que con la clase Character, se han codificado muchas funciones útiles dentro de los métodos de la clase Double. Declaraciones La primera sentencia creará una variable double y la segunda un objeto Double: double d; Double D; 77
  • 78. Valores de Double Double.POSITIVE_INFINITY Double.NEGATIVE_INFINITY Double.NaN Double.MAX_VALUE Double.MIN_VALUE Métodos de Double D.isNaN(); Double.isNaN( d ); D.isInfinite(); Double.isInfinite( d ); boolean D.equals(); String D.toString(); int D.intValue(); long D.longValue(); float D.floatValue(); double D.doubleValue(); int i = D.hashCode(); Double V.valueOf( String s ); long l = Double.doubleToLongBits( d ); double d = Double.longBitsToDouble( l ); LA CLASE Integer Cada tipo numérico tiene su propia clase de objetos. Así el tipo int tiene el objeto Integer. De la misma forma que con la clase Character, se han codificado muchas funciones útiles dentro de los métodos de la clase Integer. Declaraciones La primera sentencia creará una variable int y la segunda un objeto Integer: int i; Integer I; Valores de Integer Integer.MIN_VALUE; Integer.MAX_VALUE; Métodos de Integer String Integer.toString( int i,int base ); String Integer.toString( int i ); int I.parseInt( String s,int base ); int I.parseInt( String s ); Integer Integer.valueOf( String s,int base ); Integer Integer.valueOf( String s ); int I.intValue(); long I.longValue(); float I.floatValue(); double I.doubleValue(); String I.toString(); int I.hashCode(); boolean I.equals( Object obj ); 78
  • 79. En los métodos toString(), parseInt() y valueOf() que no se especifica la base sobre la que se trabaja, se asume que es base 10. LA CLASE Long Cada tipo numérico tiene su propia clase de objetos. Así el tipo long tiene el objeto Long. De la misma forma que con la clase Character, se han codificado muchas funciones útiles dentro de los métodos de la clase Long. Declaraciones La primera sentencia creará una variable long y la segunda un objeto Long: long l; Long L; Valores de Long Long.MIN_VALUE; Long.MAX_VALUE; Métodos de Long String Long.toString( long l,int base ); String Long.toString( long l ); long L.parseLong( String s,int base ); long L.parseLong( String s ); Long Long.valueOf( String s,int base ); Long Long.valueOf( String s ); int L.intValue(); long L.longValue(); float L.floatValue(); double L.doubleValue(); String L.toString(); int L.hashCode(); boolean L.equals( Object obj ); En los métodos toString(), parseInt() y valueOf() que no se especifica la base sobre la que se trabaja, se asume que es base 10. LA CLASE Boolean Los valores boolean también tienen su tipo asociado Boolean, aunque en este caso hay menos métodos implementados que para el resto de las clases numéricas. Declaraciones La primera sentencia creará una variable boolean y la segunda un objeto Boolean: boolean b; Boolean B; Valores de Boolean Boolean.TRUE; Boolean.FALSE; 79
  • 80. Métodos de Boolean boolean B.booleanValue(); String B.toString(); boolean B.equals( Object obj ); LA CLASE String Java posee gran capacidad para el manejo de cadenas dentro de sus clases String y StringBuffer. Un objeto String representa una cadena alfanumérica de un valor constante que no puede ser cambiada después de haber sido creada. Un objeto StringBuffer representa una cadena cuyo tamaño puede variar. Los Strings son objetos constantes y por lo tanto muy baratos para el sistema. La mayoría de las funciones relacionadas con cadenas esperan valores String como argumentos y devuelven valores String. Hay que tener en cuenta que las funciones estáticas no consumen memoria del objeto, con lo cual es más conveniente usar Character que char. No obstante, char se usa, por ejemplo, para leer ficheros que están escritos desde otro lenguaje. Existen muchos constructores para crear nuevas cadenas: String(); String( String str ); String( char val[] ); String( char val[],int offset,int count ); String( byte val[],int hibyte ); String( byte val[],int hibyte,int offset,int count ); Tal como uno puede imaginarse, las cadenas pueden ser muy complejas, existiendo muchas funciones muy útiles para trabajar con ellas y, afortunadamente, la mayoría están codificadas en la clase String. Funciones Básicas La primera devuelve la longitud de la cadena y la segunda devuelve el carácter que se encuentra en la posición que se indica en indice: int length(); char charAt( int indice ); Funciones de Comparación de Strings boolean equals( Object obj ); boolean equalsIgnoreCase( Object obj ); Lo mismo que equals() pero no tiene en cuenta mayúsculas o minúsculas. int compareTo( String str2 ); Devuelve un entero menor que cero si la cadena es léxicamente menor que str2. Devuelve cero si las dos cadenas son léxicamente iguales y un entero mayor que cero si la cadena es léxicamente mayor que str2. 80
  • 81. Funciones de Comparación de Subcadenas boolean regionMatch( int thisoffset,String s2,int s2offset,int len ); boolean regionMatch( boolean ignoreCase,int thisoffset,String s2, int s2offset,int 1 ); Comprueba si una región de esta cadena es igual a una región de otra cadena. boolean startsWith( String prefix ); boolean startsWith( String prefix,int offset ); boolean endsWith( String suffix ); Devuelve si esta cadena comienza o termina con un cierto prefijo o sufijo comenzando en un determinado desplazamiento. int indexOf( int ch ); int indexOf( int ch,int fromindex ); int lastIndexOf( int ch ); int lastIndexOf( int ch,int fromindex ); int indexOf( String str ); int indexOf( String str,int fromindex ); int lastIndexOf( String str ); int lastIndexOf( String str,int fromindex ); Devuelve el primer/último índice de un carácter/cadena empezando la búsqueda a partir de un determinado desplazamiento. String substring( int beginindex ); String substring( int beginindex,int endindex ); String concat( String str ); String replace( char oldchar,char newchar ); String toLowerCase(); String toUpperCase(); String trim(); Ajusta los espacios en blanco al comienzo y al final de la cadena. void getChars( int srcBegin,int srcEnd,char dst[],int dstBegin ); void getBytes( int srcBegin,int srcEnd,byte dst[],int dstBegin ); String toString(); char toCharArray(); int hashCode(); Funciones ValueOf La clase String posee numerosas funciones para transformar valores de otros tipos de datos a su representación como cadena. Todas estas funciones tienen el nombre de valueOf, estando el método sobrecargado para todos los tipos de datos básicos. Veamos un ejemplo de su utilización: String Uno = new String( quot;Hola Mundoquot; ); float f = 3.141592; String PI = Uno.valueOf( f ); String PI = String.valueOf( f ); // Mucho más correcto 81
  • 82. Funciones de Conversión String valueOf( boolean b ); String valueOf( int i ); String valueOf( long l ); String valueOf( float f ); String valueOf( double d ); String valueOf( Object obj ); String valueOf( char data[] ); String valueOf( char data[],int offset,int count ); Usa arrays de caracteres para la cadena. String copyValueOf( char data[] ); String copyValueOf( char data[],int offset,int count ); Crea un nuevo array equivalente para la cadena. LA CLASE StringBuffer Java posee gran capacidad para el manejo de cadenas dentro de sus clases String y StringBuffer. Un objeto String representa una cadena alfanumérica de un valor constante que no puede ser cambiada después de haber sido creada. Un objeto StringBuffer representa una cadena cuyo tamaño puede variar. La clase StringBuffer dispone de muchos métodos para modificar el contenido de los objetos StringBuffer. Si el contenido de una cadena va a ser modificado en un programa, habrá que sacrificar el uso de objetos String en beneficio de StringBuffer, que aunque consumen más recursos del sistema, permiten ese tipo de manipulaciones. Al estar la mayoría de las características de los StringBuffers basadas en su tamaño variable, se necesita un nuevo método de creación: StringBuffer(); StringBuffer( int len ); StringBuffer( String str ); Se puede crear un StringBuffer vacío de cualquier longitud y también se puede utilizar un String como punto de partida para un StringBuffer. StringBuffer Dos = new StringBuffer( 20 ); StringBuffer Uno = new StringBuffer( quot;Hola Mundoquot; ); Cambio de Tamaño El cambio de tamaño de un StringBuffer necesita varias funciones específicas para manipular el tamaño de las cadenas: int length(); char charAt( int index ); void getChars( int srcBegin,int srcEnd,char dst[],int dstBegin ); String toString(); void setLength( int newlength ); 82
  • 83. void setCharAt( int index,char ch ); int capacity(); void ensureCapacity( int minimum ); void copyWhenShared(); Obervar que una de las funciones devuelve una cadena constante normal de tipo String. Este objeto se puede usar con cualquier función String, como por ejemplo, en las funciones de comparación. Modificación del Contenido Para cambiar el contenido de un StringBuffer, se pueden utilizar dos métodos: append() e insert(). En el ejemplo CadAppend.java, vemos el uso de estos dos métodos: class CadAppend { public static void main( String args[] ) { StringBuffer str = new StringBuffer( quot;Holaquot; ); str.append( quot; Mundoquot; ); System.out.println( str ); } } En este otro ejemplo, CadInversa.java, mostramos un método muy simple que le da la vuelta a una cadena: class CadInversa { public static String cadenaInversa( String fuente ) { int longitud = fuente.length(); StringBuffer destino = new StringBuffer( longitud ); for( int i=(longitud-1); i >= 0; i-- ) destino.append( fuente.charAt( i ) ); return( destino.toString() ); } public static void main( String args[] ) { System.out.println( cadenaInversa( quot;Hola Mundoquot; ) ); } } Las funciones que cambian el tamaño son pues: StringBuffer append( Object obj ); StringBuffer append( String str ); StringBuffer append( char str[] ); StringBuffer append( char str[],int offset,int len ); StringBuffer append( boolean b ); StringBuffer append( int i ); StringBuffer append( long l ); StringBuffer append( float f ); StringBuffer append( double d ); StringBuffer append( char ch ); StringBuffer insert( int offset,Object obj ); StringBuffer insert( int offset,String str ); StringBuffer insert( int offset,char str[] ); 83
  • 84. StringBuffer insert( int offset,boolean b ); StringBuffer insert( int offset,int i ); StringBuffer insert( int offset,long l ); StringBuffer insert( int offset,float f ); StringBuffer insert( int offset,double d ); StringBuffer insert( int offset,char ch ); Operadores de Concatenación Hay que recordar que los operadores quot;+quot; y quot;+=quot; también se pueden aplicar a cadenas. Ambos realizan una concatenación y están implementados con objetos StringBuffer. Por ejemplo, la sentencia: String s = quot;¿Quéquot; + quot; tal ?quot;; es interpretada por el compilador como: String s = new StringBuffer().append( quot;¿Quéquot; ).append( quot; tal ?quot; ).toString(); y se marcaría el StringBuffer para borrarlo ya que el contenido pasa al objeto String. También, la sentencia: s += quot; por ahí!quot;; sería interpretada por el sistema como: String s = new StringBuffer().append( s ).append( quot; por ahí!quot; ).toString(); y volvería a marcar para borrar el nuevo StringBuffer. USO DE CONVERSIONES Veamos un ejemplo de utilidad de estas funciones. En el applet Conversion.java, que se muestra en el código que sigue, se usan estas funciones para producir una salida útil en un programa, presentando las coordenadas en las que se ha hecho click con el botón del ratón. public class Conversion extends Applet { int RatonX = 25; int RatonY = 25; String Status = quot;Haz click con el ratónquot;; public void paint( Graphics g ) { g.drawString( Status,RatonX,RatonY ); } public boolean mouseDown( Event evt,int x,int y ) { Integer X = new Integer( x ); Integer Y = new Integer( y ); RatonX = x; RatonY = y; Status = X.toString()+quot;,quot;+Y.toString(); repaint(); return true; } } 84
  • 85. Introducción al AWT AWT es el acrónimo del X Window Toolkit para Java, donde X puede ser cualquier cosa: Abstract, Alternative, Awkward, Another o Asqueroso; aunque parece que Sun se decanta por Abstracto, seriedad por encima de todo. Se trata de una biblioteca de clases Java para el desarrollo de Interfaces de Usuario Gráficas. La versión del AWT que Sun proporciona con el JDK se desarrolló en sólo dos meses y es la parte más débil de todo lo que representa Java como lenguaje. El entorno que ofrece es demasiado simple, no se han tenido en cuenta las ideas de entornos gráficos novedosos, sino que se ha ahondado en estructuras orientadas a eventos, llenas de callbacks y sin soporte alguno del entorno para la construcción gráfica; veremos que la simple acción de colocar un dibujo sobre un botón se vuelve una tarea harto complicada. Quizá la presión de tener que lanzar algo al mercado haya tenido mucho que ver en la pobreza de AWT. JavaSoft, asegura que esto sólo era el principio y que AWT será multi-idioma, tendrá herramientas visuales, etc. En fin, al igual que dicen los astrólogos, el futuro nos deparará muchas sorpresas. La estructura básica del AWT se basa en Componentes y Contenedores. Estos últimos contienen Componentes posicionados a su respecto y son Componentes a su vez, de forma que los eventos pueden tratarse tanto en Contenedores como en Componentes, corriendo por cuenta del programador (todavía no hay herramientas de composición visual) el encaje de todas las piezas, así como la seguridad de tratamiento de los eventos adecuados. Nada trivial. No obstante y pese a ello, vamos a abordar en este momento la programación con el AWT para tener la base suficiente y poder seguir profundizando en las demás características del lenguaje Java, porque como vamos a ir presentando ejemplos gráficos es imprescindible el conocimiento del AWT. Mientras tanto, esperemos que JavaSoft sea fiel a sus predicciones y lo que ahora veamos nos sirva de base para migrar a un nuevo y maravilloso AWT. INTERFACE DE USUARIO La interface de usuario es la parte del programa que permite a éste interactuar con el usuario. Las interfaces de usuario pueden adoptar muchas formas, que van desde la simple línea de comandos hasta las interfaces gráficas que proporcionan las aplicaciones más modernas. La interface de usuario es el aspecto más importante de cualquier aplicación. Una aplicación sin un interfaz fácil, impide que los usuarios saquen el máximo rendimiento del programa. Java proporciona los elementos básicos para construir decentes interfaces de usuario a través del AWT. Al nivel más bajo, el sistema operativo transmite información desde el ratón y el teclado como dispositivos de entrada al programa. El AWT fue diseñado pensando en que el programador no tuviese que preocuparse de detalles como controlar el movimiento del ratón o leer el teclado, ni tampoco atender a detalles como la escritura en pantalla. El AWT 85
  • 86. constituye una librería de clases orientada a objeto para cubrir estos recursos y servicios de bajo nivel. Debido a que el lenguaje de programación Java es independiente de la plataforma en que se ejecuten sus aplicaciones, el AWT también es independiente de la plataforma en que se ejecute. El AWT proporciona un conjunto de herramientas para la construcción de interfaces gráficas que tienen una apariencia y se comportan de forma semejante en todas las plataformas en que se ejecute. Los elementos de interface proporcionados por el AWT están implementados utilizando toolkits nativos de las plataformas, preservando una apariencia semejante a todas las aplicaciones que se creen para esa plataforma. Este es un punto fuerte del AWT, pero también tiene la desventaja de que una interface gráfica diseñada para una plataforma, puede no visualizarse correctamente en otra diferente. ESTRUCTURA DEL AWT La estructura de la versión actual del AWT podemos resumirla en los puntos que exponemos a continuación: • Los Contenedores contienen Componentes, que son los controles básicos • No se usan posiciones fijas de los Componentes, sino que están situados a través de una disposición controlada (layouts) • El común denominador de más bajo nivel se acerca al teclado, ratón y manejo de eventos • Alto nivel de abstracción respecto al entorno de ventanas en que se ejecute la aplicación (no hay áreas cliente, ni llamadas a X, ni hWnds, etc.) • La arquitectura de la aplicación es dependiente del entorno de ventanas, en vez de tener un tamaño fijo • Es bastante dependiente de la máquina en que se ejecuta la aplicación (no puede asumir que un diálogo tendrá el mismo tamaño en cada máquina) • Carece de un formato de recursos. No se puede separar el código de lo que es propiamente interface. No hay ningún diseñador de interfaces (todavía) COMPONENTES Y CONTENEDORES Una interface gráfica está construida en base a elementos gráficos básicos, los Componentes. Típicos ejemplos de estos Componentes son los botones, barras de desplazamiento, etiquetas, listas, cajas de selección o campos de texto. Los Componentes permiten al usuario interactuar con la aplicación y proporcionar información desde el programa al usuario sobre el estado del programa. En el AWT, todos los Componentes de la interface de usuario son instancias de la clase Component o uno de sus subtipos. Los Componentes no se encuentran aislados, sino agrupados dentro de Contenedores. Los Contenedores contienen y organizan la situación de los Componentes; además, los 86
  • 87. Contenedores son en sí mismos Componentes y como tales pueden ser situados dentro de otros Contenedores. También contienen el código necesario para el control de eventos, cambiar la forma del cursor o modificar el icono de la aplicación. En el AWT, todos los Contenedores son instancias de la clase Container o uno de sus subtipos. En la imagen siguiente presentamos una interface de usuario muy simple, con la apariencia que presenta cuando se visualiza bajo Windows '95. Los Componentes deben circunscribirse dentro del Contenedor que los contiene. Esto hace que el anidamiento de Componentes (incluyendo Contenedores) en Contenedores crean árboles de elementos, comenzando con un Contenedor en la raiz del árbol y expandiéndolo en sus ramas. A continuación presentamos el árbol que representa la interface que corresponde con la aplicación gráfica generada anteriormente. En el árbol siguiente mostramos la relación que existe entre todas las clases que proporciona AWT para la creación de interfaces de usuario, presentando la jerarquía de Clases e Interfaces: Clases: • BorderLayout • CardLayout • CheckboxGroup 87
  • 88. • Color • Component o Button o Canvas o Checkbox o Choice o Container  Panel  Window  Dialog  Frame o Label o List o Scrollbar o TextComponent  TextArea  TextField o Dimension o Event o FileDialog o FlowLayout o Font o FontMetrics o Graphics o GridLayout o GridBagConstraints o GridBagLayout 88
  • 89. o Image o Insets o MediaTracker o MenuComponent  MenuBar  MenuItem  CheckboxMenuItem  Menu o Point o Polygon o Rectangle o Toolkit Interfaces: • LayoutManager • MenuContainer En la figura siguiente reproducimos la ventana generada por el código de la aplicación ComponentesAWT.java que muestra todos los Componentes que proporciona el AWT. Vamos a ver en detalle estos Componentes, pero aquí podemos observar ya la estética que presentan en su conjunto. La ventana es necesaria porque el programa incluye un menú, y los menús solamente pueden utilizarse en ventanas. El código contiene un método main() para poder ejecutarlo como una aplicación independiente. 89
  • 90. COMPONENTES Component es una clase abstracta que representa todo lo que tiene una posición, un tamaño, puede ser pintado en pantalla y puede recibir eventos. Los Objetos derivados de la clase Component que se incluyen en el Abstract Window Toolkit son los que aparecen a continuación: • Button • Canvas • Checkbox • Choice • Container o Panel o Window  Dialog  Frame • Label • List • Scrollbar • TextComponent o TextArea o TextField Vamos a ver un poco más en detalle los Componentes que nos proporciona el AWT para incorporar a la creación de la interface con el usuario. BOTONES Veremos ejemplos de cómo se añaden botones a un panel para la interacción del usuario con la aplicación, pero antes vamos a ver la creación de botones como objetos. Se pueden crear objetos Button con el operador new: Button boton; boton = new Button( quot;Botónquot;); 90
  • 91. La cadena utilizada en la creación del botón aparecerá en el botón cuando se visualice en pantalla. Esta cadena también se devolverá para utilizarla como identificación del botón cuando ocurra un evento. Eventos Button Cada vez que el usuario pulsa un botón, se produce un evento, de la misma forma que se produce un evento cuando se aprieta el botón del ratón. Los eventos de pulsación de un botón se pueden capturar sobrecargando el método action(): public boolean action( Event evt,Object obj ) { if( evt.target instanceof Button ) System.out.println( (String)obj ); else System.out.println( quot;Evento No-Buttonquot; ); } La distinción entre todos los botones existentes se puede hacer utilizando el objeto destino pasado por el objeto Event y comparándolo con los objetos botón que hemos dispuesto en nuestro interface: import java.awt.*; import java.applet.Applet; public class Botones extends Applet { Button b1,b2,b3; public void init() { b1 = new Button( quot;Botón B1quot; ); b2 = new Button( quot;Botón B2quot; ); b3 = new Button( quot;Botón B3quot; ); this.add( b1 ); this.add( b2 ); this.add( b3 ); } public boolean action( Event evt,Object obj ) { if( evt.target.equals( b1 ) ) System.out.println( quot;Se ha pulsado el boton B1quot; ); if( evt.target.equals( b2 ) ) System.out.println( quot;Se ha pulsado el boton B2quot; ); if( evt.target.equals( b3 ) ) System.out.println( quot;Se ha pulsado el boton B3quot; ); return true; } } En el applet anterior, Botones.java, observamos que se imprime el texto asociado al botón que hayamos pulsado. 91
  • 92. Botones de Pulsación Los botones presentados en el applet son los botones de pulsación estándar; no obstante, para variar la representación en pantalla y para conseguir una interfaz más limpia, AWT ofrece a los programadores otros tipos de botones. Botones de Lista Los botones de selección en una lista (Choice) permiten el rápido acceso a una lista de elementos. Por ejemplo, podríamos implementar una selección de colores y mantenerla en un botón Choice: import java.awt.*; import java.applet.Applet; public class BotonSeleccion extends Applet { Choice Selector; public void init() { Selector = new Choice(); Selector.addItem( quot;Rojoquot; ); Selector.addItem( quot;Verdequot; ); Selector.addItem( quot;Azulquot; ); add( Selector ); } public boolean action( Event evt,Object obj ) { if( evt.target instanceof Choice ) { String color = (String)obj; System.out.println( quot;El color elegido es el quot; + color ); } return true; } } En este ejemplo, BotonSeleccion.java, la cadena proporcionada al método addItem() será devuelta en el argumento Object de un evento Choice, por ello en el manejador del botón de selección, comprobamos en primer lugar que se trate efectivamente de un evento generado en un botón de tipo Choice. Botones de Marcación Los botones de comprobación (Checkbox) se utilizan frecuentemente como botones de estado. Proporcionan información del tipo Sí o No (true o false). El estado del botón se devuelve en el argumento Object de los eventos Checkbox; el argumento es de tipo booleano: verdadero (true) si la caja se ha seleccionado y falso (false) en otro caso. Tanto el nombre como el estado se devuelven en el argumento del evento, aunque se pueden obtener a través de los métodos getLabel() y getState() del objeto Checkbox. 92
  • 93. import java.awt.*; import java.applet.Applet; public class BotonComprobacion extends Applet { Checkbox Relleno; public void init() { Relleno = new Checkbox( quot;Rellenoquot;); add( Relleno ); } public boolean action( Event evt,Object obj ) { if( evt.target instanceof Checkbox ) System.out.println( quot;CheckBox: quot; + evt.arg.toString() ); return true; } } El sencillo ejemplo anterior, BotonComprobacion.java, muestra los cambios que se producen en el estado del botón cuando la caja está o no seleccionada. Botones de Selección Los botones de comprobación se pueden agrupar para formar una interfaz de botón de radio (CheckboxGroup), que son agrupaciones de botones Checkbox en las que siempre hay un único botón activo. import java.awt.*; import java.applet.Applet; public class BotonRadio extends Applet { CheckboxGroup Radio; public void init() { Radio = new CheckboxGroup(); add( new Checkbox( quot;Primeroquot;,Radio,true) ); add( new Checkbox( quot;Segundoquot;,Radio,false) ); add( new Checkbox( quot;Terceroquot;,Radio,false) ); } } En el ejemplo anterior, BotonRadio.java, observamos que siempre hay un botón activo entre los que conforman el interfaz de comprobación que se ha implementado. 93
  • 94. Botones Autocontenidos La naturaleza orientada a objetos de Java nos da la posibilidad de crear botones completamente autocontenidos. En este tipo de botón, se construye el manejador de eventos dentro de la propia clase extendida de botón. Se pueden añadir estos botones a la aplicación, sin tener que preocuparse de los eventos que pudieran generar. En el ejemplo siguiente, BotonAuto.java, creamos el botón que muestra la figura, un botón que genera el texto quot;Boton Aceptarquot; por la salida estándar: import java.awt.*; import java.applet.Applet; class BotonAceptar extends Button { public BotonAceptar() { setLabel( quot;Aceptarquot; ); } public boolean action( Event evt,Object obj ) { System.out.println( quot;Boton Aceptarquot; ); return true; } } public class BotonAuto extends Applet { BotonAceptar boton; public void init() { boton = new BotonAceptar(); add( boton ); } } Es de hacer notar que no hay un método action() en la clase applet BotonAuto, la clase BotonAceptar manejará sus eventos. Si se hubiesen colocado otros objetos en el applet, se podría haber usado un método action() para tratar los eventos de esos objetos. ETIQUETAS Las etiquetas (Label) proporcionan una forma de colocar texto estático en un panel, para mostrar información que no varía, normalmente, al usuario. 94
  • 95. El applet Etiqueta.java presenta dos textos en pantalla, tal como aparece en la figura siguiente: import java.awt.*; import java.applet.Applet; public class Etiqueta extends Applet { public void init() { Label etiq1 = new Label( quot;Hola Java!quot; ); Label etiq2 = new Label( quot;Otra Etiquetaquot; ); setLayout( new FlowLayout( FlowLayout.CENTER,10,10) ); add( etiq1 ); add( etiq2 ); } } LISTAS Las listas (List) aparecen en los interfaces de usuario para facilitar a los operadores la manipulación de muchos elementos. Se crean utilizando métodos similares a los de los botones Choice. La lista es visible todo el tiempo, utilizándose una barra de desplazamiento para visualizar los elementos que no caben en el área que aparece en la pantalla. El ejemplo siguiente, Lista.java, crea una lista que muestra cuatro líneas a la vez y no permite selección múltiple. import java.awt.*; import java.applet.Applet; public class Lista extends Applet { public void init() { List l = new List( 4,false ); 95
  • 96. l.addItem( quot;Mercurioquot; ); l.addItem( quot;Venusquot; ); l.addItem( quot;Tierraquot; ); l.addItem( quot;Martequot; ); l.addItem( quot;Jupiterquot; ); l.addItem( quot;Saturnoquot; ); l.addItem( quot;Neptunoquot; ); l.addItem( quot;Uranoquot; ); l.addItem( quot;Plutonquot; ); add( l ); } public boolean action( Event evt,Object obj ) { if( evt.target instanceof List ) System.out.println( quot;Entrada de la Lista: quot; + obj ); return true; } } Para acceder a los elementos seleccionados se utilizan los métodos getSelectedItem() o getSelectedItems(). Para listas de selección simple, cualquier selección con doble-click en la lista disparará el método action() de la misma forma que con los eventos de selección en menús. En el applet siguiente, ListaMult.java, se permite al usuario seleccionar varios elementos de los que constituyen la lista. En la figura se muestra la apariencia de una selección múltiple en este applet. import java.awt.*; import java.applet.Applet; public class ListaMult extends Applet { List lm = new List( 6,true ); public void init() { Button boton = new Button( quot;Aceptarquot; ); lm.addItem( quot;Mercurioquot; ); lm.addItem( quot;Venusquot; ); lm.addItem( quot;Tierraquot; ); lm.addItem( quot;Martequot; ); lm.addItem( quot;Jupiterquot; ); 96
  • 97. lm.addItem( quot;Saturnoquot; ); lm.addItem( quot;Neptunoquot; ); lm.addItem( quot;Uranoquot; ); lm.addItem( quot;Plutonquot; ); add( lm ); add( boton ); } public boolean action( Event evt,Object obj ) { if( evt.target instanceof Button ) { if( quot;Aceptarquot;.equals( obj ) ) { String seleccion[]; seleccion = lm.getSelectedItems(); for( int i=0; i < seleccion.length; i++ ) System.out.println( seleccion[i] ); } } return true; } } En este caso de la selección múltiple en una lista, utilizamos un evento externo para disparar las acciones asociadas a la lista. En el ejemplo, hemos incluido un botón para generar el evento que hace que el applet recoja los elementos que hay seleccionados en la lista. CAMPOS DE TEXTO Para la entrada directa de datos se suelen utilizar los campos de texto, que aparecen en pantalla como pequeñas cajas que permiten al usuario la entrada por teclado. Los campos de texto (TextField) se pueden crear vacíos, vacíos con una longitud determinada, rellenos con texto predefinido y rellenos con texto predefinido y una longitud determinada. El applet siguiente, CampoTexto.java, genera cuatro campos de texto con cada una de las características anteriores. La imagen muestra los distintos tipos de campos. import java.awt.*; import java.applet.Applet; 97
  • 98. public class CampoTexto extends Applet { TextField tf1,tf2,tf3,tf4; public void init() { // Campo de texto vacío tf1 = new TextField(); // Campo de texto vacío con 20 columnas tf2 = new TextField( 20 ); // Texto predefinido tf3 = new TextField( quot;Holaquot; ); // Texto predefinido en 30 columnas tf4 = new TextField( quot;Holaquot;,30 ); add( tf1 ); add( tf2 ); add( tf3 ); add( tf4 ); } public boolean action( Event evt,Object obj ) { if( evt.target instanceof TextField ) { if( evt.target.equals( tf1 ) ) System.out.println( quot;Campo de Texto 1: quot; + evt.arg.toString() ); if( evt.target.equals( tf1 ) ) System.out.println( quot;Campo de Texto 2: quot; + evt.arg.toString() ); if( evt.target.equals( tf1 ) ) System.out.println( quot;Campo de Texto 3: quot; + evt.arg.toString() ); if( evt.target.equals( tf1 ) ) System.out.println( quot;Campo de Texto 4: quot; + evt.arg.toString() ); } return true; } } Cuando el usuario teclea un retorno de carro en un campo de texto, se genera un evento TextField, que al igual que con los otros Componentes del AWT podemos capturar con el método action(), tal como se demuestra en el ejemplo. AREAS DE TEXTO Java, a través del AWT, permite incorporar texto multilínea dentro de zonas de texto (TextArea). Los objetos TextArea se utilizan para elementos de texto que ocupan más de una línea, como puede ser la presentación tanto de texto editable como de sólo lectura. Para crear una área de texto se pueden utilizar cuatro formas análogas a las que se han descrito en la creación de Campos de Texto. Pero además, para las áreas de texto hay que especificar el número de columnas. Se puede permitir que el usuario edite el texto con el método setEditable() de la misma forma que se hacía en el TextField. En la figura aparece la representación del applet 98
  • 99. AreaTexto.java, que presenta dos áreas de texto, una vacía y editable y otra con un texto predefinido y no editable. import java.awt.*; import java.applet.Applet; public class AreaTexto extends Applet { TextArea t1,t2; public void init() { Button boton = new Button( quot;Aceptarquot; ); t1 = new TextArea(); t2 = new TextArea( quot;Tutorial de Javaquot;,5,40 ); t2.setEditable( false ); add( t1 ); add( t2 ); add( boton ); } public boolean action( Event evt,Object obj ) { if( evt.target instanceof Button ) { if( quot;Aceptarquot;.equals( obj ) ) { String texto = t1.getText(); System.out.println( texto ); } } 99
  • 100. return true; } } Para acceder al texto actual de una zona de texto se utiliza el método getText(), tal como muestra el código anterior. Las áreas de texto no generan eventos por sí solas, por lo que hay que utilizar eventos externos, para saber cuando tenemos que acceder a la información contenida en el TextArea. En este caso hemos utilizado un botón que generará un evento al pulsarlo que hará que se recoja el texto que haya escrito en el área de texto que constituye el applet. CANVAS Si tenemos un applet que trabaja con imágenes directamente, ya sea un applet gráfico o de dibujo, los lienzos o zonas de dibujo (Canvas) resultan muy útiles. Los Canvas son un Componente básico que captura eventos de exposición (expose), de ratón y demás eventos relacionados. La clase base Canvas no responde a estos eventos, pero se puede extender esa clase base creando subclases en las que controlemos eseos eventos. Al permitir saltarse el manejo normal de eventos, y junto con los métodos de representación gráfica, los canvas simplifican la producción de applets que necesitan una única funcionalidad para distintas áreas. Por ejemplo, el applet Lienzo.java, contiene un manejador de eventos que controla el evento mouseDown en el canvas. Si el evento no se genera en el canvas, se le pasa al applet que lo tratará como un evento de ratón normal. import java.awt.*; import java.applet.Applet; public class Lienzo extends Applet { Button boton; public void init() { setLayout( new BorderLayout( 15,15 ) ); boton = new Button( quot;Testquot; ); MiCanvas canv = new MiCanvas( 100,100 ); add( quot;Centerquot;,canv ); add( quot;Southquot;,boton ); } public boolean action( Event evt,Object obj ) { System.out.println( quot;Evento: quot; + obj ); return true; } public boolean mouseDown( Event evt,int x, int y ) { System.out.println( quot;Raton: (quot;+x+quot;,quot;+y+quot;)quot; ); return true; } } 100
  • 101. class MiCanvas extends Canvas { private int ancho; private int alto; public MiCanvas( int anc,int alt ) { ancho = anc; alto = alt; reshape( 0,0,anc,alt ); } public void paint( Graphics g ) { g.setColor( Color.blue ); g.fillRect( 0,0,ancho,alto ); } public boolean mouseDown( Event evt,int x, int y ) { if( x < ancho && y < alto ) { System.out.println( quot;Raton en Canvas: (quot;+x+quot;,quot;+y+quot;)quot; ); return true; } return false; } } BARRAS DE DESPLAZAMIENTO En determinados applets que necesiten realizar el ajuste de valores lineales en pantalla, resulta útil el uso de barras de desplazamiento (Scrollbar). Las barras de desplazamiento proporcionan una forma de trabajar con rangos de valores o de áreas como el Componente TextArea, que proporciona dos barras de desplazamiento automáticamente. Si queremos implementar un selector de color, como en el applet Slider.java, podemos utilizar una barra de desplazamiento para cada uno de los colores primarios. import java.awt.*; import java.applet.Applet; public class Slider extends Applet { Scrollbar rojo,verde,azul; public void init() { rojo = new Scrollbar( Scrollbar.VERTICAL,0,1,0,255 ); verde = new Scrollbar( Scrollbar.VERTICAL,0,1,0,255 ); azul = new Scrollbar( Scrollbar.VERTICAL,0,1,0,255 ); add( rojo ); add( verde ); add( azul ); } } Este tipo de interfaz proporciona al usuario un punto de referencia visual de un rango y al mismo tiempo la forma de cambiar los valores. Por ello, las barras de desplazamiento son 101
  • 102. Componentes un poco más complejos que los demás, reflejándose esta complejidad en sus constructores. Al crearlos hay que indicar su orientación, su valor inicial, los valores mínimo y máximo que puede alcanzar y el porcentaje de rango que estará visible. También podríamos utilizar una barra de desplazamiento para un rango de valores de color, tal como se muestra en el ejemplo Ranger.java. import java.awt.*; import java.applet.Applet; public class Ranger extends Applet { Scrollbar rango; public void init() { rango = new Scrollbar( Scrollbar.HORIZONTAL,0,64,0,255 ); add( rango ); } } Como se puede ver, el ancho de la barra es mayor, en relación al Scrollbar. En este caso, maxValue representa el valor máximo para el lado izquierdo de la barra. Si se quieren representar 64 colores simultáneamente, es decir [0-63] a [192-255], maxValue debería ser 192. Igual que otros Componentes, las barras de desplazamiento generan eventos; pero al contrario que en el resto, se tiene que utilizar el método handleEvent() directamente, en lugar del método action(). El destino del evento será un objeto de la clase Scrollbar, a partir de éste se obtiene la posición de la barra de desplazamiento. Como se habrá podido observar en los applets anteriores, las barras de desplazamiento no disponen de un display o zona donde se muestren directamente los valores asociados a los desplazamientos. Al contrario, si se desea eso, es necesario añadir explícitamente una caja de texto, tal como se muestra en el ejemplo RangoRojo.java. import java.awt.*; import java.applet.Applet; public class RangoRojo extends Applet { Scrollbar rango; TextField valor; Label etiqueta; 102
  • 103. public void init() { rango = new Scrollbar( Scrollbar.HORIZONTAL,0,1,0,255 ); valor = new TextField( quot;0quot;,5 ); etiqueta = new Label( quot;Rojo (0-255)quot; ); setLayout( new GridLayout( 1,3 ) ); valor.setEditable( false ); add( etiqueta ); add( rango ); add( valor ); } public boolean handleEvent( Event evt ) { if( evt.target instanceof Scrollbar ) { valor.setText( Integer.toString( ((Scrollbar)evt.target).getValue() ) ); return true; } return super.handleEvent( evt ); } } Ese era el código del applet que construye la ventana de la figura y actualiza el campo de texto asociado. No implementa ninguna otra acción o evento. DISEÑO DE COMPONENTES PROPIOS También podemos atrevernos en el diseño de Componentes propios. Deberán ser una subclase de Canvas o Panel. Para mostrarlos en pantalla deberemos sobreescribir los métodos paint(), update(), minimumSize() y preferredSize() y para controlar los eventos tendremos que sobreescribir el método handleEvent(). Para que podamos reusarlos, tenemos que poner cuidado en el diseño, implementando métodos get y set, lanzando excepciones cuando proceda y permitiendo el acceso a los campos de que disponga nuestro Componente. Veamos un ejemplo, Separador.java, en que a partir de la clase Canvas, creamos un separador que será una línea vertical u horizontal simulando tres dimensiones. import java.awt.*; public class Separador extends Canvas { public final static int HORIZONTAL = 0; public final static int VERTICAL = 1; int orientacion; Dimension sepTama,sepDim; public Separador( int lon,int thick,int orient ) { orientacion = orient; if( orient == HORIZONTAL ) sepTama = new Dimension( lon,thick ); 103
  • 104. else sepTama = new Dimension( thick,lon ); } public int getOrientacion() { return orientacion; } public void setOrientacion( int orient) { if( orient > VERTICAL || orient < HORIZONTAL ) throw new IllegalArgumentException( quot;Orientación ilegalquot; ); if( orientacion != orient ) { orientacion = orient; sepDim = new Dimension( sepDim.height,sepDim.width ); invalidate(); } } public Dimension preferredSize() { return sepDim; } public Dimension minimumSize() { return sepDim; } public void paint( Graphics g ) { int x1,y1,x2,y2; Rectangle bbox = bounds(); Color c = getBackground(); Color brillo = c.brighter(); Color oscuro = c.darker(); if( orientacion == HORIZONTAL ) { x1 = 0; x2 = bbox.width - 1; y1 = y2 = bbox.height/2 - 1; } else { x1 = x2 = bbox.width/2 - 1; y1 = 0; y2 = bbox.height - 1; } g.setColor( oscuro ); g.drawLine( x1,y1,x2,y2 ); g.setColor( brillo ); if( orientacion == HORIZONTAL ) g.drawLine( x1,y1+1,x2,y2+1 ); else g.drawLine( x1+1,y1,x2+1,y2 ); } } 104
  • 105. El código que mostramos a continuación EjSeparador.java, muestra un ejemplo de uso de nuestro separador recién creado: import java.awt.*; import java.applet.Applet; public class EjSeparador extends Applet { public final static int HORIZONTAL = 0; public final static int VERTICAL = 1; public void init() { setLayout( new BorderLayout() ); TextField texto1 = new TextField( quot;Holaquot;,20 ); TextField texto2 = new TextField( quot;que talquot;,20 ); Separador raya = new Separador( 8,2,HORIZONTAL ); add( quot;Northquot;,texto1 ); add( quot;Centerquot;,raya ); add( quot;Southquot;,texto2 ); } } Y ahora podemos complicar nuestro Componente, o utilizarlo como base para el desarrollo de otros más complejos. Por ejemplo, vamos a implementar un Componente de Grupo, que extenderemos de la clase Panel y que la utilizaremos para enmarcar a otros Componentes, tal como se utiliza en otros entornos de ventanas. En el código fuente de la implementación del Componente, Grupo.java, podemos observar que las acciones seguidas son exactamente las mismas que en el caso anterior: sobreescribir los métodos que necesitamos y punto. import java.awt.*; public class Grupo extends Panel { String Rotulo; int altoTexto; int longTexto; int offset; static Font defFuente; FontMetrics metFuente; public Grupo( String titulo ) { altoTexto = 20; longTexto = 20; offset = 10; Rotulo = titulo; setLayout( null ); metFuente = getFontMetrics( defFuente ); } public void paint( Graphics g ) { Dimension d = size(); Font fuente = getFont(); if( fuente != null ) metFuente = getFontMetrics( fuente ); longTexto = metFuente.stringWidth( Rotulo ); altoTexto = metFuente.getHeight(); 105
  • 106. g.setColor( Color.gray ); g.drawRect( 0, altoTexto/2,d.width-3,d.height-altoTexto/2-3 ); g.setColor( Color.white ); g.drawRect( 1,altoTexto/2+1,d.width-3,d.height-altoTexto/2-3 ); g.setColor( getBackground() ); g.drawLine( offset,altoTexto/2,offset+longTexto+12,altoTexto/2 ); g.drawLine( offset,altoTexto/2+1,offset+longTexto+12,altoTexto/2+ 1 ); g.setColor( getForeground() ); g.drawString( Rotulo,offset+6,altoTexto-3 ); } public boolean handleEvent( Event evt ) { return( super.handleEvent( evt ) ); } public Dimension preferredSize() { return( minimumSize() ); } public Dimension minimumSize() { return( new Dimension( 100,100 ) ); } static { defFuente = new Font( quot;Dialogquot;,0,12 ); } } Un ejemplo de uso, lo podremos observar compilando y ejecutando el código que se puestra a continuación, EjGrupo.java: import java.awt.*; import java.applet.Applet public class EjGrupo extends Applet { Label etiq; Button izqda; Button dcha; Button todo; public void init() { setBackground( Color.lightGray ); setLayout( null ); Grupo g = new Grupo( quot;Etiquetaquot; ); add( g ); g.setFont( new Font(quot;Dialogquot;,0,14 ) ); g.reshape( insets().left + 10,insets().top + 20,290,40 ); g.setLayout( new FlowLayout( FlowLayout.CENTER,10,10 ) ); etiq = new Label( quot;Hola Java!quot; ); g.add( etiq ); Grupo g2 = new Grupo( quot;Botonesquot; ); add( g2 ); g2.reshape( insets().left+10,80,290,60 ); izqda = new Button( quot;Botn 1quot; ); 106
  • 107. g2.add( izqda ); izqda.reshape( 20,20,70,30 ); dcha = new Button( quot;Botn 2quot; ); g2.add( dcha ); dcha.reshape( 110,20,70,30 ); todo = new Button( quot;Botn 3quot; ); g2.add( todo ); todo.reshape( 200,20,70,30 ); } } CREACION DE APLICACIONES CON AWT Para crear una aplicación utilizando AWT, vamos a ver en principio cómo podemos generar el interface de esa aplicación, mostrando los distintos elementos del AWT, posteriormente volveremos hacia la implementación de la aplicación. Interface • Crear el Marco de la aplicación (Frame) • Inicializar Fuentes, Colores, Layouts y demás recursos • Crear menús y Barras de Menús • Crear los controles, diálogos, ventanas, etc. Implementación • Incorporar controladores de eventos • Incorporar funcionalidad (threads, red, etc.) • Incorporar un controlador de errores (excepciones) CREAR EL MARCO DE LA APLICACION El Contenedor de los Componentes es el Frame. También es la ventana principal de la aplicación, lo que hace que para cambiar el icono o el cursor de la aplicación no sea necesario crear métodos nativos; al ser la ventana un Frame, ya contiene el entorno básico para la funcionalidad de la ventana principal. Vamos a empezar a crear una aplicación básica, a la que iremos incorporando Componentes. Quizás vayamos un poco de prisa en las explicaciones que siguen; no preocuparse, ya que lo que no quede claro ahora, lo estará más tarde. El problema es que para poder profundizar sobre algunos aspectos de Java, necesitamos conocer otros previos, así que proporcionaremos un ligero conocimiento sobre algunas características de Java y del AWT, para que nos permitan entrar a fondo en otras; y ya conociendo estas últimas, volveremos sobre las primeras. Un poco lioso, pero imprescindible. 107
  • 108. En el archivo AplicacionAWT.java, se encuentra el código completo de la aplicación que vamos ir construyendo a lo largo de este repaso general por las características de que dispone el AWT. Comenzaremos el desarrollo de nuestra aplicación básica con AWT a partir del código que mostramos a continuación: import java.awt.*; public class AplicacionAWT extends Frame { static final int HOR_TAMANO = 300; static final int VER_TAMANO = 200; public AplicacionAWT() { super( quot;Aplicación Java con AWTquot; ); pack(); resize( HOR_TAMANO,VER_TAMANO ); show(); } public static void main( String args[] ) { new AplicacionAWT(); } } La clase anterior es un Frame, ya que extiende esa clase y hereda todas sus características. Tiene un método, el constructor, que no admite parámetros. Además, se hace una llamada explícita al constructor super, es decir, al constructor de la clase padre, para pasarle como parámetro la cadena que figurará como el título de la ventana. La llamada a show() es necesaria, ya que por defecto, los Contenedores del AWT se crean ocultos y hay que mostrarlos explícitamente. La llamada a pack() hace que los Componentes se ajusten a sus tamaños correctos en función del Contenedor en que se encuentren situados. La ejecución de la aplicación mostrará la siguiente ventana en pantalla: 108
  • 109. Los atributos fundamentales de la ventana anterior son: • Marco de 300x200 pixels • No tiene barra de menú • No tiene ningún Componente • Título quot;Aplicación Java con AWTquot; • Color de fondo por defecto • Layout por defecto • Fondo de la ventana vacío INICIALIZAR FUENTES, COLORES Y RECURSOS Vamos a ir alterando los recursos de la ventana de la aplicación Java que estamos desarrollando con el AWT, para ir incorporando y visualizando los distintos Componentes que proporciona AWT. Insertemos algunas líneas de código en el constructor para inicializar la aplicación: • Cambiemos el font de caracteres a Times Roman de 12 puntos setFont( new Font( quot;TimesRomanquot;,Font.PLAIN,12 ) ); • Fijemos los colores de la ventana para que el fondo sea Blanco y el texto resalte en Negro setBackground( Color.white ); setForeground( Color.black ); • Seleccionemos como disposición de los Componentes el BorderLayout para este Contenedor setLayout( new BorderLayout() ); • Incorporemos gráficos. Usamos métodos definidos en la clase Graphics; por ejemplo, reproduzcamos el título de la ventana en medio con una fuente Time Roman de 24 puntos en color Azul. Es necesario utilizar new con Font ya que en Java, todo son objetos y no podríamos utilizar un nuevo font de caracteres sin antes haberlo creado public void paint( Graphics g ) { g.setFont( new Font( quot;TimesRomanquot;,Font.BOLD,24 ) ); g.setColor( Color.blue ); g.drawString( getTitle(),30,50 ); } • Incorporemos en la parte inferior de la ventana dos botones: Aceptar y Cancelar Panel p = new Panel(); p.add( new Button( quot;Aceptarquot; ) ); p.add( new Button( quot;Cancelarquot; ) ); add( quot;Southquot;,p ); 109
  • 110. Los Componentes se incorporan al Contenedor a través de los dos métodos add() que hay definidos: add( Component c ); add( String s,Component c ); Los Componentes también se podían haber insertado en el Frame, organizándolos en una cierta forma, teniendo en cuenta que su manejador de composición es un BorderLayout. Por ejemplo: add( quot;Southquot;,new Button( quot;Aceptar ) ); add( quot;Southquot;,new Button( quot;Cancelarquot; ) ); Hemos utilizado un Panel y no el segundo método, porque es más útil el organizar los Componentes en pequeñas secciones. Así, con nuestro código podemos considerar al Panel como una entidad separada del Frame, lo cual permitiría cambiar el fondo, layout, fuente, etc. del Panel sin necesidad de tocar el Frame. Si ejecutamos de nuevo la aplicación con los cambios que hemos introducido, aparecerá ante nosotros la ventana que se muestra a continuación. Si intentásemos en esta aplicación cerrar la ventana, no sucede nada. Cuando se intenta cerrar la ventana, el sistema envía un evento que no se está tratando. Incorporemos pues un controlador de eventos y empecemos tratando el evento WINDOW_DESTROY, generado cuando se intenta cerrar la ventana: public boolean handleEvent( Event evt ) { switch( evt.id ) { case Event.WINDOW_DESTROY: { System.exit( 0 ); return true; } default: return false; } } Si ahora ejecutamos de nuevo la aplicación y cerramos la ventana... Efectivamente se cierra, tal como se suponía. 110
  • 111. CREAR MENUS Y BARRAS DE MENUS En la actual versión del AWT que se proporciona con el JDK, sólo se permite crear menús a través de código, ya que Java todavía no dispone de un formato de recursos y tampoco hay un diseñador como pueden ser AppStudio, Delphi o X-Designer; aunque terminará habiendo uno, con seguridad. No hay ningún método para diseñar una buena interface, todo depende del programador. Los menús son el centro de la aplicación. La diferencia entre una aplicación útil y otra que es totalmente frustrante radica en la organización de los menús, pero eso, las reglas del diseño de un buen árbol de menús, no están claras. Hay un montón de libros acerca de la ergonomía y de cómo se debe implementar la interacción con el usuario. Lo cierto es que por cada uno que defienda una idea, seguro que hay otro que defiende la contraria. Todavía no hay un acuerdo para crear un estándar, con cada Window Manager se publica una guía de estilo diferente. Así que, vamos a explicar lo básico, sin que se deba tomar como dogma de fe, para que luego cada uno haga lo que mejor le parezca. La interface MenuContainer solamente se puede implementar sobre un Frame. Un applet que desee tener un menú, debe crear un Frame en primer lugar. El código de la función que vamos a ver, crea una barra de menús y se llama desde el constructor del Frame. La función es private porque no queremos que se pueda llamar desde ninguna otra clase. private void InicializaMenus() { mbarra = new MenuBar(); Menu m = new Menu( quot;Archivoquot; ); m.add( new MenuItem( quot;Nuevoquot;) ); m.add( new MenuItem( quot;Abrirquot;) ); m.add( new MenuItem( quot;Guardarquot;) ); m.add( new MenuItem( quot;Guardar comoquot;) ); m.add( new MenuItem( quot;Imprimirquot;) ); m.addSeparator(); m.add( new MenuItem( quot;Salirquot;) ); mbarra.add( m ); m = new Menu( quot;Ayudaquot; ); m.add( new MenuItem( quot;Ayuda!quot; ) ); m.addSeparator(); m.add( new MenuItem( quot;Acerca de...quot; ) ); mbarra.add( m ); setMenuBar( mbarra ); } 111
  • 112. El menú que crea esta función tendrá la apariencia que muestra la figura siguiente: Los eventos generados por las opciones de un menú se manejan del mismo modo que los Botones, Listas, etc. En el caso de menús, es el evento ACTION_EVENT de la clase java.awt.MenuItem el que se genera y en evt.target se nos indica la opción seleccionada. case Event.ACTION_EVENT: { if( evt.target instanceof MenuItem ) { if( quot;Nuevoquot;.equals( evt.arg ) ) AplicacionAWT aAwt = new AplicacionAWT();; if( quot;Abrirquot;.equals( evt.arg ) ) System.out.println( quot;Opcion -Abrir-quot; ); if( quot;Guardarquot;.equals( evt.arg ) ) System.out.println( quot;Opcion -Guardar-quot; ); if( quot;Guardar comoquot;.equals( evt.arg ) ) System.out.println( quot;Opcion -Guardar como-quot; ); if( quot;Imprimirquot;.equals( evt.arg ) ) System.out.println( quot;Opcion -Imprimir-quot; ); if( quot;Salirquot;.equals( evt.arg ) ) System.exit( 0 ); if( quot;Ayuda!quot;.equals( evt.arg ) ) System.out.println( quot;No hay ayudaquot; ); if( quot;Acerca dequot;.equals( evt.arg ) ) System.out.println( quot;Opcion -Acerca de-quot; ); } } En el código anterior hemos tratado los eventos del menú. Para más seguridad, aunque no sea estrictamente necesario, lo primero que hacemos es asegurarnos de que el objeto evt.target es realmente un objeto MenuItem, es decir, procede de la barra de menús; y después comprobamos la opción que se ha seleccionado. Como todo, también se puede rizar el rizo y conseguir reproducir los sistemas de menús que estamos acostumbrados a ver en las aplicaciones que manejamos habitualmente. Un ejemplo de ello son los menús en cascada, semejantes al que muestra la figura y que ha sido generado mediante la aplicación Cascada.java. 112
  • 113. Básicamente se utiliza la técnica ya descrita, pero en vez de crear un nuevo MenuItem se crea un nuevo Menu, lo que origina el menú en cascada. No obstante, y volviendo al diseño de interfaces, no debe abusarse de este tipo de menús, porque pueden crear mucha más confusión al usuario. Siempre se debe tener en mente que los usuarios tienen que navegar habitualmente por una gran cantidad de menús en las más diversas aplicaciones, por lo que no debemos esconderles demasiado las opciones que les pueden interesar. DIALOGOS Y VENTANAS Una Ventana genérica, Window, puede utilizarse simplemente para que sea la clase padre de otras clases y se puede intercambiar por un Diálogo, Dialog, sin pérdida de funcionalidad. No se puede decir lo mismo de un Frame. Se podría crear un menú pop-up con una Ventana, pero lo cierto es que en esta versión del JDK hay un montón de bugs y no merece la pena el enfrascarse en el intento. No obstante, hay ciertos métodos que están en la clase Window y que no están presentes en otras clases que pueden resultar interesantes y necesitar una Ventana si queremos emplearlos. Son: • getToolkit() • getWarningString() • pack() • toBack() • toFront() Un Diálogo es una subclase de Window, que puede tener un borde y ser modal, es decir, no permite hacer nada al usuario hasta que responda al diálogo. Esto es lo que se usa en las cajas de diálogo quot;Acerca de...quot;, en la selección en listas, cuando se pide una entrada numérica, etc. El código Java que se expone a continuación, implementa el diálogo Acerca de para la aplicación. Esta clase se crea oculta y necesitaremos llamar al método show() de la propia clase para hacerla visible. 113
  • 114. class AboutDialog extends Dialog { static int HOR_TAMANO = 300; static int VER_TAMANO = 150; public AboutDialog( Frame parent ) { super( parent,quot;Acerca de...quot;,true ); this.setResizable( false ); setBackground( Color.gray ); setLayout( new BorderLayout() ); Panel p = new Panel(); p.add( new Button( quot;Aceptarquot; ) ); add( quot;Southquot;,p ); resize( HOR_TAMANO,VER_TAMANO ); } public void paint( Graphics g ) { g.setColor( Color.white ); g.drawString( quot;Aplicación Java con AWTquot;, HOR_TAMANO/4,VER_TAMANO/3 ); g.drawString( quot;Versión 1.00quot;, HOR_TAMANO/3+15,VER_TAMANO/3+20 ); } public boolean handleEvent( Event evt ) { switch( evt.id ) { case Event.ACTION_EVENT: { if( quot;Aceptarquot;.equals( evt.arg ) ) { hide(); return true; } } default: return false; } } } La ventana que aparece en pantalla generada por la clase anterior es la que muestra la figura: Las aplicaciones independientes deberían heredar tomando como padre la ventana principal de esa aplicación. Así pueden implementar la interface MenuContainer y proporcionar menús. 114
  • 115. No hay razón aparente para que sea una subclase de la clase Frame, pero si se quiere proporcionar funcionalidad extra, sí debería serlo, en vez de serlo de su padre: Window. Esto es así porque Frame implementa la interface MenuContainer, con lo cual tiene la posibilidad de proporcionar menús y cambiar el cursor, el icono de la aplicación, etc. Un ejemplo más complicado de aplicación gráfica basada en el AWT es el convertidor de decimal a binario/octal/hexadecimal/base36, Convertidor.java, cuya presentación en pantalla es la que muestra la figura siguiente. En la construcción de esta nueva aplicación se utilizan elementos que se presentan en profundidad en secciones posteriores de este Tutorial. PANELES La clase Panel es el más simple de los Contenedores de Componentes gráficos. En realidad, se trataba de crear una clase no-abstracta (Container sí lo es) que sirviera de base a los applet y a otras pequeñas aplicaciones. La clase Panel consta de dos métodos propios: el constructor, cuyo fin es crear un nuevo Panel con un LayoutManager de tipo FlowLayout (el de defecto), y el método addNotify() que, sobrecargando la función del mismo nombre en la clase Container, llama al método createPanel() del Toolkit adecuado, creando así un PanelPeer. El AWT enviará así al Panel (y por tanto al applet) todos los eventos que sobre él ocurran. Esto que puede parecer un poco rebuscado, obedece al esquema arquitectónico del AWT; se trata del bien conocido esquema de separación interface/implementación que establece por un lado una clase de interface y por otro distintas clases de implementación para cada una de las plataformas elegidas. El uso de Paneles permite que las aplicaciones puedan utilizar múltiples layouts, es decir, que la disposición de los componentes sobre la ventana de visualización pueda modificarse con mucha flexibilidad. Permite que cada Contenedor pueda tener su propio esquema de fuentes de caracteres, color de fondo, zona de diálogo, etc. Podemos, por ejemplo, crear una barra de herramientas para la zona superior de la ventana de la aplicación o incorporarle una zona de estado en la zona inferior de la ventana para mostrar información útil al usuario. Para ello vamos a implementar dos Paneles: class BarraHerram extends Panel { public BarraHerram() { setLayout( new FlowLayout() ); add( new Button( quot;Abrirquot; ) ); add( new Button( quot;Guardarquot; ) ); add( new Button( quot;Cerrarquot; ) ); 115
  • 116. Choice c = new Choice(); c.addItem( quot;Times Romanquot; ); c.addItem( quot;Helveticaquot; ); c.addItem( quot;Systemquot; ); add( c ); add( new Button( quot;Ayudaquot; ) ); } } class BarraEstado extends Panel { Label texto; Label mas_texto; public BarraEstado() { setLayout( new FlowLayout() ); add( texto = new Label( quot;Creada la barra de estadoquot; ) ); add( mas_texto = new Label( quot;Información adicionalquot; ) ); } public void verEstado( String informacion ) { texto.setText( informacion ); } } Ahora, para dar funcionalidad, debemos crear los objetos correspondientes a la barra de herramientas y a la barra de estado con new; al contrario que en C++, en Java todos los objetos deben ser creados con el operador new: add( quot;Northquot;,tb = new ToolBar() ); add( quot;Southquot;,sb = new StatusBar() ); También vamos a incorporar un nuevo evento a nuestro controlador, para que maneje los eventos de tipo ACTION_EVENT que le llegarán cuando se pulsen los botones de la barra de herramientas o se realice alguna selección, etc. case Event.ACTION_EVENT: { be.verEstado( evt.arg.toString() ); return true; } Cuando la aplicación reciba este tipo de evento, alterará el contenido de la barra de estado para mostrar la información de la selección realizada o el botón pulsado. 116
  • 117. Al final, la apariencia de la aplicación en pantalla es la que presenta la figura anterior. LAYOUTS Los layout managers o manejadores de composición, en traducción literal, ayudan a adaptar los diversos Componentes que se desean incorporar a un Panel, es decir, especifican la apariencia que tendrán los Componentes a la hora de colocarlos sobre un Contenedor. Java dispone de varios, en la actual versión, tal como se muestra en la imagen: ¿Por qué Java proporciona estos esquemas predefinidos de disposición de componentes? La razón es simple: imaginemos que deseamos agrupar objetos de distinto tamaño en celdas de una rejilla virtual: si confiados en nuestro conocimiento de un sistema gráfico determinado, codificamos a mano tal disposición, deberemos preveer el redimensionamiento del applet, su repintado cuando sea cubierto por otra ventana, etc., además de todas las cuestiones relacionadas con un posible cambio de plataforma (uno nunca sabe a donde van a ir a parar los propios hijos, o los applets). Sigamos imaginando, ahora, que un hábil equipo de desarrollo ha previsto las disposiciones gráficas más usadas y ha creado un gestor para cada una de tales configuraciones, que se ocupará, de forma transparente para nosotros, de todas esas cuitas de formatos. Bien, pues estos gestores son instancias de las distintas clases derivadas de Layout Manager y que se utilizan en el applet que genera la figura siguiente, donde se muestran los diferentes tipos de layouts que proporciona el AWT. En el applet que genera la figura siguiente, se utilizan los diferentes tipos de layouts que proporciona el AWT. 117
  • 118. El ejemplo AwtGui.java, ilustra el uso de paneles, listas, barras de desplazamiento, botones, selectores, campos de texto, áreas de texto y varios tipos de layouts. En el tratamiento de los Layouts se utiliza un método de validación, de forma que los Componentes son marcados como no válidos cuando un cambio de estado afecta a la geometría o cuando el Contenedor tiene un hijo incorporado o eliminado. La validación se realiza automáticamente cuando se llama a pack() o show(). Los Componentes visibles marcados como no válidos no se validan automáticamente. En el ejemplo de control de eventos que se muestra a continuación, la llamada a validate() hace que se realicen en un bloque, en un solo paso, todos los cálculos necesarios para la validación del layout. public boolean action( Event evt,Object obj ) { if( obj.equals( quot;Cambia Fontquot; ) ) { boton1.setFont( nuevoFont ); boton2.setFont( nuevoFont ); etiqueta.setFont( nuevoFont ); campoTexto.setFont( nuevoFont ); validate(); return true; } } FlowLayout Es el más simple y el que se utiliza por defecto en todos los Paneles si no se fuerza el uso de alguno de los otros. Los Componentes añadidos a un Panel con FlowLayout se encadenan en forma de lista. La cadena es horizontal, de izquierda a derecha, y se puede seleccionar el espaciado entre cada Componente. Por ejemplo, podemos poner un grupo de botones con la composición por defecto que proporciona FlowLayout: 118
  • 119. import java.awt.*; import java.applet.Applet; public class AwtFlow extends Applet { Button boton1,boton2,boton3; public void init() { boton1 = new Button( quot;Aceptarquot; ); boton2 = new Button( quot;Abrirquot; ); boton3 = new Button( quot;Cerrarquot; ); add( boton1 ); add( boton2 ); add( boton3 ); } } Este código, AwtFlow.java, construye tres botones con un pequeño espacio de separación entre ellos. BorderLayout La composición BorderLayout (de borde) proporciona un esquema más complejo de colocación de los Componentes en un panel. La composición utiliza cinco zonas para colocar los Componentes sobre ellas: Norte, Sur, Este, Oeste y Centro. Es el layout o composición que se utilizan por defecto Frame y Dialog. El Norte ocupa la parte superior del panel, el Este ocupa el lado derecho, Sur la zona inferior y Oeste el lado izquierdo. Centro representa el resto que queda, una vez que se hayan rellenado las otras cuatro partes. Con BorderLayout se podrían representar botones de dirección: 119
  • 120. import java.awt.*; import java.applet.Applet; public class AwtBord extends Applet { Button botonN,botonS,botonE,botonO,botonC; public void init() { setLayout( new BorderLayout() ); botonN = new Button( quot;Nortequot; ); botonS = new Button( quot;Surquot; ); botonE = new Button( quot;Estequot; ); botonO = new Button( quot;Oestequot; ); botonC = new Button( quot;Centroquot; ); add( quot;Northquot;,botonN ); add( quot;Southquot;,botonS ); add( quot;Eastquot;,botonE ); add( quot;Westquot;,botonO ); add( quot;Centerquot;,botonC ); } } Este es el código, AwtBord.java, que genera el applet de botones de dirección: GridLayout La composición GridLayout proporciona gran flexibilidad para situar Componentes. El layout se crea con un número de filas y columnas y los Componentes van dentro de las celdas de la tabla así definida. En la figura siguiente se muestra un panel que usa este tipo de composición para posicionar seis botones en su interior, con tres filas y dos columnas que crearán las seis celdas necesarias para albergar los botones: import java.awt.*; import java.applet.Applet; public class AwtGrid extends Applet { Button boton1,boton2,boton3,boton4,boton5,boton6; public void init() { 120
  • 121. setLayout( new GridLayout( 3,2 ) ); boton1 = new Button( quot;1quot; ); boton2 = new Button( quot;2quot; ); boton3 = new Button( quot;3quot; ); boton4 = new Button( quot;4quot; ); boton5 = new Button( quot;5quot; ); boton6 = new Button( quot;6quot; ); add( boton1 ); add( boton2 ); add( boton3 ); add( boton4 ); add( boton5 ); add( boton6 ); } } Este es el código, AwtGrid.java, que genera la imagen del ejemplo. GridBagLayout Es igual que la composición de GridLayout, con la diferencia que los Componentes no necesitan tener el mismo tamaño. Es quizá el layout más sofisticado y versátil de los que actualmente soporta AWT. En la figura siguiente vemos la imagen generada por un panel que usa el GridBagLayout para soportar diez botones en su interior: import java.awt.*; import java.applet.Applet; public class AwtGBag extends Applet { public void init() { GridBagLayout gridbag = new GridBagLayout(); GridBagConstraints gbc = new GridBagConstraints(); setLayout( gridbag ); 121
  • 122. gbc.fill = GridBagConstraints.BOTH; gbc.weightx = 1.0; Button boton0 = new Button( quot;Botón 0quot; ); gridbag.setConstraints( boton0,gbc ); add( boton0 ); Button boton1 = new Button( quot;Botón 1quot; ); gridbag.setConstraints( boton1,gbc ); add( boton1 ); Button boton2 = new Button( quot;Botón 2quot; ); gridbag.setConstraints( boton2,gbc ); add( boton2 ); gbc.gridwidth = GridBagConstraints.REMAINDER; Button boton3 = new Button( quot;Botón 3quot; ); gridbag.setConstraints( boton3,gbc ); add( boton3 ); gbc.weightx = 0.0; Button boton4 = new Button( quot;Botón 4quot; ); gridbag.setConstraints( boton4,gbc ); add( boton4 ); gbc.gridwidth = GridBagConstraints.RELATIVE; Button boton5 = new Button( quot;Botón 5quot; ); gridbag.setConstraints( boton5,gbc ); add( boton5 ); gbc.gridwidth = GridBagConstraints.REMAINDER; Button boton6 = new Button( quot;Botón 6quot; ); gridbag.setConstraints( boton6,gbc ); add( boton6 ); gbc.gridwidth = 1; gbc.gridheight = 2; gbc.weighty = 1.0; Button boton7 = new Button( quot;Botón 7quot; ); gridbag.setConstraints( boton7,gbc ); add( boton7 ); gbc.weighty = 0.0; gbc.gridwidth = GridBagConstraints.REMAINDER; gbc.gridheight = 1; Button boton8 = new Button( quot;Botón 8quot; ); gridbag.setConstraints( boton8,gbc ); add( boton8 ); Button boton9 = new Button( quot;Botón 9quot; ); gridbag.setConstraints( boton9,gbc ); add( boton9 ); } } Este es el código, AwtGBag.java, que utilizamos para generar la imagen del ejemplo. Para aprovechar de verdad todas las posibilidades que ofrece este layout, hay que pintar antes en papel como van a estar posicionados los Componentes; utilizar gridx, gridy, gridwidth y gridheight en vez de GridBagConstraints.RELATIVE, porque en el proceso de 122
  • 123. validación del layout pueden quedar todos los Componentes en posición indeseable. Además, se deberían crear métodos de conveniencia para hacer más fácil el posicionamiento de los Componentes. En el ejemplo siguiente, AwtGBagConv.java, creamos el método de conveniencia addComponente() para la incorporación de nuevos Componentes al layout, lo que hace más sencillo el manejo de los Constraints: import java.awt.*; import java.applet.Applet; public class AwtGBagConv extends Applet { GridBagLayout gridbag = new GridBagLayout(); void addComponente( Component comp,int gridx,int gridy, int gridw,int gridh ) { GridBagConstraints gbc = new GridBagConstraints(); gbc.gridx = gridx; gbc.gridy = gridy; gbc.gridwidth = gridw; gbc.gridheight = gridh; gridbag.setConstraints( comp,gbc ); add( comp ); } public void init() { setLayout( gridbag ); addComponente( new Label( quot;Nombre:quot; ),0,0,1,1 ); addComponente( new TextField( 12 ),1,0,2,1 ); addComponente( new TextArea( 5,20 ),0,1,2,2 ); addComponente( new Checkbox( quot;Sí?quot; ),2,1,1,1 ); addComponente( new List(),2,2,1,1 ); } } CardLayout Este es el tipo de composición que se utiliza cuando se necesita una zona de la ventana que permita colocar distintos Componentes en esa misma zona. Este layout suele ir asociado con botones de lista (Choice), de tal modo que cada selección determina el panel (grupo de componentes) que se presentarán. En la figura siguiente mostramos el efecto de la selección sobre la apriencia de la ventana que contiene el panel con la composición CardLayout: import java.awt.*; import java.applet.Applet; 123
  • 124. public class AwtCard extends Applet { Panel card; final static String PanelBoton = quot;Panel con Botonesquot;; final static String PanelTexto = quot;Panel con Campo de Textoquot;; public void init() { setLayout( new BorderLayout() ); Panel ac = new Panel(); Choice c = new Choice(); c.addItem( PanelBoton ); c.addItem( PanelTexto ); ac.add( c ); add( quot;Northquot;,ac ); card = new Panel(); card.setLayout( new CardLayout() ); Panel p1 = new Panel(); p1.add( new Button( quot;Botón 1quot; ) ); p1.add( new Button( quot;Botón 2quot; ) ); p1.add( new Button( quot;Botón 3quot; ) ); Panel p2 = new Panel(); p2.add( new TextField( quot;Textoquot;,20 ) ); card.add( PanelBoton,p1 ); card.add( PanelTexto,p2 ); add( quot;Centerquot;,card ); } public boolean action( Event evt,Object arg ) { if( evt.target instanceof Choice ) { ( (CardLayout)card.getLayout() ).show( card,(String)arg ); return true; } return false; } } Este es el código, AwtCard.java, que hemos utilizado para generar las dos imágenes que muestran el funcionamiento de la composición CardLayout. CREAR UN LAYOUT Se puede crear un Layout personalizado en base a la interface LayoutManager. Hay que redefinir los cinco métodos que utiliza este interface, lo cual puede no resultar sencillo, así que en lo posible se deben utilizar los métodos de colocación de componentes que proporciona AWT, fundamentalmente en el momento en que parezca que ninguno de los Layouts que hemos visto satisface nuestras exigencias, deberíamos volver a comprobar que el GridBagLayout, que es el más flexible, de verdad no cumple nuestros requerimientos. 124
  • 125. No obstante, vamos a implementar un layout propio, MiLayout.java, para poder colocar los Componentes en posiciones absolutas del panel que contenga a este layout. Derivamos nuestro nuevo layout de LayoutManager y redefinimos los cinco métodos de la clase para que podamos posicionar los Componentes. import java.awt.*; public class MiLayout implements LayoutManager { public MiLayout() { } public void addLayoutComponent( String name,Component comp ) { } public void removeLayoutComponent( Component comp ) { } public Dimension preferredLayoutSize( Container parent ) { Insets insets = parent.insets(); int numero = parent.countComponents(); int ancho = 0; int alto = 0; for( int i=0; i < numero; i++ ) { Component comp = parent.getComponent( i ); Dimension d = comp.preferredSize(); Point p = comp.location(); if( ( p.x + d.width ) > ancho ) ancho = p.x + d.width; if( ( p.y + d.height ) > alto ) alto = p.y + d.height; } return new Dimension( insets.left + insets.right + ancho, insets.top + insets.bottom + alto ); } public Dimension minimumLayoutSize( Container parent ) { Insets insets = parent.insets(); int numero = parent.countComponents(); int ancho = 0; int alto = 0; for( int i=0; i < numero; i++ ) { Component comp = parent.getComponent( i ); Dimension d = comp.preferredSize(); Point p = comp.location(); if( ( p.x + d.width ) > ancho ) ancho = p.x + d.width; if( ( p.y + d.height ) > alto ) alto = p.y + d.height; } return new Dimension( insets.left + insets.right + ancho, insets.top + insets.bottom + alto ); 125
  • 126. } public void layoutContainer( Container parent ) { int numero = parent.countComponents(); for( int i=0; i < numero; i++ ) { Component comp = parent.getComponent( i ); Dimension d = comp.preferredSize(); comp.resize( d.width,d.height ); } } } Y ahora vamos a ver un ejemplo en que utilicemos nuestro Layout. Posicionaremos tres botones en el panel y un campo de texto con una etiqueta precediéndolo. La apriencia que tendrá en pantalla será la que se muestra en la figura: import java.awt.*; import java.applet.Applet; public class AwtLibre extends Applet { Button boton1,boton2,boton3; Label etiqueta; TextField texto; public void init() { setLayout( new MiLayout() ); boton1 = new Button( quot;Aceptarquot; ); boton2 = new Button( quot;Abrirquot; ); boton3 = new Button( quot;Cerrarquot; ); etiqueta = new Label( quot;Textoquot; ); texto = new TextField( quot;quot;,20 ); add( boton1 ); add( boton2 ); add( boton3 ); add( etiqueta ); add( texto ); boton1.move( 0,10 ); boton2.move( 70,10 ); boton3.move( 30,40 ); etiqueta.move( 75,70 ); 126
  • 127. texto.move( 120,70 ); } } Este código, AwtLibre.java, es el que genera la imagen anterior creando un applet que utiliza nuestro recién creado layout. CONTROL DE EVENTOS En el pasado, un programa que quisiera saber lo que estaba haciendo el usuario, debía recoger la información él mismo. En la práctica, esto significaba que una vez inicializado, el programa entraba en un gran bucle en el que continuamente se bloqueaba para comprobar que el usuario estuviese haciendo algo interesante (por ejemplo, pulsar un botón, pulsar una tecla, mover una barra o mover el ratón) y tomar las acciones oportunas. Esta técnica se conoce como polling. El polling funciona, pero se vuelve demasiado difícil de manejar con las aplicaciones modernas por dos razones fundamentales: Primero, el uso de polling tiende a colocar todo el código de control de eventos en una única localización (dentro de un gran bucle); segundo, las interacciones dentro del gran bucle tienden a ser muy complejas. Además, el polling necesita que el programa esté ejecutando el bucle, consumiendo tiempo de CPU, mientras está esperando a que el usuario se decida a hacer algo, lo que supone un gran despilfarro de recursos. El AWT resuelve estos problemas abrazando un paradigma diferente, en el que están basados todos los sistemas modernos de ventanas: la orientación a eventos. Dentro del AWT, todas las acciones que pueda realizar el usuario caen dentro de un gran saco que son los eventos. Un evento describe, con suficiente detalle, una acción particular del usuario. En lugar de que el programa activamente recoja todos los eventos generados por el usuario, el sistema Java avisa al programa cuando se produce un evento interesante. LA CLASE Event Un contenedor soltado en un entorno gráfico se convierte en rápido receptor de eventos de todo tipo, singularmente de los relacionados con el movimiento del ratón, pulsaciones de teclas, creación/movimiento/destrucción de partes gráficas y, por último, los referidos a acciones del usuario respecto de componentes (elección de un menú, pulsación de un botón, etc.). La clase Event es el jugador principal en el juego de los eventos. Intenta capturar las características fundamentales de todos los eventos que genera el usuario. Los datos miembro de la clase Event son los que se indican a continuación: id - El tipo de evento que se ha producido target - Componente sobre el que se ha producido el evento x, y - Las coordenadas en donde se ha producido el evento relativas al Componente que actualmente está procesando ese evento. El origen se toma en la esquina superior izquierda del Componente 127
  • 128. key - Para eventos de teclado, es la tecla que se ha pulsado. Su valor será el valor Unicode del carácter que representa la tecla. Otros valores que puede tomas son los de las teclas especiales como INICIO, FIN, F1, F2, etc. when - Instante en que se ha producido el evento modifiers - La combinación aritmética del estado en que se encuentran las teclas modificadoras Mays, Alt, Ctrl. clickCount - El número de clicks de ratón consecutivos. Sólo tiene importancia en los eventos MOUSE_DOWN arg - Es un argumento dependiente del evento. Para objetos Button, este objeto arg es un objeto String que contiene la etiqueta de texto del botón evt - El siguiente evento en una lista encadenada de eventos Una instancia de la clase Event será creada por el sistema Java cada vez que se genere un evento. Es posible, sin embargo, que un programa cree y envíe eventos a los Componentes a través de su método postEvent(). TIPOS DE EVENTOS Los eventos se catalogan por su naturaleza, que se indicará en el miembro id de su estructura. Los grandes grupos de eventos son: Eventos de Ventana Son los que se generan en respuesta a los cambios de una ventana un frame o un dialogo. • WINDOW_DESTROY • WINDOW_EXPOSE • WINDOW_ICONIFY • WINDOW_DEICONIFY • WINDOW_MOVED Eventos de Teclado Son generados en respuesta a cuando el usuario pulsa y suelta una tecla mientras un Componente tiene el foco de entrada. • KEY_PRESS • KEY_RELEASE • KEY_ACTION • KEY_ACTION_RELEASE 128
  • 129. Eventos de Ratón Son los eventos generados por acciones sobre el ratón dentro de los límites de un Componente. • MOUSE_DOWN • MOUSE_UP • MOUSE_MOVE • MOUSE_ENTER • MOUSE_EXIT • MOUSE_DRAG Eventos de Barras Son los eventos generados como respuesta a la manipulación de barras de desplazamiento (scrollbars). • SCROLL_LINE_UP • SCROLL_LINE_DOWN • SCROLL_PAGE_UP • SCROLL_PAGE_DOWN • SCROLL_ABSOLUTE Eventos de Lista Son los eventos generados al seleccionar elementos de una lista. • LIST_SELECT • LIST_DESELECT Eventos Varios Son los eventos generados en función de diversas acciones. • ACTION_EVENT • LOAD_FILE • SAVE_FILE • GOT_FOCUS • LOST_FOCUS 129
  • 130. El applet EventosPrnt.java está diseñado para observar los eventos que se producen sobre él. Cada vez que se genera un evento, el applet responde imprimiendo el evento que ha capturado en la línea de comandos desde donde se ha lanzado el applet. Una vez que se haya compilado el código y cargado el applet en el appletviewer o en un navegador con soporte Java, jugar un poco con el applet. Mover el cursor dentro del applet, picar con el ratón, picar y arrastrar, teclear algo, cambiar el tamaño de la ventana y taparla y destaparla con otra. Las acciones anteriores harán que en la ventana en donde se haya lanzado el appletviewer, o en la consola Java en caso de Netscape, vayan apareciendo los textos que indican los eventos que está recibiendo el applet. Lo cierto es que el uso de System.out.println() en un applet es algo que no debería utilizarse, e incluso puede llegar a no funcionar en algunos sistemas, pero tenía la ventaja de ser la forma más fácil de ver los eventos. No obstante, vamos a reescribir el código del applet utilizando una Lista. Una Lista es una lista de cadenas o Strings definidas en java.awt.List. Crearemos una lista de 25 líneas y no permitiremos selección múltiple, que son los dos parámetros que necesita el constructor del objeto List. El código EventosList.java que se muestra a continuación corresponde al anterior ejemplo un poco modificado. import java.awt.*; import java.applet.Applet; public class EventosList extends Applet { List lista; public void init() { lista = new List( 25,false ); add( lista ); lista.addItem( quot;Evento initquot; ); } public void start() { lista.addItem( quot;Evento startquot; ); } public void destroy() { lista.addItem( quot;Evento destroyquot; ); } public void paint( Graphics g ) { lista.addItem( quot;Evento paintquot; ); } public void update( Graphics g ) { lista.addItem( quot;Evento updatequot; ); } public boolean mouseUp( Event evt,int x, int y ) { lista.addItem( quot;Evento mouseUp en (quot;+x+quot;,quot;+y+quot;)quot; ); return false; } 130
  • 131. public boolean mouseDown( Event evt,int x, int y ) { lista.addItem( quot;Evento mouseDown en (quot;+x+quot;,quot;+y+quot;)quot; ); return false; } public boolean mouseDrag( Event evt,int x, int y ) { lista.addItem( quot;Evento mouseDrag en (quot;+x+quot;,quot;+y+quot;)quot; ); return false; } public boolean mouseMove( Event evt,int x, int y ) { lista.addItem( quot;Evento mouseMove en (quot;+x+quot;,quot;+y+quot;)quot; ); return false; } public boolean mouseEnter( Event evt,int x, int y ) { lista.addItem( quot;Evento mouseEnter en (quot;+x+quot;,quot;+y+quot;)quot; ); return false; } public boolean mouseExit( Event evt,int x, int y ) { lista.addItem( quot;Evento mouseExitquot; ); return false; } public boolean keyDown( Event evt,int x ) { lista.addItem( quot;Evento keyDown,carácter quot;+(char)x ); return true; } public void getFocus() { lista.addItem( quot;Evento getFocusquot; ); } public void gotFocus() { lista.addItem( quot;Evento gotFocusquot; ); } public void lostFocus() { lista.addItem( quot;Evento lostFocusquot; ); } } El applet VisorEventos.java muestra los datos que componen cada evento que se produce. Hemos incorporado un botón y una lista, tal como se puede apreciar en la figura, para poder generar diferentes eventos. 131
  • 132. Moviendo el ratón o actuando sobre los dos Componentes, botón y lista, podemos observar los datos que el sistema Java envía en la recolección de esos eventos. GENERACION Y PROPAGACION DE EVENTOS Tomemos el applet, EventosPro.java, que aparece en la figura siguiente. Consta de dos instancias de la clase Button, embebidas dentro de una instancia de la clase Panel. Esta instancia está a su vez embebida dentro de otra instancia de la clase Panel. Esta última instancia de la clase Panel está situada junto a una instancia de la clase TextArea, y ambas están embebidas dentro de una instancia de la clase Applet. La figura siguiente presenta los elementos que conforman este applet en forma de árbol, con el TextArea y Button como hojas y la instancia de Applet como raiz. 132
  • 133. Cuando un usuario interactúa con el applet, el sistema Java crea una instancia de la clase Event y rellena sus datos miembro con la información necesaria para describir la acción. Es en ese momento cuando el sistema Java permite al applet controlar el evento. Este control comienza por el Componente que recibe inicialmente el evento (por ejemplo, el botón que ha sido pulsado) y se desplaza hacia arriba en el árbol de Componentes, componente a componente, hasta que alcanza al Contenedor de la raíz del árbol. Durante este camino, cada Componente tiene oportunidad de ignorar el evento o reaccionar ante él en una (o más) de las forma siguientes: • Modificar los datos miembros de la instancia de Event • Entrar en acción y realizar cálculos basados en la información contenida en el evento • Indicar al sistema Java que el evento no debería propagarse más arriba en el árbol El sistema Java pasa información del evento a un Componente a través del método handleEvent() del Componente. Todos los métodos handleEvent() deben ser de la forma: public boolean handleEvent( Event evt ) Un controlador de eventos solamente necesita una información: una referencia a la instancia de la clase Event que contiene la información del evento que se ha producido. El valor devuelto por el método handleEvent() es importante. Indica al sistema Java si el evento ha sido o no completamente controlado por el controlador. Un valor true indica que el evento ha sido controlado y que su propagación debe detenerse. Un valor false indica que el evento ha sido ignorado, o que no ha sido controlado en su totalidad y debe continuar su propagación hacia arriba en el árbol de Componentes. Veamos la descripción de una acción con el applet de la figura anterior. El usuario pulsa el botón quot;Unoquot;. El sistema run-time del lenguaje Java capturará la información sobre el evento (el número de clicks, la localización del click, la hora en que se ha producido la pulsación y el Componente que ha recibido el click) y empaqueta todos esos datos en una instancia de la clase Event. El sistema Java comienza entonces por el Componente que ha sido pulsado (en este caso, el botón quot;Unoquot;) y, a través de una llamada al método handleEvent() del Componente, ofrece a éste la posibilidad de reaccionar ante el evento. Si el Componente no controla el evento, o no lo hace completamente (indicado por un valor de 133
  • 134. retorno false), el sistema Java presentará la instancia de Event al siguiente Componente por encima en el árbol (en este caso, una instancia de la clase Panel). El sistema Java continúa de este mismo modo hasta que el evento es controlado en su totalidad o ya no hay Componentes a los que informar. En la figura siguiente mostramos el camino recorrido por el evento en su intento de que algún Componente lo controle. Cada Componente del applet añade una línea al objeto TextArea indicando que ha recibido un evento. Luego permite que el evento se propague al siguiente Componente. El código del controlador de eventos usado en el ejemplo es el que muestran las siguientes líneas: public boolean handleEvent( Event evt) { if( evt.id == Event.ACTION_EVENT ) ta.appendText( quot;Panel quot; + str + quot; recibe action...nquot; ); else if( evt.id == Event.MOUSE_DOWN ) ta.appendText( quot;Panel quot; + str + quot; recibe mouse_down...nquot; ); return super.handleEvent( evt ); } METODOS DE CONTROL DE EVENTOS El método handleEvent() es un lugar para que el programador pueda insertar código para controlar los eventos. A veces, sin embargo, un Componente solamente estará interesado en eventos de un cierto tipo (por ejemplo, eventos del ratón). En estos casos, el programador puede colocar el código en un método de ayuda, en lugar de colocarlo en el método handleEvent(). No hay métodos de ayuda para ciertos tipos de eventos, aquí está la lista de los que están disponibles para los programadores: action( Event evt,Object obj ) gotFocus( Event evt,Object obj ) lostFocus( Event evt,Object obj ) mouseEnter( Event evt,int x,int y ) mouseExit( Event evt,int x,int y ) mouseMove( Event evt,int x,int y ) mouseUp( Event evt,int x,int y ) mouseDown( Event evt,int x,int y ) 134
  • 135. mouseDrag( Event evt,int x,int y ) keyDown( Event evt,int key ) keyUp( Event evt,int key ) false indicará que el método de ayuda no maneja el evento. La implementación del método handleEvent() proporcionada por la clase Component invoca a cada método de ayuda. Por esta razón, es importante que las implementaciones redefinidas del método handleEvent() en clases derivadas, siempre finalicen con la sentencia: return( super.handleEvent( evt ) ); El siguiente trozo de código ilustra esta regla. public boolean handleEvent( Event evt ) { if( evt.target instanceof MiBoton ) { // Hace algo... return true; } return( super.handleEvent( evt ) ); } No seguir esta regla tan simple hará que no se invoquen adecuadamente los métodos de ayuda. El applet EventosRaton.java, que controla los eventos de ratón exclusivamente a través de código insertado en sus métodos de ayuda; va dibujando una línea (rubber band) entre el último punto donde se ha producido un click de ratón y la posición actual del cursor. ACTION_EVENT Algunos de los eventos que más frecuentemente tendremos que controlar son los siguientes: ACTION_EVENT MOUSE_DOWN KEY_PRESS WINDOW_DESTROY En la documentación de la clase Event se encuentra toda la lista de eventos que cualquier aplicación puede necesitar manejar y su documentación; como ejemplo de uso vamos a detenernos en el primero de ellos, ACTION_EVENT. Como ejemplo del manejo de eventos vamos a ver este evento que se provoca al pulsar un botón, seleccionar un menú, etc. Para su control podemos manejarlo en el método handleEvent() o en el método action(). Los dos métodos anteriores pertenecen a la clase Component por lo que todas las clases derivadas de ésta contendrán estos dos métodos y se pueden sobrecargar para que se ajuste su funcionamiento a lo que requiere nuestra aplicación. 135
  • 136. Veamos el siguiente ejemplo, en que se controla este evento a través del método handleEvent(), que es el método general de manejo de eventos: public boolean handleEvent( Event evt ) { switch( evt.id ) { case Event.ACTION_EVENT: // evt.arg contiene la etiqueta del botón pulsado // o el item del menú que se ha seleccionado if( ( quot;Pulsado quot;+n+quot; vecesquot; ).equals( evt.arg ) ) return( true ); default: return( false ); } } Pero en este caso, cuando se produce este evento se llama al método action(), que sería: public boolean action( Event evt,Object arg ) { if( ( quot;Pulsado quot;+n+quot; vecesquot; ).equals( arg ) ) return( true ); return( false ); } Como se puede comprobar, incluso si las etiquetas cambian se puede recibir el evento. Los ejemplos anteriores corresponden al control de un evento producido por un botón que cambia su etiqueta cada vez que se pulsa. Aunque esta no es la única forma de manejar eventos; de hecho se puede hacer: if( evt.target == miBoton ) en donde se comparan objetos en lugar de etiquetas. MEJORAR EL DISEÑO DE INTERFACES La interface de usuario es el aspecto más importante de una aplicación, tal como ya hemos repetido. Un diseño pobre de la interface es un grave problema para que el usuario pueda obtener todo el partido posible de la aplicación. Para ser efectivos, no debemos limitarnos a colocar una serie de botones, etiquetas y barras de desplazamiento sobre la pantalla. Desafortunadamente, nadie ha determinado una reglas correctas para del diseño de una buena interface. Los diseñadores del AWT parece que se pusieron como meta principal que las clases del AWT funcionasen correctamente, dejando un poco de lado su apariencia. Sin embargo, han proporcionado suficientes mecanismos para poder alterar la apariencia de los Componentes del AWT, muchas veces no de forma sencilla, pero ahí están para que los programadores podamos alterar la visualización de los Componentes sobre nuestro interface. Vamos a ver unas cuantas formas sencillas de alterar y dar un mejor aspecto a nuestros diseños. • Cambio de Font de Caracteres • Colores de Fondo y Texto • Fijar el Tamaño Preferido • Uso de Insets 136
  • 137. • Habilitar y Deshabilitar Componentes CAMBIO DE FUENTE DE CARACTERES El font de caracteres con el que se presenta un texto en pantalla influye mucho en el impacto de una interface. Una interface efectiva no debería utilizar una maraña de fuentes, pero sí que debería utilizar dos o tres diferentes para aumentar el atractivo y la efectividad de los textos. El applet Fuentes.java, tal como se muestra en la figura, ilustra este extremo. Utiliza tres tipos de fonts de caracteres (en diferente estilo y diferente tamaño) para llamar la atención del usuario sobre las tres zonas de la interface. La fuente por defecto para todos los Componentes es la fuente Dialog. Java proporciona otras fuentes con propósitos más especializados, el número exacto de fuentes depende de la plataforma, por ello, se puede utilizar el applet ListaFuentes.java para obtener una lista de las fuentes de caracteres disponibles en el sistema. Cuando un programador necesita presentar un Componente en pantalla, como un objeto TextArea, en una fuente de caracteres distinta a la de defecto, la nueva fuente debe seleccionarse mediante el método setFont(): public void setFont( Font f ) El método setFont() espera como parámetro una fuente. En el siguiente trozo de código vemos cómo se usa: TextArea ta = new TextArea(); Font f = new Font( quot;Helveticaquot;,Font.ITALIC,12 ); ta.setFont( f ); Este código con ligeras modificaciones funcionará para cualquier Componente. Si se cambia la fuente de un Contenedor, todos los Componentes colocados dentro del Contenedor automáticamente adoptarán la nueva fuente de caracteres. El siguiente código, CambioFuentes.java, muestra esta circunstancia: import java.awt.*; import java.applet.Applet; public class CambioFuentes extends Applet { public static void main( String args[] ) { Frame fr = new Frame( quot;Cambio de Fuentesquot; ); CambioFuentes cf = new CambioFuentes(); Font f = new Font( quot;Helveticaquot;,Font.ITALIC,12 ); fr.setFont( f ); 137
  • 138. fr.setLayout( new FlowLayout() ); Button b = new Button( quot;Holaquot; ); fr.add( b ); Checkbox cb = new Checkbox( quot;Púlsamequot; ); fr.add( cb ); TextArea ta = new TextArea(); fr.add( ta ); fr.pack(); fr.show(); } } La fuente de caracteres solamente se indica para el objeto Frame, el botón, la caja y el área de texto también utilizarán esta fuente. COLORES DE FONDO Y TEXTO El impacto visual del color nunca debe ser desestimado cuando se ataca el diseño de una interface de usuario. El color tiende a atraer la visión y puede utilizarse para llamr la atención sobre una parte importante del interface. En el ejemplo siguiente, el color rojo alrededor del botón hace que la vista se fije inmediatamente en él. La clase Component proporciona dos métodos para modificar el color de un Componente. A través de los métodos setBackground() y setForeground(), se pueden indicar los colores del fondo y del texto, respectivamente: public void setBackground( Color c ) public void setForeground( Color c ) Ambos métodos solamente necesitan un parámetro, un objeto Color. A continuación mostramos un ejemplo de su uso: TextArea ta = new TextArea(); ta.setBackground( Color.blue ); ta.setForeground( Color.red ); Este código funcionará con ligeras modificaciones para casi todos los Componentes del AWT. Si se cambia el Color de un Contenedor, todos los Componentes colocados dentro de ese Contenedor, automáticamente adoptan el nuevo color. El applet, CambioColor.java, ilustra este punto. El Color solamente se fija para el color de fondo del objeto Frame; el botón, la caja y el área de texto usarán ese mismo color de fondo. import java.awt.*; import java.applet.Applet; public class CambioColor extends Applet { public static void main( String args[] ) { Frame fr = new Frame( quot;Cambio de Colorquot; ); 138
  • 139. CambioColor cc = new CambioColor(); fr.setBackground( Color.red ); fr.setLayout( new FlowLayout() ); Button b = new Button( quot;Holaquot; ); fr.add( b ); Checkbox cb = new Checkbox( quot;Púlsamequot; ); fr.add( cb ); TextArea ta = new TextArea(); fr.add( ta ); fr.pack(); fr.show(); } } La calidad de soporte del color varía mucho de una plataforma a otra. Bajo Windows '95, la clase Button ignora totalmente los comandos de color y se empeña en permanecer bajo un patrón de grises. Por otro lado, el fondo de la clase Label parece ser transparente. Algunos Componentes no se presentan en pantalla con un mismo color para un mismo objeto Color. Bajo Windows '95, un fondo de color naranja aparece como naranja en muchos Componentes (excepto en los botones), pero se presenta como amarillo cuando se trata de objetos TextArea o TextField. El soporte del color en Solaris parece ser mucho más consistente. FIJAR EL TAMAÑO PREFERIDO Otro ingrediente importante de una buena interface es el tamaño con el cual aparecerá un Componente o Contenedor en la pantalla. En el corazón del control de la composición del interface está el layout manager, que es capaz de fijar el tamaño y la posición de los Componentes que se vayan incorporando al layout que está manejando. Esto, indirectamente, también influye en el tamaño del Contenedor. En este caso, en lugar de llamar a un método para indicar cuál debe ser el tamaño de un Componente, hay que derivar una nueva clase del Componente y redefinir el método preferredSize() que devolverá el tamaño preferido. El layout manager llama al método preferredSize() para determinar cuál debe ser el tamaño preferido para cada Componente. Hay que redefinir el método: public Dimension preferredSize() Uno puede estar tentado a utilizar el método resize() o el método reshape() para especificar un tamaño, pero no debe hacerse. Ambos métodos son usados directamente por el layout manager, y los ajustes de tamaño se reclacularán la próxima vez que el layout manager tenga que recomponer la posición de los Componentes sobre el Contenedor. Las siguientes líneas de código demuestran el uso del método preferredSize(), convenientemente redefinido en una clase derivada. Este método crea un nuevo objeto Dimension con la altura y anchura especificadas y se lo devuelve a quien lo ha llamado (normalmente el layout manager). public Dimension preferredSize() { 139
  • 140. return new Dimension( 200,100 ); } Desde luego, no hay nada para evitar que el tamaño preferido de un botón varíe dinámicamente, como ocurre en el applet CambioBoton.java, mostrado en la figura: Este applet contiene dos botones. Pulsando sobre uno de ellos se provoca el cambio de tamaño en el otro. El método preferredSize() del applet de la figura anterior utiliza la variable dim, que es una variable privada: public Dimension preferredSize() { return new Dimension( dim ); } La variable dim puede ser fijada o cambiada vía una función miembro como la siguiente: public void newPreferredSize( Dimension dim ) { this.dim = new Dimension( dim ); resize( dim ); } El Contenedor debe llamar al método anterior antes de su llamada al método layout() para resituar los Componentes después de que haya cambiado el tamaño de uno de ellos. USO DE Insets Insets, o borde interior, al igual que el tamaño preferido, se puede utilizar para proporcionar a la interface de usuario una mayor ordenación espacial. El insets de un Contendor, especifica la cantidad de espacio alrededor del borde interior del Contenedor donde no se situará ningún Componente, estará vacío. El borde interior se especifica para un Contenedor, redefiniendo su método insets(): public Insets insets() El método insets() no necesita ningún parámetro y devuelve una instancia del objeto Insets. La clase Insets tiene cuatro campos, que especifican el número de pixels que constituirán el borde interior desde arriba, izquierda, abajo y derecha, respectivamente. A continuación mostramos el uso típico de insets(). El código de este ejemplo indica que los Componentes contenidos en el layout deberán estar situados a 5 unidades desde cualquiera de los bordes del Contenedor. public Insets insets() { return new Insets( 5,5,5,5 ); } En la figura siguiente se muestra el efecto que provoca en la apariencia del interface el uso de insets(). 140
  • 141. HABILITAR Y DESHABILITAR COMPONENTES Los Componentes de una interface de usuario que no están actualmente disponibles pero pueden estarlo, en función de alguna acción del usuario, se dice que están deshabilitados. Se presentan con su rótulo en gris y no responden a las acciones del usuario. El deshabilitar Componentes es mucho mejor que ocultarlos, porque el usuario puede ver las operaciones que puede realizar, aunque en ese momento no las tenga disponibles. La clase Component proporciona tres métodos para llevar a cabo la habilitación y deshabilitación de Componentes: public void enable() public void disable() public void enable( boolean condicionBooleana ) Los primeros dos métodos habilitan y deshabilitan un Componente. El tercer método también hace eso dependiendo del valor de un parámetro booleano. Veamos un ejemplo: Button b = new Button( quot;Púlsamequot; ); b.enable(); // o, b.disable(); // o, b.enable( true ); Este código funcionará, con muy pocas modificaciones, sobre cualquier Componente. Para un uso efectivo de estos métodos, un programa debe monitorizar el estado de la interface de usuario. Como el usuario interactúa con la interface, su estado interno cambia. Esto hay que reflejarlo en el estado de los Componentes que pasarán de habilitados a deshabilitados, o viceversa, en función de las circunstancias. Tomemos como ejemplo ahora el applet que aparece en la figura siguiente, obtenido de la ejecución de Habilitar.java: En este applet, los botones Añadir y Borrar están deshabilitados hasta que el usuario haya entrado en el campo de texto. Este previene una activación inadvertida de los dos botones en el caso de que no haya texto en el campo. Tan pronto como se teclee el primer carácter en el campo de texto, se habilitan los dos botones, cada cual asumiendo su propio rol. Si, en 141
  • 142. cualquier momento, el campo de texto se volviese a quedar vacío, los dos botones volverían a estar deshabilitados Además de que los Componentes deshabilitados tienen una apariencia visual diferente, tampoco reciben eventos desde el sistema Java; los eventos son inmediatamente propagados al Contenedor en que está situado el Componente deshabilitado. BOTON GRAFICO AWT adolece de herramientas ya desarrolladas para implementar interfaces al uso, con alta proliferación de imágenes y facilidades para que el programador utilice directamente Componentes. Sin embargo, sí proporciona las herramientas suficientes como para que se puedan implementar cualquier tipo de Componentes, o modificar al gusto los ya existentes. Para mostrar un ejemplo, vamos a implementar un botón gráfico, BotonGrafico.java Partimos de un botón normal al cual aplicaremos tres imágenes diferentes, para cada uno de los tres estados en que puede encontrarse: pulsado, liberado e inhabilitado. En el fichero fuente, podemos comprobar que las tres imágenes se pueden pasar cómo parámetro en la llamada APPLET, por ejemplo: <APPLET CODE=BotonGrafico.class WIDTH=100 HEIGHT=50> <PARAM NAME=IMAGEN0 VALUE=boton0.gif> <PARAM NAME=IMAGEN1 VALUE=botonup.gif> <PARAM NAME=IMAGEN2 VALUE=botondn.gif> </APPLET> Observando el código, se puede comprobar que una vez cargadas la imágenes, solamente se deben controlar los eventos del ratón, para que automáticamente se presenten las imágenes del botón adecuadas y responda correctamente. import java.awt.*; import java.applet.Applet; public class BotonGrafico extends Applet { private MediaTracker tracker; private Image imagen[] = new Image[3]; private boolean BotActivo = false; private boolean BotPulsado = false; private boolean tresImg = false; private int Estado = 0; public void init() { String istr; tracker = new MediaTracker( this ); // Recogemos las tres imágenes de los parámentros de llamada // al applet for( int i=0; i < 3; i++ ) { istr = getParameter( quot;IMAGENquot; + i ); if( istr == null ) tresImg = false; else { 142
  • 143. // Registramos las imágenes con el Media Tracker imagen[i] = getImage( getCodeBase(),istr ); tracker.addImage( imagen[i],0 ); try { tracker.waitForAll(); } catch( InterruptedException e ) { System.out.println( quot;Error cargando imagen quot; + i ); } } } } public void start() { repaint(); } public void stop(){ } // Controlamos la pulsación del ratón public boolean mouseDown( Event evt,int x,int y ) { BotPulsado = true; repaint(); return( true ); } // Controlamos cuando el usuario suelta el botón del ratón public boolean mouseUp( Event evt,int x,int y ) { if( BotPulsado && BotActivo ) { BotPulsado = true; repaint(); } else { BotPulsado = false; repaint(); } return( true ); } // Controlamos cuando el cursor del ratón entra en el // campo de acción del applet // Presentamos un mensaje en la línea de estado public boolean mouseEnter( Event evt,int x,int y ) { BotActivo = true; showStatus( quot;Tutorial de Java, Boton Graficoquot; ); repaint(); return( true ); } // Controlamos cuando el cursor del ratón abandona el // lugar ocupado por el applet public boolean mouseExit( Event evt,int x,int y ) { BotActivo = false; showStatus( quot;quot; ); 143
  • 144. repaint(); return( true ); } public void update( Graphics g ) { // Controlamos el estado en que se queda el botón // tras la acción que se haya hecho con el ratón if( !BotActivo ) Estado = 0; else if( BotActivo && !BotPulsado ) Estado = 1; else Estado = 2; paint( g ); } public void paint( Graphics g ) { g.drawImage( imagen[Estado],0,0,this ); } } CONTENEDORES Container es una clase abstracta derivada de Component, que representa a cualquier componente que pueda contener otros componentes. Se trata, en esencia, de añadir a la clase Component la funcionalidad de adición, sustracción, recuperación, control y organización de otros componentes. El AWT proporciona cuatro clases de Contenedores: • Window • Frame • Dialog • Panel Además de estos Contenedores, la clase Applet también es un Contenedor, es un subtipo de la clase Panel y puede tener Componentes. Window Es una superficie de pantalla de alto nivel (una ventana). Una instancia de la clase Window no puede estar enlazada o embebida en otro Contenedor. Una instancia de esta clase no tiene ni título ni borde. Frame Es una superficie de pantalla de alto nivel (una ventana) con borde y título. Una instancia de la clase Frame puede tener una barra de menú. Una instancia de esta clase es mucho más aparente y más semejante a lo que nosotros entendemos por ventana. 144
  • 145. Dialog Es una superficie de pantalla de alto nivel (una ventana) con borde y título. Una instancia de la clase Dialog no puede existir sin una instancia asociada de la clase Frame. Panel Es un Contenedor genérico de Componentes. Una instancia de la clase Panel, simplemente proporciona un Contenedor al que ir añadiendo Componentes. Crear un Contenedor Antes de poder incorporar Componentes a la interface de usuario que se desea implementar, el programador debe crear un Contenedor. Cuando se construye una aplicación, el programador debe crear en primer lugar una instancia de la clase Window o de la clase Frame. Cuando lo que se construye es un applet, ya existe un Frame (la ventana del navegador). Debido a que la clase Applet está derivada de la clase Panel, el programador puede ir añadiendo Componentes directamente a la instancia que se crea de la clase Applet. En el siguiente ejemplo se crea un Frame vacío. El título del Frame, que corresponderá al título de la ventana, se fija en la llamada al constructor. Un Frame inicialmente está invisible, para poder verlo es necesario invocar al método show(): import java.awt.*; public class Ejemplo1 { public static void main( String args[] ) { Frame f = new Frame( quot;Ejemplo 1quot; ); f.show(); } } En el código de ejemplo que sigue, extendemos el código anterior para que la nueva clase sea una subclase de la clase Panel. En el método main() de esta nueva clase se crea una instancia de ella y se le incorpora un objeto Frame llamando al método add(). El resultado de ambos ejemplos es idéntico a efectos de apariencia en pantalla: import java.awt.*; public class Ejemplo2 extends Panel { public static void main( String args[] ) { Frame f = new Frame( quot;Ejemplo 2quot; ); Ejemplo2 ej = new Ejemplo2(); f.add( quot;Centerquot;,ej ); f.pack(); f.show(); } } Derivando la nueva clase directamente de la clase Applet en vez de Panel, nuestro ejemplo puede ahora ejecutarse tanto como una aplicación solitaria como dentro de una página HTML en un navegador. El código siguiente muestra esta circunstancia: 145
  • 146. import java.awt.*; public class Ejemplo3 extends java.applet.Applet { public static void main( String args[] ) { Frame f = new Frame( quot;Ejemplo 3quot; ); Ejemplo3 ej = new Ejemplo3(); f.add( quot;Centerquot;,ej ); f.pack(); f.show(); } } Un objeto Window, y en algunos casos incluso un objeto Dialog, pueden reemplazar al objeto Frame. Son Contenedores válidos y los Componentes se añaden en ellos del mismo modo que se haría sobre un Frame. Añadir Componentes a un Contenedor Para que la interface sea útil, no debe estar compuesta solamente por Contenedores, éstos deben tener Componentes en su interior. Los Componentes se añaden al Contenedor invocando al método add() del Contenedor. Este método tiene tres formas de llamada que dependen del manejador de composición o layout manager que se vaya a utilizar sobre el Contenedor. En el código siguiente, incorporamos dos botones al código del último ejemplo. La creación se realiza en el método init() porque éste siempre es llamado automáticamente al inicializarse el applet. De todos modos, al inciarse la ejecución se crean los botones, ya que el método init() es llamado tanto por el navegador como por el método main(): import java.awt.*; public class Ejemplo4 extends java.applet.Applet { public void init() { add( new Button( quot;Unoquot; ) ); add( new Button( quot;Dosquot; ) ); } public static void main( String args[] ) { Frame f = new Frame( quot;Ejemplo 4quot; ); Ejemplo4 ej = new Ejemplo4(); ej.init(); f.add( quot;Centerquot;,ej ); f.pack(); f.show(); } 146
  • 147. OBJETOS GRAFICOS En páginas anteriores ya se ha mostrado cómo escribir applets, cómo lanzarlos y los fundamentos básicos de la presentación de información sobre ellos. Ahora, pues, querremos hacer cosas más interesantes que mostrar texto; ya que cualquier página HTML puede mostrar texto. Para ello, Java proporciona la clase Graphics, que permite mostrar texto a través del método drawString(), pero también tiene muchos otros métodos de dibujo. Para cualquier programador, es esencial el entendimiento de la clase Graphics, antes de adentrarse en el dibujo de cualquier cosa en Java. Esta clase proporciona el entorno de trabajo para cualquier operación gráfica que se realice dentro del AWT. Juega dos importantes papeles: por un lado, es el contexto gráfico, es decir, contiene la información que va a afectar a todas las operaciones gráficas, incluyendo los colores de fondo y texto, la fuente de caracteres, la localización y dimensiones del rectángulo en que se va a pintar, e incluso dispone de información sobre el eventual destino de las operaciones gráficas (pantalla o imagen). Por otro lado, la clase Graphics proporciona métodos que permiten el dibujo de primitivas, figuras y la manipulación de fonts de caracteres y colores. También hay clases para la manipulación de imágenes, doble-buffering, etc. Para poder pintar, un programa necesita un contexto gráfico válido, representado por una instancia de la clase Graphics. Pero, como esta clase es abstracta, no se puede instanciar directamente; así que debemos crear un componente y pasarlo al programa como un argumento a los métodos paint() o update(). Los dos métodos anteriores, paint() y update(), junto con el método repaint() son los que están involucrados en la presentación de gráficos en pantalla. El AWT, para reducir el tiempo que necesitan estos métodos para realizar el repintado en pantalla de gráficos, tiene dos axiomas: • Primero, el AWT repinta solamente aquellos Componentes que necesitan ser repintados, bien porque estuviesen cubiertos por otra ventana o porque se pida su repintado directamente • Segundo, si un Componente estaba tapado y se destapa, el AWT repinta solamente la porción del Componente que estaba oculta En la ejecución del applet que aparece a continuación, EjemploGraf.java, podemos observar como se realiza este proceso. Ignorar la zona de texto de la parte superior del applet de momento, y centrar la mirada en la parte coloreada. Utilizando otra ventana, tapar y destapar parte de la zona que ocupa el applet. Se observará que solamente el trozo de applet que estaba cubierto es el que se repinta. Yendo un poco más allá, solamente aquellos componentes que estén ocultos y se vuelvan a ver serán los que se repinten, sin tener en cuenta su posición dentro de la jerarquía de componentes. La pantalla en Java se incrementa de izquierda a derecha y de arriba hacia abajo, tal como muestra la figura: 147
  • 148. Los pixels de la pantalla son pues: posición 0 + ancho de la pantalla - 1. En los textos, el punto de inserción se encuentra en la línea base de la primera letra. Métodos para Dibujos Vamos a presentar métodos para dibujar varias figuras geométricas. Como estos métodos funcionan solamente cuando son invocados por una instancia válida de la clase Graphics, su ámbito de aplicación se restringe a los componentes que se utilicen en los métodos paint() y update(). Normalmente los métodos de dibujo de primitivas gráficas funcionan por pares: un método pinta la figura normal y el otro pinta la figura rellena. drawLine( x1,y1,x2,y2 ) drawRect( x,y,ancho,alto ) fillRect( x,y,ancho,alto ) clearRect( x,y,ancho.alto ) drawRoundRect( x,y,ancho,alto,anchoArco,altoArco ) fillRoundRect( x,y,ancho,alto,anchoArco,altoArco ) draw3DRect( x,y,ancho,alto,boolean elevado ) fill3DRect( x,y,ancho,alto,boolean elevado ) drawOval( x,y,ancho,alto ) fillOval( x,y,ancho,alto ) drawArc( x,y,ancho,alto,anguloInicio,anguloArco ) fillArc( x,y,ancho,alto,anguloInicio,anguloArco ) drawPolygon( int[] puntosX,int[] puntosY[],numPuntos ) fillPolygon( int[] puntosX,int[] puntosY[],numPuntos ) drawString( string s,x,y ) drawChars( char data[],offset,longitud,x,y ) drawBytes( byte data[],offset,longitud,x,y ) copyArea( xSrc,ySrc,ancho,alto,xDest,yDest ) LINEAS Si se necesita dibujar una línea, se puede utilizar el método g.drawLine( x1,y1,ancho,alto ); donde g es una instancia de la clase Graphics. graphics.drawLine(..) también sería legal ya que graphics es también una instancia de Graphics. Graphics es una clase abstracta por lo que no se pueden crear objetos de esta clase, es decir, la siguiente sentencia es totalmente ilegal: 148
  • 149. g = new Graphics(); porque no se puede utilizar new para obtener g. En el código de la aplicación Cuadrados.java, podemos observar el uso del método de dibujar líneas. Es el más simple de todos los métodos gráficos, que pinta una línea recta de un pixel de ancho entre el punto inicial que se indica y el final, calculado en función del ancho y alto de la región donde se pinta. En el siguiente applet, FigLinea.java, podemos ver el método drawLine() en funcionamiento: RECTANGULOS Los rectángulos, al igual que los óvalos, se definen por un punto de inicio de coordenadas x e y y el ancho y el alto de la caja que circunscribirá a la figura. Para dibujar un rectángulo en pantalla, basta con llamar al método drawRect() indicando la posición en que deseamos colocar la esquina superior-izquierda del rectángulo y su ancho y alto. Por ejemplo, el código siguiente, Rect1.java, pinta un rectángulo alrededor del applet que lo contiene: import java.awt.*; import java.applet.Applet; public class Rect1 extends Applet { int ancho,alto; public void init() { Dimension d = size(); // devuelve el tamaño del applet ancho = d.width; alto = d.height; repaint(); } public void paint( Graphics g ) { g.drawRect( 0,0,ancho-1,alto-1 ); } } En este caso hemos tenido que utilizar ancho-1 y alto-1, para que fuese visible todo el rectángulo y no solamente la mitad, por causa de la referencia de coordenadas que utiliza Java con respecto a la pantalla. El método drawRect() pinta un rectángulo abierto, si queremos un rectángulo relleno, tendremos que invocar al método fillRect(), que tiene idéntica sintaxis. El código siguiente, Rect2.java, pinta un rectángulo relleno en el centro del applet que lo contiene: import java.awt.*; import java.applet.Applet; public class Rect2 extends Applet { int apAncho; int apAlto; int x,y,ancho,alto; 149
  • 150. public void init() { Dimension d = size(); apAncho = d.width; apAlto = d.height; ancho = apAncho/3; alto = apAlto/3; x = (apAncho - ancho)/2; y = (apAlto - alto)/2; repaint(); } public void paint( Graphics g ) { g.drawRect( 0,0,apAncho-1,apAlto-1 ); g.fillRect( x,y,ancho-1,alto-1 ); } } Si queremos pintar un montón de rectángulos en posiciones y de tamaños aleatorios, al estilo de Mondrian, también podemos hacerlo. Para ello utilizaremos el método Math.random() de la clase Math. Este método devuelve un doble entre 0.0 y 1.0. El método aleatorio() sería: private int aleatorio( int rango ) { double retornoMath; retornoMath = Math.random(); return( (int)( retornoMath * rango ) ); } Este método fuerza a que el resultado sea un entero en el rango que nosotros indiquemos. El casting o moldeo se realiza de double a int. El casting en Java es mucho más seguro que en C u otros lenguajes que permiten castings arbitrarios. En Java solamente se pueden realizar castings que tengan sentido, por ejemplo entre un float y un int; y no podrían realizarse un casting, por ejemplo entre un int y un String. Vamos también a pintar los rectángulos en diferentes colores, utilizando el método setColor() de la clase Graphics. El AWT predefine suficientes colores, con lo cual, además de pintar un rectángulo aleatorio, lo mostraremos en un color aleatorio. En el código, Rect3.java, que mostramos, se pinta un rectángulo con tamaño, posición y color aleatorios: import java.awt.*; import java.applet.Applet; public class Rect3 extends Applet { int apAncho,apAlto; int x,y,ancho,alto; Color color; public void init() { Dimension d = size(); apAncho = d.width; apAlto = d.height; x = aleatorio( apAncho ); y = aleatorio( apAlto ); ancho = aleatorio( apAncho - x ); 150
  • 151. alto = aleatorio( apAlto - y ); color = new Color( aleatorio(255),aleatorio(255),aleatorio(255) ); repaint(); } public void paint( Graphics g ) { g.setColor( color ); g.drawRect( 0,0,apAncho-1,apAlto-1 ); g.fillRect( x,y,ancho-1,alto-1 ); } private int aleatorio( int rango ) { double retornoMath; retornoMath = Math.random(); return( (int)( retornoMath * rango ) ); } } Si se carga repetidas veces el applet, aparecerán diferentes rectángulos, con distintos colores y en distintas posiciones, así que vamos a automatizar ese proceso y a complicar del todo el ejemplo, permitiendo que se pinten multitud de rectángulos coloreados. Debido a que cada uno de los rectángulos va a ser diferente, tendremos que mover los cálculos de posición, tamaño y color de cada rectángulo al método paint(). Además, vamos a permitir especificar en el fichero HTML que lance el applet, el número de rectángulos que se van a dibujar. Para ello fijaremos un número por defecto y en caso de que se incluya el número de rectángulos como parámetro de la invocación al applet, utilizaremos este último. He aquí el código, Rect4.java, que realiza todo esto: import java.awt.*; import java.applet.Applet; public class Rect4 extends Applet { int apAncho,apAlto; int x,y,ancho,alto; Color color; int numRect = 100; public void init() { Dimension d = size(); apAncho = d.width; apAlto = d.height; String s = getParameter( quot;Numeroquot; ); if( s != null ) numRect = Integer.valueOf( s ).intValue(); repaint(); } public void paint( Graphics g ) { g.setColor( Color.black ); g.drawRect( 0,0,apAncho-1,apAlto-1 ); 151
  • 152. for( int i=0; i < numRect; i++ ) { x = aleatorio( apAncho ); y = aleatorio( apAlto ); ancho = aleatorio( apAncho - x ); alto = aleatorio( apAlto - y ); color = new Color( aleatorio(255),aleatorio(255), aleatorio(255) ); g.setColor( color ); g.fillRect( x,y,ancho-1,alto-1 ); } } private int aleatorio( int rango ) { double retornoMath; retornoMath = Math.random(); return( (int)( retornoMath * rango ) ); } } Los rectángulos redondeados necesitan dos parámetros adicionales, con respecto al método habitual, para controlar el arco con que se redondearán las esquinas del rectángulo. El método que pinta rectángulos tridimensionales todavía necesitan un parámetro más que indica si el rectángulo estará sobresaliendo o hundiéndose en la pantalla. En el applet siguiente, FigRectangulo.java, podemos ver y manipular los valores que pueden tomar estos métodos: CIRCULOS, ELIPSES Los m‰todos definidos en Java para la realizacin de c ヘ rculos y elipses, al igual que en la mayor ヘ a de los lenguajes, reciben como parßmetros las coordenadas de la esquina superior-izquierda y el ancho y alto de la caja en la que se circunscribe el c ヘ rculos o la elipse. En el ejemplo siguiente, Ojos.java, podemos ver la r‰plica de la aplicacin conocida por los usuarios de Motif, en la que los ojos siguen los movimientos del ratn cuando se encuentra dentro del campo del applet. import java.awt.*; import java.applet.Applet; public class Ojos extends Applet { int Mx = -1; int My = -1; int OjoR1; int OjoR2; int Ancho; int Alto; int OjoIzq; 152
  • 153. int OjoDch; int OjoPY; Color Pupila = Color.black; Color Iris = Color.green.brighter(); Color Orbita = Color.white; Image Imagen; Graphics OjoCG; public void init() { setBackground( Color.darkGray ); Dimension d = size(); // Fijamos las variables que nos van a posicionar los // ojos sobre el applet OjoIzq = d.width >> 2; OjoDch = OjoIzq * 3; OjoPY = d.height >> 2; OjoR2 = d.width >> 4; OjoR1 = d.width >> 5; Ancho = ( d.width >> 3 ) + OjoR1; Alto = Ancho >> 1; } public void update( Graphics g ) { paint( g ); } // Funcion auxiliar, para que no se desmanden los valores // y no se los salgan los ojos de las orbitas int swap( int i,int c ) { if( i > c ) i = c; else if( i < -c ) i = -c; return( i ); } // Pintamos el ojo sobre el applet void pintaOjo( Graphics g,int x ) { // Fijamos los desplazamientos, las nuevas posiciones de // referencia, en funcion de la posicion del cursor del // raton, determinada por Mx y My int dx = x-Mx; int dy = OjoPY-My; // Pintamos el ojo solamente bordeado, es decir, cerrado if( dx < Ancho && dx > -Ancho && dy < Alto && dy > -Alto ) { g.setColor( getBackground() ); g.fillOval( x-Ancho,OjoPY-Alto,Ancho << 1,Alto << 1 ); g.setColor( getBackground().brighter() ); g.drawOval( x-Ancho,OjoPY-Alto,Ancho << 1,Alto << 1 ); 153
  • 154. } else { // Pintamos el hueco del ojo, por el que se movera el iris g.setColor( Orbita ); g.fillOval( x-Ancho,OjoPY-Alto,Ancho << 1,Alto << 1 ); int y = OjoPY; dx = swap( dx >> 3,OjoR1 << 1 ); dy = swap( dy >> 5,OjoR1 >> 1 ); if( Mx >= 0 && My >= 0 ) { x -= dx; y -= dy; } // Pintamos el iris, sobre el que se movera la pupila g.setColor( Iris ); g.fillOval( x-OjoR2,y-OjoR2,OjoR2 << 1,OjoR2 << 1 ); if( Mx >= 0 && My >= 0 ) { x -= ( dx >> 1 ); y -= dy; } // Pintamos la pupila dentro del iris g.setColor( Pupila ); g.fillOval( x-OjoR1,y-OjoR1,OjoR1 << 1,OjoR1 << 1 ); } } public void paint( Graphics g ) { Dimension d = size(); // La primera vez que se llama a este metodo, todavia no // hay nada, asi que creamos el soporte de los ojos if( Imagen == null || OjoCG == null ) { Imagen = createImage( d.width,d.height >> 1 ); OjoCG = Imagen.getGraphics(); } // Pintamos los ojos OjoCG.setColor( getBackground() ); OjoCG.fillRect( 0,0,d.width,d.height ); pintaOjo( OjoCG,OjoIzq ); pintaOjo( OjoCG,OjoDch ); g.drawImage( Imagen,0,0,this ); } // Cuando movemos el cursos dentro del applet, recibimos las // coordenadas y repintamos el ojo public boolean mouseMove( Event evt,int x,int y ) { Mx = x; My = y; 154
  • 155. repaint(); return true; } // Si nos llega el evento de que el raton se ha salido del applet // ponemos los todo en el centro, con los ojos espantados, // como si se hubiese visto al diablo public boolean mouseExit( Event evt,int x,int y ) { Mx = My = -1; repaint(); return true; } } Cada uno de los métodos que nos permiten representar en pantalla elipses y arcos, requieren como parámetros las coordenadas del punto central del óvalo o arco y el ancho y alto, en valor positivo, del rectángulo que circunscribe al óvalo o al arco, como hemos dicho. Para pintar arcos, necesitamos dos parámetros adicionales, un ángulo de inicio y un ángulo para el arco; de este modo especificamos el inicio del arco y en tamaño del arco en grados (no en radianes). En la figura que sigue mostramos cómo se tiene en cuanta el ángulo a la hora de las especificación de ángulos en los valores de los parámetros a pasar a los métodos drawArc() y fillArc(). FUNCIONES GRAFICAS A través de líneas también se pueden realizar figuras más complicadas que resulten de la representación gráfica de funciones matemáticas. No pretendemos entrar en complicadas disquisiciones matemáticas, sino presentar algunas de las particularidades de los gráficos y Java. Vamos a presentar el código siguiente, Grafico1.java, que pintará la curva de la función seno de izquierda a derecha de la ventana: import java.awt.*; import java.applet.Applet; public class Grafico1 extends Applet { int x0,xN,y0,yN; public void init() { Dimension d = size(); x0 = y0 = 0; xN = d.width-1; yN = d.height-1; } public void paint( Graphics g ) { for( int x=x0; x < xN; x++ ) g.drawLine( x,(int)(yN*Math.sin(x)), x+1,(int)(yN*Math.sin(x+1)) ); } } 155
  • 156. El corazón del funcionamiento del applet se encuentra en el bucle incluido en el método paint(): for( int x=x0; x < xN; x++ ) g.drawLine( x,(int)(yN*Math.sin(x)),x+1,(int)(yN*Math.sin(x+1))); El bucle va desplazándose a través de cada pixel de la pantalla en el eje x, y en cada una de las posiciones, calcula el seno para ese pixel. También calcula el seno del pixel siguiente y pinta una línea que une esos dos puntos. Debido a que el seno de un número real está siempre comprendido entre 1 y -1, escalamos el valor de y con yN. Y por fin hacemos un casting de los valores del seno en el eje y porque son flotantes fundamentalmente y el método drawLine() necesita enteros. El applet anterior funciona correctamente, pero adolece de dos dos problemas: Primero, los senos son operaciones en coma flotante, luego para que el applet tenga realmente utilidad necesitamos utilizar números en coma flotante. Segundo, el sistema de coordenadas que maneja el applet va desde el punto (0,0), de la esquina superior-izquierda hasta la inferior- derecha. Pero el sistema normal de coordenadas Cartesianas empieza a contar desde la esquina inferior-izquierda. Lo que haremos será mover el origen al centro del applet y transformar las coordenadas del eje y para que vayan en las direcciones adecuadas. La solución a los dos problemas anteriores puede tomar un montón de caminos diferentes, sin embargo, la clave se encuentra en separar los datos de lo que es la pantalla. Es decir, vamos a realizar nuestros cálculos matemáticos suponiendo que estamos en el espacio de un rectángulo en coordenadas cartesianas y, por otro lado, tomaremos a la pantalla como un rectángulo de puntos de ancho y tamaño fijos. Así podremos realizar los cálculos en el plano de los ejes cartesianos y presentarlos en el espacio reducido de la ventana del applet. Necesitaremos pues, un método para convertir un punto de la ventana del applet en un punto en el mundo cartesiano, y otro que haga la función contraria. El código siguiente, GraficoSeno.java, hace todo esto: import java.awt.*; import java.applet.Applet; public class GraficoSeno extends Applet { int x0,xN,y0,yN; double xmin,xmax,ymin,ymax; int apAncho,apAlto; public void init() { Dimension d = size(); apAncho = d.width; apAlto = d.height; x0 = y0 = 0; xN = apAncho-1; yN = apAlto-1; xmin = -10.0; xmax = 10.0; ymin = -1.0; ymax = 1.0; } 156
  • 157. public void paint( Graphics g ) { double x1,y1,x2,y2; int j1,j2; j1 = ValorY( 0 ); for( int i=0; i < apAncho; i++ ) { j2 = ValorY( i+1 ); g.drawLine( i,j1,i+1,j2 ); j1 = j2; } } private int ValorY( int valor ) { double x,y; int retorno; // Cartesianas equivalentes al punto de la pantalla x = (valor * (xmax-xmin) / (apAncho-1)) + xmin; // Calculamos el seno de ese punto y = Math.sin( x ); // Escalamos la coordenada y dentro de los limites de la ventana retorno = (int)( (y-ymin) * (apAlto-1) / (ymax-ymin) ); // Reconvertinos el valor cartesiano a punto de pantalla retorno = apAlto - retorno; return( retorno ); } } Ejecutando este applet, podremos observar que lo que se presenta ya se parece muchísimo más a la imagen que todos conocemos de la onda senoidal. FRACTALES No vamos aquí a proporcionar una clase maestra sobre fractales, sino que vamos a mostrar que Java también se puede emplear para la implementación de algunos ejemplos clásicos de la geometría de fractales. Vamos a realizar por uno sencillito, en el que se trata de un conjunto definido por todos los números reales entre cero y uno, inclusive. Entonces, eliminamos el tercio central de ese conjunto, es decir, todo lo que se encuentre entre el primer tercio y el último, ambos exclusive. 157
  • 158. Para visualizar lo anterior vamos a utilizar segmentos de línea. Eliminaremos el tercio medio del segmento, es decir, nos quedaremos con el segmento que va desde el inicio del segmento hasta el segundo noveno, y entre el séptimo noveno y el final; y continuaremos este proceso indefinidamente. La verdad es que parece un poco confusa la explicación, pero si una imagen vale más que mil palabras, un buen programa Java vale más que mil imágenes. Por ello, aquí esta el código Java, Tercio.java, que muestra sucesivas líneas en que se demuestra la explicación del párrafo anterior. import java.awt.*; import java.applet.Applet; import java.util.Vector; public class Tercio extendsApplet { int apAncho,apAlto; Vector finPuntos = new Vector(); public void init() { apAncho = size().width; apAlto = size().height; finPuntos.addElement( new Float( 0.0f ) ); finPuntos.addElement( new Float( 1.0f ) ); } public void paint( Graphics g ) { float x1,x2; Float tmpFloat; for( int i=0; i < apAncho; i+=5 ) { // Pintamos las lineas for( int j=0; j < finPuntos.size(); j+=2 ) { tmpFloat = (Float)finPuntos.elementAt( j ); x1 = tmpFloat.floatValue(); tmpFloat = (Float)finPuntos.elementAt( j+1 ); x2 = tmpFloat.floatValue(); g.drawLine( Math.round( x1*apAncho ),i, Math.round( x2*apAncho),i ); } // Eliminamos el tercio medio de las lineas BorraSegmentos(); // Comprobamos que no nos salimos de la pantalla tmpFloat = (Float)finPuntos.elementAt( 0 ); x1 = tmpFloat.floatValue(); tmpFloat = (Float)finPuntos.elementAt( 1 ); x2 = tmpFloat.floatValue(); if( Math.round( x1*apAncho ) == Math.round( x2*apAncho ) ) break; } } private void BorraSegmentos() { int indice = 0; 158
  • 159. int fin = finPuntos.size(); for( int i=0; i < fin; i+=2 ) { BorraTercioMedio( indice,indice+1 ); indice += 4; } } private void BorraTercioMedio( int izqda,int dcha ) { float gap; float x1,x2; Float tmpFloat1,tmpFloat2; tmpFloat1 = (Float)finPuntos.elementAt( izqda ); tmpFloat2 = (Float)finPuntos.elementAt( dcha ); gap = tmpFloat2.floatValue() - tmpFloat1.floatValue(); x1 = tmpFloat1.floatValue() + gap/3.0f; x2 = tmpFloat2.floatValue() - gap/3.0f; finPuntos.insertElementAt( new Float( x2 ),dcha ); finPuntos.insertElementAt( new Float( x1 ),dcha ); } } Aquí vemos el resultado de la ejecución del applet. ¿Está claro? Desde luego no es la representación más perfecta del conjunto, debido a que tenemos que manejar puntos de tamaño finito en lugar de puntos matemáticos genuinos. Dependiendo de lo larga que sea la ventana del applet, probablemente sólo se vean entre seis y doce interacciones antes de necesitar de que los pixels se vuelvan fraccionarios. Es de hacer notar que en este programa Java hemos utilizado el objeto Vector. Debido a que Java no dispone de punteros, este objeto y la clase asociada, disponen de los métodos necesarios para poder implementar una lista enlazada, que es lo que nosotros hemos utilizado. LINEAS FLOTANTES El ejemplo de las líneas flotantes es más difícil de describir que su código. Se ejecuta sobre un bucle infinito y son líneas que se están moviendo continuamente por la ventana que ocupa el applet, rebotando en los bordes y moviéndose continuamente. El código del fichero Lineas.java, es el que contiene las sentencias que crean el applet que se visualiza a continuación. Repasar el código delalgoritmo para entenderlo, que es bastante simple. import java.awt.*; import java.applet.Applet; 159
  • 160. public class Lineas extends Applet { int LINEAS = 25; int gSup = 3; int gInf = 3; int gIzq = 2; int gDch = 6; int apAncho,apAlto; int gLineas[][] = new int[LINEAS][4]; public void init() { Dimension d = size(); apAncho = d.width; apAlto = d.height; } public void start() { gLineas[0][0] = aleatorio( apAncho ); gLineas[0][1] = aleatorio( apAlto ); gLineas[0][2] = aleatorio( apAncho ); gLineas[0][3] = aleatorio( apAlto ); for( int i=1; i < LINEAS; i++ ) { CopiaLinea( i,i-1 ); RecalcLinea( i ); } repaint(); } public void paint( Graphics g ) { while( true ) { for( int i=LINEAS-1; i > 0; i-- ) CopiaLinea( i,i-1 ); RecalcLinea( 0 ); g.setColor( Color.black ); g.drawLine( gLineas[0][0],gLineas[0][1], gLineas[0][2],gLineas[0][3] ); g.setColor( getBackground() ); g.drawLine( gLineas[LINEAS-1][0],gLineas[LINEAS-1][1], gLineas[LINEAS-1][2],gLineas[LINEAS-1][3] ); } } private void CopiaLinea( int desde,int hasta ) { for( int i=0; i < 4; i++ ) gLineas[desde][i] = gLineas[hasta][i]; } public int aleatorio( int rango ) { double retornoMath; retornoMath = Math.random(); return( (int)(retornoMath * rango) ); } 160
  • 161. private void RecalcLinea( int i ) { gLineas[i][1] += gSup; if( (gLineas[i][1] < 0 ) || (gLineas[i][1] > apAlto) ) { gSup *= -1; gLineas[i][1] += 2*gSup; } gLineas[i][3] += gInf; if( (gLineas[i][3] < 0 ) || (gLineas[i][3] > apAlto) ) { gInf *= -1; gLineas[i][3] += 2*gInf; } gLineas[i][0] += gIzq; if( (gLineas[i][0] < 0 ) || (gLineas[i][0] > apAncho) ) { gIzq *= -1; gLineas[i][0] += 2*gIzq; } gLineas[i][2] += gDch; if( (gLineas[i][2] < 0 ) || (gLineas[i][2] > apAncho) ) { gDch *= -1; gLineas[i][2] += 2*gDch; } } } POLIGONOS Los polígonos son figuras creadas a partir de una secuencia de segmentos. Cada método que permite dibujar polígonos necesita como parámetros las coordenadas de los puntos donde termina cada uno de los segmentos que constituyen el polígono. Estos puntos se pueden especificar como dos arrays paralelos de enteros, uno conteniendo las coordenadas x de los puntos y otro las coordenadas y; o mediante una instancia de la clase Polygon. Esta clase proporciona el método addPoint(), que permite ir construyendo el polígono punto a punto. El applet, FigPoligono.java, que aparece seguidamente permite ver los métodos de dibujo de polígonos en acción. METODOS PARA IMAGENES Los objetos Graphics pueden mostrar imágenes a través del método: drawImage( Image img,int x,int y,ImageObserver observador ); 161
  • 162. Hay que tener en cuenta que el método drawImage() necesita un objeto Image y un objeto ImageObserver. Podemos cargar una imagen desde un fichero de dibujo (actualmente sólo se soportan formatos GIF y JPEG) con el método getImage(): Image img = getImage( getDocumentBase(),quot;fichero.gifquot; ); La forma de invocar al método getImage() es indicando un URL donde se encuentre el fichero que contiene la imagen que queremos presentar y el nombre de ese fichero: getImage( URL directorioImagen,String ficheroImagen ); Un URL común para el método getImage() es el directorio donde está el fichero HTML. Se puede acceder a esa localización a través del método getDocumentBase() de la clase Applet, como ya se ha indicado. Normalmente, se realiza el getImage() en el método init() del applet y se muestra la imagen cargada en el método paint(), tal como se muestra en el ejemplo siguiente: public void init() { img = getImage( getDocumentBase(),quot;pepe.gifquot; ); } public void paint( Graphics g ) { g.drawImage( img,x,y,this ); } En el applet Imagen.java, podemos ver el ejemplo completo. Su ponemos en él la existencia del fichero quot;Imagenes/pepe.gifquot;: import java.awt.*; import sun.awt.image.URLImageSource; import java.applet.Applet; public class Imagen extends Applet { Imagen pepe; public void init() { pepe = getImage( getDocumentBase(),quot;Imagenes/pepe.gifquot; ); } public void paint( Graphics g ) { g.drawString( pepe,25,25,this ); } } DOBLE-BUFFERING DE GRAFICOS Al mostrar gráficos con las técnicas estándar, las imágenes suelen aparecer a trozos o con parpadeo. Las aplicaciones Java permiten que los programas dibujen en memoria, para luego ir mostrando la imagen completa de forma suave. Este es el proceso conocido como doble-buffering, y tiene dos ventajas fundamentales sobre el proceso normal de pintar o dibujar directamente sobre la pantalla: 162
  • 163. Primero, el usuario ve aparecer de golpe la imagen en la pantalla. Mientras el usuario está viendo esa imagen, el programa está generando la siguiente para mostrarla de golpe a continuación, y así una y otra vez. Segundo, la técnica de doble-buffering involucra un objeto Image, que se puede pasar directamente a varios métodos. Esta capacidad para manipular objetos Image permite descomponer las rutinas de dibujo en componentes funcionales, en lugar de un enorme método paint(). No obstante, el doble-buffering sólo debe usarse para animaciones gráficas, no como método normal. Lo usual en otras aplicaciones sería repintar la zona que interese solamente. Contextos gráficos Para entender el doble-buffering, primero se necesita comprender qué es un contexto gráfico. Un contexto gráfico es simplemente una estructura de datos que el sistema sabe utilizar como tablero de dibujo, es decir, es la zona en que se va a pintar. Ya hemos visto y utilizado contextos gráfico en las declaraciones del método paint(): public void paint( Graphics g ) { El objeto Graphics g es el contexto gráfico. Se utiliza g para realizar todo el dibujo en el applet. Por ejemplo: g.drawString( quot;¡Hola!quot;,25,25 ); g.drawRect( 15,15,50,10 ); Entonces, Java traduce todo lo que se dibuja en g en imágenes sobre la pantalla. Para realizar doble-buffering, se necesita pues, primero crear un contexto gráfico que no es presentado inmediatamente en la pantalla. Creación de Contextos Gráficos Crear contextos gráficos tiene dos pasos: Crear una imagen vacía con las dimensiones adecuadas y obtener un objeto Graphics de esa imagen. El objeto Graphics que se construye en el segundo paso realiza la función de contexto gráfico. Por ejemplo, CGrafico.java: import java.awt.*; import java.applet.Applet; public class CGrafico extends Applet { Image dobleBuffer; Graphics miCG; public void init() { // Inicializa el doble buffer dobleBuffer = createImage( 300,300 ); miCG = dobleBuffer.getGraphics(); // Construye un área gráfica de trabajo miCG .setColor( Color.white ); miCG.fillRect( 0,0,300,300 ); 163
  • 164. resize( 500,450 ); } Podemos utilizar miCG para dibujar cualquier cosa. Las imágenes se trazarán en doble buffer. Cuando el dibujo esté terminado, se puede presentar el doble buffer en pantalla: public void paint( Graphics g ) { // Sólo se tiene que presentar la imagen del buffer g.drawImage( dobleBuffer,0,0,this ); } Utilización de Contextos Gráficos Una vez definido un contexto gráfico, podemos usarlo en cualquier parte de nuestro programa. Por ejemplo, podemos repartir la responsabilidad para dibujar sobre varias funciones: public void titulo() { // Obtiene la fuente de texto actual y la guardamos Font f = miCG.getFont(); // Seleccionamos otra fuente para el título miCG.setFont( new Font( quot;TimesRomanquot;.Font.BOLD,36 ) ); miCG.drawString( quot;Ejemplo de Espiralquot;,15,50 ); miCG.drawString( quot;Círculosquot;,15,90 ); // Recuperamos la fuente original miCG.setFont( f ); } public void espiral() { int x,y; // Dibujamos circulos en los lados horizontales y = 100; for( x=100; x <= 200; x+=10 ) { miCG.drawOval( x,y,20,20 ); miCG.drawOval( x,y+100,20,20 ); } // Ahora en los verticales x = 100; for( y=100; y <= 200; y+=10 ) { miCG.drawOval( x,y,20,20 ); miCG.drawOval( x+100,y,20,20 ); } } public void start() { // Hace el dibujo off-line titulo(); espiral(); // Ahora muestra la imagen de golpe repaint(); 164
  • 165. NUEVAS CLASES PARA DIBUJO La descomposición funcional de los métodos para dibujo proporcionados por el doble- buffering se pueden extender a otras clases. Por ejemplo, se puede diseñar una clase especializada en un tipo de salida (gráficos, informes, CAD, etc.). Pasándole el contexto gráfico como argumento al constructor, la nueva clase podrá construir la imagen. Esta clase puede ser reutilizada en cualquier otro applet que lo necesite. Por ejemplo, el código del fichero fuente EspiralTest.java siguiente muestra la clase Espiral. El applet espiral crea y usa un objeto Espiral. La representación en pantalla se construye enteramente en la nueva clase: import java.awt.*; import java.applet.Applet; // Clase de ejemplo para dibujar en contextos gráficos class Espiral { // Al ser privada, las variables son sólo accesibles por esta clase private int iniX,iniY,iniAncho,iniAlto; private int incremento; private Graphics cg; // constructor. crea una referencia local al buffer gráfico y define // el azul como color de los objetos que se dibujen sobre ella public Espiral( Graphics g ) { cg = g; cg.setColor( Color.blue ); } // Establece el tamaño y posición iniciales de la espiral public void setTamInicial( int x,int y,int w,int h ) { iniX = x; iniY = y; iniAncho = w; iniAlto = h; } // Establece el incremento para espaciar los giros public void setTamEspiral( int inc ) { incremento = inc; } // Construye la espiral public void creaEspiral() { int cX = iniX; int cY = iniY; // Dibuja líneas por pares, cubriéndose entre sí para formar la // espiral cuadrada hasta alcanzar el tamaño del incremento while( iniAncho > incremento && iniAlto > incremnto ) { g.drawLine( cX,cY,(cX+iniAncho),cY ); g.drawLine( (cX+iniAncho),Cy,(cX+iniAncho),(cY+iniAlto) ); cX += iniAncho; cY += iniAlto; iniAncho -= incremento; 165
  • 166. iniAlto -= incremento; g.drawLine( cX,cY,(cX-iniAncho),cY ); g.drawLine( (cX-iniAncho),Cy,(cX-iniAncho),(cY-iniAlto) ); cX -= iniAncho; cY -= iniAlto; iniAncho -= incremento; iniAlto -= incremento; } } } // Esta es la llamada a la clase desde un Applet Html public class EspiralTest extends Applet { Image buffer; Espiral spiral; boolean cargado = false; synchronized public void init() { // crea un buffer donde dibujar buffer = createImage( 300,300 ); // crea una nueva espiral spiral = new Espiral( buffer.getGraphics() ); // establece el punto inicial y dimensiones spiral.setTamInicial( 10,10,200,200 ); // establece el incremento spiral.setTamEspiral( 10 ); // construye la espiral spiral.creaEspiral(); } synchronized public void paint( Graphics g ) { g.drawImage( buffer,25,25,this ); } } LA CLASE MediaTracker Si nuestro applet tiene que tratar con imágenes almacenadas en ficheros gif/jpeg, tendremos que recurrir a la clase MediaTracker. Esta clase proporciona muchos métodos para manejar objetos multimedia y grupos de objetos. Manejo de Imágenes para Animación Combinando MediaTracker con la técnica de doble-buffering, se pueden conseguir animaciones. Estos son algunos métodos de MediaTracker útiles para ver gráficos void addImage( Image img,int id ) Marca la imagen como parte de un grupo de identificadores id. boolean checkID( int id ) Comprueba las imágenes pertenecientes al grupo id. Devuelve true si han sido cargadas todas, o false en otro caso (no carga los ficheros que falten). 166
  • 167. Se utiliza para saber cuando se han cargado todas las imágenes que componen una animación, antes de echarla a andar sobre la pantalla. boolean checkID( int id,boolean load ) Comprueba las imágenes pertenecientes al grupo id. Devuelve true si han sido cargadas todas, o false en otro caso. Carga las imágenes que falten si load es true. boolean checkAll( boolean load ) Comprueba todas las imágenes. Devuelve true si todas están cargadas, o false en otro caso. Carga las imágenes que falten si load es true. void waitForID( int id ) Espera a que se carguen todas las imágenes del grupo id. void waitForAll() Espera a que se carguen todas las imágenes. Se debería utilizar addImage() con cada imagen que necesite un applet. MediaTracker sólo supervisa imágenes asociadas mediante el método addImage(). Si se quiere saber si un determinado gráfico ha sido cargado, se pueden utilizar los métodos check. Si se quiere que un gráfico sea cargado antes de hacer cualquier otra cosa, usar los métodos waitFor. El uso de estos métodos es especialmente útil ya que cuando realizamos la carga de una imagen con getImage(), esta carga se realiza en un thread aparte del de nuestro applet, con lo cual, aunque la imagen se encuentre en el otro lado del mundo, getImage() devuelve inmediatamente el control con lo cual podemos comenzar la ejecución de la animación, sin haberse cargado todavía todas las imágenes. Creación de un Objeto MediaTracker Los objetos MediaTracker necesitan saber qué ImageObserver verá las imágenes que se están supervisando. Para los applets, el ImageObserver es el propio applet: miTracker = new MediaTracker( this ); Ahora ya se puede usar el objeto miTracker para manejar todas las imágenes de este applet. Ejemplo de animación Veamos ahora un ejemplo de animación, Taza.java. Utilizaremos MediaTracker para asegurarnos de que se cargan todas las imágenes. De este modo, cuando se ejecute la animación, no se verá parpadeo o que falta algún fotograma. Y el código siguiente es el que corresponde a la animación anterior: import java.awt.*; import java.applet.Applet; public class Taza extends Applet { Image Images[]; MediaTracker tracker; 167
  • 168. int index = 0; int maxAncho,maxAlto; // Componentes off-screen para el doble buffering Image offScrImage; Graphics offScrCG; boolean cargado = false; // Inicializa el applet. Establece el tamaño y carga las imágenes public void init() { // Establece el supervisor de imágenes y dimensiones tracker = new MediaTracker( this ); maxAncho = 78; maxAlto = 128; imagenes = new Image[6]; // Establece el doble buffer y cambia el tamaño del applet try { offScrImage = createImage( maxAnho,maxAlto ); offScrCG = offScrImage.getGraphics(); offScrCG.setColor( Color.lightGray ); offScrCG.fillRect( 0,0,maxAncho,maxAlto ); resize( maxAncho,maxAlto ); } catch( exception e ) { e.printStackTrace(); } // Carga las imágenes en un array for( int i=0; i < 33; i++ ) { String imageFich = new String( quot;tazaquot;+String.valueOf(i+1)+quot;.gifquot; ); imagenes[i] = getImage( getDocumentBase(),imageFich ); // Pasamos esta imagen al tracker tracker.addImage( imagenes[i],i ); } try { // Utilizamos el tracker para asegurar que se // cargaran todas las imágenes tracker.waitForAll(); } catch( InterruptedException e ) { } cargado = true; } // Pinta el fotograma actual public void paint( Graphics g ) { if( cargado ) { // Copia del doble buffer a la pantalla g.drawImage( offScrImage,0,0,this ); // Hacemos una pausa y cogemos la siguiente imagen timerloop(); } 168
  • 169. } // Establecemos la primera imagen public void start() { index = 0; if( tracker.checkID( index ) ) // Pintamos en el doble buffer offScrCG.drawImage( imagenes[index],0,0,this ); } // Actualiza los fotogramas para que avance la animación public void timerloop() { // Se asegura que la imagen esté presente y la mete en el buffer if( tracker.checkID( index ) ) { // Borra el fondo y obtiene la siguiente imagen offScrCG.fillRect( 0,0,100,100 ); offScrCG.drawImage( imagenes[index],0,0,this ); index++; // Vuelve al principio de la animación if( index <= images.length ) index = 0; } // Bucle de retardo for( int retardo=0; retardo < 200000; retardo++ ); // Dibujamos el siguiente fotograma repaint(); } } SONIDO EN JAVA Java también posee métodos predefinidos para reproducir sonido. El ordenador remoto no necesita tener un reproductor de audio; Java realizará la reproducción (evidentemente, el ordenador remoto, en donde se ejecuta el applet, necesitará disponer de hardware de sonido). Reproducción de sonido La forma más fácil de reproducir sonido es a través del método play(): play( URL directorioSonido,String ficheroSonido ); o, simplemente: play( URL unURLdeSonido ); Un URL común para el método play() es el directorio donde está el fichero HTML. Se puede acceder a esa localización a través del método getDocumentBase() de la clase Applet: play( getDocumentBase(),quot;sonido.auquot; ); 169
  • 170. para que esto funcione, el fichero de la clase y el fichero sonido.au deberían estar en el mismo directorio. En el applet Sonido.java, podemos ver el ejemplo completo. Su ponemos en él la existencia del fichero sonidos/gong.au: import java.awt.Graphics; import java.applet.Applet; public class Sonido extends Applet { public void paint( Graphics g ) { g.drawString( quot;Prueba de Sonidoquot;,25,25 ); play( getDocumentBase(),quot;sonidos/gong.auquot; ); } } Reproducción Repetitiva Se puede manejar el sonido como si de imágenes se tratara. Se pueden cargar y reproducir más tarde. Para cargar un clip de sonido, se utiliza el método getAudioClip(): AudoClip sonido; sonido = getAudioClip( getDocumentBase(),quot;risas.auquot; ); Una vez que se carga el clip de sonido, se pueden utilizar tres métodos: sonido.play(); para reproducir el clip de sonido. sonido.loop(); para iniciar la reproducción del clip de sonido y que entre en un blucle de reproducción, es decir, en una repetición automática del clip. sonido.stop(); para detener el clip de sonido que se encuentre en ese instante en reproducción. Veamos como en el applet Bucle.java utilizamos estos métodos para repetir automáticamente una pista de audio. import java.awt.Graphics; import java.applet.Applet; public class Bucle extends Applet { AudioClip sonido; public void init() { sonido = getAudioClip( getDocumentBase(),quot;sonidos/risas.auquot; ); } public void paint( Graphics g ) { g.drawString( quot;Prueba de Repeticiónquot;,25,25 ); } 170
  • 171. public void start() { sonido.loop(); } public void stop() { sonido.stop(); } } Y, finalmente, el applet ControlSonido.java, nos permite a través de una interface basada en botones, poder controlar la reproducción de audioclips. El checkbox de carga se usa como indicador para saber cuando el fichero que contiene el clip de sonido a reproducir, se encuentra ya cargado en el sistema. ENTRADA POR RATON Una de las características más útiles que ofrece Java es el soporte directo de la interactividad. La aplicación puede reaccionar a los cambios producidos en el ratón, por ejemplo, sin necesidad de escribir ninguna línea de código para su control, solamente indicando qué se quiere hacer cuando el ratón haga algo. El evento más común en el ratón es el click. Este evento es gobernado por dos métodos: mouseDown() (botón pulsado) y mouseUp() (botón soltado). Ambos métodos son parte de la clase Applet, pero se necesita definir sus acciones asociadas, de la misma forma que se realiza con init() o con paint(). public boolean mouseDown( Event evt,int x,int y ) { /* ratón pulsado en x,y */ /* hacer algo */ } public boolean mouseUp( Event evt,int x,int y ) { /* ratón soltado en x,y */ /* hacer algo */ } Para ambos métodos, las coordenadas x e y de la posición en que ha ocurrido el evento son relativas a la esquina superior izquierda del applet. En el applet Raton.java, se muestra la utilización del ratón para recibir las coordenadas en donde se ha pulsado el ratón, y será en esa posición donde se repinte el saludo habitual: import java.awt.*; import java.applet.Applet; public class Raton extends Applet { int ratonX = 25; int ratonY = 25; public void paint( Graphics g ) { g.drawString( quot;Hola Mundo!quot;,ratonX,ratonY ); } public boolean mouseDown( Event evt,int x, int y ) { ratonX = x; 171
  • 172. ratonY = y; repaint(); return true; } } Las excepciones en Java están destinadas, al igual que en el resto de los lenguajes que las soportan, para la detección y corrección de errores. Si hay un error, la aplicación no debería morirse y generar un core (o un crash en caso del DOS). Se debería lanzar (throw) una excepción que nosotros deberíamos capturar (catch) y resolver la situación de error. Java sigue el mismo modelo de excepciones que se utiliza en C++. Utilizadas en forma adecuada, las excepciones aumentan en gran medida la robustez de las aplicaciones. MANEJO DE EXCEPCIONES Vamos a mostrar como se utilizan las excepciones, reconvirtiendo nuestro applet de saludo a partir de la versión iterativa de HolaIte.java: import java.awt.*; import java.applet.Applet; public class HolaIte extends Applet { private int i = 0; private String Saludos[] = { quot;Hola Mundo!quot;, quot;HOLA Mundo!quot;, quot;HOLA MUNDO!!quot; }; public void paint( Graphics g ) { g.drawString( Saludos[i],25,25 ); i++; } } Normalmente, un programa termina con un mensaje de error cuando se lanza una excepción. Sin embargo, Java tiene mecanismos para excepciones que permiten ver qué excepción se ha producido e intentar recuperarse de ella. Vamos a reescribir el método paint() de nuestra versión iterativa del saludo: public void paint( Graphics g ) { try { g.drawString( Saludos[i],25,25 ); } catch( ArrayIndexOutOfBoundsException e ) { g.drawString( quot;Saludos desbordadoquot;,25,25 ); } catch( Exception e ) { // Cualquier otra excepción System.out.println( e.toString() ); } finally { System.out.println( quot;Esto se imprime siempre!quot; ); } i++; } La palabra clave finally define un bloque de código que se quiere que sea ejecutado siempre, de acuerdo a si se capturó la excepción o no. En el ejemplo anterior, la salida en la consola, con i=4 sería: 172
  • 173. Saludos desbordado ¡Esto se imprime siempre! GENERAR EXCEPCIONES EN JAVA Cuando se produce un error se debería generar, o lanzar, una excepción. Para que un método en Java, pueda lanzar excepciones, hay que indicarlo expresamente. void MetodoAsesino() throws NullPointerException,CaidaException Se pueden definir excepciones propias, no hay por qué limitarse a las predefinidas; bastará con extender la clase Exception y proporcionar la funcionalidad extra que requiera el tratamiento de esa excepción. También pueden producirse excepciones no de forma explícita como en el caso anterior, sino de forma implícita cuando se realiza alguna acción ilegal o no válida. Las excepciones, pues, pueden originarse de dos modos: el programa hace algo ilegal (caso normal), o el programa explícitamente genera una excepción ejecutando la sentencia throw (caso menos normal). La sentencia throw tiene la siguiente forma: throw ObtejoExcepction; El objeto ObjetoException es un objeto de una clase que extiende la clase Exception. El siguiente código de ejemplo origina una excepción de división por cero: class melon { public static void main( String[] a ) { int i=0, j=0, k; k = i/j; // Origina un error de division-by-zero } } Si compilamos y ejecutamos esta aplicación Java, obtendremos la siguiente salida por pantalla: > javac melon.java > java melon java.lang.ArithmeticException: / by zero at melon.main(melon.java:5) Las excepciones predefinidas, como ArithmeticException, se conocen como excepciones runtime. Actualmente, como todas las excepciones son eventos runtime, sería mejor llamarlas excepciones irrecuperables. Esto contrasta con las excepciones que generamos explícitamente, que suelen ser mucho menos severas y en la mayoría de los casos podemos recuperarnos de ellas. Por ejemplo, si un fichero no puede abrirse, preguntamos al usuario que nos indique otro fichero; o si una estructura de datos se encuentra completa, podremos sobreescribir algún elemento que ya no se necesite. 173
  • 174. EXCEPCIONES PREDEFINIDAS Las excepciones predefinidas y su jerarquía de clases es la que se muestra en la figura: Los nombres de las excepciones indican la condición de error que representan. Las siguientes son las excepciones predefinidas más frecuentes que se pueden encontrar: ArithmeticException Las excepciones aritméticas son típicamente el resultado de una división por 0: int i = 12 / 0; NullPointerException 174
  • 175. Se produce cuando se intenta acceder a una variable o método antes de ser definido: class Hola extends Applet { Image img; paint( Graphics g ) { g.drawImage( img,25,25,this ); } } IncompatibleClassChangeException El intento de cambiar una clase afectada por referencias en otros objetos, específicamente cuando esos objetos todavía no han sido recompilados. ClassCastException El intento de convertir un objeto a otra clase que no es válida. y = (Prueba)x; // donde x no es de tipo Prueba NegativeArraySizeException Puede ocurrir si hay un error aritmético al intentar cambiar el tamaño de un array. OutOfMemoryException ¡No debería producirse nunca! El intento de crear un objeto con el operador new ha fallado por falta de memoria. Y siempre tendría que haber memoria suficiente porque el garbage collector se encarga de proporcionarla al ir liberando objetos que no se usan y devolviendo memoria al sistema. NoClassDefFoundException Se referenció una clase que el sistema es incapaz de encontrar. ArrayIndexOutOfBoundsException Es la excepción que más frecuentemente se produce. Se genera al intentar acceder a un elemento de un array más allá de los límites definidos inicialmente para ese array. UnsatisfiedLinkException Se hizo el intento de acceder a un método nativo que no existe. Aquí no existe un método a.kk class A { native void kk(); } y se llama a a.kk(), cuando debería llamar a A.kk(). InternalException 175
  • 176. Este error se reserva para eventos que no deberían ocurrir. Por definición, el usuario nunca debería ver este error y esta excepción no debería lanzarse. CREAR EXCEPCIONES PROPIAS También podemos lanzar nuestras propias excepciones, extendiendo la clase System.exception. Por ejemplo, consideremos un programa cliente/servidor. El código cliente se intenta conectar al servidor, y durante 5 segundos se espera a que conteste el servidor. Si el servidor no responde, el servidor lanzaría la excepción de time-out: class ServerTimeOutException extends Exception {} public void conectame( String nombreServidor ) throws Exception { int exito; int puerto = 80; exito = open( nombreServidor,puerto ); if( exito == -1 ) throw ServerTimeOutException; } Si se quieren capturar las propias excepciones, se deberá utilizar la sentencia try: public void encuentraServidor() { ... try { conectame( servidorDefecto ); catch( ServerTimeOutException e ) { g.drawString( quot;Time-out del Servidor, intentando alternativaquot;, 5,5 ); conectame( servidorAlterno ); } ... } Cualquier método que lance una excepción también debe capturarla, o declararla como parte de la interface del método. Cabe preguntarse entonces, el porqué de lanzar una excepción si hay que capturarla en el mismo método. La respuesta es que las excepciones no simplifican el trabajo del control de errores. Tienen la ventaja de que se puede tener muy localizado el control de errores y no tenemos que controlar millones de valores de retorno, pero no van más allá. CAPTURAR EXCEPCIONES Las excepciones lanzadas por un método que pueda hacerlo deben recoger en bloque try/catch o try/finally. int valor; try { for( x=0,valor = 100; x < 100; x ++ ) valor /= x; } catch( ArithmeticException e ) { System.out.println( quot;Matemáticas locas!quot; ); 176
  • 177. } catch( Exception e ) { System.out.println( quot;Se ha producido un errorquot; ); } try Es el bloque de código donde se prevé que se genere una excepción. Es como si dijésemos quot;intenta estas sentencias y mira a ver si se produce una excepciónquot;. El bloque try tiene que ir seguido, al menos, por una cláusula catch o una cláusula finally catch Es el código que se ejecuta cuando se produce la excepción. Es como si dijésemos quot;controlo cualquier excepción que coincida con mi argumentoquot;. En este bloque tendremos que asegurarnos de colocar código que no genere excepciones. Se pueden colocar sentencias catch sucesivas, cada una controlando una excepción diferente. No debería intentarse capturar todas las excepciones con una sola cláusula, como esta: catch( Excepcion e ) { ... Esto representaría un uso demasiado general, podrían llegar muchas más excepciones de las esperadas. En este caso es mejor dejar que la excepción se propague hacia arriba y dar un mensaje de error al usuario. Se pueden controlar grupos de excepciones, es decir, que se pueden controlar, a través del argumento, excepciones semejantes. Por ejemplo: class Limites extends Exception {} class demasiadoCalor extends Limites {} class demasiadoFrio extends Limites {} class demasiadoRapido extends Limites {} class demasiadoCansado extends Limites {} . . . try { if( temp > 40 ) throw( new demasiadoCalor() ); if( dormir < 8 ) throw( new demasiado Cansado() ); } catch( Limites lim ) { if( lim instanceof demasiadoCalor ) { System.out.println( quot;Capturada excesivo calor!quot; ); return; } if( lim instanceof demasiadoCansado ) { System.out.println( quot;Capturada excesivo cansancio!quot; ); return; } } finally System.out.println( quot;En la clausula finallyquot; ); 177
  • 178. La cláusula catch comprueba los argumentos en el mismo orden en que aparezcan en el programa. Si hay alguno que coincida, se ejecuta el bloque. El operador instanceof se utiliza para identificar exactamente cual ha sido la identidad de la excepción. finally Es el bloque de código que se ejecuta siempre, haya o no excepción. Hay una cierta controversia entre su utilidad, pero, por ejemplo, podría servir para hacer un log o un seguimiento de lo que está pasando, porque como se ejecuta siempre puede dejarnos grabado si se producen excepciones y nos hemos recuperado de ellas o no. Este bloque finally puede ser útil cuando no hay ninguna excepción. Es un trozo de código que se ejecuta independientemente de lo que se haga en el bloque try. Cuando vamos a tratar una excepción, se nos plantea el problema de qué acciones vamos a tomar. En la mayoría de los casos, bastará con presentar una indicación de error al usuario y un mensaje avisándolo de que se ha producido un error y que decida si quiere o no continuar con la ejecución del programa. Por ejemplo, podríamos disponer de un diálogo como el que se presenta en el código siguiente: public class DialogoError extends Dialog { DialogoError( Frame padre ) { super( padre,true ); setLayout( new BorderLayout() ); // Presentamos un panel con continuar o salir Panel p = new Panel(); p.add( new Button( quot;¿Continuar?quot; ) ); p.add( new Button( quot;Salirquot; ) ); add( quot;Centerquot;,new Label( quot;Se ha producido un error. ¿Continuar?quot; ) ) add( quot;Southquot;,p ); } public boolean action( Event evt,Object obj ) { if( quot;Salirquot;.equals( obj ) ) { dispose(); System.exit( 1 ); } return false; } } Y la invocación, desde algún lugar en que se suponga que se generarán errores, podría ser como sigue: try { // Código peligroso } 178
  • 179. catch( AlgunaExcepcion e ) { VentanaError = new DialogoError( this ); VentanaError.show(); } PROPAGACION DE EXCEPCIONES La cláusula catch comprueba los argumentos en el mismo orden en que aparezcan en el programa. Si hay alguno que coincida, se ejecuta el bloque y sigue el flujo de control por el bloque finally (si lo hay) y concluye el control de la excepción. Si ninguna de las cláusulas catch coincide con la excepción que se ha producido, entonces se ejecutará el código de la cláusula finally (en caso de que la haya). Lo que ocurre en este caso, es exactamente lo mismo que si la sentencia que lanza la excepción no se encontrase encerrada en el bloque try. El flujo de control abandona este método y retorna prematuramente al método que lo llamó. Si la llamada estaba dentro del ámbito de una sentencia try, entonces se vuelve a intentar el control de la excepción, y así continuamente. Veamos lo que sucede cuando una excepción no es tratada en la rutina en donde se produce. El sistema Java busca un bloque try..catch más allá de la llamada, pero dentro del método que lo trajo aquí. Si la excepción se propaga de todas formas hasta lo alto de la pila de llamadas sin encontrar un controlador específico para la excepción, entonces la ejecución se detendrá dando un mensaje. Es decir, podemos suponer que Java nos está proporcionando un bloque catch por defecto, que imprime un mensaje de error y sale. No hay ninguna sobrecarga en el sistema por incorporar sentencias try al código. La sobrecarga se produce cuando se genera la excepción. Hemos dicho ya que un método debe capturar las excepciones que genera, o en todo caso, declararlas como parte de su llamada, indicando a todo el mundo que es capaz de generar excepciones. Esto debe ser así para que cualquiera que escriba una llamada a ese método esté avisado de que le puede llegar una excepción, en lugar del valor de retorno normal. Esto permite al programador que llama a ese método, elegir entre controlar la excepción o propagarla hacia arriba en la pila de llamadas. La siguiente línea de código muestra la forma general en que un método declara excepciones que se pueden propagar fuera de él: tipo_de_retorno( parametros ) throws e1,e2,e3 { } Los nombres e1,e2,... deben ser nombres de excepciones, es decir, cualquier tipo que sea asignable al tipo predefinido Throwable. Observar que, como en la llamada al método se especifica el tipo de retorno, se está especificando el tipo de excepción que puede generar (en lugar de un objeto exception). He aquí un ejemplo, tomado del sistema Java de entrada/salida: byte readByte() throws IOException; short readShort() throws IOException; char readChar() throws IOException; 179
  • 180. void writeByte( int v ) throws IOException; void writeShort( int v ) throws IOException; void writeChar( int v ) throws IOException; Lo más interesante aquí es que la rutina que lee un char, puede devolver un char; no el entero que se requiere en C. C necesita que se devuelva un int, para poder pasar cualquier valor a un char, y además un valor extra (-1) para indicar que se ha alcanzado el final del fichero. Algunas de las rutinas Java lanzan una excepción cuando se alcanza el fin del fichero. En el siguiente diagrama se muestra gráficamente cómo se propaga la excepción que se genera en el código, a través de la pila de llamadas durante la ejecución del código: Cuando se crea una nueva excepción, derivando de una clase Exception ya existente, se puede cambiar el mensaje que lleva asociado. La cadena de texto puede ser recuperada a través de un método. Normalmente, el texto del mensaje proporcionará información para resolver el problema o sugerirá una acción alternativa. Por ejemplo: class SinGasolina extends Exception { SinGasolina( String s ) { // constructor super( s ); } .... // Cuando se use, aparecerá algo como esto try { if( j < 1 ) throw new SinGasolina( quot;Usando deposito de reservaquot; ); } catch( SinGasolina e ) { System.out.println( o.getMessage() ); 180
  • 181. } Esto, en tiempo de ejecución originaría la siguiente salida por pantalla: > Usando deposito de reserva Otro método que es heredado de la superclase Throwable es printStackTrace(). Invocando a este método sobre una excepción se volcará a pantalla todas las llamadas hasta el momento en donde se generó la excepción (no donde se maneje la excepción). Por ejemplo: // Capturando una excepción en un método class testcap { static int slice0[] = { 0,1,2,3,4 }; public static void main( String a[] ) { try { uno(); } catch( Exception e ) { System.out.println( quot;Captura de la excepcion en main()quot; ); e.printStackTrace(); } } static void uno() { try { slice0[-1] = 4; } catch( NullPointerException e ) { System.out.println( quot;Captura una excepcion diferentequot; ); } } } Cuando se ejecute ese código, en pantalla observaremos la siguiente salida: > Captura de la excepcion en main() > java.lang.ArrayIndexOutOfBoundsException: -1 at testcap.uno(test5p.java:19) at testcap.main(test5p.java:9) Con todo el manejo de excepciones podemos concluir que proporciona un método más seguro para el control de errores, además de representar una excelente herramienta para organizar en sitios concretos todo el manejo de los errores y, además, que podemos proporcionar mensajes de error más decentes al usuario indicando qué es lo que ha fallado y por qué, e incluso podemos, a veces, recuperarnos de los errores. La degradación que se produce en la ejecución de programas con manejo de excepciones está ampliamente compensada por las ventajas que representa en cuanto a seguridad de funcionamiento de esos mismos programas. 181
  • 182. THREADS Y MULTITHREADING Considerando el entorno multithread, cada thread (hilo, flujo de control del programa) representa un proceso individual ejecutándose en un sistema. A veces se les llama procesos ligeros o contextos de ejecución. Típicamente, cada thread controla un único aspecto dentro de un programa, como puede ser supervisar la entrada en un determinado periférico o controlar toda la entrada/salida del disco. Todos los threads comparten los mismos recursos, al contrario que los procesos en donde cada uno tiene su propia copia de código y datos (separados unos de otros). Gráficamente, los threads se parecen en su funcionamiento a lo que muestra la figura siguiente: FLUJO EN PROGRAMAS Programas de flujo único Un programa de flujo único o mono-hilvanado (single-thread) utiliza un único flujo de control (thread) para controlar su ejecución. Muchos programas no necesitan la potencia o utilidad de múltiples flujos de control. Sin necesidad de especificar explícitamente que se quiere un único flujo de control, muchos de los applets y aplicaciones son de flujo único. Por ejemplo, en nuestra aplicación estándar de saludo: public class HolaMundo { static public void main( String args[] ) { System.out.println( quot;Hola Mundo!quot; ); } } Aquí, cuando se llama a main(), la aplicación imprime el mensaje y termina. Esto ocurre dentro de un único thread. Programas de flujo múltiple 182
  • 183. En nuestra aplicación de saludo, no vemos el thread que ejecuta nuestro programa. Sin embargo, Java posibilita la creación y control de threads explícitamente. La utilización de threads en Java, permite una enorme flexibilidad a los programadores a la hora de plantearse el desarrollo de aplicaciones. La simplicidad para crear, configurar y ejecutar threads, permite que se puedan implementar muy poderosas y portables aplicaciones/applets que no se puede con otros lenguajes de tercera generación. En un lenguaje orientado a Internet como es Java, esta herramienta es vital. Si se ha utilizado un navegador con soporte Java, ya se habrá visto el uso de múltiples threads en Java. Habrá observado que dos applet se pueden ejecutar al mismo tiempo, o que puede desplazar la página del navegador mientras el applet continúa ejecutándose. Esto no significa que el applet utilice múltiples threads, sino que el navegador es multithreaded. Las aplicaciones (y applets) multithreaded utilizan muchos contextos de ejecución para cumplir su trabajo. Hacen uso del hecho de que muchas tareas contienen subtareas distintas e independientes. Se puede utilizar un thread para cada subtarea. Mientras que los programas de flujo único pueden realizar su tarea ejecutando las subtareas secuencialmente, un programa multithreaded permite que cada thread comience y termine tan pronto como sea posible. Este comportamiento presenta una mejor respuesta a la entrada en tiempo real. Vamos a modificar nuestro programa de saludo creando tres threads individuales, que imprimen cada uno de ellos su propio mensaje de saludo, MultiHola.java: // Definimos unos sencillos threads. Se detendrán un rato // antes de imprimir sus nombres y retardos class TestTh extends Thread { private String nombre; private int retardo; // Constructor para almacenar nuestro nombre // y el retardo public TestTh( String s,int d ) { nombre = s; retardo = d; } // El metodo run() es similar al main(), pero para // threads. Cuando run() termina el thread muere public void run() { // Retasamos la ejecución el tiempo especificado try { sleep( retardo ); } catch( InterruptedException e ) { ; } // Ahora imprimimos el nombre System.out.println( quot;Hola Mundo! quot;+nombre+quot; quot;+retardo ); } } 183
  • 184. public class MultiHola { public static void main( String args[] ) { TestTh t1,t2,t3; // Creamos los threads t1 = new TestTh( quot;Thread 1quot;,(int)(Math.random()*2000) ); t2 = new TestTh( quot;Thread 2quot;,(int)(Math.random()*2000) ); t3 = new TestTh( quot;Thread 3quot;,(int)(Math.random()*2000) ); // Arrancamos los threads t1.start(); t2.start(); t3.start(); } } Y ya mßs como espectáculo que otra cosa, aunque también podemos tomarlo por el lado ilustrativo, vemos a continuación la elecución del applet Figuras.java que muestra un montón de círculos, cada uno de ellos ejecutándose en un thread diferente y con distinta prioridad cada uno de ellos. La clase Circulo es la que se utiliza para lanzarla todas las veces que se quiere, de tal forma que cada uno de los círculos presentes en el applet son instancias de la misma clase Circulo. CREACION Y CONTROL DE THREADS Creación de un Thread Hay dos modos de conseguir threads en Java. Una es implementando la interface Runnable, la otra es extender la clase Thread. La implementación de la interface Runnable es la forma habitual de crear threads. Las interfaces proporcionan al programador una forma de agrupar el trabajo de infraestructura de una clase. Se utilizan para diseñar los requerimientos comunes al conjunto de clases a implementar. La interface define el trabajo y la clase, o clases, que implementan la interface realizan ese trabajo. Los diferentes grupos de clases que implementen la interface tendrán que seguir las mismas reglas de funcionamiento. Hay una cuantas diferencias entre interface y clase. Primero, una interface solamente puede contener métodos abstractos y/o variables estáticas y finales (constantes). Las clases, por otro lado, pueden implementar métodos y contener variables que no sean constantes. Segundo, una interface no puede implementar cualquier método. Una clase que implemente una interface debe implementar todos los métodos definidos en esa interface. Una interface tiene la posibilidad de poder extenderse de otras interfaces y, al contrario que las clases, puede extenderse de múltiples interfaces. Además, una interface no puede ser instanciada con el operador new; por ejemplo, la siguiente sentencia no está permitida: Runnable a = new Runnable(); // No se permite El primer método de crear un thread es simplemente extender la clase Thread: class MiThread extends Thread { public void run() { . . . 184
  • 185. } El ejemplo anterior crea una nueva clase MiThread que extiende la clase Thread y sobrecarga el método Thread.run() por su propia implementación. El método run() es donde se realizará todo el trabajo de la clase. Extendiendo la clase Thread, se pueden heredar los métodos y variables de la clase padre. En este caso, solamente se puede extender o derivar una vez de la clase padre. Esta limitación de Java puede ser superada a través de la implementación de Runnable: public class MiThread implements Runnable { Thread t; public void run() { // Ejecución del thread una vez creado } } En este caso necesitamos crear una instancia de Thread antes de que el sistema pueda ejecutar el proceso como un thread. Además, el método abstracto run() está definido en la interface Runnable tiene que ser implementado. La única diferencia entre los dos métodos es que este último es mucho más flexible. En el ejemplo anterior, todavía tenemos oportunidad de extender la clase MiThread, si fuese necesario. La mayoría de las clases creadas que necesiten ejecutarse como un thread , implementarán la interface Runnable, ya que probablemente extenderán alguna de su funcionalidad a otras clases. No pensar que la interface Runnable está haciendo alguna cosa cuando la tarea se está ejecutando. Solamente contiene métodos abstractos, con lo cual es una clase para dar idea sobre el diseño de la clase Thread. De hecho, si vemos los fuentes de Java, podremos comprobar que solamente contiene un método abstracto: package java.lang; public interface Runnable { public abstract void run() ; } Y esto es todo lo que hay sobre la interface Runnable. Como se ve, una interface sólo proporciona un diseño para las clases que vayan a ser implementadas. En el caso de Runnable, fuerza a la definición del método run(), por lo tanto, la mayor parte del trabajo se hace en la clase Thread. Un vistazo un poco más profundo a la definición de la clase Thread nos da idea de lo que realmente está pasando: public class Thread implements Runnable { ... public void run() { if( tarea != null ) tarea.run() ; } } ... } De este trocito de código se desprende que la clase Thread también implemente la interface Runnable. tarea.run() se asegura de que la clase con que trabaja (la clase que va a ejecutarse como un thread) no sea nula y ejecuta el método run() de esa clase. Cuando esto suceda, el método run() de la clase hará que corra como un thread. 185
  • 186. Arranque de un Thread Las aplicaciones ejecutan main() tras arrancar. Esta es la razón de que main() sea el lugar natural para crear y arrancar otros threads. La línea de código: t1 = new TestTh( quot;Thread 1quot;,(int)(Math.random()*2000) ); crea un nuevo thread. Los dos argumentos pasados representan el nombre del thread y el tiempo que queremos que espere antes de imprimir el mensaje. Al tener control directo sobre los threads, tenemos que arrancarlos explícitamente. En nuestro ejemplo con: t1.start(); start(), en realidad es un método oculto en el thread que llama al método run(). Manipulación de un Thread Si todo fue bien en la creación del thread, t1 debería contener un thread válido, que controlaremos en el método run(). Una vez dentro de run(), podemos comenzar las sentencias de ejecución como en otros programas. run() sirve como rutina main() para los threads; cuando run() termina, también lo hace el thread. Todo lo que queramos que haga el thread ha de estar dentro de run(), por eso cuando decimos que un método es Runnable, nos obliga a escribir un método run(). En este ejemplo, intentamos inmediatamente esperar durante una cantidad de tiempo aleatoria (pasada a través del constructor): sleep( retardo ); El método sleep() simplemente le dice al thread que duerma durante los milisegundos especificados. Se debería utilizar sleep() cuando se pretenda retrasar la ejecución del thread. sleep() no consume recursos del sistema mientras el thread duerme. De esta forma otros threads pueden seguir funcionando. Una vez hecho el retardo, se imprime el mensaje quot;Hola Mundo!quot; con el nombre del thread y el retardo. Suspensión de un Thread Puede resultar útil suspender la ejecución de un thread sin marcar un límite de tiempo. Si, por ejemplo, está construyendo un applet con un thread de animación, querrá permitir al usuario la opción de detener la animación hasta que quiera continuar. No se trata de terminar la animación, sino desactivarla. Para este tipo de control de thread se puede utilizar el método suspend(). t1.suspend(); Este método no detiene la ejecución permanentemente. El thread es suspendido indefinidamente y para volver a activarlo de nuevo necesitamos realizar una invocación al método resume(): t1.resume(); Parada de un Thread 186
  • 187. El último elemento de control que se necesita sobre threads es el método stop(). Se utiliza para terminar la ejecución de un thread: t1.stop(); Esta llamada no destruye el thread, sino que detiene su ejecución. La ejecución no se puede reanudar ya con t1.start(). Cuando se desasignen las variables que se usan en el thread, el objeto thread (creado con new) quedará marcado para eliminarlo y el garbage collector se encargará de liberar la memoria que utilizaba. En nuestro ejemplo, no necesitamos detener explícitamente el thread. Simplemente se le deja terminar. Los programas más complejos necesitarán un control sobre cada uno de los threads que lancen, el método stop() puede utilizarse en esas situaciones. Si se necesita, se puede comprobar si un thread está vivo o no; considerando vivo un thread que ha comenzado y no ha sido detenido. t1.isAlive(); Este método devolverá true en caso de que el thread t1 esté vivo, es decir, ya se haya llamado a su método run() y no haya sido parado con un stop() ni haya terminado el método run() en su ejecución. ARRANCAR Y PARAR THREADS Ahora que ya hemos visto por encima como se arrancan, paran y manipulan threads, vamos a mostrar un ejemplo un poco más gráfico, se trata de un contador, cuyo código (App1Thread.java) es el siguiente: import java.awt.*; import java.applet.Applet; public class App1Thread extends Applet implements Runnable { Thread t; int contador; public void init() { contador = 0; t = new Thread( this ); t.start(); } public void run() { while( true ) { contador++; repaint(); try { t.sleep( 10 ); } catch( InterruptedException e ) { ; }; } } public boolean mouseDown( Event evt,int x,int y ) { 187
  • 188. t.stop(); return( true ); } public void paint( Graphics g ) { g.drawString( Integer.toString( contador ),10,10 ); System.out.println( quot;Contador = quot;+contador ); } public void stop() { t.stop(); } } Este applet arranca un contador en 0 y lo incrementa, presentando su salida tanto en la pantalla gráfica como en la consola. Una primera ojeada al código puede dar la impresión de que el programa empezará a contar y presentará cada número, pero no es así. Una revisión más profunda del flujo de ejecución del applet, nos revelará su verdadera identidad. En este caso, la clase App1Thread está forzada a implementar Runnable sobre la clase Applet que extiende. Como en todos los applets, el método init() es el primero que se ejecuta. En init(), la variable contador se inicializa a cero y se crea una nueva instancia de la clase Thread. Pasándole this al constructor de Thread, el nuevo thread ya conocerá al objeto que va a correr. En este caso this es una referencia a App1Thread. Después de que hayamos creado el thread, necesitamos arrancarlo. La llamada a start(), llamará a su vez al método run() de nuestra clase, es decir, a App1Thread.run(). La llamada a start() retornará con éxito y el thread comenzará a ejecutarse en ese instante. Observar que el método run() es un bucle infinito. Es infinito porque una vez que se sale de él, la ejecución del thread se detiene. En este método se incrementará la variable contador, se duerme 10 milisegundos y envía una petición de refresco del nuevo valor al applet. Es muy importante dormirse en algún lugar del thread, porque sino, el thread consumirá todo el tiempo de la CPU para su proceso y no permitirá que entren otros métodos de otros threads a ejecutarse. Otra forma de detener la ejecución del thread es hacer una llamada al método stop(). En el contador, el thread se detiene cuando se pulsa el ratón mientras el cursor se encuentre sobre el applet. Dependiendo de la velocidad del ordenador, se presentarán los números consecutivos o no, porque el incremento de la variable contador es independiente del refresco en pantalla. El applet no se refresca a cada petición que se le hace, sino que el sistema operativo encolará las peticiones y las que sean sucesivas las convertirán en un único refresco. Así, mientras los refescos se van encolando, la variable contador se estará todavía incrementando, pero no se visualiza en pantalla. SUSPENDER Y REANUDAR THREADS Una vez que se para un thread, ya no se puede rearrancar con el comando start(), debido a que stop() concluirá la ejecución del thread. Por ello, en ver de parar el thread, lo que podemos hacer es dormirlo, llamando al método sleep(). El thread estará suspendido un cierto tiempo y luego reanudará su ejecución cuando el límite fijado se alcance. Pero esto no es útil cuando se necesite que el thread reanude su ejecución ante la presencia de ciertos 188
  • 189. eventos. En estos casos, el método suspend() permite que cese la ejecución del thread y el método resume() permite que un método suspendido reanude su ejecución. En la siguiente versión de nuestra clase contador, App2Thread.java, modificamos el applet para que utilice los métodos suspend() y resume(): public class App2Thread extends Applet implements Runnable { Thread t; int contador; boolean suspendido; ... public boolean mouseDown( Event evt,int x,int y ) { if( suspendido ) t.resume(); else t.suspend(); suspendido = !suspendido; return( true ); } ... Para controlar el estado del applet, hemos introducido la variable suspendido. Diferenciar los distintos estados de ejecución del applet es importante porque algunos métodos pueden generar excepciones si se llaman desde un estado erróneo. Por ejemplo, si el applet ha sido arrancado y se detiene con stop(), si se intenta ejecutar el método start(), se generará una excepción IllegalThreadStateException. ESTADOS DE UN THREAD Durante el ciclo de vida de un thread, éste se puede encontrar en diferentes estados. La figura siguiente muestra estos estados y los métodos que provocan el paso de un estado a otro. Este diagrama no es una máquina de estados finita, pero es lo que más se aproxima al funcionamiento real de un thread . 189
  • 190. Nuevo Thread La siguiente sentencia crea un nuevo thread pero no lo arranca, lo deja en el estado de quot;Nuevo Threadquot;: Thread MiThread = new MiClaseThread(); Cuando un thread está en este estado, es simplemente un objeto Thread vacío. El sistema no ha destinado ningún recurso para él. Desde este estado solamente puede arrancarse llamando al método start(), o detenerse definitivamente, llamando al método stop(); la llamada a cualquier otro método carece de sentido y lo único que provocará será la generación de una excepción de tipo IllegalThreadStateException. Ejecutable Ahora veamos las dos línea de código que se presentan a continuación: Thread MiThread = new MiClaseThread(); MiThread.start(); La llamada al método start() creará los recursos del sistema necesarios para que el thread puede ejecutarse, lo incorpora a la lista de procesos disponibles para ejecución del sistema y llama al método run() del thread. En este momento nos encontramos en el estado quot;Ejecutablequot; del diagrama. Y este estado es Ejecutable y no En Ejecución, porque cuando el thread está aquí no esta corriendo. Muchos ordenadores tienen solamente un procesador lo que hace imposible que todos los threads estén corriendo al mismo tiempo. Java implementa un tipo de scheduling o lista de procesos, que permite que el procesador sea compartido entre todos los procesos o threads que se encuentran en la lista. Sin embargo, para nuestros propósitos, y en la mayoría de los casos, se puede considerar que este estado es realmente un estado quot;En Ejecuciónquot;, porque la impresión que produce ante nosotros es que todos los procesos se ejecutan al mismo tiempo. Cuando el thread se encuentra en este estado, todas las instrucciones de código que se encuentren dentro del bloque declarado para el método run(), se ejecutarán secuencialmente. Parado El thread entra en estado quot;Paradoquot; cuando alguien llama al método suspend(), cuando se llama al método sleep(), cuando el thread está bloqueado en un proceso de entrada/salida o cuando el thread utiliza su método wait() para esperar a que se cumpla una determinada condición. Cuando ocurra cualquiera de las cuatro cosas anteriores, el thread estará Parado. Por ejemplo, en el trozo de código siguiente: Thread MiThread = new MiClaseThread(); MiThread.start(); try { MiThread.sleep( 10000 ); } catch( InterruptedException e ) { ; 190
  • 191. } 7la línea de código que llama al método sleep(): MiThread.sleep( 10000 ); hace que el thread se duerma durante 10 segundos. Durante ese tiempo, incluso aunque el procesador estuviese totalmente libre, MiThread no correría. Después de esos 10 segundos. MiThread volvería a estar en estado quot;Ejecutablequot; y ahora sí que el procesador podría hacerle caso cuando se encuentre disponible. Para cada una de los cuatro modos de entrada en estado Parado, hay una forma específica de volver a estado Ejecutable. Cada forma de recuperar ese estado es exclusiva; por ejemplo, si el thread ha sido puesto a dormir, una vez transcurridos los milisegundos que se especifiquen, él solo se despierta y vuelve a estar en estado Ejecutable. Llamar al método resume() mientras esté el thread durmiendo no serviría para nada. Los métodos de recuperación del estado Ejecutable, en función de la forma de llegar al estado Parado del thread, son los siguientes: • Si un thread está dormido, pasado el lapso de tiempo • Si un thread está suspendido, luego de una llamada al método resume() • Si un thread está bloqueado en una entrada/salida, una vez que el comando E/S concluya su ejecución • Si un thread está esperando por una condición, cada vez que la variable que controla esa condición varíe debe llamarse a notify() o notifyAll() Muerto Un thread se puede morir de dos formas: por causas naturales o porque lo maten (con stop()). Un thread muere normalmente cuando concluye de forma habitual su método run(). Por ejemplo, en el siguiente trozo de código, el bucle while es un bucle finito -realiza la iteración 20 veces y termina-: public void run() { int i=0; while( i < 20 ) { i++; System.out.println( quot;i = quot;+i ); } } Un thread que contenga a este método run(), morirá naturalmente después de que se complete el bucle y run() concluya. También se puede matar en cualquier momento un thread, invocando a su método stop(). En el trozo de código siguiente: Thread MiThread = new MiClaseThread(); 191
  • 192. MiThread.start(); try { MiThread.sleep( 10000 ); } catch( InterruptedException e ) { ; } MiThread.stop(); se crea y arranca el thread MiThread, lo dormimos durante 10 segundos y en el momento de despertarse, la llamada a su método stop(), lo mata. El método stop() envía un objeto ThreadDeath al thread que quiere detener. Así, cuando un thread es parado de este modo, muere asíncronamente. El thread morirá en el momento en que reciba la excepción ThreadDeath. Los applets utilizarán el método stop() para matar a todos sus threads cuando el navegador con soporte Java en el que se están ejecutando le indica al applet que se detengan, por ejemplo, cuando se minimiza la ventana del navegador o cuando se cambia de página. El método isAlive() La interface de programación de la clase Thread incluye el método isAlive(), que devuelve true si el thread ha sido arrancado (con start()) y no ha sido detenido (con stop()). Por ello, si el método isAlive() devuelve false, sabemos que estamos ante un quot;Nuevo Threadquot; o ante un thread quot;Muertoquot;. Si nos devuelve true, sabemos que el thread se encuentra en estado quot;Ejecutablequot; o quot;Paradoquot;. No se puede diferenciar entre quot;Nuevo Threadquot; y quot;Muertoquot;, ni entre un thread quot;Ejecutablequot; o quot;Paradoquot;. SCHEDULING Java tiene un Scheduler, una lista de procesos, que monitoriza todos los threads que se están ejecutando en todos los programas y decide cuales deben ejecutarse y cuales deben encontrarse preparados para su ejecución. Hay dos características de los threads que el scheduler identifica en este proceso de decisión. Una, la más importante, es la prioridad del thread; la otra, es el indicador de demonio. La regla básica del scheduler es que si solamente hay threads demonio ejecutándose, la Máquina Virtual Java (JVM) concluirá. Los nuevos threads heredan la prioridad y el indicador de demonio de los threads que los han creado. El scheduler determina qué threads deberán ejecutarse comprobando la prioridad de todos los threads, aquellos con prioridad más alta dispondrán del procesador antes de los que tienen prioridad más baja. El scheduler puede seguir dos patrones, preemptivo y no-preemptivo. Los schedulers preemtivos proporcionan un segmento de tiempo a todos los threads que están corriendo en el sistema. El scheduler decide cual será el siguiente thread a ejecutarse y llama a resume() para darle vida durante un período fijo de tiempo. Cuando el thread ha estado en ejecución ese período de tiempo, se llama a suspend() y el siguiente thread en la lista de procesos será relanzado (resume()). Los schedulers no-preemtivos deciden que thread debe correr y lo ejecutan hasta que concluye. El thread tiene control total sobre el sistema mientras esté en ejecución. El método yield() es la forma en que un thread fuerza al scheduler a comenzar la 192
  • 193. ejecución de otro thread que esté esperando. Dependiendo del sistema en que esté corriendo Java, el scheduler será preemtivo o no-preemptivo. En el siguiente ejemplo, SchThread.java, mostramos la ejecución de dos threads con diferentes prioridades. Un thread se ejecuta a prioridad más baja que el otro. Los threads incrementarán sus contadores hasta que el thread que tiene prioridad más alta alcance al contador que corresponde a la tarea con ejecución más lenta. PRIORIDADES, DEMONIOS... Prioridades El scheduler determina el thread que debe ejecutarse en función de la prioridad asignada a cada uno de ellos. El rango de prioridades oscila entre 1 y 10. La prioridad por defecto de un thread es Thread.NORM_PRIORITY, que tiene asignado un valor de 5. Hay otras dos variables estáticas disponibles, que son Thread.MIN_PRORITY, fijada a 1, y Thread.MAX_PRIORITY, aque tiene un valor de 10. El método getPriority() puede utilizarse para conocer el valor actual de la prioridad de un thread. Threads Demonio Los threads demonio también se llaman servicios, porque se ejecutan, normalmente, con prioridad baja y proporcionan un servicio básico a un programa o programas cuando la actividad de la máquina es reducida. Un ejemplo de thread demonio que está ejecutándose continuamente es el recolector de basura (garbage collector). Este thread, proporcionado por la Máquina Virtual Java, comprueba las variables de los programas a las que no se accede nunca y libera estos recursos, devolviéndolos al sistema. Un thread puede fijar su indicador de demonio pasando un valor true al método setDaemon(). Si se pasa false a este método, el thread será devuelto por el sistema como un thread de usuario. No obstante, esto último debe realizarse antes de que se arranque el thread (start()). Diferencia de threads con fork() fork() en Unix crea un proceso hijo que tiene su propia copia de datos y código del padre. Esto funciona correctamente si estamos sobrados de memoria y disponemos de una CPU poderosa, y siempre que mantengamos el número de procesos hijos dentro de un límite manejable, porque se hace un uso intensivo de los recursos del sistema. Los applets Java no pueden lanzar ningún proceso en el cliente, porque eso sería una fuente de inseguridad y no está permitido. Las aplicaciones y los applets deben utilizar threads. La multi-tarea pre-emptiva tiene sus problemas. Un thread puede interrumpir a otro en cualquier momento, de ahí lo de pre-emptive. Imaginarse lo que pasaría si un thread está escribiendo en un array, mientras otro thread lo interrumpe y comienza a escribir en el mismo array. Los lenguajes como C y C++ necesitan de las funciones lock() y unlock() para antes y después de leer o escribir datos. Java también funciona de este modo, pero oculta el bloqueo de datos bajo la sentencia synchronized: synchronized int MiMetodo(); 193
  • 194. Otro área en que los threads son muy útiles es en los interfaces de usuario. Permiten incrementar la respuesta del ordenador ante el usuario cuando se encuentra realizando complicados cálculos y no puede atender a la entrada de usuario. Estos cálculos se pueden realizar en segundo plano, o realizar varios en primer plano (música y animaciones) sin que se dé apariencia de pérdida de rendimiento. EJEMPLO DE ANIMACION Este es un ejemplo de un applet, Animacion.java, que crea un thread de animación que nos presenta el globo terráqueo en rotación. Aquí podemos ver que estamos creando un thread de sí mismo, concurrencia. Además, animacion.start() llama al start() del thread, no del applet, que automáticamente llamará a run(): import java.awt.*; import java.applet.Applet; public class Animacion extends Applet implements Runnable { Image imagenes[]; MediaTracker tracker; int indice = 0; Thread animacion; int maxAncho,maxAlto; Image offScrImage; // Componente off-screen para doble buffering Graphics offScrGC; // Nos indicará si ya se puede pintar boolean cargado = false; // Inicializamos el applet, establecemos su tamaño y // cargamos las imágenes public void init() { // Establecemos el supervisor de imágenes tracker = new MediaTracker( this ); // Fijamos el tamaño del applet maxAncho = 100; maxAlto = 100; imagenes = new Image[36]; // Establecemos el doble buffer y dimensionamos el applet try { offScrImage = createImage( maxAncho,maxAlto ); offScrGC = offScrImage.getGraphics(); offScrGC.setColor( Color.lightGray ); offScrGC.fillRect( 0,0,maxAncho,maxAlto ); resize( maxAncho,maxAlto ); } catch( Exception e ) { e.printStackTrace(); } // Cargamos las imágenes en un array for( int i=0; i < 36; i++ ) { String fichero = new String( quot;Tierraquot;+String.valueOf(i+1)+quot;.gifquot; ); 194
  • 195. imagenes[i] = getImage( getDocumentBase(),fichero ); // Registramos las imágenes con el tracker tracker.addImage( imagenes[i],i ); } try { // Utilizamos el tracker para comprobar que todas las // imágenes están cargadas tracker.waitForAll(); } catch( InterruptedException e ) { ; } cargado = true; } // Pintamos el fotograma que corresponda public void paint( Graphics g ) { if( cargado ) g.drawImage( offScrImage,0,0,this ); } // Arrancamos y establecemos la primera imagen public void start() { if( tracker.checkID( indice ) ) offScrGC.drawImage( imagenes[indice],0,0,this ); animacion = new Thread( this ); animacion.start(); } // Aquí hacemos el trabajo de animación // Muestra una imagen, para, muestra la siguiente... public void run() { // Obtiene el identificador del thread Thread thActual = Thread.currentThread(); // Nos aseguramos de que se ejecuta cuando estamos en un // thread y además es el actual while( animacion != null && animacion == thActual ) { if( tracker.checkID( indice ) ) { // Obtenemos la siguiente imagen offScrGC.drawImage( imagenes[indice],0,0,this ); indice++; // Volvemos al principio y seguimos, para el bucle if( indice >= imagenes.length ) indice = 0; } // Ralentizamos la animación para que parezca normal try { animacion.sleep( 200 ); } catch( InterruptedException e ) { ; } // Pintamos el siguiente fotograma repaint(); 195
  • 196. } } } En el ejemplo podemos observar más cosas. La variable thActual es propia de cada thread que se lance, y la variable animacion la estarán viendo todos los threads. No hay duplicidad de procesos, sino que todos comparten las mismas variables; cada thread, sin embargo, tiene su pila local de variables, que no comparte con nadie y que son las que están declaradas dentro de las llaves del método run(). La excepción InterruptedExcepcion salta en el caso en que se haya tenido al thread parado más tiempo del debido. Es imprescindible recoger esta excepción cuando se están implementando threads, tanto es así, que en el caso de no recogerla, el compilador generará un error. COMUNICACION ENTRE THREADS Otra clave para el éxito y la ventaja de la utilización de múltiples threads en una aplicación, o aplicación multithreaded, es que pueden comunicarse entre sí. Se pueden diseñar threads para utilizar objetos comunes, que cada thread puede manipular independientemente de los otros threads. El ejemplo clásico de comunicación de threads es un modelo productor/consumidor. Un thread produce una salida, que otro thread usa (consume), sea lo que sea esa salida. Vamos entonces a crear un productor, que será un thread que irá sacando caracteres por su salida; crearemos también un consumidor que ira recogiendo los caracteres que vaya sacando el productor y un monitor que controlará el proceso de sincronización entre los threads. Funcionará como una tubería, insertando el productor caracteres en un extremos y leyéndolos el consumidor en el otro, con el monitor siendo la propia tubería. Productor El productor extenderá la clase Thread, y su código es el siguiente: class Productor extends Thread { private Tuberia tuberia; private String alfabeto = quot;ABCDEFGHIJKLMNOPQRSTUVWXYZquot;; public Productor( Tuberia t ) { // Mantiene una copia propia del objeto compartido tuberia = t; } public void run() { 196
  • 197. char c; // Mete 10 letras en la tubería for( int i=0; i < 10; i++ ) { c = alfabeto.charAt( (int)(Math.random()*26 ) ); tuberia.lanzar( c ); // Imprime un registro con lo añadido System.out.println( quot;Lanzado quot;+c+quot; a la tuberia.quot; ); // Espera un poco antes de añadir más letras try { sleep( (int)(Math.random() * 100 ) ); } catch( InterruptedException e ) { ; } } } } Notar que creamos una instancia de la clase Tuberia, y que se utiliza el método tuberia.lanzar() para que se vaya construyendo la tubería, en principio de 10 caracteres. Consumidor Veamos ahora el código del consumidor, que también extenderá la clase Thread: class Consumidor extends Thread { private Tuberia tuberia; public Consumidor( Tuberia t ) { // Mantiene una copia propia del objeto compartido tuberia = t; } public void run() { char c; // Consume 10 letras de la tubería for( int i=0; i < 10; i++ ) { c = tuberia.recoger(); // Imprime las letras retiradas System.out.println( quot;Recogido el caracter quot;+c ); // Espera un poco antes de coger más letras try { sleep( (int)(Math.random() * 2000 ) ); } catch( InterruptedException e ) { ; } } } } En este caso, como en el del productor, contamos con un método en la clase Tuberia, tuberia.recoger(), para manejar la información. Monitor 197
  • 198. Una vez vistos el productor de la información y el consumidor, nos queda por ver qué es lo que hace la clase Tuberia. Lo que realiza la clase Tuberia, es una función de supervisión de las transacciones entre los dos threads, el productor y el consumidor. Los monitores, en general, son piezas muy importantes de las aplicaciones multithreaded, porque mantienen el flujo de comunicación entre los threads. class Tuberia { private char buffer[] = new char[6]; private int siguiente = 0; // Flags para saber el estado del buffer private boolean estaLlena = false; private boolean estaVacia = true; // Método para retirar letras del buffer public synchronized char recoger() { // No se puede consumir si el buffer está vacío while( estaVacia == true ) { try { wait(); // Se sale cuando estaVacia cambia a false } catch( InterruptedException e ) { ; } } // Decrementa la cuenta, ya que va a consumir una letra siguiente--; // Comprueba si se retiró la última letra if( siguiente == 0 ) estaVacia = true; // El buffer no puede estar lleno, porque acabamos de consumir estaLlena = false; notify(); // Devuelve la letra al thread consumidor return( buffer[siguiente] ); } // Método para añadir letras al buffer public synchronized void lanzar( char c ) { // Espera hasta que haya sitio para otra letra while( estaLlena == true ) { try { wait(); // Se sale cuando estaLlena cambia a false } catch( InterruptedException e ) { ; } } // Añade una letra en el primer lugar disponible buffer[siguiente] = c; // Cambia al siguiente lugar disponible siguiente++; // Comprueba si el buffer está lleno if( siguiente == 6 ) 198
  • 199. estaLlena = true; estaVacia = false; notify(); } } En la clase Tuberia vemos dos características importantes: los miembros dato (buffer[]) son privados, y los métodos de acceso (lanzar() y recoger()) son sincronizados. Aquí vemos que la variable estaVacia es un semáforo, como los de toda la vida. La naturaleza privada de los datos evita que el productor y el consumidor accedan directamente a éstos. Si se permitiese el acceso directo de ambos threads a los datos, se podrían producir problemas; por ejemplo, si el consumidor intenta retirar datos de un buffer vacío, obtendrá excepciones innecesarias, o se bloqueará el proceso. Los métodos sincronizados de acceso impiden que los productores y consumidores corrompan un objeto compartido. Mientras el productor está añadiendo una letra a la tubería, el consumidor no la puede retirar y viceversa. Esta sincronización es vital para mantener la integridad de cualquier objeto compartido. No sería lo mismo sincronizar la clase en vez de los métodos, porque esto significaría que nadie puede acceder a las variables de la clase en paralelo, mientras que al sincronizar los métodos, sí pueden acceder a todas las variables que están fuera de los métodos que pertenecen a la clase. Se pueden sincronizar incluso variables, para realizar alguna acción determinada sobre ellas, por ejemplo: sincronized( p ) { // aquí se colocaría el código // los threads que estén intentando acceder a p se pararán // y generarán una InterruptedException } El método notify() al final de cada método de acceso avisa a cualquier proceso que esté esperando por el objeto, entonces el proceso que ha estado esperando intentará acceder de nuevo al objeto. En el método wait() hacemos que el thread se quede a la espera de que le llegue un notify(), ya sea enviado por el thread o por el sistema. Ahora que ya tenemos un productor, un consumidor y un objeto compartido, necesitamos una aplicación que arranque los threads y que consiga que todos hablen con el mismo objeto que están compartiendo. Esto es lo que hace el siguiente trozo de código, del fuente TubTest.java: class TubTest { public static void main( String args[] ) { Tuberia t = new Tuberia(); Productor p = new Productor( t ); Consumidor c = new Consumidor( t ); p.start(); c.start(); } } Compilando y ejecutando esta aplicación, podremos observar nuestro modelo el pleno funcionamiento. 199
  • 200. Monitorización del Productor Los programas productor/consumidor a menudo emplean monitorización remota, que permite al consumidor observar el thread del productor interaccionando con un usuario o con otra parte del sistema. Por ejemplo, en una red, un grupo de threads productores podrían trabajar cada uno en una workstation. Los productores imprimirían documentos, almacenando una entrada en un registro (log). Un consumidor (o múltiples consumidores) podría procesar el registro y realizar durante la noche un informe de la actividad de impresión del día anterior. Otro ejemplo, a pequeña escala podría ser el uso de varias ventanas en una workstation. Una ventana se puede usar para la entrada de información (el productor), y otra ventana reaccionaría a esa información (el consumidor). Peer, es un observador general del sistema. 200
  • 201. CODIGO NATIVO Un método nativo es un método Java (una instancia de un objeto o una clase) cuya implementación se ha realizado en otro lenguaje de programación, por ejemplo, C. Vamos a ver cómo se integran métodos nativos en clases Java. Actualmente, el lenguaje Java solamente proporciona mecanismos para integrar código C en programas Java. Veamos pues los pasos necesarios para mezclar código nativo C y programas Java. Recurriremos (¡Cómo no!) a nuestro saludo; en este caso, el programa HolaMundo tiene dos clases Java: la primera implementa el método main() y la segunda, HolaMundo, tiene un método nativo que presenta el mensaje de saludo. La implementación de este segundo método la realizaremos en C. Las acciones que debemos realizar, para conseguir que nuestra nueva versión del saludo funcione, serán las que desarrollaremos en las páginas siguientes del Tutorial. ESCRIBIR CODIGO JAVA En primer lugar, debemos crear una clase Java, HolaMundo, que declare un método nativo. También debemos crear el programa principal que cree el objeto HolaMundo y llame al método nativo. Las siguientes líneas de código definen la clase HolaMundo, que consta de un método y un segmento estático de código: class HolaMundo { public native void presentaSaludo(); static { System.loadLibrary( quot;holaquot; ); } } Podemos decir que la implementación del método presentaSaludo() de la clase HolaMundo está escrito en otro lenguaje, porque la palabra reservada native aparece como parte de la definición del método. Esta definición, proporciona solamente la definición para presentaSaludo() y no porporciona ninguna implementación para él. La implementación la proporcionaremos desde un fichero fuente separado, escrito en lenguaje C. La definición para presentaSaludo() también indica que el método es un método público, no acepta argumentos y no devuelve ningún valor. Al igual que cualquier otro método, los métodos nativos deben estar definidos dentro de una clase Java. 201
  • 202. El código C que implementa el método presentaSaludo() debe ser compilado en una librería dinámica y cargado en la clase Java que lo necesite. Esta carga, mapea la implementación del método nativo sobre su definición. El siguiente bloque de código carga la librería dinámica, en este caso hola. El sistema Java ejecutará un bloque de código estático de la clase cuando la cargue. Todo el código anterior forma parte del fichero HolaMundo.java, que contiene la clase HolaMundo. En un fichero separado, Main.java, vamos a crear una aplicación Java que instancie a la clase HolaMundo y llame al método nativo presentaSaludo(). class Main { public static void main( String args[] ) { new HolaMundo().presentaSaludo(); } } Como se puede observar, llamamos al método nativo del mismo modo que a cualquier otro método Java; añadimos el nombre del método al final del nombre del objeto con un punto (quot;.quot;). El conjunto de paréntesis que sigue al nombre del método encierra los argumentos que se le pasen. En este caso, el método presentaSaludo() no recibe ningún tipo de argumento. Compilar el Código Java Utilizaremos ahora el compilador javac para compilar el código Java que hemos desarrollado. Compilaremos los dos ficheros fuentes de código Java que hemos creado, tecleando los siguientes comandos: > javac HolaMundo.java > javac Main.java CREAR EL FICHERO DE CABECERA Ahora debemos utilizar la aplicación javah para conseguir el fichero de cabecera .h. El fichero de cabecera define una estructura que representa la clase HolaMundo sobre código C y proporciona la definición de una función C para la implementación del método nativo presentaSaludo() definido en ese clase. Ejecutamos javah sobre la clase HolaMundo, con el siguiente comando: > javah HolaMundo Por defecto, javah creará el nuevo fichero .h en el mismo directorio en que se encuentra el fichero .class, obtenido al compilar con javac el código fuente Java correspondiente a la clase. El fichero que creará, será un fichero de cabecera del mismo nombre que la clase y con extensión .h. Por ejemplo, el comando anterior habrá creado el fichero HolaMundo.h, cuyo contenido será el siguiente: /* DO NOT EDIT THIS FILE - it is machine generated */ #include <native.h> /* Header for class HolaMundo */ 202
  • 203. #ifndef _Included_HolaMundo #define _Included_HolaMundo typedef struct ClassHolaMundo { char PAD; /* ANSI C requires structures to have a least one member */ } ClassHolaMundo; HandleTo(HolaMundo); #ifdef __cplusplus extern quot;Cquot; { #endif __declspec(dllexport) void HolaMundo_presentaSaludo(struct HHolaMundo *); #ifdef __cplusplus } #endif #endif Este fichero de cabecera contiene la definición de una estructura llamada ClassHolaMundo. Los miembros de esta estructura son paralelos a los miembros de la clase Java correspondiente; es decir, los campos en la estructura corresponden a las variables de la clase. Pero como HolaMundo no tiene ninguna variable, la estructura se encuentra vacía. Se pueden utilizar los miembros de la estructura para referenciar a variables instanciadas de la clase desde las funciones C. Además de la estructura C similar a la clase Java, vemos que la llamada de la función C está declarada como: extern void HolaMundo_presentaSaludo( struct HHolaMundo *); Esta es la definición de la función C que deberemos escribir para implementar el método nativo presentaSaludo() de la clase HolaMundo. Debemos utilizar esa definición cuando lo implementemos. Si HolaMundo llamase a otros métodos nativos, las definiciones de las funciones también aparecerían aquí. El nombre de la función C que implementa el método nativo está derivado del nombre del paquete, el nombre de la clase y el nombre del método nativo. Así, el método nativo presentaSaludo() dentro de la clase HolaMundo es HolaMundo_presentaSaludo(). En este ejemplo, no hay nombre de paquete porque HolaMundo se considera englobado dentro del paquete por defecto. La función C acepta un parámetro, aunque el método nativo definido en la clase Java no acepte ninguno. Se puede pensar en este parámetro como si fuese la variable this de C++. En nuestro caso, ignoramos el parámetro this. CREAR EL FICHERO DE STUBS Volvemos a utilizar la aplicación javah para crear el fichero de stubs, que contiene todas las declaraciones de métodos, con sus llamadas y argumentos, listos para que nosotros rellenemos el cuerpo de los métodos con los algoritmos que necesitemos implementar. Proporciona la unión entre la clase Java y su estructura C paralela. 203
  • 204. Para generar este fichero, debemos indicar el parámetro .stubs al ejecutar la aplicación javah sobre la clase HolaMundo, de la siguiente forma: > javah -stubs HolaMundo Del mismo modo que se generaba el fichero .h; el nombre del fichero de stubs será el nombre de la clase con la extensión .c. En nuestro ejemplo, será HolaMundo.c, y su contenido será el siguiente: /* DO NOT EDIT THIS FILE - it is machine generated */ #include <StubPreamble.h> /* Stubs for class HolaMundo */ /* SYMBOL: quot;HolaMundo/presentaSaludo()Vquot;, Java_HolaMundo_presentaSaludo_stub */ __declspec(dllexport) stack_item *Java_HolaMundo_presentaSaludo_stub(stack_item *_P_,struct execenv *_EE_) { extern void HolaMundo_presentaSaludo(void *); (void) HolaMundo_presentaSaludo(_P_[0].p); return _P_; } ESCRIBIR LA FUNCION C Escribiremos la función C para el método nativo en un fichero fuente de código C. La implementación será una función habitual C, que luego integraremos con la clase Java. La definición de la función C debe ser la misma que la que se ha generado con javah en el fichero HolaMundo.h. La implementación que proponemos la guardaremos en el fichero HolaImp.c, y contendrá las siguientes línea de código: #include <StubPreamble.h> #include quot;HolaMundo.h> #include <stdio.h> void HolaMundo_presentaSaludo( struct HHolaMundo *this ) { printf( quot;Hola Mundo, desde el Tutorial de Javanquot; ); return; } Como se puede ver, la implementación no puede ser más sencilla: hace una llamada a la función printf() para presentar el saludo y sale. En el código se incluyen tres ficheros de cabecera: • StubsPreamble.h Proporciona la información para que el código C pueda interactuar con el sistema Java. Cuando se escriben métodos nativos, siempre habrá que incluir este fichero en el código fuente C. • HolaMundo.h 204
  • 205. Es el fichero de cabecera que hemos generado para nuestra clase. Contiene la estructura C que representa la clase Java para la que estamos escribiendo el método nativo y la definición de la función para ese método nativo. • stdio.h Es necesario incluirlo porque utilizamos la función printf() de la librería estándar de C, cuya declaración se encuentra en este fichero de cabecera. CREAR LA LIBRERIA DINAMICA Utilizaremos el compilador C para compilar el fichero .h, el fichero de stubs y el fichero fuente .c; para crear una librería dinámica. Para crearla, utilizaremos el compilador C de nuestro sistema, haciendo que los ficheros HolaMundo.c y HolaImp.c generen una librería dinámica de nombre hola, que será la que el sistema Java cargue cuando ejecute la aplicación que estamos construyendo. Vamos a ver cómo generamos esta librería en Unix y en Windows '95. Unix Teclearemos el siguiente comando: % cc -G HolaMundo.c HolaImp.c -o libhola.so En caso de que no encuentre el compilador los ficheros de cabecera, se puede utilizar el flag -I para indicarle el camino de búsqueda, por ejemplo: % cc -G -I$JAVA_HOME/include HolaMundo.c HolaImp.c -o libhola.so donde $JAVA_HOME es el directorio donde se ha instalado la versión actual del Java Development Kit. Windows '95 El comando a utilizar en este caso es el siguiente: c:>cl HolaMundo.c HolaImp.c -Fhola.dll -MD -LD javai.lib Este comando funciona con Microsoft Visual C++ 2.x y posteriores. Si queremos indicar al compilador donde se encuentran los ficheros de cabecera y las librerías, tendremos que fijar dos variables de entorno: c:>SET INCLUDE=%JAVAHOME%include;%INCLUDE% c:>SET LIB=%JAVAHOME%lib;%LIB% donde %JAVAHOME% es el directorio donde se ha instalado la versión actual del Java Development Kit. EJECUTAR EL PROGRAMA 205
  • 206. Y, por fin, utilizaremos el intérprete de Java, java, para ejecutar el programa que hemos construido siguiendo todos los pasos anteriormente descritos. Si tecleamos el comando: > java Main obtendremos el resultado siguiente: % Hola Mundo, desde el Tutorial de Java Si no aparece este mensaje de saludo y lo que aparece en pantalla son expresiones como UnsatisfiedLinkError, es porque no tenemos fijado correctamente el camino de la librería dinámica que hemos generado. Este camino es la lista de directorios que el sistema Java utilizará para buscar las librerías que debe cargar. Debemos asegurarnos de que el directorio donde se encuentra nuestra librería hola recién creada, figura entre ellos. Si fijamos el camino correcto y ejecutamos de nuevo el programa, veremos que ahora sí obtenemos el mensaje de saludo que esperábamos. Con ello, hemos visto como integrar código C en programas Java. Quedan muchas cuestiones por medio, como la equivalencia de tipos entre Java y C, el paso de parámetros, el manejo de cadenas, etc. Pero eso supondría entrar en mucha más profundidad dentro de Java de la que aquí pretendemos (por ahora). 206
  • 207. ENTRADA Y SALIDA STANDARD Los usuarios de Unix, y aquellos familiarizados con las líneas de comandos de otros sistemas como DOS, han utilizado un tipo de entrada/salida conocida comúnmente por entrada/salida estándar. El fichero de entrada estándar (stdin) es simplemente el teclado. El fichero de salida estándar (stdout) es típicamente la pantalla (o la ventana del terminal). El fichero de salida de error estándar (stderr) también se dirige normalmente a la pantalla, pero se implementa como otro fichero de forma que se pueda distinguir entre la salida normal y (si es necesario) los mensajes de error. La clase System Java tiene acceso a la entrada/salida estándar a través de la clase System. En concreto, los tres ficheros que se implementan son: Stdin System.in implementa stdin como una instancia de la clase InputStream. Con System.in, se accede a los métodos read() y skip(). El método read() permite leer un byte de la entrada. skip( long n ), salta n bytes de la entrada. Stdout System.out implementa stdout como una instancia de la clase PrintStream. Se pueden utilizar los métodos print() y println() con cualquier tipo básico Java como argumento. Stderr System.err implementa stderr de la misma forma que stdout. Como con System.out, se tiene acceso a los métodos de PrintStream. Vamos a ver un pequeño ejemplo de entrada/salida en Java. El código siguiente, miType.java, reproduce, o funciona como la utilidad cat de Unix o type de DOS: import java.io.*; class miType { public static void main( String args[] ) throws IOException { int c; int contador = 0; while( (c = System.in.read() ) != 'n' ) { contador++; System.out.print( (char)c ); 207
  • 208. } System.out.println(); // Línea en blanco System.err.println( quot;Contados quot;+ contador +quot; bytes en total.quot; ); } } Clases comunes de Entrada/Salida Además de la entrada por teclado y salida por pantalla, se necesita entrada/salida por fichero, como son: FileInputStream DataInputStream FileOutputStream DataOutputStream También existen otras clases para aplicaciones más específicas, que no vamos a tratar, por ser de un uso muy concreto: PipedInputStream BufferedInputStream PushBackInputStream StreamTokenizer PipedOutputStream BufferedOutputStream 208
  • 209. FICHEROS EN JAVA Todos los lenguajes de programación tienen alguna forma de interactuar con los sistemas de ficheros locales; Java no es una excepción. Cuando se desarrollan applets para utilizar en red, hay que tener en cuenta que la entrada/salida directa a fichero es una violación de seguridad de acceso. Muchos usuarios configurarán sus navegadores para permitir el acceso al sistema de ficheros, pero otros no. Por otro lado, si se está desarrollando una aplicación Java para uso interno, probablemente será necesario el acceso directo a ficheros. Ficheros Antes de realizar acciones sobre un fichero, necesitamos un poco de información sobre ese fichero. La clase File proporciona muchas utilidades relacionadas con ficheros y con la obtención de información básica sobre esos ficheros. Creación de un objeto File Para crear un objeto File nuevo, se puede utilizar cualquiera de los tres constructores siguientes: File miFichero; miFichero = new File( quot;/etc/kkquot; ); o miFichero = new File( quot;/etcquot;,quot;kkquot; ); o File miDirectorio = new File( quot;/etcquot; ); miFichero = new File( miDirectorio,quot;kkquot; ); El constructor utilizado depende a menudo de otros objetos File necesarios para el acceso. Por ejemplo, si sólo se utiliza un fichero en la aplicación, el primer constructor es el mejor. Si en cambio, se utilizan muchos ficheros desde un mismo directorio, el segundo o tercer constructor serán más cómodos. Y si el directorio o el fichero es una variable, el segundo constructor será el más útil. Comprobaciones y Utilidades Una vez creado un objeto File, se puede utilizar uno de los siguientes métodos para reunir información sobre el fichero: 209
  • 210. • Nombres de fichero String getName() String getPath() String getAbsolutePath() String getParent() boolean renameTo( File nuevoNombre ) • Comprobaciones boolean exists() boolean canWrite() boolean canRead() boolean isFile() boolean isDirectory() boolean isAbsolute() • Información general del fichero long lastModified() long length() • Utilidades de directorio boolean mkdir() String[] list() Vamos a desarrollar una pequeña aplicación que muestra información sobre los ficheros pasados como argumentos en la línea de comandos, InfoFichero.java: import java.io.*; class InfoFichero { public static void main( String args[] ) throws IOException { if( args.length > 0 ) { for( int i=0; i < args.length; i++ ) { File f = new File( args[i] ); System.out.println( quot;Nombre: quot;+f.getName() ); System.out.println( quot;Camino: quot;+f.getPath() ); if( f.exists() ) { System.out.print( quot;Fichero existente quot; ); System.out.print( (f.canRead() ? quot; y se puede Leerquot; : quot;quot; ) ); System.out.print( (f.canWrite() ? quot; y se puese Escribirquot; : quot;quot; ) ); System.out.println( quot;.quot; ); System.out.println( quot;La longitud del fichero son quot;+ f.length()+quot; bytesquot; ); } else System.out.println( quot;El fichero no existe.quot; ); } } else System.out.println( quot;Debe indicar un fichero.quot; ); } } 210
  • 211. STREAMS DE ENTRADA Hay muchas clases dedicadas a la obtención de entrada desde un fichero. Este es el esquema de la jerarquía de clases de entrada por fichero: Objetos FileInputStream Los objetos FileInputStream típicamente representan ficheros de texto accedidos en orden secuencial, byte a byte. Con FileInputStream, se puede elegir acceder a un byte, varios bytes o al fichero completo. Apertura de un FileInputStream Para abrir un FileInputStream sobre un fichero, se le da al constructor un String o un objeto File: FileInputStream mi FicheroSt; miFicheroSt = new FileInputStream( quot;/etc/kkquot; ); También se puede utilizar: File miFichero FileInputStream miFicheroSt; miFichero = new File( quot;/etc/kkquot; ); miFicheroSt = new FileInputStream( miFichero ); Lectura de un FileInputStream Una vez abierto el FileInputStream, se puede leer de él. El método read() tiene muchas opciones: int read(); Lee un byte y devuelve -1 al final del stream. 211
  • 212. int read( byte b[] ); Llena todo el array, si es posible. Devuelve el número de bytes leídos o -1 si se alcanzó el final del stream. int read( byte b[],int offset,int longitud ); Lee longitud bytes en b comenzando por b[offset]. Devuelve el número de bytes leídos o -1 si se alcanzó el final del stream. Cierre de FileInputStream Cuando se termina con un fichero, existen dos opciones para cerrarlo: explícitamente, o implícitamente cuando se recicla el objeto (el garbage collector se encarga de ello). Para cerrarlo explícitamente, se utiliza el método close(): miFicheroSt.close(); Ejemplo: Visualización de un fichero Si la configuración de la seguridad de Java permite el acceso a ficheros, se puede ver el contenido de un fichero en un objeto TextArea. El código siguiente contiene los elementos necesarios para mostrar un fichero: FileInputStream fis; TextArea ta; public void init() { byte b[] = new byte[1024]; int i; // El buffer de lectura se debe hacer lo suficientemente grande // o esperar a saber el tamaño del fichero String s; try { fis = new FileInputStream( quot;/etc/kkquot; ); } catch( FileNotFoundException e ) { /* Hacer algo */ } try { i = fis.read( b ); } catch( IOException e ) { /* Hacer algo */ } s = new String( b,0 ); ta = new TextArea( s,5,40 ); add( ta ); } Hemos desarrollado un ejemplo, Agenda.java, en el que partimos de un fichero agenda que dispone de los datos que nosotros deseamos de nuestros amigos, como son: nombre, teléfono y dirección. Si tecleamos un nombre, buscará en el fichero de datos si existe ese 212
  • 213. nombre y presentará la información que se haya introducido. Para probar, intentar que aparezca la información de Pepe. Objetos DataInputStream Los objetos DataInputStream se comportan como los FileInputStream. Los streams de datos pueden leer cualquiera de las variables de tipo nativo, como floats, ints o chars. Generalmente se utilizan DataInputStream con ficheros binarios. Apertura y cierre de DataInputStream Para abrir y cerrar un objeto DataInputStream, se utilizan los mismos métodos que para FileInputStream: DataInputStream miDStream; FileInputStream miFStream; // Obtiene un controlador de fichero miFStream = new FileInputStream quot;/etc/ejemplo.dbfquot; ); //Encadena un fichero de entrada de datos miDStream = new DataInputStream( miFStream ); // Ahora se pueden utilizar los dos streams de entrada para // acceder al fichero (si se quiere...) miFStream.read( b ); i = miDStream.readInt(); // Cierra el fichero de datos explícitamente //Siempre se cierra primero el fichero stream de mayor nivel miDStream.close(); miFStream.close(); Lectura de un DataInputStream Al acceder a un fichero como DataInputStream, se pueden utilizar los mismos métodos read() de los objetos FileInputStream. No obstante, también se tiene acceso a otros métodos diseñados para leer cada uno de los tipos de datos: byte readByte() int readUnsignedByte() short readShort() int readUnsignedShort() char readChar() int readInt() long readLong() float readFloat() double readDouble() String readLine() Cada método leerá un objeto del tipo pedido. Para el método String readLine(), se marca el final de la cadena con n, r, rn o con EOF. 213
  • 214. Para leer un long, por ejemplo: long numeroSerie; ... numeroSerie = miDStream.readLong(); Streams de entrada de URLs Además del acceso a ficheros, Java proporciona la posibilidad de acceder a URLs como una forma de acceder a objetos a través de la red. Se utiliza implícitamente un objeto URL al acceder a sonidos e imágenes, con el método getDocumentBase() en los applets: String imagenFich = new String( quot;imagenes/pepe.gifquot; ); imagenes[0] = getImage( getDocumentBase(),imagenFich ); No obstante, se puede proporcionar directamente un URL, si se quiere: URL imagenSrc; imagenSrc = new URL( quot;http://enterprise.com/~infoquot; ); imagenes[0] = getImage( imagenSrc,quot;imagenes/pepe.gifquot; ); Apertura de un Stream de entrada de URL También se puede abrir un stream de entrada a partir de un URL. Por ejemplo, se puede utilizar un fichero de datos para un applet: ImputStream is; byte buffer[] = new byte[24]; is = new URL( getDocumentBase(),datos).openStream(); Ahora se puede utilizar is para leer información de la misma forma que se hace con un objeto FileInputStream: is.read( buffer,0,buffer.length ); NOTA: Debe tenerse muy en cuenta que algunos usuarios pueden haber configurado la seguridad de sus navegadores para que los applets no accedan a ficheros. STREAMS DE SALIDA La contrapartida necesaria de la lectura de datos es la escritura de datos. Como con los Streams de entrada, las clases de salida están ordenadas jerárquicamente: Examinaremos las clases FileOutputStream y DataOutputStream para complementar los streams de entrada que se han visto. En los ficheros fuente del directorio $JAVA_HOME/src/ java/io se puede ver el uso y métodos de estas clases, así como de los streams de entrada 214
  • 215. ($JAVA_HOME es el directorio donde se haya instalado el Java Development Kit, en sistemas UNIX). Objetos FileOutputStream Los objetos FileOutputStream son útiles para la escritura de ficheros de texto. Como con los ficheros de entrada, primero se necesita abrir el fichero para luego escribir en él. Apertura de un FileOutputStream Para abrir un objeto FileOutputStream, se tienen las mismas posibilidades que para abrir un fichero stream de entrada. Se le da al constructor un String o un objeto File. FileOutputStream miFicheroSt; miFicheroSt = new FileOutputStream( quot;/etc/kkquot; ); Como con los streams de entrada, también se puede utilizar: File miFichero FileOutputStream miFicheroSt; miFichero = new File( quot;/etc/kkquot; ); miFicheroSt = new FileOutputStream( miFichero ); Escritura en un FileOutputStream Una vez abierto el fichero, se pueden escribir bytes de datos utilizando el método write(). Como con el método read() de los streams de entrada, tenemos tres posibilidades: void write( int b ); Escribe un byte. void write( byte b[] ); Escribe todo el array, si es posible. void write( byte b[],int offset,int longitud ); Escribe longitud bytes en b comenzando por b[offset]. Cierre de FileOutputStream Cerrar un stream de salida es similar a cerrar streams de entrada. Se puede utilizar el método explícito: miFicheroSt.close(); O, se puede dejar que el sistema cierre el fichero cuando se recicle miFicheroSt. Ejemplo: Almacenamiento de Información Este programa, Telefonos.java, pregunta al usuario una lista de nombres y números de teléfono. Cada nombre y número se añade a un fichero situado en una localización fija. Para indicar que se ha introducido toda la lista, el usuario especifica quot;Finquot; ante la solicitud de entrada del nombre. 215
  • 216. Una vez que el usuario ha terminado de teclear la lista, el programa creará un fichero de salida que se mostrará en pantalla o se imprimirá. Por ejemplo: 95-4751232,Juanito 564878,Luisa 123456,Pepe 347698,Antonio 91-3547621,Maria El código fuente del programa es el siguiente: import java.io.*; class Telefonos { static FileOutputStream fos; public static final int longLinea = 81; public static void main( String args[] ) throws IOException { byte tfno[] = new byte[longLinea]; byte nombre[] = new byte[longLinea]; fos = new FileOutputStream( quot;telefono.datquot; ); while( true ) { System.err.println( quot;Teclee un nombre ('Fin' termina)quot; ); leeLinea( nombre ); if( quot;finquot;.equalsIgnoreCase( new String( nombre,0,0,3 ) ) ) break; System.err.println( quot;Teclee el numero de telefonoquot; ); leeLinea( tfno ); for( int i=0; tfno[i] != 0; i++ ) fos.write( tfno[i] ); fos.write( ',' ); for( int i=0; nombre[i] != 0; i++ ) fos.write( nombre[i] ); fos.write( 'n' ); } fos.close(); } private static void leeLinea( byte linea[] ) throws IOException { int b = 0; int i = 0; while( (i < ( longLinea-1) ) && ( ( b = System.in.read() ) != 'n' ) ) linea[i++] = (byte)b; linea[i] = (byte)0; } } Streams de salida con buffer Si se trabaja con gran cantidad de datos, o se escriben muchos elementos pequeños, será una buena idea utilizar un stream de salida con buffer. Los streams con buffer ofrecen los 216
  • 217. mismos métodos de la clase FileOutputStream, pero toda salida se almacena en un buffer. Cuando se llena el buffer, se envía a disco con una única operación de escritura; o, en caso necesario, se puede enviar el buffer a disco en cualquier momento. Creación de Streams de salida con buffer Para crear un stream BufferedOutput, primero se necesita un stream FileOutput normal; entonces se le añade un buffer al stream: FileOutputStream miFileStream; BufferdOutpurStream miBufferStream; // Obtiene un controlador de fichero miFileStream = new FileOutputStream( quot;/tmp/kkquot; ); // Encadena un stream de salida con buffer miBufferStream = new BufferedOutputStream( miFileStream ); Volcado y Cierre de Streams de salida con buffer Al contrario que los streams FileOutput, cada escritura al buffer no se corresponde con una escritura en disco. A menos que se llene el buffer antes de que termine el programa, cuando se quiera volcar el buffer explícitamente se debe hacer mediante una llamada a flush(): // Se fuerza el volcado del buffer a disco miBufferStream.flush(); // Cerramos el fichero de datos. Siempre se ha de cerrar primero el // fichero stream de mayor nivel miBufferStream.close(); miFileStream.close(); Streams DataOutput Java también implementa una clase de salida complementaria a la clase DataInputStream. Con la clase DataOutputStream, se pueden escribir datos binarios en un fichero. Apertura y cierre de objetos DataOutputStream Para abrir y cerrar objetos DataOutputStream, se utilizan los mismos métodos que para los objetos FileOutputStream: DataOutputStream miDataStream; FileOutputStream miFileStream; BufferedOutputStream miBufferStream; // Obtiene un controlador de fichero miFileStream = new FileOutputStream( quot;/tmp/kkquot; ); // Encadena un stream de salida con buffer (por eficiencia) miBufferStream = new BufferedOutputStream( miFileStream ); // Encadena un fichero de salida de datos miDataStream = new DataOutputStream( miBufferStream ); // Ahora se pueden utilizar los dos streams de entrada para // acceder al fichero (si se quiere) miBufferStream.write( b ); miDataStream.writeInt( i ); // Cierra el fichero de datos explícitamente. Siempre se cierra // primero el fichero stream de mayor nivel 217
  • 218. miDataStream.close(); miBufferStream.close(); miFileStream.close(); Escritura en un objeto DataOutputStream Cada uno de los métodos write() accesibles por los FileOutputStream también lo son a través de los DataOutputStream. También encontrará métodos complementarios a los de DataInputStream: void writeBoolean( boolean b ); void writeByte( int i ); void writeShort( int i ); void writeChar( int i ); void writeInt( int i ); void writeFloat( float f ); void writeDouble( double d ); void writeBytes( String s ); void writeChars( string s ); Para las cadenas, se tienen dos posibilidades: bytes y caracteres. Hay que recordar que los bytes son objetos de 8 bits y los caracteres lo son de 16 bits. Si nuestras cadenas utilizan caracteres Unicode, debemos escribirlas con writeChars(). Contabilidad de la salida Otra función necesaria durante la salida es el método size(). Este método simplemente devuelve el número total de bytes escritos en el fichero. Se puede utilizar size() para ajustar el tamaño de un fichero a múltiplo de cuatro. Por ejemplo, de la forma siguiente: . . . int numBytes = miDataStream.size() % 4; for( int i=0; i < numBytes; i++ ) miDataStream.write( 0 ); . . . FICHEROS DE ACCESO ALEATORIO A menudo, no se desea leer un fichero de principio a fin; sino acceder al fichero como una base de datos, donde se salta de un registro a otro; cada uno en diferentes partes del fichero. Java proporciona una clase RandomAccessFile para este tipo de entrada/salida. Creación de un Fichero de Acceso Aleatorio Hay dos posibilidades para abrir un fichero de acceso aleatorio: Con el nombre del fichero: miRAFile = new RandomAccessFile( String nombre,String modo ); Con un objeto File: miRAFile = new RandomAccessFile( File fichero,String modo ); El argumento modo determina si se tiene acceso de sólo lectura (r) o de lectura/escritura (r/w). Por ejemplo, se puede abrir un fichero de una base de datos para actualización: 218
  • 219. RandomAccessFile miRAFile; miRAFile = new RandomAccessFile( quot;/tmp/kk.dbfquot;,quot;rwquot; ); Acceso a la Información Los objetos RandomAccessFile esperan información de lectura/escritura de la misma manera que los objetos DataInput/DataOutput. Se tiene acceso a todas las operaciones read() y write() de las clases DataInputStream y DataOutputStream. También se tienen muchos métodos para moverse dentro de un fichero: long getFilePointer(); Devuelve la posición actual del puntero del fichero void seek( long pos ); Coloca el puntero del fichero en una posición determinada. La posición se da como un desplazamiento en bytes desde el comienzo del fichero. La posición 0 marca el comienzo de ese fichero. long length(); Devuelve la longitud del fichero. La posición length() marca el final de ese fichero. Actualización de Información Se pueden utilizar ficheros de acceso aleatorio para añadir información a ficheros existentes: miRAFile = new RandomAccessFile( quot;/tmp/kk.logquot;,quot;rwquot; ); miRAFile.seek( miRAFile.length() ); // Cualquier write() que hagamos a partir de este punto del código // añadirá información al fichero Vamos a ver un pequeño ejemplo, Log.java, que añade una cadena a un fichero existente: import java.io.*; // Cada vez que ejecutemos este programita, se incorporara una nueva // linea al fichero de log que se crea la primera vez que se ejecuta // class Log { public static void main( String args[] ) throws IOException { RandomAccessFile miRAFile; String s = quot;Informacion a incorporarnTutorial de Javanquot;; // Abrimos el fichero de acceso aleatorio miRAFile = new RandomAccessFile( quot;/tmp/java.logquot;,quot;rwquot; ); // Nos vamos al final del fichero miRAFile.seek( miRAFile.length() ); // Incorporamos la cadena al fichero miRAFile.writeBytes( s ); // Cerramos el fichero miRAFile.close(); } } 219
  • 220. COMUNICACIONES EN JAVA En este capítulo no nos vamos a extender demasiado en profundidades sobre la comunicación y funcionamiento de redes, aunque sí proporcionaremos un breve baño inicial para sentar, o recordar, los fundamentos de la comunicación en red, tomando como base Unix. Presentaremos un ejemplo básico de cliente/servidor sobre sockets TCP/IP, proporcionando un punto de partida para el desarrollo de otras aplicaciones cliente/servidor basadas en sockets, que posteriormente implementaremos. COMUNICACIONES EN UNIX El sistema de Entrada/Salida de Unix sigue el paradigma que normalmente se designa como Abrir-Leer-Escribir-Cerrar. Antes de que un proceso de usuario pueda realizar operaciones de entrada/salida, debe hacer una llamada a Abrir (open) para indicar, y obtener permisos para su uso, el fichero o dispositivo que quiere utilizar. Una vez que el objeto está abierto, el proceso de usuario realiza una o varias llamadas a Leer (read) y Escribir (write), para conseguir leer y escribir datos. Leer coge datos desde el objeto y los transfiere al proceso de usuario, mientras que Escribir transfiere datos desde el proceso de usuario al objeto. Una vez que todos estos intercambios de información estén concluidos, el proceso de usuario llamará a Cerrar (close) para informar al sistema operativo que ha finalizado la utilización del objeto que antes había abierto. Cuando se incorporan las características a Unix de comunicación entre procesos (IPC) y el manejo de redes, la idea fue implementar la interface con IPC similar a la que se estaba utilizando para la entrada/salida de ficheros, es decir, siguiendo el paradigma del párrafo anterior. En Unix, un proceso tiene un conjunto de descriptores de entrada/salida desde donde Leer y por donde Escribir. Estos descriptores pueden estar referidos a ficheros, dispositivos, o canales de comunicaciones (sockets). El ciclo de vida de un descriptor, aplicado a un canal de comunicación (socket), está determinado por tres fases (siguiendo el paradigma): • Creación, apertura del socket • Lectura y Escritura, recepción y envío de datospor el socket • Destrucción, cierre del socket 220
  • 221. La interface IPC en Unix-BSD está implementada sobre los protocolos de red TCP y UDP. Los destinatarios de los mensajes se especifican como direcciones de socket; cada dirección de socket es un identificador de comunicación que consiste en una dirección Internet y un número de puerto. Las operaciones IPC se basan en pares de sockets. Se intercambian información transmitiendo datos a través de mensajes que circulan entre un socket en un proceso y otro socket en otro proceso. Cuando los mensajes son enviados, se encolan en el socket hasta que el protocolo de red los haya transmitido. Cuando llegan, los mensajes son encolados en el socket de recepción hasta que el proceso que tiene que recibirlos haga las llamadas necesarias para recoger esos datos. SOCKETS Los sockets son puntos finales de enlaces de comunicaciones entre procesos. Los procesos los tratan como descriptores de ficheros, de forma que se pueden intercambiar datos con otros procesos transmitiendo y recibiendo a través de sockets. El tipo de sockets describe la forma en la que se transfiere información a través de ese socket. Sockets Stream (TCP, Transport Control Protocol) Son un servicio orientado a conexión donde los datos se transfieren sin encuadrarlos en registros o bloques. Si se rompe la conexión entre los procesos, éstos serán informados. El protocolo de comunicaciones con streams es un protocolo orientado a conexión, ya que para establecer una comunicación utilizando el protocolo TCP, hay que establecer en primer lugar una conexión entre un par de sockets. Mientras uno de los sockets atiende peticiones de conexión (servidor), el otro solicita una conexión (cliente). Una vez que los dos sockets estén conectados, se pueden utilizar para transmitir datos en ambas direcciones. Sockets Datagrama (UDP, User Datagram Protocol) Son un servicio de transporte sin conexión. Son más eficientes que TCP, pero no está garantizada la fiabilidad. Los datos se envían y reciben en paquetes, cuya entrega no está garantizada. Los paquetes pueden ser duplicados, perdidos o llegar en un orden diferente al que se envió. El protocolo de comunicaciones con datagramas es un protocolo sin conexión, es decir, cada vez que se envíen datagramas es necesario enviar el descriptor del socket local y la dirección del socket que debe recibir el datagrama. Como se puede ver, hay que enviar datos adicionales cada vez que se realice una comunicación. Sockets Raw Son sockets que dan acceso directo a la capa de software de red subyacente o a protocolos de más bajo nivel. Se utilizan sobre todo para la depuración del código de los protocolos. Diferencias entre Sockets Stream y Datagrama 221
  • 222. Ahora se nos presenta un problema, ¿qué protocolo, o tipo de sockets, debemos usar - UDP o TCP? La decisión depende de la aplicación cliente/servidor que estemos escribiendo. Vamos a ver algunas diferencias entre los protocolos para ayudar en la decisión. En UDP, cada vez que se envía un datagrama, hay que enviar también el descriptor del socket local y la dirección del socket que va a recibir el datagrama, luego éstos son más grandes que los TCP. Como el protocolo TCP está orientado a conexión, tenemos que establecer esta conexión entre los dos sockets antes de nada, lo que implica un cierto tiempo empleado en el establecimiento de la conexión, que no existe en UDP. En UDP hay un límite de tamaño de los datagramas, establecido en 64 kilobytes, que se pueden enviar a una localización determinada, mientras que TCP no tiene límite; una vez que se ha establecido la conexión, el par de sockets funciona como los streams: todos los datos se leen inmediatamente, en el mismo orden en que se van recibiendo. UDP es un protocolo desordenado, no garantiza que los datagramas que se hayan enviado sean recibidos en el mismo orden por el socket de recepción. Al contrario, TCP es un protocolo ordenado, garantiza que todos los paquetes que se envíen serán recibidos en el socket destino en el mismo orden en que se han enviado. Los datagramas son bloques de información del tipo lanzar y olvidar. Para la mayoría de los programas que utilicen la red, el usar un flujo TCP en vez de un datagrama UDP es más sencillo y hay menos posibilidades de tener problemas. Sin embargo, cuando se requiere un rendimiento óptimo, y está justificado el tiempo adicional que supone realizar la verificación de los datos, los datagramas son un mecanismo realmente útil. En resumen, TCP parece más indicado para la implementación de servicios de red como un control remoto (rlogin, telnet) y transmisión de ficheros (ftp); que necesitan transmitir datos de longitud indefinida. UDP es menos complejo y tiene una menor sobrecarga sobre la conexión; esto hace que sea el indicado en la implementación de aplicaciones cliente/servidor en sistemas distribuidos montados sobre redes de área local. USO DE SOCKETS Podemos pensar que un Servidor Internet es un conjunto de sockets que proporciona capacidades adicionales del sistema, los llamados servicios. Puertos y Servicios Cada servicio está asociado a un puerto. Un puerto es una dirección numérica a través de la cual se procesa el servicio. Sobre un sistema Unix, los servicios que proporciona ese sistema se indican en el fichero /etc/services, y algunos ejemplos son: daytime 13/udp ftp 21/tcp telnet 23/tcp telnet smtp 25/tcp mail http 80/tcp La primera columna indica el nombre del servicio. La segunda columna indica el puerto y el protocolo que está asociado al servicio. La tercera columna es un alias del servicio; por 222
  • 223. ejemplo, el servicio smtp, también conocido como mail, es la implementación del servicio de correo electrónico. Las comunicaciones de información relacionada con Web tienen lugar a través del puerto 80 mediante protocolo TCP. Para emular esto en Java, usaremos la clase Socket. La fecha (daytime). Sin embargo, el servicio que coge la fecha y la hora del sistema, está ligado al puerto 13 utilizando el protocolo UDP. Un servidor que lo emule en Java usaría un objeto DatagramSocket. LA CLASE URL La clase URL contiene contructores y métodos para la manipulación de URL (Universal Resource Locator): un objeto o servicio en Internet. El protocolo TCP necesita dos tipos de información: la dirección IP y el número de puerto. Vamos a ver como podemos recibir pues la página Web principal de nuestro buscador favorito al teclear: http://www.yahoo.com En primer lugar, Yahoo tiene registrado su nombre, permitiendo que se use yahoo.com como su dirección IP, o lo que es lo mismo, cuando indicamos yahoo.com es como si hubiesemos indicado 205.216.146.71, su dirección IP real. La verdad es que la cosa es un poco más complicada que eso. Hay un servicio, el DNS (Domain Name Service), que traslada www.yahoo.com a 205.216.146.71, lo que nos permite teclear www.yahoo.com, en lugar de tener que recordar su dirección IP. Si queremos obtener la dirección IP real de la red en que estamos corriendo, podemos realizar llamadas a los métodos getLocalHost() y getAddress(). Primero, getLocalHost() nos devuelve un objeto iNetAddress, que si usamos con getAddress() generará un array con los cuatro bytes de la dirección IP, por ejemplo: InetAddress direccion = InetAddress.getLocalHost(); byte direccionIp[] = direccion.getAddress(); Si la dirección de la máquina en que estamos corriendo es 150.150.112.145, entonces: direccionIp[0] = 150 direccionIp[1] = 150 direccionIp[2] = 112 direccionIp[3] = 145 Una cosa interesante en este punto es que una red puede mapear muchas direcciones IP. Esto puede ser necesario para un Servidor Web, como Yahoo, que tiene que soportar grandes cantidades de tráfico y necesita más de una dirección IP para poder atender a todo ese tráfico. El nombre interno para la dirección 205.216.146.71, por ejemplo, es www7.yahoo.com. El DNS puede trasladar una lista de direcciones IP asignadas a Yahoo en www.yahoo.com. Esto es una cualidad útil, pero por ahora abre un agujero en cuestión de seguridad. Ya conocemos la dirección IP, nos falta el número del puerto. Si no se indica nada, se utilizará el que se haya definido por defecto en el fichero de configuración de los servicios del sistema. En Unix se indican en el fichero /etc/services, en Windows-NT en el fichero services y en otros sistemas puede ser diferente. 223
  • 224. El puerto habitual de los servicios Web es el 80, así que si no indicamos nada, entraremos en el servidor de Yahoo por el puerto 80. Si tecleamos la URL siguiente en un navegador: http://www.yahoo.com:80 también recibiremos la página principal de Yahoo. No hay nada que nos impida cambiar el puerto en el que residirá el servidor Web; sin embargo, el uso del puerto 80 es casi estándar, porque elimina pulsaciones en el teclado y, además, las direcciones URL son lo suficientemente difíciles de recordar como para añadirle encima el número del puerto. Si necesitamos otro protocolo, como: ftp://ftp.microsoft.com el puerto se derivará de ese protocolo. Así el puerto FTP de Microsoft es el 21, según su fichero services. La primera parte, antes de los dos puntos, de la URL, indica el protocolo que se quiere utilizar en la conexión con el servidor. El protocolo http (HyperText Transmission Protocol), es el utilizado para manipular documentos Web. Y si no se especifica ningún documento, muchos servidores están configurados para devolver un documento de nombre index.html. Con todo esto, Java permite los siguientes cuatro constructores para la clase URL: public URL( String spec ) throws MalformedURLException; public URL( String protocol,String host,int port,String file ) throws MalformedURLException; public URL( String protocol,String host,String file ) throws MalformedURLException; public URL( URL context,String spec ) throws MalformedURLException; Así que podríamos especificar todos los componenetes del URL como en: URL( quot;httpquot;,quot;www.yahoo.comquot;,quot;80quot;,quot;index.htmlquot; ); o dejar que los sistemas utilicen todos los valores por defecto que tienen definidos, como en: URL( quot;http://www.yahoo.comquot; ); y en los dos casos obtendríamos la visualización de la página principal de Yahoo en nuestro navegador. DOMINIOS DE COMUNICACIONES El mecanismo de sockets está diseñado para ser todo lo genérico posible. El socket por sí mismo no contiene información suficiente para describir la comunicación entre procesos. Los sockets operan dentro de dominios de comunicación, entre ellos se define si los dos procesos que se comunican se encuentran en el mismo sistema o en sistemas diferentes y cómo pueden ser direccionados. Dominio Unix Bajo Unix, hay dos dominios, uno para comunicaciones internas al sistema y otro para comunicaciones entre sistemas. 224
  • 225. Las comunicaciones intrasistema (entre dos procesos en el mismo sistema) ocurren (en una máquina Unix) en el dominio Unix. Se permiten tanto los sockets stream como los datagrama. Los sockets de dominio Unix bajo Solaris 2.x se implementan sobre TLI (Transport Level Interface). En el dominio Unix no se permiten sockets de tipo Raw. Dominio Internet Las comunicaciones intersistemas proporcionan acceso a TCP, ejecutando sobre IP (Internet Protocol). De la misma forma que el dominio Unix, el dominio Internet permite tanto sockets stream como datagrama, pero además permite sockets de tipo Raw. Los sockets stream permiten a los procesos comunicarse a través de TCP. Una vez establecidas las conexiones, los datos se pueden leer y escribir a/desde los sockets como un flujo (stream) de bytes. Algunas aplicaciones de servicios TCP son: • File Tranfer Protocol, FTP • Simple Mail Transfer Protocol, SMTP • TELNET, servicio de conexión de terminal remoto Los sockets datagrama permiten a los procesos utilizar el protocolo UDP para comunicarse a y desde esos sockets por medio de bloques. UDP es un protocolo no fiable y la entrega de los paquetes no está garantizada. Servicios UDP son: • Simple Network Management Protocol, SNMP • Trivial File Transfer Protocol, TFTP (versión de FTP sin conexión) • Versatile Message Transaction Protocol, VMTP (servicio fiable de entrega punto a punto de datagramas independiente de TCP) Los sockets raw proporcionan acceso al Internet Control Message Protocol, ICMP, y se utiliza para comunicarse entre varias entidades IP. 225
  • 226. MODELO DE COMUNICACIONES CON JAVA En Java, crear una conexión socket TCP/IP se realiza directamente con el paquete java.net. A continuación mostramos un diagrama de lo que ocurre en el lado del cliente y del servidor: El modelo de sockets más simple es: • El servidor establece un puerto y espera durante un cierto tiempo (timeout segundos), a que el cliente establezca la conexión. Cuando el cliente solicite una conexión, el servidor abrirá la conexión socket con el método accept(). • El cliente establece una conexión con la máquina host a través del puerto que se designe en puerto# • El cliente y el servidor se comunican con manejadores InputStream y OutputStream Hay una cuestión al respecto de los sockets, que viene impuesta por la implementación del sistema de seguridad de Java. Actualmente, los applets sólo pueden establecer conexiones con el nodo desde el cual se transfirió su código. Esto está implementado en el JDK y en el intérprete de Java de Netscape. Esto reduce en gran manera la flexibilidad de las fuentes de datos disponibles para los applets. El problema si se permite que un applet se conecte a cualquier máquina de la red, es que entonces se podrían utilizar los applets para inundar la 226
  • 227. red desde un ordenador con un cliente Netscape del que no se sospecha y sin ninguna posibilidad de rastreo. APERTURA DE SOCKETS Si estamos programando un cliente, el socket se abre de la forma: Socket miCliente; miCliente = new Socket( quot;maquinaquot;,numeroPuerto ); Donde maquina es el nombre de la máquina en donde estamos intentando abrir la conexión y numeroPuerto es el puerto (un número) del servidor que está corriendo sobre el cual nos queremos conectar. Cuando se selecciona un número de puerto, se debe tener en cuenta que los puertos en el rango 0-1023 están reservados para usuarios con muchos privilegios (superusuarios o root). Estos puertos son los que utilizan los servicios estándar del sistema como email, ftp o http. Para las aplicaciones que se desarrollen, asegurarse de seleccionar un puerto por encima del 1023. En el ejemplo anterior no se usan excepciones; sin embargo, es una gran idea la captura de excepciones cuando se está trabajando con sockets. El mismo ejemplo quedaría como: Socket miCliente; try { miCliente = new Socket( quot;maquinaquot;,numeroPuerto ); } catch( IOException e ) { System.out.println( e ); } Si estamos programando un servidor, la forma de apertura del socket es la que muestra el siguiente ejemplo: Socket miServicio; try { miServicio = new ServerSocket( numeroPuerto ); } catch( IOException e ) { System.out.println( e ); } A la hora de la implementación de un servidor también necesitamos crear un objeto socket desde el ServerSocket para que esté atento a las conexiones que le puedan realizar clientes potenciales y poder aceptar esas conexiones: Socket socketServicio = null; try { socketServicio = miServicio.accept(); } catch( IOException e ) { System.out.println( e ); } CREACION DE STREAMS Creación de Streams de Entrada 227
  • 228. En la parte cliente de la aplicación, se puede utilizar la clase DataInputStream para crear un stream de entrada que esté listo a recibir todas las respuestas que el servidor le envíe. DataInputStream entrada; try { entrada = new DataInputStream( miCliente.getInputStream() ); } catch( IOException e ) { System.out.println( e ); } La clase DataInputStream permite la lectura de líneas de texto y tipos de datos primitivos de Java de un modo altamente portable; dispone de métodos para leer todos esos tipos como: read(), readChar(), readInt(), readDouble() y readLine(). Deberemos utilizar la función que creamos necesaria dependiendo del tipo de dato que esperemos recibir del servidor. En el lado del servidor, también usaremos DataInputStream, pero en este caso para recibir las entradas que se produzcan de los clientes que se hayan conectado: DataInputStream entrada; try { entrada = new DataInputStream( socketServicio.getInputStream() ); } catch( IOException e ) { System.out.println( e ); } Creación de Streams de Salida En el lado del cliente, podemos crear un stream de salida para enviar información al socket del servidor utilizando las clases PrintStream o DataOutputStream: PrintStream salida; try { salida = new PrintStream( miCliente.getOutputStream() ); } catch( IOException e ) { System.out.println( e ); } La clase PrintStream tiene métodos para la representación textual de todos los datos primitivos de Java. Sus métodos write y println() tienen una especial importancia en este aspecto. No obstante, para el envío de información al servidor también podemos utilizar DataOutputStream: DataOutputStream salida; try { salida = new DataOutputStream( miCliente.getOutputStream() ); } catch( IOException e ) { System.out.println( e ); } La clase DataOutputStream permite escribir cualquiera de los tipos primitivos de Java, muchos de sus métodos escriben un tipo de dato primitivo en el stream de salida. De todos esos métodos, el más útil quizás sea writeBytes(). En el lado del servidor, podemos utilizar la clase PrintStream para enviar información al cliente: 228
  • 229. PrintStream salida; try { salida = new PrintStream( socketServicio.getOutputStream() ); } catch( IOException e ) { System.out.println( e ); } Pero también podemos utilizar la clase DataOutputStream como en el caso de envío de información desde el cliente. CIERRE DE SOCKETS Siempre deberemos cerrar los canales de entrada y salida que se hayan abierto durante la ejecución de la aplicación. En la parte del cliente: try { salida.close(); entrada.close(); miCliente.close(); } catch( IOException e ) { System.out.println( e ); } Y en la parte del servidor: try { salida.close(); entrada.close(); socketServicio.close(); miServicio.close(); } catch( IOException e ) { System.out.println( e ); } MINIMO CLIENTE SMTP Vamos a desarrollar un mínimo cliente SMTP (simple mail transfer protocol), de forma que podamos encapsular todos los datos en la aplicación. El código es libre de modificación para las necesidades que sean; por ejemplo, una modificación interesante sería que aceptase argumentos desde la línea de comandos y también capturase el texto del mensaje desde la entrada estándar del sistema. Con estas modificaciones tendríamos casi la misma aplicación de correo que utiliza Unix. Veamos el código de nuestro cliente, smtpCliente.java: import java.net.*; import java.io.*; class smtpCliente { public static void main( String args[] ) { Socket s = null; DataInputStream sIn = null; DataOutputStream sOut = null; // Abrimos una conexión con breogan en el puerto 25 229
  • 230. // que es el correspondiente al protocolo smtp, e intentamos // abrir los streams de entrada y salida try { s = new Socket( quot;breoganquot;,25 ); sIn = new DataInputStream( s.getInputStream() ); sOut = new DataOutputStream( s.getOutputStream() ); } catch( UnknownHostException e ) { System.out.println( quot;No conozco el hostquot; ); } catch( IOException e ) { System.out.println( e ); } // Si todo está inicializado correctamente, vamos a escribir // algunos datos en el canal de salida que se ha establecido // con el puerto del protocolo smtp del servidor if( s != null && sIn != null && sOut != null ) { try { // Tenemos que respetar la especificación SMTP dada en // RFC1822/3, de forma que lo que va en mayúsculas // antes de los dos puntos tiene un significado especial // en el protocolo sOut.writeBytes( quot;MAIL From: froufe@arrakis.esnquot; ); sOut.writeBytes( quot;RCPT To: froufe@arrakis.esnquot; ); sOut.writeBytes( quot;DATAnquot; ); sOut.writeBytes( quot;From: froufe@arrakis.esnquot; ); sOut.writeBytes( quot;Subject: Pruebasnquot; ); // Ahora el cuerpo del mensaje sOut.writeBytes( quot;Hola, desde el Tutorial de Javanquot; ); sOut.writeBytes( quot;n.nquot; ); // Nos quedamos a la espera de recibir el quot;Okquot; del // servidor para saber que ha recibido el mensaje // correctamente, momento en el cual cortamos String respuesta; while( ( respuesta = sIn.readLine() ) != null ) { System.out.println( quot;Servidor: quot;+respuesta ); if( respuesta.indexOf( quot;Okquot; ) != -1 ) break; } // Cerramos todo lo que hemos abierto sOut.close(); sIn.close(); s.close(); } catch( UnknownHostException e ) { System.out.println( quot;Intentando conectar: quot;+e ); } catch( IOException e ) { System.out.println( e ); } } } } SERVIDOR DE ECO 230
  • 231. En el siguiente ejemplo, vamos a desarrollar un servidor similar al que se ejecuta sobre el puerto 7 de las máquinas Unix, el servidor echo. Básicamente, este servidor recibe texto desde un cliente y reenvía ese mismo texto al cliente. Desde luego, este es el servidor más simple de los simples que se pueden escribir. El ejemplo que presentamos, ecoServidor.java, maneja solamente un cliente. Una modificación interesante sería adecuarlo para que aceptase múltiples clientes simultáneos mediante el uso de threads. import java.net.*; import java.io.*; class ecoServidor { public static void main( String args[] ) { ServerSocket s = null; DataInputStream sIn; PrintStream sOut; Socket cliente = null; String texto; // Abrimos una conexión con breogan en el puerto 9999 // No podemos elegir un puerto por debajo del 1023 si no somos // usuarios con los máximos privilegios (root) try { s = new ServerSocket( 9999 ); } catch( IOException e ) { } // Creamos el objeto desde el cual atenderemos y aceptaremos // las conexiones de los clientes y abrimos los canales de // comunicación de entrada y salida try { cliente = s.accept(); sIn = new DataInputStream( cliente.getInputStream() ); sOut = new PrintStream( cliente.getOutputStream() ); // Cuando recibamos datos, se los devolvemos al cliente // que los haya enviado while( true ) { texto = sIn.readLine(); sOut.println( texto ); } } catch( IOException e ) { System.out.println( e ); } } } CLIENTE/SERVIDOR TCP/IP Mínimo Servidor TCP/IP Veamos el código que presentamos en el siguiente ejemplo, minimoServidor.java, donde desarrollamos un mínimo servidor TCP/IP, para el cual desarrollaremos después su contrapartida cliente TCP/IP. La aplicación servidor TCP/IP depende de una clase de 231
  • 232. comunicaciones proporcionada por Java: ServerSocket. Esta clase realiza la mayor parte del trabajo de crear un servidor. import java.awt.*; import java.net.*; import java.io.*; class minimoServidor { public static void main( String args[] ) { ServerSocket s = (ServerSocket)null; Socket s1; String cadena = quot;Tutorial de Java!quot;; int longCad; OutputStream s1out; // Establece el servidor en el socket 4321 (espera 300 segundos) try { s = new ServerSocket( 4321,300 ); } catch( IOException e ) { System.out.println( e ); } // Ejecuta un bucle infinito de listen/accept while( true ) { try { // Espera para aceptar una conexión s1 = s.accept(); // Obtiene un controlador de fichero de salida asociado // con el socket s1out = s1.getOutputStream(); // Enviamos nuestro texto longCad = sendString.length(); for( int i=0; i < longCad; i++ ) s1out.write( (int)sendString.charAt( i ) ); // Cierra la conexión, pero no el socket del servidor s1.close(); } catch( IOException e ) { System.out.println( e ); } } } } Mínimo Cliente TCP/IP El lado cliente de una aplicación TCP/IP descansa en la clase Socket. De nuevo, mucho del trabajo necesario para establecer la conexión lo ha realizado la clase Socket. Vamos a presentar ahora el código de nuestro cliente más simple, minimoCliente.java, que encaja con el servidor presentado antes. El trabajo que realiza este cliente es que todo lo que recibe del servidor lo imprime por la salida estándar del sistema. import java.awt.*; import java.net.*; import java.io.*; 232
  • 233. class minimoCliente { public static void main( String args[] ) throws IOException { int c; Socket s; InputStream sIn; // Abrimos una conexión con breogan en el puerto 4321 try { s = new Socket( quot;breoganquot;,4321 ); } catch( IOException e ) { System.out.println( e ); } // Obtenemos un controlador de fichero de entrada del socket y // leemos esa entrada sIn = s.getInputStream(); while( ( c = sIn.read() ) != -1 ) System.out.print( (char)c ); // Cuando se alcance el fin de fichero, cerramos la conexión y // abandonamos s.close(); } } SERVIDOR SIMPLE DE HTTP Vamos a implementar un servidor de HTTP básico, sólo le permitiremos admitir operaciones GET y un rango limitado de tipos MIME codificados. Los tipos MIME son los descriptores de tipo para contenido multimedia. Esperamos que este ejemplo sirva como base para un entretenido ejercicio de ampliación y exploración porque, desde luego, lo que no pretendemos es inquietar a los Consejos de Dirección de Microsoft o Netscape. La aplicación va a crear un ServerSocket conectado al puerto 80, que en caso de no tener privilegios para su uso, podemos cambiar, por ejemplo al 8080; y después entra en un bucle infinito. Dentro del bucle, espera dentro del método accept() del ServerSocket hasta que se establece una conexión cliente. Después asigna un flujo de entrada y salida al socket. A continuación lee la solicitud del cliente utilizando el método getRawRequest(), que devolverá un null si hay un error de entrada/salida o el cliente corta la conexión. Luego se identifica el tipo de solicitud y se gestiona mediante el método handlget() o handleUnsup(). Finalmente se cierran los sockets y se comienza de nuevo. Cuando se ejecuta el programa completo, se escribe en pantalla lo que el navegador cliente envía al servidor. Aunque se capturan varias condiciones de error, en la práctica no aparecen. El ampliar este servidor para que soporte una carga de millones de visitas al día requiere bastante trabajo; no obstante, en el ordenador en que estoy escribiendo esto, no se enlenteció demasiado con una carga de hasta diez entradas por segundo, lo que permitiría alrededor de un millón de visitas al día. Se podría mejorar mediante el uso de threads y control de la memoria caché para gestionar esas visitas, pero eso ya forma parte del ejercicio sobre el que se puede trabajar. 233
  • 234. El código fuente de nuestro mini servidor de HTTP se encuentra en el fichero TutHttp.java, que reproducimos a continuación: import java.net.*; import java.io.*; import java.util.*; // Clase de utilidades donde declaramos los tipos MIME y algunos gestores // de los errores que se pueden generar en HTML class HttpUtilidades { final static String version = quot;1.0quot;; final static String mime_text_plain = quot;text/plainquot;; final static String mime_text_html = quot;text/htmlquot;; final static String mime_image_gif = quot;image/gifquot;; final static String mime_image_jpg = quot;image/jpgquot;; final static String mime_app_os = quot;application/octet-streamquot;; final static String CRLF = quot;rnquot;; // Método que convierte un objeto String en una matriz de bytes. // Java gestiona las cadenas como objetos, por lo que es necesario // convertir las matrices de bytes que se obtienen a Strings y // viceversa public static byte aBytes( String s )[] { byte b[] = new byte[ s.length() ]; s.getBytes( 0,b.length,b,0 ); return( b ); } // Este método concatena dos matrices de bytes. El método // arraycopy() asombra por su rapidez public static byte concatenarBytes( byte a[],byte b[] )[] { byte ret[] = new byte[ a.length+b.length ]; System.arraycopy( a,0,ret,0,a.length ); System.arraycopy( b,0,ret,a.length,b.length ); return( ret ); } // Este método toma un tipo de contenido y una longitud, para // devolver la matriz de bytes que contiene el mensaje de cabecera // MIME con formato public static byte cabMime( String ct,int tam )[] { return( cabMime( 200,quot;OKquot;,ct,tam ) ); } // Es el mismo método anterior, pero permite un ajuste más fino // del código que se devuelve y el mensaje de error de HTTP public static byte cabMime(int codigo,String mensaje,String ct, int tam )[] { Date d = new Date(); return( aBytes( quot;HTTP/1.0 quot;+codigo+quot; quot;+mensaje+CRLF+ quot;Date: quot;+d.toGMTString()+CRLF+ quot;Server: Java/quot;+version +CRLF+ quot;Content-type: quot;+ct+CRLF+ ( tam > 0 ? quot;Content-length: quot;+tam+CRLF : quot;quot; )+CRLF ) ); } // Este método construye un mensaje HTML con un formato decente 234
  • 235. // para presentar una condición de error y lo devuelve como // matriz de bytes public static byte error( int codigo,String msg,String fname)[] { String ret = quot;<BODY>quot;+CRLF+quot;<H1>quot;+codigo+quot; quot;+msg+quot;</H1>quot;+CRLF; if( fname != null ) ret += quot;Error al buscar el URL: quot;+fname+CRLF; ret += quot;</BODY>quot;+CRLF; byte tmp[] = cabMime( codigo,msg,mime_text_html,0 ); return( concatenarBytes( tmp,aBytes( ret ) ) ); } // Devuelve el tipo MIME que corresponde a un nombre de archivo dado public static String mimeTypeString( String fichero ) { String tipo; if( fichero.endsWith( quot;.htmlquot; ) || fichero.endsWith( quot;.htmquot; ) ) tipo = mime_text_html; else if( fichero.endsWith( quot;.classquot; ) ) tipo = mime_app_os; else if( fichero.endsWith( quot;.gifquot; ) ) tipo = mime_image_gif; else if( fichero.endsWith( quot;.jpgquot; ) ) tipo = mime_image_jpg; else tipo = mime_text_plain; return( tipo ); } } // Esta clase sirve para que nos enteremos de lo que está haciendo // nuestro servidor. En una implementación real, todos estos mensajes // deberían registrarse en algún fichero class HTTPlog { public static void error( String entrada ) { System.out.println( quot;Error: quot;+entrada ); } public static void peticion( String peticion ) { System.out.println( peticion ); } } // Esta es la clase principal de nuestro servidor Http class TutHttp { public static final int puerto = 80; final static String docRaiz = quot;/htmlquot;; final static String fichIndice = quot;index.htmlquot;; final static int buffer = 2048; public static final int RT_GET=1; public static final int RT_UNSUP=2; public static final int RT_END=4; // Indica que la petición no está soportada, por ejemplo POST y HEAD private static void ctrlNoSop(String peticion,OutputStream sout) { HTTPlog.error( quot;Peticion no soportada: quot;+peticion ); } 235
  • 236. // Este método analiza gramaticalmente la solicitud enviada con el // GET y la descompone en sus partes para extraer el nombre del // archivo que se está solicitando. Entonces lee el fichero que // se pide private static void ctrlGet( String peticion,OutputStream sout ) { int fsp = peticion.indexOf( ' ' ); int nsp = peticion.indexOf( ' ',fsp+1 ); String fich = peticion.substring( fsp+1,nsp ); fich = docRaiz+fich+( fich.endsWith(quot;/quot;) ? fichIndice : quot;quot; ); try { File f = new File( fich ); if( !f.exists() ) { sout.write( HttpUtilidades.error( 404, quot;No Encontradoquot;,fich ) ); return; } if( !f.canRead() ) { sout.write( HttpUtilidades.error( 404, quot;Permiso Denegadoquot;,fich ) ); return; } // Ahora lee el fichero que se ha solicitado InputStream sin = new FileInputStream( f ); String cabmime = HttpUtilidades.mimeTypeString( fich ); int n = sin.available(); sout.write( HttpUtilidades.cabMime( cabmime,n ) ); byte buf[] = new byte[buffer]; while( ( n = sin.read( buf ) ) >= 0 ) sout.write( buf,0,n ); sin.close(); } catch( IOException e ) { HTTPlog.error( quot;Excepcion: quot;+e ); } } // Devuelve la cabecera de la solicitud completa del cliente al // método main de nuestro servidor private static String getPeticion( InputStream sin ) { try { byte buf[] = new byte[buffer]; boolean esCR = false; int pos = 0; int c; while( ( c = sin.read() ) != -1 ) { switch( c ) { case 'r': break; case 'n': 236
  • 237. if( esCR ) return( new String( buf,0,0,pos ) ); esCR = true; // Continúa, se ha puesto el primer n en la cadena default: if( c != 'n' ) esCR = false; buf[pos++] = (byte)c; } } } catch( IOException e ) { HTTPlog.error( quot;Error de Recepcionquot; ); } return( null ); } private static int tipoPeticion( String peticion ) { return( peticion.regionMatches( true,0,quot;get quot;,0,4 ) ? RT_GET : RT_UNSUP ); } // Función principal de nuestro servidor, que se conecta al socket // y se embucla indefinidamente public static void main( String args[] ) throws Exception { ServerSocket ss = new ServerSocket( puerto ); while( true ) { String peticion; Socket s = ss.accept(); OutputStream sOut = s.getOutputStream(); InputStream sIn = s.getInputStream(); if( ( peticion = getPeticion( sIn ) ) != null ) { switch( tipoPeticion( peticion ) ) { case RT_GET: ctrlGet( peticion,sOut ); break; case RT_UNSUP: default: ctrlNoSop( peticion,sOut ); break; } HTTPlog.peticion( peticion ); } sIn.close(); sOut.close(); s.close(); } } } EJECUTAR TCP/IP EN Windows '95 237
  • 238. Las indicaciones que se proporcionan a continuación, van a permitirnos fijar los parámetros de Windows '95 para que se puedan ejecutar programas cliente y servidor, sin necesidad de que el ordenador en el cual se está ejecutando Windows '95 esté conectado a una red de área local. Esto puede resultar útil para mucha gente que está probando Java en su casa y no dispone de red, o incluso para aquellos programadores o estudiosos que quieren probar sus nuevos programas distribuidos pero no disponen de red o de Internet. Advertencia: Si los siguientes parámetros se van a fijar en un ordenador portátil que en ocasiones sí se conecte a una red, sería conveniente anotar los parámetros actuales de la configuración de Windows '95, para que sean fácilmente recuperables cuando este ordenador se vuelva a conectar a la red. Configuración del TCP/IP de Windows '95 Hay que seguir los pasos que vamos a relatar a continuación, suponemos que se está ejecutando la versión española de Windows '95, en otras versiones puede que las opciones tengan nombre diferente: 1. En el Panel de Control, seleccionar Red 2. Picar Agregar, luego Protocolo y luego Agregar 3. Seleccionar Microsoft y luego TCP/IP y picar en Aceptar 4. En este momento probablemente se solicite la introducción de los discos de Windows '95, o del CD-ROM 5. Seleccionar la pestaña Configuración de la ventana Red 6. Seleccionar TCP/IP en la lista que aparece y picar Propiedades 7. Seleccionar la pestaña Dirección IP o Crearse una dirección IP, como por ejemplo: 102.102.102.102 o Crearse una Máscara de subred, como: 255.255.255.0 8. Seleccionar la pestaña Configuración DNS y desactivar DNS 9. Los valores correspondientes a las otras cuatro pestañas pueden dejarse los que hay por defecto 10. Picar Aceptar 11. (Opcional) Seleccionar la pestaña Identificación de la ventana Red 12. (Opcional) Introducir un nombre para el ordenador, como por ejemplo: breogan 13. (Opcional) Picar Aceptar Crear una entrada en la quot;redquot; 238
  • 239. 1. Editar el fichero hosts.sam que está en el directorio de Windows 2. Al final del fichero incorporar la dirección IP y el nombre del ordenador que se han introducido antes, en nuestro caso: 102.102.102.102 breogan 3. Asegurarse de que la dirección IP y el nombre coinciden con la dirección IP que se ha fijado en el paso 7a de antes y que el nombre es el mismo que el indicado en el paso 12 anterior 4. Salvar el fichero con el nombre quot;hostsquot; y reiniciar Windows '95 Comprobación de la red 1. Abrir una sesión MS-DOS 2. Teclear quot;ping breoganquot; 3. Debería aparecer: 4. Pinging breogan [102.102.102.102] with 32 bytes of data: 5. Reply from 102.102.102.102: bytes=32 time=1ms TTL=32 6. Reply from 102.102.102.102: bytes=32 time<10ms TTL=32 7. Reply from 102.102.102.102: bytes=32 time<10ms TTL=32 8. Reply from 102.102.102.102: bytes=32 time<10ms TTL=32 9. Teclear quot;tracert 102.102.102.102quot; 10. Debería aparecer: 11. Tracing route to 102.102.102.102 over a maximum of 30 hops 12. 1 <10 ms 1 ms <10 ms 102.102.102.102 13. Trace complete. En este instante, si todo ha ido bien, el ordenador está listo para funcionar como si estuviera en red. Dos o más programas que se comuniquen en red a través de sockets debería poder ejecutarse ahora dentro de los dominios del ordenador que acabamos de configurar Problemas más frecuentes Los tres problemas que pueden presentarse cuando intentemos comprobar el funcionamiento correcto de la red interna que acabamos de montar son: Cuando hacemos quot;pingquot; obtenemos quot;Bad IP address breoganquot; Intentar teclear quot;ping 102.102.102.102quot;. Si ahora sí se obtiene réplica, la causa del problema es que el los pasos 12 de la Configuración y 3 de la Creación de la entrada en la tabla de hosts, no se ha introducido correctamente el nombre de la máquina. Comprobar esos pasos y que todo coincide. El programa cliente o el servidor fallan al intentar el quot;connectquot; 239
  • 240. La causa podría estar en que se produzca un fallo por fichero no encontrado en el directorio Windows/System de las librerías WINSOCK.DLL o WSOCK32.DLL. Muchos programas que se utilizan en Internet reemplazan estos ficheros cuando se instalan. Asegurarse de que están estos ficheros y que son los originales que vienen con la distribución de Windows '95. El programa servidor dice que no puede quot;bindquot; a un socket Esto sucede porque tiene el DNS activado y no puede encontrar ese DNS o servidor de direcciones, porque estamos solos en la red. Asegurarse de que en el paso 8 de la Configuración la opción de DNS está deshabilitada. CLASES UTILES EN COMUNICACIONES Vamos a exponer otras clases que resultan útiles cuando estamos desarrollando programas de comunicaciones, aparte de las que ya se han visto. El problema es que la mayoría de estas clases se prestan a discusión, porque se encuentran bajo el directorio sun. Esto quiere decir que son implementaciones Solaris y, por tanto, específicas del Unix Solaris. Además su API no está garantizada, pudiendo cambiar. Pero, a pesar de todo, resultan muy interesantes y vamos a comentar un grupo de ellas solamente que se encuentran en el paquete sun.net Socket Es el objeto básico en toda comunicación a través de Internet, bajo el protocolo TCP. Esta clase proporciona métodos para la entrada/salida a través de streams que hacen la lectura y escritura a través de sockets muy sencilla. ServerSocket Es un objeto utilizado en las aplicaciones servidor para escuchar las peticiones que realicen los clientes conectados a ese servidor. Este objeto no realiza el servicio, sino que crea un objeto Socket en función del cliente para realizar toda la comunicación a través de él. DatagramSocket La clase de sockets datagrama puede ser utilizada para implementar datagramas no fiables (sockets UDP), no ordenados. Aunque la comunicación por estos sockets es muy rápida porque no hay que perder tiempo estableciendo la conexión entre cliente y servidor. DatagramPacket Clase que representa un paquete datagrama conteniendo información de paquete, longitud de paquete, direcciones Internet y números de puerto. MulticastSocket 240
  • 241. Clase utilizada para crear una versión multicast de las clase socket datagrama. Múltiples clientes/servidores pueden transmitir a un grupo multicast (un grupo de direcciones IP compartiendo el mismo número de puerto). NetworkServer Una clase creada para implementar métodos y variables utilizadas en la creación de un servidor TCP/IP. NetworkClient Una clase creada para implementar métodos y variables utilizadas en la creación de un cliente TCP/IP. SocketImpl Es un Interface que nos permite crearnos nuestro propio modelo de comunicación. Tendremos que implementar sus métodos cuando la usemos. Si vamos a desarrollar una aplicación con requerimientos especiales de comunicaciones, como pueden se la implementación de un cortafuegos (TCP es un protocolo no seguro), o acceder a equipos especiales (como un lector de código de barras o un GPS diferencial), necesitaremos nuestra propia clase Socket. Vamos a ver un ejemplo de utilización, presentando un sencillo ejemplo, servidorUDP.java, de implementación de sockets UDP utilizando la clase DatagramSocket. import java.net.*; import java.io.*; import sun.net.*; // Implementación del servidor de datagramas UDP. Envía una cadena // tras petición // class servidorUDP { public static void main( String args[] ) { DatagramSocket s = (DatagramSocket)null; DatagramPacket enviap,recibep; byte ibuffer[] = new byte[100]; String cadena = quot;Hola Tutorial de Java!nquot;; InetAddress IP = (InetAddress)null; int longitud = sendString.length(); int puertoEnvio = 4321; int puertoRecep = 4322; int puertoRemoto; // Intentamos conseguir la dirección IP del host try { IP = InetAddress.getByName( quot;bregoganquot; ); } catch( UnknownHostException e ) { System.out.println( quot;No encuentro al host breoganquot; ); System.exit( -1 ); } 241
  • 242. // Establecemos el servidor para escuchar en el socket 4322 try { s = new DatagramSocket( puertoRecep ); } catch( SocketException e ) { System.out.println( quot;Error - quot;+e.toString() ); } // Creamos un paquete de solicitud en el cliente // y nos quedamos esperando a sus peticiones recibep = new DatagramPacket( ibuffer,longitud ); try { s.receive( recibep ); } catch( IOException e ) { System.out.println( quot;Error - quot;+e.toString() ); } // Creamos un paquete para enviar al cliente y lo enviamos sendString.getBytes( 0,longitud,ibuffer,0 ); enviap = new DatagramPacket( ibuffer,longitud,IP,puertoEnvio ); try { s.send( enviap ); } catch( IOException e ) { System.out.println( quot;Error - quot;+e.toString() ); System.exit( -1 ); } // Cerramos el socket s.close(); } } Y también vamos a implementar el cliente, clienteUDP.java, del socket UDP correspondiente al servidor que acabamos de presentar: import java.net.*; import java.io.*; import sun.net.*; // Implementación del cliente de datagramas UDP. Devuelve la salida // de los servidores // class clienteUDP { public static void main( String args[] ) { int longitud = 100; DatagramSocket s = (DatagramSocket)null; DatagramPacket enviap,recibep; byte ibuffer[] = new byte[100]; InetAddress IP = (InetAddress)null; int puertoEnvio = 4321; int puertoRecep = 4322; // Abre una conexión y establece el cliente para recibir // una petición en el socket 4321 try { s = new DatagramSocket( puertoRecep ); } catch( SocketException e ) { 242
  • 243. System.out.println( quot;Error - quot;+e.toString() ); } // Crea una petición para enviar bytes. Intenta conseguir // la dirección IP del host try { IP = InetAddress.getByName( quot;depserverquot; ); } catch( UnknownHostException e ) { System.out.println( quot;No encuentro el host depserverquot; ); System.exit( -1 ); } // Envía una petición para que responda el servidor try { enviap = new DatagramPacket( ibuffer,ibuffer.length, IP,4322 ); s.send( enviap ); } catch( IOException e ) { System.out.println( quot;Error - quot;+e.toString() ); } // Consigue un controlador de fichero de entrada del socket y lee // dicha entrada. Creamos un paquete descriptor para recibir el // paquete UDP recibep = new DatagramPacket( ibuffer,longitud ); // Espera a recibir un paquete try { s.receive( recibep ); } catch( IOException e ) { System.out.println( quot;Error - quot;+e.toString() ); System.exit( -1 ); } // Imprimimos los resultados de lo que conseguimos System.out.println( quot;Recibido: quot;+recibep.getLength()+quot; bytesquot; ); String datos = new String( recibep.getData(),0 ); System.out.println( quot;Datos: quot;+datos ); System.out.println( quot;Recibido por puerto: quot;+recibep.getPort() ); // Cerramos la conexión y abandonamos s.close(); } } La salida que se producirá cuando ejecutemos primero el servidor y luego el cliente será la misma que reproducimos a continuación: %java clienteUDP Recibido: 17 bytes Datos: Hola Tutorial de Java! Recibido por puerto: 4322 243
  • 244. ARQUITECTURA MODELO / VISTA / CONTROLADOR Vamos a presentar, por curiosidad más que por otra cosa, una introducción a la interface Observer y a la clase Observable que proporciona Java. Vamos a implementar programas basados en la arquitectura Modelo/Vista/Controlador, popularizada por el lenguaje Smalltalk. Presentamos el problema: queremos diseñar un programa que visualice los datos de una escena en tres dimensiones y lo pase a dos dimensiones. El programa debe ser modular y permitir vistas múltiples y simultáneas de la misma escena. Cada vista debe ser capaz de presentar la escena desde diferentes puntos de vista y distintas condiciones de iluminación. Y, más importante todavía, si alguna porción de una escena cambia, las vistas deben actualizarse automáticamente. Otra versión del problema sería el de una hoja de cálculo, en donde tenemos una serie de datos que queremos ver representados gráficamente, para ello dispondremos de varias vistas con gráficos de línea, de barra o de tarta, y deben actualizarse automáticamente según vayan cambiando los datos que figuran en la hoja de cálculo. Ninguno de los requerimientos anteriores presenta una carga de programación imposible. Si el código que controla cada uno de los requerimientos ha de ser escrito de nuevo, sin embargo, si que supondría un esfuerzo significativo. Afortunadamente, el soporte para estas tareas ya esta proporcionado por la librería de Java, a través del interface Observer y la clase Observable. Las funcionalidades de las dos se han inspirado, en parte, en la arquitectura Modelo/Vista/Controlador. ARQUITECTURA Modelo/Vista/Controlador La arquitectura MVC (Model/View/Controller) fue introducida como parte de la versión Smalltalk-80 del lenguaje de programación Smalltalk. Fue diseñada para reducir el esfuerzo de programación necesario en la implementación de sistemas múltiples y sincronizados de los mismos datos. Sus características principales son que el Modelo, las Vistas y los Controladores se tratan como entidades separadas; esto hace que cualquier cambio producido en el Modelo se refleje automáticamente en cada una de las Vistas. 244
  • 245. Además del programa ejemplo que hemos presentado al principio y que posteriormente implementaremos, este modelo de arquitectura se puede emplear en sistemas de representación gráfica de datos, como se ha citado, o en sistemas CAD, en donde se presentan partes del diseño con diferente escala de aumento, en ventanas separadas. En la figura siguiente, vemos la arquitectura MVC en su forma más general. Hay un Modelo, múltiples Controladores que manipulan ese Modelo, y hay varias Vistas de los datos del Modelo, que cambian cuando cambia el estado de ese Modelo. Este modelo de arquitectura presenta varias ventajas: • Hay una clara separación entre los componentes de un programa; lo cual nos permite implementarlos por separado • Hay un API muy bien definido; cualquiera que use el API, podrá reemplazar el Modelo, la Vista o el Controlador, sin aparente dificultad. • La conexión entre el Modelo y sus Vistas es dinámica; se produce en tiempo de ejecución, no en tiempo de compilación. Al incorporar el modelo de arquitectura MVC a un diseño, las piezas de un programa se pueden construir por separado y luego unirlas en tiempo de ejecución. Si uno de los Componentes, posteriormente, se observa que funciona mal, puede reemplazarse sin que las otras piezas se vean afectadas. Este escenario contrasta con la aproximación monolítica típica de muchos programas Java. Todos tienen un Frame que contiene todos los elementos, un controlador de eventos, un montón de cálculos y la presentación del resultado. Ante esta perspectiva, hacer un cambio aquí no es nada trivial. Definición de las partes El Modelo es el objeto que representa los datos del programa. Maneja los datos y controla todas sus transformaciones. El Modelo no tiene conocimiento específico de los Controladores o de las Vistas, ni siquiera contiene referencias a ellos. Es el propio sistema el que tiene encomendada la responsabilidad de mantener enlaces entre el Modelo y sus Vistas, y notificar a las Vistas cuando cambia el Modelo. La Vista es el objeto que maneja la presentación visual de los datos representados por el Modelo. Genera una representación visual del Modelo y muestra los datos al usuario. Interactúa con el Modelo a través de una referencia al propio Modelo. El Controlador es el objeto que proporciona significado a las ordenes del usuario, actuando sobre los datos representados por el Modelo. Cuando se realiza algún cambio, entra en 245
  • 246. acción, bien sea por cambios en la información del Modelo o por alteraciones de la Vista. Interactúa con el Modelo a través de una referencia al propio Modelo. Vamos a mostrar un ejemplo concreto. Consideremos como tal el sistema descrito en la introducción a este capítulo, una pieza geométrica en tres dimensiones, que representamos en la figura siguiente: En este caso, la pieza central de la escena en tres dimensiones es el Modelo. El Modelo es una descripción matemática de los vértices y las caras que componen la escena. Los datos que describen cada vértice o cara pueden modificarse (quizás como resultado de una acción del usuario, o una distorsión de la escena, o un algoritmo de sombreado). Sin embargo, no tiene noción del punto de vista, método de presentación, perspectiva o fuente de luz. El Modelo es una representación pura de los elementos que componen la escena. La porción del programa que transforma los datos dentro del Modelo en una presentación gráfica es la Vista. La Vista incorpora la visión del Modelo a la escena; es la representación gráfica de la escena desde un punto de vista determinado, bajo condiciones de iluminación determinadas. El Controlador sabe que puede hacer el Modelo e implementa el interface de usuario que permite iniciar la acción. En este ejemplo, un panel de datos de entrada es lo único que se necesita, para permitir añadir, modificar o borrar vértices o caras de la figura. OBSERVADOR Y OBSERVABLE El lenguaje de programación Java proporciona soporte para la arquitectura MVC mediante dos clases: • Observer: Es cualquier objeto que desee ser notificado cuando el estado de otro objeto sea alterado • Observable: Es cualquier objeto cuyo estado puede representar interés y sobre el cual otro objeto ha demostrado ese interés Estas dos clases se pueden utilizar para muchas más cosas que la implementación de la arquitectura MVC. Serán útiles en cualquier sistema en que se necesite que algunos objetos sean notificados cuando ocurran cambios en otros objetos. El Modelo es un subtipo de Observable y la Vista es un subtipo de Observer. Estas dos clases manejan adecuadamente la función de notificación de cambios que necesita la arquitectura MVC. Proporcionan el mecanismo por el cual las Vistas pueden ser notificadas automáticamente de los cambios producidos en el Modelo. Referencias al objeto Modelo 246
  • 247. tanto en el Controlador como en la Vista permiten acceder a los datos de ese objeto Modelo. Funciones Observer y Observable Vamos a enumerar las funciones que intervienen en el control de Observador y Observable: Observer public void update( Observableobs,Object obj ) Llamada cuando se produce un cambio en el estado del objeto Observable Observable public void addObserver( Observer obs ) Añade un observador a la lista interna de observadores public void deleteObserver( Observer obs ) Borra un observador de la lista interna de observadores public void deleteObservers() Borra todos los observadores de la lista interna public int countObserver() Devuelve el número de observadores en la lista interna protected void setChanged() Levanta el flag interno que indica que el Observable ha cambiado de estado protected void clearChanged() Baja el flag interno que indica que el Observable ha cambiado de estado protected boolean hasChanged() Devuelve un valor booleano indicando si el Observable ha cambiado de estado public void notifyObservers() Comprueba el flag interno para ver si el Observable ha cambiado de estado y lo notifica a todos los observadores public void notifyObservers( Object obj ) Comprueba el flag interno para ver si el Observable ha cambiado de estado y lo notifica a todos los observadores. Les pasa el objeto especificado en la llamada para que lo usen los observadores en su método notify(). UTILIZAR OBSERVADOR Y OBSERVABLE Vamos a describir en los siguientes apartados, como crear una nueva clase Observable y una nueva clase Observer y como utilizar las dos conjuntamente. 247
  • 248. Extender un Observable Una nueva clase de objetos observables se crea extendiendo la clase Observable. Como la clase Observable ya implementa todos los métodos necesarios para proporcionar el funcionamiento de tipo Observador/Observable, la clase derivada solamente necesita proporcionar algún tipo de mecanismo que lo ajuste a su funcionamiento particular y proporcionar acceso al estado interno del objeto Observable. En la clase ValorObservable que mostramos a continuación, el estado interno del Modelo es capturado en el entero n. A este valor se accede (y más importante todavía, se modifica) solamente a través de sus métodos públicos. Si el valor cambia, el objeto invoca a su propio método setChanged() para indicar que el estado del Modelo ha cambiado. Luego, invoca a su propio método notifyObservers() para actualizar a todos los observadores registrados. import java.util.Observable; public class ValorObservable extends Observable { private int nValor = 0; // Constructor al que indicamos el valor en que comenzamos y los // limites inferior y superior que no deben sobrepasarse public ValorObservable( int nValor,int nInferior,int nSuperior ) { this.nValor = nValor; } // Fija el valor que le pasamos y notifica a los observadores que // estan pendientes del cambio de estado de los objetos de esta // clase, que su etado se ha visto alterado public void setValor(int nValor) { this.nValor = nValor; setChanged(); notifyObservers(); } // Devuelve el valor actual que tiene el objeto public int getValor() { return( nValor ); } } Implementar un Observador Una nueva clase de objetos que observe los cambios en el estado de otro objeto se puede crear implementando la interface Observer. Esta interface necesita un método update() que se debe proporcionar en la nueva clase. Este método será llamado siempre que el Observable cambie de estado, que anuncia este cambio llamando a su método notifyObservers(). El observador entonces, debería interrogar al objeto Observable para determinar su nuevo estado; y, en el caso de la arquitectura MVC, ajustar su Vista adecuadamente. En la clase ObservadorDeTexto, que muestra el código siguiente, el método notify() primero realiza una comprobación para asegurarse de que el Observable que ha anunciado 248
  • 249. un cambio es el Observable que él esta observando. Si lo es, entonces lee su estado e imprime el nuevo valor. import java.util.Observer; import java.util.Observable; public class TextoObservador extends Frame implements Observer { private ValorObservable vo = null; public TextoObservador( ValorObservable vo ) { this.vo = vo; } public void update( Observable obs,Object obj ) { if( obs == vo ) tf.setText( String.valueOf( vo.getValor() ) ); } } Usando Observador y Observable Un programa indica a un objeto Observable que hay un objeto observador que debe ser notificado cuando se produzca un cambio en su estado, llamando al método addObserver() del objeto Observable. Este método añade el Observador a la lista de observadores que el objeto Observable ha de notificar cuando su estado se altere. En el ejemplo siguiente, en donde mostramos la clase ControlValor, ControlValor.java, vemos como se usa el método addObserver() para añadir una instancia de la clase TextoObservador a la lista que mantiene la clase ValorObservable. public class ControlValor { // Constructor de la clase que nos permite crear los objetos de // observador y observable public ControlValor() { ValorObservable vo = new ValorObservable( 100,0,500 ); TextoObservador to = new TextoObservador( vo ); vo.addObserver( to ); } public static void main( String args[] ) { ControlValor m = new ControlValor(); } } En la siguiente secuencia, vamos a describir como se realiza la interacción entre un Observador y un objeto Observable, durante la ejecución de un programa: 1. En primer lugar el usuario manipula un elemento del interface de usuario representado por el Controlador. Este Controlador realiza un cambio en el Modelo a través de uno de sus métodos públicos de acceso; en nuestro caso, llama a setValue(). 2. El método público de acceso modifica el dato privado, ajusta el estado interno del Modelo y llama al método setChanged() para indicar que su estado ha cambiado. 249
  • 250. Luego llama al método notifyObservers() para notificar a los observadores que su estado no es el mismo. La llamada a este método puede realizarse en cualquier lugar, incluso desde un bucle de actualización que se esté ejecutando en otro thread. 3. Se llama a los métodos update() de cada Observador, indicando que hay un cambio en el estado del objeto que estaban observando. El Observador accede entonces a los datos del Modelo a través del método público del Observable y actualiza las Vistas. EJEMPLO DE APLICACION MVC En el ejemplo siguiente, vemos como colaboran juntos Observador y Observable en la arquitectura MVC: el Modelo de este ejemplo es muy simple. Su estado interno consta de un valor entero. Este valor, o estado, es manipulado exclusivamente a través de métodos públicos de acceso. El código del modelo se encuentra implementado en ValorObservable.java. Inicialmente, hemos escrito una clase simple de Vista/Controlador. La clase combina las características de una Vista (presenta el valor que corresponde al estado actual del Modelo) y un Controlador (permite al usuario introducir un nuevo valor para alterar el estado del Modelo). El código se encuentra en el fichero TextoObservador.java. Podemos crear instancias de esta vista pulsando el botón superior que aparece en el applet. A través de este diseño utilizando la arquitectura MVC (en lugar de colocar el código para que el Modelo, la Vista y el Controlador de texto en una clase monolítica), el sistema puede ser fácilmente rediseñado para manejar otra Vista y otro Controlador. En este caso, hemos visto una clase Vista/Controlador con una barra de desplazamiento. La posición del marcador en la barra representa el valor actual que corresponde con el estado del Modelo y puede ser alterado a través de movimientos del marcador sobre la barra por acción del usuario. El código de esta clase se encuentra en BarraObservador.java. Se pueden crear instancias de esta clase pulsando el botón inferior del applet de esta página. 250

×