Cómo hacer un proyecto, un paquete y un formulario.

15/04/2016
En esta primera parte podrán encontrar los pasos de cómo realizar un
proyecto, un paquete y un formulario en JAVA.

Durante la realización del curso se estará utilizando el IDE Netbeans; el cual es

un entorno de desarrollo gratuito, creado pensando primeramente en
el desarrollo de aplicaciones con JAVA

1-Crear un proyecto:

Ejecutamos Netbeans IDE:

Clic en File, y luego en New Project:

Cómo hacer un proyecto, un paquete y un formulario. 15/04/2016
Luego aparecerá la siguiente ventana (New Project):

En la parte de "Categories" seleccionaremos la carpeta Java:

Observaremos en la parte de "Projects" algunos elementos, de los cuales

seleccionaremos "Java Application", y luego damos clic en el botón "Next":
Cómo hacer un proyecto, un paquete y un formulario. 15/04/2016
Luego aparecerá la siguiente ventana (New Java Application):

En la parte de "Project Name", digitaremos el nombre que le daremos al

proyecto o aplicación que vamos a crear, en este caso le colocaremos
"Aplicacion1":

NOTA: Podemos colocarle cualquier nombre a nuestro proyecto; sin embargo,

no podemos utilizar ciertos caracteres cómo *?: entre otros, en caso dado que
usemos alguno de ellos, NetBeans nos mostrará un error en la parte inferior de
la ventana en la que estamos trabajando:

Luego en la parte de "Project Location", podremos escoger la ubicación o

carpeta donde guardaremos nuestro proyecto, para esto daremos clic en el
botón "Browse…", y luego buscamos la carpeta que queremos, la
seleccionamos y finalmente damos clic en Abrir:
Cómo hacer un proyecto, un paquete y un formulario. 15/04/2016

En la ventana "New Java Application", podemos observar unas cajas de

chequeo las cuales deseleccionaremos y damos clic en el botón "Finish":

Luego veremos en la ventana "Projects", nuestro proyecto creado en Netbeans:

Cómo hacer un proyecto, un paquete y un formulario. 15/04/2016

2-Crear un paquete:

Seleccionamos la carpeta "Source Packages" de nuestro proyecto, y luego

damos clic derecho sobre ella; aparecerá un menú flotante en el cual
ubicaremos el puntero del mouse sobre "New", inmediatamente nos aparecerá
una serie de elementos de los cuales daremos clic sobre "Java Package":

Aparecerá la ventana "New Java Package"; en la parte de "Package Name",

digitamos el nombre que le daremos a nuestro paquete (aquí tendremos en
cuenta las mismas recomendaciones que cuando le damos un nombre a un
proyecto); en este caso le llamaremos "Formularios", y damos clic en el botón
"Finish":
Cómo hacer un proyecto, un paquete y un formulario. 15/04/2016
Ya podemos ver nuestro paquete creado en la ventana "Projects" de Netbeans:

NOTA: Los paquetes en java son usados para agrupar las clases que vayamos
creando; esto nos va a ayudar, a llevar una mejor organización a la hora de
desarrollar nuestras aplicaciones.

3-Crear un formulario:

Seleccionamos el paquete "Formularios", que creamos anteriormente, y luego

damos clic derecho sobre este; aparecerá un menú flotante en el cual
ubicaremos el puntero del mouse sobre New, inmediatamente nos aparecerá una
serie de elementos de los cuales daremos clic sobre "JFrame Form":
Cómo hacer un proyecto, un paquete y un formulario. 15/04/2016
Aparecerá la ventana "New JFrame Form", en la parte de "Class Name"
colocaremos el nombre que le daremos a nuestro formulario (aquí tendremos
en cuenta las mismas recomendaciones que cuando le damos un nombre a un
proyecto); en este caso le llamaremos Formulario1 y damos clic en el botón
"Finish":

Ahora podemos ver en la ventana "Projects", que nuestro formulario fue

creado; sin embargo, podemos observar que automáticamente Netbeans nos
abre el formulario creado en la ventana central:
Cómo hacer un proyecto, un paquete y un formulario. 15/04/2016
Notaremos a la izquierda de la ventana de Netbeans, que hay una paleta de
elementos (cajas de texto, etiquetas, botones, etc...), los cuales usaremos para
darle forma a nuestro formulario:

Lo que haremos será dar clic sobre el elemento que queremos colocar en
nuestro formulario, y luego dirigir el puntero del mouse a nuestro JFrame o
formulario, y dar clic en este en la parte donde queremos colocar el elemento:
Cómo hacer un proyecto, un paquete y un formulario. 15/04/2016
Luego de colocar todos los elementos que queremos a nuestro formulario
tendremos algo como esto:

Para poder cambiar el tamaño de un elemento, sólo basta con seleccionarlo y

ubicarnos en uno de sus extremos (superior, inferior, derecho, izquierdo o las
esquinas), y veremos que el puntero del mouse toma una forma como de flecha
doble (bidireccional), en ese momento damos clic sostenido y arrastramos el
mouse hacia la dirección correcta y hasta la distancia requerida:

Cambiando el tamaño de una Caja de texto:

Cambiando el tamaño de un JFrame (Formulario):

Cómo hacer un proyecto, un paquete y un formulario. 15/04/2016
Ahora lo que haremos será cambiarle el texto a nuestros elementos; en este
caso seleccionamos el elemento y luego damos clic derecho sobre este; nos
saldrá un menú flotante en el cual damos clic sobre "Edit Text", y luego
procederemos a escribir el texto que deseamos y presionamos la tecla ENTER:

Luego que hagamos lo mismo con cada uno de los elementos del formulario,
obtendremos el siguiente resultado:
Abrir o llamar un formulario 15/04/2016

1. creamos nuestros dos formularios en nuestro proyecto, dentro de nuestro

paquete (Formularios):

Formulario 1:

Formulario 2:

Programación Gráfica. Ejercicio 2

Abrir o llamar un formulario 15/04/2016

En el Formulario 1 hay un botón "Ir"; lo que haremos será cambiarle el nombre

