java - 在非静态 block 之前调用构造函数？

Question

这是我的程序:

public class Num2 {

   static
   {
        System.out.println("static block -1");
   }
   int no;
   Num2(int n)
   {
       no=n;
       System.out.println("Num");
   }
   Num2()
   {
        no=0;
        System.out.println("default num");
   }
   {
        System.out.println("Non-static block of num1");
   }
}



class call_by_value2 extends Num2
{
       static
       {
           System.out.println("static block of call by value");
       }  
       {
           System.out.println("non- static block of call by value");
       }
       call_by_value2()
       {   
          System.out.println("Default of call by value");
       }
       static void changeno(Num2 n1,Num2 n2)
       {
          Num2 n=new Num2();
          n=n1;
          n1=n2;
          n2=n;
       }
       public static void main(String[] args)
       {
          System.out.println("Main method");
          call_by_value2 c=new call_by_value2();
       }
 }

输出是:

static block -1
static block of call by value
Main method
Non-static block of num1
default num
non- static block of call by value
Default of call by value

这是期望的输出，因为我们知道首先调用非静态 block ，然后调用构造函数。但是当我修改这个程序并按如下方式运行时:

public class Num2 {

   static
   {
       System.out.println("static block -1");
   }
   int no;
   Num2(int n)
   {
       no=n;
       System.out.println("Num");
   }
   Num2()
   {
       no=0;
       System.out.println("default num");
   }
   {
       System.out.println("Non-static block of num1");
   }
}



class call_by_value2 extends Num2
{
      static
      {
          System.out.println("static block of call by value");
      }  
      {
          System.out.println("non- static block of call by value");
      }
      call_by_value2()
      {   
          super(50);
          System.out.println("Default of call by value");
      }
      static void changeno(Num2 n1,Num2 n2)
      {
          Num2 n=new Num2();
          n=n1;
          n1=n2;
          n2=n;
      }
      public static void main(String[] args)
      {
          System.out.println("Main method");
          call_by_value2 c=new call_by_value2();
      }
}

现在的输出是:

static block -1
static block of call by value
Main method
Non-static block of num1
Num
non- static block of call by value
Default of call by value

所以我的问题是，如果包含 super() 方法的 callbyvalue2 类 的默认构造函数最后运行，那么 Num2 类的参数化构造函数如何在 callbyvalue2 类的默认构造函数输出之前给出输出？

Answer 1

不，这是您调用电话时发生的情况，例如。

new Num2() ;

1) 所有变量都初始化为默认值(0、null、false、'\u0000')，包括从父类(super class)继承的变量。

2) 调用隐式或显式父类(super class)构造函数直到 Object 类(不允许将任何局部变量或方法返回作为参数传递给父类(super class)构造函数调用)。请注意，此时虽然调用了隐式或显式构造函数，但它们不执行任何内部代码。

(如果您有一个空的构造函数，编译器将隐式调用无参数父类(super class)构造函数，因此在到达最顶层父类(super class)构造函数之前它不会在方法内部执行任何操作，因为第一行每个构造函数中的代码都将是 super() ；无论你是否放置它。如果父类(super class)没有可用的无参数构造函数，那么你必须明确提供一个作为子类构造函数中代码的第一行，例如 super("一个字符串参数") ;)

3) 当到达顶级父类(super class)构造函数时，在该级别声明的变量被分配给它们的初始化器(值显式分配，例如 int i = 23;)， block 语句在构造函数之前执行，无论它们在类中的何处声明和构造函数在所有非静态 block 执行后执行。

然后Point 3会沿着继承树向下执行直到Num2()

示例 1 第一个示例将无法编译。

class Animal{
    Animal(int){

    }
}

class Dog extends Animal
{
    Dog(){
        // right here compiler will place an implicit call to super() ; not seen, at compile time.
        // since there is no no-args constructor available in class Animal compiler will issue a warning and stop compiling. Remember that a no-args constructor is provided by default ONLY if no other constructor was provided by the programmer. In this example we have a constructor in our superclass that takes an int as argument and so we must explicitly tell the compiler to call super(24);
    }
}

示例 2

class Animal{

}

class Mammal extends Animal{
    Mammal(int x){ 

    }
}

class Dog extends Mammal{
    Dog(){
        super(24) ;
    }

    Dog(int x){
       super(x) ;
    }
}

class BullDog extends Dog{
    BullDog(){
        this(24) ;
    }

    BullDog(int x){
        super(x) ;
    }
}

现在，如果我们要使用无参数构造函数创建 BullDog 实例，将发生以下构造函数调用。

1 斗牛犬();

2 斗牛犬(24) ;

3 狗(24) ;

4 哺乳动物(24) ;

5 这里虽然似乎什么都不存在，但请记住编译器提供了对 super 构造函数的隐式调用，因此这里将是一个调用，例如 Anima();

6 这里 Animal 类似乎没有任何构造函数，但是编译器将提供以下无参数构造函数，并默认调用 super，它应该是 Object 类的无参数构造函数。

Animal(){
    super() ;
}

所以 6 就像 Object() ;

您现在应该明白为什么在到达 Object 构造函数之前任何构造函数中的代码都不会执行，这是因为总是会在第一行调用父类(super class)构造函数。如果您省略它，最好在您的 seperclass 中有一个无参数构造函数，以便它可以使用编译器默认提供的内容，否则您必须显式声明它。