CONTROL JTABLE CON BASE DE DATOS

1. CONTENIDO
1.1. Definición

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.

Un JTable es un componente visual de java que nos permite dibujar una tabla, de forma que en cada fila/columna de la tabla podamos poner el dato que queramos; un nombre, un apellido, una edad, un número, etc, etc.

Como muchos componentes de java, se ha seguido una separación modelo-vista. La vista es el componente visual que vemos en pantalla, el modelo es una clase que contiene los datos que luego se verán en pantalla. El modelo de datos únicamente contiene los datos, no sabe nada de quién va a visualizar los datos ni cómo. La forma más rápida y sencilla

Aparte de usar otros constructores que hay en JTable, una de las formas más rápidas y sencillas de utilizar un JTable teniendo toda su funcionalidad, consiste en instanciar como modelo de datos un DefaultTableModel y luego un JTable, pasándole el modelo en el constructor. El código quedaría:

1.2. ObjetodeControlJTable

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.

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.

1.2. Propiedades

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.

RemoveRow(): Elimina del modelo según la posición de la fila indicada.

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.

¿EDITABLE O NO?
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.

¿Y LA INFORMACIÓN, Y LAS 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.

1.3. Ejemplos
1.3.1. Ejemplo 01

       
import java.sql.*;
/**
 * @web http://www.jc-mouse.net
 * @author Mouse
 */
public class database {
 /* DATOS PARA LA CONEXION */
  private String bd = "";//BASE DE DATOS
  private String login = "root"; //USUARIO
  private String password = ""; //CONTRASEÑA
  private String url = "jdbc:mysql://localhost/"+bd;
  private Connection conn = null;

  /* Constructor de clase: Se conecta a la base de datos
 */
   public database(){
      try{
         //obtenemos el driver de para mysql
         Class.forName("com.mysql.jdbc.Driver");
         //obtenemos la conexión
         conn = DriverManager.getConnection(url,login,password);
         if (conn!=null){
            System.out.println("OK base de datos "+bd+" listo");
         }
      }catch(SQLException e){
         System.out.println(e);
      }catch(ClassNotFoundException e){
         System.out.println(e);
      }
    }

    public Connection getConnection()
    {
        return this.conn;
    }
/* Realiza una consulta a la base de datos, retorna un Object[][] con los
 * datos de la tabla persona
 */
    public Object[][] Select_Persona()
    {
     int registros = 0;
      String consulta = "Select p_id,p_nombre,p_apellido,p_edad FROM persona ";
      String consulta2 = "Select count(*) as total from persona ";
      //obtenemos la cantidad de registros existentes en la tabla
      try{
         PreparedStatement pstm = conn.prepareStatement( consulta2 );
         ResultSet res = pstm.executeQuery();
         res.next();
         registros = res.getInt("total");
         res.close();
      }catch(SQLException e){
         System.out.println(e);
      }
    //se crea una matriz con tantas filas y columnas que necesite
    Object[][] data = new String[registros][4];
    //realizamos la consulta sql y llenamos los datos en la matriz "Object"
      try{
         PreparedStatement pstm = conn.prepareStatement(consulta);
         ResultSet res = pstm.executeQuery();
         int i = 0;
         while(res.next()){
            data[i][0] = res.getString( "p_id" );
            data[i][1] = res.getString( "p_nombre" );
            data[i][2] = res.getString( "p_apellido" );
            data[i][3] = res.getString( "p_edad" );
            i++;
         }
         res.close();
          }catch(SQLException e){
               System.out.println(e);
        }
    return data;
    }

/* Ejecuta la actualizacion de la tabla persona dado los valores de actualizacion
 * y el ID del registro a afectar
 */
    public boolean update(String valores, String id)
    {
        boolean res = false;
        String q = " UPDATE persona SET " + valores + " WHERE p_id= " + id;
        try {
            PreparedStatement pstm = conn.prepareStatement(q);
            pstm.execute();
            pstm.close();
            res=true;
         }catch(SQLException e){
            System.out.println(e);
        }
        return res;
    }

}

       

1.3.2. Ejemplo 02

       

import java.awt.Component;
import javax.swing.AbstractCellEditor;
import javax.swing.JComponent;
import javax.swing.JOptionPane;
import javax.swing.JTable;
import javax.swing.JTextField;
import javax.swing.table.TableCellEditor;
/**
 * @web http://www.jc-mouse.net
 * @author Mouse
 */
public class MyTableCellEditor extends AbstractCellEditor implements TableCellEditor{

    private database db;
    private String OldValue=""; //Valor antiguo de la celda
    private String NewValue=""; //valor nuevo de la celda
    private String NameColum="";//nombre de la columna
    private String ID="";// Llave del registro
    private JComponent component = new JTextField();

    public MyTableCellEditor(database db, String NameColumn)
    {
            this.db = db;
            this.NameColum = NameColumn;
    }

