软件设计原则

已于 2023-03-10 17:30:03 修改
阅读量282 收藏
点赞数
分类专栏： 设计模式 文章标签： java 开发语言
于 2022-05-10 15:22:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45690465/article/details/124683282
版权

前言

这段时间拿出自己以前的项目代码来看，不看不知道，一看吓一跳，这简直就是shi山，代码见毫无设计可言，可拓展性差，耦合度快到天上去了，决定因此学习设计模式来了解设计之美。

内容学习自 https://www.bilibili.com/video/BV1Np4y1z7BU?spm_id_from=333.337.search-card.all.click

请添加图片描述

1. 开闭原则

开闭原则中，开：对扩展开放，闭：对修改关闭。在程序需要进行拓展的时候，不能去修改原有的代码，实现一个热插拔的效果。简言之，是为了使程序的扩展性好，易于维护和升级。
下面以 搜狗输入法 的皮肤为例介绍开闭原则的应用。

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

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

在这里插入图片描述
代码实现：

**
 * 抽象皮肤类
 */
public abstract class AbstranctSkin {
    // 显示皮肤的方法
    public abstract void display();
}


/**
 * 默认皮肤类
 */
public class DefaultSkin extends AbstranctSkin{
    @Override
    public void display() {
        System.out.println("默认皮肤");
    }
}

public class HeimaSkin extends AbstranctSkin {
    @Override
    public void display() {
        System.out.println("黑马皮肤");
    }
}

/**
 * 搜狗输入法
 */
public class SougoInput {
    private AbstranctSkin abstranctSkin;

    public void setAbstranctSkin(AbstranctSkin abstranctSkin) {
        this.abstranctSkin = abstranctSkin;
    }

    public void display(){
        abstranctSkin.display();
    }
}

/**
 * 测试类
 */
public class Client {
    public static void main(String[] args) {
        // 1.创建sougo输入法对象
        SougoInput sougoInput = new SougoInput();
        // 2.创建皮肤对象
        HeimaSkin heimaSkin = new HeimaSkin();
        // 3.将皮肤设置到搜狗输入法中
        sougoInput.setAbstranctSkin(heimaSkin );
        sougoInput.display();
    }
}

执行结果
在这里插入图片描述
如果现在想要想要出一款新的皮肤，只需要使皮肤类来实现AbstranctSkin接口，在SougoInput里使用自定义的皮肤类对AbstranctSkin进行赋值即可

public class ZJHSkin extends AbstranctSkin{
    @Override
    public void display() {
        System.out.println("大帅哥的皮肤");
    }
}

/**
 * 测试类
 */
public class Client {
    public static void main(String[] args) {
        // 1.创建sougo输入法对象
        SougoInput sougoInput = new SougoInput();
        // 2.创建皮肤对象
        ZJHSkin zjhSkin = new ZJHSkin();
        // 3.将皮肤设置到搜狗输入法中
        sougoInput.setAbstranctSkin(zjhSkin);
        sougoInput.display();
    }
}

结果：
在这里插入图片描述
总结：

  1. 为什么能自定义皮肤类就能更改皮肤？因为皮肤类是实现了AbstranctSkin接口
  2. 就例如电脑的插槽：我们的AbstranctSkin类就相当于一个模板，有了这个模板，我们才可以设计匹配插槽的钥匙，那么如何生效呢？在SougoInput中拿着已经匹配插槽的钥匙，直接使用即可
  3. 所以AbstranctSkin接口是核心，是满足了可拓展性的关键

2. 里氏替换原则

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

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

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

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

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

在这里插入图片描述


/**
 * 长方形
 */
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;
    }
}

/**
 * 正方形
 */
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);
    }
}

public class RectangleDemo {
    public static void main(String[] args) {
        // 创建长方形
        Rectangle rectangle = new Rectangle();
        rectangle.setWidth(10);
        rectangle.setLength(20);
        resize(rectangle);
        printlnLengthAndWidth(rectangle);

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

        // 创建正方形对象
        Square square = new Square();
        square.setLength(10);
        resize(square);
        printlnLengthAndWidth(square);
    }

    // 将图形的长宽设置为一样长度
    public static void resize(Rectangle rectangle) {
        // 如果宽比长小，则进行扩宽操作
        while (rectangle.getWidth() <= rectangle.getLength()) {
            rectangle.setWidth(rectangle.getWidth() + 1);
        }
    }

