Preparatório para Certificação JAVA - OCPJP - iMasters

Prévia do material em texto

Preparatório para 
Certificação JAVA - 
OCPJP 
Índice de Conteúdo 
 Introdução 
o Sobre o Curso 
o Metodologia do Curso 
o Sobre o exame OCPJP 
o Blog do Autor 
o Por que ser um profissional certificado? 
o Certificações Oracle 
o Guia do Exame 
 Fundamentos Java 
o Identificadores e classes 
o Interface e modificadores de acesso 
o Construtores e variáveis 
 Orientação a Objetos 
o Sobrecarga e conversão 
o Interface e tipos de retorno 
 Exercício 1 
o Respostas do Exercício 1 
 Atributos 
o Array e Blocos 
o Wrapper e AutoBoxing 
o Ampliação e Sobrecarga de variáveis 
 Operadores 
 Controle de Fluxo 
 Exercício 2 
o Respostas do exercício 2 
 API - Tratamento Exceções /Assertivas 
o Assertivas 
 API 
o Classe String 
o StringBuilder & StringBuffer 
o Manipulação de Arquivos 
o Serialização 
http://pro.imasters.com.br/online/cursos/preparatorio-para-certificacao-java-ocjp/pagina/1504
http://pro.imasters.com.br/online/cursos/preparatorio-para-certificacao-java-ocjp/pagina/1486
http://pro.imasters.com.br/online/cursos/preparatorio-para-certificacao-java-ocjp/pagina/1555
http://pro.imasters.com.br/online/cursos/preparatorio-para-certificacao-java-ocjp/pagina/1484
http://pro.imasters.com.br/online/cursos/preparatorio-para-certificacao-java-ocjp/pagina/1478
http://pro.imasters.com.br/online/cursos/preparatorio-para-certificacao-java-ocjp/pagina/3264
http://pro.imasters.com.br/online/cursos/preparatorio-para-certificacao-java-ocjp/pagina/1530
http://pro.imasters.com.br/online/cursos/preparatorio-para-certificacao-java-ocjp/pagina/17671
http://pro.imasters.com.br/online/cursos/preparatorio-para-certificacao-java-ocjp/pagina/1488
http://pro.imasters.com.br/online/cursos/preparatorio-para-certificacao-java-ocjp/pagina/1517
http://pro.imasters.com.br/online/cursos/preparatorio-para-certificacao-java-ocjp/pagina/1518
http://pro.imasters.com.br/online/cursos/preparatorio-para-certificacao-java-ocjp/pagina/1729
http://pro.imasters.com.br/online/cursos/preparatorio-para-certificacao-java-ocjp/pagina/1519
http://pro.imasters.com.br/online/cursos/preparatorio-para-certificacao-java-ocjp/pagina/1764
http://pro.imasters.com.br/online/cursos/preparatorio-para-certificacao-java-ocjp/pagina/2084
http://pro.imasters.com.br/online/cursos/preparatorio-para-certificacao-java-ocjp/pagina/1544
http://pro.imasters.com.br/online/cursos/preparatorio-para-certificacao-java-ocjp/pagina/3582
http://pro.imasters.com.br/online/cursos/preparatorio-para-certificacao-java-ocjp/pagina/1522
http://pro.imasters.com.br/online/cursos/preparatorio-para-certificacao-java-ocjp/pagina/2106
http://pro.imasters.com.br/online/cursos/preparatorio-para-certificacao-java-ocjp/pagina/2107
http://pro.imasters.com.br/online/cursos/preparatorio-para-certificacao-java-ocjp/pagina/2108
http://pro.imasters.com.br/online/cursos/preparatorio-para-certificacao-java-ocjp/pagina/1523
http://pro.imasters.com.br/online/cursos/preparatorio-para-certificacao-java-ocjp/pagina/2175
http://pro.imasters.com.br/online/cursos/preparatorio-para-certificacao-java-ocjp/pagina/1546
http://pro.imasters.com.br/online/cursos/preparatorio-para-certificacao-java-ocjp/pagina/1551
http://pro.imasters.com.br/online/cursos/preparatorio-para-certificacao-java-ocjp/pagina/2171
http://pro.imasters.com.br/online/cursos/preparatorio-para-certificacao-java-ocjp/pagina/2194
http://pro.imasters.com.br/online/cursos/preparatorio-para-certificacao-java-ocjp/pagina/2220
http://pro.imasters.com.br/online/cursos/preparatorio-para-certificacao-java-ocjp/pagina/2221
http://pro.imasters.com.br/online/cursos/preparatorio-para-certificacao-java-ocjp/pagina/2222
http://pro.imasters.com.br/online/cursos/preparatorio-para-certificacao-java-ocjp/pagina/2242
http://pro.imasters.com.br/online/cursos/preparatorio-para-certificacao-java-ocjp/pagina/2260
o Datas, Números e Moeda 
o Regex 
 Subscrevendo Equals/hashCode 
 Conjuntos 
o Interface Comparable e Comparator 
o Sets e PriorityQueue 
 Genéricos 
 Exercício 3 
o Respostas do exercício 3 
 Classes Internas 
 Threads 
o Estados e transições 
o Sincronização e iteração 
 Desenvolvimento 
 Simulado 
 Considerações Finais 
 
 
Introdução 
O curso a seguir é destinado à quem pretente se tornar um OCPJP (antiga SCJP). 
Nos tópicos teremos acesso a algumas informações relevantes ao curso e ao 
exame. 
 
Sobre o Curso 
Este curso não tem por objetivo ensinar a tecnologia Java. São necessários bons 
conhecimentos básicos sobre a tecnologia. Afinal de contas, o aluno realizará um 
exame real que exige isso. 
Não é necessário ser um expert em JSE, JEE ou JME., mas é preciso algum 
envolvimento básico com Java, como: 
 Saber o que é uma classe Java 
 Atributos Java 
 Tipos de métodos 
 Conceito básico de Orientação a Objetos 
http://pro.imasters.com.br/online/cursos/preparatorio-para-certificacao-java-ocjp/pagina/2276
http://pro.imasters.com.br/online/cursos/preparatorio-para-certificacao-java-ocjp/pagina/2295
http://pro.imasters.com.br/online/cursos/preparatorio-para-certificacao-java-ocjp/pagina/2309
http://pro.imasters.com.br/online/cursos/preparatorio-para-certificacao-java-ocjp/pagina/1524
http://pro.imasters.com.br/online/cursos/preparatorio-para-certificacao-java-ocjp/pagina/2547
http://pro.imasters.com.br/online/cursos/preparatorio-para-certificacao-java-ocjp/pagina/2559
http://pro.imasters.com.br/online/cursos/preparatorio-para-certificacao-java-ocjp/pagina/1525
http://pro.imasters.com.br/online/cursos/preparatorio-para-certificacao-java-ocjp/pagina/1547
http://pro.imasters.com.br/online/cursos/preparatorio-para-certificacao-java-ocjp/pagina/1554
http://pro.imasters.com.br/online/cursos/preparatorio-para-certificacao-java-ocjp/pagina/1526
http://pro.imasters.com.br/online/cursos/preparatorio-para-certificacao-java-ocjp/pagina/1527
http://pro.imasters.com.br/online/cursos/preparatorio-para-certificacao-java-ocjp/pagina/2389
http://pro.imasters.com.br/online/cursos/preparatorio-para-certificacao-java-ocjp/pagina/2390
http://pro.imasters.com.br/online/cursos/preparatorio-para-certificacao-java-ocjp/pagina/1528
http://pro.imasters.com.br/online/cursos/preparatorio-para-certificacao-java-ocjp/pagina/1529
http://pro.imasters.com.br/online/cursos/preparatorio-para-certificacao-java-ocjp/pagina/2530
Todos os códigos foram testados, desde os que compilam aos que não compilam e 
aos que lançam exceções. Muitas explicações foram inseridas dentro de 
comentários Java, a fim de prender a atenção do aluno na explicação e no 
entendimento do código de forma simultânea. 
O aluno encontrará neste curso: 
 Explicação dos objetivos para o exame 
 Exemplos através de códigos 
 Alguns exercícios para revisar 
 Simulado 
 
Metodologia do Curso 
Este curso é um pouco diferente de qualquer outro online, já que não segue um 
padrão de explicação (calma, não fique assustado. Vamos explicar mais adiante). 
Há capítulos em que a explicação está dentro dos comentários dos códigos, e 
outros em que ela se encontra na introdução do capítulo. É usada uma linguagem 
menos formal para as explanações. Mas qual a razão disso? 
No primeiro caso, o objetivo é forçar o aluno a entender o assunto através dos 
códigos que estão sendo apresentados, pois no exame real haverá muitas 
questões com códigos e perguntas referentes a eles. 
O exame não separa a teoria da prática - na verdade, ele as concatena. Ou seja, 
questões exclusivamente teóricas não são o forte do exame. Então, desde já, o 
aluno precisa estar acostumado a ler o código e associá-lo com a teoria. 
No segundo caso, será adotada uma linguagem menos formal, pelo fato de o 
instrutor acreditar que isso poderia ajudar no entendimento dos assuntos de uma 
forma menos técnica com relação ao português. A intenção é que o aluno se sinta 
em um bate-papo com um amigo, e não em um curso online. 
Às vezes será usada a primeira pessoa para explicar um assunto. Quando issoacontecer, o aluno deve refletir e pensar como se estivesse explicando o conteúdo 
para si mesmo. A intenção é que o aluno se lembre mais facilmente do material. 
Infelizmente, há partes no exame que será exigida a "decoreba". 
 
