Java 小白成长记 · 第 6 篇「为什么说要慎用继承，优先使用组合」

Posted 2021-03-30 飞天小牛肉

0. 前言

在代码的编写过程中，避免冗余代码的出现是非常重要的，大段大段的重复代码必然不能够称之为优雅。所谓减少冗余代码，通俗来说就是实现一段代码多处使用，「在不污染源代码的前提下使用现存代码」，也就是代码「复用」，避免重复编写。然而，对于像 C 语言等面向过程的语言来说，复用通常指的仅仅只是「复制代码」，任何语言都可通过简单的复制来达到代码复用的目的，显然这样做的效果并不好。

Java 作为一种面向对象的语言，围绕「类」来解决冗余代码的问题。我们可以直接使用别人构建的代码，而非创建新类、重新开始或者无脑的复制代码。

Java 中实现代码复用的手段有两种，标题也写的很清楚：

• 第一种手段：组合
• 第二种手段：继承

本文会先分别讲解什么是继承，什么是组合，最后再揭开标题的谜底 — 「为什么说要慎用继承，优先使用组合」。

1. 什么是组合

所谓组合（Composition），就是「在新类中创建现有类的对象」。不管是继承和组合，都允许在新类中直接复用旧类的「公有」方法或字段。

举个例子，比如说所有的动物都拥有心跳 beat 和呼吸 breath，我们将心跳和呼吸抽象成一个类 Animal，这个类就称为现有类，现在有一个动物：猫 Cat，那么 Cat 这个类就称为新类，「将 Animal 类的对象嵌入 Cat 这个类中，Cat 就具有了心跳和呼吸」，这就使用了组合。

通俗来说 Cat 拥有 Animal，即 「has-a」 的关系。以后再有其他动物的出现，比如狗 Dog，也同样将 Animal 类嵌入其中使其具有心跳和呼吸即可，不必重复的写心跳和呼吸方法的代码。这便是组合的全部意义。UML 类图如下：

代码示例如下：

public class Animal {
 public void beat(){
  System.out.println("My heart is beating");
 }
 public void breath(){
  System.out.println("I'm breathing");
 }
}

Cat 拥有 Animal，不仅拥有了呼吸和心跳功能，并且还可以添加自己的新属性，使其具有新的方法：

public class Cat {
    // 组合
 private Animal animal;
    // 使用构造函数初始化成员变量
 public Cat(Animal animal){
  this.animal = animal;
 }
    // 通过调用成员变量的固有方法使新类具有相同的功能
 public void breath(){
  animal.breath();
 }
    // 通过调用成员变量的固有方法使新类具有相同的功能
 public void beat(){
  animal.beat();
 }
    // 为新类增加新的方法
 public void run(){
  System.out.println("I'm running");  
 }
}

这样，Cat 这个新类拥有了三种方法：breath / beat / run：

// 显式创建被组合的对象实例 animal
Animal animal = new Animal();
// 以 animal 为基础组合出新对象实例 cat
Cat cat = new Bird(animal);
// 新对象实例 cat 可以 breath()
cat.breath();
// 新对象实例 cat 可以 beat()
cat.beat();
// 新对象实例 cat 可以 run()
cat.run();

以上便是组合实现复用的方式，Cat 对象由 Animal 对象组合而成，如上面的示例代码，在创建 Cat 对象之前先创建 Animal 对象，并利用这个 Animal 对象来创建 Cat 对象。

实际上，组合表示出来的是一种明确的「整体-部分」的关系。而对于继承来说，是将某一个抽象的类，改造成能够适用于不同特定需求的类。

2. 什么是继承

还从上面的例子的入手，上面我们使用组合复用了 Animal 类，事实上，也可以使用继承实现 Animal 类的复用。

对于 Cat 和 Animal，我们还可以这样理解，Cat 「是」一种 Animal，即 「is-a」 的关系。这样，Cat 称为「子类（派生类）」，Animal称为 Cat 的「父类（超类、基类）」。在组合中，新类 Cat 访问旧类 Animal 中的属性需要通过内嵌的旧类对象来调用，而对于继承来说，「新类（子类）可以直接调用旧类（父类）的公有属性」。UML 类图如下：

Java 中的继承关系使用关键字 extends 来标识，示例代码如下：

public class Cat extends Animal{
    // 为新类增加新的方法
 public void run(){
  System.out.println("I'm running");  
 }
}

Cat 继承 Animal 后，自动拥有了父类 Animal 中的方法 beat 和 breath，并可以直接调用，代码如下：

Cat cat = new Cat();
// 子类实例 cat 可以 breath()
cat.breath();
// 子类实例 cat 可以 beat()
cat.beat();
// 子类实例 cat 可以 run()
cat.run();

以上便是继承实现复用的方式，Cat 继承自抽象的类 Animal，并将其改造成能够适用于某种特定需求的类。

3. 方法覆盖 / 重写

