Apostila Programação II - Java POJO

Prévia do material em texto

Prof. Douglas O. Tybel 
 
FACULDADE VALE CRICARÉ – FVC 
APOSTILA LINGUAGEM 
PROGRAMAÇÃO II 
JAVA – POJO (Plain Old Java Objects) 
 
DOUGLAS TYBEL 
10/28/2010 
 
 
Data Versão da Revisão Descrição da Revisão Autor 
28/10/2010 1.00 Criada Douglas Tybel 
07/03/2014 1.01 Adicionado tópico – Erros 
Conhecidos 
Douglas Tybel 
 
 
Este documento contém material desenvolvido pelo professor Douglas Tybel da Faculdade Vale do 
Cricaré em São Mateus/Es. Esta apostila tem como objetivo facilitar o ensino da disciplina com base em 
muitos exercícios práticos, trabalhando assim a linguagem e exercitando novas técnicas cada vez mais 
evolutivas. 
 Prof. Douglas O. Tybel 
 
INTRODUÇÃO.......................................................................................................................... 1 
FÁBRICA DE CONEXÕES ....................................................................................................... 2 
IMPORTS NECESSARIOS PARA A CLASSE DE CONEXÃO: ................................................................. 3 
CÓDIGO FONTE DA CLASSE CONEXAO: ....................................................................................... 3 
EXEMPLO DA CLASSE CONEXAO.......................................................................................... 4 
EXECUTAR COMANDO INSERT NO BANCO DE DADOS ...................................................... 5 
EXEMPLO ............................................................................................................................. 6 
EXECUTANDO CONSULTA NO BANCO DE DADOS ............................................................. 7 
COMO RECUPERAR VALORES DE UM RESULTSET ........................................................................ 7 
PRATICAR ............................................................................................................................ 8 
ENTENDENDO COMPONENTE JTABLE ................................................................................ 9 
EXEMPLO POPULAR JTABLE A PARTIR RESULTADO DE CONSULTA SQL .................... 11 
PRATICAR .......................................................................................................................... 12 
CADASTRO SIMPLES EM JAVA SEM USO DE CLASSE ..................................................... 13 
CRIAR CLASSE DE ENTIDADE JAVA .................................................................................. 14 
CRIAR MÉTODO SETCADASTAR() ......................................................................................... 16 
EXEMPLO DA CLASSE CONTATOS ................................................................................... 19 
CÓDIGO DO BOTÃO “CADASTRAR” USANDO AS TÉCNICAS DE ORIENTAÇÃO A OBJETO ..................... 20 
PRATICAR .......................................................................................................................... 21 
CRIAR MÉTODO GETCONSULTAR() COM RETORNO DO TIPO RESULTSET ................... 22 
CÓDIGO USADO NO BOTÃO CONSULTAR COM TÉCNICAS ORIENTAÇÃO A OBJETOS .......................... 23 
PRATICAR .......................................................................................................................... 24 
RECUPERAR DADOS DO JTABLE ....................................................................................... 25 
DESENVOLVER O CÓDIGO PARA RECUPERAR OS DADOS DO JTABLE ............................................. 26 
ERROS CONHECIDOS .......................................................................................................... 27 
CONCLUSÃO ......................................................................................................................... 30 
 
1 
 
 
 Prof. Douglas O. Tybel 
 
