设计原则和设计模式

是棍子啊

已于 2024-05-29 22:06:58 修改

阅读量1.7k

点赞数 34

分类专栏： Java课程文章标签：设计模式

于 2024-04-21 22:56:53 首次发布

本文链接：https://blog.csdn.net/m0_64643342/article/details/138045871

版权

Java课程专栏收录该内容

15 篇文章 0 订阅

订阅专栏

知识要点

六大设计原则(也有叫七大设计原则)
23种设计模式

设计原则

1、开闭原则OCP（Open Close Principle）

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

2、里氏替换原则LSP（Liskov Substitution Principle）

所有使用父类的地方可以使用子类的对象，子类可以扩展父类的功能，但是不能替换父类的的功能。如果需要替换父类功能，建议——多用组合，少用继承, 已经有的类和功能直接拿来组合复用(合成复用原则CRP（Composite Reuse Principle), 这里引申出来, 没有单拿出来)。

里氏代换原则是面向对象设计的基本原则之一, 主要针对继承来说, 是继承复用的基石，是对开闭原则的补充。(实现开闭原则的关键步骤就是抽象化，而基类与子类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实现抽象化的具体步骤的规范)

3、依赖倒转原则DIP（Dependence Inversion Principle）

这个是开闭原则的基础，具体内容：针对接口编程，依赖于抽象接口而不依赖于具体实现。改变原有自上而下的依赖方向。

4、接口隔离原则ISP（Interface Segregation Principle）

建立单一接口，不要建立臃肿庞大的接口。接口尽量细化，同时接口中的方法尽量少, 不要违反单一职责原则;

提高接口、类、模块的处理能力，减少对外的交互。(降低耦合)

通过对不同高质量接口的组装，实现服务功能的定制化。

5、迪米特法则/最少知道原则DP（Demeter Principle）

一个实体应当尽量少地与其他实体之间发生相互作用，使得系统功能模块相对独立。调用方只想通过得到自己想要的功能和结果, 不关心被调用方内部如何复杂如何实现.

6、单一职责原则SRP：(Single Reposibility Principle)

一个类或者模块只负责完成某一个单一的功能职责。

设计模式

设计模式一共有23种，分为三大类: 创建型, 结构型, 行为型; 常用的: 单例, 工厂, 代理, 适配器.

创建型设计模式

创建型模式的主要关注点是“怎样创建对象”，它的主要特点是“将对象的创建与使用分离”。这样可以降低系统的耦合度，使用者不需要关注对象的创建细节。

1.单例（Singleton）

某个类只能生成一个实例，该类提供了一个全局访问点供外部获取该实例，节省内存, 其拓展是有限多例模式。

五种实现方式：

饿汉式

/**
 * @description 饿汉式(线程安全，调用效率高，但是不能延时加载)
 **/
public class SingletonDemo1 {

    private static SingletonDemo1 instance = new SingletonDemo1();

    private SingletonDemo1(){}

    public static SingletonDemo1 getInstance(){
        return instance;
    }
}

懒汉式

/**
 * @description 懒汉式(线程安全，调用效率不高，但是能延时加载)
 **/
public class SingletonDemo2 {
    // 类初始化时，不初始化这个对象(延时加载，真正用的时候再创建)
    private static SingletonDemo2 instance;

    // 构造器私有化
    private SingletonDemo2(){}

    // 方法同步，调用效率低
    public static synchronized SingletonDemo2 getInstance() {
        if(instance == null) {
            instance = new SingletonDemo2();
        }
        return instance;
    }
}

双重校验(双重判定锁)

/**
 * @description 双重校验(双重判定)
 **/
public class SingletonDemo3 {

    private volatile static SingletonDemo3 singletonDemo3;

    private SingletonDemo3() {}

    public static SingletonDemo3 newInstance() {
        if (singletonDemo3 == null) {
            synchronized (SingletonDemo3.class) {
                if (singletonDemo3 == null) {
                    singletonDemo3 = new SingletonDemo3();
                }
            }
        }
        return singletonDemo3;
    }
}

