Você está na página 1de 55

Tópicos Especiais de

Programação Orientada a
Objetos
Autores: Prof. José Cassiano Grassi Gunji
Prof. Salatiel Luz Marinho
Prof. Luciano Soares de Souza
Professores conteudistas: José Cassiano Grassi Gunji / Salatiel Luz Marinho /
Luciano Soares de Souza

José Cassiano Grassi Gunji Luciano Soares de Souza

É mestre em Tecnologia da Informação Aplicada pelo Mestre em Engenharia de Produção pela Universidade
Centro Estadual de Educação Tecnológica Paula Souza e Paulista (UNIP) e bacharel em Ciência da Computação pela
bacharel em Sistemas de Informação pela Universidade mesma universidade.
Presbiteriana Mackenzie.
É coordenador do Curso Superior de Tecnologia em
Atua como docente em cursos de graduação em Análise e Desenvolvimento de Sistemas da UNIP, nas
Tecnologia da Informação, lecionando em disciplinas como modalidades presencial e EaD, leciona no curso as disciplinas
Programação Orientada a Objetos em Diversas Linguagens, Engenharia de Software, Projeto de Interface com o Usuário,
Análise de Sistemas, Lógica de Programação entre outras. Princípios de Sistemas de Informação entre outras, e orienta
o Projeto Integrado Multidisciplinar – PIM.
Salatiel Luz Marinho
Na Universidade Paulista também atua como Gerente
Pós‑graduado em Gestão de Projetos pelo Instituto de Integração de Sistemas. Possui mais de 20 anos de
Brasileiro de Tecnologia Avançada (IBTA) e formado em experiência com Tecnologia da Informação, atuando nas
Engenharia da Computação pela Universidade Paulista áreas de desenvolvimento de sistemas, engenharia de
(UNIP), trabalha há mais de dez anos no desenvolvimento de software, interação humano‑computador e automação
aplicações desktop e web, tendo prestado serviços a instituições industrial. Como professor e coordenador possui mais de
financeiras, de varejo e de seguros e a instituições acadêmicas. oito anos de experiência.

Leciona há mais de oito anos as disciplinas de


programação orientada a objetos na UNIP.

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

© 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.
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
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
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
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
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.

9
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.

10
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.

11
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 significa dizer 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.

12
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 Bytecode Máquina Programa em


Java Virtual Java 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.

13
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.

14
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.
15
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 IDEs disponí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.

16
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.
17
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)

18
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

19
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.
20
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.

21
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

22
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”

23
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 seja maximizada. 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.

24
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.

25
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:

26
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.

27
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.
28
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.

29
Unidade I

A exceção ao camel case está 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


Depende da JVM de true ou false
boolean Booleanos
cada plataforma
char 16 Caractere alfanumérico ‘\u0000’ a ‘\uffff’ (0 a 65535)
byte 8 ‑128 a 127
short 16 ‑32.768 a 32.767
Número inteiro
int 32 ‑2.147.483.648 a 2.147.483.647
long 64 ‑9223372036854775808 a 9223372036854775807
Intervalo negativo:
‑3,4028234663852886E+38 a ‑1,40129846432481707e‑45
float 32
Intervalo positivo:
Número em ponto 1,40129846432481707e‑45 a 3,4028234663852886E+38
flutuante Intervalo negativo:
‑1,7976931348623157E+308 a ‑4,94065645841246544e‑324
double 64
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:

30
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.

31
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().

32
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().
33
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

34
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étodos parse 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.

35
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

36
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.
37
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:

38
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:

39
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:
40
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 é:

41
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

42
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:

43
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:

44
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

45
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.

46
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:

47
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.

48
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

49
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

50
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

51
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 numérica tenha sido lançada no bloco try, ela será capturada pelo bloco catch na linha
25. Na linha 26 é exibida uma mensagem informativa ao usuário e a variável repete não terá seu
valor alterado. Na linha 29 o laço do‑while decide se ele deve reiterar ou não, dependendo do valor
armazenado pela variável repete. Ela contém o valor true se ocorreu uma exceção, false caso contrário.

As principais exceções são:

• ArithmeticException: erro aritmético, como uma divisão por zero.

• ArrayIndexOutOfBoundsException: foi acessado um índice de vetor fora do seu limite.

• NullPointerException: foi acessado um objeto que ainda não foi instanciado.

• NumberFormatException: foi tentada a conversão de um String em um formato numérico inválido.

Também é possível fazer o tratamento de mais de uma exceção em um mesmo bloco try:

Figura 47 – Tratamento de mais de uma exceção

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

Nas linhas 16 e 18 é feita a conversão da entrada de dados do usuário para int, o que pode causar
uma exceção NumberFormatException, que é tratada pela cláusula catch da linha 23.

Na linha 20 é feita a divisão de dois números inteiros, o que pode causar uma exceção
ArithmeticException, a qual é tratada pela cláusula catch da linha 26.

