Bautista Durán Estephania
Checkbox
La versión Swing soporta botones checkbox con la clase JCheckBox. Swing también soporta checkboxes en menus, utilizando la clase JCheckBoxMenuItem. Como JCheckBox y JCheckBoxMenuItem descienden de AbstractButton, los checkboxes de Swing tienen todas las características de un botón normal como se explicó en Cómo usar Buttons. Por ejemplo, podemos especificar imágenes para ser utilizadas en los checkboxes.
Los Checkboxes son similares a los botones de radio, pero su modelo de selección es diferente, por convención. Cualquier número de checkboxes en un grupo -- ninguno, alguno o todos -- pueden ser seleccionados. Por otro lado, en un grupo de botones de rádio, sólo puede haber uno seleccionado.
Nota: En Swing 1.0.2, los botones ignoran sus mnemónicos (teclas aceleradoras). Este bug se corrigió en Swing 1.0.3.
Constructores: Hay cinco constructores de CheckBox
1.Checkbox () -> Crea una casilla de verificación con una cadena vacía para su etiqueta.
2.Checkbox (etiqueta String, boolean state) -> Crea una casilla de verificación con la etiqueta especificada y establece el estado especificado.
3.Checkbox (etiqueta String) -> Crea una casilla de verificación con la etiqueta especificada.
4.Checkbox (etiqueta String, boolean state, CheckboxGroup grupo) -> Crea una casilla de verificación con la etiqueta especificada, ajuste en el estado especificado, y en el grupo de casilla de verificación especificado.
5.Checkbox (etiqueta String, CheckboxGroup grupo, booleano estado) -> Crea una casilla de verificación con la etiqueta especificada, en el grupo de casilla de verificación especificado y establece en el estado especificado.
Este componente (casilla de activación en la paleta Swing) se utiliza frecuentemente como botón de estado. Proporciona información del tipo Sí o No (true o false), el argumento es de tipo booleano: verdadero (true) si la caja está seleccionada y falso (false) en otro caso.
Empezaré con una simple creación de casilla de verificación de Java Swing. Las casillas de verificación se crean en su apogeo por la creación de la instancia de la clase JCheckBox utilizando su constructor que contiene la cadena que se debe mostrar junto a la casilla de verificación en el marco o ventana como esta:
CÓDIGO:
import javax.swing.*;
// Especifica al compilador en donde se ubica el paquete completo javax.swing
public class Checkbox{
// Declaración de clase
public static void main(String[] args){
// En una clase se definen uno o más métodos
JFrame frame = new JFrame("Check Box Frame");
// Este comando sirve para crear una ventana, se entiende también como un contendedor (es decir, primero creamos un objeto de la clase JFrame para poder después introducir, botones, listas, cajas de texto, etc.), Para esta clase podemos acceder a sus propiedades como: titulo, ancho, alto, color, entre otros.
JCheckBox chk = new JCheckBox("Esto es un checkbox");
// el constructor creara los checkbox deseados y les asignaras un nombre
frame.add(chk);
// Lo que entrará en la ventana, en este caso el checkbox con su nombre
frame.setSize(400, 400);
// las medidas de la ventana
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
// Crea componentes para ponerlos en la ventana y que se ha concluido
frame.setVisible(true);
// Mostrar la elección del argumento True.
}
}
Concluyendo la realización del programa nos aparecerá lo siguiente al correr el programa.
Este programa es muy básico, pero podemos realizar más complejos como el siguiente:
CÓDIGO:
import javax.swing.*;
import javax.swing.event.*;
// Eventos lanzados por componentes Swing, así como oyentes para dichos eventos. Extiende los que se encuentran en el paquete AWT java.awt.event.
public class Formulario extends JFrame implements ChangeListener{
// Lo primero y más importante que tenemos que notar que para capturar el cambio de estado del JCheckBox hay que implementar la interface ChangeListener que se encuentra en el paquete.
private JCheckBox check1,check2,check3;
// Definimos tres objetos de la clase JCheckBox.
public Formulario() {
setLayout(null);
check1=new JCheckBox("Promedio 1");
check1.setBounds(10,10,150,30);
check1.addChangeListener(this);
add(check1);
check2=new JCheckBox("Promedio 2");
check2.setBounds(10,50,150,30);
check2.addChangeListener(this);
add(check2);
check3=new JCheckBox("Promedio 3");
check3.setBounds(10,90,150,30);
check3.addChangeListener(this);
add(check3);
}
// En el constructor creamos cada uno de los objetos de la clase JCheckBox y llamamos al método addChangeListener indicando quien procesará el evento de cambio de estado.
public void stateChanged(ChangeEvent e){
// El método que debemos implementar de la interfaz ChangeListener.
String cad="";
if (check1.isSelected()==true) {
cad=cad+"Promedio 1-";
}
if (check2.isSelected()==true) {
cad=cad+"Promedio 2-";
}
if (check3.isSelected()==true) {
cad=cad+"Promedio 3-";
}
setTitle(cad);
}
// En este mediante tres if verificamos el estado de cada JCheckBox y concatenamos los String con los promedios seleccionados.
public static void main(String[] ar) {
Formulario formulario1=new Formulario();
formulario1.setBounds(0,0,300,200);
formulario1.setVisible(true);
}
}
Terminando el programa nos arroja lo siguiente:
Por ultimo un programa que disponer un control JLabel que muestre el siguiente mensaje: "Esta de acuerdo con las normas del servicio?", luego un JCheckBox y finalmente un objeto de tipo JButton desactivo. Cuando se tilde el JCheckBox debemos activar el botón.
CÓDIGO:
// Importamos los paquetes donde se encuentran las interfaces para captura de eventos de objetos de tipo JButton y JCheckBox.
import javax.swing.*;
// También importamos el paquete donde están definidas las clase JFrame, JButton y JCheckBox.
import javax.swing.event.*;
import java.awt.event.*;
public class Formulario2 extends JFrame implements ActionListener, ChangeListener{
// Como debemos implementar dos interfaces las debemos enumerar después de la palabra implements separadas por coma.
private JLabel label1;
private JCheckBox check1;
private JButton boton1;
// Definimos los tres objetos.
public Formulario2() {
setLayout(null);
label1=new JLabel("Esta de acuerdo con las normas del servicio?");
label1.setBounds(10,10,400,30);
add(label1);
// En el constructor creamos el objeto de tipo JLabel.
check1=new JCheckBox("Acepto");
check1.setBounds(10,50,100,30);
check1.addChangeListener(this);
add(check1);
// El objeto de tipo JCheckBox
boton1=new JButton("Continuar");
boton1.setBounds(10,100,100,30);
add(boton1);
boton1.addActionListener(this);
boton1.setEnabled(false);
// Y también creamos el objeto de tipo JButton y llamando al método setEnabled con un valor false luego el botón aparece desactivo
}
public void stateChanged(ChangeEvent e) {
if (check1.isSelected()==true) {
boton1.setEnabled(true);
} else {
boton1.setEnabled(false);
}
}
// Cuando se cambia el estado del control JCheckBox se ejecuta el método stateChanged donde verificamos si está seleccionado procediendo a activar el botón en caso negativo lo desactivamos.
public void actionPerformed(ActionEvent e) {
if (e.getSource()==boton1) {
System.exit(0);
}
}
// El método actionPerformed se ejecuta cuando se presiona el objeto de tipo JButton (debe estar activo para poder presionarlo).
public static void main(String[] ar) {
Formulario2 formulario1=new Formulario2();
formulario1.setBounds(0,0,350,200);
formulario1.setVisible(true);
}
}
Y el resultado del código es el siguiente:
(cuando le damos en aceptar , el botón se activa y al darle click finaliza el programa).
