tesis_uam/Para programadores/Manual completo de ... - Grupo CEDIP

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
1

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
2

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
3

MARCO TEORIICO
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.
4

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
5

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
IINTODUCCIION A JJAVA
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
6

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.
7

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.
8

CARACTERIISSTIICASS DE JJAVA
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
9

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
10

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.
11

API S 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.
12

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.
13

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.
CLASSSS
Appppl leet t
PACKAGE java.applet
public class Applet extends Panel {
//metodos de instancia
public void destroy()
public AppletContext getAppletContext()
public String getAppletInfo()
public AudioClip getAudioClip(URL url)
14

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()
}
Método destroy()
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
}
Método getAppletContext()
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.");}
Método getAppletInfo
Sinatxis: public String getAppletInfo()
15

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");
}
Método getAudioClip(URL url)
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");}
Método getAudioClip(URL url, String name)
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();
Método getCodeBase()
Sintaxis: public URL getCodeBase()
Descripsion: Despliega una cadena que representa el directorio en el cual el applet esta contenido.
Image getImage(URL url)
Método getDocumentBase()
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)
Método getImage(URL url)
Sinatxis: puclic Image getImage(URL url)
16

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");}
Método getImage(URL url, String name)
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");
METODO getParameter(String name)
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"); }
METODO getParameterInfo()
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);
}
17

Método init()
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");
}
Método isActive()
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.");}
IINTERFFACE
Appppl leet tCoonnt teexxt t
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);
18

public void showDocument(URL url, String target);
void showStatus(String status);
}
IINTERFFACE
Appppl leet tSSt tuubb
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( );
}
IINTERFFACE
Auuddi iooCl li ipp 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( );
}
PPACKAGE JJAVA. .AWT
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.
19

CLASSSS
AWTEvveennt t
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;
21

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( )
}
CLASSSS
AWTEvveennt tMuul lt ti iccaasst teerr
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)
22

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)
}
CLASSSS JJaavvaa. ..aawt t. ..Addj juusst taabbl lee
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( );
23

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);
}
CLASSSS JJaavvaa. ..aawt t. ..BoorrddeerrLaayyoouut t
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)
24

public void setHgap(int hgap)
public void setVgap(int vgap)
public String toString( )
}
CLASSSS JJaavvaa. ..aawt t. ..Buut tt toonn
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)
}
CLASSSS JJaavvaa. .aawt t. ..Caannvvaass
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( )
}
25

CLASSSS JJaavvaa. .aawt t. .CaarrddLaayyoouut t
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( )
}
CLASSSS JJaavvaa. ..aawt t. ..Chheecckkbbooxx
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;
26

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)
}
CLASSSS JJaavvaa. .aawt t. .ChheecckkbbooxxGrroouupp
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()
}
CLASSSS JJaavvaa. ..aawt t. ..ChheecckkbbooxxMeennuuIIt teem
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)
27

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)
}
CLASSSS JJaavvaa. .aawt t. .Chhooi iccee
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)
}
28

CLASSSS JJaavvaa. ..aawt t. ..Cool loorr
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( )
}
29

CLASSSS JJaavvaa. ..aawt t. ..Coomppoonneennt t
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)
30

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( )
31

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)
32

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( )
}
CLASSSS JJaavvaa. ..aawt t. ..Coonnt taai inneerr
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)
33

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( )
34

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
}
CLASSSS JJaavvaa. .aawt t. ..Cuurrssoorr
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( )
}
CLASSSS JJaavvaa. ..aawt t. ..Di iaal loogg
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;
35

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( )
}
CLASSSS JJaavvaa. .aawt t. ..Di imeennssi ioonn
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( )
}
CLASSSS JJaavvaa. ..aawt t. ..Evveennt t
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;
36

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;
37

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)
}
CLASSSS JJaavvaa. ..aawt t. ..Evveennt tDi issppaat tcchhThhrreeaadd
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( )
}
38

CLASSSS JJaavvaa. .aawt t. .Evveennt tQuueeuuee
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)
}
CLASSSS JJaavvaa. ..aawt t. ..FFi il leeDi iaal loogg
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)
}
CLASSSS JJaavvaa. .aawt t. .FFl loowLaayyoouut t
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.
39

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)
}
CLASSSS JJaavvaa. .aawt t. .FFoonnt t
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
}
40

CLASSSS JJaavvaa. .aawt t. .FFoonnt tMeet trri iccss
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
}
CLASSSS JJaavvaa. ..aawt t. ..FFrraamee
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;
41

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)
}
CLASSSS JJaavvaa. ..aawt t. ..Grraapphhi iccss
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);
42

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( );
43

public abstract void setXORMode(Color cl);
public String toString( )
public abstract void translate(int x, int y);
}
CLASSSS JJaavvaa. ..aawt t. ..Grri iddBaaggCoonnsst trraai innt tss
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()
}
CLASSSS JJaavvaa. .aawt t. .Grri iddBaaggLaayyoouut tIInnf foo
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[];
44

int minHeight[];
double weightX[];
double weightY[];
GridBagLayoutlnfo( )
}
CLASSSS JJaavvaa. .aawt t. .Grri iddBaaggLaayyoouut t
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( )
}
45

