【设计模式】六大原则详解,每个原则提供代码示例

【设计模式】多维度轻松记住设计模式的六大原则 设计模式的六大原则是构建优秀软件架构的基石,本文通过六种趣味记忆法帮助开发者轻松掌握这些核心原则。文章提供场景联想、图像记忆、谐音口诀等创意方法,让抽象原则变得生动易记。掌握这些原则能显著提升代码质量和可维护性,其中OCP是设计模式的核心目标,其他原则都是实现它的具体手段。 阅读详情

设计模式六大原则

目录

一、单一职责原则——SRP

📌定义: 一个类应该仅有一个引起它变化的原因。

1、作用

  1. 提高可维护性
  2. 提高可扩展性
  3. 降低耦合度

2、基本要点

  1. 一个类只负责一个职责, 类的设计应该避免包含过多的功能
  2. 高内聚,低耦合:类的内部元素(方法、属性等)应该紧密相关,而与外部的类之间的依赖关系应该尽量降低
  3. 避免滥用接口: 单一职责原则并不要求每个方法都有自己的接口,而是要求类的设计在逻辑上应该是一致的,不涉及无关的功能。

3、举例

考虑一个 User 类,用于表示用户信息,例如用户名和密码。如果我们遵循单一职责原则,这个类应该只负责用户的信息表示,而不涉及与用户认证相关的逻辑。

// 不遵循单一职责原则的例子
public class User {
    private String username;
    private String password;

    public User(String username, String password) {
        this.username = username;
        this.password = password;
    }

    // 不应该包含与用户认证相关的逻辑
    public boolean authenticateUser(String enteredPassword) {
        return this.password.equals(enteredPassword);
    }
}

上述例子中,User 类不仅表示用户的信息,还包含了用户认证的逻辑。这违反了单一职责原则。更好的做法是将用户认证的逻辑移到一个独立的类中:

// 遵循单一职责原则的例子
public class User {
    private String username;
    private String password;

    public User(String username, String password) {
        this.username = username;
        this.password = password;
    }

    // 只负责用户信息的表示,不包含认证逻辑
}

public class Authenticator {
    // 用户认证逻辑
    public boolean authenticateUser(User user, String enteredPassword) {
        return user.getPassword().equals(enteredPassword);
    }
}

二、开放封闭原则——OCP

📌定义: 类、模块、函数应该是可以扩展的,但是不可修改

一个常见的实现开放封闭原则的方式是通过使用抽象和接口。

1、作用

  1. 提高可维护性: 通过遵循开放封闭原则,系统更容易进行扩展而不需要修改已有的代码,从而降低了代码的维护成本。
  2. 提高可扩展性: 新功能的引入不应该影响已有代码,只需通过扩展来添加新功能,这提高了系统的可扩展性。
  3. 降低风险: 通过不修改已有的代码,减少了引入新功能时对系统稳定性的影响,从而降低了系统的风险。

2、基本要点

  1. 对扩展开放,对修改封闭: 意味着已有的代码不应该被修改,新功能的引入应该通过添加新的代码实现。
  2. 通过抽象实现: 通过使用抽象(接口或抽象类)来定义系统的可扩展部分,而具体的实现则通过继承或实现抽象来完成。
  3. 避免直接依赖具体实现: 在代码中尽量避免直接依赖具体的实现,而是依赖于抽象。

3、举例

例如,通过定义接口或抽象类,你可以在不修改现有代码的情况下创建新的实现,并通过接口的引用来使用不同的实现。

// 定义图形接口
public interface Shape {
    void draw();
}

// 实现圆形
public class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing Circle");
    }
}

// 实现矩形
public class Rectangle implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing Rectangle");
    }
}

// 图形绘制系统
public class DrawingSystem {
    // 绘制图形的方法,不依赖于具体的图形类型
    public void drawShape(Shape shape) {
        shape.draw();
    }
}

