Swin01

Java - Interfaz Gráfico de Usuario (GUI)
Creación de interfaces con JFC/Swing [I]
La Güeb de Joaquín 1
La Güeb de Joaquín
Programación JAVA
INTERFAZ GRÁFICO DE USUARIO
1 - Creacion de interfaces con JFC/Swing [I]
Referencia Bibliográfica
Autor Adolfo Aladró Garcia
Publicado en la revista Solo Programadores num 117
Ejemplos copiados del libro
Java 2 - Curso de Programacion
Fco. Javier Ceballos. RA-MA
Sumario
JFC/Swing representa el API de Java orientado a diseñar interfaces de usuario
multiplataforma de forma rápida. Con JFC/Swing las aplicaciones y Applets Java pueden
presentar un aspecto profesional y estándar, compitiendo así con las aplicaciones tradicionales
que se ejecutan en entornas gráficos.
Indice de Contenidos
1 - Creacion de interfaces con JFC/Swing [I]
1.1 Introducción a JFC/SWING
1.1.1 Componentes
1.1.2 Contenedores
1.1.3 Administradores de diseño
1.1.4 Eventos
1.2 Primera aplicación completa
1.2.1 Esqueleto típico de una aplicación JFC/Swing
1.3 Segunda aplicación completa
1.4 Conclusiones
1.1 Introducción a JFC/SWING
La colección de utilidades que proporciona la plataforma Java para desarrollar interfaces de
usuario es lo que se conoce como Swing. El paquete javax.swing contiene clases que se
corresponden con elementos de interfaz típicos tales como etiquetas, botones, barras de
desplazamiento, áreas de dibujo, etc. Al mismo tiempo Swing forma parte de otro software
llamado JFC (Java Foundation Classes) que está formado por los siguientes elementos:

La Güeb de Joaquín2
• AWT (Abstract Window Toolkit), la colección primigenia para desarrollar interfaces
de usuario. En la actualidad incluye también el API que proporciona soporte para
operaciones del tipo "arrastrar y soltar".
• Java 2D, el conjunto de clases para realizar dibujos de alta calidad.
• Swing, la nueva colección de herramientas para desarrollar interfaces de usuario.
• Accesibility, los API que garantizan que una aplicación Java es utilizable por personas
con discapacidades.
• Internationalization, el soporte para crear aplicaciones válidas para cualquier usuario
del mundo, adaptándose a las particularidades del idioma y las convenciones
culturales.
Todos estos API permiten crear aplicaciones y Applets Java de forma estándar y que además
pueden ejecutarse en cualquier plataforma que disponga de la máquina virtual Java
(Windows, Mac, Unix, Linux, etc.).
Si bien JFC/Swing es una de las partes más complicadas de Java, crear interfaces avanzadas
es una tarea relativamente sencilla ya que se trabaja con componentes ya desarrollados (áreas
de texto, botones, etc.). La distribución de los componentes dentro de los contenedores, así
como su tamaño y colocación, es responsabilidad de los administradores de diseño. Éstos
definen una estrategia de forma que garantizan que una interfaz se mostrará de forma correcta
con independencia de la plataforma o incluso cuando el usuario modifique el tamaño de la
ventana.
1.1.1 Componentes
En Java un componente es el elemento más importante de la interfaz de usuario. Todos los
elementos que aparecen en una aplicación Java son componentes. Por lo general a cada
componente le corresponde una clase y todas estas clases se obtienen a partir de la clase
abstracta javax.swing.JComponent. El listado 1 muestra la jerarquía de clases de la que
depende la clase javax.swing.JLabel, que representa a una etiqueta, uno de los componentes
más típicos y fundamentales.
Listado 1
java.lang.Object
I
+--java.awt.Component
I
+--java.awt.Container
I
+--javax.swing.Jcomponent
I
+--javax.swing.Jlabel
Como se puede observar si se asciende por el árbol de clases llegamos hasta los paquetes de
AWT, la colección de clases originaria para desarrollar interfaces. En cierto sentido se puede
afirmar que JFC/Swing no es más que una extensión de AWT
Los métodos y propiedades de un componente controlan la apariencia general de un objeto
(visibilidad, tamaño, ubicación, colores, etc.). En el siguiente ejemplo se define un botón y
posteriormente se modifica el tipo de letra y el color de la misma con los métodos setFont y
setForeground respectivamente:

