Java调用超级构造函数

最终结果是4。我不清楚扩展过程。在main函数中，我们创建一个对象YfkC并调用

YfkC.x.

我的理解是，因为类YfkC中没有方法和字段，所以我们在yfkb中查找，然后在YfkC中查找。此时，YfkC是否会自动升级为YfkA？等于

System.out.println（新的YfkA（）.x）x=4

我对从

YfkC

到

YfkA

的过程感到困惑

class Yfk {
public static void main(String[] args) {
     System.out.println(new YfkC().x);
  }
}
abstract class YfkA {
int x = 3;
  YfkA() { x++; }
}
class YfkB extends YfkA {}
class YfkC extends YfkB {}

这将在内部调用子类的构造函数。因此，x的值递增并打印为4

new YfkC().x

每个类的默认构造函数都调用

super（）。这将在执行自己的超类之前调用该超类的默认构造函数

如果您想了解构造函数链，那么将其作为系统输出，并查看调用链

YfkC() -> YfkB() -> YfkA() { x++;};

输出：

YfkA

YfkB

YfkC

四,

这将在内部调用子类的构造函数。因此，x的值递增并打印为4

new YfkC().x

每个类的默认构造函数都调用
super（）。这将在执行自己的超类之前调用该超类的默认构造函数

如果您想了解构造函数链，那么将其作为系统输出，并查看调用链

YfkC() -> YfkB() -> YfkA() { x++;};

输出：

YfkA

YfkB

YfkC

四,

这将在内部调用子类的构造函数。因此，x的值递增并打印为4

new YfkC().x

每个类的默认构造函数都调用
super（）。这将在执行自己的超类之前调用该超类的默认构造函数

如果您想了解构造函数链，那么将其作为系统输出，并查看调用链

YfkC() -> YfkB() -> YfkA() { x++;};

输出：

YfkA

YfkB

YfkC

四,

这将在内部调用子类的构造函数。因此，x的值递增并打印为4

new YfkC().x

每个类的默认构造函数都调用
super（）。这将在执行自己的超类之前调用该超类的默认构造函数

如果您想了解构造函数链，那么将其作为系统输出，并查看调用链

YfkC() -> YfkB() -> YfkA() { x++;};

输出：

YfkA

YfkB

YfkC

4当您调用任何子构造函数时。当前类中存在对直接父类构造函数的链调用。调用将继续，直到对象类构造函数调用为止，因为最可能的父类是超类

下面是一个构造函数在继承中的行为示例

public  class Yfk {
  public static void main(String[] args) {
    System.out.println(new YfkC().x);
  }
}
abstract class YfkA {
  int x = 3;
  YfkA() {
    System.out.println("YfkA");
    x++; }
}
class YfkB extends YfkA {
  public YfkB() {
    System.out.println("YfkB");
  }
}
class YfkC extends YfkB {
  public YfkC() {
    System.out.println("YfkC");
  }
}

我写了一篇关于这个话题的文章，希望能澄清你的疑问

调用任何子构造函数时。当前类中存在对直接父类构造函数的链调用。调用将继续，直到对象类构造函数调用为止，因为最可能的父类是超类

下面是一个构造函数在继承中的行为示例

public  class Yfk {
  public static void main(String[] args) {
    System.out.println(new YfkC().x);
  }
}
abstract class YfkA {
  int x = 3;
  YfkA() {
    System.out.println("YfkA");
    x++; }
}
class YfkB extends YfkA {
  public YfkB() {
    System.out.println("YfkB");
  }
}
class YfkC extends YfkB {
  public YfkC() {
    System.out.println("YfkC");
  }
}

我写了一篇关于这个话题的文章，希望能澄清你的疑问

调用任何子构造函数时。当前类中存在对直接父类构造函数的链调用。调用将继续，直到对象类构造函数调用为止，因为最可能的父类是超类

下面是一个构造函数在继承中的行为示例

public  class Yfk {
  public static void main(String[] args) {
    System.out.println(new YfkC().x);
  }
}
abstract class YfkA {
  int x = 3;
  YfkA() {
    System.out.println("YfkA");
    x++; }
}
class YfkB extends YfkA {
  public YfkB() {
    System.out.println("YfkB");
  }
}
class YfkC extends YfkB {
  public YfkC() {
    System.out.println("YfkC");
  }
}

我写了一篇关于这个话题的文章，希望能澄清你的疑问

调用任何子构造函数时。当前类中存在对直接父类构造函数的链调用。调用将继续，直到对象类构造函数调用为止，因为最可能的父类是超类

下面是一个构造函数在继承中的行为示例

public  class Yfk {
  public static void main(String[] args) {
    System.out.println(new YfkC().x);
  }
}
abstract class YfkA {
  int x = 3;
  YfkA() {
    System.out.println("YfkA");
    x++; }
}
class YfkB extends YfkA {
  public YfkB() {
    System.out.println("YfkB");
  }
}
class YfkC extends YfkB {
  public YfkC() {
    System.out.println("YfkC");
  }
}

我写了一篇关于这个话题的文章，希望能澄清你的疑问

每当实例化一个子类时，它的父构造函数都会按顺序从上到下调用

在您的层次结构中，您有：


YfkC
YfkB
摘要
YfkA
对象

…在它们的每个构造函数中，都有对
super（）
的隐式调用

因此，
newyfkc
调用
YfkB
的构造函数，该构造函数调用抽象类的
YfkA
s构造函数，从而导致
x
的增量

如果您再次执行
new YfkC（）.x
，您将得到5个，因为每次新建
YfkA
的任何子类时，您都将调用该构造函数。
每当实例化子类时，它的父类构造函数都会按顺序向上调用

在您的层次结构中，您有：


YfkC
YfkB
摘要
YfkA
对象

…在它们的每个构造函数中，都有对
super（）
的隐式调用

因此，
newyfkc
调用
YfkB
的构造函数，该构造函数调用抽象类的
YfkA
s构造函数，从而导致
x
的增量

如果您再次执行
new YfkC（）.x
，您将得到5个，因为每次新建
YfkA
的任何子类时，您都将调用该构造函数。
每当实例化子类时，它的父类构造函数都会按顺序向上调用

在您的层次结构中，您有：


YfkC
YfkB
摘要
YfkA
对象

…在它们的每个构造函数中，都有对
super（）
的隐式调用

因此，
newyfkc
调用
YfkB
的构造函数，该构造函数调用抽象类的
YfkA
s构造函数，从而导致
x
的增量

如果要执行
new