Indice de Contenidos del Blog.

Aplicación de Stock con Java.

Aplicación de Stock.

Utilizando: Hibernate – MySQL – JPA.

Ver todas las entradas

Java Básico con Swing.

Trabajando Swing.

Diseño de Formularios en NetBeans.

Ver todas las entradas

Tutoriales Java Básico

Java Básico.

Trabajando en modo consola.

Ver todas las entradas

Tutoriales Java modo diseño.

Java modo diseño

Uso básico de elementos Swing con NetBeans.

Ver todas las entradas

Java básico 068. Uso de la interfaz Deque para trabajar con registros.

Utilizando la Interfaz Java Deque.

La interfaz Java Deque java.util.Deque, representa una cola de doble extremo, lo que significa una cola donde puede agregar y eliminar elementos de ambos extremos de la cola. El nombre Deque es una abreviatura de Double Ended Queue.

Para implementar un Deque podemos utilizar dos interfaces, por una parte java.util.LinkedList el más estándar y java.util.ArrayDeque.

La interfaz Java Deque contiene los siguientes métodos para agregarle elementos:

add(): Agregar elemento al principio de la cola.
addLast (): Agrega un elemento al final de la cola.
addFirst (): Agrega un elemento al principio de la cola.

Para eliminar elementos de un Java Deque, puede usarse uno de los siguientes métodos:

remove(): Elimina el primer elemento.
removeFirst(): Remueve el primer elemento.
removeLast(): Remueve el ultimo elemento.

Como ejemplo utilizamos la clase “Usuario” que nos sirve para almacenar como registro, una clase “UsuarioApp” con el método main para la ejecución.

Clase Usuario.

/**
 *
 * @author carlos
 */
public class Usuario {
    //Atributos
    private int id;
    private String nombre;
    private String password;
    
    //Constructores
    public Usuario() {
        
    }

    public Usuario(int id, String nombre, String password) {
        this.id = id;
        this.nombre = nombre;
        this.password = password;
    }

    //Getters y Setters

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getNombre() {
        return nombre;
    }

    public void setNombre(String nombre) {
        this.nombre = nombre;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
    
}

Clase UsuarioApp

import java.util.Deque;
import java.util.LinkedList;

/**
 *
 * @author carlos
 */
public class DequeApp {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        //Métodos creados más abajo
        Deque<Usuario> usuario = cargar();
        print(usuario);
        eliminar(usuario);
        print(usuario);
    }
    
    static Deque<Usuario> cargar(){
        //Forma de instanciar un Deque utilizando LinkedList
        Deque<Usuario> us = new LinkedList<>();
        //add() agrega elementos al princio. En orden en que llega.
        us.add(new Usuario(1, "Angel", "sng1236"));
        us.add(new Usuario(2, "Perla", "per20145")); 
        //addFirst() agrega justo al principio de la lista
        us.addFirst(new Usuario(3, "Manuela", "mnd23145"));
        //addLast() agrega elemento al final de la lista
        us.addLast(new Usuario(4, "Luis", "lu2345"));
        return us;
    }
    
    static void eliminar(Deque<Usuario> usuario){
        System.out.println("----------------------");
        System.out.println("Removiendo elementos");
        //Remueve el primer elemento
        usuario.removeFirst();
        //Remueve el último elemento.
        usuario.removeLast();
        
    }
    
    static void print(Deque<Usuario> usuario){
        System.out.println("Imprimiendo Datos.");
        for(Usuario us : usuario){
            System.out.println("______________________________");
            System.out.println("ID: " + us.getId());
            System.out.println("Nombre: " + us.getNombre());
            System.out.println("Password: " + us.getPassword());
        }
    }
    
}

Resultado.

Java básico 067. Uso de Pila -Stack- para trabajar con registros

Utilización de la clase Stack. Estructura de datos tipo pila.

La clase Java Stackjava.util.Stack , es una estructura de datos de pila clásica. Puede insertar elementos en la parte superior de una pila de Java y volver a abrirlos, lo que significa leer y eliminar los elementos de la parte superior de la pila.

