TRADUCCION DE LIBRERIAS DE JAVA

LIBRERÍA NUMERO 1
Package java.applet
Proporciona las clases necesarias para crear un applet y las clases que usa un applet para
comunicarse con su contexto de applet.
El marco del applet involucra dos entidades: el applet y el contexto del applet. Un applet es
una ventana incrustable (vea la clase Panel) con algunos métodos adicionales que el
contexto del applet puede usar para inicializar, iniciar y detener el applet.

El contexto de applet es una aplicación que se encarga de cargar y ejecutar applets. Por
ejemplo, el contexto del applet podría ser un navegador web o un entorno de desarrollo de
applets.

Resumen de interfaz
AppletContext
Esta interfaz corresponde al entorno de un applet: el documento que contiene el applet y los
otros applets en el mismo documento.
AppletStub
Cuando se crea un applet por primera vez, se le agrega un apéndice de applet usando el
método setStub del applet.
Segmento de audio
La interfaz AudioClip es una simple abstracción para reproducir un clip de sonido.

Resumen de clase
Applet
Un applet es un programa pequeño que no debe ejecutarse solo, sino que debe integrarse
dentro de otra aplicación.

El código que aparece a continuación muestra la implementación en Java del programa que
muestra en la ventana principal del navegador la frase ``Hola Mundo en Java":
/**
* Applet Hello World
*/
import java.applet.Applet;
import java.awt.Graphics;

public class AppletSimple extends Applet{

public void paint(Graphics g){
g.drawString("Hola Mundo en Java", 50, 25);
}
}

LIBRERÍA NUMERO 2
Package java.awt

Clases de AWT
Error al crear miniatura: Falta archivo
Jerarquía de clases de AWT
Este paquete viene incluido en la API de Java como java.awt ya desde su primera versión, con lo
que las interfaces generadas con esta biblioteca funcionan en todos los entornos Java disponibles
(incluyendo navegadores, lo que les hace especialmente eficientes para la creación de applets Java).
Component: Esta clase representa a cualquier objeto que puede ser parte de una interfaz gráfica de
usuario. Es la clase padre de muchas de las clases del AWT.
Su propósito principal es representar algo que tiene una posición y un tamaño, que puede ser
dibujado en la pantalla y que pueda recibir eventos de entrada (que responda a las interacciones con
el usuario).
Container: La clase Container sabe cómo mostrar componentes embebidos (que a su vez pueden ser
instancias de la clase Container).
Estos objetos Container tienen un LayoutManager asociado que define la manera en que van a
posicionarse los objetos componentes en su interior.

LayoutManager y LayoutManager2: son dos interfaces encargadas de la representación y

posicionamiento en pantalla de componentes AWT.
Otras clases: Por supuesto AWT no se limita a estas clases. Dentro de esta biblioteca podemos
encontrar multitud de clases prefabricadas para facilitar el diseño gráfico.
Clase Component
Su propósito principal es representar algo que tiene una posición y un tamaño, que puede ser
dibujado en la pantalla y que pueda recibir eventos de entrada (que responda a las interacciones con
el usuario).

La clase Component presenta diversos métodos, organizados para cubrir varios propósitos.

A continuación, se explican algunos de ellos.

Tamaño y posición del componente

Dimension getSize(); Devuelve la anchura y altura del componente como un objeto de la clase
Dimension, que tiene como campos: width (anchura) y heigth (altura).
void setSize(int ancho, int largo); Establece la anchura y altura del componente.
Dimension getPreferredSize(); Devuelve el tamaño que este componente debería tener.
void setPreferredSize(); Establece el tamaño que este componente debería tener.
Dimension getMinimumSize(); Devuelve el tamaño mínimo que este componente debería tener.
void setMinimumSize(int ancho, int largo); Establece el tamaño mínimo que este componente
debería tener.
Rectangle getBounds(); Devuelve las coordenadas de este componente como un objeto de la clase
Rectangle, que tiene como campos: x, y, width y heigth.
void setBounds(int x, int y, int ancho, int largo); Establece las coordenadas de este componente.
Acciones sobre el componente
boolean getEnabled(); Comprueba si el componente está o no activo.
void setEnabled(boolean); Establece el componente a activo o inactivo.
boolean getVisible(); Comprueba si el componente está o no visible.
void setVisible(boolean); Establece si el componente está visible o invisible.
void paint(Graphics g); Indica al AWT que ha de dibujar el componente g.
void repaint(); Indica al AWT que ha de volver a dibujar el componente.
void update(Graphics g); Es llamado por AWT cuando se invoca el método repaint(). Por defecto
llama a paint().
Eventos de interacción con el usuario
A su vez hay tres tipos de métodos, para la gestión de eventos mediante el nuevo modelo de eventos
de AWT (desde la versión 1.1).

