Resumo_Certificacao_SCJP_5.

txt
===============================================================================
Resumo Anotaes para Certificao SCJP 5.0
Autor:
Gilberto Augusto Holms
gibaholms85@gmail.com
@gibaholms
http://gibaholms.wordpress.com/
===============================================================================
===============================================================================
FUNDAMENTOS
===============================================================================
- Decorar todas as palavras reservadas
- Ordem obrigatria: package, imports e classes (sendo apenas 1 publica)
- Arquivo .java em branco ou sem classes tambm vlido
- Mtodo main - assinaturas vlidas:
public static void main( String args[] ) {}
final public static void main( String args[] ) {}
- Decorar ranges e tamanho-bytes de todas as variaveis primitivas
- Caracteres especiais: "Big Farms Need Red Tractors" (BFNRT)
- Operaes com inteiros sempre resulta int (exceto se tiver long)
- Operaes que envolvem um tipo maior, resultam num tipo igual o do maior
(float + double = double)
- Constantes (final) no podem ter contas com variveis
- Cuidado! No existe cast de String (inclusive pois ela final e
no possui herdeiras)
String s1 = (String)'A'; //ERRO DE COMPILAO
- No confundir [] com () na declarao de vetores
- Cuidado! Vetor pode ter ndice acessado apenas com variveis promovveis
para int ou constantes
- Atribuir valores entre chaves em vetores permitido apenas na inicializao
int vetor[] = new int[3];
vetor = {1, 2, 3}; //ERRO DE COMPILAO !!
vetor = new int[] {1, 2, 3, 4, 5}; //isso poderia, redefiniria o vetor
- Ex 1.12 - Cuidado! Ao igualar vetores, sempre verificar se as dimenses
se completam:
int v1[][] = new int [2][3];
int v2 [][][][] = new int[2][2][2][2];
v2[0][1][1] = v1; //ERRO DE COMPILAO !!
v2[0][1][1] = v1[0]; //OK!
v2[0][1] = v1; //OK!
- Ex 1.16 - Cuidado!
String [][]x = new String [2][];
System.out.println( x[1][0] );
//ERRO DE EXECUO !! NullPointerException
- Ex 1.18 - Cuidado! Sempre que chamar o vetor args [] do mtodo main com
seus ndices explicitos, ver se o numero de argumentos digitados no gera
um ArrayIndexOutOfBoundsException:
String s1 = args[0];
String s2 = args[1];
String s3 = args[2];
Pgina 1
Resumo_Certificacao_SCJP_5.txt
//Se tivesse s 2 argumentos, aqui geraria ERRO DE EXECUO
- Ex 1.20 ver a formao de um vetor String X[] = new String [2][2]
- Ex 1.43 - Cuidado!
int x = 10, y;
if (x < 10) y = 1;
if (x >= 10) y = 2;
System.out.println( y ); //ERRO DE COMPILAO !!
//Varivel local foi lida sem ser inicializada
//Obs.: deu erro porque poderia haver cdigo entre os dois if
//se fosse driblado no if com else, a inicializaria com certeza
- Pode inicializar variveis deste modo:
i = x = j = 1; //neste caso, todas valero 1
//Obs.: se fosse utilizar +=, a varivel que recebe precisaria
//ter sido inicializada antes
- Ex 1.60 - Cuidado!
public static void main(String[] args) {
int i[] = {1};
change(i);
System.out.println(i[0]); //IMPRIME 1
}

