23种设计模式

卒获有所闻

已于 2022-09-05 23:40:48 修改

阅读量221

点赞数 1

文章标签：设计模式 java

于 2022-09-05 17:30:15 首次发布

本文链接：https://blog.csdn.net/weixin_54232666/article/details/126708268

版权

设计模式概述

设计模式：是一套用来提高代码可复用性，可维护性、可读性、稳健型以及安全性的解决方案

设计模式的本质：是面向对象设计原则的实际运用，是对类的封装、继承、多态以及类的关联关系和组合关系的充分理解。

设计模式的的基本要素：模式名称、问题、解决方案、效果

面向对象OOP七大原则

开闭原则：对扩展开发，对修改关闭（当需求需要改变的时候，尽量不改原代码，独立去扩展）

里氏替换原则：继承必须确保超类所拥有的性质在子类中仍然成立（尽量添加新的方法和功能，不要修改父类原本的功能）

依赖倒置原则：要面向接口编程，不要面向实现编程（使用接口可以更好的指定规范和约定，具体的细节再交给实现类完成）

单一职责原则：控制类的粒度大小，将对象解耦，提高其内聚性（一个对象不应该担任太多的职责，原子性，单一的方法做单一的事情）

接口隔离原则：要为各个类建立他们需要的专用接口

迪米特法则：只与你的直接朋友交谈，不跟“陌生人”说话，降低代码之间的耦合度（a和b和c三个类，a和b有关系，b和c有关系，a和c没必要交互，可以通过b来转接）

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

单例模式

核心作用：保证一个类只有一个实例，并且提供一个访问该实例的全局访问点

饿汉式

构造器私有化（防止直接new）
类的内部创建对象
向外暴露一个静态的公共方法 getlinstance
代码实现

// 饿汉式单例
public class Hungry {

    // 单例模式核心思想：构造器私有
    private Hungry(){

    }
    
    //在类的内部直接创建对象 
    private final static Hungry HUNGRY = new Hungry();

    //提供个公有的方法getInstance可以返回私有对象
    public static Hungry getInstance(){
        return HUNGRY;
    }
}

为了能在静态方法getInstance中返回私有的对象，需要把对象也弄成静态的（静态方法只能访问静态属性），如果方法不是静态方法的话，那么我们调用方法就必须先创建对象了

因为在调用这个类的其他属性或者怎么样的时候，类的静态属性会先运行，所有会先new出对象，这种单例模式的对象通常是重量级对象，可能创建对象，但是没有用，造成浪费

DCL懒汉式

扔然先构造器私有化
定义一个static静态属性对象，这次不要直接new出来了（new就饿汉一样）、
提供一个public的static方法getInstance可以返回那个对象

使用的时候才创建对象，但是存在线程安全问题（如果第一个个线程在创建new对象的时候没有创建好，第二个线程判断为空进来又可以new一个对象）所有我们需要优化：

// 懒汉式单例
public class LazyMan {
    private LazyMan() {
        System.out.println(Thread.currentThread().getName() + "ok");
    }

    private  volatile static LazyMan lazyMan; //必须加上volatile 防止指令重拍

    // 双重检测锁模式的懒汉式单例  DCL 懒汉式
    public static LazyMan getInstance() {
        if (lazyMan == null) {    
            synchronized (LazyMan.class) {       //我们先加一层锁来保证只有一个线程进来
                if (lazyMan == null) {
                    lazyMan = new LazyMan();// 不是一个原子性操作
                    /*
                    1、分配内存空间
                    2、执行构造方法，初始化对象
                    3、把这个对象指向这个空间
                                        
                    123
                    132 A
                        B // 此时B线程进来会认为lazyman不为null
                          // 直接返回 此时lazyman 还没有完成构造
                          // 为了避免指令重排必须加上volatile
                       */
                }
            }
        }
        return lazyMan;
    }

    public static LazyMan getInstance() {
        if (lazyMan == null) {
            lazyMan = new LazyMan();
        }
        return lazyMan;
    }  
    }
}

