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 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.

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.

    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.

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.

    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.

    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();
    }    

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 – 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.

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
    }

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.

    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.

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

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 – 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.

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.

    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.

    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();
    }   

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) (clic sobre la imagen para ampliar)

Uso básico de elementos Swing con NetBeans – 31 – Uso de JTabbedPane, divisor de paneles.

Uso del elemento JTabbedPane en Java

JTabbedPane es un elemento útil a la hora de dividir múltiples paneles en pestañas, lo cual permite incluir multitud de funcionalidades en un solo formulario, permitiendo compactarlas en paneles independientes y de fácil navegación. Para este ejemplo utilizaremos un JTabbedPane a la cual le incluiremos tres JPanel, cada una indicará una pestaña funcional por si sola. A cada JPanel le agregaremos un JScrollPane para ajustar el redimensionado y dentro de esta última un JLabel la cual utilizando ejemplos anteriores le agregaremos una imagen. Como se ver en el diseño más abajo, los ajustes básicos la hacemos en modo código, por tanto basta con agregar de forma correcta cada elemento.

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.

package com.swing.basic;//Paquete

import javax.swing.ImageIcon;//Importación

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

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

Como es habitual utilizamos un método privado que arrancará junto con el formulario al llamarla desde el constructor, esto nos permitirá inicializar las propiedades necesarias de cada objeto del formulario. Se especifican con comentarios la funcionalidad de cada línea de código. Para este ejemplo no se aplican los eventos.

    private void inicio(){
        //Configuramos el primer tabbed, el primer parámetro indica el índice.
        jTabb.setTitleAt(0, "Primer Panel");
        jTabb.setIconAt(0, createImageIcon("/com/swing/basic/img/Search.png"));
        jTabb.setToolTipTextAt(0, "Esta es la primera pestaña");
        //Agregamos el icono al label
        jLab01.setText(null);
        //Depende de como tengamos oragnizado los paquetes para ubicar las imagenes
        jLab01.setIcon(createImageIcon("/com/swing/basic/img/aqua.png"));
        
        //Configuramos el segundo tabbed, el primer parámetro indica el índice.
        jTabb.setTitleAt(1, "Segundo Panel");
        jTabb.setIconAt(1, createImageIcon("/com/swing/basic/img/clients.png"));
        jTabb.setToolTipTextAt(1, "Esta es la segunda pestaña");
        jLab02.setText(null);
        jLab02.setIcon(createImageIcon("/com/swing/basic/img/kirito.png"));
        
        //Configuramos el tercer tabbed, el primer parámetro indica el índice.
        jTabb.setTitleAt(2, "Tercer Panel");
        jTabb.setIconAt(2, createImageIcon("/com/swing/basic/img/load.png"));
        jTabb.setToolTipTextAt(2, "Esta es la tercera pestaña");
        jLab03.setText(null);
        jLab03.setIcon(createImageIcon("/com/swing/basic/img/paisaje.png"));       
    }
    //Método que nos permitirá cargar una imagen como icono pasándole una url
    private static ImageIcon createImageIcon(String path) {
        java.net.URL imgURL = UsoJRadioButton.class.getResource(path);
        if (imgURL != null) {
            return new ImageIcon(imgURL);
        } else {
            System.err.println("Archivo no encontrado: " + path);
            return null;
        }
    }

Ahora sí, podemos ejecutar 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 – 30 – Uso de JSplitPane, divisor de elementos.

Trabajando con JSplitPane desde Java

El JSplitPane es un elemento muy útil que nos permite dividir objetos distintos en uno o varios paneles redimensionables. En este ejemplo agregamos una Lista de nombres de imágenes PNG, que se cargarán al seleccionarlas con un clic y que se mostraran en un Label, como se ve en el diseño el JSplitPane muestra la lista en la parte izquierda y al label en la parte derecha en el medio el divisor redimensionable. Como vemos en el diseño también necesitamos dos JScrollPane, que se puede agregar arrastrando y soltando en el punto específico, la misma forma el elemento que la utilizan se arrastra y suelta en su interior. Es más fácil mover elementos de un lugar a otro utilizando el “Navegador” como se muestra en la imagen más abajo.

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.

