Java基础-类的复用(2)-继承语法

上一篇 [Java基础-类的复用(1)-组合语法]

继承

跟组合语法相比,继承使用的是比较特殊的语法.在Java里,当你创建一个类时,总是在继承:如果你没有明确的指明要继承的父类时,就会隐式的继承Java的标准根类Objec.
在继承中,使用extends关键字继承其他的Java类,可以自动获得基类所有的域和方法.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
class A {
private String a = "animals:";

public void add(String str) {
a += str;
}

public void addCat() {
add(" Cat");
}

public void addDog() {
add(" Dog");
}

public void addFish() {
add(" Fish");
}

public String toString(){
return a;
}

public static void main(String[] args) {
A a = new A();
a.addCat();
a.addDog();
a.addFish();
System.out.println(a);
}
}

public class B extends A {
public void addFish(){
add(" FakeFish");
super.addFish();
}
public void addBird(){
add(" Bird");
}
public static void main(String[] args){
B b=new B();
b.addCat();
b.addDog();
b.addFish();
b.addBird();
System.out.println(b);
A.main(args);
}
}
/*
输出
animals: Cat Dog FakeFish Fish Bird
animals: Cat Dog Fish
*/

可以看到,类B继承了类A的所有的public方法,实例化后的类B可以正常使用类A的方法,改变类A的私有字符串.
在类B中,对基类A的addFish()进行修改是可行的,但是如果仍然想要使用基类继承的方法,并不能直接调用addFish(),这时候需要使用Java的super关键字,super表示超类,当前类就是从超类继承而来,使用super.addFish();即可调用基类的addFish()方法.

初始化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
class A {
A() {
System.out.println("A");
}
}
class B extends A {
B() {
System.out.println("B");
}
}
class C extends B {
C() {
System.out.println("C");
}
public static void main(String[] args) {
C c = new C();
}
}
/*
输出:
A
B
C
*/

可以发现,当初始化类C时,会先初始化C的基类B,在调用类B的构造器时,又会去初始化类B的基类A,由此可知在构建的过程中,构造顺序是”自顶向下”的.

带参数的构造函数

当调用一个含参数的构造函数时,如果没有使用super关键字显式的调用基类的构造函数时,不能成功的初始化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
class A {
A() {
System.out.println("A");
}
}
class B extends A {
B(String b) {
System.out.println(b);
}
}
class C extends B {
C() {
//显式的调用B的带参构造函数
super("BBB");
System.out.println("C");
}

public static void main(String[] args) {
C c = new C();
}
}
/*
输出
A
BBB
C
*/