1.1 为什么需要继承？#

想象一下我们要描述狗和猫这两种动物。如果不使用继承，代码可能会是这样：

1
public class Dog {
2
    String name;
3
    int age;
4
    float weight;
5

6
    public void eat() {
7
        System.out.println(name + "正在吃饭");
8
    }
9

10
    public void sleep() {
11
        System.out.println(name + "正在睡觉");
12
    }
13

14
    void bark() {
15
        System.out.println(name + "汪汪汪---");
16
    }
17
}
18

19
// Cat.java
20
public class Cat {
21
    String name;
22
    int age;
23
    float weight;
24

25
    public void eat() {
26
        System.out.println(name + "正在吃饭");
27
    }
28

29
    public void sleep() {
30
        System.out.println(name + "正在睡觉");
31
    }
32

33
    void mew() {
34
        System.out.println(name + "喵喵喵---");
35
    }
36
}

可以看到，这两个类中有大量重复的代码（name、age、weight属性，eat()和sleep()方法）。继承机制正是为了解决这种代码冗余问题而生的。

1.2 继承的概念#

继承是面向对象程序设计使代码可以复用的最重要手段，它允许程序员在保持原有类特性的基础上进行扩展，增加新功能。这样产生的新类称为派生类（子类），被继承的类称为基类（父类）。

继承关系可以用以下图示表示：

1
        Animal
2
        /    \
3
       Dog    Cat

1.3 继承的语法#

在Java中使用extends关键字实现继承：

1
public class Animal {
2
    String name;
3
    int age;
4

5
    public void eat() {
6
        System.out.println(name + "正在吃饭");
7
    }
8

9
    public void sleep() {
10
        System.out.println(name + "正在睡觉");
11
    }
12
}
13

14
// Dog.java
15
public class Dog extends Animal {
16
    void bark() {
17
        System.out.println(name + "汪汪汪---");
18
    }
19
}
20

21
// Cat.java
22
public class Cat extends Animal {
23
    void mew() {
24
        System.out.println(name + "喵喵喵---");
25
    }
26
}

1.4 继承中的成员访问#

在继承体系中，子类可以访问父类的成员，但有一些规则需要注意：

1. 成员变量访问：

   • 子类中有，优先访问子类的
   • 子类中没有，访问父类的
   • 都没有，编译报错

2. 成员方法访问：

   • 方法名不同时，优先在子类中找，再到父类中找
   • 方法名相同时，根据参数列表决定（重载）
   • 完全相同时，子类会覆盖父类方法（重写）

1.5 super关键字#

当子类和父类有同名成员时，可以使用super关键字显式访问父类的成员：

1
public class Derived extends Base {
2
    int a;  // 与父类同名
3

4
    public void method() {
5
        super.a = 200;  // 访问父类的a
6
        this.a = 100;   // 访问子类的a
7
    }
8
}

1.6 子类构造方法#

子类构造时必须先调用父类构造方法：

1
public class Base {
2
    public Base() {
3
        System.out.println("Base()");
4
    }
5
}
6

7
public class Derived extends Base {
8
    public Derived() {
9
        // 编译器会自动添加super();
10
        System.out.println("Derived()");
11
    }
12
}

注意：

1. super()必须是子类构造方法的第一条语句
2. 如果父类没有无参构造，子类必须显式调用父类的有参构造

2.1 多态的概念#

多态是指同一行为在不同对象上表现出不同的形态。例如：

1
打印机
2
├─ 彩色打印机 → 打印效果：彩色
3
└─ 黑白打印机 → 打印效果：黑白

2.2 多态的实现条件#

Java中实现多态需要满足三个条件：

1. 必须在继承体系下
2. 子类必须重写父类方法
3. 通过父类引用调用重写的方法

2.3 方法重写(Override)#

==重载和重写的区别：==

重写是子类对父类方法的重新实现，必须遵循以下规则：

• 方法名、参数列表必须相同
• 返回值类型相同或是父类返回值的子类
• 访问权限不能比父类更严格
• 不能重写static、private、final方法

示例：

1
class Animal {
2
    public void eat() {
3
        System.out.println("动物吃饭");
4
    }
5
}
6

7
class Cat extends Animal {
8
    @Override
9
    public void eat() {
10
        System.out.println("猫吃鱼");
11
    }
12
}

2.4 向上转型与向下转型#

1. 向上转型：子类对象赋值给父类引用

   1
   Animal animal = new Cat("咪咪", 2);
   

2. 向下转型：父类引用强制转换为子类类型

   1
   if (animal instanceof Cat) {
   2
       Cat cat = (Cat) animal;
   3
       cat.mew();
   4
   }
   

2.5 多态的优缺点#

优点：

1. 降低代码复杂度，减少if-else
2. 提高可扩展性，新增子类不影响现有代码

缺点：

1. 运行效率略低（动态绑定）
2. 属性没有多态性
3. 构造方法中调用重写方法可能导致问题

2.6 避免在构造方法中调用重写方法#

看一个典型问题：

1
class B {
2
    public B() {
3
        func();  // 危险！
4
    }
5

6
    public void func() {
7
        System.out.println("B.func()");
8
    }
9
}
10

11
class D extends B {
12
    private int num = 1;
13

14
    @Override
15
    public void func() {
16
        System.out.println("D.func() " + num);
17
    }
18
}
19

20
public class Test {
21
    public static void main(String[] args) {
22
        D d = new D();  // 输出：D.func() 0
23
    }
24
}

此时num还未初始化（值为0），因为父类构造方法执行时子类字段还未初始化。