郑州模板网站建设策划公司网络营销推广技术
1单例设计模式
学习目标
- 能够使用单例设计模式设计代码
内容讲解
- 正常情况下一个类可以创建多个对象
public static void main(String[] args) {// 正常情况下一个类可以创建多个对象Person p1 = new Person();Person p2 = new Person();Person p3 = new Person();
}
- 如果说有时一个对象就能搞定的事情 , 非要创建多个对象 , 浪费内存!!!
1.1 单例设计模式的作用
-
单例模式，是一种常用的软件设计模式。通过单例模式可以保证项目中，应用该模式的这个类只有一个实例。
即一个类只有一个对象实例。
-
好处 ：可以节省内存，共享数据
1.2 单例设计模式实现步骤
- 将构造方法私有化，使其不能在类的外部通过new关键字实例化该类对象。
- 在该类内部产生一个唯一的实例化对象，并且将其封装为private static 类型的成员变量。
- 定义一个静态方法返回这个唯一对象。
1.3 单例设计模式的类型
根据创建对象的时机单例设计模式又分为以下两种:
-
饿汉单例设计模式
-
懒汉单例设计模式
=============================================================================================
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
// }
//}知识小结
- 工厂模式的存在可以改变创建对象的方式,降低类与类之间的耦合问题.