软件设计模式：六大设计原则-阿里云开发者社区

前言

在软件开发中，为了提高软件系统的可维护性和可复用性，增加软件的可扩展性和灵活性，程序员要尽量根据6条原则来开发程序，从而提高软件开发效率、节约软件开发成本和维护成本。

六大设计原则：开闭原则、里氏代换原则、依赖倒转原则、接口隔离原则、迪米特原则、合成复用原则。

一、开闭原则

对扩展开放，对修改关闭。在程序需要进行拓展的时候，不能去修改原有的代码，实现一个热插拔的效果。简言之，是为了使程序的扩展性好，易于维护和升级。

想要达到这样的效果，我们需要使用接口和抽象类。

因为抽象灵活性好，适应性广，只要抽象的合理，可以基本保持软件架构的稳定。而软件中易变的细节可以从抽象派生来的实现类来进行扩展，当软件需要发生变化时，只需要根据需求重新派生一个实现类来扩展就可以了。

下面以搜狗输入法的皮肤为例介绍开闭原则的应用。

【例】搜狗输入法的皮肤设计。

分析：搜狗输入法的皮肤是输入法背景图片、窗口颜色和声音等元素的组合。用户可以根据自己的喜爱更换自己的输入法的皮肤，也可以从网上下载新的皮肤。这些皮肤有共同的特点，可以为其定义一个抽象类（AbstractSkin），而每个具体的皮肤（DefaultSpecificSkin和HeimaSpecificSkin）是其子类。用户窗体可以根据需要选择或者增加新的主题，而不需要修改原代码，所以它是满足开闭原则的。而且就算是厂家上新皮肤，只需要继承抽象类实现就行。

代码实现：

/**
 * @Version: 1.0.0
 * @Author: Dragon_王
 * @ClassName: AbstractSkin
 * @Description: 皮肤抽象类
 * @Date: 2023/12/19 21:34
 */
public abstract class AbstractSkin {
    // 显示的方法
    public abstract void display();
}

/**
 * @Version: 1.0.0
 * @Author: Dragon_王
 * @ClassName: SougouInput
 * @Description: 搜狗输入法
 * @Date: 2023/12/19 21:40
 */
public class SougouInput {
    private AbstractSkin skin;
    public void setSkin(AbstractSkin skin) {
        this.skin = skin;
    }
    public void display() {
        skin.display();
    }
}

/**
 * @Version: 1.0.0
 * @Author: Dragon_王
 * @ClassName: DefaultSkin
 * @Description: 默认皮肤类
 * @Date: 2023/12/19 21:35
 */
public class DefaultSkin extends AbstractSkin{
    @Override
    public void display() {
        System.out.println("默认皮肤");
    }
}

/**
 * @Version: 1.0.0
 * @Author: Dragon_王
 * @ClassName: DragonSkin
 * @Description: 浩泽皮肤类
 * @Date: 2023/12/19 21:38
 */
public class DragonSkin extends AbstractSkin{
    @Override
    public void display() {
        System.out.println("浩泽皮肤");
    }
}

模拟用户选择使用皮肤：

public class Client {
    @Test
    public void testSkin(){
        SougouInput input = new SougouInput();
        // 选择皮肤
        DefaultSkin skin = new DefaultSkin();
        // 设置皮肤
        input.setSkin(skin);
        // 显示
        input.display();
    }
}

二、里氏替换原则

里氏代换原则是面向对象设计的基本原则之一。

里氏代换原则：任何基类可以出现的地方，子类一定可以出现。通俗理解：子类可以扩展父类的功能，但不能改变父类原有的功能。换句话说，子类继承父类时，除添加新的方法完成新增功能外，尽量不要重写父类的方法。

如果通过重写父类的方法来完成新的功能，这样写起来虽然简单，但是整个继承体系的可复用性会比较差，特别是运用多态比较频繁时，程序运行出错的概率会非常大。

下面看一个里氏替换原则中经典的一个例子

【例】正方形不是长方形。

在数学领域里，正方形毫无疑问是长方形，它是一个长宽相等的长方形。所以，我们开发的一个与几何图形相关的软件系统，就可以顺理成章的让正方形继承自长方形。

代码实现：

/**
 * @Version: 1.0.0
 * @Author: Dragon_王
 * @ClassName: Rectangle
 * @Description: 长方形类
 * @Date: 2023/12/20 10:20
 */