    public Object getCellEditorValue() {
        return ((JTextField)component).getText();
    }

    public Component getTableCellEditorComponent(JTable table, Object value, boolean isSelected, int row, int column) {
        OldValue = value.toString();//Toma valor de celda antes de cualquier modificación
        ID = table.getValueAt(row,0).toString();//obtiene el ID unico del registro
        ((JTextField)component).setText(value.toString());//coloca valor de la celda al JTextField
        return component;
    }

    @Override
    public boolean stopCellEditing() {
        NewValue = (String)getCellEditorValue();//Captura nuevo valor de la celda
        //Compara valores, si no son iguales, debe actualizar registro
        if( !NewValue.equals(OldValue))
        {   //Realiza la actualizacion
            if( !db.update( NameColum+"='"+NewValue+"' ", ID ) )
            {   //Si existe algun error al actualizar, escribe viejo valor en la celda
                JOptionPane.showMessageDialog(null,"Error: No se puede actualizar");
                ((JTextField)component).setText(OldValue);
            }
        }
        return super.stopCellEditing();
    }
}
       

1.3.3. Ejemplo 03

       

public interfaz() {
        initComponents();
        this.setTitle("JTable editable * http://www.jc-mouse.net/");

        Actualizar_Tabla();
        //oculta columna ID
        jTable1.getColumnModel().getColumn(0).setMaxWidth(0);
        jTable1.getColumnModel().getColumn(0).setMinWidth(0);
        jTable1.getTableHeader().getColumnModel().getColumn(0).setMaxWidth(0);
        jTable1.getTableHeader().getColumnModel().getColumn(0).setMinWidth(0);
        //editor de caldas
        jTable1.getColumnModel().getColumn( 1 ).setCellEditor(new MyTableCellEditor(db,"p_nombre"));//Columna Nombre
        jTable1.getColumnModel().getColumn( 2 ).setCellEditor(new MyTableCellEditor(db,"p_apellido"));//Columna Apellido
        jTable1.getColumnModel().getColumn( 3 ).setCellEditor(new MyTableCellEditor(db,"p_edad"));//Columna Edad
    }
       

1.3.4. Ejemplo 04

       

package beastieux.gui;
 
import javax.sql.rowset.CachedRowSet;
import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.table.DefaultTableModel;
 
/**
 *
 * @author beastieux
 */
public class Ejm13_LlenarJTableDesdeDataBase extends JFrame{
 
    DefaultTableModel dtmEjemplo;
    JTable tblEjemplo;
    JScrollPane scpEjemplo;
    public Ejm13_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);
    }
 
}
       

1.3.5. Ejemplo 05

       

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

1.3.5. Ejemplo 05

       
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                  

}



       

1.3.6. Ejemplo 06

class MiModelo implements TableModel
{
    public void setValueAt (Object dato, int fila, int columna) {
         // Obtenemos la persona de la fila indicada 
        Persona aux = (Persona)datos.get (fila);       
        switch (columna) {
           // Nos pasan el nombre. 
           case 0:                                                      
               aux.nombre = (String)dato;
               break;
           // Nos pasan el apellido. 
           case 1:                                                       
               aux.apellido = (String)dato;
               break;
           // Nos pasan la edad. 
           case 2:                                                       
               aux.edad = ((Integer)dato).intValue();
               break;
        }

        // Aquí hay que avisar a los sucriptores del cambio. 
        // Ver unpoco más abajo cómo.
    }

    public Object getValueAt (int fila, int columna) {
        // Obtenemos la persona de la fila indicada 
        Persona aux = (Persona)datos.get (fila);          
        switch (columna) {
            // Nos piden el nombre 
            case 0:                                                        
                return aux.nombre;
                break;
            // Nos piden el apellido 
            case 1:                                                         
                return aux.apellido;
                break;
            // Nos piden la edad. 
            case 2:                                                        
                return new Integer (aux.edad);
                break;
         }
         return null;
    }

    private LinkedList datos = new LinkedList();
}
       

2. RESUMEN

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; un JTable es un componente visual de Java que nos permite dibujar una tabla, de forma que en cada fila y columna de la tabla podamos poner el dato que queramos; un nombre, un apellido, una edad, un número, etc.

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 tú puedes poner ciertos parámetros dentro de un TableModel y así no tener que determinarlos siempre.

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.

La clase AbstractTableModel es la que implementa directamente a la interfaceTableModel, 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.

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; A JTable is a visual component of Java that allows us to draw a table, so that in each row / column of the table we can put the data we want; A name, a surname, an age, a number, etc.

The Jtable class controls how the data is presented, with TableModel controlling the data themselves. To create a Jtable, you will have to create a TableModel before, normally. TableModel what it does is to predetermine certain characteristics for the Jtable is that you can put certain parameters inside a TableModel and thus not have to always determine them.