a la variable del componente, la cual nos va a permitir identificarlo cuando
estemos trabajando en la parte de código; para esto seleccionaremos el botón y
damos clic derecho sobre el mismo, nos saldrá un menú flotante y damos clic
en "Change Variable Name", y automáticamente saldrá una pequeña ventanita
en la cual digitaremos el nombre de la variable, en este caso le llamaremos
"btnIr" y damos clic en "OK":

NOTA: Se recomienda que al darle un nombre a la variable de un componente,

este comience con la descripción del componente o una abreviatura del mismo,
unido con la acción que realiza este elemento, por ejemplo cuando nombramos
a un botón cuya función sea guardar, le podemos llamar: btnGuardar o
botonGuardar; si es una caja de texto en la cual se digitan específicamente
apellidos le podemos llamar: txtApellidos o cajadetextoApellidos; y así
haremos con cada uno de los elementos que contenga nuestro formulario.

Luego sobre el botón "Ir", daremos doble clic y se nos mostrará

automáticamente la parte del código del botón, en otras palabras el método que
contendrá las acciones que realizará este:

Programación Gráfica. Ejercicio 2

Abrir o llamar un formulario 15/04/2016

Procederemos a borrar lo que hay dentro del método y colocaremos el siguiente

código:

Formulario2 verformulario2=new Formulario2();

verformulario2.setVisible(true);

El método del botón quedaría así:

Si ejecutamos nuestro Formulario1 y damos clic en el botón Ir; podremos

observar que se hará visible nuestro Formulario2:

Programación Gráfica. Ejercicio 2

 Formulario aparezca en el centro de tu pantalla

1. Seleccionaremos nuestro formulario y/o JFrame, dando clic directamente

sobre el mismo, o seleccionándolo en la ventana "Navegador"
(Inspector), la cual está ubicada en la parte inferior izquierda de
NetBeans IDE:

2. Luego, nos dirigimos al área de propiedades, la cual está ubicada en la

parte inferior derecha de nuestra pantalla, en NetBeans IDE.
Seguidamente daremos clic en la pestaña y/o sección llamada "Code":

3. Buscamos la propiedad "Generate Center", y activaremos la casilla que

allí se encuentra, dando clic sobre la misma:

Rafael Herrera Pineda Programación Gráfica

 Formulario aparezca en el centro de tu pantalla
4. Ahora sólo queda ejecutar nuestro proyecto y verificar que todo esté
funcionando correctamente:

Rafael Herrera Pineda Programación Gráfica

 Agregar datos de un formulario a una tabla, y eliminarlos de la
misma
A la hora de realizar nuestros formularios, nos encontramos muchas veces con
la necesidad o el requerimiento de acumular datos en una tabla (JTable), en
este Curso de JAVA, no sólo aprenderemos a agregar a una tabla los datos que
hemos digitado en los distintos campos de nuestro formulario; sino también a
eliminarlos de la misma.

Procederemos a agregar una tabla a nuestro formulario:

Luego lo que haremos será modificar el contenido de nuestra tabla, para ello la
seleccionamos y damos clic derecho sobre la misma; y escogemos la opción
“Table Contents…”:

Rafael Herrera Pineda Programación Gráfica

 Agregar datos de un formulario a una tabla, y eliminarlos de la
misma
En la ventana que nos aparece, damos clic en la pestaña "Columns":

Y en los campos “Title”, colocamos el nombre de cada columna que tendrá

nuestra tabla:

Rafael Herrera Pineda Programación Gráfica

 Agregar datos de un formulario a una tabla, y eliminarlos de la
misma
Si nos llega a hacer falta alguna columna, lo que haremos será dar clic en el
botón “Insert”, el cual presionaremos cierto número de veces de acuerdo al
número de columnas que necesitemos; es decir, si necesitamos 1 columna lo
presionamos una vez; si necesitamos 2 columnas, lo presionamos dos veces, y
así sucesivamente...

Luego nos dirigimos a la pestaña “Rows”:

Rafael Herrera Pineda Programación Gráfica

 Agregar datos de un formulario a una tabla, y eliminarlos de la
misma
En el campo “Count”, reemplazamos la cantidad que está por defecto y le
asignamos la cantidad 0 (cero), presionando seguidamente la tecla ENTER de
nuestro teclado, esto con el fin de eliminar las filas que trae la tabla de manera
predeterminada. Después de realizar lo anterior damos clic en el botón “Close”:

Ahora le asignaremos un nombre a nuestra tabla, seleccionándola y dando clic

derecho sobre la misma, escogiendo luego la opción “Change Variable
Name…”:

Rafael Herrera Pineda Programación Gráfica

 Agregar datos de un formulario a una tabla, y eliminarlos de la
misma
Luego de colocar el nombre damos clic en “OK”:

Ahora agregaremos dos botones a nuestro formulario uno para Agregar y otro
para Eliminar registros:

Damos doble clic sobre el botón “Agregar”, y borramos el comentario que trae
por defecto el método del botón:

Rafael Herrera Pineda Programación Gráfica

 Agregar datos de un formulario a una tabla, y eliminarlos de la
misma

Colocamos el siguiente código dentro del método de nuestro botón:

DefaultTableModel modelo = (DefaultTableModel) tblDatos.getModel();

Object [] fila=new Object[6];

fila[0]=txtNombrecontacto.getText();
fila[1]=txtApellidoscontacto.getText();
fila[2]=txtEmail.getText();
fila[3]=txtTelefono.getText();
fila[4]=txtDireccion.getText();
fila[5]=cboxSexo.getSelectedItem().toString();

modelo.addRow(fila);

tblDatos.setModel(modelo);

El método de nuestro botón quedaría así:

Rafael Herrera Pineda Programación Gráfica

 Agregar datos de un formulario a una tabla, y eliminarlos de la
misma
Nos dirigimos nuevamente a la parte gráfica de nuestro formulario y damos
doble clic sobre el botón “Eliminar”, y borramos el comentario que trae por
defecto el método del botón:

Colocamos el siguiente código dentro del método de nuestro botón:

DefaultTableModel model = (DefaultTableModel) tblDatos.getModel();

int a = tblDatos.getSelectedRow();

if (a<0){

JOptionPane.showMessageDialog(null,
"Debe seleccionar una fila de la tabla" );

}else {

int confirmar=JOptionPane.showConfirmDialog(null,
"Esta seguro que desea Eliminar el registro? ");

if(JOptionPane.OK_OPTION==confirmar) {

model.removeRow(a);

JOptionPane.showMessageDialog(null,
"Registro Eliminado" );

}
}

Rafael Herrera Pineda Programación Gráfica

 Agregar datos de un formulario a una tabla, y eliminarlos de la
misma
El método de nuestro botón quedaría así:

Si ejecutamos nuestro proyecto, luego de llenar los distintos campos y al

presionar el botón agregar, obtenemos el resultado deseado:

Rafael Herrera Pineda Programación Gráfica

 Agregar datos de un formulario a una tabla, y eliminarlos de la
misma
Si probamos el botón “Eliminar”, si no seleccionamos ningún registro nos
saldrá el siguiente mensaje:

En caso contrario, si seleccionamos un registro, nos pedirá confirmación,

daremos clic en “Sí”, y de forma inmediata se eliminará el registro:

Rafael Herrera Pineda Programación Gráfica

 Agregar datos de un formulario a una tabla, y eliminarlos de la
misma

Rafael Herrera Pineda Programación Gráfica

 Limpiar cajas de texto
Veremos un tema simple pero a la vez muy necesario a la hora de realizar
nuestras aplicaciones, el cual consiste en conocer el procedimiento para limpiar
las cajas de texto de nuestros formularios.

Para realizar este ejercicio usaremos un botón de nuestra aplicación, sobre el

cual daremos doble clic y nos aparecerá la parte del código:

Procedemos a borrar el comentario que está por defecto:

Ahora dentro del método del botón escribimos el siguiente código:

txtApellidoscontacto.setText(null);
txtDireccion.setText("");
txtEmail.setText(null);
txtNombrecontacto.setText("");
txtTelefono.setText(null);

El método de nuestro botón quedaría así:

Lo que hacemos es llamar la caja de texto por su nombre y seguidamente le

asignamos el texto que queremos que tenga, en este caso ninguno.
 Activar el botón salir

Aprenderemos a programar el conocido botón salir. En esta oportunidad

veremos y observaremos 2 formas principales de realizar este botón, por un
lado aquel que nos ayuda a cerrar una sola ventana de nuestra aplicación, y por
el otro aquel que nos permite cerrar de una manera total toda nuestra
aplicación.

Seguiremos usando nuestros dos formularios que hemos creado en el paquete

(Formularios) de nuestro proyecto:

Formulario 1:

Rafael Herrera Pineda Programación Gráfica

 Activar el botón salir
Formulario 2:

En ambos formularios tenemos un botón llamado "Salir", comenzaremos

usando el del Formulario2, y procedemos a cambiarle el nombre a la variable
del botón; seleccionándolo, damos clic derecho sobre el mismo, escogemos la
opción "Change Variable Name" y en el cuadro que aparece escribiremos
"btnsalirformulario2", y damos clic en "OK":

Rafael Herrera Pineda Programación Gráfica

 Activar el botón salir
Luego daremos doble clic sobre este botón y se nos mostrará automáticamente
la parte del código del mismo, en otras palabras el método que contendrá las
acciones que realizará este:

Procederemos a borrar lo que hay dentro del método y colocaremos el siguiente

código:

dispose();

El método del botón quedaría así:

Ahora en el "Fomulario1", seleccionaremos el botón "Salir" que se encuentra

allí, le cambiamos el nombre a la variable de este y le colocamos
"btnsaliraplicacion"; luego, daremos doble clic sobre este botón y se nos
mostrará automáticamente la parte del código del mismo, en otras palabras el
método que contendrá las acciones que realizará este:

Rafael Herrera Pineda Programación Gráfica

 Activar el botón salir

Procederemos a borrar lo que hay dentro del método y colocaremos el siguiente

código:
System.exit(0);

El método del botón quedaría así:

Rafael Herrera Pineda Programación Gráfica

 Programar el botón guardar

En nuestro paquete “Metodos”, procederemos a crear una nueva Clase la cual

llamaremos “MetodosBD”.

Para ello, damos clic derecho sobre nuestro paquete; luego, escogemos la
opción “Nuevo” (New), y seguidamente se nos mostrarán varias alternativas,
pero en esta ocasión seleccionaremos la que dice “Java Class…” (Clase Java).

Ahora se nos mostrará una ventana en la cual vamos a asignarle un nombre a

nuestra Clase. Dicho nombre lo digitaremos en el campo “Nombre de Clase”
(Class Name), para que posteriormente demos clic en el botón “Terminar”:

Una vez creada nuestra Clase Java, construiremos un método llamado

“Guardar”, que es el que nos permitirá proceder a almacenar en nuestra base de
 Programar el botón guardar

datos, la información consignada en un determinado formulario de nuestro

software.
En forma generalizada, en dicho método procederemos a conectarnos a nuestra
base de datos, usaremos una sentencia SQL la cual será preparada y/o
verificada, asignándole posteriormente las variables (con sus valores
respectivos) que han sido establecidas como parámetros en nuestro método; en
este caso, estos parámetros representan los valores de los campos de nuestro
formulario Java.
Para no tener errores y/o fallas en nuestro código y así poder guardar
información en nuestra base de datos sin ningún problema, deberemos importar
ciertas librerías.
Este método devolverá un valor de tipo entero (int), el cual avisará si el
proceso se ha realizado de forma correcta o no.

Teniendo en cuenta todo lo anterior, nuestra Clase quedaría de la siguiente

forma:

package Metodos;

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