Sobre o exame OCPJP 
Como fazer o exame? 
Para fazer o exame você precisa ir no site da Oracle, solicitar o voucher e informar 
qual exame deseja. 
Após a solicitação, em alguns dias dias úteis você recebe um e-mail para efetuar o 
pagamento em boleto do voucher. 
O valor do voucher está sujeito alteração e você deve verificar com Oracle. 
Após a confirmação de pagamento a Oracle envia o voucher via e-mail. Fique 
atento para o endereço da Oracle não estar sendo filtrado pelo seu filtro de spam. 
Validade: Você tem até um ano para fazer a prova. 
Marcando o exame: após ter estudado bastante é hora de marcar a prova, e o 
processo é feito apenas on-line. O candidato deve marcar o exame de 10 a 15 dias 
antes da data que pretende fazer. Caso seja necessário cancelar o exame, você 
deve fazê-lo até três dias antes da data agendada. 
O exame 
Antes de iniciar o exame real, a Oracle vem com umas 10 perguntas apenas para 
saber o nível dos candidatos do exame. Ainda não é o exame real. 
A Oracle durante todo o tempo vai tentar tirar sua atenção, como por exemplo: 
protected class Teste1{ 
 
int z=10; 
 
public static void main(String ars[]){ 
 
int z=10; 
http://education.oracle.com/
http://www.google.com/search?hl=en&q=allinurl%3Astring+java.sun.com&btnI=I%27m%20Feeling%20Lucky
 
System.out.println(z); 
 
}} 
 A – Compila e imprime 10 
 B – Não compila por que mudou o nome de args 
 C – Lança uma exceção NullPointerException 
 D – Não compila 
A resposta para essa questão é letra D. Devido o modificador protected não ser um 
modificador válido para classe pai. 
O que é mais cobrado no exame? 
Percebi que o exame é bem focado nos seguintes objetivos: fundamentos e OO. 
Porém entender OO de forma fluente é uma boa garantia de se passar no exame, 
mesmo que o programador não seja um expert em API, threads, etc. 
Como são cobrados os novos recursos Java 5? 
Os novos recursos Java 5 são cobrados a todo momento. Como as regras de 
Wrappers, generics, var-args as novas API. O exame está bem direto ao objetivo: 
“de ficar longe dos bits e mais próximo das API.” 
E o tempo é suficiente? 
Sim (são 180 minutos). Porém o candidato deve estar bem preparado para o 
exame. Caso contrário o tempo se esgota e o candidato vai marcar a última 
questão restando apenas 5 minutos. E isso aumenta o risco de ver a mensagem 
“fail". 
Estilo das questões do exame: total 60 questões (OCPJP) 
 Múltipla escolha: é onde tem mais pegadinhas. Muita atenção a elas e desconfie 
daquelas que as respostas aparentam ser óbvias. Antes de responder, analise 
http://www.google.com/search?hl=en&q=allinurl%3Asystem+java.sun.com&btnI=I%27m%20Feeling%20Lucky
sempre as respostas e o código. Veja se há quebra das regras de fundamentos, 
OO antes de marcar a opção que demonstra ser a mais óbvia. 
 Drop: dizem por aí que são as questões mais complicadas no exame. Na minha 
opinião, considero um “certo mito”, pois são as questões que o candidato tem 
certeza que: uma das opções dadas tem que preencher as lacunas em branco e, 
que o código ali está correto. Não há pegadinhas nessas questões. Porém exige 
que o futuro programador tenha praticado, e muito, durante a fase de 
preparação, já que esse tipo de questão está bem próxima das questões mais 
práticas. 
 Mais de uma opção correta/errada: Essas questões também tem pegadinhas 
como as de múltipla escolha. Porém a diferença aqui é que o exame informa 
quantas opções você deve marcar. Se o exame mencionar duas corretas/erradas, 
localize as duas respostas. 
Táctica de ser um bom administrador de tempo no exame 
 Primeiro: fazer todas as questões do exame normalmente. Quando a questão for 
muito longa e tiver uma sintaxe com mais de 30 linhas, marque para revisar. As 
drop não faça logo de cara. Apenas abra a questão, olhe as opções, anote o 
número da questão e, do lado coloque a resposta que achou válida (essas 
questões consomem muito tempo). 
 Após ter feito todas as questões simples, você vai estar no final do exame e, o 
mesmo vai te informar que algumas questões não foram respondidas, ou seja, 
estão em branco. Claro que você sabe, são as de drop (no meu caso apareceram 
apenas 10 questões desse tipo). Então, agora é hora de resolvê-las! Agora com 
mais calma e, nessa altura, sua ansiedade de saber quais as próximas questões, 
não existe mais. 
 Agora restam as questões marcadas para revisar e analisar. Havia questões com 
códigos com 45 linhas. 
 Pronto! Agora vamos estar há aproximadamente 1h20 do término do exame. 
Pode dar uma relaxada (se espreguiçar, beber uma água). Em seguida comece a 
fazer o simulado novamente, revisando a primeira questão e perguntando por 
quê? As outras alternativas não são verdadeiras? Exceto aquelas que estavam 
claras que realmente não compilava (onde você já identificou isso na primeira 
fase). 
 Terminada a revisão, ainda devem restar uns minutos para o final do exame. Ou 
você finaliza o exame, ou revisa mais uma questão. No meu caso finalizei, pois 
comecei a sentir uma leve dor de cabeça. 
 Na revisão é normal identificar as pegadinhas, e as possíveis questões que você 
estaria perdendo, por uma pequena falta de atenção. 
 Um dica: não revise as questões de drop. Se tentar, o exame vai apagar a sua 
resposta anterior. Além de que, tentando novamente, o exame emite uma 
mensagem a respeito. Esse foi um dos motivos pelo qual deixei por último as de 
drop. 
Tempo nas questões 
Não demore mais de 3 min em uma questão seja ela qual for. Assim você ganha 
tempo na revisão. 
Aprovação 
Para ser aprovado você precisa atingir 58.33% 
Não há diferença entre a quantidade e percentual de aprovação entre o exame 
para Java 5 ou 6. São os mesmos. 
Qual fazer OCPJP 5 ou 6? 
Sempre recebo e-mails com essa pergunta. E sempre aconselho, que o candidato 
deve fazer o exame que ele se sente mais preparado em realizar, porque as 
diferenças entre um exame e outro são pouquissimas. Falo isso para quem já vem 
se preparando para OCPJP 5 e não quer ter migrar para OCPJP 6. Porém, se você 
vai começar o estudo hoje, recomendaria já iniciar os estudos a partir da OCPJP 6. 
O mercado aceita as duas versões igualmente, não existe diferenciação quanto a 
isso. 
E o nosso curso, cobre qual exame? 
Eu diria que aborda os dois exames. Uma vez que a parte mais cobrada e talvez a 
mais díficil nos iremos cobrir. O que foi adicionado no exame OCPJP 6, de fato não 
merece nem que você compre um livro ou faça um curso especifico, pois 
abordagem do assunto está dentro do Java doc. São algumas novas APIs 
adicionadas apenas. 
 
Blog do Autor 
No blog do autor, há posts interessantes sobre o assunto na categoria 
Certificações. Portanto não deixe de acessar. 
Acesse: www.camilolopes.com.br 
 
Por que ser um 
profissional certificado? 
A certificação é um selo de qualidade, um atestado de competência e um 
diferencial na carreira profissional. Um bom caminho é ter Experiência + 
Certificação. 
Tanto a certificação quanto a experiência são assuntos bastante polêmicos em 
fóruns, comunidades, nos corredores das universidades etc. 
O que deve ficar claro para o profissional de TI é que a certificação e a experiência 
andam juntas e devem ser somadas na carreira profissional. 
A certificação é um meio para o profissional testar seu conhecimento ou aprender 
de forma disciplinada uma determinada tecnologia (por exemplo, Java). 
Uma certificação tem diversas vantagens para um 
profissional, entre elas: 
 Melhor posicionamento no mercado; 
 Testar o conhecimento sobre a tecnologia; 
 Procura das empresas por profissionais certificados. 
 
http://blog.camilolopes.com.br/?page_id=1312
Certificações OracleA Oracle possui várias certificações. Para entender cada uma delas há um link no 
site da Oracle Education com o caminho que o certificado OCPJP pode seguir após 
obter a certificação, confira: 
Oracle Education 
Um artigo publicado no iMasters tem informações mais detalhadas sobre as 
certificações Oracle. Certificações Oracle 
 
Guia do Exame 
Guia do Exame SCJP 
 
http://education.oracle.com/
http://imasters.com.br/artigo/2547/oracle/certificacoes_oracle/
http://static.imasters.com.br/img/curso/45932.jpg
 
É um livro que surgiu com base minha necessidade de ter um livro focado nas 
"pegadinhas" do exame. Durante a minha preparação sentir falta de um livro 
assim: curto, rápido,objetivo e focado do exame. Como não tinha tive que ir 
trilhando meu caminho. E no final de tudo, surgiu ele. :) 
Então se após o curso ou durante você precisa de um livro que o ajude revisar os 
conceitos chaves para o exame e de quebra as pegadinhas, o Guia do Exame SCJP 
é para você. 
Nota: Apesar do livro levar a sigla SCJP, pois em 2010 quando foi lançado a Oracle 
ainda não tinha comprado a Sun. Mas, eu diria que o conteúdo do livro é válido 
quanto para versão 5 ou 6 da prova. 
Para comprar o livro 30% de desconto, basta ir no site da editora www.lcm.com.br 
e realizar a compra usando o código a seguir V00014. Dúvidas? Só enviar. 
http://www.lcm.com.br/
http://static.imasters.com.br/img/curso/45932.jpg
Fundamentos Java 
 Neste tópico serão tratados os fundamentos Java, que você vai precisar conhecer 
