Java 23种设计模式

单例模式 7种实现方式

一、懒汉式（线程不安全）

package com.java.singleton;

//懒汉式 线程不安全
public class LazySingleton {

    //私有构造方法 只允许在内部进行实例的创建
    private LazySingleton() {
    }


    private static LazySingleton instance = null;

    //创建实例
    public static LazySingleton getInstance() {

        if (instance == null) {
            instance = new LazySingleton();
        }

        return instance;
    }
}

二、懒汉式（线程安全）

package com.java.singleton;

//懒汉式 线程安全
public class SynchronizedLazySingleton {

    //私有构造方法 只允许在内部进行实例的创建
    private SynchronizedLazySingleton() {
    }


    private static SynchronizedLazySingleton instance = null;

    //创建实例  线程安全
    public static synchronized SynchronizedLazySingleton getInstance() {

        if (instance == null) {
            instance = new SynchronizedLazySingleton();
        }

        return instance;
    }

}

三、饿汉式（线程安全）

package com.java.singleton;

//饿汉式
public class HungrySingleton {

    //私有构造方法 只允许在内部进行实例的创建
    private HungrySingleton() {
    }

    //静态初始化 由JVM保证线程安全
    private static HungrySingleton instance = new HungrySingleton();

    //创建实例
    public static HungrySingleton getInstance() {

        return instance;
    }

}

四、缓存实现（线程不安全）

package com.java.singleton;

import java.util.HashMap;
import java.util.Map;

//线程不安全 缓存实现
public class CacheSingleton {

    //私有构造方法 只允许在内部进行实例的创建
    private CacheSingleton() {
    }

    //构造缓存容器
    private static Map<String, CacheSingleton> map = new HashMap<>();

    //构造默认的存放key
    private static final String DEFAULT_KEY = "Cache";


    //创建实例
    public static CacheSingleton getInstance() {

        //先从缓存中取 没有就创建并放入缓存  有就返回
        CacheSingleton instance = (CacheSingleton) map.get(DEFAULT_KEY);

        if (instance == null) {

            instance = new CacheSingleton();
            map.put(DEFAULT_KEY, instance);
        }

        return instance;
    }

}

五、双重检查加锁（懒汉式 线程安全的进一步优化）

package com.java.singleton;


//双重检查加锁  懒汉式在方法上加synchronized的进一步优化
public class DoubleCheckedLockingSingleton {

    //私有构造方法 只允许在内部进行实例的创建
    private DoubleCheckedLockingSingleton() {
    }

    //volatile 修饰的变量不会被本地线程缓存 对该变量的读写直接作用于共享内存 类似于互斥锁
    private volatile static DoubleCheckedLockingSingleton instance = null;

    //创建实例
    public static DoubleCheckedLockingSingleton getInstance() {

        if (instance == null) {

            synchronized (DoubleCheckedLockingSingleton.class) {

                if (instance == null) {
                    instance = new DoubleCheckedLockingSingleton();
                }
            }

        }

        return instance;
    }


}

六、 Lazy Initialization Holder Class实现单例

package com.java.singleton;


//静态内部类 Lazy Initialization Holder Class
public class LazyInitializationHolderClassSingleton {

    //私有构造方法 只允许在内部进行实例的创建
    private LazyInitializationHolderClassSingleton() {
    }

    /*
     * 静态成员式内部类 该内部类的实例对象与外部类的实例无绑定关系
     * 有且只有在LazyInitializationHolder被调用instance时 在会对对象实例进行装载
     * 从而实现延时加载
     */
    private static class LazyInitializationHolder {

        /*
         * 静态初始化器 由JVM保证线程安全
         *
         */
        private static LazyInitializationHolderClassSingleton instance = new LazyInitializationHolderClassSingleton();
    }


    //创建实例
    public static LazyInitializationHolderClassSingleton getInstance() {

        return LazyInitializationHolder.instance;
    }


}

七、枚举实现单例

package com.java.singleton;

public enum EnumSingleton {
    //枚举类的每个元素 都代表一个单例
    uniqueEnumSingleton;


    public  void method() {

        System.out.println("EnumSingleton"+uniqueEnumSingleton.hashCode());
    }

}

---

设计模式的原则

总原则：开闭原则(使程序扩展性好、易于维护、升级)
对扩展开放，对修改关闭。在程序需要进行拓展的时候，不能去修改原有的代码，而是要扩展原有代码，实现一个热插拔的效果。想要达到这样的效果，我们需要使用接口和抽象类等。

单一职责：每个类应该实现单一的职责，如若不然，就应该把类拆分。
里氏替换原则：基类出现的地方，子类一定可以出现。
里氏代换原则是对“开-闭”原则的补充。 实现“开-闭”原则的关键步骤就是抽象化。而基类与子类的继承关系就是抽象化的具体实现。
子类对父类的方法尽量不要重写和重载。因为父类代表了定义好的结构，通过这个规范的接口与外界交互，子类不应该随便破坏它。

依赖倒转原则
这个是开闭原则的基础，具体内容：面向接口编程，依赖于抽象而不依赖于具体。写代码时用到具体类时，不与具体类交互，而与具体类的上层接口交互。

接口隔离原则
这个原则的意思是：每个接口中不存在子类用不到却必须实现的方法，如果不然，就要将接口拆分。使用多个隔离的接口，比使用单个接口（多个接口方法集合到一个的接口）要好。

迪米特法则（最少知道原则）
就是说：一个类对自己依赖的类知道的越少越好。也就是说无论被依赖的类多么复杂，都应该将逻辑封装在方法的内部，通过 public 方法提供给外部。这样当被依赖的类变化时，才能最小的影响该类。
最少知道原则的另一个表达方式是：只与直接的朋友通信。类之间只要有耦合关系，就叫朋友关系。耦合分为依赖、关联、聚合、组合等。我们称出现为成员变量、方法参数、方法返回值中的类为直接朋友。局部变量、临时变量则不是直接的朋友。我们要求陌生的类不要作为局部变量出现在类中。

合成复用原则：尽量首先使用合成/聚合的方式，而不是使用继承。

构建者模式

package com.job.app;

import java.util.ArrayList;
import java.util.List;

/**
 * @Author: zhaoxiaogang
 * @Date: 2019-02-03
 */
public class TestBuilder {
    private List<String> stringList = new ArrayList<>();

    //完成每一个步骤
    public TestBuilder test1() {
        stringList.add("1");
        return this;
    }
    
    //完成每一个步骤
    public TestBuilder test2() {
        stringList.add("2");
        return this;
    }

    //完成每一个步骤
    public List<String> last() {
        return this.stringList;
    }
}