两重检测来避免线程问题（面试必须说到）：

我们在检测为空外面在加上一层检测是否为空，加同步锁。为了让a线程进来的时候还没创建完，b线程又进来判断为空继续创建。
我们加了个volatile。因为我们在new的时候可能出现指令重拍，我们是1先分配内存空间，2执行构造方法，初始化对象。3这个对象指向这个空间。但是也有可能132的顺序，如果132在3的时候又有一个线程b进来，就不会认为这个lazyman为空直接不进最外判断，先返回了对象，那么我们就有问题了。所以要加上volatile

静态内部类

// 静态内部类实现单例模式 不安全
public class Holder {
    private Holder(){

    }

    public static Holder getInstance(){
        return InnerClass.HOLDER;
    }

    public static class InnerClass{
        private static final Holder HOLDER = new Holder();
    }
}

我们发现上面这些单例都不安全，因为反射可以破环这些单例

// 懒汉式单例
// 道高一尺，魔高一丈
public class LazyMan {

    private static  boolean qinjiang = false;

    private LazyMan() {
        if(qinjiang == false){
            qinjiang=true;
        }else{
            throw new RuntimeException("不要试图使用反射破坏异常");
        }
//        synchronized (LazyMan.class){
//            if (lazyMan!=null){
//                throw new RuntimeException("不要试图使用反射破坏异常");
//            }
//        }
//        System.out.println(Thread.currentThread().getName() + "ok");
    }

    private  volatile static LazyMan lazyMan; // volatile 为了避免指令重排

    // 双重检测锁模式的懒汉式单例  DCL 懒汉式
    public static LazyMan getInstance() {
        if (lazyMan == null) {
            synchronized (LazyMan.class) {
                if (lazyMan == null) {
                    lazyMan = new LazyMan();// 不是一个原子性操作
                    /*
                    1、分配内存空间
                    2、执行构造方法，初始化对象
                    3、把这个对象指向这个空间

                    123
                    132 A
                        B // 此时B线程进来会认为lazyman不为null
                          // 直接返回 此时lazyman 还没有完成构造
                          // 为了避免指令重排
                       */
                }
            }
        }
        return lazyMan;
    }

    // 单线程下确实单例ok,但是多线程并发
    public static void main(String[] args) throws Exception {
        // 反射 可以破环这种单例
//        LazyMan instance = LazyMan.getInstance();
        Field qinjiang = LazyMan.class.getDeclaredField("qinjiang");
        qinjiang.setAccessible(true);


        Constructor<LazyMan> declaredConstructor =LazyMan.class.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true);//无视私有构造器
        LazyMan  instance=declaredConstructor.newInstance();

        qinjiang.set(instance,false);

        LazyMan  instance2=declaredConstructor.newInstance();

        System.out.println(instance);
        System.out.println(instance2);
    }
}

枚举（自带单例模式）

当我们点开newInstance的源码的时候，我们发现

当我们想用反射破坏枚举的单例的时候，他会报错警告我们不能用反射创建枚举对象

// enum 本身也是一个 class 类
public enum  EnumSingle {

    INSTANCE;

    public EnumSingle getInstance(){
        return INSTANCE;
    }
}

class Test{
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        EnumSingle instance1 = EnumSingle.INSTANCE;
        //Constructor<EnumSingle> declaredConstructor=EnumSingle.class.getDeclaredConstructor(null);
        // 枚举没有无参构造，只有有参构造
        Constructor<EnumSingle> declaredConstructor=EnumSingle.class.getDeclaredConstructor(String.class,int.class);
        declaredConstructor.setAccessible(true);
        EnumSingle instance2 = declaredConstructor.newInstance();

        // java.lang.NoSuchMethodException: com.kuang.single.EnumSingle.<init> 没有空参的构造方法
        // java.lang.IllegalArgumentException: Cannot reflectively create enum objects  反射不能破坏枚举的单例
        System.out.println(instance1);
        System.out.println(instance2);
    }
}

枚举的最终反编译源码发现枚举没有无参构造，只有有参构造