Un Stack posee varios método propios, que le permiten gestionar los elementos agregados de una forma diferente a una interfaz List.

Como ejemplo utilizaremos una clase “Usuario”, de la cual crearemos instancias que se irán agregando a la cola. Necesitaremos una clase main para crear los métodos y ejecutarlos.

Clase Usuario.

/**
 *
 * @author carlos
 */
public class Usuario {
    //Atributos
    private int id;
    private String nombre;
    private String password;
    
    //Constructores
    public Usuario() {
        
    }

    public Usuario(int id, String nombre, String password) {
        this.id = id;
        this.nombre = nombre;
        this.password = password;
    }

    //Getters y Setters

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getNombre() {
        return nombre;
    }

    public void setNombre(String nombre) {
        this.nombre = nombre;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
    
}

Clase main “StackApp” que será el ejecutable.

import java.util.Stack;

/**
 *
 * @author carlos
 */
public class StackApp {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        //Rellenando Pila.
        Stack<Usuario> usuarios = usuarios();
        //Método propio de una pila, obtener el último elemento agregado
        System.out.println("Último elemento: " + usuarios.peek().getNombre());
        //Llamando al método para imprimir        
        print(usuarios);
        //Llamando al método para vaciar.
        vaciar(usuarios);
    }
    
    //Utilizamos un método para cargar los elementos en la pila
    //El método retorna una pila de "Usuarios"
    public static Stack<Usuario> usuarios(){
        //Se instancia utilizando new Stack<>()
        Stack<Usuario> usuarios = new Stack<>();
        //Se agregan registros de usuario a la pila.
        //Hay diferentes formas de agregar elementos a la pila
        //Utilizando add
        usuarios.add(new Usuario(1, "Jorge", "jorge2019"));
        //Utilizando push, método propia de una pila
        usuarios.push(new Usuario(2, "Anibal", "pass123"));
        usuarios.push(new Usuario(3, "Miguel", "mg2020"));
        usuarios.push(new Usuario(4, "Ariel", "arl2220"));  
        usuarios.push(new Usuario(5, "Sonia", "sn1980"));
        //Retornamos una pila de usuario.
        return usuarios;
    }
    
    public static void vaciar(Stack<Usuario> usuarios){
        System.out.println("Vaciando pila");
        System.out.println("_____________");
        //Se utiliza el método pop() para vaciar la pila
        //Se recorre la pila hasta que quede vacío
        while(!usuarios.isEmpty()){
            usuarios.pop();
        }
        System.out.println("Pila vacía.");
    }
    
    //Método para imprimir
    public static void print(Stack<Usuario> usuarios){
        System.out.println("Imprimiendo datos de Usuarios");
        System.out.println("_____________________________");
        //Utilizamos foreach para acceder a cada registro usuario y mostrarlo
        for(Usuario u: usuarios){
            System.out.println("Id: " + u.getId());
            System.out.println("Nombre: " + u.getNombre());
            System.out.println("Password: " + u.getPassword());
            System.out.println("_________________________________");
        }
    }
    
}

Resultado del ejemplo.

Java básico 066. Uso de List y ArrayList con registros

Utilización de la interfaz Java List

La interfaz Java List, almacena una secuencia ordenada de objetos. Los elementos contenidos en un Java List se pueden insertar, acceder, iterar y eliminar de acuerdo con el orden en que aparecen internamente en el Java List. El orden de los elementos es la razón por la cual esta estructura de datos se denomina Lista.

Cada elemento en un Java List tiene un índice. El primer elemento en el List tiene índice 0, el segundo elemento tiene índice 1. Se puede acceder a cualquier elemento utilizando muchos de los método con que cuenta esta interfaz.

Puede agregar cualquier objeto Java a un List. Por lo general se utiliza para almacenar registros provenientes de base de datos u otras colecciones. Ya que nos permite acceder a ellas de forma sencilla. Como ejemplo utilizaremos una clase que llamaremos “Usuario” y una clase con el método “main” para trabajar con la lista utilizando métodos que crearemos.

