Guia Do Exame SCJP

Seu
Camilo Lopes para Guia
Sun
ser de Bo
um lso
SCJ
P
CERTIFIED
Java Programmer
Guia do Exame
FOCANDO
NO
EXAME
Sumário XVII
Sumário
Capítulo 1
Fundamentos – declaração de níveis do pacote e acesso. ............. 1
Modificadores de Acesso ................................................................................ 1

Modificador de Acesso ................................................................................. 10
Variável Local ........................................................................................ 13
Construtores .......................................................................................... 14
Modificador Static ........................................................................................ 17
Enum ............................................................................................................ 19
Capítulo 2
Herança, polimorfismo, retorno covariantes ................................ 21
Modificador Static – dicas ............................................................................ 32

XVIII Sun Certified Java Programmer – Guia do Exame SCJP
Capítulo 3
Atributos ......................................................................................... 37
Wrapper ...................................................................................................... 46
Quando usar? ........................................................................................ 46
Wrappers no Java 5/superior ...................................................................... 46
Diferenciar um Wrapper de Tipos primitivos .............................................. 47
Capítulo 4
Operadores .................................................................................... 57
Avaliando Valores ........................................................................................ 57

Enums .......................................................................................................... 59
Instanceof .................................................................................................... 61
Concatenação de Strings .............................................................................. 62
Acréscimo e decréscimo ......................................................................... 63
Variável Final ........................................................................................ 63
Operador ternário ................................................................................. 64
Operadores lógicos de abreviação ........................................................ 64
Operadores sem abreviação ................................................................. 65
Capítulo 5
Tratamentos de exceções ............................................................... 69
Throwable, Error, Exception, RuntimeException ........................................... 70

Controle de Fluxo – IF, SWITCH, FOR, LOOP ................................................ 74
Continue e Break ................................................................................... 79
Continue e Break – Rotulados ........................................................ 79
Sumário XIX
Capítulo 6
API .................................................................................................. 83
StringBuilder e StringBuffer ......................................................................... 85

Serialização .................................................................................................. 91
Regras da Serialização .......................................................................... 92
Variáveis Static ............................................................................................. 92
Datas, números e moedas ........................................................................... 96
Capítulo 7
Expressões regulares - REGEX ..................................................... 105
Delimitadores gananciosos ........................................................................ 107
Capítulo 8
Genéricos e Conjuntos ................................................................. 111
Subscrevendo equals() .............................................................................. 111

hashCode() ................................................................................................ 116
Objetos ! = com hashing = = ................................................................. 119
Conjuntos ................................................................................................... 121
Ordenado X Classificado ...................................................................... 121
Interface lang.COMPARABLE ...................................................................... 136
Interface util.COMPARATOR ....................................................................... 139
Comparable!= Comparator ............................................................... 139
Classificando com classes Arrays .......................................................... 139
Convertendo array em lista e o inverso .............................................. 144
XX Sun Certified Java Programmer – Guia do Exame SCJP
Sets ............................................................................................................ 150

PriorityQueue ............................................................................................ 154
Revisão ...................................................................................................... 157
Genéricos ................................................................................................... 160
Pré-Java 5 .................................................................................................. 161
Polimorfismo e Genéricos .......................................................................... 167
Coringa <?> ........................................................................................... 173
Supertipo <?> ......................................................................................... 174
Criando suas próprias classes genéricas .................................................... 180
Criando métodos genéricos ....................................................................... 181
Capítulo 9
Classes Internas ........................................................................... 187
Classes internas anônimas ......................................................................... 192

Interface especializada .............................................................................. 196
Classes estáticas aninhadas ....................................................................... 198
Capítulo 10
Threads ........................................................................................ 203
Definindo uma Thread – extends Thread ou implements Runnable ........ 204

Estados das Threads ................................................................................... 208
STATIC SLEEP() – Suspensão ............................................................... 208
STATIC YIELD () – Prioridades de Threads .......................................... 210
NON-STATIC JOIN() – Lança uma exceção verificada. ......................... 214
Sincronização ....................................................................................... 217
Sumário XXI
Quando sincronizar? ..................................................................... 217

Iteração entre as Threads .......................................................................... 223
Quando usar? ...................................................................................... 223
Capítulo 11
Desenvolvimento ......................................................................... 227
Compilando com –d .................................................................................. 227

Propriedades do sistema ........................................................................... 228
Usando java e javac ................................................................................... 229
Referências bibliográficas ........................................................... 231

Capítulo 1
Fundamentos – declaração de níveis

do pacote e acesso.
Vai ser visto aqui o uso de declaração de package, os níveis de

acesso entre as classes e os membros, e quais modificadores
podem ser usados nas classes. Serão apresentadas as interfaces,
classes abstratas e finais.
Modificadores de Acesso
public, protected, default e private
Uma classe só pode ser PUBLIC ou DEFAULT.
Default – quando uma classe tem o acesso default, o nível de