JButton btnAceptar = new JButton("Aceptar");
btnAceptar.setFont(new Font("Courrier New", Font.BOLD, 24));
btnAceptar.setForeground(new Color(255, 0, 0));
En realidad estos dos métodos, así como muchos otros, se definen en la clase
javax.swing.JComponent y todos los componentes los heredan.
Los componentes también cuentan con métodos y propiedades que sirven para gestionar el
comportamiento del componente, o lo que es lo mismo, la interacción con el usuario. Cuando
un usuario realiza una acción se genera un evento que el componente recibe. Existen objetos
que se encargan de gestionar esos eventos y que se han configurado como tales gestores desde
el propio componente. El fragmento de código del listado 2 define un botón, un componente
de tipo JButton, y emplea el método addActionListerner de la clase
javax.swing.AbstractButton para registrar un objeto que implementa la interfaz
java.awt.event.ActionListener y que es en última instancia el responsable de gestionar el
evento que se produce cuando un usuario hace clic en el botón.
Listado 2
// Crear un botón
Jbutton botón = new JButton("Haga clic aquí");
// Establecer como tecla aceleradora la C. Entonces, pulsar Alt+C
// será equivalente ha hacer clic, sobre el botón.
botón.setMnemonic(KeyEvent.VK_C);
// Asignar al botón una descripción abreviada
botón.setToolTipText("botón de pulsación");
// Permitir que el botón responda a los eventos de acción
ActionListener al =
new ActionListener()
{
// Este método se ejecutará cuando se haga clic en "botón"
public void actionPerformed(ActionEvent evento)
{
Object obj = evento.getSource();
if (obj == botón)
mostrarMensaje();
}
};
botón.addActionListener(al);
El objeto perteneciente a la clase java.awt.event.ActionEvent representa al evento. El método
getSource, que a su vez hereda de la clase java.util.EventObject, devuelve el objeto al que le
llegó el evento, o si se prefiere, que desencadenó el evento. Más adelante se estudiarán los
eventos dentro de la aplicación y Applets JFC/Swing ya que se trata de un tema tan
importante como confuso, al menos al principio, cuando se empiezan a desarrollar interfaces
por primera vez.
1.1.2 Contenedores
Un contenedor es un tipo especial de componente que sirve para agrupar a otros componentes.
Todo objeto perteneciente a la clase JComponent puede ser un contenedor tal y como muestra
la herencia de clases del listado 3.

Listado 3
java.lang.Object
I
+--java.awt.Component
I
+--java.awt.Container
I
+--javax.swing.Jcomponent
Los contenedores clásicos se corresponden con las clases javax.swing.Jframe,
javax.swing.JPanel y javax.swing.JApplet. Un JFrame es una ventana de alto nivel. Un JPanel
es un contenedor genérico que sirve para agrupar componentes. Una interfaz puede tener
varios contenedores de tipo JPanel que a su vez pueden agrupar contenedores JPanel, todo
dentro de una ventana, típicamente un contenedor JFrame. Por último. un contenedor JApplet
se emplea para crear Applets Java.
La clase java.awt.Container contiene varios métodos add. Todo ellos sirven para añadir
elementos al contenedor. De esta forma los contenedores mantienen una lista de los
componentes que agrupan. En el ejemplo del listado 4 se define un contenedor de tipo JPane
que agrupa una colección de botones
Listado 4
// Crear un panel para colocar los controles
JPanel panel = new JPanel();
// Introducimos un borde sin pintar alrededor de los controles:
// createEmptyBorder(top, left, bottom, right)
panel.setBorder(BorderFactory.createEmptyBorder(20, 20, 20, 20));
// Establecer un administrador de diseño de cuadrícula
panel.setLayout(new GridLayout(0, 1));
// Los controles se añaden en columna (filas = 0)
// Se añaden na etiqueta y un boton definidos previamente
panel.add(etiqueta);
panel.add(botón);
// Añadir los componentes al contenedor de la aplicación
// -------------------------------------------------
// Ayuda sobre getContentPane
// public Container getContentPane()
// Returns the contentPane object for this frame.
// -------------------------------------------------
getContentPane().add(panel, BorderLayout.CENTER);
// Permitir que la ventana de la aplicación responda a los
// eventos de ventana (p.e. cerrar la ventana)
addWindowListener(
new WindowAdapter()
{
public void windowClosing(WindowEvent evento)
{
cerrarVentana();
// funcion que se encarga de cerrar la ventana
// Puedes verla en el ejmplo completo
}
} );

