二十三种设计模式，快速入门

江南_烟雨.

于 2022-10-01 10:36:39 发布

阅读量187

点赞数

分类专栏：设计模式文章标签：设计模式 java 开发语言

本文链接：https://blog.csdn.net/a2120454642/article/details/127132285

版权

设计模式专栏收录该内容

1 篇文章 0 订阅

订阅专栏

设计模式

一、设计七大原则

1、单一职责原则

细节：

降低类的复杂度，一个类只负责一项职责
提高类的可读性，可维护性
降低变更引起的风险
通常情况下，我们应当遵守单一职责原则，只有逻辑足够简单，才可以在代码级违反单一之职责原则；只有类中方法数量足够少，可以在方法级别保持单一职责原则

2、接口隔离原则

基本介绍：

客户端不应该依赖它不需要的接口，即一个类对另一个类的依赖应该建立在最小的接口上
先看一张图
将接口Interface1拆分成三个接口，类A和类C分别与他们需要的接口建立依赖关系。也就是采用接口隔离原则

3、依赖倒置原则

基本介绍

高层模块不应该依赖于低层模块，二者都应该依赖于抽象
抽象不应该依赖于细节，细节应该依赖于抽象
依赖倒置的中心思想是面向接口编程
依赖倒置原则是基于这样的设计理念：相对于细节的多变性，抽象的东西是稳定的多。以抽象为基础搭建的架构比以细节为基础的要稳定的多。在java中，抽象指的是接口和抽象类，细节就是具体的实现类
使用接口或抽象类的目的是制定好规范，而不涉及任何具体的操作，把展现细节的任务交给他们的实现类去完成

注意事项和细节

低层模块尽量都要有抽象类或者接口，或者两者都有，程序稳定性更好
变量的声明类型尽量是抽象类或者接口，这样我们的变量引用和实际对象之间，就存在一个缓存层，利于程序扩展和优化
继承时遵循里氏替换原则

4、里氏替换原则

基本介绍

里氏替换原则是一个麻省理工学院的一位姓里的女士提出
如果每个类型为T1的对象o1，都有类型T2的对象o2，使得以T1定义的所有程序P在所有的对象o1都替换成o2时，程序P的行为没有发生变化，那么类型T2是类型T1的子类型。换句话说，所有引用基类的地方必须能透明的使用其子类的对象。
在使用继承时，遵循里氏替换原则，在子类中尽量不要重写父类的方法
里氏替换原则告诉我们，继承实际上让两个类的耦合性增强了在适当的情况下，可以通过聚合，组合，依赖来解决问题

5、开闭原则

基本介绍

最基础最重要的设计原则
一个软件实体如类，模块，函数应该对扩展开放（对提供方），对修改关闭（对使用方）。用抽象构建框架，用实现扩展细节
当软件变化时，尽量通过扩展软件实体的行为来实现变化，而不是通过修改已有的代码来实现变化
编程中遵循其他原则，以及使用设计模式的目的就是遵循开闭原则

6、迪米特原则

基本介绍

一个对象应该对其他对象保持最少的了解
类与类关系越密切，耦合度越大
迪米特法则(Demeter Principle)又叫最少知道原则，即一个类对自己依赖的类知道的越少越好。也就是说，对于被依赖的类不管多么复杂，都尽量将逻辑封装在类的内部。对外除了提供的public 方法，不对外泄露任何信息
迪米特法则还有个更简单的定义：只与直接的朋友通信
直接的朋友：每个对象都会与其他对象有耦合关系，只要两个对象之间有耦合关系，我们就说这两个对象之间是朋友关系。耦合的方式很多，依赖，关联，组合，聚合等。其中，我们称出现成员变量，方法参数，方法返回值中的类为直接的朋友，而出现在局部变量中的类不是直接的朋友。也就是说，陌生的类最好不要以局部变量的形式出现在类的内部。

细节

迪米特法则的核心是降低类之间的耦合
但是注意：由于每个类都减少了不必要的依赖，因此迪米特法则只是要求降低类间(对象间)耦合关系，并不是要求完全没有依赖关系

7、合成复用原则

原则是尽量使用合成/聚合的方式，而不是使用继承

二、设计模式类型

设计模式分为三种类型，共23种

创建型模式：单例模式、抽象工厂模式、原型模式、建造者模式、工厂模式。
结构型模式：适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式。
行为型模式：模版方法模式、命令模式、访问者模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式（Interpreter模式）、状态模式、策略模式、职责链模式(责任链模式)。

1、创建型模式——单例模式

所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法(静态方法)。

单例设计模式八种方式

①、饿汉式(静态常量)

步骤如下：

构造器私有化 (防止 new ) 
类的内部创建对象 
向外暴露一个静态的公共方法。getInstance 
代码实现

//饿汉式（静态变量）
class Singleton {
    //    1.构造器私有化，外部不能new
    private Singleton() {

    }

    //    2.本类内部创建对象实例
    private final static Singleton instance = new Singleton();

    //    3.对外提供一个公有的静态方法，返回实例对象
    public static Singleton getInstance() {
        return instance;
    }
}

优缺点说明：

优点：这种写法比较简单，就是在类装载的时候就完成实例化。避免了线程同步问题。
缺点：在类装载的时候就完成实例化，没有达到Lazy Loading的效果。如果从始至终从未使用过这个实例，则会造成内存的浪费
这种方式基于classloder机制避免了多线程的同步问题，不过，instance在类装载时就实例化，在单例模式中大多数都是调用getInstance方法，但是导致类装载的原因有很多种，因此不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化instance就没有达到lazy loading的效果
结论：这种单例模式可用，可能造成内存浪费

②、饿汉式（静态代码块）（推荐）

//饿汉式（静态代码块）
class Singleton {
    //    1.构造器私有化，外部不能new
    private Singleton() {
		
    }

    //    2.本类内部创建对象实例
    private static Singleton instance;

    static {
        //    3、在静态代码块中，创建单例对象
        instance = new Singleton();
    }

    //    3.对外提供一个公有的静态方法，返回实例对象
    public static Singleton getInstance() {
        return instance;
    }
}

优缺点说明：

这种方式和上面的方式其实类似，只不过将类实例化的过程放在了静态代码块中，也是在类装载的时候，就执行静态代码块中的代码，初始化类的实例。优缺点和上面是一样的。
结论：这种单例模式可用，但是可能造成内存浪费

③、懒汉式(线程不安全)

class Singleton {
    private static Singleton instance;

    private Singleton() {
    }

    //提供给一个静态的公有方法，当时用到该方法时，才去创建instance
    //即懒汉式
    public static Singleton instance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

优缺点说明：

起到了Lazy Loading的效果，但是只能在单线程下使用。
如果在多线程下，一个线程进入了if (singleton == null)判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例。所以在多线程环境下不可使用这种方式
结论：在实际开发中，不要使用这种方式.

④、懒汉式(线程安全，同步方法)

//懒汉式(线程安全，同步方法)
class Singleton {
    private static Singleton instance;

    private Singleton() {
    }

    //提供给一个静态的公有方法，加入同步处理的代码，解决线程安全问题
    //即懒汉式
    public static synchronized Singleton instance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

优缺点说明：

解决了线程不安全问题
效率太低了，每个线程在想获得类的实例时候，执行getInstance()方法都要进行同步。而其实这个方法只执行一次实例化代码就够了，后面的想获得该类实例，直接return就行了。

方法进行同步效率太低
结论：在实际开发中，不推荐使用这种方式

⑤、懒汉式(线程安全，同步代码块)

优缺点说明：

这种方式，本意是想对第四种实现方式的改进，因为前面同步方法效率太低，改为同步产生实例化的的代码块
但是这种同步并不能起到线程同步的作用。跟第3种实现方式遇到的情形一致，假如一个线程进入了if (singleton == null)判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例
结论：在实际开发中，不能使用这种方式

⑥、双重检查（推荐）

//双重检查
class Singleton {
    private static volatile Singleton singleton;

