Java Digital 1306 A

UNINOVE uso exclusivo para aluno
PROGRAMAO
ORIENTADA A OBJETOS
COM
sem mistrios
Universidade Nove de Julho UNINOVE

Rua Vergueiro, 235/249 11 andar
01504-001 Liberdade So Paulo, SP
Tel.: (11) 3385-9218 - editora@uninove.br
Evandro Carlos Teruel
PROGRAMAO
ORIENTADA A OBJETOS
COM
sem mistrios
So Paulo
2016
2016 UNINOVE
Todos os direitos reservados. A reproduo desta publicao, no todo ou em

parte, constitui violao do copyright (Lei n 9.610/98). Nenhuma parte desta
publicao pode ser reproduzida por qualquer meio, sem a prvia autorizao
da UNINOVE.
Os conceitos emitidos neste livro so de inteira responsabilidade do autor.
Conselho Editorial

Eduardo Storpoli
Maria Cristina Barbosa Storpoli
Patricia Miranda Guimares
Andr Felipe Henriques Librantz
Marcos Alberto Bussab
Capa: Big Time Servios Editoriais

Editorao eletrnica: Big Time Servios Editoriais
Reviso: Antonio Marcos Cavalheiro
Catalogao na Publicao (CIP)

Cristiane dos Santos Monteiro - CRB/8 7474
---------------------------------------------------------------------------------------------------------------Teruel, Evandro Carlos.
Programao orientada a objetos com JAVA sem mistrios / Evandro Teruel.
So Paulo : Universidade Nove de Julho UNINOVE, 2016.
386 p. il.
Inclui bibliografia
ISBN: 978-85-89852-26-5 (impresso)
ISBN: 978-85-89852-27-2 (e-book)
I. JAVA programao. II. Teruel, Evandro Carlos. III. Ttulo.

CDU 004.439JAVA
----------------------------------------------------------------------------------------------------------------
Fabricantes
Java e NetBeans: desenvolvido pela Sun Microsystems, hoje de propriedade
da Oracle Corporation.
MySQL: desenvolvido pela MySQL AB, propriedade da Sun Microsystems,
hoje parte da Oracle Corporation.
Windows: desenvolvido pela Microsoft Corporation.
Microsoft Informtica Ltda.
Av Naes Unidas, 12901
Torre Norte 27 andar

04578-000 So Paulo
Fone: (11) 5504-2155
Site: www.microsoft.com.br
Oracle Brasil
Rua Dr. Jose Aureo Bustamante 455
Vila Cordeiro CEP 04710-090 So Paulo
Fone: +55 11 5189-1000
Site: http://www.oracle.com/br/index.html
Requisitos de Hardware e Software

Software
Windows XP Professional SP3/Vista SP1/Windows 7/8 Professional
NetBeans 6.8 ou posterior
Java Development Kit (JDK) verso 6 ou posterior
MySQL Community Server 5.1.53 ou posterior
MySQL Workbench 5.2.30 ou posterior
Hardware
Processador: 2,6 GHz Intel Premium IV ou equivalente
Memria: 2 GB
Espao em disco: 1 GB de espao livre em disco
Dedicatria
minha esposa Angela e aos meus filhos, Pedro Henrique e

Ana Luiza, que foram compreensivos nos perodos de ausncia em
que me dediquei pesquisa e ao trabalho.
Aos meus sogros Iracema e Jorge.
Aos meus pais, Jos e Aparecida, que mesmo longe me

apoiam.
Agradecimentos
Aos colegas gestores e professores da diretoria dos cursos de

Informtica da UNINOVE.
Educa a criana no caminho em que

deve andar; e at quando envelhecer
no se desviar dele.
Provrbios 22:6
Sumrio
Prefcio................................................................................................................. 15
Sobre o autor........................................................................................................ 17
Apresentao........................................................................................................ 19
Introduo............................................................................................................ 21
1. Preparando o ambiente para programar em Java........ 23
1.1 Plataformas Java............................................................................................ 23

1.1.1 Java Standard Edition (SE)........................................................................ 23
1.1.2 JavaFX ......................................................................................................... 26
1.1.3 Java Enterprise Edition (JEE) .................................................................. 26
1.1.4 Java Micro Edition (JME) ........................................................................ 26
1.2 Principais IDEs para programao em Java.............................................. 26
1.3 Criando um aplicativo Java.......................................................................... 27
1.3.1 Criando um projeto................................................................................... 27
1.3.2 A classe principal....................................................................................... 29
1.3.3 Compilando e executando........................................................................ 31
1.4 Principais recursos do NetBeans IDE......................................................... 32
1.4.1 Depurando o cdigo.................................................................................. 32
1.5 Resumo........................................................................................................... 34
1.6 Exerccios....................................................................................................... 35
2. Programao Estruturada em Java............................... 37
2.1 Paradigmas de programao....................................................................... 37

2.1.1 Caractersticas da Programao Estruturada......................................... 38
2.1.2 Caractersticas da Programao Orientada a Objetos.......................... 39
2.2 Variveis em Java........................................................................................... 41
2.3 Tipos de dados em Java................................................................................ 42
2.3.1 Tipos de dados primitivos em Java.......................................................... 42
2.3.2 Converses de tipos de dados primitivos............................................... 45
2.3.3 Tipos de dados por referncia em Java.................................................... 47
2.4 Tipos de operaes realizadas em programas Java................................... 50
2.4.1 Expresses aritmticas............................................................................... 50
2.4.2 Expresses relacionais............................................................................... 52
2.4.3 Expresses lgicas...................................................................................... 53
2.4.4 Expresses mistas....................................................................................... 53
2.5 Estruturas de seleo utilizadas em Java.................................................... 54

2.5.1 Estrutura de seleo if...else...................................................................... 54
2.5.2 Estrutura de seleo if...elseif...else.......................................................... 55
2.5.3 Comparando valores String com if...else................................................ 56
2.5.4 Estrutura de seleo switch...case...default............................................. 57
2.6 Laes de repetio em Java........................................................................ 58
2.6.1 Laos de repetio for................................................................................ 59
2.6.2 Laos de repetio while........................................................................... 60
2.6.3 Laos de repetio do...while.................................................................... 61
2.6.4 Arrays em Java............................................................................................ 61
2.6.5 Arrays unidimensionais............................................................................ 62
2.6.6 Arrays multidimensionais......................................................................... 64
2.6.7 Percorrendo arrays com laos de repetio............................................ 65
2.7 Variveis e constantes em Java..................................................................... 66
2.7.1 Constantes................................................................................................... 67
2.7.2 Boas prticas para nomeao de variveis e constantes em Java......... 67
2.8 Resumo........................................................................................................... 68
2.9 Exerccios....................................................................................................... 69
3. Orientao a objetos conceitos bsicos..................... 73
3.1 Classes............................................................................................................. 74
3.1.1 Declarao da classe.................................................................................. 74
3.1.2 Declarao dos atributos........................................................................... 74
3.1.3 Construtor................................................................................................... 75
3.1.4 Mtodos....................................................................................................... 76
3.1.5 Exemplo de classe com atributos, construtor e mtodos...................... 79
3.1.6 Diagrama UML para representar uma classe......................................... 82
3.1.7 Boas prticas para nomeao de classes.................................................. 83
3.2 Pacotes............................................................................................................ 83
3.2.1 Boas prticas para nomeao de pacotes................................................ 85
3.2.2 Como utilizar pacotes das bibliotecas Java............................................. 85
3.3 Objetos............................................................................................................ 86
3.3.1 Instncia de objetos................................................................................... 86
3.4 Encapsulamento............................................................................................ 96
3.5 Criao de objetos com entradas do usurio............................................. 96
3.5.1 Entradas do usurio com a classe Scanner............................................. 96
3.5.2 Entradas do usurio com a classe JOptionPane..................................... 99
3.5.3 Comandos encadeados.............................................................................. 102
3.6 Classes sem atributos ................................................................................... 103
3.7 Array de objetos ............................................................................................ 106
3.7.1 Quando usar arrays de objetos................................................................. 109

3.8 Resumo........................................................................................................... 110
3.9 Exerccios....................................................................................................... 111
3.9.1 Exerccios prticos..................................................................................... 111
3.9.2 Exerccios conceituais................................................................................ 113
4. Orientao a objetos conceitos avanados.........................115

4.1 Herana.......................................................................................................... 115
4.1.1 Exemplo de aplicao com herana......................................................... 117
4.1.2 Superclasses e subclasses nas relaes de herana................................. 126
4.1.3 Herana em cadeia..................................................................................... 127
4.1.4 Conseguindo polimorfismo com herana.............................................. 128
4.2 Interfaces........................................................................................................ 133
4.2.1 Quando utilizar interfaces........................................................................ 136
4.2.2 Conseguindo polimorfismo com utilizao de interfaces.................... 136
4.2.3 Implementao de mais de uma interface.............................................. 143
4.3 Classes Abstratas........................................................................................... 145
4.3.1 Exemplo de aplicao com classes abstratas........................................... 146
4.4 Modificadores de visibilidade...................................................................... 153
4.4.1 Modificador public.................................................................................... 153
4.4.2 Modificador private................................................................................... 155
4.4.3 Modificador protected............................................................................... 156
4.4.4 Sem modificador ....................................................................................... 157
4.5 Garbage collector.......................................................................................... 157
4.6 Anotaes....................................................................................................... 158
4.7 Resumo........................................................................................................... 158
4.8 Exerccios....................................................................................................... 160
5. Mtodos estticos e tratamento de excees.........................163

5.1 Mtodos Estticos......................................................................................... 164
5.1.1 Utilizando mtodos estticos de classes das bibliotecas
que fazem parte do Java...................................................................................... 164
5.1.2 Utilizando mtodos estticos de classes criadas
pelo desenvolvedor.............................................................................................. 166
5.1.3 Utilizando mtodos estticos na classe principal.................................. 169
5.1.4 Criando uma biblioteca de classes com mtodos estticos.................. 170
5.2 Tratamento de Excees............................................................................... 173
5.2.1 Tratamento de Excees com try...catch................................................. 173
5.2.2 Tratamento de Excees com throws..................................................... 179

5.3 Resumo........................................................................................................... 182
5.4 Exerccios....................................................................................................... 182
6. Criao de interface grfica.....................................................187
6.1 API swing....................................................................................................... 187

6.1.1 Contineres swing ..................................................................................... 187
6.1.2 Formas de criao de layout utilizando a API swing............................ 189
6.1.3 Aplicao exemplo criando layout com posicionamento esttico....... 189
6.2 Criao de interface com gerenciadores de layout.................................. 199
6.2.1 FlowLayout.................................................................................................. 199
6.2.2 BorderLayout.............................................................................................. 202
6.2.3 GridLayout.................................................................................................. 205
6.2.4 GridBagLayout........................................................................................... 207
6.2.5 Utilizando gerenciadores de layout compostos...................................... 216
6.2.6 Criao de interfaces grficas ricas utilizando a API swing................. 223
6.3 Tratamento de eventos.................................................................................. 254
6.3.1 Tratamento de eventos de ao................................................................ 254
6.3.2 Tratamento de eventos de janela.............................................................. 261
6.3.3 Tratamento de eventos de foco................................................................. 266
6.3.4 Tratamento de eventos de mouse............................................................. 271
6.4 Criao de aplicao com vrias janelas ou com abas.............................. 273
6.4.1 Exemplo de aplicao com vrias janelas............................................... 274
6.4.2 Exemplo de aplicao com abas na mesma janela................................. 279
6.5 Criao de interfaces do usurio utilizando recursos
de arrastar/soltar com o NetBeans.................................................................. 283
6.5.1 Exemplo de criao de interface grfica simples utilizando
os recursos de arrastar/soltar do NetBeans.................................................... 283
6.6 Resumo........................................................................................................... 294
6.7 Exerccios....................................................................................................... 297
7. Acesso a banco de dados..........................................................303

7.1 Os padres ODBC e JDBC.......................................................................... 303
7.2 Baixando e instalando o MySQL................................................................. 304
7.2.1 Criando o banco de dados e a tabela com o MySQL Workbench....... 306
7.2.2 Criando o banco de dados e a tabela com o NetBeans......................... 310
7.3 Operaes em banco de dados.................................................................... 315
7.3.1 Classes e interfaces usadas em operaes com banco de dados.......... 315
7.3.2 Operao de cadastro................................................................................ 316

7.3.3 Operao de consulta................................................................................ 322
7.3.4 Operao de consulta de todos os registros........................................... 324
7.3.5 Operao de excluso................................................................................ 327
7.3.6 Diferenas entre as interfaces PreparedStatement e Statement........... 331
7.4 Exemplo de aplicao CRUD...................................................................... 332
7.5 O padro Data Access Object (DAO)......................................................... 356
7.6 Criando uma aplicao de cadastro com duas camadas.......................... 357
7.6.1 A classe DAO.............................................................................................. 358
7.6.2 A classe modelo da tabela do banco de dados....................................... 361
7.6.3 A classe para gerao do formulrio de cadastro.................................. 363
7.6.4 Outras operaes na classe DAO............................................................. 368
7.6.5 Criao de interface DAO......................................................................... 372
7.7 Resumo........................................................................................................... 374
7.8 Exerccios....................................................................................................... 376
8. Recomendaes para complementar a formao em Java.379

8.1 Collections..................................................................................................... 379
8.2 Mapeamento Objeto-Relacional................................................................. 380
8.3 Java EE............................................................................................................ 381
8.4 Padres de projeto......................................................................................... 381
8.5 Frameworks.................................................................................................... 382
8.6 Android e iOS................................................................................................ 383
8.7 Principais certificaes Java......................................................................... 383
8.8 Resumo........................................................................................................... 384
Referncias.....................................................................................385
Evandro Carlos Teruel - 15
Prefcio
Quando comecei a trabalhar com programao, em 1989, utilizando a

linguagem Basic, me deparei com um admirvel mundo novo, o mundo da
criao. Era possvel fazer as mquinas tomarem decises, executar tarefas
rotineiras e gerenciar o armazenamento de dados que at aquele momento era
feito em papel, digitados por meio das incrveis mquinas de datilografia. O
pr-requisito para conquistar uma boa vaga de emprego naquela poca era
ter um curso de datilografia. Cursos de computao eram raros e caros, um
privilgio de poucos. Mesmo as empresas, muitas delas, no tinham condies
financeiras para comprar um computador.
Naquela poca a computao j era dita pela mdia especializada como o
conjunto de tecnologias que ditariam os caminhos do futuro, mas nem os
maiores entusiastas poderiam imaginar o cenrio que temos hoje, com mdias
sociais, comunicao instantnea, dinheiro virtual, smartphones, globalizao
e democratizao da informao.
Os mainframes daquela poca, anos depois, na dcada de 1990, deram lugar
aos servidores distribudos, porm, devido ao grande volume de dados e
processamento, voltaram atualmente para assumir de vez seu lugar de destaque
no cenrio da computao mundial.
Os telefones fixos, carssimos, comearam a perder espao para os celulares
no final da dcada de 1990 e a Internet, discada, comeou a ser oferecida
em banda larga, tudo ainda muito caro. Nesse perodo, j comeava a ter
destaque as primeiras linguagens de programao orientadas a objetos, vistas
com certa desconfiana pela comunidade de programadores de linguagens
estruturadas.
Mais de uma dcada depois, salvo linguagens estruturadas como Cobol, que
continuam em foco para programao de mainframes, as linguagens orientadas
a objetos dominam o cenrio de desenvolvimento em todos os principais
ambientes de uso (desktop, mobile e web).
Assim, aprender bem uma linguagem de programao orientada a objeto bem
aceita nas empresas essencial para uma boa colocao no mercado de trabalho.
16 - Programao Orientada a Objetos com Java sem mistrios
Java, talvez a linguagem de programao orientada a objeto mais poderosa

na atualizadade, uma excelente alternativa para quem quer aproveitar as
milhares de vagas de emprego abertas para programadores no Brasil. Apesar
dos atrativos, aprender Java no uma tarefa fcil nem rpida.
O objetivo deste livro justamente apresentar os conceitos da orientao a
objetos e a linguagem Java com um enfoque prtico e didtico, com muitos
exemplos e exerccios.
Espero que voc aprecie a leitura e que o contedo seja til para o seu
desenvolvimento profissional.
Prof. Me. Evandro Carlos Teruel
Sobre o autor
Evandro Carlos Teruel formado em Tecnologia

em Processamento de Dados. especialista PsGraduado em Projeto e Desenvolvimento de Sistemas
para Web e tambm em Segurana da Informao.
Cursou Mestrado em Tecnologia na linha de pesquisa
Gesto da Tecnologia da Informao. tambm
certificado ITIL v3 Foundation. J atuou na rea de
desenvolvimento de software em empresa prpria e
atualmente gestor e professor universitrio.
autor de diversos livros na rea de Tecnologia da
Informao, dentre eles: Web Total: desenvolva
sites com tecnologias de uso livre, Web Mobile,
Arquitetura de Sistemas para WEB com Java
Utilizando Design Patterns e Frameworks,
HTML5: Guia prtico e ITIL v3 atualizado em
2011: conceitos e simulados para certificao ITIL
foundation e teste de conhecimento.
Apresentao
Este livro apresenta de maneira prtica e simplificada a programao orientada

a objetos utilizando Java. Voc aprender a diferena entre a programao
estruturada e orientada a objetos, as estruturas e comandos fundamentais
do Java, os conceitos essenciais da programao orientada a objetos (como
encapsulamento, herana, polimorfismo, interfaces etc.), a criao de interfaces
grficas para desktop, tratamento de excees e acesso a banco de dados
utilizando a API Java Database Connectivity (JDBC).
Cada captulo estruturado com uma introduo, apresentao dos contedos
tericos com exemplos, resumo e lista de exerccios.
Contedo dos captulos:

Captulo 1 Preparando o ambiente para programar em Java
Este captulo ensina a baixar, instalar e preparar um ambiente de
desenvolvimento Java para Windows. Ensina tambm a criar, desenvolver
uma pequena aplicao, compil-la e execut-la.
Captulo 2 Programao Estruturada com Java

Este captulo apresenta a diferena entre a programao estruturada e
orientada a objetos; os tipos de dados primitivos e por referncia; declarao
e manipulao de variveis e constantes; operaes aritmticas, relacionais,
lgicas e mistas; estruturas de seleo; laos de repetio e arrays.
Captulo 3 Orientao a objetos conceitos bsicos

Este captulo ensina os conceitos fundamentais da orientao a objetos,
como classes, atributos, construtores, mtodos, objetos, encapsulamento e
modificadores de visibilidade. Apresenta vrios exemplos de classes e formas
de instanciar objetos, manipular valores em seus atributos e acessar seus
mtodos. Apresenta tambm as formas de entrada de dados utilizando as classes
Scanner e JOptionPane.
Captulo 4 Orientao a objetos conceitos avanados

Este captulo apresenta conceitos avanados da orientao a objetos como
herana, interfaces, classes abstratas e polimorfismo.
Captulo 5 Mtodos estticos e tratamento de excees

Este captulo apresenta o uso de mtodos estticos, criao de bibliotecas de
classes para reso e as formas de tratamento de excees.
Captulo 6 Criao de interface grfica

Este captulo ensina as diversas formas de criar interfaces grficas do usurio
utilizando as APIs swing e awt e a tratar eventos de ao do usurio sobre a
interface.
Captulo 7 Acesso a banco de dados

Este captulo ensina como criar aplicaes Java que acessam e executam
operaes em bancos de dados utilizando a API Java Database Connectivity
(JDBC) e o padro Data Access Object (DAO). Voc aprender a criar uma
aplicao que executa as operaes CRUD (Create, Read, Update e Delete)
no banco de dados.
Captulo 8 Recomendaes para complementar a formao

em Java
Este captulo faz um direcionamento de estudos para complementar a formao
em Java. Recomenda o estudo de colees, mapeamento objeto-relacional,
design pattern e frameworks, tecnologias Java EE e desenvolvimento para
tablets e celulares com Android. Recomenda ainda a realizao das certificaes
OCAJP e OCPJP.
Introduo
Em meio infinidade de tecnologias, linguagens e aplicativos de todos os tipos e

para todos os fins e plataformas existentes hoje, difcil escolher um caminho para
trilhar na rea da informtica que possa garantir um futuro profissional de sucesso.
Se voc escolheu a rea de desenvolvimento de sistemas, independente do
caminho que ir seguir, precisar conhecer bem uma linguagem de programao
orientada a objetos. As linguagens do pacote Visual Studio .NET da Microsoft
e a plataforma Java da Oracle Corporation so as duas grandes plataformas de
desenvolvimento orientado a objetos utilizadas hoje na maioria das empresas
de software. Sendo assim, natural voc se dirigir a uma destas plataformas. As
linguagens do pacote Visual Studio so mais fceis de aprender e utilizar, porm,
em contrapartida, so de uso pago e geram aplicaes com interfaces bonitas, mas
normalmente pesadas para executar. J a plataforma Java de uso gratuito, mas
o tempo de aprendizagem maior, assim como o nvel de complexidade. Por ser
uma plataforma gratuita e de cdigo aberto, ganhou a simpatia da comunidade
adepta dos softwares livres, que colaboraram para elevar a plataforma a um nvel
onde se pode desenvolver praticamente qualquer tipo de software para qualquer
tipo de dispositivo existente. Para acomodar e classificar melhor os recursos, a
plataforma Java em si foi subdividida em plataformas menores voltadas para
domnios especficos, como Java SE, que concentra os recursos essenciais da
plataforma e utilizada para desenvolvimento de aplicaes para desktop; Java
ME, para dispositivos mveis e computao embarcada; Java EE, para web e
outras aplicaes em que rodam em rede baseadas em servidores de aplicao;
e JavaFX para multimdia e interfaces grficas robustas. Dentro de cada uma
destas subplataformas esto concentrados pacotes de classes, APIs, bibliotecas,
frameworks e recursos que precisariam de um ou mais livros cada um para
descrev-los.
Para que voc tenha uma ideia clara do que se tornou a plataforma Java, se
voc fizesse 4 anos de faculdade apenas para aprender Java, provavelmente
no dominaria todos os seus recursos.
No pretenso do autor deste livro, com os contedos apresentados, fazer
com que voc domine Java, mas sim apresentar os principais recursos do Java
SE (Standard Edition) a partir dos quais voc ter condies de evoluir no
caminho da busca por conhecimentos mais completos da plataforma.
Voc aprender nessa obra a criar um ambiente de desenvolvimento adequado
para Java; a utilizar as estruturas essenciais da programao estruturada como
definio de tipos de dados, operaes, variveis, constantes, arrays, laos

de repetio, estruturas de seleo e tratamento de excees; os conceitos
fundamentais da orientao a objetos como classes, objetos, atributos,
mtodos, encapsulamento, herana, polimorfismo, interfaces, modificadores
de visibilidade; a criar interfaces grficas do usurio baseadas em formulrios;
e a executar conexo e operaes em bancos de dados utilizando a API JDBC.
Digitar os exemplos e fazer os exerccios do final de cada captulo ser essencial
para um bom aprendizado.
Bons estudos!
1. Preparando o ambiente
para programar em Java
Para programar em Java necessrio instalar no computador a distribuio
Java Standard Edition (Java SE), que inclui as bibliotecas de classes, os
recursos para compilao e execuo do cdigo e a mquina virtual.
necessrio tambm instalar um ambiente integrado para desenvolvimento (IDE
Integrated Development Environment), que integra os recursos da linguagem
com um editor de cdigo-fonte. Apesar de voc poder digitar seu cdigofonte em um editor simples como o bloco de notas do Windows, comum
o uso de um ambiente de desenvolvimento robusto (como o NetBeans ou o
Eclipse) que integra os recursos da linguagem com os recursos do ambiente
de desenvolvimento em uma nica interface de programao.
Neste Captulo voc aprender a baixar e instalar os recursos necessrios para
criar um ambiente de desenvolvimento Java e a criar, compilar e executar sua
primeira aplicao Java.
1.1 Plataformas Java

Desde que surgiu, na dcada de 1990, por seu uma plataforma livre e muito
poderosa, o Java ganhou recursos para o desenvolvimento de qualquer
tipo de aplicao, desde para dispositivos mveis, computao embarcada
(para microprocessadores embutidos em aparelhos eletrnicos, brinquedos,
automveis), para web, para desktop etc. Na medida em que foi crescendo,
a plataforma foi dividida em plataformas menores, para domnios (ou reas)
especficos. Desta forma, voc tem uma distribuio bsica, com os recursos
essenciais para todas as plataformas e para o desenvolvimento de aplicaes
desktop, chamada Java Standard Edition (Java SE), e plataformas especficas
para desenvolvimento de aplicaes que rodam em rede (Java EE), para
dispositivos mveis e embarcados (Java ME) e para o desenvolvimento de
interfaces grficas robustas e aplicaes multimdia (Java FX).
1.1.1 Java Standard Edition (SE)

O Java SE (Standard Edition) a plataforma essencial do Java, contendo a Java
Runtime Environment (JRE), um ambiente de tempo de execuo composto por
bibliotecas (APIs), compilador e pela Java Virtual Machine (JVM), recursos
necessrios para executar as aplicaes Java.
1.1.1.1 Java Virtual Machine (JVM)

A mquina virtual Java (JVM) responsvel pela portabilidade das aplicaes
Java. Ela abstrai a execuo do cdigo compilado, chamado bytecode, da
mquina real, ou seja, o cdigo compilado interpretado e executado na
JVM, independente de caractersticas especficas do sistema operacional ou
do hardware, permitindo a execuo da aplicao em qualquer computador
que tenha uma JVM instalada. Voc encontra implementaes da JVM para
os diversos tipos de sistemas operacionais e hardwares existentes.
1.1.1.2 Java Development Kit (JDK)

Para que todos os recursos do Java SE possam ser instalados de forma integrada,
deve-se baixar e instalar o Java Development Kit (JDK). isso mesmo, no se
instala o Java SE, mas sim o JDK, que integra os recursos do Java SE (compilador,
recursos para execuo da aplicao, bibliotecas de classe, JVM etc.).
NOTA
O Java SE deve estar instalado no computador caso voc queira utilizar as demais distribuies Java (EE, ME e FX).
1.1.1.2.1 Instalao da JDK

Para baixar o Java SE, que vem na forma de JDK, entre no link abaixo:
http://www.oracle.com/technetwork/java/javase/downloads/index.html
Na pgina que aparece, clique no boto Download referente Java Platform

(JDK) 8u20. A Figura 1.1 mostra o boto que deve ser clicado.
Figura 1.1: Link para baixar a JDK
NOTA
H uma verso da JDK, nesta tela, que j instala o NetBeans. No

interessante usar esta verso, pois ela instala apenas os recursos essenciais do NetBeans, deixando de fora alguns recursos que sero necessrios para desenvolvimento com as demais distribuies Java e com
linguagens como C++ e PHP.
Na tela que aparece voc ter que marcar a opo Accept License Agreement,
para aceitar os termos da licena de uso gratuito. Na mesma tela, na parte
de baixo, voc escolhe a verso da JDK para seu sistema operacional. Para
Windows, voc pode baixar uma das verses apresentadas a seguir:
Para Windows 32 bits jdk-8u20-windows-i586.exe 61.08 MB
Para Windows 64 bits jdk-8u20-windows-x64.exe 173.08 MB
Aps baixar a verso adequada, instale-a no computador de forma padro.
1.1.1.2.2 Instalao da IDE NetBeans
Neste ponto voc j conseguir programar com o Bloco de Notas do Windows,

mas no vai querer isso, pois os recursos do Bloco de Notas so bsicos.
Precisar ento instalar um ambiente de desenvolvimento robusto.
O NetBeans ideal, j que foi desenvolvido pela Sun Microsystems, a mesma
empresa que criou o Java, hoje, de propriedade da Oracle Corporation. Se
desejar, poder utilizar o Eclipse, da IBM, que tambm um timo ambiente
de desenvolvimento.
Neste livro, vamos utilizar o NetBeans.
Para instalar o NetBeans ou o Eclipse, necessrio que antes, voc te-
NOTA nha instalado o Java SE, atravs do JDK.

Para baixar o NetBeans, entre no link:
https://NetBeans.org/downloads/
Voc perceber que h vrias colunas com um boto Download embaixo.

Cada coluna mostra verses do NetBeans com um grupo de recursos diferente.
ideal voc clicar no boto Download da ltima coluna da direita, a coluna
que tem como ttulo a palavra Tudo, que traz a distribuio do NetBeans
mais completa. Esta verso j instala o Java EE, o Java ME, o Java FX, os
servidores de aplicao Glassfish e Tomcat para aplicaes Java EE, e recursos
para desenvolvimento em C++, PHP, HTML5 etc.
Baixe o NetBeans e instale no computador.
Na instalao, na primeira tela que aparece, clique no boto Personalizar
DICA para selecionar o servidor web Tomcat, muito bom para o desenvolvimento de sites com Java EE.
1.1.2 JavaFX
O JavaFX a distribuio Java que permite criar aplicaes multimdia com
interfaces grficas bonitas para desktop, browser e telefones celulares. Quando
voc instala a verso completa do NetBeans, como descrito no tpico anterior,
o Java FX j instalado automaticamente.
1.1.3 Java Enterprise Edition (JEE)
O Java EE a distribuio Java para o desenvolvimento de aplicaes que

rodam em rede, como sites ou aplicaes que integram outras aplicaes,
centralizando-as em um servidor de aplicaes. Sempre que voc for
desenvolver uma aplicao que necessita de um servidor de aplicaes para
rodar, essa aplicao ser considerada uma aplicao Java EE.
Esta distribuio Java traz um conjunto de APIs e frameworks como JavaServer
Pages (JSP), Servlet, JavaServar Faces (JSF), Struts, Enterprise JavaBeans
(EJB) etc. Quando voc instala a verso completa do NetBeans, como descrito
anteriormente, o Java EE j instalado automaticamente.
1.1.4 Java Micro Edition (JME)

Java ME a distribuio Java que possibilita o desenvolvimento de software
para sistemas embarcados, ou seja, para carros, eletrodomsticos, celulares,
controle remotos, automveis etc. O uso mais comum e popular para o
desenvolvimento de aplicativos e jogos para celulares, mas tambm pode ser
utilizada para uma vasta quantidade de outros tipos de dispositivos. Quando
voc instala a verso completa do NetBeans, como descrito anteriormente, o
Java ME j instalado automaticamente.
1.2 Principais IDEs para programao em Java

Como vimos anteriormente, para desenvolver aplicaes Java aconselhvel
a instalao de um Integrated Development Environment (IDE), um ambiente
integrado para desenvolvimento de software. Os IDEs mais conhecidos para
Java so NetBeans, criado pela Sun Microsystem, e o Eclipse, criado pela IBM,
porm, existem outros IDEs menos pesados, como BlueJ, JCreator e o Gel. A
seguir voc encontra o link onde poder baixar cada um, se desejar.
NetBeans https://NetBeans.org/downloads/
Eclipse http://www.eclipse.org/
BlueJ http://www.bluej.org/
JCreator http://www.jcreator.com/
Gel http://www.informaticon.com.br/downloads/gel.exe
1.3 Criando um aplicativo Java

Aps entrar no NetBeans, voc precisar criar um novo projeto para programar
em Java. Um projeto nada mais do que uma pasta que voc cria no disco
para gravar sua aplicao e concentrar alguns recursos do Java necessrios
para execut-la.
1.3.1 Criando um projeto

Para criar um novo projeto (aplicao), siga os passos abaixo:
Clique no menu Arquivo e na opo Novo Projeto (ou pressione Ctrl

+ Shift + N).
Na diviso Categorias, selecione Java. Veja que nesta diviso voc
poder selecionar outros tipos de aplicao, como HTML 5, C++, PHP,
aplicao web etc.
Na diviso Projetos, selecione Aplicao Java.
Clique no boto Prximo.
No campo Nome do Projeto, d um nome para a pasta onde ficar sua
aplicao.
No campo Localizao do Projeto, clique no boto Procurar e selecione
o local do disco onde voc deseja criar a pasta do projeto.
No campo Criar Classe Principal, digite um nome para a classe (programa)
que voc deseja criar. Lembre-se que uma boa prtica iniciar o nome da
classe com letra maiscula. Uma classe principal uma classe de start da
aplicao, como, por exemplo, um menu principal de abertura da aplicao.
A Figura 1.2 mostra a tela do assistente do NetBeans para nomeao do projeto.
Figura 1.2: Tela do assistente do NetBeans para nomeao do projeto.
Clique no boto Finalizar.

Pronto! Seu projeto est criado.
A Figura 1.3 mostra a rea de trabalho do NetBeans.
Figura 1.3: rea de trabalho do NetBeans.
1.3.2 A classe principal
Toda aplicao Java SE precisa de uma classe principal, que normalmente

gerada quando se cria um novo projeto. A classe principal uma classe de
start da aplicao, ou seja, a porta de entrada da aplicao. Voc pode ter
20 classes no projeto, mas apenas uma ser a classe principal, a partir da qual
voc acessar as demais classes. O que define uma classe como principal a
instruo public static void main(String[] args). Veja no cdigo-fonte da classe
Exemplo.java criada no nosso projeto:
public class Exemplo {
public static void main(String[] args) {
//Digite seu cdigo de inicializao da aplicao aqui
}
}
Toda classe que voc cria em um projeto iniciada pela instruo public
class seguida pelo nome da classe. Todo o cdigo-fonte da classe deve ficar
no interior das chaves.
//Digite a programao da classe aqui
}
Como a classe Exemplo.java a classe principal, ento no interior das chaves

h uma outra estrutura dizendo que trata-se de uma classe principal, a estrutura
public static void main(String[] args). Todo o contedo de start (inicializao)
da classe normalmente fica no interior das chaves desta estrutura.
//Digite seu cdigo de inicializao da aplicao aqui
}
Para definir que o contedo de uma linha um comentrio, basta utilizar
NOTA // esquerda do contedo da linha.
Se precisa definir um bloco de linhas como comentrio, utilize /* no incio do

bloco e */ no final.
Os comentrios so descartados na execuo do cdigo e servem apenas para
descrever comandos ou informaes adicionais sobre os programas.
Digite o cdigo-fonte a seguir na classe Exemplo.java, criada no nosso projeto.

int n, cont, fat;
n = 5;
cont = 2;
fat = 1;
while (cont <= n) {
fat = fat * cont;
cont++;
}
System.out.print(fat);
}
}
O cdigo-fonte apresentado calcula o fatorial do nmero 5 ou seja, 5 fatoriais,

exibindo na tela o resultado que ser 120.
No decorrer do livro voc vai entender melhor a linha public static void
main(String[] args), mas cabe aqui uma breve explicao.
Trata-se de um mtodo chamado main, que invocado automaticamente
quando a aplicao executada. Este mtodo pode ser visto, a grosso modo,
como uma espcie de funo da programao estruturada, que chamado
automaticamente na inicializao da aplicao.
Quando voc executar a aplicao, a JVM (mquina virtual) vai procurar
a classe que possui um mtodo chamado main para executar. Se nenhuma
das classes da aplicao possuir um mtodo chamado main, a aplicao no
poder ser executada. Como este mtodo ser invocado na mquina virtual
de fora da aplicao, ento ele precisa ser pblico (public) e esttico (static)
para ser acessado. A instruo void indica que quando o mtodo for chamado,
no retornar (devolver) nenhum resultado. O parmetro String[] args indica
que se voc quiser, na hora de executar a aplicao, poder passar um ou
mais parmetros para a array args. Estes parmetros, se recebidos, podem ser
usados no interior do mtodo main para definir caractersticas de execuo
para a aplicao com a finalidade de personaliz-la baseado nos parmetros.
A passagem de parmetros na inicializao de uma aplicao muito
NOTA comum em jogos que, quando iniciados com parmetros, acrescentam

poderes adicionais ao personagem do jogo.
1.3.3 Compilando e executando

Se voc estivesse usando o Bloco de Notas para criar a aplicao e no o
NetBeans, teria que abrir o prompt de comando do Windows e digitar a
instruo a seguir:
javac Exemplo.java
Esta instruo compila a classe Exemplo.java. Javac o compilador Java. Este

comando gera um arquivo compilado chamado Exemplo.class (conhecido como
bytecode), que pode ser carregado e interpretado na JVM (mquina virtual
Java). Para executar o arquivo compilado carregando-o na JVM, digita-se, no
prompt de comando, a instruo a seguir:
java Exemplo
Um pouco complicado, no?

Estes comandos precisam ser digitados na pasta onde se encontra a classe
Exemplo.java e as configuraes de caminho para o compilador e outros
recursos necessrios precisam estar configuradas nas variveis de ambiente
do Windows.
Calma! Nada de pnico.
Quando voc usa o NetBeans, tudo integrado, de forma que voc no ter
nenhuma dificuldade para compilar e executar sua aplicao.
Ao terminar de digitar a classe principal, basta pressionar a tecla F6 que a
classe ser compilada executada na JVM, apresentando o resultado na tela.
Isso mesmo! Basta pressionar F6.
Se preferir, pode realizar o mesmo trabalho clicando na seta verde da barra
de ferramentas que fica na parte superior da tela, abaixo do menu principal. A
Figura 1.4 mostra a ferramenta que pode ser clicada para compilar e executar
a aplicao no NetBeans.
Figura 1.4: Ferramenta para compilar e executar a aplicao no NetBeans.
Se preferir, voc poder tambm clicar na opo Executar do menu superior

e, em seguida, na opo Executar projeto.
1.4 Principais recursos do NetBeans IDE

Voc vai notar que o IDE NetBeans uma ferramenta extremamente til na
criao de aplicaes Java pelos seguintes motivos:
Integra a linguagem e seus recursos (bibliotecas, compilador, ferramenta de
execuo e mquina virtual) com o editor de cdigo-fonte em uma nica
interface para o usurio.
Permite compilar e executar o cdigo com um nico clique ou pressionamento
de tecla.
Possui depurador em tempo real, que autocompleta comandos que esto

sendo digitados, marca comandos escritos de forma incorreta e apresenta
sugestes de correo no momento da digitao.
Importa automaticamente pacotes de classes necessrios.
Permite indentar o cdigo-fonte automaticamente por meio do
pressionamento da combinao de teclas Alt + Shift + F ou de um clique
no menu Cdigo-Fonte e na opo Formatar.
Permite depurar (ou debugar) o cdigo-fonte mostrando passo a passo a
execuo dos comandos e os estados das variveis na memria, auxiliando
no entendimento do programa e na correo de erros.
Mostra as diversas categorias de instrues como classes, instrues
primitivas, contedos de variveis etc. em cores diferentes, facilitando o
entendimento do cdigo-fonte.
1.4.1 Depurando o cdigo

A depurao um processo essencial para que voc entenda o cdigo e encontre
erros de lgica difceis de encontrar visualmente. o processo de acompanhar
a execuo do cdigo linha a linha, verificando o que ocorre na execuo de
cada instruo.
Para depurar um cdigo-fonte, voc dever clicar sobre o nmero da linha
onde deseja iniciar o acompanhamento da execuo, como mostra a Figura
1.5 a seguir:
Figura 1.5: Marcao de linha para depurao de cdigo no NetBeans.
Em seguida, deve pressionar a combinao de teclas Ctrl + F5 ou clicar no

menu Depurar e Depurar projeto.
A linha que estava marcada com fundo vermelho ficar marcada com fundo
verde, como mostra a Figura 1.6 a seguir:
Figura 1.6: Depurao de cdigo no NetBeans.
Agora, basta selecionar abaixo da rea onde est o cdigo-fonte a aba

Variveis e pressionar a tecla F8 para executar cada linha do cdigo. Cada
vez que voc pressionar a tecla F8, o depurador executar uma linha e voc
poder acompanhar os valores armazenados nas variveis, como mostra a
Figura 1.7 a seguir.
Figura 1.7: Acompanhamento das variveis na memria durante a depurao no NetBeans.
Caso haja alguma linha de cdigo que chame mtodos em outras classes,
pressione F7 para entrar nestes mtodos e depur-los.
Caso queira parar a depurao, basta clicar no menu Depurar e em Finalizar
sesso do depurador.
1.5 Resumo
Com Java possvel desenvolver qualquer tipo de aplicao, estruturada
ou orientada a objetos. Voc pode desenvolver sistemas para desktop, sites,
jogos para celulares, programas para microcontroladores embutidos em
eletrodomsticos, carros etc.
Java, criada pela Sun Microsystem, hoje de propriedade da Oracle Corporation,
cresceu tanto que teve que ser dividida em plataformas (distribuies)
especializadas em domnios especficos. Assim, Java Standard Edition (SE)
a plataforma fundamental, com a linguagem Java e os recursos necessrios
para utilizar qualquer outra distribuio. Java Enterprise Edition (EE) a
distribuio para desenvolvimento de aplicaes que executam em rede, em
servidores de aplicaes. Com Java EE voc pode desenvolver sites ou outras
aplicaes corporativas que centralizam processamento em um servidor. Java

Micro Edition (ME) a distribuio para desenvolver aplicativos para celulares
(incluindo jogos) e programas para serem executados em microcontroladores de
eletrodomsticos, carros, controles remotos, sistemas de automao etc. JavaFX
a distribuio para desenvolvimento de aplicaes multimdia, normalmente
que necessitam de uma interface grfica mais bonita.
Para utilizar Java EE, Java ME ou JavaFX necessrio ter o Java SE instalado.
O Java SE instalado na forma de kit, chamado Java Development Kit (JDK),
baixado do site da Oracle. Aps instalar o JDK que contm o Java SE com os
recursos fundamentais para a utilizao de Java, necessrio instalar um IDE
(ambiente de desenvolvimento). Os principais IDEs so Eclipse e NetBeans,
robustos, mas que exigem muitos recursos disponveis no computador, como
memria e espao em disco. Caso voc tenha recursos mais escassos, pode
utilizar IDEs mais simples como JCreator, Gel ou BlueJ. O NetBeans o IDE
mais indicado para Java, por ter sido criado tambm pela Sun Microsystems,
criadora da linguagem. Apesar do Eclipse, criado pela IBM, ser o IDE mais
antigo e conhecido pela comunidade de desenvolvedores, o NetBeans mais
fcil de utilizar e mais integrado com os recursos da plataforma Java.
1.6 Exerccios
1) Quais so as plataformas para desenvolvimento de aplicaes com Java?
2) Que plataforma (ou distribuio) Java necessrio utilizar para desenvolver
programas embarcados?
3) O que necessrio instalar no computador para utilizar o Java EE, Java
ME e JavaFX?
4) Um site feito em Java considerado uma aplicao Java _________.
5) Quando se compila um programa Java, como chamado o arquivo
compilado, que possui a extenso .class?
6) Onde o arquivo compilado em Java carregado e executado?
7) Quais so os principais IDEs de desenvolvimento para Java?
8) O que o processo de depurao ou debugao?

9) Que procedimento precisa ser adotado para indentar o cdigo-fonte
automaticamente no NetBeans?
10) O que um projeto criado no NetBeans?
11) O que a classe principal de uma aplicao Java?
12) Como se compila e executa a aplicao Java criada no NetBeans?

13) Porque se diz que as aplicaes feitas em Java possuem portabilidade?
14) Para que serve o mtodo main em uma classe principal?
2. Programao Estruturada
em Java
Voc deve achar estranho um livro de Programao Orientada a Objeto iniciar
com um Captulo com o ttulo Programao Estruturada em Java. Pois ,
mas no h nada de estranho nisso. A maioria das linguagens de programao
orientadas a objeto, incluindo Java, utilizam um conjunto de estruturas
derivadas da programao estruturada, como criao de variveis de tipos
primitivos, comparaes, laos de repetio, arrays (vetores e matrizes) etc.
As aplicaes orientadas a objetos normalmente utilizam programao
estruturada quando criam variveis, fazem comparaes, executam laos
de repetio e manipulam arrays. Voc pode programar 100% de maneira
estruturada utilizando uma linguagem orientada a objeto como Java, porm,
estar subutilizando os recursos mais importantes da linguagem.
Este Captulo apresentar:
A diferena entre programao estruturada e programao orientada a
objetos.
As instrues fundamentais da linguagem Java para tipificao e criao
de variveis simples, arrays e constantes.
As principais operaes aritmticas, relacionais e lgicas.
Estruturas de seleo e laos de repetio.
No final voc encontrar um conjunto de exerccios para praticar e ajudar a
fixar conceitos.
O objetivo principal deste Captulo apresentar a voc as estruturas
fundamentais de programao usadas tanto na programao estruturada como
na programao orientada a objetos com Java.
2.1 Paradigmas de programao

Um paradigma de programao representa o conjunto de princpios ou
estilo utilizado no desenvolvimento de um programa ou aplicao. Existem
atualmente dois paradigmas de programao de destaque: Programao
Estruturada e Programao Orientada a Objetos.
2.1.1 Caractersticas da Programao Estruturada

Se voc j assistiu aulas de disciplinas que tratavam de algoritmos e lgica de
programao, utilizou programao estruturada.
A programao estruturada consiste basicamente em dispor um conjunto de

instrues sequenciais em um programa de computador para realizar uma tarefa.
Sendo assim, um programa desenvolvido de forma estruturada normalmente
inicia com a declarao de variveis, entrada de dados ou atribuio de valores
a estas variveis, eventual realizao de operaes e comparaes com estas
variveis, possveis laos de repetio, quando necessrio, e visualizao de
resultados. As operaes, caso sejam acessadas mais de uma vez, podem ser
colocadas em funes ou procedimentos para que possam ser chamadas diversas
vezes do corpo da parte principal do programa.
Normalmente, toda a tarefa a que a aplicao se dispe a realizar feita dentro
de um nico programa e, no mximo, em outro programa auxiliar importado
no programa principal.
Programao estruturada uma forma mais antiga de se programar utilizando
normalmente Linguagem C, Pascal, Cobol etc. No passado, todas as operaes
de um software podiam ser concentradas em um nico programa ou em meia
dzia de programas utilizando normalmente sequncias, estruturas de deciso
e de repetio, o que no mais realidade hoje, sendo um dos motivos pelo
qual a programao orientada a objeto ganhou espao.
Para que voc possa entender melhor, veja a seguir um exemplo de aplicao
estruturada construda com Java, onde so pedidos o nome e duas notas de
um aluno. Aps a digitao das notas, o programa calcula a mdia aritmtica
e mostra uma mensagem indicando se o aluno foi aprovado ou reprovado,
considerando mdia para aprovao maior ou igual a 6.
No se preocupe neste momento em entender os comandos, pois estes sero
apresentados em detalhes no decorrer do livro. Concentre-se nas operaes
realizadas pelo programa para entender a diferena entre os dois paradigmas.
Considere a classe Exemplo.java, cujo cdigo-fonte apresentado a seguir:
import javax.swing.JOptionPane;
String nome, mensagem;
double nota1, nota2, media;
nome = JOptionPane.showInputDialog("Digite o nome do aluno");
nota1 = Double.parseDouble(JOptionPane.showInputDialog("Digite a primeira nota"));
nota2 = Double.parseDouble(JOptionPane.showInputDialog("Digite a segunda nota"));
media = (nota1 + nota2) / 2;
if (media >= 6) {
mensagem = "aprovado";
} else {
mensagem = "reprovado";
}
System.out.print("O aluno " + nome + " foi " + mensagem + " com mdia " + media);
}
}
Observe que no programa acontece sequencialmente a declarao das variveis,

a entrada dos dados, o clculo da mdia, a comparao e a exibio dos
resultados esperados.
No tpico seguinte voc ver como esta mesma tarefa ser realizada de maneira
orientada a objetos.
2.1.2 Caractersticas da Programao Orientada

a Objetos
Na programao orientada a objetos voc normalmente separa as informaes
de uma determinada categoria ou classe e as operaes sobre estas informaes
em programas separados do programa principal. Assim, por exemplo, se for
necessrio aumentar o salrio de um funcionrio necessrio manipular as
informaes e operaes deste funcionrio em um arquivo de programa (classe)
criado exclusivamente para esta finalidade. Cada categoria de informao e suas
operaes so tratadas em programas separados. Por exemplo, se for necessrio
manipular dados e operaes de clientes, cria-se um programa chamado Cliente.
java; se for necessrio manipular informaes e operaes relacionadas a
produtos, cria-se um programa denominado Produto.java e assim por diante.
Para que voc entenda melhor como se programa orientado a objetos, o mesmo
programa apresentado de maneira estruturada no tpico anterior apresentado
a seguir usando o paradigma orientado a objetos.
Sero necessrios dois programas, um principal (de start), chamado Exemplo.java,
e outro chamado Aluno.java.
O cdigo-fonte do programa Exemplo.java apresentado a seguir:
String nome, mensagem;
double nota1, nota2, media;
nome = JOptionPane.showInputDialog("Digite o nome do aluno");
nota1 = Double.parseDouble(JOptionPane.showInputDialog("Digite a primeira nota"));
nota2 = Double.parseDouble(JOptionPane.showInputDialog("Digite a segunda nota"));
Aluno aluno = new Aluno (nome, nota1, nota2);

media = aluno.calcularMedia();
if (media >= 6) {
mensagem = "aprovado";
} else {
mensagem = "reprovado";
}
System.out.print("O aluno " + aluno.getNome() + " foi " + mensagem + " com mdia " + media);
}
O cdigo-fonte do programa Aluno.java apresentado a seguir:

public class Aluno {
private String nome;
private double nota1;
private double nota2;
public Aluno(String nome, double nota1, double nota2) {
this.nome = nome;
this.nota1 = nota1;
this.nota2 = nota2;
}
public String getNome() {
return nome;
}
public void setNome(String nome) {
this.nome = nome;
}
public double getNota1() {
return nota1;
}
public void setNota1(double nota1) {
this.nota1 = nota1;
}
public double getNota2() {
return nota2;
}
public void setNota2(double nota2) {
this.nota2 = nota2;
}
public double calcularMedia() {
return (nota1 + nota2) / 2;
}
}
Analisando o tamanho dos programas voc deve estar pensando que bem
mais fcil programar de maneira estruturada. Se pensarmos na simples tarefa
que executamos, voc tem razo. Agora pense no sistema de uma empresa
onde necessrio manipular dados de funcionrios, de clientes, de impostos

etc. Neste caso, quando se separa as informaes em classes de programas
interligados de forma que cada um realize as operaes relacionadas classe
na qual pertence, fica mais fcil para modelar, para manter e para reaproveitar
operaes que podem ser executadas diversas vezes.
NOTA
Na programao orientada a objetos cada arquivo de programa chamado de classe. Assim, por exemplo, se voc for construir uma aplicao com 5 arquivos .java, ter 5 classes na aplicao.
2.2 Variveis em Java

Existem linguagens de programao, como PHP e JavaScript, que so
fracamente tipadas, ou seja, voc no precisa especificar o tipo de dado que a
varivel ir armazenar. Basta atribuir um valor varivel que ela assumir o
tipo referente ao valor armazenado automaticamente. Veja o exemplo abaixo
de criao de variveis em PHP:
$idade=40;
$nome="Evandro";
Note que a varivel idade recebeu um valor numrico inteiro, logo, implicitamente do tipo int. J a varivel nome recebeu uma cadeia de caracteres, logo,
definida implicitamente como String.
Este no o caso da linguagem Java. Nesta linguagem, considerada fortemente
tipada, voc precisa obrigatoriamente indicar o tipo da varivel antes de atribuir
um valor a ela. Por exemplo:
int idade=40;
String nome="Evandro";
Voc pode ainda declarar as variveis e depois atribuir valores a elas, da

seguinte forma:
int idade;
String nome;
idade=40;
nome="Evandro";
No h, em termos de execuo, diferenas significativas entre declarar as variveis e

j atribuir valores a elas ou declarar as variveis e atribuir os valores posteriormente.
2.3 Tipos de dados em Java

H duas categorias de tipos de dados em Java, os tipos primitivos e os tipos de
referncia. Isso significa que voc poder criar variveis primitivas e variveis
por referncia. Veremos a seguir como criar cada um destes tipos de variveis.
2.3.1 Tipos de dados primitivos em Java

Os tipos de dados primitivos em Java so aqueles tipos essenciais, normalmente
existentes na maioria das linguagens de programao, que no necessitam de
nenhum programa ou classe especial para permitir sua criao. Estes tipos so
mostrados na Tabela 2.1.
Inteiros
Reais
Tipo primitivo
Exemplo
char
byte
short
int
long
float
double
Espao em bytes
usado na memria
2
1
2
4
8
4
8
boolean
boolean casado=true;
char sexo= 'M';

byte idade=55;
short x=3456;
int y= 678934;
long cod=1756453;
float pi=3.1415F;
double valor=34.56;
Tabela 2.1: Tipos de dados primitivos em Java.
2.3.1.1 Tipo char

O tipo char destinado a armazenar um nico caractere, colocado entre aspas
simples. Utiliza dois bytes de memria para armazenamento. Isso significa que
possvel armazenar 65536 caracteres diferentes e exclusivos em uma varivel
do tipo char, sabe por qu?
Porque dois bytes de memria equivalem a 16 bits. Cada um destes 16 bits
pode ser representado pelos algarismos 0 ou 1. Logo, para sabermos quantos
caracteres diferentes possvel armazenar em duas posies (ou bytes) de
memria, basta calcular 216, onde 2 a quantidade de valores possveis para
representar cada bit e 16 o nmero de bits equivalentes a dois bytes de
memria. So exemplos vlidos de variveis do tipo char:
char classe='B';
char sexo='M';
Note que armazenado um nico caractere entres aspas simples.
2.3.1.2 Tipo byte

Um tipo byte um tipo inteiro muito pequeno, que usa apenas um byte de
memria para armazenamento. Como mostrado no tpico anterior, que explica
o tipo char, em um byte de memria possvel armazenar apenas 256 valores
diferentes e exclusivos, logo, um tipo byte pode armazenar apenas 256 valores
inteiros exclusivos. Isso porque 28 = 256.
Ento a linha abaixo est correta?
byte a=240;
No, no est correta. Apesar de voc poder armazenar 256 valores inteiros
diferentes e exclusivos em uma varivel do tipo byte, estes valores podem ser
negativos ou positivos. Logo, voc pode armazenar valores de -128 at 127.
Se voc contar quantos valores inteiros exclusivos existem entre -128 e 127
(incluindo o zero), perceber que existem 256 valores que equivalem ao total
permitido em uma varivel do tipo byte. Sendo assim, no exemplo acima, a
varivel poderia armazenar apenas valores de -128 at 127.
Vamos ver alguns exemplos corretos:
byte a=127;
byte b=-80;
byte c=110;
Em resumo, use variveis do tipo byte apenas se for armazenar valores inteiros
na faixa de -128 at 127. Se precisar armazenar valores maiores, utilize o tipo
short.
2.3.1.3 Tipo short

O tipo short armazena valores inteiros em dois bytes (posies) de memria. Em
duas posies de memria (que equivalem a dois bytes ou 16 bits), possvel
armazenar at 65536 valores inteiros diferentes e exclusivos. Isso porque 216
= 65536, onde 2 o nmero de valores diferentes para cada bit e dois bytes de
memria utilizados para o armazenamento equivalem a 16 bits. Como valores
inteiros podem ser negativos ou positivos (duas possibilidades), dividindo-se
65536 por 2 obtm-se 32768, que a quantidade de nmeros inteiros negativos
e positivos (incluindo o zero), que podem ser armazenados em uma varivel
do tipo short. Sendo assim, variveis do tipo short podem receber valores de
-32768 at 32767. A quantidade de nmeros inteiros deste intervalo 65536.
Vamos ver alguns exemplos:
short f=-20567;
short g=31789;
short h=32767;
short i=-32768;
Se precisar armazenar valores inteiros maiores, deve utilizar o tipo int.
2.3.1.4 Tipo int

O tipo int o tipo padro da linguagem Java para armazenamento de valores
inteiros em 4 bytes (posies) de memria. Isso nos leva a concluir que
possvel armazenar at 4294967296 valores inteiros exclusivos em uma
varivel do tipo int, pois 232 = 4294967296, onde 2 a quantidade de valores
que representam os bits (0 ou 1) e 32 o nmero de bits referente aos 4 bytes
de memria usados para armazenar valores do tipo int. Como valores inteiros
podem ser negativos ou positivos, dividindo-se 4294967296 por 2 obtm-se
2147483648, que a quantidade de valores negativos e positivos que podem
ser armazenados (incluindo o zero) em uma varivel int. Desta forma, uma
varivel do tipo int pode armazenar valores de -2147483648 at 2147483647.
Se precisar armazenar valores maiores, utilize o tipo long.
2.3.1.5 Tipo long

O tipo long armazena valores inteiros em 8 bytes (posies) de memria.
Isso nos leva a concluir que para saber quantos valores inteiros diferentes
e exclusivos podem ser armazenados em uma varivel do tipo long basta
calcular 264 = 18446744073709551616, onde 2 a quantidade de valores que
representam os bits (0 ou 1) e 64 o nmero de bits referente aos 8 bytes de
memria usados para armazenar valores do tipo long. Teoricamente, seguindo
a linha de raciocnio utilizada nos tipos inteiros explicados anteriormente,
possvel armazenar em uma varivel do tipo long valores inteiros de
-9223372036854775808 a 9223372036854775807.
2.3.1.6 Tipo float

O tipo float utilizado para armazenar valores numricos reais, ou seja, que
normalmente necessitam de casas decimais. Utiliza 4 bytes (posies) de
memria. Para saber a quantidade de valores reais exclusivos que possvel
armazenar em uma varivel do tipo float, basta calcular 232, que equivale a
4294967296. No d para determinar a faixa de valores permitida, por se tratar
de armazenamento de nmeros reais.
float pi=3.1415F;
float valor=45.6789F;
Por no ser considerado o tipo padro para nmeros reais da linguagem Java,
j que o tipo padro double, valores atribudos a uma varivel do tipo float
devem terminar com a letra F.
2.3.1.7 Tipo double

O tipo double o padro da linguagem Java para armazenamento de valores
numricos reais. Utiliza 8 bytes (posies) de memria para armazenamento
do valor. Para saber a quantidade de valores reais exclusivos que possvel
armazenar em uma varivel do tipo double, basta calcular 264, que equivale
a 18446744073709551616. Assim como no tipo float, no possvel
determinar a faixa de valores permitida, por se tratar de armazenamento
de nmeros reais.

double valorTotal=1765642.45;
double renda=10678.99;
2.3.1.8 Tipo boolean

O tipo boolean armazena apenas valores lgicos true ou false em um byte de
memria. True equivale ao bit 1 e false, ao bit 0. Teoricamente seria necessrio
apenas um bit para armazenar um valor boolean, porm, como os computadores
trabalham com posies de memria de 8 bits, um byte ser necessrio. Vamos
ver alguns exemplos:
boolean estudante=true;
boolean fumante=false;
2.3.2 Converses de tipos de dados primitivos

Os dados numricos primitivos em Java podem ser convertidos de um tipo
para outro, de acordo com a necessidade. H dois tipos de converso: de um
tipo de menor preciso para um tipo de maior preciso (promotion) e de um
tipo de maior preciso para um tipo de menor preciso (casting). Estes tipos
de converso so apresentados a seguir.
2.3.2.1 Casting
Se a converso for de um tipo de dado de maior preciso para um tipo de dado
de menor preciso, o processo de converso chamado casting.
Trabalharemos neste tpico converses dos seguintes tipos de dados:
byte
short
int
long
float
double
Casting ocorre sempre que se deseja converter de um tipo mais abaixo, na lista
de tipos apresentada, para um tipo mais acima.
Por exemplo, para converter um valor do tipo int para byte, utiliza-se:
int a=10;
byte b=(byte) a;
Veja que a varivel int a recebeu o valor inteiro 10 e este valor foi convertido
para byte e armazenado na varivel byte b.
Para fazer casting, na converso, coloca-se o tipo de dado para o qual se quer
converter entre parnteses.
Vejamos outros exemplos:
double b=10.0;
short c=(short) b;
O valor 10 da varivel double b foi convertido e armazenado na varivel short c.

double d=13.0;
float e=(float) d;
O valor 13 da varivel double d foi convertido e armazenado na varivel float e.

long f=1234;
int g=(int) f;
O valor 1234 da varivel long f foi convertido e armazenado na varivel int g.
2.3.2.2 Promotion
Quando a converso ocorre de um tipo de menor preciso para um tipo de
maior preciso, ou seja, de um tipo mais acima na lista de tipos apresentada,
para um tipo mais abaixo, a converso ser direta, sem precisar de casting.
Neste caso chamamos a operao de promotion.
Vejamos alguns exemplos:
int a = 1786;
long c = a;
byte v = 2;
double x=v;
short t = 290;
long u = t;
int k=1675;
float l=k;
Veja que as converses, neste caso, acontecem sem necessidade de indicar

entre parnteses o tipo para o qual se est convertendo o valor.
2.3.3 Tipos de dados por referncia em Java

Como voc aprendeu no tpico anterior, os tipos primitivos so aqueles mais
simples, comuns maioria das linguagens de programao, que no necessitam
de nenhum recurso especial para serem declarados. Voc deve ter notado que
todos os tipos primitivos so escritos em letra minscula.
J os tipos de referncia, so aqueles que necessitam de uma classe (ou arquivo
de programa) para serem declarados e manipulados. Muitas destas classes
j vm instaladas com o Java (como a classe String.java e Date.java), mas
muitas precisaro ser criadas. Quando se usa os tipos de referncia, dizemos
que o valor armazenado no objeto da classe de referncia. O objeto nada
mais , neste caso, de forma simplificada, uma varivel que permite acessar
as operaes que podem ser aplicadas sobre o valor na classe de referncia.
Voc pode criar novos tipos de dados por referncia, de acordo com suas
necessidades, o que torna a linguagem bastante dinmica no que se refere a
manipulao de dados.
Os tipos de dados por referncia mais comuns so Date e String.
Em linguagens orientadas a objetos, os arquivos de programas so deno-
NOTA minados classes. Desta forma, no decorrer dos demais tpicos deste livro,
utilizaremos a palavra classe como sinnimo de arquivo de programa.
2.3.3.1 Tipo de dado String

O tipo de dado String utiliza a classe String.java, que instalada como parte
da plataforma Java, para declarar uma varivel.
H duas maneiras de declarar uma varivel do tipo String:
String nome = "Evandro";
ou
String nome = new String("Evandro");
Como visto anteriormente, voc ainda poderia separar declarao e atribuio

em duas operaes distintas, da seguinte forma:
String nome;
nome = "Evandro";
ou
String nome;
nome = new String("Evandro");
Em todos os casos, o valor entre aspas passado para a classe String.java e

l cada caracter manipulado como um tipo primitivo char. Basicamente um
tipo String uma espcie de array de valores do tipo char.
Note que a palavra String, na declarao do tipo da varivel, escrita em letra
maiscula, j que se refere classe String.java, cujo nome se inicia por letra
maiscula.
2.3.3.2 Tipo de dado Date

Assim como o tipo String, Date um tipo de dado de referncia, ou seja,
utiliza a classe Date.java para ser manipulado. H diversas classes, alm da
Date.java, para manipular datas, mas neste tpico utilizaremos a forma mais
simples, apresentada a seguir:
Date nascimento = new Date("07/08/1974");
Na varivel nascimento ser armazenado o valor Mon Jul 08 00:00:00 BRT

1974. H classes Java que permitem formatar a forma como a data armazenada
e impressa, mas estas classes no fazem parte do escopo deste tpico.
2.3.3.3 Outros tipos de dados de referncia

Alm dos tipos de referncia String e Date, h diversos outros tipos de
referncia em Java, para o caso de voc no querer utilizar os tipos de dados
primitivos para manipulao de valores numricos. Voc pode utilizar as classes
como Byte.java, Short.java, Integer.java, Long.java, Float.java e Double.java
para manipular estes tipos, como apresentado nos exemplos a seguir.
Byte b = new Byte("120");

Short s=new Short("10");
Integer i = new Integer("10");
Long l = new Long("1678");
Double d = new Double("14.5");
Float f = new Float("13.14");
Observe que b uma varivel que faz referncia classe Byte.java, ou seja,
uma varivel do tipo Byte. Dizemos, neste caso, que b um objeto do tipo
Byte. Deixaremos os detalhes em relao ao termo objeto para o prximo
Captulo deste livro.
Da mesma forma, s um objeto do tipo Short, i um objeto do tipo Integer, l
um objeto do tipo Long, e assim por diante.
Alm das classes de referncia para tipos de dados numricos acima, caso
precise armazenar e manipular valores acima dos limites permitidos nos tipos
de dados numricos primitivos, pode utilizar a classe BigDecimal.java, como
mostra o exemplo a seguir:
BigDecimal g = new BigDecimal ("98876716752638949.78");
Veja que g um objeto da classe BigDecimal.java que armazena um valor

superior ao permitido nos tipos de dados primitivos.
2.3.3.4 Tipos de dados de referncia personalizados

No tpico Programao Orientada a Objetos, foram apresentadas duas
classes, Exemplo.java e Aluno.java. Na classe Exemplo.java, voc pde
encontrar a instruo abaixo:
Aluno aluno = new Aluno(nome, nota1, nota2);
Veja que aluno uma varivel que faz referncia classe Aluno.java, ou seja,
uma varivel do tipo Aluno. Neste caso, dizemos que aluno um objeto da
classe Aluno.java. Esta classe contm recursos para manipular os dados do
aluno e executar operaes sobre estes dados.
Voc pode criar classes para manipular outras categorias de informaes e criar
objetos (variveis) de referncia a estas classes. Veremos isso nos prximos
Captulos deste livro.
2.4 Tipos de operaes realizadas em

programas Java
Em toda linguagem de programao orientada a objetos ou no, voc pode
realizar uma srie de operaes sobre valores armazenados na memria. Os
principais tipos de operaes que podem ser realizadas sobre os dados so por
meio de expresses aritmticas, relacionais e lgicas.
Este tpico apresenta um resumo destes tipos de expresses fundamentais na

lgica de programao.
2.4.1 Expresses aritmticas

As expresses aritmticas so clculos matemticos realizados normalmente
com valores armazenados em variveis. Por exemplo:
int a = 1;
int b = 3;
int c = a + b;
Note que a varivel c armazenar o valor 4. Uma expresso aritmtica utiliza

operadores aritmticos (sinais) e operandos (valores). A Tabela 2.2 mostra
alguns exemplos de expresses aritmticas.
Operador
*
Significado
Multiplicao
Diviso
Soma
Subtrao
Tabela 2.2: Operadores aritmticos.
Exemplos
double quantidade=20;
double valor = 109.6;
double total = quantidade*valor;
double salario=1987.7;
double percentual=10.0;
double aumento=salario*percentual/100;
int a=10;
int b=20;
int c=a + b;
double desconto=200.57;
double salLiquido= salario desconto;
Operaes que envolvem razes, exponenciao e outras operaes mate-
NOTA mticas e de trigonometria, so realizadas utilizando a classe Math.java.

importante lembrar as prioridades matemticas dos clculos envolvendo
vrios operadores aritmticos. Primeiro so realizados multiplicao e diviso
e depois, soma e subtrao. Por exemplo:
double percentualAumento=1876.56;
double salReajustado=salario + salario * percentualAumento / 100;
Note que primeiro realizado o clculo de salario*percentualAumento/100

para depois o valor resultante ser somado ao contedo da varivel salario.
Caso voc queira alterar a prioridade natural das operaes, forando a
realizao de uma operao de menor prioridade antes de uma operao de
maior prioridade, deve colocar a operao de menor prioridade entre parnteses.
Veja o exemplo a seguir:
double nota1=9.5;
double nota2=6.0;
double media=(nota1+nota2)/2;
Veja que naturalmente seria realizada a diviso de nota2 por 2 para depois o
valor resultante ser somado ao contedo da varivel nota1. Porm, o parntese
altera esta ordem natural, fazendo com que primeiro o contedo da varivel
nota1 seja somado ao contedo da varivel nota2 para depois o valor resultante
ser dividido por 2.
2.4.1.1 Operaes de incremento e decremento

Dentro da categoria das expresses aritmticas esto as operaes que
incrementam e decrementam valores em uma varivel. A Tabela 2.3 mostra
exemplos destas operaes que podem ser realizadas de modo extendido e
reduzido. Considere a existncia de uma varivel a declarada da seguinte
forma:
int a=10;
Modo extendido
Modo reduzido
a=a+1;
a=a+5;
a=a*4;
a=a/2;
a=a-1;
a=a-6;
a++;
a+=5;
a*=4;
a/=2;
a--;
a-=6;
Valor resultante na
varivel a
11
15
40
5
9
4
Operao
incremento
incremento
incremento
decremento
decremento
decremento
Tabela 2.3: Operaes de incremento e decremento de variveis.
Voc pode utilizar tanto o modo extendido quanto o modo reduzido que ter
o mesmo resultado.
Veja que o contedo da varivel a utilizado na operao e o resultado
armazenado na prpria varivel a. Quando o valor resultante for maior do que
o valor inicial da varivel, ocorreu uma operao incremento. Quando o valor
resultante for menor, ocorreu um decremento de valor.
2.4.2 Expresses relacionais

As expresses relacionais envolvem a comparao de dois valores por meio
dos operadores relacionais mostrados na Tabela 2.4. Considere a existncia
de trs variveis declaradas com os valores seguintes:
int a=2;
int b=5;
int c=5;
Operador
==
Significado
igual
>
>=
maior
maior ou igual
<
<=
!=
menor
menor ou igual
diferente
Exemplo
a==b
b==c
b>a
b>=c
a>=c
b<c
a<=b
a!=b
b!=c
Resultado
false
true
true
true
false
false
true
true
false
Tabela 2.4: Operadores relacionais.
Note que o resultado de uma operao relacional ser sempre um valor boolean
(true ou false). Para indicar o que deve ocorrer se a avaliao da expresso for true
ou false utiliza-se o comando if que veremos no decorrer neste Captulo.
2.4.3 Expresses lgicas

Expresses lgicas so aquelas que envolvem dois valores boolean e resultam
em um terceiro valor boolean. Utiliza operadores lgicos como NO, OU e E.
A Tabela 2.5 mostra os operadores lgicos em ordem de prioridade, de cima
para baixo, e exemplos de expresses. Para entender os exemplos considere a
existncia de duas variveis declaradas com os valores seguintes:
boolean a=true;
boolean b=false;
Operador
!
Significado
No
&&
||
OU
Exemplo
!a
!b
a&&b
a&&a
a||b
b||b
Resultado
false
true
false
true
true
false
Tabela 2.5: Operadores lgicos.
Para saber mais sobre expresses lgicas, pesquise na Internet sobre o
NOTA tema Tabela Verdade. Trata-se de uma tabela que mostra os resultados das principais expresses lgicas.
2.4.4 Expresses mistas

As expresses mistas podem envolver expresses aritmticas, relacionais e/ou
lgicas em uma nica operao. Quando isto acontece, primeiro so resolvidas
as expresses aritmticas, em seguida as operaes relacionais e, por ltimo,
as expresses lgicas. Veja um exemplo, considerando que as variveis a, b e
c foram inicializadas com os valores abaixo.
int a=2;
int b=5;
int c=3;
boolean resultado=(a+b*a)>(b-c) && (b+c)<=(a+c);
Na resoluo, primeiro so resolvidas as expresses aritmticas, resultando em:

14 > 2 && 8 <= 5
Em seguida, so resolvidas as expresses relacionais, resultando em:

true && false
Por ltimo, resolvida a expresso lgica, resultando no valor false que

armazenado na varivel boolean resultado.
2.5 Estruturas de seleo utilizadas em Java
As estruturas de seleo utilizadas em Java comparam valores e, de acordo

com o resultado da comparao, realiza determinados procedimentos. Se o
resultado for verdadeiro (true), executa um tipo de procedimento. Se for falso
(false), executa outro.
As principais estruturas de seleo utilizadas em Java so if..else e switch...
case. Estas estruturas so apresentadas a seguir.
NOTA
Para testar as estruturas apresentadas no restante deste Captulo, coloque os cdigos-fonte apresentados no interior do mtodo main de uma
classe principal criada em um projeto Java no NetBeans. Para compilar e executar a classe, pressione a tecla F6. Se precisar de mais orientaes sobre esse procedimento, reveja o Captulo 1.
2.5.1 Estrutura de seleo if...else

Utiliza-se, assim como em outras linguagens de programao, a estrutura de
seleo com a sintaxe seguinte:
if (expresso) {
procedimento caso o resultado seja true
} else {
procedimento caso o resultado seja false
}
Por exemplo:
int a=2;
int b=6;
if (a>=b){
System.out.println("a contm um valor maior ou igual a b");
} else {
System.out.println("a no contm um valor maior ou igual a b");
}
Neste exemplo, como a varivel a no contm um valor maior ou igual a b,

ser exibida a mensagem a no contm um valor maior ou igual a b.
Observe que para o caso da expresso ser verdadeira, ser executado o comando
no interior da primeira chave. Caso seja falsa, ser executado o comando no
interior da segunda chave.
Para comparar se dois valores numricos so iguais, utiliza-se a estrutura a seguir:
if (a==b) {
} else {
}
Para comparar se dois valores numricos so diferentes, utiliza-se a estrutura

a seguir:
if (a!=b) {
} else {
}
NOTA
Quando apenas um comando tiver de ser executado para cada resultado da comparao (true ou false), as chaves so desnecessrias. Caso
seja necessrio executar mais de um comando para cada resultado, as
chaves sero obrigatrias.
2.5.2 Estrutura de seleo if...elseif...else

Voc pode encadear estruturas if caso necessite fazer diversas comparaes.
Para isso utiliza-se uma estrutura com a seguinte sintaxe:
if (expresso 1) {
procedimento caso o resultado da expresso seja true
} else if (expresso 2) {
procedimento caso o resultado da primeira expresso tenha sido false e da expresso
atual tenha sido true.
} else if (expresso 3){
procedimento caso o resultado da primeira e da segunda expresses tenham sido false
e da expresso atual tenha sido true.
} else {
procedimento caso o resultado de todas as expresses anteriores tenha sido false
}
Veja que muitas expresses podem ser avaliadas utilizando esta estrutura.
Por exemplo:
if (nota1<nota2 && nota1<nota3) {

media=(nota2+nota3)/2;
} else if (nota2<nota3){
} else {
}
System.out.print(media);
Na estrutura apresentada, dadas trs notas armazenadas respectivamente nas

variveis nota1, nota2 e nota3, ser calculada a mdia aritmtica das duas
maiores.
2.5.3 Comparando valores String com if...else

Valores String podem ser comparados apenas quanto igualdade e no utilizam
o operador relacional == como para comparar valores numricos. Desta forma,
para verificar se uma varivel nome contm o valor Pedro utiliza-se:
if (nome.equals("Pedro") {
} else {
}
Caso queira ignorar a forma como o valor est armazenado na varivel, ou

seja, independente da letra estar maiscula ou minscula, utiliza-se:
if (nome.equalsIgnoreCase("pedro") {
} else {
}
Neste exemplo, se o nome estiver armazenado, por exemplo, como Pedro,

pedro, PEDRO ou PeDrO, o resultado da expresso ser true, pois o
caixa da letra (alta ou baixa) ser ignorado.
2.5.4 Estrutura de seleo switch...case...default

A estrutura de seleo switch...case...default em Java, assim como acontece
em Linguagem C, aceita apenas tipos como byte, short, int, long etc. Esta
estrutura realiza apenas verificao de igualdade, ou seja, verifica se uma
varivel contm um valor especfico.
A sintaxe da estrutura de seleo switch...case...default apresentada a seguir:

switch(varivel) {
case valor:
operao a ser realizada se a varivel contiver o valor especificado no case
break;
case valor:
break;
case valor:
break;
default:
}
Exemplo:
public class Principal {
int a = Integer.parseInt(JOptionPane.showInputDialog("Digite um valor inteiro
para a varivel a"));
switch (a) {
case 0:
System.out.print("A varivel recebeu o valor 0");
break;
case 1:
break;
case 2:
break;
default:
System.out.print("A varivel recebeu qualquer outro valor no testado
acima");
}
}
}
Note que solicitado ao usurio um valor inteiro que armazenado na varivel

a. Em seguida, o contedo desta varivel testado pela instruo switch. Caso
ela tenha recebido o valor 0, a mensagem A varivel recebeu o valor 0 ser
exibida. Caso tenha recebido o valor 1, a mensagem A varivel recebeu o
valor 1 ser exibida. Caso tenha recebido o valor 2, a mensagem A varivel
recebeu o valor 2 ser exibida. Caso tenha recebido qualquer outro valor
ainda no testado, a mensagem A varivel recebeu qualquer outro valor no
testado acima ser exibida.
Veja que aps a operao realizada em cada teste case h um comando

break. Este comando encerra os testes case quando a condio verdadeira for
encontrada. Vale observar a instruo default, sempre aps o ltimo case, para
o caso de alguma condio ter sido esquecida nos testes.
A estrutura switch...case...default tambm pode ser utilizada com valores
String. Veja o exemplo a seguir:
String cidade;
cidade = JOptionPane.showInputDialog("Digite o nome da cidade:");
switch (cidade) {
case "So Paulo":
System.out.println("Cidade da garoa");
break;
case "Rio de Janeiro":
System.out.println("Cidade maravilhosa");
break;
default:
System.out.println("Cidade no reconhecida");
}
}
}
Note que se a cidade informada pelo usurio for So Paulo, ser exibida
a mensagem Cidade da garoa. Se for Rio de Janeiro, ser exibida a
mensagem Cidade maravilhosa. Se for qualquer outra cidade, ser exibida
a mensagem Cidade no reconhecida.
2.6 Laes de repetio em Java

Em Java h trs estruturas para criar laos de repetio: for, while e do...while.
Estas estruturas sero apresentadas nos tpicos a seguir. Vale relembrar que
uma estrutura de repetio utilizada quando uma mesma operao precisa
ser executada vrias vezes mudando apenas detalhes desta operao.
2.6.1 Laos de repetio for

Os laos de repetio for operam sobre variveis contendo valores numricos
inteiros. Todo lao de repetio possui uma estrutura semelhante contendo
inicializao de uma varivel que um contador, o teste desta varivel e o
incremento ou decremento. Veja a sintaxe da estrutura de repetio for:
for (valor inicial da varivel contador; teste; incremento/decremento){
operao a ser repetida
}
Exemplo de lao com incremento:

for (int cont=1; cont<=10; cont++){
System.out.print(cont);
}
Veja que a varivel cont inicializada com o valor 1 e testada a cada passagem
pelo lao verificando se contm um valor menor ou igual a 10. Em cada
passagem pelo lao, esta varivel vai sendo incrementada em 1. Quando a
varivel receber o valor 11, que torna o teste false, o lao finalizado.
Exemplo de lao com decremento:
for (int cont=10; cont>=1; cont--){
}
Veja neste exemplo que a varivel cont inicializada com o valor 10 e

decrementada em 1 a cada passagem pelo lao, onde o valor testado e a
operao do interior do lao realizada enquanto a condio for verdadeira.
Quando a varivel receber o valor 0, o lao ser finalizado.
Em alguns casos, a varivel cont no inicializada no interior do lao, mas
antes dele, sem comprometer ou modificar a execuo. Veja um exemplo:
int cont=10;
for (; cont>=1; cont--){
}
Se preferir, pode apenas declarar a varivel fora do lao. Veja o exemplo:

int cont;
for (cont=10; cont>=1; cont--){
}
2.6.2 Laos de repetio while

A maior diferena entre o lao de repetio for e o lao while que o lao while
compara tambm valores que no so numricos. Em todo lao haver inicializao
da varivel do contador, o teste da varivel e o incremento ou decremento. A
diferena neste sentido que estas operaes ocorrem em linhas diferentes, e no
na mesma linha como o caso do lao for. Veja a sintaxe do lao while:
declarao e inicializao da varivel contador
while(teste da varivel contador) {
incremento ou decremento da varivel contador
}
Veja o exemplo abaixo com incremento da varivel cont:

int cont=1;
while (cont<=10){
cont++;
}
A instruo de incremento foi escrita de forma reduzida (cont++), mas poderia

ter sido escrita de forma extendida (cont = cont +1) que daria o mesmo resultado.
As duas formas podem ser usadas em qualquer tipo de lao de repetio.
Veja agora um exemplo com decremento da varivel contador:
int cont=10;
while (cont>=1){
cont-=2;
}
Veja que neste exemplo, a varivel cont decrementada em 2 a cada passagem do

lao. A instruo cont-=2 tambm poderia ter sido escrita como cont = cont 2.
A estrutura de repetio while tambm permite testes com valores String. Veja
o exemplo a seguir:
String resposta = "sim";
while (resposta.equalsIgnoreCase("sim")) {
String nome = JOptionPane.showInputDialog("Nome:");
String telefone = JOptionPane.showInputDialog("Telefone:");
resposta = JOptionPane.showInputDialog("Deseja continuar[sim/no]?");
}
Veja que o contedo do lao ser repetido enquanto a resposta da pergunta

Deseja continuar[sim/no]? for sim. Este exemplo no poderia ser
implementado utilizando o lao for.
2.6.3 Laos de repetio do...while

O lao de repetio do...while testa a condio aps a operao do interior do
lao ser realizada, e no antes, como acontece no lao while.
Isso faz com que o lao seja executado pelo menos uma vez, mesmo que a
condio retorne false no primeiro teste. A sintaxe do comando apresentada
a seguir:
declarao e inicializao da varivel contador
do {
incremento ou decremento da varivel contador
} while(teste da varivel contador);
Veja um exemplo:
int cont=1;
do {
cont++;
} while (cont<=10);
necessrio ter cuidado ao utilizar esta estrutura de repetio, pois se a

condio for falsa j no primeiro teste, mesmo assim o contedo do lao ser
executado. Veja um exemplo deste tipo:
int cont=11;
do {
cont++;
} while (cont<=10);
Neste caso, a varivel cont foi inicializada com o valor 11, o que faz com que
no primeiro teste o resultado seja false. Mesmo assim, a mensagem ser exibida
uma vez.
2.6.4 Arrays em Java

Arrays so variveis que permitem armazenar vrios valores, ao contrrio de
variveis simples. H dois tipos de arrays, os vetores e as matrizes. Os vetores so
chamados de arrays unidimensionais, e as matrizes, de arrays multidimensionais.
Quando se armazena informaes em uma array Java, cada posio da array

identificada por um ndice numrico inteiro, iniciado sempre em 0.
2.6.5 Arrays unidimensionais

Nas arrays unidimensionais os valores so armazenados em apenas uma
dimenso, que normalmente representada em linha. Cada posio da linha
(coluna) recebe um ndice numrico inteiro iniciado em 0.
Veja um exemplo de array unidimensional, declarada em Java da seguinte forma:
String nomes[] = new String[3];
nomes
0
Para armazenar valores nas posies da array, utiliza-se as seguintes instrues:

nomes[0]="Paulo";
nomes[1]="Pedro";
nomes[2]="Ana";
Veja como ficar:

nomes
Paulo
0
Pedro
1
Ana
2
Observe que na representao da array unidimensional os nomes so

armazenados, em uma representao simblica, em colunas de uma nica linha.
Cada coluna identificada por um valor de ndice iniciado por 0.
Note que na declarao da array voc indicou que ela ter 3 posies, porm,
os ndices vo de 0 2.
Para declarar uma array unidimensional de outros tipos utilize sempre a sintaxe:
TipoDeDado nomeDaArray[]=new TipoDeDado[quantidadeDePosies]
Por exemplo:
String clientes[] = new String[2];
int idades[] = new int[4];
double salarios[]=new double[3];
Para armazenar valores nestas arrays utiliza-se:

clientes[0]= "Joo";
clientes[1]= "Paulo";
idades[0] = 19;
idades[1] = 40;
idades[2] = 29;
idades[3] = 41;
salarios[0]=1678.67;
Nos exemplos acima declaramos as arrays e depois armazenamos os valores

em cada posio. Outra maneira de obter o mesmo resultado j atribuir os
valores na declarao da array. Ficaria da seguinte forma:
String clientes[]={"Joo","Paulo"};
int idades[]={19,40,29,41};
double salarios[]={1678.67,1390.00,2765.34};
O resultado pode ser representado da seguinte maneira:

clientes
Joo
0
Paulo
1
idades
19
0
40
1
29
2
41
3
salarios
1678.67
0
NOTA
1390.00
1
2765.34
2
Na declarao de array os colchetes podem vir antes ou depois do nome

da array. Isto significa, por exemplo, que tanto int idades[] = new int[4];
quanto int[] idades = new int[4]; so declaraes corretas.
2.6.6 Arrays multidimensionais

Arrays multidimensionais podem ter muitas dimenses, mas normalmente so
usadas apenas duas, visualizadas, simbolicamente, como linhas e colunas. As
arrays multidimensionais mais comuns so as de duas dimenses, chamadas
bidimensionais, que sero explicadas neste tpico.
Veja o exemplo abaixo de uma array bidimensional declarada da seguinte forma:
String nomes[][]= new String[2][2];
nomes
0
1
Observe que trata-se de uma array de duas dimenses, onde tanto as linhas
quanto as colunas possuem ndices numricos iniciados em 0.
Para armazenar valores nesta array utiliza-se as instrues:
nomes[0][0]= "Paulo";
nomes[0][1]= "Maria";
nomes[1][0]= "Ana";
nomes[1][1]= "Angela";
O resultado pode ser representado da seguinte forma:

nomes
0
1
Paulo
Ana
0
Maria
Angela
1
Caso seja necessrio visualizar o nome Angela, voc pode digitar o comando
a seguir:
System.out.print (nomes[1][1]);
Note que h necessidade de indicar a posio da array onde o nome se encontra.

Para armazenar em uma posio da array uma informao digitada pelo usurio,
voc pode utilizar a seguinte instruo:
nomes[1][1] = JOptionPane.showInputDialog("Digite um nome");
Detalhes sobre os comandos Java acima sero apresentados nos Captulos

seguintes deste livro.
Se desejar declarar a array e j atribuir valores s suas posies, voc pode
fazer da seguinte forma:
String [][] nomes = { { "Paulo", "Maria"}, { "Ana", "Angela"} };
2.6.7 Percorrendo arrays com laos de repetio

comum popular (preencher) arrays utilizando laos de repetio.
Veja o exemplo utilizando o lao for:

String[] nomes = new String[3];
for (int indice=0;indice<3;indice++){
nomes[indice] = JOptionPane.showInputDialog("Digite um nome:");
}
Veja o exemplo utilizando o lao while:

int indice=0;
while (indice<3){
nomes[indice] = JOptionPane.showInputDialog("Digite um nome:");
indice++;
}
O lao ser executado 3 vezes, pois o contador (varivel indice) vai de 0 2,

incrementando de 1 em 1. Ao passar pelo lao a primeira vez, o nome digitado
ser armazenado na posio 0 da array nomes. Ao passar pelo lao pela segunda
vez o nome digitado ser armazenado na posio 1 da array. Ao passar pela
terceira vez, o nome digitado ser armazenado na posio 2 da array.
Para exibir os valores armazenados tambm podem ser utilizados laos de
repetio, da seguinte forma:
for (int i=0;i<3;i++){
System.out.println(nomes[i]);
}
OU
int i=0;
while (i<3){
System.out.println(nomes[i]);
i++;
}
A condio de teste do lao poderia ser modificada de i<3 para i<nomes.length.

A instruo nomes.length captura o tamanho da array nomes, que neste caso 3.
No caso das arrays bidimensionais so necessrios dois laos de repetio
encadeados, um para cada dimenso. Veja o exemplo:
String[][] nomes = new String[2][2];
for (int indiceLinha = 0; indiceLinha < 2; indiceLinha++) {
for (int indiceColuna = 0; indiceColuna < 2; indiceColuna++) {
nomes[indiceLinha][indiceColuna] = JOptionPane.showInputDialog("Digite
um nome:");
}
}
2.7 Variveis e constantes em Java

Variveis so espaos na memria identificados por um nome onde podem ser
armazenadas informaes sujeitas a mudanas no decorrer da execuo do
programa. Como os valores que podem ser armazenados podem ser caracteres,
nmeros inteiros, nmeros reais, valores booleanos, datas etc, na declarao da
varivel necessrio, em Java, indicar o tipo de valor que a varivel armazenar.
As variveis podem ser simples, quando armazenam um nico valor; arrays,
quando armazenam vrios valores; e objetos, que discutiremos mais frente
neste livro.
Vale lembrar que quando se trabalha com variveis voc pode declarar a
varivel e posteriormente armazenar valores nela (o que mais indicado) ou
j declarar a varivel atribuindo valores.
Para declarar uma varivel simples e em seguida armazenar um valor nela,
basta seguir a sintaxe abaixo:
TipoDaVarivel nomeDaVarivel;
nomeDaVarivel=valor;
TipoDaVarivel pode ser char, byte, short, int, long, float, double, boolean,
String, Date etc. Veja alguns exemplos:
int codigo;
codigo=10;
String cidade;
cidade= "So Paulo";
char sexo;
sexo= 'F';
Um valor armazenado em uma varivel pode mudar no decorrer da execuo

do programa. Desta forma, se forem executados os comandos abaixo, o valor
da varivel idade ir variar.
int idade = 39;
idade = 80;
Veja que a varivel idade recebeu o valor 39 e depois teve o valor modificado
para 80.
Outra maneira de trabalhar com variveis simples declarando a varivel e
j atribuindo valor na mesma linha, em uma nica instruo. Neste caso a
sintaxe ser:
TipoDaVarivel nomeDaVarivel=valor;
Veja o exemplo:
int codigo=1012;
String email= "aluno@uninove.edu.br";
2.7.1 Constantes
A diferena entre uma varivel e uma constante que o valor armazenado em
uma varivel pode mudar no decorrer da execuo de um programa e o valor
armazenado em uma constante, no.
Em Java, para declarar uma constante utiliza-se a sintaxe seguinte:
final TipoDaConstante NomeDaConstante = valor;
A palavra reservada final identifica que trata-se de uma constante e no de uma

varivel. Veja um exemplo:
final double PI = 3.1415;
Veja que PI uma constante, o que significa que o valor armazenado no

poder ser modificado na aplicao.
2.7.2 Boas prticas para nomeao de variveis e

constantes em Java
Existem um conjunto de boas prticas utilizadas em Java para nomear
variveis e constantes. Boas prticas so padres adotados pela comunidade
de desenvolvedores e recomendadas pelo fabricante da linguagem. No seguir
estas prticas no causa normalmente erros de compilao ou de tempo de

execuo no programa, porm, recomendvel se voc quer demostrar que
possui bons conhecimentos da linguagem.
So boas prticas na nomeao de variveis:
Se o nome da varivel for composto por apenas uma palavra, esta dever
ser escrita em letra minscula. Exemplo: int idade=50;
Se o nome da varivel for composto por mais de uma palavra, a primeira
deve ser escrita em letra minscula e as demais, sem espaos em
branco, devem ser escritas com letra inicial maiscula. Exemplo: String
nomeClienteEspecial="Paulo Freitas";
No utilizar acentos, espaos em branco e caracteres especiais do portugus

nos nomes das variveis;
No iniciar nomes de variveis por nmeros ou caracteres especiais.
Na nomeao de constantes, todo o nome da constante deve ser escrito em letra
maiscula. Exemplo: final String CATEGORIA= Tcnico;
2.8 Resumo
Este Captulo apresentou um conjunto de conceitos e estruturas utilizados em
Java que incluem:
A diferena entre programao estruturada e orientada a objetos;
Os tipos de dados para declarar variveis (primitivos e por referncia);
As categorias de variveis (simples, arrays e objetos);
Operaes (aritmticas, relacionais e lgicas);
Declarao e atribuio de dados s variveis simples;
Declarao, atribuio de valores e manipulao de dados em arrays
unidimensionais e bidimensionais;
Declarao e atribuio de valores constantes;
Estruturas de seleo (if..elseif..else e switch...case..default);
Estruturas de repetio (for, while e do while).
A programao de computadores pode ser realizada de formas diferentes, de
acordo com um conjunto de princpios e recursos disponveis na linguagem de
programao. Estas formas so conhecidas como paradigmas de programao.
Os dois principais paradigmas so Programao Estruturada e Programao
Orientada a Objetos. Na programao estruturada os comandos so executados
sequencialmente, normalmente em um nico programa, que executa todas
as operaes necessrias. Na programao orientada a objetos as operaes
referentes determinadas classes de informaes so executadas em arquivos

de programa separados do programa principal, denominados classes. Desta
forma, as operaes, por exemplo, relacionadas a funcionrios, so executadas
em uma classe Funcionario.java, as operaes relacionadas a clientes, em uma
classe denominada Cliente.java e assim por diante.
Tanto nas linguagens orientadas a objetos quanto nas linguagens estruturadas

so utilizados recursos bsicos de programao que permitem criar variveis,
constantes, estruturas de seleo e repetio e arrays.
Variveis so espaos na memria identificados por um nome que armazenam
informaes que podem mudar no decorrer da execuo do programa. Para criar
variveis em Java voc precisa declarar seu tipo, pois Java uma linguagem
fortemente tipada. Existem duas categorias de tipos de dados em Java: primitivos
e por referncia. Os tipos primitivos so os tipos mais simples e essenciais
(char, byte, short, int, long, float, double e boolean). Os tipos por referncia
necessitam de classes prontas ou da criao de novas classes. Os principais
tipos de referncia so Date, String, Byte, Short, Integer, Long, Double, Float
e BigDecimal. Voc pode criar novos tipos de dados em Java, caso necessite.
Caso queira armazenar um valor que no vai mudar durante a execuo do
programa, utilize uma constante. Um valor armazenado em uma constante
no poder ser alterado.
Para fazer comparaes em Java utilizam-se estruturas de seleo. As estruturas
de seleo so if..elseif...else e switch...case...default.
Quando h necessidade de repetir tarefas em um programa utilizam-se os laos
de repetio. Em Java existem trs tipos de laos de repetio: for, while e
do...while.
Alm das variveis simples, que armazenam apenas um valor, em Java
possvel criar arrays unidimensionais (vetores) e multidimensionais (matrizes)
para armazenar diversos valores. Cada valor armazenado na array identificado
por um ndice inteiro. Para armazenar e ler informaes em arrays normalmente
so utilizados laos de repetio.
2.9 Exerccios
1) Dadas as variveis abaixo, resolva as expresses mistas A e B indicando o
resultado de cada uma:
int a=2;
int b=3;
int c=5;
int d = 1;
A) boolean e = (a+b*(c+d))<=(d*(b+c)/2)||(a+b-c)>(c+d);
B) boolean f = !((b*c/d)==(d*b+c)) && (c*d+a)!=(c+d);
2) O que o trecho a seguir exibir?
int a = 2;
int b = 3;
int c = 5;
int d = 1;
if((b*c/d)==(d*b+c)&&(c*d+a)!=(c+d)||(a+b)<=(c-d)) {
System.out.print("A");
} else if ((a+b*d)>(b+c/2)||(a-c)>(c+d)) {
System.out.print("B");
} else if ((a*b/2)<(d*c+8)|| !((c+d*4)<=12)) {
System.out.print("C");
} else {
System.out.print("D");
}
3) Quais as formas de criar a array bidimensional representada abaixo?

nomes
0
1
2
Paulo
Ana
Janaina
0
Maria
Marcelo
Jos
1
Pedro
Andr
Renato
2
Marcos
Mauro
Clia
3
4) Qual a principal diferena entre a programao estruturada e a programao

orientada a objeto?
5) correto afirmar que estruturas fundamentais da programao
estruturada, como laos de repetio, estruturas de seleo e manipulao
de arrays no fazem parte da programao orientada a objeto? Justifique
sua resposta.
6) Como se escreve em Java os operadores lgicos OU, E e NO?
7) Como se escreve em Java o operador relacional DIFERENTE?
8) Quando em uma expresso mista h expresso aritmtica, lgica e relacional,

qual a ordem de resoluo?
9) Como se escreve de forma reduzida as operaes abaixo:
a=a-8;
b=b*5;
c=c+1;
d=d-1;
e=e/8;
10) Dada a varivel b a seguir, converta seu valor para a varivel c do tipo byte
e para a varivel d do tipo short.
double b=12;
11) Dada a varivel g a seguir, converta seu valor para a varivel h do tipo
float e i do tipo long.
int g=6;
12) Crie uma array unidimensional e armazene nela o salrio de 3

funcionrios.
13) Crie uma array bidimensional para armazenar os dados representados
abaixo.
idades
0
1
60
23
0
78
50
1
14) Dado o algoritmo a seguir, na forma de pseudocdigo, escreva o programa

Java correspondente.
Algoritmo fatorial
var a, n, cont: inteiro
incio
n5;
a 1
cont1

enquanto (cont<=n) faa
a a* cont
cont cont +1

fim enquanto

imprima (a)
fim

Algoritmo soma
var a, n, cont : inteiro
incio
n 10
a0
para cont=1 at n passo 1
a a + cont
fim_para
imprima(a)
fim

Algoritmo nmeros
var n1,n2: inteiro
incio
leia (n1,n2)
se n1>n2
ento imprima ("o nmero", n1, " maior que", n2)
seno se n1=n2
ento imprima ("os nmeros so iguais")
seno imprima ("o nmero", n2, " maior que", n1)
fim_se
fim_se
fim
3. Orientao a objetos
conceitos bsicos
A orientao a objetos foi criada observando-se conceitos aplicados no diaa-dia das pessoas. Normalmente categorizamos, classificamos, relacionamos
e realizamos operaes sobre um incontvel nmero de informaes. Nosso
crebro est programado para classificar tudo baseado em nosso conjunto de
conhecimentos e valores.
Na programao orientada a objetos tudo comea com a categorizao ou
classificao de informaes agrupando-as em classes. As informaes de uma
determinada classe ou categoria esto sujeitas a um conjunto de operaes
criadas especificamente para atuar sobre elas. Vamos a um exemplo prtico.
Em uma empresa podemos classificar as pessoas como clientes, funcionrios e,
em alguns casos, fornecedores. Cada uma destas classes de pessoas possui um
conjunto de informaes que as identifica e/ou caracteriza. Estas informaes
so seus atributos.
Vamos focar, por exemplo, na classe dos funcionrios. O funcionrio possui
matrcula, nome, cargo, salrio etc. Sobre estas informaes, podem ser
realizadas um conjunto de operaes. Por exemplo, sobre o salrio pode ser
realizada uma operao de reajuste, uma operao de desconto de imposto
etc. Estas operaes, na orientao a objetos, so chamadas de mtodos. Deste
exemplo podemos obter alguns conceitos essenciais da orientao a objetos,
que so:
Classe: Funcionrio
Atributos: matrcula, nome, cargo, salrio.
Mtodos: reajuste, desconto de imposto.
No s pessoas podem ser categorizadas ou classificadas em uma empresa. Por
exemplo, podemos identificar a classe dos produtos que a empresa vende. Estes
produtos possuem cdigo, nome, medida, cor, preo etc. Sobre estas informaes
do produto podem ser realizadas operaes. Por exemplo, sobre o preo, podem
ser realizadas operaes de reajuste, desconto etc. Assim, podemos tirar deste
exemplo um conjunto de conceitos da orientao a objetos que so:
Classe: Produto
Atributos: cdigo, nome, medida, cor, preo.
Mtodos: reajuste, desconto.
Muito bem, conceitualmente simples. Mas como transformar isso em
programa de computador?
isso que veremos no prximo tpico deste Captulo.
3.1 Classes
Tirando a parte conceitual e abstrata, uma classe nada mais do que um
arquivo de programa Java que precisa possuir uma estrutura que atenda aos
padres da linguagem. Elas possuem identificao, a declarao dos atributos
ou informaes que manipulam, um ou mais construtores e operaes que
podem ser realizadas sobre estes atributos. Cada uma destas caractersticas
das classes ser apresentada a seguir.
3.1.1 Declarao da classe

Uma classe precisa ser identificada com o mesmo nome do arquivo criado
no projeto para a classe. Assim, se o arquivo criado for Funcionario.java, a
classe deve se chamar Funcionario. Neste caso, a declarao da classe ficaria
da seguinte forma:
public class Funcionario{
// Contedo da classe
}
NOTA
Veja que a palavra Funcionario no foi acentuada, pois no uma boa

prtica acentuar nomes de classes, j que a linguagem e seus padres,
apesar de aceitar acentos, foram criados em lngua inglesa, que no utiliza acentuao.
3.1.2 Declarao dos atributos

Aps declarar a classe voc pode declarar os atributos, caso haja necessidade.
Um atributo nada mais do que uma varivel especial que vai permitir
manipular uma informao daquela classe. Desta forma, a declarao de
atributos da classe Funcionario poderia ser:
public class Funcionario {

private int matricula;
private String cargo;
private double salario;
}
A palavra private, que define que o atributo s poder ser acessado
NOTA de dentro da prpria classe, ser explicada mais a frente, no prximo

Captulo, no tpico sobre modificadores de visibilidade.
3.1.3 Construtor
Construtor uma estrutura, semelhante a um mtodo ou funo, que permite
criar (ou instanciar) um objeto (varivel) da classe, j incluindo valores a serem
armazenados no objeto ou no.
Segundo Horstmann (2009, p. 369), construtores contm instrues para
inicializar os atributos de um objeto.
Se o construtor permitir o recebimento de parmetros, ento voc poder criar
um objeto (varivel) da classe e j armazenar as informaes nos atributos
desta classe em uma mesma operao. Veja um exemplo:
public Funcionario(int matricula, String nome, String cargo, double salario) {
this.matricula = matricula;
this.nome = nome;
this.cargo = cargo;
this.salario = salario;
}
Se o construtor no permitir o recebimento de parmetros, voc ter que

declarar o objeto da classe e, posteriormente, atravs dos mtodos iniciados
pela palavra set (setter), armazenar os valores nos atributos desta classe. Veja
um exemplo de construtor que no recebe parmetros:
public Funcionario() {
}
Voc deve observar que o construtor, obrigatoriamente, deve ter o mesmo nome
da classe. Pode haver diversos construtores em uma classe, desde que eles
recebam parmetros diferentes. O uso de vrios construtores em uma classe
chamado de sobrecarga de construtor.
NOTA
Se voc no escrever um construtor na classe, implicitamente o compilador vai entender que existe um construtor vazio que no recebe parmetros. Neste caso, apesar de parecer que a classe no tem construtor,
h sim um construtor implcito.
Apesar da semelhana com mtodo, o construtor no considerado um mtodo,

pois no possui tipo de retorno, nem mesmo void. Os mtodos necessitam da
declarao de um tipo de retorno, ao contrrio dos construtores.
3.1.4 Mtodos
Mtodos so semelhantes s funes utilizadas na programao estruturada,
porm, ao contrrio das funes, estaro sempre associados aos objetos da
classe e executaro operaes sobre os valores manipulados pela classe. So
trechos de cdigo em uma classe que podem ser chamados uma ou mais vezes
para realizar procedimentos especficos sobre os atributos da classe.
Os mtodos so recursos excelentes para viabilizar o reaproveitamento de
cdigo, uma vez que precisam ser digitados uma vez, mas podem ser chamados
quantas vezes forem necessrias.
Segundo Horstmann (2009. p. 63), um mtodo uma sequncia de instrues
que acessam os dados internos de um objeto.
Em uma classe Java normalmente existem trs categorias de mtodos: os
mtodos setter (que incluem valores nos atributos de um objeto); os mtodos
getter (que obtm valores armazenados nos atributos de um objeto); e mtodos
de uso geral, que executam operaes personalizadas e diversificadas sobre
os atributos da classe.
3.1.4.1 Sintaxe dos mtodos

Um mtodo tem a seguinte sintaxe:
modificadorVisibilidade tipoRetorno nomeMtodo (parmetros){
corpo do mtodo
}
Onde:
ModificadorVisibilidade: determina se o mtodo ter acesso pblico,
privado, protegido ou padro. Veremos detalhes sobre esses modificadores
no prximo captulo.
TipoRetorno: determina que tipo de valor o mtodo ir retornar. Um mtodo
pode retornar qualquer tipo de valor, seja simples, array, objeto etc. Caso
o mtodo no retorne valor deve ser escrito void neste local.
NomeMetodo: o nome do mtodo, seguindo as boas prticas de nomeao,

as mesmas utilizadas na nomeao de variveis.
Parmetros: so valores que o mtodo pode receber para cumprir seu papel.
Um mtodo pode receber qualquer tipo de valor como variveis simples,
array, objetos etc.
Corpo do mtodo: sempre entre chaves, o corpo do mtodo o local onde
as operaes as quais o mtodo se prope so realizadas. Caso exista um
tipo de retorno definido na declarao do mtodo, obrigatoriamente no
corpo do mtodo deve existir uma instruo return.
Vamos analisar alguns exemplos:

public void imprimirNome(String nome){
System.out.print(nome);
}
Veja que este mtodo recebe um nome (do tipo String), exibe este nome na
tela e no retorna nenhum valor (void).
public double calcularMedia(double nota1, double nota2){
return (nota1+nota2)/2;
}
Veja que este mtodo recebe duas notas do tipo double e retorna o resultado
do clculo da mdia entre elas, tambm do tipo double.
public double calcularMedia(){
return (8.0+5.0)/2;
}
Este mtodo no recebe nada como parmetro, mas devolve o resultado de um

clculo que um valor do tipo double.
public String verificarStatusAluno(double media){
if (media>=6){
return "Aprovado";
} else{
return "Reprovado";
}
}
Este mtodo recebe a mdia e retorna Aprovado, se for maior ou igual a 6,

ou Reprovado, se a mdia for menor que 6.
A linha de declarao de um mtodo com modificador de visibilidade, tipo de

retorno, nome do mtodo e parmetros chamada de assinatura do mtodo.
No mtodo acima, por exemplo, a assinatura do mtodo :
public String verificarStatusAluno(double media)
Quando se est desenvolvendo uma aplicao orientada a objetos, a assinatura

do mtodo a nica coisa que necessrio saber para se acessar um mtodo.
3.1.4.2 Mtodos getter e setter
H duas operaes padro que podem ser realizadas sobre os atributos da classe
por meio de um objeto desta classe: armazenar valor e obter o valor armazenado.
Mtodos destinados a armazenar valores nos atributos so conhecidos como
mtodos setter e aqueles que obtm os valores armazenados, so conhecidos
como mtodos getter.
3.1.4.2.1 Mtodos setter

Para armazenar valores nos atributos da classe, necessrio utilizar mtodos
normalmente iniciados pela palavra set. Estes mtodos so conhecidos como
mtodos setter. Por exemplo, para armazenar um nome no atributo nome da
classe pode ser utilizado o seguinte mtodo:
this.nome = nome;
}
Veja que este mtodo, chamado setNome, recebe um nome como parmetro
e transfere este nome para o atributo nome da classe (this.nome). H duas
variveis nome diferentes: a varivel local, que recebe o nome como parmetro;
e o atributo nome, privado da classe, antecedido pela instruo this, que recebe
o nome que chegou como parmetro.
NOTA
Normalmente, para cada atributo da classe haver um mtodo iniciado

pela palavra set e sucedido pelo nome do atributo com letra inicial
maiscula. Por exemplo, se houver um atributo cargo, haver um mtodo
setCargo; se houver um atributo telefone, haver um mtodo setTelefone
e assim por diante.
3.1.4.2.2 Mtodos getter

Para obter valores armazenados nos atributos de uma classe, utilizam-se mtodos
getter. Um mtodo getter iniciado pela palavra get e sucedido pelo nome do
mtodo com letra inicial maiscula. Quando chamado, um mtodo getter retorna
o valor armazenado no atributo referente a este mtodo. Veja o exemplo:

return this.nome;
}
NOTA
Normalmente, para cada atributo da classe haver um mtodo iniciado

pela palavra get e sucedido pelo nome do atributo com letra inicial
maiscula. Por exemplo, se houver um atributo cargo, haver um
mtodo getCargo; se houver um atributo telefone, haver um mtodo
getTelefone e assim por diante.
3.1.4.3 Outros mtodos

Alm dos mtodos setter e getter, voc poder criar tantos mtodos quanto
precisar para executar operaes com os valores manipulados pela classe.
Normalmente, so comuns mtodos para executar operaes matemticas
com valores contidos nos atributos, mas quaisquer outras operaes podero
ser realizadas.
3.1.5 Exemplo de classe com atributos,

construtor e mtodos
Este tpico apresenta uma classe padro para manipular dados de funcionrios,
contendo declarao da classe, declarao de atributos; construtores, mtodos
setter e getter e um mtodo para aumentar o salrio do funcionrio.
Para digitar esta classe, entre no NetBeans e crie um novo projeto Java, seguindo
as orientaes a seguir:
Clique no menu Arquivo e na opo Novo Projeto (ou pressione Ctrl
+ Shift + N).
Na diviso Categorias, selecione Java.
Na diviso Projetos, selecione Aplicao Java.
Clique no boto Prximo.
No campo Nome do Projeto, d um nome para a pasta onde ficar sua

aplicao. Pode ser qualquer nome vlido como nome de pasta.
No campo Localizao do Projeto, clique no boto Procurar e selecione
o local do disco onde voc deseja criar a pasta do projeto.
Desmarque a opo Criar Classe Principal, pois a classe que vamos
criar ser uma classe de apoio, no a classe de start da aplicao. A classe
principal ser criada mais a frente neste captulo.
Agora que o projeto est criado, vamos criar a classe Funcionario.java. Para
criar esta classe, siga os procedimentos a seguir:
Clique com o boto direito do mouse no nome da pasta do projeto, localizado
na diviso Projetos do canto superior esquerdo da tela, clique na opo
Novo e, em seguida, na opo Classe Java.
No campo Nome da Classe, digite Funcionario e clique no boto
Finalizar.
No uma boa prtica acentuar nomes de classes e variveis, por esse
NOTA motivo, o nome da classe Funcionario no deve ser acentuado.

Digite o cdigo-fonte abaixo, da classe Funcionario.java.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class Funcionario {

private int matricula;
private String cargo;
public Funcionario(int matricula, String nome,String cargo,double salario) {
this.nome = nome;
this.cargo = cargo;
}
public Funcionario() {
}
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
public int getMatricula() {

return matricula;
}
public void setMatricula(int matricula) {
}
return nome;
}
this.nome = nome;
}
public String getCargo() {
return cargo;
}
public void setCargo(String cargo) {
this.cargo = cargo;
}
public double getSalario() {
return salario;
}
public void setSalario(double salario) {
}
public void ajustarSalario(double percentual) {

this.salario = this.salario + this.salario * percentual / 100;
}
A linha 1 declara a classe com nome Funcionario. Veja que a chave aberta
nesta linha fechada apenas na linha 52.
Da linha 2 a 5 so declarados os atributos da classe, ou seja, as informaes que
se deseja manipular. Estes atributos no so nada mais que variveis privadas
da classe, ou seja, variveis que s podem ser acessadas do interior desta classe.
As linhas de 7 a 12 compem o construtor da classe que recebe como parmetros

as informaes a serem manipuladas nos atributos. J as linhas 14 e 15
compem outro construtor, s que este no recebe parmetros.
As linhas de 17 a 47 compem os mtodos (operaes) para inserir as
informaes nos atributos da classe e para obter as informaes que foram
inseridas nestes atributos. Mtodos cujos nomes so iniciados pela palavra set
inserem valores nos atributos. Mtodos cujos nomes so iniciados pela palavra
get obtm os valores inseridos nos atributos.
As linhas de 49 a 51 compem um mtodo para aumentar o valor do salrio
no percentual recebido como parmetro.
Calma!
No adianta compilar e executar esta classe que nada vai acontecer. Trata-se
de uma classe de apoio, que ser acessada de outras classes, sempre que se
desejar manipular dados de funcionrios. Para testarmos a classe Funcionario,
vamos criar nos tpicos seguintes uma classe principal (que possui o mtodo
main) no projeto por meio da qual manipularemos os dados de um funcionrio.
3.1.6 Diagrama UML para representar uma classe

Para modelar sistemas desenvolvidos utilizando linguagens orientadas a objetos
comum e popular a utilizao da linguagem Unified Modeling Language (UML). A
UML apresenta a notao para um conjunto de diagramas que podem representar
a maioria dos aspectos relevantes para o desenvolvimento do sistema. Um dos
diagramas que a UML permite desenvolver o diagrama de classes que nada mais
do que um desenho da classe usando uma notao especfica. Veja a seguir o
diagrama de classe da classe Funcionario.java desenvolvida nos tpicos anteriores.
Funcionario
- matricula: int
- nome: String
- cargo: String
- salario: double
+ setMatricula (matricula):void
+ setNome (nome): void
+ setCargo (cargo): void
+ setSalario(salario): void
+ getMatricula(): int
+ getNome(): String
+ getCargo(): String
+ getSalario(): double
+ ajustarSalario(double percentual): void
O diagrama de classes dividido em trs clulas contendo, de cima para baixo,

o nome da classe, os atributos e os mtodos. O sinal de menos (-) indica que
os atributos so privados (private) e o sinal de mais (+), indica que os mtodos
so pblicos (public). O significado das instrues public e private ser visto
em detalhes no prximo Captulo.
Nos diagramas de classe, a representao dos mtodos setter e getter, apesar
de poder existir, no so necessrias.
NOTA
A ideia do diagrama de classes desenhar a classe antes do seu desenvolvimento. Normalmente a equipe de anlise e/ou projeto desenha as classes
e entrega aos programadores para que eles a implementem na linguagem
de programao orientada a objeto definida para o projeto.
3.1.7 Boas prticas para nomeao de classes

Existem boas prticas para nomeao de classes utilizadas pela comunidade
de desenvolvedores, dentre elas:
Para nomes com apenas uma palavra, iniciar o nome da classe sempre em
letra maiscula, escrevendo o restante do nome em letra minscula. Veja
exemplos de nomes vlidos: Cliente, Produto, Conta.
Para nomes compostos de mais de uma palavra, iniciar cada palavra com
letra maiscula e digitar o restante em letra minscula. No deixar espaos
ou usar caracteres especiais como underline (_) entre as palavras. Veja
exemplos de nomes vlidos: ControleClientes, ContaCorrente.
No utilizar acentos ou caracteres especiais no nome de classes.
NOTA
Se voc no adotar as boas prticas de nomeao, no ocorrer erro, porm, sua aplicao no ser bem vista entre desenvolvedores profissionais. As boas prticas representam recomendaes adotadas como padro
atualmente e recomendadas pelos desenvolvedores da linguagem.
3.2 Pacotes
Pacotes so contineres (ou pastas) que se cria em um projeto para agrupar
classes que possuem alguma caracterstica comum ou afinidade.
Horstmann (2009, p. 339), afirma que um pacote um conjunto de classes
relacionadas.
Por exemplo, em um projeto, pode-se criar um pacote para agrupar as classes
que implementam o mdulo de controle de funcionrios, um pacote para
agrupar classes que implementam o mdulo de clientes, e assim por diante.
No NetBeans, para criar um pacote no projeto utiliza-se o seguinte procedimento:

Clica-se com o boto direito do mouse sobre o nome do projeto, na diviso
Projetos do canto superior esquerdo da tela, seleciona-se a opo Novo
e, em seguida, a opo Pacote Java.
Na janela que aparece, no campo Nome do pacote, digite um nome para
o pacote, todo em letra minscula (que representa uma boa prtica), apesar
de serem permitidas letras maisculas.
Para criar classes no pacote criado, utilize o procedimento a seguir:
Clique com o boto direito do mouse sobre o nome do pacote e selecione

a opo Novo e Classe Java.
Na janela que aparece, no campo Nome da Classe, digite o nome desejado
para a classe, com letra inicial maiscula (que uma boa prtica), e clique
no boto Finalizar.
A Figura 3.1 mostra a tela que aparece no processo de criao da classe no
pacote:
Figura 3.1: Criao de classes em um pacote Java.
A primeira linha de cdigo da classe que est no pacote requer o comando

package seguido do nome do pacote. Veja o exemplo:
package rh;
public classe Funcionrio{
}
Neste caso, a classe Funcionario.java foi criada no pacote rh.
NOTA
Para representar os pacotes de uma aplicao pode ser utilizado o diagrama de pacotes da UML. Se voc quiser saber mais sobre o diagrama de
pacotes, visite o link a seguir: <http://www.uml-diagrams.org/package-diagrams-overview.html>.
3.2.1 Boas prticas para nomeao de pacotes

Apesar de no ocorrer erro, existem boas prticas utilizadas pela comunidade
de desenvolvedores para nomear pacotes, dentre elas esto:
Utilizar todo o nome do pacote em letras minsculas. Por exemplo: controle.
Se o nome do pacote tiver mais que uma palavra, utilizar ponto final para
separar as palavras. Por exemplo: cadastro.clientes
3.2.2 Como utilizar pacotes das bibliotecas Java

Quando voc instala o Java no computador, as classes das bibliotecas da
linguagem vm agrupadas APIs que contm pacotes. Por exemplo, o pacote
java.swing (que ser estudado no Captulo 6) possui as classes JFrame,
JOptionPane, JLabel, JTextField etc. J o pacote java.util possui as classes
Date, Scanner etc.
Se voc desejar utilizar uma destas classes na classe que est escrevendo, ter
que importar a classe do pacote correspondente, digitando, antes da declarao
da classe, a instruo import. Veja o Exemplo:
public class Teste{
public static void main (String[] args){
JOptionPane.showMessageDialog(null, "Ol!");
}
}
Para importar todas as classes de um pacote de uma s vez, pode-se utilizar o

asterisco. Veja o exemplo a seguir:
import javax.swing.*;
Esta instruo permite utilizar na classe que voc est escrevendo qualquer
classe que esteja no pacote javax.swing.
3.3 Objetos
A classe Funcionario.java que voc criou no tpico anterior, uma classe
que permite manipular no projeto criado um novo tipo de dado, um tipo
Funcionario.
isso mesmo, agora voc pode criar variveis do tipo Funcionario sempre que
desejar armazenar informaes de funcionrios e manipular estas informaes.
String, por exemplo, um tipo de dado porque h uma classe chamada String.
java. Da mesma forma, Funcionario um tipo de dado porque existe a classe
Funcionario.java.
As variveis que criamos das classes so chamadas objetos. Assim, uma

varivel do tipo String um objeto, assim como uma varivel do tipo
Funcionario tambm um objeto.
Objeto pode ser definido como uma varivel de um tipo classe que permite
manipular informaes nos atributos desta classe atravs de seus mtodos.
Horstmann (2009. p. 63), afirma que objetos so entidades no programa que
voc manipula invocando mtodos.
Ento, pode-se concluir que objetos so variveis de um tipo de referncia a
uma classe.
3.3.1 Instncia de objetos

Uma instncia de um objeto a alocao de espao na memria para
armazenar e manipular dados neste objeto. Basicamente a gerao do
objeto na memria. Lembre-se que um objeto uma varivel criada a partir da
existncia de uma classe para esta finalidade. Para instanciar um objeto de uma
classe necessrio chamar o construtor da classe. Por exemplo, para instanciar
(ou criar) objetos do tipo da classe Funcionario, criada anteriormente,
necessrio chamar um dos construtores da classe Funcionario.java, a partir
do interior de outra classe que deseja manipular dados de funcionrios.
Neste projeto, vamos criar uma classe principal chamada Teste.java a partir
da qual vamos manipular os dados de funcionrios por meio de objetos da
classe Funcionario.java.
Para criar a classe principal Teste.java, siga as instrues a seguir:
Clique com o boto direito do mouse no nome da pasta do projeto, localizado
na diviso Projetos do canto superior esquerdo da tela, clique na opo
Novo e, em seguida, na opo Classe Java.
No campo Nome da Classe, digite Teste e clique no boto Finalizar.
A classe Teste.java ser criada com a estrutura bsica a seguir:

public class Teste {
}
Neste ponto voc deve ter no projeto a classe Funcionario.java e Teste.java,

como mostra a Figura 3.2 a seguir:
Figura 3.2: ProjetoTeste com suas classes.
3.3.1.1 Instncia de objetos utilizando

construtor vazio
A classe Funcionario.java foi criada com dois construtores: um vazio, que no
recebe parmetros, e um que recebe como parmetro os dados que se deseja
manipular.
No interior do mtodo main da classe Teste.java, vamos instanciar um objeto
chamado func da classe Funcionario.java, por meio de uma chamada ao
construtor que no recebe parmetros. A instruo dever ser a seguinte:
Funcionario func = new Funcionario();
}
}
Se preferir, pode declarar o objeto func primeiro para depois instanci-lo, da

seguinte forma:
Funcionario func;
func = new Funcionario();
Veja na Figura 3.3 que a instruo new Funcionrio() chama o construtor vazio
da classe Funcionario.java.
Figura 3.3: Chamada ao construtor de uma classe.
A instruo mostrada na Figura 3.3 instancia na memria o objeto chamado

func, com os atributos vazios, j que a criao foi feita por uma chamada
ao construtor da classe que no recebe parmetros. O objeto func pode ser
representado, apenas para fins didticos, como mostra a Figura 3.4.
func
matricula
nome
cargo
salario
0
Null
Null
0.0
setMatricula(int matricula): void
getMatricula(): int
setNome(String nome): void
getNome(): String
setCargo(String cargo): void
getCargo(): String
setSalario(double salario): void
getSalario(): double
ajustarSalario(double
percentual):void
Figura 3.4: Criao de um objeto vazio.
Veja que o objeto func agrega um conjunto de atributos e as operaes que

podem ser realizadas sobre estes atributos.
Como o objeto foi instanciado vazio por meio do construtor que no recebe
parmetros, para armazenar (setar) valores no objeto deve-se chamar os
mtodos setter da seguinte forma:

func.setMatricula(67543);
func.setNome("Angela Cristina");
func.setCargo("Analista");
func.setSalario(24567.98);
}
}
A chamada ao mtodo setMatricula inclui o valor 67543 no atributo matricula;

a chamada ao mtodo setNome, inclui o nome Angela Cristina no atributo
nome; a chamada ao mtodo setCargo, inclui o cargo Analista no atributo
cargo; e a chamada ao mtodo setSalario, inclui o salario 24567.98 no atributo
salario.
Estas operaes (setter) deixaro o objeto func da forma mostrada na Figura 3.5:
67543
Angela Cristina
Analista
24567.98
getMatricula(): int
getNome(): String
getCargo(): String
ajustarSalario(double percentual): void
Figura 3.5: Objeto preenchido por meio dos mtodos setter.
Aps instanciar o objeto func e armazenar valores em seus atributos, se

voc deseja mostrar, por exemplo, o contedo dos atributos do objeto ser
necessrio obter o contedo de cada atributo e exibir na tela. Para obter
o contedo armazenado nos atributos, utilizam-se os mtodos getter, das
seguintes formas:

System.out.println(func.getMatricula());
System.out.println(func.getNome());
System.out.println(func.getCargo());
System.out.println(func.getSalario());
}
}
Note que para obter o valor da matrcula armazenado no atributo matricula foi
utilizada a instruo func.getMatricula(). A instruo System.out.println exibe
na tela o valor obtido do atributo. Para obter os valores contidos nos demais
atributos, foram chamados os mtodos getter destes atributos. A Figura 3.6
ilustra o uso dos mtodos getter.
67543
Angela Cristina
Analista
24567.98
getMatricula(): int
getNome(): String
getCargo(): String
ajustarSalario(double percentual): void
Figura 3.6: Obtendo valores dos atributos.
Uma vez que um objeto instanciado, para acessar qualquer mtodo contido
na classe referente ao objeto, deve-se digitar o nome do objeto, o ponto final
e o mtodo que se deseja acessar. Pode-se concluir ento, at aqui, que:
O acesso aos mtodos de uma classe ocorre por meio de um objeto instanciado
desta classe.
3.3.1.2 Instncia de objetos utilizando

construtor parametrizado
Se voc quiser instnciar o objeto func por meio de uma chamada ao construtor
que recebe parmetros, deve fazer da seguinte forma:
Funcionario func = new Funcionario(1367, "Paulo Henrique", "Gerente", 789.56);
}
}
Se preferir, poder primeiro declarar o objeto para depois instanci-lo, da

seguinte forma:
Funcionario func;
func = new Funcionario(1367, "Paulo Henrique", "Gerente", 789.56);
}
}
Veja na Figura 3.7 que a instruo new Funcionario chamou o construtor da

classe Funcionario.java passando as informaes que se deseja armazenar no
objeto como parmetro.
Figura 3.7: Passagem de parmetros ao construtor de uma classe.
Veja na Figura 3.8 a representao do objeto func na memria aps a execuo

da instruo acima:
func
matricula
nome
cargo
salario
1367
Paulo Henrique
Gerente
789.56
getMatricula(): int
getNome(): String
getCargo(): String
percentual):void
Figura 3.8: Objeto preenchido por meio dos mtodos setter.
Na instncia do objeto, os valores passados como parmetro j foram armazenados no objeto func, sem a necessidade de chamar os mtodos setter.
Para obter os valores contidos nos atributos do objeto func, chamam-se os
mtodos getter, como mostra o exemplo a seguir.
Funcionario func = new Funcionario(1367, "Paulo Henrique", "Gerente",
789.56);
System.out.println(func.getMatricula());
System.out.println(func.getNome());
System.out.println(func.getCargo());
System.out.println(func.getSalario());
}
}
NOTA
Quando voc instancia um objeto feita a chamada a um dos construtores

da classe. Neste momento, todas as instrues que estiverem no corpo do
construtor, ou seja, dentro das chaves, sero executadas.
3.3.1.3 Instncia de vrios objetos

Um objeto uma instncia de uma classe, ou varivel de uma classe. Assim
como qualquer outro tipo de varivel, o objeto necessita de uma maneira
especial para ser manipulado, como voc deve ter percebido. Para armazenar
valores, voc precisa chamar os mtodos setter e para obter os valores
armazenados, precisa chamar os mtodos getter.
A nomeao de objetos segue as mesmas regras e boas prticas da nomeao

de variveis comuns. Da mesma forma, possvel ter vrios objetos diferentes
da mesma classe, assim como possvel ter diversas variveis diferentes de
um mesmo tipo. Veja o exemplo abaixo da classe Teste.java.

Funcionario func1 = new Funcionario(1367, "Paulo Henrique", "Gerente", 789.56);
Funcionario func2 = new Funcionario(2567, "Maria Paula", "Vendedora", 1675.55);
Funcionario func3 = new Funcionario(9634, "Ana Luiza", "Analista", 2765.23);
}
}
Veja que foram instanciados (criados) trs objetos: func1, func2, func3. Cada
objeto uma instncia da classe Funcionario.java. Em cada objeto, os atributos
matricula, nome, cargo e salario receberam valores diferentes. Se voc desejar
exibir uma informao contida no atributo de um objeto, deve primeiro obter
o valor do atributo, por meio do mtodo getter correspondente, para depois
exibir o valor obtido. Por exemplo:
System.ou.println(func2.getNome());
Esta instruo exibir o nome armazenado no atributo nome do objeto func2,

ou seja, Maria Paula. Se voc quiser exibir o nome Paulo Henrique, que
est no atributo nome do objeto func1, ter que digitar:
System.ou.println(func1.getNome());
Se voc desejar, para cada funcionrio, poder instanciar um objeto diferente

e manipular os dados nele por meio dos mtodos getter e setter.
Mas e se desejar cadastrar 200 funcionrios, ter que instanciar 200 objetos?
No. Nesse caso, voc ter que usar um banco de dados e apenas um objeto.
Voc ter que armazenar os dados do primeiro funcionrio no objeto, enviar
o objeto para a tabela do banco de dados, armazenar os dados do segundo
funcionrio no mesmo objeto, enviar o objeto para a tabela do banco de dados,
e assim por diante. Isso ser visto no Captulo 7 deste livro. Como um objeto
varivel, voc poder substituir o contedo dele quantas vezes quiser, bastando
chamar os mtodos setter. Veja o exemplo a seguir:
Funcionario func = new Funcionario(1367, "Paulo Henrique", "Gerente", 789.56);
Note que o objeto func foi instanciado com os seguintes valores:

matricula
nome
cargo
salario
1367
Paulo Henrique
Gerente
789.56
Em seguida, estes valores foram alterados, por meio de chamadas aos mtodos
setter, para:
matricula
nome
cargo
salario
NOTA
67543
Angela Cristina
Analista
24567.98
Voc pode alterar os valores de um objeto quantas vezes desejar, bastando, para isso, chamar os mtodos setter a partir deste objeto e passar outros valores para seus atributos.
3.3.1.4 Acesso aos mtodos

Para acessar os mtodos pblicos de uma classe, necessrio, antes, instanciar
um objeto desta classe. A instncia de um objeto ocorre por meio da chamada
ao construtor da classe da qual se quer criar o objeto.
Aps a instncia, possvel chamar os mtodos pblicos da classe, sejam os
mtodos setter, que incluem valores nos atributos do objeto; sejam os getter,
que obtm os valores armazenados nos atributos do objeto; ou outros mtodos
que atuam sobre os valores dos atributos.
Chamar os mtodos setter e getter voc j aprendeu nos tpicos anteriores.
Mas e para chamar outros mtodos?
A forma a mesma.
Veja o exemplo do mtodo ajustarSalario da classe Funcionario.java
apresentada anteriormente. Este mtodo recebe um percentual no qual o salrio
dever ser aumentado e aplica este percentual sobre o valor contido no atributo
salario, modificando-o.
Veja como feito na classe principal Teste.Java o acesso ao mtodo

ajustarSalario:

func.ajustarSalario(10);
}
}
Observe que o mtodo ajustarSalario chamado por meio do objeto func,

passando como parmetro o valor 10, que o percentual no qual se deseja
aumentar o salrio. Na classe Funcionario.java o valor passado como parmetro
recebido pelo mtodo e aplicado sobre o valor do atributo salario alterando-o.
Assim, o objeto func, que tinha o valor 789.56 no atributo salario, passar a
ter o valor 868.516.
A Figura 3.9 mostra como ficou a representao do objeto func.
func
matricula
nome
cargo
salario
1367
Paulo Henrique
Gerente
868.516
getMatricula(): int
getNome(): String
getCargo(): String
percentual):void
Figura 3.9: Objeto aps modificao de valores nos atributos.
Caso voc deseje visualizar o novo valor contido no atributo salario, basta
digitar a instruo System.out.print(func.getSalario()); aps a chamada ao
mtodo na classe Teste.java.
3.4 Encapsulamento
Quando voc instancia um objeto de uma classe voc encapsula os atributos
privados da classe no objeto, de forma que possam ser acessados somente por
mtodos pblicos. Dessa forma, podemos ver um objeto como uma cpsula.
Segundo Horstmann (2009, p. 112), o encapsulamento o processo de ocultar

dados contidos em um objeto e fornecer mtodos para acessar estes dados.
Um exemplo de uso do encapsulamento ocorre quando inserimos ou
consultamos valores nos atributos de um objeto. Para inserir valores nos
atributos privados necessrio chamar os mtodos setter pblicos e para
obter os dados presentes nos atributos, necessrio chamar os mtodos
getter pblicos. Nesse caso particular, os atributos no podem ser acessados
diretamente de fora da classe, pois so privados. Desta forma so necessrios
mtodos pblicos para acess-los.
3.5 Criao de objetos com entradas do usurio

At agora voc criou a classe Funcionario.java e a classe principal Teste.java
em um projeto do NetBeans. Na classe Teste.java, instanciou um objeto func
da classe Funcionario.java e manipulou dados neste objeto diretamente.
Mas como fazer para armazenar no objeto informaes inseridas pelo usurio?
Nesse caso, necessrio utilizar comandos de entrada e armazenar estas
entradas no objeto.
Estas entradas podem ser feitas pelo prompt de comando, utilizando recursos
da classe Scanner (contida no pacote java.util) ou por uma interface grfica,
utilizando a classe JOptionPane (contida no pacote javax.swing). Os dois
tpicos a seguir apresentam um exemplo de uso destas classes.
H outras classes no pacote javax.swing que permitem a entrada de da-
NOTA dos do usurio utilizando interface grfica, por meio de formulrio. A

utilizaro destas classes ser explicada no Captulo 6.
3.5.1 Entradas do usurio com a classe Scanner

A classe Scanner, presente no pacote java.util, permite a entrada de
dados via prompt de comando. Para que estas entradas possam ocorrer,
necessrio criar um objeto desta classe e, por meio dele, acessar os mtodos
de entrada. O mtodo nextInt utilizado para entrada de valores inteiros;
nextLine, para entrada de valores String; e nextDouble, para entradas de
valores double.
Veja a seguir o exemplo usando a classe Scanner:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
import java.util.Scanner;
Scanner ler;
Funcionario func;
ler= new Scanner(System.in);
System.out.println("Informe a matrcula:");
func.setMatricula(ler.nextInt());
ler.nextLine();
System.out.println("Informe o nome:");
func.setNome(ler.nextLine());
System.out.println("Informe o cargo:");
func.setCargo(ler.nextLine());
System.out.println("Informe o valor do salrio:");
func.setSalario(ler.nextDouble());
System.out.print("\n");
System.out.println("Matrcula:" + func.getMatricula());
System.out.println("Nome:" + func.getNome());
System.out.println("Cargo:" + func.getCargo());
System.out.println("Salrio:" + func.getSalario());
func.ajustarSalario(10);
System.out.println("Salrio reajustado:" + func.getSalario());
System.out.print("\n");
}
}
A linha 4 declara um objeto chamado ler da classe Scanner, necessrio para

acessar os mtodos de entrada de dados. A linha 6 instancia o objeto.
A linha 5 declara um objeto func da classe Funcionario.java. A linha 7 instancia
o objeto. As linhas 9, 12, 14 e 16, aguardam a entrada dos dados do funcionrio,
por meio de chamadas de mtodos da classe Scanner para esta finalidade.
Note que antes de cada pedido exibida uma mensagem solicitando o dado
a ser digitado (linhas 8, 11, 13 e 15). Os dados digitados em cada entrada
so passados como parmetro aos mtodos setter correspondentes da classe
Funcionario.java.
A linha 17 apenas quebra uma linha por meio da impresso do caracter \n.
As linhas de 18 a 21 exibem na tela o contedo dos atributos do objeto func da
classe Funcionario.java. Note que para obter os dados armazenados no objeto
foram feitas chamadas aos mtodos getter. O sinal de mais (+) em cada linha
concatena um rtulo String ao contedo obtido do atributo do objeto.
A linha 22 chama o mtodo ajustarSalario e passa o valor 10, que se refere
ao percentual no qual se quer aumentar o salrio. Este mtodo recebe o valor
como parmetro e aumenta o salrio trocando o valor do atributo salario pelo
valor reajustado.
A linha 23 obtm o salrio reajustado por meio de uma chamada ao mtodo
getSalario da classe Funcionario.java e exibe na tela.
Observe na classe apresentada que para cada informao que se deseja pedir
ao usurio, so usadas duas linhas, uma para exibir o pedido da informao,
e outra para receber a informao e armazenar no atributo do objeto func da
classe Funcionario.java. Veja por exemplo a entrada da matrcula (linhas 8 e 9):
System.out.println("Informe a matrcula:");
func.setMatricula(ler.nextInt());
Note que ler.nextInt() aguarda a digitao de um valor inteiro. O valor digitado

passado automaticamente como parmetro para o mtodo setMatricula da classe Funcionario.java, armazenando este valor no atributo matricula.
Aps compilar e executar a classe Teste.java por meio do pressionamento da tecla
F6, e fornecer os dados solicitados, ser exibida a tela mostrada na Figura 3.10:
Figura 3.10: Saida da execuo da classe Teste.java.
NOTA
O mtodo nextDouble da classe Scanner requer a digitao de um valor double utilizando vrgula para separar casas decimais, caso seja
necessrio.
3.5.2 Entradas do usurio com a classe

JOptionPane
A classe JOptionPane do pacote javax.swing utilizada para gerar na tela janelas

pop-up para receber e exibir dados. O mtodo showInputDialog desta classe
gera janelas pop-up para entrada de dados. J o mtodo showMessageDialog
gera uma janela pop-up apenas para exibir dados.
Veja a seguir o exemplo com entrada por interface grfica usando a classe
JOptionPane.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
Funcionario func;
func.setMatricula(Integer.parseInt(JOptionPane.showInputDialog("Digite a
matrcula: ")));
func.setNome(JOptionPane.showInputDialog("Digite o nome: "));
func.setCargo(JOptionPane.showInputDialog("Digite o cargo: "));
func.setSalario(Double.parseDouble(JOptionPane.showInputDialog("Digite o
salrio: ")));
JOptionPane.showMessageDialog(null,
"Matrcula:" + func.getMatricula() + "\n"
+ "Nome:" + func.getNome() + "\n"
+ "Cargo:" + func.getCargo() + "\n"
+ "Salrio:" + func.getSalario() + "\n");
func.ajustarSalario(Integer.parseInt(JOptionPane.showInputDialog("Digite o
percentual de reajuste para o salrio: ")));
JOptionPane.showMessageDialog(null, "Salrio reajustado: " + func.
getSalario());
}
}
A linha 4 declara o objeto func da classe Funcionario.java e a linha 5 instancia

este objeto. As linhas de 6 a 9 pedem ao usurio a digitao dos dados dos
funcionrios e passam estes dados para os mtodos setter correspondentes
da classe Funcionario.java. A linha 10 exibe em uma nica janela pop-up os
dados contidos no objeto func, por meio de chamadas aos mtodos getter da
classe Funcionario.java. Note que o caracter \n serve para quebrar linha na

janela pop-up que exibe os dados.
A linha 11 pede o percentual de reajuste do salrio do funcionrio e passa como
parmetro para o mtodo ajustarSalario da classe Funcionario.java, que altera
o valor contido no atributo salario para o valor do salrio reajustado. A linha
12 exibe o contedo do atributo salario (que contm o salrio reajustado),
por meio de uma chamada ao mtodo getSalario da classe Funcionario.java.
Observe que a entrada de dados ocorrer por meio de janelas pop-up geradas
pelo mtodo showInputDialog da classe JOptionPane. Estas janelas aparecero
uma por uma, ao compilar e executar a classe utilizando a tecla F6. Veja na
Figura 3.11 como sero estas janelas:
Figura 3.11: Janelas pop-up para entrada de dados de usurio.
Aps a digitao dos dados, o mtodo showMessageDialog da classe

JOptionPane exibir uma janela pop-up com os dados que foram armazenados
no objeto func da classe Funcionario.java (linha 10).
Veja na Figura 3.12 como os dados sero exibidos na tela:
Figura 3.12: Exibio de dados em uma janela pop-up.
Aps a exibio dos dados aparecer a janela pop-up mostrada na Figura 3.13,
para a digitao do percentual de aumento do salrio (linha 11).
Figura 3.13: Entrada do percentual de aumento do salrio em uma janela pop-up.
Aps a digitao do percentual, por exemplo, o valor 10, aparecer a janela

pop-up mostrada na Figura 3.14, que exibe o salrio reajustado (linha 12).
Figura 3.14: Janela pop-up para exibio do salrio reajustado.
NOTA
Todo valor digitado em campos de entrada, no Java e na maioria das linguagens, considerado um valor do tipo String, mesmo que a entrada seja
um nmero. Por esse motivo, se voc quer manipular o valor que entrou
como um valor numrico, deve fazer a converso para o tipo numrico do
seu interesse. As operaes de converso de tipo String para tipos numricos chamada parse. Assim, veja algumas formas de converso:
byte idade=Byte.parseInt(JOptionPane.showInputDialog(Digite a idade: );
short idade=Short.parseShort(JOptionPane.showInputDialog(Digite a idade:);
int idade=Integer.parseInt(JOptionPane.showInputDialog(Digite a idade: );
long idade=Long.parseLong(JOptionPane.showInputDialog(Digite a idade: );
float salario=Float.parseFloat(JOptionPane.showInputDialog(Digite o salrio:);
double salario=Double.parseDouble(JOptionPane.showInputDialog(Digite
o salrio:);
3.5.3 Comandos encadeados

Em Java comum digitar em uma nica linha diversos comandos aninhados,
que poderiam ser desmembrados em diversas linhas, uma para cada operao.
Para quem est iniciando o aprendizado do Java, pode ser difcil lidar com
comandos aninhados.
Vamos analisar, por exemplo, a linha abaixo, apresentada na classe Teste.java,
do tpico anterior:
func.setMatricula(Integer.parseInt(JOptionPane.showInputDialog("Digite a matrcula: ")));
H, nesta linha, trs operaes:

Solicitao do valor da matrcula por meio do comando JOptionPane.
showInputDialog.
Converso do valor digitado para a matrcula de String para int, por meio
do comando Integer.parseInt.
Passagem do valor convertido para inteiro para o mtodo setMatricula, para
ser includo no atributo matricula do objeto func.
A linha apresentada pode ser desmembrada em trs, uma para cada operao,
da seguinte forma:
String m = JOptionPane.showInputDialog("Digite a matrcula: ");
int mat = Integer.parseInt(m);
func.setMatricula(mat);
Que tal, gostou desta forma?

Vejamos outras linhas que digitamos em exemplos anteriores:
func.setSalario(ler.nextDouble());
Veja que so executadas duas operaes na linha acima:

Entrada de um valor double.
Passagem do valor double digitado para o mtodo setSalario, para ser
armazenado no atributo salario do objeto func.
Esta linha poderia ser desmembrada em duas, da seguinte forma:
double valor = ler.nextDouble();
func.setSalario(valor);
DICA
Procure ver nas linhas com instrues aninhadas as diversas operaes

que esto sendo realizadas e procure desmembr-las em uma instruo
para cada operao. Vai facilitar o seu aprendizado.
3.6 Classes sem atributos
Pode parecer, devido explicao da aplicao desenvolvida nos tpicos

anteriores com as classes Teste.java e Funcionario.java, que toda classe
precisa ter atributo, o que no verdade. Voc pode criar classes apenas para
concentrar mtodos que precisa utilizar com frequncia na aplicao. Sempre
que precisar utilizar estes mtodos, basta instanciar um objeto da classe e
chamar o mtodo adequado.
Veja o exemplo a seguir onde ser criada a classe Calculo.java para concentrar
mtodos que executam operaes aritmticas. Ser criada tambm uma classe
Teste.java, de onde estes mtodos sero chamados.
Para digitar os cdigos-fonte que sero apresentados, execute os procedimentos
a seguir:
Crie um projeto chamado ProjetoTeste.
Crie um pacote chamado app.
Cria, dentro do pacote app, as classes Calculo.java e Teste.java.
Aps a realizao dos procedimentos acima, a pasta do projeto deve estar
como mostra a Figura 3.15:
Figura 3.15: Criao do Projeto ProjetoTeste no NetBeans.
Na classe Calculo.java, digite o seguinte cdigo-fonte:

package app;
public class Calculo {
public Calculo(){
}
public double media(double valor1, double valor2) {
return (valor1 + valor2) / 2;
}
public double media(double valor1, double valor2, double valor3) {
return (valor1 + valor2 + valor3) / 3;
}
public int soma(int valor1, int valor2) {
return (valor1 + valor2);
}
public double soma(int valor1, int valor2, double valor3) {
return (valor1 + valor2 + valor3);
}
public double raizQuadrada(int valor) {
return (Math.sqrt(valor));
}
}
Note que h dois mtodos chamados media, um que recebe dois valores double,
calcula a mdia entre estes valores e retorna o resultado como double e um
que recebe trs valores double, calcula a mdia entre estes valores e retorna o
resultado como double.
H tambm dois mtodos chamados soma, um que recebe dois valores inteiros,
soma estes valores e retorna o resultado como int e um que recebe dois valores
inteiros e um valor double, soma estes valores e retorna o resultado como
double.
O mtodo chamado raizQuadrada recebe um valor int, calcula a raiz quadrada
deste valor e retorna o resultado como double. Para calcular a raiz quadrada foi
utilizado o mtodo sqrt da classe Math, instalada com o Java. A classe Math
permite realizar diversos tipos de operaes matemticas e trigonomtricas.
Perceba que h mais de um mtodo com o mesmo nome na classe, porm, estes
mtodos de mesmo nome recebem parmetros diferentes. Isto chamado na
orientao a objetos de sobrecarga de mtodos.
O diagrama de classes da UML para a classe acima mostrado na Figura 3.16.
Calculo
+ media(double valor1, double valor2): double
+ media(double valor1, double valor2, double valor3) : double
+ soma(int valor1, int valor2): int
+ soma(int valor1, int valor2, double valor3): double
+ raizQuadrada(int valor): double
Figura 3.16: Diagrama de classes mostrando a classe Calculo.
Observe que a diviso destinada aos atributos est vazia, j que a classe no
possui atributos.
Para interagir com a classe Calculo.java, chamando seus mtodos, digite na

classe principal, Teste.java, o seguinte cdigo-fonte:
package app;
Calculo calc = new Calculo();
double med1 = calc.media(10.5, 13.6);
double med2 = calc.media(10.5, 13.6, 45.6);
int soma1 = calc.soma(14, 34);
double soma2 = calc.soma(14, 34, 56.7);
double r = calc.raizQuadrada(16);
System.out.println(med1);
System.out.println(med2);
System.out.println(soma1);
System.out.println(soma2);
System.out.println(r);
}
}
Veja que um objeto chamado calc, da classe Calculo.java foi instanciado,

para poder acessar os mtodos da classe. Por meio deste objeto so chamados
os mtodos e so passados os parmetros que os mtodos requerem. O valor
resultante retornado dos mtodos armazenado em variveis. Note que se
o mtodo retorna um valor do tipo double, a varivel que recebe o retorno
tambm deve ser do tipo double. Note tambm que como h mais de um mtodo
com o mesmo nome, o compilador sabe qual deles est sendo chamado pelos
parmetros que so passados. Por exemplo, se forem passados para o mtodo
soma dois valores inteiros e um valor real, ser chamado o mtodo soma que
est esperando dois valores int e um double.
As instrues System.out.println exibem o contedo de cada varivel que
recebeu valor dos mtodos.
Ao compilar e executar o projeto, por meio do pressionamento da tecla F6,

ser exibido na tela os valores a seguir, resultantes da chamada aos mtodos:
12.05
23.233333333333334
48
104.7
4.0
O cdigo-fonte da classe Teste.java tambm poderia ser escrito da forma

apresentada a seguir, sem alterar o resultado apresentado:
package app;
System.out.println(calc.media(10.5, 13.6));
System.out.println(calc.media(10.5, 13.6, 45.6));
System.out.println(calc.soma(14, 34));
System.out.println(calc.soma(14, 34, 56.7));
System.out.println(calc.raizQuadrada(16));
}
}
Note que, neste caso, so usadas operaes aninhadas que chamam os mtodos,
passam os parmetros e j exibem os valores retornados, poupando a criao
de variveis.
Como voc deve ter percebido, pode criar uma classe apenas com mtodos de
apoio para operaes que ir utilizar na aplicao.
3.7 Array de objetos

Neste tpico vamos misturar o o uso de arrays visto no captulo 2, com
orientao a objetos. Vamos criar uma array unidimensional e armazenar trs
objetos da classe Funcionario.java nesta array, um em cada posio (ndice),
como mostra a representao na Figura 3.17.
Figura 3.17: Array de objetos.
Os dados armazenados sero fornecidos pelo usurio.

Para realizar este trabalho, crie um projeto chamado ProjetoTeste e as classes
Teste.java e Funcionario.java, como mostra a Figura 3.18.
Figura 3.18: Representao do projeto criado no NetBeans.
A classe Funcionario.java a mesma apresentada anteriormente nesse Captulo,

portanto, digite o cdigo-fonte desta classe ou copie-o, caso j tenha digitado.
Na classe principal Teste.java, digite o cdigo a seguir:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
Funcionario funcionarios[];
funcionarios = new Funcionario[3];
Funcionario func;
for (int indice = 0; indice < funcionarios.length; indice++) {
func.setMatricula(Integer.parseInt(JOptionPane.showInputDialog("Digi
te a matrcula: ")));
func.setNome(JOptionPane.showInputDialog("Digite o nome: "));
func.setCargo(JOptionPane.showInputDialog("Digite o cargo: "));
func.setSalario(Double.parseDouble(JOptionPane.showInputDialog("Di
gite o salrio: ")));
funcionarios[indice] = func;
}
for (int indice = 0; indice < funcionarios.length; indice++) {
func = funcionarios[indice];
JOptionPane.showMessageDialog(null,
"Matrcula:" + func.getMatricula() + "\n"
+ "Nome:" + func.getNome() + "\n"
+ "Cargo:" + func.getCargo() + "\n"
+ "Salrio:" + func.getSalario() + "\n");
}
}
}
Basicamente, o que esta classe faz pedir dados de funcionrios, colocar estes
dados em objetos da classe Funcionario.java e incluir cada um destes objetos
nas posies de uma array. Para isso, utilizado um lao de repetio para
passar por cada posio da array (linhas de 7 14). Em seguida, o contedo
de cada objeto das posies da array tem seu contedo exibido. Para percorrer
a array, um lao de repetio tilizado (linhas 15 18).
Para entender melhor todo o processo, segue uma explicao mais detalhada.
A linha 4 declara a array funcionarios e a linha 5 instancia a array com trs
posies, sempre numeradas a partir de 0 (neste caso, de 0 2).
A linha 6 declara o objeto func da classe Funcionario.java.

A linha 5 inicia um lao de repetio que vai de 0 ao tamanho da array
funcionrios -1, incrementando a varivel indice em 1 a cada passagem pelo
interior do lao. Note que a varivel indice iniciada com valor 0. O lao de
repetio tem seu fechamento na linha 14.
No interior do lao (linha 8), o objeto func da classe Funcionario.java
instanciado vazio. Na linha 9, pedido o valor da matrcula do funcionrio,
convertido em inteiro e armazenado no atributo matricula do objeto func.
Na linha 10, pedido o nome do funcionrio e armazenado no atributo nome
do objeto func.
Na linha 11, pedido o cargo do funcionrio e armazenado no atributo cargo
do objeto func.
Na linha 12, pedido o valor do salrio do funcionrio, convertido em double
e armazenado no atributo salario do objeto func.
Na linha 13, o objeto func adicionado posio 0 da array funcionarios e o
lao retorna a execuo para a linha 7, onde a varivel indice, que representa as
posies da array incrementada em 1, passando a valer 1. Como a condio
do lao ainda verdadeira, o interior do lao executado novamente.
Note que a linha 8 instancia um novo objeto func da classe Funcionario.
java. As linhas de 9 12 so executadas, solicitando novamente valores e
armazenando no novo objeto func. Na linha 13, o objeto func, que j contm
os novos dados, armazenado na posio 1 da array funcionarios. Veja que a
linha 14 retorna para a linha 7, linha de abertura do lao. Novamente a varivel
indice incrementada em 1, passando a valer 2. Como a condio do lao ainda
verdadeira, o interior do lao executado novamente.
Note que a linha 8 instancia um novo objeto da classe Funcionario.java. As linhas
de 9 12 so executadas, solicitando novamente valores e armazenando no novo
objeto func. Na linha 13, o objeto func, que j contm os novos dados, armazenado
na posio 2 da array funcionarios. A linha 14 retorna para a linha 7 onde a varivel
indice incrementada em 1 passando a valer 3, o que torna a condio do lao

falsa, encerrando sua execuo e desviando para a linha 15, que inicia um novo
lao, este, para exibir os dados dos objetos em cada posio da array funcionarios.
O lao da linha 15 idntico ao lao anterior, contando de 0 a 2, ou seja, de 0

ao tamanho da array funcionarios -1. A varivel indice iniciada em 0 e usada
para contar as execues do interior do lao.
Note na linha 16, que o contedo da array funcionarios na posio indice, que
vale 0, colocado em um objeto func da classe Funcionario.java. Basicamente
esta linha pega o primeiro objeto da posio 0 da array funcionarios e coloca
em um objeto func da classe Funcionario.java. A linha 17 exibe os dados
deste objeto e a linha 18 retorna ao incio do lao, incrementando a varivel
indice em 1, fazendo com que esta varivel passe a valer 1. Como condio
do lao verdadeira, o interior do lao executado novamente. Na linha 16, o
objeto da classe Funcionario.java contido na posio 1 da array funcionarios
armazenado em um objeto func da classe Funcionario.java. A linha 17 exibe
o contedo deste objeto e a linha 18 retorna para o incio do lao (linha 15).
A varivel indice incrementada em 1, passando a valer 2. Como a condio
ainda verdadeira, o lao executado novamente. A linha 16 pega o objeto
da classe Funcionario.java contido na posio 2 da array e armazena em um
objeto func da classe Funcionario.java. A linha 17 exibe o contedo deste
objeto. A linha 18 retorna para a linha de abertura do lao, onde a varivel
indice incrementada em 1, passando a valer 3. Como a condio agora se
tornou falsa, o lao encerrado e as linhas 19 e 20 so executadas, terminando
a execuo da classe.
3.7.1 Quando usar arrays de objetos

Muitas vezes voc precisa passar um conjunto de objetos para um mtodo,
como parmetro. Passar um a um pode ser muito trabalhoso, pois necessitaria
de muitas chamadas ao mtodo. Neste caso, mais fcil colocar o conjunto
de objetos em uma array e passar a array como parmetro em uma nica
chamada de mtodo.
Quando se quer armazenar um conjunto de objetos no banco de dados, em
alguns casos, tambm mais fcil armazenar estes objetos em uma array e
enviar esta array para alguma API ou mtodo que gerencie o envio para a
tabela do banco de dados.
H muitos usos para arrays de objetos e com o tempo certamente voc vai
precisar utilizar uma.
3.8 Resumo
Os conceitos fundamentais da orientao a objetos so classes, atributos,
mtodos, construtores e objetos.
Uma classe um arquivo de programa Java com algumas caractersticas especiais

para atender ao paradigma orientado a objetos. Assim, deve possuir uma declarao
e um construtor (explcito ou implcito). Alm destas estruturas, pode possuir
declarao de atributos e/ou constantes e mtodos. Classes com caractersticas
comuns normalmente so agrupadas em contineres (espcie de pastas), chamados
pacotes. As bibliotecas de classes que fazem parte da linguagem Java normalmente
vm agrupadas em pacotes, como java.swing, java.util etc. Para modelar (ou
desenhar) uma classe utiliza-se a notao do diagrama de classes da UML. Para
modelar um pacote, utiliza-se a notao do diagrama de pacotes.
As classes normalmente representam abstraes do mundo real para categorizao
ou classificao de algo. Por exemplo, as pessoas em uma empresa podem ser
classificadas em clientes e funcionrios. A classe dos clientes pode possuir os
atributos nome, endereo, telefone etc. A classe dos funcionrios pode possuir
nome, cargo, salrio etc. Sobre o salrio podem ser executadas operaes
(mtodos) para reajustar o salrio, calcular o imposto de renda etc.
Um atributo, na programao, uma varivel da classe, e um mtodo, uma
operao que pode ser realizada sobre os valores contidos nos atributos e/ou
sobre valores recebidos como parmetro.
Um objeto uma varivel de referncia a uma classe que permite incluir valores
nos seus atributos (por meio de mtodos setter) ou obter valores destes atributos
(por meio de mtodos getter), alm de permitir, normalmente, acessar seus
mtodos visveis. Para instanciar (criar) um objeto de uma classe, necessrio
chamar o construtor da classe utilizando a instruo new seguida do nome do
construtor, que deve ter o mesmo nome da classe. O construtor pode estar vazio
e no receber parmetros. Neste caso, o objeto ser criado com os atributos
vazios. Se o construtor receber parmetros, estes normalmente so adicionados
aos atributos da classe no corpo do construtor. Uma classe pode ter vrios
construtores, desde que recebam parmetros diferentes. Neste caso, dizemos
que h sobrecarga de construtor. Pode-se criar diversos objetos da mesma classe
com os atributos em cada objeto contendo valores diferentes.
Um mtodo setter um mtodo que normalmente inicia pela palavra set,
seguida do nome do atributo com letra inicial maiscula. Este tipo de mtodo
recebe um valor como parmetro que includo no atributo do objeto.
Um mtodo getter um mtodo que normalmente inicia pela palavra get,
seguida do nome do atributo com letra inicial maiscula. Este tipo de mtodo
normalmente no recebe parmetro e apenas retorna o valor armazenado no
atributo. Alm dos mtodos setter e getter, uma classe pode ter qualquer outro
mtodo que pode atuar sobre os valores dos atributos ou no.
A tcnica de ocultar de um objeto detalhes internos do funcionamento dos
mtodos de uma classe, de forma que o conhecimento interno do corpo dos
mtodos no seja necessrio para cham-los, conhecida como encapsulamento.
H classes que so criadas sem atributos, apenas com mtodos, para executar
operaes especficas na aplicao, que normalmente so chamadas diversas vezes.
Mtodos em uma mesma classe podem ter o mesmo nome, desde que recebam
parmetros diferentes. Neste caso, dizemos que h sobrecarga de mtodos.
A entrada de dados do usurio em uma aplicao Java SE pode ser feita
via prompt de comando, utilizando a classe Scanner; via interface grfica,
utilizando a classe JOptionPane; ou via formulrio, utilizando outras classes
do pacote javax.swing.
3.9 Exerccios
A seguir voc encontrar exerccios prticos, onde ter que criar projetos no
NetBeans e digitar o cdigo-fonte de classes, e tambm exerccios para fixar
os conceitos aprendidos neste Captulo. No deixe de fazer estes exerccios.
3.9.1 Exerccios prticos

1) Crie um projeto chamado Projeto1 no NetBeans com um pacote chamado
teste contendo uma classe principal chamada Teste.java e uma classe chamada
Aluno.java.
O desenho da classe Aluno.java apresentado a seguir:
Aluno
- matricula:long
- nome:String
- disciplina:String
- numeroAulas:int
- numeroFaltas:int
- notaAv1:double
- notaAv2:double
- notaAv3:double
+ calcularMedia():double
+ calcularLimiteFaltas():double
+verificarSituacao(media:double, limiteFaltas:double):String
Instrues para a criao da classe Aluno.java:

Na classe Aluno.java, declare os atributos, um construtor vazio, os mtodos
getter e setter e os mtodos descritos calcularMedia, calcularLimiteFaltas e
verificarSituacao, descritos a seguir.
O mtodo calcularMedia deve descartar a menor das trs notas e calcular a
mdia das duas maiores, retornando o valor resultante.
O mtodo calcularLimiteFaltas deve retornar o limite de faltas que 25% do

nmero de aulas. Esse limite de faltas representa o nmero mximo de faltas
que o aluno pode ter em determinada disciplina.
O mtodo verificarSituacao deve verificar se o aluno foi aprovado ou no. Para
isto, esse mtodo recebe a mdia do aluno e o limite de faltas que ele pode ter.
Para ser aprovado, o aluno deve ter mdia maior ou igual a 6.00 e o nmero
de faltas menor do que o limite de faltas permitido. Se aprovado, esse mtodo
deve retornar a String Aprovado, seno, deve retornar a String Reprovado.
Instrues para a criao da classe Teste.java:
Na classe principal Teste.java, os dados do aluno devem ser solicitados
utilizando interface grfica por meio da classe JOptionPane e armazenados
em um objeto da classe Aluno.java. Em seguida, os dados armazenados neste
objeto devem ser exibidos em uma nica caixa de dilogo. Aps a exibio
dos dados, deve ser exibida a mdia e a situao do aluno (Aprovado ou
Reprovado) em uma nova caixa de dilogo.
2) Crie um projeto chamado Projeto2 que contenha em um pacote chamado
classes.teste uma classe principal chamada Principal.java e uma classe chamada
Produto.java. O desenho da classe Produto.java apresentado a seguir:
Produto
- id:long
- nome:String
- marca:String
- preco:double
+ diminuirPreco(percentual:double):void
+ aumentarPreco(percentual:double):void
Instrues para construir a classe Produto.java:

A classe Produto.java deve possuir os atributos, um construtor vazio e um
construtor recebendo todas as informaes do produto como parmetro. Deve
tambm possuir mtodos getter e setter para os atributos declarados.
O mtodo diminuirPreco deve receber um valor double e reduzir o preo do

produto neste percentual.
O mtodo aumentarPreco deve receber um valor double e reduzir o preo do
produto neste percentual.
Instrues para construir a classe Principal.java:
Devem ser instanciados dois objetos da classe Produto.java e cadastrados todos

os dados de dois produtos a partir da entrada de dados do usurio por meio de
campos gerados com a utilizao da classe Scanner. Aps o cadastro dos dois
produtos, o primeiro, deve ter seu preo diminudo em um percentual solicitado
ao usurio. O segundo, deve ter seu preo aumentado em um percentual tambm
solicitado ao usurio. Em seguida, todos os dados dos dois produtos devem
ser exibidos na tela.
3) Utilize as mesmas classes da questo 2, alterando a classe principal Teste.java,
de tal forma que os dois objetos da classe Produto.java sejam armazenados em
uma array unidimensional de produtos, como a representada a seguir:
3.9.2 Exerccios conceituais

1) Defina:
A) Classe.
B) Atributo.
C) Mtodo.
D) Mtodos setter.
E) Mtodos getter.
F) Construtor.
G) Objeto.
H) Pacote.
2) Quais so as boas prticas para nomeao de variveis, classes e pacotes

em Java?
3) O que encapsulamento? Qual a vantagem proporcionada pelo
encapsulamento em aplicaes orientadas a objetos?
4) O que sobrecarga de mtodo e sobrecarga de construtor?
5) Que instruo na declarao do mtodo indica que ele no retorna nada?
6) Quantos valores um mtodo pode retornar de cada vez? Justifique sua resposta.
4. Orientao a objetos
conceitos avanados
Ao chegar neste ponto do livro voc precisa ter os conhecimentos bsicos
da orientao a objetos apresentados no Captulo anterior. Precisa ser
capaz de criar classes, com atributos e mtodos, instanciar objetos destas
classes e manipular dados nestes objetos. Precisa tambm entender a funo
do construtor de uma classe, sobrecarga de construtores e sobrecarga de
mtodos.
Alm dos conceitos bsicos da orientao a objetos, precisa estar adaptado ao
uso do NetBeans, tendo condies de criar projetos com pacotes e classes e
compilar e executar estes projetos adequadamente.
Neste Captulo vamos alm dos conceitos bsicos. Voc vai aprender o conceito
de herana em suas vrias formas, que podem ocorrer em graus diferentes de
maneira simples, por meio do uso de interfaces e por meio do uso de classes
abstratas.
4.1 Herana
Herana um conceito proveniente da observao das relaes humanas, onde
os filhos herdam caractersticas dos pais; e da modelagem de dados, onde
tabelas especializadas herdam atributos de tabelas generalizadas.
Voc vai usar herana quando possuir um conjunto de atributos e/ou mtodos
que comum a um conjunto de classes e possuir alguns deles que so
especficos de cada classe. Nesse caso, voc centraliza os que so comuns em
uma superclasse e os especficos coloca nas respectivas subclasses, de tal forma
que estas subclasses herdem os atributos e/ou mtodos comuns da superclasse.
Segundo Horstmann (2009, p. 400),
a herana um mecanismo para estender as classes existentes adicionando novos mtodos e campos. A classe
mais geral chama-se superclasse e a classe mais especializada, que herda da superclasse chama-se subclasse.
Veja um exemplo de diagrama de classe representando uma relao de herana

entre as classes Conta, ContaCorrente e ContaPoupanca.
Figura 4.1: Diagrama de classe representando herana.
Note que os atributos noBanco, noAgencia, noConta, nomeCliente e saldo

so comuns a todos os tipos de conta (corrente e poupana), por isso so
centralizados em uma classe pai (superclasse) chamada Conta. J os atributos
especficos de conta corrente so centralizados na classe filha (subclasse)
ContaCorrente e os de conta poupana so centralizados na classe filha
(subclasse) ContaPoupanca.
Na realidade, as subclasses ContaCorrente e ContaPoupanca possuem todos os
atributos e mtodos da superclasse Conta e tambm seus atributos e mtodos
especficos.
NOTA
Em uma relao de herana, a classe pai chamada de superclasse e as

classes filhas, de subclasses. Os atributos e mtodos comuns so centralizados na superclasse e os especficos, nas subclasses. As subclasses herdam todos os atributos e mtodos da superclasse.
Em Java, vrias subclasses diferentes podem herdar de uma mesma superclasse,

mas uma subclasse no pode herdar de mais de uma superclasse, pois no existe
herana mltipla em Java. Logo, no exemplo acima, a subclasse ContaCorrente,
por exemplo, poder herdar da superclasse Conta, mas no poderia herdar de
nenhuma outra superclasse, caso existissem outras superclasses na aplicao.
Para indicar que uma subclasse herda de uma superclasse utiliza-se a palavra
reservada extends. Por exemplo, veja como fica a declarao da classe
ContaCorrente.
public class ContaCorrente extends Conta {

//O contedo da classe deve ser digitado aqui
}
Nos tpicos seguintes, as classes Conta, ContaCorrente e ContaPoupanca

sero implementadas em um projeto Java criado no NetBeans.
4.1.1 Exemplo de aplicao com herana

Para implementar as classes do diagrama apresentado no tpico anterior,
crie um projeto Java no NetBeans e nomeie-o de ProjetoTeste. Neste projeto,
crie quatro classes: Conta.java, ContaCorrente.java, ContaPoupanca.java e
Principal.java. A classe Principal.java ser utilizada para instanciarmos objetos
das classes da relao de herana.
A Figura 4.2 mostra como deve ficar o projeto aps a criao destas classes.
Figura 4.2: Projeto com uso de herana simples.
Nos tpicos seguintes sero apresentados os cdigos-fonte das classes criadas.
4.1.1.1 Implementao da superclasse Conta
A superclasse Conta.java uma classe comum, como criada no Captulo

anterior, onde so declarados os atributos, definidos os construtores (um vazio
e um recebendo parmetros) e os mtodos getter e setter para os atributos.
Veja como ficar o cdigo-fonte.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
public class Conta {

private String noBanco;
private String noAgencia;
private String noConta;
private String nomeCliente;
private double saldo;
public Conta(String noBanco, String noAgencia, String noConta, String
nomeCliente, double saldo) {
this.noBanco = noBanco;
this.noAgencia = noAgencia;
this.noConta = noConta;
this.nomeCliente = nomeCliente;
this.saldo = saldo;
}
public Conta() {
}
public String getNoBanco() {
return noBanco;
}
public void setNoBanco(String noBanco) {
this.noBanco = noBanco;
}
public String getNoAgencia() {
return noAgencia;
}
public void setNoAgencia(String noAgencia) {
this.noAgencia = noAgencia;
}
public String getNoConta() {
return noConta;
}
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
public void setNoConta(String noConta) {

this.noConta = noConta;
}
public String getNomeCliente() {
return nomeCliente;
}
public void setNomeCliente(String nomeCliente) {
this.nomeCliente = nomeCliente;
}
public double getSaldo() {
return saldo;
}
public void setSaldo(double saldo) {
this.saldo = saldo;
}
}
NOTA
Os mtodos da superclasse Conta.java, para serem acessados a partir das

subclasses ContaCorrente.java e ContaPoupanca.java devem ser pblicos (public) ou protegidos (protected). Mtodos protected podem ser
acessados a partir de subclasses em uma relao de herana. J mtodos
public podem ser acessados a partir de qualquer classe.
4.1.1.2 Implementao da subclasse

ContaCorrente
A subclasse ContaCorrente.java herda todo o contedo da classe Conta.java,
o que pode ser percebido pelo uso da instruo extends na sua declarao. Veja
a seguir o cdigo-fonte desta subclasse:
1
2
3
4
5
6
public class ContaCorrente extends Conta {

private double limiteCheque;
private double juroCheque;
public ContaCorrente(double limiteCheque, double juroCheque, String noBanco,
String noAgencia, String noConta, String nomeCliente, double saldo) {
super(noBanco, noAgencia, noConta, nomeCliente, saldo);
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
this.limiteCheque = limiteCheque;
this.juroCheque = juroCheque;
public ContaCorrente() {
}
public double getLimiteCheque() {
return limiteCheque;
}
public void setLimiteCheque(double limiteCheque) {
this.limiteCheque = limiteCheque;
}
public double getJuroCheque() {
return juroCheque;
}
public void setJuroCheque(double juroCheque) {

this.juroCheque = juroCheque;
}
A instruo extends na linha 1 indica que a subclasse ContaCorrente.java herda

o contedo da classe Conta.java.
Note, nas linhas de 5 9, o construtor da subclasse ContaCorrente.java. Ele
recebe como parmetro os valores necessrios para os atributos desta subclasse
(limiteCheque e juroCheque) e tambm valores para os atributos da superclasse
Conta.java (noBanco, noAgencia, noConta, nomeCliente e saldo). Os valores
para os atributos desta subclasse so includos nos atributos nas linhas 7 e 8.
J os valores para os atributos da superclasse so enviados ao construtor da
superclasse por meio da instruo super, na linha 6.
Nas linhas 11 e 12 h um segundo construtor, que no recebe parmetros. Este
construtor poder ser usado para criar um objeto desta subclasse vazio e depois,
se necessrio, incluir valores por meio dos mtodos setter.
NOTA
Em uma subclasse, sempre que voc quiser acessar mtodos da superclasse, basta digitar a palavra super seguida do ponto final e do nome
do mtodo. Por exemplo: super.getNomeCliente(); Vale lembrar que o
mtodo deve permitir acesso, ou seja, deve ser pblico (public) ou protegido (protected).
4.1.1.3 Implementao da subclasse

ContaPoupanca
A subclasse ContaPoupanca.java herda todo o contedo da classe Conta.
java, o que tambm pode ser percebido pelo uso da instruo extends na sua
declarao. Veja a seguir o cdigo-fonte desta subclasse:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import java.util.Date;
public class ContaPoupanca extends Conta {
private Date dataAniversario;
public ContaPoupanca(Date dataAniversario, String noBanco, String noAgencia,
String noConta, String nomeCliente, double saldo) {
super(noBanco, noAgencia, noConta, nomeCliente, saldo);
this.dataAniversario = dataAniversario;
}
public ContaPoupanca() {
}
public Date getDataAniversario() {
return dataAniversario;
}
public void setDataAniversario(Date dataAniversario) {

this.dataAniversario = dataAniversario;
}
As linhas de 6 9 correspondem ao construtor da subclasse ContaPoupanca.

java. Ele recebe como parmetro o valor necessrio para o atributo desta
subclasse (dataAniversario) e tambm valores para os atributos da superclasse
Conta.java (noBanco, noAgencia, noConta, nomeCliente e saldo). O valor para
o atributo desta subclasse incluido no atributo dataAniversario. J os valores
para os atributos da superclasse so enviados ao construtor da superclasse por
meio da instruo super, na linha 7.
4.1.1.4 Implementao da classe Principal

A classe Principal.java por onde instanciaremos objetos das classes
envolvidas na relao de herana.
Vamos instanciar, em um primeiro momento, apenas um objeto da subclasse
ContaCorrente.java e entender como ocorre a instncia. Para isso, digite na
classe Principal.java, o seguinte cdigo-fonte:
1
2
3
4
5
6

ContaCorrente ctCor2;
ctCor2 = new ContaCorrente(10000.00, 6.5, "035", "143-2", "01435-9",
"Evandro", 32789.50);
}
}
Veja na classe ContaCorrente.java, que h um construtor que recebe como

parmetro o limiteCheque, o juroCheque, o noBanco, o noAgencia, o noConta,
o nomeCliente e o saldo. A linha 4 instancia o objeto ctCor2 por meio de uma
chamada a este construtor feita pela instruo new.
Na instncia do objeto ctCor2 foram passados como parmetro diversos valores
ao construtor da classe ContaCorrente.java. O valor 10000.00 foi passado para
a varivel limiteCheque; o valor 6.5 foi passado para a varivel juroCheque; o
valor 035 foi passado para a varivel noBanco; o valor 143-2 foi passado
para a varivel noAgencia; o valor 01435-9 foi passado para a varivel
noConta; o valor Evandro foi passado para a varivel nomeCliente; e o valor
32789.50 foi passado para a varivel saldo.
No construtor da classe ContaCorrente.java o contedo das variveis noBanco,
noAgencia, noConta, nomeCliente e saldo so passados para o construtor
da superclasse Conta.java, por meio da instruo super. J o contedo das
variveis limiteCheque e juroCheque so armazenados nos atributos da classe
ContaCorrente.java. A Figura 4.3 representa a passagem dos parmetros na
instncia do objeto.
Figura 4.3: Instncia de objetos da subclasse em uma relao de herana simples.
Basicamente, quando voc instancia um objeto da subclasse voc passa um

conjunto de parmetros para o construtor desta subclasse. Os parmetros que
so da superclasse so passados ao construtor da superclasse por meio da
instruo super e os parmetros que so da subclasse so incluidos nos atributos
da subclasse. Os parmetros que foram passados ao construtor da superclasse
so includos nos atributos da superclasse no corpo do construtor. O objeto
ctCor2 ter, aps sua instncia, um formato que pode ser representado pela
Figura 4.4:
limiteCheque
juroCheque
noBanco
noAgencia
noConta
nomeCliente
saldo
ctCor2
10000.00
6.5
035
143-2
01435-9
Evandro
32789.50
setLimiteCheque(double limiteCheque): void
getLimiteCheque(): double
setJuroCheque(double juroCheque): void
getJuroCheque(): double
setNoBanco(String noBanco): void
getNoBanco(): String
setNoAgencia(String noAgencia): void
getNoAgencia(): String
setNoConta(String noConta): void
getNoConta(): String
setNomeCliente(String nomeCliente): void
getNomeCliente(): String
setSaldo(double saldo): void
getSaldo(): double
Figura 4.4: Formato do objeto ctCor2.
Vamos alterar o cdigo-fonte da classe Principal.java instanciando, alm do

objeto ctCor2 da subclasse ContaCorrente.java, um objeto ctPoup da subclasse
ContaPoupanca.java. Em seguida, vamos exibir o contedo dos dois objetos
por meio de chamadas aos mtodos getter.
1
2
3
4
5
6
7
8
9
10
ContaCorrente ctCor2;
ContaPoupanca ctPoup;
Date data;
data = new Date("07/10/2014");
ctCor2 = new ContaCorrente(10000.00, 6.5, "035", "143-2", "01435-9",
"Evandro", 32789.50);
ctPoup = new ContaPoupanca(data, "022", "347-2", "003491-1", "Ana Luiza",
18976.40);
System.out.println("Banco:" + ctCor2.getNoBanco() + "\n"
11
12
13
+ "Agncia:" + ctCor2.getNoAgencia() + "\n"

+ "Conta:" + ctCor2.getNoConta() + "\n"
+ "Cliente:" + ctCor2.getNomeCliente() + "\n"
+ "Saldo:" + ctCor2.getSaldo() + "\n"
+ "Limite:" + ctCor2.getLimiteCheque() + "\n"
+ "Juros do Cheque especial:" + ctCor2.getJuroCheque() + "\n");
System.out.println("Banco:" + ctPoup.getNoBanco() + "\n"
+ "Agncia:" + ctPoup.getNoAgencia() + "\n"
+ "Conta:" + ctPoup.getNoConta() + "\n"
+ "Cliente:" + ctPoup.getNomeCliente() + "\n"
+ "Saldo:" + ctPoup.getSaldo() + "\n"
+ "Data de aniversrio da conta:" + ctPoup.getDataAniversario());
Observe na linha 7 que foi instanciado um objeto da classe Date onde foi
armazenada a data de 07/10/2014 neste objeto. Est ser a data de aniversrio
da conta poupana.
Na linha 8 foi instanciado um objeto da subclasse ContaCorrente.java, que
j estudamos anteriormente, e na linha 9 foi instanciado um objeto da classe
ContaPoupanca.java.
Na linha 10 o contedo dos atributos do objeto ctCor2 obtido por meio de
chamadas aos mtodos getter correspondentes e exibidos na tela. J na linha
11, o contedo dos atributos do objeto ctPoup tambm obtido por meio de
chamadas aos mtodos getter e exibidos na tela.
Quando voc compilar e executar o projeto por meio do pressionamento da
tecla F6, ser apresentado na tela o seguinte resultado:
Banco:035
Agncia:143-2
Conta:01435-9
Cliente:Evandro
Saldo:32789.5
Limite:10000.0
Juros do Cheque especial:6.5
Banco:022
Agncia:347-2
Conta:003491-1
Cliente:Ana Luiza
Saldo:18976.4
Data de aniversrio da conta:Thu Jul 10 00:00:00 BRT 2014
Para alterar o contedo dos objetos podem ser feitas chamadas aos respectivos
mtodos setter. Veja, por exemplo, como poderiam ser includos novos valores
no objeto ctCor2 aps sua criao na classe Principal.java.
ctCor2.setNoBanco("546");
ctCor2.setNoConta("6758-9");
ctCor2.setNoAgencia("01564-2");
ctCor2.setNomeCliente("Marco Antnio");
ctCor2.setSaldo(23456.65);
ctCor2.setJuroCheque(5.9);
ctCor2.setLimiteCheque(1200.5);
Para inserir valores no objeto ctPoup voc pode chamar os mtodos setter
correspondentes de forma semelhante incluso que fizemos no objeto ctCor2.
4.1.2 Superclasses e subclasses nas relaes de

herana
Subclasses so classes que herdam da superclasse. A herana estabelecida
pela instruo extends na declarao das subclasses. As subclasses herdam das
superclasses atributos e mtodos como se estivessem dentro das prprias subclasses.
No exemplo que estamos utilizando, ContaCorrente.java e ContaPoupanca.
java so tipos de Conta.java, logo, objetos do tipo ContaCorrente.java e
ContaPoupanca.java so tambm objetos do tipo Conta.java.
Veja o exemplo da instncia de dois objetos ctCor3 e ctCor4:
Conta ctCor3 = new ContaCorrente(10000.00, 6.5, "035","143-2","01435-9",
"Evandro",32789.50);
ContaCorrente ctCor4 = new ContaCorrente(10000.00, 6.5, "035","143-2","01435-9",
"Evandro",32789.50);
Note que ctCor3 um objeto da superclasse Conta.java criado a partir de uma

chamada ao construtor da subclasse ContaCorrente.java. Isso possvel porque
um objeto da superclasse tambm um objeto de sua subclasse. J ctCor4
um objeto da subclasse ContaCorrente.java criado a partir de uma chamada
ao construtor desta subclasse. A diferena entre os dois objetos criados que
por meio do objeto ctCor3 no ser possvel acessar os mtodos da subclasse
ContaCorrente.java, j que ele foi declarado explicitamente como um objeto
da superclasse Conta.java e s poder acessar os mtodos desta superclasse. J
o objeto ctCor3, por ser declarado como objeto da subclasse ContaCorrente.
java, permitir o acesso aos mtodos da classe Conta.java e da subclasse
ContaCorrente.java.
4.1.3 Herana em cadeia
Uma subclasse pode ser superclasse de outras subclasses, criando relaes de

herana em cadeia. A Figura 4.5 mostra o diagrama de classes de uma relao
de herana em cadeia.
Figura 4.5: Diagrama de classes representando cadeia de herana.
Note, neste caso, que ContaCorrente.java subclasse da superclasse Conta.

java e superclasse das subclasses Universitaria.java e Empresarial.java.
As subclasses Universitaria.java e Empresarial.java herdam toda a cadeia de
herana, ou seja, herdam os atributos e mtodos de ContaCorrente e tambm
de Conta.java. Veja como feita a declarao destas classes:
public class Conta{

}
public class ContaCorrente extends Conta{
}
public class Universitaria extends ContaCorrente {
}
public class Empresarial extends ContaCorrente {
}
public class ContaPoupanca Extends Conta {
}
Voc ainda poderia ter mais subclasses herdando de Empresarial.java e

Universitaria.java.
4.1.4 Conseguindo polimorfismo com herana

Objetos das subclasses em uma relao de herana so tambm considerados
objetos da superclasse. Quando por meio destes objetos se acessa um mesmo
mtodo em subclasses diferentes e se obtm resultados diferentes, podemos
dizer que estes objetos possuem formas diferentes, o que nos remete ao conceito
de polimorfismo.
Este um conceito complexo na orientao a objetos, que se obtm apenas
quando se utiliza herana, interfaces ou classes abstratas.
Para entender como ocorre o polimorfismo nas relaes de herana, vamos
criar uma pequena aplicao Java cujas classes so representadas no diagrama
mostrado na Figura 4.6.
Figura 4.6: Diagrama de classes de aplicao exemplo.
Note que as subclasses Alimento.java e Vestuario.java herdam os atributos

e mtodos da superclasse Produto.java. Apesar de herdarem o mtodo
calcularPreco da superclasse, as subclasses reescrevem este mtodo para que
possam calcular o preo de maneira especializada, ou seja, o clculo do preo
dos alimentos ser diferente do calculo do preo dos produtos de vesturio.
Aqui ocorre o que conhecemos como sobrescrita de mtodos, pois um mtodo
da superclasse reescrito com a mesma assinatura nas subclasses, porm, com
corpo diferente.
Vamos criar um novo projeto no NetBeans para implementar esta aplicao.
Crie um novo projeto chamado ProjetoPoli e, nele, crie as classes mostradas
na Figura 4.7.
Figura 4.7: representao dos componentes do ProjetoPoli no NetBeans.
Escreva o seguinte cdigo-fonte para a superclasse Produto.java:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
public class Produto {

private double valorBase;
public Produto(String nome, double valorBase) {
this.nome = nome;
this.valorBase = valorBase;
}
return nome;
}
this.nome = nome;
}
public double getValorBase() {
return valorBase;
}
public void setValorBase(double valorBase) {
this.valorBase = valorBase;
}
public double calcularPreco() {

return getValorBase();
}
Note que nesta classe o mtodo calcularPreco apenas retorna o contedo do

atributo valorBase, por meio de uma chamada ao mtodo getValorBase.
Para a subclasse Alimento.java, escreva o cdigo-fonte a seguir:
1
2
3
4
5
6
public class Alimento extends Produto {

private double peso;
public Alimento(double peso, String nome, double valorBase) {
super(nome, valorBase);
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
this.peso = peso;
public double getPeso() {

return peso;
}
public void setPeso(double peso) {
this.peso = peso;
}
@Override
public double calcularPreco() {
return super.getValorBase() * this.peso;
}
O mtodo calcularPreco herdado da superclasse Produto.java, porm,

reescrito nas linhas de 18 21, retornando o contedo do atributo valorBase
a partir de uma chamada ao mtodo getValorBase da superclasse Produto.java
multiplicado pelo contedo do atributo peso desta subclasse. Apesar do mtodo
ter o mesmo nome do mtodo da superclasse Produto.java, sua implementao
nesta subclasse diferente. A indicao que o mtodo foi sobrescrito ocorre
pela presena da anotao @Override, que ser vista em detalhes no final
deste Captulo.
Para a subclasse Vestuario.java, escreva o cdigo-fonte a seguir:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class Vestuario extends Produto{

private double quantidade;
public Vestuario(double quantidade, String nome, double valorBase) {
super(nome, valorBase);
this.quantidade = quantidade;
}
public double getQuantidade() {
return quantidade;
}
public void setQuantidade(double quantidade) {
this.quantidade = quantidade;
}
17
18
19
20
21
22
@Override
public double calcularPreco(){
return (super.getValorBase() * this.quantidade) super.getValorBase() *
20/100;
}
}
O mtodo calcularPreco herdado da superclasse, porm, reescrito nas linhas

de 17 20, retornando o contedo do atributo valorBase multiplicado pelo
contedo do atributo quantidade menos 20% do valorBase. Apesar do mtodo
ter o mesmo nome do mtodo da superclasse Produto.java, sua implementao
nesta superclasse diferente.
Para iniciar (startar) a aplicao e manipular objetos, precisamos da classe
Teste.java, cujo cdigo-fonte mostrado a seguir:
1
2
3
4
5
6
7
8

Produto p1 = new Alimento(10.0, "Arroz", 10.5);
Produto p2 = new Vestuario(10.0, "Camisa", 10.5);
System.out.print("Preo de " + p1.getNome() + " igual a " +
p1.calcularPreco() + "\n");
System.out.print("Preo de " + p2.getNome() + " igual a " +
p2.calcularPreco());
}
}
Ao compilar e executar este projeto, o que pode ser feito pelo pressionamento
da tecla F6, ser exibido na tela os seguintes valores:
Preo de Arroz igual a 105.0
Preo de Camisa igual a 102.9
Note que foram instanciados dois objetos p1 e p2 (linhas 3 e 4), ambos do tipo
Produto.java, porm, com chamadas ao construtor de subclasses diferentes. O
objeto p1 foi instanciado por meio de uma chamada ao construtor da subclasse
Alimento.java e o objeto p2 por meio uma chamada ao construtor da subclasse
Vestuario.java. Em ambas as instncias, foram passados os mesmos valores
numricos utilizados para calcular o preo do produto.
Na linha 5 mostrado o nome do produto contido no atributo nome do objeto
p1 e o preo, calculado por meio de uma chamada ao mtodo calcularPreco.
Na linha 6 mostrado o nome do produto contido no atributo nome do

objeto p2 e o preo, calculado tambm por meio de uma chamada ao mtodo
calcularPreco.
Note que apesar dos dois objetos serem do tipo da superclasse Produto.java e
chamarem o mtodo calcularPreco, foram retornados valores diferentes, j que
a operao contida no mtodo em cada uma das subclasses diferente. Logo,
podemos concluir que os objetos p1 e p2, apesar de serem do mesmo tipo,
apresentam formas diferentes. Esta situao, que pode ocorrer em aplicaes
que utilizam herana, conhecida como polimorfismo, onde poli significa
muitas e morfirmo significa formas.
4.2 Interfaces
Uma interface, na orientao a objetos, um tipo de classe que contm apenas
mtodos abstratos, ou seja, mtodos que possuem apenas a assinatura, sem
corpo. Podem tambm possuir constantes. A implementao (construo) dos
membros feita por uma classe concreta que implementa a interface.
Segundo Horstmann (2009, p. 361), um tipo interface em Java declara um
conjunto de mtodos e suas assinaturas e permite tornar o cdigo da aplicao
mais reutilizvel.
Para declarar uma classe como interface utiliza-se no lugar da instruo class
a instruo interface. Veja o exemplo a seguir:
public interface Operacoes{
}
Nas interfaces, os mtodos no podem ter corpo, ou seja, devem ter apenas
uma assinatura (declarao).
Veja o exemplo da interface chamada Operacoes.java que possui a assinatura
do mtodo calcularMedia.
public abstract double calcularMedia(double n1, double n2);
}
O mtodo no tem corpo entre chaves e termina com ponto e vrgula. Esta forma
de declarao chamada de assinatura do mtodo. A assinatura do mtodo mostra
de onde o mtodo pode ser acessado, o que o mtodo retorna, o nome do mtodo
e os parmetros que eventualmente o mtodo recebe, sem dizer o que o mtodo
faz. Ela mostra apenas o que necessrio saber para acessar o mtodo.
Um mtodo em uma interface implicitamente pblico (public) e abstrato

(abstract). No podem ser privados (private) nem protegidos (protected).
Mtodos abstratos so mtodos sem corpo que obrigatoriamente tero que ser
implementados em uma classe concreta que implementa a interface. Mtodos
pblicos so aqueles que podem ser acessados de qualquer outra classe da
aplicao. Como implicitamente todos os mtodos em uma interface so
pblicos e abstratos, ento no necessrio escrever isso explicitamente. Logo,
a declarao de mtodo acima pode ser escrita apenas da seguinte forma:

double calcularMedia(double n1, double n2);
}
Ao contrrio das classes simples, uma interface nunca poder ser instanciada,
por isso, no pode conter um construtor, j que o construtor utilizado para
instncia de objetos. Voc instancia a classe que implementa a interface, no
a interface em si.
Para uma classe implementar a interface, ela deve ter, na linha da sua
declarao, a instruo implements. Veja o exemplo:
public class Professor implements Operacoes {
@Override
public double calcularMedia(double n1, double n2) {
return (n1+n2)/2;
}
}
Veja que por implementar a classe Operacoes.java, a classe Professor.java

foi OBRIGADA a implementar o mtodo calcularMedia, ou seja, a construir
o corpo do mtodo.
Acima da declarao do mtodo implementado, aparece a instruo @Override,
que indica que o mtodo foi sobrescrito, ou seja, sua apario na classe concreta
sobrepe a existncia do mtodo sem corpo assinado na interface.
NOTA
Sobrescrita de mtodo ocorre em duas situaes:

1. Quando um mtodo escrito em uma interface ou classe abstrata
e reescrito nas classes que implementam a interface ou que herdam a
classe abstrata.
2. Quando um mtodo escrito em uma superclasse nas relaes de
herana simples e reescrito nas subclasses, normalmente para realizar
operaes diferentes.
A sobrescrita de mtodos necessria para se conseguir polimorfismo.
O diagrama de classes que mostra a relao entre a classe Professor.java e a

interface Operacoes.java mostrado na Figura 4.8:
Figura 4.8: Diagrama de classe com interfaces.
Note que, para indicar que a classe implementa a interface, utilizou-se uma
linha tracejada com seta apontando para a interface. Acima do nome da interface
foi utilizado o esteretipo <<interface>>. Um esteretipo, neste caso, uma
palavra que identifica uma categoria especial de classe.
As interfaces podem ser implementadas por diversas classes. Alis, esta uma
das grandes finalidades das interfaces, centralizar operaes obrigando diversas
classes que necessitam destas operaes a implement-las. Por exemplo, voc
pode centralizar a operao de login de um sistema em uma interface Login.
java e obrigar as classes Funcionario.java, Cliente.java e Fornecedor.java a
implementar a operao de login assinada na interface.
Uma classe pode implementar diversas interfaces. Por exemplo, se a classe
Professor.java deseja implementar as interfaces Operacoes.java e Aulas.java,
sua declarao deve ser:
public class Professor implements Operacoes, Aulas {
}
Neste caso, no corpo da classe Professor.java devem ser implementados todos

os mtodos assinados nas interfaces Operacoes.java e Aulas.java.
NOTA
Uma interface pode definir uma srie de mtodos, mas nunca conter
implementao deles. Ela s expe o que seus mtodos devem fazer, e
no como eles fazem. Como eles fazem ser definido em uma implementao dessa interface.
Alm de assinaturas de mtodos, interfaces tambm podem conter declarao

de constantes, apesar de no ser muito comum. Veja um exemplo:
public interface NewInterface {

public final double MED=6;
public abstract double calcularMedia(double n1, double n2);
}
4.2.1 Quando utilizar interfaces

Voc normalmente utiliza interfaces em duas situaes:
1 Quando deseja obrigar que um conjunto de classes de diferentes origens
implemente um ou mais mtodos de maneiras diferentes;
2 Quando uma subclasse que j est herdando mtodos e atributos de uma
superclasse em relaes de herana precisa herdar (e implementar) mtodos
de outro lugar. Como Java no permite herana mltipla nas verses
anteriores 8 (na verso 8 j permite), o uso de interfaces, neste caso, pode
ser uma boa alternativa.
4.2.2 Conseguindo polimorfismo com utilizao de

interfaces
Polimorfismo um conceito da orientao a objetos conseguido quando objetos
de um mesmo tipo apresentam formas diferentes, ou seja, comportam-se de
maneiras diferentes, mesmo executando a mesma operao (mtodo).
Segundo Horstmann (2009, p. 369), o polimorfismo indica o princpio de que
o comportamento pode variar com base no tipo real de um objeto.
Se voc pode invocar um mtodo de uma interface por meio de objetos de
classes concretas diferentes, isso significa que o comportamento desta execuo
pode variar com base no tipo real do objeto que est invocando o mtodo.
Neste tpico, vamos montar a aplicao representada no diagrama de classes
mostrado na Figura 4.9 e observar nela o conceito de polimorfismo.
Figura 4.9: Diagrama de classes - conseguindo polimorfismo com interfaces.
Para implementarmos a aplicao mostrada na Figura 4.8, crie um novo

projeto no NetBeans chamado ProjetoInterface. Neste projeto, crie uma
interface chamada Operacoes.java e as classes FuncionarioDiarista.java,
FuncionarioMensalista.java e Principal.java.
Se voc no se recorda como cria classes e interfaces no projeto do NetBeans,
basta clicar com o boto direito do mouse sobre o nome do projeto, selecionar
a opo Novo e, em seguida, Classe Java ou Interface Java.
Aps a criao, seu projeto deve aparecer como mostra a Figura 4.10.
Figura 4.10: Projeto ProjetoInterface criado no NetBeans.
Digite o seguinte cdigo-fonte para a interface Operacoes.java:

1
2
3
public interface Operacoes {

public double calcularSalarioLiquido();
}
Note que nesta interface h a assinatura de apenas um mtodo, apesar de uma

interface poder concentrar a assinatura de diversos mtodos.
Digite o seguinte cdigo-fonte para a classe FuncionarioMensalista.java:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
public class FuncionarioMensalista implements Operacoes {

public FuncionarioMensalista(String nome, double salario) {
this.nome = nome;
}
return nome;
}
this.nome = nome;
}
return salario;
}
}
@Override
public double calcularSalarioLiquido() {
return this.salario this.salario*27.5/100;
}
}
Veja na linha 1 que esta classe implementa a interface Operacoes.java. Isso

faz com que o mtodo calcularSalarioLiquido tenha que ser obrigatoriamente
implementado, ou seja, o mtodo ter que ser reescrito, mas dessa vez, com
corpo. A implementao ocorre nas linhas de 26 29. Este mtodo retorna
o salrio diminudo do percentual de 27.5%. Note na linha 26 a instruo @
Override, que indica que o mtodo existe na interface e est sendo sobrescrito
na classe que implementa a interface.
Os demais aspectos desta classe so comuns. H atributos declarados, um
construtor que recebe parmetros e mtodos setter e getter para os atributos.
Digite o seguinte cdigo-fonte para a classe FuncionarioDiarista.java:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
public class FuncionarioDiarista implements Operacoes{

private double valorDia;
private int diasTrabalhados;
public FuncionarioDiarista(String nome, double valorDia, int diasTrabalhados) {
this.nome = nome;
this.valorDia = valorDia;
this.diasTrabalhados = diasTrabalhados;
}
return nome;
}
this.nome = nome;
}
public double getValorDia() {
return valorDia;
}
public void setValorDia(double valorDia) {
this.valorDia = valorDia;
}
public int getDiasTrabalhados() {
return diasTrabalhados;
}
public void setDiasTrabalhados(int diasTrabalhados) {
33
34
35
36
37
38
39
40
41
this.diasTrabalhados = diasTrabalhados;
@Override
return valorDia*diasTrabalhados;
}
}
Note na linha 1 que esta classe implementa a interface Operacoes.java. Isso

obriga a reescrita do mtodo calcularSalarioLiquido, agora com corpo, o que
feito nas linhas de 36 39. Este mtodo retorna o valor pago pela diria
multiplicado pelo nmero de dias trabalhados pelo funcionrio.
Os demais aspectos da classe so comuns. Veja que so declarados os atributos
nas linhas de 2 4, definido um construtor que recebe parmetros (linhas 6
10) e definidos os mtodos setter e getter para os atributos (linhas 12 34).
Agora que temos as classes implementando a interface, precisamos manipular
dados dos funcionrios por meio de objetos das classes da aplicao. Isto
ser feito a partir da classe principal de inicializao da aplicao, chamada
Principal.java, cujo cdigo-fonte apresentado a seguir:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
String nom;
double sal, valDia, valLiquido;
int diasTrab;
nom = JOptionPane.showInputDialog("Digite o nome do funcionrio
mensalista");
sal = Double.parseDouble(JOptionPane.showInputDialog("Digite o valor do
salrio"));
FuncionarioMensalista fm = new FuncionarioMensalista(nom, sal);
valLiquido = fm.calcularSalarioLiquido();
System.out.println("Funcionrio: " + fm.getNome() + "\nValor lquido a
receber: " + valLiquido);
nom = JOptionPane.showInputDialog("Digite o nome do funcionrio
Diarista");
valDia = Double.parseDouble(JOptionPane.showInputDialog("Digite o valor
do dia trabalhado"));
16
17
18
19
20
21
diasTrab = Integer.parseInt(JOptionPane.showInputDialog("Digite o nmero

de dias trabalhados no ms"));
FuncionarioDiarista fd = new FuncionarioDiarista(nom, valDia, diasTrab);
valLiquido = fd.calcularSalarioLiquido();
System.out.println("Funcionrio: " + fd.getNome() + "\nValor lquido a
receber: " + valLiquido);
Note nas linhas 9 e 10 que so pedidos ao usurio o nome e o salrio e estes

valores so armazenados, respectivamente, nas variveis nom e sal. Na linha 11
instanciado um objeto chamado fm do tipo FuncionarioMensalista.java, por
meio de uma chamada ao construtor desta classe. Veja que este objeto conter
em seus atributos o nome e o salrio do funcionrio. Digamos que para nome
seja digitado Maria e para salrio seja digitado 1000.00, este objeto ter o
formato mostrado na Figura 4.11.
fm
nome
salario
Maria
1000.00
getNome(): String
calcularSalarioLiquido():double
Figura 4.11: Representao do formato do objeto fm.
Na linha 12 o mtodo calcularSalarioLiquido chamado por meio do objeto

fm. O retorno deste mtodo armazenado na varivel valLiquido que
exibida na tela na linha 13. A varivel valLiquido receber o valor 725.0,
pois o mtodo calcularSalarioLiquido retornar o salrio digitado reduzido
de 27.5%.
As linhas de 14 16 solicitam o nome do funcionrio diarista, o valor pago pelo
dia trabalhado e o nmero de dias trabalhados no ms. Os valores digitados
so armazenados, respectivamente, nas variveis nom, valDia e diasTrab.
Na linha 17 instanciado um objeto chamado fd do tipo FuncionarioDiarista.
java, por meio de uma chamada ao construtor desta classe, onde os valores
armazenados nas variveis nom, valDia e diasTrab so passados como
parmetro. Digamos que sejam digitados Joo para nome, 100.00 para valor
do dia trabalhado e 10 para dias trabalhados no ms, este objeto ter o formato
mostrado na Figura 4.12.
fd
nome
valorDia
diasTrabalhados
Joo
100.00
10
getNome(): String
setValorDia(double valorDia): void
getValorDia(): double
setDiasTrabalhados(int diasTrabalhados): void
getDiasTrabalhados(): int
calcularSalarioLiquido():double
Figura 4.12: representao do formato do objeto fd.
Na linha 18 chamado o mtodo calcularSalarioLiquido por meio do objeto

fd. O resultado retornado armazenado na varivel valLiquido e exibido na
linha 19. Veja que a varivel valLiquido, neste caso, receber o valor 1000.00,
pois o mtodo calcularSalarioLiquido retorna o contedo do atributo valorDia
multiplicado pelo contedo do atributo diasTrabalhados.
Aps compilar e executar a aplicao, o que pode ser feito por meio do
pressionamento da tecla F6, sero exibidos na tela os seguintes dados:
Funcionrio: Maria
Valor lquido a receber: 725.0
Funcionrio: Joo
Valor lquido a receber: 1000.0
Observe que os objetos fm da classe FuncionarioMensalista.java e fd da classe

FuncionarioDiarista.java so tambm objetos dos tipos da interface Operacoes.
java, pois estas classes implementam tal interface. Assim, podemos dizer que
fm e fd so objetos do mesmo tipo de interface, o tipo Operacoes.java. Estes
objetos, ao chamarem o mtodo calcularSalarioLiquido, obtiveram como
retorno valores diferentes, pois este mtodo executa operaes diferentes em
cada uma das classes. Quando objetos do mesmo tipo de interface executam
uma mesma operao (mtodo) e obtm resultados diferentes, dizemos que
houve polimorfismo (poli=muitas; morfismo=formas). Os objetos do mesmo
tipo de interface, neste caso, apresentaram mais de uma forma diferente.
NOTA
Polimorfismo o conceito da orientao a objetos que ocorre quando

objetos do mesmo tipo de interface ou de subclasses da mesma superclasse nas relaes de herana executam uma mesma operao e obtm
resultados diferentes, pois as operaes (mtodos) possuem formas diferentes. Isto significa que polimorfismo conseguido apenas com o
uso de herana, implementao de interfaces ou de classes abstratas.
4.2.3 Implementao de mais de uma interface
Uma classe pode implementar diversas interfaces, desde que escreva o corpo
dos mtodos assinados de todas estas interfaces. Para demostrar como isso
possvel, vamos criar uma pequena aplicao com as classes mostradas no
diagrama a seguir:
Figura 4.13: Implementao de mltiplas interfaces.
Crie um novo projeto Java no NetBeans chamado ProjetoNovo. Crie neste

projeto as interfaces InterfaceA.java e InterfaceB.java. Crie tambm as classes
ClasseA.java e Teste.java (classe principal). A Figura 4.14 mostra como deve
estar o projeto aps a criao das classes e interfaces.
Figura 4.14: Projeto no NetBeans utilizando classes e interfaces.
Digite o seguinte cdigo-fonte para a interface InterfaceA.java:

1
2
3
public interface InterfaceA {

public double metodoA();
}
Digite o seguinte cdigo-fonte para a InterfaceB.java:

1
2
3
public interface InterfaceB {

public String metodoB(double valor);
}
Digite o seguinte cdigo-fonte para a ClasseA.java:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class ClasseA implements InterfaceA, InterfaceB {

@Override
public double metodoA() {
return 10.5;
}
@Override
public String metodoB(double valor) {
if (valor <= 10) {
return "Valor vlido";
} else {
return "Valor invlido";
}
}
Note que a ClasseA.java implementou as interfaces InterfaceA.java e

InterfaceB.java, logo, foi obrigada a reescrever (com corpo) os mtodos
metodoA e metodoB de acordo com a assinatura presente nas interfaces.
Digite o seguinte cdigo-fonte para a Teste.java:
1
2
3
4
5
6
7
8
9

ClasseA c = new ClasseA();
double v = c.metodoA();
String x = c.metodoB(10);
System.out.println(x);
System.out.println(v);
}
}
A classe Teste.java a classe principal, por onde foi instanciado um objeto da

ClasseA.java (linha 3) e por meio deste objeto foram acessados os mtodos
metodoA (linha 4) e metodoB (linha 5). O retorno destes mtodos foram
armazenados em variveis e exibido em seguida (linhas 6 e 7).
Nas relaes de herana uma subclasse no pode herdar de mais de uma
NOTA superclasse. J nas relaes com interfaces, uma classe pode implementar mtodos de diversas interfaces, sendo obrigada a implement-los.
4.3 Classes Abstratas

Diferente das interfaces, que podem conter apenas assinaturas de mtodos e
constantes, uma classe abstrata pode conter assinaturas de mtodos, mtodos
implementados, constantes, variveis, construtores e atributos. Mtodos que
contm apenas assinatura so chamados mtodos abstratos e nas classes
abstratas precisam ser declarados com a palavra-chave abstract. Assim como
acontece com as interfaces, uma classe abstrata no pode ser instanciada
diretamente, mas apenas suas subclasses. Deve possuir na sua declarao a
instruo abstract, da seguinte forma:
public abstract class Operacoes {
public abstract void conectar();
public abstract void desconectar();
public void sair(){
System.exit(0);
}
}
Veja neste exemplo que h dois mtodos abstratos (que contm apenas a
assinatura) e um mtodo concreto (implementado).
Classes abstratas, assim como as interfaces, servem apenas como modelo para
classes concretas. Como so modelos de classes, no podem ser instanciadas
diretamente com a instruo new, mas podem ser herdadas por classes concretas
(subclasses). Uma classe pode herdar uma classe abstrata da mesma forma
que uma subclasse herda de uma superclasse nas relaes de herana simples,
utilizando a instruo extends. Veja o exemplo a seguir:
public class ControleCliente extends Operacoes {

@Override
public void conectar() {
// a implementao do mtodo deve ocorrer aqui
}
@Override
public void desconectar() {
// a implementao do mtodo deve ocorrer aqui
}
Note que os mtodos abstratos da classe abstrata Operacoes.java tiveram de ser

implementados na subclasse ControleCliente.java, que herda a classe abstrata.
NOTA
Uma classe abstrata semelhante a uma superclasse nas relaes de herana simples, com a grande diferena de poder ter assinaturas de mtodos, obrigando as subclasses a implement-los, o que no ocorre nas
relaes de herana simples.
4.3.1 Exemplo de aplicao com classes abstratas

Talvez a grande dvida sobre o uso das classes abstratas seja quando utiliz-las.
Imagine uma aplicao onde voc precisa de uma classe que contenha atributos
e/ou mtodos comuns que queira compartilhar com outras classes. Imagine
tambm que tenha mtodos que queira obrigar as subclasses a implementar
de formas diferentes. Neste caso, os mtodos comuns s subclasses so
declarados e escritos (implementados) na classe abstrata e tambm a assinatura
dos mtodos que voc quer que as subclasses sejam obrigadas a implementar.
A diferena do uso de classe abstrata em relao herana simples que na
herana simples voc no obriga as subclasses a implementar nada, pois no
so permitidos mtodos abstratos nas superclasses.
Outra diferena que na herana simples voc pode instanciar objetos da

superclasse, o que no pode ocorrer com classes abstratas.
Neste tpico vamos criar uma pequena aplicao, representada no diagrama

de classes mostrado na Figura 4.15.
Figura 4.15: Diagrama de classes representando classes abstratas.
Neste exemplo, na classe abstrata Funcionario.java, teremos atributos e

mtodos. O mtodo calcularSalarioLiquido um mtodo cuja implementao
a mesma para as subclasses Administrativo.java e Academico.java, por isso,
ser implementado na prpria classe abstrata Funcionario.java. J o mtodo
obterCargo.java ter implementao diferente nas subclasses Administrativo.
java e Academico.java, por isso ser abstrato e ter apenas a assinatura na classe
Funcionario.java, obrigando as subclasses a implement-lo.
Note que no geral parece uma relao de herana comum, porm h diferenas.
Mesmo no digrama de classes, veja que o nome da classe abstrata aparece
em itlico, e as linhas que ligam as subclasses classe abstrata pontilhada.
Para iniciarmos o exemplo mostrado no diagrama, crie um projeto Java no
NetBeans chamado ProjetoAbs com as classes mostradas na Figura 4.16.
Figura 4.16: Projeto no NetBeans chamado ProjetoAbs.
Observe que alm das classes mostradas no diagrama de classes precisaremos

de uma classe principal por onde instanciaremos objetos das subclasses
Administrativo.java e Academico.java para demonstrao de uso dos recursos.
Escreva o cdigo-fonte da classe abstrata Funcionario.java, mostrado a seguir:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public abstract class Funcionario {

private int id;
private String categoria;
private double descontos;
public abstract String obterCargo();
public Funcionario(int id, String nome, String categoria, double
salario, double descontos) {
this.id = id;
this.nome = nome;
this.categoria = categoria;
this.descontos = descontos;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

return nome;
}
this.nome = nome;
}
public String getCategoria() {
return categoria;
}
public void setCategoria(String categoria) {
this.categoria = categoria;
}
return salario;
}
}
public double getDescontos() {
return descontos;
}
public void setDescontos(double descontos) {
this.descontos = descontos;
}

return salario descontos;
}
Note a declarao dos atributos (linhas de 3 7), a assinatura do mtodo abstrato

(linha 9), o construtor da classe (linhas 11 17), os mtodos setter e getter
(linhas de 19 57) e o mtodo calcularSalarioLiquido (linhas 59 61). Como
este mtodo ser comum s subclasses, ele foi implementado subtraindo-se os
descontos do valor do salrio.
Escreva agora o cdigo-fonte da subclasse Administrativo.java, apresentado

a seguir:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
19
public class Administrativo extends Funcionario {

public Administrativo(int id, String nome, String categoria, double
salario, double descontos) {
super(id, nome, categoria, salario, descontos);
}
@Override
public String obterCargo() {
switch (super.getCategoria()) {
case "A":
return "Gerente";
case "B":
return "Contador";
default:
return "Auxiliar";
}
}
Veja na linha 1 que esta classe herda a classe abstrata Funcionario.java.

Note que, por isso, ela ter obrigatoriamente um construtor que recebe
como parmetro os valores necessrios para os atributos da classe abstrata
Funcionario.java. Estes valores so passados para o construtor da classe
abstrata Funcionario.java por meio da instruo super (linha 4).
As linhas de 7 17 implementam obrigatoriamente o mtodo obterCargo,
assinado na classe abstrata. Lembre que a instruo @Override indica que o
mtodo est sendo sobrescrito, s que agora, com corpo.
Escreva agora o cdigo-fonte da subclasse Academico.java, apresentado a
seguir:
1
2
3
4
5
6
7
public class Academico extends Funcionario {

private String areaAtuacao;
public Academico(String areaAtuacao, int id, String nome, String
categoria, double salario, double descontos) {
super(id, nome, categoria, salario, descontos);
this.areaAtuacao = areaAtuacao;
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
}
public String getAreaAtuacao() {
return areaAtuacao;
}
public void setAreaAtuacao(String areaAtuacao) {
this.areaAtuacao = areaAtuacao;
}
@Override
public String obterCargo() {
switch (super.getCategoria()) {
case "A":
return "Pesquisador";
case "B":
return "Professor";
default:
return "Tutor";
}
}
Observe que esta classe herda a classe abstrata Funcionario.java (linha 1), o
que a obriga a criar um construtor (linhas de 5 a 8) e a implementar o mtodo
obterCargo (linhas de 18 28).
Note que o mtodo obterCargo, apesar de ter implementao semelhante nas
subclasses Administrativo.java e Academico.java, retornam valores diferentes,
por isso precisam ser implementados em cada uma das subclasses da classe
abstrata.
Note tambm que o construtor necessrio, pois ele precisa receber parmetros
e pass-los para os atributos da classe abstrata Funcionario.java, o que feito
pela instruo super (linha 6).
Para terminar a aplicao, escreva o cdigo-fonte da classe Principal.java, por
onde instanciaremos os objetos das subclasse Administrativo.java e Acedemico.
java. O cdigo-fonte da classe Principal.java apresentado a seguir:
1
2
3
4

Administrativo adm = new Administrativo(10, "Paulo Cesar", "A",
10678.56, 789.50);
5
6
7
8
9
10
Academico aca = new Academico("Matemtica", 12, "Maria Paula", "B",

8432.20, 521.32);
System.out.println("Nome: " + adm.getNome() + "\n" + "Cargo: " + adm.
obterCargo() + "\n" + "Salrio Lquido: " + adm.calcularSalarioLiquido() +
"\n");
System.out.println("Nome: " + aca.getNome() + "\n" + "Cargo: " + aca.
obterCargo() + "\n" + "Salrio Lquido: " + aca.calcularSalarioLiquido());
Observe que foram instanciados os objetos adm, na subclasse Administrativo.

java (linha 4) e aca, da subclasse Academico.java (linha 5). Em seguida
foram mostrados por meio de cada objeto o nome (por meio de uma
chamada ao mtodo getNome), o cargo (por meio de uma chamada ao
mtodo getCargo) e o salrio lquido (por meio de uma chamada ao mtodo
calcularSalarioLiquido).
Vale lembrar que os objetos adm e aca so tambm objetos da classe abstrata
Funcionario.java, j que os objetos de subclasses so tambm objetos de sua
classe abstrata correspondente. Desta forma, voc poderia encontrar a instncia
destes objetos da seguinte forma:
Funcionario adm = new Administrativo(10, "Paulo Cesar", "A", 10678.56, 789.50);
Funcionario aca = new Academico("Matemtica", 12, "Maria Paula", "B", 8432.20, 521.32);
Veja que a referncia feita classe abstrata Funcionario.java, mas a chamada

feita ao construtor das respectivas subclasses (new). Perceba que adm e aca
so objetos da classe abstrata Funcionario.java e tambm das respectivas
subclasses apontadas pela chamada ao construtor.
Aps concluir a digitao das classes, compile e execute o projeto, por meio
da tecla F6. Aparecer na tela o seguinte resultado:
Nome: Paulo Cesar
Cargo: Gerente
Salrio Lquido: 9889.06
Nome: Maria Paula
Cargo: Professor
Salrio Lquido: 7910.880000000001
NOTA
A chamada ao mtodo obterCargo (que possui implementao diferente nas subclasses), por meio de dois objetos (adm e aca) de subclasses
do mesmo tipo de classe abstrata, configura polimorfismo, j que estes
objetos do mesmo tipo de classe abstrata apresentaro comportamentos
diferentes, principalmente nesta chamada de mtodos.
4.4 Modificadores de visibilidade
Na declarao de um mtodo, varivel ou constante, deve-se indicar de onde

podem ser acessados, se apenas de dentro da prpria classe (private); se de
qualquer classe da aplicao (public); ou se apenas de dentro do pacote ao qual a
classe pertence ou de subclasses ligadas em uma relao de herana (protected).
O que define de onde o recurso (varivel, mtodo ou constante) poder ser
acessado so os modificadores de visibilidade, que so: public, private e protected.
Veja na Tabela 4.1 um resumo da visibilidade destes modificadores:
Modificador
private
public
protected
sem
modificador
Mesma
classe
x
x
x
x
Mesmo
pacote
Subclasses
Todas as
classes
x
x
x
x
x
Tabela 4.1: Modificadores de visibilidade.
4.4.1 Modificador public

O modificador public indica que o recurso poder ser acessado a partir de
qualquer classe da aplicao, inclusive de dentro da prpria classe.
Na UML esse modificador representado pelo sinal de mais (+).
Vamos a um exemplo.
Crie um novo projeto Java com duas classes: Cliente.java e Principal.java.
Escreva na classe Cliente.java, o cdigo-fonte a seguir:
1
2
3
4
5
public class Cliente {

public int id;
public String nome;
public double renda;
6
7
8
9
10
11
12
13
14
15
16
public Cliente() {
}
public double obterRendaAjustada() {
return this.renda + obterValor();
}
public double obterValor() {

return 1000.00;
}
Note que o mtodo obterRendaAjustada (linhas 9 11) chama o mtodo

obterValor (linhas 13 15), que pblico. Veja que um mtodo de uma classe
pode chamar outro mtodo pblico da mesma classe.
Escreva na classe Principal.java, o cdigo-fonte a seguir, que acessa recursos
da classe Cliente.java:
1
2
3
4
5
6
7
8
9
10

Cliente cli = new Cliente();
cli.id = 10;
cli.nome = "Ana Paula";
cli.renda = 2000.00;
System.out.println ("Renda do cliente: " + cli.renda);
System.out.println ("Renda ajustada: " + cli.obterRendaAjustada());
}
}
Observe que como os atributos id, nome e renda da classe Cliente.java so

pblicos, no h necessidade de mtodos setter para acess-los. Bastou
instanciar o objeto cli da classe Cliente (linha 3) e acessar os atributos incluindo
valores neles (linhas 4 6).
Para exibir a renda (linha 7), bastou indicar o atributo do objeto onde estava
armazenado o valor da renda, sem a necessidade de obter o valor por meio de
um mtodo getter. Onde teramos que digitar cli.getRenda() se o atributo renda
fosse privado e tivesse um mtodo getter para ele, bastou digitar cli.renda (linha
7). O acesso direto, pois renda um atributo pblico na classe Cliente.java.
Para exibir a renda ajustada, o mtodo obterRendaAjustada da classe Cliente.java
foi chamado por meio do objeto cli (linha 8). Este mtodo pde ser chamado a
partir da classe Principal.java porque pblico na classe Cliente.java.
Ao executar a aplicao, pressionando a tecla F6, aparecer na tela o seguinte

resultado:
Renda do cliente: 2000.0
Renda ajustada: 3000.0
NOTA
Apesar de voc poder declarar os atributos de uma classe como pblicos, como viu no exemplo apresentado, isso no comum nem indicado, pois outros objetos poderiam, em algumas circunstncias, ter acesso
ao contedo dos atributos, j que so pblicos. O ideal sempre declarar os atributos da classe como privados e criar mtodos getter e setter pblicos para eles.
4.4.2 Modificador private

O modificador private permite que o recurso seja acessado somente de dentro da
prpria classe. Na UML esse modificador representado pelo sinal de menos (-).
Para testar o modificador private, crie um novo projeto no NetBeans com duas
classes: Calculo.java e Teste.java.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
private final double IR=27.5;
public Calculo() {
}
private double obterPercentual(){
return Double.parseDouble (JOptionPane.showInputDialog ("Digite o valor do
percentual: "));
}
public double ajustarSalario(double salario){

return (salario + salario * obterPercentual()/100) - (salario * IR/100);
}
Veja que na linha 4 foi criada a constante privada IR do tipo double contendo
o valor 27.5. Como sabe, no ser possvel, na aplicao, mudar o valor
armazenado, pois trata-se de uma constante. A palavra final quem define que
se trata de uma constante.
Nas linhas de 9 11 foi criado o mtodo privado obterPercentual. Por ser
privado, este mtodo s poder ser chamado de dentro desta classe. A chamada
a este mtodo ocorre da linha 14, do interior do mtodo ajustarSalario. O
mtodo obterPercentual solicita um percentual, converte em double e retorna.
Veja que o mtodo ajustarSalario pblico, assim, poder ser chamado a

partir de outras classes da aplicao. Este mtodo recebe um valor de salrio
do tipo double, aplica o percentual de aumento obtido na chamada ao mtodo
obterPercentual, subtrai o desconto de imposto contido na constante IR e
retorna o resultado.
Na classe principal Teste.java, digite o seguinte cdigo-fonte:
1
2
3
4
5
6
7
8
double salario = Double.parseDouble (JOptionPane.showInputDialog
("Digite o valor do percentual: "));
Calculo c = new Calculo();
System.out.print ("Salrio Lquido: " + c.ajustarSalario(salario));
}
}
Na linha 4 pedido um valor de salrio, convertido em double e armazenado

na varivel salario.
Na linha 5 instanciado um objeto da classe Calculo.java chamado c. Por meio
deste objeto, na linha 6, chamado o mtodo pblico ajustarSalario da classe
Calculo.java e passado como parmetro o valor do salrio. Veja que s possvel
chamar o mtodo ajustarSalario a partir da classe Teste.java porque ele pblico.
Voc no conseguiria, por exemplo, chamar o mtodo obterPercentual, pois
ele privado. Nem poderia acessar a constante IR, pois ela tambm privada.
4.4.3 Modificador protected

O modificador protected permite que o recurso seja acessado de dentro da
mesma classe, de qualquer classe que esteja no mesmo pacote da classe que
contm o recurso e de subclasses da classe que contm o recurso em uma
relao de herana. Na UML, esse modificador representado pelo sinal de
cerquilha (#). Este modificador ser explicado em mais detalhes no prximo
captulo, quando sero apresentados exemplos de uso de herana de classes.

Apenas para voc entender como se utiliza este modificador, segue um exemplo
de um mtodo declarado como protected:
protected int obterCodigo() {
return 10;
}
Voc tambm pode declarar atributos protegidos. Veja o exemplo:
protected String nome;
NOTA
No Java, um recurso protegido (protected) pode ser acessado de classes do mesmo pacote em que est a classe que contm o recurso e de
subclasses em uma relao de herana. Porm, na maioria das demais
linguagens orientadas a objeto, um recurso protegido s poder ser acessado de subclasses em uma relao de herana.
4.4.4 Sem modificador

Na ausncia de um modificador, o recurso poder ser acessado apenas de
dentro da prpria classe e de classes que esto no mesmo pacote. Veja como
se declara um mtodo sem modificador:
double soma( double a, double b){
return a+b;
}
Veja como se declara um atributo sem modificador:

String nome;
double salario;
4.5 Garbage collector

Quando voc instala o Java, integrado na Java Runtime Environment (JRE),
existe um componente chamado Garbage Collector, que responsvel por
coletar da memria objetos e dados que esto sendo mais usados. Assim, em
Java, o programador no precisa se preocupar em alocar e desalocar memria
quando lida com objetos, como acontece na linguagem C ou C++. Quando
no precisamos mais de um objeto, basta anular sua referncia elegendo-o a
ser coletado (liberado da memria) pelo Garbage Collector.
Veja o exemplo a seguir:

Funcionrio func;
func = new Funcionrio(1367, "Paulo Henrique", "Gerente", 789.56);
func=null;
Quando o objeto func torna-se nulo, ele vira candidato a ser desalocado da
memria pelo Garbage Collector.
Tipos primitivos (char, byte, short, int, long, float, double e boolean)
NOTA alocados dentro de um mtodo no so liberados da memria pelo
Garbage Collector.
4.6 Anotaes
Anotaes (ou annotations, em ingls) so instrues iniciadas pelo caractere
arroba (@) que podem fornecer informaes sobre o cdigo Java (seja sobre
um mtodo ou uma classe) e, apesar de muitas vezes se assemelharem a
comentrios, podem ser interpretadas pelos compiladores.
Algumas anotaes comuns utilizadas em Java so @Deprecated e @Override.
@Deprecated uma anotao colocada na linha anterior declarao de um
mtodo para indicar que seu uso desencorajado por ser perigoso ou por ter
uma alternativa melhor j desenvolvida.
@Override uma anotao colocada na linha anterior declarao de um
mtodo para indicar que ele est sendo sobrescrito, ou seja, que existe este
mtodo em uma superclasse e ele est sendo escrito de outra forma na subclasse.
Esta anotao normalmente utilizada em aplicaes que utilizam classes
relacionadas por herana onde se deseja obter polimorfismo.
Existem inmeras outras anotaes relacionadas a tecnologias Java especficas,
principalmente sobre Java EE (Enterprise Edition).
4.7 Resumo
As relaes de herana na programao orientada a objetos podem ocorrer de
vrias maneiras e utilizando vrios recursos, como herana simples, interfaces
e classes abstratas.
Voc deve utilizar herana na sua forma pura e simples quando tem um
conjunto de atributos e/ou mtodos comuns que deseja que vrias subclasses
compartilhem. Para no repetir essa parte comum nas subclasses da relao de
herana, centralize-os na superclasse e herde-os nas subclasses. As subclasses
podero ter, alm dos recursos herdados, seus prprios recursos (atributos,
mtodos etc.). Uma subclasse pode herdar de apenas uma superclasse. No
h herana mltipla em Java antes da verso 8, porm, a verso 8 j permite
herana mltipla. As subclasses tambm podem ser superclasses de outras
subclasses, em cadeias de herana.
Voc deve utilizar interfaces quando deseja obrigar que um conjunto de classes
implementem os mesmos mtodos, porm, de maneiras diferentes. Estas classes
tambm podero implementar seus prprios mtodos especficos.
As interfaces estabelecem um contrato em que as classes que implementam as

interfaces devem aceitar, implementando os mtodos assinados nas interfaces.
Os mtodos nas interfaces so, por padro, pblicos e abstratos, no podendo
ser declarados de outra forma.
Voc deve utilizar classes abstratas quando tem um conjunto de atributos e/ou
mtodos comuns que deseja que vrias subclasses compartilhem (como nas
relaes de herana), e tambm quer que estas subclasses sejam obrigadas
a implementar certos mtodos de maneiras diferentes. As classes abstratas
representam uma mistura entre os recursos providos pelas relaes de herana
simples e pelas interfaces. Classes abstratas podem ter variveis, mtodos
abstratos, mtodos implementados, construtores, atributos e constantes.
Tanto as interfaces quanto as classes abstratas no podem ser instanciadas
diretamente. Voc deve instanciar sempre as subclasses ligadas a elas.
Nas relaes de herana simples, com interfaces e com classes abstratas,
normalmente voc tem um mesmo mtodo em vrias subclasses implementado
de maneiras diferentes. Objetos dessas subclasses que chamam estes mtodos
normalmente obtm resultados diferentes. Esta uma das caractersticas que
permite obter o que chamamos na orientao a objetos de polimorfismo (objetos
do mesmo tipo, mas com formas/comportamentos diferentes).
Em uma aplicao, normalmente criamos diversas classes que se comunicam
normalmente por meio da criao de objetos umas das outras. A partir de um
objeto de uma classe, possvel acessar seus mtodos, desde que o modificador
de visibilidade permita. Os modificadores de visibilidade definem de onde
mtodos, variveis e constantes (recursos) de uma classe podem ser acessados.
Se o recurso possuir o modificador public, o recurso poder ser acessado de
qualquer classe da aplicao. Se possuir o modificador private, s poder ser
acessado do interior da prpria classe. Se possuir o modificador protected, s
poder ser acessado a partir de classes que esto no mesmo pacote da classe que
contm o recurso ou de subclasses de uma classe em uma relao de herana.
Se no possuir modificador, poder ser acessado somente de dentro da prpria
classe e de classes que estejam no mesmo pacote da classe que contm o recurso.
4.8 Exerccios
Voc encontrar a seguir exerccios prticos, onde precisar criar projetos e
escrever o cdigo-fonte de vrias classes e exerccios para fixar os conceitos
tericos do Captulo. No deixe de resolv-los e esclarecer dvidas com seu
professor, caso voc seja um estudante de ensino tcnico ou superior.

1) Crie um projeto Java e implemente as classes mostradas no diagrama de
classes a seguir. Implemente os mtodos setter e getter para os atributos, e o
mtodo validarDocumento em cada uma das classes. Este mtodo deve apenas
retornar true ou false. Implemente tambm o mtodo escreverNome na classe
Pessoa.java. Esse mtodo deve apenas imprimir o nome da pessoa em uma
caixa de dilogo.
Crie uma classe principal, cadastre uma pessoa fsica e exiba o nome dela por
meio do mtodo escreverNome.
<<interface>>
Validador
validarDocumento() : Boolean
Pessoa
nome : String
escreverNome()
Fisica
Juridica
cnpj : String
cpf : String
escreverNome()
escreverNome()
2) Implemente as classes mostradas no diagrama de classes a seguir. Para

cada uma das classes voc deve definir pelo menos um atributo e gerar os
mtodos getter e setter para eles. Implemente o mtodo getValor em cada
uma das classes. Nas subclasses, este mtodo deve calcular o valor do aluguel
do filme de maneiras diferentes. Crie uma classe principal e cadastre um
filme de cada categoria (normal, infantil e lanamento), calculando o valor
do aluguel e exibindo na tela.
Filme
+ getValor(diasAluguel: int) : double
FilmeNormal
FilmeInfantil
FilmeLanamento

1) Um desenvolvedor Java tem trs classes declaradas em uma aplicao: A,
B e C. Na classe A deseja colocar os atributos que so comuns s classes B e
C e tambm implementar os mtodos que so comuns a estas classes. Porm,
deseja colocar na classe A um mtodo que no deseja implementar, mas que
quer obrigar as classe B e C a implement-lo. Baseado nestes dados, qual
o melhor recurso a utilizar, herana simples, interface ou classe abstrata?
Justifique sua resposta.
2) Em uma aplicao de acesso a banco de dados, os mtodos salvar, consultar,
excluir e alterar devero ser implementados no mdulo de clientes, de produtos e
de funcionrios, porm, de maneiras diferentes. Qual o melhor recurso a utilizar,
uma interface, uma classe abstrata ou herana simples? Justifique sua resposta.
3) Quando em uma aplicao poder ocorrer polimorfismo? Que tipo de recurso
deve haver nessa aplicao para que seja conseguido polimorfismo?
4) Qual a diferena entre sobrescrita de mtodos e sobrecarga de mtodos?
5) O que pode e o que no pode conter uma classe abstrata?
6) O que permitido em uma interface?
7) Qual a diferena entre classe abstrata e interface?
8) Podemos considerar que o uso de classe abstrata ou interface prov herana

na aplicao? Justifique sua resposta.
9) possvel implementar herana mltipla em Java? Justifique sua resposta.
10) O que so anotaes?
11) Qual a finalidade do Garbage Collector?
12) O que significa a anotao @Override na linha anterior declarao de

um mtodo?
13) Qual o papel do comando super em uma subclasse em aplicaes que
contm relaes de herana?
14) Quais instrues so utilizadas para indicar que uma classe herda outra e
que implementa os mtodos abstratos de outra?
15) Considere que a C herda a classe A e ambas possuem um construtor vazio
padro. Nestas condies, a instruo abaixo, contida no mtodo main de uma
classe principal da aplicao est correta? Justifique sua resposta.
A obj = new C();
16) Uma classe pode implementar mais de uma interface? Justifique sua resposta.
17) Quando uma classe implementa uma interface, o que ela ser obrigada a fazer?
18) O que um mtodo abstrato e em que tipos de classes eles podem aparecer?
19) Explique as diferenas entre os modificadores de visibilidade public,
private, protected?
5. Mtodos estticos e
tratamento de excees
Para acessar os mtodos pblicos de uma classe necessrio instanciar um
objeto desta classe, correto?
Est correto desde que o mtodo no seja esttico. Mtodos estticos podem
ser acessados diretamente a partir do nome da classe, sem precisar de instncia
de objetos desta classe.
Programar usando mtodos estticos, de certa forma, faz perder a caracterstica
principal da orientao a objetos, que acessar recursos das classes por
meio de objetos destas classes. O uso de mtodos estticos e tipos de dados
primitivos fazem com que Java no seja considerada por muitos profissionais
uma linguagem totalmente orientada a objetos. Em uma linguagem totalmente
orientada a objetos, os recursos (mtodos, atributos, variveis, constantes) s
podem ser acessados a partir da instncia de um objeto da classe que contm
o recurso.
Esse assunto renderia um captulo a parte, por isso, vamos deixar estas
discusses de lado e vamos entender como podemos aproveitar os mtodos
estticos nas nossas aplicaes.
O caso principal de uso de mtodos estticos em uma aplicao para
criar bibliotecas de classes de apoio cujos mtodos podero ser acessados
diretamente, sem instncia de objetos. Assim, de qualquer classe da aplicao
voc poder chamar os mtodos estticos das classes includas na biblioteca
do projeto. Veremos isso em um exemplo que ser apresentado no decorrer
deste captulo.
Alm de apresentar os mtodos estticos, sero apresentadas ainda as principais
formas de realizar tratamento de excees em Java. Excees so entradas no
esperadas nos mtodos, arrays e outras estruturas da aplicao. Por exemplo,
quando a aplicao est esperando e digitao do valor do salrio e o usurio
digita seu nome, ocorrer uma exceo, pois a aplicao est esperando um
valor double, mas entrou um valor String. Outro exemplo comum quando
voc tem, por exemplo, uma array com 3 posies numeradas de 0 2. Se voc
tentar, por engano, incluir um valor em uma posio que no existe, ocorrer
uma exceo. Existem inmeros outros casos em que excees podem causar
srias interrupes na execuo do programa e comprometer todo o sistema.
Para que isso no ocorra, as excees precisam ser tratadas de forma que se
ocorrerem o programa possa contorn-las com o menor impacto possvel.
No decorrer deste captulo sero apresentados exemplos de tratamento das
principais excees.
5.1 Mtodos Estticos

Mtodos estticos so mtodos que podem ser acessados diretamente por meio
do nome da classe, sem precisar instanciar objetos desta classe. Todo mtodo
esttico possui na sua declarao a palavra static.
Existem duas categorias de classes com mtodos estticos: as que vm

instaladas com o Java e as criadas pelo desenvolvedor da aplicao.
As classes de apoio que so instaladas com o Java possuem mtodos estticos
que podem ser chamados na aplicao para auxiliar o programador oferecendo
diversas operaes j implementadas, evitando que ele tenha que reinventar
a roda.
Alm dessas classes, voc pode criar suas prprias classes de apoio com
mtodos estticos que necessita chamar de diversas classes da aplicao de
forma fcil e rpida. Nos prximos tpicos sero apresentadas estas duas
categorias de classes.
5.1.1 Utilizando mtodos estticos de classes das

bibliotecas que fazem parte do Java
Quando voc instala o Java no computador, so instaladas uma srie de pacotes
de classes que fazem parte de bibliotecas do Java que voc pode utilizar como
apoio para desenvolver suas aplicaes.
Usamos com frequncia mtodos estticos de classes contidas nestes pacotes.
Por exemplo, usamos muito os mtodos estticos da classe Math.java,
destinados a resolver operaes matemticas e trigonomtricas. Veja um
exemplo:
double b = Math.pow(10,3);
Esta operao calcula 103, logo, a varivel b receber o valor 1000.00. Note
que o mtodo pow da classe Math.java chamado diretamente por meio do
nome da classe. Veja como este mtodo escrito na classe Math.java:
public static double pow (double a, double b){
return StrictMath.pow(a,b);
}
Perceba o uso da palavra static na declarao do mtodo. Observe ainda que

este mtodo ainda aponta para outro, da classe StrictMath.java.
No NetBeans, no mtodo main de uma classe principal, digite Math seguido

do ponto final, que voc ver os mtodos e constantes disponveis na classe
Math.java. Veja na Figura 5.1 alguns dos mtodos estticos da classe Math.
java.
Figura 5.1: Mtodos estticos da classe Math.java.
Sempre que digitar o nome de uma classe que possui mtodos e/ou constantes
acessveis, estes mtodos/constantes aparecero em uma lista para que voc
possa escolh-los, ao invs de digit-los. Este um recurso do NetBeans para
facilitar a vida do desenvolvedor.
Outros exemplos que utilizamos anteriormente foram os mtodos estticos
da classe JOptionPane.java, que vem instalada no pacote javax.swing, que
estudaremos no Captulo 6. Veja um exemplo de uso do mtodo esttico
showInputDialog desta classe:
String c = JOptionPane.showInputDialog( "Digite o nome da cidade");
}
}
Note que o mtodo showInputDialog foi chamado diretamente pelo nome da

classe JOptionPane, logo, podemos concluir que este mtodo esttico. Veja
como este mtodo est escrito na classe JOptionPane.java:
public static String showInputDialog(Object message)
throws HeadlessException {
return showInputDialog(null, message);
}
Veja a seguir outros exemplos para:

1 Converter um valor String para double:
String sal="12678.56";
double d = Double.parseDouble(sal);
Note que foi chamado o mtodo esttico parseDouble da classe Double.java.

Este mtodo est escrito na classe Double.java da seguinte forma:
public static double parseDouble(String s) throws NumberFormatException {
return FloatingDecimal.readJavaFormatString(s).doubleValue();
}
2 Converter um valor int para String:

int i=10;
String j= String.valueOf(i);
Veja que foi chamado o mtodo esttico valueOf da classe String.java. Observe
como este mtodo est escrito na classe String.java:
public static String valueOf(int i) {
return Integer.toString(i);
}
5.1.2 Utilizando mtodos estticos de classes

criadas pelo desenvolvedor
Voc pode criar classes com mtodos estticos que utiliza constantemente, e
utilizar como apoio nas suas aplicaes. Vamos a um exemplo prtico.
Crie um projeto Java no NetBeans chamado ProjetoStatic. Crie uma classe
chamada Calculo.java, em um pacote chamado calc.mat. Crie tambm uma
classe chamada Principal.java no pacote padro. Veja na Figura 5.2 como deve
estar seu projeto aps realizar estes procedimentos.
Figura 5.2: Projeto ProjetoStatic criado no NetBeans.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
package calc.mat;
public static double soma(double a, double b) {
return a + b;
}
public static double soma(double a, double b, double c) {
return a + b + c;
}
public static int soma(int a, int b) {
return a + b;
}
public static String obterInfo() {
return "Esta uma classe teste";
}
public static double mult(int a, int b) {

return a * b;
}
Note que h vrios mtodos, todos estticos, que executam tarefas especficas.
Note que vrios destes mtodos possuem o mesmo nome, mas recebem
parmetros diferentes. O nome disto sobrecarga de mtodos, lembra? J
discutimos isso em captulos anteriores.
NOTA
Na mesma classe podem haver mtodos estticos e no estticos. A diferena ser apenas a forma de acesso. Para acessar os mtodos estticos,
basta digitar o nome da classe, o ponto final e o nome do mtodo. Para
acessar os mtodos no estticos, ser necessrio instanciar um objeto da
classe e fazer o acesso por meio deste objeto.
Para acessarmos os mtodos da classe criada, utilizaremos a classe Principal.

java, cujo cdigo-fonte apresentado a seguir:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import calc.mat.Calculo;

double a = Calculo.mult(10, 20);
System.out.print("Informaes sobre a classe:" +
Calculo.obterInfo());
System.out.print(Calculo.soma(10.5, 20.6));
double c = Calculo.soma(2.1, 3.4, 10.9);
int d = Calculo.soma(3, 4);
int s = calc.soma(10,2);
System.out.print(s);
}
Veja na linha 1 que a classe Calculo.java foi importada do pacote calc.mat.

Isto foi necessrio porque a classe Principal.java no est no mesmo pacote
da classe Calculo.java.
Note que, para acessar os mtodos estticos, digitou-se o nome da classe
(Calculo), o ponto final e o nome do mtodo, passando os parmetros necessrios.
Como h diversos mtodos com o mesmo nome na classe Calculo.java, ao
chamar o mtodo o interpretador sabe qual chamar pelos parmetros passados.
Note uma particularidade nas linhas 11 e 12. Veja que foi instanciado um objeto
da classe Calculo.java chamado calc (linha 11) e, por meio deste objeto, foi
chamado o mtodo esttico soma (linha 12). Isso no necessrio nem indicado,
j que o mtodo soma esttico, porm, possvel. O correto mesmo fazer
como na linha 10.
5.1.3 Utilizando mtodos estticos na classe

principal
Voc pode criar mtodos estticos dentro da classe principal, e cham-los do
interior do mtodo main, que tambm esttico. Esta forma de uso no muito
comum, j que o mtodo main da classe principal normalmente utilizado
para acessar recursos de outras classes. Desta forma, o ideal colocar os
mtodos estticos em outra classe e cham-los do interior do mtodo main,
como fizemos no tpico anterior.
Apesar de no ser a forma mais indicada de uso, vamos conferir no exemplo

a seguir como acessar do interior do mtodo main mtodos estticos criados
na prpria classe principal.
Crie um projeto no NetBeans e crie uma classe principal chamada Teste.java.
Nessa classe, digite o seguinte cdigo-fonte:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

double s = somar(10.5, 30.0);
System.out.println ("O resultado da soma : " + s);
double m = multiplicar(5.0, 4.0);
System.out.println ("O resultado da multiplicao : " + m);
}
public static double somar(double a, double b) {
return a + b;
}
public static double multiplicar(double a, double b) {

return a * b;
}
Execute o projeto pressionando a tecla F6.

Veja que na linha 2 feita uma chamada do mtodo somar que est na linha
9. Na linha 5 chamado o mtodo multiplicar que est na linha 13. O retorno
desses mtodos armazenado em variveis e exibidos nas linhas 4 e 6.
5.1.4 Criando uma biblioteca de classes com

mtodos estticos
O uso mais comum de mtodos estticos ocorre como ser mostrado a seguir.
Normalmente voc cria bibliotecas de classes na forma de um arquivo com
extenso .jar e coloca nelas mtodos estticos utilizados com muita frequncia
nas suas aplicaes.
Uma biblioteca criada em um projeto Java do NetBeans. O nome da biblioteca
ser o mesmo nome do projeto.
Para mostrar como funciona a criao de bibliotecas de classe com mtodos

estticos, crie um projeto chamado Matematica e crie nele duas classes
Multiplica.java e Soma.java, no pacote calc.mat, conforme mostra a Figura 5.3.
Figura 5.3: Projeto no netBeans para mostrar a criao de bibliotecas de classes.
O cdigo-fonte da classe Soma.java apresentado a seguir:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package calc.mat;
public class Soma {
public static double soma(double a, double b) {
return a + b;
}
public static double soma(double a, double b, double c) {
return a + b + c;
}
public static int soma(int a, int b) {

return a + b;
}
O cdigo-fonte da classe Multiplica.java apresentado a seguir:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package calc.mat;
public class Multiplica {
public static double mult(int a, int b) {
return a * b;
}
public static double mult(double a, double b) {
return a * b;
}
public static int mult(int a, int b, int c) {

return a * b;
}
Agora que voc j digitou o cdigo-fonte das duas classes, vamos gerar a
biblioteca. Para isso, ter que compilar a aplicao e gerar um arquivo de
distribuio que ter o mesmo nome do projeto, mas com a extenso .jar. Clique
no menu Executar e na opo Limpar e Construir Projeto (Matematica).
Ser gerado o arquivo Matematica.jar na subpasta dist, contida na pasta do
projeto. O caminho provavelmente ser \Matematica\dist\Matematica.jar.
Nossa biblioteca o arquivo Matematica.jar.
Para usar a biblioteca criada, vamos iniciar um novo projeto Java chamado
NovoProjeto. Nesse projeto, crie uma classe principal chamada Principal.java.
Clique na pasta Biblioteca do projeto com o boto direito do mouse e
selecione a opo Adicionar Jar/Pasta, como mostra a Figura 5.4.
Figura 5.4: Adicionando uma biblioteca JAR na pasta Bibliotecas do projeto Java
criado com o NetBeans.
Selecione a biblioteca Matematica.jar na pasta dist do projeto da biblioteca (\

Matematica\dist\Matematica.jar) e clique no boto Abrir.
Clique no sinal de mais esquerda da pasta Bibliotecas, no sinal de mais

esquerda da biblioteca Matematica.jar e no sinal de mais esquerda do pacote
calc.mat. Voc ver as classes da biblioteca, conforme mostra a Figura 5.5.
Figura 5.5: Exibio das bibliotecas de classes do projeto criado com o uso do NetBeans.
Na classe Principal.java da nossa aplicao, vamos chamar os mtodos

estticos das classes Multiplica.java e Soma.java da nossa biblioteca. Veja
na Figura 5.5 que estas classes, compiladas, aparecem com extenso .class.
Na classe Principal.java, digite o seguinte cdigo-fonte:
1
2
3
4
5
6
7
8
9
10
11
12
import calc.mat.Multiplica;
import calc.mat.Soma;

double m = Multiplica.mult(10.5, 2.3);
double n = Soma.soma(2.1, 3.0, 4.3);
System.out.print("Resultado da multiplicao: " + m);
System.out.print("Resultado da soma: " + n);
}
Note nas linhas 7 e 8 que so chamados os mtodos das classes que esto na
biblioteca do projeto, diretamente pelo nome da classe, afinal, os mtodos so
estticos.
5.2 Tratamento de Excees

Uma exceo um comportamento inesperado do programa causado
normalmente por uma entrada no esperada do usurio ou por falha do
programador na passagem de parmetros para um mtodo, na referncia a
recursos no disponveis etc. Para evitar que as excees causem paradas
no sistema, necessrio trat-las, para que, se ocorrerem, causem o menor
transtorno possvel. Em Java possvel tratar as excees utilizando as estruturas
try...catch e throws. Estas estruturas sero apresentadas nos prximos tpicos.
5.2.1 Tratamento de Excees com try...catch

O tratamento de excees com try...catch trata o problema, sem passar a
responsabilidade pela resoluo a quem chamou o mtodo onde a exceo
ocorreu. Voc utiliza try...catch quando sabe como tratar a exceo. Se no
sabe, utilize o throws, que passa a responsabilidade pelo tratamento a quem
chamou o mtodo que gerou a exceo. A sintaxe da estrutura try...catch
apresentada a seguir:
try {
// linha(s) que podem causar a exceo
}
catch (Classe_que_vai_tratar_a_exceo objeto_da_classe)
{
//O que deve acontecer se a exceo ocorrer
}
O interpretador tenta executar as linhas que esto no interior das chaves do

try. Se no conseguir devido a uma exceo, desvia para o catch, executando
as linhas que esto no interior das chaves.
Vamos a um exemplo prtico para entender melhor o uso do try...catch.
Crie um projeto no NetBeans e uma classe Principal.java nesse projeto.
Digite o cdigo-fonte a seguir na classe Principal.java:
int a=2;
int b=0;
int c=a/b;
}
}
O cdigo vai gerar uma exceo, voc sabe qual ?

isso mesmo, no possvel dividir um nmero inteiro por zero.
Execute o projeto pressionando F6 que ser apresentada a mensagem de erro

mostrada na Figura 5.6.
Figura 5.6: Exceo ArithmeticException.
Veja na mensagem que j aparece o nome da classe que deve ser utilizada no
catch para tratar a exceo, a classe ArithmeticException, e tambm a descrio
do erro /by zero.
Para evitarmos que a exceo cause o erro mostrado na Figura 5.6, altere o
cdigo-fonte da classe Principal.java para:
int a = 2;
int b = 0;
try {
int c = a / b;
} catch (ArithmeticException x) {
System.out.println("No possvel dividir por zero");
}
}
}
Execute o projeto novamente, pressionando a tecla F6, que voc ver a

mensagem No possvel dividir por zero.
Este tratamento de exceo poderia estar em um mtodo, da seguinte forma:
public void dividir(int a, int b){
try {
int c = a / b;
} catch (ArithmeticException x) {
System.out.println("No possvel dividir por zero");
}
}
}
Neste exemplo, a clusula catch recebe como parmetro um objeto da classe

ArithmeticException contendo os dados do erro.
Quando uma exceo gerada, o catch recebe um objeto da classe referente

exceo, contendo dados sobre a exceo. No exemplo acima, o objeto v
possui informaes sobre a exceo. Se voc quiser, dentro do catch, ver a
mensagem de erro, basta digitar:
System.out.println(v.getMessage());
Outros dados do erro podem ser obtidos por meio deste objeto.
Vamos a outro exemplo prtico.
Crie um novo projeto Java no NetBeans e digite o seguinte cdigo-fonte na

classe Principal.java:
int idade = Integer.parseInt(JOptionPane.showInputDialog("Digite sua
idade"));
}
}
Suponhamos que o usurio digite o valor mostrado na Figura 5.7, quando o

programa for executado:
Figura 5.7: Entrada de valor que gerar a exceo NumberFormatException.
Voc sabe que exceo ser gerada ao clicar no boto OK?

Ser gerada a exceo mostrada na Figura 5.8, devido a tentativa de converter
a String digitada em valor inteiro:
Figura 5.8: Exceo NumberFormatException.
Veja que j aparece o nome da classe NumberFormatException que ser usada

no catch para o tratamento da exceo, e tambm a mensagem de erro For
input String : 30 anos.
A exceo foi gerada porque houve uma tentativa de converter o valor String
digitado (30 anos) para inteiro.
Para tratar a exceo, ajuste o cdigo-fonte da classe Principal.java para ficar
da seguinte forma:
try{
int idade = Integer.parseInt(JOptionPane.showInputDialog("Digite sua
idade"));
} catch(NumberFormatException e){
JOptionPane.showMessageDialog(null, "Digite apenas nmeros no
campo idade");
}
}
}
Se voc executar novamente o projeto e digitar no campo o mesmo valor (30

anos) digitado anteriormente, ver uma caixa de dilogo com a mensagem
Digite apenas nmeros no campo idade.
Vamos a outro exemplo prtico, apresentado na classe Principal.java, a seguir:
nomes[0] = "Ana";
nomes[1] = "Paulo";
nomes[2] = "Pedro";
}
}
Ao executar o projeto, ser gerada uma exceo, voc sabe qual ?

Veja que se est tentando colocar o nome Pedro em uma posio da array
que no existe, pois as posies vo de 0 1, j que a array tem duas posies
apenas. Aparecer na tela a mensagem mostrada na Figura 5.9.
Figura 5.9: Exceo ArrayIndexOutOfBoundsException.
Veja que a classe que deve ser utilizada no catch para o tratamento da exceo
a classe ArrayIndexOutOfBoundsException.
Para resolver este problema, voc pode alterar a classe da seguinte forma:
0
1
2
3
4
5
6
7
8
9
10
11

try {
nomes[0] = "Ana";
nomes[1] = "Paulo";
nomes[2] = "Pedro";
} catch (ArrayIndexOutOfBoundsException v) {
System.out.println("Voc est armazenando valor em uma
posio da array que no existe");
}
}
}
Se executar o projeto novamente ver a mensagem Voc est armazenando

valor em uma posio da array que no existe, pois ao tentar executar a linha
6, ser feito um desvio automtico para o catch da linha 7 e executada a linha
8, que mostra a mensagem.
possvel tambm que um grupo de linhas que se deseja executar possa gerar
mais de uma exceo. Nesse caso, todas as excees tero que ser tratadas por
quantos catch forem necessrios.
Veja o exemplo a seguir de um mtodo de uma classe de conexo com um

banco de dados:
1
2
3
4
5
public int conectar(){

Class.forName("com.mysql.jdbc.Driver");
Connection conn = DriverManager.getConnection ("jdbc:mysql://
localhost:3306/banco", "usuario", "senha");
return 1;
}
As linhas 2 e 3 podem gerar excees.

A linha 2 passa para o mtodo forName da classe Class.java um parmetro
solicitando o carregamento da classe Driver.class do pacote com.mysql.jdbc
que deve estar na pasta Bibliotecas do projeto. Caso esta classe no esteja na
biblioteca do projeto, ser gerada uma exceo do tipo ClassNotFoundException.
A linha 3 passa para o mtodo getConnection da classe DriverManager.java trs
parmetros, o URL e o nome do banco de dados, o nome do usurio do banco
de dados e a senha deste usurio. Se um destes parmetros estiver incorreto ser
gerada uma exceo do tipo SQLException. Para tratar estas duas excees,
deve-se mudar o cdigo-fonte do mtodo para:
1
2
3
4
5
6
7
8
9
10
11

try {
Connection conn = DriverManager.getConnection ("jdbc:mysql://
localhost:3306/banco","usuario","senha");
return 1;
} catch (ClassNotFoundException ex) {
return 2;
} catch (SQLException x){
return 3;
}
}
Veja que a linha 3 pode gerar uma exceo de falta da classe Driver.class e
desviar para a linha 6, onde os dados do erro ficaro no objeto ex da classe
ClassNotFoundException, e ser retornado para quem chamou o mtodo o
valor 2.
A linha 4 pode gerar uma exceo por encontrar dados incorretos do banco
de dados. Os dados do erro ficaro no objeto x da classe SQLException e ser
retornado o valor 3 para que chamou o mtodo.
Note que o mtodo acima retorna um valor inteiro para quem cham-lo. Se as
linhas 3 e 4 forem executadas sem erro, ser retornado o valor 1. Se a linha
2 gerar a exceo de ClassNotFoundException, ser retornado o valor 2. Se
a linha 4 gerar uma exceo do tipo SQLException, ser retornado o valor 3.
Com os valores retornados quem chamou o mtodo saber o que ocorreu na
sua execuo. Os mtodos de acesso a bancos de dados sero melhor estudados
no Captulo 7 deste livro.
NOTA
Toda linha de cdigo que executa comando SQL ou de conexo com

banco de dados pode gerar uma exceo do tipo SQLException, por isso,
este tratamento de exceo comum em aplicaes Java que acessam
banco de dados.
Caso voc no tenha certeza de qual exceo ser gerada, pode usar uma forma
de tratamento de exceo genrica, por meio da classe Exception. Veja a seguir
o mtodo apresentado anteriormente tratado desta forma:
1
2
3
4
5
6
7
8
9

try {
Connection conn = DriverManager.getConnection
localhost:3306/banco","usuario","senha");
return 1;
} catch (Exception ex) {
return 2;
}
}
("jdbc:mysql://
Note que qualquer tipo de exceo que ocorrer nas linhas do interior das chaves
do try ir desviar para o catch, que receber em um objeto da classe Exception
informaes da exceo e retornar o valor 2. Nesse caso, duas excees
diferentes podem ocorrer, uma na linha 3 e outra na linha 4. O desvio para um
nico catch no permite diferenciar o tratamento das duas, mas apresentar um
tratamento genrico. Este o motivo pelo qual esta forma de tratamento de
excees no recomendada.
5.2.2 Tratamento de Excees com throws

Quando voc no quer tratar a exceo, ou no tem ideia clara de como resolver
o problema que pode ser causado na execuo de uma linha ou trecho de cdigo
de um mtodo, deve utilizar a clusula throws, que passa a responsabilidade
pelo tratamento da exceo a que chamou o mtodo. Com o throws o mtodo
declara que pode lanar o erro, e se este ocorrer, o mtodo que o chamou deve
tratar a exceo.
Se voc colocar throws na declarao do mtodo, voc est dizendo algo como:
Olha, tem certas operaes que eu executo mas que no tenho a mnima ideia de
como resolver, resolva voc.
Por exemplo:
public void imprimeArquivo(File arquivo) throws FileNotFoundException{

//Implementao do corpo do mtodo
}
Neste mtodo, o desenvolvedor no sabe o que fazer se o arquivo recebido

como parmetro no for encontrado, por isso, o throws passa a responsabilidade
de tratar a exceo FileNotFoundException para quem chamar o mtodo, que
ter que trat-lo com try...catch.
Veja o exemplo abaixo, do mtodo conectar da classe Dao.java, que faz uma
conexo com um banco de dados:
1
2
3
4
5
6
7
8
9
10
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
public class Dao {
public int conectar(String driver, String url, String usuario, String senha)
throws ClassNotFoundException, SQLException{
Class.forName(driver);
Connection conn = DriverManager.getConnection (url, usuario, senha);
return 1;
}
}
No tpico anterior tratamos este mtodo (conectar) com o try...catch, mas

agora, da forma que ele foi implementado, o tratamento das excees
ClassNotFoundException e SQLException ser responsabilidade de quem
chamar o mtodo. Isso pode ser percebido pelo uso da clusula throws na
declarao do mtodo. Quem chamar o mtodo conectar ter que tratar com
try...catch estas excees.
Veja a exceo tratada na chamada ao mtodo conectar, a partir de uma classe

chamada Principal.java.
1
2
3
4
5
6
7
8
9
10
11
12
13
Dao d = new Dao();
try {
int r = d.conectar();
System.out.print("A classe do driver de acesso ao banco de dados no est
dispponvel");
} catch (SQLException ex) {
System.out.print("H um erro nos dados de conexo com o banco de dados");
}
}
}
Observe na linha 4 que foi instanciado um objeto d da classe Dao.java. Por

meio deste objeto, na linha 6, foi chamado o mtodo conectar. Note que essa
chamada de mtodo obrigatoriamente ter que estar no interior de um try, pois
o mtodo tem a clusula throws que obriga quem cham-lo a tratar as excees
lanadas, que, neste caso, so ClassNotFoundException e SQLException.
Caso no mtodo conectar tenha ocorrido uma exceo do tipo
ClassNotFoundException (linha 7), ser exibida a mensagem da linha 8. Caso
tenha ocorrido uma exceo do tipo SQLException (linha 9), ser exibida a
mensagem da linha 10.
A clusula throws, na declarao de um mtodo, passa a responsabi-
NOTA lidade pelo tratamento das excees que possam ocorrer no mtodo a
quem cham-lo.
As formas mais comuns de lidar com excees foram apresentadas neste captulo,
mas h muito mais sobre excees. Voc pode conferir no link: <http://blog.
caelum.com.br/lidando-com-exceptions/> um bom artigo intitulado Lidando
com Exceptions. Se deseja informaes mais tcnicas, acesse o link:
<http://www.caelum.com.br/apostila-java-orientacao-objetos/excecoes-e-con
trole-de-erros/#11-11-exercicios-excecoes>.
5.3 Resumo
Este captulo tratou de dois assuntos: uso de mtodos estticos e tratamento

de excees.
Mtodos estticos podem ser chamados diretamente por meio do nome
da classe, sem precisar instanciar objeto. Aqueles mtodos de apoio que
utilizamos com frequncia em diversas classes e/ou aplicaes, normalmente
declaramos como estticos em uma classe e inclumos na biblioteca do projeto.
O Java traz um conjunto de classes com mtodos estticos para facilitar o
trabalho do programador, como a classe Math, para operaes matemticas e
trigonomtricas; e a classe JOptionPane, para gerar caixas de dilogo etc. Uma
classe pode ter mtodos estticos e no estticos. Para declarar um mtodo
como esttico, utiliza-se a instruo static na declarao do mtodo. Utilize
mtodos estticos para criar bibliotecas e reutiliz-las em vrios projetos.
Uma exceo em Java ocorre por meio da entrada no esperada de dados do
usurio, por parmetros incorretos para um mtodo, pela falta de um recurso
requerido etc. Tratar a exceo permite minimizar o problema, evitando a
interrupo da execuo do programa e a exibio daquelas mensagens de
erro que assustam o usurio.
O tratamento de excees em Java pode ocorrer por meio de duas estruturas
fundamentais: try...catch e throws.
Utilize throws em um mtodo quando voc no quer ou no sabe como tratar
a exceo e deseja deixar o tratamento para quem chamar o mtodo. Nesse
caso, dizemos que o throws lana a exceo para ser tratada por quem chamou
o mtodo.
Utilize try...catch para tratar a exceo de fato, quando voc sabe qual a
exceo e como ela deve ser tratada. O try tenta executar uma linha ou bloco
de linhas. Se ocorrer algum problema, automaticamente feito um desvio para
o catch, que executa a ao necessria relacionada a resoluo do problema.
5.4 Exerccios
1) Analise o cdigo abaixo e preencha corretamente a lacuna:
public static void metodo() {
try {
new java.io.FileInputStream("arquivo.txt");
} catch (____________________ e) {
System.out.println("Nao foi possvel abrir o arquivo para leitura");
}
}
2) Considere o cdigo a seguir:

String f1 = null;
String f2 = null;
f2 = f1.toUpperCase();
System.out.println("Frase antiga: " + f1);
System.out.println("Frase nova: " + f2);
}
}
Ao executar o cdigo foi exibida a seguinte mensagem:

Exception in thread "main" java.lang.NullPointerException at Teste.
main(Teste.java:5)
Reescreva o cdigo tratando a exceo gerada com try...catch.
3) Considere o cdigo do mtodo abaixo:
private static void aumentarLetras() {
String f1 = null;
String f2 = null;
f2 = f1.toUpperCase();
System.out.println("Frase antiga: " + f1);
System.out.println("Frase nova: " + f2);
}
Este cdigo gerar uma exceo do tipo NullPointerException. Como voc no

deseja tratar a exceo, mas sim deixar que ela seja tratada por quem chamar
o mtodo, reescreva o cdigo de forma a permitir isso.
int a[] = new int[3];
for (int cont = 0; cont <= a.length; cont++) {
a[cont] = Integer.parseInt(JOptionPane.showInputDialog("Digite um
valor inteiro"));
}
}
}
Ao executar a classe acima aparece a seguinte mensagem:

Exception in thread main java.lang.ArrayIndexOutOfBoundsException: 3
at Teste.main(Teste.java:9)
Reescreva o cdigo tratando esta exceo com try...catch.

int a, b, c;
a = Integer.parseInt(JOptionPane.showInputDialog("Digite um valor
inteiro"));
b = Integer.parseInt(JOptionPane.showInputDialog("Digite outro
valor inteiro"));
c = a / b;
}
}
A) Trate a exceo que ser gerada se for digitado na primeira caixa de dilogo
o valor abaixo:
B) Trate a exceo que ser gerada se for digitado na segunda caixa de dilogo
o valor abaixo:
6) O mtodo abaixo tem o objetivo de incluir dados em uma tabela de um

banco de dados. Reescreva-o direcionando a exceo adequada para quem
chamar o mtodo.
public int salvar(Cliente cli){

String sql = "insert into cliente values ('" + cli.getCodigo() + "', '" +
cli.getNome() + "', '" + cli.getCargo() + "', '" + cli.getTelefone() + "',
'" + cli.getEmail()+ "', "+ cli.getRenda()+ ")";
return statement.executeUpdate(sql);
}
7) Crie uma classe em um projeto Java com um mtodo esttico para calcular
a mdia entre trs notas, descartando a menor delas, calculando a mdia das
duas maiores e retornando o resultado. Construa o arquivo .JAR do projeto.
Crie um novo projeto e adicione o arquivo .JAR biblioteca. Crie uma classe
principal nesse projeto, leia trs notas e utilize o mtodo esttico da classe que
est na biblioteca do projeto para calcular a mdia.
6. Criao de
interface grfica
Uma das partes mais importantes de um software a interface do usurio. A

interface do usurio composta por todas as telas que o usurio tem contato
quando interage com o software. Criar telas com visual agradvel e que
consumam pouco recurso computacional no uma tarefa fcil.
A linguagem Java possui duas APIs (Application Programming Interface)
com pacotes de classes especficos para a criao de interfaces do usurio, que
poupa o programador de parte da complexidade da programao. Trata-se das
APIs swing e awt, bastante conhecidas pelos desenvolvedores.
A API awt foi a primeira utilizada na construo de interface grfica de usurio
(GUI Graphical User Interface) da plataforma Java, mas como usava muitas
rotinas do sistema operacional (tendo diferenas em cada um deles), foi aos
poucos perdendo espao para a API swing, que pode ser utilizado da mesma
maneira em qualquer sistema operacional. Podemos dizer que a API swing
a evoluo da API awt, e vem sendo constantemente atualizada, sendo a
Implementao de Referncia (IR) para a criao de interface grfica do usurio
em aplicaes desktop construdas com Java.
Neste captulo, vamos focar no estudo da API swing, mas utilizaremos tambm
alguns recursos da API awt, quando necessrio.
6.1 API swing

A API swing a implementao de referncia oficial para o desenvolvimento
de interface grfica do usurio (GUI) em aplicaes desktop Java.
Ela basicamente voltada criao de janelas, normalmente formulrios, que
podem ter barras de menus, botes e outros elementos necessrios em uma
aplicao. A API swing composta por diversos pacotes de classes, sendo que
os mais utilizados so javax.swing e javax.swing.event. O foco desse captulo
sero as classes destes dois pacotes principais.
6.1.1 Contineres swing

Para criar um componente de interface do usurio, por exemplo, uma janela,
uma barra de menu e campos de formulrio, precisamos escolher um continer
que receber esses componentes. Nesse caso, o continer mais indicado a

classe JFrame, do pacote javax.swing. Criamos uma classe que estende (herda)
a classe JFrame e que gera uma tela e adicionamos os componentes nela.
Na hierarquia da classes da API swing, os contineres esto no topo. Um

continer pode conter e controlar a exibio de qualquer outro componente.
A Figura 6.1 mostra uma viso simplificada da relao de herana entre as
principais classes da API swing e awt, incluindo os contineres.
Figura 6.1: Principais classes das APIs swing e awt.
A forma mais comum de se construir componentes grficos utilizando a API

swing especializ-los, ou seja, criar uma classe que estende o comportamento
de outra. Dessa forma, todos os mtodos da superclasse sero herdados,
facilitando a construo do cdigo-fonte. Se nossa classe estender (herdar)
a classe JFrame, poderemos utilizar os mtodos da classe JFrame e de suas
subclasses para definir as propriedades do continer gerado.
NOTA
Alm do continer JFrame h outros tipos de continer na API swing,

como JPanel e JApplet. Neste captulo focaremos nos conteineres
principais, que so JFrame e JPanel.
6.1.2 Formas de criao de layout utilizando a API

swing
O layout de uma janela e de seus componentes, criado com as classes dos
pacotes da API swing, pode ser definido de duas maneiras:
1. Posicionando-se estaticamente cada elemento na tela.
2. Utilizando gerenciadores de layout.
No posicionamento esttico voc tem controle total sobre o layout que est
sendo criado, mas precisa fazer normalmente um conjunto de clculos para
que os elementos no sejam posicionados uns sobre os outros.
Quando se utiliza os gerenciadores de layout (que so classes e mtodos
especficos para lidar com o layout dos contineres) o alinhamento,
posicionamento e dimensionamento dos componentes feito automaticamente.
A vantagem que voc no precisa fazer clculos para posicionar componentes.
A desvantagem que voc tem que se contentar com os layouts pr-definidos,
tendo pouca liberdade de modificao e personalizao.
Os gerenciadores de layout so classes contidas no pacote java.awt. Estas
classes so: FlowLayout, GridLayout, BorderLayout e GridBagLayout. Voc
pode ainda, se desejar, misturar o uso dos gerenciadores de layout, caso
necessrio.
6.1.3 Aplicao exemplo criando layout com

posicionamento esttico
O posicionamento esttico consiste no programador definir a posio de todos
os elementos do layout, desde a janela at dos componentes em seu interior.
Apesar de este modo permitir a personalizao e controle absoluto sobre o
layout, necessrio um conjunto de clculos para posicionar adequadamente
os elementos sem que uns sobreponham outros no todo ou em parte.
Para mostrar como esta forma de criao de layout funciona, crie um projeto
Java no NetBeans chamado ControleCliente e, neste projeto, crie as classes
Principal.java e TelaCliente.java. Aps este procedimento seu projeto deve
estar como mostra a Figura 6.2.
Figura 6.2: Projeto ControleCliente criado no NetBeans.
Basicamente a interface do usurio ser gerada na classe TelaCliente.java, que

ser chamada a partir da classe Principal.java.
Digite o seguinte cdigo-fonte para a classe TelaCliente.java:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JTextField;
public class TelaCliente extends JFrame{
private JLabel lblNome, lblRenda;
private JTextField txtNome, txtRenda;
private JButton btnSalvar, btnSair;
public TelaCliente() {
// definindo propriedades do formulrio
setLayout(null);
setDefaultCloseOperation(EXIT_ON_CLOSE);
setSize(600, 200);
setLocation(200, 300);
setTitle("Controle de Clientes");
//Definindo propriedades dos campos do formulrio
lblNome = new JLabel("Nome:");
lblNome.setSize(50,30);
lblNome.setLocation(30,10);
add(lblNome);
txtNome = new JTextField();
txtNome.setSize(480,30);
txtNome.setLocation(80,10);
add(txtNome);
lblRenda = new JLabel("Renda:");
lblRenda.setSize(50,30);
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
lblRenda.setLocation(30,45);
add(lblRenda);
txtRenda = new JTextField();
txtRenda.setSize(100,30);
txtRenda.setLocation(80,45);
add(txtRenda);
btnSalvar = new JButton("Salvar");
btnSalvar.setSize(80,30);
btnSalvar.setLocation(30,90);
add(btnSalvar);
btnSair = new JButton("Sair");

btnSair.setSize(80,30);
btnSair.setLocation(120,90);
add(btnSair);
Para construir o layout, so usadas as classes JFrame, JButton, JLabel e

JTextField, do pacote javax.swing. Estas classes so importadas das linhas 1 4.
Observe que a classe TelaCliente.java herda a classe JFrame (linha 6). Isso
significa que do interior desta classe ser possvel acessar mtodos da classe
JFrame e de suas subclasses.
Como sero necessrios rtulos, campos de texto e botes na tela que ser
gerada, foram declarados objetos das classes JLabel, JTextField e JButton
nas linhas de 7 9.
Note ainda que a maioria da programao que gera a tela est no interior do
construtor da classe TelaCliente.java (linhas de 11 49). Isso significa que
quando um objeto desta classe for instanciado, todo este bloco de cdigo ser
executado.
Nas linhas de 13 17 so definidas propriedades da janela por meio de chamadas
aos mtodos da classe JFrame e de suas subclasses.
Note que como no utilizamos gerenciadores de layout, a linha 13 passa o
valor null para o mtodo setLayout da classe JFrame, definindo que no ser
utilizado nenhum gerenciador de layout.
A linha 14 passa o valor EXIT_ON_CLOSE para o mtodo
setDefaultCloseOperation da classe JFrame, indicando que ao clicar no
X vermelho do canto superior direito da janela a aplicao ser encerrada.
As linhas 15 e 16 definem, respectivamente, o tamanho da janela e a posio

desta na tela. Veja na Figura 6.3 que o mtodo setSize define que a janela ter
600 pixels de largura por 200 pixels de altura (linha 15). Veja tambm que o
mtodo setLocation define que a janela aparecer a partir da coluna de pixel
300 (eixo x) e da linha de pixel 200 (eixo y).
setSize(600, 200);
Figura 6.3: Posicionamento da janela da aplicao.
A linha 17 define um ttulo que aparecer na barra de ttulo da janela.

As linhas a partir da 20 definem as propriedades dos rtulos, campos e botes que
so colocados na janela. Perceba que para todos os elementos h uma instncia
definida pelo comando new, um tamanho definido pelo mtodo setSize, uma
posio definida pelo mtodo setLocation e por fim, o elemento adicionado
janela por meio do mtodo add. Veja a seguir a criao de cada elemento, onde
mostrado o tamanho e posicionamento do elemento.
As linhas a seguir criam o rtulo Nome: por meio de um objeto lblNome da

classe JLabel (linhas 20 a 23).

lblNome.setSize(50,30);
lblNome.setLocation(30,10);
add(lblNome);
Figura 6.4: Posicionamento do rtulo Nome na janela.
As linhas a seguir criam o campo vazio para a digitao do nome, por meio de
um objeto txtNome da classe JTextField (linhas 25 28). Veja na Figura 6.5
como este campo aparecer na janela.
txtNome.setSize(480,30);
txtNome.setLocation(80,10);
add(txtNome);
Figura 6.5: Posicionamento do campo nome na janela.
As linhas a seguir criam o rtulo Renda: por meio de um objeto lblRenda da classe
JLabel (linhas 30 33). Veja na Figura 6.6 como este rtulo aparecer na janela.

lblRenda.setSize(50,30);
lblRenda.setLocation(30,45);
add(lblRenda);
Figura 6.6: Posicionamento do rtulo Renda na janela.
As linhas a seguir criam o campo vazio para a digitao da renda por meio de
um objeto txtRenda da classe JTextField (linhas 35 38). Veja na Figura 6.7
como este campo aparecer na janela.
txtRenda.setSize(100,30);
txtRenda.setLocation(80,45);
add(txtRenda);
Figura 6.7: Posicionamento do campo renda na janela.
As linhas a seguir criam o boto Salvar, por meio de um objeto btnSalvar da

classe JButton (linhas 40 43). Veja na Figura 6.8 como este boto aparecer
na janela.

btnSalvar.setSize(80,30);
btnSalvar.setLocation(30,90);
add(btnSalvar);
Figura 6.8: Posicionamento do boto Salvar na janela.
As linhas a seguir criam o boto Sair, por meio de um objeto btnSair da

classe JButton (linhas 45 48). Veja na Figura 6.9 como este boto aparecer
na janela.
btnSair.setLocation(120,90);
add(btnSair);
Figura 6.9: Posicionamento do boto Sair na janela.
Quando voc chama um mtodo a partir de um objeto, este mtodo pode ser
da classe que instanciou o objeto ou de qualquer uma de suas subclasses,
quando esta classe herda outras classes. Veja por exemplo a seguinte chamada
ao mtodo setSize:
Apesar do objeto btnSair ser da classe JButton, o mtodo setSize da classe

Component. Isso ocorre porque a classe JButton herda a classe AbstractButton,
que herda a classe JComponente, que herda a classe Container, que herda a
classe Component.
Quando chamamos um mtodo por meio de um objeto de uma classe
NOTA que faz parte de uma cadeia de herana, o mtodo pode ser de qualquer
uma das classes da cadeia de herana.
Para gerar a tela programada na classe TelaCliente.java, necessrio instanciar um objeto desta classe, o que feito na classe Principal.java, cujo
cdigo-fonte apresentado a seguir:
1
2
3
4
5
6

TelaCliente tela = new TelaCliente();
tela.setVisible(true);
}
}
Veja que a linha 3 instancia um objeto da classe TelaCliente.java e, por meio

deste objeto, feita uma chamada ao mtodo setVisible da classe Window
(subclasse da cadeia de herana de JFrame), passando como parmetro o valor
true, que torna a janela visvel.
Para compilar e executar o projeto, pressione a tecla F6 ou clique no menu
Executar e na opo Executar Projeto. Ao fazer isso voc ver a janela
Figura 6.10: Janela do formulrio de cadastro.
Voc deve ter observado que utilizamos duas classes para criar a aplicao:
TelaCliente.java e Principal.java.
Poderamos ter conseguido o mesmo resultado apenas com a classe Principal.
java. Para isso, o cdigo-fonte desta classe deveria ficar da seguinte forma:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import static javax.swing.JFrame.EXIT_ON_CLOSE;
public class Principal extends JFrame {
public Principal() {
// definindo propriedades do formulrio
setLayout(null);
setSize(600, 200);
setTitle("Controle de Clientes");
//Definindo propriedades dos campos do formulrio
lblNome.setSize(50, 30);
lblNome.setLocation(30, 10);
add(lblNome);
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
txtNome.setSize(480, 30);
txtNome.setLocation(80, 10);
add(txtNome);
lblRenda.setSize(50, 30);
lblRenda.setLocation(30, 45);
add(lblRenda);
txtRenda.setSize(100, 30);
txtRenda.setLocation(80, 45);
add(txtRenda);
btnSalvar.setSize(80, 30);
btnSalvar.setLocation(30, 90);
add(btnSalvar);

btnSair.setSize(80, 30);
btnSair.setLocation(120, 90);
add(btnSair);

Principal tela = new Principal();
}
Note que na linha 54 foi instanciado um objeto da prpria classe Principal.java

por meio do comando new, que chama o construtor desta classe. O construtor
compreende as linhas de 13 51. Quando o construtor executado, a janela
gerada na memria. Para visualizar esta janela, o mtodo setVisible chamado
passando como parmetro o valor true, que torna a janela visvel (linha 55).
Note que a classe Principal.java agora herda a classe JFrame (linha 7).
NOTA
Alm de rtulos, campos de formulrio e botes, possvel criar barras de

menus, reas de texto, caixas de combinao e de listagem, painis, abas,
campos formatados, enfim, qualquer componente comum de interface
de usurio. A forma de criao e uso semelhante ao que foi visto no
exemplo apresentado. Instancia-se o objeto referente ao elemento, definese a posio e o dimensionamento e adiciona-o tela. No decorrer deste
captulo voc aprender como trabalhar com estes elementos.
6.2 Criao de interface com gerenciadores de

layout
Vimos no tpico anterior como posicionar e dimensionar os componentes na
rea da interface utilizando posicionamento esttico. Apesar do controle que
se tem sobre a criao da tela, este mtodo requer clculos para posicionar
corretamente os componentes, o que demanda um pouco mais de tempo.
Alm do posicionamento esttico, podemos utilizar gerenciadores de layout
que fazem todo trabalho de clculo para alinhamento, posicionamento
e dimensionamento dos componentes. Os gerenciadores de layout so a
seguintes classes do pacote java.awt: FlowLayout, GridLayout, BorderLayout
e GridBagLayout.
Estes gerenciadores de layout sero apresentados a seguir neste captulo.
6.2.1 FlowLayout
Este gerenciador de layout o mais simples de todos e possui as seguintes
caractersticas:

Faz o alinhamento padro ao centro e acima, com deslocamento em

linhas (flow = fluxo). Quando voc adiciona o primeiro elemento, ele
posicionado ao centro e na parte de cima do continer. Quando voc
adiciona novos elementos, eles vo sendo posicionados em linha,
direita do anterior. Se acabar a rea disponvel na linha, o elemento cai
automaticamente para a prxima linha. Apesar dos elementos aparecerem
por padro ao centro, eles podem ser posicionados esquerda ou
direita.
Tem a capacidade de manter o tamanho original dos componentes

durante o redimensionamento (mantm o prefered size dos componentes).
Se voc redimensiona a janela, o tamanho dos componentes no
modificado, mantendo os valores originais.
6.2.1.1 Exemplo simples com FlowLayout

Veja a seguir a mesma aplicao que desenvolvemos anteriormente, mas
agora utilizando o gerenciador de layout FlowLayout. Crie um projeto Java
no NetBeans chamado ProjetoFlow e nele crie uma classe chamada Principal.
java. A Figura 6.11 mostra como deve estar o projeto aps sua criao.
Figura 6.11: Projeto utilizando o gerenciador de layout FlowLayout.
Digite o seguinte cdigo-fonte para a classe Principal.java:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import java.awt.FlowLayout;
public class Principal extends JFrame {
public Principal() {
// Propriedades da janela
setTitle("Exemplo de Flow layout");
setLayout(new FlowLayout());
setSize(600, 200);
// definio dos componentes da janela
add(lblNome);
txtNome = new JTextField(45);
add(txtNome);
add(lblRenda);
txtRenda = new JTextField(15);
add(txtRenda);
add(btnSalvar);
28
29
30
31
32
33
34
35
add(btnSair);
public static void main(String args[]) {

Principal tela = new Principal();
}
A linha 11 define que o layout da janela ser FlowLayout utilizando o posicionamento padro ao centro. Caso voc queira que o alinhamento seja esquerda,
precisa digitar a seguinte instruo:
setLayout(new FlowLayout(FlowLayout.LEFT));
Observe nas linhas 13 e 14 que o tamanho e posio da janela devem ser

definidos, porm, das linhas 17 28 os objetos referentes a cada elemento so
apenas instanciados e adicionados ao continer (janela), sem a necessidade de
definio da posio e do tamanho. A linha 32 instancia um objeto da prpria
classe e por meio desse objeto chama o mtodo setVisible passando o parmetro
true, para exibir a janela.
Ao compilar e executar o projeto pressionando a tecla F6, voc ver a tela
Figura 6.12: Tela gerada utilizando o gerenciador de layout FlowLayout.
Veja que o campo Nome foi inserido na tela, ocupando praticamente

toda a primeira linha. Em seguida foi includo o campo Renda. Como
este campo no coube na primeira linha do continer, ele foi deslocado
automaticamente para a segunda linha. Em seguida foram inseridos os botes
Salvar e Sair. Como estes botes couberam na mesma linha do campo
Renda, foram colocados direita. Note que o contedo das duas linhas se
mantm centralizado e na parte superior da janela. Se fossem inserido novos
componentes eles apareceriam direita do boto Sair, mudando de linha

caso no coubessem.
Caso voc aumente a largura da janela, os elementos que estavam na segunda

linha sobem para a primeira linha, sempre direita do elemento anterior, at
preencher toda a linha, como mostra a Figura 6.13.
Figura 6.13: Redimensionamento da janela que utiliza o gerencidor de layout FlowLayout.
6.2.2 BorderLayout
O gerenciador de layout BorderLayout divide o continer em cinco reas: norte,
sul, leste, oeste e centro. Alm de no manter o tamanho original dos componentes
durante o redimensionamento (j que eles so aumentados de acordo com a tela),
o continer pode receber somente um componente por rea. A Figura 6.14 mostra
como o gerenciador de layout BorderLayout divide a janela.
Figura 6.14: reas do layout BorderLayout.
O componente colocado em uma rea usa todo o espao dessa rea.
NOTA
O gerenciador de layout padro dos contineres o BorderLayout. Isso

significa que se voc no definir explicitamente o gerenciador de layout
por meio do mtodo setLayout, o BorderLayout ser adotado por padro.
6.2.2.1 Exemplo simples com BorderLayout

Para testar o uso do gerenciador de layout BorderLayout, crie um projeto
chamado ProjetoBorder com uma classe principal chamada Tela.java, conforme
mostra a Figura 6.15.
Figura 6.15: Projeto ProjetoBorder usando Borderlayout.
Na classe Tela.java, digite o seguinte cdigo-fonte:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
import java.awt.BorderLayout;
public class Tela extends JFrame {
private JButton btnCentro, btnLeste, btnOeste, btnNorte, btnSul;
public Tela() {
setTitle("Exemplo com Border Layout");
setLayout(new BorderLayout());
setSize(700, 200);
btnCentro = new JButton("Centro");
add(btnCentro, BorderLayout.CENTER);
btnLeste = new JButton("Leste");
add(btnLeste, BorderLayout.EAST);
btnSul = new JButton("Sul");
add(btnSul, BorderLayout.SOUTH);
btnNorte = new JButton("Norte");
add(btnNorte, BorderLayout.NORTH);
btnOeste = new JButton("Oeste");
add(btnOeste, BorderLayout.WEST);
}

Tela tela = new Tela();
}
Na linha 11 o layout da janela foi definido como BorderLayout.

Note nas linhas de 15 a 24 que cada elemento instanciado e, em seguida,
adicionado ao continer (janela) indicando a posio em que ser colocado.
Veja, por exemplo, as linhas 15 e 16. Na linha 15 um objeto da classe JButton
instanciado e na linha 16 este objeto adicionado ao continer por meio
de uma chamada ao mtodo add da classe Container. Este mtodo receber
como parmetro o nome do objeto que ser adicionado e tambm a posio
do objeto. O comando BorderLayout.CENTER obtm o valor da constante
chamada CENTER da classe BorderLayout. L na classe BorderLayout esta
constante declarada da seguinte forma:
public static final String CENTER = "Center";
Como a constante CENTER pblica e esttica, pode ser acessada do interior da

nossa classe Tela.java. As demais linhas seguem o mesmo padro, posicionando
os demais elementos na janela.
Ao compilar e executar o projeto pressionando a tecla F6 voc ver a tela
Figura 6.16: Tela gerada com BorderLayout.
Veja que foi colocado um boto em cada regio do layout j que s permitido
um elemento por rea e eles ocuparam todo o espao daquela rea. Se voc
aumentar ou diminuir a janela, o tamanho dos botes aumenta ou diminui
proporcionalmente.
NOTA
Este tipo de layout utilizado para que cada regio da janela receba
novos contineres (normalmente JPanel) e estes contineres menores
agrupem elementos como botes, rtulos, campos texto etc. Veremos
como fazer isso mais adiante neste captulo.
6.2.3 GridLayout
O gerenciador de layout GridLayout divide o continer em linhas e colunas
como uma tabela com clulas (grid). Se voc aumentar ou diminuir a janela,
o tamanho dos componentes acompanharo proporcionalmente as novas
dimenses da janela, ou seja, se voc aumentar a janela, o tamanho dos
componentes aumenta, se diminuir, o tamanho dos componentes diminui. Em
cada clula do grid, ou seja, em cada posio do layout, voc pode colocar
apenas um elemento.
6.2.3.1 Exemplo simples com GridLayout

Para entender melhor como este gerenciador de layout funciona, crie um novo
projeto Java no NetBeans chamado ProjetoGrid com uma classe principal
chamada Tela.java, conforme mostra a Figura 6.17.
Figura 6.17: Projeto ProjetoGrid usando GridLayout.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import java.awt.GridLayout;
private JButton sim, nao, cancelar;
private JLabel mensagem;
public Tela() {
setTitle("Exemplo com GridLayout");
setLayout(new GridLayout(3, 2));
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
setSize(600, 200);
add(lblNome);
add(txtNome);
add(lblRenda);
add(txtRenda);
add(btnSalvar);
add(btnSair);

}
Na linha 16 o layout da janela definido como GridLayout com trs linhas e

duas colunas, totalizando 6 clulas. As linhas 17 e 18 definem, respectivamente,
tamanho e posio da janela na tela.
Das linhas 19 30 os objetos so declarados e adicionados na janela. Veja que
os objetos vo sendo colocados nas clulas da grid da esquerda para a direita
e de cima para baixo, de forma sequencial.
NOTA
Todas as clulas da grid possuem o mesmo tamanho, que pode ser

alterado automaticamente na medida em que a janela aumentada ou
diminuda. No h como definir tamanho diferenciado para cada coluna,
linha ou clula. Se deseja tamanhos diferentes, utilize o gerenciador
de layout GridBagLayout, que ser visto mais a frente neste captulo.
Note que a linha 34 instancia um objeto da prpria classe Tela.java por meio
do comando new, que chama o construtor da classe (linhas de 13 31). Nessa
operao, todo o contedo do construtor executado, gerando a tela. A linha
35 exibe a janela.
Ao compilar e executar o projeto pressionando a tecla F6 voc ver a tela

apresentada na Figura 6.18.
Figura 6.18: Tela gerada com layout GridLayout.
Observe a diviso da tela em trs linhas e duas colunas e o posicionamento dos

elementos na ordem em que foram adicionados. Cada elemento ocupa toda a
rea da clula da grid.
6.2.4 GridBagLayout
O gerenciador de layout GridBagLayout o mais flexvel de todos, porm,
o mais complexo, pois cada elemento deve conter uma posio inicial, uma
posio final, um tamanho, uma escala, um alinhamento e um preenchimento.
Ele divide o continer em linhas e colunas como uma tabela com clulas (grid).
Dependendo do alinhamento dentro de uma clula, pode ou no manter o
tamanho original dos componentes. Em cada clula, pode ser colocado apenas
um componente e cada clula pode ser expandida para ocupar o espao de
uma ou mais clulas adjacentes usando regras especficas de alinhamento e
posicionamento.
Quando se utiliza o gerenciador de layout GridBagLayout, um objeto da classe
GridBagConstraints normalmente utilizado para determinar o posicionamento
do elemento na grid.
6.2.4.1 Exemplo simples com GridBagLayout

Para entender melhor como funciona o gerenciador de layout GridBagLayout,
vamos criar a tela cuja diviso mostrada na Figura 6.19.
Figura 6.19: Exemplo de layout GridBagLayout.
Note que as clulas possuem posicionamento especfico e algumas possuem

tamanhos diferentes.
Crie um novo projeto Java no NetBeans chamado ProjetoGridBag com a classe
Tela.java, conforme mostra a Figura 6.20.
Figura 6.20: Projeto ProjetoGridBag utilizando GridBagLayout.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import java.awt.*;
private JButton btn1, btn2, btn3, btn4;
public Tela() {
setTitle("Exemplo com GridBagLayout");
setSize(500, 200);
setLayout(new GridBagLayout());
GridBagConstraints gridCons = new GridBagConstraints();
btn1 = new JButton("Um");
btn2 = new JButton("Dois");
btn3 = new JButton("Trs");
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
btn4 = new JButton("Quatro");

gridCons.gridx = 0;
gridCons.gridy = 0;
add(btn1, gridCons);
gridCons.gridx = 3;
gridCons.gridx = 1;
gridCons.gridy = 1;
gridCons.gridwidth = 2;
gridCons.gridx = 0;
gridCons.gridy = 3;

}
Observe na linha 13 a indicao de que a janela utilizar o layout GridBagLayout.

Na linha 14 instanciado um objeto da classe GridBagConstraints por meio
do qual os elementos sero posicionados. Nas linhas de 16 19 os botes que
sero inseridos na tela so criados.
Nas linhas 21 e 22 definem-se, respectivamente, a posio no eixo x e y
(coluna e linha) para o boto 1 (btn1), inserido na tela na linha 23. Veja que a
insero na tela feita pelo mtodo add da classe Container, que precisa de
dois parmetros: o objeto a ser inserido e o posicionamento. Note que o boto
btn1 foi inserido na clula 0,0, ou seja, na coluna 0 e linha 0 da grid.
Na linha 25 definida a posio do boto 2 (btn2). Veja que ele ser colocado
na terceira coluna. Como a linha no foi definida, por padro ser 0, ou seja,
o boto ser colocado na posio 3,0 (coluna 3 e linha 0). Na linha 26 o boto
adicionado janela com o respectivo posicionamento.
Nas linhas 28 e 29 define-se que o boto 3 (btn3) ser colocado na clula de
posio 1,1, ou seja, coluna 1 e linha 1. Na linha 30 define-se que esta clula
ocupar duas colunas, ou seja, ter a largura de duas colunas. Esse efeito
semelhante mesclagem de clulas do Excel. Na linha 31, o boto 3
adicionado janela com o respectivo posicionamento.
Nas linhas 33 e 34 definido o posicionamento do boto 4 (btn4). Este boto

ser posicionado na coluna 0 da linha 3, ou seja, na clula de posio 0,3. Na
linha 35 o boto 4 adicionado janela com o respectivo posicionamento.
Ao compilar e executar o projeto pressionando-se a tecla F6, voc ver a tela

Figura 6.21:Janela usando GridBagLayout.
Apesar de existir uma grade, ela utilizada apenas para o posicionamento do

contedo, mas no visualizada.
6.2.4.2 Definio das propriedades do

GridBagLayout
No exemplo apresentado voc percebeu o uso das propriedades gridx, gridy
e gridwidth, acessadas por meio de um objeto da classe GridBagConstraints,
para definir o posicionamento e dimensionamento das clulas do layout definido
como GridBagLayout. H, porm, muitas outras propriedades que podem ser
definidas. Estas propriedades so apresentadas a seguir:
gridx e gridy Especificam a posio x e y para adicionar o componente. A
propriedade gridx permite especificar qual a posio absoluta horizontal onde
o componente ser posicionado. A propriedade gridy permite especificar qual
a posio absoluta vertical onde o componente ser posicionado.
gridheight e gridwidth Especificam o tamanho do componente baseado em
clulas. com essa propriedade que voc indicar o nmero de clulas que
um elemento ocupar. A varivel gridwidth especifica o nmero de clulas
que o componente ocupar na horizontal. A varivel gridheight especifica o
nmero de clulas que o componente ocupar na vertical. Valor padro 1
para as duas propriedades.
weightx e weighty Essas propriedades especificam um percentual de
crescimento da clula, no do componente, quando a mesma precisar ser
redimensionada. O valor padro 0 e os valores percentuais so dados em
casas decimais, por exemplo: 0.03 refere-se a 3%, 1.00 refere-se a 100% etc.
ipadx e ipady Determinam as bordas internas do componente. O tamanho

mnimo ser o ipad + o valor mnimo do componente.
fill Determina como redimensionar o componente. Os valores possveis para
esta propriedade so:
NONE No permite redimensionar o componente.
HORIZONTAL Permite redimensionar horizontalmente, fazendo com que
o componente ocupe toda a rea horizontal na clula.
VERTICAL Permite redimensionar verticalmente, fazendo com que o
componente ocupe toda a rea vertical na clula.
BOTH Permite redimensionar o componente para ambas as direes.
O valor padro NONE.

Por exemplo, para que cada componente ocupe todo o espao da clula digita-se a instruo seguinte:
gridCons.fill = GridBagConstraints.BOTH;
Onde gridCons um objeto da classe GridBagConstraints.

anchor Essa propriedade utilizada somente quando o tamanho do
componente menor que a rea que lhe foi concedida. Sendo assim, o layout
precisa saber em que posio da clula deixar o componente. Os valores
para essa propriedade so de dois tipos: Absolutos (CENTER, NORTH,
NORTHEAST, EAST, SOUTHEAST, SOUTH, SOUTHWEST, WEST, e
NORTHWEST) e Relativos (PAGE_START, PAGE_END, LINE_START, LINE_
END, FIRST_LINE_START, FIRST_LINE_END, LAST_LINE_START e LAST_
LINE_END). O valor padro CENTER.
insets Determina o espao vazio em volta do componente, como uma margem
externa. Por exemplo, para deixar espao de 5 pixel em volta de um componente
em todos os lados, utiliza-se a instruo seguinte:
gridCons.insets = new Insets(5, 5, 5, 5);
Onde gridCons um objeto da classe GridBagConstraints.
6.2.4.3 Exemplo com GridBagLayout utilizando

diversas propriedades
Vamos construir um exemplo um pouco mais complexo, que utiliza mais
propriedades na definio do layout mostradas na Figura 6.22.
0
Nome:
Renda:
Salvar
Sair
Figura 6.22: Exemplo de layout GridBagLayout.
Note que:
O rtulo Nome: est na posio gridx=0 e gridy=0, ocupando duas
colunas (gridwidth=2).
O campo para o preenchimento do nome est na posio gridx=2 e gridy=0,
ocupando quatro colunas (gridwidth=4).
O rtulo Renda: est na posio (gridx=0 e gridy=1), ocupando duas
O campo para o preenchimento da renda est na posio gridx=2 e gridy=1,
ocupando duas colunas (gridwidth=2).
O boto Salvar est na posio (gridx=1 e gridy=2), ocupando duas
O boto Sair est na posio (gridx=3 e gridy=2), ocupando duas colunas
(gridwidth=2).
Para gerar a tela apresentada, crie um novo projeto chamado ProjetoGridBagNovo
e uma classe principal chamada Tela.java, conforme mostra a Figura 6.23.
Figura 6.23: Projeto ProjetoGridBagNovo.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
import java.awt.*;
public Tela() {
setTitle("Exemplo com GridBagLayout");
setSize(700, 200);
setLayout(new GridBagLayout());
GridBagConstraints gridCons = new GridBagConstraints();
gridCons.gridx = 0;
gridCons.gridy = 0;
add(lblNome, gridCons);
gridCons.gridx = 2;
gridCons.gridy = 0;
add(txtNome, gridCons);
gridCons.gridx = 0;
gridCons.gridy = 1;
add(lblRenda, gridCons);
gridCons.gridx = 2;
gridCons.gridy = 1;
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
gridCons.anchor = GridBagConstraints.WEST;
add(txtRenda, gridCons);
gridCons.gridx = 1;
gridCons.gridy = 2;
gridCons.anchor = GridBagConstraints.CENTER;
add(btnSalvar, gridCons);
gridCons.gridx = 3;
gridCons.gridy = 2;
add(btnSair, gridCons);

}
Neste exemplo ser comentado apenas o que novo em relao aos exemplos
anteriores. Veja que o rtulo lblNome, criado na linha 18, ser posicionado na
coluna 0 e linha 0 e ter duas colunas de largura.
J o campo txtNome, criado na linha 19, ser posicionado na coluna 2 e linha
0 e ter 4 colunas de largura.
O rtulo lblRenda, criado na linha 20, ser posicionado na coluna 0 e linha 1
e ter duas colunas de largura. Note que este rtulo ter 15 pixels de margem
superior e 8 pixel de margem inferior. Isso foi definido pela propriedade insets
(linha 38) com objetivo de desgrudar o contedo desta linha das demais.
O campo txtRenda, criado na linha 21, ser posicionado na coluna 2 e linha 1 e
ter 2 colunas de largura. Como o tamanho deste campo no chega a preencher
as duas colunas, ele foi alinhado esquerda pela propriedade anchor da linha 44.
O boto btnSalvar, criado na linha 22, ser posicionado na coluna 1 e linha 2
e ter 2 colunas de largura. Este boto ter uma margem de 5 pixel em todos
os seus lados (linha 50) e ser centralizado (linha 51).
O boto btnSair, criado na linha 23, ser posicionado na coluna 3 e linha 2 e
ter 2 colunas de largura. Este boto ser centralizado (linha 57).
Ao compilar e executar o projeto por meio do pressionamento da tecla F6,

ser exibida a tela mostrada na Figura 6.24.
Figura 6.24: Tela criada com GridBagLayout.
Apesar de no termos utilizado nos exemplos apresentados a propriedade

gridheight, ela muito importante para fazer a mesclagem de linhas. Veja o
layout mostrado na Figura 6.25.
Figura 6.25: Exemplo de Layout que utiliza Grid BagLayout com mesclagem de clulas.
Para gerar o rtulo Nome sero necessrias as linhas abaixo, considerando

lblNome do tipo JLabel e gridCons um objeto da classe GridBagConstraints.
Veja como ficaria o bloco de cdigo para gerar o rtulo Nome:
gridCons.gridx = 0;
gridCons.gridy = 0;
gridCons.gridheight = 2;
add(lblNome, gridCons);
Criar uma tela com GridBagLayout permite um bom nvel de personalizao,

porm este o mais complexo dos gerenciadores de layout, dando quase tanto
trabalho quanto criar o layout utilizando posicionamento esttico.
6.2.5 Utilizando gerenciadores de layout

compostos
Em muitos casos a criao do layout necessita do uso de mais de um gerenciador

de layout na mesma tela. Normalmente isso ocorre quando voc s pode colocar
um elemento em uma rea do layout e dentro deste elemento continer (que
pode ser, por exemplo, um JPanel), deseja colocar outros elementos. Nesse
caso, a janela pode utilizar um gerenciador de layout e o elemento continer
colocado em uma posio da janela pode utilizar outro. A deciso de qual e
quantos gerenciadores de layout precisaro ser utilizados depende do projeto,
mas voc precisa saber quando usar cada um dos gerenciadores de layout
vistos anteriormente.
DICA
Para colocar mais de um componente dentro de uma rea de um

continer devemos usar o gerenciador de layout FlowLayout. Se
quisermos dividir uma rea em clulas padro, devemos usar o
GridLayout. Se estas clulas precisam ter tamanhos e posicionamentos
personalizados, utilizamos o GridBagLayout. Se quisermos dividir
um continer em norte, sul, leste, oeste e centro, devemos usar o
BorderLayout.
6.2.5.1 Exemplo utilizando gerenciadores de

layout compostos
Neste tpico vamos criar uma tela semelhante a de um editor de texto simples,
como o Bloco de Notas do Windows, utilizando dois gerenciadores de layout,
FlowLayout e BorderLayout. Para isso, crie um novo projeto Java chamado
ProjetoLayoutComposto e com uma classe principal chamada Tela.java, como
Figura 6.26: Projeto utilizando gerenciadores de layout compostos.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
import java.awt.*;
private JPanel pnlBotoes;
private JPanel pnlBarraStatus;
private JScrollPane pnlScrTexto;
private JButton btnNovo, btnLimpar, btnSalvar, btnSair;
private JLabel lblMensagem, lblHora;
private JTextArea txtAreaTexto;
public Tela() {
// Propriedades da janela (JFrame)
setTitle("Layout composto");
setSize(640, 480);
// Criao dos elementos
btnNovo = new JButton("Novo");
btnLimpar = new JButton("Limpar");
lblMensagem = new JLabel("Mensagem: ");
lblHora = new JLabel("Data e Hora: " + new Date().toString());
txtAreaTexto = new JTextArea("Digite seu texto aqui: ", 20, 40);
pnlScrTexto = new JScrollPane(txtAreaTexto,
JScrollPane.VERTICAL_SCROLLBAR_ALWAYS,
JScrollPane.HORIZONTAL_SCROLLBAR_ALWAYS);
// Criao do painel para colocar os botes e adio dos botes a
este painel
pnlBotoes = new JPanel(new FlowLayout());
pnlBotoes.add(btnNovo);
pnlBotoes.add(btnSalvar);
pnlBotoes.add(btnLimpar);
pnlBotoes.add(btnSair);
// Criao do painel para a barra de status e adio dos botes a
este painel
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
pnlBarraStatus = new JPanel(new FlowLayout());

pnlBarraStatus.add(lblMensagem);
pnlBarraStatus.add(lblHora);
// Adio dos paineis Janela (JFrame)
add(pnlBotoes, BorderLayout.NORTH);
add(pnlScrTexto, BorderLayout.CENTER);
add(pnlBarraStatus, BorderLayout.SOUTH);
}

}
Em uma janela (JFrame), que considerada um continer, podem ser adicionados diversos elementos, inclusive outros contineres, como JScrollPane e
JPanel. Contineres criados pela classe JPanel podem conter a maioria dos
outros elementos de tela, como caixas de texto, rtulos, caixas de combinao
etc. Contineres criados pela classe JScrollPane podem conter caixas de texto
dimensionadas com colunas e linhas definidas e j permitem apresentar barra
de rolagem.
Para entender o cdigo apresentado, segue a explicao das principais linhas.
Note que esta aplicao composta por quatro painis:
A janela JFrame.
O painel para colocar os botes (pnlBotoes).
O painel com a caixa de texto (pnlScrTexto).
O painel para compor uma barra de status (pnlBarraStatus).
A janela (JFrame) foi configurada para utilizar o layout BorderLayout (linha 21).
O painel para inserir os botes (pnlBotoes) foi configurado para usar o
gerenciador de layout FlowLayout (linha 34).
O painel para inserir a barra de status (pnlBarraStatus) foi configurado para
usar o gerenciador de layout FlowLayout (linha 41).
Para a rea de texto (pnlScrTexto) no foi definido gerenciador de layout
(linhas 30 e 31).
Note que os painis pnlBotoes, pnlScrTexto e pnlBarraStatus so criados,

elementos so adicionados a eles e, por fim, eles so adicionados janela
JFrame (linhas de 46 48).
Note na linha 29, que o rtulo lblHora criado com a data atual que convertida
do tipo Date para String por meio da instruo new Date().toString(), que j
instancia um objeto da classe Date, que obtm a data atual e converte esta data
para String por meio do mtodo toString.
Na linha 30 a caixa de texto criada com um texto padro e com 20 linhas
e 40 colunas. Est caixa de texto adicionada ao painel (pnlScrTexto) que
gera barras de rolagem horizontais e verticais (linha 31), que ficaro sempre
visveis (ALWAYS).
Nas linhas de 34 38 o painel pnlBotoes criado e os botes so adicionados a ele.

Nas linhas de 41 43 o painel pnlBarraStatus criado e os rtulos so
adicionados a ele.
Na linha 46 o painel pnlBotoes adicionado janela ao norte, j que a janela
usa o gerenciador de layout BorderLayout.
Na linha 47 o painel pnlSrcTexto, que contm a caixa de texto com barras de
rolagem, inserido na janela ao centro.
Na linha 48 o painel pnlBarraStatus adicionado janela ao sul.
Aps compilar e executar o projeto pressionando a tecla F6 ser exibida a
janela mostrada na Figura 6.27.
Figura 6.27: Tela com layout composto.
Os botes ainda no respondem ao evento de clique, mas veremos como se

programa isto no decorrer deste captulo.
6.2.5.2 Aspectos visuais da aplicao

Os componentes visuais da API swing podem sofrer a ao de um conjunto de
mtodos que nos permite controlar aspectos visuais dos elementos de tela, como
tipo da fonte, cor da fonte, cor do fundo, cursor, borda etc. Para mostrar como estes
aspectos visuais podem ser modificados, utilizaremos exemplos nos prximos
tpicos considerando os elementos criados no exemplo do tpico anterior.
6.2.5.2.1 Mudando o aspecto do cursor
Considerando o ltimo exemplo apresentado, veja as linhas que permitir

mudar o cursor quando o ponteiro do mouse for posicionado sobre os painis
pnlBotoes, pnlBarraStatus e sobre a rea de texto txtAreaTexto:
Cursor hand = new Cursor(Cursor.HAND_CURSOR);
pnlBotoes.setCursor(hand);
Cursor text = new Cursor(Cursor.TEXT_CURSOR);
txtAreaTexto.setCursor(text);
Cursor cross = new Cursor(Cursor.CROSSHAIR_CURSOR);
pnlBarraStatus.setCursor(cross);
No painel pnlBotoes o cursor aparecer no formato de uma mo com o dedo

indicador apontando um clique (Cursor.HAND_CURSOR). Na caixa de texto
txtAreaTexto aparecer um cursor comum em reas de texto (Cursor.TEXT_
CURSOR). No painel pnlBarraStatus aparecer um cursor no formato de uma
cruz preta (Cursor.CROSSHAIR_CURSOR).
Note que em ambos os casos um objeto da classe Cursor instanciado, passando
para o construtor da classe, como parmetro, uma constante que indica o cursor
desejado. Em seguida, este objeto passado como parmetro a um mtodo
setter da classe que instanciou o elemento, fazendo com que o cursor escolhido
seja aplicado ao elemento.
6.2.5.2.2 Mudando o tipo, efeito e tamanho da fonte

Para mudar o tipo da fonte de um elemento ser necessrio um objeto da classe
Font. Veja o bloco de cdigo a seguir:
Font arialBold = new Font("Calibri", Font.BOLD, 16);
txtAreaTexto.setFont(arialBold);
Font arial = new Font("Arial", Font.ITALIC, 10);
lblMensagem.setFont(arial);
Note que o tipo, efeito e tamanho da fonte definido em um objeto da classe

Font que aplicado ao elemento por meio do mtodo setFont. Na instncia do
objeto da classe Font so passados como parmetro para o construtor o tipo

da fonte, o efeito desejado e o tamanho da fonte.
6.2.5.2.3 Mudando a cor da fonte e do plano de

fundo
Para definir a cor da letra de um elemento basta chamar o mtodo setForeground
a partir do objeto referente ao elemento e passar a cor como parmetro. Isso pode
ser feito de duas maneiras: passando uma constante da classe Color para indicar
a cor ou passando um objeto da classe Color como parmetro.
Veja a definio da cor da fonte por meio de uma constante da classe Color:
txtAreaTexto.setForeground(Color.blue);
Veja a definio da cor da fonte por meio de um objeto da classe Color:

Color cor = new Color(255,0,126);
txtAreaTexto.setForeground(cor);
Ou ainda:
txtAreaTexto.setForeground(new Color(255,0,126));
Para definir a cor do plano de fundo do elemento, utiliza-se o mtodo

setBackground, que funciona de forma semelhante ao mtodo setForeground
apresentado acima.
pnlBotoes.setBackground(new Color(0,255,0));
Ou ainda:
Color cor = new Color(0,255,0);
txtAreaTexto.setForeground(cor);
Ou ainda:
txtAreaTexto.setForeground(Color.green);
6.2.5.2.4 Apresentando dicas sobre o elemento

As dicas so muito teis para indicar formato de preenchimento de campos ou para
descrever botes em um formulrio. Elas aparecem ao posicionar o ponteiro do
mouse sobre o elemento, apresentando o texto referente dica. Veja um exemplo:
btnSalvar.setToolTipText("Clique neste boto para salvar o documento");
Ao posicionar o mouse sobre o boto Salvar (btnSalvar) o texto referente

dica ser mostrado.
6.2.5.2.5 Definindo bordas para o elemento

Para colocar borda em um elemento necessrio um objeto da classe Border,
instanciado a partir do construtor da subclasse LineBorder, passando como
parmetro a cor e a espessura da borda. Veja um exemplo:
Border borda = new LineBorder(Color.RED, 2);
pnlBarraStatus.setBorder(borda);
Ou ainda:
pnlBarraStatus.setBorder( new LineBorder(Color.RED, 2) );
Note que a aplicao no elemento da borda definida ocorre por meio do mtodo
setBorder da classe do elemento em que se quer aplicar a borda. Para que estas
instrues funcionem ter que importar as classes Border e LineBorder, por
meio das instrues:
import javax.swing.border.Border;
import javax.swing.border.LineBorder;
6.2.5.2.6 Centralizando a janela

Para que a janela aparea centralizada quando aplicao for executada, basta
trocar as linhas:
setSize(800, 700);
Por:
Toolkit tk = Toolkit.getDefaultToolkit();
Dimension d = tk.getScreenSize();
int largura = d.width/2;
int altura = d.height/;

setSize(largura, altura);
setLocation(largura/2, altura/2);
Note que o tamanho da tela obtido por meio de uma chamada ao mtodo
getScreenSize da classe Toolkit e armazenado em um objeto d da classe
Dimension. Por meio desse objeto possvel obter a largura (width) e a altura
(height) da tela. A diviso por 2 utilizada para achar o ponto central da tela
(eixos x e y). A janela ter a largura e a altura da medida deste ponto central,
o que definido na passagem do parmetro para o mtodo setSize. O ponto de
posio inicial da janela ser a medida do ponto central dividida por dois, o
que definido no parmetro passado ao mtodo setLocation.
6.2.5.2.7 Dimensionando elementos

Para definir a largura e a altura de um elemento (tamanho), utiliza-se o mtodo
setSize da classe referente ao elemento. Para definir a posio da tela em que
o elemento aparecer, utiliza-se o mtodo setLocation da classe referente ao
elemento. Veja alguns exemplos:
setSize(800, 700);
btnSalvar.setSize(100, 30);
btnSalvar.setLocation(10, 20);
Em lugar destas instrues existe o mtodo setBounds, que define a posio e

o tamanho do elemento em uma nica instruo. Veja como fica os exemplos
anteriores utilizando o mtodo setBounds:
setBounds(300, 200, 800, 700);
btnSalvar.setBounds(10, 20,100, 30);
Os dois primeiros parmetros referem-se ao posicionamento do elemento nos

eixos x e y. Os dois ltimos parmetros referem-se largura e altura do elemento.
6.2.6 Criao de interfaces grficas ricas

utilizando a API swing
At agora utilizamos classes para a criao de componentes visuais mais
bsicos da API swing, como janelas (classe JFrame), botes (classe JButton),
rtulos (classe JLabel), campos de texto (classe JTextField), rea de texto
(classe JTextArea), painis de rolagem (classe JScrollPane) e painel de uso
geral (classe JPanel).
Neste tpico, vamos utilizar outros componentes que nos permitir criar
interfaces mais ricas, com menus (classe JMenuBar), caixas de dilogo (classe
JOptionPane), combos (classe JComboBox), listas (classe JList) e tabelas
(classe JTable).
6.2.6.1 Criando menus

Para construir um menu voc precisar criar uma barra de menus, as opes do
menu principal e os itens de cada opo deste menu. Para isso ter que utilizar,
respectivamente, as classes JMenuBar, JMenu e JMenuItem.
Primeiro voc cria os itens de menu, os menus e a barra de menus. Depois,

adiciona os itens de menu aos menus, adiciona os menus na barra de menus
e, por ltimo, adiciona a barra de menu janela.
Vamos criar um exemplo para gerar a tela mostrada na Figura 6.28.
Figura 6.28: Criao de menus.
Crie um projeto chamado ProjetoMenu com uma classe principal chamada

TelaMenu.java, conforme mostra a Figura 6.29.
Figura 6.29: Projeto para criao de menus.
Na classe TelaMenu.java, digite o seguinte cdigo-fonte:

1
2
3
4
public class TelaMenu extends JFrame {
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
private JMenuItem mnuItmAbrir, mnuItmNovo, mnuItmSalvar, mnuItmSair,

mnuItmCopiar, mnuItmColar, mnuItmRecortar;
private JMenu mnuArquivo, mnuEditar;
private JMenuBar mnuBar;
public TelaMenu() {
setTitle("Exemplo de menu");
setSize(400, 200);
// instanciando os objetos referentes aos elementos do menu
mnuItmAbrir = new JMenuItem("Abrir");
mnuItmNovo = new JMenuItem("Novo");
mnuItmSalvar = new JMenuItem("Salvar");
mnuItmSair = new JMenuItem("Sair");
mnuItmCopiar = new JMenuItem("Copiar");
mnuItmColar = new JMenuItem("Colar");
mnuItmRecortar = new JMenuItem("Recortar");
mnuArquivo = new JMenu("Arquivo");
mnuEditar = new JMenu("Editar");
// Adicionando os itens de menu ao menu Arquivo
mnuArquivo.add(mnuItmAbrir);
mnuArquivo.add(mnuItmNovo);
mnuArquivo.add(mnuItmSalvar);
mnuArquivo.addSeparator();
mnuArquivo.add(mnuItmSair);
// Adicionando os itens de menu ao menu Editar
mnuEditar.add(mnuItmCopiar);
mnuEditar.add(mnuItmColar);
mnuEditar.add(mnuItmRecortar);
// Adicionando os menus barra de menus
mnuBar = new JMenuBar();
mnuBar.add(mnuArquivo);
mnuBar.add(mnuEditar);
// Adicionando a barra de menus janela
setJMenuBar(mnuBar);
}

TelaMenu tela = new TelaMenu();
}
As linhas de 6 8 declaram os objetos que sero utilizados nos menus. Estes

objetos so instanciados nas linhas de 16 24.
As linhas de 26 30 constroem o menu Arquivo, ou seja, adiciona (ou agrega)
as opes Abrir, Novo, Salvar e Sair ao menu Arquivo. Note, na
linha 29, que o mtodo addSeparator adiciona uma linha de separao entre
as opes Salvar e Sair.
As linhas de 32 34 constroem o menu Editar, ou seja, adiciona as opes
Copiar, Colar e Recortar ao menu Editar.
As linhas 37 e 38 adicionam o menu Arquivo e o menu Editar barra de

menus.
A linha 40 adiciona a barra de menus janela. Note que no foi necessrio
definir um gerenciador de layout para a barra de menus, pois ela posicionada,
por padro, na parte superior da tela.
Se desejasse voc poderia adicionar outros elementos na tela abaixo da barra
de menus. Observe que as aes de clique das opes do menu no esto
funcionando, pois ainda no foram programadas. Voc vai aprender como
programar botes e opes de menu mais frente, ainda nesse captulo.
6.2.6.2 Trabalhando com caixas de dilogo

A classe JOptionPane da API swing traz um conjunto de caixas de dilogo
prontas que podem ser chamadas pelos mtodos showConfirmDialog,
showInputDialog, showMessageDialog e showOptionDialog. Estes mtodos
so descritos a seguir:
showConfirmDialog confirmao de ao.
showInputDialog entrada de dados.
showMessageDialog exibio de mensagem.
showOptionDialog caixa personalizada.
NOTA
Os mtodos da classe JOptionPane so pblicos e estticos, por isso

podem ser chamados diretamente a partir do nome da classe. Estes mtodos tambm so sobrecarregados, ou seja, so escritos na classe vrias vezes, porm, recebendo parmetros diferentes.
6.2.6.2.1 Mtodo showMessageDialog

O mtodo showMessageDialog da classe JOptionPane permite mostrar diversos
tipos de mensagens em uma caixa de dilogo.
A forma mais simples de uso desse mtodo definindo apenas a mensagem:
JOptionPane.showMessageDialog(null, "Erro na aplicao");
Note que apenas dois parmetros so passados para o mtodo showMessageDialog:

null e a mensagem Erro na aplicao.
Veja a tela que ser gerada na Figura 6.30.
Figura 6.30: Caixa de dilogo de mensagem.
O parmetro null refere-se ao nome nome do objeto em que se quer relacionar

a caixa de dilogo. Se for, por exemplo, um boto JButton chamado btnSalvar,
voc poderia escrever a linha da seguinte forma:
JOptionPane.showMessageDialog(btnSalvar, "Erro na aplicao");
Nesse caso, a caixa de dilogo ser relacionada ao boto btnSalvar e aparecer,

consequentemente, sobre este boto na tela.
Veja outro exemplo onde outras propriedades da caixa de dilogo so definidas,
como ttulo, formato do cone e mensagem:
JOptionPane.showMessageDialog(null, "Erro na aplicao", "Falha no aplicativo", JOptionPane.
ERROR_MESSAGE);
Nesse caso, o mtodo showMessageDialog recebe como parmetro o nome do

objeto ao qual a caixa de dilogo estar relacionada (neste caso, null significa
que no estar relacionada a nenhum objeto), a mensagem, o ttulo da caixa
de dilogo e o formato do cone que ficar esquerda da mensagem. Veja a
janela que ser gerada na Figura 6.31.
Figura 6.31: Caixa de dilogo indicando erro.
6.2.6.2.2 Mtodo showInputDialog
O mtodo showInputDialog abre uma caixa de dilogo onde se pode entrar

com um valor. O valor digitado ser sempre do tipo String, independente de
ser nmero ou no. Veja um exemplo:
String nome = JOptionPane.showInputDialog("Qual seu nome?:");
Veja na Figura 6.32 o que aparecer na tela ao executar a linha acima:
Figura 6.32: Caixa de dilogo para entrada de dados.
Voc tambm pode pedir a informao colocando ttulo na janela e personalizando o cone que aparece esquerda. Veja como na linha abaixo:
String nome = JOptionPane.showInputDialog(null, "Qual seu nome?: ", "Cadastro", JOptionPane.
DEFAULT_OPTION);
Veja na Figura 6.33 o que aparece na tela ao executar a linha acima:
Figura 6.33: Caixa de dilogo de entrada com ttulo.
Como visto nos captulos anteriores, para receber o valor digitado em uma
varivel de tipo numrico primitivo voc deve converter o valor digitado de
String para o tipo numrico desejado.
Veja os exemplos a seguir:
byte idade = Byte.parseByte(JOptionPane.showInputDialog("Qual a sua idade"));
int cod = Integer.parseInt(JOptionPane.showInputDialog("Digite o cdigo do produto"));
long codBarra = Long.parseLong(JOptionPane.showInputDialog("Digite o cdigo de barras"));
double sal = Double.parseDouble(JOptionPane.showInputDialog("Digite o salrio"));
6.2.6.2.3 Mtodo showConfirmDialog

O mtodo showConfirmDialog gera uma janela para confirmao de alguma
ao, onde o usurio pode clicar em uma das opes disponveis, normalmente,
Sim ou No. Veja um exemplo:
int op = JOptionPane.showConfirmDialog(null, "Deseja encerrar?", "sair do Sistema",
JOptionPane.YES_NO_OPTION);
if (op == 0) {
JOptionPane.showMessageDialog(null, "Voc clicou na opo Sim");
} else if (op == 1) {
JOptionPane.showMessageDialog(null, "Voc clicou na opo No");
}
Ao executar o cdigo acima, veja na Figura 6.34 como aparecer a caixa de

dilogo:
Figura 6.34: Caixa de dilogo de confirmao.
Se clicar na opo Sim, este mtodo retorna o valor 0. Se clicar na opo

No, este mtodo retorna o valor 1.
6.2.6.2.4 Mtodo showOptionDialog

O mtodo showOptionDialog permite criar caixas de dilogo personalizadas
a partir de opes presentes em uma array unidimensional. Veja o exemplo:
Object[] opt = {"Sim", "No", "No sei"};

int op = JOptionPane.showOptionDialog(null, "Clique OK para continuar", "Aviso",
JOptionPane.DEFAULT_OPTION, JOptionPane.INFORMATION_MESSAGE, null, opt,
opt[0]);
if (op == 0) {
JOptionPane.showMessageDialog(null, "Voc clicou na opo Sim");
} else if (op == 1) {
JOptionPane.showMessageDialog(null, "Voc clicou na opo No");
} else if (op == 2) {
JOptionPane.showMessageDialog(null, "Voc clicou na opo No Sei");
}
Veja na Figura 6.35 a caixa de dilogo gerada:
Figura 6.35: caixa de dilogo de confirmao personalizada.
Se clicar no boto Sim, o mtodo showOptionDialog retornar o valor 0.

Se clicar no boto No, este mtodo retornar o valor 1. Se clicar no boto
No Sei, este mtodo retornar o valor 2.
6.2.6.3 Trabalhando por botes

Na API swing h vrias classes para criar os mais variados tipos de botes. J
utilizamos a classe JButton para criar botes padro.
Existe ainda a classe JRadioButton, para criar botes circulares agrupados pela
classe ButtonGroup, de forma que apenas um dos botes do grupo possa ser
selecionado. ideal para escolha de sexo, estado civil etc.
A classe JCheckBox permite criar botes quadrados e pequenos e permite
que mais de um esteja selecionado ao mesmo tempo. ideal para seleo de
produtos, por exemplo.
A classe JToogleButton permite criar botes que podem ser ativados e
desativados, alternado a cada clique.
Para testar a criao de botes, crie um projeto chamado ProjetoBotoes com

uma classe chamada Tela.java, conforme mostra a Figura .
Figura 6.36: Projeto utilizando botes variados.
Digite o seguinte cdigo-fonte na classe Tela.java:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
import java.awt.*;
private JButton btnSalvar, btnAbrir;
private JCheckBox chkTeatro, chkCinema, chkTv;
private JRadioButton rdoMasculino, rdoFeminino;
private JToggleButton tglAlarme;
private JPanel pnlBotoes1, pnlBotoes2, pnlBotoes3, pnlBotoes4;
public Tela() {
// Propriedades dajanela JFrame
setTitle("Exemplo com botes");
setSize(300, 200);
// Criao (instncia) dos botes
btnAbrir = new JButton("Abrir");
chkTeatro = new JCheckBox("Teatro");
chkCinema = new JCheckBox("Cinema");
chkTv = new JCheckBox("TV");
rdoMasculino = new JRadioButton("Masculino");
rdoFeminino = new JRadioButton("Feminino");
tglAlarme = new JToggleButton("Alarme");
// Criao do painel 1 e adio de botes
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
pnlBotoes1 = new JPanel();

pnlBotoes1.add(btnSalvar);
pnlBotoes1.add(btnAbrir);
pnlBotoes2.add(chkTeatro);
pnlBotoes2.add(chkCinema);
pnlBotoes2.add(chkTv);
// Criao do grupo ao qual so adicionados os botes radio
ButtonGroup gruSexo = new ButtonGroup();
gruSexo.add(rdoMasculino);
gruSexo.add(rdoFeminino);
pnlBotoes3.add(rdoMasculino);
pnlBotoes3.add(rdoFeminino);
// Criao do painel 4 e adio doboto
pnlBotoes4.add(tglAlarme);
// Adio dos botes janela

add(pnlBotoes1);
add(pnlBotoes2);
add(pnlBotoes3);
add(pnlBotoes4);
public static void main(String arg[]) {

}
A tela dividida em 4 clulas de tamanhos iguais pelo gerenciador de layout

GridLayout (linha 17), ou seja, este gerenciador define que a janela ter 4
linhas e uma coluna.
Note que so criados 4 painis (pnlBotoes1, pnlBotoes2, pnlBotoes3 e
pnlBotoes4). Em cada um so adicionados os botes de tipos diferentes (linhas
32 34, 37 40, 48 50, 53 e 54) e depois esses painis so adicionados
janela (linhas 57 60).
Perceba nas linhas de 43 45 que os botes do tipo JRadioButton so

adicionados a um mesmo grupo do tipo ButtonGroup. Isso necessrio para
que no seja permitido selecionar mais de um boto do grupo.
Ao compilar e executar o projeto por meio do pressionamento da tecla F6 ser

exibida a janela mostrada na Figura
Figura 6.37: Janela com botes diversificados.
Observe que os botes de cada linha esto em um painel diferente. Note que podem
ser selecionados vrios botes check da segunda linha, porm na terceira linha
permitido selecionar apenas um sexo por meio dos botes radio. Na terceira linha
o boto Alarme pode ser ativado com um clique e desativado com outro. Veja
na Figura 6.38 como ficar a janela aps as algumas selees de botes.
Figura 6.38: janela com botes selecionados.
Ainda no estamos programando as aes dos botes, ou seja, o que deve

ocorrer quando o boto for clicado, mas vamos fazer isso mais a frente no
tpico sobre tratamento de eventos.
6.2.6.3.1 Mtodos para trabalhar com botes

H um conjunto de mtodos para se trabalhar com botes que pode incluir
ou obter o rtulo dos botes, verificar se o boto foi selecionado, selecionar
o boto automaticamente etc. Estes mtodos se aplicam a todos os botes
vistos no exemplo anterior, ou seja, a botes das classes JCheckBox, JButton,
JRadioButton e JToggleButton. Veja a seguir os principais mtodos:
String teatro = chkTeatro.getText();
Obtm o rtulo do boto e armazena em uma varivel String.
chkTeatro.setText(Shows);
Troca o rtulo do boto pela palavra Shows.

chkTeatro.setSelected(true);
Seleciona automaticamente o boto.
chkTeatro.setVisible(true);
Torna o boto visvel. Para ocult-lo, mude o parmetro para false.
if(chkTeatro.isSelected()){}
Verifica se o boto est selecionado.
6.2.6.4 Trabalhando com campos texto

Em uma janela a entrada de dados feita normalmente por meio de campos
texto. H vrias classes na API swing que permitem a entrada de texto, cada
uma com caractersticas especficas.
A classe JTextField j foi utilizada em projetos anteriores nesse livro. Ela
permite a criao de uma caixa para entrada de texto com uma linha, sem
formatao.
A classe JTextArea permite a criao de caixas para entrada de texto com
mltiplas linhas, sem formatao.
A classe JPasswordField permite a criao de campos para entrada de senhas,
com uma linha, sem formatao, onde os caracteres digitados no aparecem
de forma clara.
A classe JFormattedTextField permite a criao de campos formatados, onde
se pode definir mscaras de entrada por meio da classe MaskFormatter e outros
tipos de formatao.
Para testar o uso dessas classes, crie um novo projeto chamado ProjetoCampos,
com uma classe chamada Tela.java, como mostra a Figura 6.39.
Figura 6.39: projeto utilizando campos texto.
Digite o seguinte cdigo-fonte para a classe Tela.java:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
import java.awt.*;
import java.text.*;
import javax.swing.text.MaskFormatter;
private JLabel lblNome, lblNascimento, lblTelefone, lblCpf, lblCep, lblEndereco;
private JTextField txtNome;
private JFormattedTextField txtNascimento, txtCep, txtTelefone, txtCpf;
private JTextArea txtEndereco;
MaskFormatter mskCep, mskTelefone, mskCpf, mskNascimento;
public Tela() {
FlowLayout esquerda = new FlowLayout(FlowLayout.LEFT);
setSize(600, 450);
// Criao dos rtulos dos campos
lblNome = new JLabel("Nome");
lblNascimento = new JLabel("Nascimento");
lblTelefone = new JLabel("Telefone");
lblCpf = new JLabel("CPF");
lblCep = new JLabel("CEP");
lblEndereco = new JLabel("Endereo");
// Criao dos campos e definio das mscaras quando pertinente
try {
mskNascimento = new MaskFormatter("##/##/####");
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
mskNascimento.setPlaceholderCharacter('_');
mskTelefone = new MaskFormatter("(##)####-####");
mskTelefone.setPlaceholderCharacter('_');
mskCpf = new MaskFormatter("#########-##");
mskCpf.setPlaceholderCharacter('_');
mskCep = new MaskFormatter("#####-###");
mskCep.setPlaceholderCharacter('_');
} catch (ParseException ex) {
JOptionPane.showMessageDialog (null,"Erro na definio das
mscaras dos campos");
}
txtNascimento = new JFormattedTextField(mskNascimento);
txtTelefone = new JFormattedTextField(mskTelefone);
txtCpf = new JFormattedTextField(mskCpf);
txtCep = new JFormattedTextField(mskCep);
txtEndereco = new JTextArea("", 3, 40);
JScrollPane scrollEndereco = new JScrollPane(txtEndereco,
JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED,
JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED);
// Criao do painel para insero do rtulo e do campo nome
JPanel pnlNome = new JPanel(esquerda);
pnlNome.add(lblNome);
pnlNome.add(txtNome);
// Criao do painel para insero do rtulo e do campo nascimento
JPanel pnlNascimento = new JPanel(esquerda);
pnlNascimento.add(lblNascimento);
pnlNascimento.add(txtNascimento);
// Criao do painel para insero do rtulo e do campo telefone
JPanel pnlTelefone = new JPanel(esquerda);
pnlTelefone.add(lblTelefone);
pnlTelefone.add(txtTelefone);
// Criao do painel para insero do rtulo e do campo CPF
JPanel pnlCpf = new JPanel(esquerda);
pnlCpf.add(lblCpf);
pnlCpf.add(txtCpf);
// Criao do painel para insero do rtulo e do campo CEP
JPanel pnlCep = new JPanel(esquerda);
pnlCep.add(lblCep);
pnlCep.add(txtCep);
// Criao do painel para insero do rtulo e do campo endereo
JPanel pnlEndereco = new JPanel(esquerda);
pnlEndereco.add(lblEndereco);
pnlEndereco.add(scrollEndereco);
// Adio dos paineis janela
add(pnlNome);
74
75
76
77
78
79
80
81
82
83
84
85
86
add(pnlNascimento);
add(pnlTelefone);
add(pnlCpf);
add(pnlCep);
add(pnlEndereco);
}

}
Esta classe apresenta um conjunto de campos de entrada na tela, desde

campos simples at campos formatados e caixas de texto. Cada campo
colocado em um painel e este painel colocado na janela, um abaixo do
outro, sequencialmente.
Temos uma forma um pouco diferente de aplicao de gerenciadores de layout.
Veja na linha 16 que a janela (JFrame) usa o gerenciador de layout GridLayout
com 6 linhas e uma coluna, ou seja, com 6 clulas, uma abaixo da outra. Em
cada clula ser colocado um painel com um campo diferente.
Como se deseja colocar os painis alinhados esquerda, instanciou-se um
objeto chamado esquerda, da classe FlowLayout, na linha 17, utilizando
o parmetro FlowLayout.LEFT que define o alinhamento do contedo do
continer que aplicar esse layout esquerda. Note que este gerenciador de
layout representado pelo objeto esquerda usado nos painis instanciados
nas linhas 49, 53, 57 61, 65 e 69. Isso faz com que estes painis tenham seu
contedo alinhado esquerda.
Nas linhas de 31 38 foram definidas as mscaras de entrada para diversos
campos. Perceba que para cada campo definida uma mscara por meio de
um objeto da classe MaskFormatter e o caracter que deve aparecer no lugar
do cerquilha (#) da mscara, neste caso, o underline (_).
Perceba que as mscaras so aplicadas aos campos nas linhas de 42 45.
Note tambm que a criao das mscaras ocorre no interior de uma estrutura
de tratamento de exceo try. Isso necessrio porque na criao da mscara
instanciado um objeto da classe MaskFormatter passando a mscara como
parmetro String. Esse parmetro pode estar incorreto e, nesse caso, quando ele
for convertido de String para uma mscara vlida pode ocorrer uma exceo
do tipo ParseException, caindo no bloco catch e exibindo uma mensagem. Se
as mscaras estiverem corretas, o bloco catch jamais ser executado.
As linhas 46 e 47 criam uma caixa de texto para o endereo. Veja na linha 46

que o objeto da caixa de texto (JTextArea) instanciado vazio, com 3 linhas
e 40 colunas. Como caixas de texto podem conter mais texto do que a parte
visvel comporta, a linha 47 adiciona barras de rolagem caixa de texto que
aparecero somente se o texto exceder o tamanho da caixa.
As linhas de 49 51 criam um painel e incluem o campo nome nele. As linhas de
53 55 criam outro painel e incluem o endereo. As demais linhas, na sequncia,
criam os painis para os demais campos e incluem os respectivos campos neles.
As linhas de 73 78 incluem os painis na janela, lembrando que eles usam

o gerenciador de layout FlowLayout e a janela usa o gerenciador de layout
GridLayout.
DICA
Use sempre que possvel painis para agrupar campos ou para agrupar
rtulo e campo. Painis podem ser configurados e formatados facilmente,
podendo receber cores, bordas etc.
Ao compilar e executar o projeto por meio do pressionamento da tecla F6

aparecer a tela mostrada na Figura 6.40.
Figura 6.40: Janela com campos.
Veja na Figura 6.41 como fica a tela aps o preenchimento dos campos.
Figura 6.41: janela com campos preenchidos.
6.2.6.4.1 Mtodos para trabalhar

com campos texto
H um conjunto de mtodos que pode manipular valores em campos texto e
permitem, entre outras coisas, adicionar valores aos campos, obter os valores
digitados, posicionar o cursor no campo etc.
Os exemplos apresentados a seguir aplicam-se a todos os tipos de campos
texto vistos at agora, ou seja, a campos das classes JFormattedTextField,
JTextField e JTextArea.
String cep = txtCep.getText();
Obtm o texto digitado no campo e armazena em uma varivel do tipo String.
txtCep.requestFocus();
Posiciona o cursor no campo.
txtCep.setForeground(Color.BLUE);
Define a cor de letra para o campo.
txtCep.setBackground(Color.red);
Define a cor de fundo para o campo.
txtCep.setFont(new Font("Arial", Font.BOLD, 14));
Define uma configurao de fonte para o campo.
txtCep.setText("04135-090");
Inclui o valor entre aspas no campo.
6.2.6.5 Trabalhando com listas

Para trabalhar com listas utilizando a API swing normalmente voc utiliza duas
classes principais: JList e DefaultListModel.
A classe JList cria a lista. Se quisermos utilizar um modelo de lista j existente
(o que indicado) utilizamos a classe DefaultListModel.
Para entender como trabalhar com listas, crie um projeto chamado ProjetoLista
com uma classe principal chamada TelaLista.java, conforme mostra a Figura
6.42.
Figura 6.42: Projeto para trabalhar com listas.
Na classe TelaLista.java, digite o seguinte cdigo-fonte:

1
2
3
4
5
6
7
8
9
10
11
import java.awt.*;
public class TelaLista extends JFrame {
private JList lstCidades;
private DefaultListModel lstCidadesModel;
public TelaLista() {
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
setTitle("Exemplo com lista");

setSize(200, 150);
lstCidadesModel = new DefaultListModel();

lstCidades = new JList(lstCidadesModel);
String cidade1 = "So Paulo";

String cidade2 = "Rio de Janeiro";
String cidade3 = "Campinas";
lstCidadesModel.addElement(cidade1);
add(lstCidades, BorderLayout.CENTER);
JLabel lblCidade = new JLabel("Escolha uma cidade");

add(lblCidade, BorderLayout.NORTH);

TelaLista tela = new TelaLista();
}
Para criar uma lista foram utilizados objetos de duas classes: DefaultListModel
e JList. Quando foi instanciado um objeto da classe JList que efetivamente criou
a lista, foi preciso passar como parmetro o objeto da classe DefaultListModel,
indicando que a lista utiliza um modelo padro (linha 19).
Note nas linhas de 22 24 que so criadas trs variveis do tipo String como
nomes de cidades que sero colocadas na lista nas linhas de 26 28 por meio dos
mtodos addElement da classe DefaultListModel. As opes da lista recebem um
nmero de ndice iniciado por 0, na ordem que so inseridas na lista.
Na linha 30 a lista adicionada janela (JFrame) utilizando o gerenciador de
layout BorderLayout. Veja que a lista posicionada na rea CENTER, ou
seja, na rea central do layout.
Para que a lista tenha um rtulo como ttulo, um objeto da classe JLabel foi
instanciado na linha 32 e adicionado janela, ao norte.

Figura 6.43: janela com listas.
Veja que foi clicado na primeira opo da lista e ela ficou selecionada. Voc
pode rolar o cursor sobre os elementos da lista utilizando as teclas de direo
do teclado ou clicar na opo que deseja selecionar.
6.2.6.5.1 Mtodos para trabalhar com as listas

Na classe apresentada, por meio do objeto lstCidadesModel da classe
DefaultListModel possvel acessar um conjunto de mtodos teis para
manipular opes na lista, dentre eles:
lstCidadesModel.add(2, "Franca");
Adiciona o elemento "Franca" na terceira posio da lista de cima para baixo,
ou seja, na posio de ndice 2.
lstCidadesModel.clear();
Remove todos os elementos da lista.
if(lstCidadesModel.contains("Campinas")){ }
Verifica se a lista contm a opo "Campinas".
if(lstCidadesModel.isEmpty()){}
Verifica se a lista est vazia.
String cidade = (String) lstCidadesModel.elementAt(1);

Obtm o elemento de ndice 1 da lista, converte em String e armazena na
varivel String cidade.
String cidade = (String) lstCidadesModel.firstElement();
Obtm o primeiro elemento da lista, converte em String e armazena na varivel
String cidade.
String cidade = (String) lstCidadesModel.lastElement();
Obtm o ltimo elemento da lista, converte em String e armazena na

String cidade = (String) lstCidadesModel.get(1);
Obtm o elemento de ndice 1 da lista, converte em String e armazena na
int total = lstCidadesModel.getSize();
Obtm o nmero de elementos da lista.
lstCidadesModel.insertElementAt("Itu", 2);
Insere o elemento "Itu" na posio de ndice 2 da lista.
lstCidadesModel.remove(2);
Remove o elemento de ndice nmero 2 da lista, ou seja, a terceira opo da
lista de cima para baixo.
lstCidadesModel.removeAllElements();
Remove todos os elementos da lista e define o tamanho da lista como 0.
lstCidadesModel.removeElement("So Paulo");
Remove o elemento "So Paulo" da lista.
lstCidadesModel.removeElementAt(2);
Remove o elemento de ndice 2.
lstCidadesModel.set(2, "Votuporanga");
Substitui o item de ndice 2 da lista por "Votuporanga".
lstCidadesModel.setSize(2);
Define o nmero de elementos visveis na lista.
int tamanho = lstCidadesModel.size();

Obtm o tamanho da lista.
Voc percebeu que as opes foram adicionadas lista (JList) por meio do
seu modelo (DefaultListModel). Se voc quiser, pode dispensar o modelo e
adicionar as opes diretamente na lista, da seguinte forma:
String[] cidades = new String[]{"So Paulo", "Rio de Janeiro", "Campinas"};
JList lstCidades = new JList(cidades);
Neste caso voc poderia utilizar no objeto lstCidades da classe JList para
acessar diversos mtodos importantes, dentre eles:
int indiceSelecionado = lstCidades.getSelectedIndex();
Obtm o nmero de ndice da opo selecionada na lista.
lstCidades.setForeground(Color.BLUE);
Define uma cor de letra para as opes da lista.
lstCidades.setFont(new Font("Arial", Font.BOLD, 14));
Define uma configurao de fonte para as opes da lista.
6.2.6.6 Trabalhando com caixas de combinao

De forma semelhante criao de listas, a criao de caixas de combinao (combo
boxes) necessita de uma classe para a criao do combo (JComboBox) e uma
classe para definir um modelo padro a ser utilizado (DefaultComboBoxModel).
Para entender como funciona a criao de caixas de combinao, crie um novo

projeto Java chamado ProjetoComboBox com uma classe chamada TelaCombo.
java, conforme mostra Figura 6.44.
Figura 6.44: projeto com combo boxes.
Na classe TelaCombo.java digite o seguinte cdigo-fonte:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import java.awt.*;
public class TelaCombo extends JFrame {
private JComboBox cmbCidades;
private DefaultComboBoxModel cmbCidadesModel;
public TelaCombo() {
setTitle("Exemplo ComoBox");
setSize(300, 200);
cmbCidadesModel = new DefaultComboBoxModel();
cmbCidades = new JComboBox(cmbCidadesModel);
cmbCidadesModel.addElement(cidade1);
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
cmbCidades.setEditable(true);
JPanel auxNomes = new JPanel();
auxNomes.add(cmbCidades);
add(auxNomes, BorderLayout.WEST);
JLabel lblTituloLista = new JLabel("Escolha uma opo");

add(lblTituloLista, BorderLayout.NORTH);

TelaCombo tela = new TelaCombo();
}
Note na linha 17 que foi instanciado um objeto da classe DefaultComboBoxModel.

Este objeto foi passado como parmetro na instncia de um objeto da
classe JComboBox na linha 18. Isso significa que a caixa de combinao
usar o modelo de caixa de combinao padro definido pela classe
DefaultComboBoxModel.
Nas linhas de 20 22 foram armazenados em variveis String o nome das
cidades que foram adicionadas caixa de combinao nas linhas de 24 26.
Perceba que os nomes das cidades so passados como parmetro ao mtodo
addElement da classe DefaultComboBoxModel. Cada opo na caixa de
combinao recebe um nmero de ndice, na ordem em que foram inseridos,
comeando por 0. Logo So Paulo tem ndice 0, Rio de Janeiro tem ndice
1 e Campinas tem ndice 2.
Para tornar a caixa de combinao editvel foi usado o mtodo setEditable da
classe JComboBox, passando como parmetro o valor true (linha 27). Dessa
forma a caixa de combinao permitir a entrada de dados via linha editvel.
Nas linhas de 29 e 30 foi criado um painel e a lista foi adicionada a ele. Em
seguida, na linha 31, este painel foi adicionado janela usando o gerenciador
de layout BorderLayout, que o posicionou esquerda da janela (WEST).
Na linha 33 foi instanciado um objeto da classe JLabel, usado como rtulo,
que foi posicionado acima da caixa de combinao. Este objeto foi adicionado
janela na linha 34, na posio norte do layout, ou seja, acima da caixa de
combinao.
Ao compilar e executar o projeto por meio do pressionamento da tecla F6 ser

mostrada a janela esquerda na Figura 6.45.
Figura 6.45: Janela com combo boxes.
Ao clicar na caixa de combinao ela se abre, como mostra a janela da direita.
6.2.6.6.1 Mtodos para trabalhar com as caixas

de combinao
Aps criar uma caixa de combinao, podemos utilizar um conjunto de mtodos
por meio do objeto da classe DefaultComboBoxModel para adicionar novos
elementos, remover elementos, obter elementos e executar outras operaes
na caixa de combinao. Alguns dos principais mtodos para executar estas
operaes so apesentados a seguir:
String cidade = (String) cmbCidadesModel.getElementAt(1);
Obtm o elemento de ndice 1 da lista, converte em String e armazena na varivel
cidade.
String cidade = (String) cmbCidadesModel.getSelectedItem();
Obtm o elemento selecionado na lista, converte em String e armazena na
varivel cidade.
int tamanho = cmbCidadesModel.getSize();
Obtm o tamanho da lista e armazena na varivel tamanho.
cmbCidadesModel.insertElementAt("Franca", 2);
Insere o elemento "Franca" na posio de ndice 2 da lista.
cmbCidadesModel.removeAllElements();
Remove todos os elementos da lista.
cmbCidadesModel.removeElement("Campinas");
Remove o elemento "Campinas" da lista.
cmbCidadesModel.removeElementAt(1);
Remove o elemento de ndice 1 da lista.
cmbCidadesModel.setSelectedItem("Itu");
Muda o item selecionado da lista para "Itu".
Voc pode perceber que na classe apresentada adicionamos os itens caixa de
combinao (JComboBox) por meio de seu modelo (DefaultComboBoxModel)
utilizando o mtodo addElement (linhas de 24 26). Voc poderia adicionar
os elementos diretamente caixa de combinao, dispensando o modelo, da
seguinte forma:
String[] cidades = new String[]{"So Paulo", "Rio de Janeiro", "Campinas"};
JComboBox cmbCidades = new JComboBox(cidades);
Ou ainda:
JComboBox cmbCidades = new JComboBox();
cmbCidades.addItem("So Paulo");
cmbCidades.addItem("Rio de Janeiro");
cmbCidades.addItem("Campinas");
Veja alguns mtodos que podem ser aplicados por meio do objeto cmbCidades
da classe JComboBox, sem utilizar o DefaultComboBoxModel:
cmbCidades.removeItem("Rio de Janeiro");
Remove o item "Rio de Janeiro" da caixa de combinao.
cmbCidades.removeItemAt(1);
Remove o segundo item da caixa de combinao, de cima para baixo, ou seja,
o item "Rio de Janeiro", que tem ndice 1.
cmbCidades.removeAllItems();
Remove todos os itens da caixa de combinao.
cmbCidades.setSelectedItem("Campinas");
A opo selecionada e visvel na caixa de combinao ser "Campinas".
cmbCidades.setSelectedIndex(2);
A opo selecionada e visvel na caixa de combinao ser a terceira opo de

cima para baixo (opo que tem ndice 2), ou seja, "Campinas".
String cidadeSelecionada = (String) cmbCidades.getSelectedItem();
Obtm a cidade selecionada na caixa de combinao, converte para String e
armazena na varivel String cidadeSelecionada.
int indiceSelecionado = cmbCidades.getSelectedIndex();
Obtm o nmero de ndice da opo selecionada na caixa de combinao e
armazena na varivel indiceSelecionado.
String cidade = (String) cmbCidades.getItemAt(2);
Obtm a cidade de ndice 2 na caixa de combinao, converte para String e
armazena na varivel String cidade. A opo de ndice 2 "Campinas".
int totalCidades = cmbCidades.getItemCount();
Obtm o nmero de opes que tem na caixa de combinao e armazena na
varivel totalCidades.
cmbCidades.setForeground(Color.BLUE);
Define a cor azul de fundo para a caixa de combinao.
cmbCidades.setFont(new Font("Arial", Font.BOLD, 14));
Define a fonte arial, com efeito de negrito e de tamanho 14 para a caixa de
combinao.
cmbCidades.setMaximumRowCount(2);
Define o nmero de opes que estar visvel quando abrir a caixa de combinao.
6.2.6.7 Trabalhando com tabelas

As tabelas so muito teis para a exibio de dados, principalmente resultantes
de consultas realizadas a bancos de dados. Para criar tabelas podem ser
utilizadas duas classes principais: JTable e TableModel.
A classe JTable utilizada para a criao da tabela. Para aplicar a ela um
modelo padro que nos isenta da responsabilidade de criar um novo modelo
de tabela, utilizamos a classe DefaultTableModel.
Para testar o uso destas classes, crie um novo projeto chamado ProjetoTabela
com uma classe principal chamada TelaTabela.java, conforme mostra a Figura
Figura 6.46: Projeto para trabalhar com tabelas.
Na classe TelaTabela.java, digite o seguinte cdigo-fonte:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import javax.swing.table.*;
import java.awt.*;
public class TelaTabela extends JFrame {
private JTable tblClientes;
private DefaultTableModel tblClientesModel;
public TelaTabela() {
setTitle("Exemplo de tabela");
setSize(400, 200);
String[] cols = {"Cdigo", "Nome", "E-mail"};
tblClientesModel = new DefaultTableModel(cols, 4);
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
tblClientes = new JTable(tblClientesModel);

String[] linha1 = {"1", "Fernando Pereira de Souza", "fersouza@ig.com.br"};
String[] linha2 = {"2", "Angela Cristina", "acris@ig.com.br"};
String[] linha3 = {"3", "Pedro Henrique", "pedro@yahoo.com.br"};
String[] linha4 = {"4", "Ana Luiza Benfica", "ana@gmail.com"};
tblClientesModel.insertRow(0, linha1);
tblClientesModel.setNumRows(4);
JScrollPane scrRolagem = new JScrollPane(tblClientes,
add(scrRolagem, BorderLayout.CENTER);
JLabel lblTitulo = new JLabel("Lista de Clientes");
add(lblTitulo, BorderLayout.NORTH);
}

TelaTabela tela = new TelaTabela();
}
Note que na linha 17 foi criada uma array unidimensional e nela foram
armazenados os valores que sero rtulos das colunas da tabela. Esta array
foi adicionada tabela na linha 18, juntamente com o nmero de linhas que a
tabela dever ter, neste caso, 4 linhas.
Na linha 19 foi instanciado um objeto da classe JTable aplicando o modelo de
tabela instanciado na linha 18.
Nas linhas de 21 24 foram criadas arrays unidimensionais com os valores
que sero adicionados em cada linha da tabela. Nas linhas de 26 29, estas
arrays foram adicionadas tabela, respectivamente, nas linhas de 0 3, pois
apesar da tabela ter 4 linhas, a numerao vai de 0 3.
Na linha 30 foi definido o nmero de linhas da tabela, neste caso, 4 linhas.
Na linha 32, a tabela foi adicionada barra de rolagem, indicando, pelos
parmetros, que estas barras (verticais e horizontais) estaro sempre visveis,
independente do contedo da tabela exceder a rea disponvel ou no. Na linha
33 a barra de rolagem com a tabela adicionada janela na posio central

do layout BorderLayout.
Na linha 35 criado um rtulo para a tabela. Este rtulo adicionado janela
na posio norte do layout Borderlayout, ou seja, acima da tabela.

Figura 6.47: Janela com tabela.
Note a presena das barras de rolagem na vertical e na horizontal. Note tambm

o ttulo acima da tabela. Para manipular os valores nesta tabela podem ser
utilizados um conjunto de mtodos, que sero apresentados a seguir.
6.2.6.7.1 Mtodos para trabalhar com tabelas

Voc pode querer incluir novos elementos na tabela, excluir elementos,
alter-los, mudar o tamanho das colunas, obter um elemento selecionado etc.
Para executar estas operaes, voc pode utilizar um conjunto de mtodos
das classes DefaultTableModel. Os principais mtodos sero apresentados
a seguir:
tblClientesModel.addColumn("Telefone");
Adiciona a coluna "Telefone" direita na tabela.
String[] linha5 = {"4", "Ana Luiza Benfica", "ana@gmail.com",
"4567-9087"};
tblClientesModel.addRow(linha5);
Adiciona uma nova linha no final da tabela, contendo os valores presentes na
array linha5.
String[] linha6 = {"4", "Ana Luiza Benfica", "ana@gmail.com",

"5678-0987"};
Adiciona uma nova linha na tabela, na posio 3, ou seja, adiciona a quarta
linha, j que o ndice de numerao de linhas comea em 0.
int qtdColunas = tblClientesModel.getColumnCount();
Obtm o nmero de colunas da tabela.
String nomeColuna = tblClientesModel.getColumnName(1);

Obtm o nome (rtulo) da coluna 1 da tabela, ou seja, da segunda coluna, j
que a numerao de colunas comea no ndice 0.
int numLinhas = tblClientesModel.getRowCount();
Obtm o nmero de linhas da tabela.
String valor = (String) tblClientesModel.getValueAt(2, 3);
Obtm o valor contido na clula de linha 2 e coluna 3 da tabela e armazena
em uma varivel String.
Determina que a tabela ter 6 linhas.
tblClientesModel.setColumnCount(5);
Determina que a tabela ter 5 colunas.
tblClientesModel.setValueAt("Maria Paula", 1, 1);
Insere na clula de linha 1 e coluna 1 da tabela o valor "Maria Paula".
tblClientesModel.removeRow(3);
Remove a linha de nmero 3 da tabela.
6.3 Tratamento de eventos

Eventos so estmulos na aplicao, produzidos ou no pelo usurio, que
realizam chamadas a mtodos para tratar o evento, ou seja, para indicar o que
ocorrer a partir daquele estmulo. Estes mtodos normalmente executam
operaes para responder ao estmulo com a ao adequada.
Cada tipo de componente em uma janela suporta um conjunto de eventos que
no passam de objetos proveniente de classes, que possuem mtodos e atributos.
As principais categorias de eventos que podem ocorrer em uma aplicao
Java so:
Eventos de Ao.
Eventos de Janela.
Eventos de Foco.
Eventos de Mouse.
Nos tpicos seguintes sero apresentados exemplos de cada uma dessas
categorias.
6.3.1 Tratamento de eventos de ao

Os eventos de ao so tratados normalmente a partir de mtodos assinados na
interface ActionListener. Estes eventos so gerados quando se clica em objetos
do formulrio como botes, listas, opes de menu etc. So os eventos mais
comuns em aplicaes que utilizam as APIs swing e awt.
A maneira mais comum para uma classe tratar os eventos de ao
implementando o mtodo actionPerformed da interface ActionListener.
Sendo assim, a classe deve implementar a interface ActionListener e reescrever
obrigatoriamente o mtodo actionPerformed. Alm disso, o elemento que
sofrer a ao de clique do mouse dever se auto monitorar constantemente
para identificar quando ocorre o clique do mouse. Isso feito pelo mtodo
addActionListener.
Veja a seguir a estrutura bsica de uma classe preparada para tratar eventos
de ao:
public class Tela extends JFrame implements ActionListener {
@Override
public void actionPerformed(ActionEvent e) {
}
Para testar o tratamento desta categoria de eventos, vamos criar um projeto

Java no NetBeans chamado Aplicativo, com uma classe principal chamada
Aplicativo.java, conforme mostra a Figura 6.48.
Figura 6.48: Projeto para tratamento de eventos de ao de clique.
A classe Aplicativo.java vai gerar uma janela com diversos campos e dois
botes: Adicionar tabela e Limpar campos. Ao preencher os campos e
clicar no boto Adicionar tabela, o contedo dos campos so adicionados
uma tabela na parte inferior da janela. Ao clicar no boto Limpar campos,
todos os campos so limpos.
Veja a seguir o cdigo-fonte da classe Aplicativo.java:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.text.ParseException;
import javax.swing.border.TitledBorder;
import javax.swing.table.DefaultTableModel;
public class Aplicativo extends JFrame implements ActionListener {
private JPanel pnlCampos, pnlTabela, pnlBotoes, pnlNome,
pnlTelefone, pnlCidade;
private TitledBorder tituloPnlCampos, tituloPnlTabela, tituloPnlBotoes;
private JLabel lblNome, lblTelefone, lblCidade;
private JFormattedTextField txtTelefone;
private MaskFormatter mskTelefone;
private JTable tblClientes;
private DefaultTableModel tblClientesModel;
JButton btnAdicionar, btnLimpar;
private JComboBox cmbCidades;
private DefaultComboBoxModel cmbCidadesModel;
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
public Aplicativo() {
definirJanela();
pnlCampos = new JPanel(new GridLayout(3, 1));
tituloPnlCampos = BorderFactory.createTitledBorder("Cadastro de
Clientes");
pnlCampos.setBorder(tituloPnlCampos);
pnlBotoes = new JPanel(new FlowLayout());
tituloPnlBotoes = BorderFactory.createTitledBorder("Botes");
pnlBotoes.setBorder(tituloPnlBotoes);
pnlTabela = new JPanel(new GridLayout(1, 1));
tituloPnlTabela = BorderFactory.createTitledBorder("Tabela de
exibio de dados");
pnlTabela.setBorder(tituloPnlTabela);
lblTelefone = new JLabel("Telefone");
lblCidade = new JLabel("Cidade");
try {
JOptionPane.showMessageDialog(null, "Mscara incorreta");
}
cmbCidadesModel = new DefaultComboBoxModel();
cmbCidades = new JComboBox(cmbCidadesModel);
pnlNome = new JPanel(new FlowLayout(FlowLayout.LEFT));
pnlNome.add(lblNome);
pnlNome.add(txtNome);
pnlCampos.add(pnlNome);
pnlTelefone = new JPanel(new FlowLayout(FlowLayout.LEFT));
pnlTelefone.add(lblTelefone);
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
pnlTelefone.add(txtTelefone);
pnlCampos.add(pnlTelefone);
pnlCidade = new JPanel(new FlowLayout(FlowLayout.LEFT));
pnlCidade.add(lblCidade);
pnlCidade.add(cmbCidades);
pnlCampos.add(pnlCidade);
btnAdicionar = new JButton("Adicionar tabela");
btnAdicionar.addActionListener(this);
btnLimpar = new JButton("Limpar campos");
btnLimpar.addActionListener(this);
pnlBotoes.add(btnAdicionar);
pnlBotoes.add(btnLimpar);
String[] cols = {"Nome", "Telefone", "Cidade"};
tblClientesModel = new DefaultTableModel(cols, 3);
tblClientes = new JTable(tblClientesModel);
JScrollPane scrRolagem = new JScrollPane(tblClientes,
pnlTabela.add(scrRolagem);
add(pnlCampos, BorderLayout.NORTH);
add(pnlBotoes, BorderLayout.CENTER);
add(pnlTabela, BorderLayout.SOUTH);
private void definirJanela() {

setTitle("Aplicao");
setSize(800, 700);
}
Aplicativo ap = new Aplicativo();
ap.setVisible(true);
}
@Override
113
114
115
116
117
118
119
120
121
122
123
if (e.getSource() == btnAdicionar) {
String[] linha = {txtNome.getText(), txtTelefone.getText(),
cmbCidadesModel.getSelectedItem().toString()};
tblClientesModel.addRow(linha);
} else if (e.getSource() == btnLimpar) {
txtNome.setText(null);
txtTelefone.setText(null);
cmbCidadesModel.setSelectedItem("So Paulo");
txtNome.requestFocus();
}
Veja na linha 11 que a classe Aplicativo.java herda a classe JFrame e

implementa os mtodos abstratos da interface ActionListener. Nesse caso h
apenas um mtodo abstrato, o mtodo actionPerformed, que est implementado
obrigatoriamente, nas linhas de 111 122.
As linhas de 13 23 declaram os objetos referentes aos componentes que
sero colocados na tela. Veja que teremos painis, ttulos de painis, rtulos,
campos de texto simples, campo de texto formatado, tabela, botes de ao e
caixa de combinao (combo).
Note que o contrutor da classe implementado da linha 25 linha 96. Toda a criao
de componentes e adio janela ocorre nesse bloco, no interior do construtor.
Neste exemplo, as configuraes da janela foram colocadas em um mtodo
definirJanela, que chamado na linha 26. Este mtodo implementado da linha
98 linha 104. Voc vai encontrar as configuraes padro de janela nesse mtodo,
com definio de ttulo (linha 99), definio de que ao clicar no X vermelho no
canto superior direito da janela a aplicao ser encerrada (linha 100), definio
do gerenciador de layout utilizado na janela, nesse caso, FlowLayout (linha 101),
largura e altura da janela (linha 102) e posio da janela (linha 103).
As linhas de 28 38 criam trs painis, um para colocar os campos, um para
colocar os botes e um para colocar a tabela. Cada painel definido para usar
um gerenciador de layout especfico. Veja que o primeiro painel usa GridLayout
com 3 linhas e 1 coluna (linha 28), o segundo usa FlowLayout (linha 32), e o
terceiro usa GridLayout com 1 linha e 1 coluna (linha 36). Essas definies de
layout determinam como os elementos que sero colocados nos painis sero
posicionados. Caso tenha dvidas sobre eles, releia os tpicos anteriores deste
Captulo sobre gerenciadores de layout.
Note que cada painel tambm ter uma moldura visvel com um ttulo. Isso
definido nas linhas 29 e 30, 33 e 34, 37 e 38.
As linhas de 40 52 instanciam os objetos que sero colocados nos painis

e, consequentemente, na janela. Nesse bloco de linhas, no h novidade em
relao ao que vimos nos exemplos anteriores.
As linhas de 54 59 definem o contedo da caixa de combinao (combo).
As linhas de 61 74 criam respectivamente painis para o campo nome, telefone

e cidade e adiciona esses campos aos respectivos painis. Note que cada painel
criado para usar o gerenciador de layout Flowlayout com contedo alinhado
esquerda. Perceba que cada painel (que contm os campos) adicionado ao
painel pnlCampos nas linhas 64, 69 e 74.
As linhas de 76 81 criam um painel, adiciona os botes dentro e adiciona
este painel ao painel pnlBotoes. Aqui tem uma grande novidade. Note o uso
do mtodo addActionListener. esse mtodo que faz com que o boto, ao
receber um clique, chame automaticamente o mtodo actionPerformed da
linha 112. Dentro do mtodo actionPerformed foi programado o que deve
ocorrer quando o boto recebe o clique. Se voc esquecer de chamar este
mtodo addActionListener para o boto, o mtodo actionPerformed no ser
chamado e, consequentemente, nada acontecer.
Nas linhas de 83 91 criada a tabela e definidos seus parmetros. Veja que
ser uma tabela com 3 colunas contendo como ttulo das colunas os rtulos
Nome, Telefone e Cidade (linhas 83 e 84). Na linha 86 define-se que
a tabela ter inicialmente 0 linhas. Na linha 88 a tabela agregada barra de
rolagem e na linha 91 adicionada ao painel pnlTabela.
Nas linhas de 93 95, os painis que contm os campos, os botes e a tabela
so adicionados janela.
Veja agora o mtodo actionPerformed (linha 112), que acionado ao
clicar nos botes Adicionar janela (btnAdicionar) e Limpar campos
(btnLimpar). Quando o boto recebe o clique, o mtodo addActionLister
aciona o mtodo actionPerformed, que recebe como parmetro um objeto
da classe ActionEvent contendo informaes sobre o boto clicado. Se o
boto clicado foi o boto btnAdicionar (linha 113), ento ser criada uma
array String unidimensional com o contedo dos campos nome, telefone e
cidade (linha 114). Esta array adicionada tabela na linha 115. Se o boto
clicado no foi o boto btnAdicionar, mas sim o boto btnLimpar (linha 116),
os campos so limpos (linhas 17 e 118), a opo So Paulo selecionada
como cidade na caixa de combinao (linha 119) e o cursor posicionado
no campo nome (linha 120).
Perceba que o que deve ocorrer ao clicar nos botes programado de forma
personalizada no mtodo actionPerformed. O objeto e da classe ActionEvent
permite verificar qual foi o boto clicado por meio do mtodo getSource.

Figura 6.49: Janela com tratamento de evento de clique em botes.
Ao preencher os campos e clicar no boto Adicionar tabela, os dados so

includos na tabela abaixo dos botes, aumentando o nmero de linhas a cada
adio. Aps cadastrar alguns nomes e adicionar tabela, a janela estar como
Figura 6.50: Janela com campos preenchidos e tratamento de evento de clique em botes.
Programar os eventos de clique em botes e em opes do menu em aplicaes

Java comum e faz parte do dia-a-dia do programador. H outras formas de
tratar esses eventos chegando aos mesmos resultados, mas estas formas no
sero abordadas nesse livro. Procure aprender e memorizar bem uma forma de
fazer e use-a bem nas suas aplicaes. No estude todas as formas ao mesmo
tempo para evitar confuso.
6.3.2 Tratamento de eventos de janela

Os eventos de janela podem ocorrer quando a janela abre, quando ela fecha,
quando ganha ou perde o foco, quando maximizada ou minimizada etc.
H um conjunto enorme de eventos de janela, mas, neste livro, vamos tratar

de dois deles, o de fechar e o de abrir a janela.
H vrias classes para tratar os eventos de janela, como WindowEvent,
WindowListener, WindowAdapter, WindowFocusEvent, WindowFocusListener,
WindowFocusAdapter, WindowStateEvent, WindowStateListener e
WindowStateAdapter.
No geral, independente das classes utilizadas, se consegue os mesmos resultados,
por isso, nesse tpico vamos utilizar apenas as classes WindowsAdapter e
WindowEvent.
Para testar o tratamento de eventos de janela, crie um novo projeto Java,
chamado ProjetoJanela, e crie nele trs classes: Tela.java, EventoClose.java
e EventoOpen.java.
A Figura 6.51 mostra a pasta do projeto aps sua criao.
Figura 6.51: Projeto para tratamento de eventos de janela.
As classes EventoOpen.java e EventoClose.java herdaro a classe

WindowsAdapter e reescrevero, respectivamente, os mtodos windowOpened
e windowClosing da superclasse WindowsAdapter. O contedo destes mtodos
indicar o que deve ocorrer quando a janela criada pela classe Tela.java abrir
e quando a janela fechar.
Na classe EventosOpen.java, escreva o seguinte cdigo-fonte:
1
2
3
4
5
6
7
8
9
10
11
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
public class EventoOpen extends WindowAdapter {
@Override
public void windowOpened(WindowEvent we) {
JOptionPane.showMessageDialog(null, "A janela foi aberta");
}
Veja que a classe EventoOpen.java herda a classe WindowAdapter (linha 5).

Note que o mtodo windowOpened existe na classe WindowAdapter e est
sendo sobrescrito aqui. Isso indicado pela instruo @Override na linha
7. Este mtodo ser chamado quando a janela for aberta, e mostrar em uma
caixa de dilogo a mensagem contida na linha 9.
Na classe EventosClose.java, escreva o seguinte cdigo-fonte:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class EventoClose extends WindowAdapter {
@Override
public void windowClosing(WindowEvent we) {
int resp = JOptionPane.showConfirmDialog(null, "Deseja sair ?");
if (resp == JOptionPane.YES_OPTION) {
System.exit(0);
}
}
Veja que a classe EventoClose.java herda a classe WindowAdapter (linha 5).

Note que o mtodo windowClosing existe na classe WindowAdapter e est
sendo sobrescrito aqui. Este mtodo ser chamado quando a janela for fechada,
normalmente ao se clicar no X vermelho do canto superior direito. Quando
isso ocorrer, aparecer uma caixa de dilogo perguntando se deseja sair da
aplicao (linha 9). Esta caixa de dilogo ter trs botes: Sim, No e
Cancelar. Se for clicado no boto Sim (linha 10), a aplicao finalizada

e descarregada da memria (linha 11).
Na classe Tela.java, escreva o seguinte cdigo-fonte:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
private JLabel lblNome;
public Tela() {
setTitle("Eventos de Janela");
setSize(300, 200);
setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
add(lblNome);
add(txtNome);
addWindowListener(new EventoClose());
addWindowListener(new EventoOpen());
}

Tela t = new Tela();
t.setVisible(true);
}
Esta uma classe comum, que gera uma janela com um boto para a incluso
do nome. Criamos dezenas de classes como esta nos tpicos anteriores, por
isso, vamos explicao apenas do necessrio.
Veja na linha 14 que a finalizao automtica da aplicao ao se clicar no X
do canto superior direito da janela foi cancelada. Isso foi necessrio porque
queremos que ao clicar no X seja gerado um evento e chamado o mtodo
windowClosing da classe EventoClose.java.
O mtodo addWindowListener da linha 20 monitora a janela at que ela feche.
Quando isso ocorrer, um objeto da classe EventoClose.java instanciado
e passado como parmetro para este mtodo. Isso faz com que o mtodo
windowClosing da classe EventoClose.java seja executado.
O mesmo acontece na linha 21, mas com a classe EventoOpen.java, que executa
o mtodo windowOpened.
Perceba que so as linhas 20 e 21 que puxam o gatilho, quando o evento
ocorre e direcionam para os mtodos corretos para trat-los. Dessa forma, se
deseja apenas tratar o evento de fechamento da janela, mantenha a linha 20 e
retire a linha 21. Se deseja apenas tratar o evento de abertura da janela, mantenha
apenas a linha 21.
As linhas 20 e 21 poderiam ser desmembradas em quatro linhas, mantendo o

mesmo resultado, ficando da seguinte forma:
EventoClose evtClose = new EventoClose();
addWindowListener(evtClose);
EventoOpen evtOpen = new EventoOpen();
addWindowListener(evtOpen);

aparecer uma caixa de dilogo e a janela, como mostra a Figura 6.52.
Figura 6.52: Resultado do tratamento de eventos de abertura e fechamento da janela.
Ao clicar no X vermelho do canto superior direito da janela aparecer a caixa

de dilogo mostrada na Figura 6.53.
Figura 6.53: Caixa de dilogo para confirmao do fechamento da janela.
Ao clicar no boto Sim a aplicao ser finalizada.
Apesar de termos criado uma classe para tratar cada evento, poderamos tratar
os eventos dentro da mesma classe que gera a tela. Nesse caso, a aplicao
teria apenas uma classe, mas o cdigo ficaria um pouco mais complexo. Veja
abaixo como ficar o cdigo-fonte, neste caso:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
public Tela() {
setTitle("Eventos de Janela");
setSize(300, 200);
setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
add(lblNome);
add(txtNome);
addWindowListener(new WindowAdapter() {
@Override
public void windowClosing(WindowEvent we) {
int resp = JOptionPane.showConfirmDialog(null, "Deseja sair ?");
if (resp == JOptionPane.YES_OPTION) {
System.exit(0);
}
}
});
addWindowListener(new WindowAdapter() {
@Override
public void windowOpened(WindowEvent we) {
JOptionPane.showMessageDialog(null, "A janela foi aberta");
}
});
38
39
40
41
42
43
44

t.setVisible(true);
}
Veja que o evento de tratamento da janela tratado das linhas 23 31 e o evento

de abertura da janela tratado das linhas 32 38. No haveria diferena com
relao a colocar o tratamento de eventos em classes separadas.
6.3.3 Tratamento de eventos de foco

Os eventos de foco so disparados quando o elemento ganha ou perde o foco.
Por exemplo, uma caixa de texto ganha o foco quando voc clica sobre ela; e
perde o foco quando voc sai dela.
Podemos usar diversas classes para tratar eventos de foco, como FocusListener,
FocusAdapter e FocusEvent. Neste tpico criaremos um exemplo utilizando
as duas ltimas.
Trataremos os eventos de foco de forma semelhante que tratamos os eventos
de janela, criando classes auxiliares para o tratamento dos eventos.
Para testar o uso destes eventos, crie um projeto Java no NetBeans chamado
AplicativoFoco e nele crie as classes EventoGanhaFoco.java, EventoPerdeFoco.
java e Tela.java (classe principal), conforme mostra a Figura 6.54.
Figura 6.54: Projeto para tratar eventos de foco.
Nesse projeto, ser gerada uma janela com dois campos: nome e renda. Quando
o campo renda ganhar o foco do cursor, ser chamado o mtodo focusGained da
classe EventoGanhaFoco.java. Quando o campo perder o foco, ser chamado
o mtodo focusLost da classe EventoPerdeFoco.java.
Digite o cdigo-fonte abaixo para a classe EventoGanhaFoco.java:
1
2
3
4
5
6
7
8
9
10
import java.awt.event.FocusAdapter;
import java.awt.event.FocusEvent;
public class EventoGanhaFoco extends FocusAdapter {
@Override
public void focusGained(FocusEvent e) {
System.out.println("O campo Renda ganhou o foco");
}
O mtodo focusGained (linha 7) existe na classe herdada FocusAdapter (linha

4) e sobrescrito nesta classe. Esse mtodo ser chamado quando o campo
renda da janela ganhar o foco.
1
2
3
4
5
6
7
8
9
10
public class EventoPerdeFoco extends FocusAdapter {
@Override
public void focusLost(FocusEvent e) {
System.out.println("O campo Renda perdeu o foco");
}
O mtodo focusLost (linha 7) existe na classe herdada FocusAdapter (linha

4) e sobrescrito nesta classe. Esse mtodo ser chamado quando o campo
renda da janela perder o foco.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

public Tela() {
setTitle("Eventos de Foco");
setSize(300, 200);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
lblRenda = new JLabel("Renda");
add(lblNome);
add(txtNome);
add(lblRenda);
add(txtRenda);
txtRenda.addFocusListener(new EventoGanhaFoco());
txtRenda.addFocusListener(new EventoPerdeFoco());
}

t.setVisible(true);
}
Perceba na linha 24 que adicionado um Listener (ouvinte) ao campo

textRenda de tal forma que quando ele ganhar o foco, um objeto da classe
EventoGanhaFoco.java instanciado e passado como parmetro para o
mtodo addFocusListener. Isso faz com que o mtodo focusGained da classe
EventoGanhaFoco.java seja executado.
O mesmo ocorre na linha 25. Quando o campo renda perder o foco, um objeto
da classe EventoPerdeFoco.java instanciado e passado como parmetro para
o mtodo addFocusListener. Isso faz com que o mtodo focusLost da classe
EventoPerdeFoco.java seja executado.

aparecer a janela mostrada na Figura 6.55.
Figura 6.55: Tela para tratamento de evento de foco.
Ao clicar no campo renda e ele ganhar o foco, aparecer no console a mensagem

O campo Renda ganhou o foco. Ao sair do campo renda, por exemplo,
clicando no campo nome, aparecer no console a mensagem O campo Renda
perdeu o foco.
Console a rea de sada do NetBeans, situada geralmente abaixo do cdigo-fonte na tela, conforme mostra a Figura 6.56.
Figura 6.56: Sada da aplicao exemplo para tratamento de eventos de foco.
Caso queira, ao invs de criar classes auxiliares para tratar os eventos de ganho
e perda de foco, pode fazer diretamente na classe que gera a janela, ou seja,
na classe Tela.java, da seguinte forma:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

public Tela() {
setTitle("Eventos de Foco");
setSize(300, 200);
lblRenda = new JLabel("Renda");
add(lblNome);
add(txtNome);
add(lblRenda);
add(txtRenda);
txtRenda.addFocusListener(new FocusAdapter() {
@Override
public void focusGained(FocusEvent we) {
System.out.println("O campo Renda ganhou o foco");
}
});
txtRenda.addFocusListener(new FocusAdapter() {
@Override
public void focusLost(FocusEvent we) {
System.out.println("O campo Renda perdeu o foco");
}
});
}

t.setVisible(true);
}
Veja que o evento de ganho de foco tratado das linhas 26 31 e o evento de

perda de foco tratado da linha 32 37.
A grande vantagem de tratar o evento na mesma classe que voc pode, no
interior do mtodo que trata o evento, fazer referncia aos elementos da tela, pois
esto na mesma classe. No h diferena, neste caso, em termos de resultado.
6.3.4 Tratamento de eventos de mouse

Os eventos de mouse acontecem quando o mouse interage com o elemento,
seja sendo posicionado sobre o elemento, saindo de sobre o elemento, clicando
no elemento, movendo-se sobre o elemento etc.
As principais classes utilizadas para tratar eventos de mouse so MouseListener,
MouseMotionListener, MouseMotionAdapter, MouseAdapter e MouseEvent.
Nesse exemplo utilizaremos as duas ltimas.
Ao contrrio dos exemplos anteriores, vamos tratar os eventos de mouse em

uma nica classe, evitando a criao de classes auxiliares.
No exemplo apresentado a seguir, vamos tratar apenas os eventos mouseEntered
e mouseExited que tratam, respectivamente, os eventos de posicionar o mouse
sobre a rea do elemento e retirar o mouse de sobre a rea do elemento. H ainda
diversos outros eventos, como mouseClicked, mousePressed, mouseReleased,
mouseWheelMoved, mouseDragged e mouseMoved, mas no sero tratados
neste exemplo.
Para testar o uso de eventos de mouse, crie um projeto chamado
AplicativoEventosMouse com uma classe principal chamada Tela.java,
conforme mostra a Figura 6.57.
Figura 6.57: projeto para tratamento de eventos de mouse.
A classe Tela.java ter um campo nome e um boto Salvar. Quando o mouse

for posicionado sobre o boto, sua cor de fundo mudar para amarelo (evento
mouseEntered). Quando ele sair da rea do boto, sua cor de fundo mudar
para vermelho (evento mouseExited).
1
2
3
4
5
6
7
8
import java.awt.Color;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

private JButton btnSalvar;
public Tela() {
setTitle("Eventos de Mouse");
setSize(300, 200);
add(lblNome);
add(txtNome);
add(btnSalvar);
btnSalvar.addMouseListener(new MouseAdapter() {
@Override
public void mouseEntered(MouseEvent we) {
btnSalvar.setBackground(Color.yellow);
}
@Override
public void mouseExited(MouseEvent evt) {
btnSalvar.setBackground(Color.red);
}
});

t.setVisible(true);
}
Observe que os eventos mouseEntered (linha 30) e mouseExited (linha 34), so

tratados das linhas 28 37. Caso queira tratar outros eventos, deve incluir o
mtodo referente ao evento imediatamente aps a linha 36. Perceba na linha 28
que foi adicionado um Listener (ouvinte) ao boto para monitor-lo quanto
aos eventos de mouse. Toda vez que o ponteiro do mouse entra em contato com
a rea da superfcie do boto, um objeto da classe MouseAdapter instanciado
e passado como parmetro ao mtodo addMouseListener. Na instncia do
objeto, so implementados (ou sobrescritos) os mtodos mouseEntered e

mouseExited (que existem vazios na classe MouseAdapter), permitindo tratar
estes dois eventos.
Note na implementao do mtodo mouseEntered (linhas de 30 32) que
quando o ponteiro do mouse passar sobre a rea do boto, ele ficar amarelo
(linha 31). Quando sair da rea do boto, ser executado o mtodo mouseExited
(linhas de 34 36) e o boto ficar vermelho (linha 35).

Figura 6.58: Tela com tratamento de eventos de mouse.
Voc pode perceber que o tratamento de eventos em Java no uma tarefa fcil.
A maioria dos eventos tratados nos exemplos deste Captulo foram aplicados
apenas a alguns tipos de elementos da janela, mas a forma de tratamento de
eventos sobre outros elementos ocorre de forma semelhante.
Mais frente neste Captulo voc ver que h maneiras mais simples de se
trabalhar com a criao de interfaces de usurio utilizando as APIs swing e
awt no NetBeans.
6.4 Criao de aplicao com vrias janelas ou

com abas
At agora criamos pequenas aplicaes que utilizaram apenas uma janela,
porm, em aplicaes reais criadas nas empresas, muitas janelas podem ser
necessrias. Estando em uma janela, o usurio pode acessar outra clicando em
um boto, em uma opo de menu etc. Normalmente um evento chama um
mtodo que carrega outra janela da aplicao.
Uma alternativa ao uso de janelas a utilizao de abas (guias) na mesma
janela. Nesse caso, cada guia pode conter o que estaria em uma janela diferente.
Esta pode ser uma tima alternativa para quem no quer lidar com abertura,
fechamento e alternncia entre janelas.
Nesse tpico vamos criar uma aplicao simples que utiliza duas janelas e
mostrar como se faz para passar de uma para outra, quando necessrio. Vamos
tambm criar uma aplicao que utiliza abas na mesma janela e mostrar como
se alterna entre elas.
6.4.1 Exemplo de aplicao com vrias janelas
Criar uma aplicao que utiliza vrias janelas no uma tarefa difcil. Difcil
mesmo ajustar os elementos nas janelas de maneira adequada. O exemplo
que ser apresentado a seguir composto por uma nica classe que cria trs
janelas JFrame e alterna entre elas por meio de clique em botes. No teremos
a preocupao em colocar outros elementos nas janelas, pois o objetivo
explicar as operaes de alternncia entre janelas. Vamos ento ao exemplo.
Crie um novo projeto Java no NetBeans chamado AplicativoMultijanelas com
uma classe principal chamada Menu.java, conforme mostra a Figura 6.59.
Figura 6.59: Projeto com mltiplas janelas.
Na classe Menu.java, digite o seguinte cdigo-fonte:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import java.awt.*;
import java.awt.event.*;
public class Menu extends JFrame implements ActionListener {
JFrame frmJanela1, frmJanela2;
JButton btnJanela1, btnJanela2, btnVolta1, btnVolta2;
public Menu() {
//Programao da janela principal
setTitle("Janela Principal");
btnJanela1 = new JButton("Chama Janela 1");
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
btnJanela1.addActionListener(this);
btnJanela2 = new JButton("Chama Janela 2");
btnJanela2.addActionListener(this);
add(btnJanela1);
add(btnJanela2);
setBounds(100, 100, 300, 200);
//Programao da janela 1
frmJanela1 = new JFrame("Janela 1");
frmJanela1.setDefaultCloseOperation(EXIT_ON_CLOSE);
frmJanela1.setBounds(100, 100, 300, 200);
frmJanela1.getContentPane().setBackground(Color.yellow);
btnVolta1 = new JButton("Voltar");
frmJanela1.add(btnVolta1, "South");
btnVolta1.addActionListener(this);
//Programao da janela 2
frmJanela2 = new JFrame("Janela 2");
frmJanela2.setDefaultCloseOperation(EXIT_ON_CLOSE);
frmJanela2.setBounds(100, 100, 300, 200);
frmJanela2.getContentPane().setBackground(Color.green);
btnVolta2 = new JButton("Voltar");
frmJanela2.add(btnVolta2, "South");
btnVolta2.addActionListener(this);
}
@Override
Object btn = e.getSource();
if (btn == btnJanela1) {
setVisible(false);
frmJanela1.setVisible(true);
}
if (btn == btnJanela2) {
setVisible(false);
frmJanela2.setVisible(true);
}
if (btn == btnVolta1) {
setVisible(true);
frmJanela1.setVisible(false);
}
if (btn == btnVolta2) {
setVisible(true);
frmJanela2.setVisible(false);
62
63
64
65
66
67
68
69

Menu m = new Menu();
m.setVisible(true);
}
A linha 5 indica que a classe Menu.java herda a classe JFrame e implementa o

mtodo abstrato actionPerformed da interface ActionListener. Caso voc no
se lembre, a classe JFrame utilizada para criar janelas swing e a interface
ActionListener para que possam ser tratados eventos de ao, como cliques
de mouse em botes.
As linhas 7 e 8 declaram os elementos que sero utilizados na aplicao.
Ateno declarao dos objetos frmJanela1 e frmJanela2 da classe JFrame
na linha 7. Estes objetos sero usados para criar duas janelas.
Dentro do construtor da classe Menu.java, que vai da linha 10 42, so criadas
as janelas e todos os elementos que sero includos nelas.
As linhas de 12 22 criam a janela principal, que aparecer na tela quando
a aplicao for compilada e executada. Alm de criar a janela, estas linhas
incluem nela os botes btnJanela1 (Chama Janela 1) e btnJanela2 (Chama
Janela 2). Note que esta janela utilizar o gerenciador de layout FlowLayout
(linha 15) e que finalizar a aplicao ao clicar no X do canto superior direito
da janela (linha 14). Perceba nas linhas 17 e 19 que um Listener (ouvinte),
ficar monitorando os botes. Quando eles receberem um clique, o mtodo
actionPerformed (linha 45) ser chamado e um objeto da classe ActionEvent
permitir identificar a origem do clique. Na linha 22 foi utilizado o mtodo
setBounds, que determina a posio e o tamanho da janela em uma nica
operao. Se voc no se recorda, os dois primeiros parmetros desse mtodo
determinam a posio da janela nos eixos x e y e os dois ltimos parmetros
determinam o tamanho da janela (largura e altura).
As linhas de 24 31 criam a janela frmJanela1 que ser chamada ao clicar
no boto btnJanela1 da janela principal. Alm de criar a janela, estas linhas
incluem nela o boto btnVolta1 (Voltar), que ao ser clicado volta para a
janela principal. Note que esta janela tambm poder encerrar a aplicao se
for clicado no X do canto superior direito (linha 26). Perceba que o objeto
da janela tem nome de frmJanela1 e por meio desse objeto so adicionados
elementos janela e realizadas configuraes de propriedades, como na linha
27, que determina a posio e o tamanho da janela, e na linha 28, que determina
a cor de fundo da janela. Esta janela utilizar o gerenciador de layout padro,
que o BorderLayout, por isso, o boto btnVolta1 foi adicionado na posio

sul do layout (linha 30). Perceba que a este boto foi adicionado um Listener
(ouvinte) para quando ele for clicado chamar o mtodo actionPerformed da
linha 45, que indica o que deve ser feito aps o clique.
As linhas de 33 40 criam a janela frmJanela2 que ser chamada ao clicar no
boto btnJanela2 da janela principal. Alm de criar a janela, estas linhas incluem
nela o boto btnVolta2 (Voltar), que ao ser clicado volta para a janela principal.
Observe que todos os botes possuem um Listener (ouvinte) adicionado pelo

mtodo addActionListener. Este Listener chama automaticamente o mtodo
actionPerformed da linha 45 quando o boto clicado. Este mtodo recebe um
objeto da classe ActionEvent com informaes sobre o objeto de origem do clique.
Na linha 46, um objeto da classe Object recebe o nome e informaes sobre
o boto clicado. Por meio deste objeto, so feitas comparaes para indicar o
que deve ocorrer de acordo com o clique em cada um dos botes das janelas.
Se o evento de clique foi gerado no boto btnJanela1 (linha 47), a janela
principal fica oculta (linha 48) e a janela frmJanela1 se torna visvel na tela.
Se o evento de clique foi gerado no boto btnJanela2 (linha 51), a janela
principal fica oculta (linha 52) e a janela frmJanela2 se torna visvel na tela.
Se o evento de clique foi gerado no boto btnVolta1 (linha 55), a janela principal
se torna visvel (linha 56) e a janela frmJanela1 se torna oculta (linha 57).
Se o evento de clique foi gerado no boto btnVolta2 (linha 59), a janela principal
se torna visvel (linha 60) e a janela frmJanela2 se torna oculta (linha 61).
As linhas de 65 68 iniciam a aplicao quando ela for compilada e executada.
A linha 66 instancia um objeto da classe Menu por meio de uma chamada ao
construtor da classe utilizando o comando new. O construtor ento executado,
gerando as janelas na memria. A linha 67 exibe apenas a janela principal. As
demais ficam na memria, mas s sero visualizadas quando os botes forem
clicados.
NOTA
Toda e qualquer classe em Java subclasse da classe Object. Mesmo

quando no h extends na declarao da classe, o Java automaticamente
faz a classe criada herdar a classe Object. Como as classes que criamos
so subclasses da classe Object, elas tambm herdam os mtodos da
classe Object, como getClass, toString, equals etc. Muitos mtodos
que chamamos de classes instaladas com o Java retornam um objeto
da classe Object, como o mtodo getSource da classe ActionEvent. Por
ser genrico, este objeto normalmente pode ser convertido em outros
objetos, de acordo com a recessidade de quem recebe.

aparecer a janela mostrada na Figura 6.60.
Figura 6.60: Tela principal da aplicao com vrias janelas.
Ao clicar no boto Chama Janela 1, a janela principal ficar oculta e a janela

mostrada esquerda na Figura 6.61 ser apresentada na tela. Se for clicado no
boto Chama Janela 2, a janela principal ficar oculta e a janela mostrada
direita na Figura 6.61 ser apresentada na tela.
Figura 6.61: Janelas da aplicao abertas a partir da janela principal.
Se for clicado no boto Voltar, a janela atual ficar oculta e a janela principal
ser mostrada na tela novamente.
Voc deve ter observado que trabalhar com janelas em uma nica classe no
uma tarefa difcil, porm, dependendo da quantidade de elementos que
forem colocados na janela, o cdigo-fonte pode ficar muito grande e difcil de
gerenciar e manter. Nesse caso, uma alternativa criar uma classe que herda a
classe JFrame para cada janela. Quando um boto de uma janela for clicado,
voc instancia um objeto da classe referente a outra janela e a torna visvel.
NOTA
Quando voc criar aplicao com vrias janelas, alterne entre elas tornando visvel a que voc deseja, e invisvel a que no quer ver. Isto
feito por meio do mtodo setVisible do objeto referente janela.
6.4.2 Exemplo de aplicao com abas na mesma janela

Utilizar abas to fcil como trabalhar com diversas janelas e oferece a
facilidade de ter o contedo de vrias janelas em uma s, separado por abas (ou
guias). Voc pode alternar entre as abas facilmente, clicando no ttulo da aba.
Para testar o trabalho com abas, crie um novo projeto Java no NetBeans
chamado ProjetoAbas, e nele crie a classe principal TelaAbas.java, como
Figura 6.62: Projeto da aplicao com janelas com abas.
Para trabalhar com abas voc deve criar um painel que suporta abas, utilizando
a classe JTabbedPane. Alm desse painel, voc deve criar vrios painis
comuns, utilizando a classe JPanel. Nesses painis comuns voc deve colocar os
elementos que cada aba ter. No final, cada painel JPanel ser ento adicionado
como uma aba do painel JTabbedPane.
Na classe TelaAbas.java, digite o seguinte cdigo-fonte:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import java.awt.*;
public class TelaAbas extends JFrame {
private JTabbedPane pnlComGuias;
private JPanel pnl1, pnl2;
private JLabel lblUsuario, lblSenha, lblNome, lblEndereco, lblCidade;
private JTextField txtUsuario, txtNome, txtEndereco, txtCidade;
private JPasswordField txtSenha;
public TelaAbas() {
setTitle("Aplicao de painel com guia");
setSize(300, 200);
setLocation(300,300);
setBackground(Color.gray);
//Cria o painel pnl2 que ser includo na primeira aba
pnl1 = new JPanel();
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
pnl1.setLayout(null);
lblUsuario = new JLabel("Username:");
lblUsuario.setBounds(10, 15, 150, 20);
pnl1.add(lblUsuario);
txtUsuario = new JTextField();
txtUsuario.setBounds(10, 35, 150, 20);
pnl1.add(txtUsuario);
lblSenha = new JLabel("Senha:");
lblSenha.setBounds(10, 60, 150, 20);
pnl1.add(lblSenha);
txtSenha = new JPasswordField();
txtSenha.setBounds(10, 80, 150, 20);
pnl1.add(txtSenha);
//Cria o painel pnl2 que ser includo na segunda aba
pnl2 = new JPanel();
pnl2.setLayout(new GridLayout(3, 2));
pnl2.add(lblNome);
pnl2.add(txtNome);
lblEndereco = new JLabel("Endereo:");
pnl2.add(lblEndereco);
txtEndereco = new JTextField();
pnl2.add(txtEndereco);
lblCidade = new JLabel("Cidade:");
pnl2.add(lblCidade);
txtCidade = new JTextField();
pnl2.add(txtCidade);
// Cria o painel com abas e adiciona os paineis pnl1 e pnl2 a ele

pnlComGuias = new JTabbedPane();
pnlComGuias.addTab("Login", pnl1);
pnlComGuias.addTab("Cadastro", pnl2);
add(pnlComGuias, BorderLayout.CENTER);

TelaAbas tela = new TelaAbas();
}
Nas linhas de 6 10 so declarados os objetos que sero colocados na janela.

Veja que so declarados dois painis JPanel (linha 7) e um painel JTabbedPane
(linha 6). Os dois painis JPanel, depois de construdos, sero adicionados ao
painel que gera as abas, o painel JTabbedPane (linhas 54 e 55).
O construtor da classe contm as linhas que geram os elementos e os adicinam

em painis e na tela. Ele vai da linha 12 linha 57.
Nas linhas de 14 18 so definidas as propriedades da janela, como em projetos
anteriores.
Nas linhas de 21 34 criado o painel pnl1 (linha 21), com layout nulo (linha
22), o que significa que os elementos tero a posio e o tamanho definidos
manualmente por meio do mtodo setBounds. Veja que diversos elementos
so criados e adicionados a este painel.
A linha 23 cria o rtulo Username, que tem sua posio e tamanho definidos
na linha 24 e adicionado ao painel pnl1 na linha 25. O mesmo procedimento
ocorre com o campo texto para entrada do nome do usurio, das linhas 26
28; com o rtulo Senha, das linhas 29 31; e com o campo texto para a
entrada da senha, das linhas 32 34. Veja que o campo para a entrada de senha
criado utilizando a classe JPasswordField (linha 32).
Das linhas 36 50 criado o painel pnl2 (linha 37) com layout GridLayout com
3 linhas e 2 colunas (linha 38). Nas linhas seguintes, de 39 50, so criados
rtulos e campos texto e adicionados a este painel.
Na linha 53 criado o painel que suporta guias, o JTabbedPane. Na linha 54
o painel pnl1 adicionado na primeira guia deste painel com o ttulo de guia
Login. Na linha 55 o painel pnl2 adicionado a este painel com o ttulo de
guia Cadastro. Na linha 56 o painel com as guias (pnlComGuias) adicionado
janela na posio central do layout BorderLayout.
A linha 60 cria um objeto desta classe (TelaAbas.java), o que executa o
construtor da classe, criando a janela e os objetos da janela na memria. A
linha 61 torna tudo isso visvel ao usurio.
Ao compilar e executar o projeto por meio do pressionamento da tecla F6, a
janela da esquerda na Figura 6.63 apresentada na tela.
Figura 6.63: Janela com abas.
Perceba na Figura 6.63 que a janela da esquerda mostra a aba Login aberta,
quando a aplicao executada. J a janela da direita mostra a aba Cadastro
aberta, quando o usurio clicar nesta aba. Voc pode alternar entre as abas
facilmente, bastando para isso clicar sobre o ttulo dela.
As abas possuem um ndice numrico comeado por 0 que vai aumentando
na medida em que vo sendo adicionadas janela. Assim, a primeira aba ter
ndice 0, a segunda ter ndice 1, e assim por diante.
A seguir so apresentados os principais mtodos utilizados para executar
operaes com as abas.
pnlComGuias.setSelectedIndex(1);
Ao executar a aplicao, a aba ativa ser a segunda (aba 1).

pnlComGuias.setBackgroundAt(0, Color.BLUE);
O plano de fundo do ttulo da primeira aba (aba 0) ficar azul.
pnlComGuias.setEnabledAt(0, false);
A primeira aba (aba 0) ser desativada. Ao clicar, no ser aberta.
pnlComGuias.setTitleAt(1, "Controle");
O ttulo da segunda aba (aba 1) ser "Controle".
int indice = pnlComGuias.getSelectedIndex();
Obtm o nmero de ndice da aba ativa e armazena na varivel do tipo int.
String tituloAba = pnlComGuias.getTitleAt(1);
Obtm o ttulo da segunda aba (aba 1) e armazena na varivel String.
if(pnlComGuias.isEnabledAt(1)){};
Verifica se a segunda aba (aba 1) est ativa.
pnlComGuias.remove(1);
Remove a segunda aba (aba 1).
6.5 Criao de interfaces do usurio utilizando

recursos de arrastar/soltar com o NetBeans
Provavelmente nesta altura do Captulo voc deve estar comparando o

desenvolvimento de interfaces do usurio em Java com o desenvolvimento em
outras plataformas, como com o Visual Studio da Microsoft. Desenvolvendo,
por exemplo, em C# ou Visual Basic com o Visual Studio, voc cria rapidamente
interfaces grficas de usurio (GUIs) com recursos de arrastar/soltar. possvel
criar uma interface de usurio em minutos. Porm, voc no tem acesso ao
cdigo-fonte que gerado pelos componentes que voc coloca na janela. Eles
so, neste caso, uma enorme caixa-preta. Na plataforma Java, d trabalho,
demora, mas voc cria cada componente e tem mais controle sobre eles.
Apesar disso, as empresas querem agilidade no desenvolvimento de software,
tanto na modelagem e projeto, quanto na programao. Por isso, acabam
optando, quando possvel, por ferramentas que permitam desenvolver o
software mais rapidamente.
Para no ficar atrs de outras ferramentas, a Sun Microsystem (hoje de
propriedade da Oracle Corporation) adicionou ao NetBeans recursos que
permitem criar interfaces do usurio de forma semelhante ao Visual Studio da
Microsoft, com recursos de arrastar/soltar.
Neste tpico, vamos explorar estes recursos e criar interfaces de usurio ricas
em pouco tempo.
6.5.1 Exemplo de criao de interface grfica

simples utilizando os recursos de arrastar/
soltar do NetBeans
Neste tpico vamos criar um projeto de uma interface de usurio simples
utilizando as APIs swing e awt e os recursos de arrastar/soltar do NetBeans.
Para criar um novo projeto, execute os passos a seguir:
Clique no menu Arquivo e na opo Novo projeto.
Na diviso Categorias, selecione Java; na diviso Projetos, selecione
Aplicativo Java e clique no boto Prximo.
No campo Nome do Projeto: digite ArrastarSoltar e desmarque a caixa
de seleo Criar Classe Principal, pois no iremos criar nenhuma classe
principal. Faremos isso mais adiante.
Ao terminar este processo, o projeto estar como mostra a Figura 6.64.
Figura 6.64: Projeto com recursos de arrastar/soltar.
Agora vamos criar a classe principal, que ser um formulrio JFrame. Execute,
para isso, os seguintes procedimentos:
Clique com o boto direito sobre o nome do projeto (ArrastarSoltar),

selecione a opo Novo e a opo Form JFrame, como mostra a Figura
6.65.
Figura 6.65: Criao de formulrio JFrame.
No campo Nome da Classe, digite Tela e clique no boto Finalizar.

Aparecer na rea de trabalho do NetBeans, no centro da tela, um formulrio
vazio e direita, uma paleta com os elementos que podem ser arrastados para
este formulrio, como mostra a Figura 6.66.
Figura 6.66: Paleta de elementos que podem ser adicionados ao formulrio.
Veja que na paleta (painel) da direita existe o elemento Label (JLabel), Boto
(JButton), Painel (JPanel) etc. H uma barra de rolagem nessa paleta que
permite visualizar os demais elementos. A Figura 6.67 mostra os elementos
disponveis nesta paleta.
Figura 6.67: Paleta de elementos que podem ser arrastados para o formulrios.
Clique no formulrio no centro da tela para selecion-lo. Se voc posicionar o

ponteiro do mouse sobre suas laterais, poder redimension-lo. Observe que
ao clicar no formulrio, do lado inferior direito, aparece um painel com as
propriedades que podem ser modificadas no formulrio. A Figura 6.68 mostra
algumas destas propriedades.
Figura 6.68: painel para mudar as propriedades dos elementos de tela.
Para mudar as propriedades de qualquer elemento, basta clicar sobre ele que
as propriedades passveis de modificao sero mostradas.
No canto inferior esquerdo da tela h um painel chamado Navegador, onde
so exibidos o nome do formulrio JFrame e os nomes dos elementos includos
no formulrio. Clicando com o boto direito do mouse sobre JFrame, voc
poder definir algumas propriedades do formulrio, como o gerenciador de
layout que ele deve utilizar. A Figura 6.69 mostra este procedimento.
Figura 6.69: Painel Navegador mudando o layout do formulrio.
Veja que o layout padro do formulrio o BorderLayout (Layout de Borda),

mas sugiro mudar para Layout nulo, para voc ter mais liberdade para arrastar
elementos para o formulrio. Todos os elementos colocados no formulrio
aparecero nesse painel Navegador, abaixo de JFrame.
Arraste da paleta para o formulrio dois painis e os redimensione, como mostra
a Figura 6.70. No painel da parte superior, coloque trs rtulos (JLabel) e trs
campos de texto (JTextField). No painel da parte inferior, coloque trs botes
(JButton). Selecione os painis e mude a propriedade background, selecionando
cor de fundo para eles. Veja na Figura 6.70 como deve ficar o formulrio.
Figura 6.70: Formulrio com elementos arrastados.
No painel Navegador, no canto inferior esquerdo da tela, voc ver o nome

padro de todos os elementos do formulrio, conforme Figura a seguir:
Figura 6.71: Apinel Navegador, com os nomes dos elementos do formulrio.
Fica difcil programar os botes utilizando os nomes padro dos elementos,

por isso, temos que renome-los. Precisamos tambm mudar o texto padro
que aparece nesses elementos. H diversas maneiras de fazer isso. Uma delas
selecionar o elemento e mudar o nome e o texto no painel de propriedades que
aparece direita. Outra forma, clicar com o boto direito sobre o elemento e
selecionar Editar Texto, para mudar o que est escrito no elemento e Alterar
o Nome da Varivel, para mudar o nome do elemento. Veja estas opes na
Figura 6.72.
Figura 6.72: Nomeando os elementos e mudando os rtulos.
Ao clicar com o boto direito do mouse sobre a primeita caixa de texto e

selecionar a opo Alterar o Nome da Varivel, aparecer a janela mostrada
na Figura 6.73.
Figura 6.73: Nomeao de elementos do formulrio.
Mude o nome para txtNome e clique no boto OK.

Mude o nome de todos os elementos utilizando o procedimento acima, de forma
que eles fiquem com os nomes mostrados no painel Navegador apresentado
na Figura 6.74.
Figura 6.74: Painel Navegador com elementos nomeados.
Mude tambm o texto dos elementos, de forma que o formulrio fique com a
aparncia mostrada na Figura 6.75.
Figura 6.75: Formulrio criado e com propriedades definidas.
Para que o formulrio aparecea centralizado ao executar e tambm aparea no

tamanho em que foi desenhado, voc deve alterar, no painel de propriedades
direita, a poltica de tamanho de formulrio. Para isso, no painel Propriedades,
clique na opo Cdigo, na parte superior do painel e, no campo Poltica de

Tamanho do Form, selecione a opo Gerar Cdigo de Redimensionamento.
Marque ainda a opo Gerar Centralizado. Veja a seguir a Figura 6.76, do
painel Propriedades, onde so realizados estes procedimentos.
Figura 6.76: definindo a poltica de tamanho do formulrio.
Para compilar e executar o projeto e ver como est o visual da tela, basta
pressionar a tecla F6 a qualquer momento.
Chegou a hora de programar os botes. Para isso, clique com o boto direito
do mouse sobre o boto Salvar, selecione a opo Eventos, em seguida
a opo Action e, por ltimo, a opo actionPerformed, como mostra a
Figura 6.77.
Figura 6.77: Programando os eventos dos botes.
Aparecer uma rea para edio de cdigo-fonte, onde o cursor estar na linha
90 da Figura 6.78, e onde deve ser programado o que deve ocorrer quando o
usurio clicar no boto Salvar. A Figura 6.78 mostra detalhes desta rea de
programao.
Figura 6.78: rea de programao dos eventos dos botes.
Na Figura 6.78, alguns detalhes merecem ateno. Veja que por trs daquele
formulrio para onde voc arrasta os elementos, h uma classe gerada
automaticamente, de acordo com os elementos que voc vai adicionando
e com as propriedades que voc vai mudando. Na linha 10 voc pode ver
que a classe foi declarada. Na linha 97 voc pode ver a implementao
do mtodo main, j que esta a classe principal. Na linha 89 voc pode
ver o mtodo btnSalvarActionPerformed, utilizado para programar o
evento de clique no boto Salvar. Na linha 93 voc pode ver o mtodo
btnExcluirActionPerformed, utilizado para programar o evento de clique no
boto Excluir.
Veja que a numerao de linhas do nmero 16 passa para 88. Isso ocorre porque
tem um conjunto de linhas ocultas entre a linha 16 e a linha 88. Para ver essas
linhas, clique no sinal de mais (+) que aparece na linha 16. Voc ver que as
linhas ocultas sero mostradas. Ver que nessas linhas est a programao
referente a gerao dos elementos arrastados para a tela. Voc no pode alterar
o cdigo-fonte dessa rea, pois ela gerada na medida em que voc interage
montando o formulrio. Poder apenas inserir cdigo de programao nos
mtodos de tratamento de evento.
Perceba na parte superior da tela que h duas opes clicveis e relevantes:

Cdigo-Fonte e Projeto. Se voc clicar em Projeto, ser mostrado
o formulrio para voc incluir novos elementos ou modificar elementos j
existentes. Se voc clicar em Cdigo-Fonte, aparecer esta rea de edio
do cdigo-fonte.
Pressionando F6 para compilar e executar o projeto, voc ver que a janela

aparecer centralizada, como mostra a Figura 6.79.
Figura 6.79: Janela gerada com recursos de arrastar/soltar.
No programamos o boto Salvar, pois faremos isso no prximo Captulo,

quando trataremos de operaes com acesso a banco de dados. Neste tpico
o objetivo mostrar como fcil criar uma interface do usurio utilizando os
recursos de arrastar/soltar do NetBeans.
Caso em algum momento algum dos painis da rea de trabalho do NetBeans
for fechado, voc poder abr-lo novamente clicando na opo Janela do
menu, conforme mostra a Figura 6.80.
Figura 6.80: menu Janela para exibir paineis fechados por engano.
Veja que voc pode clicar e exibir os painis Projetos, Arquivos e Servios,
que aparecem na parte superior esquerda da rea de trabalho; o painel Paleta,
que aparece na parte superior direita da janela com os elementos que podem
ser arrastados para o formulrio; o painel Propriedades, que aparece na
parte inferior direita da janela e permite mudar as propriedades dos elementos
colocados no formulrio etc.
6.6 Resumo
A interface do usurio uma das partes mais importantes da aplicao, pois
representa todas as telas s quais o usurio tem acesso.
Para criar interfaces grficas de usurio (GUIs) em aplicaes para desktop
com Java utilizam-se as APIs swing e awt. A API swing a evoluo da awt
e composta por diversos pacotes de classes, sendo que os mais utilizados
so javax.swing e javax.swing.event. Nesses pacotes existem um conjunto de
classes que permitem criar, configurar e apresentar qualquer componente de
tela como janelas, painis, rtulos, caixas de texto, menus, tabelas etc, e tratar
eventos que podem ocorrer nesses componentes.
Na criao de uma janela comum o uso da classe JFrame. Para agrupar
componentes na janela comum o uso da classe JLabel. Estas classes
permitem criar contineres para agrupar elementos, normalmente, com
caractersticas comuns.
A criao de janelas que compem a interface do usurio utilizando as APIs

swing e awt pode ser feita de duas maneiras: posicionando os elementos
estaticamente de forma manual ou posicionando os elementos automaticamente
utilizando gerenciadores de layout.
No posicionamento esttico voc define a posio e o tamanho do elemento
em pixel, de acordo com as coordenadas x e y. Dessa forma voc ter mais
controle sobre os elementos, porm, precisar fazer clculos para que uns no
sobreponham outros. Os mtodos utilizados para posicionar e dimensionar os
elementos so setSize, setLocation e setBounds.
Na criao de janelas de forma automtica voc usa gerenciadores de layout que

j apresentam uma pr-disposio de layout onde voc ter apenas que encaixar
os elementos. mais fcil de utilizar, mas voc fica preso s caractersticas
pr-definidas do layout.
Os gerenciadores de layout so classes contidas no pacote java.awt que possuem
atributos e mtodos como classes convencionais. Estas classes so FlowLayout,
GridLayout, BorderLayout e GridBagLayout.
O gerenciador de layout padro BorderLayout, que divide a janela em cinco
regies: norte, sul, leste, oeste e centro. Cada regio poder conter apenas um
elemento que ocupar toda rea disponvel.
O gerenciador de layout mais simples o FlowLayout, que encaixa os
elementos um direita do outro a partir do topo da janela, quebrando linha
automaticamente.
O gerenciador de layout GridLayout divide o continer em linhas e colunas
como uma tabela com clulas (grid). Em cada clula voc s poder colocar
um elemento, que ocupar toda a rea disponvel na clula.
O gerenciador de layout GridBagLayout o mais flexvel de todos, porm,
o mais complexo para se criar, pois cada elemento deve conter uma posio
inicial, uma posio final, um tamanho, uma escala, um alinhamento e um
preenchimento. Ele divide o continer em linhas e colunas como uma tabela
com clulas (grid). Esse gerenciador de layout permite a mesclagem de clulas
e, consequentemente, a criao de clulas de tamanhos diferentes.
Na maioria das vezes, quando criamos uma aplicao desktop para uma
empresa, temos que utilizar vrios gerenciadores de layout em uma mesma
janela, normalmente, um para a janela principal e diversos outros para os
painis que a janela ter. A combinao de gerenciadores de layout permite
mais flexibilidade ao desenvolvedor.
Uma aplicao desktop normalmente no composta de apenas uma janela,
mas sim por um conjunto de janelas. Uma alternativa criao de vrias
janelas a criao de abas (ou guias) na mesma janela. Para criar janelas voc
utiliza a classe JFrame, e para criar abas na janela voc pode utilizar as classes
JTabbedPane e JPanel.
Os elementos colocados na janela podem ser formatados, tendo suas propriedades
de formatao alteradas. Assim, voc poder definir cores de fonte e de fundo,
tipo e tamanho de fonte etc. Cada elemento permite mudar um conjunto de
formataes especficas, que podem no ser comuns a todos os elementos.
As janelas criadas nas aplicaes desktop podem conter menus agrupados em

uma barra de menus posicionada na parte superior da tela. Esses menus podem
ser criados pelas classes JMenuBar, JMenu e JMenuItem. Alm dos menus, nas
janelas, voc pode inserir diversos tipos de botes por meio de classes como
JButton, JRadioButton, ButtonGroup, JCheckBox e JToogleButton.
As caixas de texto permitem que o usurio entre com informaes que podem
ser manipuladas na aplicao. Para criar e formatar caixas de texto voc utiliza
classes como JTextField, JTextArea, JPasswordField, JFormattedTextField e
MaskFormatter.
Alm das caixas de texto voc pode criar caixas de combinao (combos),
por meio das classes JComboBox e DefaultComboBoxModel; listas, por meio
das classes DefaultListModel e JList; tabelas, por meio das classes JTable e
TableModel etc.
Todos os elementos colocados na janela, incluindo a prpria janela, so
sucetveis a eventos como cliques, abertura, fechamento, foco etc. Quando
estes eventos acontecem, mtodos especficos so chamados para trat-los.
Existem vrias categorias de eventos, sendo que as principais so eventos de
ao, eventos de janela, eventos de foco e eventos de mouse.
Os eventos de ao so normalmente disparados quando se clica em um
elemento. Eles so tratados utilizando classes como ActionListener e
ActionEvent. Todos os elementos de tela sucetveis a clique podem tratar
eventos deste tipo.
Os eventos de janela ocorrem quando a janela recebe algum estmulo, seja
do usurio, ou automaticamente. Ocorrem quando a janela abre, quando ela
fecha, quando ganha ou perde o foco, quando maximizada ou minimizada
etc. Para tratar os eventos de janela podem ser utilizadas diversas classes,
como WindowEvent, WindowListener, WindowAdapter, WindowFocusEvent,
WindowFocusListener, WindowFocusAdapter, WindowStateEvent,
WindowStateListener e WindowStateAdapter.
Eventos de foco ocorrem normalmente quando o elemento ganha ou perde o
foco. Eles so tratados normalmente pelas classes FocusListener, FocusAdapter
e FocusEvent.
Eventos de mouse acontecem quando o mouse interage com o elemento, seja

sendo posicionado sobre o elemento, saindo de sobre o elemento, clicando no
elemento, movendo-se sobre o elemento etc. As principais classes utilizadas
para tratar eventos de mouse so MouseListener, MouseMotionListener,
MouseMotionAdapter, MouseAdapter e MouseEvent.
Criar interface grfica de usurio manualmente e tratar seus eventos utilizando
as APIs swing e awt uma tarefa difcil e desafiadora, pois demanda muito
tempo, tanto na aprendizagem para usar os recursos como na programao em
si. A carga de comandos utilizados muito grande. Pensando em facilitar a
vida do programador, a Sun Microsystem incluiu no NetBeans um conjunto de
recursos que permite criar as telas com recursos de arrastar/soltar, como outros
ambientes de desenvolvimento, por exemplo, o Visual Studio da Microsoft.
Criar as telas com esses recursos faz com que o desenvolvedor tenha mais
tempo para se dedicar programao dos eventos e das regras de negcio
da aplicao. Diversas ferramentas tm sido desenvolvidas para agilizar ou
at mesmo automatizar a criao da interface do usurio com o auxlio do
desenvolvedor.
6.7 Exerccios
Os exerccios sero divididos em duas partes: os exerccios prticos, que
envolvem criao de telas e programao de eventos, e os exerccios conceituais,
que desenvolvem o entendimento dos conceitos apresentados neste captulo.

1) Crie a janela a seguir utilizando posicionamento esttico e manual dos
elementos de tela. Veja que h dois painis com ttulo. O painel superior
contm os campos e o painel inferior contm os botes. No utilize recursos
de arrastar/soltar.
2) Crie a janela a seguir utilizando gerenciadores de layout. Note que a barra

de menus contm os menus Arquivo e Ajuda. No menu Arquivo coloque
os itens de menu Salvar e Sair. No menu Ajuda, coloque apenas a opo
Obter ajuda. No utilize recursos de arrastar/soltar.
3) Crie a janela a seguir utilizando gerenciadores de layout. Programe os botes

Fatorial e Raiz Quadrada. O boto Fatorial, ao ser clicado, deve calcular
o fatorial do nmero inserido no campo Valor e exibir o resultado no campo
Resultado. O boto Raiz Quadrada, ao ser clicado, deve calcular a raiz
quadrada do nmero inserido no campo Valor e exibir o resultado no campo
Resultado. No utilize recursos de arrastar/soltar.
4) Crie uma aplicao Java que gere a janela com o menu principal abaixo.
Ao ser clicado na opo Cadastro de Clientes, a janela principal deve ser
fechada e deve ser aberta a janela de cadastro de clientes. Ao ser clicado no
boto Cadastro de Produtos, a janela principal deve ser fechada e deve ser
aberta a janela para o cadastro de produtos. Ao clicar no boto Voltar das
telas secundrias, estas janelas devem ser fechadas e a janela principal deve
ser mostrada. Utilize ou no gerenciadores de layout. No utilize recursos de
arrastar/soltar.
5) Crie uma janela que contenha duas abas: Cadastro de Clientes e Cadastro
de Produtos. Cada aba deve conter um conjunto de campos e um boto, como
mostra a Figura a seguir. Utilize ou no gerenciadores de layout. No utilize
recursos de arrastar/soltar.
6) Crie a tela cujo layout mostrado a seguir, utilizando o gerenciador de

layout GridBagLayout. Programe o boto Sair de forma que ao ser clicado
a aplicao seja finalizada. No utilize recursos de arrastar/soltar.
7) Crie a janela a seguir, considerando que o menu Dados contm a opo Ver
grfico e o menu Operaes contm a opo Sair. Programe a opo Sair, de
forma que ao ser clicada finalize a aplicao. No utilize recursos de arrastar/soltar.
8) Crie a mesma janela apresentada na questo anterior utilizando recursos de

arrastar/soltar do NetBeans.

1) Quais so as APIs do Java que permitem a criao de interface grfica de
usurio para aplicaes desktop?
2) Quais so os principais pacotes da API swing?
3) Quais so as principais classes utilizadas para criar contineres em interfaces
grficas de usurio para desktop com Java?
4) Quais so os mtodos utilizados para determinar a posio e o tamanho de
um elemento na janela JFrame?
5) Quais so os gerenciadores de layout utilizados em Java?
6) Quando utilizar cada um dos gerenciadores de layout da API awt?

7) Qual classe da API swing utilizada para gerar caixas de dilogo?
8) Que mtodo deve ser utilizado para criar caixas de dilogo de confirmao
em uma aplicao?
9) Quais classes da API swing so utilizadas para criar menus?
10) Que mtodos so utilizados para mudar a cor do plano de fundo e da fonte
de um elemento?
11) Quais classes da API swing so utilizadas para criar os principais tipos de
botes que podem existir em um continer?
12) A que os botes JRadioButton precisam ser associados para que seja
permitido a seleo de apenas um em um conjunto deste tipo de boto?
13) Que mtodo deve ser utilizado para verificar se um boto foi selecionado?
14) Explique o procedimento necessrio para definir uma mscara de entrada
em um campo formatado.
15) Quais as principais classes utilizadas para criar listas e caixas de combinao
(combos)?
16) Qual mtodo deve ser utilizado para se obter a opo selecionada em uma
caixa de combinao (combo) ou em uma lista?
17) Como se associa um modelo de tabela DefaultTableModel a uma tabela
JTable?
18) Como se adiciona dados em uma linha de um modelo de tabela
DefaultTableModel?
19) Como se obtm um valor selecionado em uma clula de uma tabela JTable?
20) Quais so os principais tipos de eventos que podem ser tratados em
aplicaes desktop que utilizam as APIs swing e awt?
21) Quais classes so normalmente utilizadas para lidar com eventos de ao
de clique do mouse sobre o elemento?
22) Quais so os principais eventos de mouse?

23) Quais as principais classes que podem ser utilizadas para tratar eventos
de janela?
24) Que mtodo(s) precisa(m) ser escritos em classes que implementam a
interface ActionListener?
25) Para que serve o mtodo addActionListener em classes que tratam eventos
de ao?
26) Explique o bloco de cdigo a seguir, considerando btnSalvar um objeto
da classe JButton.
btnSalvar.addMouseListener(new MouseAdapter() {
@Override
public void mouseEntered(MouseEvent we) {
btnSalvar.setBackground(Color.yellow);
} @Override
public void mouseExited(MouseEvent evt) {
btnSalvar.setBackground(Color.red);
}
});
27) Qual classe deve ser utilizada para criar um painel que suporta abas (ou
guias)? O que precisa ser adicionado a este painel para construir as abas?
28) Qual alternativa os desenvolvedores do NetBeans encontraram para agilizar
a criao de interface grfica de usurio?
7. Acesso a banco de dados
Os programas de computador suportam a entrada, o processamento e as sadas

de dados, mas estes dados, precisam quase sempre serem guardados em um
banco de dados para manipulao posterior.
Voc pode conectar a sua aplicao Java a qualquer Sistema Gerenciador de
Banco de Dados (SGBD), como MySQL, PostgreSQL, Oracle, SQL Server
etc. Para isso precisar de um driver produzido pelo fabricante do SGBD
que permite tal conexo. O driver normalmente um pacote de classes que
voc precisar referenciar na aplicao no momento de fazer a conexo com
o banco de dados.
Neste Captulo voc aprender a realizar conexo com banco de dados e
executar operaes de cadastro (insert), alterao (update), consulta (select) e
excluso (delete). Uniremos tudo que foi visto neste livro at este momento em
projetos mais robustos que envolvem criao de interface grfica de usurio,
encapsulamento, interfaces, pacotes e operaes em banco de dados.
7.1 Os padres ODBC e JDBC

Para acessar bancos de dados em aplicaes Java existem dois padres que
determinam as regras para acesso de maneira eficiente: Open Database
Connectivity (ODBC) e Java Database Connectivity (JDBC). Para utilizar estes
padres, os fabricantes de SGBDs1 criam os drivers (que so bibliotecas de
classes) para seguir as regras impostas por esses padres. Assim, voc precisar
de um driver JDBC ou um driver ODBC do fabricante do SGBD para fazer a
ligao da aplicao com o banco de dados.
ODBC uma interface padro Microsoft Windows que permite a ligao de
aplicaes feitas em qualquer linguagem de programao com qualquer banco
de dados. J JDBC uma interface padro, independente de plataforma, que
permite a comunicao entre aplicaes baseadas em Java e SGBDs.
JDBC para aplicaes feitas com a linguagem Java, independente de um
sistema operacional especfico. ODBC para aplicaes feitas em qualquer
linguagem de programao, mas fica preso ao sistema operacional Windows.
1
SGBD a sigla de Sistema Gerenciador de Banco de Dados. Trata-se do software, tambm

conhecido como servidor de banco de dados, onde voc poder criar bancos de dados
e tabelas e executar operaes SQL.
Use ODBC quando precisar de maior desempenho, j que este padro est
mais integrado ao sistema operacional. Quando precisar de independncia
de plataforma, ou seja, quiser que sua aplicao execute em mquinas com
qualquer sistema operacional, use JDBC.
Neste Captulo utilizaremos o padro JBDC, cujo driver j vem integrado
IDE NetBeans. Com este driver, poderemos conectar a aplicao a qualquer
SGBD, modificando apenas algumas strings de conexo.
Existem outras formas para se acessar banco de dados utilizando frameworks
e bibliotecas de persistncia, mas estes recursos apenas abstraem e escondem
do programador a complexidade do uso da API JDBC, mas no deixam de
utiliz-la.
7.2 Baixando e instalando o MySQL

O MySQL foi criado por uma empresa chamada MySQL AB, comprada
posteriormente pela Sun Microsystems (criadora do Java), que foi comprada
pela Oracle Corporation. Logo, o MySQL, o NetBeans e o Java so de
propriedade da Oracle Corporation. Sendo assim, o MySQL funciona muito
bem integrado com Java, tanto que o NetBeans j traz o driver JDBC de conexo
(connector) incorporado.
Para utilizar o MySQL com o NetBeans para desenvolver aplicaes para
desktop em Java que acessam banco de dados, voc precisar instalar o
MySQL no computador. Para isso, dever baixar o MySQL Community Server
e o MySQL Workbench. O MySQL Community Server o servidor de banco
de dados e o MySQL Workbench uma ferramenta de desenvolvimento que
prov um ambiente visual (grfico) para projetar e modelar bancos de dados,
manipular bancos de dados e tabelas por meio de comando SQL e assistentes,
administrar bancos de dados (permisses, backup, restore etc.) e fazer a
migrao de bancos de dados.
Para baixar estes recursos, siga as orientaes a seguir:
Entre no site <http://dev.mysql.com/downloads/>.
Clique no link "MySQL Community Server".
Aparecer na pgina a rea mostrada na Figura 7.1.
Figura 7.1: Tela para a seleo de verses do MySQL para baixar.
Clique no boto Download.

Aparecer uma pgina com a rea mostrada na Figura 7.2.
Figura 7.2: seleo da verso do MySQL para Windows.
Note que h duas opes de download para a plataforma Windows. A primeira,

de 1.4M, vai baixando e j instalando o MySQL em seu computador. A segunda,
de 270.0M, permite baixar e salvar os recursos MySQL no computador para
fazer a instalao posterior. Sugiro clicar nesta opo, pois caso voc tenha
algum problema na instalao ou tenha que reinstalar posteriormente, no
precisar baixar os recursos novamente.
Clique no boto Download.
Na pgina que aparecer, clique na parte inferior da tela no link No thanks,
just start my download. Est opo evita que voc tenha que criar um usurio
no site para acessar a rea de download.
Aparecer, na parte inferior da tela, a janela mostrada na Figura 7.3.
Figura 7.3: Opes para salvar ou executar o instalador do MySQL.
Clique no boto Executar, caso queira que aps baixar j seja iniciada
a instalao, ou no boto Salvar, para salvar na pasta configurada para
receber os downloads em seu computador. Caso queira escolher a pasta,
clique na setinha preta direita do boto Salvar.
Aps o download ser concludo, abra a pasta onde gravou o arquivo mysqlinstaller-community-5.6.21.0 e clique sobre ele.
Durante a instalao, basta clicar no boto Next, e em algumas telas,
Execute, at chegar tela mostrada na Figura 7.4, onde ser solicitado a
senha para o superusurio root, que j instalado no MySQL.
Figura 7.4: Definindo a senha do usurio root durante a instalao do MySQL.
Aps digitar e repetir a senha que voc deseja atribuir ao servidor MySQL,
clique no boto Next e prossiga a instalao at terminar.
7.2.1 Criando o banco de dados e a tabela com o

MySQL Workbench
Aps concluir a instalao, clique no boto Iniciar do Windows, em Todos
os programas, na pasta MySQL e na opo MySQL Workbench 6.1 CE.
Aparecer a tela mostrada na Figura 7.5.
Figura 7.5: Tela inicial do MySQl Workbench.
Para acessar a rea de trabalho do MySQL Workbench, clique na opo

Local Instance MySQL56, que aparecer a tela mostrada na Figura 7.6.
Figura 7.6: rea de trabalho do MySQL Workbench.
Na tela mostrada na Figura 7.6, j podemos criar nosso banco de dados, as tabelas
que necessitamos e executar outros comandos SQL, caso seja necessrio.
Para criar um novo banco de dados, clique na ferramenta create a new
schema in the connected server, na parte superior da tela. Trata-se de
uma ferramenta com desenho de um barril com um sinal de mais no canto
inferior esquerdo ( ).
Aparece a tela mostrada na Figura 7.7.
Figura 7.7: Criao do banco de dados nomeao.
No campo Name:, digite o nome do banco de dados, neste caso, bd001.

Clique no boto Apply. Aparece a instruo CREATE SCHEMA bd001;
Clique no boto Apply novamente. Em seguida, clique no boto Finish.
Pronto! O Banco de dados bd001 foi criado.
Do lado esquerdo da tela aparecem o nome dos bancos de dados existentes no
computador, como mostra a Figura 7.8.
Figura 7.8: Bancos de dados existentes.
Note que nosso banco de dados bd001 j est na lista de bancos de dados
existentes.
Clique na seta esquerda do nome do banco de dados e aparecer o que

Figura 7.9: Opes do banco de dados.
Clique com o boto direito sobre Tables e selecione a opo Create

Table..., como mostra a Figura 7.10.
Figura 7.10: Criao da tabela.
Na tela que aparece, no campo Table Name: digite o nome da tabela,

neste caso, cliente.
Em seguida, digite os campos que a tabela ter, como mostra a Figura 7.11.
Figura 7.11: Definio dos campos da tabela.
Clique no boto Apply.

Aparecer uma tela com o cdigo SQL a seguir, que gerar a tabela:
CREATE TABLE 'bd001'.'cliente' (
'id' INT NOT NULL,
'nome' VARCHAR(50) NULL,
'telefone' VARCHAR(15) NULL,
'sexo' VARCHAR(15) NULL,
'renda' DOUBLE NULL,
PRIMARY KEY ('id'));
Clique no boto Apply novamente e, em seguida, no boto Finish.
Pronto! Nossa tabela cliente j est criada e aparecer esquerda da tela,

como mostra a Figura 7.12.
Figura 7.12: Tabela criada.
No necessrio incluir, alterar, consultar ou excluir dados no banco de dados

por meio do MySQL Workbench. S utilizamos essa ferramenta para criar o
banco de dados e a tabela. As operaes no banco de dados sero executadas
na aplicao Java que ser criada.
7.2.2 Criando o banco de dados e a tabela com o

NetBeans
possvel criar o banco de dados e a tabela diretamente no NetBeans,
dispensando o MySQL Workbench. Para isso, siga as orientaes abaixo.
Para se conectar ao MySQL server e criar o banco de dados e a tabela usando
o NetBeans, inicie o servidor MySQL clicando em Iniciar, Todos os
programas, MySQL, MySQL Server 5.6 e MySQl 5.6 Command Line
Cliente. Caso prefira, pode abrir o Workbench apenas para iniciar o MySQL
Server.
Na rea de trabalho do NetBeans, clique na guia Servios, mostrada na

Figura 7.13.
Figura 7.13: Guia servios do NetBeans.
Clique com o boto direito do mouse sobre a opo Banco de Dados.

Selecione a opo Registrar Servidor MySQL.
Digite os dados do servidor, como mostra a Figura 7.14, inclusive a senha que
voc definiu na instalao do MySQL.
Figura 7.14: Informando os dados do servidor MySQL.
Clique no boto OK.

Na janela ativa aparecer a opo Servidor MySQL em localhost:3306[root].
Clique com o boto direito do mouse sobre esta opo e selecione
Conectar. Clique no sinal de mais esquerda desta opo e ver o nome
dos bancos de dados existentes no computador.
Clique com o boto direito do mouse sobre esta opo e selecione a opo
Criar banco de Dados, como mostra a Figura 7.15.
Figura 7.15: Criao do banco de dados.
Aparecer uma janela onde voc deve digitar o nome do banco de dados,
Figura 7.16: Nomeando o banco de dados.
Clique no boto OK.

Aparecer na janela a conexo com o banco de dados criado, com a seguinte
descrio:
jdbc:mysql://localhost:3306/bd002?zeroDateTimeBehavior=convertToNull
Clique no sinal de mais esquerda desta opo e aparecer os bancos de

dados existentes, como mostra a Figura 7.17.
Figura 7.17: Mostrando os bancos de dados exeistentes.
Clique com o boto direito do mouse sobre a opo Tabelas e selecione

a opo Criar Tabela.
No campo Nome da tabela, digite cliente, conforme mostra a Figura
7.18.
Figura 7.18: Criando a tabela.
Clique no boto Adicionar Coluna para criar os campos da tabela.

Aparecer a Figura 7.19.
Figura 7.19: Criao dos campos da tabela.
No campo Nome:, digite id, no campo Tipo:, selecione int, em

Restries, selecione Chave primria e clique no boto OK.
Repita esse procedimento at criar todos os campos mostrados na Figura 7.20.
Figura 7.20: Campos da tabela.
Aps terminar, clique no boto OK.

Pronto! A tabela est criada, como mostra a Figura 7.21.
Figura 7.21: Exibindo a tabela criada.
Clique na guia Projetos, esquerda da guia Servios, para iniciar a

aplicao Java que ser conectada ao banco de dados criado.
7.3 Operaes em banco de dados

Agora que voc j sabe como criar um banco de dados e uma tabela no MySQL,
j podemos comear a executar operaes nesta tabela do banco de dados. Para
todos os exemplos deste Captulo, utilizaremos o banco de dados bd002 e
a tabela cliente criados no tpico anterior.
Para executar operaes em um banco de dados, precisamos nos conectar a ele,

executar a operao e desconectar. Muitas vezes mantemos a conexo aberta e a
gerenciamos atravs de um pool de conexes, o que diminui consideravelmente
a carga de operaes no banco de dados.
O pool de conexes um repositrio que mantm uma lista de conexes abertas
e reutilizveis. Basicamente criado por uma classe que gerencia as operaes
de abertura e fechamento da conexo. Nos exemplos apresentados a seguir no
criaremos pool de conexo, pois o nvel de complexidade muito alto para o
aprendizado inicial pretendido neste Captulo.
7.3.1 Classes e interfaces usadas em operaes

com banco de dados
Para executar operaes em um banco de dados voc precisar, alm do banco
de dados e da tabela:
De um driver de conexo criado pelo fabricante do SGBD que vamos
utilizar. O NetBeans j traz incorporado drivers para diversos SGBDs,
como MySQL, Oracle, PostgreSQL etc.
Do pacote de classes java.sql, que traz as interfaces Connection, Statement,
PreparedStatement e ResultSet, e as classes DriverManager e SQLException.
Todas estas classes e interfaces cumprem um papel especfico e importante
para realizar operaes com um banco de dados. Este papel apresentado
a seguir:

Connection Estabelece e mantm uma conexo ativa com o banco

de dados.
Statement ou PreparedStatement Permite executar comandos

SQL no banco de dados, como insert, select, delete e update. Por
meio de mtodos assinados nesta interface possvel utilizar estes
comandos. O mtodo executeQuery, permite executar o comando
select e o mtodo executeUpdate permite executar os comandos insert,
update e delete.
ResultSet Recebe o retorno das consultas realizadas na tabela por

meio do comando select. Os dados que o comando select retornam do
banco de dados so recebidos por um objeto da interface ResultSet.
SQLException Quando uma exceo relacionada a uma operao

no banco de dados ocorre, um objeto desta classe recebido na
clusula catch de um tratamento de exceo iniciado pela instruo
try. Por meio deste objeto possvel obter informaes do erro, como
o nmero (mtodo getErrorCode), a mensagem de erro (mtodo
getErrorMessage) etc.
DriverManager Passa os parmetros para realizar a conexo com o

banco de dados, como o caminho, a porta, o nome do banco de dados, o
usurio e a senha, e gerencia o uso do driver de conexo fornecido pelo
fabricante do SGBD.
Nos tpicos a seguir voc aprender como utilizar essas classes e interfaces
para realizar operaes no banco de dados.
7.3.2 Operao de cadastro

Neste tpico voc ver um pequeno exemplo que faz uma conexo com o
banco de dados, executa uma incluso de registro (cadastro) na tabela e fecha
a conexo. O exemplo ser apresentado duas vezes, uma utilizando a interface
PreparedStatement para executar o comando SQL insert e outra utilizando a
interface Statement.
Crie um novo projeto Java chamado TesteBanco e uma classe principal chamada
Banco.java.
Para executar operaes no banco de dados, temos que adicionar o driver JDBC
biblioteca do projeto. Para isso, clique com o boto direito do mouse sobre
a pasta Bibliotecas e selecione a opo Adicionar Biblioteca.
Aparecer a tela mostrada na Figura 7.22.
Figura 7.22: Janela para a seleo do driver JDBC.
Selecione, na lista de bibliotecas disponveis, a opo Driver JDBC do

MySQL e clique na opo Adicionar Biblioteca.
Ao realizar este procedimento o projeto dever estar como mostra a Figura 7.23.
Figura 7.23: Projeto para incluso de dados no banco de dados.
Veja que o driver JDBC do MySQL j est na pasta Bibliotecas do projeto.

Clique no sinal de mais (+) esquerda do nome do driver (Driver JDBC do
MySQL mysql-connector-java-5.1.23-bin.jar) que voc ver o que mostra
a Figura 7.24.
Figura 7.24: Pacotes do driver JDBC do MySQL.
Note que nesta biblioteca de driver h um pacote de classes chamado com.

mysql.jdbc. Clique no sinal de mais esquerda do nome deste pacote e voc
ver a relao de classes que ele contm, como mostra a Figura 7.25.
Figura 7.25: Classe do driver na biblioteca do projeto.
Nesta lista de classes, localize a classe Driver.class. Esta classe especial,

pois ser utilizada em todas as classes que voc criar para realizar a conexo
com o banco de dados.
Na classe Banco.java, digite o cdigo-fonte a seguir:

1
2
3
4
5
6
7
8
9
10
11
12
import java.sql.PreparedStatement;
public class Banco {
13
14
15
16
17
18
19
20
21
22
23
24
25
26

try {
("jdbc:mysql://localhost:3306/bd002", "root", "teruel");
PreparedStatement st = conn.prepareStatement("insert into cliente
(id, nome, telefone, sexo, renda) values (?, ?, ?, ?, ?)");
st.setInt(1, 10);
st.setString(2, "Marco Antonio");
st.setString(3, "(11)5678-9087");
st.setString(4, "Masculino");
st.setDouble(5, 14567.56);
st.executeUpdate();
JOptionPane.showMessageDialog(null, "Os dados do cliente foram
salvos");
conn.close();
} catch (ClassNotFoundException | SQLException ex) {
JOptionPane.showMessageDialog(null, "Erro ao conectar com o
Banco de Dados");
}
}
Veja que as operaes no banco de dados esto concentradas dentro de uma

instruo try (da linha 10 21). Isso significa que se algumas destas operaes
falharem ser feito um direcionamento para a linha da instruo catch (linha
22). Neste bloco de linhas, podero ocorrer apenas dois tipos de excees:
ClassNotFoundException e SQLException.
Uma exceo ClassNotFoundException poder ser gerada na linha 11, se a
classe Driver.class no for encontrada no pacote com.mysql.jdbc da biblioteca
do driver do projeto. Veja que adicionamos essa biblioteca ao projeto antes
de criar esta classe.
Uma exceo SQLException poder ser gerada na linha 19, quando a instruo
insert definida na linha 13 for executada pelo mtodo executeUpdate. Caso
esta instruo esteja incorreta, gerar a exceo.
A linha 11 informa a classe do driver que ser utilizada para fazer a conexo
entre a aplicao e o MySQL.
A linha 12 faz a conexo com o banco de dados. Veja que o mtodo esttico
getConnection da classe DriverManager utilizado para passar os parmetros
de conexo com o banco de dados. So passados trs parmetros, apresentados
a seguir:
jdbc:mysql://localhost:3306/bd002 indica o IP da mquina em que o
MySQL server est instalado (localhost indica a mquina local, mas este
valor pode ser substitudo pelo IP da mquina), a porta onde o MySQL
recebe requisies (3306) e o nome do banco de dados (bd002).
root indica o nome do usurio que acessar o banco de dados. Deve ser
um usurio registrado no MySQL. O valor root de um usurio padro j
instado e configurado automaticamente na instalao do MySQL.
teruel indica a senha do MySQL. Neste caso, teruel a minha senha.
No deixe de colocar a senha que voc definiu na instalao do MySQL
em seu computador.
O mtodo getConnection, aps passar os parmetros de conexo com o banco
de dados, retorna um objeto da interface Connection, contendo a conexo
estabelecida. Este objeto recebido e chamado de conn (linha 12).
A linha 13 passa para o mtodo prepareStatement da interface Connection
uma instruo insert incompleta, pois precisa receber parmetros nos locais
onde esto os pontos de interrogao. Estes parmetros so fornecidos nas
linhas de 14 18. Veja na linha 14 que o valor 10 passado como parmetro
e substituir o primeiro ponto de interrogao. O nome Marco Antonio
passado como parmetro e substituir o segundo ponto de interrogao, e
assim por diante.
A linha 19 executa a instruo insert definida na linha 13, aps ela receber
todos os parmetros e se tornar completa. Veja que o mtodo executeUpdate da
interface Statement responsvel por executar o comando insert da linguagem
SQL. A linha 20 mostra uma mensagem indicando que a incluso foi realizada
e a linha 21 encerra (fecha) a conexo com o banco de dados.
Se ocorrerem as excees ClassNotFoundException ou SQLException ser
mostrada a mensagem contida na linha 23.
Ao compilar e executar o projeto acima por meio do pressionamento da tecla

F6, ser mostrada a mensagem apresentada na Figura 7.26.
Figura 7.26: Confirmao de cadastro.
NOTA
Na classe apresentada, voc poderia solicitar os valores a serem inseridos

ao usurio e passar estes valores como parmetros para a instruo insert
definida no mtodo prepareStatement. A interface PreparedStatement
permite executar uma operao SQL parametrizada, ou seja, que recebe
parmetros.
Alm da interface PreparedStatement, a interface Statement tambm pode ser

utilizada para executar comandos SQL. A grande diferena que a instruo
SQL executada por mtodos da interface PreparedStatement pode receber
parmetros e a instruo SQL executada pela interface Statement, no.
Veja o mesmo exemplo apresentado anteriormente utilizando a interface Statement.
1
2
3
4
5
6
7
8
9
import java.sql.*;
try {
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
Statement st = conn.createStatement();
int id = 12;
String nome = "Marco Antonio";
String telefone = "(11)5678-9087";
String sexo = "Masculino";
double renda = 14567.56;
String sql = "insert into cliente (id, nome, telefone, sexo, renda)
values (" + id + ", '" + nome + "', '" + telefone + "', '" + sexo + "', " +
renda + ")";
st.executeUpdate(sql);
JOptionPane.showMessageDialog(null, "Os dados do cliente foram
salvos");
conn.close();
JOptionPane.showMessageDialog(null, "Erro ao conectar com o
Banco de Dados");
}
Note no bloco de linhas de 10 17 a execuo da instruo insert utilizando a

interface Statement. Veja que a instruo insert armazenada na varivel SQL
(linha 16), concatenando-se as partes da instruo com os valores contidos
nas variveis onde esto os dados a serem inseridos. Perceba como esta linha
complexa. O sinal de + utilizado para concatenar valores na String.
Perceba na linha 17 que a instruo insert contida na varivel sql executada.
Observe com ateno as diferenas entre o uso da interface Statement (neste
exemplo), e da interface PreparedStatement (no exemplo anterior). O uso da
interface PreparedStatement mais comum na comunidade de desenvolvedores.
Se voc deseja se conectar a outro SGBD que no seja o MySQL, dever
apenas trocar o driver adicionado biblioteca para o driver fornecido
pelo fabricante do SGBD e mudar as seguintes linhas de conexo:
NOTA
Class.forName(com.mysql.jdbc.Driver);
Connection conn = DriverManager.getConnection (jdbc:mysql://localhost:3306/
bd002, root, teruel);
Bastar mudar os parmetros passados para o mtodo forName da

classe Class e getConnection da classe DriverManager. Voc descobrir
quais so os parmetros na documentao do driver JDBC ou no site
do fabricante do SGBD.
7.3.3 Operao de consulta

Para realizar uma operao de consulta (busca) em uma tabela do banco de
dados necessrio se conectar ao banco de dados, executar a consulta e fechar
a conexo. Podem ser utilizados mtodos das interfaces PreparedStatement
ou Statement para executar a consulta.
Veja o exemplo da classe Banco.java que busca um registro na tabela cujo

campo id possua o valor 10:
1
2
3
4
5
6
7
8
import java.sql.*;
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

try {
PreparedStatement st = conn.prepareStatement("select * from
cliente where id = ? ");
st.setInt(1, 10);
ResultSet rs = st.executeQuery();
if (rs.next()) {
System.out.println("ID: " + rs.getString("id"));
System.out.println("Nome: " + rs.getString("nome"));
System.out.println("Telefone: " + rs.getString("telefone"));
System.out.println("Sexo: " + rs.getString("sexo"));
System.out.println("Renda: " + rs.getString("renda"));
} else {
System.out.println("Cliente no encontrado");
}
conn.close();
System.out.println("Erro ao tentar se conectar ao banco de
dados");
}
}
Veja na linha 9 a gerao da instruo SQL select incompleta, necessitando

como parmetro do id para substituir o ponto de interrogao. Este parmetro,
passado na linha 10.
A linha 11 executa a instruo SQL select por meio do mtodo executeQuery

da interface PreparedStatement. O resultado da pesquisa na tabela do banco
de dados armazenado no objeto rs da interface ResultSet. A linha 12 verifica
se este objeto contm dados. Se sim, porque a consulta tabela retornou
algum registro. Neste caso, as linhas de 13 17 exibem os dados retornados.
Veja que para obter o contedo de cada campo da tabela, utilizou-se o mtodo
getString da interface ResultSet. A instruo rs.getString(id), por exemplo,
retorna o id contido no objeto rs da interface ResultSet.
Caso a consulta no tenha retornado nenhum registro, o que aconteceria se o

id informado para a pesquisa no existisse no banco de dados, a mensagem
da linha 19 seria mostrada.
Ao compilar e executar o projeto, por meio do pressionamento da tecla F6, os
dados sero apresentados na tela, como mostra a Figura 7.27.
Figura 7.27: Exibio dos dados da consulta.
Veja agora o mesmo exemplo utilizando a interface Statement:

1
2
3
4
5
6
7
8
9
10
11
12
13
import java.sql.*;
try {
int id = 12;
String sql = "select * from cliente where id = " + id;
ResultSet rs = st.executeQuery(sql);
if (rs.next()) {
14
15
16
17
18
19
20
21
22
23
24
25
26
27

} else {
}
conn.close();
System.out.println("Erro ao tentar se conectar ao banco de dados");
}
Observe que as linhas responsveis pela consulta esto no intervalo de linhas

de 9 13. Note na linha 11 que a instruo select armazenada na varivel
String sql, concatenada como o valor contido na varivel id. A linha 12 executa
a instruo select contida na varivel sql e armazena o registro retornado da
tabela em um objeto da interface ResultSet. Se a consulta retornou algum valor
(linha 13), os dados so exibidos na tela (linhas de 14 18).
Note que as diferenas no so muito grandes em relao ao uso da interface
PreparedStatement.
7.3.4 Operao de consulta de todos os registros

O tpico anterior apresentou uma consulta que retornava apenas um registro.
Este tpico apresentar uma consulta que retornar vrios registros. O que
muda, de fato, a instruo SQL select executada e a forma de exibir os dados,
pois se so retornados mais de um registro, ser necessrio um lao de repetio
para percorr-los e exibi-los.
Veja o exemplo da classe Banco.java utilizando a interface PreparedStatement:
1
2
3
4
5
6
7
8
import java.sql.*;
try {
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
PreparedStatement st = conn.prepareStatement("select * from

cliente");
ResultSet rs = st.executeQuery();
while (rs.next()) {
System.out.println("--------------------------------------");
}
conn.close();
dados");
}
Note que a instruo SQL select preparada na linha 9 e executada na linha

10. Neste caso, no foi necessrio nenhum parmetro na instruo select.
Caso a consulta tenha retornado um ou mais registros, a linha 11 define um
lao de repetio que ser executado enquanto houver prximo registro na
relao de registros retornada na consulta.
Enquanto tiver registro a ser exibido, o lao de repetio das linhas 11 18
ser executado, exibindo na tela os dados de cada pessoa. Veja que o mtodo
getString responsvel por obter os dados do objeto rs da interface ResultSet,
como String. Voc poderia utilizar os mtodos getDouble, getInt etc para obter
os dados de outros tipos.
os dados cadastrados na tebela do banco de dados sero apresentados na tela,
Figura 7.28: Exibio do resultado da consulta que retorna vrios registros.
Veja agora o exemplo da classe Banco.java utilizando a interface Statement:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import java.sql.*;
try {
String sql = "select * from cliente";
ResultSet rs = st.executeQuery(sql);
while (rs.next()) {
System.out.println("--------------------------------------");
}
20
21
22
23
24
25
conn.close();
}
Observe que as linhas responsveis pela consulta esto no intervalo de 9

11. Note na linha 10 que uma instruo select armazenada em uma varivel
String que passada como parmetro para o mtodo executeQuery da linha
11 para ser executada. O resultado da busca ser armazenado no objeto rs
da interface ResultSet. Se foram retornados registros na consulta, eles sero
mostrados pelas linhas de 12 19.
7.3.5 Operao de excluso

Para executar uma operao de excluso de registro na tabela voc precisa
se conectar ao banco de dados, executar a instruo SQL delete e fechar a
conexo com o banco de dados. Voc pode executar esta operao utilizando
as interfaces PreparedStatement ou Statement.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import java.sql.*;
try {
PreparedStatement st = conn.prepareStatement("delete from
cliente where id = ? ");
st.setInt(1, 10);
int r = st.executeUpdate();
if (r == 1) {
System.out.println("Cliente excludo com sucesso");
} else {
}
conn.close();
19
20
21
22

dados");
Veja que a instruo SQL delete preparada na linha 9, aguardando o id como

parmetro, que ser inserido na posio onde est o ponto de interrogao.
Este parmetro fornecido na linha 10.
A linha 11 executa o comando delete (preparado na linha 9) por meio do mtodo
executeUpdate. Este mtodo retorna o nmero de linhas da tabela que foram
afetadas pela execuo do comando delete, neste caso, 1, pois apenas um registro
foi excludo; ou 0, caso nenhum registro tenha sido excludo. Se o valor retornado
for 1 (linha 12), porque a excluso ocorreu. Neste caso, ser apresentada a
mensagem definida na linha 13. Se o retorno foi 0, o que indica que a operao
de excluso no ocorreu, normalmente porque o id passado como parmetro
no existe cadastrado na tabela, ser mostrada a mensagem definida na linha 15.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import java.sql.*;

try {
int id = 12;
String sql = "delete from cliente where id = " + id;
int r = st.executeUpdate(sql);
if (r == 1) {
System.out.println("Cliente excludo com sucesso");
} else {
}
conn.close();
}
}
Observe que as linhas responsveis pela excluso do registro cujo id igual a

12 esto no intervalo de 9 12. Perceba que a instruo delete armazenada
em uma varivel String (linha 11) que passada como parmetro para o mtodo
executeUpdate na linha 12, para ser executada. Se a operao ocorreu, exibe a
mensagem presente na linha 14. Se no ocorreu, exibe a mensagem presente
na linha 16.
7.3.5.1 Operao de alterao

Para executar uma operao de alterao de registro em uma tabela do banco
de dados voc dever se conectar ao banco de dados, executar um comando
SQL update e fechar a conexo com o banco de dados.

1
2
3
4
5
6
7
8
import java.sql.*;
9
10
11
12
13
14
15
16
17
18
19
20
21
22

try {
PreparedStatement st = conn.prepareStatement("update cliente
set nome=?, telefone=?, sexo=?, renda=? where id=?");
st.setString(1, "Anderson Silva");
st.setString(2, "(11)4567-9876");
st.setString(3, "Masculino");
st.setDouble(4, 22987.56);
st.setInt(5, 1);
st.executeUpdate();
System.out.println("Os dados do cliente foram alterados");
conn.close();
dados");
}
}
Esta classe altera os dados do registro cadastrado cujo contedo do campo id

igual a 1.
Observe que a instruo SQL update preparada na linha 9, aguardando

apenas os parmetros que sero includos nos lugares onde esto os pontos de
interrogao. Estes parmetros so passados em ordem, das linhas 10 14.
A linha 15 executa a operao de alterao e exibe a mensagem da linha 16.
Note que o mtodo da interface PreparedStatement responsvel por executar
um comando update o mtodo executeUpdate.
Na linha 17 a conexo com o banco de dados finalizada.

aparecer a mensagem mostrada na Figura 7.29, caso voc tenha um registro
contendo o valor 1 no campo id.
Figura 7.29: Confirmao da alterao de um registro no banco de dados.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import java.sql.*;
try {
int id = 3;
String nome = "Joo de Deus";
String telefone = "(11)7865-9087";
String sexo = "Masculino";
double renda = 14567.56;
String sql = "update cliente set nome= '" + nome + "', telefone= '" +
telefone + "', sexo= '" + sexo + "', renda=" + renda + " where id= " +
id + "";
int r = st.executeUpdate(sql);
if (r == 1) {
18
19
20
21
22
23
24
25
26
27
System.out.println("Os dados do cliente foram alterados");

} else {
System.out.println("cliente no encontrado");
}
conn.close();
}
Observe que as linhas responsveis por executar a alterao no registro esto

no intervalo de 14 16. Veja que na linha 15 a instruo update armazenada
em uma varivel String, concatenando-se as partes da instruo com o contedo
das variveis que contm os dados a serem alterados. Perceba que muito
trabalhoso e complexo gerar esta linha.
Na linha 16 a instruo update contida na varivel String executada, retornando
o valor 1 caso a operao tenha sido executada com sucesso, e 0, caso no tenha
sido executada (no caso de no haver um registro com o id informado para
alterao). Se a operao teve sucesso (linha 17), exibe a mensagem contida na
linha 18. Caso contrrio, exibe a mensagem contida na linha 20.
7.3.6 Diferenas entre as interfaces

PreparedStatement e Statement
Como voc pde perceber nos exemplos apresentados nos tpicos anteriores,
para executar qualquer operao em uma tabela do banco de dados voc
precisar de um objeto das interfaces PreparedStatement ou Statement.
Por meio deste objeto voc conseguir acessar os mtodos para executar os
comandos insert, updade, select e delete da linguagem SQL. Para executar as
instrues insert, update e delete, voc dever utilizar o mtodo executeUpdate.
Para executar a instruo select, precisar do mtodo executeQuery.
Se voc utilizar um objeto da interface PreparedStatement, sua instruo SQL
poder receber, como parmetro, os valores a serem inseridos. Se utilizar a
interface Statement, ter que montar a instruo SQL concatenando sua partes
com os valores a serem inseridos, o que dar bastante trabalho e a instruo
estar propensa a erros.
Procure utilizar a interface PreparedStatement, mais fcil de utilizar, mais
segura e mais utilizada pela comunidade de desenvolvedores Java.
7.4 Exemplo de aplicao CRUD

CRUD a abreviao de Create, Read, Update e Delete.
Uma aplicao CRUD precisa executar estas operaes em um banco de dados.
Create a funcionalidade de cadastro, executada pela instruo SQL insert.
Read a funcionalidade de consulta, executada pela instruo SQL select.
Update a funcionalidade de alterao, executada pela instruo SQL update.
Delete a funcionalidade de excluso, executada pela instruo SQL delete.
Neste tpico criaremos uma aplicao CRUD utilizando os recursos das APIs
swing e awt para criar as janelas para entrada e apresentao de dados, e da
API JDBC para executar operaes no banco de dados e na tabela que criamos
no incio deste Captulo.
Crie ento um projeto chamado ProjetoBD e uma classe principal chamada
Menu.java, conforme mostra a Figura 7.30.
Figura 7.30: Projeto para criar uma aplicao CRUD.
Adicione o driver JDBC pasta Bibliotecas do projeto, clicando com o boto

direito sobre o nome da pasta, como mostra a Figura 7.31.
Figura 7.31: Adicionando o driver JDBC biblioteca.
Selecione a opo Adicionar Biblioteca, que aparecer a Figura 7.32.
Figura 7.32: Escolha do driver JDBC entre as bibliotecas disponveis.
Selecione Driver JDBC do MySQL e clique no boto Adicionar Biblioteca.

Pronto!
Veja na Figura 7.33 que o driver j est na biblioteca do nosso projeto.
Figura 7.33: Driver JDBC do MySQL na pasta Bibliotecas do projeto.
Agora j podemos programar a classe Menu.java, mas antes vamos

apresentao de algumas informaes sobre a aplicao que facilitar o
entendimento do cdigo-fonte.
A classe Menu.java criar trs formulrios (janelas): uma janela do menu
principal, uma janela para cadastro e alterao de dados e uma janela para
consulta e excluso de dados.
Ao executar a aplicao aparecer a janela principal, mostrada na Figura 7.34.
Figura 7.34: janela do menu principal da aplicao.
Ao clicar no boto Cadastro no menu principal aparecer a janela mostrada

na Figura 7.35.
Figura 7.35: Janela para cadastro e alterao de dados.
Aps cadastrar os dados nos campos, a janela ter a aparncia mostrada na

Figura 7.36.
Figura 7.36: Entrando com dados para o cadastro.
Ao clicar no boto Salvar, aparecer a mensagem mostrada na Figura 7.37.
Figura 7.37: Confirmao de cadastro.
Ao clicar no boto Voltar, a janela atual escondida e a tela do menu principal

ser apresentada novamente.
Ao clicar no boto Outras Operaes, no menu principal, aparecer a janela
Figura 7.38: Janela para consultas e excluso de dados.
Veja que voc tem um painel na parte superior onde poder realizar as operaes
de consulta, excluso e alterao.
Ao digitar no campo ID o valor 1 e clicar no boto Buscar, caso exista este
registro no banco de dados, os dados sero carregados na tabela na parte inferior
da janela, como mostra a Figura 7.39.
Figura 7.39: Exibio do registro retornado do banco de dados.
Ao clicar no boto Exibir Tudo, todos os registros na tabela do banco de

dados sero apresentados, como mostra a Figura 7.40.
Figura 7.40: Exibio de todos os registros da tabela do banco de dados.
Ao digitar 2 no campo ID e clicar no boto Excluir, ser apresentado o que

mostra a Figura 7.41, pedindo a confirmao da excluso.
Figura 7.41: Operao de excluso de registro.
Ao clicar no boto no boto Sim, aparecer a caixa de dilogo mostrada na

Figura 7.42.
Figura 7.42: Confirmao da excluso de um registro.
Digitando o valor 1 no campo ID e clicando no boto Alterar, a mesma

janela usada no cadastro ser exibida, porm, com os dados do registro cujo
ID 1 e com o boto Salvar Alterao na parte de baixo da janela, como
Figura 7.43: Carregamento dos dados para alterao.
Veja na janela mostrada na Figura 7.44 que foi feita uma modificao nos
campos nome e telefone.
Figura 7.44: Modificando dados.
Ao clicar no boto Salvar Alterao, aparecer a caixa de dilogo mostrada

na Figura 7.45.
Figura 7.45: Confirmao da operao de alterao.
Ao clicar no boto OK, a tela de operaes ser mostrada. Ao clicar no boto

Voltar, o menu principal ser exibido novamente.
As trs janelas utilizadas, assim como o tratamento de eventos de clique nos
botes, foram geradas pela mesma classe, o que deixou o cdigo-fonte bastante
longo. Uma alternativa seria usar uma classe para cada janela, mas seria um
pouco mais difcil de alternar entre elas, principalmente quando necessrio
passar parmetros de uma tela para outra.
Agora que voc j viu as telas geradas pelas operaes da aplicao, vamos
analisar o cdigo-fonte da classe Menu.java, apresentado a seguir:
1
2
3
4
5
6
7
import java.awt.*;
import java.awt.event.*;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
import java.text.DecimalFormat;
import javax.swing.border.TitledBorder;
import javax.swing.table.DefaultTableModel;
import javax.swing.text.DefaultFormatterFactory;
import javax.swing.text.NumberFormatter;
public class Menu extends JFrame implements ActionListener {
JFrame frmCadastrarAlterar, frmManutencao;
JButton btnCadastro, btnOp, btnVoltaCadAlt, btnVoltaManutencao,
btnSair;
JButton btnSalvar, btnSalvarAlteracao, btnAlterar, btnBuscar, btnExcluir,
btnExibirTudo;
JLabel lblId, lblNome, lblTelefone, lblSexo, lblRenda;
JTextField txtNome;
JFormattedTextField txtTelefone, txtId, txtIdConsulta, txtRenda;
MaskFormatter mskTelefone, mskId;
ButtonGroup gruSexo;
JRadioButton rdoMasculino, rdoFeminino;
JPanel pnlCampos, pnlTabela;
TitledBorder tituloPnlCampos, tituloPnlTabela;
DefaultTableModel tblConsultaModel;
JTable tblConsulta;
JScrollPane scrRolagem;
Connection conn;
PreparedStatement st;
ResultSet rs;
public Menu() {
//Programao da janela principal (Menu)
setTitle("Menu Principal");
setLayout(null);
setBounds(500, 300, 300, 210);
btnCadastro = new JButton("Cadastro");
btnCadastro.setBounds(50, 20, 150, 30);
btnCadastro.addActionListener(this);
btnOp = new JButton("Outras Operaes");
btnOp.setToolTipText("Consultas, excluso e alterao de
dados");
btnOp.setBounds(50, 70, 150, 30);
btnOp.addActionListener(this);
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

btnSair.setBounds(50, 120, 150, 30);
btnSair.addActionListener(this);
add(btnCadastro);
add(btnOp);
add(btnSair);
//Programao da janela para cadastro e alterao de dados
frmCadastrarAlterar = new JFrame("Cadastro");
frmCadastrarAlterar.setDefaultCloseOperation(EXIT_ON_CLOSE);
frmCadastrarAlterar.setLayout(null);
frmCadastrarAlterar.setBounds(400, 200, 600, 280);
frmCadastrarAlterar.getContentPane().setBackground
(Color.LIGHT_GRAY);
lblId = new JLabel("ID:");
lblId.setBounds(10, 10, 50, 30);
frmCadastrarAlterar.add(lblId);
txtId = new JFormattedTextField();
txtId.setFormatterFactory(new DefaultFormatterFactory(new
NumberFormatter(new DecimalFormat("#"))));
txtId.setBounds(10, 40, 150, 30);
txtId.requestFocus();
frmCadastrarAlterar.add(txtId);
lblNome.setBounds(170, 10, 50, 30);
frmCadastrarAlterar.add(lblNome);
txtNome.setBounds(170, 40, 400, 30);
frmCadastrarAlterar.add(txtNome);
lblTelefone = new JLabel("Telefone:");
lblTelefone.setBounds(10, 80, 150, 30);
frmCadastrarAlterar.add(lblTelefone);
try {
}
txtTelefone.setBounds(10, 110, 100, 30);
frmCadastrarAlterar.add(txtTelefone);
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
lblSexo = new JLabel("Sexo:");

lblSexo.setBounds(170, 80, 150, 30);
frmCadastrarAlterar.add(lblSexo);
rdoMasculino.setBounds(170, 110, 100, 30);
rdoFeminino.setBounds(300, 110, 100, 30);
gruSexo = new ButtonGroup();
frmCadastrarAlterar.add(rdoMasculino);
frmCadastrarAlterar.add(rdoFeminino);
lblRenda.setBounds(450, 80, 150, 30);
frmCadastrarAlterar.add(lblRenda);
txtRenda = new JFormattedTextField();
txtRenda.setFormatterFactory(new DefaultFormatterFactory(new
NumberFormatter(new DecimalFormat("#0.00"))));
txtRenda.setBounds(450, 110, 100, 30);
txtRenda.setToolTipText("Utilize vrgula para separar as casas
decimais");
frmCadastrarAlterar.add(txtRenda);
btnSalvar.setBounds(10, 170, 150, 30);
btnSalvar.addActionListener(this);
btnSalvar.setVisible(false);
frmCadastrarAlterar.add(btnSalvar);
btnSalvarAlteracao = new JButton("Salvar Alterao");
btnSalvarAlteracao.setBounds(10, 170, 150, 30);
btnSalvarAlteracao.addActionListener(this);
btnSalvarAlteracao.setVisible(false);
frmCadastrarAlterar.add(btnSalvarAlteracao);
btnVoltaCadAlt = new JButton("Voltar");
btnVoltaCadAlt.setBounds(170, 170, 150, 30);
btnVoltaCadAlt.addActionListener(this);
frmCadastrarAlterar.add(btnVoltaCadAlt);
//Programao da janela de consulta e excluso (Outras Operaes)
frmManutencao = new JFrame("Manuteno");
frmManutencao.setDefaultCloseOperation(EXIT_ON_CLOSE);
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
frmManutencao.setLayout(null);
frmManutencao.setBounds(400, 200, 600, 500);
frmManutencao.getContentPane().setBackground(Color.LIGHT_
GRAY);
pnlCampos = new JPanel(null);
tituloPnlCampos = BorderFactory.createTitledBorder("rea de
operaes");
pnlCampos.setBorder(tituloPnlCampos);
pnlCampos.setBounds(10, 10, 565, 100);
pnlCampos.add(lblId);
txtIdConsulta = new JFormattedTextField();
txtIdConsulta.setBounds(40, 35, 100, 30);
pnlCampos.add(txtIdConsulta);
btnBuscar = new JButton("Buscar");
btnBuscar.setBounds(170, 35, 80, 30);
btnBuscar.addActionListener(this);
pnlCampos.add(btnBuscar);
btnExcluir = new JButton("Excluir");
btnExcluir.setBounds(255, 35, 80, 30);
btnExcluir.addActionListener(this);
pnlCampos.add(btnExcluir);
btnExibirTudo = new JButton("Exibir Tudo");
btnExibirTudo.setBounds(340, 35, 100, 30);
btnExibirTudo.addActionListener(this);
pnlCampos.add(btnExibirTudo);
btnAlterar = new JButton("Alterar");
btnAlterar.setBounds(445, 35, 80, 30);
btnAlterar.addActionListener(this);
pnlCampos.add(btnAlterar);
frmManutencao.add(pnlCampos);
pnlTabela = new JPanel(null);
pnlTabela.setLayout(new GridLayout(1, 1));
tituloPnlTabela = BorderFactory.createTitledBorder("rea de exibio");
pnlTabela.setBorder(tituloPnlTabela);
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
201
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
pnlTabela.setBounds(10, 120, 565, 300);

frmManutencao.add(pnlTabela);
String[] cols = {"ID", "Nome", "Telefone", "Sexo", "Renda"};
tblConsultaModel = new DefaultTableModel(cols, 5);
tblConsulta = new JTable(tblConsultaModel);
tblConsultaModel.setNumRows(0);
scrRolagem = new JScrollPane(tblConsulta,
pnlTabela.add(scrRolagem);
btnVoltaManutencao = new JButton("Voltar");
btnVoltaManutencao.setBounds(200, 425, 150, 30);
frmManutencao.add(btnVoltaManutencao);
btnVoltaManutencao.addActionListener(this);
}
//Programao dos botes
@Override
Object btn = e.getSource();
if (btn == btnCadastro) {
setVisible(false);
btnSalvar.setVisible(true);
frmCadastrarAlterar.setVisible(true);
}
if (btn == btnOp) {
setVisible(false);
tblConsultaModel.setRowCount(0);
txtIdConsulta.setText("");
frmManutencao.setVisible(true);
}
if (btn == btnVoltaCadAlt) {
setVisible(true);
limparCampos();
frmCadastrarAlterar.setVisible(false);
}
if (btn == btnVoltaManutencao) {
setVisible(true);
frmManutencao.setVisible(false);
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
}
if (btn == btnSair) {
System.exit(0);
}
if (btn == btnSalvar) {
int id;
double renda;
String nome, telefone, sexo;
id = Integer.parseInt(txtId.getText());
nome = txtNome.getText();
telefone = txtTelefone.getText();
if (rdoMasculino.isSelected()) {
sexo = rdoMasculino.getText();
} else if (rdoFeminino.isSelected()) {
sexo = rdoFeminino.getText();
} else {
sexo = "";
}
renda = Double.parseDouble(txtRenda.getText().replace(",", "."));
if (conectar() == null) {
JOptionPane.showMessageDialog(btnSalvar, "Erro ao tentar
Se conectar ao banco de dados");
} else {
try {
st = conn.prepareStatement("insert into cliente (id, nome,
telefone, sexo, renda) values (?, ?, ?, ?, ?)");
st.setInt(1, id);
st.setString(2, nome);
st.setString(3, telefone);
st.setString(4, sexo);
st.setDouble(5, renda);
st.executeUpdate();
JOptionPane.showMessageDialog(btnSalvar, "Os dados do
cliente foram salvos");
limparCampos();
if (ex.getErrorCode() == 1062) {
JOptionPane.showMessageDialog(btnSalvar, "J existe um
cliente com este ID");
} else {
JOptionPane.showMessageDialog(btnSalvar, "Erro ao tentar
salvar os dados");
}
}
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
desconectar();
if (btn == btnBuscar) {
try {
JOptionPane.showMessageDialog(btnBuscar, "Erro ao tentar
conectar ao banco de dados");
} else {
if (txtIdConsulta.getText().isEmpty()) {
JOptionPane.showMessageDialog(btnBuscar, "Por favor,
digite um valor no campo ID");
txtIdConsulta.requestFocus();
} else {
int id = Integer.parseInt(txtIdConsulta.getText());
st=conn.prepareStatement("select * from cliente where id=? ");
st.setInt(1, id);
rs = st.executeQuery();
if (rs.next()) {
String[] linha = {rs.getString("id"), rs.getString("nome"),
rs.getString("telefone"), rs.getString("sexo"),
rs.getString("renda").replace(".", ",")};
tblConsultaModel.addRow(linha);
} else {
JOptionPane.showMessageDialog(btnBuscar, "Este cliente
no foi encontrado");
}
desconectar();
}
}
JOptionPane.showMessageDialog(btnBuscar, "Erro na consulta");
}
}
if (btn == btnExibirTudo) {
try {
JOptionPane.showMessageDialog(btnExibirTudo, "Erro ao
tentar conectar ao banco de dados");
} else {
st = conn.prepareStatement("select * from cliente");
314
315
while (rs.next()) {
String[] linha = {rs.getString("id"), rs.getString("nome"),
rs.getString("telefone"), rs.getString("sexo"),
rs.getString("renda").replace(".", ",")};
tblConsultaModel.addRow(linha);
}
desconectar();
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
}
JOptionPane.showMessageDialog(btnExibirTudo, "Erro na
consulta");
}
if (btn == btnExcluir) {
try {
JOptionPane.showMessageDialog(btnSalvar, "Erro ao tentar se
} else {
JOptionPane.showMessageDialog(btnExcluir, "Por favor,
} else {
int op = JOptionPane.showConfirmDialog(btnExcluir, "Tem
certeza que deseja excluir este cliente?",
JOptionPane.OPTIONS_PROPERTY,
JOptionPane.YES_NO_OPTION);
if (op == 0) {
st=conn.prepareStatement("delete from cliente where
id=?");
st.setInt(1, id);
if (r == 1) {
JOptionPane.showMessageDialog(btnExcluir, "Cliente
excludo com sucesso");
} else {
JOptionPane.showMessageDialog(btnExcluir, "Este
cliente no est cadastrado");
}
desconectar();
}
}
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
}
JOptionPane.showMessageDialog(btnExcluir, "Erro na excluso");
}
if (btn == btnAlterar) {
try {
JOptionPane.showMessageDialog(btnAlterar, "Erro ao tentar se
} else {
JOptionPane.showMessageDialog(btnAlterar, "Por favor,
} else {
st=conn.prepareStatement("select * from cliente where id=?");
st.setInt(1, id);
if (rs.next()) {
txtId.setText(rs.getString("id"));
txtId.setEditable(false);
txtNome.setText(rs.getString("nome"));
txtTelefone.setText(rs.getString("telefone"));
if (rs.getString("sexo").equalsIgnoreCase("masculino")) {
rdoMasculino.setSelected(true);
}
if (rs.getString("sexo").equalsIgnoreCase("feminino")) {
rdoFeminino.setSelected(true);
}
txtRenda.setText(rs.getString("renda").replace(".", ","));
btnSalvar.setVisible(false);
btnSalvarAlteracao.setVisible(true);
frmManutencao.setVisible(false);
frmCadastrarAlterar.setVisible(true);
} else {
JOptionPane.showMessageDialog(btnAlterar, "Este cliente
no foi encontrado");
}
}
}
JOptionPane.showMessageDialog(btnAlterar, "Erro na consulta");
}
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
if (btn == btnSalvarAlteracao) {
int id;
double renda;
} else {
sexo = "";
}
try {
st = conn.prepareStatement("update cliente set nome=?,
telefone=?, sexo=?, renda=? where id=?");
st.setString(1, nome);
st.setString(2, telefone);
st.setString(3, sexo);
st.setDouble(4, renda);
st.setInt(5, id);
st.executeUpdate();
JOptionPane.showMessageDialog(btnSalvarAlteracao, "Os dados
do cliente foram alterados");
limparCampos();
JOptionPane.showMessageDialog(btnSalvarAlteracao, "Erro ao
tentar salvar os dados");
}
desconectar();
limparCampos();
frmCadastrarAlterar.setVisible(false);
frmManutencao.setVisible(true);
}
//programao de mtodos de apoio

private Connection conectar() {
try {
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
conn = DriverManager.getConnection
return conn;
return null;
}
private void desconectar() {

try {
conn.close();
JOptionPane.showMessageDialog(btnSalvar, "Erro ao tentar se
desconectar do banco de dados");
}
}
private void limparCampos() {
txtId.setEditable(true);
txtId.setText("");
txtNome.setText("");
txtTelefone.setText("");
gruSexo.clearSelection();
txtRenda.setText("");
}
// mtodo principal de star da aplicao

Menu m = new Menu();
m.setVisible(true);
}
Nas linhas de 1 15 so importadas as classes utilizadas na aplicao. Note

que so importadas as classes da API awt, swing e JDBC.
Observe na linha 17 que a classe menu herda a classe JFrame e implementa
o mtodo abstrato da interface ActionListener. Lembre-se que implementar
a classe ActionListener obriga sobrescrever o mtodo actionPerformed, que
trata eventos de ao de clique do mouse.
Nas linhas de 19 35 so declarados os objetos que sero includos nas janelas
e tambm os que sero utilizados nas operaes com o banco de dados.
Nas linhas de 31 201 est o construtor da classe Menu.java. Este trecho
de cdigo gerar as janelas que sero utilizadas na aplicao. Ser utilizado
posicionamento esttico dos elementos, ou seja, no sero utilizados

gerenciadores de layout. Os objetos (elementos) tero sua posio e tamanho
configurados um a um por meio do mtodo setBounds. Lembre-se que este
mtodo recebe 4 parmetros, sendo os dois primeiros referentes posio do
elemento (eixos x e y) e os dois ltimos ao tamanho do elemento (largura e
altura). Poderamos utilizar os mtodos setLocation e setSize, mas optamos
por usar apenas o mtodo setBounds.
As linhas de 41 57 criam a janela do menu principal, que aparecer na tela

quando a aplicao for compilada e executada. Essa janela mostrada na
Figura 7.46.
Figura 7.46: Tela do menu principal.
Note a linha 49, que por meio do mtodo setToolTipText aplica uma mensagem
ao boto ao boto btnOp, que ser mostrada quando o ponteiro do mouse for
posicionado sobre ele.
Observe tambm as linhas 47, 51 e 54, que adicionam um Listener (ouvinte)
aos botes, de tal forma que quando eles receberem o clique do mouse, ser
feito um desvio para o mtodo actionPerformed, que tratar os eventos de
clique sobre os botes. As linhas de 55 57 adicionam os botes Cadastro,
Outras Operaes e Sair janela principal.
As linhas de 59 136 criam a janela com os campos. Esta janela ser utilizada
para fazer o cadastro e a alterao nos dados de um cliente. A janela gerada
Figura 7.47: tela para cadastro e alterao de dados.
No h novidades na criao desta janela em relao ao que j vimos no Captulo

anterior, exceto o que consta nas linhas 71 e 116. A linha 71 faz com que seja
permitido no campo ID apenas nmeros inteiros. A linha 116 permite apenas a
entrada de nmeros e da vrgula para separar as casas decimais. Caso voc inclua
outro caracter que no sejam os permitidos, eles automaticamente desaparecero.
Note tambm que trs botes so adicionados a esta janela: Salvar, Salvar
Alterao e Voltar, mas apenas um definido como visvel, o boto Voltar.
O boto Salvar Alterao ficar oculto (linha 130) e ser visualizado somente
quando esta janela for aberta para alterao de dados. J o boto Salvar ser
visualizado somente quando a tela for aberta para cadastro de um novo cliente.
Veja que os botes Salvar e Salvar Alterao ocupam a mesma posio,
pois nunca ficaro visveis ao mesmo tempo e dependero da operao a ser
realizada.
Da linha 138 linha 200 criada a janela para consulta e excluso de dados,
referente opo Outras Operaes do menu principal. Esta janela mostrada
pela Figura 7.48.
Figura 7.48: Janela para consultas e excluso de dados.
No h novidades na criao desta janela em relao ao que vimos no Captulo

anterior. H dois painis, um abaixo do outro. O painel superior contm um
campo de busca e alguns botes para realizar operaes de busca, excluso e
para chamar a operao de alterao. O painel inferior, que usa o gerenciador
de layout GridLayout (linha 183) para que a tabela se ajuste a nica clula do
layout, utilizado para exibir dados.
As linhas de 204 434 compem o mtodo actionPerformed, que chamado
sempre que um boto das janelas for clicado. Isso porque a todos os botes foi
adicionado um Listener (ouvinte) que monitora o boto. Dentro deste mtodo
est programado o que ocorrer aps cada boto ser clicado. A linha 207
captura o nome do boto que foi clicado e armazena na varivel btn, testando
em seguida esta varivel para saber o boto que foi clicado e realizar a operao
adequada para cada boto. J estudamos o tratamento de eventos de ao de
clique no captulo anterior. Se precisar de mais detalhes, releia o tpico sobre
tratamento de eventos no captulo 6.
As linhas de 209 213 tratam o evento de clique no boto Cadastrar
(btnCadastro) do menu principal. Veja que este mtodo apenas esconde o
formulrio de menu (linha 210) e exibe o formulrio do cadastro (linha 212).
Veja que antes de exibir o formulrio de cadastro, o boto Salvar deste
formulrio torna-se visvel (linha 211), j que esse boto havia sido criado
oculto (linha 124).
As linhas de 215 220 tratam o evento de clique no boto Outras Operaes
(btnOp) do menu principal. Este mtodo torna o formulrio de menu invisvel
(linha 216), limpa a tabela do formulrio (frmManutencao linha 217), limpa

o campo ID (linha 218) e exibe o formulrio para consulta e excluso de dados
(frmManutencao).
As linhas de 222 226 tratam o evento de clique no boto Voltar
(btnVoltaCadAlt) da janela onde ser feito cadastro e alterao de dados
(frmCadastrarAlterar). Veja que este mtodo torna o formulrio de menu ativo
e visvel (linha 223), chama o mtodo limparCampos, para limpar os campos
dos formulrios (veja o mtodo limparCampos das linhas 445 463) e esconde
o formulrio para cadastro e alterao de dados (linha 230).
As linhas de 228 231 referem-se ao boto Voltar do formulrio de consulta

e excluso de dados (frmManutencao). Ao clicar nesse boto, a janela ativa
ficar oculta e a janela do menu ser visualizada.
As linhas de 233 235 referem-se ao boto Sair do menu principal. Ao clicar
nesse boto, a aplicao ser finalizada (linha 234).
As linhas de 237 275 referem-se ao boto Salvar, pressionado no formulrio
para cadastro. As linhas de 241 251 capturam os valores incluidos nos campos
do formulrio e armazena em variveis. Note, nas linhas de 244 250, que o
texto da opo selecionada para sexo armazenada na varivel sexo. Isso
feito verificando qual opo foi selecionada. Na linha 251 a renda digitada
capturada. Como a renda pode ter sido digitada com vrgula para separar as
casas decimais, a vrgula trocada por ponto, j que o tipo double usa ponto
no lugar da vrgula.
A linha 252 chama o mtodo conectar, escrito da linha 437 linha 445. Este
mtodo retorna uma conexo com o banco de dados, ou nulo (null), caso a
conexo no tenha ocorrido. Se a conexo com o banco de dados no ocorreu
(linha 252), a mensagem da linha 253 ser exibida. Seno, se a conexo
ocorreu (linha 254), as linhas de 255 273 so executadas. Na linha 256 uma
instruo SQL insert preparada, aguardando como parmetro os dados que
sero inseridos. Estes dados parmetros so passados das linhas 257 261,
completando a instruo insert, que executada na linha 262. Em seguida, na
linha 263 exibida uma mensagem avisando que os dados foram inseridos
na tabela e os campos do formulrio so limpos por meio de uma chamada
ao mtodo limparCampos (linha 264). As instrues que limpam os campos
esto nas linhas de 455 463.
Observe o intervalo de linhas de 266 271, dentro do bloco catch que
executado se houve algum problema na execuo do comando insert. Na linha
266 verificado se o cdigo do erro gerado 1062. Este cdigo refere-se
tentativa de cadastrar um valor no campo chave primria, que j foi cadastrado
anteriormente, ou seja, tentativa de cadastrar um cliente com id que j foi
cadastrado. Neste caso, ser exibida a mensagem da linha 267 e o campo ID
receber o foco do cursor (linha 268). Se o erro no for o de nmero 1062, a

mensagem da linha 270 ser exibida.
Aps a operao ter sido realizada, a linha 273 chama o mtodo desconectar,
escrito das linhas 447 453. Este mtodo fecha a conexo com o banco de dados.
As linhas de 277 304 referem-se ao boto Buscar, pressionado no

formulrio para consulta e excluso. Se a conexo com o banco de dados no
foi estabelecida (linha 279), a mensagem de erro da linha 280 mostrada.
Seno, se a conexo foi estabelecida com sucesso (linha 281), as linhas de
282 297 so executadas.
Se o campo ID estiver vazio (linha 282), a mensagem pedindo o preenchimento
do campo ser exibida (linha 283) e o cursor ser posicionado no campo ID
(linha 284). Seno, se o campo ID tiver um valor de ID vlido (linha 285), este
valor capturado e armazenado na varivel id (linha 286).
A linha 287 prepara uma instruo SQL select aguardando o id como parmetro.
Este id passado para a instruo na linha 288. Na linha 289 a tabela que exibir
os dados limpa e a instruo select executada na linha 290. O resultado
retornado da tabela do banco de dados armazenado no objeto rs da interface
ResultSet (linha 290). Se este objeto recebeu um registro (linha 291), ele
carregado na tabela da parte inferior da janela (linhas 292 e 293). Seno, uma
mensagem ser exibida informando que o cliente no foi encontrado.
Caso tenha ocorrido algum erro na execuo da instruo select, a linha 300
ser executada e a mansegem da linha 301 ser exibida na tela.
As linhas de 306 333 so referentes ao boto Exibir Tudo do formulrio
para consulta e excluso de dados. Ao clicar nesse boto, todos os registros
cadastrados na tabela do banco de dados sero exibidos em uma tabela na parte
inferior da janela. Veja que a programao deste boto muito semelhante
programao do boto Buscar. Quando a conexo com o banco de dados
estabelecida (linha 310), uma instruo select preparada (linha 311) e
executada (linha 312). Em seguida, da linha 314 317, um lao de repetio
percorre o objeto rs da interface ResultSet, que contm os dados, carregando
cada registro em uma linha da tabela que fica na parte inferior da janela.
As linhas de 325 355 so referentes ao boto Excluir do formulrio de
consulta e excluso de dados. Ao clicar nesse boto, uma caixa de dilogo
pergunta se o usurio realmente deseja excluir o registro cujo ID foi informado
no campo ID. Se o usurio confirmar, o registro ser excludo.
A programao deste boto semelhante programao dos demais botes.
Quando a conexo com o banco de dados estabelecida, as linhas de 330
348 so executadas. A linha 330 verifica se o campo ID est vazio e mostra
uma mensagem pedindo seu preenchimento, caso esteja. Se o campo ID no
estiver vazio, a linha 334 abre uma caixa de dilogo pedindo a confirmao da
excluso. Se o usurio clicar na opo Sim desta caixa de dilogo (linha 335),
o ID digitado no campo ID capturado (linha 336), uma instruo SQL delete
preparada (linha 337) e o id passado como parmetro para esta instruo
(linha 338). A linha 339 executa a instruo delete e guarda o retorno desta
execuo em uma varivel. Se o retorno for 1, ou seja, se a excluso ocorreu
com sucesso (linha 340), ser mostrada uma mensagem avisando que o registro
foi excludo (linha 341). Em seguida, a tabela que est na parte inferior da
janela limpa, assim como o campo ID (linha 343), e o cursor posicionado
neste campo (linha 344). Se a excluso no ocorreu (linha 345), ser mostrada
a mensagem da linha 346. Em seguida, a conexo com o banco de dados
encerrada (linha 348). Se houve alguma exceo na execuo da instruo
delete (linha 352), ser mostrada a mensagem da linha 353.
As linhas de 357 396 so referentes ao boto Alterar do formulrio de
consulta e excluso. Quando este boto pressionado, os dados do cliente
cujo ID est no campo ID desta janela so carregados no formulrio para
cadastro e alterao, para serem alterados. Basicamente este trecho executa
uma consulta na tabela do banco de dados, como o boto Buscar, j explicado
anteriormente. A diferena que os dados retornados nesta consulta so
carregados na janela para cadastro e alterao (linhas de 371 381). Quando
os dados consultados so carregados no formulrio, todos os campos podero
ser editados, exceto o campo ID, pois ele chave primria da tabela do banco
de dados e no poder ser modificado nesta operao. Isso mostrado na
linha 372. Note tambm na linha 381 que a renda obtida da tabela do banco
de dados vem com ponto para separar as casas decimais. Quando esta renda
carregada no campo renda do formulrio (linha 381), o ponto trocado por
vrgula, exibindo o valor com a vrgula separando as casas decimais. Aps os
dados consultados serem carregados nos campos do formulrio, o boto Salvar
Alterao exibido (linha 383), o formulrio ativo de consulta e excluso
escondido (linha 385) e o formulrio com os dados a serem alterados mostrado
(linha 386). Veja que na programao deste boto (Alterar) a conexo com
o banco de dados no foi fechada, pois isto ser feito apenas depois que os
dados forem alterados e salvos novamente no banco de dados, por meio do
boto Salvar Alterao.
As linhas de 398 434 so referentes ao boto Salvar Alterao, do formulrio
que exibe os dados para alterao. Aps os dados terem sido modificados neste
formulrio, esse boto permite atualizar o registro na tabela do banco de dados,
executando a instruo update da linguagem SQL.
Note que na programao deste boto no foi feita conexo com o banco de
dados, pois a conexo j foi aberta quando os dados foram carregados no
formulrio por meio do pressionamento do boto Alterar. Observe que os
dados do formulrio so capturados e armazenados em variveis (linhas de

402 412). Em seguida uma instruo SQL update preparada na linha 414
e os dados das variveis que contm os valores dos campos do formulrio so
passados como parmetro para esta instruo (linhas 415 419). A linha 420
executa a instruo update atualizando o registro na tabela do banco de dados.
Agora sim, o banco de dados fechado na linha 426.
Nas linhas de 436 463 esto os mtodos conectar, desconectar e
limparCampos, chamados durante a programao dos eventos dos botes.
As instrues contidas nestes mtodos no so novas e j foram vistas em
exemplos anteriores. As linhas de 465 469 so do mtodo main, que inicia
a janela principal da aplicao quando o projeto compilado e executado.
Compile e execute o projeto por meio do pressionamento da tecla F6 para

testar a aplicao.
7.5 O padro Data Access Object (DAO)

O design pattern (padro de projeto) Data Access Object (DAO) um padro que
recomenda que todas as operaes de acesso a banco de dados sejam separadas em
uma classe que chamamos de classe DAO. Os mtodos para conectar/desconectar
do banco de dados e para executar incluso, excluso, consulta e alteraes, devem
ser colocados nesta classe, em mtodos especficos para cada uma destas operaes.
Isso permite separar as operaes de acesso a dados da interface do usurio das
classes que implementam as regras de negcio.
Em aplicaes que utilizam duas, trs ou mais camadas, a classe DAO
representada na camada de Persistncia, tambm chamada de camada de
Dados ou de Modelo.
No que se refere arquitetura de aplicaes, o modelo de camadas mais
utilizado o modelo de trs camadas. Neste modelo, as classes que geram as
janelas criadas utilizando as APIs swing e awt so representadas na camada
de Apresentao, e a classe DAO, na camada de Persistncia. Entre estas
camadas, so criadas classes que implementam as regras de negcio, em uma
camada chamada de camada de Negcio. Regras de negcio so operaes
especficas de uma empresa ou negcio em particular. Por exemplo, clculos
de saldo bancrio e verificaes de saldo, clculo e verificao de notas de
alunos, clculos e operaes de impostos etc.
Nos tpicos a seguir ser criada uma nova aplicao apenas com a operao
de cadastro, utilizando o padro DAO.
7.6 Criando uma aplicao de cadastro com duas

camadas
Neste tpico vamos criar uma pequena aplicao com duas camadas: camada
de Apresentao (view) e camada de Persistncia (persistence). No criaremos
a camada de Negcio porque a aplicao muito simples e no ter nenhuma
regra de negcio para ser implementada.
Para iniciar, crie um projeto chamado ProjetoCamadas, uma classe principal

chamada TelaCliente.java em um pacote chamado view, e duas classes em um
pacote chamado persistence: Cliente.java e ClienteDao.java.
No esquea de adicionar o driver JDBC na biblioteca do projeto. Para isso,
clique com o boto direito do mouse na pasta Bibliotecas e selecione a opo
Adicionar Biblioteca. Na janela que aparece, selecione Driver JDBC do
MySQL e clique no boto Adicionar Biblioteca.
Ao terminar, o projeto dever estar como mostra a Figura 7.49.
Figura 7.49: Projeto usando o padro DAO.
Note que os pacotes view e persistence simbolizam as camadas de Apresentao

e de Persistncia.
A relao de dependncia entre as trs classes que sero desenvolvidas
apresentada no diagrama de classes mostrado na Figura 7.50.
Figura 7.50: Diagrama de classes - relaes entre as classes da aplicao.
Note que os mtodos de acesso ao banco de dados esto concentrados na classe

ClienteDao.java.
A classe Cliente.java representa o modelo da tabela cliente do banco de dados,
por isso, seus atributos tm relao direta com os campos da tabela. Os dados
cadastrados nos campos da janela (formulrio), criada pela classe TelaCliente.
java, sero encapsulados em um objeto da classe Cliente.java e este objeto
ser enviado ao mtodo salvar da classe ClienteDao.java para ser inserido na
tabela do banco de dados.
7.6.1 A classe DAO

A classe DAO concentra os mtodos de acesso a banco de dados. Estes mtodos
sero chamados do interior do mtodo actionPerformed da classe TelaCliente.
java, onde so tratados os eventos de clique nos botes.
A seguir apresentado o cdigo-fonte da classe ClienteDao.java:
1
2
3
4
5
6
package persistence;
import java.sql.*;
public class ClienteDao {
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
String url = "jdbc:mysql://localhost:3306/bd002";

String usuario = "root";
String senha = "";
Connection con;
PreparedStatement st;
public int conectar() {

try {
con = DriverManager.getConnection(url, usuario, senha);
return 1;
return 2;
return 3;
}
}
public int salvar(Cliente cli) {
try {
st = con.prepareStatement("insert into cliente (id, nome, telefone,
sexo, renda) values (?, ?, ?, ?, ?)");
st.setInt(1, cli.getId());
st.setString(2, cli.getNome());
st.setString(3, cli.getTelefone());
st.setString(4, cli.getSexo());
st.setDouble(5, cli.getRenda());
int retorno = st.executeUpdate();
return retorno;
int c = ex.getErrorCode();
if (c == 1062) {
return 2;
} else {
return 3;
}
}
}
public int desconectar() {
try {
con.close();
return 1;
51
52
53
54
55

return 0;
}
Observe na linha 2 a indicao de que esta classe est no pacote persistence.

Na linha 3, todas as classes e interfaces do pacote java.sql so importadas.
Isso inclui as classes DriverManager e SQLException e as interfaces
PreparedStatement e Connection.
As linhas 7, 8 e 9 criam variveis que armazenam os parmetros que sero
utilizados na conexo com o banco de dados. Estes parmetros so passados ao
mtodo getConnection da classe DriverManager na linha 17 para estabelecer
a conexo com o banco de dados.
As linhas de 14 24 compem o mtodo conectar, que faz a conexo com o
banco de dados e retornar o valor inteiro 1 (se a conexo foi estabelecida
linha 18), 2 (se a classe do driver no estiver na biblioteca do projeto linha
20) ou 3 (se os parmetros de conexo estiverem incorretos linha 22).
As linhas de 26 45 compem o mtodo salvar. Veja que este mtodo recebe
um objeto da classe Cliente.java como parmetro, contendo encapsulados os
dados digitados nos campos do formulrio. Se este mtodo realizar a incluso
dos dados na tabela do banco de dados corretamente, ele devolver o valor
inteiro 1 (linha 35). Se a incluso no for realizada porque o id que est sendo
inserido (que chave primria na tabela) j estiver cadastrado, este mtodo
retornar o valor 2 (linha 39). Se der qualquer outro erro na execuo do
comando insert, este mtodo retornar o valor 3 (linha 41). Note na linha 28
que uma instruo insert preparada aguardando como parmetro os dados a
serem inseridos. As linhas de 29 33 passam os parmetros instruo insert.
Observe que como os valores a serem inseridos esto no objeto cli da classe
Cliente.java, foi necessrio retirar estes valores do objeto por meio dos metodos
getter. Assim, por exemplo, na linha 29, obteve-se o id contido no objeto cli
por meio da instruo cli.getId() e esse valor foi passado como parmetro para
o mtodo setInt da interface PreparedStatement, como parmetro de nmero
(ndice) 1. Note que o mesmo tipo de operao ocorre nas linhas de 31 33.
A linha 34 executa o comando insert preparado e recebe da tabela do banco
de dados o retorno da operao. Este retorno ser 1 se a operao for realizada
com sucesso, ou 0, se a operao no teve sucesso. O retorno de uma operao
realizada pelo mtodo executeUpdate sempre o nmero de linhas da tabela
que foram afetadas pela operao. Seja qual for o valor retornado na operao,
ele retornado a quem chamar o mtodo salvar, na linha 35.
Se ocorrer algum problema na execuo da instruo SQL insert, um objeto ex

da classe SQLException recebido como parmetro na instruo catch da linha
36. Por meio do objeto se obtm o nmero do erro na linha 37. Se o nmero
do erro for 1062, que indica tentativa de duplicao de valor no campo chave
primria da tabela, retornado o valor 2, seno, se houver qualquer outro erro
na execuo da instruo insert, retornado o valor 3 (linha 41).
A comparao da linha 38 tem o objetivo de identificar se voc est tentando

cadastrar um nmero de id que j est cadastrado. Isso necessrio quando o valor
do campo chave primria inserido pelo usurio na aplicao. Uma alternativa
para evitar esse tipo de problema usar o id como auto numerao, de forma que
ele seja incrementado automaticamente sem a interveno do usurio.
As linhas de 47 54 compem o mtodo desconectar. Veja que a linha que
desconecta do banco de dados a 49. Est linha deve estar dentro de uma
estrutura de tratamento de exceo try...catch, pois voc pode, por engano,
tentar fechar uma conexo que nunca foi estabelecida. Nesse caso, geraria
uma exceo do tipo SQLException. Se a conexo for fechada com sucesso,
este mtodo retornar 1, seno, retornar 0.
7.6.2 A classe modelo da tabela do banco de dados

A classe Cliente.java um modelo da tabela do banco de dados. Ela ter como
atributo o que campo na tabela, respeitando, inclusive, os mesmos tipos
de dados. Este tipo de classe tambm chamada de classe bean ou POJO
(Plain Old Java Objects). Basicamente so classes que possuem atributos, um
construtor e mtodos setter e getter para os atributos.
Nesta aplicao de cadastro voc ver como este tipo de classe, estudada no
Captulo 3, utilizada com janelas e acesso a banco de dados. Basicamente os
dados cadastrados em um formulrio que est em uma janela so encapsulados
em um objeto desta classe para serem transportados para mtodos de outras
classes ou para o banco de dados. Isto essencial na orientao a objetos,
transportar dados encapsulados em objetos.
Veja a seguir o cdigo-fonte da classe Cliente.java:
1
2
3
4
5
6
7
public class Cliente {
private int id;
private String telefone;
private String sexo;
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
private double renda;

public Cliente() {
}
public Cliente(int id, String nome, String telefone, String sexo, double
renda) {
this.id = id;
this.nome = nome;
this.telefone = telefone;
this.sexo = sexo;
this.renda = renda;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
return nome;
}
this.nome = nome;
}
public String getTelefone() {
return telefone;
}
public void setTelefone(String telefone) {
this.telefone = telefone;
}
public String getSexo() {
return sexo;
}
public void setSexo(String sexo) {
this.sexo = sexo;
}
52
53
54
55
56
57
58
59
60
61
public double getRenda() {

return renda;
}
public void setRenda(double renda) {
this.renda = renda;
}
}
Note que esta classe possui dois construtores, um vazio (linhas 10 e 11) e um
que recebe os parmetros que sero guardados em atributos do objeto (linhas
de 13 19). Observe que para cada atributo definido um mtodo setter e um
mtodo getter equivalente.
7.6.3 A classe para gerao do formulrio de

cadastro
Para o usurio cadastrar os dados ser gerado um formulrio com os campos
necessrios. Utilizaremos a mesma tela j gerada em aplicaes anteriores,
para podermos focar a explicao apenas no que representa alguma novidade.
A tela que ser gerada mostrada na Figura 7.51.
Figura 7.51: Tela de cadastro da aplicao utilizando o padro DAO.
A classe que gera a janela mostrada na Figura 7.51 a classe TelaCliente.java,

cujo cdigo-fonte apresentado a seguir:
1
2
3
4
package view;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
import java.text.DecimalFormat;
import javax.swing.text.DefaultFormatterFactory;
import javax.swing.text.NumberFormatter;
import persistence.Cliente;
import persistence.ClienteDao;
public class TelaCliente extends JFrame implements ActionListener {
JButton btnSalvar;
JLabel lblId, lblNome, lblTelefone, lblSexo, lblRenda;
JTextField txtNome;
JFormattedTextField txtTelefone, txtId, txtRenda;
MaskFormatter mskTelefone, mskId;
ButtonGroup gruSexo;
JRadioButton rdoMasculino, rdoFeminino;
public TelaCliente() {
setTitle("Cadastro");
setLayout(null);
setBounds(400, 200, 600, 280);
add(lblId);
txtId = new JFormattedTextField();
txtId.setBounds(10, 40, 150, 30);
add(txtId);
lblNome.setBounds(170, 10, 50, 30);
add(lblNome);
txtNome.setBounds(170, 40, 400, 30);
add(txtNome);
lblTelefone = new JLabel("Telefone:");
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
lblTelefone.setBounds(10, 80, 150, 30);

add(lblTelefone);
try {
}
txtTelefone.setBounds(10, 110, 100, 30);
add(txtTelefone);
lblSexo = new JLabel("Sexo:");
lblSexo.setBounds(170, 80, 150, 30);
add(lblSexo);
rdoMasculino.setBounds(170, 110, 100, 30);
rdoFeminino.setBounds(300, 110, 100, 30);
gruSexo = new ButtonGroup();
add(rdoMasculino);
add(rdoFeminino);
lblRenda.setBounds(450, 80, 150, 30);
add(lblRenda);
txtRenda = new JFormattedTextField();
txtRenda.setFormatterFactory(new DefaultFormatterFactory(new
NumberFormatter(new DecimalFormat("#0.00"))));
txtRenda.setBounds(450, 110, 100, 30);
txtRenda.setToolTipText("Utilize vrgula para separar as casas
decimais");
add(txtRenda);
81
82
83
84
85
86
87
88
89
90
91

btnSalvar.setBounds(10, 170, 150, 30);
btnSalvar.addActionListener(this);
add(btnSalvar);
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
TelaCliente tela = new TelaCliente();

}
@Override
String mensagem;
if (e.getSource() == btnSalvar) {
int id;
double renda;
} else {
sexo = "";
}
Cliente cli = new Cliente(id, nome, telefone, sexo, renda);
ClienteDao dao = new ClienteDao();
int r = dao.conectar();
if (r == 2) {
mensagem = "Driver de conexo no foi encontrado";
} else if (r == 3) {
mensagem = "Os dados de conexo com o banco de dados
esto incorretos";
} else {
int x = dao.salvar(cli);
if (x == 1) {
mensagem = "Dados gravados com sucesso";
limparCampos();
} else if (x == 2) {
mensagem = "Voc est tentando cadastrar um ID que j
existe";
} else {
mensagem = "Dados gravados com sucesso";
}
dao.desconectar();
}
JOptionPane.showMessageDialog(null, mensagem);
135
136
137
138
139
140
141
142
143
144
145
146
private void limparCampos() {

txtId.setText("");
txtNome.setText("");
txtTelefone.setText("");
gruSexo.clearSelection();
txtRenda.setText("");
}
Observe que a janela e seus componentes so gerados no construtor da classe,

que vai da linha 24 linha 89.
Alm dos campos, haver no formulrio apenas o boto Salvar, criado das
linhas 85 88. Note que a este boto foi adicionado um Listener (ouvinte)
para que quando ele for clicado seja executado o mtodo actionPerformed da
linha 98. Neste mtodo, o objeto e do tipo ActionEvent permitir identificar a
origem do clique por meio do mtodo getSource. Se houve um clique no boto
Salvar (btnSalvar linha 100), a operao de gravao ser executada (das
linhas 101 135).
As linhas de 104 114 capturam os valores inseridos nos campos do formulrio
e guardam em variveis. Em seguida, na linha 115, estes dados so armazenados
(encapsulados) no objeto cli da classe Cliente.java.
A linha 116 instancia um objeto da classe ClienteDao.java para que seja
possvel chamar o mtodo conectar desta classe por meio deste objeto (linha
117). Na chamada ao mtodo conectar (linha 117) retornado o valor inteiro
1 (se a conexo foi estabelecida), 2 (se a classe do driver no estiver na
biblioteca do projeto) ou 3 (se os parmetros de conexo estiverem incorretos).
Se o retorno foi 2 (linha 118), a mensagem da linha 119 armazenada na
varivel mensagem. Se o retorno foi 3 (linha 120), a mensagem da linha 121
armazenada na varivel mensagem. Se o retorno foi 1 (linha 122), executa
as linhas de 123 132, que realizam a operao de cadastro.
A linha 123 chama o mtodo salvar da classe ClienteDao.java e passa como
parmetro o objeto da classe Cliente.java que contm os dados cadastrados no
formulrio. O mtodo salvar, aps ser executado, retornar 1 (se a operao de
cadastro for realizada com sucesso), 2 (se o id j existe cadastrado na tabela
do banco de dados) ou 3 (se ocorreu qualquer outro erro na incluso dos
dados na tabela do banco de dados). Se o retorno foi 1 (linha 124), armazena a
mensagem da linha 125 na varivel mensagem e limpa os campos por meio de
uma chamada ao mtodo limparCampos (linha 126). Se o retorno foi 2 (linha

127), armazena a mensagem da linha 128 na varivel mensagem. Se o retorno
for 3 (linha 129), armazena a mensagem da linha 130 na varivel mensagem.
A linha 132 chama o mtodo desconectar da classe ClienteDao.java, que
encerra a conexo com o banco de dados.
A linha 134 exibe a mensagem que foi armazenada anteriormente na varivel
mensagem.
As linhas de 138 145 compem o mtodo limparCampos que limpa os campos

e posiciona o cursor no campo ID para um novo cadastro.
DICA
Quando voc precisa exibir apenas uma dentre muitas mensagens que so
geradas em uma estrutura de seleo (if..else if..else), crie uma varivel para
receber a mensagem e exiba o contedo desta varivel somente aps sair
da estrutura de seleo. Isto diminui a execuo de comandos de exibio
e pode melhorar a performance da aplicao.
Agora que voc terminou de digitar o cdigo-fonte das classes da aplicao,

compile e execute o projeto por meio do pressionamento da tecla F6 e cadastre
alguns clientes.
7.6.4 Outras operaes na classe DAO

A classe ClienteDao.java que desenvolvemos na aplicao apresentada
anteriormente tinha apenas os mtodos conectar, desconectar e salvar, pois a
aplicao realizava apenas a operao de cadastro.
Se a aplicao realizar outras operaes como alterao, consulta e excluso,
ser necessrio adicionar mtodos para realizar estas operaes na classe DAO
e chamar estes mtodos quando os botes referentes a estas funcionalidades
forem clicados na interface do usurio.
No vamos desenvolver neste livro estas funcionalidades, mas ser apresentada
a seguir a classe ClienteDao.java com os mtodos que executam as principais
operaes na tabela do banco de dados. Voc poder, a partir desta classe,
implementar as demais funcionalidades na classe TelaCliente.java.
O cdigo-fonte a seguir apresenta a classe ClienteDao.java com mtodos
para conectar ao banco de dados, salvar um cliente, consultar um cliente,
consultar todos os clientes, excluir um cliente e alterar os dados de um
cliente.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
import java.sql.*;
import java.util.ArrayList;
public class ClienteDao {
private String url = "jdbc:mysql://localhost:3306/bd002";
private String usuario = "root";
private String senha = "";
private Connection con;
private PreparedStatement st;
private ResultSet rs;
//Mtodo para conectar ao banco de dados
try {
con = DriverManager.getConnection(url, usuario, senha);
return 1;
return 2;
return 3;
}
}
//Mtodo para salvar os dados de um cliente
public int salvar(Cliente cli) {
try {
st = con.prepareStatement("insert into cliente (id, nome, telefone,
sexo, renda) values (?, ?, ?, ?, ?)");
int retorno = st.executeUpdate();
return retorno;
int c = ex.getErrorCode();
if (c == 1062) {
return 2;
} else {
return 3;
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
//Mtodo para consultar apenas um cliente cujo id foi informado

public Cliente buscar(int id) {
try {
st = con.prepareStatement("select * from cliente where id = ? ");
st.setInt(1, id);
if (rs.next()) {
cli.setId(rs.getInt("id"));
cli.setNome(rs.getString("nome"));
cli.setTelefone(rs.getString("telefone"));
cli.setSexo(rs.getString("sexo"));
cli.setRenda(rs.getDouble("renda"));
return cli;
} else {
return null;
}
return null;
}
}
//Mtodo para buscar todos os registros cadastrados
public ArrayList buscarTudo() {
ArrayList<Cliente> listaClientes = new ArrayList<>();
try {
st = con.prepareStatement("select * from cliente");
while (rs.next()) {
cli.setId(rs.getInt("id"));
cli.setNome(rs.getString("nome"));
cli.setTelefone(rs.getString("telefone"));
cli.setSexo(rs.getString("sexo"));
cli.setRenda(rs.getDouble("renda"));
listaClientes.add(cli);
}
return listaClientes;
return null;
}
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
104
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
}
//Mtodo para excluir um registro cujo id foi informado
public int excluir(int id) {
try {
st = con.prepareStatement("delete from cliente where id = ? ");
st.setInt(1, id);
return r;
return 0;
}
}
// Mtodo para alterar o registro cujo id foi informado
public int salvarAlteracao(Cliente cli) {
try {
st = con.prepareStatement("update cliente set nome=?, telefone=?,
sexo=?, renda=? where id=?");
return r;
return 0;
}
}
//Mtodo para se desconectar do banco de dados

public int desconectar() {
try {
con.close();
return 1;
return 0;
}
}
Como j foram explicados os mtodos conectar, desconectar e salvar no

exemplo anterior, as prximas linhas comentaro apenas os mtodos para
consultar, alterar e excluir dados.
O mtodo para consultar apenas um cliente apresentado das linhas 50 69.

Este mtodo recebe o id do cliente a ser consultado, realiza a busca na tabela
do banco de dados e armazena os dados retornados em um objeto da classe
Cliente.java. Em seguida, retorna este objeto com os dados a quem chamar
este mtodo de busca. Caso ocorra algum problema na consulta ou a consulta
no retorne nenhum cliente do banco de dados, ser retornado null a quem
chamar este mtodo de busca.
Observe da linha 72 90 o mtodo para buscar todos os clientes cadastrados no
banco de dados. Os dados retornados por meio da execuo da instruo select
so armazenados em um objeto da interface ResultSet (linha 76). Em seguida,
no lao de repetio das linhas de 77 85, estes dados do objeto da interface
ResultSet so encapsulados em objetos da classe Cliente.java e armazenados
em uma lista do tipo ArrayList. Ao final da execuo do lao voc ter uma
lista de objetos da classe Cliente.java com os dados retornados do banco de
dados. Esta lista ser retornada a quem chamar este mtodo.
O mtodo para realizar a excluso composto pelas linhas de 93 102. Este
mtodo executa uma instruo delete e retorna 1 se a operao ocorreu com
sucesso ou 0 se a operao falhou.
Das linhas 104 118 est o mtodo para alterar os dados de um cliente. Este
mtodo semelhante ao mtodo salvar, porm, executa uma instruo update
ao invs de uma instruo insert.
7.6.5 Criao de interface DAO

Se voc precisa criar uma aplicao que controle, por exemplo, produtos,
funcionrios e clientes, ter que construir uma classe ProdutoDao.java, uma
classe FuncionarioDao.java e uma classe ClienteDao.java. Normalmente ter
que construir uma classe DAO para cada tabela do banco de dados em que
voc executar operaes. Todas estas classes DAO tero que implementar
alguns mtodos comuns, porm, de maneiras diferentes. Estes mtodos so
salvar, consultar, alterar, excluir etc. Neste caso, indicada a criao de uma
interface DAO com a assinatura destes mtodos que sero implementados nas
respectivas classes DAO da aplicao. Veja essa representao no diagrama
de classes mostrado na Figura 7.52.
Figura 7.52: Diagrama de classes utilizando uma interface DAO na aplicao.
Observe que os mtodos assinados na interface so sobrescritos em todas as

classes que implementam as interfaces. Observe tambm que o mtodo salvar
recebe como parmetro um objeto genrico da classe Object que pode ser
um objeto da classe Cliente.java na classe ClienteDao.java; Produto.java na
classe ProdutoDao.java e Funcionario.java na classe FuncionarioDao.java.
Observe tambm que a classe FuncionarioDao.java possui um mtodo
que no est assinado na interface. Isso totalmente permitido. Alm dos
mtodos assinados na interface que tero implementao obrigatria na
classe, ela poder implementar quantos outros mtodos especficos forem
necessrios.
Observando o diagrama apresentado possvel concluir que a interface Dao.
java ter o seguinte cdigo-fonte:
public interface Dao {
public int salvar (Object obj);
public Object consultar(int id);
public int excluir(int id);
public int alterar(Object obj);
}
J as classes que implementam a interface Dao.java, por exemplo, a classe

ClienteDao.java, ter o seguinte cdigo-fonte:
public class ClienteDao implements Dao{
@Override
public int salvar(Object obj) {
//implementao do mtodo aqui
}
@Override
public Object consultar(int id) {
}
@Override
public int excluir(int id) {
}
@Override
public int alterar(Object obj) {
}
@Override
}
@Override
public void desconectar() {
}
Trabalhar com interfaces garante uma padronizao maior na aplicao e

facilita o entendimento, mas pode impor maior complexidade na programao.
Voc deve analisar quais recursos so relevantes e implement-los de forma a
reaproveitar o mximo de cdigo possvel, evitando repetio e de forma que
no comprometa a performance da aplicao.
7.7 Resumo
Para acessar bancos de dados em aplicaes Java existem dois padres que
determinam as regras para acesso de maneira eficiente: Open Database
Connectivity (ODBC) e Java Database Connectivity (JDBC). Para utilizar
estes padres, os fabricantes de SGBDs criam os drivers (que so bibliotecas

de classes) para seguir as regras impostas por esses padres.
ODBC uma interface genrica padro Microsoft Windows que permite a
ligao de aplicaes feitas em qualquer linguagem de programao com
qualquer banco de dados. J JDBC uma interface padro, independente de
plataforma, que permite a comunicao entre aplicaes baseadas em Java e
SGBDs.
Para que sua aplicao possa se conectar a um SGBD especfico necessrio

entrar no site do fabricante e baixar o driver JDBC. Este driver deve ser
adicionado pasta Bibliotecas do projeto criado com o NetBeans.
Quando voc deseja criar uma aplicao que acessa banco de dados, primeiro
deve entrar no SGBD e criar o banco de dados e as tabelas que pretente utilizar.
O NetBeans permite criar o banco de dados e as tabelas na sua prpria rea
de trabalho, na guia Servios, mas para isso o servidor de banco de dados
dever ter sido inicializado (startado).
Em uma aplicao que acessa banco de dados, voc ter que utilizar classe
e interfaces do pacote java.sql. Este pacote traz as interfaces Connection,
Statement, PreparedStatement e ResultSet, e as classes DriverManager e
SQLException.
A interface Connection estabelece e mantm uma conexo ativa com o banco
de dados.
As interfaces Statement ou PreparedStatement permitem executar comandos
SQL no banco de dados, como insert, select, delete e update. A diferena entre
estas duas interfaces que a interface PreparedStatement prepara uma instruo
SQL que pode receber parmetros posteriormente. J com a interface Statement,
a instruo SQL no poder receber parmetros. Por meio de mtodos assinados
nestas interfaces possvel utilizar os comandos SQL. O mtodo executeQuery
permite executar o comando select e o mtodo executeUpdate permite executar
os comandos insert, update e delete.
Objetos da interface ResultSet recebem o retorno das consultas realizadas na
tabela por meio do comando select.
Um objeto da classe SQLException instanciado quando uma exceo
relacionada a uma operao no banco de dados ocorre. Este objeto recebido
como parmetro na clusula catch de um tratamento de exceo iniciado
pela instruo try. Por meio deste objeto possvel obter informaes do
erro, como o nmero (mtodo getErrorCode), a mensagem de erro (mtodo
getErrorMessage) etc.
A classe DriverManager passa, por meio do mtodo getConnection, os

parmetros para realizar a conexo com o banco de dados, como o caminho,
a porta, o nome do banco de dados, o usurio e a senha, e gerencia o uso do
driver de conexo fornecido pelo fabricante do SGBD.
Para se conectar a qualquer SGBD bastar modificar apenas duas linhas na
aplicao:
"root", "teruel");
("jdbc:mysql://localhost:3306/bd002",
Bastar mudar os parmetros passados para o mtodo forName da classe Class

e getConnection da classe Drivermanager para se conectar a qualquer SGBD.
As aplicaes com acesso a banco de dados normalmente executam as
funcionalidades chamadas de CRUD (Create, Read, Update e Delete). Create
a funcionalidade de cadastro, executada pela instruo SQL insert. Read a
funcionalidade de consulta, executada pela instruo SQL select. Update a
funcionalidade de alterao, executada pela instruo SQL update. Delete a
funcionalidade de excluso, executada pela instruo SQL delete.
Apesar de voc poder realizar as operaes de acesso a banco de dados em
qualquer local da aplicao, comum separar essas operaes em uma classe
que chamamos de classe DAO.
O design pattern (padro de projeto) Data Access Object (DAO) um padro
que recomenda que todas as operaes de acesso a banco de dados sejam
separadas em classes DAO.
Em aplicaes que utilizam duas, trs ou mais camadas, a classe DAO
representada na camada de Persistncia, tambm chamada de camada de
Dados ou de Modelo.
Se voc precisar criar uma aplicao que necessita de muitas classes DAO e
elas precisem implementar um conjunto de mtodos com assinatura comum,
mas com implementao diferente, aconselhvel o uso de uma interface DAO
para centralizar a assinatura dos mtodos comuns.
7.8 Exerccios
Os exerccios presentes neste tpico so divididos em duas categorias: prticos e
conceituais. Os exerccios prticos precisam ser realizados em um computador com
ambiente de programao Java instalado e configurado. Os exerccios conceituais
cobram conceitos referentes aos temas abordados neste captulo.
1) Crie um projeto no NetBeans e implemente a aplicao mostrada no diagrama

de classes a seguir:
2) Implemente uma aplicao Java utilizando as APIs swing e awt para criar a
interface do usurio. Esta aplicao dever executar as operaes CRUD em
um banco de dados chamado BdProd com uma tabela produto contendo os
seguintes campos:
id int, not null, primary key
nomeProduto varchar (50)
marca varchar (30)
categoria varchar (30)
preco double precision

1) Qual a diferena entre os padres ODBC e JDBC?
2) O que muda em uma aplicao se voc quiser fazer a conexo com um
SGBD diferente do utilizado atualmente?
3) Qual a diferena entre as interfaces Statement e PreparedStatement? D

um exemplo.
4) O que driver e onde ele deve ser adicionado no projeto Java que acessa
banco de dados?
5) Quais mtodos das interfaces Statement e preparedStatement so utilizados
para executar as instrues SQL insert, update, delete e select?
6) Qual a finalidade de uma classe DAO?

7) Quando, em uma aplicao que possui diversos mdulos e diversas tabelas
no banco de dados, aconselhvel utilizar interfaces?
8) Que exceo (ou excees) pode gerar um mtodo que realiza conexo com
banco de dados?
9) Como pode ser verificado em uma operao de cadastro se o valor que est
sendo inserido na chave primria da tabela j foi cadastrado?
10) O que o mtodo executeUpdate das interfaces Statement e PreparedStatement
retorna? Para que pode ser utilizado este valor de retorno?
11) O que o mtodo executeQuery das interfaces Statement e PreparedStatement
retorna?
12) Como possvel percorrer o contedo de um objeto da interface ResultSet
at o seu final?
13) Quais so as principais classes e/ou interfaces contidas no pacote java.sql?
8. Recomendaes para
complementar a formao
em Java
Aps ler e praticar os contedos vistos at aqui neste livro, voc estar
pronto para aprofundar seus conhecimentos em Java estudando assuntos
mais complexos como Collections, Mapeamento Objeto-Relacional com
JPA e Hibernate, desenvolvimento de sites ou aplicaes distribudas com
Java EE (JSP, servlet, EJB, JSF etc.), desenvolvimento Java para celulares
e tablets que usam o sistema Android, design patterns (padres de projeto)
e frameworks. Poder ainda, se desejar, fazer provas para certificaes Java
reconhecidas internacionalmente. Este captulo apresenta uma introduo
sobre estes assuntos.
8.1 Collections
Agora que voc j conheceu e utilizou as diversas formas de manipulao
de dados com variveis simples, constantes, objetos, tipos primitivos e de
referncia, um bom caminho estudar um tipo de estrutura mais complexa
chamada de coleo (collection).
As colees (collections) em Java so estruturas de dados semelhantes as
arrays, porm, que manipulam dados como objetos, so dimensionadas
dinamicamente (ou seja, no tem tamanho pr-definido) e possuem um conjunto
de mtodos teis para manipular dados como listas, filas etc.
Da interface Collection descendem as interfaces Set(conjunto), Queue (filas)
e List (listas) que formam a base das colees genricas da linguagem Java,
como pode ser visto na Figura 8.1.
A interface Set define uma coleo que no contm valores duplicados;
Queue define uma coleo que representa uma fila no modelo FIFO (FirstIn, First-Out); e List define uma coleo ordenada que pode conter elementos
duplicados.
<<interface>>
Collection
<<interface>>
Set
<<interface>>
List
<<interface>>
Queue
<<interface>>
SortedSet
HashSet
LinkedHashSet
TreeSet
ArrayList
Vector
LinkedList
PriorityQueue
Figura 8.1: Hierarquia das colees em java.

Fonte: http://www.w3resource.com/java-tutorial/java-collections.php
Note que as classes concretas HashSet, LinkedHashSet e TreeSet implementam

a interface Set; ArrayList, Vector e LinkedList implementam a interface List; e
LinkedList e PriorityQueue implementam a interface Queue.
8.2 Mapeamento Objeto-Relacional

Executar operaes em banco de dados relacionais utilizando Java com
JDBC e controlando as operaes no cdigo-fonte uma tarefa difcil, pois
inclui o trabalho de gerenciar as conexes com o banco de dados e executar
operaes SQL de forma a manter a consistncia dos dados. Da forma mostrada
no Captulo 7 deste livro, um mtodo que recebe, por exemplo, um objeto
contendo dados em uma classe DAO, no pode envi-lo diretamente para a
tabela correspondente do banco de dados, tendo que retirar os valores contidos
no objeto, coloc-los em uma instruo INSERT da linguagem SQL e depois
enviar os dados atravs da execuo deste comando.
Para que o objeto possa ser enviado diretamente para a tabela correspondente
do banco de dados relacional, de forma que os atributos sejam mapeados
corretamente para os campos da tabela correspondente, Java possui uma API
chamada Java Persistence API (JPA). Para implementar JPA necessrio o uso de
um framework de persistncia como EclipseLink, Oracle TopLink ou Hibernate.
O uso mais comum de JPA com Hibernate. Utilizando estes recursos,
voc poder delegar o gerenciamento de conexes com o banco de dados,
assim como a execuo de operaes SQL ao JPA, focando seus esforos na
implementao das regras de negcio da aplicao ou em outros aspectos que
necessitam da ateno do desenvolvedor. JPA mapeia o envio de objetos da
aplicao para as tabelas e de registros das tabelas para objetos da aplicao,
reduzindo significativamente o esforo de programao.
8.3 Java EE
Hoje em dia, a maioria das aplicaes funcionam na web, o que torna
atrativo aprender Java EE. Com os recursos disponveis no Java EE voc
pode desenvolver sites e aplicaes corporativas distribudas, como aquelas
que disponibilizam um conjunto de recursos acessados de aplicaes web,
desktop e mobile, oferecendo uma interface adequada para cada uma. Dentre
os recursos mais importantes do Java EE que vale a pena estudar esto JSP,
servlet, JSTL, EJB e JSF. Para criar aplicaes Java EE voc vai precisar de
um servidor de aplicao como TomEE, Glasfish, JBoss, Weblogic, Tomcat
(apenas continer web) etc.
8.4 Padres de projeto

Outro assunto que voc no pode deixar de estudar so os padres de projeto
(design patterns).
Os padres de projeto so solues reutilizveis, pr-definidas e modeladas
para problemas comuns dentro de um determinado contexto (ou domnio) de
aplicao. O padro de projeto dita ou apresenta uma maneira de fazer algo
de forma j testada em que os resultados positivos j foram comprovados.
uma maneira de no ter que reinventar a roda.
Alguns dos principais padres de projeto foram apresentado em um livro escrito
por quatro autores conhecidos como a Gangue dos Quatro (Gang of Four
GoF). Eles apresentaram os padres de projetos divididos em trs grupos:
padres de criao, relacionados criao de objetos; padres estruturais, que
tratam das associaes entre classes e objetos; e padres comportamentais,
que tratam das interaes e divises de responsabilidades entre as classes ou
objetos. Os padres de cada grupo so apresentados a seguir:
Padres de criao:
Abstract Factory.
Builder.
Factory Method.
Prototype.
Singleton.
Padres estruturais:
Adapter.
Bridge.
Composite.
Decorator.
Faade.
Flyweight.
Proxy.
Padres
comportamentais:
Chain of Responsibility.
Command.
Interpreter.
Iterator.
Mediator.
Memento.
Observer.
State.
Strategy.
Template Method.
Visitor.
Alm destes padres apresentados pelo Gang of Four GoF, h diversos

outros padres de projeto disponveis, como Model-View-Controller (MVC),
o Data Access Object (DAO) etc.
O MVC um dos mais famosos padres de projeto para o desenvolvimento de
aplicaes web em trs camadas. Ele sugere o agrupamento dos componentes
da aplicao em Apresentao (View), Controle (Controller) e Modelo (Model).
No grupo View so representados os componentes que apresentam informaes
aos usurios, como pginas HTML, arquivos CSS, JavaScript e JSP. No grupo
Controller, so representadas as servlets Java que recebem as requisies dos
usurios, passam dados a componentes do grupo Model e devolvem dados
do Model aos usurios. No grupo Model so representadas as clesses bean
(ou JavaBean) que representam o modelo das tabelas do banco de dados, as
classes que implementam as regras de negcio e as classes de acesso a dados,
que executam operaes SQL no banco de dados.
DAO um padro para persistncia de dados que permite separar as regras de
negcio das regras de acesso ao banco de dados. Normalmente em aplicaes
que utiliza o padro MVC, todas as funcionalidades de bancos de dados, tais
como conexes, mapeamento de objetos para as tabelas do banco de dados
e execuo de comandos SQL so feitas utilizando classes no padro DAO.
8.5 Frameworks
Depois de entender o conceito de padro de projeto, ou design pattern, voc
deve estudar um pouco sobre os frameworks. Enquanto os design patterns
representam modelos de procedimentos que comprovadamente funcionam,
os frameworks trazem normalmente algo pronto, ou seja, pelo menos uma
parte dos cdigos necessrios para executar os procedimentos definidos em
algum padro de projeto. Alguns frameworks, principalmente voltados para o
desenvolvimento de aplicaes web, so listados a seguir:
Spring http://www.springsource.org/
EJB http://www.oracle.com/technetwork/java/javaee/ejb/index.html
Hibernate http://www.hibernate.org/
EJB http://www.oracle.com/technetwork/java/javaee/ejb/index.html
Struts http://struts.apache.org/
JSF http://www.oracle.com/technetwork/java/javaee/javaserverfaces-139869.html
Estes frameworks normalmente j vem integrados a IDEs como o NetBeans ou

Eclipse, porm, em alguns casos, precisaro ser baixados e integrados IDE.
8.6 Android e iOS

Java a linguagem de programao base para o desenvolvimento de aplicativos
para dispositivos mveis (celulares e tablets) que utilizam o Sistema
Operacional Android, baseado no ncleo do Sistema Operacional Linux. Se voc
quiser aproveitar este mercado, vale a pena dedicar um tempo para aprender a
usar o Java para programao voltada a dispositivos com Android.
Caso queira desenvolver para dispositivos da Apple que usam o Sistema
Operacional iOS, como iPhones e iPads, ter que aprender outra linguagem
com sintaxe bem diferente do Java, a Objective-C, e utilizar um ambiente de
desenvolvimento (IDE) chamada xCode.
8.7 Principais certificaes Java

Uma boa opo para conseguir espao no mercado de trabalho to concorrido,
fazer uma certificao Java reconhecida internacionalmente, principalmente
se voc no tem experincia comprovada em desenvolvimento Java.
As duas principais certificaes Java SE so OCAJP e OCPJP.
OCAJP Oracle Certified Associate Java SE Programmer (Programmer
I), cobra as bases do desenvolvimento Java. Trata-se de uma prova com 70
questes de mltipla escolha e o candidato ter 120 minutos para respond-la.
preciso acertar pouco mais de 60% das questes para passar nesta prova.
A prova inicia com temas bsicos sobre laos de repetio e declarao de
variveis, e segue at tpicos mais complexos, como arrays e excees. No
cobre tpicos especficos como criao de GUIs e programao para Internet.
OCPJP Oracle Certified Professional Java SE Programmer (Programmer II),
a prxima certificao, que cobra conhecimentos aprofundados do Java SE.
Esta prova cobra conhecimentos de construo de laos de repetio complexos,
Threads, Collections e Generics. No abrange domnios tecnolgicos
especficos, como a criao de programao GUI, web e distribuda. A prova
composta por 60 questes e o candidato tem 150 minutos para responder.
Para ser aprovado o candidato deve acertar pouco mais de 60% das questes.
Voc pode conhecer estas e outras certificaes disponveis no site da Oracle:
<https://education.oracle.com/pls/web_prod-plq-dad/db_pages.getpage
?page_id=632>
As provas esto disponveis em vrios idiomas, inclusive em portugus.
8.8 Resumo
As colees (collections) so estruturas de dados semelhantes s arrays,
que manipulam dados como objetos, so dimensionadas dinamicamente e
possuem um conjunto de mtodos teis para manipular dados como listas, filas
e conjunto. Da interface Collection descendem as interfaces Set (conjuntos),
Queue (filas) e List (listas), que formam a base das colees em Java.
Quando precisar fazer a comunicao de aplicao com o banco de dados,

voc pode utilizar a API JPA com o framework Hibernate para mapear objetos
para o banco de dados diretamente, sem ter necessariamente que utilizar
comandos SQL, e receber registros do banco de dados como objetos, sem ter
necessariamente que utilizar comandos de consulta SQL. A criao e execuo
dos comandos SQL pode ser deixada a cargo da JPA.
Para criar sites e aplicaes distribudas e multiplataforma, voc pode utilizar
recurso do Java EE como JSP, servlets, EJB, JSF, Struts etc. Estas aplicaes
necessitam de servidores, alguns deles integrados IDE, como Glassfish,
Tomcat entre outros.
Muitas das situaes e problemas encontrados no projeto e desenvolvimento
de software j foram resolvidos e as solues j foram testadas e tiveram a
eficincia comprovada. Estas solues foram desenhadas e documentadas em
padres de projeto, para evitar que novos desenvolvedores tenham os mesmos
problemas e as mesmas dificuldades para solucion-los. H um conjunto de
padres de projeto utilizados com frequncia no mercado que interessante o
desenvolvedor conhecer, como o MVC e DAO. Alm dos padres de projeto,
que apresentam modelos de solues, existem os frameworks, que apresentam
parte da soluo j desenvolvida, normalmente partes de cdigo j prontos
para facilitar a implementao dos design patterns. Alguns dos principais
frameworks so JSF, Hibernate, Struts e EJB.
Se desejar programar para celulares e tablets, ou voc utiliza o Java ME, ou
utiliza programao Java para dispositivos que utilizam o Sistema Operacional
Android. O desenvolvimento desse tipo de aplicao tem crescido muito devido
popularizao dos dispositivos mveis e do acesso sem fio Internet.
Uma boa opo para conseguir espao no mercado de trabalho to concorrido,
fazer uma certificao Java internacional, principalmente se voc no tem
experincia comprovada em desenvolvimento com Java. As duas certificaes
Java SE mais importantes hoje so OCAJP e OCPJP. A primeira aborda aspectos
mais bsicos e a segunda, conceitos mais avanados.
Referncias
CAELUM. Excees e controle de erros. Disponvel em: <http://www.caelum.com.
br/apostila-java-orientacao-objetos/excecoes-e-controle-de-erros>. Acesso em: 15
ago. 2014.
CODEJAVA. JComboBox basic tutorial and examples. Disponvel em: < http://www.
codejava.net/java-se/swing/jcombobox-basic-tutorial-and-examples>. Acesso em: 08
ago. 2014.
DEITEL, H.; DEITEL, P. Java: como programar. 8. ed. So Paulo: Pearson PrenticeHall, 2010.
HORSTMANN, Key. Conceitos de computao com Java. 5. ed. Porto Alegre:
Bookman, 2009.
Java Collection Framework. Disponvel em: <http://www.w3resource.
com/java-tutorial/java-collections.php>. Acesso em: 28 set. 2015.
TERUEL, Evandro Carlos. Arquitetura de sistemas para web com Java utilizando
design patterns e frameworks. Rio de Janeiro: Cincia Moderna, 2012.
O Gestor de Posicionamento GridBagLayout. Disponvel
em: <http://www.dei.isep.ipp.pt/~mouta/LPG2-Programas/progJavaGestPos/
GridBagLayout.htm>. Acesso em: 05 ago. 2014.
ORACLE Java Documentation. Trail: creating a GUI With JFC/Swing.
Disponvel em: <http://docs.oracle.com/javase/tutorial/uiswing/index.html>. Acesso
em: 05 ago. 2014.
Este livro apresenta de maneira prtica e simplificada a programao orientada a objetos utilizando Java.
Voc aprender a diferena entre a programao estruturada e orientada a objetos, as estruturas e comandos
fundamentais do Java, o s conceitos essenciais da
programao orientada a objetos (como encapsulamento, herana, polimorfismo, interfaces etc.), a criao de
interfaces g rficas para desktop, tratamento de excees e acesso a banco de dados utilizando a API Java
Database Connectivity (JDBC).
Cada captulo estruturado com uma i ntroduo,
apresentao dos contedos t ericos com exemplos,
resumo e lista de exerccios.
Um livro para se aprender, definitivamente, a
programao com Java.

Java Digital 1306 A

Caricato da

Informazioni sul documento

Titolo originale

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Java Digital 1306 A

Caricato da

Copyright:

Formati disponibili

UNINOVE uso exclusivo para aluno

UNINOVE uso exclusivo para aluno

Universidade Nove de Julho UNINOVE

UNINOVE uso exclusivo para aluno

Evandro Carlos Teruel

Todos os direitos reservados. A reproduo desta publicao, no todo ou em

UNINOVE uso exclusivo para aluno

Capa: Big Time Servios Editoriais

Catalogao na Publicao (CIP)

I. JAVA programao. II. Teruel, Evandro Carlos. III. Ttulo.

UNINOVE uso exclusivo para aluno

Torre Norte 27 andar

Requisitos de Hardware e Software

UNINOVE uso exclusivo para aluno

minha esposa Angela e aos meus filhos, Pedro Henrique e

Aos meus sogros Iracema e Jorge.

UNINOVE uso exclusivo para aluno

Aos meus pais, Jos e Aparecida, que mesmo longe me

Aos colegas gestores e professores da diretoria dos cursos de

Educa a criana no caminho em que

UNINOVE uso exclusivo para aluno

UNINOVE uso exclusivo para aluno

1. Preparando o ambiente para programar em Java........ 23

1.1 Plataformas Java............................................................................................ 23

2. Programao Estruturada em Java............................... 37

2.1 Paradigmas de programao....................................................................... 37

UNINOVE uso exclusivo para aluno

2.5 Estruturas de seleo utilizadas em Java.................................................... 54

3. Orientao a objetos conceitos bsicos..................... 73

3.7.1 Quando usar arrays de objetos................................................................. 109

UNINOVE uso exclusivo para aluno

4. Orientao a objetos conceitos avanados.........................115

5. Mtodos estticos e tratamento de excees.........................163

5.2.2 Tratamento de Excees com throws..................................................... 179

UNINOVE uso exclusivo para aluno

6. Criao de interface grfica.....................................................187

6.1 API swing....................................................................................................... 187

7. Acesso a banco de dados..........................................................303

UNINOVE uso exclusivo para aluno

7.3.2 Operao de cadastro................................................................................ 316

8. Recomendaes para complementar a formao em Java.379

UNINOVE uso exclusivo para aluno

Evandro Carlos Teruel - 15

UNINOVE uso exclusivo para aluno

Quando comecei a trabalhar com programao, em 1989, utilizando a

16 - Programao Orientada a Objetos com Java sem mistrios

Java, talvez a linguagem de programao orientada a objeto mais poderosa

UNINOVE uso exclusivo para aluno

Evandro Carlos Teruel - 17

UNINOVE uso exclusivo para aluno

Evandro Carlos Teruel formado em Tecnologia

UNINOVE uso exclusivo para aluno

Evandro Carlos Teruel - 19

UNINOVE uso exclusivo para aluno

Este livro apresenta de maneira prtica e simplificada a programao orientada

Contedo dos captulos:

Captulo 2 Programao Estruturada com Java

Captulo 3 Orientao a objetos conceitos bsicos

Captulo 4 Orientao a objetos conceitos avanados

20 - Programao Orientada a Objetos com Java sem mistrios

Captulo 5 Mtodos estticos e tratamento de excees

Captulo 6 Criao de interface grfica

UNINOVE uso exclusivo para aluno