单例模式和多例模式和工厂模式

1单例设计模式

学习目标

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

内容讲解

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

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

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

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.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;
}

}

- ##### 注意 ：- 懒汉单例设计模式在多线程环境下可能会实例化出多个对象，不能保证单例的状态，所以加上关键字：synchronized，保证其同步安全。- 需求：使用懒汉单例 ，改写皇帝类的单例模式```java

知识小结

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

• 实现单例模式的步骤：

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

2 多例设计模式

学习目标

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

内容讲解

2.1 多例设计模式的作用

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

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

• 使用场景：线程池

  线程池 = Executors.newFixedThreadPool(3);
  

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()));}
}

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

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 {@Overridepublic void run() {System.out.println("法拉利3秒破百...");}
}//  编写一个Benchi类实现Car接口
class Benchi implements Car {
//    public Benchi(int price) {
//
//    }@Overridepublic 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
//    }
//}

知识小结

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