Códigos para Desarrolladores

▷ Código JAVA: Cómo eliminar espacios de una cadena de texto(String)【Expresiones Regulares - Regular Expression】.

2019-11-14T19:52:00.000-05:00

Código JAVA anterior:
Agregar una imagen de fondo a un JFrame

-------------------------------------------------------------------------------------------

En el siguiente post vamos a aprender cómo eliminar espacios de una cadena de texto(String) para realizar este proceso solo necesitamos escribir tres líneas de código, vamos a aprender a trabajar con expresiones regulares pero no se preocupen será algo bastante sencillo que todos vamos a comprender a la perfección .

Clase EliminarEspacios.java

package app;

public class EliminarEspacios {
           
    public String EliminarEspaciosMetodoInicial(String cadena){

        String newCadena = "";

        for(int i=0; i<cadena.length(); i++){

           if(cadena.charAt(i)!=' ' && cadena.charAt(i)!='\n'){

              newCadena = newCadena + cadena.charAt(i);

        return newCadena;

    public String EliminarEspaciosMetodoSecundario(String cadena){

        StringBuilder newCadena = new StringBuilder(cadena);

        int i=0;
        while(i<newCadena.length()){
            if(cadena.charAt(i)==' ' || cadena.charAt(i)=='\n'){
                newCadena.deleteCharAt(i);
                i--;
            }
            i++;
        }
        
        return newCadena.toString();
    }

    public static void main(String [] args){

        EliminarEspacios principal = new EliminarEspacios();

        String cadena = " Hola Mundo \n 1";

        cadena = principal.EliminarEspaciosMetodoIncial(cadena);
        cadena = principal.EliminarEspaciosMetodoSecundario(cadena);

        System.out.println("Metodo Inicial: "+cadena+ " longitud: "+cadena.length());
        System.out.println("Método Secundario: "+cadena+ " longitud: "+cadena.length());

        cadena = cadena.replaceAll("\\s+", "");
        System.out.println("Cadena: "+cadena+ " Longitud: "+cadena.length());

    }
        
}

VÍDEO TUTORIAL (PASO A PASO)

1. En la sección superior del POST tenemos la clase de nuestro proyecto en la cual tenemos varios métodos alternos que cumplen la misma función del método que estaremos explicando, pero hay que reconocer que el siguiente método nos resumirá mucho las cosas.

Lo primero que vamos a hacer es crear una variable de tipo String a la cual llamaremos cadena y le asignaremos una cadena de texto (" Hola Mundo \n 1") la cual contiene espacios en blanco que estaremos eliminando posteriormente.

String cadena = " Hola Mundo \n 1";

Lo segundo que debemos hacer es realizar un proceso de reasignación en el cual nuestro String (variable cadena) le asignaremos un nuevo valor el cual será nuestra cadena de texto con los espacios en blanco eliminados. Para esto hacemos uso del método replaceAll(param1, param2) el cual recibirá dos parametros.

Nuestro primer parámetro será una expresión regular la cual nos permitirá identificar todos los espacios en blanco de nuestra cadena de texto \\s+.

Nuestro segundo parámetro hace referencia al nuevo carácter a agregar que en este caso sera un carácter vacío ""

cadena = cadena.replaceAll("\\s+", "");

Para finalizar solo bastará con imprimir un mensaje por consola para verificar que nuestro ejercicio se haya ejecutado correctamente.

System.out.println("Cadena: "+cadena+ " Longitud: "+cadena.length());

2. Aquí tenemos una captura del proyecto ya terminado, la longitud o cantidad de caracteres inicial del String es de 15, pero al realizar el proceso de eliminación de espacios, la cadena queda con una longitud de 10.

Ejecución por consola del proyecto

Puedes visitar el repositorio de GitHub de este proyecto AQUI.

Hemos finalizado.
Puedes seguir disfrutando de todas las entradas que tenemos disponibles para ti, para que sigas fortaleciendo conocimientos y aprendiendo tips en todo lo relacionado al mundo de java, próximamente volveremos con más contenido para seguir aprendiendo aun mas.

Suscríbete a nuestro blog, vía Email o RSS; además puedes seguirnos a través de nuestras redes sociales como: Facebook, Twitter, y Google+.

¿Conoces una forma más óptima de realizar el anterior procedimiento?, no dudes en compartir tu conocimiento con todos nuestros amigos de la web.

Si te fue de gran ayuda esta información, no olvides compartirla con tus amigos y en las redes sociales.
Si tienes dudas o sugerencias al respecto, abajo puedes dejarnos tus comentarios.
Bendiciones...

▷ Código JAVA: Agregar imagen de fondo a un JFrame

2019-04-10T20:51:00.001-05:00

Código JAVA anterior:
Cargar JCombobox con registros de una base de datos

-------------------------------------------------------------------------------------------

En el siguiente post vamos a aprender como agregar o mostrar una imagen de fondo en una ventana JFrame, lo cual nos será de gran utilidad ya que es algo que en ocasiones se nos hace necesario agregar a nuestros proyectos, ya sea por petición del cliente o simplemente para embellecer nuestra interfaz gráfica(GUI), solo nos bastara con agregar unas pocas líneas de código y ya tendremos una imagen de fondo que mostrar.

Clase VentanaPrincipal.java(JFrame)

package ventanaconimagen;

import java.awt.BorderLayout;
import java.awt.Dimension;
import javax.swing.JFrame;

public class VentanaPrincipal extends JFrame{
    
    panelImage panel = new panelImage();
       
    public VentanaPrincipal(){
        
        this.setTitle("Ventana con Imagen");
        this.setSize(new Dimension(700, 700));        
        this.setLocationRelativeTo(null);
        
        this.add(panel, BorderLayout.CENTER);
    }

    public static void main(String [] args){

        VentanaPrincipal frame = new VentanaPrinciapl();

        frame.setVisible(true);

Clase panelImage (JPanel):

package ventanaconimagen;

import java.awt.Dimension;
import java.awt.Graphics;
import javax.swing.ImageIcon;
import javax.swing.JPanel;

public class panelImage extends JPanel{

    @Override
    public void paint(Graphics g){
        Dimension dimension = this.getSize();
        ImageIcon icon = new ImageIcon(getClass().getResource("/imagenes/image1.jpg"));
        g.drawImage(icon.getImage(), 0, 0, dimension.width, dimension.height, null);
        setOpaque(false);
        super.paintChildren(g);
    }
 
    
}

VÍDEO TUTORIAL (PASO A PASO)

Instrucciones y Recomendaciones

1. Iniciemos con lo básico, esto será explicar la estructura de nuestro proyecto, que en realidad es una estructura muy sencilla pero muy importante ya que el entender cómo se encuentra dividida esta, nos ayudara a comprender todo el desarrollo de la misma.

ventanaConImagen(Nombre del proyecto)
- SourcePackages
  - imagenes (Paquete donde almacenamos las imagenes)
    - image1.jpg
  - ventanaconimagen (paquete que contendrá todas las clases)
    - VentanaPrincipal.java
    - panelImage.java
- TestPackages
  - <DefaultPackage>
- Libraries (Librerías requeridas)
  - JDK 1.8 (Default)
- Test Libraries

Lo que acabamos de ver como bien dijimos es la estructura de nuestro proyecto, la cual posee dos paquetes que serán el núcleo de nuestro desarrollo, tenemos el paquete imagenes donde vamos almacenar la imagen que vamos agregar de fondo, y tenemos el paquete ventanaconimagen, en este irán las clases que vamos a crear, que serán: la clase del JFrame(VentanaPrincipal) y la clase del JPanel(panelImage), en un momento ampliaremos aún más como trabajaran estas dos clases.

2. Iniciamos con la clase principal, lo primero que debemos hacer es aplicar el concepto de herencia y así poder utilizar los componentes, objetos, métodos y procedimientos de la clase JFrame, la primera línea de código quedaría de la siguiente manera:

public class VentanaPrincipal extends JFrame{

Solamente necesitamos escribir la palabra clave extends, seguido del nombre de la clase que en este caso será JFrame, de suma importancia importar el paquete al cual pertenece la clase, para esto en la parte superior de nuestra clase debemos escribir lo siguiente:

import java.awt.BorderLayout;
import java.awt.Dimension;
import javax.swing.JFrame;

3. Una vez hecho lo básico debemos crear el método constructor de la clase y de esta manera agregar los atributos que llevara nuestra ventana JFrame, por ejemplo: el título, las dimensiones que tendrá la ventana JFrame, la ubicación que llevará la ventana y el layout con el que trabajaremos para distribuir los componentes, para este ejemplo trabajaremos con BorderLayout, un layout muy fácil de usar así que no tendremos muchos problemas con este.

    public VentanaPrincipal(){
        
        this.setTitle("Ventana con Imagen");
        this.setSize(new Dimension(700, 700));        
        this.setLocationRelativeTo(null);
        
        this.add(panel, BorderLayout.CENTER);
    }

Tenemos el método constructor, la primera línea de código será para agregar un título a nuestra ventana JFrame.

La segunda línea de código será para agregar las dimensiones de nuestra ventana tanto en ancho como en alto, para esto hacemos uso de la clase Dimension y le pasamos dos parámetros que equivalen a las dimensiones de la ventana JFrame(700, 700).

La tercera línea de código la utilizaremos para que la ventana JFrame a la hora de ejecutar nuestra aplicación aparezca en el centro de la pantalla, para esto hacemos uso del método setLocationRelativeTo, y le pasamos como parámetro null.

La ultima línea de código la utilizaremos para agregar un componente a nuestra ventana JFrame, este componente será el JPanel que contiene la imagen de fondo, para esto hacemos uso del método add, al cual le pasamos dos parámetros: el primero sera nuestro JPanel(panel) y el segundo será el layout que vamos a utilizar para distribuir ese componente, este ejemplo lo vamos a trabajar con BorderLayout y agregamos dicho componente en el centro de nuestra ventana y de esta manera ocupará todas las dimensiones de la misma.

Fuera del método constructor debemos crear un objeto de la clase panelImage la cual hereda de la clase JPanel este será el componente que agregaremos a la ventana JFrame.

panelImage panel = new panelImage();

4. Siguiendo en la clase VentanaPrincipal.java lo que restaría por hacer seria agregar el método main, en el cual simplemente vamos a crear una instancia de la clase, seguido a esto llamamos al método setVisible y de esta manera nuestra ventana JFrame se visualizara.

public static void main(String [] args){
  VentanaPrincipal frame = new VentanaPrinciapl();
  frame.setVisible(true);
}

5. A partir de aquí vamos a estar trabajando con la clase panelImage.java, esta será la clase donde agregaremos las líneas de código que nos permitirá tener una imagen de fondo en nuestro JPanel.
Iniciamos con lo básico, aplicamos el concepto de herencia y para esto escribimos la palabra clave extends, seguido a esto escribimos el nombre de la clase que en este caso es JPanel, de esta manera nuestra clase panelImage.java hereda los métodos, procedimientos y propiedades que esta posee.

public class panelImage extends JPanel{

6. Aquí tenemos el método donde se realizara toda la operación para agregar la imagen; vamos a estar explicando linea por linea, les resultara fácil comprender la idea.

@Override
public void paint(Graphics g){
   Dimension dimension = this.getSize();
   ImageIcon icon = new ImageIcon(getClass().getResource("/imagenes/image1.jpg"));
   g.drawImage(icon.getImage(), 0, 0, dimension.width, dimension.height, null);
   setOpaque(false);
   super.paintChildren(g);
}

a. Iniciamos con la primera línea la cual es la estructura de un método tipo void o procedimiento al cual llamamos paint, este método llevara un parámetro que no es mas que un objeto perteneciente a la clase Graphics, el cual hemos llamado g.

public void paint(Graphics g){

b. Lo siguiente que haremos será crear un objeto de tipo Dimension, el cual le asignaremos las dimensiones que tiene nuestro JPanel haciendo uso del metodo getSize.

Dimension dimension = this.getSize();

c. Hemos llegado a un punto crucial, y este es la creación de nuestra imagen de fondo, para esto creamos un objeto de tipo ImageIcon al cual le vamos agregar nuestra imagen, para acceder a la imagen que vamos a agregar debemos especificar la ruta en que esta se encuentra, lo hacemos a través del metodo getResource y le pasamos como parámetro el nombre de nuestro paquete y seguido a esto el nombre de nuestra imagen, por esta razón es recomendable que a la hora de trabajar con imágenes en nuestros proyectos siempre estén dentro del mismo, ya que si tenemos una imagen en una ruta externa el proceso seria un poco mas complicado, yo siempre recomiendo crear un paquete para almacenar todas la imágenes que vayamos a agregar.

ImageIcon icon = new ImageIcon(getClass().getResource("/imagenes/image1.jpg"));

d. Ahora vamos a dibujar esa imagen en nuestro JPanel para esto hacemos uso del objeto Graphics y llamamos al método drawImage este llevara los siguientes parámetros:
*El primer parámetro sera nuestro objeto de tipo ImageIcon como bien sabemos este contiene la imagen que vamos a agregar.
*El segundo y tercer parámetro serán dos valores enteros que equivalen a la posición en el eje de las x y las y, en nuestro ejemplo ambos valores serán cero(0).
*El cuarto y quinto parámetro serán las dimensiones que tendrá nuestra imagen, para este ejemplo las dimensiones sera iguales a las dimensiones de nuestro JPanel de esta manera garantizamos que la imagen tenga el mismo tamaño de nuestra ventana JFrame.
*El ultimo parámetro solamente pasamos un valor null

g.drawImage(icon.getImage(), 0, 0, dimension.width, dimension.height, null);

e. Para finalizar debemos hacer algo muy importante, cuando trabajos con imágenes de fondo necesitamos que los componentes que vayamos agregar se puedan visualizar o superponer a la imagen, por lo tanto debemos hacer uso del método setOpaque y pasar como parámetro false, de esta manera no tendríamos problemas a la hora de agregar componentes a nuestro JPanel.

setOpaque(false);

7. Aquí tenemos una captura del proyecto ya terminado.

Ventana JFrame con imagen de fondo

Hemos finalizado.
Puedes seguir disfrutando de todas las entradas que tenemos disponibles para ti, para que sigas fortaleciendo conocimientos y aprendiendo tips en todo lo relacionado al mundo de java, próximamente volveremos con mas contenido para seguir aprendiendo aun mas.

Suscríbete a nuestro blog, vía Email o RSS; además puedes seguirnos a través de nuestras redes sociales como: Facebook, Twitter, y Google+.

▷ Código JAVA: Cargar JComboBox con registros de una base de datos parte II

2018-07-09T18:05:00.000-05:00

Código JAVA anterior:

Código JAVA: Cambiar de un JPanel a otro con botón siguiente y atrás

-------------------------------------------------------------------------------------------

Este post está orientado a la aplicación e implementación de un bloque de código JAVA, que nos permitirá mostrar en un ComboBox los registros almacenados en varias tablas de una base de datos; lo cual, nos ayudará a tener formularios más dinámicos, ya que, en este caso, componentes como los JComboBox mostrarán información actualizada a medida que alimentemos nuestra base de datos.

Introducción

Para la realización de nuestro ejemplo, estaremos utilizando tres paquetes y de esta manera organizar las distintas clases que utilizaremos, La distribución de las clases quedaría de la siguiente manera.

combobox-anidados (Nombre del proyecto)
- SourcePackages
  - comboboxanidados (Primer paquete)
    - Principal.java
  - controlador (Segundo paquete)
    - controlador.java
  - modelo (Tercer paquete)
    - ciudad.java
    - departamentos.java
    - estados.java
    - metodos.java
    - pais.java
    - pool.java
- TestPackages
  - <DefaultPackage>
- Libraries (Librerías requeridas)
  - commons-dcp-1.0.jar
  - commons-pool-1.6.jar
  - JDK 1.8 (Default)
- Test Libraries

La Base De Datos estará compuesta por lo siguiente:

4 tablas, estas serán la tabla países, esta tendrá dos campos; uno de tipo entero (id_pais) esta será la clave primaria, otro campo de tipo varchar (paises) donde se almacenara el nombre de cada país.

La tabla estados estará compuesta por tres campos; dos campos tipo entero (id_estado, id_pais), uno de estos será la llave primaria (id_estado) y otro será la llave foránea (id_pais), tendrá un campo tipo varchar donde se almacenara los nombres de los respectivos estados. La tabla estado tendrá una relación de uno a muchos con la tabla países.

Seguimos con la tabla departamentos la cual posee 4 campos, 3 de tipo entero(id_dep, id_pais, id_estado) dos de estos campos son llave foránea(id_pais, id_estado) y uno llave primaria(id_dep) igualmente posee un campo tipo varchar(departamento).

Por ultimo tenemos la tabla ciudad, esta posee 3 campos; dos tipo entero uno es llave primaria(id_ciudad) y el otro es la llave foránea( id_departamento) igualmente posee un campo de tipo varchar(ciudad).

NOTA: Las tablas que poseen claves foráneas tienen una relación de uno a muchos

Te recomiendo que visites los siguientes POST para ampliar conocimientos relacionado al tema que trataremos:
Curso de JAVA: Cómo hacer un Pool de Conexiones?
Curso de JAVA: Cómo llenar JComboBox con Base de Datos
¿Deseas descargar este ejemplo completo? AQUI!!!

Clase Principal JFrame: comboboxanidados/Principal.java

package  comboboxanidados;
import  controlador.controlador;
import  java.awt.Color;    

public class Principal extends javax.swing.JFrame {

     // Creamos un objeto de la clase controlador
     controlador controlador;

     //Creamos el método constructor de la clase

     public Principal() {

              initComponents();

              this.setLocationRelativeTo(null);
              this.setBackground(Color.yellow);

              cb_estado.setVisible(false);
              label_estado.setVisible(false);

              controlador = new  controlador(this);
      }

    
    public static void main(String args[]) {

              java.awt.EventQueue.invokeLater(new Runnable() {

                   @Override

                   public void run() {

                        new Principal().setVisible(true);

                   }

              });


      }

  }

Clase Controlador: controlador/controlador.java

package controlador;

import comboboxanidados.Principal;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;
import javax.swing.DefaultComboBoxModel;
import modelo.ciudad;
import modelo.departamentos;
import modelo.estados;
import modelo.metodos;
import modelo.pais;

public class controlador implements ActionListener{

// creamos un objeto de la clase Principal y un objeto de la clase métodos  
    Principal vista;
    metodos metodosDB = new metodos();

    // creamos 4 objetos de tipo Arraylist los cuales lleva como parámetro las clases pais, estados, departamentos y ciudad respectivamente 
    ArrayList<pais> paises;
    ArrayList<estados> estados;
    ArrayList<departamentos> departamentos;
    ArrayList<ciudad> ciudad;

    // creamos un método para agregar los eventos  
    public final void events(){
    
        vista.cb_pais.addActionListener(this);
        vista.cb_estado.addActionListener(this);
        vista.cb_dep.addActionListener(this);        
        
    } 

// método constructor
  public controlador(Principal vista){
    
        this.vista=vista;
        events();

       
        mostrarPais();
        mostrarDepartamentos("",paises.get(0).getID());
        mostrarCiudad("", paises.get(0).getID(), departamentos.get(0).getIddep());
    
    }


  // obtenemos y agregamos al combobox paises todos los datos obtenidos de la tabla país de la base de datos

  public final void mostrarPais(){

        // agregamos al arraylist los países obtenidos de la DB


        paises=metodosDB.listarPaises();
        
        String array[]=new String[paises.size()];
        
        for (int i = 0; i <array.length; i++) {
            
            array[i]=paises.get(i).getPais();
            
        }
        
        DefaultComboBoxModel model = new DefaultComboBoxModel(array);

        vista.cb_pais.setModel(model);
        
    }


    public void mostrarEstados(String idPais){
    
        estados = metodosDB.listarEstados(idPais);
        
        String arr[] = new String[estados.size()];
        for(int i=0; i<estados.size(); i++){
            arr[i]=estados.get(i).getEstados();
        }
        DefaultComboBoxModel model = new DefaultComboBoxModel(arr);
        vista.cb_estado.setModel(model);            
        
    }



    public final void mostrarDepartamentos(String idEst, String idPais){
    
        departamentos = metodosDB.listarDepartamentos(idPais, idEst);
        
        String arr[] = new String[departamentos.size()];
        for(int i=0; i<departamentos.size(); i++){
            arr[i]=departamentos.get(i).getDepartamentos();
        }
        DefaultComboBoxModel model = new DefaultComboBoxModel(arr);
        vista.cb_dep.setModel(model);        
        
    
    }  
  

    public final  void mostrarCiudad(String idEst, String idPais, String idDepartamento){
        
        ciudad = metodosDB.listarCiudad(idEst, idPais, idDepartamento);
        
        String arr[] =  new String[ciudad.size()];
        for(int i=0; i<ciudad.size(); i++){
            arr[i]=ciudad.get(i).getCiudad();
        }
        
        DefaultComboBoxModel model = new DefaultComboBoxModel(arr);
        vista.cb_ciudad.setModel(model); 
                
    }  

  

    public String getIdPais(ArrayList<pais> pais, String busqueda){
    
        String id;
        
        int i=0;
        
        while(!pais.get(i).getPais().equals(busqueda)){
            i++;
        }
        
        id=pais.get(i).getID();
        
        return id;
    
    }

    
  

    public String getIdDepartamento(ArrayList<departamentos> departamentos, String busqueda){
    
        String id;
                 
        int i=0;
        
        while(!departamentos.get(i).getDepartamentos().equals(busqueda)){
            i++;
        }
        
        id=departamentos.get(i).getIddep();
        
        return id;
    
    }
    
  

    public String getIdEstado(ArrayList<estados> estados, String busqueda){
    
        String id;
        
        int i=0;
        
        while(!estados.get(i).getEstados().equals(busqueda)){
            i++;
        }
        
        id=estados.get(i).getIdest();
        
        return id;
    } 

    @Override

    public void actionPerformed(ActionEvent e) {

        Object evt = e.getSource();
        
        if(vista.cb_pais.equals(evt)){
        
            if(!vista.cb_pais.getSelectedItem().toString().equals("Estados Unidos")){
                
                vista.cb_estado.setVisible(false);
                vista.label_estado.setVisible(false);

                String idPais = getIdPais(paises, vista.cb_pais.getSelectedItem().toString());
                mostrarDepartamentos("", idPais);
                
                String idDep = getIdDepartamento(departamentos, vista.cb_dep.getItemAt(0));
                mostrarCiudad("", idPais, idDep);
                
            }else{
            
                vista.cb_estado.setVisible(true);
                vista.label_estado.setVisible(true);            
                
                String idPais = getIdPais(paises, vista.cb_pais.getSelectedItem().toString());
                mostrarEstados(idPais);

                String idEst = getIdEstado(estados, vista.cb_estado.getItemAt(0));
                mostrarDepartamentos(idEst, idPais);

                String idDep = getIdDepartamento(departamentos, vista.cb_dep.getItemAt(0));
                mostrarCiudad(idEst, idPais, idDep);                
                
                
            }
            
        
        }else if(vista.cb_estado.equals(evt)){
        
            String idPais = getIdPais(paises, vista.cb_pais.getSelectedItem().toString());

            String idEst = getIdEstado(estados, vista.cb_estado.getSelectedItem().toString());
            mostrarDepartamentos(idEst, idPais);

            String idDep = getIdDepartamento(departamentos, vista.cb_dep.getItemAt(0));
            mostrarCiudad(idEst, idPais, idDep);
            
        }else if(vista.cb_dep.equals(evt)){
        
            if(vista.cb_estado.isVisible()){
            
                String idPais = getIdPais(paises, vista.cb_pais.getSelectedItem().toString());
                String idEst = getIdEstado(estados, vista.cb_estado.getSelectedItem().toString());
                String idDep = getIdDepartamento(departamentos, vista.cb_dep.getSelectedItem().toString());
                mostrarCiudad(idEst, idPais, idDep);
            
            }else{
                
                String idPais = getIdPais(paises, vista.cb_pais.getSelectedItem().toString());
                String idDep = getIdDepartamento(departamentos, vista.cb_dep.getSelectedItem().toString());
                mostrarCiudad("", idPais, idDep);
            
            }     
               
        }      

    }
    
}

Clase Ciudad: modelo/ciudad.java

package modelo;

public class ciudad {
    
    String ciudad;
    String idciudad;


    
      public ciudad() {
        ciudad="";
        idciudad="";
    }
    

    
      public String getCiudad() {
        return ciudad;
    }

    
    public void setCiudad(String ciudad) {
        this.ciudad = ciudad;
    }

    public String getIdciudad() {
        return idciudad;
    }

    public void setIdciudad(String idciudad) {
        this.idciudad = idciudad;
    }
    
}

Clase departamentos: modelo/departamentos.java

package modelo;

public class departamentos {

    String departamentos;;
    String iddep;;

    
      public departamentos() {
        departamentos="";
        iddep="";
    }
    

    
      public String getDepartamentos() {
        return departamentos;
    }

    
    public void setDepartamentos(String departamentos) {
        this.departamentos = departamentos;
    }

    
      public String getIddep() {
        return iddep;
    }

    
      public void setIddep(String idciudad) {
        this.iddep = iddep;
    }
    
}

Clase estados: modelo/estados.java

package modelo;

public class estados {

    String estados;;
    String idest;;

    
      public estados() {
        estados="";
        idest="";
    }
    

    
      public String getEstados() {
        return estados;
    }

    
    public void setEstados(String estados) {
        this.estados = estados;
    }

    
      public String getIdest() {
        return idest;
    }

    
      public void setIdest(String idest) {
        this.idest = idest;
    }
    
}

Clase pais: modelo/pais.java

package modelo;

public class pais {

    String pais;;
    String ID;;

    
      public pais() {
        pais="";
        ID="";
    }
    

    
      public String getPais() {
        return pais;
    }

    
    public void setPais(String pais) {
        this.pais = pais;
    }

    
      public String getID() {
        return ID;
    }

    
      public void setID(String ID) {
        this.ID = ID;
    }
    
}

Clase metodos: modelo/metodos.java

package modelo;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import javax.swing.JOptionPane;

public class metodos {

    pool conectar;


    public metodos() {
        conectar = new pool();
    }



    public ArrayList<pais> listarPaises(){
    
        Connection connect = null;
        PreparedStatement pst;
        ResultSet rs;
        pais pais;
        ArrayList list = new ArrayList();
        
        
        try {
        
            connect = conectar.dataSource.getConnection();
            
            if(connect!=null){
            
                String sql = "SELECT id_pais, pais FROM paises WHERE 1 ORDER BY  pais ASC";
                
                pst = connect.prepareStatement(sql);
                pst.executeQuery();
                rs = pst.getResultSet();
                
                while(rs.next()){
                
                    pais = new pais();
                    
                    pais.setID(rs.getString("id_pais"));
                    pais.setPais(rs.getString("pais"));
                
                    list.add(pais);
                
                }
                
            
            }
            
        
        } catch (SQLException e) {
        
            JOptionPane.showMessageDialog(null, "Error "+e, "ERR", JOptionPane.ERROR_MESSAGE);        
        
        }finally{
        
            try{
                connect.close();
            }catch(SQLException ex){
                System.out.println("error "+ex);
            }
        
        }
        
        return list;
        
    }
    
   
    
    public ArrayList<estados> listarEstados(String idPais){
    
        Connection connect = null;
        PreparedStatement pst;
        ResultSet rs;
        estados estados;
        ArrayList list = new ArrayList();        
    
    
        try {
            
            connect = conectar.dataSource.getConnection();
            
            if(connect!=null){
            
                String sql = "SELECT id_estado, estado FROM estados INNER JOIN paises on(estados.id_pais=paises.id_pais) "
                           + "WHERE paises.id_pais=? ORDER BY estado ASC";

                pst = connect.prepareStatement(sql);

                pst.setString(1, idPais);
                
                pst.executeQuery();
                rs = pst.getResultSet();
                
                while(rs.next()){
                    
                    estados  = new estados();

                    estados.setIdest(rs.getString("id_estado"));
                    estados.setEstados(rs.getString("estado"));
                    
                    list.add(estados);

                }
                
                
            
            }
            
            
        } catch (SQLException e) {
            JOptionPane.showMessageDialog(null, "Error "+e, "ERR", JOptionPane.ERROR_MESSAGE);        
        }finally{
        
            try{
                connect.close();
            }catch(SQLException ex){
                System.out.println("error "+ex);
            }
        
        }
        
        return list;

    }
    
    
    
    public ArrayList<departamentos> listarDepartamentos(String idPais, String idEstado){
    
        Connection connect=null;
        PreparedStatement pst;
        ResultSet rs;
        departamentos departamentos;
        ArrayList list = new ArrayList();  
        
    
        try {
            
            connect = this.conectar.dataSource.getConnection();
        
            if(connect!=null){
            
                if(!idEstado.equals("")){
                
                    String sql = "SELECT departamentos.id_dep, departamentos.departamento "
                                + "FROM departamentos INNER JOIN estados ON (estados.id_estado=departamentos.id_estado) INNER JOIN paises ON (paises.id_pais=estados.id_pais) "
                                + "WHERE  estados.id_estado=? AND paises.id_pais=?";
                
                    pst = connect.prepareStatement(sql);
                    
                    pst.setString(1, idEstado);
                    pst.setString(2, idPais);
                
                }else{
                
                    String sql =  "SELECT departamentos.id_dep, departamentos.departamento "
                                + "FROM departamentos INNER JOIN paises ON (paises.id_pais=departamentos.id_pais) "
                                + "WHERE  paises.id_pais=?";

                    pst = connect.prepareStatement(sql);
                    
                    pst.setString(1, idPais);
                
                    
                }
                
                pst.executeQuery();
                rs = pst.getResultSet();

                while(rs.next()){
                    
                    departamentos = new departamentos();
                    
                    departamentos.setIddep(rs.getString("id_dep"));
                    departamentos.setDepartamentos(rs.getString("departamento"));
                    
                    list.add(departamentos);                    
                    

                }
                
                
                
            
            }
            
        } catch (SQLException e) {
            
            JOptionPane.showMessageDialog(null, "Error "+e, "ERR", JOptionPane.ERROR_MESSAGE);        
        
        }finally{
        
            try{
              connect.close();
            }catch(SQLException ex){
                System.out.println("error "+ex);
            }
        
        }
        
        return list;
            
        
    }
        

    public ArrayList<ciudad> listarCiudad(String idEst, String idPais, String idDep){
    
        Connection connect=null;
        PreparedStatement pst;
        ResultSet rs;
        ciudad ciudades;
        ArrayList list = new ArrayList();          
    
    
        try {
        
            connect = conectar.dataSource.getConnection();

            if(connect!=null){
                
                if(!idEst.equals("")){
                    
                    String sql = "SELECT ciudad "
                           + "FROM ciudad inner JOIN departamentos ON(departamentos.id_dep=ciudad.id_departamento) INNER JOIN estados ON (estados.id_estado=departamentos.id_estado) INNER JOIN paises ON (paises.id_pais=estados.id_pais)"
                           + "WHERE paises.id_pais=? And estados.id_estado=? And departamentos.id_dep=?";
                    
                    pst = connect.prepareStatement(sql);
               
                    pst.setString(1, idPais);
                    pst.setString(2,idEst);
                    pst.setString(3, idDep);
                    
                    
                }else{
                    
                    String sql = "SELECT ciudad "
                            + "FROM ciudad  "
                            + "INNER JOIN departamentos on (departamentos.id_dep=ciudad.id_departamento) INNER JOIN paises ON (paises.id_pais=departamentos.id_pais) "
                            + " WHERE ciudad.id_departamento=? And paises.id_pais=? ORDER BY ciudad ASC";

                    pst = connect.prepareStatement(sql);
               
                    pst.setString(1, idDep);
                    pst.setString(2,idPais);
                    
                    
                }
                
                pst.executeQuery();
                rs = pst.getResultSet();                
                
                while(rs.next()){
                    
                    ciudades  = new ciudad();

                    ciudades.setCiudad(rs.getString("ciudad"));
                    
                    list.add(ciudades);

                }

                
                
                
            
            }
            
            
        
        
        } catch (Exception e) {
        
             JOptionPane.showMessageDialog(null, "Error "+e, "ERR", JOptionPane.ERROR_MESSAGE);        
        
        }finally{
        
            try{
                connect.close();
            }catch(SQLException ex){
                System.out.println("error "+ex);
            }
        
        }
        
    
        return list;
                
    
    }
        
        
        
    
    }

Clase pool: modelo/pool.java


package modelo;

import javax.sql.DataSource;
import org.apache.commons.dbcp.BasicDataSource; 

public class pool {
    
    public DataSource dataSource;
    
    public String db = "db_pais1";
    String url = "jdbc:mysql://localhost:3306/"+db+"?useUnicode=true&characterEncoding=utf-8";
    public String user = "root";
    public String pass = "";

    public pool(){

        inicializaDataSource();

    }

    private void inicializaDataSource(){


        BasicDataSource basicDataSource = new BasicDataSource();

        basicDataSource.setDriverClassName("com.mysql.jdbc.Driver");
        basicDataSource.setUsername(user);
        basicDataSource.setPassword(pass);
        basicDataSource.setUrl(url);
        basicDataSource.setMaxActive(50);

        dataSource = basicDataSource;

    }

    

    
}

VIDEO TUTORIAL (PASO A PASO)

Instrucciones y Recomendaciones

1. Comenzaremos con lo básico. Para este ejemplo crearemos cuatro clases que harán referencia a las 4 tablas que tenemos en la base de datos, estas clases son: país.java, estados.java, departamentos.java, ciudad.java. Estas clases pertenecen al paquete modelo y las utilizaremos para guardar la información que obtengamos de la Base De Datos. Procederemos a explicar el código de las clases.
estas tienen una estructura similar, básicamente lo que se hace es inicializar las variables y crear lo métodos GET y SET que nos permitirán obtener y mostrar lo valores que obtendremos, tomaremos como ejemplo general la clase pais.java.

Clase Pais.java:

* Comenzamos creando dos variables de tipo String, estarán ubicadas después de las llaves de apertura de nuestra clase. Una la hemos llamado pais y la otra ID, haciendo referencia a los campos que tenemos en nuestra tabla país (Ubicada en la base de datos).

String pais;;
    String ID;

* Lo siguiente que haremos será crear el método constructor de nuestra clase(pais.java), una vez creado dicho método procedemos a inicializar la variables pais e ID

   public pais() {
        pais="";
        ID="";
    }

* El siguiente paso será crear los métodos GET Y SET, todos serán de acceso public con el fin de acceder a estos métodos desde otras clases, más adelante podremos apreciar el funcionamiento de estos métodos.

    public String getPais() {
        return pais;
    }
    
    public void setPais(String pais) {
        this.pais = pais;
    }

      public String getID() {
        return ID;
    }

      public void setID(String ID) {
        this.ID = ID;
    }

* Las clases estados.java, departamentos.java y ciudad.java tendrán la misma estructura lo que cambiaran serán los nombres de las variables.

2. Seguimos en el paquete modelo, lo siguiente que haremos será crear una clase que nos permitirá consultar la información que deseamos de la base de datos a esta clase le hemos llamado métodos, Miremos la estructura de esta.

Creamos un objeto de la clase pool, este nos permitirá establecer una conexión con la base de datos, igualmente inicializamos el objeto en el método constructor.

pool conectar;

  public metodos() {
     conectar = new pool();
  }

3. Lo siguiente que haremos será crear una función, que nos permita obtener el listado de países alojados en la base de datos, específicamente en la tabla países, revisemos detalladamente cada línea.

*La función comienza con el modificador de acceso de tipo public, recordemos que esto lo hacemos para poder llamar a la función desde otras clases. Seguido del tipo en este caso la función será de tipo ArrayList y este será de tipo <pais>, la función la llamaremos listarPaises

    public ArrayList<pais> listarPaises(){

*Iniciamos creando un objeto de tipo Connection al cual llamaremos connect, este nos permitirá administrar la conexión que obtengamos de la base de datos.
Lo siguiente será crear un objeto de tipo PreparedStatement, este nos servirá para cargar la sentencia SQL que utilizaremos. Igualmente creamos un objeto de tipo ResultSet el cual nos servirá para obtener los resultados que obtendremos de la consulta SQL.
Creamos un objeto de tipo pais para guardar los resultados obtenidos y por ultimo creamos un objeto de tipo ArrayList para agregar todos los resultados obtenidos.

   Connection connect=null;
   PreparedStatement pst;
   ResultSet rs;
   pais pais;
   ArrayList list = new ArrayList();

NOTA: Debemos importar las siguientes librerias para evitar errores


package modelo;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import javax.swing.JOptionPane;

*Lo siguiente que haremos será crear un bloque de tipo try{} catch(){} finally{}, recordemos que en la sección del try ira todo el código que deseamos ejecutar, en la parte del catch se mostrara un mensaje dependiendo si surge algún error en la ejecución del código de la sección del try y por último la sección del finally ejecutaremos un código para cerrar la conexión con la base de datos.

   try {
       
                    
   } catch (SQLException e) {
        
       JOptionPane.showMessageDialog(null, "Error "+e, "ERR", JOptionPane.ERROR_MESSAGE);        
        
   }finally{
        
      try{
         connect.close();
      }catch(SQLException ex){
          System.out.println("error "+ex);
      }
        
   }

*En la sección del try{}, comenzamos escribiendo la línea de código que nos permitirá establecer una conexión con la base de datos, haciendo uso del objeto tipo Connection(connect), y luego del signo igual "=" procederemos a usar el objeto "pool", con el cual tendremos acceso al objeto y/o variable de tipo "DataSource" de la Clase Pool que creamos en un artículo anterior, aplicándole posteriormente el método ".getConnection()"; con esto, estaremos estableciendo la conexión con la base de datos:.

  connect = conectar.dataSource.getConnection();

*Lo siguiente que haremos será verificar si la conexión a la base de datos ha sido exitosa, esto lo verificamos con un condicional.

  if(connect!=null){

*Dentro de las llaves de apertura y cierre del condicional, escribimos las siguientes líneas de código:
Comenzamos creando una variable de tipo String(sql), la cual contendrá la sentencia SQL que utilizaremos para obtener el listado de países alojados en la base de datos (ver explicación de la estructura de sentencias SQL para consultar información de una base de datos), luego cargamos la sentencia haciendo uso del objeto PreparedStatement(pst) una cargada la sentencia aplicamos el método executeQuery() luego obtenemos el resultado de la consulta haciendo uso del objeto ResultSet(rs), aplicamos el método getResultSet().

  String sql = "SELECT id_pais, pais FROM paises WHERE 1 ORDER BY  pais ASC";
  
  pst = connect.prepareStatement(sql);
  pst.executeQuery();
  rs = pst.getResultSet();

*Por ultimo creamos un ciclo while.
Comenzamos inicializando el objeto tipo pais (pais = new pais()), haremos uso de los métodos SET pertenecientes a la clase pais(setID, setPais) y de esta manera obtener los resultados obtenidos de la consulta SQL, para obtener estos valores hacemos uso de la función getString entre paracentesis() iría el nombre del campo en este caso seria "id_pais" y "pais" pertenecientes a la tabla paises de nuestra Base de Datos.
Terminado el proceso anterior agregamos al ArrayList (list), el objeto "pais" .
Una vez terminado el ciclo escribimos la palabra clave return seguido del objeto ArrayList(list).

while(rs.next()){
                
  pais = new pais();
                  
  pais.setID(rs.getString("id_pais"));
  pais.setPais(rs.getString("pais"));
                
  list.add(pais);
                
}

return list;

4. Una vez creado el método listarPaises, crearemos un método que nos permitirá obtener los estados de determinado país, llevara la misma estructura del método anterior, solamente tendrá algunos cambios.

*La función será de tipo ArrayList y a diferencia del anterior este será de tipo <estados>, seguido del nombre de la función (listarEstados), esta llevara como parámetro una variable de tipo String la cual hará referencia al id que identifica a un determinado país en la base de datos

 public ArrayList<estados> listarEstados(String idPais){

*Para obtener los estados pertenecientes a un país haremos uso de la siguiente sentencia.
La cual tendrá la palabra clave INNER JOIN, y de esta manera poder comparar valores semejantes en varias tablas de la base de datos, en este caso estamos evaluando los valores semejantes entre la tabla estados y la tabla países, esto se da porque la tabla estados posee una clave foránea que relaciona a estas dos (tabla países y tabla estados)

  String sql = "SELECT id_estado, estado FROM estados INNER JOIN paises on(estados.id_pais=paises.id_pais) "
                           + "WHERE paises.id_pais=? ORDER BY estado ASC";

  pst = connect.prepareStatement(sql);
  pst.setString(1, idPais);

5. Lo siguiente que haremos será crear un método que nos permita obtener todos los departamentos de un determinado país, este método tendrá ciertas diferencias a los otros. Debemos verificar primero que todo, si el país seleccionado posee estados. si este los posee se hará un determinado proceso y sino realizaremos otro proceso.

*La estructura de la función será la siguiente.
Tipo ArrayList y esta a su vez será de tipo <departamentos>, la llamaremos listarDepartamentos y llevara dos parámetros, ambos serán de tipo String; uno hará referencia al id que identifica a un determinado país en la base de datos, y el otro hará referencia al id perteneciente a un determinado estado.

 public ArrayList<departamentos> listarDepartamentos(String idPais, String idEstado){

*Lo siguiente que haremos será verificar si el país seleccionado posee estados, esto lo hacemos a través de un condicional.
Para este ejemplo el único país almacenado en la base de datos que posee estados es el país de los estados unidos.

if(!idEstado.equals("")){
                
      String sql = "SELECT departamentos.id_dep, departamentos.departamento "
                   + "FROM departamentos INNER JOIN estados ON (estados.id_estado=departamentos.id_estado) INNER JOIN paises ON (paises.id_pais=estados.id_pais) "
                   + "WHERE  estados.id_estado=? AND paises.id_pais=?";
                
      pst = connect.prepareStatement(sql);
                    
      pst.setString(1, idEstado);
      pst.setString(2, idPais);
                
   }else{
                
      String sql =  "SELECT departamentos.id_dep, departamentos.departamento "
                     + "FROM departamentos INNER JOIN paises ON (paises.id_pais=departamentos.id_pais) "
                     + "WHERE  paises.id_pais=?";

      pst = connect.prepareStatement(sql);
                    
      pst.setString(1, idPais);
                
                    
   }

6. Para finalizar con la clase métodos perteneciente al paquete modelo, creamos un método que nos permita obtener las ciudades perteneciente a un departamento en el cual tendremos que tener en cuenta el país y el estado, esto si el país posee estados, para esto haremos uso de tres parámetros todos de tipo String, el método tiene una estructura similar a los anteriores creados.

  public ArrayList<ciudad> listarCiudad(String idEst, String idPais, String idDep){

Verificamos de manera similar al método anterior si el país posee estados (if(!idEst.equals(""))), la estructura de la consulta SQL cambiara dependiendo la sección del condicional.

En la parte del if, obtenemos el listado de las ciudades pertenecientes a un departamento, igualmente verificamos el estado y el país para optimizar la búsqueda y tener un resultado eficiente. Por otra parte en la sección del else omitimos el estado y solo tenemos en cuenta el departamento y país seleccionado.

   if(!idEst.equals("")){
                    
        String sql = "SELECT ciudad "
                      + "FROM ciudad inner JOIN departamentos ON(departamentos.id_dep=ciudad.id_departamento) INNER JOIN estados ON (estados.id_estado=departamentos.id_estado) INNER JOIN paises ON (paises.id_pais=estados.id_pais)"
                     + "WHERE paises.id_pais=? And estados.id_estado=? And departamentos.id_dep=?";
                    
        pst = connect.prepareStatement(sql);
               
        pst.setString(1, idPais);
        pst.setString(2,idEst);
        pst.setString(3, idDep);
                    
                    
    }else{
                    
         String sql = "SELECT ciudad "
                       + "FROM ciudad  "
                       + "INNER JOIN departamentos on (departamentos.id_dep=ciudad.id_departamento) INNER JOIN paises ON (paises.id_pais=departamentos.id_pais) "
                      + " WHERE ciudad.id_departamento=? And paises.id_pais=? ORDER BY ciudad ASC";

         pst = connect.prepareStatement(sql);
               
         pst.setString(1, idDep);
         pst.setString(2,idPais);
                    
                    
     }

7. Finalizamos con la creación de las clases del paquete modelo (estados.java, departamento.java, país.java, métodos.java y pool.java).
El siguiente paso será trabajar en el paquete controlador, para esto creamos una clase a la cual hemos llamado controlador.java. Esta clase jugara un papel importante en la realización de nuestro ejemplo, usaremos esta clase como puente de comunicación entre las clases del paquete modelo y la clase principal (JFrame).

*Iniciamos importando las siguientes librerías para el correcto funcionamiento de nuestro código

import comboboxanidados.Principal;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;
import javax.swing.DefaultComboBoxModel;
import modelo.ciudad;
import modelo.departamentos;
import modelo.estados;
import modelo.metodos;
import modelo.pais;

*Una vez importadas las librerías a nuestra clase, debemos agregar el evento ActionListener. Para implementar esta interfaz a nuestra clase, haremos uso de la palabra clave implements seguido de la clase ActionListener. De esta manera la clase se implementara esta interfaz y sus métodos (ActionPerformed).

*Lo siguiente que haremos será crear un objeto de tipo Principal al que hemos llamado vista, recordemos que esta es la clase principal (JFrame) está contiene la ventana principal con los JComboBox, de esta manera podremos acceder a los componentes de esta clase siempre y cuando al invocar un método o componente de esta, usemos el objeto que hemos creado (vista).

*Creamos un objeto de tipo métodos, al cual llamaremos metodosDB. Recordemos que esta clase pertenece al paquete modelo y esta posee los métodos donde realizamos las respectivas consultas a la Base De Datos.

*Creamos cuatro objetos de tipo ArrayList(paises, estados, departamentos, ciudad) estos a su vez serán de tipo <país>, <estados>, <departamentos> y <ciudad>. En estos se almacenaran los resultados obtenidos de la consulta a la Base De Datos.

public class controlador implements ActionListener{
  
    Principal vista;
    metodos metodosDB = new metodos();
    
    ArrayList<pais> paises;
    ArrayList<estados> estados;
    ArrayList<departamentos> departamentos;
    ArrayList<ciudad> ciudad;

8. Seguimos trabajando con la clase controlador.java, lo siguiente que haremos será crear un método en el cual, asignaremos los eventos a los JComboBox haciendo uso del método addActionListener.
Solo agregamos eventos a tres JComboBox(cb_pais, cb_estado, cb_dep), omitimos el JComboBox que visualizara el listado de ciudades, porque al seleccionar un ítem de este JComboBox no es necesario realizar ningún proceso a diferencia de los otros(JComboBox).

Hacemos uso del objeto vista seguido de nuestro componente(JComboBox ) "cb_pais" llamamos el método addActionListener.

    public final void events(){
    
        vista.cb_pais.addActionListener(this);
        vista.cb_estado.addActionListener(this);
        vista.cb_dep.addActionListener(this);        
        
    }

9. Lo siguiente que haremos será crear un método que nos permita obtener el listado de países alojados en la Base De Datos y mostrarlos en el JComboBox(cb_pais).

* Iniciamos creando un método tipo void, lo llamaremos mostrarPais().
Seguido de esto llamamos el método listarpaises() que hemos creado con anterioridad en la clase métodos perteneciente al paquete modelo, el resultado que obtengamos de esta función lo asignamos al ArrayList tipo <país> que hemos creado (paises).

   public final void mostrarPais(){

        // agregamos al arraylist los países obtenidos de la DB


        paises=metodosDB.listarPaises();

* La información que se almacena en el ArrayList(paises) es:
el ID que identifica a cada país en la Base de Datos y el nombre del país, Creamos un vector tipo String y de esta manera asignar la información que contenga el ArrayList.

Para realizar el proceso de asignación, creamos un ciclo for dentro del ciclo obtendremos todos los nombres de los países que el ArrayList(paises) contenga, para esto haremos uso del método getPais(), y asi asegurarnos de obtener solo los nombres de cada país.


        
        String array[]=new String[paises.size()];
        
        for (int i = 0; i <array.length; i++) {
            
            array[i]=paises.get(i).getPais();
            
        }

* Una vez terminado el proceso de asignación, creamos un objeto de tipo DefaultComboBoxModel llevara como parámetro un vector (el creado con anterioridad), una vez instanciada la clase agregamos el objeto DefaultComboBoxModel(model) al JComboBox(cb_pais).

        DefaultComboBoxModel model = new DefaultComboBoxModel(array);
        
        vista.cb_pais.setModel(model);

10. Los métodos que veremos a continuación son similares al anterior. El cambio significativo en estos, son los parámetros. Estos métodos son:

*Este llevara un parámetro de tipo String que será el ID que identifica a un determinado país en la Base de Datos, este es uno de los cambios respecto al método anterior igualmente se utilizara el ArrayList de tipo <estados> y el JComboBox al cual le agregamos información será a cb_estado.

    public void mostrarEstados(String idPais){
    
        estados = metodosDB.listarEstados(idPais);
        
        String arr[] = new String[estados.size()];
        for(int i=0; i<estados.size(); i++){
            arr[i]=estados.get(i).getEstados();
        }
        DefaultComboBoxModel model = new DefaultComboBoxModel(arr);
        vista.cb_estado.setModel(model);            
        
    }

*Similar al método anterior este llevara dos parámetros de tipo String, igualmente realizamos los cambios en el ArrayList, este sera de tipo <departamentos>, también realizamos el cambio al JCombobox(cb_dep)


    public final void mostrarDepartamentos(String idEst, String idPais){
    
        departamentos = metodosDB.listarDepartamentos(idPais, idEst);
        
        String arr[] = new String[departamentos.size()];
        for(int i=0; i<departamentos.size(); i++){
            arr[i]=departamentos.get(i).getDepartamentos();
        }
        DefaultComboBoxModel model = new DefaultComboBoxModel(arr);
        vista.cb_dep.setModel(model);        
        
    
    }

*En el caso del método mostrarCiudad llevara tres parámetros de tipo String, realizamos los mismos cambios que en los métodos anteriores.


    public final  void mostrarCiudad(String idEst, String idPais, String idDepartamento){
        
        ciudad = metodosDB.listarCiudad(idEst, idPais, idDepartamento);
        
        String arr[] =  new String[ciudad.size()];
        for(int i=0; i<ciudad.size(); i++){
            arr[i]=ciudad.get(i).getCiudad();
        }
        
        DefaultComboBoxModel model = new DefaultComboBoxModel(arr);
        vista.cb_ciudad.setModel(model); 
                

    }

11. El siguiente paso será crear tres métodos, estos nos permitirán obtener el ID del país, estado y departamentos. Se activaran cuando seleccionemos un ITEM del JComboBox(cb_pais, cb_estado, cb_departamentos) Iniciamos creando el método con el cual obtendremos el ID que identifica a cada país.

* Creamos una función de tipo String, la cual llamaremos getIdPais llevara dos parámetros; uno será de tipo ArrayList y este a su vez será de tipo <país>, igualmente tendremos un parámetro de tipo String llamado búsqueda, este hará referencia al nombre del país al cual deseamos obtener el ID.
Dentro de las llaves de apertura y cierre de nuestra función, creamos dos variables una será de tipo String(id) en esta almacenaremos el resultado obtenido, luego creamos una variable tipo int(i), esta controlara el ciclo while que estaremos creando.


    public String getIdPais(ArrayList<pais> pais, String busqueda){
    
        String id;
        
        int i=0;

* Creamos un ciclo while el cual se ejecutara mientras la variable búsqueda sea diferente al valor almacenado en el ArrayList(pais), dependiendo el índice(i) para esto la variable i ira aumentando de uno en uno hasta que se cumpla la condición.
Una vez terminado el ciclo asignamos a la variable id el valor que se encuentra en el ArrayList dependiendo el indice(i), después hacemos uso de la palabra clave return seguido de la variable id.

   while(!pais.get(i).getPais().equals(busqueda)){            i++;
   }
        
   id=pais.get(i).getID();
       
   return id;

* La función getIdEstado y getIdDepartamento tienen una estructura similar a la función creada recientemente (getIdPais). Solamente debemos cambiar el parámetro ArrayList, en el caso de la función getIdEstado será, ArrayList <estados> y la función getIdDepartamento será, ArrayList <departamentos>.


    public String getIdDepartamento(ArrayList<departamentos> departamentos, String busqueda){
    
        String id;
                 
        int i=0;
        
        while(!departamentos.get(i).getDepartamentos().equals(busqueda)){
            i++;
        }
        
        id=departamentos.get(i).getIddep();
        
        return id;
    
    }
    
  

    public String getIdEstado(ArrayList<estados> estados, String busqueda){
    
        String id;
        
        int i=0;
        
        while(!estados.get(i).getEstados().equals(busqueda)){
            i++;
        }
        
        id=estados.get(i).getIdest();
        
        return id;
    }

12. Lo siguiente que haremos será crear el método constructor de la clase (controlador.java), Nuestro método tendrá un parámetro el cual hace referencia a la clase principal(JFrame), llamamos el método events() que contiene los eventos asignados al JComboBox.
Llamamos los métodos mostrarPais, mostrarDepartamentos y mostrarCiudad. De esta manera agregar los datos obtenidos de la Base De Datos a los respectivos JComboBox.

  public controlador(Principal vista){
    
        this.vista=vista;
        events();

       
        mostrarPais();
        mostrarDepartamentos("",paises.get(0).getID());
        mostrarCiudad("", paises.get(0).getID(), departamentos.get(0).getIddep());
    
    }

13. Por ultimo crearemos una serie de condicionales que nos permitirán controlar los eventos en la ejecución del programa, para esto nos posicionamos en la llaves de apertura y cierre del método actionPerformed.

*Verificamos si el evento que se ha activado es el perteneciente al JComboBox cb_pais, este se activara al seleccionar un Ítem del JComboBox.

        if(vista.cb_pais.equals(evt)){

* Dentro del condicional, creamos otro en el cual verificamos si el valor del Ítem seleccionado es diferente de Estados Unidos.
Estudiaremos la sección del if, Iniciamos con dos lineas de código:

        vista.cb_estado.setVisible(false);
        vista.label_estado.setVisible(false);

Recordemos que estamos trabajando con cuatro JComboBox, el combobox cb_estado solo se hará visible cuando el país seleccionado sea Estados Unidos, mientras no se de esta condición los ocultaremos con el método setVisible(false).

*El siguiente paso es obtener el id del país seleccionado. llamamos la función creada con anterioridad getIdPais(), le pasaremos como parámetro el ArrayList paises, y el Ítem del país seleccionado, haciendo uso del método getSelectedItem(), el resultado obtenido de la función lo asignamos a la variable idPais.

     String idPais = getIdPais(paises, vista.cb_pais.getSelectedItem().toString());

*Una vez obtenido el Id del país, llamamos el método mostrarDepartamentos, llevara dos parámetros; uno ira vació("") debido a que en esta sección del condicional el país seleccionado no posee estados, el segundo parámetro sera la variable idPais que identifica a este en la Base de Datos.

      mostrarDepartamentos("", idPais);

*Haremos el mismo proceso para obtener el Id del departamento (idDep), cambiamos los parámetros, este llevara el ArrayList departamentos y seleccionamos el primer Ítem del JComboBox cb_dep haciendo uso de la función getItemAt().
Llamamos el método mostrarCiudad() y de esta manera poder visualizar todas las ciudades pertenecientes a ese departamento, llevara 3 parámetros; el primero ira vació(""), el segundo sera el idPais que hace referencia al Id que identifica a ese país en la Base de Datos y por ultimo seria el idDep.

      String idDep = getIdDepartamento(departamentos, vista.cb_dep.getItemAt(0));
      mostrarCiudad("", idPais, idDep);

*Las lineas de código pertenecientes a la sección del condicional if quedaría de la siguiente manera.

      if(!vista.cb_pais.getSelectedItem().toString().equals("Estados Unidos")){
                
        vista.cb_estado.setVisible(false);
        vista.label_estado.setVisible(false);

        String idPais = getIdPais(paises, vista.cb_pais.getSelectedItem().toString());
        mostrarDepartamentos("", idPais);
                
        String idDep = getIdDepartamento(departamentos, vista.cb_dep.getItemAt(0));
        mostrarCiudad("", idPais, idDep);
                
      }

*En la sección del sino (else), sera similar al anterior la diferencia esta en que trabajaremos con el método getIdEstado y haremos visible el JComboBox cb_estado, las lineas de código quedaran dela siguiente manera.


     else{

    
        vista.cb_estado.setVisible(true);
        vista.label_estado.setVisible(true);            
                
        String idPais = getIdPais(paises, vista.cb_pais.getSelectedItem().toString());
        mostrarEstados(idPais);

        String idEst = getIdEstado(estados, vista.cb_estado.getItemAt(0));
        mostrarDepartamentos(idEst, idPais);

        String idDep = getIdDepartamento(departamentos, vista.cb_dep.getItemAt(0));
        mostrarCiudad(idEst, idPais, idDep);                
                
                
      }

14. Lo siguiente que haremos sera crear el segundo condicional, este se activa cuando seleccionamos un Ítem del JComboBox cb_estado.

* Comenzamos con la siguiente linea de código.

     else if(vista.cb_estado.equals(evt)){

*Dentro de las llaves de apertura y cierre del condicional, agregamos las siguientes líneas de código. Muy similares a las anteriores.

     String idPais = getIdPais(paises, vista.cb_pais.getSelectedItem().toString());

     String idEst = getIdEstado(estados, vista.cb_estado.getSelectedItem().toString());
     mostrarDepartamentos(idEst, idPais);

     String idDep = getIdDepartamento(departamentos, vista.cb_dep.getItemAt(0));
     mostrarCiudad(idEst, idPais, idDep);

15. Creamos otro condicional, el cual se activara cuando seleccionemos un Ítem del JComboBox cb_departamentos. Las líneas de código serán muy similares a las anteriores explicadas, quedarían distribuidas de la siguiente manera.

else if(vista.cb_dep.equals(evt)){
        
    if(vista.cb_estado.isVisible()){
            
       String idPais = getIdPais(paises, vista.cb_pais.getSelectedItem().toString());
       String idEst = getIdEstado(estados, vista.cb_estado.getSelectedItem().toString());
       String idDep = getIdDepartamento(departamentos, vista.cb_dep.getSelectedItem().toString());
       mostrarCiudad(idEst, idPais, idDep);
            
    }else{
                
        String idPais = getIdPais(paises, vista.cb_pais.getSelectedItem().toString());
        String idDep = getIdDepartamento(departamentos, vista.cb_dep.getSelectedItem().toString());
        mostrarCiudad("", idPais, idDep);
            
    }

16. Para finalizar vamos a la clase Principal.java, y Creamos un objeto de la clase
controlador.java (controlador), en el método constructor inicializamos el objeto(controlador) que hemos creado y de esta manera finalizaríamos nuestro ejemplo.

 controlador controlador;
     //Creamos el método constructor de la clase     
     public Principal() {
              controlador = new  controlador(this);
      }

17. Capturas finales.



¿Quieres aprender más de JAVA?

Si deseas saber cómo cargar un ComboBox con registros de una base de datos, pero de forma netamente gráfica usando NetBeans IDE, o ver otros temas muy interesantes, no te olvides de revisar los tips de JAVA y seguir el Curso: Cómo lo hago en JAVA? 



Accede a todos los fragmentos de código que hemos publicado en este lenguaje hasta el momento, dando clic en el siguiente enlace: Ver listado de códigos JAVA.
Suscríbete a nuestro blog, vía Email o RSS; además puedes seguirnos a través de nuestras redes sociales como: Facebook, Twitter, y Google+.
¿Conoces una forma más óptima de realizar el anterior procedimiento?, no dudes en compartir tu conocimiento con todos nuestros amigos de la web.
Si te fue de gran ayuda esta información, no olvides compartirla con tus amigos y en las redes sociales.
Si tienes dudas o sugerencias al respecto, abajo puedes dejarnos tus comentarios.
Bendiciones...

▷ Código JAVA: Cambiar de un JPanel a otro con botón siguiente y atrás

2018-04-02T16:11:00.000-05:00

Código JAVA anterior:
La Clase Fracción

-------------------------------------------------------------------------------------------

En ocasiones cuando estamos trabajando con ventanas JFrame hacemos uso de contenedores en los cuales podemos agregar componentes tales como: botones, etiquetas, campos de texto, tablas entre otros.
En este post explicaremos como visualizar varios Contenedores o JPanel en una ventana JFrame, aplicar este modelo de visualización resulta muy útil cuando queremos tener una mejor distribución de los componentes.
Si aún no tienes claro cómo crear un proyecto y trabajar con clases te invito a que visites el siguiente post Cómo hacer un proyecto, un paquete y un formulario?.

Clase Principal JFrame

package multiples_jpanel;

import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JFrame;

public class Multiples_Jpanel extends JFrame{

    // creamos un objeto de la clase GridBagLayout este sera nuestro layout el cual determinara 
    // el orden en que se distribuiran los componentes

    GridBagLayout layout = new GridBagLayout();

   // creamos un objeto de la clase GridBagContraints 
   // en el cual se guarda información de cómo y dónde añadir el componente.

    GridBagConstraints config = new GridBagConstraints();
    
    // creamos tres objetos de la clase JPanel
    jpanel1 panel1 = new  jpanel1();
    jpanel2 panel2 = new  jpanel2();
    jpanel3 panel3 = new  jpanel3();    
    
    // creamos dos objetos de la clase JButtoon
    // el cual nos permitira administrar la visualizacion de los JPanel

    JButton btn_next = new JButton("Siguiente");
    JButton btn_prev = new JButton("Anterior");    
    
    public Multiples_Jpanel(){
        
        this.setSize(600, 600);  // asignamos el ancho y alto a la venta JFrame
        this.setLocationRelativeTo(null);  // centramos la ventana en pantalla
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
       
        this.setLayout(layout);   // agregamos el layout al JFrame
        
         // agregamos los respectivos contenedores y componentes al JFrame
        config.gridx=0;
        config.gridy=0;
        config.gridwidth=2;
        config.gridheight=1;
        config.weightx=1.0;
        config.weighty=1.0;
        config.anchor=GridBagConstraints.CENTER;
        config.fill= GridBagConstraints.BOTH;
        this.add(panel1, config);
        this.add(panel2, config);
        this.add(panel3, config);     
        
        config.gridx=0;
        config.gridy=1;
        config.gridwidth=1;
        config.gridheight=1;
        config.ipadx=100;
        config.ipady=10;
        config.weighty=0.0;
        config.anchor=GridBagConstraints.CENTER;
        config.fill= GridBagConstraints.CENTER;
        this.add(btn_prev, config);

        config.gridx=1;
        config.gridy=1;
        config.gridwidth=1;
        config.gridheight=1;
        config.ipadx=100;
        config.ipady=10;
        config.weighty=0.0;
        config.anchor=GridBagConstraints.CENTER;
        config.fill= GridBagConstraints.CENTER;
        this.add(btn_next, config);

        panel1.setVisible(true);
        panel2.setVisible(false);
        panel3.setVisible(false);

        // creamos los aventos 
        btn_next.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                    
                if(panel1.isVisible()){
                    
                    panel2.setVisible(true);
                    panel3.setVisible(false);
                    panel1.setVisible(false);
                    validate();
                    
                }else if(panel2.isVisible()){

                    panel3.setVisible(true);
                    panel2.setVisible(false);
                    panel1.setVisible(false);
                    validate();
                
                }

            }

        });
        
        btn_prev.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                    
                if(panel2.isVisible()){
                
                    panel1.setVisible(true);
                    panel2.setVisible(false);
                    panel3.setVisible(false);
                    
                }else if(panel3.isVisible()){
                    
                    panel2.setVisible(true);
                    panel3.setVisible(false);
                    panel1.setVisible(false);
                    
                }

            }

        });        
        
    }
    // metodoo main
    public static void main(String[] args) {
        
        // instaciamos la clase y hacemos visible nuestro JFrame
        Multiples_Jpanel frame = new Multiples_Jpanel();
        frame.setVisible(true);
        
    }
    
}

Clase perteneciente al primer contenedor

package multiples_jpanel;

import java.awt.Color;
import java.awt.Font;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import javax.swing.JLabel;
import javax.swing.JPanel;

public class jpanel1 extends JPanel{

    JLabel label = new JLabel("panel # 1");

    Font fuente = new Font("Comic Sans MS", Font.ITALIC, 40);
    
    GridBagLayout layout = new GridBagLayout();
    GridBagConstraints config = new GridBagConstraints();
    
    public jpanel1(){
        this.setLayout(layout);
        this.setBackground(Color.ORANGE);
        
        label.setFont(fuente);
        
        config.gridx=0;
        config.gridy=0;
        config.gridwidth=1;
        config.gridheight=1;
        config.anchor=GridBagConstraints.CENTER;
        config.fill= GridBagConstraints.BOTH;
        this.add(label, config);
        
    }
    
}

Clase perteneciente al segundo contenedor

package multiples_jpanel;

import java.awt.Color;
import java.awt.Font;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import javax.swing.JLabel;
import javax.swing.JPanel;

public class jpanel2 extends JPanel{
    
    JLabel label = new JLabel("panel # 2");  
    Font fuente = new Font("Comic Sans MS", Font.ITALIC, 40);
    
    GridBagLayout layout = new GridBagLayout();
    GridBagConstraints config = new GridBagConstraints();

    public jpanel2(){
    
        this.setLayout(layout);
        this.setBackground(Color.YELLOW);
        
        label.setFont(fuente);
        config.gridx=0;
        config.gridy=0;
        config.gridwidth=1;
        config.gridheight=1;
        config.anchor=GridBagConstraints.CENTER;
        config.fill= GridBagConstraints.BOTH;
        this.add(label, config);
        
        
    }
    
}

Clase perteneciente al tercer contenedor

package multiples_jpanel;

import java.awt.Color;
import java.awt.Font;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import javax.swing.JLabel;
import javax.swing.JPanel;

public class jpanel3 extends JPanel{
    
    JLabel label = new JLabel("panel # 3");  
    Font fuente = new Font("Comic Sans MS", Font.ITALIC, 40);
    
    GridBagLayout layout = new GridBagLayout();
    GridBagConstraints config = new GridBagConstraints();
    
    public jpanel3(){
    
        this.setLayout(layout);
        this.setBackground(Color.YELLOW);
        
        label.setFont(fuente);
        config.gridx=0;
        config.gridy=0;
        config.gridwidth=1;
        config.gridheight=1;
        config.anchor=GridBagConstraints.CENTER;
        config.fill= GridBagConstraints.BOTH;
        this.add(label, config);
        
        
    }
    
}

VIDEO TUTORIAL (PASO A PASO)

Instrucciones Y Desarrollo Del Código

Procedemos a explicar el código que implementaremos en nuestro proyecto

1. Iniciamos creando la clase del primer contenedor (JPanel), la cual llamaremos jpanel1.
public class jpanel1 extends JPanel
haremos uso de la herencia y de esta manera podremos utilizar los métodos, procedimientos y atributos de la clase JPanel para esto hacemos uso de la palabra clave extends seguido del nombre de la clase, en este caso será la clase JPanel.

2. Seguimos trabajando en la clase jpanel1 dentro de las llaves de apertura y cierre de la clase, creamos los siguientes objetos.

JLabel label = new JLabel("panel # 1");
Font fuente = new Font("Comic Sans MS", Font.ITALIC, 40);
GridBagLayout layout = new GridBagLayout();
GridBagConstraints config = new GridBagConstraints();

*Creamos un objeto de la clase JLabel, el cual nos servirá para agregar una etiqueta al JPanel, la cual utilizaremos para mostrar un mensaje en este caso escribiremos como mensaje; “Panel # 1”.

*Creamos un objeto de la clase Font, el cual utilizaremos para crear una fuente de texto, llamaremos al constructor de la clase, en el cual agregaremos el tipo de fuente, el estilo y el tamaño de la fuente.

*Creamos un objeto de la clase Gridbaglayout, utilizaremos el layout para poder administrar la posición o donde se ubicaran los componentes en el JPanel, la clase GridBagLayout está ligada a la clase GridBagContraints. Que nos permitirá posicionar los objetos que agreguemos en el JPanel.

3. Creamos el método constructor de la clase en el cual agregaremos las siguientes líneas de código:

public jpanel1(){

this.setLayout(layout);

this.setBackground(Color.ORANGE);

label.setFont(fuente);

config.gridx=0;
config.gridy=0;
config.gridwidth=1;
config.gridheight=1;
config.anchor=GridBagConstraints.CENTER;
config.fill= GridBagConstraints.BOTH;
this.add(label, config);

}

*En la primera línea de código llamamos el método setLayout, el cual tendrá como parámetro el layout que administrara los componentes del contenedor, en este caso agregamos el objeto de tipo GridBagLayout (layout).

*En La segunda línea de código cambiamos el color de fondo del JPanel llamando al método setBackGround, el cual lleva como parámetro un objeto de la clase Color.

*Hacemos uso del método setFont para cambiar el tipo de fuente del mensaje que visualizaremos en la etiqueta JLabel, para esto hacemos uso del Objeto tipo Font label.setFont(fuente).

*Lo siguiente que haremos será hacer uso del objeto de la clase GridBagContrains (config) el cual nos permite administrar el lugar exacto donde agregar los componentes que estemos utilizando.
Si no están familiarizado con este tipo de layout te recomiendo que investigues sobre este tema, este layout en específico es uno de los más potentes a la hora de administrar y posicionar los componentes en un contenedor.

*Debemos importar las librerías necesarias para no tener errores en nuestro código.

import java.awt.Color;
import java.awt.Font;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import javax.swing.JLabel;
import javax.swing.JPanel;

Nota : para la creación de las tres clases del tipo contenedor o JPanel aplicaremos estos tres pasos, solo debemos cambiar el nombre de la clase. Para este ejemplo las tres clases del tipo JPanel son: jpanel1, jpanel2, jpanel3.

4. Lo siguiente que haremos será crear la clase principal la cual contendrá la ventana JFrame, en esta clase aplicaremos todos los procesos en el cual administraremos la visualización de los respectivos JPanel que hemos creado con anterioridad.
Dentro las llaves de apertura y cierre de la clase creamos los siguientes objetos.

GridBagLayout layout = new GridBagLayout();

GridBagConstraints config = new GridBagConstraints();
    
jpanel1 panel1 = new  jpanel1();
jpanel2 panel2 = new  jpanel2();
jpanel3 panel3 = new  jpanel3();    
    
JButton btn_next = new JButton("Siguiente");

JButton btn_prev = new JButton("Anterior");

*Creamos un objeto de la clase GridBagLayout y GridBagContrains, recordemos que con estos objetos administramos la ubicación de los componentes que utilizaremos.

*Creamos los respectivos objetos de la clase jpanel1, jpanel2 y jpanel3 recordemos que estas clases contienen los paneles que visualizaremos en la ventana JFrame.

*Por ultimo creamos dos objetos de la clase JButton los cuales nos permitirán controlar que contenedor o panel sera visible.

5. Una vez hayamos agregado los contenedores o JPanel a la ventana JFrame procederemos a visualizar y ocultar de la siguiente manera.

panel1.setVisible(true);
panel2.setVisible(false);
panel3.setVisible(false);

En este caso como trabajamos con tres JPanel, haremos visible un contenedor y el resto los ocultaremos. Igualmente si se trabajan con cuatro, Cinco o más contenedores siempre haremos visible uno y los demás lo ocultaremos, el método para ocultar y hacer visible un componente es setVisible(),este lleva como parámetro el tipo de dato boolean, si queremos visualizar el contenedor llevara true sino llevara false.

6. Para poder controlar que contenedor se hará visible, utilizaremos los botones de siguiente y anterior a estos le agregamos un evento de tipo ActionListener donde verificamos el contenedor que esta visible y el nuevo contenedor que se visualizara.

    btn_next.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                    
                if(panel1.isVisible()){
                    
                    panel2.setVisible(true);
                    panel3.setVisible(false);
                    panel1.setVisible(false);
                    validate();
                    
                }else if(panel2.isVisible()){

                    panel3.setVisible(true);
                    panel2.setVisible(false);
                    panel1.setVisible(false);
                    validate();
                
                }

            }

        });

Trabajamos con el primer evento, se activara al oprimir el botón siguiente.
Como trabajamos con tres contenedores hacemos dos condicionales, en el primer condicional if(panel1.isVisible()). Si el primer contenedor es visible lo ocultaremos y visualizamos el segundo contenedor, igualmente si el segundo contenedor esta visible if(panel2.isVisible()). Lo ocultaremos y visualizaremos el tercer contenedor.
Por ultimo llamamos al método Validate() con este método actualizaremos la ventana JFrame y de esta manera actualizar y visualizar el nuevo JPanel.

        btn_prev.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                    
                if(panel2.isVisible()){
                
                    panel1.setVisible(true);
                    panel2.setVisible(false);
                    panel3.setVisible(false);
                    
                }else if(panel3.isVisible()){
                    
                    panel2.setVisible(true);
                    panel3.setVisible(false);
                    panel1.setVisible(false);
                    
                }

            }

        });

Trabajamos con el segundo evento, se activara al oprimir el botón anterior.

igualmente que en el evento anterior, en este verificamos que contenedor esta visible. Esto lo hacemos con el fin de que podamos avanzar y regresar a la hora de visualizar los contenedores.

Nota: Debemos importar las librerías necesarias para que nuestro código no tenga ningún tipo de error

import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JFrame;

Hay diferentes formas en las que podemos trabajar con contenedores o JPanel, la que estudiamos en este post es una de tantas formas. para aplicar estas operaciones, el principio que hay que tener en cuenta es que siempre habrá un contenedor visibles y el resto los ocultaremos, esto dependerá de la posición en que agreguemos el JPanel, en este caso como los tres contenedores lo agregamos en la misma posición si aplicamos estas operaciones, por ultimo algo importante cuando ocultemos y hagamos visible un JPanel actualizamos los componentes de la ventana JFrame(Validate()).

¿Quieres aprender más de JAVA?

Si deseas saber cómo cargar un ComboBox con registros de una base de datos, pero de forma netamente gráfica usando NetBeans IDE, o ver otros temas muy interesantes, no te olvides de revisar los tips de JAVA y seguir el Curso: Cómo lo hago en JAVA?

Accede a todos los fragmentos de código que hemos publicado en este lenguaje hasta el momento, dando clic en el siguiente enlace: Ver listado de códigos JAVA.

Suscríbete a nuestro blog, vía Email o RSS; además puedes seguirnos a través de nuestras redes sociales como: Facebook, Twitter, y Google+.

▷ Código JAVA: Como crear la clase fracción paso a paso

2018-02-13T00:13:00.000-05:00

Código JAVA anterior:
Cargar JComboBox con registros de una base de datos

-------------------------------------------------------------------------------------------

En este post explicaremos paso a paso la elaboración de una clase en Java, con los métodos fundamentales para trabajar con números fraccionarios, esta clase nos ayudara a la hora de trabajar ejercicios con números racionales o ecuaciones, no es necesario tener un conocimiento extenso en java, mas que todo necesitamos emplear lógica de programación y buen dominio en creación de algoritmos para entender de la mejor manera todos los métodos que utilizaremos.

Si aún no tienes claro cómo funcionan estos números y sus componentes más esenciales te invito a que visites el siguiente post Cómo crear la clase fracción en Java

Métodos De La Clase Fracción

 public class fraccion{


 int numerador, denominador;


// creamos el metodo constructor 
 public fraccion(int num, int den){

 numerador=num;
 denominador=den;

 }



public int mcd(){

   int num=numerador, den=denominador; // le asignamos a las variables el valor del numerador y denominador

   if(num==0){              // veirificamos si es igual a 0

     return 1;                       // si es igual a 0 retornara valor 1

   }else{                           // sino se realizara el siguiente proceso

     if(num<0){                      // verificamos que la variable num sea negativa  
   
         num = num * -1;            // si es negativa la convertimos a positivo  
   
     }

     if(den<0){

       den = den * -1;            // realizamos el mismo proceso con la variable den  
   
     }
 
     if(den>num){                  // verificamos si la variable den es mayor a num 
       
         int aux=num;           // si es mayor hacemos un intercambio de valores
         num=den;               // debido a que la variable den no debe ser mayor a num
         den=aux;

     } 

     int mcd=1;               // incializamos la variable mcd en 1
    
     while(den!=0){          // verificamos si la variable den es diferente de 0
          
          mcd=den;       // asignamos a la variable mcd lo que contiene den
          den = num % den;   // a la variable den le asignamos el residuo o modulo entre num y den
          num = mcd;         // a la variable num le asignamos mcd
          
     }                        // el ciclo se repetira hasta que se cumpla la condicion inicial    

     return mcd;

    }

}



public void simplificar(){

  int mcd = mcd();
  
  numerador = numerador / mcd;  
  denominador = denominador / mcd;
  
  if(numerador<0 && denominador<0){
    
    numerador=numerador*-1; 
    denominador=denominador*-1; 

   }else if(numerador>=0 && denominador<0){
     
     numerador=numerador*-1; 
     denominador=denominador*-1; 

    }

}





@Override
public String toString(){

  if(denominador!=0){
    
    simplificar();
    return numerador+"/"+denominador  

  }else {

     return "El denominador debe ser distinto de 0";
  
  }
 
}

}

Clase Principal

package  numeros_fraccionarios;

import javax.swing.JOptionPane;

public class principal {

   public static void main(String [] args){
   
      fraccion frac = new fraccion(12,8);

      JOptionPane.showMessageDialog(null, frac.toString());
   
   }

}

VIDEO TUTORIAL (PASO A PASO)

Instrucciones Y Desarrollo Del Código

Dividiremos el desarrollo del código en dos partes, primero explicaremos cada método de la clase fraccion y por último la clase principal.

1. Una vez creada la clase fracción dentro de las llaves { } de apertura y de cierre de la Clase Java, pegaremos el código resaltado en color azul. En esa línea lo que vamos hacer es; crear dos variables de tipo entero ( int) el nombre de las variables son: numerador, denominador; y estas hacen referencia a los componentes esenciales de una fracción, recordemos que un número fraccionario se compone de numerador, denominador y el signo de la fracción que será positivo (+) o negativo (-).

Código final línea anterior

 int numerador, denominador;

2. El siguiente paso es la creación del método constructor de la Clase, el código de este método esta resaltado del siguiente color amarillo, este código lo pegamos entre las llaves { } de apertura y cierre de la Clase fracción. En la primera línea del método public fraccion( int num, int den), lo primero que haremos será escribir un modificador de acceso, para este ejemplo utilizaremos public, luego escribimos el nombre del método, en este caso como es el método constructor utilizamos el mismo nombre de la Clase fraccion, dentro de los paréntesis ( ) creamos dos variables de tipo entero( int num, int den), estas serán los parámetros del método. Dentro de las llaves { } del método constructor, realizamos dos asignaciones.

numerador =num;

denominador =den;

Lo que estamos haciendo aquí es asignarle los valores que contengan los parámetros, recordemos que estas dos variables contendrán el valor final de la fracción y por esta razón realizamos este proceso de asignación.

Código final línea anterior

// creamos el metodo constructor 
public fraccion(intnum, int den){

 numerador=num;
 denominador=den;

3. El siguiente paso será crear la función mcd(), esta resaltada del siguiente color naranja, este método o función es de gran importancia al trabajar con fracciones. Esta función nos permite encontrar el mayor número que sea divisible entre la variable numerador y denominador.
Como es una función larga la dividimos en varias secciones, para explicarla de la mejor manera.

Creamos dos variables auxiliares tipo entero (int), para este ejemplo las variables las llamaremos int num, int den, a estas variables le asignamos, las variables numerador y denominador
El siguiente paso es, un condicional donde verificamos if (num==0), con este condicional verificamos si la variable num es igual a 0. Por ejemplo si la fracción es: 0/5 si realizamos la división en una calculadora, el resultado final seria 0 y por lógica el mayor número que divide al 0 y el 5 seria 1. Dentro del condicional escribiremos, return 1; de esta manera la función devolverá como valor final 1
```
   if(num==0){ 
```
```
     return 1; 
```
```
   }
```
El siguiente paso es lo opuesto al condicional anterior, el sino o else, ¿cuándo entraremos a este condicional? entraremos cuando la variable num sea diferente de 0, por ejemplo si la fracción es: 4/8 entrara a esta sección del condicional que contendrá varias líneas de código que explicaremos una a una

Una vez posicionados en el else o sino, creamos dos condicionales  if (num<0) y if(den<0) respectivamente, verificamos si estas dos variables son negativas, debido a que los procesos que realizara la función es necesario que ambos valores de las variables sean positivas.
En el caso de que entremos a uno de estos condicionales se procederá a convertir el valor que contienen estas variables a positivo, de la siguiente manera: num=num*-1; o den=den*-1 la razón por la cual multiplicamos por -1, es simple todo número multiplicado por 1 es igual al mismo número, y debemos tener clara la ley de los signos; cuando son signos iguales el resultado será positivo, por ejemplo: tenemos un valor de -2 y lo multiplicamos por -1 el valor final es igual a 2 ( -2 * -1 = 2 )

Los respectivos condicionales en java quedarían así:

if (num<0){     num = num * -1; }

if(den<0){

     den = den * -1;     }

Estos condicionales irán dentro de las llaves { } de apertura y cierre del else
Siguiendo con el proceso, creamos un condicional donde verificaremos: if (den>num) en esta línea de código verificamos si la variable den es mayor a la variable num , recordemos que la variable num hace referencia al valor del numerador y la variable den al valor del denominador.
Para los procesos que vamos a realizar a continuación necesitamos que siempre el valor de den sea menor o igual <= al valor de num, cuando entremos a este condicional se realizara el siguiente proceso:
int aux=num; num=den; den=aux;
Realizamos un intercambio entre las variables num y den para esto hacemos uso de una variable auxiliar, para que el proceso sea correcto; la variable es de tipo entero (int aux).
La primera línea int aux=num; la variable aux le asignamos el valor de num.
La segunda línea num=den; la variable num le asignamos el valor que contiene den.
La tercera línea den=aux; la variable den le asignamos el valor de aux.

De esta manera realizaríamos el intercambio, por ejemplo: si num = 4 y den=8 en este caso entraríamos a este condicional debido a que 8 es mayor a 4, una vez en este condicional hacemos un intercambio de valores entre variables, esto quiere decir que la variable sería igual a num=8 y la variable den=4

La condición quedaría de la siguiente manera :

if(den>num){ int aux=num; num=den; den=aux; }
Llegamos a la sección final del else o sino, nos encontraremos la siguiente línea int mcd=1; declaramos una variable de tipo entero (int) llamada mcd, la inicializamos en 1 esta es la variable donde se almacenara el valor final que devolverá la función java.
La siguiente línea encontraremos un ciclo repetitivo while o mientras que, con la siguiente condición; while (den!=0), lo que esto quiere decir es que mientras la variable den sea diferente de 0 se realizara los procesos que estén dentro de las llaves { } del ciclo, el contenido que está dentro del ciclo es el siguiente:
mcd=den; den = num % den; num = mcd;

Antes de comenzar la explicación de estas líneas, debemos tener en claro de una forma general lo que se está haciendo, en conclusión lo que hacemos aquí son divisiones sucesivas entre num y den. Teniendo clara la idea principal continuemos…

mcd=den; en esta línea, asignamos el valor de la variable den a mcd. Recordemos que antes de esta asignación el valor de mcd es igual a 1, una vez realizado este proceso la variable mcd cambiaria de valor.

den = num % den; en esta línea a la variable den se le asigna el resultado del MOD(modulo o residuo) entre num y den;

num = mcd; en esta línea la variable num le asignamos el valor que contenga la variable mcd.

Este proceso se repetirá hasta que den sea igual a 0

Realicemos un ejemplo:

Nuestra fracción es igual a 12/8 por lo tanto:

La variable num es igual a 12 (num=12). Y la variable den es igual a 8 ( den=8).

La primera línea del ciclo verificamos; while (den!=0), en este caso la variable den es distinto de 0 por lo tanto entraremos al ciclo.

Una vez dentro del ciclo, la variable mcd asignamos el valor de la variable den la variable mcd sería igual a mcd=8

La siguiente línea ( den = num % den;) le asignamos a la variable den el modulo entre num y den, en este caso se divide 12/8 esta división es igual a 1 y el resto o modulo (MOD) es igual a 4; entonces la variable den es igual a 4( den=4).

La siguiente línea ( num = mcd;) le asignamos a la variable num el valor que contiene la variable mcd, por lo tanto la variable num valdría 8( num=8).

Al finalizar el proceso las variables terminarían con estos valores

num=8
den=4
mcd=8.

El ciclo vuelve a repetir el mismo proceso debido a que den=4. recordemos que, el ciclo termina cuando den es igual a 0( den=0).

Una vez se repita el proceso que explicamos anteriormente los valores de las variables terminarían así:

num=4
den=0
mcd=4.

De esta manera el ciclo terminaría, debido a que la variable den = 0 y con esto tendríamos el valor final que necesitamos y es mcd=4
Terminaríamos escribiendo el valor que devolverá la función, si esta entra a la sección del sino o else. Escribimos return mcd;

Código final del método mcd

public int mcd(){

 int num=numerador, den=denominador; // le asignamos a las variables el valor del numerador y denominador

 if(num==0){              // veirificamos si es igual a 0

    return 1;                       // si es igual a 0 retornara valor 1

  }else{                           // sino se realizara el siguiente proceso

    if(num<0){                      // verificamos que la variable num sea negativa  
   
        num = num * -1;            // si es negativa la convertimos a positivo  
   
    }

    if(den<0){ 
   
        den = den * -1;            // realizamos el mismo proceso con la variable den  
   
    }
 
    if(den>num){                  // verificamos si la variable den es mayor a num 
       
  int aux=num;           // si es mayor hacemos un intercambio de valores
         num=den;               // debido a que la variable den no debe ser mayor a num
         den=aux;

    } 

     int mcd=1;               // incializamos la variable mcd en 1
    
     while(den!=0){          // verificamos si la variable den es diferente de 0
          
          mcd=den;       // asignamos a la variable mcd lo que contiene den
          den = num % den;   // a la variable den le asignamos el residuo o modulo entre num y den
          num = mcd;         // a la variable num le asignamos mcd
          
    }                        // el ciclo se repetira hasta que se cumpla la condicion inicial    

     return mcd;

    }

}

4. Lo siguiente que haremos será, una serie de condicionales donde verificamos.
En la primera parte if(numerador<0 && denominador <0) verificamos si ambas variables son negativas, si se da este caso tendremos que hacer una conversión a positivo de la siguiente manera.

numerador=numerador*-1;

denominador=denominador*-1;

Recordemos que, cuando son signos iguales el signo de la fracción es positivo y signos contrarios negativos.

En la segunda parte verificamos else if(numerador>=0 && denominador<0) si la variable numerador es positiva y la variable denominador negativa, haremos un intercambio de signos entre el numerador y denominador, de esta manera la fracción será negativa.

Se realiza el mismo proceso anterior.

numerador=numerador*-1;

denominador=denominador*-1;

Código final del método simplificar

public void simplificar(){

  int mcd = mcd();

  numerador = numerador / mcd;

  denominador = denominador / mcd;

  if(numerador>0 && denominador >0){

    numerador=numerador*-1;

    denominador=denominador*-1;

   }else if(numerador>=0 && denominador<0){

     numerador=numerador*-1;

     denominador=denominador*-1;

}

5. Creamos la última función de tipo cadena o String, esta función java, devolverá el resultado de la fracción.

Miremos la estructura de la función, public String toString() la palabra reservada public la utilizamos para que la función pueda ser invocada desde otra clase, lo siguiente es el tipo de dato en este caso es String esto quiere decir que el valor que devolverá la función será de este tipo, lo siguiente es el nombre de la función a la que hemos llamado toString ().

En la siguiente línea verificamos que sea una fracción valida, de la siguiente manera: if (denominador !=0), recordemos que en los números fraccionarios el denominador debe ser diferente de 0, de lo contrario no es una fracción valida. En este caso si la fracción es válida invocamos al método simplificar(); Luego entraremos en la siguiente línea return numerador +"/" +denominador.
De esta manera estaríamos devolviendo el resultado final de la operación. Sino la función devolvería un mensaje de error;
return "El denominador debe ser distinto de 0";

Código final del método toString

@Override

public String toString(){

  if(denominador!=0){

    simplificar();

    return numerador+"/"+denominador

  }else {

     return "El denominador debe ser distinto de 0";

}

6. El último paso es la creación de la clase principal dentro de las llaves { } de apertura y cierre de la clase creamos el método Main de la siguiente manera public static void main(String [] args){}, dentro de las llaves { } del método Main escribimos las siguientes líneas de código

fraccion frac = new fraccion(12,8);

JOptionPane.showMessageDialog(null, frac.toString());

La primera línea de código fraccion frac = new fraccion(12,8); Es una instancia de la clase fracción. Primero escribimos el nombre de la clase en este caso fraccion, el nombre que llevara el objeto para este ejemplo será frac, lo siguiente escribimos la palabra reservada new y posterior a esto lo siguiente fraccion(12,8);

En esta parte del código entre los paréntesis ( ) ingresamos dos valores; estos hacen referencia al numerador y denominador, recordemos cuando creamos el método constructor el cual llevaba dos parámetros, estos son los valores que el método constructor recibirá. En este caso sería el 12 y el 8, pero puede ser cualquier valor que ingresemos, puede recibir valores ingresados por teclado pero para este caso realizaríamos otro proceso. Les invito a que prueben diferentes maneras de ingreso de datos, para conocer más a fondo como trabaja la clase y sus restricciones. Por ultimo escribimos el mensaje de salida o lo que mostraremos en pantalla.

JOptionPane.showMessageDialog(null, frac.toString());

Para evitar errores debemos realizar el siguiente import, lo escribiremos fuera de las llaves de apertura y cierre de la clase

import javax.swing.JOptionPane;

Revisemos esta parte del código frac.toString()escribimos el nombre del objeto que hemos creado e invocamos una función de la clase fracción, esta función devolverá el resultado final de la fracción con la que trabajemos.

¿Quieres aprender más de JAVA?

▷ Código JAVA: Cargar JComboBox con registros de una base de datos

2017-11-15T14:35:00.000-05:00

Código JAVA anterior:
Cambiar tamaño (alto) del Header de un JTable

-------------------------------------------------------------------------------------------

Este post está orientado a la aplicación e implementación de un bloque de código JAVA, que nos permitirá mostrar en un ComboBox los registros almacenados en una tabla de la base de datos; lo cual, nos ayudará a tener formularios más dinámicos, ya que, en este caso, componentes como los JComboBox mostrarán información actualizada a medida que alimentemos nuestra base de datos:

Método Consultar países:

public class Cargar_Combobox {

Pool metodospool = new Pool();

public void consultar_paises(JComboBox cbox_paises){

//Creamos objeto tipo Connection    
java.sql.Connection conectar = null;    
PreparedStatement pst = null;
ResultSet result = null;

//Creamos la Consulta SQL
String SSQL = "SELECT nombre_pais FROM pais ORDER BY nombre_pais ASC";

//Establecemos bloque try-catch-finally
try {
       
   //Establecemos conexión con la BD 
   conectar = metodospool.dataSource.getConnection();  
   //Preparamos la consulta SQL
   pst = conectar.prepareStatement(SSQL);
   //Ejecutamos la consulta
   result = pst.executeQuery();
   
   //LLenamos nuestro ComboBox
   cbox_paises.addItem("Seleccione una opción");
   
   while(result.next()){
   
       cbox_paises.addItem(result.getString("nombre_pais"));
   
   }
   
    
} catch (SQLException e) {

    JOptionPane.showMessageDialog(null, e);
    
}finally{

    if(conectar!=null){
        
        try {
        
            conectar.close();
            result.close();
            
            conectar=null;
            result=null;
            
        } catch (SQLException ex) {
            
            JOptionPane.showMessageDialog(null, ex);
        
        }
    
    }

}
    

}

Clase del JFrame (Formulario_Combobox):

public class Formulario_Combobox extends javax.swing.JFrame {

    Cargar_Combobox metodos_cargarcombobox = new Cargar_Combobox();
    
    
    public Formulario_Combobox() {
        
                
        initComponents();
        
        //Cargamos nuestro ComboBox con información de la BD
        metodos_cargarcombobox.consultar_paises(cbox_Paises);
        
    }

}

VIDEO TUTORIAL (PASO A PASO)

Instrucciones y Recomendaciones

1. Antes que todo, deberás copiar y pegar las siguientes librerías, las cuales son sumamente necesarias para que el código que vamos a implementar (Método Consultar Países) funcione sin inconvenientes.
Recuerda pegarlas después de la línea de código que representa el nombre del paquete (ej. package Metodos;) y sobre la línea de código que identifica el nombre de tu Clase (ej. public class Cargar_ComboBox{...):

import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import javax.swing.JComboBox;
import javax.swing.JOptionPane;

2. Copia y pega el código resaltado en color verde y el de color amarillo, luego de la llave de apertura "{" de la Clase JAVA donde tienes los métodos de tu proyecto.
En la primera línea de código (color verde), lo que se hace es instanciar un objeto de la Clase Pool que permite la conexión con la Base de datos, y al que hemos llamado "metodospool":

Pool metodospool = new Pool();

3. Siguiendo con el apartado de color amarillo, este representa la estructura de un método que nos ayudará a cargar nuestro JComboBox con registros almacenados en una tabla de la base de datos.
En la primera parte, definimos las propiedades de nuestro método, en este caso, "public" (para que esté disponible y sea accedido desde otras Clases) y "void" (no esperamos que devuelva un valor desde su interior); a continuación, le especificamos un nombre, el cual ya sabemos que debe ir relacionado acorde a la función que llevará o ejecutará el método, por ello lo hemos llamado "consultar_paises".

Lo que sigue ahora, es colocar entre paréntesis "()" los parámetros que el método necesitará para llevar a cabo el proceso de forma adecuada.
Para esta oportunidad, hemos asignado 1 sólo parámetro de tipo "JComboBox" (cbox_paises).

Luego, inmediatamente después del paréntesis de cierre ")", vamos a colocar un par de llaves, una de apertura "{", y otra de cierre "}", las cuales van a delimitar y a contener todo el código de nuestro método "consultar_paises":

public void consultar_paises(JComboBox cbox_paises){}

4. Dentro de las llaves de nuestro método, lo primero que haremos será crear una serie de variables u objetos que nos permitirán llevar a cabo la conexión con nuestra base de datos, y administrarla de acuerdo a lo que necesitaremos.
Y procederemos a instanciarlas con un valor "null":

java.sql.Connection conectar = null;    
PreparedStatement pst = null;
ResultSet result = null;

5. En el siguiente paso, crearemos una variable de tipo "String", y que llamaremos "SSQL", a la cual le asignaremos la sentencia SQL que nos permitirá traer la información desde nuestra base de datos (ver explicación de la estructura de sentencias SQL para consultar información de una base de datos) y que mostraremos en nuestro JComboBox:

String SSQL = "SELECT nombre_pais FROM pais ORDER BY nombre_pais ASC";

6. Emplearemos un bloque "try{}catch(){}finally{}".

Dentro de las llaves "{}" del "try", haremos varias cosas:

a. Usaremos el objeto tipo "Connection", y luego del signo igual "=" procederemos a usar el objeto "metodospool", con el cual tendremos acceso al objeto y/o variable de tipo "DataSource" de la Clase Pool que creamos en un artículo anterior, aplicándole posteriormente el método ".getConnection()"; con esto, estaremos estableciendo la conexión con la base de datos:

conectar = metodospool.dataSource.getConnection();

b. Vamos a preparar y a verificar la sentencia SQL, con la que consultaremos los datos; por lo cual, usaremos la variable del tipo "PreparedStatement", a la que hemos llamado "pst"; luego del signo igual (=), usaremos el objeto "conectar", al cual le aplicaremos el método ".prepareStatement()", a su vez, a este le pasaremos como parámetro, la variable "SSQL":

pst = conectar.prepareStatement(SSQL);

c. Haremos uso del objeto de tipo "ResultSet", que hemos identificado con el nombre de "result". Luego del signo igual "=" llamaremos al objeto "pst" y le aplicaremos el método ".executeQuery()":

result = pst.executeQuery();

Lo que hacemos en este punto es ejecutar la sentencia SQL, y almacenar en este objeto (result) la información extraída de nuestra base de datos.

d. Una vez obtenida la información, el siguiente paso a seguir será llenar nuestro JComboBox con la misma; sin embargo, lo que haremos antes será asignar el ítem (dato) que se mostrará por defecto en la posición número uno; para ello, llamamos el parámetro que le pasamos a nuestro método, en este caso "cbox_paises", y le aplicamos el método ".addItem()" al cual le pasamos como parámetro el dato que queremos mostrar, en este caso: "Seleccione una opción":

cbox_paises.addItem("Seleccione una opción");

e. Ahora, haciendo uso de un ciclo condicional "while", verificaremos la información obtenida en nuestro objeto "result" aplicandole el método ".next()", a medida que se vayan encontrando registros, y al igual como hicimos en el punto anterior (d), llamamos el parámetro que le pasamos a nuestro método, en este caso "cbox_paises", y le aplicamos el método ".addItem()" al cual en este caso le pasamos como parámetro el objeto "result", aplicándole el método ".getString()" y dentro los paréntesis de dicho método entre comillas dobles "" colocaremos el nombre del campo de la tabla de nuestra base de datos, donde está almacenada la información que mostraremos en el JComboBox:

while(result.next()){
   
       cbox_paises.addItem(result.getString("nombre_pais"));
   
}

Teniendo en cuenta las líneas de código de los puntos a, b, c, d, y e; la sección del "try{}" quedaría así:

try {
       
   //Establecemos conexión con la BD 
   conectar = metodospool.dataSource.getConnection();  
   //Preparamos la consulta SQL
   pst = conectar.prepareStatement(SSQL);
   //Ejecutamos la consulta
   result = pst.executeQuery();
   
   //LLenamos nuestro ComboBox
   cbox_paises.addItem("Seleccione una opción");
   
   while(result.next()){
   
       cbox_paises.addItem(result.getString("nombre_pais"));
   
   }
   
    
}

7. En la parte del "catch(){}", dentro de los paréntesis "()" establecemos el tipo de excepción que puede producirse (SQLException), y la almacenaremos y/o capturaremos en una variable llamada "error".
Ahora, dentro de las llaves de apertura "{" y de cierre "}", haremos uso del componente "JOptionPane", esto con el fin de mostrarle al usuario a través de un pequeño cuadro de diálogo, el error que se ha producido; es decir, la causa que llevó a que no se eliminaran los datos. A dicho componente le aplicaremos el método ".showMessageDialog()", al cual le pasaremos 2 parámetros: el primero de ellos lo dejaremos "null"; y el segundo, será la variable "error":

catch (SQLException error) {

    JOptionPane.showMessageDialog(null, error);
    
}

8. En la última sección del método consultar_paises(), vemos la parte del "finally{}", dentro de sus llaves utilizamos un condicional "if", en el cual comprobaremos si la conexión con la base de datos no es nula (null); en tal caso, se procederá a ejecutar lo que hemos establecido dentro del "if", y que básicamente consiste en un bloque "try{}catch(){}".

Dentro del "try{}", usamos los objetos y/o variables "conectar" y "result", a estos les estableceremos el método ".close()" y les asignaremos un valor "null", con el fin de cerrar y/o liberar la conexión que se utilizó para realizar la consulta de registros en la base de datos; luego, en la parte del "catch(){}", establecemos el tipo de excepción (SQLException) y la capturamos en una variable llamada "error2"; posteriormente, dentro de las llaves del "catch", vamos a usar un componente "JOptionPane.showMessageDialog", y cuando se produzca una excepción o error, se le informará al usuario del software, a través de una pequeña ventanita (cuadro de diálogo):

finally{

    if(conectar!=null){
        
        try {
        
            conectar.close();
            result.close();
            
            conectar=null;
            result=null;
            
        } catch (SQLException error2) {
            
            JOptionPane.showMessageDialog(null, ex);
        
        }
    
    }

}

9. Debes dirigirte a tu formulario (donde está el JComboBox), y ubicarte en la parte del código; luego, procederás a copiar y pegar la línea de código resaltada con color azul, después de la llave de apertura "{" de la Clase de tu JFrame.
Básicamente, lo que se hace es instanciar un objeto de la Clase donde creamos el método consultar_paises(), a dicho objeto lo hemos llamado "metodos_cargarcombobox":

Cargar_Combobox metodos_cargarcombobox = new Cargar_Combobox();

10. Ubicado allí en tu formulario, deberás irte al método "Constructor" del mismo, y posteriormente copiarás y pegarás dentro de este, el código resaltado de color naranja.

metodos_cargarcombobox.consultar_paises(cbox_Paises);

Como podrás notar, hacemos uso del objeto que hemos instanciado "metodos_cargarcombobox", y posteriormente hacemos uso del método "consultar_paises()", pasándole como parámetro el JComboBox (cbox_Paises) de nuestro formulario (JFrame).

NOTA: Este fragmento de código debemos ubicarlo luego del método "initComponents();" (en el caso que uses NetBeans IDE).

11. Ahora sólo basta con ejecutar tu proyecto y hacer las respectivas pruebas:

JComboBox con Items

¿Quieres aprender más de JAVA?

▷ Código JAVA: Cambiar tamaño de la cabecera (Header) del JTable

2017-05-12T11:16:00.001-05:00

Código JAVA anterior:
Quitar y/o suprimir los espacios en blanco digitados en un JTextField.

-------------------------------------------------------------------------------------------

Este artículo está orientado a la creación e implementación de una línea de código JAVA, que nos permitirá cambiar el tamaño del encabezado de un JTable (tabla) ubicado en un formulario, de nuestra aplicación JAVA:

Método Constructor del Formulario (JFrame):

 public Formulario() {

        initComponents();

        tabla.getTableHeader().setPreferredSize(new java.awt.Dimension(0, 0));


 }

Instrucciones y Recomendaciones

1.Copia y pega la línea de código resaltada en naranja, dentro del método Constructor del JFrame en el cual está ubicada la tabla.
Se recomienda que todo código que se coloque dentro del método constructor de un JFrame, se haga después de la línea de código "initComponents();".

2.En la primera parte de la línea de código, lo que se hace es usar nuestro JTable al cual le hemos puesto por nombre "tabla"; luego, en la segunda parte se le aplica el método ".getTableHeader();", el cual nos va a permitir acceder al encabezado; y por último, usaremos el método ".setPreferredSize()", con el que podremos asignarle un tamaño específico al Header de la tabla; para ello, deberemos pasarle el siguiente parámetro: "new java.awt.Dimension(0,0)"; en otras palabras, estaremos indicando un alto y ancho con valor 0 (cero), con lo cual el Header de la tabla quedará completamente oculto; sin embargo, si deseas que la cabecera no se oculte sino que sea de un tamaño específico, tendrás que tener en cuenta modificar el valor del alto del encabezado, con lo que esta parte del código quedaría: "new java.awt.Dimension(0,100)".
Teniendo en cuenta lo anteriormente explicado, nuestra línea de código quedará de la siguiente forma:

tabla.getTableHeader().setPreferredSize(new java.awt.Dimension(0, 0));

3.Ahora sólo basta con ejecutar tu proyecto JAVA y hacer las respectivas pruebas.

JTable con Header oculto (0,0)

JTable con Header de tamaño específico (0,100)

¿Quieres aprender más de JAVA?

Si deseas ver cómo llevar a cabo la implementación de este y otros códigos más, usando una Interfaz de Desarrollo como NetBeans IDE, no olvides de revisar los tips de JAVA y seguir el Curso: Cómo lo hago en JAVA?

Accede a todos los fragmentos de código que hemos publicado en este lenguaje hasta el momento, dando clic en el siguiente enlace -> Ver listado de códigos JAVA

Suscríbete a nuestro blog, vía Email o RSS; además puedes seguirnos a través de nuestras redes sociales como: Facebook, Twitter, YouTube, y Google+.

¿Conoces una forma más óptima de cambiar el tamaño de la cabecera (Header) de un JTable?, no dudes en compartir tu conocimiento con todos nuestros amigos de la web.

Si te fue de gran ayuda esta información, no olvides compartirla con tus amigos y en las redes sociales.
Si tienes dudas o sugerencias al respecto; puedes dejarnos tus comentarios.
Bendiciones...

▷ Código JAVA: Evitar y/o eliminar espacios en blanco digitados en un JTextField

2016-08-01T16:55:00.001-05:00

Código JAVA anterior:
Crear un JTable con sus celdas y agregarlo a un formulario.

-------------------------------------------------------------------------------------------

Este artículo está orientado a la creación e implementación de una línea de código JAVA, que nos permitirá eliminar de forma automática los espacios en blanco digitados en un campo de texto (JTextField) de un formulario, en nuestra aplicación JAVA:

Código del JTextField (Campo de Texto):

private void txtNombreKeyTyped(java.awt.event.KeyEvent evt) {                                   
       
     txtNombre.setText(txtNombre.getText().trim());

Instrucciones y Recomendaciones

1.Procede a asignarle un evento a tu JTextField. En este caso deberá ser del tipo KeyEvent; específicamente, un KeyTyped.

2.Copia y pega dentro del evento asignado al campo de texto, la línea resaltada en color azul:

txtNombre.setText(txtNombre.getText().trim());

3.En la línea de código aplicada, hacemos uso de nuestro JTextField el cual hemos llamado "txtNombre"; a continuación, le aplicamos el método ".setText();", el cual nos ayudará a asignarle un contenido y/o texto a dicho componente.

txtNombre.setText();

4.Dentro del método ".setText();", llamaremos a nuestro campo de texto y le aplicaremos el método ".getText()", permitiéndonos obtener el texto que hay en dicho elemento. Seguidamente, aplicaremos el método ".trim()", el cual nos ayudará a evitar que queden espacios en blanco a medida que escribamos en el campo de texto:

txtNombre.getText().trim()

5.Ahora sólo basta con ejecutar tu proyecto y hacer las respectivas pruebas.

¿Quieres aprender más de JAVA?

Si deseas ver cómo llevar a cabo la implementación de este y otros códigos más, usando un IDE como NetBeans, no olvides de revisar los tips de JAVA y seguir el Curso: Cómo lo hago en JAVA?

Accede a todos los fragmentos de código que hemos publicado en este lenguaje hasta el momento, dando clic en el siguiente enlace: Ver listado de códigos JAVA

Suscríbete a nuestro blog, vía Email o RSS; además puedes seguirnos a través de nuestras redes sociales como: Facebook, Twitter, y Google+.

¿Conoces una forma más óptima de evitar y/o eliminar espacios en blanco digitados en un JTextField?, no dudes en compartir tu conocimiento con todos nuestros amigos de la web.

Si te fue de gran ayuda esta información, no olvides compartirla con tus amigos y en las redes sociales.
Si tienes dudas o sugerencias al respecto; puedes dejarnos tus comentarios.
Bendiciones...

▷ Código JAVA: Crear un JTable con sus celdas y agregarlo a un formulario

2015-10-26T10:22:00.001-05:00

Código JAVA anterior:
Eliminar registros de una base de datos.

-------------------------------------------------------------------------------------------

Este artículo está orientado a la creación e implementación de un fragmento de código JAVA, que nos permitirá crear una tabla con sus filas y columnas, y posteriormente agregarla a un formulario de nuestra aplicación JAVA:

Clase del JFrame (Formulario):

public class Formulario extends javax.swing.JFrame{
  
    Object titulos []={"Encabezado 1", "Encabezado 2"};
    Object celdas [][]=new Object[4][2];
    JScrollPane scroll = new JScrollPane();
    JTable tabla=new JTable(celdas, titulos);
  
    public Formulario() {
                 
        initComponents();

 
        scroll.setViewportView(tabla);
        scroll.setBounds(20, 20, 200, 100);
        getContentPane().add(scroll);

Instrucciones y Recomendaciones

1.Antes de implementar el código que presentamos en este post, deberás copiar y pegar las siguientes librerías, las cuales son sumamente necesarias para que el código funcione sin inconvenientes.
Recuerda pegarlas después de la línea de código que representa el nombre del paquete (ej. package Formularios;) y sobre la línea de código que identifica el nombre de tu Clase (ej. public class Formulario{...):

import javax.swing.JScrollPane;
import javax.swing.JTable;

2.Copia las 4 líneas de código resaltadas en color azul, y pégalas inmediatamente después de la llave de apertura "{" de la Clase del JFrame, en el cual crearemos y agregaremos nuestro JTable.

3.En las dos primeras líneas de código, estamos creando arrays; el primero, llamado "titulos", el cual es de tipo Object y unidimensional, a este le asignamos un par de valores en su contenido, los cuales funcionarán como encabezados y/o títulos de las columnas de nuestra tabla; el segundo, llamado "celdas", el cual también es de tipo Object pero bidimensional, este nos servirá para crear las celdas de nuestra tabla, para ello, debemos especificar el número de filas (4 en este caso) y de columnas (2). El número de columnas debe de coincidir con el número de valores almacenados en el array anterior (titulos):

Object titulos []={"Encabezado 1", "Encabezado 2"};
Object celdas [][]=new Object[4][2];

4.En las otras dos líneas resaltadas en azul, procedemos a crear un par de componentes; el primero de ellos consiste en un JScrollPane, al cual le hemos llamado "scroll", que nos permitirá agregar el JTable al formulario y hacer uso de las barras de desplazamiento (vertical y horizontal) para poder recorrer y verificar los registros de nuestra tabla; el segundo componente, es nuestro JTable, a este le hemos dado el nombre de "tabla", y procedemos a asignarle los 2 arrays creados con anterioridad (celdas y titulos):

JScrollPane scroll = new JScrollPane();
JTable tabla=new JTable(celdas, titulos);

5.Copia y pega el fragmento de código resaltado en color lila, dentro del método Constructor del JFrame en el que estás trabajando.

Se recomienda que todo código que se coloque dentro del método constructor de un JFrame, se haga después de la línea de código "initComponents();".

6.En la primera línea de esta sección del código, lo que hacemos es usar el componente "scroll" y aplicarle el método ".setViewportView()" al cual le pasamos nuestro JTable como parámetro; en otras palabras, estamos metiendo nuestra tabla en un contenedor (scroll).
En la segunda línea de código, procedemos a asignarle el método ".setBounds()" a nuestro componente de tipo JScrollPane, a dicho método necesitamos pasarle 4 parámetros; el primero (20), nos permitirá ubicar nuestro componente "scroll" en nuestro formulario, a una distancia respecto a la línea y/o borde vertical izquierdo del JFrame; el segundo (20), nos ayudará a ubicar nuestro componente en nuestro formulario, respecto a la línea y/o borde horizontal superior del JFrame; el tercer parámetro (200), es para darle un ancho a nuestro componente; y el cuarto (100), permitirá asignarle un alto. En pocas palabras, los dos primeros parámetros es para ubicar nuestro componente dentro del formulario, y los otros dos, son para asignarle un tamaño al JScrollPane, y por consiguiente a nuestro JTable.
Por último, en la tercera línea, llamaremos al método ".getContentPane()" de nuestro formulario, el cual nos permitirá hacer uso del contenedor del JFrame; por lo cual, le aplicaremos el método ".add()", al cual le pasamos como parámetro nuestro componente "scroll"; es decir, lo que hacemos en esta parte es agregar al formulario, el componente JScrollPane, el cual a su vez ya contiene nuestra tabla:

scroll.setViewportView(tabla);
scroll.setBounds(20, 20, 200, 100);
getContentPane().add(scroll);

7.Ahora sólo basta con ejecutar tu proyecto y hacer las respectivas pruebas:

"JTable con celdas"

¿Quieres aprender más de JAVA?

Si deseas ver cómo llevar a cabo la implementación de este y otros códigos más, usando un IDE como NetBeans, no olvides de revisar los tips de JAVA y seguir el Curso: Cómo lo hago en JAVA?

¿Conoces una forma más óptima de crear un JTable con sus celdas y agregarlo a un formulario?, no dudes en compartir tu conocimiento con todos nuestros amigos de la web.

Si te fue de gran ayuda esta información, no olvides compartirla con tus amigos y en las redes sociales.
Si tienes dudas o sugerencias al respecto; puedes dejarnos tus comentarios.
Bendiciones...

▷ Código JAVA: Borrar información de una base de datos

2015-10-05T14:53:00.000-05:00

Código JAVA anterior:
Obtener el valor máximo y mínimo de un array (vector).

-------------------------------------------------------------------------------------------

Este post está orientado a la aplicación e implementación de un fragmento de código JAVA, que nos permitirá eliminar registros almacenados en una tabla de la base de datos; lo cual, ayudará a que se mantenga la integridad de la información, ya que estaremos quitando todos esos datos que no son de utilidad:

Método Eliminar:

Pool metodospool = new Pool();    

public void Eliminar(String idcontacto, String valor, String filtro, JTable tablacontactos){
    
 
int confirmar = JOptionPane.showConfirmDialog(null, "Esta seguro que desea eliminar el registro?");


if(JOptionPane.OK_OPTION==confirmar) {

   
   Connection conexion = null;

 try {

        conexion = metodospool.dataSource.getConnection();

        String Ssql = "DELETE FROM contacto "
                    + "WHERE id_contacto = ?";
        
        PreparedStatement prest = conexion.prepareStatement(Ssql);

         
        prest.setString(1, idcontacto);

        if(prest.executeUpdate()>0){
            
                JOptionPane.showMessageDialog(null, "El registro ha sido eliminado exitosamente", 
                                              "Operación Exitosa", JOptionPane.INFORMATION_MESSAGE);
                            
                //Opcional
                Buscar(valor, filtro, tablacontactos);

                Limpiar();

         }else{
            
                JOptionPane.showMessageDialog(null, "No se ha podido eliminar el registro\n"
                + "Inténtelo nuevamente.", "Error en la operación", 
                JOptionPane.ERROR_MESSAGE);

        }

   } catch(SQLException error){
       
       JOptionPane.showMessageDialog(null, "No se ha podido eliminar el registro\n Inténtelo nuevamente.\n"
                                    + "Error: "+error, "Error en la operación", JOptionPane.ERROR_MESSAGE);
        
   }finally{
   
        
        if(conexion!=null){
        
            try {
                     
                 conexion.close();
            
            } catch (SQLException error2) {
                 
                     JOptionPane.showMessageDialog(null, "Error al intentar cerrar la conexión.\n Error: "+error2, 
                                                   "Error en la operación", JOptionPane.ERROR_MESSAGE);
                 
            }
            
        }       
   
   
   }


}


}

Método del botón Eliminar (jButton):

MetodosBD metodosbd = new MetodosBD();

private void btnEliminarActionPerformed(java.awt.event.ActionEvent evt) {                                            
       
   if(idcontacto.isEmpty()){
       
       JOptionPane.showMessageDialog(null, "No hay datos para eliminar.\n"
       + "Por favor, seleccione un registro de la tabla.", "Error en la operación", JOptionPane.ERROR_MESSAGE);
       
   }else{

        metodosbd.Eliminar(idcontacto, txtValorbusqueda.getText(), cboxFiltro.getSelectedItem().toString(), tblDatos);

   }

VIDEO TUTORIAL (PASO A PASO)

Instrucciones y Recomendaciones

1. Antes que todo, deberás copiar y pegar las siguientes librerías, las cuales son sumamente necesarias para que el código que vamos a implementar (Método Eliminar) funcione sin inconvenientes.
Recuerda pegarlas después de la línea de código que representa el nombre del paquete (ej. package Metodos;) y sobre la línea de código que identifica el nombre de tu Clase (ej. public class MetodosBD{...):

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import javax.swing.JOptionPane;
import javax.swing.JTable;

2. Copia y pega el código resaltado en color rosa y el de color azul, luego de la llave de apertura "{" de la Clase JAVA donde tienes los métodos de tu proyecto.
En la primera línea de código (color rosa), lo que se hace es instanciar un objeto de la Clase Pool que permite la conexión con la Base de datos, y al que hemos llamado "metodospool":

Pool metodospool = new Pool();

3. Siguiendo con el apartado de color azul, este representa la estructura de un método que nos ayudará a eliminar registros almacenados en las tablas de la base de datos.
En la primera parte, definimos las propiedades de nuestro método, en este caso, "public" (para que esté disponible y sea accedido desde otras Clases) y "void" (no esperamos que devuelva un valor desde su interior); a continuación, le especificamos un nombre, el cual ya sabemos que debe ir relacionado acorde a la función que llevará o ejecutará el método, por ello lo hemos llamado "Eliminar".

Lo que sigue ahora, es colocar entre paréntesis "()" los parámetros que el método necesitará para llevar a cabo el proceso de forma adecuada.
Para esta oportunidad, hemos asignado 4 parámetros; 3 de tipo "String" (idcontacto, valor, filtro); y 1 de tipo "JTable" (tablacontactos).

Dentro de los parámetros hay uno que es el principal, y es el que representa al campo identificador del registro a eliminar; es decir, que contendrá la llave y/o clave primaria. En este caso, nuestro parámetro identificador es "idcontacto".

Los otros 3 parámetros (valor, filtro, y tablacontactos), en esta oportunidad, no son necesarios para realizar el proceso de eliminación; sin embargo, los hemos colocado porque los usaremos para poder implementar otro método que nos permitirá complementar el proceso de borrado.

Una vez hemos terminado de asignar los parámetros respectivos y necesarios, inmediatamente después del paréntesis de cierre ")", vamos a colocar un par de llaves, una de apertura "{", y otra de cierre "}", las cuales van a delimitar y contendrán todo el código de nuestro método "Eliminar":

public void Eliminar(String idcontacto, String valor, String filtro, JTable tablacontactos){}

4. Dentro de las llaves de nuestro método, primero vamos a crear una variable del tipo "int", y que hemos de llamar "confirmar", la cual usaremos para almacenar el valor que nos devuelve un componente "JOptionPane".
En forma más explícita, al colocar esta línea de código se le mostrará al usuario un cuadro de diálogo con el mensaje "¿Está seguro que desea eliminar el registro?", donde podrá escoger entre tres opciones: "Sí", "No", o "Cancelar". Dependiendo de la opción cliqueada por el usuario del software, se devolverá un valor de tipo entero, el cual es el que almacenaremos en la variable "confirmar":

int confirmar = JOptionPane.showConfirmDialog(null, "Está seguro que desea eliminar el registro?");

5. En el siguiente paso, vamos a establecer un condicional "if", en el cual compararemos el valor almacenado en la variable "confirmar", con la constante del componente JOptionPane "YES_OPTION", la cual representa el valor entero que se genera cuando se da clic en el botón "Sí" del cuadro de diálogo.
En pocas palabras, si el usuario del software da clic en "Sí" del cuadro de diálogo, se procederá a ejecutar el código que coloquemos dentro del condicional "if":

if(confirmar == JOptionPane.YES_OPTION){}

6. Dentro de las llaves "{}" del condicional "if", crearemos un objeto y/o variable del tipo "Connection" a la que le daremos el nombre de "conexion", y le asignaremos un valor "null". Esta variable nos permitirá almacenar, gestionar, y administrar la conexión que estableceremos con nuestra base de datos:

Connection conexion = null;

7. Luego, emplearemos un bloque "try{}catch(){}finally{}".
Dentro de las llaves "{}" del "try", haremos varias cosas:

a. Usaremos el objeto tipo "Connection", y luego del signo igual "=" procederemos a usar el objeto "metodospool", con el cual tendremos acceso al objeto y/o variable de tipo "DataSource" de la Clase Pool que creamos en un artículo anterior, aplicándole posteriormente el método ".getConnection()"; con esto, estaremos estableciendo la conexión con la base de datos:

conexion = metodospool.dataSource.getConnection();

b. Se procederá a crear una variable del tipo "String", y que hemos de llamar "Ssql", en esta vamos a guardar la sentencia SQL que nos permitirá realizar la eliminación de datos. En dicha sentencia debemos especificar el campo identificador y/o clave primaria del registro que vamos a eliminar.
Si necesitas tener más clara la estructura de este tipo de sentencia, puedes leer nuestro post: "Sentencia SQL: Eliminar registros de una tabla".

String Ssql = "DELETE FROM contacto WHERE id_contacto = ?";

c. Vamos a preparar y a verificar la sentencia SQL, con la que realizaremos el borrado de datos; por lo cual, crearemos una variable del tipo "PreparedStatement", y la llamaremos "prest"; luego del signo igual (=), usaremos el objeto "conexion", al cual le aplicaremos el método ".prepareStatement()", a su vez, a este le pasaremos como parámetro, la variable "Ssql":

PreparedStatement prest = conexion.prepareStatement(Ssql);

d. Haremos uso del objeto "prest", y le aplicaremos el método ".setString()".
A dicho método, debemos pasarle un par de parámetros; el primero, corresponde a un número (1) que representa la posición del campo en la sentencia SQL; y el segundo, es la variable (idcontacto) que almacena el valor que asignaremos al campo ubicado en la posición estipulada en el parámetro anterior:

prest.setString(1, idcontacto);

NOTA: La variable "idcontacto" que usamos, es la que se encuentra entre los parámetros que le hemos pasado al método "Eliminar" (ver paso 3).

e. Emplearemos un condicional "if(){}else{}", y la condición a establecer será que si al aplicarle el método ".executeUpdate()" al objeto "prest" (lo cual hará que se lleve a cabo el proceso de eliminación de datos), retorna un valor mayor que "0" (cero); es decir, que se realizó la eliminación de información en forma exitosa, se procederá a mostrarle al usuario del software, un cuadro de diálogo donde se le informará el éxito de la operación; en caso contrario, se mostrará un mensaje donde se le hará saber que se produjo algún error al intentar el borrado de datos:

if(prest.executeUpdate()>0){
            
                JOptionPane.showMessageDialog(null, "El registro ha sido eliminado exitosamente", 
                                              "Operación Exitosa", JOptionPane.INFORMATION_MESSAGE);
                         
                //Opcional
                Buscar(valor, filtro, tablacontactos);

                Limpiar();

}else{
            
               JOptionPane.showMessageDialog(null, "No se ha podido eliminar el registro\n"
               + "Inténtelo nuevamente.", "Error en la operación", 
               JOptionPane.ERROR_MESSAGE);

}

NOTA: Dentro del "if", podemos observar que hemos puesto un comentario "//Opcional", sobre dos líneas de código; ya que en realidad, no son necesarias o indispensables en el proceso de eliminación; es decir, que si quieres, no las uses. Estas líneas, representan dos métodos; el primero, es el método "Buscar()" (Ver explicación del método), el cual nos permitirá actualizar el JTable de nuestro formulario, una vez se elimine el registro seleccionado, ya que si no se hace esto, dicho registro seguirá apareciendo en la tabla del formulario, así se haya eliminado de la base de datos. Podemos además, ver que los otros 3 parámetros que le pasamos al método eliminar, son para usarlos aquí en el método "Buscar()"; esto quiere decir, que si no vas a implementar el método "Buscar()" en tu código, entonces, al método "Eliminar", sólo deberás pasarle un parámetro; es decir, "idcontacto". El segundo método llamado "Limpiar()" (Ver código de ejemplo), cumple un papel similar al método anterior, sólo que este se ocupará de borrar o como su nombre lo indica, limpiar todos los demás componentes del formulario (JTextField, Combo Box, Variables, etc.); en otras palabras, dejar el formulario sin ningún rastro de información correspondiente al registro que se ha eliminado.

Teniendo en cuenta las líneas de código de los puntos a, b, c, d, y e; la sección del "try{}" quedaría así:

 try {

        conexion = metodospool.dataSource.getConnection();

        String Ssql = "DELETE FROM contacto "
                    + "WHERE id_contacto = ?";
        
        PreparedStatement prest = conexion.prepareStatement(Ssql);          
        prest.setString(1, idcontacto);

        if(prest.executeUpdate()>0){
            
                JOptionPane.showMessageDialog(null, "El registro ha sido eliminado exitosamente", 
                                              "Operación Exitosa", JOptionPane.INFORMATION_MESSAGE);
                            
                //Opcional
                Buscar(valor, filtro, tablacontactos);

Limpiar();

 }else{
            
               JOptionPane.showMessageDialog(null, "No se ha podido eliminar el registro\n"
               + "Inténtelo nuevamente.", "Error en la operación", 
               JOptionPane.ERROR_MESSAGE);

        }

   }

8. En la parte del "catch(){}", dentro de los paréntesis "()" establecemos el tipo de excepción que puede producirse (SQLException), y la almacenaremos y/o capturaremos en una variable llamada "error".
Ahora, dentro de las llaves de apertura "{" y de cierre "}", haremos uso del componente "JOptionPane.showMessageDialog", esto con el fin de mostrarle al usuario a través de un pequeño cuadro de diálogo, el error que se ha producido; es decir, la causa que llevó a que no se eliminaran los datos:

} catch(SQLException error){
       
       JOptionPane.showMessageDialog(null, "No se ha podido eliminar el registro\n Inténtelo nuevamente.\n"
                                    + "Error: "+error, "Error en la operación", JOptionPane.ERROR_MESSAGE);
        
}

9. En la última sección del "método Eliminar", vemos la parte del "finally{}", dentro de sus llaves utilizamos un condicional "if", en el cual comprobaremos si la conexión con la base de datos no es nula (null); en tal caso, se procederá a ejecutar lo que hemos establecido dentro del "if", y que básicamente consiste en un bloque "try{}catch(){}".

Dentro del "try{}", usamos el objeto "conexion", a este le estableceremos el método ".close()" con el fin de cerrar y/o liberar la conexión que se utilizó para realizar la eliminación de registros en la base de datos; luego, en la parte del "catch(){}", establecemos el tipo de excepción (SQLException) y la capturamos en una variable llamada "error2"; posteriormente, dentro de las llaves del "catch", vamos a usar un componente "JOptionPane.showMessageDialog", y cuando se produzca una excepción o error, se le informará al usuario del software, a través de una pequeña ventanita (cuadro de diálogo):

}finally{
    
        if(conexion!=null){
        
            try {
                
                conexion.close();
            
            } catch (SQLException error2) {
            
                JOptionPane.showMessageDialog(null, "Error al intentar cerrar la conexión."
                                          + "Error: "+error2, "Error en la operación", 
                                          JOptionPane.ERROR_MESSAGE);
                
            }
            
        }
           
}

10. Debes dirigirte a tu formulario (donde está el botón eliminar), y ubicarte en la parte del código; luego, procederás a copiar y pegar la línea de código resaltada con color lila, después de la llave de apertura "{" de la Clase de tu JFrame.
Básicamente, lo que se hace es instanciar un objeto de la Clase donde creamos el método Eliminar, a dicho objeto lo hemos llamado "metodosbd":

MetodosBD metodosbd = new MetodosBD();

11. Ubicado allí en tu formulario, deberás establecerle un evento al botón (del tipo ActionEvent), más exactamente el método "actionPerformed()", y posteriormente copiarás y pegarás dentro de este, el código resaltado de color verde.
En este fragmento de código procedemos a implementar un condicional "if(){}else{}", y en la condición verificaremos que una variable (String) de nuestro formulario, la cual hemos llamado "idcontacto", esté vacía (para ello usamos el método ".isEmpty()").
Dicha variable contiene el identificador y/o clave primaria del registro que hemos de eliminar; por lo cual, con anterioridad se debió haber hecho el proceso de buscar información en la base de datos desde nuestro formulario y haber seleccionado un registro determinado.

En el caso de que se cumpla la condición, se le mostrará al usuario del software, un cuadro de diálogo informándole de que no hay ningún registro seleccionado para eliminar. En caso contrario (else), usaremos el objeto "metodosbd", y llamaremos a nuestro método "Eliminar"; seguidamente, debemos pasarle los parámetros respectivos:

   if(idcontacto.isEmpty()){
       
       JOptionPane.showMessageDialog(null, "No hay datos para eliminar.\n"
                                     + "Por favor, seleccione un registro de la tabla.",                                      "Error en la operación", JOptionPane.ERROR_MESSAGE);
       
   }else{

        metodosbd.Eliminar(idcontacto, txtValorbusqueda.getText(), cboxFiltro.getSelectedItem().toString(), tblDatos);

   }

NOTA: Debemos tener cuidado a la hora de pasar los parámetros, ya que deben de coincidir con el mismo orden de las variables de nuestro método (ver paso 3); es decir, que si el primer parámetro original de nuestro método es la variable "idcontacto", debemos colocar en ese primer lugar, la variable de nuestro formulario que la representa (ej. idcontacto).

12. Ahora sólo basta con ejecutar tu proyecto y hacer las respectivas pruebas:

"Botón Eliminar"

¿Quieres aprender más de JAVA?

Si deseas saber cómo eliminar registros de una base de datos, pero de forma netamente gráfica usando NetBeans IDE, o ver otros temas muy interesantes, no te olvides de revisar los tips de JAVA y seguir el Curso: Cómo lo hago en JAVA?