    private Singleton() {
    }
//提供一个静态的公有方法，加入双重检查代码，解决线程安全问题，同时解决懒加载问题
//推荐使用
    public static Singleton getInstance() {
        if (singleton == null) {
            synchronized (Singleton.class) {
                if (singleton == null) {
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}

优缺点说明：

Double-Check概念是多线程开发中常使用到的，如代码中所示，我们进行了两次if (singleton == null)检查，这样就可以保证线程安全了。
这样，实例化代码只用执行一次，后面再次访问时，判断if (singleton == null)，直接return实例化对象，也避免的反复进行方法同步.
线程安全；延迟加载；效率较高
结论：在实际开发中，推荐使用这种单例设计模式

⑦、静态内部类（推荐）

//使用静态内部类，推荐使用
class Singleton {
    private static volatile Singleton singleton;

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

    //写一个静态内部类，该类中有一个静态属性Singleton
    private static class SingletonInstance {
        private static final Singleton INSTANCE = new Singleton();
    }

    //提供一个静态的公有方法，直接返回SingletonInstance.INSTANCE
    public static Singleton getInstance() {
        return SingletonInstance.INSTANCE;
    }
}

优缺点说明：

这种方式采用了类装载的机制来保证初始化实例时只有一个线程。
静态内部类方式在Singleton类被装载时并不会立即实例化，而是在需要实例化时，调用getInstance方法，才会装载SingletonInstance类，从而完成Singleton的实例化。
类的静态属性只会在第一次加载类的时候初始化，所以在这里，JVM帮助我们保证了线程的安全性，在类进行初始化时，别的线程是无法进入的。
优点：避免了线程不安全，利用静态内部类特点实现延迟加载，效率高
结论：推荐使用.

⑧、枚举（推荐）

enum Singleton {

    INSTANCE;  //属性

    public void sayOk() {
        System.out.println("ok");
    }
}

优缺点说明：

这借助JDK1.5中添加的枚举来实现单例模式。不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象。
这种方式是Effective Java作者Josh Bloch 提倡的方式
结论：推荐使用

单例模式总结

1) 单例模式保证了 系统内存中该类只存在一个对象，节省了系统资源，对于一些需要频繁创建销毁的对象，使用单例模式可以提高系统性能 

2) 当想实例化一个单例类的时候，必须要记住使用相应的获取对象的方法，而不是使用new 

3) 单例模式使用的场景：需要频繁的进行创建和销毁的对象、创建对象时耗时过多或耗费资源过多(即：重量级对象)，但又经常用到的对象、工具类对象、频繁访问数据库或文件的对象(比如数据源、session工厂等)

2、创建型模式——工厂模式

简单工厂模式

传统的方式的优缺点

1) 优点是比较好理解，简单易操作。 

2) 缺点是违反了设计模式的ocp原则，即**对扩展开放，对修改关闭**。即当我们给类增加新功能的时候，尽量不修改代码，或者尽可能少修改代码. 

3) 比如我们这时要新增加一个Pizza的种类(Pepper披萨)，我们需要做如下修改.

4) 改进的思路分析 

分析：修改代码可以接受，但是如果我们在其它的地方也有创建Pizza的代码，就意味着，也需要修改，而创建Pizza的代码，往往有多处。 

思路：把创建Pizza对象封装到一个类中，这样我们有新的Pizza种类时，只需要修改该类就可，其它有创建到Pizza对象的代码就不需要修改了.-> 简单工厂模式

工厂方法模式

介绍

工厂方法模式设计方案：将披萨项目的实例化功能抽象成抽象方法，在不同的口味点餐子类中具体实现。 

工厂方法模式：定义了一个创建对象的抽象方法，由子类决定要实例化的类。工厂方法模式将对象的实例化推迟到子类。

    @Override
    public void prepare() {
        setName("北京奶酪披萨");
        System.out.println("准备北京奶酪披萨的原材料");
    }
    
        @Override
    public void prepare() {
        setName("北京的胡椒披萨");
        System.out.println("准备北京胡椒披萨的原材料");
    }

3、创建型模式——抽象工厂模式

基本介绍

基本介绍
1) 抽象工厂模式：定义了一个interface用于创建相关或有依赖关系的对象簇，而无需指明具体的类
2) 抽象工厂模式可以将简单工厂模式和工厂方法模式进行整合。
3) 从设计层面看，抽象工厂模式就是对简单工厂模式的改进(或者称为进一步的抽象)。
4) 将工厂抽象成两层，AbsFactory(抽象工厂) 和 具体实现的工厂子类。程序员可以根据创建对象类型使用对应的工厂子类。这样将单个的简单工厂类变成了工厂簇，更利于代码的维护和扩展。
5) 类图

    //让下面的过程子类来实现
    public Pizza createPizza(String orderType);

    ==============================================
        
    public class BJFactory implements AbsFactory {
    @Override
    public Pizza createPizza(String orderType) {
        System.out.println("使用的抽象工厂模式");
        Pizza pizza = null;
        if (orderType.equals("cheese")) {
            pizza = new BJCheesePizza();
        } else if (orderType.equals("pepper")) {
            pizza = new BJPepperPizza();
        }

        return pizza;
    }
}

public class LDFactory implements AbsFactory {
    @Override
    public Pizza createPizza(String orderType) {
        System.out.println("使用的抽象工厂模式");
        Pizza pizza = null;
        if (orderType.equals("cheese")) {
            pizza = new LDCheesePizza();
        } else if (orderType.equals("pepper")) {
            pizza = new LDPepperPizza();
        }
        return pizza;
    }
}

工厂模式小结

1) 工厂模式的意义 

将实例化对象的代码提取出来，放到一个类中统一管理和维护，达到和主项目的依赖关系的解耦。从而提高项目的扩展和维护性。 

2) 三种工厂模式 (简单工厂模式、工厂方法模式、抽象工厂模式) 

3) 设计模式的依赖抽象原则 

1、创建对象实例时，不要直接 new 类, 而是把这个new 类的动作放在一个工厂的方法中，并返回。有的书上说，变量不要直接持有具体类的引用。 
2、不要让类继承具体类，而是继承抽象类或者是实现interface(接口) 
3、不要覆盖基类中已经实现的方法。

4、创建型模式——原型模式

传统方式解决克隆羊


    public static void main(String[] args) {
        Sheep sheep = new Sheep("tom", 1, "白色");
        Sheep sheep2 = new Sheep(sheep.getName(), sheep.getAge(), sheep.getColor());
        Sheep sheep3 = new Sheep(sheep.getName(), sheep.getAge(), sheep.getColor());
        Sheep sheep4 = new Sheep(sheep.getName(), sheep.getAge(), sheep.getColor());
        Sheep sheep5 = new Sheep(sheep.getName(), sheep.getAge(), sheep.getColor());
        //....
        System.out.println(sheep);
        System.out.println(sheep2);
        System.out.println(sheep3);
        System.out.println(sheep4);
        System.out.println(sheep5);
        //....
    }

传统的方式的优缺点

优点是比较好理解，简单易操作。
在创建新的对象时，总是需要重新获取原始对象的属性，如果创建的对象比较复杂时，效率较低
总是需要重新初始化对象，而不是动态地获得对象运行时的状态, 不够灵活
改进的思路分析

**思路：**Java中Object类是所有类的根类，Object类提供了一个clone()方法，该方法可以将一个Java对象复制一份，但是需要实现clone的Java类必须要实现一个接口Cloneable，该接口表示该类能够复制且具有复制的能力 => 原型模式

原型模式介绍

原型模式(Prototype模式)是指：用原型实例指定创建对象的种类，并且通过拷贝这些原型，创建新的对象
原型模式是一种创建型设计模式，允许一个对象再创建另外一个可定制的对象，无需知道如何创建的细节
工作原理是:通过将一个原型对象传给那个要发动创建的对象，这个要发动创建的对象通过请求原型对象拷贝它们自己来实施创建，即对象.clone()
形象的理解：孙大圣拔出猴毛，变出其它孙大圣

应用

浅拷贝的介绍

对于数据类型是基本数据类型的成员变量，浅拷贝会直接进行值传递，也就是将该属性值复制一份给新的对象。
对于数据类型是引用数据类型的成员变量，比如说成员变量是某个数组、某个类的对象等，那么浅拷贝会进行引用传递，也就是只是将该成员变量的引用值（内存地址）复制一份给新的对象。因为实际上两个对象的该成员变量都指向同一个实例。在这种情况下，在一个对象中修改该成员变量会影响到另一个对象的该成员变量值
前面我们克隆羊就是浅拷贝
浅拷贝是使用默认的 clone()方法来实现 sheep = (Sheep) super.clone();

        System.out.println("原型模式完成对象的创作");
        Sheep sheep = new Sheep("tom", 1, "白色");
        sheep.friend = new Sheep("jack", 2, "黑色");

        Sheep sheep2 = (Sheep) sheep.clone();
        Sheep sheep3 = (Sheep) sheep.clone();
        Sheep sheep4 = (Sheep) sheep.clone();
        Sheep sheep5 = (Sheep) sheep.clone();

        System.out.println(sheep2 + "sheep2.friend " + sheep.friend.hashCode());
        System.out.println(sheep3 + "sheep3.friend " + sheep.friend.hashCode());
        System.out.println(sheep4 + "sheep4.friend " + sheep.friend.hashCode());
        System.out.println(sheep5 + "sheep5.friend " + sheep.friend.hashCode());

深拷贝的介绍