    public static void printlnLengthAndWidth(Rectangle rectangle){
        System.out.println("长为"+rectangle.getLength()+"  宽为"+ rectangle.getWidth());
    }

}

上述代码中，正方形继承长方形，重写setLength，setWidth方法，在测试类中，将正方形传入到resize方法后出现死循环。

死循环原因：

  1. 因为正方形对边长的修改方法会将长宽同时修改，所以永远满足不了while条件，一直处于循环中，但是长方形的修改边长的方法只是修改一条边，所以长方形循环到某一时刻是能够满足while条件的。所以resize方法满足长方形，但是不能满足正方形，因为正方形重写父类长方形的方法时，将方法逻辑修改了，所以导致不能满足resize方法。

对上述代码进行修改，抽象出四边形的接口，使长方形，正方形实现四边形的接口

在这里插入图片描述

/**
 * 四边形接口
 */
public interface Quadrilateral {
    public double getLength();
    public double getWidth();
}


/**
 * 长方形
 */
public class Rectangle implements Quadrilateral {
    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;
    }
}

/**
 * 正方形
 */
public class Square implements Quadrilateral{

    private double size;

    public double getSize() {
        return size;
    }

    public void setSize(double size) {
        this.size = size;
    }

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

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

public class RectangleDemo {
    public static void main(String[] args) {
        Rectangle rectangle = new Rectangle();
        rectangle.setLength(20);
        rectangle.setWidth(10);
        resize(rectangle);
        printlnLengthAndWidth(rectangle);

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

        Square square = new Square();
        square.setSize(10);
        printlnLengthAndWidth(square);
    }

    public static void resize(Rectangle rectangle) {
        // 如果宽比长小，则进行扩宽操作
        while (rectangle.getWidth() <= rectangle.getLength()) {
            rectangle.setWidth(rectangle.getWidth() + 1);
        }
    }

    public static void printlnLengthAndWidth(Quadrilateral quadrilateral){
        System.out.println("长为"+quadrilateral.getLength()+"  宽为"+ quadrilateral.getWidth());
    }

}

运行结果

在这里插入图片描述

3. 依赖倒转原则

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

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

【例】组装电脑

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

在这里插入图片描述

/**
 * 英特尔cpu
 */
public class InterCpu {
    public void run(){
        System.out.println("使用英特尔处理器");
    }
}

/**
 * 金士顿内存条
 */
public class KingstonMemory {
    public void save(){
        System.out.println("使用金士顿内存条");
    }
}

/**
 * 希捷硬盘
 */
public class XiJieHardDisk {
    public void save(String data){
        System.out.println("使用希捷硬盘存储数据"+data);
    }

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

public class Computer {
    private XiJieHardDisk hardDisk;
    private InterCpu cpu;
    private KingstonMemory memory;

    public XiJieHardDisk getHardDisk() {
        return hardDisk;
    }

    public void setHardDisk(XiJieHardDisk hardDisk) {
        this.hardDisk = hardDisk;
    }

    public InterCpu getCpu() {
        return cpu;
    }

    public void setCpu(InterCpu cpu) {
        this.cpu = cpu;
    }

    public KingstonMemory getMemory() {
        return memory;
    }

    public void setMemory(KingstonMemory memory) {
        this.memory = memory;
    }

