狂神说Java之设计模式

设计模式概述

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

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

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

分类

创建型模式：（描述怎样去创建一个对象，创建和使用分离）

• 单例模式、工厂模式、抽象工厂模式、建造者模式、原型模式

结构型模式：（描述如何将类或对象安装某种类型组成更大的结构）

• 适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式

行为型模式：（描述类和对象如何可以相互协作）

• 模板方法模式、命令模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式、状态模式、策略模式、职责链模式、访问者模式

OOP七大原则

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

里氏替换原则： 继承必须确保超类所拥有的性质在子类中仍然成立（尽量不重写父类的方法）

依赖倒置原则： 要面向接口编程，不要面向实现编程

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

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

迪米特法则： 只与你的直接朋友交谈，不跟“陌生人”说话，降低代码之间的耦合度

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

单例模式

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

饿汉式单例模式：

// 饿汉式单例
public class Hungry {
    
    

    // 可能会浪费空间 
    private byte[] data1 = new byte[1024*1024];
    private byte[] data2 = new byte[1024*1024];
    private byte[] data3 = new byte[1024*1024];
    private byte[] data4 = new byte[1024*1024];

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

    }

    private final static Hungry HUNGRY = new Hungry();

    public static Hungry getInstance(){
    
    
        return HUNGRY;
    }

}

DCL懒汉式单例模式：

// 懒汉式单例
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 还没有完成构造
                          // 为了避免指令重排
                       */
                }
            }
        }

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

    // 单线程下确实单例ok,但是多线程并发
    public static void main(String[] args) {
    
    
        for (int i = 0; i < 10; i++) {
    
    
            new Thread(() -> {
    
    
                LazyMan.getInstance();
            }).start();
        }
    }
}

反射 可以破环这种单例

// 懒汉式单例
// 道高一尺，魔高一丈
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);
    }
}

静态内部类

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

    }

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

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

单例不安全，因为有反射

枚举

// 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);
    }
}

枚举没有无参构造，只有有参构造

工厂设计模式

作用：

• 实现了创建者和调用者的分离
• 详细分类：
  • 简单工厂模式：用来生产同一等级结构中的任意产品（对于增加新的产品，需要扩展已有代码）
  • 工厂方法模式：用来生产同一等级结构中的固定产品（支持增加任意产品）
  • 抽象工厂模式：围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。

工厂设计模式的原则（OOP七大原则）：

• 开闭原则：一个软件的实体应当对扩展开放，对修改关闭
• 依赖倒转原则：要针对接口编程，不要针对实现编程
• 迪米特法则：只与你直接的朋友通信，而避免和陌生人通信

核心本质：

• 实例化对象不使用new，用工厂方法代替 factory
• 将选择实现类，创建对象统一管理和控制。从而将调用者跟我们的实现类解耦

简单工厂模式（静态工厂模式）

用来生产同一等级结构中的任意产品（对于增加新的产品，需要扩展已有代码）

public interface Car {
    
    
    void name();
}

public class WuLing implements Car{
    
    

    @Override
    public void name() {
    
    
        System.out.println("五菱宏光");
    }
}

public class Tesla implements Car{
    
    

    @Override
    public void name() {
    
    
        System.out.println("特斯拉");
    }
}

// 静态工厂模式
// 开闭原则
public class CarFactory {
    
    

    // 方法一： 不满足开闭原则
    public static Car getCar(String car){
    
    
        if(car.equals("wuling")){
    
    
            return new WuLing();
        }else if(car.equals("tesila")){
    
    
            return new Tesla();
        }else {
    
    
            return null;
        }
    }

    // 方法二：
    public static Car geyWuling(){
    
    
        return new WuLing();
    }
    public static Car geyTesla(){
    
    
        return new Tesla();
    }


}

public class Consumer {
    
    
    public static void main(String[] args) {
    
    
        // 接口，所有的实现类
        // Car car = new WuLing();
        // Car car1 = new Tesla();

        // 2、使用工厂创建
        Car car = CarFactory.getCar("wuling");
        Car car1 = CarFactory.getCar("tesila");

        car.name();
        car1.name();
    }
}

弊端：

增加一个新的产品，做不到不修改代码。

工厂方法模式：

用来生产同一等级结构中的固定产品（支持增加任意产品）

public interface Car {
    
    
    void name();
}

public class WuLing implements Car {
    
    

    @Override
    public void name() {
    
    
        System.out.println("五菱宏光");
    }
}