import javax.swing.DefaultListModel;
import javax.swing.ImageIcon;//Importaciones

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

    /**
     * Creates new form UsoJSplitPane
     */
    public UsoJSplitPane() {
        initComponents();
        setLocationRelativeTo(null);//Centrar formulario
        inicio();//Método de arranque
    }
    private DefaultListModel modelList;//Variable de clase.

Para el ejemplo utilizamos varios métodos que cumplen funciones específicas, la principal es “inicio” que nos permitirá inicializar la lista y configurar ciertas propiedades de cada elemento del diseño. Las propiedades de objetos se pueden editar en modo diseño, pero es más fácil entender cómo funcionan al hacerla en modo código.

    private void inicio(){
        //Incluye las fechitas de expanción rápida al JSplitPane
        jSp.setOneTouchExpandable(true);
        //Localización de divisor
        jSp.setDividerLocation(150);
        //Array de String con los nombres de archivos PNG que utilizaremos
        //Cada uno puede hacer su propia lista.
        String[] img = {"paisaje","bosque","kirito","Delete","Login","New","Save","Select","load","note","package",
        "print","userr","aqua"};
        //DefaultListModel para el JList
        modelList = new DefaultListModel();
        //Agregamos el array de String a la lista
        for (String string : img) {
            modelList.addElement(string);
        }
        //Específicamos el DefaultListModel para nuestro JList
        jLt.setModel(modelList);
        //Indicamos que el JLabel no muestre texto
        jLb.setText(null);
        
        /**
        Imagen tipo JPG para indicar una imagen incial al JLabel
        El resto de las imagenes utilizada son PNG
        Las imagenes debemos de tenerlas en un paquete dentro del mismo proyecto...
        O dentro del mismo paquete que nuestro JFrame, en tal caso solo indicamos el nombre y la extensión,
        Caso contrario debemos de indicar toda la ruta...
        * */        
        jLb.setIcon(createImageIcon("/com/swing/basic/img/" + "acercaFond" + ".jpg"));
    }
    //Método para actualizar la imagenes mostradas en el JLabel
    private void actualizar(){
        imageLabel(jLt.getSelectedValue().toString());
    }
    //Método que requiere como parámetro el nombre del la imagen para mostrar
    private void imageLabel(String nombre){
        jLb.setIcon(createImageIcon("/com/swing/basic/img/" + nombre + ".png"));
    }
    
    //Método que nos permitira cargar una imagen como icono pasándole una url
    private static ImageIcon createImageIcon(String path) {
        java.net.URL imgURL = UsoJRadioButton.class.getResource(path);
        if (imgURL != null) {
            return new ImageIcon(imgURL);
        } else {
            System.err.println("Archivo no encontrado: " + path);
            return null;
        }
    }

En este ejemplo el único elemento que maneja eventos es la lista, la cual utiliza el MouseClicked. En las primeras guías de la serie vimos cómo se implementan los eventos desde el entorno de diseño, si hay dudas se pueden consultar esas entradas.

    private void jLtMouseClicked(java.awt.event.MouseEvent evt) {                                 
        actualizar();
    }  

Ahora sí, podemos ejecutar 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) (clic sobre la imagen para ampliar)

Uso básico de elementos Swing con NetBeans – 29 – Uso de Spinners, ejemplo 2.

Uso básico de Spinners en Java

Para este ejemplo utilizamos dos JSpinner, una para indicar fecha y otra para hora. Aparte de las etiquetas no se utiliza otro elemento, el diseño es bastante sencillo. El proceso es similar al ejemplo uno, se especifica el funcionamiento de cada línea de código con comentarios.

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.

import java.util.Calendar;
import java.util.Date;
import javax.swing.JSpinner;//Importaciones
import javax.swing.SpinnerDateModel;
import javax.swing.SpinnerModel;

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

    /**
     * Creates new form UsoJSliderDos
     */
    public UsoSpinnerDos() {
        initComponents();
        setLocationRelativeTo(null);//Centrar formulario
        inicio();//Método de arranque
    }
    Calendar calendar = Calendar.getInstance();//Variable de Objeto Calendar