acesso é restrito aos pacotes – package, ou seja, apenas as clas-
ses dentro daquele package têm acesso aos mesmos disponíveis
naquela classe. Em outras palavras não podemos importar uma clas-
se default a partir de outro package.
2 Sun Certified Java Programmer – Guia do Exame SCJP
package cap1.x;
class Casa {
}
package cap1.y;
import cap1.x.Casa;
public class Zona {
//esse código não compila; Casa tem o acesso default
//só pode ser vista dentro do package cap1.x }
package cap1.x;
public class Zar {
/* observe que tenho um objeto de minha class Casa
* devido a ela estar no mesmo package*/
Casa c;
}
public – permite a importação da classe, mesmo em package

diferentes.
package cap1.x;
public class Jarro {}
package cap1.y;
import cap1.x.Jarro;
class Jar {
/* observe que minha class Jarro é public, então posso
importá-la para outros pacotes*/
public static void main(String[] args) { }
}
Capítulo 1 - Fundamentos - declaração de níveis do pacote e acesso 3
private class – não existem classes private, protected, todas as

classes só podem ser public ou default. Private e protected são
aplicados aos membros.
Veja a seguir as possiveis pegadinhas que podem aparecer no

exame.
Uma classe final quebra o conceito de extensibilidade do Java e

principalmente do polimorfismo.
Dica: Lembre-se desse conceito, pode-se deparar com uma ques-

tão teórica no exame
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)
classes Abstract e final - são dois tipos de modificadores não

referentes ao nível de acesso que podemos utilizar em uma clas-
se de topo do nível.
final class – uma classe marcada como final é o mesmo que

dizer: “essa classe não pode ter filhos, ela nasceu com problemas
no ovário”. Mas é exatamente isso que acontece quando se tem
uma classe como final e não pode ter o relacionamento É-UM. O
fato de criar uma classe final é dizer que a classe já disse tudo a
respeito de seus métodos e não precisa da minha opinião ou de
alguém para dizer que tem algo de errado. Uma classe final quebra
o conceito de extensibilidade do Java e principalmente do
polimorfismo.
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 genética */
final – aplicado a um método significa que o método é herdado

por uma subclasse, porém a subclasse NÃO pode subscrever esse
método, na tentativa do código não compilar.
O modificador final é uma segurança onde se torna classe, méto-

dos e variáveis inalteráveis.
package cap1.x;
class Papi {
final void setNum(){System.out.println(“final”);}
}
/* aqui estou subscrevendo meu método final, isso não é
válido para um código que não compila
*/
class fifi extends Papi{
public void setNum(){}
}
package cap1.x;
class Al{
final void setName(){System.out.println(“final
herdado”);}
}
class Est extends Al{

new Est().setName();
}}
Imprime: final herdado
Classes abstract – é completamente o oposto de uma declaração

de final class. Em uma abstract class, é obrigatório haver uma class
extends para ela fornecer implementações dos métodos abstract.
Regras de abstract:
Nunca usar abstract com: final e private.

Uma class abstract pode ter métodos abstract ou não.
Os métodos abstract terminam com ponto-e-vírgula e têm
o modificador (abstract) que os acompanham
Um método abstract na class, a mesma deve ser abstract,
senão o código nem compila.
Não se instancia algo abstract (new class()) – isso nem
compila.
Possuem construtores das classes abstract.
package cap1.x;
public abstract class Bike {
public void cor(){} //método não abstract sem modificador

e com chaves {}
abstract void marca();//método abstract com modificador
e ponto-e-vírgula
}
package cap1.x;
public class Guri extends Bike{
/* com método da class abstract implementado
* corretamente, o código compila */
public void marca(){System.out.println(“caloi”);}
}}
Uma class concreta deve fornecer implementações para todos os

métodos abstract da class não concreta. Isso é uma REGRA, po-
rém uma class filha abstract não tem obrigação de fornecer
implementações de nenhum método abstract da class pai abstract.
package cap1.x;
public abstract class Jogo {
abstract void nome();
}
abstract class start extends Jogo{
/* a class abstract não tem obrigação de implementar
* os métodos da superclass abstract */}
Não compila
package cap1.x;
public abstract class Notcomp {
void setName(); // não compila, o modificador abstract
foi omitido
/* não compila; a class concreta não implementa o
método abstract da class abstract */
Notcomp nt = new Notcomp();
System.out.println(“zomm”); }}
package cap1.x;
public abstract class Zz {

abstract void ordem();
}
package cap1.x;
class Zazz extends Zz{

/* não compila; a class concreta não implementa o método
abstract da class abstract
*/
}}
O método abstract é obrigado a ser implementado por uma class

concreta.
O uso do modificador private com abstract não combina muito bem,

devido o uso do modificador ser restrito a class. Veja o problema:
package cap1.x;
public abstract class Problem {

private abstract void setNN();
/* o código não compila abstract and private jamais,
abstract e final também não*/
}
package cap1.x;
abstract class ProFin {
/* também não compila
*
*/
final abstract void setnn();
}}
O uso dos modificadores:
public e default private, protected, final

class, métodos e variáveis métodos e variáveis
abstract, native stricfp

somente métodos classes e métodos
Interface – é apenas um contrato que a classe deve cumprir

com a interface que a implementa.
As interfaces:
Não fazem parte da herança Java.