public class Tesla implements Car {
    
    

    @Override
    public void name() {
    
    
        System.out.println("特斯拉");
    }
}

// 工厂方法模式
public interface CarFactory {
    
    
    Car getCar();
}

public class WulingFactory implements CarFactory{
    
    
    @Override
    public Car getCar() {
    
    
        return new WuLing();
    }
}

public class TeslaFactory implements CarFactory{
    
    
    @Override
    public Car getCar() {
    
    
        return new Tesla();
    }
}

public class Consumer {
    
    
    public static void main(String[] args) {
    
    
        Car car = new WulingFactory().getCar();
        Car car1 = new TeslaFactory().getCar();

        car.name();
        car1.name();

        Car car2 = new MoBaiFactory().getCar();
        car2.name();
    }
}

对比简单工厂模式

1、结构复杂度：simple>method

2、代码复杂度：simple>method

3、编程复杂度：simple>method

4、管理上的复杂度：simple>method

根据设计原则，使用工厂方法模式；根据实际业务，使用简单工厂模式

抽象工厂模式：

围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂

定义：

抽象工厂模式提供了一个创建一系列相关或者相互依赖对象的接口，无需指定他们的具体的类（针对整个产品族，产品等级数量相对固定的产品族）

适用场景：

• 客户端（应用层）不依赖于产品类实例如何被创建、实现等细节
• 强调一系列相关的产品对象（属于同一产品族）一起使用创建对象需要大量的重复代码
• 提供一个产品类的库，所有的产品以同样的接口出现，从而使得客户端不依赖于具体实现

// 手机产品接口
public interface IphoneProduct {
    
    

    void start();
    void shutdown();
    void callup();
    void sendSMS();
}

// 小米手机
public class XiaomiPhone implements IphoneProduct{
    
    
    @Override
    public void start() {
    
    
        System.out.println("开启小米手机");
    }

    @Override
    public void shutdown() {
    
    
        System.out.println("关闭小米手机");
    }

    @Override
    public void callup() {
    
    
        System.out.println("小米手机打电话");
    }

    @Override
    public void sendSMS() {
    
    
        System.out.println("小米手机发短信");
    }
}


// 华为手机
public class HuaweiPhone implements IphoneProduct{
    
    
    @Override
    public void start() {
    
    
        System.out.println("开启华为手机");
    }

    @Override
    public void shutdown() {
    
    
        System.out.println("关闭华为手机");
    }

    @Override
    public void callup() {
    
    
        System.out.println("华为手机打电话");
    }

    @Override
    public void sendSMS() {
    
    
        System.out.println("华为手机发短信");
    }
}

// 路由器产品接口
public interface IRouterProduct {
    
    

    void start();
    void shutdown();
    void openWifi();
    void setting();
}

// 小米路由器
public class XiaomiRouter implements IRouterProduct{
    
    
    @Override
    public void start() {
    
    
        System.out.println("启动小米路由器");
    }

    @Override
    public void shutdown() {
    
    
        System.out.println("关闭小米路由器");
    }

    @Override
    public void openWifi() {
    
    
        System.out.println("打开小米Wi-Fi");
    }

    @Override
    public void setting() {
    
    
        System.out.println("小米设置");
    }
}

// 华为路由器
public class HuaweiRouter implements IRouterProduct{
    
    
    @Override
    public void start() {
    
    
        System.out.println("启动华为路由器");
    }

    @Override
    public void shutdown() {
    
    
        System.out.println("关闭华为路由器");
    }

    @Override
    public void openWifi() {
    
    
        System.out.println("打开华为Wi-Fi");
    }

    @Override
    public void setting() {
    
    
        System.out.println("华为设置");
    }
}

// 抽象产品工厂
public interface IProductFactory {
    
    

    // 生产手机
    IphoneProduct iphoneProduct();

    // 生产路由器
    IRouterProduct irouterProduct();

}

public class XiaomiFactory implements IProductFactory{
    
    
    @Override
    public IphoneProduct iphoneProduct() {
    
    
        return new XiaomiPhone();
    }

    @Override
    public IRouterProduct irouterProduct() {
    
    
        return new XiaomiRouter();
    }
}

public class HuaweiFactory implements IProductFactory{
    
    
    @Override
    public IphoneProduct iphoneProduct() {
    
    
        return new HuaweiPhone();
    }

