什么是继承？什么是组合？为何说要多用组合少用继承？

什么是继承

继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

/*** 动物*/
public class Animal {public void breathing() {System.out.println("呼气...吸气...");}
}/*** 飞行动物* 继承，可以获得父类属性和方法*/
public class FlyingAnimals extends Animal{public void filying() {System.out.println("飞行...");}public static void main(String[] args) {FlyingAnimals flyingAnimals = new FlyingAnimals();flyingAnimals.breathing();flyingAnimals.filying();}
}

什么是组合

组合是通过对现有对象进行拼装即组合产生新的具有更复杂的功能。

/*** 动物*/
public class Animal {public void breathing() {System.out.println("呼气...吸气...");}
}/*** 爬行动物* 组合，可以获取组合对象的属性和方法*/
public class Reptilia {private Animal animal;public Reptilia(Animal animal) {this.animal = animal;}public void crawling() {System.out.println("爬行...");}public void breathing() {animal.breathing();}public static void main(String[] args) {Animal animal = new Animal();Reptilia reptilia = new Reptilia(animal);reptilia.breathing();;reptilia.crawling();}
}

继承和组合有什么区别和联系

继承最大的一个好处就是代码复用。假如两个类有一些相同的属性和方法，我们就可以将这些相同的部分，抽取到父类中，让两个子类继承父类。这样，两个子类就可以重用父类中的代码，避免代码重复写多遍。不过，这一点也并不是继承所独有的，我们也可以通过其他方式来解决这个代码复用的问题，比如利用组合关系而不是继承关系。

继承是面向对象的四大特性之一，用来表示类之间的 is-a 关系，可以解决代码复用的问题。虽然继承有诸多作用，但继承层次过深、过复杂，也会影响到代码的可维护性。在这种情况下，我们应该尽量少用，甚至不用继承。

继承主要有三个作用：表示 is-a 关系，支持多态特性，代码复用。而这三个作用都可以通过组合、接口、委托三个技术手段来达成。除此之外，利用组合还能解决层次过深、过复杂的继承关系影响代码可维护性的问题。

尽管我们鼓励多用组合少用继承，但组合也并不是完美的，继承也并非一无是处。在实际的项目开发中，我们还是要根据具体的情况，来选择该用继承还是组合。如果类之间的继承结构稳定，层次比较浅，关系不复杂，我们就可以大胆地使用继承。反之，我们就尽量使用组合来替代继承。除此之外，还有一些设计模式、特殊的应用场景，会固定使用继承或者组合。

为什么不推荐使用继承

我们定义一个抽象的“鸟”的类，所有鸟都继承这个类。

AbstractBird 中定义的fly方法并不完全都适用于所有的鸟，比如鸵鸟不会飞，继承父类之后只能重写fly方法，抛出一个异常表示不会飞。
但是这显然违背了里氏替换原则，也违背了我们之后要讲的最小知识原则（Least Knowledge Principle，也叫最少知识原则或者迪米特法则），暴露不该暴露的接口给外部，增加了类使用过程中被误用的概率，也徒增了代码量。

public class AbstractBird {//...省略其他属性和方法...public void fly() { //... }
}public class Ostrich extends AbstractBird { //鸵鸟//...省略其他属性和方法...public void fly() {throw new UnSupportedMethodException("I can't fly.'");}
}

或许我们可以再更细分一下，分别定义会飞的鸟类 AbstractFlyableBird 和不会飞的鸟类 AbstractUnFlyableBird，继承关系就变成了：

但是，鸟会不会飞只是其中一个行为，会不会叫、会不会下蛋……如果每一种行为都定义一个抽象类，那继承关系会越来越复杂，而且都是强耦合性。

所以，继承最大的问题就在于：继承层次过深、继承关系过于复杂会影响到代码的可读性和可维护性。这也是为什么我们不推荐使用继承。

组合的好处

上面关于继承的问题，针对“会飞”这样一个行为特性，我们可以定义一个 Flyable 接口，只让会飞的鸟去实现这个接口。对于会叫、会下蛋这些行为特性，我们可以类似地定义 Tweetable 接口、EggLayable 接口。我们将这个设计思路翻译成 Java 代码的话，就是下面这个样子：

