1

INTRODUÇÃO ................................................................................................................................................ 2

FÁBRICA DE CONEXÕES.......................................................................................................................... 4

Imports necessarios para a classe de conexão: .................................................................................... 4

Código fonte da classe Conexao: .......................................................................................................... 4

EXEMPLO DE INSERÇÃO NO BANCO DE DADOS ..................................................................................... 6

EXECUTANDO CONSULTA NO BANCO DE DADOS ................................................................................... 6

COMO RECUPERAR VALORES DE UM RESULTSET................................................................................................... 7

PRATICAR............................................................................................................................................... 8

ENTENDENDO O COMPONENTE JTABLE ................................................................................................. 9

POPULAR JTABLE A PARTIR DE UMA CONSULTA SQL ........................................................................................... 11

PRATICAR ................................................................................................................................................ 12
CRIAR UM CADASTRO SIMPLES NO JAVA, SEM CLASSE DE ENTIDADE ...................................................................... 13
CRIAR UMA CLASSE JAVA DE UMA ENTIDADE ..................................................................................................... 14
CRIAR MÉTODO SETCADASTAR() ..................................................................................................................... 16
CÓDIGO DO BOTÃO “CADASTRAR” USANDO AS TÉCNICAS DE ORIENTAÇÃO A OBJETO ................................................. 19
PRATICAR ................................................................................................................................................ 20
CRIAR MÉTODO GETCONSULTAR() COM RETORNO DO TIPO RESULTSET .................................................................. 21
Código usado no botão consultar com técnicas orientação a objetos ............................................... 22
PRATICAR ................................................................................................................................................ 23
 2

COMO CRIAR UMA CLASSE DE

CONEXÃO JAVA COM BANCO DE
DADOS MYSQL

Introdução
Conectar-se a um banco de dados com Java é feito de maneira diferenciada. Para evitar que cada banco
tenha a sua própria API e conjunto de classes e métodos, temos um único conjunto de interfaces muito
bem definidas que devem ser implementadas. Esse conjunto de interfaces fica dentro do pacote java.sql
1
e nos referiamos a esta API como JDBC .

Interface JDBC Implementação

Cliente JDBC MySQL
DB

Entre as diversas interfaces deste pacote, existe a interface Connection que define, entre outros,
métodos para executar uma query, comitar transação e fechar a conexão. Caso queiramos trabalhar
2
com o MySQL , precisamos de classes concretas que implementem essas interfaces do pacote java.sql.
3
Esse conjunto de classes concretas é quem fará a ponte entre o código cliente que usa a API JDBC e o
banco de dados. São essas classes que sabem se comunicar através do protocolo proprietário do banco
de dados. Esse conjunto de classes recebe o nome de driver. Todos os principais bancos de dados do
mercado possuem drivers JDBC para que você possa utilizá-los com Java.

