APOSTILA - TÓPICOS ESPECIAIS DE PROGRAMAÇÃO ORIENTADA A OBJETOS

Prévia do material em texto

Autores: Prof. José Cassiano Grassi Gunji
 Prof. Salatiel Luz Marinho
 Prof. Luciano Soares de Souza
 
Tópicos Especiais de 
Programação Orientada a 
Objetos
Re
vi
sã
o:
 M
ac
ili
a/
Ro
se
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
1/
10
/1
5
Professores conteudistas: José Cassiano Grassi Gunji / Salatiel Luz Marinho / 
Luciano Soares de Souza
© Todos os direitos reservados. Nenhuma parte desta obra pode ser reproduzida ou transmitida por qualquer forma e/ou 
quaisquer meios (eletrônico, incluindo fotocópia e gravação) ou arquivada em qualquer sistema ou banco de dados sem 
permissão escrita da Universidade Paulista.
Dados Internacionais de Catalogação na Publicação (CIP)
G975t Gunji, José Cassiano Grassi. 
Tópicos especiais de programação orientada a objetos. / José 
Cassiano Grassi Gunji, Salatiel Luz Marinho, Luciano Soares de Souza. 
– São Paulo: Editora Sol, 2015.
128 p., il.
Nota: este volume está publicado nos Cadernos de Estudos e 
Pesquisas da UNIP, Série Didática, ano XXI, n. 2-167/15, ISSN 1517-9230.
11. Interfaces gráficas. 2. Linguagem JAVA. 3. Programação 
ANDROID. I. Marinho, Salatiel Luz. II. Souza, Luciano Soares de. II.Título.
CDU 681.3.062
José Cassiano Grassi Gunji
É mestre em Tecnologia da Informação Aplicada pelo 
Centro Estadual de Educação Tecnológica Paula Souza e 
bacharel em Sistemas de Informação pela Universidade 
Presbiteriana Mackenzie.
Atua como docente em cursos de graduação em 
Tecnologia da Informação, lecionando em disciplinas como 
Programação Orientada a Objetos em Diversas Linguagens, 
Análise de Sistemas, Lógica de Programação entre outras.
Salatiel Luz Marinho
Pós-graduado em Gestão de Projetos pelo Instituto 
Brasileiro de Tecnologia Avançada (IBTA) e formado em 
Engenharia da Computação pela Universidade Paulista 
(UNIP), trabalha há mais de dez anos no desenvolvimento de 
aplicações desktop e web, tendo prestado serviços a instituições 
financeiras, de varejo e de seguros e a instituições acadêmicas.
Leciona há mais de oito anos as disciplinas de 
programação orientada a objetos na UNIP.
Luciano Soares de Souza
Mestre em Engenharia de Produção pela Universidade 
Paulista (UNIP) e bacharel em Ciência da Computação pela 
mesma universidade.
É coordenador do Curso Superior de Tecnologia em 
Análise e Desenvolvimento de Sistemas da UNIP, nas 
modalidades presencial e EaD, leciona no curso as disciplinas 
Engenharia de Software, Projeto de Interface com o Usuário, 
Princípios de Sistemas de Informação entre outras, e orienta 
o Projeto Integrado Multidisciplinar – PIM.
Na Universidade Paulista também atua como Gerente 
de Integração de Sistemas. Possui mais de 20 anos de 
experiência com Tecnologia da Informação, atuando nas 
áreas de desenvolvimento de sistemas, engenharia de 
software, interação humano-computador e automação 
industrial. Como professor e coordenador possui mais de 
oito anos de experiência.
Re
vi
sã
o:
 M
ac
ili
a/
Ro
se
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
1/
10
/1
5
Prof. Dr. João Carlos Di Genio
Reitor
Prof. Fábio Romeu de Carvalho
Vice-Reitor de Planejamento, Administração e Finanças
Profa. Melânia Dalla Torre
Vice-Reitora de Unidades Universitárias
Prof. Dr. Yugo Okida
Vice-Reitor de Pós-Graduação e Pesquisa
Profa. Dra. Marília Ancona-Lopez
Vice-Reitora de Graduação
Unip Interativa – EaD
Profa. Elisabete Brihy 
Prof. Marcelo Souza
Prof. Dr. Luiz Felipe Scabar
Prof. Ivan Daliberto Frugoli
 Material Didático – EaD
 Comissão editorial: 
 Dra. Angélica L. Carlini (UNIP)
 Dra. Divane Alves da Silva (UNIP)
 Dr. Ivan Dias da Motta (CESUMAR)
 Dra. Kátia Mosorov Alonso (UFMT)
 Dra. Valéria de Carvalho (UNIP)
 Apoio:
 Profa. Cláudia Regina Baptista – EaD
 Profa. Betisa Malaman – Comissão de Qualificação e Avaliação de Cursos
 Projeto gráfico:
 Prof. Alexandre Ponzetto
 Revisão:
 Marcilia Brito
 Rose Castilho
 Virgínia Bilatto
Re
vi
sã
o:
 M
ac
ili
a/
Ro
se
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
1/
10
/1
5
Sumário
Tópicos Especiais de Programação 
Orientada a Objetos
APRESENTAÇÃO ......................................................................................................................................................9
INTRODUÇÃO ...........................................................................................................................................................9
Unidade I
1 INTRODUÇÃO AO JAVA ................................................................................................................................. 11
1.1 Um breve histórico .............................................................................................................................. 11
1.2 Arquitetura de um programa em Java ........................................................................................ 12
1.3 Características da linguagem Java ................................................................................................ 14
1.3.1 Simplicidade .............................................................................................................................................. 14
1.3.2 Orientação a objetos ............................................................................................................................. 14
1.3.3 Multithread ............................................................................................................................................... 14
1.3.4 Robustez ..................................................................................................................................................... 14
1.3.5 Segurança .................................................................................................................................................. 15
1.4 O que é necessário para se programar em Java ...................................................................... 15
1.4.1 Instalando o JDK Java SE ..................................................................................................................... 17
1.4.2 Instalando o Eclipse ............................................................................................................................... 18
2 A LINGUAGEM JAVA ...................................................................................................................................... 18
2.1 Entrada e saída de dados usando JOptionPane ....................................................................... 25
2.2 Recomendações de estilo .................................................................................................................. 29
2.3 Tipos primitivos ..................................................................................................................................... 30
2.4 Conversão de tipos .............................................................................................................................. 31
2.5 Classes wrapper (invólucro) ............................................................................................................. 34
2.6 Introdução a classes e objetos ........................................................................................................ 37
2.7 Instruções de controle ........................................................................................................................ 40
2.8 Arrays ........................................................................................................................................................ 47
2.9 Coleções ................................................................................................................................................... 49
2.10 Tratamento de exceções .................................................................................................................. 50
Unidade II
3 PROGRAMAÇÃO ORIENTADA A OBJETOS ..............................................................................................56
3.1 Sobrecarga .............................................................................................................................................. 56
3.2 Herança .................................................................................................................................................... 58
3.3 Sobrescrita ............................................................................................................................................... 59
Re
vi
sã
o:
 M
ac
ili
a/
Ro
se
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
1/
10
/1
5
3.4 Polimorfismo .......................................................................................................................................... 60
3.5 Modificadores de acesso ................................................................................................................... 62
3.6 Escopo ....................................................................................................................................................... 63
3.7 Classes abstratas e interfaces .......................................................................................................... 65
4 INTERFACES GRÁFICAS ................................................................................................................................. 70
Unidade III
5 INTRODUÇÃO AO ANDROID ........................................................................................................................ 79
5.1 Fundamentos e paradigmas de programação para dispositivos móveis ....................... 79
5.1.1 Dispositivos móveis ................................................................................................................................ 80
5.1.2 Desafios técnicos para dispositivos móveis ................................................................................. 80
5.1.3 Usabilidade e os dispositivos móveis .............................................................................................. 80
5.1.4 Aplicações móveis .................................................................................................................................. 81
5.2 Android ..................................................................................................................................................... 82
5.3 Open Handset Alliance ....................................................................................................................... 83
5.4 Versões do Android .............................................................................................................................. 84
5.5 Arquitetura do Android ...................................................................................................................... 85
5.5.1 Linux Kernel ............................................................................................................................................... 86
5.5.2 Libraries e Android Runtime ............................................................................................................... 87
5.5.3 Application Framework ........................................................................................................................ 88
5.5.4 Applications .............................................................................................................................................. 89
6 CONCEITOS FUNDAMENTAIS ...................................................................................................................... 89
6.1 Construindo o ambiente de desenvolvimento ......................................................................... 89
6.2 Instalando o Android Development Kit (Android SDK) ......................................................... 89
6.3 Instalando o Android Development Tools (ADT) ...................................................................... 90
Unidade IV
7 PROGRAMAÇÃO ANDROID ......................................................................................................................... 94
7.1 Criando um projeto do Android ..................................................................................................... 94
7.2 Executar o projeto ................................................................................................................................ 95
7.3 O arquivo AndroidManifest.xml ..................................................................................................... 98
7.4 Efetuando debug no aplicativo ....................................................................................................100
7.5 Activities.................................................................................................................................................100
7.6 Views........................................................................................................................................................101
7.7 Método setContentView() ...............................................................................................................101
7.8 Criar uma Activity ..............................................................................................................................101
8 INTERFACES GRÁFICAS ...............................................................................................................................104
8.1 TextView .................................................................................................................................................106
8.2 EditText ...................................................................................................................................................107
8.3 CheckBox ...............................................................................................................................................108
8.4 RadioButton .........................................................................................................................................110
Re
vi
sã
o:
 M
