Alguém pode me explicar o que é isto no JAVA?

Programação Java
#1

Opa.

Estou fazendo um trabalho em JAVA e peguei um código de um professor e encontrei o seguinte no código:

public class Teste extends UmaClasseQueNaoTenhoFontes{

  {variavel = true;}

}

Não entendi o que isso faz… só sei que essa variável vem desta classe que não tenho os fontes e que ela está como protected.

Se alguém puder me ajudar, valew!

#2

Olá Puri.

Neste caso a classe teste herda a propriedade varrável da UmaClasseQueNaoTenhoFontes e define um bloco de código para então dar um valor a ela, no caso true.

blocos de código são como metodos sem nome que serão executados em sequencia quando sua classe for criada, antes mesmo até dos construtores.

#3

São blocos estáticos.

#4

[quote]
Um bloco estático em JAVA começa com palavra chave static e todo o código
colocado entre as chaves é considerado um bloco de inicialização estático.
Um bloco estático pode estar em qualquer lugar dentro da classe e pode conter
código tão complexo quanto se queria. Também podemos ter mais de um bloco
estático dentro de uma classe.
Os blocos estáticos são executados antes mesmo do construtor da classe, isso
permite que se inicialize variáveis estáticas ou trechos de código antes do
objeto existir.
As variáveis que são declaradas dentro de um bloco estático pertencem ao escopo do bloco estático [/quote]

fonte: http://www.portaljava.com/home/modules.php?name=Content&pa=showpage&pid=33

Att,

Ricardo Cabral

#5

Não é bloco estático, é apenas um bloco de código qualquer, se fosse estatico ele não teria acesso a variavel da super-classe. e seria rodado apenas na primeira vez que a classe fosse referenciada.

Neste caso toda vez que uma nova classe for criada new Teste(), ele será executado

#6

Não é um bloco statico pois o mesmo vem precedido da palavra static, é um bloco de código de instância.
A diferença é que o bloco estático é executado apenas uma vez durante a execução do programa quando a primeira declaração da classe é encontrada,e o bloco de código de instânciaé executado a cada instância da classe.
O bloco estático vale para todas as classes e deve ter variáveis static dentro.

#7

Neste caso, como a palavra chave não está lá, é simplesmente um bloco de inicialização.

Esse trecho rodará antes do construtor e alterará o valor da variável de instância.

Particularmente, não é muito comum o uso. Por mim, até removeriam isso da linguagem (colocando, claro, uns warnings em algumas releases).

É uma forma também fazer um construtor simples para classes anônimas.

No exemplo abaixo, os atributos estão com os nomes de acordo com a sua ordem de inicialização.

[code]public class Exemplo {
private static int primeiro = 1;
private static int segundo;
private int terceiro = 3;
private int quarto;
private int quinto;

static {
segundo = 2;
}

//Esse é um bloco não estático. A classe pode ter mais
//de um desses e serão executados antes do construtor,
//na ordem em que aparecerem.
{
quarto = 4;
}

//Finalmente, o construtor!
Exemplo() {
quinto = 5;
}
}[/code]

#8

Para mim, esse código abaixo é exatamente igual.
Eu também falaria que é um bloco static, ou pelo menos funciona como um.
Assim como o Daniel falou…
estou papando mosca?

static {
       segundo = 2;
    }
 
    //Esse é um bloco não estático. A classe pode ter mais 
    //de um desses e serão executados antes do construtor, 
    //na ordem em que aparecerem.
    {
        quarto = 4;
    }
#9

Não são iguais. A diferença está justamente no fato do primeiro bloco de inialização ser estático, e o segundo não.

Isto é, o primeiro não terá acesso as variáveis não estáticas e executará quando o classloader carregar a classe, geralmente uma só vez no programa todo.

O segundo executará para cada objeto, pois serve para os atributos não estáticos. É mais como um construtor (inclusive, pode ser usado como um construtor simples de inner classes anônimas).

#10

Exemplo:

public class Test
  {
   public static int DEF;
   public static int DEF2 = 1;

   static
     { DEF = 2; }

   { DEF2 += DEF; }
  }

No código acima, a chamada abaixo:

Test.DEF;

Sempre resultará em 2.

Ao passo que Test.DEF2 será incrementado em 2 a cada chamada de new Test() feita durante a execução da JVM.

public class Testes
  {
   public Testes()
     {
       System.out.println(Test.DEF); // imprime 2
       System.out.println(Test.DEF2); // imprime 1
       new Test();
       System.out.println(Test.DEF2); // imprime 3
       new Test();
       System.out.println(Test.DEF2); // imprime 5
       new Test();
       System.out.println(Test.DEF2); // imprime 7
       new Test();
       new Test();
       System.out.println(Test.DEF2); // imprime 11
       System.out.println(Test.DEF); // imprime 2
     }
  }
#11

Muito obrigado pessoal! Me ajudou bastante. :slight_smile:

Valew!

#12