面向对象的六大原则

• 单一职责原则 Single Responsibility Principle
  一个类中应该是一组相关性很高的函数、数据的封装。两个完全不一样的功能就不应该放在一个类中。

• 开闭原则 Open Close Principle
  软件中的对象（类、模块、函数等）应该对于扩展是开放的，但是对于修改是封闭的。
  在软件的生命周期内，因为变化、升级、维护等原因需要对软件原有的代码进行修改时，可能会将错误引入原本已经经过测试的旧代码中，破坏原有系统。因此当软件需要变化时，我们应该尽量通过扩展的方式来实现变化，而不是通过修改已有的代码来实现。尽量，说明OCP原则并不是说绝对不能修改原始类的，当原始类不好的时候应该尽早的进行重构。

• 里氏替换原则 Liskov Substitution Principle
  所有引用基类的地方，必须能透明地使用其子类的对象。里氏替换原则就是依赖于继承和多态这两大特性。
  开闭原则和里氏替换原则往往是相互依赖的，通过里氏替换来达到对扩展开放，对修改 封闭的效果。

• 依赖倒置原则 Dependence Inversion Principle
  一种特定的解耦形式，使得高层次的模块不依赖底层次的模块。具体而言即：1）高层模块不应该依赖低层模块，两者都应该依赖其抽象；2）抽象不应该依赖细节；3）细节应该依赖抽象。
  在Java语言中，一般抽象是指接口或者抽象类，两者都无法被实例化。细节是指实现类，实现接口或继承抽象类而产生的类就是细节。
  模块间的依赖通过抽象发生，实现类之间不发生直接的依赖关系，其依赖关系是通过接口或抽象类产生的。

• 接口隔离原则 Interface Segregation Principle
  客户端不应该依赖它不需要的接口。目的是系统解耦，从而更容易重构、更改和重新部署。
  上述是面向对象编程的5个基本原则。当这些原则被一起应用时，它们使得一个软件系统更清晰、简单，最大程度地拥抱变化。

• 迪米特原则 最少知识原则 Least Knowledge Principle
  一个类应该对自己需要耦合或调用的类知道得最少，类的内部如何实现与调用者或者依赖者没关系，调用者或者依赖者只需要知道它需要的方法即可，其他的可一概不管。

单例模式是应用最广的模式之一。

定义

确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例。

以上可知单例类的特点：

• 只能有一个实例
• 必须自己创建自己的唯一实例
• 必须给其他对象（整个系统）提供这一实例

使用场景

当这个类的对象在多个地方创建的时候，使得内部的方法多次调用，但是我们希望只要一个对象操作这个方法，或者不希望多个地方同时调用这个方法，我们需要保持这个方法的单一性质，我们就用单例模式。

比如：访问IO和数据库资源、单一弹框等。

实现单例模式的关键点

• 构造函数不对外开放，一般为Private
• 通过一个静态方法或者枚举返回单例类对象
• 确保单例类的对象有且仅有一个，尤其是在多线程环境下
• 确保单例类对象在反序列化时不会重新构建对象

单例模式UML类图

单例模式的实现方法

1.懒汉模式

//懒汉式单例类.在第一次调用的时候实例化自己
public class LHS_Singleton {

    private static LHS_Singleton instance;

    private LHS_Singleton() {
    }

    //静态工厂方法
    public static synchronized LHS_Singleton getInstance() {
        if (instance == null) {
            instance = new LHS_Singleton();
        }
        return instance;
    }
}

在getInstance()方法中用到了synchronized同步锁，保证了线程安全。
懒汉式是典型的时间换空间

• 优点：单例只有在使用的时候才会被实例化，一定程度上节约了资源。
• 缺点：第一次加载的时候需要及时进行实例化，最大问题在于每次调用都要进行同步，会造成不必要的同步开销，降低整个访问速度，且每次都需要进行判断是否需要创建实例。

2.DCL双重检查加锁模式

public class DCL_Singleton {
    private volatile static DCL_Singleton singleton = null;

    private DCL_Singleton() {
    }

    public static DCL_Singleton getSingleton() {
        //先检查实例是否存在，如果不存在才进入下面的同步块
        if (singleton == null) {
            //同步块，线程安全的创建实例
            synchronized (DCL_Singleton.class) {
                //再次检查实例是否存在，如果不存在才真正的创建实例
                if (singleton == null) {
                    singleton = new DCL_Singleton();
                }
            }
        }
        return singleton;
    }
}

与懒汉式不同在于，在getInstance()方法中不用再进行同步锁。第一个判断singleton == null主要是为了避免不必要的同步，第二次判断则是为了singleton = null的时候在线程安全的情况下创建实例。