Hay tres tipos de métodos:

void add_Tipo_Listener(_Tipo_Listener l); Añade un oyente a la espera de algún tipo de eventos

sobre este componente.
void remove_Tipo_Listener(_Tipo_Listener l); Elimina algún oyente que estaba a la espera de
algún tipo de eventos sobre este componente.
void process_Tipo_Event(_Tipo_Event e); Procesa eventos del tipo _Tipo_Event enviándolos a
cualquier objeto _Tipo_Listener que estuviera escuchando.
En estos métodos _Tipo_ puede ser cualquiera de los siguientes:

Component, Focus, InputMethod, Key, Mouse, MouseMotion.

Clase Container
La clase Container sabe cómo mostrar componentes embebidos (que a su vez pueden ser instancias
de la clase Container).

Algunos de los métodos de la clase Container son:

Component add(Component c); Añade un componente al contenedor.

void print(Graphics g); Imprime el contenedor.
void printComponents(Graphics g); Imprime cada uno de los componentes de este contenedor.
LayoutManager getLayout(); Devuelve el gestor de impresión (LayoutManager) asociado a este
contenedor, que es el responsable de colocar los componentes dentro del contenedor.
void setLayout(LayoutManager 1); Establece un gestor de impresión para este componente.
Estos objetos Container tienen un LayoutManager asociado que define la manera en que van a
posicionarse los objetos componentes en su interior.

Gestores de impresión
LayoutManager y LayoutManager2 son dos interfaces encargadas de la representación y
posicionamiento en pantalla de componentes AWT.

De estas interfaces se proporcionan cinco implementaciones en AWT. Cada una de ellas reparte los
objetos de una forma particular:

BorderLayout: En cinco lugares: Norte, Sur, Este, Oeste y Centro (North, South, East, West y
Center).
CardLayout: Permite gestionar varios componentes de los que sólo uno se visualiza a la vez,
permaneciendo los demás invisibles debajo.
FlowLayout: De izquierda a derecha horizontalmente en cada línea. Cuando sobrepasan una línea se
comienza a la izquierda de la siguiente.
GridLayout: Es una tabla en la que todas las casillas tienen el mismo tamaño.
GridBagLayout: Es una tabla, pero las casillas no tienen que tener el mismo tamaño.
Otras clases
Dentro de esta biblioteca podemos encontrar multitud de clases prefabricadas para facilitar el diseño
gráfico.

A continuación, explicamos algunas de ellas.

Clases contenedoras (hijas de Container)

Panel: Permite hacer una presentación más avanzada que Container mediante la combinación con
subpaneles o subclases para crear contenedores personalizados. La clase Applet que sirve para crear
applets Java, hereda de esta clase Panel.
ScrollPane: Una barra de desplazamiento, horizontal o vertical.
Window: Una ventana sin borde.
Frame: Una ventana que no tiene borde. Puede tener asociado un objeto Menubar (una barra de
herramientas o barra de menú personalizada).
Dialog: Una ventana usada para crear diálogos. Tiene la capacidad de ser modal con lo que sólo este
contenedor recibiría entradas del usuario.
Filedialog: Un diálogo que usa el selector de archivos nativo del sistema operativo.
Clases componentes (hijas directas de Component)
Button: Un botón gráfico para el que se puede definir una acción que sucederá cuando se presione
el botón.
Canvas: Permite pintar o capturar eventos del usuario. Se puede usar para crear gráficos o como
clase base para crear una jerarquía de componentes personalizados.
Checkbox: Soporta dos estados: on y off. Se pueden asociar acciones que se ejecuten (triggers)
cuando el estado cambie.
Choice: Menú desplegable de opciones.
Label: Cadena de etiqueta en una localización dada.
List: Una lista desplegable de cadenas.
Scrollbar: Desplegable de objetos Canvas.
TextComponent: Cualquier componente que permita editar cadenas de texto.Tiene dos clases hijas:
TextField: Componente de texto consistente en una línea que puede ser usada para construir
formularios.
TextArea: Componente para edición de texto de tamaño variable.
Eventos de AWT
AWT tiene sus propios eventos, que se explican a continuación.