Clase “Usuario”

/**
 *
 * @author carlos
 */
public class Usuario {
    //Atributos
    private int id;
    private String nombre;
    private String password;
    
    //Constructores
    public Usuario() {
        
    }

    public Usuario(int id, String nombre, String password) {
        this.id = id;
        this.nombre = nombre;
        this.password = password;
    }

    //Getters y Setters

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getNombre() {
        return nombre;
    }

    public void setNombre(String nombre) {
        this.nombre = nombre;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
    
}

Clase main “UsuarioApp”. Tomar en cuenta las importaciones.

import java.util.ArrayList;
import java.util.List;

/**
 *
 * @author carlos
 */
public class UsuarioApp {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        //Llamamos a los métodos creados más abajo.
        List<Usuario> usuarios = usuarios();
        print(usuarios);
    }
    
    //Método cargar datos en Lista
    //El método retorna un objeto tipo List<Usuario>, una lista de usuarios
    public static List<Usuario> usuarios(){
        //Se instancia utilizando ArrayList. 
        List<Usuario> usuarios = new ArrayList<>();
        //Se agregan registros de usuario a la lista.
        //Cada registro es una instancia de la clase Usuario
        usuarios.add(new Usuario(1, "Jorge", "jorge2019"));
        usuarios.add(new Usuario(2, "Anibal", "pass123"));
        usuarios.add(new Usuario(3, "Miguel", "mg2020"));
        usuarios.add(new Usuario(4, "Ariel", "arl2220"));
        //Retornamos la lista usuario.
        return usuarios;
    }
    
    //Método para imprimir
    public static void print(List<Usuario> usuarios){
        System.out.println("Imprimiendo datos de Usuarios");
        System.out.println("_____________________________");
        //Utilizamos foreach para acceder a cada registro usuario y mostrarlo
        for(Usuario u: usuarios){
            System.out.println("Id: " + u.getId());
            System.out.println("Nombre: " + u.getNombre());
            System.out.println("Password: " + u.getPassword());
            System.out.println("_________________________________");
        }
    }
    
}

Resultado.

Java básico 065. Factorial de Números de 1 al 10.

Ejercicio: Realizar el factorial de números de 1 al 10.

/**
 *
 * @author carlos
 */
public class Factoriales {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        System.out.println("Factorial de números de 1 al 10");
        System.out.println("_______________________________");
        long factorial = 1;
        for (int num = 1; num <= 10; num++) {
            for (int i = num; i > 0; i--) {
                factorial = factorial * i;
            }
            System.out.println("El factorial de " + num + " es: " + factorial);
            factorial = 1;//Reiniciar el valor del factorial por cada vuelta
        }
    }
    
}

Resultado.

Uso básico de elementos Swing con NetBeans – 35 – Uso de JToolBar, barra de herramientas.

Utilización de JToolBar, modo diseño en Netbeans

En este ejemplo sencillo veremos la utilidad de un “JToolBar”, objeto que puede contener botones u otros elementos, tiene ciertas ventajas como la posibilidad de flotar de forma libre o ubicarse fácilmente en cualquiera de los cuatro costados del formulario desplazando automáticamente otros elementos. En este ejemplo nuestra “Barra de Herramientas” contendrá cinco botones, cada una al hacer clic sobre ellas agregará una línea de texto al “Área de texto” indicando la procedencia del clic. En modo diseño podremos ver la distribución de los elementos. El nombre que le demos al formulario es a criterio de cada uno. Tomar en cuenta los nombres de variable de cada objeto, se especifican los nombres en el diseño. Esto es muy importante ya que desde los métodos se utilizan estos nombres para referencia a cada objeto. Se puede cambiar el “Nombre de variable” de cada objeto haciendo clic derecho sobre la misma y clic en “Cambiar nombre de variable…”. (clic sobre la imagen para ampliar)