para todo o exame. É um dos tópicos mais importantes, pois os demais assuntos 
dependem daqueles abordados aqui. 
 Alguns assuntos podem ser mostrados de maneira superficial pelo fato de não 
ter chegado o momento de abordá-los. Tudo tem seu tempo exato. 
 
Identificadores e classes 
Este primeiro tópico tratará dos fundamentos básicos da tecnologia Java. Alguns 
tópicos podem ser considerados muito básicos para quem já passou pelo Java 
Básico. Mas é prudente citar e revisar para evitar esquecimentos. 
Identificadores Legais 
Os identificadores legais em Java só podem começar por letra, $ ou _. Qualquer 
outra forma colocada impede a compilação do código. O uso das palavras-chave 
não é permitido. 
Convenção da Oracle 
É apenas uma forma organizada de você desenvolver sua sintaxe, porém nada 
obriga a usar algo diferente. Lembrando que a convenção é a mais utilizada por 
todos os bons programadores Java. 
Veja o seguinte: 
 Constantes: as variáveis declaradas como final, static e do tipo enum devem estar 
em maiúsculo. 
 Variáveis: devem iniciar com letras minúsculas. No caso de nome composto, a 
primeira letra será em maiúsculo. 
 Métodos: a primeira letra deve ser minúscula e seguir o padrão JavaBeans,onde 
este diz que para obter algo de um método você usa get, e para fazer algo 
usamos set 
 Classes/Interface: as primeiras letras devem ser maiúsculas e as demais 
minúsculas. Se formarem um nome composto, o início de cada nome deve ser 
com letra maiúscula. 
Java Bean Nomeação 
A nomeação foi criada para ajudar desenvolvedores a criar componentes Java de 
fácil interpretação para outros programadores. 
 Boolean: is ou get 
 Chamada: set devem usar argumentos ou não e devem retornar um tipo void 
 Obter: get - não pode ter argumentos, deve retornar um tipo e ser um método 
public (set e get) 
Classes 
Uma class declarada como padrão (default) pertence apenas àquele pacote (pasta, 
diretório) onde foi criada. 
Não é possível acessar uma default class de um pacote diferente, mesmo que ele 
tenha um import: 
package p; 
class Ave{} 
package A; 
import p.Ave; 
class Galo extends Ave{} 
O código acima não compila devido ao fato de a class Ave ser padrão daquele 
pacote - ela é dele, e ninguém pode usar. A solução para isso é declarar a class 
Ave como public, assim ela estaria disponível para o mundo, ou seja, para 
qualquer pacote. 
Quando class é public, é possível importá-la para outro pacote diferente. 
package cap1.Fornecedor; 
 
class Dept { 
 
} 
package cap1.Produto; 
import cap1.Fornecedor.Dept; 
public class Prod { 
 public static void main(String[] args) { 
 System.out.println("Produto fornecedor"); 
 }} 
 
Esse código não compila, pois a Class Dept é default, então não pode ser 
importada para outro package, a não ser aquele onde foi declarada. Esse tópico é 
alvo de pegadinha em simulados. 
Class abstract 
As class abstratas nunca podem ser declaradas como FINAL, pois devem ter 
alguém que as estenda. As regras abaixo não podem ser esquecidas: 
 Jamais usar FINAL e ABSTRACT juntos, tanto para classes quanto para método 
abstract. 
 Uma class abstrata pode ter um ou nenhum método abstrato, porém se uma 
class concreta tiver um método abstrato, ela deve ser declarada como abstract. 
 Para clarear o conceito de class abstract: seria aquilo que não é real, como um 
veículo (moto, carro, avião). Por isso não se cria instância new de objetos de uma 
classe abstrata, ou seja, de um veículo. 
 É criada uma instância de uma class quando é algo real, algo concreto em que 
posso tocar, como uma galinha ou um carro. 
abstract class Galinha{ 
 void setIdade(int d); 
http://www.google.com/search?hl=en&q=allinurl%3Astring+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Asystem+java.sun.com&btnI=I%27m%20Feeling%20Lucky
} 
 
package cap1.Carros; 
 
public abstract class Celta { 
 
} 
package cap1.cliente; 
import cap1.Carros.Celta; 
class Cli extends Celta{ 
 public static void main(String args[]){ 
System.out.println("ok"); 
 }} 
 
Observe que importei uma class de outro pacote devido ao modificador public que 
ela possui. 
Isso aqui é uma má implementação, porque estou dizendo que Cli é um Celta, 
mas, no exame, você será testado com nomes estranhos, que não usaria na vida 
real. O objetivo dos examinadores é tentar tirar sua atenção com apenas uma 
nomeação. Se você aluno é “esperto” o suficiente, vai saber que um nome não 
apropriado não quer dizer que a classe não compila. 
Vejamos mais exemplos: 
package cap1.Produto; 
import cap1.Fornecedor.*; 
public class Prod { 
http://www.google.com/search?hl=en&q=allinurl%3Astring+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Asystem+java.sun.com&btnI=I%27m%20Feeling%20Lucky
 public static void main(String[] args) { 
 System.out.println("Produto fornecedor"); 
 }} 
Esse código funciona. Observe que coloquei * (asterisco) na importação da classe. 
Assim estamos dizendo que é para importar todas todas as classes visíveis 
daquele pacote. 
Pegadinha para o exame: 
class Bike{ 
void cor(); 
 } 
 class Boy extends Bike{ 
 void cor(){} 
 public static void main(String ar[]){ 
 new Boy().cor(); 
 } 
 } 
Esse código não compila, pois o método da class Bike não é abstract. O fato de 
colocar ; (ponto e vírgula) não é suficiente para afirmar que um método é abstract. 
 
Interface e modificadores 
de acesso 
Interface 
É apenas um contrato feito entre a class e a interface que ela vai implementar. As 
interfaces servem para o caso seguinte: 
http://www.google.com/search?hl=en&q=allinurl%3Astring+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Asystem+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Astring+java.sun.com&btnI=I%27m%20Feeling%20Lucky
Minha class Ferrari, ou seja meu carro Ferrari, vai ser o único, entre outros 10 
carros de luxo, que vai ter efeitos especiais no painel. 
Então fazemos um contrato com a interface que vai prestar esse serviço à minha 
Ferrari, e a class Ferrari vai cumprir todas as regras da Interface. 
interface Efeitos{ 
 void setPiscar(); 
 void setFarol(); 
} 
class Ferrari implements Efeitos{ 
 void setPiscar(){} //não compila ométodo deve ser declarado como 
public 
 void setFarol(){} 
} 
Uma interface é 100% abstrata e não pode ter, de maneira alguma, o modificador 
FINAL em nenhum dos seus métodos. A diferença entre interfaces e class abstrata 
é que, nas interfaces, não pode haver, em momento algum, um método que não 
seja abstrato. Mas podemos ter variáveis, desde que sejam constantes. 
O que você precisa saber e jamais esquecer: 
 As constantes são public static e final 
 As interfaces são sempre abstract implicitamente 
 A classe que implementa a interface deve declarar explicitamente como public os 
métodos implementados, senão gera o erro de compilação 
 O valor de uma constante, após a definição, não pode ser alterado - é o mesmo 
que se trancar em um quarto e mandar jogar a chave fora 
 Não temos interface com o acesso default. Os métodos de uma interface são: 
public e abstract. E as variáveis: public static e final 
 Interfaces não implementam outras, apenas extendem (extends) à outra interface 
 Interfaces são implementadas por classes 
 A única coisa que interface faz é extender a outra e ser implementada por uma 
class concreta 
 Class abstrata pode passar a implementação de uma interface para a próxima 
class concreta 
Vejamos alguns exemplos: 
package cap1; 
 
public interface Veiculo { 
 int x=10; 
} 
package cap1; 
 
public class Carro implements Veiculo{ 
 public void setNome(String n){ 
 n="celta"; 
 System.out.println(n); 
 } 
 public void setPlaca(int p){ 
 p=2568; 
 System.out.println(p); 
 } 
 public static void main(String[] args) { 
 System.out.println(x);//10 
 new Carro().setNome("celta"); 
http://www.google.com/search?hl=en&q=allinurl%3Astring+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Asystem+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Asystem+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Astring+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Asystem+java.sun.com&btnI=I%27m%20Feeling%20Lucky
 new Carro().setPlaca(25); 
 } 
} 
Observe que implementei os métodos e acessei minha variável x - public static e 
final. 
O código abaixo não compila. Coloquei minha interface com default e tentei 
acessá-la em outro pacote. Veja: 
package cap1.inter; 
 
interface Moda { 
String r = "roupa"; 
} 
package cap1; 
public class Loja implements Moda{ 
 public static void main(String args[]){ 
 System.out.println(r); 
 }} 
Recebemos este erro do compilador: 
Exception in thread "main" java.lang.Error: Unresolved compilation 
problem: 
 cannot be resolved 
Para resolver esse problema, devemos fazer isto: 
package cap1.inter; 
 
public interface Moda { 
String r = "roupa"; 
http://www.google.com/search?hl=en&q=allinurl%3Astring+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Astring+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Asystem+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Aexception+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Aerror+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Astring+java.sun.com&btnI=I%27m%20Feeling%20Lucky
} 
package cap1; 
import cap1.inter.Moda; 
public class Loja implements Moda{ 
 public static void main(String args[]){ 
 System.out.println(r); 
 }} 
