Apostila Programação Java

ESCOLA TÉCNICA ESTADUAL
MONTEIRO LOBATO
Programação Java
Curso Técnico em Informática

______________________________________________________________________________________________
Curso Técnico em Informática 2 Programação Java
1 Introdução ...................................................................................................................................8
1.1 Padronização .................................................................................................................9
1.2 Características...............................................................................................................9
1.3 Licença.........................................................................................................................10
1.4 Máquina Virtual............................................................................................................10
1.5 Garbage Collection...................................................................................................... 11
1.6 Estrutura de um código em Java ............................................................................... 11
1.7 Instalação e configuração do java .............................................................................13
1.7.1 Requisitos do Sistema Java 8..........................................................................13
1.7.2 Download e Instalação.....................................................................................13
1.8 Ferramentas.................................................................................................................24
1.8.1 Eclipse .............................................................................................................24
1.8.2 NetBeans .........................................................................................................25
1.8.3 Jcreator............................................................................................................25
1.8.4 BlueJ................................................................................................................26
1.9 IDE Netbeans ...............................................................................................................26
2 Linguagem Java............................................................................................................28
2.1 Sintaxe Java ....................................................................................................................29
2.1.1 Delimitadores em Java...............................................................................................29
2.1.2 Identificadores e palavras reservadas........................................................................30
2.1.3 Declaração de Variáveis.............................................................................................31
2.1.4 Tipos primitivos...........................................................................................................32
2.1.4.1 Tipos lógicos: boolean ..................................................................................32
2.1.4.2 Tipos textuais: char e String..........................................................................32
2.1.4.3 Tipos numéricos inteiros: byte, short, int e long ............................................33
2.1.4.4 Tipos numéricos de ponto flutuante: float e double.......................................33
2.2 Convenções de codificação .......................................................................................33
3 Expressões....................................................................................................................34
3.1 Operadores ..................................................................................................................34
3.1.1 Operadores Delimitadores............................................................................ 34
Sumário

______________________________________________________________________________________________
3.1.2 Operadores Aritméticos ...................................................................................34
3.1.3 Operadores de Atribuição ................................................................................35
3.1.4 Operadores Unários.........................................................................................35
3.1.5 Operadores de Incremento e Decremento.......................................................35
3.1.6 Operadores Relacionais ..................................................................................35
3.1.7 Operadores Lógicos.........................................................................................35
3.1.8 Operador de concatenação .............................................................................36
3.1.9 Operadores de deslocamento..........................................................................36
3.2 Casting .........................................................................................................................37
3.3 Recebendo dados do usuário ....................................................................................38
4 Controle de Fluxo......................................................................................................................39
4.1 Execução Condicional....................................................................................................40
4.1.1 Comando if ......................................................................................................40
4.1.2 Comando if-else...............................................................................................41
4.1.3 Condicional ternário.........................................................................................42
4.1.4 Comando If-else Aninhados.............................................................................42
4.1.5 Comando switch .............................................................................................44
4.2 Laços de Repetição ........................................................................................................48
4.2.1 Comando While ...............................................................................................48
4.2.2 Comando do-while...........................................................................................49
4.2.3 Comando for ....................................................................................................50
4.2.4 Comandos de desvio .......................................................................................51
4.3 Recursividade..............................................................................................................54
5 Estrutura de dados.................................................................................................................56
5.1 Vetores .........................................................................................................................56
5.1.1 Inicialização de vetores....................................................................................61
5.1.2 Estrutura for aprimorada ..................................................................................62
5.2 Matrizes........................................................................................................................64
6 Programação Orientada a Objetos....................................................................................... 68
6.1 Introdução....................................................................................................................68
6.2 Ideias básicas da POO................................................................................................69
6.3 Classes.........................................................................................................................69
6.4 Objetos.........................................................................................................................70
6.5 Mensagens...................................................................................................................71
6.6 Métodos........................................................................................................................71

______________________________________________________________________________________________
6.7 Abstração.....................................................................................................................73
6.8 Encapsulamento..........................................................................................................73
6.9 Herança ........................................................................................................................76
6.10 Classes abstratas......................................................................................................79
6.11 Polimorfismo..............................................................................................................82
7 Documentação – JavaDoc.....................................................................................................86
8 Interface Gráfica.....................................................................................................................91
8.1 Componentes Swing .....................................................................................................91
8.1.1 Hierarquia das Classes dos Componentes......................................................92
8.1.2 Portabilidade....................................................................................................93
8.1.3 Look And Feel..................................................................................................93
8.1.4 Bases de Estruturação das Interfaces Gráficas...............................................93
8.1.4.1 Conteiners..........................................................................................94
8.1.4.2 Swing - Mensagens............................................................................94
8.1.4.3 Componentes: JFrame, JPanel e JButton..........................................95
8.1.4.4 JFrame ...............................................................................................95
8.1.4.5 JDesktopPane e JInternalFrame ........................................................97
8.1.4.6 JDialog ...............................................................................................97
8.1.4.7 Componentes Atômicos......................................................................98
8.1.4.7.1 JLabel ...................................................................................98
8.1.4.7.2 Botões...................................................................................98
8.1.4.7.3 JButton..................................................................................99
8.1.4.7.4 JCheckBox............................................................................99
8.1.4.7.5 JRadioButton ......................................................................100
8.1.4.7.6 JTextField............................................................................100
8.1.4.7.7 JPasswordField...................................................................101
8.1.4.7.8 JTextArea............................................................................101
8.1.4.7.9 JScrollPane.........................................................................102
8.1.4.7.10 JSlider...............................................................................102
8.1.4.7.11 JComboBox.......................................................................103
8.1.4.7.12 JList ..................................................................................103
8.1.4.7.13 JPopupMenus...................................................................104
8.1.4.7.14 Menus...............................................................................104
8.2 Eventos ......................................................................................................................105
8.2.1 Tratamento de Eventos..................................................................................105

______________________________________________________________________________________________
8.2.1.1 A Origem do Evento .........................................................................105
8.2.1.2 O Objeto Evento...............................................................................105
8.2.1.3 Ouvinte do Evento............................................................................106
8.2.2 Tratadores de Eventos ou Ouvintes (Listeners).............................................106
8.2.2.1 ActionListener...................................................................................106
8.2.2.2 FocusListener...................................................................................106
8.2.2.3 ItemListener......................................................................................107
8.2.2.4 KeyListener ......................................................................................107
8.2.2.5 MouseListener..................................................................................107
8.2.2.6 MouseMotionListener .......................................................................108
8.2.2.7 WindowListener................................................................................108
8.3 Classes Adaptadoras ................................................................................................108
8.4 JavaFX........................................................................................................................109
8.4.1 Introdução......................................................................................................109
8.4.2 Aplicação de internet rica (RICH INTERNET APPLICATION – RIA)..............109
8.4.3 Sobre JAVAFX ............................................................................................... 110
8.4.4 Características............................................................................................... 111
8.4.5 À linguagem JavaFX script ............................................................................ 113
8.4.5.1 Tipos de variáveis............................................................................. 115
8.4.5.2 Características especiais.................................................................. 115
8.4.5.3 Ambiente web................................................................................... 117
8.4.5.4 A aplicação JXplayer ........................................................................ 118
8.4.5.4.1 Características da aplicação JXPlayer................................ 118
8.4.5.4.2 Ferramentas de apoio ao desenvolvimento ........................ 118
8.4.6 Interface e efeitos gráficos............................................................................. 119
8.4.7 Suporte a áudio e vídeo................................................................................. 119
9 Expressões Regulares – Java..........................................................................................120
10 Tratando exceções em Java...........................................................................................124
10.1 Entendendo as exceções........................................................................................124
11 Conexão com banco de dados ............................................................................................131
12 Java Persistence API - JPA ..................................................................................................134
12.1 Entity ........................................................................................................................135
12.1.1 Anotações para Entity..................................................................................136
12.1.1.1 javax.persistence.Entity..................................................................136
12.1.1.2 javax.persistence.Table ..................................................................136

______________________________________________________________________________________________
12.1.1.3 javax.persistence.Id........................................................................137
12.1.1.4 javax.persistence.Column ..............................................................137
12.1.1.5 javax.persistence.SequenceGenerator ..........................................138
12.1.1.6 javax.persistence.GeneratedValue.................................................138
12.1.1.7 javax.persistence.Temporal............................................................139
12.1.1.8 javax.persistence.Transient............................................................139
12.2 EntityManager..........................................................................................................141
12.3 Unidade de Persistência .........................................................................................141
12.4 Criando uma unidade de persistência no NetBeans ............................................142
12.5 EntityManager gerenciado pela Aplicação............................................................147
12.6 EntityManager gerenciado pelo Container............................................................148
12.7 Interface EntityManager..........................................................................................149
12.7.1 Ciclo de vida da Entity .................................................................................150
12.8 DAO (CRUD) utilizando JPA ...................................................................................150
12.9 Estratégia de SEQUENCE para gerar ID................................................................156
12.10 Utilizando chave composta ..................................................................................158
12.11 Relacionamento entre entidades..........................................................................168
12.12 Os quatro tipos de cardinalidade.........................................................................168
12.13 Cascade Type.........................................................................................................189
12.14 FetchType...............................................................................................................189
12.15 Consultas com JPAQL ..........................................................................................199
12.15.1 Interface Query .............................................................................................203
13 Relatórios ..............................................................................................................................207
13.1 Acesso ao banco de Dados....................................................................................213
13.2 iReport Wizard .......................................................................................................2130
13.3 Modelo Relatório iReport........................................................................................213
13.3.1 Estrutura de um relatório .............................................................................213
13.3.2 Variáveis, Parâmetros e campos ...............................................................2134
13.3.3 Arquivos gerados pelo iReport.....................................................................216
14 Threads em Java...................................................................................................................223
14.1 Thread em Java .......................................................................................................224
14.2 Criando Threads em Java.......................................................................................225
14.2.1 Implementando o Comportamento de uma Thread .....................................226
14.2.2 Criando uma subclasse de Thread ..............................................................226
14.2.3 Implementando a Interface Runnable ..........................................................226
14.2.4 Escolhendo entre os dois métodos de criação de threads...........................227

______________________________________________________________________________________________
14.2.5 O ciclo de vida de uma Thread ....................................................................230
14.2.6 Criando Threads ..........................................................................................230
14.2.7 Iniciando Threads ........................................................................................230
14.2.8 Fazendo Thread Esperar .............................................................................231
14.2.9 Finalizando Threads ....................................................................................231
14.2.9.1 Verificando se Threads estão Executando/Pronta/Esperando ou
Novas/Mortas...............................................................................................................................231
14.10 Threads Daemon .................................................................................................2341
14.11 Escalonamento de Threads ................................................................................2342
14.12 Sincronizando Threads (Concorrência) ...........................................................2343
14.13 Implementando Exclusão Mútua de Regiões Críticas......................................2343
14.14 Comunicação Entre Threads................................................................................234
14.15 Evitando Starvation e Deadlock...........................................................................234

______________________________________________________________________________________________
Java é uma linguagem de programação orientada a objetos desenvolvida no início
da década de 90, pela Sun Microsystems1. Diferentemente das linguagens convencionais, que
são compiladas para código nativo, a linguagem Java é compilada para um bytecode2 que é
executado por uma máquina virtual.
Em 1991, a Sun Microsystems, deu início ao Green Project, a origem do Java,
uma linguagem de programação orientada a objetos. Os idealizadores do projeto eram Patrick
Naughton, Mike Sheridan, e James Gosling. Eles acreditavam que, em breve, haveria uma
convergência dos computadores com os equipamentos e eletrodomésticos utilizados no dia-a-dia.
Para provar a viabilidade desta ideia, 13 pessoas trabalharam durante 18 meses. No verão
de 1992 foi apresentado uma demonstração funcional da ideia inicial. O protótipo se
chamava *7 (lê-se “Star Seven”), um controle remoto com uma interface gráfica touchscreen. Para
o *7, foi criado um mascote, hoje amplamente conhecido no mundo Java, o Duke. O trabalho do
Duke no *7 era ser um guia virtual ajudando e ensinando o usuário a utilizar o equipamento. O *7
tinha a habilidade de controlar diversos dispositivos e aplicações. James Gosling especificou uma
nova linguagem de programação para o *7. Gosling decidiu batizá-la de “Oak”, que quer
dizer carvalho, uma árvore que ele podia observar quando olhava através da sua janela.
O próximo passo era encontrar um mercado para o *7. A equipe achava que uma boa ideia
seria controlar televisões e vídeo por demanda com o equipamento. Eles construíram uma
demonstração chamada de MovieWood, mas infelizmente era muito cedo para que o vídeo por
demanda bem como as empresas de TV a cabo pudessem viabilizar o negócio. A ideia que o *7
tentava vender, hoje já é realidade em programas interativos e também na televisão digital. Permitir
ao telespectador interagir com a emissora e com a programação em uma grande rede de cabos,
era algo muito visionário e estava muito longe do que as empresas de TV a cabo tinham capacidade
de entender e comprar. A ideia certa, na época errada.
Entretanto, o estouro da internet aconteceu e rapidamente uma grande rede interativa
estava se estabelecendo. Era este tipo de rede interativa que a equipe do *7 estava tentando vender
para as empresas de TV a cabo. E, da noite para o dia, não era mais necessário construir a
infraestrutura para a rede, ela simplesmente estava lá. Gosling foi incumbido de adaptar o Oak para
a internet e em janeiro 1995 foi lançada uma nova versão do Oak que foi rebatizada para Java. A
tecnologia Java tinha sido projetada para se mover por meio das redes de dispositivos
heterogêneos, redes como a internet. Agora aplicações poderiam ser executadas dentro
dos navegadores nos Applets Java e tudo seria disponibilizado pela internet instantaneamente. Foi
o estático HTML dos navegadores que promoveu a rápida disseminação da dinâmica tecnologia
Java. A velocidade dos acontecimentos seguintes foi assustadora, o número de usuários cresceu
rapidamente, grandes fornecedores de tecnologia, como a IBM anunciaram suporte para a
tecnologia Java.
Desde seu lançamento, em maio de 1995, a plataforma Java foi adotada mais rapidamente
do que qualquer outra linguagem de programação na história da computação. Em 2004 Java
1
Sun Microsistens : É uma subsidiária da Oracle Corporation fabricante de computadores, semicondutores e
software com sede em Santa Clara, Califórnia, no Silicon Valley.
2
Bytecode : É a forma intermediária de código, resultante da compilação de um código escrita na linguagem Java.
Introdução 1

______________________________________________________________________________________________
atingiu a marca de 3 milhões de desenvolvedores em todo mundo. Java continuou crescendo e
hoje é uma referência no mercado de desenvolvimento de software. Java tornou-se popular pelo
seu uso na internet e hoje possui seu ambiente de execução presente
em navegadores, mainframes, sistemas operacionais, celulares, palmtops, cartões inteligentes etc.
1.1 Padronização
Em 1997 a Sun Microsystems tentou submeter a linguagem a padronização pelos
órgãos ISO/IEC e ECMA, mas acabou desistindo.3 4 5 Java ainda é um padrão de fato, que é
controlada através da JCP Java Community Process.6. Em 13 de novembro de 2006, a Sun lançou
a maior parte do Java como Software Livre sob os termos da GNU General Public License (GPL).
Em 8 de maio de 2007 a Sun finalizou o processo, tornando praticamente todo o código Java como
software de código aberto, menos uma pequena porção da qual a Sun não possui copyright.7
1.2 Características
A tecnologia Java é composta basicamente de uma linguagem de programação, um
ambiente de desenvolvimento, um ambiente de distribuição e uma Java Virtual Machine (Máquina
virtual Java), responsável pela execução das aplicações (SANTOS, pág. 13, 2010).
A linguagem Java foi projetada tendo em vista os seguintes objetivos:
 Orientação a objetos - Baseado no modelo de simular;
 Portabilidade - Independência de plataforma - "escreva uma vez, execute em qualquer lugar"
("write once, run anywhere");
 Recursos de Rede - Possui extensa biblioteca de rotinas que facilitam a cooperação com
protocolos TCP/IP, como HTTP e FTP;
 Segurança - Pode executar programas via rede com restrições de execução;
Além disso, podem-se destacar outras vantagens apresentadas pela linguagem:
 Sintaxe similar a C/C++;
 Facilidades de Internacionalização - Suporta nativamente caracteres Unicode;
 Simplicidade na especificação, tanto da linguagem como do "ambiente" de execução (JVM);
 É distribuída com um vasto conjunto de bibliotecas (ou APIs);
 Possui facilidades para criação de programas distribuídos e multitarefa (múltiplas linhas de
execução num mesmo programa);
 Deslocação de memória automática por processo de coletor de lixo;
 Carga Dinâmica de Código - Programas em Java são formados por uma coleção de classes
armazenadas independentemente e que podem ser carregadas no momento de utilização;
De acordo com Santos (pág. 14, 2010), um programa feito em Java é composto de classes que
possuem atributos e métodos. Os atributos em uma classe são variáveis que podem ser
modificadas ao longo da execução do programa, os métodos por sua vez, executam determinadas
tarefas e retornam respostas.
Ainda de acordo com Santos (pág. 14, 2010), Java é totalmente orientada a objetos, possui
suporte para threads3, ou seja, garante que o programa rode vários processos ao mesmo tempo
3
thread : Um fluxo de controle sequencial isolado dentro de um programa.

______________________________________________________________________________________________
(multitarefa), possuí tratamento de erros (exceptions), coletor de lixo (Garbage Colector). Possui
também um conjunto de bibliotecas de classes (API) prontas, que diminuem o trabalho do
programador, é multiplataforma, enfim são essas, e outras características que fazem do Java uma
das linguagens mais populares do mundo.
1.3 Licença
A Sun disponibiliza a maioria das distribuições Java gratuitamente e obtém receita com
programas mais especializados como o Java Enterprise System. Em 13 de novembro de 2006, a
Sun liberou partes do Java como software livre, sob a licença GNU General Public License. A
liberação completa do código fonte sob a GPL ocorreu em maio de 2007.
1.4 Máquina Virtual
Quando um programa Java é compilado, gera-se um código intermediário, o bytecode, que
é interpretado pela máquina virtual Java, que por sua vez traduz os bytecodes para a linguagem de
máquina nativa do processador. Desta forma, a tecnologia Java é multiplataforma, ou seja, um
programa em Java rodará em qualquer plataforma que possua um JVM (SANTOS, pág. 3, 2010).
De acordo com a especificação da SUN, a máquina virtual do Java pode ser vista como:
 Uma máquina imaginária que é implementada via software ou hardware;
 Um código a ser executado por essa máquina deve ser gravado em um arquivo com
extensão .class. e possuir um código compatível com as instruções Java.
Para um programa Java ser executado, ele precisa passar pelo processo ilustrado na figura a
seguir:
O código é compilado, gerando um conjunto de instruções chamado de byte-code. Esse
byte-code é aplicado à Máquina Virtual Java ( JVM ) que se encarrega de interpretar os comandos
para o sistema operacional onde o programa está rodando, ou seja, a máquina virtual traduz as
instruções do código Java para instruções válidas no sistema operacional em que está rodando.
Se essa portabilidade fosse requerida em C, o código deveria ser compilado várias vezes – uma
para cada sistema operacional desejado. No caso do Java, o código é compilado apenas uma vez,
gerando o byte-code. Esse byte-code poderá então ser interpretado por qualquer máquina virtual
Java, rodando em Linux, Windows, Palm OS, Solaris ou qualquer outro sistema operacional que
possua uma máquina virtual Java implementada.
Uma JVM possui definições concretas para a implementação dos seguintes itens:
 Conjunto de instruções (equivalentes às instruções da CPU);

______________________________________________________________________________________________
 Conjunto de registradores;
 Formato padrão de classes;
 Pilha de memória;
 Pilha de objetos coletados pelo garbage-collector;
 Área de memória.
IMPORTANTE: a JVM não permite que um programa Java acesse recursos de hardware
diretamente, protegendo o computador de operações perigosas, como acesso a regiões protegidas
da memória ou formatação física do disco rígido. Um programa Java só é executado caso o seu
byte-code passe pela verificação de segurança da JVM, que consiste em dizer que:
 O programa foi escrito utilizando-se a sintaxe e semântica da linguagem Java;
 Não existem violações de áreas restritas de memória no código;
 O código não gera Stack Overflow;
 Os tipos de parâmetros dos métodos são corretos;
 Não existe nenhuma conversão ilegal entre dados do programa, como a tentativa de
conversão de inteiros em ponteiros;
 O acesso a objetos está corretamente declarado;
 Caso alguma das condições acima não seja satisfeita, a máquina virtual Java causará um
erro de execução (runtime error).
1.5 Garbage Collection
Durante a execução de um programa de computador, ocorre a alocação e liberação dinâmica
de memória RAM. Dados são escritos e lidos da memória do computador satisfazendo os requisitos
de cada programa. Em linguagens tradicionais como Pascal, Basic e C/C++, o programador é
responsável por controlar essa alocação, impedindo o estouro de memória (stack overflow) e outros
problemas, como o acesso indevido a áreas reservadas de memória. Para facilitar a vida dos
programadores, e evitar os erros comuns associados à alocação de memória, a linguagem Java
introduziu um novo conceito: o garbage-collection.
Garbage-collection é um mecanismo de controle automático de alocação e liberação de
memória. Quando uma variável é declarada em um código de computador, a JVM cria um ponteiro
para uma área de memória equivalente ao tamanho do tipo de dado utilizado por essa variável.
Quando essa variável é associada a outra região de memória, a JVM coloca o espaço alocado
anteriormente em uma pilha de objetos em desuso. Caso o computador fique com pouca memória
disponível, a JVM remove objetos dessa pilha, permitindo que esse espaço de memória seja
realocado.
O processo de garbage-collection ocorre automaticamente durante a execução de um
programa Java. O programador não precisa se preocupar com aritmética de ponteiros (grande
dificuldade em linguagens como C e Pascal).
1.6 Estrutura de um código em Java
Como todas as outras linguagens de programação, Java possui um formato básico para a

______________________________________________________________________________________________
escrita de códigos. Tal formato é demonstrado a seguir:
1. // Duas barras significam comentário
2. /* comentários também podem seguir o formato de C++ */
3.
4. public class NomeDoPrograma
5. {
6. // O método main sempre deve estar presente para que um código Java possa ser
executado:
7. static public void main(String[] args)
8. {
9. // aqui virão os comandos, que são parecidos com C++
10. }
11. }
Compreendendo o código Java:
 linhas 1 e 2: representam comentários. Um comentário pode conter qualquer informação
relevante ao comportamento do programa, autor, versão, etc.;
 linha 3: está em branco, pois Java permite linhas em branco entre os comandos;
 linha 4: é a declaração do "nome do programa", que é case-sensitive (existe diferença entre
maiúsculas e minúsculas). O arquivo que contém o código Java deve ser salvo com o mesmo
nome que aparece após a declaração public class e mais a extensão .java (o exemplo acima
deveria ser salvo como NomeDoPrograma.java);
 linha 5 e 8: a abertura de chave { indica início de bloco;
 linha 7: essa linha deve aparecer em todos os códigos Java. Quando um programa Java é
executado, o interpretador da JVM executa os comandos que estiverem dentro do bloco
indicado pelo método "static public void main(String)";
 Linha 9: aqui seria escrito o código propriamente dito. Instruções como for-next, print, etc.;
 Linha 10 e 11: o fechamento de chave } indica fim de bloco;

______________________________________________________________________________________________
Exemplo de código Java:
Como rodar o programa:
1. Salvar o código acima em um arquivo nomeado: OlaMundo.java (não esqueça o case-sensitive);
2. Digite no console:
a. C:exercicio-java>javac AloMundo.java;
3. Caso não ocorra nenhuma mensagem de erro, digite:
a. C:exercicio-java>java AloMundo
Obs: Caso os procedimentos acima não funcionarem deve ser verificado se o Java está instalado
na máquina, ou o JDK (Kit de Desenvolvimento Java), ou ainda se as configurações estão corretas.
1.7 Instalação e configuração do java
As instruções aqui contidas referem-se ao sistema operacional Windows 7.
1.7.1 Requisitos do Sistema Java 8
 Windows 10 (8u51 e versões posteriores);
 Windows 8.x (Desktop);
 Windows 7 SP1;
 Windows Vista SP2;
 Windows Server 2008 R2 SP1 (64 bits);
 Windows Server 2012 e 2012 R2 (64 bits);
 RAM: 128 MB;
 Espaço em disco: 124 MB para JRE; 2 MB para Java Update;
 Processador: no mínimo, um processador Pentium 2 de 266 MHz;
 Browsers: Internet Explorer 9 e versão mais recente, Firefox, Chrome;
1.7.2 Download e Instalação
É recomendável a desativação do firewall da Internet antes de continuar com a instalação
on-line. Em alguns casos, as configurações padrão do firewall estão definidas para rejeitar
instalações automáticas ou on-line, como a do Java. Se o firewall não estiver configurado
corretamente, talvez ele atrase a operação de download/instalação do Java sob certas condições.

______________________________________________________________________________________________
Consulte o seu manual específico para obter instruções sobre como desativar seu firewall da
Internet.
 Acessar a página de download: manual:https://www.java.com/pt_BR/download/manual.jsp
 Clicar em Windows Online.
 A caixa de diálogo Download de Arquivo é exibida, solicitando que execute ou salve o
arquivo do download.
 Para executar o instalador, clique em Executar.
 Para salvar o arquivo para instalação posterior, clicar em Salvar.
 Selecione a localização da pasta e salve o arquivo no sistema local.
Dica: salvar o arquivo em um local do computador que seja fácil de acessar, como a área de
trabalho.
Para iniciar o processo de instalação, clicar duas vezes no arquivo salvo.
 O processo de instalação será iniciado. Clicar no botão Instalar para aceitar os termos de
licença e continuar com a instalação.
 A Oracle é parceira de algumas empresas que oferecem diversos produtos. O instalador poderá
apresentar uma opção para instalar esses programas quando você instalar o Java. Depois de
verificar se os programas desejados foram selecionados, clique no botão Avançar para
continuar com a instalação;
 Algumas caixas de diálogo confirmam as últimas etapas do processo de instalação. Clique em
Fechar na última caixa de diálogo. Isso concluirá o processo de instalação do Java.

______________________________________________________________________________________________
Remover versões mais antigas (8u20 e versões posteriores). A partir do Java 8 Update 20
(8u20), nos sistemas Windows, a ferramenta de desinstalação do Java é integrada com o instalador
para fornecer uma opção para remover do sistema as versões mais antigas do Java. A alteração
se aplica a plataformas Windows de 32 bits e de 64 bits.
Notificações sobre Java desativado e restauração de prompts. O instalador avisa caso o
conteúdo Java esteja desativado nos Web browsers e fornece instruções para ativá-lo. Se você
tiver optado por ocultar alguns prompts de segurança para applets e aplicações Java Web Start, o
instalador fornecerá uma opção para restaurar os prompts. O instalador pode solicitar que o
computador seja reiniciado se você tiver optado por não reiniciar um Internet browser quando foi
solicitado a fazê-lo.
Após a instalação do Java (JRE) o sistema está pronto para executar aplicações construídas
utilizando a linguagem. Porém, para que se possa criar novos programas não é o suficiente. Para
tanto é necessário ter instalado no computador o JDK (Kit de Desenvolvimento Java).
Instalação do JDK
O JDK (Java Development Kit) possui todo o ambiente necessário para desenvolver e
executar aplicativos em Java, contendo uma cópia do JRE que pode ser distribuído junto com sua
aplicação em algum tipo de instalador ou CD, por exemplo, para os clientes não precisarem baixar
e/ou instalar o Java pessoalmente.
A seguir o endereço para o obter a versão 8 do JDK:
http://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html
Um ponto bastante importante é sempre escolher o tipo do sistema operacional, este exemplo de
instalação é para versões Windows (x86).

______________________________________________________________________________________________
Página para download do JDK 8.
Após ter baixado o instalador da JDK, execute o instalador e avance nas telas a seguir:

______________________________________________________________________________________________
Opções de instalação:
Status de instalação e pasta de destino:

______________________________________________________________________________________________
Progresso da instalação JDK:
Local da instalação do JRE:
Browser que irá possuir o plugin do Java
Progresso da instalação do JRE:

______________________________________________________________________________________________
Finalização da Instalação:
Após o término da instalação vamos configurar as variáveis do ambiente, abaixo estão os passos
a serem seguidos.
1. Clique com o botão direito em cima do ícone “Meu Computador”;
2. Vá em “Propriedades”;
3. Selecione a aba “Avançado” (Windows XP) ou “Configurações avançadas do sistema”, depois
na aba “Avançado” (Windows 7);
4. Clique no botão “Variáveis de ambiente”;
5. Clique no botão “Nova” em “Variáveis do sistema”;
5.1. Nome da variável: JAVA_HOME
5.2. Valor da variável: coloque aqui o endereço de instalação (o caminho tem que ser o
mesmo especificado na figura a seguir) “C:Arquivos de programasJavajdk1.5.0_05”
5.3. Clique em OK

______________________________________________________________________________________________
6. Clique novamente no botão “Nova” em “Variáveis do sistema”;
6.1. Nome da variável: CLASSPATH
6.2. Os valores da variável encontram-se abaixo, sempre insira um do lado outro sem
espaços e com o ; (ponto e vírgula) no final.
Listagem 1: Valor da variável
CLASSPATH ;%JAVA_HOME%lib;%JAVA_HOME%libtools.jar;%JAVA_HOME%libdt.jar;%JAVA
_HOME%libhtmlconverter.jar;%JAVA_HOME%jrelib;%JAVA_HOME%jrelibrt.jar;
6.3. Clique em OK
7. Selecione a variável PATH em “Variáveis do sistema” e clique no botão “Editar”;
7.1. Defina o valor dessa variável com o caminho da pasta Bin. No caso, pode-se utilizar a
variável JAVA_HOME previamente definida.
Listagem 2: Valor da variável de ambiente PATH;%JAVA_HOME%bin

______________________________________________________________________________________________
7.3. Então confirma-se todas as telas no botão Ok.
Logo após ter realizado a configuração acima emula-se um programa em Java.
Testando o Programa em Java
Abra o programa de bloco de notas do Windows (Iniciar > Programas > Acessórios > Bloco de
Notas.
Digite as seguintes linhas:
Listagem 3: Código de um programa Java para teste
public class Ola{
public static void main(String[] args){
System.out.println("Bem Vindo ao Mundo Java!");
}
}

______________________________________________________________________________________________
Salvamento do arquivo Ola.java:
Depois de salvar abra o Prompt do Dos para testar a saída desse sistema.
1. Iniciar
2. Windows XP - Executar e digitar a palavra cmd
3. Windows 7 apenas digite cmd e aperte Enter
Prompt do DOS
Digite a seguinte linha abaixo, para testar se o java está tendo retorno da sua máquina. Deve ser
retornado uma mensagem conforme a figura a seguir.
Verificando a versão do Java
java -version

______________________________________________________________________________________________
Versão do Java instalada no computador
Após obter o retorno da versão estamos prontos para compilar nosso primeiro programa em
Java. Para efetuar a ação seguinte irá ser preciso entrar em modo DOS na pasta em que foi salvo
o arquivo “Ola.java”, como nesse exemplo foi salvo dentro da pasta que já iniciou o Prompt do Dos
(c:UsersThiago), apenas vamos digitar a seguinte linha.
Compilando um programa Java pelo prompt
javac Ola.java
Ao efetuar esse processo é criado na nossa pasta mais um arquivo “Ola.class”, que nada
mais é que os bytecodes gerados pela JVM, quando compilado o arquivo “Ola.java”.
Os arquivos .java são os nossos códigos fontes e os .class são a execução deles, sendo que
se tentarmos abrir um arquivo .class irá aparecer vários caracteres especiais, sendo ilegível, ou
seja, ele transforma o código fonte para código de máquina sendo este independente de plataforma.
Agora, para finalizarmos, vamos ver a saída do programa digitando a linha abaixo:
java Ola

______________________________________________________________________________________________
O resultado deverá possuir a saída “Bem Vindo ao Mundo Java”.
1.8 Ferramentas
O desenvolvimento de software é uma das áreas que mais recursos livres possui,
frameworks multiplataforma, IDE4´s livres de alta qualidade, bancos de dados, entre outros. Nesta
apostila é apresentado algumas ferramentas que proporcionam maior qualidade no processo de
desenvolvimento de software, na linguagem Java, totalmente livres.
A seguir é apresentado um algumas das principais IDEs, de para desenvolvimento em Java.
Na área de desenvolvimento de software, muitos programadores (principalmente aqueles
que iniciam) possuem certo grau de indecisão sobre qual IDE utilizar. Atualmente, as duas IDEs
mais conhecidas e utilizadas para o desenvolvimento de software em Java são o Eclipse e o
NetBeans, sendo ótimas opções aos desenvolvedores, que muitas vezes se deparam com a dúvida
de qual escolher. Estes dois ambientes possuem código aberto e são gratuitos, podendo ser
utilizados para o desenvolvimento de aplicações em outras linguagens, além de Java, podendo
também serem executados em diversas plataformas, além do Windows.
Existem ainda outras IDEs, gratuítas, para o desenvolvimento de aplicações java, como o
JCreator, CodeBlock, BlueJ e outros.
1.8.1 Eclipse
O Eclipse é uma ferramenta IDE que compreende vários tipos de linguagem e que aceita a
instalação de plugins para emular o desenvolvimento da plataforma.
O projeto Eclipse foi iniciado pela IBM, que doou como software livre para a comunidade a
primeira versão do produto. Os autores que criam plug-ins para Eclipse ou que o usam como base
para um aplicativo de desenvolvimento de software são obrigados a liberar qualquer código ou
modificação do Eclipse que usarem de acordo com os termos da EPL, mas podem licenciar suas
próprias adições da maneira que desejarem.
Com o Eclipse boa parte da dificuldade em compilar o programa é descartada, pois, seu
editor de códigos possui muitas funcionalidades e ferramentas, facilitando o desenvolvimento da
aplicação.
Como desvantagem pode-se citar a falta de funcionalidades essenciais para o
desenvolvimento, como criação de telas GUI (Graphic User Interface) que são janelas de
4
IDE : IDE é uma ferramenta que reúne recursos para que o desenvolvimento de software fique mais ágil e fácil,
possibilitando assim maior produtividade ao desenvolvedor.

______________________________________________________________________________________________
programas e sistemas comerciais, como as do Windows e do Linux) e design de páginas web.
1.8.2 NetBeans
O NetBeans é uma ferramenta IDE que permite o desenvolvimento rápido e fácil de
aplicações desktop Java, móveis e Web e também aplicações HTML5 com HTML, JavaScript e
CSS. O IDE também fornece um grande conjunto de ferramentas para desenvolvedores de PHP e
C/C++. Ela é gratuita e tem código-fonte aberto, além de uma grande comunidade de usuários e
desenvolvedores em todo o mundo.
O Netbeans foi desenvolvido por dois estudantes tchecos na Universidade de Charles,
em Praga, quando a linguagem de programação Java ainda não era tão popular como atualmente.
Primeiramente o nome do projeto era Xelfi, em alusão ao Delphi, pois a pretensão deste
projeto era ter funcionalidades semelhantes aos IDEs tão populares do Delphi, que eram mais atra-
tivas por serem ferramentas visuais e mais fáceis de usar, porém com o intuito de ser totalmente
desenvolvido em Java.
Em 1999 o projeto já havia evoluído para uma IDE proprietário, com o nome de NetBeans
DeveloperX2, nome que veio da ideia de reutilização de componentes que era a base do Java.
Nessa época a empresa Sun Microsystems havia desistido de sua IDE Java Workshop e, procu-
rando por novas iniciativas, adquiriu o projeto NetBeans DeveloperX2 incorporando-o a sua linha
de softwares.
Como uma das vantagens do NetBeans ele é 100% java, feito em Swing, portanto roda onde
houver uma JRE 1.3 compatível (Java Runtime Environment), suporta 'out-of-the-box' (sem plugins
extras) J2EE (EJBs, WebServices, JSP, etc), design visual de telas Swing. Versão 4.1 é uma versão
mais rápida e possui menos memória
Como desvantagens ele fica um pouco atrás nas funcionalidades na compilação de progra-
mas, poucos templates de código, pouco controle no código da aplicação por parte do desenvolve-
dor. A IDE gera código automaticamente sem que o desenvolvedor o conheça.
1.8.3 Jcreator
JCreator é um IDE Ambiente de Desenvolvimento Integrado criado pela Xinox Software
tendo as versões Pro e LE (Learn Edition) que suporta o desenvolvimento em Java,JavaS-
cript,XML,HTML.
JCreator é uma poderosa e interativa ferramenta de desenvolvimento (IDE) para JAVA que
com as seguintes características:
 Manipulação de projetos em uma interface semelhante à do Microsoft Visual Studio;
 Definição de esquemas de cor XML;
 Reutilização de código de projetos existentes usando diferentes versões do JDK;
 Modelos pré-definidos;
 Permite manusear e intercambiar código com sua integração entre Ant e CVS.
 Personalização da interface do usuário.
Como vantagem pode-se citar o uso dele pela web, incorpora Framework, desvantagens perde um
pouco em agilidade.

______________________________________________________________________________________________
1.8.4 BlueJ
O BlueJ é um ambiente gratuito de desenvolvimento de aplicações orientadas a objetos
utilizando a linguagem de programação Java. Uma de suas características principais é a facilidade
de aprendizagem de programação OO, através de recursos visuais interativos. Por exemplo,
classes e relacionamentos podem ser definidos visualmente, e é possível verificar o comportamento
dos objetos em memória durante a execução.
O BlueJ é resultado de um projeto de pesquisa voltado ao ensino de orientação a objetos
para iniciantes, desenvolvido pela Deakin University (Austrália) e University of Kent (Inglaterra),
com contribuições de diversos outros grupos. É também suportado pela Sun Microsystems. O
projeto "NetBeans BlueJ Edition", que recentemente liberou sua primeira versão beta, permite a
migração suave de iniciantes utilizando do BlueJ para um IDE profissional.
1.9 IDE Netbeans
Os exemplos apresentados doravante serão construídos utilizando a IDE NetBeans.
Portanto faz-se necessário uma apresentação mais detalhada desta ferramenta. A seguir é
apresentado os recursos mais utilizados desta ferramenta.
Criação de Projeto:
1 – Abrir a ferramenta NetBeans, clicar em “Arquivo”, “Novo Projeto”.
2- Em “Novo Projeto”, selecionar a opção “aplicação JAVA”, então “Próximo”.

______________________________________________________________________________________________
Criando classe:

______________________________________________________________________________________________
Criando primeiro programa em Java
Execução do Programa:
Antes de apresentar a sintaxe da linguagem Java, é importante apresentar alguns conceitos
básicos e essenciais para a programação, utilizando como ferramenta a linguagem Java, que se
baseia nas linguagens C e C++.
Um programa escrito em Java é composto de classes que possuem atributos e métodos. Os
atributos em uma classe são variáveis que podem ser modificadas ao longo da execução do
programa, já os métodos, executam determinadas tarefas a partir de informações de entrada,
retornando ou não, respostas.
Java é totalmente orientada a objetos, ...
Linguagem Java 2

______________________________________________________________________________________________
2.1 Sintaxe Java
O formato de codificação da linguagem Java deve seguir uma serie de diretrizes para que
os algoritmos possam ser implementados. Um algoritmo é um procedimento para resolver um
problema em um número finito de passos, que frequentemente envolve a repetição de operações.
2.1.1 Delimitadores em Java
Em um código-fonte Java, alguns símbolos são utilizados pelo compilador para diferenciar
comandos, blocos de comandos, métodos, classes, etc. Tais símbolos, chamados de delimitadores,
são enumerados a seguir:
2.1.1.1 Comentários
Comentários servem para identificar a função de um comando, um trecho de código, ou um
método.
Além disso, os comentários podem ser utilizados para documentar aspectos de
desenvolvimento de um programa: como o nome da empresa que o desenvolveu, nome dos
programadores, versão, etc. Existem dois tipos de comentário: o simples e o de documentação.
O comentário simples é delimitado por duas barras // e termina ao final de uma linha. O
comentário de documentação é iniciado pelo símbolo /** e encerrado pelo símbolo */, podendo
conter várias linhas de texto e linhas em branco.
2.1.1.2 Blocos
Um bloco é formado por um conjunto de instruções delimitadas por chaves, como no
exemplo abaixo:
Ponto e vírgula, blocos e espaços em branco: em Java, todo comando é terminado por um ponto
e vírgula (;). Exemplo: System.out.println("note o ponto e vírgula no final ");
Espaço em branco, quebra de linha e caracteres de tabulação são permitidos em qualquer

______________________________________________________________________________________________
trecho do código-fonte, devendo ser utilizados para realçar o aspecto visual de seu código. Apesar
do aspecto visual do código-fonte não ter nenhum impacto no desempenho de um programa Java,
o uso de endentação é uma característica de bons códigos-fonte. Um único programador não será
o único a ler o código-fonte de seus programas, portanto o programa deve ser escrito da maneira
mais organizada e legível possível.
2.1.2 Identificadores e palavras reservadas
Em Java, um identificador é uma sequência de símbolos UNICODE (64K símbolos) que
começa com uma letra, um símbolo subscrito _, ou o caractere $. Os demais símbolos de um
identificador podem conter também números. Identificadores são case-sensitive e não tem um
tamanho máximo estabelecido. Apesar da tabela UNICODE ser bastante extensa, um bom hábito
de programação é utilizar somente letras do alfabeto (a-Z) e números para nomear identificadores.
Exemplo de identificadores Válidos:
data
_data
$data
data_do_mês
data1
uma_variável_pode_SER_bastante_extensa_e_conter_Numeros234876238476
data_public_class_NoteQueEsseIdentificadorContemPalavrasReservadas
Apesar desta "liberdade" de opções para nomes de identificadores, algumas palavras não
são permitidas. Tais palavras são ditas palavras reservadas, e representam o conjunto de
comandos que forma a sintaxe da linguagem Java. O conjunto de palavras reservadas em Java é
o seguinte:
abstract
boolean
break
byte
case
catch
char
class
const
continue
default
double
else
extends
final
finally
float
for
goto
if
implements
import
int
interface
long
native
new
package
private
protected
public
return
short
strictfp
super
switch
synchronized
this
throw

______________________________________________________________________________________________
throws
transient
try
void
volatile
static
while
Não é preciso se preocupar em memorizar o nome das palavras reservadas em Java. À
medida que se pratica a programação em Java, isso se tornará natural. Além disso, o compilador
acusa um erro de nomenclatura quando se tenta utilizar uma palavra reservada para nomear uma
variável, um método ou uma classe.
2.1.3 Declaração de Variáveis
Uma variável é sempre declarada seguindo do seguinte esquema:
<tipo> + <espaço> + identificador + ;
ou
<tipo> + <espaço> + identificador + = + valor + ;
onde:
<tipo> é um tipo primitivo de dados ou o nome de uma classe ou interface
identificador é o nome da variável
valor é o valor atribuído à variável. No caso de uma variável ser declarada sem atribuir um valor,
ela não poderá ser utilizada em um código Java, a tentativa de utilizar uma variável não inicializada
em Java gerará um erro de compilação. Exemplos:
Posteriormente será visto que Java possui um mecanismo de inicialização de variáveis de
seus tipos primitivos, mas o aluno deve evitar considerar essa inicialização como prática de
programação. De fato, esta inicialização automática não funciona para variáveis de tipos agregados
ou abstratos de dados e também que o escopo das variáveis, de classe ou de instância, tem
influência na sua inicialização. O aluno é fortemente recomendado a pensar em variáveis como
espaços alocados na memória RAM, inicialmente podendo conter qualquer valor (conhecido como
lixo na memória).

______________________________________________________________________________________________
2.1.4 Tipos primitivos
A linguagem Java utiliza oito tipos primitivos de dados e um tipo especial. Esses tipos
primitivos podem ser utilizados para declarar constantes ou variáveis utilizadas em programas Java.
Os tipos primitivos estão divididos em quatro categorias: lógicos, textuais, numéricos inteiros e
numéricos de ponto flutuante.
2.1.4.1 Tipos lógicos: boolean
Valores lógicos possuem dois estados, normalmente ditos verdadeiro/falso, sim/não e ligado/
desligado. Em Java um tipo lógico é definido pela palavra boolean, e pode assumir dois valores:
true ou false.
2.1.4.2 Tipos textuais: char e String
Caracteres simples são representados pelo tipo char. Um char representa um caracter
UNICODE, ou seja, um número inteiro sem sinal de 16 bits, no intervalo de 0 até 216 -1. O valor de
um literal char deve ser delimitado por aspas simples:
Palavras são representadas por uma sequência de dados do tipo char, agrupadas em um
tipo especial de dados: a classe String. Apesar de ser uma classe, uma variável do tipo String

______________________________________________________________________________________________
suporta operações como se fosse um tipo primitivo de dados. O valor de uma variável String deve
ser delimitado por aspas duplas "valor". A concatenação de qualquer tipo de dado com um dado do
tipo String resulta em um novo dado do tipo String.
2.1.4.3 Tipos numéricos inteiros: byte, short, int e long
Existem quatro tipos primitivos de números em Java. Além disso, os valores numéricos
podem ser representados de forma decimal, octal ou hexadecimal:
Valores numéricos inteiros em Java:
2 decimal
077 um número que começa com zero está representado de forma octal
0xBABE representação hexadecimal
Todos os valores numéricos em Java têm sinal positivo ou negativo. Um valor numérico é
sempre considerado do tipo int, a menos que seja acompanhado do sufixo L, que representa um
valor do tipo long. A diferença de um inteiro para um longo é a capacidade de dígitos que podem
ser representados, conforme aparece no quadro abaixo.
Valores numéricos em Java, representados como long:
2L decimal
077L um número que começa com zero está representado de forma octal
0xBABEL representação hexadecimal
2.1.4.4 Tipos numéricos de ponto flutuante: float e double
Um valor fracionário pode ser representado em Java através dos tipos float e double. A
diferença entre esses dois tipos é o tamanho da mantissa:
float 32 bits
double 64 bits
Para um número ser considerado do tipo ponto flutuante, é necessário a inclusão de um ponto, do
caractere E (de expoente) ou do sufixo D ou F, conforme mostra o quadro abaixo:
// Representação de valores numéricos de ponto flutuante
float pi = 3.141516;
float taxa = 6.02E23;
double valor= 123.4E+306D;
Todo o valor numérico de ponto flutuante é considerado do tipo double, a menos que o programador
o declare explicitamente como float.
2.2 Convenções de codificação
Durante os estudos realizados a partir desta disciplina, será adotada a seguinte convenção

______________________________________________________________________________________________
de codificação:
 Classes: as classes devem ser designadas por nomes, começando por uma letra maiúscula
e depois minúsculas. Cada nova palavra que formar o nome da classe deve ser capitalizada.
Ex: class Calculadora, class CalculadoraCientifica, ...
 Interfaces: igual às classes. Ex: interface Calculo, interface EquacaoLogaritmica, ...
 Métodos: métodos devem ser nomeados por verbos, seguindo o mesmo formato de
capitalização das classes. Entretanto, um método sempre deve começar com letra
minúscula. Ex: public void calcular(int numero), public void extrairRaiz(int numero), ...
 Constantes: constantes devem ter todas as suas letras em maiúsculo, com o símbolo de
subscrito para separa as palavras. Ex: final int ANO = 2002, final boolean VERDADE =
true, ...
 Variáveis: tal qual os métodos, as variáveis devem começar com uma letra minúscula e
depois alternar a cada palavra. Procure usar nomes significativos para variáveis. Evite
declarar variáveis usando apenas um a letra.
Através de expressões é implementado a manipulação de variáveis e implementação de
tomada de decisões em programas Java.
3.1 Operadores
Os operadores Java são similares em estilo e função aos operadores da linguagem C/C++.
A tabela abaixo enumera esses operadores em ordem de precedência:
3.1.1 Operadores Delimitadores
. [] () ; , Servem para delimitar partes distintas de um comando, método ou classe.
3.1.2 Operadores Aritméticos
+ Adição
- Subtração
* Multiplicação
/ Divisão
% Resto (Modulo)
Expressões 3

______________________________________________________________________________________________
3.1.3 Operadores de Atribuição
+= x += y → x=x + y
-= x -= y → x=x - y
*= x *= y → x=x * y
/= x /= y → x=x / y
%= x %= y → x=x % y
3.1.4 Operadores Unários
+ e - Para mudar o sinal do operando.
3.1.5 Operadores de Incremento e Decremento
++ Incremento Ex: x++ → x=x+1
-- Decremento Ex: x-- → x=x-1
3.1.6 Operadores Relacionais
> Maior que
< Menor que
== Igual a
!= Diferente de
>= Maior ou igual
<= Menor ou igual
3.1.7 Operadores Lógicos
&& Devolve true se ambos operandos forem true.
||
!
Esses operadores permitem a representação de expressões booleanas, que formam o argumento
para comandos de decisão (IF), seguindo a seguinte tabela:
AND
true && true = true;
false && false = false;
false && true = false;
true && false = false;
OR
true || true = true
false || false = false
false || true = true
true || false = true
Os comandos de controle (if, while, switch) utilizam o valor de expressões booleanas para guiar o
fluxo de controle de um programa, como no exemplo a seguir:

______________________________________________________________________________________________
3.1.8 Operador de concatenação
+ Concatena (junta) dados do tipo string
Quando o operador + é aplicado a dados do tipo String, ele cria um novo dado do tipo String,
concatenando os dois operandos:
/**
* Concatenação de Strings
*/
String sigla = "CIMOL";
String nome = "Escola Estadual Monteiro Lobato";
String titulo = sigla + " - " + nome;
// Esse comando imprimirá na tela a frase:
// SOO-I – Sistemas Orientados a Objetos I
System.out.prinln(titulo);
int i = 10;
String legenda = "valor = ";
// campo é uma variável do tipo String
String campo = legenda + i;
3.1.9 Operadores de deslocamento
>> É usado para deslocar o padrão de bits para a direita respeitando o bit do
sinal, ou seja, tudo é deslocado, menos o primeiro bit.
<< É usado para deslocar os bits para a esquerda.
>>> Não respeita o sinal, ou seja, realmente todo mundo é deslocado para
direita, e é colocado um bit com valor 0 à esquerda do padrão.
O operador de deslocamento aritmético >> executa um deslocamento de um bit para a direita
de um número (na prática, o primeiro argumento desse operador é dividido por dois 'n' vezes –
onde n é o segundo argumento do operador):
8 >> 2 = 2

______________________________________________________________________________________________
128 >> 1 = 64
256 >> 4 = 16
 Notação em complemento de dois: o operador >> mantém o sinal do bit mais significativo
durante o deslocamento.
O operador de deslocamento lógico >>> executa um deslocamento no padrão dos bits ao
invés do significado aritmético de um valor numérico. Esse operador sempre adiciona o valor 0 ao
bit mais significativo:
1010 ... >> 2 = 111010 ...
1010 ... >>> 2 = 001010 …
 Os operadores de deslocamento reduzem seus operandos à direita módulo 32 para um valor
do tipo int e módulo 64 para um tipo long. Dessa forma, para qualquer valor do tipo int:
int x
x >>> 32 = x
O operador de deslocamento lógico >>> só pode ser aplicado a valores inteiros, e não é
efetivo em valores int e long. Se for aplicado a valor short ou byte, o valor será promovido a um int
antes da aplicação do operador. Por isso, um deslocamento sem sinal acaba se tornando um
deslocamento com sinal.
3.2 Casting
A linguagem Java não suporta atribuições arbitrárias entre variáveis de tipos diferentes. Por
exemplo, você não pode inicializar uma variável inteira com um valor de ponto flutuante sem
explicitar isso através de um processo que chamamos de casting.
Quando atribuímos um valor a uma variável, e esse valor é incompatível com o tipo de dado
definido para a variável, ocorrerá uma conversão. Em alguns casos, essa conversão será
automática, em outros o programador deve indicar de que forma o valor será convertido ao tipo de
dado da variável.
Quando o processo de conversão for automático, dizemos que ocorreu uma promoção, ou
seja, um valor com um tipo de dado foi promovido a outro tipo de dado. Veja no exemplo abaixo:
// Promoção entre valores de tipos de dados distintos
// Apesar 6 ser um inteiro, o valor da variável grande
// continua sendo do tipo long
long grande = 6;
// Uma variável do tipo inteiro não possui
// espaço para armazenar um valor longo.
// A instrução abaixo é ilegal, e causará um erro de compilação.
int pequeno = 99L;
float a = 12.121F;
float b = 12.121;
// correto
// 12.121 é um double - incorreto
Como visto acima, algumas conversões não podem ser realizadas de forma automática, pois

______________________________________________________________________________________________
o compilador não pode assumir que tipo de conversão ele deve realizar (o tamanho do tipo de dado
a ser recebido por uma variável é maior que o tamanho pré-definido para o tipo dessa variável, logo
o compilador não sabe como "ajustar" os bits excedentes). Nesse caso, o programador deve indicar
ao compilador que tipo de conversão deverá ocorrer, digitando o tipo de dado que o valor deverá
assumir entre parênteses:
// Casting entre valores de tipos de dados distintos
// Apesar 6 ser um inteiro, o valor da variável grande
// continua sendo do tipo long
long grande = 6;
int pequeno = (int)99L; // sem problemas
float a = 12.121F;
float b = (float)a;
// sem problemas
3.3 Recebendo dados do usuário
Até este momento as variáveis estão sendo definidas juntamente com seus valores durante
a programação. Mas e se for necessário obter essa informação do usuário? Por exemplo, para
perguntar a idade ou para criar uma calculadora? Depende do que for digitado.
De agora em diante será utilizado a classe Scanner para realizar a leitura de dados a partir do
teclado.
3.3.1 Importando (import) classes (class) e pacotes (packages)
Existem milhares de funcionalidades no Java. Essas classes foram agrupadas em pacotes,
os packages.
E pacotes para a mesma funcionalidade são chamados de API (Application Programming
Interface). Por exemplo, tem uma seção sobre a API Java 2D, para fazer desenhos em 2D. Ou seja,
são uma série de pacotes para desenhar.
Porém, todos esses pacotes não estão simplesmente prontos para serem utilizados, pois
são muitos.
Inclusive, pode ser criado pacotes customizados, pode baixar, reutilizar, compartilhar, vender
etc.
Se todos estes estivessem prontos para utilização, demoraria MUITO para rodar um
programa em Java.
Para solucionar este problema, diz ao Java quais funcionalidades pretende-se usar. Pra isso,
usa-se a função 'import':
Import pacote_que_quer_importar;
Por exemplo: para usar print, printf e println, não precisa dizer nada ao Java. São métodos
tão comuns que podem ser usados automaticamente em qualquer aplicação. Esses métodos fazem
parte de um pacote chamado 'java.lang'.
Para receber dados do usuário, utiliza-se a classe Scanner, que faz parte do pacote 'java.util'.
Diz ao Java que essa classe será utilizada na aplicação. Para isso, adiciona-se essa linha no
começo do programa:

______________________________________________________________________________________________
import java.util.Scanner;
O próximo passo é declarar objeto do tipo Scanner. Chamá-lo de 'entrada'. Sua declaração
é feita da seguinte maneira:
Scanner entrada = new Scanner(System.in);
Agora, o objeto 'entrada' será usado para ler entradas do sistema.
Para o Java, há muita diferença entre inteiros, float, doubles e outros tipos. Portanto, é
necessário ser bem claro quanto ao tipo de dado que vai ser lido. Assim, a entrada será bem tipada.
Para receber um número inteiro do usuário, com nosso objeto 'entrada', usaremos a seguinte
sintaxe: inteiro = entrada.nextInt();
Esse é um exemplo bem simples que pergunta a idade do usuário, espera ele digitar (e teclar enter)
e exibe essa mensagem na tela:
No exemplo anterior foi realizado a leitura de um número inteiro. Caso o tipo de dados a ser lido
seja diferente de inteiro, deverá ser utilizado outro método, equivalente ao tipo de dados a ser
lido. Ex: Tipo double → entrada.nextDouble()
Mais informações sobre os métodos da classe Scanner pode ser encontrada na
documentação do Java: https://docs.oracle.com/javase/7/docs/api/java/util/Scanner.html.
De acordo com Santos (2010), no desenvolvimento de um programa, muitas vezes se faz
necessário o conhecimento de uma resposta para se possa decidir qual bloco de comando será
executado. Isto é alcançado através dos comandos de controle de fluxo disponibilizados pela
linguagem de programação. Desta forma, os comandos de controle de fluxo de uma linguagem de
programação especificam a ordem em que processamento é feito.
Controle de fluxo é a habilidade de ajustar a maneira como um programa realiza suas tarefas.
Por meio de instruções especiais, chamadas comandos. Essas tarefas podem ser executadas
seletivamente, repetidamente ou excepcionalmente. Não fosse o controle de fluxo, um programa
Controle de Fluxo 4

______________________________________________________________________________________________
poderia executar apenas uma única sequência de tarefas, perdendo completamente uma das
características mais interessantes da programação: a dinâmica.
Pode-se classificar os comandos aceitos pela linguagem Java em basicamente quatro categorias:
Comando Palavra Chave
Tomada de decisões if-else, switch-case
Laços ou repetições for, while, do-while
Apontamento e tratamento de
exceções
try-catch-finally, throw
outros break, continue, label:, return
4.1 Execução Condicional
4.1.1 Comando if
A forma mais simples de controle de fluxo é o comando if. Ele é empregado para executar
seletivamente ou condicionalmente um outro comando mediante um critério de seleção. Esse
critério é dado por uma expressão, cujo valor resultante deve ser um dado do tipo booleano, isto
é, true ou false. Se esse valor for true, então o outro comando é executado; se for false, a
execução do programa segue adiante. A sintaxe para esse comando é:
if ([condição])
[comando] // Executado se a condição for true
Exemplo:
Exercícios:
1) Crie um programa em que o usuário informa o nome de um mês (ex: janeiro) e o programa exibe
o número correspondente a esse mesmo mês (ex: 1);
2) Faça um programa que para n==5 exiba uma mensagem de parabéns;
3) Crie um menu de uma biblioteca da seguinte maneira: 1. Retirar um livro; 2. Devolver um livro e
3. Renovar a retirada de um livro. Em seguida, conforme a opção digitada pelo usuário, mostrar as
mensagens: 1. Livro retirado com sucesso! 2. Livro devolvido com sucesso e 3. Livro renovado.

______________________________________________________________________________________________
4) Faça um programa usando o desvio condicional "IF", que leia o nome e a idade de 1 nadador e
exiba na tela o nome da categoria a qual este nadador pertence. A categoria dos nadadores é dada
pela seguinte tabela:
5) Usando o comando de desvio condicional simples “IF”, faça um programa que leia uma senha
de 8 caracteres inteiros e verifique se a senha informada equivale a senha predefinida no programa.
Se for válida informe na tela "Acesso Autorizado. Caso a senha não estiver correta informe "Acesso
negado".
4.1.2 Comando if-else
Uma variação do comando if, e o if-else que permitem escolher alternadamente entre dois
outros comandos a executar. Nesse caso, se o valor da expressão condicional que define o critério
de seleção for true, então o primeiro dos outros dois comandos é executado, do contrário, o
segundo.
if([condição])
[comando 1] // Executado se a condição for true
else
[comando 2] // Executado se a condição for false
Exemplo:
O if-else compacto não é propriamente um comando, mas um operador que realiza
avaliação seletiva de seus operandos, mediante o valor de uma expressão booleana semelhante à
do comando if-else. Se essa expressão for true, então um primeiro operando é avaliado; se for
false então o segundo operando é avaliado. A sua sintaxe é:
[expressão condicional] ? [expressão 1] : [expressão 2]
onde [condição condicional] deve resultar em true ou false,[expressão1] e [expressão 2] são
os operandos, que podem ser expressões quaisquer. O valor resultante da aplicação do operador
if-else compacto é obviamente igual ao valor do operando que tiver sido avaliado. O tipo desse
valor obedece às regras de conversão de tipos de dados discutida anteriormente.
Para melhor ilustrar o if-else compacto, considera-se o seguinte comando:
y = x < 1 ? x*x : 2-x;

______________________________________________________________________________________________
Este é logicamente equivalente à seguinte sequência de comandos:
if (x<1) then
y = x*x;
else
y = 2-x;
4.1.3 Condicional ternário
O operador condicional ternário, também chamado de if-else compacto, é uma forma
composta de expressar uma instrução if-else:
(condição)? “Operação caso verdadeiro” : “operação caso falso”;
Exemplo:
int m = x < y ? x : y
Na instrução anterior é testado a condição, e caso, for verdadeira atribui x para m, senão
atribui y para m.
É importante notar que o operador condicional ternário é de baixa precedência, logo o uso
de parênteses para separar seus operandos não é necessário (a menos que mais de um desses
operadores esteja presente na mesma expressão). Porém há casos em que o uso de parênteses
para definir claramente os operandos é essencial. Por exemplo, y = |x|*sin(x), pode ser codificado
como:
y = ( x<0 ? -x : x ) * Math.sin(x); // aqui os parenteses são essenciais.
Sem os parênteses, x * Math.sin(x) seria visto pelo operador if-else compacto como se fosse um
único operando, devido à alta precedência do operador multiplicação.
4.1.4 Comando If-else Aninhados
No comando utilizando if-else aninhado o else é sempre associado ao if mais interno (mais
próximo). Frequentemente, deseja-se que um único comando (ou único bloco de comandos) de
uma lista seja executado mediante um dado critério. Isso pode ser feito através do aninhamento ou
acoplamento de vários comandos if-else, do seguinte modo:
if ([condição 1])
[comando 1]
else if ([condição 2])
[comandos 2])
else if ([condição 3])
[comando 3]
....
else
[comando n]
A presença do último else, juntamente com seu comando, é opcional. Neste código,
o [comando 1] será executado (e os demais saltados) caso a primeira condição seja true,
o [comando 2] será executado (e os demais saltados) caso a primeira condição seja false e a
segunda condição seja true, e assim sucessivamente. O [comando n] (se houver) somente será
executado (e os demais saltados) caso todas as condições sejam false.

______________________________________________________________________________________________
Exemplo:
Exercícios:
1) Escreva um programa em Java que recebe um inteiro e diga se é par ou ímpar.
Use o operador matemático % (resto da divisão ou módulo) e o teste condicional if
2) Crie um programa que teste se o valor que usuário digitou está entre 10 e 15 e exiba alguma
mensagem na tela.
3) Faça um programa que solicite ao usuário digitar dois valores, em seguida, exiba na tela qual
dos dois é o maior. OBS: o usuário poderá informar valores iguais, logo, o sistema deve dizer que
foram digitados valores iguais.
4) Crie um algoritmo que pergunte ao usuário se ele deseja converter uma temperatura de graus
Celsius em graus Fahrenheit ou Fahrenheit em Celsius. Em seguida mostre na tela o valor final
correspondente a opção escolhida pelo usuário. F = 1.8 * C + 32 | C = (F – 32) / 1.8;
5) A calculadora de Luciana pifou, justo quando ela precisa fazer vários cálculos. Ela tem um
computador, mas não sabe que um dos acessórios do Windows é uma calculadora. Sendo
estudante de programação, Luciana resolveu fazer um programa. A especificação que bolou prevê
que programa leia dois números inteiros (o que atende suas necessidades) e em seguida um
símbolo de operação. Se este for '+', o programa soma os números, se '-', subtrai, se '*' multiplica
e se '/' divide. Se o símbolo for diferente desses, é mostrada uma mensagem de erro. O programa,
antes de dividir, critica se o divisor é zero e mostra uma mensagem de erro neste caso. Implemente
um programa que construa essa calculadora para Luciana, utilizando o desvio condicional "IF" e
“ELSE”. Crie também procedimentos para executar cada uma das funções da calculadora.
6) Receba três valores fornecidos pelo usuário que representarão os lados de um triângulo.

______________________________________________________________________________________________
Verifique se os valores formam um triângulo e classifique esse triângulo como:
a) Equilátero: três lados iguais.
b) Isósceles: dois lados iguais.
c) Escaleno: três lados diferentes.
Lembre-se de que, para formar um triângulo, nenhum dos lados pode ser igual a zero, um lado não
pode ser maior do que a soma dos outros dois.
7) A partir de 3 notas fornecidas de um aluno, informe se ele foi aprovado, ficou de recuperação ou
foi reprovado. A média de aprovação é >= 7.0; a média de recuperação é >= 5.0 e < 7.0; e a média
do reprovado é < 5.0
8) Solicite o nome e a idade de duas pessoas. Em seguida exiba o nome da pessoa mais velha e
o nome da pessoa mais nova.
9) Verifique quem entre duas pessoas faz aniversário primeiro. Exiba o nome do primeiro aniversa-
riante considerando que estamos no dia 1 de janeiro. Use como entrada o nome, o dia e o mês de
nascimento de cada pessoa.
10) Receba 2 horários e exiba a diferença entre eles em segundos. A entrada destes horários pode
ocorrer em qualquer ordem.
Dica: transforme os dois horários para segundos.
4.1.5 Comando switch
Assim como no caso da execução seletiva de múltiplos comandos, utilizando if-else
aninhados, há situações em que se sabe de antemão que as condições assumem o valor true de
forma mutuamente exclusiva, isto é, apenas uma entre as condições sendo testadas assume o
valor true num mesmo momento. Nesses casos, a linguagem Java (como também as linguagem
C, C++ e Pascal) provê um comando de controle de fluxo bastante poderoso. Trata-se do
comando swich, cuja sintaxe é a seguinte:
switch([expressão]) {
case [constante 1]:
[comando 1]
break;
case [constante 2]:
[comando 2]
break;
.
.
.
case [constante n]:
[de comando n]
break;
default:
[comando]
}

______________________________________________________________________________________________
A [expressão] pode ser qualquer expressão válida. Esta é avaliada e o seu valor resultante
é comparado com as constantes distintas [constante 1],[constante 2], ..., [constante n]. Caso
esse valor seja igual a uma dessas constantes, o respectivo comando é executado (e todos os
demais são saltados). Se o valor for diferente de todas essas constantes, então o comando
presente sob o rótulo default: é executado (e todos os demais são saltados), caso este esteja
presente.
Exemplo:
A opção default, é opcional, caso nenhuma das opções for executada, o switch não executará
nada. Somente serão aceitos valores int e char.
Exercícios:
1) Crie um programa que exibe se um dia é dia útil, fim de semana ou dia inválido dado o número
referente ao dia. Considere que domingo é o dia 1 e sábado é o dia 7.
2) Ler o código de um produto e exibir seu nome de acordo com a tabela a seguir:
3) Criar um programa para identificar o valor a ser pago por um plano de saúde dada a idade do
conveniado considerando que todos pagam R$ 100 mais um adicional conforme os seguintes
dados:
a) crianças com menos de 10 anos pagam R$80;
b) conveniados com idade entre 10 e 30 anos pagam R$50;
c) conveniados com idade entre 40 e 60 anos pagam R$ 95;
d) conveniados com mais de 60 anos pagam R$130.

______________________________________________________________________________________________
Exercícios:
1) Faça um programa que transforme um número Racional (formado por numerador e
denominador) para um número Real. Antes de dividir, verifique se o denominador é diferente de
zero. Emita uma mensagem de alerta ao usuário se for zero.
3) Um banco concede empréstimo a seus clientes no valor máximo de 30% do valor do seu salário
líquido. Receba o valor do salário bruto, o valor dos descontos e o valor do possível empréstimo de
um cliente, em seguida avise se ele poderá ou não fazer o empréstimo.
4) Escreva um programa que a partir de 3 notas fornecidas de um aluno, informe se ele foi aprovado,
ficou de recuperação ou foi reprovado. A média de aprovação é >= 7.0; a média de recuperação
é >= 5.0 e < 7.0; e a média do reprovado é < 5.0
5) Faça um programa que receba do usuário o nome de um mês. Exiba o número equivalente deste
mês. Caso seja informado um mês que não existe, deve ser informado ao usuário.
6) Faça um programa que verifique a validade de uma data de aniversário (solicite apenas o número
do dia e do mês). Além de falar se a data está ok, informe também o nome do mês. Dica: meses
com 30 dias: abril, junho, setembro e novembro.
7) Faça um programa que receba três valores inteiros, e exiba estes números em ordem crescente.
8) Faça um programa que solicite o nome e a idade de 2 pessoas. Em seguida exiba o nome da
pessoa mais velha e o nome da pessoa mais nova.
9) Escreva um programa que receba 2 horários e exiba a diferença entre eles em segundos.
10) Elaborar um programa que verifique quem entre duas pessoas faz aniversário primeiro. Exiba
o nome do primeiro aniversariante considerando que estamos no dia 1 de janeiro. Use como
entrada o nome, o dia e o mês de nascimento de cada pessoa.
11) As Organizações Tabajara resolveram dar um aumento de salário aos seus colaboradores e lhe
contrataram para desenvolver o programa que calculará os reajustes.
Faça um programa que recebe o salário de um colaborador e o reajuste segundo o seguinte critério,
baseado no salário atual:
 Salários até R$ 280,00 (incluindo) : aumento de 20%;
 Salários entre R$ 280,00 e R$ 700,00 : aumento de 15%;
 Salários entre R$ 700,00 e R$ 1500,00 : aumento de 10%;
 Salários de R$ 1500,00 em diante : aumento de 5% Após o aumento ser realizado, informe
na tela: O salário antes do reajuste;
 O percentual de aumento aplicado;
 O valor do aumento;
 O novo salário, após o aumento.

______________________________________________________________________________________________
12) Faça um programa que calcule as raízes de uma equação do segundo grau, na forma ax2 + bx
+ c. O programa deverá pedir os valores de a, b e c e fazer as consistências, informando ao usuário
nas seguintes situações:
a) Se o usuário informar o valor de A igual a zero, a equação não é do segundo grau e o
programa não deve fazer pedir os demais valores, sendo encerrado;
b) Se o delta calculado for negativo, a equação não possui raízes reais. Informe ao usuário
e encerre o programa;
c) Se o delta calculado for igual a zero a equação possui apenas uma raiz real; informe-a ao
usuário;
d) Se o delta for positivo, a equação possui duas raízes reais; informe-as ao usuário;
13) Chaves foi ao Paraguai e realizou a compra de alguns artigos lá. Com base na tabela abaixo
informe a porcentagem do imposto a ser pago e o valor total.
VALOR IMPOSTO %
Até R$10 3%
De R$10,01 a
R$99,99
5%
De R$100 a
R$299,99
10%
Acima de R$300 30%
14) Faça um programa onde o operador de distribuição dos correios digite o código de destino
impresso nas caixas e o sistema exibe o local para onde a encomenda se destina.
CÓDIGO
DESTINO
DESTINO
1 a 5 BRASIL
6 A 9 EUA
10, 11 e 12 RÚSSIA
De 15 a 20 ou de
30 a 35
SUÍCA
13 a 14 AFEGANISTÃO
21 a 29 FRANÇA
15) Um posto está vendendo combustíveis conforme os seguintes descontos:
Álcool:

______________________________________________________________________________________________
a. até 20 litros, desconto de 3% por litro
b. acima de 20 litros, desconto de 5% por litro
Gasolina:
c. até 20 litros, desconto de 4% por litro
d. acima de 20 litros, desconto de 6% por litro
Escreva um algoritmo que leia o número de litros vendidos, o tipo de combustível (codificado da
seguinte forma: A-álcool, G- gasolina), calcule e imprima o valor a ser pago pelo cliente sabendo-
se que o preço do litro da gasolina é R$ 2,50 o preço do litro do álcool é R$ 1,90.
4.2 Laços de Repetição
Frequentemente em aplicações é preciso repetir a execução de um bloco de códigos do
programa até que determinada condição seja verdadeira, ou senão até uma quantidade de vezes
seja satisfeita. Para que essas repetições sejam possíveis, utiliza-se os laços de repetições.
A condição a ser analisada para a execução do laço de repetição deverá retornar um valor
booleano. Podendo acontecer de maneira pré definida como acontece no laço for, ou com o final
aberto como ocorre com os laços while e do-while.
4.2.1 Comando While
Esta instrução é usada quando não se sabe quantas vezes um determinado bloco de
instruções precisa ser repetido. Com ele, a execução das instruções vai continuar até que uma
condição seja verdadeira.
Na estrutura while pode ter uma condição de termino definida já no início ou não.
Necessariamente ele testa a condição e se caso for verdadeiro executa o bloco, caso seja falso ele
vai para a próxima instrução fora do laço.
While (Condição)
{
Comandos;
}
Uma condição deve ser qualquer expressão valida que tenha como resultado true ou false.
Somente se a condição for verdadeira o corpo do laço de repetição, com seus respectivos
comandos, serão executados. Portanto, o conteúdo será repetido até que esta condição não seja
mais verdadeira.
Exemplo:
Pode ocorrer casos em que o laço de repetição while pode não ser executado. Isso pode
ocorrer quando, na primeira verificação da condição, ela for falsa. Neste cenário, o programa
simplesmente irá “pular” para a execução da próxima instrução após o laço.
Exercícios:
1) Escreva um aplicativo em Java que mostra todos os números ímpares de 1 até 100.

______________________________________________________________________________________________
2) Escreva um programa que pergunte ao usuário quantos alunos tem na sala dele.
Em seguida, através de um laço while, peça ao usuário para que entre com as notas de todos os
alunos da sala, um por vez. Por fim, o programa deve mostrar a média, aritmética, da turma.
3) Escreva um programa que pergunta um número ao usuário, e mostra sua tabuada completa (de
1 até 10).
4) Faça um programa que, para um número indeterminado de pessoas: leia a idade de cada uma,
sendo que a idade 0 (zero) indica o fim da leitura e não deve ser considerada. A seguir calcule:
 o número de pessoas;
 a idade média do grupo;
 a menor idade e a maior idade.
5) Crie um programa simulando o acesso a uma conta bancária, onde ele tenha 3 chances para
acertar a senha. Se na quarta vez ele errar, o programa exibe a mensagem de “conta bloqueada”
e, se ele digitar a senha correta exiba a mensagem “bem vindo usuário”.
4.2.2 Comando do-while
Com a estrutura do while, as instruções que estiverem dentro do bloco do{} serão
executadas e, logo depois, a condição será testada. Com do while, mesmo que a condição nunca
seja verdadeira, as instruções sempre serão executadas pelo menos uma vez, pois o teste da
condição ocorre no final do laço.
do{
instruções
}while(condição);
O comando do-while deve ser usado quando não se sabe exatamente quantas vezes o
laço deve se repetir, e o bloco de comandos deve ser executado pelo menos uma vez.
Exemplos:

______________________________________________________________________________________________
Exercícios:
1) Faça um programa que leia dois números inteiros, o primeiro é o valor inicial de um contador, e
o segundo é o valor final do contador (testar se o valor inicial fornecido é inferior ao valor final).
Usando o comando do-while, escreva na tela uma contagem que comece no primeiro número lido,
escreva os números seguintes colocando sempre apenas um número em cada nova linha da tela,
e terminando a contagem quando chegar ao valor final indicado.
2) Apresentar na tela a tabuada de multiplicação dos números de 1 até 10. O programa deve exibir
o resultado das multiplicações de 1x1, 1x2, ... até 1x10, pedir para o usuário pressionar uma tecla,
e recomeçar com 2x1, 2x2, ... até 2x10, pedir novamente para teclar algo e seguir assim
sucessivamente até chegar em 10x10. Use o comando do-while.
3) Faça um programa para ler 10 valores reais, armazenando estes valores em uma tabela (vetor).
Exibir na tela a média simples dos 10 valores lidos. Faça uma primeira versão deste programa
usando apenas comandos while (faça um laço de leitura de dados e um outro laço para o cálculo
da média). Faça uma segunda versão deste programa usando apenas comandos do-while.
Exemplo de tela de saída:
4.2.3 Comando for
O comando for permite que um certo trecho de programa seja executado um determinado
número de vezes. O laço for pode receber três argumentos, separados por ponto e vírgula e
executa as instruções dentro do bloco {}. Incremente a variável de teste, enquanto a condição for
verdadeira.

______________________________________________________________________________________________
Os argumentos são opcionais. Se o teste lógico estiver ausente, e assumido o padrão true,
você pode inicializar mais uma variável, desde que seja do mesmo tipo. O terceiro argumento será
executado ao fim de cada laço e pode ter mais de uma instrução.
O comando for deve ser usado sempre que se souber exatamente quantas vezes o laço
deve ser repetido.
A forma do comando for é a seguinte:
for (comandos de inicialização;condição de teste; incremento/decremento )
{
// comandos a serem repetidos
// comandos a serem repetidos
}
// comandos após o 'for'
Exemplos:
No exemplo a seguir, é testado a condição e após a execução das instruções incrementa x.
No próximo exemplo não apresenta o primeiro e terceiro argumentos, o incremento é feito dentro
do laço for.
Exercícios:
1) Exiba todos os números pares de 10 a 200.
2) Exiba todos os números ímpares existentes entre dois números informados pelo usuário. Dica:
use o operador % para calcular o resto da divisão entre dois números.
3) Escrever um algoritmo que lê 10 valores, um de cada vez, e conta quantos deles estão no inter-
valo [10,20] e quantos deles estão fora do intervalo, escrevendo estas informações.
4.2.4 Comandos de desvio
Os laços em Java, assim como a maioria das linguagens de programação, possuem dois
comandos de desvios: break e continue. Estes comandos funcionam com todos os comandos de
repetição.
O comando break encerra o laço no ponto em que for executado.

______________________________________________________________________________________________
Exemplo:
O comando continue desvia o fluxo para o início do laço.
Exemplo:
Obs: Deve-se evitar o comando continue e break, pois seu uso dificulta a legibilidade do código.
O código a seguir cria um laço de repetição entre 0 e 11, através do comando
if(i%2==1)continue, seleciona os valores impares para não serem impressos e finaliza a execução
do comando if(i==12)break.
Exercícios:
1) Crie um programa que se inicia em 1 e deve terminar em mil (1.000), mas dentro desta estrutura
há uma condição: se a variável for igual a 10 ela sai da estrutura de repetição.
2) Uma academia deseja fazer um senso entre seus clientes para descobrir o mais alto, o mais
baixo, o mais gordo e o mais magro, para isto você deve fazer um programa que pergunte a cada
um dos clientes da academia seu código, sua altura e seu peso. O final da digitação de dados deve
ser dado quando o usuário digitar 0 (zero) no campo código. Ao encerrar o programa também de-
vem ser informados os códigos e valores do cliente mais alto, do mais baixo, do mais gordo e do
mais magro, além da média das alturas e dos pesos dos clientes

______________________________________________________________________________________________
3) Escreva um programa contendo uma estrutura de repetição que irá contar de 1 a 100, mas
sempre que o número não for múltiplo de 5, o código para apresentar o número na tela será
ignorado e a repetição continuará com o número seguinte, ou seja, apenas os múltiplos de 5 entre
1 e 100 aparecem na tela.
Exercícios:
1) Faça um programa que exiba na tela todos os números entre 50 (inclusive) e 200 (inclusive).
Pode ser utilizado qualquer estrutura de repetição.
2) Faça um programa que exiba na tela todos os números pares existentes entre 1 e 100.
3) Faça um programa que exiba todos os números divisíveis por 5 no intervalo de 1 a 500.
4) Faça um programa que mostre a quantidade de números divisíveis por 3 encontrados no intervalo
de 1 a 1000.
5) Faça um programa que exiba na tela todos os números primos encontrados no intervalo entre 1
e 2000.
6) Faça um programa que solicite ao usuário um número inteiro. Analise este número e informe se
o mesmo par ou ímpar.
7) Faça um programa que solicite ao usuário um número inteiro. Analise este número e informe se
o mesmo primo ou não.
8) Faça um programa que solicite ao usuário um número inteiro. Exiba a raiz quadrada deste
número. Evite utilizar a classe Math ou outra classe ou método especializado nesta operação.
9) Escreva um programa que mostre os números impares e divisíveis por 3 e 5 encontrados no
intervalo de 1 a 1000.
10) Elaborar um programa de solicite ao usuário diversos números inteiros. O usuário irá parar de
informar números inteiros, quando digitar 0 (zero). No final deverá ser exibido a soma dos números
informados.
11) Dado um número inteiro positivo n, imprimir os n primeiros naturais ímpares.
Exemplo: Para n=4 a saída deverá ser 1,3,5,7.
12) Dado o número n de alunos de uma Programação II e suas notas da primeira prova, determinar
a maior e a menor nota obtidas por essa turma (Nota máxima = 100 e nota mínima = 0).
13) Dado um inteiro não-negativo n, informado pelo usuário, determinar n!
14) Dado um inteiro não-negativo n, informado pelo usuário, determinar se este número é primo.
15) Crie um programa que o usuário entre com 2 números, faça a soma entre eles e mostre o

______________________________________________________________________________________________
resultado dizendo se o número é par ou ímpar.
16) Um banco concede empréstimo a seus clientes no valor máximo de 30% do valor do seu salário
líquido. Receba o valor do salário bruto, o valor dos descontos e o valor do possível empréstimo de
um cliente, em seguida avise se ele poderá ou não fazer o empréstimo.
17) Crie um programa de contagem crescente, onde não importe a ordem que os valores sejam
digitados. Ex: digitou 1 e 5: o sistema conta de 1 até 5; digitou 5 e 1: o sistema conta de 1 até 5;
18) Faça um programa que some dois valores digitados pelo usuário e, enquanto ele desejar
continuar realizando operações, o sistema vai repetindo. Ex: pressione (1) para continuar ou
qualquer tecla para sair;
19) Faça um programa que exiba os números ímpares de um intervalo citado pelo usuário;
20) Crie um programa que exiba na tela os números múltiplos de 3 entre 0 e 20; use o resto da
divisão por 3;
4.3 Recursividade
A recursividade trabalha de forma similar a um laço de repetição, na verdade tudo que
fazemos em laço, pode ser feito em recursividade. A recursividade é nada mais nada menos do que
uma função dentro da outra e ela deve ser pensada como uma pilha (estrutura de dados onde o
último a entrar, deve ser o primeiro a sair). A estrutura dela consiste em descer até a base fazendo
os cálculos ou rotinas de cada instrução, e então da base até o topo da pilha são empilhados os
resultados de cada instrução e no final o topo contém o resultado que é retornado. Na figura a
seguir, temos um exemplo que é frequentemente usado para explicar a recursividade, podemos
encontrar em diversos livros didáticos, porque é um dos mais fáceis para se entender, estou falando
do fatorial.
Exemplo: Desenvolver um método recursivo para descobrir o fatorial de um número “N”. Supondo
que o N seja igual a 4.
Obs: O “fatorial(4)” só pode ser descoberto depois que o “fatorial(3)” for descoberto, que por sua
vez só poderá ser descoberto depois do fatorial(2) e assim por diante. Por isso vai do topo até a
base, e depois vai empilhando os resultados da base até o topo.

______________________________________________________________________________________________
Agora uma ilustração com os valores para fixar o conceito:
O conceito de recursividade como podemos ver anteriormente não é tão difícil, é claro que
na hora da programação é sempre recomendável atenção, organização e fazer o tão “chato”, mas
eficiente teste de mesa, ou seja, fazer o máximo para dar certo, pois a hora de errar é quando
estiver treinando, fazendo exercícios e não deixar para errar quando estiver em um mercado de
trabalho, onde um projeto pode ter mais de 10000 linhas.
A seguir a apresentado a implementação de uma classe Java com o exemplo de
recursividade:
Essa é a função recursiva do fatorial em JAVA. Agora falta implementar um método principal para
testar esta função, para facilitar esse método será criado dentro da classe que já foi criada. Como
a seguir:

______________________________________________________________________________________________
Estruturas de dados como o próprio nome sugere, é um modo particular de armazenamento
e organização de dados em um computador de modo que estes possam ser usados de forma
eficiente. Sendo um pouco mais abstrato, imagine como seria o mundo real se não existisse o
conceito de “Fila”, tudo seria um caos sem nenhuma ordem ou organização e o mesmo aplica-se
ao mundo digital.
O objetivo não é entrar em detalhes sobre explicações teóricas, mas sim práticas, algumas
estruturas exigem um pouco mais de foco do que outras para serem entendidas, devido ao seu
grau de complexidade. Sendo assim, nem todas as estruturas de dados serão tratadas neste
momento.
5.1 Vetores
Vetores ou arrays são estruturas de dados que armazenam usualmente uma quantidade fixa
de dados de um certo tipo; por esta razão, também são conhecidos como estruturas homogêneas
de dados.
Internamente, um vetor/array armazena diversos valores, cada um associado a um número
que se refere à posição de armazenamento, e é conhecido como índice. Os vetores são estruturas
indexadas, em que cada valor que pode ser armazenado em uma certa posição (índice) é chamado
de elemento do vetor.
Cada elemento do vetor/array pode ser utilizado individualmente de forma direta, ou seja,
pode ser lido ou escrito diretamente, sem nenhuma regra ou ordem preestabelecida, fazendo dos
vetores estruturas de dados de acesso aleatório. O número de posições de um vetor/array
corresponde ao tamanho que ele tem assim, um vetor de tamanho 10 tem esse número de
elementos, isto é, pode armazenar até dez elementos distintos. Os diferentes elementos de um
vetor são distinguidos unicamente pela posição que ocupam no vetor. Cada posição de um vetor é
unicamente identificada por um valor inteiro positivo, linear e sequencialmente numerado.
a[i], corresponde ao i-ésimo elemento do vetor a, sendo que o valor da variável i deve
pertencer ao intervalo dos índices do vetor: ((i >= 0) && (i < a.length)).
O Java como as linguagens C e C++ são linguagens com vetores zero-based, isto é, as
posições do vetor iniciam a numeração a partir do valor 0, portanto, um vetor de tamanho 10 teria
índices iniciados em 0 prosseguindo até o 9.
Na declaração de vetores deverão ser fornecidas três informações:
1) O nome do vetor,
2) O número de posições do vetor (seu tamanho), e
3) O tipo de dado que será armazenado no vetor.
Declaração de um vetor para "inteiros", de nome "vetor", em Java:
int vetor[]; // declaração do vetor
Podemos notar que as declarações de vetores são semelhantes às declarações de variáveis,
os elementos sintáticos que diferenciam as variáveis do tipo vetor das outras variáveis são
Estrutura de dados 5

______________________________________________________________________________________________
os colchetes. Embora declarado, o vetor não está pronto para uso, sendo necessário reservar
espaço para seus elementos (uma operação de alocação de memória).
vetor = new int[10]; // alocação de espaço para vetor
Na alocação de espaço, não repetimos os colchetes e utilizamos o operador new (uma palavra
reservada da linguagem) para reservar espaço para 10 (dez) elementos do tipo int.
As duas declarações podem ser combinadas em uma única, mais compacta:
a) declarando um vetor para armazenar 10 números inteiros
int nro = new int[10];
b) declarando um vetor para armazenar 10 valores do tipo real (ou monetários)
double salario = new double[10];
c) declarando um vetor para armazenar as letras do alfabeto
char alfabeto = new char[26];
Obs: Um vetor/array de caracteres é o mesmo que um dado do tipo String.
d) declarando um vetor para armazenar o nome dos 12 meses do ano
String mes = new String[12];
Exemplo:
Representação interna:
V[0] V[1] V[2] V[3] V[4] V[5] V[6] V[7] V[8] V[9]
0 1 2 3 4 5 6 7 8 9

______________________________________________________________________________________________
Aplicação Java exemplificando a utilização do tipo de dados vetor:

______________________________________________________________________________________________
Resultado da execução do programa:
A classe Math contém diversos métodos estáticos (não exige uma instância da classe para
utilização) destinados a operações numéricas, citando:
 static double random(): retorna um valor, do tipo double, "aleatório" no intervalo de 0.0
até 1.0;
 static long round(double): retorna um número do tipo long mais próximo (ou
arredondado) do valor do tipo double do argumento.
A utilização combinada dos métodos "random" e "round" possibilita a geração de números
aleatórios, como por exemplo:
a[i] = (int)Math.round(Math.random() * 10); // gera um número inteiro aleatório no intervalo
de 0 até 10
Entendendo a atribuição:
 Math.random() retorna um número aleatório, do tipo double, no intervalo de 0.0 até 1.0;
 Math.random() * 10 tem como resultado um número no intervalo de 0.0 até 10.0;
 Math.round(Math.random() * 10) retorna um número do tipo long mais próximo (ou
arredondado) do resultado;
 (int) faz a conversão (ou coerção, em inglês "cast") do tipo long para o tipo int.

______________________________________________________________________________________________
A aplicação Java a seguir implementa o método de ordenação por seleção ou Selection Sort:
O resultado da execução deste programa será:

______________________________________________________________________________________________
5.1.1 Inicialização de vetores
Java permite a inicialização de vetores no momento da declaração, por exemplo:
String nome[] = {"Juca Bala", "Maria das Dores", "Pedro Bó"};
Isso significa que nome[0] terá o valor Juca Bala, nome[1] terá o valor Maria das Dores, nome[2]
terá o valor Pedro Bó. Nota-se que não é necessário indicar o tamanho do vetor e também fazer a
alocação de espaço através do operador new. O tamanho do vetor será conhecido através do
campo como mostra a aplicação a seguir:
A inicialização de vetores na declaração também permite indexar valores predefinidos como no
caso das informações relacionadas aos meses do ano. Conforme o exemplo a seguir:

______________________________________________________________________________________________
5.1.2 Estrutura for aprimorada
Utilizada para percorrer os elementos de um vetor sem utilizar um contador:
for (parâmetro: nomeDoVetor) {
instrução;
}
Onde "parâmetro" tem duas partes:
a) um tipo (deve corresponder ao tipo dos elementos no vetor), e
b) um identificador, por exemplo: int nro.
O identificador representa os valores sucessivos do vetor nas sucessivas iterações da
instrução for. Veja um exemplo na próxima aplicação Java:
O resultado da execução do programa é a seguinte:
Exercícios:
Nesta lista de exercícios em alguns casos é solicitado um número aleatório. Para gerar este número
utilize a função rand(). Por exemplo para gerar um número aleatório entre 0 e 9, deve ser construído

______________________________________________________________________________________________
o seguinte comando: rand() % 100
1) Criar um vetor A com 5 elementos inteiros, gerados de forma aleatória. Construir um vetor B de
mesmo tipo e tamanho e com os "mesmos" elementos do vetor A, ou seja, B[i] = A[i]. Exibir os dois
vetores na tela.
mesmo tipo e tamanho, sendo que cada elemento do vetor B deverá ser o quadrado do respectivo
elemento de A, ou seja:
B[i] = A[i] * A[I]. Exibir os dois vetores na tela.
mesmo tamanho, sendo que cada elemento do vetor B deverá ser a raiz quadrada do respectivo
elemento de A, ou seja: B[i] = sqrt(A[i]). Exibir os dois vetores na tela.
mesmo tipo e tamanho, sendo que cada elemento do vetor B deverá ser o respectivo elemento de
A multiplicado por sua posição (ou índice), ou seja: B[i] = A[i] * i. Exibir os dois vetores na tela.
5) Criar dois vetores A e B cada um com 10 elementos inteiros, gerados de forma aleatória.
Construir um vetor C, onde cada elemento de C é a soma dos respectivos elementos em A e B, ou
seja: C[i] = A[i] + B[i]. Exibir os dois vetores na tela.
mesmo tipo e tamanho, sendo que cada elemento do vetor B deverá ser o resto da divisão do
respectivo elemento de A por 2 (dois), ou seja: B[i] := A[i] % 2. Exiba os dois vetores na tela.
7) Faça um programa que leia 5 nomes e notas de uma turma, Calcular e exibir a média a média
das notas da turma e em seguida exibe a relação de nomes cuja nota é superior a esta média.
8) Faça um programa que leia um conjunto de notas, cuja quantidade seja determinada pelo
usuário. Calcule a média de todas elas. Exiba o conjunto das notas maiores do que a média
calculada. Em seguida, de forma agrupada, exiba o outro conjunto de notas (menores do que a
média).
9) Faça um programa que leia um conjunto de salários, sendo que o usuário determinará a
quantidade de salários informados. Após toda a entrada ter sido realizada, leia o valor de um
reajuste. Em seguida exiba todos os salários já reajustados.
10) Faça um programa de consulta de telefones a partir de um nome informado. Primeiro leia nomes
de pessoas com seus respectivos telefones, sendo a quantidade determinada pelo usuário. Em
seguida pergunte ao usuário qual o nome que ele deseja consultar o telefone. Após sua resposta,
exiba o telefone da pessoa procurada. Informe também se o nome é inexistente no banco de dados.
11) Solicite ao usuário que informe uma frase. Posteriormente descubra quantos caracteres existem
na frase e quantos destes são vogais. Exiba a frase digitada substituindo as vogais por '#', e

______________________________________________________________________________________________
apresente a quantidade de caracteres e o número de vogais encontradas.
12) Solicite ao usuário que informe uma sequência de caracteres qualquer. Posteriormente
descubra quantos caracteres existem na sequência e quantos destes são vogais. Em seguida
construa um array contendo somente as vogais. Exiba a sequência de caracteres digitados ao
contrário, e em seguida a lista de vogais.
5.2 Matrizes
A linguagem Java não fornece vetores multidimensionais, mas como um vetor pode ser
declarado e ter qualquer tipo de base, é possível criar vetores de vetores (de vetores etc.),
alcançando assim o mesmo efeito.
Nos exemplos anteriores, foram declarados apenas um bloco de variáveis. Diz-se que esse
vetor é unidimensional, pois é somente um bloco.
Para se ter uma noção de dimensão, deve se observar o array/vetor apenas como uma linha.
Por exemplo, declara-se um array unidimensional com 5 notas de Matemática:
int[] notas = {8.0 , 7.5, 8.5 , 9.0 , 8.0};
Essa nota pode ser representada por uma matriz 1x5, ou seja, uma linha e 5 colunas:
8.0 7.5 8.5 9.0 8.0
A seguir é demonstrado as notas em Física, abaixo das de Matemática. Tem-se uma matriz 2x5, ou
seja, uma matriz de duas linhas e 5 colunas:
8.0 7.5 8.5 9.0 8.0
8.9 9.0 8.6 8.4 8.0
Agora é representado as notas de Química, a seguir as notas de Física.
Tem-se uma matriz 3x5, ou seja, uma matriz de três linhas e 5 colunas:
8.0 7.5 8.5 9.0 8.0
8.9 9.0 8.6 8.4 8.0
6.8 7.1 7.0 7.6 6.5
A sintaxe é exatamente a mesma do array normal, a diferença está no número de colchetes '[]' que
se usa.
No caso, usa-se um par para cada dimensão.
Por exemplo, para declarar a matriz 2x5 do exemplo anterior:
float[][] notas = new float[2][5];
ou
float[][] notas = { {8.0, 7.5, 8.5, 9.0, 8.0 }, {8.9, 9.0, 8.6, 8.4, 8.0 } };

______________________________________________________________________________________________
Para declarar a matriz 3x5 do exemplo anterior:
float[][] notas = new float[3][5];
ou
float[][] notas = { {8.0, 7.5, 8.5, 9.0, 8.0}, {8.9, 9.0, 8.6, 8.4, 8.0}, {6.8, 7.1, 7.0, 7.6, 6.5 } };
Note que notas[0] se refere ao array de notas de Matemática.
Note que notas[1] se refere ao array de notas de Física.
Note que notas[2] se refere ao array de notas de Química.
Por exemplo: qual foi a quarta nota de Física do aluno?
Ora, o vetor de Física é notas[1], e a quarta nota é o elemento [3] desse array.
Então a quarta nota de Física do aluno está armazenada em: nota[1][3], que é 8.4
Exemplos:
1) Criar um aplicativo em Java que peça ao usuário para preencher uma matriz 3x3 com valores
inteiros e depois exiba essa matriz.
Obs: A grande novidade, nesse tipo de estrutura são os laços for aninhados, ou seja, um dentro
do outro.
Primeiro cria-se um laço que vai percorrer todas as linhas da matriz. Cada linha deve ser vista como
um vetor de 3 elementos. Dentro de cada linha, é necessário percorrer cada elemento do vetor/array
e fornecer seu valor. Isso é feito através de outro laço for, que ficará responsável pelas 'colunas',
formando os laços aninhados.
Para imprimir, o esquema é exatamente o mesmo. Imprime-se linha por linha, e em cada linha,
imprime-se coluna por coluna.

______________________________________________________________________________________________
2) Crie um aplicativo em Java que peça ao usuário para preencher uma matriz 3x2 com valores
inteiros e depois exiba essa matriz.
No exemplo anterior, o número de linhas era igual ao número de colunas, da matriz. Agora será
visto um exemplo diferente, para fixar o conhecimento em arrays multidimensionais.
Como dito no começo, uma matriz, vetor/array multidimensional ou vetor multidimensional nada
mais é que um conjunto de arrays ou conjunto de vetores, array de arrays.
Quando é feito: int[5] para declarar um array de inteiros, está se declarando 5 variáveis do tipo
inteiro.
Quando é feito: int[10][5], está se declarando 10 arrays, e em cada array desses existem 5 inteiros,
ou seja, 10 arrays do tipo do exemplo anterior. Logo, o tamanho desse array – length – é 10. Esta
informação pode ser obtida com o comando: array.length
Assim, uma matriz 3x2 tem tamanho 3.
Uma 4x3 tem tamanho 4, uma 10x123123 tem tamanho 10 etc.
Ou seja, o length de arrays multidimensionais é o número de linhas.
Fazendo uso desse fato nos laços:
Exercícios:
1) Escreva um programa que declara e constrói uma matriz 3x3, de inteiros. Use um laço for para
preencher os elementos da matriz usando valores aleatórios de 0 até 9 (incluindo os valores 0 e
10). Para finalizar, percorra os elementos da matriz e exiba seus valores. A saída do programa

______________________________________________________________________________________________
deverá ser parecida com:
3 5 5
5 3 8
1 0 9
2) Escreva um programa que gera uma matriz 4x4, de números inteiros. Posteriormente percorrer
todos os elementos desta matriz duas vezes e exibi-los na ordem original e invertidos (somente na
exibição, ou seja, não é necessário alterar a ordem dos elementos na matriz).
3) Escreva um programa que gere uma matriz 4x3, de números inteiros. Posteriormente percorra
todos os elementos desta matriz a fim exibir a soma de seus valores. O programa deverá exibir
uma saída com a mensagem:
A soma dos valores da matriz é: valor resultante da soma
4) Escreva um programa que declara e constrói uma matriz 5x5, de inteiros, gerados
aleatoriamente. Posteriormente inverta a ordem dos elementos da matriz, usando apenas uma
variável temporária, ou seja, não é permitido usar nenhum método disponível. Sua saída deverá
ser algo como:
Original
1 3 5 6 7
7 3 9 2 4
9 5 1 3 0
2 1 9 5 8
5 8 1 3 0
Invertido
7 6 5 3 1
4 2 9 3 7
0 3 1 5 9
8 5 9 1 2
0 3 1 8 5
aleatoriamente, no intervalo de 0 a 100. Posteriormente selecione todos os números primos desta
matriz e armazene-os em um vetor. Exiba a matriz gerada e o vetor contendo os números primos.
aleatoriamente, no intervalo de 0 a 10. Posteriormente obtenha a soma da diagonal da matriz.
Exiba a matriz gerada e o valor resultante da soma da diagonal.
Ex:
2 3 4 5 6
9 7 5 3 1
1 3 5 7 9

______________________________________________________________________________________________
8 6 4 2 3
7 0 5 2 9
Soma da diagonal: 25
aleatoriamente, no intervalo de 0 a 9. Posteriormente obtenha a soma da diagonal inversa da matriz.
Exiba a matriz gerada e o valor resultante da soma da diagonal inversa.
Ex:
2 3 4 5 6 1 9
9 7 5 3 1 2 4
1 3 5 7 9 2 8
8 6 4 2 3 1 7
7 0 5 2 9 8 1
5 6 4 2 3 1 7
3 4 5 2 9 8 1
Soma da diagonal inversa: 36
8) Escreva um programa que declara e constrói uma matriz 5x5, de inteiros pares, gerados
aleatoriamente, no intervalo de 10 a 99. Exiba a matriz gerada.
9) Escreva um programa que declara e constrói uma matriz 4x4, de inteiros primos, gerados
aleatoriamente, no intervalo de 10 a 99. Exiba a matriz gerada.
10) Escreva um programa que declara e constrói uma matriz 6x6, de inteiros impares e divisíveis
por 3 e 7, gerados aleatoriamente, no intervalo de 100 a 999. Exiba a matriz gerada, o menor e
maior elemento sorteado.
6.1 Introdução
O termo Programação Orientada a Objetos foi criado por Alan Kay, autor da linguagem de
programação Smalltalk. Mas mesmo antes da criação do Smalltalk, algumas das ideias da POO já
eram aplicadas, sendo que a primeira linguagem a realmente utilizar estas ideias foi a linguagem
Simula 67, criada por Ole Johan Dahl e Kristen Nygaard em 1967. Note que este paradigma de
programação já é bastante antigo, mas só agora vem sendo aceito realmente nas grandes
empresas de desenvolvimento de Software. Alguns exemplos de linguagens modernas utilizadas
por grandes empresas em todo o mundo que adotaram essas ideias: Java, C#, C++, Object Pascal
(Delphi), Ruby, Python, Lisp, ...
A maioria delas adota as ideias parcialmente, dando espaço para o antigo modelo procedural
de programação, como acontece no C++ por exemplo, onde temos a possibilidade de usar POO,
mas a linguagem não força o programador a adotar este paradigma de programação, sendo ainda
Programação Orientada a Objetos 6

______________________________________________________________________________________________
possível programar da forma procedural tradicional. Este tipo de linguagem segue a ideia de utilizar
uma linguagem previamente existente como base e adicionar novas funcionalidades a ela.
Outras são mais "puras", sendo construídas do zero focando-se sempre nas ideias por trás
da orientação a objetos como é o caso das linguagens Smalltalk, Self e IO, onde TUDO é orientado
a objetos.
6.2 Ideias básicas da POO
A POO foi criada para tentar aproximar o mundo real do mundo virtual: a ideia fundamental
é tentar simular o mundo real dentro do computador. Para isso, nada mais natural do que utilizar
Objetos, afinal, nosso mundo é composto de objetos.
Na POO o programador é responsável por moldar o mundo dos objetos, e explicar para estes
objetos como eles devem interagir entre si. Os objetos "conversam" uns com os outros através do
envio de mensagens, e o papel principal do programador é especificar quais serão as mensagens
que cada objeto pode receber, e também qual a ação que aquele objeto deve realizar ao receber
aquela mensagem em específico.
Uma mensagem é um pequeno texto que os objetos conseguem entender e, por questões
técnicas, não pode conter espaços. Junto com algumas dessas mensagens ainda é possível passar
algumas informações para o objeto (parâmetros), dessa forma, dois objetos conseguem trocar
informações entre si facilmente.
A seguir é apresentado um exemplo prático para melhor elucidar este conceito. Um
programador está desenvolvendo um software para uma locadora e essa locadora tem diversos
clientes. Como tenta-se modelar um sistema baseado no sistema real, nada mais obvio do que
existirem objetos do tipo Clientes dentro do nosso programa, e esses Clientes dentro do nosso
programa nada mais serão do que objetos que "simulam" as características e ações no mundo
virtual que um cliente pode realizar no mundo real.
Mais a diante será apresentado um exemplo mais detalhada, mas antes é necessário
especificar mais alguns conceitos.
6.3 Classes
Uma classe é uma abstração que define um tipo de objeto e o que objetos deste determinado
tipo tem dentro deles (seus atributos) e também define que tipo de ações esse tipo de objeto é
capaz de realizar (métodos).
É importante salientar que uma classe não representa nenhum objeto em particular, é
apenas um modelo.
A seguir é como criar uma classe Java, representando a entidade conta corrente. Uma
classe deve definir entre abre e fecha chaves ({ e }) somente atributos, métodos e códigos de
inicialização.
Exemplo:
package poo;
/*Declaração da classe ContaCorrente
* O nome da classe deve ser igual ao dome do arquivo que a contém.
* O nome de uma classe deve iniciar com letra maiúcula*/
public class ContaCorrente {
/*Declarando os atributos*/
int conta;
int agencia;
double saldo;

______________________________________________________________________________________________
String titular;
/*Métodos de acesso e modificadores =>
* (Não é nescessário explicar por enquanto.)*/
public int getConta() {
return conta;
}
public void setConta(int conta) {
this.conta = conta;
}
public int getAgencia() {
return agencia;
}
public void setAgencia(int agencia) {
this.agencia = agencia;
}
public double getSaldo() {
return saldo;
}
public void setSaldo(double saldo) {
this.saldo = saldo;
}
public String getTitular() {
return titular;
}
public void setTitular(String nome) {
this.titular = nome;
}
}//Nenhuma linha de código de ser definida depois deste simbolo de fecha chaves.
A classe acima representa uma conta corrente com seus atributos métodos de acesso
(getXxx()) e métodos modificadores (setXxx()). Os métodos de acesso e modificadores devem ser
usados pelo programador, para acessar ou alterar os atributos, sem fazê-lo de forma direta. Apesar
de ser possível realizar o acesso de forma direta, as boas práticas e o conceito de encapsulamento
(a ser estudado mais tarde), um atributo deve sempre ser acessado por método de acesso ou
modificador.
A classe ContaCorrente representa a entidade conta corrente, assim com uma tabela no
banco de dados, onde definimos suas colunas (atributos) para receberem seus registros.
Em um método modificador podemos definir regras de validação para os atributos, evitando
que um valor inválido seja atribuído a um atributo. Por exemplo: uma agencia não pode ser
inicializada com um parâmetro com valor menor ou igual a 0 (zero).
6.4 Objetos
Objetos são representações das classes. Para criar um objeto deve ser utilizado o operador
new, conforme a representação a seguir:
Classe nomeDoObjeto = new Classe();
A seguir um exemplo de objetos sendo criados.

______________________________________________________________________________________________
Exemplo:
package poo;
public class Principal {
public static void main(String args[]){
ContaCorrente conta1 = new ContaCorrente(); //Crando o objeto conta1
}
}
Este programa representa apenas como criar um objeto. Se for executado não será exibido
nenhum resultado na tela, já que que o objetivo aqui é apenas apresentar a sintaxe usada para a
criação de objetos.
6.5 Mensagens
Para se fazer uso de um objeto recém-criado, é necessário o envio de mensagens, que é a
forma de comunicação entre objetos. Para tanto é necessário criar um objeto, identificar o método
a ser executado, e se for o caso, identificar os parâmetros que o método recebe ou retorna. Para
enviar uma mensagem a um objeto utiliza-se o seguinte comando.
conta1.setConta(456789);
Neste exemplo está sendo enviado uma mensagem informando ao objeto conta1, o número da
conta.
No exemplo a seguir está sendo informado o valor de todos os atributos do objeto conta1.
package poo;
conta1.setConta(2156570);
conta1.setAgencia(1579);
conta1.setSaldo(1243.56);
conta1.setTitular("João Aluno");
}
}
6.6 Métodos
Toda classe Java contém pelo menos um método chamado de método construtor (método
com o mesmo nome da classe). O método construtor se não for explicitamente criado pelo
programador, será criado pelo compilador sempre que não tiver sido criado. O método construtor
será visto com maiores detalhes mais adiante.

______________________________________________________________________________________________
É importante observar que dentro dos métodos pode-se criar variáveis, mas estas têm
validade (escopo) somente dentro do método que as criou.
Uma classe para ser executável deve conter um método chamado main(), é a partir deste
método que um programa começa a ser executado. Diz-se que uma classe que contém o método
main(), é uma classe principal.
A seguir é mostrado um exemplo onde o usuário informa os dados de 5 contas corrente
diferentes, armazenando-as em um vetor. Para posteriormente recuperá-las e exibi-las na tela.
package poo;
import java.util.Scanner;
ContaCorrente conta = new ContaCorrente(); //Criando o objeto conta
ContaCorrente contas[] = new ContaCorrente[5];//Cria um vetor de contas
correntes com 5 posições
Scanner lerTeclado = new Scanner(System.in);//Cria objeto da classe Scanner
para realizar leitura do teclado.
for(int i=0; i<5; i++){
System.out.println("n ------------------------------ n ");
System.out.println("Informe o número da conta : ");
conta.setConta(lerTeclado.nextInt());
System.out.println("Informe o número da agencia : ");
conta.setAgencia(lerTeclado.nextInt());
System.out.println("Informe o saldo da conta : ");
conta.setSaldo(lerTeclado.nextDouble());
lerTeclado.nextLine();//Limpa buffer do teclado
System.out.println("Informe o nome do titular : ");
conta.setTitular(lerTeclado.nextLine());
contas[i]=conta;
}
//Recuperar os dados no vetor
for(int i=0; i<5; i++){
conta=contas[i];
System.out.println("n ------------------------------ n ");
System.out.println("Número da conta : "+conta.getConta());
System.out.println("Agência : "+conta.getSaldo());
System.out.println("Saldo : "+conta.getSaldo());
System.out.println("Titular : "+conta.getTitular());
}
}
}

______________________________________________________________________________________________
Exercícios:
1) Escreva uma classe que represente um automóvel. Um automóvel tem como atributos o seu
modelo, fabricante, cor, placa e potência (cilindradas). Forneça os métodos de acesso para os
atributos da classe. Posteriormente escreva uma classe principal que faça uso da classe
'Automóvel'. Nesta classe o usuário deverá informar os dados de até 10 automóveis diferentes.
Utilize um vetor para armazenar os automóveis que estão sendo informados.
No final da execução do programa exiba na tela a lista dos automóveis informados.
2) Escreva uma classe que represente um paciente. Um paciente tem como atributos o seu nome,
idade, telefone e convenio. Forneça os métodos de acesso para os atributos da classe.
Posteriormente escreva uma classe principal que faça uso da classe 'Paciente'. Nesta classe o
usuário deverá informar os dados de até 10 pacientes diferentes.
Utilize um vetor para armazenar os pacientes que estão sendo informados.
No final da execução do programa exiba na tela a lista dos pacientes informados.
Para se obter um melhor entendimento sobre o paradigma da programação orientada a objetos, é
fundamental conhecer alguns conceitos que formam os pilares da programação orientada a objetos.
Estes conceitos são: Abstração, encapsulamento, Herança e Polimorfismo.
6.7 Abstração
A abstração aplicada para a definição de entidades do mundo real. Sendo onde são criadas
as classes. Essas entidades são consideradas tudo que é real, tendo como consideração as suas
características e ações.
Como visto anteriormente, uma classe é reconhecida quando tem a palavra reservada
“class”. No exemplo referente a conta corrente, é apresentado a classe “ContaCorrente” com seus
atributos (características) e métodos (ações).
6.8 Encapsulamento
O encapsulamento visa não expor detalhes internos de uma classe, para o usuário, tornando
partes do sistema mais independentes possível. Por exemplo, quando um controle remoto estraga
apenas é trocado ou consertado o controle e não a televisão inteira. Nesse exemplo do controle
remoto, acontece a forma clássica de encapsulamento, pois quando o usuário muda de canal não
se sabe que programação acontece entre a televisão e o controle para efetuar tal ação.
Como um exemplo mais técnico podemos descrever o que acontece em um sistema de
vendas, aonde temos cadastros de funcionários, usuários, gerentes, clientes, produtos entre outros.
Se por acaso acontecer um problema na parte do usuário é somente nesse setor que será realizada
a manutenção não afetando os demais.
Um componente importante neste processo são os modificadores de acesso. Como boas
práticas (best practices) do Java, na maioria das declarações de variáveis de instância são definidos
os seus atributos com a palavra-chave private, para garantir a segurança de alterações acidentais,
sendo somente acessíveis através dos métodos. Essa ação tem como efeito ajudar no
encapsulamento dos dados, preservando ainda mais a segurança e a aplicação de programação
orientada a objetos do Java. Existem três modificadores de acesso: private, protect e public.
Em um processo de encapsulamento os atributos das classes são do tipo private. Para
acessar esses atributos é necessário criar métodos de acesso e modificadores. Estes métodos são
chamados de métodos setters e getters.

______________________________________________________________________________________________
Como regra os métodos setters servem para alterar a informação de uma propriedade de
um objeto. E os métodos getters para retornar o valor dessa propriedade.
No exemplo utilizando a classe ContaCorrente, os atributos são declarados como privados (private),
e então gerado os métodos geters e seters.
package poo;
/*Declaração da classe ContaCorrente
* O nome da classe deve ser igual ao dome do arquivo que a contém.
* O nome de uma classe deve iniciar com letra maiúcula*/
public class ContaCorrente {
/*Declarando os atributos*/
private int conta;
private int agencia;
private double saldo;
private String titular;
/*Métodos de acesso e modificadores */
public int getConta() {
return conta;
}
public void setConta(int conta) {
this.conta = conta;
}
public int getAgencia() {
return agencia;
}
public void setAgencia(int agencia) {
this.agencia = agencia;
}
public double getSaldo() {
return saldo;
}
public void setSaldo(double saldo) {
this.saldo = saldo;
}
public String getTitular() {
return titular;
}
public void setTitular(String nome) {
this.titular = nome;
}
}//Nenhuma linha de código de ser definida depois deste simbolo de fecha chaves.
No exemplo a seguir, é instanciado a classe “ContataCorrente”, onde o objeto de referência
“conta”, é usado para invocar os métodos setters, informando algum dado. Ao final, é usado os

______________________________________________________________________________________________
métodos getters dentro de um “System.out.println” para gerar a saída dos resultados que foram
passados nos métodos setters.
package poo;
public class Conta {
public static void main(String[] args) {
ContaCorrente conta = new ContaCorrente();
/*Atribuindo valores através dos métodos seters*/
conta.setAgencia(867676);
conta.setConta(5454);
conta.setSaldo(568.9);
conta.setTitular("Pedro Boh");
/*Resgatando os valores através dos métodos geters*/
System.out.println("Agencia :"+conta.getAgencia());
System.out.println("Conta : "+conta.getConta());
System.out.println("Saldo : "+conta.getSaldo());
System.out.println("Titular : "+conta.getTitular());
}
}
Exercícios:
1) Escreva uma classe, aplicando os conceitos de encapsulamento, que represente um aluno. Um
aluno tem como atributos o seu nome, matricula e turma. Forneça os métodos de acesso para os
atributos da classe.
Posteriormente escreva uma classe principal que faça uso da classe 'Aluno'. Nesta classe o usuário
deverá informar os dados de até 15 alunos diferentes.
Utilize um vetor para armazenar os alunos que estão sendo informados.
No final da execução do programa exiba na tela a lista dos alunos informados.
2) Escreva uma classe, aplicando os conceitos de encapsulamento, que represente uma turma.
Uma turma tem como atributos o seu nome, curso e turno. Forneça os métodos de acesso para os
atributos da classe.
Posteriormente escreva uma classe principal que faça uso da classe 'Turma'. Nesta classe o
usuário deverá informar os dados de até 10 turmas diferentes.
Utilize um vetor para armazenar as turmas que estão sendo informadas.
No final da execução do programa exiba na tela a lista das turmas informadas.
3) Escreva uma classe, aplicando os conceitos de encapsulamento, que represente um professor.
Um professor tem como atributos o seu nome, especialidade e curso. Forneça os métodos de
acesso para os atributos da classe.
Posteriormente escreva uma classe principal que faça uso da classe 'Professor'. Nesta classe o
usuário deverá informar os dados de até 15 professores diferentes.
Utilize um vetor para armazenar os professores que estão sendo informados.

______________________________________________________________________________________________
No final da execução do programa exiba na tela a lista dos professores informadas.
6.9 Herança
Na Programação Orientada a Objetos o significado de herança tem o mesmo significado
para o mundo real. Assim como um filho pode herdar alguma característica do pai, na Orientação
a Objetos é permitido que uma classe herde atributos e métodos da outra, tendo apenas uma
restrição para a herança. Os modificadores de acessos das classes, métodos e atributos só podem
estar com visibilidade public e protected para que sejam herdados.
Uma das grandes vantagens de usar o recurso da herança é na reutilização do código. Esse
reaproveitamento pode ser acionado quando se identifica que o atributo ou método de uma classe
será igual para as outras. Para efetuar uma herança de uma classe é utilizada a palavra reservada
chamada extends.
Classe pai (superclasse)
package poo.heranca;
import java.util.Date;
public class Funcionario {
protect int id;
protect String nome;
protect String dataContrato;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getNome() {
return nome;
}
public void setNome(String nome) {

______________________________________________________________________________________________
this.nome = nome;
}
public String getDataContrato() {
return dataContrato;
}
public void setDataContrato(String dataContrato) {
this.dataContrato = dataContrato;
}
}
Classes filhas (subclasses)
Motorista
public class Motorista extends Funcionario{
protect int cnh;
public int getCnh() {
return cnh;
}
public void setCnh(int cnh) {
this.cnh = cnh;
}
}
Engenheiro
public class Engenheiro extends Funcionario{
protect String crea;
public String getCrea() {
return crea;
}
public void setCrea(String crea) {
this.crea = crea;
}
}
Secretária

______________________________________________________________________________________________
public class Secretaria extends Funcionario{
protect String formacao;
public String getFormacao() {
return formacao;
}
public void setFormacao(String formacao) {
this.formacao = formacao;
}
}
Classe Principal faz uso das classes filhas.
/*Criação de atributos estáticos para que não haja necessidade de instanciação de
objetos desta classe.*/
public static Motorista motorista;
public static Engenheiro engenheiro;
public static Secretaria secretaria;
motorista = new Motorista();
motorista.setId(1);//-> atributo herdado da classe pai
motorista.setNome("Pedro Pedroso");//-> atributo herdado da classe pai
motorista.setDataContrato("03/10/2012");//-> atributo herdado da classe pai
motorista.setCnh(45677893);
System.out.println("+-------------------------------------+");
System.out.println("| Dados do Motorista |");
System.out.println("| Nome : "+motorista.getNome());
System.out.println("| Data Contratação : "+motorista.getDataContrato());
System.out.println("| CNH : "+motorista.getCnh());
System.out.println("+-------------------------------------+n");
engenheiro = new Engenheiro();
engenheiro.setId(1);//-> atributo herdado da classe pai
engenheiro.setNome("Ferdinando Martelo");//-> atributo herdado da classe
pai
engenheiro.setDataContrato("09/03/2011");//-> atributo herdado da classe pai

______________________________________________________________________________________________
engenheiro.setCrea("CREA-77893");
System.out.println("| Dados do Engenheiro |");
System.out.println("| Nome : "+engenheiro.getNome());
System.out.println("| Data Contratação : "+engenheiro.getDataContrato());
System.out.println("| CREA : "+engenheiro.getCrea());
secretaria = new Secretaria();
secretaria.setId(1);//-> atributo herdado da classe pai
secretaria.setNome("Mariete Maricota");//-> atributo herdado da classe pai
secretaria.setDataContrato("22/06/2013");//-> atributo herdado da classe pai
secretaria.setFormacao("Superior");
System.out.println("| Dados da Secretária |");
System.out.println("| Nome : "+secretaria.getNome());
System.out.println("| Data Contratação :
"+secretaria.getDataContrato());
System.out.println("| Formação : "+secretaria.getFormacao());
}
}
Exercício:
1) Em um banco existem muitos funcionários. Além dos funcionários comuns há também outros
cargos, como os gerentes. Os gerentes guardam a mesma informação que um funcionário comum,
mas possuem outras informações, além de ter funcionalidades um pouco diferentes. Um gerente
possui uma senha numérica que permite o acesso ao sistema interno do banco, além do número
de funcionários que ele gerencia. De todo funcionário deve ser mantido o nome, cpf, e-mail,
telefone e endereço. Apresente o modelo de classes que melhor represente o cenário descrito.
6.10 Classes abstratas
Uma classe abstrata nada mais é do que uma especificação conceitual para outras classes.
Isso quer dizer que esta classe nunca será instanciada. Uma classe abstrata apenas fornece um
modelo para geração de outras classes. Esta classe nunca está completa, ou seja, servirá apenas
para criação de funcionalidades genéricas de classes filhas. Podemos também chamar as classes
abstratas de super classe. Por exemplo, é sabido que Pessoa Física e Pessoa Jurídica possuem
o atributo nome como uma informação em comum. Dentre dezenas de informações, a mais
comentada que gera uma grande diferença entre as duas
são CPF para Física e CNPJ para Jurídica. Este é um bom motivo para que se defina uma classe
abstrata. Ao invés de definir o atributo nome para as duas classes, o que gera redundância, cria-

______________________________________________________________________________________________
se uma classe abstrata e insere um atributo nome dentro dela. Feito isso, haverá a herança das
propriedades para as classes filhas, física e Jurídica, desta maneira ficam definidas dentro
de Física o atributo CPF e para. Jurídica o CNPJ. O atributo nome vem automaticamente
pela super classe.
Exemplo:
Super classe
package poo.heranca.abstracao;
public abstract class Pessoa {
protected int id;
protected String nome;
public Pessoa(String nome){
this.nome=nome;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getNome() {
return nome;
}
public void setNome(String nome) {
this.nome = nome;
}
}
Sub classes
public class Juridica extends Pessoa{
private String cnpj;
public Juridica(String nome) {
super(nome);//Utiliza o método construtor da super classe
}
public String getCnpj() {
return cnpj;
}
public void setCnpj(String cnpj) {
this.cnpj = cnpj;
}

______________________________________________________________________________________________
}
public class Fisica extends Pessoa{
private String cpf;
public Fisica(String nome) {
super(nome);//Utiliza o método construtor da super classe
}
public String getCpf() {
return cpf;
}
public void setCpf(String cpf) {
this.cpf = cpf;
}
}
Exercícios:
1) Criar um modelo hierárquico que contenha as seguintes classes: Veiculo (classe abstrata),
Bicicleta e Automóvel.
Os métodos da classe veículo são todos abstratos e possuem a seguinte assinatura:
public float acelerar(float velocidade);
public void parar();
Estes métodos são implementados nas subclasses Automóvel e Bicicleta. Acrescentar na classe
Automóvel o método public void torcarOleo(float litros).
2) Implemente uma classe abstrata de nome Forma onde são declarados dois métodos abstratos:
float calcularArea();
float calcularPerimetro();
Crie, como subclasse de Forma, uma classe de nome Retângulo cujas instâncias são
caracterizadas pelos atributos lado e altura, ambos do tipo float. Implemente na classe Retângulo
os métodos herdados de Forma e outros que achar necessário.
Crie, como subclasse de Forma, uma classe de nome Círculo cujas instâncias são
caracterizadas pelo atributo raio do tipo float. Implemente na classe Círculo os métodos herdados
de Forma e outros que achar necessário.
Crie, como subclasse de Retângulo, uma classe de nome Quadrado cujas instâncias são
caracterizadas pelos atributos lado e altura com o mesmo valor.
Elabore um programa de teste, onde é declarado um vetor (array), de dimensão 5, do tipo
estático Forma. Nesse vetor devem ser guardadas instancias de Retângulo, Circulo e Quadrado
seguindo uma ordem aleatória. Em seguida percorra o vetor exibindo a área e o perímetro de cada
forma armazenada no vetor.

______________________________________________________________________________________________
6.11 Polimorfismo
Polimorfismo é o princípio pelo qual duas ou mais classes derivadas de uma mesma
superclasse podem invocar métodos que têm a mesma identificação, assinatura, mas
comportamentos distintos, especializados para cada classe derivada, usando para tanto uma
referência a um objeto do tipo da superclasse. O overload não é um tipo de polimorfismo, pois com
overload a assinatura do método obrigatoriamente tem que ter argumentos diferentes, requisito que
fere o conceito de Polimorfismo citado anteriormente.
De forma genérica, polimorfismo significa várias formas. No caso da Orientação a Objetos,
polimorfismo denota uma situação na qual um objeto pode se comportar de maneiras diferentes ao
receber uma mensagem, dependendo do seu tipo de criação.
Polimorfismo também implica que uma operação de uma mesma classe pode ser
implementada por mais de um método. O usuário não precisa saber quantas implementações
existem para uma operação, ou explicitar qual método deve ser utilizado: a linguagem de
programação deve ser capaz de selecionar o método correto a partir do nome da operação, classe
do objeto e argumentos para a operação. Desta forma, novas classes podem ser adicionadas sem
necessidade de modificação de código já existente, pois cada classe apenas define os seus
métodos e atributos. Em Java, o polimorfismo se manifesta apenas em chamadas de métodos.
A decisão sobre qual o método que deve ser selecionado, de acordo com o tipo da classe
derivada, é tomada em tempo de execução, através do mecanismo de ligação tardia. A ligação
tardia ocorre quando o método a ser invocado é definido durante a execução do programa. Através
do mecanismo de sobrecarga, dois métodos de uma classe podem ter o mesmo nome, desde que
suas assinaturas sejam diferentes, entretanto isso não é polimorfismo. Como dito anteriormente,
tal situação não gera conflito, pois o compilador é capaz de detectar qual método deve ser escolhido
a partir da análise dos tipos dos argumentos do método. Nesse caso, diz-se que ocorre a ligação
prematura para o método correto. Em Java, todas as determinações de métodos a executar
ocorrem através de ligação tardia exceto em dois casos:
1) Métodos declarados como final não podem ser redefinidos e, portanto, não são passíveis
de invocação polimórfica da parte de seus descendentes; e
2) Métodos declarados como private são implicitamente finais.
No caso de polimorfismo, é necessário que os métodos tenham exatamente a mesma identificação,
sendo utilizado o mecanismo de redefinição de métodos, que é o mesmo que sobrescrita de
métodos em classes derivadas. A redefinição ocorre quando um método cuja assinatura já tenha
sido especificada recebe uma nova definição, ou seja, um novo corpo, em uma classe derivada. É
importante observar que, quando polimorfismo está sendo utilizado, o comportamento que será
adotado por um método só será definido durante a execução. Embora em geral esse seja um
mecanismo que facilite o desenvolvimento e a compreensão do código orientado a objetos, há
algumas situações onde o resultado da execução pode ser não-intuitivo.
Exemplo:
abstract class Mamífero {
public abstract double obterCotaDiariaDeLeite();
}

______________________________________________________________________________________________
class Elefante extends Mamífero {
public double obterCotaDiariaDeLeite(){
return 20.0;
}
}
class Rato extends Mamifero {
public double obterCotaDiariaDeLeite() {
return 0.5;
}
}
class Aplicativo {
System.out.println("Polimorfismon");
Mamifero mamifero1 = new Elefante();
System.out.println("Cota diaria de leite do elefante: " +
mamifero1.obterCotaDiariaDeLeite());
Mamifero mamifero2 = new Rato();
System.out.println("Cota diaria de leite do rato: " +
mamifero2.obterCotaDiariaDeLeite());
}
}
Exercícios:
1) Defina o que significa uma classe em Programação Orientada a objetos.
2) Defina um Objeto.
3) Quais os três pilares da programação orientada a objetos.
4) O que é uma interface? Qual a sua aplicação?
5) Defina uma classe abstrata.
6) Defina o que são modificadores de acesso.

______________________________________________________________________________________________
7) Defina encapsulamento. Qual a sua finalidade?
8) Defina herança em POO.
9) Defina super classe e subclasse.
10) Quantas subclasses uma superclasse pode ter.
11) É possível uma subclasse descender de vaias superclasses?
12) Como funciona a reescrita de métodos?
13) Qual a consequência em declarar um método como final?
14) Qual a função da anotação @override?
15) Depois que um método é reescrito, é possível chamar o método antigo da classe mãe?
16) Defina polimorfismo em POO.
17) Defina como ocorre o acoplamento entre classes.
18) Qual a relação de Herança e acoplamento?
19) Qual a finalidade da palavra-chave super?
20) Diferencie polimorfismo estático e dinâmico.
21) Considere as classes a seguir, presentes em uma aplicação Java orientada a objetos:

______________________________________________________________________________________________
Em uma classe principal foram digitadas, no interior do método main, as seguintes linhas:
As linhas que contêm a instrução s = f.calcularSalario( ); demonstram um conceito da orientação a
objetos conhecido como:
a) encapsulamento
b) sobrecarga de métodos
c) polimorfismo
d) método abstratos
e) sobrecarga de construtores

______________________________________________________________________________________________
Documentar pontos estratégicos do código fonte, é uma necessidade universal em vários
paradigmas ou plataformas de desenvolvimento. E cada vez mais, é necessário gerar e manipular
de uma forma eficiente todos os comentários em formato de documentação de códigos, visando
com isso, facilitar a reutilização futura desses comentários como fonte geradora de conhecimentos
acerca de uma classe.
Em Java, felizmente, há um recurso do próprio JDK, que facilita todo o trabalho de criação e
manipulação dos comentários, essa ferramenta é denominada de JavaDoc.
De maneira geral o JavaDoc fornece uma linguagem especifica para enriquecer os
comentários que introduzem classes, atributos e métodos.
Seu funcionamento baseia-se na inserção de textos explicativos em forma de um comentário
especial, que antecedem um escopo de uma classe ou método, tendo assim, a responsabilidade
de apresentar o mesmo.
Seu funcionamento é através do uso de marcação de documentos com doclets, gerando
arquivos nos formatos HTML, SGML, XML ou RTF. Tais marcações são feitas através de
comentários, contendo tags especiais que especificam quais informações serão inseridas, com
objetivo de manter uma massa de conhecimento reutilizável em qualquer projeto que faça uso da
classe em questão.
Vale ressaltar, que é possível combinar tags da própria especificação HTML, com as tags
oferecidas pelo JavaDoc, tornando possível à criação de documentos completos gerados a partir
dos comentários do próprio código.
Entendendo a sintaxe
A estrutura básica de um comentário de documentação tem como característica principal, o
uso de uma barra e dois asteriscos (/**) no início e no seu final, possui um asterisco e uma
barra ( */ ). Conforme o exemplo a seguir.
/** Exemplo básico de um comentário em JavaDoc */
/** Exemplo básico de um comentário em JavaDoc
* com mais de uma linha.
*/
Por convenção, sugere-se alocar os blocos de comentários, antes da definição de uma
classe, interface, atributos, ou métodos, dessa forma, cria-se uma introdução conceitual ao referido
elemento do código.
Documentação - JavaDoc 7

______________________________________________________________________________________________
Um ponto forte do JavaDoc é o uso de tags especiais a fim de qualificar melhor a informação
contida nos comentários.
Com as tags é possível especificar, por exemplo, o autor, a versão, links, data, exceções
lançadas, lista de argumentos de um método e tipo de retorno de um método.
Essas tags são inseridas dentro do bloco de comentários, antecedidas pelo carctetre @
(arroba), e após o nome da própria tag, insere-se o conteúdo desejado. A seguir, as tags
disponíveis pelo JavaDoc.
Tag Significado
@author Especifica o autor da classe ou do
método em questão.
@deprecated Identifica classes ou métodos obsoletos.
É interessante informar nessa tag, quais
métodos ou classes podem ser usadas
como alternativa ao método obsoleto.
@link Possibilita a definição de um link para
um outro documento local ou remoto
através de um URL.
@param Mostra um parâmetro que será passado
a um método.
@return Mostra qual o tipo de retorno de um
método.
@see Possibilita a definição referências de
classes ou métodos, que podem ser
consultadas para melhor compreender a
ideia daquilo que está sendo comentada.
@since Indica desde quando uma classe ou
métodos foi adicionado na aplicação.
@throws Indica os tipos de exceções que podem
ser lançadas por um método.
@version Informa a versão da classe.
Exemplos:
A seguir alguns exemplos de codificação com o uso de comentários JavaDoc.

______________________________________________________________________________________________
Comentário simples
/** Um exemplo de um simples de comentário com o JavaDoc */
Outro exemplo interessante é a possibilidade de inserção de tags HTML, dentro do próprio
comentário JavaDoc. A seguir um exemplo que faz uso das tas e para destacar, trechos
do comentário.
/**Com esta combinação podemos inserir marcações HTML em nossos*/
Comentários em classes
A seguir, um exemplo de classe com atributos e métodos comentados com JavaDoc.
package projetojavadoc;
/**Classe para objetos do tipo Funcionários, onde serão contidos, valores e
métodos para o mesmo.
* @author Maria Felipeta
* @version 1.05
* @since Release 02 da aplicação
*/
public class Funcionarios {
private String matricula;
private Double salario;
/** Método para retorno da matrícula do funcionário
* @return String - Nr da Matrícula*/
public String getMatricula(){
return this.matricula;
}
/** Método para retorno do salário do funcionário
* @return Double - Valor do Salário */
public Double getSalario(){
return this.salario;
}
/**Método para cálculo da diária com base no salário do
* funcionário dividido pelo mês comercial de 30 dias para efeito * de cálculo de
ajuda de custo para viagem.
* @author Pedro Bó
* @param diasViagem int - Valor total das vendas do mês.

______________________________________________________________________________________________
* @param valorDeslocamento Double - Valor pago em cada diária despesas
básicas de deslocamento.
* @return Double - Valor da diaria
*/
public Double calculaAjudaCusto(int diasViagem, Double
valorDeslocamento) throwsArithmeticException {
try{
return (this.salario / 30)*diasViagem+valorDeslocamento;
}catch (ArithmeticException ae){
return 0.0;
}
}
/**Método para cálculo do valor da bonificação baseada na
* seguinte faixa de valores: Para vendas menores de
* 25.000,00, o percentual de comissão aplicado será de 5%, e * para valores
iguais ou maiores de 25.000,00, o percentual
* será de 10%
* @author Maria Felipeta
* @param valorVendas - Valor total das vendas do mês
* @return Double - Valor do resultado do cálculo conforme a faixa de
comissões.
*/
public Double calculaBonificacao(Double valorVendas) {
if (valorVendas <25000.00 ){
return this.salario * 0.05;
} else {
return this.salario * 0.10;
}
}
}
Automatizando através do NetBeans
O NetBeans que atualmente encontra-se na versão 8.0.2, oferece recursos nativos na
própria IDE para:
 Criar de maneira automática os comentários no mesmo momento da criação de uma classe
em projeto.
 Disponibilizar code completion para mostrar as tags JavaDoc disponíveis em cada área
do código.
 Gerar a criação de documentos HTML, contendo a documentação feita através dos
comentários em JavaDoc.

______________________________________________________________________________________________
Criando um projeto no NetBeans
Vamos agora criar um projeto básico, para isso, abra o NetBeans, clique no menu File/New,
será aberta uma janela para escolher o tipo de projeto desejado, nessa etapa, escolha Java
Application, siga os procedimentos para nomeação e definição dos diretórios onde será
armazenado esse nosso projeto.
Após a conclusão desse processo, se você deixou marcado a opção Create a main class na
tela de construção da aplicação, seu projeto terá uma classe chamada Main, que dentre outras
finalidades, possui um método main para o bloco de execução principal de sua aplicação. Note que
essa classe já foi criada com alguns comentários usando JavaDoc
Para ter a total visão sobre a aplicação do JavaDoc, crie no próprio NetBeans, uma classe
chamada Funcionarios, e codifique-a conforme a listagem mostrada anteriormente.
É importante você notar que o NetBeans possui um recurso de code completion para mostrar
e inserir as tags disponíveis, ou seja, dentro do bloco de comentário, você pode digitar o sinal de
@ (arroba) seguido pelo pelas teclas Ctrl+Espaço, para que seja mostrada uma pequena janela
flutuante estilo menu popup sobre seu código, para que seja escolhida a tag desejada.
Uma vez concluída essa classe, podemos agora, gerar os arquivos HTML em formato de
documentação, para isso, conforme mostra abaixo, clique no menu Build/Generate javadoc for
“seu projeto”.
Após esse processo, será executado automaticamente o navegador padrão de sua máquina,
exibindo um arquivo na estrutura de HTML conteúdo o arquivo JavaDoc gerado, veja na figura a
seguir, um trecho de um arquivo desses, vale ressaltar que, esse arquivo estará armazenado no
sub-diretório distjavadoc dentro do diretório de seu projeto.

______________________________________________________________________________________________
Atualmente, o Java suporta, oficialmente, dois tipos de bibliotecas gráficas: AWT e Swing. A
AWT foi a primeira API para interfaces gráficas a surgir no Java e foi, mais tarde, superada pelo
Swing (a partir do Java 1.2), que possui diversos benefícios em relação a seu antecessor.
As bibliotecas gráficas são bastante simples no que diz respeito a conceitos necessários
para usá-las. A complexidade no aprendizado de interfaces gráficas em Java reside no tamanho
das bibliotecas e no enorme mundo de possibilidades; isso pode assustar, em um primeiro
momento.
AWT e Swing são bibliotecas gráficas oficiais inclusas em qualquer JRE ou JDK. Além
destas, existem algumas outras bibliotecas de terceiros, sendo a mais famosa, o SWT desenvolvida
pela IBM e utilizada no Eclipse e em vários outros produtos.
8.1 Componentes Swing
O pacote javax.swing foi criado em 1997 e inclui os componentes GUI que se tornaram
padrão em Java a partir da versão 1.2 da plataforma Java 2. A maioria dos componentes Swing
(assim são denominados) são escritos, manipulados e exibidos completamente em Java, sendo
conhecidos como componentes Java puros. Isso oferece a eles um maior nível de portabilidade e
flexibilidade. Os nomes de tais componentes recebem um “J”, como, por exemplo: JLabel, JButton,
JFrame, JPanel, etc. Tal peculiaridade se justifica para diferenciar esses componentes dos que
serão mencionados logo adiante. São considerados peso-leve e fornecem funcionalidade e
aparência uniforme em todas as plataforma, sendo denominada de aparência de metal (metal look-
and-feel).
Interface Gráfica 8

______________________________________________________________________________________________
8.1.1 Hierarquia das Classes dos Componentes
Mostraremos abaixo a hierarquia de herança das classes que definem atributos e
comportamentos que são comuns a maioria dos componentes Swing. Cada classe é exibida com
o seu pacote:
As operações comuns à maioria dos componentes GUI, tanto Swing como AWT são
definidas na classe Component. Isso inclui métodos relativos à posicionamento, personalização,
tamanho, visibilidade, pintura, registro de tratadores de eventos, ajuste e retorno de estado dos
componentes. Em aplicativos com JFrames e em applets, anexamos os elementos ao painel de
conteúdo, que é um objeto da classe Container. Logo, a classe Container dá suporte à adição e
posicionamento dos componentes ao painel de conteúdo de um contêiner. A classe JComponent,

______________________________________________________________________________________________
que define os atributos e comportamentos para suas subclasses, é a superclasse da maioria dos
componentes Swing. Com exceção dos conteiners JFrame e JDialog, todos os demais
componentes Swing cujo nome comece com “J” descendem da classe JComponent.
8.1.2 Portabilidade
As APIs de interface gráfica do Java favorecem, ao máximo, o lema de portabilidade da
plataforma Java. O look-and-feel do Swing é único em todas as plataformas onde roda, seja ela
Windows, Linux, ou qualquer outra. Isso implica que a aplicação terá exatamente a mesma interface
(cores, tamanhos etc) em qualquer sistema operacional.
Grande parte da complexidade das classes e métodos do Swing está no fato da API ter sido
desenvolvida tendo em mente o máximo de portabilidade possível. Favorece-se, por exemplo, o
posicionamento relativo de componentes, em detrimento do uso de posicionamento fixo, que
poderia prejudicar usuários com resoluções de tela diferentes da prevista.
Com Swing, não importa qual sistema operacional, qual resolução de tela, ou qual
profundidade de cores: sua aplicação se comportará da mesma forma em todos os ambientes.
8.1.3 Look And Feel
Look-and-Feel (ou LaF) é o nome que se dá à "cara" da aplicação (suas cores, formatos e
etc.). Por padrão, o Java vem com um look-and-feel próprio, que se comporta exatamente da
mesma forma em todas as plataformas suportadas.
Mas, às vezes, esse não é o resultado desejado. Quando rodamos nossa aplicação no
Windows, por exemplo, é bastante gritante a diferença em relação ao visual das aplicações nativas.
Por isso é possível alterar qual o look-and-feel a ser usado em nossa aplicação.
Além do padrão do Java, o JRE 5 da Sun ainda traz LaF nativos para Windows e Mac OS,
além do Motif e GTK. E, fora esses, você ainda pode baixar diversos LaF na Internet ou até
desenvolver o seu próprio.
Veja esses screenshots da documentação do Swing mostrando a mesma aplicação rodando
com 4 LaF diferentes:
8.1.4 Bases de Estruturação das Interfaces Gráficas
Visto que agora já temos uma ideia espacial concebida, resta-nos analisar a anatomia das
interfaces gráficas em Java, a qual baseia-se nos elementos que serão descritos nestas próximas
seções.

______________________________________________________________________________________________
8.1.4.1 Conteiners
Dão suporte à exibição e agrupamento de outros componentes, inclusive outros conteiners.
Eles constituem a base onde os outros elementos são anexados. Precisamente, é o local onde
podemos montar nossa aplicação.
Como veremos, em praticamente todos os nossos exemplos usamos um objeto da classe
Container denominado conteiner. A ele atribuímos uma chamada ao método getContentPane( ),
que devolve uma referência para o painel de conteúdo do aplicativo ou do applet. O painel de
conteúdo compreende a área imediatamente inferior a barra de título de uma janela, estendendo-
se até os limites da mesma.
A classe Container define o método add(Component), para adicionar elementos, e setLayout
(LayoutManager), que configura um gerenciador de leiaute para gerir o posicionamento e
dimensionamento dos mesmos.
Ressalta-se que a disposição dos elementos adicioandos a um contêiner obedece a ordem
em que eles foram anexados e ao gerenciador de leiaute previamente definido. Se um conteiner
não é suficientemente dimensionado para acomodar os componentes anexados a ele, alguns ou
todos os elementos GUI simplesmente não serão exibidos.
Qualquer programa que ofereça uma interface vai possuir pelo menos um conteiner, que pode ser :
 JFrame - janela principal do programa;
 JDialog - janela para diálogos;
 JApplet - janela para Applets.
8.1.4.2 Swing - Mensagens
A classe mais simples do Swing é a JOptionPane que mostra janelinhas de mensagens,
confirmação e erros, entre outras.
Podemos mostrar uma mensagem para o usuário com a seguinte linha:
A classe JFileChooser é a responsável por mostrar uma janela de escolha de arquivos. É
possível indicar o diretório inicial, os tipos de arquivos a serem mostrados, selecionar um ou vários
e muitas outras opções.
Para mostrar a mensagem:
O argumento do showOpenDialog indica qual o componente pai da janela de mensagem
(pensando em algum frame aberto, por exemplo, que não é nosso caso). Esse método retorna
um int indicando se o usuário escolheu um arquivo ou cancelou. Se ele tiver escolhido um,
podemos obter o File com getSelectedFile:

______________________________________________________________________________________________
8.1.4.3 Componentes: JFrame, JPanel e JButton
Uma interface gráfica em Java é baseada em dois elementos:
– Containers: servem para agrupar e exibir outros componentes
 JFrame e JPanel
– Componentes:
 JLabel, JButton, JTextField, JScrollPane, JCheckBox, JComboBox, JRadioButton ,JList,
JTable, JMenuBar, JMenu e JmenuItem
Uma janela é definida através da classe JFrame, que serve como container para outros
componentes, como botões, imagens ou painéis. O JFrame possui atributos que definem uma
janela, como barra de título e borda. O JPanel é um container simples que pode ser utilizado para
acrescentar componentes em uma janela, que será utilizado mais tarde.
8.1.4.4 JFrame
Esta classe define objetos que são frequentemente utilizados para criar aplicativos baseados
em GUI. Eles consistem em uma janela com barra de título e uma borda e fornecem o espaço para
a GUI do aplicativo ser construída. A classe JFrame é uma subclasse de java.awt.Frame, que por
sua vez é subclasse de java.awt.Window. Pelo mecanismo de herança, nota-se que JFrames são
um dos poucos componentes GUI do Swing que não são considerados de peso-leve, pois não são
escritos completamente em Java. Sendo assim, quando possível, devemos devolver ao sistema os
recursos ocupados pela janela, descartando-a. Frisamos que a janela de um programa Java faz
parte do conjunto de componentes GUI da plataforma local e será semelhante as demais janelas,
pois serve-se da biblioteca gráfica do sistema em questão.
A classe JFrame suporta três operações quando o usuário fecha a janela. Por default, a
janela é removida da tela (ocultada) quando o usuário intervém indicando o seu fechamento. Isso
pode ser controlado com o método setDefaultCloseOperation(int), que utiliza como argumento as
constantes da interface WindowConstants (pacote javax.swing) implementada por JFrame:
 DISPOSE ON CLOSE: descarta a janela devolvendo os seus recursos ao sistema;
 DO NOTHING ON CLOSE: indica que o programador determinará o que fazer quando o
usuário designar que a janela deve ser fechada;
 HIDE ON CLOSE: (o default) a janela é ocultada, removida da tela;
 EXIT ON CLOSE: determinamos que quando fechamos a JFrame, o aplicativo seja
finalizado. Essa constante é definida na classe JFrame e foi introduzida na versão 1.3 da
Plataforma Java. A janela só será exibida na tela quando o programa invocar o método

______________________________________________________________________________________________
setVisible(boolean) com um argumento true, ou o método show( ).
O tamanho da janela é configurado com uma chamada ao método setSize(int x, int y), que
define nos valores inteiros dos argumentos a largura e a altura da mesma. Se não chamarmos esse
método, somente a barra de título será exibida. Também podemos utilizar o método pack( ), que
utiliza os tamanhos preferidos dos componentes anexados ao painel de conteúdo para determinar
o tamanho da janela. Por tamanho preferido, entende-se uma chamada realizada pelos
gerenciadores de leiaute ao método getPreferredSize( ) de cada componente GUI. Esse método
indica o melhor tamanho para os componentes. É herdado da classe java.awt.Component, de modo
que todos 15 os objetos que derivem-se dessa classe podem responder a essa evocação. Ela
devolve um objeto da classe Dimension (pacote java.awt). Podemos fazer uso dos métodos
setMinimumSize(Dimension) e setMaximumSize(Dimension), que estabelecem os tamanhos
extremos dos elementos. O componente não deveria ser maior que o tamanho máximo e nem
menor que o mínimo. Entretanto, esteja consciente de que certos gerenciadores de leiaute ignoram
essa sugestão. Todos os elementos têm um tamanho preferido default, como, por exemplo, um
objeto JPanel, que tem altura e largura de 10 pixels. Se necessitarmos mudar esse tamanho default,
devemos sobrescrever o método getPreferredSize( ), fazendo com que ele retorne um objeto
Dimension que contenha a nova largura e altura do componente, ou usar o método
setPreferredSize(new Dimension( int x, int y)). Sobre o posicionamento, por default, o canto superior
esquerdo da janela é posicionado nas coordenadas (0, 0) da tela, ou seja, no canto superior
esquerdo. Podemos alterar essa característica com o método setLocation(int x, int y). Mais à frente,
discutiremos os eventos gerados pela manipulação de janelas e como tratá-los.
Exemplo instanciando um JFrame:
import javax.swing.*;
public class JanelaJFrame {
JFrame janela = new JFrame("Minha Primeira Janela");
janela.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); //define o que fazer
quando a janela for fechada
janela.setSize(800, 600); //define o tamanho da janela
janela.setVisible(true); //exibe a janela
}
}

______________________________________________________________________________________________
8.1.4.5 JDesktopPane e JInternalFrame
São classes que fornecem suporte à criação de interfaces de múltiplos documentos. Uma
janela principal (pai) contém e gerencia outras janelas (filhas). A grande utilidade disso é que
podemos visualizar vários documentos que estão sendo processados em paralelo ao mesmo
tempo, facilitando a edição ou leitura dos mesmos. Um JInternalFrame tem um painel de conteúdo
ao qual os componentes GUI podem ser anexados.
8.1.4.6 JDialog
Usamos a classe JDialog, que é subclasse de java.awt.Dialog para criarmos caixas de
diálogo elaboradas, embora mais limitados que as originadas por JFrames. Em prol da facilidade,
a classe JOptionPane, que está definida no pacote de extensão javax.swing, oferece caixas de
diálogo pré-definidas que permitem aos programas exibir simples mensagens para os usuários.
Cada vez que usamos uma JOptionPane para implementar um diálogo, na verdade estamos
usando uma JDialog nos bastidores. A razão é que JOptionPane são simplesmente um contêiner
que pode automaticamente criar uma JDialog e anexa-la ao seu painel de conteúdo.
Podemos definir se o tamanho de uma JDialog é redimensionável, com o método
setResizable(boolean).
Obviamente, devido a diversidade de funcionalidades e de construtores, para usarmos todas
as potencialidades devemos estudar profundamente as classes em questão. Abaixo mostraremos
alguns métodos estáticos da classe JOptionPane.(todos são precedidos por JOptionPane.) e a
sintaxe mais comumente utilizada para criarmos caixas de diálogo pré-definidas:
 showInputDialog(String):Método usado para solicitar a entrada de algum dado em forma de
String. Lembre-se que os valores recebidos devem ser atribuídos à variáveis do tipo String
e convertidos para outros tipos caso desejarmos realizar operações sobre eles.
 showMessageDialog(Component, Object, String, int, Icon): Método que exibe uma caixa de
diálogo com texto, ícone, posicionamento e título definidos pelo programador.
Podemos fazer uso dos seguintes valores para as constantes:
 JOptionPane.ERROR MESSAGE - Indica mensagem de erro ao usuário;
 JOptionPane.INFORMATION MESSAGE - Exibe uma mensagem com informações que
podem ser dispensadas;
 JOptionPane.WARNING MESSAGE - Indica mensagem de advertência sobre algum

______________________________________________________________________________________________
problema em potencial;
 JOptionPane.QUESTION MESSAGE - Impõe uma mensagem que pergunta algo ao usuário;
 JOptionPane.PLAIN MESSAGE - Exibe um diálogo que simplesmente contém uma
mensagem sem nenhum ícone.
8.1.4.7 Componentes Atômicos
São os botões, scrollbars, labels, sliders, check boxes, etc. Eles não podem conter outros
elementos.
8.1.4.7.1 JLabel
São rótulos inertes que geralmente informam ou descrevem a funcionalidade de outros
componentes GUI, como por exemplo, campos de texto, ícones, etc. As instruções são mostradas
por meio de uma linha de texto somente leitura, uma imagem, ou ambos. Aqui salientamos o uso
do método setToolTipText(String), o qual fornece dicas de ferramenta a todos os elementos
herdados da classe JComponent. Dessa forma, quando o usuário posicionar o cursor do mouse
sobre algum componente, ficará ciente da função do mesmo.
8.1.4.7.2 Botões
É um componente que quando clicado dispara uma ação específica. Um programa Java
pode utilizar vários tipos de botões, incluindo botões de comando, caixas de marcação, botões de
alternância e botões de opção. Para criarmos algum desses tipos de botões, devemos instanciar
uma das muitas classes que descendem da classe AbstractButton, a qual define muito dos recursos
que são comuns aos botões do Swing. Cita-se, por exemplo, a exibição de texto e imagens em um
botão, o uso de caracteres mnemônicos, dentre outros. Vejamos a hierarquia de classes, partindo
da classe JComponent:

______________________________________________________________________________________________
8.1.4.7.3 JButton
É um dos componentes mais familiares e intuitivos ao usuário. Os botões de comando são
criados com a classe JButton e seu pressionamento geralmente dispara a ação especificada em
seu rótulo, que também suporta a exibição de ícones. Também podemos definir dicas de ferramenta
para cada botão, juntamente com mnemônicos, que dão acesso rápido pelo teclado aos comandos
definidas nos botões. Para oferecer maior interatividade visual com a GUI, o JButton oferece a
possibilidade de ícones rollover, os quais mudam de aparência quando o cursor está posicionado
sobre eles, dando a entender que o seu pressionamento resulta em uma ação. Deve-se ter a
mesma atenção com os arquivos de imagem, de acordo com o que foi mencionado anteriormente.
Pressionar um JButton gera eventos ActionEvent que, juntamente com outros eventos, serão
abordados mais à frente.
8.1.4.7.4 JCheckBox
A classe JCheckBox dá suporte à criação de botões com caixa de marcação, sendo que
qualquer número de itens pode ser selecionado. Quando um item é selecionado, um ItemEvent é
gerado. O mesmo pode ser tratado por um objeto que implemente a interface ItemListener. A classe
que fornece as funcionalidades para este objeto deve definir o método itemStateChanged.

______________________________________________________________________________________________
8.1.4.7.5 JRadioButton
Os botões de opção, que são definidos na classe JRadioButton, assemelham-se às caixas
de marcação no que concerne aos seus estados (selecionado ou não selecionado). Entretanto,
costumeiramente são usados em grupo no qual apenas um botão de opção pode ser marcado,
forçando os demais botões ao estado não-selecionado.
Os métodos aqui utilizados pouco diferem dos da classe anterior, sendo que a única
novidade é o método getSource( ), que retorna a fonte geradora do evento.
8.1.4.7.6 JTextField
Compreende a área de uma única linha que suporta a inserção ou exibição de texto.
Podemos definir se o texto pode ser manipulado com o método setEditable(boolean), utilizando no
argumento o valor true.
Quando o usuário digita os dados em uma JTexField e pressiona Enter, ocorre um evento de
ação. Esse evento é processado pelo ouvinte de evento registrado que pode usar os dados que
estão no JTexField no momento em que o evento ocorre.

______________________________________________________________________________________________
8.1.4.7.7 JPasswordField
É uma subclasse de JTextField e acrescenta vários métodos específicos para o
processamento de senhas. Sua aparência e comportamento quase nada diferem de uma
JTextField, a não ser quando o texto é digitado, pois o mesmo fica ocultado pelos asteriscos. Tal
procedimento se justifica para ocultar os caracteres inseridos, dado que esse campo contém uma
senha.
8.1.4.7.8 JTextArea
É uma área dimensionável que permite que múltiplas linhas de texto sejam editadas com a
mesma fonte. Esta classe é herdada de JTextComponent, que define métodos comuns para
JTextField, JTextArea e outros elementos GUI baseados em texto.
As JTextAreas não têm eventos de ação como os objetos da classe JTextField, cujo o
pressionamento de Enter gera um evento. Então, utiliza-se um outro componente GUI (geralmente
um botão) para gerar um evento externo que sinaliza quando o texto de uma JTextArea deve ser
processado.

______________________________________________________________________________________________
8.1.4.7.9 JScrollPane
Objetos dessa classe fornecem a capacidade de rolagem a componentes da classe
JComponent, quando estes necessitam de mais espaço para exibir dados.
JScrollpane (Component, int, int) é o construtor mais elaborado e recebe um componente
(JTextArea por exemplo) como primeiro argumento, definindo qual será o cliente do JScrollPane,
ou seja, para que membro será fornecido as barras de rolagem. Os dois próximos argumentos
definem o comportamento da barra vertical e da horizontal, respectivamente. Para isso, podemos
fazer uso das constantes definidas na interface ScrollPaneConstants que é implementada por
JScrollPane. Vejamos elas:
 JScrollPane.VERTICAL SCROLLBAR AS NEEDED;
 JScrollPane.HORIZONTAL SCROLLBAR AS NEEDED Indicam que as barras de rolagem
devem aparecer somente quando necessário;
 JScrollPane.VERTICAL SCROLLBAR ALWAYS;
 JScrollPane.HORIZONTAL SCROLLBAR ALWAYS Indicam que as barras de rolagem
devem aparecer sempre;
 JScrollPane.VERTICAL SCROLLBAR NEVER;
 JScrollPane.HORIZONTAL SCROLLBAR NEVER Indicam que as barras de rolagem nunca
devem aparecer;
8.1.4.7.10 JSlider
É um marcador que desliza entre um intervalo de valores inteiros, podendo selecionar
qualquer valor de marca de medida em que o marcador repouse. Uma das inúmeras utilidades
desse controle deslizante é restringir os valores de entrada em um aplicativo, evitando que o usuário
informe valores que causem erros.

______________________________________________________________________________________________
8.1.4.7.11 JComboBox
Assemelha-se a um botão, porém, quando clicado, abre uma lista de possíveis valores ou
opções. Mais precisamente é uma caixa de combinação que permite ao usuário fazer uma seleção
a partir de uma lista de itens.
Atende-se para que a lista da caixa de combinação, quando aberta, não ultrapasse os limites
da janela da aplicação.
Também é possível digitar nas linhas de uma caixa de combinação. Elas são implementadas
com a classe JComboBox, herdada de JComponent. Tais caixas de combinação geram ItemEvents,
assim como as JCheckBoxes.
8.1.4.7.12 JList
Exibe em uma coluna uma série de itens que podem ser selecionados. A classe JList suporta
listas em que o usuário pode selecionar apenas um item e listas de seleção múltipla, permitindo
que um número qualquer de itens seja selecionado. Fazemos uso do método
setSelectionMode(ListSelectionMode) para definir isso.
Os itens que serão exibidos por uma lista podem ser passados como argumento no momento
da inicialização. A classe JList fornece construtores que recebem Vectors e arrays como
argumentos. Se você inicializar uma lista com um array ou vetor, o construtor implicitamente cria
uma lista modelo default. Ela é imutável, ou seja, você não poderá adicionar, remover ou
sobrescrever os itens. Para criar uma lista onde os itens possam ser modificados, devemos
configurar o modelo de lista chamando o método setModel(ListModel). Para o mesmo propósito,
também é possível instanciar um objeto de uma classe de lista mutável, como DefaultListMode,
adicionar elementos a ele, para depois passa-lo como argumento do construtor de JList.

______________________________________________________________________________________________
8.1.4.7.13 JPopupMenus
São menus sensíveis ao contexto, ou seja, em virtude da localização do cursor do mouse,
um clique no botão direito do mesmo dispara um evento que abre um menu flutuante. Tal menu
fornece opções selecionáveis ao determinado componente por sobre o qual o evento de disparo foi
gerado.
8.1.4.7.14 Menus
Muito familiares a nós, os menus talvez sejam os componentes que mais aparecem nas
ferramentas computacionais que utilizamos. Geralmente eles são encontrados no topo da janela
da aplicação, de onde dão suporte à organização e agrupamento de funções afins em um mesmo
contexto visual, o que facilita muito a localização e entendimento por parte do usuário, já que a
estrutura de cada menu está delineada pelas características dos itens.
Os menus, que são instanciados a partir da classe JMenu, são anexados a uma barra de

______________________________________________________________________________________________
menus com o método add(JMenu) de JMenuBar, sendo que instancias dessa última classe
comportam-se como conteiners para menus. A classe JMenuBar fornece os métodos necessários
ao gerenciamento da barra onde os menus são anexados. A ordenação dos mesmos depende da
ordem em que foram adicionados, sendo que são “empilhados” horizontalmente da esquerda para
a direita. Evidentemente, só podemos anexar menus à janelas da classe JApplet, JDialog, JFrame
e JInternalFrame, e fazemos isso usando o método setJMenuBar(JMenuBar).
A classe JMenuItem capacita a criação de itens de menu que, por sua vez, devem ser
anexados a um menu. Podemos usar um item de menu para executar alguma ação ou para gerir o
acionamento de um submenu, o qual fornece mais itens que estão relacionados por alguma
característica comum.
8.2 Eventos
Eventos são o resultado da interação do usuário com algum componente GUI. Mover o
mouse, clicá-lo, digitar num campo de texto, selecionar um item de menu, fechar uma janela, clicar
num botão, etc. são interações que enviam eventos para o programa, normalmente realizando
serviços. Eventos também podem ser gerados em resposta a modificações do ambiente, como por
exemplo, quando a janela de um applet é coberta por outra janela. Em outras palavras, define-se
eventos GUI como mensagens (chamadas a métodos) que indicam que o usuário do programa
interagiu com um dos componentes GUI.
8.2.1 Tratamento de Eventos
O mecanismo de tratamento de eventos compreende três partes: a origem, o objeto e o
ouvinte do evento.
8.2.1.1 A Origem do Evento
É o componente GUI em particular com o qual o usuário interage. ´
8.2.1.2 O Objeto Evento
Dada a interação com algum componente, um objeto evento é criado. Ele encapsula as
informações sobre o evento que ocorreu, incluindo uma referência para a origem e demais dados
necessários para que o ouvinte do evento o trate.

______________________________________________________________________________________________
8.2.1.3 Ouvinte do Evento
É um objeto de uma classe que implementa uma ou mais das interfaces listeners de eventos
dos pacotes java.awt.event e javax.swing.event. Ele é notificado da ocorrência de um evento e usa
o objeto evento que recebe para, de acordo com seus métodos de tratamento de eventos,
responder ao evento. Para isso o ouvinte deve ser registrado e implementar a interface
correspondente ao(s) evento(s) que deseja tratar. Cada fonte de eventos pode ter mais de um
ouvinte registrado. Analogamente, um ouvinte pode registrar múltiplas fontes de eventos.
Basicamente, quando ocorre um evento (pressionar um JButton, por exemplo), o
componente GUI com o qual o usuário interagiu notifica seus ouvintes registrados chamando o
método de tratamento de evento (como você verá é o ActionPerformed, nesse caso) apropriado de
cada ouvinte. Esse estilo de programação é conhecido como programação baseada em eventos.
8.2.2 Tratadores de Eventos ou Ouvintes (Listeners)
São objetos de qualquer classe que implemente uma interface específica para o tipo de
evento que se deseja tratar. Essa interface é definida para cada classe de eventos.
Para a classe de eventos java.awt.eventFocusEvent existe a interface
java.awt.eventFocusListener, por exemplo.
Vamos explorar esse assunto nestas próximas seções, descrevendo os métodos definidos
por cada interface e em decorrência de quais ações eles são chamados.
8.2.2.1 ActionListener
A partir dessa interface, instanciamos objetos que “sabem” tratar eventos de ação.
public void actionPerformed(ActionEvent)
Invocado quando clicamos em um botão, pressionamos Enter enquanto digitamos em um
campo de texto ou selecionamos um item de menu.
8.2.2.2 FocusListener
Trata de eventos de visibilidade, ou seja, quando o componente fica no foco de ação do
teclado (primeiro plano), ganhando ou perdendo habilidade de receber entradas do mesmo. Os
métodos recebem como argumento um objeto da classe FocusEvent.
public void focusGained(FocusEvent)
Chamado somente depois que o componente ganha o primeiro plano de ação.
public void focusLost(FocusEvent)
Chamado somente depois que o componente perde o foco de ação.

______________________________________________________________________________________________
8.2.2.3 ItemListener
Compreende eventos relativos a marcação, onde existe a possibilidade do estado
selecionado e não-selecionado. Por exemplo, as opções de JCheckBox, JCheckBoxItem e
JCombobox.
public itemStateChanged(ItemEvent) Invocado após o componente sofrer um mudança de
estado.
8.2.2.4 KeyListener
Aqui apresentaremos a interface listener de eventos KeyListener, que trata dos eventos de
pressionamento e liberação das teclas. Uma classe que implementa esta interface deve fornecer
definição para os métodos:
 public void KeyPressed (KeyEvent) - Chamado quando se pressiona qualquer tecla.
 public void KeyReleased (KeyEvent) - Chamado quando se libera qualquer tecla.
 public void KeyTyped (KeyEvent) - Chamado quando se pressiona uma tecla de ação ( setas,
Home, End, Page Up, Page Down) ou de função (Num Lock, Caps Lock, Scroll Lock, Pause,
Print Screen).
8.2.2.5 MouseListener
Agora apresentaremos a interface listener de eventos MouseListener, que trata dos eventos
de pressionamento e liberação dos botões do mouse. Uma classe que implementa esta interface
deve fornecer definição para os métodos:
 public void mousePressed(MouseEvent) - Chamado quando se pressiona um botão do
mouse com o cursor sobre um componente.
 public void mouseClicked(MouseEvent) - Chamado quando se pressiona e libera-se um
botão do mouse sobre um componente, sem mover o cursor.
 public void mouseReleased(MouseEvent) - Chamado quando se libera um botão do mouse
depois de ser pressionado. As chamadas para este método são enviadas para o ouvinte de
eventos do componente sobre o qual a operação de arrastar iniciou. Esse evento sempre é
precedido por um evento mousePressed.
 public void mouseEntered(MouseEvent) - Chamado quando o cursor do mouse entra nos
limites de um componente.
 public void mouseExited(MouseEvent) - Chamado quando o cursor do mouse sai dos limites
de um componente.

______________________________________________________________________________________________
8.2.2.6 MouseMotionListener
A interface listener de eventos MouseMotionListener trata dos eventos de “arrasto” do
mouse. Uma classe que implementa esta interface deve fornecer definição para os métodos:
public void mouseDragged(MouseEvent) - Chamado quando se pressiona o botão do mouse
com o cursor sobre um componente e se move o mouse. As chamadas para este método são
enviadas para o ouvinte de eventos do componente sobre o qual a operação de arrastar iniciou.
Esse evento é sempre precedido por uma chamada mousePressed.
public void mouseMoved(MouseEvent) - Chamado quando se move o mouse com o cursor
sobre um componente. Os eventos do mouse podem ser capturados por qualquer componente GUI
que se derive de java.awt.Component (painéis, botões, etc.), sendo que o componente deve ter um
objeto listener registrado. Todos esses métodos recebem um objeto MouseEvent como argumento,
o qual encapsula as informações sobre o evento que ocorreu, incluindo as coordenadas x e y da
posição em que o mesmo se verificou.
8.2.2.7 WindowListener
Todas as janelas geram eventos quando o usuário as manipula. Os ouvintes (listeners) de
eventos são registrados para tratar eventos de janela com o método
addWindowListener(WindowListener) da classe Window.
A interface WindowListener, que é implementada por ouvintes de eventos de janela, fornece
sete métodos para tratar esses eventos, Todos os métodos recebem um objeto da classe
WindowEvent. Vejamos eles:
 public void windowActivated(WindowEvent) - Chamado quando o usuário torna uma janela
ativa.
 public void windowClosed(WindowEvent) - Chamado depois que a janela é fechada.
 public void windowClosing (WindowEvent) - Chamado quando o usuário inicia o fechamento
da janela.
 public void windowDesactivated(WindowEvent) - Chamado quando o usuário torna outra
janela a ativa.
 public void windowIconified(WindowEvent) - Chamado quando o usuário minimiza a janela.
 public void windowDeiconified(WindowEvent) - Chamado quando o usuário restaura uma
janela minimiza.
 public void windowOpened(WindowEvent) - Chamado quando uma janela é exibida pela
primeira vez na tela.
8.3 Classes Adaptadoras
A premissa de que uma classe implementa uma interface implica que o programador deverá
definir todos os métodos declarados nessa interface.
Porém, nem sempre é desejável definir todos os métodos. Podemos construir aplicações
que utilizem apenas o método tratador de eventos mouseClicked da interface MouseListener, por
exemplo. Para muitas das interfaces listeners que contém vários métodos, os pacotes
java.awt.event e javax.swing.event fornecem classes adaptadoras de ouvintes de eventos.
Essas classes implementam uma interface e fornecem cada método implementado com um
o corpo vazio. O programador pode criar uma classe que herde da classe adaptadora todos os
métodos com a implementação default (corpo vazio) e depois sobrescrever o(s) método(s)

______________________________________________________________________________________________
necessário(o) para o tratamento de eventos.
Vejamos as classes adaptadoras que implementam as respectivas interfaces:
8.4 JavaFX
8.4.1 Introdução
Em um mundo cada vez mais conectado, a Web tornou-se o principal canal de comunicação
e relacionamento. Os softwares começam a seguir a tendência de migrar para essa nova
plataforma, que elimina vários obstáculos, como a distância, e minimiza outros, como o tempo, por
exemplo. Contudo, ainda não se pode afirmar que a Web substitui completamente o Desktop, pois
sua usabilidade é menor.
Com base nisso e na nova tecnologia JavaFX tenta-se unir a dinamicidade da Web e o poder
do Desktop. Essa nova tecnologia usa a plataforma Java como base, o que faz com que sua
Runtime já esteja disponível em mais de 4,5 bilhões de computadores no mundo (SUN, 2009), além
da possibilidade de usar todo o código desenvolvido em Java e sua extensa biblioteca de códigos.
Entre as vantagens de migrar software para a Web, podem-se citar: acesso ao
programa/dados em qualquer lugar conectado à internet, facilidade no compartilhamento de
informações, facilidade na instalação e atualização de software, entre outras (MACORATTI, 2009).
Porém, a sua tecnologia padrão ((X)HTML) não oferece uma experiência de navegação e utilização
tão intuitiva como a que é conseguida em um sistema Desktop (MACORATTI, 2009).
Para suprir a lacuna, busca-se uma alternativa que una o melhor dos dois mundos (COSTA,
2008). As chamadas Rich Internet Applications tentam aproximar a experiência de navegação de
um usuário Web a um usuário Desktop.
8.4.2 Aplicação de internet rica (RICH INTERNET APPLICATION – RIA)
Primeiramente, deve-se descrever o que é o termo “Aplicação de Internet Rica”, em inglês,
Rich Internet Application (RIA). O termo RIA foi cunhado pela empresa Macromedia (incorporada
pela Adobe) para descrever aplicações que tenham características de software Desktop, mas
rodem na Web (ADOBE, 2009).
Algumas das características que permitem classificar um software como RIA são:
a) executar a aplicação em um navegador (lado cliente);
b) manter os dados no servidor de aplicações;
c) executar em uma sandbox.2;

______________________________________________________________________________________________
De acordo com Costa (2008), a experiência do usuário com o software é melhor em relação
ao usuário Web convencional, pois várias ações são feitas localmente, o que evita a troca de
informações entre cliente e servidor, tornando a aplicação mais rápida.
O termo riqueza, segundo Web Design Development India (2009), significa que as mídias
suportadas por uma aplicação dessa categoria são amplas e, de modo geral, para ser considerada
rica, a tecnologia deve suportar, entre outras mídias: animações, múltiplas fontes, conferência on-
line, gráficos vetoriais ou rasteirizados, áudio, vídeo e outros.
Segundo Macoratti (2009), o uso de aplicações RIA justifica-se em razão de que ao contrário
de uma aplicação Desktop, as RIAs não necessitam de instalação, sua atualização é feita no
servidor, novas versões são usadas automaticamente, a aplicação é acessível de qualquer
computador conectado à internet, ou seja, o usuário não fica preso a um computador apenas, pois
os dados estão na rede, independência de plataforma (sistema operacional e browser), menor
possibilidade de infecção de vírus nas aplicações, entre outras vantagens.
Podem-se citar vários exemplos de linguagens que permitem implementação RIA, as
principais são:
a) Javascript: foi a primeira linguagem que permitiu execução de código no lado do cliente e
que teve adoção maciça dos navegadores;
b) AJAX (Acrônimo para Asynchronous Javascript and XML) Javascript e XML assíncronos:
conjunto de tecnologias e técnicas que permitem criar aplicações ricas;
c) Adobe Flash, Adobe Flex, Adobe Air: Adobe Flash usa animações. O Adobe Flex cria
interfaces em flash compilando em XML, e o Adobe Air une HTML, Ajax, Flash e PDF;
d) Microsoft Silverlight: concorrente direto do flash, utiliza XML e é baseado na
plataforma .NET 3.0;
e) Applets Java: uma das primeiras aplicações do Java, um dos primeiros RIA, são pequenas
aplicações Java embutidas na página HTML;
f) Aplicativos Java: por meio do protocolo Java Web Start podem ser lançados via browser
aplicativos Java em todo o seu poder;
g) JavaFX: nova Tecnologia da Sun para aplicações RIA.
8.4.3 Sobre JAVAFX
De acordo com Doederlein (2009, p. 19), JavaFX Script é em parte declarativa, o que
significa que ela se preocupa em dizer o que fazer e não como fazer. É orientada a objetos, roda
na Máquina Virtual Java (JVM), utiliza Classes Java, tem tipagem estática.
JavaFX fornece um modelo unificado de desenvolvimento e implantação para a construção
de aplicações ricas que integram mídias, como áudio e vídeo, gráficos, texto rico e serviços Web.
JavaFX permite aos desenvolvedores de criação programarem em um contexto visual, assim,
ajudando-os a trazer suas ideias para a vida mais rápido e melhor.
JavaFX foi elaborado com o conceito de perfil comum, que conforme a Sun (2010), são
componentes reutilizáveis em todos dispositivos suportados, o que permite uma redução do
tamanho do núcleo da plataforma e consequentemente um reuso de APIs internas. Conforme Chen
(2008), nesse perfil, podemos destacar as seguintes características:
a) Apresentação gráfica: A apresentação gráfica representa a interface que será exibida pela

______________________________________________________________________________________________
aplicação. Dentre seus elementos destacam-se:
1. Formas geométricas;
2. Linhas;
3. Arcos;
4. Transparência;
5. Preenchimento de cores;
6. Textura;
7. Suporte à exibição em tela cheia;
8. Transformações tais como: girar, redimensionar e inclinar.
b) Apresentação textual: Refere-se ao modo como os textos da interface serão apresentados na
aplicação. Dentre seus elementos destacam-se:
1. Renderização de fontes;
2. Transformações tais como: girar, redimensionar e inclinar.
c) Animação: Permite a criação de forma fácil de conteúdo animado para as aplicações. Dentre
seus elementos destacam-se:
1. Animações tais como: rotação e aproximação;
2. Transições animadas entre componentes.
d) Áudio e vídeo: Compõe a camada de apresentação incorporada de vídeo e áudio. Dentre seus
elementos destacam-se:
1. Suporte a áudio e vídeo digitais;
2. Reprodução, pausa, pesquisa, volume e controle de velocidade;
3. Fluxo de mídia sobre HTTP com utilização de buffer.
Para permitir que o desenvolvedor não se preocupe com peculiaridades de cada dispositivo
suportado, foi desenvolvida uma linguagem de programação que é utilizada para a construção das
aplicações JavaFX. A linguagem JavaFX Script, é de acordo com a Sun Microsystem (2010) ”uma
linguagem de programação de script de alto desempenho que permite criar e disponibilizar a
próxima geração de aplicações avançadas de Internet para desktop, celulares e televisores.”.
8.4.4 Características
Podem-se enumerar várias características da linguagem JavaFX, como:
a) facilita a junção de áudio, vídeo, animação, gráficos e texto. Os gráficos em 2D podem
sofrer transformações em perspectiva 3D (gráficos 3D reais em breve);
b) aspectos da animação avançada incluem timeline, animação por keyframe, e animação
baseada em caminho;
c) pode-se reutilizar bibliotecas Java, o que preserva investimentos feitos nesta tecnologia;
d) instalação fácil;

______________________________________________________________________________________________
e) linguagem simples e declarativa;
f) É orientada a objetos;
g) É uma linguagem com estilo funcional, onde as funções podem ser atribuídas a variáveis;
h) É uma linguagem de expressão, ou seja, todo código JavaFX consiste de expressões;
i) É uma linguagem declarativa, o que é conveniente para o desenvolvimento das interfaces
para o usuário;
j) Possui a característica de ser uma linguagem que segue o raciocínio lógico, permitindo
assim a descrição mais fácil das interfaces para o usuário;
k) Permite, de forma simples a separação de modelos e visualizações das interfaces;
l) É uma linguagem fortemente tipada, com capacidades de inferência de tipo básico, ou
seja, o compilador identifica os tipos e reporta quaisquer erros;
m) O código JavaFX Script é compilado para classes Java;
n) Possui quatro tipos de dados: tipos primitivos, de vetores, de função e de classe.
As interfaces do JavaFX utilizam alguns componentes do Swing, interface gráfica padrão do
Java, porém de acordo com Giles (2010) “não é a intenção do JavaFX criar uma simples camada
sobre os componentes Swing/AWT, pois estes não são portáveis para celulares, dispositivos e
televisões, o qual faz parte dos planos do JavaFX.”. A figura abaixo ilustra as classes e camadas
que compõem a arquitetura JavaFX para ambientes desktop, além de demonstrar claramente a
próxima relação com as classes Java.
Ainda conforme Giles (2010), nessa arquitetura, destacam-se os seguintes componentes:
a) Stage: A classe Stage está no topo da hierarquia de interface do usuário para qualquer
aplicação JavaFX. Ela representa o ponto principal de início da aplicação;
b) Scene: Essa classe representa o segundo nível na hierarquia das classes nas aplicações
JavaFX. Ela contém todos os elementos da interface do usuário criada na aplicação, sendo
tais elementos denominados “nós gráficos”. As subclasses que herdam diretamente de
Scene, representam as características de apresentação da aplicação, em que na figura
acima são representadas por:
1. Effects: São efeitos de animação, tais como reflexão e brilho que foram criados

______________________________________________________________________________________________
para utilização de forma trivial por parte do desenvolvedor da aplicação;
2. Transitions: São efeitos de transição de componentes da aplicação que são
baseadas em tempo de exibição e permitem transições suaves;
3. Nodes: Em uma aplicação JavaFX, os nós são ditos como os elementos gráficos
da aplicação. A classe Node contém eventos relacionados ao mouse, cursores,
translação na tela por coordenadas;
4. Animation: Essa classe contém as funcionalidades que permitem uma aplicação
JavaFX prover conteúdo de animação, tais como transições por tempo,
rotacionamento.
8.4.5 À linguagem JavaFX script
Segundo Doederlein (2009, p. 19-20), JavaFX lembra bastante Java; pode-se ver em um
código-fonte com sintaxe e declarações conhecidas a um programador Java, como class, import,
package, delimitação de bloco por chaves, etc., porém sua API acrescenta novos termos e
conceitos que serão, posteriormente expostos, de forma resumida. Segundo Weawer et al. (2009,
p. 99), a metáfora do JavaFX é um teatro, há um palco (Stage) e, dentro desse palco, uma ou mais
cenas (Scene).
Segundo Doederlein (2009, p. 40), em um primeiro contato com o código JavaFX Script, um
programador Java5 logo percebe algumas diferenças, como a falta de uma declaração de classe,
e a definição de funções, variáveis e sentenças espalhadas pelo escopo global do Script; o return
é implícito na função; JavaFX utiliza sua própria sintaxe para instanciar novos objetos, chamada de
Objeto Literal, como se pode observar no exemplo abaixo.
nomeDaClasse{
propriedade1: valor
propriedade2: valor
}
Os iniciadores são separados por vírgula, ponto e vírgula ou espaços. As variáveis e constantes
são declaradas da maneira retratada no exemplo a seguir.
var valorInicial : Integer;
def constante : String = “valor”;
A figura abaixo ilustra uma exemplificação de código da linguagem JavaFX Script:

______________________________________________________________________________________________
Resultado:
O trecho de código ilustrado acima representa:
a) Linhas 1-9: Cria uma estrutura de diretório com nome “javafxapl”, indica as classes que são
dependências da aplicação e que necessitam fazer parte do escopo para execução normal da
aplicação;
b) Linha 11: Assim como na linguagem Java, nessa linha pode-se observar um comentário de final
de linha. Convém mencionar que o comentário do trecho de código (/* */) também é permitido;
c) Linha 12: É criada uma instância da classe Image que representa a imagem de fundo da
aplicação. A classe Image representa itens gráficos na aplicação e é utilizada para carregar
imagens de diretórios locais ou remotos;
d) Linha 14: É declarado um objeto do tipo Stage que é basicamente a interface de usuário das
aplicações JavaFX, completamente independente do dispositivo;
e) Linhas 15-17: São variáveis de instância que representam as características de largura, altura e

______________________________________________________________________________________________
título da aplicação, respectivamente;
f) Linha 18: Essa linha representa uma cena na aplicação, definida pela classe Scene. Essa classe
contém os elementos gráficos da aplicação e que serão apresentados na Stage, que representa
uma janela na aplicação;
g) Linhas 20-23: Esse trecho do código indica a imagem de fundo que será apresentada na
aplicação, sendo que a classe ImageView é utilizada para desenhar as imagens que são
representadas pela classe Image. Além disso, o caractere "[" indica o início de uma sequência
lógica de ações;
h) Linhas 24-30: Essa sequência, definida pela classe Text, exibe na janela da aplicação a palavra
JavaFX com uma fonte Monotype Corsiva em negrito e tamanho de 25 pixels. Além disso, o
caractere "]" indica o fim de uma sequência lógica que foi iniciada pelo caractere "[" na linha 15.
8.4.5.1 Tipos de variáveis
Tipos primitivos de JavaFX têm sempre uma classe de Base e valores-padrão para quando
uma variável é declarada sem um inicializador, não admitem null (exceto para tipos de Classe)
(WEAVER et al., 2009, p. 46), e são tipos de valor, ou seja, para comparar duas Strings, pode-se
usar o operador ==, diferentemente de Java, onde a comparação usando esse operador compararia
as referências ao objeto, em JavaFX é feita uma comparação de valores (DOEDERLEIN, 2009c).
a) Boolean – armazena os valores true ou false (ANDERSON; ANDERSON, 2009, p. 61), é
importante destacar que, diferentemente de Java, os operadores lógicos são escritos literalmente
como and, ore not (WEAVER et al., 2009, p. 47);
b) Integer – tem como Classe de base a classe java.lang.Integer, o valor padrão é 0;
c) Number – tem como classe de base a classe java.lang.Float, o valor padrão é 0.0;
d) String – tem como valor padrão uma String vazia, ou seja, “”. Como os outros tipos de valor,
String não aceita null. Pode ser usada tanto aspas duplas quanto aspas simples para delimitá-lo. A
concatenação de duas Strings em sequência é automática, sem o uso do caractere de soma (+),
ou de vírgula (,). Todos os métodos de java.lang.String, que é a classe de base de String podem
ser usados (WEAVER et al., 2009, p. 55).
e) Duration – é usado para representação de tempo, em animações; ele é criado com um Integer
ou number sucedido por uma unidade de tempo sem espaço entre eles (WEAVER et al., 2009, p.
57). Ao contrário dos outros tipos primitivos de JavaFX que têm classes base em java.lang.*, o tipo
Duration tem como classe base uma classe JavaFX, javafx.lang.Duration (WEAVER et al., 2009, p.
57).
f) Sequences – segundo Anderson e Anderson (2009, p. 21), são coleções de objetos que você
pode acessar sequencialmente. O valor padrão de uma sequence é uma sequence vazia, e o tipo
de uma sequence é o tipo dos seus elementos seguido por colchetes, um exemplo é Boolean[].
Não é possível ter elementos null no interior de uma sequence (WEAVER et al., 2009, p. 59).
8.4.5.2 Características especiais
a) Binding – uma das técnicas mais poderosas de JavaFX (ANDERSON; ANDERSON, 2009, p. 31)
é o recurso de Binding, em uma tradução livre, vinculação. Por meio da palavra-chave bind pode-
se vincular uma variável a outra variável, a uma expressão ou função. Quando você atualiza algum
valor da expressão a qual a variável foi vinculada, o valor do objeto dependente é atualizado, como

______________________________________________________________________________________________
é demonstrado abaixo:
var altura = 4;
var base = 3;
function calculaHipotenusa(base, altura){
return Math.sqrt(base*base + altura*altura);
};
var hipotenusa = bind calculaHipotenusa(base, altura);
println(hipotenusa);
base = 30;
altura = 40;
b) Expressões de Bloco – conforme Anderson e Anderson (2009, p. 50), JavaFX é uma linguagem
de expressão, o que significa que vários tipos de expressão em JavaFX retornam valores, que
podem ser usados, por exemplo, em uma atribuição. Uma Expressão de Bloco nada mais é do que
um conjunto de expressões delimitadas por colchetes ({ }). O tipo e o valor do retorno são o tipo e
o valor da última expressão do bloco.
c) Expressão IF – também retorna valor, então pode-se associar o resultado de uma expressão if
a uma variável, o retorno da expressão if é do mesmo tipo e valor do retorno da expressão then ou
else, por exemplo;
d) Expressão for – é usada para fazer alguma ação em um determinado número de vezes. Ele
retorna uma sequence formada pelos retornos de cada iteração, essa sequence pode ser
armazenada em uma variável, como se nota na figura abaixo;
var nomeDasPessoas = for (pessoa in pessoas){
“{pessoa.nome} {pessoa.sobrenome}”;
}
e) Expressões while – não retornam valor, elas atuam e têm sintaxe exatamente como no Java;
palavra-chave while, seguida de uma expressão booleana entre parênteses e um bloco para ser
executado enquanto a condição retornar true;
f) Funções – funções em JavaFX são criadas pela palavra-chave function, seguida do nome da
função e de parênteses que delimitam os parâmetros que porventura existam, e, por último, um
bloco delimitado por chaves;
g) Triggers – segundo Weaver et al. (2009, p. 215) as triggers são uma parte opcional de uma
declaração de variável. Ela é caracterizada pelo uso das palavras-chave on replace seguidas de
um bloco de código a ser executado sempre que a variável mudar;
h) Event Handlers – os Nodes de JavaFX contêm variáveis que armazenam funções que são
chamadas quando determinado evento acontece, exemplos de event handlers são:
onMousePressed, onKeyTyped, onMouseEntered.

______________________________________________________________________________________________
8.4.5.3 Ambiente web
Durante a década de 90 a tecnologia de Java Applets demonstrava todo potencial no
desenvolvimento de aplicativos que poderiam ser executados diretamente nos navegadores web.
Devido à complexidade, falta de produtividade e escassez de boas ferramentas, a utilização dessa
tecnologia se tornou menos frequente. O avanço no desenvolvimento dos navegadores web e a
concepção do conceito de aplicações ricas para Internet permitiram novos investimentos nessa
área e conforme a Sun (2010), por volta de dezembro de 2008, foi demonstrado a primeira versão
de JavaFX, que tem como objetivo revigorar a plataforma Java no desenvolvimento de aplicativos
com execução do lado do cliente.
O JavaFX foi elaborado para permitir que uma aplicação seja executada em diferentes
ambientes com o mínimo de modificação. Uma aplicação JavaFX desenvolvida para ser executada
dentro do navegador web, necessita da criação de um arquivo JNLP (Java Network Launching
Protocol) e a inserção de uma chamada a aplicação no código HTML (HyperText Markup
Language). A abaixo demonstra um código JavaFX Applet.
O trecho de código ilustrado na acima representa:
a) Linhas 1-5: O trecho de código define o início da linguagem de marcação HTML que possibilitará
a inserção direta do código JavaScript;
b) Linha 6: O arquivo JavaScript “dtfx.js” contém definições para verificar automaticamente
atualizações e geração da tag “<APPLET>”;
c) Linhas 7-17: O código exposto define a configuração da aplicação no navegador web. Nesse
caso, será exibido uma aplicação que possui 200 pixels de altura e 350 pixels de largura, e o início
da aplicação é configurado para o método principal da classe "MeuAplicativo".
O princípio proposto pela plataforma JavaFX é que a aplicação possa ser executada de
forma transparente em todos ambientes. No entanto torna-se evidente que a forma de distribuição
da aplicação deve ser adaptada ao perfil em que será executada. Conforme apresentado nessa
subseção, a aplicação JavaFX para web necessita de uma adaptação na forma de distribuição, que
é resolvido através da utilização do JWS.

______________________________________________________________________________________________
8.4.5.4 A aplicação JXplayer
A plataforma JavaFX fornece toda infra-estrutura tecnológica para o desenvolvimento de
aplicações RIA complexas por meio de componentes integrados e simples de usar. Como forma de
verificar a produtividade no desenvolvimento de aplicações JavaFX, foi elaborado um exemplo
funcional, denominado JXPlayer, que tem o intuito de apresentar algumas características da
plataforma.
8.4.5.4.1 Características da aplicação JXPlayer
A aplicação JXPlayer foi desenvolvida para demonstrar que funcionalidades complexas em
outras linguagens, são construídas de forma simples em JavaFX. As funcionalidades da aplicação
são:
 Suporte à áudio/vídeo local e remoto (streaming);
 Controles de reprodução de áudio/vídeo (avançar/retroceder reprodução, diminuir/aumentar
volume, interromper/finalizar reprodução);
 Suporte à aplicação de efeitos em fotos;
 Execução de tarefas em segundo plano, por exemplo, escutar música enquanto manipulo
uma foto;
 Efeitos de transição entre as telas;
 Efeito de ofuscamento de imagem durante reprodução de uma música;
 Barras de progressão de áudio e vídeo;
 Controles de interfaces com efeitos gráficos.
A figura abaixo ilustra a tela principal da aplicação.
8.4.5.4.2 Ferramentas de apoio ao desenvolvimento
A interface e funcionalidades da aplicação JXPlayer foram desenvolvidas no IDE NetBeans
2008 com o plugin JavaFX Composer 1.10.3. Conforme a Sun Microsystems (2010), JavaFX
Composer é um plugin para o NetBeans que fornece uma infra-estrutura integrada e um ambiente

______________________________________________________________________________________________
visual no desenvolvimento das aplicações JavaFX.
A utilização de técnicas de drag-and-drop5 providas pelo ambiente de desenvolvimento
possibilitou uma redução no tempo dedicado a criação da interface gráfica e formatação dos
componentes visuais em tela. Internamente, o plugin gera os códigos necessários para apresentar
os componentes e restringe as alterações apenas para o modo visual no NetBeans. Com isso, as
características dos componentes terão o comportamento e forma definidos pelas funcionalidades
implementadas no plugin, o que muitas das vezes não é suficiente.
Apesar de auxiliar e automatizar a utilização de vários componentes no desenvolvimento do
JXPlayer, o plugin apresentou instabilidade e comportamentos incoerentes. Por exemplo, uma
simples modificação de aparência (alteração de uma Fonte) de um menu impossibilitou toda a
aplicação de ser executada.
O plugin JavaFX Composer fornece uma forma visual e amigável no desenvolvimento de
aplicações JavaFX, que agiliza a criação e integração dos componentes visuais do JavaFX na tela
da aplicação. No entanto, sua instabilidade e rigidez no gerenciamento do código fonte, podem
impedir que ele seja adotado como uma ferramenta principal na elaboração de aplicações JavaFX
mais complexas.
8.4.6 Interface e efeitos gráficos
Conforme mencionado na subseção anterior, as ferramentas de apoio ao desenvolvimento
NetBeans e JavaFX Composer ofereceram a infra-estrutura básica na criação das interfaces
gráficas da aplicação. Como a plataforma JavaFX provê APIs específicas e bem estruturadas para
efeitos e transições, a implementação desses recursos na aplicação foi simples e com poucas
linhas de código. A simplicidade do uso foi devido à utilização da palavra chave bind, que conforme
Weaver (2010) é um arranjo dinâmico que normalmente está associado a uma variável e reflete
suas atualizações. Um exemplo da versatilidade do bind utilizado na aplicação é a redução
dinâmica do brilho e contraste de uma imagem quando uma música está sendo reproduzida.
A criação de interfaces em JavaFX é feita de forma simples e declarativa, portanto não houve
grandes obstáculos na elaboração da parte gráfica da aplicação.
Porém, a utilização do JavaFX Composer restringiu a modelagem dos componentes gráficos
e inviabilizou o desenvolvimento de um aplicativo mais rico em detalhes visuais.
8.4.7 Suporte a áudio e vídeo
Uma parte do escopo da aplicação JXPlayer é permitir que arquivos de mídia possam ser
executados de forma transparente, seja de origem local ou remota (Internet). O JavaFX permitiu
que essas funcionalidades fossem incorporadas a aplicação de forma trivial e rápida, por meio de
sua API de mídia. Contudo, para o diálogo de seleção de arquivos locais, foi necessário utilizar um
componente do Swing, interface gráfica nativa do Java, pois não existe a funcionalidade como
recurso nativo do JavaFX. Isso demonstra que alguns componentes essenciais, por exemplo um
componente de seleção de arquivos, ainda precisam ser incorporados ao JavaFX, além de
demonstrar também a integração com a plataforma Java, pois foi possível utilizar classes nativas
do Java na aplicação.
As classes do JavaFX abstraem toda complexidade na reprodução de arquivos de mídia e
oferecem suporte a vários tipos de arquivos. Incorporar na aplicação a funcionalidade de
5
Conforme a Adobe (2010), drag and drop é a ação de “arrastar e soltar” determinado conteúdo em outro destino.

______________________________________________________________________________________________
reprodução de mídias locais e remotas foi trivial, porém a alternância da origem dos arquivos foi
onerosa porque mesmo modificando no objeto da classe a localização da mídia, o arquivo
permanecia o mesmo. A solução encontrada foi utilizar o recurso bind para gerar uma classe
dinâmica associada ao componente de mídia do JavaFX.
As ferramentas de produtividade, NetBeans e JavaFX Composer, e a variedade de APIs
públicas do JavaFX, auxiliaram o desenvolvimento da aplicação JXPlayer e possibilitaram
incorporar funcionalidades que seriam muito complexas de serem agregadas caso fosse necessário
desenvolvê-las por completo. No entanto, a restrição e falta de implementação de alguns
componentes indicam que é necessário um prévio conhecimento da plataforma Java para elaborar
soluções que não estejam nativamente incorporadas ao JavaFX.
Expressão regular é um método formal de se especificar um padrão de texto. É uma
composição de símbolos, caracteres com funções especiais, que agrupados entre si e com
caracteres literais, formam uma sequência, uma expressão.
Uma expressão é interpretada como uma regra, que indica sucesso se uma entrada de
dados qualquer casar com essa regra.
Os símbolos que compõem uma expressão regular (ER), são chamados de meta caracteres,
pois possuem funções especiais.
As ERs servem para dizer algo abrangente de forma especifica. Tal como determinar uma
lista finita de possibilidades de ocorrência de determinados caracteres em uma palavra.
Ex: [rgp]ato → Aceita resultados como rato, pato e gato. Abrange especificamente estas 3 palavras
e mais nada.
Metacaractere Mnemônico
. Ponto
[ ] Lista
[^] Lista negada
? Opcional
* Asterisco
+ Mais
{} Chaves
^ Circunflexo
$ Cifrão
b Borda
Escape
| Ou
Expressões Regulares - Java 9

______________________________________________________________________________________________
() Grupo
1 Retrovisor
Os metacaracteres estão divididos em 4 grupos distintos de acordo com características
comuns entre eles.
Representantes
Meta
caractere
Mnomônico Função
. Ponto Um caractere
qualquer
[...] Lista Lista de caracteres
permitidos
[^...] Lista negada Lista de caracteres
proibidos
Quantificadores
Meta caractere Mnomônico Função
? Opcional Zero ou um
* Asterisco Zero, um ou mais
+ Mais Um ou mais
{n,m} Chaves De n até m
Âncoras
^ Circunflexo Inicio da linha
$ Cifrão Fim da linha
b Borda Início ou fim da palavra
Outros
c Escape Torna literal o caractere c
| Ou Ou um ou outro
(…) Grupo Delimita um grupo
1…9 Retrovisor Texto casado nos grupos 1..9

______________________________________________________________________________________________
Exemplos:
Expressão Casa com
n[ãa]o Não, nao
[Tt]eclado Teclado, teclado
e[sx]tendido estendido, extendido
<[BIP]> , ,
b[ip]+ Bi, bip, biipp,bpipipi, biip, bppp, …
9.1 ERs em Java
Java dispõe de mecanismos muito bons para o tratamento de expressões regulares no
pacote java.util.regex. Para um melhor aproveitamento, é aconselhável o estudo da
documentação deste pacote disponível em:
http://java.sun.com/j2se/1.4.2/docs/api/java/util/regex/package-summary.html[/url]
Um objeto da classe Pattern contém a expressão regular desejada que será usada em uma
comparação. Já um objeto da classe Matcher contém os métodos que validarão nossa String, dada
uma expressão regular.
Exemplo:
Pattern padrao = Pattern.compile(“Java*”);
Matcher pesquisa = padrao.matcher(“JavaFree”);
if (pesquisa.matches())
{
System.out.println(“JavaFree Rox”);
}
else
{
System.out.println(“Inconpativel”);
}
O exemplo acima poderia, ainda, ser feito somente com o uso do método boolean
matches (String regex, CharSequence entrada) da classe Pattern, da seguinte
forma:
if (Pattern.matches(“Java*”, “JavaFree”))
{
System.out.println(“JavaFree Rox”);
}
else
{
System.out.println(“Incompativel”);
}

______________________________________________________________________________________________
Estes exemplos mostram que é bem fácil trabalhar com expressões regulares em Java.
Exemplo: Validar um Endereço de Email
Fica bem simples, agora, validar um endereço de email (ou outro dado qualquer).
/* Exemplo prático
* Verifica se um endereço de email é válido
* Compilar: javac ValidarEmail.java
* Executar: java ValidarEmail teste@meuemail.com
*/
// ————————————————————— classes nativas
import java.util.regex.*;
// ————————————————————— nossa classe
class ValidarEmail
{
public static void main (String[] args)
{
if (args.length < 1) // Falta argumentos de execução
{
System.out.println(“Uso: java ValidarEmail <seu@email.com>”);
}
else
{
// Email válido é na forma usario@endereco.com , usario@endereco.com.br,
etc.
// Tente fazer um expressão mais restringente
Pattern padrao = Pattern.compile(“.+@.+.[a-z]+”);
Matcher pesquisa = padrao.matcher(args[0]);
if (pesquisa.matches())
{
System.out.println(“O email ” + args[0] + ” eh valido!”);
}
else
{
System.out.println(“O email ” + args[0] + ” nao eh valido!”);
}
}
}//end main()
}//ValidarEmail.class
Vale sempre estudar a documentação das classes. O exemplo dado aqui é bem trivial,
existem outros métodos com outras funcionalidade muito interessantes neste pacote.

______________________________________________________________________________________________
Nesta seção será visto como tratar exceções na linguagem Java, entendendo a teoria de
funcionamento desse tipo de estrutura, passando pelos comandos de tratamento e captura até a
customização de exceções para fins específicos.
Quando se cria programas de computador em Java, há possibilidade de ocorrer erros
imprevistos durante sua execução, esses erros são conhecidos como exceções e podem ser
provenientes de erros de lógica ou acesso a dispositivos ou arquivos externos.
10.1 Entendendo as exceções
As exceções ocorrem quando algo imprevisto acontece, elas podem ser provenientes de
erros de lógica ou acesso a recursos que talvez não estejam disponíveis.
Alguns possíveis motivos externos para ocorrer uma exceção são:
 Tentar abrir um arquivo que não existe;
 Tentar fazer consulta a um banco de dados que não está disponível;
 Tentar escrever algo em um arquivo sobre o qual não se tem permissão de escrita;
 Tentar conectar em servidor inexistente.
Alguns possíveis erros de lógica para ocorrer uma exceção são:
 Tentar manipular um objeto que está com o valor nulo;
 Dividir um número por zero;
 Tentar manipular um tipo de dado como se fosse outro;
 Tentar utilizar um método ou classe não existentes.
Uma forma de tentar contornar esses imprevistos é realizar o tratamento dos locais no código
que podem vir a lançar possíveis exceções, como por exemplo, campo de consulta a banco de
dados, locais em que há divisões, consulta a arquivos de propriedades ou arquivos dentro do
próprio computador.
Para tratar as exceções em Java são utilizados os comandos try e catch.
Sintaxe:
try
{
//trecho de código que pode vir a lançar uma exceção
}
catch(tipo_exceçao_1 e)
{
//ação a ser tomada
}
{
Tratando exceções em Java 10

______________________________________________________________________________________________
}
catch(tipo_exceçao_n e)
{
}
Onde:
 try{ … } - Neste bloco são introduzidas todas as linhas de código que podem vir a lançar
uma exceção.
 catch(tipo_excessao e) { … } - Neste bloco é descrita a ação que ocorrerá quando a
exceção for capturada.
Tomando como exemplo uma classe que tem um método principal main que tem como seu único
objetivo alterar todas as letras de um frase para maiúsculas utilizando o método toUpperCase() da
classe String, caso a frase esteja nula e se tente usar o método toUpperCase() na mesma será
lançada uma exceção de NullPointerException.
Primeiro vamos ver como ficaria a tal classe sem a utilização do try/catch.
public class aumentaFrase {
public static void main(String args[])
{
String frase = null;
String novaFrase = null;
novaFrase = frase.toUpperCase();
System.out.println("Frase antiga: "+frase);
System.out.println("Frase nova: "+novaFrase);
}
}
Quando este código for executado, o mesmo lançará uma NullPointerException, como poder ser
visto na saída do console quando executamos tal programa.
Exception in thread "main" java.lang.NullPointerException
at aumentaFrase.main(aumentaFrase.java:15)
Ou seja, o mesmo tentou acessar um atributo de um objeto que estava nulo. Para ajudar a melhorar
a situação, deve-se usar o try/catch.
Reformulação do código com try-catch
{
try
{

______________________________________________________________________________________________
}
catch(NullPointerException e) //Captura da possível exceção.
{
//Tratamento da exceção
System.out.println("A fase inicial está nula, para solucionar tal problema, foi lhe
atribuído um valor default.");
frase = "Frase vazia";
}
}
Quando este código for executado, o mesmo lançará uma NullPointerException, porém esta
exceção será tratada desta vez, sendo a mesma capturada pelo catch{} e dentro deste bloco as
devidas providências são tomadas. Neste caso é atribuído um valor default à variável frase. A saída
deste programa seria a seguinte:
Saída do programa reformulado:
array4
Imagine a seguinte situação: foi aberta uma conexão com o banco de dados para realizar
determinada ação, e no meio deste processo seja lançada alguma exceção, como por exemplo,
NullPointerException ao tentar manipular um determinado atributo de um objeto. Neste caso seria
necessário que mesmo sendo lançada uma exceção no meio do processo a conexão fosse
fechada. Um outro exemplo bom seria a abertura de determinado arquivo para escrita no mesmo,
e no meio deste processo é lançada uma exceção por algum motivo, o arquivo não seria fechado,
o que resultaria em deixar o arquivo aberto.
Quando uma exceção é lançada e é necessário que determinada ação seja tomada mesmo
após a sua captura, utilizamos a palavra reservada finally.
Sintaxe de uso do bloco finally
try
{
//trecho de código que pode vir a lançar uma exceção
}
{
}
{
}
catch(tipo_exceçao _n e)
{

______________________________________________________________________________________________
}
finally
{
}
Programa aumetaFrase com bloco finally
public class aumentaFrase {
{
try
{
}
catch(NullPointerException e)
{
System.out.println("A frase inicial está nula, para solucionar tal problema, foi
lhe atribuído um valor default.");
frase = "Frase vazia";
}
finally
{
}
}
}
Quando este código fosse executado, o mesmo lançaria uma NullPointerException, porém
esta exceção será tratada desta vez, sendo a mesma capturada pelo catch{} e dentro deste bloco
as devidas providências são tomadas. Neste caso é atribuído um valor default à variável frase.
Neste exemplo, mesmo o código lançando uma exceção durante a sua execução e a mesma sendo
capturada pelo catch, uma determinada ação será tomada no bloco finally, neste caso tanto com a
exceção ou não será executada a linha “ novaFrase = frase.toUpperCase();”, tornando todas letras
da frase maiúsculas. A saída deste programa seria a seguinte:
Saída do programa com bloco finally
array4
Utilizando como exemplo uma situação em que não é desejado que uma exceção seja tratada na
própria classe ou método, mas sim em outro que venha lhe chamar. Para solucionar tal situação
utilizamos o comando throws na assinatura do método com a possível exceção que o mesmo

______________________________________________________________________________________________
poderá a vir lançar.
Sintaxe de declaração de método com definição de exceções
tipo_retorno nome_metodo() throws tipo_exceção_1, tipo_exceção_2, tipo_exceção_n
{
…
}
Onde:
 tipo_retorno – Tipo de retorno do método.
 nome_metodo() - Nome do método que será utilizado.
 tipo_exceção_1 a tipo_exceção_n – Tipo de exceções separadas por virgula que o seu
método pode vir a lançar.
Definição de exceções que um método pode gerar
public class TesteString {
private static void aumentarLetras() throws NullPointerException //lançando excessão
{
}
{
try
{
aumentarLetras();
}
{
System.out.println("Ocorreu um NullPointerException ao executar o método
aumentarLetras() "+e);
}
}
}
Neste exemplo será lançada uma exceção no método aumetarLetras():
Definição da exceção gerada pelo método aumentarLetras
private static void aumentarLetras() throws NullPointerException

______________________________________________________________________________________________
E o mesmo será tratado no método main().
Aplicação da exceção definida
...
try
{
aumentarLetras();
}
{
System.out.println("Ocorreu um NullPointerException ao executar o método
}
…
Saída do programa atualizado
Ocorreu um NullPointerException ao executar o método aumentarLetras()
java.lang.NullPointerException.
Agora imagine o caso em que seja necessário lançar uma exceção padrão ao invés de uma
especifica. Para resolver este problema, utilizamos o comando throw dentro do bloco catch que
desejamos converter a exceção.
Sintaxe de uso do comando throw:
try
{
//…
}
catch(tipoExcessão_1 e)
{
throw new novoTipoExceçao(e);
}
Onde:
 tipoExcessão_1 e – Tipo de exceção que pode ser capturada pelo bloco catch.
 NovoTipoExceçao – Tipo de exceção que será lançada.
Exemplo de uso do comando throw:
public class TesteString {
private static void aumentarLetras() throws Exception //lançando exceção
{
try
{

______________________________________________________________________________________________
}
{
throw new Exception(e);
}
}
{
try
{
aumentarLetras();
}
catch(Exception e)
{
System.out.println("Ocorreu uma exceão ao executar o método
}
}
}
Neste exemplo será lançada uma NullPointerException e a mesma será convertida para
Exception e relançada como Exception no método aumentarLetras() e, por fim, a mesma é tratada
no método main().
Saída do programa atualizada
Ocorreu uma exceção ao executar o método aumentarLetras() java.lang.Exception:
java.lang.NullPointerException
Assim como qualquer objeto, em Java também é possível criar suas próprias exceções.
Imagine um cenário em que nenhuma exceção existente faça sentido para ser lançada por você.
Por exemplo, imagine que por algum motivo você precisa que uma exceção seja lançada
quando a letra “B” ou “b” não existe e determinada frase, como não existe nenhuma exceção
específica para este caso será necessário criar uma exceção.
Criando uma exceção para ser lançada toda vez que uma letra “B” ou “B” não é encontrada em
uma determinada frase.
Exemplo de exceção customizada:
public class SemLetraBException extends Exception {
@Override
public String getMessage(){
return "Não existe letra B em sua frase";
}
}
Toda exceção criada deve estender Exception, neste exemplo foi sobrescrito o método

______________________________________________________________________________________________
getMessage(), que é exibida no prompt toda vez que a exceção é lançada.
A seguir é apresentado um exemplo que utilizada a exceção criada anteriormente.
Utilizando a exceção customizada:
public class TesteExcecao {
public static void main(String args[]) throws SemLetraBException
{
String frase = "Sou um teste!";
if(!frase.contains("b") || !frase.contains("B"))
throw new SemLetraBException();
}
}
Quando o programa acima fosse executado, uma exceção do tipo SemLetraBException() seria
lançada. Abaixo está a saída exibida no prompt:
Saída do método com a mensagem da exceção customizada:
Exception in thread "main" SemLetraBException: Não existe letra B ou b em sua frase at
TesteExcecao.main(TesteExcecao.java:8)
O tratamento de exceções em Java pode ser considerado bem simples e sua manipulação
pode ser feita de acordo com o que o programador deseja, desde tratá-la no próprio método ou
lança-la para ser tratada em um método que venha chamar o método que lança a exceção.
Muitos sistemas precisam manter as informações com as quais eles trabalham, seja para
permitir consultas futuras, geração de relatórios ou possíveis alterações nas informações. Para que
esses dados sejam mantidos para sempre, esses sistemas geralmente guardam essas informações
em um banco de dados, que as mantém de forma organizada e prontas para consultas.
A maioria dos bancos de dados comerciais são os chamados relacionais, que é uma forma
de trabalhar e pensar diferente ao paradigma orientado a objetos.
O MySQL é o banco de dados que usaremos durante o curso. É um dos mais importantes
bancos de dados relacionais, e é gratuito, além de ter uma instalação fácil para todos os sistemas
operacionais.
O processo de armazenamento de dados é também chamado de persistência. A biblioteca
de persistência em banco de dados relacionais do Java é chamada JDBC, e também existem
diversas ferramentas do tipo ORM (Object Relational Mapping) que facilitam bastante o uso do
JDBC. Neste momento, neste momento o foco esta nos conceitos e no uso do JDBC.
Conectar-se a um banco de dados com Java é feito de maneira elegante. Para evitar que
cada banco tenha a sua própria API e conjunto de classes e métodos, há um único conjunto de
interfaces muito bem definidas que devem ser implementadas. Esse conjunto de interfaces fica
dentro do pacote java.sql e referenciar como JDBC.
Conexão com banco de dados 11

______________________________________________________________________________________________
Entre as diversas interfaces deste pacote, existe a interface Connection que define métodos
para executar uma query (como um insert e select), comitar transação e fechar a conexão, entre
outros. Caso queiramos trabalhar com o MySQL, precisamos de classes concretas que
implementem essas interfaces do pacote java.sql.
Esse conjunto de classes concretas é quem fará a ponte entre o código cliente que usa a
API JDBC e o banco de dados. São essas classes que sabem se comunicar através do protocolo
proprietário do banco de dados. Esse conjunto de classes recebe o nome de driver. Todos os
principais bancos de dados do mercado possuem drivers JDBC para que você possa utilizá-los com
Java. O nome driver é análogo ao que usamos para impressoras: como é impossível que um
sistema operacional saiba conversar com todo tipo de impressora existente, precisamos de um
driver que faça o papel de "tradutor" dessa conversa.
Para abrir uma conexão com um banco de dados, é necessário utilizar sempre um driver. A
classe DriverManager é a responsável por se comunicar com todos os drivers que que estão
disponíveis. Para isso, invocamos o método estático getConnection com uma String que indica a
qual banco será estabelecida a conexão.
Essa String - chamada de String de conexão JDBC - que será utilizada para acessar o
MySQL tem sempre a seguinte forma:
jdbc:mysql://ip/nome_do_banco
o ip deve ser substituído pelo IP da máquina do servidor e nome_do_banco pelo nome do banco
de dados a ser utilizado.
Seguindo o exemplo da linha acima e tudo que foi dito até agora, seria possível rodar o
exemplo abaixo e receber uma conexão para um banco MySQL, caso ele esteja rodando na mesma
máquina:
public class JDBCExemplo {
public static void main(String[] args) throws SQLException {
Connection conexao = DriverManager.getConnection(
"jdbc:mysql://localhost/fj21");
System.out.println("Conectado!");

______________________________________________________________________________________________
conexao.close();
}
}
Repare que estamos deixando passar a SQLException, que é uma exceptionchecked,
lançada por muitos dos métodos da API de JDBC. Numa aplicação real devemos
utilizar try/catch nos lugares que julgamos haver possibilidade de recuperar de uma falha com o
banco de dados. Também precisamos tomar sempre cuidado para fechar todas as conexões que
foram abertas.
Ao testar o código acima, recebemos uma exception. A conexão não pôde ser aberta. Recebemos
a mensagem:
java.sql.SQLException: No suitable driver found for
jdbc:mysql://localhost/fj21
O sistema ainda não achou uma implementação de driver JDBC que pode ser usada para abrir a
conexão indicada pela URL jdbc:mysql://localhost/fj21.
O que precisamos fazer é adicionar o driver do MySQL ao classpath, o arquivo.jar contendo
a implementação JDBC do MySQL (mysql connector) precisa ser colocado em um lugar visível pelo
seu projeto ou adicionado à variável de ambiente CLASSPATH. Como usaremos o Eclipse, fazemos
isso através de um clique da direita em nosso projeto, Properties/Java Build Path e
em Librariesadicionamos o jar do driver JDBC do MySQL. Veremos isto passo a passo nos
exercícios.
Teoricamente, basta alterar as duas Strings que escrevemos para mudar de um banco para
outro. Porém, não é tudo tão simples assim! O código SQL que veremos a seguir pode funcionar
em um banco e não em outros. Depende de quão aderente ao padrão ANSI SQL é seu banco de
dados.
Isso só causa dor de cabeça e existem projetos que resolvem isso, como é o caso do
Hibernate (www.hibernate.org) e da especificação JPA (Java Persistence API). Veremos um pouco
do Hibernate ao final desse curso e bastante sobre ele no FJ-25.
11.1 Drivers de outros bancos de dados
Os drivers podem ser baixados normalmente no site do fabricante do banco de dados. Alguns
casos, como no Microsoft SQL Server, existem outros grupos que desenvolvem o driver
em http://jtds.sourceforge.net . Enquanto isso, você pode achar o driver do MYSQL (chamado
de mysql connector) no sitehttp://www.mysql.org.
11.2 Fábrica de Conexões
Em determinado momento de nossa aplicação, gostaríamos de ter o controle sobre a
construção dos objetos da nossa classe. Muito pode ser feito através do construtor, como saber
quantos objetos foram instanciados ou fazer o log sobre essas instanciações.
Às vezes, também queremos controlar um processo muito repetitivo e trabalhoso, como abrir
uma conexão com o banco de dados. Tomemos como exemplo a classe a seguir que seria
responsável por abrir uma conexão com o banco:
public class ConnectionFactory {

______________________________________________________________________________________________
public Connection getConnection() {
try {
return DriverManager.getConnection(
"jdbc:mysql://localhost/fj21", "root", "");
} catch (SQLException e) {
throw new RuntimeException(e);
}
}
}
Poderíamos colocar um aviso na nossa aplicação, notificando todos os programadores a adquirir
uma conexão:
Connection con = new ConnectionFactory().getConnection();
Note que o método getConnection() é uma fábrica de conexões, isto é, ele cria novas conexões
para nós. Basta invocar o método e recebemos uma conexão pronta para uso, não importando de
onde elas vieram e eventuais detalhes de criação. Portanto, vamos chamar a classe
de ConnectionFactory e o método degetConnection.
Encapsulando dessa forma, podemos mais tarde mudar a obtenção de conexões, para, por
exemplo, usar um mecanismo de pooling, que é fortemente recomendável em uma aplicação real.
O Java Persistence API é um framework para camada de persistência dos dados, que
fornece uma camada de comunicação entre a aplicação escrita em Java e o banco de dados.
Algumas facilidades que o JPA oferece são:
 Conversão de registros do banco de dados em objetos Java;
 Não necessita criar códigos SQL para salvar, alterar ou remover registros do banco de da-
dos;
 A aplicação não fica presa a um banco de dados sendo simples a troca.
Além disso, aumenta a produtividade dos desenvolvedores que utilizam o banco de dados,
Java Persistence API - JPA 12

______________________________________________________________________________________________
deixando de forma transparente a sua utilização, principalmente por não deixar a programação
Java vinculada a um tipo específico de banco de dados.
Para trazer as informações do banco de dados e convertê-las em classes Java, acaba sendo
um pouco trabalhoso. Quando é usado JDBC puro, há a necessidade de realizar o mapeamento
entre os atributos e colunas do banco de dados. Às vezes é necessário fazer uma conversão do
tipo de dado declarado no banco de dados com o tipo de dado utilizado na classe. O mesmo
processo ocorre quando os objetos Java são salvos no banco de dados.
O JPA utiliza o conceito de mapeamento objeto / relacional (ORM – Object / Relational
Mapping) para fazer ponte entre a base de dados relacional e os objetos Java. A figura a seguir,
mostra o próprio framework que realiza o relacionamento entre os atributos das classes Java com
a tabela do banco de dados.
O JPA cria uma instância da classe Produto para cada linha da tabela Produto, como
mostrado na figura a seguir, e também atribui os valores das propriedades da classe Produto de
acordo com os valores das colunas da tabela. Por padrão o JPA realizará o mapeamento da classe
e atributos com o mesmo nome.
12.1 Entity
Uma Entity (Entidade) é um objeto utilizado para representar uma tabela da base de dados,
sendo que cada instância da entidade corresponde a uma linha da tabela.
A Entity é baseada em uma simples classe Java do tipo Plain Old Java Object (POJO), por-
tanto, nada mais é do que uma classe Java comum, porém com anotações para fornecer informa-
ções mais especificas para o gerenciador das entidades. O exemplo a seguir é uma Entity que
representa um produto.

______________________________________________________________________________________________
package pbc.jpa.exemplo1.entity;
import java.io.Serializable;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Temporal;
import javax.persistence.TemporalType;
/**
* Classe utilizada para representar a tabela Produto.
*/
@Entity
public class Produto implements Serializable {
private static final long serialVersionUID = 4185059514364687794L;
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
private Long id;
private String descricao;
@Temporal(TemporalType.DATE)
private Date dataValidade;
private Double peso;
public Date getDataValidade() { return dataValidade; }
public void setDataValidade(Date dataValidade) {
this.dataValidade = dataValidade;
}
public String getDescricao() { return descricao; }
public void setDescricao(String descricao) {
this.descricao = descricao;
}
public Long getId() { return id; }
public void setId(Long id) { this.id = id; }
public Double getPeso() { return peso; }
public void setPeso(Double peso) { this.peso = peso; }
}
Neste exemplo é utilizada a anotação @Entity para definir está classe como uma entidade
do banco de dados. Utilizamos a anotação @Id para definir que o atributo Long id é chave primaria
da tabela Produto; também é definido que o atributo Long id tem seu valor gerado automatica-
mente através da anotação @GeneratedValue. Quando têm atributos que representam datas ou
tempos é necessário adicionar a anotação @Temporal para definir que o atributo Date dataVali-
dade é um campo do tipo Date no banco de dados.
O relacionamento feito entre a classe Java e a tabela do Banco de Dados, ocorre automati-
camente quando o nome da classe é igual ao nome da tabela; o mesmo vale para os atributos que
correspondem às colunas da tabela. Então, quando solicitar ao JPA para salvar, consultar, alterar
ou excluir uma entidade automaticamente será criado o Script SQL para executar a operação.
Esta classe está implementando a interface java.io.Serializable para informar que pode ser
serializada e trafegada pela rede de computadores. Quando as entidades fazem parte de uma apli-
cação console ou desktop não há necessidade de implementar esta interface, a não ser que a

______________________________________________________________________________________________
aplicação precise trafegar o objeto desta classe pela rede ou em algum HD. Quando implementada
esta interface também é preciso definir o atributo private static final long serialVersionUID com
um número longo, isto serve para identificar a classe quando o objeto for trafegar via rede.
Observação: o nome das tabelas no banco de dados não é case sensitive quando o banco de
dados é instalado no Windows, no caso do Linux já é case sensitive.
12.1.1 Anotações para Entity
As entidades podem ser melhor detalhadas adicionando mais algumas anotações e suas
propriedades. Estas anotações, podem informar ao JPA que por exemplo, uma entidade não segue
o padrão de nome igual ao da tabela, ou que sua tabela no banco possui um relacionamento de
Um-Para-Muitos com outra tabela, ou ainda, que a tabela utiliza um gerador de ID do tipo SE-
QUENCE para definir o número da chave primária e outras informações que veremos a seguir:
Obrigatoriamente toda entidade do JPA precisa ter pelo menos as anotações javax.persis-
tence.Entity que informa que é uma tabela do banco de dados e javax.persistence.Id que informa
qual o atributo é chave primária da tabela.
12.1.1.1 javax.persistence.Entity
Usado para definir que a classe é uma Entity, por padrão quando o nome da Entity é igual
ao nome da tabela o relacionamento é feito automaticamente pelo JPA. As propriedades da anota-
ção @Entity são listadas na tabela a seguir:
Propriedade Descrição
Name Informa o nome da entidade, por padrão o nome da entidade é nome
da classe. Este nome é utilizado para referenciar a entidade na
consulta.
12.1.1.2 javax.persistence.Table
Define o nome da tabela no banco de dados. As propriedades da anotação @Table são
listadas na tabela a seguir:
Catalog O catalogo da tabela.
Name O nome da tabela.
Schema O esquema da tabela.
uniqueConstraints Regras que podem ser adicionadas na tabela.
12.1.1.3 javax.persistence.Id
Informa o atributo da Entity que representa a chave primária.
12.1.1.4 javax.persistence.Column
Informa as configurações de coluna da tabela, por padrão quando o nome do atributo da
Entity é igual ao nome da coluna da tabela, o relacionamento é feito automaticamente pelo JPA. As
propriedades da anotação @Column são listadas na tabela a seguir:

______________________________________________________________________________________________
columnDefinition Definição do tipo da coluna.
insertable Informa se a tabela deve ser incluída no SQL de insert, por
padrão é true.
length Tamanho da coluna, por padrão é 255.
name Nome da tabela que contém está coluna, se não for informado
a coluna assume o nome da tabela da entity.
nullable Informa se o valor pode ser null.
precision Precisão da coluna decimal.
scale Número de casas decimais, usado somente em coluna com
número decimal.
table Nome da tabela que contém está coluna, se não for informado
assume o nome da tabela da entity.
unique Informa se a coluna é chave única.
updatable Informa se a coluna deve ser incluída no SQL de update, por
padrão é true.
12.1.1.5 javax.persistence.SequenceGenerator
Utilizado para representar uma sequência numérica gerada através do banco de dados. As
propriedades da anotação @SequenceGenerator são listadas na tabela a seguir:
name Nome único para o gerador que pode ser referenciado por uma
ou mais classes que pode ser utilizado para gerar valores de
chave primaria.
allocationSize A quantidade que será incrementada na sequence. O padrão é
50.
initialValue Valor inicial da sequence.
sequenceName Nome da sequence do banco de dados.
12.1.1.6 javax.persistence.GeneratedValue
Define a estratégia para criar o ID, que pode ser tipo AUTO (incrementa automaticamente 1,
2, 3 em sequência) ou SEQUENCE. As propriedades da anotação @GeneratedValue são listadas
na tabela a seguir:

______________________________________________________________________________________________
generator Nome do gerador da chave primaria que é especificado na
anotação @SequenceGenerator ou @TableGenerator.
strategy Estratégia de geração de chave primaria que o serviço de
persistência precisa usar para gerar a chave primaria. Seu valor
pode ser obtido através da enum
javax.persistence.GenerationType. Os valores podem ser: AUTO,
IDENTITY, SEQUENCE ou TABLE.
12.1.1.7 javax.persistence.Temporal
Utilizado para representar campos de Data e Hora. Nesta anotação podemos definir o tipo
de dado DATE, TIME e TIMESTAMP. As propriedades da anotação @Temporal são listadas na
tabela a seguir:
value O tipo usado para mapear java.util.Date é java.util.Calendar. Seu
valor pode ser obtido através da enum
javax.persistence.TemporalType. Os valores podem ser DATE:
TIME e TIMESTAMP.
12.1.1.8 javax.persistence.Transient
Informa que o atributo não é persistente.
No exemplo abaixo, será criado uma entity para tabela Usuario a seguir:
CREATE TABLE Usuario (
id NUMBER(10) NOT NULL PRIMARY KEY,
nome VARCHAR2(100) NOT NULL,
dataNasc DATE NOT NULL,
email VARCHAR2(150) NOT NULL,
ativo NUMBER(1) NOT NULL,
comentario VARCHAR2(200)
);
Crie a Entity para representar a tabela Usuario:
package pbc.jpa.exemplo1.entity;
import javax.persistence.Column;
/**

______________________________________________________________________________________________
* Entidade utilizada para representar um Usuario.
*/
@Entity
public class Usuario implements Serializable {
private static final long serialVersionUID = -8762515448728066246L;
@Id
private Long id;
@Column(nullable = false)
private String nome;
@Column(name="dataNasc", nullable = false)
private Date dataNascimento;
private String email;
private Boolean ativo;
private String comentario;
public Boolean getAtivo() { return ativo; }
public void setAtivo(Boolean ativo) {
this.ativo = ativo;
}
public String getComentario() { return comentario; }
public void setComentario(String comentario) {
this.comentario = comentario;
}
public Date getDataNascimento() {
return dataNascimento;
}
public void setDataNascimento(Date dataNascimento) {
this.dataNascimento = dataNascimento;
}
public String getEmail() { return email; }
public void setEmail(String email) {
this.email = email;
}
public String getNome() { return nome; }
public void setNome(String nome) { this.nome = nome; }
}
Foi utilizada a anotação @Entity para informar que a classe Usuario é uma entidade do
banco de dados; também foi definido que a propriedade Long id será o ID da tabela através da
anotação @Id e é informado que seu valor será gerado automaticamente com a anotação @Gene-
ratedValue. Por meio da anotação @Column é especificado quais os atributos não podem
ser null e que o atributo Date dataNascimento está mapeado para a coluna dataNasc da tabela
Usuario.

______________________________________________________________________________________________
12.2 EntityManager
O EntityManager é um serviço responsável por gerenciar as entidades. Por meio dele é pos-
sível gerenciar o ciclo de vida das entidades, as operações com a base de dados (inserir, atualizar
ou remover), a consulta de entidades, entre outras operações.
Quando uma entidade está associada a um EntityManager, esta entidade está no contexto
em que pode ser persistida, ou seja, que todas as operações realizadas no objeto da entidade são
refletidas no banco de dados. Todas as identidades das entidades são únicas, portanto para cada
registro no banco de dados haverá apenas uma referência no contexto do EntityManager.
O EntityManager pode ser gerenciado de duas formas:
 Gerenciado pelo Container;
 Gerenciado pela Aplicação.
12.3 Unidade de Persistência
A unidade de persistência é utilizada para configurar as informações referentes ao provedor
do JPA (implementação da especificação JPA) e ao banco de dados; também é possível identificar
as classes que serão mapeadas como entidades do banco de dados.
Para definir a unidade de persistência é necessário um arquivo XML chamado persis-
tence.xml, que deve ser criado na pasta META-INF do projeto. Por meio deste arquivo é possível
definir quantas unidades de persistência for necessário para o projeto. Exemplo de unidade de
persistência mapeado para um banco de dados:
<?xml version="1.0" encoding="UTF-8"?>
<persistence version="1.0"
xmlns="http://java.sun.com/xml/ns/persistence"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence
http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd">
<persistence-unit name="ExemploJPAPU" transaction-type ="RESOURCE_LOCAL">
<provider>org.hibernate.ejb.HibernatePersistence</provider>
<class>pbc.jpa.exercicio1.modelo.Livro</class>
<properties>
<property name="hibernate.connection.username” value="usuario"/>
<property name="hibernate.connection.password" value="senha"/>
<property name="hibernate.connection.driver_class" value="oracle.jdbc.driver.Oracle-
Driver"/>
<property name="hibernate.connection.url" value="jdbc:oracle:thin:@loca-
lhost:1521:XE"/>
<property name="hibernate.cache.provider_class" value="org.hibernate.cache.NoCa-
cheProvider"/>
<property name="hibernate.dialect" value="org.hibernate.dialect.Oracle9Dialect"/>
<property name="hibernate.show_sql" value="true"/>
</properties>
</persistence-unit>
</persistence>
Neste arquivo persistence.xml a tag persistence-unit define a unidade de persistência, e na
propriedade name qual seu nome (utilizado quando um EntityManager é criado por meio do Entity-
ManagerFactory no contexto Java SE ou quando é realizado injeção de dependência através da

______________________________________________________________________________________________
anotação javax.persistence.PersistenceUnit no contexto Java EE). A propriedade transaction-
type informa qual o tipo de transação (RESOURCE_LOCAL ou JTA). Se a aplicação é Java SE,
então, utilize o tipo de transação RESOURCE_LOCAL, assim programaticamente são criadas as
transações com o banco de dados e na aplicação Java EE utilize o JTA que acessa um pool de
conexões em um servidor web.
Em uma unidade de persistência utilize a tag provider para informar qual a API que fornecerá
uma implementação do JPA.
Em uma aplicação Java SE é necessário informar quais as classes são entidades do banco
de dados através da tag class e também informar quais as propriedades necessárias para encontrar
o banco de dados através da tag properties.
Nas aplicações Java EE é possível criar um pool de conexões com o banco de dados no
servidor web; neste caso é aconselhado utilizar o tipo de transação Java Transaction API
(JTA) que é fornecida pelo container EJB. Também é utilizada a tag jta-data-source para informar a
fonte do pool de conexões (nome JNDI). Exemplo de persistence.xml para aplicações Java EE:
<persistence-unit name="ExemploJPAPU" transaction-type="JTA">
<jta-data-source>jdbc/ExemplosJPA</jta-data-source>
<properties>
</properties>
</persistence-unit>
</persistence>
12.4 Criando uma unidade de persistência no NetBeans
O NetBeans possui uma forma mais simples de criação da unidade de persistência. Clique
com o botão direito no projeto e selecione a opção Novo -> Outro..., na tela de Novo arquivo se-
lecione a categoria Persistence e o tipo de arquivo Unidade de Persistência, conforme a figura a
seguir:

______________________________________________________________________________________________
Clique em Próximo > para definir as propriedades do banco de dados. Na tela de Provedor e
banco de dados digite um nome para a unidade de persistência, escolha qual a biblioteca de per-
sistência, defina a conexão com o banco de dados e qual a estratégia para geração de tabelas,
conforme a figura a seguir:
 O Arquivos da Unidade de Persistência é utilizado quando a EntityManager é criada. Por
meio deste nome o EntityManager encontrará as configurações do banco de dados.
 O Provedor de Persistência é a implementação do JPA utilizada para acessar o banco de
dados; neste exemplo é utilizado o framework Hibernate (JPA 2.0).
 Fonte de dados é a forma como será realizada a conexão com o banco de dados. Pode ser
feito de duas maneiras, criada uma conexão direta na aplicação ou criado um pool de cone-
xões no servidor.
Para criar uma nova conexão direta na aplicação clique na caixa de seleção Fonte de Dados e
escolha a opção Nova fonte de dados..., conforme apresentado na figura a seguir:

______________________________________________________________________________________________
Na tela de Criar fonte de dados informe um Nome JNDI. Esse nome é usado para referenciar a
conexão e também uma Conexão de banco de dados. Caso ainda não tenha uma conexão criada,
escolha na caixa de seleção Conexão de banco de dados a opção Nova Conexão de Banco de
Dados..., conforme apresentado na figura a seguir:
Na tela Assistente de Nova Conexão escolha o Driver chamado Oracle Thin, conforme apresen-
tado na figura a seguir:
Na primeira vez que ele é usado é preciso especificar o driver do banco de dados Oracle. Clique
em Adicionar e escolha o driver ojdbc6.jar, conforme a figura a seguir:

______________________________________________________________________________________________
Clique em Próximo para continuar a criação da conexão. Continuando a criação da Nova Conexão
escolha o Nome do Driver, defina o Host (IP), Porta, ID do Serviço, Nome do usuário e Senha,
conforme o exemplo da figura a seguir:
Clique em Testar Conexão caso queira validar se as informações da conexão estão corretas, de-
pois clique em Próximo para continuar e depois clique em Finalizar para terminar a criação da
conexão.
Durante o desenvolvimento de uma aplicação web que acessa banco de dados, pode ser
utilizado um pool de conexões que é criado pelo próprio servidor de aplicações web, ao invés de
criar uma conexão com o banco de dados direto na aplicação é necessário criar um pool de co-
nexões no servidor e depois escolher na Fonte de dados, conforme a figura a seguir:
Neste exemplo será escolhida uma Fonte de Dados que foi criada no servidor GlassFish.
A Estratégia de geração de tabelas permite:
 Criar - o JPA cria a estrutura de tabelas no banco de dados;

______________________________________________________________________________________________
 Apagar e criar – o JPA apaga a estrutura existente e cria uma estrutura nova das tabelas do
banco de dados;
 Nenhum – criar manualmente as tabelas do banco de dados.
Depois de criada a unidade de persistência, conforme apresentado na figura a seguir, note que esta
é uma versão visual do arquivo persistence.xml. OBS: caso você utilize o MYSQL os procedimentos
serão o mesmo, porem deverá substituir a fonte de dados pela do Mysql.
Este é o arquivo persistence.xml criado na pasta META-INF do projeto:
<persistence-unit name="ExemplosJPAPU" transaction-type="JTA">
<jta-data-source>jdbc/Oracle</jta-data-source>
<properties>
<property name="hibernate.dialect"
value="org.hibernate.dialect.Oracle9Dialect"/>
</properties>
</persistence-unit>
</persistence>
Para utilizar o Hibernate é necessário adicionar suas bibliotecas no projeto. Para fazer isso
clique com o botão direito no projeto e selecione a opção Propriedades, nesta tela selecione a

______________________________________________________________________________________________
categoria Bibliotecas, após isso clique no botão Adicionar biblioteca... e adicione as bibliote-
cas JPA do Hibernate, conforme a figura a seguir:
12.5 EntityManager gerenciado pela Aplicação
Nas aplicações Java SE é necessário controlar pela aplicação como deve ser criado o Enti-
tyManager, para isso precisamos fazer os seguintes passos:
1) Utilizando a classe javax.persistence.Persistence podemos utilizar o método createEntityMa-
nagerFactory() que recebe como parâmetro o nome da unidade de persistência (que veremos
mais adiante) que contém as informações sobre o banco de dados para criar uma javax.persis-
tence.EntityManagerFactory.
EntityManagerFactory factory =
Persistence.createEntityManagerFactory("UnitName");
2) Através do javax.persistence.EntityManagerFactory podemos utilizar o método createEntity-
Manager() para obtermos uma EntityManager.
EntityManager entityManager = factory.createEntityManager();
Exemplo:
package pbc.jpa.exemplo.dao;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;

______________________________________________________________________________________________
/**
* Classe utilizada para fazer realizar as operações
* de banco de dados sobre a entity Livro.
*/
public class DAO {
private EntityManager entityManager;
public EntityManager getEntityManager() {
EntityManagerFactory factory =
Persistence.createEntityManagerFactory("ExemplosJPAPU");
entityManager = factory.createEntityManager();
factory.close();
}
}
No exemplo dentro do método getEntityManager() criamos um EntityManagerFactory da
unidade de persistência ExemplosJPAPU através da classe Persistence, depois criamos um En-
tityManager a partir da factory. Quando terminamos de utilizar a EntityManagerFactory é impor-
tante chamar o método close() para liberar os recursos da factory.
12.6 EntityManager gerenciado pelo Container
No desenvolvimento de aplicações Java EE é possível deixar o contêiner EJB injetar a uni-
dade de persistência através da anotação javax.persistence.PersistenceContext.
package pbc.jpa.exemplo.ejb;
import javax.ejb.Stateless;
/**
* EJB utilizado para demonstrar o uso da injeção de
* dependência do EntityManager.
*/
@Stateless
public class ExemploBean implements ExemploRemote {
@PersistenceContext(unitName = "ExercicioJPA1PU")
private EntityManager entityManager;
}
Este exemplo mostra um componente Session Bean Stateless que utiliza a anotação @Persisten-
ceContext para adicionar uma unidade de persistência no EntityManager. Repare que não é pre-
ciso criar manualmente a EntityManager, pois o container EJB se encarrega de fazer isso e também
atribui seu objeto para a variável com a anotação. A anotação @PersistenceContext possui o atri-
buto unitName para informar que o nome da unidade de persistência é ExemplosJPAPU, definido
na tag persistence-unit do arquivo persistence.xml.

______________________________________________________________________________________________
12.7 Interface EntityManager
A interface javax.persistence.EntityManager possui a assinatura de métodos manipular as
entidades, executar consultas e outros:
public void persist(Object entity);
Faz uma nova instância gerenciável e persistivel.
entityManager.persist(pessoa);
Neste exemplo o método persist da EntityManager salva a entidade Pessoa no banco de dados.
public <T> T merge(T entity);
Junta o estado da Entity com o estado persistido, por exemplo:
entityManager.merge(pessoa);
Neste exemplo o método merge da EntityManager atualiza a entidade Pessoa no banco de dados.
public void remove(Object entity);
Remove a instância da Entity do banco de dados, por exemplo:
entityManager.remove(pessoa);
Neste exemplo o método remove da EntityManager exclui a entidade Pessoa no banco de dados.
public boolean contains(Object entity);
Verifica se a instância da Entity está em um estado persistível.
public <T> T find(Class<T> entityClass, Object primaryKey);
Procura um registro no banco de dados através da Entity e id (chave primária) da tabela, caso não
encontre retorna null, por exemplo:
Pessoa pessoa = entityManager.find(Pessoa.class, id);
Neste exemplo o método find da EntityManager pesquisa uma entidade pela sua classe e a chave
primária.
public <T> T getReference(Class<T> entityClass, Object primaryKey);
Procura um registro no banco de dados através da Entity e id da tabela, caso não encontre retorna
uma exceção javax.persistence.EntityNotFoundException.
public void flush();
Os métodos persist(), merge() e remove() aguardam a finalização da transação para sincronizar as
entidades com o banco de dados, o método flush() força esta sincronização no momento em que
é chamado.
public void refresh(Object entity);
Verifica se houve alguma alteração no banco de dados para sincronizar com a entidade.
public void clear();
Remove as entidades que estão no estado gerenciável dentro da EntityManager.
public void close();
Fecha a conexão do EntityManager.

______________________________________________________________________________________________
public boolean isOpen();
Verifica se o EntityManager está com a conexão aberta.
public EntityTransaction getTransaction();
Obtém uma javax.persistence.EntityTransaction que é uma transação com o banco de dados.
12.7.1 Ciclo de vida da Entity
Uma entidade do banco de dados pode passar por quatro estados diferentes que fazem
parte do seu ciclo de vida: novo, gerenciável, desacoplado e removido, conforme a figura a seguir:
Novo (new)
A Entity foi criada, mas ainda não foi persistida no banco de dados. Mudanças no estado da
Entity não são sincronizadas com o banco de dados.
Gerenciado (managed)
A Entity foi persistida no banco de dados e encontra-se em um estado gerenciável. Mudan-
ças no estado da Entity são sincronizadas com o banco de dados assim que uma transação for
finalizada com sucesso.
Removido (removed)
A Entity foi agendada para ser removida da base de dados, esta entidade será removida
fisicamente do banco de dados quando a transação for finalizada com sucesso.
Desacoplado (detached)
A Entity foi persistida no banco de dados, mas encontra-se em um estado que não está
associada ao contexto persistível, portanto as alterações em seu estado não são refletidas na base
de dados.
12.8 DAO (CRUD) utilizando JPA
Nesse exemplo, vamos criar uma aplicativo Java (console) chamado Exemplo, para salvar,
alterar, consultar por id e apagar um registro de pessoa, utilizaremos o banco de dados Oracle.
Observação: Lembre de adicionar as bibliotecas do Hibernate JPA e Oracle (ojdbc6.jar) no seu
projeto ou do Mysql.
Vamos criar uma Entity para representar a tabela Pessoa a seguir:
CREATE SEQUENCE PESSOA_SEQ INCREMENT BY 1
START WITH 1 NOCACHE NOCYCLE;

______________________________________________________________________________________________
CREATE TABLE Pessoa (
id NUMBER(5) NOT NULL,
dataNasc DATE NOT NULL,
email VARCHAR2(150),
PRIMARY KEY(ID)
);
Criando a entity para representar a tabela Pessoa:
package pbc.jpa.exemplo1.modelo;
import javax.persistence.SequenceGenerator;
/**
* Classe utilizada para representar uma pessoa.
*/
@Entity
@SequenceGenerator(name="PES_SEQ",
sequenceName="PESSOA_SEQ", allocationSize=1,
initialValue=1)
public class Pessoa implements Serializable {
@Id
@GeneratedValue(strategy=GenerationType.SEQUENCE,
generator="PES_SEQ")
private Long id;
@Column(name = "dataNasc", nullable = false)
private Date dataNascimento;
private String email;
public Date getDataNascimento() {
return dataNascimento;
}
public void setDataNascimento(Date dataNascimento) {
this.dataNascimento = dataNascimento;
}
public String getEmail() { return email; }
public void setEmail(String email) {
this.email = email;

______________________________________________________________________________________________
}
}
Vamos criar o arquivo persistence.xml. O NetBeans possui um wizard que permite de forma
fácil a criação desta unidade de persistência, para isto, clique com o botão direito do mouse no
nome do projeto, selecione a opção Novo -> Outro..., na tela de Novo arquivo selecione a cate-
goria Persistence e o tipo de arquivo Unidade de Persistência.
Na tela de Novo Unidade de persistência, informe:
 Nome da unidade de persistência: ExemplosJPAPU
 Biblioteca de persistência: Hibernate JPA (1.0)
 Conexão com o banco de dados: Aqui vamos criar uma nova conexão com o Oracle, então
selecione a opção Nova conexão com banco de dados...
Na tela Nova Conexão do Banco de Dados, selecione no campo Nome do driver a opção Novo
driver...
Na tela de Novo driver JDBC, clique em Adicionar... e procure pelo arquivo com o driver
do Oracle ou do Mysql (Caso esteja fazendo o uso desse banco), neste caso o arquivo ojdbc6.jar.
Após isso clique em OK para prosseguir.
Voltando na tela Nova Conexão do Banco de Dados, configure as seguintes informações:
 Modo de entrada de dados: Entrada direta de URL
 Nome do usuário: Informe seu usuário
 Senha do usuário: Informe sua senha
 URL JDBC: Para conectar no banco de dados utilize a URL jdbc:oracle:thin:@loca-
lhost:1521:XE ou outra de acordo com o local que foi instalado o seu banco de dados.
Clique em OK para prosseguir, a conexão com o banco de dados será testada e apresentará a
mensagem na tela “Conexão estabelecida”. Clique em OK para prosseguir.
Ao clicar em Finalizar será gerado o arquivo persistence.xml.
<persistence-unit name="ExemplosJPAPU"
transaction-type="RESOURCE_LOCAL">
<class>pbc.jpa.exemplo1.modelo.Pessoa</class>
<properties>
<property name="hibernate.connection.username"
value="usuario"/>

______________________________________________________________________________________________
<property name="hibernate.connection.password"
value="senha"/>
<property name="hibernate.connection.driver_class"
value="oracle.jdbc.driver.OracleDriver"/>
<property name="hibernate.connection.url"
value="jdbc:oracle:thin:@localhost:1521:XE"/>
<property name="hibernate.cache.provider_class"
value="org.hibernate.cache.NoCacheProvider"/>
</properties>
</persistence-unit>
</persistence>
Vamos criar uma classe PessoaDAO que possui os métodos para manipular (salvar, atualizar, apa-
gar e consultar por id) um objeto Pessoa.
import pbc.jpa.exemplo.modelo.Pessoa;
/**
* Classe utilizada para fazer realizar as operações de
* banco de dados sobre a entity Pessoa.
*/
public class PessoaDAO {
/**
* Método utilizado para obter o entity manager.
* @return
*/
private EntityManager getEntityManager() {
EntityManagerFactory factory = null;
EntityManager entityManager = null;
try {
//Obtém o factory a partir da unidade de persistência.
factory = Persistence.createEntityManagerFactory
("ExemplosJPAPU");
//Cria um entity manager.
//Fecha o factory para liberar os recursos utilizado.
} finally {
factory.close();
}
return entityManager;
}
/**

______________________________________________________________________________________________
* Método utilizado para salvar ou atualizar as
* informações de uma pessoa.
* @param pessoa
* @return
* @throws java.lang.Exception
*/
public Pessoa salvar(Pessoa pessoa) throws Exception {
EntityManager entityManager = getEntityManager();
try {
// Inicia uma transação com o banco de dados.
entityManager.getTransaction().begin();
System.out.println("Salvando a pessoa.");
/* Verifica se a pessoa ainda não está salva
no banco de dados. */
if(pessoa.getId() == null) {
entityManager.persist(pessoa);
} else {
pessoa = entityManager.merge(pessoa);
}
// Finaliza a transação.
entityManager.getTransaction().commit();
} finally {
entityManager.close();
}
return pessoa;
}
/**
* Método que apaga a pessoa do banco de dados.
* @param id
*/
public void excluir(Long id) {
try {
/* Consulta a pessoa na base de dados através
do seu ID. */
Pessoa pessoa = consultarPorId(id);
System.out.println("Excluindo a pessoa: "
+ pessoa.getNome());
// Remove a pessoa da base de dados.
entityManager.remove(pessoa);
} finally {
}
}
/**
* Consulta o pessoa pelo ID.

______________________________________________________________________________________________
* @param id
* @return o objeto Pessoa.
*/
public Pessoa consultarPorId(Long id) {
Pessoa pessoa = null;
try {
pessoa = entityManager.find(Pessoa.class, id);
} finally {
}
return pessoa;
}
}
O método salvar recebe o objeto Pessoa que será salvo, neste exemplo usaremos este método
para salvar uma nova pessoa ou atualizar os dados de uma pessoa.
Mas como sabemos quando temos que salvar e quando tem que atualizar, basta olhar o
atributo id da classe Pessoa, se o id for null significa que é um novo objeto que ainda não foi salvo
no banco de dados, então utilizaremos o método persist da EntityManager para salva-lo, caso o id
tenha algum valor então significa que o objeto já foi salvo anteriormente, portanto ele deve ser
atualizado então utilizaremos o método merge da EntityManager para atualiza-lo.
Note que como vamos salvar ou atualizar os dados, precisamos criar uma transação, com o
método getTransaction() do EntityManager obtemos um objeto EntityTransaction com ele pode-
mos iniciar a transação através do método begin(), finalizar a transação com sucesso através do
método commit() ou desfazer as alterações em caso de erro com o método rolback(). Este mesmo
conceito de transação será utilizado no método excluir.
O método excluir não precisa receber todos os dados da Pessoa, recebendo apenas o seu
ID através do parâmetro Long id, podemos utilizar o método find do EntityManager para consul-
tar os dados da Pessoa, depois com o objeto Pessoa consultado podemos usar o método re-
move do EntityManager para apagar os dados da Pessoa.
O método consultarPorId recebe um objeto Long chamado id, com o ID da tabela Pessoa,
utilizando o método find do EntityManager passamos a classe da entidade Pessoa.class e
seu id para que possamos consultar os dados da Pessoa.
Vamos criar uma classe PessoaDAOTeste para testarmos os métodos da classe PessoaDAO:
package pbc.jpa.exemplo1.teste;
import java.util.Calendar;
import java.util.GregorianCalendar;
import pbc.jpa.exemplo1.dao.PessoaDAO;
import pbc.jpa.exemplo1.modelo.Pessoa;
/**
* Classe utilizada para testar os métodos do PessoaDAO.
*/
public class PessoaDAOTeste {
public static void main(String[] args) throws Exception {
Pessoa pessoa = new Pessoa();

______________________________________________________________________________________________
pessoa.setId(1L);
pessoa.setNome("Rafael Sakurai");
Calendar data = new GregorianCalendar();
data.set(Calendar.YEAR, 1983);
data.set(Calendar.MONTH, 11);
data.set(Calendar.DAY_OF_MONTH, 26);
pessoa.setDataNascimento(data.getTime());
pessoa.setEmail("rafael.sakurai@metodista.br");
PessoaDAO dao = new PessoaDAO();
System.out.println("Salvando a pessoa: "
pessoa = dao.salvar(pessoa);
pessoa.setNome("Rafael Guimarães Sakurai");
pessoa = dao.salvar(pessoa);
System.out.println("Alterando a pessoa: "
Pessoa pessoa2 = dao.consultarPorId(pessoa.getId());
System.out.println("Consultando: " + pessoa2.getNome());
System.out.println("Removendo a pessoa: "
+ pessoa.getId());
dao.excluir(pessoa.getId());
}
}
Neste teste vamos criar um objeto pessoa e salva-lo, depois vamos altera o nome da pessoa, va-
mos consultar a pessoa pelo id e no final vamos apagar o registro da pessoa.
12.9 Estratégia de SEQUENCE para gerar ID
O banco de dados possui um tipo de objeto que pode ser criado internamente chamado
SEQUENCE (sequência) e que pode ser associado a um contador. Cada vez que o seu próximo
valor é solicitado ocorre um incremento deste valor. Para gerar o ID da entidade é possível utilizar
a estratégia de SEQUENCE também, associando a sequência criada no banco de dados com o
gerador de ID.
No exemplo, a seguir, será criada uma entidade que utiliza uma SEQUENCE para gerar o id
referente a chave primária da tabela. Primeiro será criada a sequência USUARIO_SEQ no banco
de dados:
CREATE SEQUENCE USUARIO_SEQ INCREMENT BY 1 START WITH 1 NOCACHE NOCYCLE;
A seguir, crie a entidade Usuario que utilizará está sequência para gerar o ID.
package pbc.jpa.exemplo.sequence.modelo;

______________________________________________________________________________________________
import javax.persistence.Table;
/**
* Classe utilizada para demonstrar o uso da SEQUENCE.
*/
@Entity
@Table(name = "USUARIO")
@SequenceGenerator(name="USU_SEQ", sequenceName="USUARIO_SEQ",
initialValue=1, allocationSize=1)
public class Usuario implements Serializable {
private static final long serialVersionUID
= -4023522856316087762L;
@Id
@GeneratedValue(strategy = GenerationType.SEQUENCE,
generator = "USU_SEQ")
private Long id;
}
A anotação @SequenceGenerator vai indicar qual a sequência do banco de dados, qual o valor
inicial e a quantidade que esta sequência é incrementada.
 name = informa o apelido da sequence exemplo "USU_SEQ";
 sequenceName = informa o nome da sequência criada no banco de dados, por exemplo:
"USUARIO_SEQ";
 initialValue = informa o valor inicial da sequência, por exemplo: 1;
 allocationSize = informa a quantidade que será incrementada na sequência, o padrão (de-
fault) é 50, neste exemplo foi definido que será incrementado de 1 em 1.
A anotação @GeneratedValue nesse caso está usando a estratégia de SEQUENCE então ele vai
procurar a sequência que tem o apelido "USU_SEQ" e faz uma consulta no banco para pegar seu
resultado:
SELECT USUARIO_SEQ.NEXTVAL FROM DUAL;
 strategy = informa o tipo de estratégia que será utilizado nesse exemplo Generation-
Type.SEQUENCE;
 generator = informa o apelido da sequence nesse exemplo "USU_SEQ".

______________________________________________________________________________________________
12.10 Utilizando chave composta
A chave composta define que vários atributos serão utilizados para definir a chave de uma
entidade, com isso, acabamos tendo uma restrição onde os atributos da chave composta não po-
dem ser repetidos.
No JPA quando precisamos definir uma chave composta precisamos criar uma classe sepa-
rada apenas com os atributos que fazem parte da chave composta e precisamos utilizar a anota-
ção javax.persistence.Embeddable.
Neste exemplo vamos criar uma entidade Telefone que possui uma chave composta pelos
atributos ddd e número do telefone, pois não pode ter o mesmo número de telefone para mais de
1 cliente.
Para declarar a chave composta vamos criar uma classe chamada TelefonePK com os atri-
butos ddd e numero:
package pbc.jpa.exemplo.chave.composta.modelo;
import javax.persistence.Embeddable;
/**
* Esta classe representa a composição da chave do
* telefone, está chave é composta por ddd + numero
* do telefone.
*/
@Embeddable
public class TelefonePK implements Serializable {
= -637018809489152388L;
private Short ddd;
private String numero;
public Short getDdd() { return ddd; }
public void setDdd(Short ddd) { this.ddd = ddd; }
public String getNumero() { return numero; }
public void setNumero(String numero) {
this.numero = numero;
}
@Override
public String toString() {
return "("+ getDdd() + ") " + getNumero();
}
}
Observação: Sobrescrevi o método toString() para imprimir de forma mais amigável a chave com-
posta.
Note que adicionamos a anotação @Embeddable na classe TelefonePK para informar que
está classe será adicionado em outra entidade.

______________________________________________________________________________________________
Para adicionarmos a chave composta na entidade, vamos criar um atributo do tipo da classe
que possui a anotação @Embeddable e vamos adicionar a anotação javax.persistence.Em-
beddedId neste atributo.
Na entidade Telefone vamos declarar um atributo chamado id do tipo TelefonePK para re-
presentar a chave composta:
package pbc.jpa.exemplo.chave.composta.modelo;
import javax.persistence.EmbeddedId;
/**
* Classe utilizada para representar o telefone de um cliente.
* Nesta classe abordamos o uso da chave composta através
* da anotação @EmbeddedId.
*/
@Entity
public class Telefone implements Serializable {
= 5999236902534007386L;
@EmbeddedId
private TelefonePK id;
private String cliente;
public String getCliente() { return cliente; }
public void setCliente(String cliente) {
this.cliente = cliente;
}
public TelefonePK getId() { return id; }
public void setId(TelefonePK id) { this.id = id; }
}
Agora vamos criar a classe TelefoneDAO para executar as operações de Salvar, Alterar,
Consultar por chave composta e apagar o telefone:
package pbc.jpa.exemplo.chave.composta.dao;
import javax.persistence.EntityExistsException;
import pbc.jpa.exemplo.chave.composta.modelo.Telefone;
import pbc.jpa.exemplo.chave.composta.modelo.TelefonePK;
/**
* Classe utilizada para testar as operações Salvar,
* Altera, Consultar por Id e Apagar o registro de
* um telefone.
*/
public class TelefoneDAO {

______________________________________________________________________________________________
try {
("ExemplosJPAPU");
} finally {
factory.close();
}
}
public Telefone consultarPorId(TelefonePK id) {
Telefone telefone = null;
try {
telefone = entityManager.find(Telefone.class, id);
} finally {
}
return telefone;
}
public Telefone salvar(Telefone telefone)
throws Exception {
try {
entityManager.persist(telefone);
entityManager.flush();
/*Esta exceção pode ser lançada caso já exista um registro
com a mesma chave composta. */
} catch (EntityExistsException ex) {
entityManager.getTransaction().rollback();
throw new Exception("Este telefone já está registrado
para outro cliente.");
} catch (Exception ex) {
} finally {
}
return telefone;
}
public Telefone atualizar(Telefone telefone)

______________________________________________________________________________________________
throws Exception {
try {
entityManager.merge(telefone);
} finally {
}
return telefone;
}
public void apagar(TelefonePK id) {
try {
Telefone telefone = entityManager.find(Telefone.class,
id);
entityManager.remove(telefone);
} finally {
}
}
}
No método consultarPorId precisamos agora passar um atributo da chave composta Tele-
fonePK para que possamos localizar um telefone.
No método salvar vamos receber o objeto Telefone que será salvo, note que estamos tra-
tando a exceção javax.persistence.EntityExitsException que será lançada caso tentamos salvar
duas entidades com o mesmo id, neste caso com o mesmo ddd e número de telefone.
Criamos agora um método atualizar separado apenas para atualizar o telefone, pois pode-
mos criar um Telefone e alterar o nome do cliente, mas não podemos criar dois telefones com o
mesmo ddd e número de telefone.
No método apagar precisamos receber um objeto que representa a chave composta Tele-
fonePK, desta forma podemos localizar o objeto Telefone para que possamos apagá-lo.
Nesta classe TelefoneDAOTeste vamos testar todas as operações da classe TelefoneDAO
declarada acima:
package pbc.jpa.exemplo.chave.composta.dao;
import pbc.jpa.exemplo.chave.composta.modelo.Telefone;
import pbc.jpa.exemplo.chave.composta.modelo.TelefonePK;

______________________________________________________________________________________________
/**
* Classe utilizada para testar as operações da
* classe TelefoneDAO.
*/
public class TelefoneDAOTeste {
public static void main(String[] args) throws Exception {
/* Cria uma chave composta. */
TelefonePK pk = new TelefonePK();
pk.setDdd((short) 11);
pk.setNumero("1111-1111");
/* Cria um telefone. */
Telefone tel = new Telefone();
tel.setId(pk);
tel.setCliente("Sakurai");
TelefoneDAO dao = new TelefoneDAO();
System.out.println("Salvando o telefone: " + pk);
dao.salvar(tel);
System.out.println("Consultando o telefone: " + pk);
Telefone tel2 = dao.consultarPorId(pk);
System.out.println("Cliente " + tel2.getCliente());
try {
System.out.println("Tentando salvar o mesmo número
de telefone para outro cliente.");
Telefone tel3 = new Telefone();
tel3.setId(pk);
tel3.setCliente("Rafael");
dao.salvar(tel3);
System.out.println(ex.getMessage());
}
System.out.println("Alterando o cliente:");
tel.setCliente("Rafael");
dao.atualizar(tel);
System.out.println("Apagando o registro do telefone:");
dao.apagar(pk);
}
}
Exercícios:
Neste exercício vamos abordar como criar uma aplicação CRUD (salvar, alterar, consultar e
excluir) do Livro utilizando o Java Persistence API.
Crie o seguinte banco de dados:
CREATE SEQUENCE LIVRO_SEQ INCREMENT BY 1
CREATE TABLE Livro (
id number(5) NOT NULL,

______________________________________________________________________________________________
titulo varchar2(200) NOT NULL,
autor varchar2(200) NOT NULL,
isbn varchar2(50) NOT NULL,
paginas number(5) NOT NULL,
preco number(10,2) NOT NULL,
PRIMARY KEY(id)
);
Crie um Projeto Java chamado ExercicioJPA1, adicione as bibliotecas Hibernate JPA e Driver
da Oracle (ojdbc6.jar ou ojdbc7.jar) ou Driver do Mysql e crie:
 Uma classe entity para representar um Livro com os atributos id, titulo, autor, isbn, paginas
e preco.
package pbc.jpa.exercicio1.modelo;
/**
* Classe utilizada para representar uma Entity Livro.
*/
@Entity
@SequenceGenerator(name = "LIVRO_SEQ",
sequenceName = "LIVRO_SEQ", initialValue = 1,
allocationSize = 1)
public class Livro implements Serializable {
= 2405106626392673061L;
@Id
generator = "LIVRO_SEQ")
private Long id;
private String titulo;
private String autor;
private String isbn;
private Integer paginas;
private Double preco;
public String getAutor() { return autor; }

______________________________________________________________________________________________
public void setAutor(String autor) {
this.autor = autor;
}
public String getIsbn() { return isbn; }
public void setIsbn(String isbn) { this.isbn = isbn; }
public Integer getPaginas() { return paginas; }
public void setPaginas(Integer paginas) {
this.paginas = paginas;
}
public Double getPreco() { return preco; }
public void setPreco(Double preco) {
this.preco = preco;
}
public String getTitulo() { return titulo; }
public void setTitulo(String titulo) {
this.titulo = titulo;
}
}
 Crie uma classe LivroDAO com os seguintes métodos:
o getEntityManager() – que cria um EntityManager
o salvar() – chame o método do EntityManager que realize a operação de salvar ou
alterar um livro.
o consultarPorId() – chame o método do EntityManager que realize a operação de
consultar passando o atributo da chave primaria.
o excluir() – chame o método do EntityManager que realize a operação de remover
um livro.
package pbc.jpa.exercicio1.dao;
import pbc.jpa.exercicio1.modelo.Livro;
/**
* Classe utilizada para fazer realizar as operações de
* banco de dados sobre a entity Livro.
*/
public class LivroDAO {

______________________________________________________________________________________________
/**
* @return
*/
try {
//Obtém o factory a partir da unidade de persistência.
("ExercicioJPA1PU");
//Fecha o factory para liberar os recursos utilizado.
} finally {
factory.close();
}
}
/**
* Método utilizado para salvar ou atualizar as
* informações de um livro.
* @param livro
* @return
*/
public Livro salvar(Livro livro) throws Exception {
try {
System.out.println("Salvando o livro.");
/* Verifica se o livro ainda não está salvo
if(livro.getId() == null) {
entityManager.persist(livro);
} else {
livro = entityManager.merge(livro);
}
} finally {
}
return livro;
}
/**
* Método que exclui o livro do banco de dados.
* @param id
*/
public void excluir(Long id) {

______________________________________________________________________________________________
try {
// Consulta o livro na base de dados através do seu ID.
Livro livro = entityManager.find(Livro.class, id);
System.out.println("Excluindo o livro: "
+ livro.getTitulo());
// Remove o livro da base de dados.
entityManager.remove(livro);
} finally {
}
}
/**
* Consulta o livro pelo ID.
* @param id
* @return
*/
public Livro consultarPorId(Long id) {
Livro livro = null;
try {
livro = entityManager.find(Livro.class, id);
} finally {
}
return livro;
}
}
Vamos criar um arquivo persistence.xml dentro da pasta META-INF para guardar as configura-
ções do banco de dados. Neste arquivo também vamos informar a Entity Livro.
<persistence-unit name="ExercicioJPA1PU"
<class>pbc.jpa.exercicio1.modelo.Livro</class>
<properties>
value="usuario"/>

______________________________________________________________________________________________
value="senha"/>
</properties>
</persistence-unit>
</persistence>
Para testar as operações sobre a entidade Livro, vamos criar a classe LivroTeste que utiliza o
LivroDAO para fazer uso da EntityManager para gerenciar a entity Livro.
package pbc.jpa.exercicio1.teste;
import pbc.jpa.exercicio1.dao.LivroDAO;
import pbc.jpa.exercicio1.modelo.Livro;
/**
* Classe utilizada para testar a persistência da
* entity Livro.
*/
public class LivroTeste {
try {
Livro livro = new Livro();
livro.setAutor("Rafael Guimarães Sakurai");
livro.setIsbn("111-11-1111-111-1");
livro.setPaginas(439);
livro.setPreco(30.90);
livro.setTitulo("Guia de estudos SCJA.");
LivroDAO dao = new LivroDAO();
livro = dao.salvar(livro);
System.out.println("ID do livro salvo: "
+ livro.getId());
/*
* PARA FAZER - Teste a consulta, alteração
* e exclusão do livro.
*/
ex.printStackTrace();
}
}
}
Agora só testar e terminar de implementar.

______________________________________________________________________________________________
Exericios:
1) Crie uma aplicação Swing utilizando JPA para fazer o CRUD (salvar, alterar, consultar e excluir)
da tabela Produto a seguir:
CREATE TABLE Produto (
id number(5) NOT NULL PRIMARY KEY,
nome varchar2(200) NOT NULL,
preco number(10,2) NOT NULL,
dataValidade date,
qtdEstoque number(5)
);
2) Crie uma aplicação Swing ou Console utilizando o JPA para fazer o CRUD (salvar, consultar,
alterar e excluir) de duas entidades a sua escolha.
12.11 Relacionamento entre entidades
Os relacionamentos também podem ser:
Unidirecional
A partir de uma entidade, é possível encontrar outra entidade, mas o contrario não acontece,
nesse exemplo a Entidade A conhece a Entidade B, mas o contrario não acontece.
Bidirecional
Ambas entidades se conhecem, nesse exemplo a Entidade A conhece a Entidade B e vice-
versa.
Esses relacionamentos são definidos de acordo com a necessidade do negocio, não existe uma
regra que sempre tem que ser unidirecional ou bidirecional.
12.12 Os quatro tipos de cardinalidade
Um-para-Um (OneToOne) - Este relacionamento informa que há apenas um registro da
entidade relacionado com um registro de outra entidade.
Exemplo de relacionamento Um-para-Um unidirecional:
Script do banco de dados:
CREATE TABLE Mensagem (
id number(5) NOT NULL PRIMARY_KEY,
assunto varchar2(200) NOT NULL,
dataEnvio date NOT NULL,
mensagemcorpo_id number(5)
);

______________________________________________________________________________________________
CREATE TABLE MensagemCorpo (
descricao varchar2(200)
);
Modelo UML:
Neste exemplo definimos que uma Mensagem possui uma MensagemCorpo, então desta
forma a Mensagem sabe qual é seu MensagemCorpo, mas o contrario não existe, a Mensa-
gemCorpo não tem a necessidade de conhecer qual a Mensagem está associado a ele, ou seja,
temos um relacionamento unidirecional.
Primeiramente podemos mostrar apenas uma listagem de Mensagens, mas não tem neces-
sidade por enquanto de mostrar o conteúdo de todas as mensagens e depois caso eu queira ler o
conteúdo da mensagem podemos através dela chegar até seu corpo utilizando o atributo do tipo
MensagemCorpo.
Código fonte das classes com o relacionamento:
package pbc.jpa.exemplo.modelo;
import javax.persistence.CascadeType;
import javax.persistence.OneToOne;
/**
* Classe utilizada para representar uma Mensagem.
*/
@Entity
public class Mensagem implements Serializable {
= 1912492882356572322L;
@Id
private Long id;

______________________________________________________________________________________________
private String assunto;
private Date dataEnvio;
@OneToOne(cascade=CascadeType.ALL)
private MensagemCorpo mensagemCorpo;
public String getAssunto() { return assunto; }
public void setAssunto(String assunto) {
this.assunto = assunto;
}
public Date getDataEnvio() { return dataEnvio; }
public void setDataEnvio(Date dataEnvio) {
this.dataEnvio = dataEnvio;
}
public MensagemCorpo getMensagemCorpo() {
return mensagemCorpo;
}
public void setMensagemCorpo(MensagemCorpo mensagemCorpo) {
this.mensagemCorpo = mensagemCorpo;
}
}
Na classe Mensagem utilizamos a anotação javax.persistence.OneToOne para definir o relacio-
namento de um-para-um entre as classes Mensagem e MensagemCorpo.
/**
* Classe utilizada para representar o corpo de uma
* mensagem.
*/
@Entity
public class MensagemCorpo implements Serializable {
= 986589124772488369L;
@Id
private Long id;

______________________________________________________________________________________________
}
}
A classe MensagemCorpo é uma entidade normal que não conhece a classe Mensagem.
Note que não precisamos criar nenhuma referencia para informar que o
atributo mensagemCorpo da classe Mensagem referencia a coluna mensagemcorpo_id da tabela
Mensagem.
O JPA possui alguns padrões para facilitar o mapeamento entre a classe Java e a tabela do
banco de dados, quando criamos uma coluna de chave estrangeira seguindo o padrão nometa-
bela_chaveprimaria, o mapeamento é feito automaticamente pelo JPA, ou seja, o atributo Mensa-
gemCorpo mensagemCorpo é automaticamente associado com a coluna mensagemcorpo_id.
javax.persistence.OneToOne - Esta anotação define uma associação com outra entidade que
tenha a multiplicidade de um-para-um. A tabela a seguir mostra as propriedades da anotação
@OneToOne.
cascade As operações que precisam ser refletidas no alvo da associação.
fetch Informa se o alvo da associação precisa ser obtido apenas quando
for necessário ou se sempre deve trazer.
mappedBy Informa o atributo que é dono do relacionamento.
optional Informa se a associação é opcional.
targetEntity A classe entity que é alvo da associação.
Quando precisamos especificar um mapeamento que não é padrão do JPA, podemos utilizar a
anotação javax.persistence.JoinColumn, por exemplo se a tabela Mensagem e MensagemCorpo
fossem:
CREATE TABLE Mensagem (
assunto varchar2(200),
dataEnvio date,
ID_MENSAGEMCORPO number(5)
);
CREATE TABLE MensagemCorpo (

______________________________________________________________________________________________
MC_ID number(5) NOT NULL PRIMARY_KEY,
descricao varchar2(200)
);
Poderíamos utilizar o JoinColumn para criar a associação:
@JoinColumn(name="ID_MENSAGEMCORPO", referencedColumnName="MC_ID")
javax.persistence.JoinColumn - esta anotação é utilizada para especificar a coluna utilizada na
associação com outra entity. A tabela a seguir apresenta as propriedades da anotação @JoinCo-
lumn.
columnDefinition Definição do tipo da coluna.
insertable Informa se a coluna é incluída no SQL de INSERT.
name Informa o nome da coluna de chave estrangeira.
nullable Informa se a coluna pode ser null.
referencedColumnName Nome da coluna que é referenciada pela coluna da
chave estrangeira.
table Nome da tabela que contém a coluna.
unique Informa se a propriedade é chave única.
updatable Informa se a coluna é incluída no SQL de UPDATE.
Um-para-Muitos (OneToMany) - Este relacionamento informa que o registro de uma entidade está
relacionado com vários registros de outra entidade.
Exemplo de relacionamento Um-para-Muitos unidirecional:
CREATE TABLE Aula (
data date NOT NULL
);
CREATE TABLE Tarefa (
descricao varchar2(45) NOT NULL,
aula_id number(5)
);

______________________________________________________________________________________________
Modelo UML:
Neste exemplo definimos que uma Aula possui uma lista de Tarefa, portanto a aula pode não ter
tarefa, pode ter apenas uma tarefa ou pode ter varias tarefas, uma Tarefa não precisa saber de
qual Aula ela está associada, portanto temos um relacionamento unidirecional.
Na classe Aula utilizamos a anotação javax.persistence.OneToMany no atributo tarefas, para in-
formar que uma Aula está associada com várias tarefas.
import java.util.List;
import javax.persistence.JoinColumn;
import javax.persistence.OneToMany;
/**
* Classe utilizada para representar uma aula.
*/
@Entity
public class Aula implements Serializable {
= -6745032908099856302L;
@Id
private Long id;
private Date data;
@OneToMany(cascade = CascadeType.ALL)
@JoinColumn(name="aula_id")

______________________________________________________________________________________________
private List<Tarefa> tarefas;
public Date getData() { return data; }
public void setData(Date data) { this.data = data; }
}
public List<Tarefa> getTarefas() { return tarefas; }
public void setTarefas(List<Tarefa> tarefas) {
this.tarefas = tarefas;
}
}
javax.persistence.OneToMany - esta anotação define uma associação com outra entidade que
tenha a multiplicidade de um-para-muitos.
fetch Informa se o alvo da associação precisa ser obtido apenas quando for
necessário ou se sempre deve trazer.
A classe Tarefa é uma entidade normal que não conhece a classe Aula.
import javax.persistence.ManyToOne;
/**
* Classe utilizada para representar as tarefas
* aplicadas em uma aula.
*/
@Entity
public class Tarefa implements Serializable {
@Id

______________________________________________________________________________________________
private Long id;
}
}
}
Muitos-para-Um (ManyToOne) - este relacionamento informa que existem muitos registros de uma
entidade associados a um registro de outra entidade.
Exemplo de relacionamento Um-para-Muitos e Muitos-para-Um bidirecional:
cpf varchar2(11) NOT NULL
);
CREATE TABLE Telefone (
tipo varchar2(200) NOT NULL,
numero number(8) NOT NULL,
pessoa_id number(5)
);
Modelo UML:

______________________________________________________________________________________________
Neste exemplo definimos que uma Pessoa possui uma lista de Telefones e um Telefone está as-
sociado a uma Pessoa, portanto temos um relacionamento bidirecional.
Na entidade Pessoa definimos que uma pessoa possui vários telefones através do atri-
buto List<Telefone> telefones e adicionamos a anotação javax.persistence.OneToMany para in-
formar que o relacionamento de Pessoa para Telefone é de Um-para-Muitos, note que nesta ano-
tação definimos a propriedade mappedBy como "pessoa" que é para informar que o atributo com
o nome pessoa na entity Telefone que é dona do relacionamento.
/**
* Classe utilizada para representar uma Pessoa.
*/
@Entity
= -1905907502453138175L;
@Id
private Long id;
private String cpf;
@OneToMany(mappedBy="pessoa", cascade=CascadeType.ALL)
private List<Telefone> telefones;
public String getCpf() { return cpf; }
public void setCpf(String cpf) { this.cpf = cpf; }
public List<Telefone> getTelefones() { return telefones; }
public void setTelefones(List<Telefone> telefones) {
this.telefones = telefones;
}
}

______________________________________________________________________________________________
Na entidade Telefone definimos o atributo Pessoa pessoa e adicionamos a anotação ja-
vax.persistence.ManyToOne para definir que o relacionamento de Telefone para Pessoa é de
Muitos-para-Um.
/**
* Classe utilizada para representar um Telefone.
*/
@Entity
= 7526502149208345058L;
@Id
private Long id;
private String tipo;
private Integer numero;
@ManyToOne
private Pessoa pessoa;
public Integer getNumero() { return numero; }
public void setNumero(Integer numero) {
}
public Pessoa getPessoa() { return pessoa; }
public void setPessoa(Pessoa pessoa) {
this.pessoa = pessoa;
}
public String getTipo() { return tipo; }
public void setTipo(String tipo) { this.tipo = tipo; }
}
javax.persistence.ManyToOne - esta anotação define uma associação com outra entidade que
tenha a multiplicidade de muitos-para-um.

______________________________________________________________________________________________
Fetch Informa se o alvo da associação precisa ser obtido apenas quando for
necessário ou se sempre deve trazer.
optional Informa se a associação é opcional.
Também podemos adicionar uma tabela para realizar o relacionamento unidirecional de um-
para-muitos e o relacionamento muitos-para-muitos, normalmente utilizamos está alternativa como
uma forma de normalizar os dados evitando duplicar o conteúdo dos registros.
Nesse exemplo queremos utilizar a entidade Telefone com as entidades Pessoa e Aluno,
dessa forma Pessoa possui uma lista de Telefones e Aluno possui uma lista de Telefones, mas o
telefone não sabe para quem ele está associado. Este tipo de relacionamento é unidirecional de
um-para-muitos.
Na base de dados iremos criar as tabelas Pessoa, Telefone e Aluno, também iremos criar duas
tabelas de associação chamadas Pessoa_Telefone e Aluno_Telefone:
cpf varchar2(11) NOT NULL
);
CREATE TABLE Aluno (
matricula number(5) NOT NULL
);
CREATE TABLE Telefone (
tipo varchar2(200) NOT NULL,
numero number(5) NOT NULL
);
CREATE TABLE Pessoa_Telefone (
pessoa_id number(5),
telefone_id number(5)
);
CREATE TABLE Aluno_Telefone (

______________________________________________________________________________________________
aluno_id number(5),
telefone_id number(5)
);
Na entidade Pessoa definimos que uma pessoa possui vários telefones através do atri-
formar que o relacionamento de Pessoa para Telefone é de Um-para-Muitos.
Para informar que vamos utilizar a tabela PESSOA_TELEFONE para realizar a associação
entre as tabelas PESSOA e TELEFONE utilizamos a anotação javax.persistence.JoinTable.
Para informar que a coluna PESSOA_ID da tabela PESSOA_TELEFONE é a coluna chave
estrangeira para a tabela PESSOA e para informar que a coluna TELEFONE_ID da tabela PES-
SOA_TELEFONE é a chave estrangeira para a tabela TELEFONE utilizamos a anotação ja-
vax.persistence.JoinColumn.
import javax.persistence.FetchType;
import javax.persistence.JoinTable;
/**
* Classe utilizada para representar uma Pessoa.
*/
@Entity
= -1905907502453138175L;
@Id
private Long id;
private String cpf;
@OneToMany(cascade=CascadeType.ALL, fetch=FetchType.EAGER)
@JoinTable(name="PESSOA_TELEFONE",
joinColumns={@JoinColumn(name = "PESSOA_ID")},
inverseJoinColumns={@JoinColumn(name = "TELEFONE_ID")})
public String getCpf() { return cpf; }
public void setCpf(String cpf) { this.cpf = cpf; }

______________________________________________________________________________________________
}
}
javax.persistence.JoinTable - esta anotação é utilizada para definir uma tabela que será utilizada
na associação de um-para-muitos ou de muitos-para-muitos.
catalog O catalogo da tabela.
inverseJoinColumns Chave estrangeira para realizar a associação com a tabela
que não é dona do relacionamento.
joinColumns Chave estrangeira para realizar a associação com a tabela
que é dona do relacionamento.
name Nome da tabela de associação.
schema Esquema da tabela.
uniqueConstraints Regras que podem ser adicionadas na tabela.
Na entidade Aluno definimos que um aluno possui vários telefones através do atri-
formar que o relacionamento de Aluno para Telefone é de Um-para-Muitos.
Para informar que vamos utilizar a tabela ALUNO_TELEFONE para realizar a associação
entre as tabelas ALUNO e TELEFONE utilizamos a anotação javax.persistence.JoinTable.
Para informar que a coluna ALUNO_ID da tabela ALUNO_TELEFONE é a coluna chave
estrangeira para a tabela ALUNO e para informar que a coluna TELEFONE_ID da tabela
ALUNO_TELEFONE é a chave estrangeira para a tabela TELEFONE utilizamos a anotação ja-
vax.persistence.JoinColumn.
/**
* Classe utilizada para representar uma entidade Aluno.

______________________________________________________________________________________________
*/
@Entity
public class Aluno {
@Id
private Long id;
private Long matricula;
@OneToMany(cascade=CascadeType.ALL, fetch=FetchType.EAGER)
@JoinTable(name="ALUNO_TELEFONE",
joinColumns={@JoinColumn(name = "ALUNO_ID")},
inverseJoinColumns={@JoinColumn(name = "TELEFONE_ID")})
public Long getMatricula() { return matricula; }
public void setMatricula(Long matricula) {
this.matricula = matricula;
}
}
}
Agora vamos declarar a entidade Telefone, note que esta entidade não conhece as associações
que são criadas para ela.
/**
* Classe utilizada para representar um Telefone.
*/
@Entity
= 7526502149208345058L;
@Id
private Long id;

______________________________________________________________________________________________
private String tipo;
private Integer numero;
public Integer getNumero() { return numero; }
public void setNumero(Integer numero) {
}
public String getTipo() { return tipo; }
public void setTipo(String tipo) { this.tipo = tipo; }
}
Para testar o cadastro de Aluno e Telefone vamos criar a classe AlunoDAO para salvar, alterar,
consultar por id e apagar os registro do aluno e telefone.
import javax.persistence.EntityTransaction;
import pbc.jpa.exemplo.modelo.Aluno;
/**
* Classe DAO para manipular as informações do
* Aluno no banco de dados.
*/
public class AlunoDAO {
try {
//Obtem o factory a partir da unidade de persistência.
("UnidadeDePersistencia");
} finally {
factory.close();
}
}
public Aluno consultarPorId(Long id) {
Aluno aluno = null;
try {
aluno = entityManager.find(Aluno.class, id);
} finally {

______________________________________________________________________________________________
}
return aluno;
}
public Aluno salvar(Aluno aluno) {
try {
System.out.println("Salvando as informações do aluno.");
/* Verifica se o aluno ainda não está salvo no
banco de dados. */
if(aluno.getId() == null) {
entityManager.persist(aluno);
} else {
aluno = entityManager.merge(aluno);
}
} catch(Exception ex) {
} finally {
}
// Retorna o aluno salvo.
return aluno;
}
public void apagar(Long id) {
try {
// Consulta o aluno na base de dados através do seu ID.
Aluno aluno = entityManager.find(Aluno.class, id);
System.out.println("Excluindo o aluno: "
+ aluno.getNome());
// Remove o aluno da base de dados.
entityManager.remove(aluno);
} finally {
}
}
}
Vamos criar a classe AlunoDAOTeste que utiliza a classe AlunoDAO para salvar, alterar, consultar
por id e apagar os registros de aluno e telefone:

______________________________________________________________________________________________
import java.util.ArrayList;
import pbc.jpa.exemplo.modelo.Aluno;
import pbc.jpa.exemplo.modelo.Telefone;
/**
* Classe utilizada para testar as operações do
* banco de dados referente ao Aluno.
*/
public class AlunoDAOTeste {
AlunoDAO dao = new AlunoDAO();
//Cria uma aluno.
Aluno aluno = new Aluno();
aluno.setNome("Rafael");
aluno.setMatricula(123456L);
//Cria o telefone residencial do aluno.
Telefone telefone = new Telefone();
telefone.setTipo("RES");
telefone.setNumero(12345678);
//Cria o telefone celular do aluno.
Telefone telefone2 = new Telefone();
telefone2.setTipo("CEL");
telefone2.setNumero(87654321);
//Cria uma lista de telefones e guarda dentro do aluno.
List<Telefone> telefones = new ArrayList<Telefone>();
telefones.add(telefone);
telefones.add(telefone2);
aluno.setTelefones(telefones);
System.out.println("Salva as informações do aluno.");
aluno = dao.salvar(aluno);
System.out.println("Consulta o aluno que foi salvo.");
Aluno alunoConsultado = dao.consultarPorId(aluno.getId());
System.out.println(aluno.getNome());
for(Telefone tel : aluno.getTelefones()) {
System.out.println(tel.getTipo() + " - "
+ tel.getNumero());
}
//Cria o telefone comercial do aluno.
Telefone telefone3 = new Telefone();
telefone3.setTipo("COM");
telefone3.setNumero(55554444);
//Adiciona o novo telefone a lista de telefone do aluno.
alunoConsultado.getTelefones().add(telefone3);

______________________________________________________________________________________________
System.out.println("Atualiza as informações do aluno.");
alunoConsultado = dao.salvar(alunoConsultado);
System.out.println(alunoConsultado.getNome());
for(Telefone tel : alunoConsultado.getTelefones()) {
System.out.println(tel.getTipo() + " - "
+ tel.getNumero());
}
System.out.println("Apaga o registro do aluno.");
dao.apagar(alunoConsultado.getId());
}
}
Quando executamos a classe AlunoDAOTeste temos a seguinte saída no console:
Salva as informações do aluno:
Hibernate: insert into Aluno (matricula, nome) values (?, ?)
Hibernate: insert into Telefone (numero, tipo) values (?, ?)
Hibernate: insert into ALUNO_TELEFONE (ALUNO_ID, TELEFONE_ID)
values (?, ?)
values (?, ?)
Consulta o aluno que foi salvo:
Hibernate: select aluno0_.id as id21_1_, aluno0_.matricula as
matricula21_1_, aluno0_.nome as nome21_1_, telefones1_.ALUNO_ID
as ALUNO1_3_, telefone2_.id as TELEFONE2_3_, telefone2_.id as
id18_0_, telefone2_.numero as numero18_0_, telefone2_.tipo as
tipo18_0_ from Aluno aluno0_ left outer join ALUNO_TELEFONE
telefones1_ on aluno0_.id=telefones1_.ALUNO_ID left outer join
Telefone telefone2_ on telefones1_.TELEFONE_ID=telefone2_.id
where aluno0_.id=?Rafael
RES - 12345678
CEL - 87654321
Atualiza as informações do aluno:
where aluno0_.id=?
Hibernate: delete from ALUNO_TELEFONE where ALUNO_ID=?
values (?, ?)
values (?, ?)

______________________________________________________________________________________________
values (?, ?)
Rafael
RES - 12345678
CEL - 87654321
COM - 55554444
Apaga o registro do aluno:
where aluno0_.id=?
Hibernate: delete from ALUNO_TELEFONE where ALUNO_ID=?
Hibernate: delete from Telefone where id=?
Hibernate: delete from Aluno where id=?
Muitos-para-Muito (ManyToMany) - este relacionamento informa que muitos registros de uma
entidade estão relacionados com muitos registros de outra entidade:
CREATE TABLE Projeto (
nome varchar2(200) NOT NULL
);
CREATE TABLE Funcionario (
nome varchar2(200) NOT NULL
);
CREATE TABLE Projeto_Funcionario (
projeto_id number(5),
funcionario_id number(5)
);
Note que nesse caso precisamos utilizar uma tabela intermediária entre Projeto e Funcionario, para
evitar duplicar dados (normalização) desnecessários no banco de dados. Através da tabela Pro-
jeto_Funcionario criamos o relacionamento entre Projeto e Funcionario.

______________________________________________________________________________________________
Modelo UML:
Neste exemplo definimos que um Projeto tem vários funcionários, e um Funcionario participa
de vários projetos, portanto temos um relacionamento bidirecional de muitos-para-muitos.
A entidade Projeto possui um relacionamento de muitos-para-muitos com a entidade Fun-
cionario, para definir esta associação utilizamos a anotação javax.persistence.ManyToMany,
note que utilizamos a propriedade mappedBy da anotação ManyToMany para informar que o Pro-
jeto é o dono do relacionamento.
import javax.persistence.ManyToMany;
/**
* Classe utilizada para representar um projeto.
*/
@Entity
public class Projeto implements Serializable {
= 1081869386060246794L;
@Id
private Long id;
@ManyToMany(mappedBy="projetos", cascade=CascadeType.ALL)
private List<Funcionario> desenvolvedores;
public List<Funcionario> getDesenvolvedores() {
return desenvolvedores;
}
public void setDesenvolvedores(List<Funcionario>
desenvolvedores) {
this.desenvolvedores = desenvolvedores;
}

______________________________________________________________________________________________
}
javax.persistence.ManyToMany - esta anotação define uma associação com outra entidade que
tenha a multiplicidade de muitos-para-muitos.
fetch Informa se o alvo da associação precisa ser obtido apenas quando
for necessário ou se sempre deve trazer.
A entidade Funcionario possui um relacionamento de muitos-para-muitos com a entidade
Projeto, para definir esta associação utilizamos a anotação javax.persistence.ManyToMany.
Para informar que vamos utilizar a tabela PROJETO_FUNCIONARIO para realizar a asso-
ciação entre PROJETO e FUNCIONARIO utilizamos a anotação javax.persistence.JoinTable.
Para informar que a coluna PROJETO_ID da tabela PROJETO_FUNCIONARIO é a coluna
chave estrangeira para a tabela PROJETO e para informar que a coluna FUNCIONARIO_ID da
tabela PROJETO_FUNCIONARIO é a chave estrangeira para a tabela FUNCIONARIO utilizamos
a anotação javax.persistence.JoinColumn.
import javax.persistence.ManyToMany;
/**
* Classe utilizada para representar um Funcionário.
*/
@Entity
public class Funcionario implements Serializable {
= -9109414221418128481L;
@Id

______________________________________________________________________________________________
private Long id;
@ManyToMany(cascade = CascadeType.ALL)
@JoinTable(name="PROJETO_FUNCIONARIO",
joinColumns={@JoinColumn(name="PROJETO_ID")},
inverseJoinColumns={@JoinColumn(name="FUNCIONARIO_ID")})
private List<Projeto> projetos;
public List<Projeto> getProjetos() { return projetos; }
public void setProjetos(List<Projeto> projetos) {
this.projetos = projetos;
}
}
12.13 Cascade Type
Com o CascadeType podemos definir a forma como serão propagadas as operações em
cascata de uma Entity para suas referencias.
 PERSIST – Quando salvar a Entidade A, também será salvo todas as Entidades B associa-
das.
 MERGE – Quando atual as informações da Entidade A, também será atualizado no banco
de dados todas as informações das Entidades B associadas.
 REMOVE – Quando remover a Entidade A, também será removida todas as entidades B
associadas.
 REFRESH – Quando houver atualização no banco de dados na Entidade A, todas as enti-
dades B associadas serão atualizadas.
 ALL – Corresponde a todas as operações acima (MERGE, PERSIST, REFRESH e RE-
MOVE).
12.14 FetchType
Com o FetchType podemos definir a forma como serão trazidos os relacionamentos, pode-
mos fazer de duas formas:

______________________________________________________________________________________________
 EAGER - Traz todas as entidades que estão relacionadas, ou seja, se a Entidade A possui
um relacionamento com a Entidade B, então quando consultar a Entidade A, também será
consultado suas referencias na Entidade B.
 LAZY - Não traz as entidades que estão relacionadas, ou seja, se a Entidade A possui um
relacionamento com a Entidade B, então quando consultar a Entidade A só serão retornadas
as informações referentes a esta Entidade.
Exemplo de relacionamento LAZY, desse modo o corpo da mensagem é consultado apenas
quando houver a necessidade:
@Entity
public class Mensagem {
@Id
private Long id;
private String assunto;
private Date dataEnvio;
@OneToOne(cascade=CascadeType.ALL, fetch=FetchType.LAZY)
}
Nesse exemplo utilizamos a enum FetchType.LAZY no relacionamento um-para-um para
informar que quando consultarmos a entidade Mensagem, não queremos consultar a entidade Men-
sagemCorpo ao mesmo tempo.
Exercícios:
Neste exercício vamos abordar como funciona os relacionamentos entre as entidades, va-
mos utilizar o relacionamento entre as entidades Cliente e Endereco, quando salvar o cliente tam-
bém deve salvar o endereço e quando o cliente for consultado deve trazer também as informações
do endereço.
Crie o seguinte banco de dados:
CREATE SEQUENCE CLI_SEQ INCREMENT BY 1
CREATE SEQUENCE END_SEQ INCREMENT BY 1
CREATE TABLE ENDERECO (
estado VARCHAR2(50) NOT NULL,
cidade VARCHAR2(50) NOT NULL,
bairro VARCHAR2(50) NOT NULL,
logradouro VARCHAR2(50) NOT NULL,
complemento VARCHAR2(50) NOT NULL
);
CREATE TABLE CLIENTE (

______________________________________________________________________________________________
endereco_id number(5) NOT NULL
);
Crie um projeto Java chamado ExercicioJPA4, adicione as bibliotecas Hibernate JPA e Driver da
Oracle (ojdbc6.jar) ou do Mysql (Caso tenha optado por esse banco de dados) e crie:
 Classe entity para representar um endereço com os atributos id, estado, cidade, bairro, lo-
gradouro e complemento.
/**
* Classe utilizada para representar um Endereço.
*/
@Entity
@SequenceGenerator(name = "ENDERECO_SEQ",
sequenceName = "END_SEQ", initialValue = 1,
allocationSize = 1)
public class Endereco implements Serializable {
= 5331450149454053703L;
@Id
generator = "ENDERECO_SEQ")
private Long id;
private String estado;
private String cidade;
private String bairro;
private String logradouro;
private String complemento;
public String getBairro() { return bairro; }
public void setBairro(String bairro) {
this.bairro = bairro;
}
public String getCidade() { return cidade; }
public void setCidade(String cidade) {
this.cidade = cidade;
}
public String getComplemento() { return complemento; }
public void setComplemento(String complemento) {

______________________________________________________________________________________________
this.complemento = complemento;
}
public String getEstado() { return estado; }
public void setEstado(String estado) {
this.estado = estado;
}
public String getLogradouro() { return logradouro; }
public void setLogradouro(String logradouro) {
this.logradouro = logradouro;
}
}
 Classe entity para representar um cliente com id, nome e endereço, note que vamos utilizar
a anotação javax.persistence.OneToOne para definir o relacionamento de um-para-um en-
tre as entidades Cliente e Endereco.
import javax.persistence.OneToOne;
/**
* Classe utilizada para representar um Cliente.
*/
@Entity
@SequenceGenerator(name = "CLIENTE_SEQ",
sequenceName = "CLI_SEQ", initialValue = 1,
allocationSize = 1)
public class Cliente implements Serializable {
= 4521490124826140567L;
@Id
generator = "CLIENTE_SEQ")
private Long id;
private Endereco endereco;
public Endereco getEndereco() { return endereco; }
public void setEndereco(Endereco endereco) {

______________________________________________________________________________________________
this.endereco = endereco;
}
}
 Crie o arquivo persistence.xml dentro da pasta META-INF do projeto, note que neste ar-
quivo vamos informar qual o banco de dados iremos utilizar e quais classes são entidades
do banco:
<persistence-unit name="ExercicioJPA4PU"
<class>pbc.jpa.exercicio3.modelo.Endereco</class>
<class>pbc.jpa.exercicio3.modelo.Cliente</class>
<properties>
value="usuario"/>
value="senha"/>
</properties>
</persistence-unit>
</persistence>
 Crie a classe ClienteDAO que será responsável por utilizar o EntityManager para manipu-
lar (salvar, alterar, remover e consultar por id) as informações referentes ao Cliente.
package pbc.jpa.exercicio4.dao;
import pbc.jpa.exercicio4.modelo.Cliente;
import pbc.jpa.exercicio4.modelo.Endereco;

______________________________________________________________________________________________
/**
* Classe utilizada para fazer as operações de
* banco de dados sobre a entity Cliente.
*/
public class ClienteDAO {
/**
* @return
*/
try {
//Obtém o factory a partir da unidade de persistencia.
("ExercicioJPA4PU");
} finally {
factory.close();
}
}
/**
* Método que salva ou atualiza as informações do cliente.
* @param cliente
* @return
*/
public Cliente salvar(Cliente cliente) throws Exception {
try {
System.out.println("Salvando as informações do cliente.");
/* Verifica se o cliente ainda não está salvo
if(cliente.getId() == null) {
entityManager.persist(cliente);
} else {
cliente = entityManager.merge(cliente);
}
} finally {
}
// Retorna o cliente salvo.

______________________________________________________________________________________________
return cliente;
}
/**
* Método que apaga as informações do cliente
* do banco de dados.
* @param id
*/
try {
// Consulta o cliente na base de dados através do seu ID.
Cliente cliente = entityManager.find(Cliente.class, id);
System.out.println("Excluindo o cliente: "
+ cliente.getNome());
// Remove o cliente da base de dados.
entityManager.remove(cliente);
} finally {
}
}
/**
* Consulta o cliente pelo ID.
* @param id
* @return
*/
public Cliente consultarPorId(Long id) {
Cliente cliente = null;
try {
//Consulta o cliente pelo ID.
cliente = entityManager.find(Cliente.class, id);
} finally {
}
//Retorna o cliente consultado.
return cliente;
}
}
Vamos desenvolver a interface gráfica em SWING que será responsável por chamar o ClienteDAO
para executar as operações no banco de dados.

______________________________________________________________________________________________
Código fonte da tela de cadastro do cliente.
Observação: este código não está completo, ele possui apenas implementado o código dos botões.
package pbc.jpa.exercicio4.tela;
import javax.swing.JOptionPane;
import pbc.jpa.exercicio4.dao.ClienteDAO;
import pbc.jpa.exercicio4.modelo.Cliente;
import pbc.jpa.exercicio4.modelo.Endereco;
/**
* Classe utilizada para representar o cadastro do Cliente.
*/
public class CadastroCliente extends javax.swing.JFrame {
= -6011351657657723638L;
public CadastroCliente() {
initComponents();
}
/**
* Código para montar a tela.
*/
@SuppressWarnings("unchecked")
private void initComponents() {
//Código que monta a tela mostrada na imagem anterior.
}
/**
* Botão que salva as informações do cliente.
*
* @param evt
*/
private void botaoSalvarActionPerformed(
java.awt.event.ActionEvent evt) {
try {
//Cria um objeto endereco;

______________________________________________________________________________________________
Endereco e = new Endereco();
e.setEstado(this.estado.getText());
e.setCidade(this.cidade.getText());
e.setBairro(this.bairro.getText());
e.setLogradouro(this.logradouro.getText());
e.setComplemento(this.complemento.getText());
//Cria um objeto cliente.
Cliente c = new Cliente();
c.setNome(this.nome.getText());
c.setEndereco(e);
//Salva o cliente.
ClienteDAO dao = new ClienteDAO();
c = dao.salvar(c);
JOptionPane.showMessageDialog(this, "Cliente "
+ c.getId() + " - " + c.getNome(), "INFORMAÇÃO",
JOptionPane.INFORMATION_MESSAGE);
limparDados();
JOptionPane.showMessageDialog(this, ex.getMessage(),
"ERRO", JOptionPane.ERROR_MESSAGE);
}
}
/**
* Botão que consulta as informações do cliente.
*
* @param evt
*/
private void botaoConsultarActionPerformed(
try {
Cliente c = dao.consultarPorId(Long.valueOf(this.id.getText()));
if(c != null) {
this.nome.setText(c.getNome());
this.estado.setText(c.getEndereco().getEstado());
this.cidade.setText(c.getEndereco().getCidade());
this.bairro.setText(c.getEndereco().getBairro());
this.logradouro.setText(c.getEndereco().getLogradouro());
this.complemento.setText(c.getEndereco().getComplemento());
} else {
limparDados();
JOptionPane.showMessageDialog(this,
"Cliente não foi encontrado!",
}
} catch (NumberFormatException ex) {
"O campo código precisa ser um número inteiro",

______________________________________________________________________________________________
}
}
/**
* Botão para limpar as informações do formulario
* para cadastrar um novo cliente.
*
* @param evt
*/
private void botaoNovoActionPerformed(
limparDados();
}
/**
* Botão para remover as informações referentes a um cliente.
*
* @param evt
*/
private void botaoApagarActionPerformed(
try {
dao.excluir(Long.valueOf(this.id.getText()));
limparDados();
"As informações do cliente foram apagadas do sistema.",
"INFORMAÇÃO", JOptionPane.INFORMATION_MESSAGE);
} catch (NumberFormatException ex) {
"O campo código precisa ser um número inteiro",
}
}
/**
* Limpa os dados do formulario.
*/
private void limparDados() {
this.id.setText(null);
this.nome.setText(null);
this.estado.setText(null);
this.cidade.setText(null);
this.bairro.setText(null);
this.logradouro.setText(null);
this.complemento.setText(null);
}
/**
* @param args the command line arguments
*/
public static void main(String args[]) {

______________________________________________________________________________________________
java.awt.EventQueue.invokeLater(new Runnable() {
public void run() {
new CadastroCliente().setVisible(true);
}
});
}
private javax.swing.JTextField bairro;
private javax.swing.JButton botaoApagar;
private javax.swing.JButton botaoConsultar;
private javax.swing.JButton botaoNovo;
private javax.swing.JButton botaoSalvar;
private javax.swing.JTextField cidade;
private javax.swing.JTextField complemento;
private javax.swing.JTextField estado;
private javax.swing.JTextField id;
private javax.swing.JLabel labelBairro;
private javax.swing.JLabel labelCadastroCliente;
private javax.swing.JLabel labelCidade;
private javax.swing.JLabel labelCodigo;
private javax.swing.JLabel labelComplemento;
private javax.swing.JLabel labelEstado;
private javax.swing.JLabel labelLogradouro;
private javax.swing.JLabel labelNome;
private javax.swing.JTextField logradouro;
private javax.swing.JTextField nome;
}
Exercicio:
Neste exercício vamos desenvolver uma aplicação swing para implementar o seguinte requisito
de sistema:
Precisamos controlar as vendas de instrumentos musicais, desenvolva uma aplicação para ca-
dastrar, alterar, consultar pelo código e remover os instrumentos musicais (marca, modelo e
preço). Também devemos cadastrar as vendas feitas para um cliente, onde o cliente (nome, cpf e
telefone) pode comprar diversos instrumentos musicais. Não temos a necessidade de controlar o
estoque dos produtos, pois apenas será vendido os itens que estão nas prateleiras.
12.15 Consultas com JPAQL
Utilizando JPA podemos também adicionar consultas personalizadas, para criação das con-
sultas utilizamos a Java Persistence API Query Language (JPAQL) que é uma linguagem muito
similar ao Structured Query Language (SQL) com a diferença que é mais voltado para orientação
a objetos, onde facilita a navegação pelos objetos. Nesse exemplo vamos abordar o seguinte ce-
nário, empréstimo de livros para os clientes da biblioteca, temos as seguintes tabelas:

______________________________________________________________________________________________
CREATE TABLE Livro (
autor varchar2(200) NOT NULL,
isbn varchar2(20) NOT NULL,
paginas number(5) NOT NULL,
PRIMARY KEY(id)
);
CREATE TABLE Cliente (
cpf varchar2(14) NOT NULL,
telefone varchar2(9) NOT NULL,
PRIMARY KEY(id)
);
CREATE TABLE Emprestimo (
livro_id number(5) NOT NULL,
cliente_id number(5) NOT NULL,
dataEmprestimo date NOT NULL,
dataDevolucao date,
PRIMARY KEY(id)
);
INSERT INTO Livro (id, titulo, autor, isbn, paginas)
VALUES (1, 'Almoçando com Java', 'Sakurai',
'111-11-1111-111-1', 325);

______________________________________________________________________________________________
VALUES (2, 'Classes Java em fila indiana', 'Cristiano',
'222-22-2222-222-2', 120);
VALUES (3, 'Java em todo lugar', 'Sakurai',
'333-33-3333-333-3', 543);
VALUES (4, 'Viajando no Java', 'Cristiano',
'444-44-4444-444-4', 210);
INSERT INTO Cliente (id, nome, cpf, telefone)
VALUES (1, 'Marcelo', '333.333.333-33', '9999-8888');
INSERT INTO Cliente (id, nome, cpf, telefone)
VALUES (2, 'Ana', '222.222.222-22', '7777-6666');
Utilizando o EJB-QL podemos criar diversas formas de consultas, onde podemos especificar as
projeções, associações, restrições e outros. Exemplos de consultas:
Consultar todos os empréstimos:
SELECT e
FROM Emprestimo e
Consultar a quantidade de empréstimo por livro:
SELECT count(e)
FROM Emprestimo e
WHERE e.livro.id = :id
Consultar os empréstimos por titulo do livro:
SELECT e
FROM Emprestimo e, Livro l
WHERE e.livro.id = l.id
AND l.titulo LIKE :titulo
As consultas podem ser criadas junto com as entidades:
import javax.persistence.NamedQueries;
import javax.persistence.NamedQuery;
/**

______________________________________________________________________________________________
* Classe utilizada para representar o emprestimo
* de um livro para um cliente.
*/
@NamedQueries({
@NamedQuery(name = "Emprestimo.consultarTodos",
query= "SELECT e FROM Emprestimo e"),
@NamedQuery(name = "Emprestimo.qtdEmprestimosPorLivro",
query = " SELECT count(e) " +
" FROM Emprestimo e " +
" WHERE e.livro.id = :id "),
@NamedQuery(name = "Emprestimo.consultarTodosPorTituloLivro",
query = " SELECT e " +
" FROM Emprestimo e, Livro l " +
" WHERE e.livro.id = l.id " +
" AND l.titulo LIKE :titulo ")
})
@Entity
public class Emprestimo implements Serializable {
= 7516813189218268079L;
@Id
private Long id;
@ManyToOne(cascade=CascadeType.REFRESH, fetch=FetchType.EAGER)
private Livro livro;
@ManyToOne(cascade=CascadeType.REFRESH, fetch=FetchType.EAGER)
private Cliente cliente;
private Date dataEmprestimo;
private Date dataDevolucao;
public Cliente getCliente() { return cliente; }
public void setCliente(Cliente cliente) {
this.cliente = cliente;
}
public Date getDataDevolucao() { return dataDevolucao; }
public void setDataDevolucao(Date dataDevolucao) {
this.dataDevolucao = dataDevolucao;
}
public Date getDataEmprestimo() { return dataEmprestimo; }
public void setDataEmprestimo(Date dataEmprestimo) {
this.dataEmprestimo = dataEmprestimo;
}
public Livro getLivro() { return livro; }
public void setLivro(Livro livro) { this.livro = livro; }

______________________________________________________________________________________________
}
12.15.1 Interface Query
A interface Query é responsável por:
 Fazer as consultas;
 Executar updates;
 Passar parâmetros para consulta;
 Pegar um simples resultado;
 Pegar uma lista de resultados.
Para executar uma consulta utilizamos a interface javax.persistence.Query e criamos uma Query a
partir do EntityManager, exemplo:
public List<Emprestimo> consultarTodos() {
EntityManager em = getEntityManager();
Query query = em.createNamedQuery("Emprestimo.consultarTodos");
return query.getResultList();
}
Nesse exemplo estamos utilizando a EntityManager para criar uma consulta nomeada atra-
vés do método getNamedQuery e passamos o nome da consulta "Emprestimo.consultarTo-
dos" declarado na entidade.
Através da EntityManager podemos utilizar o método createQuery para criar a consulta e já decla-
rar todo o código dela, podendo criar uma consulta um pouco mais personalizada:
Query query = em.createQuery("SELECT c FROM Cliente c");
Também podemos criar uma consultas nativa para uma base de dados especifica:
Query query = em.createNativeQuery("SELECT * FROM Cliente");
Para executar uma consulta podemos ter como resposta um simples objeto ou uma lista de obje-
tos.
Neste exemplo vamos executar uma consulta que retorna uma lista de objetos:
Query query = em.createNamedQuery("Cliente.consultarTodosClientes");
List<Cliente> clientes = (List<Cliente>) query.getResultList();
Quando utilizamos o método getResultList da interface Query é retornado uma lista de entidades.
Consulta que retorna um único objeto:
Query query = em.createNamedQuery("Emprestimo.qtdEmprestimosPorLivro");
Long quantidade = (Long) query.getSingleResult();

______________________________________________________________________________________________
Quando utilizamos o método getSingleResult da interface Query é retornado apenas um
objeto. Este método pode lançar também a exceção javax.persistence.NoResultExcep-
tion quando a consulta não retorna nenhum resultado ou também uma exceção javax.persis-
tence.NonUniqueResultException quando você espera retornar apenas um objeto e a consulta
acaba retornando mais de um objeto.
Através da interface Query podemos passando parâmetros para a consulta através do mé-
todo setParameter:
public List<Emprestimo> consultarTodosPorTituloLivro
(String tituloLivro) {
Query query = entityManager.createNamedQuery
("Emprestimo.consultarTodosPorTituloLivro");
query.setParameter("titulo", tituloLivro);
}
Exemplo de classe DAO que executa as operações: salvar, alterar, remover, consultar por id, con-
sultar todos os empréstimos, consultar a quantidade de empréstimos de um livro e consultar todos
os empréstimos de um livro.
import javax.persistence.Query;
import pbc.jpa.exemplo.modelo.Emprestimo;
/**
* Classe utilizada para representar as
* operações sobre a entidade emprestimo.
*/
public class EmprestimoDAO {
try {
("UnidadeDePersistencia");
} finally {
factory.close();
}
}
public Emprestimo consultarPorId(Long id) {

______________________________________________________________________________________________
Emprestimo emprestimo = null;
try {
emprestimo = entityManager.find(Emprestimo.class, id);
} finally {
}
return emprestimo;
}
public Emprestimo salvar(Emprestimo emprestimo) {
try {
if(emprestimo.getId() == null) {
entityManager.persist(emprestimo);
} else {
entityManager.merge(emprestimo);
}
} finally {
}
return emprestimo;
}
try {
Emprestimo emprestimo = entityManager.
find(Emprestimo.class, id);
entityManager.remove(emprestimo);
} finally {
}
}
public List<Emprestimo> consultarTodos() {
("Emprestimo.consultarTodos");

______________________________________________________________________________________________
}
public Long getQtdEmprestimosPorLivro(Long id) {
("Emprestimo.qtdEmprestimosPorLivro");
query.setParameter("id", id);
return (Long) query.getSingleResult();
}
public List<Emprestimo> consultarTodosPorTituloLivro
(String tituloLivro) {
("Emprestimo.consultarTodosPorTituloLivro");
query.setParameter("titulo", tituloLivro);
}
}
Exercícios:
Seguindo como base o exercício anterior, agora vamos criar uma aplicação para realizar a
venda de um produto para um cliente.
Utilize as tabelas da figura a seguir para modelar o sistema.
Crie as entidades Produto, Cliente e Venda, DAOs e uma classe para teste.
Observação: Se quiser pode começar com uma carga prévia de clientes e produtos fazendo assim
apenas a parte das vendas.
Após isso amplie a aplicação para que seja possível vender vários produtos para um cliente.

______________________________________________________________________________________________
O que é o iReport?
O iReport é uma ferramenta poderosa, intuitiva e fácil de usar que constrói relatórios
para JasperReports. O iReport é desenvolvido 100% em Java. Essa ferramenta permite ao
usuário gerar relatórios complexos com imagens, gráficos e subrelatórios. O iReport é integrado
com o JfreeChart, uma das bibliotecas Java de geração de gráficos mais difundidas. Com o iReport
é possível gerar relatórios em vários formatos incluindo
PDF, HTML, XML, XLS, CVS, entre outros.
O que é o JasperReports
JasperReport é a biblioteca de classes que torna possível gerar os relatórios.
O iReport é apenas uma interface gráfica que faz uso do JasperReports.
São as classes e métodos disponibilizados pelo JasperReports que serão usados para
efetivamente gerar e exportar os relatórios.
Instalando o iReport
O iReport está disponível para download no site da SourceForge.net. O iReport e o
JasperReports são projetos dessa comunidade de desenvolvedores de software livre. O endereço
para download é:
http://ireport.sf.net
Para que o iReport funcione corretamente no seu sistema é necessário que você tenha a versão
mais atualizada do JDK instalada no seu sistema.
Caso você ainda não tenha o Java Development Kit (JDK) instalado no seu computador, você pode
fazer o download no site da Sun:
http://java.sun.com
A instalação do iReport é bastante simples. É preciso apenas descompactar o
arquivo .zip que você baixou do site da SourceForge.net. Ao descompactar esse arquivo ele
já vai criar toda a estrutura de diretórios necessários para que o iReport funcione. Uma vez
descompactado, basta executar o arquivo iReport.bat (para Windows), ou iReport.sh (para Linux),
que o iReport irá ser exeutado.
13.1 Acesso ao banco de Dados
Antes de mais nada devemos criar uma conexão com nossa fonte de dados:
1. Selecione o menu Datasources >> Connection/Datasources. A janela que aparece lista
todas as fontes de dados e conexões JDBC que você define. Clique no botão New para criar
uma nova conexão (ou datasource).
Relatórios
13

______________________________________________________________________________________________
2. Na janela que aparece escolha o tipo de conexão (no nosso caso Database JDBC
Connection). Na mesma janela dê um nome à conexão. Por exemplo, “BibliotecaPessoal
FB”.
3. No campo “JDBC Driver”, selecione o driver do seu banco. Caso não esteja listado, como
no nosso caso, especifique um de acordo com o seu SGBD. Para o Firebird, digite
“org.firebirdsql.jdbc.FBDriver”, lembrando que o driver deve estar no classpath.
4. Em “JDBC URL” digitamos o caminho para a nossa base de dados:
“jdbc:firebirdsql:localhost/3050:c://db//Acervo.fdb”
Obs.: A sintaxe da URL difere de SGBD para SGBD, consulte a documentação de seu banco
para saber a sintaxe exata. Repare também no caminho para a base de dados.
5. Em “Server Address” digite o caminho para servidor de banco de dados, no nosso caso
“localhost”.
Em “Database”, entre com o nome do banco (Acervo.fdb) ou do alias. Entramos, então, com
o user “sysdba” e password “masterkey”. Temos a possibilidade de salvar a senha marcando
a opção “Save password”.

______________________________________________________________________________________________
6. Para testarmos a conexão clicamos no botão “Test”. Não esqueça que o SGBD precisa
estar rodando.
Se tudo ocorreu bem a seguinte mensagem irá aparecer:
7. O próximo passo é ir ao menu “Build >> Set active connection”, escolhendo na janela que
aparece a conexão com a base que iremos utilizar para preencher o relatório, no nosso caso:
“BibilotecaPessoal FB”.
Obs.: É importante salientar que a configuração de uma conexão dentro do iReport não é
obrigatória, pois podemos utilizá-lo apenas para criar o design do relatório e compilá-lo. As tarefas

______________________________________________________________________________________________
de preenchimento, exportação para um formato (pdf, por exemplo), e visualização, ficam de
responsabilidade de uma classe Java. Porém, é conveniente, até mesmo para a realização dos
testes, termos um único ambiente que além de permitir a definição do layout, também permita
visualizarmos, em diversos formatos, o resultado do design e preenchimento do relatório através
de um simples botão (Run): . Para isso, é necessário que a conexão JDBC esteja funcionando.
13.2 iReport Wizard
Vamos criar o nosso primeiro relatório utilizando o Wizard do iReport. No menu File selecione
o item “Report Wizard”. A janela de diálogo irá guiar o processo para geração de um relatório. No
passo 1, conforme mostra a figura abaixo, devemos colocar qual o SQL que vamos usar para gerar
esse relatório. No nosso exemplo, vamos listar todo o conteúdo da tabela vendas.
No passo 2, vamos selecionar as colunas que desejamos mostrar no relatório. Vamos selecionar
todos os campos, conforme mostra a seguir
No passo 3, podemos escolher se queremos agrupar o resultado por alguma coluna. Nesse primeiro
exemplo vamos deixar em branco e seguir para o passo 4, conforme mostra a figura abaixo:

______________________________________________________________________________________________
No passo 4, vamos selecionar o layout do relatório. O iReport já tem alguns layouts default para
serem selecionados. Os layouts podem ser tabular ou dispostos em colunas. Vamos escolher
tabular e o layout classicT.xml, conforme mostra a figura a seguir.
No passo 5 basta clicar finish para finalizar a criação do seu relatório, conforme mostra a figura.
Agora para visualizar o seu relatório recém gerado, selecione no menu “Build”, a opção “JRViewer
preview”.

______________________________________________________________________________________________
Após selecionar o item mostrado na figura acima, clique no menu “Build” e selecione a opção
“Execute report (using active conn.)”. Vai aparecer uma janela pedindo para salvar o relatório. Salve
o relatório e a visualização deve aparecer, como mostra a figura abaixo.
Pronto você acaba de construir o primeiro relatório utilizando o iReport.
Exercícios:
1. Utilizando o Wizard do iReport, crie um relatório que liste todos os produtos e quantidades desses
produtos e a quantidade de cada um deles agrupados por estado.
2. Utilizando o Wizard do iReport, crie um relatório que apresente o total das quantidades de
produtos em cada estado. Utilize o SQL abaixo para efetuar a pesquisa:
• SELECT UF, SUM(QTDE) AS TOTAL FROM VENDAS GROUP BY UF
3. Com o Wizard do iReport crie um relatório “columnar” que mostre o nome e o preço dos produtos
da tabela produto.
a. Clique em File | Report Wizard;
b. Entre o comnado SQL “select * from produto”;
c. Clique Next;
d. Selecione as colunas “preco” e “nome” e clique Next;
e. Clique Next novamente;
f. Selecione “Columnar” da combobox de layout e clique no template classicC.xml. Clique
Next.
g. Clique em Finish;
h. Salve o relatório com o nome a sua escolha;

______________________________________________________________________________________________
i. Para visualizar o relatório clique em Build | Execute report (usinf active conn.).
13.3 Modelo Relatório iReport
13.3.1 Estrutura de um relatório
Os relatório do JasperReports gerados pelo iReport tem a seguinte estrutura conforme
mostra a tabela abaixo.
As sessões 1. Título e 11. Sumário são exibidas apenas uma vez em todo o relatório. As
sessões 2. Cabeçalho da Página e 10. Rodapé da Página repetem a cada nova página. As sessões
3. Cabeçalho Coluna e 9. Rodapé Coluna repetem a cada nova coluna dentro da página. As
sessões 4, 5, 7 e 8 repetem de acordo com mudanças dos campos de 6. Detalhe. Pode haver
quantos grupos se deseje, inclusive zero. Essas sessões são chamadas faixas (bands). Então
temos a faixo deTítulo, a faixa de Cabeçalho de Página, a faixa de Detalhe, etc. Dentro dessas
faixas é que são inseridos os elementos do relatório, tais como os rótulos, campos, imagens,
gráficos, etc.
A figura abaixo mostra as faixas de título, cabeçalho de página, cabeçalho de coluna,
detalhe, rodapé de página.
Na faixa de título temos o campo de texto estático “Clasic Report Template”. A faixa de
cabeçalho da página está em branco apenas para dar espaço entre o título e o cabeçalho da coluna.
Na faixa cabeçalho da coluna temos os campos de texto estáticos “UF”, “Produto” e “QTDE”. Na
faixa de detalhe temos campos de referência aos valores retornados pela consulta SQL $F{UF},
$F{Produto} e $F{QTDE}. Não se preocupe com o que isso quer dizer, vamos explicar em seguida.
O importante é identificar as faixas. Na faixa de rodapé de página, estão as funções de data e
paginação. Como os elementos já estão dispostos nas faixas, fica mais difícil indentificá-las. Se
não houvesse nenhum elemento no relatório as faixas ficariam como demonstra figura a seguir.

______________________________________________________________________________________________
Note as demais faixas não aparecem porque eles estão “escondidas”. Para visualizar todas as
faixas de um relatório, clique no menu principal “View” e seleciona a opção “Bands”. A janela de
diálogo mostrada na figura 5.3 vai aparecer. Note que ela lista todas as faixas desse relatório. As
faixas com altiura zero ficam escondidas. As faixas com tamanho maior que zero aparecem no
relatório. Na figura abaixo, a faixa de detalhe tem altura igual a 19.
Assim se você quer mostrar alguma faixa que não está aparecendo ou você está precisando
de mais espaço, aumente a altura da faixa. Depois é só colocar os elementos que desejar.
13.3.2 Variáveis, Parâmetros e campos
Como vocês visto nas figuras acima, apareceu várias expressões como $F{UF}
$V{PAGE_NUMBER}. Mas o que são essas expressões? $F{} é uma referências as colunas (ou
campos) retornados pela consulta SQL do relatório. Assim se seu SQL tiver como retorno uma
coluna UF, $F{UF} referencia essa coluna. As colunas resultantes do SQL são mapeadas para os
campos do nosso relatório. $V{} indica um parâmetro passado para a query SQL do relatório. Os
paramêtros são uteis para cue possamos executar a query de acordo com a seleção do usuário.
Por exemplo, para trazer o resultado das vendas de apenas um estado podemos criar um parâmetro
na consulta SQL para trazer os resultados do estado indicado. Para criar um parâmetro clique no
menu principal “View” e selecione a opção “Report Parameters”.Então vai aparecer:

______________________________________________________________________________________________
Clique no Botão “New”. Uma nova janela vai aperecer conforme mostra a figura abaixo. Preencha
o campo “Parameter Name” com “estado”. O campo “Class Type” com “java.lang.String”. Marque o
campo “Is For Prompting”, assim quando você executar o relatório dentro do iReport ele vai
perguntar qual o valor vc quer passar para esse parâmetro. O campo “Default value expression”
indica um valor padrão a ser usado caso o valor para o parâmetro estado não seja passado ao
relatório. Preencha esse campo com “ “SP” ”. O campo “Parameter Description” contém a descrição
do que esse parâmetro representa. Clique em OK e depois feche a janela de parâmetros.
Clique no menu principal “View” e selecione “Report Query”. Agora altere o sql do relatório
para select * from vendas where uf = $P{estado}. Agora execute o seu relatório clicando no menu
principal “Build” e selecionando a opção “Execute Report (using active conn.)”. A janela da figura a
seguir deve aparecer, perguntando qual o valor do parâmetro estado. Preencha com “MG” e o
resultado do relatório deve ser o que mostra na sequência.

______________________________________________________________________________________________
13.3.3 Arquivos gerados pelo iReport
Agora que você já viu os detalhes da interface gráfica, é preciso entender o que o iReport
faz para gerar esses relatórios. Salve o seu relatório corrente. Clique no menu principal em “File” e
selecione “Save”. Veja que ele vai salvar o nosso relatório com a extensão .jrxml (JasperReports
XML). Esse arquivo é um documento padrão XML. Ele contém as configurações do nosso relatório.
Esse XML é utilizado pelo JasperReports para gerar um arquivo binário com a extensão .Jasper
que é o arquivo utilizado pelo JasperReports para efetivamente gerar o nosso relatório. O
arquivo .jrxml é muito complexo. Por isso editá-lo manualmente seria no mínimo trabalhoso e nada
produtivo, já que teriamos que descrever em forma de XML tudo aquilo que pode ser feito de forma
gráfica através do iReport. Uma das vantagens de se ter o relatório descrito num documento XML
é que ele é facilmente alterável. Por exemplo, se o nome da sua empresa mudar, e você tiver 100
relatórios aonde fazer a alteração. Basta mandar substituir em seus arquivos .jrxml o nome velho
da empresa pelo novo, compilar os .jrxml novamente e você já terminou a sua tarefa.
Exercicio:
Crie um relatório que recebe como parâmetro um preço mínimo e um preço máximo e mostre
todos os produtos nessa faixa de preço.
a) Clique em File | Report Wizard
b) Entre o comando SQL “select * from produto” e clique Next
c) Selecione a coluna “Nome” e clique Next
d) Clique Next novamente
e) Selecione o layout “Tabular” da combobox e o template classicT.xml
f) Clique Next e depois Clique em Finish
g) Clique em “View | Report Parameters”
h) Clique no botão New
i) No campo parameter name digite mínimo.
j) Mude o parameter class type para double
k) Marque “is for Prompting”. Clique em OK.
l) Clique em New novamente
m) No campo parameter name digite maximo.
n) Mude o parameter class type para double
o) Marque “is for Prompting”. Clique em OK.
p) Feche a janela de Parameters
q) Clique em “View | Report Query”
r)Adicione a query a cláusula “where preco > $P{minimo} and preco < $P{maximo}”. O seu
comando SQL deve ficar assim: “select * from produto where preco > $P{minimo} and preco <
$P{maximo}”

______________________________________________________________________________________________
s) Salve o relatório.
t) Para visualizar, clique em Build | Execute Report (using active conn.)
u) O iReport vai perguntar o valor mínimo e máximo. Entre com os valores (“0” e “999999”,
por exemplo) e veja o resultado.
v) Execute novamente, mas agora mude os valores de mínimo e máximo (0 e 500) e veja se
o relatório muda.
13.4 Criando um relatório
Até agora vimos como criar um relatório a partir do iReport Wizard. Agora vamos criar um
relatório desde o começo. Para tanto, clique em “File” no menu principal e selecione a opção “New
Document”. A janela da figura abaixo irá aparecer. Nela é possível escolher o tamanho, definir as
margens, a orientação do relatório e o nome. Dê o nome de “MeuRelatorio” e clique no botão OK.
Um novo relatório em branco vai ser criado como mostra a figura a seguir. Nele podemos
ver que algumas faixas já aparecem com tamanhos pré-definidos. Agora basta colocar os
elementos que desejarmos nas faixas para montar o nosso relatório.

______________________________________________________________________________________________
A figura abaixo mostra alguns botões da barra de ferramenta que vamos utilizar. Da
esquerda para a direita, são eles: Imagem Texto Estático, Campo de texto, SubRelatório, Gráfico
e Código de Barra.
Clique no botão de texto estático, arraste o cursor sobre a faixa de Título para inserir o
elemento de texto estático. Dê um duplo clique sobre o elemento recém inserido e a janela da figura
abaixo deve aparecer. Nela você pode alterar todas as propriedades desse elemento. Mude o texto
para “Meu Relatório” e aumente o tamanho da fonte para 20.
Veja como ficou sobrando espaço na banda de título diminua o tamanho da faixa de título.
Aproveite e diminua a faixa de Cabeçalho de Pagina (page header) para altura 10, pois também
não vamos utilizá-la. Insira mais três elementos de texto estático na faixa de Cabeçalho de Coluna
(columnHeader). Mude o texto para “ID”, “Descrição” e “Preço”. Para podermos inserir dados nesse
relatório vamos listar a tabela de produto. Para tanto clique no menu “View” e selecione “Report
Query”. Entre o comando SQL “select * from produto” e clique no botão OK. Agora clique no botão
de campo de texto ( o botão com a letra F estilizada). Insira três campos na faixa de Detalhe (detial).
Para poder referenciar uma coluna da nossa consulta SQL, temos que dar duplo clique sobre o
elemento de campo de texto inserido. Uma janela como mostra a figura 6.5 vai abrir, clique na aba
“text field”. No campo Text Field Expression, entre a referência da coluna. Por exemplo, a coluna
ID da consulta SQL acima é referenciada com a expressão $F{ID}. Faça o mesmo para os outros
dois campos. Referencia a coluna “nome” e “preco”. Cuide para colocar o tipo de dado correto no
cmapo “Textfield Expression Class” para evitar erros. Repare que a expressão vai ficar verde
quando você entrar uma expressão válida.

______________________________________________________________________________________________
Agora esconda as demais faixas (colocando sua altura para zero), menos a faixa de Rodapé
de Página (pageFooter). Na faixa de rodapé de página, vamos colocar a data e o número da página.
Para tanto adicione dois novos campos de texto na faixa de rodapé de página. Dê duplo clique
sobre o campo de texto da data. Clique na aba “Text Field”, troque o Textfield Expresion Class para
java.lang.Date e no campo “Textfield expression” entre o comando “new Date()”. Dê duplo clique no
o outro campo de texto e clique na aba “Text Field”. Mude o “Textfield Expression Class” para
java.lang.Integer e no campo “Textfield expression” coloque a referência a variável do número da
página, $V{PAGE_NUMBER}. Para visualizar as variáveis pré-disponíveis (builtin) em todos os
relatórios basta clicar no menu “View” e selecionar “Report Variables”. O seu relatório agora deve
aparecer como o dá figura abaixo. Clique no menu “Build” e selcione “Execute Report (using active
conn.)” e veja o resultado.

______________________________________________________________________________________________
13.5 Gerando o seu relatório em formato PDF
Você pode gerar o seu relatório e salvar o resultado em um arquivo PDF. O JasperReports
é capaz de salvar o seu relatório em um arquivo PDF sem complicações. No código 8.1 temos o
exemplo de como salvar o nosso relatório a partir de uma aplicação Java padrão. Para tanto basta
carregar o arquivo .JASPER gerado pelo iReport e os métodos da biblioteca JasperReports fazem
o resto do serviço.
import net.sf.jasperreports.engine.*;
import net.sf.jasperreports.view.*;
import java.sql.*;
import java.util.*;
public class Visualizador{
private static final String driver = “oracle.jdbc.driver.OracleDriver”;
private static final String url =
“jdbc:oracle:thin:@localhost:1521:MYDATABASE”;
private static final String login = “java”;
private static final String Senha = “java”;
private static final String pdf = “relatorio.pdf”;
private static final String relat = “classic.jasper”;
public static void main (String args[])throws Exception{
Class.forName(driver);
Connection conn =
DriverManager.getConnection(url,login,senha);
HashMap parametros = new HashMap();
//Executa o relatório
JasperPrint impressao = JasperFillManager.fillReport(
relat,
parametros,
conn);
//Exibe o relatório
JasperViewer viewer = new JasperViewer(impressao,true);
Viewer.show();
//Salva o relatorio no arquivo
JasperExportManager.exportReportToPdfFile(impressao,pdf);
}
}

______________________________________________________________________________________________
No código a seguir, temos um exemplo de como mostrar um relatório em formato PDF numa página
JSP. Assim você pode mostrar seus relatórios na Web.
<%@ page errorPage="error.jsp" %>
<%@ page import="datasource.*" %>
<%@ page import="net.sf.jasperreports.engine.*" %>
<%@ page import="java.util.*" %>
<%@ page import="java.io.*" %>
<%
String url = “jdbc:oracle:thin:@localhost:1521:MYDATABASE”;
String login = “java”;
String Senha = “java”;
File reportFile = new File(application.getRealPath("classic.jasper"));
if (!reportFile.exists())
throw new JRRuntimeException("Arquivo classic.jasper não
encontrado.");
//Abre conexão com o banco de dados
Connection conn =
Map parameters = new HashMap();
parameters.put("ReportTitle", "Address Report");
parameters.put("BaseDir", reportFile.getParentFile());
byte[] bytes =
JasperRunManager.runReportToPdf(
reportFile.getPath(),
parameters,
conn
);
response.setContentType("application/pdf");
response.setContentLength(bytes.length);
ServletOutputStream ouputStream = response.getOutputStream();
ouputStream.write(bytes, 0, bytes.length);
ouputStream.flush();
ouputStream.close();
%>
13.6 Gerando o seu relatório em formato HTML
Se você quiser exibir os seus relatórios diretamente na sua aplicação Web em formato
HTML, o código a seguir, mostra como fazer isso.
<%@ page import="net.sf.jasperreports.engine.*" %>
<%@ page import="net.sf.jasperreports.engine.util.*" %>
<%@ page import="net.sf.jasperreports.engine.export.*" %>
<%@ page import="java.util.*" %>
<%@ page import="java.io.*" %>
<%
String url = “jdbc:oracle:thin:@localhost:1521:MYDATABASE”;
String login = “java”;
String Senha = “java”;
File reportFile = new

______________________________________________________________________________________________
File(application.getRealPath("/reports/WebappReport.jasper"));
if (!reportFile.exists())
throw new JRRuntimeException("Arquivo WebappReport.jasper não
encontrado.");
JasperReport jasperReport =
(JasperReport)JRLoader.loadObject(reportFile.getPath());
//Abre conexão com o banco de dados
Connection conn =
Map parameters = new HashMap();
parameters.put("ReportTitle", "Relatorio Web");
parameters.put("BaseDir", reportFile.getParentFile());
JasperPrint jasperPrint =
JasperFillManager.fillReport(
jasperReport,
parameters,
conn
);
JRHtmlExporter exporter = new JRHtmlExporter();
Map imagesMap = new HashMap();
session.setAttribute("IMAGES_MAP", imagesMap);
exporter.setParameter(JRExporterParameter.JASPER_PRINT, jasperPrint);
exporter.setParameter(JRExporterParameter.OUTPUT_WRITER, out);
exporter.setParameter(JRHtmlExporterParameter.IMAGES_MAP, imagesMap);
exporter.setParameter(JRHtmlExporterParameter.IMAGES_URI, "image.jsp?
image=");
exporter.exportReport();
%>
Como você pode observar no código acima, o relatório gerado no iReport,
WebappReport.jasper, é carregado (JRLoader.loadObject(...)) e logo após executado
(JasperFillManager.fillReport(...)). Após o relatório executado, ele é expotardo para o formato
HTML. Objeto exporter é setado em seus parâmetros, indicando qual é o relatório a ser exportado
(jasperPrint) e para onde deve ser exportado (out – a página JSP). O comando exportReport( )
realiza por fim a exportação.
Exercícios:
1 – Crie uma aplicação Java que visualize o relatório gerado pelo iReport (.jasper) e depois salve
o mesmo em um arquivo em fomrato PDF. Abra o PDF para conferir o seu relatório.
2 – Crie uma aplicação Web. Construa uma página JSP que carregue o relatório gerado pelo iReport
e mostra como formato PDF.
3 – Crie uma outra página JSP na sua aplicação Web que mostra o conteúdo do seu relatório
diretamente na página JSP com formato HTML.
4 - Experimente passar parâmetros para a sua query através das páginas JSP. Não esqueça de
carregar um relatório que aceita parâmetros e lembre o nome do parâmetro a ser usado.

______________________________________________________________________________________________
O que é Thread ?
O conceito de thread está intimamente ligado ao conceito de processo, assim é fundamental
entender o que são processos, como eles são representados e colocados em execução pelo
Sistema Operacional, para em seguida entender as threads. Dessa forma segue uma breve defini-
ção de Processo e posteriormente a de Thread.
Definição de Processo:
“Um processo é basicamente um programa em execução, sendo constituído do código ex-
ecutável, dos dados referentes ao código, da pilha de execução, do valor do contador de programa
(registrador PC), do valor do apontador do apontador de pilha (registrador SP), dos valores dos
demais registradores do hardware, além de um conjunto de outras informações necessárias à ex-
ecução dos programas.” Tanenbaum
Podemos resumir a definição de processo dizendo que o mesmo é formado pelo seu espaço
de endereçamento lógico e pela sua entrada na tabela de processos do Sistema Operacional. As-
sim um processo pode ser visto como uma unidade de processamento passível de ser executado
em um computador e essas informações sobre processos são necessárias para permitir que vários
processos possam compartilhar o mesmo processador com o objetivo de simular paralelismo na
execução de tais processos através da técnica de escalonamento, ou seja, os processos se reve-
zam (o sistema operacional é responsável por esse revezamento) no uso do processador e para
permitir esse revezamento será necessário salvar o contexto do processo que vai ser retirado do
processador para que futuramente o mesmo possa continuar sua execução.
Definição de Thread:
“Thread, ou processo leve, é a unidade básica de utilização da CPU, consistindo de : contador
de programa, conjunto de registradores e uma pilha de execução. Thread são estruturas de ex-
ecução pertencentes a um processo e assim compartilham os segmentos de código e dados e os
recursos alocados ao sistema operacional pelo processo. O conjunto de threads de um processo é
chamado de Task e um processo tradicional possui uma Task com apenas uma thread.” Silber-
schatz
O conceito de thread foi criado com dois objetivos principais: Facilidade de comunicação entre
unidades de execução e redução do esforço para manutenção dessas unidades. Isso foi conse-
guido através da criação dessas unidades dentro de processos, fazendo com que todo o esforço
para criação de um processo, manutenção do Espaço de endereçamento lógico e PCB, fosse apro-
veitado por várias unidades processáveis, conseguindo também facilidade na comunicação entre
essas unidades.
Dessa forma o escalonamento de threads de um mesmo processo será facilitado pois a troca
de contexto entre as threads exigirá um esforço bem menor. Sendo que ainda assim, ocorrerá o
escalonamento de processos, pois outros processos poderão estar sendo executado paralelamente
ao processo que possui as threads. Podemos concluir então que a real vantagem é obtida no es-
calonamento de threads de um mesmo processo e na facilidade de comunicação entre essas thre-
ads.
Threads em Java 14

______________________________________________________________________________________________
Paralelismo x Concorrência:
Threads podem executar suas funções de forma paralela ou concorrente, onde quando as
threads são paralelas elas desempenham o seus papeis independente uma das outras. Já na exe-
cução concorrente, as threads atuam sobre objetos compartilhados de forma simbiótica necessi-
tando de sincronismo no acesso a esses objetos, assim deve ser garantido o direito de atomicidade
e exclusão mútua nas operações das threads sobre objetos compartilhados.
14.1 Thread em Java
Todo programador está familiarizado com a programação sequencial, pois sem dúvida até o
presente momento esta é a forma de programação mais comum. Programas do tipo “Hello World”,
ou que ordenam uma lista de nome, ou que gera e imprime uma lista de números primos, etc são
programas tipicamente sequenciais, onde cada um possui: seu início, sequência de execução e fim
e em qualquer momento da sua execução estes programas possuem apenas um ponto de ex-
ecução.
Uma thread é similar ao programas sequenciais, pois possui um início, sequência de execu-
ção e um fim e em qualquer momento uma thread possui um único ponto de execução. Contudo,
uma thread não é um programa, ela não pode ser executada sozinha e sim inserida no contexto de
uma aplicação, onde essa aplicação sim, possuirá vários pontos de execuções distintos, cada um
representado por uma thread. A figura abaixo descreve esse mecanismo de funcionamento da
thread dentro de um programa em execução.
Definição: Uma thread representa um fluxo de controle de execução dentro de um programa.
Não há nada de novo nesse conceito de processo com uma única thread, pois o mesmo é
idêntico ao conceito tradicional de processo. O grande benefício no uso de thread é quando temos
várias thread num mesmo processo sendo executadas simultaneamente e podendo realizar tarefas
diferentes. A figura abaixo representa um processo com múltiplas threads (Programação Multi-
Thread.)
Programa em Execução - Processo
Espaço de
Endereçamento
Lógico
Segmento de
Texto
Segmento de
Dados
Segmento de
Pilha
Thread
Texto
Pilha de
Execução
Registradores
Process
Control
Block
(PCB)
Informações
para Gerência
do Processo
Informações
para Gerência
de Memória
Informações
para Gerência
de Arquivos
Processo com apenas uma Thread

______________________________________________________________________________________________
Definição : Com múltiplas theads um programa possui múltiplos pontos de execução
Dessa forma podemos perceber facilmente que aplicações multithreads podem realizar
tarefas distintas ao “mesmo tempo”, dando idéia de paralelismo. Veja um exemplo do navegador
web HotJava, o qual consegue carregar e executar applets, executar uma animação, tocar um som,
exibir diversas figuras, permitir rolagem da tela, carregar uma nova página, etc e para o usuário
todas essas atividades são simultâneas, mesmo possuindo um único processador. Isso é possível,
por que dentro da aplicação do navegador HotJava várias threads foram executadas, provavel-
mente, uma para cada tarefa a ser realizada.
Alguns autores tratam threads como processos leves. Uma thread é similar a um processo no
sentido que ambos representam um único fluxo de controle de execução, sendo considerada um
processo leve por ser executada dentro do contexto de um processo e usufruir dos recursos aloca-
dos pelo processo. Cada thread necessita possuir apenas as informações (contador de programa
e pilha de execução) necessárias a sua execução, compartilhando todo o contexto de execução do
processo com todas a demais threads do mesmo processo.
A linguagem Java possui apenas alguns mecanismos e classes desenhadas com a finalidade
de permitir a programação Multi-Thread, o que torna extremamente fácil implementar aplicações
Multi-Threads, sendo esses:
 A classe java.lang.Thread utilizada para criar, iniciar e controlar Threads;
 As palavras reservadas synchronized e volatile usadas para controlar a execução de código
em objetos compartilhados por múltiplas threads, permitindo exclusão mútua entre estas;
 Os métodos wait, notify and notifyAll definidos em java.lang.Object usados para coordenar
as atividades das threads, permitindo comunicação entre estas.
14.2 Criando Threads em Java
A criação de threads em java é uma atividade extremamente simples e existem duas formas
distintas de fazê-lo: uma através da herança da classe Thread, outra através da implementação da
interface Runnable, e em ambos os casos a funcionalidade (programação) das threads é feita na
implementação do método run.
Programa em Execução - Processo
Espaço de
Endereçamento
Lógico
Segmento de
Texto
Segmento de
Dados
Segmento de
Pilha
Thread
Texto
Pilha de
Execução
Registradores
Process
Control Block
(PCB)
Informações
para Gerência
do Processo
Informações
para Gerência
de Memória
Informações
para Gerência
de Arquivos
Processo com múltiplas Threads
Thread
Texto
Pilha de
Execução
Registradores
...

______________________________________________________________________________________________
14.2.1 Implementando o Comportamento de uma Thread
O método run contém o que a thread faz, ele representa o comportamento (implementação)
da thread, é como um método qualquer podendo fazer qualquer coisa que a linguagem Java per-
mita. A classe Thread implementa uma thread genérica que por padrão não faz nada, contendo um
método run vazio, definindo assim uma API que permite a um objeto runnable prover uma imple-
mentação para o método run de uma thread.
14.2.2 Criando uma subclasse de Thread
A maneira mais simples de criar uma thread em Java é criando uma subclasse de Thread e
implementando o que a thread vai fazer sobrecarregando o método run.
Exemplo de criação de threads estendendo a classe Thread
/** Criação de NovaThread através da herança da classe Thread */
public class NovaThread extends Thread {
/** Construtor de NovaThread*/
public NovaThread (String threadName) {
/* construtor de Thread passando o nome da Thread como parâmetro */
super(threadName);
}
/** método run o qual representa o comportamento de NovaThread */
public void run () {
/* Implementação do comportamento da thread */
}
}
14.2.3 Implementando a Interface Runnable
A outra forma de criar threads em Java é implementando a interface Runnable e implemen-
tando o método run definido nessa interface. Sendo que a classe que implementa a thread deve
declarar um objeto do tipo Thread e para instanciá-lo deve chamar o construtor da classe Thread
passando como parâmetro a instância da própria classe que implementa Runnable e o nome da
thread. Como o objeto do tipo Thread é local a classe que vai implementar thread, e normalmente
privado, há a necessidade de criação de um método start para permitir a execução do objeto thread
local. O mesmo deve ser feito para qualquer outro método da classe Thread que dever ser visto ou
usado fora da classe que implementa Runnable.
Exemplo de thread implementando a interface Runnable
/** Criação de NovaThread através da implementação da Interface Runnable */
public class NovaThread implements Runnable {
/* Objeto local do tipo Thread*/
private Thread thread = null;
/* Construtor da classe */
public NovaThread (String threadName) {

______________________________________________________________________________________________
/* Caso o objeto thread local não tiver sido criado ainda */
if (thread == null) {
/* A mesma deve ser instanciada com o nome recebido no construtor
* Detalhe importante é que uma instância da própria classe (this)
* também é passada ao construtor da classe Thread permitindo assim
* a associação do método run com a thread
*/
thread = new Thread(this, threadName);
}
}
/* Método para iniciar o objeto thread local */
public void start() {
thread.start();
}
/* Comportamento da thead */
}
}
14.2.4 Escolhendo entre os dois métodos de criação de threads
O principal fator a ser levado em consideração na escolha entre um dos dois métodos de
criação de thread é que a linguagem Java não permite herança múltipla, assim quando uma classe
que já for sub-classe de outra precisar implementar thread é obrigatório que isso seja feito através
da implementação da interface Runnable, caso contrário pode-se utilizar sub-classes da classe
Thread. Um exemplo claro desse fator de escolha é na implementação de Applet as quais obriga-
toriamente devem ser sub-classes da classe Applet, assim applets só podem implementar threads
através da implementação da interface Runnable.
Um exemplo mais interessante de threads em Java
Simulação de uma Corridas de Sapos, onde cada sapo na corrida é representado por uma
thread.
/* Aplicação que simula uma corrida de sapos usando threads */
public class CorridaDeSapos {
final static int NUM_SAPOS = 5;// QTE. de sapos na corrida
final static int DISTANCIA = 500; // Distância da corrida em cm
public static void main (String[] args) {
/* colocando sapos na corrida */
for (int i = 1; i <= NUM_SAPOS; i++) {
new SapoCorrendoThread("SAPO_" + i, DISTANCIA).start();
}
}
}
/* Classe usando Thread que simula a corrida de um sapo */
class SapoCorrendoThread extends Thread {
String nome; // nome do sapo
int distanciaCorrida = 0; // distância já corrida pelo sapo
int distanciaTotalCorrida; // distância a ser corrida pelo sapo
int pulo = 0; // pulo do sapo em cm

______________________________________________________________________________________________
int pulos = 0; // quantidades de pulos dados na corrida
static int colocacao = 0; // colocação do sapo ao final da corrida
final static int PULO_MAXIMO = 50; // pulo máximo em cm que um sapo pode dar
/** Construtor da classe. Parâmtros : Nome do Sapo e Distância da Corrida */
public SapoCorrendoThread (String nome, int distanciaTotalCorrida) {
/* chamando o construtor de Thread passando o nome do sapo como parâmetro */
super(nome);
this.distanciaTotalCorrida = distanciaTotalCorrida;
this.nome = nome;
}
/** Imprime o último pulo do sapo e a distância percorrida */
public void sapoImprimindoSituacao () {
System.out.println("O " + nome + " pulou " + pulo + "cm t e já percorreu " +
distanciaCorrida + "cm");
}
/** Faz o sapo pular */
public void sapoPulando() {
pulos++;
pulo = (int) (Math.random() * PULO_MAXIMO);
distanciaCorrida += pulo;
if (distanciaCorrida > distanciaTotalCorrida) {
distanciaCorrida = distanciaTotalCorrida;
}
}
/** Representando o descanso do sapo */
public void sapoDescansando () {
/* Método que passa vez a outras threads */
yield();
}
/** Imprime a colocação do sapo ao final da corrida */
public void colocacaoSapo () {
colocacao++;
System.out.println(nome + " foi o " + colocacao +
"º colocado com " + pulos + " pulos");
}
/** Método run da thread Corrida de Sapos */
while (distanciaCorrida < distanciaTotalCorrida) {
sapoPulando();
sapoImprimindoSituacao();
sapoDescansando();
}
colocacaoSapo();
}
}
Resultado da Execução – Corrida de Sapos
O SAPO_01 pulou 21cm e já percorreu 21cm

______________________________________________________________________________________________
SAPO_03 foi o 1º colocado com 7 pulos

______________________________________________________________________________________________
14.2.5 O ciclo de vida de uma Thread
A melhor forma de analisar o ciclo de vida de uma thread é através das operações que podem
ser feitas sobre as mesmas, tais como : criar, iniciar, esperar, parar e encerrar. O diagrama abaixo
ilustra os estados os quais uma thread pode assumir durante o seu ciclo de vida e quais métodos
ou situações levam a estes estados.
Ciclo de vida de uma thread
(Nova/Executando/Pronta/Esperando/Morta)
14.2.6 Criando Threads
A criação de uma thread é feita através da chamado ao seu construtor colocando a thread no
estado Nova, o qual representa uma thread vazia, ou seja, nenhum recurso do sistema foi alocado
para ela ainda. Quando uma thread está nesse estado a única operação que pode ser realizada é
a inicialização dessa thread através do método start(), se qualquer outro método for chamado com
a thread no estado Nova irá acontecer uma exceção (IllegalThreadStateException), assim como,
quando qualquer método for chamado e sua ação não for condizente com o estado atual da thread.
14.2.7 Iniciando Threads
A inicialização de uma thread é feita através do método start() e nesse momento os recursos
necessários para execução da mesma são alocados, tais como recursos para execução, escalo-
namento e chamada do método run da thread. Após a chamada ao método start a thread está
pronta para ser executada e será assim que for possível, até lá ficará no estado Pronta. Essa
mudança de estado (Pronta/Executando) será feito pelo escalonador do Sistema de Execução
Java. O importante é saber que a thread está pronta para executar e a mesma será executada,
Estados de Threads
Esperando
Pronta
Nova
Executando
Morta
start()
newThread()
Escalonado
r
Escalonador
yield()
Método run acabar
 sleep(tempo)
 wait()
 Solicitação de I/O
 Solicitação de I/O atendida
 Tempo do sleep decorrido
 Outra thread chamar notify() / notifyAll()

______________________________________________________________________________________________
mais cedo ou mais tarde de acordo com os critérios, algoritmo, de escalonamento do Sistema de
Execução Java.
14.2.8 Fazendo Thread Esperar
Uma thread irá para o estado Esperando quando:
 O método sleep (faz a thread esperar por um determinada tempo) for chamado;
 O método wait (faz a thread esperar por uma determinada condição) for chamado;
 Quando realizar solicitação de I/O.
Quando um thread for para estado Esperando ela retornará ao estado Pronta quando a con-
dição que a levou ao estado Esperando for atendida, ou seja:
 Se a thread solicitou dormir por determinado intervalo de tempo (sleep), assim que
este intervalo de tempo for decorrido;
 Se a thread solicitou esperar por determinado evento (wait), assim que esse evento
ocorrer (outra thread chamar notify ou notifyAll);
 Se a thread realizou solicitação de I/O, assim que essa solicitação for atendida.
14.2.9 Finalizando Threads
Uma Thread é finalizada quando acabar a execução do seu método run, e então ela vai para
o estado Morta, onde o Sistema de Execução Java poderá liberar seus recursos e eliminá-la.
14.2.9.1 Verificando se Threads estão Executando/Pronta/Esperando ou Novas/Mortas
A classe Thread possui o método isAlive, o qual permite verificar se uma thread está nos
estado Executando/Pronta/Esperando ou nos estados Nova/Morta. Quando o retorno do método
for true a thread esta participando do processo de escalonamento e o retorno for false a thread
está fora do processo de escalonamento. Não é possível diferenciar entre Executando, Pronta ou
Esperando, assim também como não é possível diferenciar entre Nova ou Morta.
14.10 Threads Daemon
São threads que rodam em background e realizam tarefas de limpeza ou manutenção, as
quais devem rodar enquanto a aplicação estiver em execução, as threads daemons somente mor-
rerem quando a aplicação for encerrada. Sendo que o Sistema de Execução Java identifica que
uma aplicação acabou quando todas as suas threads estão morta, assim para que seja possível
que uma aplicação seja encerrada ainda possuindo threads, tais threads devem ser daemon. Em
outras palavras, o Sistema de Execução Java irá terminar uma aplicação quando todas as suas
threads não daemon morrerem. Threads daemons são denominadas de Threads de Serviço e as
não daemon são denominadas de Threads de Usuário.
Os métodos para manipulação de threads daemon são:
public final void setDaemon(boolean) Torna ou não uma thread daemon
public final boolean isDaemon() Verifica se uma thread é daemon

______________________________________________________________________________________________
14.11 Escalonamento de Threads
O escalonamento é fundamental quando é possível a execução paralela de threads, pois,
certamente existirão mais threads a serem executadas que processadores, assim a execução pa-
ralela de threads é simulada através de mecanismos do escalonamento dessas threads, onde os
processadores disponíveis são alternados pelas diversas threads em execução. O mecanismo de
escalonamento utilizado pelo Sistema de Execução Java é bastante simples e determinístico, e
utiliza um algoritmo conhecido como Escalonamento com Prioridades Fixas, o qual escalona
threads baseado na sua prioridade. As threads escalonáveis são aquelas que estão nos estados
Executando ou Pronta, para isso toda thread possui uma prioridade, a qual pode ser um valor
inteiro no intervalo [MIN_PRIORITY ... MAX_PRIORITY], (estas são constantes definidas na classe
Thread), e quanto maior o valor do inteiro maior a prioridade da thread. Cada thread Nova recebe
a mesma prioridade da thread que a criou e a prioridade de uma thread pode ser alterada através
do método setPriority(int priority).
O algoritmo de escalonamento com Prioridades Fixas utilizado pela Sistema de Execução
Java funcionada da seguinte forma:
1. Quando várias threads estiverem Prontas, aquela que tiver a maior prioridade será
executada.
2. Quando existir várias threads com prioridades iguais, as mesmas serão escalonadas
segundo o algoritmo Round-Robin de escalonamento.
3. Uma thread será executada até que: uma outra thread de maior prioridade fique Pronta;
acontecer um dos eventos que a faça ir para o estado Esperando; o método run acabar;
ou em sistema que possuam fatias de tempo a sua fatia de tempo se esgotar.
4. Threads com prioridades mais baixas terão direito garantido de serem executadas para
que situações de starvation não ocorram.
Exemplo de aplicação usando threads com diferentes prioridades
Observe que essa corrida não é justa pois os sapos 4 e 5 possuem prioridades máximas e
com certeza ganharão a corrida.
/* Aplicação que simula uma corrida de sapos usando threads */
public class CorridaDeSapos {
final static int NUM_SAPOS = 5; // QTE. de sapos na corrida
final static int DISTANCIA = 500; // Distância da corrida em cm
/* Criando as threads para representar os sapos correndo */
SapoCorrendoThread sapo_1 = new SapoCorrendoThread("SAPO_01",
DISTANCIA);
DISTANCIA);
DISTANCIA);
DISTANCIA);
DISTANCIA);
/* Estabelecendo prioridades para as threads */
sapo_1.setPriority(Thread.MIN_PRIORITY);

______________________________________________________________________________________________
sapo_2.setPriority(Thread.MIN_PRIORITY);
sapo_3.setPriority(Thread.NORM_PRIORITY);
sapo_4.setPriority(Thread.MAX_PRIORITY);
sapo_5.setPriority(Thread.MAX_PRIORITY);
/* Iniciando as threads */
sapo_1.start();
sapo_2.start();
sapo_3.start();
sapo_4.start();
sapo_5.start();
}
}
14.12 Sincronizando Threads (Concorrência)
Até o momento temos abordado threads como unidades de processamento independentes,
onde cada uma realiza a sua tarefa sem se preocupar com o que as outras threads estão fazendo
(paralelimos), ou seja, abordamos threads trabalhando de forma assíncrona e embora a utilização
de threads dessa maneira já seja de grande utilidade, muitas vezes precisamos que um grupo de
threads trabalhem em conjunto e agindo sobre objetos compartilhados, onde várias threads desse
conjunto podem acessar e realizar operações distintas sobre esses objetos, sendo que, muitas
vezes a tarefa de uma thread vai depender da tarefa de outra thread, dessa forma as threads terão
que trabalhar de forma coordenada e simbiótica, ou seja, deverá haver uma sincronização entre as
threads para que problemas potenciais advindos do acesso simultâneo a esses objetos com-
partilhado não ocorram.
Esses problemas são conhecidos como condições de corrida (Race Conditions) e os trechos
de códigos, das threads, que podem gerar condições de corrida são chamados de regiões críticas
(critical sections), assim as condições de corridas podem ser evitadas através da exclusão mútua
das regiões críticas das threads e sincronização entre as threads envolvidas.
O mecanismo para prover exclusão mútua entre threads em Java é bastante simples, neces-
sitando apenas da declaração dos métodos que contém regiões críticas como synchronized. Isso
garante que quando uma das threads estiver executando uma região crítica em um objeto compar-
tilhado nenhuma outra poderá fazê-lo. Ou seja, quando uma classe possuir métodos sincronizados,
apenas um deles poderá estar sendo executado por uma thread.
14.13 Implementando Exclusão Mútua de Regiões Críticas
A sincronização entre threads, que acessam concorrentemente um mesmo objeto com-
partilhado, é feita da seguinte forma: a classe do objeto compartilhado deve possuir métodos que
realizem as operações de interesse das threads que o acessam e esses métodos devem ser
declarados como synchronized, garantido que somente uma thread por vez poderá executar um
desses métodos. Assim é fácil perceber que o mecanismo descrito acima fornece, de forma sim-
ples, a exclusão mútua de regiões críticas a qual é garantida pelo Sistema de Execução Java.
Fazendo uma relação com a teoria de Sistemas Operacionais a linguagem de programação Java
fornece um MONITOR, onde o Compilador e o Sistema de Execução garantem a exclusão mútua
e sincronia, provendo assim um mecanismo de alto nível para facilitar a criação de aplicações Multi-
Threads.

______________________________________________________________________________________________
14.14 Comunicação Entre Threads
Um outro aspecto muito importante na implementação de threads que trabalham concorren-
temente sobre um objeto compartilhado é que muitas vezes a atividade de uma thread depende da
atividade de outra thread, assim é necessário que as threads troquem mensagem afim de avisarem
umas as outras quando suas tarefas forem concluídas ou quando precisam esperar por tarefas de
outras. Em Java isso é feito através dos métodos wait, notify, notifyAll, onde:
wait Faz a thread esperar (coloca no estado Esperando) em um objeto
compartilhado, até que outra thread a notifique ou determinado intervalo de
tempo seja decorrido.
notify Notifica (retira do estado Esperando) uma thread que esta esperando em um
objeto compartilhado.
notifyAll Notifica todas as threads que estão esperando em um objeto compartilhado,
onde uma delas será escalonada para usar o objeto e as outras voltarão ao
estado Esperando.
Observação: Esses métodos devem ser usados na implementação das operações dos objetos
sincronizados, ou seja, nos métodos synchronized dos objetos sincronizados. Pois só faz sentido
uma thread notificar ou esperar por outra em objetos sincronizados e o Sistema de Execução Java
tem mecanismos para saber qual thread irá esperar ou receber a notificação, pois somente uma
thread por vez pode estar executando um método sincronizado de um objeto compartilhado.
14.15 Evitando Starvation e Deadlock
Com a programação concorrente de diversas threads que trabalham em conjunto e acessam
objetos compartilhados surge o risco potencial de Starvation e Deadlock, onde Starvation acontece
quando uma thread fica esperando por um objeto que nunca lhe será concedido e o Deadlock é
quando duas ou mais threads esperam, de forma circular, por objetos compartilhados e nenhuma
delas será atendida pelo fato de esperar umas pelas outras.
Na programação Java Starvation e Deadlock devem ser evitados pelo controle lógico de
acesso aos objetos compartilhados, fazendo com que o programador deva identificar situação que
possam gerar Starvation e Deadlock e evitá-las de alguma forma e com certeza essa é a tarefa
mais desafiadora e trabalhosa na programação concorrente.
Agrupando Threads
Toda thread Java é membro de um grupo. Grupo de threads é um mecanismo para agrupar
várias threads em um único objeto e permitir realizar operações sobre todas elas mais facilmente.
O Sistema de Execução Java coloca threads em grupos no momento da sua criação. Quando uma
thread é criada a mesma é colocada num grupo padrão pelo Sistema de Execução Java ou o grupo
pode ser especificado pelo programador. Uma vez criada, a thread é membro permanente do seu
grupo e a mesma não pode ser movida para outro grupo.
O Grupo Padrão de Threads
Quando uma thread é criada sem a especificação de um grupo no seu construtor, o Sistema
de Execução Java a coloca no mesmo grupo da thread que a criou. Quando uma thread for criada

______________________________________________________________________________________________
em uma aplicação sem a especificação de um grupo a mesma será colocada no grupo padrão
“main” o qual é criado na inicialização da aplicação pelo Sistema de Execução Java.
É muito comum que o programa não se preocupe com grupos no uso de threads em Java
deixando que o Sistema de Execução Java faça a tarefa de agrupar as threads. Mas, quando uma
aplicação for trabalhar com diversas threads é mais conveniente agrupá-las, pois algumas
operações deverão ser feitas sobre todas as threads e a criação de grupos de threads irá facilitar
tais operações.
Criando Grupos de Threads e Inserindo Threads
A criação de um grupo de threads é feita através do construtor da classe ThreadGroup, onde
basta informar o nome do grupo:
 GroupThread grupoDeThreads = new GroupThread(“Nome Grupo de Threads”)
A colocação de threads em grupos é realizada no momento da sua criação para isso, existem
três construtores onde é possível informar o grupo ao qual a thread deve ser inserida.
public Thread(ThreadGroup group, Runnable runnable)
public Thread(ThreadGroup group, String name)
public Thread(ThreadGroup group, Runnable runnable, String name)
Operações sobre Grupos de Threads
As principais operações que podem ser realizadas sobre grupos de threads são:
Método Descrição
getName() Retorna o nome do grupo
toString() Retorna uma representação do grupo em string
list() Imprime informações sobre o grupo no dispositivo padrão de saída
O Exemplo Produtor/Consumidor ou Buffer Limitado
class ProdutorConsumidor {
/* Criando o Buffer Limitado */
BufferLimitado buffer = new BufferLimitado();
/* Quantidade de itens a serem produzidos/consumidos pelas threads */
final int QUANT_ITENS = 10;
/* Quantidade de threads */
final int QUANT_THREADS = 5;
/* Criando os grupos de threads Produtoras/Consumidoras */
ThreadGroup threadsProdutoras = new ThreadGroup("Produtores");
ThreadGroup threadsConsumidoras = new ThreadGroup("Consumidores");
/* Criando e iniciando e inserindo nos grupos as threads Produtoras */
for (int i = 1; i <= QUANT_THREADS; i++){
new ProdutorThread(threadsProdutoras,"Produtor_" + i,
buffer,QUANT_ITENS).start();

______________________________________________________________________________________________
}
/* Criando, iniciando e inserindo nos grupos as threads Consumidoras */
for (int i = 1; i <= QUANT_THREADS; i++){
new ConsumidorThread(threadsConsumidoras,"Consumidor_" + i,
buffer,QUANT_ITENS).start();
}
}
}

______________________________________________________________________________________________
class ProdutorThread extends Thread {
/* objeto para referenciar o buffer */
BufferLimitado buffer;
/* quantidade de itens a serem produzidos */
int quantItens;
/**
* Construtor
* @param threadGroup Grupo da thread
* @param nomeThread Nome da thread
* @param buffer buffer a ser utilizado
* @param quantItens quantidade de itens a serem produzidos
*/
public ProdutorThread (ThreadGroup threadGroup,String nomeThread,
BufferLimitado buffer, int quantItens) {
super(threadGroup, nomeThread);
this.buffer = buffer;
this.quantItens = quantItens;
}
/*
* Método run da thread, o qual contém o ser comportamento
*/
for (int i = 1; i <= quantItens; i++) {
/* Gera um novo item aleatoriamente */
int novoItem = (int) (Math.random() * 10);
/* Insere o novo item no buffer */
buffer.insere(novoItem);
/* dorme pelo intervalo de tempo aleatório [0 ... 100]mseg */
int tempo = (int) (Math.random() * 1000);
dorme(tempo);
}
}
private void dorme(int tempo) {
try {
sleep(tempo);
} catch (InterruptedException e) {
System.out.println(e.getMessage());
}
}
}

______________________________________________________________________________________________
class ConsumidorThread extends Thread {
/* objeto para referenciar o buffer */
BufferLimitado buffer;
/* quantidade de itens a serem consumidos */
int quantItens;
/**
* Construtor
* @param threadGroup Grupo da thread
* @param nomeThread Nome da thread
* @param buffer buffer a ser utilizado
* @param quantItens quantidade de itens a serem consumidos
*/
public ConsumidorThread (ThreadGroup threadGroup, String nomeThread,
BufferLimitado buffer, int quantItens) {
super(threadGroup, nomeThread);
this.buffer = buffer;
this.quantItens = quantItens;
}
/*
* Método run da thread, o qual contém o ser comportamento
*/
for (int i = 1; i <= quantItens; i++) {
/* Retita um elemtno do buffer */
buffer.retira();
/* dorme pelo intervalo de tempo aleatório [0 ... 100]mseg */
int tempo = (int) (Math.random() * 1000);
dorme(tempo);
}
}
private void dorme(int tempo) {
try {
sleep(tempo);
System.out.println(e.getMessage());
}
}
}

______________________________________________________________________________________________
class BufferLimitado {
/* tamano do buffer */
private final static int TAMANHO = 5;
/* buffer */
private int[] buffer = new int[TAMANHO];
/* posição para insercão de novo item (in) */
private int posicaoInsere = 0;
/* posição para remoção do item (out) */
private int posicaoRetira = 0;
/* quantidades de itens no buffer */
private int quantItens = 0;
/* Construtor */
public BufferLimitado () {
}
/**
* Insere um novo item no buffer
* @param novoItem item a ser inserido no buffer
*/
synchronized public void insere (int novoItem) {
/* enquanto o buffer estiver cheio a thread deve esperar */
while (quantItens == TAMANHO) {
try {
wait();
} catch (InterruptedException e){
System.out.println("Erro de Estado da Thread "
+ e.getMessage());
}
}
/* colocando novo item no buffer */
buffer[posicaoInsere] = novoItem;
/* exibindo informções sobre a inserção do novo item */
System.out.print("Inserindo " + novoItem + "tna posição " + posicaoInsere + "t");
/* atualizando a posição de inserção */
posicaoInsere = proximaPosicao(posicaoInsere);
/* incrementando a quantidade de itens no buffer */
quantItens++;
/* imprimindo o buffer */
imprime();
/* caso o buffer estivesse vazio, acordar as threads consumidoras */
if (quantItens == 1) {
notifyAll();
}
}

______________________________________________________________________________________________
/**
* Retira um item do buffer
* @return Item retirado do buffer
*/
synchronized public int retira () {
int itemRetirado; // item retirado
/* enquanto o buffer estiver vazio a thread deve esperar */
while (quantItens == 0) {
try {
wait();
System.out.println("Erro de Estado da Thread "
+ e.getMessage());
}
}
/* armazendo o item a ser retirado */
itemRetirado = buffer[posicaoRetira];
/* atualizando a quantidade de itens */
quantItens--;
/* exibindo informações sobre a retirado do item do buffer */
System.out.print("Retirando " + itemRetirado
+ "tda posição " + posicaoRetira + "t");
/* atualizando a posição de retirado */
posicaoRetira = proximaPosicao(posicaoRetira);
/* imprimindo o buffer */
imprime();
/* caso o buffer estivesse cheio, acordar as threads produtoras */
if (quantItens == TAMANHO - 1) {
notifyAll();
}
/* retorna o item retirado */
return itemRetirado;
}
/**
* Obtem a próxima posição no buffer
* @param posicaoAtual a atual posicao no buffer
* @return a prómixa posição no buffer
*/
private int proximaPosicao (int posicaoAtual) {
/* obtem a nova posição */
int novaPosicao = ++posicaoAtual;
/* caso ultrapasse o tamanho do buffer,irá para o 1ª posição (0) */
if (novaPosicao > TAMANHO - 1) {
novaPosicao = 0;
}
return novaPosicao;
}
/**
* Obtem a posição anterior no buffer

______________________________________________________________________________________________
* @param posicaoAtual a atual posicao no buffer
* @return a posição anterior no buffer
*/
private int posicaoAnterior (int posicaoAtual) {
/* obtem a nova posição */
int novaPosicao = --posicaoAtual;
/* caso seja menor que a posição inicial, irá para a última posição */
if (novaPosicao < 0) {
novaPosicao = TAMANHO-1;
}
return novaPosicao;
}
/*
* Imprime o buffer
*/
synchronized private void imprime () {
/* posição inicial da impressão */
int inicio = posicaoRetira;
/* posição final da impressão */
int fim = posicaoAnterior(posicaoInsere);
/* posição impressa */
int i = inicio;
/* quantidade de itens impressos */
int quantItensImpressos = 0;
System.out.print("tBuffer[" + quantItens + "] t= ");
while (quantItensImpressos < quantItens) {
System.out.print(buffer[i] + " ");
i = proximaPosicao(i);
quantItensImpressos++;
}
System.out.println();
}
}
Resultado da Execução – Produtor/Consumidor:
Inserindo 5 na posição 0 Buffer[1] = 5
Inserindo 0 na posição 1 Buffer[2] = 5 0
Inserindo 1 na posição 2 Buffer[3] = 5 0 1
Inserindo 5 na posição 3 Buffer[4] = 5 0 1 5
Inserindo 9 na posição 4 Buffer[5] = 5 0 1 5 9
Retirando 5 da posição 0 Buffer[4] = 0 1 5 9
Retirando 0 da posição 1 Buffer[3] = 1 5 9
Retirando 1 da posição 2 Buffer[2] = 5 9
Retirando 5 da posição 3 Buffer[1] = 9
Retirando 9 da posição 4 Buffer[0] =
Inserindo 8 na posição 0 Buffer[1] = 8
Inserindo 6 na posição 1 Buffer[2] = 8 6

______________________________________________________________________________________________
.
.
.

______________________________________________________________________________________________
O Exemplo do Jantar dos Filósofos Glutões
Exemplo para demonstrar o controle e esforço necessário para prevenção de Starva-
tion/Deadlocks
class JantarDosFilosofos {
/* Mesa de jantar para os filósofos */
MesaDeJantar mesa = new MesaDeJantar ();
/* Criação das threads representando os cinco filósofos */
for (int filosofo = 0; filosofo < 5; filosofo++) {
new Filosofo("Filosofo_" + filosofo, mesa, filosofo).start();
}
}
}

______________________________________________________________________________________________
class Filosofo extends Thread {
/* Tempo máximo (em milesegundos) que o filósofo vai comer ou pensar */
final static int TEMPO_MAXIMO = 100;
/* Referência à mesa de jantar */
MesaDeJantar mesa;
/* Filósofo na mesa [0,1,2,3,4] */
int filosofo;
public Filosofo (String nomeThread, MesaDeJantar mesa, int filosofo) {
/* construtor da classe pai */
super(nomeThread);
this.mesa = mesa;
this.filosofo = filosofo;
}
int tempo = 0;
/* Laço representando a vida de um filósofo : pensar e comer */
while (true) {
/* sorteando o tempo pelo qual o filósofo vai pensar */
tempo = (int) (Math.random() * TEMPO_MAXIMO);
/* filósofo pensando */
pensar(tempo);
/* filósofo pegando garfos */
pegarGarfos();
/* sorteando o tempo pelo qual o filósofo vai comer */
tempo = (int) (Math.random() * TEMPO_MAXIMO);
/* filósofo comendo */
comer(tempo);
/* filósofo devolvendo garfos */
devolverGarfos();
}
}
/* simula o filósofo pensando */
private void pensar (int tempo) {
try {
/* filósofo dorme de tempo milisegundos */
sleep(tempo);
System.out.println("Filófoso pensou demais, morreu");
}
}
/* simula o filósofo comendo */
private void comer (int tempo) {
try {
sleep(tempo);
System.out.println("Filófoso comeu demais, morreu");
}
}

______________________________________________________________________________________________
/* pega os garfos */
private void pegarGarfos() {
mesa.pegandoGarfos(filosofo);
}
/* devolve os garfos */
private void devolverGarfos() {
mesa.devolvendoGarfos(filosofo);
}
}

______________________________________________________________________________________________
class MesaDeJantar {
/* filósofo pensando */
final static int PENSANDO = 1;
/* filósofo comendo */
final static int COMENDO = 2;
/* filósofo com fome */
final static int COM_FOME = 3;
/* Quantidade de filósofos */
final static int QUANT_FILOSOFOS = 5;
/* Número do primeiro filósofo */
final static int PRIMEIRO_FILOSOFO = 0;
/* Número do último filósofo */
final static int ULTIMO_FILOSOFO = QUANT_FILOSOFOS - 1;
/* array[0...QUANT_FILOSOFOS - 1] representando os garfos na mesa :
* true = garfo na mesa; false = garfo com filósofo
*/
boolean[] garfos = new boolean[QUANT_FILOSOFOS];
/* array [0...QUANT_FILOSOFOS - 1]
representando o estado de cada um dos filósofos
*/
int[] filosofos = new int[QUANT_FILOSOFOS];
/* Quantas vezes cada filósofo tentou comer e não conseguiu,
* serve para identificar situações de Starvation
*/
int[] tentativasParaComer = new int[QUANT_FILOSOFOS];
/* Construtor */
public MesaDeJantar() {
/* Preenchendo os vetores de Garfos e filósofos à mesa */
for (int i = 0; i < 5; i++) {
/* Todos os garfos estão na mesa */
garfos[i] = true;
/* Todos os filósofos sentam à mesa pensando */
filosofos[i] = PENSANDO;
/* Nenhum filósofo tentou comer ainda */
tentativasParaComer[i] = 0;
}
}
/* filosofo pegando os garfos */
synchronized void pegandoGarfos (int filosofo) {
/* filósofo com fome */
filosofos[filosofo] = COM_FOME;
/* Deve esperar enquanto algum filósofo vizinho estive comendo */
while (filosofos[aEsquerda(filosofo)] == COMENDO
|| filosofos[aDireita(filosofo)] == COMENDO) {
try {
/* Filósofo tentou comer e não conseguiu */
tentativasParaComer[filosofo]++;
/* colocando o filosofo para esperar */
wait();
System.out.println("Filósofo morreu de fome");

______________________________________________________________________________________________
}
}
/* Filósofo conseguiu comer */
tentativasParaComer[filosofo] = 0;
/* retirando os garfos esquerdo e direito da mesa */
garfos[garfoEsquerdo(filosofo)] = false;
garfos[garfoDireito(filosofo)] = false;
/* Filósofo comendo */
filosofos[filosofo] = COMENDO;
imprimeEstadosFilosofos();
imprimeGarfos();
imprimeTentativasParaComer();
}
/* Filosofo devolvendo os garfos */
synchronized void devolvendoGarfos (int filosofo) {
/* Devolvendo os garfos esquerdo e direito da mesa */
garfos[garfoEsquerdo(filosofo)] = true;
garfos[garfoDireito(filosofo)] = true;
/* Verificando se há algum filósofo vizinho com fome */
if (filosofos[aEsquerda(filosofo)] == COM_FOME ||
filosofos[aDireita(filosofo)] == COM_FOME) {
/* Notifica (acorda) os vizinhos com fome */
notifyAll();
}
/* Filósofo pensando */
filosofos[filosofo] = PENSANDO;
imprimeEstadosFilosofos();
imprimeGarfos();
imprimeTentativasParaComer();
}
/* Retorna o número do filósofo a direita */
private int aDireita (int filosofo) {
int direito;
/* Caso seja o filósofo nº5, a sua direita está o filósofo nº1 */
if (filosofo == ULTIMO_FILOSOFO) {
direito = PRIMEIRO_FILOSOFO;
} else {
/* Caso contrário */
direito = filosofo + 1;
}
return direito;
}
/* Retorna o número do filósofo a esquerda */
private int aEsquerda (int filosofo) {
int esquerdo;
/* Caso seja o primeiro filósofo a sua esquerda está o último */
if (filosofo == PRIMEIRO_FILOSOFO) {
esquerdo = ULTIMO_FILOSOFO;
} else {

______________________________________________________________________________________________
esquerdo = filosofo - 1;
}
return esquerdo;
}
/** Retorna o número do garfo a esquerda do filósofo */
private int garfoEsquerdo (int filosofo) {
/* O filósofo 1 possui o garfo 1 a sua esquerda e assim por diante */
int garfoEsquerdo = filosofo;
return garfoEsquerdo;
}
/** Retorna o número do garfo a direita do filósofo */
private int garfoDireito (int filosofo) {
int garfoDireito;
/* O último filósofo possui o garfo 0 a sua direita*/
if (filosofo == ULTIMO_FILOSOFO) {
garfoDireito = 0;
} else {
garfoDireito = filosofo + 1;
}
return garfoDireito;
}
/* Imprimindo os estados dos filósofos */
private void imprimeEstadosFilosofos () {
String texto = "*";
System.out.print("Filósofos = [ ");
for (int i = 0; i < QUANT_FILOSOFOS; i++) {
switch (filosofos[i]) {
case PENSANDO :
texto = "PENSANDO";
break;
case COM_FOME :
texto = "COM_FOME";
break;
case COMENDO :
texto = "COMENDO";
break;
}
System.out.print(texto + " ");
}
System.out.println("]");
}
/* Imprimindo os que estão na mesa */
private void imprimeGarfos () {
String garfo = "*";
System.out.print("Garfos = [ ");

______________________________________________________________________________________________
if (garfos[i]) {
garfo = "LIVRE";
} else {
garfo = "OCUPADO";
}
System.out.print(garfo + " ");
}
}
/* Imprimindo as tentativas de comer dos dos filósofos */
private void imprimeTentativasParaComer () {
System.out.print("Tentou comer = [ ");
System.out.print(filosofos[i] + " ");
}
}
}
Resultado da Execução – Jantar do Filósofos Glutões:
Filósofos = [ PENSANDO COMENDO PENSANDO PENSANDO PENSANDO ]
Garfos = [ LIVRE OCUPADO OCUPADO LIVRE LIVRE ]
Tentou comer = [ 1 2 1 1 1 ]
Filósofos = [ PENSANDO COMENDO COM_FOME COMENDO PENSANDO ]
Garfos = [ LIVRE OCUPADO OCUPADO OCUPADO OCUPADO ]
Tentou comer = [ 1 2 3 2 1 ]
Filósofos = [ COM_FOME PENSANDO COM_FOME COMENDO COM_FOME ]
Garfos = [ LIVRE LIVRE LIVRE OCUPADO OCUPADO ]
Tentou comer = [ 3 1 3 2 3 ]
Filósofos = [ COMENDO PENSANDO COM_FOME COMENDO COM_FOME ]
Garfos = [ OCUPADO OCUPADO LIVRE OCUPADO OCUPADO ]
Tentou comer = [ 2 1 3 2 3 ]
Filósofos = [ COMENDO PENSANDO COM_FOME PENSANDO COM_FOME ]
Garfos = [ OCUPADO OCUPADO LIVRE LIVRE LIVRE ]
Tentou comer = [ 2 1 3 1 3 ]
Filósofos = [ COMENDO PENSANDO COMENDO PENSANDO COM_FOME ]
Garfos = [ OCUPADO OCUPADO OCUPADO OCUPADO LIVRE ]
Tentou comer = [ 2 1 2 1 3 ]
Filósofos = [ PENSANDO PENSANDO COMENDO COM_FOME COM_FOME ]
Garfos = [ LIVRE LIVRE OCUPADO OCUPADO LIVRE ]
Tentou comer = [ 1 1 2 3 3 ]
Filósofos = [ PENSANDO PENSANDO COMENDO COM_FOME COMENDO ]
Garfos = [ OCUPADO LIVRE OCUPADO OCUPADO OCUPADO ]
Tentou comer = [ 1 1 2 3 2 ]
Filósofos = [ PENSANDO COM_FOME PENSANDO COM_FOME COMENDO ]
Garfos = [ OCUPADO LIVRE LIVRE LIVRE OCUPADO ]
Tentou comer = [ 1 3 1 3 2 ]
Filósofos = [ PENSANDO COMENDO PENSANDO COM_FOME COMENDO ]
Garfos = [ OCUPADO OCUPADO OCUPADO LIVRE OCUPADO ]
Tentou comer = [ 1 2 1 3 2 ]
Filósofos = [ PENSANDO COMENDO PENSANDO COM_FOME PENSANDO ]

______________________________________________________________________________________________
Garfos = [ LIVRE OCUPADO OCUPADO LIVRE LIVRE ]
Tentou comer = [ 1 2 1 3 1 ]
Filósofos = [ PENSANDO COMENDO PENSANDO COMENDO PENSANDO ]
Garfos = [ LIVRE OCUPADO OCUPADO OCUPADO OCUPADO ]
Tentou comer = [ 1 2 1 2 1 ]
Filósofos = [ PENSANDO PENSANDO PENSANDO COMENDO PENSANDO ]
Garfos = [ LIVRE LIVRE LIVRE OCUPADO OCUPADO ]
Tentou comer = [ 1 1 1 2 1 ]
Filósofos = [ PENSANDO PENSANDO PENSANDO PENSANDO PENSANDO ]
Garfos = [ LIVRE LIVRE LIVRE LIVRE LIVRE ]
Tentou comer = [ 1 1 1 1 1 ]
Filósofos = [ COMENDO PENSANDO PENSANDO PENSANDO PENSANDO ]
Garfos = [ OCUPADO OCUPADO LIVRE LIVRE LIVRE ]
Tentou comer = [ 2 1 1 1 1 ]
Filósofos = [ COMENDO PENSANDO COMENDO PENSANDO COM_FOME ]
Garfos = [ OCUPADO OCUPADO OCUPADO OCUPADO LIVRE ]
Tentou comer = [ 2 1 2 1 3 ]
Filósofos = [ PENSANDO COM_FOME COMENDO COM_FOME COM_FOME ]
Garfos = [ LIVRE LIVRE OCUPADO OCUPADO LIVRE ]
Tentou comer = [ 1 3 2 3 3 ]
Filósofos = [ PENSANDO COM_FOME COMENDO COM_FOME COMENDO ]
Garfos = [ OCUPADO LIVRE OCUPADO OCUPADO OCUPADO ]
Tentou comer = [ 1 3 2 3 2 ]
Filósofos = [ PENSANDO COM_FOME PENSANDO COM_FOME COMENDO ]
Tentou comer = [ 1 3 1 3 2 ]
Filósofos = [ PENSANDO COMENDO PENSANDO COM_FOME COMENDO ]
Garfos = [ OCUPADO OCUPADO OCUPADO LIVRE OCUPADO ]
Tentou comer = [ 1 2 1 3 2 ]
Filósofos = [ PENSANDO PENSANDO PENSANDO COM_FOME COMENDO ]
.
.
.
Exercícios:
1) Crie uma class que extends a Thread e, no trabalho a ser executado, faça a soma dos números
de 1 a 10. Esse processo deve ser executado em uma nova pilha.
2) Crie uma class que implements runnable e o trabalho a ser feito é que ela conte de 1 à 15 e,
quando um número impar for encontrado, a thread entra em suspensão e depois, quando concluir
a contagem, informe quantas vezes a thread entrou em suspensão.
3) Desenvolva uma class que tenha quatro threads, cada uma com o nome diferente, e o trabalho
a ser feito em uma nova pilha seja imprimir o nome das threads.
4) Faça um programa que imprima os números primos existentes entre 0 e 99999. UTILIZE
THREADS. Dica: para cada faixa de mil valores crie um thread e dispare o processo para

Apostila Programação Java

Mais conteúdo relacionado

Mais procurados

Destaque

Semelhante a Apostila Programação Java

Mais de info_cimol

Apostila Programação Java