CURSO TCNICO DE NVEL MDIO EM INFORMTICA

Apostila Guia

Disciplina

Programao Estruturada e Orientada a Objetos

Docente

Jurasildo Oliveira Reinaldo

Mossor, julho de 2016

Lista de Tabelas
Tabela 1: Tipos primitivos de dados em Java ............................................................................... 9
Tabela 2: Propriedade do Hibernate ........................................................................................... 39

Lista de Figuras
Figura 1: Funcionamento de uma aplicao Java .......................................................................... 7
Figura 2: Declarao de uma classe em Java ................................................................................ 8
Figura 3: Declarao de atributos.................................................................................................. 8
Figura 4: Instncias da classe Aluno ............................................................................................. 9
Figura 5: Vetores ......................................................................................................................... 10
Figura 6: If - else ......................................................................................................................... 11
Figura 7: Switch .......................................................................................................................... 12
Figura 8: While ........................................................................................................................... 12
Figura 9: Lao for........................................................................................................................ 13
Figura 10: Do - while .................................................................................................................. 13
Figura 11: Declarao de um mtodo ......................................................................................... 14
Figura 12: Classe com mtodo main ........................................................................................... 14
Figura 13: Sobrecarga de mtodos ............................................................................................. 15
Figura 14: Declarao de pacotes................................................................................................ 15
Figura 15: Classe Aluno dentro do pacote disciplina .................................................................. 16
Figura 16: Construtores ............................................................................................................... 18
Figura 17: Herana ...................................................................................................................... 19
Figura 18: Implementao da herana......................................................................................... 20
Figura 19: Classe abstrata ........................................................................................................... 21
Figura 20: Interface ..................................................................................................................... 22
Figura 21: Polimorfismo .............................................................................................................. 23
Figura 22: Excees try - catch .................................................................................................... 24
Figura 23: Exceo throws........................................................................................................... 24
Figura 24: Janela com diferentes LAF.......................................................................................... 25
Figura 25: JOptionPane ............................................................................................................... 25
Figura 26: JFrame ........................................................................................................................ 26
Figura 27: Banco de dados MySQL .............................................................................................. 29
Figura 28: Conexo de uma aplicao Java com um banco de dados relacional ........................ 30
Figura 29: Criando uma conexo com JDBC ................................................................................ 31
Figura 30: Modelo da Tabela contato ......................................................................................... 32
Figura 31: Classe ConnectionFactory .......................................................................................... 34
Figura 32: Operao Insert .......................................................................................................... 35
Figura 33: Operao select .......................................................................................................... 36
Figura 34: Operao update ........................................................................................................ 36

Sumrio
1.

Evoluo Histrica das Linguagens de Programao ........................................................... 5

2.

Paradigma Orientado a Objetos versus Estruturado .............................................................. 5

3.

Paradigma Orientado a Objetos - Java .................................................................................. 6

3.1.

Como o Java funciona ................................................................................................... 6

3.2.

Configurando o Ambiente Java ..................................................................................... 7

3.3.

Classes ........................................................................................................................... 7

3.4.

Atributos........................................................................................................................ 8

3.5.

Tipos de dados em Java ................................................................................................. 9

3.6.

Vetores .......................................................................................................................... 9

3.7.

Estruturas de Controle e Deciso ................................................................................ 11

3.8.

Estruturas de repetio ................................................................................................ 12

3.9.

Mtodos ....................................................................................................................... 13

3.10.

Pacotes..................................................................................................................... 15

3.11.

Modificadores de acesso ......................................................................................... 16

3.12.

Construtores ............................................................................................................ 17

3.13.

Herana.................................................................................................................... 18

3.14.

Classes Abstratas ..................................................................................................... 20

3.15.

Interfaces ................................................................................................................. 21

3.16.

Polimorfismo ........................................................................................................... 22

3.17.

Excees .................................................................................................................. 23

3.18.

Interface grfica usando Swing ............................................................................... 24

3.19.

Eventos .................................................................................................................... 28

3.20.

Acesso a Banco de Dados ....................................................................................... 28

3.21.

Mapeamento Objeto Relacional .............................................................................. 37

Referencial bibliogrfico ......................................................................................................... 43

1. Evoluo Histrica das Linguagens de Programao

A utilizao da computao nas mais variadas reas, desde controlar usinas
nucleares at disponibilizar jogos eletrnicos em telefones celulares, contribuiu
diretamente no surgimento de inmeras linguagens de programao.
Cada linguagem desenvolvida pensando em resolver um determinado
problema, devido complexidade ou limitao que as outras possuem. Antes de
1940, a programao dos computadores digitais era feita utilizando uma
programao de baixo nvel chamada Assembly. Uma linguagem muito eficiente em
termos de desempenho de mquina, mas muito difcil de ser interpretada pelo
homem. O que exigia pessoas altamente capacitadas para desenvolver os programas.
Diante desse contexto, foram surgindo novas abordagens para se desenvolver
software. Logo surgiram as chamadas linguagens de alto nvel, como Fortran,
Cobol, C++, e Java. As linguagens de alto nvel receberam esse nome por causa da
abstrao que elas oferecem ao desenvolvedor, possibilitando que o software seja
escrito de uma forma mais legvel e parecida com a linguagem humana e no apenas
referenciando posies de memria e valores binrios.
Com o surgimento das linguagens de alto nvel, ampliou-se a quantidade de
paradigmas de programao. Inicialmente, predominava-se o paradigma imperativo,
ou procedural, projetado considerando a principal arquitetura de computadores, at
os dias de hoje, chamada de Arquitetura de von Newmann, cujo nome derivado de
um de seus criadores, John von Newmann. Posteriormente, surgiram diversos outros
paradigmas: funcional, Lgico, Estruturado, e Orientado a Objetos. Durante a
disciplina, sero abordados apenas os dois ltimos paradigmas, dando maior nfase
ao Paradigma Orientado a Objetos.
Inicialmente, a voc aluno, ser apresentada de forma superficial apenas a
definio desses paradigmas, medida que os conceitos bsicos de programao
estiverem assimilados, introduziremos as principais diferenas de cada um deles.

2. Paradigma Orientado a Objetos versus Estruturado

O paradigma Estruturado, tambm conhecido como programao modular, tem
como principal caracterstica a compartimentao de cdigo e de dados. Trata-se da
habilidade de uma linguagem seccionar e esconder do resto do programa todas as
informaes necessrias para se realizar uma tarefa especfica. Uma das maneiras
que a programao Estruturada consegue realizar esse artifcio por meio do uso de
sub-rotinas que empregam variveis locais. Dessa maneira, os programas podem
compartilhar facilmente sees de cdigo.

O Paradigma Orientado a Objetos introduz o conceito de objeto nas linguagens

de programao e substitui as funes das linguagens estruturadas por mtodos.
Dessa forma, surgiram outras caractersticas que sero vistas no prximo capitulo, e
que s a Orientao a Objetos fornece, como a herana e o polimorfismo.

3. Paradigma Orientado a Objetos - Java

