curso programación en java

Ignacio Zahonero MartínezLuis Joyanes Aguilar

CursoProgramación en Java

Tema 10

Interfaz gráfico de usuario (GUI)

Swing -Eventos

2Ignacio Zahonero MartínezLuis Joyanes Aguilar

SWING

Swing es el conjunto de clases, interfaces, recursos, etc, para la construcción de IGU (Interfaz Gráfico de Usuario). Forma parte de Java Foundation Classes (JFC).

Las JFC contiene los componenetes Swing, un API para 2D, un API para arrastrar y soltar y un API para facilitar el acceso.

Swing está construido sobre la arquitectura AWT (Abstract Window Toolkit). AWT es la biblioteca de clases, incorporada en Java 1.0, para realizar programación IGU.

AWT depende de la plataforma. Swing aparece en Java 2, es independiente de la plataforma.

Con Swing el aspecto de los elementos del interfaz gráfico es el mismo en todas las plataformas.

En la actualidad, toda, o casi toda, la progrmación gráfica se hace en Swing.

Las clases de Swing se encuentran en el paquete javax.swing. Entonces, un programa que utilice componentes gráficos y procese eventos, tendrá las sentencias import:

import java.awt.*; // no siempre será necesario

import java.awt.event.*;

import.javax.swing.*;


JERARQUÍA DE CLASES GUI

Component

Container

JComponet

JTextComponent

JLabel JPanel

Panel

Applet

JApplet

Window

Frame

JFrame

Dialog

JDialog

Las clases que empiezan por J son de swing.


ELEMENTOS DE UN GUI

Un programa que implementa una interfaz gráfico va a tener, normalmente, cuatro tipos de elementos:

1. Un contenedor de nivel superior: un marco (JFrame), un applet (JApplet), o bien objetos JDialog. Estos contenedores no están dentro de otra ventana, son las ventanas principales.

2. Componentes de la interfaz gráfica, como botones, campos de texto, ..., que se ubican en la ventana principal o en contenedores.

3. Contenedores. Diseñados para contener a otros elementos de la interfaz. JPanel, JScrollPane son dos contenedores. Estos contenedores a su vez son componenetes.

4. Elementos de para la gestión de eventos.

Los componentes siempre se añaden a una lámina o panel. Puede ser a la lámina del marco, o bien a un panel JPanel.

En general, siempre se crean clases derivadas de las clases "contenedores de nivel superior". Todo marco sera una subclase de JFrame, al igual que un applet es una subclase de JApplet.


MARCOS(I)

Una aplicación GUI se crea con una ventana principal en la que se ubican componentes.

La ventana principal es un objeto marco, que deriva de la clase JFrame.

Alguno de los métodos propios de JFrame:• JFrame() constructor

• JFrame(String titulo) constructor, pone el título

• void setTitle(String titulo)

• void setIconImage(Image m) imagen como icono del marco

• void setDefaultCloseOperation(int op) operación al cerrar el marco, constantes de JFrame: EXIT_ON_CLOSE, DO_NOTHING_ON_CLOSE, DISPOSE_ON_CLOSE, HIDE_ON_CLOSE

• Container getContentPane() proporciona lámina de contenidos

• void setUndecorated(boolean b) si b=true quita adornos: bordes...

• public void setResizable(boolean r) si r=true se puede cambiar tamaño

• void add(Component c) añade el componente a la lámina(java 1.5)

• void remove(Component comp)

• void setLayout(LayoutManager manager)


MARCOS(II)

Métodos de JFrame heredados de Container:

• Component add(Component comp)

• Component add(Component comp, int p) añade componente en la posición p.

Si se añade un componente a un contenedor ya visible, es necesario hacer una llamada a validate()

• void validate()

• void remove(int p) elimina componente de posición p

• void remove(Component comp)

Métodos de JFrame heredados de Component:• void setVisible(boolean b) muestra componente.

• void setBounds(int x, int y, sitúa el componente y cambia su tamaño

int ancho, int alto)

• void setLocation(int x, int y)

• void setLocation(Point p)

• void setSize(int ancho, int alto) dimensiona componente.

• void setSize(Dimension d) dimensiona componente.


PROPIEDADES DEL SISTEMA DE VENTANAS

La clase Toolkit (java.awt) está diseñada para establecer un comunicación con el sistema nativo de ventanas. Es una clase abstracta, entoces para obtener características del sistema de ventanas lo primero que se hace es llamar al método:

static Toolkit getDefaultToolkit()

que devuelve un objeto detivado de Toolkit con las propiedades de la ventana.

Métodos de interes de Toolkit:

Image getImage(String nom); devuelve imagen (GIF, JPEG,PNG) del archivo

Image getImage(URL u);

Dimension getScreenSize() devuelve la dimensión de la ventana

Dimension (java.awt) tiene los atributos public: int height, int width. Y los métodos: double getHeight(), double getWith().


Ejemplo. Marco centrado que ocupa la mitad de la pantalla.

Para centrar el marco en la pantalla se utiliza la clase Toolkit. Primero se crea el objeto derivado de Toolkit (static Toolkit getDefaultToolkit()) y después se obtiene su dimensión (Dimension getScreenSize()). El tamaño y posición del marco (coordenadas de esquina superior izquierda) se realiza llamando a setSize() y setLocation().

Como ejemplo, se pone una etiqueta y un botón en el panel de contenidos del marco. Hay que tener en cuenta que los elementos de un marco no se ponen en posiciones absolutas; se distribuyen según el "manejador" que tengan establecido. En un marco, el layout por defecto es BorderLayout. Este layout considera cinco zonas, según las coordenadas y el centro.


MarcoCentrado.java (I)

import javax.swing.*;

import java.awt.*;

public class MarcoCentrado extends JFrame

{

public MarcoCentrado()

{

setTitle("Marco Centrado");

Toolkit k = Toolkit.getDefaultToolkit();

Dimension d = k.getScreenSize();

int alto = d.height; int ancho = d.width;

setSize(ancho/2, alto/2);

setLocation(ancho/4, alto/4);

add(new JButton("Boton"));

add(new JLabel("HOLA",SwingConstants.CENTER),BorderLayout.SOUTH);

setResizable(false);

}


MarcoCentrado.java (II)

public static void main(String args[])

{

MarcoCentrado miMarco = new MarcoCentrado();

miMarco.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

miMarco.setVisible(true);

}

}

