复用代码是 Java 众多引人注目的功能之一,但是想成为一门极具革命性的语言,仅仅能够复制代码并加以改变是远远不够的,它必须能够做更多的事情。
继承语法
继承无处不在,每当创建一个类的时候,就已经在继承了,因为,除非明确指出要从其他类中继承,否则所有的类都从隐式地从根类 Object 类中进行继承。
继承通过关键字 extends 实现,子类会自动获取父类中所有的成员和方法。我们先创建一个父类:
public class Pet {
private String name = "Tom";
public void play() {
System.out.println("play method");
}
public String getName() {
return name;
}
}
再创建一个子类:
public class Cat extends Pet {
public void play() {
System.out.println(getName());
//调用父类的 play 方法
super.play();
}
}
由于父类的成员变量 name 是 private 修饰,所以可以通过 getName() 方法来获取 name 属性。在子类方法 play() 中,不能直接调用 play() 方法,这样做会产生递归(自己调用自己),所以引用 super 关键字来表示 play() 方法是从父类中继承来的。
父类初始化
从外部来看,子类就像是一个与父类具有相同接口的新类,也许会增加一些成员或方法,但是继承并不只是复制父类的接口。当创建一个新的子类对象时,这个对象就已经包含了一个父类的子对象,这个子对象与直接用父类创建的对象时一样的。区别在于,父类的子对象被包装在子类对象的内部,直接用父类创建的对象来自于外部。
我们先创建一个父类 People:
public class People {
public People() {
System.out.println("people constructor");
}
}
再创建一个继承 People 的子类 Chinese :
public class Chinese extends People {
public Chinese() {
System.out.println("chinese constructor");
}
}
再创建一个继承 Chinese 的子类 Student :
public class Student extends Chinese {
public Student() {
System.out.println("student constructor");
}
public static void main(String[] args) {
new Student();
}
}
运行 Student 类的 main 方法,打印结果如下:
people constructor
chinese constructor
student constructor
我们可以看到,构建过程是从父类开始然后逐渐向外扩散,所以父类在子类构造器可以访问它之前,就已经完成初始化了,即使没有创建 Student() 构造器,编译器也会合成一个默认的构造器,这个构造器将调用父类的构造器。
带参数的父类初始化
以上的构造器都是无参的,我们来看看带参的:
public class People {
private String name;
//有参构造器
public People(String name) {
System.out.println("people constructor, name:" + name);
}
}
public class Chinese extends People {
public Chinese(String name) {
super(name);
System.out.println("chinese constructor, name:" + name);
}
}
public class Student extends Chinese {
public Student(String name) {
super(name);
System.out.println("student constructor, name:" + name);
}
public static void main(String[] args) {
new Student("Tom");
}
}
运行 main 方法,看打印结果:
people constructor, name:Tom
chinese constructor, name:Tom
student constructor, name:Tom
我们可以看到如果没有默认的父类构造器,或者想调用一个带参的父类构造器,就必须使用关键字 super 来调用父类的构造器,并且要配上参数列表。
父类的 static 初始化
我们知道 Java 的所有事物都是对象,每个类只有在初次使用的时候才会加载,通常是指在创建第一个对象的时候发生加载,但是在访问 static 修饰的变量或者方法的时候,也会发生加载,并且加载的顺序就是程序中的顺序,static 的成员或者方法只会被加载一次。我们下面来看看带有 static 关键字的子父类加载过程:
先看看父类:
public class Insect {
private int i = 1;
private static int j = 2;
{
System.out.println("insect code block");
}
static {
System.out.println("insect static code block, j = " + j);
}
public Insect() {
System.out.println("insect constructor");
}
}
然后再看看子类:
public class Butterfly extends Insect {
private int m = 11;
private static int n = 22;
{
System.out.println("Butterfly code block");
}
static {
System.out.println("Butterfly static vode bolock, n = " + n);
}
public Butterfly() {
System.out.println("Butterfly constructor");
}
public static void main(String[] args) {
new Butterfly();
}
}
打印结果如下:
insect static code block, j = 2
Butterfly static vode bolock, n = 22
insect code block
insect constructor
Butterfly code block
Butterfly constructor
所以我们看到加载顺序如下:
父类静态代码块(属性)—> 子类静态代码块(属性)—> 父类非静态代码块(属性) —> 父类构造器 —> 子类非静态代码块(属性)—> 子类构造器