APOSTILA JAVA OO LOGUSTI FINALv3

Prévia do material em texto

Orientação a objetos 
em Java – JOO 
 2016 v1 
 
 
 
 
 
 
 
 
LogusTI – Treinamento em Informática 
 
Tel (61) 3244 - 5000 
WhatsApp (61) 9 8548-0058 
SCS QD 02 BL C n 252 
BRASÍLIA – DF 
www.logusti.com.br 
logusti@logusti.com.br 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 2 
LogusTI 
 
A LogusTI nasceu da necessidade de oferecer novos treinamentos na área de Tecnologia da 
Informação em Brasília, visto que este segmento é escasso na Capital Federal. 
A excelência dos serviços prestados pela LogusTI está apoiada em profissionais especializados, 
processos estabelecidos e uma larga experiência em seus profissionais. O capital humano é um 
elemento chave na estratégia de atuação da empresa, que investe continuamente na atualização e 
capacitação de seus profissionais, propiciando um ambiente encorajador para serem os melhores 
naquilo que fazem. 
A alta qualidade dos serviços prestados aliada ao compromisso em gerar resultados e 
proporcionar maior vantagem competitiva a seus clientes tem propiciado a LogusTI relacionamentos 
duradouros e bem sucedidos com empresas de diversos segmentos de mercado. 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 3 
Sobre o autor Gleidson Porto 
 
 Bacharel em Ciência da Computação, Pós-graduação em Sistemas Orientados a Objetos, MBA 
em Gestão Estratégica de TI pela FGV e Mestre em Gestão Estratégica das Organizações. 
 Tem experiência na área de Ciência da Computação, com ênfase Fábrica de Software, 
Engenharia de Software e Governança Estratégica de TI; 
 Atuou como Gerente de Projetos Estratégicos de TI na CAPGEMINI/CPMBRAXIS, a maior 
empresa de TI europeia e sétima maior do mundo, nas operações do Ministério de Ciência e 
Tecnologia, Caixa Econômica Federal, Brasiltelecom, Oi e Embratur. 
 Atuou como Coordenador de TI pela Stefanini IT Solutions, maior empresa de TI brasileira, em 
operações de missão crítica de TI na BrasilTelecom. 
 Atuou também professor de Informática da EIBNET – Escola de Informática de Brasília com 
mais de 15.000 horas de treinamentos em JAVA, SCRUM, COBIT, APF, RUP e ITIL. 
 Foi professor de ensino superior de TI no Instituto Fátima em Brasília – DF durante 6 anos. 
 Hoje atua como coordenador da divisão de Desenvolvimento de Software da autarquia pública 
CFM - Conselho Federal de Medicina e professor de ensino superior da Faculdade JK. 
 Atua também como instrutor da LogusTI. 
 Possui as certificações internacionais IBM Certified Solution Designer - Sun Certified Java 
Programmer, IBM Rational Unified Process V7.0, COBIT, ITIL Foundation Certified e 
ScrumMaster Certified pela ScrumAlliance. 
 
 
 
 
 
 
https://www.linkedin.com/in/gleidson-porto-06817637/ 
gleidsonporto@gmail.com 
 http://lattes.cnpq.br/6540446452817806 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 4 
Sumário 
1 INTRODUÇÃO .............................................................................................................................................. 8 
1.3 História da Linguagem Java ......................................................................................................................... 9 
2 A LINGUAGEM JAVA ................................................................................................................................. 10 
2.1 Java ......................................................................................................................................................... 10 
2.2 Máquina Virtual ......................................................................................................................................... 10 
2.3 Garbage Collection ................................................................................................................................... 11 
2.4 Instalando o Java ...................................................................................................................................... 12 
2.4.1 Instalando o JDK .................................................................................................................................... 12 
2.4.2 Configurando o Java no Windows ........................................................................................................... 13 
2.4.3 Confirmando a instalação e configuração do Java .................................................................................... 15 
2.5 Compilando e executando o primeiro programa .......................................................................................... 15 
3 AMBIENTE INTEGRADO DE DESENVOLVIMENTO - ECLIPSE ................................................................... 17 
3.1 O Eclipse .................................................................................................................................................. 17 
3.2 Característica e Ferramentas ..................................................................................................................... 17 
3.3 Instalando o Eclipse .................................................................................................................................. 18 
3.4 Conhecendo o Eclipse ............................................................................................................................... 18 
4 SINTAXE DA LINGUAGEM JAVA................................................................................................................ 20 
4.1 Delimitadores em Java .............................................................................................................................. 20 
4.2 Identificadores e palavras reservadas......................................................................................................... 21 
4.3 Declarando variáveis em Java ................................................................................................................... 23 
4.5 - Convenções de codificação ..................................................................................................................... 26 
4.6 Exercícios........................................................................................................................................ 27 
5 EXPRESSÕES ............................................................................................................................................ 28 
5.1 Operadores lógicos e aritméticos ............................................................................................................... 28 
5.2 Concatenação de Strings com o operador + ............................................................................................... 29 
Alguns métodos úteis em dados do tipo String:................................................................................................. 29 
5.3 Promoção e Casting .................................................................................................................................. 30 
5.4 Operadores de deslocamento (>>, <<, >>>)................................................................................................ 31 
5.5 Circuitos lógicos ........................................................................................................................................ 31 
5.6 Exercícios........................................................................................................................................ 32 
6 FLUXO DE CONTROLE .............................................................................................................................. 33 
6.1 Ramificação if,else ................................................................................................................................... 33 
6.2 Ramificação switch ................................................................................................................................... 34 
6.3 Repetição for ............................................................................................................................................ 35 
6.4 Repetição while ........................................................................................................................................ 36 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 5 
6.5 Comandos especiais de controle de fluxo: break, continue e label ................................................................ 37 
6.6 Lendo valores do teclado ........................................................................................................................... 38 
6.7 Exercícios................................................................................................................................................. 38 
7 AGRUPAMENTO DE DADOS (ARRAYS)..................................................................................................... 39 
7.1 Declarando e criando Arrays ...................................................................................................................... 39 
7.2 Modificando o conteúdo de um array .......................................................................................................... 41 
7.3 Acessando o conteúdo de um array ........................................................................................................... 41 
7.4 Percorrendo um Array ............................................................................................................................... 42 
7.5.1 Ordenando um Array .............................................................................................................................. 43 
7.5.2 Duplicando um Array .............................................................................................................................. 43 
7.5.3 Preenchendo um Array ........................................................................................................................... 43 
7.6 Arrays multidimensionais ........................................................................................................................... 44 
7.7 Array esparso ........................................................................................................................................... 44 
7.8 Exercícios........................................................................................................................................ 45 
8 ORIENTAÇÃO A OBJETOS(OO) BÁSICA ................................................................................................... 46 
8.1 Fundamentos da Programação Orientada a Objetos ................................................................................... 46 
8.2. Paradigma Orientado por Objetos ............................................................................................................. 46 
8.3 Principais conceitos de POO...................................................................................................................... 46 
8.3.1 Objetos .................................................................................................................................................. 46 
8.3.2 Atributos e métodos................................................................................................................................ 48 
8.3.3 Classes ................................................................................................................................................. 49 
8.3.3 Instanciação........................................................................................................................................... 50 
8.4 - Exercício - Conceitos OO ........................................................................................................................ 51 
8.5 – Classes e Objetos em Java ..................................................................................................................... 52 
8.5.1 Criando objetos em Java ........................................................................................................................ 52 
8.5.2 Referências ........................................................................................................................................... 53 
8.5.3 Manipulando Atributos ............................................................................................................................ 54 
8.5.4 Valores Padrão ...................................................................................................................................... 54 
8.6 Exercícios Complementares ...................................................................................................................... 56 
9 OO - HERANÇA, POLIMORFISMO E INTERFACES .................................................................................... 57 
9.1 Objetos e Construtor ................................................................................................................................. 57 
9.2 Herança ................................................................................................................................................... 57 
9.3 Polimorfismo ............................................................................................................................................. 59 
9.3.1 Polimorfismo - Sobreescrita .................................................................................................................... 60 
9.3.2 Polimorfismo – Sobrecarga ..................................................................................................................... 61 
9.4 Exercício - Polimorfismo ............................................................................................................................ 62 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 6 
9.5 Interfaces ................................................................................................................................................. 63 
10 OO - CLASSES ABSTRATAS.................................................................................................................... 65 
11 MODIFICADORES JAVA ........................................................................................................................... 66 
11.1 Introdução .............................................................................................................................................. 66 
11.2 Modificadores de Acesso ......................................................................................................................... 66 
11.2.1 Private ................................................................................................................................................. 67 
11.2.2 Protected ............................................................................................................................................. 68 
11.2.3 Public .................................................................................................................................................. 69 
11.2.4 Default (padrão) ................................................................................................................................... 69 
11.3 Outros Modificadores ..............................................................................................................................69 
11.3.1 Final .................................................................................................................................................... 69 
11.3.2Abstract ................................................................................................................................................ 70 
11.3.3 Static ................................................................................................................................................... 70 
11.3.4 Transient ............................................................................................................................................. 71 
11.3.5 Synchronized ....................................................................................................................................... 71 
11.3.6 Volatile ................................................................................................................................................ 71 
11.3.7 Native .................................................................................................................................................. 71 
11.4 Encapsulamento ..................................................................................................................................... 71 
11.4.1 Métodos Getters e Setters .................................................................................................................... 72 
11.5 Exercício ................................................................................................................................................ 73 
12 EXCEÇÕES – CONTROLANDO OS ERROS .............................................................................................. 75 
12.1 Tratamento de exceções ......................................................................................................................... 75 
12.2 Erros e Exceções de runtime ................................................................................................................... 77 
12.3 Propagando exceções ............................................................................................................................. 77 
12.4 Definindo e gerando exceçoes ................................................................................................................. 78 
12.5 Hierarquia de exceções Java ................................................................................................................... 79 
13 THREADS .......................................................................................................................................... 81 
13.1 Conceito de Threads ............................................................................................................................... 81 
13.2 Ciclo de Vida de uma Thread ................................................................................................................... 82 
13.2.1 Criando Threads................................................................................................................................... 82 
13.2.2 Iniciando Threads ................................................................................................................................. 83 
13.2.3 Fazendo Thread Esperar ...................................................................................................................... 83 
13.2.4 Finalizando Threads ............................................................................................................................. 83 
13.2.5 Verificando se Threads estão Executando/Pronta/Esperando ou Novas/Mortas........................................ 83 
13.3 Implementando Threads em java ............................................................................................................. 83 
13.4 Escalonamento de Threads ..................................................................................................................... 85 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 7 
13.5 Exercícios ............................................................................................................................................... 88 
14 API JAVA - JAVA.IO ................................................................................................................................ 89 
14.1 Classe InputStream ................................................................................................................................. 89 
14.2 Lendo um arquivo ................................................................................................................................... 90 
14.3 OutputStream ......................................................................................................................................... 92 
14.4 Reader ................................................................................................................................................... 92 
14.5 Writer ..................................................................................................................................................... 92 
14.6 Buffers.................................................................................................................................................... 93 
14.7 Exercícios ............................................................................................................................................... 94 
15 COLLECTIONS FRAMEWORK .................................................................................................................. 95 
15.1 – Introdução............................................................................................................................................ 95 
15.2 – Tipos de Coleções ................................................................................................................................ 95 
15.2.1 – Lista.................................................................................................................................................. 98 
15.2.2 – Conjunto ........................................................................................................................................... 99 
15.2.3 – Mapas............................................................................................................................................... 99 
15.3 – Exercício ............................................................................................................................................ 101 
RESPOSTAS DO EXERCÍCIOS.................................................................................................................... 102 
REFERÊNCIAS ............................................................................................................................................ 137 
 
 
 
 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 8 
1 INTRODUÇÃO 
 
1.1 Sobre a LogusTI 
A LogusTI nasceu da necessidade de oferecer novos treinamentos na área de Tecnologia 
da Informação em Brasília, visto que este segmento é escasso na Capital Federal. 
A excelência dos serviços prestados pela LogusTI está apoiada em profissionais 
especializados, processos estabelecidos e uma larga experiência em seus profissionais. O 
capital humano é um elemento chave na estratégia de atuação da empresa, que investe 
continuamente na atualização e capacitação de seus profissionais, propiciando um ambiente 
encorajador para serem os melhores naquilo que fazem. 
A alta qualidade dos serviços prestados aliada ao compromisso em gerar resultados e 
proporcionarmaior vantagem competitiva a seus clientes tem propiciado a LogusTI 
relacionamentos duradouros e bem sucedidos com empresas de diversos segmentos de 
mercado. 
O principal objetivo da LogusTI é promover treinamentos de máxima qualidade que 
relacionados às principais tecnologias utilizadas pelas empresas. Por meio desses 
treinamentos, seus alunos se tornam capacitados para atuar no mercado de trabalho. 
 