Criada por James Gosling, a linguagem Java veio para resolver determinados
problemas que assolavam programao da dcada de 1990. Como, ponteiros,
gerenciamento de memria, falta de bibliotecas e ter que reescrever parte do cdigo
quando mudava de sistema operacional.
O primeiro nome dado por Gosling foi OaK (carvalho), mas por direitos autorais
o nome no pode ser registrado. O nome que acabou ficando foi Java, o nome da
Terra onde se produzia o caf que os programadores da equipe tomavam.
Em 1995 a Sun, empresa liderada por James Gosling e seus amigos, viu uma
oportunidade na Web. Nessa poca, as pginas no possuam muita interatividade,
ento, a Sun resolveu anunciar o Ambiente Java, sendo um sucesso nos navegadores
mais populares.
O principal fator que impulsionou a popularizao da linguagem Java, foi a
independncia de plataforma. Uma aplicao feita em um sistema operacional
conseguiria funcionar em qualquer outro. Para isso, bastava-se utilizar uma mquina
virtual que emulasse o software para cada tipo de arquitetura. Assim, o software era
o mesmo, apenas a mquina virtual que deveria ser desenvolvida de acordo com
cada sistema operacional.

3.1.

Como o Java funciona

Uma aplicao Java funciona de acordo com os passos da Figura 1.

Inicialmente, o programa codificado deve ser salvo com a extenso .java. Em
seguida, o cdigo fonte submetido ao compilador Java, chamado javac, para
verificar se o cdigo contm erros. Caso o compilador no detecte nenhum erro,
um executvel do cdigo fonte gerado com a extenso .class, chamado
Bytecode. O arquivo .class, ento executado na JVM - Mquina Virtual
Java, especfica para cada plataforma operacional de trabalho: Linux, Windows,
macOS, Android ioS, ou WindowPhone.

Figura 1: Funcionamento de uma aplicao Java

3.2.

Configurando o Ambiente Java

Para desenvolver qualquer aplicao Java preciso inicialmente instalar

o JDK Java Development Kit. Um pacote de ferramentas para
desenvolvedores Java, composto pela Mquina Virtual Java (JRE Java
Runtime Environment ); o compilador, um depurador de cdigo fonte e as API
Java.
Esse
kit
pode
ser
baixado
pelo
link:
http://www.oracle.com/technetwork/pt/java/javase/downloads/index.html.

3.3.

Classes

Uma classe utilizada para representar um conjunto especfico seres ou

coisas que compartilham as mesmas caractersticas e comportamentos. So
exemplos de classes: Co, gato, Carro, Empregado e Endereo.
Uma classe declarada em Java atravs da palavra reservada class
seguida por um nome qualquer, que represente o conjunto que se est a
trabalhar, e um abre e fecha chaves, onde ficaro todas as caractersticas e
comportamentos da classe. A Figura 2 mostra a definio de uma classe
chamada Aluno.

Figura 2: Declarao de uma classe em Java

padro em Java que o nome da classe principal tenha o mesmo nome do

arquivo onde est sendo definida a classe. Veremos nas sees seguintes que s pode
existir uma classe pblica por arquivo Java e que ela deve ser a classe principal.

3.4.

Atributos

Atributos, tambm conhecidos

caractersticas de uma classe.

como

variveis

representam

as

Uma varivel pode ser comparada a uma bolsa feminina. Uma bolsa um
acessrio onde as mulheres colocam a casa inteira l dentro! Brincadeira!!
Colocam somente o necessrio, para serem utilizados posteriormente. Assim
como uma bolsa, uma varivel no tem sentido em existir, se no contiver nada
dentro. Uma varivel ou atributo criado com um objetivo especfico, servir de
espao bolsa para se colocar dados. Quando se deseja colocar mais objetos na
bolsa, mas ela j est totalmente cheia. preciso esvazia-la, para depois colocar
outros objetos. Com uma varivel acontece a mesma coisa. Caso no se queira
perder os dados da varivel, necessrio tir-los previamente para dar espao
aos novos.
Tomando como base a classe Aluno, declarada anteriormente, pode-se
definir como caractersticas bsicas de um aluno, o seu nome e sua idade. uma
boa prtica de programao declarar todos os atributos na parte superior da
classe e em minsculo, veja a Figura 3.

Figura 3: Declarao de atributos

O Java exige que se especifique o tipo do atributo antes do seu nome. Na

prxima seo voc ficar sabendo por que eles foram declarados com os tipos
String e int.

3.5.

Tipos de dados em Java

A Linguagem Java trabalha com dois tipos de dados: primitivos e

complexos.
Os dados primitivos so estruturas simples, que geralmente comportam
apenas valores reais, inteiros, lgicos e caracteres. A Tabela 1 mostra os tipos
bsicos da linguagem Java.
Tabela 1: Tipos primitivos de dados em Java

Tipo
Inteiro
Ponto flutuante 32bits
Lgico
Binrio
Ponto flutuante 64bits
Caractere

Declarao
int
float
boolean
byte
double
char

Exemplo
int x;
float x;
boolean x;
byte x;
double x;
char x;

Alm dos tipos primitivos, um atributo pode ser um tipo complexo de

dado, ou seja, um objeto referente a um tipo de classe. Por exemplo, a Figura 3
mostra a declarao do atributo nome do tipo String. Esse tipo de dado
representa uma instncia da classe String, um tipo complexo de dado.
Uma instncia pode ser entendida como algo nico. Levando-se em
considerao a classe Aluno criada anteriormente, podem-se criar diversas
instncias dessa classe, como: Aluno num1, Aluno num2 e assim por diante,
como est na Figura 4. A classe fornece o modelo para as diversas instncias.

Figura 4: Instncias da classe Aluno

3.6.

Vetores

Vetores so estruturas de dados que armazenam, internamente, diversos

valores, cada um associado a um nmero que se refere a posio de
armazenamento, conhecida como ndice.
Assim como as linguagens C e C++, o Java possui vetores zero-based, ou
seja, sua posio inicial comea em zero.
9

A declarao de um vetor comea por seu tipo, seguido por um nome e a

sua dimenso. A maioria dos vetores possuem apenas duas dimenses, mas nada
impede que esse nmero seja bem maior, sendo chamados de vetores
bidimensionais.
Abaixo est a declarao de um vetor do tipo inteiro (int) com o nome
alunos e apenas uma dimenso de tamanho 10.
int alunos[10];

A Figura 5 mostra a correspondncia entre valor e ndice de um vetor.

Figura 5: Vetores

Um vetor pode ser instanciado da seguinte forma:

Int vetor[] = new int[10];

O Java permite inicializar vetores no momento da instanciao. Veja

abaixo:
String nome[ ]= {Paulo, Maria, Luana}

A declarao de vetores bidimensionais um pouco diferente, mas o

princpio o mesmo. Apenas so adicionadas novas dimenses, veja abaixo:
String nome[][]= new String[2][3];

Cada conjunto de colchetes representam uma dimenso. Cada dimenso

mais esquerda corresponde a multiplicao pela dimenso direita. Isso
significa, que para cada ndice da esquerda, deve-se percorrer toda dimenso da
direita, e assim sucessivamente.
A inicializao de vetores bidimensionais ocorre da forma baixo:
int nota[][] = {{70,50,100},{40,56,98}};

10

Os parnteses internos representam a primeira dimenso e a quantidade

de valores, a segunda.
Obs: os colchetes podem ficar antes ou depois do nome do vetor.