Fique atento às regras e saiba como resolver o problema quando encontrar um 
código que não compila. Há questões em que a Sun vai afirmar que não compila, e 
o futuro programador certificado deve saber a solução. 
Como falamos no tópico anterior sobre modificadores de acesso, vamos aproveitar 
e entrar no assunto. 
Modificadores de acesso 
Eles controlam o nível de acesso entre os membros de uma class. Podem ser: 
public, default, private e protect. Importante deixar claro que uma classe só pode 
ser default ou public. 
O importante está no nível da class. Se ela está disponível para outra class 
visualizá-la, então seus membros (métodos e variáveis) estão disponíveis também 
para ela. Claro, apenas os que forem marcados. 
//a class B não tem acesso aos membros da class A, 
// se declaradas em package diferentes 
class A{ 
 public int a=10; 
} 
class B{ 
 A i = new A(); 
 i.a; 
http://www.google.com/search?hl=en&q=allinurl%3Astring+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Asystem+java.sun.com&btnI=I%27m%20Feeling%20Lucky
} 
Observe que as duas têm acesso padrão, mas nenhuma conhece a outra. A nem 
sabe que B existe (lembrando que elas estão em package diferentes). 
No exame pode aparecer uma questão perguntando qual modificador é apropriado 
para que um determinado código compile. Temos as seguintes opções: 
 Quando um membro é declarado com public, todas as classes têm acesso a ele, 
mesmo fora do package (não se esqueça de importar). Lembrando que a class 
deve ser public; caso contrário, nada feito. 
 Os private pertencem àquela mesma classe, ou seja, ninguém poderá ver a não 
ser que seja da class o qual foi declarado. Pense nisso quando vir algo declarado 
em uma class private. 
O capital na sua conta bancária é private, então somente você tem acesso, certo? 
Mas outros membros da classe Banco podem saber o valor na sua conta, como o 
gerente, o sub-gerente, etc. 
class Conta{ 
private double real = 1000.0000.000; 
} 
protected e default: São bastante parecidos e confudem muito na hora do exame. 
 protected: Você pode ter acesso ao membro de uma class mesmo que ela esteja 
fora do pacote atual, através de herança. 
 default: Não é possível ter acesso ao membro de outro pacote. Default = = 
membro é desse pacote e ninguém vai usá-lo, se quiser que entre no pacote. 
Mesmo com uma class public, se o membro for default, ele não pode ser usado em 
outra classe de outros pacotes. 
Para um protected não faz diferença se o membro declarado como protected está 
fora do pacote, pois ele é acessado da mesma forma, através da herança. 
Exemplo: 
package cert; 
public class Ot{ 
protected int x=9; 
 int z = 10; 
} 
 
package oth; 
import cert.*; 
class Her extends Ot{ 
System.out.println(x); 
} 
Lembrando que variáveis de pacotes diferentes (marcadas como protected) não 
são herdadas, mas a subclass visualiza o membro de uma class que está em outro 
pacote. Mas o membro z não é visualizado; na verdade, ele nem existe para class 
Her. 
As variáveis locais não recebem nenhum modificador de acesso além de FINAL. 
Isso acontece porque se elas são locais apenas naquele método ou bloco onde 
foram declaradas, então não faz sentido receberem qualquer outro modificador. 
Um exemplo são as variáveis usadas em uma instrução for. Elas existem enquanto 
o for retorna true. Depois disso elas são destruídas. 
Observe o exemplo abaixo, que as classes estão no mesmo pacote e a variável foi 
“herdada”. 
package cap1; 
 
public class Mem { 
static int a=10; 
} 
package cap1; 
 
public class MemTest extends Mem { 
http://www.google.com/search?hl=en&q=allinurl%3Asystem+java.sun.com&btnI=I%27m%20Feeling%20Lucky
 
 public static void main(String[] args) { 
 System.out.println(a); 
 }} 
Pacotes diferentes, e a variável não foi herdada, porque não está com protected. 
package cap1.Other; 
public class Vava { 
 static int e=20;//sou apenas deste pacote. 
} 
package cap1.inter; 
import cap1.Other.Vava; 
public class Vv extends Vava{ 
 
public static void main(String[] args) { 
 System.out.println(e); 
}} 
O código acima compila? Recomendamos escrever a resposta em um papel e 
depois implementare ver o resultado. 
Analise a situação a seguir: 
package cap1; 
 
 public class Defau { 
static int x = 10; 
} 
http://www.google.com/search?hl=en&q=allinurl%3Astring+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Asystem+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Astring+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Asystem+java.sun.com&btnI=I%27m%20Feeling%20Lucky
/*minha class é public disponivel para todos, porém 
 o membro so pode ser visto nesse pacote*/ 
 
package cap1.Carros; 
import cap1.Defau; 
public class Fau extends Defau{ 
 
 public static void main(String[] args) { 
 System.out.println(x); 
 } 
} 
Exception in thread "main" java.lang.Error: Unresolved compilation 
problem: 
 The field Defaut.x is not visible 
A class é importada porque ela é public, porém não é possível acessar o membro 
de um pacote diferente, somente onde ele foi declarado e por isso que o código 
não compila. 
As variáveis locais não podem ter modificadores de acesso. 
package cap1; 
 
public class VarLoca { 
 
public static void main(String[] args) { 
 private int x=10; 
 public int z=20; 
http://www.google.com/search?hl=en&q=allinurl%3Astring+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Asystem+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Aexception+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Aerror+java.sun.com&btnI=I%27m%20Feeling%20Lucky
 System.out.println(x + z); 
}} 
Não compila: as variáveis locais. Pertencem somente àquele escopo aonde foi 
declarada; então não se pode usar nenhum tipo de modificador de acesso. 
Variável local final 
As variáveis locais somente podem receber um modificador, que é final, pois ele 
não é de acesso, e sim um modificador de classe. 
package cap1; 
 
public class VarComp { 
 
 public static void main(String[] args) { 
 final int x = 10; 
 System.out.println(x); 
 } 
} 
A classe acima compila e imprime o resultado. Por quê? 
Métodos final 
O que for declarado como final é uma constante e não pode ter o valor alterado. 
No caso de métodos, eles não podem ser subscritos em uma subclass. 
package cap1; 
class F{ 
 public final void setF(){System.out.println("final");} 
} 
public class Fin extends F{ 
http://www.google.com/search?hl=en&q=allinurl%3Astring+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Asystem+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Asystem+java.sun.com&btnI=I%27m%20Feeling%20Lucky
 public void setF(){} 
 public static void main(String[] args) { 
 Fin fi = new Fin(); 
 fi.setF(); 
 }} 
Esse código não compila, pois tentou-se subscrever um método final. 
Uma variável declarada como final não pode ter o valor alterado. Veja: 
package cap1; 
public class TentARg { 
public void muda(final int num){ 
 num=50; 
 System.out.println(num); 
} 
public static void main(String[] args) { 
 new TentARg().muda(22); 
 } 
} 
Esse código não compila, pois a variável no argumento do método não pode ser 
alterada por ter sido declarada com o modificador final. 
Métodos abstract 
São métodos que foram declarados, mas que não possuem implementações. 
 Devem ser implementados pela primeira class concreta que extends a class 
abstract do método 
 Devem existir em uma class abstract 
 São subscritos e não sobrecarregados 
http://www.google.com/search?hl=en&q=allinurl%3Astring+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Asystem+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Astring+java.sun.com&btnI=I%27m%20Feeling%20Lucky
 Uma class abstract pode ter um ou nenhum método abstrato 
 Se a class tiver pelo menos 1 método abstrato, é obrigatório ela ser abstract 
package cap1; 
 
public abstract class Abt { 
public void noAbt(){} 
 public static void main(String[] args) { 
 
 }} 
O código acima compila normalmente. É uma class abstract, porém sem nenhum 
método, e não há problema nenhum aqui. 
package cap1; 
public class Noabt { 
public abstract void chama(); 
 public static void main(String[] args) { 
 
 }} 
Já esse código não compila, pois não pode existir método abstract em uma class 
concreta. 
Abstract X Static 
Método abstratos não podem ser static. Essa é a regra. 
package cap1; 
 
public abstract class StaticAbt { 
abstract static void setA(); 
http://www.google.com/search?hl=en&q=allinurl%3Astring+java.sun.com&btnI=I%27m%20Feeling%20Lucky
 public static void main(String[] args) { 
 
 } 
} 
O código acima não compila. 
Abstract somente para métodos e class - nada de usá-lo em variáveis. O código 
abaixo não compila. 
package cap1; 
 
public class Varabt { 
abstract String s = "camilo"; 
 public static void main(String[] args) { 
 
 }} 
Outros modificadores que você precisa saber onde usar, exceto o synchronized, 
que vamos usar na aula sobre Threads: 
 Métodos synchronized - são usados para sincronização de métodos e bloco de 
códigos. 
 Métodos nativos - são usados apenas para métodos. Lembrando que se trata de 
um modificador. 
 Métodos strictfp - forçam os pontos flutuantes no padrão IEEE 754. Esse 
modificador é usado em classes e em métodos. 
 
Construtores e variáveis 
Construtores 
http://www.google.com/search?hl=en&q=allinurl%3Astring+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Astring+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Astring+java.sun.com&btnI=I%27m%20Feeling%20Lucky
Os construtores são sempre chamados quando um objeto é construído. Eles não 
possuem nenhum tipo de retorno e devem ter o mesmo nome da class. 
Regras que precisam ser conhecidas: 
 Não podem ser marcados como static, final ou abstract. 
 Podem receber um modificador de acesso como protected. 
Analisando o código abaixo: 
class C{ 
 
 C(String s){} 
} 
class D extends C{ 
 public static void main(){} 
} 
O código acima não compila, pois o compilador chama super() implicitamente, 
porém ela não encontra o construtor da super sem argumentos. 
Mais alguns exemplos: 
class C{ 
 
 C(String s){} 
} 
class D extends C{ 
 public static void main(){ 
 D(){ 
 super("S"); 
 }}} 