• 优点：资源利用率高，既能够在需要的时候才初始化单例，又能保证线程安全，且单例对象初始化后调用getInstance()不再进行同步锁。
• 缺点：第一次加载反应稍慢，由于Java内存模型原因偶尔会失败，高并发情况下有一定缺陷。
• 注：由于volatile关键字可能会屏蔽掉虚拟机中一些必要的代码优化，所以运行效率并不是很高。因此虽然可以使用“双重检查加锁”机制来实现线程安全的单例，但并不建议大量采用，可以根据情况来选用。

3.静态内部类模式

public class JTNBL_Singleton {
    private JTNBL_Singleton() {
    }

    public static JTNBL_Singleton getInstanse() {
        return SingletonHolder.instance;
    }

    /**
     *    类级的内部类，也就是静态的成员式内部类，该内部类的实例与外部类的实例
     *    没有绑定关系，而且只有被调用到时才会装载，从而实现了延迟加载。
     */
    private static class SingletonHolder {
        /**
         * 静态初始化器，由JVM来保证线程安全
         */
        private static final JTNBL_Singleton instance = new JTNBL_Singleton();
    }
}

当getInstance()方法第一次被调用的时候，它第一次读取SingletonHolder.instance，会使SingletonHolder类得到初始化；而这个类在装载并被初始化的时候，会初始化它的静态域，从而创建JTNBL_Singleton的实例，由于是静态的域，因此只会在虚拟机加载类的时候初始化一次，并由虚拟机来保证它的线程安全性。

优点：这种方式不仅能够确保线程安全，也能够保证单例对象的唯一性，同时也延迟了单例的实例化。

注

在上述的几种实现单例模式的情况中，有一个情况下他们会出现重新创建对象的情况，那就是反序列化。如果要杜绝单例对象在被反序列化时重新生成对象，那么必须加入下面的方法：

private Object readResolve() throws ObjectStreamException {
        return instance;
    }

4.枚举单例

对于枚举，则不存在反序列化问题，因为即使反序列化枚举单例也不会重新生成新的实例。

public enum MJ_Singleton {
    /**
     * 定义一个枚举的元素，它就代表了MJ_Singleton的一个实例。
     */
    INSTANCE;

    /**
     * 单例可以有自己的操作
     */
    public void doSomething() {
        System.out.println("Hello World");
    }
}

枚举在JAVA中与普通的类一样，不仅能有字段，还能有自己的方法，最重要的是默认枚举实例的创建是线程安全的，并且在任何情况下它都是一个单例。

按照《高效Java 第二版》中的说法：单元素的枚举类型已经成为实现Singleton的最佳方法。用枚举来实现单例非常简单，只需要编写一个包含单个元素的枚举类型即可。

5.使用容器实现单例模式

public class RQ_Singleton {
    private static Map<String, Object> objectMap = new HashMap<>();

    private RQ_Singleton() {
    }

    public static void registerService(String key, Object instance) {
        if (!objectMap.containsKey(key)) {
            objectMap.put(key, instance);
        }
    }

    public static Object getService(String key) {
        return objectMap.get(key);
    }
}

在程序初始，将多种单例类型注入到一个统一的单例管理类中，通过key来获取对应类型的对象。

这种方式使得我们可以管理多种类型的单例，并且在使用时可以通过统一的接口进行获取操作，降低了耦合度，对用户隐藏了具体实现。

6.饿汉模式

public class EHS_Singleton {
    // 在这个类被加载的时候，静态变量single会被初始化，
    // 此时类的私有构造子会被调用。这时单例类的唯一实例就被构造出来了。
    private static EHS_Singleton instance = new EHS_Singleton();

    private EHS_Singleton() {
    }

    public static EHS_Singleton getInstance() {
        return instance;
    }
}

饿汉式其实是一种比较形象的称谓。既然饿，那么在创建对象实例的时候就比较着急，饿了嘛，于是在装载类的时候就创建对象实例。

饿汉式是典型的空间换取时间，当类装载时就会创建类的实例，不管你用不用，先创建出来，然后每次调用的时候，就不需要再判断，节省了运行时间。

单例模式的优点

• 在内存中只有一个实例，减少了内存开支，特别是对于一个对象需要频繁地创建、销毁时，而且创建或销毁时性能又无法优化，单例模式的优势便非常明显。
• 当一个对象的产生需要比较多的资源时，如读取配置、产生其他依赖对象时，则可以通过在应用启动时直接产生一个单例对象，然后永久驻留内存的方式来解决。
• 单例模式可以避免对资源的多重占用，例如写文件操作，避免了对同一个资源文件的同时写操作。
• 单例模式可以在系统设置全局的访问点，优化和共享资源访问，例如可以设计一个单例类，负责所有数据表的映射处理。

单例模式的缺点

• 单例模式一般没有接口，扩展很困难，若要扩展，除了修改代码基本上没有第二种途径可实现
• 单例对象如果持有Context，那么很容易引发内存泄漏，此时需要注意传递给单例对象的Context最好是Application Context

引用：
Android 源码设计模式解析与实战》
Java设计模式之单例模式及在Android中的重要使用