INTRODUÇÃO 
Plain Old Java Objects ou POJO são objetos Java que seguem um desenho simplificado em 
contraposição aos EJBs (Enterprise JavaBeans), por exemplo. Um JavaBean é um POJO que 
segue definições rígidas de estrutura (construtor default sem argumentos e métodos que 
seguem o padrão de encapsulamentos getters e setters para seus atributos). 
Este padrão é baseado na ideia de que quanto mais simples o projeto, melhor. O termo foi 
inventado por Martin Fowler, Rebecca Parsons e Josh MacKenzie em Setembro de 2000. 
Mesmo sendo simplificada, conta com integração de bibliotecas capazes de conectar-se a um 
banco de dados com Java, isto é 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 e nos referiamos a esta API como JDBC
1
. 
 
 
 
 
 
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 com o MySQL
2
, precisamos de classes concretas que implementem essas 
interfaces do pacote java.sql. 
Esse conjunto de classes concretas é quem fará a ponte entre o código cliente que usa a API 
3
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. 
 
 
 
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. 
Cliente 
Interface 
JDBC 
Implementação 
JDBC MySQL DB 
Implementação 
JDBC MySQL 
DriverManager.getConnection("jdbc:mysql://l
ocalhost/teste"); 
2 
 
 
 Prof. Douglas O. Tybel 
 
FÁBRICA DE CONEXÕES 
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 - utilizada 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áriode 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. Em uma 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. 
 
 
 
3 
 
 Prof. Douglas O. Tybel 
 
Abaixo segue exemplo de uma classe simples para conexão. 
1. Crie um banco de dados chamado banco, tenha em mãos seu usuario e senha do 
MySQL; 
2. 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”. 
3. Crie uma nova classe no seu projeto chamada Conexao, para isso clique com botão 
direito do mouse no pacote principal escolha Novo >> Classe Java, ao solicitar o nome 
da classe digite Conexao, pressione Finalizar para concluir. (observe que a primeira 
letra é maiúscula). 
4. Copie os imports necessários em destaque vermelho logo abaixo e cole na classe 
Conexao em baixo da linha: 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: 
 
1. public Conexao () { } //Possibilita instancias 
2. public static Connection con = null; 
 
3. public static void Conectar() { 
4. System.out.println("Conectando ao banco..."); 
5. try { 
6. Class.forName("com.mysql.jdbc.Driver"); 
7. con = DriverManager.getConnection("jdbc:mysql://127.0.0.1/banco","root",""); 
8. System.out.println("Conectado."); 
9. } catch (ClassNotFoundException ex) { 
10. System.out.println("Classe não encontrada, adicione o driver nas bibliotecas."); 
11. Logger.getLogger(Conexao.class.getName()).log(Level.SEVERE, null, ex); 
12. } catch(SQLException e) { 
13. System.out.println(e); 
14. throw new RuntimeException(e); 
15. } 
 
16. } 
 
Observe que existem quatro parâmetros para serem configurados na classe Conexao, eles 
são: IP, BANCO, USUARIO E SENHA. 
 
 
4 
 
 Prof. Douglas O. Tybel 
 
EXEMPLO DA CLASSE Conexao 
 
package Fabrica; 
 
import java.sql.Connection; 
import java.sql.DriverManager; 
import java.sql.SQLException; 
import java.util.logging.Level; 
import java.util.logging.Logger; 
 
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/banco","usuario","senha"); 
 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); 
} 
 
} 
 
} 
 
 
 
PARA REALIZAR O TESTE COM SUA CLASSE DE CONEXÃO, FAÇA O SEGUINTE: 
1. Crie um JFRAME 
4
e um botão no meio com o seguinte código: 
Conexao.Conectar(); 
Este método Conectar() 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(); 
Repare que ao clicar no botão aparecerá caso tudo ocorra bem, a seguinte saída: 
Conectando ao banco... 
Conectado. 
 
 
4
 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. 
5 
 
 Prof. Douglas O. Tybel 
 
EXECUTAR COMANDO INSERT NO BANCO DE DADOS 
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. Crie uma tabela no banco de dados chamado “banco” que você criou nos passos 
anteriores, chamada: contatos com os campos id : Integer(autoInc),nome : 
Varchar(80) e email : Varchar(80) 
2. 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”. 
3. Crie um novo Jframe, para isso execute um clique com botão direito do mouse sobre o 
pacote pricipal Pagina5, Novo >> Formulário Jframe. Ao solicitar o nome do frame 
digita JFPagina5. 
4. Adicione um botão (Button) no meio do frame, rotule-o como Inserir e adicione no 
evento actionPerformed 
5
 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 
 
5
 Clique com botão direito do mouse sobre o componente escolha Eventos >> Action >> actionPerformed 
6 
 
 Prof. Douglas O. Tybel 
 
EXEMPLO 
 
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. 
Deixe sempre uma linha sobrando ao final do código antes de usar o assistente para usar o 
bloqueio, será a linha que ele usará para colocar o catch. 
 
7 
 
 Prof. Douglas O. Tybel 
 
EXECUTANDO CONSULTA NO BANCO DE DADOS 
Para realizarconsultas, 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. 
 
Como recuperar valores de um ResultSet 
 
Este trecho abaixo, explica a linha com fundo cinza acima dentro da estrutura de repetição 
while. 
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 
 
 Prof. Douglas O. Tybel 
 
 
PRATICAR 
 
1. Crie um banco de dados chamado contatos; 
2. Crie uma tabela chamada contatos (nome, email); 
3. Crie um projeto 
6
 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; 
