Singleton mode (hungry and lazy)

Single case Pattern

        The so-called singleton design pattern , Is to take certain methods to ensure that in the whole software system , There can only be one object instance for a class , And this class only provides a method to get its object instance

        Singleton mode has two ways ： Hungry Chinese style Slacker type

step [ The singleton pattern - Hungry Chinese style ]

        1. Privatize the constructor

        2. Build directly inside the class

        3. Provide a public static Method , Returns the object

public class Ch01 {
    public static void main(String[] args) {
        GirlFriend instance1 = GirlFriend.getInstance();
        GirlFriend instance2 = GirlFriend.getInstance();
        System.out.println(instance1);
        System.out.println(instance1==instance2);
    }
}
class GirlFriend{
    private String name;
    private static GirlFriend girlFriend=new GirlFriend(" Safflower ");
    private GirlFriend(String name){
        this.name=name;
    }
    public static GirlFriend getInstance(){
        return girlFriend;
    }

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

Running results

---

step [ Single case Pattern - Slacker type ]

        1. Privatize the constructor

        2. Build directly inside the class

        3. Provide a public static Method , Returns the object

        4. Slacker type , Only when the user uses getInstance when , To return the object , When called again later , The last called object will be returned

        So as to ensure the singleton

public class Ch02 {
    public static void main(String[] args) {
        System.out.println(Cat.age);
        System.out.println(Cat.getInstance());
        System.out.println(Cat.getInstance());
    }
}
class Cat{
    public static int age=2;
    private String name;
    private static Cat cat;
    private Cat(String name){
        System.out.println(" Invoking Constructors ");
        this.name=name;
    }
    public static Cat getInstance(){
        if(cat==null){
            cat=new Cat(" Cutie ");
        }
        return cat;
    }

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

Running results

---

  The difference between the hungry and the lazy

1. The main difference between the two is the timing of creating objects ： Hungry Chinese style is to create an object instance when the class is loaded , Lazy style is created when used

2. There is no thread safety problem in starving Han style , Lazy has thread safety issues , It will be improved after the thread

3. There is the possibility of wasting resources . Because if a programmer doesn't use an object instance , Then the objects created in a hungry way are wasted , Lazy is created when used , There is no such thing

4. In us javaSE Standard class ,java.lang.Runtime It's the classic singleton pattern