设计模式--待补充

一. 定义

是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。是一种思想。

二. 设计原则

1. 开闭原则：对扩展开放，对修改封闭。 在程序需要进行拓展的时候，不能去修改原有的代码，而是要扩展原有代码。想要达到这样的效果，需要使用抽象和多态，把有可能变化的内容抽象出来，使抽象的部分相对稳定，而具体的实现是可以改变和扩展的。
2. 单一职责原则：每个类应该实现单一的职责，对外只提供一种功能，而引起类变化的原因应该只有一个。
3. **里氏替换原则：任何父类出现的地方都可以用他的子类替代。**同一个继承体系中的对象应该有共同的行为特征。里氏代换原则是对“开-闭”原则的补充。实现“开闭”原则的关键步骤就是抽象化。而基类与子类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实现抽象化的具体步骤的规范。里氏替换原则中，子类对父类的方法尽量不要重写和重载。因为父类代表了定义好的结构，通过这个规范的接口与外界交互，子类不应该随便破坏它。
4. 依赖注入原则（Dependence Inversion Principle） 面向接口编程，依赖于抽象而不依赖于具体。写代码时用到具体类时，不与具体类交互，而与具体类的上层接口交互。
5. 接口隔离原则（Interface Segregation Principle） **不应该强迫程序依赖他们不需要使用的方法。一个接口不应该提供太多行为，应该只提供一种对外的功能。**每个接口中不存在子类用不到却必须实现的方法，如果不然，就要将接口拆分。使用多个隔离的接口，比使用单个接口（多个接口方法集合到一个的接口）要好。
6. 迪米特法则（最少知道原则）（Demeter Principle） **一个类对自己依赖的类知道的越少越好。**无论被依赖的类多么复杂，都应该将逻辑封装在方法的内部，通过public方法提供给外部。这样当被依赖的类变化时，才能最小的影响该类。 最少知道原则的另一个表达方式是：只与直接的朋友通信。类之间只要有耦合关系，就叫朋友关系。耦合分为依赖、关联、聚合、组合等。我们称出现为成员变量、方法参数、方法返回值中的类为直接朋友。局部变量、临时变量则不是直接的朋友。我们要求陌生的类不要作为局部变量出现在类中。
7. 合成复用原则（Composite Reuse Principle） 尽量首先使用合成/聚合的方式，而不是使用继承。

三 常见设计模式

1. 策略模式：策略模式定义了一系列的算法，并将每一个算法封装起来，使每个算法可以相互替代，使算法本身和使用算法的客户端分割开来，相互独立。学习链接
2. 模板模式
3. 工厂模式
4. 代理模式

四 单例模式的实现方式

1. 定义：确保一个类只有一个实例，并提供给外部一个访问它的全局访问点。
2. 两个基本原则：
   • private的构造函数——>确保单例不会在系统中的其他代码内被实例化
   • instance 成员变量和 getInstance 方法必须是 static 的——>因为要通过类名构造对象，因此方法static，进而方法内部的成员变量也要static。
3. 两种实现分类：
   • 饿汉方式。JVM在加载这个类时就马上创建此唯一的单例实例
   • 懒汉方式。指全局的单例实例在第一次被使用时构建。
4. 五种代码实现
   1. 饿汉式——线程安全；但不是懒加载，会造成空间浪费;在一些场景中将无法使用：如 Singleton 实例的创建是依赖参数或者配置文件的，在 getInstance() 之前必须调用某个方法设置参数给它，那样这种单例写法就无法使用了。

public class Singleton {
       //在静态初始化器中创建单例实例，这段代码保证了线程安全
        private static Singleton instance = new Singleton();
        private Singleton(){}
        public static Singleton getInstance(){
            return uniqueInstance;
        }
    }

• 2. 懒汉式——线程安全；但是每一个线程都会进入getInstance()， 都要经过synchronized加锁这一层，增加时间消费，而且还可能会发生阻塞。

public class Singleton {
    private static Singleton instance;
    private Singleton (){}

    public static synchronized Singleton getInstance() {
     if (instance == null) {
         instance = new Singleton();
     }
     return instance;
    }
}

• 3. 懒汉式(双重检查加锁版本)——首先检查是否实例已经创建，如果尚未创建，“才”进行同步

public class Singleton {

    //volatile保证，禁止指令重排
    private volatile static Singleton uniqueInstance;
    private Singleton() {
    }
    public static Singleton getInstance() {
       //检查实例，如果不存在，就进入同步代码块
        if (uniqueInstance == null) {
            //只有第一次才彻底执行这里的代码
            synchronized(Singleton.class) {
               //进入同步代码块后，再检查一次，如果仍是null，才创建实例
                if (uniqueInstance == null) {
                    uniqueInstance = new Singleton();
                }
            }
        }
        return uniqueInstance;
    }
}

• 4. 静态内部类——最推荐。注意final
  • 原理：加载一个类时，其内部类不会同时被加载。一个类被加载，当且仅当其某个静态成员（静态域、构造器、静态方法等）被调用时发生，也就是说内部类：SingletonHolder 只有我们调用getInstance()的时候才会被加载。
  • 优点：外部类加载时并不需要立即加载内部类，内部类不被加载则不去初始化INSTANCE，故而不占内存。这种方法不仅能确保线程安全，也能保证单例的唯一性，同时也延迟了单例的实例化。还是懒汉。

public class Singleton {  
    private static class SingletonHolder {  
        private static final Singleton INSTANCE = new Singleton();  
    }  
    private Singleton (){}  
    public static final Singleton getInstance() {  
        return SingletonHolder.INSTANCE; //此时才加载SingletonHolder类
    }  
}

• 5. 枚举。创建枚举默认就是线程安全的

public enum EasySingleton{
    INSTANCE;
}