设计模式概念

1.设计模式是静态方法和属性的经典使用
2.设计模式是大量时间中总结和理论化后优选的代码结构、编程风格、以及解决问题的思考方式
3.我们可以这样理解，设计模式就像是一个棋谱，遇到不同的棋局，我们就用不同的棋谱，免去我们自己的思考。

单例设计模式

单例模式的概念

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

比如说在软件开发中，有一个类是核心类，它很耗费资源，而且我们只需要一个，这个时候，就可以单例设计模式

2.单例模式有两种方式: 饿汉式 和 懒汉式

饿汉式

只要类加载，就会创建对象
我们可能还没有用到这个对象，但是这个时候对象已经创建好了(饿汉式)
比如说我们调用一个静态属性，这个时候类就会加载，静态属性的初始化就会被执行，但是此时我们还没有用到这个实例，就有可能导致对象创建，但是我们没有用，就会导致资源的浪费

步骤:
1.构造器私有化，防止直接new对象 (构造器如果不私有化，那么我们就可以new多个对象，构造器私有化，可以保证我们只能创建一个对象，因为私有的方法只能在本类中调用)
2.类的内部创建对象(静态的)

3.向外暴露静态的公共方法，来获取这个实例

思考：为什么内部创建的对象要是静态的呢？

就算这个对象不是静态的，我们也可以保证这个类只能有一个对象，但是main方法是静态的，静态方法只能调用静态方法和静态属性，如果说这个对象不是静态的，那么获取这个对象的方法就不能是静态的’，如果想要在main方法中调用这个方法来获取实例，是不行的，我们就需要在外面创建对象，然后才可以调用这个方法，这样就矛盾了，所以说内部创建的对象必须是静态的

 
public class SingleInstance {
    public static void main(String[] args) {
        GirlFriend g1 = GirlFriend.getInstance();
        GirlFriend g2 = GirlFriend.getInstance();
        System.out.println(g1);
        System.out.println(g2);
        System.out.println(g1 == g2);

    }
}
//饿汉式
class GirlFriend{
    //保证这个类只有一个对象
    //所以要保证不能随意创建对象，因此构造器要私有化
    //在类的内部创建好对象
    private static GirlFriend girlFriend=new GirlFriend("lucy");
    private String name;
    private GirlFriend(){

    }
    private GirlFriend(String name){
        this.name=name;
    }

    public static GirlFriend getInstance(){
        return girlFriend;
    }

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

输出结果:

GirlFriend{name='lucy'}
GirlFriend{name='lucy'}
true

这样可以说明，g1和g2其实是同一个对象

懒汉式

我们在使用这个实例的时候，才会创建这个实例

步骤:
1.构造器私有化，防止直接new对象 (构造器如果不私有化，那么我们就可以new多个对象，构造器私有化，可以保证我们只能创建一个对象，因为私有的方法只能在本类中调用)
2.定义一个静态属性对象

3.向外暴露静态的公共方法，可以返回一个对象，如果对象还没有创建，我们就创建一个对象，否则，直接返回一个对象

 
public class SingleInstance1 {
    public static void main(String[] args) {
        Cat cat=Cat.getInstance();
        Cat cat1=Cat.getInstance();
        System.out.println(cat);
        System.out.println(cat1);
    }
}

class Cat{

    private String name;
    private static Cat instance;
    private Cat(){}
    private Cat(String name){this.name=name;}

    public static Cat getInstance(){
        if (instance == null){
            instance=new Cat("小猫");
        }
        return instance;
    }

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

运行结果

Cat{name='小猫'}
Cat{name='小猫'}
true

两者的区别

1.二者主要的区别在于创建对象的时机不同；饿汉式是在类加载就创建了对象实例，而懒汉式是在使用的时候才创建的
2.饿汉式不存在线程安全问题，懒汉式存在线程安全问题
3.饿汉式在类加载的时候就创建了，存在浪费资源的可能，因为如果我们一个对象实例都没有使用，那么饿汉式创建的对象就浪费了，懒汉式是使用的时候创建，就不会存在这个问题
4.javase中，Java.lang.Runtime就算经典的单例模式,饿汉式

public class Runtime {
    private static Runtime currentRuntime = new Runtime();

    /**
     * Returns the runtime object associated with the current Java application.
     * Most of the methods of class <code>Runtime</code> are instance
     * methods and must be invoked with respect to the current runtime object.
     *
     * @return  the <code>Runtime</code> object associated with the current
     *          Java application.
     */
    public static Runtime getRuntime() {
        return currentRuntime;
    }

    /** Don't let anyone else instantiate this class */
    private Runtime() {}