public interface Flyable {void fly();
}
public interface Tweetable {void tweet();
}
public interface EggLayable {void layEgg();
}
public class Ostrich implements Tweetable, EggLayable {//鸵鸟//... 省略其他属性和方法...@Overridepublic void tweet() { //... }@Overridepublic void layEgg() { //... }
}
public class Sparrow impelents Flyable, Tweetable, EggLayable {//麻雀//... 省略其他属性和方法...@Overridepublic void fly() { //... }@Overridepublic void tweet() { //... }@Overridepublic void layEgg() { //... }
}

不过，我们知道，接口只声明方法，不定义实现。也就是说，每个会下蛋的鸟都要实现一遍 layEgg() 方法，并且实现逻辑是一样的，这就会导致代码重复的问题。那这个问题又该如何解决呢？

我们可以针对三个接口再定义三个实现类，它们分别是：实现了 fly() 方法的 FlyAbility 类、实现了 tweet() 方法的 TweetAbility 类、实现了 layEgg() 方法的 EggLayAbility 类。然后，通过组合和委托技术来消除代码重复。具体的代码实现如下所示：

public interface Flyable {void fly()；
}
public class FlyAbility implements Flyable {@Overridepublic void fly() { //... }
}
//省略Tweetable/TweetAbility/EggLayable/EggLayAbilitypublic class Ostrich implements Tweetable, EggLayable {//鸵鸟private TweetAbility tweetAbility = new TweetAbility(); //组合private EggLayAbility eggLayAbility = new EggLayAbility(); //组合//... 省略其他属性和方法...@Overridepublic void tweet() {tweetAbility.tweet(); // 委托}@Overridepublic void layEgg() {eggLayAbility.layEgg(); // 委托}
}

我们知道继承主要有三个作用：表示 is-a 关系，支持多态特性，代码复用。而这三个作用都可以通过其他技术手段来达成。比如 is-a 关系，我们可以通过组合和接口的 has-a 关系来替代；多态特性我们可以利用接口来实现；代码复用我们可以通过组合和委托来实现。所以，从理论上讲，通过组合、接口、委托三个技术手段，我们完全可以替换掉继承，在项目中不用或者少用继承关系，特别是一些复杂的继承关系。

不过，之所以“多用组合少用继承”这个口号喊得这么响，只是因为，长期以来，我们过度使用继承。其实，组合并不完美，继承也不是一无是处。只要我们控制好它们的副作用、发挥它们各自的优势，在不同的场合下，恰当地选择使用继承还是组合，这才是我们所追求的境界。

必须使用继承

一些特殊的场景要求我们必须使用继承。如果你不能改变一个函数的入参类型，而入参又非接口，为了支持多态，只能采用继承来实现。比如下面这样一段代码，其中 FeignClient 是一个外部类，我们没有权限去修改这部分代码，但是我们希望能重写这个类在运行时执行的 encode() 函数。这个时候，我们只能采用继承来实现了。

public class FeignClient { // Feign Client框架代码//...省略其他代码...public void encode(String url) { //... }
}public void demofunction(FeignClient feignClient) {//...feignClient.encode(url);//...
}public class CustomizedFeignClient extends FeignClient {@Overridepublic void encode(String url) { //...重写encode的实现...}
}// 调用
FeignClient client = new CustomizedFeignClient();
demofunction(client);

必须使用组合

比如，Crawler 类和 PageAnalyzer 类，它们都用到了 URL 拼接和分割的功能，但并不具有继承关系（既不是父子关系，也不是兄弟关系）。仅仅为了代码复用，生硬地抽象出一个父类出来，会影响到代码的可读性。如果不熟悉背后设计思路的同事，发现 Crawler 类和 PageAnalyzer 类继承同一个父类，而父类中定义的却只是 URL 相关的操作，会觉得这个代码写得莫名其妙，理解不了。这个时候，使用组合就更加合理、更加灵活。具体的代码实现如下所示：

public class Url {//...省略属性和方法
}public class Crawler {private Url url; // 组合public Crawler() {this.url = new Url();}//...
}public class PageAnalyzer {private Url url; // 组合public PageAnalyzer() {this.url = new Url();}//..
}

参考资料

https://blog.csdn.net/zymx14/article/details/79605926
王争老师《设计模式之美》