现在就可以实现不需要修改现有的 DrawingSystem 类,而增加新的功能。

这符合开放封闭原则,通过扩展接口和实现类来引入新的功能,而不影响已有的代码。

三、里氏替换原则——LSP

📌定义: 在任何时候,子类应该能够替代父类而不引起程序的错误。

1、作用

  1. 里氏替换原则是实现开放封闭原则的重要方式之一。
  2. 它克服了继承中重写父类造成的可复用性变差的缺点。
  3. 它是动作正确性的保证。即类的扩展不会给已有的系统引入新的错误,降低了代码出错的可能性。

2、基本要点

  1. 子类必须保留父类的行为,即子类应该覆盖或实现父类的方法,而不应该删除、修改或使其行为不一致。
  2. 子类可以具有自己的特定行为,但不能违反父类的约定
  3. 子类重载父类方法的前置条件1可以比父类宽松,后置条件2需要比父类更加严格或者相等。

3、举例

// 符合里氏替换原则的例子

// 父类
public class Shape {
    protected int width;
    protected int height;

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

    public void setHeight(int height) {
        this.height = height;
    }

    public int calculateArea() {
        return width * height;
    }
}

// 子类-长方形
public class Rectangle extends Shape {
    // 可以保留父类的行为,也可以有自己的特定行为
}

// 另一个子类-正方形
public class Square extends Shape {
    @Override
    public void setWidth(int width) {
        super.setWidth(width);
        super.setHeight(width);  // 正方形的宽高一致
    }

    @Override
    public void setHeight(int height) {
        super.setWidth(height);  // 正方形的宽高一致
        super.setHeight(height);
    }
}

// 在使用父类的地方可以使用其任何子类
public class ExampleUsage {
    public void processShape(Shape shape) {
        int area = shape.calculateArea();
        // 处理其他逻辑
    }
}

关于里氏替换原则的例子,最有名的是“正方形不是长方形”。当然,生活中也有很多类似的例子,例如,企鹅、鸵鸟和几维鸟从生物学的角度来划分,它们属于鸟类;但从类的继承关系来看,由于它们不能继承“鸟”会飞的功能,所以它们不能定义成“鸟”的子类。同样,由于“气球鱼”不会游泳,所以不能定义成“鱼”的子类;“玩具炮”炸不了敌人,所以不能定义成“炮”的子类等。

四、依赖倒置原则——DLP

📌定义:高层模块不应该依赖低层模块,二者都应该依赖抽象。抽象不应该依赖细节,细节应该依赖抽象

在Java中,抽象就是抽象类/接口;细节就是实现类;高层模块就是调用端;底层模块就是具体实现类。

也就是说,模块间依赖是通过抽象发生;实现类之间没有依赖关系,所有的依赖关系通过接口/抽象类产生。

1、作用

  1. 降低类间的耦合性,提高系统的稳定性。
  2. 可以减少并行开发引起的风险。

2、基本要点

  1. 每个类尽量提供接口或抽象类,或者两者都具备。
  2. 变量的声明类型应是接口或者是抽象类。
  3. 任何类都不应该从实现类派生。
  4. 使用继承时尽量遵循里氏替换原则

3、举例

// 抽象
public interface DataService {
    String getData();
}

// 低层模块(数据服务)实现了抽象
public class DatabaseService implements DataService {
    @Override
    public String getData() {
        // 实际的数据获取逻辑
        return "Data from database";
    }
}

// 高层模块(业务逻辑)依赖于抽象
public class BusinessLogic {
    private DataService dataService;

    // 通过构造函数注入依赖
    public BusinessLogic(DataService dataService) {
        this.dataService = dataService;
    }

    public void doSomething() {
        // 使用抽象而不是直接依赖于具体实现
        String data = dataService.getData();
        // 处理业务逻辑
    }
}

五、迪米特法则——LoD