Nota: añadir otros tres componentes mas al marco, en el NORTH, EAST y WEST. Probar los efectos del método setUndecorated(boolean b) en la imagen del marco. Compilar y ejecutar.


LÁMINA DE CONTENIDOS. PANEL

Un marco consta de una serie de láminas. La lámina de contenidos es en la que se añaden componenrtes. El método Container getContentPane() devuelve dicha lámina.

Actualmente, en Java 5, el método add(Component) de JFrame añade un componente a la lámina de contenidos; versiones anteriores de Java exigían hacerlo directamente a dicha lámina, similar al siguiente código:

marco.getContentPane().add(new Jlabel("Hola Amigos"));

Además de la lámina de contenidos, la clase JPanel define una lámina en la que se puede dibujar y poner componentes (campos de testo, botones, ....).

Constructores de JPanel: JPanel() y JPanel(LayoutManager l);

Por herencia, los métodos: add(Component c ) y add(Component c, int p);

La ubicación, por defecto, de componenetes en JPanel es del tipo FlowLayout. Esto significa que se disponen de izquierda a derecha y de arriba a abajo.

En el ejemplo que se pone a continuación, se crea un panel al que se añaden 5 componentes. El panel reemplaza al panel a la lámina de contenidos del marco.


MarcoPanel.java (I)


import java.awt.*;

public class MarcoPanel extends JFrame

{

public MarcoPanel()

{

JPanel pa = new JPanel(); // por default FlowLayout()

pa.add(new JTextField("Razones debiles", 10));

pa.add(new JButton("Boton"));

pa.add(new JCheckBox("Box ",false));

pa.add(new JLabel ("Calendario", JLabel.CENTER));

pa.add(new JRadioButton("Bot Radio", true));

setContentPane(pa);

setSize(300,200);

}


MarcoPanel.java (II)

public static void main(String[] args)

{

MarcoPanel m;

m = new MarcoPanel();

m.setVisible(true);

m.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

}

}

Ejecución:

Nota: Pinchar con el ratón y ampliar el marco; ¿cómo se distribuyen los elementos?


VISUALIZACÍON DE COMPONENTES

Para dibujar en un panel (lámina) se utiliza el método paintComponent(Graphics g). Este método, definido en JComponent (con visibilidad protected), es necesario redefinirlo para que realiza las acciones deseadas.

paintComponent(Graphics g) tiene la particularidad de que recibe el argumento Graphics , para dibujar imágenes, texto, poner colores, establecer el tipo de letra.

Se puede afirmar que el argumento Graphics es el contexto gráfico. Graphics es una clase definida en el paquete java.awt coon métodos para dibujar texto e imagenes.

Cada vez que una ventana vaya a ser dibujada, el manejador del evento se lo hace saber a cada componente. Esto hace que se llame automáticamente a paintComponent().

No se llama directamente al método paintComponent(). Se llama automáticamente cuando por algún cambio es necesario redibujarse.

Por ejemplo, si el usuaio aumenta, o disminuye, el tamaño de la ventana. Si se ha "tapado" la ventana por otra ventana.

Para forzar la llamada a paintComponent(Graphics g), se hace una llamada al método repaint(), el cual da lugar a una llamada paintComponent() con el objeto Graphics .

A tener en cuenta: las medidas se hacen en pixeles, y (0,0) es la esquina superior izquierda.


Ejemplo. Panel en el que se escribe una cadena y un rectángulo

Se declara una clase derivada de JPanel en la cual se redefine el método paintComponent(). Como se puede observar en la redefinición, la primera sentencia es una llamada a paintComponent() de la clase base (simplemente para pintar el color del fondo, en realidad se puede omitir). A continuación, se escribe una cadena junto a su posición de inicio:

g.drawString("Cadena en Panel (" + x + "," + y + ")", x, y);

También, se dibuja un rectángulo:

g.drawRect(x-1, y-12, 135, 12);

Al ejecutar, se recomienda cambiar el tamaño, ampliar, minimizar y sacar conclusiones.

Nota: Una probado, modificar el método con el fin de añadir otra figura, por ejemplo una elipse.


PanelDibujo.java (I)


import java.awt.*;

public class PanelDibujo extends JPanel

{

private int x=0,y=10;

public void paintComponent(Graphics g)

{

super.paintComponent(g);

g.drawString("Cadena en Panel (" + x + "," + y + ")", x, y);

x++; y += 2;

g.drawRect(x-1, y-12, 135, 12);

}

}


PanelDibujo.java (II)


import java.awt.*;

public class MarcoDibujo extends JFrame

{

private static final int ANCHO=300, ALTO=200;

public MarcoDibujo()

{

setTitle("Marco con panel de dibujo");

setSize(ANCHO,ALTO); setLocation(ANCHO/2,ALTO/2);

}

public static void main(String args[])

{

MarcoDibujo marco;

marco = new MarcoDibujo();

PanelDibujo uno = new PanelDibujo();

marco.add(uno);

marco.setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);

//marco.pack();

marco.setVisible(true);

}

}


CLASE Graphics

La clase Graphics (java.awt) es una clase abstracta que proporciona el contexto gráfico. La clase dispone de métodos para dibujar todo tipo de elementos.

Graphics al ser clase abstracta no se puede instanciar. El contexto gráfico se obtiene a través de los métodos paint(Graphics g) y update(Graphics g) de la clase Component.

Métodos de dibujo de Graphics: void drawString(String cad, int x, int y); (x,y) coordenadas de origen

void drawLine(int x1, int y1, int x2, int y2); dibuja una línea

void drawRect(int x, int y, int ancho, int alto); dibuja rectángulo

void fillRect(int x, int y, int ancho, int alto); llena rectángulo con colora actual

void fillRoundRect(int x, int y, int ancho, int alto,

int arcoAncho, int arcoAlto); llena rectángulo redondeado

void drawOval(int x, int y, int ancho, int alto); dibuja elipse

void drawArc(int x, int y, int ancho, int alto,

int anguloInicio, int anguloArco); dibuja arco

boolean drawImage(Image m, int x, int y, ImageObserver b);

...

Graphics2D es una subclase de Graphics que se utiliza para dibujar formas en java 2D.


CONTROL DE VISUALIZACÍON(I)

La clase Component (en la parte alta de la jerarquía AWT y también de swing) dispone de los métodos que controlan la visualización de cualquier componente, tanto en las aplicaciones GUI como en los applet,s.

