设计模式 ~ 设计原则。

lyfGeek

已于 2023-02-26 20:40:38 修改

阅读量203

点赞数 1

分类专栏：开发。文章标签：设计模式 uml 设计原则

于 2020-12-18 15:41:16 首次发布

本文链接：https://blog.csdn.net/lyfGeek/article/details/111372347

版权

开发。专栏收录该内容

97 篇文章 0 订阅

订阅专栏

设计模式 ~ 设计原则。

文章目录

- 设计模式 ~ 设计原则。

UML 图。

《UML ~ Unified Modeling Language ~ 统一建模语言。》

软件设计原则。

系统软件是控制和协调计算机以及外部设备，支持应用的软件开发和运行的系统，是不需要用户干预的各种程序的集合。主要功能是调度、监控和维护计算机系统，负责管理计算机系统中各种独立的硬件，使得它们可以协调工作。

所以，可以说软件系统是连接需求分析、硬件系统以及使得系统实现的桥梁，对软件的设计应首先了解软件设计的设计原则。

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

开闭原则 ~ Open Closed Principle。

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

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

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

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

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

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

在这里插入图片描述

package com.geek.designprincipalgeek.open.close.principle;

/**
 * 抽象皮肤类。
 *
 * @author geek
 */
public abstract class AbstractClassSkin {

    /**
     * 显示方法。
     */
    abstract void display();

}

package com.geek.designprincipalgeek.open.close.principle;

/**
 * 默认皮肤类。
 *
 * @author geek
 */
public class DefaultSkin extends AbstractClassSkin {

    /**
     * 显示方法。
     */
    @Override
    void display() {
        System.out.println("默认皮肤。");
    }

}

package com.geek.designprincipalgeek.open.close.principle;

/**
 * Geek 皮肤。
 *
 * @author geek
 */
public class GeekSkin extends AbstractClassSkin {

    /**
     * 显示方法。
     */
    @Override
    void display() {
        System.out.println("Geek 皮肤。");
    }

}

package com.geek.designprincipalgeek.open.close.principle;

/**
 * 搜狗输入法。
 *
 * @author geek
 */
public class SogoInput {

    private AbstractClassSkin skin;

    public void setSkin(AbstractClassSkin skin) {
        this.skin = skin;
    }

    /**
     * 显示方法。
     */
    public void display() {
        skin.display();
    }

}

package com.geek.designprincipalgeek.open.close.principle;

/**
 * 开闭原则。
 * 增加新皮肤，不修改原来的代码，增加一个皮肤类。
 *
 * @author geek
 */
public class Client {

    public static void main(String[] args) {
        // 创建搜狗输入法对象。
        SogoInput input = new SogoInput();
        // 创建皮肤对象。
//        AbstractClassSkin skin = new DefaultSkin();
        AbstractClassSkin skin = new GeekSkin();
        // 将皮肤设置到输入法中。
        input.setSkin(skin);
        // 显示皮肤。
        input.display();
    }

}

里氏代换原则 ~ Liskov Substitution Principle。

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

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

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

【eg. 】正方形不是长方形。

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

package com.geek.designprincipalgeek.liskov.substitution.principle.before;

import lombok.Data;

/**
 * 长方形。
 *
 * @author geek
 */
@Data
public class Rectangle {

    private double length;

    private double width;

}

package com.geek.designprincipalgeek.liskov.substitution.principle.before;

/**
 * 正方形。
 *
 * @author geek
 */
public class Square extends Rectangle {

    @Override
    public void setLength(double length) {
        super.setLength(length);
        super.setWidth(length);
    }

    @Override
    public void setWidth(double width) {
        super.setWidth(width);
        super.setLength(width);
    }

}

package com.geek.designprincipalgeek.liskov.substitution.principle.before;

/**
 * @author geek
 */
public class RectangleDemo {

