Java进阶（二）：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关键修饰单例成员变量，确保对其赋值时，指令不重新排序。

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 具体子类对象，用具体子类对象调用模版方法，把父类中具体方法与自己实现的抽象方法一起执行。

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

十.策略模式

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

结构

抽象类：抽象方法

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

环境类(使用者)