ac
ili
a/
Ro
se
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
1/
10
/1
5
8.5 ImageView .............................................................................................................................................110
8.6 Button .....................................................................................................................................................111
8.7 DatePicker .............................................................................................................................................112
8.8 TimePicker .............................................................................................................................................113
8.9 Layouts ...................................................................................................................................................114
8.9.1 Linear layout ...........................................................................................................................................114
8.9.2 Table layout .............................................................................................................................................115
8.10 Intent ....................................................................................................................................................116
8.11 Broadcast Receivers .........................................................................................................................117
8.12 Services ................................................................................................................................................117
8.13 Persistência de dados .....................................................................................................................119
9
Re
vi
sã
o:
 M
ac
ili
a/
Ro
se
 -
 D
ia
gram
aç
ão
: J
ef
fe
rs
on
 -
 2
1/
10
/1
5
APRESENTAÇÃO
Este livro tem como finalidade apresentar um roteiro de estudos com exemplos práticos, visando 
preparar o aluno para desenvolver programas de computador utilizando a tecnologia Java.
Todo o conteúdo desta obra foi desenvolvido de maneira a permitir que o aluno construa seu 
conhecimento a respeito da tecnologia Java de maneira gradativa. Por isso, para se entender as 
últimas partes do livro, o aluno deve ter passado por todas as partes anteriores, de modo a acumular 
conhecimento suficiente para compreender os assuntos desenvolvidos.
Não é necessário conhecimento anterior de Java para acompanhar essa obra. Entretanto, assume-se 
que o aluno já esteja familiarizado com os conceitos de Lógica de Programação, assim como de Análise 
de Sistemas Orientados a Objetos.
Inicialmente, veremos os conceitos relacionados à tecnologia de programação Java e como essa 
tecnologia se situa com relação às demais tecnologias em uso atualmente. Um pouco da história do 
desenvolvimento do Java também será apresentada.
Abordaremos de maneira prática a programação usando a linguagem Java. Faremos breves revisões 
sobre os conceitos da Lógica de Programação e Orientação a Objetos aplicadas ao Java.
Também serão apresentados os recursos do Java para o desenvolvimento de interfaces gráficas com 
o usuário.
Em seguida, serão apresentados os conceitos relacionados à computação móvel e ao ambiente de 
programação para dispositivos móveis que utilizam o sistema operacional Android.
Bons estudos!
INTRODUÇÃO
O conhecimento tecnológico dos homens propiciou a criação de diversos mecanismos capazes de 
realizar tarefas. Há séculos existem aparelhos mecânicos capazes de realizar tarefas dos mais diversos 
níveis de complexidade. Por exemplo, existiram teares capazes de tecer padrões complexos em tecidos 
de maneira automática, máquinas capazes de realizar cálculos matemáticos e até mesmo codificar e 
decodificar mensagens de rádio. A tecnologia desses mecanismos podia ser mecânica, elétrica e, mais 
recentemente, eletrônica. Algo que estes dispositivos tinham em comum era algum método pelo qual 
eles poderiam ser programados.
Com o desenvolvimento da tecnologia e com o surgimento dos computadores digitais, foram 
desenvolvidas linguagens de programação que poderiam ser interpretadas diretamente por esses 
computadores: as linguagens de máquina. Entretanto, linguagens de máquina são de difícil entendimento 
para pessoas e, por isso, logo começaram a ser desenvolvidas linguagens de alto nível.
10
Re
vi
sã
o:
 M
ac
ili
a/
Ro
se
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
1/
10
/1
5
Uma linguagem de alto nível é um código com o qual se pode expressar algoritmos usando um 
vocabulário e uma sintaxe semelhante ao vocabulário e sintaxe da linguagem humana (quase sempre 
em inglês). Esse código escrito em linguagem de alto nível pode ser, então, traduzido (compilado) para 
a linguagem de máquina do computador em que ele será executado.
É nesse contexto que surge a linguagem de programação Java. Seus desenvolvedores estipularam 
uma meta arrojada: criar uma linguagem de programação multiplataforma. Isso significa que um código 
de computador escrito em Java, depois de compilado, poderia ser executado por qualquer computador, 
executando qualquer sistema operacional que oferecesse suporte ao Java, sem a necessidade de 
recompilar o código-fonte. Como o Java realiza esta tarefa é o que veremos neste livro-texto. Também 
veremos como desenvolver aplicativos usando Java, tanto para computadores desktop quanto para 
dispositivos móveis que executem o sistema operacional Android.
11
Re
vi
sã
o:
 M
ac
ili
a/
Ro
se
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
1/
10
/1
5
TÓPICOS ESPECIAIS DE PROGRAMAÇÃO ORIENTADA A OBJETOS
Unidade I
1 INTRODUÇÃO AO JAVA
Os computadores modernos, independentemente da arquitetura ou fabricante, apenas conseguem 
executar programas escritos em sua própria linguagem de máquina. Uma linguagem de máquina é uma 
sequência de números escritos na base 16, também conhecida como números hexadecimais. Um trecho 
de um programa em linguagem de máquina apresenta a aparência da figura a seguir.
CD 20 FF 9F 00 9A F0 FE-1D F0 4F 03 F0 07 8A 03
F0 07 17 03 F0 07 DF 07-01 01 01 00 02 FF FF FF
FF FF FF FF FF FF FF FF-FF FF FF FF BD 0D 4C 01
D0 0C 14 00 18 00 3D 0E-FF FF FF FF 00 00 00 00
05 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00
CD 21 CB 00 00 00 00 00-00 00 00 00 00 20 20 20
20 20 20 20 20 20 20 20-00 00 00 00 00 20 20 20
20 20 20 20 20 20 20 20-00 00 00 00 00 00 00 00
00 0D 76 2E 65 78 65 0D-44 4F 57 53 5C 73 79 73
74 65 6D 33 32 5C 64 6F-73 78 0D 0D 64 61 20 72
65 64 65 20 28 63 61 72-72 65 67 61 72 20 61 6E
74 65 73 20 64 6F 20 64-6F 73 78 2E 65 78 65 29
Figura 1 – Exemplo de um código de computador em hexadecimal
Por razões óbvias, é muito difícil para um programador escrever um programa usando linguagem 
de máquina. Para resolver este problema, logo começaram a ser desenvolvidas diversas linguagens de 
computador de alto nível, ou seja, linguagens que permitem que se escreva algoritmos usando palavras 
com um vocabulário e uma sintaxe semelhante ao vocabulário e sintaxe da linguagem humana, sendo 
que quase todas usam a língua inglesa.
Muitas linguagens nunca atingiram grande aceitação. Outras chegaram a ser usadas com frequência, 
mas acabaram caindo em desuso. Hoje em dia há um punhado de linguagens que permanecem bastante 
populares. Alguns exemplos são o COBOL, o C++ e o C# (DEITEL; DEITEL, 2005; 2010). As linguagens de 
sucesso sempre apresentam algo que as diferencia das demais, trazendo alguma vantagem com relação 
às outras. O Java é um desses casos de sucesso. Vejamos a seguir como se deu o desenvolvimento do Java.
1.1 Um breve histórico
A história da criação do Java é descrita por diversos autores, como Horstmann e Cornell (2010), 
Deitel e Deitel (2005; 2010), Jorge (2004), entre outros.
12
Re
vi
sã
o:
 M
ac
ili
a/
Ro
se
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
1/
10
/1
5
Unidade I
A Sun Microsystems, em 1991, financiou um projeto de pesquisa corporativa interna com o codinome 
Green, que resultou no desenvolvimento de uma linguagem baseada em C++ que seu criador, James 
Gosling, chamou de Oak. Descobriu-se mais tarde que já havia uma linguagem de programação com 
este nome. Uma equipe da Sun, em uma visita a uma cafeteria local, que servia café cuja origem era da 
ilha de Java na Indonésia, sugeriu esse nome e ele acabou pegando.
O projeto passou por dificuldades e quase foi cancelado. Mas em 1993 a World Wide Web explodiu 
em popularidade e a equipe da Sun viu um grande potencial para utilizar o Java para adicionar conteúdo 
dinâmico, como interatividade e animações, às páginas da Web, o que deu nova vida ao projeto.
O Java foi anunciado formalmente em 1995, ganhando muito interesse da comunidade do World 
Wide Web. Atualmente, o Java é popular no desenvolvimento de software para diversos aplicativos, 
como aplicativos corporativos de grande porte, aplicativos governamentais, no aprimoramento da 
funcionalidade de servidores Web, assim como aplicativos para o consumo popular em microcomputadores 
pessoais e dispositivos móveis.
 Saiba mais
Está disponível (em inglês) uma linha do tempo detalhada do 
desenvolvimento do Java desde sua concepção até o momento atual:
<http://oracle.com.edgesuite.net/timeline/java/>.
1.2 Arquitetura de um programa em Java
Um dos aspectos mais marcantes do Java e que esteve presente desde sua concepção é o fato 
de essa linguagem ser multiplataforma. Plataforma é o conjunto formado por um computador e o 
sistema operacional instalado nesse computador. Podemos, então, ter as seguintes plataformas:
• Computador padrão PC-Intel executando Windows.
• Computador padrão PC-Intel executando Linux.
• Computador padrão iMac executando Mac OS.
• Computador padrão workstation executando Solaris.
Dizer que o Java é multiplataforma significadizer que um programa feito em Java e compilado em 
uma determinada plataforma poderá ser executado nessa plataforma e também em todas as demais 
plataformas que dão suporte ao Java.
13
Re
vi
sã
o:
 M
ac
ili
a/
Ro
se
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
1/
10
/1
5
TÓPICOS ESPECIAIS DE PROGRAMAÇÃO ORIENTADA A OBJETOS
 Observação