Eventos físicos
Son todos hijos del evento ComponentEvent, que indica algún cambio en un objeto Component:

InputEvent: Se ha producido una entrada del usuario. Tiene como eventos hijos KeyEvent
(pulsación de una tecla) y MouseEvent (acción sobre el ratón).
FocusEvent: Avisa al programa de que el componente ha ganado o perdido la atención (enfoque)
del usuario. Esto se deduce de la actividad del usuario (ratón y teclado).
WindowEvent: Avisa al programa de que el usuario ha utilizado uno de los controles de ventana a
nivel del sistema operativo, como los controles de minimizar o cerrar.
ContainerEvent: Se envía cuando se añaden o eliminan componentes a un contenedor.
PaintEvent: Evento especial que señala que el sistema operativo quiere dibujar de nuevo una parte
de la interfaz. Un componente debe sobreescribir el método paint() o el método update() para
gestionar este evento.
Eventos semánticos
Son todos hijos del evento AWTEvent, que es el evento base de la jerarquía de eventos:

ActionEvent: Avisa al programa de acciones específicas de componentes como las pulsaciones de

botones.
AdjustmenteEvent: Comunica que una barra de desplazamiento ha sido ajustada.
ItemEvent: Avisa al programa cuando el usuario interacciona con una elección, una lista o una
casilla de verificación.
TextEvent: Avisa cuando un usuario cambia texto en un componente TextComponent, TextArea o
TextField.
InputMethodEvent: Avisa que un texto que está siendo creado utilizando un método de entrada está
cambiando (se ha escrito algo más...).
InvocationEvent: Este evento ejecuta el método run () en una clase Runnable cuando es tratado por
el thread del despachador (dispatcher) de AWT.

Pasos para crear una interfaz gráfica con AWT

Unos pasos sencillos para la elaboración de una primitiva interfaz con AWT serían los siguientes:
Crear una clase con el método main () que es donde empezará a correr nuestro programa.
Crear una clase derivada de Frame que responda al evento WindowClosing ().
Añadir al contenedor todos los componentes que queremos que tenga nuestra interfaz gráfica.
Implementar los objetos gestores (event listeners) que responden a nuestros eventos.

EJEMPLO
1. import java.awt.*;

2. import java.awt.event.*;

3. class CerrarVentana extends WindowAdapter

4. {

5. public void windowClosing(WindowEvent e)

6. {

7. System.exit(0);
8. }

9. }

10. class Ventana extends Frame

11. {

12. public Ventana()

13. {

14. CerrarVentana cv = new CerrarVentana();

15. addWindowListener(cv);

16. Button Boton = new Button();

17. this.add(Boton);

18. Boton.setLabel("Boton");

19. setSize(400, 400);

20. setTitle("Ventana");

21. setVisible(true);

22. }

23. public static void main(String args[])

24. {

25. Ventana mainFrame = new Ventana() ;

26. }

27. }

LIBRERÍA NUMERO 3
java.awt.color
Proporciona clases para espacios de color.
Proporciona clases para espacios de color. Contiene una implementación de un espacio de
color basado en la especificación de formato de perfil del Consorcio Internacional del Color
(ICC), Versión 3.4, 15 de agosto de 1997. También contiene perfiles de color basados en la
Especificación de formato de perfil ICC.
CLASES
ColorSpace
Esta clase abstracta se utiliza para servir como una etiqueta de espacio de color para
identificar el espacio de color específico de un objeto Color o, a través de un objeto
ColorModel, de una Imagen, una Imagen Buffered o un Dispositivo de Gráficos.

ICC_ColorSpace
La clase ICC_ColorSpace es una implementación de la clase abstracta ColorSpace.

ICC_Profile
Una representación de los datos de perfil de color para espacios de color independientes del
dispositivo y dependientes del dispositivo según la especificación ICC.1: 2001-12 del
Consorcio internacional de color, Formato de archivo para perfiles de color

ICC_ProfileGray
Una subclase de la clase ICC_Profile que representa perfiles que cumplen los siguientes
criterios: el tipo de espacio de color del perfil es TYPE_GRAY y el perfil incluye las
etiquetas grayTRCTag y mediaWhitePointTag.

ICC_ProfileRGB
La clase ICC_ProfileRGB es una subclase de la clase ICC_Profile que representa perfiles
que cumplen los siguientes criterios: El tipo de espacio de color del perfil es RGB. El perfil
incluye las etiquetas redColorantTag, greenColorantTag, blueColorantTag, redTRCTag,
greenTRCTag, blueTRCTag y mediaWhitePointTag. El método ICC_Profile getInstance
devolverá un objeto ICC_ProfileRGB cuando se cumplan estas condiciones.
Ejemplo de la librería
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.EventQueue;