    public static void main(String[] args) {
        // 创建长方形对象。
        Rectangle rectangle = new Rectangle();
        // 设置长和宽。
        rectangle.setLength(20);
        rectangle.setWidth(10);
        // 调用 resize(); 方法进行扩宽。
        resize(rectangle);
        printLengthAndWidth(rectangle);

        System.out.println("～　～　～　～　～　～　～");

        // 创建正方形对象。
        Square square = new Square();
        // 设置长和宽。
        square.setLength(10);
        // 调用 resize(); 方法进行扩宽。
//        resize(square);
//        printLengthAndWidth(square);
    }

    // 运行一下这段代码就会发现，假如把一个普通长方形作为参数传入 resize(); 方法，就会看到长方形宽度逐渐增长的效果，当宽度大于长度，代码就会停止，这种行为的结果符合我们的预期。
    // 假如再把一个正方形作为参数传入 resize(); 方法后，就会看到正方形的宽度和长度都在不断增长，代码会一直运行下去，直至系统产生溢出错误。所以，普通的长方形是适合这段代码的，正方形不适合。
    // 得出结论：在 resize(); 方法中，Rectangle 类型的参数是不能被 Square 类型的参数所代替，如果进行了替换就得不到预期结果。因此，Square 类和 Rectangle 类之间的继承关系违反了里氏代换原则，它们之间的继承关系不成立，正方形不是长方形。

    /**
     * 扩宽方法。
     *
     * @param rectangle
     */
    private static void resize(Rectangle rectangle) {
        // 判断宽如果比长小，进行扩宽操作。
        while (rectangle.getWidth() < rectangle.getLength()) {
            rectangle.setWidth(rectangle.getWidth() + 1);
            printLengthAndWidth(rectangle);
        }
    }

    /**
     * 打印长和宽。
     *
     * @param rectangle
     */
    private static void printLengthAndWidth(Rectangle rectangle) {
        System.out.println(rectangle.getLength() + " ~ " + rectangle.getWidth());
    }

}

改进。

此时我们需要重新设计他们之间的关系。抽象出来一个四边形接口（IQuadrilateral），让 Rectangle 类和 Square 类实现 IQuadrilateral 接口。

在这里插入图片描述

package com.geek.designprincipalgeek.liskov.substitution.principle.after;

/**
 * 四边形接口。
 *
 * @author geek
 */
public interface IQuadrilateral {

    /**
     * 长。
     *
     * @return
     */
    double getLength();

    /**
     * 宽。
     *
     * @return
     */
    double getWidth();

}

package com.geek.designprincipalgeek.liskov.substitution.principle.after;

/**
 * 长方形。
 *
 * @author geek
 */
public class Rectangle implements IQuadrilateral {

    private double length;

    private double width;

    @Override
    public double getLength() {
        return length;
    }

    public void setLength(double length) {
        this.length = length;
    }

    @Override
    public double getWidth() {
        return width;
    }

    public void setWidth(double width) {
        this.width = width;
    }

}

package com.geek.designprincipalgeek.liskov.substitution.principle.after;

/**
 * 正方形。
 *
 * @author geek
 */
public class Square implements IQuadrilateral {

    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;
    }

}

package com.geek.designprincipalgeek.liskov.substitution.principle.after;

/**
 * @author geek
 */
public class RectangleDemo {

    public static void main(String[] args) {
        // 创建长方形对象。
        Rectangle rectangle = new Rectangle();
        rectangle.setLength(20);
        rectangle.setWidth(10);
        // 调用 resize(); 方法进行扩宽。
        resize(rectangle);
        printLengthAndWidth(rectangle);
    }

    /**
     * 扩宽方法。
     *
     * @param rectangle
     */
    private static void resize(Rectangle rectangle) {
        // 判断宽如果比长小，进行扩宽操作。
        while (rectangle.getWidth() <= rectangle.getLength()) {
            rectangle.setWidth(rectangle.getWidth() + 1);
        }
    }

    /**
     * 打印长和宽。
     *
     * @param quadrilateral
     */
    private static void printLengthAndWidth(IQuadrilateral quadrilateral) {
        System.out.println(quadrilateral.getLength() + " ~ " + quadrilateral.getWidth());
    }

}

