Java基类构造器调用的讲解（附代码）

不言

发布时间：2018-10-08 15:03:41

2764人浏览过

来源于博客园

转载

本篇文章给大家带来的内容是关于java基类构造器调用的讲解（附代码），有一定的参考价值，有需要的朋友可以参考一下，希望对你有所帮助。

在《Java编程思想》第７章复用类中有这样一段话，值得深思。当子类继承了父类时，就涉及到了基类和导出类（子类）这两个类。从外部来看，导出类就像是一个与基类具有相同接口的新类，或许还会有一些额外的方法和域。但继承并不只是复制基类的接口。当创建一个导出类对象时，该对象包含了一个基类的子对象，这个子对象与你用基类直接创建的对象是一样的，二者区别在于，后者来自于外部，而基类的子对象是被包裹在导出类对象内部。

这就引发出了一个很重要的问题，对基类子对象的正确初始化也是至关重要的（我们可能在子类的使用基类中继承的方法和域），而且也仅有一种方法来保证这一点：在子类构造器中调用基类构造器来执行初始化。

无参的基类构造器

我们知道，当一个类你没有给他构造函数，Java会自动帮你调用无参的构造器，同时Java也会在导出类的构造器中插入对基类构造器的调用。下面的代码说明了这个工作机制：

//: reusing/Cartoon.java
// Constructor calls during inheritance.
import static net.mindview.util.Print.*;

class Art {
  Art() { print("Art constructor"); }
}

class Drawing extends Art {
  Drawing() { print("Drawing constructor"); }
}

public class Cartoon extends Drawing {
  public Cartoon() { print("Cartoon constructor"); }
  public static void main(String[] args) {
    Cartoon x = new Cartoon();
  }
} /* Output:
Art constructor
Drawing constructor
Cartoon constructor
*///:~

观察上述代码的运行结果，在创建Cartoon对象时，会先调用其父类Drawing的构造器，而其父类又继承自Art类，所以又会调用Art类的构造器，就像层层往上。虽然在其构造器中都没有显式调用其父类构造器，但是Java会自动调用其父类的构造器。即使不为Cartoon()创建构造器，编译器也会合成一个默认的无参构造器，该构造器将调用基类的构造器。

立即学习“Java免费学习笔记（深入）”；

带参数的基类构造器

当基类中的构造器都是带有参数时，编译器就不会自动调用，必须用关键字super显式地调用基类构造器，并且传入适当的参数，相应的例子代码如下：

//: reusing/Chess.java
// Inheritance, constructors and arguments.
import static net.mindview.util.Print.*;

class Game {
  Game(int i) {
    print("Game constructor");
  }
}

class BoardGame extends Game {
  BoardGame(int i) {
    super(i);
    print("BoardGame constructor");
  }
}   

public class Chess extends BoardGame {
  Chess() {
    super(11);
    print("Chess constructor");
  }
  public static void main(String[] args) {
    Chess x = new Chess();
  }
} /* Output:
Game constructor
BoardGame constructor
Chess constructor
*///:~

从上述代码中可以观察到，必须在子类Chess构造器中显示的使用super调用父类构造器并传入适当参数。而且，调用基类构造器必须是在子类构造器中做的第一件事。

基类构造器的调用顺序问题

在此之前，我们先来探讨一下对象引用的初始化问题。在Java中，类中域为基本类型时能够自动被初始化为零，但是对象引用会被初始化为null。我们往往需要在合适的位置对其进行初始化，下面是几个可以进行初始化的位置：

1.在定义对象的地方。这意味着它们总是能够在构造器被调用之前被初始化。

2.在类的构造器中。

有道智云AI开放平台

下载

3.就在正要使用这些对象之前，这种方式称为惰性初始化。

记住上面的第１点，下面看一个比较复杂的例子来看一下基类构造器的调用顺序问题。

// reusing/Ex7/C7.java
// TIJ4 Chapter Reusing, Exercise 7, page 246
/* Modify Exercise 5 so that A and B have constructors with arguments instead
* of default constructors. Write a constructor for C and perform all 
* initialization within C's constructor. 
*/
 
import static org.greggordon.tools.Print.*;

class A { 
    A(char c, int i) { println("A(char, int)");} 
}

class B extends A {     
    B(String s, float f){
        super(' ', 0); 
        println("B(String, float)");
    } 
}

class C7 extends A { 
    private char c;
    private int i;
    C7(char a, int j) {     
        super(a, j); 
        c = a;
        i = j;
    }
    B b = new B("hi", 1f); // will then construct another A and then a B
    public static void main(String[] args) {
        C7 c = new C7('b', 2); // will construct an A first
    }
}

上述这段代码输出：

A(char, int)

B(String, float)