Todos os métodos de uma interface são public e abstract
implicitamente.
As variáveis são implicitamente public static final.
Uma interface pode aplicar extends em outra, porém ja-
mais implementar.
Uma interface não pode implementar uma class.
Uma class pode implementar varias interfaces.
Não se podem ter métodos com chaves{} em uma interface.
As variáveis/métodos não têm outro modificador além de public.
package cap1.y;
public interface Dados {

int z =10;
void num();
}
package cap1.y;
class joga implements Dados {

/* o código compila normalmente; implementei meu método
e imprimi o valor da interface*/
public void num() { } //método implementado

System.out.println(z);
}}
public interface Dados {

int z =10;
void num();
}
public class Jhg implements Dados {
static int z=8;
public void num() { }
/*refere-se ao static da class
* */
z=9;
//não compila; tentei alterar o valor de uma variável
final da interface
Dados.z=20; }}
public class Nointer implements Dados{

void num(){}
/* não compila onde está o public? Não posso converter
de public para default */}
Não posso combinar nenhum destes modificadores com os méto-

dos da INTERFACE:
final – o método não pode ser subscrito

private – o método não pode ser herdado
native – somente a métodos
stricfp – classes e métodos
synchronized – somente a métodos concretos e blocos
de código. (interface métodos abstract)
interface Corp {
void seta(){}
/* não posso ter métodos com chaves em uma interface,
* pois os métodos são implicitamente abstract aqui
*/}
Modificador de Acesso
Este conceito é tão importante quanto qualquer outro assunto e no
exame, a Sun lida com eles em todos os assuntos. Às vezes, o
escopo da pergunta é sobre Threads, mas, na verdade, o objetivo
é testar o uso dos modificadores de acesso.
Public funciona da seguinte forma: se a class é public, você

pode ter acesso aos membros public e protected dessa classe.
Agora, se sua class não é public, ou seja, é default e se os

membros forem public (métodos e variáveis), o acesso ainda é por
pacote. Tudo depende do modificador da class para depois verifi-
car se o membro é visível ou não.
package cap1.f;
public class Fog {

private int z;
public void cor(){}
}
package cap1.g;
import cap1.f.Fog;
class Ge{
/* válida a class Fog public e o método cor também
* só não posso chamar a variável private aqui
*/
public static void main(String arg){
new Fog().cor();
}}
package cap1.g;
class Refrig {
public void marca(){}
}
package cap1.f;
import cap1.g.Refrig;
/* não compila; a class Refrig só é vista dentro do

package cap1.g se a tentativa de importar para outro o
código não é compilado */
public class Ben {

package cap1.f;
public class Aviao {

private int num=10;
}
package cap1.f;
public class Opera {

public static void main(String arg[]){
System.out.println(new Aviao().num);
}
/*não compila; a variável num é private da class
aviao; ninguém pode saber que ela existe */
}
Veja na página seguinte alguns exemplos:

Protected – tem apenas um objetivo acessar, um membro da

class através de um pacote diferente. Porém, somente funciona
através da herança.
package cap1.g;
/* observe o package dessa class */
public class Zer {
protected void zar(){System.out.println(“membro
protected”);}
}
package cap1.f;
import cap1.g.Zer;
class Zr extends Zer{
/* o método com o modificado protected foi herdado e
estou chamando-o */
new Zr().zar();
}}
package cap1.g;
/* observe o package dessa class */
public class Zer {
protected void zar(){System.out.println(“membro
protected”);}
}
package cap1.f;
import cap1.g.Zer;
class Zarra extends Zer{
/* isso não compila; não posso usar o nome da superclasse
para chamar o método protected */
new Zer().zar();
}
}
The method zar() from the type Zer is not visible
Variável Local
Uma variável local só pode ser marcada com o modificador FI-
NAL; qualquer outro o código nem compila.
class Foo {
void f(){
/* não compila; modificador inválido para esse
tipo de variavel*/
private int z=0;
}}
class Fac {
void setN(){
/* modificador válido para a variável local
* o código compila tranquilamente */
final int a=0;
}
}
Regras:
As variáveis locais antes do uso devem possuir um valor,

caso contrário, um erro de compilação ocorre ao tentar usar
uma variável local sem valor.
Elas não recebem valor padrão como as variáveis de instância.
São destruídas após a conclusão do seu escopo.

class Fac {
void setN(){
int z;
System.out.println(10);
/* compila normalmente; não usei a variável local,
apenas declarei */
}}
class Foo {
void f(){
/* não compila; tentei usar uma variável local sem
valor; elas não recebem um valor padrão como as variá-
veis de instância */
int num;
System.out.println(num);
}}
Construtores
Refere-se à construção de objetos da classe. Posso usar qualquer
um dos modificadores: public, protected, default e private.
Um construtor jamais pode ter:
final – aplica-se somente a métodos, classes e variáveis

static – somente a variáveis e métodos
abstract – somente a classes e métodos
synchronized – somente a métodos e blocos
native – somente a métodos
stricfp – classes e métodos
Um construtor tem o mesmo nome da classe sem o tipo de retorno

e sempre é sobrecarregado. Se houver um tipo de retorno, ele será
um método e não um construtor, porém um método que tem o

