java单例模式

单例(单个的实例)
1．所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法

2．单例模式有两种方式:

1)饿汉式：即类加载就会创建对象，可能还没有用到对象就创建好了。可能导致资源浪费 

2)懒汉式：只有用户使用getInstance()时，才返回对象，后面再次调用时，会返回上次创建的对象

1）饿汉式

public class SingleTon01 {
    public static void main(String[] args) {
        //通过方法获取对象
        GirlFriend instance1 = GirlFriend.getInstance();
//        System.out.println(instance1);//重写toString方法后，打印对象会默认调用toString()
        System.out.println(instance1.toString());
        GirlFriend instance2 = GirlFriend.getInstance();
        System.out.println(instance2.toString());
        System.out.println(instance1==instance2);//true 说明只能创建一个GirlFriend对象
    }

}
class GirlFriend{
    private String name;
    //保障只能创建一个GirlFriend对象
    //饿汉式单例模式
    //1.private构造器私有化
    //2.在类的内部直接创建
    //3.提供一个公共的static方法，返回gf对象
    private static GirlFriend gf = new GirlFriend("xxx");
    //为了能够在静态方法中，返回gf对象，需要将其修饰为static
    private GirlFriend(String name) {
        this.name = name;
    }
    //为了保证不用创建对象就能调用方法，所以用static修饰
    public static GirlFriend getInstance(){
        return gf;
    }

    @Override
    public String toString() {
        return "GirlFriend{" +
                "name='" + name + '\'' +
                '}';
    }
}

2）懒汉式

/*  懒汉式单例模式
*   只有用户使用getInstance()时，才返回cat对象，后面再次调用时，会返回上次创建的cat对象
**/
public class SingleTon02 {
    public static void main(String[] args) {
//        System.out.println(Cat.n1);//main方法只有这一句情况下，这句话调用了类的属性，类已经被加载，但是只输出了999 说明对象没有被创建
        Cat instance1 = Cat.getInstance();
        System.out.println(instance1);
        //再次调用
        Cat instance2 = Cat.getInstance();
        System.out.println(instance2);
        System.out.println(instance1 == instance2);//true 说明只创建了一个对象
    }
}
class Cat{
    private String name;
        //步骤
    public static int n1 = 999;
        //1.仍然构造器私有化
    private Cat(String name) {
        System.out.println("构造器被调用");
        this.name = name;
    }
        //2.定义一个静态属性对象
    private static Cat cat;
        //3.提供一个public static方法，可以返回一个Cat对象
    public static Cat getInstance(){
        if(cat == null){
            cat = new Cat("花花");
        }
        return cat;
    }

    @Override
    public String toString() {
        return "Cat{" +
                "name='" + name + '\'' +
                '}';
    }
}

总结：

1．二者最主要的区别在于创建对象的时机不同:饿汉式是在类加载就创建了对象实例,而懒汉式是在使用时才创建。
2、饿汉式不存在线程安全问题，懒汉式存在线程安全问题。(后面我学习线程后，再总结)
3．饿汉式存在浪费资源的可能。因为如果程序员一个对象实例都没有使用，那么饿汉式创建的对象就浪费了，懒汉式是使用时才创建，就不存在这个问题。
4.在我们javaSE标准类中，java.lang.Runtime就是经典的单例模式（而且是饿汉式）。