依赖倒转原则 ~ Dependence Inversion Principle, DIP。

高层模块不应该依赖低层模块，两者都应该依赖其抽象；抽象不应该依赖细节，细节应该依赖抽象。

简单的说就是要求对抽象进行编程，不要对实现进行编程，这样就降低了客户与实现模块间的耦合。

【eg. 】组装电脑。

在这里插入图片描述
现要组装一台电脑，需要配件 cpu，硬盘，内存条。只有这些配置都有了，计算机才能正常的运行。选择 cpu 有很多选择，eg. Intel，AMD 等，硬盘可以选择希捷，西数等，内存条可以选择金士顿，海盗船等。

package com.geek.designprincipalgeek.dependence.inversion.principle.before;

import lombok.Data;

/**
 * @author geek
 */
@Data
public class Computer {

    private IntelCpu cpu;
    private KinstonMemory memory;
    private XijieHardDisk hardDisk;

    public void run() {
        System.out.println("运行计算机。");
        String data = hardDisk.get();
        System.out.println("从硬盘获取的数据 ~ " + data);
        cpu.run();
        memory.save();
    }

}

package com.geek.designprincipalgeek.dependence.inversion.principle.before;

/**
 * Intel cpu。
 *
 * @author geek
 */
public class IntelCpu {

    /**
     * cpu 运行。
     */
    public void run() {
        System.out.println("Intel CPU。");
    }

}

package com.geek.designprincipalgeek.dependence.inversion.principle.before;

/**
 * 金士顿内存。
 *
 * @author geek
 */
public class KinstonMemory {

    /**
     * 内存存储。
     */
    public void save() {
        System.out.println("金士顿内存条。");
    }

}

package com.geek.designprincipalgeek.dependence.inversion.principle.before;

/**
 * 希捷硬盘。
 *
 * @author geek
 */
public class XijieHardDisk {

    /**
     * 存储数据。
     *
     * @param data
     */
    public void save(String data) {
        System.out.println("希捷硬盘存储数据 ~ " + data);
    }

    /**
     * 获取数据。
     *
     * @return
     */
    public String get() {
        System.out.println("希捷硬盘获取数据。");
        return "数据。";
    }

}

package com.geek.designprincipalgeek.dependence.inversion.principle.before;

/**
 * @author geek
 */
public class ComputerDemo {

    public static void main(String[] args) {
        // 创建组件对象。
        IntelCpu cpu = new IntelCpu();
        KinstonMemory memory = new KinstonMemory();
        XijieHardDisk hardDisk = new XijieHardDisk();
        // 组装计算机。
        Computer computer = new Computer();
        computer.setCpu(cpu);
        computer.setMemory(memory);
        computer.setHardDisk(hardDisk);
        // 运行计算机。
        computer.run();
    }

}

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

改进。

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

在这里插入图片描述

package com.geek.designprincipalgeek.dependence.inversion.principle.after;

import lombok.Data;

/**
 * @author geek
 */
@Data
public class Computer {

    private ICpu cpu;
    private IMemory memory;
    private IHardDisk hardDisk;

    public void run() {
        System.out.println("运行计算机。");
        String data = hardDisk.get();
        System.out.println("从硬盘获取的数据 ~ " + data);
        cpu.run();
        memory.save();
    }

}

package com.geek.designprincipalgeek.dependence.inversion.principle.after;

/**
 * cpu 接口。
 *
 * @author geek
 */
public interface ICpu {

    /**
     * cpu 运行。
     */
    void run();

}

package com.geek.designprincipalgeek.dependence.inversion.principle.after;

/**
 * 内存条接口。
 *
 * @author geek
 */
public interface IMemory {

    /**
     * 内存存储。
     */
    void save();

}

package com.geek.designprincipalgeek.dependence.inversion.principle.after;

/**
 * 硬盘接口。
 *
 * @author geek
 */
public interface IHardDisk {

    /**
     * 存储数据。
     *
     * @param data
     */
    void save(String data);

    /**
     * 获取数据。
     *
     * @return
     */
    String get();

}