Diversas linguagens, como o C++, por exemplo, estão disponíveis para 
diversas plataformas. Entretanto, um código escrito em C++ que seja 
compilado em uma determinada plataforma só poderá ser executado nesta 
mesma plataforma. Para que o código seja executado em outra plataforma, 
ele deverá ser compilado novamente, mas, dessa vez, na plataforma em que 
se deseja executar o código.
Como é possível que um programa compilado em Java em uma determinada plataforma possa ser 
executado em outras plataformas?
 Lembrete
Um computador só consegue executar programas que estejam escritos 
em linguagem de máquina. Quando um programa é escrito em uma 
linguagem de alto nível, o código deste programa deve ser compilado 
(traduzido) para a linguagem de máquina da plataforma que irá executar 
o programa.
O Java realiza esta façanha porque ele não é compilado diretamente para a linguagem de máquina 
de uma plataforma específica. Em vez disso, ele é compilado para uma linguagem de máquina de 
um computador fictício, uma máquina virtual. Para que o programa possa ser, então, executado, um 
computador deve utilizar um emulador desse computador fictício, que interpreta o código compilado 
Java. Em outras palavras: um programa em Java é semicompilado, o que significa que o código-fonte é 
compilado para uma linguagem intermediária, conhecida como bytecode. O bytecode é um código de 
computador escrito em linguagem de máquina da Máquina Virtual Java (Java Virtual Machine – JVM). 
A Máquina Virtual Java, então, interpreta o bytecode e executa o programa.
Código-fonte Compilador 
Java
Bytecode Máquina 
Virtual Java
Programa em 
execução
Figura 2 – Processo de compilação e execução de um programa em Java
Com esta estrutura, um programa compilado em Java pode ser executado diretamente em qualquer 
sistema que possua uma Máquina Virtual Java.
14
Re
vi
sã
o:
 M
ac
ili
a/
Ro
se
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
1/
10
/1
5
Unidade I
1.3 Características da linguagem Java
Mendes (2009) sumariza algumas das principais características do Java, características estas que 
justificam a grande penetração da tecnologia no mercado. Resumidamente temos:
1.3.1 Simplicidade
A linguagem Java é considerada simples porque permite que o programador crie sistemas para 
diferentes plataformas sem se preocupar com a arquitetura do hardware particular de cada uma delas.
O Java também não tenta “reinventar a roda”, criando uma nova sintaxe. Ele utiliza a sintaxe já bem 
estabelecida da linguagem C. Além disso, o Java não implementa alguns aspectos menos utilizados da 
orientação a objetos, como a herança múltipla, a sobrecarga de operadores, os ponteiros e as operações 
aritméticas sobre os ponteiros.
1.3.2 Orientação a objetos
O paradigma orientado a objetos de análise de sistemas (e de programação) traz uma nova maneira 
de se pensar o desenvolvimento de sistemas. Essa nova maneira de se criar programas utiliza os conceitos 
de herança, polimorfismo e encapsulamento. Tais conceitos incentivam boas práticas de programação, 
como o reuso de código e a padronização, o que torna sistemas orientados a objetos mais fáceis de 
serem desenvolvidos, reutilizados, e faz com que apresentem manutenção mais rápida e barata.
1.3.3 Multithread
O Java é uma linguagem que permite o multiprocessamento (multithreading). Isso significa 
que partes de um mesmo programa podem ser executadas simultaneamente. Essa técnica permite 
o total aproveitamento de sistemas dotados de múltiplos processadores. Deve-se ressaltar que o 
multiprocessamento traz benefícios também para programas executados em sistemas com apenas um 
núcleo de processamento.
1.3.4 Robustez
A linguagem Java e sua arquitetura de compilação para um código intermediário (bytecode) otimizado 
garantem que uma grande quantidade de erros comuns em outras linguagens não ocorra em Java, por 
exemplo, código não alcançável e vazamentos de memória. Esse segundo tipo de erro, muito comum 
em programas feitos em C++, ocorre quando o programador reserva um espaço de memória de trabalho 
para seu programa e esquece de liberá-lo após seu uso. Com o tempo, estes espaços não liberados vão 
se acumulando, tornando o sistema cada vez menos estável, até que ele não possa mais ser utilizado. 
Em Java, este tipo de erro é extremamente improvável, pois um mecanismo automatizado chamado de 
garbage collector (coletor de lixo) garante que espaços de memória reservados pelo programa e que 
não estão mais em uso sejam automaticamente liberados.
15
Re
vi
sã
o:
 M
ac
ili
a/
Ro
se
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
1/
10
/1
5
TÓPICOS ESPECIAIS DE PROGRAMAÇÃO ORIENTADA A OBJETOS
1.3.5 Segurança
A linguagem Java está preparada para ser utilizada em aplicações corporativas de grande porte, com 
arquitetura distribuída, situação em que a segurança é de extrema importância.
 Saiba mais
Vários livros que abordam a programação em Java apresentam a 
história do desenvolvimento da linguagem, assim como suas principais 
características, dos quais destacamos:
MENDES, D. R. Programação Java com ênfase em orientação a objetos. 
São Paulo: Novatec, 2009.
1.4 O que é necessário para se programar em Java
O Java é disponibilizado por seu atual desenvolvedor, a Oracle, em diversas distribuições. Algumas delas são:
• Java Standard Edition (Java SE).
• Java Enterprise Edition (Java EE).
• Java Micro Edition (Java ME).
• Java Card.
• Java TV.
A mais importante distribuição é a Java SE (Java Edição Padrão). É nessa distribuição que estão as 
bibliotecas básicas do Java e as principais ferramentas de desenvolvimento, como o compilador Java.
As demais distribuições são complementos ao Java SE que disponibilizam outras capacidades à 
linguagem. Por exemplo, o Java EE (Java Edição Corporativa) inclui bibliotecas e servidores capazes de 
permitir a criação e operação de sistemas corporativos distribuídos, o uso de persistência automatizada 
e a criação de páginas dinâmicas de internet entre outras funcionalidades. O Java ME (Java Edição Micro) 
oferece a base para a programação de dispositivos móveis, como celulares, PDAs, receptores de TV, TVs 
inteligentes etc. No caso de dispositivos como TVs, DVDs e Blu-Rays, há uma distribuição específica, o 
Java TV, que é uma especialização do Java ME para estas aplicações particulares.
Tendo o SDK Java SE (também conhecido como JDK – Java Development Kit) instalado, já é possível 
escrever programas usando algum editor de arquivos de texto e usando o compilador Java por meio de 
linha de comando.
16
Re
vi
sã
o:
 M
ac
ili
a/
Ro
se
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
1/
10
/1
5
Unidade I
 Saiba mais
Você pode obter uma visão geral a respeito do Java, assim como 
adquiri-lo, na página de seu desenvolvedor:
<http://www.oracle.com/technetwork/java/javase/overview/index.html>.
É perfeitamente possível criar sistemas complexos utilizando apenas editores de arquivos texto e o 
compilador por linha de comando. Entretanto, essa não é a nossa proposta.
Apesar do SDK Java SE ser suficiente para se programar em Java, a maioria dos estudantes e 
programadores admitem que o uso de um Ambiente Integrado de Desenvolvimento (IDE – Integrated 
Development Environment) torna o trabalho do desenvolvedor mais fácil. Um IDE é um sistema que 
reúne em um único pacote diversas ferramentas como:
• Editor de código-fonte.
• Gerenciador de arquivos.
• Corretor de sintaxe.
• Ferramenta de automação de compilação.
• Ferramenta de automação de depuração.
Assim, mesmo sendo opcional, vamos adotar uma IDE para desenvolver os exemplos deste livro-texto. 
Existem diversas IDEsdisponíveis, tanto de código aberto quanto de código proprietário. Várias delas podem 
ser utilizadas, mas, para não gastarmos tempo discutindo as diferenças entre elas, vamos utilizar o Eclipse.
 Observação
O Eclipse é um IDE de código aberto de grande popularidade. Outro 
IDE bastante conhecido é o NetBeans, mantido principalmente pela Oracle, 
mesmo desenvolvedor do Java. Há algumas diferenças entre ambos, mas 
não é possível dizer se um é melhor do que o outro. O que pode ser dito é 
que ambos são equivalentes, ou seja, tudo o que é feito com um pode ser 
feito com o outro.
Todos os códigos-fonte inseridos neste livro-texto podem ser executados 
tanto na IDE Eclipse como na NetBeans.
17
Re
vi
sã
o:
 M
ac
ili
a/
Ro
se
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
1/
10
/1
5
TÓPICOS ESPECIAIS DE PROGRAMAÇÃO ORIENTADA A OBJETOS
 Saiba mais
O Eclipse pode ser obtido da página de seu desenvolvedor:
<http://www.eclipse.org>.
O NetBeans pode ser obtido da página:
<https://netbeans.org>.
1.4.1 Instalando o JDK Java SE
Vá até o site de download do Java <http://www.oracle.com/technetwork/java/javase/downloads/index.
html>. Clique no link Java Platform (JDK). Marque sua aceitação do contrato de licença e escolha o JDK 
apropriado para a plataforma que você deseja utilizar para desenvolver os seus programas. O download do 
arquivo de instalação do JDK deve iniciar. Inicie o arquivo de instalação e siga as instruções na tela.
Figura 3 – Assistente de instalação do SDK Java SE
 Lembrete
Para se desenvolver em qualquer tecnologia Java, a única distribuição 
obrigatória é o Java SE. Este kit de desenvolvimento (SDK – Software 
Development Kit) é a única distribuição que contém o compilador Java. 
Qualquer outra distribuição é um acessório que deve ser instalado junto ao 
SDK Java SE.
18
Re
vi
sã
o:
 M