子类继承父类后，不仅可以直接调用父类的方法，还可以对父类的方法进行重写，使其拥有自己的特征。仍然以上面的 Cat 和 Animal 为例，假设 Cat 继承 Animal 后，对 Animal 原生的呼吸方法 breath 很不满意，但是你不能不呼吸对吧，所以这个时候就可以直接对 breath 方法的方法体进行重写。

「注意，重写和重载不同」，在Java 小白成长记第 4 篇中我们说过，重载指的是两个方法具有相同的名字，但是不同的参数，而「重写不仅方法名相同，参数列表和返回类型也相同」。示例代码如下：

public class Cat extends Animal{
    ......
    
    // 重写 breath 方法
    @Override
    public void breath(){
  System.out.println("I'm cat, " + super.breath());
 }    
}

@Override 注解即表示方法重写，不过这个也可以不写，JVM 能够自动的识别方法覆盖。

上面这个方法输出的将是 I'm cat, I'm breathing，也就是说，在子类中可以使用 super 关键字调用父类的方法。

另外，一定要注意的是：「在覆盖一个方法的时候，子类方法不能低于父类方法的可见性」。特别是， 如果超类方法是 public, 子类方法一定要声明为 public。常会发生这类错误：在声明子类方法的时候， 遗漏了 public修饰符。此时，编译器将会把它解释为试图提供更严格的访问权限：

4. 子类的构造函数

现在，我们为父类 Animal 添加一个私有字段 age，每个动物都有年龄嘛，当然，对于子类来说，这个私有字段它们是无法访问的。

public class Animal {
    // 新增一个私有字段
    private int age; 
    
    // 父类的构造函数
    public Animal(int age) { 
        this.age = age;
    }
 ......
}

同样的，我们规定在构造 Cat 的时候，需要为其指定年龄 age 和猫耳的类型 earKind，这就需要使用子类的构造函数了：

public class Cat extends Animal{
    private String earKind;
    
    public Cat(int age, String earKind) {
        super(age);
        this.earKind = earKind;
    }
    
    .........
}

可以看出，我们通过 super(age) 调用了父类的构造函数为这个猫指定了年龄，这个同 this 关键字一样，「使用 super调用构造函数的语句必须是子类构造函数的第一条语句」。

❝

「如果子类的构造器没有显式地调用父类的构造器， 则将自动地调用父类默认的构造函数（无参构造函数）」。如果超类没有无参构造函数， 并且在子类的构造器中又没有显式地调用超类的其他构造器，则 Java 编译器将报告错误。

❞

需要注意的是：「父类的构造函数总是先于子类的构造函数执行」。这点应该很好理解，你不能说先构造一个个猫出来，再给他添加呼吸和心跳对吧，你一定是先有呼吸和心跳，才有这个猫的。

5. 向上转型和向下转型

① 向上转型

继承最重要的方面不是为子类提供方法。它是子类与父类的一种关系。简而言之，上文我们也说过，这种关系可以表述为「子类是父类的一种类型」。这种描述并非是解释继承的一种花哨方式，这是直接由语言支持的。下面例子展示了编译器是如何支持这一概念的：

Animal cat = new Cat(...); // 向上转型 Cat->Animal

也就是说，「程序中出现父类对象的任何地方都可以用子类对象置换」，这便是「向上转型」。通过子类对象 (小范围) 实例化父类对象(大范围)，这种属于自动转换。事实上，这是「多态」的一种体现。后续文章我们会详细讲解。

需要注意的是：「父类引用变量指向子类对象后，只能使用父类已声明的方法」，但方法如果被重写会执行子类的方法，如果方法未被重写那么将执行父类的方法。

② 向下转型

不仅存在向上转型，还存在向下转型。正像有时候需要将浮点型数值 float 转换成整型数值 int 一样，有时候也可能需要「将某个父类的对象引用转换成子类的对象引用，调用一些子类特有而父类没有的方法」。对象向下转型的语法与数值表达式的类型转换类似，仅需要用一对圆括号将目标类名括起来，并放置在需要转换的对象引用之前就可以了。例如：

Animal animal = new Cat(...); // 向上转型 Cat->Animal
Cat cat = (Cat) animal; // 向下转型 Animal->Cat，animal 的实质还是指向 Cat

6. 受保护访问 protected

大家都知道，最好将类中的域标记为 private, 而方法标记为 public。任何声明为 private 的内容对其他类都是不可见的。前面已经看到， 这对于子类来说也完全适用，即子类也不能访问父类的私有域。

然而，在有些时候，人们希望父类中的某些方法或字段允许被子类访问，为此， 需要将这些方法或域声明为 protected。上篇文章说过，「这个访问修饰符提供包访问权限和子类访问权限」。例如，如果将父类 Animal中的 age声明为 proteced，而不是私有的， Cat中的方法就可以直接地访问它，「即使子类和父类不在一个包下」。这表明子类得到信任，可以正确地使用这个方法，而不和父类在同一个包下的其他类则不行。

7. Java 中的单继承

在深入学习 Java 之前，我学的其实是 C++，而 C++ 是支持多继承的，也就是说 A 可以同时继承 B 和 C 甚至更多。然而，「在 Java 中，子类只能继承一个父类」。也就是「单继承」。