package com.geek.designprincipalgeek.dependence.inversion.principle.after;

/**
 * Intel cpu。
 *
 * @author geek
 */
public class IntelCpu implements ICpu {

    /**
     * cpu 运行。
     */
    @Override
    public void run() {
        System.out.println("Intel CPU。");
    }

}

package com.geek.designprincipalgeek.dependence.inversion.principle.after;

/**
 * 金士顿内存。
 *
 * @author geek
 */
public class KinstonMemory implements IMemory {

    /**
     * 内存存储。
     */
    @Override
    public void save() {
        System.out.println("金士顿内存条。");
    }

}

package com.geek.designprincipalgeek.dependence.inversion.principle.after;

/**
 * 希捷硬盘。
 *
 * @author geek
 */
public class XijieHardDisk implements IHardDisk {

    /**
     * 存储数据。
     *
     * @param data
     */
    @Override
    public void save(String data) {
        System.out.println("希捷硬盘存储数据 ~ " + data);
    }

    /**
     * 获取数据。
     *
     * @return
     */
    @Override
    public String get() {
        System.out.println("希捷硬盘获取数据。");
        return "数据。";
    }

}

package com.geek.designprincipalgeek.dependence.inversion.principle.after;

/**
 * @author geek
 */
public class ComputerDemo {

    public static void main(String[] args) {
        // 创建组件对象。
        ICpu cpu = new IntelCpu();
        IMemory memory = new KinstonMemory();
        IHardDisk hardDisk = new XijieHardDisk();
        // 组装计算机。
        Computer computer = new Computer();
        computer.setCpu(cpu);
        computer.setMemory(memory);
        computer.setHardDisk(hardDisk);
        // 运行计算机。
        computer.run();
    }

}

要使用 amd cpu，只需要新建一个 amd cpu 类实现 ICpu，不需要修改 Computer 类的代码。

接口隔离原则 ~ Interface Segregation Principle, ISP。

客户端不应该被迫依赖于它不使用的方法。

一个类对另一个类的依赖应该建立在最小的接口上。

在这里插入图片描述
【eg. 】安全门案例。

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

package com.geek.designprincipalgeek.interface1.segregation.principal.before;

/**
 * 安全门接口。
 *
 * @author geek
 */
public interface ISafetyDoor {

    /**
     * 防盗。
     */
    void antiTheft();

    /**
     * 防火。
     */
    void fireProof();

    /**
     * 防水。
     */
    void waterProof();

}

package com.geek.designprincipalgeek.interface1.segregation.principal.before;

/**
 * Geek 品牌安全门。
 *
 * @author geek
 */
public class GeekSafetyDoor implements ISafetyDoor {

    /**
     * 防盗。
     */
    @Override
    public void antiTheft() {
        System.out.println("防盗。");
    }

    /**
     * 防火。
     */
    @Override
    public void fireProof() {
        System.out.println("防火。");
    }

    /**
     * 防水。
     */
    @Override
    public void waterProof() {
        System.out.println("防水。");
    }

}

package com.geek.designprincipalgeek.interface1.segregation.principal.before;

/**
 * @author geek
 */
public class Client {

    public static void main(String[] args) {
        GeekSafetyDoor door = new GeekSafetyDoor();
        door.antiTheft();
        door.antiTheft();
        door.waterProof();
    }

}

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

在这里插入图片描述

package com.geek.designprincipalgeek.interface1.segregation.principal.after;

/**
 * 防盗接口。
 *
 * @author geek
 */
public interface IAntiTheft {

    /**
     * 防盗。
     */
    void antiTheft();

}

package com.geek.designprincipalgeek.interface1.segregation.principal.after;

/**
 * 防火接口。
 *
 * @author geek
 */
public interface IFireProof {

    /**
     * 防火。
     */
    void fireProof();

}

package com.geek.designprincipalgeek.interface1.segregation.principal.after;

/**
 * 防水接口。
 *
 * @author geek
 */
public interface IWaterProof {

    /**
     * 防水。
     */
    void waterProof();

}