ac
ili
a/
Ro
se
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
1/
10
/1
5
Unidade I
1.4.2 Instalando o Eclipse
Vá até o site de download do Eclipse <http://www.eclipse.org/downloads/>. Selecione o download 
para Eclipse IDE for Java Developers na versão correta para seu sistema operacional. Escolha um 
site espelho para realizar o download (se estiver disponível). Quando o download estiver completo, 
descompacte o conteúdo do arquivo em alguma pasta fácil de lembrar. O Eclipse não possui arquivo de 
instalação. Você deve iniciá-lo diretamente do local onde foi extraído.
Figura 4 – O Eclipse deve ser iniciado a partir do local onde ele foi extraído
2 A LINGUAGEM JAVA
Vamos criar nosso primeiro programa, o famoso Olá mundo! Comece iniciando o Eclipse. Caso nunca 
o tenha iniciado antes, ele deve apresentar uma página de boas-vindas semelhante à seguinte figura:
Figura 5 – Seleção do workspace (pasta de trabalho)
19
Re
vi
sã
o:
 M
ac
ili
a/
Ro
se
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
1/
10
/1
5
TÓPICOS ESPECIAIS DE PROGRAMAÇÃO ORIENTADA A OBJETOS
Esta janela pede para que você indique qual é a pasta que deseja utilizar para guardar os seus 
projetos Java. Utilize o local padrão ou indique o local que deseja utilizar. Se marcar a check box, o 
Eclipse não irá mais fazer esta pergunta ao iniciá-lo.
A seguir, o Eclipse inicia. Novamente, caso seja a primeira vez que o esteja executando, ele deve 
apresentar uma tela de boas-vindas como na figura a seguir.
Figura 6 – Página de boas-vindas do Eclipse
Clique no ícone Workbench para exibir a área de trabalho.
Figura 7 – Área de trabalho do Eclipse
20
Re
vi
sã
o:
 M
ac
ili
a/
Ro
se
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
1/
10
/1
5
Unidade I
Vamos criar um projeto. Clique no menu File → New → Java Project. O seguinte assistente surge:
Figura 8 – Assistente de criação de projeto
Na caixa de texto Project name digite o nome do seu projeto, “Ola mundo”. Certifique-se de que na 
área JRE você esteja usando alguma máquina virtual Java SE. Se por algum motivo a JRE padrão em seu 
computador não for um Java SE, selecione o primeiro botão de rádio e escolha uma versão J2SE ou Java 
SE (qualquer versão dessas deve ser suficiente).
 Observação
Em qualquer linguagem de programação, sempre é recomendado não 
utilizar caracteres acentuados ou especiais. Ainda é possível (mesmo que 
incomum) que haja problemas tanto na compilação quanto na execução de 
códigos que utilizem tais símbolos. A única exceção é quando escrevemos 
algum texto em um String, por exemplo. Se desejamos escrever a mensagem 
“Olá mundo!” na tela, podemos usar acentos e caracteres especiais.
21
Re
vi
sã
o:
 M
ac
ili
a/
Ro
se
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
1/
10
/1
5
TÓPICOS ESPECIAIS DE PROGRAMAÇÃO ORIENTADA A OBJETOS
Figura 9 – Seleção de uma máquina virtual específica
As demais opções não precisam ser modificadas. Você já pode clicar no botão Finish. Nesse momento, 
o Eclipse cria uma pasta chamada “Ola mundo” no local que você indicou como pasta de trabalho. 
Dentro dela serão armazenados seus códigos-fonte, classes compiladas, arquivos de configuração, entre 
outros. Note que no Package Explorer (Explorador de Pacotes) agora há o seu projeto “Ola mundo”. 
Clique no sinal à esquerda do projeto para expandir sua estrutura interna.
22
Re
vi
sã
o:
 M
ac
ili
a/
Ro
se
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
1/
10
/1
5
Unidade I
Figura 10 – Projeto com sua estrutura expandida
Agora vamos criar o arquivo onde será escrito o código-fonte do programa. Note que dentro do 
projeto “Ola mundo” há uma pasta chamada src. Ela é uma abreviação de source (fonte) e é nela que 
iremos colocar todos os códigos-fonte de um projeto. Com o botão direito do mouse, clique na pasta src 
e selecione new → package. Package (pacote) é um conceito da orientação a objetos que permite que 
o desenvolvedor agrupe suas classes em pacotes.
Figura 11 – Criação do pacote
23
Re
vi
sã
o:
 M
ac
ili
a/
Ro
se
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
1/
10
/1
5
TÓPICOS ESPECIAIS DE PROGRAMAÇÃO ORIENTADA A OBJETOS
Na caixa para definir o nome do pacote, digite “primeiroPrograma”. Note que, em Java, nomes devem 
ser compostos de apenas uma palavra. Clique em Finish.
Em linguagens que derivam do C, como o C++, C# e Java, os nomes de classes, variáveis, métodos, 
atributos e demais elementos devem ter como nome um termo composto de uma única palavra.
Recomenda-se que os nomes sejam sempre mnemônicos, ou seja, o próprio nome deve indicar 
qual é a natureza ou finalidade do elemento que ele batiza. Por exemplo, uma variável não mnemônica 
chamada “xpto12” não dá nenhuma indicação ao programador de sua finalidade. Já, se ela for chamada 
de “contadorDeIterações”, sua finalidade se torna evidente.
Quando se utiliza mais de uma palavra como nome, recomenda-se que a primeira letra de cada palavra, 
a partir da segunda palavra, seja escrita em maiúscula. Esta notação é conhecida como camel case.
Dentro do pacote “primeiroPrograma” vamos criar a classe “OlaMundo”. Clique com o botão direito 
no pacote e selecione new → Class.
Figura 12 – Criação da classe “OlaMundo”
24
Re
vi
sã
o:
 M
ac
ili
a/
Ro
se
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
1/
10
/1
5
Unidade I
Na caixa para definir o nome da classe, digite o nome “OlaMundo”. Clique em Finish. Neste momento, 
o Eclipse cria o arquivo OlaMundo.java e o exibe no editor. Já se pode notar um pouco de código escrito 
no arquivo, a declaração do pacote e da classe. A seguir, basta escrever o código do método principal 
main() como demonstrado a seguir:
Figura 13 – Código do programa “OlaMundo”
A seguir, para compilar e executar seu programa, clique no botão indicado pela primeira seta (ou 
selecione o menu run → run). O Eclipse irá executar o compilador Java sobre seu código e executar o 
programa compilado. A saída do console é exibida na aba destacada pela segunda seta.
 Observação
Caso a janela para o seu código esteja pequena demais, você pode dar um 
duplo clique na aba da janela, o que faz com que ela sejamaximizada. Para 
voltar à visualização anterior, basta dar um duplo clique na aba novamente.
As abas também podem ser fechadas definitivamente, clicando no 
símbolo “X”. Caso você tenha fechado acidentalmente uma aba e não saiba 
como fazer para que ela seja reapresentada, você pode pedir ao Eclipse para 
restaurar a configuração padrão das janelas. Para tanto, chame o menu 
Window → Perspective → Reset Perspective... e responda Yes quando lhe for 
perguntado se quer realmente as janelas retornem à configuração padrão.
25
Re
vi
sã
o:
 M
ac
ili
a/
Ro
se
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
1/
10
/1
5
TÓPICOS ESPECIAIS DE PROGRAMAÇÃO ORIENTADA A OBJETOS
2.1 Entrada e saída de dados usando JOptionPane
No exemplo anterior, utilizamos um método para criar uma saída de texto no console. Também é 
possível receber dados do usuário pelo console. No entanto, deixaremos de lado esta forma de interação 
homem-máquina e priorizaremos, neste material, o uso de interfaces gráficas.
 Saiba mais
A Interação Homem-Máquina (IHC) é uma disciplina extensa que trata de 
diversos aspectos da interação entre pessoas e equipamentos tecnológicos. 
Para aprofundar seus conhecimentos a respeito desse assunto, leia:
ROGERS, Y.; SHARP, H.; PREECE, J. Design de interação: além da interação 
humano-computador. 3. ed. Porto Alegre: Bookman, 2013.
BENYON, D. Interação humano-computador. 2. ed. São Paulo: Pearson 
Prentice Hall, 2011.
O Java nos oferece uma ferramenta pronta para criar caixas de diálogo que são um tipo especial 
de janela em ambiente gráfico. Elas servem para apresentar informações e também para receber dados 
do usuário. Essas funcionalidades estão disponíveis na classe JOptionPane que está definida no pacote 
javax.swing, como ilustrado na figura a seguir:
Figura 14 – A classe JOptionPane dentro do pacote javax.swing
Na figura anterior, a classe JOptionPane é representada em um diagrama de classes, tendo seus 
atributos omitidos e apenas dois de seus métodos representados. A classe está definida no pacote swing, 
que por sua vez está definido no pacote javax.
26
Re
vi
sã
o:
 M
ac
ili
a/
Ro
se
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
1/
10
/1
5
Unidade I
 Saiba mais
O uso do console como mecanismo de interação é abordado 
extensivamente pela maioria dos livros sobre Java. Alguns deles são:
HORSTMANN, C. S.; CORNELL, G. Core Java. 8. ed. São Paulo: Pearson 
Prentice Hall, 2010.
JORGE, M. Java: passo a passo Lite. São Paulo: Pearson Education do 
Brasil, 2004.
 Observação