import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.border.EmptyBorder;
import javax.swing.JLabel;
import javax.swing.JButton;
import javax.swing.JTextField;

public class EjemploColores extends JFrame {

private JPanel contentPane;

private JTextField txtColor;

/**
* Launch the application.
*/
public static void main(String[] args) {
EventQueue.invokeLater(new Runnable() {
public void run() {
try {
EjemploColores frame = new EjemploColores();
frame.setVisible(true);
} catch (Exception e) {
e.printStackTrace();
 }
}
});
}

/**
* Create the frame.
*/
public EjemploColores() {

//Parámetro asociados a la ventana

setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setBounds(100, 100, 450, 300);
contentPane = new JPanel();
contentPane.setLayout(null);
setContentPane(contentPane);

//Colores

Color color1=new Color(223, 45, 223);

Color color2=new Color(223, 227, 40);
Color color3=new Color(80, 13, 255);

//Componentes

JLabel lblColor = new JLabel("Color1");

lblColor.setBackground(color1);
//Si no lo indocamos no se vera el color
 lblColor.setOpaque(true);
lblColor.setBounds(48, 38, 46, 14);
contentPane.add(lblColor);

JButton btnColor = new JButton("Color2");

btnColor.setBackground(color2);
//Si no lo indicamos, en este caso, no pasaria nada
btnColor.setOpaque(true);
btnColor.setBounds(48, 86, 89, 23);
contentPane.add(btnColor);

txtColor = new JTextField();

txtColor.setText("color3");
txtColor.setBackground(color3);
//Si no lo indicamos, en este caso, no pasaria nada
txtColor.setOpaque(true);
txtColor.setBounds(48, 150, 86, 20);
contentPane.add(txtColor);
txtColor.setColumns(10);

}
}
LIBRERÍA NUMERO 4
java.awt.datatransfer
Proporciona interfaces y clases para transferir datos entre y dentro de las aplicaciones.
Define la noción de objeto "transferible", que es un objeto capaz de ser transferido entre o
dentro de las aplicaciones. Un objeto se identifica como transferible mediante la
implementación de la interfaz Transferible.
También proporciona un mecanismo de portapapeles, que es un objeto que contiene
temporalmente un objeto transferible que se puede transferir entre o dentro de una
aplicación. El portapapeles se usa generalmente para copiar y pegar. Aunque es posible
crear un portapapeles para usar dentro de una aplicación, la mayoría de las aplicaciones
usarán el portapapeles del sistema para garantizar que los datos se puedan transferir a todas
las aplicaciones que se ejecutan en la plataforma.

Resumen de la interfaz
ClipboardOwner
Define la interfaz para las clases que proporcionarán datos a un portapapeles.
FlavorListener
Define un objeto que escucha FlavorEvents.
FlavorMap
Un mapa bidireccional entre "nativos" (cadenas), que corresponde a formatos de datos
específicos de la plataforma, y "sabores" (DataFlavors), que correponde a tipos MIME
independientes de la plataforma.
FlavorTable
Un FlavorMap que relaja la restricción tradicional de 1 a 1 de un Mapa.
Transferible
Define la interfaz para las clases que se pueden usar para proporcionar datos para una
operación de transferencia.
Resumen de la clase
Clipboard
Una clase que implementa un mecanismo para transferir datos usando operaciones de cortar
/ copiar / pegar.
DataFlavor
Un DataFlavor proporciona metainformación sobre datos.
FlavorEvent
FlavorEvent se usa para notificar a las partes interesadas que los DataFlavors disponibles
han cambiado en el Portapapeles (el origen del evento).
StringSelection
A Transferible que implementa la capacidad requerida para transferir una Cadena.
SystemFlavorMap
SystemFlavorMap es un mapa configurable entre "nativos" (cadenas), que corresponden a
formatos de datos específicos de la plataforma, y "sabores" (DataFlavors), que
corresponden a tipos MIME independientes de la plataforma.

Ejemplo de la librería
import java.awt.Toolkit;
import java.awt.datatransfer.Clipboard;
import java.awt.datatransfer.StringSelection;