public class Rectangle {
    private double length;
    private double width;
    public double getLength() {
        return length;
    }
    public void setLength(double length) {
        this.length = length;
    }
    public double getWidth() {
        return width;
    }
    public void setWidth(double width) {
        this.width = width;
    }
}

/**
 * @Version: 1.0.0
 * @Author: Dragon_王
 * @ClassName: Square
 * @Description: 正方形类
 * @Date: 2023/12/20 10:21
 */
public class Square extends Rectangle {
    public void setWidth(double width) {
        super.setLength(width);
        super.setWidth(width);
    }
    public void setLength(double length) {
        super.setLength(length);
        super.setWidth(length);
    }
}

/**
 * @Version: 1.0.0
 * @Author: Dragon_王
 * @ClassName: RectangleDemo
 * @Description: 变换长宽测试
 * @Date: 2023/12/20 10:24
 */
public class RectangleDemo {
    public static void main(String[] args) {
        Rectangle r = new Rectangle();
        r.setLength(20);
        r.setWidth(10);
        resize(r);
        printLengthAndWithWidth(r);
        Square s = new Square();
        s.setLength(10);
        resize(s);
        printLengthAndWithWidth(r);
    }
    public static void resize(Rectangle rectangle) {
        while (rectangle.getWidth() <= rectangle.getLength()) {
            rectangle.setWidth(rectangle.getWidth() + 1);
        }
    }
    public static void printLengthAndWithWidth(Rectangle rectangle) {
        System.out.println("Length："+rectangle.getLength());
        System.out.println("Width："+rectangle.getWidth());
    }
}

运行发现正方形调用的方法一直没在有显示，仔细分析：那是因为正方形就一个边长，所以我们创建正方形类继承长方形时，让其长宽都等于一个值（正方形的边长），所以在测试类里，变换边长的函数里的while内的判断条件始终是true（rectangle.getWidth() == rectangle.getLength())），所以一直在循环里出不来。

正方形的宽度和长度都在不断增长，代码会一直运行下去，直至系统产生溢出错误。所以，普通的长方形是适合这段代码的，正方形不适合。

我们得出结论：在resize方法中，Rectangle类型的参数是不能被Square类型的参数所代替，如果进行了替换就得不到预期结果。因此，Square类和Rectangle类之间的继承关系违反了里氏代换原则，它们之间的继承关系不成立，正方形不是长方形。

如何改进呢？此时我们需要重新设计他们之间的关系。抽象出来一个四边形接口(Quadrilateral)，让Rectangle类和Square类实现Quadrilateral接口：

/**
 * @Version: 1.0.0
 * @Author: Dragon_王
 * @ClassName: Quadrilateral
 * @Description: 四边形接口
 * @Date: 2023/12/20 10:34
 */
public interface Quadrilateral {
    double getLength();
    double getWidth();
}

/**
 * @Version: 1.0.0
 * @Author: Dragon_王
 * @ClassName: Rectangle
 * @Description: 长方形类
 * @Date: 2023/12/20 10:38
 */
public class Rectangle implements Quadrilateral{
    private double length;
    private double width;
    public void setLength(double length) {
        this.length = length;
    }
    public void setWidth(double width) {
        this.width = width;
    }
    @Override
    public double getLength() {
        return length;
    }
    @Override
    public double getWidth() {
        return width;
    }
}

/**
 * @Version: 1.0.0
 * @Author: Dragon_王
 * @ClassName: Square
 * @Description: 正方形类
 * @Date: 2023/12/20 10:36
 */
public class Square implements Quadrilateral{
    private double side;
    public double getSide() {
        return side;
    }
    public void setSide(double side) {
        this.side = side;
    }
    @Override
    public double getLength() {
        return side;
    }
    @Override
    public double getWidth() {
        return side;
    }
}

/**
 * @Version: 1.0.0
 * @Author: Dragon_王
 * @ClassName: RectangleDemo
 * @Description: TODO(描述)
 * @Date: 2023/12/20 10:39
 */