3.7.

Estruturas de Controle e Deciso

Assim como as linguagens estruturadas, Java possui diversas

estruturas de controle e deciso.

If - else
Nessa estrutura, uma expresso avaliada como verdadeira ou falsa.
Caso ela seja verdadeira a seo de cdigo correspondente ao if ser
executada. Se no, o cdigo correspondente ao else. Na Figura 6, tem-se
uma expresso que avalia se o nmero 3 maior que 1. Evidentemente, a
resposta est correta, logo o trecho de cdigo a ser executado ser o que est
dentro do if. Caso, a resposta fosse no, ento o cdigo correspondente ao
else seria executado.

Figura 6: If - else

As linhas de cdigo dentro do if - else esto imprimindo na tela as frases

entre aspas: Sim maior! e No maior!.

Switch
Essa estrutura de controle bastante similar ao if - else. Incialmente, um
valor passado para dentro do switch. Com o valor em mos, o switch testa
todos os case buscando um valor igual ao que lhe foi passado. Observando a
Figura 7 e o valor passado ao switch, conclui-se que o case a ser executado
ser o da linha 6.
A palavra reservada default utilizada quando se deseja que uma
determinada ao acontea, caso nenhuma das outras ocorra. Nesse exemplo,
se o valor 5 fosse passado ao switch o default seria executado.
Outra palavra reservada o break ou quebra. Como o prprio nome diz,
ela serve para quebrar a sequncia de execuo. Isso importante em casos,
11

onde o valor passado ao switch modificado dentro dos case. Assim, o

break evita que mais de um case possa ser executado em um mesmo teste.

Figura 7: Switch

3.8.

Estruturas de repetio

While
O while uma estrutura de repetio, que tem como caracterstica a
avaliao de uma expresso antes de executar o trecho de cdigo
correspondente. Na Figura 8 o while avalia se 3 maior que 1. Como a
expresso verdadeira, o trecho de cdigo da linha 2 ser executado. Ao
finalizar todo o cdigo de dentro do while, a expresso ser avaliada
novamente. Como nenhum valor foi alterado, a expresso tambm ser
verdadeira e assim continuar at que o programa seja forado a finalizar.

Figura 8: While

For

O for tambm uma estrutura de repetio e tem como caracterstica, a

capacidade de colocar na sua declarao, o nmero de repeties que ela deve
executar. Essa capacidade conseguida porque na sua declarao, o for
inicializa as variveis utilizadas, avalia se a expresso verdadeira e modifica os
valores de algumas variveis. Na Figura 9, o for ir imprimir o valor de 1 a 5.
Primeiro o valor da varivel x inicializado em 1 e em seguida a expresso
avalia se o valor de x menor que 5. Como a resposta verdadeira o trecho de
cdigo ser executado e o valor de x ser aumentado em 1 unidade, como mostra
o terceiro parmetro. Esse procedimento vai acontecer at que o valor da
expresso seja falso e assim, o for consequentemente finalizado.

12

Figura 9: Lao for

Do - while

Diferentemente do while, o do - while permite que todo o cdigo dentro dele

seja executado pelo menos uma vez e s depois a expresso seja avaliada. Caso
o valor da expresso seja verdadeiro, uma nova interao ocorrer. Se no, a
estrutura ser finalizada e a execuo seguir sua sequncia normal. A Figura 10
mostra a declarao de um do - while.
Inicialmente, todo o cdigo dentro do bloco executado. Assim, o valor da
varivel a aumentado em uma unidade e seu valor impresso na tela. Apenas no
final do bloco, a expresso avaliada. Caso o valor de a seja menor que 5, uma
nova interao ocorrer, e assim esse ciclo continuar, enquanto a expresso da
linha 7 possuir um valor verdadeiro.

Figura 10: Do - while

3.9.

Mtodos

Os mtodos so os comportamentos que uma determinada classe pode

oferecer. A assinatura de um mtodo em Java composta por um nome,
podendo ter ou no parmetros e um tipo de retorno. Parmetros so os valores
que ficam entre parnteses, passados no momento da chamada do mtodo. Por
exemplo, a Figura 11 mostra a declarao de um mtodo chamado soma que
recebe como parmetros dois valores inteiros e retorna sua soma por meio da
palavra reservada return. Essa palavra garante retornar ao ponto de onde a
funo foi chamada. Quando no se deseja retornar nada pelo mtodo, utiliza-se
a palavra reservada void.

13

Figura 11: Declarao de um mtodo

Em toda aplicao Java obrigatrio declarar um mtodo chamado

main, pelo fato de ser o primeiro mtodo a ser executado na aplicao. Sua
assinatura est descrita na linha 10, da Figura 12. Algumas palavras ainda so
desconhecidas como para a gente como public e static, mas no se preocupe,
elas sero vistas mais adiante. At esse momento, apenas suficiente saber que,
o mtodo main no retorna nenhum parmetro devido a presena do void antes
de seu nome. E que ele recebe um tipo de dado como parmetro chamado
String[].
Como j foram declarados dois mtodos na classe Aluno, e o mtodo
main o primeiro a ser chamado. Caso queira-se realizar a soma de dois
nmeros, basta chamar o mtodo soma, dentro do mtodo main, como est na
linha 11 da Figura 12. Dessa forma, o mtodo soma est sendo chamado pelo
mtodo main, passando como parmetros os valores 10 e 15. Com a finalizao
do mtodo soma, a execuo do programa volta para o mtodo main, mais
especificamente pra linha 11.

Figura 12: Classe com mtodo main

Um termo bastante utilizado em Java a sobrecarga de mtodos.

Sobrecarregar um mtodo significa definir dois ou mais mtodos com a mesma
assinatura, ou seja, mesmo nome, mesmo tipo de retorno, mas com argumentos
diferentes.
A Figura 13 foi criada com uma classe chamada Calculadora, que
contm dois mtodos chamados soma. Isso s possvel se os tipos e
quantidades de parmetros forem diferentes. Como um mtodo possui dois
parmetros e o outro trs, a sobrecarga ocorre normalmente.

14

Figura 13: Sobrecarga de mtodos

Existe um tipo de mtodo que pode ser chamado independente de se

instanciar uma classe. So os chamados mtodos estticos.
Para um mtodo ser considerado esttico, ele deve possuir na sua
assinatura a denominao static. Como pode ser visto, logo abaixo:
public void static soma(){};

Para chamar esse mtodo, basta colocar o nome da classe (Calculadora)

seguida por um ponto, e o nome do mtodo (soma).
Calculadora.soma();

3.10. Pacotes
Pacotes so utilizados para agrupar classes com objetivos especficos.
Por exemplo, um pacote chamado formas geomtricas. Dentro desse pacote,
provavelmente iro est classes chamadas crculo, retngulo, elipse, quadrado, e
tringulo.
Em Java, um pacote criado atravs da palavra reservada package
seguido do nome do pacote, como na Figura 14. Essa definio deve estar no
incio do arquivo, e as classes que o iro compor ficaro abaixo.

Figura 14: Declarao de pacotes

A Figura 15 mostra a declarao da classe Aluno, dentro do pacote disciplina.

15

Figura 15: Classe Aluno dentro do pacote disciplina

