1

INDICE

Marco Teorico ------------------------------------------------------------------------------------------------------- 4 Introducción a Java ------------------------------------------------------------------------------------------------- 6 Orígenes de Java ---------------------------------------------------------------------------------------------------- 7 Características de Java --------------------------------------------------------------------------------------------- 9 Características principales de Java ------------------------------------------------------------------------------- 9 Api’s de la Plataforma Java --------------------------------------------------------------------------------------- 12 Packages de Java --------------------------------------------------------------------------------------------------- 13 PARTE I : Package Java.applet ------------------------------------------------------------------------------- 14

Clase Applet ------------------------------------------------------------------------------------------------ 14 Interface Applet.context ----------------------------------------------------------------------------------- 18 Interface Applet.stub --------------------------------------------------------------------------------------- 19 Interface Audio.Clip ---------------------------------------------------------------------------------------- 19

PARTE II: Package Java.awt ----------------------------------------------------------------------------------- 19 Clase Java.AWTEvent ------------------------------------------------------------------------------------- 21 Clase Java.AWTEvent.Multicaster ---------------------------------------------------------------------- 22 Clase Java.awt.Adjustable -------------------------------------------------------------------------------- 23 Clase Java.awt.BorderLayout ----------------------------------------------------------------------------- 24 Clase Java.awt.Button ------------------------------------------------------------------------------------- 25 Clase Java.awt.Canvas ------------------------------------------------------------------------------------- 25 Clase Java.awt.CardLayout ------------------------------------------------------------------------------- 26 Clase Java.awt.Checkbox ---------------------------------------------------------------------------------- 26 Clase Java.awt.CheckboxGroup -------------------------------------------------------------------------- 27 Clase Java.awt.CheckboxMenuItem --------------------------------------------------------------------- 27 Clase Java.awt.Choice ------------------------------------------------------------------------------------- 28 Clase Java.awt.Color --------------------------------------------------------------------------------------- 29 Clase Java.awt.Component -------------------------------------------------------------------------------- 30 Clase Java.awt.Container ---------------------------------------------------------------------------------- 33 Clase Java.awt.Cursos ------------------------------------------------------------------------------------- 35 Clase Java.awt.Dialog -------------------------------------------------------------------------------------- 35 Clase Java.awt.Dimension --------------------------------------------------------------------------------- 36 Clase Java.awt.Event --------------------------------------------------------------------------------------- 36 Clase Java.awt.EventDispatchThread -------------------------------------------------------------------- 38 Clase Java.awt.EventQueue ------------------------------------------------------------------------------- 39 Clase Java.awt.FileDialog --------------------------------------------------------------------------------- 39 Clase Java.awt.FlowLayout -------------------------------------------------------------------------------- 39 Clase Java.awt.Font ---------------------------------------------------------------------------------------- 40 Clase Java.awt.FontMetrics ------------------------------------------------------------------------------- 41 Clase Java.awt.Freme -------------------------------------------------------------------------------------- 41 Clase Java.awt.Graphics ----------------------------------------------------------------------------------- 42 Clase Java.awt.GridBagConstraints ---------------------------------------------------------------------- 44 Clase Java.awt.GridBagLayoutInfo ---------------------------------------------------------------------- 44 Clase Java.awt.GridBagLayout --------------------------------------------------------------------------- 45

2

Clase Java.awt.GridLayout -------------------------------------------------------------------------------- 46 Clase Java.awt.Image --------------------------------------------------------------------------------------- 46 Clase Java.awt.Insets -------------------------------------------------------------------------------------- 47 Clase Java.awt.ItemSelectable ---------------------------------------------------------------------------- 47 Clase Java.awt.Labe ---------------------------------------------------------------------------------------- 47 Clase Java.awt.LayoutManage ---------------------------------------------------------------------------- 48 Clase Java.awt.LayoutManager2 ------------------------------------------------------------------------- 48 Clase Java.awt.List ----------------------------------------------------------------------------------------- 48 Clase Java.awt.MediaTracker ----------------------------------------------------------------------------- 50 Clase Java.awt.Menu --------------------------------------------------------------------------------------- 51 Clase Java.awt.MenuBar ---------------------------------------------------------------------------------- 51 Clase Java.awt.MenuComponent ------------------------------------------------------------------------- 52 Clase Java.awt.MenuContainer --------------------------------------------------------------------------- 52 Clase Java.awt.MenuItem --------------------------------------------------------------------------------- 53 Clase Java.awt.MenuShortcut ----------------------------------------------------------------------------- 53 Clase Java.awt.Panel --------------------------------------------------------------------------------------- 54 Clase Java.awt.Point --------------------------------------------------------------------------------------- 54 Clase Java.awt.Polygon ------------------------------------------------------------------------------------ 54 Clase Java.awt.PopupMenu ------------------------------------------------------------------------------- 55 Clase Java.awt.PrintGraphics ----------------------------------------------------------------------------- 55 Clase Java.awt.PrintJob ------------------------------------------------------------------------------------ 55 Clase Java.awt.Rectangle ---------------------------------------------------------------------------------- 56 Clase Java.awt.ScrollPane --------------------------------------------------------------------------------- 56 Clase Java.awt.Scrollbar ----------------------------------------------------------------------------------- 57 Clase Java.awt.Shape -------------------------------------------------------------------------------------- 58 Clase Java.awt.SystemColor ------------------------------------------------------------------------------ 58 Clase Java.awt.TextArea ---------------------------------------------------------------------------------- 60 Clase Java.awt.TextComponent -------------------------------------------------------------------------- 60 Clase Java.awt.TextComponet ---------------------------------------------------------------------------- 61 Clase Java.awt.TextField ---------------------------------------------------------------------------------- 61 Clase Java.awt.Toolkit -------------------------------------------------------------------------------------- 62 Clase Java.awt.Window ------------------------------------------------------------------------------------- 63

PARTE III: Package Java.awt.event ---------------------------------------------------------------------------- 64

Clase Java.awt.event.ActionEvent ------------------------------------------------------------------------ 65 Clase Java.awt.event.ActionListener --------------------------------------------------------------------- 65 Clase Java.awt.event.AdjustmentEvent ------------------------------------------------------------------ 65 Clase Java.awt.event.AdjustmentListener --------------------------------------------------------------- 66 Clase Java.awt.event.componentAdapter ---------------------------------------------------------------- 66 Clase Java.awt.event.ComponentEvent ------------------------------------------------------------------ 66 Clase Java.awt.event.ComponenentListener ------------------------------------------------------------ 67 Clase Java.awt.event.ContainerAdapter ----------------------------------------------------------------- 67 Clase Java.awt.event.ContainerEvent -------------------------------------------------------------------- 67 Clase Java.awt.event.ContainerListener ----------------------------------------------------------------- 68 Clase Java.awt.event.FocusAdapter ---------------------------------------------------------------------- 68 Clase Java.awt.event.FocusEvent ------------------------------------------------------------------------- 68 Clase Java.awt.event.FocusListener ---------------------------------------------------------------------- 68

3

Clase Java.awt.event.InputEvent ------------------------------------------------------------------------- 69 Clase Java.awt.event.ItemEvent -------------------------------------------------------------------------- 69 Clase Java.awt.event.ItemListener ----------------------------------------------------------------------- 70 Clase Java.awt.event.KeyAdapter ------------------------------------------------------------------------ 70 Clase Java.awt.event.KeyEvent --------------------------------------------------------------------------- 70 Clase Java.awt.event.KeyListener ------------------------------------------------------------------------ 73 Clase Java.awt.event.MouseAdapter --------------------------------------------------------------------- 73 Clase Java.awt.event.MouseEvent ----------------------------------------------------------------------- 73 Clase Java.awt.event.MouseListener --------------------------------------------------------------------- 74 Clase Java.awt.event.MouseMotionAdapter ------------------------------------------------------------ 74 Clase Java.awt.event.MouseMotionListener ------------------------------------------------------------ 74 Clase Java.awt.event.PointEvent ------------------------------------------------------------------------- 75 Clase Java.awt.event.TextEvent -------------------------------------------------------------------------- 75 Clase Java.awt.event.TextListener ----------------------------------------------------------------------- 75 Clase Java.awt.event.WindowAdapter ------------------------------------------------------------------- 75 Clase Java.awt.event.WindowEvent --------------------------------------------------------------------- 76 Clase Java.awt.event.WindowListener ------------------------------------------------------------------ 76

PARTE IV: Clase Java.awt.Image. ------------------------------------------------------------------------------- 77 Clase Java.awt.Image.AreaAveragingScaleFilter ------------------------------------------------------ 77

Clase Java.awt.Image.ColorModel ----------------------------------------------------------------------- 78 Clase Java.awt.Image.CropImageFilter ------------------------------------------------------------------ 78 Clase Java.awt.Image.DirectColorModel ---------------------------------------------------------------- 78 Clase Java.awt.Image.FilteredImageSource ------------------------------------------------------------ 79 Clase Java.awt.Image.ImageConsumer ------------------------------------------------------------------ 79 Clase Java.awt.Image.ImageFilter ------------------------------------------------------------------------ 80 Clase Java.awt.Image.ImageObserver ------------------------------------------------------------------- 80 Clase Java.awt.Image.Producer --------------------------------------------------------------------------- 80 Clase Java.awt.Image.IndexColorModel ---------------------------------------------------------------- 81 Clase Java.awt.Image.MemoryImageSource ----------------------------------------------------------- 81 Clase Java.awt.Image.PixelGrabber ---------------------------------------------------------------------- 82 Clase Java.awt.Image.RGBImageFilter ----------------------------------------------------------------- 83 Clase Java.awt.Image.ReplicateScaleFilter ------------------------------------------------------------- 83

4

Este trabajo va dirigido a todos aquellos que intentan entrar al mundo java, que han oído o leído cosas que no saben a ciencia cierta que es eso de java. Java es una palabra que actualmente esta en boca de todos y ha creado una autentica revolución. La verdad es que no es para tanto. Java es una gran idea, pero no escandalosamente genial. Quizá todo se haya visto magnificado por Internet pero java se anuncia como un lenguaje completo de propósito general y, bueno, hay ciertas porciones del mismo que no están definidas o son discutibles, y algunas características son ciertamente obscuras. A lo largo del desarrollo del tutorial – ayuda el lector podrá ir observando todas esas cosas. A finales 1999, Sun Microsystems presento su nueva estrategia en torno a la plataforma Java2, que se resume en la diversificación de Java en tres grandes ramas, atendiendo al mercado a que va dirigido: grandes ordenadores, ordenadores de sobremesa y microordenadores o dispositivos de memoria limitada, fruto de esta declaración de intenciones, a lo largo de estos años han ido surgiendo las versiones de java que se adaptan a esta nueva estrategia de Sun, así es posible encontrar los siguientes productos de la plataforma Java2: Enterprise Edition (J2EE), Standard Edition (J2SE) y Micro Edition (J2ME). Java2 EE: Es la plataforma de desarrollo de aplicaciones para servidores utilizados en un entorno empresarial. Incluye Enterprice Java Beans (EJB), JavaServerPages (JSP), Servlets, JDBC, JNDI y especificaciones para interactuar con sistemas de administración ya implementados en empresas. Java2 SE: Es la plataforma de desarrollo de aplicaciones en clientes, fundamentalmente orientadas a ordenadores de sobremesa o pequeños grupos de servidores. Incluye el API básico de java con applets, red RMI, Servlets, JDBC, Swing, AWT, JFC 2D, Java Media (Java 3D, Java Sound, JAI, JMF), Java Beans (no Enterprice de Java Beans) y algunos mas. Java2 ME: Es la plataforma de desarrollo de aplicaciones en dispositivos de capacidades limitadas, por ejemplo teléfonos móviles, Asistentes digitales Personales (PDA), dispositivos WAP, sistemas de navegación para coches, etc. La mayoría de los programadores están interesados en la versión J2SE, porque es la que ofrece todas las ventajas de la plataforma Java2, sin los inconvenientes de dificultad (y alto coste) que suelen acompañar a todo lo que se desarrolla para un entorno empresarial. La versión del JDK que es tema de estudio en este trabajo es la versión 1.4 y fue la primera que vio la luz realmente adaptada a esta nueva estrategia de Sun. El lector no debe esperar que este trabajo le proporcione ungüentos milagrosos que por arte de magia traspasen el conocimiento el conocimiento. El estudio de Java y sus applets a través de este tutorial, no será sino el examen de una particular forma de ver las cosas, con un poco de estructuración en la presentación y un cierto trasfondo de Internet; el resto es como siempre, tarea del programador. Es decir, uno puede aprender a construir un applet, o bien dejar que alguna de las herramientas lo construya automáticamente, igual que puede enseñarse a codificar un dialogo en un entorno grafico, pero... la inteligencia de esa pieza siempre dependerá de la habilidad y experiencia del programador respecto al lenguaje usado y sus recursos. En fin un buen applet será únicamente resultado del trabajo de un buen programador Java.

MMMAAARRRCCCOOO TTTEEEOOORRRIIICCCOOO

5

Las principales interrogantes acerca del presente trabajo: 1.- ¿Porque habiendo suficiente información en fuentes impresas y en Internet, además de la documentación

del API proporcionado por Sun Microsystems se decidió realizar este tutorial - sistema de ayuda.? 2.- ¿Que ofrece este trabajo que no puedan ofrecer las fuentes antes mencionadas?

En principio la creación de este sistema de ayuda - tutorial ha partido de la necesidad del aprendizaje del lenguaje java. Lo que encontraras en este trabajo:

• Un sistema de ayuda que te permitirá navegar a través de paginas web que contienen imágenes con hipervínculos o mapas de navegación donde podrás ir conociendo los packages sus clases e interfaces con las que cuenta el API y una descripción pertinente del mismo, estos mapas son la representación grafica de la jerarquía de herencia de clases e interfaces de java en el pakage en el que te encuentres; La pagina principal inicia mostrando todos los packages con los que cuenta el API de Java; Se navega haciendo clic con el ratón sobre el nombre del package en principio, lo cual te lleva a otra pagina que contiene otro mapa que muestra la jerarquía de herencia de las clases y las interfaces contenidas en el, luego puedes clicar nuevamente sobre el nombre de una clase o interfase, esta acción te lleva a la definición de la clase donde te muestra todas las variables y métodos con las que cuenta esta, todos los métodos son hipervínculos donde finalmente puedes clicar cobre la definición de este método para ver un ejemplo de uso, así como la sintaxis y una descripción apropiada del mismo.

• El principal objetivo de este trabajo es mostrar ejemplos concretos de las variable y métodos contenidos en

cada una de las clases que conforman el API de Java, así como su sintaxis de uso, el trabajo se avanzo hasta donde el tiempo lo permitió, por lo tanto no esta completamente terminado debido a que Java cuenta con una gran cantidad de packages y cada package contiene una gran cantidad de clases e interfaces, y estos a su vez cuentan con una cantidad considerable de métodos, la descripción de todos los métodos esta fuera del alcance de esta primera versión de este trabajo, por lo que queda abierta la posibilidad de que alguien mas pueda continuar con este maratónico trabajo en su primero o segundo proyecto terminal. En lo personal considero que este trabajo seria de gran utilidad para aquellos quienes aun están el proceso de iniciación del lenguaje Java, además se plantea la posibilidad de que entre todos creemos un acervo propio de nuestra comunidad universitaria como muchas otras ya lo han estado haciendo desde hace tiempo.

Evidentemente podemos encontrar una basta cantidad de ayuda en Internet pero la fuente de esta información es muy escueta y de dudosa procedencia, salvo algunos sitios que son bastante completos y de buena fuente, al final de este trabajo se muestra un apéndice en el que se pueden consultar algunos sitios confiables y completos en Internet. Pero con el inconveniente de es muy difícil encontrar ejemplos concretos del uso de los métodos de alguna clase en particular; En este trabajo se pretende mostrar ejemplos de uso de todos los métodos de todas las clases e interfaces de todos los packages, cuando este completamente terminado. Debido a que como todos los lenguajes de programación van evolucionando en el transcurso del tiempo del mismo modo es de esperarse que Java evolucione, que crezca en cuanto al numero de packages, se agreguen nuevas clases a los packages, nuevos métodos a las clases, este trabajo requerirá de mantenimiento en su actualización, esta pues hecha la invitación a la

6

comunidad para participar en el presente ya que será de gran utilidad para todos aquellos quienes nos dedicamos a la programación en Java INTRODUCCIÓN

El uso principal que se hace de Internet e incluso de las redes internas (corporativas) es el correo electrónico (e-mail), aunque actualmente hay un auge sorprendente de la navegación web. Los documentos web pueden contener una gran variedad de texto y gráficos de todas clases, así como proporcionar enlaces hipertexto hacia cualquier lugar de la red. Los navegadores utilizan documentos escritos en lenguajes HTML. La combinación de navegadores HTML / WWW esta limitada, pues, a texto y gráficos. Si se quiere reproducir sonido o ejecutar un programa de demostración, primero hay que descargar el fichero en cuestión y luego utilizar un programa en el ordenador propio capaz de entender el formato de ese fichero que se ha descargado.

Hasta ahora la única forma de realizar una pagina web con contenido interactivo era mediante la interfaz CGI (Common Gateway Interfase), que permite pasar parámetros entre formularios definidos en lenguaje HTML y programas escritos en Perl o en C. Esta interfaz resulta muy incomoda 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 producir 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 líneas telefónicas, el navegador ya estará preparado para mostrar esas imágenes. Utilizando Java se pueden eliminar los inconvenientes de la interfaz CGI así como añadir aplicaciones que vayan desde experimentos científicos interactivos de propósito educativo a juegos o aplicaciones especializadas para la tele venta. 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 el usuario puede estar seguro 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. 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 les necesita. Por ejemplo, la mayoría de los navegadores del web pueden procesar un reducido número de formatos gráficos (generalmente GIF y JPEG). Si se encuentra con otro tipo de formato, el navegador estándar no tiene capacidad de procesarlo, tendría que ser actualizado para aprovechar las ventajas del nuevo formato. Sin embargo, un navegador con soporte Java se 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 solo necesita estar seguro de que hay una copia en código Java de ese algoritmo instalada en el en el servidor que contiene las imágenes que quiere publicar. Es decir, los navegadores con soporte Java se actualizan así mismos sobre la marcha, cuando encuentran un nuevo tipo de fichero o algoritmo. En Java esta la filosofía en la que se basar los NC (Network Computer), que serán ordenadores sin disco y con mucha memoria. Sus programas residen en un servidor que los envía cuando se les solicita. Es quizá un guiño

IIINNNTTTOOODDDUUUCCCCCCIIIOOONNN AAA JJJAAAVVVAAA

7

