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.