单例模式和多例模式和工厂模式_java单例和多例的使用场景

1单例设计模式

学习目标

• 能够使用单例设计模式设计代码

内容讲解

• 正常情况下一个类可以创建多个对象

public static void main(String[] args) {
	// 正常情况下一个类可以创建多个对象
	Person p1 = new Person();
	Person p2 = new Person();
	Person p3 = new Person();
}
1
2
3
4
5
6

• 如果说有时一个对象就能搞定的事情 , 非要创建多个对象 , 浪费内存!!!

1.1 单例设计模式的作用

• 单例模式，是一种常用的软件设计模式。通过单例模式可以保证项目中，应用该模式的这个类只有一个实例。

  即一个类只有一个对象实例。

• 好处 ：可以节省内存，共享数据

1.2 单例设计模式实现步骤

1. 将构造方法私有化，使其不能在类的外部通过new关键字实例化该类对象。
2. 在该类内部产生一个唯一的实例化对象，并且将其封装为private static 类型的成员变量。
3. 定义一个静态方法返回这个唯一对象。

1.3 单例设计模式的类型

根据创建对象的时机单例设计模式又分为以下两种:

1. 饿汉单例设计模式

2. 懒汉单例设计模式

=============================================================================================

1.4 饿汉单例设计模式

• 饿汉单例设计模式就是使用类的时候已经将对象创建完毕

  不管以后会不会使用到该实例化对象，先创建了再说。很着急的样子，故被称为“饿汉模式”。

• 代码如下：

  public class Singleton {
      // 1.将构造方法私有化，使其不能在类的外部通过new关键字实例化该类对象。
      private Singleton() {}
  
      // 2.在该类内部产生一个唯一的实例化对象，并且将其封装为private static 类型的成员变量。
      private static Singleton instance = new Singleton();
      
      // 3.定义一个静态方法返回这个唯一对象。
      public static Singleton getInstance() {
          return instance;
      }
  }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12

• 需求：定义一个皇帝类，要求对象只能存在一个。

  
  1

=============================================================================================

1.5 懒汉单例设计模式

• 懒汉单例设计模式就是调用getInstance()方法时对象才被创建

  也就是说先不急着实例化出对象，等要用的时候才实例化出对象。不着急，故称为“懒汉模式”。

  代码如下：