Para este ejemplo requerimos de un solo método privado, que se iniciará desde el constructor del JFrame y permitirá inicializar los spinners. Se especifica el funcionamiento de cada línea de código utilizando comentarios. No se requieren eventos para este ejemplo.

    private void inicio(){
        //Obtenemos una fecha de inicio, será la fecha actual del sistema
        Date inicio = calendar.getTime();
        //Indicamos año hasta -100 del actual
        calendar.add(Calendar.YEAR, -100);
        //Guardamos la configuración en un DATE
        Date fechaAnterior = calendar.getTime();
        //Indicamos año hasta +200 del actual
        calendar.add(Calendar.YEAR, 200);
        //Guardamos la configuración en un DATE
        Date fechaPosterior = calendar.getTime();
        //Usamos el contructor de abajo para crear un modelo para el Spinner
        //SpinnerDateModel(Date value, Comparable start, Comparable end, int calendarField)
        //Utilizamos los datos que creamos más arriba
        //Para fecha utilizamos Calendar.YEAR y para hora Calendar.HOUR, el resto puede ser igual
        SpinnerModel fechaModel = new SpinnerDateModel(inicio, fechaAnterior, fechaPosterior, Calendar.YEAR);
        SpinnerModel horaModel = new SpinnerDateModel(inicio, fechaAnterior, fechaPosterior, Calendar.HOUR);
        //Indicamos el model para cada Spinner además del formato de fecha y hora según corresponda.
        fecha.setModel(fechaModel);
        fecha.setEditor(new JSpinner.DateEditor(fecha, "dd/MM/yyyy"));
        hora.setModel(horaModel);
        hora.setEditor(new JSpinner.DateEditor(hora, "HH:mm:ss"));
    }

Ahora sí, podemos ejecutar 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) (clic sobre la imagen para ampliar)

Uso básico de elementos Swing con NetBeans – 28 – Uso de Spinners, lista de elementos.

Trabajando con Spinners desde Java.

En esta oportunidad pondremos en funcionamiento tres Spinnes, que contendrán una lista de días meses y años respectivamente. Como sabemos un spinner puede contener diferentes tipos de elementos sean estas numéricas o no. Para el ejemplo agregaremos tres Spinnes que contendrán cada uno un modelo específico de elementos que se contendrán en Arrays y enteros. Dependiendo del caso se pueden utilizar SpinnerListModel o SpinnerNumberModel.

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.

import java.util.Calendar;
import javax.swing.SpinnerListModel;
import javax.swing.SpinnerModel;//Importaciones
import javax.swing.SpinnerNumberModel;

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

    /**
     * Creates new form UsoSpinner
     */
    public UsoSpinner() {
        initComponents();
        setLocationRelativeTo(null);//Centrar Formulario
        inicio();
    }
    Calendar calendar = Calendar.getInstance();//Variable de Objeto Calendar

Para este ejemplo requerimos de un solo método privado, que se iniciará desde el constructor del JFrame y permitirá inicializar los spinners. Se especifica el funcionamiento de cada línea de código utilizando comentarios. No se requieren eventos para este ejemplo.

    private void inicio(){
        //Array de String para los días y meses
        String[] d = {"Domingo","Lunes","Martes","Miércoles","Jueves","Viernes","Sábado"};
        //El array mes puede contener un registro vacío, se puede corregir con un pequeño ajuste...
        String[] mes = new java.text.DateFormatSymbols().getMonths();
        //Tipo entero para año
        int an = calendar.get(Calendar.YEAR);
        
        //Especificando modelos para cada Spinner
        SpinnerListModel modelDias = new SpinnerListModel(d);
        SpinnerListModel modelMes = new SpinnerListModel(mes);
        //Parámetro numéricos
        //public SpinnerNumberModel(int value, int minimum, int maximum, int stepSize)
        //Valor inicial - valor mínimo - valor máximo - incremento a 1
        SpinnerModel modelAnyo = new SpinnerNumberModel(an, an - 100, an + 100, 1);
        //Agregamos el modelo a cada Spinner
        dias.setModel(modelDias);
        meses.setModel(modelMes);
        anyos.setModel(modelAnyo);
    }

Llegado a esta parte podremos ejecutar 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) (clic sobre la imagen para ampliar)