1.2 Objetivo 
O objetivo fundamental dos treinamentos da LogusTI é transmitir os conhecimentos necessários 
para que os seus alunos possam atuar no mercado de trabalho na área de Tecnologia da Informação. 
A plataforma Java é a mais utilizada no desenvolvimento de software no mundo. Para utilizar os 
recursos oferecidos por essa plataforma de forma eficiente, é necessário possuir conhecimento sólido 
em orientação a objetos. 
Assim sendo, esta apostila da LogusTI tem como intuito ensinar Java de uma maneira simples e 
objetiva. 
Esperamos que você aproveite esse material, e que ele possa contribuir positivamente para 
construção do conhecimento acerca da programação Java. 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 9 
1.3 História da Linguagem Java 
 
 
Java é uma linguagem de programação interpretada orientada a objetos 
desenvolvida na década de 90 por uma equipe de programadores chefiada 
por James Gosling, na empresa Sun Microsystems, adquirida pela Oracle. 
Diferente das linguagens de programação convencionais, que são 
compiladas para código nativo, a linguagem Java é compilada para um 
bytecode que é executado por uma máquina virtual. A linguagem de 
programação Java é a linguagem convencional da Plataforma Java, mas 
não é a sua única linguagem. 
Em 1991, na Sun Microsystems, foi iniciado o Green Project, o berço do Java, uma linguagem de 
programação orientada a objetos. Os mentores do projeto eram Patrick Naughton, Mike Sheridan, e James 
Gosling. Eles acreditavam que, eventualmente, haveria uma convergência dos computadores com os 
equipamentos e eletrodomésticos frequentemente usados pelas pessoas no seu dia-a-dia. 
Para provar a viabilidade desta ideia, 13 pessoas trabalharam arduamente durante 18 meses. No verão de 
1992 eles emergiram de um escritório de Sand Hill Road, no Menlo Park, com uma demonstração funcional da 
ideia inicial. O protótipo se chamava *7 (lê-se “Star Seven”), um controle remoto com uma interface gráfica 
touchscreen. Para o *7, foi criado um mascote, hoje amplamente conhecido no mundo Java, o Duke. O trabalho 
do Duke no *7 era ser um guia virtual ajudando e ensinando o usuário a utilizar o equipamento. O *7 tinha a 
habilidade de controlar diversos dispositivos e aplicações. James Gosling especificou uma nova linguagem de 
programação para o *7. Gosling decidiu batizá-la de “Oak”, que quer dizer carvalho, uma árvore que ele podia 
observar quando olhava através da sua janela. 
O nome da linguagem desenvolvida pelo projeto Green foi mudada de Oak para Java, que foi uma 
homenagem à uma ilha da Indonésia de onde os Norte-Americanos importavam o café que era consumido pela 
equipe de James Gosling. Ate 1994, não havia uma aplicação definida para o Java. Foi quando Jonathan Payne e 
Patrick Naughton criaram um novo navegador para Web que podia executar programas escritos em Java 
(applets), batizado de Web Runner. E em 1996, em uma iniciativa inédita, a Sun Microsystems resolveu 
disponibilizar gratuitamente um kit de desenvolvimento de software para a comunidade, que ficou conhecido como 
Java Developer`s Kit (JDK). Desde então a aceitação da tecnologia Java cresceu rapidamente entre empresas e 
desenvolvedores. A Sun Microsystems lançou o JDK 1.1 com melhorias significativas para o desenvolvimento de 
aplicações gráficas e distribuídas. Depois disso, a empresa continuou lançando novas versões gratuitas com 
novas melhorias e recursos. 
Em abril de 2009, a Oracle ofereceu US$ 7,4 bilhões pela aquisição da Sun Microsystems e a proposta foi 
aceita. Essa aquisição deu à Oracle a propriedade de vários produtos, incluindo o Java e o sistema operacional 
Solaris. Em comunicado, a Oracle afirmou que o Java foi o software mais importante adquirido ao longo de sua 
história. Muitas especulações foram feitas acerca do futuro do Java depois de passar a ser propriedade da Oracle. 
Mais com certeza essa aquisição contribuiu muito para que o Java tivesse um salto qualitativo. 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 10 
2 A LINGUAGEM JAVA 
2.1 Java 
Java é uma linguagem de programação orientada a objetos desenvolvida pela antiga Sun Microsystems, 
agora Oracle. Modelada depois de C++, a linguagem Java foi projetada para ser pequena, simples e portável a 
todas as plataformas e sistemas operacionais, tanto o código fonte como os binários. Esta portabilidade é obtida 
pelo fato da linguagem ser interpretada, ou seja, o compilador gera um código independente de máquina chamado 
byte-code. No momento da execução este byte-code é interpretado por uma máquina virtual instalado na máquina. 
Para portar Java para uma arquitetura hadware/s específica, basta instalar a máquina virtual 
(interpretador). Além de ser integrada à Internet, Java também é uma excelente linguagem para desenvolvimento 
de aplicações em geral. Dá suporte ao desenvolvimento de software em larga escala. 
2.2 Máquina Virtual 
De acordo com a especificação da SUN, a máquina virtual do Java pode ser vista como: 
 
 
 
 
Para um programa Java ser executado, ele precisa passar pelo processo ilustrado na figura abaixo: 
 
 
 
 
 
 
 
 
 
 
Figura 1- JVM 
 
O código é compilado, gerando um conjunto de instruções chamado de byte-code. Esse byte-code é 
aplicado à Máquina Virtual Java (JVM) que se encarrega de interpretar os comandos para o sistema 
operacional onde o programa está rodando. Ou seja, a máquina virtual traduz as instruções do código Java para 
instruções válidas no sistema operacional em que está rodando. Se essa portabilidade fosse requerida em C, o 
código deveria ser compilado várias vezes – uma para cada sistema operacional desejado. No caso do Java, o 
código é compilado apenas uma vez, gerando o byte-code. Esse byte-code poderá então ser interpretado por 
qualquer máquina virtual Java, rodando em Linux, Windows, Palm OS, Solaris ou qualquer outro sistema 
operacional que possua uma máquina virtual Java implementada. (Compile once, run anywhere). 
Uma máquina imaginária que é implementada via software ou hardware. Um código a ser 
executado por essa máquina deve ser gravado em um arquivo com extensão .class. e 
possuir um código compatível com as instruções Java. 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 11 
 
Uma JVM possui definições concretas para a implementação dos seguintes itens: 
 Conjunto de instruções (equivalentes às instruções da CPU) 
 Conjunto de registradores 
 Formato padrão de classes 
 Pilha de memória 
 Pilha de objetos coletados pelo garbage-collector 
 Área de memória 
 
IMPORTANTE: a JVM não permite que um programa Java acesse recursos de hardware diretamente, protegendo 
o computador de operações perigosas, como acesso à regiões protegidas da memória ou formatação física do 
disco rígido. 
 
Um programa Java só é executado caso o seu byte-code passe pela verificação de segurança da JVM, que 
consiste em dizer que: 
 O programa foi escrito utilizando-se a sintaxe e semântica da linguagem Java 
 Não existem violações de áreas restritas de memória no código 
 O código não gera Stack Overflow 
 Os tipos de parâmetrosdos métodos são corretos 
 Não existe nenhuma conversão ilegal entre dados do programa, como a tentativa de conversão de inteiros 
em ponteiros 
 O acesso a objetos está corretamente declarado 
Caso alguma das condições acima não seja satisfeita, a máquina virtual Java causará um erro de execução 
(runtime error). 
 
 
 
 
 
2.3 Garbage Collection 
Durante a execução de um programa de computador, ocorre a alocação e liberação dinâmica de memória 
RAM. Dados são escritos e lidos da memória do computador satisfazendo os requisitos de cada programa. Em 
linguagens tradicionais como Pascal, Basic e C/C++, o programador é responsável por controlar essa alocação, 
impedindo o estouro de memória (stack overflow) e outros problemas, como o acesso indevido a áreas reservadas 
de memória. Para facilitar a vida dos programadores, e evitar os erros comuns associados à alocação de 
memória, a linguagem Java introduziu um novo conceito: o garbage-collection. 
Garbage-collection é um mecanismo de controle automático de alocação e liberação de memória. 
Quando uma variável é declarada em um código de computador, a JVM cria um ponteiro para uma área 
de memória equivalente ao tamanho do tipo de dado utilizado por essa variável. Quando essa variável é 
associada a outra região de memória, a JVM coloca o espaço alocado anteriormente em uma pilha de objetos em 
Mais sobre 
Geralmente, as máquinas virtuais utilizam uma estratégia de compilação chamada Just-in-time 
compilation (JIT). Nessa abordagem, o código de máquina pode ser gerado diversas vezes durante o 
processamento de um programa com o intuito de melhorar a utilização dos recursos disponíveis em um 
determinado instante da execução. 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 12 
desuso. Caso o computador fique com pouca memória disponível, a JVM remove objetos dessa pilha, permitindo 
que esse espaço de memória seja realocado. 
O processo de garbage-collection ocorre automaticamente durante a execução de um programa Java. O 
programador não precisa se preocupar com aritmética de ponteiros (grande dificuldade em linguagens como C e 
Pascal). 
2.4 Instalando o Java 
Para desenvolver aplicações Java, o programador deve instalar em sua máquina um Java Development 
Kit(JDK). Um JDK contém diversas ferramentas utilizadas na criação de um programa Java. Mostraremos a 
seguir como instalar um JDK no sistema operacional Windows. 
 JDK: Faça o download da versão mais atual aqui: 
 http://www.oracle.com/technetwork/java/javase/downloads/index.html 
 
Observe abaixo que a Oracle disponibiliza a versão do JDK para vários sistemas operacionais. Vamos 
utilizar a versão jdk-8u101-windows-x64.exe para o Windows x64 de 193.68 MB. 
 
 
Figura 2 – Site da Oracle para download do JDK 
 
O procedimento de instalação no Windows é muito simples: basta você executar o arquivo e seguir os 
passos abaixo: 
2.4.1 Instalando o JDK 
 
Execute o instalador do JDK (jdk-8u101-windows-x64.exe) e siga as instruções até concluir (next > next > 
finish ), se desejar, é possível informar o diretório de instalação (que vai ser muito importante para 
realizarmos a configuração do JDK – Figura 3). 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 13 
 
Figura 3 – Tela de Instalação do JDK 
 
Juntamente com o JDK será feita a instalação do JRE (Java Runtime Environment) que é o aplicativo que 
permite executar os programas em JAVA no seu sistema operacional. 
 
2.4.2 Configurando o Java no Windows 
 
Clique com o botão direito em Computador e siga as opções Propriedades > Configurações 
avançadas do sistema > (aba Avançado) Variáveis de Ambiente… 
 
Crie/edite as variáveis do sistema listadas abaixo: 
 
JAVA_HOME 
 Informe o diretório da instalação do JDK (Figura 4). 
 Exemplo C:\Program Files\Java\jdk1.8.0_101 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 14 
 
Figura 4 – Configuração da variável de ambiente “JAVA_HOME”. 
 
PATH 
 Informe %JAVA_HOME%\bin (Figura 5). 
 
Figura 5– Configuração da variável de ambiente “PATH”. 
 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 15 
2.4.3 Confirmando a instalação e configuração do Java 
 
Para confirmar que a instalação e configuração do JAVA foi realizada com sucesso, execute os comandos 
“java -version” e “javac -version” no prompt de comando. O resultado esperado está na Figura 6. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Figura 6 – Validação de instalação e configuração do Java 
 
 
 
 
 
 
2.5 Compilando e executando o primeiro programa 
Vamos criar um simples programa para entendermos como funciona o processo de compilação e 
execução. Utilizaremos a linguagem Java, que é amplamente adotada nas empresas. Observe o código do 
exemplo de um programa escrito em Java que imprime uma mensagem na tela: 
1 public class OlaMundo { 
2 public static void main ( String [] args ) { 
3 System.out.println("Olá Mundo!"); 
4 } 
5 } 
Código Java 2.5: OlaMundo.java 
O código fonte Java deve ser colocado em arquivos com a extensão .java. Agora, não é necessário 
entender todo o código do exemplo. Basta saber que toda aplicação Java precisa ter um método especial 
chamado main para executar. 
O próximo passo é compilar o código fonte, para gerar um executável que possa ser processado pela 
máquina virtual do Java. O compilador padrão da plataforma Java ( javac) pode ser utilizado para compilar esse 
arquivo. O compilador pode ser executado pelo terminal. 
Mais sobre 
No Linux, são as mesmas variáveis, mas o PATH é separado por :. Nos Windows velhos, como o 98, você 
deve alterar isso no autoexec.bat. Nos Windows mais novos, como NT, 2000, e XP, procure onde você pode 
adicionar novas variáveis de ambiente (em Iniciar - Painel de Controle – Sistema – Avançado Variáveis de 
Sistema). No Linux, geralmente a alteração deverá ser feita no arquivo ~/.bashrc se você não tiver privilégios 
de administrador. 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 16 
C:\LOGUSTI\EXEMPLOS> dir 
OlaMundo.java 
C:\LOGUSTI\EXEMPLOS>javac OlaMundo.java 
C:\LOGUSTI\EXEMPLOS> dir 
OlaMundo.class 
OlaMundo.java 
O código gerado pelo compilador Java é armazenado em arquivos com a extensão .class. No exemplo, o 
programa gerado pelo compilador é colocado em um arquivo chamado OlaMundo.class e ele pode ser executado 
através de um terminal. 
C:\LOGUSTI\EXEMPLOS> dir 
OlaMundo.class 
OlaMundo.java 
C:\LOGUSTI\EXEMPLOS> java OlaMundo 
Olá Mundo! 
Importante 
Antes de compilar e executar um programa escrito em Java, é necessário que você tenha instalado e 
configurado em seu computador o JDK (Java Development Kit). 
 
 
2.5 – Exercícios 
 
 
 
 
 
 
Mais sobre 
Quando uma aplicação ou biblioteca Java é composta por diversos arquivos .class, podemos “empacotá-los” em um 
único arquivo com a extensão .jar com o intuito de facilitar a distribuição da aplicação ou da biblioteca. 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 17 
3 AMBIENTE INTEGRADO DE DESENVOLVIMENTO - 
ECLIPSE 
3.1 O Eclipse 
Na prática, alguma ferramenta de desenvolvimento é adotada para aumentar a produtividade. Essas 
ferramentas são chamadas IDE (Integrated Development Environment - Ambiente de Desenvolvimento Integrado).Uma IDE é uma ferramenta que provê facilidades para o desenvolvedor realizar as principais tarefas relacionadas 
ao desenvolvimento de um software. 
No caso específico da plataforma Java, a IDE mais utilizada é o Eclipse. Essa ferramenta é bem 
abrangente e oferece recursos sofisticados para o desenvolvimento de uma aplicação Java. Além disso, ela é 
gratuita. 
É a IDE líder de mercado. Formada por um consórcio liderado pela IBM, possui seu código livre. 
As diversas distribuições do Eclipse podem ser obtidas através do site http://www.eclipse. org/. 
Descompacte o arquivo e pronto; basta rodar o executável. 
3.2 Característica e Ferramentas 
A IDE Eclipse é um programa que reúne ferramentas de apoio ao desenvolvimento de software 
possibilitando uma agilidade maior no processo de construção de um software. 
 
 Editor – edita o código-fonte do programa escrito 
 Compiler – compila o código-fonte transformando em código de máquina. 
 Linker – são os vários pedaços de códigos reunidos transformando em um executável. 
 Debugger – processo de se localizar erros(famosos bugs) . 
 Modelling - criação do modelo de classes, objetos, interfaces, associações e interações 
dos artefatos envolvidos no software. 
 Geração de código - A IDE gera códigos(templates) comumente utilizados 
possibilitando algumas soluções. 
 Deploy - auxilia no processo de criação do instalador do software. (no nosso caso os famosos 
*.jar). 
 Automated tests - realiza testes no software de forma automatizada, 
 Refactoring - consiste na melhoria constante do código-fonte do software para construção 
de código mais otimizado. 
 
IMPORTANTE 
Preciso pagar pela ferramenta Eclipse? 
Não, é uma ferramenta OPEN SOURCE conforme mencionado acima é um software livre. 
 
Porque o Eclipse faz tanto sucesso? 
“Na prática ele cria um modelo de Open Innovation Network, onde empresas concorrentes podem criar redes de 
inovação, cooperando no desenvolvimento de softwares Open Source...” - Cezar Taurion(IBM) 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 18 
 
 
3.3 Instalando o Eclipse 
O Eclipse roda direto de um arquivo executável. Realize o download por meio do link 
http://www.eclipse.org/downloads/packages/eclipse-ide-java-developers/neonr e extraia o 
pacote “.zip” do Eclipse (eclipse-java-neon-R-win32-x86_64.zip) para o diretório de sua preferência. Execute o 
arquivo eclipse.exe para iniciar. 
Ao iniciar o eclipse, você deve definir o workspace de trabalho (que é a pasta onde será mantido seu 
espaço de trabalho – Figura 7). 
 
Figura 7 – Configuração do workspace do Eclipse. 
 
Figura 8 – Tela inicial do Eclipse. 
3.4 Conhecendo o Eclipse 
O eclipse possui uma interface amigável com as ferramentas agrupadas por perspectivas(Views e 
Perspective). Iremos utilizar a perspectiva Java que apresenta os seguintes recursos: 
 
 1 - Package Explorer - janela contendo todos os projetos desenvolvidos, cada projeto representa um 
programa ou aplicação; 
 2 - Problems - janela que indica erros contidos no código ordenados pela linha em que acontece; 
 3 - Console - janela responsável pela saída de padrão para mensagens proveniente qualquer 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 19 
programa Java; 
 4 - Janela com código - janela onde aparecerá o código fonte do arquivo .java selecionado no 
momento.Tal janela aparece automaticamente ou dando 2 cliques em algum arquivo .java presente na 
janela Package Explorer. 
 
 
 
 
 
 
 
 
 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 20 
4 SINTAXE DA LINGUAGEM JAVA 
4.1 Delimitadores em Java 
Em um código-fonte Java, alguns símbolos são utilizados pelo compilador para diferenciar comandos, 
blocos de comandos, métodos, classes, etc. Tais símbolos, chamados de delimitadores, são 
enumerados abaixo: 
 
Comentários 
Comentários servem para identificar a função de um comando, um trecho de código, ou um 
método. Além disso, os comentários podem ser utilizados para documentar aspectos de desenvolvimento 
de um programa: como o nome da empresa que o desenvolveu, nome dos programadores, versão, etc. 
Existem dois tipos de comentário: o simples e o de documentação. 
O comentário simples é delimitado por duas barras // e termina ao final de uma linha, conforme 
abaixo. 
 
 // comentário simples: não será incluído na documentação 
 // do programa (note que comentários simples exigem 
 // um par de barras para cada linha). 
 
 
O comentário de bloco é delimitado por duas barras /* e termina com */ ao final de uma linha. 
 /* Comentário de bloco 
 utilizado para comentar 
 várias linhas de código */ 
 
O comentário de documentação é iniciado pelo símbolo /** e encerrado pelo símbolo */, podendo 
conter várias linhas de texto e linhas em branco. Esse tipo de comentário será utilizado pela ferramenta 
geradora de documentação javadoc, que acompanha o ambiente de desenvolvimento SDK. 
Todo o texto entre os delimitadores de comentários do Javadoc é ignorado pelo compilador. 
Permitem incorporar a documentação do programa diretamente nos programas. O programa utilitário 
javadoc lê comentários no estilo Javadoc e utiliza-os para preparar a documentação do seu programa no 
formato HTML. 
Ponto e vírgula, blocos e espaços em branco: em Java, todo comando é terminado por um 
ponto e vírgula (;). 
Exemplo: 
 System.out.println ("note o ponto e vírgula no final  "); 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 21 
Um bloco é formado por um conjunto de instruções delimitadas por chaves, como no exemplo abaixo: 
 /** Exemplo de bloco */ 
 { // Chamamos essa chave de início de bloco 
 int ano; // Note o ponto e vírgula 
 ano = 2002; // sempre ao final de um comando Java 
 } // Chamamos essa chave de final de bloco 
 
O espaço em branco, quebra de linha e caracteres de tabulação são permitidos em qualquer trecho do 
código-fonte, devendo ser utilizados para realçar o aspecto visual de seu código. 
 
IMPORTANTE 
Apesar do aspecto visual do código-fonte não ter nenhum impacto no desempenho de um programa 
Java, o uso de endentação é uma característica de bons códigos-fonte. Lembre-se que você não será o 
único a ler o código-fonte de seus programas, portanto escreva-o da maneira mais organizada e legível 
possível. 
 
 
 
 
4.2 Identificadores e palavras reservadas 
Em Java, um identificador é uma sequência de símbolos UNICODE (64K símbolos) que começa 
com uma letra, um símbolo subscrito _, ou o caractere $. Os demais símbolos de um identificador podem 
conter também números. Identificadores são case-sensitive e não tem um tamanho máximo estabelecido. 
Apesar da tabela UNICODE ser bastante extensa, um bom hábito de programação é utilizar somente 
letras do alfabeto (a-Z) e números para nomear identificadores. 
Exemplo de identificadores válidos em Java: 
 data
 _data
 $data
 data_do_mês
 data1
 uma_variável_pode_SER_bastante_extensa_e_conter_Numeros234876238476 
 data_public_class_NoteQueEsseIdentificadorContemPalavrasReservadas
 
Apesar desta "liberdade" de opções para nomes de identificadores, algumas palavras não são 
permitidas. Tais palavras são ditas palavras reservadas, e representam o conjunto de comandos que 
forma a sintaxe da linguagem Java. O conjunto de palavras reservadas em Java é o seguinte: 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICAPÁGINA 22 
abstract double int strictfp 
boolean else interface super 
break extends long switch 
byte final native synchronized 
case finally new this 
catch float package throw 
char for private throws 
class goto protected transient 
const if public try 
continue implements return void 
default import short volatile 
do instanceof static while 
 
IMPORTANTE 
Você não precisa se preocupar em memorizar o nome das palavras reservadas em Java. À medida que 
você for praticando a programação em Java, isso se tornará natural. Além disso, o compilador acusa um 
erro de nomenclatura quando você tenta utilizar uma palavra reservada para nomear uma variável, um 
método ou uma classe. 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 23 
4.3 Declarando variáveis em Java 
Uma variável é sempre declarada seguindo do seguinte esquema: 
<tipo> + <espaço> + identificador + ; 
ou 
<tipo> + <espaço> + identificador + = + valor + ; 
onde: 
<tipo> é um tipo primitivo de dados ou o nome de uma classe ou interface 
identificador é o nome da variável 
valor é o valor atribuído à variável. 
Exemplos: 
 int number1 = 10; // primeiro número a somar 
 int number2 = 20; // segundo número a somar 
 int sum; // soma de number1 e number2 
 
IMPORTANTE 
Caso você declare uma variável e não atribua nenhum valor, ela não poderá ser utilizada em um código 
Java – a tentativa de utilizar uma variável não inicializada em Java gerará um erro de compilação. 
 
IMPORTANTE 
Veremos mais adiante que Java possui um mecanismo de inicialização de variáveis de seus tipos 
primitivos, mas o aluno deve evitar considerar essa inicialização como prática de programação. De fato, 
esta inicialização automática não funciona para variáveis de tipos agregados ou abstratos de dados e 
também que o escopo das variáveis – de classe ou de instância - tem influência na sua inicialização. O 
aluno é fortemente recomendado a pensar em variáveis como espaços alocados na memória RAM, 
inicialmente podendo conter qualquer valor (conhecido como lixo na memória). 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 24 
4.4 Tipos primitivos da linguagem Java 
A linguagem Java utiliza oito tipos primitivos de dados e um tipo especial. Esses tipos primitivos 
podem ser utilizados para declarar constantes ou variáveis utilizadas em programas Java. Os tipos 
primitivos estão divididos em quatro categorias: lógicos, textuais, numéricos inteiros e numéricos de ponto 
flutuante. 
 
Tipos lógicos: boolean 
Valores lógicos possuem dois estados, normalmente ditos verdadeiro/falso, sim/não e ligado/ 
desligado. Em Java um tipo lógico é definido pela palavra boolean, e pode assumir dois valores: true ou 
false. 
// Exemplo de variável que suporta valores booleanos 
 boolean anoBissexto = false; 
 boolean anoPar = true; 
 
// Apesar de uma variável poder ser declarada 
// sem receber um valor, ela só poderá ser usada 
// após a atribuição de algum valor a ela. 
 boolean valido; 
 
Tipos textuais: char e String 
 
Caracteres simples são representados pelo tipo char. Um char representa um caracter UNICODE, ou 
seja, um número inteiro sem sinal de 16 bits, no intervalo de 0 até 216-1. O valor de um literal char deve 
ser delimitado por aspas simples: 
 
// Exemplo de representação de caracteres UNICODE 
 char primeiraLetra = 'a'; 
 char tabulacao = '\t'; 
 
// Código UNICODE para o caractere de interrogação 
 char unicode = '\u0A02'; 
 
// Lembre-se: Uma variável só poderá 
// ser manipulada após receber um valor. 
 
 char inutil; // variável sem utilidade neste momento 
 inutil = '@'; // variável útil a partir de agora 
 
Palavras são representadas por uma sequência de dados do tipo char, agrupadas em um tipo 
“especial” de dados: a classe String. Apesar de ser uma classe, uma variável do tipo String suporta 
operações como se fosse um tipo primitivo de dados. O valor de uma variável String deve ser delimitado 
por aspas duplas "valor". 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 25 
 // Exemplo de uso de variáveis do tipo String 
 String curso = "Java Básico OO - LogusTI"; 
 
 // Uma variável pode receber o valor de outra 
 String outraVariavel = curso; 
 
 // A concatenação de Strings pode ser feita através do operador de soma (+) 
 curso = "Java Básico OO " + " Java Web" ; 
 
 // Concatenação de String com outro tipo de dados: 
 curso = "Java Básico OO" + 'I'; 
 curso = "Java Básico OO" + 1; 
 
 // Para comparar duas variáveis do tipo String devemos usar o método 
equals(): 
 // curso == "Java Básico OO..." INCORRETO 
 // curso.equals("Java Básico OO...") CORRETO 
 
A concatenação de qualquer tipo de dado com um dado do tipo String resulta em um novo dado do tipo 
String. 
 
Tipos numéricos inteiros: byte, short, int e long 
Existem quatro tipos primitivos de números em Java. Além disso, os valores numéricos podem 
ser representados de forma decimal, octal ou hexadecimal: 
Valores numéricos inteiros em Java: 
2 decimal 
077 um número que começa com zero está representado de forma octal 
0xBABE representação hexadecimal 
 
Todos os valores numéricos em Java tem sinal positivo ou negativo. 
Um valor numérico é sempre considerado do tipo int, a menos que seja acompanhado do sufixo 
L, que representa um valor do tipo long. A diferença de um inteiro para um longo é a capacidade de 
dígitos que podem ser representados, conforme aparece no quadro abaixo. 
Valores numéricos em Java, representados como long: 
2L decimal 
077L um número que começa com zero está representado de forma octal 
0xBABEL representação hexadecimal 
 // Valores inteiros representáveis pelos tipos numéricos em Java: 
 byte a = 127; // -27 ... 27 -1 
 short b = 32767; // -215 ... 215 -1 
 int c = 2147483647; // -231 ... 231 -1 
 long d = 9223372036854775807L; // -263 ... 263 –1 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 26 
Tipos numéricos de ponto flutuante: float e double 
Um valor fracionário pode ser representado em Java através dos tipos float e double. A diferença 
entre esses dois tipos é o tamanho de bits: 
float 32 bits 
double 64 bits 
 
Para um número ser considerado do tipo ponto flutuante, é necessário a inc lusão de um ponto, 
do caractere E (de expoente) ou do sufixo D ou F, conforme mostra o quadro abaixo: 
 // Representação de valores numéricos de ponto flutuante 
 float pi = 3.141516F; 
 float taxa = 15.02E23f; 
 double salario = 22521.20D; 
 
 // Quando não é definido o sufixo para um número decimal, o compilador entende 
que o tipo é double 
 double valor= 122.4E+306; 
 double valorX= 99.22; 
 
IMPORTANTE 
Todo o valor numérico de ponto flutuante é considerado do tipo double, a menos que o programador o 
declare explicitamente como float. 
4.5 - Convenções de codificação 
Em geral, as linguagens de programação possuem convenções para definir os nomes das 
variáveis. Essas convenções ajudam o desenvolvimento de um código mais legível. 
 Classes – as classes devem ser designadas por nomes, começando por uma letra maiúscula e 
depois minúsculas. Cada nova palavra que formar o nome da classe deve ser capitalizada. 
 Ex: class Calculadora, class PessoaFisica e class CalculadoraCientifica 
 
 Intefaces – igual às classes. 
Ex: interface Calculo e interface EquacaoLogaritmica. 
 
 Métodos – métodos devem nomeados por verbos, seguindo o mesmo formato de capitalização 
das classes. Entretanto, um método sempre deve começar comletra minúscula. 
Ex: public void calcular(int numero), public void extrairRaiz(int numero), ... 
 
 Constantes – constantes devem ter todas as suas letras em maiúsculo, com o símbolo de 
subscrito para separa as palavras. 
Ex: final int ANO = 2002, final boolean VERDADE = true, ... 
 
 Variáveis – tal qual os métodos, as variáveis devem começar com uma letra minúscula e depois 
alternar a cada palavra. Procure usar nomes significativos para variáveis. Evite declarar variáveis 
usando apenas um a letra. 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 27 
Mais Sobre 
Em geral, as linguagens de programação possuem convenções para definir os nomes das variáveis. 
Essas convenções ajudam o desenvolvimento de um código mais legível. 
Na convenção de nomes da linguagem Java, os nomes das variáveis devem seguir o padrão camel case 
com a primeira letra minúscula (lower camel case). Veja alguns exemplos: 
 nomeDoCliente 
 numeroDeAprovados 
A convenção de nomes da linguagem Java pode ser consultada na seguinte url: http://www. 
oracle.com/technetwork/java/codeconv-138413.html 
 
4.6 Exercícios 
 
a) Altere o programa AloMundo.Java para que ele imprima na tela todos os tipos primitivos de dados 
suportados pela linguagem Java. 
 
b) Altere o programa AloMundo para que ele imprima os parâmetros recebidos pela linha de comando de 
execução do programa. (Dica: são os valores do array args: args[0], args[1], etc.) 
 
c) Crie um programa que receba três argumentos da linha de comando e imprima-os na mesma linha, em 
ordem inversa. 
 
Exemplo: 
java Programa a1 a2 a3 
Saída: a3 a2 a1 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 28 
5 EXPRESSÕES 
 
Esta seção apresenta a manipulação de variáveis e implementação de tomada de decisões em 
programas Java. 
5.1 Operadores lógicos e aritméticos 
Os operadores Java são similares em estilo e função aos operadores da linguagem C/C++. A 
tabela abaixo enumera esses operadores. 
 
Delimitadores . [] () ; , Servem para delimitar partes 
distintas de um comando, 
método ou classe. 
 
Operador Função 
++ Incrementa o valor da variável em uma unidade. 
Exemplo: i++; contador++; 
-- Incrementa o valor da variável em uma unidade. 
Exemplo: i++; contador++; 
+ - Operadores aritméticos 
* / % Multiplicação, divisão, resto 
<< >> 
>>> 
Operadores de deslocamento aritmético e lógico 
== != Igualdade e desigualdade 
^ Potência 
&& AND 
|| OR 
?: Operador condicional. 
Exemplo: i=0; (i>2?i=0:i --); 
= *= %= 
+= -= 
<<= >>= 
>>>= &= 
^= |= 
 
Operadores aplicados sobre a atribuição. 
instance 
of 
Identificador de classes 
 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 29 
5.2 Concatenação de Strings com o operador + 
 
Quando o operador + é aplicado a dados do tipo String, ele cria um novo dado do tipo String, 
concatenando os dois operandos. 
 /** 
 * Concatenação de Strings 
 */ 
 String sigla = "JOO"; 
 String nome = "Java Orientado a Objetos"; 
 String titulo = sigla + " - " + nome; 
 
 // Esse comando imprimirá na tela a frase: 
 // JOO – Java Orientado a Objetos 
 
 System.out.println(titulo); 
 int i = 10; 
 
 String legenda = "valor = "; 
 
 // campo é uma variável do tipo String 
 String campo = legenda + i; 
 
Alguns métodos úteis em dados do tipo String: 
 String curso = "Java Orientado a Objetos"; 
 System.out.println("curso: " + curso); 
 
 // Isolando um caractere: 
 System.out.print("primeiro caractere: "); 
 System.out.println(curso.charAt(0)); 
 System.out.print("segundo caractere: "); 
 System.out.println(curso.charAt(1)); 
 
 // O primeiro caractere de uma String tem o 
 // índice 0, o segundo o índice 1 e assim por diante 
 // letra = 's'; 
 
 char letra = curso.charAt(2); 
 
 // substrings: 
 System.out.print("primeiras cinco letras: "); 
 System.out.println(curso.substring(0, 5)); 
 System.out.print("letras a partir da quarta: "); 
 System.out.println(curso.substring(4)); 
 
 // número de caracteres em uma String: 
 System.out.print("tamanho da frase: "); 
 System.out.println(curso.length() + " letras"); 
 
 // usando os caracteres de tabulação e quebra 
 // de linha: 
 System.out.println("" 
 + curso.length() 
 + " letras" 
 + " \n" 
 + " Nova linha\ttabulação" ); 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 30 
5.3 Promoção e Casting 
A linguagem Java não suporta atribuições arbitrárias entre variáveis de tipos diferentes. Por 
exemplo, você não pode inicializar uma variável inteira com um valor de ponto flutuante sem explicitar 
isso através de um processo que chamamos de casting. 
Quando atribuímos um valor a uma variável, e esse valor é incompatível com o tipo de dado 
definido para a variável, ocorrerá uma conversão. Em alguns casos, essa conversão será automática, em 
outros o programador deve indicar de que forma o valor será convertido ao tipo de dado da variável. 
Quando o processo de conversão for automático, dizemos que ocorreu uma promoção, ou seja, 
um valor com um tipo de dado foi promovido a outro tipo de dado. Veja no exemplo abaixo: 
// 
// Promoção entre valores de tipos de dados distintos 
// Apesar 6 ser um inteiro, o valor da variável grande 
// continua sendo do tipo long 
long grande = 6; 
// Uma variável do tipo inteiro não possui 
// espaço para armazenar um valor longo. 
// A instrução abaixo é ilegal, e causará um erro de compilação. 
int pequeno = 99L; 
float a = 12.121F; // correto 
float b = 12.121; // 12.121 é um double - incorreto 
Como visto acima, algumas conversões não podem ser realizadas de forma automática, pois o 
compilador não pode assumir que tipo de conversão ele deve realizar (o tamanho do tipo de dado a ser 
recebido por uma variável é maior que o tamanho pré-definido para o tipo dessa variável, logo o 
compilador não sabe como "ajustar" os bits excedentes). Nesse caso, o programador deve indicar ao 
compilador que tipo de conversão deverá ocorrer, digitando o tipo de dado que o valor deverá assumir 
entre parênteses: 
 // 
 // Casting entre valores de tipos de dados distintos 
 // 
 // Apesar 6 ser um inteiro, o valor da variável grande 
 // continua sendo do tipo long 
 long grande = 6; 
 int pequeno = (int)99L; // sem problemas 
 float a = 12.121F; 
 float b = (float)a; // sem problemas 
 
Abaixo estão relacionados todos os casts possíveis na linguagem Java, mostrando quando 
você quer converter de um valor para outro. A indicação Impl. quer dizer que aquele cast é implícito e 
automático, ou seja, você não precisa indicar o cast explicitamente. (lembrando que o tipo boolean não 
pode ser convertido para nenhum outro tipo). 
 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 31 
 
 
 
 
 
 
 
 
 
5.4 Operadores de deslocamento (>>, <<, >>>) 
Java provê operadores para a manipulação dos bits em variáveis de tipo numérico: o 
deslocamento aritmético >> e o deslocamento lógico >>>. 
O operador de deslocamento aritmético >> executa um deslocamento de um bit para a direita de 
um número (na prática, o primeiro argumento desse operador é dividido por dois 'n' vezes – onde n é o 
segundo argumento do operador): 
8 >> 2 = 2 
128 >> 1 = 64 
256 >> 4 = 16 
* Notação em complemento de dois: o operador >> mantém o sinal do bit mais significativo duranteo 
deslocamento. 
O operador de deslocamento lógico >>> executa um deslocamento no padrão dos bits ao invés do 
significado aritmético de um valor numérico. Esse operador sempre adiciona o valor 0 ao bit mais 
significativo: 
1010 ... >> 2 = 111010 ... 
 
1010 ... >>> 2 = 001010 ... 
* Os operadores de deslocamento reduzem seus operandos à direita módulo 32 para um valor do tipo int 
e módulo 64 para um tipo long. Dessa forma, para qualquer valor do tipo int: 
int x  x >>> 32 = x 
O operador de deslocamento lógico >>> só pode ser aplicado a valores inteiros, e não é efetivo em 
valores int e long. Se for aplicado a valor short ou byte, o valor será promovido a um int antes da 
aplicação do operador. Por isso, um deslocamento sem sinal acaba se tornando um deslocamento com 
sinal
5.5 Circuitos lógicos 
 Java possui três operadores básicos para implementar circuitos lógicos: 
NOT: operador ! 
Pág. 
 
5 EXPRESSÕES 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 32 
AND: operador && 
OR: operador || 
 
 Esses operadores permitem a representação de expressões booleanas, que formam o argumento 
para comandos de decisão (IF), seguindo a seguinte tabela: 
 
 AND: OR: 
true && true = true; true || true = true; 
true && false = false; true || false = true; 
false && true = false; false || true = true; 
false && false = false; false || false = false; 
!true = false; 
!false = true; 
!(a && b) = !a || !b 
!(a || b) = !a && !b 
5.6 Exercícios 
a) Implemente um programa para calcular a área de um trapézio, onde: 
 
h = altura 
b = base menor 
B = base maior 
Área = (h . (b + B)) / 2 
 
b) Faça o programa acima calcular utilizando valores de ponto flutuante e depois imprima na tela duas 
informações: 
 
Valor exato da área: 
Valor arredondado para inteiro: 
c) Calcule o valor das seguintes equações: 
a. 3 – 2 – 1 + 2 + 1 + 3 
b. 2 * 3 – 4 * 5 
c. 2 + 6 – 3 / 7 * 9 
d. 3 % 4 – 8 
 
d) Indique qual o valor verdade das seguintes expressões: 
a. (1 > 2) // exemplo: false 
b. (8 == 8) // exemplo: true 
c. ((12 – 5) > 6) 
d. (0 < 3) && (8 < 9) 
e. ((i++) > i) 
f. ((10 * 90 / 50 – 2) == 16) 
Pág. 
 
6 FLUXO DE CONTROLE 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 33 
6 FLUXO DE CONTROLE 
 
Esta seção demonstra como implementar tomada de decisões em códigos Java. 
 
6.1 Ramificação if, else 
 
A sintaxe básica para declarações if, else é a seguinte: 
if (expressão_booleana) 
{ 
 // bloco de comandos 
} 
else 
{ 
 // bloco alternativo de comandos 
} 
Exemplo: 
 /** 
 * Usando if, else */ 
 
 int maior = 10; 
 int menor = 5; 
 
 if (maior > menor) 
 { 
 // (10 > 5) = true 
 System.out.println(maior + ">" + menor); 
 } 
 else 
 { 
 // (10 > 5) != true 
 System.out.println(menor + ">" + maior); 
 } 
 
// Lembre-se que o controle de fluxo é feito através 
// do valor verdade de uma expressão booleana 
 
 boolean verdade = (10 > 5); 
 
 if (verdade) 
 { 
 // (10 > 5) = true 
 System.out.println(maior + ">" + menor); 
 
 } 
Pág. 
 
6 FLUXO DE CONTROLE 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 34 
 else 
 { 
 // (10 > 5) != true 
 System.out.println(menor + ">" + maior); 
 } 
 
6.2 Ramificação switch 
 
Switch é uma declaração semelhante ao if, mas que usa valores inteiros para a tomada de decisões ao invés 
de expressões booleanas. (só pode ser usada em dados dos tipos short, int, byte ou char). Se o tipo de dado não 
for inteiro, o comando switch irá executar uma promoção desse valor ao tipo int para somente depois 
executar a ramificação. 
A sintaxe básica para declarações switch é a seguinte: 
Switch ((int)expressão) 
{ 
// bloco de comandos 
case ((int) valor_1): 
// bloco de comandos break; 
 
case ((int) valor_2): 
// bloco de comandos break; 
default : 
// bloco de comandos padrão. 
// Se nenhum dos valores acima corresponder à 
// expressão definida no comando switch, então 
// o programa executará o trecho default. 
// o trecho default é opcional. 
break; 
} 
Exemplo: 
 /** 
 * Usando switch 
 */ 
 // Considere valorDoTeclado() como um número 
 // inteiro digitado pelo usuário 
 
 int valor = valorDoTeclado(); 
 switch (valor) 
 { 
 
 case 0: 
Pág. 
 
6 FLUXO DE CONTROLE 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 35 
 System.out.println("cadastro de produto"); 
 break; 
 case 1: 
 System.out.println("emitir nota fiscal"); 
 break; 
 case 2: 
 System.out.println("cancelar compra"); 
 break; 
 default: 
 System.out.println("efetuar venda"); 
 break; 
 } 
6.3 Repetição for 
A declaração for é utilizada para definir que um bloco de comandos deve ser executado 'n' vezes, onde 'n' é 
um número inteiro. A sintaxe do comando for é a seguinte: 
for (int i = 0; i < 10; i++) 
{ 
 // bloco de comandos 
} 
Exemplo: 
 /** 
 * repetição de comandos usando FOR 
 */ 
 // Calculando o fatorial de um número: 
 int numero = 10; 
 int fatorial = 1; 
 
 for (int i = numero; i > 0; i--) 
 { 
 fatorial = fatorial * i; 
 } 
 
 System.out.println("fatorial de " + numero + " = " + fatorial); 
 
 // Imprimindo os dias do ano: 
 for (int mes = 1; mes < 12; mes++) 
 { 
 switch (mes) 
 { 
 case 1: 
 System.out.println("janeiro"); 
 break; 
 case 2: 
 System.out.println("março"); 
 break; 
 case 3: 
 System.out.println("abril"); 
 break; 
 // escreva aqui os demais comandos 
Pág. 
 
6 FLUXO DE CONTROLE 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 36 
 } 
 } 
 
6.4 Repetição while 
A declaração while é utilizada para definir que um bloco de comandos e deve ser executado enquanto uma 
expressão booleana (condição de parada) não seja verdade. A sintaxe do comando while é a seguinte: 
While (expressão_booleana) 
{ 
// bloco de comandos executados enquanto a 
// expressão boolena tiver valor verdade = true 
} 
 ou 
do 
{ 
// bloco de comandos executados pelo menos uma vez 
} While (expressão_booleana); 
 
Exemplo: 
 public static void main(String[] args) { 
 
 /** 
 * repetição de comandos usando FOR 
 */ 
 // Calculando o fatorial de um número: 
 int numero = 10; 
 int fatorial = 1; 
 int i = numero; 
 
 while (i > 0) 
 { 
 fatorial = fatorial * i; 
 i--; 
 } 
 
 System.out.println("O fatorial de " + numero + " = " + fatorial); 
 // Lendo a condição de parada do teclado: 
 
 numero = 0; 
 while (numero < 10) 
 { 
 System.out.println("Digite um número: "); 
 numero = valorDoTeclado(); 
 } 
Pág. 
 
6 FLUXO DE CONTROLE 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 37 
 
 System.out.println("O usuário digitou um número maior que 10"); 
 
 } 
6.5 Comandos especiais de controle de fluxo: break, continue e label 
 
Os comandos de repetição em Java suportam dois tipos de desvios: o break e o continue. O break faz com 
que um laço seja interrompido, enquanto o continue é usado para "pular" uma execução e continuar a partir da 
próxima. 
Exemplo: 
 // pulando a execução No 10 e parando na No 15 
 for (int i=0; i<20; i++) 
 { 
 if(i== 10) 
 { 
 continue; 
 } 
 else if(i == 15) 
 { 
 break; 
 } 
 System.out.println("contador: " + i); 
 } 
Além disso, esse desvio pode ser direcionado, ou seja, o programador pode indicar para qual linha do código 
a execução do programa deve ser desviada (uma espécie de GOTO em Java). Essa prática é altamente 
desaconselhada, e foi mantida no Java por motivos de compatibilidade com a linguagem C. 
Um label em Java só pode ser usado para identificar um comando for, while ou do. 
Exemplo: 
 desvio: for (int i=0; i<20; i++) 
 { 
 if(i == 10) 
 { 
 continue desvio; 
 } 
 else if(i == 15) 
 { 
 // Essa linha nunca será executada 
 // pois o laço sempre será reiniciado 
 // quando o valor de i for igual a 10 
 break desvio; 
 } 
 System.out.println("contador: " + i); 
 
 } 
Pág. 
 
6 FLUXO DE CONTROLE 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 38 
6.6 Lendo valores do teclado 
 
Nem sempre é necessário fazer entrada byte a byte. Nestes casos, normalmente, é mais simples utilizar a classe 
Scanner do pacote java.util do Java. Essa classe possui métodos mais sofisticados para obter os dados de uma 
entrada. 
 // Criando objeto de entrada de dados 
 InputStream entrada = System.in; 
 Scanner scanner = new Scanner (entrada) ; 
 
 // Realizando a leitura 
 String linha = scanner.nextLine () ; 
 
 // Imprimindo a informação lida 
 System.out.println(linha); 
 
 
6.7 Exercícios 
 
1. Escreva um programa que imprima na tela a soma dos números ímpares entre 0 e 20 e a multiplicação dos 
números pares entre 0 e 20. 
 
2. Faça um programa para ler um número do teclado e imprimir na tela se ele é par ou ímpar. 
 
3. O valor pago por um Hotel da Praia de Iracema para seus porteiros é de R$ 10,25 por hora de trabalho. Faça um 
programa que pergunte ao usuário quantas horas ele trabalhou e imprima na tela o valor do salário a ser recebido 
por ele. 
 
4. Modifique o programa anterior para que o sistema imprima uma mensagem de alerta quando o valor a ser pago 
ao funcionário seja inferior a R$ 50,00: "Atenção, dirija-se à direção do Hotel!". 
 
5. Sabendo que na LogusTI a média mínima é 7,0 e a tolerância de faltas é 15 % da carga horária do curso, faça 
uma classe com o método main que peça as informações necessárias e informe a situação do usuário. 
 
6. Implemente uma classe java “Calculos” com um método”calcularMedia” que receba três números e calcule a 
média e imprima na tela essa média. O método “calcularMaior”, deverá receber também três números e retornar o 
maior número e o método “calcularMenor”, deverá receber três números e retornar o melhor número. Implemente a 
classe com o método main e instancie a classe Calculos executando todos os seus métodos. 
 
7. Construa uma classe que peça o Nome, Endereço, Sexo, Cidade, Estado, Idade dos funcionários. Além disto, 
dado o Salário Bruto do funcionário, calcule o seu Salário Líquido. Considere que os descontos podem ser o Vale 
Transporte (2%), Vale Alimentação (5%) e Plano de Saúde (10%). 
Pág. 
 
7 AGRUPAMENTO DE DADOS (ARRAYS) 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 39 
7 AGRUPAMENTO DE DADOS (ARRAYS) 
 
Nesta seção analisaremos o agrupamento de dados, uma estrutura simples mas essencial para a compreensão de 
como Java manipula dados na memória. 
7.1 Declarando e criando Arrays 
 
 Suponha que o sistema do banco tenha que gerar listas com os números das contas de uma agência. 
Poderíamos declarar uma variável para cada número 
 
int numero1; 
int numero2; 
int numero3; 
Contudo, não seria uma abordagem prática, pois uma agência pode ter uma quantidade muito grande de 
contas. Além disso, novas contas podem ser abertas todos os dias. Isso implicaria em alterações constantes no 
código fonte. 
Quando desejamos armazenar uma grande quantidade de valores de um determinado tipo, po-demos utilizar 
arrays. Um array é um objeto que pode armazenar muitos valores de um determinado tipo. 
 Podemos imaginar um array como sendo um armário com um determinado número de gavetas. E cada 
gaveta possui um rótulo com um número de identificação. 
 
Arrays são tipos indexados de dados que permitem a representação de agrupamento de dados como vetores 
e matrizes. 
 
Pág. 
 
7 AGRUPAMENTO DE DADOS (ARRAYS) 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 40 
Podemos declarar arrays de qualquer tipo de dado suportado em Java (primitivo ou agregado – tipos 
agregados de dados serão discutidos posteriormente). Essa declaração é feita pela adição do símbolo [] a um tipo de 
dado, que pode aparecer antes ou após o identificador da variável: 
char[] arrayDeCaracteres; 
String[] arrayDePalavras; 
Ponto[] arrayDeObjetosDoTipoPonto; 
int números[]; 
Na memória, um array é um agrupamento de dados, indexados pelo tamanho do tipo de dado que o array 
suporta:
 
 
O primeiro índice de um array é sempre 0, e o último índice é o N-1, onde N é o número de elementos do 
array. 
IMPORTANTE 
Apesar da posição do símbolo [] poder ser no início ou no final do nome da variável, é fortemente recomendado que 
você sempre aplique o [] após o tipo da variável. Isso torna o código muito mais legível. 
 
Para criar um array, usamos a palavra chave new: 
 
int[] números = new int[50]; 
 
A quantidade de elementos de um array sempre deve ser um valor inteiro. O comprimento de um array é dado pelo 
método length: 
 
// Imprimindo o comprimento de um array 
char [] alfabeto = new char[24]; 
int tamanhoDoAlfabeto = alfabeto.length; 
System.out.println("alfabeto com " + tamanhoDoAlfabeto " letras"); 
 
 
 
IMPORTANTE 
Um array de 10 elementos tem os índices de 0 a 9. 
Pág. 
 
7 AGRUPAMENTO DE DADOS (ARRAYS) 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 41 
 
7.2 Modificando o conteúdo de um array 
 
Para modificar o conteúdo de um array, devemos escolher uma ou mais posições que devem ser alteradas e utilizar 
a sintaxe abaixo: 
 int [] numeros = new int [100]; 
 numeros [0] = 136; 
 numeros [99] = 17; 
 
IMPORTANTE 
Quando um array é criado com o comando new, todas as posições são inicializadas com os valores padrão 
(números são inicializados com 0, booleanos com false e referências com null). 
 
Também podemos definir os valores de cada posição de um array no momento da sua criação utilizando as 
sintaxes abaixo: 
 int [] numeros1 = new int []{100 ,87}; 
 int [] numeros2 = {100 ,87}; 
 
7.3 Acessando o conteúdo de um array 
Para acessar o conteúdo de um array, devemos escolher uma ou mais posições e utilizar a sintaxe abaixo: 
 int [] numeros1 = new int []{100 ,87}; 
 int [] numeros2 = {100 ,87}; 
 System.out.println(numeros2[0]); 
 System.out.println(numeros1[1]); 
 
IMPORTANTE 
Acessar posições fora do intervalo de índices de um array gera erro de execução. Mais especificamente, em Java, 
ocorrerá a exception ArrayIndexOutOfBoundsException. 
 
Pág. 
 
7 AGRUPAMENTO DE DADOS (ARRAYS) 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 42 
7.4 Percorrendo um Array 
Quando trabalhamos com um array, uma das tarefas mais comuns é acessarmos todas ou algumas de suas 
posições sistematicamente. Geralmente, fazemos isso para resgatar todos ou alguns dos valores armazenados e 
realizar algum processamento sobre tais informações.Para percorrermos um array, utilizaremos a instrução de repetição for. Podemos utilizar a instrução while 
também. Porém, logo perceberemos que a sintaxe da instrução for, em geral, é mais apropriada quando estamos 
trabalhando com arrays. 
 int [] numeros = new int [100]; 
 for ( int i = 0; i < 100; i ++) { 
 numeros [ i ] = i ; 
 } 
 Para percorrer um array, é necessário saber a quantidade de posições do mesmo. Essa quantidade é 
definida quando o array é criado através do comando new. Nem sempre essa informação está explícita no código. 
Por exemplo, considere um método que imprima na saída padrão os valores armazenados em um array. 
Provavelmente, esse método receberá como parâmetro um array e a quantidade de posições desse array não estará 
explícita no código fonte. 
 public void imprimirArray(int[] numeros) { 
 // Implementação do Array 
 
 } 
 
Podemos imprimir todos os elementos do array utilizando o for e atributo length. 
 public void imprimirArray(int[] numeros) { 
 for (int i = 0; i < numeros.length; i++) { 
 // Imprimindo cada elemento do array 
 System.out.println(numeros[i]); 
 } 
 } 
 
Para acessar todos os elementos de um array, é possível aplicar o comando for com uma sintaxe um pouco 
diferente, utilizando o laço foreach. 
 
 public static void imprimirArray2(int[] numeros){ 
 
 for(int numero:numeros) { 
 System.out.println(numero); 
 } 
 
Pág. 
 
7 AGRUPAMENTO DE DADOS (ARRAYS) 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 43 
 } 
 
7.5 Operações com Arrays 
Nas bibliotecas da plataforma Java, existem métodos que realizam algumas tarefas úteis relacionadas a arrays. 
Veremos esses métodos a seguir. 
 
7.5.1 Ordenando um Array 
 
Considere um array de String criado para armazenar nomes de pessoas. Podemos ordenar esses nomes através 
do método Arrays.sort(). 
String [] nomes = new String []{ "João Paulo" , "Gabriel Jesus" , "André Santos", "Paulo 
Henrique" }; 
Arrays.sort(nomes); 
 
for (String nome:nomes) { 
 System.out.println (nome); 
} 
 
Analogamente, também podemos ordenar números. 
7.5.2 Duplicando um Array 
 
Para copiar o conteúdo de um array para outro com maior capacidade, podemos utilizar o mé-todo 
Arrays.copyOf(). 
 String [] nomes = new String []{"Neymar" , "Gabriel Jesus" , "Gabigol" }; 
 
 String [] nomesDuplicados = Arrays.copyOf(nomes,10); 
 
7.5.3 Preenchendo um Array 
Podemos preencher todas as posições de um array com um valor específico utilizando o método Arrays.fill(). 
 int [] numeros2 = new int [10]; 
 
 java . util . Arrays . fill ( numeros2 , 5) ; 
 
Pág. 
 
7 AGRUPAMENTO DE DADOS (ARRAYS) 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 44 
7.6 Arrays multidimensionais 
Quando declaramos um array através do símbolo [], estamos de fato criando um array unidimensional (vetor). 
Além de vetores, a linguagem Java permite a declaração de arrays n-dimensionais, conforme os exemplos abaixo: 
 // array unidimensional (VETOR) 
 String[] frases = new String[5]; 
 
 // array bidimensional (MATRIZ) 
 String[][] tabela = new String[5][15]; 
 
 // array n-dimensional 
 double [][][] densidade; 
 densidade = new double[10][10][10]; 
 
 // observe que nem todos os valores de um array 
 // precisam estar preenchidos. Sempre que você for 
 // usar o valor contido em uma posição de um array 
 // você deve ter certeza que essa posição 
 // foi inicializada 
 densidade[0][0][0] = 35.034; 
 densidade[1][0][0] = 30.876; 
 System.out.println("densidade na coordenada 1,0,0 = " 
 + densidade[1][0][0]); 
 
7.7 Array esparso 
 
Java permite a declaração de estruturas esparsas, ou seja, um agrupamento indexado de dados onde nem 
todas as dimensões são iguais: 
 
 
 // Matrizes esparsas podem ser representadas em Java 
 // através de arrays com dimensões heterogêneas: 
 int[][] esparso = new int[4][]; 
 esparso[0] = new int[10]; 
 esparso[1] = new int[2]; 
 
 esparso[2] = new int[5]; 
 esparso[3] = new int[1]; 
 
 // Na memória, o espaço de dados ocupado pelo 
 // array acima seria aproximadametne assim: 
 // [ | | | | | | | | | ] 
 // [ | ] 
 // [ | | | | ] 
 // [ ] 
Pág. 
 
7 AGRUPAMENTO DE DADOS (ARRAYS) 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 45 
7.8 Exercícios 
 
1) Crie um programa que imprima na tela os argumentos passados na linha de comando para o método main. 
Compile e execute a classe ImprimeArgumentos. Na execução, não esqueça de passar alguns parâmetros na linha 
de comando. 
2) Faça um programa que ordene o array de strings recebido na linha de comando.Compile e execute a classe 
Ordena. Na execução, não esqueça de passar alguns parâmetros na linha de comando. 
3) Faça um programa que calcule a média dos elementos recebidos na linha de comando. Dica: para converter 
strings para double utilize o método parseDouble() 
4) Faça um programa que leia cinco nomes do teclado, e depois imprima esses nomes na ordem inversa em 
que foram digitados pelo usuário. 
5) O tempo que um determinado avião dispensa para percorrer o trecho entre duas localidades distintas está 
disponível através da seguinte tabela: 
 
 A B C D E F G 
 02 11 06 15 11 01 
02 07 12 04 02 15 
11 07 11 08 03 13 
06 12 11 10 02 01 
15 04 08 10 05 13 
11 02 03 02 05 14 
01 15 13 01 13 14 
 
 
a) Construa uma classe java que leia a tabela anterior e informe ao usuário o tempo necessário para percorrer duas 
cidades por ele fornecidas, até o momento em que ele fornecer duas cidades iguais (origem e destino). 
 
b) Elabore uma classe que imprima a tabela sem repetições(apenas o triângulo superior ou o triângulo inferior). 
 
 
 
 
 
 
 
 
Pág. 
 
8 ORIENTAÇÃO A OBJETOS(OO) BÁSICA 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 46 
8 ORIENTAÇÃO A OBJETOS(OO) BÁSICA 
 
8.1 Fundamentos da Programação Orientada a Objetos 
A Orientação a Objetos é uma tecnologia que enxerga os sistemas como sendo coleção de objetos 
integrantes. Ela permite melhorar a reusabilidade e extensibilidade dos softwares. 
A tecnologia orientada a objetos é fundamentada no que, coletivamente, chamamos de modelo de objetos, 
que engloba os princípios da abstração, hierarquização, encapsulamento, classificação, modularização, 
relacionamento, simultaneidade e persistência 
8.2. Paradigma Orientado por Objetos 
 
A proposta da orientação a Objetos é representar o mais fielmente possível as situações do mundo real nos 
sistemas computacionais. Nós entendemos o mundo como um todo composto por vários objetos que interagem uns 
com os outros. Da mesma maneira, a Orientação a Objetos consiste em considerar os sistemas computacionais não 
como uma coleção estruturada de processos, mas sim como uma coleção de objetos que interagem entre si. 
Os programas Orientados a objetos são programas estruturados em módulos que agrupam um estado e 
operações sobre este estado. Apresentam ênfase em reutilização de código. 
Um dos grandes diferenciais da programação orientada a objetos em relação a outros paradigmas de 
programação que também permitem a definição de estruturas e operações sobre essas estruturas está no conceito 
de herança, mecanismo através do qual definições existentes podem ser facilmente estendidas. Juntamente com a 
herança deve ser enfatizada aimportância do polimorfismo, que permite selecionar funcionalidades que um 
programa irá utilizar de forma dinâmica, durante sua execução. 
 
“Orientação a Objetos consiste em considerar os sistemas computacionais como uma 
coleção de objetos que interagem de maneira organizada. ” 
8.3 Principais conceitos de POO 
8.3.1 Objetos 
 
Usamos o termo objeto para representar um determinado elemento do mundo real. Mas somente 
analisaremos os objetos que tem relevância para a solução de um determinado problema. Portanto, o objeto é uma 
entidade do mundo real que merece representação para o ambiente estudado. 
Objetos são instâncias de classes, que determinam qual informação um objeto contém e como ele pode 
manipulá-la. É uma entidade capaz de reter um estado (informação) e que oferece uma série de operações 
Pág. 
 
8 ORIENTAÇÃO A OBJETOS(OO) BÁSICA 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 47 
(comportamento) ou para examinar ou para afetar este estado. É através deles que praticamente todo o 
processamento ocorre em sistemas implementados com linguagens de programação orientadas a objetos. 
Como exemplos de objetos, podemos citar os objetos físicos (um livro, uma mercadoria), funções de pessoas para os 
sistemas (cliente, vendedor), eventos (uma compra, um telefonema), interações entre outros objetos (um item de 
uma nota fiscal é uma interação entre uma compra e um produto do estoque) e lugares (loja matriz, revenda norte). 
Por exemplo, vamos considerar um cachorro(Bob) como nosso “objeto” para facilitar o entendimento acerca 
do conceito de OO: 
 
Analisando este objeto, o cachorro, podemos deduzir que o mesmo possui algumas características que 
pertencem apenas a ele próprio. Por exemplo, um cachorro possui: 
 
 Um nome, 
 Uma idade, 
 Um comprimento de pêlos, 
 Uma cor dos pelos, 
 Uma cor dos olhos, 
 Um peso, 
.... 
“As características que descrevem um objeto são chamadas de atributos”. 
 
Além do conjunto de características que descrevem o cachorro, podemos também identificar um conjunto de ações 
que ele é capaz de executar: 
 Latir, 
 Babar, 
 Correr em círculos, 
 Pegar a bola, 
 Sentar, 
Pág. 
 
8 ORIENTAÇÃO A OBJETOS(OO) BÁSICA 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 48 
 Comer, 
 Dormir. 
“As ações que um objeto pode executar são chamadas de métodos ou serviços”. 
 
A única maneira de interagir com os objetos é através dos métodos que ele disponibiliza. Para interagir com 
o cachorro, utilizamos os métodos que relacionamos acima: para alimentá-lo, utilizamos o método “comer”, para 
brincar com ele, utilizamos o método “pegar a bola”, etc. 
“Chamamos de interface ao conjunto de métodos disponíveis em um objeto.” 
8.3.2 Atributos e métodos 
 
Vimos então que os objetos são compostos de atributos e métodos, mas afinal, o que são atributos e o que são 
métodos? 
 
8.3.2.1 Atributos 
Os objetos do mundo real possuem propriedades que possuem valores. Estes valores definem o estado do 
objeto. As propriedades recebem o nome de atributos em OO. 
Podemos dizer que os atributos dos objetos são “variáveis” ou “campos” que armazenam os diferentes 
valores que as características dos objetos podem conter. 
O estado de um objeto é o conjunto de valores de seus atributos em um determinado instante. O 
comportamento de um objeto é como ele age e reage em termos de suas mudanças de estado e troca de 
mensagens com outros objetos. 
O cachorro(Bob) do nosso exemplo poderia ser representado pelos seguintes atributos: 
 
CACHORRO 
Nome Bob 
Idade 10 meses 
Cor dos pelos Bege 
Peso 4 kg 
 
 
Pág. 
 
8 ORIENTAÇÃO A OBJETOS(OO) BÁSICA 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 49 
Um outro objeto “cachorro” apresentaria valores diferentes para os mesmos atributos, por exemplo: 
 
 
CACHORRO 
Nome Lulu 
Idade 2 anos 
Cor dos pelos Laranja 
Peso 3 kg 
 
 
Os atributos de um objeto somente mudam de valor através de estímulos externos ou internos. A única forma 
de modificar os atributos dos objetos é disparando eventos que provocam a transição desses estados no objeto. 
 
8.3.2.2 Métodos 
Os métodos são procedimentos ou funções que realizam as ações próprias do objeto. Assim, os métodos 
são as ações que o objeto pode realizar. Tudo que o objeto faz é realizado através de seus métodos, pois é através 
dos seus métodos que um objeto se manifesta, e através deles que o objeto interage com os outros objetos. 
Um objeto exibe algum comportamento (executa uma operação) quando recebe um estímulo de outro objeto. 
Um objeto requisita a ação de algum outro objeto, enviando uma mensagem para ele. Esta mensagem é uma 
solicitação a um objeto para que seja executada as rotinas que chamamos de Método da classe. 
Os métodos são responsáveis por acessar ou alterar os atributos de um objeto. Imaginando os métodos do 
nosso objeto de estudo, o cachorro, enumeramos métodos (ações) como latir, babar, comer sentar, etc. 
 
8.3.3 Classes 
 
Uma classe representa um conjunto de objetos que possuem características e comportamentos comuns e de 
agora em diante, diremos que um objeto é uma instância de uma determinada classe, ou seja, criaremos nossos 
objetos baseados nas características definidas nas classes. A ênfase da metodologia orientada a objetos é dada na 
criação das classes, e não dos objetos, como se poderia pensar pelo nome. Olhando os dois cães do exemplo 
anterior, vemos que os dois possuem exatamente o mesmo conjunto de atributos. Isso acontece porque se trata de 
dois objetos da mesma classe, ou categoria. Isso significa que os dois possuem exatamente o mesmo conjunto de 
atributos e métodos, embora cada objeto possa ter valores diferentes para os seus atributos. 
Pág. 
 
8 ORIENTAÇÃO A OBJETOS(OO) BÁSICA 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 50 
 
 
 
 
 
 
 
 
Classe Cachorro 
 
 
Objetos de mesma classe possuem a mesma definição tanto para métodos quanto para atributos. 
Tomemos uma classe gatos formada de objetos “gato”. Estes objetos possuem as seguintes características: 
nome, idade, peso, cor de pelos, cor de olhos e comprimento de pelos. Além disso, o objeto possui as seguintes 
ações: miar, comer, dormir, subir na árvore. 
 
 
 
 
 
 
 
 
 
Classe Gato 
 
Muitos objetos do mundo real possuem características comuns e podem ser agrupados de acordo com elas. 
Uma classe representa um gabarito para muitos objetos e descreve como estes objetos estão estruturados 
internamente. 
As classes Cães e Gatos possuem características e métodos comuns, por exemplo: Características comuns 
(nome, idade, peso, cor de pelos, cor de olhos e comprimento de pelos), Métodos comuns (pegar a bola, comer, 
dormir). 
8.3.3 Instanciação 
 
Pág. 
 
8 ORIENTAÇÃO A OBJETOS(OO) BÁSICA 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 51 
A instanciação é quando a classe produz um objeto, como se ela fosse uma espécie de modelo ou gabarito 
para a criação de objetos. Conforme a teoria da orientação a objetos, dizemos que um objeto é, nada mais nada 
menos, que a instância de uma classe. 
Pelo exemplo que estamos estudando, cada cachorro que for armazenado é um novo objeto, uma nova 
instância da classe “Cachorro”. A classe serve de modelo para a criação de novos objetos.8.4 - Exercício - Conceitos OO 
 
Para atender as necessidades de informação de uma biblioteca universitária foi proposto um sistema que deve 
atender as seguintes características: 
 
 O cadastro dos usuários da biblioteca com endereço completo. Os usuários podem ser classificados em três 
grupos: Professores, Alunos e Funcionários. Para os Alunos é necessário conhecer o curso ao qual 
pertencem. Dos Professores e funcionários, é necessário conhecer o Departamento ao qual estão sempre 
vinculados. 
 O cadastro das obras da biblioteca, que podem ser classificadas em: Livros científicos, periódicos científicos, 
periódicos informativos, periódicos diversos, entretenimento, etc. 
 A língua em que se encontra o exemplar da obra. 
 A mídia onde se encontra o exemplar da obra. 
 Os autores da obra com o controle da nacionalidade do autor. 
 As editoras dos exemplares com o ano de edição de cada exemplar. 
 O histórico dos empréstimos. 
 
Identifique as possíveis classes e objetos com seus respectivos atributos e métodos. 
 
 
 
 
 
 
 
 
 
 
Pág. 
 
8 ORIENTAÇÃO A OBJETOS(OO) BÁSICA 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 52 
8.5 – Classes e Objetos em Java 
 
O conceito de classe apresentado anteriormente é genérico e pode ser aplicado em diversas linguagens de 
programação. Mostraremos como a classe Conta poderia ser escrita utilizando a linguagem Java. Inicialmente, 
discutiremos apenas sobre os atributos. Os métodos serão abordados posteriormente. 
class Conta { 
 
 double saldo; 
 
 double limite; 
 
 int numero; 
 
} 
A classe Java Conta é declarada utilizando a palavra reservada class. No corpo dessa classe, são 
declaradas três variáveis que são os atributos que os objetos possuirão. Como a linguagem Java é estaticamente 
tipada, os tipos dos atributos são definidos no código. Os atributos saldo e limite são do tipo double, que permite 
armazenar números com casas decimais, e o atributo número é do tipo int, que permite armazenar números inteiros. 
Importante 
Por convenção, os nomes das classes na linguagem C# devem seguir o padrão “Camel Case” com a primeira letra 
maiúscula. 
 
8.5.1 Criando objetos em Java 
Após definir a classe Conta, podemos criar objetos a partir dela. Esses objetos devem ser alocados na 
memória RAM do computador. Felizmente, todo o processo de alocação do objeto na memória é gerenciado pela 
máquina virtual. O gerenciamento da memória é um dos recursos mais importantes oferecidos pela máquina virtual. 
Do ponto de vista da aplicação, basta utilizar um comando especial para criar objetos e a máquina virtual se 
encarrega do resto. O comando para criar objetos é o new. 
class TestaConta { 
 
public static void main (String [] args ) { 
 // criando um objeto 
 new Conta () ; 
 } 
 
} 
 
Pág. 
 
8 ORIENTAÇÃO A OBJETOS(OO) BÁSICA 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 53 
A linha com o comando new poderia ser repetida cada vez que desejássemos criar (instanciar) um objeto da 
classe Conta. A classe TestaConta serve apenas para colocarmos o método main, que é o ponto de partida da 
aplicação. 
class TestaConta { 
 
public static void main (String [] args ) { 
 // criando três objetos 
 new Conta () ; 
 new Conta () ; 
 new Conta () ; 
 } 
 
} 
 
Analogia 
Chamar o comando new passando uma classe Java é como se estivéssemos contratando uma construtora passando a 
planta da casa que queremos construir. A construtora se encarrega de construir a casa para nós de acordo com a planta. 
Assim como a máquina virtual se encarrega de construir o objeto na memória do computador. 
 
8.5.2 Referências 
 
Todo objeto possui uma referência. A referência de um objeto é a única maneira de acessar os seus atributos e 
métodos. Dessa forma, devemos guardar as referências dos objetos que desejamos utilizar. 
Referências em Java 
Ao utilizar o comando new, um objeto é alocado em algum lugar da memória. Para que possamos acessar esse 
objeto, precisamos de sua referência. O comando new devolve a referência do objeto que foi criado. 
Para guardar as referências devolvidas pelo comando new, devemos utilizar variáveis não primitivas. 
 
 Conta referencia = new Conta () ; 
No código Java acima, a variável referencia receberá a referência do objeto criado pelo comando new. Essa 
variável é do tipo Conta. Isso significa que ela só pode armazenar referências de objetos do tipo Conta. 
 
 
 
Pág. 
 
8 ORIENTAÇÃO A OBJETOS(OO) BÁSICA 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 54 
8.5.3 Manipulando Atributos 
 
Podemos alterar ou acessar os valores guardados nos atributos de um objeto se tivermos a referência a esse 
objeto. Os atributos são acessados pelo nome. No caso específico da linguagem Java, a sintaxe para acessar um 
atributo utiliza o operador ".". 
public class TesteOO { 
 
public static void main (String [] args ) { 
 
 
 Conta referencia = new Conta () ; 
 
 referencia.saldo = 5000; 
 
 referencia.limite = 10000; 
 
 referencia.numero = 1; 
 
 System.out.println ( referencia . saldo ) ; 
 
 System.out.println ( referencia . limite ) ; 
 
 System.out.println ( referencia . numero ) ; 
 
 } 
 
} 
No código acima, o atributo saldo recebe o valor 5000. O atributo limite recebe o valor 10000 e o número recebe 
o valor 1. Depois, os valores são impressos na tela através do comando System.out.println. 
8.5.4 Valores Padrão 
 
Poderíamos instanciar uma classe para criar um objeto e utilizar seus atributos sem inicializá-los explicitamente, 
pois os atributos são inicializados com valores padrão. Os atributos de tipos numéricos são inicializados com 0, os 
atributos do tipo boolean são inicializados com false e os demais atributos com null (referência vazia). 
class Conta { 
 
 double limite ; 
 
} 
 
class TestaConta { 
 
 public static void main ( String [] args ) { 
 
Pág. 
 
8 ORIENTAÇÃO A OBJETOS(OO) BÁSICA 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 55 
 Conta conta = new Conta () ; 
 
 // imprime 0 
 System . out . println ( conta . limite ) ; 
 
 } 
 
} 
 
A inicialização dos atributos com os valores padrão ocorre na instanciação, ou seja, quando o comando new é 
utilizado. Dessa forma, todo objeto “nasce” com os valores padrão. Em alguns casos, é necessário trocar esses 
valores. Para trocar o valor padrão de um atributo, devemos inicializá-lo na declaração. Por exemplo, suponha que o 
limite padrão das contas de um banco seja R$ 2500. Nesse caso, seria interessante definir esse valor como padrão 
para o atributo limite. 
 
class Conta { 
 
 double limite = 2500; 
 
} 
 
 
class TestaConta { 
 
 public static void main ( String [] args ) { 
 
 Conta conta = new Conta () ; 
 
 // imprime 2500 
 System . out . println ( conta . limite ) ; 
 
 } 
 
} 
 
 
 
 
 
 
 
Pág. 
 
8 ORIENTAÇÃO A OBJETOS(OO) BÁSICA 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 56 
8.6 Exercícios Complementares 
 
a) Implemente uma classe chamada Aluno para definir os objetos que representarão os alunos de uma escola. 
Essa classe deve declarar três atributos: o primeiro para o nome, o segundo para o RG e o terceiro para o CPF dos 
alunos.b) Faça uma classe chamada TestaAluno e crie dois objetos da classe Aluno atribuindo valores a eles. A classe 
também deve mostrar na tela as informações desses objetos. 
c) Em uma escola, além dos alunos temos os funcionários, que também precisam ser representados em nossa 
aplicação. Então implemente outra classe chamada Funcionario que contenha dois atributos: o primeiro para o cargo 
e o segundo para o salário dos funcionários. 
d) Faça uma classe chamada TestaFuncionario e crie dois objetos da classe Funcionario atribuindo valores a 
eles. Mostre na tela as informações desses objetos. 
e) Em uma escola, os alunos precisam ser divididos por turmas, que devem ser representadas den-tro da 
aplicação. Implemente uma classe chamada Turma que contenha quatro atributos: o primeiro para o período, o 
segundo para definir a série, o terceiro para sigla e o quarto para o tipo de ensino. 
f) Faça uma classe chamada TestaTurma para criar dois objetos da classe Turma. Adicione informações a eles 
e depois mostre essas informações na tela. 
Pág. 
 
9 OO - HERANÇA, POLIMORFISMO E INTERFACES 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 57 
9 OO - HERANÇA, POLIMORFISMO E INTERFACES 
 
9.1 Objetos e Construtor 
 
Objetos e Construtor 
Objetos são criados através da declaração new, seguida de um método construtor. Exemplo: 
Automovel gol1 = new Automovel(“Gol V”); 
Uma classe pode ter construtores especializados ou somente o construtor default (gerado pelo compilador). 
Um construtor recebe sempre o mesmo nome da sua classe. 
O método construtor gera uma instância do objeto em memória e o seu código é executado imediatamente após a 
criação do objeto provendo-lhe um estado inicial. Quando declaramos variáveis de qualquer tipo primitivo (boolean, 
byte, short, char, int, long, float, ou double) o espaço em memória (na área de dados) é alocado como parte da 
operação. A declaração de uma variável referência a um objeto não aloca espaço em memória. 
A alocação de memória (no heap) é feita somente quando o objeto é criado. 
Considere o exemplo abaixo: 
Automovel gol; 
gol = new Automovel(); 
• O primeiro comando, a declaração, aloca apenas o espaço suficiente para a referência. O segundo, aloca o 
espaço para os atributos do objeto gol. 
 
• Somente após a criação do objeto é que seus membros (atributos e métodos) podem ser referenciados. 
 
9.2 Herança 
Herança significa ser capaz incorporar os dados e métodos de uma classe previamente definida. Assim como 
a herança de todas as operações e dados, você pode especializar métodos da classe ancestral e especificar novos 
operações e dados, para refinar, especializar, substituir ou estender a funcionalidade da classe progenitora. 
Você pode fazer sempre com que um objeto mais geral armazene um objeto mais especializado, mas 
o contrário não é verdadeiro sem uma conversão explícita de tipos. 
Pág. 
 
9 OO - HERANÇA, POLIMORFISMO E INTERFACES 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 58 
Veja o exemplo abaixo: 
 
 
 
 
 
 
 
 
Herança - terminologia 
• estender = criar uma nova classe que herda todo o conteúdo da classe existente. 
• superclasse = uma classe progenitora ou “base”. 
• subclasse = uma classe filha que herda, ou estende, uma superclasse. 
Em Java, a classe “Object” é raiz de todas as classes: 
 
 
 
 
 
 
 
 
 
 
 
 
Pág. 
 
9 OO - HERANÇA, POLIMORFISMO E INTERFACES 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 59 
this é uma palavra-chave usada num método como referência para o objeto corrente. 
• ela tem o significado de: “o objeto para o qual este trecho de código está sendo executado”. 
 
//Classe ponto 
public class Ponto 
{ 
 
 private float x,y; 
 
 public Ponto(float x,float y) 
 { 
 this.x=x; this.y=y; 
 } 
 
 public void move(float dx,float dy) 
 { 
 this.x+=dx; this.y+=dy; 
 } 
 
 public float retorna_x() 
 { 
 return x; 
 } 
 
 public void mostra() 
 { 
 System.out.println( "(" + this.x + "," + this.y + ")" ); 
 } 
 
} 
 
super é uma palavra chave usada numa subclasse como referência para membros da superclasse. 
• ela tem o significado de: “a superclasse da classe corrente”. 
 
9.3 Polimorfismo 
Existem dois tipos de polimorfismo que são conhecidos como sobrecarga (overload) e sobreposição 
(override). 
Ocorre quando uma classe possui um método com o mesmo nome e assinatura (número, tipo e ordem de 
parâmetros) de um método na sua superclasse. Toda vez que isto ocorrer, a máquina virtual irá executar o método 
da classe mais especializada (a subclasse) e não o método da superclasse. Note que esta decisão ocorre em tempo 
de execução. 
Pág. 
 
9 OO - HERANÇA, POLIMORFISMO E INTERFACES 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 60 
Polimorfismo ocorre também quando existem dois métodos com mesmo nome, na mesma classe com e 
assinaturas diferentes. O método será escolhido de acordo com o número de parâmetros, tipo ou valor de retorno 
esperado. Note que esta decisão ocorre em tempo de compilação. 
Membros com mesmos identificadores substituem membros herdados. 
• Os membros definidos na superclasse podem ser acessados na subclasse através do qualificador super. 
• Métodos declarados como final não podem ser redefinidos. 
• Métodos abstratos devem ser redefinidos ou declarados como abstratos. 
9.3.1 Polimorfismo - Sobreescrita 
A sobrescrita (ou override) está diretamente relacionada à orientação a objetos, mais especificamente com a 
herança. Com a sobrescrita, conseguimos especializar os métodos herdados das superclasses, alterando o seu 
comportamento nas subclasses por um mais específico. 
A sobrescrita de métodos consiste basicamente em criar um novo método na classe filha contendo a mesma 
assinatura e mesmo tipo de retorno do método sobrescrito. 
Substituir a implementação de um método herdado por uma implementação própria da subclasse. 
public class Super 
{ 
... 
public void metodo1() 
{ 
 a = b * c; 
} 
} 
public class Sub extends Super 
{ 
... 
public void metodo1() 
{ 
 x = y + z; 
} 
} 
Pág. 
 
9 OO - HERANÇA, POLIMORFISMO E INTERFACES 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 61 
9.3.2 Polimorfismo – Sobrecarga 
A sobrecarga (overload) consiste em permitir, dentro da mesma classe, mais de um método com o mesmo 
nome. A sobrecarga de métodos (overload) é um conceito do polimorfismo que consiste basicamente em criar 
variações de um mesmo método, ou seja, a criação de dois ou mais métodos com nomes totalmente iguais em uma 
classe. A Sobrecarga permite que utilizemos o mesmo nome em mais de um método contanto que suas listas de 
argumentos sejam diferentes para que seja feita a separação dos mesmos. 
 
public class Fruta 
{ 
int gramas; 
int calorias_por_grama; 
 
public Fruta() 
{ 
gramas=55; 
calorias_por_grama=0; 
} 
public Fruta(int g, int c) 
{ 
this.gramas =g; 
this.calorias_por_grama =c; 
} 
} 
 
public class Feira 
{ 
public static void main(String args[]) 
{ 
Fruta melancia = new Fruta(4000, 5); 
Fruta manga = new Fruta (); 
manga.gramas=100; 
manga.calorias_por_grama=100; 
System.out.println(“manga “+ manga.gramas + “ gs “ + manga.calorias_por_grama); 
} 
} 
Pág. 
 
9 OO - HERANÇA, POLIMORFISMOE INTERFACES 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 62 
9.4 Exercício - Polimorfismo 
 
1) Crie duas classes que definam os seguintes atributos e métodos para objetos do tipo: 
 
 
 
 
 
 
 
 
 
 
Ao final crie um objeto da classe Empregado e um objeto da classe Gerente, atribuindo valores para seus 
salários e comissão para o gerente. Ao final execute os métodos getSalario() de ambos objetos. Lembrar que o 
salário do gerente é composto do salário + comissão. 
 
 
 
 
 
 
 
 
 
 
Pág. 
 
9 OO - HERANÇA, POLIMORFISMO E INTERFACES 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 63 
9.5 Interfaces 
Interface pode ser considerada como a forma com que um objeto se apresenta para outros, no que diz 
respeito aos seus atributos e métodos (sua funcionalidade). 
* É a representação externa de um objeto. 
* Na nossa vida, estamos acostumados a lidar com objetos através de sua interface, ignorando sua 
complexidade. 
 
 
 
 
 
 
 
 
 
 
 
 
• Criadas com a palavra reservada interface. 
• São sempre públicas. 
• Implementadas pelas classes com a palavra reservada implements. 
Exemplo Interface 
 public interface ControleRemoto 
 { 
 public void ligaTV(); 
 public void desligaTV(); 
 public void mudaCanalTV(int canalNovo); 
Pág. 
 
9 OO - HERANÇA, POLIMORFISMO E INTERFACES 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 64 
 } 
 
 public class TV implements ControleRemoto 
 { 
 public void ligaTV() {...} 
 public void desligaTV() {...} 
 public void mudaCanalTV(int canalNovo) {...} 
 } 
 
 
Pág. 
 
10 OO - CLASSES ABSTRATAS 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 65 
10 OO - CLASSES ABSTRATAS 
 
Por vezes, no desenvolvimento de bibliotecas, pode ser útil criar e definir métodos para uma classe que 
represente algum comportamento fundamental. Entretanto o comportamento não será implementado nessa classe. 
Em vez disso, os métodos serão implementados nas subclasses. 
Por exemplo, considere uma classe para representar uma venda. O valor de uma venda é subdividido entre 
valor da mercadoria + valor do imposto. Nossa classe genérica não conhece todos os tipos de imposto, mas as 
subclasses podem conhecer. Por exemplo uma classe que representa venda à vista sabe que o imposto para este 
tipo de venda é 1% e outra classe que representa venda à prazo, sabe que o tipo de imposto para este tipo de venda 
é de 2%. Então a superclasse Venda pode delegar às suas subclasses a tarefa de descobrir a taxa do seu imposto. 
Regras para classes abstratas 
Classes abstratas funcionam de forma muito semelhante às classes normais e praticamente tudo o que é 
possível fazer com classes normais, também pode ser feito com classes abstratas. 
- Elas são identificadas pela palavra chave abstract na definição da classe. 
- Seus métodos abstratos também são identificados pela palavra chave abstract na definição da classe. 
- Não é possível construir uma instância de uma classe abstract, a não ser indiretamente, construindo 
uma instância de uma subclasse dela. 
- As subclasses das classes abstratas devem fornecer implementações para todos os métodos abstratos 
das respectivas classes pai. Caso contrário, elas também serão classes abstratas. Portanto qualquer 
subclasse da classe Venda que não forneça uma implementação para retornar o taxa do imposto 
também será abstrata. 
- Métodos abstratos não podem ser privados nem estáticos. 
 
public abstract class Venda( 
 ... 
 public abstract double getTaxaImposto(); 
 ... 
} 
 
Pág. 
 
11 MODIFICADORES JAVA 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 66 
11 MODIFICADORES JAVA 
11.1 Introdução 
Os modificadores são utilizados para modificar os comportamentos das classes, métodos ou atributos. Os 
modificadores Java são public, protected, private, static, abstract, final, native, synchronized, transient e 
volatile. 
Alguns modificadores podem ser classificados como pertencentes a um grupo chamado modificadores de 
acesso, tais modificadores (public, protected, private) ditam como membros de uma classe são visíveis por outras 
classes. Os outros modificadores não possuem uma organização clara e serão explicados um a um. 
Para cada modificador será explicado o resultado de aplicá-lo sobre cada um dos seguintes elementos da 
linguagem: variáveis, métodos, construtores e classes. 
11.2 Modificadores de Acesso 
Os modificadores de acesso são padrões de visibilidade de acessos às classes, atributos e métodos. 
Esses modificadores são palavras-chaves reservadas pelo Java, ou seja, palavras reservadas não podem ser usadas 
como nome de métodos, classes ou atributos. 
Como boas práticas (best practices) do Java, na maioria das declarações de variáveis de instância são 
definidos os seus atributos com a palavra-chave private, para garantir a segurança de alterações acidentais, sendo 
somente acessíveis através dos métodos. Essa ação tem como efeito ajudar no encapsulamento dos dados, 
preservando ainda mais a segurança e a aplicação de programação orientada a objetos do Java. 
Por exemplo, quando um programa cria (instancia) um objeto da classe Banco, a variável senha é 
encapsulada (ocultada) no objeto onde pode ser acessada apenas por métodos da classe do objeto, os 
métodos getters e setters, que manipulam a variável de instância. Vejamos abaixo a explicação sobre cada um. 
 
Pág. 
 
11 MODIFICADORES JAVA 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 67 
11.2.1 Private 
O modificador de acesso private e o mais restritivo de todos, variáveis, métodos e construtores com esse 
modificador são visíveis somente dentro da definição da própria classe, acessando-o diretamente ou através de uma 
instância da mesma classe. 
O modificador private pode ser usado em variáveis, métodos e construtores. Em classes, seu uso é restrito a 
classes internas, ou seja, classes declaradas dentro de outras classes. 
Da forma como nossa classe ContaCorrente foi construída, por mais que modifiquemos o atributo saldo 
através do método sacar, é possível atribuir qualquer valor ao atributo saldo. 
public class ContaCorrente { 
 int numero; 
 double saldo; 
 
 boolean sacar(float valor){ 
 
 if (saldo>=valor) { 
 saldo = saldo - valor; 
 return true; 
 } 
 else return false; 
 } 
} 
public class Teste2 { 
 
 public static void main(String[] args) { 
 // Criando um objeto passando dois parâmetros(número e saldo inicial) em seu 
método construtor. 
 ContaCorrente conta = new ContaCorrente(100,5500.00); 
 // Realizando o saque por meio do método sacar 
 conta.sacar(1000); 
 // Alterando diretamente o atributo saldo do objeto conta 
 conta.saldo = -100; 
 } 
 
} 
 A melhor forma de resolver isso seria forçar quem usa a classe a chamar sempre o método sacar e não 
permitir que seja atribuído um valor diretamente ao atributo saldo. Para fazer isso em Java, basta declarar que os 
atributos não podem ser acessados fora da classe usando a palavra chave private. 
 
Pág. 
 
11 MODIFICADORES JAVA 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 68 
Isso é importante,pois pode ser que um valor inválido seja atribuído ao valor do saldo. A melhor forma de 
resolver isso seria forçar quem usa a classe ContaCorrente a chamar sempre o método sacar e não permitir que seja 
atribuído um valor diretamente ao atributo saldo. Para fazer isso em Java, basta declarar que os atributos não podem 
ser acessados fora da classe usando a palavra chave private. Assim, toda conversa de um objeto com outro é feita 
através de troca de mensagem (acessando seus métodos). Veja exemplo abaixo. 
public class ContaCorrente { 
 private int numero; 
 private double saldo; 
 
 // Método construtor da classe ContaCorrente 
 public ContaCorrente(int numero, double saldoInicial){ 
 // Atribuindo os valores recebidos no método construtor para os atributos da 
classe. 
 this.numero = numero; 
 this.saldo = saldo; 
 } 
 
 
 // Método para realizar o saque 
 public boolean sacar(float valor){ 
 
 if (saldo>=valor) { 
 saldo = saldo - valor; 
 return true; 
 } 
 else return false; 
 } 
 
} 
 
public class Teste2 { 
 
 public static void main(String[] args) { 
 // Criando um objeto passando dois parâmetros(número e saldo inicial) em seu 
método construtor. 
 ContaCorrente conta = new ContaCorrente(100,5500.00); 
 // Realizando o saque por meio do método sacar 
 conta.sacar(1000); 
 
 } 
 
} 
 11.2.2 Protected 
O modificador de acesso protected define que variáveis, métodos e construtores com esse modificador 
podem somente ser acessados por classes no mesmo pacote ou subclasses da classe onde o elemento foi definido, 
é importante notar que para os elementos serem acessados na subclasse não é preciso estar no mesmo pacote da 
Pág. 
 
11 MODIFICADORES JAVA 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 69 
classe pai. O modificador protected pode ser aplicado somente em variáveis, métodos e construtores, o seu uso em 
classes não é permitido. 
11.2.3 Public 
O mais abrangente de todos os tipos de acesso, o modificador public declara que elementos com esse 
modificador são acessíveis de qualquer classe Java. Este modificador é aplicável a variáveis, métodos, construtores 
e classes. 
11.2.4 Default (padrão) 
 A classe e/ou seus membros são acessíveis somente por classes do mesmo pacote, na sua declaração não 
é definido nenhum tipo de modificador, sendo este identificado pelo compilador. 
 
public class ModificadorDefault { 
 
 public static void main(String[] args) { 
 String nome = "Roberto Carlos"; 
 System.out.printf("Nome.: %s",nome); 
 } 
} 
A tabela a seguir apresenta um resumo dos modificadores de acesso. 
Tabela dos modificadores de acesso 
Escopo de acesso private default protected public 
mesma classe sim sim sim sim 
mesmo pacote não sim sim sim 
pacotes diferentes (subclasses) não não sim sim 
pacotes diferentes (sem subclasses) não não não sim 
 
11.3 Outros Modificadores 
11.3.1 Final 
O modificador final pode ser aplicado a variáveis, métodos e classes. O comportamento descrito pelo 
operador final varia de elemento para elemento, mas tem um conceito em comum, o conceito de imutabilidade, isto é, 
Pág. 
 
11 MODIFICADORES JAVA 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 70 
elementos final não podem ser mudados. Você pode desejar declarar classes que implementam seus algoritmos 
como classes final. 
11.3.2Abstract 
O modificador abstract pode ser aplicado somente a classes e métodos. Classes abstratas provem um 
modo de adiar a implementação de métodos para subclasses. Uma classe abstrata não pode ser instanciada, ou 
seja, não podemos chamar seus construtores. 
11.3.3 Static 
Este modificador pode ser aplicado a variáveis, métodos e a uma porção de código que não está dentro de 
nenhum método, geralmente referenciado como bloco estático. 
A ideia geral sobre o modificador static é que elementos com esse modificador estão associados com a 
classe e não com instâncias dessa classe. 
Uma variável estática é compartilhada por todas as instâncias de uma classe, ou seja, ao invés de cada 
instância da classe ter uma cópia dessa variável ela é uma única variável compartilhada por todos as instâncias. Para 
a existência de uma variável estática não é preciso nem mesmo a criação de uma instância da classe que contenha a 
variável, é necessário somente que a classe seja carregada na Máquina Virtual Java, já que está é criada e 
inicializada no momento de carga da classe. 
Em relação a métodos as mesmas explicações são verdadeiras, ou seja, métodos podem ser chamados 
mesmo sem nenhuma instância da classe ter sido construída. Um bom exemplo de métodos estáticos existe em toda 
aplicação Java, o método main() é invocado sem a existência de nenhuma instância. 
Métodos e variáveis podem ser referenciados além da forma padrão (através do nome do objeto) através do 
nome da classe. Embora as duas formas sejam corretas e trabalham exatamente da mesma forma a primeira pode 
tornar-se confusa quando referenciando métodos e variáveis estáticas, levando o programador a pensar que este 
método ou variável é não estático. Por esse motivo e conveniente sempre referenciar variáveis estáticas através do 
nome da classe para evitar confusões. 
É importante dizer que métodos estáticos podem somente acessar variáveis também estáticas, ou seja, é 
proibido o uso de variáveis não estáticas dentro de blocos estáticos, com exceção de variáveis criadas dentro do 
próprio bloco é claro. Essa restrição se deve ao fato de que é possível fazer uma chamada a um método estático 
mesmo sem haver nenhuma instância dessa classe, ou seja, a provável variável a ser referenciada dentro do método 
pode nem mesmo ter sido criada ainda. 
Pág. 
 
11 MODIFICADORES JAVA 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 71 
Outra importante característica é que não podemos usar a palavra chave this com métodos e variáveis 
estáticas, já que este é uma referência para o objeto que contém o método o qual não é verdadeiro para métodos e 
variáveis estáticas já que estes não pertencem a um objeto em particular, mas sim a classe. 
11.3.4 Transient 
É aplicado somente a variáveis. Quando uma variável é declarada transient ela não é guardada como parte 
do estado de persistência do objeto. 
11.3.5 Synchronized 
Esse modificador é usado para sincronizar o acesso a código em ambientes paralelos. Este modificador será 
visto detalhadamento onde veremos threads e métodos de sincronização. 
11.3.6 Volatile 
São aplicados somente a variáveis. Volatile permite que várias threads acessem simultaneamente a mesma 
variável. 
11.3.7 Native 
 Esse modificador é usado somente em métodos. Algumas vezes é necessário executar código não Java em 
aplicações. Quando desejamos acessar chamadas do Sistema Operacional, interfacear com dispositivos de 
hardware, reusar código não Java, implementar código onde o tempo é um parâmetro crítico e etc... 
11.4 Encapsulamento 
Uma das ideias mais importantes da orientação a objetos é o encapsulamento. Encapsular significa esconder 
a implementação dos objetos. O encapsulamento favorece principalmente dois aspectos de um sistema: a 
manutenção e o desenvolvimento. 
A manutenção é favorecida pois, uma vez aplicado o encapsulamento, quando o funcionamento de um objeto 
deve ser alterado, em geral, basta modificar a classe do mesmo. 
O desenvolvimento é favorecido pois, uma vez aplicado o encapsulamento, conseguimos determinar 
precisamente as responsabilidades de cada classe da aplicação. 
OBJETIVOS DO ENCAPSULAMENTOServe para ocultar os dados; evita que o usuário acesse membros que ele não precisa manipular; permite a 
modificação interna de uma classe sem alterar a sua funcionalidade e o modo como é acessada e é utilizado em 
Java através dos modificadores de acesso. 
Pág. 
 
11 MODIFICADORES JAVA 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 72 
 
11.4.1 Métodos Getters e Setters 
 
Na linguagem Java, há uma convenção de nomenclatura para os métodos que têm como finalidade acessar 
ou alterar as propriedades de um objeto. 
Segundo essa convenção, os nomes dos métodos que permitem a consulta das propriedades de um objeto 
devem possuir o prefixo get. Analogamente, os nomes dos métodos que permitem a alteração das propriedades de 
um objeto devem possuir o prefixo set. 
Na maioria dos casos, é muito conveniente seguir essa convenção, pois os desenvolvedores Java já estão 
acostumados com essas regras de nomenclatura e o funcionamento de muitas bibliotecas do Java depende 
fortemente desse padrão. 
class Cliente { 
 
 // Atributos da classe 
 private String nome; 
 private String cpf; 
 
 // Métodos acessadores para os atributos da classe 
 
 public String getNome() { 
 return nome; 
 } 
 public void setNome(String nome) { 
 this.nome = nome; 
 } 
 public String getCpf() { 
 return cpf; 
 } 
 public void setCpf(String cpf) { 
 this.cpf = cpf; 
 } 
 
} 
 
IMPORTANTE 
Os métodos gets e sets são utilizados para permitir o acesso aos atributos (já que eles são private) de uma 
maneira controlada, a prática mais comum é criar dois métodos 
 
 
Pág. 
 
11 MODIFICADORES JAVA 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 73 
11.5 Exercício 
 
1) Julgue V ou F os seguintes itens a seguir acerca dos modificadores de Java. 
 
( ) public: Uma classe declarada como pública dá as outras classes, de todos os pacotes, acesso aos seus membros 
que forem públicos também. 
 
( ) private: O membro da classe não pode ser acessado por nenhuma outra classe, quando é declarado private. 
Como não é visto pelas subclasses, não se aplica regras de overriding. Esse modificador não se aplica a classes, 
somente a seus membros (métodos e atributos). 
 
( ) protected: Quando um membro da classe é declarado assim, ele se torna acessível por classes do mesmo pacote 
ou através de herança. 
 
( ) abstract: Quando é aplicado à classe não permite estendê-la, nos métodos impede que o mesmo seja sobrescrito 
(overriding) na subclasse, já nas variáveis impossibilita que essa seja reinicializada com outro valor. 
 
( ) final: Classes declaradas como abstratas provém um modo de adiar a implementação de métodos também 
declarados como abstratos para subclasses. Uma classe abstrata não pode ser instanciada, ou seja, não podemos 
chamar os seus construtores. 
 
( ) static: Variáveis e métodos marcados como static pertencem à classe, ao invés de alguma instância dessa, esse 
modificador não se aplica a classes. 
 
( ) public : É o mais restritivo de todos. Atributos e métodos declarados como public em uma classe podem ser 
acessados pelos métodos da própria classe, por classes derivadas desta e por qualquer outra classe em qualquer 
outro pacote. 
 
( ) protected : Atributos e métodos definidos como protected são acessíveis pelos métodos da própria classe e pelas 
classes derivadas. 
 
 ( ) private : É o mais restritivo. Atributos e métodos declarados como private só podem ser acessados pelos 
métodos da própria classe. 
 
 ( ) A instrução final indica que a classe, método ou variável assim declarada têm uma única atribuição que se 
mantém constante, ou seja, não pode ser alterada no decorrer do processamento. 
Pág. 
 
11 MODIFICADORES JAVA 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 74 
( ) O nível de acesso protected é mais restritivo do que o nível de acesso private. 
( ) Os métodos declarados como public só podem ser acessados a partir dos métodos da própria classe ou de 
classes derivadas. 
 
2) Porque esse código não compila? 
class Teste { 
 
int x = 37; 
 
public static void main(String [] args) { 
 System.out.println(x); 
 } 
} 
R = 
 
3) Defina uma classe Funcionário com os atributos nome, cargo e salário. Na mesma classe, defina os métodos 
acessadores para garantir o encapsulamento dos atributos. Defina outra classe com o método main para 
criar objetos da classe Funcionário e executar os seus métodos. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Pág. 
 
12 EXCEÇÕES – CONTROLANDO OS ERROS 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 75 
12 EXCEÇÕES – CONTROLANDO OS ERROS 
 
 Exceção é uma indicação de um problema que ocorre durante a execução de um programa. O nome 
“exceção” significa que o problema não ocorre frequentemente. Com o tratamento de exceções, um programa 
pode continuar executando (em vez de encerrar) depois de lidar com um problema. Uma exceção é um sinal que 
indica que algum tipo de condição excepcional ocorreu durante a execução do programa. Assim, exceções estão 
associadas a condições de erro que não tinham como ser verificadas durante a compilação do programa. 
As duas atividades associadas à manipulação de uma exceção são: 
geração: a sinalização de que uma condição excepcional (por exemplo, um erro) ocorreu, e 
captura: a manipulação (tratamento) da situação excepcional, onde as ações necessárias para a recuperação 
da situação de erro são definidas. 
 
Para cada exceção que pode ocorrer durante a execução do código, um bloco de ações de tratamento (um 
exception handler) deve ser especificado. O compilador Java verifica e enforça que toda exceção “não-trivial” tenha 
um bloco de tratamento associado. 
 
O mecanismo de manipulação de exceções em Java, embora apresente suas particularidades, teve seu 
projeto inspirado no mecanismo equivalente de C++, que por sua vez foi inspirado em Ada. É um mecanismo 
adequado à manipulação de erros síncronos, para situações onde a recuperação do erro é possível. 
 
A sinalização da exceção é propagada a partir do bloco de código onde ela ocorreu através de toda a pilha 
de invocações de métodos até que a exceção seja capturada por um bloco manipulador de exceção. Eventualmente, 
se tal bloco não existir em nenhum ponto da pilha de invocações de métodos, a sinalização da exceção atinge o 
método main(), fazendo com que o interpretador Java apresente uma mensagem de erro e aborte sua execução. 
 
12.1 Tratamento de exceções 
 
A captura e o tratamento de exceções em Java se dá através da especificação de blocos try, catch e finally, 
definidos através destas mesmas palavras reservadas da linguagem. 
 
A estruturação desses blocos obedece à seguinte sintaxe: 
try { 
// código que inclui comandos/invocações de métodos 
// que podem gerar uma situação de exceção. 
} 
catch (XException ex) { 
Pág. 
 
12 EXCEÇÕES – CONTROLANDO OS ERROS 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 76 
// bloco de tratamento associado à condição de 
// exceção XException ou a qualquer uma de suas 
// subclasses, identificada aqui pelo objeto 
// com referência ex 
} 
catch (YException ey) { 
// bloco de tratamento para a situação de exceção 
// YException ou a qualquer uma de suas subclasses 
} 
finally { 
// bloco de código quesempre será executado após 
// o bloco try, independentemente de sua conclusão 
// ter ocorrido normalmente ou ter sido interrompida 
} 
onde XException e YException deveriam ser substituídos pelo nome do tipo de exceção. Os blocos não podem ser 
separados por outros comandos — um erro de sintaxe seria detectado pelo compilador Java neste caso. Cada bloco 
try pode ser seguido por zero ou mais blocos catch, onde cada bloco catch refere-se a uma única exceção. 
O bloco finally, quando presente, é sempre executado. Em geral, ele inclui comandos que liberam recursos que 
eventualmente possam ter sido alocados durante o processamento do bloco try e que podem ser liberados, 
independentemente de a execução ter encerrado com sucesso ou ter sido interrompida por uma condição de 
exceção. A presença desse bloco é opcional. Alguns exemplos de exceções já definidas no pacote java.lang incluem: 
 
ArithmeticException: indica situações de erros em processamento aritmético, tal como uma divisão inteira por 0. A 
divisão de um valor real por 0 não gera uma exceção (o resultado é o valor infinito); 
 
NumberFormatException: indica que tentou-se a conversão de uma string para um formato numérico, mas seu 
conteúdo não representava adequadamente um número para aquele formato. É uma subclasse de 
IllegalArgumentException; 
 
IndexOutOfBounds: indica a tentativa de acesso a um elemento de um agregado aquém ou além dos limites 
válidos. É a superclasse de ArrayIndexOutOfBoundsException, para arranjos, e de StringIndexOutOfBounds, para 
strings; 
 
NullPointerException: indica que a aplicação tentou usar uma referência a um objeto que não foi ainda definida; 
 
ClassNotFoundException: indica que a máquina virtual Java tentou carregar uma classe mas não foi possível 
encontrá-la durante a execução da aplicação. 
 
Além disso, outros pacotes especificam suas exceções, referentes às suas funcionalidades. Por exemplo, no 
pacote java.io define-se IOException, que indica a ocorrência de algum tipo de erro em operações de entrada e 
saída. É a superclasse para condições de exceção mais específicas desse pacote, tais como EOFException (fim de 
Pág. 
 
12 EXCEÇÕES – CONTROLANDO OS ERROS 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 77 
arquivo ou stream), FileNotFoundException (arquivo especificado não foi encontrado) e InterruptedIOException 
(operação de entrada ou saída foi interrompida). 
Uma exceção contém pelo menos uma string que a descreve, que pode ser obtida pela aplicação do método 
getMessage(), mas pode eventualmente conter outras informações. Por exemplo, InterruptedIOException inclui um 
atributo público do tipo inteiro, bytesTransferred, para indicar quantos bytes foram transferidos antes da interrupção 
da operação ocorrer. Outra informação que pode sempre ser obtida de uma exceção é a seqüência de métodos no 
momento da exceção, obtenível a partir do método printStackTrace(). 
Como exceções fazem parte de uma hierarquia de classes, exceções mais genéricas (mais próximas do topo 
da hierarquia) englobam aquelas que são mais específicas. Assim, a forma mais genérica de um bloco try-catch é 
try { ... } 
catch (Exception e) { ... } 
 
pois todas as exceções são derivadas de Exception. Se dois blocos catch especificam exceções em um mesmo ramo 
da hierarquia, a especificação do tratamento da exceção derivada deve preceder aquela da mais genérica. 
 
12.2 Erros e Exceções de runtime 
 
Exceções consistem de um caso particular de um objeto da classe Throwable. Apenas objetos dessa classe 
ou de suas classes derivadas podem ser gerados, propagados e capturados através do mecanismo de tratamento de 
exceções. 
Além de Exception, outra classe derivada de Throwable é a classe Error, que é a raiz das classes que 
indicam situações que a aplicação não tem como ou não deve tentar tratar. Usualmente indica situações anormais, 
que não deveriam ocorrer. Entre os erros definidos em Java, no pacote java.lang, estão StackOverflowError e 
OutOfMemoryError. São situações onde não é possível uma correção a partir de um tratamento realizado pelo 
próprio programa que está executando. 
Há também exceções que não precisam ser explicitamente capturadas e tratadas. São aquelas derivadas de 
RuntimeException, uma classe derivada diretamente de Exception. São exceções que podem ser geradas durante a 
operação normal de uma aplicação para as quais o compilador Java não irá exigir que o programador proceda a 
algum tratamento (ou que propague a exceção, como descrito na Seção 2.6.3). Entre essas incluem-se 
ArithmeticException, IllegalArgumentException, IndexOutOfBoundsException e NullPointerException. 
 
12.3 Propagando exceções 
 
Embora toda exceção que não seja derivada de RuntimeException deva ser tratada, nem sempre é possível 
tratar uma exceção no mesmo escopo do método cuja invocação gerou a exceção. Nessas situações, é possível 
propagar a exceção para um nível acima na pilha de invocações. Para tanto, o método que está deixando de capturar 
e tratar a exceção faz uso da cláusula throws na sua declaração: 
Pág. 
 
12 EXCEÇÕES – CONTROLANDO OS ERROS 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 78 
 
void métodoQueNãoTrataExceção() throws Exception { 
invoca.métodoQuePodeGerarExceção(); 
} 
 
Nesse caso, métodoQueNãoTrataExceção() reconhece que em seu corpo há a possibilidade de haver a 
geração de uma exceção mas não se preocupa em realizar o tratamento dessa exceção em seu escopo. Ao 
contrário, ele repassa essa responsabilidade para o método anterior na pilha de chamadas. 
 
Eventualmente, também o outro método pode repassar a exceção adiante. Porém, pelo menos no método 
main() as exceções deverão ser tratadas ou o programa pode ter sua interpretação interrompida. 
 
12.4 Definindo e gerando exceçoes 
 
Exceções são classes. Assim, é possível que uma aplicação defina suas próprias exceções através do 
mecanismo de definição de classes. 
 
Por exemplo, considere que fosse importante para uma aplicação diferenciar a condição de divisão por zero 
de outras condições de exceções artiméticas. Neste caso, uma classe DivideByZeroException poderia ser criada: 
 
public class DivideByZeroExceptionextends ArithmeticException { 
 
public DivideByZeroException() { 
super("O denominador na divisão inteira tem valor zero"); 
 } 
 
} 
Neste caso, o argumento para o construtor da superclasse especifica a mensagem que seria impressa 
quando o método getMessage() fosse invocado para essa exceção. Essa é a mesma mensagem que é apresentada 
para um RuntimeException que não é capturado e tratado. 
Para gerar uma condição de exceção durante a execução de um método, um objeto dessa classe deve ser 
criado e, através do comando throw, propagado para os métodos anteriores na pilha de execução: 
 
public double calculaDivisao (double numerador, int denominador) 
throws DivideByZeroException { 
if (denominador == 0) 
throw new DivideByZeroException(); 
return numerador / denominador; 
} 
 
Pág. 
 
12 EXCEÇÕES – CONTROLANDO OS ERROS 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 79 
O mesmo comando throw pode ser utilizado para repassar uma exceção após sua captura—por exemplo, 
após um tratamento parcial da condição de exceção: 
public void usaDivisao() throws DivideByZeroException { 
... 
try { 
d = calculaDivisao(x, y); 
} 
catch (DivideByZeroException dbze) { 
... 
throw dbze; 
} 
... 
} 
Nesse caso, a informação associada à exceção (comoo seu ponto de origem, registrado internamente no 
atributo do objeto que contém a pilha de invocações) é preservada. Caso fosse desejado mudar essa informação, 
uma nova exceção poderia ser gerada ou, caso a exceção seja a mesma, o método fillInStackTrace() poderia ser 
utilizado, como em 
throw dbze.fillInStackTrace(); 
12.5 Hierarquia de exceções Java 
 As classes de exceção herdam direta ou indiretamente da classe Exception, formando uma 
hierarquia de herança. Pode estender essa hierarquia com suas próprias classes de exceção.A figura 
abaixo mostra uma pequena parte da hierarquia de herança da classe Throwable (uma subclasse de 
Object), que é a superclasse da classe Exception. Somente objetos Throwable podem ser utilizados com o 
mecanismo de tratamento de exceções. A classe Throwable tem duas subclasses: Exception e Error. A 
classe Exception e suas subclasses representam situações excepcionais que podem ocorrer em um 
programa Java. Essas subclasses podem ser capturadas e tratadas pelo aplicativo. A classe Error e suas 
subclasses representam situações anormais que podem acontecer na JVM. 
Pág. 
 
12 EXCEÇÕES – CONTROLANDO OS ERROS 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 80 
 
Pág. 
 
THREADS 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 81 
13 THREADS 
 
13.1 Conceito de Threads 
Se pensarmos nos programas que utilizamos comumente no dia a dia, conseguiremos chegar a seguinte 
conclusão: um programa executa um conjunto de tarefas relativamente independentes entre si. Por exemplo, um 
navegador pode baixar vários arquivos diferentes além de permitir a navegação. Um software de visualização de 
vídeos além de reproduzir imagens também reproduzir sons. 
Se pensarmos em sistemas corporativos, também chegamos na mesma conclusão: um sistema corporativo 
executa um conjunto de tarefas relativamente independentes entre si. Por exemplo, dois ou mais usuários acessando 
o mesmo sistema para fazer coisas diferentes. 
Neste sentido uma thread trabalha como um subsistema, sendo uma forma de um processo se autodividir em 
duas ou mais tarefas. É o termo em inglês para Linha ou Encadeamento de Execução. 
O conceito de thread está intimamente ligado ao conceito de processo, assim é fundamental entender o que são 
processos, como eles são representados e colocados em execução pelo Sistema Operacional, para em seguida 
entender as threads. 
Dessa forma segue uma breve definição de Processo e posteriormente a de Thread. 
 
 
Definição de Processo 
“Um processo é basicamente um programa em execução, sendo constituído do código executável, dos dados 
referentes ao código, da pilha de execução, do valor do contador de programa (registrador PC), do valor do 
apontador do apontador de pilha (registrador SP), dos valores dos demais registradores do hardware, além de um 
conjunto de outras informações necessárias à execução dos programas.” Tanenbaum 
 
 
Definição de Thread 
“Thread, ou processo leve, é a unidade básica de utilização da CPU, consistindo de : contador de programa, conjunto de 
registradores e uma pilha de execução. Thread são estruturas de execução pertencentes a um processo e assim compartilham os 
segmentos de código e dados e os recursos alocados ao sistema operacional pelo processo. O conjunto de threads de um 
processo é chamado de Task e um processo tradicional possui uma Task com apenas uma thread.” Silberschatz 
 
 
Pág. 
 
THREADS 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 82 
 
 Paralelismo x Concorrência 
Threads podem executar suas funções de forma paralela ou concorrente, onde quando as threads são 
paralelas elas desempenham o seus papeis independente uma das outras. Já na execução concorrente, as threads 
atuam sobre objetos compartilhados de forma necessitando de sincronismo no acesso a esses objetos, assim deve 
ser garantido o direito de atomicidade e exclusão mútua nas operações das threads sobre objetos compartilhados. 
13.2 Ciclo de Vida de uma Thread 
Durante a vida de uma thread ela pode estar em vários estados, conforme pode ser visto abaixo. 
 
 
13.2.1 Criando Threads 
A criação de uma thread é feita através do chamado ao seu construtor colocando a thread no estado Nova, o 
qual representa uma thread vazia, ou seja, nenhum recurso do sistema foi alocado para ela ainda. Quando uma 
thread está nesse estado a única operação que pode ser realizada é a inicialização dessa thread através do método 
start(), se qualquer outro método for chamado com a thread no estado Nova irá acontecer uma exceção 
(IllegalThreadStateException), assim como, quando qualquer método for chamado e sua ação não for condizente 
com o estado atual da thread. 
Pág. 
 
THREADS 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 83 
13.2.2 Iniciando Threads 
A inicialização de uma thread é feita através do método start() e nesse momento os recursos necessários 
para execução da mesma são alocados, tais como recursos para execução, escalonamento e chamada do método 
run da thread. 
13.2.3 Fazendo Thread Esperar 
Uma thread irá para o estado Esperando quando: 
 
 O método sleep (faz a thread esperar por um determinada tempo) for chamado; 
 O método wait (faz a thread esperar por uma determinada condição) for chamado; 
 Quando realizar solicitação de I/O. 
13.2.4 Finalizando Threads 
Uma Thread é finalizada quando acabar a execução do seu método run, e então ela vai para o estado Morta, 
onde o Sistema de Execução Java poderá liberar seus recursos e eliminá-la . 
13.2.5 Verificando se Threads estão Executando/Pronta/Esperando ou Novas/Mortas 
 
A classe Thread possui o método isAlive, o qual permite verificar se uma thread está nos estado 
Executando/Pronta/Esperando ou nos estados Nova/Morta. Quando o retorno do método for true a thread esta 
participando do processo de escalonamento e o retorno for false a thread está fora do processo de escalonamento. 
Não é possível diferenciar entre Executando, Pronta ou Esperando, assim também como não é possível diferenciar 
entre Nova ou Morta. 
13.3 Implementando Threads em java 
Podemos, em Java, facilmente criar uma classe que tem um método que vai ser executado 
concorrentemente com o seu main. Para isso, você precisa implementar a interface Runnable, que define o método 
run. 
 
class ThreadTeste 
{ 
 public static void main (String args[]) 
 { 
 ThreadInterface tiJ = new ThreadInterface(); 
 Thread thread = new Thread(tiJ); 
 thread.start(); 
 } 
} 
// Classe que implementa a interface Runnable 
Pág. 
 
THREADS 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 84 
public class ThreadInterface implements Runnable { 
 public void run() 
 { 
 for (int i=0; i<100; i++) { 
 System.out.println(" Contador --> "+i); 
 } 
 } 
} 
Como a classe Thread implementa Runnable, é possível criar uma subclasse de Threads e reescrever o run, 
que na classe Thread não faz nada, conforme exemplo abaixo: 
package threads; 
 
class MinhaThread extends Thread 
{ 
 public MinhaThread(String nome){ 
 super(nome); 
 } 
 
 public void run(){ 
 
 for (int i=0; i<10; i++) 
 { 
 System.out.println(getName()+ " - " +i ); 
 } 
 } 
 
} 
package threads; 
 
public class Teste { 
 public static void main(String args[]){ 
 MinhaThread a,b; 
 a = new MinhaThread("Joao"); 
 b = new MinhaThread("Jose"); 
 a.start();b.start(); 
 } 
} 
 
 
Threads: Alguns métodos 
 
• public static native void yield() 
– faz uma suspensão temporária da execução da Thread e permite que outra execute. 
 
• public static native void sleep(long millis) throws InterruptedException 
– faz a corrente threat em execução “dormir” por um período de tempo (cessa a execução temporariamente) por um 
número de milisegundos específico. 
– Throws: caso outra thread tenha interrompido esta thread. 
 
• public native synchronized void start() 
– causa o início da execução da thread. A Java Virutal Machine chama o método run para a thread. 
– Throws: IilegalThreadStateException ocorre caso a thread já tenha sido iniciada. 
Pág. 
 
THREADS 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 85 
 
• public void run() 
– Se essa thread tenha sido construída usando um objeto Runnable, então o método run deste objeto será chamado. 
Caso contrário nada é executado e retorna. 
 
• public final void stop() 
– força a thread para a execução. 
 
• public final void setPriority (int newPriority) 
– muda a prioridade de uma thread. 
 
• public final int getPriority() 
– retorna a prioridade da thread 
 
• public final void setName (String name) 
– muda o nome da thread para o novo nome 
 
• public final String getName() 
– retorna o nome da thread 
Threads Daemon 
São threads que rodam em background e realizam tarefas de limpeza ou manutenção, as quais devem rodar 
enquanto a aplicação estiver em execução, as threads daemons somente morrerem quando a aplicação for 
encerrada. Threads daemons são denominadas de Threads de Serviço e as não daemon são denominadas de 
Threads de Usuário. 
Os métodos para manipulação de threads daemon são: 
public final void setDaemon(boolean) Torna ou não uma thread daemon 
public final boolean isDaemon() Verifica se uma thread é daemon 
13.4 Escalonamento de Threads 
O escalonamento é fundamental quando é possível a execução paralela de threads, pois, certamente 
existirão mais threads a serem executadas que processadores, assim a execução paralela de threads é simulada 
através de mecanismos do escalonamento dessas threads, onde os processadores disponíveis são alternados pelas 
diversas threads em execução. O mecanismo de escalonamento utilizado pelo Sistema de Execução Java é bastante 
simples e determinístico, e utiliza um algoritmo conhecido como Escalonamento com Prioridades Fixas, o qual 
escalona threads baseado na sua prioridade. As threads escalonáveis são aquelas que estão nos estados 
Executando ou Pronta, para isso toda thread possui uma prioridade, a qual pode ser um valor inteiro no intervalo 
[MIN_PRIORITY ... MAX_PRIORITY], (estas são constantes definidas na classe Thread), e quanto maior o valor do 
inteiro maior a prioridade da thread. Cada thread Nova recebe a mesma prioridade da thread que a criou e a 
prioridade de uma thread pode ser alterada através do método setPriority(int priority). 
 
Exemplo de aplicação usando threads com diferentes prioridades 
Pág. 
 
THREADS 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 86 
Observe que essa corrida não é justa pois os sapos 4 e 5 possuem prioridades máximas e com certeza 
ganharão a corrida. 
Exemplo1: 
/* Aplicação que simula uma corrida de sapos usando threads */ 
public class CorridaDeSapos { 
 
 final static int NUM_SAPOS = 5; // QTE. de sapos na corrida 
 final static int DISTANCIA = 500; // Distância da corrida em cm 
 public static void main (String[] args) { 
 
 /* Criando as threads para representar os sapos correndo */ 
 SapoCorrendoThread sapo_1 = new SapoCorrendoThread("SAPO_01", DISTANCIA); 
 SapoCorrendoThread sapo_2 = new SapoCorrendoThread("SAPO_02", DISTANCIA); 
 SapoCorrendoThread sapo_3 = new SapoCorrendoThread("SAPO_03", DISTANCIA); 
 SapoCorrendoThread sapo_4 = new SapoCorrendoThread("SAPO_04", DISTANCIA); 
 SapoCorrendoThread sapo_5 = new SapoCorrendoThread("SAPO_05", DISTANCIA); 
 
 /* Estabelecendo prioridades para as threads */ 
 sapo_1.setPriority(Thread.MIN_PRIORITY); 
 sapo_2.setPriority(Thread.MIN_PRIORITY); 
 sapo_3.setPriority(Thread.NORM_PRIORITY); 
 sapo_4.setPriority(Thread.MAX_PRIORITY); 
 sapo_5.setPriority(Thread.MAX_PRIORITY); 
 
 /* Iniciando as threads */ 
 sapo_1.start(); 
 sapo_2.start(); 
 sapo_3.start(); 
 sapo_4.start(); 
 sapo_5.start(); 
 } 
} 
 
Simulação de uma Corridas de Sapos, onde cada sapo na corrida é representado por uma 
thread. 
Exemplo2: 
public class CorridaDeSapos2 { 
 final static int NUM_SAPOS = 5; // QTE. de sapos na corrida 
 final static int DISTANCIA = 500; // Distância da corrida em cm 
 
 public static void main (String[] args) { 
 /* colocando sapos na corrida */ 
 for (int i = 1; i <= NUM_SAPOS; i++) { 
 new SapoCorrendoThread("SAPO_" + i, DISTANCIA).start(); 
 } 
 } 
} 
Pág. 
 
THREADS 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 87 
 
Classe SapoCorrendoThread utilizada pelas duas classes dos exemplos acima. 
 
class SapoCorrendoThread extends Thread { 
 
 String nome; // nome do sapo 
 int distanciaCorrida = 0; // distância já corrida pelo sapo 
 int distanciaTotalCorrida; // distância a ser corrida pelo sapo 
 int pulo = 0; // pulo do sapo em cm 
 int pulos = 0; // quantidades de pulos dados na corrida 
 static int colocacao = 0; // colocação do sapo ao final da corrida 
 final static int PULO_MAXIMO = 50; // pulo máximo em cm que um sapo pode dar 
 /** Construtor da classe. Parâmtros : Nome do Sapo e Distância da Corrida */ 
 
 public SapoCorrendoThread (String nome, int distanciaTotalCorrida) { 
 /* chamando o construtor de Thread passando o nome do sapo como parâmetro */ 
 super(nome); 
 this.distanciaTotalCorrida = distanciaTotalCorrida; 
 this.nome = nome; 
 } 
 
 /** Imprime o último pulo do sapo e a distância percorrida */ 
 public void sapoImprimindoSituacao () { 
 System.out.println("O " + nome + " pulou " + pulo + "cm \t e já percorreu " + 
 distanciaCorrida + "cm"); 
 } 
 
 /** Faz o sapo pular */ 
 public void sapoPulando() { 
 pulos++; 
 pulo = (int) (Math.random() * PULO_MAXIMO); 
 distanciaCorrida += pulo; 
 if (distanciaCorrida > distanciaTotalCorrida) { 
 distanciaCorrida = distanciaTotalCorrida; 
 } 
 } 
 
 /** Representando o descanso do sapo */ 
 public void sapoDescansando () { 
 /* Método que passa vez a outras threads */ 
 yield(); 
 } 
 
 /** Imprime a colocação do sapo ao final da corrida */ 
 public void colocacaoSapo () { 
 colocacao++; 
 System.out.println(nome + " foi o " + colocacao + "º colocado com " + pulos + " 
pulos"); 
 } 
 
 /** Método run da thread Corrida de Sapos */ 
 public void run () { 
 while (distanciaCorrida < distanciaTotalCorrida) { 
Pág. 
 
THREADS 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 88 
 sapoPulando(); 
 sapoImprimindoSituacao(); 
 sapoDescansando(); 
 } 
 colocacaoSapo(); 
 } 
} 
 
13.5 Exercícios 
 
a) Defina a classe Contador como uma subclasse de Thread, que imprime números de 0 a 10. Crie a classe 
TesteContador que deve definir o método main que cria e inicia a execução do thread Contador. Teste o 
resultado executando a classe TesteContador. 
 
b) Altere as classes Contador e TesteContador de modo que a classe Contador seja definida como uma 
implementação da interface Runnable. Teste o resultado. 
 
Pág. 
 
14 API JAVA - JAVA.IO 
 
 
 
JAVA OO LOGUSTI – TREINAMENTOEM INFORMÁTICA PÁGINA 89 
14 API JAVA - JAVA.IO 
A linguagem Java é capaz de processar arquivos que requisitam grandes quantidades de dados persistentes. 
Esses são os dados que ficam armazenados dentro dos arquivos, sendo que a sua duração vai além da finalização 
de um programa. Esse processamento de arquivos é uma capacidade que o Java oferece para ler e gravar dados na 
memória, arquivos e conexões de rede. 
Quando existe um dispositivo de entrada de dados ativo, para obter dados deste dispositivo é usada uma 
ação conhecida como read(). E para enviar um dado para um dispositivo de saída é utilizado o método write(). 
Para trabalhar com entrada e saída de dados são utilizadas as classes que estão dentro do java.io. Essas 
classes oferecem algumas funcionalidades como: 
 Manipulação de entrada e saída de bytes – transferência de dados binários; 
 Manipulação de entrada e saída de caracteres – transferência de textos; 
 Buffers - melhoram a eficiência da velocidade de leitura e escrita; 
 Conversão de formatos – texto e formato interno de dados binários. 
As entradas e saídas de dados são manipuladas como sequência de bytes, através das classes 
InputStream e OutputStream e as classes dependentes. 
 
14.1 Classe InputStream 
É uma classe abstrata que oferece a funcionalidade básica para a leitura de um byte ou de uma sequência 
de bytes a partir de alguma fonte. 
Pág. 
 
14 API JAVA - JAVA.IO 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 90 
14.2 Lendo um arquivo 
Os métodos read() oferecem a leitura de bytes. O valor de retorno desse método é um inteiro, que pode ser o 
byte lido do próprio método ou número de bytes lidos do método read(byte[] b) sendo que quando o retorno for o 
valor de -1, é informado que o final do arquivo foi atingindo. 
 InputStream is = new FileInputStream("arquivo.txt"); 
 int valor = is.read(); 
Exemplo 1 
No exemplo acima, a classe abstrata InputStream é declarada inicializando uma classe dependente, a 
FileInputStream. Essa classe recebe uma String como argumento no construtor. Esse argumento é a definição de 
onde está localizado o arquivo. 
 
 
Pág. 
 
14 API JAVA - JAVA.IO 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 91 
Então as principais subclasses de InputStream são: 
 ByteArrayInputStream – Valores são originários de um arranjo de bytes; 
 FileInputStream – Bytes com originalidade de um arquivo. 
 FilterInputStream – Filtra os dados de um InputStream. 
 BufferedInputStream – Faz a leitura de grandes volumes de bytes que armazena em um buffer interno. 
 DataInputStream – Permite a leitura de representações binárias dos tipos primitivos de Java. 
 ObjectInputStream – Oferece o método readObject para a leitura de objetos que foram serializados para um 
ObjectOutputStream. 
 PipedInputStream – Faz a leitura de um pipe de bytes cuja origem está associada a um objeto 
PipedOutputStream. 
import java.io.BufferedReader; 
import java.io.IOException; 
import java.io.InputStream; 
import java.io.InputStreamReader; 
 
public class TestaEntrada { 
 
 public static void main(String[] args) throws IOException{ 
 
 InputStream is = System.in; 
 System.out.print("Digite um texto: "); 
 
 InputStreamReader isr = new InputStreamReader(is); 
 BufferedReader br = new BufferedReader(isr); 
 
 String digitado = br.readLine(); 
 
 while(digitado != null){ 
 System.out.println("Texto Digitado = "+digitado); 
 digitado = br.readLine(); 
 } 
 
 } 
} 
Exemplo 2 
Pág. 
 
14 API JAVA - JAVA.IO 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 92 
14.3 OutputStream 
É uma classe abstrata que transfere sequencialmente os bytes para algum destino. Os métodos write(), tem 
a função de escrever em forma de bytes para o destino onde vai enviar. 
 
Subclasses OutputStream 
As classes abstratas Reader e Writer se envolvem na manipulação de arquivos (leitura e escrita) que 
contém caracteres. 
14.4 Reader 
É uma classe abstrata sendo igual à InputStream, é voltada para a manipulação de caracteres. Nessa classe 
não é possível criar objetos diretos dela. Para criar objetos é necessário instanciar uma das subclasses concretas 
para ter o acesso à funcionalidade especificada por Reader. 
14.5 Writer 
É uma classe abstrata que escreve stream de caracteres. Os únicos métodos que uma subclasse writer deve 
implementar são: write(char [], int, int), flush () e close (). 
 
Subclasses da classe Writer 
Pág. 
 
14 API JAVA - JAVA.IO 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 93 
14.6 Buffers 
São entidades intermediárias entre duas ou mais entidades que produzem e consomem elementos. No Buffer 
existe uma área de memória que é utilizada para armazenamento temporário dos elementos que foram produzidos 
mas ainda não foram consumidos. 
Para aprendizado abaixo é mostrado um exemplo do que o código faz a criação e leitura do arquivo 
declarado dentro do construtor da classe File. 
A classe abaixo cria e lê o arquivo texto "ArquivoCriado.txt". 
import java.io.File; 
import java.io.IOException; 
import java.io.FileWriter; 
import java.io.FileReader; 
import java.io.BufferedWriter; 
import java.io.BufferedReader; 
 
class Cria_e_Le_Arquivo { 
 public static void main(String args[]) { 
 
 File f = new File("ArquivoCriado.txt"); 
 
 try { 
 FileWriter fw = new FileWriter(f); 
 BufferedWriter bw = new BufferedWriter(fw); 
 
 bw.write("Esse texto está sendo inserido"); 
 
 //INSERE UMA NOVA LINHA 
 bw.newLine(); 
 
 bw.write("Continua sendo inserido em uma nova linha"); 
 
 bw.newLine(); 
 
 bw.write("Continua sendo inserido em uma 3ª linha"); 
 
 bw.flush(); 
 bw.close(); 
 
 } catch (IOException e) { 
 e.printStackTrace(); 
 } 
 
 //EFETUANDO A LEITURA 
 try { 
 FileReader fr = new FileReader(f); 
 BufferedReader br = new BufferedReader(fr); 
 String s; 
Pág. 
 
14 API JAVA - JAVA.IO 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 94 
 
 //ENQUANTO EXISTE DADOS CONTINUA IMPRIMINDO 
 while ((s = br.readLine()) != null) { 
 System.out.println(s); 
 } 
 } catch (IOException e) { 
 System.out.println("###### Erro: "+e.getMessage()); 
 e.printStackTrace(); 
 } 
 } 
} 
Apenas vale lembrar que quando executado o código mostrado acima, é criado um arquivo chamado 
ArquivoCriado.txt dentro do projeto e com as saídas que foram dadas ao BufferedWriter. Efetue o teste achando esse 
arquivo e consulte se os valores que foram inseridos no programa são os mesmo que estão no arquivo. 
IMPORTANTE 
A partir do Java 5, foi criada a classe java.util.Scanner, que facilita bastante o trabalho de ler de um InputStream. 
Além disso, a classe PrintStream possui um construtor que já recebe o nome de um arquivo como argumento. Dessa 
forma, a leitura do teclado com saída para um arquivo ficou muito simples: 
 
Scanner s = new Scanner(System.in); 
PrintStream ps = new PrintStream("arquivo.txt"); 
while (s.hasNextLine()) { 
 ps.println(s.nextLine()); 
} 
A classe Scanner é do pacote java.util. Ela possui métodos muito úteis para trabalhar com Strings, em especial, 
diversos métodos já preparados para pegar números e palavras já formatadas através de expressões regulares. Fica 
fácil parsear um arquivo com qualquer formato dado. 
 
14.7 Exercíciosa) Faça um programa em Java que leia um texto informado pelo usuário no console e que salve o texto 
informado em um arquivo qualquer. 
Pág. 
 
15 COLLECTIONS FRAMEWORK 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 95 
15 COLLECTIONS FRAMEWORK 
 
15.1 – Introdução 
 
Quando uma aplicação precisa manipular uma quantidade grande de dados, ela deve utilizaralguma estrutura 
de dados. Podemos dizer que a estrutura de dados mais básica do Java são os arrays. Entretanto, trabalhar 
diretamente com arrays não é simples dado as diversas limitações que eles possuem. A limitação principal é a 
capacidade fixa, um array não pode ser redimensionado. Se todas as posições de umarray estiverem ocupadas não 
podemos adicionar mais elementos. Normalmente, criamos um outro array com maior capacidade e transferimos os 
elementos do array antigo para o novo. 
Além disso, adicionar ou remover elementos provavelmente gera a necessidade de deslocar parte do 
conteúdo do array. 
Para facilitar a manipulação de dados por meio das estruturas de dados, java possui a API Collection. 
 
15.2 – Tipos de Coleções 
 
 Existem várias coleções diferentes. Elas diferem, por exemplo, nos mecanismos de armazenagem usados, 
na maneira que acessam, dados e nas regras sobre quais dados podem ser armazenados. A API Collections 
oferecem uma variedade de interfaces e algumas classes de implementação concreta cobrindo essas variações. 
Uma interface geral, java.util.Collection, define a estrutura básica de coleções. Essa interface estipula os 
métodos que permitem a você acrescentar itens, remover itens, determinar se eles estão na coleção e contar a 
quantidade de itens na coleção. 
Algumas coleções são ordenadas; isto é, há uma clara noção de um item seguindo um outro. Uma coleção 
desse tipo, normalmente é conhecida como uma lista ou uma seqüência. Em algumas listas, a ordem é uma ordem 
em que os itens são acrescentados à coleção; em outras os próprios elementos parecem ter uma ordem natural, e 
aquela ordem é entendida pela lista. Na API Collections de Java, a interface java.util.List define uma estrutura 
básica para coleções desse tipo. 
Se uma coleção impõe a condição específica que ela não pode conter o mesmo valor mais do que uma vez, 
então ela é conhecida como um set(conjunto). A interface java.util.Set define a estrutura básica desse tipo de 
coleção. 
O tipo final de comportamento especializado, diretamente suportado pelas API Collectiosn é conhecido como 
uma map(mapa), java.util.Map. Um mapa usa um conjunto de valores-chave para buscar, ou indexar, os dados 
armazenados. Por exemplo, se você armazenar um objeto representando uma pessoa, então como valor chave você 
Pág. 
 
15 COLLECTIONS FRAMEWORK 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 96 
pode usar o nome daquela pessoa ou algum outro identificador único, como um número de seguro social ou um 
número de identificação de funcionário. É uma exigência para um mapa que a chave seja única, e por esse motivo, 
se você estiver armazenando dados sobre uma pessoa em um mapa, o nome não é uma chave muito boa – é bem 
possível que duas pessoas tenham o mesmo nome. A interface Map não herda a interface Collection! 
 
 
Collection 
Set – Sem repetição 
List – Com repetição/ordenação 
Coleção Map – Par/Valor 
 
Tanto a interface List como a interface Set herdam a interface Collection que define métodos para adicionar e 
remover um elemento, verificar se ele está na coleção e outras operações, alguns métodos da interface collection: 
 
Nome do Método Descrição 
boolean add(Object) Adiciona um elemento na coleção. Como algumas coleções não suportam 
elementos duplicados, este método retorna true ou false indicando se a 
adição foi efetuada com sucesso. 
boolean remove(Object) Remove determinado elemento da coleção. Se ele não existia, retorna 
false. 
int size() Retorna a quantidade de elementos existentes na coleção. 
boolean contains(Object) Procura por determinado elemento na coleção, e retorna verdadeiro caso 
ele exista. Esta comparação é feita baseando-se no método equals() do 
objeto, e não através do operador ==. 
Iterator iterator() Retorna um objeto que possibilita percorrer os elementos daquela 
coleção. 
 
Antes de começarmos a codificar alguns exemplos de como utilizar as collections, vamos tomar como base a 
classe abaixo: 
 
 
public class Livro { 
 
 // Atributos da classe 
 private String titulo; 
 private String editora; 
Pág. 
 
15 COLLECTIONS FRAMEWORK 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 97 
 
 // Método construtor sem parâmetros 
 Livro() { } 
 
 // Método construtor com parâmetros 
 Livro(String titulo, String editora) { 
 this.titulo = titulo; 
 this.editora = editora; 
 } 
 
 // Métodos acessadores 
 public String getEditora() { 
 return this.editora; 
 } 
 public void setEditora(String editora) { 
 this.editora = editora; 
 
 } 
 public String getTitulo() { 
 return this.titulo; 
 } 
 public void setTitulo(String editora) { 
 this.editora = editora; 
 } 
} 
 
 
Exemplo utilizando os Arrays 
 
 
public class TesteArray { 
 
 public static void main(String args[]) { 
 // Criando o array com três posições 
 Livro[] livros = new Livro[3]; 
 
 // Populando o array 
 livros[0] = new Livro("Java: Como Programar", "Bookman"); 
 livros[1] = new Livro("Tutorial do JEE", "Campus"); 
 livros[2] = new Livro("Core Java 2: Fundaments", "Makron Books"); 
 
 // Percorrendo e imprimindo os elementos do array 
 for( int i = 0; i < livros.length ; i++ ) { 
 System.out.println("Titulo: " + livros[i].getTitulo() + "Editora: " + 
livros[i].getEditora() ); 
 } 
 } 
 
} 
 
Pág. 
 
15 COLLECTIONS FRAMEWORK 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 98 
15.2.1 – Lista 
É uma coleção que permite elementos duplicados e mantendo uma ordenação específica entre os 
elementos. Você tem garantia de que quando percorrer a lista, os elementos serão encontrados em uma ordem pré-
determinada, definida na hora da inserção dos elementos. 
A implementação mais famosa da interface List é a ArrayList, ela trabalha com um array interna para gerar uma lista 
portanto ela é mais rápida que sua concorrente, a LinkedList que é mais rápida na inserção e remoção de itens nas 
pontas. 
 
Exemplo utilizando uma ArrayList 
 
import java.util.ArrayList; 
 
public class TesteArrayList { 
 
 public static void main(String[] args) { 
 
 ArrayList<Livro> list = new ArrayList<Livro>(); 
 list.add(new Livro("Java: Como Programar", "Bookman")); 
 list.add(new Livro("Tutorial do JEE", "Campus")); 
 list.add(new Livro("Core Java 2: Fundaments", "Makron Books")); 
 
 for( int i = 0; i < list.size() ; i++ ) { 
 Livro tempLivro = (Livro) list.get(i); 
 System.out.println(tempLivro.getTitulo() ); 
 } 
 } 
} 
 
 
 
 
IMPORTANTE 
A partir do Java 5 existe o suporte à Generics que evitam alguns erros de casting e facilitam muito a vida do 
desenvolvedor. A interface Collection agora é parametrizada. Isto é, temos uma Collection<Tipo> que indica 
qual é o tipo que estamos trabalhando com essa coleção. Com isso definimos o que os métodos vão receber 
e devolver. Uma 
Collection<Tipo> tem métodos como contains(Tipo o) e add(Tipo o), o que nos da uma enorme segurança em 
tempo de compilação, evitando castings. No exemplo acima, o tipo definido para o Arraylist foi da classe 
Livro.Pág. 
 
15 COLLECTIONS FRAMEWORK 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 99 
15.2.2 – Conjunto 
 
Uma das principais características de um conjunto(Set) é o fato de que a ordem em que os elementos são 
armazenados. 
A ordem vai variar de implementação para implementação, as principais implementações de uma interface 
Set são as classes HashSet e ThreeSet. 
Quantos elementos serão adicionados no Set chamado conjunto no exemplo abaixo? 
 
package collections; 
 
import java.util.ArrayList; 
import java.util.HashSet; 
import java.util.Set; 
 
public class TesteConjunto { 
 
 public static void main(String[] args) { 
 
 // Criando a estrutura de conjunto 
 Set conjunto = new HashSet(); 
 
 // Populando a estrutura criada 
 conjunto.add("Elemento 1"); 
 conjunto.add("Elemento 2"); 
 conjunto.add("Elemento 3"); 
 conjunto.add("Elemento 3"); 
 conjunto.add("Elemento 4"); 
 } 
} 
 
 
15.2.3 – Mapas 
 
Os mapas trabalham associando chaves a valores, para quem já tem uma certa experiência com Java e já 
trabalho com arquivos properties vai ficar fácil assimilar esta interface. As principais implementações da interface 
Map são o HashMap e o HashTable. 
 
Exemplo utilizando um HashMap 
 
 
import java.util.HashMap; 
import java.util.Map; 
 
public class ExemploMapas { 
 
 public static void main(String args[]) { 
Pág. 
 
15 COLLECTIONS FRAMEWORK 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 100 
 
 // Criando a estrutura de mapas 
 Map<String, String> mapa = new HashMap<>(); 
 
 // Variável auxiliar 
 String pessoaNome; 
 // Populando o mapa 
 mapa.put( "pessoa.nome", "Gleidson Porto"); 
 mapa.put( "pessoa.idade", "35") ; 
 mapa.put( "pessoa.email", "gleidsonporto@gmail.com"); 
 mapa.put( "pessoa.site", "www.logusti.com.br") ; 
 
 // Pegando o nome da chave pessoa.nome do mapa 
 pessoaNome = (String)mapa.get("pessoa.nome"); 
 System.out.println("Nome: " + pessoaNome); 
 
 } 
 
}} 
 
O método put(Object, Object) da interface Map recebe a chave e o valor de uma nova associação, caso já 
exista uma associação para esta chave o método irá retornar o objeto associado a esta chave, e irá trocar o este 
objeto pelo novo objeto passado no método put. 
 
SAIBA MAIS 
Um mapa importante é a tradicional classe Properties, que mapeia strings e é muito utilizada para a configuração 
de aplicações. 
A Properties possui, também, métodos para ler e gravar o mapeamento com base em um arquivo texto, 
facilitando muito a sua persistência. 
Properties config = new Properties(); 
 
config.setProperty("database.login", "logusti"); 
config.setProperty("database.password", "g1o4a1"); 
config.setProperty("database.url","jdbc:mysql:/localhost/teste"); 
 
// muitas linhas depois... 
 
String login = config.getProperty("database.login"); 
String password = config.getProperty("database.password"); 
String url = config.getProperty("database.url"); 
DriverManager.getConnection(url, login, password); 
Repare que não houve a necessidade do casting para String no momento de recuperar os objetos associados. 
Isto porque a classe Properties foi desenhada com o propósito de trabalhar com a associação entre Strings. 
 
Pág. 
 
15 COLLECTIONS FRAMEWORK 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 101 
15.3 – Exercício 
 
a) Implemente uma classe em Java com as funcionalidades de uma agenda telefônica, associando um nome a 
um número telefônico. A classe deve possuir a interface abaixo: 
 
 
b) Crie um programa em Java para testar a classe AgendaTelefonica desenvolvida no exercício anterior. Teste 
a classe com pelo menos 5 contatos diferentes na agenda de telefones. 
 
Pág. 
 
RESPOSTAS DO EXERCÍCIOS 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 102 
RESPOSTAS DO EXERCÍCIOS 
 
LISTA DE EXERCÍCIOS 4.6 
 
a) Altere o programa AloMundo.Java para que ele imprima na tela todos os tipos primitivos de dados suportados pela 
linguagem Java. 
 
public class Exercicio_4_6_A { 
 
 public static void main(String[] args) { 
 System.out.println("*** Tipos primitivos do Java ****"); 
 System.out.println(); 
 System.out.println("Tipo - Bits - Bytes "); 
 System.out.println("byte - 8 - 1 "); 
 System.out.println("short - 16 - 2 "); 
 System.out.println("int - 32 - 4 "); 
 System.out.println("long - 64 - 8 "); 
 System.out.println("float - 32 - 4 "); 
 System.out.println("double - 64 - 8 "); 
 System.out.println("char - 16 - 2 "); 
 System.out.println("boolean - 1 - - "); 
 } 
} 
 
b) Altere o programa AloMundo para que ele imprima os parâmetros recebidos pela linha de comando de execução 
do programa. (Dica: são os valores do array args: args[0], args[1], etc.) 
public class Exercicio_4_6_B { 
 
 public static void main(String[] args) { 
 // Considerando que neste momento pelo conteúdo apresentado, pressupõe-se que 
tenha conhecimento 
 // em estruturas de laço de repetição. Sendo assim, o exercício será realizado da 
forma mais simples. 
 // Nos capítulos seguintes o aluno, descobrirá outra forma para eficiente para 
resolução deste exercício. 
 
 // Recebendo os três argumentos. 
 // Observe que o primeiro elemento do array começa na posição 0(zero). 
 String parametroRecebido1= args[0]; 
 String parametroRecebido2= args[1]; 
 String parametroRecebido3= args[2]; 
 
 // Imprimindo os parâmetros recebidos 
 System.out.println(parametroRecebido1); 
 System.out.println(parametroRecebido2); 
 System.out.println(parametroRecebido3); 
Pág. 
 
RESPOSTAS DO EXERCÍCIOS 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 103 
 } 
 
} 
 
c) Crie um programa que receba três argumentos da linha de comando e imprima-os na mesma linha, em ordem 
inversa. 
 
Exemplo: 
java Programa a1 a2 a3 
Saída: a3 a2 a1 
 
public class Exercicio_4_6_C { 
 
 public static void main(String[] args) { 
 // Considerando que neste momento pelo conteúdo apresentado, pressupõe-se que 
tenha conhecimento 
 // em estruturas d e laço de repetição. Sendo assim, o exercício será realizado 
da forma mais simples. 
 // Nos capítulos seguintes o aluno, descobrirá outra forma para eficiente para 
resolução deste exercício. 
 
 // Recebendo os três argumentos. 
 // Observe que o primeiro elemento do array começa na posição 0(zero). 
 String parametroRecebido1= args[0]; 
 String parametroRecebido2= args[1]; 
 String parametroRecebido3= args[2]; 
 
 // Imprimindo os parâmetros recebidos na ordem invertida 
 System.out.println(parametroRecebido3); 
 System.out.println(parametroRecebido2); 
 System.out.println(parametroRecebido1); 
 
 } 
 
} 
LISTA DE EXERCÍCIO 5.6 
a) Implemente um programa para calcular a área de um trapézio, onde: 
 
h = altura 
b = base menor 
B = base maior 
Área = (h . (b + B)) / 2 
import java.io.IOException; 
import java.io.InputStream; 
import java.util.Scanner; 
 
public class Exercicio_5_6_A { 
 
Pág. 
 
RESPOSTAS DO EXERCÍCIOS 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 104 
 public static void main(String[] args) { 
 
 // Para leitura do parâmetros do cálculo, utilizaremos a classe Scanner. 
 // Você verá em detalhes este recurso no tópico 6.6 Lendovalores do teclado da 
apostila. 
 
 // O objeto System.in possibilita a leitura do que se escreve no teclado 
 InputStream entrada = System.in; 
 
 // Objeto para captura das informações 
 System.out.println("Cálculo da Área do Trapézio"); 
 Scanner linha = new Scanner(entrada); 
 
 // Realizando a leitura da altura. 
 System.out.print("Forneça a altura: "); 
 double altura = linha.nextDouble(); 
 
 // Realizando a leitura da base menor. 
 System.out.print("Forneça a base menor: "); 
 double baseMenor = linha.nextDouble(); 
 
 // Realizando a leitura da base maior. 
 System.out.print("Forneça a base maior: "); 
 double baseMaior = linha.nextDouble(); 
 
 // Calculando a fórmula para obter a área do trapézio 
 double area = (altura * (baseMenor + baseMaior))/2; 
 
 
 // Imprimindo a área calculada 
 System.out.println("A área do trapézio é " + area); 
 
 
 } 
 
} 
 
b) Faça o programa acima calcular utilizando valores de ponto flutuante e depois imprima na tela duas 
informações: 
 
Valor exato da área: 
Valor arredondado para inteiro: 
import java.io.IOException; 
import java.io.InputStream; 
import java.util.Scanner; 
 
public class Exercicio_5_6_B { 
 
 public static void main(String[] args) { 
 
 // Para leitura do parâmetros do cálculo, utilizaremos a classe Scanner. 
 // Você verá em detalhes este recurso no tópico 6.6 Lendo valores do teclado da 
apostila. 
Pág. 
 
RESPOSTAS DO EXERCÍCIOS 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 105 
 
 // O objeto System.in possibilita a leitura do que se escreve no teclado 
 InputStream entrada = System.in; 
 
 // Objeto para captura das informações 
 System.out.println("Cálculo da Área do Trapézio"); 
 Scanner linha = new Scanner(entrada); 
 
 // Realizando a leitura da altura. 
 System.out.print("Forneça a altura: "); 
 double altura = linha.nextDouble(); 
 
 // Realizando a leitura da base menor. 
 System.out.print("Forneça a base menor: "); 
 double baseMenor = linha.nextDouble(); 
 
 // Realizando a leitura da base maior. 
 System.out.print("Forneça a base maior: "); 
 double baseMaior = linha.nextDouble(); 
 
 // Calculando a fórmula para obter a área do trapézio 
 double area = (altura * (baseMenor + baseMaior))/2; 
 
 
 // Imprimindo a área EXATA calculada do trapézio 
 System.out.println("A área exata do trapézio é " + area); 
 
 // Imprimindo a área calculada do trapézio arredondada 
 System.out.println("A área exata arredondada do trapézio é " + (int)area); 
 
 } 
 
} 
 
c) Calcule o valor das seguintes equações: 
a. 3 – 2 – 1 + 2 + 1 + 3 
b. 2 * 3 – 4 * 5 
c. 2 + 6 – 3 / 7 * 9 
d. 3 % 4 – 8 
 
public class Exercicio_5_6_C { 
 
 public static void main(String[] args) { 
 
 
 // Realizando os cálculos das equações 
 double resultadoA = 3 - 2 - 1 + 2 + 1 + 3; 
 double resultadoB = 2 * 3 - 4 * 5; 
 double resultadoC = 2 + 6 - 3 / 7 * 9; 
 double resultadoD = 3 % 4 - 8; 
 
 // Imprimindo o resultado das equações 
Pág. 
 
RESPOSTAS DO EXERCÍCIOS 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 106 
 System.out.println("Resultado das Equações"); 
 System.out.println(" a) 3 – 2 – 1 + 2 + 1 + 3 = " + resultadoA); 
 
 System.out.println(" b) 2 * 3 – 4 * 5 = " + resultadoB); 
 
 System.out.println(" c) 2 + 6 – 3 / 7 * 9 = " + resultadoC); 
 
 System.out.println(" d) 3 % 4 – 8 = " + resultadoD); 
 
 //Resultado da Execução 
 
 /*Resultado das Equações 
 a) 3 – 2 – 1 + 2 + 1 + 3 = 6.0 
 b) 2 * 3 – 4 * 5 = -14.0 
 c) 2 + 6 – 3 / 7 * 9 = 8.0 
 d) 3 % 4 – 8 = -5.0*/ 
 
 
 } 
 
} 
d) Indique qual o valor verdade das seguintes expressões: 
a. (1 > 2) // exemplo: false 
b. (8 == 8) // exemplo: true 
c. ((12 – 5) > 6) - FALSE 
d. (0 < 3) && (8 < 9) - TRUE 
e. ((i++) > i) - FALSE 
f. ((10 * 90 / 50 – 2) == 16) TRUE 
 
LISTA DE EXERCÍCIO 6.7 
 
1. Escreva um programa que imprima na tela a soma dos números ímpares entre 0 e 20 e a multiplicação dos 
números pares entre 0 e 20. 
 
public class Exercicio_6_7_1 { 
 
 public static void main(String[] args) { 
 // Variáveis criadas para armazenar os valores dos cálculos 
 int totalImpares=0; 
 // Será utilizado o tipo double porque o int possui limitação de tamanho 
 double totalPares=1; 
 
 // Laço de repetição de 0 a 20. 
 for (int numero=1; numero <= 19;numero++){ 
 // Número par 
 if (numero % 2 == 0){ 
 // Multiplicando os números pares 
 totalPares = totalPares * numero; 
 
 } else 
 // Somando os números ímpares 
Pág. 
 
RESPOSTAS DO EXERCÍCIOS 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 107 
 totalImpares = totalImpares + numero; 
 
 } 
 
 System.out.println("Total da soma dos números ímpares de 0 a 20: " + 
totalImpares); 
 
 System.out.println("Total da multiplicação dos números pares de 0 a 20: " + 
totalPares); 
 
 } 
 
} 
 
Execução 
Total da soma dos números ímpares de 0 a 20: 100 
Total da multiplicação dos números pares de 0 a 20: 1.8579456E8 
 
 
 
2. Faça um programa para ler um número do teclado e imprimir na tela se ele é par ou ímpar. 
 
import java.io.InputStream; 
import java.util.Scanner; 
 
public class Exercicio_6_7_2 { 
 
 public static void main(String[] args) { 
 
 
 // O objeto System.in possibilita a leitura do que se escreve no teclado 
 InputStream entrada = System.in; 
 Scanner linha = new Scanner(entrada); 
 
 // Objeto para captura das informações 
 System.out.println("Digite um número"); 
 
 int numero = linha.nextInt(); 
 
 
 // Verificando se o número é par 
 if (numero % 2 == 0){ 
 
 System.out.println( numero + " é um número par. "); 
 
 } else 
 System.out.println( numero + " é um número ímpar. "); 
 
 } 
 
} 
 
 
 
Pág. 
 
RESPOSTAS DO EXERCÍCIOS 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 108 
3. O valor pago por um Hotel da Praia de Iracema para seus porteiros é de R$ 10,25 por hora de trabalho. Faça um 
programa que pergunte ao usuário quantas horas ele trabalhou e imprima na tela o valor do salário a ser recebido 
por ele. 
 
import java.io.InputStream; 
import java.util.Scanner; 
 
public class Exercicio_6_7_3 { 
 
 public static void main(String[] args) { 
 
 // Valor da hora de trabalho 
 double valorHora = 10.25; 
 
 System.out.println("** Cálculo de Salário de Porteiro - Hotel da Praia de Iracema 
**"); 
 
 // O objeto System.in possibilita a leitura do que se escreve no teclado 
 InputStream entrada = System.in; 
 Scanner linha = new Scanner(entrada); 
 
 // Objeto para captura das informações 
 System.out.println("Digite a quantidade de horas: "); 
 
 // Capturando a quantidade de horas 
 double horas = linha.nextDouble(); 
 
 // Cálculo do salário 
 double salario = horas * valorHora; 
 
 // Imprimindo o salário 
 System.out.println( " Valor do salário: " + salario); 
 
 } 
 
} 
 
4. Modifique o programa anterior para que o sistema imprima uma mensagem de alerta quando o valor a ser pago 
ao funcionário seja inferior a R$ 50,00: "Atenção, dirija-se à direção do Hotel!". 
 
import java.io.InputStream; 
import java.util.Scanner; 
 
public class Exercicio_6_7_4 { 
 
 public static void main(String[] args) { 
 
 // Valor da hora de trabalho 
 double valorHora = 10.25; 
 
 System.out.println("** Cálculo de Salário de Porteiro - Hotel da Praia de Iracema 
**"); 
 
 // Oobjeto System.in possibilita a leitura do que se escreve no teclado 
 InputStream entrada = System.in; 
Pág. 
 
RESPOSTAS DO EXERCÍCIOS 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 109 
 Scanner linha = new Scanner(entrada); 
 
 // Objeto para captura das informações 
 System.out.println("Digite a quantidade de horas: "); 
 
 // Capturando a quantidade de horas 
 double horas = linha.nextDouble(); 
 
 // Cálculo do salário 
 double salario = horas * valorHora; 
 
 // Condição estabelecida no exercício 
 if (salario <50 ) 
 System.out.println("Atenção, dirija-se à direção do Hotel!"); 
 else System.out.println( " Valor do salário: " + salario); 
 
 } 
 
} 
 
 
5. Sabendo que na LogusTI a média mínima é 7,0 e a tolerância de faltas é 15 % da carga horária do curso, faça 
uma classe com o método main que peça as informações necessárias e informe a situação do usuário. 
 
public class Exercicio_6_7_5 { 
 
 public static void main(String[] args) { 
 
 String situacao; 
 
 System.out.println("** RENDIMENTO DE ALUNO - LOGUSTI **"); 
 
 // O objeto System.in possibilita a leitura do que se escreve no teclado 
 InputStream entrada = System.in; 
 Scanner linha = new Scanner(entrada); 
 
 // Capturando as informações para cálculo do rendimento 
 System.out.print("Digite o nome do aluno: "); 
 String nome = linha.nextLine(); 
 
 System.out.print("Digite a nota de média do aluno: "); 
 double nota = linha.nextDouble(); 
 
 System.out.print("Digite o percentual(%) de falta do aluno: "); 
 double percFalta = linha.nextDouble(); 
 
 
 // Verificação do rendimento escolar 
 if (nota>=7.0 && percFalta<=15) 
 situacao = "APROVADO"; 
 else situacao = "REPROVADO"; 
 
 
 System.out.println("\n** RENDIMENTO DO ALUNO ** "); 
 System.out.println("Nome............: " + nome); 
Pág. 
 
RESPOSTAS DO EXERCÍCIOS 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 110 
 System.out.println("Nota de Média...: " + nota); 
 System.out.println("Faltas(%).......: " + percFalta); 
 System.out.println("Situação........: " + situacao ); 
 
 } 
 
} 
 
Exemplo da execução 
 
** RENDIMENTO DE ALUNO - LOGUSTI ** 
Digite o nome do aluno: Gleidson Porto 
Digite a nota de média do aluno: 10 
Digite o percentual(%) de falta do aluno: 0 
 
** RENDIMENTO DO ALUNO ** 
Nome............: Gleidson Porto 
Nota de Média...: 10.0 
Faltas(%).......: 0.0 
Situação........: APROVADO 
 
 
 
6. Implemente uma classe java “Calculos” com um método”calcularMedia” que receba três números e calcule a 
média e imprima na tela essa média. O método “calcularMaior”, deverá receber também três números e retornar o 
maior número e o método “calcularMenor”, deverá receber três números e retornar o melhor número. Implemente a 
classe com o método main e instancie a classe Calculos executando todos os seus métodos. 
 
 
public class Calculos { 
 
 public double calcularMedia(double num1, double num2, double num3){ 
 // Calculando a média 
 double media = (num1 + num2 + num3)/3.0; 
 // Retornando a média 
 return media; 
 } 
 
 public double calcularMaior(double num1, double num2, double num3){ 
 
 double maior; 
 
 // Comparando para identificar o maior número 
 if (num1>num2 && num1>num3) 
 maior = num1; 
 else if (num2>num3) 
 maior = num2; 
 else maior = num3; 
 
 return maior; 
 } 
 
 public double calcularMenor(double num1, double num2, double num3){ 
 double menor; 
 
Pág. 
 
RESPOSTAS DO EXERCÍCIOS 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 111 
 // Comparando para identificar o maior número 
 if (num1<num2 && num1<num3) 
 menor = num1; 
 else if (num2<num3) 
 menor = num2; 
 else menor = num3; 
 
 return menor; 
 } 
 
} 
 
import java.io.InputStream; 
import java.util.Scanner; 
 
public class Exercicio_6_7_6 { 
 
 public static void main(String[] args) { 
 
 // Criando o objeto da classe Cálculo 
 Calculos objCalculo = new Calculos(); 
 
 
 // O objeto System.in possibilita a leitura do que se escreve no teclado 
 InputStream entrada = System.in; 
 Scanner linha = new Scanner(entrada); 
 
 // Capturando os números 
 
 System.out.print("Número 1...: "); 
 double num1 = linha.nextDouble(); 
 
 System.out.print("Número 2...: "); 
 double num2 = linha.nextDouble(); 
 
 System.out.print("Número 3...: "); 
 double num3 = linha.nextDouble(); 
 
 // Calcular maior número 
 System.out.println("Maior número........: " + objCalculo.calcularMaior(num1, num2, 
num3)); 
 
 // Calcular média 
 System.out.println("Média dos números...: " + objCalculo.calcularMedia(num1, num2, 
num3)); 
 
 // Calcular menor número 
 System.out.println("Menor número........: " + objCalculo.calcularMenor(num1, num2, 
num3)); 
 
 
 } 
 
} 
 
Pág. 
 
RESPOSTAS DO EXERCÍCIOS 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 112 
 
Execução 
Número 1...: 2,2 
Número 2...: 9 
Número 3...: 4,5 
Maior número........: 9.0 
Média dos números...: 5.233333333333333 
Menor número........: 2.2 
 
7. Construa uma classe que peça o Nome, Endereço, Sexo, Cidade, Estado, Idade dos funcionários. Além disto, 
dado o Salário Bruto do funcionário, calcule o seu Salário Líquido. Considere que os descontos podem ser o Vale 
Transporte (2%), Vale Alimentação (5%) e Plano de Saúde (10%). 
 
import java.io.InputStream; 
import java.util.Scanner; 
 
public class Exercicio_6_7_7 { 
 
 public static void main(String[] args) { 
 
 String situacao; 
 
 System.out.println("** CALCULO DE SALÁRIO **"); 
 
 // O objeto System.in possibilita a leitura do que se escreve no teclado 
 InputStream entrada = System.in; 
 Scanner linha = new Scanner(entrada); 
 
 // Capturando as informações do funcionário 
 
 System.out.print("Nome.........: "); 
 String nome = linha.nextLine(); 
 
 System.out.print("Idade.......: "); 
 int idade = Integer.parseInt(linha.nextLine()); 
 
 System.out.print("Endereço....: "); 
 String endereco = linha.nextLine(); 
 
 System.out.print("Sexo........: "); 
 String sexo = linha.nextLine(); 
 
 System.out.print("Cidade......: "); 
 String cidade = linha.nextLine(); 
 
 System.out.print("Estado......: "); 
 String estado = linha.nextLine(); 
 
 System.out.print("Salário Bruto...: "); 
 double salarioBruto = linha.nextDouble(); 
 
 // Calculando o salário 
Pág. 
 
RESPOSTAS DO EXERCÍCIOS 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 113 
 // Calculando os descontos Vale Transporte (2%), Vale Alimentação (5%) e Plano de 
Saúde (10%). 
 double valeTransporte = salarioBruto * (2/100.0); 
 double valeAlimentacao = salarioBruto * (5/100.0); 
 double planoSaude = salarioBruto * (10/100.0); 
 
 // Calculando o salário líquido 
 double salarioLiquido = salarioBruto - valeTransporte - valeAlimentacao - 
planoSaude; 
 
 System.out.println("** DEMONSTRATIVO DE SALÁRIO *** "); 
 System.out.println("Nome............: " + nome); 
 System.out.println("Salário Bruto...: " + salarioBruto); 
 System.out.println("Salário Líquido.: " + salarioLiquido); 
 
 
 } 
 
} 
 
Exemplo da Execução 
** CALCULO DE SALÁRIO ** 
Nome.........: Roberto Carlos 
Idade.......: 37 
Endereço....: SGAS 916 LT 32 
Sexo........: M 
Cidade......: BRASILIA 
Estado......: DF 
Salário Bruto...: 22500,50 
** DEMONSTRATIVODE SALÁRIO *** 
Nome............: Roberto Carlos 
Salário Bruto...: 22500.5 
Salário Líquido.: 18675.415 
 
LISTA DE EXERCÍCIOS 7.8 
1) Crie um programa que imprima na tela os argumentos passados na linha de comando para o método main. 
Compile e execute a classe ImprimeArgumentos. Na execução, não esqueça de passar alguns parâmetros na linha 
de comando. 
public class Exercicio_7_8_1 { 
 
 public static void main(String[] parametros) { 
 
 // Imprimindo todos os parametros recebidos 
 for (int i = 0; i < parametros.length; i++) { 
 System.out.print(parametros[i] + " "); 
 } 
 
 } 
 
Pág. 
 
RESPOSTAS DO EXERCÍCIOS 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 114 
} 
 
2) Faça um programa que ordene o array de strings recebido na linha de comando. Compile e execute a classe 
Ordena. Na execução, não esqueça de passar alguns parâmetros na linha de comando. 
import java.util.Arrays; 
 
//2) Faça um programa que ordene o array de strings recebido na linha de comando. Compile e 
execute a classe Ordena. 
//Na execução, não esqueça de passar alguns parâmetros na linha de comando. 
 
public class Exercicio_7_8_2 { 
 
 public static void main(String[] parametros) { 
 
 // Ordenando os elementos numéricos do arrays 
 Arrays.sort(parametros); 
 
 // Imprimindo os elementos ordenados 
 System.out.println("Valores ordenados" + Arrays.toString(parametros)); 
 
 } 
} 
 
Execução 
Valores digitados como parâmetros: 9 2 1 0 3 5 
Valores ordenados[0, 1, 2, 3, 5, 9] 
 
3) Faça um programa que calcule a média dos elementos recebidos na linha de comando. Dica: para converter 
strings para double utilize o método parseDouble() 
public class Exercicio_7_8_3 { 
 
 public static void main(String[] numerosRecebidos) { 
 
 // Variável auxiliar para soma 
 double soma =0; 
 
 // Percorrendo o array e realizando o somatório dos valores informados 
 for (int i = 0; i < numerosRecebidos.length; i++) { 
 soma = Double.parseDouble(numerosRecebidos[i]) + soma; 
 } 
 
 // Calculando a média dos valores recebidos 
 
 double media = soma/numerosRecebidos.length; 
 
 System.out.println("Média dos valores " + media); 
Pág. 
 
RESPOSTAS DO EXERCÍCIOS 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 115 
 } 
 
} 
 
4) Faça um programa que leia cinco nomes do teclado, e depois imprima esses nomes na ordem inversa em 
que foram digitados pelo usuário. 
public class Exercicio_7_8_4 { 
 
 public static void main(String[] numerosRecebidos) { 
 
 
 // Percorrendo o array e imprimindo os elementos na ordem inversa 
 for (int i = numerosRecebidos.length-1; i >= 0; i--) { 
 System.out.println(numerosRecebidos[i]); 
 } 
 
 } 
 
} 
5) O tempo que um determinado avião dispensa para percorrer o trecho entre duas localidades distintas está 
disponível através da seguinte tabela: 
 
 A B C D E F G 
 02 11 06 15 11 01 
02 07 12 04 02 15 
11 07 11 08 03 13 
06 12 11 10 02 01 
15 04 08 10 05 13 
11 02 03 02 05 14 
01 15 13 01 13 14 
 
 
a) Construa uma classe java que leia a tabela anterior e informe ao usuário o tempo necessário para percorrer duas cidades 
por ele fornecidas, até o momento em que ele fornecer duas cidades iguais (origem e destino). 
 
 
import java.io.InputStream; 
import java.util.Scanner; 
 
public class Exercicio_7_8_5 { 
 
 public static void main(String[] args) { 
 
 // Carregando a matriz com os valores pré-definidos 
 int[][] matriz = new int[7][7]; 
 
 // Distâncias da linha 0 ou cidade A 
 matriz[0][0] = 0; 
 matriz[0][1] = 2; 
Pág. 
 
RESPOSTAS DO EXERCÍCIOS 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 116 
 matriz[0][2] = 11; 
 matriz[0][3] = 6; 
 matriz[0][4] = 15; 
 matriz[0][5] = 11; 
 matriz[0][6] = 1; 
 
 // Distâncias da linha 1 ou cidade B 
 matriz[1][0] = 2; 
 matriz[1][1] = 0; 
 matriz[1][2] = 7; 
 matriz[1][3] = 12; 
 matriz[1][4] = 4; 
 matriz[1][5] = 2; 
 matriz[1][6] = 15; 
 
 // Distâncias da linha 2 ou cidade C 
 matriz[2][0] = 11; 
 matriz[2][1] = 7; 
 matriz[2][2] = 0; 
 matriz[2][3] = 11; 
 matriz[2][4] = 8; 
 matriz[2][5] = 3; 
 matriz[2][6] = 13; 
 
 
 matriz[3][0] = 6; 
 matriz[3][1] = 12; 
 matriz[3][2] = 11; 
 matriz[3][3] = 0; 
 matriz[3][4] = 10; 
 matriz[3][5] = 2; 
 matriz[3][6] = 1; 
 
 
 matriz[4][0] = 15; 
 matriz[4][1] = 4; 
 matriz[4][2] = 8; 
 matriz[4][3] = 10; 
 matriz[4][4] = 0; 
 matriz[4][5] = 5; 
 matriz[4][6] = 13; 
 
 
 matriz[5][0] = 11; 
 matriz[5][1] = 2; 
 matriz[5][2] = 3; 
 matriz[5][3] = 2; 
 matriz[5][4] = 5; 
 matriz[5][5] = 0; 
 matriz[5][6] = 14; 
 
 matriz[6][0] = 1; 
 matriz[6][1] = 15; 
 matriz[6][2] = 13; 
 matriz[6][3] = 1; 
Pág. 
 
RESPOSTAS DO EXERCÍCIOS 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 117 
 matriz[6][4] = 13; 
 matriz[6][5] = 14; 
 matriz[6][6] = 0; 
 
 
 System.out.println("*** Calculo de Distância de Cidades A B C D E F G *** 
"); 
 
 InputStream entrada = System.in; 
 Scanner linha = new Scanner(entrada); 
 
 System.out.println("Cidade origem(A, B, C , D, E, F ou G): "); 
 String cidadeOrigem = linha.next(); 
 
 System.out.println("Cidade destino(A, B, C , D, E, F ou G): "); 
 String cidadeDestino = linha.next(); 
 
 // Realizando o de - para para identificar a linha e coluna da matriz 
 int lin=0; 
 
 if (cidadeOrigem.toUpperCase().equals("A")) 
 lin = 0; 
 else if (cidadeOrigem.toUpperCase().equals("B")) 
 lin = 1; 
 else if (cidadeOrigem.toUpperCase().equals("C")) 
 lin = 2; 
 else if (cidadeOrigem.toUpperCase().equals("D")) 
 lin = 3; 
 else if (cidadeOrigem.toUpperCase().equals("E")) 
 lin = 4; 
 else if (cidadeOrigem.toUpperCase().equals("F")) 
 lin = 5; 
 else if (cidadeOrigem.toUpperCase().equals("G")) 
 lin = 6; 
 
 
 int col=0; 
 
 if (cidadeDestino.toUpperCase().equals("A")) 
 col = 0; 
 else if (cidadeDestino.toUpperCase().equals("B")) 
 col = 1; 
 else if (cidadeDestino.toUpperCase().equals("C")) 
 col = 2; 
 else if (cidadeDestino.toUpperCase().equals("D")) 
 col = 3; 
 else if (cidadeDestino.toUpperCase().equals("E")) 
 col = 4; 
 else if (cidadeDestino.toUpperCase().equals("F")) 
 col = 5; 
 else if (cidadeDestino.toUpperCase().equals("G")) 
 col = 6; 
 
 System.out.println("A distância entre as cidades " + cidadeOrigem + " e " + cidadeDestino + 
"é " + matriz[lin][col]); 
Pág. 
 
RESPOSTAS DO EXERCÍCIOS 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 118 
 
 } 
 
} 
 
*** Calculo de Distância de Cidades A B C D E F G *** 
Cidade origem(A, B, C , D, E, F ou G): 
A 
Cidade destino(A, B, C , D, E, F ou G): 
F 
A distância entre as cidades A e F é 11 
 
 
b) Elabore uma classe que imprima a tabela sem repetições(apenas o triângulo superior ou o triângulo inferior). 
 
import java.io.InputStream; 
import java.util.Scanner; 
 
public class Exercicio_7_8_5 { 
 
 public static void main(String[] args) { 
 
 // Carregandoa matriz com os valores pré-definidos 
 int[][] matriz = new int[7][7]; 
 
 // Distâncias da linha 0 ou cidade A 
 matriz[0][0] = 0; 
 matriz[0][1] = 2; 
 matriz[0][2] = 11; 
 matriz[0][3] = 6; 
 matriz[0][4] = 15; 
 matriz[0][5] = 11; 
 matriz[0][6] = 1; 
 
 // Distâncias da linha 1 ou cidade B 
 matriz[1][0] = 2; 
 matriz[1][1] = 0; 
 matriz[1][2] = 7; 
 matriz[1][3] = 12; 
 matriz[1][4] = 4; 
 matriz[1][5] = 2; 
 matriz[1][6] = 15; 
 
 // Distâncias da linha 2 ou cidade C 
 matriz[2][0] = 11; 
 matriz[2][1] = 7; 
 matriz[2][2] = 0; 
 matriz[2][3] = 11; 
 matriz[2][4] = 8; 
 matriz[2][5] = 3; 
 matriz[2][6] = 13; 
 
Pág. 
 
RESPOSTAS DO EXERCÍCIOS 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 119 
 
 matriz[3][0] = 6; 
 matriz[3][1] = 12; 
 matriz[3][2] = 11; 
 matriz[3][3] = 0; 
 matriz[3][4] = 10; 
 matriz[3][5] = 2; 
 matriz[3][6] = 1; 
 
 
 matriz[4][0] = 15; 
 matriz[4][1] = 4; 
 matriz[4][2] = 8; 
 matriz[4][3] = 10; 
 matriz[4][4] = 0; 
 matriz[4][5] = 5; 
 matriz[4][6] = 13; 
 
 
 matriz[5][0] = 11; 
 matriz[5][1] = 2; 
 matriz[5][2] = 3; 
 matriz[5][3] = 2; 
 matriz[5][4] = 5; 
 matriz[5][5] = 0; 
 matriz[5][6] = 14; 
 
 matriz[6][0] = 1; 
 matriz[6][1] = 15; 
 matriz[6][2] = 13; 
 matriz[6][3] = 1; 
 matriz[6][4] = 13; 
 matriz[6][5] = 14; 
 matriz[6][6] = 0; 
 
 
 System.out.println("*** Calculo de Distância de Cidades A B C D E F G *** 
"); 
 
 InputStream entrada = System.in; 
 Scanner linha = new Scanner(entrada); 
 
 System.out.println("Cidade origem(A, B, C , D, E, F ou G): "); 
 String cidadeOrigem = linha.next(); 
 
 System.out.println("Cidade destino(A, B, C , D, E, F ou G): "); 
 String cidadeDestino = linha.next(); 
 
 // Realizando o de - para para identificar a linha e coluna da matriz 
 int lin=0; 
 
 if (cidadeOrigem.toUpperCase().equals("A")) 
 lin = 0; 
 else if (cidadeOrigem.toUpperCase().equals("B")) 
 lin = 1; 
Pág. 
 
RESPOSTAS DO EXERCÍCIOS 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 120 
 else if (cidadeOrigem.toUpperCase().equals("C")) 
 lin = 2; 
 else if (cidadeOrigem.toUpperCase().equals("D")) 
 lin = 3; 
 else if (cidadeOrigem.toUpperCase().equals("E")) 
 lin = 4; 
 else if (cidadeOrigem.toUpperCase().equals("F")) 
 lin = 5; 
 else if (cidadeOrigem.toUpperCase().equals("G")) 
 lin = 6; 
 
 
 int col=0; 
 
 if (cidadeDestino.toUpperCase().equals("A")) 
 col = 0; 
 else if (cidadeDestino.toUpperCase().equals("B")) 
 col = 1; 
 else if (cidadeDestino.toUpperCase().equals("C")) 
 col = 2; 
 else if (cidadeDestino.toUpperCase().equals("D")) 
 col = 3; 
 else if (cidadeDestino.toUpperCase().equals("E")) 
 col = 4; 
 else if (cidadeDestino.toUpperCase().equals("F")) 
 col = 5; 
 else if (cidadeDestino.toUpperCase().equals("G")) 
 col = 6; 
 
 System.out.println("A distância entre as cidades " + cidadeOrigem + " e " + cidadeDestino + 
" é " + matriz[lin][col]); 
 
 imprimirTrianguloInferior(matriz); 
 } 
 
 public static void imprimirTrianguloInferior(int[][] matriz){ 
 
 for (int lin = 0; lin < matriz.length; lin++) { 
 
 for (int col = 0; col < matriz.length; col++) { 
 if (lin==col) 
 { System.out.println(); 
 break; 
 } 
 
 System.out.print(matriz[lin][col] + " "); 
 } 
 } 
 
 } 
 
} 
Pág. 
 
RESPOSTAS DO EXERCÍCIOS 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 121 
Execução 
*** Calculo de Distância de Cidades A B C D E F G *** 
Cidade origem(A, B, C , D, E, F ou G): 
a 
Cidade destino(A, B, C , D, E, F ou G): 
b 
A distância entre as cidades a e b é 2 
 
2 
11 7 
6 12 11 
15 4 8 10 
11 2 3 2 5 
1 15 13 1 13 14 
LISTA DE EXERCÍCIO 8.4 
 
Para atender as necessidades de informação de uma biblioteca universitária foi proposto um sistema que deve 
atender as seguintes características: 
 
 O cadastro dos usuários da biblioteca com endereço completo. Os usuários podem ser classificados em três 
grupos: Professores, Alunos e Funcionários. Para os Alunos é necessário conhecer o curso ao qual 
pertencem. Dos Professores e funcionários, é necessário conhecer o Departamento ao qual estão sempre 
vinculados. 
 O cadastro das obras da biblioteca, que podem ser classificadas em: Livros científicos, periódicos científicos, 
periódicos informativos, periódicos diversos, entretenimento, etc. 
 A língua em que se encontra o exemplar da obra. 
 A mídia onde se encontra o exemplar da obra. 
 Os autores da obra com o controle da nacionalidade do autor. 
 As editoras dos exemplares com o ano de edição de cada exemplar. 
 O histórico dos empréstimos. 
 
Identifique as possíveis classes e objetos com seus respectivos atributos e métodos. 
 
LISTA DE EXERCÍCIO 8.6 
 
a) Implemente uma classe chamada Aluno para definir os objetos que representarão os alunos de uma escola. 
Essa classe deve declarar três atributos: o primeiro para o nome, o segundo para o RG e o terceiro para o CPF dos 
alunos. 
Pág. 
 
RESPOSTAS DO EXERCÍCIOS 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 122 
public class Aluno { 
 
 // Definindo os atributos da classe 
 private String nome; 
 private String rg; 
 private String cpf; 
 
 
 // Definindo os métodos acessadores para garantir o encapsulamento 
 
 // Método para recuperar o nome 
 public String getNome() { 
 return nome; 
 } 
 // Método para atualizar o nome 
 public void setNome(String nome) { 
 this.nome = nome; 
 } 
 // Método para recuperar o RG 
 public String getRg() { 
 return rg; 
 } 
 // Método para atualizar o RG 
 public void setRg(String rg) { 
 this.rg = rg; 
 } 
 public String getCpf() { 
 return cpf; 
 } 
 public void setCpf(String cpf) { 
 this.cpf = cpf; 
 } 
 
 
} 
 
b) Faça uma classe chamada TestaAluno e crie dois objetos da classe Aluno atribuindo valores a eles. A classe 
também deve mostrar na tela as informações desses objetos. 
public class TestaAluno { 
 
 public static void main(String[] args) { 
 
 // Criando objeto 1 da classe aluno 
 Aluno obj1 = new Aluno(); 
 
 // Populando o objeto criado 
 obj1.setNome("Gleidson Porto"); 
 obj1.setRg("888.888-8"); 
 obj1.setCpf("888.888.888-88"); 
 
 // Criando objeto 2 da classe aluno 
 Aluno obj2 = new Aluno(); 
Pág. 
 
RESPOSTAS DO EXERCÍCIOS 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 123 
 
 // Populando o objeto criado 
 obj2.setNome("Roberto Carlos"); 
 obj2.setRg("999.999-9"); 
 obj2.setCpf("999.999.999-99"); 
 
 // Imprimindo informações dos objetos criados 
 System.out.println(" NOME - RG - CPF "); 
 System.out.println(obj1.getNome() + " - " + obj1.getRg() + " - " + obj1.getCpf()); 
 System.out.println(obj2.getNome() + " - " + obj2.getRg() + " - " + obj2.getCpf()); 
 
 } 
} 
 
Execução: 
 NOME - RG - CPF 
Gleidson Porto - 888.888-8 - 888.888.888-88 
Roberto Carlos - 999.999-9 - 999.999.999-99 
c) Em uma escola, além dos alunos temosos funcionários, que também precisam ser representados em nossa 
aplicação. Então implemente outra classe chamada Funcionario que contenha dois atributos: o primeiro para o cargo 
e o segundo para o salário dos funcionários. 
public class Funcionario { 
 
 // Definindo os atributos da classe 
 private String cargo; 
 private double salario; 
 
 // Definindo os métodos acessadores 
 public String getCargo() { 
 return cargo; 
 } 
 public void setCargo(String cargo) { 
 this.cargo = cargo; 
 } 
 public double getSalario() { 
 return salario; 
 } 
 public void setSalario(double salario) { 
 this.salario = salario; 
 } 
 
} 
 
d) Faça uma classe chamada TestaFuncionario e crie dois objetos da classe Funcionario atribuindo valores a 
eles. Mostre na tela as informações desses objetos. 
public class TestaFuncionario { 
 
Pág. 
 
RESPOSTAS DO EXERCÍCIOS 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 124 
 public static void main(String[] args) { 
 
 // Criando objeto 1 da classe Funcionario 
 Funcionario obj1 = new Funcionario(); 
 
 // Populando o objeto criado 
 obj1.setCargo("Professor"); 
 obj1.setSalario(10500); 
 
 // Criando objeto 2 da classe Funcionario 
 Funcionario obj2 = new Funcionario(); 
 
 // Populando o objeto criado 
 obj2.setCargo("Diretor"); 
 obj2.setSalario(20500); 
 
 
 // Imprimindo informações dos objetos criados 
 System.out.println(" CARGO - SALÁRIO"); 
 System.out.println(obj1.getCargo() + " - " + obj1.getSalario()); 
 System.out.println(obj2.getCargo() + " - " + obj2.getSalario()); 
 
 } 
 
} 
 
Execução 
CARGO - SALÁRIO 
Professor - 10500.0 
Diretor - 20500.0 
 
e) Em uma escola, os alunos precisam ser divididos por turmas, que devem ser representadas dentro da 
aplicação. Implemente uma classe chamada Turma que contenha quatro atributos: o primeiro para o período, o 
segundo para definir a série, o terceiro para sigla e o quarto para o tipo de ensino. 
public class Turma { 
 
 // Definindo os atributos da classe 
 private String período; 
 private String serie; 
 private String sigla; 
 private String tipoEnsino; 
 
 
 // Definindo os métodos acessadores para garantir o encapsulamento 
 
 
 // Método para recuperar o período 
 public String getPeríodo() { 
 return período; 
 } 
Pág. 
 
RESPOSTAS DO EXERCÍCIOS 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 125 
 // Método para atualizar o período 
 public void setPeríodo(String período) { 
 this.período = período; 
 } 
 public String getSerie() { 
 return serie; 
 } 
 public void setSerie(String serie) { 
 this.serie = serie; 
 } 
 public String getSigla() { 
 return sigla; 
 } 
 public void setSigla(String sigla) { 
 this.sigla = sigla; 
 } 
 public String getTipoEnsino() { 
 return tipoEnsino; 
 } 
 public void setTipoEnsino(String tipoEnsino) { 
 this.tipoEnsino = tipoEnsino; 
 } 
 
 
} 
 
f) Faça uma classe chamada TestaTurma para criar dois objetos da classe Turma. Adicione informações a eles 
e depois mostre essas informações na tela. 
 
public class TestaTurma { 
 
 public static void main(String[] args) { 
 
 // Criando objeto 1 da classe Turma 
 Turma obj1 = new Turma(); 
 
 // Populando o objeto criado 
 obj1.setPeríodo("2016.2"); 
 obj1.setSerie("7a Série"); 
 obj1.setSigla("7A"); 
 obj1.setTipoEnsino("Ensino Médio"); 
 
 
 // Criando objeto 2 da classe aluno 
 Turma obj2 = new Turma(); 
 
 // Populando o objeto criado 
 obj2.setPeríodo("2016.1"); 
 obj2.setSerie("6a Série"); 
 obj2.setSigla("6A"); 
 obj2.setTipoEnsino("Ensino Médio"); 
Pág. 
 
RESPOSTAS DO EXERCÍCIOS 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 126 
 // Imprimindo informações dos objetos criados - obj 1 
 System.out.println("Período.......: " + obj1.getPeríodo()); 
 System.out.println("Série.........: " + obj1.getSerie()); 
 System.out.println("Sigla.........: " + obj1.getSigla()); 
 System.out.println("Tipo Ensino...: " + obj1.getTipoEnsino()); 
 
 System.out.println("-------------------------------------"); 
 // Imprimindo informações dos objetos criados - obj 2 
 System.out.println("Período.......: " + obj2.getPeríodo()); 
 System.out.println("Série.........: " + obj2.getSerie()); 
 System.out.println("Sigla.........: " + obj2.getSigla()); 
 System.out.println("Tipo Ensino...: " + obj2.getTipoEnsino()); 
 } 
} 
Execução 
Período.......: 2016.2 
Série.........: 7a Série 
Sigla.........: 7A 
Tipo Ensino...: Ensino Médio 
------------------------------------- 
Período.......: 2016.1 
Série.........: 6a Série 
Sigla.........: 6A 
Tipo Ensino...: Ensino Médio 
LISTA DE EXERCÍCIO 9.4 
1) Crie duas classes que definam os seguintes atributos e métodos para objetos do tipo: 
 
 
 
 
 
 
 
 
 
Ao final crie um objeto da classe Empregado e um objeto da classe Gerente, atribuindo valores para seus 
salários e comissão para o gerente. Ao final execute os métodos getSalario() de ambos objetos. Lembrar que o 
salário do gerente é composto do salário + comissão. 
Pág. 
 
RESPOSTAS DO EXERCÍCIOS 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 127 
public class Empregado { 
 
 // Atributos da classe empregado 
 private String nome; 
 private float salario; 
 
 // Métodos acessadores 
 public String getNome() { 
 return nome; 
 } 
 public void setNome(String nome) { 
 this.nome = nome; 
 } 
 
 public float getSalario() { 
 return salario; 
 } 
 
 public void setSalario(float salario) { 
 this.salario = salario; 
 } 
 
} 
 
public class Gerente extends Empregado { 
 
 // Atributo da classe 
 private float comissao; 
 
 public float getComissao() { 
 return comissao; 
 } 
 
 public void setComissao(float comissao) { 
 this.comissao = comissao; 
 } 
 
 // Método getSalario sobeescrito da classe Empregado. Pois o salário do Gerente é 
composto do salário + comissão. 
 public float getSalario() { 
 // A palavra reservada super faz referência ao método da super classe. 
 return super.getSalario() + comissao; 
 } 
 
} 
 
 
public class Exercicio_9_4_1 { 
 
 public static void main(String[] args) { 
 
Pág. 
 
RESPOSTAS DO EXERCÍCIOS 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 128 
 
 Empregado empregado = new Empregado(); 
 empregado.setNome("Carlos Alberto"); 
 empregado.setSalario(5600); 
 
 Gerente gerente = new Gerente(); 
 gerente.setNome("Carlos Alberto"); 
 gerente.setSalario(8000); 
 gerente.setComissao(1000); 
 
 System.out.println("Empregado...: " + empregado.getNome()); 
 System.out.println("Salário.....: " + empregado.getSalario()); 
 System.out.println("---------------------------------"); 
 System.out.println("Gerente................: " + gerente.getNome()); 
 System.out.println("Salário + comissão.....: " + gerente.getSalario()); 
 
 } 
 
} 
 
Empregado...: Carlos Alberto 
Salário.....: 5600.0 
--------------------------------- 
Gerente................: Carlos Alberto 
Salário + comissão.....: 9000.0 
LISTA DE EXERCÍCIO 11.5 
 
1) Julgue V ou F os seguintes itens a seguir acerca dos modificadores de Java. 
 
(V) public: Uma classe declarada como pública dá as outras classes, de todos os pacotes, acesso aos seus membros 
que forem públicos também. 
 
(V) private: O membro da classe não pode ser acessado por nenhuma outraclasse, quando é declarado private. 
Como não é visto pelas subclasses, não se aplica regras de overriding. Esse modificador não se aplica a classes, 
somente a seus membros (métodos e atributos). 
 
(V) protected: Quando um membro da classe é declarado assim, ele se torna acessível por classes do mesmo pacote 
ou através de herança. 
 
(F) abstract: Quando é aplicado à classe não permite estendê-la, nos métodos impede que o mesmo seja sobrescrito 
(overriding) na subclasse, já nas variáveis impossibilita que essa seja reinicializada com outro valor. 
 
Pág. 
 
RESPOSTAS DO EXERCÍCIOS 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 129 
(F) final: Classes declaradas como abstratas provém um modo de adiar a implementação de métodos também 
declarados como abstratos para subclasses. Uma classe abstrata não pode ser instanciada, ou seja, não podemos 
chamar os seus construtores. 
 
(V) static: Variáveis e métodos marcados como static pertencem à classe, ao invés de alguma instância dessa, esse 
modificador não se aplica a classes. 
 
(F) public : É o mais restritivo de todos. Atributos e métodos declarados como public em uma classe podem ser 
acessados pelos métodos da própria classe, por classes derivadas desta e por qualquer outra classe em qualquer 
outro pacote. 
 
(V) protected : Atributos e métodos definidos como protected são acessíveis pelos métodos da própria classe e pelas 
classes derivadas. 
 
(V) private : É o mais restritivo. Atributos e métodos declarados como private só podem ser acessados pelos métodos 
da própria classe. 
 
 (V) A instrução final indica que a classe, método ou variável assim declarada têm uma única atribuição que se 
mantém constante, ou seja, não pode ser alterada no decorrer do processamento. 
(F) O nível de acesso protected é mais restritivo do que o nível de acesso private. 
(F ) Os métodos declarados como public só podem ser acessados a partir dos métodos da própria classe ou de 
classes derivadas. 
 
2) Porque esse código não compila? 
class Teste { 
 
int x = 37; 
 
public static void main(String [] args) { 
 System.out.println(x); 
 } 
} 
R = O código não compila porque o atributo X não é estático, pois métodos estáticos podem somente acessar 
variáveis também estáticas, ou seja, é proibido o uso de variáveis não estáticas dentro de blocos estáticos, com 
exceção de variáveis criadas dentro do próprio bloco é claro. Essa restrição se deve ao fato de que é possível fazer 
Pág. 
 
RESPOSTAS DO EXERCÍCIOS 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 130 
uma chamada a um método estático mesmo sem haver nenhuma instância dessa classe, ou seja, a provável variável 
a ser referenciada dentro do método pode nem mesmo ter sido criada ainda. 
 
3) Defina uma classe Funcionário com os atributos nome, cargo e salário. Na mesma classe, defina os métodos 
acessadores para garantir o encapsulamento dos atributos. Defina outra classe com o método main para 
criar objetos da classe Funcionário e executar os seus métodos. 
public class Funcionario { 
 
 // Definindo os atributos da classe 
 private String nome; 
 private String cargo; 
 private double salario; 
 
 // Definindo os métodos acessadores 
 public String getNome() { 
 return nome; 
 } 
 public void setNome(String nome) { 
 this.nome = nome; 
 } 
 
 public String getCargo() { 
 return cargo; 
 } 
 public void setCargo(String cargo) { 
 this.cargo = cargo; 
 } 
 public double getSalario() { 
 return salario; 
 } 
 public void setSalario(double salario) { 
 this.salario = salario; 
 } 
 
} 
 
public class TesteFuncionario11_5 { 
 
 public static void main(String[] args) { 
 
 // Criando objeto 1 da classe Funcionario 
 Funcionario obj1 = new Funcionario(); 
 
 // Populando o objeto criado 
 obj1.setNome("Joao da Silva"); 
 obj1.setCargo("Professor"); 
 obj1.setSalario(10500); 
 
 
 // Imprimindo informações dos objetos criados 
Pág. 
 
RESPOSTAS DO EXERCÍCIOS 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 131 
 System.out.println(" CARGO - SALÁRIO"); 
 System.out.println("Nome......: " + obj1.getNome()); 
 System.out.println("Cargo.....: " + obj1.getCargo()); 
 System.out.println("Salário...: " + obj1.getSalario()); 
 
 } 
 
} 
 
Execução 
CARGO - SALÁRIO 
Nome......: Joao da Silva 
Cargo.....: Professor 
Salário...: 10500.0 
 
 LISTA DE EXERCÍCIO 13.5 
a) Defina a classe Contador como uma subclasse de Thread, que imprime números de 0 a 10. Crie a classe 
TesteContador que deve definir o método main que cria e inicia a execução do thread Contador. Teste o resultado 
executando a classe TesteContador. 
 
public class Contador extends Thread { 
 
 // Definição do método construtor atribuindo o nome para Thread 
 public Contador(String nome) 
 { 
 super(nome); 
 } 
 
 // Método de execução da Thread 
 public void run(){ 
 for (int i=0; i<=10; i++) 
 { 
 System.out.println(getName()+ " - " +i ); 
 } 
 } 
 
} 
public class TesteContador { 
 
 public static void main(String[] args) { 
 
 // Criando os objetos da classe contador 
 Contador contaA = new Contador("ContadorA"); 
 Contador contaB = new Contador("ContadorB"); 
 
 // Iniciando as Threads 
 contaA.start(); 
 contaB.start(); 
Pág. 
 
RESPOSTAS DO EXERCÍCIOS 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 132 
 
 } 
 
} 
 
b) Altere as classes Contador e TesteContador de modo que a classe Contador seja definida como uma 
implementação da interface Runnable. Teste o resultado. 
 
public class Contador implements Runnable { 
 
 public void run() { 
 for (int i=0; i<=10; i++) 
 { 
 System.out.println(" Contador --> "+i); 
 } 
 } 
} 
 
public class TesteContador { 
 
 public static void main(String[] args) { 
 
 // Criando os objetos da classe contador 
 Contador contaAInterface = new Contador(); 
 Contador contaBInterface = new Contador(); 
 
 Thread threadContaA = new Thread(contaAInterface); 
 Thread threadContaB = new Thread(contaBInterface); 
 
 
 // Iniciando as Threads 
 threadContaA.start(); 
 threadContaB.start(); 
 
 } 
 
} 
 
LISTA DE EXERCÍCIO 14.7 
 
a) Faça um programa em Java que leia um texto informado pelo usuário no console e que salve o texto informado em 
um arquivo qualquer. 
 
import java.io.FileWriter; 
import java.io.IOException; 
import java.io.InputStream; 
Pág. 
 
RESPOSTAS DO EXERCÍCIOS 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 133 
import java.io.PrintWriter; 
import java.util.Scanner; 
 
public class Exercicio_14_7_A { 
 
 public static void main(String[] args) { 
 
 System.out.println("**** Gravação em arquivo texto **** \n\n"); 
 
 
 // O objeto System.in possibilita a leitura do que se escreve no teclado 
 InputStream entrada = System.in; 
 Scanner linha = new Scanner(entrada); 
 
 // Capturando os números 
 System.out.print("Informe o texto......: "); 
 String texto = linha.nextLine(); 
 
 
 FileWriter arq; 
 try { 
 arq = new FileWriter("c:\\temp\\teste.txt"); 
 PrintWriter gravarArq = new PrintWriter(arq); 
 
 gravarArq.printf(texto); 
 arq.close(); 
 
 } catch (IOException e) { 
 // TODO Auto-generated catch block 
 e.printStackTrace(); 
 } 
 
 
 System.out.print("\nTexto gravado do sucessono arquivo " + 
"c:\\temp\\teste.txt"); 
 
 } 
 
} 
 
LISTA DE EXERCÍCIO 15.3 
 
a) Implemente uma classe em Java com as funcionalidades de uma agenda telefônica, associando um nome a 
um número telefônico. A classe deve possuir a interface abaixo: 
Pág. 
 
RESPOSTAS DO EXERCÍCIOS 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 134 
 
import java.util.HashMap; 
import java.util.Map; 
 
public class AgendaTelefonica { 
 
 // Criação da estrutura de dados HashMap para os contatos 
 Map<String, String> contatos = new HashMap<String, String>(); 
 
 
 // Método para inserir o nome e número na agenda de contatos 
 public void inserir(String nome, String numero){ 
 contatos.put(nome, numero); 
 System.out.println("Nome e número inseridos com sucesso! "); 
 
 } 
 
 
 // Método para buscar o número do contato 
 public String buscarNumero(String nome){ 
 return contatos.get(nome); 
 } 
 
 
 // Método para remover o contato 
 public void remover(String nome){ 
 if (contatos.remove(nome)!=null) 
 System.out.println(nome + " removido com sucesso da agenda! "); 
 else System.out.println(nome + " não encontrado na agenda. "); 
 } 
 
 
 // Método para retornar o número de contatos cadastrados 
 public int tamanho(){ 
 return contatos.size(); 
 } 
 
} 
 
b) Crie um programa em Java para testar a classe AgendaTelefonica desenvolvida no exercício anterior. Teste 
a classe com pelo menos 5 contatos diferentes na agenda de telefones. 
 
Pág. 
 
RESPOSTAS DO EXERCÍCIOS 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 135 
import java.io.InputStream; 
import java.util.Scanner; 
 
public class AppAgendaTelefonica { 
 
 public static void main(String[] args) { 
 
 AgendaTelefonica agenda = new AgendaTelefonica(); 
 
 
 InputStream entrada = System.in; 
 Scanner linha = new Scanner(entrada); 
 
 String nome; 
 String numero; 
 
 
 int opcao = mostrarOpcoes(); 
 
 while (opcao!=0) { 
 
 
 switch (opcao) { 
 
 // Inserir contato 
 case 1: 
 System.out.println("*** 1 - Cadastro de Contato *** "); 
 System.out.print("Digite o nome: "); 
 nome = linha.nextLine(); 
 System.out.print("Digite o número: "); 
 numero = linha.nextLine(); 
 agenda.inserir(nome, numero); 
 break; 
 // Localizar número 
 case 2: 
 System.out.println("*** 2 - Localização de Número **** "); 
 System.out.print("Digite o contato: "); 
 nome = linha.nextLine(); 
 
 String numeroEncontrado = agenda.buscarNumero(nome); 
 
 if (numeroEncontrado!=null) 
 System.out.println(" Telefone " + numeroEncontrado + " do 
contato " + nome); 
 else System.out.println(" Telefone não encontrado para o contato " + 
nome); 
 
 break; 
 //Excluir contato 
 case 3: 
 System.out.println("*** 3 - Exclusão de Número *** "); 
 System.out.println("Digite o contato para exclusão: "); 
 nome = linha.nextLine(); 
 
 agenda.remover(nome); 
Pág. 
 
RESPOSTAS DO EXERCÍCIOS 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 136 
 break; 
 
 // Quantidade de contatos 
 case 4: 
 System.out.println("*** 4 - Quantidade de Contatos *** "); 
 System.out.println(agenda.tamanho() + " contato(s) cadastrados na 
agenda. "); 
 break; 
 
 // Sair do sistema 
 case 0: 
 System.exit(0); 
 break; 
 } 
 
 opcao = mostrarOpcoes(); 
 
 } 
 
 } 
 
 public static int mostrarOpcoes(){ 
 System.out.println("\n*** AGENDA TELEFÔNICA *** \n"); 
 
 // apresentando as opções do menu ao usuário 
 System.out.println("1 - Incluir Contato "); 
 System.out.println("2 - Localizar Número "); 
 System.out.println("3 - Excluir Contato "); 
 System.out.println("4 - Quantidade de contatos "); 
 System.out.println("0 - Sair "); 
 System.out.print("\n Digite a opção: "); 
 
 // O objeto System.in possibilita a leitura do que se escreve no teclado 
 InputStream entrada = System.in; 
 Scanner linha = new Scanner(entrada); 
 
 // capturando a opçao do usuário 
 int opcao = linha.nextInt(); 
 
 // retornando a opção 
 return opcao; 
 
 } 
 
} 
*** AGENDA TELEFÔNICA *** 
 
1 - Incluir Contato 
2 - Localizar Número 
3 - Excluir Contato 
4 - Quantidade de contatos 
0 - Sair 
 
 Digite a opção: 
Pág. 
 
REFERÊNCIAS 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 137 
REFERÊNCIAS 
 
 Liang, Daniel, Eclipse Tutorial: a Supplement J, 2005. 
 Eclipse, In: Eclipse Foundation: Disponível em: http://www.eclipse.org. 
 Eclipse(IDE), In: Wikipédia: a enciclopédia livre. 
 Erickson, Marc (IBM), What is Eclipse, and how do I use it? 
 Paul Deitel Harvey Deitel. Java Como Programar. oitava edição. ISBN-10: 8576055635. Pearson, 2010. 
 Bertrand Meyer. Object-Oriented Software Construction. segunda edição. ISBN-10: 0136291554. Prentice 
Hall, 1997. 
 Heller, Philip. Guia Completo de Estudos para Certificação em Java. 
 Silveira, Paulo. Um pouco sobre o pacote java.util. 
 Rogers Cadenhead & Laura Lemay. Aprenda em 21 dias java. 
 Cornell, Gary. Core Java. 
 Documentação oficial – Java/Oracle. 
 Outros sites especializados em Java.