orientação a objetos em java

Prévia do material em texto

Orientação a objetos 
em Java - JOO 
 
 
 
 
 
 
 
 
 
 
JAVA OO UDF – LINGUAGEM DE PROGRAMAÇÃO JAVA OO PÁGINA 2 
 
Sumário 
1 INTRODUÇÃO ....................................................................................................................................................... 6 
1.3 História da Linguagem Java ................................................................................................................................ 7 
2 A LINGUAGEM JAVA ............................................................................................................................................ 8 
2.1 Java ..................................................................................................................................................................... 8 
2.2 Máquina Virtual .................................................................................................................................................... 8 
2.3 Garbage Collection .............................................................................................................................................. 9 
2.4 Instalando o Java ............................................................................................................................................... 10 
2.4.1 Instalando o JDK............................................................................................................................................. 10 
2.4.2 Configurando o Java no Windows .................................................................................................................. 11 
2.4.3 Confirmando a instalação e configuração do Java ......................................................................................... 13 
2.5 Compilando e executando o primeiro programa ................................................................................................ 13 
3 AMBIENTE INTEGRADO DE DESENVOLVIMENTO - ECLIPSE ....................................................................... 15 
3.1 O Eclipse ........................................................................................................................................................... 15 
3.2 Característica e Ferramentas ............................................................................................................................ 15 
3.3 Instalando o Eclipse ........................................................................................................................................... 16 
3.4 Conhecendo o Eclipse ....................................................................................................................................... 16 
4 SINTAXE DA LINGUAGEM JAVA ....................................................................................................................... 18 
4.1 Delimitadores em Java ...................................................................................................................................... 18 
4.2 Identificadores e palavras reservadas ............................................................................................................... 19 
4.3 Declarando variáveis em Java ........................................................................................................................... 21 
4.5 - Convenções de codificação ............................................................................................................................. 24 
4.6 Exercícios ................................................................................................................................................ 25 
5 EXPRESSÕES ..................................................................................................................................................... 26 
5.1 Operadores lógicos e aritméticos....................................................................................................................... 26 
5.2 Concatenação de Strings com o operador +...................................................................................................... 27 
Alguns métodos úteis em dados do tipo String: ....................................................................................................... 27 
5.3 Promoção e Casting .......................................................................................................................................... 28 
5.4 Operadores de deslocamento (>>, >>) ...................................................................................................... 29 
5.5 Circuitos lógicos ................................................................................................................................................. 29 
5.6 Exercícios ................................................................................................................................................ 30 
6 FLUXO DE CONTROLE ....................................................................................................................................... 31 
6.1 Ramificação if, else ............................................................................................................................................ 31 
JAVA OO UDF – LINGUAGEM DE PROGRAMAÇÃO JAVA OO PÁGINA 3 
6.2 Ramificação switch ............................................................................................................................................ 32 
6.3 Repetição for ..................................................................................................................................................... 33 
6.4 Repetição while.................................................................................................................................................. 34 
6.5 Comandos especiais de controle de fluxo: break, continue e label ................................................................... 35 
6.6 Lendo valores do teclado ................................................................................................................................... 36 
6.7 Exercícios .......................................................................................................................................................... 36 
7 AGRUPAMENTO DE DADOS (ARRAYS) ........................................................................................................... 37 
7.1 Declarando e criando Arrays ............................................................................................................................. 37 
7.2 Modificando o conteúdo de um array ................................................................................................................. 39 
7.3 Acessando o conteúdo de um array .................................................................................................................. 39 
7.4 Percorrendo um Array ........................................................................................................................................ 40 
7.5.1 Ordenando um Array ...................................................................................................................................... 41 
7.5.2 Duplicando um Array ...................................................................................................................................... 41 
7.5.3 Preenchendo um Array ................................................................................................................................... 41 
7.6 Arrays multidimensionais ................................................................................................................................... 42 
7.7 Array esparso ....................................................................................................................................................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 UDF - SI - LINGUAGEM DE PROGRAMAÇÃO PÁGINA 38 
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 UDF - SI - LINGUAGEM DE PROGRAMAÇÃO PÁGINA 39 
 
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 UDF - SI - LINGUAGEM DE PROGRAMAÇÃO PÁGINA 40 
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; iagrupamento 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 UDF - SI - LINGUAGEM DE PROGRAMAÇÃO PÁGINA 43 
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 UDF - SI - LINGUAGEM DE PROGRAMAÇÃO PÁGINA 44 
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 a importâ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 UDF - SI - LINGUAGEM DE PROGRAMAÇÃO PÁGINA 45 
(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 UDF - SI - LINGUAGEM DE PROGRAMAÇÃO PÁGINA 46 
 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 UDF - SI - LINGUAGEM DE PROGRAMAÇÃO PÁGINA 47 
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ímulosexternos 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 UDF - SI - LINGUAGEM DE PROGRAMAÇÃO PÁGINA 48 
 
 
 
 
 
 
 
 
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 UDF - SI - LINGUAGEM DE PROGRAMAÇÃO PÁGINA 49 
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 UDF - SI - LINGUAGEM DE PROGRAMAÇÃO PÁGINA 50 
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 UDF - SI - LINGUAGEM DE PROGRAMAÇÃO PÁGINA 51 
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 tipoConta. 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 UDF - SI - LINGUAGEM DE PROGRAMAÇÃO PÁGINA 52 
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 UDF - SI - LINGUAGEM DE PROGRAMAÇÃO PÁGINA 53 
 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 UDF - SI - LINGUAGEM DE PROGRAMAÇÃO PÁGINA 54 
 
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 UDF - SI - LINGUAGEM DE PROGRAMAÇÃO PÁGINA 55 
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 UDF - SI - LINGUAGEM DE PROGRAMAÇÃO PÁGINA 56 
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 UDF - SI - LINGUAGEM DE PROGRAMAÇÃO PÁGINA 57 
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 UDF - SI - LINGUAGEM DE PROGRAMAÇÃO PÁGINA 58 
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 UDF - SI - LINGUAGEM DE PROGRAMAÇÃO PÁGINA 59 
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, POLIMORFISMO E INTERFACES 
 
 
 
JAVA OO UDF - SI - LINGUAGEM DE PROGRAMAÇÃO PÁGINA 60 
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 UDF - SI - LINGUAGEM DE PROGRAMAÇÃO PÁGINA 61 
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 UDF - SI - LINGUAGEM DE PROGRAMAÇÃO PÁGINA 62 
 } 
 
 public class TV implements ControleRemoto 
 { 
 public void ligaTV() {...} 
 public void desligaTV() {...} 
 public void mudaCanalTV(int canalNovo) {...} 
 } 
 
 