Table models are objects that implement the TableModel interface; Through them it is possible to customize much more and better the behavior of the JTable components, allowing to use their potential to the maximum.

The AbstractTableModel class is the one that implements directly to the interfaceTableModel, although it is this class that is recommended to extend to use it as a table model, there is a default table model that greatly facilitates working with tables. This default model is the DefaultTableModel class.

4. RECOMENDACIONES

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

• El control Jtable es muy importante ya 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.

• Debemos tener en cuenta que para la construcción de la tabla se tienen que tener de antemano los datos que queremos que contenga la tabla ya sea en un array o en un vector, lo que le resta flexibilidad al llenado de la tabla; ya que quizás en un momento dado, sería mucho más práctico y rápido, colocar directamente los datos en la tabla y no tener que colocarlos antes en un array o vector.

5. CONCLUSIONES

• Este control Jtable nos facilita para construir tablas de una manera fácil y sencilla, también nos permite ordenar los datos en la tabla, etc.

• Para crear una tabla se necesita importar la librería javax.swing.table; otro requerimiento que va a tener la tabla es: DefaultTableModel modelo=new DefaultTableModel(); estos son datos indispensables al momento de elaborar o construir una tabla
• El JTable tiene muchas ventajas, es más eficaz crear una tabla swing personalizada y reutilizar está en cada proyecto, si deseas realizar un cambio en la interfaz, solo debes modificar el swing una sola vez.

6. APRECIACIÓN DEL EQUIPO

En esta oportunidad tratamos sobre un tema muy substancial en el mundo de la programación CONTROL JTABLE CON BASE DE DATOS, digo sustancial porque el Jtable nos permite perpetrar numerosas tareas una de ellas visualizar información en una tabla.

En nuestra opinión si queremos elaborar consultas de una base de datos utilizando el jTable que cumpla con todos los requerimientos del usuario, es necesario saber  más sobre las funcionalidades, propiedades y métodos de un Jtable en otras palabras conocer más la teoría.

Para eso hemos desarrollado este block, porque contiene estos puntos indispensables que nos ayudaran a utilizar los controladores de un Jtable de manera correcta. Cabe mencionar que también desarrollamos múltiples ejemplos que contienen la mayoría de las propiedades y métodos de un Jtable es necesario ponerlo en práctica estos ejemplos ya que con la práctica se aprende mejor.
Para nosotros fue muy importante aprender sobre este tema aunque ya aviamos visto algunas propiedades y métodos en un jTable en práctica, pero nos dimos cuenta gracias a la investigación más amplia de este tema que estábamos tomando por alto algunos puntos importantes, especialmente algunos métodos de un jTable.

7. GLOSARIO DE TÉRMINOS

JTABLE: es un componente visual de Java que nos permite dibujar una tabla, de forma que en cada fila/columna de la tabla podamos poner el dato que queramos; un nombre, un apellido, una edad, un número, etc

DEFAULTTABLEMODEL Esta clase permite construir el modelo para el objeto Table

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.

DEFAULTTABLEMODEL:

Es un modelo genérico y puede no ser suficiente (o al menos, incómodo de usar) para nuestros propósitos. modelo.setValueAt (fila, columna, edad); y algo parecido para obtener o borrar una persona dentro del modelo. Por ello, a veces esmás cómodo implementar nuestros propios modelos de tabla.

PROTECTED COMPONENT EDITORCOMP: El componente que procesa la edición

PROTECTED BOOLEAN SHOWVERTICALLLINES:

 Las líneas verticales se dibujan entre las celdas cuando el campo está en true

PROTECTD JTABLEHEADER TABLEHEADER: El JTableHeader que funciona con la tabla

Interfaz:Conexión o frontera común entre dos aparatos o sistemas independientes.

CONEXIÓN, FÍSICA O LÓGICA, entre una computadora y el usuario, undispositivo periférico o un enlace de comunicaciones.

GETROWCOUNT(): Devuelve el número de filas en la tabla.

8. LINKOGRAFÍA
http://www.jc-mouse.net/java/jtable-editable-con-base-de-datos

https://beastieux.com/2011/01/20/codigo-java-llenar-un-jtable-desde-una-base-de-datos/

http://www.chuidiang.org/java/tablas/tablamodelo/tablamodelo.php

http://yohanamoreno.blogspot.pe/2008/04/jtable.html

http://www.tutorial-es.com/java-swing-rellenar-jtable-de-base-de-datos/

http://codejavu.blogspot.pe/2017/04/como-llenar-jtable-desde-la-base-de.html

http://www.programandoconcafe.com/2010/11/java-llenar-un-jtable-con-resultset.html

http://soloprogramacionjava.blogspot.pe/2010/11/llenar-un-jtable-con-una-base-de-datos.html

DIAPOSITIVA

Control de-jtable from KELION ENDE TADEO SANTOS