A UML (Unified Modeling Language – Linguagem Unificada de 
Modelagem) define diversos diagramas úteis para a documentação, 
modelagem, análise e projeto de sistemas orientados a objetos. O diagrama 
de classes, um dos mais importantes da UML, representa as classes de um 
sistema em um retângulo dividido em três partes. Na primeira, é anotado 
o nome da classe, na segunda, seus atributos e na terceira seus métodos.
O método showMessageDialog() permite a exibição de uma caixa de diálogo onde uma informação 
é exibida para o usuário. A sobrecarga mais simples desse método é:
Figura 15 – Declaração do método showMessageDialog()
Este método requer dois parâmetros: o primeiro, chamado pai, recebe um objeto que representa o 
elemento gráfico pai da caixa de mensagem. Esse elemento gráfico costuma ser uma janela do aplicativo. 
Entretanto, ainda não sabemos como criar qualquer elemento gráfico, por isso, vamos utilizar a palavra 
reservada null para indicar que a caixa de diálogo não irá possuir qualquer componente gráfico como 
pai. Isso também fará com que a caixa de diálogo seja apresentada centralizada na tela. A palavra 
reservada null indica um objeto que não foi instanciado, um objeto nulo. O segundo parâmetro é a 
mensagem que será apresentada dentro da caixa de diálogo.
Assim, em um programa, poderíamos utilizar o método showMessageDialog() da seguinte forma e 
obter o resultado exibido a seguir:
27
Re
vi
sã
o:
 M
ac
ili
a/
Ro
se
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
1/
10
/1
5
TÓPICOS ESPECIAIS DE PROGRAMAÇÃO ORIENTADA A OBJETOS
Figura 16 – Exemplo de uso do método showMessageDialog()
O método showInputDialog() permite criar uma caixa de diálogo que apresenta uma pergunta e 
exibe um espaço para que o usuário digite sua resposta. Quando o método é encerrado, ele retorna um 
String contendo o texto digitado pelo usuário. A declaração de sua sobrecarga mais simples é:
Figura 17 – Declaração do método showInputDialog()
Note que o método showInputDialog() não requer a indicação de um componente pai. Entretanto, 
se você desejar, pode indicar um, mesmo que seja null. O trecho de código a seguir mostra como podemos 
usar esse método para receber um texto do usuário. O texto digitado pelo usuário é armazenado na 
variável resposta:
Figura 18 – Exemplo de uso do método showInputDialog()
No exemplo a seguir, mostraremos um programa inteiro que utiliza a classe JOptionPane para 
realizar entrada e saída de dados usando as caixas de diálogo. Note que, para se utilizar esta classe, é 
necessário importar a classe para que o programa possa utilizá-la. Isto é feito com a palavra reservada 
import, que deve ser inserida logo abaixo da palavra package.
28
Re
vi
sã
o:
 M
ac
ili
a/
Ro
se
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
1/
10
/1
5
Unidade I
Figura 19 – Um programa que realiza entrada e saída de dados por meio de caixas de diálogo
Assumindo-se que, ao executar o programa demonstrado anteriormente, o usuário digite o nome 
Maria, ele irá obter as seguintes mensagens:
Figura 20 – Saída gerada pelo programa OlaMundoGrafico
 Observação
O programa apresentado na figura 19 deve ser criado em um pacote 
chamado unidadeUm. É recomendado também que ele seja criado em um 
novo projeto. A razão para isso é que cada projeto deve ter apenas um 
método main(). Quando um projeto apresenta mais de um método main(), 
pode ser necessário indicar ao Eclipse qual é o método main() ativo no 
projeto. A maneira de se fazer isso varia dependendo da versão do Eclipse.
29
Re
vi
sã
o:
 M
ac
ili
a/
Ro
se
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
1/
10
/1
5
TÓPICOS ESPECIAIS DE PROGRAMAÇÃO ORIENTADA A OBJETOS
2.2 Recomendações de estilo
Podemos dar nomes a diversos elementos de nossos programas, como variáveis, atributos, métodos, 
parâmetros etc.
 Lembrete
Em Java e em linguagens orientadas a objeto, em geral, recomenda-se 
o uso de nomes mnemônicos, ou seja, nomes que já indicam qual é a 
finalidade do elemento que ele batiza. Por exemplo, pode ser difícil saber 
qual é a finalidade de uma variável chamada xpto12. Por outro lado, se 
a mesma variável receber o nome contadorDeIteracoes, sua finalidade 
torna-se bastante clara.
Para que se criem nomes mnemônicos, muitas vezes, desejamos usar mais de uma palavra. Mas um 
nome deve ser uma única palavra, sem espaços. A recomendação, neste caso, é escrever todas as palavras 
juntas, sem espaço. Para se marcar a separação entre as palavras, a partir da segunda palavra, a primeira 
letra deve ser grafada com letra maiúscula. Esta notação é conhecida como camel case. Exemplo:
• contadorDeIteracoes.
• respostaDoUsuario.
• mediaFinal.
O Java recomenda que a primeira letra do nome seja maiúscula caso o nome seja de uma classe ou 
de uma interface. Exemplos:
• OlaMundo.
• ProgramaPrincipal.
• String.
 Observação
Não confunda interface com interface gráfica. A interface gráfica é 
um recurso de entrada e saída de dados utilizando elementos gráficos e 
dispositivos de interação humana, como mouse e teclado. Já a interface 
é um conceito de orientação a objetos que será abordado mais adiante. 
Uma interface pode ser entendida, resumidamente, como uma classe 
sem atributos e que apenas declara as assinaturas dos métodos, sem 
implementar qualquer um deles.
30
Re
vi
sã
o:
 M
ac
ili
a/
Ro
se
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
1/
10
/1
5
Unidade I
A exceção ao camel caseestá na declaração de nomes de constantes. Constantes são atributos 
cujo valor não pode ser alterado. O Java recomenda que constantes sejam escritas com todas as letras 
maiúsculas, separando as palavras pelo símbolo do sublinhado. Exemplos:
• NOTA_MINIMA.
• TAMANHO_PADRAO.
• PI.
• CONSTANTE_GRAVITACIONAL.
2.3 Tipos primitivos
Tipos são a natureza dos dados que podem ser armazenados em uma variável, um atributo, que 
podem ser transferidos por um parâmetro ou retorno de método. Tipo primitivo é o tipo de dado que 
está definido na própria linguagem Java. Por isso, esses tipos têm um excelente desempenho tanto em 
economia de memória quanto em desempenho de processamento. Estes tipos são:
Quadro 1 – Tipos primitivos em Java
Tipo Tamanho em bits Natureza Valores
boolean Depende da JVM de cada plataforma Booleanos true ou false
char 16 Caractere alfanumérico ‘\u0000’ a ‘\uffff’ (0 a 65535)
byte 8
Número inteiro
-128 a 127
short 16 -32.768 a 32.767
int 32 -2.147.483.648 a 2.147.483.647
long 64 -9223372036854775808 a 9223372036854775807
float 32
Número em ponto 
flutuante
Intervalo negativo:
-3,4028234663852886E+38 a -1,40129846432481707e-45
Intervalo positivo:
1,40129846432481707e-45 a 3,4028234663852886E+38
double 64
Intervalo negativo:
-1,7976931348623157E+308 a -4,94065645841246544e-324
Intervalo positivo:
4,94065645841246544e-324 a 1,7976931348623157E+308
Adaptado de: Deitel (2005).
Na figura a seguir, criamos algumas variáveis e atribuímos a elas valores definidos por literais, ou 
seja, valores definidos no próprio código-fonte:
31
Re
vi
sã
o:
 M
ac
ili
a/
Ro
se
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
1/
10
/1
5
TÓPICOS ESPECIAIS DE PROGRAMAÇÃO ORIENTADA A OBJETOS
Figura 21 – Exemplos de declaração de variáveis de tipos primitivos
Quando se define um literal numérico inteiro, ele é tratado como sendo um inteiro. Já quando se 
define um literal numérico com um ponto decimal, ele é tratado como um double. Para se definir um 
literal caractere, ele deve ser circundado por aspas simples. Um literal booleano só pode assumir os 
valores representados pelas palavras reservadas true ou false.
Quando se deseja definir um literal inteiro maior do que a capacidade de representação do int, 
deve-se indicar que o literal é um long, adicionando-se o sufixo L ou l. Analogamente, ao se representar 
um literal como um float, deve-se adicionar o sufixo F ou f:
Figura 22 – Literais de tipo long e float
2.4 Conversão de tipos
Quando se trabalha com mais de um tipo primitivo, podemos atribuir o valor armazenado em uma 
variável de tipo de menor capacidade em uma variável de maior capacidade. De certa forma, podemos 
entender que um tipo menor “cabe” dentro de um tipo maior.
byte short int long float double
Figura 23 – Relação de capacidade entre tipos primitivos numéricos
Desta forma, o seguinte método, se executado, irá gerar a mensagem representada na figura 25.
32
Re
vi
sã
o:
 M
ac
ili
a/
Ro
se
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
1/
10
/1
5
Unidade I
Figura 24 – Atribuições de variáveis a tipos de capacidade crescentes
Na linha 10 é declarado o método atribuicoesSemCast(), o qual realiza o exemplo. Na linha 11 é 
declarada a variável b do tipo byte com o valor 8. Da linha 12 até a linha 16, o valor da variável b é 
transferido sucessivamente para variáveis de maior capacidade. Na linha 18 é declarada uma variável do 
tipo String chamada valores. A esta variável é atribuído o retorno do método format() da classe String. 
O método format() recebe pelo menos dois parâmetros.
O primeiro é um String de formatação. Este String é composto de caracteres que são simplesmente 
retornados, como “b = “ e parâmetros de formatação que são compostos de um sinal % e uma letra. 
Esta letra indica se o parâmetro será substituído por um número decimal (d) ou um número de ponto 
flutuante (f). A seguir, o método format() recebe os valores que serão inseridos nos parâmetros do String 
de formatação. As sequências “\n” indicam que será inserido no String uma quebra de linha. Por fim, 
para que o código não fique demasiadamente largo, pode-se quebrar uma linha no meio do String. 
Para tanto, ele deve ser encerrado na primeira linha fechando as aspas e, na linha seguinte, deve ser 
concatenado com o segundo String usando o operador +.
 Observação
