Post on 19-Jun-2015
description
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.
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 é 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{
public static void main(String[] args) {
new Est().setName();
}}
Imprime: final herdado
5Capítulo 1 - Fundamentos - declaração de níveis do pacote e acesso
����� 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”);}
public static void main(String[] args) {
}}
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.
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) {
}}
7Capítulo 1 - Fundamentos - declaração de níveis do pacote e acesso
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();
public static void main(String[] args) {
}}
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
8 Sun Certified Java Programmer – Guia do Exame SCJP
����� 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
public static void main(String[] args) {
System.out.println(z);
}}
9Capítulo 1 - Fundamentos - declaração de níveis do pacote e acesso
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 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
*/}
10 Sun Certified Java Programmer – Guia do Exame SCJP
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();
}}
11Capítulo 1 - Fundamentos - declaração de níveis do pacote e acesso
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 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 */
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();
13Capítulo 1 - Fundamentos - declaração de níveis do pacote e acesso
}
}
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 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.
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 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á
15Capítulo 1 - Fundamentos - declaração de níveis do pacote e acesso
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.
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 nocaso do construtor, chama o da própria class.
17Capítulo 1 - Fundamentos - declaração de níveis do pacote e acesso
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 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*/}
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 */
}
19Capítulo 1 - Fundamentos - declaração de níveis do pacote e acesso
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);}
}
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, 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 */
}
22 Sun Certified Java Programmer – Guia do Exame SCJP
����� 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 {
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. 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
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 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 {
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 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.
25Capítulo 2 - Herança, polimorfismo, retorno covariantes
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 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(){}
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 */
}
27Capítulo 2 - Herança, polimorfismo, retorno covariantes
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çã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.
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*/
}
29Capítulo 2 - Herança, polimorfismo, retorno covariantes
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{}
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 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;}
}
31Capítulo 2 - Herança, polimorfismo, retorno covariantes
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*/
33Capítulo 2 - Herança, polimorfismo, retorno covariantes
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 acoplamentoforte 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 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.
35Capítulo 2 - Herança, polimorfismo, retorno covariantes
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.
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ãocompila. 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 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
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 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”);}
}}
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);
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{
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 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.