震惊！居然有如此容易理解的——单例模式

写在前面的话：
本人自己认为学的其实不算好，写这些是为了自己能够总结中提高，还有忘记了的时候能回来瞄一眼~~~
所以写的东西肯定比较通俗，也比较浅。大多是从书本和一些视频教材里得到的体会，太多了就不引用了。总之很感谢为我提供这些知识的老师和前辈们~
一直在努力让自己进步，如果有什么错误和忽略，请大家一定为我指出来~

单例(Singleton)模式：

功能：保证一个类的对象的唯一性。
Q：什么时候需要用到这个功能呢？
A：比如说多个程序都要使用一个配置文件中的数据，而且要实现数据的共享。就必须要将多个数据封装到一个对象中。而且多个程序操作的是同一个对象。也就是说，我们必须保持这个配置文件对象的唯一性的时候！

Q：咋保证对象的唯一性呢？
A：要把大象装冰箱，不。。。是把对象变唯一，思考这个问题总共要分三步。第一步，我们知道，一个类如果提供了public的构造函数，就可以产生多个对象了。所以我们就应该阻止其他程序建立对象！第二步，在本类中创建一个对象，就可以达到可控！第三步，我们需要给其他程序提供一个访问这个对象的方式！

总结一下实现步骤：
1.私有化构造函数，不让其他程序创建的对象初始化。
2.在本类中new一个本类对象。
3.定义一个功能，其他程序可以通过这个功能获取到本类的对象。
搞定！！

接下来我们看一下实现的具体步骤,我们搞一个Single类进行试验~
public class Single {}
好的，现在它是空的，我们按照步骤往里面填东西吧。

public class Single {
    //1.创建一个本类对象。
    private static final Single single = new Single();
    //2.私有化构造函数
    private Single(){
    }
    //3.定义一个方法返回这个对象。
    public static Single getInstance() {
        return single;
    }
}

上面就是一个最简单的单例。从头到尾来讲代码。
Q1：创建本类对象时候的private是必要的吗？
A1：这是很有必要的，我们写一个Test类。

public class SingleTest {
    public static void main(String[] args) {
          Single s1 = Single.getInstance();     
          Single s2 = Single.getInstance();//可以输出一下试试，s1和s2获取的是同一个对象！
  }
}

如果我们不给本类的对象加上private的话。我们可以用这样的方法来获取对象：
Single ss1 = Single.single;
Single ss2 = Single.single;
Q1：那既然这样也可以，用方法获取的方式比它好在哪里呢？
A1：用方法获取比它多的优势是对对象可控！我们可以在方法里加上条件语句，来控制可获取到的对象~

Q2：static 为啥要用上呢？
A2：因为对方法的调用是直接通过类，而不是通过已有对象，所以要加静态。

好的，这个时候，我们就已经学会了最基础的单例了，本人慢慢摸索和学习中，学到了单例模式的不同写法。接下来我们来谈一谈~

单例模式的不同写法

①饿汉式：我很饿，我一上来就要new个对象！

public class Single {
    //1.创建一个本类对象。
    private static final Single single = new Single();
    //2.私有化构造函数
    private Single(){
    }
    //3.定义一个方法返回这个对象。
    public static Single getInstance() {
        return single;
    }
}

我们刚才讲的最基础的就是饿汉式，我个人觉得饿汉式很稳妥，他不用考虑线程的问题，因为在类创建的同时，就已经建好了一个静态的对象了。

②懒汉式：我先不new对象，等我干活的时候，我再去new。虽然，额。。。我多线程时候会出现点问题。。。

public class Single2 {
    private static Single2 single2 = null;
    private Single2() {}
    public static Single2 getInstance() {
        if (single2 == null) {
            single2 = new Single2();
        }
        return single2;
    }

}

虽然说懒汉式会出现线程问题，但是并不意味着这是不可避免的，利用静态内部类，就可以解决问题：

public class Single {
    private static class LazyHolder {
      private static final Single2 INSTANCE = new Single(); 
    }
    private Single () {}
    public static final Single getInstance() {
        return LazyHolder.INSTANCE;
    }
}

还有别的解决这个线程问题的方法，不过这里我觉得放上我认为最好的方式就足够了。。。太多了更容易记不住
总之，这个懒汉式我是特别的不喜欢，效率上也没啥优势。用它还不如用饿汉了。

③利用枚举：(很好很强大！)

先说，这种方法我以前是不知道的，总结的时候，发现了这种方法，感觉非常的新颖，所以觉得值得记下来~

public enum Single {  
    INSTANCE;  
    public void whateverMethod() {  
    }  
}  

结束了，对！这种方法，这样就OK了！它利用了enum的特性，它避免了线程的问题，而且防止利用反序列化的方式重新创建新对象。但是他也有他的缺点，他失去了一些类的特性，不过比起来，还是比其他的方法强大太多了！

我给大家写一些例子，然后测试用，这样就更好理解啦！

懒汉式和饿汉式的话，我决定就写一个饿汉式好啦，他俩差别就在于创建对象的时间。
比如说我们写个孙悟空吧。为了让大家看的更清晰,接下来我决定贴图，请主要看注释~
(请忽略那个很不标准的包名~别学我，我平时代码都写的很标准的 <(￣3￣)>)

写一个孙悟空类

接下来我们写测试类：
可以看一下是否对象唯一了，如果不报错那是有问题的：

因为上文中孙悟空是唯一的了

接下来我们来测试：

注意我们获得的monkeyKing1和monkeyKing2

下面是结果：

运行结果

在结果里我们很清楚的看到了，我们改的是monkeyKing2的名字，但是monkeyKing1的名字也跟着变化了，成功证明：他俩获取到的是同一对象！

接下来就是枚举的演示了！大大推荐这种写法！

其实我感觉利用枚举反而变得简单多了！
先改孙悟空那个类：

利用枚举的写法

现在那个static可以加，不加也没事~

再看测试类：

测试类

有点小改动，直接调就行！

测试结果：

运行结果

没有任何问题！灰常开心！！！

这里我们看到了，利用枚举，简单粗暴，不会有线程的问题，直接调确实稳定性会几乎是无懈可击的~