Muitas vezes, necessrio que se utilize de classes j existentes,

desenvolvidas por terceiros, como forma de melhorar a produtividade e
consequentemente reduzir o tempo de desenvolvimento. Mas como utilizar uma
classe desenvolvida por outra pessoa em minha aplicao? Utilizando a palavra
reservada import. Caso seja necessrio trabalhar com a classe String, ser
preciso escrever o comando abaixo. Essa declarao est chamando nesse ponto
do cdigo, uma classe chamada String que est dentro de um pacote chamado
java.lang. Por isso, ela deve ficar antes da declarao da classe que a ir utilizar.
import java.lang.String;
Quando se deseja utilizar mais de uma classe do mesmo pacote, e a
pessoa no quer escrever um monte de imports. O Java oferece a opo de
importar todas as classes do pacote atravs do comando abaixo. Dessa forma,
todas as classes pertencentes ao pacote java.lang sero importadas para o
projeto.
import java.lang.*;
Os exemplos mostrados utilizando a classe String foram apenas
utilizados como forma didtica. Na prtica, o Java importa implicitamente todas
as classes do pacote java.lang.

3.11. Modificadores de acesso

Uma das grandes comodidades da orientao a objetos o
encapsulamento. Encapsular informaes permite que elas possam ser ocultadas
de objetos no autorizados.
16

Em Java existem trs tipos de modificadores: public, protected e private.

Cada modificador pode ter funes diferentes para cada tipo de elemento.

Public: Todos podem acessar aquilo que estiver definido como public.
Classes, atributos, mtodos e construtores podem ser public.
Private: permite que apenas a classe tenha acesso aos atributos, construtores
e mtodos declarados como private.
Protected: Aquilo que protected pode ser acessado por todas as classes do
mesmo pacote e por todas as classes que o estendam, mesmo que essas no
estejam no mesmo pacote. Somente atributos, construtores e mtodos podem
ser protected.

3.12. Construtores
Quando se cria uma classe, apenas se est fornecendo um modelo de
dados com atributos e comportamentos. Para que esse modelo de classe exista e
possa ser utilizado no programa, ele precisa ser instanciado. Instanciar uma
classe significa criar algo vivo de um modelo. No exemplo da classe Aluno,
Figura 15, foi criado um atributo chamado nome do tipo String. At esse
momento, essa varivel no foi instanciada, ou seja, a varivel est vazia.
Para instanciar uma classe em Java utiliza-se o conceito de construtor. O
construtor um mtodo, geralmente pblico e sem retorno, que pode receber ou
no parmetros. A Figura 16 mostra um cdigo onde duas classes foram
declaradas: Aluno, j conhecida, e Turma. A classe Aluno cria uma instncia
da classe Turma na linha 31, por meio da palavra reservada new. A partir do
momento que uma instncia criada, ela oferece acesso a seus atributos e
mtodos, de acordo com a limitao de privacidade, a qual lhe foi concedida.
Dessa forma, a classe Aluno consegue acessar o mtodo getTurma, da classe
Turma, na linha 32, e imprimir o nome dela.

17

Figura 16: Construtores

3.13. Herana
O conceito de herana surgiu da mesma ideia da herana entre pai e filho.
Sendo o pai o cabea da famlia, sua responsvel passar suas caractersticas
genticas aos seus filhos. Assim como seus filhos iro passar seus genes para
seus descendentes, e assim por diante. Diante disso, pode-se afirmar que todos
os descentes herdaram genes dos seus antecessores.
De forma similar acontece a herana na Orientao a Objetos. A Figura
17 contm trs classes: Super Heri, Capito America e Homem de Ferro.
18

Como tanto a classe Capito America, quanto Homem de Ferro possuem

atributos e mtodos similares, criou-se uma classe chamada Super Heroi que ir
contm os atributos e mtodos comuns a classe Capito America e Homem de
Ferro. Dessa forma, cada classe conter apenas atributos e mtodos especficos
e herdar da classe Super Heroi os atributos e mtodos comuns a ambas. A
classe genrica tambm chamada de superclasse e as especializaes de
subclasses.
Quando uma classe herda uma outra classe, a subclasse sobrepe os
mtodos da superclasse. Assim, a subclasse pode adapt-los a sua realidade. Na
Figura 17, o mtodo usarPoderEspecial da superclasse, foi sobreposto pelas
classes Capito America e Homem de Ferro, devido as particularidades dos
poderes de cada um deles.

Figura 17: Herana

Em Java, a herana realizada por meio da palavra reservada extends. A

Figura 18 mostra como implementada a herana em Java, por meio da
sobreposio de mtodos. Percebe-se, que dependendo da subclasse, as
implementaes dos mtodos podem mudar.

19

Figura 18: Implementao da herana

Quando uma subclasse possui um mtodo com a mesma assinatura da

classe pai, o mtodo da subclasse esconde a implementao do mtodo da
superclasse (classe pai). Em certos casos, quando se necessita acessar
diretamente o mtodo da superclasse, usa-se a palavra reservada super. seguida
do nome do mtodo.

3.14. Classes Abstratas

As classes abstratas so classes que no podem ser instanciadas. Em
outras palavras, uma forma de impedir que algum use o operador new. Mas,
qual a vantagem de no instanciar uma classe? Em alguns casos, classes
diferentes possuem comportamentos similares, mas realizados de maneiras
diferentes. Tomando-se como exemplo um Pssaro. Pode-se definir como um
comportamento genrico o ato de voar. Mas, cada Pssaro possui suas
particularidades de voo. Assim, no lugar de criar para cada tipo de Pssaro um
20

mtodo de voo, cria-se apenas uma classe abstrata que contenha um mtodo
chamado voo, e estende-se essa classe para as demais.
A declarao de uma classe abstrata pode ser vista abaixo:
Abstract public class Passaro{
Abstract public void voar();
}
Uma classe abstrata declarada por meio da palavra reservada abstract.
Assim como uma classe pode ser abstrata, os mtodos tambm podem. No
entanto, mtodos abstratos no possuem corpo. O seu contedo ser especificado
nas classes que os estender.
Todos os mtodos abstratos pertencentes a uma classe devem
obrigatoriamente ser sobrepostos nas classes que os estenderam. Se um mtodo
abstrato, obrigatoriamente a classe qual ele pertence tambm deve ser abstrata.
A Figura 19 mostra a classe Papagaio que estende a classe abstrata
Passaro. Como se percebe, o mtodo abstrato da classe Passaro sobreposto na
classe Papagaio e seu corpo ento criado.

Figura 19: Classe abstrata

3.15. Interfaces
Uma interface Java como uma classe 100% abstrata, ou seja, ela deve
conter apenas mtodos abstratos. Por padro os mtodos das interfaces so
sempre pblicos e abstratos, tornando sua declarao opcional. Uma interface
utilizada quando um determinado grupo de objetos ou seres possuem
comportamentos iguais, mas realizados de maneiras diferentes. Dessa forma, as
classes que possuem os mesmos comportamentos apenas implementam a
interface e sobrepem os seus mtodos.

21

Uma interface declarada por meio da palavra reservada implements. A

