设计模式六大原则

Milo(xiu)

已于 2023-01-31 17:07:08 修改

阅读量58

点赞数

文章标签：设计模式

于 2023-01-30 15:45:55 首次发布

本文链接：https://blog.csdn.net/qq_48496989/article/details/128799074

版权

单一职责原则

单一职责原则(Single Responsibility Principle, SRP)：一个类只负责一个功能领域中的相应职责，或者可以定义为：就一个类而言，应该只有一个引起它变化的原因。

（1）一个类（或者大到模块，小到方法）承担的职责越多，它被复用的可能性越小，而且如果一个类承担的职责过多，就相当于将这些职责耦合在一起，当其中一个职责变化时，可能会影响其他职责的运作。

（2）类的职责主要包括两个方面:数据职责和行为职责,数据职责通过其属性来体现，而行为职责通过其方法来体现。

（3）单一职责原则是实现高内聚、低耦合的指导方针,在很多代码重构手法中都能找到它的存在,它是最简单但又最难运用的原则，需要设计人员发现类的不同职责并将其分离，而发现类的多重职责需要设计人员具有较强的分析设计能力和相关重构经验。
————————————————
版权声明：本文为CSDN博主「行孤、」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_43403759/article/details/117417230
开闭原则

开闭原则(Open-Closed Principle, OCP)：一个软件实体应当对扩展开放，对修改关闭。即软件实体应尽量在不修改原有代码的情况下进行扩展。

为了满足开闭原则，需要对系统进行抽象化设计，抽象化是开闭原则的关键。
里氏替代原则

里氏替换原则通俗的来讲：子类可以扩展父类的功能，但是子类不能修改父类原有的功能；只要父类能出现的地方子类就可以出现，而且替换为子类也不会产生任何错误或者异常，使用者可能根本不需要知道是父类还是子类。但是反过来就不行了，有子类出现的地方，父类未必就能适应。里氏替换原则就是给继承性的使用制定了规范

里氏替代原则是实现开闭原则的重要方式之一
实现里氏替代原则的要求
1.子类可以实现父类的抽象方法，但不能（尽量不）覆盖父类的非抽象方法
2.子类中可以增加自己特有的方法
3.当子类的方法重载父类的方法时，方法的前置条件（即方法的输入参数）要比父类的方法更宽松
4.当子类的方法实现父类的方法时（重写/重载或实现抽象方法），方法的后置条件（即方法的的输出/返回值）要比父类的方法更严格或相等
https://blog.csdn.net/m0_50414588/article/details/118032730
接口隔离原则

接口隔离原则(Interface Segregation Principle, ISP)：使用多个专门的接口，而不使用单一的总接口，即客户端不应该依赖那些它不需要的接口。

接口隔离原则是设计接口的一个规范，也是单一职责原则的体现。
六大设计模式原则-接口隔离原则_晴天的空间的博客-CSDN博客_接口隔离原则
依赖倒置原则

依赖倒转原则(Dependency Inversion Principle, DIP)：抽象不应该依赖于细节，细节应当依赖于抽象。换言之，要针对接口编程，而不是针对实现编程。

在实现依赖倒转原则时，我们需要针对抽象层编程，而将具体类的对象通过依赖注入(DependencyInjection, DI)的方式注入到其他对象中，依赖注入是指当一个对象要与其他对象发生依赖关系时，通过抽象来注入所依赖的对象。常用的注入方式有三种，分别是：构造注入，设值注入（Setter注入）和接口注入。
————————————————
版权声明：本文为CSDN博主「LoveLion」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/LoveLion/article/details/7562783
依赖倒置原则_SanfordChern的博客-CSDN博客_依赖倒置原则
开闭原则是目标，里氏代换原则是基础，依赖倒转原则是手段
迪米特法则

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

迪米特法则 (Law of Demeter)_小风的笔记的博客-CSDN博客_迪米特法则

设计模式之创建型模式

【大厂面试题系列】：volatile在单例模式中的作用_Code皮皮虾的博客-CSDN博客_单例模式volitaile有什么用
 volatile详解_温JZ的博客-CSDN博客_volatile

简单工厂，工厂方法，抽象工厂（factory）