mesmo nome da classe.
public class Bola {

Bola(){}
Bola(int z){}
/* dois construtores */
}
zum construtor só pode chamar outro construtor. Não pode

chamar um construtor dentro de um método ou um bloco.
Sempre dentro de outro construtor. ISSO É UMA REGRA.
public class Ball {
public Ball(int a) { }
}
/* a class filha é obrigada a chamar o construtor da
superclass, senão o código nem compila */
class Player extends Ball{
Player(){
super(2);
}}
Se o programador não fornecer nenhum construtor, o compilador

fornecerá um sem argumentos.
O compilador sempre faz uma chamada implícita para super().
Dica: Não se esqueça que o construtor padrão somente é forneci-

do quando não declaramos nenhum construtor.
public class Peek {
}
class Pee extends Peek{
Pee(){}
/* chamada implícita para super()*/
}
public class Nota {

Nota(int n){}
}
class Al extends Nota{
Al(){}
/* o código não compila; a superclass não tem nenhum
construtor sem argumento.
* então sou obrigado a chamar o construtor criado expli-
citamente */
public class Nota {

Nota(int n){}
Nota(){}
}
class Al extends Nota{
Al(){}
/* agora compila uma chamada implícita para super()
- você não é obrigado a chamar todos os construtores */
}
super – sempre chama a class pai
this – sempre chama algo sendo executando no momento e no

caso do construtor, chama o da própria class.
public class ConstPriv {

private ConstPriv(){}
}}
/* o código não compila a subclass que está chamando o
construtor da superclass, que é private e ela nem deve-
ria saber que ele existe*/
class Cont extends ConstPriv{
Cont(){}
}
Modificador Static
Permite acessar um membro sem precisar criar uma instância da
classe(new class()).
métodos, variáveis, blocos e class(aninhada). Esses

podem ser marcados com o modificador static.
Isso nao pode ser usado com o modificador static:
variáveis locais – apenas final

construtores – é usado para criar a instância
class – public e default
interface – public e default
enum – public e default.
public class Zorra {

static int n=9;
public void run(){
int n1=n;
}
/* aqui não há problemas, nenhum membro não static pode
chamar os membros static. observe que o acesso é direto*/}
public class Member {

int z=10;
static void setNum(){
int z1 = z;
/* não compila; método static chamando um membro não
static isso não é válido o membro não static precisa de
uma instância de class */
}}
o valor de um membro static é compartilhado por todos.

Static só visualiza outro static.
public class Full {

static int z=20;
}
/* não há problemas aqui, o código compila
tranquilamente */
}
import static java.lang.System.out;

public class FullProb {
int num=0;
out.println(num);
}
/* não compila o membro não static sendo chamado dentro
de um contexto static */
}
Enum
É um tipo de class especial, o objetivo aqui é criar constantes.
Pode ser declarado fora de uma class ou dentro de uma class.
Modificadores válidos:
Public e default
Inválidos:
final
abstract
static
private
protected
public class Flor {

enum floresta{LEAO, LEOA, TRIGRE}
floresta f = floresta.LEAO;
System.out.println(f.toString());
}
/* imprime LEAO */
}
Não se cria instâncias de enum:
floresta f = new floresta() – não compila

enum cidade{CURITIBA, NATAL, PORTOALEGRE}
class Brasil {
/* enum fora da class é válido */
Cidade c = Cidade.CURITIBA;
System.out.println(c);
}
}
public class EnumNo {

enum time{Flamengo,Palmeiras};
/*não compila enum dentro de um método */
}
}
private enum Veiculos {

/* não aceita nenhum modificador além de public e default*/
}
package cap1.f;
public enum Map { BIG(8),HUGE(10);

Map(int z){
id=z;
}
int id;
/* declaração válida; construtor enum sobrecarregado*/
}
Capítulo 2
Herança, polimorfismo, retorno

covariantes
A herança permite a flexibilidade e a facilidade de manutenção.

Com a herança, é possível criar classes mais especializadas so-
bre a classe-pai.
Um dos dois benefícios da OO está na flexibilidade e na manuten-

ção, porém isso não acontece apenas porque o Java implementa
os conceitos da OO. Isso depende do programador e o uso do
encapsulamento é um beneficio essencial para uma boa
implementação da OO. Porém, vale ressaltar que depende do pro-
gramador. “A capacidade de fazer alterações no código de
implementação sem interromper o código das outras pessoas que
estiverem usando, isso é encapsulamento.”
public class Encap {

private int z=0;
public void setConecta(){}
public int getError(){return z;}
/* o fato de ter variáveis de instância private e
métodos públicos para acessar o conteúdo private já
implementa a ideia de encapsulamento */
}
Polimorfismo - permite a criação de muitas formas e tem o

relacionamento semelhante à herança. A reutilização está inserida
no conceito de polimorfismo.
Quando se passa no teste É-UM, temos o polimorfismo. É aplica-

do também com INTERFACE pela palavra-chave implements e
pela herança com a palavra-chave extends.
public class Veiculo {}

class Carro extends Veiculo{} // carro É-UM veiculo
interface Som{}
/* Vectra é um carro que implementa um Som implements -
É-UM. */
class Vectra extends Carro implements Som{}
Variável de referência – determina qual método será chama-

