Java进阶（二）：Java设计模式

设计模式分为3大类
根据模式是用来完成什么工作来划分，这种方式可分为创建型模式、结构型模式和行为型模式 3 种。
创建型模式 ：用于描述"怎样创建对象"，它的主要特点是"将对象的创建与使用分离"。提供了单
例 、原型、 工厂方法 、抽象工厂、建造者5 种创建型模式。
结构型模式 ：用于描述如何将类或对象按某种布局组成更大的结构，提供了代理、适配器、桥接、
装饰、外观、享元、组合 7 种结构型模式。
行为型模式 ：用于描述类或对象之间怎样相互协作共同完成单个对象都无法单独完成的任务，以及
怎样分配职责。提供了模板方法、策略、命令、职责链、状态、观察者、中介者、迭代器、访问
者、备忘录、解释器 11 种行为型模式。

五.单例模式（只创建一个对象）

在一个项目中，如何确保一个类始终只有一个对象。

特点：

单例类只有一个实例对象；（虽然多次创建，但只能产生一个）

该单例对象必须由单例类自行创建；（在单例类内部，在第一次使用时才创建）

单例类对外提供一个访问该单例的全局访问点；（需要提供一个公共的方法）

单例模式通常两种实现

①饿汉式单例 ：单例模式中的饿汉式(急切式单例) 在加载此类时,就已经将唯一的一个对象创建出来。

好处:不会存在线程安全问题。

不足: 在类加载时，就会创建单例对象，有可能一段时间内还用不到它。

java 复制代码

public class MyWindow {
    //在内部自己创建的一个单例对象
    private static MyWindow myWindow = new MyWindow();

    private MyWindow() {
    }

    /*
       对外提供这唯一的对象
     */
    public static MyWindow getMyWindow() {
        return myWindow;
    }
}

**②懒汉式单例：**在类加载时，并没有创建单例对象，在第一次获取单例对象时，才去创建了单例对象。

好处:类加载时先不创建，在第一次使用获取时才会创建。

不足: 会出现线程安全问题 ，加锁解决（synchronized锁）。

※ 双重检索 + volatile(可见性,避免重排序)

例如：A a = new A();

创建对象这一条语句编译为指令时,可以分为三个指令顺序：

1. new 申请空间

2. 调用构造方法初始化对象

3. 把对象地址赋给引用变量

如果按照这个正常的顺序执行，是没有问题的，但是执行时，如果2,3条指令顺序发生变化， 导致把没有初始化完成的对象地址返回了，拿去使用了,这么做会出问题，因为对象没有初始化完成。所有需要使用volatile关键修饰单例成员变量，确保对其赋值时，指令不重新排序。

java 复制代码

public class MyWindow {

    private volatile static MyWindow myWindow;

    public static MyWindow getMyWindow() {

        //第一重检索，隔绝后面大量的线程进入
        if (myWindow == null) {

            //加锁，只能一个一个进入
            synchronized (MyWindow.class) {

                //第二重检索，隔绝前面少量的线程进入
                if (myWindow == null) {
                    myWindow = new MyWindow();
                }
            }
        }
        return myWindow;
    }
}

六.工厂模式

解决的就是在项目将创建对象和使用对象分离的问题,(结合Spring)，如何更好的组织类与类之间的关系。

简单工厂模式（一个工厂对应多类产品）

简单工厂并不是一种设计模式，违背了开闭原则，主要是引出工厂方法和抽象工厂模式

涉及的角色：

工厂角色: 根据我们的需求，创建对应的对象。

抽象产品: 具体产品的抽象，具体产品实现 / 继承抽象产品，可以使用上层的抽象父类，表示任意的子类对象。

具体产品: 具体的对象。

优点: 创建对象和使用对象分离了。

缺点: 只能创建实现了同一个父类 / 接口的子类对象，扩展新的类型，需要**修改工厂，**违背了开闭原则。

适合简单的,子类较少的场景。

工厂方法模式（一个工厂对应一类产品）

由于简单工厂中，一个工厂，可以造同一类型的所有具体产品，导致简单工厂比较复杂，扩展一个新类型时，需要修改工厂代码。

工厂方法模式，为工厂也进行抽象，并且为同类型每个具体产品都创建了一个具体的工厂。

每一个工厂负责创建一个具体的产品 (类型)对象，这样扩展一个新的产品，与之对应就要扩展一个产品工厂，就不需要修改工厂，遵守了开闭原则，单一职责原则。

好处: 遵守了开闭原则。