1.1.3 Administradores de diseño
Los administradores de diseño son los responsables de la presentación (tamaño y ubicación)
de los componentes que se agrupan dentro de un mismo contenedor. Todos los contenedores
tienen un administrador de diseño por defecto. El método getLayout definido en la clase
java.awt.Container devuelve el objeto correspondiente con el administrador de diseño.
Asimismo el método setLayout permite asignar un nuevo administrador de diseño.
FlowLayout
Por ejemplo, el administrador de diseño que emplea el componente JPanel por defecto es el
que se corresponde con la clase java.awt.FlowLayout Éste intenta colocar los objetos de
izquierda a derecha y de arriba abajo dentro del contenedor, tratando además de respetar para
todos ellos el tamaño preferido. Por lo tanto, en el ejemplo del apartado anterior los botones
se presentan uno seguido detrás de otro, de izquierda a derecha y de arriba abajo, y el tamaño
de los mismos trata de ser simplemente el que ocupa el texto de su etiqueta, es decir, el
preferido o el natural, si se prefiere. Ahora bien, se puede modificar el administrador de
diseño tal y como se muestra a continuación:
jPanel MijPanel = new JPanel();
BoxLayout MiboxLayout = new BoxLayout (MijPanel, BoxLayout.Y_AXIS);
MijPanel.setLayout(MiboxLayout);
BoxLayout
El administrador javax.swing.BoxLayout agrupa los elementos entorno a un eje (horizontal o
vertical). Como consecuencia del cambio anterior los botones aparecerían uno debajo de otro
siguiendo un eje vertical.
1.1.4 Eventos
Un evento es lo que sucede cuando, por ejemplo, un usuario lleva a cabo cualquier acción en
la interfaz (hacer clic en un botón, seleccionar un elemento de una lista, escribir en un campo
de texto, etc.). Los eventos se generan desde un componente y son enviados a uno o más
gestores de evento que son los responsables últimos de su tratamiento. Las clases
correspondientes a los distintos eventos que pueden darse en una interfaz extienden a la clase
java.util.EventObject (véase el listado 5).
Listado 5
java.lang.Object
I
+-- java.util.EventObject
I
+-- java.awt.AWTEvent
I
+-- java.awt.event.ActionEvent