Figura 20 mostra a criao de uma interface chamada Animal com dois
mtodos: come e dorme, e a classe Gato que implementa essa interface e
obrigatoriamente sobrepe seus mtodos. Alm desses mtodos, a classe Gato
tem seus prprios mtodos como darBanho.
As interfaces so elementos fundamentais para a utilizao do
polimorfismo, o prximo assunto sobre Orientao a Objetos.

Figura 20: Interface

3.16. Polimorfismo
O polimorfismo como o prprio nome sugere, significa vrias formas. Na
Orientao a Objetos, o polimorfismo oferece a capacidade de se utilizar um
objeto como se fosse outro. Por exemplo, na Figura 21, tem-se a classe
Papagaio que estende Passaro e implementa a interface Animal. Na linha 30
cria-se uma instncia da classe Papagaio e atribui-se varivel p1. Na linha
seguinte chamado o mtodo come referente instncia de p1. Na linha 32
ocorre a atribuio de uma instncia da classe Papagaio a uma varivel do tipo
Passaro. Esse procedimento possvel sim, pois Passaro estendida por
Papagaio, dessa forma, atravs da varivel p2 possvel acessar apenas os
mtodos sobrepostos presente na classe Papagaio.

22

Figura 21: Polimorfismo

3.17. Excees
Uma exceo representa uma situao anormal que ocorre no sistema,
indicando que algo de estranho ou errado aconteceu.
Existem no Java duas formas de se tratar essas situaes inesperadas. A
primeira delas por meio dos operadores try/catch. Todo o cdigo que est
sendo observado e que pode gerar uma exceo colocado dentro do try. No
catch define-se o tipo de exceo e o que fazer para trata-la. A Figura 22 mostra
o tratamento de uma exceo chamada FileNotFoundException, ou seja, quando
se tenta abrir um arquivo em disco, mas ele no encontrado. O comando que
pode gerar essa exceo fica na linha 4 e o mtodo que trata essa exceo fica na
linha 7.

23

Figura 22: Excees try - catch

A outra forma similar, mas a responsabilidade de tratar o erro fica com

quem chamou o mtodo de tratamento de exceo. A Figura 23 tambm possui
uma exceo do tipo FileNotFoundException, mas agora ela criada pelo
mtodo main por meio da palavra reservada throws. Na maioria dos casos, o
resultado o mesmo em ambas as abordagens, fica a critrio de cada um
escolher qual forma utilizar. No entanto, tratar excees no uma tarefa fcil,
por isso sempre necessrio bastante ateno quando precisar us-las.

Figura 23: Exceo throws

3.18. Interface grfica usando Swing

Atualmente, o Java suporta duas bibliotecas grficas: AWT e Swing. A
AWT foi a primeira biblioteca para interfaces grficas a surgir no Java. Sendo
mais tarde superada pela Swing, que incorporou mais funcionalidades e
benefcios com relao a AWT.
Essas APIs favorecem o mximo a portabilidade, permitindo que a
aplicao tenha a mesma interface em qualquer sistema operacional. Um termo
bastante usado para designar essa caracterstica da aplicao LAF - Look And
Feel (Olhe e Sinta). O JRE j vem com um padro LAF, mas nada impedi que
ele seja alterado. A Figura 24 mostra uma janela rodando com diferentes LAFs.

24

Figura 24: Janela com diferentes LAF

A biblioteca do Swing est no pacote javax.swing, onde se encontram

diversos tipos de componentes: JFrame, JButton, JPanel, JTable, e Scrollable.
Vejamos os principais:

JOptionPane
Esse componente usado para exibir mensagens ao usurio por meio de
uma janela de dilogo.

Figura 25: JOptionPane

O cdigo abaixo mostra como criar um JOptionPane. A forma mais

simples de se criar uma janela de dilogo chamando o mtodo exttico
showMessageDialog que recebe como parmetro a frame a ser exibida.
JOptionPane.showMessageDialog(null, "Hello my friend!");

JFrame
uma moldura (janela) que o sistema operacional abre para exibir todos
os componentes visveis de uma aplicao. Dentro de um JFrame podem
ficar botes, listas, tabelas, imagens, formulrio e menus.

25

Uma das maneiras de se criar uma janela instanciando um objeto da

classe JFrame, passando como parmetro o ttulo da janela.
JFrame janela = new JFrame("Nome da janela");

Figura 26: JFrame

JPanel
um componente adicionado ao JFrame. Alm de outras
funcionalidades, serve para organizar os componentes dentro do JFrame.
O cdigo abaixo mostra como adicionar um JPanel a um JFrame.
Inicialmente, cria-se um JPanel e adiciona essa instncia ao JFrame atravs
do mtodo add.
JPanel painel = new JPanel();
JFrame janela = new JFrame(Meu nome);
janela.add(painel);

JButton

Como o prprio nome diz, utilizado na criao de botes, sendo

tratados por meio de eventos e muito utilizados na criao de formulrios. Uma
das formas de se criar um JButton passando o texto que estar no boto por
meio do seu construtor.
JButton p =new JButton("Cancelar");

JTable

26

 um componente de interface grfica que permite manipular tabelas de

dados. Entre os principais mtodos dessa classe esto:

JTable():Constri a tabela propriamente dita.

JTable(int numRows, int numColumns): Constroi uma tabela passando o
nmero de linhas e colunas.
JTable(Object[][] rowData, Object[] columnNames): Constri um novo
JTable com o array de dados e os nomes das colunas indicados.
JTable(JTableModel dm): Constri um novo JTable com o modelo da tabela
indicado.
JTable(Vector rowData, Vector columnNames): Constri uma tabela usando
os nomes das colunas indicadas no vetor columnNames e os dados contidos
no vetor rowData.
Void addColumn(TableColumn coluna):Adiciona uma nova coluna na tabela
coluna.
TableModel getModel(): Retorna o modelo da tabela que est sendo usada
para exibir os dados da tabela.
Object getValue(int row, int column): retorna o valor da clula especificada
nos parmetros.
Void setModel(TableModel dataModel): Atribui o modelo dataModel a uma
tabela.

setValueAt(Object value, int row, int column): atribui um valor a uma clula
especfica atravs das posies row e column.

O cdigo abaixo mostra como criar uma tabela com dados e exibi-la em
uma janela. Para se criar a tabela foi utilizado um construtor que recebe dois
vetores: um com os nomes das colunas chamado colunas e o outro com os
dados, dados.
Com a tabela criada, agora adicion-la a janela por meio do mtodo
add. Para que a janela seja exibida, preciso utilizar o mtodo
setVisible(boolean b) da classe JFrame.

JFrame janela = new JFrame("Nome da janela");

String[] colunas = new String[]{"Nome","Idade","Sexo"};
String[][] dados = new String[][]{
{"Roberto","28","Masculino"},
{"Brenda","30","Feminino"}
};

27

JTable tabela = new JTable(dados,colunas);

janela.add(tabela);
janela.setVisible(true);

3.19. Eventos
Em geral, as aplicaes precisam de alguns eventos para o
funcionamento completo do programa. Normalmente as GUIs do Java so
baseadas em eventos - tarefas realizadas quando um usurio faz a interao com
algum componente GUI, convertendo as aes do usurio em eventos. So
exemplos de eventos:

Quando ocorre uma ao (ActionEvent)