A saída formatada utilizada no exemplo anterior é uma ferramenta 
poderosa que foi criada originalmente na linguagem C e está disponível no 
Java nos métodos String.format() e System.out.printf().
33
Re
vi
sã
o:
 M
ac
ili
a/
Ro
se
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
1/
10
/1
5
TÓPICOS ESPECIAIS DE PROGRAMAÇÃO ORIENTADA A OBJETOS
Figura 25 – Saída do método atribuicoesSemCast()
Já para se fazer as atribuições na direção oposta, é necessário realizar um cast, ou conversão de 
tipo. Um cast é representado pelo tipo de destino entre parênteses antes do valor a ser convertido. O 
programa apresentado na figura 24 foi alterado para realizar atribuições de variáveis de maior capacidade 
a variáveis de menor capacidade.
Figura 26 – Atribuições de variáveis de maior capacidade a variáveis de menor capacidade
Na figura anterior está representado o mesmo programa Atribuicoes. Repare que na linha 11 há um 
sinal + e a próxima linha é a 24. Este sinal indica que a implementação do método atribuicoesSemCast() 
foi ocultada. Este recurso está disponível no Eclipse (e em praticamente qualquer IDE moderna). Para 
se exibir novamente o código oculto, basta clicar no sinal +. Para se ocultar um trecho de código, 
clica-se no sinal –. A outra modificação está no método main(), que agora chama também o método 
atribuicoesComCast().
34
Re
vi
sã
o:
 M
ac
ili
a/
Ro
se
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
1/
10
/1
5
Unidade I
Na linha 26 é declarada uma variável double com um valor em ponto flutuante. Nas linhas 27 a 31, 
este valor é convertido sucessivamente em tipos cada vez de menor capacidade. O resultado pode ser 
visto na figura a seguir.
Figura 27 - Saída do método atribuicoesComCast()
Note como os valores, ao serem convertidos para tipos de menor capacidade, foram perdendo 
precisão, como se estivessem sendo corrompidos. Isto ocorre porque o cast não faz arredondamento, 
ele faz truncamento em binário. Isso significa que, quando um número é convertido para um tipo de 
capacidade menor em bits, apenas os bits menos significativos são mantidos. Os bits excedentes do 
número são desprezados, o que causa a perda de informação.
 Observação
A partir de agora, os exemplos apresentados neste livro-texto não 
serão mais programas inteiros. Para poupar espaço, os exemplos serão 
apresentados como métodos que podem simplesmente ser inseridos em 
um programa qualquer que você já tenha criado. Basta chamar o método a 
partir do seu método main().
2.5 Classes wrapper (invólucro)
Cada tipo primitivo possui uma classe wrapper associada. Uma classe wrapper pode ser utilizada para 
instanciar um objeto que armazena um valor do tipo primitivo associado a ela. Além disso, estas classes 
apresentam diversos métodos para fazer a conversão de e para diversos tipos. As classes wrapper são:
Quadro 2 – Tipos primitivos e suas classes wrapper associadas
Tipo primitivo Classe wrapper
boolean Boolean
char Character
byte Byte
35
Re
vi
sã
o:
 M
ac
ili
a/
Ro
se
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
1/
10
/1
5
TÓPICOS ESPECIAIS DE PROGRAMAÇÃO ORIENTADA A OBJETOS
short Short
int Integer
long Long
float Float
double Double
Essas classes podem ser utilizadas para se instanciar objetos com um valor do tipo primitivo associado 
a elas:
Figura 28 – Instanciação de objetos de classes wrapper
A partir do Java 5 (Java versão 1.5), o valor de uma variável de tipo primitivo pode ser atribuído 
diretamente a um objeto de sua classe wrapper associada e vice-versa. Este recurso é chamado de 
autoboxing:
Figura 29 – Exemplo de autoboxing
As classes wrapper oferecem métodosparse que são úteis para se converter um String em um valor 
de tipo primitivo associado. Cada classe wrapper possui um método parse:
Figura 30 – Exemplos de conversão de String para tipos primitivos
As classes wrapper numéricas (todas exceto boolean e character) possuem métodos value para 
converter o valor armazenado no objeto para outros tipos primitivos numéricos. Dessa vez, a conversão 
é feita com arredondamento, não mais com truncamento, como o que ocorre quando se utiliza um 
cast. O exemplo a seguir utiliza os métodos value para converter de um objeto Integer para diversos 
outros tipos, mas o mesmo pode ser feito com qualquer outro wrapper numérico.
36
Re
vi
sã
o:
 M
ac
ili
a/
Ro
se
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
1/
10
/1
5
Unidade I
Figura 31 – Exemplo de uso de um objeto wrapper para se converter um inteiro para diversos outros tipos
Repare que na primeira linha foi usado um construtor da classe Integer que recebe um String e não 
um int. Todas as classes wrapper possuem um construtor que recebe um String. Este construtor faz a 
conversão apropriada (usando um método parse adequado) antes de terminar a instanciação do objeto.
 Saiba mais
Como em qualquer recurso do Java, é possível aprender bastante 
estudando a documentação da linguagem.
Para saber do que mais são capazes as classes wrapper, consulte:
<https://docs.oracle.com/javase/tutorial/java/data/index.html>.
Veja o programa a seguir que utiliza uma classe wrapper para receber dois números do usuário e, a 
seguir, realizar um cálculo matemático:
Figura 32 – Um programa que recebe números do usuário e realiza um cálculo matemático com eles
37
Re
vi
sã
o:
 M
ac
ili
a/
Ro
se
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
1/
10
/1
5
TÓPICOS ESPECIAIS DE PROGRAMAÇÃO ORIENTADA A OBJETOS
Observe a seguir as saídas do programa da figura anterior:
Figura 33
2.6 Introdução a classes e objetos
Uma das diferenças mais óbvias entre uma linguagem estruturada e uma linguagem orientada a 
objetos são justamente as classes e objetos. Pode-se entender, de maneira bastante simplificada, que 
uma classe é um trecho de código de computador que modela algum conceito útil para o sistema que se 
está desenvolvendo. Este conceito pode ser algo tangível, como um cliente, um funcionário, um produto, 
uma venda, mas também pode ser um conceito mais abstrato, como um conjunto de ferramentas de 
cálculo ou um conjunto de funcionalidades de acesso a banco de dados.
Quando se faz a análise de um sistema, deve-se modelar classes que encapsulem, isolem, coloquem 
uma “cápsula” em torno deste conceito. Para tanto, é preciso ter em mente as seguintes regras para um 
bom projeto de classe:
• Uma classe deve modelar apenas um conceito.
• Uma classe não deve modelar qualquer aspecto de outro conceito.
• Não deve haver em nenhuma outra parte do sistema qualquer aspecto do conceito modelado pela classe.
38
Re
vi
sã
o:
 M
ac
ili
a/
Ro
se
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
1/
10
/1
5
Unidade I
 Saiba mais
As tarefas relacionadas à criação da estrutura de classes de um sistema 
podem ser estudadas nos seguintes livros:
MEDEIROS, E. S. de. Desenvolvendo software com UML 2.0: definitivo. 
São Paulo: Pearson Makron Books, 2004.
PAGE-JONES, M. Fundamentos do desenho orientado a objeto com 
UML. São Paulo: Makron Books, 2001.
Uma classe modela um determinado conceito reunindo, em um único elemento, os dados 
que definem esse conceito e os comportamentos que esse conceito pode apresentar. Uma boa 
maneira de se representar classes é usando o Diagrama de Classes da UML (Linguagem Unificada de 
Modelagem em inglês). Neste diagrama, uma classe é representada com um retângulo dividido em 
três partes. Na primeira parte é registrado o nome da classe. Na segunda, os atributos da classe, 
que armazenam os dados da classe. Na terceira parte, os métodos da classe, que implementam 
os comportamentos da classe.
Figura 34 – Diagrama de classes da classe Pessoa
A figura registra uma classe em UML. Esta classe tem o nome Pessoa e possui dois atributos: nome 
e telefone. O primeiro atributo armazena dados do tipo String, enquanto que o segundo armazena 
dados do tipo int. A classe também apresenta o método apresente(), que será usado para exibir as 
informações armazenadas nos atributos. Este método não recebe parâmetros, pois não há nenhum 
parâmetro representado entre os parênteses. Ele também não devolve nenhum valor, pois seu tipo de 
retorno é void. Esta classe pode ser codificada em Java da seguinte maneira:
39
Re
vi
sã
o:
 M
ac
ili
a/
Ro
se
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
1/
10
/1
5
TÓPICOS ESPECIAIS DE PROGRAMAÇÃO ORIENTADA A OBJETOS
Figura 35 – A classe Pessoa codificada em Java
Nas linhas 7 e 8 estão declarados os atributos nome e telefone. Eles são declarados como se 
fossem variáveis, mas são atributos por não estarem dentro de qualquer método. Suas declarações são 
precedidas pela palavra reservada public, representada pelo sinal + no diagrama UML da figura 34. Esta 
palavra reservada indica que esses atributos podem ser acessados por qualquer parte do sistema que 
tenha acesso à classe Pessoa. Na linha 10 é declarado o método apresente(), que imprime em uma caixa 
de diálogo os dados armazenados nos atributos.
 Observação