http://www.google.com/search?hl=en&q=allinurl%3Astring+java.sun.com&btnI=I%27m%20Feeling%20Lucky
Não compila, pois o construtor está sendo chamado dentro do método. 
A classe a seguir compila, já que temos um construtor válido na super classe: 
class C{ 
 
 C(String s){} 
} 
class D extends C{ 
 D(){ 
 super("S"); 
 } 
 public static void main(){ 
 
 }} 
Variáveis 
 Primitivas: são as tradicionais, como int, float, double, etc. Uma vez declarado 
seu tipo, jamais pode ser modificado. 
 Variáveis de referência: são usadas para se referirem a um objeto e seu tipo 
nunca pode ser modificado. Lembrando que podem se referir a um objeto que 
passa no teste É-um. Exemplo: Cachorro extends Animal{} posso referenciar 
minha variável de referência para Cachorro e para Animal já que cachorro passa 
no teste É-UM. 
Class Animal{} 
Class Cachorro extends Animal{} 
Animal s = new Cachorro(); 
// minha variavel de referencia s, É-UM objeto cachorro do tipo Animal. 
http://www.google.com/search?hl=en&q=allinurl%3Astring+java.sun.com&btnI=I%27m%20Feeling%20Lucky
Não se preocupe, se não entendeu o código acima, ainda vamos explicar esse tipo 
de relacionamento nas próximas aulas. 
 Variáveis de instância: Elas estão dentrode uma class, porém fora de qualquer 
método e são inicializadas com o valor padrão. 
 Arrays: São nada mais que objetos de um tipo que armazena elementos de um 
determinado tipo, mas no fundo sempre são objetos. 
//instancie meu array que vai receber elemento do tipo int 
int array[] = new int[3]; 
int []outro;//aqui é declaração e não cria o array propriamente dito. 
 Variáveis transient: a variável é ignorada para serialização do objeto. Transient = 
= ignore essa variável. Somente aplicadas a variáveis de instância. 
 Variáveis volatile: aplicadas também somente a variáveis de instância. 
Métodos e variáveis static 
São usados quando se criam variáveis para serem usadas independentemente de 
se ter uma instância dessa class. 
Var-args 
Permite receber inúmeros valores via parâmetro de um tipo declarado. 
void x(int...g){} 
//Posso receber inúmeros parâmetros do tipo int 
Argumento: é aquilo que é passado explicitamente: void setI(10) 
Parâmetro: passo o tipo do que pode receber: void setD(int a) 
Na lista de parâmetros, o var-args deve estar sempre por último. 
Enum 
É um tipo especial de class. O que você precisa saber sobre enum: 
 Os membros de uma enum são constantes 
 Pode ser declarado tanto fora quanto dentro da class 
 Não é valido declarar uma enum dentro de um método 
 As enums são static e final 
Veja algumas implementações com enum: 
enum Coffe{BIG,HUGE} 
class Cafe{ 
 public static void main(String args[]){ 
 Coffe c = Coffe.BIG; //a forma de declaracao é crucial 
 System.out.println(c); 
 }} 
Não existe o new na instanciação da variável enum 
class EnuClass{ 
 enum Tam{M(10),P(20),G(30); 
 Tam(int a){ 
 tam=a; 
 }//fim do construtor 
private int tam; 
 public int getTam(){ 
 return tam; 
 } 
}//fim da class especial do tipo enum 
 public static void main(String args[]){ 
 Tam t = Tam.P; 
 System.out.println(t+" "+t.getTam());//exibe P 20 
 }} 
http://www.google.com/search?hl=en&q=allinurl%3Astring+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Asystem+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Astring+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Asystem+java.sun.com&btnI=I%27m%20Feeling%20Lucky
Código enum um pouco mais complexo: 
import java.util.Scanner; 
class ModaLoja{ 
enum idade{INFANTIL(1),ADULTO(2),JOVEM(3); 
 idade(int a){ 
 cod=a; 
 } 
 private int cod; 
 public int getSec(){ 
 return cod; 
 }} 
public static void main(String args[]){ 
 Scanner dados = new Scanner(System.in); 
 idade id= idade.ADULTO; 
System.out.println("Escolha a secao 1 - INFANTIL 2 -ADULTO 3 - JOVEM"); 
 int sec = dados.nextInt(); 
 if(sec==id.getSec()){//se for 2 
System.out.println("Voce esta na secao de " + idade.ADULTO); 
 }}}/* bem complexo esse, mas bem interessante*/ 
Algumas questões sobre enum são teóricas e envolvem códigos longos. Então, 
esteja certo de que consegue entender o código acima. 
Recomendamos implementar o código acima. Assim, poderá compreender melhor 
como enum funciona. 
http://www.google.com/search?hl=en&q=allinurl%3Astring+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Asystem+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Asystem+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Asystem+java.sun.com&btnI=I%27m%20Feeling%20Lucky
Acreditamos que esse foi um dos maiores tópicos, pois não poderíamos deixar 
nada passar, já que "fundamentos Java" é a base para que você possa dominar 
qualquer outro assunto com fluência. 
 
Orientação a Objetos 
Herança 
A herança acontece quando usamos a palavra-chave extends ou a implements. 
Abaixo algumas informações que você precisa saber sobre herança: 
 promove a reutilização de códigos 
 permite o uso de polimorfismo 
 códigos mais claros 
 previne a duplicação do código 
Por exemplo: em alguns programas, para realizar a modificação em um lugar, 
seria necessário rastrear os outros pontos para alterar também. Com herança isso 
é quebrado. 
Toda subclasse(+ especializada) herda os métodos da superclass. 
Codificando para aprender: 
class Game{ 
public void inicio(){ 
 System.out.println("comecou o jogo"); 
 }} 
class Mortal extends Game{ 
public void sub(){ 
 System.out.println("jogo mortal"); 
 }} 
http://www.google.com/search?hl=en&q=allinurl%3Asystem+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Asystem+java.sun.com&btnI=I%27m%20Feeling%20Lucky
class GameTest{ 
 public static void main(String args[]){ 
 Mortal jogador = new Mortal(); 
 jogador.inicio(); 
 jogador.sub(); 
 }} 
São impressos os dois métodos, porém o ponto-chave aqui é que a subclasse 
herdou o método da superclasse implicitamente. 
Relacionamento É-UM 
Conceito baseado na herança de classes ou na implementação de interfaces. 
Exemplo: carro É UM veículo (carro é um tipo de veículo). 
Ferrari É UM carro (Ferrari é um tipo de carro). 
No conceito de herança, sempre vamos usar o relacionamento É-UM. Na sintaxe 
que vimos anteriormente, vimos que a class Mortal É-UM jogo da class mãe Game. 
class Fami{ 
 public void setF(){System.out.println("Minha familia ");} 
 public static void main (String adas[]){ 
 Tio t = new Tio(); 
 t.setF(); 
 }} 
class Sob extends Fami{} 
class Tio extends Sob{/*ele herda tb os métodos da super da super*/} 
Exceções: 
 Private: pertence à classe. 
 Final: quer dizer que não pode ser subcrito, porém é herdado. 
http://www.google.com/search?hl=en&q=allinurl%3Astring+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Asystem+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Astring+java.sun.com&btnI=I%27m%20Feeling%20Lucky
 Static: não são herdados,porém estão visíveis para subclass. 
Polimorfismo – “muitas formas” 
É quando uma mesma mensagem é enviada para um ou vários objetos, porém os 
resultados são diferentes. 
Sabemos que todos os animais correm, porém cada um de uma maneira diferente. 
Essa é uma forma de fazer uma analogia e tornar a compreensão do conceito mais 
fácil. 
Polimorfismo X Interface 
Interface – não faz parte da hierarquia de classe, ou seja, uma class não pode 
extends a uma interface, mas pode implementá-la. 
Polimorfismo - faz parte da hierarquia de classe. Uma classe pode herdar atributos 
da classe mãe e pode implementar os métodos (marcados como abstract). 
class Fabrica { 
 public void setF() { 
 System.out.println("Fabrica"); 
 } 
 
 public static void setFa(){ 
 System.out.println("fabrica static"); 
 } 
} 
 
class Pc extends Fabrica { 
 public static void setFa() { 
 System.out.println("fabrica static sub"); 
http://www.google.com/search?hl=en&q=allinurl%3Asystem+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Asystem+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Asystem+java.sun.com&btnI=I%27m%20Feeling%20Lucky
 } 
 
 public static void main(String args[]){ 
 Fabrica f = new Pc(); 
 f.setFa(); 
 } 
} 
Observe que métodos static não são herdados. 
Métodos subscritos 
Motivo: definir um comportamento específico para determinado tipo de subclasse. 
Os métodos abstratos são os mesmos métodos subscritos, porém nunca 
sobrecarregados. 
Só é possível referenciar a objetos do tipo que a super classe conheça. 
Exemplo: 
class Animal{ 
 public void eat(){ 
 System.out.println("class generic"); 
 } 
} 
 
public class Cavalo extends Animal{ 
 public void eat(){System.out.println("raça mangalarga"); 
 } 
http://www.google.com/search?hl=en&q=allinurl%3Astring+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Asystem+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Asystem+java.sun.com&btnI=I%27m%20Feeling%20Lucky
 } 
 
 class AnimalTest{ 
 public static void main(String args[]){ 
 Animal a = new Animal(); 
 Animal b = new Cavalo(); 
 a.eat();//class generic 
 b.eat();//raça mangalarga 
 } } 
