单例设计模式

单例的要求：保证一个类在程序中只有一个对象。

如何保证对象的唯一性：

1.不允许其它程序用new创建该对象

2.在该类创建一个本类实例

3.对外提供一个方法让其他程序可以获取该对象

步骤：

1.私有化该类的的构造函数

2.通过new在本类中创建一个本类对象

3.定义了一个公有的方法，将创建的对象返回

package gt;

/**
 * Created by Cronous on 2017/10/29.
 * 单例设计模式
 */
public class day01 {

    public static void main(String[] args){
        Single s = Single.getInstance();
        System.out.println("s=" + s);
    }
}

class Single{
    //1.自己内部创建对象，因为返回方法是静态所以需要静态修饰
    private static Single s = new Single();
    //2.私有化构造方法
    private Single(){}
    //3.创建公共的内部函数，new对象并返回对象
    //4.注意这里不能创建对象，所以需要加上static修饰符
    public static Single getInstance() {
         return s;
    }
}

下面看一个例子：

package gt;

/**
 * Created by Cronous on 2017/10/29.
 * 单例设计模式
 */
public class day01 {

    public static void main(String[] args){
        Single s1 = Single.getInstance();
        Single s2 = Single.getInstance();
        System.out.println("s1 == s2 ?" + (s1 == s2));
        s1.setInt(5);
        System.out.println("i= " + s2.getInt());
    }
}

class Single{
    private int i = 1;
    //自己内部创建对象，因为返回方法是静态所以需要静态修饰
    private static Single s = new Single();
    //2.私有化构造方法
    private Single(){}
    //3.创建公共的内部函数，new对象并返回对象
    //4.注意这里不能创建对象，所以需要加上static修饰符
    public static Single getInstance() {
         return s;
    }

    public void setInt(int i){
        this.i = i;
    }
    public int getInt(){
        return i;
    }
}

这里我们得到两个实例，比较一下是否是同一个实例，并且以第一个实例设置 i 的值，

之后通过第二个实例获取，观察 i 的唯一性，如果唯一，s1 s2 引用的就是唯一实例。

控制台结果如下：

s1 == s2 ?true
i= 5

结果论证成功。

单例的另外一种表现形式：懒汉式和饿汉式的区别

上面的为饿汉式，类一加载对象就存在了

我们看下面的懒汉式：

class Single{
    private int i = 1;
    //自己内部创建对象，因为返回方法是静态所以需要静态修饰
    private static Single s = null;
    //2.私有化构造方法
    private Single(){}
    //3.创建公共的内部函数，new对象并返回对象,这里懒汉式先判断对象是否存在
    public static Single getInstance() {
        if(s == null){
            s = new Single();
        }
        return s;
    }
    public void setInt(int i){
        this.i = i;
    }
    public int getInt(){
        return i;
    }
}

懒汉式也就是延时加载

真正开发其实饿汉式用的较多