java.lang.Object
I
+-- java.util.EventObject
I
+-- java.awt.AWTEvent
I
+-- java.awt.event.ComponentEvent
I
+-- java.awt.event.InputEvent
I
+-- java.awt.event.MouseEvent
Las clases java.awt.eventActionEvent y java.awt.eventMouseEvent se corresponden con dos
de los eventos más comunes en todas las interfaces. La primera representa una acción llevaba
a cabo por el usuario, como por ejemplo pulsar un botón. La segunda clase representa a los
eventos que se producen cuando el usuario emplea el ratón.
Los gestores de eventos reciben los objetos correspondientes al evento producido y realizan
las acciones que en cada caso se consideren oportunas. Las clases correspondientes a los
gestores de eventos deben implementar una determinada interfaz dependiendo del tipo de
evento. Por ejemplo, cuando un usuario pulsa un botón o hace clic en él se genera un evento
del tipo ActionEvent. El gestor de este tipo de evento tiene que corresponderse
necesariamente con una clase que implemente a la interfaz java.awt.eventActionListener.
Todas las interfaces de gestión de eventos proceden de la interfaz java.utiI.EventListener.
Algunas de las más comunes son MouseListener o FocusListerner. En el ejemplo del listado 6
se crea una etiqueta (JLabel), otro de los componentes más comunes de las interfaces.
Seguidamente se emplea el método addMouseListener para indicar cuál es el objeto
responsable de la gestión del evento MouseEvent. Este objeto es a su vez una instancia de una
nueva clase que implementa la interfaz MouseListerner. Cuando el usuario hace clic en la
etiqueta o pasa por encima se muestra el correspondiente mensaje por la consola.
Listado 6
JLabel lblEtiqueta = new JLabel("Etiqueta");
lblEtiqueta.addMouseListener(new MouseListener()
{
public void mouseClicked(MouseEvent e)
{
System.out.println("mouseClicked... ");
}
public void mousePressed(MouseEvent e)
{
System.out.println("mousePressed... ");
}
public void mouseReleased(MouseEvent e)
{
System. out. println ("mouseReleased. . . ") ;
}

public void mouseEntered(MouseEvent e)
{
System.out.println("mouseEntered... ");
}
public void mouseExited(MouseEvent e)
{
System. out .println ("mouseExited. . .") ;
}
}
};
En la mayor parte de las aplicaciones los gestores de eventos no necesitan gestionar todos los
eventos que reciben. Siguiendo con el ejemplo anterior, con frecuencia sólo será necesario
implementar algunos de los métodos de la interfaz MouseListerner. Sin embargo como se
trata de una interfaz es obligatorio escribirlos todos, aunque estén vacíos. Para evitar esta
situación, entre otras muchas ventajas que se irán desvelando más adelante, la gestión de
eventos cuenta con lo que se denomina como adaptadores. Los adaptadores son clases de
ayuda que implementan los interfaces como MouseListerner y que pueden emplearse para la
gestión de eventos.
El listado 7 codifica una nueva versión del ejemplo anterior y emplea la clase MouseAdapter
para implementar la gestión de eventos de forma que solamente se trata el evento que se
desencadena cuando el usuario hace clic en la etiqueta.
Listado 7
lblEtiqueta.addMouseListener(new MouseAdapter()
{
public void mouseClicked(MouseEvent e)
{
System. out. println ("mouseClicked. . . ") ;
}
}
};
1.2 Primera aplicación completa
Hasta el momento se han visto los fundamentos de las interfaces JFC/Swing. A lo largo de
esta serie de artículos se profundizarán en cada uno de los aspectos destacados (componentes,
contenedores, administradores de diseños y eventos) pero sin duda alguna la mejor manera de
aprender es haciendo aplicaciones.
1.2.1 Esqueleto típico de una aplicación JFC/Swing
Una aplicación JFC/Swing típica es una clase que extiende a la clase javax.swing.JFrame. Por
ejemplo:

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
public class JApplication1
extends JFrame
{
. . .
}
El constructor de la clase JApplicationl es el responsable de crear los componentes,
agruparlos dentro de contenedores empleando para ello los administradores de diseño que
considere oportunos, establecer las clases que gestionarán los eventos que reciben los
componentes, etc. En este ejemplo la aplicación simplemente abrirá una ventana en la que
mostrará una imagen. El único evento que hay que gestionar es el que se produce cuando el
usuario hace clic para cerrar la aplicación. En la clase Japplication1 se han definido las
siguientes propiedades o atributos:
int iWidth = 640;
int iHeight = 480;
ImageIcon imageIcon;
Los dos primeros almacenan respectivamente la anchura y la altura que se quiere dar a la
ventana de la aplicación. El tercero es un objeto perteneciente a la clase
javax.swing.ImageIcon que se empleará para leer la imagen una única vez al comienzo de la
aplicación.
El constructor comienza de la siguiente forma:
public JApplication1()
{
super("Introducción a la creación de interfaces" +
" con JFC/Swing (1 de 4)");
setSize(iWidth, iHeight);
imageIcon = new ImageIcon("DSCN0055.JPG");
}
En la primera línea se establece la cadena de texto que dará título a la ventana principal. Para
ello se llama al constructor de la clase superior, JFrame. Seguidamente el método setSize se
utiliza para determinar la anchura y la altura de la ventana. Finalmente se crea una instancia
de la clase ImageIcon, lo que en última instancia es lo mismo que decir que se lee la imagen.
Para presentar la imagen vamos a crear un componente específico que no será más que una
pequeña modificación de la clase javax.swing.JPanel, pero antes de crearlo y añadirlo a la
ventana principal de la aplicación es preciso obtener el contenedor asociado a dicha ventana.
Esto se logra empleando el método getContentPane:
Container contentPane = getContentPane();
El método add sirve para añadir un componente al contenedor. En este ejemplo el componente
en cuestión es una modificación de un componente JPanel para el que se ha reescrito el
método paintComponent (véase el listado 8).