El método de la clase Component, void paint(Graphics g) recibe el contexto gráfico g; con g se puede llamar a los métodos de la clase Graphics.

La definición original de paint(Graphics g) no hace nada. Puede ser redefinido para realizar operaciones gráficas.

La llamada a paint() se realiza de dos formas:

• Directamente por la aplicación, cuando el componente se muestra por primera vez, o bien cuando deja de estar tapado por otro componente, o cambia de tamaño.

• Al llamar a repaint(), éste, indirectamente a través de update(), llama a paint()

La clase JComponent define el método paint() de tal forma que llama a paintComponent(Graphics g). Por esa razón si se quiere realizar operaciones gráficas es necesario redefinir paintComponent()


CONTROL DE VISUALIZACÍON(II)

El método repaint(), de la clase Component, se llama siempre que se desee volver a dibujar un componenete. repaint() hace una llamada a update(), que en su implementación original, llama a paint().

repaint() está sobrecargado:

• void repaint() para todo el recinto

• void repaint(int x, int y, int ancho, int alto) limitado al rectángulo

El método update(), de la clase Component, normalmente es llamado por el método repaint(). Su prototipo: void update(Graphics g). Si no se redefine, realiza dos acciones:

1. Redibujar el componente con el color de fondo actual. l

2. Llamar al método paint(), pasando el contexto gráfico.


COLOR

La clase Color (java.awt) está diseñada para definir colores. La clase dispone de constantes predefinidas para los colores estándar: BLACK, BLUE, CYAN, WHITE, GRAY, RED ... También, la clase SystemColor dispone de constantes que representan colores del sistema.

Otra forma de especificar un color es creando un objeto de Color mediante sus componentes rojo, verde y azul. El constructor es el siguiente:

public Color (int rojo, int verde, int azul);

La escala de cada parámetro es de 0 a 255. Por ejemplo, el color GRAY está definidö:

Color gray = new Color(128, 128, 128);

Aumentando, o disminuyendo, estos valores se consiguen distintas tonalidades.

Métodos de interes: para especificar el color de fondo se utiliza el método setBackgroud(Color c) de la clase Component, heredado por todos los componenetes. También, el método setForeground(Color c) de la clase Component , para el color del primer plano de un componente. La clase Graphics dispone del método setColor(Color c) para dar color a las siguientes operaciones gráficas.


FUENTES (tipo de letra)

Para especificar un tipo de letra se utiliza la clase Font. El constructor de Font crea un tipo de letra que se puede aplicar a texto.

Constructor: Font(String nombre, int estilo, int tamaño);

Por ejemplo: Font tipo = new Font("Serif",Font.PLAIN,14);

En la clase Font están definidas constantes que representan los estilos: PLAIN, BOLD(negrita) , ITALIC (cursiva).

El método String[] getAvailableFontFamilyNames() de la clase GraphicsEnvironment proporciona un array de cadenas con los nombres de los tipos de letras disponibles. Un objeto de la clase mencionada se obtiene:

GraphicsEnvironment g = GraphicsEnvironment. getLocalGraphicsEnvironment()

La clase Component dispone del método setFont(Font tipo) para poner el tipo de letra al texto del componente.

La clase Graphics dispone del método setFont(Font tipo) para poner el tipo de letra del texto que se escriba.


CARGA DE IMAGENES

Las imagenes, normalmente, están almacenadas en archivos de nuestro computador, o en algún lugar (URL) de internet. Se pueden leer, o descargar, para después visualizarlas.

Una C una imagen es llamando al método ImageIO.read(archivo), que es un método static de la clase ImageIO (paquete javax.imageio).

String nomArchivo =" ";

Image imag = ImageIO.read(new File(nomArchivo));

Si la imagen se encuentra en una dirección de internet:

Image imag = ImageIO.read(new URL(nomURL));

El método read() lanza la excepción IOException si el objeto imagen no está disponible.

Para visualizar la imagen se llama al método drawImage() , de la clase Graphics, en la redefinición de paintComponent().

