quero sair do DefaultTableModel

JavaEvangelist Membro desde: 05/11/2009 18:10:51 Mensagens: 378 Offline

tendo essa classe de modelo de tabela

package nome_do_pacote;  
  
import br.com.agenda.model.*;  
import java.util.*;  
import java.util.ArrayList;  
import javax.swing.table.AbstractTableModel;  
  
public class ContatoTableModel extends AbstractTableModel{  
  
    public static final int COL_CODIGO = 0;  
    public static final int COL_NOME = 1;  
    public static final int COL_EMAIL = 2;  
    public static final int COL_FIXO = 3;  
    public static final int COL_CELULAR = 4;  
    private List<Contato> listarContatos;  
  
  
public ContatoTableModel(List<Contato> l){  
    this.listarContatos = new ArrayList<Contato>(l);  
}  
  
public int getRowCount(){  
    return listarContatos.size();  
}  
  
public int getColumnCount(){  
    return 5;  
}  
  
public Object getValueAt(int linhas, int colunas){  
    Contato cont  = this.listarContatos.get(linhas);  
    if(colunas == COL_CODIGO) return cont.getCodigo();  
    if(colunas == COL_NOME) return cont.getNome();  
    if(colunas == COL_EMAIL) return cont.getEmail();  
    if(colunas == COL_FIXO) return cont.getFixo();  
    if(colunas == COL_CELULAR) return cont.getCelular();  
    return "";  
}  
  
public String getColumnName(int colunas){  
    if(colunas == COL_CODIGO) return "Código";  
    if(colunas == COL_NOME) return "Nome";  
    if(colunas == COL_EMAIL) return "E-mail";  
    if(colunas == COL_FIXO) return "Telefone";  
    if(colunas == COL_CELULAR) return "Celular";  
    return "";  
}  
  
public Contato get(int linhas){  
    return listarContatos.get(linhas);  
}  
  
}

Na minha view para eu chamar o modelo da classe ContatoTableModel como faria ?

This message was edited 1 time. Last update was at 29/01/2012 21:16:21

Use assim, apenas modifique os dados, pois este é um modelo que eu havia feito para cidade:

package br.com.estoque.cadastro;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

import javax.swing.table.AbstractTableModel;

import br.com.estoque.bean.Cidade;
  
/** 
* Implementação de Table Model para exibir os Sócios. 
*  
* @author Fernando Evangelista
*/  
public class ContatoTableModel extends AbstractTableModel {  
  
    /* Lista de Cidades que representam as linhas. */  
    private List<Cidade> linhas;  
  
    /* Array de Strings com o nome das colunas. */  
    private String[] colunas = new String[] {  
            "Código", "Nome", "Uf"};  
  
  
    /* Cria um SocioTableModel vazio. */  
    public ContatoTableModel() {  
        linhas = new ArrayList<Cidade>();  
    }  
  
    /* Cria um SocioTableModel carregado com 
     * a lista de cidade especificada. */  
    public ContatoTableModel(List<Cidade> listaDeSocios) {  
        linhas = new ArrayList<Cidade>(listaDeSocios);  
    }  
  
  
    /* Retorna a quantidade de colunas. */  
    @Override  
    public int getColumnCount() {  
        // Está retornando o tamanho do array "colunas".  
        // Mas como o array é fixo, vai sempre retornar 4.  
        return colunas.length;  
    }  
  
    /* Retorna a quantidade de linhas. */  
    @Override  
    public int getRowCount() {  
        // Retorna o tamanho da lista de sócios.  
        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. */  
    @Override  
    public Class<?> getColumnClass(int columnIndex) {  
        // Retorna a classe referente a coluna especificada.  
        // Aqui é feito um switch para verificar qual é a coluna  
        // e retornar o tipo adequado. As colunas são as mesmas  
        // que foram especificadas no array "colunas".  
        switch (columnIndex) {  
        case 0: // Primeira coluna é o codigo, que é um Interger.  
            return Integer.class;  
        case 1: // Segunda coluna é o nome, que também é uma String..  
            return String.class;  
        case 2: // Terceira coluna é uf, 
        	return String.class;
        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");  
        }  
    }  
  
    /* Retorna o valor da célula especificada 
     * pelos índices da linha e da coluna. */  
    @Override  
    public Object getValueAt(int rowIndex, int columnIndex) {  
        // Pega a cidade da linha especificada.  
        Cidade cidade = 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) {  
        case 0: // Primeira coluna é o nome.  
            return cidade.getCodigo();  
        case 1: // primeira coluna é o Codigo.  
            return cidade.getNome();  
        case 2: // segunda coluna é a nome.  
            return cidade.getUf();  
            	// terceira coluna é a Uf.  
        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) {};  
  
    /* 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 a cidade da linha especificada. */  
    public Cidade getCidade(int indiceLinha) {  
        return linhas.get(indiceLinha);  
    }  
      
    /* Adiciona um registro. */  
    public void addSocio(Cidade cidade) {  
        // Adiciona o registro.  
        linhas.add(cidade);  
  
        // 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 removeCidade(int indiceLinha) {  
        // Remove o cidade 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 cidade ao final dos registros. */  
    public void addListaDeCidade(List<Cidade> cidade) {  
        // Pega o tamanho antigo da tabela.  
        int tamanhoAntigo = getRowCount();  
  
        // Adiciona os registros.  
        linhas.addAll(cidade);  
  
        // 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 sócios.  
        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();  
    }  
  
}

E chame assim:

Vc pode iniciar esse metodo no construtor da sua view, assim ele pode exibir os registros quando abrir a sua view.

Boa sorte.

Tópico movido para o fórum de interface gráfica.

Notícias, artigos e o maior fórum brasileiro sobre Java