public class MetodosBD {

Pool metodospool = new Pool();

public int Guardar(String nombres, String apellidos, String email, String

celular,
String direccion, String sexo){
 Programar el botón guardar

int resultado = 0;

Connection con = null;

String SSQL = "INSERT INTO contacto (nombres, apellidos, email, celular,

direccion, sexo) "
+ "VALUES (?, ?, ?, ?, ?, ?)";

try {

con = metodospool.dataSource.getConnection();

PreparedStatement psql = con.prepareStatement(SSQL);

psql.setString(1, nombres);
psql.setString(2, apellidos);
psql.setString(3, email);
psql.setString(4, celular);
psql.setString(5, direccion);
psql.setString(6, sexo);

resultado = psql.executeUpdate();

psql.close();

} catch (SQLException e) {

JOptionPane.showMessageDialog(null, "Error al intentar almacenar la

información:\n"
+ e, "Error en la operación", JOptionPane.ERROR_MESSAGE);

}finally{
 Programar el botón guardar

try {

if(con!=null){

con.close();

} catch (SQLException ex) {

JOptionPane.showMessageDialog(null, "Error al intentar cerrar la conexión:\n"

+ ex, "Error en la operación", JOptionPane.ERROR_MESSAGE);

return resultado;

}
}
Si deseas obtener una explicación detallada línea por línea del código anterior,
puedes visitar el siguiente artículo: "Código JAVA: Guardar registros en una
base de datos".
Una vez hayamos terminado el método, nos dirigiremos a nuestro formulario
Java, y daremos doble clic sobre el botón “Guardar”:

Borraremos el comentario que está allí por defecto, y colocaremos el siguiente

código:
 Programar el botón guardar

MetodosBD metodosbd = new MetodosBD();

int exito = metodosbd.Guardar(txtNombrecontacto.getText(),

txtApellidoscontacto.getText(),
txtEmail.getText(), txtCelular.getText(), txtDireccion.getText(),
cboxSexo.getSelectedItem().toString());

if(exito>0){

JOptionPane.showMessageDialog(null, "Los datos se han guardado

correctamente",
"Éxito en la operación", JOptionPane.INFORMATION_MESSAGE);

}else{

JOptionPane.showMessageDialog(null, "Los datos no se pudieron guardar\n"

+ "Inténtelo nuevamente", "Error en la operación",
JOptionPane.ERROR_MESSAGE);

Vemos que lo que hacemos es llamar al método “Guardar” pasándole los

valores que se capturan de los campos del formulario en el que nos
encontramos. Utilizamos además el valor entero que se nos devuelve, y
dependiendo de dicho valor, le avisamos al usuario a través de un cuadro de
diálogo, si se ha guardado o no, la información en la base de datos.

Ahora sólo debemos ejecutar nuestro proyecto y/o formulario, rellenar los
 Programar el botón guardar
campos con los datos correspondientes y pulsar el botón “Guardar” para así
poder obtener el resultado esperado:
 Cómo hacer un Login
Usuario y contraseña fijos sin conexión a Base de datos

Al realizar una aplicación, en especial una que maneja información importante para el
usuario y/o empresa que adquiere dicho programa, se hace necesario crear esquemas de
seguridad como lo son en primera instancia el acceso al sistema mediante un usuario y
contraseña.

Luego de haber aprendido en el capítulo anterior a agregar datos de un formulario a una

tabla, y eliminarlos de la misma, en esta parte del curso aprenderemos a desarrollar un
sencillo formulario de acceso o Login, el cual consta de un usuario y contraseña fijos; es
decir, establecidos por el desarrollador en el código del software, lo que los hace
inmodificables una vez se haya compilado el programa.

Procederemos a crear un nuevo formulario el cual llamaremos Login (te podría interesar
ver cómo crear un proyecto, un paquete y un formulario), y a este le

agregaremos 2 JLabel (a uno le asignamos el texto “USUARIO”, y al otro el texto

“CLAVE”), 1 JTextField (donde se digitará el usuario para ingresar al sistema), 1
JPasswordField (donde se digitará la contraseña para ingresar al sistema), y por último
colocamos 1 JButton (a este le asignamos el texto “INGRESAR”):
 Cómo hacer un Login
Usuario y contraseña fijos sin conexión a Base de datos

Después lo que haremos será darle un nombre a cada componente, ej. :

Campo de texto usuario= txtUsuario

Campo de texto de la clave= jpassClave

Botón de ingreso= btnIngresar

Luego damos doble clic sobre el botón “INGRESAR”, y borramos el comentario que trae
por defecto:
 Cómo hacer un Login
Usuario y contraseña fijos sin conexión a Base de datos
Agrega el siguiente código dentro del método del botón “INGRESAR”:

char clave[]=jpassClave.getPassword();

String clavedef=new String(clave);

if (txtUsuario.getText().equals("Administrador") &&
clavedef.equals("12345")){

this.dispose();

JOptionPane.showMessageDialog(null, "Bienvenido\n"
+ "Has ingresado satisfactoriamente al sistema", "Mensaje de
bienvenida",
JOptionPane.INFORMATION_MESSAGE);

Formulario1 formformulario1 = new Formulario1();

formformulario1.setVisible(true);

}else {

JOptionPane.showMessageDialog(null, "Acceso denegado:\n"

+ "Por favor ingrese un usuario y/o contraseña
correctos", "Acceso denegado",
JOptionPane.ERROR_MESSAGE);

Lo que hacemos en el código es guardar el contenido del JPasswordField en un array tipo

char, y luego convertimos ese array en un String.
 Cómo hacer un Login
Usuario y contraseña fijos sin conexión a Base de datos
Seguidamente realizamos un condicional donde compararemos el contenido de lo que se
haya digitado en la caja de texto de usuario y la clave que hemos convertido a String con
anterioridad; esta comparación se hace con datos fijos (inmodificables por el usuario); en el
caso dado que ambos datos sean correctos, se procederá a cerrar el formulario de acceso y
seguidamente se mostrará un cuadro de diálogo dando la bienvenida al sistema y abriendo
el formulario principal del programa:

Si por el contrario digitamos mal los datos de ingreso, nos aparecerá un cuadro de diálogo,
advirtiéndonos dicha situación:
 Cómo conectar JAVA con una Base de datos de forma básica

Primero que todo, lógicamente debemos de contar ya con una Base de datos
previamente creada (si aún no la tienes o no sabes cómo crearla, puedes ver
nuestro artículo:

Nos ubicaremos en Netbeans IDE, y en nuestro proyecto localizamos la carpeta

“Libraries” (Bibliotecas), la seleccionamos, damos clic derecho sobre la misma
y escogemos la opción “Add JAR/Folder…”:
 Cómo conectar JAVA con una Base de datos de forma básica

Nos saldrá una nueva ventana, lo que tenemos que hacer es buscar a través de
dicha ventana, el archivo “.jar” que descargamos con anterioridad; luego de
ubicarlo lo seleccionamos y damos clic en el botón “Abrir”. Ahora si
expandimos nuestra carpeta Libraries, observaremos que ya contamos con este
archivo en nuestro proyecto:
 Cómo conectar JAVA con una Base de datos de forma básica
Ahora crearemos un nuevo paquete al cual le pondremos por nombre
“Metodos” y dentro de este paquete, crearemos una Clase la cual llamaremos
“ConexionMySQL”:
 Cómo conectar JAVA con una Base de datos de forma básica

Procederemos a pegar el siguiente código dentro de la clase que hemos creado:

public String db = "bdcontactos";

public String url = "jdbc:mysql://localhost/"+db;
public String user = "root";
public String pass = "123";
public Connection Conectar(){

Connection link = null;

try{
Class.forName("org.gjt.mm.mysql.Driver");
link = DriverManager.getConnection(this.url, this.user, this.pass);
}catch(Exception ex){

JOptionPane.showMessageDialog(null, ex);

}
return link;
}
 Cómo conectar JAVA con una Base de datos de forma básica
Nos saldrán algunos errores en el código, lo cual se debe a que necesitamos
importar ciertas librerías, para solucionar esto colocaremos fuera de la clase,
más exactamente después de “package Metodos;” y antes de la línea
“public class ConexionMySQL {“, el siguiente código:

import java.sql.*;
import javax.swing.JOptionPane;

Para mayor claridad y teniendo en cuenta todo lo anterior, nuestro código

quedaría de la siguiente forma:

package Metodos;

import java.sql.*;
import javax.swing.JOptionPane;

public class ConexionMySQL {

public String db = "bdcontactos";

public String url = "jdbc:mysql://localhost/"+db;
public String user = "root";
public String pass = "123";

public Connection Conectar(){

Connection link = null;

try{

Class.forName("org.gjt.mm.mysql.Driver");

link = DriverManager.getConnection(this.url, this.user, this.pass);

}catch(Exception ex){
 Cómo conectar JAVA con una Base de datos de forma básica

JOptionPane.showMessageDialog(null, ex);

return link;

En resumen, lo que hacemos en el código es crear variables que contendrán

valores específicos, como la dirección del servidor, el usuario y la clave para
acceder a la Base de datos, y el nombre de la misma; luego se crea un método
con el cual obtendremos la conexión a nuestra BD; claro está, usando los datos
que almacenamos en las variables y por supuesto el driver y/o la librería que
descargamos. En el caso dado de que tengamos un problema; es decir, que no
nos podamos conectar, se nos mostrará en una ventana, un mensaje donde se
nos informa acerca de esta falla.

Ahora haremos una prueba para verificar que si nos podemos conectar a nuestra
base de datos, para esto nos iremos a nuestro formulario principal y daremos
doble clic sobre un botón que vamos a agregar para hacer la prueba:
 Cómo conectar JAVA con una Base de datos de forma básica
Procedemos a borrar el comentario que hay en el método del botón por defecto:

Pegaremos el siguiente código dentro de dicho método:

ConexionMySQL mysql = new ConexionMySQL();

java.sql.Connection cn= mysql.Conectar();

if(!cn.equals(null)){

JOptionPane.showMessageDialog(null, "Conectado");

try{

cn.close();

}catch(SQLException ex){

System.out.println("Error al desconectar "+ex);

}
 Cómo conectar JAVA con una Base de datos de forma básica
Nos saldrán algunos errores en el código, lo cual se debe a que necesitamos
importar ciertas librerías, para solucionar esto procederemos a importarlas
dando clic en el bombillito (ubicado en la barra de numeración) que sale con
error al lado de nuestro código, y luego seleccionando las librerías necesarias:
 Cómo conectar JAVA con una Base de datos de forma básica

En el código lo que hacemos es instanciar un objeto de la clase

ConexionMySQL; luego implementamos el método “Conectar” y almacenamos
en una variable tipo Connection, la conexión establecida entre nuestra
aplicación y la base de datos; ahora, verificamos a través de un condicional
“if”, si la conexión es exitosa, en caso tal, se nos mostrará una ventana con el
mensaje “Conectado”; luego se procede a desconectar nuestra aplicación de la
base de datos, y en el caso de que haya un error a la hora de realizar la
desconexión, se mostrará un mensaje por consola informándonos del error. Por
último sólo nos resta ejecutar nuestro formulario principal y presionar el botón
que realiza el test de conexión:
 Programar
Cómo conectar JAVA el botón
con una Buscar
Base de datos de forma básica

Una de las grandes ventajas que nos ofrece el uso de un sistema de información
en nuestra empresa y/o negocio, además de almacenar y/o guardar información
en una base de datos, es el poder realizar consultas de todos esos datos
guardados, de una manera rápida y eficaz.
Si bien es cierto, que aún muchas personas son reacias a que en su trabajo
implanten un software para gestionar y manejar ciertos procesos, ellos no
pueden "tapar el sol con una mano", y negar que es mucho más óptimo dar unos
cuantos clics para tener a la mano toda la información que un determinado
cliente u otra persona les solicite, que preferir buscar en una "pila o montaña
de papel" que de verdad resulta muy tedioso y muy pero muy poco óptimo e
insatisfactorio.

Dirígete a tu formulario, y agrega 5 componentes, así:

-1 JLabel (Etiqueta): Le cambiaremos el texto y le colocaremos “Buscar

por:”.

-1 JComboBox (Lista desplegable): Procede a asignar una serie de valores

predeterminados al ComboBox, los cuales equivalen a los nombres de las
columnas de la tabla que agregaremos a nuestro formulario, pero en esta
oportunidad sólo asignaremos 3 de los campos del JTable (“Nombres”,
“Apellidos”, y “Ciudad”); luego, cambiamos el nombre de la variable de dicho
elemento, en este caso le pondremos “cboxFiltro”.
Este componente, cumplirá con la función de ayudarnos a filtrar la búsqueda de
información, realizando las consultas en un determinado campo de nuestra
tabla de la base de datos.

-1 JTextField (Campo de texto): Eliminaremos el texto que trae por defecto;

luego, modificaremos el nombre de la variable de dicho elemento, en este caso
le pondremos “txtValorbusqueda”.
 Programar el botón Buscar

Todo lo que se escriba en este elemento, será lo que se busque en un

determinado campo (de acuerdo a lo seleccionado en el ComboBox) de la tabla
ubicada en la base de datos.

-1 JButton (Botón): Modificamos el texto que trae por defecto y le colocamos

“Buscar”; a continuación, cambiaremos el nombre de la variable de dicho
elemento, en este caso le pondremos “btnBuscar”.

Al presionar este elemento, se ejecutará la consulta de información en la base

de datos.

-1 JTable (Tabla): Configuramos y establecemos el diseño y estructura de

nuestra tabla; en otras palabras, le asignamos un número de columnas con sus
respectivos nombres y/o títulos, eliminamos también todas las filas que esta
traiga por defecto; posteriormente, alteramos el nombre de la variable del
JTable, en este caso le pondremos “tblDatos”. Aquí se mostrarán todos los
registros que coincidan con la búsqueda y/o consulta lanzada desde nuestro
programa:
 Programar el botón Buscar
Ya con nuestro formulario listo, nos ubicaremos en nuestro paquete “Metodos”,
y creamos la Clase “MetodosBD”:

Deberás copiar y pegar las siguientes librerías, para que el código funcione:

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

NOTA: Recuerda pegar dichas librerías 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{...).

Luego, copia y pega el siguiente código, dentro de las llaves de apertura “{” y
de cierre “}” de la Clase “MetodosBD”:

Pool metodospool = new Pool();

DefaultTableModel ModeloTabla;

public void Buscar(String valor, String filtro, JTable tablacontactos){

 Programar el botón Buscar

String [] columnas={"ID","Nombres","Apellidos","Email","Celular",
"Dirección", "Ciudad"};
String [] registro=new String[7];
ModeloTabla=new DefaultTableModel(null,columnas);
String SSQL;
Connection conect = null;

if(filtro.equals("Apellidos")){

SSQL= "SELECT id_contacto, nombres, apellidos, email, celular,

direccion, ciudad "
+ "FROM contacto WHERE apellidos LIKE '%"+valor+"%'";

}else if(filtro.equals("Email")){

SSQL= "SELECT id_contacto, nombres, apellidos, email, celular,

direccion, ciudad "
+ "FROM contacto WHERE email LIKE '%"+valor+"%'";

}else{

SSQL= "SELECT id_contacto, nombres, apellidos, email, celular,

direccion, ciudad "
+ "FROM contacto WHERE celular LIKE '%"+valor+"%'";

try {

conect = metodospool.dataSource.getConnection();
PreparedStatement st = conect.prepareStatement(SSQL);
 Programar el botón Buscar

ResultSet rs = st.executeQuery();

while (rs.next()){

registro[0]=rs.getString("id_contacto");
registro[1]=rs.getString("nombres");
registro[2]=rs.getString("apellidos");
registro[3]=rs.getString("email");
registro[4]=rs.getString("celular");
registro[5]=rs.getString("direccion");
registro[6]=rs.getString("ciudad");

ModeloTabla.addRow(registro);

tablacontactos.setModel(ModeloTabla);

} catch (SQLException e) {

JOptionPane.showMessageDialog(null, e, "Error durante el

procedimiento", JOptionPane.ERROR_MESSAGE);

}finally{

if(conect!=null){

try {

conect.close();
 Programar el botón Buscar

} catch (SQLException ex) {

JOptionPane.showMessageDialog(null, ex, "Error de desconexión",

JOptionPane.ERROR_MESSAGE);

NOTA: Lo que representa este código, es la creación de un método que hemos

llamado “Buscar”; el cual, como su nombre lo indica, es el que nos va a
permitir realizar las consultas en nuestra tabla de la base de datos, para que de
esta manera el usuario del software pueda obtener la información requerida.

Como vemos, este es un método que necesita de otra Clase (Pool), para realizar
la conexión con la base de datos; además, se procede a usar un
objeto “DefaultTableModel”, que nos va a permitir manipular el contenido de
nuestro JTable.

NOTA: Algo muy importante a tener en cuenta de este método, es la parte de

la sentencia SQL que hemos de establecer para realizar nuestra consulta a
la Base de datos.
 Programar el botón Buscar

Teniendo en cuenta todo lo anterior, nuestra Clase “MetodosBD” quedaría de

la siguiente forma:
package Metodos;

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

public class MetodosBD {

Pool metodospool = new Pool();

DefaultTableModel ModeloTabla;

public void Buscar(String valor, String filtro, JTable tablacontactos){

String [] columnas={"ID","Nombres","Apellidos","Email","Celular",
"Dirección", "Ciudad"};
String [] registro=new String[7];
ModeloTabla=new DefaultTableModel(null,columnas);
String SSQL;
Connection conect = null;

if(filtro.equals("Apellidos")){

SSQL= "SELECT id_contacto, nombres, apellidos, email, celular,

direccion, ciudad "
+ "FROM contacto WHERE apellidos LIKE '%"+valor+"%'";
 Programar el botón Buscar

}else if(filtro.equals("Email")){

SSQL= "SELECT id_contacto, nombres, apellidos, email, celular,

direccion, ciudad "
+ "FROM contacto WHERE email LIKE '%"+valor+"%'";

}else{

SSQL= "SELECT id_contacto, nombres, apellidos, email, celular,

direccion, ciudad "
+ "FROM contacto WHERE celular LIKE '%"+valor+"%'";

try {

conect = metodospool.dataSource.getConnection();
PreparedStatement st = conect.prepareStatement(SSQL);
ResultSet rs = st.executeQuery();

while (rs.next()){

registro[0]=rs.getString("id_contacto");
registro[1]=rs.getString("nombres");
registro[2]=rs.getString("apellidos");
registro[3]=rs.getString("email");
registro[4]=rs.getString("celular");
registro[5]=rs.getString("direccion");
registro[6]=rs.getString("ciudad");

ModeloTabla.addRow(registro);
 Programar el botón Buscar

tablacontactos.setModel(ModeloTabla);

} catch (SQLException e) {

JOptionPane.showMessageDialog(null, e, "Error durante el

procedimiento", JOptionPane.ERROR_MESSAGE);

}finally{

if(conect!=null){

try {

conect.close();

} catch (SQLException ex) {

JOptionPane.showMessageDialog(null, ex, "Error de desconexión",

JOptionPane.ERROR_MESSAGE);

}
}

}
 Programar el botón Buscar

Ahora, vamos a dirigirnos nuevamente a nuestro formulario JAVA, y daremos

doble clic (seguidos) sobre nuestro botón “Buscar”, para que de esta manera
accedamos a la parte del código, más exactamente dentro del Evento que se
ejecutará todos los códigos que allí se coloquen (una vez se pulse sobre el
botón “Buscar”):

Borraremos el comentario que está allí por defecto, y colocaremos el siguiente

código:
MetodosBD metodosbd = new MetodosBD();
metodosbd.Buscar(txtValorbusqueda.getText(),
cboxFiltro.getSelectedItem().toString(), tblDatos);

Lo que hacemos es instanciar un objeto de la Clase “MetodosBD” y

posteriormente se procede a llamar al método “Buscar”, pasándole los
respetivos parámetros, los cuales se capturan de los componentes del
formulario en el que nos encontramos, los cuales agregamos al inicio
(JComboBox, JTextField, y JTable).

NOTA: Si lo deseas, la línea de código:

MetodosBD metodosbd = new MetodosBD();

Puedes colocarla afuera (arriba) del método del botón, pues esto es lo más
recomendable, ya que posiblemente necesites usar otros métodos creados en la
Clase “MetodosBD” y por consiguiente ya no tendrás que instanciarla
nuevamente para hacer uso de los mismos, sino que tan sólo con instanciarla
una sola vez, bastará.
 Programar el botón Buscar

Ahora sólo debemos ejecutar nuestro proyecto y/o formulario, diligenciar los
campos con los datos correspondientes y pulsar el botón “Buscar”, de esta
manera se nos mostrarán en la tabla, los registros que coincidan con la consulta
ejecutada:
 Programar el botón Modificar

Si hay algo que debemos tener en cuenta, es que la información, al igual que la
mayoría de las cosas en la vida, está sujeta a cambios y/o modificaciones.

Cuando desarrollamos un programa (software), somos conscientes de que este

no sólo debe guardar y consultar información en una base de datos, sino que
además de esto, hay que brindarle la posibilidad al usuario de nuestra
aplicación, de poder cambiar y/o actualizar los datos previamente guardados;
ya que por ejemplo, una persona registrada en el sistema, dio una dirección de
domicilio, pero más adelante dicho individuo, cambia de residencia, y se hace
necesaria la modificación de este dato, para mantener la integridad de la
información.

Nos ubicaremos en nuestro paquete “Metodos”, y accederemos a la

Clase “MetodosBD” o a la clase donde estés creando los métodos de tu
proyecto:
 Programar el botón Modificar
Deberás copiar y pegar las siguientes librerías, para que el código funcione:

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

NOTA: Recuerda pegar dichas librerías 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{...).

Luego, copia y pega el siguiente código, dentro de las llaves de apertura “{” y
de cierre “}” de la Clase“MetodosBD”:

1.
Pool metodospool = new Pool();
2.
3.
4. public void Modificar(String nombres, String apellidos, String email,
String celular,
5. String direccion, String ciudad, String idcontacto){
6.
7. int confirmar = JOptionPane.showConfirmDialog(null, "¿Desea
modificar los datos actuales?");
8.
9.
10. if(confirmar == JOptionPane.YES_OPTION){
11.
12. Connection conexion = null;
13.
14. try {
15.
16. conexion = metodospool.dataSource.getConnection();
17.
 Programar el botón Modificar

18. String Ssql = "UPDATE contacto SET nombres=?, apellidos=?,

email=?, celular=?, direccion=?, ciudad=? "
19. + "WHERE id_contacto=?";
20.
21. PreparedStatement prest = conexion.prepareStatement(Ssql);
22.
23. prest.setString(1, nombres);
24. prest.setString(2, apellidos);
25. prest.setString(3, email);
26. prest.setString(4, celular);
27. prest.setString(5, direccion);
28. prest.setString(6, ciudad);
29. prest.setString(7, idcontacto);
30.
31. if(prest.executeUpdate() > 0){
32.
33. JOptionPane.showMessageDialog(null, "Los datos han sido
modificados con éxito", "Operación Exitosa",
34. JOptionPane.INFORMATION_MESSAGE);
35.
36. }else{
37.
38. JOptionPane.showMessageDialog(null, "No se ha podido
realizar la actualización de los datos\n"
39. + "Inténtelo nuevamente.", "Error en la
operación",
40. JOptionPane.ERROR_MESSAGE);
41.
42. }
43.
44. } catch (SQLException e) {
45.
 Programar el botón Modificar

46. JOptionPane.showMessageDialog(null, "No se ha podido realizar

la actualización de los datos\n"
47. + "Inténtelo nuevamente.\n"
48. + "Error: "+e, "Error en la operación",
49. JOptionPane.ERROR_MESSAGE);
50.
51. }finally{
52.
53. if(conexion!=null){
54.
55. try {
56.
57. conexion.close();
58.
59. } catch (SQLException e) {
60.
61. JOptionPane.showMessageDialog(null, "Error al intentar
cerrar la conexión."
62. + "Error: "+e, "Error en la operación",
63. JOptionPane.ERROR_MESSAGE);
64.
65. }
66.
67. }
68.
69. }
70.
71.
72. }
73.
74. }
 Programar el botón Modificar
NOTA: Lo que representa este código, es la creación de un método que hemos
llamado“Modificar”; el cual, como su nombre lo indica, es el que nos va a
permitir realizar las modificaciones de los registros que se encuentran en
una tabla de la base de datos, para que de esta manera el usuario del software
pueda corregir y/o actualizar los datos guardados previamente en el sistema.
Como podemos ver, este es un método que necesita de otra Clase (Pool),
para realizar la conexión con la base de datos.

NOTA: Algo muy importante a tener en cuenta de este método, es la parte de

la sentencia SQL que hemos de establecer y/o usar para poder realizar
modificaciones en los registros de la Base de datos.

4. Teniendo en cuenta todo lo anterior, nuestra Clase “MetodosBD” quedaría

de la siguiente forma:

package Metodos;

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

public class MetodosBD {

Pool metodospool = new Pool();

public void Modificar(String nombres, String apellidos, String email, String

celular,
String direccion, String ciudad, String idcontacto){

int confirmar = JOptionPane.showConfirmDialog(null, "¿Desea modificar los

datos actuales?");

if(confirmar == JOptionPane.YES_OPTION){

Connection conexion = null;

 Programar el botón Modificar

try {

conexion = metodospool.dataSource.getConnection();

String Ssql = "UPDATE contacto SET nombres=?, apellidos=?, email=?,

celular=?, direccion=?, ciudad=? "
+ "WHERE id_contacto=?";

PreparedStatement prest = conexion.prepareStatement(Ssql);

prest.setString(1, nombres);
prest.setString(2, apellidos);
prest.setString(3, email);
prest.setString(4, celular);
prest.setString(5, direccion);
prest.setString(6, ciudad);
prest.setString(7, idcontacto);

if(prest.executeUpdate() > 0){

JOptionPane.showMessageDialog(null, "Los datos han sido

modificados con éxito", "Operación Exitosa",
JOptionPane.INFORMATION_MESSAGE);

}else{

JOptionPane.showMessageDialog(null, "No se ha podido realizar la

actualización de los datos\n"
+ "Inténtelo nuevamente.", "Error en la
operación",
JOptionPane.ERROR_MESSAGE);
 Programar el botón Modificar

} catch (SQLException e) {

JOptionPane.showMessageDialog(null, "No se ha podido realizar la

actualización de los datos\n"
+ "Inténtelo nuevamente.\n"
+ "Error: "+e, "Error en la operación",
JOptionPane.ERROR_MESSAGE);

}finally{

if(conexion!=null){

try {

conexion.close();

} catch (SQLException e) {

JOptionPane.showMessageDialog(null, "Error al intentar cerrar la

conexión."
+ "Error: "+e, "Error en la operación",
JOptionPane.ERROR_MESSAGE);

}
 Programar el botón Modificar

}
5. Ahora, vamos a dirigirnos nuevamente a nuestro formulario JAVA, y
daremos doble clic (seguidos) sobre nuestro botón “Modificar”, para que de
esta manera accedamos a la parte del código, más exactamente dentro del
Evento que ejecutará todas las líneas de código que allí se coloquen (una vez se
pulse sobre el botón):

6. Borraremos el comentario que está allí por defecto, y colocaremos el

siguiente código:

MetodosBD metodosbd = new MetodosBD();

if(idcontacto.isEmpty()){

JOptionPane.showMessageDialog(null, "No hay datos para modificar.\n"

+ "Por favor, seleccione un registro de la tabla.",
"Error en la operación",
JOptionPane.ERROR_MESSAGE);

}else{

metodosbd.Modificar(txtNombrecontacto.getText(),
txtApellidoscontacto.getText(), txtEmail.getText(),
txtCelular.getText(), txtDireccion.getText(),
cboxCiudad.getSelectedItem().toString(),
idcontacto);

}
 Programar el botón Modificar
Lo que hacemos es instanciar un objeto de la Clase “MetodosBD”, al cual
hemos llamado con el mismo nombre; es decir, “metodosbd”.

Emplearemos un condicional “if-else”. La condición que usamos, es que la

variable “idcontacto” (tipo String) no este vacía, dicha variable debe contener
el código o id que identifica de forma única al registro de la tabla que
queremos modificar; en otras palabras, el contenido de “idcontacto”, es la
llave primaria de uno de los registros de la tabla que se encuentra en nuestra
base de datos. Por lo cual, lógicamente, de forma anterior se ha debido realizar
la consulta y/o búsqueda de datos desde el formulario que estamos usando, y
mostrar dichos datos en los respectivos campos del mismo.

NOTA: La línea de código:

MetodosBD metodosbd = new MetodosBD();

Puedes colocarla afuera del método del botón (arriba, después de la llave de
apertura de la Clase), pues esto es lo más recomendable, ya que posiblemente
necesites usar otros métodos creados en la Clase “MetodosBD”; y por
consiguiente, ya no tendrás que instanciarla nuevamente para hacer uso de los
mismos, sino que tan sólo con instanciarla una sola vez, bastará.

Para obtener una explicación detallada línea por línea, del código que nos
permitirá actualizar la información de los registros de nuestra base de
datos.

7. Ahora sólo debemos ejecutar nuestro proyecto y/o formulario, consultar el

registro que hemos de actualizar, y realizar los cambios en los campos
respectivos; a continuación, daremos clic en el botón “Modificar” y
pulsaremos en el botón "Sí", y para finalizar daremos clic en el
botón "Aceptar" del cuadro de diálogo que nos aparece:

Cuadro de dialogo