1.
CONTENIDO
CONTROL JTABLE CON BASE DE DATOS
Jtable
es una clase que me permite organizar una determinada información en tabla,
esta difiere de una base de datos normal porque al utilizar Jtable tu puedes
visualizar esta tabla, brindándole a el usuario organización de información,
oportunidades de editar y cambiar el tamaño de las columnas entre otras.
Como
programadores, sabemos muy bien que la presentación de datos tabulados es una de
las tareas más comunes que se presentan al momento de crear interfaces
gráficas; desde la simple tabla que permite únicamente mostrar el resultado de
una consulta, hasta las que permiten editar directamente el contenido de cada
celda, ordenar las columnas, personalizar su apariencia, etc. Todas las tareas
antes descritas, y muchas otras, son posibles de realizar utilizando la clase
JTable; por supuesto, mientras más complejo sea el requerimiento a cubrir, se
requerirá en igual medida utilizar más métodos o recursos de la clase.
Los modelos de tabla son objetos que
implementan la interface TableModel;
a través de
ellos
es posible personalizar mucho más y mejor el comportamiento de los componentes
Jtable,
permitiendo utilizar al máximo sus potencialidades.
El
siguiente gráfico intenta mostrar como cada componente JTable obtiene siempre
sus
datos
desde un modelo de tabla.
INICIOS DE
JTABLE
En
principio se creo la clase Jtable para constituir un interfaz ligado a bases de
datos a través de "Java Database Connectivity" (JDBC), y así evita la
complejidad que existía par el manejo de datos, dando así al programador mucha
mas facilidad a la hora de trabajar con este tipo de información.
Jtable le da al programador muchas facilidades, pues este posee varias características que permiten hacer desde tablas con información compleja y muy estructurada hasta tablas con información sencilla y "básica".
Jtable le da al programador muchas facilidades, pues este posee varias características que permiten hacer desde tablas con información compleja y muy estructurada hasta tablas con información sencilla y "básica".
INFORMACIÓN Y COLUMNAS
Jtable
te brinda muchas facilidades para poder crear una table, y así mismo de
llenarla con la información que desees ( números, letras etc...) por lo que
sencillamente dentro de una tabla esta automáticamente a través de la
información debidamente separada - por ""(comillas) o por , (coma) -
es capaz de contabilizarlas y al mismo tiempo llenarla con la información que
se le dio; es decir el programador solo se debe encargar de poner los títulos
de las tablas y así mismo de escribir la información en el mismo orden en que
desee que salga de acuerdo con los títulos y Jtable se encargara
automáticamente de colocar la
información donde se le indico.
PROPIEDADES
Propiedad
más usada:
●
Model: Permite definir el número de columnas y filas del objeto como también
las
expresiones
que irán en las columnas.
Métodos
más usados:
●
addColumn(): Añade la columna al final de la matriz de columnas.
setModel():
Asigna el modelo de datos al objeto JTable.
GetRowCount():
Devuelve el número de filas en la tabla.
DefaultTableModel
Esta
clase permite construir el modelo para el objeto Table. Los métodos más
utilizados
son:
●
addColumn(): Añade una columna al modelo.
●
AddRow(): Añade una fila al final del modelo.
●
getColumnCount(): Devuelve el número de columnas en esta tabla de datos.
●
getRowCount(): Devuelve el número de filas en esta tabla de datos.
●
getValueAt(): Devuelve un
valor de atributo para
la celda en
la posición row,
column.
●
insertRow(): Inserta una fila en el modelo.
TABLE MODEL
La
clase Jtable controla como se presentan los datos, siendo el TableModel quien
controla los datos sí mismos. para crear una Jtable habrá pues que crear un
TableModel antes, normalmente. TableModel lo que hace es predeterminar ciertas
características para el Jtable es decir que tu puedes poner ciertos parámetros
dentro de un TableModel y así no tener que determinarlos siempre. TableModel es
un programa que guarda los datos de la tabla para si mismo, es decir, puede
tener la información de la tabla pero estos datos son los visualizados por el
computador, es decir, para visualizar una tabla el TABLEMODEL puede tener la
información pero sin el Jtable no se puede visualizar para el usuario.
La
clase AbstractTableModel es la que implementa directamente a la interface
TableModel,
aunque es esta clase la que se recomienda extender para utilizarla como
modelo
de tabla, existe un modelo de tabla predeterminado que
facilita mucho el trabajo
con
tablas. Este modelo predeterminado es la clase DefaultTableModel.
JTable
es un componente swing java que nos permite mostrar datos en una tabla de una
base de datos, sin embargo a diferencia de otros componentes similares de otros
lenguajes de programación (Delphi por ejemplo), java no nos permite gestionar
directamente los datos. Es eso lo que haremos hoy, construir un JTable
editable, más propiamente, este JTable nos permitirá actualizar datos de una
JTable directamente con la base de datos.
JTABLE EDITABLE
Jtable
tiene una característica muy llamativa, este permite que el programador pueda
decirdir que se edita y que no, sin embargo si el programador dentro de su
programa o de su TABLEMODEL no tiene determinado este aspecto, Jtable
automáticamente hace editable las celdas dentro de la tabla. Existen varias
maneras de hacer editable o no las celdas dentro de la tabla, para ver estos
comandos tu te puedes dirigir a Dentro de las celdas encontradas en una tabla
se puede permitir al usuario editar o no editar según lo desee el programador,
esta propiedad se puede arreglar desde el table model o directamente y/o desde
el programa. Jtable tiene la propiedad de dejar editable las celdas si no
encuentra nada que hable de esto.
EJEMPLOS:
1.
public class Ejm1_LlenarJTableDesdeDataBase extends JFrame{
DefaultTableModel dtmEjemplo;
JTable tblEjemplo;
JScrollPane scpEjemplo;
public Ejm1_LlenarJTableDesdeDataBase()
{
tblEjemplo = new JTable();
scpEjemplo= new JScrollPane();
//Llenamos el modelo
dtmEjemplo = new DefaultTableModel(null,getColumnas());
setFilas();
tblEjemplo.setModel(dtmEjemplo);
scpEjemplo.add(tblEjemplo);
this.add(scpEjemplo);
this.setSize(500, 200);
scpEjemplo.setViewportView(tblEjemplo);
setDefaultCloseOperation(javax.swing.WindowConstants.DISPOSE_ON_CLOSE); }
//Encabezados de la tabla
private String[] getColumnas()
{
String columna[]=new String[]{"Columna1","Columna2","Columna3"};
return columna;
}
private void setFilas()
{
//Conectar a PostgreSQL\\
Ejm12_1_ConectarPostgreSQL cnndb = new Ejm12_1_ConectarPostgreSQL();
CachedRowSet crs = cnndb.Function("SELECT deptno, dname, loc FROM dept");
Object datos[]=new Object[3]; //Numero de columnas de la tabla
try {
while (crs.next()) {
for (int i = 0; i < 3; i++) {
datos[i] = crs.getObject(i + 1);
}
dtmEjemplo.addRow(datos);
}
crs.close();
} catch (Exception e) {
}
}
public static void main(String args[]) {
Ejm13_LlenarJTableDesdeDataBase obj1 = new Ejm13_LlenarJTableDesdeDataBase();
obj1.setVisible(true);
}
}
2.
package dba;
import java.sql.Connection;
import java.sql.DriverManager;
import javax.swing.JOptionPane;
public class Mysql {
private static String db="unalm";
private static String user="root";
private static String
pass="aquitupassword";
private static String
url="jdbc:mysql://localhost:3306/"+db;
private static Connection Conn;
public static Connection getConnection(){
try{
Class.forName("com.mysql.jdbc.Driver");
Conn=DriverManager.getConnection(url, user, pass);
}catch(Exception e){
JOptionPane.showMessageDialog(null,"Error"+e.getMessage());
}
return Conn;
}
}
package form;
import javax.swing.table.DefaultTableModel;
import dba.Mysql;
import java.sql.*;
import javax.swing.JOptionPane;
public class Cliente extends javax.swing.JFrame {
DefaultTableModel
model;
Connection
Conn;
Statement
sent;
public Cliente() {
initComponents();
Conn=Mysql.getConnection();
Deshabilitar();
Llenar();
}
void
Deshabilitar(){
txtNombre.setEditable(false);
txtDireccion.setEditable(false);
txtCorreo.setEditable(false);
txtTelefono.setEditable(false);
}
void
Limpiar(){
txtNombre.setText("");
txtDireccion.setText("");
txtCorreo.setText("");
txtTelefono.setText("");
}
void
Habilitar(){
txtNombre.setEditable(true);
txtCorreo.setEditable(true);
txtDireccion.setEditable(true);
txtTelefono.setEditable(true);
txtNombre.requestFocus();
}
void Llenar(){
try{
Conn=Mysql.getConnection();
String [] titulos
={"Id","Nombre","Direccion",
"Telefono", "Correo"};
String sql="select * from contactos";
model=new DefaultTableModel(null,
titulos);
sent=Conn.createStatement();
ResultSet rs=sent.executeQuery(sql);
String
fila []= new String [5];
while(rs.next()){
fila [0]=rs.getString("id");
fila [1]=rs.getString("nombre");
fila [2]=rs.getString("direccion");
fila [3]=rs.getString("telefono");
fila [4]=rs.getString("correo");
model.addRow(fila);
}
jTable1.setModel(model);
}catch(Exception e){
e.printStackTrace();
}
}
private void
btnEliminarActionPerformed(java.awt.event.ActionEvent evt)
{
try{
int
fila=jTable1.getSelectedRow();
String sql="delete from
contactos where id="+jTable1.getValueAt(fila,0);
sent=Conn.createStatement();
int n=sent.executeUpdate(sql);
if(n>0){
Llenar();
JOptionPane.showMessageDialog(null, "datos eliminados");
Limpiar();
}
}catch(Exception e){
JOptionPane.showMessageDialog(null,
"error"+e.getMessage());
}
}
private void
btnGuardarActionPerformed(java.awt.event.ActionEvent evt)
{
try{
String sql="insert into contactos ( direccion ,nombre, telefono, correo)"
+
"Values (?,?,?,?) ";
PreparedStatement ps=Conn.prepareCall(sql);
ps.setString(1, txtNombre.getText());
ps.setString(2, txtDireccion.getText());
ps.setString(3, txtTelefono.getText());
ps.setString(4, txtCorreo.getText());
int n=ps.executeUpdate();
if(n>0)
JOptionPane.showMessageDialog(null, "datos
guardados");
}catch(Exception e){
JOptionPane.showMessageDialog(null, "error"+ e.getMessage());
}
Llenar();
Limpiar();
}
private void
btnNuevoActionPerformed(java.awt.event.ActionEvent evt)
{
Limpiar();
Habilitar();
// TODO
add your handling code here:
}
private void
jTable1MouseClicked(java.awt.event.MouseEvent evt)
{
if(evt.getButton()==1){
try{
Habilitar();
int
fila=jTable1.getSelectedRow();
String
sql="select * from contactos where id="+jTable1.getValueAt(fila,0);
sent=Conn.createStatement();
ResultSet
rs=sent.executeQuery(sql);
rs.next();
txtNombre.setText(rs.getString("nombre"));
txtDireccion.setText(rs.getString("direccion"));
txtTelefono.setText(rs.getString("telefono"));
txtCorreo.setText(rs.getString("correo"));
}catch(Exception e){
e.printStackTrace();
}
}
}
private void
btnModificarActionPerformed(java.awt.event.ActionEvent evt)
{
try{
String sql="Update contactos set nombre=?, direccion=?, telefono=?,
correo=?"+
"where id=?";
int
fila=jTable1.getSelectedRow();
String
dao=(String)jTable1.getValueAt(fila,0);
PreparedStatement
ps=Conn.prepareCall(sql);
ps.setString(1,txtNombre.getText());
ps.setString(2,txtDireccion.getText());
ps.setString(3,txtTelefono.getText());
ps.setString(4,txtCorreo.getText());//valor de campos de texto a pasar a
//BasedeDatos
ps.setString(5,dao);//la llamada sql se muestra en la tabla
int n=ps.executeUpdate();
if(n>0){
Limpiar();
Llenar();
JOptionPane.showMessageDialog(null, "datos modificados");
}
}catch (Exception e){
JOptionPane.showMessageDialog(null, "error"+ e.getMessage());
}
// TODO
add your handling code here:
}
private void
btnCerrarActionPerformed(java.awt.event.ActionEvent evt)
{
System.exit(0);
// TODO
add your handling code here:
}
public static void main(String args[]) {
java.awt.EventQueue.invokeLater(new Runnable() {
public void run() {
new Cliente().setVisible(true);
}
});
}
private javax.swing.JButton btnCerrar;
private javax.swing.JButton
btnEliminar;
private javax.swing.JButton
btnGuardar;
private javax.swing.JButton
btnModificar;
private javax.swing.JButton
btnNuevo;
private javax.swing.JLabel
jLabel1;
private javax.swing.JLabel
jLabel2;
private javax.swing.JLabel
jLabel3;
private javax.swing.JLabel
jLabel4;
private javax.swing.JPanel
jPanel1;
private javax.swing.JScrollPane
jScrollPane1;
private javax.swing.JTable
jTable1;
private javax.swing.JTextField
txtCorreo;
private javax.swing.JTextField
txtDireccion;
private javax.swing.JTextField
txtNombre;
private javax.swing.JTextField
txtTelefono;
// End of
variables
declaration
}
2.
RESUMEN
El
control Jtable es una clase que me permite organizar una determinada
información en tabla, esta difiere de una base de datos normal porque al
utilizar Jtable tu puedes visualizar esta tabla, brindándole al usuario organización de información, oportunidades
de editar y cambiar el tamaño de las columna entre otras.
Los modelos
de tabla son objetos que implementan la interface TableModel; a través de ellos es posible personalizar
mucho más y mejor el comportamiento de los componente Jtable, permitiendo utilizar
al máximo sus potencialidades.
3.
SUMMARY
Jtable is a class that allows me to organize a certain
information in a table, this differs from a normal database because when using
Jtable you can visualize this table, giving the user information organization,
opportunities to edit and resize the columns among other.
Table models are objects that implement the TableModel
interface; through
They are possible to personalize much more and better the
behavior of the components Jtable, allowing you to make the most of your
potential.
4. RECOMENDACIONES
Es
necesario conocer que la implementación del código debe estar bien estructurado
para evitar algunas redundancias innecesarias.
Conocer
las especificaciones que nos presenta cuando estructuramos las tablas de cada
base de datos, realizando nuestro trabajo más práctico y sencillo.
5.
CONCLUSIONES
JTable es un componente swing java que nos permite mostrar
datos en una tabla de una base de datos, sin embargo, a diferencia de otros
componentes similares de otros lenguajes de programación (Delphi por ejemplo),
java no nos permite gestionar directamente los datos. Es eso lo que haremos
hoy, construir un JTable editable, más propiamente, este JTable nos permitirá actualizar
datos de una JTable directamente con la base de datos
5. APRECIACIÓN DEL EQUIPO
Jtable le da al programador muchas
facilidades, pues este posee varias características que permiten hacer desde
tablas con información compleja y muy estructurada hasta tablas con información
sencilla y "básica".
Jtable te brinda muchas
facilidades para poder crear una table, y así mismo de llenarla con la
información que desees ( números, letras etc...) por lo que sencillamente
dentro de una tabla esta automáticamente a través de la información debidamente
separada - por ""(comillas) o por , (coma) - es capaz de
contabilizarlas y al mismo tiempo llenarla con la información que se le dio; es
decir el programador solo se debe encargar de poner los títulos de las tablas y
así mismo de escribir la información en el mismo orden en que desee que salga
de acuerdo con los títulos y Jtable se encargara automáticamente de colocar la
información donde se le indico.
7.
GLOSARIO
DE
Interfaz:
Se
utiliza para nombrar a la conexión funcional entre dos sistemas, dispositivos o
componentes de cualquier tipo, que proporciona una comunicación de distintos
niveles permitiendo el intercambio de información. Su plural es interfaces
METODO: un método es una subrutina cuyo código es definido en
una clase y puede pertenecer tanto a una clase, como es el caso de
los métodos de clase o estáticos,
como a un objeto, como es el caso de los métodos de instancia. Análogamente a los procedimientos
en lenguajes imperativos, un método consiste generalmente de una serie de
sentencias para llevar a cabo una acción
OBJETO es una unidad
dentro de un programa de computadora que consta de un estado y de un
comportamiento, que a su vez constan respectivamente de datos almacenados y de
tareas realizables durante el tiempo de ejecución
ATRIBUTO: es una
especificación que define una propiedad de un objeto, elemento o archivo.
También puede referirse o establecer el valor específico para
una instancia determinada de los mismos.
8.
LINKOGRAFIA
Aqui les dejo el link de las diapositivas