class ClipDemo1 {

public static void main(String args[]) {

//este es nuestro objeto Transferable para trabajar con strings
StringSelection ss = new StringSelection("Hola Mundo");

//accedemos al portapapeles del sistema

Clipboard cb = Toolkit.getDefaultToolkit().getSystemClipboard();

//añadimos nuestro dato Transferable y como no usaremos ningún clipboardOwner le

pasamos null como argumento
cb.setContents(ss, null);
}
}
LIBRERÍA NUMERO 5
java.awt.dnd
Este paquete define las clases y las interfaces necesarias para realizar operaciones de
arrastrar y soltar en Java. Define las clases para el origen de arrastre y el objetivo de soltar,
así como los eventos para transferir los datos que se arrastran. Este paquete también
proporciona un medio para dar retroalimentación visual al usuario durante la operación de
arrastrar y soltar.
Resumen de interfaz
Autoscroll
Durante las operaciones de DnD es posible que un usuario desee dejar caer el sujeto de la
operación en una región de un control de GUI desplazable que no está actualmente visible
para el usuario.
DragGestureListener
La interfaz del oyente para recibir eventos de gestos de arrastre.
DragSourceListener
El DragSourceListener define la interfaz del evento para los creadores de las operaciones
de arrastrar y soltar para rastrear el estado del gesto del usuario y para proporcionar una
retroalimentación apropiada sobre el "arrastre" al usuario durante la operación de arrastrar y
soltar.
DragSourceMotionListener
Una interfaz de escucha para recibir eventos de movimiento del mouse durante una
operación de arrastre.
DropTargetListener
La interfaz DropTargetListener es la interfaz de devolución de llamada utilizada por la
clase DropTarget para proporcionar notificaciones de las operaciones de DnD que
involucran el tema DropTarget.

Resumen de clase
DnDConstants
Esta clase contiene valores constantes que representan el tipo de acción (es) a realizar por
una operación de arrastrar y soltar.
DragGestureEvent
Un DragGestureEvent se pasa al método DragGestureRecognized () de
DragGestureListener cuando un DragGestureRecognizer determinado detecta que ha
ocurrido un gesto de inicio de arrastre dependiente de la plataforma en el Componente que
está rastreando.
DragGestureRecognizer
El DragGestureRecognizer es una clase base abstracta para la especificación de un oyente
dependiente de la plataforma que puede asociarse con un Componente particular para
identificar los gestos de inicio de arrastre dependientes de la plataforma.
DragSource
DragSource es la entidad responsable del inicio de la operación Arrastrar y soltar, y se
puede usar en una serie de escenarios: 1 instancia predeterminada por JVM durante toda la
vida de esa JVM.
DragSourceAdapter
Una clase de adaptador abstracta para recibir eventos fuente de arrastre.
DragSourceContext
La clase DragSourceContext es responsable de administrar el lado iniciador del protocolo
Arrastrar y soltar.
DragSourceDragEvent
El DragSourceDragEvent se entrega desde DragSourceContextPeer, a través del
DragSourceContext, al DragSourceListener registrado con ese DragSourceContext y con su
DragSource asociado.
DragSourceDropEvent
El DragSourceDropEvent se entrega desde DragSourceContextPeer, a través del
DragSourceContext, al método dragDropEnd de DragSourceListeners registrado con ese
DragSourceContext y con su DragSource asociado.
DragSourceEvent
Esta clase es la clase base para DragSourceDragEvent y DragSourceDropEvent.
DropTarget
DropTarget está asociado a un Componente cuando ese Componente desea aceptar caídas
durante las operaciones de Arrastrar y Soltar.
DropTarget.DropTargetAutoScroller
esta clase anidada protegida implementa autoscroll
DropTargetAdapter
Una clase de adaptador abstracta para recibir eventos de destino de caída.
DropTargetContext
Un DropTargetContext se crea siempre que el cursor lógico asociado con una operación de
arrastrar y soltar coincida con la geometría visible de un componente asociado con un
DropTarget.
DropTargetDragEvent
DropTargetDragEvent se entrega a DropTargetListener a través de sus métodos dragEnter
() y dragOver ().
DropTargetDropEvent
DropTargetDropEvent se entrega a través del método dropTargetListener drop ().
DropTargetEvent
DropTargetEvent es la clase base para DropTargetDragEvent y DropTargetDropEvent.
MouseDragGestureRecognizer
Esta subclase abstracta de DragGestureRecognizer define un DragGestureRecognizer para
los gestos basados en el mouse.

Ejemplo de la librería
import java.awt.*;

