Noticias

* Completa este formulario para conocer los temas de tu interes, te tomará unos segundos.

* Contenido actualizado diariamente!!

* Nueva categoría JavaScript!, aprender javascript está en tus manos!

* Nueva categoría VB .Net!, aprender VB .NET fácilmente con franvarvil!

* Sigue a la página para seguir creciendo!!
Mostrando entradas con la etiqueta botones. Mostrar todas las entradas

sábado, 20 de abril de 2013

Java: Swing: JCheckBox, JRadioButton y ButtonGroup

Francisco 17:58 , , , , , , , , , , , , 5 comentarios :

Introducción

Esta vez aprenderemos a crear dos elementos nuevos de interfaz de usuario en Java, los JCheckBox, primero que todo para los que no saben que son, los checkbox son unos cuadros que salen en un formulario -por ejemplo- cuando te preguntan: "¿Que te gusta?", salen un montón de opciones y puedes marcar más de una, por otro lado están los JRadioButton son parecidos a los checkbox pero son redondos, 

Los radiobutton, son para opciones mutuamente excluyentes, por ejemplo un caso hipotético, en un cuestionario te preguntan "¿Que género eres?", las posibles opciones son "masculino" o "femenino" pero, no puedes tener ambas condiciones a la vez. 

Por último tenemos al ButtonGroup, los radiobutton por si solos no pueden ser mutuamente excluyentes, porque son elementos individuales y si no usamos buttonGroup tendríamos que validar esa característica desde código, pero con un buttonGroup lo hacemos automáticamente.

Imaginemos el ButtonGroup como una caja, donde tendremos unas bolitas -los radiobutton- y cerramos la caja, ahora hacemos una salida en la caja por la cual solo puede pasar una bolita a la vez pero, con la condición de que solo puedes sacar una bolita y si la quieres cambiar tienes que devolverla a la caja, entonces si queremos una bolita podremos sacar una -solamente una-, no podemos hacernos de ninguna más, si queremos otra tendremos que devolver la bolita actual y tomar la otra, en caso contrario los checkbox podemos tener todas las bolitas que queramos.

Desarollo

Ahora si todo bien claro a programar, iniciaremos con el JCheckBox:

 //Creamos nuestra variable global
 private JCheckBox check1;
 //Creamos el método que regresará el checkbox
 private JCheckBox getCheck1() {
 //inicializamo
 check1 = new JCheckBox();
 //le asignamos una posición
 check1.setBounds(80, 30, 20, 20);
 //Decimos que esté seleccionado por defecto
 check1.setSelected(true);
 //por ultimo retornamos
 return check1;
 }

Como ven el método no tiene nada del otro mundo, es muy sencillo crearlos, lo de decir que este seleccionado por defecto es opcional.

 Vamos ahora por el JRadioButton:

 //Creamos la variable Global
 private JRadioButton radio1;
 
 //Método que retorna el radiobutton
 private JRadioButton getRadio1() {
 //inicializamos
 radio1 = new JRadioButton();
 //seleccionamos por defecto
 radio1.setSelected(true);
 //posicionamos
 radio1.setBounds(80, 100, 20, 20);
 //retornamos el objeto
 return radio1;
 }

Es más util usar el selected(boolean) en los radiobutton, para que siempre exista una opción por defecto y no quede vacío.

Bien ya sabemos crearlos entonces, vamos a hacer un ejemplo rápido con estos dos elementos e integramos lo que es el buttonGroup, primero crearemos: seis Jlabel para los textos, dos radioButton y dos Checkbox, acá les dejo el código de todos ellos: 

private JLabel getLabel1() {
 JLabel l = new JLabel("Seleccione que le gusta");
 l.setBounds(10, 5, 180, 30);
 return l;
 }

 private JLabel getLabel2() {
 JLabel l = new JLabel("Comer");
 l.setBounds(10, 30, 80, 30);
 return l;
 }

 private JLabel getLabel3() {
 JLabel l = new JLabel("Dormir");
 l.setBounds(10, 50, 80, 30);
 return l;
 }

 private JCheckBox getCheck1() {
 check1 = new JCheckBox();
 check1.setBounds(80, 30, 20, 20);
 check1.setSelected(true);
 return check1;
 }

 private JCheckBox getCheck2() {
 check2 = new JCheckBox();
 check2.setBounds(80, 53, 20, 20);
 return check2;
 }

 private JLabel getLabel4() {
 JLabel l = new JLabel("Genero");
 l.setBounds(10, 80, 80, 30);
 return l;
 }

 private JLabel getLabel5() {
 JLabel l = new JLabel("Masculino");
 l.setBounds(10, 100, 80, 30);
 return l;
 }

 private JLabel getLabel6() {
 JLabel l = new JLabel("Femenino");
 l.setBounds(10, 115, 80, 30);
 return l;
 }

 private JRadioButton getRadio1() {
 radio1 = new JRadioButton();
 radio1.setSelected(true);
 radio1.setBounds(80, 100, 20, 20);
 return radio1;
 }

 private JRadioButton getRadio2() {
 radio2 = new JRadioButton();
 radio2.setBounds(80, 120, 20, 20);
 return radio2;
 }

