Agora eu sou SCJP!!

Quero pedir desculpas pela minha ociosidade repentina mas é que eu estava na minha semana decisiva. Fiz a prova da certificação ontem e obtive 83% \o/. Acertei 60 das 72 questões, um resultado além do meu esperado. A prova estava bem tranquila mas é lógico que eu estudei pra caramba pra fazer. Então em breve estaremos postando novos artigos sobre a SCJP, agora que estou mais experiente vai ficar ainda melhor. um abraço e até o próximo post.

Novidades do Java 5.0: Enums

Hoje iremos aprender mais um assunto novo para a prova de certificação java 5.0: os enums. Podemos entender enums como tipos de constantes. Por exemplo: SEGUNDA, TERCA, QUARTA...etc, podem ser iplementados como constantes ou membros de um enum chamado DiasDaSemana. Enums ajudam bastante os programadores a tornar seus códigos mais claros e com menos possibilidades de bugs.

Para definir um enum usamos a palavra chave enum, por exemplo, o nosso enum descrito acima ficaria assim:

public enum DiasDaSemana {

DOMINGO, SEGUNDA, TERCA, QUARTA, QUINTA,

SEXTA, SABADO

}

Um enum pode ser declarado em uma classe própria ou ainda dentro de uma classe. Vejamos como é isso:

enum DiasDaSemana {

DOMINGO, SEGUNDA, TERCA, QUARTA, QUINTA,

SEXTA, SABADO

}

class Calendario {

enum Meses {

JANEIRO, FEVEREIRO, MARCO

//OUTROS MESES AQUI

}

DiasDaSemana dia;

Meses mes;

}

public class UsandoCalendario {

public static void main(String... args){

Calendario c = new Calendario();

c.dia = DiasDaSemana.SEGUNDA;

c.mes = Calendario.Meses.JANEIRO;

}

}

Apesar de enum ser um classe (é isso mesmo) um enum não é instanciado diretamente como as outras classes em java (usando new por exemplo), basta chamar uma de suas 'constantes'. A ordem dos elementos de um enum é importante e uma coisa importante também é que nada pode ser declarado antes delas. Bom, você pode declarar variáveis em um enum, mas elas precisam vir após a declaração dos elementos. Por exemplo:

enum DiasDaSemana {

private boolean diaUtil; // erro!

DOMINGO, SEGUNDA, TERCA, QUARTA, QUINTA,

SEXTA, SABADO

}

O correto seria:

enum DiasDaSemana {

DOMINGO, SEGUNDA, TERCA, QUARTA, QUINTA,

SEXTA, SABADO; // o ; é obrigatório caso declare algo depois

private boolean diaUtil;

}

Enums também pode ter construtores. Porém eles não são acessíveis fora da definição do enum. Podemos usar os construtores para inicializar algum tipo de variável ou valor default para um enum. Por exemplo:

enum DiasDaSemana {

DOMINGO(false), SEGUNDA(true), TERCA(true), QUARTA(true), QUINTA(true), SEXTA(true), SABADO(false);

// o ; é obrigatório caso declare algo depois

private boolean diaUtil;

DiasDaSemana(boolean util){

this.diaUtil = util;

}

public boolean isDiaUtil(){

return this.diaUtil;

}

Enums também pode ser utilizados com a estrutura de switch. Como no exemplo abaixo:

public enum Luas {
          CHEIA, CRESCENTE, MINGUANTE, NOVA
}

.... definição da classe
Luas l = Luas.NOVA;
switch(l) {
             case CHEIA: //codigo aqui
             case CRESCENTE: //codigo aqui
             case MINGUANTE: //codigo aqui
             case NOVA: //codigo aqui
             default: //codigo aqui
}

Até o próximo post.

Novidades do Java 5.0: Varargs

Suponhamos que você deseja criar um método que faz a soma dos inteiros passados como parâmetros nele. Como você faria isso antes do java 5? Bem, teríamos que fazer algo do tipo:

public int somar(int a) {
 return a;
}

public int somar(int a, int b) {
 return a + b;
}

public int somar(int a, int b, int c){
 return somar(a,b) + c;
}
...

O problema é que para conseguir suportar mais argumentos você teria que criar mais métodos sobrecarregados, tornando a sua classe gigante e difícil de manter. A partir do java 5 ficou muito mais fácil criar essa funcionalidade. Através da sintaxe de argumentos variáveis ou varargs. Então os métodos que nós escrevemos antes ficariam todos resumidos em um método assim:

public int somar(int... args) {
int total = 0;
for (int i = 0; i < args.lenght; i++)
total += args[i];
return total;
}

chamadas válidas ao método
System.out.println(somar()); imprime 0
System.out.println(somar(1)); imprime 1
System.out.println(somar(1,2)); imprime 3
System.out.println(somar(1,2,3)); imprime 6

Acho que você notou que o argumento variável nada mais é que um array de objetos ou de primitivos do tipo informado no parâmetro né? Só que o recurso é mais interessante porque me dá a flexibilidade de passar quantos parâmetros eu quiser sem precisar declará-los em um array. Agora vejamos as regras do varargs:

1. Todo vararg tem um tipo definido. Como no nosso exemplo o tipo foi int.
2. Para definir que o parâmetro é vararg use ... (três pontinhos) depois do tipo. Cuidado para não confundir com a sintaxe de arrays, ainda não vimos arrays mas vamos adiantar a sintaxe aqui: um array pode ser definido: int[] a ou int a[]. Um vararg só pode ser int... a e NUNCA int a...
3. Eu posso ter vários parâmetros junto com o vararg, porém só posso ter um ÚNICO vararg como parâmetro e este precisa ser OBRIGATORIAMENTE o último deles. Assim é válido ter: public void somar(String msg, int... a); mas é inválido: public void somar(int... a , String msg);

Por último devemos saber que acessamos vararg como se tivéssemos acessando um array do tipo informado. Assim você pode usar qualquer estrutura de laço ou índice, como for por exemplo.
Até o próximo post.

Declarando Variáveis de Classe

No post anterior vimos como declarar variáveis locais. Vimos que normalmente o escopo de uma variável local é o método ou a estrutura onde ela foi declarada (por ex. um for) e vimos ainda que elas só aceitam o modificador final.
Agora iremos aprender o que são e como usar variáveis de classe. Uma variável de classe nada mais é do que uma variável que tem o seu escopo na classe na qual ela foi criada. Isso quer dizer que ela vive enquanto a classe estiver viva (ou na memória né...). Você define uma variável como sendo de classe utilizando o modificador static. Uma variável estática pode ser acessada diretamente através da classe, ou seja, eu não preciso ter um objeto (ou uma instância de um) para acessar a variável, só preciso utilizar ClassName.variableName. Vamos dar um exemplo:

public class Carro {
   public static String cor = "Azul";
}

public class TesteCarro {
   public static void main(String args[]){
         Carro c = new Carro();
         System.out.println(Carro.cor); //classe
         System.out.println(c.cor);     //objeto
   }
}

Note que não criamos um objeto Carro, simplesmente chamamos a variável cor através da classe Carro (claro que isso foi possível também porque cor é uma variável pública). Você pode também acessar uma variável de classe através de uma instância da classe, pois todas as instâncias compartilharão a mesma variável, já que ela pertence à classe. Então eu sugiro que você sempre acesse via classe mesmo e não via objeto, até para deixar seu código mais claro.
Até o próximo post.

Declarando Variáveis Locais

Um dos tópicos da seção 1 diz que o programador deve desenvolver código que declare, inicialize e use variáveis locais. Neste post iremos falar um pouco sobre elas. Já vimos vários modificadores de acesso. Vimos que eles são aplicados em membros de uma classe (que podem ser métodos ou variáveis). Toda variável possui um escopo. Escopo a gente aprendeu na 1ª série que nada mais é do que o limite até onde essa variável pode ser acessada (cuidado pra não confundir com encapsulamento). No java variáveis podem ser de 3 tipos:

• Locais ou de métodos
• De classe
• De instância

Uma variável local ou de método tem o seu escopo limitado ao método ou bloco (por exemplo um for) em que ela foi definida. A sua vida se resume ao local delimitado pelas chaves em que ela foi criada. Por exemplo:

public void mostrarNome(String nome) {
      int a = 10;
      System.out.println(nome);
}

As variáveis 'a' e 'nome' são variáveis locais. O escopo delas está limitado as chaves que abrem e fecham o método mostrarNome. Isso significa que após a última chave, elas simplesmente não existirão. Podemos ter também algo do tipo:

public void contarAte(int contador) {
    for (int i =0; i <= contador)          System.out.println(i);            }            System.out.println(i); }           