复制对象的所有基本数据类型的成员变量值
为所有引用数据类型的成员变量申请存储空间，并复制每个引用数据类型成员变量所引用的对象，直到该对象可达的所有对象。也就是说，对象进行深拷贝要对整个对象进行拷贝
深拷贝实现方式1：重写clone方法来实现深拷贝
深拷贝实现方式2：通过对象序列化实现深拷贝(推荐)

    //深拷贝 方式1、克隆

    @Override
    protected Object clone() throws CloneNotSupportedException {
        Object deep = null;
        deep = super.clone();
        //这里完成对基本数据类型（属性）和字符串的克隆
        //对引用数据类型单独处理
        DeepProtoType deepProtoType = (DeepProtoType) deep;
        deepProtoType.deepCloneableTarget = (DeepCloneableTarget) deepCloneableTarget.clone();

        return deepProtoType;
    }

    //深拷贝 方式二推荐
    public Object deepClone() {
        //创建流对象
        ByteArrayOutputStream bos = null;
        ObjectOutputStream oos = null;
        ByteArrayInputStream bis = null;
        ObjectInputStream ois = null;

        try {
            bos = new ByteArrayOutputStream();
            oos = new ObjectOutputStream(bos);
            oos.writeObject(this);

            //反序列化
            bis = new ByteArrayInputStream(bos.toByteArray());
            ois = new ObjectInputStream(bis);
            DeepProtoType copyObj = (DeepProtoType) ois.readObject();
            return copyObj;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        } finally {
            try {
                bos.close();
                oos.close();
                bis.close();
                ois.close();
            } catch (IOException e2) {
                System.out.println(e2.getMessage());
            }
        }
    }

原型模式的注意事项和细节

创建新的对象比较复杂时，可以利用原型模式简化对象的创建过程，同时也能够提高效率
不用重新初始化对象，而是动态地获得对象运行时的状态
如果原始对象发生变化(增加或者减少属性)，其它克隆对象的也会发生相应的变化，无需修改代码
在实现深克隆的时候可能需要比较复杂的代码

5) 缺点：需要为每一个类配备一个克隆方法，这对全新的类来说不是很难，但对已有的类进行改造时，需要修改其源代码，违背了ocp原则，这点请同学们注意.

5、创建型模式——建造者模式

传统方法

public abstract class AbsHouse {

    //打地基
    public abstract void buildBasic();

    //砌墙
    public abstract void buildWalls();

    //封顶
    public abstract void roofed();

    public void build() {
        buildBasic();
        buildWalls();
        roofed();
    }
}

public class CommonHouse extends AbsHouse {
    @Override
    public void buildBasic() {
        System.out.println("给普通房子打地基");
    }

    @Override
    public void buildWalls() {
        System.out.println("给普通房子砌墙");
    }

    @Override
    public void roofed() {
        System.out.println("给普通房子封顶");
    }
}

public class Client {

    public static void main(String[] args) {
        CommonHouse commonHouse = new CommonHouse();
        commonHouse.build();
    }
}

传统方式解决盖房需求问题分析

优点是比较好理解，简单易操作。
设计的程序结构，过于简单，没有设计缓存层对象，程序的扩展和维护不好. 也就是说，这种设计方案，把产品(即：房子) 和创建产品的过程(即：建房子流程) 封装在一起，耦合性增强了。
解决方案：将产品和产品建造过程解耦 => 建造者模式.

建造者模式基本介绍

1) 建造者模式（Builder Pattern）又叫生成器模式，是一种对象构建模式。它可以将复杂对象的建造过程抽象出来（抽象类别），使这个抽象过程的不同实现方法可以构造出不同表现（属性）的对象。

2) 建造者模式 是一步一步创建一个复杂的对象，它允许用户只通过指定复杂对象的类型和内容就可以构建它们，用户不需要知道内部的具体构建细节。

建造者模式的四个角色

1) Product（产品角色）：一个具体的产品对象。

2) Builder（抽象建造者）：创建一个Product对象的各个部件指定的接口/抽象类。

3) ConcreteBuilder（具体建造者）：实现接口，构建和装配各个部件。

4) Director（指挥者）：构建一个使用Builder接口的对象。它主要是用于创建一个复杂的对象。它主要有两个作用，一是：隔离了客户与对象的生产过程，二是：负责控制产品对象的生产过程。

代码演示

public abstract class HouseBuilder {

    protected House house = new House();

    //将建造者的流程写好，抽象的方法
    public abstract void buildBasic();

    public abstract void buildWalls();

    public abstract void roofed();

    //建造房子,将房子返回
    public House buildHouse() {
        return house;
    }
}


public class CommonHouse extends HouseBuilder {
    @Override
    public void buildBasic() {
        System.out.println("普通房子打地基五米");
    }

    @Override
    public void buildWalls() {
        System.out.println("普通房子砌墙10cm");
    }

    @Override
    public void roofed() {
        System.out.println("普通房子盖屋顶");
    }
}

public class HighBuilding extends HouseBuilder {
    @Override
    public void buildBasic() {
        System.out.println("打高楼地基一百米");
    }

    @Override
    public void buildWalls() {
        System.out.println("高楼的砌墙20cm");
    }

    @Override
    public void roofed() {
        System.out.println("高楼的透明屋顶");
    }
}


public class House {

    private String basic;
    private String wall;
    private String roofed;

    public String getBasic() {
        return basic;
    }

    public void setBasic(String basic) {
        this.basic = basic;
    }

    public String getWall() {
        return wall;
    }

    public void setWall(String wall) {
        this.wall = wall;
    }

    public String getRoofed() {
        return roofed;
    }

    public void setRoofed(String roofed) {
        this.roofed = roofed;
    }
}

public class HouseDirector {

    HouseBuilder houseBuilder = null;

    //构造器
    public HouseDirector(HouseBuilder houseBuilder) {
        this.houseBuilder = houseBuilder;
    }


    //setter方法
    public void setHouseBuilder(HouseBuilder houseBuilder) {
        this.houseBuilder = houseBuilder;
    }

    //如何处理建房子的流程，交给指挥者
    public House constructHouse() {
        houseBuilder.buildBasic();
        houseBuilder.buildWalls();
        houseBuilder.roofed();
        return houseBuilder.buildHouse();
    }

}

public class Client {

    public static void main(String[] args) {
        //盖普通房子
        CommonHouse commonHouse = new CommonHouse();
        //准备创建房子的指挥者
        HouseDirector houseDirector = new HouseDirector(commonHouse);
        //完成盖房子，返回产品
        House house = houseDirector.constructHouse();

        System.out.println("=====================================");

        HighBuilding highBuilding = new HighBuilding();
        HouseDirector houseDirector1 = new HouseDirector(highBuilding);
        House house1 = houseDirector1.constructHouse();
    }
}

建造者模式在JDK的应用和源码分析

源码中建造者模式角色分析

Appendable 接口定义了多个append方法(抽象方法), 即Appendable 为抽象建造者, 定义了抽象方法
AbstractStringBuilder 实现了 Appendable 接口方法，这里的AbstractStringBuilder 已经是建造者，只是不能实例化
StringBuilder 即充当了指挥者角色，同时充当了具体的建造者，建造方法的实现是由 AbstractStringBuilder 完成, 而StringBuilder 继承了AbstractStringBuilder

建造者模式的注意事项和细节

客户端(使用程序)不必知道产品内部组成的细节，将产品本身与产品的创建过程解耦，使得相同的创建过程可以创建不同的产品对象
每一个具体建造者都相对独立，而与其他的具体建造者无关，因此可以很方便地替换具体建造者或增加新的具体建造者， 用户使用不同的具体建造者即可得到不同的产品对象

3) 可以更加精细地控制产品的创建过程 。将复杂产品的创建步骤分解在不同的方法中，使得创建过程更加清晰，也更方便使用程序来控制创建过程

4) 增加新的具体建造者无须修改原有类库的代码，指挥者类针对抽象建造者类编程，系统扩展方便，符合 “开闭原则”

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

7) 抽象工厂模式VS建造者模式

抽象工厂模式实现对产品家族的创建，一个产品家族是这样的一系列产品：具有不同分类维度的产品组合，采用抽象工厂模式不需要关心构建过程，只关心什么产品由什么工厂生产即可。而建造者模式则是要求按照指定的蓝图建造产品，它的主要目的是通过组装零配件而产生一个新产品

6、结构型模式——适配器模式

基本介绍

适配器模式(Adapter Pattern)将某个类的接口转换成客户端期望的另一个接口表示，主的目的是兼容性，让原本因接口不匹配不能一起工作的两个类可以协同工作。其别名为包装器(Wrapper)
适配器模式属于结构型模式
主要分为三类：类适配器模式、对象适配器模式、接口适配器模式