do e durante a execução, o seu tipo não pode ser modificado.
Mas... pode referir-se ou apontar para qualquer objeto que passe
no teste É-UM. A variável de referência fica antes do = (sinal de
igualdade).
Válidos:
Carro car = new Carro();

Object o = car;//Object é super de car
Veiculo v = car;//Veiculo é super de car – carro
Inválidos:
Veiculo v = new Veiculo();//aqui é válido

Som s = v; //Som é sub de Vectra
Carro c = v;//Carro é sub de Veiculo e não super
Capítulo 2 - Herança, polimorfismo, retorno covariantes 23
O tipo da variável de referência só pode chamar aquilo que a

superclass conhece, caso contrário, o código nem compila.
public class Concorrencia {

void setTel(){}
}
class Voip extends Concorrencia{
void setTel(){System.out.println(“subcsrito”);}
void setCusto(){System.out.println(“custo”);}
}
public class Principal {

Concorrencia c = new Voip();
c.setTel();//chama o método subscrito;
/* a linha abaixo não deixa o código compilar a superclass
não tem esse método */
c.setCusto();
}}
The method setCusto() is undefined for the type
Concorrencia
O tipo do objeto só é chamado com métodos de instância. E

quando deseja chamar o método subscrito, usa o tipo do objeto.
Static e variáveis são chamados por variáveis de referência.
Superclass s = new Subclass();

s.método(); //chama o método subscrito
Caso o método não seja subscrito, é chamado o da superclass.

Porém, isso não funciona com os métodos static, já que nem eles
são subscritos e sim, redefinidos, e as variáveis também não são
herdadas. Veja:
public class Casa {

static void cor(){System.out.println(“azul”);}
}
class Ap extends Casa{
static void cor(){System.out.println(“amarelo”);}
}
public class CaPrin {

Casa c = new Ap();
c.cor();
}
/* imprime a cor azul */
}
Dica: Combinar ABSTRACT com:

- private – não herdado;
- final – não pode ser subscrito;
- static – não é herdado = O CÓDIGO NÃO COMPILA
Sobrecarga de métodos – é o fato de ter vários métodos com o

mesmo nome, porém com uma lista de argumentos com tipos
diferentes.
No método sobrecarregado, o tipo de variável de referência diz

qual método vai ser chamado, ao contrário do tipo do objeto que
chama o método subscrito pela subclasse.
class Mundo {}
public class Terra extends Mundo{}
public class Galatix {
void chama(Mundo m){
System.out.println(“mundo chamando”);
}
//método sobrecarregado
void chama(Terra t){
System.out.println(“terra chamando”);
}
Galatix g = new Galatix();
Mundo m = new Mundo();
Terra t = new Terra();
/* aqui ele chama mundo e depois terra, de acordo com o
tipo passado em args */
g.chama(m);
g.chama(t);
/*neste aqui, chama o tipo de referência e não o tipo do

objeto Terra. */
Mundo m2 = new Terra();
g.chama(m2);
}}
EXIBI:
mundo chamando
terra chamando
mundo chamando
Regras do sobrecarregado:
Deve alterar a lista args

Pode lançar exceções novas e mais abrangentes
Pode alterar o tipo de retorno
Regras do subscrito:
não pode alterar a lista args

não pode alterar o tipo de retorno (exceto com o retorno de
covariantes Java 1.5). Válido somente para os objetos.
pode lançar exceções novas e menos restritivas.
Para entender, basta lembrar dos recursos de herança como É-

UM. A partir do Java 1.5 é permitido que o método subscrito retorne
um valor que passe no teste É-UM, desde que esse seja um
objeto e não um tipo primitivo.
public class Super {

void soma(){}
}
/* não compila o método subscrito lançando uma exceção
mais abrangente que o método da superclass
*/
class Sub extends Super{
void soma() throws Exception {}
/* dica- quando não declaro uma exceção,
implicitamente meu método lança uma exceção não verificada
RuntimeException*/
}
public class Sitio {
void mum() throws Exception{}
public static void main(String[] args) {}
}
class Cad extends Sitio{
void mum(){}
/* aqui não há problemas, minha subclasse subscre-
ve; o método não tem obrigação de lançar uma exceção ou
tratar */
}
public class Cobra {

void cor(){}
}
class Minhoca extends Cobra{
void cor() throws NumberFormatException{}
/* o código compila sem problemas ja que a subclass
lança uma exceção menos abrangente que da superclass */
}
public class Tarta {

void casco(){}
}
class Cagado extends Tarta{
void casco() throws Exception{}
/* o código não compila a subclass está lançando
uma exceção mais abrangente que da superclass */
}
Conversão de variáveis de referência – tenha muita atenção

ao se deparar com este assunto no exame. Aparece por todo o
exame e as questões não são as mais simples de responder.
public class Tranpor {}

class Onibus extends Tranpor{}
public class Conducao {
Tranpor t = new Tranpor();
Onibus o =(Onibus)t;
/* o código compila devido às classes envolvidas Tranpor
e Onibus fazerem parte da mesma herança, porém uma
exceção é lançada e não posso dizer que todo Transporte
é um Ônibus */
}}
Exception in thread “main” java.lang.ClassCastException:
public class Esport {}