static void change(int i[]) {
int j[] = {2};
i = j;
}
- Ex 1.20 - Cuidado!
String x[][] = new String[2][2];
String y[] = new String[15];
x[0] = y;
System.out.println(x[0].length); //IMPRIME 15
===============================================================================
VARIVEIS
===============================================================================
- Intervalo das variveis
- Operaes com inteiros sempre resulta int
- Promoo de variveis (casting)
- Variaveis locais precisam ser inicializadas (cuidado com if sem else)
- Cuidado com variveis de escopo de bloco de cdigo sendo usadas depois
do bloco
- Cuidado com variavel declarada no if e usada no else (analogo para
outros blocos)
- Var de referencia locais tambm precisam ser inicializadas (apontar um
objeto ou null)
- Cuidado com sombreamento: sempre vale a local
- No pode sombrear variavel local com variavel de bloco
- Declarando e inicializando arrays:
int x[] = new int[3];
int x[] = {1,2,3}
int x[] = new int[] {1,2,3}
- No confundir propriedade length do vetor com mtodo length() da String
- Blocos de inicializao
Pgina 2
Resumo_Certificacao_SCJP_5.txt
. A ordem em que aparece faz diferena (executados de cima pra baixo)
. So estaticos (1 vez) ou instancia (1 vez por operador new)
. Executados antes do construtor
. Ordem de inicializao: bloco estatico pai, bloco estatico filho,
bloco instacia pai, construtor pai, bloco instancia filho, construtor filho
- Bloco de inicializao esttico: executado quando a classe carregada
(quando o primeiro objeto da classe criado)
static { //comandos }
- Bloco de inicializao de instncia: executado quando a classe instanciada
{ //comandos }
===============================================================================
MODIFICADORES
===============================================================================
- No pode abstract private, abstract final, abstract static
- Pode abstract protected
- Pode argumento final (no pode ser modificado dentro do mtodo)
- Pode variavel de referencia final (nao pode mudar o objeto a qual aponta)
- Cuidado com protected (acesso por herana = sim VS. acesso
por instancia = no) - depois se torna private para outras classes que
instanciem a subclasse pelo pacote da subclasse, mas normal se for pelo
pacote da superclasse
===============================================================================
OPERADORES
===============================================================================
- Diviso por zero (inteiros)
- Comparao apenas com booleanos
- Cuidado com Inteligente (&& , ||) vs. Burro (& , |)
- Cuidado com ps-incremento e pr-incremento
- Deslocamento de bits
<< Desloca para esquerda completando com zero
>> Desloca para direita, completando com o que estava antes
>>> Desloca para direita, completando com zero
Manipulando Binarios Negativos:
. Inverte tudo
. Soma 1
. Faz a conta especificada
. Se continuar negativo (mais significativo 1), inverte tudo
e soma 1
. Se tornar-se positivo (mais significativo 0), j o valor
- Operador ternario condicional sempre precisa os tres pedaos
- Operadores atribuio fazem converso implcita
byte b = 3;
b += 7; //OK
b = b + 7; //ERRO - precisa de (int)(b + 7)
- Ateno:
String x = null;
x instanceof String; // sempre false
null instanceof String; // sempre false
- Cuidado com concatenao misturada com soma (precedencia da esquerda
para direita)
Pgina 3
Resumo_Certificacao_SCJP_5.txt
- Cuidado com 5 && 6 (no pode - 5 & 6 pode)
===============================================================================
ESTRUTURAS DE CONTROLE
===============================================================================
- Switch s pode verificar variveis promovveis para int
- Cases do switch podem apenas valores constantes inteiros ou enum
(nunca variveis)
- Variveis inicializadas no for servem apenas para o for
- Pode ter um for vazio (;;;)
- Break pode apenas em switch e nas estruturas de repetio (sai da estrutura)
- Continue pode apenas nas estruturas de repetio (prox. iterao)
- Em caso de rtulos no break ou continue, vale e estrutura rotulada (cuidado
com rtulos perdidos no meio do cdigo - vale somente para os laos)
===============================================================================
STRINGS E STRINGBUFFER
===============================================================================
- Cuidado:
String tem mtodo lenght(), portanto com os parnteses
Vetor tem propriedade lenght, portanto sem os parnteses
- String so objetos, portanto imutveis
- Quando "mudamos" uma string, na verdade criamos um objeto novo e
redirecionamos a referncia a ele, onde o anterior ir pra coleta de lixo
- Exemplo:
String s1 = "spring"; //um objeto - uma referncia

String s2 = s1 + " summer"; //trs objetos
//(spring, summer e spring summer) - duas referncias
//(summer perdido)
s1.concat(" fall");
System.out.println(s1); //imprime spring
System.out.println( s1.concat(" fall") ); //imprime spring fall
s1 = s1.concat("fall");
System.out.println(s1); //imprime spring fall
- Pool de Strings: rea reservada na memria onde a JVM guarda todas as
strings literais. Quando criada uma string literal, a JVM analisa o pool
e observa se j tem uma idntica. Se j tiver, ao invs de criar outra,
ele s duplica sua referncia usando a varivel definida.
//supondo que aqui no h nenhuma string no pool
String s = "abc"; //cria um objeto string abc, inserido-o no pool
//e s o referenciar
//supondo que aqui no h nenhuma string no pool
String s = new String("abc");
//cria dois objetos string abc, um na memria
//comum (operador new) e um no pool ("abc"), e s referenciar o da
//memria, que por sua vez refenciar o do pool
- Mtodos interessantes
String y;
String x = "0123456789";
y = x.substring(5); //comea no ndice 5 e vai at o fim -> 56789
Pgina 4
Resumo_Certificacao_SCJP_5.txt
y = x.substring(5, 8);
//comea no ndice 5, pegando 8-5 = 3 caracteres -> 567

String w = " giba holms ";
w = w.trim(w); //remove espaos -> gibaholms
- StringBuffer: trabalha a String sobre ela mesma, e no fica perdendo
espao gravando no pool:
StruingBuffer sb = new StringBuffer("abc");
sb.append("def");
System.out.println(sb); //imprime -> abcdef

===============================================================================
CLASSES E OBJETOS
===============================================================================
- Para acessar estaticos, usar o nome da classe (ou um objeto j instanciado)
- No pode usar operador this dentro de mtodos estticos
- Para chamar outros construtores, pode usar this() ou super() apenas na
primeira linha de um constutor
- Um objeto que referencia outro da mesma classe, pode acessar os
membros private !!!!
- " Um" VS. "Tem Um"
. Um = extends e implements
. Tem Um = varivel de referncia
- Encapsulamento - benefcios:
. Clareza do cdigo
. Possibilidade de adicionar novas funcionalidades e validaes
. Facilidade de manuteno
- Encapsulamento - no benefcios
. Eficincia / performance do cdigo
- Herana
. -um = abaixo na relao de herana
. Tem-Um = operador new
. Override
. Overload
. Pode override de varivel
- Acoplamento: baixo = classes fornecem apenas servios, independentemente da
implementao
- Coeso: alta = classe que faz uma tarefa bem especfica
===============================================================================
OVERRIDE vs. OVERLOAD
===============================================================================
- Override:
. No pode mudar tipos do parmetro nem retorno
. Excees: podem ser reduzidas ou eliminadas (se no forem
verificadas, no importa)
. Acesso: no pode reduzir acesso
- Overload
. Deve mudar tipos do parmetro
. Parametros apenas em ordem diferente j overload
. Por ser um mtodo diferente, no possui outras restries
. Para parmetro passado como objeto, o tipo da referncia que manda
. Para parmetros com overload, se a JVM no encontrar correspondencia
exata de tipo, ela usa o mtodo com o proximo mais amplo argumento
Pgina 5
Resumo_Certificacao_SCJP_5.txt
===============================================================================
CONSTRUTORES
===============================================================================
- Cuidado com mtodo com retorno, disfarado de construtor
- Construtor private faz com que a classe s possa ser instanciada dentro dela
mesma
- Pode contrutor protected, porm tambm limita quem pode instanciar
- No pode fazer uma chamada ao contrutor de dentro de um mtodo
- Cuidado com o construtor declarado com argumentos, que inibe o padro
(a no ser que seja explicitamente declarado)
- Cuidado com construtor da superclasse com argumentos (problema acima)
===============================================================================
INTERFACES
===============================================================================
- Mtodos so public abstract
- Atributos so public static final (ou seja, so CONSTANTES - no podem
alterar seu valor durante o codigo)
- No pode ter mtodos static
- No pode ter mtodos final, native, strictfp ou synchronized
- Mtodos no podem ser declarados com private ou protected
- Pode extends interface (ou mais de uma interface)
- No pode implements nada
- Pode ser declarada como public abstract interface
- Como classes, pode ser public ou default
- Cuidado com classe concreta que no implementa mtodo abstrato da interface
quando uma superclasse dela j o fez (vlido)
===============================================================================
CLASSES ABSTRATAS
===============================================================================
- Apesar de no serem instanciadas, podem ter construtor (executado quando
uma herdeira instanciada)
- Apenas um mtodo abstract contamina toda a classe como abstract
- Classe abstrata herdando de classe abstrata no precisa implementar mtodos
- Cuidado com classe concreta que no implementa mtodo abstrato da classe
abstrata quando uma superclasse dela j o fez (vlido)
===============================================================================
POLIMORFISMO
===============================================================================
- Cuidado com erros de downcasting (uso do instanceof)
- Operador instanceof = -UM
- Cuidado com ClassCastException - erro de runtime (ateno para se uso
com operadores lgicos de abreviao)
===============================================================================
MEMBROS ESTATICOS
Pgina 6
Resumo_Certificacao_SCJP_5.txt
===============================================================================
- Mtodo estatic s pode acessar membros tambm static
- Mtodo Static pode ser "redefinido" (um pouco diferente de sobrescrito,
pois no existe super.metodo )
===============================================================================
COLETA DE LIXO
===============================================================================
- System.gc()
- Nunca garantida a execuo
- Pode executar o mtodo finalize() apenas uma vez, e no garante quando
- Objeto elegvel = referncia null
- Cuidado com "ilhas de isolamento" - tambm ficam elegveis
===============================================================================
CLASSES WRAPPER
===============================================================================
- Todas exceto Character tem construtor com argumentos: String e seu literal
primitivo
- Character aceita apenas o seu literal primitivo
- No possuem construtor padro ()
- Mtodo valueOf( String, base ) - esttico - retorna um objeto wrapper do
objeto utilizado
- Mtodo xxxValue() - retorna o tipo primitivo do wrapper
- Mtodo parseXXX(String) - esttico - retorna o primitivo da String no
parmetro
- Todos tm valueOf() exceto Character
- Todos tm parseXXX(String) exceto Character e Boolean
- Todos tm xxxValue() exceto Character e Boolean
- Apenas Integer e Long possuem toXXXString( primitivo ) - esttico - retorna
string com base XXX
- Mtodo equals() em wrapper: so iguais se tiverem mesmo tipo e mesmo valor
- Classes wrapper no tem relao herana, ou seja, "Short NO -um Integer"
- Todas as classes Wrapper tem como PAI comum a interface Number
- Observaes
Byte n1 = new Byte(2); //ERRO !!!!
Byte n1 = new Byte((byte)2); //OK
Byte n1 = new Byte("2"); //OK
Number n1 = new Byte("2"); //OK

===============================================================================
EXCEES
===============================================================================
- Posso pegar (catch) toda a hierarquia de erros (Throwable, Error,
Exception ou RuntimeError), obedecendo o polimorfismo
- O erro passado de mtodo para mtodo at achar um catch, ou chegar no fim
Pgina 7
Resumo_Certificacao_SCJP_5.txt
do programa. Ele vai finalizando os mtodos na ordem da pilha
- Pode-se fazer novas excesses extendendo as classes de erro
- Quando se lana uma Exception ou qualquer subclasse dela (exceto
RuntimeException), OBRIGATRIO captur-la com o catch, ao menos que o mtodo
contenha Trhows Exception na assinatura
- Error e RuntimeException no so obrigatrios o seu catch
- Mesmo que o mtodo no lance erros, se tiver throws Exception na assinatura,
s pode ser chamado dentro de um try catch
- Qualquer comando abaixo de um Throw, erro de compilao
- Na assinatura da classe, s tem sentido utilizar "Throws Exception", que serve
para repassar o tratamento da Exception (que seria obrigatrio) para o mtodo
seguinte na pilha (ento ser obrigatrio neste mtodo)
- try precisa estar colado com um catch ou um finally. Tambm no pode catch nem
finally voando.
- Cuidado com um metodo que lanca Exception dentro de um finally. Ele precisa
ser tratado tambm
- erro de compilao dois catch capturando a mesma classe de excesso no
mesmo try
- No pode um catch mais abrangente em cima de um menos abrangente
===============================================================================
ASSERTIVAS
===============================================================================
- assert(condio):"Descrio de debug";
- S compilando com -source 1.3 pode usar a palavra assert como identificador
- Uso inapropriado de assertivas:
. Verificar argumento de mtodo pblico
. Verificar argumento da linha de comando
. Verificar default de switch
. Chamar um mtodo dentro dela

===============================================================================
CLASSES INTERNAS
===============================================================================
- Tipos: comum, local de mtodo, annima e estatica
- Ateno com modificadores de acesso. Para ser acessada externamente, precisa
ser visivel tanto a externa quanto a interna
- Comum:
. Instancia na mesma classe:
Interna i1 = new Interna(); //normal
. Instancia por outra classe:
Externa e1 = new Externa();
Externa.Interna i1 = e1.new Interna();
//ou...
Externa.Interna i2 = new Externa().new Interna();
. Para instanciar, precisa de uma instancia da externa
. Portanto, no pode ser usada em mtodo esttico da externa
Pgina 8
Resumo_Certificacao_SCJP_5.txt
. Sombreamento de variveis:
Externa.this.x; //externa
this.x; //interna
x; //local do metodo
- Local de Mtodo:
. S pode ser instanciada dentro do mtodo que a contm, e depois de
sua definio (abaixo dela)
. S pode utilizar variveis locais do mtodo que a contm se forem
"final"
. Pode utilizar as variveis de instancia da classe externa total
. Se o mtodo for esttico, s poder acessar membros estticos da
classe externa
. S pode ser abstract ou final
- Anonimas - herdando de classe

class Popcorn { }
Popcorn p = new Popcorn() {
//classe herdeira anonima
};
. Isso acima uma classe annima herdeira (subclasse) de uma Popcorn
j existente
. Valem as regras da herana e do polimorfismo
. Cuidado com a falta do ponto-e-virgula (;) no final
- Anonimas - implementando interface
interface Cookable { public void cook(); }
Cookable c = new Cookable() {
public void cook() { //implementao
}
};
. Modo curioso de se "instanciar uma interface". Na verdade estamos
criando uma classe interna annima que implementa ela
Runnable r = new Runnable(); //ERRADOOOOOOOOOOo
Runnable r = new Runnable() { public void run() {} }; //CORRETO
. Cuidado com a falta do ponto-e-virgula (;) no final
- Anonimas - em argumento
interface Cookable { public void cook(); }
class Kitchen {
public void cook(Cookable c) { }
}
public class Argumento {
public static void main( String [] args ) {
Kitchen k1 = new Kitchen();

k1.cook( new Cookable() {
public void cook() {}
}
);
}
Pgina 9
Resumo_Certificacao_SCJP_5.txt
}
. Cuidado para no esquecer o parnteses ")" e o ponto-e-vrgula ";"
no final
- Classes Internas Estticas
. um "membro esttico" da classe externa
. Instancia na mesma classe:
InternaEstatica ie1 = new InternaEstatica(); //normal
. Instancia por outra classe:
Externa.InternaEstatica ie1 = new Externa.InternaEstatica();
. Logicamente no pode acessas membros no-static da classe externa
. Pode ter membros comuns dentro dela, como qualquer outra

===============================================================================
COLEES
===============================================================================
- Se sobrescrever "public boolean equals(Object o)", precisa sobrescrever
"public int hashCode()"
- Interface Collection - possui as interfaces derivadas Set, List e Queue
- Interface Map no pertence interface Collection
- Classe java.util.Collections - possui mtodos utilitrios static para serem
usados nas colees
- No confundir Collections com Collection
- Ordenado: armazenados numa ordem especfica
- Classificado: assumem sua ordenao de acordo com uma regra especfica
(ex. strings em ordem alfabtica)
- Interface LIST
. Permite duplicatas
. Funciona em funo de um ndice, como um vetor
. Ordenada pelo ndice
. ArrayList: ordenado pelo ndice
. Vector: um ArrayList sincronizado
. LinkedList: ordenado por encadeamento (ordem de insero)
- Interface SET
. No permite duplicatas
. Depende da implementao do mtodo equals()

. HashSet: no-classificado e no-ordenado
. LinkedHashSet: ordenado por encadeamento (ordem de insero)
. TreeSet: ordenado e classificado pela ordem natural dos elementos
- Interface MAP
. Duplas chave/valor - tabela de hash
. A chave no pode ser repetida
. Permite chave null
. Depende da implementao do mtodo equals()

. HashMap: no-classificado e no-ordenado
. Hashtable: um HashMap sincronizado
. LinkedHashMap: ordenado por encadeamento (ordem de insero)
. TreeMap: ordenado e classificado pela ordem natural dos elementos

===============================================================================
Pgina 10
Resumo_Certificacao_SCJP_5.txt
THREADS
===============================================================================
- S vale extender Thread e instanciar normal, ou implementar Runnable e enviar
como construtor para uma classe Thread
- Assinatura vlida:
public void run() {}
public synchronized void run() {} //porm sincroniza apenas
//uma instncia
- Chamar run() executa na pilha atual. Para ser Thread, precisa chamar start()
- Cuidado! Chamar start() sempre numa instncia de Thread, no de Runnable
- Thread.currentThread() retorna uma instncia ao Thread atual. STATIC
- erro de execuo chamar o mtodo start() mais de uma vez na mesma
referncia. (IllegalThreadStateException)
- Mtodos que lanam excesso verificada:
Thread.sleep()
Thread.sleep(long mili)
join()
join(long mili)
wait() - de Object
wait(long mili) - de Object
- sleep() fora o Thread atual para estado de suspenso. Ele mantm seus
bloqueios. STATIC
- Prioridade padro igual a prioridade do Thread que o criou
- yield() faz o Thread atual voltar ao pool dando chance a outro de mesma
prioridade (no garante nada) STATIC
- join() = "me anexe ao final de", ou seja, s executa quando o expecificado
terminar
- Modificador synchronized = s para mtodos. Impede que dois Threads acessem
o mtodo simultaneamente, o que corromperia variveis de instncia. Bloqueia
o objeto atual. Outro Thread s poderia acessar quando o bloqueio for
liberado (fim do mtodo sincronizado)
- synchonized importante apenas para Threads que utilizam mesmas instncias
de objetos
- Bloco synchronized = qualquer bloco. Bloqueia o objeto entre parnteses
synchronized(this) { }
- synchronized X static synchronized
Pgina 11