Clique do mouse (MouseEvent)
Apertar em uma tecla (KeyEvent)
Fechar uma janela (WindowEvent)

As classes criadas especificamente para o tratamento de eventos so as

Listeners. As listeners so implementadas atravs de interfaces, por exemplo: a
interface MouseListener possui os seguintes mtodos, que devem ser
sobrepostos na classe que a implementar.

mouseClicked(MouseEvent e) chamado quando o boto do mouse

clicado (e solto) sobre um componente.
mousePressed(MouseEvent e) chamado quando o boto do mouse
clicado sobre um componente.
mouseReleased(MouseEvent e) chamado quando o boto do mouse solto
sobre um componente.
mouseEntered(MouseEvent e) chamado quando o mouse entra na rea
de um componente.
mouseExited(MouseEvent e) chamado quando o mouse deixa a rea de um
componente.

MouseEvent uma classe que representa eventos de mouse. Cada Listener

utiliza uma classe especfica para representar o evento, de acordo com o tipo que
ser gerado.

3.20. Acesso a Banco de Dados

28

A utilizao de um banco de dados muito importante em aplicaes que

trabalham com grandes quantidades de dados, pois oferece uma forma mais
robusta de manipulao, acesso simultneo, backup e segurana.
A maioria dos bancos de dados comerciais so chamados relacionais,
sendo uma forma de trabalhar e pensar diferente do paradigma Orientado a
Objetos. Os bancos de dados relacionais trabalham com a manipulao de
tabelas, enquanto os bancos orientados a objetos trabalham diretamente sobre
objetos.
Nessa disciplina ser abordado apenas os bancos de dados relacionais,
mais especificamente o banco de dados MySQL.

Figura 27: Banco de dados MySQL

O MySQL um dos bancos de dados mais utilizados, tanto em pequenos

quanto em grandes aplicaes. Alm do fato de ser gratuito, possui uma fcil
instalao em qualquer sistema operacional e pode ser baixado no seguinte
endereo: https://www.mysql.com/downloads/.
Uma das formas mais simples de se instalar o MySQL por meio de um
gerente de instalao chamado MySQL Installer. Essa ferramenta auxilia no
processo de instalao, mas est disponvel apenas para Windows.
O processo de armazenamento de informaes em um banco de dados
chamado de persistncia. O Java utiliza uma biblioteca chamada JDBC
responsvel por realizar todo o processo de armazenamento, comunicao,
atualizao, e manipulao com os bancos de dados relacionais.
O JDBC foi criado para facilitar o trabalho dos desenvolvedores nas
tarefas de comunicao entre a aplicao e o banco de dados. Antes do JDBC, a
comunicao com o banco de dados era feita por meio de acesso direto a API do
banco de dados, ou seja, os desenvolvedores tinham que conhecer como
funcionava as APIs de cada banco que iriam trabalhar. Isso era um problema
quando o assunto era trocar de banco de dados. Com o JDBC, o Java isolou esse
acesso direto a API do banco de dados.
O JDBC uma API formada por vrias interfaces que ficam dentro do
pacote java.sql e que devem ser implementadas nas classes que fazem a
comunicao com cada tipo de banco de dados. Esse conjunto de classes
concretas, tambm chamadas de drivers JDBC quem faz a ponte entre o cdigo
29

cliente que usar a API JDBC e o banco de dados. Entre as diversas interfaces
deste pacote, existe a interface Connection que define mtodos para executar
uma query como um insert e select.

Figura 28: Conexo de uma aplicao Java com um banco de dados relacional

As classes Java que formam o driver JDBC so especficas de cada

banco de dados. Assim, a maioria dos bancos de dados do mercado
disponibilizam o seu driver JDBC.
Antes de realizar a manipulao com as classes do driver JDBC ser
preciso criar um banco de dados. O seguinte cdigo criar um banco de dados
com o nome agenda no MySQL.
create database agenda;
Em seguida, criamos uma tabela que ir armazenar todos os contatos.
create table contato(
id BIGINT NOT NULL AUTO_INCREMENT,
nome VARCHAR(255),
email VARCHAR(255),
endereco VARCHAR(255),
dataNascimento DATE,
PRIMARY KEY (id)
);
Agora que criamos um banco de dados chamado agenda e uma tabela
chamada contato. Vamos baixar o driver JDBC para o MySQL no site:
http://dev.mysql.com/downloads/connector/j/.

30

Depois de baixado preciso configur-lo no nosso projeto. Utilizando o

Netbeans, vamos criar um projeto chamado Agenda. Nesse projeto vamos criar
um arquivo chamado Agenda que ir conter a classe principal e outro chamado
TesteConexao. Para utilizar o driver preciso adicion-lo a pasta drivers de
banco de dados do Netbeans que fica na aba servios, do projeto; depois banco
de dados drivers. Clica-se com o boto direito em Drivers, e na janela que
abrir, adicionar driver. Pronto, o pacote que contm as classes que implementam
o JDBC j est no projeto. Agora, preciso adicionar o arquivo .jar, do driver
JDBC, na pasta bibliotecas do projeto. Para isso, clica-se com o boto direito
sobre bibliotecas Adicionar JAR/Pasta.
A classe TesteConexao contm um mtodo chamado getConnection, que
retorna uma conexo. DriverManager uma das classes do pacote java.sql, que
atravs de um mtodo exttico, retorna um objeto do tipo Connection. O
mtodo getConnection recebe como parmetro: a definio do gerenciador
MySQL; o ip da mquina onde o banco de dados se encontra, nesse caso,
localhost. E o nome do banco agenda. Os dois ltimos parmetros so: nome do
usurio e senha. Se algum desses parmetros estiverem errados, a exceo
SQLException ser ativada.

Figura 29: Criando uma conexo com JDBC

Com a tabela contato criada no banco MySQL, vamos criar agora uma
classe que modele essa tabela. A Figura 30 mostra a classe Contato, com os mesmos
campos que a tabela do MySQL. Alm disso, ela conta com mtodos get e set para todos
os atributos.

31

Figura 30: Modelo da Tabela contato

Com o JDBC configurado e a classe Contato criada, vamos agora inserir

dados no banco, utilizando as classes do JDBC.
O comando abaixo, cria uma String chamada sql, que vai receber a
instruo SQL a ser enviada ao MySQL. Os pontos de interrogao significam
que ainda no se conhece os valores a serem inseridos. O mtodo
preparedStatement recebe a instruo SQL e retorna um objeto do tipo
PreparedStatement que uma interface do JDBC. O objeto stmt possui alguns
mtodos set e get que permitem passar valores para ele.
Os mtodos do PrepareStatement comeam com um nmero que indica a
posio dos valores (sinais de interrogao) na instruo SQL e os valores a
32

serem passados. Depois de inserir os valores no objeto stmt, agora preciso

enviar o comando ao banco de dados. Para isso, utiliza-se o execute, passando o
objeto do tipo PreparedStatement. O ltimo passo agora fechar a conexo e o
PreparedStatement atravs do comando close.
String sql = "insert into contatos " +
"(nome,email,endereco,dataNascimento) " +
"values (?,?,?,?)";
PreparedStatement stmt = con.prepareStatement(sql);
stmt.setString(1, "Maria");
stmt.setString(2, "maria@hotmail.com.br");
stmt.setString(3, "R. Nossa Senhora");
java.sql.Date data = new java.sql.Date(
Calendar.getInstance().getTimeInMillis());
stmt.setDate(4, data);
stmt.execute();
stmt.close();
con.close();