public class java1316 extends java.applet.Applet {

public void init() {

add( new Button( "Uno" ) );
add( new Button( "Dos" ) );
}

public static void main( String args[] ) {

Frame f = new Frame( "Tutorial de Java" );
java1316 ejemplo = new java1316();

ejemplo.init();

f.add( "Center",ejemplo );
f.pack();
f.show();
 }
}

LIBRERÍA NUMERO 6
java.awt.event
Proporciona interfaces y clases para tratar con diferentes tipos de eventos activados por
componentes AWT. Consulte la clase java.awt.AWTEvent para obtener detalles sobre el
modelo de evento AWT. Los eventos son activados por fuentes de eventos. Un oyente de
evento se registra con un origen de evento para recibir notificaciones sobre los eventos de
un tipo particular. Este paquete define eventos y detectores de eventos, así como
adaptadores de escucha de eventos, que son clases de conveniencia para facilitar el proceso
de escritura de oyentes de eventos.
Resumen de interfaz
ActionListener
La interfaz del oyente para recibir eventos de acción.
AdjustmentListener
La interfaz del oyente para recibir eventos de ajuste.
AWTEventListener
La interfaz de escucha para recibir notificaciones de eventos enviados a objetos que son
instancias de Component o MenuComponent o sus subclases.
ComponentListener
La interfaz del oyente para recibir eventos de componentes.
ContainerListener
La interfaz del oyente para recibir eventos del contenedor.
FocusListener
La interfaz del oyente para recibir eventos de enfoque del teclado en un componente.
HierarchyBoundsListener
La interfaz del oyente para recibir el ancestro movió y redimensionó los eventos.
HierarchyListener
La interfaz del oyente para recibir jerarquía cambió los eventos.
InputMethodListener
La interfaz del oyente para recibir eventos del método de entrada.
ItemListener
La interfaz del oyente para recibir eventos de elementos.
KeyListener
La interfaz del oyente para recibir eventos del teclado (pulsaciones de teclas).
MouseListener
La interfaz del oyente para recibir eventos de mouse "interesantes" (presionar, soltar, hacer
clic, ingresar y salir) en un componente.
MouseMotionListener
La interfaz del oyente para recibir eventos de movimiento del mouse en un componente.
MouseWheelListener
La interfaz del oyente para recibir eventos de la rueda del mouse en un componente.
TextListener
La interfaz del oyente para recibir eventos de texto.
WindowFocusListener
La interfaz del oyente para recibir WindowEvents, incluidos los eventos
WINDOW_GAINED_FOCUS y WINDOW_LOST_FOCUS.
WindowListener
La interfaz del oyente para recibir eventos de la ventana.
WindowStateListener
La interfaz del oyente para recibir eventos del estado de la ventana.

Resumen de la clase
ActionEvent
Un evento semántico que indica que se produjo una acción definida por el componente.
AdjustmentEvent
El evento de ajuste emitido por objetos Ajustables como Scrollbar y ScrollPane.
AWTEventListenerProxy
Una clase que amplía el EventListenerProxy específicamente para agregar un
AWTEventListener para una máscara de evento específica.
ComponentAdapter
Una clase de adaptador abstracta para recibir eventos de componentes.
ComponentEvent
Un evento de bajo nivel que indica que un componente se movió, cambió de tamaño o
cambió la visibilidad (también, la clase raíz para los otros eventos de nivel de componente).
ContainerAdapter
Una clase de adaptador abstracta para recibir eventos de contenedor.
ContainerEvent
Un evento de bajo nivel que indica que el contenido de un contenedor ha cambiado porque
se ha agregado o eliminado un componente.
FocusAdapter
Una clase de adaptador abstracta para recibir eventos de enfoque de teclado.
FocusEvent
Un evento de bajo nivel que indica que un Componente ha ganado o perdido el foco de
entrada.
HierarchyBoundsAdapter
Una clase de adaptador abstracta para recibir ancestros movió y redimensionó los eventos.
HierarchyEvent
Un evento que indica un cambio en la jerarquía de Componente a la que pertenece el
Componente.
InputEvent
La clase de evento raíz para todos los eventos de entrada de nivel de componente.
InputMethodEvent
Los eventos del método de entrada contienen información sobre el texto que se está
componiendo utilizando un método de entrada.
InvocationEvent
Un evento que ejecuta el método run () en un Runnable cuando es enviado por el hilo del
despachador de eventos AWT.
ArtículoEvento
Un evento semántico que indica que un elemento fue seleccionado o deseleccionado.
KeyAdapter
Una clase de adaptador abstracta para recibir eventos de teclado.
Evento clave
Un evento que indica que se produjo una pulsación de tecla en un componente.
MouseAdapter
Una clase de adaptador abstracta para recibir eventos de mouse.
MouseEvent
Un evento que indica que se produjo una acción del mouse en un componente.
MouseMotionAdapter
Una clase de adaptador abstracto para recibir eventos de movimiento del mouse.
MouseWheelEvent
Un evento que indica que la rueda del mouse se ha girado en un componente.
PaintEvent
El evento de pintura a nivel de componente.
TextEvent
Un evento semántico que indica que el texto de un objeto ha cambiado.
WindowAdapter
Una clase de adaptador abstracta para recibir eventos de ventana.
WindowEvent
Un evento de bajo nivel que indica que una ventana ha cambiado su estado.