Para este ejemplo necesitamos una única importación y el método de inicio habitual.

Código Java

package com.swing.basic;//Paquete

import java.awt.Color;//Importación

/**
 *
 * @author Ariel
 */
public class UsoJToolBar extends javax.swing.JFrame {

    /**
     * Creates new form UsoJToolBar
     */
    public UsoJToolBar() {
        initComponents();
        setLocationRelativeTo(null);//Centrar formulario
        inicio();//Método de arranque
    }

El único método que necesitamos es “inicio()” la cual inicializará ciertas propiedades del área de texto como ya veremos.

    private void inicio(){
        //Pequeños ajuste para el Area de Texto.
        //Los ajustes para la barra de herramientas se hacen en modo diseño.
        jTextA.setEditable(false);
        jTextA.setBackground(Color.lightGray);
        jTextA.setForeground(Color.BLUE);
    }

Para los botones se utiliza el evento “ActionPerformed” que permitirá ejecutar los métodos. En las primeras guías de la serie vimos cómo se hacer para relacionar un evento con un objeto visual.

Código Java

    private void btn01ActionPerformed(java.awt.event.ActionEvent evt) {                                      
        jTextA.append("Clic botón Abrir..." + "\n");
    }                                     

    private void btn02ActionPerformed(java.awt.event.ActionEvent evt) {                                      
        jTextA.append("Clic botón Buscar..." + "\n");
    }                                     

    private void btn03ActionPerformed(java.awt.event.ActionEvent evt) {                                      
        jTextA.append("Clic botón Consultar..." + "\n");
    }                                     

    private void btn04ActionPerformed(java.awt.event.ActionEvent evt) {                                      
        jTextA.append("Clic botón Imprimir..." + "\n");
    }                                     

    private void btn05ActionPerformed(java.awt.event.ActionEvent evt) {                                      
        jTextA.append("Clic botón Ayuda..." + "\n");
    }

Llegado a este punto podremos ejecutar y probar nuestro formulario. (Por si hay alguna duda en el proceso, debemos hacer clic derecho sobre nuestro archivo fuente y presionar “ejecutar archivo” ya que nuestro proyecto no tiene una clase principal definida).

Uso básico de elementos Swing con NetBeans – 34 – Uso de JTextArea, cambio de fuente y tamaño de fuente.

Trabajando con JTextArea.

Ampliando el ejemplo anterior, veremos cómo obtener la lista de fuentes del sistema y aplicarlas a nuestro Área de Texto, también veremos cómo ajustar el tamaño de fuentes. El resto es totalmente igual al del ejemplo anterior. Para mostrar la lista de fuentes y tamaño de fuente utilizamos combos. Es necesario limpiar los ítems del “model” en modo diseño.

El nombre que le demos al formulario es a criterio de cada uno. Tomar en cuenta los nombres de variable de cada objeto, se especifican los nombres en el diseño. Esto es muy importante ya que desde los métodos se utilizan estos nombres para referencia a cada objeto. Se puede cambiar el “Nombre de variable” de cada objeto haciendo clic derecho sobre la misma y clic en “Cambiar nombre de variable…”. (clic sobre la imagen para ampliar)

Lista de importaciones que necesitamos para trabajar con ciertos objetos. Además los métodos llamados desde el constructor del JFrame.

Código Java

package com.swing.basic;//Paquete de fuente

import java.awt.Font;//Importación
import java.awt.GraphicsEnvironment;

/**
 *
 * @author Ariel
 */
public class EjJTextArea extends javax.swing.JFrame {

    /**
     * Creates new form EjJTextArea
     */
    public EjJTextArea() {
        initComponents();
        setLocationRelativeTo(null);//Centrar formulario
        inicio();//Método de inicio
    }

Para el ejemplo utilizamos varios métodos que cumplen funciones específicas. El nombre que le damos a cada método nos da una idea de que función cumple. El método “inicio()” por ejemplo arranca desde el constructor del JFrame y nos permite inicializar algunas propiedades del área de texto. Se agregan comentarios para indicar la funciona de cada línea de código.

Código Java

