非零基础自学Java (老师：韩顺平) 第10章 面向对象编程(高级部分) 10.4 单例设计模式

非零基础自学Java (老师：韩顺平)

✈【【零基础 快速学Java】韩顺平 零基础30天学会Java】

第10章 面向对象编程(高级部分)

10.4 单例设计模式

10.4.1 什么是设计模式

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

10.4.2 什么是单例模式

【单例[单个的实例]】

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

单例模式有两种方式：

• 饿汉式
• 懒汉式

10.4.3 单例模式应用实例

步骤：

1. 构造器私有化，防止直接new
2. 类的内部创建对象
3. 向外暴露一个静态的公共方法

举个栗子

【饿汉式】

package com.dingjiaxiong.single_;

/**
 * ClassName: SingleTon01
 * date: 2022/9/3 17:44
 * 【饿汉式】
 * @author DingJiaxiong
 */

public class SingleTon01 {
    public static void main(String[] args) {

        //通过方法获取对象
        GirlFriend instance = GirlFriend.getInstance();
        System.out.println(instance);

        GirlFriend instance2 = GirlFriend.getInstance();
        System.out.println(instance2);

        System.out.println(instance == instance2);
        System.out.println(GirlFriend.n1);

    }
}

class GirlFriend{
    private String name;
    public static int n1 = 100;

    private static GirlFriend girlFriend = new GirlFriend("小红红");

    private GirlFriend(String name){
        System.out.println("构造器被调用");
        this.name = name;
    }

    public static GirlFriend getInstance(){
        return girlFriend;
    }

    @Override
    public String toString() {
        return "GirlFriend{" +
                "name='" + name + '\'' +
                '}';
    }
}
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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

运行结果

【懒汉式】

package com.dingjiaxiong.single_;

import java.io.PipedReader;
import java.util.concurrent.CopyOnWriteArrayList;

/**
 * ClassName: SingleTon02
 * date: 2022/9/3 17:54
 *
 * @author DingJiaxiong
 */

public class SingleTon02 {
    public static void main(String[] args) {
        Cat instance = Cat.getInstance();
        System.out.println(instance);

        Cat instance2 = Cat.getInstance();
        System.out.println(instance2);

        System.out.println(instance == instance2);
    }
}

//希望在程序运行过程中，只能创建一个Cat对象

class Cat{
    private String name;
    public static int n1 = 999;
    private static Cat cat ; //默认是null

    private Cat(String name){
        System.out.println("构造器被调用");
        this.name = name;
    }

    public static Cat getInstance(){
        if (cat == null){
            cat = new Cat("小可爱");
        }
        return cat;
    }

    @Override
    public String toString() {
        return "Cat{" +
                "name='" + name + '\'' +
                '}';
    }
}
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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

运行结果

10.4.4 饿汉式 VS 懒汉式

• 二者最主要的区别在于创建对象的时机不同:

  饿汉式是在类加载就创建了对象实例,而懒汉式是在使用时才创建。

• 饿汉式不存在线程安全问题，懒汉式存在线程安全问题。

• 饿汉式存在浪费资源的可能。因为如果程序员一个对象实例都没有使用，那么饿汉式创建的对象就浪费了，懒汉式是使用时才创建，就不存在这个问题。

• 在javaSE标准类中，java.lang.Runtime就是经典的单例模式。