Ejemplo de la librería
import javax.swing.JFrame;
import javax.swing.JButton;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JTextField;
import java.awt.Color;
import java.awt.Font;
import java.awt.GridLayout;
import java.awt.BorderLayout;
import java.awt.FlowLayout;
import java.awt.Container;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowListener;
import java.awt.event.WindowEvent;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
import java.util.ArrayList;

/**
*
* @author ProfesorLuisEduardo
*/
public class Ventana extends JFrame {

// Declaración de variables
private JTextField txtNombre;
private JTextField txtEdad;
private JButton btnGuardar;
private JButton btnSalir;
private ArrayList ar = new ArrayList();

public static void main(String[] args) {

new Ventana ("Ejemplo Examen");

}
public Ventana (String titulo)
{
Container c = this.getContentPane();
c.setLayout(new BorderLayout());
JLabel lblTitulo = new JLabel("Ejemplo de Ventana");
lblTitulo.setFont(new Font("Arial", Font.BOLD, 14));
c.add(lblTitulo, BorderLayout.NORTH);
JLabel lblNombre = new JLabel("Nombre: ");
txtNombre = new JTextField (10);
txtNombre.addKeyListener (new KeyAdapter()
{
 @Override
public void keyPressed (KeyEvent e)
{
if(e.getKeyCode() == KeyEvent.VK_ENTER)
txtEdad.requestFocus();
}
});
JLabel lblEdad = new JLabel("Edad: ");
txtEdad = new JTextField (10);
txtEdad.setBackground (Color.BLACK);
txtEdad.setForeground (Color.YELLOW);
txtEdad.setHorizontalAlignment(JTextField.CENTER);
txtEdad.addKeyListener (new KeyAdapter()
{
public void keyPressed (KeyEvent e)
{
if(e.getKeyCode() == KeyEvent.VK_ENTER)
{
// Almacenar la ocurrencia creada en un ArrayList
String nombre = txtNombre.getText();
int edad = Integer.parseInt(txtEdad.getText());
ar.add(new Persona(nombre, edad));
// Limpiamos las cajas de texto
txtNombre.setText("");
txtEdad.setText("");
// Asignamos el foco a la primera caja de texto
txtNombre.requestFocus();
}
}
});
JPanel pnlCentro = new JPanel();
pnlCentro.setLayout(new GridLayout(2,2));
pnlCentro.add (lblNombre);
pnlCentro.add (txtNombre);
pnlCentro.add (lblEdad);
pnlCentro.add (txtEdad);
c.add (pnlCentro, BorderLayout.CENTER);
btnGuardar = new JButton("Guardar el objeto");
btnGuardar.addActionListener (new ActionListener()
{
public void actionPerformed (ActionEvent e)
{
}
});
btnSalir = new JButton ("Salir de la Aplicación");
btnSalir.addActionListener (new ActionListener()
{
public void actionPerformed (ActionEvent e)
{
Ventana.this.dispose();
System.exit(0);
}
});

JPanel pnlSur = new JPanel();

pnlSur.setLayout (new FlowLayout());
pnlSur.add (btnGuardar);
pnlSur.add (btnSalir);
c.add (pnlSur, BorderLayout.SOUTH);
this.setTitle(titulo) ;
this.setResizable(false);
this.pack();
this.setVisible(true);
this.addWindowListener(new WindowAdapter()
{
@Override
public void windowClosing (WindowEvent e)
{
// Finalizamos la aplicación
Ventana.this.dispose();
System.exit(0);
}
});
}
}