工作原理

适配器模式：将一个类的接口转换成另一种接口.让原本接口不兼容的类可以兼容
从用户的角度看不到被适配者，是解耦的
用户调用适配器转化出来的目标接口方法，适配器再调用被适配者的相关接口方法
用户收到反馈结果，感觉只是和目标接口交互，如图

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dqCGrqpS-1664591750871)(C:\Users\Jay Lin\Desktop\面试\image-20220925093926113.png)]

①、类适配器

代码演示

public class Voltage220V {
    //输出220V的电压
    public int output220V() {
        int src = 220;
        System.out.println("电压==" + src + "V");
        return src;
    }
}

public interface IVoltage5V {
    public int output5V();
}

public class VoltageAdapter extends Voltage220V implements IVoltage5V {
    @Override
    public int output5V() {
        int srcV = output220V();
        int dstV = srcV / 44;
        return dstV;
    }
}

public class Phone {
    //充电方法
    public void charging(IVoltage5V iVoltage5V) {
        if (iVoltage5V.output5V() == 5) {
            System.out.println("电压为5V，可以充电");
        } else if (iVoltage5V.output5V() > 5) {
            System.out.println("电压大于5V，无法充电");
        }
    }
}

public class Client {
    public static void main(String[] args) {
        System.out.println("=============类适配器模式===============");
        Phone phone = new Phone();
        phone.charging(new VoltageAdapter());
    }
}

类适配器模式注意事项和细节

Java是单继承机制，所以类适配器需要继承src类这一点算是一个缺点, 因为这要求dst必须是接口，有一定局限性;
src类的方法在Adapter中都会暴露出来，也增加了使用的成本。
由于其继承了src类，所以它可以根据需求重写src类的方法，使得Adapter的灵活性增强了。

②、对象适配器

对象适配器模式介绍

基本思路和类的适配器模式相同，只是将Adapter类作修改，不是继承src类，而是持有src类的实例，以解决兼容性的问题。即：持有 src类，实现 dst 类接口，完成src->dst的适配
根据“合成复用原则”，在系统中尽量使用关联关系来替代继承关系。

3) 对象适配器模式是适配器模式常用的一种

public interface IVoltage5V {
    public int output5V();
}

public class Voltage220V {
    //输出220V的电压
    public int output220V() {
        int src = 220;
        System.out.println("电压==" + src + "V");
        return src;
    }
}

public class VoltageAdapter implements IVoltage5V {

    private Voltage220V voltage220V;

    //通过构造器传入一个Voltage220V实例
    public VoltageAdapter(Voltage220V voltage220V) {
        this.voltage220V = voltage220V;
    }

    @Override
    public int output5V() {
        int dst = 0;
        if (null != voltage220V) {
            int src = voltage220V.output220V(); //获取220V电压
            System.out.println("使用对象适配器进行适配");
            dst = src / 44;
            System.out.println("适配完成，输出的电压==" + dst);
        }
        return dst;
    }
}

public class Phone {
    //充电方法
    public void charging(IVoltage5V iVoltage5V) {
        if (iVoltage5V.output5V() == 5) {
            System.out.println("电压为5V，可以充电");
        } else if (iVoltage5V.output5V() > 5) {
            System.out.println("电压大于5V，无法充电");
        }
    }
}

public class Client {
    public static void main(String[] args) {
        System.out.println("=============对象适配器模式===============");
        Phone phone = new Phone();
        phone.charging(new VoltageAdapter(new Voltage220V()));
    }
}

对象适配器模式注意事项和细节

对象适配器和类适配器其实算是同一种思想，只不过实现方式不同。根据合成复用原则，使用组合替代继承，所以它解决了类适配器必须继承src的局限性问题，也不再要求dst必须是接口。
使用成本更低，更灵活。

③、接口适配器

接口适配器模式介绍

一些书籍称为：适配器模式(Default Adapter Pattern)或缺省适配器模式。
当不需要全部实现接口提供的方法时，可先设计一个抽象类实现接口，并为该接口中每个方法提供一个默认实现（空方法），那么该抽象类的子类可有选择地覆盖父类的某些方法来实现需求
适用于一个接口不想使用其所有的方法的情况。

代码演示

public interface Interface4 {

    public void m1();

    public void m2();

    public void m3();

    public void m4();

}

public abstract class AbsAdapter implements Interface4 {
    @Override
    public void m1() {

    }
    @Override
    public void m2() {

    }
    @Override
    public void m3() {

    }
    @Override
    public void m4() {

    }
}

public class Client {
    public static void main(String[] args) {
        AbsAdapter abs = new AbsAdapter() {
            //只需要覆盖我们需要使用的接口方法
            @Override
            public void m1() {
                System.out.println("使用了m1的方法");
            }
        };
        abs.m1();
    }
}

适配器模式的注意事项和细节

三种命名方式，是根据 src是以怎样的形式给到Adapter（在Adapter里的形式）来命名的。
类适配器：以类给到，在Adapter里，就是将src当做类，继承

对象适配器：以对象给到，在Adapter里，将src作为一个对象，持有

接口适配器：以接口给到，在Adapter里，将src作为一个接口，实现

Adapter模式最大的作用还是将原本不兼容的接口融合在一起工作。
实际开发中，实现起来不拘泥于我们讲解的三种经典形式

7、结构性模式——桥接模式

手机操作问题

传统方案解决手机操作问题

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vPzxzZAB-1664591750873)(C:\Users\Jay Lin\Desktop\面试\image-20220925133426647.png)]

传统方案解决手机操作问题分析

扩展性问题(类爆炸)，如果我们再增加手机的样式(旋转式)，就需要增加各个品牌手机的类，同样如果我们增加一个手机品牌，也要在各个手机样式类下增加。
违反了单一职责原则，当我们增加手机样式时，要同时增加所有品牌的手机，这样增加了代码维护成本.
解决方案-使用桥接模式

桥接模式介绍

桥接模式(Bridge模式)是指：将实现与抽象放在两个不同的类层次中，使两个层次可以独立改变。
是一种结构型设计模式
Bridge模式基于类的最小设计原则，通过使用封装、聚合及继承等行为让不同的类承担不同的职责。它的主要特点是把抽象(Abstraction)与行为实现(Implementation)分离开来，从而可以保持各部分的独立性以及应对他们的功能扩展

桥接模式原理图

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xGpWodZO-1664591750873)(C:\Users\Jay Lin\Desktop\面试\image-20220925134424250.png)]

代码说明

public interface Brand {
    void open();
    void close();
    void call();
}

public class Huawei implements Brand {
    @Override
    public void open() {
        System.out.println("华为手机开机");
    }
    @Override
    public void close() {
        System.out.println("华为手机关机");
    }
    @Override
    public void call() {
        System.out.println("华为手机打电话");
    }
}

public class Xiaomi implements Brand {
    @Override
    public void open() {
        System.out.println("小米手机开机");
    }
    @Override
    public void close() {
        System.out.println("小米手机关机");
    }
    @Override
    public void call() {
        System.out.println("小米手机打电话");
    }
}

public abstract class Phone {
    //组合品牌
    private Brand brand;
    public Phone(Brand brand) {
        this.brand = brand;
    }
    protected void open() {
        this.brand.open();
    }
    protected void close() {
        brand.close();
    }
    protected void call() {
        brand.call();
    }
}

public class FoldedPhone extends Phone {
    //构造器
    public FoldedPhone(Brand brand) {
        super(brand);
    }
    public void open() {
        super.open();
        System.out.println("折叠手机");
    }
    public void close() {
        super.close();
        System.out.println("折叠手机");
    }
    public void call() {
        super.call();
        System.out.println("折叠手机");
    }
}

public class UpRightPhone extends Phone {
    public UpRightPhone(Brand brand) {
        super(brand);
    }
    public void open() {
        super.open();
        System.out.println("直立手机");
    }
    public void close() {
        super.close();
        System.out.println("直立手机");
    }
    public void call() {
        super.call();
        System.out.println("直立手机");
    }
}

//测试
public class Client {
    public static void main(String[] args) {
        //获取折叠手机
        FoldedPhone p1 = new FoldedPhone(new Xiaomi());
        p1.open();
        p1.call();
        p1.close();
        System.out.println("=============================");
        FoldedPhone p2 = new FoldedPhone(new Huawei());
        p2.open();
        p2.call();
        p2.close();
        System.out.println("=========================");
        UpRightPhone p3 = new UpRightPhone(new Xiaomi());
        p3.open();
        p3.call();
        p3.close();
        System.out.println("=================================");
        UpRightPhone p4 = new UpRightPhone(new Huawei());
        p4.open();
        p4.call();
        p4.close();
    }
}

8、结构性模式——装饰者模式