    @Override
    public IRouterProduct irouterProduct() {
    
    
        return new HuaweiRouter();
    }
}

public class Client {
    
    
    public static void main(String[] args) {
    
    
        System.out.println("小米系列产品--------------------");
        // 小米工厂
        XiaomiFactory xiaomiFactory = new XiaomiFactory();

        IphoneProduct iphoneProduct = xiaomiFactory.iphoneProduct();
        iphoneProduct.callup();
        iphoneProduct.sendSMS();

        IRouterProduct iRouterProduct = xiaomiFactory.irouterProduct();
        iRouterProduct.openWifi();

        System.out.println("华为系列产品--------------------");
        // 小米工厂
        HuaweiFactory huaweiFactory = new HuaweiFactory();

        iphoneProduct = huaweiFactory.iphoneProduct();
        iphoneProduct.callup();
        iphoneProduct.sendSMS();

        iRouterProduct = huaweiFactory.irouterProduct();
        iRouterProduct.openWifi();
    }
}

优点

具体产品在应用层的代码隔离，无需关心创建的细节

将一个系列的产品统一到一起创建

缺点：

规定了所有可能被创建的产品集合，产品族中扩展新的产品困难；

增加了系统的抽象性和理解难度

工厂模式小结：

简单工厂模式：虽然某种程度上不符合设计原则，但实际使用最多

工厂方法模式：不修改已有类的前提下，通过增加新的工厂类实现扩展

抽象工厂模式：不可以增加产品，可以增加产品族

应用场景：

• jdk中calendar的getInstance方法
• JDBC中的Connection对象的获取
• Spring中的IOC容器创建管理bean对象
• 反射中Class对象的newInstance方法

建造者模式

它提供了一种创建对象的最佳方式

定义：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示

主要作用：在用户不知道 对象的建造过程和细节 的情况下就可以直接创建复杂的对象。

用户只需要给出指定复杂对象的类型和内容，建造者牧师负责按顺序创建复杂对象（把内部的建造过程和细节隐藏起来）

例如：

• 工厂（建造者模式）：负责制造汽车（组装过程和细节在工厂内）
• 汽车购买者（用户）：你只需要说出你需要的型号（对象的类型和内容），然后直接购买就可以使用了（不需要知道汽车怎么组装的）

// 抽象的建造者：只是定义一些方法和接口
public abstract class Builder {
    
    
    abstract void buildA(); // 地基
    abstract void buildB(); // 钢筋工程
    abstract void buildC(); // 铺电线
    abstract void buildD(); // 粉刷

    // 完工：得到产品
    abstract Product getProduct();
}

// 产品：房子
public class Product {
    
    

    private String buildA;
    private String buildB;
    private String buildC;
    private String buildD;

    public String getBuildA() {
    
    
        return buildA;
    }

    public void setBuildA(String buildA) {
    
    
        this.buildA = buildA;
    }

    public String getBuildB() {
    
    
        return buildB;
    }

    public void setBuildB(String buildB) {
    
    
        this.buildB = buildB;
    }

    public String getBuildC() {
    
    
        return buildC;
    }

    public void setBuildC(String buildC) {
    
    
        this.buildC = buildC;
    }

    public String getBuildD() {
    
    
        return buildD;
    }

    public void setBuildD(String buildD) {
    
    
        this.buildD = buildD;
    }

    @Override
    public String toString() {
    
    
        return "Product{" +
                "buildA='" + buildA + '\'' +
                ", buildB='" + buildB + '\'' +
                ", buildC='" + buildC + '\'' +
                ", buildD='" + buildD + '\'' +
                '}';
    }
}

// 具体的建造者：工人
public class Worker extends Builder {
    
    

    private Product product;

    public Worker() {
    
    
         product = new Product();// 工人负责创建产品
    }

    @Override
    void buildA() {
    
    
        product.setBuildA("地基");
        System.out.println("地基");
    }

    @Override
    void buildB() {
    
    
        product.setBuildB("钢筋工程");
        System.out.println("钢筋工程");
    }

    @Override
    void buildC() {
    
    
        product.setBuildC("铺电线");
        System.out.println("铺电线");
    }

    @Override
    void buildD() {
    
    
        product.setBuildD("粉刷");
        System.out.println("粉刷");
    }

    @Override
    Product getProduct() {
    
    
        return product;
    }
}

// 指挥：核心 负责指挥构建一个工程，工程如何构建，由他决定
public class Director {
    
    