静态内部类

/**
 * 问题：为什么这种内部静态类的方式，是线程安全的？
 * 答：首先要了解类加载过程中的最后一个阶段：即类的初始化，类的初始化阶本质就是执行类构造器的<clinit>方法。那么什么是<clinit>方法？
 * 这不是由程序员写的程序，而是根据代码由javac编译器生成的。它是由类里面所有的【静态成员的的赋值语句】和【静态代码块】组成的。JVM内部会保证一个类的
 * <clinit>方法在多线程环境下被正确的加锁同步，也就是说如果多个线程同时去进行“类的初始化”，那么只有一个线程会去执行类的<clinit>方法，其他的线程
 * 都要阻塞等待，直到这个线程执行完<clinit>方法。然后执行完<clinit>方法后，其他线程唤醒，但是不会再进入<clinit>方法。也就是说同一个加载器下，
 * 一个类型只会初始化一次。
 *
 * 那么回到这个代码中，这里的静态变量的赋值操作进行编译之后实际上就是一个<clinit>代码，当我们执行getInstance方法的时候，会导致SingletonClassInstance
 * 类的加载，类加载的最后会执行类的初始化，但是即使在多线程情况下，这个类的初始化的<clinit>代码也只会被执行一次，所以他只会有一个实例。
 *
 * @description 静态内部类（线程安全，调用效率高，可以延时加载）
 **/
public class SingletonDemo4 {
    private SingletonDemo4(){
        System.out.println("SingletonDemo4");
    }

    /** 静态内部类 */
    private static class SingletonClassInstance {
        private static final SingletonDemo4 instance = new SingletonDemo4();
    }

    /** 只有在第一次调用时，才会被创建，可以认为是懒加载的升级版本 */
    public static SingletonDemo4 getInstance(){
        return SingletonClassInstance.instance;
    }

    public static void main(String[] args) {
        System.out.println("args = " + Arrays.deepToString(args));
        SingletonDemo4.getInstance();
        SingletonDemo4.getInstance();
    }
}

枚举类(本身就是单例)

2.原型（Prototype）

将一个对象作为原型，通过对其进行复制而克隆出多个和原型类似的新实例, 不通过new关键字来产生对象。内存中二进制流的拷贝, 性能好于new.

使用场景：

① 类的初始化需要消耗非常多的资源。

② 通过new产生一个对象需要非常繁琐的数据准备或访问。

③ 一个对象需要提供给其他对象访问，而且每个调用者可能都需要修改其值时。

引申:浅拷贝与深拷贝

3.简单工厂

一个工厂类，对实现了同一接口的一些类进行实例的创建，适合创建对象比较少的场景；相对简单,但是违反开闭原则, 一旦类修改或新增类,就要修改工厂, 耦合度高。

简单工厂其实不像是一个设计模式，反而比较像是一种编程习惯.

public class SimplePizzaFactory {
    public Pizza createPizza(String pizzaType) {
        Pizza pizza = null;
        if (pizzaType.equals("cheese")) {
            pizza = new CheesePizza();
        } else if (pizzaType.equals("pepperoni")) {
            pizza = new PepperoniPizza();
        } else if (pizzaType.equals("clam")) {
            pizza = new ClamPizza();
        } else if (pizzaType.equals("veggie")) {
            pizza = new VeggiePizza();
        }
        return pizza;
    }
}

4.工厂方法（Factory Method）

定义了一个创建对象的抽象方法，若干个子工厂类实现接口, 每一个子工厂类固定创建指定的类, 把实例化推迟到子类。

5.抽象工厂（Abstract Factory）

提供一个创建产品族的接口，而不需要明确指定要创建的具体类, 其每个子类可以生产一系列相关的产品。

6.建造者/生成器模式（Builder）

将一个复杂对象分解成多个相对简单的部分，然后根据不同需要分别创建它们，最后构建成该复杂对象。@Builder注解