又叫作最少知识原则(Least Knowledge Principle,LKP)

📌定义:只与你的“直接朋友”交谈,不跟“陌生人”说话。也就是说:如果两个软件实体无须直接通信,那么就不应当发生直接的相互调用,可以通过第三方转发该调用。

迪米特法则中的“朋友”:指的是直接的成员、局部变量、方法的参数以及当前对象创建的对象等。

迪米特原则的核心思想:

  1. 一个对象应该对其他对象有最少的了解。
  2. 类与类之间的关系应该尽量降低耦合。

1、作用

  1. 降低耦合度
  2. 提高模块的独立性: 迪米特原则鼓励将系统划分为独立的模块,每个模块只与少数几个其他模块发生直接的联系。
  3. 增强系统的可维护性: 当系统需要进行修改或扩展时,只需要关注当前对象的直接朋友,而不需要关注对象之间的详细关系。

2、基本要点

  1. 只与朋友交流: 一个对象应该对其他对象有最少的了解,只与朋友交流。
  2. 不要轻易访问非直接关联的对象的内部信息: 对于一个对象,只应该调用与之直接关联的对象的方法,而不要去调用非直接关联对象的方法。这有助于降低对象之间的耦合度。
  3. 如果需要一个对象调用另一个对象的某个方法,可以通过第三者转发这个调用

3、举例

考虑一个购物车系统,其中包含顾客、购物车和商品三个类。

根据迪米特原则,顾客类应该尽可能不直接获取商品类的信息,而是通过购物车类来处理商品的添加和删除等操作。

这样可以降低顾客类对商品类的依赖,提高系统的灵活性和可维护性。

在这里插入图片描述

// 商品类
public class Product {
    private String name;