5. Crie um JFrame 
7
 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 07; 
 
 
6
 No NetBeans clique no menu Novo >> Novo Projeto, categoria Java e projetos “Aplicativo a área de trabalho 
Java”. 
7
 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 
 
 Prof. Douglas O. Tybel 
 
ENTENDENDO 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 sua utilização: javax.swing.table. A JTable é um componente MVC
8
: 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: 
 
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” 
 
8
 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. 
Componente 
jTable 
Componente jButton 
10 
 
 Prof. Douglas O. Tybel 
 
 
Vamos neste momento definir uma variável para armazenar a estrutura atual da tabela: 
1. DefaultTableModel modelo = (DefaultTableModel) jTable1.getModel(); 
2. modelo.setNumRows(0); //Limpar as linhas 
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 
 
 Prof. Douglas O. Tybel 
 
EXEMPLO POPULAR JTABLE A PARTIR RESULTADO DE 
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 
 
 Prof. Douglas O. Tybel 
 
PRATICAR 
 
1. Crie um banco de dados no MySql chamado CONTATOS; 
2. Crie uma tabela chamada pessoas, com a seguinte estrutura 
(codPessoa,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 figura: jTable1 1 da 
pagina: 09, não será necessário os menus; 
8. O código do botão Consultar deve: Conectar e popular o JTable, conforme exemplo 
na pagina: 11 
 
13 
 
 Prof. Douglas O. Tybel 
 
CADASTRO SIMPLES EM JAVA SEM USO DE CLASSE 
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 
 
 Prof. Douglas O. Tybel 
 
CRIAR CLASSE DE ENTIDADE JAVA 
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 Contatos, 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; 
 
1. public class Contatos { 
//Implementar os atributos e métodos 
} 
 
Implemente os atributos na classe conforme abaixo, em destaque vermelho: 
 
2. 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: 
A criação de um modificador de acesso aos métodos privados é chamada de 
encapsulamento. 
15 
 
 Prof. Douglas O. Tybel 
 
 
 
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 usando a técnica de encapsulamento serão gerados automaticamente na classe 
acima. 
 
16 
 
 Prof. Douglas O. Tybel 
 
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: 
//O código abaixo será usado no evento click do botão, não será colocado na classe Contatos. 
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 da declaração do método setCadastrar() que deverá ser inserido na classe 
Contatos: 
1. public void setCadastrar(){ 
 //Comandos a serem executados 
} 
 
Para usarmos o conceito de classe abstrata e poliformismo, estenderíamos a classe Contatos 
para a uma classe pessoas: “Public class Contatos extends Pessoas{ códigos... };” fazendo 
com que a classe Contatos herdasse todos os métodos públicos da classe Pai chamada 
Pessoas. 
 
17 
 
 Prof. Douglas O. Tybel 
 
Usaremos então o mesmo código utilizado no botão cadastar, contudo faremos algumas 
alterações: 
Insira o código abaixo dentro do método setCadastrar que você acabou de criar acima, na classe 
Contatos: 
 
2. 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: 
//Código do evento actionPerformed do botão cadastrar, não deverá haver mais nenhum outro código 
além deste abaixo: 
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. 
18 
 
 Prof. Douglas O. Tybel 
 
 
Após alteração o trecho será alterado conforme acima. 
Segue abaixo conteúdo do método setCadastrar: 
 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 
 
 Prof. Douglas O. Tybel 
 
EXEMPLO DA CLASSE CONTATOS 
 
package Pagina20; 
 
import java.sql.PreparedStatement; 
import java.sql.ResultSet; 
import java.sql.SQLException; 
import java.util.logging.Level; 
import java.util.logging.Logger; 
 
public class Contatos { 
private Integer codPessoa; 
private String pessoa; 
private String telefone; 
 
 public Integer getCodPessoa() { 
 return codPessoa; 
 } 
 
 public void setCodPessoa(Integer codPessoa) { 
 this.codPessoa = codPessoa; 
 } 
 
 public String getPessoa() { 
 return pessoa; 
 } 
 
 public void setPessoa(String pessoa) { 
 this.pessoa = pessoa; 
 } 
 
 public String getTelefone() { 
 return telefone; 
 } 
 
 public void setTelefone(String telefone){ 
 this.telefone = telefone; 
 } 
 
public void setCadastrar(){ 
 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); 
 } 
 
} } 
20 
 
 Prof. Douglas O. Tybel 
 
 
Código do botão “Cadastrar” usando as técnicas de orientação a 
objeto 
 