Implementação
JDBC MySQL DriverManager.getConnection("jdbc:mysql://localh
ost/teste");

1
Java Database Connectivity ou JDBC é um conjunto de classes e interfaces (API) escritas em Java que fazem o envio de instruções
SQL para qualquer banco de dados relacional
2
O MySQL é um sistema de gerenciamento de banco de dados (SGBD), que utiliza a linguagem SQL (Linguagem de Consulta
Estruturada, do inglês Structured Query Language) como interface
3
Application Programming Interface (ou Interface de Programação de Aplicações) é um conjunto de rotinas e padrões
estabelecidos por um software para a utilização das suas funcionalidades por programas aplicativos que não querem envolver-se
em detalhes da implementação do software, mas apenas usar seus serviços.
 3

Para abrir uma conexão com um banco de dados, precisamos utilizar sempre um driver. A classe
DriverManager é a responsável por se comunicar com todos os drivers que você deixou disponível. Para
isso, invocamos o método estático getConnection com uma String que indica a qual banco desejamos
nos conectar.

Essa String - chamada de String de conexão JDBC - utilizaada para acessar o MySQL, segue o padrão
abaixo:

jdbc:mysql://ip/nome_do_banco

Devemos substituir ip pelo IP do servidor e nome_do_banco pelo nome do banco de dados a ser
utilizado, o restante mantem o padrão.

Seguindo o exemplo da linha acima e tudo que foi dito até agora, seria possível rodar o exemplo abaixo
e receber uma conexão para um banco MySQL chamado exemplo, caso ele esteja rodando na mesma
máquina:

public class JDBCExemplo {

public static void main(String[] args) throws SQLException {

Connection conexao = DriverManager.getConnection("jdbc:mysql://localhost/nome_banco","usuario","senha");
System.out.println("Conectado!");
conexao.close();

}
}

Parâmetos a serem preencidos no getConnection: jdbc:mysql://localhost/nome_banco

1. Devemos substituir localhost para o IP ou nome do servidor
2. Devemos substituir “nome_banco” pelo nome do banco de dados
3. Devemos substituir “usuario” pelo usuário de acesso ao banco de dados
4. Devemos substituir “senha” pela senha do usuário de acesso ao banco de dados

Repare que estamos deixando passar a SQLException, que é uma exception checked, lançada por
muitos dos métodos da API de JDBC. Numa aplicação real devemos utilizar try/catch nos lugares que
julgamos haver possibilidade de recuperar uma falha com o banco de dados. Também precisamos tomar
sempre cuidado para fechar todas as conexões que foram abertas.

Dica
É necessário carregar o driver MySQL na biblioteca.
Clique com botão direito nas bibliotecas >> Adicionar biblioteca, na lista escolha MySQL JDBC Driver.
 4

Fábrica de Conexões

Abaixo segue exemplo de uma classe simples de conexão. Para efetuar teste com esta classe, crie um
novo projeto no NetBeans chamado Fabrica. Clique no menu Novo >> Novo Projeto, categoria Java e
projetos “Aplicativo a área de trabalho Java”.

Crie uma nova classe no seu projeto chamada Conexao, para isso clique com botão direito do mouse no
projeto principal escolha Novo >> Classe Java, ao solicitar o nome da classe digite Conexao, observe que
a primeira letra é maiuscula.

Use os imports abaixo da linha semelhante a esta: package Fabrica;

Imports necessarios para a classe de conexão:

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.logging.Level;
import java.util.logging.Logger;

Código fonte da classe Conexao:

public class Conexao {

public Conexao () { } //Possibilita instancias

public static Connection con = null;

public static void Conectar() {

System.out.println("Conectando ao banco...");
try {
Class.forName("com.mysql.jdbc.Driver");
con = DriverManager.getConnection("jdbc:mysql://127.0.0.1/nome_do_banco","root","");
System.out.println("Conectado.");
} catch (ClassNotFoundException ex) {
System.out.println("Classe não encontrada, adicione o driver nas bibliotecas.");
Logger.getLogger(Conexao.class.getName()).log(Level.SEVERE, null, ex);
} catch(SQLException e) {
System.out.println(e);
throw new RuntimeException(e);
}

Observe que existem 4 parametros para configurar, eles são: IP, NOME_DO_BANCO, USUARIO E SENHA.

con = DriverManager.getConnection("jdbc:mysql://IP/nome_do_banco","usuario","senha");

PARA REALIZAR O TESTE COM SUA CLASSE DE CONEXÃO, FAÇA O SEGUINTE:

1. Crie um jFrame e um botão no meio com o seguinte código:

Conexao.Conectar();
 5

Este método será executado normalmente na abertura do frame, já instanciando a variável con da
classe Conexao com as informações para conectar-se ao banco de dados.

A partir deste momento a variável con da classe Conexao está declarada contendo os dados de conexão.

Para fechar a conexão é necessário usar: Conexao.con.close();

Com a conexão pronta, necessitamos declarar uma SQL para executarmos no banco de dados.
Poderemos usar os comandos DML para modelar os dados no banco, como por exemplo:
INSERT,UPDATE e DELETE bem como o famoso SELECT.

As cláusulas são executadas em um banco de dados através da interface PreparedStatement. Para

receber um PreparedStatement relativo à conexão, basta chamar o método prepareStatement,
passando como argumento o comando SQL com os valores vindos de variáveis preenchidos com uma
interrogação.

1. Abaixo segue exemplo do comando para inserir diretamente no banco de dados sem uso de
classe de entidade. Para efetuar teste com este comando, crie um novo projeto no NetBeans
chamado Pagina5. Clique no menu Novo >> Novo Projeto, categoria Java e projetos “Aplicativo
a área de trabalho Java”.
2. Crie um novo Jframe, para isso execute um clique com botão direito do mouse sobre o projeto
Pagina5, Novo >> Formulário Jframe. Ao solicitar o nome do frame digita JFPagina5.
3. Adicione um botão (Button) no meio do frame, rotule-o como Inserir e adicione no evento
4
actionPerformed o código abaixo:

String sql = "insert into contatos (nome,email) values (?,?)";

java.sql.PreparedStatement stmt = Conexao.con.prepareStatement(sql);

Cada interrogação no comando insert acima é um parametro que deve ser definido no
PreparedStatement com setString para String’s setInt, setFloat e assim por diante, no nosso exemplo
usaremos setString, pois os valores nome e email são deste tipo String. Não substitua as interrogações
do comando insert acima por valores, as interrogações serão substituídas por meio dos parâmetros
abaixo:

// preenche os valores dos parametros em sua respectiva ordem

stmt.setString(1, "DOUGLAS");
stmt.setString(2, "dtybel@yahoo.com.br");

Por fim, uma chamada ao metodo execute() que serve para executar o comando SQL sem retornar
dados, isso significa que seu uso será geralmente para INSERT, UPDATE e DELETE.

stmt.execute();

Será necessário adicionar trecho para tratamento de erro por bloqueio com try-catch

4
Clique com botão direito do mouse sobre o componente escolha Eventos >> Action >> actionPerformed
 6

Exemplo de Inserção no banco de dados

Veja o exemplo abaixo, execução de comando insert no banco considerando classe conexão
explicada neste artigo. Crie um jFrame com um jButton, insira o código abaixo no evento
actionPerformed, conforme exemplo da pagina acima.

// conectando
Conexao.Conectar();
// cria um preparedStatement
String sql = "insert into contatos (nome,email) values (?,?)";
java.sql.PreparedStatement stmt = Conexao.con.prepareStatement(sql);
// preenche os valores
stmt.setString(1, "DOUGLAS");
stmt.setString(2, "dtybel@yahoo.com.br");

// executa
stmt.execute();
stmt.close();
System.out.println("Gravado!");
Conexao.con.close();

Será necessário adicionar trecho para tratamento de erro por bloqueio com try-catch.

Executando consulta no banco de dados

Para realizar consultas, também utilizamos a interface PreparedStatement, de forma que o método
executeQuery retorna todos os dados de uma determinada consulta.

O objeto retornado é do tipo ResultSet que permite navegar por seus registros através do método
next etc. Esse método irá retornar false quando chegar ao fim da consulta, portanto é normalmente
utilizado para realizar um loop nos registros como no exemplo a seguir:

// pega a conexão e o Statement

Conexao.Conectar();
java.sql.PreparedStatement stmt = Conexao.con.prepareStatement("select * from contatos");
// executa um select
ResultSet rs = stmt.executeQuery();
// rs é a variável que armazenou todo o resultado (ResultSet)
while (rs.next()) { //Observe que o loop inicia aqui, enquanto o rs.next() for igual a true(conter resultado)

System.out.println(rs.getString("nome") + " :: " + rs.getString("email"));

} //O loop renova aqui

rs.close();
stmt.close();
Conexao.con.close();

Exemplo da saída: DOUGLAS :: dtybel@yahoo.com.br

Será necessário adicionar trecho para tratamento de erro por bloqueio com try-catch.
 7

Como recuperar valores de um ResultSet

Para retornar o valor de uma coluna no banco de dados basta chamar um dos métodos get do
ResultSet , dentre os quais, o mais comum: getString.

Segue passos para recuperar dados do ResultSet.

Declarar uma variável do tipo ResultSet para armazenar o resultado do banco

Usar os metodos getString,getFloat,getInt e outros.

ResultSet rs = stmt.executeQuery();

CampoTexto.setText( rs.getString(“nome_do_campo_da_tabela_do_tipo_String”) );
CampoInteiro.setText( rs.getInt(“nome_do_campo_da_tabela_do_tipo_Inteiro”) );
CampoFloat.setText( rs.getFloat(“nome_do_campo_da_tabela_do_tipo_Real”) );

Este código não é muito diferente de um código em linguagem C, isto acontece porque a linguagem Java
foi criada com base na linguagem C possuindo quase todas as palavras reservadas dela e um conceito
que deixa muitos desenvolvedores descontentes: o case-sensitive. Isso mesmo, Java é case-sensitive,
portanto maiúsculas são diferentes de minúsculas, a é diferente de A .
 8

PRATICAR

1. Crie um banco de dados chamado contatos;

2. Crie uma tabela chamada contatos (nome, email);
5
3. Crie um projeto chamado contatos;
4. Crie uma classe para conexão no banco de dados chamada Conexao com referencia ao banco
agenda com usuário e senha definido na instalação do MySQL;
6
5. Crie um JFrame chamado JFAgenda com um botão JButton rotulado como CADASTRAR;
6. O comando deste botão será uma inserção conforme exemplo acima na pagina 06;
7. Adicione um novo jButton no frame jFAgenda agora rotulado como CONSULTAR;
8. O comando deste botão será uma consulta conforme acima na pagina 06;

5
No NetBeans clique no menu Novo >> Novo Projeto, categoria Java e projetos “Aplicativo a área de trabalho Java”.

6
No NetBeans clique com botão direito do mouse sobre o projeto, Novo >> Formulário Jframe. Ao solicitar o nome do
frame digite nome desejado.
 9

Entendendo o componente Jtable

A classe JTable é utilizada para vizualizar dados em grid no Swing é um dos componentes mais
complexos desse pacote. Alias o JTable possui até um pacote especial, que contém diversas classes para
7
sua utilização: javax.swing.table. A JTable é um componente MVC : o seu trabalho é dividido em 3
partes: Model: É a parte que cuida dos dados, quem controla e distribui os dados na jtable. É
implementado pela interface TableModel ( AbstractTableModel e DefaultTableModel ). Ela é
responsavel por fornecedor os dados para a tabela, a qual requisitará os dados atraves do método
getValueAt, informando a linha e a coluna. Este método retorna um Object, ou seja, um objeto
qualquer, que pode ser um Integer, uma String ou outra classe que você tenha implementado.

Objerve o jFrame abaixo:

Componente jTable

Componente jButton

jTable1 1

O importante é observar as colunas (Código, Nome, Telefone), são estas colunas que usaremos como
base para iniciar a população de dados.

Para reproduziar a tabela acima, clique com botão direito no JTable e selecione “Conteúdo da tabela”

7
Model-view-controller (MVC) é um padrão de arquitetura de software que visa a separar a lógica de negócio da lógica de
apresentação, permitindo o desenvolvimento, teste e manutenção isolado de ambos.
 10

Vamos neste momento definir uma variável para armazenar a estrutura atual da tabela:

1. DefaultTableModel modelo = (DefaultTableModel) jTable1.getModel();

2. modelo.setNumRows(0);

Onde modelo receberá os dados conforme a figura 1.

Para inserir uma linha sera preciso executar o método addRow:

modelo.addRow

Segue abaixo como usá-lo corretamente:

3. modelo.addRow(new Object[]{
“0001”,
“Douglas”,
“2799379892”
});

4. jTable1.setModel(modelo);

Esse comando adicionará uma nova linha com o conteúdo acima na tabela.
 11

Popular Jtable a partir de uma consulta SQL

Crie um jFrame com um Jbutton, adicione o conteúdo abaixo no evento actionPerformed do botão:

// TODO add your handling code here:

Conexao.Conectar();
java.sql.PreparedStatement stmtQuery = Conexao.con.prepareStatement("Select * from pessoas");
ResultSet resultSet = stmtQuery.executeQuery();
resultSet.beforeFirst();

DefaultTableModel modelo = (DefaultTableModel) jTable1.getModel();

modelo.setNumRows(0);
while (resultSet.next()){
modelo.addRow(new Object[]{
resultSet.getString("codPessoa"),
resultSet.getString("pessoa"),
resultSet.getString("telefone")
});

jTable1.setModel(modelo);
 12

PRATICAR

1. Crie um banco de dados no MySql chamado CONTATOS;

2. Crie uma tabela chamada pessoas, com a seguinte estrutura(id,pessoa,telefone);
3. Adicione alguns dados fictícios;
4. Crie um novo projeto chamado Pagina12;
5. Crie uma classe chamada Conexao, conforme o conteúdo da pagina: 4;
6. Observe os parametros do getConnection da classe Conexao, direcione para o banco de dados
correto com o usuário e senha:
DriverManager.getConnection("jdbc:mysql://127.0.0.1/nome_do_banco","root","");

7. Criar novo Formulário jFrame chamado jFContato, conforme pagina: 9, não será necessário
menus;
8. O código do botão Consultar, deve: Conectar e popular o JTable, conforme exemplo na pagina:
11
 13

Criar um cadastro simples no JAVA, sem classe de entidade

Crie um formulário jFrame chamado JFContato, conforme a figura abaixo:

Renomeie os campos conforme abaixo:

Rótulo Nome
Código codigojTextField
Nome pessoajTextField
Telefone telefonejTextField
Cadastrar cadastrarjButton

Insira o seguinte código no evento actionPerformed do botão rotulado Cadastrar:

try {
// TODO add your handling code here:
// conectando
Conexao.Conectar();
// cria um preparedStatement
String sql = "insert into pessoas (pessoa,telefone) values (?,?)";
PreparedStatement stmt = Conexao.con.prepareStatement(sql);
// preenche os valores
stmt.setString(1, pessoajTextField.getText());
stmt.setString(2, telefonejTextField.getText());
// executa
stmt.execute();
stmt.close();
System.out.println("Gravado!");
Conexao.con.close();

} catch (SQLException ex) {

Logger.getLogger(jFContato.class.getName()).log(Level.SEVERE, null, ex);
}
 14

Criar uma classe Java de uma entidade

Para realizarmos o cadastro acima, colocamos o código DML diretamente no botão cadastrar, o que não
é permitido na programação orientada a objeto.

Entendemos que o insert acima representa o método “Cadastrar contato”, isto significa que é um
método chamado setCadastar() da classe de contato.

Para representarmos isso de forma correta devemos montar a classe:

Contatos
codPessoa
pessoa
telefone
setCadastrar()
setConsultar()

Logicamente existem outros métodos na classe contatos, contudo focaremos na função setCadastrar();

É bem simples a lógica, pois divide em duas partes conforme abaixo:

1. Criar a classe chamada Contatos

2. Criar método setCadastar() na classe Contatos

Para criar uma classe chamada Contratos, clique com botão direito no pacote da aplicação e escolha
opção: Novo >> Classe Java

O código conforme abaixo será gerado automaticamente:

package desktopapplication1;

public class Contatos {

Implemente os atributos na classe conforme abaixo:

public class Contatos {

private Integer codPessoa;
private String pessoa;
private String telefone;

No próximo passo precisamos criar os métodos get e set publicos. Para realizar esta tarefa de forma
automática, clique no final da classe antes da “chave }” e pressione as teclas [ALT] e [INSERT] .

Aparecerá uma janela de opções conforme abaixo:

 15

Escolha Getter e setter, aparecerá uma nova janela com as opções abaixo:

Marque todos os métodos e clique no botão [Gerar].

Os métodos públicos serão gerados automaticamente na classe acima.

 16

Criar método setCadastar()

Para criarmos um método que contenha os comandos para cadastrar um contato, é necessário observar
três pontos importantes:

1. Visibilidade
2. Retorno
3. Parametros

O primeiro ponto trata-se de visibilidade, pois não adinhanta criarmos um método que os frames não
possão acessar, deste modo a visibilidade do método será public, assim sua visibilidade será publica
para todo o projeto.

O segundo ponto trata-se do retorno desejado após execução do comando. Normalmente para
comandos de definição como o setCadastrar , setAlterar ou setExcluir, não existe retorno, pois apenas
queremos alterar o conteúdo da tabela e não precisamos de retorno para mostrar para o usuário, deste
modo o retorno correspondente a nulo será void.

O terceiro e ultimo ponto, trata-se de parâmetros que possamos precisar para execução o comando. Os
parametros podem ser repassados atraves da própria função como exemplo abaixo:

Declaração:
setCadastar(int Codigo);

Uso:
setCadastrar( 2 );

Com este uso o número 2 estará disponível dentro da classe e do método setCadastrar na variável
Codigo.

Por outro lado e até mais útil, podemos usar os próprios atributos da classe como parâmetros, pois eles
já são visíveis e acessáveis de dentro do método sem a necessidade de repassá-los, apenas é necessário
atribuir valor antes de executar o método, como exemplo abaixo:

Contatos oContato = new Contatos();

oContato.setCodPessoa( 2 );
oContato.setCadastrar();

A variável codPessoa estará presente dentro da função setCadastrar com o valor 2, assim podemos
utilizá-lo para inserir em nosso comando.

Veja exemplo do método declarado:

public void setCadastrar(){

//Comandos a serem executados
}
 17

Usaremos então o mesmo código utilizado no botão cadastar, contudo faremos algumas alterações:

Insira o código abaixo no método setCadastrar que você acabou de criar na classe Contatos:

String sql = "insert into pessoas (pessoa,telefone) values (?,?)";

PreparedStatement stmt = Conexao.con.prepareStatement(sql);
// preenche os valores
stmt.setString(1, pessoajTextField.getText());
stmt.setString(2, telefonejTextField.getText());
// executa
stmt.execute();
stmt.close();
System.out.println("Gravado!");
Conexao.con.close();

Lembre-se de importar a biblioteca java.sql.PreparedStatement.

Use o bloquei para casos de erro no trecho desenvolvido acima.

Observe que duas linhas ainda constam erros, pois não existe os componentes pessoajTextField e
telefonejTextField na classe Contatos para pegar os valores, assim os mesmos devem ser passados para
classe antes mesmo da execução deste método, como no exemplo a seguir:

Contatos oContato = new Contatos();

oContato.setPessoa( “DOUGLAS” );
oContato.setTelefone( “2799379892” );
oContato.setCadastrar();

Devemos alterar as linhas erradas pelos próprios métodos, já que os valores foram atribuídos antes da
execução do método.

Após alteração o trecho será alterado conforme acima.

 18

Segue abaixo código completo:

try {
// cria um preparedStatement
String sql = "insert into pessoas (pessoa,telefone) values (?,?)";
PreparedStatement stmt = Conexao.con.prepareStatement(sql);
// preenche os valores
stmt.setString(1, getPessoa() );
stmt.setString(2, getTelefone() );
// executa
stmt.execute();
stmt.close();
System.out.println("Gravado!");
Conexao.con.close();
} catch (SQLException ex) {
Logger.getLogger(Contatos.class.getName()).log(Level.SEVERE, null, ex);
}
 19

Código do botão “cadastrar” usando as técnicas de orientação a objeto

8
O código do botão cadastrar usando as técnicas OO , será sempre mais curto, pois todo o código estará
na classe, assim em todo o projeto, toda vez que fizer necessário o uso do cadastro de contato, não será
necessário digitar todo o código e sim o método chamado a partir da classe Contatos, conforme abaixo:

Conexao.Conectar();
Contatos oContato = new Contatos();
oContato.setPessoa( pessoajTextField.getText() );
oContato.setTelefone( telefonejTextField.getText() );
oContato.setCadastrar();

Obs.: Não se faz necessário a conexão toda vez que for executar um método, basta conectar na abertura
do frame por exemplo.

8
A orientação a objetos é um paradigma de análise, projeto e programação de sistemas de software baseado na composição e
interação entre diversas unidades de software chamadas de objetos.

Em alguns contextos, prefere-se usar modelagem orientada ao objeto, em vez de programação. De fato, o paradigma "orientação
a objeto", tem bases conceituais e origem no campo de estudo da cognição, que influenciou a área de inteligência artificial e da
linguística, no campo da abstração de conceitos do mundo real
 20

PRATICAR

1. Em sua aplicação chamada Pagina20;

2. Contendo uma classe chamada Conexao, conforme o conteúdo da pagina: 4;
3. Criar novo Formulário jFrame chamado jFContatoOO, conforme pagina: 13;
4. Crie uma classe para entidade Contatos;
5. Crie na classe Contatos o método setCadastar() com os códigos conforme pagina: 16
6. O código do botão Cadastar, deve: Conectar e executar o método setCadastar() da classe
Contatos, conforme exemplo na pagina: 18
 21

Criar método getConsultar() com retorno do tipo ResultSet

Para criarmos um método que contenha os comandos para consultar um contato, é necessário observar
três pontos simples:

1. Visibilidade
2. Retorno
3. Parametros

O primeiro ponto trata-se de visibilidade, pois não adinhanta criarmos um método que os frames não
possão acessar, deste modo a visibilidade do método será public, pois sua visibilidade será publica para
todo o projeto.

O segundo ponto trata-se do retorno desejado após execução do comando. Normalmente para
comandos de consulta como o getConsultar, getEmitir ou getID, existem retornos de diversos tipos, mas
normalmente gostariamos de tratar todo o retorno em forma de tabela. O retorno que representará a
tabela em sua igualdade será o tipo ResultSet.

O terceiro e ultimo ponto trata-se de parâmetros que possamos precisar para execução do comando. Os
parametros podem ser repassados atraves da própria função no caso da consulta não será necessário.

Conforme já visto no método setCadastrar, a única diferença é que o retorno da função não é nulo ou
void por assim dizer, observe abaixo a declaração do método:

public ResultSet getConsultar(){

//Código para consultar

Será necessário importar a seguinte classe: java.sql.ResultSet, conforme imagem acima.

Substituir //Código para consultar, pelo seguinte código:

java.sql.PreparedStatement stmtQuery = Conexao.con.prepareStatement("Select * from pessoas");

ResultSet resultSet = stmtQuery.executeQuery();
resultSet.beforeFirst();
return resultSet;

A linha em destaque amarela acima, refere ao retorno da função com a variável resultSet declarada
para armazanar o resultado do banco de dados.

Obs.: Lembre-se de deixar o tratamento de exceção com uma throws chamada SQLException, conforme
a figura abaixo:
 22

Segue abaixo código completo após criação:

public ResultSet getConsultar() throws SQLException{

java.sql.PreparedStatement stmtQuery = Conexao.con.prepareStatement("Select * from pessoas");
ResultSet resultSet = stmtQuery.executeQuery();
resultSet.beforeFirst();

return resultSet;
}

Código usado no botão consultar com técnicas orientação a objetos

try {
// TODO add your handling code here:
Conexao.Conectar();
Contatos oContato = new Contatos();
ResultSet resultSet = oContato.getConsultar();
DefaultTableModel modelo = (DefaultTableModel) jTable1.getModel();
modelo.setNumRows(0);
while (resultSet.next()) {
modelo.addRow(new Object[]{resultSet.getString("codPessoa"), resultSet.getString("pessoa"),
resultSet.getString("telefone")});
}
jTable1.setModel(modelo);

} catch (SQLException ex) {

Logger.getLogger(DesktopApplication1View.class.getName()).log(Level.SEVERE, null, ex);
}
 23

PRATICAR

1. Crie uma aplicação chamada Servicos;

2. Use a classe Conexao já existente (altere apenas os dados de conexão);
3. Crie um banco de dados chamado Servicos;
4. Crie uma tabela chamada Servicos (id,servico,descricao), id sendo autoInc;
5. Crie a classe de entidade Servicos no projeto corrente, conforme exemplos ensinados;
6. Crie os métodos de consulta e cadastro na classe de Servicos conforme exemplos;
7. Crie um frame para cadastrar os Serviços e outro frame para consultar os serviços, quem quiser
pode fazer em um jFrame apenas se achar mais simples.
8. Desenvolva os códigos dos botões chamando os métodos da classe Serviço para cadastrar e
consultar, conforme exemplos a partir da pagina: 16