    public Product(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

// 购物车类
public class ShoppingCart {
    private List<Product> products = new ArrayList<>();

    public void addProduct(Product product) {
        products.add(product);
    }

    public void removeProduct(Product product) {
        products.remove(product);
    }
}

// 顾客类
public class Customer {
    private ShoppingCart shoppingCart;

    public Customer(ShoppingCart shoppingCart) {
        this.shoppingCart = shoppingCart;
    }

    public void addToCart(Product product) {
        shoppingCart.addProduct(product);
    }

    public void removeFromCart(Product product) {
        shoppingCart.removeProduct(product);
    }
}

六、接口隔离原则——ISP

📌定义:一个类对另一个类的依赖应该建立在最小的接口上。
该原则还有另一个定义:一个类不应该被强迫依赖于它不使用的接口。

简而言之,接口隔离原则要求一个类对其他类的依赖关系应该建立在最小的接口上,而不是依赖于它不需要的接口。这样可以避免类对不必要的接口产生依赖,减少耦合,提高系统的灵活性和可维护性。

接口隔离原则和单一职责都是为了提高类的内聚性、降低它们之间的耦合性,体现了封装的思想,但两者是不同的:

  • 单一职责原则注重的是职责,而接口隔离原则注重的是对接口依赖的隔离。
  • 单一职责原则主要是约束类,它针对的是程序中的实现和细节;接口隔离原则主要约束接口,主要针对抽象和程序整体框架的构建。

1、作用

  1. 将臃肿庞大的接口分解为多个粒度小的接口,可以预防外来变更的扩散,提高系统的灵活性和可维护性。
  2. 接口隔离提高了系统的内聚性,减少了对外交互,降低了系统的耦合性。

2、基本要点

  1. 一个类不应该依赖它不需要的接口。
  2. 客户端不应该被强制依赖于它不使用的方法。
  3. 接口设计应该精简明了,避免臃肿的接口。

3、举例

考虑一个接口设计的例子,有一个动物接口 Animal,其中包含了两个方法:fly() 和 swim()。

public interface Animal {

  void fly();

  void swim();

}`

现在,有两个类 Bird 和 Fish 分别实现了这个接口。但是,鸟类不需要实现 swim() 方法,鱼类不需要实现 fly() 方法,这就违反了接口隔离原则。

public class Bird implements Animal {

  @Override

  public void fly() {

    System.out.println("Bird is flying");

  }

  @Override

  public void swim() {

    // Bird does not need to swim, but forced to implement the method

    System.out.println("Bird is swimming");

  }

}

public class Fish implements Animal {

  @Override

  public void fly() {

    // Fish does not need to fly, but forced to implement the method

    System.out.println("Fish is flying");

  }

  @Override

  public void swim() {

    System.out.println("Fish is swimming");

  }

}

为了符合接口隔离原则,可以将 Animal 接口拆分为两个接口:IFlyable 和 ISwimmable。

public interface IFlyable {

  void fly();

}

public interface ISwimmable {

  void swim();

}

public class Bird implements IFlyable {

  @Override

  public void fly() {

    System.out.println("Bird is flying");

  }

}

public class Fish implements ISwimmable {

  @Override

  public void swim() {

    System.out.println("Fish is swimming");

  }

}

通过这样的设计,Bird 只需要实现 IFlyable 接口,而 Fish 只需要实现 ISwimmable 接口,避免了不必要的方法实现。这符合接口隔离原则,使得接口更加精简和灵活。


  1. 前置条件(Input Preconditions):当子类重载(overload)父类的方法时,子类的方法的输入参数要比父类的方法更宽松。这意味着子类的方法可以接受更多的输入参数类型,但不能缩小输入参数类型的范围。 ↩︎

  2. 后置条件(Output Postconditions):当子类覆写(override)或重载父类的方法时,子类方法的返回值类型和行为要比父类方法更严格或相等。这确保了子类方法的行为不会违反父类方法的契约,而是更强或相同。 ↩︎

设计模式六大原则详解 经典 设计模式六大原则详解 设计模式原则详解 设计模式原则详解 立即下载

相关推荐

24种设计模式介绍与6大设计原则

24种设计模式介绍与6大设计原则详解。根据实例介绍24种设计模式更生动

设计模式——类与对象设计的六大基本原则

本文介绍了设计模式中的六大基本原则:单一职责原则、开放封闭原则、子类替换父类原则、接口调用原则、类对象交互原则和接口隔离原则。通过具体代码示例,阐述了每个原则的核心思想和应用场景,旨在提高代码的可维护性和灵活性。

庄小焱 6191

手把手教你用TiggerRamDisk绕过iPhone/iPad激活锁(支持iOS16.3,Win/Mac双平台保姆级教程)

本文详细介绍了如何使用TiggerRamDisk工具绕过iPhone/iPad的激活锁,支持iOS16.3系统,并提供Windows和Mac双平台的保姆级教程。从工具准备、设备连接到核心解锁流程,一步步指导用户完成操作,帮助二手设备或旧设备重获新生。

weixin_29323493的博客 958

设计模式(一)——六大原则

设计模式六大原则

m0_47743175的博客 3838

Silvaco二极管、三极管、CMOS的制备

Silvaco二极管和三极管的制备

yytu231的博客 5754

VFIO框架源码分析(一)- 从初始化到设备访问

本文深入剖析了Linux内核中的VFIO(Virtual Function I/O)框架,详细解读了其从初始化到设备访问的全过程。VFIO通过Container->Group->Device的层次化设计,利用IOMMU提供安全隔离,允许用户空间直接访问物理设备。文章基于Linux v5.15版本,重点分析了vfio_init模块入口、Container创建与配置、Group关联以及最终设备访问等关键环节,揭示了VFIO如何通过逐层授权机制构建安全可靠的设备直通模型,为虚拟化技术提供核心支持。

qq_36071928的博客 381

设计模式之美

c++设计模式

心愿许得无限大 3198

PostgreSQL和PostGIS安装、导入shp或gdb格式数据至数据库、使用QGIS测试上传PstGIS数据库操作和代码

本文详细介绍了postgresql和postgis安装步骤,并且使用postgis测试上传shp和gdb格式的矢量数据至数据库,包括步骤和代码,并使用qgis连接postgis数据查看数据库里的数据,数据依旧和本地数据一样可查看可编辑,方便后续数据底座开发和服务。

weixin_46456488的博客 1250

设计模式的六大原则

一、单一职责原则 单一职责原则(SRP),就一个类而言,应该仅有一个引起它变化的原因。 我们在编程的时候,很自然的就会给一个类增加各种各样的功能,比如一个Fun类中,可能包含了各种各样的代码,像一些运算的算法、数据库访问的SQL语句什么的,但如果这样做就意味着,无论任何需求的改变,都需要对Fun类进行更改,维护麻烦,复用不可能,也缺乏灵活性。 如果一个类承担的职责过多,就等于把这些职责耦合在一起,一个职责的变化可能会削弱或者抑制这个类完成其他职责的能力。这种耦合会导致脆弱的设计,当变化发生时,设计会遭受到

m0_55759099的博客 1063

ComfyUI入门学习-教程篇

深入的 ComfyUI 教程,不同功能节点的详细指南。一个比较有意思的Comfyui教程,动画式学习。从安装到基础教程、高级教程再到各种工作流。非常全面,有教程有搭建好的工作流。

wincyfu的博客 1347

华为Ascend_toolkit在x86ubuntu安装失败报错。[WARNING] driver package is not installed. If you install in docker

这个报错发生在交叉编译配置Ascend_toolkit环境时,安装Ascend_toolkit安装包的时候发生。[Y/N]Y。

anananajiushiwo的博客 1026

设计模式的几大原则

设计模式原则,其实就是程序员在编程时,应当遵守的原则, 也是各种设计模式的基础(即: 设计模式为什么这样设计的依据)设计模式常用的六大原则有:①单一职责原则②里氏替换原则③依赖倒转(倒置)原则④接口隔离原则⑤迪米特法则⑥开闭原则什么是单一职责原则呢?

qq_45726327的博客 3222

【人工智能】《Deep Dive into LLMs like ChatGPT 》—— Andrej Karpathy 第三阶段:强化学习(Reinforcement Learning, RL)

摘要:强化学习(RL)阶段通过让模型自主生成并验证答案,突破SFT阶段的模仿局限,使其在数学、代码等领域形成独特的推理路径。RL流程包括批量生成解答、自动批改筛选正确路径,并采用PPO/GRPO算法优化模型。模型会自发涌现自我检查、回滚等策略,显著提升正确率(如AIME竞赛准确率从15%升至56%)。与SFT模型相比,RL模型具备主动链式思维、验算能力,响应时间更长但效果更优,形成真正的“思考模型”。三阶段对比显示,RL通过可验证题的对错奖励机制,赋予模型超越人类范式的推理能力。

奶爸的编程之路,也就一周冷个三天 153

设计模式六大原则

文章目录软件设计的六大原则1. 开放-封闭原则2. 单一职责原则举例3. 里氏替换原则4. 依赖倒置原则举例5. 接口隔离原则6. 迪米特原则举例 软件设计的六大原则 设计模式的六大原则 参考URL: https://zhuanlan.zhihu.com/p/92152190 1. 开放-封闭原则 Open-Close Principle(OCP):一个软件实体如类、模块和函数应该对扩展开放,对修改关闭。目的就是保证程序的扩展性好,易于维护和升级。 对于扩展是开放的,对于更改是封闭的。 开放-封闭原则是面向

西京刀客 1万+

【05】昊一源科技——昊一源科技 嵌入式笔试, 校招,题目记录及解析

本文记录了昊一源科技嵌入式校招笔试题目及解析,涵盖计算机基础、汇编语言、网络协议、C语言编程等内容。主要包括:1)补码真值计算;2)MCS51汇编指令执行后寄存器状态;3)网络广播地址计算;4)TCP协议特点;5)C语言三目运算符应用;6)宏定义优先级问题;7)字符指针与数组的区别;8)C++静态成员变量应用;9)三位完全平方数查找程序。题目难度适中,涉及嵌入式开发常见知识点,对求职者基础能力考察全面。

程序员,他们想的是什么?他们想的永远都是技术,他们崇尚的也永远都是技术。 1312

Devexpress16.2.6破解工具

Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具

设计模式六大原则详解

Single-Responsibilitiy Principle(SRP):对一个类而言,应该仅有一个引起它变化的原因。如果存在多于一个动机去改变一个类,那么这个类就具有多于一个的职责,就应该把多余的职责分离出去,再去创建一些类来完成每一个职责。

eyes++的博客 4720

Camera2Demo

在Camera2 的基础上进行封装,使得Camera2一堆初始化逻辑与Activity分离,降低耦合度,完成预览拍照并保存的操作

设计模式的六大原则详解与应用

在软件开发过程中,**设计模式**帮助开发者创建更高效、灵活且可维护的代码。设计模式不仅仅是一些常见的解决方案,更是一套抽象思维方式,帮助我们设计出符合软件工程原则的架构。设计模式的基础是六大原则,这些原则指引我们如何设计出高内聚、低耦合的代码结构,减少复杂度,增加系统的扩展性和维护性。 本文将详细介绍设计模式中的**六大设计原则**,包括其核心概念、实际应用场景以及每个原则在软件开发中的重要性。

fudaihb的博客 1224

jre9下载 jdk9

(Java SE Runtime Environment 9.0) 9.0u175 官方最新版 【x86|x64】

锂电池充电器电路设计 里面有电路

锂电池充电器电路设计 里面有电路 3.7V升压到5V电路设计。

【iOS】设计模式的六大原则

笔者这段时间看了一下有关于设计模式的七大原则,下面代码示例均为OC。

qq_73106050的博客 1607

【C++】【设计模式的六大原则】

介绍C++设计模式的6个主要原则

zwh1298454060的博客 2381

【设计模式】六大原则详解

ps:写到这里, 我明显感觉我的思考问题的方式在发生着改变, 我们的代码, 应该遵循的一些规范, 往往在人们的生活方式改变的同时改变着, 代码离不开生活, 美好的生活由代码构成, 在今后的社会, 有可能我们的代码就像是科学一样, 人人都应该了解她, 学习她.这样简单明朗,意思深刻 ,当然这些都是我抄的大神的, 有时候没有必要自己写一些代码, 跟着前辈走, 带你少走很多弯路, 有时候总是走自己的路, 尽管得到的更多, 但是并不是每个人都是这样的, 我是前者, 我明白自己的短板.

沙师弟专栏 1582

六大原则与设计模式

迭代器模式的角色: 1. 迭代器:迭代器定义访问和遍历元素的接口 2. 具体迭代器: 实现迭代器接口,对该聚合遍历时跟踪当前位置 3. 聚合: 聚合实现创建相应迭代器的接口,这个操作是返回具体迭代器的实例。2. 变更引起的风险降低,变更是必不可少的,如果接口的单一职责做得好,一个接口修改只对相应的实现类有影响,对其他的接口无影响,这对系统的扩展性、维护性都有非常大的帮助。使用场景: 1.访问一个聚合对象的内容而无需暴露它的内部表示 2.支持对聚合对象的多种遍历 3.为遍历不同的聚合结构提供一个统一的接口。

fengfeiyeqi的博客 1610
上一篇: 【Android】在Android上使用mlKit构建人脸检测程序
下一篇: 【Android】源码解析Activity的结构分析
摸鱼小小虫
博客等级 码龄4年 1万+粉丝 73原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

摸鱼小小虫

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值
⌂ 换网址