Java Swing 2: Crear ventanas con Eclipse

Para éste microtutorial he usado el Swing Designer de Eclipse y la versión 1.7 update 9 de Java, el JDK y el JRE.

En Eclipse tenemos tenemos varias opciones para generar código esqueleto para nuestro programa. En la ventana del explorador de proyectos, en el lugar elegido le damos con el botón derecho a New -> Other… y nos saldrá una ventana como la siguiente con las opciones disponibles con respecto a Swing:

En el árbol de Swing Designer tenemos las opciones para crear programas con ventanas Swing, valga la redundancia. Todos los códigos generados con el Swing Designer también se pueden crear a mano y se pueden llevar a otros entornos de desarrollo y te van a funcionar. Ésto lo digo porque no ocurre siempre, según en qué entorno de desarrollo estés, a veces pasa que si te sales de él ya no te sirven los códigos porque se les han puesto «extras» que te atan a ellos. Ésto no te va a pasar con los Swing en Eclipse, o por lo menos yo no me encontrado con éste problema.

Vamos al grano…

Application Window

Si elegimos una Application Window nos va a crear la clase siguiente:

package pruebasSwing;

import java.awt.EventQueue;
import javax.swing.JFrame;

public class ApplicationWindowPrueba {

    private JFrame frame;

    // primero se ejecuta ésto…
    public static void main(String[] args) {
        // en un hilo de ejecución aparte hace todo
        // porque todo lo hace en un new Runnable
        // a continuación…
        EventQueue.invokeLater(new Runnable() {
            // run es el método que se ejecuta
            // al arrancar el hilo
            public void run() {
                try {
                    // crea una variable de la clase y se inicializa
                    // con el constructor de la misma                  
                    ApplicationWindowPrueba window = new ApplicationWindowPrueba();
                    // muestra la ventana
                    window.frame.setVisible(true);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
    }

    // éste es el constructor de la clase
    public ApplicationWindowPrueba() {
        initialize();
    }

    // la función que inicializa
    private void initialize() {
        // crea el frame
        frame = new JFrame();
        // coordenadas de la ventana
        frame.setBounds(100, 100, 450, 300);
        // establece la operación a ejecutar cuando
        // se cierra el JFrame
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }

}

Se trata de una clase que no hereda de ninguna otra, y lo que simplemente hace es crear un JFrame en un hilo de ejecución separado.

JApplet

Un Applet es una programa de Java que se ejecuta en un navegador de Internet. Éste programa se le envía al cliente mientras que navega y se ejecuta en su máquina. Nos crea lo básico para hacer uno, pero a fecha de hoy están totalmente en desuso y los navegadores los desactivan por defecto.. Así que mejor ni probarlo…

package pruebasSwing;

import javax.swing.JApplet;

// clase que extiende de JApplet,
// que a su vez extiende de la clase
// Applet y ésta en sí es un Panel…
public class JAppletPrueba extends JApplet {

    // el constructor
    public JAppletPrueba() {

    }
}

JDialog

Con ésta opción generaremos el código para hacer un típico cuadro de diálogo con el usuario para que se le informe de algo o elija entre las opciones que queramos. Éste tipo de ventanas se usan asociadas a otra ventana padre, aunque al tener un main se puede generar un .jar ejecutable que sólo tenga un cuadro de diálogo de éstos.

El código que genera:

package pruebasSwing;

import java.awt.BorderLayout;
import java.awt.FlowLayout;

import javax.swing.JButton;
import javax.swing.JDialog;
import javax.swing.JPanel;
import javax.swing.border.EmptyBorder;

// la clase que extiende de JDialog,
// que a su vez extiende de Dialog,
// y ésta de Window…
public class JDialogPrueba extends JDialog {

    private final JPanel contentPanel = new JPanel();

    public static void main(String[] args) {
        try {
            // crea un nuevo objeto de la clase
            JDialogPrueba dialog = new JDialogPrueba();
            // operacion al cerrar
            dialog.setDefaultCloseOperation(JDialog.DISPOSE_ON_CLOSE);
            // lo muestra
            dialog.setVisible(true);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    // constructor de la clase
    public JDialogPrueba() {
        // propiedades de la ventana
        setBounds(100, 100, 450, 300);
        getContentPane().setLayout(new BorderLayout());
        contentPanel.setLayout(new FlowLayout());
        contentPanel.setBorder(new EmptyBorder(5, 5, 5, 5));
        getContentPane().add(contentPanel, BorderLayout.CENTER);
       
        // los botones para confirmar o cancelar
        {
            JPanel buttonPane = new JPanel();
            buttonPane.setLayout(new FlowLayout(FlowLayout.RIGHT));
            getContentPane().add(buttonPane, BorderLayout.SOUTH);
            {
                JButton okButton = new JButton(«OK»);
                okButton.setActionCommand(«OK»);
                buttonPane.add(okButton);
                getRootPane().setDefaultButton(okButton);
            }
            {
                JButton cancelButton = new JButton(«Cancel»);
                cancelButton.setActionCommand(«Cancel»);
                buttonPane.add(cancelButton);
            }
        }
    }

}

JFrame

Con el asistente del JFrame, hace casi lo mismo que con el de Application Window, pero hay dos ligeras diferencias. La primera es que con Application Window tenemos una variable interna a la clase que es el JFrame, y con el éste lo que tenemos es que la clase misma extiende a JFrame, con lo que realmente tenemos un JFrame en sí que se puede reutilizar en otros lugares del programa. La segunda diferencia es que añade un JPanel al JFrame, cosa que con el asistente de Application Window no lo hace.

El código es el siguiente:

package pruebasSwing;

import java.awt.BorderLayout;
import java.awt.EventQueue;

import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.border.EmptyBorder;

// la clase extiende de JFrame, realmente ES un JFrame
public class JFramePrueba extends JFrame {

    private JPanel contentPane;

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

    public JFramePrueba() {
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setBounds(100, 100, 450, 300);
        // añade el panel…
        contentPane = new JPanel();
        contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
        contentPane.setLayout(new BorderLayout(0, 0));
        setContentPane(contentPane);
    }

}

JInternalFrame

Ésta clase se usa para hacer ventanas que se ejecutan dentro de un JDesktopPane. Es decir, dentro de la misma ventana padre, tendremos una zona que será un panel de escritorio, el anterior JDesktopPane. Y en éste panel es donde veremos el JInternalFrame. Así que necesitaremos un JFrame padre para poder ejecutarlo dentro.

Ésta clase tiene un main pero no se puede ejecutar en un .jar aparte.

El código:

package pruebasSwing;

import java.awt.EventQueue;
import javax.swing.JInternalFrame;

public class JInternalFramePrueba extends JInternalFrame {

    // arranca en un hilo el formulario hijo
    public static void main(String[] args) {
        EventQueue.invokeLater(new Runnable() {
            public void run() {
                try {
                    JInternalFrame frame = new JInternalFrame();
                    frame.setVisible(true);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
    }

    // aquí estará construida la ventana
    public JInternalFramePrueba() {
        setBounds(100, 100, 450, 300);

    }

}

JPanel

Ésto es una clase básica que podemos usar en otros formularios o ventanas. Es decir, podemos poner paneles dentro de JFrames. Así que puede ser útil tener un panel programado aparte. El código que genera es:

package pruebasSwing;

import javax.swing.JPanel;

public class JPanelPrueba extends JPanel {

    // constructor de la clase
    public JPanelPrueba() {

    }

}

Swing Automatic Databinding

Aquí tenemos un asistente que nos va a crear lo necesario para crear una ventana con Databindings. Necesitaremos un Bean, y configurar las diversas opciones. Ésto es bastante extenso así que ya tengo tema para otro post.. 🙂

Terminando

Las principales clases que primero se van a usar van a ser la ApplicationWindow o la JFrame. De éstas la JFrame es bueno usarla de un principio porque luego la puede incluir dentro de otros proyectos sin muchos cambios.

Dentro de Eclipse podemos visualizar todos los anteriores con F11, menos el JInternalFrame y el JPanel que se podrá visualizar dentro de otro. Una vez generado el código correspondiente, podremos entrar a editar el diseño visualmente, con lo que nos ahorraremos un considerable esfuerzo.

Con ésto me voy a la cama y mañana más…

Un saludo!