Listado 8
contentPane.add(
new JPanel()
{
protected void paintComponent(Graphics g)
{
g.drawImage(
imageIcon.getImage(),
0,
0,
getSize().width,
getSize().height,
0,
0,
imageIcon.getIconWidth(),
imageIcon.getIconHeight(),
this
);
}
}
);
El método paintComponent de un componente es llamado por el interfaz de usuario de forma
automática cada vez que determina que el componente ha de ser "pintado", Esto sucede, por
ejemplo, cuando la ventana de la aplicación se presenta por primera vez o cuando el usuario
cambia el tamaño de la misma, En este ejemplo el componente lo único que va a hacer es
mostrar la imagen que previamente se ha cargado mediante la clase ImageIcon, ocupando
todo el espacio disponible. La clase java.awt.Graphics cuenta con un conjunto de métodos
para dibujar todo tipo de formas básicas y entre ellos está drawImage, que sirve para presentar
imágenes. El método drawImage está sobrescrito de muchas formas distintas pero en este
ejemplo se emplea una definición del mismo que permite dibujar la imagen original en un
área destino de manera que la ocupe por completo. El primer parámetro es el objeto de tipo
java.awt.Image que representa a la imagen. Los cuatro siguientes parámetros son los puntos
(dxl ,dyl) Y (dx2,dy2) que se corresponden con la esquina superior izquierda y la esquina
inferior derecha del área de destino. A continuación los cuatro siguientes parámetros son los
puntos (sxl.sy1) y (sx2.sy2) que se corresponden con la esquina superior izquierda y la
esquina inferior derecha del fragmento de la imagen que se va a dibujar en el área destino. El
último parámetro es el objeto a que el interfaz notificará los cambios. Al utilizar
getSize().width y getSize().height para definir el punto (dx2,dy2) se garantiza que el área
destino de dibujo siempre va a ser tan grande como el propio componente en ese momento.
Del mismo modo, al emplear imageIcon.getIconWidth() y imageIcon.getIconHeight() para
definir el punto (sx2,sy2) se garantiza que el fragmento que se dibuja es toda la imagen.
Hasta el momento lo único que se ha escrito es la definición de la clase JApplication1. El
último paso que falta para tener una aplicación completa es el método main. Este método
puede verse en el listado 9.