装饰者模式定义

装饰者模式：动态的将新功能附加到对象上。在对象功能扩展方面，它比继承更有弹性，装饰者模式也体现了开闭原则(ocp)
这里提到的动态的将新功能附加到对象和ocp****原则，在后面的应用实例上会以代码的形式体现，请同学们注意体会。

装饰者模式原理

装饰者模式就像打包一个快递

主体：比如：陶瓷、衣服 (Component) // 被装饰者

包装：比如：报纸填充、塑料泡沫、纸板、木板(Decorator)

Component

主体：比如类似前面的Drink

ConcreteComponent和Decorator

ConcreteComponent：具体的主体，

比如前面的各个单品咖啡

Decorator: 装饰者，比如各调料.

在如图的Component与ConcreteComponent之间，如果ConcreteComponent类很多,还可以设计一个缓冲层，将共有的部分提取出来，抽象成一个类。

装饰者模式设计的方案

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Yg7BppnB-1664591750874)(C:\Users\Jay Lin\Desktop\面试\image-20220925163347200.png)]

装饰者模式解决星巴克咖啡订单

装饰者模式下的订单：2份巧克力+一份牛奶的LongBlack

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XjgLHghi-1664591750874)(C:\Users\Jay Lin\Desktop\面试\image-20220925163655592.png)]

代码演示

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-aedCfirF-1664591750875)(C:\Users\Jay Lin\Desktop\面试\image-20220925191145101.png)]

public class CoffeeBar {
    public static void main(String[] args) {
        //下订单
        //先点一份LongBlack
        Drink order = new Decaf();
        System.out.println("order.cost() = " + order.cost());
        System.out.println("order.getDes() = " + order.getDes());
        //加入一分牛奶
        order = new Milk(order);
        System.out.println("加入一份牛奶");
        System.out.println("order.cost() = " + order.cost());
        System.out.println("order.getDes() = " + order.getDes());
        //加入一份巧克力
        order = new Chocolate(order);
        System.out.println("加入一份巧克力");
        System.out.println("order.cost() = " + order.cost());
        System.out.println("order.getDes() = " + order.getDes());
        //再加入一份巧克力
        order = new Chocolate(order);
        System.out.println("再加入一份巧克力");
        System.out.println("order.cost() = " + order.cost());
        System.out.println("order.getDes() = " + order.getDes());
    }
}

9、结构性模式——组合模式

基本介绍

组合模式（Composite Pattern），又叫部分整体模式，它创建了对象组的树形结构，将对象组合成树状结构以表示“整体-部分”的层次关系。
组合模式依据树形结构来组合对象，用来表示部分以及整体层次。
这种类型的设计模式属于结构型模式。
组合模式使得用户对单个对象和组合对象的访问具有一致性，即：组合能让客户以一致的方式处理个别对象以及组合对象

组合模式的原理类图

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-98jDTCdu-1664591750875)(C:\Users\Jay Lin\Desktop\面试\image-20220925192624346.png)]

对原理结构图的说明-即(组合模式的角色及职责)

1) Component :这是组合中对象声明接口，在适当情况下，实现所有类共有的接口默认行为,用于访问和管理Component 子部件, Component 可以是抽象类或者接口

2) Leaf : 在组合中表示叶子节点，叶子节点没有子节点

3）Composite：飞叶子节点，用于存储子部件，在Component 中实现子部件的相关操作，比如增加（add）、（del）操作

代码分析

public abstract class OrganizationComponent {

    public String name; //名字
    public String des; //说明

    protected void add(OrganizationComponent OrganizationComponent) {
        //默认实现
        throw new UnsupportedOperationException("不支持操作");
    }

    protected void remove(OrganizationComponent OrganizationComponent) {
        //默认实现
        throw new UnsupportedOperationException("不支持操作");
    }

    public OrganizationComponent(String name, String des) {
        this.name = name;
        this.des = des;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getDes() {
        return des;
    }

    public void setDes(String des) {
        this.des = des;
    }

    //展示方法,子类都需要实现
    protected abstract void show();
}

//学校类
public class University extends OrganizationComponent {

    List<OrganizationComponent> organizationComponents = new ArrayList<>();

    //构造器
    public University(String name, String des) {
        super(name, des);
    }

    @Override
    protected void add(OrganizationComponent organizationComponent) {
        organizationComponents.add(organizationComponent);
    }

    @Override
    protected void remove(OrganizationComponent organizationComponent) {
        organizationComponents.remove(organizationComponent);
    }

    @Override
    public String getName() {
        return super.getName();
    }

    @Override
    public String getDes() {
        return super.getDes();
    }

    //展示学院
    @Override
    protected void show() {
        System.out.println("===============" + getName() + "================");
        for (OrganizationComponent organizationComponent : organizationComponents) {
            organizationComponent.show();
        }
    }
}

//学院类
public class College extends OrganizationComponent {

    //
    List<OrganizationComponent> organizationComponents = new ArrayList<>();

    //构造器
    public College(String name, String des) {
        super(name, des);
    }

    @Override
    protected void add(OrganizationComponent organizationComponent) {
        organizationComponents.add(organizationComponent);
    }

    @Override
    protected void remove(OrganizationComponent organizationComponent) {
        organizationComponents.remove(organizationComponent);
    }

    @Override
    public String getName() {
        return super.getName();
    }

    @Override
    public String getDes() {
        return super.getDes();
    }

    //展示学院
    @Override
    protected void show() {
        System.out.println("===============" + getName() + "================");
        for (OrganizationComponent organizationComponent : organizationComponents) {
            organizationComponent.show();
        }
    }
}

//系
public class Department extends OrganizationComponent {

    public Department(String name, String des) {
        super(name, des);
    }

    @Override
    public String getName() {
        return super.getName();
    }

    @Override
    public String getDes() {
        return super.getDes();
    }

    @Override
    protected void show() {
        System.out.println(getName());
    }
}


public class Client {
    public static void main(String[] args) {
        //从大到小创建对象
        OrganizationComponent university = new University("清华大学", "顶尖大学");
        //创建学院
        OrganizationComponent college1 = new College("信息工程学院", "计算机学院");
        OrganizationComponent college2 = new College("文化传媒学院", "文化传媒学院");
        //创建学院下面的系
        college1.add(new Department("软件工程", "软件工程"));
        college1.add(new Department("网络工程", "网络工程"));
        college1.add(new Department("计算机科学与技术", "计算机科学与技术是一个老牌专业"));
        college2.add(new Department("新闻媒体", "新闻媒体"));
        college2.add(new Department("导演", "导演"));
        //将两个学院加入到学校中
        university.add(college1);
        university.add(college2);
        university.show();
    }
}

10、结构性模式——外观模式

基本介绍

外观模式（Facade），也叫“过程模式：外观模式为子系统中的一组接口提供一个一致的界面，此模式定义了一个高层接口，这个接口使得这一子系统更加容易使用
外观模式通过定义一个一致的接口，用以屏蔽内部子系统的细节，使得调用端只需跟这个接口发生调用，而无需关心这个子系统的内部细节

原理类图

原理类图的说明(外观模式的角色)

外观类(Facade): 为调用端提供统一的调用接口, 外观类知道哪些子系统负责处理请求,从而将调用端的请求代理给适当子系统对象
调用者(Client): 外观接口的调用者
子系统的集合：指模块或者子系统，处理Facade 对象指派的任务，他是功能的实际提供者

代码演示

public class DVDPlayer {

    //使用单例模式，饿汉式
    private static DVDPlayer instance = new DVDPlayer();

    public static DVDPlayer getInstance() {
        return instance;
    }

    public void on() {
        System.out.println("dvd on");
    }

    public void off() {
        System.out.println("dvd off");
    }

    public void play() {
        System.out.println("dvd is play");
    }

    public void pause() {
        System.out.println("dvd pause");
    }
}

public class Popcorn {

    private static Popcorn instance = new Popcorn();

    public static Popcorn getInstance() {
        return instance;
    }

    public void on() {
        System.out.println("pop on");
    }

    public void off() {
        System.out.println("pop off");
    }

    public void pop() {
        System.out.println("pop is pop");
    }

}

public class Projector {

    private static Projector instance = new Projector();

    public static Projector getInstance() {
        return instance;
    }

    public void on() {
        System.out.println("pop on");
    }

    public void off() {
        System.out.println("pop off");
    }

    public void focus() {
        System.out.println("Projector is focus");
    }
}

public class Screen {

    private static Screen instance = new Screen();

    public static Screen getInstance() {
        return instance;
    }

    public void up() {
        System.out.println("Screen up");
    }

    public void down() {
        System.out.println("Screen down");
    }

}

public class Stereo {

    private static Stereo instance = new Stereo();

    public static Stereo getInstance() {
        return instance;
    }