Diante do que foi mostrado, percebe-se que seguindo esse modelo de

desenvolvimento, nossa aplicao ficar muito difcil de compreender e ao
mesmo tempo, ter baixa portabilidade, pois tem comandos SQL misturados com
programao Java e consequentemente, muita repetio de cdigo. Imagine que
no futuro seja necessrio migrar para outro banco de dados! Como ficaria?
Pensando nesses problemas, surgiu o padro DAO Data Access Object.
Esse padro permite separar o cdigo de manipulao do banco de dados, do
cdigo de lgica de programao. Dessa forma, a mudana de banco de dados
no afeta a lgica do programa.
Para ver como esse padro funciona, vamos pegar o mesmo banco de
dados, que trabalhos anteriormente e adapt-lo as novas regras.
Inicialmente, para cada classe que represente uma tabela no banco de
dados, ser preciso criar uma classe DAO, por exemplo ContatoDAO. Nas
classes DAO, ir ficar toda a comunicao com o banco de dados. Isso inclui
consultas, como insert, delete, update e tambm conexes.
A primeira classe a ser criada ser chamada de ConnectionFactory. Essa
classe ir ajudar a gerenciar a quantidade de objetos instanciados e o nmero de
conexes criadas durante a execuo do programa. Agora, quando precisar abrir
uma conexo com o banco de dados, basta criar uma instncia dessa classe e
chamar o mtodo getConnection.

33

Figura 31: Classe ConnectionFactory

Na classe Contato, apenas foi acrescentado um construtor, o restante no

mudou.
public Contato(int id, String nome, String email, String
endereco, Calendar dataNascimento) {
this.id = id;
this.nome = nome;
this.email = email;
this.endereco = endereco;
this.dataNascimento = dataNascimento;
}

Na classe ContatoDAO foram colocadas todas as regras de manipulao

e acesso ao banco de dados. Comeando pela conexo, at as trs operaes
bsicas: insero, seleo e atualizao dos dados.
Para inserir um novo contato no banco, basta chamar o mtodo
setContato da classe ContatoDAO, passando um objeto do tipo Contato.

34

Figura 32: Operao Insert

Para obter uma lista dos contatos no banco, basta chamar o mtodo
getContato. Esse mtodo comea criando um PreparedStatement, passando
como parmetro uma consulta select.
PreparedStatement stmt =
this.connection.prepareStatement("select * from contato");

A consulta select um pouco diferente da insero, por isso usa-se o

mtodo executeQuery; A Figura 33 mostra a criao de uma lista para adicionar
os resultados obtidos pelo executeQuery. No final, essa lista de contatos
retornada para a classe que invocou o mtodo getcontato.

35

Figura 33: Operao select

A operao de atualizao, vista na Figura 34, utiliza os mesmo mtodos

da operao de insero, a diferena principal fica na consulta SQL.

Figura 34: Operao update

36

A ltima classe que veremos a Agenda. Essa classe foi desenvolvida

utilizando o padro DAO. Por isso, sua estrutura ficou bem legvel e com alta
portabilidade. Inicialmente foi criada uma instncia da classe ContatoDAO, que
abriu uma conexo com o banco de dados e depois, utilizando o mtodo
setContato, adicionou um novo contato ao banco.
ContatoDAO contatoDAO = new ContatoDAO();
contatoDAO.setContato(new Contato(1, "Pedro",
"pedro@gmail.com", "Rua das Flores",
Calendar.getInstance())
);

Para a operao de seleo apenas foi trocado o mtodo da classe

contatoDAO de setContato para getContato. O mesmo para a operao de
atualizao.

contatoDAO.updateContato(new Contato(1, "Lcia",

"lucia@gmail.com", "Rua das Flores",
Calendar.getInstance()));

3.21. Mapeamento Objeto Relacional

A utilizao do JDBC facilitou bastante a vida dos desenvolvedores, mas
atualmente ele costuma ser pouco usado. Isso acontece devido ao surgimento
das ferramentas de ORM - Object Relational Mapping ou Mapeamento
relacional de objetos. Essas ferramentas abstraem toda a camada JDBC e SQL
da aplicao. Assim, o desenvolvedor pode aproveitar todos os benefcios da
orientao a objetos.
Existem vrias ferramentas de ORM, mas a lder de mercado atualmente
a Hibernate. O Hibernate um framework open source que permite abstrair do
desenvolvedor, a manipulao direta com os bancos de dados relacionais,
gerando cdigo SQL de acordo com os principais tipos de bancos de dados do
mercado: MySQL, Oracle e PostegreSQL.
Devido a sua popularidade, o Hibernate inspirou o surgimento de novas
ferramentas, como o JPA Java Persistence API.
37

O JPA um framework utilizado para persistir objetos Java. Por ser

baseado no Hibernate, o JPA pode acess-lo diretamente. E com isso, diversas
implementaes surgiram, entre as principais: Hibernate da JBoss, OpenJPA, e
EclipseLink.
Para utilizar o JPA em uma aplicao ser preciso baix-lo no site
http://hibernate.org/orm/. O Hibernate j vem com suporte para o JPA. Assim,
utilizando a IDE Netbeans, basta ir na pasta biblioteca do projeto e clicar com o
boto direito para adicionar a biblioteca do Hibernate.
O Hibernate utiliza para conexo com os bancos de dados, o driver
JDBC. Por isso, caso ele ainda no esteja instalado, ser necessrio adicion-lo a
pasta drivers do banco de dados.
Para mostrar como o JPA funciona juntamente com o Hibernate, vamos
utilizar as mesmas tabelas dos exemplos anteriores, ou seja, tabela Contato
pertencente ao banco Agenda.
Inicialmente, ser preciso adaptar a classe Contato seguindo algumas
regras de desenvolvimento do Hibernate e JPA. Primeiro, toda classe que
represente uma tabela no banco de dados deve implementar uma interface
chamada Serializable; a classe deve possuir um construtor sem argumentos; e
encapsular os atributos, ou seja, declarar os atributos como privados e utilizar,
para todos os atributos, mtodos get e set.
Feita as mudanas, agora necessrio criar um arquivo que ir informar
ao JPA, como ele deve persistir a classe Contato no banco de dados.
O caminho no Netbeans para criar esse arquivo clicar com o boto
direito sobre o projeto novo outros Persistncia Unidade de Persistncia.
Escolhe a biblioteca de persistncia, nesse caso, Hibernate JPA e a conexo
com o banco de dados, onde utilizaremos o driver JDBC para MySQL.
Alm das propriedades que esto nesse arquivo, importante acrescentar
o dialeto que o SQL utilizar, referente ao MySQL. O cdigo abaixo, define o
tipo de dialeto para MySQL5InnoDBDialect.
<property name="hibernate.dialect"
value="org.hibernate.dialect.MySQL5InnoDBDialect" />

Outras propriedades que ajudam bastante hibernate.show_sql e