CLASSSS JJaavvaa. ..aawt t. ..Grri iddLaayyoouut t
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( )
}
CLASSSS JJaavvaa. ..aawt t. .IImaaggee
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); }
46

CLASSSS JJaavvaa. ..aawt t. ..IInnsseet tss
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( )
}
CLASSSS JJaavvaa. ..aawt t. .IIt teemSSeel leecct taabbl lee
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);
}
CLASSSS JJaavvaa. .aawt t. .Laabbeel l
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)
}
47

CLASSSS JJaavvaa. ..aawt t. ..Laayyoouut tMaannaaggeerr
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);
}
CLASSSS JJaavvaa. .aawt t. .Laayyoouut tMaannaaggeerr22
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);
}
CLASSSS JJaavvaa. ..aawt t. ..Li isst t
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)
48

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)
49

private void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException
}
CLASSSS JJaavvaa. ..aawt t. ..Meeddi iaaTrraacckkeerr
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
}
50

CLASSSS JJaavvaa. ..aawt t. ..Meennuu
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( )
}
CLASSSS JJaavvaa. .aawt t. .MeennuuBaarr
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( )
51

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( )
}
CLASSSS JJaavvaa. .aawt t. .MeennuuCoomppoonneennt t
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( )
}
CLASSSS JJaavvaa. ..aawt t. ..MeennuuCoonnt taai inneerr
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);
}
52

CLASSSS JJaavvaa. .aawt t. .MeennuuIIt teem
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)
}
CLASSSS JJaavvaa. ..aawt t. ..MeennuuSShhoorrt tccuut t
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( )
53

protected String paramString( )
public String toString( )
public boolean usesShiftModifier( )
}
CLASSSS JJaavvaa. ..aawt t. ..PPaanneel l
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)
}
CLASSSS JJaavvaa. .aawt t. .PPooi innt t
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)
}
CLASSSS JJaavvaa. ..aawt t. ..PPool lyyggoonn
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[];
54

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)
}
CLASSSS JJaavvaa. .aawt t. .PPooppuuppMeennuu
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)
}
CLASSSS JJaavvaa. ..aawt t. ..PPrri innt tGrraapphhi iccss
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( );
}
CLASSSS JJaavvaa. .aawt t. .PPrri innt tJJoobb
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( );
}
55

CLASSSS JJaavvaa. ..aawt t. ..Reecct taannggl lee
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)
}
CLASSSS JJaavvaa. ..aawt t. ..SSccrrool ll lPPaannee
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.
56

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)
}
CLASSSS JJaavvaa. ..aawt t. ..SSccrrool ll lbbaarr
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( )
57

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)
}
CLASSSS JJaavvaa. .aawt t. .SShhaappee
Shape es una interfaz usada por algunas de las clases gráficos-relacionadas.
public interface Shape {
public Rectangle getBounds( );
}
CLASSSS JJaavvaa. ..aawt t. ..SSyysst teemCool loorr
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;
58

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;
}
59

CLASSSS JJaavvaa. .aawt t. .Teexxt tArreeaa
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)
}
CLASSSS JJaavvaa. ..aawt t. ..Teexxt tCoomppoonneennt t
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.
60

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)
}
CLASSSS JJaavvaa. .aawt t. .Teexxt tFFi ieel ldd
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)
61

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)
}
CLASSSS JJaavvaa. ..aawt t. ..Tooool lkki it t
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);
62

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( );
}
CLASSSS JJaavvaa. ..aawt t. ..Wi innddoow
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( )
63

void transferFocus(Component base)
Window( )
public Window(Frame parent)
}
PPACKAGE
Las clases e interfaces en el pakete java.awt.event
JJaavvaa. .aawt t. .eevveennt t
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
64

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.
CLASSSS JJaavvaa. .aawt t. .eevveennt t. .Acct ti ioonnEvveennt t
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( )
}
CLASSSS JJaavvaa. ..aawt t. .eevveennt t. .Acct ti ioonnLi isst teenneerr
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);
}
CLASSSS JJaavvaa. .aawt t. .eevveennt t. .Addj juusst tmeennt tEvveennt t
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 {
65

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( )
}
CLASSSS JJaavvaa. ..aawt t. .eevveennt t. .Addj juusst tmeennt tLi isst teenneerr
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);
}
CLASSSS JJaavvaa. ..aawt t. ..eevveennt t. ..Coomppoonneennt tAddaappt teerr
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)
}
CLASSSS JJaavvaa. ..aawt t. ..eevveennt t. .Coomppoonneennt tEvveennt t
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;
66

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( )
}
CLASSSS JJaavvaa. ..aawt t. ..eevveennt t. ..Coomppoonneennt tLi isst teenneerr
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);
}
CLASSSS JJaavvaa. .aawt t. .eevveennt t. .Coonnt taai inneerrAddaappt teerr
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)
}
CLASSSS JJaavvaa. .aawt t. .eevveennt t. .Coonnt taai inneerrEvveennt t
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( )
67