al pasado y una versión futurista de lo que ha sido una Terminal-X en otros tiempos, salvando las diferencias, evidentemente (no sea que alguien tilde el presente de irreverente con las nuevas tecnologías). Java es el primer lenguaje que tiene la virtud de ser compilado e interpretado de forma simultanea. Cuando un programador realiza una aplicación o un applet en Java y lo compila, en realidad, el compilador no trabaja como un compilador de un lenguaje al uso. El compilador Java únicamente genera el denominado BiteCode. Este código es un código intermedio entre el lenguaje maquina del preprocesador y Java. Evidentemente este código no es ejecutable por si mismo en ninguna plataforma hardware, pues no se corresponde con el lenguaje de ninguno de los procesadores que actualmente se conocen (habrá que esperar a ver que ocurre con los procesadores Java). Por lo tanto, para ejecutar una aplicación Java es necesario disponer de un mecanismo que permita ejecutar el BiteCode. Este mecanismo es la denominada Maquina Virtual Java (JVM). En cada plataforma (Solaris, Linux, Windows 95/98/NT, HP-UX, MacOS, etc.) existe una maquina virtual, esta lo interpreta pasándolo a código maquinadle procesador donde se este trabajando, así como ejecutando las instrucciones en lenguaje maquina que se deriven de la aplicación Java. De este modo cuando el mismo BiteCode llega a diferentes plataformas existirá la maquina virtual adecuada. Con este mecanismo se consigue la famosa multiplataforma de Java, en la que solo con codificar una vez, podemos ejecutar en varias plataformas. En realidad la maquina virtual de Java (JVM) desempeña otras funciones, como la de aislar los programas Java al entorno de la JVM, consiguiendo una gran seguridad. Sin embargo, como padras estar deduciendo, esto tiene algunas desventajas, y la mas clara es la velocidad de ejecución. Puesto que la VJM debe estar interpretando constantemente el ByteCode, se consume demasiado tiempo en realizar esta interpretación, que por otra parte no aporta nada a la aplicación, obteniendo así un bajo rendimiento Para solucionarlo se han optado soluciones intermedias. Una de las mas novedosas son los compiladores JIT (Just in Time). Estos compiladores están situado en la entrada de la JVM, de modo que según llega el ByteCode lo van compilando al lenguaje maquina del procesador. A diferencia de la interpretación, el compilador no ejecuta el ByteCode, únicamente lo traduce y lo almacena en código nativo dentro de la JVM, Así, una vez que la aplicación esta dentro de la JVM, ya se encuentra en lenguaje maquina y, por lo tanto, será directamente ejecutable, sin necesidad de interpretaciones, consiguiendo dotar de mayores rendimientos a la aplicación. Muy brevemente y de forma muy genérica, este es el funcionamiento básico de Java. Todas las mejoras al lenguaje se centran básicamente en conseguir mejores tiempos de ejecución y dotar de mayores prestaciones a la Maquina Virtual Java. ORIGENES DE JAVA

Sun Microsystems, líder en servidores para Internet, uno de cuyos lemas desde hace mucho tiempo ha sido “the network is the computer” (el verdadero ordenador es la red en su conjunto y no cada maquina individual), es quien ha inventado el lenguaje Java, en un intento de resolver todos los problemas que se planteaba a los desarrolladores de software por la proliferación de arquitecturas incompatibles, tanto entre las diferentes maquinas como entre los diversos sistemas operativos y sistemas de ventanas que funcionan sobre una misma maquina, añadiendo la dificultad de crear aplicaciones distribuidas en una red como Internet. Se han podido leer mas de cinco versiones distintas sobre el origen, concepción y desarrollo de Java, desde la que dice que este fue un proyecto que reboto durante mucho tiempo por distintos departamentos de Sun sin que nadie le prestara atención, hasta que finalmente encontró su nicho de mercado en la Aldea global que es Internet; hasta la mas difundida, que justifica a Java como el lenguaje de pequeños electrodomésticos.

8

Hace algunos años Sun Microsystems decidió 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, First Person Inc. Para dar margen de maniobra al equipo responsable del proyecto. El mercado inicialmente previsto para los programas de First Person eran los equipos domésticos: microondas, tostadoras y, fundamentalmente, televisión interactiva. Este mercado, dada la falta de sofisticación de los usuarios, requería unas interfaces mucho mas cómodas e intuitivas que los sistemas de ventanas que proliferaban en el memento. Otros requisitos importantes eran la fiabilidad del código y la fiabilidad de desarrollo. James Gosling, el miembro con mas experiencia en lenguajes de programación. Decidió que las ventajas de eficiencia de C++ no compensaba el gran coste de pruebas y depuración. Gosling había estado trabajando en su tiempo libre en un lenguaje de programación que el había llamado Oak, según parece el nombre se debe al viejo roble que veía por la ventana de su casa, el cual aun partiendo de la sintaxis de C++, intentaba remediar las deficiencias que había observado. 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 causado por en el campo de la electrónica de consumo. La aparición de un chip mas barato y, generalmente más eficiente, conduce a los 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 utilizo este lenguaje recibió el nombre de proyecto Geen y consistía en un sistema de control de los aparatos y el entorno de su hogar. Para ello se construyo 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 aplico a otro proyecto denominado VOD (video on Demand) en el que se empleaba para interfaz para televisión interactiva. Ninguno de estos proyectos se convirtió nunca en un sistema comercial, pero fueron desarrollados enteramente un Java primitivo y fueron como su bautismo de fuego. Una vez que Sun se dieron cuenta que a corto plazo la televisión interactiva no iba a ser un gran éxito, urgieron a First Person a desarrollar con rapidez nuevas estrategias que produjeran beneficios. No lo consiguieron y First Person cerro en la primavera del 1994. Pese al oque parecía ya un olvido definitivo, Bill Joy, cofundador de Sun y uno de los desarrolladores principales de Unís de Bekeley, juzgó que Internet podía llegar a ser el campo de juego adecuado para disputar a Microsoft supremacía casi absoluta en e terreno del software, y vio en Oak el instrumento idóneo para llevar a cabo esto planes. Tras un cambio de nombre y algunos de diseño, el lenguaje Java fue presentado en sociedad en agosto del 1995. No obstante, 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 las expectativas del lector. Porque tampoco es cuestión de desechar la penicilina auque su origen haya sido origen de la casualidad.

9

Java al igual que cualquier otro lenguaje de programación, dispone de sus propias peculiaridades, que representan una ventaja o una desventaja dependiendo de la aplicación que se vaya a realizar. Por ello, este capitulo esta dedicado a recoger las principales características propias de Java y proporcionar una visión desde la perspectiva de la empresa sobre las expectativas que se colocar sobre Java. CARACTERÍSTICAS PRINCIPALES DE JAVA Las características principales que ofrece Java frente a cualquier otro lenguaje de programación, se podría resumir en las siguientes: SIMPLE Java ofrece toda la funcionalidad de un lenguaje potente, pero sin las características menos usadas y más confusas de estos. C++ no es un lenguaje conveniente por razones de seguridad, pero C y C++ son los lenguajes mas ampliamente difundidos, por ello Java se diseño 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 de baja prioridad, cuando entra en acción, permite liberar bloques de memoria muy grandes, lo que limita mucho la fragmentación de memoria.

Java reduce en un 50% los errores mas comunes de programación con lenguajes como C y C++ al eliminar muchas de las características de estos, entre las que destacan:

• aritmética de punteros • no existen referencias • registros (struct) • definición de tipos (typedef) • macros(#define) • necesidad de liberar memoria

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 de esos objetos. Soporta las tres características propias del paradigma de la orientación a objetos: Encapsulacion, herencia y polimorfismo. Las plantillas de Objeto son llamadas, como en C++, Clases y sus copias, instancias. Estas instancias, como en C++, necesitan ser construidas y destruidas en espacios de memoria. DISTRIBUIDO

CCCAAARRRAAACCCTTTEEERRRIIISSSTTTIIICCCAAASSS DDDEEE JJJAAAVVVAAA

10

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. Java en si no es distribuido, sino que proporciona las librarías y herramientas para que los programas puedan ser distribuidos, es decir, que se ejecuten en varias maquinas, interactuando. 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 explicita 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. Además, para asegurar el funcionamiento de la aplicación, realiza una verificación de los Bites Codes, que son el resultado de la compilación de un programa Java. ARQUITECTURA NEUTRAL Para establecer Java como parte integral de la red, el compilador Java compila su código a un fichero de formato independiente de la arquitectura de la maquina en que se ejecutara. Cualquier maquina que tenga el sistema de ejecución (Run Time) pude ejecutar ese código objeto, independientemente de la maquina en la que ha sido generado. Actualmente existen sistams run time para Solaris 2.x, MacOs. 4.1.x, Windows 95/98, Windows NT, Linux, HP-UX, Iris, Aix, MacOs, Applet y probablemente haya grupos de desarrolladores trabajando el porting a otras plataformas. SEGURO La seguridad en Java tiene dos facetas. En el lenguaje, características como los punteros o el casting implícito que hace el compilador de C y C++, se elimina para prevenir el acceso ilegal a la memoria. Cuando se usa Java para crear un navegador, se combinan las características de lenguaje con protecciones de sentido común aplicadas al propio navegador. El código Java pasa muchas comprobaciones antes de ejecutarse en una maquina. El código se pasa a través del verificador de Bites Code 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-. El cargador de clases también ayuda a Java a mantener su seguridad, separando el espacio de nombres del sistema de ficheros local 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 ente 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. 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 ficheros de la maquina local (siempre que realiza operaciones con archivos, estas trabajan sobre el disco duro de la maquina 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

11

decir, nadie puede utilizar una maquina para hacer peticiones o realizar operaciones con otra. Además, los intérpretes que incorporan los navegadores Web son aun más restrictivos. Bajo estas condiciones (y dentro de la filosofía de que el único ordenador seguro es el que esta apagado, desenchufado, dentro de una cámara acorazada en un bunker y rodeado por mil soldados de los cuerpos espaciales del ejercito), se puede considerar que Java es un lenguaje seguro y que los applets están libres de virus. Respecto a la seguridad del código fuente, no ya el lenguaje, el propio JDK proporciona un desensamblador de Byte Code, que hace 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 código fuente original, pero si desmonta el programa mostrando el algoritmo que se utiliza, que es lo realmente interesante. La protección ante esto es utilizar llamadas 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 cosas que Java tiene pendientes. PORTABLE Mas 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 ventanas de forma que estos pueden ser implementados en entornos Unís, PC o Mac. INTERPRETADO El interprete de Java (sistema run-time) puede ejecutar directamente el código objeto. Enlazar un programa normalmente consume menos recursos que compilarlo, por lo que los desarrolladores con Java pasaran menos tiempo desarrollando y menos esperando por el ordenador. No obstante, el compilador actual del JDK es bastante lento. Por ahora, en que todavía no hay compiladores específicos de Java para las diversas plataformas, Java es mas lento que otros lenguajes de programación, como C++, ya que debe ser interpretado y no ejecutado como sucede en cualquier programa tradicional. No obstante, este panorama esta cambiando a pasos agigantados, y aunque Java sigue siendo básicamente un lenguaje interpretado, la situación se acerca mucho a la de los programas compilados, sobre todo en lo que a la rapidez en la ejecución del código se refiere. MULTITAREA Al ser multitarea o multihilo (o multihilvanado “multithread”), Java permite realizar muchas actividades simultaneas en un programa. El termino multithread es de difícil traducción, aunque actualmente parece ser que la palabra multitarea para expresar lo mismo es la que esta mas comúnmente aceptada. Las tareas – a veces llamadas, procesos ligeros, o hilos de ejecución – son básicamente pequeños procesos o piezas independientes de un gran proceso. Al estar estas tareas construidas en el mismo lenguaje, son mas fáciles de usar y mas robustos que sus homólogos en C o C++. El beneficio de ser multitarea consiste en un mejor rendimiento interactivo y mejor comportamiento en tiempo real. Aunque el comportamiento en tiempo real esta limitado a las capacidades del sistema operativo subyacente (Unís, Windows, est.) de la plataforma, aun supera a los entornos de flujo único de programa (single- threaded) tanto en facilidad de desarrollo como en rendimiento. DINAMICO Java se beneficia todo lo posible de la tecnología Orientada a Objetos y no intenta conectar todos los módulos que comprenden una aplicación hasta el mismo tiempo de ejecución. Las librerías nuevas o actualizadas no paralizaran la ejecución de las aplicaciones actuales siempre que mantenga el API anterior.

12

APIS DE LA PLATAFORMA JAVA Para que se tenga una idea de que es lo que se mueve alrededor de java, no hay mejor información que la descripción de los APIs que componen la plataforma Java, aunque no todas las que aquí se citan estan disponibles para su uso, ya que algunas se encuentran en fase de desarrollo, otras en fase de discusión publica para aporte de ideas y otras en fase beta. Java Enterprice Conjunto de especificaciones para entornos corporativos

JDBC API Java Database Conectivity, para permitir a las aplicaciones o applets acceder a bases de datos de forma homogénea vía consultas SQL.

Java RMI Remote Meted Invocation, invocación remota de métodos para aplicaciones distribuidas.

Java IDL Puente de compatibilidad con el modelo estándar de objetos CORBA. JNDI Java Naming and Directory Interfase, proporciona servicios de directorio y

localización de recursos en un entorno corporativo. JavaBeans Especificación de componentes basados en Java

JAF JavaBeans Activation Framework, entorno para determinar el tipo de datos, encapsular el acceso a ellos, descubrir las acciones que se les pueden aplicar e instanciar el componente JavaBeans adecuado.

Java Security API API para componentes que necesitan encriptación, certificación, firmas digitales y autenticación.

JFC Java Fundation Classes, jerarquía de clases para el desarrollo de aplicaciones graficas e interfaces de usuario.

Swing Set Conjunto de pequeños componentes gráficos para aplicaciones: botones, pestañas, etc.

Java 2D Extensión del AWT para el tratamiento de información grafica bidimensional. Java Servlet API Especificaciones que permiten crear applets que se ejecutan en el servidor. Java Server API API para el intercambio de información entre un servidor Web y aplicaciones

que se ejecutan en su entorno. Java Comerse API Conjunto de especificaciones para el acceso y utilización de información

interactiva. JMF Java Media Framework, Conjunto de especificaciones para la arquitectura,

protocolos e interfaces de programación, para reproductores multimedia, captura y videoconferencia.

Java Colaboración Especificación para la comunicación interactiva bidireccional. Java Telephony Especificación para aplicaciones de telefonía Java Speech Especificación para el reconocimiento y síntesis de voz Java Animation Especificación para la manipulación y movimiento de objetos bidimensionales Java 3D Especificación para la manipulación de Objetos tridimensionales Java Management API Especificación para la gestión remota de redes. Java Bluetooth API Especificación para estandarizar un conjunto de clases Java que permiten a

cualquier tipo de dispositivo integrarse en un entorno Bluetooth Java USB API Especificación para proporcionar un conjunto de clases del puerto USB

(Universal Serial Bus), de forma que las aplicaciones Java puedan manipular dispositivos manipulados al bus.

Java Mail API Especificaciones para proporcionar un conjunto de clases abstractas que modelice un sistema de correo.

13

Personal Java Especificaciones para aparatos electrónicos de consumo conectables a redes, incluyendo televisores, teléfonos inteligentes, videoconsolas, etc.

Java Smart Card Especificaciones para tarjetas inteligentes, tipo tarjetas de crédito Embedded Java Especificaciones para dispositivos electrónicos industriales con software

embebido ejecutándose sobre sistemas operativos en tiempo real, incluyendo dispositivos de instrumentación, electrónica de control de procesos, etc.

Braile API Especificaciones para dispositivos que funcionen con líneas braile y facilitar el uso de estos dispositivos.

PACKAGES de JAVA

La siguiente figura muestra algunos de los packages que conforman el API de Java2SE, los nombres de los packages están dispuestos en forma de bloques, la figura forma parte de la pagina HTML que es el punto de inicio del sistema de ayuda Java, esta figura forma un mapa de enlace, de tal modo que al hacer clic con el ratón sobre algunos de los bloques de la figura esta acción produce que se realice la apertura del package y se nos muestre otra figura la cual contiene la jerarquía de herencia del conjunto de clases e interfaces que lo conforman.

14

La acción de clikar sobre la pieza de rompecabezas Java.applet realiza la apertura otra pagina que contiene la jerarquía de herencia de las clases e interfaces correspondientes, como se muestra a continuación en la siguiente figura.

FIGURA 2. esta imagen también esta implementada como un mapa en el que al clikar sobre alguna de las figura que indica ser una clase o interfase nos envía a otra pagina donde podemos ver la definición completa de la clase o Interfase correspondiente, incluso las figuras en cuadro guía proporcionan ayuda sobre la definición de clase, Interfase o la herencia.

El cual contiene la clase Applet que es la superclase de todos los applets. Para crear un applet debes extender(como una subclase) "extends" de Applet. El cual contiene muchos métodos para accesar datos desde un servidor web, sirviendo al applet, tal como getImage() y getAudioClip(). Para crear un applet que corra dentro de un navegador web debes extender la clase applet y sobre escribir los métodos init(), start(), stop() y destroy(). Para mas detalles sobre la implementación consulta la pagina web de este trabajo, en el cual podrás navegar desde el inicio usando la figura 1(mapa de enlace), hasta llegar a la implementación de la clase y ver la sintaxis, descripción y ejemplos de cada método. Además los applets están sujetos a restricciones de seguridad. Una instancia de un Applet requiere de apoyo para funcionar correctamente, el cual es proporcionado por el navegador web o el appletViewer (visor de applets). Los applets están sujetos a restricciones de seguridad como ya se ha mencionado con anterioridad, los applets requieren de apoyo del navegador web o del appletViewer para su funcionamiento. public class Applet extends Panel { //metodos de instancia public void destroy() public AppletContext getAppletContext() public String getAppletInfo() public AudioClip getAudioClip(URL url)

PPAACCKKAAGGEE jjaavvaa..aapppplleett

CCCLLLAAASSSSSS AAAppppppllleeettt

15

public AudioClip getAudioClip(URL url, String name) public URL getCodeBase() public URL getDocumentBase() public Image getImage(URL url) public Image getImage(URL url, String name) public String getParameter(String name) public String[][] getParameterInfo() public void init() public boolean isActive() public void play(URL url) public void play(URL url, String name) public void resize(Dimension d) public void final resize(Dimension d) public void showStatus(String msg) public void start() public void stop() } sintaxis: public void destroy( ) Descripsion: El metodo destroy habilita al applet para que limpie los recursos que este utilizo; Si este esta activo se invoca al metodo stop() posteriormente se destruye. public void destroy() { // aqui se hace la limpieza // tales como liberar recursos // y/o detener hilos } Sintaxis: public AppletContext getAppletContext() Descripsion: Este metodo regresa el manejador al contexto del applet. El contexto del applet habilita al applet para controlar este entorno (usualmente el navegador o el visor de applets) try{ URL clipUrl = new URL("file:///C:/src/ProRef/test.au"); AppletContext myContext = getAppletContext(); // puede tomar ventaja del cache de los navegadores AudioClip myClip = myContext.getAudioClip(clipUrl); myClip.play(); }catch(MalformedURLException e){showStatus("URL Error.");} Sinatxis: public String getAppletInfo()

Método destroy()

Método getAppletContext()

Método getAppletInfo

16

Descripsion: Despliega la informacion acerca del autor, la version del applet, retorna una cadena de informacion particular de derechos reservados. public String getAppletInfo() { return("Programa test v1.0 Nombre del Autor"); } Sintaxis: public AudioClip getAudioClip(URL url) Descripsion: Carga una porcion de audio; Despues de que la clase tiene el objeto audioClip puedes usar el metodo play() para reproducir el archivo de audio. try{ URL clipUrl = new URL("file:///C:/src/ProRef/test.au"); AudioClip myClip = getAudioClip(clipUrl); myClip.play(); }catch(MalformedURLException e){shwStatus("URL Error");} Sinatxis: puclic AudioClip getAudioClip(URL url, String name) Descripsion: Carga una porcion de audio; El parametro URL indica la localizacion del objeto; El parametro String indica la cadena del clip que quieres obtener. AudioClip myClip = getAudioClip(getDocumentBase(), "test.au"); myClip.play(); Sintaxis: public URL getCodeBase() Descripsion: Despliega una cadena que representa el directorio en el cual el applet esta contenido. Image getImage(URL url) Sinatxis: puclic URL getDocumentBase() Descripsion: Recupera el el objeto que representa el directorio del archivo desde el cual el applet corre. Image myImage = getImage(getDocumentBase(), "test.gif"); getImage(URL url, String name) Sinatxis: puclic Image getImage(URL url)

Método getAudioClip(URL url)

Método getAudioClip(URL url, String name)

Método getCodeBase()

MMééttooddoo ggeettDDooccuummeennttBBaassee(())

Método getImage(URL url)

17

Descripsion: Carga un objeto imagen inmediatamente desde la URL especificada y crea una instancia de la clase imagen. Este metodo algunas veces regresa un objeto imagen, incluso si la imagen no existe. El parametro URL indica la localizacion de la imagen u objeto en el internet. try{ myImageUrl = new URL("file:///C:/src/bookProRef/test.gif"); myImage = getImageUmy(myImageUrl); }catch(MalformedURLException e){showStatus("URL Error");} Sinatxis: puclic Image getImage(URL url, String name) Descripsion: Carga un objeto imagen desde la URL especificada y crea una instancia de la clase imagen. Este metodo tambien especifica la cadena que representa la ruta o el nombre del archivo de la imagen actual. Este metodo algunas veces regresa un objeto imagen, si la imagen no existe.El parametro URL indica la localizacion de la imagen u objeto en el internet. El parámetro String indica la cadena del objeto o imagen. Image myImage = getImage(getDocumentBase(), "test.gif"); Sinatxis: public String getParameter(String name) Descripsion: Busca el parámetro del applet. Este método acepta un especificador de cadena (el parámetro que representa el nombre del parámetro que de esta buscando) y regresa una cadena que contiene el valor correspondiente String side = getParameter("side"); try{ int numPlayers = Integer.parseInt(getParameter("numplayers")); testArea.appendText("numplayers is fine"\n"); }catch(NumberFormatException e){ textArea.appendText("numplayers parameter badlyformatted"); } Sinatxis: puclic String[][] getParameterInfo() Descripsion: Regresa un array de cadenas que describe los parametros de un applet. El array usualmente consiste de un juego de tres cadenas: El nombre del parametro, El tipo de valor requerido para el parametro y la descripsion del parametro. public String[][] getParameterInfo() { String[][] myInfo = { {"numplayers","integer","number of players uno o cero"}, {"side","character","must be character 'x' o '0'"} }; return(myInfo); }

Método getImage(URL url, String name)

METODO getParameter(String name)

METODO getParameterInfo()

18

Sinatxis: puclic void init() Descripsion: Inicializa el applet (Crea el objeto requerido, carga imagenes o fuentes y mas) cuando este es cargado o recargado. No se necesita llamar este metodo directamente, init es llamado automaticamente cuando el applet es creado. // Remplace el constructor - solo en la primera llamada // Llamado cuando el applet es creado public void init() { textArea = new TextArea(10,40); this.add(textArea); textArea.appendText("Initializad.\n"); repaint(); System.err.println("Initializing\n"); } Sinatxis: puclic boolean isActive() Descripsion: Determina cuando el applet esta activo. Este metodo regresa verdadero cuando el applet esta activo. Java marca un applet activo inmediatamente antes de que el metodo start sea llamado. try { URL clipURL = new URL("file:///c:/src/book/ProRef/test.au"); play(clipURL); }catch(MalformedURLException e){showStatus("URL Error.");} Define métodos usados por un applet para obtener información del entorno del applet, este es usualmente el navegador web o el appletViewer. No accese estos metodos directamente; use los metodos equivalentes en la clase Applet isntanciada. Public interface Applet { // Metodos de instancia Applet getApplet(String name); Enumeration getApplet(String name); AudioClip getAudioClip(URL url); Image getImage(URL url); void showDocument(URL url);

Método init()

Método isActive()

IIINNNTTTEEERRRFFFAAACCCEEE AAAppppppllleeetttCCCooonnnttteeexxxttt

19

PPPAAACCCKKKAAAGGGEEE JJJAAAVVVAAA...AAAWWWTTT

IIINNNTTTEEERRRFFFAAACCCEEE AAAppppppllleeetttSSStttuuubbb

IIINNNTTTEEERRRFFFAAACCCEEE AAAuuudddiiioooCCCllliiippp

public void showDocument(URL url, String target); void showStatus(String status); }

Esta interfase obtiene información del navegador Web. No accese estos métodos directamente; use un método equivalente de Applet. public interface AppletStub { // Metodos de instancia void appletResize(int width, int height); AppletContext getAppletContext( ); URL getCodeBase( ); URL getDocumentBase( ); boolean isActive( ); }

Esta Interfase es una simple implementación de un simple audio clip. La interfase

define métodos que todo audio clip debe implementar, tales como play(), y stop(). El método applet.getAudioClip() regresa un objeto AudioClip. public interface AudioClip { //Métodos de la interfase void loop( ); void play( ); void stop( ); }

El paquete Java.awt (Abstract Windowing Toolkit, o AWT) contiene clases para dezarrollar interfaces graficas de usuario (GUI´s). Las siguientes tres figuras muestran los esquemas de la jerarquía de herencia para el paquete

java.awt, en la implementacion del sistema de ayuda, esta figura es un mapa de tal modo que al clikar sobre alguna clase o Interfase que muestra se abre una pagina web con la definición de esta clase o interface.

20

21

Esta clase es para manejo de eventos de alto nivel, esta clase y subclases sobrescriben a la clase original Java.awt.Event. public abstract class AWTEvent extends EventObject { protected int id; public final static long COMPONENT_EVENT_MASK; public final static long ONTAINER_EVENT_MASK; public final static long FOCUS_EVENT_MASK; public final static long KEY_EVENT_MASK; public final static long MOUSE_EVENT_MASK; public final static long MOUSE_MOTION_EVENT_MASK; public final static long WINDOW_EVENT_MASK; public final static long ACTION_EVENT_MASK; public final static long ADJUSTMENT_EVENT_MASK; public final static long ITEM_EVENT_MASK; public final static int RESERVED_ID_MASK; public final static long TEXT_EVENT_MASK;

CCCLLLAAASSSSSS AAAWWWTTTEEEvvveeennnttt

22

public AWTEvent(Event event) public AWTEvent(Object source, int id) protected void consume( ) Event convertToOld( ) public int getID( ) int getOldEventKey(KeyEvent e) protected Boolean isConsumed( ) public String paramString( ) public String toString( ) } Esta clase despacha eventos a varios oyentes(listeners) de eventos. Puedes registrar el oyente llamando al método apropiado add( ). Los eventos son enviados cuando el método asociado es llamado. Por ejemplo, para enviar un evento de tecla presionada, use el método KeyPressed( ). public class AWTEventMulticaster implements ComponentListener, ContainerListener, FocusListener,

KeyListener, MouseListener, MouseMotionListener, WindowListener, ActionListener, ItemListener, AdjustementListener, TextListener {

protected EventListener a, b; public void actionPerformed(ActionEvent e) public static ComponentListener add(ComponentListener a, ComponentListener b) public static ComponentListener add(ComponentListener a, ContainerListener b) public static FocusListener add(FocusListener a, FocusListener b) public static KeyListener add(KeyListener a, KeyListener b) public static MouseListener add(MouseMotionListener a, MouseMotionListener b) public static WindowListener add(WindowListener a, WindowListener b) public static ActionListener add(ActionListener a Action Listener b) public static ItemListener add(ItemListener a, ItemListener b) public static AdjustmentListener add(AdjustmentListener a, AdjustmentListener b) public static TextListener add(TextListener a, TextListener b) protected static EventListener addInternal(EventListener a, EventListener b) public void AdjustmentValueChanged(AdjustmentEvent e) protected AWTEventMulticaster(EventListener a, EventListener b) public void componentAdded(ContainerEvent e) public void ComponentHidden(ComponentEvent e) public void ComponentMoved(ComponentEvent e) public void ComponentRemoved(ComponentEvent e) public void ComponentResized(ComponentEvent e) public void ComponentShown(ComponentEvent e) public void focusGained(FocusEvent e) public void focusLost(FocusEvent e) public void itemStateChanged(ItemEvent e) public void keyPressed(KeyEvent e) public void keyReleased(KeyEvent e)

CCCLLLAAASSSSSS AAAWWWTTTEEEvvveeennntttMMMuuullltttiiicccaaasssttteeerrr

23

public void keyTyped(KeyEvent e) public void mouseClicked(MouseEvent e) public void mouseDragged(MouseEvent e) public void mouseEntered(Mouse Event e) public void mouseExited(MouseEvent e) public void mouseMoved(MouseEvent e) public void mosePressed(MouseEvent e) public void mouseReleased(MouseEvent e) potected EventListener remove(EventListener old) public static ComponentListener remove(ComponentListener l, ComponentListener oldl) public static ContainerListener remove(ContainerListener 1,ContainerListener oldl) public static FocusListener remove(FocusListener 1,FocusListener oldl) public static KeyListener remove(KeyListener 1, KeyListener oldl) public static MouseListener remove(MouseListener 1,MouseListener oldl) public static MouseMotionListener remove(MouseMotionListener 1, MouseMotionListener oldl) public static WindowListener remove(WindowListener 1,WindowListener oldl) public static ActionListener remove(ActionListener 1, ActionListener oldl) public static ItemListener remove(ItemListener 1, ItemListener oldl) public static AdjustmentListener remove(AdjustmentListener 1, AdjustmentListener oldl) public static TextListener remove(TextListener 1, TextListener oldl) protected static EventListener removeInternal(EventListener 1, EventListener oldl) public void textValueChanged(TextEvent e) public void windowActivated(WindowEvent e) public void windowClosed(WindowEvent e) public void windowClosing(WindowEvent e) public void windowDeactivated(WindowEvent e) public void windowDeiconified(WindowEvent e) public void windowIconified(WindowEvent e) public void windowOpened(WindowEvent e) } Use esta interfase con componentes que pueden ser ajustados, tales como barras deslizables (scroll bar) public interface Adjustable { public static final int HORIZONTAL; public static final int VERTICAL; void addAdjustmentListener(AdjustmentListener 1); int getBlockIncrement( ); int getMaximum ( ); int getMinimum( ); int getOrientation( ); int getUnitIncrement( ); int getValue( ); int getVisibleAmount( );

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...AAAdddjjjuuussstttaaabbbllleee

24

void removeAdjustmentListener(AdjustmentListener l); void setBlocklncrement(int b); void setMaximum(int max); void setMinimum(int min); void setUnitIncrement(int u); void setValue(int v); void setVisibleAmount(int v); } BorderLayout es un manejador de diseño con cinco áreas para agregar componentes: Norte, Sur, Este, Oeste, Centro. El argumento de cadena para el metodo add( ) para contenedores especificos en el cual los componentes pueden ser agregados. Si no se especifica el area se toma el Centro por default. El tamaño de cada area depende de el tamaño predefinidos de los componentes en el area. El Centro esta por encima de cualquiera de las demas areas. Si necesita mas de un componente en un area, agrege aun panel con el componente dentro. public class BorderLayout implements LayoutManager2, java.io.Serializable { int hgap; int vgap; Component north; Component west; Component east; Component south; Component center; public static final String NORTH; public static final String SOUTH; public static final String EAST; public static final String WEST; public static final String CENTER; public void addLayoutComponent(Component comp, Object constraints) public void addLayoutComponent(String name, Component comp) public BorderLayout( ) public BorderLayout(int hgap, int vgap) public int getHgap( ) public float getLayoutAlignmentX(Container parent) public float getLayoutAlignmentY(Container parent) public int getVgap( ) public void invalidateLayout(Container target) public void layoutContainer(Container target) public Dimension maximumLayoutSize(Container target) public Dimension minimumLayoutSize(Container target) public Dimension preferredLayoutSize(Container target) public void removeLayoutComponent(Component comp)

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...BBBooorrrdddeeerrrLLLaaayyyooouuuttt

25

public void setHgap(int hgap) public void setVgap(int vgap) public String toString( ) } Button es un simple componente boton-oprimible, puedes agregar un botón a un contenedor, tal como Panel o marco(Frame), para este sea utilizado. public class Button extends Component { String label; String actionCommand; ActionListener actionListener; public void addActionListener(ActionListener 1) public void addNotify( ) public Button( ) public Button(String label) boolean eventEnabled(AWTEvent e) public String getActionCommand( ) public String getLabel( ) protected String paramString( ) protected void processActionEvent(ActionEvent e) protected void processEvent(AWTEvent e) public void removeActionListener(ActionListener 1) public void setActionCommand(String command) public synchronized void setLabel(String label) } Canvas es una area reactangular comunmente usada para dibujar o construir componentes de cliente. Canvas se parece a panel, pero puedes agregar componentes a canvas como con paneles. Esto es devido a que panel es un contenedor, esto significa que puede mantener otro componentes anteriores, y canvas no. public class Canvas extends Component { public void addNotify( ) public Canvas( ) public void paint(Graphics g) boolean postsOldMouseEvents( ) }

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...BBBuuuttttttooonnn

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...CCCaaannnvvvaaasss

26

CardLayout le permite mostrar un Componente o Panel a la vez, tantas como un abanico de tarjetas engalanadas, salvando su valor de espacio en pantalla. Para usar CardLayout, simplemente cree un conjunto de Panels con componentes dentro y agregar este a un contenedor a lo largo con una cadena dada al nombre de un panel, si quieres mostrar un panel en particular, simplemente llame al método add( ) con el nombre del panel. public class CardLayout implements LayoutManager2, java.io.Serializable { Hashtable tab; int hgap; int vgap; public void addLayoutComponent(Component comp, Object constraints) public void addLayoutComponent(String name, Component comp) public CardLayout() public CardLayout(int hgap, int vgap) void checkLayout(Container parent) public void first(Container parent) public int getHgap( ) public float getLayoutAlignmentX(Container parent) public float getLayoutAlignmentY(Container parent) public int getVgap() public void invalidateLayout(Container target) public void last(Container parent) public void layoutContainer(Container parent) public Dimension maximumLayoutSize(Container target) public Dimension minimumLayoutSize(Container parent) public void next(Container parent) public Dimension preferredLayoutSize(Container parent) public void previous(Container parent) public void removeLayoutComponent(Component comp) public void setHgap(int hgap) public void setVgap(int vgap) public void show(Container parent, String name) public String toString( ) } Checkbox crea un simple on/of caja checada. Las cajas checkeables actuan independientemente por default. Si quieres hacer que varias cajas actúen de manera mutuamente exclusiva, que los usuarios de Mac llaman botones de radio, es necesario crear un grupo de check box (CheckboxGroup). public class Checkbox extends Component implements ItemSelectable { String label; boolean state; CheckboxGroup group; ItemListener itemListener;

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...CCCaaarrrdddLLLaaayyyooouuuttt

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...CCChhheeeccckkkbbboooxxx

27

public void addItemListener(ItemListener 1) public void addNotify( ) public Checkbox( ) public Checkbox(String label) public Checkbox(String label, boolean state) public Checkbox(String label, boolean state, CheckboxGroup group) public Checkbox(String label, CheckboxGroup group, boolean state) boolean eventEnabled(AWTEvent e) public CheckboxGroup getCheckboxGroup( ) public String getLabel() public Object[] getSelectedObjects( ) public boolean getState() protected String paramString( ) protected void proceszEvent(AWTEvent e) protected void processltemEvent(ItemEvent e) public void removeItemListener(ItemListener 1) public void setCheckboxGroup(CheckboxGroup g) public synchronized void setLabel(String label) public void setState(boolean state) synchronized void setStatelnternal(boolean state) } CheckboxGroup crea grupos de Checkboxes mutuamente exclusivos, Los cuales son llamdos radio buttons en el mundo de Mac. CheckboxGroup no es difícil de usar. Simplemente cree una instancia de CheckboxGroup y referirse a esta cuando usted cree cada Checkboxes, Esto es, solo una forma en la los Ckeckboxes pueden ser agrupados en un momento dado. public class CheckboxGroup implements java.io.Serializable { Checkbox selectedCheckbox; public CheckboxGroup( ) public Checkbox getCurrent( ) public Checkbox getSelectedCheckbox( ) public synchronized void setCurrent(Checkbox box) public synchronized void setSelectedCheckbox(Checkbox box) public String toString() } Esta clase crea un MenuItem con una caja chekable dentro de este. Cuando seleccionas el item desde el menu, el estado del checkbox cambia. Este se comporta como un ManuItem cualquiera. public class CheckboxMenultem extends Menultem implements Itemselectable { boolean state; ItemListener itemListener; public void addItemListener(ItemListener 1) public void addNotifyO public CheckboxMenultem( ) public CheckboxMenultem(String label)

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...CCChhheeeccckkkbbboooxxxGGGrrrooouuuppp

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...CCChhheeeccckkkbbboooxxxMMMeeennnuuuIIIttteeemmm

28

public CheckboxMenultem(String label, boolean state) boolean eventEnabled(AWTEvent e) public synchronized Object[1 getSelectedObjects( ) public boolean getState( ) public String paramString() protected void processEvent(AWTEvent e) protected void processltemEvent(ItemEvent e) public void removeltemListener(ItemListener 1) public synchronized void setState(boolean b) } Choice es como un menú emergente, solo es posible seleccionar uno de los Ítem a la vez. public class Choice extends'Component implements ItemSelectable { Vector pItems; int selectedlndex; ItemListener itemListener; public synchronized void add(String item) public synchronized void addltem(String item) public void addltemListener(ItemListener 1) public void addNotify( ) public Choice( ) public int countltems( ) boolean eventEnabled(AWTEvent e) public String getItem(int index) public int getItemCount( ) public int getSelectedlndex( ) public synchronized String getSelectedltem( ) public synchronized Object[] getSelectedObjects( ) public synchronized void insert(String item, int index) protected String paramString( ) protected void processEvent(AWTEvent e) protected void processltemEvent(ItemEvent e) public synchronized void remove(String item) public synchronized void remove(int position) public synchronized void removeAll( ) public void removeltemListener(ItemListener 1) public synchronized void select(int pos) public synchronized void select(String str) }

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...CCChhhoooiiiccceee

29

Color es un objeto que puede ser fijado a un color con valor de 32 bits representando 8 bits para el rojo, gris, azul y alfa. Puedes crear un color con valores enteros o de punto flotante. El rango de valores enteros estan entre 0 y 255, Considerando los valores de punto flotante en el rango de 0.0 a 1.0. public class Color implements java.io.Serializable { public final static Color white; public final static Color lightGray; public final static Color gray; public final static Color darkGray; public final static Color black; public final static Color red; public final static Color pink; public final static Color orange; public final static Color yellow; public final static Color green; public final static Color magenta; public final static Color cyan; public final static Color blue; transient private int pData; int value; private static final double FACTOR; public Color brighter( ) public Color(int r, int g, int b) public Color(int rgb) public Color(float r, float g, float b) public Color darker( ) public static Color decode(String nm) throws NumberFormatException public boolean equals(Object obj) public int getBlue( ) public static Color getColor(String nm) public static Color getColor(String nm, Color v) public static Color getColor(String nm, int v) public int getGreen( ) public static Color getHSBColor(float h, float s, float b) public int getRed( ) public int getRGB( ) public int hashCode( ) public static int HSBtoRGB(float hue, float saturation, float brightness) public static floatEl RGBtoHSB(int r, int g, int b, float[] hsbvals) public String toString( ) }

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...CCCooolllooorrr

30

Component es el Objeto de mas alto nivel en el AWT. Esto es tiene mucho material en este. Muchas de las clases en el AWT heredan desde Component, tales como Button, Checkbox, TextField y algunos contenedores, incluyendo Panel y Frame, son algunos componentes, pero estos pueden mantener Componentes. public abstract class Component implements ImageObserver, MenuContainer, Serializable { transient ComponentPeer peer; transient Container parent; int x; int y; int width; int height; Color foreground; Color background; Font font; Cursor cursor; protected Locale locale; boolean visible; boolean enabled; boolean valid; Vector popups; String name; public static final Object LOCK; Dimension minSize; Dimension prefSize; boolean newEventsOnly; ComponentListener componentListener; FocusListener focusListener; KeyListener keyListener; MouseListener mouseListener; MouseMotionListener mouseMotionListener; long eventMask; static boolean isInc; static int incRate; public static final float TOP ALIGNMENT; public static final float CENTER_ALIGNMENT; public static final float BOTTOM_ALIGNMENT; public static final float LEFT_ALIGNMENT; public static final float RIGHT_ALIGNMENT; public boolean action(Event evt, Object what) public synchronized void add(PopupMenu popup) public synchronized void addComponentListener public synchronized void addFocusListener(FocusListener 1) public synchronized void addKeyListener(KeyListener 1) public synchronized void addMouseListener(MouseListener 1) public synchronized void addMouseMotionListener(MouseMotionListener 1) public void addNotifyO public Rectangle bounds( ) public int checkImage(Image image, ImageObserver observer)

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...CCCooommmpppooonnneeennnttt

31

public int checklmage(Image image, int width, int height, ImageObserver observer) protected Component( ) public boolean contains(int x, int y) public boolean contains(Point p) public Image createImage(ImageProducer producer) public Image createImage(int width, int height) public void deliverEvent(Event e) public void disable( ) protected final void disableEvents(long eventsToDisable) public final void dispatchEvent(AWTEvent e) public void doLayout( ) public void enable( ) public void enable(boolean b) protected final void enableEvents(long eventsToEnable) boolean eventEnabled(AWTEvent e) public float getAlignmentX( ) public float getAlignmentY( ) public Color, getBackground( ) public Rectangle getBounds( ) public ColorModel getColorModel( ) public Component getComponentAt(int x, int y) public Component getComponentAt(Point p) public Cursor getCursor( ) public Font getFont( ) public FontMetrics getFontMetrics(Font font) public Color getForeground( ) public Graphics getGraphics( ) public Locale getLocale( ) public Point getLocation( ) public Point getLocationOnScreen( public Dimension getMaximumSize( ) public Dimension getMinimumSize( ) public String getName( ) Container getNativeContainer( ) public Container getParent( ) public ComponentPeer getPeer( ) public Dimension getPreferredSize( ) public Dimension getSize( ) public Toolkit getToolkit( ) public final Object getTreeLock( ) public boolean gotFocus(Event evt, Object what) public boolean handleEvent(Event evt) public void hide( ) public boolean imageUpdate(Image img, int flags, int x, int y, int w, int h) public boolean inside(int x, int y) public void invalidate( ) public boolean isEnabled( ) public boolean isFocusTraversable( )

32

public boolean isShowing( ) public boolean isValid( ) public boolean isVisible( ) public boolean keyDown(Event evt, int key) public boolean keyUp(Event evt, int key) public void layout( ) public void listo( ) public void list(PrintStream out) public void list(PrintStream out, int indent) public void list(PrintWriter out) public void list(PrintWriter out, int indent) public Component locate(int x, int y) public Point location( ) public boolean lostFocus(Event evt, Object what) public Dimension minimumSize( ) public boolean mouseDown(Event evt, int x, int y) public boolean mouseDrag(Event evt, int x, int y) public boolean mouseEnter(Event evt, int x, int y) public boolean mouseExit(Event evt, int x, int y) public boolean mouseMove(Event evt, int x, int y) public boolean mouseUp(Event evt, int x, int y) public void move(int x, int y) public void nextFocus( ) public void paint(Graphics g) public void paintAll(Graphics g) protected String paramString( ) public boolean postEvent(Event e) boolean postsOldMouseEvents( ) public Dimension preferredSize( ) public boolean prepareImage(Image image, ImageObserver observer) public boolean prepareImage(Image image, int width, int height, ImageObserver observer) public void print(Graphics g) public void printAll(Graphics g) protected void processComponentEvent(ComponentEvent e) protected void pro cessEvent(AWTEvent e) protected void processFocusEyent(FocusEvent e) protected void processKeyEvent(KeyEvent e) protected void processMouseEvent(MouseEvent e) protected void processMouseMotionEvent(MouseEvent e) public synchronized void remove(MenuComponent popup) public synchronized void removeComponentListener public synchronized void removeFocusListener(FocusListener 1) public synchronized void removeKeyListener(KeyListener 1) public synchronized void removeMouseListener(MouseListener 1) public synchronized void removeMouseMotionListener(MouseMotionListener 1) public void removeNotify() public void repaint( ) public void repaint(long tm) public void repaint(int x, int y, int width, int height)

33

public void repaint(long tm, int x, int y, int width, int height) public void requestFocus( ) public void reshape(int x, int y, int width, int height) public void resize(int width, int height) public void resize(Dimension d) public void setBackground(Color c) public void setBounds(int x, int y, int width, int height) public void setBounds(Rectangle r) public synchronized void setCursor(Cursor cursor) public void setEnabled(boolean b) public synchronized void setFont(Font f) public void setForeground(Color c) public void setLocale(Locale 1) public void setLocation(int x, int y) public void setLocation(Point p) public void setName(String name) public void setSize(int width, int height) public void setSize(Dimension d) public void setVisible(boolean b) public void show( ) public void show(boolean b) public Dimension size( ) public String toString( ) public void transferFocus( public void update(Graphics g) public void valídate( ) } Container es una clase abstracta usada para fijar componentes. Panels y Frames son contenedores, pero botones y Checkboxes no lo son. Puedes crear una instancia de de container directamente; Tienes a esta subclase si la quieres usar. Muchos programadores usan contenedores(container) proporcionados en el API(Panel, Frame,, Dialog, y otros mas) y no crean el propio. public abstract class Container extends Component { int ncomponents; Component component[]; LayoutManager layoutMgr; private LightweightDispatcher dispatcher; private Dimension maxSize; ContainerListener containerListener; private int containerSerializedDataVersion; public Component add(Component comp) public Component add(String name, Component comp) public Component add(Component comp, int índex) public void add(Component comp, Object constraints) public void add(Component comp, Object constraints, int index)

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...CCCooonnntttaaaiiinnneeerrr

34

public void addContainerListener(ContainerListener 1) protected void addImpl(Component comp, Object constraints, int index) public void addNotify( ) protected Container( ) public int countComponents( ) public void deliverEvent(Event e) void dispatchEvent(AWTEvent e) public void doLayout( ) boolean eventEnabled(AWTEvent e) public float getAlignmentX( ) public float getAlignmentY( ) public Component getComponent(int n) public Component getComponentAt(int x, int y) public Component getComponentAt(Point p) public int getComponentCount( ) public Component[] getComponents( ) public Insets getInsets( ) public LayoutManager getLayout( ) public Dimension getMaximumSize( ) public Dimension getMinimumSize( ) Component getMouseEventTarget(int x, int y) public Dimension getPreferredSize( ) public Insets insets( ) public void invalidote( ) public boolean isAncestor0f(Component c) public void layout( ) public void list(PrintStream out, int indent) public void list(PrintWriter out, int indent) public Component locate(int x, int y) public Dimension minimumSize( ) void nextFocus(Component base) public void paint(Graphics g) public void paintComponents(Graphics g) protected String paramString( ) void postProcessKeyEvent(KeyEvent e) boolean postsOldMouseEvents( public Dimension preferredSize ) public void print(Graphics g) public void printComponents(Graphics g) protected void processContainerEvent(ContainerEvent e) protected void processEvent(AWTEvent e) void proxyEnableEvents(long events) void proxyRequestFocus(Component c) private void readObject(java.io.ObjectlnputStream s) throws java.lang.ClassNotFoundException, java.io.IOException public void remove(int index) public void remove(Component comp) public void removeAll( )

35

public void removeContainerListener(ContainerListener 1) public void removeNotify( ) void setFocusOwner(Component c) public void setLayout(LayoutManager mgr) void transferFocus(Component base) public void valídate( ) protected void validateTree( ) prívate void writeObject(java.io.ObjectOutputStream s) throws java.lang.ClassNotFoundException, java.io.IOException } Cursor representa un cursor del mouse. Puedes especificarcursores para cada componente. Simplemente llamando a Component.setCursor() con el cursor que deseas. public class Cursor implements java.io.Serializable { public static final int DEFAULT_CURSOR; public static final int CROSSHAIR_CURSOR; public static final int TEXT CURSOR; public static final int WAIT_CURSOR; public static final int SW_RESIZE_CURSOR; public static final int SE_RESIZE_CURSOR; public static final int NW RESIZE CURSOR; public static final int NE_RESIZE_CURSOR; public static final int N_RESIZE_CURSOR; public static final int S RESIZE CURSOR; public static final int W_RESIZE_CURSOR; public static final int E RESIZE CURSOR; public static final int HAND_ CURSOR; public static final int MOVE CURSOR; protected static Cursor predefined[]; int type; public Cursor(int type) static public Cursor getDefaultCursor( ) static public Cursor getPredefinedCursor(int type) public int getType( ) } Le permite crear una caja de dialogo modal o cajas de dialogo modales. Una bandera booleana en el constructor describe el tipo. Puedes especificar un marco padre cuando creas un cuadro de dialogo. Este puede ser cualquier marco(Frame) en la aplicación. public class Dialog extends Window { boolean resizable; boolean modal; String title; WindowListener windowListener;

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...CCCuuurrrsssooorrr

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...DDDiiiaaallloooggg

36

public void addNotify( ) public Dialog(Frame parent) public Dialog(Frame parent, boolean modal) public Dialog(Frame parent, String title) public Dialog(Frame parent, String title, boolean modal) boolean eventEnabled(AWTEvent e) public String getTitle( ) public boolean isModal( ) public boolean isResizable( ) protected String paramString( ) protected void processEvent(AWTEvent e) protected void processWindowEvent(WindowEvent e) public void setModal(boolean b) public synchronized void setResizable(boolean resizable) public synchronized void setTitle(String title) public void show( ) } Dimensión es un envoltorio para ancho y alto. El objeto dimensión aparece sobre todos los lugares para especificar el acho y alto. public class Dimension implements java.io.Serializable { public int width; public int height; public Dimension( ) public Dimension(Dimension d) public Dimension(int width, int height) public boolean equals(Object obj) public Dimension getSize( ) public void setSize(Dimension d) public void setSize(int width, int height) public String toString( ) } Event mantiene toda la informacion contenida en un evento de usuario, tales como cuando el usuario presiona una tecla o mueve el mouse. Muchas de las veces recibes objetos de eventos de usuario desde el entorno en tiempo de corrida, pero puedes crear tus propios eventos y enviar estos a otros componentes. public class Event implements java.io.Serializable { public static final int SHIFT MASK; public static final int CTRL MASK; public static final int META_MASK;

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...DDDiiimmmeeennnsssiiiooonnn

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...EEEvvveeennnttt

37

public static final int ALT_MASK; public static final int HOME; public static final int END; public static final int PGUP; public static final int PGDN; public static final int UP; public static final int DOWN; public static final int LEFT; public static final int RIGHT; public static final int F1; public static final int F2; public static final int F3; public static final int F4; public static final int F5; public static final int F6; public static final int F7; public static final int F8; public static final int F9; public static final int F10; public static final int F11; public static final ínt F12; public static final int PRINT SCREEN; public static final int SCROLL_LOCK; public static final int CAPSLOCK; public static final int NUM_LOCK; public static final int PAUSE; public static final int INSERT; public static final int ENTER; public static final int BACK_SPACE; public static final int TAB; public static final int ESCAPE; public static final int DELETE; public static final int WINDOW DESTROY; public static final int WINDOW_EXPOSE; public static final int WINDOW_ICONIFY; public static final int WINDOW_DEICONIFY; public static final int WINDOW_MOVED; public static final int KEY_PRESS; public static final int KEY_RELEASE; public static final int KEY ACTION; public static final int KEY ACTION_RELEASE; public static final int MOUSE_DOWN; public static final int MOUSE UP; public static final int MOUSE_MOVE; public static final int MOUSE ENTER; public static final int MOUSE_EXIT; public static final int MOUSE_DRAG;

38

public static final int SCROLL LINE_UP; public static final int SCROLL_LINE_DOWN; public static final int SCROLL_PAGE_UP; public static final int SCROLL_PAGE_DOWN; public static final int SCROLLABSOLUTE; public static final int SCROLL BEGIN; public static final int SCROLL_END; public static final int LIST_SELECT; public static final int LIST_DESELECT; public static final int ACTIONEVENT; public static final int LOAD FILE; public static final int SAVE_FILE; public static final int GOT_FOCUS; public static final int LOST_FOCUS; public Object target; public long when; public int id; public int x; public int y; public int key; public int modifiers; public int clickCount; public Object arg; public Event evt; void consume( ) public boolean controlDown( ) public Event(Object target, long when, int id, int x, int y, int key, int modifiers, Object arg) public Event(Object target, long when, int id, int x, int y, int key, int modifiers) public Event(Object target, int id, Object arg) boolean isConsumed( ) public boolean metaDown( ) protected String paramString( ) public boolean shiftDown( ) public String toString( ) public void translate(int x, int y) }

EventDiapatchTread es un hilo que atrapa eventos y envía estos a otros componentes. class EventDispatchThread extends Thread { EventDispatchThread(String name) public void run( ) public void stopDispatching( ) }

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...EEEvvveeennntttDDDiiissspppaaatttccchhhTTThhhrrreeeaaaddd

39

EventQueue Es una clase que encola eventos antes de que estos sean enviados a un componente. public class EventQueue { static EventQueue theEventQueue; public EventQueue( ) public synchronized Object getNextEvent() throws InterruptedException public synchronized Object peekEvent( public synchronized Object peekEvent(int id) public synchronized void postEvent(Event theEvent) public synchronized void postEvent(AWTEvent theEvent) } Crea un archivo recogedor de dialogo, creando una interface de usuario en un tiempo muy reducido. Es muy facil de usar. Simplemente cre una instancia de FileDialog, diga si este es un FileDialog modal,asi show( ) muestra los blockes mientras el usuario completa la actividad, cuando este retorna, puedes interrogar el objeto para determinar que archivo fue seleccionado. public class FileDialog extends Dialog { public static final int LOAD; public static final int SAVE; int mode; String dir; String file; FilenameFilter filter; public void addNotify( ) public FileDialog(Frame parent) public FileDialog(Frame parent, String title) public FileDialog(Frame parent, String title, int mode) public String getDirectory( ) public String getFile( ) public FilenameFilter getFilenameFilter( ) public int getMode( ) protected String paramString( ) boolean postsOldMouseEvents( ) public synchronized void setDirectory(String dir) public synchronized void setFile(String file) public synchronized void setFilenameFilter(FilenameFilter filter) public void setMode(int mode) } Es el mas basico de los manejadores. Las posiciones de los componentes izquierda a derecha, centrando estos tanto como sea posible. Puedes encontrar FlowLayout muy util para prototipos rapidoscuando el diseño sofisticado no es una proriedad.

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...EEEvvveeennntttQQQuuueeeuuueee

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...FFFiiillleeeDDDiiiaaallloooggg

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...FFFlllooowwwLLLaaayyyooouuuttt

40

public class FlowLayout implements LayoutManager, java.io.Serializable { public static final int LEFT; public static final int CENTER; public static final int RIGHT; int align; int hgap; int vgap; public void addLayoutComponent(String nace, Component comp) public FlowLayout( ) public F1owLayout(int align) public F1owLayout(int align, int hgap, int vgap) public int getAlignment() public int getHgap( ) public int getVgap( ) public void layoutContainer(Container target) public Dimension minimumLayoutSize(Container target) } Los Objetos Font son usados cuando ponemos las Fuentes para un Objeto grafico grapfico en un componenteen un metodo de componentes Paint. public class Font implements java.io.Serializable { public static final int PLAIN; public static final int BOLD; public static final int ITALIC; protected String nace; protected int style; protected int size; transient FontPeer peer; public static Font decode(String str) public boolean equals(Object obj) public Font(String name, int style, int size) public String getFamily( ) public static Font getFont(String nm) public static Font getFont(String nm, Font font) public String getName( ) public FontPeer getPeer( ) public int getSize( ) public int getStyle( ) public int hashCode( ) public boolean isBold( ) public boolean isltalic( ) public boolean isPlain( ) public String toString( ) private void writeObject(java.io.ObjectOutputStream s) throws java.lang.ClassNotFoundException, java.io.IOException }

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...FFFooonnnttt

41

Obtiene informacion acerca de una fuente, tales como Fuentes grandes, ascensión, descension, y otras mas. A menudo viene habilitado cuando usamos Graphics.drawString( ) en el dibujado de texto. Para usar esta clase simplemente una nueva instancia con la fuente de interes como un parámetro para el constructor. public class Font implements java.io.Serializable { public static final int PLAIN; public static final int BOLD; public static final int ITALIC; protected String nace; protected int style; protected int size; transient FontPeer peer; public static Font decode(String str) public boolean equals(Object obj) public Font(String name, int style, int size) public String getFamily( ) public static Font getFont(String nm) public static Font getFont(String nm, Font font) public String getName( ) public FontPeer getPeer( ) public int getSize( ) public int getStyle( ) public int hashCode( ) public boolean isBold( ) public boolean isltalic( ) public boolean isPlain( ) public String toString( ) private void writeObject(java.io.ObjectOutputStream s) throws java.lang.ClassNotFoundException, java.io.IOException } Crea una ventana con una barra de titulo. Se podria preguntar: Si todo en los Frame es bueno para que, porque no simplemente crear una ventana?, Window es la superclase de Frame, puedes crear una instancia de window por varias razones que son mas complecadas de explicar aquí. Es bastante confuso slo tenga confianza en uno. El manejador de diseño por default para Frame, y todas las subclases de ventanas para esta matera, es BorderLayout. Sin embargo ciertamente lo debes establecer. public class Frame extends Window implements MenuContainer { public static final int DEFAULT_CURSOR; public static final int CROSSHAIR_CURSOR; public static final int TEXT CURSOR; public static final int WAIT_CURSOR; public static final int SW_RESIZE_CURSOR; public static final int SE_RESIZE_CURSOR; public static final int NW_RESIZE_CURSOR;

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...FFFooonnntttMMMeeetttrrriiicccsss

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...FFFrrraaammmeee

42

public static final int NE_RESIZE_CURSOR; public static final int N_RESIZE_CURSOR; public static final int S_RESIZE_CURSOR; public static final int W_RESIZE_CURSOR; public static final int E RESIZE_CURSOR; public static final int HAND-CURSOR; public static final int MOVE CURSOR; String title; Image icon; MenuBar menuBar; boolean resizable; Vector ownedWindows; WindowListener windowListener; public void addNotify( ) Window addOwnedWindow(Window window) public synchronized void dispose( ) boolean eventEnabled(AWTEvent e) public Frame( ) public Frame(String title) public int getCursorType( ) public Image getlconImage( ) public MenuBar getMenuBar( ) public String getTitle( ) public boolean isResizable( ) protected String paramString( ) void postProcessKeyEvent(KeyEvent e) protected void processEvent(AWTEvent e) protected void processWindowEvent(WindowEvent e) public synchronized void remove(MenuComponent m) void removeOwnedWindow(Window window) public synchronized void setCursor(int cursorType) public synchronized void setIconlmage(Image image) public synchronized void setMenuBar(MenuBar mb) public synchronized void setResizable(boolean resizable) public synchronized void setTitle(String title) } La magia de los Objetos graficos. Que puedes crear debido a la abstracción. Si puedes crear uno, entonces pudes obtener uno? Puedes obtener un componente grafico en una pintura o actualizar metodos. Puedes tambien obtener un graphics desde un Objeto Imagen llamándolo Image.getGraphics. Este es de rendimiento fuera de la pantalla usando el doble buffer. public abstract class Graphics { public abstract void clearRect(int x, int y, int width, int height); public abstract void clipRect(int x, int y, int width, int height);

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...GGGrrraaappphhhiiicccsss

43

public abstract void copyArea(int x, int y, int width, int height, int dx, int dy); public abstract Graphics create( ); public Graphics create(int x, int y, int width, int height) public abstract void dispose( ); public void draw3DRect(int x, int y, int width, int height, boolean raised) public abstract void drawArc(int x, int y, int width, int height, int startAngle, int arcAngle); public void drawBytes(byte data[], int offset, int length, int x, int y) public void drawChars(char data[], int offset, int length, int x, int y) public abstract boolean drawImage(Image img, int x, int y, ImageObserver observer); public abstract boolean drawImage(Image img, int x, int y, int width, int height, ImageObserver observer); public abstract boolean drawImage(Image ¡mg, int x, int y, Color bgcolor, ImageObserver observer); public abstract boolean drawImage(Image img, int x, int y, Int width, int height, Color bgcolor, ImageObserver observer); public abstract boolean drawImage(Image img, int dxl, int dy1, int dx2, int dy2, int sxl, int sy1, int sx2, int sy2, ImageObservdrawimage public abstract boolean drawImage(Image img, int dxl, int dy1, int dx2, int dy2, int sx1, int sy1, int sx2, int sy2, Color bgcoldrawimage 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 drawPolygon(int xPoints[], int yPoints[], int nPoints); public void drawPolygon(Polygon p) public abstract void drawPolyline(int xPoints[], int yPoints[], int nPoints); public void drawRect(int x, int y, int width, int height) public abstract void drawRoundRect(int x, int y, int width, int height, int arcWidth, int arcHeight); public abstract void drawString(String str, int x, int y); public void fi113DRect(int x, int y, int width, int height, boolean raised) public abstract void fillArc(int x, int y, int width, int height, int startAngle, int arcAngle); public abstract void fillOval(int x, int y, int width, int height); public abstract void fillPolygon(int xPoints[], int yPoints[], int nPoints); public void fillPolygon(Polygon p) public abstract void fillRect(int x, int y, int width, int height); public abstract void fillRoundRect(int x, int y, int width, int height, int arcWidth, int arcHeight); public void finalize( ) public abstract Shape getClip( ); public abstract Rectangle getClipBounds( ) ; public Rectangle getClipRect( ) public abstract Color getColor( ); public abstract Font getFont( ); public FontMetrics getFontMetrics( ) public abstract FontMetrics getFontMetrics(Font f); protected Graphicsl( ) public abstract void setClip(int x, int y, int width, int height); public abstract void setClip(Shape clip); public abstract void setColor(Color c); public abstract void setFont(Font font); public abstract void setPaintMode( );

44

public abstract void setXORMode(Color cl); public String toString( ) public abstract void translate(int x, int y); } Es usada en conjunsion con GridBagLayout para configurar constraints para un componente antes de que el componente sea agregado a un contenedor. Muchos constraints pueden interactuar con muchos otros en muchas formas teniendo algunas funciones. public class GridBagConstraints implements Cloneable, java.io.Serializable { public static final int RELATIVE; public static final int REMAINDER; public static final int NONE; public static final int BOTH; public static final int HORIZONTAL; public static final int VERTICAL; public static final int CENTER; public static final int NORTH; public static final int NORTHEAST; public static final int EAST; public static final int SOUTHEAST; public static final int SOUTH; public static final int SOUTHWEST; public static final int WEST; public static final int NORTHWEST; public int gridx, gridy, gridwidth, gridheight; public double weightx, weighty; public int anchor, fill; public Insets insets; public int ipadx, ipady; int tempX, tempY; int tempWidth, tempHeight; int minWidth, minHeight; public Object clone( ) public GridBagConstraints() } Proprciona informacion para GridBagLayout. No es publico, no puedes usarlo a menos que estes en el packete awt. Que mas o menos le hace improbable eso, usted tendra que usar mucho GridBagLayoutInfo. class GridBagLayoutlnfo implements java.io.Serializable { int width, height; int startx, starty; int minWidth[];

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...GGGrrriiidddBBBaaagggCCCooonnnssstttrrraaaiiinnntttsss

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...GGGrrriiidddBBBaaagggLLLaaayyyooouuutttIIInnnfffooo

45

int minHeight[]; double weightX[]; double weightY[]; GridBagLayoutlnfo( ) } El mas flexible contenedor de todos los menejadores de diseño, es muy complicado la descripción para usarse efectivamente se describe aquí. Si esres maestro usando GridBagLayout, puedes crear impresionantes diseños. Use GridBagLayout con precaución. public class GridBagLayout implements LayoutManager2, java.io.Serializable { protected static final int MAXGRIDSIZE; protected static final int MINSIZE; protected static final int PREFERREDSIZE; protected Hashtable comptable; protected GridBagConstraints defaultConstraints; protected GridBagLayoutlnfo layoutlnfo; public int columnWidths[]; public int rowHeights[]; public double columnWeights[]; public double rowWeights[]: public void addLayoutComponent(String name, Component comp) public void addLayoutComponent(Component comp, Object constraints) protected void AdjustForGravity(GridBagConstraints con straints, Rectangle r) protected void ArrangeGrid(Container parent) public GridBagConstraints getConstraints(Component comp) public float getLayoutAlignmentX(Container parent) public float getLayoutAlignmentY(Container parent) public int [][] getLayoutDimensions( ) protected GridBagLayoutlnfo GetLayoutlnfo(Container parent, int sizeflag) public Point getLayoutOrigin( ) public double [][] getLayoutWeights( ) protected Dimension GetMinSize(Container parent, GridBagLayoutlnfo info) public GridBagLayout( ) public void invalidateLayout(Container target) public void layoutContainer(Container parent) public Point location(int x, int y) protected GridBagConstraints lookupConstraints(Component comp) public Dimension maximumLayoutSize(Container target) public Dimension minimumLayoutSize(Container parent) public Dimension preferredLayoutSize(Container parent) public void removeLayoutComponent(Component comp) public void setConstraints(Component comp, GridBagConstraints constraints) public String toString( ) }

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...GGGrrriiidddBBBaaagggLLLaaayyyooouuuttt

46

Use GridLayout cuando necesite posicionar varios componentes en una rejilla. Para usar GriLayout, cree un objeto GrifLayout con el numero de renglones y columnas que desee y luego agregue componentes a el contenedor. Agregue los componentes de izquierda a derecha, y de arriba a bajo. Cuando crea un GridLayout, sea cuidadoso cuando agregue muchos componentes. El manejador de diseño tiende a confundirse si no agrega el numero correcto de componentes. Por ejemplo si tiene un grid de 3x3, asegúrese de agregar nueve componentes. public class GridLayout implements LayoutManager, java.io.Serializable { int hgap; int vgap; int rows; int cols; public void addLayoutComponent(String name, Component comp) public int getColumns( ) public int getHgap( ) public int getRows( ) public int getVgap( ) public GridLayout( ) public GridLayout(int rows, int cols) public GridLayout(int rows, int cols, int hgap, int vgap) public void layoutContainer(Container parent) public Dimension minimumLayoutSize(Container parent) public Dimension preferredLayoutSize(Container parent) public void removeLayoutComponent(Component comp) public void setColumns(int cols) public void setVgap(int hgap) public void setRows(int rows) public void setVgap(int vgap) public String toString( ) }

Image es una de las rezones por las que Java se ha convertido en el éxito del momento. Pudes crear una imagen directamente devido a que esta es abstracta. Muchas de las veces, muchas de las veces puedes obtener una imagen algunas veces usando getImage. Puedes tambien crear una imagen usando valores de píxel. public abstract class Image implements java.io.Serializable { public static final Object UndefinedProperty; public static final int SCALE DEFAULT; public static final int SCALE_FAST; public static final int SCALE_SM00TH; public static final int SCALE_REPLICATE; public static final int SCALE_AREA AVERAGING; public Image getscaledinstance(int width, int height, int hints) public abstract void flush( ); public abstract Graphics getGraphicso; public abstract int getHeight(ImageObserver observer); public abstract Object getProperty(String name, ImageObserver observer); public abstract ImageProducer getSource( ); public abstract int getWidth(ImageObserver observer); }

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...GGGrrriiidddLLLaaayyyooouuuttt

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...IIImmmaaagggeee

47

Es una pequeña clase curiosa usada para agregar espacios entre componentes en un contenedor. Ofrece entrar en conjunción con GridBagLayot. public class Insets implements Cloneable, java.io.Serializable { public int top; public int left; public int bottom; public int right; public Object clone( ) public boolean equals(Object obj) public Insets(int top, int left, int bottom, int right) public String toString( ) } Es una interfaz usada por clases que pueden sostener una o más opciones seleccionables. La clase implementa esta interfaz. public interface ItemSelectable { public void addItemListener(ItemListener 1); public Object[] getSelectedObjects( ); public void removeItemListener(ItemListener 1); } Un componente Label, simplemente puede desplegar texto en una simple linea. Puede hacer lo mismo usando eficazmente Graphics. Funciona como cualquier otro componente solo agréguelo a un contenedor. public class Label extends Component { public static final int LEFT; public static final int CENTER; public static final int RIGHT; String text; int alignment; public void addNotify( ) public int getAlignment( ) public String getText() public Label( ) public Label(String text) public Label(String text, int alignment) protected String paramString( ) public synchronized void setAlignment(int alignment) public synchronized void setText(String text) }

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...IIInnnssseeetttsss

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...IIIttteeemmmSSSeeellleeeccctttaaabbbllleee

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...LLLaaabbbeeelll

48

Si usted alguna vez quiere crear su propio LayoutManager, implemente esta clase. Por otra parte, usted realmente no necesita preocuparse por LayoutManager. Básicamente, todos los LayoutsManagers (tales como FlowLayout y GridaLayout) debe implementar esta interfaz y sobreescribir los métodos. public interface LayoutManager { void addLayoutComponent(String nace, Component comp); void layoutContainer(Container parent); Dimension minimumLayoutSize(Container parent); Dimension preferredLayoutSize(Container parent); void removeLayoutComponent(Component comp); } De paso a la continuación para LayoutMananger. Esta interfaz extiende LayoutManager para tratar con LayoutManagers con el objeto constreñimiento. Es útil cuando usted quiere crear manejadores de diseño avanzados como GridBagLayout. A menos que usted se un superheroe de la programación-Java, usted probablemente no usará demasiado a menudo esta interfaz. public interface LayoutManager2 extends LayoutManager { void addLayoutComponent(Component comp, Object constraints); public float getLayoutAlignmentX(Container target); public float getLayoutAlignmentY(Container target); public void invalidateLayout(Container target); public Dimension maximumLayoutSize(Container target); } Lista, un componente de caja-lista, se parece a un juego de ítems de texto de seleccion. Usted puede especificar cuántos items se despliegan en un momento y si más de un Item pueden seleccionarse. public class List extends Component implements ItemSelectable { Vector items; int rows; boolean multipleMode; int selected[]; int visibleIndex; ActionListener actionListener; ItemListener itemListener; final static int DEFAULT_VISIBLE_ROWS; public void add(String item) public synchronized void add(String item, int index) public void addActionListener(ActionListener 1) public void addltem(String item) public synchronized void addltem(String item, int index) public void addltemListener(ItemListener 1)

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...LLLaaayyyooouuutttMMMaaannnaaagggeeerrr

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...LLLaaayyyooouuutttMMMaaannnaaagggeeerrr222

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...LLLiiisssttt

49

public void addNotify( ) public boolean allowsMultipleSelections( ) public synchronized void clear( ) public int countltems( ) public synchronized void delltem(int position) public synchronized void delltems(int start, int end) public synchronized void deselect(int index) boolean eventEnabled(AWTEvent e) public String getltem(int index) public int getltemCount( ) public synchronized String[] getltems( ) public Dimension getMinimumSize(int rows) public Dimension getMinimumSize( ) public Dimension getPreferredSize(int rows) public Dimension getPreferredSize( ) public int getRows( ) public synchronized int getSelectedlndex( ) public synchronized int[] getSelectedlndexes( ) public synchronized String getSelectedltem( ) public synchronized String[] getSelectedltems( ) public Object[] getSelectedObjects( ) public int getVisiblelndex( ) public boolean islndexSelected(int index) public boolean isMultipleMode( ) public boolean isSelected(int index) public Listo( ) public List(int rows) public List(int rows, boolean multipleMode) public synchronized void makeVisible(int index) public Dimension minimumSize(int rows) public Dimension minimumSize( ) protected String paramString( ) public Dimension preferredSize(int rows) public Dimension preferredSize( ) protected void processActionEvent(ActionEvent e) protected void processEvent(AWTEvent e) protected void processltemEvent(ItemEvent e) public synchronized void remove(String item) public synchronized void remove(int position) public void removeActionListener(ActionListener 1) public synchronized void removeAll( ) public void removeltemListener(ItemListener 1) public void removeNotify( ) public synchronized void replaceltem(String newValue, int index) public synchronized void select(int index) public synchronized void setMultipleMode(boolean b) public synchronized void setMultipleSelections(boolean b)

50

private void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException } Normalmente, Images es descargado asincrónicamente desde una red para que usted no tenga que esperar por ello. A veces, sin embargo, usted puede querer esperar por un 1 Imagen antes de que usted siga - por ejemplo, antes de algunas salidas de la animación. Usted podría crear una clase que lleva a cabo un Consumidor y podría mirar pasar los pedazos, mientras notando cuando los acabados del traslado. Afortunadamente, Sun Microsystems ha hecho esto para usted en el formulario de Media Tracker. Para usar la clase, cree una instancia de Media Tracker, agregue un objeto imagen con un número de identificación arbitrario, y llama a waitForld(). Entonces el waitForld( ) volverá cuando la Imagen haya sido completamente transmitido. public class MediaTracker implements java.io.Serializable { Component target; MediaEntry head; public static final int LOADING; public static final int ABORTED; public static final int ERRORED; public static final int COMPLETE; static final int DONE; public void addlmage(Image image, int id) public synchronized void addlmage(Image image, int id, int w, int h) public boolean checkAll( ) public synchronized boolean checkAll(boolean load) public boolean checklD(int id) public synchronized boolean checklD(int id, boolean load) public synchronized Object[] getErrorsAny( ) public synchronized Object[] getErrorslD(int id) public synchronized boolean isErrorAny( ) public synchronized boolean isErrorID(int id) public MediaTracker(Component comp) public synchronized void removelmage(Image image) public synchronized void removelmage(Image image, int id) public synchronized void removelmage(Image image, int id, int width, int height) synchronized void setDone( ) public synchronized int statusAll(boolean load) public synchronized int statuslD(int id, boolean load) public void waitForAll( ) throws InterruptedException public synchronized boolean waitForAll(long ms) throws InterruptedException public void waitForID(int id) throws InterruptedException public synchronized boolean waitForID(int id, long ms) throws InterruptedException }

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...MMMeeedddiiiaaaTTTrrraaaccckkkeeerrr

51

Menú es que una de tres clases para crear los menús en un Frame. (Las otras clases son MenuBa r y Menultem (o CheckboxMenu Item)). los Menús no son Componentes, e estos no pueden agregarse a Containers. Se agregan a las Barras de Menu, y los MenuItem se agregan a los menu. Los menu también pueden agregarse los Menús para crear los menús en forma de cascada. public class Menu extends Menultem implements MenuContainer { Vector items; boolean tearOff; boolean isHelpMenu; public synchronized Menultem add(Menultem mi) public void add(String label) public void addNotify( ) public void addSeparator() public int countltems( ) void deleteShortcut(MenuShortcut s) public Menultem getltem(int index) public int getltemCount( ) Menultem getShortcutMenultem(MenuShortcut s) boolean handleShortcut(KeyEvent e) public synchronized void insert(Menultem menuitem, int index) public void insert(String label, int index) public void insertSeparator(int index) public boolean isTearOff() public Menu( ) public Menu(String label) public Menu(String label, boolean tearOff) public String paramString( ) public synchronized void remove(int index) public synchronized void remove(MenuComponent item) public synchronized void removeAll( ) public void removeNotify( ) synchronized Enumeration shortcuts( ) } Un Marco puede sostener una Barra de menú, que aparece arriba de un marco para usar la Barra de menú, cree una instancia de él y agregúelo a un marco llamando a Frame.setMenuBar. public class MenuBar extends MenuComponent implements MenuContainer { Vector menus; Menu helpMenu; public synchronized Menu add(Menu m) public void addNotify( ) public int countMenus( ) public void deleteShortcut(MenuShortcut s) public Menu getHelpMenu( ) public Menu getMenu(int i) public int getMenuCount( )

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...MMMeeennnuuu

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...MMMeeennnuuuBBBaaarrr

52

public Menultem getShortcutMenuItem(MenuShortcut s) boolean handleShortcut(KeyEvent e) public MenuBar( ) public synchronized void remove(int index) public synchronized void remove(MenuComponent m) public void removeNotify( ) public synchronized void setHelpMenu(Menu m) public synchronized Enumeration shortcuts( ) } MenuComponent es la superclass de los objetos Menú. Es abstracto, y no puede crear una instancia directamente de el. Usted probablemente no tendrá que tratar con MenuComponent a menos que planee crear sus propios Items de menú. public abstract class MenuComponent implements java.io.Serializable { transient MenuComponentPeer peer; transient MenuContainer parent; Font font; String name; boolean newEventsOnly; void dispatchEvent(AWTEvent e) boolean eventEnabled(AWTEvent e) public Font getFont( public String getName( ) public MenuContainer getParent( ) public MenuComponentPeer getPeer( ) protected String paramString() public boolean postEvent(Event evt) protected void processEvent(AWTEvent e) public void removeNotify( ) public void setFont(Font f) public void setName(String name) public String toString( ) } Bienvenido a MenuContainer, una interfaz usada con los Menús. A menos que usted quiera crear su propio tipo de Menú, sentimos decirle que usted no tendrá mucho uso para MenuContainer. Pero tomaremos un atisbo a él, sólo en caso de que usted lo necesite a algún punto. public interface MenuContainer { Font getFont() ; boolean postEvent(Event evt); void remove(MenuComponent comp); }

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...MMMeeennnuuuCCCooommmpppooonnneeennnttt

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...MMMeeennnuuuCCCooonnntttaaaiiinnneeerrr

53

MenuItem crea el Item actual que un usuario selecciona de un Menú. (Vea "java.awtCheckboxMenultem" en esta parte si usted quiere un CheckboxinyourMenultem.) apoyese en los atajos de teclado. Para crear un MenuItem, simplemente cree un Instancia de MenuItemand y agregúelo a un Menú. public class MenuItem extends MenuComponent { boolean enabled; String label; String actionCommand; long eventMask; ActionListener actionListener; public void addActionListener(ActionListener 1) public void addNotify( ) public void deleteShortcut( ) void deleteShortcut(MenuShortcut s) public synchronized void disable( ) protected final void disableEvents(long eventsToDisable) public synchronized void enable( ) public void enable(boolean b) protected final void enableEvents(long eventsToEnable) boolean eventEnabled(AWTEvent e) public String getActionCommand( ) public String getLabel( ) public MenuShortcut getShortcut( ) Menultem getShortcutMenuItem(MenuShortcut s) boolean handleShortcut(KeyEvent e) public boolean isEnabled( ) public MenuItem( ) public Menultem(String label) public Menultem(String label, MenuShortcut s) public String paramString( ) protected void processActionEvent(ActionEvent e) protected void processEvent(AWTEvent e) public void removeActionListener(ActionListener 1) public void setActionCommand(String command) public synchronized void setEnabled(boolean b) public synchronized void setLabel(String label) public void setShortcut(MenuShortcut s) } Si usted alguna vez se preguntara de qué clase se crea los atajos del teclado para losMenuItems, entonces haga una extensa investigasion de MenuShortcut. public class MenuShortcut implements Serializable { public boolean equals(MenuShortcut s) public int getKey( )

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...MMMeeennnuuuIIIttteeemmm

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...MMMeeennnuuuSSShhhooorrrtttcccuuuttt

54

protected String paramString( ) public String toString( ) public boolean usesShiftModifier( ) } Usted puede usar Panel, una área rectangular, un contenedor para dibujar o agregar los Componentes. Porque Panel es un recipiente, la mayoría del tiempo, usted usa el Panelagregar agrupar los Componentes. Usted puede notar las similitudes entre el Panelero y Canvas, pero el Panel es un Contenedor y Canvas no lo es. El administrador de diseño predefinido para el Panel (y todas las subclasses, como Applet) es FlowLayout. public class Panel extends Container { final static LayoutManager panelLayout; public void addNotify( ) public Panel( ) public Panel(LayoutManager layout) } A veces usted puede necesitar una clase simple para sostener una X y Y coordenada. Introduzca el punto para hacer simplemente eso. public class Point implements java.io.Serializable { public int x; public int y; public boolean equals(Object obj) public Point getLocation( ) public int hashCode( ) public void move(int x, int y) public Point( ) public Point(Point p) public Point(int x, int y) public void setLocation(Point p) public void setLocation(int x, int y) public String toString( ) public void translate(int x, int y) } Polígon dibuja polígonos. La clase Gráphics contiene un metodo drawPolygon() que toma un objeto Polígono como un argumento y realmente hace el dibujo. El polígono simplemente sostiene las coordenadas de los vertices. public class Polygon implements Shape, java.io.Serializable { public int npoints; public int xpoints[]; public int ypoints[];

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...PPPaaannneeelll

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...PPPoooiiinnnttt

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...PPPooolllyyygggooonnn

55

protected Rectangle bounds; public void addPoint(int x, int y) void calculateBounds(int xpoints[], int ypoints[], int npoints) public boolean contains(Point p) public boolean contains(int x, int y) public Rectangle getBoundingBox() public Rectangle getBounds( ) public boolean inside(int x, int y) public Polygon( ) public Polygon(int xpoints[], int ypoints[], int npoints) public void translate(int deltaX, int deltaY) void updateBounds(int x, int y) } PopupMenu crea un menú automáticamente en cualquier parte en un Componente. Para usarlo, simplemente cree una Instancia, agregue algúnos MenuItems (o CheckboxMenultems), y entonces llame a PopupMenu.show() con el Componente y coordenadas que especifican donde usted quiere que aparezca. public class PopupMenu extends Menu { public synchronized void addNotify( ) public PopupMenu( ) public PopupMenu(String label) public void show(Component origin, int x, int y) } Esta interfaz mantiene un contexto de gráficos de impresión para una página. Esta clase contiene un método por devolver el objeto de Trabajo de Impresión que el objeto de PrintGraphics originó. public interface PrintGraphics { public PrintJob getPrintJob( ); } PrintJob se usa para efectuar la impresión. La clase es abstracta, para instanciarla directamente. Usted debe recibir una instancia de Toolkit que usara el getPrintJob(). public abstract void end(); { public void finalize( ) public abstract Graphics getGraphics(); public abstract Dimension getPageDimension( ); public abstract int getPageResolution( ); public abstract boolean lastPageFirst( ); }

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...PPPooopppuuupppMMMeeennnuuu

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...PPPrrriiinnntttGGGrrraaappphhhiiicccsss

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...PPPrrriiinnntttJJJooobbb

56

Rectángle es una clase de utilidad que sostiene cuatro enteros: x, y, anchura, y altura. El rectángulo ofrece algunos métodos útiles, como incide() que le dice si un punto está dentro del Rectángulo. public class Rectangle implements Shape, java.io.Serializable { public int x; public int y; public int width; public int height; public void add(int newx, int newy) public void add(Point pt) public void add(Rectangle r) public boolean contains(Point p) public boolean contains(int x, int y) public boolean equals(Object obj) public Rectangle getBounds( public Point getLocation( ) public Dimension getSize() public void grow(int h, int v) public int hashCode() public boolean inside(int x, int y) public Rectangle intersection(Rectangle r) public boolean intersects(Rectangle r) public boolean isEmpty( ) public void move(int x, int y) public Rectangle( ) public Rectangle(Rectangle r) public Rectangle(int x, int y, int width, int height) public Rectangle(int width, int height) public Rectangle(Point p, Dimension d) public Rectangle(Point p) public Rectangle(Dimension d) public void reshape(int x, int y, int width, int height) public void resize(int width, int height) public void setBounds(Rectangle r) public void setBounds(int x, int y, int width, int height) public void setLocation(Point p) public void setLocation(int x, int y) public void setSize(Dimension d) public void setSize(int width, int height) public String toString( ) public void translate(int x, int y) public Rectangle union(Rectangle r) } ScrollPane, es un nuevo Recipiente desde el JDK 1.1, crea un Tablero desplazable. Que trabaja con un simple Panel (vea "java.awt.Panel" en esta parte), excepto que las barras pueden desplasarse y desplazar los componentes.

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...RRReeeccctttaaannngggllleee

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...SSScccrrrooollllllPPPaaannneee

57

public class ScrollPane extends Container { public static final int SCROLLBARS_AS NEEDED; public static final int SCROLLBARS_ALWAYS; public static final int SCROLLBARS_NEVER; public Component add(Component comp, int pos) public void addNotify( ) public void doLayout( ) public Adjustable getHAdjustable( ) public int getHScrollbarHeight( ) public int getScrollbarDisplayPolicy( ) public Point getScrollPosition( ) public Adjustable getVAdjustable( ) public Dimension getViewportSize( ) public int getVScrollbarWidth( ) public void layout( ) public String paramString( ) public void printComponents(Graphics g) public ScrollPane( ) public ScrollPane(int scrollbarDisplayPolicy) public final void setLayout(LayoutManager mgr) public void setScrollPosition(int x, int y) public void setScrollPosition(Point p) } Scrollbar es un Componente como Botón o Casilla de verificación. Para usar esta clase, todos que usted tiene que hacer es crear una Instancia y agregarla a un Container. Usted puede especificar páginado y los incrementos finos, aunque los valores predefinidos toman el efecto si usted no lo hace. public class Scrollbar extends Component implements Adjustable { public static final int HORIZONTAL; public static final int VERTICAL; int value; int maximum; int minimum; int visibleAmount; int orientation; int lineIncrement; int pageIncrement; AdjustmentListener adjustmentListener; public void addAdjustmentListener(AdjustmentListener l) public void addNotify( ) boolean eventEnabled(AWTEvent e) public int getBlockIncrement( ) public int getLinelncrement( ) public int getMaximum( ) public int getMinimum( )

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...SSScccrrrooollllllbbbaaarrr

58

public int getOrientation( ) public int getPageIncrement( ) public int getUnitlncrement( ) public int getValue( ) public int getVisible( ) public int getVisibleAmount( ) protected String paramString( ) protected void processAdjustmentEvent(AdjustmentEvent e) protected void processEvent(AWTEvent e) public void removeAdjustmentListener(AdjustmentListener 1) public Scrollbar( ) public Scrollbar(int orientation) public Scrollbar(int orientation, int value, int visible, int minimum, int maximum) public synchronized void setBlockIncrement(int v) public void setLineIncrement(int v) public synchronized void setMaximum(int newMaximum) public synchronized void setMinimum(int newMinimum) public synchronized void setOrientation(int orientation) public void setPageIncrement(int v) public synchronized void setUnitIncrement(int v) public synchronized void setValue(int newValue) public synchronized void setValues(int value, int visible, int minimum, int maximum) public synchronized void setVisibleAmount(int newAmount) } Shape es una interfaz usada por algunas de las clases gráficos-relacionadas. public interface Shape { public Rectangle getBounds( ); } SystemColor describe colores simbólicos que representan el color de objetos de GUI en un sistema. public final class SystemColor extends Color implements java.io.Serializable { public final static int DESKTOP; public final static int ACTIVE CAPTION; public final static int ACTIVE_CAPTION_TEXT; public final static int ACTIVE CAPTION_BORDER; public final static int INACTIVE_CAPTION; public final static int INACTIVE_CAPTION TEXT; public final static int INACTIVE CAPTION_BORDER; public final static int WINDOW; public final static int WINDOW_BORDER; public final static int WINDOW TEXT; public final static int MENU;

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...SSShhhaaapppeee

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...SSSyyysssttteeemmmCCCooolllooorrr

59

public final static int MENU_TEXT; public final static int TEXT; public final static int TEXT TEXT; public final static int TEXT HIGHLIGHT; public final static int TEXT_HIGHLIGHT TEXT; public final static int TEXT INACTIVE_TEXT; public final static int CONTROL; public final static int CONTROL_TEXT; public final static int CONTROL_ HIGHLIGHT; public final static int CONTROL_LT_HIGHLIGHT; public final static int CONTROL_SHADOW; public final static int CONTROL_DK_SHADOW; public final static int SCROLLBAR; public final static int INFO; public final static int INFO TEXT; public final static int NUM_COLORS; public final static SystemColor desktop; public final static SystemColor activeCaption; public final static SystemColor activeCaptionText; public final static SystemColor activeCaptionBorder; public final static SystemColor inactiveCaption; public final static SystemColor inactiveCaptionText; public final static SystemColor inactiveCaptionBorder; public final static SystemColor window; public final static SystemColor windowBorder; public final static SystemColor windowText; public final static SystemColor menu; public final static SystemColor menuText; public final static SystemColor text; public final static SystemColor textText; public final static SystemColor textHighlight; public final static SystemColor textHighlightText; public final static SystemColor textInactiveText; public final static SystemColor control; public final static SystemColor controlText; public final static SystemColor controlHighlight; public final static SystemColor controlLtHighlight; public final static SystemColor controlShadow; public final static SystemColor controlDkShadow; public final static SystemColor scrollbar; public final static SystemColor info; public final static SystemColor infoText; }

60

TextArea es una área del multi-línea usada pora editar. Es un Componente, para que usted puede agregarlo a cualquier Recipiente(container). TextArea puede ocuparse de eventos importantes, incluso el corte y funcionamientos de pegado, automáticamente. Esta clase también puede crear el scrollbars y puede ocuparse de los eventos como es de era de esperarse. Note que algunos de los métodos que usted puede esperar encontrar en esta clase, como el getText (), realmente se define en TextComponent. Si usted no encuentra lo que está buscando aquí, revise en TextComponent (vea "java.awt.TextComponent" en esta parte). public class TextArea extends TextComponent { int rows; int columns; public static final int SCROLLBARS_BOTH; public static final int SCROLLBARS_VERTICAL_ONLY; public static final int SCROLLBARS_HORIZONTAL_ONLY; public static final int SCROLLBARS_NONE; public void addNotify( ) public synchronized void append(String str) public void appendText(String str) public int getColumns( ) public Dimension getMinimumSize(int rows, int columns) public Dimension getMinimumSize( ) public Dimension getPreferredSize(int rows, int columns) public Dimension getPreferredSize( ) public int getRows( ) public int getScrollbarVisibility( ) public synchronized void insert(String str, int pos) public void insertText(String str, int pos) public Dimension minimumSize(int rows, int columns) public Dimension minimumSize( ) protected String paramString( ) public Dimension preferredSize(int rows, int columns) public Dimension preferredSize( ) public synchronized void replaceRange(String str, int start, int end) public void replaceText(String str, int start, int end) public void setColumns(int columns) public void public TextArea( ) public TextArea(String text) public TextArea(String text, int rows, int columns) public TextArea(String text, int rows, int columns, int scrollbars) public TextArea(int rows, int columns) } TextComponent es la superclase de TextField y TextArea. Apenas factoriza fuera alguna de la conducta común en las dos clases. Usted probablemente no accederá directamente esta clase, pero usted puede tener que buscar aquí para encontrar métodos esperados que no aparecen en TextField o TextArea.

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...TTTeeexxxtttAAArrreeeaaa

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...TTTeeexxxtttCCCooommmpppooonnneeennnttt

61

public class TextComponent extends Component { String text; boolean editable; int selectionStart; int selectionEnd; protected TextListener textListener; public void addTextListener(TextListener 1) boolean eventEnabled(AWTEvent e) public int getCaretPosition( ) public synchronized String getSelectedText( ) public synchronized int getSelectionEnd( ) public synchronized int getSelectionStart( ) public synchronized String getText( ) public boolean isEditable( ) protected String paramString( ) protected void processEvent(AWTEvent e) protected void processTextEvent(TextEvent e) public void removeNotify( ) public void removeTextListener(TextListener 1) public synchronized void select(int selectionStart, int selectionEnd) public synchronized void selectAll( public void setCaretPosition(int position) public synchronized void setEditable(boolean b) public synchronized void setSelectionEnd(int selectionEnd) public synchronized void setSelectionStart(int selectionStart) public synchronized void setText(String t) TextComponent(String text) } TextField es una simple línea de texto editable. Usted puede especificar el número de columnas que son visible en uno de los constructores. TextField puede hacerse no-editable si usted apenas quiere desplegar el texto con un borde alrededor de él para las estética. public class TextField extends TextComponent { int columns; char echoChar; ActionListener actionListener; public void addActionListener(ActionListener 1) public void addNotify( ) public boolean echoCharIsSet( boolean eventEnabled(AWTEvent e) public int getColumns( ) public char getEchoChar( ) public Dimension getMinimumSize(int columns) public Dimension getMinimumSize( ) public Dimension getPreferredSize(int columns) public Dimension getPreferredSize( ) public Dimension minimumSize(int columns)

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...TTTeeexxxtttFFFiiieeelllddd

62

public Dimension minimumSize( ) protected String paramString( ) public Dimension preferredSize(int columns) public Dimension preferredSize( ) protected void processActionEvent(ActionEvent e) protected void processEvent(AWTEvent e) public void removeActionListener(ActionListener 1) public void setColumns(int columns) public void setEchoChar(char c) public void setEchoCharacter(char c) public TextField( ) public TextField(String text) public TextField(String text, int columns) public TextField(int columns) }

Toolkit es para encontrar todas las propiedades de un sistema, como el tamaño de la pantalla, la resolución, las fuentes disponibles, y así sucesivamente. Porque Toolkit es abstracto, usted puede hacer una Instancia del objeto llamando Toolkit.getDefaultToolkit( ). public abstract class Toolkit { public abstract void beep( ); public abstract int checkImage(Image image, int width, int height, ImageObserver observar); protected abstract ButtonPeer createButton(Button target); protected abstract CanvasPeer createCanvas(Canvas target); protected abstract CheckboxPeer createCheckbox(Checkbox target); protected abstract CheckboxMenultemPeer createCheckboxMenuItem(CheckboxMenultem target); protected abstract ChoicePeer createChoice(Choice target); protected java.awt.peer.LightweightPeer createComponent(Component target) protected abstract DialogPeer createDialog(Dialog target); protected abstract FileDialogPeer createFileDialog(FileDialog target); protected abstract FramePeer createFrame(Frame target); public abstract Image createImage(ImageProducer producer); public Image createImage(byte[] imagedata) public abstract Image createImage(byte[] imagedata, int imageoffset, int imagelength); protected abstract LabelPeer createLabel(Label target); protected abstract ListPeer createList(List target); protected abstract MenuPeer createMenu(Menu target); protected abstract MenuBarPeer createMenuBar(MenuBar tar get); protected abstract MenuItemPeer createMenuItem(Menultem target); protected abstract Panel Peer createPanel(Panel target); protected abstract PopupMenuPeer createPopupMenu(PopupMenu target); protected abstract ScrollbarPeer createScrollbar(Scrollbar target); protected abstract Scrol]Pan ePeer createScrol1Pane(Scrol1Pane target); protected abstract TextAreaPeer createTextArea(TextArea target);

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...TTToooooolllkkkiiittt

63

protected abstract TextFieldPeer createTextField(TextField target); protected abstract WindowPeer createWindow(Window target); public abstract ColorModel getColorModel( ); public static synchronized Toolkit getDefaultToolkit( ) public abstract String[] getFontList( ); public abstract FontMetrics getFontMetrics(Font font); protected abstract FontPeer getFontPeer(String name, int style); public abstract Image getImage(String filename); public abstract Image getlmage(URL url); public int getMenuShortcutKeyMask( ) protected static Container getNativeContainer(Component c) public abstract PrintJob getPrintJob(Frame frame, String jobtitle, Properties props); public static String getProperty(String key, String defaultValue) public final EventQueue getSystemEventQueue( ) public abstract int getScreenResolution( ); public abstract Dimension getScreenSize( ); public abstract Clipboard getSystemClipboard( ); protected void loadSystemColors(int[] systemColors) public abstract boolean prepareImage(Image image, int width, int height, ImageObserver observer); static public abstract void sync( ); } La ventana es la superclase de Frame y Diálog. Usted no puede crear una Instancia de Window a menos que usted este en el paquete de AWT. Usted usa Window como factor comun entre Frame y Diálog. Si usted quiere crear una ventana estandar con una barra de título, use Frame(vea "java.awt.Frame" en esta parte). public class Window extends Container { String warningString; public void addNotify( ) public synchronized void addWindowListener(WindowListener 1) void dispatchEvent(AWTEvent e) public void dispose( ) boolean eventEnabled(AWTEvent e) public Component getFocusOwner( ) public Locale getLocale( ) public Toolkit getToolkit( ) public final String getWarningString( ) void nextFocus(Component base) public synchronized void removeWindowListener(WindowListener 1) public void pack( ) public boolean postEvent(Event e) void postProcessKeyEvent(KeyEvent e) void setFocusOwner(Component c) public void show( ) public void toBack( ) public void toFront( )

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...WWWiiinnndddooowww

64

PPPAAACCCKKKAAAGGGEEE

JJJaaavvvaaa...aaawwwttt...eeevvveeennnttt

void transferFocus(Component base) Window( ) public Window(Frame parent) }

Las clases e interfaces en el pakete java.awt.event soprtan el modelo de delegacion de eventos. Usted

puede encontrar el modelo de delegacion mas eficaz que los métodos convencionales encontrados en el JDK 1.02. Los métodos

convencionales todavía se apoyan y funcionan como se encontraba en el JDK 1.1, pero usted no debe mezclar a los métodos convencionales y el modelo de delegacion de eventos. Las figuras siguientes muestran el package de la jerarquía de clases de java.awt.event.

Usted encuentra tres tipos de objetos en este paquete: los eventos, los adaptadores, y los oyentes. Los eventos, como ActionEvent o MouseEvent, contienen la información sobre los eventos y son pasados al manejador de evento de los métodos. Los adaptadores, como WindowAdapter o ComponentAdapter, son clases abstractas que

65

usted puede extender en orden para manejar los eventos. Los oyentes, como MouseMotionListener o ActionListener, son las interfazs que usted puede lnstanciar para ocuparse de eventos. ¿Así que cuál es la diferencia entre los adaptadores y oyentes? Los adaptadores son las clases abstractas, que usted puede solamente puede extender de ellos. Los oyentes son las interfaces, que usted puede lnstanciar tantos como usted guste. ¿usted puede usar a los tantos oyentes como usted quiera, por qué no siempre usa los oyentes? La mayoría de los oyentes tienen más de un método especificado, usted pueda sobre escribir todos sus métodos, aun cuando estos no hacen nada. Los métodos del adaptador no hacen nada por defecto, para que usted sólo tiene que sobre escribir los métodos que le interesan. En los casos dónde sólo un método se especifica, como ActionListener, ninguna clase del adaptador correspondiente existe. Una clase abstracta para una interfaz con sólo un método no proporciona ningún ventaja, porque no se define. Cuando una acción ocurre, un ActionListener recibe una Instancia de este objeto. Las acciones pueden ser de botón presionado, las selecciones de Item de menú, el retorno de las letras introducidas en un campo del texto, y así sucesivamente. public class ActionEvent extends AWTEvent { public static final int SHIFT_MASK: public static final int CTRL MASK; public static final int METAMASK; public static final int ALT TMASK; public static final int ACION_FIRST; public static final int ACTION_LAST; public static final int ACTION_PERFORMED; String actionCommand; int modifiers; public ActionEvent(Object source, int id, String command) public ActionEvent(Object source, int id, String command, int modifiers) public String getActionCommand( ) public int getModifiers( ) public String paramString( ) } Cuando usted crea una clase para el manejo de un evento de acción, usted debe Instanciar esta interfaz y debe sobre escribir el método del actionPerformed. El resultado: Usted consigue una Instancia de ActionListener que describe el evento. public interface ActionListener extends EventListener { public void actionPerformed(ActionEvent e); } Use esta clase con los componentes ajustables, tales como las barras desplazables. Objetos que llevan a cabo el AdjustmentListener reciben una Instancia de esta clase. public class AdjustmentEvent extends AWTEvent {

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...eeevvveeennnttt...AAAccctttiiiooonnnEEEvvveeennnttt

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...eeevvveeennnttt...AAAccctttiiiooonnnLLLiiisssttteeennneeerrr

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...eeevvveeennnttt...AAAdddjjjuuussstttmmmeeennntttEEEvvveeennnttt

66

public static final int ADJUSTMENT FIRST; public static final int ADJUSTMENT_LAST; public static final int ADJUSTMENT_VALUE_CHANGED; public static final int UNIT_INCREMENT; public static final int UNIT DECREMENT; public static final int BLOCK_DECREMENT; public static final int BLOCK_INCREMENT; public static final int TRACK; Adjustable adjustable; int value; int adjustmentType; public AdjustmentEvent(Adjustable source, int id, int type, i n t value) public Adjustable getAdjustable( ) public int getAdjustmentType( ) public int getValue( ) public String paramString( ) } Si usted quiere ocuparse de eventos de ajuste, como los eventos de barra desplazable, cree que una clase que lleva a cabo esta interfaz y sobre escriba el Valor cambiado por el método. Su objeto recibe una Instancia de AdjustmentEvent cuando un ajuste ocurre. Note que ninguna clase del adaptador correspondiente existe. public interface AdjustmentListener extends EventListener { public void adjustmentValueChanged(AdjustmentEvent e); } Si usted quiere cachar algunos eventos de componente generales, extienda esta clase y sobre escriba los métodos que le interesan. Cada uno de sus métodos recibe una Instancia de ComponentEvent que describe el evento. public abstract class ComponentAdapter implements ComponentListener { public void componentHidden(ComponentEvent e) public void componentMoved(ComponentEvent e) public void componentResized(ComponentEvent e) public void componentShown(ComponentEvent e) } Cuando un evento de componente ocurre (como el movimiento, tamaño, muestrar, y acultar), un Instancia de esta clase va a todos los Componentes Listeners y ComponentAdapters. public class ComponentEvent extends AWTEvent { public static final int COMPONENT_FIRST;

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...eeevvveeennnttt...AAAdddjjjuuussstttmmmeeennntttLLLiiisssttteeennneeerrr

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...eeevvveeennnttt...CCCooommmpppooonnneeennntttAAAdddaaapppttteeerrr

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...eeevvveeennnttt...CCCooommmpppooonnneeennntttEEEvvveeennnttt

67

public static final int COMPONENT_LAST; public static final int COMPONENT MOVED; public static final int COMPONENT_RESIZED; public static final int COMPONENT_SHOWN; public static final int COMPONENT_HIDDEN; public ComponentEvent(Component source, int id) public Component getComponent( ) public String paramString( ) } Si usted quiere cachar algunos eventos de componentes generales, como el resize y mueve, Implemente esta interfaz y sobre escriba los métodos. Su clase recibe una Instancia de ComponentEvent cuando uno de los eventos del componente ocurre. Usted tiene que sobre escribir todos los métodos en esta interfaz, aun cuando usted no hace nada con ellos. public interface ComponentListener extends EventListener { public void componentResized(ComponentEvent e); public void componentMoved(ComponentEvent e); public void componentShown(ComponentEvent e); public void componentHidden(ComponentEvent e); } ContainerAdapter se parece ComponentAdapter, pero ContainerAdapter trabaja en los contenedores, como Frame o Panel. Si usted quiere ocuparse de eventos de container, extienda esta clase y sobre escriba los métodos que le interesan. Cada uno de sus métodos recibe un Instancia de ContainerEvent que describe el evento que ocurrió. public abstract class ContainerAdapter implements ContainerListener { public void componentAdded(ContainerEvent e) public void componentRemoved(ContainerEvent e) } Una Instancia de esta clase se da a todo los ContainerListeners y ContainerAdapters cuando un Componente se agrega o quita de un Recipiente. public class ContainerEvent extends ComponentEvent { public static final int CONTAINER_FIRST; public static final int CONTAINER_LAST; public static final int COMPONENT_ADDED; public static final int COMPONENT_REMOVED; Component child; public ContainerEvent(Component source, int id, Component child) public Component getChild( ) public Container getContainer( )

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...eeevvveeennnttt...CCCooommmpppooonnneeennntttLLLiiisssttteeennneeerrr

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...eeevvveeennnttt...CCCooonnntttaaaiiinnneeerrrAAAdddaaapppttteeerrr

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...eeevvveeennnttt...CCCooonnntttaaaiiinnneeerrrEEEvvveeennnttt

68

ublic String paramString( ) } Si usted quiere saber cuando un Componente fue agregado o quitado de un Recipiente, Implemente esta interfaz y sobre escriba los métodos. Cada uno de sus métodos recibe un Instancia de ContainerEvent que describe el evento que ocurrió. public interface ContainerListener extends EventListener { public void componentAdded(ContainerEvent e); public void componentRemoved(ContainerEvent e); } FocusAdapter coge los eventos de enfoque de Componente. lf que usted quiere coger los eventos del enfoque, extienda esta clase e Implemente los métodos que le interesan. Cada uno de sus métodos recibe una Instancia de FocusEvent que describe el evento que ocurrió. public abstract class FocusAdapter implements FocusListener { public void focusGained(FocusEvent e) public void focusLost(FocusEvent e) } FocusAdapters y FocusListeners reciben una Instancia de esta clase cuando un componente gana o pierde el enfoque. public olass FocusEvent extends ComponentEvent { public static final int FOCUS_FIRST; public static final int FOCUS_LAST; public static final int FOCUS GAINED; public static final int FOCUS_LOST; boolean temporary; public FocusEvent(Component source, int id, Boolean temporary) public FocusEvent(Component source, int id) public boolean isTemporary( ) public String paramString( ) } Si usted quiere ser notificado que cuando un componente gana o pierde el enfoque, Implemente esta interfaz e Implemente sus métodos. Cada uno de sus métodos recibe un caso de FocusEvent que describe el evento que ocurrió. public interface FocusListener extends EventListener { public void focusGained(FocusEvent e); public void focusLost(FocusEvent e); }

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...eeevvveeennnttt...CCCooonnntttaaaiiinnneeerrrLLLiiisssttteeennneeerrr

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...eeevvveeennnttt...FFFooocccuuusssAAAdddaaapppttteeerrr

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...eeevvveeennnttt...FFFooocccuuusssEEEvvveeennnttt

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...eeevvveeennnttt...FFFooocccuuusssLLLiiittteeennneeerrr

69

InputEvent es el superclass de otra clase de eventos, como KeyEvent y MouseEvent. Los InputEvent clasifican los factores fuera de los modificadores importantes, como el cambio y mando. Usted probablemente no usará directamente esta clase, pero usted puede querer usar sus métodos para averiguar si el usuario estaba sujetando la tecla mayúscula cuando él o ella arrastraron el ratón, por ejemplo. public abstract class InputEvent extends ComponentEvent { public static final int SHIFT MASK; public static final int CTRL MASK; public static final int META _MASK; public static final int ALT_MASK; public static final int BUTTONI MASK; public static final int BUTTON2_MASK; public static final int BUTTON3 MASK; long when; int modifiers; public void consume( ) public int getModifiers() public long getWhen( ) InputEvent(Component source, int id, long when, int modifiers) public boolean isAltDown( ) public boolean isConsumed( ) public boolean isControlDown( ) public boolean isMetaDown( ) public boolean isShiftDown( ) } Cuando usted usa ItemEvent en su código, un Instancia de ItemEvent se pasa al ItemListener cuando un cambio de estado ocurre en un Componente. ItemEvent se apoya por componentes que mantienen el estado; una caja del cheque es un ejemplo de un Componente que mantiene un estado (en o fuera de). public class ItemEvent extends AWTEvent { public static final int ITEM_FIRST; public static final int ITEM_LAST; public static final int ITEM_STATE_CHANGED; public static final int SELECTED; public static final int DESELECTED; Object item; int stateChange; public Object getItem( ) public ItemSelectable getltemSelectable( ) public int getStateChange( ) public ItemEvent(ItemSelectable source, int id, Object item, int stateChange) public String paramString( ) }

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...eeevvveeennnttt...IIInnnpppuuutttEEEvvveeennnttt

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...eeevvveeennnttt...IIIttteeemmmEEEvvveeennnttt

70

Si usted quiere coger los eventos de cambio de estado, Implemente esta interfaz y Sobre escriba el método. Su clase recibe una Instancia de ItemEvent cuando un cambio de estado ocurre. (Un evento de cambio de estado ocurre cuando un usuario hace clic en una caja del chequeo.) Nota que no hay ningún adaptador correspondiente para esta interfaz public interface ItemListener extends EventListener { void itemStateChanged(ItemEvent e); } KeyAdapter coge los eventos importantes. Si usted quiere manejar los eventos, extienda esta clase y sobre escriba los métodos que le interesan. Cada uno de los métodos recibe un objeto de KeyEvent cuando un evento importante ocurre. public abstract class KeyAdapter implements KeyListener { public void keyPressed(KeyEvent e) public void keyReleased(KeyEvent e) public void keyTyped(KeyEvent e) } KeyEvent le dice en la vida todo lo que usted quiso saber sobre un evento importante. Puede decirle incluso cosas que usted no quiere saber. KeyAdapters y KeyListeners reciben una Instancia de KeyEvent cuando un evento importante ocurre. public class KeyEvent extends InputEvent {

public static final int KEY_FIRST; public static final int KEY_LAST; public static final int KEY TYPED; public static final int KEY_PRESSED; public static final int KEYRELEASED; public static final int VK_ENTER; public static final int VK BACK_SPACE; public static final int VK_TAB; public static final int VK_CANCEL; public static final int VK CLEAR; public static final int VK SHIFT; public static final int VK_CONTROL; public static final int VK ALT; public static final int VK_PAUSE; public static final int VK_CAPS_LOCK; public static final int VK_ESCAPE; public static final int VK_SPACE; public static final int VK_PAGE UP; public static final int VK_PAGE_DOWN; public static final int VK END;

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...eeevvveeennnttt...IIIttteeemmmLLLiiisssttteeennneeerrr

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...eeevvveeennnttt...KKKeeeyyyAAAdddaaapppttteeerrr

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...eeevvveeennnttt...KKKeeeyyyEEEvvveeennnttt

71

public static final int VK HOME; public static final int VK_LEFT; public static final int VK UP; public static final int VK_RIGHT; public static final int VK_DOWN; public static final int VK COMMA; public static final int VK_PERIOD; public static final int VK SLASH; public static final int VK_0; public static final int VK_1; public static final int VK 2; public static final int VK 3; public static final int VK_4; public static final int VK_5; public static final int VK_6; public static final int VK_7; public static final int VK 8; public static final int VK_9; public static final int VK SEMICOLON; public static final int VK_EQUALS; public static final int VK_A; public static final int VK_B; public static final int VK_C; public static final int VK D; public static final int VK_E; public static final int VK F; public static final int VK_G; public static final int VK_H; public static final int VK_I; public static final int VK_J; public static final int VK K; public static final int VK_L; public static final int VK_M; public static final int VK_N; public static final int VK_O; public static final int VK_P; public static final int VK_0; public static final int VK_R; public static final int VK_S; public static final int VK T; public static final int VK_U; public static final int VK V; public static final int VK_W; public static final int VK_X; public static final int VK Y; public static final int VK_Z; public static final int VK_OPEN_BRACKET;

72

public static final int VK_BACK SLASH; public static final int VK CLOSE_BRACKET; public static final int VK_NUMPADO; public static final int VK_NUMPAD1; public static final int VK_NUMPAD2; public static final int VK_NUMPAD3; public static final int VK_NUMPAD4; public static final int VK_NUMPADS; public static final int VK_NUMPAD6; public static final int VK_NUMPAD7; public static final int VK NUMPAD8; public static final int VK_NUMPAD9; public static final int VK_MULTIPLY; public static final int VK_ADD; public static final int VK_SEPARATER; public static final int VK SUBTRACT; public static final int VK_DECIMAL; public static final int VK DIVIDE; public static final int VK_F1; public static final int VK_F2; public static final int VK_F3; public static final int VK_F4; public static final int VK F5; public static final int VK_F6; public static final int VK_F7; public static final int VK_F8; public static final int VK F9; public static final int VK_F10; public static final int VK_F11; public static final int VK_F12; public static final int VK DELETE; public static final int VK_NUM_LOCK; public static final int VK_SCROLL_LOCK; public static final int VK_PRINTSCREEN; public static final int VK_INSERT; public static final int VK HELP; public static final int VK_META; public static final int VK BACK_QUOTE; public static final int VK_QUOTE; public static final int VK_UNDEFINED; public static final char CHAR_UNDEFINED; int keyCode; char keyChar; public char getKeyChar() public int getKeyCode() public static String getKeyModifiersText(int modifiers) public static String getKeyText(int keyCode)

73

public boolean isActionKey() public KeyEvent(Component source, int id, long when, int modifiers, int keyCode, char keyChar) public KeyEvent(Component source, int id, long when, int modifiers, int keyCode) public String paramString() public void setKeyChar(char keyChar) public void setKeyCode(int keyCode) public void setModifiers(int modifiers)

} KeyListener se habilita cuando usted quiere ocuparse de eventos importantes. Simplemente Implemente esta interfaz y sobre escriba los métodos. Cada uno de los métodos recibe una Instancia de un objeto KeyEvent cuando un evento importante ocurre. public interface KeyListener extends EventListener { public void keyTyped(KeyEvent e); public void keyPressed(KeyEvent e); public void keyReleased(KeyEvent e); } Piense en MouseAdapter como el gato de la caza de java.awt.event el paquete: MouseAdapter coge los eventos del ratón. Para ocuparse de eventos del ratón, extienda esta clase y sobre escriba los métodos que le interesan. Cada uno de estos métodos recibe una Instancia de MouseEvent cuando un evento del ratón ocurre. public abstract class MouseAdapter implements MouseListener { public void mouseClicked(MouseEvent e) public void mouseEntered(MouseEvent e) public void mouseExited(MouseEvent e) public void mousePressed(MouseEvent e) public void mouseReleased(MouseEvent e) } Esta clase contiene todos los tipos de información buena sobre un evento del ratón, incluso una cuenta de doble clics y múltiples clicspueden ser manejados facilmente Usted puede usar esta clase para verificar los multiples clics del ratón para realizar algunas tareas interesantes. Por ejemplo, si el usuario pulsa el botón cinco veces, usted puede hacer el programa que desplegacaja de dialogo "Stop Pressing My Button". public class MouseEvent extends InputEvent { public static final int MOUSE FIRST; public static final int MOUSELAST; public static final int MOUSE_CLICKED; public static final int MOUSE_PRESSED; public static final int MOUSE_RELEASED;

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...eeevvveeennnttt...KKKeeeyyyLLLiiisssttteeennneeerrrttt

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...eeevvveeennnttt...MMMooouuussseeeAAAdddaaapppttteeerrr

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...eeevvveeennnttt...MMMooouuussseeeEEEvvveeennnttt

74

public static final int MOUSE_MOVED; public static final int MOUSE_ENTERED; public static final int MOUSE_EXITED; public static final int MOUSE_DRAGGED; int x; int y; int clickCount; boolean popupTrigger; public int getClickCount( ) public Point getPoint( ) public int getX( ) public int getY( ) public boolean isPopupTrigger( ) public MouseEvent(Component source, int id, long when, int modifiers, int x, int y, int clickCount, boolean popupTrigger) public String paramString( ) public synchronized void translatePoint(int x, int y) } MouseListener le ayuda a manejar eventos del ratón. Si Implementa esta interfaz y Implementa los métodos, cada uno de estos métodos recibe una Instancia de MouseEvent cuando un evento del ratón ocurre. public interface MouseListener extends EventListener { public void mouseClicked(MouseEvent e); public void mousePressed(MouseEvent e); public void mouseReleased(MouseEvent e); public void mouseEntered(MouseEvent e); public void mouseExited(MouseEvent e); } Este adaptador coge los movimientos y arrastres del ratón. Si usted quiere manejar estos eventos, extienda esta clase e Implemente los métodos que le interesan. Cada uno de los métodos recibe una Instancia de MouseEvent que describe el evento en detalle. public abstract class MouseMotionAdapter implements MouseMotionListener { public void mouseDragged(MouseEvent e) public void mouseMoved(MouseEvent e) } Si usted quiere manejar eventos y errastre y movimientos del ratón, Implemente esta interfaz y sobre escriba los métodos. Cada uno de sus métodos recibe una Instancia de MouseEvent que describe el evento en detalle. public interface MouseMotionListener extends EventListener {

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...eeevvveeennnttt...MMMooouuussseeeLLLiiisssttteeennneeerrr

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...eeevvveeennnttt...MMMooouuussseeeMMMoootttiiiooonnnAAAdddaaapppttteeerrr

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...eeevvveeennnttt...MMMooouuussseeeMMMoootttiiiooonnnLLLiiisssttteeennneeerrr

75

public void mouseDragged(MouseEvent e); public void mouseMoved(MouseEvent e); } PaintEvent contiene la información sobre los eventos de paint, el más importante de los destinos Graficos es el objeto grphics g. public class PaintEvent extends ComponentEvent { public static final int PAINT_FIRST; public static final int PAINT_LAST; public static final int PAINT; public static final int UPDATE; Graphics g; public Graphics getGraphics( ) public PaintEvent(Component source, int id, Graphics g) public String paramString( ) } Esta clase contiene la información sobre los eventos del componente de texto. TextEvent se entrega a TextLiStenerS cuando un evento del texto ocurre, como una accion importante en un campo del texto. public class TextEvent extends AWTEvent { public static final int TEXT FIRST; public static final int TEXTLAST; public static final int TEXT_VALUE_CHANGED; public String paramString( ) public TextEvent(Object source, int id) } Si usted quiere averiguar si algo en un TextComponent ha cambiado, Implemente esta interfaz y ha sobre escriba el método. Su método recibe una Instancia de TextEvent cuando un evento del texto ocurre. public interface TextListener extends EventListener { public void textValueChanged(TextEvent e); } La clase coge los eventos de la ventana, como active o iconify. Si usted quiere manejar eventos como éstos, extienda esta clase y sobre escriba los métodos que le interesan. Cada uno de sus métodos recibe una Instancia de WindowEvent que contiene la información detallada sobre el evento. Cuando usted crea una aplicación Java, usted debe crear a un manejador de eventos para manejar el cerrando de la ventana, el evento destruye ventana, y terminacion de la aplicación. Si usted no crea a un manejador de eventos para estos eventos, la aplicación no se termianra cuando el usuario intenta cerrar la ventana.

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...eeevvveeennnttt...PPPoooiiinnntttEEEvvveeennnttt

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...eeevvveeennnttt...TTTeeexxxtttEEEvvveeennnttt

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...eeevvveeennnttt...TTTeeexxxtttLLLiiisssttteeennneeerrr

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...eeevvveeennnttt...WWWiiinnndddooowwwAAAdddaaapppttteeerrr

76

public abstract class WindowAdapter implements WindowListener { public void windowActivated(WindowEvent e) public void windowClosed(WindowEvent e) public void windowClosing(WindowEvent e) public void windowDeactivated(WindowEvent e) public void windowDeiconified(WindowEvent e) public void windowIconified(WindowEvent e) public void windowOpened(WindowEvent e) } WindowEvent proporciona la información útil a WindowAdapters y WindowListeners cuando un evento de la ventana ocurre. public class WindowEvent extends ComponentEvent { public static final int WINDOW_FIRST; public static final int WINDOW_LAST; public static final int WINDOW_OPENED; public static final int WINDOW CLOSING; public static final int WINDOW CLOSED; public static final int WINDOWICONIFIED; public static final int WINDOW DEICONIFIED; public static final int WINDOW_ACTIVATED; public static final int WINDOW_DEACTIVATED; public Window getWindow( ) public String paramString( ) public WindowEvent(Window source, int id) } Para manejar eventos de ventana, como cierre o iconify, Implemente esta interfaz y sobre escriba todos los métodos. Cada uno de sus métodos recibe una Instancia de WindowEvent que contiene la información detallada sobre el evento. public interface WindowListener extends EventListener { public void windowopened(WindowEvent e); public void windowClosing(WindowEvent e); public void windowClosed(WindowEvent e); public void windowlconified(WindowEvent e); public void windowDeiconified(WindowEvent e); public void windowActivated(WindowEvent e); public void windowDeactivated(WindowEvent e); }

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...eeevvveeennnttt...WWWiiinnndddooowwwEEEvvveeennnttt

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...eeevvveeennnttt...WWWiiinnndddooowwwLLLiiisssttteeennneeerrr

77

PPPAAACCCKKKAAAGGGEEE

JJJaaavvvaaa...aaawwwttt...IIImmmaaagggeee

El paquete java.awt.image contiene varias clases para el

manejo de imagenes y su procesamiento. Si usted quiere que todas las imagenes sean cargadas y

desplegar estas, no se preocupe por este paquete. El paquete se usa por el resto de awt y applet, pero puede ser transparente (perdón por el juego de palabras) a usted. Nosotros sabemos que usted ha estado investigando para conseguir una Ilustracion de la jerarquía de clases del paquete java.awt.image, sin la dificultad extensa, se la presento a usted en la figura siguiente:

Las conexiones de la red lentas complican el manejo de imágenes. Los diseñadores de Sun Microsystems crearon productores y consumidores para que las imágenes se transmitan asincrónicamente. Eso significa que usted no tiene que esperar por su applet para simplemente continuar porque contiene muchas imágenes (como el Duque Dando volteretas). Esto nos trae al asunto de productores de la imagen, observadores, y consumidores. Un productor de la imagen entrega una imagen; un consumidor recibe una imagen; y un observador realizan la observasion de los productores y consumidores. Los detalles de estas clases pueden ponerse bastante pesados, estudie las clases dedicadamente si usted planea usarlos. AreaAveragingScaleFilter es un ImageFilter que usted usa junto con FilteredImageSource para descascarar las imágenes. Cuando usted descascara las imágenes a, se reproducen los pixeles, y cuando usted reduce las imágenes, se promedian los pixeles. Esta clase es muy similar a ReplicateScaleFilter, sólo que AreaAveragingScaleFilter consigue los pixeles en orden para mirear bien la escala. public class AreaAveragingScaleFilter extends ReplicateScaleFilter { ColorModel model, Object pixels, int off, int scansize)

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...IIImmmaaagggeee...AAArrreeeaaaAAAvvveeerrraaagggiiinnngggSSScccaaallleeeFFFiiilllttteeerrr

78

public AverageScaleFilter(int width, int height) private int[] calcRow( ) private void makeAccumBuffers( ) public void setHints(int hints) public void setPixels(int x, int y, int w, int h, ColorModel model, byte pixels[], int off, int scansize) public void setPixels(int x, int y, int w, int h, ColorModel model, int pixels[], int off, int scansize) } Esta clase define un modelo de color. ColorModel es abstracto, pero usted no puede crear una Instancia directamente de el. Otras clases en este paquete; use ColorModel. public abstract class ColorModel { protected int pixel bits; public abstract int getRed(int pixel); public abstract int getGreen(int pixel); public abstract int getBlue(int pixel); public abstract int getAlpha(int pixel); public ColorModel(int bits) public void finalize( ) public int getPixelSize( ) public int getRGB(int pixel) public static ColorModel getRGBdefault( ) } CropImageFilter es un filtro de imagen que asigna a una imagen un tamaño particular. Usted puede aplicar este filtro si usted quiere conseguir un subconjunto de una imagen. public class CroplmageFilter extends ImageFilter { int cropX; int cropY; int cropW; int cropH; public CroplmageFilter(int x, int y, int w, int h) public void setDimensions(int w, int h) public void setPixels(int x, int y, int w, int h, ColorModel model, byte pixels[], int off, int scansize) public void setPixels(int x, int y, int w, int h. ColorModel model, int pixels[], int off, int scansize) public void setProperties(Hashtable props) } Este modelo mapea ejemplares de color plano rojo, verde, azul, y el alfa directamente. public class DirectColorModel extends ColorModel { public DirectColorModel(int bits, int rmask, int gmask, int bmask) public DirectColorModel(int bits, int rmask, int gmask, int bmask, int amask)

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...IIImmmaaagggeee...CCCooolllooorrrMMMooodddeeelll

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...IIImmmaaagggeee...CCCrrrooopppIIImmmaaagggeeeFFFiiilllttteeerrr

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...IIImmmaaagggeee...DDDiiirrreeeccctttCCCooolllooorrrMMMooodddeeelll

79

final public int getAlpha(int pixel) final public int getAlphaMask( ) final public int getBlue(int pixel) final public int getBlueMask( ) final public int getGreen(int pixel) final public int getGreenMask( ) final public int getRed(int pixel) final public int getRedMask( ) final public int getRGB(int pixel) } Use esta clase cuando usted quiere filtrar una imagen antes de que se use. Usted puede querer ajustar algunos de los colores, por ejemplo. FilteredImageSource trabaja con el productor de la imagen y un filtro de la imagen. public class FilteredlmageSource implements ImageProducer { ImageProducer src; ImageFilter filter; public synchronized void addConsumer(ImageConsumer ic) public FilteredlmageSource(ImageProducer orig, ImageFilter imgf) public synchronized boolean isConsumer(ImageConsumer ic) public synchronized void removeConsumer(ImageConsumer ic) public void requestTopDownLeftRightResend(ImageConsumer ic) public void startProduction(ImageConsumer ic) } Esta interfaz describe los métodos requeridos por un consumidor de la imagen. public interface ImageConsumer { void setDimensions(int width, int height); void setProperties(Hashtable props); void setColorModel(ColorModel model); void setHints(int hintflags); int RANDOMPIXELORDER; int TOPDOWNLEFTRIGHT; int COMPLETESCANLINES; int SINGLEPASS; int SINGLEFRAME; void setPixels(int x, int y, int w, int h, ColorModel modela byte pixels[], int off, int scansize); void setPixels(int x, int y, int w, int h, ColorModel model, int pixels[], int off, int scansize); void imageComplete(int status); int IMAGEERROR; int SINGLEFRAMEDONE; int STATICIMAGEDONE; int IMAGEABORTED; }

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...IIImmmaaagggeee...FFFiiilllttteeerrreeedddIIImmmaaagggeeeSSSooouuurrrccceee

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...IIImmmaaagggeee...IIImmmaaagggeeeCCCooonnnsssuuummmeeerrr

80

Esta clase trabaja con FilteredImageSource para filtrar una imagen antes de que se use. Éste es la superclase de todos los filtros de la imagen; no hace ninguna filtración solo. Si usted quiere definir su propio filtro de la imagen, extiende esta clase e Implemente los métodos de interés. public class ImageFilter implements ImageConsumer, Cloneable { protected ImageConsumer consumer; public Object clone() public ImageFilter getFilterlnstance(ImageConsumer ic) public void imageComplete(int status) public void resendTopDownLeftRight(ImageProducer ip) public void setColorModel(ColorModel model) public void setDimensions(int width, int height) public void setHints(int hints) public void setPixels(int x, int y, int w, int h, ColorModel model, byte pixels[], int off, int scansize) public void setPixels(int x, int y, int w, int h, ColorModel model, int pixels[], int off, int scansize) public void setProperties(Hashtable props) } Esta interfaz es usada por clases que reciben las imágenes y para obtener la información sobre la producción de la imagen. Graphics.drawImage() usa esta interfaz para determinar si la imagen se ha entregado totalmente. public interface ImageObserver { public boolean imageUpdate(Image img, int infoflags, int x, int y, int width, int height); public static final int WIDTH; public static final int HEIGHT; public static final int PROPERTIES; public static final int SOMEBITS; public static final int FRAMEBITS; public static final int ALLBITS; public static final int ERROR; public static final int ABORT; } Esta clase abstracta define a un productor de imagen. El productor debe ser extendido por otras clases para ser útiles. public interface ImageProducer { public void addConsumer(ImageConsumer ic); public boolean isConsumer(ImageConsumer ic); public void removeConsumer(ImageConsumer ic); public void startProduction(ImageConsumer ic); public void requestTopDownLeftRightResend(ImageConsumer ic); }

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...IIImmmaaagggeee...IIImmmaaagggeeeFFFiiilllttteeerrr

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...IIImmmaaagggeee...IIImmmaaagggeeeOOObbbssseeerrrvvveeerrr

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...IIImmmaaagggeee...PPPrrroooddduuuccceeerrr

81

Use esta clase para mapear los colores con array fijos public class IndexColorModel extends ColorModel { final public int getAlpha(int pixel) final public void getAlphas(byte a[]) final public int getBlue(int pixel) final public void getBlues(byte b[]) final public int getGreen(int pixel) final public void getGreens(byte g[]) final public int getMapSize() final public int getRed(int pixel) final public void getReds(byte r[]) final public int getRGB(int pixel) final public int getTransparentPixel() public IndexColorModel(int bits, int size, byte r[], byte g[], byte b[]) public IndexColorModel(int bits, int size, byte r[], byte g[], byte b[], int trans) public IndexColorModel(int bits, int size, byte r[], byte g[], byte b[], byte a[]) public IndexColorModel(int bits, int size, byte cmap[], int start, boolean hasalpha) public IndexColorModel(int bits, int size, byte cmap[], int start, boolean hasalpha, int trans) } Este productor de la imagen puede crear una imagen de una serie de pixeles en la memoria. Usted puede usar esta clase para crear sus propias imágenes para la animación o construir una clase que puede leer las imágenes guardadas en un formato propietario. public class MemorylmageSource implements ImageProducer { int width; int height; ColorModel model; Object pixels; int pixeloffset; int pixelscan; Hashtable properties; Vector theConsumers; boolean animating; boolean fullbuffers; public synchronized void addConsumer(ImageConsumer ic) public synchronized boolean isConsumer(ImageConsumer ic) public MemorylmageSource(int w, int h, ColorModel cm, byte[] pix, int off, int scan) public MemorylmageSource(int w, int h, ColorModel cm, byte[] pix, int off, int scan, Hashtable props) public MemorylmageSource(int w, int h, ColorModel cm, int[] pix, int off, int scan) public MemorylmageSource(int w, int h, ColorModel cm, int[] pix, int off, int scan, Hashtable props) public MemorylmageSource(int w, int h, int pix[1, int off, int scan) public MemorylmageSource(int w, int h, int pix[1, int off, int scan, Hashtable props) public void newPixels( )

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...IIImmmaaagggeee...IIInnndddeeexxxCCCooolllooorrrMMMooodddeeelll

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...IIImmmaaagggeee...MMMeeemmmooorrryyyIIImmmaaagggeeeSSSooouuurrrccceee

82

public synchronized void newPixels(int x, int y, int w, int h) public synchronized void newPixels(int x, int y, int w, int h, boolean framenotify) public synchronized void newPixels(byte[] newpix, ColorModel newmodel, int offset, int scansize) public synchronized void newPixels(int[1 newpix, ColorModel newmodel, int offset, int scansize) public synchronized void removeConsumer(ImageConsumer ic) public void requestTopDownLeftRightResend(ImageConsumer ic) public synchronized void setAnimated(boolean animated) public synchronized void setFullBufferUpdates(Boolean fullbuffers) public void startProduction(ImageConsumer ic) } ¡Aférrese a sus pixeles - aquí viene PixelGrabber! Esta clase pequeña mala hace lo contrario de MemoryImageSource.PixelGrabber toma un objeto imagen y produce una serie de valores del pixel. public class PixelGrabber implements ImageConsumer { ImageProducer producer; int dstX; int dstY; int dstW; int dstH; ColorModel imageModel; byte[] bytePixels; int[] intPixels; int dstOff; int dstScan; public synchronized void abortGrabbing() public synchronized ColorModel getColorModel() public synchronized int getHeight() public synchronized Object getPixels( ) public synchronized int getStatus() public synchronized int getWidth() public boolean grabPixels() throws InterruptedException public synchronized boolean grabPixels(long ms) throws InterruptedExceptios public synchronized void imageComplete(int status) public PixelGrabber(Image img, int x, int y, int w, int h, int[] pix, int off, int scansize) public PixelGrabber(ImageProducer ip, int x, int y, int w, int h, int[] pix, int off, int scansize) public PixelGrabber(Image img, int x, int y, int w, int h, boolean forceRGB) public void setColorModel(ColorModel model) public void setDimensions(int width, int height) public void setHints(int hints) public void setPixels(int srcX, int srcY, int srcW, int srcH, ColorModel model, byte pixels[], int srcOff, int srcScan) public void setPixels(int srcX, int srcY, int srcW, int srcH, ColorModel model, int pixeis[], int srcOff, int srcScan) public void setProperties(Hashtable props) public synchronized void startGrabbing() public synchronized int status() }

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...IIImmmaaagggeee...PPPiiixxxeeelllGGGrrraaabbbbbbeeerrr

83

RGBImageFilter, un filtro de imagen, puede modificar valores de pixel usando una Instancia de método en lugar de una serie fija. Si usted quiere filtrar una imagen que usa alguna función arbitraria, extiende esta clase y sobre escriba el metodo filterRGB(). Su método sera llamado por cada pixel eso es efectuado por un ImageProducer public abstract class RGBImageFilter extends ImageFilter { protected ColorModel origmodel; protected ColorModel newmodel; protected boolean canFilterlndexColorModel; public abstract int filterRGB(int x, int y, int rgb); public IndexColorModel filterIndexColorModel(IndexColorModel icm) public void filterRGBPixels(int x, int y, int w, int h, int pixels[], int off, int scansize) public void setColorModel(ColorModel model) public void setPixels(int x, int y, int w, int h, ColorModel model, byte pixels[], int off, int scansize) public void setPixels(int x, int y, int w, int h, ColorModel model, int pixeis[], int off, int scansize) public void substituteColorModel(ColorModel oldcm, ColorModel newcm) } ReplicateScaleFilter, un filtro de imagen, trabaja junto con FilteredImageSource para descascarar las imágenes. Cuando usted escala las imágenes, se reproducen los pixeles. Cuando usted reduce las imágenes, se promedian los pixeis. public class ReplicateScaleFilter extends ImageFilter { protected int srcWidth; protected int srcHeight; protected int destWidth; protected int destHeight; protected int srcrows[]; protected int srccols[]; protected Object outpixbuf; private void calculateMaps() public ReplicateScaleFilter(int width, int height) public void setDimensions(int w, int h) public void setPixels(int x, int y, int w, int h, ColorModel model, byte pixeis[], int off, int scansize) public void setPixels(int x, int y, int w, int h, ColorModel model, int pixeis[], int off, int scansize) public void setProperties(Hashtable props) }

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...IIImmmaaagggeee...RRRGGGBBBIIImmmaaagggeeeFFFiiilllttteeerrr

CCCLLLAAASSSSSS JJJaaavvvaaa...aaawwwttt...IIImmmaaagggeee...RRReeepppllliiicccaaattteeeSSScccaaallleeeFFFiiilllttteeerrr