Usa método de clicar para selecciona + função

Seja mais específico, dê um exemplo

assim, tenho um tabela eu irei clicar na linha dessa tabela onde ira marca todo conteúdo dessa linha após isso irei excluir essa linha na tupla do banco de dados.

aqui o code de excluir :

1. public void excluir (BeanEvento mod){

3. conectar.conexao();
   

4. try {
   

5. PreparedStatement pst = conectar.con.prepareStatement("delete from cadastro where Id_cadastro=?");
   

6. pst.setInt(1,mod.getIdeve());
   

7. pst.execute();
   

9. } catch (SQLException ex) {
   

10. Logger.getLogger(DaoEvento.class.getName()).log(Level.SEVERE, null, ex);
    

11. }
    

14. conectar.desconecta();
    

16. }
    

Apenas uma linha por vez?
Se sim e dependendo de qual table model é utilizado, poderá fazer uso do método getSelectedRow da classe JTable para obter a linha selecionada.
Se tiver um table model próprio, pode criar um método para obter o objeto referente à linha selecionada, algo como

public Blablabla obtemObjetoDaLinha(int linha) {
    return listaDeItems.get(linha);
}

Não esqueça de remover o elemento e a linha da JTable, então, disparar o evento fireTableDataChanged(), também da JTable.

desculpa sou iniciante, poderia ser mas claro na parte de colocar o blablabla?

Qual table model utiliza? DefaultTableModel ou um que estende AbstractTableModel?

o padrão, jTable1

A JTable é, somente, um modelo. Não é possível adicionar ou remover nada diretamente da JTable, ela é estática.
A única maneira de manipular um objeto da classe JTable é definindo um table model.
Se ainda não fez isso, sugiro, fortemente, que o faça já.
E opte por criar um table model próprio.

hm, como poderia fazer esse jtable model?

Nãio é JTable model, é Table Model.

Eu não assisti, mas, este vídeo tem um passo a passo.

ok, obg

// assim você inicializa sua JTable informando o TableModel que ela deve utilizar
JTable minhaJTable = new JTable(new MeuModelo());

Aqui está o pseudo-código da classe MeuModelo utilizada no exemplo acima:

class MeuModelo extends AbstractTableModel {

    /**
     * A JTable vai chamar este método para obter a quantidade de colunas que ela tem
     */
    @Override
    public int getColumnCount() {
        return <quantidade de colunas da tabela>;
    }
    
    /**
     * A JTable vai chamar este método para obter o nome da coluna informada
     */
    @Override
    public String getColumnName(int coluna) {
        return <nome da coluna informada>;
    }

    /**
     * A JTable vai chamar este método para obter a quantidade de linhas que ela tem
     */
    @Override
    public int getRowCount() {
        return <quantidade de linhas da tabela>;
    }

    /**
     * A JTable vai chamar este método para obter o valor a ser apresentado na linhe e coluna informados
     */
    @Override
    public Object getValueAt(int linha, int coluna) {
        return <valor a ser apresentado na posição (linha, coluna)>;
    }
}

Mano, muito obg, vc me ajudou e muito mesmo, porem agora preciso saber qual code que posso colocar para que, quando eu clicar na linha da tabela ele ira identificar a coluna ID e pega esse valor e jogar no banco de dados.

Uma vez que a ordem das colunas pode ser alterada, não é uma solução muito viável.
O mais adequado é identificar qual é a linha selecionada, a partir daí, recupera o objeto correspondente e pega seu ID.

e com fazer isso?

A classe JTable oferece o método getSelectedRow(), correto? Este método devolve o número correspondente ao índice da linha selecionada (partindo de 0).
Com esse valor, você precisa ir até o seu table model customizado (agradeça ao @staroski) e, criar um método que devolva o elemento da enésima posição da lista que compõe o teu modelo. Como a interface List possui o método get(int x) que devolve o elemento, exatamente na enésima posição, é muito fácil.