Hasta ahora todo normal, entonces vamos a crear el buttongroup con el siguiente código:

//Creación del grupo de botones recibe nuestro radiobutton creados
 //anteriormente
 private void getButtonGroup (JRadioButton radio1, JRadioButton radio2){
 //creamos el objeto
 ButtonGroup bgroup = new ButtonGroup();
 //añadimos al grupo el primer radioButton
 bgroup.add(radio1);
 //añadimos al grupo el segundo radioButton
 bgroup.add(radio2); 
 }

Como vemos en un método void y esto ¿porque? ¿no lo deberíamos agregar a nuestro JFrame?, la respuesta es no, lo que agregamos son los radiobutton que pueden estar en distintos lugares nosotros solo usamos dos pero, pueden ser muchos más, entonces, para que se entienda mejor diremos que el grupo de botones trabaja por debajo.

Lo llamamos en el constructor más solo trabaja en lógica, no es un elemento de interfaz.

Finalmente agregamos todos los elementos al JFrame, mi costructor quedaría así:

public Checs() {
   add(getCheck1());
   add(getCheck2());
   add(getLabel1());
   add(getLabel2());
   add(getLabel3());
   add(getLabel4());
   add(getLabel5());
   add(getLabel6());
   // acá se añaden los radiobutton al buttongruop
   getButtonGroup(getRadio1(), getRadio2());
   add(this.radio1);
   add(this.radio2);
   inicializador();
 }

Prestemos atención que llamamos a nuestro método de crear el grupo y le pasamos como parámetro nuestros dos métodos para crear los radioButton, y luego agregamos los radiobutton al JFrame. Al final de todo mi clase queda de la siguiente manera: 

import javax.swing.ButtonGroup;
import javax.swing.JCheckBox;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JRadioButton;

@SuppressWarnings("serial")
public class Checs extends JFrame {

 private JCheckBox check1;
 private JCheckBox check2;
 private JRadioButton radio1;
 private JRadioButton radio2;

 public Checs() {
 add(getCheck1());
 add(getCheck2());
 add(getLabel1());
 add(getLabel2());
 add(getLabel3());
 add(getLabel4());
 add(getLabel5());
 add(getLabel6());
 getButtonGroup(getRadio1(), getRadio2());
 add(this.radio1);
 add(this.radio2);
 inicializador();
 }

 private void inicializador() {
 setSize(400, 300);
 setLayout(null);
 setTitle("Aprendiendo Checkbox");
 setLocationRelativeTo(null);
 setVisible(true);
 setResizable(false);
 setDefaultCloseOperation(EXIT_ON_CLOSE);
 }

 private JLabel getLabel1() {
 JLabel l = new JLabel("Seleccione que le gusta");
 l.setBounds(10, 5, 180, 30);
 return l;
 }

 private JLabel getLabel2() {
 JLabel l = new JLabel("Comer");
 l.setBounds(10, 30, 80, 30);
 return l;
 }

 private JLabel getLabel3() {
 JLabel l = new JLabel("Dormir");
 l.setBounds(10, 50, 80, 30);
 return l;
 }

 private JCheckBox getCheck1() {
 check1 = new JCheckBox();
 check1.setBounds(80, 30, 20, 20);
 check1.setSelected(true);
 return check1;
 }

 private JCheckBox getCheck2() {
 check2 = new JCheckBox();
 check2.setBounds(80, 53, 20, 20);
 return check2;
 }

 private JLabel getLabel4() {
 JLabel l = new JLabel("Genero");
 l.setBounds(10, 80, 80, 30);
 return l;
 }

 private JLabel getLabel5() {
 JLabel l = new JLabel("Masculino");
 l.setBounds(10, 100, 80, 30);
 return l;
 }

 private JLabel getLabel6() {
 JLabel l = new JLabel("Femenino");
 l.setBounds(10, 115, 80, 30);
 return l;
 }

 private JRadioButton getRadio1() {
 radio1 = new JRadioButton();
 radio1.setSelected(true);
 radio1.setBounds(80, 100, 20, 20);
 return radio1;
 }

 private JRadioButton getRadio2() {
 radio2 = new JRadioButton();
 radio2.setBounds(80, 120, 20, 20);
 return radio2;
 }
 
 //Creación del grupo de botones recibe nuestro radiobutton creados
 //anteriormente
 private void getButtonGroup (JRadioButton radio1, JRadioButton radio2){
 //creamos el objeto
 ButtonGroup bgroup = new ButtonGroup();
 //añadimos al grupo el primer radioButton
 bgroup.add(radio1);
 //añadimos al grupo el segundo radioButton
 bgroup.add(radio2); 
 }

 public static void main(String[] args) {
 new Checs();
 }

}
Conclusión

Todos los elementos que aprendimos anteriormente, son muy utilizados al momento de crear formularios, debido a que brindan muchas facilidades e inclusive en muchos casos se libera de las validaciones.


jueves, 6 de diciembre de 2012

Java: Swing: AWT: JButton y ActionListener

Francisco 10:40 , , , , , , , , , , , , 3 comentarios :
Introducción