    public void up() {
        System.out.println("Stereo up");
    }

    public void down() {
        System.out.println("Stereo down");
    }
}

public class TheaterLight {

    private static TheaterLight instance = new TheaterLight();

    public static TheaterLight getInstance() {
        return instance;
    }

    public void on() {
        System.out.println("TheaterLight on");
    }

    public void off() {
        System.out.println("TheaterLight off");
    }

    public void dim() {
        System.out.println("TheaterLight dim");
    }

    public void bright() {
        System.out.println("TheaterLight bright");
    }

}

==============外观类=================
public class HomeTheaterFacade {

    //定义各个子系统的对象
    private TheaterLight theaterLight;
    private Popcorn popcorn;
    private Stereo stereo;
    private Projector projector;
    private Screen screen;
    private DVDPlayer dvdPlayer;

    public HomeTheaterFacade() {
        this.theaterLight = TheaterLight.getInstance();
        this.popcorn = Popcorn.getInstance();
        this.stereo = Stereo.getInstance();
        this.projector = Projector.getInstance();
        this.screen = Screen.getInstance();
        this.dvdPlayer = DVDPlayer.getInstance();
    }

    //分成四步
    public void ready() {
        popcorn.on();
        popcorn.pop();
        screen.down();
        projector.on();
        stereo.up();
        dvdPlayer.on();
        theaterLight.dim();
    }

    public void play() {
        dvdPlayer.play();
    }

    public void pause() {
        dvdPlayer.pause();
    }

    public void end() {
        popcorn.off();
        popcorn.off();
        screen.up();
        projector.off();
        stereo.down();
        dvdPlayer.off();
        theaterLight.bright();
    }

}    

public class Client {

    public static void main(String[] args) {
        HomeTheaterFacade facade = new HomeTheaterFacade();
        facade.ready();
        facade.play();
    }
}

外观模式的注意事项和细节

外观模式对外屏蔽了子系统的细节，因此外观模式降低了客户端对子系统使用的复杂性
外观模式对客户端与子系统的耦合关系，让子系统内部的模块更易维护和扩展
通过合理的使用外观模式，可以帮我们更好的划分访问的层次
当系统需要进行分层设计时，可以考虑使用Facade模式
在维护一个遗留的大型系统时，可能这个系统已经变得非常难以维护和扩展，此时可以考虑为新系统开发一个Facade类，来提供遗留系统的比较清晰简单的接口，让新系统与Facade类交互，提高复用性
不能过多的或者不合理的使用外观模式，使用外观模式好，还是直接调用模块好。要以让系统有层次，利于维护为目的。

11、结构性模式——享元模式

基本介绍

享元模式（Flyweight Pattern）也叫蝇量模式: 运用共享技术有效地支持大量细粒度的对象
常用于系统底层开发，解决系统的性能问题。像数据库连接池，里面都是创建好的连接对象，在这些连接对象中有我们需要的则直接拿来用，避免重新创建，如果没有我们需要的，则创建一个
享元模式能够解决重复对象的内存浪费的问题，当系统中有大量相似对象，需要缓冲池时。不需总是创建新对象，可以从缓冲池里拿。这样可以降低系统内存，同时提高效率
享元模式经典的应用场景就是池技术了，String常量池、数据库连接池、缓冲池等等都是享元模式的应用，享元模式是池技术的重要实现方式

原理类图

对原理图的说明-即(模式的角色及职责)

FlyWeight 是抽象的享元角色, 他是产品的抽象类, 同时定义出对象的外部状态和内部状态(后面介绍) 的接口或实现
ConcreteFlyWeight 是具体的享元角色，是具体的产品类，实现抽象角色定义相关业务
UnSharedConcreteFlyWeight 是不可共享的角色，一般不会出现在享元工厂
FlyweightFactory 享元工厂类，用于构建一个池容器（集合），同时提供从池中获取到对象方法

内部状态和外部状态

比如围棋、五子棋、跳棋，它们都有大量的棋子对象，围棋和五子棋只有黑白两色，跳棋颜色多一点，所以棋子颜色就是棋子的内部状态；而各个棋子之间的差别就是位置的不同，当我们落子后，落子颜色是定的，但位置是变化的，所以棋子坐标就是棋子的外部状态

享元模式提出了两个要求：细粒度和共享对象。这里就涉及到内部状态和外部状态了，即将对象的信息分为两个部分：内部状态和外部状态

2) 内部状态指对象共享出来的信息，存储在享元对象内部且不会随环境的改变而改变

3) 外部状态指对象得以依赖的一个标记，是随环境改变而改变的、不可共享的状态。

举个例子：围棋理论上有361个空位可以放棋子，每盘棋都有可能有两三百个棋子对象产生，因为内存空间有限，一台服务器很难支持更多的玩家玩围棋游戏，如果用享元模式来处理棋子，那么棋子对象就可以减少到只有两个实例，这样就很好的解决了对象的开销问题

代码演示

public abstract class WebSite {
    public abstract void use(User user);
}

public class ConcreteWebsite extends WebSite {

    private String type = "";//网站发布的形式

    public ConcreteWebsite(String type) {
        this.type = type;
    }

    @Override
    public void use(User user) {
        System.out.println("网站的发布形式为 " + type + user.getName() + " 在使用中");
    }
}

public class WebSiteFactory {

    //集合，充当池的作用
    private HashMap<String, ConcreteWebsite> pool = new HashMap<>();

    //根据网站的类型，返回一个网站，如果没有就创建网站，并放入到池中
    public WebSite getWebSiteCategory(String type) {
        if (!pool.containsKey(type)) {
            pool.put(type, new ConcreteWebsite(type));
        }
        return (WebSite) pool.get(type);
    }

    //获取网站分类的总数(池中有多少个网站类型)
    public int getWebSiteCount() {
        return pool.size();
    }
}

public class User {

    private String name;

    public User() {
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

public class Client {

    public static void main(String[] args) {
        //创建一个工厂
        WebSiteFactory factory = new WebSiteFactory();
        //客户要创建一个新闻形式发布的网站
        WebSite ws1 = factory.getWebSiteCategory("新闻");
        ws1.use(new User("tom"));

        //博客
        WebSite ws2 = factory.getWebSiteCategory("博客");
        ws2.use(new User("Jack"));
        WebSite ws3 = factory.getWebSiteCategory("博客");
        ws3.use(new User("Mary"));
        WebSite ws4 = factory.getWebSiteCategory("博客");
        ws4.use(new User("Break"));
        WebSite ws5 = factory.getWebSiteCategory("博客");
        ws5.use(new User("God"));

        System.out.println("factory.getWebSiteCount() = " + factory.getWebSiteCount());
    }
}

享元模式的注意事项和细节

在享元模式这样理解，“享”就表示共享，“元”表示对象
系统中有大量对象，这些对象消耗大量内存，并且对象的状态大部分可以外部化时，我们就可以考虑选用享元模式
用唯一标识码判断，如果在内存中有，则返回这个唯一标识码所标识的对象，用 HashMap/HashTable存储
享元模式大大减少了对象的创建，降低了程序内存的占用，提高效率
享元模式提高了系统的复杂度。需要分离出内部状态和外部状态，而外部状态具有固化特性，不应该随着内部状态的改变而改变，这是我们使用享元模式需要注意的地方.
使用享元模式时，注意划分内部状态和外部状态，并且需要有一个工厂类加以控制。
享元模式经典的应用场景是需要缓冲池的场景，比如 String常量池、数据库连接池

12、结构性模式——代理模式

基本介绍

代理模式：为一个对象提供一个替身，以控制对这个对象的访问。即通过代理对象访问目标对象.这样做的好处是:可以在目标对象实现的基础上,增强额外的功能操作,即扩展目标对象的功能。
被代理的对象可以是远程对象、创建开销大的对象或需要安全控制的对象
代理模式有不同的形式, 主要有三种 静态代理、动态代理 (JDK代理、接口代理)和 Cglib代理可以在内存动态的创建对象，而不需要实现接口，他是属于动态代理的范畴) 。

静态代码模式的基本介绍

静态代理在使用时,需要定义接口或者父类,被代理对象(即目标对象)与代理对象一起实现相同的接口或者是继承相同父类

静态代理优缺点

优点：在不修改目标对象的功能前提下, 能通过代理对象对目标功能扩展
缺点：因为代理对象需要与目标对象实现一样的接口,所以会有很多代理类
一旦接口增加方法,目标对象与代理对象都要维护

JDK动态代理

代理对象,不需要实现接口，但是目标对象要实现接口，否则不能用动态代理
代理对象的生成，是利用JDK的API，动态的在内存中构建代理对象
动态代理也叫做：JDK代理、接口代理

JDK中生成代理对象的API

代理类所在包:java.lang.reflect.Proxy
JDK实现代理只需要使用newProxyInstance方法,但是该方法需要接收三个参数,完

整的写法是:

static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces,InvocationHandler h )

