STANDARD
EDITION
Fortaleza, maro/2014
Sumrio
Introduo.............................................................................................................................................8
Capitulo 1.O que a linguagem java....................................................................................................9
1.1.- Histrico da linguagem............................................................................................................9
1.2.Uso da linguagem no mercado atualmente(especificao das tecnologias)............................10
1.3.Principais caractersticas da linguagem de programao java.................................................10
1.4. Ambientes e ferramentas de desenvolvimento com java........................................................14
1.4.1. Instalao do JDK ou SDK e JRE e suas configuraes.................................................14
1.5.Meu primeiro programa em java.............................................................................................14
1.5.1.Comentrios em Java:......................................................................................................16
1.5.2.Compilando meu primeiro programa em Java.................................................................16
1.5.3.Dicas para resoluo de problemas em programas java...................................................17
1.6.Erros comum em programas java............................................................................................17
1.6.1.Erros em java:..................................................................................................................17
1.6.2.Erro em tempo de compilao :.......................................................................................18
1.6.3.Erro em tempo de execuo:............................................................................................18
1.7.Netbeans...................................................................................................................................18
1.8.Viso de outras IDEs para o desenvolvimento com java.........................................................19
1.8.1.IDE Eclipse......................................................................................................................19
1.8.2.A IDE Bluej......................................................................................................................19
1.8.3.A IDE Gel.........................................................................................................................19
1.8.4.A IDE Jdeveloper.............................................................................................................19
1.9.Identificadores e palavras-chaves............................................................................................20
1.10.Tipos primitivos:....................................................................................................................21
1.10.1.Uso de valores literais de todos os tipos de dados existentes........................................21
1.10.1.1.Literais Inteiros:.....................................................................................................21
1.10.1.2.Literais decimal:.....................................................................................................22
1.10.1.3.Literais octal:..........................................................................................................22
1.10.1.4.Literais hexadecimal:.............................................................................................22
1.10.1.5.Literais de ponto flutuante:.....................................................................................23
1.10.1.6.Literais booleanos:.................................................................................................23
1.10.1.7.Literais de caracteres:.............................................................................................24
1.10.1.8.Literais para String:................................................................................................24
1.11.Operadores em Java:..............................................................................................................25
1.11.1.Operadores de atribuio composto...............................................................................25
1.11.2. Operadores de comparao...........................................................................................26
1.11.3.Igualdade de tipos primitivos :.......................................................................................27
1.11.4.Igualdade de variveis de referncias:...........................................................................27
1.11.5.Operador Instanceof:......................................................................................................28
1.11.6.Operador concatenao de strings:.................................................................................29
1.12. Operadores aritmticos.........................................................................................................29
1.12.1.Operador resto (%) :.......................................................................................................30
1.12.2.Operadores de Incremento e Decremento:.....................................................................30
OBS: A diferena que nesse caso podemos visualizar os resultados, 5,4 e 3;..........................31
1.12.3.Exerccio resolvido........................................................................................................32
1.12.4.Operadores relacionais:..................................................................................................32
1.12.5.Operadores lgicos.........................................................................................................32
1.12.6.Os operadores Bitwise :.................................................................................................33
1.12.7. Operadores lgicos de abreviao:................................................................................33
1.12.8.Operadores lgicos ^ e !:................................................................................................34
1.12.9.Operadores condicionais................................................................................................34
1.12.10.Operador Ternrio........................................................................................................35
1.12.11. Precedncia de Operadores.........................................................................................36
Capitulo 2.Controle de fluxo em java.................................................................................................37
2.1.Utilizar cdigo que use instrues if........................................................................................37
8.1.1.Diagrama de Atividade:...................................................................................................76
8.1.2.Diagrama de Sequencia....................................................................................................76
8.1.3.Diagrama de Caso de Uso................................................................................................76
8.1.4.Diagrama de Classe..........................................................................................................76
8.2.Abrindo o Projeto.....................................................................................................................77
Capitulo 9.Fila e Pilha........................................................................................................................79
9.1.Fila...........................................................................................................................................79
9.1.1.Implementando Fila em Java...........................................................................................79
9.2.Pilha.........................................................................................................................................81
9.2.1.Implementando Pilha em Java.........................................................................................81
Capitulo 10.Colees: List e Map......................................................................................................83
10.1. Introduo a Colees/Collections.......................................................................................83
10.2. Collection List ou Coleo Lista..........................................................................................85
10.3.ArrayList................................................................................................................................86
10.3.1.Criando uma Lista em Java usando a Classe ArrayList.................................................87
10.3.2.Adicionando elementos em uma Lista...........................................................................87
10.3.3.Removendo elementos de uma Lista..............................................................................89
10.3.4.Acessando elementos da Lista.......................................................................................90
10.3.5.Pesquisando elementos na Lista.....................................................................................93
10.4. Collection Map ou Coleo Mapa........................................................................................94
10.5.HashMap................................................................................................................................95
10.5.1.Criando uma coleo do tipo Mapa usando a Classe HashMap....................................95
10.5.2.Adicionando elementos em uma coleo do tipo Mapa.................................................96
10.5.3.Removendo elementos em uma coleo do tipo Mapa..................................................97
10.5.4.Selecionando/Pesquisando elementos em uma coleo do tipo Mapa...........................98
10.5.5.Nmero de elementos em uma coleo do tipo Mapa...................................................98
Capitulo 11.Interface Grfica com Usurio GUI...........................................................................100
11.1.Interface Grfica com usurio - GUI...................................................................................100
11.2.Bibliotecas AWT e SWING.................................................................................................101
11.3.JFrame..................................................................................................................................101
11.3.1.Camadas JFrame..........................................................................................................101
11.3.2.Nossa primeira Janela com JFrame..............................................................................102
11.4.Criando uma classe com propriedades SWING...................................................................103
11.5. JLabel..................................................................................................................................105
11.6. JButton................................................................................................................................106
11.7. JTextField............................................................................................................................107
11.8. Icon.....................................................................................................................................108
11.9. Editando fonte com o setFont()...........................................................................................109
11.10.JMenuBar, JMenu e JMenuItem........................................................................................109
11.11.JCheckBox..........................................................................................................................111
11.12.JRadioButton......................................................................................................................113
11.13.JComboBox........................................................................................................................114
11.14.Mais Componentes Swing..................................................................................................115
Capitulo 12.Gerenciadores de Layout..............................................................................................115
12.1. Gerenciadores de Layout....................................................................................................115
12.2. BorderLayout......................................................................................................................116
12.3.BoxLayout............................................................................................................................116
12.4.FlowLayout..........................................................................................................................117
12.5.GridLayout...........................................................................................................................118
12.6.GridBabLayout....................................................................................................................119
Capitulo 13.Eventos (Listeners).......................................................................................................121
13.1.ActionListener.....................................................................................................................121
13.2.FocusListener.......................................................................................................................122
13.3.KeyEvent.............................................................................................................................123
13.4.MouseListener.....................................................................................................................124
Capitulo 14.Java e Banco de Dados: JDBC.....................................................................................133
14.1.Introduo............................................................................................................................133
14.2.Comunicao: Java e Mysql................................................................................................133
14.3.Baixando o driver JDBC......................................................................................................134
14.4.IDE Eclipse: Importando o driver JDBC para o nosso projeto............................................136
14.5.IDE NetBeans: Importando o driver JDBC para o nosso projeto........................................138
14.6.JDBC: Criando conexo com o Banco de Dados................................................................139
14.6.1.Minha primeira Conexo.............................................................................................139
14.6.2.Ajustando a classe Conexao.........................................................................................141
14.7.JDBC: Inserindo dados no banco de dados.........................................................................142
14.7.1.Criando a Classe Contato.............................................................................................142
14.7.2.Criando a Classe ContatoDao......................................................................................143
14.7.3.Usando a classe ContatoDao: Classe Agenda..............................................................145
14.8.JDBC: inserindo vrios registros.........................................................................................146
14.8.1.Sobrecarregando mtodo insereContatos.....................................................................146
14.8.2.Utilizando o mtodo que insere vrios contatos: insereContato..................................148
14.9.JDBC: Listando registros.....................................................................................................149
14.9.1.Implementando mtodo listaContatos..........................................................................149
14.9.2.Utilizando o mtodo listaContatos...............................................................................151
14.10.JDBC: Excluso de registro...............................................................................................152
14.10.1.Implementando o mtodo deletaContato...................................................................152
14.11.JDBC: Atualizao de registro...........................................................................................152
14.11.1.Implementando mtodo editaContato........................................................................153
14.12.Exerccios propostos..........................................................................................................154
Capitulo 15.Java e Banco de Dados: Hibernate...............................................................................155
15.1.Introduo............................................................................................................................155
15.2.Hibernate uma implementao ORM..................................................................................156
15.3.Arquitetura Hibernate..........................................................................................................156
15.4.Baixando o Hibernate..........................................................................................................157
15.5.Instalando o Hibernate.........................................................................................................158
15.6.Criando uma conexo com o Hibernate...............................................................................162
15.6.1.Criando o arquivo xml na raiz da pasta src utilizando o eclipse..................................162
15.6.2.Escrevendo o arquivo de configurao do Hibernate..................................................163
15.6.3.Criando o pacote conexao............................................................................................165
15.6.4.Criando e escrevendo a classe HibernateUtil...............................................................166
15.6.5.Criando e escrevendo a classe TesteConexaoHibernateMysql....................................167
15.7.Hibernate C.R.U.D de um objeto simples sem relacionamentos.........................................169
15.7.1.Criando pacote modelo................................................................................................169
15.7.2.Mapeando a Classe Contato.........................................................................................170
15.7.3.Classe ContatoDao com Hibernate: inserindo.............................................................171
15.7.4.Classe ContatoDao com Hibernate: listando................................................................173
15.7.5.Classe ContatoDao com Hibernate: buscando.............................................................173
15.7.6.Classe ContatoDao com Hibernate: removendo..........................................................174
15.7.7.Classe ContatoDao com Hibernate: atualizando..........................................................175
15.7.8.Mtodos da interface Session.......................................................................................175
15.8.Mapeamento de objetos utilizando Annotations e Hibernate..............................................177
15.9.Relacionamentos entre tabelas: Hibernate e Annotation.....................................................181
15.9.1.Modelando o Banco de Dados Relacional: Agenda.....................................................182
15.9.2.HashCode, equals e interface Serializable e sua relao como Hibernate...................184
15.9.3.Mapeamento de entidades: endereco...........................................................................185
15.9.4.Class EnderecoDao......................................................................................................188
15.9.5.Mapeamento de entidades: Telefone............................................................................190
15.9.6.Mapeamento de entidades: ContatoAnnotation...........................................................192
15.9.7.Mapeamento de entidades: Grupo................................................................................195
15.10.Consultas utilizando: Classe Criteria.................................................................................195
15.10.1.API Criteria................................................................................................................195
15.10.2.Restries com Criteria..............................................................................................196
15.10.3.Paginando Resultados................................................................................................198
15.10.4.Retornando Resultados nicos..................................................................................199
15.10.5.Ordenando Resultados...............................................................................................199
15.10.6.Associaes................................................................................................................199
15.10.7.Projeo e Agregao.................................................................................................200
15.11.Referncias bibliogrficas..................................................................................................202
Bibliografia.......................................................................................................................................204
Titulo da Apostila
Introduo
Essa apostila tem como objetivo ajudar ao aluno na disciplina de Introduo a
Programao Orientada a Objetos do nosso curso,visto que o requisito bsico para que se
possa alcanar todos os objetivo do nosso curso nesta
disciplina que o aluno tenha passado pela disciplina
de Introduo a Lgica de Programao para
Computadores. Mas no nos atearemos em barrlos,sem o pr-requisito bsico,isso porque confiamos
e acreditamos na capacidade dos nossos alunos que
com muitas fora,dedicao e vontade de vencer na
vida,conseguir ultrapassar qualquer preconceito
contra o acesso ao conhecimento tecnolgico.
O nosso objetivo principal com este material capacitar o aluno para um entendimento
critico a respeito do Paradigma de Programao Orientada a Objetos. Visto que uma das
tendncia atualmente no mercados usar esse paradigma no desenvolvimento de sistemas
em geral.
Aliado ao Software Livre que uma tendncia e uma alternativa para o mundo
corporativo no que se refere a softwares,e que tambm tem sido
atualmente desenvolvido por programadores espalhados ao redor
mundo,sendo que boa parte dessas tecnologias veem sendo
desenvolvidas utilizando ferramentas livres na maioria de seus
projetos, contribuindo para os avanos e colaborando para o acesso
de milhares de pessoas as incluses digitais no que tange as
tecnologias da informao no mundo. Daremos tambm a nossa disciplina uma nfase
maior no uso desse tipo de tecnologia,passando para os nossos alunos um modelo e uma
alternativa fantstica,que a utilizao das ferramentas livres disponveis na internet.
Primeiramente vamos estudar um pouco sobre a histria da linguagem de programao
java que iremos utilizar na nossa disciplina. Relatamos as caractersticas principais da
linguagem que para muitos ainda desconhecido, ou seja,conhecer a ferramenta antes de
domin-la de estrema importncia para os futuros programadores.
Obrigado professor! Eu sou o Tutor e os ajudarei, respondendo
as perguntas que forem surgindo ao longo do nosso curso, mas,
algumas dessas perguntas se dirija ao Instrutor que dever
auxiliar meus colegas de sala, os alunos!
Alias professor, por onde comearemos a estudar java?Nos d
uma dica!Calma!Muita calma meus colegas. Porque o ejavashow
ainda vai comear. Apresentaremos nesta apostilas no final de
cada captulo uma lista muitos dos exerccios,que muitas vezes so
aparentemente repetitivos e at mesmo redundantes. Isso
proposital: se o estudante conseguir resolver um dos exerccios
aparentemente repetidos, poder deduzir a soluo de outros mais facilmente. A criao de
vrios exerccios aparentemente redundantes tambm facilita ao instrutor na criao de
listas
de
exerccios
distintas
e
complementares.
claro! Comearemos a estudar sobre os fundamentos de programao e falaremos em
seguida sobre as estruturas bsicas da linguagem java.
Capitulo 1.
Bem vindos ao futuro! Java no somente uma linguagem de programao, mas sim uma
tecnologia que tem como objetivo construir programas que possam ser utilizados em qualquer
plataforma ou computador, com o mnimo possvel de dependncia com um sistema operacional
ou ambiente de desenvolvimento. Java possui uma sintaxe extremamente similar do C++, e com
diversas caractersticas herdadas de outras linguagens,como Smalltalk e Modula-3. antes de tudo
uma boa linguagem,simples,com um ambiente de execuo de alta qualidade e uma vasta
biblioteca de classes disponveis. Essa combinao que torna Java uma proposta irresistvel para
tantos programadores. Alm de contar com as seguintes caractersticas,totalmente orientada a
objetos,fortemente tipada, independente de arquitetura,robusta,segura,portvel,bem estruturada,
suporta programao distribuda, multithreaded e conta com garbage collection.
Browsers nos Applets Java e tudo seria disponibilizado pela Internet instantaneamente.
Foi o esttico HTML dos Browsers que promoveu a rpida disseminao da dinmica
tecnologia Java. A velocidade dos acontecimentos seguintes foi assustadora,o nmero de
usurios cresceu rapidamente, grandes players, como a IBM anunciaram suporte para a
tecnologia Java.
SEGURA: Java foi elaborada para ser usada em ambientes de rede distribuda,
10
10
11
12
JAVA E A INTERNET: Os programas java que rodam em pginas web so chamados applets.
Para usar applets, voc precisa de um navegador web habilitado para Java,o qual executar os
bytecodes para voc. Em particular servidores de aplicao podem usar as capacidades de
monitoramento da mquina virtual java para realizar o equilbrio automtico de carga,controle de
conexes a banco de dados,sincronizao de objetos,desligamento e reinicializao seguros,alm de
outros servios necessrios para aplicaes escalveis de servios,mas que so notoriamente
difceis de se implementar corretamente. Em java, possvel escrever aplicaes
completas,inclusive acessando bancos de dados relacionais independentemente do servidor
web,bem como possvel implementar os nveis de interface com o usurio e de lgica do
negocio,utilizando um servidor de banco de dados para implementar o nvel de acesso aos dados.
13
1.4.1.
A Sun a empresa proprietria do Java que atualmente pertence a empresa (Oracle). Ela
disponibiliza, basicamente, duas verses de sua mquina
virtual: o JRE (Java Runtime Environment) e JDK (Java
Development Kit). O JRE contm a mquina virtual que
permite rodar programas feitos na linguagem Java em
uma mquina. O JDK, por sua vez, um pacote para
desenvolvedores programarem suas aplicaes em Java,
possuindo vrios utilitrios, inclusive compilador e
bibliotecas. Uma das verses mais usadas do Java foi a
1.4.x, que possua inclusive um visual um pouco (para ser
modesto) rstico. Mais para frente a Sun lanou a verso
1.5.0, com vrias melhorias em termos de programao e
um visual um pouco melhor. Foi lanado em dezembro
do de 2006 o Java 1.6.0, conhecido tambm como Java 6,
que trouxe,finalmente,uma integrao total com o
desktop em termos visuais,e vrias melhorias tambm
para quem programador.
Mustang o nome dado para a nova verso 6 de Java,que saiu no final do ano passado.
Entre as novidades mais conhecidas esto o suporte a linguagens de script, melhores ferramentas
para o monitoramento de aplicaes Java e mais integrao com o sistema operacional. Mas o qual
realmente a diferena entre o JDK e Java SDK? : O kit de desenvolvimento para java (Sofware
Development Kit). Trata-se de um conjunto de softwares para programadores em java que voc no
precisa instalar se sua inteno for apenas usar os programas feitos em java. Para rodar os
programas em java basta instalar o JRE (Java Runtime Environment) .
http://www.guiadohardware.net/tutoriais/java-linux/
14
hardware ou software que possua uma verso da JVM. A Mquina Virtual java definida
como uma mquina imaginria implementada atravs da emulao em um software
executado em uma mquina real. Ela possui uma arquitetura que permite garantir
segurana. Quando um programa Java executado,seus bytecodes so verificados pela
JVM para que estejam de acordo com os seus requisitos de segurana,impedindo a
execuo de cdigo com alguma irregularidade. Assim,cdigos-fonte com instrues que
acessem reas restritas da memria ou at mesmo recursos do hardware no so
executados pela JVM.
A palavra public indica que a classe ter um nvel de acesso pblico, ou seja, que ela
ser acessvel por qualquer classe. A palavra class indica que uma classe est sendo
declarada e seu nome HelloWorld. A { delimita o limite inicial da classe.
A palavra public j foi descrita, portanto permite que o mtodo seja acessado
publicamente. A palavra static ser descrita posteriormente. O lugar onde fica a palavra
void onde se deve indicar o tipo de retorno do mtodo. Neste caso, no retorna nenhum
valor, dessa maneira o mtodo declarado como void. O conjunto String[] args
presentes entre ( ) so os argumentos do mtodo. Neste exemplo,o mtodo possui um
nico argumento (um vetor de Strings denominado args. A { delimita o limite inicial do
mtodo.
A terceira linha consiste no contedo do mtodo principal, formado apenas por um
comando,ou uma instruo que composta de uma ou mais linhas terminadas por ponto e
vrgula. Exemplo:
O System.out.println usado para exibir algo na sada padro, por padro, na linha de
comando. Ser exibido o que tiver entre (), no caso,Hello world. No final deste comando, temse um; que o finaliza. Por fim,h duas fecha chaves } } , que delimitam o fim do mtodo e da
classe,respectivamente.
14
15
1.5.2.
Nesse segundo exemplo vamos usar um editor de texto qualquer para editor o cdigofonte do nosso segundo exemplo e vamos compilar usando terminal(Konsole) do sistema
operacional.
15
16
1.5.3.
Erros em java:
Durante o desenvolvimento de programas, muito comum que erros podem ocorrer,em java
pode ser em dois domnios: tempo de compilao e tempo de execuo.
16
17
1.7. Netbeans
O termo IDE em ingls,que quer dizer(Integrated
Development Environment). O NetBeans IDE um
ambiente de desenvolvimento integrado e est
disponvel para Windows, Mac, Linux e Solaris. O
projeto NetBeans consiste em um IDE de cdigofonte aberto e uma plataforma de aplicaes que
permitem
que
os
desenvolvedores
criem
rapidamente aplicativos web, corporativos, desktop e
aplicaes mveis utilizando a plataforma Java,bem
como JavaFX, PHP, JavaScript e Ajax Ruby e Ruby on Rails , Groovy e Grails, e C / C + +. O
17
18
1.8.2.
A IDE Bluej
BlueJ um ambiente de desenvolvimento java projetado
especificamente para o ensino em um nvel introdutrio. BlueJ foi
projetado e implementado pelas equipes das universidade Monash
1.8.3.
A IDE Gel
1.8.4.
A IDE Jdeveloper
19
nmeros;
No possuem limite de tamanho;
No podem ser palavras reservadas restritas da linguagem;
20
1.10.Tipos primitivos:
Todo programa de computador deve ser capaz de lidar com dados para conseguir fazer
seus processos como, por exemplo, somar,
multiplicar, dividir, etc. Usar atributos a melhor
forma de manipular os dados. Os tipos de dados
so o que definem a quantidade de memria do
computador que ser utilizado para guardar tal
dado. As variveis primitivas pode ser declaradas
como variveis de classe(static), variveis
instncias, parmetros de mtodos ou variveis
locais. Uma vez declarado, seu tipo primitivo no
pode nunca ser modificado,embora na maioria dos
casos seu valor possa se modificar. Java um
linguagem fortemente tipada. Isso significa que toda varivel deve ter um tipo declarado.
Existem oito tipos primitivos em java. Quatro deles so do tipo inteiros; dois so do tipo de
nmeros de ponto flutuante; um o tipo de caracteres char,usado para unidades de cdigo
no esquema de codificao Unicode e um deles do tipo lgico para valores
true/false(verdadeiro/falso).
1.10.1.
1.10.1.1.
Literais Inteiros:
H trs maneiras de representar nmeros na linguagem Java: decimal (base 10), octal
(base 8) e hexadecimal (base 16).
20
21
1.10.1.2.
Literais decimal:
1.10.1.3.
Literais octal:
1.10.1.4.
Literais hexadecimal:
O tipo short guarda inteiros de 2 bytes (16 bits) e pode guardar nmeros entre -32.768 a
32.767.
21
22
O tipo int o tipo de dado mais comum. Ele consome 4 bytes (32 bits) e guarda valores
entre -2.147.483.648 e 2.147.483.647.
1.10.1.5.
1.10.1.6.
Literais booleanos:
22
23
1.10.1.7.
Literais de caracteres:
O literal char representado por um nico caractere entre aspas simples. Eles podem
tambm representar valores Unicode do caractere,usando a notao Unicode que
acrescenta o prefixo \u ao valor,atribuir um literal numrico,contanto que ele esteja no
intervalo de 16 bits sem sinal (65535 ou menor).
Vlidos:
Invlidos:
1.10.1.8.
23
24
Exemplo usando
operador composto:
24
25
1.11.2.
Operadores de comparao.
= = igual a.
! = diferente de.
Exemplo 02:
Exemplo 02:
25
26
1.11.3.
1.11.4.
As variveis de referncias podem ser testadas com o operador (==) para sabermos se
esto referenciando um objeto em comum. Mas muito importante ressaltar que o mesmo
operador estar examinando os bits da
varivel,portanto com relao as
variveis de referncias, se os bits das
duas variveis forem idnticos, elas
estaro referenciando (apontando) o
mesmo objeto.
Neste exemplo do cdigo acima, foi criado trs variveis de referncia a partir da classe
Funcionrio. As duas primeiras f1 e f2, so objetos de Funcionrio diferentes, que por
acaso tem o mesmo valor inicial, a terceira varivel de referncia f3, inicializada para
referenciar o mesmo objeto que a varivel f1 est referenciando. O operador == no testar
se dois objetos so significativamente equivalentes,isso porque ele compara os bits das
variveis,ento as referncia de memrias das variveis no soa iguais.
26
27
1.11.5.
Operador Instanceof:
Permite-nos saber se um objeto pertence a uma classe ou no,ou seja se o objeto passa
no teste -um. Este operador usado somente com variveis de referncias de objetos, e
pode ser empregado para verificar se um objeto do tipo especfico. Quando tratamos de
tipos, queremos dizer tipo de interface ou classe. Em outras palavras,se o objeto
referenciado pela varivel esquerda do operador passaria no teste -um do tipo de
interface ou classe do lado direito do operador.
Sintaxe do operador instanceof:
if (tipo_1 instanceof tipo_2)
{
/**bloco de cdigo aqui...*/
}
Exemplo 01.
Exemplo 02.
27
28
1.11.6.
O sinal de adio(+) tambm pode ser usado para concatenar duas strings. Se um dos
valores for uma String, o operador + atuar como um operador de concatenao de
Strings. E se os dois valores forem nmeros, o operando + funcionar como o operador de
adio.
Exemplo 01.
Resultado do cdigo acima, executado dentro de uma classe que possua o mtodo
main().
Exemplo 02. Resultado do cdigo ser mostrado ao lado,executado dentro de uma classe
que possua o mtodo main().
28
29
1.12.1.
O operador resto da diviso divide o operando a esquerda pelo direito com o resultado
sendo o resto dessa diviso.
1.12.2.
Exemplo 01:
OBS:
30
30
31
1.12.3.
Exerccio resolvido
01 Crie um programa em java que decremente uma varivel 4 vezes e mostre cada
parte do calculo,sendo que a varivel se inicia com valor igual a 5.
1.12.4.
Operadores relacionais:
1.12.5.
Operadores lgicos.
Expresses lgicas so aquelas que realizam uma operao lgica (ou, e, no, etc...) e
retorna verdadeiro ou falso. A linguagem java especificam seis operadores lgicos (! , & , | ,
^ , && , || ).
31
32
1.12.6.
Os operadores Bitwise :
1.12.7.
O operador de abreviao (&&) consiste no fato de ele no perder seu tempo avaliaes
inteis.O operador de abreviao (&&) avaliar o lado esquerdo da operao (operando
um) e se esse operando tiver um resultado false, ele no examinar o lado direito da
equao(operando dois),j que o operador saber que a expresso completa no ser true.
AND abreviao (&&)
OR abreviao (||)
Exemplos:
32
33
1.12.8.
Operadores lgicos ^ e !:
Exemplos:
Nota: A expresso acima avalia como false porque tanto o primeiro operando (2<3)
quanto o segundo(4>3) avaliam como true.
Exemplos 01:
Exemplos 02:
1.12.9.
Operadores condicionais.
O operador condicional um operador ternrio tem trs valores usado para avaliar
expresses boleanas de modo semelhante a instruo IF ,exceto por em vez de executar um
bloco de cdigo se o resultado do teste for true,atribuir um valor varivel. Ou seja
objetivo do operador condicional decidir qual dos valores atribuir a uma varivel.Ele
constitudo dos smbolos ?(ponto de interrogao) e (dois pontos),os parnteses so
opcionais.Veja a sintaxe:
X = (expresso boleana) ?valor a atribuir se true : valor atribuir se false
Exemplo 01.
33
34
Exemplo 02.
Exemplo 03.
1.12.10.
Operador Ternrio
34
35
1.12.11.
Precedncia de Operadores
operador
() parnteses
++ ps-incremento e - - ps-decremento
++ pr-incremento e - - pr-decremento
! negao lgica
* Multiplicao e / diviso
% Resto da diviso
+ soma e - subtrao
< menor que, <= menor igual, > maior que, >= maior igual
== igual e ! = no igual
10
11
| OU binrio
12
^ OU exclusivo binrio
13
14
|| OU lgico
15
?: condicional
16
= atribuio
35
36
Capitulo 2.
2.1.1.
Exemplos 01:
Neste exemplo ambas as instrues so avaliadas como verdadeira tanto a do lado
direito quanto a do lado esquerdo, pois, o valor da varivel x for maior do que o valor da
varivel y, ento o bloco de instruo executado, e a mensagem ser imprimida na sada
padro.
Exemplos 02:
36
37
Neste outro exemplo a instruo avaliada como true, pois, o valor da varivel teste
false,mais quando o fluxo entra no if a varivel teste recebe true, logo bloco de instruo
ser executado e resultando impresso na sada padro.
Notas: Nestes exemplos a instruo do lado esquerdo avaliada como verdadeira, pois, o
valor da varivel x no maior do que o valor da varivel y e a instruo do lado direito
tambm avaliada como verdadeira, pois a varivel teste tinha valor inicial false, mas
dentro da instruo atribudo um novo valor igual a true, logo bloco de instruo tanto
da esquerda como o da direita sero executados,atribuindo um novo valor para a varivel y
igual a 25 imprimindo o valor de y na sada padro.
Exemplos 01:
Notas: Nestes exemplos ambas os cdigo do if sero avaliada como verdadeira,ento ela
executa a instruo imprimindo teste 1. Se as instruo if fosse falsa ele executariam o
eles,imprimindo teste 2,mas no nosso caso foram verdadeiras.
37
38
Podemos ter vrias estruturas else-if depois de uma declarao if. A estrutura else
opcional e pode ser omitida. No exemplo mostrado acima, se a expresso_lgica1
verdadeira, o programa executa a instruo1 e salta as outras instrues. Caso contrrio, se
a expresso_lgica1 falsa, o fluxo de controle segue para a anlise da expresso_lgica2.
Se esta for verdadeira, o programa executa a instruo2 e salta a instruo3. Caso
contrrio, se a expresso_lgica2 falsa, ento a instruo3 executada.
Fluxograma da instruo if-else-if
38
39
Exemplo 01:
40
Exemplos 01:
As constantes CASE so avaliadas de cima para baixo,e a primeira constante CASE que
bater com a expresso SWITCH ser o ponto de entrada da execuo.
Exemplos 02:
Soluo Incorreta.
Soluo Correta.
Este exemplo perfeitamente vlido para a declarao switch-case, porque mesmo a
varivel sendo do tipo String,porm quando entrar na instruo switch,o mtodo invocado
pela varivel s.length que retornar um valor inteiro,ou seja o tamanho da string,que no
nosso caso igual a 7.
Exemplo 03:
40
41
41
42
Exemplo 01:
Exemplo 01:
42
43
Neste exemplo a varivel x inicializada com 0,o bloco de cdigo executado pelo
menos uma vez antes que a condio seja verificada. Aps a condio ser avaliada como
verdadeira,a varivel ser incrementada em 1 e a execuo do cdigo volta para o inicio do
bloco e isso se repetir at que a condio seja avaliada como falsa.
2.3.2.Loop for:
A declarao for, como nas declaraes anteriores, permite a execuo do mesmo bloco de
cdigo uma quantidade determinada de vezes.
Sintaxe: do loop for:
Fluxograma For
Exemplo 01:
Exemplo 02:
43
44
Exemplo 02:
Nota: A sada dos exemplos anteriores, aps compilado e executado, dever ser uma
exibio dos nmeros inteiros do arranjo com nome semana. Esta estrutura otimiza a
interao no arranjo ou coleo passada para a expresso podendo ser efetuada a
navegao sem a necessidade de ndices ou interadores.
44
45
Nota: Vamos analisar este exemplo acima que tem como resultado a impresso de todos
os nmeros cuja o mdulo da diviso por 10 seja igual a 0. Da o resultado o mostrado
abaixo:
[ i = 100, i = 90, i= 80, i = 70, i= 60, i = 50, i = 40, i= 30, i = 20, i = 10 ]
Exemplo 02:
Agora vamos analisar o exemplo 02,que mostra o mesmo programa com uma pequena
diferena que a incluso do comando break depois do comando System.out.println();
45
46
2.5.2. Continue:
A instruo continue far com que somente a iterao atual do loop seja encerrada e que
a prxima iterao do mesmo loop seja iniciada deste que for atendida. Quando usar uma
instruo continue em um loop for, voc ter que considerar seus efeitos na iterao do
loop. A declarao continue faz com que a execuo do programa volte imediatamente para
o incio do lao, porm para a prxima interao. O continue faz o interpretador pular para
a prxima iterao e obriga-o a testar a condio. Exemplo:
A pergunta : Esse um loop infinito? A resposta no. Quando a instruo continue for
atingida,a expresso de iterao ainda ser executada! Ela ser exatamente como se a
iterao atual terminasse de maneira natural. Portanto,no exemplo anterior, ainda
aumentar o valor antes da condio (i < 10) ser verificada novamente. Mas geralmente a
instruo continue usada dentro de um teste if como segue abaixo:
Nota: Este dois comando tambm podem ser usados como instrues rotuladas. As
instrues rotuladas esto alm do escopo do nosso curso,mas,embora muitas instrues
em java possam ser rotuladas, mais comum usar rtulos com instrues loop tais como
for e while, em conjunto com instrues break e continue. Uma instruo de rtulo deve
ser colocada antes da instruo sendo rotulada,e consiste de um identificador vlido que
termina com dois pontos(:). As instrues rotuladas sero necessrias somente nas
situaes em que voc tiver um loop aninhado e precisa indicar qual quer encerrar ou a
partir do qual deseja continuar a prxima iterao.
2.5.3. Return:
A declarao return utilizada para sair de um mtodo. O fluxo de controle retorna para
a declarao que segue a chamada do mtodo original. A declarao de retorno possui dois
46
47
47
48
Capitulo 3.
Casting.
identificadores.
49
Exemplo 02:
Exemplo 03:
Neste exemplo vamos
mostrar atravs de um
programa como usar as
variveis estticas.
49
50
3.3. Constantes
O valor de uma varivel pode ser alterado durante a execuo do programa. Mas,o valor
de uma constante no alterado jamais. Por padro, recomendamos que crie constantes
sempre com letras maisculas por seguirem as normas da SUN, as constantes trazem
algumas vantagens,entre elas o fato de que nomes descritivos para constantes podem
tornar o programa mais fcil de ser lido.
Sintaxe:
final static tipo_de_dado IDENTIFICADOR = valor;
Exemplo 01:
51
A regra fundamental para o cast : o casting no modifica o objeto ou valor que est
sendo moldado; porm, o receptor do cast constitui um novo objeto ou um novo tipo. O
casting de dados primitivos ocorre com bastante frequncia. A maneira pelo qual o casting
age depende da preciso dos dados envolvidos. Por sua vez, a preciso depende da
quantidade de informaes que um tipo pode conter; assim, um tipo de ponto flutuante
double tem maior preciso que um float, pois o primeiro um tipo de 64 bits e o segundo,
de 32 bits.
Um byte pode ser convertido em um short, int, long, float ou double
Um short pode ser convertido em um int, long, float ou double
Um char pode ser convertido em um int, long, float ou double
Um int pode ser convertido em um long, float ou double
Um long pode ser convertido em um float ou double
Um float pode ser convertido em um double
Sempre que houver uma transferncia de dados de um tipo menos preciso para um mais
preciso, o casting explcito no obrigatrio.
Exemplo 02:
Exemplo 03:
51
52
Exemplo 04:
Exemplo 05:
52
53
Ou
53
54
Capitulo 4.
4.1. Introduo
Programao Orientado a Objeto, constitui em um conjunto de regras de programao.
Estudamos anteriormente como programar de forma estruturada, inicivamos a execuo
do cdigo e finalizando todos os processos na mesma classe . Porm sem saber estvamos
usando algumas regras de POO(Programao Orientada a Objetos) como por exemplo,
usando a classe System ou JOptionPane. Essas classes no foram criadas por ns,
porm elas foram reaproveitadas em nosso cdigo com objetivo de resolver os nossos
algoritmos. Vamos fazer uma comparao com o dia- a -dia para entendermos melhor .
Fabrica de Computadores.
Servio de Digitao.
Relatrio Final.
54
55
56
CLASSE
ATRIBUTOS
MTODOS
Agora construmos a nossa classe, mas o que significa este public antes dos atributos
e mtodos e o que significa o void? Para entender melhor , temos que aprender sobre
Encapsulamento e tipo de retorno de dados. Assunto que iremos ver no
prximo tpico.
4.4. Encapsulamento.
Encapsulamento uma forma de proteo do nosso cdigo, existem informaes que
queremos que outras classes vejam, outras no. Imagine a sua conta de e-mail. A conta do
seu usurio poder ser vista por outras pessoas, pois ele ir identificar o seu e-mails dos
demais, porm a sua senha algo privado onde s voc poder ter acesso a ela. Da
mesma forma que queremos mostrar ou proteger os nossos dados, uma classe tambm tem
as mesmas necessidades e podemos defini-las atravs do encapsulamento.
protected - ou protegido, pode ser acessado apenas pela prpria classe ou pelas
suas subclasses).
Assim podemos alterar o public da nossa classe por outro valor de encapsulamento,
dependendo da necessidade de proteo dos nossos atributos ou mtodos. Por boas
prticas de programao, os atributos da nossa classe Pessoa ester como private.
Faa alterao de encapsulamento na classe Pessoa.
56
57
4.5. Retorno
Os mtodos podem realizar uma ao interna e podem influenciar em outros mtodos
atravs do seu Retorno. Ele pode representar os tipos primitivos de dados que conhecemos
como : int, string, double, float, chat, boolean por exemplo, ou pode retornar vazio,
simbolizado por void. Os mtodos que tiver retorno, dever ter dentro do seu corpo um
return que ir representar o resultado final da minha operao.
Veja o exemplo abaixo:
Nesse cdigo o nosso construtor responsvel por alimentar os atributos nome e data de
nascimento da pessoa. tambm garantimos que ao momento da construo do objeto, uma
Pessoa no poder existir se no tiver um nome e uma data de nascimento.
Mas como eu poderei alterar o meu CPF, RG, e como poderei mostrar esses valores de
atributos? Assunto que veremos no prximo tpico.
58
como referencia. Ento, iremos voltar a classe que tenha o mtodo main e realizar a
seguinte operao:
Agora estou estanciando o meu objeto e de acordo com meu construtor, eu preciso
obrigatoriamente de um nome = Fabrcio e uma data de nascimento = 17/02/87 todos
eles do tipo String. Vamos agora usar os mtodos da nossa classe criada.
Dessa forma podemos modificar e acessar qualquer varivel dependendo das nossas
necessidades. Todas as informaes do Fabrcio esto dentro de uma varivel do tipo
Pessoa chamada de x. Se eu quiser criar uma nova pessoa, posso cham-la de qualquer
outro valor.
58
59
59
60
Capitulo 5.
Herana e Interface.
5.1. Introduo
Estudamos anteriormente como estruturar as nossas classes, agora precisamos gerar
uma interao entre classe criadas. Para isso no conceito de POO tambm temos que saber
Interface e herana. Iremos aprender casa uma delas, seu conceito e como implementlas.
5.2.Herana
60
61
Exemplo 01: Neste exemplo vamos mostrar como proceder com esse poderoso recurso
do java que chamamos de herana simples.
Cdigo da superclasse Conta.
61
62
62
63
Nota: Java permite que uma classe herde apenas as caractersticas de uma nica classe,
ou seja, no pode haver heranas mltiplas. Porm, permitido heranas em cadeias, por
exemplo: se a classe Mamfero herda a classe Animal, quando fizermos a classe Cachorro
herdar a classe Mamfero, a classe Cachorro tambm herdar as caractersticas da classe
Animal.
Como estamos tratando de herana de
classes, toda classe tem seu mtodo construtor.
Portanto, se estamos trabalhando com duas
classes, temos dois mtodos construtores. Para
acessarmos o mtodo construtor da classe que
est sendo herdada usamos o super().
Exemplo 02:
Para demonstrar como definir o relacionamento de herana, considera-se o contexto de
63
64
ter que desenvolver um programa que simule o comportamento de vrios tipos de animais
como mostrado na figura ao lado em um determinado ambiente.
Inicialmente, apenas um grupo de
animais estar presente neste ambiente
e cada animal deve ser representado
por um objeto. Alm disso, os animais
movem-se no ambiente ao seu modo e
podem fazer um conjunto de coisas. O
programa dever prever que novos
tipos de animais podero ser includos
no ambiente.
O primeiro passo observar cada animal e definir o que cada objeto do tipo animal tem
em comum no que diz respeito aos atributos e comportamentos (mtodos). Deve-se definir
tambm como os tipos de animais se relacionam. Inicialmente, o programa deve simular o
comportamento dos animais ilustrados na figura, ou seja, de um leo,de um lobo,de um
gato, de um hipoptamo, de um tigre e de um cachorro .
O segundo passo consiste em projetar a superclasse, ou seja, a classe que representa o estado e o
comportamento em comum a todos os animais. Para este exemplo, como todos os objetos so
animais, a superclasse foi denominada como Animal e as variveis e mtodos em comuns a todos
os animais foram atribudos a ela, como ilustrado na Figura. Neste exemplo, cinco variveis foram
definidas: (o tipo de comida que o animal come), (o nvel de fome do animal), (representao da
altura e largura do espao que o animal vagar ao seu redor) e (as coordenadas X e Y do animal no
espao). Alm disso, quatro mtodos foram definidos para definir o comportamento dos animais:
(comportamento do animal ao fazer algum rudo),(comportamento 57 do animal ao comer),
(comportamento do animal dormindo) e (comportamento do animal quando no est nem
dormindo nem comendo, provavelmente vagueando no ambiente).
64
65
Os construtores da superclasse no so herdados pela subclasse, logo, esta dever ter seus
prprios construtores para inicializar seus atributos. Todavia, ao instanciar um objeto da
subclasse, devemos inicializar aqueles atributos que ela est herdando, e o fazemos
chamando algum construtor da superclasse, usando a chamada super(...).
Dessa forma podemos dizer que MeuCarro que poder ser um Objeto, herda de
Carro que uma classe abstrata.
65
66
66
67
5.4.Interface
Interface uma espcie de superclasse 100% abstrata que define os mtodos que uma
subclasse deve suportar, mas no como esse suporte deve ser implementado. Isso porque
ao criar uma interface,estar definindo um contrato com o que a classe pode fazer,sem
mencionar nada sobre como o far. Uma interface um contrato. Qualquer tipo de classe
(concreta) e de qualquer rvore de herana pode implementar uma interface.
Exemplo 01:
Exemplo 02:
Exemplo 03:
67
68
Capitulo 6.
Tratamento de Excees
O termo excees significa condio excepcional, e uma ocorrncia que altera o fluxo
normal do programa. Vrias coisas podem levar a excees,incluindo falhas do
hardware,exausto de recurso e os famosos erros. Quando isso acontece,ou seja quando
ocorre um evento excepcional ocorre em Java,diz se que uma exceo ser lanada.
Exemplo 01:
Nota: O mtodo calc se for chamado com y igual zero(0),gerar um erro e uma exceo
ser lanada, esse erro poder ser sinalizado no bloco try-catch,ento a execuo do
mtodo pular para a bloco de cdigo catch,onde ser mostrado uma mensagem de erro.
68
69
Exemplo 02:
Caso 01: Neste exemplo vamos chamar o mtodo converteStr(),passando uma string
numrica,que no nosso caso 8 e o resultado a converso da string em um nmero de
ponto flutuante,da a diviso feita e a execuo do programa acontece sem nenhum
problema.
Caso 02: Neste mesmo exemplo vamos chamar agora o mtodo converteStr(),passando
uma string no numrica,que no nosso caso a caractere 'n' e o resultado o lanamento
de uma exceo,jogando o fluxo de execuo do programa para o bloco catch,onde
imprime uma mensagem na no console.
6.1.1. Finally
Finally: o trecho de cdigo final. A funo bsica de finally sempre executar seu
bloco de dados mesmo que uma exceo seja lanada. muito til para liberar recursos do
sistema quando utilizamos, por exemplo, conexes de banco de dados e abertura de buffer
para leitura ou escrita de arquivos.
69
70
Exemplo 02:
71
atingiu o final do mtodo (return implcito, somente no caso de mtodos do tipo void!), (ii)
porque o fluxo de controle atingiu um comando return, ou (iii) porque foi executado um
throw implcito ou explcito que no foi apanhado por um comando try-catch daquele
mtodo. A procura por um try-catch apropriado propagada at o ponto em que h um
retorno para o mtodo main, neste caso a execuo do programa ser finalizada, com
mensagem de erro provida pela MVJ dizendo que uma exceo foi lanada sem que fosse
apanhada. E dever ser mostrado algo como:
71
72
Capitulo 7.
Herana (Polimorfismo )
7.1. Introduo
Neste capitulo veremos como funciona a interao com classes em Polimorfismo.
Usamos esse recurso quando queremos que modificar mtodos herdados para isso temos
que aprender o conceito e prtica de sobrecarga e sobrescrita. Veremos estes assuntos
no prximo tpico.
7.2. Sobrecarga.
Usamos sobrecarregar de mtodos quando temos um determinado mtodo com o
mesmo nome, porm com assinaturas diferentes, sou seja, parmetros diferentes, dessa
forma quando usamos um determinado mtodo com sobrecarga podemos escolher qual
mtodo sobrecarregado ser usado de acordo com o nmero e tipo de dados do
parmetros oferecidos. Veja um exemplo abaixo :
Na Classe animal criamos 2 mtodo chamado comer, o mtodo que no contm nenhum
parmetro, o animal apenas mostra a ao de comer, estado da carne. O nosso segundo
mtodo, tambm chama-se comer, porm ele tem um assinatura diferente, ele recebe
como parmetro um valor boleano que refere-se ao estado da carne, dessa forma o animal
pode simplesmente comer ou verificar o tipo de alimento antes de se alimentar.
7.3. SobreEscrita
Usamos sobrescrita de mtodos quando temos que modificar um mtodo herdado da
classe pai, para sobrescrever os mtodos teremos que criar o mesmo mtodo herdado na
classe filha com o nome assinaturas igual. Levando em considerao a classe Animal
criada no tpico anterior, veja no exemplo abaixo:
73
um mtodo de sobrescrita.
7.4. Polimorfismo
Podemos dizer que polimorfismo quanto temos mtodos de sobrescritas distintos entre
classes filhas que referencia um mesmo Pai. Veja o exemplo abaixo.
Pessoa
Professor
Aluno
Note as roupas que eles usam. A pessoa por padro, tem um estilo de roupa, porm
dependendo da situao, temos que usar roupas especficas para cada situao. Um
professor tambm uma pessoa, porm do tipo Professor e ele precisa de um tipo
especfico de uniforme para dar suas aulas. O aluno tambm uma Pessoa, porm ele
precisa de um fardamento adequado para assistir as aulas. Assim ns temos a classe
Professor e Aluno herdando de Pessoa Porm cada uma delas tem mtodos
diferentes quando nos referimos como se vestir. Vamos ver como ficaria em cdigo java o
nosso Polimorfismo.
73
74
Classe Pai
74
75
Capitulo 8.
UML
8.1.Introduo
Neste captulo iremos aprender como, instalar e criar uma diagramao de classes
usando o Netbeans para a linguagem Java. UML significa : Unified Modeling
Language, ou seja Linguagem de Modelagem unificada. Modelar nossa cdigo com
objetivo de documentar e visualizar melhor o projeto.
Para realizar a instalao simples, basta ir em Ferramentas > Plugins e buscar por
UML. Este plugin est disponvel livremente a partir da verso 6.7.
Antes de comearmos a trabalhar com eles, precisam saber quais is tipos de diagramas
podemos desenvolver e qual a utilidade de cada uma dentro de um Projeto de qualquer
escala.Tipos de Diagramas.
maioria das transies ativada por concluso das aes nos estados de origem.
Um ator uma pessoa (ou dispositivo, ou outro sistema) que interage com o
sistema.
Neste Curso aprenderemos como trabalhar com Diagrama de Classe, pois esse
diagrama bem prximo da criao e estruturao de classes e herana entre as classes
criadas.
75
76
76
77
Na direita Clicando em Class, clique no palco principal que ser gerado uma nova
classe indefinida. Para alterar a Classe, basta clicar em Create Atributes para criar os
atributos , e Create Operation para criar os mtodos, lembre-se que para o diagrama,
primeiro vem o nome da varivel ou mtodo, em seguida vem o seu tipo:
Exemplo: nome : String
Veja como criar uma classe simples com o tipo, pessoa:
Dessa forma podemos criar qualquer classe com os seus atributos e mtodos de forma a
poder visualizar melhor a estrutura do projeto.
Para criar interface ou Herana, basta clicarmos em uma classe ao qual voc quer
montar uma relao e aparecer o seguinte menu ao lado:
Implementation podemos criar uma implementao, ou seja
uma interface.
77
78
Capitulo 9.
Fila e Pilha
9.1. Fila
Imagine que voc tem uma Fila de atendimento em um Banco.
O que podemos observar em uma Fila?
A pessoa que atendida, sempre o primeiro em uma fila e logo depois de ser
atendido, ele sai da fila, dando lugar a outras pessoas alterando a ordem de
chamada de todo mundo. Quem era o terceiro, passa a ser o segundo, quem era o
segundo passa a ser primeiro na fila.
Tudo o que acontece em uma fila normal tambm pode ser implementado na
Programao Java.
Funo
element(Object);
offer();
poll();
78
79
10
Sendo assim, se usarmos o mtodo Poll mais 5 vezes, estes elementos seriam retornados e
retirados da fila nessa ordem mantendo a fila vazia. Quando a Fila estiver vazia, o comando Poll
passar a retornar null.
Vrios sistemas usam esse recurso, como sistema de atendimento ao cliente, um sistema de fila de
impressora onde os primeiros documentos a serem impresso tero prioridade em relao aos outros
documento que sero impresso em seguida. Pesquise por mais implementaes usando o recurso de
Fila.
79
80
9.2. Pilha
Imagine uma Pilha de Pratos a ser lavados o que podemos observar?
Mtodo
Funo
empty()
push();
pop();
peek();
80
81
10
Sendo assim, se usarmos o mtodo pop mais 4 vezes, estes elementos seriam retornados e
retirados da pilha na ordem inversa mantendo a pilha vazia. O Comando pop no retorna null
quando a pilha estiver vazia, ento recomanda-se sempre verificar se contm elementos na pilha
usando o mtodo empty.
Vrios sistemas usam esse recurso, um deles bem usado por ns sem percebermos, imagine que
est digitando um texto e precisa desfazer uma operao. Cada elemento de Input posto em
uma pilha e quando usamos o CTRL+Z como usar um pop na pilha de retirando apenas o
ultimo elemento digitado.Pesquise por mais implementaes usando o recurso de Pilha.
81
Aprendemos em captulos anteriores que existe uma estrutura de dados chamada Array.
Essa estrutura de dados ela foi criada para guardar na memria do computador dados
primitivos ou objetos do mesmo tipo, de maneira organizada (bloco de dados contnuo),
em que cada informao pode ser acessada por ndices(index),
A estrutura de dados Array muito inflexvel, preciso definir seu tamanho assim que
ns a criamos. E isso pode gerar um problema para ns programadores Java.
Vamos analisar a seguinte situao:
Criaremos um Array para guardar os nomes de uma lista de 10 alunos do Curso de Java
UTD:
Mas se no meio do meu programa eu precisar acrescentar a minha lista mais 20 alunos.
Como o tamanho do Array alunosNomes foi definido com 10 posies ento no seria
possvel adicionar os 20 novos alunos a essa estrutura, teramos que tratar isso. Uma das
alternativas para fazer isso acrescentar o seguinte cdigo:
82
83
10.2.
Uma lista uma coleo de elementos arrumados numa ordem linear, isto , onde cada
elemento tem um antecessor (exceto o primeiro) e um sucessor (exceto o ltimo).
Normalmente implementada como "Array" ou "Lista Encadeada". A Lista pode ser
mantida ordenada ou no e as operaes mais importantes de uma coleo do tipo Lista
so:
Adio de elementos
Remoo de elementos
Pesquisa de elementos
Em Java existem trs classes que trabalham com a Coleo do tipo Lista ou List elas se
encontram no pacote/package java.util . So elas:
Vector
ArrayList
LinkedList
Escolhemos explanar nesse captulo a classe Java mais utilizada para implementar listas
que a classe ArrayList.
84
10.3.
ArrayList
85
10.3.1.
Para criar uma lista usando a Classe ArrayList do Java, escreva em seu programa a
seguinte linha de cdigo:
tipo: tipo do objeto que voc quer guarda na lista. Ex: Integer, String, Carro, Pessoa...
Exemplo:
Na verso 7 do Java voc tambm pode criar uma lista dessa forma:
Observao:
Todas os cdigos que trabalharem com listas usando a classe ArrayList precisam
importar a classe ArrayList. Isso pode ser feito adicionando a seguinte instruo no
cabealho da classe:
import java.util.ArrayList;
10.3.2.
Agora que voc j criou seu objeto Lista voc pode adicionar elementos dentro dela. As
Listas quando criadas elas no possuem nenhum elemento, ou seja, elas so Listas Vazias.
Na Lista, diferente do Array, voc no especifica seu tamanho, ela cresce de forma
dinmica medida que voc acrescenta dados a ela.
Vamos aprender como adicionar elementos a uma Lista, para isso iremos usar o mtodo
add() que pertence a classe ArrayList.
86
Exemplo:
O mtodo add(), usado da forma mostrada acima ele sempre coloca o novo dado
adicionado lista na ultima posio da mesma, mas podemos utiliz-lo de outra maneira,
de tal forma que podemos escolher a posio em que queremos adicionar o novo elemento.
Vamos ver como fica essa outra forma de usar mtodo add().
Exemplo:
Para visualizar todos os lados da lista na forma de uma String use o mtodo toString(),
desta forma:
Vamos aplicar esse mtodo no exemplo em que criamos uma lista de anos, ficar desta
maneira:
87
Sada do programa:
10.3.3.
Vamos aplicar esse mtodo no exemplo em que criamos uma lista de anos, ficar desta
maneira:
88
Outra forma de usar o mtodo remove() passando para o mtodo o objeto que voc
quer remover. Ficando desta forma:
Exemplo:
10.3.4.
Para acessar um valor de uma determinada lista usamos o mtodo get() da classe
ArrayList dessa forma:
Exemplo:
Temos mtodos na classe ArrayList para auxiliar na interao da lista, ou seja, percorrer
a lista acessando os seus valores em todas as direes possveis.
Esses mtodos precisam, alm da lista que iram auxiliar a percorre, um objeto do tipo
ListIterator onde esse objeto ser como um leitor de posies da lista que pode
89
Agora vamos criar um objeto do tipo ListIterator, onde esse objeto ser como um leitor
de posies da lista que pode ser deslocado para frente e para trs ao longo de uma lista.
Para criar um objeto do tipo ListIterator precisamos importar a classe que cria esse objeto
para o nosso programa, pois esse objeto no pode ser instanciado pela classe ArrayList. A
importao da classe feita adicionando a seguinte instruo no cabealho de sua classe:
import java.util.ListIterator;
Aps importar o mtodo podemos criar nosso objeto do tipo ListIterator da seguinte
maneira:
Por fim, podemos usar os mtodos da classe ArrayList que nos ajudam a percorrer uma
lista, da seguinte forma:
90
Sada do programa:
10.3.5.
Exemplo:
Sada do programa:
92
10.4.
Um mapa armazena pares (chave, valor) chamados itens, essas chaves e valores podem
ser de qualquer tipo, portanto, a chave utilizada para achar um elemento rapidamente.
Estruturas especiais so usadas para que a pesquisa seja rpida, como "Tabela Hash" ou
"rvore". Os dados armazenados nos mapas podem ser mantidos ordenados ou no (com
respeito s chaves).
A coleo do tipo Mapa difere das Listas por diversas caractersticas, as principais so:
Remoo de elementos
Pesquisa de elementos
Vamos utilizar a classe HashMap para trabalhar com colees do tipo mapa ou map.
93
10.5.
HashMap
Vamos explanar os principais mtodos da classe HashMap, mtodos que nos permitir
criar, adicionar, remover, selecionar e pesquisar itens em uma coleo do tipo Map.
10.5.1.
Para criar um mapa usando a Classe HashMap do Java, escreva em seu programa a
seguinte linha de cdigo:
tipo_da_chave: coloque o tipo que ter a chave/ndice do seu Map, essa chave ser
usada para acessar os valores guardados no Map;
tipo_do_valor: coloque o tipo que ter os valores que sero guardados em seu Map;
Pronto, dessa forma j instanciamos
HashMap.
Agora temos que inserir elementos a coleo do tipo Map , pois s criamos o Map, mas
no h elementos dentro dele.
Lembre se de importar a Classe HashMap para seu programa, j que estamos usando-a
para implementar e trabalhar com Colees do tipo Mapa. Podemos importar a classe
colocando a seguinte instruo no cabealho do programa o qual estamos escrevendo:
import java.util.HashMap;
10.5.2.
Aps criar o seu Map, podemos adicionar um elemento usando o mtodo put() da
Classe HashMap da seguinte forma:
objeto_chave: valor do objeto que ser a chave de acesso para os valores do mapa;
objeto_valor: valor do objeto que ser guardado no mapa;
Exemplo:
Vamos criar um Map para guardar estados e suas respectivas capitais. Os estados sero
as chaves e as capitais sero os valores guardados no Mapa, ambos sero do tipo String.
Agora vamos adicionar os valores ao nosso mapa usando o mtodo put, da seguinte
forma:
Vamos usar o mtodo toString() para visualizar como esto os dados dentro do nosso
mapa, da seguinte forma:
Sada do Programa:
95
10.5.3.
Para remover elementos de uma coleo do tipo Mapa usando os mtodos da Classe
HashMap usamos o mtodo remove().
O mtodo remove() retorna uma String com o valor removido do mapa ou retorna o
valor null se no for achado nenhum valor associado a chave passada no argumento do
mtodo.
Exemplo:
Vamos remover uma capital do mapa cidadeEstado criado anteriormente. O cdigo ir
ficar dessa maneira:
Sada do programa:
96
10.5.4.
Selecionando/Pesquisando elementos em uma coleo do tipo
Mapa
O mtodo de seleo get() da classe HashMap o mesmo mtodo usado para se
pesquisar um valor dentro de um mapa. Esse mtodo funciona da seguinte forma:
Sada do programa:
10.5.5.
97
Exemplo:
Sada do programa:
98
Capitulo 11.
99
A partir da verso 2 do Java, a JFC (Java Foundation Classes) apresentou novos recursos
para a construo da GUI das aplicaes, o que melhorou muito os problemas de
portabilidade. So eles:
bom salientar que o Swing no substitui o AWT, mas o kit de ferramentas GUI mais
utilizado para desenvolvimento de aplicaes visuais. O AWT continua existindo,
mantendo a mesma arquitetura criada para o Java verso 1.1.
O Swing possui muito mais recursos, alm de garantir maior portabilidade e, em boa
parte dos casos, mais fcil de usar. Isso no significa que ou se utiliza AWT ou se utiliza
Swing, normalmente o que acontece que elementos das duas bibliotecas so utilizados
conjuntamente nas aplicaes.
import javax.swing.*;
import java.awt.*;
11.3. JFrame
Pode parecer estranho para quem vem de outras linguagens, como o Delphi ou o VB,
mas em Java, cada tipo de componente grfico uma classe com atributos e mtodos
prprios. E para utiliz-las, devemos instanci-las.
11.3.1.
Camadas JFrame
Antes que possamos criar nossa primeira janela precisamos conhecer como funciona a
hierarquia dos elementos que so responsveis visualizao grfica.
Frame
RootPane
LayeredPane
ContentPane
GlassPane
Onde:
100
11.3.2.
A primeira e mais simples chama-se JFrame, e cria telas retangulares sem nada dentro,
um espao onde trabalharemos logo depois.
101
No construtor
podemos tambm
definir qualquer
outra propriedade na sua chamada, como coordenadas, cor do plano de fundo,
procedimento utilizado quando for fechado a janela,layout, visibilidade, etc. Veja o
Exemplo abaixo ainda no mesmo construtor :
102
Temos ento o mesmo resultado do tpico anterior, perceba que se quisermos criar uma
2 janela por exemplo, no precisamos definir todas as propriedades novamente, basta
instanciar uma nova MinhaJanela definindo um segundo ttulo, assim teremos uma nova
janela.
Usando herana, podemos atravs da nossa classe definida acessar os elementos do
Jframe baseado no seu nvel de encapsulamento. No Exemplo abaixo usaremos o mtodo
setLocation() para alterar a localizao da nosssa janela. Esse mtodo no foi criado por
ns, mas foi definido pelas classes Pai nas definies de herana da Classe Jframe.
Iremos usar o exemplo da Classe Minha Janela para criar os componentes nos prximos
tpicos.
103
11.5. JLabel
um pequeno componente com o qual colocamos pedaos de texto sem nenhuma
funo, a no ser a de indicar para qu servem os campos de uma tela qualquer.
O cdigo acima no apresenta grandes novidades. Apenas instanciamos o Jlabel, dandolhe um texto qualquer para exibir. Depois, demos o mesmo setBounds nele, em seguida
fizemos a ao realmente revolucionria:
super.getContentPane().add(texto);
Adicionamos o objeto texto na tela usando super.getContentPane(). Note que o
setBounds do texto passa a usar como bordas as bordas do JFrame. E fica contido nele.
O JLabel pode ter desenhos por dentro, mas veremos isso mais adiante, quando
tratarmos do Icon, outro tipo de objeto Java.
O resultado de nossa janela esse:
104
11.6. JButton
O JButton , finalmente, o boto. Colocamos ele nas telas com inmeras funes. Estas
funes sero tratadas mais adiante, quando chegarmos s aulas sobre Eventos. Por
enquanto, basta-nos desenhar os botes.
O JButton poder ser instanciado de trs formas diferentes:
1. JButton() aqui, teremos depois que rodar um mtodo setText(algum texto)
para dar-lhe um contedo(um contedo que aparece para o usurio).
2. JButton(String) aqui, escrevemos algum texto para aparecer no boto e o
usurio saber do que se trata.
3. JButton(icon) neste caso, adicionamos uma figura ao boto para dar-lhe uma
aparncia personalizada.
Veja este cdigo:
No exemplo acima, usamos praticamente a mesma tela criada antes, porm adicionamos
as rotinas de criao de um boto. Primeiro, instanciamos a classe JButton e usamos os
mtodos j conhecidos setBounds para definir suas coordenadas.
105
11.7. JTextField
O JTextField uma caixa utilizada para que o usurio possa escrever um texto de uma
linha s. Tratasse de um componente bastante simples, que tem basicamente as mesmas
especificaes dos que acabamos de ver: setBounds, setBackground, setForeground, e o
ADD da tela sobre ele.
Enriquecendo o cdigo anterior, adicionando um JTextField:
106
11.8. Icon
A classe Icon tem um uso bastante simples, mas muito importante. Com ela, podemos
carregar uma imagem (devidamente criada em um arquivo JPG ou PNG), para dentro do
programa, utilizando esta imagem como quisermos.
O comando para isso bastante simples. Basta instanciar a classe Icon criando uma
ImageIcon que carregar o arquivo, cujo nome ou localizao completa.
Comando assim:
Icon imagem = new ImageIcon(arquivo.jpg);
Existe ainda uma funcionalidade que muita gente desconhece: O formato de imagem
PNG, que capaz de armazenar instrues sobre transparncias, quando lido, acaba numa
imagem com transparncias, pois o Java consegue respeitar bem estes parmetros.
Depois de carregarmos uma imagem para dentro de uma varivel, podemos atribu-la a
uma srie de objetos atravs do mtodo setIcon.
Exemplos:
JButton botao = new JButton();
botao.setIcon(imagem);
JLabel rotulo = new JLabel();
rotulo.setIcon(imagem);
Um detalhe importante a notar que, quando atribumos o Icon a um JButton, o boto
ganha o desenho mas permanece com o aspecto de boto, mudando a cor da borda
quando colocamos o mouse sobre ele.
J quando atribumos o Icon a uma JLabel, a imagem fica parecendo solta no ar entro da
tela. E a, a transparncia tem realmente sua funo efetiva, uma vez que o fundo atrs da
JLabel aparece plenamente.
possvel fazer botes redondos, triangulares ou com qualquer forma, usando Jlabel,
simplesmente desenhando o boto, colocando em uma JLabel e, na funo do boto,
107
incluir um comando para mudar o Icon da JLabel, trocando-o por uma figura do mesmo
boto, mas com aparncia de pressionado.
11.10.
Estas classes so utilizadas sempre em conjunto, para criar um menu na parte superior
do JFrame, e deixar seu software com aquela facilidade de uso que os usurios modernos
exigem.
Aqui, comeamos a trabalhar uma modalidade de programao que costumo chamar
informalmente de empilhamento de objetos, pois os objetos s funcionam quando
colocamos um dentro do outro em uma espcie de pirmide.
O objeto que serve de base o JMenuBar, adicionado diretamente ao JFrame, e sobre ele
vo todas as coisas. Ele a barra clara no alto do JFrame, dentro da qual os menus ficaro.
Depois, temos os JMenu, que ficam dentro da MenuBar e podem, inclusive, ficar um
dentro do outro. Dentro dos JMenu, ficam os JMenuItem, que tm uma funo cada um.
Para ativar suas funes, utilizaremos os Listeners, mais adiante. Deixemos isso para outro
captulo.
Criando uma janela, um JMenuBar(container de menus), Menus(JMenu) e por fim itens
de menus(JMenuItem).
108
109
11.11.
JCheckBox
110
11.12.
JRadioButton
112
11.13.
JComboBox
113
Para obter o retorno das informaes, temos uma srie de mtodos que nos dizem o que,
afinal, o usurio escolheu. Os mais usados so os seguintes:
comb.getSelectedItem()
Este retorna o texto que est na caixa do Combo. Poder ser usado especialmente para
quando colocamos o setEditable em TRUE, ou seja, quando o usurio pode escrever na
caixa. O retorno deste mtodo uma String, com o texto da caixa.
comb.getSelectedIndex();
Este mtodo retorna o ndice do item selecionado (como se as opes fossem um vetor).
Caso o usurio possa escrever algo na caixa de texto, e escreva alguma coisa que no consta
das opes fornecidas, ento o ndice que retorna o -1. Portanto, s use se o setEditable
for FALSE.
11.14.
Existem mais componentes Swing, alm dos mostrados at aqui. Foram mostrados os
principais componentes. Caso voc precise ou deseje conhecer mais componentes Swing
acesse:
http://docs.oracle.com/javase/7/docs/api/
Capitulo 12.
Gerenciadores de Layout
114
12.2.
BorderLayout
12.3.BoxLayout
Um BoxLayout coloca os componentes em uma nica linha ou coluna, permitindo ainda
que voc especifique o alinhamento deles. Digite o seguinte programa e salve em um
arquivo chamado "BoxLayoutTest.java":
115
12.4.
FlowLayout
116
12.5.GridLayout
Um GridLayout atua como uma grade de uma planilha de clculo, colocando os
componentes em linhas e colunas pr-determinadas e deixando os componentes com o
mesmo tamanho. Veja isso no programa "GridLayoutTest.java":
117
12.6.
GridBabLayout
118
119
Capitulo 13.
Eventos (Listeners)
13.1. ActionListener
Vamos estudar algo muito interessante: o ActionListener. Trata-se de uma classe que
detecta se houve uma ao no objeto a que ela est associada (um boto, por exemplo), e
que, dependendo da ao executada, rodar uma funo qualquer. Vejamos um exemplo
de cdigo usando o ActionListener:
13.2.FocusListener
O FocusListener se parece com o ActionListener em seu modo de construo, mas serve
para detectar quando o foco (ou seja, o cursor, a seleo, no o ponteiro do mouse) est
sobre um objeto ou no.
Ele possui dois mtodos que precisam ser implementados: o focusGained e
o focusLost, um para quando o objeto ganha foco e outro para quando perde.
121
13.3.KeyEvent
O KeyEvent serve para que eu possa coordenar as aes do usurio com o teclado
quando ele est escrevendo em algum espao ou utilizando alguma funo. Posso atribuir
KeyListener a qualquer objeto grfico do Java QUALQUER! e detectar o que, afinal, o
meu usurio est apertando no teclado.
Acima, defini a ao a executar para quando o usurio tira o dedo do boto que havia
pressionado.
122
O mtodo keyTyped funciona quando o aperto da tecla faz efeito. Isso quer dizer que se
eu botar o dedo numa letra do teclado, e no tirar mais, e esta letra ficar se repetindo, o
evento keyTyped tambm ficar.
NOTA: Pode-se detectar qual o boto apertado pelo usurio explorando a varivel
KeyEvent e, que retornar o cdigo da tecla apertada.
13.4.
MouseListener
O MouseListener, como seu nome obviamente revela, serve para tratarmos eventos
relacionados ao uso do mouse.
123
O mtodo mouseEntered ocorre quando o mouse adentra, quando o ponteiro passar por
cima.
124
125
14.2.
126
14.3.
Sabemos que para nossa aplicao Java possa se comunicar com o Banco de dados
precisamos utilizar um conjunto de classes Java(API) escritas por terceiros que chamamos
de Driver JDBC. E que cada SGDB tem um driver JDBC especfico. Vamos ento fazer o
download do driver JDBC que iremos utilizar em nosso projeto Agenda.
O driver JDBC escrito para o MySQL Server, tambm chamado pela MySQL de
Conector J encontra-se no link abaixo:
http://dev.mysql.com/downloads/connector/j/
O site do MySQL ir lhe redirecionar para uma pgina de cadastro(opcional). Voc pode
pular esse cadastro clicando no link No thanks, just start my download.(No obrigado,
apenas iniciar meu download) veja imagem abaixo:
127
Dentro da pasta descompactada voc encontrar o driver JDBC para o SGBD MySQL Server, um
arquivo no formato .jar, que seria todas as classes que implementam o driver JDBC compactadas e
prontas para utilizao em seu programa Java.
128
14.4.
IDE Eclipse: Importando o driver JDBC para o
nosso projeto
1. Crie um novo projeto Java na IDE Eclipse:
129
e escolha a opo:
JARs...
arquivo 2 vezes.
130
Java.
131
14.6.
J temos o que precisamos para manipular o MySQL Server atravs de nosso programa
Java. Vamos criar uma conexo entre o Banco de Dados e nossa aplicao Java.
Para abrir uma conexo com um banco de dados, precisamos utilizar sempre um driver.
A classe DriverManager a responsvel por se comunicar com todos os drivers que voc
deixou disponvel. Para isso, invocamos o mtodo esttico getConnection com uma String
que indica a qual banco desejamos nos conectar.
Essa String - chamada de String de conexo JDBC - que utilizaremos para acessar o
MySQL tem sempre a seguinte forma:
jdbc:mysql://ip/nome_do_banco
PostgreSQL jdbc:postgresql://servidor:porta/banco
SQL Server
14.6.1.
jdbc:sqlserver://servidor:porta;databaseName=banco
MySQL
jdbc:mysql://servidor:porta/banco
Java DB
jdbc:derby://servidor:porta/banco
Sybase
jdbc:sybase:Tds:servidor:porta/banco
Oracle
jdbc:oracle:thin:@servidor:porta:banco
132
133
I. Na linha 11 temos a criao da varivel url que do tipo String, ela ir receber a
String de conexo JDBC j discutido no tpico 15.5.
II. Na linha 12 criamos uma varivel conexao que um objeto do tipo
Connection(interface contida dentro do pacote java.sql). Por isso que fizemos o
import da linha 5. Esse pacote contm vrias classes e interfaces que so utilizadas
pelo driver JDBC. O mtodo getConnection um mtodo esttico da classe
DriverManager. Esse mtodo responsvel por solicitar uma conexo com o
banco de dados.
O mtodo getConnection sobrecarregado dentro de sua classe de origem,
utilizamos a opo do mtodo que recebe 3 parmetros, so eles: url de conexo
JDBC, login do usurio que ir utilizar o Mysql e senha do mesmo.
Lembre-se! Esse login e senha aquele utilizado para acessar o MySQL atravs do
MySQL Client(Captulo 3: Instalao 3.11/3.12).
O mtodo getConnection retorna uma conexo de sua aplicao com o banco,
caso no ocorra nenhum erro nos dados enviados para o mtodo ou no
carregamento/importao do driver JDBC.
Se um erro ocorrer uma exceo checada do tipo SQLException ser lanada. Nesse
exemplo no estamos capturando essa exceo com o bloco try-catch, mas
lanando a mesma para ser tratada para quem chamar o mtodo main(definio
de throws). Fizemos isso s por motivos didticos, mas em um projeto real temos
que colocar o bloco try-catch para capturar e tratar a possvel exceo lanada.
Iremos fazer isso futuramente.
Caso tudo ocorra bem ser impresso na tela a mensagem Conectado.
III.Na linha 14 fechamos o canal de conexo entre o banco e sua aplicao. No esquea
de fechar a conexo, aps fazer as operaes desejadas no banco.
14.6.2.
Vamos fazer alguns ajustes na classe Conexao implementada no tpico anterior para que
ela fique no padro ideal para aplicarmos no projeto. Veja abaixo como ficou a classe aps
as modificaes:
134
14.7.1.
Crie uma classe chamada Contato(ver tpico 15.5.1). Essa classe conter os atributos
id do tipo Integer, nomeContato e telefone do tipo String com o modificador de
acesso private e os mtodos de acesso get/set para os respectivos atributos. Nossa classe
Contato ficar dessa forma:
135
14.7.2.
Agora, vamos criar uma classe chamada ContatoDao(ver tpico 15.5.1) responsvel
por todas as operaes de acesso e C.R.U.D referentes aos dados dos contatos que sero
persistidos no banco de dados Agenda. A classe ContatoDao a princpio vai conter apenas
um atributo privado chamado de conexao que vai armazenar uma conexo com o banco
quando uma operao for solicitada pelo usurio.
Esta idia, inocente primeira vista, capaz de isolar todo o acesso a banco em classes
bem simples, cuja instncia um objeto responsvel por acessar os dados. Da
responsabilidade deste objeto surgiu o nome de Data Access Object ou simplesmente
DAO, um dos mais famosos padres de projeto (design pattern).
Vamos adicionar a classe ContatoDao o mtodo de insereContato responsvel por
inserir um objeto Contato na tabela contato do banco Agenda. A implementao do
mtodo ficou dessa forma:
136
VI. Depois da instruo sql pronta com todos as substituies feitas vamos enviar o
comando sql construdo pelo canal de comunicao aberto(PreparedStatement
stmt) utilizando o mtodo execute pertencente ao objeto stmt.
VII.
Se nenhuma exceo for lanada os dados do seu contato j estaro na tabela
contato do banco de dados Agenda, caso contrrio a exceo lanada ser capturada
pelo(s) catch informando para o usurio que um problema aconteceu e retornar o
valor false.
VIII.
Ns precisamos fechar os 2 canais de comunicao com o banco que abrimos:
conexao e o stmt; Independente se a operao ocorreu bem ou no. Para isso
utilizamos o bloco finally(linha 39) que o cdigo dentro dele sempre ser
executado.
IX. Na linha 42 fechamos o canal por onde foi enviado a instruo sql. Fazemos isso
chamando o mtodo close do objeto stmt. Esse mtodo pode lanar uma exceo
por isso colocamos a instruo stmt.close(linha 42) dentro de um bloc try-catch
para caso acontea uma exceo na hora da execuo da instruo, a exceo ser
capturada avisando para o usurio sobre o problema.
X. Na linha 45 fechamos a conexo armazenada no atributo conexao da classe
ContatoDao. Nesse utilizamos o mtodo close pertencente ao objeto
Connection conexao, para fechar a conexo com o banco. Colocamos essa
instruo em um bloco try-catch, pois pode lanar uma exceo checada.
Ateno: No podemos esquecer de fazer os tpicos X e XI, pois abertura de conexes,
sesses, threads so recursos caros e o mal gerenciamento pode causar um funcionamento
instvel de nossa aplicao.
14.7.3.
A classe ContatoDao est pronta para efetuar inseres de contatos no banco de dados
Agenda, mas especificamente na tabela contato. Vamos criar uma classe chamada
Agenda(ver tpico 15.5.1) dentro do pacote jdbc que efetuar a insero de um contato.
A classe Agenda foi escrita desta forma:
II. Na linha 11 foi criado o objeto c1 que do tipo Contato, classe criada em tpicos
anteriores.
III.Nas linhas 12 e 13 utilizamos o respectivo mtodos set para inicializar os atributos
do objeto c1, pois esses atributos so privados sendo possvel a modificao ou
acesso dos valores contidos nos atributos atravs dos mtodos get e set(conceito
de encapsulamento).
IV. Na linha 12 criamos um objeto bd do tipo ContatoDao, classe criada no tpico
15.6.2. Esse objeto ser o nosso objeto DAO(Data Access Object), atravs dele
podemos efetuar todas as operaes no Banco de Dados.
V. Na linha 13 atravs de uma simples chamada ao mtodo insereContato
conseguimos fazer a insero de um contato, ou seja, os valores armazenados nos
atributos do objeto c1 sero inseridos na tabela contato.
14.8.
Aprendemos no tpico anterior como inserir um contato em nossa agenda, mas se fosse
preciso inserir vrios contatos de uma s vez.
14.8.1.
Da forma que escrevemos o mtodo insereContato teramos que chamar vrias vezes o
mesmo, que por sua vez abrir vrias vezes um PreparedStatement que como um
canal por onde ser enviado a instruo com os dados a serem manipulados no banco para
o Mysql e isso ter que ser feito todas as vezes que um novo contato for inserido.
Lembre-se, quanto menos conexes e statements forem criados
proporcionar um melhor desempenho do seu sistema e evitar
inconsistncias.
139
14.8.2.
Vamos adicionar 10 contatos em nossa Agenda de uma nica vez utilizando o mtodo
insereContato que acabamos de implementar utilizando a classe Agenda, o cdigo ficar
dessa forma:
141
Aps a execuo da classe Agenda a nossa tabela contato se mostrar desta forma:
14.9.1.
Na linha 98 foi criado um canal por onde ser enviado a instruo sql.
VIII.
Na linha 99 um objeto do tipo ResultSet foi criado com o retorno do mtodo
executeQuery, o qual responsvel por realizar, especificamente, consultas sql no
banco de dados. O retorno da consulta programada na linha 93 representado no
Java por um objeto do tipo ResultSet, um tipo de lista.
IX. Na linha 100 temos um lao de repetio while. Na expresso de controle do
while foi colocado um mtodo next. Esse mtodo pertence ao objeto do tipo
ResultSet chamado de resultadoConsulta e ele acessa a prximo objeto da lista
resultadoConsulta e retorna true se houver tal objeto. Quando no houver um
prximo objeto a ser acessado o mtodo retornar false e o lao de repetio
parar.
X. Na linha 102 usamos o mtodo getInt passando como parmetro um valor inteiro.
Esse valor inteiro representa um ndice, onde o primeiro campo do registro no
momento acessado representado pelo nmero 1(um), o segundo pelo numero
2(dois)... O retorno do mtodo getInt nessa linha o valor contido no campo id da
tabela contato.
XI. Na linha 103 usamos o mtodo getString passando como parmetro um valor
inteiro. Esse valor inteiro representa um ndice, onde o primeiro campo do registro
no momento acessado representado pelo nmero 1(um), o segundo pelo numero
2(dois)... O retorno do mtodo getString nessa linha o valor contido no campo
contato na tabela contato.
XII.
Na linha 105 tambm utilizamos o mtodo getString, mas agora com uma
String como parmetro, essa String corresponde ao nome do campo que queremos
acessar no registro que est sendo no momento apontado. O retorno do mtodo
getString nessa linha o valor contido no campo telefone da tabela contato.
XIII.
Na linha 106 109 criamos e inicializamos os atributos de um objeto
contato com as informaes retornadas do banco de dados.
XIV.
Na linha 110 adicionamos o objeto gerado, nas linhas 106 109, dentro
da lista contatos instanciada na linha 92.
XV.
Nas linhas 113 a 116 temos um catch com dois tipos de excees. Como o
tratamento para ambas so iguais ento em vez de dois catch, um para cada tipo de
exceo, utilizamos o operador | que permite que um mesmo catch capture mais de
uma exceo.
XVI.
Dentro do bloco finally colocamos o cdigo para fechamento do Connection,
do ResultSet e do PreparedStatement. Todas essas instcias precisam ser fechadas
utilizando o mtodo close();
143
14.9.2.
14.10.
144
14.10.1.
14.11.1.
145
14.12.
Exerccios propostos
1. Faa adaptaes nos cdigos estudados nesse captulo e implemente uma agenda
com a interface grfica(GUI) abaixo:
2. Crie um novo menu na GUI da questo anterior chamado editar. Ao clicar nessa
opo o usurio ser levado para uma tela onde a interface pedir o cdigo do
contato a ser editado depois os dados desse contato sero buscados na tabela
contato e exibido na GUI. A GUI deve permitindo que o usurio edite as
informaes do mesmo e grave essas novas informaes no banco quando clicado
no boto alterar que conter na parte inferior da GUI.
3. Adicione um novo item de menu a GUI e o chame de Excluir. Clicando no item de
menu Excluir o programa deve pedir o cdigo do contato a ser excludo, que aps
digitado precisar chamar o mtodo deletaContato que por sua vez deletar o
registro na tabela contato que contm no campo id o cdigo correspondente ao
digitado pelo usurio.
Ateno! Faa todos os tratamentos para que seu cdigo no lance
excees. Bom trabalho!
146
Capitulo 15.
15.1. Introduo
O JDBC uma das formas mais diretas para integrar um software em Java com um
Banco de Dados(BD). Com essa tecnologia podemos fazer diversos tipos de operaes no
banco, atendendo nossas necessidades em relao a persistncia de dados. Contudo, a
medida que a aplicao cresce e surge dificuldades em permanecermos usando o JDBC.
Algumas desvantagens do JDBC:
Todas as funes CRUD (Create, Retrieve, Update and Delete) precisam ser
codificadas;
A estrutura utilizada pelos BD relacionais para alocar os dados difere da utilizada pelas
aplicaes orientadas a objetos, por isso precisamos restruturar os dados que vem do BD
relacional para serem organizados em objetos e vice-versa. Fazer isso para diversos tipos
de objetos que precisam ser persistido trabalhoso de ser implementado.
Para facilitar esse processo de transformao de dados que
trafegam entre a aplicao e o BD podemos utilizar o conceito de
ORM.
Mapeamento objeto-relacional (ou ORM, do ingls: Objectrelational mapping) uma tcnica de desenvolvimento utilizada
para padronizar e reduzir o trabalho de estruturao e
restruturao de dados que transitam entre a aplicao que regida
pelo paradigma orientado a objetos e o BD que por sua vez utiliza o
paradigma procedural.
Quando usamos a tcnica de ORM as tabelas do
banco de dados so representadas atravs de classes,
os registros de cada tabela so representados com
objetos das classes correspondentes e os atributos
pertencentes a esses objetos representam os campos
do registro.
Com esta tcnica, o programador no precisa se
preocupar com os comandos em linguagem SQL; ele
usar uma interface de programao simples que faz
todo o trabalho de persistncia.
147
Hibernate, RedHat;
OpenJPA, da Apache;
TopLink, da Oracle;
Hibernate Annotations: uma nova forma de fazer mapeamento objetorelacional utilizando annotations, um tipo de tag especial semelhante ao JavaDoc.
Essas tags foram padronizadas segundo o padro JPA, mas o Hibernate tambm
adicionou algumas tags prprias. A vantagem de se usar as annotations a reduo
de linhas de cdigo, ao fazer mapeamento objeto-relacional, em relao
mapeamento utilizando o uso de XML.
15.3.Arquitetura Hibernate
Apesar de tantas ferramentas e classes compondo seu ncleo a arquitetura do Hibernate
pode ser simplificada conforme a imagem abaixo:
148
A figura lista dois tipos de mapeamento, annotations ou XML, apesar de ser possvel
utilizar os dois, no recomendado.
15.4.Baixando o Hibernate
Entre no site oficial: http://www.hibernate.org e clique nas reas onde o cursor do
mouse est sobre.
149
15.5.Instalando o Hibernate
Dentro do arquivo baixado no tpico anterior tem todos os jars necessrios para o bom
funcionamento do Hibernate. Utilizaremos nessa apostila a verso mais nova do
Hibernate, verso 4.3.4 ou Hibernate 4.
2. Vamos criar uma pasta dentro do projeto AgendaHibernate chamada de lib. Nessa
pasta colocaremos todos os JARs necessrios para o funcionamento do Hibernate.
Criando pasta lib. Veja abaixo:
150
151
5. Tambm vamos adicionar a pasta lib do nosso projeto um outro pool de conexo.
Pool de conexo um objeto que disponibiliza uma coleo de conexes com o BD
para ser utilizadas por sua aplicao, no sendo preciso ficar abrindo conexes. O
Hibernante j tem um pool de conexo nativo, mas no recomendado para o
ambiente de produo, pois falta diversos recursos encontrados em qualquer pool
de conexo decente. O pool de conexo que adicionaremos est dentro da pasta
/lib/optional/c3p0 da pasta gerada ao descompactar o Hibernate. Copie todos os
arquivos dessa pasta e cole dentro da pasta lib do projeto AgendaHibernate.
6. Para finalizar a instalao vamos adicionar todos os .JARs da pasta lib de nosso
projeto no Build Path do mesmo.
152
153
15.6.1.
154
15.6.2.
155
Descrio
c3po.min_size
c3po.max_size
c3po.timeout
c3po.max_statements
c3p0.idle_test_period
Descrio
show_sql
format_sql
generate_statistics
use_sql_comments
Alm das propriedades apresentadas podemos ainda comentar mais trs que
poderiam ser adicionadas ao arquivo conforme a necessidade:
Propriedade
hibernate.hbm2ddl.auto
Descrio
Automaticamente valida ou exporta a
estrutura do banco de dados contendo as
instrues DDL desse banco quando
SessionFactory criada, construindo,
dessa forma, a estrutura do banco de
dados automaticamente. Com a opo
createdrop configurada, por exemplo o
banco de dados excludo quando a
SessionFactory fechada. No
156
hibernate.transaction.auto_close_session
hinernate.transaction.factory_class
Claro que existem outas configuraes alem das mencionadas que podem ser
includas no arquivo de configurao. No entanto, caso alguma configurao
complementar seja necessria aos exemplos criados, isso ser explicado ao longo do livro.
Caso deseje consultar outras possibilidades, visite o site
http://docs.jboss.org/hibernate/orm/4.3/manual/en-US/html/ch03.html#configurationoptional, onde possvel ver a documentao da configurao do Hibernate na ntegra.
Precisamos agora escrever o cdigo-fonte que far a ponte entre o arquivo de
configurao e a conexo com o banco. Para isso, vamos criar duas classes: HibernateUtil e
TesteConexaoHibernateMysql no package conexao. Vamos criar primeiro HibernateUtil.
Ateno! Para ajudar na criao do arquivo xml de configurao do
Hibernate podemos instalar um plugin do eclipse chamado JBoss Tools que
encontrado facilmente no Eclipse Marcketplace do IDE Eclipse.
15.6.3.
157
15.6.4.
158
O mtodo esttico
constroiSessionFactory() responsvel
por carregar todas as configuraes do
Hibernate utilizando um objeto do tipo
Configuration. Com o mtodo
configure contido nessa classe as
configuraes armazenadas no arquivo
hibernate.cfg.xml so carregadas e com o
mtodo buildSessionFactory() uma
conexo com o banco de dados
realizado. Caso no seja passado o nome ou a localizao do arquivo de configurao o
Hibernate procurar na raiz do projeto, se no for encontrado, uma exceo ser lanado.
Tambm desenvolvemos um mtodo esttico chamado getSessionFactory(), esse mtodo
repensvel por retornar uma sesso Hibernate que se encontra dentro do atributo
privado chamado sessao.
Ateno! Perrceba que o mtodo buildSessionFactory() est riscado. Isso
significa que para o Hibernate 4 esse mtodo no o mtodo adequado para
construes de SessionFactory, ele foi utilizado nas verses anteriores do
Hibernate. Veja abaixo como ficou a implementao do HibernateUtil na
verso mais recente do Hibernate:
15.6.5.
J temos a classe HibernateUtil que faz todo o processo de configurao e cria o objeto
SessionFactory do Hibernate. Agora utilizando a classe TesteConexaoHibernateMysql
vamos verificar se conseguimos abrir uma conexo com o BD utilizando o Hibernate.
O cdigo fica dessa forma:
159
160
15.7.1.
15.7.2.
162
15.7.3.
Crie uma classe ContatoDao no pacote modelo. A classe ContatoDao ser responsvel
por dar acesse aos dados que se encontram no banco, referentes ao objeto Contato. A
arquitetuara do nosso projeto ficar dessa forma:
Vamos escrever o cdigo responsvel por fazer inseres de objetos do tipo Contato no
BD usando a API do Hibernate. Veja o cdigo abaixo:
163
15.7.4.
Para retornar objetos da base de dados, usaremos a linguagem HQL que similar a
linguagem SQL, mas essa linguagem referenciar nomes usados no mapeamento das
tabelas em vez de nomes de tabelas e colunas usados na base de dados. Ela uma poderosa
linguagem de consulta que se parece muito com a SQL, mas a HQL totalmente orientada
a objeto, incluindo os paradigmas de herana, polimorfismo e encapsulamento. No
Hibernate, podemos escolher tanto em usar a SQL quanto a HQL. Escolhendo a HQL,
poderemos executar as solicitaes SQL sobre as classes de persistncia do Java em vez de
tabelas no banco de dados.
Vamos escrever o mtodo que listar todos os registros da tabela contato utilizando uma
consulta HQL. O cdigo desse mtodo ficar desta forma:
Perceba que nesse mtodo utilizamos um mtodo novo do objeto sessao: mtodo
createQuery(). Esse mtodo realiza uma consulta HQL nas classes mapeadas, ou seja, em
vez de voc utilizar o nome da tabela(contato) que deseja realizar a consulta, utilizasse a
classe(Contato) que representa essa tabela. Veremos logo mais, no mtodo buscar() outro
exemplo do uso do HQL. A consulta armazenada em um objeto do tipo Query que possui
um mtodo chamado list() que transforma a consulta retornada em um objeto do tipo
List.
15.7.5.
165
Perceba que o mtodo createQuery() dessa vez faz uma consulta usando a clusula
where. Implementamos uma consulta HQL que procura na classe mapeada Contato, que
representa a tabela contato, um objeto contato com o atributo id = parametro. O valor
do parametro definido no mtodo serInteger().
Utilizamos outro mtodo do objeto sessao, uniqueResult(). Esse mtodo retorna
utilizado para retorna um nico objeto em uma consulta. Caso no encontre o objeto que
atenda os requisitos da consulta o mtodo retorna null, caso encontre mais de um objeto
que atenda a consulta lana uma exceo do tipo HibernateException.
15.7.6.
No mtodo remover() temos o mtodo get pertencente ao objeto sessao. O mtodo get
recebe como parmetro uma classe e um id. Como desejamos buscar um contato, a classe
que representa a tabela contato a Classe Contato, ento utilizando reflexo recuperamos
uma referncia dessa classe atravs do atributo esttico class. E o outro parmetro o id
do objeto contato que desejamos excluir.
Outro mtodo do objeto sessao o delete(). Esse mtodo recebe o objeto que deve ser
166
15.7.7.
15.7.8.
saveOrUpdate()
merge()
persist()
get()
getEntityName()
Descrio
Salva um objeto na base de dados. Este mtodo no deveria
ser chamado por um objeto que foi salvo na base de dados.
Salva um objeto na base de dados ou atualiza a base de
dados se o objeto j existe. Este mtodo menos eficiente
que o mtodo save(), pois ele necessidade fazer um SELECT
para checar se o objeto j existe, mas no falhar se o objeto
j foi salvo.
Mescla os campos de um objeto no persistente dentro de
um objeto persistente apropriado (determinado pelo ID). Se
tal objeto no existe na base de dados, ento um criado e
salvo.
Reassocia um objeto com a sesso, dessa forma as alteraes
feitas no objeto sero persistidas.
Recupera um objeto especfico da base de dados pelo objeto
identificador.
Retorna o nome da entidade.
167
getIdentifier()
load()
refresh()
update()
delete()
createFilter()
enableFilter()
disableFilter()
getEnabledFilter()
createQuery()
getNamedQuery()
cancelQuery()
createCriteria()
beginTransaction()
getTransaction()
lock()
contains()
clear()
evict()
flush()
isOpen()
isDirty()
getCacheMode()
setCacheMode()
getCurrentLockMode()
setFlushMode()
setReadOnly()
close()
getSessionFactory()
connection()
disconnect()
reconnect()
isConnected()
Como j vimos, geralmente usaremos as Sesses para criar, atualizar, pesquisar e deletar
objetos.
15.8.
Mapeamento de objetos utilizando Annotations e
Hibernate
Vamos fazer o mapeamento da
classe Contato utilizando
Annotation, no mais com o
arquivo xml Contato.hbm.xml.
Annotation(representado pela
inicial @), um recurso da
Plataforma Java, introduzido
como padro de linguagem na
verso 1.5, esse recurso nos
permite utilizar tags dentro do
cdigo fonte da classe que ser
mapeada, as quais mapeiam a
respectiva classe e dispensa o
arquivo xml.
Vamos criar uma classe
ContatoAnnotation. Essa classe
ser semelhante a classe Contato.
A nica diferena ser as
annotations que sero digitadas
para mapear a classe e dispensar
o uso do arquivo xml. O cdigo
da classe ContatoAnnotation vai
ficar como na imagem ao lado.
Veja na tabela abaixo os
atributos que cada annotation
aceita:
169
Tag
@Entity
@Table
@Id
@GeneratedValue
@Column
170
try{
sessao.close();
}catch(Exception e){
System.out.println("Problema ao fechar a sessao: "+e);
}
}
public void inserir(ContatoAnnotation c){
try{
this.sessao = HibernateUtil.getSessionFactory().openSession();
this.transacao = sessao.beginTransaction();
sessao.save(c);
this.transacao.commit();
}catch(HibernateException e){
System.out.println("Problema ao inserir o contato: "+e);
this.transacao.rollback();
}finally{
this.fecharSessao();
}
}
public List<ContatoAnnotation> listar(){
List<ContatoAnnotation> listaContato = null;
Query consulta;
try{
this.sessao = HibernateUtil.getSessionFactory().openSession();
this.transacao = sessao.beginTransaction();
consulta = sessao.createQuery("from ContatoAnnotation");
listaContato = consulta.list();
transacao.commit();
return listaContato;
}catch(HibernateException e){
System.out.println("Problema ao cosultar: "+e);
this.transacao.rollback();
}finally{
this.fecharSessao();
}
return listaContato;
}
public ContatoAnnotation buscar(Integer id){
Query resultado;
ContatoAnnotation c = null;
try{
this.sessao = HibernateUtil.getSessionFactory().openSession();
this.transacao = sessao.beginTransaction();
resultado = sessao.createQuery("from ContatoAnnotation where id
= :parametro");
resultado.setInteger("parametro", id);
c = (ContatoAnnotation)resultado.uniqueResult();
this.transacao.commit();
return c;
172
}catch(HibernateException e){
System.out.println("Problema na consulta: "+e);
this.transacao.rollback();
}finally{
this.fecharSessao();
}
return c;
}
public void remover(Integer id){
try{
this.sessao = HibernateUtil.getSessionFactory().openSession();
this.transacao = sessao.beginTransaction();
/** busca objeto do tipo Contato com o id informado. Utilize o
mtodo get ou load.*/
ContatoAnnotation c =
(ContatoAnnotation)sessao.get(ContatoAnnotation.class, id);
if(c != null){
this.sessao.delete(c);
}
this.transacao.commit();
}catch(HibernateException e){
System.out.println("Problema ao remover: "+e);
this.transacao.rollback();
}finally{
this.fecharSessao();
}
}
173
Tag(Annotation)
@OneToOne
@OneToMany
@ManyToOne
@ManyToMany
Tabela relacionamentos
15.9.1.
174
175
15.9.2.
HashCode, equals e interface Serializable e sua relao como
Hibernate.
As melhores prticas do Hibernate recomendam ao mximo que os mtodos equals
e hashCode sejam sobrescrito nas classes persistveis de seu projeto.
Isso necessrio porque a implementao dos mtodos equals e hashCode
existentes na classe Object s considera endereo de memria do objeto. Isso significa que
se duas instncias de uma mesma classe, com os mesmos dados internamente, forem
comparadas com == ou obj1.equals(obj2), o resultado ser false, pois elas esto em
endereos de memria diferentes.
A comparao usando == sempre considera apenas o endereo de memria do
objeto, mas, para o Hibernate o interessante que o contedo seja comparado, o que pode
ser alcanado reimplementado os mtodos equals e hashCode.
176
Para uma simples regra do Java, sempre que voc reimplementar o mtodo equals
dever fazer isso com o hashCode tambm.
Uma implementao manual desses mtodos nos obrigaria a comparar
individualmente cada propriedade dos objetos, alm de comparar o tipo do objetoem
questo, o que seria uma tarefa bastante penosa.
Porm, para facilitar a vida dos desenvolvedores, a Eclipse IDE tem um recurso para
gerar automaticamente os mtodos hashCode e equalscom base nas propriedades da
classe. Para gerar automaticamente, clique com o boto direito do mouse no corpo da
classe, escolha Source Generate hashCode and equals, selecione todas as propriedades
da classe e clique em OK.
Existem vrios textos j publicados sobre a linguagem Java que explicam, tanto do ponto
de vista da arquitetura como de implementao, o motivo pelo qual devemos ter os
mtodos hashCode e equals implementados em nossas classes. O foco aqui no explicar a
teoria por trs desses conceitos, mas dizer que uma boa prtica ter esses mtodos
reimplementados nas classes de seu projeto, independentemente de estarmos trabalhando
com o Hibernate. Contudo, para aqueles que desejarem se aprofundar sobre o assunto fica
a sugesto de leitura dos artigos em ingls constantes nestes links:
htpp://community.jboss.org/wiki/EqualsandHashCode
htpp://www.ibm.com/developerworks/java/library/j-jtp05273.html
O uso da interface serializable est vinculado necessidade eventual de transformar
um objeto em uma sequncia (stream) de bytes, que poder ser gravada ou transmitida de
alguma maneira. A serializao deve garantir que essa sequncia de dados possa ser
convertida novamente no objeto original, ou seja, desserializada. Usa-se serializao
quando desejamos gravar objetos em arquivos e transmiti-los por alguma via como, por
exemplo, sockets ou rmi.
Alm disso, quando um objeto serializado no Java, essa sequncia de bytes carrega
consigo um nmero que identifica a verso da classe usada durante o processo. Esse
nmero um requisito quando uma classe for implementar a interface Serializable. O
nmero ser sempre armazenado na propriedade serialVersionUID, ou seja, o
identificador de verso de serializao de uma classe. Com base nesse nmero, possvel
saber se o objeto que estamos recuperando de uma verso compatvel com a verso da
classe que foi utilizada quando serializamos o objeto.
Explicado o motivo pelo qual devemos implementar esses mtodos em nossas
classes, mais adiante no projeto veremos como colocar isso nas classes com a ajuda da IDE
Eclipse de uma maneira prtica.
15.9.3.
177
foma:
Veja como ficou a implementao da Class Endereco:
179
15.9.4.
Class EnderecoDao
180
181
15.9.5.
Criamos uma classe Telefone para representar a tabela telefone. O mapeamento dessa
classe ficou desta forma:
183
15.9.6.
184
@ JoinTable: essa notao vai representar a tabela gerada entre a tabela contato e grupo
quando fazemos o relacionamento entre as mesmas.
name: nome da tabela intermediria
joinColumns= faz a ligao entre o campo contato_id, que representa um contato na
tabela contato_grupo, e o campo id da tabela contato;
inverseJoinColumns: faz o mesmo que o joinColumns, mas agora com o atributo
grupo_id que representa um grupo na tabela contato_grupo.
Na tabela Grupo vamos ter uma notao semelhante a vista acima com a diferena que
agora o mapeamento vai ser feito pela viso da tabela Grupo, ficando dessa forma:
186
15.9.7.
Criamos uma classe Grupo para representar a tabela grupo. O mapeamento dessa classe
ficou desta forma:
15.10.
O Hibernate prov trs tipos diferentes para retornar informaes, uma a HQL, outra
forma atravs de consultas nativas e a terceira forma atravs da API Criteria.
A API Criteria nos permite construir consultas estruturadas utilizando Java, e ainda
prov uma checagem de sintaxe em tempo de compilao que no possvel com uma
linguagem de consulta como HQL ou SQL. A API Criteria tambm fornece projeo,
agregao e outras funcionalidades.
No restante do artigo verificaremos melhor o que essa API e o que ela oferece aos
desenvolvedores Hibernate.
15.10.1.
API Criteria
A API Criteria possui a interface org.hibernate.Criteria que est disponvel com todos os
mtodos fornecidas pela API. Atravs dessa API podemos construir consultas de forma
programtica. A interface Session do Hibernate contm vrios mtodos createCriteria()
que recebem como parmetro uma classe de um objeto persistente ou o nome da entidade
187
e, dessa forma, o Hibernate criar um objeto Criteria que retorna instncias das classes de
objetos persistentes quando a aplicao executa uma consulta com a API. Na Listagem 1
temos um exemplo introdutrio.
Listagem 1. Exemplo utilizando createCriteria.
Criteria crit = session.createCriteria(Produto.class);
List results = crit.list();
Nessa pesquisa temos como retorno todos os objetos que so instncia da classe
Produto. Classes derivadas de produto tambm so retornadas.
15.10.2.
A API Criteria tambm permite que possamos criar restries onde restringimos os
objetos retornados. Um exemplo disso seria retornar apenas produtos que tenham um
preo abaixo de 30 reais. Para usar restries da API utilizamos o mtodo add() que espera
receber um objeto org.hibernate.criterion.Criterion que representa um restrio
individual. Tambm podemos ter mais que uma restrio para uma consulta.
Embora possam criar nossos prprios objetos implementando o objeto Criterion ou
estendendo um objeto Criterion j existente, recomenda-se que os desenvolvedores usem
objetos Criterion embutidos da lgica de negcio da aplicao. Tambm podemos criar
nossa prpria classe factory que retorna instncias do objeto Criterion do Hibernate
apropriadamente configurados para as restries da nossa aplicao.
Usamos mtodos de fbrica (factory) na classe org.hibernate.criterion.Restrictions para
obter instncias dos objetos Criterion. Para retornar objeto que possuem um valor de
propriedade que igual nossa restrio, usamos o mtodo eq() em Restrictions. A
assinatura do mtodo :
public static SimpleExpression eq(String propertyName, Object value)
Podemos passar o mtodo eq() para o mtodo add() no objeto Criteria. Segue na
Listagem 2 um exemplo de como procuraramos um teclado nos produtos:
Listagem 2. Criando uma restrio com eq().
Criteria crit = session.createCriteria(Produto.class);
crit.add(Restrictions.eq("nome","Teclado"));
List results = crit.list();
Objetos nulos podem ser encontrados utilizando isNull(), ou ento podemos utiliza
isNotNull() para pesquisar objetos no nulos, como na Listagem 4.
Listagem 4. Criando uma restrio com isNull().
Criteria crit = session.createCriteria(Produto.class);
crit.add(Restrictions.isNull("nome"));
List results = crit.list();
188
Outra pesquisa muito utilizada quando queremos retornar objetos que possuem
algumas propriedades em comum, como a clusula LIKE do SQL. Para isso utilizamos o
mtodo ilike() ou like(). A diferena que o mtodo ilike() case-insensitive, ou seja,
maisculas ou minsculas so desprezadas. Segue na Listagem 5 um exemplo da
utilizao de like.
Listagem 5. Criando uma restrio com like().
Criteria crit = session.createCriteria(Produto.class);
crit.add(Restrictions.like("nome","Tec%"));
List results = crit.list();
O smbolo "%" utilizado para combinar partes de uma String. Dessa forma, tudo que
comear com Tec e tiver quaisquer outros caracteres sero retornados.
Os mtodos ilike e like possuem duas assinaturas:
public static SimpleExpression like(String propertyName, Object value);
ou
public static SimpleExpression like(String propertyName, String value,
MatchMode matchMode);
Segue na Listagem 6 um exemplo que usa o mtodo ilike() para pesquisar combinaes
de case-insensitive no final da String.
Listagem 6. Criando uma restrio com ilike().
Criteria crit = session.createCriteria(Produto.class);
crit.add(Restrictions.ilike("nome","browser", MatchMode.END));
List results = crit.list();
A API Criteria tambm oferece mtodos para comparaes como gt() (greater-than) que
verifica se maior que, ge() (greater-than-or-equal-to) que verifica se maior que e igual,
lt() (less-than) que verifica se menor, e por fim le() (less-than-or-equal-to) que verifica se
menor e igual. No exemplo da Listagem 7 pesquisamos por produtos que tenham um
valor menor que 30 reais.
Listagem 7. Pesquisando valores menores que 30.
Criteria crit = session.createCriteria(Produto.class);
crit.add(Restrictions.gt("preco",new Double(30.0)));
List results = crit.list();
189
Nesse caso estamos pesquisando produto com preo maior que 30 reais que tenham um
nome comeando com Tec.
Para fazer um OR nessas duas restries teramos que utilizar o mtodo or() como na
Listagem 9.
Listagem 9. Criando mais de uma restrio com OR.
Criteria crit = session.createCriteria(Produto.class);
Criterion preco = Restrictions.gt("preco",new Double(30.0));
Criterion nome = Restrictions.like("nome","Tec%");
LogicalExpression orExp = Restrictions.or(preco,nome);
crit.add(orExp);
List results = crit.list();
Quando temos trs OR ou mais podemos representar isso de uma forma melhor
utilizado o objeto org.hibernate.criterion.Disjunction. Para representar uma expresso
AND com mais que dois Criteria podemos usar o mtodo conjunction(). Segue na
Listagem 10 um exemplo utilizando disjunction.
Listagem 10. Utilizando disjunction() com Criteria.
Criteria crit = session.createCriteria(Produto.class);
Criterion preco = Restrictions.gt("preco",new Double(25.0));
Criterion nome = Restrictions.like("nome","Tec%");
Criterion desc = Restrictions.ilike("descricao","teclas%");
Disjunction disjunction = Restrictions.disjunction();
disjunction.add(preco);
disjunction.add(nome);
disjunction.add(desc);
crit.add(disjunction);
List results = crit.list();
O {alias} utilizado quando no sabemos o nome da tabela que a nossa classe utiliza.
Dessa forma, {alias} significa o nome da tabela da classe.
O mtodo sqlRestriction() possui ainda mais dois mtodos que permitem passar
paramtros e valores JDBC para o comando SQL.
15.10.3.
Paginando Resultados
Criteria tambm faz paginao sobre os resultados de uma consulta. Existem dois
mtodos na interface da API Criteria para realizar a paginao, so eles: setFirstResult() e
setMaxResults(). O mtodo setFirstResult() requer um inteiro que representa a primeira
linha no conjunto de dados retornado, iniciando com a linha 0. O mtodo setMaxResults()
retorna um nmero fixo de objetos. Segue na Listagem 12 um exemplo da utilizao dos
mtodos.
190
15.10.4.
Algumas vezes desejamos retornar zero ou um nico objeto para algumas consultas. Isso
acontece quando usamos agregaes como COUNT ou porque as restries na consulta
levam a um resultado nico. Podemos limitar os resultados de qualquer consulta setando
apenas setMaxResults() para que ele retorne um nico objeto. Porm, existe outra forma
de fazer isso que tem como resultado um Object ao invs de um List, o mtodo
uniqueResult(). O mtodo uniqueResult() retorna um nico resultado ou null. Caso
tenhamos mais de um resultado lanada uma exceo NonUniqueResultException. Na
Listagem 13 temos um exemplo da sua utilizao.
Listagem 13. Retornando resultados nico com uniqueResult().
Criteria crit = session.createCriteria(Produto.class);
Criterion preco = Restrictions.gt("preco",new Double(25.0));
crit.setMaxResults(1);
Produto produto = (Produto) crit.uniqueResult();
15.10.5.
Ordenando Resultados
15.10.6.
Associaes
Para adicionar uma restrio na que classe que esta associada com Criteria, precisamos
criar outro objeto Criteria, e passar o nome da propriedade da classe associada para o
mtodo createCriteria(). Dessa forma, teremos outro objeto Criteria. Segue na Listagem
15 temos um exemplo da utilizao da associao onde se criou um novo objeto Criteria
para a propriedade produtos e adicionou-se uma restrio para um atributo da
propriedade.
Listagem 15. Utilizando associaes com Criteria.
Criteria crit = session.createCriteria(Suplementos.class);
Criteria prdCrit = crit.createCriteria("produtos");
prdCrit.add(Restrictions.gt("preco",new Double(25.0)));
List results = crit.list();
191
15.10.7.
Projeo e Agregao
Podemos notar que a projeo contm uma funo agregada. Outras funes agregadas
so listadas abaixo:
Tambm podemos ter uma lista de projees, como mostra o exemplo da Listagem 17.
Listagem 17. Criando uma lista de projees.
Criteria crit = session.createCriteria(Produto.class);
ProjectionList projList = Projections.projectionList();
projList.add(Projections.max("preco"));
projList.add(Projections.min("preco"));
projList.add(Projections.avg("preco"));
projList.add(Projections.countDistinct("descricao"));
crit.setProjection(projList);
List results = crit.list();
Retornar propriedades tambm melhor para a performance da aplicao, pois com isso
temos uma reduo substancial no trfego de dados na rede.
Por fim, tambm temos a possibilidade de agrupar resultados, semelhante a clausula
GROUP BY no SQL. A projeo groupProperty faz isso de forma simples. Na Listagem 19
temos um exemplo demonstrado o seu uso.
Listagem 19. Utilizando groupProperty() com Criteria
192
193
Bibliografia
http://www.guj.com.br/
http://pt.wikipedia.org/wiki
http://jedi.wv.com.br/
http://docs.oracle.com/javase/7/docs/api/
http://jacques.dsc.ufcg.edu.br/cursos/p2/html/ed/colecoes.htm
http://www.xti.com.br/carreira/universidade-xti.htm
http://pt.scribd.com/doc/86301078/Apostila-Java
http://www.hibernate.org/hib_docs/v3/reference/en/html/queryhql.html
http://www.devmedia.com.br/hibernate-api-criteria-realizandoconsultas/29627#ixzz2xYra6bpa
194