简单工厂：适用于业务简单，工厂生产的产品确定的情况，不需要经常修改工厂方法的场景。缺点：违反了开闭原则。
工厂方法：解决了简单工厂模式违反开闭原则的缺陷，满足新增产品，只需添加新的产品类和对应工厂类。缺点：如果新产品数量过多，每增加一个产品就要增加一个具体产品类和一个对应的具体工厂类，这增加了系统的复杂度。非常的不太友好。
抽象工厂：是一种为访问类提供一个创建一组相关或相互依赖对象的接口，且访问类无须指定所要产品的具体类就能得到同族的不同等级的产品的模式结构。减少了新产品工厂子类的创建，缺点：如果需要新增一个产品族，所有的工厂方法都需要进行修改。

设计模式|工厂模式详解_一名路过的小码农啊的博客-CSDN博客_设计模式工厂模式详解
 设计模式之工厂设计模式（Factory Pattern）详细剖析_设计模式工厂模式详解_fckey的博客-CSDN博客44 - 工厂模式 - 适用场景 - 简书

单例模式

单例模式常见的实现方式：
饿汉式 -- 同步方法同步代码块 (实现简单，但可能造成内存浪费)
饿汉式 -- 双重校验 + volatile 避免指令重排静态内部类枚举（推荐使用）

/**
 * 单例模式  保证某类只有一个实例对象，并且该类提供一个获取该对象实例的静态方法
 */

// 饿汉式--静态常量
class SingletonHunger1 {
    private SingletonHunger1 () {

    }
    private static SingletonHunger1 instance = new SingletonHunger1();
    public static SingletonHunger1 getInstance() {
        return instance;
    }
}
// 饿汉式--静态代码块
class SingletonHunger2 {
    private SingletonHunger2 () {

    }
    private static SingletonHunger2 instance;

    static {
        instance = new SingletonHunger2();
    }
    public static SingletonHunger2 getInstance() {
        return instance;
    }
}
// 懒汉式 -- 线程不安全  在多线程下，会产生多个实例对象
class SingletonHunger3 {
    private SingletonHunger3 () {}
    private static SingletonHunger3 instance;
    public static SingletonHunger3 getInstance() {
        if (instance == null) {
            instance = new SingletonHunger3();
        }
        return instance;
    }
}
// 懒汉式 -- 线程安全 同步方法 线程较多会影响效率
class SingletonHunger4 {
    private SingletonHunger4 () {}
    private static SingletonHunger4 instance;
    public static synchronized SingletonHunger4 getInstance() {
        if (instance == null) {
            instance = new SingletonHunger4();
        }
        return instance;
    }
}
// 懒汉式 -- 线程安全 双重校验 + 防止指令重排
class SingletonHunger5 {
    private SingletonHunger5 () {}
    private static volatile SingletonHunger5 instance;
    public static SingletonHunger5 getInstance() {
        if (instance == null) {
            synchronized (SingletonHunger5.class) {
                if (instance == null) {
                    instance = new SingletonHunger5();
                }
            }
        }
        return instance;
    }
}
// 静态内部类
class SingletonHunger6 {
    private SingletonHunger6 () {}
    private static class SingletonInstance {
        private static final SingletonHunger6 INSTANCE = new SingletonHunger6();
    }

    public static SingletonHunger6 getInstance() {
        return SingletonInstance.INSTANCE;
    }
}
// 枚举
enum SingletonHunger7 {
    INSTANCE;

    public static SingletonHunger7 getInstace () {
        return INSTANCE;
    }
}

一文带你搞定单例模式 - 知乎

设计模式——单例模式_小叶曲的博客-CSDN博客_设计模式--单例模式

volatile详解_温JZ的博客-CSDN博客_volatile

【大厂面试题系列】：volatile在单例模式中的作用_Code皮皮虾的博客-CSDN博客_单例模式volitaile有什么用

原型模式

原型模式（Prototype Pattern）是用于创建重复的对象，同时又能保证性能。
建造者模式

Milo(xiu)

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
设计模式六大原则

（1）一个类（或者大到模块，小到方法）承担的职责越多，它被复用的可能性越小，而且如果一个类承担的职责过多，就相当于将这些职责耦合在一起，当其中一个职责变化时，可能会影响其他职责的运作。（2）类的职责主要包括两个方面:数据职责和行为职责,数据职责通过其属性来体现，而行为职责通过其方法来体现。（3）
复制链接

扫一扫