¿Cómo agrupar y utilizar botones de opción en una GUI de java?
Saludos!
Continuando con esta serie sobre el uso de los controles gráficos básicos, en este post toca hablar sobre dos de ellos muy parecidos pero de comportamiento ligeramente diferente: los JRadioButton y los JCheckBox.
Pero antes me gustaría explicar un poco por qué es importante utilizar diversos controles al diseñar una aplicación.
Un control para cada entrada.
El control gráfico más básico, y también uno de los más útiles es el JTextField o caja de texto. Sin embargo, debemos utilizar los controles más convenientes que nos permitan cerrar el conjunto de datos que el usuario pueda proporcionar.
Por ejemplo, considera que dentro de la aplicación se requiere conocer la localidad donde vive un usuario. Si dejas que el usuario introduzca esta información en una caja de texto, podría suceder lo siguiente:
- Que el usuario escriba cualquier texto que no corresponda con el nombre de una localidad
- Podría escribir un nombre de localidad real pero con faltas de ortografía
- O no equivocarse y escribir correctamente lo solicitado.
Ahora piensa que de la localidad ingresada, realizarás una búsqueda en una base de datos. Obviamente los escenarios 1 y 2 arrojarán errores en la búsqueda, pues no se encontrarán esas “localidades” dentro de la base de datos.
Por ello es mejor cerrarle al usuario las posibilidades de equivocarse. Con el uso de un JComboBox, por ejemplo, podrías haberlo obligado a seleccionar una localidad de la lista, la cual contendrá los nombres correctos de las localidades, lo que después para realizar una búsqueda en alguna base de datos evitaría los problemas.
Entonces, aunque genere un poco más de esfuerzo para el programador, lo ideal será diseñar nuestra GUI con los controles gráficos más adecuados que ayuden a que el usuario se equivoque menos al introducir datos.
JCheckbox (Casillas de verificación)
La clase JCheckbox proporciona los atributos y métodos para implementar una casilla de verifiación que es básicamente un botón de dos estados. En la siguiente tabla se muestran los métodos más comunes de esta clase.
| Nombre y tipo del método | Función |
| boolean isSelected() | Devuelve true si el componente está seleccionado, en caso contrario devuelve false |
| boolean isEnabled() | Devuelve true si el componente está activo, en caso contrario, devuelve false |
| void setEnabled(boolean) | Habilita (true) o deshabilita (false) el objeto, en cuyo caso no puede ser seleccionado |
En la figura 1 se muestra un ejemplo de 3 objetos tipo JCkeckBox
Figura 1. Ejemplo de JCheckBox
En este caso, el método que nos permite tener acceso al valor seleccionado es isSelected(), el cual es el que nos regresa true si el objeto está seleccionado por el usuario o false si no lo está.
El comportamiento que caracteriza a este control y que es reconocido por los usuarios es la posibilidad de poder seleccionar varios objetos de este tipo, sin que sean excluyentes, por lo que al diseñar la GUI de nuestra aplicación debemos respetar las convenciones de uso ya establecidas universalmente y reconocidas por los usuarios.
A continuación te muestro el código correspondiente al botón Aceptar de la interfaz mostrada en la Figura 1.
1
2
3
4
5
6
7
8
9
10
11
12
|
private void botonAceptarActionPerformed(java.awt.event.ActionEvent evt) {
// Revisar si las casillas están seleccionadas.
boolean r1, r2, r3;
// Recuperamos el valor de las casillas de verificación
r1 = requisito1.isSelected(); //requisito1 es un JCheckBox
r2 = requisito2.isSelected();
r3 = requisito3.isSelected();
if ( r1 || r2 || r3 ) //Si cualquiera de las casillas está seleccionada
JOptionPane.showMessageDialog(this, "¡Felicidades! Tienes derecho a beca");
else
JOptionPane.showMessageDialog(this, "No cumples con los requisitos para recibir beca");
}
|
JRadioButton (Botones de opción)
La clase JRadioButton proporciona los atributos y métodos para implementar un botón de opción el cual es un botón de dos estados mutuamente excluyentes. En la figura 2 se muestra un ejemplo de objetos de esta clase.
Figura 2. Ejemplo de objetos de la clase JRadioButton
Cómo se mencionó, la principal característica de este control es ser mutuamente excluyente, esto quiere decir que, considerando el ejemplo de la figura 2, el usuario sólo puede seleccionar una de las dos alternativas, ya sea “Tengo 18 años o más” o “Tengo menos de 18 años”. Al momento de seleccionar alguna de las dos, la que estaba seleccionada pasa a no seleccionada y viceversa.
Mi recomendación es utilizar este tipo de botones para preguntas excluyentes, donde el usuario deba seleccionar una y sólo una opción de n opciones. Algunos ejemplos de estas preguntas son:
- Sexo ( femenino / masculino)
- Pertenecer o no a un rango de edad (como en el ejemplo de la figura 2)
- Practicar o no algún deporte
entre tantas otras que obliguen a seleccionar sólo una alternativa.
ButtonGroup.
Para lograr este comportamiento, no basta con agregar el control JRadioButton, sino que además es necesario agrupar los controles de este tipo en un ButtonGroup. La clase ButtonGroup se encuentra en la paleta de controles, en la categoría Swing Controls, tal y como se muestra en la figura 3.
Figura 3. El control Button Group en la categoría Swing Controls de la paleta.
ButtonGroup no es un control visible, por lo que no se mostrará en el JFrame.De hecho, en el panel Navigator tampoco se muestra como un control anclado al JFrame, sino que está categorizado como Otros Componentes (Other Components). Esto se aprecia en la figura 4.
Figura 4. Dos grupos de JRadioButton agrupados en dos ButtonGroup diferentes
Una vez creado el ButtonGroup, lo único que falta es agregar los JRadioButon al grupo de botones. Para esto, selecciona uno de los JRadioButton y usa la paleta Properties(Propiedades). Ahí se encuentra la propiedad buttonGroup, y dado que ya fué creado el grupo, al presionar la flecha de la lista se desplegará el nombre del grupo. Este proceso se observa en la figura 5.
Figura 5. Configurando la propiedad buttonGroup de un JRadioButton.
Si no se añaden los controles JRadioButton a un grupo, cada control será independiente, y tendremos el comportamiento no deseado (ni esperado por el usuario) de poder seleccionar los n botones de opción que se muestren en la interfaz.
Métodos de JRadioButton.
Los métodos relacionados con este control son los siguientes:
| Nombre del método | Función |
| boolean isSelected() | Devuelve true si el componente está seleccionado, en caso contrario devuelve false |
| boolean isEnabled() | Devuelve true si el componente está activo, en caso contrario, devuelve false |
| void setEnabled(boolean) | Habilita (true) o deshabilita (false) el objeto, en cuyo caso no puede ser seleccionado |
Como verás, los métodos son los mismos que se presentan en un control JCheckBox.
Para la interfaz que se muestra en la Figura 4, el siguiente es el código asociado al botón Continuar, en el cual se ejemplifica el uso de botones de opción:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
private void botonContinuarActionPerformed(java.awt.event.ActionEvent evt) {
// Pregunta si el aspirante tiene 18 años
boolean mayorDeEdad = false;
if ( edad1.isSelected()) // edad1 es un JRadioButton
mayorDeEdad = true;
else
if (edad2.isSelected()) // edad2 es un JRadioButton
mayorDeEdad = false;
if (mayorDeEdad){
// Habilita la segunda parte del cuestionario
java1.setEnabled(true);
java2.setEnabled(true);
botonAceptar.setEnabled(true);
jLabel3.setEnabled(true);
}
else
JOptionPane.showMessageDialog(this, "Gracias por participar");
|
Ejemplo de TableModel en JTable
Vamos a ver cómo utilizar un JTable de java. Pudes ver un applet de ejemplo y el código fuente.
Un JTable es un componente visual de java que nos permite dibujar una tabla, de forma que en cada fila/columna de la tabla podamos poner el dato que queramos; un nombre, un apellido, una edad, un número, etc, etc.
Como muchos componentes de java, se ha seguido una separación modelo-vista . La vista es el componente visual que vemos en pantalla, el modelo es una clase que contiene los datos que luego se verán en pantalla. El modelo de datos únicamente contiene los datos, nosabe nada de quién va a visulizar los datos ni como.
La forma más rápida y sencilla
DefaultTableModel modelo = new DefaultTableModel();
JTable tabla = new JTable (modelo);
A partir de ahora todo se maneja con el modelo. En cuanto añadamos, borremos o cambiemos datos del modelo, el JTable se enterará y actualizará automáticamente. El DefaultTableModel tiene todos los métodos necesarios para modificar datos en su interior, añadir filas o columnas y darle a cada columna el nombre que queramos
Vamos a hacer nuestro propio modelo de datos
El DefaultTableModel es un modelo genérico y puede no ser suficiente (o al menos, incómodo de usar) para nuestros propósitos.
Es bastante habitual el querer manejar la tabla como si fuera una lista, de forma que cada filacorresponde a una clase de datos y las columnas son los atributos de esaclase. Por ejemplo, queremos una lista de Persona y cada persona tiene unnombre, un apellido y una edad. Queremos pintar este lista en una tabla,de forma que tiene tres columnas (nombre, apellido y edad) y tantas filascomo Personas haya en la lista. A mi me gustaría tener un modelo alque le diga
modelo.anhadePersona (persona);
y no un
modelo.setValueAt (fila, columna, persona.nombre);
columna++;
modelo.setValueAt (fila, columna, persona.apellido);
columna++;
modelo.setValueAt (fila, columna, edad);
y algo parecido para obtener o borrar una persona dentro del modelo.
Por ello, a veces esmás cómodo implementar nuestros propios modelos de tabla. Lacosa es fácil, únicamente debemos implementar la interfaceTableModel y luego poner además todos losmétodos que queramos, como el anhadePersona() o el damePersona() mencionados antes.
Una clase que implemente un TableModel debe redefinir los siguientes métodos:
class MiModelo implements TableModel
{
public void addTableModelListener (TableModelListener l) {...}
public Class getColumnClass (int columIndex) {...}
public int getColumnCount() {...}
public String getColumnName (int columnIndex) {...}
public int getRowCount() {...}
public Object getValueAt (int rowIndex, int columnIndex) {...}
public boolean isCellEditable (int rowIndex, int columnIndex) {...}
public void removeTableModelListener (TableModelListener l) {...}
public void setValueAt (Object aValue, int rowIndex, int columnIndex)
}
ArrayList en Java, con ejemplos
La clase ArrayList en Java, es una clase que permite almacenar datos en memoria de forma similar a los Arrays, con la ventaja de que el numero de elementos que almacena, lo hace de forma dinámica, es decir, que no es necesario declarar su tamaño como pasa con los Arrays. Para todos aquellos que hayáis estudiado en alguna asignatura las estructuras de datos de las Pilas, Colas, Listas, Arboles (AVL, B, B+, B*) etc. hay decir que los ArrayList "tiran por tierra" toda la teoria que hay detrás de esas estructuras de datos ya que los ArrayList nos permiten añadir, eliminar y modificar elementos (que pueden ser objetos o elementos atómicos) de forma trasparente para el programador. Antes de pasar a explicar el manejo de los ArrayList, dejamos un enlace al JavaDoc, pulsando AQUI.
Antes de todo, decir que el código de todos los ejemplos que se ponen a continuación los podeis descargar pulsando AQUI.
Los principales métodos para trabajar con los ArrayList son los siguientes:
// Declaración de un ArrayList de "String". Puede ser de cualquier otro Elemento u Objeto (float, Boolean, Object, ...)
ArrayList<String> nombreArrayList = new ArrayList<String>();
// Añade el elemento al ArrayList
nombreArrayList.add("Elemento");
// Añade el elemento al ArrayList en la posición 'n'
nombreArrayList.add(n, "Elemento 2");
// Devuelve el numero de elementos del ArrayList
nombreArrayList.size();
// Devuelve el elemento que esta en la posición '2' del ArrayList
nombreArrayList.get(2);
// Comprueba se existe del elemento ('Elemento') que se le pasa como parametro
nombreArrayList.contains("Elemento");
// Devuelve la posición de la primera ocurrencia ('Elemento') en el ArrayList
nombreArrayList.indexOf("Elemento");
// Devuelve la posición de la última ocurrencia ('Elemento') en el ArrayList
nombreArrayList.lastIndexOf("Elemento");
// Borra el elemento de la posición '5' del ArrayList
nombreArrayList.remove(5);
// Borra la primera ocurrencia del 'Elemento' que se le pasa como parametro.
nombreArrayList.remove("Elemento");
//Borra todos los elementos de ArrayList
nombreArrayList.clear();
// Devuelve True si el ArrayList esta vacio. Sino Devuelve False
nombreArrayList.isEmpty();
// Copiar un ArrayList
ArrayList arrayListCopia = (ArrayList) nombreArrayList.clone();
// Pasa el ArrayList a un Array
Object[] array = nombreArrayList.toArray();
Otra cosa muy importante a la hora de trabajar con los ArrayList son los "Iteradores" (Iterator). Los Iteradores sirven para recorrer los ArrayList y poder trabajar con ellos. Los Iteradores solo tienen tres métodos que son el "hasNext()" para comprobar que siguen quedando elementos en el iterador, el "next()" para que nos de el siguiente elemento del iterador; y el "remove()" que sirve para eliminar el elemento del Iterador.
Bueno, si esto no te ha quedado muy claro, pasamos a poner el primer ejemplo. En el siguiente fragmento de código, declaramos un ArrayList de Strings y lo rellenamos con 10 Strings (Elemento i). Esto lo hacemos con el método "add()". Después añadimos un nuevo elemento al ArrayList en la posición '2' (con el metodo "add(posición,elemento)") que le llamaremos "Elemento 3" y posteriormente imprimiremos el contenido del ArrayList, recorriendolo con un Iterador. El fragmento de este código es el siguiente:
// Declaración el ArrayList
ArrayList<String> nombreArrayList = new ArrayList<String>();
// Añadimos 10 Elementos en el ArrayList
for (int i=1; i<=10; i++){
nombreArrayList.add("Elemento "+i);
}
// Añadimos un nuevo elemento al ArrayList en la posición 2
nombreArrayList.add(2, "Elemento 3");
// Declaramos el Iterador e imprimimos los Elementos del ArrayList
Iterator<String> nombreIterator = nombreArrayList.iterator();
while(nombreIterator.hasNext()){
String elemento = nombreIterator.next();
System.out.print(elemento+" / ");
}
Ejecutando esta código obtenemos por pantalla lo siguiente:
Elemento 1 / Elemento 2 / Elemento 3 / Elemento 3 / Elemento 4 / Elemento 5 / Elemento 6 / Elemento 7 / Elemento 8 / Elemento 9 / Elemento 10 /
Como se observa en el resultado tenemos repetido el elemento "Elemento 3" dos veces y esto lo hemos puesto a proposito para mostrar el siguiente ejemplo. Ahora para seguir trabajando con los ArrayList, lo que vamos ha hacer es mostrar el numero de elementos que tiene el ArrayList y después eliminaremos el primer elemento del ArrayList y los elementos del ArrayList que sean iguales a "Elemento 3", que por eso lo hemos puesto repetido. El "Elemento 3" lo eliminaremos con el metodo "remove()" del iterador. A continuación mostramos el código que realiza lo descrito:
// Recordar que previamente ya hemos declarado el ArrayList y el Iterator de la siguiente forma:
// ArrayList<String> nombreArrayList = new ArrayList<String>();
// Iterator<String> nombreIterator = nombreArrayList.iterator();
// Obtenemos el numero de elementos del ArrayList
int numElementos = nombreArrayList.size();
System.out.println("nnEl ArrayList tiene "+numElementos+" elementos");
// Eliminamos el primer elemento del ArrayList, es decir el que ocupa la posición '0'
System.out.println("n... Eliminamos el primer elemento del ArrayList ("+nombreArrayList.get(0)+")...");
nombreArrayList.remove(0);
// Eliminamos los elementos de ArrayList que sean iguales a "Elemento 3"
System.out.println("n... Eliminamos los elementos de ArrayList que sean iguales a "Elemento 3" ...");
nombreIterator = nombreArrayList.iterator();
while(nombreIterator.hasNext()){
String elemento = nombreIterator.next();
if(elemento.equals("Elemento 3"))
nombreIterator.remove(); // Eliminamos el Elemento que hemos obtenido del Iterator
}
// Imprimimos el ArrayList despues de eliminar los elementos iguales a "Elemento 3"
System.out.println("nImprimimos los elementos del ArrayList tras realizar las eliminaciones: ");
nombreIterator = nombreArrayList.iterator();
while(nombreIterator.hasNext()){
String elemento = nombreIterator.next();
System.out.print(elemento+" / ");
}
// Mostramos el numero de elementos que tiene el ArrayList tras las eliminaciones:
numElementos = nombreArrayList.size();
System.out.println("nNumero de elementos del ArrayList tras las eliminaciones = "+numElementos);
Estos últimos días en clase hemos estado estudiando los ArrayList, en esta entrada pretendo explicarlos y exponer una práctica que hemos hecho en clase sobre ellos.
Lo primero que debemos saber es, ¿Que es un ArrayList? Pues la clase ArrayList es una clase que permite almacenar datos en memoria de forma similar a los Arrays.
Una de sus principales ventajas es que el número de elementos que almacena lo hace de forma dinámica, es decir, no necesita que le pasemos un tamaño definido, el va aumentándolo a medida que vayamos introduciendo datos.
La clase ArrayList nos ofrece métodos para las operaciones comunes, tales como eliminar, insertar o modificar elementos.
– Una vez explicado, voy a exponer como se declara un ArrayList.
Durante la declaración se indica el tipo de los elementos entre < >
Ejemplo: ArrayList<String> prueba = new ArrayList<String>();
– Principales métodos del ArrayList:
- add Añade un elemento ( prueba.add(“Diego”); )
- get Devuelve un elemento ( prueba.get(PosiciónQueSeDevuelve); )
- remove Elimina un elemento ( prueba.remove(PosiciónQueSeElimina); )
- set Cambia un elemento ( prueba.set(PosiciónQueSeCambia, ElementoQueSustituye); )
- size Tamaño del ArrayList ( prueba.size(); )
Una vez explicada la teoría, pasemos a la práctica, en este ejercicio que he realizado he puesto en práctica lo que he explicado anteriormente, de forma que voy a ir poniendo capturas de pantalla a la vez que explico lo que se realiza en cada captura, bueno empecemos:
Lo primero que voy a poner es como mostrar el primer elemento de nuestro ArrayList, se hace mediante el método get(), que devuelve el elemento que le digamos.
Ahora lo que vamos a hacer es eliminar el primer elemento que hemos mostrado mediante el método remove() y mostrar todo el ArrayList mediante un bucle for.
Lo siguiente que nos pedía el ejercicio era cambiar el segundo elemento de nuestro ArrayList por otro que queramos mediante el método set() y mostrar todo el ArrayList mediante un bucle for.
Y bueno ahora voy a explicar un ejercicio un poco mas complejo, en este caso voy a poner la captura arriba y debajo lo iré explicando poco a poco:
En este ejercicio lo que se hace es declarar dos ArrayList.
Primero pedimos al usuario que introduzca el número de datos que va a introducir en el ArrayList datos, para así poder hacer el bucle for y rellenarlo. Justo después podemos observar como lo muestro.
El siguiente for es el mas complejo, de lo que se trata es de que en ArrayList inversaestén los datos del ArrayList datos pero justo de al revés, es decir de manera inversa. entonces lo que le digo al for es que el contador se inicialice por el tamaño total de datos – 1 (para que no nos salte la excepción), y que vaya restanto hasta que llegue a 0, de esa manera estamos añadiendo a inversa la información que contiene datos de manera inversa.
Finalmente mostramos inversa mediante un bucle for.
No hay comentarios.:
Publicar un comentario