Não entendi direito sorry.

Você já tem o método que implementa a ação do JButton clicado?
Se sim, você precisa
1 - Identificar qual foi a linha selecionada.
Isso pode ser feito pelo método getSelectedRow

int linha = jTable1.getSelectedRow();

É interessante validar se há uma linha selecionada, pois, caso o valor da variável linha seja -1, significa que nada foi selecioando.

2 - A partir do momento que você tem a linha selecionada, você vai até o table model e obtém o elemento que corresponde à linha em questão. Isso será feito graças ao fato de que a inerface List oferece o método get que recebe um inteiro como parâmetro e que devolve o elemento correspondente a posição solicitada, partindo de 0, de acordo com o tamanho da lista (quantidade de elementos).
Suponto que é uma lista de Pessoas, o método pode ser parecido com isso

public Pessoa recuperaPessoaPorLinha(int linha) {
     Pessoa p = pessoas.get(linha);
     return p;
}

A partir daí, é só prosseguir com o que deseja fazer.

Porém, eu preciso dizer que você deve, urgentemente, estudar coleções e a estrutura da JTable e de table model.

blz, e para colocar essa edição com base ao banco de dados?

Fera, deixa eu tentar te explicar de uma maneira que você consiga compreender e que não me faça parecer um cara (muito) chato:
O que você tentou fazer?
Veja, programar é mais que pegar um código pronto aqui, outro ali. É extremamente necessário que você coloque a mão na massa e faça.
O objetivo do guj é esclarecer dúvidas a partir de algo que você já fez.
Então, me mostre os códigos:

• Obtendo linha da JTable
• O teu table model
• O método que, a partir da linha selecionada, retorna o objeto
• A classe que faz conexão com o banco de dados
• O método que realiza o tal update que você está questionando.

Aí podemos ajudar, talvez não apenas eu, mas os demais participantes do fórum.

mano entenda. eu quero muito mostrar o code porem eu não sei colocar ele aqui, de forma da pagina toda, se eu souber eu coloco, se pah o projeto todo para poderem me ajudar.

Upa o projeto no github então.

ok.

upado, ele aqui https://github.com/hazalith/projeto_universitario1/

Quais é a tela? E o table model? E o dao?

TelaInicial -> tela para inicialização e com um label que mostrar a conexão com o DB.

TelaEntrar -> (1) tela onde ira solicitar para o usuário selecionar.
Editar -> (1) tela onde se cadastra, altera e apaga os evento.

TelaEvento -> Após clicar no evento selecionado na TelaEntrar será onde todas as adição dos atleta, mostra relatório, apaga atleta editar atleta será referente a esse evento selecionado.

AtletaEd + TelaEditarAtleta + TelaCadastroAtleta( Essa tela foi descontinuada) ( todas as 3 tela são para o mesmo propósito) -> tela de cadastras, apaga e editar atleta referente ao evento selecionado na TelaEntrar.

TelaChaveLuta -> Onde ira mostrar as informação do atleta referente a caixa de combinação.

Não quero toda a estrutura, apenas a que está em questão neste tópico.
Onde está o table model?
Onde está o dao?
Ou você fez tudo misturado?

Dao, está na pasta model, fiz um pouco misturado, pois qnd eu iniciei o projeto não sabia dessa metodologia ágil do dao e bean, e a jtable está no meu comentário anterior.

E o bendito table model? Não fez?

Man sorry não sei operar o Github, deu um trabalhão para colocar meu projeto nele, rsrsrsr

/EventoEntarTableModel

/ *

• Para alterar esse cabeçalho de licença, escolha Cabeçalhos de licença em Propriedades do projeto.
• Para alterar este arquivo de modelo, escolha Ferramentas | Modelos
• e abra o modelo no editor.
• /
  pacote Model.Bean;

import java.util.ArrayList;

import java.util.List;

import javax.swing.table.AbstractTableModel;

/ **
*