    private void inicio(){
        //-Establecemos propiedades para el JTextArea-
        //Establecemos tipo de fuente predeterminado, texto itálico, tamaño 15
        jTex.setFont(new Font("Default", Font.PLAIN, 15));
        //Especificamos que el texto se ajusta al tamaño del Área de texto
        jTex.setLineWrap(true);
        jTex.setWrapStyleWord(true);
        //Hacemos que el área de texto no sea editable
        jTex.setEditable(false);
        
        //Configuramos la lista de tipo de fuentes y tamaño
        //Obtenemos la lista de fuentes del sistema utilizando getAvailableFontFamilyNames()
        GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
        String[] fonts = ge.getAvailableFontFamilyNames();
        
        //Agregamos cada nombre de fuente a nuestro combo.
        for (String string : fonts) { 
            fuenteTipo.addItem(string);
        }
        
        //Agregamos los tamaños de fuente, de 1 al 70
        for (int i = 1; i < 71; i++) {
            fuenteTam.addItem(i);
        }
        
        //Inicializamos el tamaño de fuente en 15.
        fuenteTam.setSelectedIndex(14);        
    }
    
    //Método para agregar texto al área de texto.
    private void agregar(){
        //Verificamos que el campo de texto no este vacío
        if(!jT.getText().isEmpty()){
            //Para agregar textos se utiliza append. "\n" indica salto de línea.
            jTex.append(jT.getText() + "\n");
            //Limpiamos el campo JTextField.
            jT.setText(null);
        }
    }
    
    //Método para manejar los cambios de fuente y tamaño
    private void tipoFuente(){
        //Obtenemos tipo y tamaño.
        String toString = fuenteTipo.getSelectedItem().toString();
        int selectedIndex = fuenteTam.getSelectedIndex() + 1;
        jTex.setFont(new Font(toString, Font.PLAIN, selectedIndex));
    }
}

En relación a los eventos, tanto para el botón agregar como en los dos combos utilizaremos el “ActionPerformed” que permitirá ejecutar los métodos. En las primeras guías de la serie vimos cómo se hacer para relacionar un evento con un objeto visual.

Código Java

    private void agregarActionPerformed(java.awt.event.ActionEvent evt) {                                        
        agregar();
    }                                       

    private void fuenteTipoActionPerformed(java.awt.event.ActionEvent evt) {                                           
        tipoFuente();
    }                                          

    private void fuenteTamActionPerformed(java.awt.event.ActionEvent evt) {                                          
        tipoFuente();
    }

Uso básico de elementos Swing con NetBeans – 33 – Uso de JTextArea, agregar elementos desde JTextField.

Uso básico del elemento JTextArea

Anteriormente ya vimos la utilizando de un “JTextArea” o Área de Texto, en esta oportunidad daremos un pequeño ejemplo de cómo agregar texto desde un JTextField. El nombre que le demos al formulario es a criterio de cada uno. Tomar en cuenta los nombres de variable de cada objeto, se especifican los nombres en el diseño. Esto es muy importante ya que desde los métodos se utilizan estos nombres para referencia a cada objeto. Se puede cambiar el “Nombre de variable” de cada objeto haciendo clic derecho sobre la misma y clic en “Cambiar nombre de variable…”. (clic sobre la imagen para ampliar)

Lista de importaciones que necesitamos para trabajar con ciertos objetos. Además los métodos llamados desde el constructor del JFrame.

Código Java

package com.swing.basic;//Paquete de fuente

import java.awt.Font;//Importación

/**
 *
 * @author Ariel
 */
public class EjJTextArea extends javax.swing.JFrame {

    /**
     * Creates new form EjJTextArea
     */
    public EjJTextArea() {
        initComponents();
        setLocationRelativeTo(null);//Centrar formulario
        inicio();//Método de inicio
    }

Código Java

