Home | Clases | Interfaces de usuario con Java Swing | Componentes JFrame, JLabel y JDialog: Diálogos modales

Componentes JFrame, JLabel y JDialog: Diálogos modales


JFrame y JLabel

Si bien utilizar la paleta de ayuda de Netbeans resulta muy útil, es preciso definir cómo funcionan los componentes de interfaces visuales de Swing para, más adelante, poder desarrollar aplicaciones más complejas. Para ello realizaremos un primer ejemplo de creación de interfaces pero sin utilizar la paleta. Para ello creamos un nuevo proyecto Java en Netbeans con una clase principal e incorporamos el siguiente código.

Ejemplo 4: Crear un JFrame con un texto que diga "Hola Mundo"

/* Las componentes Swing hay que importarlas del paquete javax.swing. Cuando debemos importar varias componentes de un paquete es más conveniente utilizar el asterisco que indicar cada clase a importar.*/
import javax.swing.*;

/* La clase JFrame encapsula el concepto de una ventana, para implementar una aplicación que muestre una ventana debemos plantear una clase que herede de la clase JFrame */
public class Formulario extends JFrame{

/* Definimos un objeto JLabel para la etiqueta. */
private JLabel label1;

/* En el constructor de la clase llamamos al método heredado de la clase JFrame llamado setLayout y le pasamos como parámetro un valor null, con esto estamos informándole a la clase JFrame que utilizaremos posicionamiento absoluto para los controles visuales dentro del JFrame*/
public Formulario() {

setLayout(null);

/* Creamos el objeto de la clase JLabel y le pasamos como parámetro al constructor el texto a mostrar.*/
label1=new JLabel("Hola Mundo.");

/* Ubicamos al objeto de la clase JLabel llamando al método setBounds, este requiere como parámetros la columna, fila, ancho y alto del JLabel. Finalmente llamamos al método add (metodo heredado de la clase JFrame) que tiene como objetivo añadir el control JLabel al control JFrame */
label1.setBounds(10,20,200,30);
add(label1);
}

/* En el método main creamos un objeto de la clase Formulario, llamamos al método setBounds para ubicar y dar tamaño al control y mediante el método setVisible hacemos visible el JFrame */
public static void main(String[] args) {

Formulario formulario1=new Formulario();
formulario1.setBounds(10,10,400,300);
formulario1.setVisible(true);
}

}


JDialog: Diálogos modales

Cuando nuestra aplicación necesita más de una ventana, debemos utilizar ventanas secundarias mediante el componente JDialog.

Un JFrame no admite a ninguna otra ventana como padre. El JDialog sí admite como padres un JFrame u otros JDialog. Esto es importante porque una ventana hija siempre quedará por encima de su ventana padre. Si al crear los JDialog les pasamos el JFrame como padre o parent, los JDialog siempre estarán visibles por encima del JFrame. No se podrán ir "detrás" de él.

Si además, en el constructor del JDialog ponemos a true el flag que indica que es modal, además de pasarle una ventana padre, entonces el JDialog impedirá el acceso a las otras ventanas hasta que se cierre.

Ejemplo 5: Crear una ventana con un botón que lleve a otra ventana e impida que se abran nuevas ventanas hasta que se cierre la anterior. Éste sería el código del JFrame:

/* Importo las clases necesarias */
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.*;

/* Nuevo JFrame que implementa el interface ActionListener */
public class Formulario extends JFrame implements ActionListener{

/* Declaro variables */
private JButton boton1;
private JLabel label1;

/* Constructor */
public Formulario() {

/* Layout absoluto */
setLayout(null);

//Etiqueta
label1 = new JLabel("Esta es la ventana principal");
label1.setBounds(115,60,200,30);
add(label1);

//Botón
boton1 = new JButton("Haz clic aquí");
boton1.setBounds(105,110,200,40);
add(boton1);

/* Inicializo escuchador del botón */
boton1.addActionListener(this);

}

/* Método que implementa la acción del botón */
public void actionPerformed(ActionEvent e) {
if (e.getSource() == boton1) {
/* Inicializo y muestro la segunda pantalla con los argumentos this (JFrame) y true (modal) */
Secundaria secundaria = new Secundaria(this,true);
secundaria.setVisible(true);
}
}

/* Incializo el formulario */
public static void main(String[] args) {
Formulario formulario1=new Formulario();
formulario1.setBounds(10,10,410,210);
formulario1.setVisible(true);
}
}


Y éste sería el correspondiente al JDialog.

/* Importo las clases necesarias */
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JDialog;
import javax.swing.JLabel;

/* Nuevo JDialog que implementa el interface ActionListener */
public class Secundaria extends JDialog implements ActionListener{

/* Declaro variables */
private JButton boton2;
private JLabel label1;

/* Constructor que recibe el JFrame Formulario como parent y el modal */
public Secundaria(Formulario parent, boolean modal) {

/* Invoco al constructor de la clase superior */
super(parent, modal);

/* Layout absoluto y límites*/
setLayout(null);
setBounds(440,10,410,210);

//Etiqueta
label1 = new JLabel("Esta es la ventana secundaria");
label1.setBounds(115,60,200,30);
add(label1);

//Botón
boton2 = new JButton("Volver");
boton2.setBounds(105,110,200,40);
add(boton2);

/* Inicializo escuchador del botón */
boton2.addActionListener(this);

}

/* Método que implementa la acción del botón */
public void actionPerformed(ActionEvent e) {
if (e.getSource() == boton2) {
//Cierro la pantalla
setVisible(false);
}
}

}


Prueba ahora a cambiar el valor de modal a false y comprueba que puedes abrir tantas ventanas secundarias como quieras.

Ejercicios propuestos:

  • Crear una ventana de 1024 píxeles por 800 píxeles. Luego no permitir que el operador modifique el tamaño de la ventana. Sabiendo que hacemos visible al JFrame llamando la método setVisible pasando el valor true, existe otro método llamado setResizable que también requiere como parámetro un valor true o false.
  • Crear tres objetos de la clase JLabel, ubicarlos uno debajo de otro y mostrar nombres de personas.
  • Disponer dos objetos de la clase JButton con las etiquetas: "carne" y "pescado", al presionarse cada botón abrir una nueva ventana que muestre la opción elegida, no permitiendo elegir otra opción mientras no se cierre la anterior.


Fuente: Wikipedia y Diego Moisset. tutorialesprogramacionya.com

Fecha de publicación: 18/09/2020
Asignaturas: desarrollo de interfaces
Temas: interfaces usuario usabilidad
Utilizamos cookies propias y de terceros para mejorar su experiencia en la navegación. Al seguir navegando entendemos que acepta su uso.
Si lo desea, consulte nuestras políticas de privacidad y cookies
ENTENDIDO
[X] Cerrar

Contacta conmigo


[X] Cerrar

Acceso alumnos