没有女朋友的点进来！！一起来使用单例模式写个女朋友吧！！

hello，大家好，这里是布丁萨玛，最近疫情结束了。小伙伴们是不是都要和自己的女朋友出去嗨了？
什么？
你还没有朋友。
不要紧，今天布丁就教你写个女朋友。

开始搞事情！！

几天前，我有一个朋友，是一个单身贵族。并且单身了18年了。有一天他就跑来找我说。

“布丁啊，你说JAVA既然可以把任何东西都抽象成一个对象，那么是不是可以写个女朋友出来”。

“嗯！！我觉得可以有，骚年。去吧勇敢的去创造奇迹吧”

于是过了十分钟朋友拿着他写的女朋友来找我了。

“布丁，布丁你看看这就是我写的女朋友。”

“我的女朋友可以和我一起逛街、吃饭、看电影。甚至之后的嘿嘿嘿”

布丁：“嗯？，嘿嘿嘿是什么啊？我怀疑你在搞黄色。”

“什么？什么是搞黄色？嘿嘿嘿是我们两个一起在房间里讲笑话。所以才会有嘿嘿嘿的声音”

哦哦哦。。。原来如此（奇怪的只是增加了）。

你们这群心里有颜色的人是不是想歪了。想歪了评论区罚站去。

下面我们看下我朋友写的女朋友。

/**
 * @Author: buding
 * 女朋友类
 * 
 * @DateTime: 2020/6/8 8:52 下午
 */
public class Girl {
    // 好感度
    private int favorability = 0;
    /**
     * 逛街
     */
    public void shop() {
        System.out.println("你和女朋友一起去看逛街，好感度+30");
        // 好感度+30
        favorability += 30;
        showFavorability();
    }
    /**
     * 吃饭
     */
    public void eat() {
        System.out.println("你和女朋友一起去看吃饭，好感度+30");
        favorability += 30;
        showFavorability();
    }
    /**
     * 看电影
     */
    public void watchMovie() {
        System.out.println("你和女朋友一起去看电影，好感度+30");
        favorability += 30;
        showFavorability();
    }
    /**
     * 嘿嘿嘿
     */
    public void heiheihei() {
        if (favorability > 90) {
            System.out.println("晚上等你一起heiheihei");
        } else {
            System.out.println("警察叔叔！！！！！这有个变态");
        }
    }
    private void showFavorability() {
        System.out.println("你和你女朋友的好感度是：" + favorability);
    }
}

看完上面的女朋友。

有很多小伙伴就说了是不是可以直接嘿嘿嘿啊？

哎，我就不知道了。笑话有这么好听吗？逛街不好吗？

搞不懂你们。

不过，这里如果我们想要和女朋友嘿嘿嘿。那么就首先要把好感度达到一定的90以上。
那么要怎么样才能达到那？

我们可以陪女朋友逛街、吃饭、看电影。这样好感度就会达到100 。
我们就可以和女朋友嘿嘿嘿了。

ok,简单。

那么我们开始吧。

  public static void main(String[] args) {
        Girl girl = new Girl();
        // 逛街
        girl.shop();
        // 吃饭
        girl.eat();
        // 看电影
        girl.watchMovie();
    }

我们已经和女朋友逛了街、吃了羊腰子、看了爱情电影。就在你想着要和女朋友开个房间一起讲笑话的时候。

女朋友突然说：人家想要在五星级酒店的总统套房里面讲笑话。

于是你看了看你支付宝仅有的150块钱。
愣在了原地。

你看着你女朋友说：宝贝，你可以等我吗？我一定要和你在五星级酒店的总统套房里面讲笑话。不过我现在没有钱。我要去北京搬砖。努力赚钱，

十年～十年～十年之后我来接你去五星级酒店讲笑话。

女朋友说：好，我会等你的。。你去吧。【哭泣

于是你开始了十年的打工之路～～～

～～～十年之后～～～

你望着你手里搬了十年砖终于攒够的10000块钱。

今天终于可以和女朋友一起去五星级酒店总统套房讲笑话了。

于是你兴冲冲的询问女友要不要嘿嘿嘿。

     Girl girl = new Girl();
     girl.heiheihei();

然而，你得到的回答是

oh，天呐？为什么？为什么？为什么会这样。我苦苦搬砖十年。为什么她还是不愿意和我去讲笑话。明明～～明明我们都已经经历了那么多。

为什么啊？老天爷你告诉我啊！！！

这是天上一道金灿灿的光芒照在了你的面前。

一个白发苍苍的老爷爷来到了你的面前。

“少年啊，你是不是觉得你的女朋友变了？”

“是啊？为什么啊？”

“哎，他已经不是你的女朋友了。因为你没有用单例，所以你每一次创建的女朋友的是不同的女朋友”

“那什么是单例我要怎么使用单例！！！告诉我啊！！”

“骚年，别着急，接下来我们娓娓道来”

正文开始

什么是单例模式?

看完上面的惨剧，我们就知道了为了能够和女朋友嘿嘿嘿，我们是一定要使用单例的。

如果不实用单例，那么我们每一次都要和女朋友先逛街、吃饭、看电影。才能嘿嘿嘿。

如果使用单例，那么我们就可以只陪她做一次之后，之后的时间就可以随时和她讲笑话了。

是不是很开心？很兴奋？

那么什么是单例模式呢？

单例就是让我们自己只有一个女朋友。而且随时都可以调用。

“布丁布丁，我喜欢多人运动。“

那么单例模式的简单的定义就是：只存在一个实例，并且提供一个全局调用的方法

简单吧。不难吧。那么接下来我们就来看下，我们要如何实现单例。又有几种实现单例的方法呢。