Pág. 
 
10 OO - CLASSES ABSTRATAS 
 
 
 
JAVA OO UDF - SI - LINGUAGEM DE PROGRAMAÇÃO PÁGINA 63 
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 UDF - SI - LINGUAGEM DE PROGRAMAÇÃO PÁGINA 64 
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 
somenteacessí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 UDF - SI - LINGUAGEM DE PROGRAMAÇÃO PÁGINA 65 
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 UDF - SI - LINGUAGEM DE PROGRAMAÇÃO PÁGINA 66 
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 UDF - SI - LINGUAGEM DE PROGRAMAÇÃO PÁGINA 67 
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 UDF - SI - LINGUAGEM DE PROGRAMAÇÃO PÁGINA 68 
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 umachamada 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 UDF - SI - LINGUAGEM DE PROGRAMAÇÃO PÁGINA 69 
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 ENCAPSULAMENTO 
Serve 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 UDF - SI - LINGUAGEM DE PROGRAMAÇÃO PÁGINA 70 
 
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 UDF - SI - LINGUAGEM DE PROGRAMAÇÃO PÁGINA 71 
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 UDF - SI - LINGUAGEM DE PROGRAMAÇÃO PÁGINA 72 
( ) 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 UDF - SI - LINGUAGEM DE PROGRAMAÇÃO PÁGINA 73 
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çaque 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 UDF - SI - LINGUAGEM DE PROGRAMAÇÃO PÁGINA 74 
// 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 que sempre 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 UDF - SI - LINGUAGEM DE PROGRAMAÇÃO PÁGINA 75 
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 UDF - SI - LINGUAGEM DE PROGRAMAÇÃO PÁGINA 76 
 
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 UDF - SI - LINGUAGEM DE PROGRAMAÇÃO PÁGINA 77 
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 (como o 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 UDF - SI - LINGUAGEM DE PROGRAMAÇÃO PÁGINA 78 
 
Pág. 
 
THREADS 
 
 
 
JAVA OO UDF - SI - LINGUAGEM DE PROGRAMAÇÃO PÁGINA 79 
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 UDF - SI - LINGUAGEM DE PROGRAMAÇÃO PÁGINA 80 
 
 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 UDF - SI - LINGUAGEM DE PROGRAMAÇÃO PÁGINA 81 
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 ainterface 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 UDF - SI - LINGUAGEM DE PROGRAMAÇÃO PÁGINA 82 
public class ThreadInterface implements Runnable { 
 public void run() 
 { 
 for (int i=0; i "+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 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 Sapos42 
7.8 Exercícios ................................................................................................................................................ 43 
8 ORIENTAÇÃO A OBJETOS(OO) BÁSICA ......................................................................................................... 44 
8.1 Fundamentos da Programação Orientada a Objetos......................................................................................... 44 
8.2. Paradigma Orientado por Objetos .................................................................................................................... 44 
8.3 Principais conceitos de POO ............................................................................................................................. 44 
8.3.1 Objetos ........................................................................................................................................................... 44 
8.3.2 Atributos e métodos ........................................................................................................................................ 46 
8.3.3 Classes ........................................................................................................................................................... 47 
8.3.3 Instanciação .................................................................................................................................................... 48 
8.4 - Exercício - Conceitos OO ................................................................................................................................ 49 
8.5 – Classes e Objetos em Java ............................................................................................................................ 50 
8.5.1 Criando objetos em Java ................................................................................................................................ 50 
8.5.2 Referências ..................................................................................................................................................... 51 
8.5.3 Manipulando Atributos .................................................................................................................................... 52 
8.5.4 Valores Padrão ............................................................................................................................................... 52 
8.6 Exercícios Complementares .............................................................................................................................. 54 
9 OO - HERANÇA, POLIMORFISMO E INTERFACES ......................................................................................... 55 
9.1 Objetos e Construtor .......................................................................................................................................... 55 
9.2 Herança ............................................................................................................................................................. 55 
9.3 Polimorfismo ...................................................................................................................................................... 57 
JAVA OO UDF – LINGUAGEM DE PROGRAMAÇÃO JAVA OO PÁGINA 4 
9.3.1 Polimorfismo - Sobreescrita ............................................................................................................................ 58 
9.3.2 Polimorfismo – Sobrecarga ............................................................................................................................. 59 
9.4 Exercício - Polimorfismo .................................................................................................................................... 60 
9.5 Interfaces ........................................................................................................................................................... 61 
10 OO - CLASSES ABSTRATAS ........................................................................................................................... 63 
11 MODIFICADORES JAVA ................................................................................................................................... 64 
11.1 Introdução ........................................................................................................................................................ 64 
11.2 Modificadores de Acesso ................................................................................................................................. 64 
11.2.1 Private ........................................................................................................................................................... 65 
11.2.2 Protected ...................................................................................................................................................... 66 
11.2.3 Public ............................................................................................................................................................ 67 
11.2.4 Default (padrão) ............................................................................................................................................ 67 
11.3 Outros Modificadores ....................................................................................................................................... 67 
11.3.1 Final .............................................................................................................................................................. 67 
11.3.2Abstract .......................................................................................................................................................... 68 
11.3.3 Static ............................................................................................................................................................. 68 
11.3.4 Transient ....................................................................................................................................................... 69 
11.3.5 Synchronized ................................................................................................................................................ 69 
11.3.6 Volatile .......................................................................................................................................................... 69 
11.3.7 Native ............................................................................................................................................................ 69 
11.4 Encapsulamento .............................................................................................................................................. 69 
11.4.1 Métodos Getters e Setters ............................................................................................................................ 70 
11.5 Exercício .......................................................................................................................................................... 71 
12 EXCEÇÕES – CONTROLANDO OS ERROS .................................................................................................... 73 
12.1 Tratamento de exceções ................................................................................................................................. 73 
12.2 Erros e Exceções de runtime ........................................................................................................................... 75 
12.3 Propagando exceções ..................................................................................................................................... 75 
12.4 Definindo e gerando exceçoes ........................................................................................................................*/ 
 public void run () { 
 while (distanciaCorridaarquivo 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ícios 
 
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. 
Pág. 
 
15 COLLECTIONS FRAMEWORK 
 
 
 
JAVA OO UDF - SI - LINGUAGEM DE PROGRAMAÇÃO PÁGINA 93 
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 UDF - SI - LINGUAGEM DE PROGRAMAÇÃO PÁGINA 94 
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 UDF - SI - LINGUAGEM DE PROGRAMAÇÃO PÁGINA 95 
 
 // 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 list = new ArrayList(); 
 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 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 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 UDF - SI - LINGUAGEM DE PROGRAMAÇÃO PÁGINA 97 
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 UDF - SI - LINGUAGEM DE PROGRAMAÇÃO PÁGINA 98 
 
 // Criando a estrutura de mapas 
 Map 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 UDF - SI - LINGUAGEM DE PROGRAMAÇÃO PÁGINA 99 
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 UDF - SI - LINGUAGEM DE PROGRAMAÇÃO PÁGINA 100 
RESPOSTAS DO EXERCÍCIOS 
 
 As respostas dos exercícios descritos neste material são apresentadas pelo professor em sala de 
aula. 
Pág. 
 
REFERÊNCIAS 
 
 
 
JAVA OO UDF - SI - LINGUAGEM DE PROGRAMAÇÃO PÁGINA 101 
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.76 
12.5 Hierarquia de exceções Java ........................................................................................................................... 77 
13 THREADS .................................................................................................................................................... 79 
13.1 Conceito de Threads ........................................................................................................................................ 79 
13.2 Ciclo de Vida de uma Thread .......................................................................................................................... 80 
13.2.1 Criando Threads ........................................................................................................................................... 80 
13.2.2 Iniciando Threads ......................................................................................................................................... 81 
13.2.3 Fazendo Thread Esperar .............................................................................................................................. 81 
13.2.4 Finalizando Threads ..................................................................................................................................... 81 
JAVA OO UDF – LINGUAGEM DE PROGRAMAÇÃO JAVA OO PÁGINA 5 
13.2.5 Verificando se Threads estão Executando/Pronta/Esperando ou Novas/Mortas .......................................... 81 
13.3 Implementando Threads em java..................................................................................................................... 81 
13.4 Escalonamento de Threads ............................................................................................................................. 83 
13.5 Exercícios ........................................................................................................................................................ 86 
14 API JAVA - JAVA.IO ......................................................................................................................................... 87 
14.1 Classe InputStream ......................................................................................................................................... 87 
14.2 Lendo um arquivo ............................................................................................................................................ 88 
14.3 OutputStream................................................................................................................................................... 90 
14.4 Reader ............................................................................................................................................................. 90 
14.5 Writer ............................................................................................................................................................... 90 
14.6 Buffers ............................................................................................................................................................. 91 
14.7 Exercícios ........................................................................................................................................................ 92 
15 COLLECTIONS FRAMEWORK ......................................................................................................................... 93 
15.1 – Introdução ..................................................................................................................................................... 93 
15.2 – Tipos de Coleções ........................................................................................................................................ 93 
15.2.1 – Lista ........................................................................................................................................................... 96 
15.2.2 – Conjunto .................................................................................................................................................... 97 
15.2.3 – Mapas ........................................................................................................................................................ 97 
15.3 – Exercício ....................................................................................................................................................... 99 
RESPOSTAS DO EXERCÍCIOS ............................................................................................................................100 
REFERÊNCIAS ......................................................................................................................................................101 
 
 
 
 
 
 
 
JAVA OO UDF – LINGUAGEM DE PROGRAMAÇÃO JAVA OO PÁGINA 6 
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 
proporcionar maior 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 UDF – LINGUAGEM DE PROGRAMAÇÃO JAVA OO PÁGINA 7 
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 trabalharamarduamente 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 UDF – LINGUAGEM DE PROGRAMAÇÃO JAVA OO PÁGINA 8 
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 UDF – LINGUAGEM DE PROGRAMAÇÃO JAVA OO PÁGINA 9 
 
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âmetros dos 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 UDF – LINGUAGEM DE PROGRAMAÇÃO JAVA OO PÁGINA 
10 
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. Mostraremosa 
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). 
http://www.oracle.com/technetwork/java/javase/downloads/index.html
JAVA OO UDF – LINGUAGEM DE PROGRAMAÇÃO JAVA OO PÁGINA 
11 
 
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 
http://404846152.r.upxcdn.net/br/wp-content/uploads/2015/05/Figura1.png
JAVA OO UDF – LINGUAGEM DE PROGRAMAÇÃO JAVA OO PÁGINA 
12 
 
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”. 
 
 
 
 
http://404846152.r.upxcdn.net/br/wp-content/uploads/2015/05/Figura2.png
http://404846152.r.upxcdn.net/br/wp-content/uploads/2015/05/Figura3.png
JAVA OO UDF – LINGUAGEM DE PROGRAMAÇÃO JAVA OO PÁGINA 
13 
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.4: 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 UDF – LINGUAGEM DE PROGRAMAÇÃO JAVA OO PÁGINA 
14 
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 UDF – LINGUAGEM DE PROGRAMAÇÃO JAVA OO PÁGINA 
15 
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) 
http://www.eclipse.org/
http://www.eclipse.org/
JAVA OO UDF – LINGUAGEM DE PROGRAMAÇÃO JAVA OO PÁGINA 
16 
 
 
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 
http://www.eclipse.org/downloads/packages/eclipse-ide-java-developers/neonr
http://404846152.r.upxcdn.net/br/wp-content/uploads/2015/05/Figura6.png
JAVA OO UDF – LINGUAGEM DE PROGRAMAÇÃO JAVA OO PÁGINA 
17 
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 UDF – LINGUAGEM DE PROGRAMAÇÃO JAVA OO 
PÁGINA 18 
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 UDF – LINGUAGEM DE PROGRAMAÇÃO JAVA OO 
PÁGINA 19 
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 UDF – LINGUAGEM DE PROGRAMAÇÃO JAVA OO 
PÁGINA 20 
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 UDF – LINGUAGEM DE PROGRAMAÇÃO JAVA OO 
PÁGINA 21 
4.3 Declarando variáveis em Java 
Uma variável é sempre declarada seguindo do seguinte esquema: 
 + + identificador + ; 
ou 
 + + identificador + = + valor + ; 
onde: 
 é 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 UDF – LINGUAGEM DE PROGRAMAÇÃO JAVA OO 
PÁGINA 22 
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 programasJava. 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é 2
16
-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 UDF – LINGUAGEM DE PROGRAMAÇÃO JAVA OO 
PÁGINA 23 
 // 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 24 
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 inclusã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 com letra 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 25 
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 26 
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. 
instanceof 
Identificador de classes 
 
 
 
 
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 27 
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 28 
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 29 
 
 
 
 
 
 
 
 
 
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 durante o 
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 UDF - SI - LINGUAGEM DE PROGRAMAÇÃO PÁGINA 30 
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 i) 
f. ((10 * 90 / 50 – 2) == 16) 
Pág. 
 
6 FLUXO DE CONTROLE 
 
 
 
JAVA OO UDF - SI - LINGUAGEM DE PROGRAMAÇÃO PÁGINA 31 
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 booleanaboolean verdade = (10 > 5); 
 
 if (verdade) 
 { 
 // (10 > 5) = true 
 System.out.println(maior + ">" + menor); 
 
 } 
Pág. 
 
6 FLUXO DE CONTROLE 
 
 
 
JAVA OO UDF - SI - LINGUAGEM DE PROGRAMAÇÃO PÁGINA 32 
 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 UDF - SI - LINGUAGEM DE PROGRAMAÇÃO PÁGINA 33 
 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 0; i--) 
 { 
 fatorial = fatorial * i; 
 } 
 
 System.out.println("fatorial de " + numero + " = " + fatorial); 
 
 // Imprimindo os dias do ano: 
 for (int mes = 1; mes 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