不足: 类的数量增多了。

抽象工厂（一个工厂对应多类商家工厂）

如：一个工厂可分为小米工厂，华为工厂。小米工厂可造汽车，手机。华为工厂可造汽车，手机。

工厂方法模式 ，是按照产品类型进行分类的，一类产品，对应一类工厂， 不同类型产品之间,相互隔离的。例如：华为和小米，既要汽车，又要造手机，都是属于同一家的产品，但是工厂方法这种设计，同一个公司产品与产品之间没有联系。
抽象工厂模式 对工厂重新进行分类，以公司为单位进行工厂的抽象(提取)，一个工厂内，可以创建不同的产品，这样我们就可以创建出像华为工厂，小米工厂这样的具体工厂，一个工厂内，可以创建不同公司的各种产品。

七.原型模式

在某些场景下，为（解决的问题：）避免自己手动的new对象，我们可以使用对象克隆方式，创建并返回一个新的对象。这种克隆新对象的效率比我们自己new的效率要高。

对象克隆实现方式有两种：

1.实现Cloneable接口,重写clone()

2.使用对象序列化反序列化重新生成对象

注意深克隆和浅克隆问题。

八.代理模式

早在spring aop思想中，已经用到了代理思想。在不修改原来代码的前提下，为我们方法添加额外的功能。通过代理对象帮助我们进行调用。

有些时候，目标对象(汽车厂)不想或不能直接与客户打交道，通过代理对象进行访问，代理对象可以保护目标对象，对目标对象功能进行扩展，降低了模块之间的耦合度。

涉及到三个主题:

抽象主题: (抽取的功能，让目标对象进行实现，以及代理对象进行实现)

具体主题: 真正要实现功能的类。

代理对象

代理模式实现方式又有两种:

1.静态代理

创建一个代理类，代理实现与具体对象实现相同的接口 / 抽象类，重写抽象方法。还有一个成员变量，可以用接收具体的主题，在代理类中重写的抽象方法中调用真实主题方法，这样就可以在调用之前和之后添加额外的功能。

不足: 一个代理对象，只能代理一个接口类型的对象，不灵活。

2.动态代理

只需要写一次代理类，就可以通过反射机制动态获得类的信息，可以为任何类提供代理功能。

动态代理实现分为两种:

①jdk代理

jdk代理实现是通过反射机制实现的, 目标类必须要实现一个接口,通过接口动态获得目标类中的信息。

②cglib代理

是spring中提供的一种代理技术，目标类可以不实现任何接口 ，采用字节码生成子类的方式，对方法进行拦截，实现机制不同。

注意：cglib不能代理final修饰的类以及fnal和static修饰的方法。

目前spring中两种动态代理都支持，如果目标类没有实现接口，默认使用cglib代理，如果目标类有实现接口，采用jdk代理。

九.模板方法模式

模版方法模式，是在一个类中，定义好一个算法骨架，设定好实现步骤，把一些公共的通用的在父类中实现，然后将一些不确定的实现在具体的子类中实现。

例如，去银行办理业务一般要经过以下 4 个流程：取号、排队、办理具体业务、对银行
工作人员进行评分等，其中取号、排队和对银行工作人员进行评分的业务对每个客户是一样
的，可以在父类中实现，但是办理具体业务 却因人而异，它可能是存款、取款或者转账等，
可以延迟到子类中实现。
结构:

抽象类: 负责给出一个算法的轮廓和骨架。它由一个模板方法和若干个基本方法构成。

模版方法: 定义好执行顺序的算法骨架，确定好执行流程顺序。

抽象方法: 不确定的功能，定义为抽象的，交给子类实现。

具体方法: 都一样的公共的通用的方法，在抽象父类中实现。

具体子类: 实现抽象类中的抽象方法的具体类，有不同的实现方式，就可以用多个子类。

new 具体子类对象，用具体子类对象调用模版方法，把父类中具体方法与自己实现的抽象方法一起执行。

将变化部分定义为抽象的，让子类去扩展实现，满足开闭原则，适合流程相对比较固定的，其中有变化的场景。

十.策略模式

将不同的实现算法进行封装，将功能的实现与使用相分离。（多选一策略）在使用时，可以用不同的策略实现类进行替换。重点用到的知识点：继承，多态。

结构

抽象类：抽象方法

具体实现类（多个实现类实现抽象类的抽象方法，在多个实现类中多选一）

环境类(使用者)

**感谢你的阅读与关注，如有问题欢迎探讨！**💓