public class RectangleDemo {
    public static void main(String[] args) {
        Rectangle r = new Rectangle();
        r.setLength(20);
        r.setWidth(10);
        resize(r);
        printLengthAndWidth(r);
    }
    public static void resize(Rectangle rectangle) {
        while (rectangle.getWidth() <= rectangle.getLength()) {
            rectangle.setWidth(rectangle.getWidth() + 1);
        }
    }
    public static void printLengthAndWidth(Quadrilateral quadrilateral) {
        System.out.println("Length：" + quadrilateral.getLength());
        System.out.println("Width：" + quadrilateral.getWidth());
    }
}

这时square对象是无法调用的，resize只能传Rectangle类型

三、依赖倒转原则

高层模块不应该依赖低层模块，两者都应该依赖其抽象；抽象不应该依赖细节，细节应该依赖抽象。简单的说就是要求对抽象进行编程，不要对实现进行编程，这样就降低了客户与实现模块间的耦合。

下面看一个例子来理解依赖倒转原则

【例】组装电脑

现要组装一台电脑，需要配件cpu，硬盘，内存条。只有这些配置都有了，计算机才能正常的运行。选择cpu有很多选择，如Intel，AMD等，硬盘可以选择希捷，西数等，内存条可以选择金士顿，西部数据等。

分析：上面的结构可以看到组装一台电脑，但是似乎组装的电脑的cpu只能是Intel的，内存条只能是金士顿的，硬盘只能是希捷的，这对用户肯定是不友好的，用户有了机箱肯定是想按照自己的喜好，选择自己喜欢的配件。

根据依赖倒转原则进行改进：

代码我们只需要修改Computer类，让Computer类依赖抽象（各个配件的接口），而不是依赖于各个组件具体的实现类。

代码实现：

/**
 * @Version: 1.0.0
 * @Author: Dragon_王
 * @ClassName: Computer
 * @Description: 电脑类
 * @Date: 2023/12/20 16:26
 */
public class Computer {
    private HardDisk hardDisk;
    private Cpu cpu;
    private Memery memery;
    public HardDisk getHardDisk() {
        return hardDisk;
    }
    public void setHardDisk(HardDisk hardDisk) {
        this.hardDisk = hardDisk;
    }
    public Cpu getCpu() {
        return cpu;
    }
    public void setCpu(Cpu cpu) {
        this.cpu = cpu;
    }
    public Memery getMemery() {
        return memery;
    }
    public void setMemery(Memery memery) {
        this.memery = memery;
    }
    public void run(){
        System.out.println("计算机开始工作");
        cpu.run();
        memery.save();
        String data = hardDisk.get();
        System.out.println("从硬盘中获取的数据为：" + data);
    }
}

/**
 * @Version: 1.0.0
 * @Author: Dragon_王
 * @ClassName: Cpu
 * @Description: Cpu接口
 * @Date: 2023/12/20 16:18
 */
public interface Cpu {
    public void  run();
}

/**
 * @Version: 1.0.0
 * @Author: Dragon_王
 * @ClassName: HardDisk
 * @Description: 硬盘接口
 * @Date: 2023/12/20 16:17
 */
public interface HardDisk {
    public void save(String data);
    public String get();
}

/**
 * @Version: 1.0.0
 * @Author: Dragon_王
 * @ClassName: Memery
 * @Description: 内存条接口
 * @Date: 2023/12/20 16:19
 */
public interface Memery {
    public void save();
}

/**
 * @Version: 1.0.0
 * @Author: Dragon_王
 * @ClassName: IntelCpu
 * @Description: 英特尔 Cpu
 * @Date: 2023/12/20 16:23
 */
public class IntelCpu implements Cpu{
    @Override
    public void run() {
        System.out.println("使用Intel处理器");
    }
}

/**
 * @Version: 1.0.0
 * @Author: Dragon_王
 * @ClassName: KingstonMemory
 * @Description: 金士顿内存类
 * @Date: 2023/12/20 16:25
 */
public class KingstonMemory implements Memery{
    @Override
    public void save() {
        System.out.println("使用金士顿作为内存条");
    }
}

/**
 * @Version: 1.0.0
 * @Author: Dragon_王
 * @ClassName: XijieHardDisk
 * @Description: 希捷硬盘类
 * @Date: 2023/12/20 16:19
 */
public class XijieHardDisk implements HardDisk{
    @Override
    public void save(String data) {
        System.out.println("使用希捷硬盘存储数据：" + data);
    }
    @Override
    public String get() {
        System.out.println("使用希捷硬盘取数据");
        return "数据";
    }
}