Saiba mais

Consulte a documentação sobre as exceções em Java:

<https://docs.oracle.com/javase/tutorial/essential/exceptions/index.html>.

Resumo

A tecnologia Java foi desenvolvida para ser uma tecnologia de


desenvolvimento de software multiplataforma, ou seja, seu código
compilado pode ser executado diretamente em qualquer plataforma que
esteja equipada com uma Máquina Virtual Java (JVM, sigla em inglês). Isso
é possível porque o código‑fonte Java é compilado para um bytecode. A
partir daí, esse bytecode é interpretado pela máquina virtual na plataforma
de execução.

O Java teve sua popularidade favorecida pelo surgimento da World Wide


Web, que viu na tecnologia uma maneira de incorporar interatividade e
multimídia às páginas web. Atualmente o Java é utilizado em praticamente
qualquer situação em que se utiliza programação, como aplicativos desktop,
corporativos distribuídos, para dispositivos móveis, para eletrodomésticos,
automóveis, entre outros.

Para se desenvolver em qualquer tecnologia Java, o mínimo necessário


é instalar o Kit de Desenvolvimento Java SE (Java SE SDK ou, simplesmente,
JDK). É possível programar utilizando um simples editor de arquivos de
texto e compilar usando o JDK. No entanto, são bastante populares as
Plataformas de Desenvolvimento Integradas (IDEs). Com elas, é possível
realizar a maioria das atividades relacionadas ao desenvolvimento de
software, como escrever código, compilar, depurar e implantar o sistema.

Pode‑se realizar a entrada e saída de dados de uma maneira simples


utilizando a classe JOptionPane, a qual disponibiliza métodos para a
exibição de caixas de diálogo. O método showMessageDialog() exibe uma
mensagem; o método showInputDialog() recebe dados do usuário e o

53
Unidade I

método showConfirmDialog() permite que o usuário responda a perguntas


cujas respostas podem ser simplesmente “sim”, “não” e “cancela”.

Todos os elementos que podem ser nomeados (variáveis, atributos,


métodos, parâmetros, classes, pacotes etc.) devem ter nomes escritos sem
espaços. Caso o programador escolha um nome composto por mais de uma
palavra, elas devem ser escritas juntas, com a primeira letra de cada palavra
a partir da segunda palavra em letra maiúscula. A primeira letra da primeira
palavra deve ser maiúscula caso o nome seja de uma classe (ou interface,
algo que será visto a seguir). Essa notação é conhecida como camel case.

Os tipos primitivos são os tipos de dados que a linguagem pode manipular


diretamente. Dados armazenados em uma variável de tipo primitivo podem
ser armazenados em outra variável de tipo primitivo de maior capacidade.
Já a atribuição na direção da variável de maior capacidade para a de
menor capacidade deve ser feita utilizando‑se alguma forma de conversão,
como a conversão direta, ou cast. Cada tipo primitivo possui uma classe
wrapper associada, que pode instanciar objetos que armazenam um valor
do tipo primitivo associado a ela, além de oferecer diversos métodos para
conversão de tipos. As classes wrapper devem ser utilizadas apenas para a
conversão de tipos. Já para uso normal no aplicativo, é recomendado o uso
dos tipos primitivos, que são muito mais eficientes em uso de memória e
no desempenho de processamento.

Classes são a estrutura básica de um programa orientado a objetos.


Elas são compostas basicamente de atributos e métodos. Uma classe deve
modelar algum conceito presente no sistema. Desta forma, os atributos da
classe modelam os dados desse conceito enquanto os métodos da classe
modelam os comportamentos desse conceito.

Algoritmos podem ser construídos utilizando‑se instruções de controle.


As instruções de controle do Java são inspiradas nas instruções de controle
do C e seguem a sua sintaxe básica. As instruções são o if, switch‑case, for,
while e do‑while.

Conjuntos maiores de dados podem ser armazenados em estruturas


homogêneas de dados, também conhecidas como vetores, ou ainda
arrays. Caso seja desejada uma estrutura de armazenamento dinâmica,
ou seja, que possa mudar de tamanho durante a execução do programa,
pode‑se utilizar as estruturas disponíveis no framework Collections,
como a classe ArrayList. Um objeto desta classe comporta‑se como um
array que pode mudar de tamanho conforme muda a quantidade de
elementos armazenados por ele.

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

Durante a execução de qualquer programa, podem ocorrer situações


de exceção, que podem (devem) ser tratadas pelo programa, de modo que
este não seja interrompido. O uso de tratamento de exceções pelo uso dos
blocos try‑catch e try‑catch‑finally tornam o sistema mais tolerante a
falhas. Assim, o programa pode se recuperar de alguma situação inesperada
e cumprir suas tarefas corretamente.

55

Você também pode gostar