Quantas variáveis locais temos aí? Quem disse 2 acertou na mosca. São elas: 'contador' e 'i'. A variável 'i' é uma variável local também, só que o seu escopo está limitado ao laço for no qual ela foi criada. Então isso significa que esse código não compilaria pois estamos tentando acessar a variável 'i' fora o seu escopo, pois o compilador não enxerga mais a varíavel após a última chave do for. Já a variável contador seria perfeitamente acessível daí, já que o seu escopo é o método todo.
Mas eu falei de modificadores de acesso no começo deste post, o que tem a ver com as variáveis locais? Tem tudo a ver. Ou por que não dizer "não tem nada a ver". Isso porque as variáveis locais só aceitam um único modificador de acesso: final. O modificador final quando aplicado a uma varíavel local diz que o valor da variável não pode ser modificado após a sua inicialização. Então se fizéssemos algo do tipo:

public void contarAte(final int contador) {
    contador = 100; //erro
    ...
}

Esse código não compila, pois a varíavel contador não pode ter o seu valor alterado pois ela é uma variável final. O modificador final pode ser usado em java para definir constantes, apesar de uma das palavras chaves da linguagem ser a palavra const, ela não é utilizada. Assim você diz que uma variável é uma constante aplicando a ela o modificador final.
Para finalizar você precisa saber que uma variável local precisa ser OBRIGATORIAMENTE inicializada antes de ser utilizada. E você precisa garantir que ela o será, caso contrário o seu código não irá compilar.

public void exibeResultado(boolean exibe) {
      String resultado;
      if (exibe)
               resultado = "Fui iniciada?";
      System.out.println(resultado);
}

Você pode achar que o compilador vai ser legal com você e aceitar que se o parâmetro exibe for true a variável resultado será inicializada e poderá ser utilizada. Mas ele não vai aceitar isso. Ele vai reclamar para você que a variável resultado pode não ser inicializada. Lembra que eu falei que você tinha que garantir que ela o seja? Para corrigir o trecho acima basta fazermos:

public void exibeResultado(boolean exibe) {
      String resultado;
      if (exibe)
               resultado = "Fui iniciada?";
      else
               resultado = "Com certeza";
      System.out.println(resultado);
}

Agora sim, o compilador se dará por satisfeito e compilará o seu código. Resumindo o que vimos:

• Variáveis locais só podem ser marcadas como final.
• Variáveis locais TEM que ser inicializadas antes do seu uso.

Até o próximo post.

Windows Explorer com abas e muito mais

Se você assim como acha que o Windows Explorer do XP é uma porcaria, então esse programa foi feito pra você também! O ExplorerXP permite você navegar nos arquivos e pastas do seu windows e oferece uma série de recursos extras. Você pode clicar aqui e ver as vantagens de usar o software e também pode fazer o download. O programa é bem pequeno (apenas 410KB) e consome pouca memória ao ser ativado. O melhor de tudo é que ele não afeta o seu Windows Explorer. Você pode usar os dois independentemente.

Abaixo você pode ver um screeshot do programa.