|
Certificação
de Programador Java 5.0
Tudo sobre
a atualização da prova mais famosa
do mercado
O
Java 5.0 está próximo de fazer seu
segundo aniversário, e sua certificação
está há mais de um ano disponível
no mercado. Já não é hora de
fazer uma atualização? Apresentamos
aqui os novos tópicos, juntamente com os
detalhes que você deve ficar mais atento.
A primeira versão
da certificação de programador era
voltada à versão 1.2 do Java, em que
até conceitos e a API do java.awt faziam
parte dos tópicos. A versão 1.4 eliminou
grande parte da necessidade de decorar classes e
métodos da API, tornando-a mais ágil
e conceitual.
Um ano atrás, a Sun lançou a versão
da prova para o Java 5.0 (código CX-310-055)
e hoje muitos programadores estão fazendo
esta nova certificação. E quem já
é certificado, tem a opção
de fazer a prova de atualização.
A edição número 6 da revista
MundoJava trazia um artigo sobre a prova 1.4, juntamente
com um simulado. Aqui, fazemos uma revisão
dos novos conceitos do Java 5, apontando onde você
deve prestar mais atenção durante
seu estudo para a certificação.
No final do artigo, veja alguns exercícios
importantes e depoimentos de profissionais que estão
no mercado sobre a certificação.
Como
é a prova?
Os tópicos
da prova incluem praticamente todos os da versão
1.4, com exceção dos operadores de
deslocamento (shift - <<, >>, >>>).
Novas APIs são cobradas, como java.util com
mais profundidade, além da volta do java.io,
que havia sido retirado da antiqüíssima
versão 1.2. Veremos os tópicos mais
adiante.
A mudança mais significativa é a dificuldade
da prova. Na prova 1.4, você precisa fazer
52% de 61 questões em 2 horas. Já
na 5.0, você precisa fazer 59% de 72 questões
em 2 horas e 55 minutos. E esta dificuldade não
está apenas no quesito da porcentagem a ser
atingida, nem no tamanho da prova, as questões
conceituais estão mais difíceis e
os códigos mais longos (algumas questões
têm códigos de mais de 30 linhas).
A sintaxe usada é mais rebuscada, muitas
questões abusam de classes anônimas,
além de nomes de classes métodos e
atributos obscurso (tais como class A1, class Z)
para testar especificamente seu conhecimento da
linguagem, sem se prender ao uso do dia-a-dia. Além
dessas novidades, atualmente existe a possibilidade
de fazer essa prova em português.
A seguir, mostraremos os principais tópicos
e atualizações da nova prova em seções
com diversos exemplos. Não se assuste principalmente
com a parte de Generics, que é a mais difícil
da preparação para a prova.
Não
há mais a necessidade de colocar um inteiro
dentro de um Integer para passá-lo a um método
que precisa receber Integer ou mesmo Object. Repare:
Integer i = 5;
Object o = 7;
int x = i;
Collection c = new HashSet();
c.add(3);
Pode
até parecer, mas tipos primitivos não
são referências. O que ocorre é
que quando o compilador percebe que não vai
funcionar, ele tenta colocar ou tirar o objeto de
sua respectiva wrapper, algo como:
Integer i = Integer.valueOf(5);
Object o = Integer.valueOf(7);
int x = i.intValue();
Podemos
utilizar o mesmo recurso em comparações,
o que antes do Java 5 também resultaria em
erro de compilação:
Integer i = new Integer(5);
x = 4;
if(x < i) {
}
No código
anterior, o compilador vai chamar o métido
intValue da classe Integer. Cuidado! Caso o Integer
seja null, haverá aí um NullPointerException.
Exemplo:
Integer x = null;
array[x] = 5;
Mas e
no código a seguir, o que acontece?
Integer i = new Integer(5);
Integer j = new Integer(5);
if(i == j) {
}
Retornará
false, pois não há a necessidade do
unboxing para compilar. Tudo o que funcionava no
Java 1.4 tem, obrigatoriamente, que funcionar de
maneira idêntica no Java 5. Caso contrário,
uma atualização de virtual machine
poderia mudar o comportamento de um programa, quebrando
a compatibilidade retroativa tão prezada
pelo Java. Você vai reparar que essa regra
pode causar certo desconforto e estranheza em diversas
funcionalidades novas, mas lembre-se de que tudo
faz sentido, basta seguir a especificação.
Podemos usar também operadores como ++, lembrando
que um novo objeto irá ser criado, sendo
uma péssima opção para laços.
O seguinte código não compila:
Double d = 0;
O autoboxing
de um int é feito com Integer, e Integer
não é um Double.
Já o seguinte trecho compila:
Double d = 0.0;
Um ponto
importante é o lookup de método, ou
seja, o compilador dará prioridade para os
que não necessitam de boxing ou unboxing,
para não acontecer diferente de como seria
no Java 1.4. Como exemplo, analise o código
a seguir:
void metodo(double
d) {}
void metodo(Integer x) {}
metodo(5);
Pode
parecer contra-intuitivo, mas essa chamada irá
invocar o primeiro método declarado, já
que não necessita do boxing. O motivo aqui
também é a compatibilidade. Essa chamada
no Java 1.4 executaria o primeiro método,
então continuará assim.
Varargs é a abreviação
de número de argumentos variáveis.
Se você precisa de zero ou mais argumentos
de um mesmo tipo em um método, basta utilizá-lo.
Na prática, esse argumento é uma array
de objetos. Veja:
public static void main(String ...
args) {
String[] array = args;
}
No código anterior,
args realmente é uma referência para
array e sendo assim você pode fazer um for
em args usando o args.length, ou mesmo usar o enhanced
for. A invocação desse método
main pode ser feita de várias maneiras:
main(); // será enviado array
de length 0
main(“a”); // será enviado array
de length 1
main(“a”, “b”, “c”);
// será enviado array de length 3
Em todos os casos, uma
array será criada e nunca null será
passado. Um parâmetro
varargs deve ser sempre o último da assinatura
do método para evitar ambigüidade. Isso
implica em que apenas um dos parâmetros de
um método seja varargs.
Repare que aqui também será dada a
prioridade para o método que já podia
existir antes no Java 1.4:
void metodo(int ... x) { }
void metodo(int x) {}
metodo(5);
No código anterior,
o segundo método será invocado. É
a mesma questão de compatibilidade já
apresentada na seção de autoboxing.
Leia
o artigo completo na revista MUNDOJAVA, já
nas bancas!
|