/**
 * @Version: 1.0.0
 * @Author: Dragon_王
 * @ClassName: TestComputer
 * @Description: 电脑测试类
 * @Date: 2023/12/20 16:28
 */
public class TestComputer {
    public static void main(String[] args) {
        Computer computer = new Computer();
        computer.setCpu(new IntelCpu());
        computer.setHardDisk(new XijieHardDisk());
        computer.setMemery(new KingstonMemory());
        computer.run();
    }
}

四、接口隔离

客户端不应该被迫依赖于它不使用的方法；一个类对另一个类的依赖应该建立在最小的接口上。

下面看一个例子来理解接口隔离原则

【例】安全门案例

我们需要创建一个浩泽品牌的安全门，该安全门具有防火、防水、防盗的功能。可以将防火，防水，防盗功能提取成一个接口，形成一套规范。类图如下：

上面的设计我们发现了它存在的问题，黑马品牌的安全门具有防盗，防水，防火的功能。现在如果我们还需要再创建一个传智品牌的安全门，而该安全门只具有防盗、防水功能呢？很显然如果实现SafetyDoor接口就违背了接口隔离原则，那么我们如何进行修改呢？看如下类图：

代码实现：

/**
 * @Version: 1.0.0
 * @Author: Dragon_王
 * @ClassName: AntiTheft
 * @Description: 防盗功能接口
 * @Date: 2023/12/20 16:33
 */
public interface AntiTheft {
    public void antiTheft();
}

/**
 * @Version: 1.0.0
 * @Author: Dragon_王
 * @ClassName: Fireproof
 * @Description: 防火功能接口
 * @Date: 2023/12/20 16:34
 */
public interface Fireproof {
    public void fireproof();
}

/**
 * @Version: 1.0.0
 * @Author: Dragon_王
 * @ClassName: Waterproof
 * @Description: 防水功能接口
 * @Date: 2023/12/20 16:35
 */
public interface Waterproof {
    public void wateproof();
}

/**
 * @Version: 1.0.0
 * @Author: Dragon_王
 * @ClassName: DragonSafetyDoor
 * @Description: 龙牌安全门
 * @Date: 2023/12/20 16:36
 */
public class DragonSafetyDoor implements AntiTheft,Fireproof,Waterproof{
    @Override
    public void antiTheft() {
        System.out.println("防盗");
    }
    @Override
    public void fireproof() {
        System.out.println("防火");
    }
    @Override
    public void wateproof() {
        System.out.println("防水");
    }
}

/**
 * @Version: 1.0.0
 * @Author: Dragon_王
 * @ClassName: HaozeSafeDoor
 * @Description: 浩泽牌安全门
 * @Date: 2023/12/20 16:38
 */
public class HaozeSafeDoor implements AntiTheft,Fireproof{
    @Override
    public void antiTheft() {
        System.out.println("防盗");
    }
    @Override
    public void fireproof() {
        System.out.println("防火");
    }
}

/**
 * @Version: 1.0.0
 * @Author: Dragon_王
 * @ClassName: TestDoor
 * @Description: TODO(描述)
 * @Date: 2023/12/20 16:38
 */
public class TestDoor {
    public static void main(String[] args) {
        HaozeSafeDoor haozeSafeDoor = new HaozeSafeDoor();
        DragonSafetyDoor dragonSafetyDoor = new DragonSafetyDoor();
        haozeSafeDoor.antiTheft();
        haozeSafeDoor.fireproof();
        dragonSafetyDoor.antiTheft();
        dragonSafetyDoor.fireproof();
        dragonSafetyDoor.wateproof();
    }
}

五、迪米特法则

迪米特法则又叫最少知识原则。

只和你的直接朋友交谈，不跟“陌生人”说话（Talk only to your immediate friends and not to strangers）。

其含义是：如果两个软件实体无须直接通信，那么就不应当发生直接的相互调用，可以通过第三方转发该调用。其目的是降低类之间的耦合度，提高模块的相对独立性。

迪米特法则中的“朋友”是指：当前对象本身、当前对象的成员对象、当前对象所创建的对象、当前对象的方法参数等，这些对象同当前对象存在关联、聚合或组合关系，可以直接访问这些对象的方法。

下面看一个例子来理解迪米特法则

【例】明星与经纪人的关系实例

