Métodos estáticos - qual a saida do código abaixo?

puts acho que vou debugar isso ai kkk

O código acima equivale a:

public class Foo {
    private static final int DELTA = 6;
    private static Foo instance;
    private static int BASE;
    static {
        instance = new Foo(); // neste momento, BASE ainda não foi inicializada para 7 - o valor ainda é zero
        BASE = 7;
    }
    private Foo () {
          x = BASE + DELTA;  
    }
    public static void main(String[] args) {
        System.out.println(Foo.instance.x);  // imprimirá 6
    }
}

po Andre pq o resultado foi 6 rs, tem como vc da uma explicada ai?

do jeito que ta o cod do entanglement eu entendi, mas do jeito do Andre nao, como vc desmembrou esse static entanglement?

static { instance = new Foo(); // neste momento, BASE ainda não foi inicializada para 7 - o valor ainda é zero BASE = 7; }

Regra bem simples:
a) Pegue todos os “static final” que são primitivos e deixe quietos. Eles são constantes e não são inicializados no bloco static, mas antes disso.

b) Crie um bloco static e copie as inicializações dos membros estáticos, uma por uma, na ordem em que aparecem na declaração da classe. Por isso, instance aparece antes de BASE.

puuuuuuuuuuta que pariu vc deu um tapa na cara do papa agora ehehe, vlw entanglement.

entanglement:

O código acima equivale a:

public class Foo {
    private static final int DELTA = 6;
    private static Foo instance;
    private static int BASE;
    static {
        instance = new Foo(); // neste momento, BASE ainda não foi inicializada para 7 - o valor ainda é zero
        BASE = 7;
    }
    private Foo () {
          x = BASE + DELTA;  
    }
    public static void main(String[] args) {
        System.out.println(Foo.instance.x);  // imprimirá 6
    }
}

é isso ai, vc achou o código aqui não foi?

quando inicializa o Foo o BASE está como 0 e como a constante nao é inicaliza no bloco estatico…

Me gerou uma duvida galera tem como me ajudar olha so:

se o codigo ficar assim a saida ficaria diferente? pq?

public static void main(String[] args) { System.out.println(new Foo().x);

Olhando o código abaixo

public class Foo {
	private static Foo instance;
	private static final int DELTA = 6;
	private static int BASE;
	private int x;

	static {
		System.out.println("entrando no bloco estatico");
		instance = new Foo();
		BASE = 7;

	}

	private Foo() {
		System.out.println("chamando construtor");
		System.out.println("valor de BASE:"+BASE);
		x = BASE + DELTA;
	}

	public static void main(String... argv) {
		System.out.println(Foo.instance.x);  //1
		System.out.println(new Foo().x);     //2
	}
}

Posso perceber que para a situacao 1 o construtor é chamado apenas uma vez, quando eu inicializo a variavel instance, o que é feito dentro do bloco estatico
Como quando eu faço isso a variavel BASE ainda está com o valor default de int (no caso 0) sera criado um objeto do tipo Foo que contem um valor x de 0 + 6 (constante)

Ja no segundo caso o construtor é chamado duas vezes, na primeira ele apenas cria o valor de instance com o mesmo valor de x = 0 + 6
Já na segunda vez que o construtor é chamado nesta situação o valor de BASE ja foi inicializado com 7, neste caso ele altera o valor de x para 7 + 6 = 13

Este código eu vi no link que passei acima

Mais detalhes pode ser visto em Static Initializers

Alias, a especificacao da JVM é um otimo lugar para sanar este tido de dúvida :)