    private void inicio(){
        //-Establecemos propiedades para el JTextArea-
        //Establecemos tipo de fuente predeterminado, texto itálico, tamaño 15
        jTex.setFont(new Font("Default", Font.ITALIC, 15));
        //Especificamos que el texto se ajusta al tamaño del Área de texto
        jTex.setLineWrap(true);
        jTex.setWrapStyleWord(true);
        //Hacemos que el área de texto no sea editable
        jTex.setEditable(false);
    }
    
    //Método para agregar texto al área de texto.
    private void agregar(){
        //Verificamos que el campo de texto no este vacío
        if(!jT.getText().isEmpty()){
            //Para agregar textos se utiliza append. "\n" indica salto de línea.
            jTex.append(jT.getText() + "\n");
            //Limpiamos el campo JTextField.
            jT.setText(null);
        }
    }

En este ejemplo tenemos un solo botón denominado “Agregar” la cual utilizará el evento “ActionPerformed” que permitirá ejecutar el método “agregar()”. En las primeras guías de la serie vimos cómo se hacer para relacionar un evento con un objeto visual.

Código Java

    private void agregarActionPerformed(java.awt.event.ActionEvent evt) {                                        
        agregar();
    }

Uso básico de elementos Swing con NetBeans – 32 – Uso de JTable, agregar y eliminar elementos de tabla.

Trabajando con JTable en Java

Las tablas son uno de los elementos más utilizados dentro de cualquier lenguaje de programación, se puede utilizar para desplegar lista de datos similares ordenados de una forma específica. Su uso es bastante amplio pues es bastante versátil. En este ejemplo utilizaremos la tabla para mostrar datos ingresados por el usuario. Con esto podremos ver como se agregan y eliminan filas de una tabla. Como agregado veremos cómo agregar un JCheckBox a la tabla utilizando CellEditor y CellRenderer.

La tabla se puede manipular en modo diseño, se especifican los nombres y cantidad de columnas haciendo clic derecho sobre la tabla y accediendo a “Contenidos de tabla (Table Contents)”. Para el combo agregamos “Sí” y “No” en modo diseño desde la propiedad del objeto y en el apartado “model”. Agregar icono para los botones es opcional.

Tomar en cuenta los nombres de variable de cada objeto, se especifican los nombres en el diseño. Esto es muy importante ya que desde los métodos se utilizan estos nombres para referencia a cada objeto. Se puede cambiar el “Nombre de variable” de cada objeto haciendo clic derecho sobre la misma y clic en “Cambiar nombre de variable…”. (clic sobre la imagen para ampliar)

Lista de importaciones que necesitamos para trabajar con ciertos objetos. Además los métodos llamados desde el constructor del JFrame y las variables de clase.

Código Java

package com.swing.basic;//Paquete

import java.awt.Color;
import java.awt.Component;
import javax.swing.DefaultCellEditor;
import javax.swing.JCheckBox;
import javax.swing.JComponent;//Importaciones
import javax.swing.JOptionPane;
import javax.swing.JTable;
import javax.swing.table.DefaultTableModel;
import javax.swing.table.TableCellRenderer;

/**
 *
 * @author Ariel
 */
public class UsoJTable extends javax.swing.JFrame {

    /**
     * Creates new form UsoJTable
     */
    public UsoJTable() {
        initComponents();
        setLocationRelativeTo(null);//Centrar formulario
        inicio();//Método de inicio
    }
    private DefaultTableModel model;//Modelo para tabla
    private int sel;//Variable para obtener fila seleccionada de tabla.

Para el ejemplo utilizamos varios métodos que cumplen funciones específicas. El nombre que le damos a cada método nos da una idea de que función cumple. El método “inicio()” por ejemplo arranca desde el constructor del JFrame y nos permite inicializar algunas propiedades de la tabla. Se agregan comentarios para indicar la funciona de cada línea de código.

Código Java