O código do botão cadastrar usando as técnicas OO
9
, 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 há necessidade de uma conexão toda vez que for executar um método, basta 
conectar na abertura do frame por exemplo. 
 
 
9
 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 
21 
 
 Prof. Douglas O. Tybel 
 
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: 18 
6. O código do botão Cadastar, deve: Conectar e executar o método setCadastar() da 
classe Contatos, conforme exemplo na pagina: 20 
 
22 
 
 Prof. Douglas O. Tybel 
 
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 abaixo: 
 String comandoSQL = "Select * from pessoas "; 
 if ( getCodPessoa() > 0 ){ 
 comandoSQL += " where codPessoa = ?"; 
 } 
 java.sql.PreparedStatement stmtQuery = Conexao.con.prepareStatement(comandoSQL); 
 
 if ( getCodPessoa() > 0 ){ 
 stmtQuery.setInt(1, getCodPessoa()); 
 } 
 
 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. 
23 
 
 Prof. Douglas O. Tybel 
 
Obs.: Lembre-se de deixar o tratamento de exceção com uma throws chamada 
SQLException, conforme a figura abaixo: 
 
Segue abaixo código completo após criação: 
public ResultSet getConsultar() throws SQLException{ 
 String comandoSQL = "Select * from pessoas "; 
 if ( getCodPessoa() > 0 ){ 
 comandoSQL += " where codPessoa = ?"; 
 } 
 java.sql.PreparedStatement stmtQuery = Conexao.con.prepareStatement(comandoSQL); 
 
 if ( getCodPessoa() > 0 ){ 
 stmtQuery.setInt(1, getCodPessoa()); 
 } 
 
 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); 
 } 
 
24 
 
 Prof. Douglas O. Tybel 
 
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: 20 
 
25 
 
 Prof. Douglas O. Tybel 
 
RECUPERAR DADOS DO JTABLE 
Para recuperar os dados de um jTable e preencher os campos do formulário é necessário 
seguir a lógica abaixo: 
1. A primeira coluna do jTable deve ser o código do item desejado; 
2. Pegar o código da primeira coluna quando o usuário clicar em cima do registro e 
armazenar em uma variável do tipo int; 
3. Com o código do item devemos efetuar uma consulta no banco de dados; 
4. Usar o resultado e preencher os campos do formulário; 
Observe abaixo o que deve acontecer: 
1. 
2. 
3. 
 
Vamos considerar a classe Contatos já criada anteriormente nos exercícios acima, conforme 
grade abaixo. 
Contatos 
codPessoa 
pessoa 
telefone 
setCadastrar() 
setConsultar() 
 
Criaremos um novo projeto chamado Pagina25, crie um novo jFrame chamado JFRecuperar. 
Este formulário será desenhado conforme figuraacima, o botão consultar deve popular a grade 
conforme exemplo acima das paginas anteriores usando a orientação a objetos. O que 
devemos saber no momento é que o clique no registro deverá preencher os campos do 
formulário. 
 
 
26 
 
 Prof. Douglas O. Tybel 
 
Desenvolver o código para recuperar os dados do jTable 
 
Para realizar esta tarefa, siga os passos abaixo: 
1. Use o nome dos componentes conforme grade abaixo: 
Rótulo Nome 
Código codigojTextField 
Nome pessoajTextField 
Telefone telefonejTextField 
Consultar consultarjButton1 
 
2. Entre no evento mouseClicked (clique do mouse na grade) do jTable1, conforme 
imagem abaixo: 
 
3. Insira o código abaixo: 
 
 int codPessoa = Integer.parseInt(jTable1.getValueAt(jTable1.getSelectedRow(), 0).toString()); 
 Contatos oContato = new Contatos(); 
 oContato.setCodPessoa(codPessoa); //Filtrar pelo código 
 java.sql.ResultSet rs = oContato.getConsultar(); 
 rs.first(); 
 codPessoajTextField.setText( rs.getString("codPessoa") ); 
 pessoajTextField.setText( rs.getString("pessoa") ); 
 telefonejTextField.setText( rs.getString("telefone") ); 
 
4. Será necessário bloquear o trecho com try-catch, conforme imagem abaixo: 
 
 
 
27 
 
 Prof. Douglas O. Tybel 
 
