🥳🥳🥳 茫茫人海千千万万，感谢这一刻你看到了我的文章，感谢观赏，大家好呀，我是最爱吃鱼罐头，大家可以叫鱼罐头呦~🥳🥳🥳

从今天开始，将开启一个专栏，【贯穿设计模式】，设计模式是对软件设计中普遍存在（反复出现）的各种问题，所提出的解决方案，是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。为了能更好的设计出优雅的代码，为了能更好的提升自己的编程水准，为了能够更好的理解诸多技术的底层源码， 设计模式就是基石，万丈高楼平地起,一砖一瓦皆根基。 ✨✨欢迎订阅本专栏✨✨

🥺 本人不才，如果文章知识点有缺漏、错误的地方 🧐，也欢迎各位人才们评论批评指正！和大家一起学习，一起进步! 👀

❤️ 愿自己还有你在未来的日子，保持学习，保持进步，保持热爱，奔赴山海！ ❤️

💬 最后，希望我的这篇文章能对你的有所帮助！ 🍊 点赞 👍 收藏 ⭐留言 📝 都是我最大的动力！

📃 前言回顾

---

​ 🔥【贯穿设计模式】第一话·设计模式初介绍和单一职责原则🔥

​ 🔥【贯穿设计模式】第二话·设计模式的七大原则之开闭原则🔥

​ 🔥【贯穿设计模式】第三话·设计模式的七大原则之依赖倒转🔥

​ 🔥【贯穿设计模式】第四话·设计模式的七大原则之里氏替换🔥

​ 🔥【贯穿设计模式】第五话·设计模式的七大原则之接口隔离🔥

​ 🔥【贯穿设计模式】第六话·设计模式的七大原则之迪米特法则🔥

在第五篇文章中，我们了解设计模式的七大原则中第六个原则： 迪米特法则；

我们来回顾下，它的定义：一个实体应当尽量少的与其他实体之间发生相互作用，使得系统功能模块相对独立，其核心思想就是在于降低类之间的耦合，要求降低类之间（对象间）耦合关系，并不是要求完全没有依赖关系。

并且我们通过每年放寒暑假时都会布置特别多的作业，接着放假回来老师叫班长收作业的例子，讲述了老师不能跟学生接触，这样违反了迪米特法则，增加了系统的耦合度。值得注意的是：在应用迪米特法则时，我们只需要知道一个对象只能与直接朋友发生交互，不要与陌生人发生直接交互，这样做可以降低系统的耦合度，所以一个方法尽量不引入一个类中不存在的对象。

🐐合成复用原则

今天我们学习的是合成复用原则，尽量使用合成/聚合的方式，而不是使用继承。

🐪概述

• 该原则是指尽量使用合成/聚合的方式，而不是使用继承。就是在一个新的对象里面使用一些已有的对象，使之成为新对象的一部分，新的对象通过这些对象的委派达到复用已有功能的目的。
• 合成复用原则就是在一个新的对象里通过关联关系（包括组合关系和聚合关系）来使用一些已有的对象，使之成为新对象的一部分；新对象通过委派调用已有对象的方法达到复用功能的目的。简言之：复用时要尽量使用组合／聚合关系（关联关系），少用继承；
• 简单理解在系统中实现过程中，首先考虑使用的是组合／聚合，组合／聚合可以使系统更加灵活，降低类与类之间的耦合度，一个类的变化对其他类造成的影响相对较少。其次才考虑继承，在使用继承时，需要严格遵循里氏代换原则，有效使用继承会有助于对问题的理解，降低复杂度，而滥用继承反而会增加系统构建和维护的难度以及系统的复杂度，因此需要慎重使用继承复用；
• 比如有现在有两个类，A类包含着一个method1()方法， 还有一个B类包含method2()方法，此时现在A类的method1()需要用到B类的method2()方法，首先我们考虑是否可以直接使用组合／聚合的方式能够完成，如果不行，再通过继承B类的方法来实现。当然这里可以通过将把B对象作为A类的method1()方法的参数传入method1()方法中使用即可。

🐫特点

合成复用原则主要强调尽量先采用合成/聚合的方式，而不是使用继承，采用组合或聚合复用时，可以将已有对象纳入新对象中，使之成为新对象的一部分，新对象可以调用已有对象的功能，它有以下优点 ：

• 它维持了类的封装性。因为成分对象的内部细节是新对象看不见的，所以这种复用又称为“黑箱”复用。
• 新旧类之间的耦合度低。这种复用所需的依赖较少，新对象存取成分对象的唯一方法是通过成分对象的接口。
• 复用的灵活性高。这种复用可以在运行时动态进行，新对象可以动态地引用与成分对象类型相同的对象。

🦒问题引出

在学生时期，我们都知道学生最重要的任务就是在学校教室上课吧，上不同的课程学习提升自已，已能够在学校取得一个好成绩，而每个学期都可能上不同的课程吧，那接下来我们就以简单的上课来讲解下合成复用原则吧。

1. 先创建个课程类吧Course：

要上课，当然得有课程吧。

package com.ygt.principle.carp;

/**
 * 课程类
 *  包含着不同的课程，如语文、数学等
 */
public class Course {

    // 语文课
    public void studyChinese(){
        System.out.println("正在上语文课！");
    }

    // 数学课
    public void studyMathematics(){
        System.out.println("正在上数学课！");
    }

    // 计算机课
    public void studyComputer(){
        System.out.println("正在上计算机课！");
    }
}

2. 建立个学生类Ygt去继承课程：

继承课程后，就能使用课程的所有公开的方法

package com.ygt.principle.carp;

/**
 * 建立一个学生类ygt
 *  当前使用继承的方式继承课程
 *  使用继承后，我们就可以学习课程内的所有课程
 */
