Construcción de Interfaces Gráficas de Usuarios en JAVA
CONSTRUCCIÓN DE INTERFACES GRÁFICAS DE USUARIO (GUI)
Swing
Swing es un conjunto de clases desarrolladas por primera vez para Java 1.2 para reemplazar el paquete anterior que se utilizaba para programar interfaces gráficas de usuarios: el AWT (Abstract Windows Tools).
Tanto Swing como AWT forman parte de una colección de clases llamadas JFC (Java Fundation Classes), que incluyen paquetes dedicados a la programación de interfaces gráficas.
AWT tenía varios problemas:
- era incompatibles con algunos sistemas,
- le faltaban algunos componentes avanzados
- consumía muchos recursos del sistema
Swing aporta muchas más clases, consume menos recursos y construye mejor apariencia de los programas.
Todas las clases de Swing está en el paquete javax.swing. Dentro de este paquete hay otros con sus especificidades.
Componentes
Los componentes son los elementos básicos de programación con Swing. Todo lo que se ve en una interfaz gráfica de Java es un componente. Los componentes se colocan en otros elementos llamados contenedores que sirve para agrupar componentes. Un administrador de diseño se encarga de disponer la presentación de los componentes en un dispositivo de presentación concreto.
Por ejemplo:
en la figura se ilustran algunas de las componentes que se pueden poner en una ventana, utilizando Swing.
La clase JComponent es la clase ancestro de todas los componentes de Swing, a su vez JComponent hereda de Container (una clase de AWT) y esta de Component (también de AWT). De aquí se ve que Swing es una extensión de AWT.
La clase Component de AWT tiene algunos métodos que son heredados e importantes:
La clase JComponent hereda de Component todos estos métodos para controlar la apariencia del componente: visibilidad, tamaño, posición, color, tipo de letra, etc. Al dibujar un componente se le asigna un dispositivo de presentación. Además posee métodos que controlan el comportamiento del componente. Cuando el usuario hace algo sobre ella se produce un evento, del cual se hablará más adelante.
Los objetos java.awt.Color representan colores y se pueden construir de la siguiente forma:
Color(int rojo, int verde, int azul)
Construye un color indicando los niveles de rojo, verde, azul.
Color(int RGB)
Construye un color indicado un único valor que indica los niveles de rojo, verde, azul. Se suele emplear un número en hexadecimal con 6 dígitos. Ejemplo oxFFCC33.
Esta clase tiene además definidas una series de constantes que representan los colores más usuales, están declaradas estáticas y con el nombre del color en inglés.
Asi Color.RED representa el color Rojo, Color.WHITE representa el color blanco, etc.
Estos son objetos que se pueden pasar a los métodos que manejan el color.
Contenedores
Son un tipo de componentes que sirven para contener a otros componente. Los objetos JComponent pueden ser contenedores al descender de la clase Container que es la clase de objetos contenedores de AWT.
Para hacer que un componente sea parte de un contenedor se utiliza el método add, mientras que el método remove es el encargado de quitar el componente del contenedor.
Swing posee algunos contenedores especiales:
JFrame: Objeto que presenta una ventana típica, con bordes, botones para cerrar, etc.
Constructores:
JFrame() – crea un ventana vacía.
JFrame(String título) – crea un ventana con el título indicado
JWindow: Representa una ventana sin bordes, ni elementos visibles. Suelen estar dentro de objetos JFrame.
JWindow() – crea una ventana independiente.
JWindow(JFrame padre) – crea una ventana dentro de un JFrame.
JWindow(JWindow padre) – crea una ventana dentro de otra ventana.
JPanel: Contenedor genérico para agrupar componentes.
JDialog: Ventana especial que representa un cuadro de diálogo.
JApplet: Contenedor especial que representa una ventana que será mostrada en un navegador.
La clase JFrame tiene algunos métodos interesantes, que aunque algunos no son propiamente definidos en esta clase son útiles:
Ejemplo:
Para crear una ventana que tenga el título “Swing” se puede hacer:
import javax.swing.*;
public class TestPanel {
public static void main(String[] args) {
JFrame ventana = new JFrame(”Swing”);
ventana.setSize(200,200);
ventana.setLocation(100,100);
ventana.setVisible(true);
}
}
Observar que dentro de un método main, se crea un objeto de tipo JFrame, se dan las magnitudes que se desea que tenga, se localiza en un lugar determinado y se dice que es visible.
Esto muestra una ventana así:
En la posición 100, 100 de la pantalla. El 0,0 se considera en la esquina, superior izquierda de la pantalla.
Una aplicación con Interfaz gráfica de Usuario, siempre debe tener un objeto JFrame ( o uno de sus descendientes) que sea el contenedor principal.
Paneles
Los paneles son elementos interiores a los contenedores que permiten gestionar su contenido.
La clase JFrame no tiene el método add para añadir componentes a la ventana, hay que utilizar el método getContentPane() que devuelve un objeto tipo Container que representa el área visible de la ventana y entonces a este objeto si se le pueden añadir componentes.
Clase JPanel
Esta clase es la clase básica contenedora de Swing, se puede usar para dibujar componentes y luego añadirsela al objeto de tipo Container que se obtiene con el método getContentPane().
import javax.swing.*;
import java.awt.*;
public class TestPanel {
public static void main(String[] args) {
JPanel jp=new JPanel();
// se crea un panel de 200×200 de color rojo
jp.setBackground(Color.RED);
jp.setSize(200,200);
// se crea la ventana localizada en 100,100
// y de tamaño 200 x 200
JFrame ventana = new JFrame(”Swing”);
ventana.setLocation(100,100);
ventana.setSize(200,200);
Container c=ventana.getContentPane();
// se añade el panel
c.add(jp);
ventana.setVisible(true);
}
}
La ventana que se obtienen, presenta la siguiente apariencia:
Etiquetas
Son textos para dar información estáticas en las ventanas (y applets). Se basan en la clase JLabel.
Constructores
JLabel(String texto) Crea una etiqueta con una cadena dada.
Estas etiquetas se pueden añadir al panel para luego ponerla en la ventana:
import javax.swing.*;
import java.awt.*;
public class TestPanel {
public static void main(String[] args) {
JPanel jp=new JPanel();
// se crea un panel de 200×200 de color rojo
jp.setBackground(Color.RED);
jp.setSize(200,200);
// crear etiqueta
JLabel etiq=new JLabel(”Hola!!”);
// añadir la etiqueta al panel
jp.add(etiq);
// se crea la ventana localizada en 100,100
// y de tamaño 200 x 200
JFrame ventana = new JFrame(”Swing”);
ventana.setLocation(100,100);
ventana.setSize(200,200);
Container c=ventana.getContentPane();
// se añade el panel
c.add(jp);
ventana.setVisible(true);
}
}
Con esto pueden entender que hacen los IDEs para progamación en java como NetBeans o Eclipse a la hora de crear las ventanas o casos de usos de su aplicación web.