明星由于全身心投入艺术，所以许多日常事务由经纪人负责处理，如和粉丝的见面会，和媒体公司的业务洽淡等。这里的经纪人是明星的朋友，而粉丝和媒体公司是陌生人，所以适合使用迪米特法则。

类图如下：

代码实现：

/**
 * @Version: 1.0.0
 * @Author: Dragon_王
 * @ClassName: Agent
 * @Description: 经纪人类
 * @Date: 2023/12/20 21:11
 */
public class Agent {
    private Start start;
    private Fans fans;
    private Company company;
    public void setStart(Start start) {
        this.start = start;
    }
    public void setFans(Fans fans) {
        this.fans = fans;
    }
    public void setCompany(Company company) {
        this.company = company;
    }
    public void meeting(){
        System.out.println(fans.getName() + "与明星" + start.getName() + "见面了。");
    }
    public void business() {
        System.out.println(company.getName() + "与明星" + start.getName() + "洽谈业务。");
    }
}

/**
 * @Version: 1.0.0
 * @Author: Dragon_王
 * @ClassName: Company
 * @Description: 公司类
 * @Date: 2023/12/20 21:10
 */
public class Company {
    private String name;
    public Company(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
}

/**
 * @Version: 1.0.0
 * @Author: Dragon_王
 * @ClassName: Fans
 * @Description: 粉丝类
 * @Date: 2023/12/20 21:09
 */
public class Fans {
    private String name;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

/**
 * @Version: 1.0.0
 * @Author: Dragon_王
 * @ClassName: Start
 * @Description: 明星类
 * @Date: 2023/12/20 21:08
 */
public class Start {
    private String name;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

/**
 * @Version: 1.0.0
 * @Author: Dragon_王
 * @ClassName: Test
 * @Description: 测试类
 * @Date: 2023/12/20 21:15
 */
public class Test {
    public static void main(String[] args) {
        Fans fans = new Fans();
        fans.setName("武汉粉丝团");
        Start start = new Start();
        start.setName("浩泽");
        Company company = new Company("华中经济公司");
        Agent agent = new Agent();
        agent.setStart(start);
        agent.setCompany(company);
        agent.setFans(fans);
        agent.meeting();
        agent.business();
    }
}

六、合成复用原则

-合成复用原则是指：尽量先使用组合或者聚合等关联关系来实现，其次才考虑使用继承关系来实现。

通常类的复用分为继承复用和合成复用两种。

继承复用虽然有简单和易实现的优点，但它也存在以下缺点：

继承复用破坏了类的封装性。因为继承会将父类的实现细节暴露给子类，父类对子类是透明的，所以这种复用又称为“白箱”复用。

子类与父类的耦合度高。父类的实现的任何改变都会导致子类的实现发生变化，这不利于类的扩展与维护。

它限制了复用的灵活性。从父类继承而来的实现是静态的，在编译时已经定义，所以在运行时不可能发生变化。

采用组合或聚合复用时，可以将已有对象纳入新对象中，使之成为新对象的一部分，新对象可以调用已有对象的功能，它有以下优点：

它维持了类的封装性。因为成分对象的内部细节是新对象看不见的，所以这种复用又称为“黑箱”复用。

对象间的耦合度低。可以在类的成员位置声明抽象。

复用的灵活性高。这种复用可以在运行时动态进行，新对象可以动态地引用与成分对象类型相同的对象。

下面看一个例子来理解合成复用原则

【例】汽车分类管理程序

汽车按“动力源”划分可分为汽油汽车、电动汽车等；按“颜色”划分可分为白色汽车、黑色汽车和红色汽车等。如果同时考虑这两种分类，其组合就很多。类图如下：

从上面类图我们可以看到使用继承复用产生了很多子类，如果现在又有新的动力源或者新的颜色的话，就需要再定义新的类。我们试着将继承复用改为聚合复用看一下。

总结

以上就是软件设计模式六大设计原则的讲解。

软件设计模式：六大设计原则

前言

一、开闭原则

二、里氏替换原则

三、依赖倒转原则

四、接口隔离

五、迪米特法则

六、合成复用原则

总结

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

软件设计模式：六大设计原则

前言

一、开闭原则

二、里氏替换原则

三、依赖倒转原则

四、接口隔离

五、迪米特法则

六、合成复用原则

总结

热门文章

最新文章

相关课程

相关电子书

相关实验场景