public class Ygt extends Course{
    // 这里也不重写，直接调用课程方法即可
}

3. 创建个测试类测试学生上课学习的过程：

package com.ygt.principle.carp;

/**
 * 合成复用原则的测试类
 */
public class CarpTest {

    public static void main(String[] args) {
        Ygt ygt = new Ygt();
        ygt.studyChinese();
        ygt.studyMathematics();
        ygt.studyComputer();
    }
}

4. 得到结果：

正在上语文课！
正在上数学课！
正在上计算机课！

到这里，是不是发现继承课程类并没有什么问题呢？但是你想下，这里课程肯定包含了很多不同类型的课程（这里只是简单写了三个课程），但是如果另一个学期时，不需要学习计算机课了怎么办，学习计算机的方法就是相当于空方法，而且继承课程类后，后续课程增加任何一个公开的学习课方法时，学生又会自动包含该方法了，这样导致两个类的耦合度增加了，那就违反我们的合成复用原则，下面我们就看看使用合成复用原则的主要核心解决该问题吧。

🐿️解决方案

合成复用原则主要强调尽量先采用合成/聚合的方式，而不是使用继承，所以我们可以先尝试使用合成/聚合的方式来使用课程类。

1. 创建学生类，使用不同的方式进行合成聚合方式：

简单依赖

package com.ygt.principle.carp;

/**
 * 创建一个新的学生类ZhangSan
 * 张三只需要学习语文和数学
 *  使用不同的聚合组合的方式演示
 *  1. 这里使用简单依赖方式，方法传参
 */
public class ZhangSan {

    // 语文课
    public void studyChinese(Course course){
        course.studyChinese();
    }

    // 数学课
    public void studyMathematics(Course course) {
        course.studyMathematics();
    }
}

2. 创建第二个学生类：

组合方式

package com.ygt.principle.carp;

/**
 * 创建第二个新的学生类 LiSi
 * 李四只需要学习语文课即可
 *  使用不同的聚合组合的方式演示
 *  2. 这里使用组合方式
 */
public class LiSi {

    private Course course = new Course();

    // 语文课
    public void studyChinese(){
        course.studyChinese();
    }
}

3. 创建第三个学生类：

聚合方式

package com.ygt.principle.carp;

/**
 * 创建第三个新的学生类 WangWu
 * 王五需要学习语文课、数学课、计算机课
 *  使用不同的聚合组合的方式演示
 *  3. 这里使用聚合方式
 */
public class WangWu {
    private Course course;

    public Course getCourse() {
        return course;
    }

    public void setCourse(Course course) {
        this.course = course;
    }

    // 语文课
    public void studyChinese() {
        course.studyChinese();
    }

    // 数学课
    public void studyMathematics() {
        course.studyMathematics();
    }

    // 计算机课
    public void studyComputer() {
        course.studyComputer();
    }
}

4. 修改测试类：

package com.ygt.principle.carp;

/**
 * 合成复用原则的测试类
 */
public class CarpTest {

    public static void main(String[] args) {
        System.out.println("继承的方式");
        Ygt ygt = new Ygt();
        ygt.studyChinese();
        ygt.studyMathematics();
        ygt.studyComputer();

        System.out.println("简单依赖的方式");
        ZhangSan zhangSan = new ZhangSan();
        Course course = new Course();
        zhangSan.studyChinese(course);
        zhangSan.studyMathematics(course);

        System.out.println("组合的方式");
        LiSi liSi = new LiSi();
        liSi.studyChinese();

        System.out.println("聚合的方式");
        WangWu wangWu = new WangWu();
        wangWu.setCourse(course);
        wangWu.studyChinese();
        wangWu.studyMathematics();
        wangWu.studyComputer();
    }
}

5. 得到结果：

继承的方式
正在上语文课！
正在上数学课！
正在上计算机课！
简单依赖的方式
正在上语文课！
正在上数学课！
组合的方式
正在上语文课！
聚合的方式
正在上语文课！
正在上数学课！
正在上计算机课！

可以看到，我们可以使用不同的组合/聚合的方式来实现调用课程类的方法，并不需要继承课程类，这样不继承的好处，就是我们可以使用想要的方法即可。所以需要记住的是合成复用原则向我们传达的设计理念是：**优先考虑使用“合成”复用，其次在使用“继承”，并不是不使用“继承”。**当然继承也是有其优点的啦。

🌸 完结

相信各位看官看到这里大致都对设计模式中的其中一个原则有了了解吧，合成复用原则指尽量使用合成/聚合的方式，而不是使用继承。就是在一个新的对象里面使用一些已有的对象，使之成为新对象的一部分，新的对象通过这些对象的委派达到复用已有功能的目的。复用时要尽量使用组合／聚合关系（关联关系），少用继承

学好设计模式，让你感受一些机械化代码之外的程序设计魅力，也可以让你理解各个框架底层的实现原理。最后，祝大家跟自己能在程序员这条越走越远呀，祝大家人均架构师，我也在努力。 接下来我们准备正式进入了设计模式的学习中，下一篇先总结设计原则篇。 💪💪💪

文章的最后来个小小的思维导图：

🧐 本人不才，如有什么缺漏、错误的地方，也欢迎各位人才们评论批评指正！🤞🤞🤞

🤩 当然如果这篇文章确定对你有点小小帮助的话，也请亲切可爱的人才们给个点赞、收藏下吧，非常感谢！🤗🤗🤗

🥂 虽然这篇文章完结了，但是我还在，永不完结。我会努力保持写文章。来日方长，何惧车遥马慢！✨✨✨

💟 感谢各位看到这里！愿你韶华不负，青春无悔！让我们一起加油吧！ 🌼🌼🌼

💖 学到这里，今天的世界打烊了，晚安！🌙🌙🌙