在构造函数中初始化静态变量

Question

看下面的代码：

public class Foo {
    private static Foo sigleton=new Foo();
    private static int count1;
    private static int count2=0;

    private Foo (){
        count1++;
        count2++;
    }

    public static Foo getInstance(){
        return sigleton;
    }

    public static void main(String[] args) {
        //Foo f= Foo.getInstance(); // case 1
        //Foo f= new Foo(); // case 2
        System.out.println(f.count1);
        System.out.println(f.count2);
    } 
}

对于每次运行，请取消注释main方法中的其中一行。

为什么情况1和2的输出不同？

Answer 1

仅仅因为在第一种情况下，构造了一个Foo对象，但是在第二种情况下，构造了两个Foo对象。

您可以静态初始化sigleton字段-因此，在加载类时，始终会调用Foo构造函数（如您为字段初始化程序指定的那样）。

现在，在第一种情况下，您只是调用一个method ，它返回已经构造的sigleton对象-因此不再调用任何构造函数。 在情况2中，您显式构造了一个新的Foo对象-但sigleton仍将被构造。 因此，在后一种情况下，将创建两个对象，构造函数总共运行两次，因此count1和count2将count2 。

Answer 2

比您的问题更有趣的是count1 == count2 + 1的事实。

原因是静态声明以编译器发现它们的顺序运行，因此对Foo的第一次调用将调用以下语句：

private static Foo sigleton = null; //default value for objects
private static int count1 = 0; //default value for int
private static int count2 = 0; //default value for int

sigleton = new Foo(); //first static initializer => count1 = 1 AND count2 = 1
count2 = 0; //second static initializer

从那时起，count1和count2一起增加，您将始终拥有count1 == count2 + 1 。

底线：不要编写这种代码！

Answer 3

Java首先将静态变量初始化为默认值（null，0和等效值）。 无论是否指定了初始值，都将执行此操作。

然后，它将从类的开头到底部运行所有静态代码块 （不是静态方法！）。 初始化也被认为是代码块，它按照文件中指定的顺序运行。 因此，这样的代码：

// static block of code in front

static Type variable = initialValue;

// static block of code in-between

static OtherType anotherVariable = someInitialValue;

// static block of code below

大致等同于（大致-由于它们在语法上不等同）

static Type variable;
static OtherType anotherVariable;

// static block of code in front

static {
    variable = initialValue;
}

// static block of code in-between

static {
    anotherVariable = someInitialValue;
}

// static block of code below

（就在调用构造函数之前，所有非静态代码块都将在调用构造函数之前运行。不过，这与OP的代码段不是很相关。）

从上面的方案中，将调用Foo()构造函数。 并将count1和count2初始化为1。

执行完singleton = new Foo()初始化程序后，它将继续执行初始化count2 = 0 ，并有效地将count2设置为0。

至此，我们将进入main()函数并打印出来。 如上所述，如果第二次调用该构造函数，则将在该构造函数之前运行非静态代码块，并且将再次调用该构造函数，以将count1和count2值分别增加1。 。

您可以尝试编译并运行以下代码以查看效果：

class Foo {
    static {
      System.out.println("static 0: " + Foo.sigleton + " " + Foo.sigleton.count1 + " " + Foo.sigleton.count2);
    }

    private static Foo sigleton=new Foo();

    static {
      System.out.println("static 1: " + sigleton + " " + sigleton.count1 + " " + sigleton.count2);
    }

    private static int count1;

    static {
      System.out.println("static 2: " + sigleton + " " + sigleton.count1 + " " + sigleton.count2);
    }

    private static int count2=0;

    static {
      System.out.println("static 3: " + sigleton + " " + count1 + " " + count2);
    }

    {
      System.out.println("non-static 1: " + sigleton + " " + count1 + " " + count2);
    }

    private Foo (){
        count1++;
        count2++;

        System.out.println(count1 + " " + count2);
    }

    {
      System.out.println("non-static 2: " + sigleton + " " + count1 + " " + count2);
    }

    public static Foo getInstance(){
        return sigleton;
    }

    public static void main(String[] args) {
        Foo f= Foo.getInstance(); // case 1
        System.out.println(f.count1);
        System.out.println(f.count2);
        Foo t= new Foo(); // case 2
        System.out.println(t.count1);
        System.out.println(t.count2);
    } 
}

Answer 4

在情况2中，构造函数Foo()被调用2次，一次是在初始化private static Foo时调用，另一次是从main方法中调用。 如果使用getInstance()方法获取Foo，则不会发生第二次调用。