ERROS CONHECIDOS 
ERRO: 
no suitable method found for add 
CAUSA: 
Os botões novo, salvar etc, foram copiados de um formulário CRUD JPA para outro form 
SOLUÇÃO: 
Ir em cada um dos botões acertando de acordo com a classe nova ou deletar e refazer 
======================================================================== 
ERRO: 
java.lang.ClassCastException: com.mysql.jdbc.JDBC4PreparedStatement cannot be cast to 
get.PreparedStatement 
CAUSA: 
Foi criado as classes: SQLException,PreparedStatement ao invés de importá-las 
Ao clicar no assistente de importação do IDE Netbeans (lampada) foi escolhida a opção "criar 
classe" 
SOLUÇÃO: 
Na pacote do projeto, deve ter classes do tipo SQLException ou PrepareStatement, então 
exclua. 
Os importes serão solicitados novamente, clique em importar. Não clique em criar classe 
SQLException. 
======================================================================== 
ERRO: 
java.sql.SQLException: Access denied for user 'root'@'localhost' (using password: YES) 
CAUSA: 
Usuário ou senha do mysql não está correto 
SOLUÇÃO: 
Na Unidade de persistência ou classe de conexão corrija o usuário ou senha para conectar ao 
mysql 
======================================================================== 
ERRO: 
java.lang.ClassNotFoundException: com.mysql.jdbc.Driver 
No suitable driver found for jdbc:mysql 
28 
 
 Prof. Douglas O. Tybel 
 
 
CAUSA: 
Ausência dos drivers mysql nos libs (bibliotecas) do projeto 
SOLUÇÃO: 
Na pasta library ou biblioteca do projeto, adicione o pacote do mysql 
======================================================================== 
ERRO: 
Exception in thread "AWT-EventQueue-0" javax.persistence.PersistenceException: No 
Persistence provider for EntityManager named ecomercialPU: 
CAUSA: 
Ao realizar @JoinColumn deve-se excluir o @Basic(optional = false) 
Erro acontece com JPA e CRUD, nada mais funciona(jframes) 
SOLUÇÃO: 
Existe algum: @Basic(optional = false) 
Em alguma classe e, campos com @ManyToOne,@JoinColumn não pode ter @Basic. 
SOLUÇÃO 2: 
Em ultimo caso: 
1 - Remover da biblioteca a swing application framework 
2 - Adicionar novamente 
3 - Vassourar(compilar e limpar) 
======================================================================== 
ERRO: 
cvc-complex-type.3.1: Value '2.0' of attribute 'version' of element 'persistence' is not valid with 
respect to the corresponding attribute use. 
Attribute 'version' has a fixed value of '1.0' 
SOLUÇÃO: 
1 - Remover da biblioteca a Vinculação de Beans 
2 - Recompilar - Vassourar(compilar e limpar) 
3 - Obs(ele vai se auto adicionar, quando vc for até o designer do frame e entrar no codigo 
fonte) 
======================================================================== 
 
29 
 
 Prof. Douglas O. Tybel 
 
ERRO: 
org.jdesktop.beansbinding.Binding.convertReverse float 
Bind jformatedTextField no netbeans 
CAUSA: 
O value de um campo é preenchido antes mesmo da mascara, por isso o erro, já o text não. 
SOLUÇÃO: 
Vincule o text não o value. 
 
30 
 
 Prof. Douglas O. Tybel 
 
CONCLUSÃO 
Nesta apostila conferimos como efetuar uma conexão entre o Java e o banco de dados 
MySQL. Vimos também como representar uma classe e objeto em Java de uma tabela do 
banco de dados, tudo isso usando o paradigma da orientação a objetos. 
Construindo comandos SQL nos métodos das classes, aliado ao IDE de desenvolvimento do 
NetBeans, desenvolvemos telas capazes de manipular os dados armazenados no banco de 
dados. 
É importante ressaltar a importância do uso deste paradigma POO (Programação Orientada a 
Objetos), veja que ao aprender Java, você também está aprendendo diversas linguagens 
associadas ao POO, sendo capaz de programar em: C, C++, C#,PHP e o mais diferente entre 
esses o Pascal(IDE do CodeGear – Delphi). 
Aprendido como usar as classes POJO é um enorme salto para o aprendizado de novos 
modelos de arquitetura como Model-view-controller (MVC) que conta com algumas diferenças 
que serão absorvidas facilmente com o conteúdo aprendido sobre Plan Old Java Objects. 
Imagine aprender uma linguagem e levar este pacote inteiro! Não seria uma maravilha? Isso é 
real, um programador Java consegue aprender estas outras linguagens em menos de duas 
semanas.