class miPanel extends JPanel {...


{

g.drawImage(imag, 0, 0, null); // (0,0) esquina superior izda.


EJEMPLO

A un marco se añade un panel en el que se ha dibujado una imgen que se encuentra en un archivo. El tamaño del marco se ajusta a la ventana (Toolkit.getDefaultToolkit()). La clase panel, derivada de JPanel, dispone de un constructor que lee la imagen (ImegeIO.read()). Si la imagen no se puede leer, el método read() lanza una excepción que será "atrapada" y relanzada. La clase que implenta el panel redefine el método paintContent() con la finalidad de dibujar la imagen (drawImage()).

LaminaImagen.java


import javax.imageio.ImageIO;

import java.awt.*;

import java.io.*;

public class LaminaImagen extends JPanel

{

private Image ima = null;


LaminaImagen.java (II) /** Constructor, carga la imagen */

public LaminaImagen() throws IOException

{

try {

ima = ImageIO.read(new File(

"C:\\Documents and Settings

\\All Users\\" +

"Documentos\\Mis imágenes\\

Imágenes de muestra\\Invierno.GIF"));

}

catch(IOException e)

{

System.out.println(

"No se puede cargar la imagen: " +e);

throw e;

}

}


{

super.paintComponent(g);

System.out.println("PaintComponen" + ima);

if (ima == null) return; // no hay imagen

// this es el "observador"

int ancho = ima.getWidth(this);

int alto = ima.getHeight(this);

System.out.println("Ancho y alto de imagen:" + ancho+", "+alto);

//(0,0) esquina superior izdq. g.drawImage(ima, 0, 0, this

/* for (int i = 0;

i* 20 <= getWidth(); i++)

for (int j = 0;

j* 20 <= getHeight(); j++)

if (i + j > 0)

g.copyArea(0, 0, 20, 20, i*20 ,

j*20); */

}

}


Nota: El método copyaArea() de la clase Graphics permite copiar un área de dibujo en otra posición del panel.

Prototipo:

void copyArea(int x, int y, int ancho, int alto, int despl_X, int despl_Y);

x,y: coordenadas de la parte superior izqda de la imagen origen

ancho, alto: rectangulo de la imagen origen que se va a copiar

despl_X: desplazamiento horizontal desde imagen origen al destino

despl_Y: desplazamiento vertical desde imagen origen al destino

Por ejemplo: Se recubre la ventana con un rectángulo de 20*20 pixeles de la imagen original.

for (int i = 0; i* 20 <= getWidth(); i++)

for (int j = 0; j* 20 <= getHeight(); j++)

if (i + j > 0)

g.copyArea(0, 0, 20, 20, i*20 , j*20);


MarcoImagCentr.java(I)import javax.swing.*;

import java.awt.*;

public class MarcoImagCentr extends JFrame

{

/** Constructor */

public MarcoImagCentr()

{

// Dimensiones de la pantalla

setTitle("Marco Con Imagen");

Toolkit k = Toolkit.getDefaultToolkit(); /* método factoría. Ventana actual */

Dimension d = k.getScreenSize();

int alto = d.height;

int ancho = d.width;

setSize(ancho/2, alto/2);

setLocation(ancho/4, alto/4);

/* setSize(ancho,alto);

setLocation(0,0);

*/

}


MarcoImagCentr.java(II) public static void main(String args[])

{

MarcoImagCentr miMarco = new MarcoImagCentr();

LaminaImagen pan;

//miMarco.setUndecorated(true);

miMarco.setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);

try {

pan = new LaminaImagen();

miMarco.add(pan);

}

catch (Exception e)

{

System.out.println("No se ha podido realizar el dibujo de la imagen");

System.exit(1);

}

}

}


GESTORES DE POSICIONAMIENTO

La disposición de componentes no se suele determinar de modo absoluto. De esta forma se evita depender del dispositivo.

La distribución de componentes se hace con los gestores de posicionamiento. Objetos que implementan la interfaz LayoutManager.

Cada contenedor tiene su propio gestor de posicionamiento por omisión: Window, JFrame y JDialog: BorderLayout. JPanel, JApplet : FlowLayout.

Para cambiarlo, la clase Container tiene el método setLayout(LayoutManager mng).

Hay definidos hasta 7 tipos de layouts; son los siguientes: FlowLayout, BorderLayout, GridLayout, BoxLayout, GridBagLayout, CardLayout y SpringLayout.


BorderLayout Divide al contenedor en cinco zonas. Los componentes se disponen en las

posiciones superior (“North”), inferior (“South”), derecha (“West”), izquierda (“East”) y centro (“Center”).

Las posiciones están representadas por las constantes: BorderLayout.CENTER, BorderLayout.NORTH, ...

El método add(), (add (Component c, int zona)) por default, dispone el componente en el centro.

Los componentes del marco se pueden separar con el constructor:

BorderLayout(int separaHorizontal, int separaVertical);

Para indicar la separación en pixeles.

Con este layout, primero se sitúan los componentes de los bordes y después el componente del centro, que ocupará el espacio restante.

Cuando se modifican las dimensiones del contenedor, las dimensiones de los componenetes de los bordes no cambian, cambia el tamaño del componente central.


EJEMPLO BorderLayout E constructor del objeto Marco (class Marco extends JFrame) crea 5 etiquetas en

las posiciones indicadas.

Marco(){ super("Mi marco"); add(new JLabel("Norte", SwingConstants.CENTER), BorderLayout.NORTH); add(new JLabel("Sur", SwingConstants.CENTER), BorderLayout.SOUTH); add(new JLabel("Centro", SwingConstants.CENTER), BorderLayout.CENTER); add(new JLabel("Oeste", SwingConstants.CENTER), BorderLayout.WEST); add(new JLabel("Este", SwingConstants.CENTER), BorderLayout.EAST); setSize(ancho,alto); setVisible(true);}

Ejercicio: Cambiar la etiquetas por botones (JButton) y separar los componentes en 5 * 5 pixeles


FlowLayout

Los componentes se disponen en fila de izquierda a derecha. Una vez completada una línea comienza otra línea

Constructor: setLayout(new FlowLayout(int alineación)).

La alineación puede tomar los valores: FlowLayout.RIGHT, FlowLayout.CENTER y FlowLayout.LEFT.

setLayout(new FlowLayout(int alin, int sepHztal, int sepVert)).

Marco(){ super("Mi marco"); setLayout(new FlowLayout()); add(new JLabel("Primera")); add(new JLabel("Segunda")); add(new JLabel("Tercera")); add(new JLabel("Cuarta")); add(new JLabel("Quinta")); add(new JLabel("Sexta")); setSize(ancho,alto); setVisible(true);}


GridLayout

Los componentes se distribuyen en una rejilla de celdas iguales (en forma de cuadrícula). Los elementos se ubican de arriaba hacia abajo y de izquierda a derecha.

Constructores:

GridLayout() coloca los componentes en una única fila y única columna.

GridLayout(int f,int c) coloca los componentes en cuadrículas de f filas y c columnas.

GridLayout(int f, int c, int sepHztal, int sepVert)Marco(){ super("Mi marco"); setLayout(new GridLayout(3,2)); add(new JLabel("Primera")); add(new JLabel("Segunda")); add(new JLabel("Tercera")); add(new JLabel("Cuarta")); add(new JLabel("Quinta")); add(new JLabel("Sexta")); setSize(ancho,alto); setVisible(true);}


BoxLayout

Permite mostrar una única fila o una única columna con los componentes utilizados. El constructor necesita un argumento con el contenedor que va a utilizar y la orientación. La orientación puede ser: BoxLayout.X_AXIS o BoxLayout.Y_AXIS

Constructor: BoxLayout(Container destino, int orientacion)

Ejemplo:Marco(){ super("Marco BoxLayout"); JPanel pan = new JPanel() ; pan.setLayout(new BoxLayout(pan, BoxLayout.Y_AXIS)); pan.add(new JButton("Primera")); pan.add(new JButton("Segunda")); pan.add(new JButton("Tercera")); pan.add(new JButton("Cuarta")); pan.add(new JButton("Quinta")); pan.add(new JButton("Sexta")); add(pan); // o bien, setContentPane(pan) setSize(ancho,alto); setVisible(true);}


BoxLayout-Box

Hay un contenedor que tiene como gestor predeterminado un BoxLayout: contenedor Box.

Un objeto Box se crea con los métodos factoría de la clase Box:

Box.createHorizontalBox()

Box.createVerticalBox()

Estos son métodos static que crean un objeto Box con la orientación del nombre:

Box cajaHoriz = Box.createHorizontalBox()

Se añaden los elementos al contenedor: cajaHoriz.add(elemento). Y después el contenedor al marco.

Ejemplo: public MarcoBotEve()

{

pc = getContentPane();

setTitle("Ejemplo de eventos botones");

azul = new JButton("Azul");

amar = new JButton("Amarillo");

rojo = new JButton("Rojo");


Ejemplo (continuación) cajaH = Box.createHorizontalBox(); // método factoria

cajaH.add(azul);

cajaH.add(Box.createHorizontalStrut(25)); // separación horizontal 25 pixeles

cajaH.add(amar);

cajaH.add(Box.createRigidArea(new Dimension(50,80))); // zona rígida, separación

// horizontal y vertical que afecta a todos los componentes

cajaH.add(rojo);

/* azul.addActionListener(new OyenteBoton());

amar.addActionListener(new OyenteBoton());

rojo.addActionListener(new OyenteBoton());

*/

setContentPane(cajaH);

}

// clase con método main

public static void main(String[] args) {

MarcoBotEve m ;

m = new MarcoBotEve(); //m.pack();

m.setVisible(true);


}


COMBINAR GESTORES DE POSICIONAMIENTO

Cada contenedor (JFrame, JPanel, JDialog,...) sólo puede tener un gestor de posicionamiento. Sin embargo un contenedor de primer nivel (un JFrame, ...) puede tener otros contenedores anidados, cada uno con su propio gestor de posicionamiento. En definitiva, se combinan o andan diversos gestores de posicionamiento.

Ejemplo: se definen tres paneles, cada uno con su propio layout. A cada panel se añaden elementos como botones, etiquetas, campos de texto y una lista. Una vez creados los tres paneles, se estable el layout del contenedor de primer nivel (marco) y se añaden.

MarcoGestores.java (I)

import java.io.*;


import java.awt.*;

public class MarcoGestores extends JFrame

{

//Constructor en el que se crean los paneles


MarcoGestores.java (II)

public MarcoGestores()

{

JPanel pa1 = new JPanel(new FlowLayout()); // por default FlowLayout()

JPanel pa2 = new JPanel(new BorderLayout());

JPanel pa3 = new JPanel();

pa3.setLayout ( new BoxLayout(pa3, BoxLayout.Y_AXIS));

String [] opc = {"Marea alta", "Bajamar", " Montaña"};

pa1.add(new JLabel (" Elegir", JLabel.CENTER));

pa1.add(new JList(opc));

pa1.add(new JButton("Pulsar"));

JTextField j = new JTextField("Razones "); j.setEditable(false);

pa2.add(j,BorderLayout.WEST);

pa2.add(new JButton("Boton"),BorderLayout.EAST);

pa3.add(new JCheckBox("Box ",false));

pa3.add(new JLabel ("Calendario", JLabel.CENTER));

pa3.add(new JRadioButton("Boton Radio", true));


MarcoGestores.java (III) /* Container ppal = getContentPane();

ppal.setLayout ( new BorderLayout());

ppal.add(pa1,BorderLayout.NORTH);

ppal.add(pa2,BorderLayout.CENTER);

ppal.add(pa3,BorderLayout.SOUTH); */

setLayout( new BorderLayout(10, 15));

add(pa1,BorderLayout.NORTH);

add(pa2,BorderLayout.CENTER);

add(pa3,BorderLayout.SOUTH);

}


{

MarcoGestores m; m = new MarcoGestores();

m.setSize(200, 300); m.setLocation(20, 200);

m.setResizable(false);

m.setVisible(true);


}

}


DESACTIVAR EL GESTOR DE POSICIONAMIENTO

Mediante el mensaje setLayout(null) se desactiva el gestor de posicionamiento de un contendor.

Una vez desactivado el gestor de posicionamiento, el usuario deberá distribuir cada componente en la lámina o panel contenedor. Las coordenadas absolutas que se utilizan son en pixeles.

Métodos más utilizados (definidos en clase Component) :

setSize(int ancho, int alto)

setLocation(int x, int y)

setBounds(int x, int y, int ancho, int alto); fija la posición y el tamaño del componente

Ejemplo:

JLabel etq = new JLabel("Ventana");

etq.setLocation(10,20);

etq.setSize(50,60);

// estas dos últimas llamadas son equivalentes a:

etq.setBounds(10,20, 50,60);


COORDENAS y DISEÑO

Coordenadas.

Se miden en pixeles.

El origen de coordenadas es (0,0), representa la esquina superior izquierda.

El eje x representa el eje de abscisas (horizontal), es decir de izquierda a derecha.

El eje y representa el eje de ordenadas (vertical), es decir de arriba a abajo.

Cada componente se ubica en el sistema de coordenasas padre.

¿Cuando tiene lugar el diseño?

Cuando se hace visible por primera vez; o bien, cuando se borra o añade un componente.

Cuando cambia el tamaño de un componente.

Una vez hecho visible un marco, si se cambia el tamaño de un componente, no se activará el nuevo diseño hasta llamar al método revalidate() del componente.


COMPONENTES swing

Todos los componentes que se agregan a un contenedor descienden de la clase JComponent.

Un componente representa cualquier cosa que tenga una posición, un tamaño, que pueda pintarse y que pueda recibir eventos.

Añadir componentes a un contenedor. Método add() de la superclase Container. public Container Add(Component comp).

Añade un componente después del anterior en el gestor de posicionamiento.

public Container Add(Component comp, int indice). Añade un componente en la posición indice.


ETIQUETAS (JLabel)

Representan componentes con texto fijo.

No reciben eventos.

Constructores. JLabel(). JLabel(String mensaje). JLabel(String mensaje, Icon icono); JLabel(String mensaje, int alineación).

Para la alineación se pueden utilizar las constantes estáticas CENTER, LEFT y RIGHT del interface SwingConstants.

Algunos métodos. public String getText(). public void setText(String mensaje).


BOTONES

La clase base de los botones es AbstractButton.

AbstractButton es una clase abstracta que encapsula propiedades y métodos comunes a los diversos tipos de botones:

AbstractButton

JButton JToogleButton

JRadioButton JCheckBox


BOTÓN- JButton

Representa el botón común. Se crea especificando una cadena, un icono, ambos, o bien sin especificar elemento.

Recibe eventos; es el click del botón. El listener asociado implementa ActionListener.

Constructores. JButton(). JButton(String mensaje). JButton(String mensaje, Icon icono);

Algunos métodos (heredados de AbstractButton): public String getText(); public void setText(String m). public void setIcon(Icon icono). public void setMnemonic(char nemotécnico). public void addActionListener(ActionListener oyente). public boolean isSelected(). public void setSelected(boolean flag).


BOTÓN CON DOS ESTADOS

JToogleButton es la clase base de los botones con dos estados.

JRadioButton (subclase de JToogleButton ) se utiliza para definir un grupo de botones de opción única.

Para agrupar botones de opción única, es necesario la clase ButtonGroup para agruparlos. Primero se crea un objeto ButtonGroup (constructor sin argumentos). A continuación, se añaden JRadioButton con el método de ButtonGroup, add(AbstractButton b).

Constructores de JRadioButton. JRadioButton(). JRadioButton(String mensaje). JRadioButton(String mensaje, boolean selecion);

Algunos métodos: public boolean isSelected(). public void setSelected(boolean flag).


JCheckBox (subclase de JToogleButton ) se utiliza para definir un casillas de verificación .

Constructores de JCheckBox . JCheckBox(). JCheckBox(String mensaje). crea casilla de verificación con texto

inicial. JCheckBox(String mensaje, boolean selecion);

Algunos métodos: public boolean isSelected(). public void setSelected(boolean flag).

Casillas de verificación

Listas desplegables, JComboBox

JComboBox se utiliza para crear una lista desplegable, a la que se pueden agregar opciones, editarlas, seleccionar una opción.

Constructores de JComboBox . JComboBox(); JComboBox(Object lista[])


JComboBox

Algunos métodos: public void addItem(Object q). public insertItemAt(Object q, int indice). public void setEditable(boolean flag). Permite teclear opción public void setMaximumRowCount(int n). Pone el máximo de

opciones. public void actionPerformed(ActionEvent ev). public void addActionListener(ActionListener ae). public void addItemListener(ItemListener it). public void addStateChanged(ItemEvent ev). public Object getSelectedItem(). Devuelve el elemento

seleccionado.


EJEMPLO CON BOTONES

Una aplicación ofrece al usuario la posibilidad de elegir tipos de transporte. La elección de "avión" despliega un combobox.

El código que se pone a continuación no está completo; se pueden añadir eventos para realizar más selecciones.


import java.awt.*;


class MarcoJRadio extends JPanel

{

ButtonGroup grb;

JRadioButton jr1, jr2, jr3;

/** constructor MarcoPrueba */

MarcoJradio.java(I) (agrupa botones de radio en un panel)


MarcoJradio.java(II) (agrupa botones de radio en un panel)

public MarcoJRadio()

{

grb = new ButtonGroup();

setLayout(new GridLayout(4,1));

add (new JLabel(" Selección excluyente"));

// se crea botón de radio,y seañade al panel y a la agrupación

jr1 = new JRadioButton("Avion", false);

add(jr1);

grb.add(jr1);


jr2 = new JRadioButton("Tren", false);

add(jr2);

grb.add(jr2);


jr3 = new JRadioButton("Coche", false);

add(jr3);

grb.add(jr3);


MarcoJradio.java(III) (agrupa botones de radio en un panel)

jr1.addActionListener(new ActionListener() // oyente: objetos anónimos

{

public void actionPerformed (ActionEvent evento)

{

/*jr1.setBackground(Color.RED); setVisible(false);*/

new MarcoParaJRadio(new PanelJCombo());

}

}

);

jr2.addActionListener(new ActionListener()

{

public void actionPerformed (ActionEvent evento)

{

/*jr1.setBackground(Color.RED);setVisible(false);*/

new MarcoParaJRadio(new PanelLista());

}

}

);

}

}


MarcoParaJradio.java(I)


import java.awt.*;


public class MarcoParaJRadio extends JFrame

{

static MarcoParaJRadio mr;

public MarcoParaJRadio(MarcoJRadio mr)

{

Container pc;


setTitle("Ejemplo de botones excluyentes");

pc.setLayout(new FlowLayout());

pc.add(mr);

pack();setSize(400,300);

setVisible(true);

//setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

}


MarcoParaJradio.java(II)

public MarcoParaJRadio(PanelJCombo la)

{

Container pc;


setTitle("Ejemplo de comboBox");


pc.add(la);

pack();setSize(400,300);

setVisible(true);

// setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

}

public MarcoParaJRadio(PanelLista la)

{

Container pc;


setTitle("Ejemplo de lista");


pc.add(la); pack();setSize(400,300);

setVisible(true);

}


MarcoParaJradio.java(III)


{

// MarcoParaJRadio mr;

//m.setVisible(true);

mr = new MarcoParaJRadio(new MarcoJRadio());

// mr.setVisible(true);

// mr.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

mr.addWindowListener(new WindowAdapter()

{

public void windowClosing(WindowEvent e) {System.exit(0);}

public void windowDeactivated(WindowEvent e){mr.dispose();}

});

}

}


PanelJCombo.java(I) (combox, crea lista desplegable)

import java.io.*;


import java.awt.*;


class PanelJCombo extends JPanel

{

private JComboBox jcb;

public PanelJCombo()

{

jcb = new JComboBox();

setLayout(new BorderLayout());

jcb.addItem("MAD - BCN"); jcb.addItem("MAD - AGP");jcb.addItem("MAD - XRY");

jcb.addItem("BRU - TFN"); jcb.addItem("LEN - BCN");jcb.addItem("ROM - BCN");

jcb.setMaximumRowCount(4);

add(jcb,BorderLayout.NORTH);


PanelJCombo.java(II) (combox, crea lista desplegable)

// oyentes: objeto anónimo

jcb.addItemListener(new ItemListener()

{

public void itemStateChanged (ItemEvent evento)

{

add(new JLabel("Muchas gracias"), BorderLayout.SOUTH);

//jcb.setEditable(true);

revalidate(); //para validar y que se pueda ver

/// new MarcoParaJRadio(new MarcoJRadio());

}

}

);

}

}


PanelLista.java(I) (lista de tipo JList)

import java.io.*;


import java.awt.*;


class PanelLista extends JPanel

{

private JList jl;

public PanelLista()

{

String [] lt = {"AVE", "CERCANIAS", "REGIONAL","EXPRESO","CREMALLERA",

"VIA corta","RADIAL","TALGO"};

jl = new JList(lt);

setLayout(new BorderLayout());

jl.setVisibleRowCount(4);

jl.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);

JScrollPane pa = new JScrollPane(jl);

add(pa,BorderLayout.EAST);


PanelLista.java(II) (lista de tipo JList)

/* jl.addItemListener(new ItemListener()

{

public void itemStateChanged (ItemEvent evento)

{

add(new JLabel("Muchas gracias"), BorderLayout.SOUTH);

//jcb.setEditable(true);

revalidate(); //para validar y que se pueda ver

/// new MarcoParaJRadio(new MarcoJRadio());

}

}

);*/

}

}


CAMPOS DE TEXTO

La clase abstracta JTextComponent (javax.swing.text) agrupa las características comunes de los campos de texto.

JTextComponent

JTextField JEditorPane

JPasswordField

JTextArea

JTextPane


JTextField, JPasswordField

JTextField es una clase que respresenta un campo de texto de una línea.

JPasswordField deriva de JTextField; es un componente que representa una línea cuyos caracteres están ocultos. Por omisión, cada carácter de un JPasswordField se reemplaza por *.

Constructores. JTextField(). campo de texto vacío, de 0

columnas JTextField(int cols); JTextField(String mensaje). JTextField(String mensaje,int col);

Algunos métodos: public String getText(); public void setText(String m). public void setEditable(boolean f); editable, o no. public void setFont(Font tipo). public void setHorizontalAlignment(int alig); alineacción del

texto: SwingConstants.RIGHT(LEFT, CENTER, TRAILING). public void addActionListener(ActionListener ae). public void setEchoChar(char c); método de JPasswordField:

establece a c el carácter que enmascara cada carácter del campo de texto.


JTextArea

JTextArea se utiliza con el fin de colocar muchas líneas de texto.

Constructores. JTextArea(). JTextArea(int filas,int cols); JTextArea(String t). JTextArea(String t,int filas, int col);

Algunos métodos: public void append(String t); añade al final public void insert(String t,int p); inserta t a partir de p public void setColumns(int cols) public void setLineWrap(boolean f); activa salto automático línea public void setWrapStyleWord(boolean f); no rompe palabras en

el salto de línea En swing el area de texto no tiene barra de desplazmiento. Para asociar una

barra de desplazmiento, se pone el area de texto en un JScollPane: area = new JTextArea() ...

JScrollPane br = new JScrollPane(area);

marco.add(br) la barra aparece automáticamente si faltan líneas por visualizar.


EJEMPLO Campos de texto

Selecciona un archivo de texto de un dialogo creado con la clase JFileChooser. El archivo seleccionado se lee línea a lína, poniendo cada línea en un área de texto (JTextArea). El componente área de texto se pone en una barra de desplazamiento para poder visualizar el texto completo.

Además, la aplicación que se escribe nos muestra cómo utilizar un "filtro" y un objeto seleccionador de ficheros.

import java.io.*;


import javax.swing.filechooser.FileFilter;

import java.awt.*;

import java.util.*;

MarcoJFileChooser.java(I) (crea un selector de archivo; lee el archivo de texto y cada lína se añade a un área de texto)


class FiltroText extends FileFilter

{

public boolean accept(File d)

{

boolean sw;

String nm;

nm = d.getName().toLowerCase();

sw =nm.endsWith(".java") || nm.endsWith(".txt") ||

d.isDirectory();

return sw;

}

public String getDescription()

{

return "archivos de texto, o código fuente java";

}

}

MarcoJFileChooser.java(II) (clase filtro, establece los elementos a seleccionar)


public class MarcoJFileChooser extends JFrame{

/** Creates a new instance of MarcoJFileChooser */

public MarcoJFileChooser()

{

setTitle("Ventana principal para selección de un archivo");

Toolkit kt = Toolkit.getDefaultToolkit();

Dimension tam = kt.getScreenSize();

int a = tam.height;

int w = tam.width;

this.setSize(w, a);

//this.setLocation(w/4, a/4);

/* Image im = kt.getImage("icon.gif");

panC.setIconImage(im); */

// panC.setLayout(new FlowLayout());

}

MarcoJFileChooser.java(III) (clase principal, crea el marco y el selector de archivos)


static public void main (String [] a) throws Exception

{

MarcoJFileChooser marco = new MarcoJFileChooser();

JFileChooser jf = null;

// crea objeto selector y el directorio actual

jf = new JFileChooser();

jf.setCurrentDirectory(new File("."));

//jf.setSelectedFile(new File("..."));

// para poder seleccionar archivos o path

jf.setFileSelectionMode(JFileChooser.FILES_AND_DIRECTORIES);

jf.setFileFilter(new FiltroText());

int res = jf.showOpenDialog(marco);// botones Abrir y Cancelar

// int res = jf.showSaveDialog(marco); //botones Guardar y Cancelar

// int r2 = jf.showDialog(marco, "Run"); // botones Run y Cancelar

MarcoJFileChooser.java(IV) (clase principal, método main: establece path actual, modo de selección y filtro; además abre un cuadro de diálogo)


if (res == JFileChooser.APPROVE_OPTION)

{

JTextField jte = null;

JLabel lab = null;

JTextArea area = null;

File s = jf.getSelectedFile();

String path, nom;

path = s.getPath();

nom = s.getName();

// se muestra en pantalla(output)

System.out.println(" Selección: " + path + nom);

if (s.isDirectory())

{

jte = new JTextField(path + nom);

lab = new JLabel(" Carpeta seleccionada");

marco.getContentPane().setLayout(new BorderLayout(5, 5));

marco.getContentPane().add(BorderLayout.NORTH, lab);

marco.getContentPane().add(jte);

marco.pack();

}

MarcoJFileChooser.java(V) (opción "Abrir" del cuadro de diálogo: obtiene el elemento seleccionado, selecciona si es un directorio ....)


else {

marco.getContentPane().setLayout(new FlowLayout(FlowLayout.CENTER,5, 5));

area = new JTextArea();

area.setColumns(30); // numero de columnas a utilizar

area.setRows(20);

area.setLineWrap(true); // salto automático de línea

area.setWrapStyleWord(true); // salto de línea sin cortar palabra

JScrollPane desplaz = new JScrollPane(area);

String cd; int i = 1;

BufferedReader en = new BufferedReader(new

InputStreamReader(new FileInputStream(s)));

while ((cd = en.readLine()) != null)

area.append(cd + "\n");

// se pone el area de texto

marco.getContentPane().add(desplaz); marco.pack();

}

marco.setVisible(true);

marco.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

}

} // fin de main()

} // fin de la clase

MarcoJFileChooser.java(VI) (en caso contrario es un archivo .; crea un flujo de texto ...)


EVENTOS


EVENTOS

Un evento es un suceso que ocurre en un sistema. Una acción realizada sobre algún componente.

El modelo de eventos de la interfaz gráfica es el modelo de eventos propuesto en AWT

La captura de eventos de una interfaz gráfica tiene varias partes: Implementar una clase “oyente” (un Listener) que rastrea los eventos producidos

dentro de ella. La interfaz Listener presenta una serie de clases adecuadas al tipo de evento y tipo de objeto

a rastrear.

Agregar a cada componente del que se quiera rastrear eventos un “oyente” de esa interfaz.

Implementar los métodos de la interfaz para ejecutar las acciones.

Hay que considerar 3 objetos: Objeto fuente del envento (botón, campo de texto, ...) Objeto evento, del tipo xxxEvent (ActionEvent,..., clase base Event): Objeto oyente, que monitoriza y responde (implementa un interfaz de tipo Listener)


GESTION DE EVENTOS Para la gestión de eventos será necesario:

• Crear un objeto oyente que implemente algún inteface de tipo Listener

• Asociar el objeto oyente al componente origen de evento; para lo que llama al método: componenteOrigen.addEventoListener(objeto oyente).

• Implementar los métodos del interface Listener. Cada tipo de Listener dispone de un conjunto de métodos.

Al producirse un evento, el objeto fuente crea el correspondiente objeto evento (por ejemplo, para un botón: ActionEvent). A continuación, se envía un mensaje, una notificación, al objeto oyente. El mensaje es la llamada a un método (para el botón, actionPerformed(ActionEvent a)) con el argumento el objeto evento creado.

La acción, o acciones, a realizar como respuesta al evento se codifican en el método al que se llama (actionPerformed() para un botón).

El oyente o monitor del evento es un objeto que implementa un Listener. El componente fuente se asocia al oyente con un método add; por ejemplo, el siguiente marco es a la vez el oyonte de un componente botón:

class MiMarco extends JFrame implements ActionListener {... boton.addActionListener(this);

...

public void actionPerformed(ActionEvent evento) { ...}


OYENTE DE EVENTOS Un objeto para ser oyente de un componente ha de implementar un interface

de tipo Listener.

Hay tres formas de declarar el oyente:

• Declarar una nueva clase como oyente, que implemente el Listener.

class Oyente implements ActionListener {...

• Directamente crear un objeto anónimo que implemente el Listener.

• El contenedor (Marco, panel) declare que implementa el Listener.

class MarcoPpal extends JFrame implements ActionListener {...

Siempre será necesario registrar, o asociar, el objeto oyente al componente. Enviando este el mensaje addxxxListener(oyente). para ser oyente de un componente ha de implementar un interface de tipo Listener. Para un botón y para cada forma de declaración del oyente:

• boton.addActionListener(new Oyente());

• boton.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent evento) { ...}

}

• boton.addActionListener(this);


JERARQUIA DE EVENTOS Todos los eventos descienden de EventObject (java.util). Esta clase dispone del

método Object getSource() que devuelve una referencia al objeto en el cual se ha producido el evento.

EventObject

AWTEvent

ActionEvent AdjustmentEvent ComponentEvent ItemEvent TextEvent

KeyEventMouseEvent

.....


Eventos y componentes

Componente Eventos generados Significado

JButton ActionEvent Hacer clic en el botón

JCheckBox ItemEvent Seleccionar o deseleccionar un item

JCheckboxMenuItem ItemEvent Seleccionar o deseleccionar un item

Choice ItemEvent Seleccionar o deseleccionar un item

Container ContainerEvent Añadir o eliminar un componente de un container

JList ActionEvent Hacer dobleclick sobre un item de la lista

JList ItemEvent Seleccionar o deseleccionar un item de la lista

JMenuItem ActionEvent Seleccionar un item de un menú

Scrollbar AdjustementEvent Cambiar el valor de la scrollbar

JTextComponent TextEvent Cambiar el texto

JTextField ActionEvent Terminar de editar un texto pulsando Intro

Window WindowEvent Acciones sobre una ventana: abrir, cerrar, iconizar, restablecer e iniciar el cierre

ComponentEvent Mover, cambiar tamaño, mostrar u ocultar un componente

FocusEvent Obtener o perder el focus

KeyEvent Pulsar o soltar una tecla

MouseEvent Pulsar o soltar un botón del ratón; entrar o salir de un componente; mover o arrastrar el ratón


Eventos, oyentes y métodos

Evento Interface Listener Métodos de Listener

ActionEvent ActionListener actionPerformed()

AdjustementEvent AdjustementListener adjustementValueChanged()

ComponentEvent ComponentListener componentHidden(), componentMoved(), componentResized(), componentShown()

ContainerEvent ContainerListener componentAdded(), componentRemoved()

FocusEvent FocusListener focusGained(), focusLost()

ItemEvent ItemListener itemStateChanged()

KeyEvent KeyListener keyPressed(), keyReleased(), keyTyped()

MouseEvent MouseListener mouseClicked(), mouseEntered(), mouseExited(), mousePressed(),mouseReleased()

MouseMotionListener mouseDragged(), mouseMoved()

TextEvent TextListener textValueChanged()

WindowEvent WindowListener windowActivated(), windowDeactivated(), windowClosed(), windowClosing(), windowIconified(), windowDeiconified(), windowOpened()


Adaptadores (I)

Si el “oyente” tiene muchos métodos, puede ser complicada la implementación completa de una interfaz Listener (por ejemplo para la interfaz WindowListener).

Algunos oyentes tienen adaptadores que implementan métodos por omisión vacíos para todos los métodos de la interfaz.

Para utilizarlos sólo habría que incluir un oyente utilizando el adaptador adecuado y sobrescribir sólo los métodos necesarios. class MiWindowListener extends WindowAdapter{…}

ComponentAdapter, ContainerAdaptar, FocusAdapter, KeyAdapter, MouseAdapter, MouseMotionAdapter y WindowAdapter.


Adaptadores (II) Ejemplo:

import java.awt.*;import java.awt.event.*;import javax.swing.*;

class MiWindowAdapter extends WindowAdapter{ public void windowClosing(WindowEvent e){ System.exit(0); } } public class UnDialogo extends JDialog{

static final int ANCHO = 300;static final int ALTO= 300;public UnDialogo()

{super(new JFrame() ,"Mi Diálogo");

this.addWindowListener(new MiWindowAdapter());setSize(ANCHO,ALTO);setVisible(true);

} public static void main(String args[]) { new UnDialogo(); }}