Las tablas en Swing son importantes y poderosas, en pricipio se crearon para construir una interfaz ligada a base de datos a traves del Java Database Connectivity (JDBC) y así evitar la complejidad inherente al manejo de los datos, proporcionando mucha flexibilidad al programador.[1].
Que es JDBC? : La colectividad de la base de datos de Java (JDBC , Java Database Connectivity) es un marco de programación para los desarrolladores de Java que escriben los programas que tienen acceso a la información guardada en bases de datos, hojas de calculo, y archivos "planos". JDBC se utiliza comúnmente para conectar un programa del usuario con una base de datos por “detrás de la escena”, sin importar qué software de administración o manejo de base de datos se utilice para controlarlo.[2].
La JTable controla como se presentan los datos, siendo el TableModel quien controla los datos en si mismos. Para crear una JTable habria que crear pues, previamente, un TableModel. Se puede implementar, para ello, la interfaz TabelModel.[1]
La interfaz TableModel: define una serie de metodos para acceder a los datos contenidos en una determinada posición en la tabla y tambien para asignar valores a la tabla. A continuacion se muestran algunos de los metodos que ofrece esta interfaz (consultad la ayuda para ver la lista completa)
// Para ob t ene r e l n´umero de columnas que posee l a t a b l a :
p u b l i c i n t getColumnCount ( )
// Para obtener el numero de filas que posee la tabla :
public int getRowCount ( )
// Para obtener el valor en una determinada celda de la tabla :
public Object getValueAt ( i n t rowIndex , i n t columnIndex )
// Para establecer el valor de una determinada celda de la tabla :
void setValueAt ( Object aValue , int rowIndex , int columnIndex )
Para realizar un model que sustituya al que se ofrece por defecto con la clase JTable hay dos
opciones:
1. Realizar una clase que implemente todos los m´etodos de la interfaz TableModel.
2. Realizar una clase que extienda a la clase AbstractTableModel (Esta segunda opcion es la que se muestra en el código de ejemplo proporcionado).
La clase AbstractTableModel ya implementa
alguno de los metodos de la interfaz TableModel pero deja otros 3 métodos de la interfaz sin
implementar:
1 public int getRowCount ( ) ;
2 public int getColumnCount ( ) ;
3 public Object getValueAt ( int row , int column ) ;[3]
Ahora creando un Modelo de Tabla –TableModel:
El modelo de tabla será aquel que determine la forma que nuestra tabla tendrá, y su comportamiento ante los eventos.
Generalmente utilizamos un tabla para listar algo, o cargar datos de forma rapida, por ejemplo personas. En este ejemplo utilizare una clase Personas que tiene tres atributos: Apellido, Nombre (Strings) y número de documento (int).
Lo primero que hay que hacer es crear una clase que implemente la interfaz TableModel. En dicha clase se instanciaran tres variables; dos del tipo LinkedList y una del tipo Persona.
public class MyModelo implements TableModel{
private LinkedList datos = new LinkedList();
private LinkedList listeners = new LinkedList();
Peronas persona =new Peronas();
….
}
La clase LinkedList es una especie de lista que permite incluir y manejar elementos a través de operaciones. Pudiendo ser de cualquier tipo, incluso null. Esta clase nos brinda métodos uniformados para insertar, borrar, obtener y poner elementos en la lista.
La implementación de la interfaz TableModel nos obliga a la utilización de algunos métodos que mostrare a continuación:
1)
public int getColumnCount() {
return 3;
}
Este metodo determina la cantidad de columnas que la tabla tendera. Por ejemplo si queremos que la tabla tenga 3 debemos retornar el numero 3
2)
public int getRowCount() {
return datos.size();
}
Retorna la cantidad de filas, se basa en la lista de elementos declarada con anterioridad.
3) Hora viene uno de los métodos mas importantes el que servirá para obtener los datos de la lista.
public Object getValueAt(int rowIndex, int columnIndex) {
Personas aux;
//castemos el dato de la lista a una variable del tipo Personas
aux = (Personas)(datos.get(rowIndex));
// Se obtendra la persona seleccionada según el numero de fila
switch (columnIndex)
{
case 0:
return aux.getDni();
case 1:
return aux.getApellido();
case 2:
return aux.getNombre();
default:
return null;
}
}
4) asi como tenemos el metodo get existe el metodo set
public void setValueAt(Object aValue, int rowIndex, int columnIndex)
Personas aux;
aux = (Personas)(datos.get(rowIndex));
switch(columnIndex)
{
case 0:
aux.setDni((Integer)aValue);
break;
case 1:
aux.setApellido((String)aValue);
break;
case 2:
aux.serNombre((String)aValue);
break;
default:
break;
}
TableModelEvent evento = new TableModelEvent (this, rowIndex, rowIndex,
columnIndex);
avisaSuscriptores (evento);
}
aValue es un objeto que se pasa como parametro y que contendrá, en nuestro caso, a la persona, pero para convertirla primero debemos castearlo.
Un TableModelEvent se utilizar para notificar a los suscriptores (todos aquellos que necesitan conocer las actividades que se realizan sobre el modelo, por ejemplo la tabla) que el tablemodel a cambiado.
5)
public Class getColumnClass(int columnIndex) {
// Devuelve la clase que hay en cada columna.
switch (columnIndex)
case 0:
return Integer.class;
case 1:
return String.class;
case 2:
return String.class;
default:
return Object.class;
}
}
Nos permitirá obtener las clases de cada columna para utilizarla después.
6)
public String getColumnName(int columnIndex)
switch (columnIndex)
{
case 0:
return "DNI";
case 1:
return "Apellido";
case 2:
return “Nombre”;
default:
return null;
}
}
Este metodo permite definir el nombre de los campos que saldran en el encabezado de la tabla.
7)
public boolean isCellEditable(int rowIndex, int columnIndex) {
return true;
}
Determina si la celda es editable, nosotros podemos jugar con condicionales para determinar que columnas serán editables y cuales no. En este caso todas las celdas son editables.
8)
public void addTableModelListener(TableModelListener l) {
// Añade el suscriptor a la lista de suscriptores
listeners.add (l);
}
9)
public void removeTableModelListener(TableModelListener l) {
// borra un suscriptor
listeners.remove(l);
}
Una ves que terminamos con todos lo métodos que se nos exige implementar, podemos empezar a crear nuestros propios métodos para el manejo de los datos de las celdas.
Lo primero que aremos será crear el método que avise a los suscriptores que el modelo a cambiado y por lo tanto la tabla deberá cambiar.
private void avisaSuscriptores (TableModelEvent evento)
int i;
for (i=0; i
((TableModelListener)listeners.get(i)).tableChanged(evento);
}
Después comenzaremos a crear los metodos para insertar, borrar y acualizar las personas de la tabla
Insertar:
public void insertarPersona (Personas nuevaPersona)
// Añade la persona al modelo
datos.add (nuevaPersona);
// Avisa a los suscriptores creando un TableModelEvent...
TableModelEvent evento;
evento = new TableModelEvent (this, this.getRowCount()-1,
this.getRowCount()-1, TableModelEvent.ALL_COLUMNS,
TableModelEvent.INSERT);
// ... y avisando a los suscriptores
avisaSuscriptores (evento);
}
Con el metodo LinkedList.add() agregamos un elemento a la lista de elemntos que contiene los datos de las personas. Después de ello debemos crear un TableModelEvent que permita notificar de la inserción del dato a la lista.
La estructura del constructor del TableModelEvent que utilizamos es:
TableModelEvent(TableModel modeloDeTabla, int filaInicio, int filaFin, int columna, int tipoEvento)
En este caso en particular, estamos incertando en la ultima fila por que la fila de inicio y de fin es la misma , los cambios se realizarán en todas las columnas, y el evento es un INSERT.
Borrar:
public void borrarPerona (int fila)
datos.remove(fila);
TableModelEvent evento = new TableModelEvent (this, fila, fila,
TableModelEvent.ALL_COLUMNS, TableModelEvent.DELETE);
avisaSuscriptores (evento);
}
Similar a al anterior pero para borrar.
Actualizar:
public void updateTurno(Turnos turno_completo, int fila){
datos.remove(fila);
datos.add(fila,turno_completo);
TableModelEvent e =new TableModelEvent(this,fila,fila,TableModelEvent.ALL_COLUMNS,TableModelEvent.UPDATE);
this.avisaSuscriptores(e);
}
A la hora de realizar el update, prefiero primero remover de la lista el elemento (persona) que se encuentra en el lugar indicado por el parametro fila, para despues realizar la acutalizacion.
Construyendo la tabla:
Después de ver distintos códigos de cómo se crearon tablas y scrollpane, y luego se le asignaban restricciones, layouts y metodos etc, etc, encontré navegando la forma mas sencilla de crearla:
En el frame que vamos a utilizar, podemos arrastrar y soltar algún JScrollPane así lo ubicamos y le damos el tamaño que deseamos. Luego vamos al codigo y escrivimos:
JTable tabla =new JTable(modelo);
JScrollPane jScrollPane1 =new JScrollPane(tabla);//este es el scroll creado por el ide y
//le modificamos el constructor pasandole como parametro la tabla
En el caso de insertar la persona hacemos:
Personas p = new Personas(25425456,”Lopez”,”Juan”);
modelo.insertarPersona(p);
De forma similar trabajamos con el resto de los métodos del modelo.
Mas adelante, escribiré como definir el tamaño de las columnas, y las posibilidades de agregarle componentes a las celdas, imágenes, colores, etc.
Espero haber sido de ayuda, saludos y hasta la proxima. [4]
UN EJEMPLO DE JTABLE:
[1]
[1] Libro JAVA 2 Manual de usuario y tutorial.
[2] http://www.acm.org/crossroads/espanol/xrds7-3/ovp_marzo2001.html.
[3] http://informatica.uv.es/it3guia/LP/laboratorio/P8/p8.pdf.
[4]http://arodm.blogspot.com/2006/11/tablas-under-java-i-jtables-tablemodel.html
No hay comentarios:
Publicar un comentario