    // 指挥工人按照顺序建房子
    public Product build(Builder builder){
    
    
        builder.buildA();
        builder.buildB();
        builder.buildC();
        builder.buildD();
        return builder.getProduct();
    }
}


public class Test {
    
    
    public static void main(String[] args) {
    
    
        // 指挥
        Director director = new Director();
        // 指挥 具体的工人 完成产品
        Product build = director.build(new Worker());
        System.out.println(build.toString());
    }
}

上面示例是Builder模式的常规用法，Director在builder模式中具有重要的作用，他用于指导具体构建者如何构建产品，**控制调用先后次序，并向调用者返回完整的产品类，**但有些情况下需要简化系统结构，可以把Director和抽象建造者进行结合

通过静态内部类方式实现零件无序装配构造，这种方式使用更加灵活，更符合定义。
内部有复杂对象的默认实现，使用时可以根据用户需求自由定义更改内容，并且无需改变具体的构造方式。就可以生产出不同复杂产品

例如：麦当劳的套餐，服务员（具体建造者）可以随机搭配任意几种产品（零件）组成一款套餐（产品），然后出售给客户。
比第一种方式少了指挥者，主要是因为第二种方式把指挥者交给用户来操作，使得产品创建更加简单灵活

// 抽象的建造者
public abstract class Builder {
    
    
    public abstract Builder builderA(String msg);// 汉堡
    public abstract Builder builderB(String msg);// 可乐
    public abstract Builder builderC(String msg);// 薯条
    public abstract Builder builderD(String msg);// 甜点

    abstract Product getProduct();
}

// 产品 ：套餐
public class Product {
    
    
    private String BuildA = "汉堡" ;
    private String BuildB = "可乐" ;
    private String BuildC = "薯条" ;
    private String BuildD = "甜点" ;

    public String getBuildA() {
    
    
        return BuildA;
    }

    public void setBuildA(String buildA) {
    
    
        BuildA = buildA;
    }

    public String getBuildB() {
    
    
        return BuildB;
    }

    public void setBuildB(String buildB) {
    
    
        BuildB = buildB;
    }

    public String getBuildC() {
    
    
        return BuildC;
    }

    public void setBuildC(String buildC) {
    
    
        BuildC = buildC;
    }

    public String getBuildD() {
    
    
        return BuildD;
    }

    public void setBuildD(String buildD) {
    
    
        BuildD = buildD;
    }

    @Override
    public String toString() {
    
    
        return "Product{" +
                "BuildA='" + BuildA + '\'' +
                ", BuildB='" + BuildB + '\'' +
                ", BuildC='" + BuildC + '\'' +
                ", BuildD='" + BuildD + '\'' +
                '}';
    }
}


// 具体的建造者
public class Woker extends Builder{
    
    

    private  Product product;

    public Woker() {
    
    
        product = new Product();
    }

    @Override
    public Builder builderA(String msg) {
    
    
        product.setBuildA(msg);
        return this;
    }

    @Override
    public Builder builderB(String msg) {
    
    
        product.setBuildB(msg);
        return this;
    }

    @Override
    public Builder builderC(String msg) {
    
    
        product.setBuildC(msg);
        return this;
    }

    @Override
    public Builder builderD(String msg) {
    
    
        product.setBuildD(msg);
        return this;
    }

    @Override
    Product getProduct() {
    
    
        return product;
    }
}

public class Test {
    
    

    public static void main(String[] args) {
    
    
        // 服务员
        Woker woker = new Woker();
        // 链式编程  ：在原来的基础上，可以自由的自合，如果不组合也有固定的套餐
        Product product = woker.builderA("全家桶").builderB("雪碧")
                .getProduct();
        System.out.println(product.toString());
    }
}

优点：

• 产品的建造和表示分离，实现了解耦。使用建造者模式可以使客户端不必知道产品内部组成的细节
• 将复杂产品的创建步骤分解在不同的方法中，是得创建过程更加清晰
• 具体的建造者之间是相互独立的，这有利于系统的扩展。增加新的具体建造者无需修改原有类库代码，符合“开闭原则”

缺点：

• 建造者模式所创建的产品一般具有较多的共同点，其组成部分相似；如果产品之间的差异性很大，则不适合使用建造者模式，因此其使用范围受到一定的限制
• 如果产品的内部变化复杂，可能会导致需要定义很多具体建造者类来实现这种变化，导致系统变的很庞大