You are on page 1of 49

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.
4 Sun Certified Java Programmer – Guia do Exame SCJP

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{

public static void main(String[] args) {


new Est().setName();
}}
Imprime: final herdado
Capítulo 1 - Fundamentos - declaração de níveis do pacote e acesso 5

„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”);}
public static void main(String[] args) {

}}

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.
6 Sun Certified Java Programmer – Guia do Exame SCJP

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
public static void main(String[] args) {
/* 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
*/
public static void main(String[] args) {
}}
Capítulo 1 - Fundamentos - declaração de níveis do pacote e acesso 7

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();
public static void main(String[] args) {

}}

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
8 Sun Certified Java Programmer – Guia do Exame SCJP

„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

public static void main(String[] args) {


System.out.println(z);
}}
Capítulo 1 - Fundamentos - declaração de níveis do pacote e acesso 9

public interface Dados {


int z =10;
void num();
}
public class Jhg implements Dados {
static int z=8;
public void num() { }
public static void main(String[] args) {
/*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
*/}
10 Sun Certified Java Programmer – Guia do Exame SCJP

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();
}}
Capítulo 1 - Fundamentos - declaração de níveis do pacote e acesso 11

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 {


public static void main(String[] args) { }

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:


12 Sun Certified Java Programmer – Guia do Exame SCJP

„ 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 */
public static void main(String[] args) {
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 */
public static void main(String[] args) {
new Zer().zar();
Capítulo 1 - Fundamentos - declaração de níveis do pacote e acesso 13

}
}
Exception in thread “main” java.lang.Error: Unresolved
compilation problem:
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.


14 Sun Certified Java Programmer – Guia do Exame SCJP

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á
Capítulo 1 - Fundamentos - declaração de níveis do pacote e acesso 15

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.
16 Sun Certified Java Programmer – Guia do Exame SCJP

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.
Capítulo 1 - Fundamentos - declaração de níveis do pacote e acesso 17

public class ConstPriv {


private ConstPriv(){}
public static void main(String[] args) {

}}
/* 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*/}
18 Sun Certified Java Programmer – Guia do Exame SCJP

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;
public static void main(String[] args) {
System.out.println(z);
}
/* não há problemas aqui, o código compila
tranquilamente */
}

import static java.lang.System.out;


public class FullProb {
int num=0;
public static void main(String[] args) {
out.println(num);
}
/* não compila o membro não static sendo chamado dentro
de um contexto static */
}
Capítulo 1 - Fundamentos - declaração de níveis do pacote e acesso 19

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}
public static void main(String[] args) {
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 */
public static void main(String[] args) {
Cidade c = Cidade.CURITIBA;
System.out.println(c);
}
}
20 Sun Certified Java Programmer – Guia do Exame SCJP

public class EnumNo {


public static void main(String[] args) {
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 */
}
22 Sun Certified Java Programmer – Guia do Exame SCJP

„ 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 {

public static void main(String[] args) {


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();
}}
Exception in thread “main” java.lang.Error: Unresolved
compilation problem:
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
24 Sun Certified Java Programmer – Guia do Exame SCJP

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 {

public static void main(String[] args) {


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.
Capítulo 2 - Herança, polimorfismo, retorno covariantes 25

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”);
}
public static void main(String[] args) {
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
26 Sun Certified Java Programmer – Guia do Exame SCJP

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(){}
public static void main(String[] args) { }
}
/* 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 */
}
Capítulo 2 - Herança, polimorfismo, retorno covariantes 27

public class Cobra {


void cor(){}
public static void main(String[] args) {}
}
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(){}
public static void main(String[] args) {}
}
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.
28 Sun Certified Java Programmer – Guia do Exame SCJP

public class Tranpor {}


class Onibus extends Tranpor{}
public class Conducao {
public static void main(String[] args) {
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 {


public static void main(String[] args) {
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 {
public static void main(String[] args) {
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*/
}
Capítulo 2 - Herança, polimorfismo, retorno covariantes 29

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{}
30 Sun Certified Java Programmer – Guia do Exame SCJP

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;}
}
Capítulo 2 - Herança, polimorfismo, retorno covariantes 31

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 */
}
}
32 Sun Certified Java Programmer – Guia do Exame SCJP

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”);}
public static void main(String[] args) {
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*/
Capítulo 2 - Herança, polimorfismo, retorno covariantes 33

public class Wv {
static void num(){System.out.println(“static”);}
void num(){System.out.println(“non-stati”);}
public static void main(String[] args) {}
/* 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;
public static void main(String[] args) {
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(){}
public static void main(String[] args) {
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
34 Sun Certified Java Programmer – Guia do Exame SCJP

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.


Capítulo 2 - Herança, polimorfismo, retorno covariantes 35

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.
38 Sun Certified Java Programmer – Guia do Exame SCJP

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;
System.out.println(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 */
}
public static void main(String[] args) {
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
public static void main(String[] args) {
/* 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”);}
}}
60 Sun Certified Java Programmer – Guia do Exame SCJP

enum Fest{CARNAVAL,SAOJOAO,NATAL}
class Em{
public static void main(String args[]){
Fest f = Fest.NATAL;
System.out.println(f.toString());
}
}

class Festa{
enum zorra{TIRADENTES,SOLDADO};
//static,public,protected. default - valido
//abstract, final - invalido
public static void main(String args[]){
System.out.println(zorra.SOLDADO);
}
}

Não compila

class Enum{
final enum Pu {FUTEBOL, VOLEI,BOXE};
public static void main(String args[]){
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};
public static void main(String args[]){
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{
public static void main(String args[]){
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’”);
}}
62 Sun Certified Java Programmer – Guia do Exame SCJP

„ 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.