hibernate.format_sql. Essas propriedades permitem acompanhar no console, o
cdigo SQL gerado nas operaes com o banco.
<property name="hibernate.show_sql" value="true" />

38

O Prximo passo agora mapear as classes no banco de dados. Para isso,

o Hibernate exige no mnimo duas propriedades: @Entity e @id. Essas
propriedades so tambm chamadas de anotaes. Um recurso do Java que
permite inserir metadados em classes, mtodos e atributos.
A anotao @Entity usada para indicar que os objetos dessa classe
devem ser persistentes. J a propriedade @Id usada para mapear o atributo que
ser a chave primria da tabela. O cdigo abaixo, mostra como elas so
declaradas.
@Entity
public class Contato implements Serializable{
@Id
private int id;
}

Abaixo, tem uma tabela com as principais propriedades do Hibernate.

Tabela 2: Propriedade do Hibernate

Propriedade
@GeneratedValue
@TemporalType

Funo
Auto incremento
Mapear um tipo Calendar para o
banco
Define um nome da coluna
Define o nome da tabela

@column
@Table

Para utilizar o JPA no nosso cdigo, preciso fazer com que ele leia o
arquivo de configurao XML que declaramos anteriormente. Para isso, vamos
criar um novo arquivo chamado ContatoPersistencia que ser responsvel por
realizar consultas no banco de dados, relativo a classe Contato.
O
mtodo
Persistence.createEntityManagerFactory
acessa
a
configurao do arquivo XML, passando o seu nome como parmetro e a retorna
como um objeto do tipo EntityManagerFactory.
EntityManagerFactory factory =
Persistence.createEntityManagerFactory("Hbernate_
JPAPU");
EntityManager manager =
factory.createEntityManager();

39

O objeto factory permite criar, por meio do mtodo

createEntityManager, um objeto gerenciador do tipo EntityManager,
responsvel por gerenciar toda transao da classe Contato.
Agora preciso criar um objeto do tipo Contato e seu respectivo modelo
no banco de dados.
Contato contato = new Contato();
contato.setDataNascimento(Calendar.getInstance())
;
contato.setEmail("fabiana@gmail.com");
contato.setEndereco("Rua Gonslves dias");
contato.setNome("Fabiana");

Com a criao do objeto contato, agora preciso persisti-lo no banco.

Utilizando o objeto manager, obtm-se uma transao e a inicia com o begin.
Em seguida, passa o objeto criado como parmetro de persist e realiza o commit
pra finalizar a transao.
manager.getTransaction().begin();
manager.persist(contato);
manager.getTransaction().commit();

A partir do momento que a classe Contato j persistente, j possvel

realizar algumas consultas.
Para buscar um objeto, utilizando sua chave primria, utiliza-se o mtodo
find. Esse mtodo recebe como parmetro a classe a ser encontrada e sua chave
primria, como est especificado no cdigo abaixo:
Contato encontrado = manager.find(Contato.class, 1);
Com a classe em mo, pode-se acessar seus valores utilizando os
mtodos get e set, previamente declarados.
Para remover um objeto, tambm muito simples. A classe
EntityManager possui mtodos para cada operao. Mas, antes de remover,
preciso carregar o objeto e depois usar o mtodo remove.

Contato encontrado = manager.find(Contato.class, 1);

40

manager.getTransaction().begin();
manager.remove(contato);
manager.getTransaction().commit();

Para atualizar (update) um determinado objeto, a EntityManager oferece

o mtodo merge. Para isso, basta criar uma instncia da classe a ser persistida e
inserir os novos valores por meio dos mtodos sets. Depois, s passar essa
instncia para o mtodo merge, como no cdigo abaixo:
Contato contato = new Contato();
contato.setDataNascimento(Calendar.getInstance());
contato.setEmail("joao@gmail.com");
contato.setEndereco("Rua Pedro Marcelino");
contato.setNome("Joo");
manager.getTransaction().begin();
manager.merge(contato);
manager.getTransaction().commit();

Para realizar consultas mais complexas, o JPA disponibiliza uma

linguagem prpria de queries chamada JPQL. O cdigo abaixo utiliza o mtodo
createQuery, para passar uma consulta JPQL, que retorne o endereo de todos os
Contatos que possuam o email igual a paulo@gmail.com.
List<Contato> lista = manager.createQuery(
"select c from Contato as c where c.email =
paulo@gmail.com"
).getResultList();
for(Contato contato : lista){
System.out.println(contato.getEndereco());
}

Tambm possvel passar um parmetro em uma consulta JPQL.

Utilizando-se da classe Query, pode-se passar uma consulta, juntamente com
um identificador (dois pontos), que represente o parmetro a ser injetado na
consulta. No cdigo abaixo, foi utilizado o identificador :paramEmail para ser
41

substitudo pelo valor do atributo email. Essa substituio realizada pelo

mtodo setParameter.
O resultado da consulta devolvido em forma de lista pelo mtodo
getResultList.
String email = "paulo@gmail.com";

Query query = manager.createQuery("select c from

contato as c where c.email = :paramEmail");
query.setParameter("paramEmail ", email);
List<Contato> lista = query.getResultList();

Essas so apenas algumas das principais consultas que a JPQL oferece.

Para um maior aprofundamento s visitar o seguinte site:
http://docs.oracle.com/javaee/6/tutorial/doc/bnbtg.html

42

Referencial bibliogrfico
ARNOLD, K.; GOSLING, J.; HOLMES, D. A Linguagem de Programao Java. 4. ed. Porto
Alegre: Bookman, 2007.
SCHILDT, H. C Completo e Total. 3. ed. So Paulo: Makron Books, 1996
SIERRA, K.; BATES, B.; COELHO, A. J. Use a Cabea!: Java. 2. Ed. Rio de Janeiro: Alta
Books, 2005.
CAELUM. Uma introduo prtica ao JPA com Hibernate. Capitulo 14 da apostila - Java
para Desenvolvimento Web. Disponvel em: <https://www.caelum.com.br/apostila-javaweb/uma-introducao-pratica-ao-jpa-com-hibernate/>. Acesso em: 11 maio 2016.
______. Interfaces grficas com Swing. Capitulo 5 da apostila Apostila Laboratrio Java
com Testes, XML e Design Patterns. Disponvel em: < http://www.caelum.com.br/apostila-javatestes-xml-design-patterns/interfaces-graficas-com-swing/>. Acesso em: 12 maio 2016.
______. Excees e controle de erros. Disponvel em: <https://www.caelum.com.br/apostilajava-orientacao-objetos/excecoes-e-controle-de-erros/>. Acesso em: 27 jun. 2016.
______. Trabalhando com eventos na GUI do Java. Disponvel em:
<http://www.devmedia.com.br/trabalhando-com-eventos-na-gui-do-java/25898>. Acesso em: 27
jun. 2016.
______. Bancos de dados e JDBC. Disponvel em: <https://www.caelum.com.br/apostila-javaweb/bancos-de-dados-e-jdbc/>. Acesso em: 27 jun. 2016.
PALMEIRA, Thiago Vincius Varallo. Java: histria e principais conceitos. Disponvel em:
<http://www.devmedia.com.br/java-historia-e-principais-conceitos/25178>. Acesso em: 12 maio
2016.

43