public class Singleton {

// 2.在该类内部产生一个唯一的实例化对象，并且将其封装为private static类型的成员变量。
private static Singleton instance;// 0x001

// 1.将构造方法私有化，使其不能在类的外部通过new关键字实例化该类对象。
private Singleton() {}

// 3.定义一个静态方法返回这个唯一对象。要用的时候才例化出对象

public static synchronized Singleton getInstance() {
    if(instance == null) {
        instance = new Singleton();// 0x001
    }
    return instance;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

}

- ##### 注意 ：

- 懒汉单例设计模式在多线程环境下可能会实例化出多个对象，不能保证单例的状态，所以加上关键字：synchronized，保证其同步安全。



- 需求：使用懒汉单例 ，改写皇帝类的单例模式

```java

1
2
3
4
5
6
7
8
9
10
11

知识小结

• 单例模式可以保证系统中一个类只有一个对象实例。

• 实现单例模式的步骤：

  • 将构造方法私有化，使其不能在类的外部通过new关键字实例化该类对象。
  • 在该类内部产生一个唯一的实例化对象，并且将其封装为private static类型的成员变量。
  • 定义一个静态方法返回这个唯一对象。

2 多例设计模式

学习目标

• 能使用多例设计模式设计代码

内容讲解

2.1 多例设计模式的作用

• 多例模式，是一种常用的设计模式之一。通过多例模式可以保证项目中，应用该模式的类有固定数量的实例。

  多例类要自我创建并管理自己的实例，还要向外界提供获取本类实例的方法。

• 使用场景：线程池

  线程池 = Executors.newFixedThreadPool(3);
  1

2.2.实现步骤

​ 1.创建一个类, 将构造方法私有化，使其不能在类的外部通过new关键字实例化该类对象。

​ 2.在类中定义该类被创建对象的总数量

​ 3.在类中定义存放类实例的list集合

​ 4.在类中提供静态代码块,在静态代码块中创建类的实例

​ 5.提供获取类实例的静态方法

2.3.实现代码

• 某一个学科有固定3位老师，年级中上该课程的老师就是这三位老师其中一位

  要求使用多例模式 ,每次获取的都是这三位老师其中一位

import com.itheima.homework.Test;

import java.time.Period;
import java.util.ArrayList;
import java.util.Random;

/*
    需求  : 某一个学科有固定3位老师，年级中上该课程的老师就是这三位老师其中一位
            要求使用多例模式 ,每次获取的都是这三位老师其中一位

    实现步骤 :
        1.创建一个类,  将构造方法私有化，使其不能在类的外部通过new关键字实例化该类对象。
        2.在类中定义该类被创建对象的总数量
        3.在类中定义存放类实例的list集合
        4.在类中提供静态代码块,在静态代码块中创建类的实例
        5.提供获取类实例的静态方法
 */
public class Teacher {
    //  1.创建一个类,  将构造方法私有化，使其不能在类的外部通过new关键字实例化该类对象。
    private Teacher() {
    }

    // 2.在类中定义该类被创建对象的总数量
    private static final int maxCount = 3;

    // 3.在类中定义存放类实例的list集合
    private static ArrayList<Teacher> list = new ArrayList<>();//{三个老师对象}

    // 4.在类中提供静态代码块,在静态代码块中创建类的实例
    static {
        for (int i = 0; i < maxCount; i++) {
            list.add(new Teacher());
        }
    }

    // 5.提供获取类实例的静态方法
    public static Teacher getInstance() {
        Random r = new Random();
        // 返回集合中的某一个老师
        return list.get(r.nextInt(list.size()));
    }
}

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

import org.junit.Test;

public class TeacherTest {

    @Test
    public void getInstance() {
        for (int i = 0; i < 10; i++) {
            Teacher teacher = Teacher.getInstance();
            System.out.println(teacher);
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13

2.4 小结

• 多例模式作用 : 可以保证项目中一个类有固定个数的实例, 在实现需求的基础上, 能够提高实例的复用性.

  实现多例模式的步骤 ：

  • 创建一个类, 将构造方法私有化，使其不能在类的外部通过new关键字实例化该类对象。
  • 在类中定义该类被创建的总数量
  • 在类中定义存放类实例的list集合
  • 在类中提供静态代码块,在静态代码块中创建类的实例
  • 提供获取类实例的静态方法

3 工厂设计模式

学习目标

• 能够使用工厂设计模式设计代码

内容讲解

3.1 概述

• 工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。之前我们创建类对象时, 都是使用 new 对象的形式创建, 除new 对象方式以外, 工厂模式也可以创建对象.

3.2作用

• 解决类与类之间的耦合问题

3.3案例实践

• 需求：定义汽车工厂类，生产各种品牌的车

• 实现步骤

  • 编写一个Car接口, 提供run方法
  • 编写一个Falali类实现Car接口,重写run方法
  • 编写一个Benchi类实现Car接口
  • 提供一个CarFactory(汽车工厂),用于生产汽车对象
  • 定义CarFactoryTest测试汽车工厂

实现代码

/*
      - 需求：定义汽车工厂类，生产各种品牌的车

      - 实现步骤
          - 编写一个Car接口, 提供run方法
          - 编写一个Falali类实现Car接口,重写run方法
          - 编写一个Benchi类实现Car接口
          - 提供一个CarFactory(汽车工厂),用于生产汽车对象
          - 定义CarFactoryTest测试汽车工厂
 */
public class CarTest {
    public static void main(String[] args) {
        // 多态
        // Car falali = CarFactory.getCar("Falali");

//        Car falali = CarFactory.getCar("fghjkl");
//        falali.run();

        // 调用此方法getCar , 只能传入枚举项
        CarFactory.getCar(CarBrand.FALALI);

    }
}

// 汽车接口
interface Car {
    public abstract void run();// 行驶
}

// 编写一个Falali类实现Car接口,重写run方法
class Falali implements Car {
    @Override
    public void run() {
        System.out.println("法拉利3秒破百...");
    }
}

//  编写一个Benchi类实现Car接口
class Benchi implements Car {
//    public Benchi(int price) {
//
//    }

    @Override
    public void run() {
        System.out.println("法拉利5秒破百...");
    }
}

// 枚举
enum CarBrand {
    // 枚举项 : 每个枚举项都相当于枚举的对象
    BENCHI, FALALI, DAZHONG, LASILAISI, AODI;
}

// 提供一个CarFactory(汽车工厂),用于生产汽车对象
class CarFactory {
    public static Car getCar(CarBrand carBrand) {
        switch (carBrand) {
            case BENCHI:
                return new Benchi();
            case FALALI:
                return new Falali();
            //...
            default:
                return null;
        }
    }
}


 提供一个CarFactory(汽车工厂),用于生产汽车对象
//class CarFactory {
//    public static Car getCar(String carName) {
//        if (carName.equals("Falali")) {
//            return new Falali();
//        } else if (carName.equals("Benchi")) {
//            return new Benchi(1000000);
//        }
//        return null;// 传入的不是Falali或者Benchi 则返回null
//    }
//}


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
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

知识小结

• 工厂模式的存在可以改变创建对象的方式,降低类与类之间的耦合问题.