• @autor hyago

• /
  public class EventoEntarTableModel extends AbstractTableModel {

  Lista privada eve = new ArrayList <> ();
  private String [] colunas = {“id_evento”, “nome_evento”, “organizador”, “Data_Inicio”, “Data_Fim”};

  @Sobrepor
  
  public String getColumnName (coluna int) {
  
  return colunas [coluna];
  
  }
  

  @Sobrepor
  
  public int getRowCount () {
  
  return eve.size ();
  
  }
  

  @Sobrepor
  
  public int getColumnCount () {
  
  return colunas.length;
  
  }
  

  @Sobrepor
  
  Objeto público getValueAt (int linha, int coluna) {
  
  interruptor (coluna) {
  
  caso 0:
  
  return eve.get (linha) .getId_evento ();
  
  caso 1:
  
  return eve.get (linha) .getNome_evento ();
  
  caso 2:
  
  return eve.get (linha) .getOrganizador ();
  
  caso 3:
  
  return eve.get (linha) .getData_Inicio ();
  
  caso 4:
  
  return eve.get (linha) .getData_Fim ();
  
  }
  
  return null;
  
  }
  

  @Sobrepor
  
  public void setValueAt (valor do objeto, int linha, int coluna) {
  
  interruptor (coluna) {
  
  caso 0:
  
  eve.get (linha) .setId_evento (Integer.parseInt ((String) valor));
  
  pausa;
  
  caso 1:
  
  eve.get (linha) .setNome_evento ((String) valor);
  
  pausa;
  
  caso 2:
  
  eve.get (linha) .setOrganizador ((String) valor);
  
  pausa;
  
  caso 3:
  
  eve.get (linha) .setData_Inicio ((String) valor);
  
  pausa;
  
  caso 4:
  
  eve.get (linha) .setData_Fim ((String) valor);
  
  pausa;
  
  }
  
  this.fireTableRowsUpdated (linha, linha);
  
  }
  

  public void addRow (Evento e) {
  
  this.eve.add (e);
  
  this.fireTableDataChanged ();
  
  }
  

  removedor público vazioRow (int linha) {
  
  this.ve.remove (linha);
  
  this.fireTableRowsDeleted (linha, linha);
  
  }
  
  }
  

Você pode fazer de várias maneiras, eu faria assim,
Primeiro, no arquivo EventoEntarTableModel, criaria esses dois métodos:

public Evento retornaEventoPorLinha(int linha) {
    return this.eve.get(linha);
}

E

public void setEventoNaLinha(int linha, Evento evento) {
    this.eve.set(linha, evento);
    fireTableDataChanged();
}

Aí, você já tem a possibilidade de selecionar uma linha, clicar em um botão para editar, abrir o formulário com os dados deste evento, salvar, gravar no banco e atualizar a tabela.
Era isso que queria saber?

Mas como eu faço para o atleta sempre ser ligado ao evento selecionado?

Teu projeto está tão bagunçado, que eu sequer encontrei a classe evento.

Kkkkkkk, realmente está uma zorra esse projeto.

Sugestão: refaça tudo do zero.
E isso significa, basicamente, começar definindo as estruturas mais básicas, aquelas que representam o domínio do teu projeto, as entidades e suas relações.
Eu criaria um projeto com esta estrutura:

Projeto
    |---src
         |---- pu
             |---- entities
             |---- repositories
             |---- utils
             |---- views

Onde:
pu - diretório principal do projeto, onde você vai colocar a classe com o método main para iniciar o projeto.
entities - onde ficam somente as entidades.
repositories - onde ficam os daos
utils - onde ficam todas as classes utilitárias, incluindo os enums
views - onde ficam as classes relacionadas à view, incluindo os table models.

Depois que construir tudo isso, aí sim, pouco a pouco, vai construindo a aplicação, começando pelos DAOs.

Mano, poderia entrar em contato com vc pelo Skype?

Não.