O código acima imprime os dois métodos, porém, primeiro, ele imprime um que é 
do tipo animal, que é um objeto da classe animal. O segundo é do tipo animal, 
porém é um objeto da classe Cavalo. 
O segundo método é executado, e estamos dizendo também que a class Cavalo É-
UM Animal, ou seja, ela recebe todas as características da classe Animal. 
No código abaixo, temos um trecho que foi comentado. Caso esse comentário 
fosse removido teríamos problemas na compilação, pois foi definido um método 
do tipo Animal, sendo que a class não possui esse método. Veja: 
public class Animal 
{ 
 public void printYour(){ 
 System.out.println("chamei a super class"); 
 }} 
class Horse extends Animal{ 
 public void printYour(){ 
 super.printYour();// chama a superclass 
 } 
http://www.google.com/search?hl=en&q=allinurl%3Astring+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Asystem+java.sun.com&btnI=I%27m%20Feeling%20Lucky
 public void buck(){} 
 
} 
 
public class TestAnimal 
{ 
 public static void main(String args[]){ 
 
 Animal a = new Animal(); 
 Animal b = new Horse();//referencia animal, mais é um objeto horse 
 
 Animal c = new Horse(); 
 
 
 a.eat();//chamo o método da classe referente 
 b.eat(); 
//dar erro porque a class animal não tem o método buck e sim a class 
horse. 
//c é um objeto horse mais não referente a classe animal. 
 
 //c.buck(); // esse método não temos no tipo da class animal 
 } 
} 
Recomendamos analisar com atenção esse código. 
http://www.google.com/search?hl=en&q=allinurl%3Astring+java.sun.com&btnI=I%27m%20Feeling%20Lucky
Regras que você precisa saber: 
 O novo método (nível de acesso) pode ser alterado desde que seja menos 
restritivo do que substituto 
 Não é possível trocar um public para umprotected, porém o inverso é permitido 
(protected public) 
 O tipo de retorno dever ser o mesmo; 
 A lista de argumentos deve ser igual à do método subscrito, senão gera uma 
sobrecarga 
 Métodos estáticos não podem ser subscritos, mas são redefinidos em tempo de 
execução. Chamando de método da superclasse. 
 Super() é uma referência à superclasse; 
 O método subscrito pode ou não lançar uma exceção menos restrita que a da 
superclasse. 
O código a seguir não compila o método subcrito, ele está lançando uma nova 
Exceção 
mais abragente. Implicitamente, o método da super lança uma exceção não 
verificada - RuntimeException 
class DuvS{ 
 public static void main(String args[]){ 
 aviao b = new boing(); 
 b.gol(); 
 }} 
//super 
class aviao{ 
 void gol(){ 
 System.out.println("gol");} 
} 
http://www.google.com/search?hl=en&q=allinurl%3Astring+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Asystem+java.sun.com&btnI=I%27m%20Feeling%20Lucky
//subclass 
class boing extends aviao{ 
 void gol() throws Exception{} 
} 
Não se preocupe, se você não sabe nada sobre exceções. Explicarei mais na frente. 
Para static isso também é válido, veja: o código abaixo também não compila. 
class DuvS{ 
 public static void main(String args[]){ 
 aviao b = new boing(); 
 b.gol(); 
 }} 
 
class aviao{ 
 static void gol(){ 
 System.out.println("gol");} 
} 
class boing extends aviao{ 
 static void gol() throws Exception{} 
} 
 
Sobrecarga e conversão 
Métodos sobrecarregados 
http://www.google.com/search?hl=en&q=allinurl%3Aexception+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Astring+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Asystem+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Aexception+java.sun.com&btnI=I%27m%20Feeling%20Lucky
Possibilitam usar o nome de um método em uma classe várias vezes, porém com 
argumentos diferentes. 
Exemplo: posso ter dois arquivos com mesmo nome, porém de tipos diferentes em 
formato. (.doc, .txt, .pdf). 
Os métodos sobrecarregados podem: 
 alterar o tipo de retorno 
 alterar o modificador de acesso (private, protected) 
 ser sobrecarregado na mesma classe ou subclasse 
O tipo a que o objeto é referenciado determina qual método será sobrecarregado. 
Animal cavalo = new horse(); 
// objeto horse, mas uma referencia a class animal. 
O subscrito é o tipo de objeto que chama o método subscrito. 
class TV{ 
 public void setMs(TV t){System.out.println("TV");} 
} 
class Us extends TV{ 
 //realizando sobrecarga 
public void setMs(Us u) 
{System.out.println("usuario tv sobrecarregado");} 
} 
class LojaTv{ 
 public static void main(String args[]){ 
 TV t = new TV(); 
 t.setMs(t); 
 
http://www.google.com/search?hl=en&q=allinurl%3Asystem+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Asystem+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Astring+java.sun.com&btnI=I%27m%20Feeling%20Lucky
 TV t1 = new Us(); 
 t1.setMs(t1); 
//ele chama TV 
 //na sobrecarga o que vale é o tipo e não objeto criado do 
 //tipo Us 
 }} 
Para chamar a versão sobrecarregada, é preciso criar uma variável de referência do 
tipo Us. 
Outro exemplo que pode confundir: 
class Teclado{ 
public void cor(){System.out.println("preto - teclado");} 
public void cor(String a){System.out.println("teclado " + a);} 
public static void main(String args[]){ 
Teclado t = new Teclado(); 
t.cor(); 
Teclado c = new Mouse(); 
c.cor(); 
//apesar de ter ocorrido uma sobrecarga ele chama o do 
//objeto ja que o método sobrecarregado foi ?subscrito? na 
//super class 
Teclado cc = new Mouse(); 
cc.cor("Verde"); 
}} 
 
http://www.google.com/search?hl=en&q=allinurl%3Asystem+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Astring+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Asystem+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Astring+java.sun.com&btnI=I%27m%20Feeling%20Lucky
class Mouse extends Teclado{ 
public void cor(){System.out.println("Azul - mouse");} 
public void cor(String a){System.out.println("mouse "+ a);} 
} 
Entendendo o código acima: 
- ele herda tudo da superclass 
 
- método cor sobrecarregado na superclass 
 
- método cor subcrito na subclass 
Mais um código para análise: 
package cap1; 
public class Shop { 
public void setInfo(){System.out.println("Secao de infomatica");} 
public void setInfo(String secao){System.out.println("Secao " +secao);} 
 
 public static void main(String[] args) { 
 Shop s = new Shop(); 
 s.setInfo(); 
 s.setInfo("Eletronicos"); 
 Shop sp = new CliInfo(); 
 sp.setInfo("Roupa"); 
 }} 
class CliInfo extends Shop{ 
public void setInfo(){System.out.println("cliente esta subscrito");} 
 public void setInfo(String s){System.out.println("novo met " + s);} 
http://www.google.com/search?hl=en&q=allinurl%3Asystem+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Astring+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Asystem+java.sun.com&btnI=I%27m%20Feeling%20Luckyhttp://www.google.com/search?hl=en&q=allinurl%3Asystem+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Astring+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Asystem+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Astring+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Asystem+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Astring+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Asystem+java.sun.com&btnI=I%27m%20Feeling%20Lucky
} 
 
Observe que alterei o nome da variável do objeto e não houve problema. Isso é 
válido, mas não podemos alterar o tipo, senão é uma sobrecarga. 
Conversão de variáveis de referência 
A melhor forma para explicar esse assunto é através de códigos e de blocos de 
comentários em cada um. Então, espere encontrar o uso de conversão de variáveis 
de referência dentro de códigos Java. 
O conceito básico aqui é o relacionamento É-UM. Usamos a conversão quando 
queremos fazer um cast para ter acesso mais específico à classe. 
class Faunabr{} 
class Gira extends Faunabr{} 
class FaunaTest{ 
 public static void main(String args[]){ 
 Faunabr fb = new Faunabr(); 
 Faunabr f = (Gira)fb; 
 }} 
 
Esse código compila, mas lança uma exceção. Compila, porque temos classes na 
mesma árvore de herança (relacionamento É-UM). Mas não posso dizer que uma 
fauna é um Gira (podemos chamar de girafa). 
Mais um exemplo para esclarecer: 
class Pais{} 
class Brasil extends Pais{} 
class PaisT{ 
 public static void main(String args[]){ 
http://www.google.com/search?hl=en&q=allinurl%3Astring+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Astring+java.sun.com&btnI=I%27m%20Feeling%20Lucky
 Pais pb = new Brasil(); 
 Pais p = (Brasil)pb; 
 //isso compila ja que pb é um objeto Brasil 
 }} 
Lembre-se de que o que pode ser alterado é o objeto, e não o tipo dele. Já que pb 
é o tipo País e referencia a um objeto Brasil. Posso converter explicitamente pb 
para Brasil. 
Não compila se o tipo não fizer parte da árvore de herança. E lança uma exceção 
quando tento converter algo impossível. Ex: País em Brasil. 
Pais pb = new Pais(); 
Pais p = (Brasil)pb; 
Compila porque os tipos na árvore de herança, mas na hora da conversão, a JVM 
não consegue converter os tipos e lança uma exceção ClassCastException. 
Exemplos 
Código que não compila e lança exceções: 
public class Cidade { 
 public void setName(){System.out.println("Cidade ");} 
 
public static void main(String[] args) { 
Cidade cd = new Cidade(); 
 cd.setName(); //isso compila normal 
 Cidade cd1 = (Valenca)cd; 
//compila porém é lançada uma exceção 
/*uma cidade não pode ser Valenca,lembrar que não posso 
 alterar o tipo de referencia*/ 
http://www.google.com/search?hl=en&q=allinurl%3Asystem+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Astring+java.sun.com&btnI=I%27m%20Feeling%20Lucky
cd1.setName(); } 
//o fato de compilar é que faz parte da mesma arvore de herança 
} 
class Valenca extends Cidade{ 
public void setIdade(){ 
System.out.println("Mais de 450 anos");} 
 public void setName(){System.out.println("Cidade Valenca");}} 