Listado 9
public static void main(String[] args)
{
JFrame jFrame = new JApplication1();
jFrame.addWindowListener(
new WindowAdapter()
{
public void windowClosing(WindowEvent e)
{
System.exit(0);
}
}
);
jFrame.setVisible(true);
}
En primer lugar se crea una instancia de la clase JApplication 1. Seguidamente se crea una
instancia de la clase java.awt.event.WindowAdapter que será la responsable de gestionar los
eventos relacionados con la ventana que reciba la aplicación. El método addWindowListemer
del componente establece cuál es el gestor para dicho componente para ése tipo de evento. El
método windowClosing se ejecutará cuando el usuario haga clic en el icono correspondiente
de cerrar la ventana y en ese momento se ejecutará System.exit(0) con lo que la aplicación se
cerrará. Por último, la llamada al método setVisible(true) hace que la ventana se muestre y
con ella todos los componentes definidos en el contendor principal.
A parir de la aplicación resultante se puede introducir una pequeña mejora consistente en
hacer que la aplicación se cierra simplemente pulsando la tecla Esc. Para ello es preciso
configurar un nuevo gestor de eventos, concretamente uno encargado de procesar para ese
componente los eventos generados por las pulsaciones del teclado (véase el listado 10).
Listado 10
jFrame.addKeyListener(
new KeyAdapter()
{
public void keyPressed(KeyEvent e)
{
if (e.getKeyCode() == KeyEvent.VK_ESCAPE) {
System.exit(0);
}
}
}
);
El método keyPressed de la clase java.awt.event.KeyAdapter se ejecutará cada vez que el
usuario pulse una tecla teniendo la aplicación activa en primer plano. El objeto perteneciente a
la clase java.awt.event.KeyEvent guarda toda la información concerniente al evento y el
método getKeyCode, por ejemplo, devuelve el código correspondiente a la tecla pulsada. La
propia clase KeyEvent define una serie de teclas estándar de manera que
KeyEvent.VK_ESCAPE representa a la tecla ESC. Cuando se detecta que el usuario ha
pulsado esta tecla se cierra la aplicación System.exit(0), igual que en el caso anterior.