单例模式的5种写法

以下是实现单例的常用的几种方法，我个人感觉没有绝对最优的方法，至于最终使用哪一种还要看项目的需求。

ok，废话少说，我们一起来看看吧。

1、懒汉法

懒顾名思义就是实例在用到的时候才去创建，“比较懒”，用的时候才去检查有没有实例，如果有则返回，没有则新建。

优点：写起来简单，容易理解
缺点：线程不安全

/**
 * @Author: buding
 * 懒汉式
 * @DateTime: 2020/6/8 12:45 下午
 */
public class Lhan {
    private static Lhan instance = null;
    // 将构造方法私有化，防止外部调用
    private Lhan() {
        System.out.println("创建了Lhan");
    }
    // 使用static使外部可以直接进行调用。
    public static Lhan getInstance() {
        // 判断是不是有实例化过，没有则进行实例话，否则直接返回实例化后的对象
        if (instance == null) {
            instance = new Lhan();
        }
        return instance;
    }
}

2、饿汉法

饿汉式，从名字上也很好理解，就是“比较勤”，由于使用了static关键字，所以实例在初始化的时候就已经建好了，不管你有没有用到，都先建好了再说。

优点：书写简单、没有线程安全的问题
缺点：是浪费内存空间

public class Ehan {
    private static final Ehan instance = new Ehan();

    public Ehan() {
        System.out.println("创建了Ehan");
    }

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

2、双检锁

双检锁，又叫双重校验锁，综合了懒汉式和饿汉式两者的优缺点整合而成。看上面代码实现中，特点是在synchronized关键字内外都加了一层 if 条件判断，这样既保证了线程安全，又比直接上锁提高了执行效率，还节省了内存空间。
记得要加上volatile关键字，因为instance = new DoubleCheck();并不是一步完成的。如果不加volatile，多线程容易出现指令重排的问题。

指令重排:在计算机执行指令的顺序在经过程序编译器编译之后形成的指令序列，一般而言，这个指令序列是会输出确定的结果；以确保每一次的执行都有确定的结果。但是，一般情况下，CPU和编译器为了提升程序执行的效率，会按照一定的规则允许进行指令优化。

优点：没有线程安全的问题
缺点：书写麻烦

/**
 * @Author: buding
 * 双重锁
 * @DateTime: 2020/6/8 1:01 下午
 */
public class DoubleCheck {

    private static volatile DoubleCheck instance = null;

    private DoubleCheck() {
        System.out.println("创建了DoubleCheck");
    }

    public static DoubleCheck getInstance() {
        if (instance == null) {
            synchronized (DoubleCheck.class) {
                if (instance == null) {
                    instance = new DoubleCheck();
                }
            }
        }
        return instance;
    }
}

2、静态内部类

静态内部类主要是利用了JVM自身的特性。带有static关键字只在类加载的是有执行一次，所以不会多次创建。

优点：书写简单 无多线程问题
缺点：只适用于静态域情况

/**
 * @Author: buding
 * 静态内部类
 * @DateTime: 2020/6/8 1:04 下午
 */
public class StaticClass {


    private StaticClass() {
        System.out.println("创建了StaticClass");
    }

    private static class Holder {
        private static StaticClass instance = new StaticClass();
    }

    public static StaticClass getInstance() {
        return Holder.instance;
    }
}

2、枚举

枚举的方式是比较少见的一种实现方式，也是利用了JVM自身的特性，防止多次实例化。

优点：书写简单
缺点：不好理解 无法传递初始化参数

/**
 * @Author: 于丁
 * @DateTime: 2020/6/8 1:27 下午
 */
public enum Enums {
    INSTANCE;

    private EnumDemo enumDemo = new EnumDemo();

    public EnumDemo getEnumDemo() {
        return enumDemo;
    }
}

后记

之后把这些东西和我的那个朋友讲了之后他也顺利的写出来单例模式的女朋友。
并且也成功和她去五星级总统套房讲笑话去了。

代码如下

/**
 * @Author: buding
 * 女朋友单例版（静态内部类）
 * @DateTime: 2020/6/8 8:52 下午
 */

public class GirlSignleton {

    private static GirlSignleton instance;

    // 好感度
    private int favorability = 0;

    private GirlSignleton() {
        shop();
        eat();
        watchMovie();
    }

    private static class Holder {
        private static GirlSignleton girlSignleton = new GirlSignleton();
    }

    public static GirlSignleton getInstance() {
        return Holder.girlSignleton;
    }

    /**
     * 逛街
     */
    public void shop() {
        System.out.println("你和女朋友一起去看逛街，好感度+30");
        // 好感度+30
        favorability += 30;
        showFavorability();
    }

    /**
     * 吃饭
     */
    public void eat() {
        System.out.println("你和女朋友一起去看吃饭，好感度+30");
        favorability += 30;
        showFavorability();
    }

    /**
     * 看电影
     */
    public void watchMovie() {
        System.out.println("你和女朋友一起去看电影，好感度+30");
        favorability += 40;
        showFavorability();
    }

    /**
     * 嘿嘿嘿
     */
    public void heiheihei() {
        if (favorability > 90) {
            System.out.println("晚上等你一起heiheihei");
        } else {
            System.out.println("警察叔叔！！！！！这有个变态");
        }
    }

    private void showFavorability() {
        System.out.println("你和你女朋友的好感度是：" + favorability);
    }

}

ok，今天的单例模式就到这里了，最终我们使用了静态内部类的方式实现了单例的女朋友。 小伙伴们可以试着使用其他的模式写一下自己的女朋友。如果有什么问题欢迎评论区指出。谢谢🙏