LIBRERÍA NUMERO 7
java.awt.font
Proporciona clases e interfaces relacionadas con las fuentes. Contiene soporte para
representar fuentes múltiples maestras tipo 1, tipo 1, fuentes OpenType y fuentes
TrueType.
Resumen de interfaz
MultipleMaster
La interfaz MultipleMaster representa fuentes Tipo Multiple Multiple Master.
De tipo abierto
La interfaz OpenType representa fuentes OpenType y TrueType.

Resumen de clase
FontRenderContext
La clase FontRenderContext es un contenedor de la información necesaria para medir
correctamente el texto.
GlyphJustificationInfo
La clase GlyphJustificationInfo representa información sobre las propiedades de
justificación de un glifo.
GlyphMetrics
La clase GlyphMetrics representa información para un solo glifo.
GlyphVector
Un objeto GlyphVector es una colección de glifos que contiene información geométrica
para la ubicación de cada glifo en un espacio de coordenadas transformadas que
corresponde al dispositivo en el que finalmente se muestra el GlyphVector.
GraphicAttribute
Esta clase se usa con el atributo CHAR_REPLACEMENT.
ImageGraphicAttribute
La clase ImageGraphicAttribute es una implementación de GraphicAttribute que dibuja
imágenes en un TextLayout.
LayoutPath
LayoutPath proporciona una asignación entre las ubicaciones relativas a la línea de base y
los puntos en el espacio de usuario.
LineBreakMeasurer
La clase LineBreakMeasurer permite dividir el texto con estilo en líneas (o segmentos) que
se ajustan a un avance visual particular.
LineMetrics
La clase LineMetrics permite el acceso a las métricas necesarias para el diseño de los
caracteres a lo largo de una línea y para el diseño de un conjunto de líneas.
NumericShaper
La clase NumericShaper se usa para convertir dígitos Latin-1 (europeos) a otros dígitos
decimales Unicode.
ShapeGraphicAttribute
La clase ShapeGraphicAttribute es una implementación de GraphicAttribute que dibuja
formas en un TextLayout.
TextAttribute
La clase TextAttribute define las claves de atributo y los valores de atributo utilizados para
la representación de texto.
TextHitInfo
La clase TextHitInfo representa una posición de carácter en un modelo de texto y un sesgo
o "lado" del personaje.
TextLayout
TextLayout es una representación gráfica inmutable de los datos de carácter con estilo.
TextLayout.CaretPolicy
Define una política para determinar la ubicación fuerte de intercalación.
TextMeasurer
La clase TextMeasurer proporciona las operaciones primitivas necesarias para el salto de
línea: medir hasta un avance dado, determinar el avance de un rango de caracteres y generar
un TextLayout para una variedad de caracteres.
TransformAttribute
La clase TransformAttribute proporciona un contenedor inmutable para una transformación
para que sea seguro usarlo como atributo.

Ejemplo de la librería
package com.chuidiang.ejemplos.fonts;

import java.awt.Font;
import java.awt.GraphicsEnvironment;
import java.util.Arrays;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.SwingConstants;

/**
* Example of Fonts.
*
* @author Chuidiang
*
*/
public class FontsExample {

public static void main(String[] args) throws InterruptedException {

// List all available fonts.
String[] fontNames = GraphicsEnvironment.getLocalGraphicsEnvironment()
.getAvailableFontFamilyNames();
System.out.println(Arrays.toString(fontNames));

// A windows with a label.

JFrame frame = new JFrame("Fonts Example");
JLabel label = new JLabel();
label.setHorizontalAlignment(SwingConstants.CENTER);
frame.getContentPane().add(label);
frame.setSize(400, 100);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setLocationRelativeTo(null);
frame.setVisible(true);

// Show a text for each font

for (String font : fontNames) {
label.setText("Hi, I'm " + font);
label.setFont(new Font(font, Font.PLAIN, 15));
Thread.sleep(1000);
}
}

LIBRERÍA NUMERO 8
java.awt.geom
Proporciona las clases de Java 2D para definir y realizar operaciones en objetos
relacionados con la geometría bidimensional. Algunas características importantes del
paquete incluyen:
clases para manipular geometría, como AffineTransform y la interfaz PathIterator que
implementan todos los objetos Shape.
clases que implementan la interfaz Shape, como CubicCurve2D, Ellipse2D, Line2D,
Rectangle2D y GeneralShape.
la clase Área que proporciona mecanismos para operaciones add (union), resta, intersect
yOROR en otros objetos Shape.