guia do exame scjp

Java Programmer

Sun

Guia do Exame

eu Gu d Bolso

Sia e

pa ser um SCJP

raCamilo Lopes

FOCANDONO

EXAME

CERTIFIED

FOCANDONO

EXAME

XVIISumário

Sumário

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

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

XVIII Sun Certified Java Programmer – Guia do Exame SCJP

Capítulo 3Atributos ......................................................................................... 37

Wrapper ...................................................................................................... 46

Quando usar? ........................................................................................ 46

Wrappers no Java 5/superior ...................................................................... 46

Diferenciar um Wrapper de Tipos primitivos .............................................. 47

Capítulo 4Operadores .................................................................................... 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 5Tratamentos 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

XIXSumário

Capítulo 6API .................................................................................................. 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 7Expressões regulares - REGEX ..................................................... 105

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

Capítulo 8Gené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 9Classes Internas ........................................................................... 187

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

Interface especializada .............................................................................. 196

Classes estáticas aninhadas ....................................................................... 198

Capítulo 10Threads ........................................................................................ 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

XXISumário

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

Iteração entre as Threads .......................................................................... 223

Quando usar? ...................................................................................... 223

Capítulo 11Desenvolvimento ......................................................................... 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íveisdo pacote e acesso.

Vai ser visto aqui o uso de declaração de package, os níveis deacesso entre as classes e os membros, e quais modificadorespodem 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 deacesso é restrito aos pacotes – package, ou seja, apenas as clas-ses dentro daquele package têm acesso aos mesmos disponíveisnaquela 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 packagediferentes.

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) { }

}

3Capítulo 1 - Fundamentos - declaração de níveis do pacote e acesso

�� private class – não existem classes private, protected, todas asclasses só podem ser public ou default. Private e protected sãoaplicados aos membros.

Veja a seguir as possiveis pegadinhas que podem aparecer noexame.

Uma classe final quebra o conceito de extensibilidade do Java eprincipalmente 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ãoreferentes 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 quedizer: “essa classe não pode ter filhos, ela nasceu com problemasno ovário”. Mas é exatamente isso que acontece quando se temuma classe como final e não pode ter o relacionamento É-UM. Ofato de criar uma classe final é dizer que a classe já disse tudo arespeito de seus métodos e não precisa da minha opinião ou dealguém para dizer que tem algo de errado. Uma classe final quebrao conceito de extensibilidade do Java e principalmente dopolimorfismo.


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 é herdadopor uma subclasse, porém a subclasse NÃO pode subscrever essemé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(“finalherdado”);}}class Est extends Al{


new Est().setName();

}}

Imprime: final herdado


�� Classes abstract – é completamente o oposto de uma declaraçãode final class. Em uma abstract class, é obrigatório haver uma classextends 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êmo 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 nemcompila.�� 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 osmétodos abstract da class não concreta. Isso é uma REGRA, po-rém uma class filha abstract não tem obrigação de fornecerimplementaçõ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 classconcreta.

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 class, métodos e variáveis

abstract, native somente métodos

private, protected, finalmétodos e variáveis

stricfpclasses e métodos


�� Interface – é apenas um contrato que a classe deve cumprircom 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 abstractimplicitamente.�� 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 blocosde 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 noexame, a Sun lida com eles em todos os assuntos. Às vezes, oescopo 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 osmembros forem public (métodos e variáveis), o acesso ainda é porpacote. 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 daclass através de um pacote diferente. Porém, somente funcionaatravé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 usaruma 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 qualquerum 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 retornoe 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 omesmo nome da classe.

public class Bola {

Bola(){}

Bola(int z){}

/* dois construtores */

}

�� um construtor só pode chamar outro construtor. Não podechamar 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 compiladorfornecerá 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 nocaso 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 daclasse(new class()).

�� métodos, variáveis, blocos e class(aninhada). Essespodem 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}

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 compilaenum 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);}

}


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, retornocovariantes

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 implementaos conceitos da OO. Isso depende do programador e o uso doencapsulamento é um beneficio essencial para uma boaimplementação da OO. Porém, vale ressaltar que depende do pro-gramador. “A capacidade de fazer alterações no código deimplementação sem interromper o código das outras pessoas queestiverem 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 orelacionamento semelhante à herança. A reutilização está inseridano conceito de polimorfismo.

Quando se passa no teste É-UM, temos o polimorfismo. É aplica-do também com INTERFACE pela palavra-chave implements epela 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 passeno teste É-UM. A variável de referência fica antes do = (sinal deigualdade).

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

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

O tipo da variável de referência só pode chamar aquilo que asuperclass 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. Equando 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 elessão subscritos e sim, redefinidos, e as variáveis também não sãoherdadas. 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 omesmo nome, porém com uma lista de argumentos com tiposdiferentes.

No método sobrecarregado, o tipo de variável de referência dizqual método vai ser chamado, ao contrário do tipo do objeto quechama 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 decovariantes 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 retorneum valor que passe no teste É-UM, desde que esse seja umobjeto 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çãoao se deparar com este assunto no exame. Aparece por todo oexame 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 aserem 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 comextends 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 quandoenvolvia herança e a subscrição estava no retorno de covariantesmarcando presença.

Para entender, basta lembrar dos recursos de herança. É-UM, noJava 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 acoplamentoforte 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 dasclasses 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. Quandodesenvolvemos uma class e ela faz tudo como, por exemplo, gerarrelatório, conectar um banco de dados etc., isso é uma baixacoesão porque não tem nenhum foco. A partir do momento emque 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 elastendem a ser mais difíceis por necessitarem de mais atenção docandidato.

As variáveis aparecem em qualquer lugar de uma classe java econhecer 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 valore é somente vista naquele contexto onde foi declarada. Lembre-seque as variáveis locais não recebem um valor padrão quando sãodeclaradas.

Uma variável de instância de objetos recebe o valor null, comopadrão. Uma tentativa de manipular esse valor é lançando umaexceçã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ãocompila. 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 queno fundo, um array é um objeto e isso é fundamental ter emmente. Na declaração, um array é null, mas quando este éinstaciado os elementos contidos nele serão do tipo declarado.

39Capítulo 3 - Atributos

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 umbloco 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 */}

59Capítulo 4 - Operadores

boolean b = true;if(b = false); // ele recebe false não compara

//invalido o codigo abaixoint 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 dasduas 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);

61Capítulo 4 - Operadores

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 noteste É-UM.�� É bom lembrar que se uma class implementa uma interfaceela 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

Documents