    public void run(){
        System.out.println("运行计算机咯");
        hardDisk.save("数据");
        cpu.run();
        memory.save();
    }
}

public class Client {
    public static void main(String[] args) {
        Computer computer = new Computer();
        computer.setCpu(new InterCpu());
        computer.setHardDisk(new XiJieHardDisk());
        computer.setMemory(new KingstonMemory());
        computer.run();
    }
}

上述代码中，实现了InterCPU，希捷硬盘，金士顿内存条，电脑（电脑中包含了InterCPU，希捷硬盘，金士顿内存条），在Client类中进行测试

结果

在这里插入图片描述
上述结果有一个坏处，就是该电脑只能使用InterCPU，希捷硬盘，金士顿内存条。例如我要换一个AMDCPU就不行，因为Computer类中已经明确指定了只能使用InterCPU。所以这就不满足依赖倒转原则。我们应该将Computer依赖于CPU的抽象，而不是具体的实现

改进代码

public interface Cpu {
    public void run();
}

public class AmdCpu implements Cpu{
    @Override
    public void run() {
        System.out.println("AmdCPU running");
    }
}


/**
 * 英特尔cpu
 */
public class InterCpu implements Cpu{
    public void run(){
        System.out.println("使用英特尔处理器");
    }
}


public interface HardDisk {
    public void save(String data);
    public String get();
}

/**
 * 希捷硬盘
 */
public class XiJieHardDisk implements HardDisk{
    public void save(String data){
        System.out.println("使用希捷硬盘存储数据"+data);
    }

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

public interface Menory {
    public void save();
}

/**
 * 金士顿内存条
 */
public class KingstonMemory implements Menory {
    public void save(){
        System.out.println("使用金士顿内存条");
    }
}

public class Computer {
   private Cpu cpu;
   private HardDisk hardDisk;
   private Menory menory;

    public Cpu getCpu() {
        return cpu;
    }

    public void setCpu(Cpu cpu) {
        this.cpu = cpu;
    }

    public HardDisk getHardDisk() {
        return hardDisk;
    }

    public void setHardDisk(HardDisk hardDisk) {
        this.hardDisk = hardDisk;
    }

    public Menory getMenory() {
        return menory;
    }

    public void setMenory(Menory menory) {
        this.menory = menory;
    }

    public void run(){
        System.out.println("运行计算机咯");
        hardDisk.save("数据");
        cpu.run();
        menory.save();
    }
}


public class Client {
    public static void main(String[] args) {
        Computer computer = new Computer();
        computer.setCpu(new AmdCpu());
        computer.setHardDisk(new XiJieHardDisk());
        computer.setMenory(new KingstonMemory());
        computer.run();
    }
}

这样就能够让电脑满足能够使用任意的CPU，硬盘和内存条

在这里插入图片描述

4. 接口隔离原则

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

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

【例】安全门案例

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

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

在这里插入图片描述
接口隔离原则的目的就是不要去实现不需要的方法，而是将接口的方法细粒度化。

5. 迪米特法则

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

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

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

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

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

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

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

类图如下：

在这里插入图片描述

迪米特法则的最主要的目的就是，避免一动而迁全身。避免修改一处地方就需要跟着修改无数处的地方。

6. 合成复用原则

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

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

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

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

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

  1. 它维持了类的封装性。因为成分对象的内部细节是新对象看不见的，所以这种复用又称为“黑箱”复用。
  2. 对象间的耦合度低。可以在类的成员位置声明抽象。
  3. 复用的灵活性高。这种复用可以在运行时动态进行，新对象可以动态地引用与成分对象类型相同的对象。

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

【例】汽车分类管理程序

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

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

那么继承和聚合应该怎么选择呢？