package com.geek.designprincipalgeek.interface1.segregation.principal.after;

/**
 * Li 品牌安全门。
 *
 * @author geek
 */
public class LiSafetyDoor implements IAntiTheft, IFireProof {

    @Override
    public void antiTheft() {
        System.out.println("防盗。");
    }

    @Override
    public void fireProof() {
        System.out.println("防火。");
    }

}

package com.geek.designprincipalgeek.interface1.segregation.principal.after;

/**
 * Geek 品牌安全门。
 *
 * @author geek
 */
public class GeekSafetyDoor implements IAntiTheft, IFireProof, IWaterProof {

    @Override
    public void antiTheft() {
        System.out.println("防盗。");
    }

    @Override
    public void fireProof() {
        System.out.println("防火。");
    }

    @Override
    public void waterProof() {
        System.out.println("防水。");
    }

}

package com.geek.designprincipalgeek.interface1.segregation.principal.after;

/**
 * @author geek
 */
public class Client {

    public static void main(String[] args) {
        GeekSafetyDoor door = new GeekSafetyDoor();
        door.antiTheft();
        door.fireProof();
        door.waterProof();

        System.out.println("～　～　～　～　～　～　～");

        LiSafetyDoor door1 = new LiSafetyDoor();
        door1.antiTheft();
        door1.fireProof();
    }

}

迪米特法则 ~ Law of Demeter。

迪米特法则（Law of Demeter）又叫作最少知识原则（The Least Knowledge Principle），一个类对于其他类知道的越少越好，就是说一个对象应当对其他对象有尽可能少的了解，只和朋友通信，不和陌生人说话。英文简写为：LOD。

Talk only to your immediate friends.

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

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

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

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

类图如下。

在这里插入图片描述

package com.geek.designprincipalgeek.law.of.demeter;

import lombok.AllArgsConstructor;
import lombok.Data;

/**
 * 明星类。
 *
 * @author geek
 */
@Data
@AllArgsConstructor
public class Star {

    private String name;

}

package com.geek.designprincipalgeek.law.of.demeter;

import lombok.AllArgsConstructor;
import lombok.Data;

/**
 * 粉丝类。
 *
 * @author geek
 */
@Data
@AllArgsConstructor
public class Fans {

    String name;

}

package com.geek.designprincipalgeek.law.of.demeter;

import lombok.AllArgsConstructor;
import lombok.Data;

/**
 * 媒体公司类。
 *
 * @author geek
 */
@Data
@AllArgsConstructor
public class Company {

    private String name;

}

package com.geek.designprincipalgeek.law.of.demeter;

import lombok.Data;

/**
 * 经纪人类。
 *
 * @author geek
 */
@Data
public class Agent {

    private Star star;
    private Fans fans;
    private Company company;

    public void meeting() {
        System.out.println(fans.getName() + " 与明星 " + star.getName() + " 见面。");
    }

    public void business() {
        System.out.println(company.getName() + " 与明星 " + star.getName() + " 洽谈业务。");
    }

}

package com.geek.designprincipalgeek.law.of.demeter;

/**
 * @author geek
 */
public class Client {

    public static void main(String[] args) {
        // 创建经纪人类。
        Agent agent = new Agent();
        // 明星对象。
        Star star = new Star("林青霞");
        agent.setStar(star);
        // 粉丝对象。
        Fans fans = new Fans("张三");
        agent.setFans(fans);
        // 媒体公司对象。
        Company company = new Company("Geek 媒体公司");
        agent.setCompany(company);

        agent.business();
        agent.meeting();
    }

}

合成复用原则 ~ Composite/Aggregate Reuse Principle, CARP。

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

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

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

继承复用破坏了类的封装性。因为继承会将父类的实现细节暴露给子类，父类对子类是透明的，所以这种复用又称为“白箱”复用。
子类与父类的耦合度高。父类的实现的任何改变都会导致子类的>实现发生变化，这不利于类的扩展与维护。
ta 限制了复用的灵活性。从父类继承而来的实现是静态的，在编译时已经定义，所以在运行时不可能发生变化。

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