2.5设计模式（单例设计模式）

1.设计模式：23种设计模式。对问题行之有效的解决方式。其实它是一种思想。
2.单例设计模式：就是可以保证一个类在内存中的对象唯一性。
解决办法：

步骤：
1）私有化该类的构造函数。
2）通过new在本类中创建一个本类对象
3）定义一个公有的方法，将创建的对象返回。

代码例子：
1.饿汉式：一上来就吃

/*
设计模式：23种设计模式。对问题行之有效的解决方式。其实它是一种思想。

1.单例设计模式。
        解决的问题：就是可以保证一个类在内存中的对象唯一性。

比如说对于多个程序使用同一个配置信息对象时，就需要保证该对象的唯一性。

如何保证对象的唯一性？
1）不允许其他程序用new创建该类对象。
2）在该类中创建一个本类实例。
3）对外提供一个方法让其他程序可以获取该对象。

步骤：
1）私有化该类的构造函数。
2）通过new在本类中创建一个本类对象
3）定义一个公有的方法，将创建的对象返回。
*/


class Single //类一加载，对象就已经存在了
{
    private Single(){};

    private static Single s = new Single();     //成员变量一般不暴露出去

    public static Single getInstance()   //这个方法存在是赋予对象的可控性
    {
            return s;
    }
}
class SingleDemo
{
    public static void main(String[] args)
    {
            Single ss = Single.getInstance();
            Single s1 = Single.getInstance();
            System.out.println(ss == s1);
            //Single ss = Single.s;   //这样对象没有可控性

            Test t1 =Test.getInstance();
            Test t2 =Test.getInstance();
            t1.setNum(10);
            t2.setNum(20);
            System.out.println(t1.getNum());
            System.out.println(t2.getNum());
    }
}

class Test
{
    private int num;

    private Test(){};

    private static Test t = new Test();

    public static Test getInstance()
    {
        return t;
    }

    public void setNum(int num)
    {
        this.num = num;
    }

    public int getNum()
    {
        return num;
    }
}

3.单例设计模式内存分析：

4.另一种表现模式：延迟加载形式，面试这个问得比较多。（懒汉式：用的时候再做）

class Single2    //类加载进来，没有对象，只有调用了getInstance方法时，才会创建对象。
                                //称为延迟加载形式
{
    private Single2(){};
    private static Single2 s  = null;
    private static Single2 getInstance()
    {
        if(s == null)
            s = new Single2();
        return s;
    }
}

5.注意：

面试时，问懒汉式比较多，知识点较多。

开发时，用饿汉式：
1.因为单例这个类就是要用对象，所以先加载后加载没区别。
2.懒汉式存在问题：如果被多线程并发访问时，可能保证不了对象的唯一性，有安全隐患。想保证要改，改了之后效率也降低了。