Listado Codigo Completo
1 import javax.swing.*;
2
3 import java.awt.*;
4 import java.awt.event.*;
5
6 class JApplication1
7 extends JFrame
8 {
9 int iWidth = 640;
10 int iHeight = 480;
11
12 ImageIcon imageIcon;
13
14 public JApplication1()
15 {
16 super("Introducción a la creación de interfaces" +
" con JFC/Swing (1 de 4)");
17 setSize(iWidth, iHeight);
18
19 imageIcon = new ImageIcon("DSCN0055.JPG");
20
21 Container contentPane = getContentPane();
22 contentPane.add(
23 new JPanel()
24 {
25 protected void paintComponent(Graphics g)
26 {
27 g.drawImage(
28 imageIcon.getImage(),
29 0,
30 0,
31 getSize().width,
32 getSize().height,
33 0,
34 0,
35 imageIcon.getIconWidth(),
36 imageIcon.getIconHeight(),
37 this
38 );
39 }
40 }
41 );
42 }
43
44 public static void main(String[] args)
45 {
46 JFrame jFrame = new JApplication1();
47 jFrame.addWindowListener(
48 new WindowAdapter()
49 {
50 public void windowClosing(WindowEvent e)
51 {
52 System.exit(0);
53 }
54 }
55 );

56 jFrame.addKeyListener(
57 new KeyAdapter()
58 {
59 public void keyPressed(KeyEvent e)
60 {
61 if (e.getKeyCode() == KeyEvent.VK_ESCAPE) {
62 System.exit(0);
63 }
64 }
65 }
66 );
67 jFrame.setVisible(true);
68 }
69 }
70
1.3 Segunda aplicación completa
A continuacion hay otro ejemplo completo y sencillo de creacion de una aplcacion AWT
Listado Codigo Ejemplo 2
1 import javax.swing.*;
2 import java.awt.*;
3 import java.awt.event.*;
4
5 public class AplicacionSwing extends JFrame
6 {
7 // Referencias a los componentes
8 private JLabel etiqueta;
9 private JButton botón;
10
11 // Otras referencias
12 private static String mensaje = "¡¡¡Hola mundo!!!";
13
14 private AplicacionSwing(String título) // constructor
15 {
16 super(título); // título de la ventana principal
17 iniciarComponentes();
18 // Ajustar el tamaño de la ventana al mínimo
19 pack();
20 }
21
22 private void iniciarComponentes()
23 {
24 // Crear una etiqueta con el texto centrado
25 etiqueta = new JLabel();
26 etiqueta.setHorizontalAlignment(JLabel.CENTER);
27
28 // Crear un botón
29 botón = new JButton("Haga clic aquí");
30 // Establecer como tecla aceleradora la C. Entonces, pulsar
31 // Alt+C será equivalente ha hacer clic, sobre el botón.
32 botón.setMnemonic(KeyEvent.VK_C);
33 // Asignar al botón una descripción abreviada
34 botón.setToolTipText("botón de pulsación");
35 // Permitir que el botón responda a los eventos de acción

36 ActionListener al =
37 new ActionListener()
38 {
39 // Este método se ejecutará cuando
// se haga clic en "botón"
40 public void actionPerformed(ActionEvent evento)
41 {
42 Object obj = evento.getSource();
43 if (obj == botón)
44 mostrarMensaje();
45 }
46 };
47 botón.addActionListener(al);
48
49 // Crear un panel para colocar los controles
50 JPanel panel = new JPanel();
51 // Introducimos un borde sin pintar alrededor de los controles:
52 // createEmptyBorder(top, left, bottom, right)
53 panel.setBorder(BorderFactory.createEmptyBorder(
20, 20, 20, 20));
54 // Establecer un administrador de diseño de cuadrícula
55 panel.setLayout(new GridLayout(0, 1));
56 // Los controles se añaden en columna (filas = 0)
57 panel.add(etiqueta);
58 panel.add(botón);
59
60 // Añadir los componentes al contenedor de la aplicación
61 getContentPane().add(panel, BorderLayout.CENTER);
62
63 // Permitir que la ventana de la aplicación responda a los
64 // eventos de ventana (p.e. cerrar la ventana)
65 addWindowListener(
66 new WindowAdapter()
67 {
68 public void windowClosing(WindowEvent evento)
69 {
70 cerrarVentana();
71 }
72 } );
73 }
74
75 private void mostrarMensaje()
76 {
77 // Mostrar el "mensaje" en la "etiqueta"
78 etiqueta.setText(mensaje);
79 }
80
81 private void cerrarVentana()
82 {
83 // Salir de la aplicación
84 System.exit(0);
85 }
86
87 public static void main(String[] args)
88 {
89 try
90 {
91 // Aspecto y percepción de la interfaz gráfica
92 UIManager.setLookAndFeel(
93 UIManager.getCrossPlatformLookAndFeelClassName());
94 }

95 catch (Exception e)
96 {
97 System.out.println("No se pudo establecer" +
" el aspecto deseado: " + e);
98 }
99 AplicacionSwing vPpal =
new AplicacionSwing("Aplicación Swing");
100 vPpal.show();
101 }
102 }
1.4 Conclusiones
En este capítulo se han introducido los fundamentos de la creación de interfaces con
JFCjSwing. Quedan muchos aspectos por estudiar, entre los que destacan el manejo de los
distintos tipos de componentes, la gestión eficaz de los eventos y el uso de los
administradores de diseño. No en vano JFCjSwing es probablemente uno de las partes más
sofisticadas y complejas de la plataforma Java. Si bien al principio la creación de interfaces
con JFCjSwing puede resultar una tarea compleja e incluso pesada, más adelante se
comprobará que una vez adquiridos los conceptos básicos resulta muy sencillo ir
desarrollando paulatinamente interfaces cada vez más sofisticados y profesionales.

Swin01

Más contenido relacionado

La actualidad más candente (20)

Destacado (18)

Similar a Swin01 (20)

Más de Robert Wolf (20)

Swin01