public class Cidade2 { 
 public void setName(){System.out.println("Cidade ");} 
 
 public static void main(String[] args) { 
 Cidade2 cd = new Cidade2(); 
 Cidade2 cd2 = (Feira)cd; 
/*compilar vai... ja que Feira, e Cidade2 estão 
na mesma arvore de herança porém uma exceção 
é lançada em tempo de execucao não posso 
converter uma Cidade em Feira*/ 
}} 
class Feira extends Cidade2{ 
public void setIdade(){ 
 System.out.println("Mais de 450 anos");} 
 public void setName(){System.out.println("Cidade Feira");}} 
Esse código lança Exception in thread "main" java.lang.ClassCastException 
 
http://www.google.com/search?hl=en&q=allinurl%3Asystem+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Asystem+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Asystem+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Astring+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Asystem+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Asystem+java.sun.com&btnI=I%27m%20Feeling%20Lucky
Interface e tipos de 
retorno 
Interface 
 Fazemos um contrato com a JVM para que todos os métodos válidos definidos na 
interface devam ser implementados 
 Fornecer implementação concreta para todos métodos da interface marcados 
como abstract 
 Seguir as regras de sobrecarga 
 Manter assinatura e o mesmo tipo de retorno (regra de subscrito) 
Se a classe que implementa for abstrata, ela não tem obrigação de implementar 
todos os métodos da interface. 
Exemplo: leve em conta que após implements sejam interfaces. 
class venda implements Loja, comissão{} 
Lembre-se sempre disso: 
 Uma interface jamais vai implementar outra 
 Uma interface jamais vai implementar uma class 
 Interface não extends a class 
Exemplo prático de uso: 
interface empregado{ 
 public void setNome(); 
 public String getNome(); 
 } 
abstract class Venda implements empregado{ 
string nome; 
 public void setNome(){ 
http://www.google.com/search?hl=en&q=allinurl%3Astring+java.sun.com&btnI=I%27m%20Feeling%20Lucky
 nome = "camilo";}} 
interface coca{ 
 void setN(); 
} 
interface fanta{ 
 void setN(); 
} 
class Clic implements coca,fanta{ 
 public void setN(){System.out.println("Fanta");} 
 public void setN(){System.out.println("Conta");} 
 public static void main(String args[]){ 
}} 
 
Isso não compila, devido ao fato de as duas interfaces terem métodos iguais, e 
quando a class Clic herda apenas uma, já não podemos ter dois métodos iguais 
na mesma class. 
As interfaces não possuem construtores por não fazerem parte das árvores de 
herança de classes. 
Tipos de retorno 
Quando alteramos uma lista de argumentos de um método estamos 
sobrecarregando, portanto o tipo de retorno é valido, mas não com a super classe. 
 Array é um tipo valido de retorno, veja: 
public String []go(){ 
return new String[]{?Camilo?,?lu?}; 
} 
http://www.google.com/search?hl=en&q=allinurl%3Asystem+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Asystem+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Astring+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Astring+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Astring+java.sun.com&btnI=I%27m%20Feeling%20Lucky
 void: não pode retornar nenhum tipo de retorno 
 Retorno a objetos: em um método que tenha um tipo de retorno, a referência a 
