在构造函数中初始化静态最终字段

Question

public class A 
{    
    private static final int x;

    public A() 
    {
        x = 5;
    }
}

• final 表示该变量只能分配一次（在构造函数中）。
• static 意味着它是一个类实例。

我不明白为什么这会被禁止。这些关键词在哪里互相干扰？

Answer 1

Static

关键字static 表示对象的成员（在本例中为字段）不依赖于类的实例，而是一般类的成员。如果静态成员是一个字段，则它会在类加载期间初始化。

它可以通过类而不是通过实例访问（尽管后者并非不可能，但它被认为是不好的形式），因此在构造函数根本没有运行的情况下就可以访问它。

Final

当关键字final应用于对象的字段时，意味着它只能被赋值一次，并且它必须在初始化期间被赋值。

Static Final

结合起来，这两个关键字有效地定义了一个常量：它只能被赋值一次，必须被赋值，并且对于该类的所有实例都是相同的。

由于静态字段是在类加载期间初始化的，因此必须在声明时或在静态初始化块中对其进行初始化。

这意味着，如果您到达构造函数，它就已经被初始化了，因为它需要已经被初始化了。

Singleton

如果您正在寻找一个只分配一次但多次读取的类成员，那么您正在处理 一个单身人士。单例模式通常用于访问共享资源。

该字段是静态的，但不是最终的；相反，当访问该字段时，代码会检查它是否已经初始化，如果没有，则立即完成。请注意，在多线程环境中，您需要同步对该字段的访问，以避免在初始化时对其进行访问。

Answer 2

想一想。您可以使用代码执行此操作：

A a = new A();
A b = new A(); // Wrong... x is already initialised

初始化 x 的正确方法是：

public class A 
{    
    private static final int x = 5;
}

或

public class A 
{    
    private static final int x;

    static
    {
        x = 5;
    }
}

Answer 3

Final 并不意味着必须在构造函数中初始化。
一般来说，这样做是这样的：

 private static final int x = 5;

静态意味着变量将通过类的多个实例共享。例如 ：

public class Car {
   static String name;
   public Car(String name) {
      this.name = name;
   }
}

...

Car a = new Car("Volkswagen");
System.out.println(a.name); // Produces Volkswagen

Car b = new Car("Mercedes");
System.out.println(b.name); // Produces Mercedes
System.out.println(a.name); // Produces Mercedes

Answer 4

    public class StaticFinalExample {
  /*
   * Static final fields should be initialized either in
   * static blocks or at the time of declaration only
   * Reason : They variables are like the utility fields which should be accessible
   * before object creation only once.
   */
  static final int x;

  /*
   * Final variables shuould be initialized either at the time of declaration or
   * in initialization block or constructor only as they are not accessible in static block
   */
  final int y;

  /*
   * Static variables can be initialized either at the time of declaration or
   * in initialization or constructor or static block. Since the default value is given to the
   * static variables by compiler, so it depends on when you need the value
   * depending on that you can initialize the variable appropriately
   * An example of this is shown below in the main method
   */
  static int z;

  static {
    x = 20; // Correct
  }
  {
    y = 40; // Correct
  }
  StaticFinalExample() {
    z = 50; // Correct
  }
  public static void main (String args[]) {
    System.out.println("Before Initialization in Constructor" + z);   // It will print 0
    System.out.println("After Initializtion in Constructor" + new StaticFinalExample().z); // It will print 50
  }
}

Answer 5

每次创建类的实例时都会调用构造函数。因此，上面的代码意味着每次创建实例时都会重新初始化x的值。但是因为变量被声明为final（并且是static），所以你只能这样做

class A {    
    private static final int x;

    static {
        x = 5;
    }
}

但是，如果你删除static，你可以这样做：

class A {    
    private final int x;

    public A() {
        x = 5;
    }
}

或者这样：

class A {    
    private final int x;

    {
        x = 5;
    }
}

Answer 6

static Final 变量在类加载时初始化。构造函数可能会在很晚之后被调用，或者根本不会被调用。此外，构造函数将被多次调用（每个新对象），因此该字段不再是最终字段。

如果您需要自定义逻辑来初始化静态最终字段，请将其放入静态块中

Answer 7

想想第二次实例化一个对象时会发生什么。它尝试再次设置它，这是静态决赛明确禁止的。只能为整个类设置一次，不能为实例设置一次。

您应该在声明时设置该值。

private static final x=5;

如果您需要额外的逻辑或更复杂的实例化，可以在静态初始化程序块中完成。

Answer 8

static 意味着该变量在应用程序中是唯一的。
final 意味着它只能设置一次。

如果在构造函数中设置它，则允许多次设置该变量。

因此，您应该直接初始化它或提出一个静态方法来初始化它。