为啥 Java 和 C++ 都是面向对象的，C++ 支持多继承和 Java 却不支持呢？C++ 语言是 1983 年由贝尔实验室的 Bjarne Stroustrup 在 C 语言的基础上推出的，Java 语言是 1995 年由 James Gosling 和同事共同正式推出的。在 C++ 被设计出来后，太多人掉进了多继承带来的坑，虽然它也提出了相应的解决办法，「但 Java 语言本着简单的原则舍弃了 C++ 中的多继承，这样也会使程序更具安全性」。

那么多继承到底带来什么坑？其实也不难理解：

如果一个子类拥有多个父类的话，那么当多个父类中有重复的属性或者方法时，子类的调用结果就会含糊不清，也就是存在「二义性」。因此 Java 使用了单继承。

那么问题来了，假设有一个人鱼种类，它既拥有动物 Animal 的特征，又拥有人 Person 的特征，既然不支持多继承，它如何同时具有这两个的特征呢？这时候就可以使用「多接口（多实现）」，通过实现多个接口拓展类的功能，即使实现的多个接口中有重复的方法也没关系，因为在实现类中必须重写接口中的方法，所以调用的时候调用的是实现类中重写的方法。接口部分是后话了，本文暂且不做讨论。

8. 为什么说要慎用继承，优先使用组合

终于来到了文章标题，为什么说要「慎用继承，优先使用组合」？

因为在 Java 中使用继承就无法避免以下这两个问题：

• 1）打破了封装性，违反了 OOP 原则。迫使开发者去了解父类的实现细节，子类和父类耦合
• 2）父类更新后可能会导致一些不可知的错误

这么说大家可能还无法直观的感受，这样，我们举个例子：自定义一个子类 MyHashSet，它继承了 Java 的原生 API HashSet，并重写了父类的两个方法 add 和 addAll，它和父类唯一的区别是加入了一个计数器，用来统计添加过多少个元素。

public class MyHashSet<E> extends HashSet<E> {
    private int addCount = 0; 
 
    // 获取 addCount
    public int getAddCount() { 
        return addCount;
    }
 
    // 重写父类的 add 方法
    @Override
    public boolean add(E e) {
        addCount++;
        return super.add(e);
    }
 
    // 重写父类的 add 方法
    @Override
    public boolean addAll(Collection<? extends E> c) {
        addCount += c.size();
        return super.addAll(c);
    }
}

HashSet 是集合章节的内容，后续会详细讲解，这里大家只需要知道 add 用来向集合中添加一个元素，addAll 用来向集合中添加多个元素即可。

按照上面子类重写的逻辑，每向集合中添加一个元素，addCount 就会相应的增加一个。

MyHashSet<Integer> myHashSet = new MyHashSet<Integer>();
myHashSet.addAll(Arrays.asList(1,2,3));
System.out.println(myHashSet.getAddCount());

上面这段测试代码我们通过子类重写的 addAll 方法向集合中添加了 3 个元素，按理来说，addCount 应该是 3。然而，运行结果却是 6。这看起来确实很匪夷所思。

我们进入父类 HashSet 的源码看看，就能发现出错的原因：

addAll 方法内部调用的是 add() 方法。也就是说，按照上面子类重写的逻辑，子类在调用自己的 addAll() 方法时，首先 addCount 会加 3，然后调用父类的 addAll() 方法，父类的 addAll() 又会调用子类的 add() 方法三次，这样 addCount 又会再加 3。

出现这种情况的原因，就是「父类中可覆盖的方法调用了别的可覆盖的方法，这时候如果子类覆盖了其中的一些方法，就可能导致错误」。

结合上图理解，HashSet 类里有可覆盖的方法 addAll 和方法 add，并且 addAll 调用了 add。子类 MyHashSet 重写了方法 add，这时候如果子类调用继承来的方法 addAll，那么方法 addAll 调用的就不再是父类的 HashSet.add()，而是子类中的方法 MyHashSet.add()。

显然，这样的问题出现后，开发人员会一脸懵逼，子类的写法从表面上看来完全没有问题，这就迫使开发认域去了解父类的实现细节，从而打破了面向对象的封装性，因为封装性是要求隐藏实现细节的。更危险的是，错误不一定能轻易地被测出来，如果开发者不了解超类的实现细节就进行重写，那么可能就埋下了隐患。

第二个使用继承的缺点即父类更新后可能会导致一些不可知的错误，这点很好理解：

• 1）父类更改了方法的签名，会导致编译错误
• 2）父类新增了方法，并且正好和子类的某个方法同名但是返回类型不同，会导致编译错误
• 3）父类新增了方法，并且正好和子类的某个方法的签名完全相同，这时候编译器会认为子类进行了方法重写，会导致编译错误
• 4）......

说到这里，大家大概了解了为什么说要慎重使用继承了吧，「如果使用继承和组合都可以处理某种情况，那么优先使用组合」，组合完美的解决了上述继承的缺点。而如果必须要使用继承，那么应该精心设计父类，防止上述问题的发生，并提供详细的开发文档。