class Boxe extends Esport{}
public class Quadro {

Esport e = new Boxe();
Boxe b =(Boxe)e;//compila e roda sem problemas
Esport es=b;//boxe é um esport
}
public class Esport {}

class Capoeira extends Esport{}
public class CapBa {
Esport t = new Esport();
Capoeira ca=(String)t;
}
/* nem compila; String não faz parte da herança entre
essas classes, o compilador não permite a compilação*/
}
Inválido:
Esport p = new Esport();

// não posso converter o objeto
//Esport em Boxe:
Boxe bh = (Boxe)p;
Porém, o código compila, mas lança uma exceção.
Implementando uma interface – um pouco mais de regras a

serem seguidas. Uma classe concreta deve implementar to-
dos os métodos de uma interface. Caso exista uma subinterface,
os métodos dela também devem ser implementados.
interface luz extends cor{

void marca();
}
interface cor{
void ss();
}
class carr implements luz{
/*deve implementar todos os métodos de luz e cor */
public void marca(){}
public void ss(){}
}
uma interface não implementa nada, somente estende com

extends a outra interface.
interface roda{}
/* válida a relação entre as interfaces */
interface modelo extends roda{}
interface moda implements loja{}

/* nem compila; a interface não implementa nada*/
interface loja{}
interface roupa{}
/* não compila; uma class não aplica extends em nada que
seja uma class e roupa é uma interface */
class fab extends roupa{}
Retorno de covariantes – Este não é um assunto complicado.

Porém, no exame ele apareceu a todo o momento, sempre quando
envolvia herança e a subscrição estava no retorno de covariantes
marcando presença.
Para entender, basta lembrar dos recursos de herança. É-UM, no

Java 1.5, permite que o método subscrito retorne um valor é-
um.(Desde que seja um objeto e não tipos primitivos)
public class Foo {

Object go(){return null;}
}
class Bar extends Foo{
/* String é-um Object; o código compila
tranquilamente */
String go(){return null;}
}
public class Primit {

int go(){ return 1;}
}
class Prim extends Primit{
char go(){return ‘d’;}
/* o código não compila, alterei o tipo, porém não args
char não passa no teste é-um para o tipo primitivo; isso
só funciona com objetos.*/
}
class Numbr {
Number go(){return null;}
}
class numb extends Numbr{
Integer go(){return null;}
/* o código compila normalmente; objeto Integer é-
um Number */
}
public class Numeros {

int go(){
float f=10.0f;
return (int)f;
}
/* compilará normalmente se remover ( ); o f de
10.0 não compila */
}
public class Varia {

int go(){
return 10.0;
/*não compila o tipo de retorno; é int e não
double */
}
}
public class Floa {

float go(){
return 1;
/* compila normalmente não há problema retornar
um int para um float */
}
public static void main(String ar[]){
System.out.println(new Floa().go());
}
}
Exibe
1.0
Modificador Static – dicas

Não podem ser subscritos e sim, redefinidos. O seu valor é
compartilhado em toda a classe.
Não pertence a nenhuma instância da classe
Somente podem ser chamados por outro static
public class SupStatic {

static void set(){System.out.println(“super”);}
SupStatic sp = new substati();
sp.set();
}
/* o método que é chamado foi da variável de refe-
rência, já que os métodos static não são subscritos */
}
class substati extends SupStatic{
static void set(){System.out.println(“sub”);}
}/* imprime super*/
public class Wv {
static void num(){System.out.println(“static”);}
void num(){System.out.println(“non-stati”);}
/* o código não compila dois métodos com tipos de
argumentos iguais, com o mesmo nome e retorno também.
O fato de ser static não muda a regra Static não é um
tipo de retorno e sim um modificador */
}
public class Kv {
static int num;
System.out.println(num);
}
/* variável static; posso chamar diretamente e não
precisa de uma instância de class */
}
public class StaticMet {

void método(){}
método();
}
/* não compila o método não static sendo chamado
dentro de um método static*/
}
Acoplamento – o estado desejável é o fraco, o indesejável é

o forte.
Quando uma classe é mal encapsulada, temos aí o acoplamento

forte e suas variáveis public é um exemplo. Quando a class A
sabe mais do que devia da class B e uma alteração em uma das

classes danifica a outra, isto é um acoplamento forte.
public class A {
int r =10;
void met(){
B b = new B();
r=b.num;
}}
/* observe que a class B e a class A sabem demais uma
sobre a outra e isso é um estado indesejável */
class B{
public int num=50;
void met(){
num = new A().r;
}}
Coesão – é o grau, o objetivo ou o foco de uma classe. Quando

desenvolvemos uma class e ela faz tudo como, por exemplo, gerar
relatório, conectar um banco de dados etc., isso é uma baixa
coesão porque não tem nenhum foco. A partir do momento em
que defino o objetivo, o foco de minha classe, tenho alta coesão.
A coesão está relacionada à classe estar focada ou não.

