初始化“最终”实例变量

Question

我想了解各种情况下类实例的初始化
在JLS-7第12.5节中，没有提到如何以及何时初始化最终实例变量？如果实例变量被声明为final，是否有人能给我一点参考来理解其行为？

   public class Test {

        public static void main(String args[]){

            Child  c1 = new Child();
        }
    }

    class Parent{
        final int a =30;
        Parent(){
            System.out.println("From super Contsrutor "+a);
            meth();
        }
        void meth(){
             System.out.println("From super");
        }
    }

    class Child extends Parent{
         final  int e=super.a;
         int b=30;
        void meth(){
            System.out.println("From Sub e=" +e+", b="+b);
        }
    }

给出的输出如下

From super Contsrutor 30
From Sub e=0,b=0

在哪里作为

public class Test {

    public static void main(String args[]){

        Child  c1 = new Child();
    }
}

class Parent{
    final int a =30;
    Parent(){
        System.out.println("From super Contsrutor "+a);
        meth();
    }
    void meth(){
         System.out.println("From super");
    }
}

class Child extends Parent{
     final  int e=a;
    void meth(){
        System.out.println("From Sub " +e);
    }
}

是否将输出作为

From super Contsrutor 30
From Sub 30

Answer 1

让我们找出程序的流程，我写了下面的代码：

package com.test;

public class Test {

    public static void main(String args[]) {
        Child c1 = new Child();
    }
}

class Parent {
    final int a = 30;
    static int count = 0;
    {
        System.out.println("Parent initialization block " + ++count);
    }
    Parent() {
        System.out.println("Parent constructor " + ++count);
        // System.out.println("From super Contsrutor " + a);
        meth();
    }
    void meth() {
        // System.out.println("From super");
        System.out.println("Parent meth method " + ++count);
    }
}

class Child extends Parent {
    final int e = super.a;
    int b = 30;
    {
        System.out.println("Child initialization block " + ++count);
    }
    public Child() {
        System.out.println("Child constructor " + ++count);
    }
    void meth() {
        System.out.println("Child meth method " + ++count);
        // System.out.println("From Sub e=" + e + ", b=" + b);
    }
}

输出：

Parent initialization block 1
Parent constructor 2
Child meth method 3
Child initialization block 4
Child constructor 5

首先，请记住，我已经为父和子类编写了初始化块，它在构造函数之前被调用。

现在，如果您可以从创建Child对象时的输出中看到，首先Parent类被加载到内存中，然后您调用了meth方法，在Parent构造函数中调用meth方法的Child类，但是Child但是此时没有调用初始化块和Child构造函数，这意味着此时b没有初始化为30，而是初始化为int默认值值0，与e变量的情况相同。

Answer 2

第一段代码给出如下输出

From super Contsrutor 30
From Sub e=0,b=0

这是因为下面的原因。

当我们执行new Childs（）时，Childclass的构造器开始执行

但它的第一个语句默认为super，因此它调用父类构造函数

现在父类构造函数有以下代码

父（）{System.out.println（"来自超级联系人"a）；冰毒（）；}

所以这里父类调用meth（）方法，它的调用方实际上是子类child的对象，所以它调用子类meth（）方法。

现在，当它从super Constructor调用子类meth（）方法时，实际上子对象尚未创建，因此其变量尚未初始化，但我们正在打印a和b的值。

因此，在子构造函数完成执行之后，b在分配之前得到0。

因此，像下面这样更改第一段代码将得到所需的输出，即将meth（）调用放在子构造函数中，而不是放在父构造函数中。

package com.kb.finalVariables;

public class Test {

    public static void main(String args[]){

        Child  c1 = new Child();
    }
}

class Parent{
    final int a =30;
    Parent(){
        System.out.println("From super Contsrutor "+a);
       // meth();
    }
    void meth(){
         System.out.println("From super");
    }
}

class Child extends Parent{

     final  int e=super.a;
     int b=30;
     public Child() {
        meth();
    }
    void meth(){
        System.out.println("From Sub e=" +e+", b="+b);
    }
}

Answer 3

这个啊

final int e = a;

是一个常量变量，一个常量表达式。在调用中

System.out.println("From Sub e=" +e+", b="+b);

编译器可以将e的使用替换为其值30。

在里面

final int e = super.a;

变量e不是常量变量，因为super。a不是简单的名称，因此该值不能也不会被替换。