Os modificadores de acesso serão abordados mais adiante neste 
livro-texto.
Uma classe é uma definição de um conceito, como o simples cadastro de uma pessoa apresentado 
no exemplo mencionado anteriormente. No entanto, um programa não pode utilizar esta definição 
diretamente, ele precisa instanciar esta classe em um objeto. Imagine que uma classe seja uma receita 
de bolo. Com esta receita, pode-se preparar vários bolos e todos acabarão sendo mais ou menos parecidos. 
Da mesma forma, uma classe é usada para se instanciar vários objetos. É o objeto que realmente possui 
os dados e os comportamentos modelados. O programa a seguir instancia um objeto da classe Pessoa, 
atribui valores aos seus atributos e chama o método apresente(). O resultado de sua execução também 
é apresentado:
40
Re
vi
sã
o:
 M
ac
ili
a/
Ro
se
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
1/
10
/1
5
Unidade I
Figura 36 – Programa TestaPessoa e o resultado de sua execução
Na linha 7 é criada uma variável chamada p, cujo tipo é Pessoa. Nesta variável é armazenado um 
objeto da classe Pessoa. O objeto é instanciado com o uso da palavra reservada new seguida do “nome 
da classe”. Na verdade, o termo Pessoa() que segue a palavra new não é o nome da classe, mas um 
método construtor. Métodos construtores serão apresentados logo a seguir.
Nas linhas 9 e 10 os atributos nome e telefone de p têm seus valores atribuídos. Note que o objeto 
p têm seus próprios atributos nome e telefone. Caso um outro objeto fosse instanciado, ele poderia ter 
valores diferentes em seus atributos nome e telefone.
Na linha 12 é chamado o método apresente() de p, que faz ser exibida a caixa de mensagem com as 
informações armazenadas no objeto p.
2.7 Instruções de controle
Note que, da maneira que a classe Pessoa no item anterior foi escrita, qualquer valor pode ser 
atribuído aos atributos da classe, mesmo que eles sejam inválidos. Há uma maneira de se evitar que isso 
aconteça: nós podemos encapsular os atributos, ou seja, torna-los privados, e oferecer acesso a eles por 
métodos acessores (getters, em inglês), que fazem a validação dos dados de forma que apenas dados 
válidos sejam armazenados. A seguir, modificamos a classe Pessoa para que só possam ser armazenados 
telefones com pelo menos oito dígitos. Vamos também encapsular o atributo nome, mesmo que 
nenhuma validação seja feita:
41
Re
vi
sã
o:
 M
ac
ili
a/
Ro
se
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
1/
10
/1
5
TÓPICOS ESPECIAIS DE PROGRAMAÇÃO ORIENTADA A OBJETOS
Figura 37 – A classe Pessoa com atributos encapsulados
Nas linhas 7 e 8, os atributos nome e telefone foram alterados para privados,o que significa que 
agora eles só podem ser acessados de dentro da própria classe Pessoa. Para permitir que eles tenham seus 
valores lidos, foram criados os métodos getters, nas linhas 10 e 18. Estes métodos, quando executados, 
retornam o valor armazenado no atributo correspondente.
Na linha 14 é criado o método setNome(), que recebe como parâmetro um nome e o atribui ao 
atributo nome. Como tanto o parâmetro quanto o atributo possuem o mesmo nome, o programa 
não teria como saber qual é o atributo e qual é o parâmetro. Para resolver este problema, utiliza-se a 
referência this na linha 15. Desta forma, pode-se ler a linha 15 como sendo “o nome deste objeto recebe 
o valor de nome”. Assim, this.nome é o atributo do objeto enquanto que nome é o parâmetro.
Já no método setTelefone() na linha 22, só é feita a atribuição se o valor do parâmetro telefone tiver 
ao menos oito dígitos. Esta verificação é feita com o desvio condicional if. Sua sintaxe completa é:
42
Re
vi
sã
o:
 M
ac
ili
a/
Ro
se
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
1/
10
/1
5
Unidade I
Figura 38 – Sintaxe do desvio condicional if
A condição pode ser qualquer expressão que tenha como valor final um booleano. Isso significa que 
a condição pode ser uma simples variável booleana ou uma expressão booleana, que é o resultado de 
alguma operação lógica. As operações lógicas são:
Quadro 3 – Operadores lógicos
== Igual a
!= Diferente de
< Menor que
> Maior que
<= Menor ou igual a
>= Maior ou igual a
! Não (inverte o resultado de uma expressão booleana)
Quando se deseja realizar vários testes, pode-se encadear outro if dentro do conjunto de instruções 
da cláusula else. Mas também pode-se utilizar a estrutura switch-case, que tem a sintaxe a seguir:
Figura 39 – Sintaxe da estrutura switch-case
43
Re
vi
sã
o:
 M
ac
ili
a/
Ro
se
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
1/
10
/1
5
TÓPICOS ESPECIAIS DE PROGRAMAÇÃO ORIENTADA A OBJETOS
A estrutura switch-case usa como cláusula de teste uma variável que pode ser dos tipos primitivos 
char, int, short ou byte. Cada cláusula case define um conjunto de instruções que será executado caso 
seu valor corresponda ao valor da variável de teste. A cláusula default, que é opcional, é executada se 
nenhuma outra cláusula case foi executada.
 Saiba mais
A sintaxe completa das estruturas if, if-else e switch-case pode ser 
encontrada na bibliografia e também nos documentos de apoio do Java, 
disponíveis na internet:
ORACLE. The if-then and if-then-else statements. The Java Tutorials. 
2015b. Disponível em: <https://docs.oracle.com/javase/tutorial/java/
nutsandbolts/if.html>. Acesso em: 15 out. 2015.
ORACLE. The switch statement. The Java Tutorials. 2015d. Disponível 
em: <https://docs.oracle.com/javase/tutorial/java/nutsandbolts/switch.
html>. Acesso em: 15 out. 2015.
A classe Pessoa ainda não teve um método construtor definido explicitamente. Método construtor é 
um método que é executado sempre que um objeto é instanciado. Esse método deve possuir exatamente 
o mesmo nome da classe e não deve apresentar nenhum tipo de retorno, nem mesmo void. Quando não 
criamos um construtor em uma classe, o próprio compilador cria um para nós, é o construtor padrão. 
O método construtor padrão é um construtor sem parâmetros e que não executa nenhuma ação em 
sua implementação. Quando escrevemos “Pessoa p = new Pessoa();”, o termo Pessoa(), na verdade, é o 
construtor padrão da classe. Nós podemos criar os nossos próprios construtores. Uma vez que a classe 
tenha um construtor qualquer, o compilador não irá criar o construtor padrão. Caso queiramos um 
construtor sem parâmetros, devemos declará-lo explicitamente, como do exemplo a seguir:
44
Re
vi
sã
o:
 M
ac
ili
a/
Ro
se
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
1/
10
/1
5
Unidade I
Figura 40 – A classe Pessoa com métodos construtores
Na linha 28 é declarado o método construtor sem parâmetros. Note que o método deve ter 
exatamente o mesmo nome da classe e não deve apresentar nenhum tipo de retorno. Na linha 32 é 
criado um segundo método construtor, desta vez ele recebe como parâmetros o nome e o telefone da 
pessoa. Em sua implementação, ele faz a atribuição dos valores utilizando a validação de dados por meio 
dos métodos acessores que já foram criados na classe.
A classe TestaPessoa pode ser modificada da seguinte maneira para refletir as mudanças feitas na 
classe Pessoa:
45
Re
vi
sã
o:
 M
ac
ili
a/
Ro
se
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
1/
10
/1
5
TÓPICOS ESPECIAIS DE PROGRAMAÇÃO ORIENTADA A OBJETOS
Figura 41 – Programa TestePessoa corrigido
Na linha 7, é instanciado o objeto p1 utilizando o construtor sem parâmetros. Nas linhas 8 e 9, 
os valores dos atributos agora precisam ser definidos utilizando os métodos acessores. Já não é mais 
possível acessar os atributos diretamente, pois eles foram definidos como privados.
Na linha 12, um outro objeto, p2, é instanciado, desta vez utilizando o construtor que recebe como 
parâmetros os valores do nome e do telefone. Durante a instanciação, os valores são armazenados nos 
atributos e o objeto já está pronto para exibir suas informações.
Agora, digamos que queiramos que o programa leia e exiba os dados de dez pessoas. Nós poderíamos 
simplesmente repetir a lógica do programa anterior dez vezes, mas esta não é a melhor escolha.
 Observação
O computador existe para realizar o trabalho árduo para nós. Sempre 
que nos pegamos pensando algo como “vou ter que fazer a mesma coisa de 
46
Re
vi
sã
o:
 M
ac
ili
a/
Ro
se
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
1/
10
/1
5
Unidade I
novo”, muito provavelmente há algo errado em nosso algoritmo. Sempre há 
alguma maneira de fazer como que o programa realize a tarefa repetitiva 
para nós.
A seguir, vamos modificar o programa TestePessoa para repetir dez vezes a rotina de receber e exibir 
os dados de dez pessoas:
Figura 42 – O programa que recebe e exibe os dados de dez pessoas
O método recebePessoa() entre as linhas 7 e 19 recebe do usuário os dados de uma pessoa, instancia 
um objeto da classe Pessoa com estes dados e o retorna.
O método main() entre as linhas 21 e 30 utiliza o método recebePessoa() para receber os dados de 
dez pessoas. Na linha 25 é iniciado um laço de repetição for para repetir dez vezes a rotina definida nas 
linhas 26 e 27. O laço for tem três parâmetros: o primeiro é uma definição de uma variável contadora; 
o segundo é a condição que, se verdadeira, permitirá que o laço seja repetido mais uma vez; o terceiro 
é a lógica de incremento (ou decremento) da variável contadora.
47
Re
vi
sã
o:
 M
