设计模式--单例模式

什么是设计模式？

设计模式是静态方法和属性的经典使用
设计模式是在大量的实践中总结和理论化之后的优选代码结构，编程风格，以及解决问题的思考方式。设计模式就像是游戏攻略，不同的游戏使用不同的攻略，免得自己再思考和摸索。

什么是单例模式？

单例模式可以理解为只有一个实例对象的设计模式
简单来说就是采取一定的方法保证在整个的软件中对每个类只能存在一个对象实例的约束，只提供一个取得其对象实例的方法。

单例模式懒汉式的步骤：
1. 构造器私有化
2. 类的内部创建对象
3. 向外暴露一个静态的公共方法

单例模式饿汉式

所谓饿汉式就是在上诉单例模式的基础上，实例化对象的时间非常早。在还没有使用的时候就已经创建好了。

代码实现-步骤分析：

1. 创建一个类
2. 将构造器私有化

原因：为了不让别人随便创建对象

3. 在类的内部创建对象并且私有化

原因：当构造器私有化之后，在别的类就无法创建对象了，所以得自己创建一个唯一的对象，这才是单例模式。私有化是为了不让别人随便调这个对象。而且一定是static修饰的，这样才能再加载类的时候就把这个对象创建好，这也是饿汉式的精髓

4. 向外暴露一个静态的公共方法

原因：得让别人有一个获取到这个唯一对象的方法，而且也必须是静态的方法，不然别人创建不了对象无法调用这个方法

代码演示:

public class Singletest {
    public static void main(String[] args) {
        //5.创建一个引用指向唯一的对象
        girls xhh = girls.getGirls();
        System.out.println(xhh.name);
        //6.再创建一个引用指向那个对象看看是不是同一个对象
        girls xhh2 = girls.getGirls();
        System.out.println(xhh == xhh2);
    }
}
class girls{
    //1.随便定义一个属性用于测试
    static String name;
    //2.将构造器私有化,让别人无法创建此类对象
    private girls(String name) {
        this.name = name;
    }
    //3.自己创建一个对象，且用static修饰，让在加载类的时候就实例化这个唯一的对象
    static girls xh = new girls("小花");

    //4.提供一个获取上面这个唯一对象的方法，用static修饰，不然别人无法使用这个方法
    public static girls getGirls(){
        return xh;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

根据第6步的测试结果可以看到,不管获取多少次,都是指向同一个对象,并没有创建一个新的对象.只可以让多个引用都指向它(单例模式的意义)

饿汉式的理解:
比如我们先不获取xh这个对象,先输出一下这个类的属性.然后后面再获取xh这个对象

 System.out.println(girls.name);
 ...
 girls xhh = girls.getGirls();
 
1
2
3
4

那么其实在执行girls xhh = girls.getGirls();这个语句之前xh这个对象就已经创建好了,因为在girls类中创建对象是static修饰的. 这也就是还没用它,它就存在了,非常着急.所以叫饿汉式.所以饿汉式可能会存在浪费内存的可能性,所以创建了另一种单例模式:懒汉式

单例模式懒汉式

所谓懒汉式就是只有当别人明确表示要调用你这个类的中唯一对象时,才去创建这个对象再提供给他.
代码实现-步骤分析：

1. 创建一个类
2. 将构造器私有化
3. 定义一个类的引用但是不实例化对象

这里比较关键,这里只有一个引用但是没有实例化对象,所以此时这个引用是null.就算加载了这个类也不会浪费内存创建对象

4. 创建获取唯一对象的方法

上面说到只有一个引用,所以此时还没有对象可以返回给他.所以使用if判断如果上面的引用是null就创建一个对象地址给到上面的引用.如果不是null就直接返回上面的引用

代码实现:

public class Singletest {
    public static void main(String[] args) {
        //5.创建一个引用指向唯一的对象
        girls xhh = girls.getGirls();
        System.out.println(xhh.name);
        //6.再创建一个引用指向那个对象看看是不是同一个对象
        girls xhh2 = girls.getGirls();
        System.out.println(xhh == xhh2);
    }
}
class girls{
    //1.随便定义一个属性用于测试
    static String name;
    //2.将构造器私有化,让别人无法创建此类对象
    private girls(String name) {
        this.name = name;
    }
    //3.自己创建一个对象，且用static修饰,但是先不实例化对象
    static girls xh;

    //4.提供一个获取上面这个唯一对象的方法，如果xh是null就实例化对象
    public static girls getGirls(){
        if (xh == null){
            xh = new girls("小红");
        }
        return xh;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

饿汉式和懒汉式的区别

1. 创建对象的时机不同:饿汉式在类加载的时候就创建了对象实例,懒汉式只有在使用时才创建
2. 饿汉式没有线程安全问题,懒汉式有线程安全问题(后面再说)’
3. 饿汉式有浪费资源的可能,懒汉式没有

---