ublic String paramString( )
}
CLASSSS JJaavvaa. .aawt t. .eevveennt t. .Coonnt taai inneerrLi isst teenneerr
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);
}
CLASSSS JJaavvaa. .aawt t. .eevveennt t. .FFooccuussAddaappt teerr
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)
}
CLASSSS JJaavvaa. .aawt t. .eevveennt t. ..FFooccuussEvveennt t
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( )
}
CLASSSS JJaavvaa. .aawt t. .eevveennt t. .FFooccuussLi it teenneerr
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); }
68

CLASSSS JJaavvaa. ..aawt t. .eevveennt t. .IInnppuut tEvveennt t
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( )
}
CLASSSS JJaavvaa. .aawt t. .eevveennt t. .IIt teemEvveennt t
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( )
}
69

CLASSSS JJaavvaa. ..aawt t. ..eevveennt t. ..IIt teemLi isst teenneerr
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);
}
CLASSSS JJaavvaa. .aawt t. .eevveennt t. .KeeyyAddaappt teerr
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)
}
CLASSSS JJaavvaa. .aawt t. .eevveennt t. .KeeyyEvveennt t
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;
70

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;
71

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)
72

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)
}
CLASSSS JJaavvaa. ..aawt t. ..eevveennt t. .KeeyyLi isst teenneerrt t
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);
}
CLASSSS JJaavvaa. ..aawt t. .eevveennt t. .MoouusseeAddaappt teerr
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)
}
CLASSSS JJaavvaa. .aawt t. .eevveennt t. .MoouusseeEvveennt t
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;
73

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)
}
CLASSSS JJaavvaa. ..aawt t. .eevveennt t. .MoouusseeLi isst teenneerr
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);
}
CLASSSS JJaavvaa. .aawt t. .eevveennt t. ..MoouusseeMoot ti ioonnAddaappt teerr
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)
}
CLASSSS JJaavvaa. .aawt t. .eevveennt t. ..MoouusseeMoot ti ioonnLi isst teenneerr
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 {
74

public void mouseDragged(MouseEvent e);
public void mouseMoved(MouseEvent e);
}
CLASSSS JJaavvaa. ..aawt t. ..eevveennt t. ..PPooi innt tEvveennt t
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( )
}
CLASSSS JJaavvaa. ..aawt t. ..eevveennt t. ..Teexxt tEvveennt t
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)
}
CLASSSS JJaavvaa. ..aawt t. ..eevveennt t. ..Teexxt tLi isst teenneerr
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);
}
CLASSSS JJaavvaa. .aawt t. .eevveennt t. .Wi innddoowAddaappt teerr
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.
75

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)
}
CLASSSS JJaavvaa. .aawt t. .eevveennt t. .Wi innddoowEvveennt t
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)
}
CLASSSS JJaavvaa. .aawt t. .eevveennt t. .Wi innddoowLi isst teenneerr
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);
}
76

El paquete java.awt.image contiene varias clases para el
PPACKAGE
manejo de imagenes y su procesamiento. Si usted
JJaavvaa. .aawt t. .IImaaggee
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.
CLASSSS JJaavvaa. ..aawt t. ..IImaaggee. ..ArreeaaAvveerraaggi innggSSccaal leeFFi il lt teerr
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)
77

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)
}
CLASSSS JJaavvaa. ..aawt t. ..IImaaggee. ..Cool loorrMooddeel l
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( )
}
CLASSSS JJaavvaa. .aawt t. ..IImaaggee. ..CrrooppIImaaggeeFFi il lt teerr
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)
}
CLASSSS JJaavvaa. ..aawt t. ..IImaaggee. ..Di irreecct tCool loorrMooddeel l
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)
78

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)
}
CLASSSS JJaavvaa. ..aawt t. .IImaaggee. .FFi il lt teerreeddIImaaggeeSSoouurrccee
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)
}
CLASSSS JJaavvaa. ..aawt t. .IImaaggee. .IImaaggeeCoonnssuumeerr
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;
}
79

CLASSSS JJaavvaa. .aawt t. .IImaaggee. .IImaaggeeFFi il lt teerr
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)
}
CLASSSS JJaavvaa. ..aawt t. ..IImaaggee. ..IImaaggeeObbsseerrvveerr
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;
}
CLASSSS JJaavvaa. ..aawt t. ..IImaaggee. ..PPrroodduucceerr
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);
}
80

CLASSSS JJaavvaa. .aawt t. .IImaaggee. .IInnddeexxCool loorrMooddeel l
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)
}
CLASSSS JJaavvaa. ..aawt t. ..IImaaggee. ..MeemoorryyIImaaggeeSSoouurrccee
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( )
81

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)
}
CLASSSS JJaavvaa. ..aawt t. ..IImaaggee. ..PPi ixxeel lGrraabbbbeerr
¡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() }
82

CLASSSS JJaavvaa. .aawt t. .IImaaggee. .RGBIImaaggeeFFi il lt teerr
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)
}
CLASSSS JJaavvaa. ..aawt t. .IImaaggee. .Reeppl li iccaat teeSSccaal leeFFi il lt teerr
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)
}
83