PRIMEIRA COISA: você deve criar uma classe no seu projeto para ser a classe do modelo… Para fazer isso, basta você adaptar o seguinte código:
import java.util.ArrayList;
import java.util.List;
import javax.swing.table.AbstractTableModel;
public class ClientesTableModel extends AbstractTableModel {
private static final long serialVersionUID = 1L;
/* Lista de clientes que representam as linhas. */
private List<Clientes> linhas;
/* Array de Strings com o nome das colunas. */
private String[] colunas = new String[]{
"Tipo","Data de Cadastro", "Nome", "Idade"};
/* Cria um ClienteTableModel vazio. */
public ClientesTableModel() {
linhas = new ArrayList<Clientes>();
}
/* Cria um ClienteTableModel carregado com
* a lista de clientes especificada. */
public ClienteTableModel(List<Clientes> listaDeClientes) {
linhas = new ArrayList<Clientes>(listaDeClientes);
}
/* Retorna a quantidade de colunas. */
@Override
public int getColumnCount() {
// Está retornando o tamanho do array "colunas".
return colunas.length;
}
/* Retorna a quantidade de linhas. */
@Override
public int getRowCount() {
// Retorna o tamanho da lista de clientes.
return linhas.size();
}
/* Retorna o nome da coluna no Ãndice especificado.
* Este método é usado pela JTable para saber o texto do cabeçalho. */
@Override
public String getColumnName(int columnIndex) {
// Retorna o conteúdo do Array que possui o nome das colunas
// no Ãndice especificado.
return colunas[columnIndex];
}
;
/* Retorna a classe dos elementos da coluna especificada.
* Este método é usado pela JTable na hora de definir o editor da célula.
* Como todos os campos deste model são Strings (nome, e-mail e fones),
* o retorno será sempre a classe String. */
@Override
public Class<?> getColumnClass(int columnIndex) {
return String.class;
}
;
/* Retorna o valor da célula especificada
* pelos Ãndices da linha e da coluna. */
@Override
public Object getValueAt(int rowIndex, int columnIndex) {
// Pega o sócio da linha especificada.
Clientes Clientes = linhas.get(rowIndex);
// Retorna o campo referente a coluna especificada.
// Aqui é feito um switch para verificar qual é a coluna
// e retornar o campo adequado. As colunas são as mesmas
// que foram especificadas no array "colunas".
switch (columnIndex) {
// Seguindo o exemplo: "Tipo","Data de Cadastro", "Nome", "Idade"};
case 0:
return Clientes.getTipo();
case 1:
return Clientes.getData();
case 2:
return Clientes.getNome();
case 3:
return Clientes.getIdade();
default:
// Se o Ãndice da coluna não for válido, lança um
// IndexOutOfBoundsException (Exceção de Ãndice fora dos limites).
// Não foi necessário verificar se o Ãndice da linha é inválido,
// pois o próprio ArrayList lança a exceção caso seja inválido.
throw new IndexOutOfBoundsException("columnIndex out of bounds");
}
}
/* Seta o valor da célula especificada
* pelos Ãndices da linha e da coluna.
* Aqui ele está implementado para não fazer nada,
* até porque este table model não é editável. */
public void setValueAt(Object aValue, int rowIndex, int columnIndex) {
//pega o produto da linha
Clientes m = linhas.get(rowIndex);
//avisa que os dados mudaram
fireTableDataChanged();
}
;
/* Retorna um valor booleano que define se a célula em questão
* pode ser editada ou não.
* Este método é utilizado pela JTable na hora de definir o editor da célula.
* Neste caso, estará sempre retornando false, não permitindo que nenhuma
* célula seja editada. */
@Override
public boolean isCellEditable(int rowIndex, int columnIndex) {
return false;
}
////////////////////////////////////////////////////////////
// Os métodos declarados até aqui foram as implementações //
// de TableModel, que são continuamente utilizados //
// pela JTable para definir seu comportamento, //
// por isso o nome Table Model (Modelo da Tabela). //
// //
// A partir de agora, os métodos criados serão //
// particulares desta classe. Eles serão úteis //
// em algumas situações. //
////////////////////////////////////////////////////////////
/* Retorna o sócio da linha especificada. */
public void getClientes(int indiceLinha) {
linhas.get(indiceLinha);
}
/* Adiciona um registro. */
public void addClientes(Clientes m) {
// Adiciona o registro.
linhas.add(m);
// Pega a quantidade de registros e subtrai um para achar
// o último Ãndice. Ã? preciso subtrair um, pois os Ãndices
// começam pelo zero.
int ultimoIndice = getRowCount() - 1;
// Reporta a mudança. O JTable recebe a notificação
// e se redesenha permitindo que visualizemos a atualização.
fireTableRowsInserted(ultimoIndice, ultimoIndice);
}
/* Remove a linha especificada. */
public void removeClientes(int indiceLinha) {
// Remove o sócio da linha especificada.
linhas.remove(indiceLinha);
// Reporta a mudança. O JTable recebe a notificação
// e se redesenha permitindo que visualizemos a atualização.
fireTableRowsDeleted(indiceLinha, indiceLinha);
}
/* Adiciona uma lista de sócios ao final dos registros. */
public void addListaDeClientes(List<Clientes> Clientes) {
// Pega o tamanho antigo da tabela.
int tamanhoAntigo = getRowCount();
// Adiciona os registros.
linhas.addAll(Clientes);
// Reporta a mudança. O JTable recebe a notificação
// e se redesenha permitindo que visualizemos a atualização.
fireTableRowsInserted(tamanhoAntigo, getRowCount() - 1);
}
/* Remove todos os registros. */
public void limpar() {
// Remove todos os elementos da lista de Clientes.
linhas.clear();
// Reporta a mudança. O JTable recebe a notificação
// e se redesenha permitindo que visualizemos a atualização.
fireTableDataChanged();
}
/* Verifica se este table model está vazio. */
public boolean isEmpty() {
return linhas.isEmpty();
}
}
SEGUNDA COISA: criar um atributo do tipo do modelo na janela em que a jtable existe:
ClientesTableModel modelo;
TERCEIRA COISA: no construtor da janela você vai adicionar o modelo: eis o exemplo:
public Jan_Principal() {
super("Título da janela");
initComponents();
setLocationRelativeTo(null); //janela fica no centro da tela ao ficar visível...
//Adicionando os modelos das tabelas
modelo = new ClientesTableModel();
tabela_Exemplo.setModel(modelo);
}
QUARTA COISA: na hora de adicionar algum “Cliente” no caso na tabela basta fazer:
modelo.addClientes(objetoDoCliente);
ADAPTAÇÕES: você vai ter que ter uma classe para identificar seja-lá o que for que você quer colocar na sua tabela… e na hora de pegar do banco, você vai ter que criar um objeto com esses dados… dps só seguir o “quarto passo”
abraços!