public class Cad_cli {

void dados(){}
void endereco(){}
}
/* tenho aqui alta coesão entre as classes */
class Relatorio{}
class Bd_connectar{}
public class Usuario {

void relat(){}
void savearq(){}
void exportar(){}
/* tenho aqui a baixa coesão, pois uma class que
faz tudo. Aqui, tenho o problema de que ter que digitar
o código novamente, caso precise de um dos recursos dos
métodos em outra classe*/}
Capítulo 3
Atributos
Tenha cuidado com as questões com fluxo de controle, pois elas

tendem a ser mais difíceis por necessitarem de mais atenção do
candidato.
As variáveis aparecem em qualquer lugar de uma classe java e

conhecer como ela se comporta, tendo como base onde foi decla-
rada, é essencial para acertar as questões no exame.
O uso de uma variável local é permitido após ser atribuído o valor

e é somente vista naquele contexto onde foi declarada. Lembre-se
que as variáveis locais não recebem um valor padrão quando são
declaradas.
Uma variável de instância de objetos recebe o valor null, como

padrão. Uma tentativa de manipular esse valor é lançando uma
exceção não verificada: NullPointerException.
Variável de Instância
- Os seus valores são iniciados automati-
camente e são declaradas fora de qualquer método ou bloco.
Um detalhe importante é o uso do modificador final em uma variá-

vel; esta deve ter um valor inicial, caso contrário, o código não
compila. Vejamos no nível do código.
public class Varva {

int z;
void método(){
int z;
/* o código não compila; tentei usar uma
variável local sem inicializar*/
}
public static void main(String[] args) {}}
public class Var {

int z;
void método(){
int z;
System.out.println(this.z);
/* aqui não temos problema nenhum, a variável da
instância é chamada e não o código local, e imprime 0 */
}
new Var().método();
}}
Variáveis de instância do array - não se pode esquecer que

no fundo, um array é um objeto e isso é fundamental ter em
mente. Na declaração, um array é null, mas quando este é
instaciado os elementos contidos nele serão do tipo declarado.
Capítulo 3 - Atributos 39
public class Array {

int[] array;// aqui recebe null porque apenas declarei
int [] ar = new int[2];// aqui recebe o valor padrão cada
elemento
/* válido; os códigos abaixo compilam nor-
malmente */
System.out.println(new Array().array);
System.out.println(new Array().ar[1]);
System.out.println(new Array().ar);//imprime a referência
do objeto(já que instanciei)
}
resultado:
null
0
I@18d107f
Variável local – se inicializar uma variável local dentro de um

bloco condicional (if/while), o compilador irá reclamar.
public class Cond {

void met(){
int n;
while(true){
n=4;
}
System.out.println(n);
}
/* esse código não compila porque estou inicializando
minha variável local dentro de um bloco de instrução e
isso não será válido se o código for false. Então, o que
o compilador faz? Para evitar transtorno, ele não acei-
ta, mesmo sendo true */}
Capítulo 4 - Operadores 59
boolean b = true;
if(b = false); // ele recebe false não compara
//invalido o codigo abaixo

int x=1;
if(x = 0)// x é inteiro e não booleano.
Enums
Enum: é um tipo especial de class.
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.
Os enums são static e final.
Para enums pode usar o = = ou equals() para comparação das

duas variáveis.
class EnumEqua2l{
enum Color{RED, BLUE}
public static void main(String args[]){
Color c1 = Color.RED;
Color c2 = Color.BLUE;
if(c1= =c2){
System.out.println(“= =”);
}
if(c1.equals(c2)){System.out.println(“dot
equals”);}
}}
enum Fest{CARNAVAL,SAOJOAO,NATAL}
class Em{
Fest f = Fest.NATAL;
System.out.println(f.toString());
}
}
class Festa{
enum zorra{TIRADENTES,SOLDADO};
//static,public,protected. default - valido
//abstract, final - invalido
System.out.println(zorra.SOLDADO);
}
}
Não compila
class Enum{
final enum Pu {FUTEBOL, VOLEI,BOXE};
System.out.println(Pu.BOXE==Pu.BOXE);
Pu p = Pu.FUTEBOL;
Pu p2 = Pu.FUTEBOL;
System.out.println(p.equals(p2));
}
}
//não compila olha o modificar de acesso de enum
class Enum{
abstract enum Pu {FUTEBOL, VOLEI,BOXE};
System.out.println(Pu.BOXE==Pu.BOXE);
Capítulo 4 - Operadores 61
Pu p = Pu.FUTEBOL;
Pu p2 = Pu.FUTEBOL;
System.out.println(p.equals(p2));
}
}
//não compila olha o modificar de acesso de enum
Instanceof
Este operador é usado apenas para variáveis de referencia de obje-
to para verificar se um objeto é especifico de outro.
class A{}
class B extends A{
A meuA = new B(); // é um objeto de b do tipo A
B meuB = new B();
m2(meuA);
public static void m2(A a){//esse método so recebe

argumento que seja da classe pai
if(a instanceof B)
((B)a).doStuf(); // converto o objeto
‘a’ em b
}
public static void doStuf(){

System.out.println(“ ‘a refere to a ‘B’”);
}}
Um objeto só vai ser especifico do outro se passar no

