单例设计模式
- 正常情况下一个类可以创建多个对象
public static void main(String[] args) {
// 正常情况下一个类可以创建多个对象
Person p1 = new Person();
Person p2 = new Person();
Person p3 = new Person();
}
- 如果说有时一个对象就能搞定的事情 , 非要创建多个对象 , 浪费内存!!!
1 单例设计模式的作用
-
单例模式，是一种常用的软件设计模式。通过单例模式可以保证项目中，应用该模式的这个类只有一个实例。
即一个类只有一个对象实例。
-
好处 ：可以节省内存，共享数据
2 单例设计模式实现步骤
- 将构造方法私有化，使其不能在类的外部通过new关键字实例化该类对象。
- 在该类内部产生一个唯一的实例化对象，并且将其封装为private static 类型的成员变量。
- 定义一个静态方法返回这个唯一对象。
3 单例设计模式的类型
根据创建对象的时机单例设计模式又分为以下两种:
-
饿汉单例设计模式
-
懒汉单例设计模式
=============================================================================================
4 饿汉单例设计模式
-
饿汉单例设计模式就是使用类的时候已经将对象创建完毕
不管以后会不会使用到该实例化对象，先创建了再说。很着急的样子，故被称为“饿汉模式”。
-
代码如下：
public class Singleton { // 1.将构造方法私有化，使其不能在类的外部通过new关键字实例化该类对象。 private Singleton() {} // 2.在该类内部产生一个唯一的实例化对象，并且将其封装为private static 类型的成员变量。 private static final Singleton instance = new Singleton(); // 3.定义一个静态方法返回这个唯一对象。 public static Singleton getInstance() { return instance; } } -
需求：定义一个皇帝类，要求对象只能存在一个。
package com.itheima.singledesign; /* 需求 : 使用单例模式(饿汉式) , 要求此类只能有一个对象 步骤 : 1. 将构造方法私有化，使其不能在类的外部通过new关键字实例化该类对象。 2. 在该类内部产生一个唯一的实例化对象，并且将其封装为private static 类型的成员变量。 3. 定义一个静态方法返回这个唯一对象。 */ public class King { // 1. 将构造方法私有化，使其不能在类的外部通过new关键字实例化该类对象。 private King(){ } // 2. 在该类内部产生一个唯一的实例化对象，并且将其封装为private static 类型的成员变量。 private static final King KING = new King(); // 3. 定义一个静态方法返回这个唯一对象。 public static King getInstance(){ return KING; } }
=============================================================================================
5 懒汉单例设计模式
-
懒汉单例设计模式就是调用getInstance()方法时对象才被创建
也就是说先不急着实例化出对象，等要用的时候才实例化出对象。不着急，故称为“懒汉模式”。
代码如下：
public class Singleton {
// 1.将构造方法私有化，使其不能在类的外部通过new关键字实例化该类对象。
private Singleton() {}
// 2.在该类内部产生一个唯一的实例化对象，并且将其封装为private static类型的成员变量。
private static Singleton instance;
// 3.定义一个静态方法返回这个唯一对象。要用的时候才例化出对象
public static synchronized Singleton getInstance() {
if(instance == null) {
instance = new Singleton();
}
return instance;
}
}
-
注意 ：
- 懒汉单例设计模式在多线程环境下可能会实例化出多个对象，不能保证单例的状态，所以加上关键字：synchronized，保证其同步安全。
-
需求：使用懒汉单例 ，改写皇帝类的单例模式
package com.itheima.singledesign; /* 需求 : 使用单例模式(懒汉式) , 要求此类只能有一个对象 步骤 : 1. 将构造方法私有化，使其不能在类的外部通过new关键字实例化该类对象。 2. 在该类内部定义一个private static修饰的成员变量 . 此变量不需要赋值 3. 定义一个静态方法返回这个唯一对象。 此方法需要加上synchronized关键字保证在多线程中也只有一个实例对象 */ public class King2 { // 1. 将构造方法私有化，使其不能在类的外部通过new关键字实例化该类对象。 private King2() { } // 2. 在该类内部定义一个private static修饰的成员变量 . 此变量不需要赋值 private static King2 king2; // 3. 定义一个静态方法返回这个唯一对象。 此方法需要加上synchronized关键字保证在多线程中也只有一个实例对象 public static synchronized King2 getInstance() { if (king2 == null) { king2 = new King2(); } return king2; } }
知识小结
- 单例模式可以保证系统中一个类只有一个对象实例。
- 实现单例模式的步骤：
- 将构造方法私有化，使其不能在类的外部通过new关键字实例化该类对象。
- 在该类内部产生一个唯一的实例化对象，并且将其封装为private static类型的成员变量。
- 定义一个静态方法返回这个唯一对象。
多例设计模式
学习目标
- 能使用多例设计模式设计代码
内容讲解
1 多例设计模式的作用
-
多例模式，是一种常用的设计模式之一。通过多例模式可以保证项目中，应用该模式的类有固定数量的实例。
多例类要自我创建并管理自己的实例，还要向外界提供获取本类实例的方法。
-
使用场景：线程池
线程池 = Executors.newFixedThreadPool(3);
2.实现步骤
1.创建一个类, 将构造方法私有化，使其不能在类的外部通过new关键字实例化该类对象。
2.在类中定义该类被创建对象的总数量
3.在类中定义存放类实例的list集合
4.在类中提供静态代码块,在静态代码块中创建类的实例
5.提供获取类实例的静态方法
3.实现代码
-
某一个学科有固定3位老师，年级中上该课程的老师就是这三位老师其中一位
要求使用多例模式 ,每次获取的都是这三位老师其中一位
package com.itheima.moreinstance_demo;
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 int maxCount = 3;
// 3.在类中定义存放类实例的list集合
private static ArrayList<Teacher> list = new ArrayList<>();// {teacher1 , teacher2 , teacher3}
// 4.在类中提供静态代码块,在静态代码块中创建类的实例
static {
for (int i = 0; i < maxCount; i++) {
list.add(new Teacher());
}
}
// 5.提供获取类实例的静态方法
public static Teacher getInstance() {
int index = new Random().nextInt(3);// [0 - 2]
return list.get(index);
}
}
4 小结
-
多例模式作用 : 可以保证项目中一个类有固定个数的实例, 在实现需求的基础上, 能够提高实例的复用性.
实现多例模式的步骤 ：
- 创建一个类, 将构造方法私有化，使其不能在类的外部通过new关键字实例化该类对象。
- 在类中定义该类被创建的总数量
- 在类中定义存放类实例的list集合
- 在类中提供静态代码块,在静态代码块中创建类的实例
- 提供获取类实例的静态方法
工厂设计模式
学习目标
- 能够使用工厂设计模式设计代码
内容讲解
1 概述
- 工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。之前我们创建类对象时, 都是使用 new 对象的形式创建, 除new 对象方式以外, 工厂模式也可以创建对象.
2 作用
- 解决类与类之间的耦合问题
3案例实践
- 需求：定义汽车工厂类，生产各种品牌的车
- 实现步骤
- 编写一个Car接口, 提供run方法
- 编写一个Falali类实现Car接口,重写run方法
- 编写一个Benchi类实现Car接口,重写run方法
- 提供一个CarFactory(汽车工厂),用于生产汽车对象
- 定义CarFactoryTest测试汽车工厂
实现代码
package com.itheima.factorydesign_demo;
/*
- 需求：定义汽车工厂类，生产各种品牌的车
- 实现步骤
- 编写一个Car接口, 提供run方法
- 编写一个Falali类实现Car接口,重写run方法
- 编写一个Benchi类实现Car接口
=============================================
- 提供一个CarFactory(汽车工厂),用于生产汽车对象
- 定义CarFactoryTest测试汽车工厂
*/
public class CarTest {
public static void main(String[] args) {
Car benchi = CarFactory.getInstance(Brand.BENCHI);
System.out.println(benchi);
}
}
// 汽车接口
interface Car {
public abstract void run();
}
// 编写一个Falali类实现Car接口,重写run方法
class Falali implements Car {
public Falali() {
}
@Override
public void run() {
System.out.println("法拉利破百需要3秒...");
}
}
// 编写一个Benchi类实现Car接口
class Benchi implements Car {
@Override
public void run() {
System.out.println("奔驰破百需要5秒...");
}
}
// 汽车品牌枚举
enum Brand {
BENCHI, FALALI, BAOMA, BINLI, AODI;
}
// 提供一个CarFactory(汽车工厂),用于生产汽车对象
class CarFactory {
private CarFactory() {
}
public static Car getInstance(Brand brand) {
switch (brand) {
case FALALI:
return new Falali();
case BENCHI:
return new Benchi();
default:
return null;
}
}
}
提供一个CarFactory(汽车工厂),用于生产汽车对象
//class CarFactory{
// private CarFactory(){}
//
// public static Car getInstance(String brand) {
// if(brand.equals("Falali")){
// return new Falali(10);
// }else if(brand.equals("Benchi")) {
// return new Benchi();
// }else {
// return null;
// }
// }
//}
知识小结
- 工厂模式的存在可以改变创建对象的方式,降低类与类之间的耦合问题.