代码演示

public interface ITeacherDao {
    void teach();//授课
}

public class TeacherDao implements ITeacherDao {
    @Override
    public void teach() {
        System.out.println("老师正在授课中");
    }
}

public class ProxyFactory {

    //维护一个目标对象
    private Object target;

    //构造器，对目标对象初始化
    public ProxyFactory(Object target) {
        this.target = target;
    }

    //给目标对象生成一个代理对象
    public Object getProxyInstance() {
        /**
         *     public static Object newProxyInstance(ClassLoader loader,
         *                                           Class<?>[] interfaces,
         *                                           InvocationHandler h)
         *      1.ClassLoader loader:指定当前目标对象使用的类加载器，获取加载器的方法固定
         *      2. Class<?>[] interfaces：目标对象实现的接口类型，使用泛型方法确认类型
         *      3.InvocationHandler h：事情处理，执行目标对象的方法时，会触发事情处理器方法，会把当前执行的目标对象方法作为参数传入
         */

        return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), (proxy, method, args) -> {
            System.out.println("JDK动态代理开始");
            //通过反射机制调用目标对象的方法
            Object returnVal = method.invoke(target, args);
            System.out.println("JDK代理提交");
            return returnVal;
        });
    }
}

public class Client {

    public static void main(String[] args) {
        //创建一个目标对象
        ITeacherDao target = new TeacherDao();
        //给目标对象创建代理对象,可以转成
        ITeacherDao proxyInstance = (ITeacherDao) new ProxyFactory(target).getProxyInstance();
        System.out.println("proxyInstance = " + proxyInstance.getClass());
        //通过代理对象，调用目标对象的方法
        proxyInstance.teach();
    }
}

CGLIB动态代理

基本介绍

静态代理和JDK代理模式都要求目标对象是实现一个接口,但是有时候目标对象只是一个单独的对象,并没有实现任何的接口,这个时候可使用目标对象子类来实现代理-这就是Cglib代理
Cglib代理也叫作子类代理,它是在内存中构建一个子类对象从而实现对目标对象功能扩展, 有些书也将Cglib代理归属到动态代理。
Cglib是一个强大的高性能的代码生成包,它可以在运行期扩展java类与实现java接口.它广泛的被许多AOP的框架使用,例如Spring AOP，实现方法拦截
在AOP编程中如何选择代理模式：

目标对象需要实现接口，用JDK代理
目标对象不需要实现接口，用Cglib代理

Cglib包的底层是通过使用字节码处理框架ASM来转换字节码并生成新的类

代码演示

public class TeacherDao {
    public void teach() {
        System.out.println("老师授课中......我是CGLIB，不需要实现接口");
    }
}

public class ProxyFactory implements MethodInterceptor {

    private Object target;

    //传入一个被代理的对象
    public ProxyFactory(Object target) {
        this.target = target;
    }

    //返回一个代理对象：是target对象的代理对象
    public Object getProxyInstance() {
        //1 创建一个工具类
        Enhancer enhancer = new Enhancer();
        //2 设置父类
        enhancer.setSuperclass(target.getClass());
        //3 设置回调函数
        enhancer.setCallback(this);
        //4 创建子类对象，即代理对象
        return enhancer.create();
    }

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("CGLIB代理模式开始");
        Object returnVal = method.invoke(target, objects);
        System.out.println("CGLIB代理模式提交");
        return returnVal;
    }
}

public class Client {
    public static void main(String[] args) {
        //创建目标对象
        TeacherDao teacherDao = new TeacherDao();
        //获取代理对象，并且将目标对象传递给代理对象
        TeacherDao proxyFactory = (TeacherDao) new ProxyFactory(teacherDao).getProxyInstance();
        //执行代理对象方法，触发intercept
        proxyFactory.teach();
    }
}

几种常见的代理模式介绍——几种变体

1) 防火墙代理

内网通过代理穿透防火墙，实现对公网的访问。

2) 缓存代理

比如：当请求图片文件等资源时，先到缓存代理取，如果取到资源则ok,如果取不到资源，再到公网或者数据库取，然后缓存。

3) 远程代理

远程对象的本地代表，通过它可以把远程对象当本地对象来调用。远程代理通过网络和真正的远程对象沟通信息。

4) 同步代理：主要使用在多线程编程中，完成多线程间同步工作

13、行为型模式——模板模式

基本介绍

模板方法模式（Template Method Pattern），又叫模板模式(Template Pattern)，在一个抽象类公开定义了执行它的方法的模板。它的子类可以按需要重写方法实现，但调用将以抽象类中定义的方式进行。
简单说，模板方法模式 定义一个操作中的算法的骨架，而将一些步骤延迟到子类中，使得子类可以不改变一个算法的结构，就可以重定义该算法的某些特定步骤
这种类型的设计模式属于行为型模式。

原理类图

对原理类图的说明-即(模板方法模式的角色及职责)

1) AbstractClass 抽象类，类中实现了模板方法(template)，定义了算法的骨架，具体子类需要去实现其它的抽象方法operationr2,3,4

2) ConcreteClass 实现抽象方法operationr2,3,4, 以完成算法中特点子类的步骤

代码演示

public abstract class SoyMilk {

    public final void make() {
        select();
        add();
        soak();
        beat();
    }

    public void select() {
        System.out.println("第一步，选择黄豆");
    }

    public abstract void add();

    public void soak() {
        System.out.println("第三步，黄豆和配料浸泡三小时");
    }

    public void beat() {
        System.out.println("第四步，打豆浆");
    }
}

public class PeanutSoyaMilk extends SoyMilk {
    @Override
    public void add() {
        System.out.println("第二步，加入上好的花生");
    }
}

public class RedBeanSoyaMilk extends SoyMilk {
    @Override
    public void add() {
        System.out.println("第二步，加入上好的红豆");
    }
}

public class Client {

    public static void main(String[] args) {
        //制作红豆豆浆
        System.out.println("==========制作红豆豆浆==========");
        SoyMilk redBeanSoyaMilk = new RedBeanSoyaMilk();
        redBeanSoyaMilk.make();

        //制作花生豆浆
        System.out.println("==========制作花生豆浆==========");
        SoyMilk peanutSoyaMilk = new PeanutSoyaMilk();
        peanutSoyaMilk.make();
    }
}

模板方法模式的钩子方法

在模板方法模式的父类中，我们可以定义一个方法，它默认不做任何事，子类可以视情况要不要覆盖它，该方法称为“钩子”。
还是用上面做豆浆的例子来讲解，比如，我们还希望制作纯豆浆，不添加任何的配料，请使用钩子方法对前面的模板方法进行改造

代码演示

public abstract class SoyMilk {
    public final void make() {
        select();
        if (wantAdd()) {
            add();
        }
        soak();
        beat();
    }

    public void select() {
        System.out.println("第一步，选择黄豆");
    }

    public abstract void add();

    public void soak() {
        System.out.println("第三步，黄豆和配料浸泡三小时");
    }

    public void beat() {
        System.out.println("第四步，打豆浆");
    }

    //钩子方法，决定是否需要添加配料
    boolean wantAdd() {
        return true;
    }
}

public class PureSoyaMilk extends SoyMilk {
    @Override
    public void add() {
        //空实现
    }

    @Override
    boolean wantAdd() {
        return false;
    }
}

public class Client {
    public static void main(String[] args) {
        //制作纯豆浆
        System.out.println("==========制作纯豆浆==========");
        SoyMilk pureSoyaMilk = new PureSoyaMilk();
        pureSoyaMilk.make();
    }
}

模板方法模式的注意事项和细节

基本思想是：**算法只存在于一个地方，也就是在父类中，容易修改。**需要修改算法时，只要修改父类的模板方法或者已经实现的某些步骤，子类就会继承这些修改

2) **实现了最大化代码复用。**父类的模板方法和已实现的某些步骤会被子类继承而直接使用。

3) **既统一了算法，也提供了很大的灵活性。**父类的模板方法确保了算法的结构保持不变，同时由子类提供部分步骤的实现。

该模式的不足之处：每一个不同的实现都需要一个子类实现，导致类的个数增加，使得系统更加庞大
一般模板方法都加上final关键字，防止子类重写模板方法.
模板方法模式使用场景：当要完成在某个过程，该过程要执行一系列步骤 ，这一 系列的步骤基本相同，但其个别步骤在实现时可能不同，通常考虑用模板方法模式来处理

14、行为型模式——命令模式

基本介绍