teste É-UM.
É bom lembrar que se uma class implementa uma interface
ela faz parte do teste É-UM então temos ai um instanceof valido:
interface foo{}
class a implements foo{}
class b extends a{}
a a = new a();
b b = new b();
a instanceof Foo
b instanceof a
b instanceof Foo;//implementação indiretamente
Código invalido para instanceof.
class Cat{}
class Dog{
public static void main(String[] args){
Dog d = new Dog();// novo objeto de dog
System.out.println(d instanceof Cat);
}
}
/* aqui dar pau ja q d nem conhece Cat*/
/* para ser verdadeiro teria que usar É-UM.*/
Os arrays são objetos em qualquer circunstancia e sempre será

uma instancia de Object.
Concatenação de Strings
O operador de + pode concatenar String e somar int, porém de-
pende do valor a sua esquerda ou nível de precedência.

Guia Do Exame SCJP

Enviado por

Dados do documento

Descrição:

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Descrição:

Direitos autorais:

Formatos disponíveis

Guia Do Exame SCJP

Título original:

Enviado por

Descrição:

Direitos autorais:

Formatos disponíveis

Seu

Camilo Lopes para Guia

Modificadores de Acesso ................................................................................ 1

Modificador Static – dicas ............................................................................ 32

Avaliando Valores ........................................................................................ 57

Throwable, Error, Exception, RuntimeException ........................................... 70

StringBuilder e StringBuffer ......................................................................... 85

Delimitadores gananciosos ........................................................................ 107

Subscrevendo equals() .............................................................................. 111

Sets ............................................................................................................ 150

Classes internas anônimas ......................................................................... 192

Definindo uma Thread – extends Thread ou implements Runnable ........ 204

Quando sincronizar? ..................................................................... 217

Compilando com –d .................................................................................. 227

Referências bibliográficas ........................................................... 231

Fundamentos – declaração de níveis

Vai ser visto aqui o uso de declaração de package, os níveis de

Uma classe só pode ser PUBLIC ou DEFAULT.

Default – quando uma classe tem o acesso default, o nível de

public – permite a importação da classe, mesmo em package

public class Jarro {}

private class – não existem classes private, protected, todas as

Veja a seguir as possiveis pegadinhas que podem aparecer no

Uma classe final quebra o conceito de extensibilidade do Java e

Dica: Lembre-se desse conceito, pode-se deparar com uma ques-

classes Abstract e final - são dois tipos de modificadores não

 final class – uma classe marcada como final é o mesmo que

public final class Pai {

final – aplicado a um método significa que o método é herdado

O modificador final é uma segurança onde se torna classe, méto-

public static void main(String[] args) {

Classes abstract – é completamente o oposto de uma declaração

 Nunca usar abstract com: final e private.

public abstract class Bike {

public void cor(){} //método não abstract sem modificador

Uma class concreta deve fornecer implementações para todos os

public abstract class Zz {

class Zazz extends Zz{

O método abstract é obrigado a ser implementado por uma class

O uso do modificador private com abstract não combina muito bem,

public abstract class Problem {

O uso dos modificadores:

public e default private, protected, final

abstract, native stricfp

Interface – é apenas um contrato que a classe deve cumprir

 Não fazem parte da herança Java.

 Uma interface pode aplicar extends em outra, porém ja-

 Uma class pode implementar varias interfaces.

 Não se podem ter métodos com chaves{} em uma interface.

 As variáveis/métodos não têm outro modificador além de public.

public interface Dados {

class joga implements Dados {

public static void main(String[] args) {

public interface Dados {

public class Nointer implements Dados{

Não posso combinar nenhum destes modificadores com os méto-

 final – o método não pode ser subscrito

 stricfp – classes e métodos

 synchronized – somente a métodos concretos e blocos

Default – quando uma classe tem o acesso default, o nível de

public – permite a importação da classe, mesmo em package

private class – não existem classes private, protected, todas as

classes Abstract e final - são dois tipos de modificadores não

final class – uma classe marcada como final é o mesmo que

final – aplicado a um método significa que o método é herdado

Classes abstract – é completamente o oposto de uma declaração

Nunca usar abstract com: final e private.

Interface – é apenas um contrato que a classe deve cumprir

Não fazem parte da herança Java.

Uma interface pode aplicar extends em outra, porém ja-

Uma class pode implementar varias interfaces.

Não se podem ter métodos com chaves{} em uma interface.

As variáveis/métodos não têm outro modificador além de public.

final – o método não pode ser subscrito

stricfp – classes e métodos

synchronized – somente a métodos concretos e blocos

Public funciona da seguinte forma: se a class é public, você

Protected – tem apenas um objetivo acessar, um membro da

As variáveis locais antes do uso devem possuir um valor,

São destruídas após a conclusão do seu escopo.

final – aplica-se somente a métodos, classes e variáveis

synchronized – somente a métodos e blocos

native – somente a métodos

stricfp – classes e métodos

super – sempre chama a class pai

this – sempre chama algo sendo executando no momento e no

métodos, variáveis, blocos e class(aninhada). Esses

variáveis locais – apenas final

o valor de um membro static é compartilhado por todos.

Polimorfismo - permite a criação de muitas formas e tem o

Variável de referência – determina qual método será chama-

Sobrecarga de métodos – é o fato de ter vários métodos com o