Los JButton, pues no hay mucho que decir son botones que se agregan en nuestro Frames para que ejecuten una acción al ser presionados por el Usuario.

Desarrollo
Primero tenemos que agregar la librería: 

import javax.swing.JButton;

Ahora vamos a crear nuestro método para el botón: 

private JButton verBoton() {
    //Inicializamos el botón
    JButton boton = new JButton();
    //agregamos texto al botón
    boton.setText("Botón");
    //agregamos coordenadas
    boton.setBounds(50, 50, 100, 50);
    //le damos una tipografía
    boton.setFont(new Font("Arial", 1, 18));
    //le damos un color a la fuente
    boton.setForeground(new Color(25,85,255));
 
    return boton;
 }

Con eso tendremos un botón con las letras azules (el color no es muy bonito pero es para que se aprecie el cambio). Nuestro botón si lo presionamos, no pasa nada entonces vamos a implementar una interface para que puedan ser "escuchados", con ser escuchados me refiero a que realicen algo cuando se les presione. 

public class MiClase extends JFrame implements ActionListener {//nuestro código}

Cuando implementamos ActionListener tenemos que colocar el método de esta interface de lo contrario nos va a mostrar un error, para los que usan un IDE es muy fácil porque lo coloca automáticamente, pero para los que no, acá está el método que tenemos que colocar:

@Override
 public void actionPerformed(ActionEvent e) {
 }

En este método tenemos que colocar las acciones que van a ejecutar, en este caso nuestros botones. 

Vamos a hacer un ejemplo reuniendo todo lo que vimos hasta ahora: JLabel, JTextField y JButton, vamos a escribir algo en un campo de texto y lo vamos a pasar (en mayúscula) a otro campo de texto que no se puede editar cuando presionemos un botón. 

Aunque se vea muy simple, es para dar un ejemplo de como usar actionListener y bueno acá va el código comentado las partes que no se han visto antes: 
import java.awt.Font;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JTextField;

@SuppressWarnings("serial")
public class JFrames extends JFrame implements ActionListener {

    //Ocupamos que nuestro botón y los jtextfield sean globales para poder acceder a ellos 
    //por medio de actionPerformed
    private JButton boton;
    private JTextField jtfPalabra;
    private JTextField jtfPalabraPasada;

    public JFrames() {
        add(verBoton());
        add(getPalabra());
        add(getIngresar());
        add(getPalabraPasada());
        inicializador();
    }
   
    private void inicializador() {
        setSize(400, 300);
        setLayout(null);
        setTitle("Mi ventana");
        setLocationRelativeTo(null);
        setVisible(true);
        setResizable(false);
        setDefaultCloseOperation(EXIT_ON_CLOSE);
    }

    private JButton verBoton() {
        boton = new JButton();
        boton.setText(">>>");
        boton.setBounds(150, 200, 100, 50);
        boton.setFont(new Font("Arial", 1, 18));
        //le incluimos la posibilidad de ser escuchado cuando se
        //le precione
        boton.addActionListener(this);
        return boton;
    }
 
    private JLabel getIngresar() {
        JLabel jlIngresar = new JLabel("Ingrese una palabra: ");
        jlIngresar.setBounds(30, 50, 150, 30);
        return jlIngresar;
    }
 
    private JTextField getPalabra() {
        jtfPalabra = new JTextField();
        jtfPalabra.setBounds(180, 50, 100, 30);
        return jtfPalabra;
    }
 
    private JTextField getPalabraPasada() {
        jtfPalabraPasada = new JTextField();
        jtfPalabraPasada.setBounds(180, 120, 150, 30);
        //Hacemos que lo que esté escrito acá no se pueda modificar
        jtfPalabraPasada.setEnabled(false);
        return jtfPalabraPasada;
    }

    @Override
    public void actionPerformed(ActionEvent e) {
        //Para hacerlo paso a paso vamos a crear unas variables tipo
        //string para almacenamiento temporal
        String palabra = "";
 
        //si precionamos nuestro botón ejecutará una acción
        if (e.getSource() == boton){
            //Obtenemos el valor del campo de texto
            palabra = jtfPalabra.getText();
            //convertimos a mayúsculas
            palabra = palabra.toUpperCase();
            //asignamos al otro jtextfield (el que no se puede editar)
            jtfPalabraPasada.setText(palabra);
            //limpiamos el campo en el que escribimos la palabra
            jtfPalabra.setText(""); 
        }
    } 
}

Y como siempre la documentación de java con respecto a los temas tratados:
Botones: http://docs.oracle.com/javase/8/docs/api/javax/swing/JButton.html
ActionListener: http://docs.oracle.com/javase/8/docs/api/java/awt/event/ActionListener.html

Conclusiones

 Los botones y las acciones que se realizan al presionarlos son elementos que se utilizan en la gran mayoría de aplicaciones hoy en día.

El ActionListener es una interface que se implementa para poder asignarle una acción a un elemento del JFrame.
Suscribirse a: Entradas ( Atom )

Seguidores

Envía tú opinión, comentario o sugerencia.

Nombre

Correo electrónico *

Mensaje *