ENTENDENDO STATIC

Em 14/02/2003 , por Rafael Steil

Quando e porqu usar static? static uma das palavras-chave do J ava, e tambm motivo de muita
confuso e dvidas entre o pessoal que esta comeando. Alis, mesmo os mais experienciados
confundem-se s vezes em usar ela. O mtodo static mais famoso de todos o main. atravs dele que
vimos nosso primeiro programa em J ava nascer, e sempre via main que nossos programas criam vida.
Por definio da linguagem J ava, o mtodo main precisa necessariamente ter acesso public, ser static, no
retornar coisa alguma ( void ) e receber como argumento um array de String ( String args[] ):
1. public static void main(String args[])

Entendendo static
Como regra geral, tenha isso em mente: dentro de mtodos static somente possvel pode acessar outros
mtodos e variveis que tambm sejam static. Dentro do mtodo pode-se definir qualquer tipo de
varivel, static ou no. Caso seja necessrio acessar algum mtodo ou membro no-static, necessrio
criar uma instncia da classe e ento chamar o que quiser. J o contrario um pouco diferente: dentro de
membros no-static, possvel acessar tanto propriedades static quanto as no-static. O fato de ser preciso
primeiramente criar uma instncia da classe para s ento chamar algum mtodo no-static ou acessar
uma varivel comum dentro de um mtodo static deve-se ao fato que dentro dele no existe uma
referncia para o ponteiro this. O ponteiro this utilizado para referenciar propriedades da classe em que
estamos trabalhando. Por exemplo:
1. ...
2. // Varivel simples, para guardar o nome
3. private String nome;
4.
5. // Algum mtodo comum
6. public void meuMetodo()
7. {
8. this.nome ="Fulano";
9. }

No exemplo acima, this.nome = "Fulano" diz que estamos atribuindo ao membro da classe chamado
nome o valor "Fulano". O uso de this automtico, portando o exemplo acima poderia ser escrito
simplesmente da forma
1. ...
2. // Varivel simples, para guardar o nome
3. private String nome;
4.
5. // Algum mtodo comum
6. public void meuMetodo()
7. {
8. nome ="Fulano";
9. }


Note que agora no mais usamos this, e funciona da mesma maneira. Se o mtodo meuMetodo fosse
static, o cdigo acima no funcionaria, pois como foi dito antes, mtodos static no possuem this. Ao
contrrio do que o nome soa, static no significa que a varivel ou mtodo sera esttica do ponto de vista
que seu valor no pode mudar ( final usado para estes casos ). static nos garante que somente haver
uma, e no mais que uma, referncia para determinada varivel ou mtodo disponvel em mmoria. Em
outras palavras, declarando alguma coisa como static, todas as instncias da classe iro compartilhar a
mesma cpia da varivel ou mtodo. Declarar algo como static tambm permite voc acessar as coisas
diretamente, ou seja, sem precisar criar uma instncia da classe. Existe inclusive um Design Patter
baseado no uso de static: Singleton.
Exemplificando
Para entender melhor tudo o que foi dito, nada melhor que alguns exemplos prticos para ver com os
prprios olhos o funcionamento. O primeiro exemplo consiste em uma classe com 2 variveis, uma static
e outra no-static. A cada novo objeto criado, incrementados ambas variveis e imprimimos o resultado
na tela. Digite o seguinte cdigo em um arquivo chamado "TesteStatic.java":
1. // TesteStatic.java
2. class Classe1
3. {
4. // Variavel static
5. public static int contador =0;
6.
7. // Variavel nao-static
8. public int outroContador =0;
9.
10. public Classe1() {}
11.
12. // Precisa ser static porque "contador" static
13. public static void incrementaContador()
14. {
15. contador++;
16.
17. System.out.println("contador agora "+contador);
18. }
19.
20. public void incrementaOutroContador()
21. {
22. outroContador++;
23.
24. System.out.println("outroContador agora "+outroContador);
25. }
26. }
27.
28. public class TesteStatic
29. {
30. public static void main(String args[])
31. {
32. Classe1 c1 =new Classe1();
33. c1.incrementaContador();
34. c1.incrementaOutroContador();
35.
36. Classe1 c2 =new Classe1();
37. c2.incrementaContador();
38. c2.incrementaOutroContador();
39.
40. Classe1 c3 =new Classe1();
41. c3.incrementaContador();
42. c3.incrementaOutroContador();
43.
44. Classe1 c4 =new Classe1();
45. c4.incrementaContador();
46. c4.incrementaOutroContador();
47. }
48. }

A saida gerada por este programa ser
1. contador agora 1
2. outroContador agora 1
3. contador agora 2
4. outroContador agora 1
5. contador agora 3
6. outroContador agora 1
7. contador agora 4
8. outroContador agora 1

Note que a variavel "contador", que static, no teve seu valor zerado a cada novo objeto criado da classe
Classe1, mas sim incrementado, enquando "outroContador", que uma varivel comum, ficou sempre em
1, pois a zeramos o valor no construtor da classe.
Acesso direto
Ao contrrio de tipos de dados no-static, qualquer varivel ou mtodo static podem ser acessado
diretamente, sem necessitar de uma instncia da classe criada:
1. // TesteStatic2.java
2. class Classe2
3. {
4. // Escreve alguma frase na tela
5. public static void escreve(String msg)
6. {
7. System.out.println(msg);
8. }
9.
10. // Retorna a multiplicao de dois nmeros int
11. public static int multiplica(int n1, int n2)
12. {
13. return (n1 * n2);
14. }
15.
16. // Construtor, apenas para mostrar que
17. // ele nem chega ser chamado
18. public Classe2()
19. {
20. System.out.println("Construtor de Classe2");
21. }
22. }
23.
24. public class TesteStatic2
25. {
26. public static void main(String args[])
27. {
28. Classe2.escreve("Multiplicando 3 vezes 3:");
29. int resultado =Classe2.multiplica(3, 3);
30. Classe2.escreve("Resultado: "+resultado);
31. }
32. }

Rode este programa e repare no resultado. Veja que o construtor da classe no foi chamado, pois no
aparece na tela a string "Construtor de Classe2". Repare tambm que no criamos instncia alguma de
Classe2 para chamar seus mtodos. Caso os mtodos escreve e multiplica no fossem static, seria
necessrio fazer
1. public class TesteStatic2
2. {
3. public static void main(String args[])
4. {
5. Classe2 c2 =new Classe2();
6. c2.escreve("Multiplicando 3 vezes 3:");
7. int resultado =c2.multiplica(3, 3);
8. c2.escreve("Resultado: "+resultado);
9. }
10. }

Note que o cdigo acima funciona perfeitamente mesmo com os mtodos static. Isso funciona porque
apesar de podermos chamar diretamente as coisas quando elas so static, no obrigatrio, podendo
perfeitamente ser criada uma instncia da classe e ento chamar os mtodos. O uso de static depende
muito do caso, e conforme voc vai pegando mais experincia, ir naturalmente identificar os lugares que
precisam - ou que so mais convenientes - ao uso de tal palavra-chave. Caso tenha alguma dvida, no
hesite em postar no frum do GUJ . Abraos e at a prxima.