    private void inicio(){ 
        //Método para configurar el DefaultTableModel de la tabla.
        //Especificamos el tamaño de cada columna
        jTb.getColumnModel().getColumn(0).setPreferredWidth(100);
        jTb.getColumnModel().getColumn(1).setPreferredWidth(100);
        jTb.getColumnModel().getColumn(2).setPreferredWidth(50);
        jTb.getColumnModel().getColumn(3).setPreferredWidth(100);
        jTb.getColumnModel().getColumn(4).setPreferredWidth(100);
        //Indicamos el DefaultTableModel de nuestra tabla
        model = (DefaultTableModel) jTb.getModel();
        //Indicamos el número de filas
        model.setNumRows(0);        
    } 
    
    //Método para agregar datos a la tabla.
    private void agregar(){
        //También mostramos como agregar un JCheckBox a la tabla
        JCheckBox check = new JCheckBox();
        //Comprobamos que los campos de datos no esten vacíos
        if(!nombre.getText().isEmpty() || !apellido.getText().isEmpty() ||
                !edad.getText().isEmpty() || !profesion.getText().isEmpty()){ 
            //Utilizamos un boolean para obtener el valor del combo.
            boolean rp = casado.getSelectedItem().toString().equals("Sí");  
            //Utilizamos try para la controlar posibles errores de conversión.
            try {
                //Convertimos en entero lo obtenido del campo edad.
                int edd = Integer.parseInt(edad.getText());
                //agregamos los datos a la tabla utilizando Object[]
                model.addRow(new Object[]{
                    nombre.getText(),apellido.getText(),edd, profesion.getText(),rp
                }); 
                limpiar();
            } catch (NumberFormatException e) {
                JOptionPane.showMessageDialog(null, "Edad debe ser numérico");
            }
            
        }
        //Agregamos el JCheckBox utilizando CellEditor y la clase CellRenderer creado más abajo
        jTb.getColumnModel().getColumn(4).setCellEditor(new DefaultCellEditor(check));
        jTb.getColumnModel().getColumn(4).setCellRenderer(new Render_CheckBox());
    }
    //Método para obtener la fila seleccionada de la tabla
    private void seleccion(){
        if(jTb.getRowCount() > 0 ){
            sel = jTb.getSelectedRow();
        }
    }
    //Método para obtener la fila seleccionada de la tabla.
    private void eliminar(){
        if(sel >= 0){
            model.removeRow(sel);
            sel = -1;
        }
        else{
            JOptionPane.showMessageDialog(null, "Selecciona una fila.");
        }
    }
    
    //Método para limpiar campos después de agregar los datos a la tabla
    private void limpiar(){
        nombre.setText(null);
        apellido.setText(null);
        edad.setText(null);
        profesion.setText(null);
        casado.setSelectedIndex(-1);
    }
    //Clase para manejar el TableCellRenderer, que permitirá mostrar el JCheckBox
    class Render_CheckBox extends JCheckBox implements TableCellRenderer {
    //
        private final JComponent component = new JCheckBox();

        /** Constructor de clase */
        public Render_CheckBox() {
            setOpaque(true);
    }

            @Override
      public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
          //Color de fondo de la celda
          ( (JCheckBox) component).setBackground( new Color(98,138,183) );
          //obtiene valor boolean y coloca valor en el JCheckBox
          boolean b = ((Boolean) value).booleanValue();
          ( (JCheckBox) component).setSelected( b );
          return ( (JCheckBox) component);
      }
    }

Para el ejemplo utilizamos dos tipos de evento, “ActionPerformed” para los botones y “MouseClicked” para la tabla. Abajo la lista de eventos. Obs.: En las primeras guías de esta serie vimos cómo se agregan eventos a objetos en modo diseño.

Código Java

    private void agregarActionPerformed(java.awt.event.ActionEvent evt) {                                        
        agregar();
    }                                       

    private void eliminarActionPerformed(java.awt.event.ActionEvent evt) {                                         
        eliminar();
    }                                        

    private void jTbMouseClicked(java.awt.event.MouseEvent evt) {                                 
        seleccion();
    }

Suscribirse a: Entradas ( Atom )