命令模式（Command Pattern）：在软件设计中，我们经常需要向某些对象发送请求，但是并不知道请求的接收者是谁，也不知道被请求的操作是哪个，我们只需在程序运行时指定具体的请求接收者即可，此时，可以使用命令模式来进行设计
命名模式使得请求发送者与请求接收者消除彼此之间的耦合，让对象之间的调用关系更加灵活，实现解耦。
在命名模式中，会将一个请求封装为一个对象，以便使用不同参数来表示不同的请求(即命名)，同时命令模式也支持可撤销的操作。
通俗易懂的理解：将军发布命令，士兵去执行。其中有几个角色：将军（命令发布者）、士兵（命令的具体执行者）、命令(连接将军和士兵)。

Invoker是调用者（将军），Receiver是被调用者（士兵），MyCommand是命令，实现了Command接口，持有接收对象

原理类图

类图说明

Invoker 是调用者角色
Command: 是命令角色，需要执行的所有命令都在这里，可以是接口或抽象类
Receiver: 接受者角色，知道如何实施和执行一个请求相关的操作
ConcreteCommand: 将一个接受者对象与一个动作绑定，调用接受者相应的操作，实现execute

代码说明

public interface Command {
    void execute();

    void undo();
}

public class LightReceive {

    public void on() {
        System.out.println("电灯打开了");
    }

    public void off() {
        System.out.println("电灯关闭了");
    }
}

public class LightOnCommand implements Command {

    LightReceive light;

    //构造器
    public LightOnCommand(LightReceive light) {
        this.light = light;
    }

    @Override
    public void execute() {
        //调用接受者的方法
        light.on();
    }

    @Override
    public void undo() {
        light.off();
    }
}

public class LightOffCommand implements Command {

    LightReceive light;

    public LightOffCommand(LightReceive light) {
        this.light = light;
    }

    @Override
    public void execute() {
        light.off();
    }

    @Override
    public void undo() {
        light.on();
    }
}

public class NoCommand implements Command {

    @Override
    public void execute() {

    }

    @Override
    public void undo() {

    }
}

public class RemoteController {

    //开按钮的命令
    Command[] onCommands;
    Command[] offCommands;

    //执行撤销命令
    Command undoCommand;

    //构造器，完成对按钮的初始化
    public RemoteController() {
        onCommands = new Command[5];
        offCommands = new Command[5];

        for (int i = 0; i < 5; i++) {
            onCommands[i] = new NoCommand();
            offCommands[i] = new NoCommand();
        }
    }

    //给我们的按钮设置你需要的命令
    public void setCommand(int no, Command onCommand, Command offCommand) {
        onCommands[no] = onCommand;
        offCommands[no] = offCommand;
    }

    //按下开按钮
    public void onButtonWasPushed(int no) {
        //找到你按下的按钮，并调用对应方法
        onCommands[no].execute();
        //记录这次的操作，用于撤销
        undoCommand = onCommands[no];
    }

    //按下关按钮
    public void offButtonWasPushed(int no) {
        //找到你按下的按钮，并调用对应方法
        offCommands[no].execute();
        //记录这次的操作，用于撤销
        undoCommand = offCommands[no];
    }

    //撤销按钮
    public void undoButtonPushed() {
        undoCommand.undo();
    }
}

public class Client {

    public static void main(String[] args) {
        //使用命令设计模式，完成如果遥控器，对电灯的操作

        //创建电灯的对象（接受者）
        LightReceive lightReceive = new LightReceive();
        //创建电灯开关的命令
        LightOnCommand lightOnCommand = new LightOnCommand(lightReceive);
        LightOffCommand lightOffCommand = new LightOffCommand(lightReceive);
        //遥控器设置命令
        RemoteController remoteController = new RemoteController();
        remoteController.setCommand(0, lightOnCommand, lightOffCommand);
        System.out.println("==============按下灯的开按钮===============");
        remoteController.onButtonWasPushed(0);
        System.out.println("==============按下灯的关按钮===============");
        remoteController.offButtonWasPushed(0);
        System.out.println("==============按下灯的撤销按钮===============");
        remoteController.undoButtonPushed();
    }
}

命令模式的注意事项和细节

将发起请求的对象与执行请求的对象解耦。发起请求的对象是调用者，调用者只要调用命令对象的execute()方法就可以让接收者工作，而不必知道具体的接收者对象是谁、是如何实现的，命令对象会负责让接收者执行请求的动作，也就是说：”请求发起者”和“请求执行者”之间的解耦是通过命令对象实现的，命令对象起到了纽带桥梁的作用。
容易设计一个命令队列。只要把命令对象放到列队，就可以多线程的执行命令
容易实现对请求的撤销和重做
命令模式不足：可能导致某些系统有过多的具体命令类，增加了系统的复杂度，这点在在使用的时候要注意
空命令也是一种设计模式，它为我们省去了判空的操作。在上面的实例中，如果没有用空命令，我们每按下一个按键都要判空，这给我们编码带来一定的麻烦。
命令模式经典的应用场景：界面的一个按钮都是一条命令、模拟CMD（DOS命令）订单的撤销/恢复、触发-反馈机制

JUC

JVM

MySQL

数据结构与算法

网络编程

计算机网络原理

doCommand;

//构造器，完成对按钮的初始化
public RemoteController() {
    onCommands = new Command[5];
    offCommands = new Command[5];

    for (int i = 0; i < 5; i++) {
        onCommands[i] = new NoCommand();
        offCommands[i] = new NoCommand();
    }
}

//给我们的按钮设置你需要的命令
public void setCommand(int no, Command onCommand, Command offCommand) {
    onCommands[no] = onCommand;
    offCommands[no] = offCommand;
}

//按下开按钮
public void onButtonWasPushed(int no) {
    //找到你按下的按钮，并调用对应方法
    onCommands[no].execute();
    //记录这次的操作，用于撤销
    undoCommand = onCommands[no];
}

//按下关按钮
public void offButtonWasPushed(int no) {
    //找到你按下的按钮，并调用对应方法
    offCommands[no].execute();
    //记录这次的操作，用于撤销
    undoCommand = offCommands[no];
}

//撤销按钮
public void undoButtonPushed() {
    undoCommand.undo();
}

}

public class Client {

public static void main(String[] args) {
    //使用命令设计模式，完成如果遥控器，对电灯的操作

    //创建电灯的对象（接受者）
    LightReceive lightReceive = new LightReceive();
    //创建电灯开关的命令
    LightOnCommand lightOnCommand = new LightOnCommand(lightReceive);
    LightOffCommand lightOffCommand = new LightOffCommand(lightReceive);
    //遥控器设置命令
    RemoteController remoteController = new RemoteController();
    remoteController.setCommand(0, lightOnCommand, lightOffCommand);
    System.out.println("==============按下灯的开按钮===============");
    remoteController.onButtonWasPushed(0);
    System.out.println("==============按下灯的关按钮===============");
    remoteController.offButtonWasPushed(0);
    System.out.println("==============按下灯的撤销按钮===============");
    remoteController.undoButtonPushed();
}

}


#### 命令模式的注意事项和细节 

1) 将发起请求的对象与执行请求的对象解耦。发起请求的对象是调用者，调用者只要调用命令对象的execute()方法就可以让接收者工作，而不必知道具体的接收者对 象是谁、是如何实现的，命令对象会负责让接收者执行请求的动作，也就是说：”请求发起者”和“请求执行者”之间的解耦是通过命令对象实现的，命令对象起到了纽带桥梁的作用。 

2) 容易设计一个命令队列。只要把命令对象放到列队，就可以多线程的执行命令 

3) 容易实现对请求的撤销和重做 

4) 命令模式不足：可能导致某些系统有过多的具体命令类，增加了系统的复杂度，这 点在在使用的时候要注意 

5) 空命令也是一种设计模式，它为我们省去了判空的操作。在上面的实例中，如果没 有用空命令，我们每按下一个按键都要判空，这给我们编码带来一定的麻烦。 

6) 命令模式经典的应用场景：界面的一个按钮都是一条命令、模拟CMD（DOS命令）订单的撤销/恢复、触发-反馈机制

江南_烟雨.

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
二十三种设计模式，快速入门

客户端不应该依赖它不需要的接口，即一个类对另一个类的依赖应该建立在最小的接口上先看一张图将接口Interface1拆分成三个接口，类A和类C分别与他们需要的接口建立依赖关系。也就是采用接口隔离原则高层模块不应该依赖于低层模块，二者都应该依赖于抽象抽象不应该依赖于细节，细节应该依赖于抽象依赖倒置的中心思想是面向接口编程依赖倒置原则是基于这样的设计理念：相对于细节的多变性，抽象的东西是稳定的多。以抽象为基础搭建的架构比以细节为基础的要稳定的多。
复制链接

扫一扫