ac
ili
a/
Ro
se
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
1/
10
/1
5
TÓPICOS ESPECIAIS DE PROGRAMAÇÃO ORIENTADA A OBJETOS
O Java ainda define os laços while e do-while, que possuem a seguinte sintaxe:
Figura 43 – Sintaxe dos laços while e do-while
O laço while inicia testando a condição de parada. Se ela for verdadeira, ele irá executar o conjunto 
de instruções de repetição. Em algum momento durante a execução, a condição de parada deve ser 
alterada para falsa, de modo a fazer com que o laço encerre.
O laço do-while inicia executando uma vez o conjunto de instruções de repetição. A seguir ele 
verifica a condição de parada. Se ela estiver verdadeira, o loop reinicia. Novamente, em algum momento 
a condição de parada deve ser alterada para falsa para que o laço termine.
 Saiba mais
Consulte a documentação do Java para conhecer mais detalhes dos 
laços for, while e do-while:
ORACLE. The for statement. The Java Tutorials. 2015c. Disponível em 
<https://docs.oracle.com/javase/tutorial/java/nutsandbolts/for.html>. 
Acesso em: 15 out. 2015.
ORACLE. The while and do-while statements. The Java Tutorials. 2015e. 
Disponível em: <https://docs.oracle.com/javase/tutorial/java/nutsandbolts/
while.html>. Acesso em: 15 out. 2015.
2.8 Arrays
O programa do exemplo anterior conseguia ler e exibir os dados de dez pessoas,mas não era capaz 
de armazená-los. Para tanto, deveríamos ter criado dez variáveis. Entretanto, criando dez variáveis, seria 
muito difícil continuar utilizando o laço for para automatizar o processo. Para resolver este problema, 
podemos utilizar um array (vetor). Um array é um conjunto de variáveis de mesmo tipo. Vejamos como 
o programa pode ser modificado para utilizar um array de Pessoa:
48
Re
vi
sã
o:
 M
ac
ili
a/
Ro
se
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
1/
10
/1
5
Unidade I
Figura 44 – Programa que recebe e armazena Pessoa em um array
Na linha 22 é declarada a variável p, que desta vez é um array de objetos da classe Pessoa. Isso é 
indicado pelo símbolo []. Um array deve ser instanciado como se fosse um objeto, o que é feito na linha 
23 com o operador new, seguido do tipo de dado de cada elemento do vetor (Pessoa) e da quantidade 
de elementos do vetor ([10]).
Na linha 25 é declarada a variável contadora que será usada nos dois laços for a seguir.
Na linha 27 é iniciado o laço de leitura das dez pessoas. Na linha 28, cada pessoa é lida pelo método 
recebePessoa() e é armazenada no elemento de ordem i do vetor p (p[i]). Note que os índices de vetores 
em Java iniciam com o valor 0.
Na linha 31 é iniciado o laço de apresentação das dez pessoas. Cada elemento do vetor p é um objeto 
da classe Pessoa e, por isso, possui o método apresente(). Assim, na linha 32, cada elemento do vetor tem 
o seu método apresente() chamado.
49
Re
vi
sã
o:
 M
ac
ili
a/
Ro
se
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
1/
10
/1
5
TÓPICOS ESPECIAIS DE PROGRAMAÇÃO ORIENTADA A OBJETOS
 Saiba mais
Consulte a documentação do Java sobre a declaração e uso de arrays:
ORACLE. Arrays. The Java Tutorials. 2015a. Disponível em: <https://docs.oracle.
com/javase/tutorial/java/nutsandbolts/arrays.html>. Acesso em: 15 out. 2015.
2.9 Coleções
O uso de arrays foi útil para armazenar uma quantidade definida de objetos da classe Pessoa. 
Entretanto, para utilizar arrays, deve-se saber de antemão quantos elementos serão necessários para 
se criar o vetor. Quando não se sabe quantos elementos serão necessários, podemos utilizar estruturas 
dinâmicas de armazenamento de dados. O Java nos oferece um conjunto de estruturas deste tipo, as 
coleções. Uma coleção é um conjunto de variáveis semelhante a um array, mas que pode ter o seu 
tamanho modificado conforme a necessidade.
Vamos modificar o programa TestaPessoa para receber uma quantidade indefinida de pessoas. Este 
programa irá armazenar objetos da classe Pessoa enquanto o usuário desejar:
Figura 45 – Um programa que recebe uma quantidade indefinida de pessoas
50
Re
vi
sã
o:
 M
ac
ili
a/
Ro
se
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
1/
10
/1
5
Unidade I
Na linha 24 é declarada a estrutura dinâmica de armazenamento de dados pessoas, que é um ArrayList 
que irá armazenar elementos da classe Pessoa. Na mesma linha, a estrutura pessoas é instanciada. Por 
enquanto, a estrutura já existe, mas ainda não possui nenhum elemento dentro dela.
Nas linhas 27 a 32 é feita a leitura de uma quantidade não conhecida de pessoas. Na linha 27 
é declarada a variável que irá conter a resposta do usuário quando lhe for perguntado se ele deseja 
continuar cadastrando pessoas. Sua resposta será na forma de um número inteiro, como será visto 
adiante. Na linha 28 é iniciado o laço do-while, o que significa que o laço será executado ao menos uma 
vez. Na linha 29, o método recebePessoa() é executado para ler os dados de uma pessoa. Ele devolve 
um objeto da classe Pessoa, que é, então, passado como parâmetro para o método add() do ArrayList 
pessoas. Esse método adiciona seu parâmetro como um novo elemento do vetor dinâmico pessoas. Na 
linha 30 é usado o método showConfirmDialog da classe JOptionPane. Esse método exibe uma caixa de 
diálogo onde o usuário pode dar sua resposta por meio de botões. A versão do método utilizada pede 
quatro parâmetros: o primeiro é a janela pai (continuamos usando nenhuma); o segundo é a pergunta 
que será exibida para o usuário; o terceiro é o título da caixa de diálogo; o quarto define quais são os 
botões exibidos. As opções são YES_NO_CANCEL_OPTION e YES_NO_OPTION. Na linha 32, a resposta do 
usuário é verificada. Para que não tenhamos que decorar qual é o valor de cada resposta, utilizamos uma 
das constantes disponíveis para a resposta: YES-OPTION, NO_OPTION ou CANCEL_OPTION.
Nas linhas 35 a 37 um novo laço é feito, desta vez para exibir os dados de todas as pessoas cadastradas. 
A linha 35 utiliza uma forma alternativa do laço for. Esta forma recebe dois parâmetros separados por dois 
pontos (em vez de ponto e vírgula): o primeiro é uma definição de cada elemento da estrutura definida 
pelo segundo parâmetro. Essa linha pode ser lida como “para cada Pessoa p em pessoas”. O segundo 
parâmetro pode ser uma coleção ou um vetor. Esse laço, então, irá percorrer todos os elementos dentro de 
pessoas, irá chamar cada um de p e irá executar a linha 36, em que é chamado o método apresenta() de p.
 Saiba mais
Consulte a documentação disponível para coleções:
<https://docs.oracle.com/javase/tutorial/collections/index.html>.
Veja também a classe JOptionPane:
CLASS JOptionPane. Oracle.com, 2014. Disponível em: <https://docs.oracle.
com/javase/7/docs/api/javax/swing/JOptionPane.html>. Acesso em: 19 out. 2015.
2.10 Tratamento de exceções
Se você esteve testando os programas discutidos até aqui, deve ter encontrando algumas situações 
em que o programa parou abruptamente devido a alguma situação inesperada. Por exemplo, em qualquer 
um dos programas que cadastra o telefone de uma pessoa, se o usuário digitar uma letra (ou nada) no 
51
Re
vi
sã
o:
 M
ac
ili
a/
Ro
se
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
1/
10
/1
5
TÓPICOS ESPECIAIS DE PROGRAMAÇÃO ORIENTADA A OBJETOS
lugar de um número inteiro quando lhe é pedido para digitar o número de um telefone, o programa é 
encerrado informando uma mensagem de erro. Experimente fazer isso agora e observe a mensagem de 
erro que é apresentada na janela do Console. Na primeira linha da mensagem de erro é dito que ocorreu 
uma exceção do tipo NumberFormatException (em inglês). Isso indica que foi tentada a conversão para 
inteiro de um String que não representava um número inteiro.
Nós podemos modificar o programa para que ele perceba esta exceção e peça ao usuário para 
inserir novamente o número de telefone até que um número válido seja inserido. Isso é feito com o 
tratamento de exceções, que é composto de blocos try-catch ou try-catch-finally.
No bloco try é implementado o código que pode provocar uma exceção. No bloco catch é implementado 
o código que será executado caso uma exceção ocorra. No bloco opcional finally é implementado o código 
que deve ser executado tendo ocorrido uma exceção ou não. Ele é útil para fechar recursos que estavam 
sendo usados no bloco try, como arquivos, conexões com bancos de dados, conexões de rede etc.
Vamos modificar o método recebePessoa() da classe TestaPessoa para que ele se recupere de uma 
entrada de dados errada no número do telefone.
Figura 46 – Programa que trata exceções
52
Re
vi
sã
o:
 M
ac
ili
a/
Ro
se
 -
 D
ia
gr
am
aç
ão
: J
ef
fe
rs
on
 -
 2
1/
10
/1
5
Unidade I
O trecho que recebe o número de telefone de uma pessoa agora está entre as linhas 19 e 29. Na 
linha 19 é definida uma variável booleana que é verdadeira quando o usuário precisa inserir um número 
de telefone válido. Na linha 20 é iniciado o laço que será repetido quando o usuário insere caracteres 
inválidos para um número de telefone. Na linha 21 é iniciado o bloco try, que é o trecho de código 
que pode causar uma exceção. A exceção de formatação numérica pode ocorrer na linha 22, quando 
o método parseInt() tenta converter um String inválido para um número inteiro. Se a conversão for 
bem-sucedida, a linha 24 é executada e armazena o valor false na variável repete. Caso uma exceção 
de formatação