um objeto pode retornar qualquer tipo de objeto 
public Animal getAnimal(){ 
return new horse(); // desde que horse extends a Animal. 
Perceba a diferença nos próximos códigos abaixo: 
O primeiro não compila, porque não posso dizer que short É-UM int, ele pode ser 
convertido implicitamente para um int. 
Agora nós podemos dizer que uma subclass É-UM subtipo da superclass. A sacada 
no tipo de retorno funciona para objetos do método, porém, para primitivos, 
apenas no return. 
class VarRetur{ 
 int inte(){ 
 return (short)127; 
 }} 
class vvv extends VarRetur{ 
 short inte(){ 
 return 7; 
 }} 
/* não compila isso short não É-UM int, é apenas convertido*/ 
//aqui compila tranqüilo... 
class VarRetur{ 
VarRetur inte(){ 
return newVarRetur(); 
 }} 
class vvv extends VarRetur{ 
 vvv inte(){ 
return new vvv();}} 
Construtores 
Servem para inicializar o estado das variáveis de instância. Toda class possui um 
construtor. Os construtores podem usar qualquer modificador de acesso, até o 
private . 
Nos construtores privados (private), somente os códigos dessa class podem 
utilizá-lo. 
class PrivateConst{ 
 private PrivateConst(){ } 
} 
class PvtC extends PrivateConst{ 
 PvtC(){} 
} 
Não compila, pois a subclasse está chamando implicitamente(super()) 
um construtor que ela não deveria nem conhecer, por ser private. 
Construtores sobrecarregados 
Construtores são chamados apenas por outros construtores, jamais por um 
método. 
Lembre-se: eles não são herdados por uma subclasse. 
Servem para fornecer alternativas do estado inicial e uma variável de instância. 
Por exemplo: o cliente pode fornecer o nome do cachorro ou o programa pode 
sugerir um. Isso acontece muito quando vamos criar um e-mail e no ato do 
cadastro, o sistema oferece uma sugestão para e-mail. 
Alguns códigos: 
class Cotr{ 
 Cotr(){ 
 } 
} 
class Cot extends Cotr{ 
 Cot(int z){} 
} 
/*implicitamente super() - código compila normalmente*/ 
Já o código abaixo não está tão feliz... 
class Cotr{ 
 Cotr(int z){ 
 } 
} 
class Cot extends Cotr{ 
 Cot(int z){} 
} 
Há uma chamada implícita super(), mas a superclass não tem nenhum construtor 
sem argumento. Esse código não compila. 
Estáticos - static 
Já falamos sobre static no início do curso, mas apenas superficialmente, como um 
comentário. Agora, entraremos nos detalhes. 
Garante que somente haverá uma referência a determinada variável na memória. 
Static não quer dizer que a variável, ou o método, não pode ter seu valor alterado 
(no caso como final). 
O static permite acessar algo diretamente, sem a necessidade de instanciar um 
objeto. 
Quando os métodos ou variáveis não são static, é necessário criar objetos da 
classe, ou seja, instanciar (usar o new). 
Exemplo: criando uma instância. 
 Empresa funcionário = new Empresa(); 
// criei um objeto funcionário da classe empresa. 
Exemplo 2: 
class Hip{ 
 static void doSt(){System.out.println("a");}} 
class Jaca extends Hip{ 
 static void doSt(){System.out.println("b");} 
 public static void main(String arg[]){ 
 Jaca.doSt(); 
 Hip j = new Jaca(); //é chamado da superclass 
j.doSt();}} 
Os métodos static não são subscritos, eles são redefinidos. 
Coesão e Acomplamento 
A coesão acontece quando temos uma classe bem definida e focada. Ou seja, 
quando uma classe tem um único objetivo e uma única função, e não uma 
multitarefa. 
Desejável: alta coesão. 
public class RelatorioEstoque { 
 public void dataEntrada(){} 
 public void DtSaida(){} 
 /* aqui temos a alta coesao 
 * onde a class é bem focada 
 * em seu objetivo de relatorio de 
 * estoque 
 */} 
http://www.google.com/search?hl=en&q=allinurl%3Asystem+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Asystem+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Astring+java.sun.com&btnI=I%27m%20Feeling%20Lucky
Indesejável: baixa coesão – quando a class é multitarefa. 
public class CadCliente { 
 
 public void cadCliente(){} 
 public void relatorioCliente(){} 
 public void vendasClente(){} 
 /* aqui temos a baixa coesao, observe que 
 * a class faz varias tarefas onde quebra 
 * a ideia de reutilização e flexibilidade 
 */} 
Acomplamento: é a relação entre as APIs das classes. 
Desejável: baixo acomplamento – quando a alteração em uma API não afeta erros 
em outra API. 
public class BaixoAc { 
private static Acp ac; 
public static void main(String args[]){ 
ac.met(); 
}} 
/* observe que aqui eu acesso 
 * um método de uma class realizo alteracao 
 * porém nada sei sobre api da class ap 
 * so conheço os métodos disponiveis 
 */ 
class Acp{ 
http://www.google.com/search?hl=en&q=allinurl%3Astring+java.sun.com&btnI=I%27m%20Feeling%20Lucky
 
public void met(){}} 
Indesejável: alto acoplamento – quando uma classe conhece demais sobre a API da 
outra classe. 
public class AltoAcom { 
 atcom at; 
 public void met(){ 
 at.a=8;} 
} 
/* observe que minha class AltoAcom sabe demais sobre minha class atcom */ 
class atcom{ 
 int a=10; 
 public void ss(){} 
} 
Eu desejo a alta coesão e o baixo acomplamento. 
Não se esqueça de que Orientação à Objetos estará em mais que 50% das questões 
do exame real. 
 
Exercício 1 
Neste tópico, você vai encontrar alguns exercícios para poder exercitar seu 
conhecimento. Para dificultar um pouco, as questões não serão de múltipla 
escolha como no exame. Você deve ser capaz de olhar o código e saber a 
resposta. 
Não queira passar por cima dos exercícios, tentado responder qualquer coisa. 
Analise com cuidado, veja os detalhes e anote a resposta. 
Antes de ver a resposta, revise todas as questões e esteja certo da sua resposta 
anterior. É válido, neste exercício, fazer uma revisão nos assuntos já vistos, porém 
tente não ver a resposta logo após a primeira tentativa. 
Não se preocupe, se neste momento, demorar muito para responder. Agora é o 
momento de aprender e saber o porque das coisas. Guarde as energias de 
cronometrar o tempo de resposta para cada questão, nos simulados. 
Qual o resultado de cada questão abaixo? 
Questão 1 
package p; 
class Ave{} 
package A; 
import p.Ave; 
class Galo extends Ave{} 
Questão 2 
package cap1.Fornecedor; 
class Dept {} 
package cap1.Produto; 
import cap1.Fornecedor.Dept; 
public class Prod { 
 public static void main(String[] args) { 
 System.out.println("Produto fornecedor"); 
 }} 
Questão 3 
package cap1.y; 
http://www.google.com/search?hl=en&q=allinurl%3Astring+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Asystem+java.sun.com&btnI=I%27m%20Feeling%20Lucky
private class Priv { 
 public static void main(String[] args) { 
 
 }} 
Questão 4 
package cap1.x; 
 
public final class Pai { 
 
} 
class filho extends Pai{} 
Questão 5 
package cap1.x; 
public abstract class Notcomp { 
 void setName(); 
 public static void main(String[] args) { 
 
 System.out.println("zomm"); }} 
Questão 6 
package cap1.x; 
 
public abstract class Problem { 
private abstract void setNN(); 
http://www.google.com/search?hl=en&q=allinurl%3Astring+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Astring+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Asystem+java.sun.com&btnI=I%27m%20Feeling%20Lucky
Questão 7 
package cap1.x; 
abstract class ProFin { 
 
final abstract void setnn(); 
 public static void main(String[] args) { 
 
 }} 
Questão 8 
package cap1.y; 
 
public interface Dados { 
int z =10; 
void num(); 
} 
 
package cap1.y; 
 
class joga implements Dados { 
 public void num() { } 
 
 public static void main(String[] args) { 
 System.out.println(z); 
http://www.google.com/search?hl=en&q=allinurl%3Astring+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Astring+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Asystem+java.sun.com&btnI=I%27m%20Feeling%20Lucky
 }} 
Questão 9 
interface Corp { 
void seta(){} 
 
Respostas do Exercício 1 
Aqui você encontrará as respostas do exercício anterior. Algumas respostas 
estarão dentro dos comentários. 
Questão 1 
package p; 
class Ave{} 
package A; 
import p.Ave; 
class Galo extends Ave{} 
Esse código não compila devido ao fato de a class Ave ser padrão daquele pacote. 
Questão 2 
package cap1.Fornecedor; 
class Dept {} 
package cap1.Produto; 
import cap1.Fornecedor.Dept; 
publicclass Prod { 
 public static void main(String[] args) { 
 System.out.println("Produto fornecedor"); 
http://www.google.com/search?hl=en&q=allinurl%3Astring+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Asystem+java.sun.com&btnI=I%27m%20Feeling%20Lucky
 }} 
Esse código não compila pois a Class Dept é default, portanto não pode ser 
importada para outro package, a não ser para aquele onde foi declarada. Os 
simulados estão cheios de "pegadinhas" desse tipo. 
Questão 3 
package cap1.y; 
private class Priv { 
 public static void main(String[] args) { 
 
 }} 
Exception in thread "main" java.lang.Error: Unresolved compilation 
problem: 
 
 at cap1.y.Priv.main(Priv.java:3) 
É valido usar private para classes. Por isso não compila. 
Questão 4 
package cap1.x; 
 
public final class Pai { 
 
} 
class filho extends Pai{} 
 
/* isso não compila a class Pai não pode ter filho questão de genetica 
http://www.google.com/search?hl=en&q=allinurl%3Astring+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Aexception+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Aerror+java.sun.com&btnI=I%27m%20Feeling%20Lucky
 */ 
Questão 5 
package cap1.x; 
public abstract class Notcomp { 
 void setName(); // não compila o modificador abstract não tem 
 public static void main(String[] args) { 
 /* não posso ter instancia de classes abstract */ 
 Notcomp nt = new Notcomp(); 
 System.out.println("zomm"); }} 
Questão 6 
package cap1.x; 
 
public abstract class Problem { 
private abstract void setNN(); 
/* código não compila abstract and private jamais abstract e final também 
não 
 */ 
} 
Questão 7 
package cap1.x; 
abstract class ProFin { 
 /* também não compila 
 * 
http://www.google.com/search?hl=en&q=allinurl%3Astring+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Asystem+java.sun.com&btnI=I%27m%20Feeling%20Lucky
 */ 
final abstract void setnn(); 
 public static void main(String[] args) { 
}} 
Questão 8 
package cap1.y; 
 
public interface Dados { 
int z =10; 
void num(); 
} 
 
package cap1.y; 
 
class joga implements Dados { 
/* código compila normal implementei meu método 
 * e imprimir o valor da interface 
 */ 
 public void num() { } //método implementado 
 
 public static void main(String[] args) { 
 System.out.println(z); 
 }} 
http://www.google.com/search?hl=en&q=allinurl%3Astring+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Astring+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Asystem+java.sun.com&btnI=I%27m%20Feeling%20Lucky
Questão 9 
interface Corp { 
void seta(){} 
/* não posso ter métodos com chaves em uma interface 
 * pois os métodos sao implicitamente abstract aqui 
 */} 
 
Atributos 
Conversão de tipos primitivos 
A conversão permite a transformação de valores primitivos de um tipo para outro, 
de modo explícito ou implícito. 
 Explicito: é necessário que o programador informe ao compilador 
 Implícito: você não precisa informar nada ao compilador 
Ex.: posso converter um int em long pois potencialmente long aceita um int, mas 
o inverso deve ser feito de forma explícita (cast). 
Você pode colocar na caixa de uma TV de 20’’, uma de 20’’ ou uma menor, mas 
jamais uma acima de 20’’ (29’’, 32’’ etc). 
Uso das variáveis 
Em Java, temos a opção de inicializar uma variável local ou deixá-la sem inicializar, 
porém depende do tipo dessa variável. 
 Variáveis locais: antes de serem utilizadas, devem possuir um valor de acordo 
com o seu tipo. 
 Variáveis de instância: elas pertencem a toda classe e podem ser utilizadas com o 
valor padrão adquirido pelo tipo da mesma. 
As variáveis de instância referem-se a um objeto que recebe um valor padrão do 
tipo da variável. 
NULL= significa que a variável de referência não foi atribuída a nenhum objeto na 
pilha. 
Podemos criar variáveis locais e não inicializar, e o programa não emitirá nenhum 
erro na compilação, desde que a variável local não seja utilizada no escopo da 
declaração. 
Referências de objetos locais 
Quando duas variáveis referem-se ao mesmo objeto, a alteração em um dos dois 
vai refletir na outra variável. 
class ReferObjt{ 
 public static void main(String args[]){ 
 Integer i = new Integer(10); 
 Integer j=i; 
 System.out.println(i); 
 System.out.println(j); 
 i+=20; 
//sera que j ta referenciado ao novo valor de i? 
 System.out.println(i);//imprime 30 
 System.out.println(j);//imprime o valor 10 
 }} 
O fato aqui é que wrapper(Integer, Short etc.) éfinal . Apenas usamos o recurso de 
autoboxing, que na linha i+=20 cria outro objeto wrapper, para referenciar a esse 
novo valor. Não se preocupe, mais na frente iremos conhecer como Wrapper 
trabalha. 
Objetos string 
Os objetos String são inalteráveis. Com strings, quando se tem duas variáveis 
apontando para o mesmo objeto, a JVM atualizará apenas a variável de referência. 
http://www.google.com/search?hl=en&q=allinurl%3Astring+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Ainteger+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Ainteger+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Ainteger+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Asystem+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Asystem+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Asystem+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Asystem+java.sun.com&btnI=I%27m%20Feeling%20Lucky
String a = "Camilo"; 
String d=a; 
Se uma alteração ocorrer, apenas a vai sofrer alteração, e d, não. 
Uma variável de referência significa que está se passando uma cópia dos bits. 
Passar por valor significa passar uma cópia da variável. O método chamado NÃO 
pode alterar a variável que a chamou. 
Variáveis de referência de objetos: o método chamado pode alterar o objeto da 
variável de referência. 
class DuvObjtRe{ 
 int array[] = new int[2]; 
 static void go(int [] a){ 
 a[1]=5;} 
 public static void main(String ar[]){ 
 go(new DuvObjtRe().array); 
 for(int z:new DuvObjtRe().array) 
 System.out.println(z); 
}} 
O código acima Imprime 0,0 devido ao fato de ser acessado por uma NEW(nova) 
instância da class e não por uma instância que foi passada para método. 
class DuvObjtRe{ 
 int array[] = new int[2]; 
 static void go(int [] a){ 
 a[1]=5;} 
public static void main(String ar[]){ 
 DuvObjtRe b =new DuvObjtRe(); 
 go(b.array); 
http://www.google.com/search?hl=en&q=allinurl%3Astring+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Astring+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Astring+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Asystem+java.sun.com&btnI=I%27m%20Feeling%20Lucky
http://www.google.com/search?hl=en&q=allinurl%3Astring+java.sun.com&btnI=I%27m%20Feeling%20Lucky
for(int z:b.array) 
 System.out.println(z); 
}} 
Agora imprime, devido à alteração no objeto original. 
Atenção neste ponto para não errar, pois esses detalhes são facilmente 
esquecidos. 
Array 
São objetos que armazenam diversas variáveis do mesmo tipo. Podem ser 
primitivos ou de objeto. Mas um array sempre será um objeto na PILHA. 
Podem ser criados: 
int[] array; 
int array[]; 
Para definir o tamanho do array, o objeto deve ser instanciado (criado - new) na 
pilha. 
Inválido: 
int[5] array ; 
Válido: 
int[] array = new