  1. 如果我们使用继承被迫去实现多种方法来维持逻辑正确，那么我们就不要使用继承而是使用聚合
  2. 如果我们使用了聚合，发现几乎需要复制其所有的功能，那么我们就选择继承
..Serendipity
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
软件产品设计
Shyanaqaq的博客
06-23 798
更新和支持：产品软件通常提供持续的更新和支持。开发团队会不断改进和优化产品，修复漏洞，提供新功能和改进的版本，确保产品的稳定性和安全性，并与用户保持良好的沟通和支持。通过良好的用户界面和交互设计，产品软件可以提供直观、易用和愉悦的用户体验，增加用户的满意度和忠诚度。不同用户可能有不同的需求和工作流程，产品软件可以根据用户的要求进行灵活的配置和定制，以满足个性化的需求。设计原则：根据用户需求和目标定位，制定产品的设计原则和指导方针，包括用户界面设计、交互设计和视觉设计等，以确保产品的易用性、美观性和一致性。
什么是软件产品设计？
weixin_70895406的博客
06-22 1584
软件产品设计指的是将客户或用户的需求转化为软件产品的详细设计方案，为软件产品的制作提供了具体的、可行的解决方案。它是在软件开发过程中非常重要的一个阶段，其主要目标是为开发人员提供清晰、准确、详细的软件开发目标，并最大程度地减少后期重构的成本。
【设计模式】软件设计七大原则 ( 单一职责原则 | 代码示例 )
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
08-24 3282
一、单一职责原则简介、 二、单一职责原则代码示例 ( 反面示例 )、 1、不遵循单一职责原则的类、 2、测试类、 三、单一职责原则代码示例 ( 正面示例 | 类的单一职责 )、 1、用翅膀飞的鸟、 2、用脚走的鸟、 3、测试类 四、单一职责原则代码示例 ( 接口的单一职责 )、 1、反面示例、 2、拆分出的接口 1、 3、拆分出的接口 2、 4、接口实现类、 五、单一职责原则代码示例 ( 方法的单一职责 )、 1、反面示例、 2、单一职责示例、
软件产品设计个人经验流程
xsclzy的博客
06-23 214
很多的项目经理或者产品经理，会说，我的业务非常完善，我的流程考虑了所有的情况，但是，实际是，这个业务流程特别复杂和僵硬。其实可以非常简单，让参与的双方沟通，给他们不同的选项，给他们不同选项的原因，就够了，复杂的流程，得简单化。使用的方式再说一遍，就是协同，各方按照简单的业务先后，在系统中协同，保证业务流程进行下去，也给了各方很大的操作空间，我觉得这个是好的想法，也是软件设计的可取之处，软件，这包括研究用户的使用场景、习惯和行为，收集用户意见和反馈，根据实际情况，提炼出用户真正的需求，为设计提供方向。
软件设计原则.pptx
02-05
软件设计原则是软件开发中的核心指导思想，它们旨在提高代码的可读性、可维护性和可扩展性。在本文中，我们将深入探讨这六大设计原则，包括它们的定义、应用场景以及如何通过遵循这些原则来优化软件开发过程。 首先...
软件设计原则与实践
01-24
软件设计原则在嵌入式领域的应用。使用C语言进行解释。结合嵌入式领域的工作实践对设计原则进行具体的解释。
设计模式——6大软件设计原则（demo案例实现，附带解析，快速掌握软件设计原则的精髓）
07-31
该包下的所有demo都是一个个的软件设计原则的案例实现 包含有： 1、开闭原则 2、里氏代换原则 3、依赖倒转原则 4、接口隔离原则 5、迪米特法则 6、合成复用原则 使用了一个个的demo案例，以通俗易懂的生活...
软件设计的基本原则说明
10-14
8. 方案生命周期长设计原则：软件设计应考虑到整个生命周期，能够满足业务需求和用户需求。 在软件设计过程中，需要遵循这些基本原则，以确保软件的质量、效率和可维护性。而且，软件设计也需要考虑到业务发展的...
软件架构设计原则.pdf
03-29
软件架构设计原则
软件设计6原则
07-22
单一责任原则 开放封闭原则 依赖到转原则 里氏替换原则 最少知识原则 迪米特法则
软件工程---软件设计原则
12-06
做就做最好，深入发展必修之课 软件工程，让我们的代码更上一层楼
软件设计原则-面向对象设计七大原则.zip
12-24
软件设计原则-面向对象设计七大原则.zip 面向对象和C语言完全不是一种思考问题的方式,面向对象是种哲学思想,只有明白了其核心思想,才能以不变应万变 只有吃透面向对象的七大设计原则,比如:依赖倒置原则,迪米特法则等...
软件开发设计原则
11-01
软件开发设计原则 软件开发设计原则是指在软件开发过程中所遵循的一些基本原则，这些原则可以帮助开发者编写出更加灵活、可维护、可扩展的代码。这些原则包括单一职责原则、开放封闭原则、里氏替换原则、最少知识...
软件产品设计介绍
最新发布
m0_68061279的博客
06-25 362
软件产品设计是指设计软件产品的用户体验（UX）和用户界面（UI）的过程。它涉及创建软件应用程序的视觉和交互元素，以确保其直观、用户友好，并为用户提供无缝体验。总体而言，软件产品设计结合了以用户为中心的设计原则、创造力和技术知识，以创建引人注目且用户友好的软件应用程序。
软件设计原则 易维护性
05-05
"易维护性"是软件设计中非常重要的一个原则，它指的是软件系统易于被维护、修改和更新。一个易于维护的软件系统可以降低维护成本、提高开发效率和质量，同时也能够更好地适应用户需求的变化。 以下是一些提高软件易...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值