- 前言
- 一、设计模式介绍
- 二、设计模式有 23 种
- 三、单例模式
- (1) 单例模式有 8 种
- (2) 饿汉式(静态常量)
- (3) 饿汉式(静态代码块)
- (4) 懒汉式(线程不安全)
- (5) 懒汉式(线程安全 - 同步方法)
- (6) 懒汉式(线程安全 - 同步代码块)
- (7) 双重检查(推荐使用)
- (8) 静态内部类【极度推荐】
- (9) 枚举【推荐使用】
- (10) JDK 中 的 Runtime 类就是单例模式
- (11) 单例模式使用在...
- 四、简单工厂设计模式
- (1) 项目介绍
- (2) 传统方式
- (3) 使用简单工厂模式
- 五、工厂方法模式
- 六、抽象工厂模式
- 七、原型模式
每一种设计模式都是基于七大设计原则而存在的。需掌握设计模式七大原则(迪米特法则、里氏替换原则原则、依赖倒置原则、开闭原则、接口隔离原则、单一职责原则、合成复用原则)后再看下面的内容。
① 软件设计模式(Design pattern),又称设计模式,是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性、程序的重用性。
② 设计模式的本质提高软件的维护性,通用性和扩展性,并降低软件的复杂度。
③ 1994 年,Erich Gamma、Richard Helm、Ralph Johnson 和 John Vlissides 四人合著出版了一本名为 Design Patterns - Elements of Reusable Object-Oriented Software(中文译名:设计模式 - 可复用的面向对象软件元素) 的书。该书首次提到了软件开发中的设计模式的概念。
④ 设计模式并不局限于某种语言。Java、php、Python、C++ 等各种编程语言都有设计模式的概念。
上图分类罗列了设计模式的类型和 23 种设计模式的名称。为了板式好看,有些设计模式是横着排版的。
作用:实现在整个软件系统运行过程中,某个类始终永远只能存在一个对象实例。
Demo:
① SqlSessionFactory 是一个可以从中获得 SqlSession 的实例的工厂类。从 SqlSessionFactory 中获取的 SqlSession 提供了在数据库执行 SQL 命令所需的所有方法。SqlSessionFactory 在整个应用运行期间应该一直存在。下图是 MyBatis 官方文档对 SqlSessionFactory 的描述。
② Hibernate 框架的 SessionFactory 充当数据存储源的代理,并负责创建 Session 对象。SessionFactory 并不是轻量级的,一个项目只需要一个 SessionFactory。此时就可使用单例模式。
① 饿汉式(静态常量)
② 饿汉式(静态代码块)
③ 懒汉式(线程不安全)
④ 懒汉式(线程安全,同步方法)
⑤ 懒汉式(线程安全,同步代码块)
⑥ 双重检查
⑦ 静态内部类
⑧ 枚举
public class Singleton01 {
// 所谓饿汉式,Singleton01 一被加载 Singleton01 实例就被创建(有点饥渴)
private static final Singleton01 INSTANCE = new Singleton01();
// 构造方法私有化
private Singleton01() {
}
public static Singleton01 getInstance() {
return INSTANCE;
}
}
总结:① 构造方法私有化(单例模式的作用是:让某个类的实例在整个应用运行过程中永远只有一个。因此不能提供公共的构造方法来实例化对象)
② 在类的内部创建(new)唯一的该类的实例
③ 向外提供一个静态的公共的方法返回该类唯一的实例
所谓饿汉式,就是该类比较饥渴、比较饿。只要 Singleton01 被加载,它的实例就被创建。
饿汉式(静态常量)单例模式的优缺点:
① 优点: 类装载,唯一的对象实例就被创建。避免了线程同步问题。
② 缺点:在类装载的时候就完成实例化,没有实现懒加载(Lazy Load)。如果从始至终从未使用过该实例,则会造成内存浪费。
解释:该方式基于类加载(ClassLoader)机制避免了多线程的同步问题。但 INSTANCE 在类装载时就实例化可能造成内存浪费。在单例模式中,一般是调用 getInstance 方法导致类装载,进而创建唯一的对象实例。但导致类装载的方式不止一种,因此不能确定是否有其他的方式导致类装载。如果有,会导致内存方法。
触发类加载的方式:
① 调用静态成员时(静态常量、静态方法)
② 第一次 new 对象的时候
③ 子类加载会导致父类先被加载
public class Singleton02 {
private static Singleton02 instance;
static { // 在静态代码块中实例化 Singleton02 对象
instance = new Singleton02();
}
// 构造方法私有化
private Singleton02() {
}
public static Singleton02 getInstance() {
return instance;
}
}
说明:该方式和静态常量饿汉式类似。区别是:将类实例化的过程放在了静态代码块中。由于也是在类装载的时候执行静态代码块中的代码,进行实例的创建。所以,可避免线程同步问题(优点),可能造成内存浪费(缺点)。
public class LazySingleton01 {
private static LazySingleton01 instance;
private LazySingleton01() {
}
public static LazySingleton01 getInstance() {
if (instance == null) {
instance = new LazySingleton01();
}
return instance;
}
}
优缺点:
① 优点:相比饿汉式,该方式有懒加载(Lazy Load)的效果,可以避免内存浪费。
② 缺点:可能有线程安全问题。如果在多线程环境下,一个线程进入了 if (instance== null) 判断语句,且还未来得及往下执行。此时另一个线程也进入了 if (instance== null) 判断语句,次时便会产生多个实例,因此也就没有实现单例模式的功能了。
结论:该写法在多线程环境下不可使用,开发中也不这样写。
public class LazySingleton02 {
private static LazySingleton02 instance;
private LazySingleton02() {
}
public static synchronized LazySingleton02 getInstance() {
if (instance == null) {
instance = new LazySingleton02();
}
return instance;
}
}
优缺点:
① 线程安全、和饿汉式比不浪费内存(优点)
② 同步方法效率太低。 每个线程需要获得类实例的时候都得执行 getInstance() 方法,都要执行线程同步操作。线程同步操作(有 synchronized 效率是会降低的)。实际上,实例化对象的代码只需要执行一次即可,之后若想获得该类实例直接 return 即可。
该方式并未解决线程同步问题。
public class LazySingleton03 {
private static LazySingleton03 instance;
private LazySingleton03() {
}
public static LazySingleton03 getInstance() {
if (instance == null) {
// 同步代码块
synchronized (LazySingleton03.class) {
instance = new LazySingleton03();
}
}
return instance;
}
}
【说明】该方式本来是想对【懒汉式(线程安全 - 同步方法)】的代码进行改进,提高其效率。但该写法并不能起到线程同步的作用。假如一个线程进入了 if (instance== null) 判断语句,还未来得及往下执行。此时,另一个线程也进行了 if (instance== null) 判断语句,此时便会产生多个实例(哪就不是单例模式了)
volatile 是 Java 提供的一种轻量级的同步机制。
当多个线程同时访问同一个变量时,若某个线程修改了该变量的值,其他线程能够立即看到该变量被修改的值。
在多线程环境下,某个线程对共享变量的操作(修改)对其他线程是不可见的。Java 提供了 volatile 关键字来保证可见性(当一个变量被 volatile 修饰后,表示线程本地内存无效。当一个线程修改共享变量后,共享变量的值会被立即更新到主内存中。其他线程读取共享变量时,会直接从主内存读取。)
public class DoubleCheckSingleton {
// volatile:假如某个线程修改了 instance 的值,其他线程能够立刻知道
private static volatile DoubleCheckSingleton instance;
private DoubleCheckSingleton() {
}
public static DoubleCheckSingleton getInstance() {
if (instance == null) { // 第一层检查
synchronized (DoubleCheckSingleton.class) {
if (instance == null) { // 第二层检查
instance = new DoubleCheckSingleton();
}
}
}
return instance;
}
}
【优点】
① 线程安全
② 懒加载
③ 实例化代码只执行一次,之后再调用 getInstance 方法的时候,依然会判断 instance 是否为 null。如果不为 null,直接 return 即可
④ 避免反复进行线程同步操作
实际开发和编程中,推荐双重检查的方式实现单例模式。
public class Test {
private static class StaticInner {
private static String name = "顾清兒";
}
public static String getName() {
return StaticInner.name;
}
}
静态内部类特点:以上面的代码为例。① 当 Test 类被装载的时候,StaticInner 类不会被装载。
② 调用 Test 类的 getName 方法(getName 内部使用 StaticInner 静态内部类)会导致 StaticInner 类被装载(只装载一次),类被装载的时候线程是安全的。
下面代码的作用:证明静态内部类的特点
public class Test {
// 当 Test 类被装载的时候,静态代码块的代码会被执行
static {
System.out.println("Test - 静态代码块");
}
static class StaticInner {
static String name = "顾清兒";
static { // 当 StaticInner 被加载的时候,静态代码块的代码会被执行
System.out.println("StaticInner - 静态代码块");
}
}
public static void getName() {
// 使用 StaticInner 里面的 静态属性会导致 StaticInner 类的装载
String goodName = StaticInner.name;
}
}
使用静态内部类的特点编写单例模式。
public class SingletonStaticInner {
private SingletonStaticInner() {
}
private static class StaticInnerClass {
private static final SingletonStaticInner INSTANCE =
new SingletonStaticInner();
}
public static SingletonStaticInner getInstance() {
return StaticInnerClass.INSTANCE;
}
}
【说明】
① 该方式通过类装载机制保证初始化实例时只有一个线程。
② 静态内部类在 SingletonStaticInner 类被装载时不会被装载(静态内部类里面的代码不会执行)
③ 当调用 SingletonStaticInner 类里面的 getInstance 方法后,getInstance 方法内部会使用到静态内部类 StaticInnerClass 里面的静态属性。使用静态内部类里面的静态属性会导致静态内部类的装载,进而导致静态内部类里面的代码被执行,以至于 SingletonStaticInner 被实例化,并赋值给了 INSTANCE 。
④ 类的静态属性只会在第一次装载类的时候初始化(效率高)。此处巧妙地利用 JVM 保证了线程安全,类装载的时候别的线程是无法进入的。
优点:避免线程不安全;利用静态内部类的特点实现延迟加载、避免内存浪费【推荐使用】
public enum SingletonEnum {
INSTANCE; // 默认就是单例的
public void getInstance() {
System.out.println(INSTANCE.hashCode());
}
}
【说明】
① 在此借助 JDK1.5 中添加的枚举类型来实现单例模式。不仅能避免多线程同步问题,而且还能防止反序列化重新创建新的对象的情况。
② Effective Java (书名,见下图)的作者 Josh Bloch 提倡该方式实现单例模式。
① 被设计为单例模式的类的对象在整个应用运行过程中只有一个实例,节省了系统资源。对于一些需要频繁创建和销毁的对象,使用单例模式可以提高性能
② 单例模式使用的场景:
若对象需要被频繁地创建和销毁;
若创建某个对象时需要耗费很多时间和资源(重量级对象),但该对象又经常被使用到;
工具类对象;
频繁访问数据库或文件的对象(eg:数据源、session 工厂等)。
通过一个简单的项目引出简单工厂模式。
编写代码实现【奶茶店项目】功能。
【项目 UML 类图】
【项目代码】
public abstract class MilkTeaAbstract {
private String name = setMilkyTeaName();
public String getName() {
return name;
}
abstract String setMilkyTeaName();
abstract void prepareMaterial();
abstract void make();
abstract void box();
}
public class AppleMilkTea extends MilkTeaAbstract {
@Override
String setMilkyTeaName() {
return "苹果奶茶";
}
@Override
void prepareMaterial() {
System.out.println("prepare material for 【APPLE】 milk tea");
}
@Override
void make() {
System.out.println("make 【APPLE】 milk tea");
}
@Override
void box() {
System.out.println("box 【APPLE】 milk tea");
}
}
public class IcedMilkTea extends MilkTeaAbstract {
@Override
String setMilkyTeaName() {
return "冰冰奶茶";
}
@Override
void prepareMaterial() {
System.out.println("prepare material for 【iced】 milk tea");
}
@Override
void make() {
System.out.println("make 【iced】 milk tea");
}
@Override
void box() {
System.out.println("box 【iced】 milk tea");
}
}
public class PearlMilkTea extends MilkTeaAbstract {
@Override
String setMilkyTeaName() {
return "珍珠奶茶";
}
@Override
void prepareMaterial() {
System.out.println("prepare material for 【pearl】 milk tea");
}
@Override
void make() {
System.out.println("make 【pearl】 milk tea");
}
@Override
void box() {
System.out.println("box 【pearl】 milk tea");
}
}
public class OrderMilkTea {
private String[] milkTeaTypes;
public OrderMilkTea(String[] milkTeaTypes) {
this.milkTeaTypes = milkTeaTypes;
}
public void order() {
boolean noExit = true;
showMilkTeaList();
do {
String milkTeaName = getMilkTeaName();
if (milkTeaName.equals("000")) {
noExit = false;
}
boolean existMilkTea = checkExist(milkTeaName);
if (!existMilkTea && !milkTeaName.equals("000")) {
System.out.println("不存在这种奶茶!!!");
System.out.println("不想买了?输入【000】");
} else if (existMilkTea) {
handleOrderByMilkTeaName(milkTeaName);
System.out.println("不想买了?输入【000】");
} else {
System.out.println("欢迎再次光临!");
}
} while (noExit);
}
private void handleOrderByMilkTeaName(String milkTeaName) {
MilkTeaAbstract milkTeaAbstract = null;
switch (milkTeaName) {
case "珍珠奶茶":
milkTeaAbstract = new PearlMilkTea();
break;
case "冰冰奶茶":
milkTeaAbstract = new IcedMilkTea();
break;
case "苹果奶茶":
milkTeaAbstract = new AppleMilkTea();
break;
}
assert milkTeaAbstract != null;
System.out.println("您点了 ❀ " + milkTeaAbstract.getName() + " ❀ ");
System.out.println("---------------------");
milkTeaAbstract.prepareMaterial();
milkTeaAbstract.make();
milkTeaAbstract.box();
System.out.println("给您!请慢用 ❀");
System.out.println("---------------------");
}
private boolean checkExist(String name) {
for (String n : milkTeaTypes) {
if (n.equals(name)) {
return true;
}
}
return false;
}
private String getMilkTeaName() {
try {
InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader reader = new BufferedReader(isr);
System.out.println("input milk tea name:");
return reader.readLine();
} catch (IOException e) {
e.printStackTrace();
return "";
}
}
private void showMilkTeaList() {
System.out.println("本店现有如下奶茶可供销售");
System.out.println("❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀");
for (String type : milkTeaTypes) {
System.out.println("❀❀❀❀❀❀❀❀❀❀❀ " + type + " ❀❀❀❀❀❀❀❀❀");
}
System.out.println("❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀");
}
}
public class GQEMilkTeaStore {
private static String[] types = new String[]{"苹果奶茶", "珍珠奶茶", "冰冰奶茶"};
private static OrderMilkTea orderMilkTea = new OrderMilkTea(types);
public static void main(String[] args) {
System.out.println("【❀ 顾清兒的奶茶店 ❀】");
orderMilkTea.order();
}
}
【实现截图】
【传统出现的问题分析】
① 这种实现方式违反了设计原则中的 OCP 原则,既开闭原则(对扩展开放,对修改关闭)。
② 若需要给项目扩展新功能,通过增加代码(模块、类)的方式进行扩展,不要修改原有的代码。
在上面的项目中,若想增加一个新的奶茶类型 —— “花儿奶茶”,则需要做如下的改变。
【改进思路分析】把创建 MilkTea 对象的代码封装到一个类中。优点:当有新的 MilkTea 种类时,只需要修改这个类即可(降低耦合)。
public class OrderMilkTea {
private String[] milkTeaTypes;
public OrderMilkTea(String[] milkTeaTypes) {
this.milkTeaTypes = milkTeaTypes;
}
public void order() {
boolean noExit = true;
showMilkTeaList();
do {
String milkTeaName = getMilkTeaName();
if (milkTeaName.equals("000")) {
noExit = false;
}
boolean existMilkTea = checkExist(milkTeaName);
if (!existMilkTea && !milkTeaName.equals("000")) {
System.out.println("不存在这种奶茶!!!");
System.out.println("不想买了?输入【000】");
} else if (existMilkTea) {
handleOrderByMilkTeaName(milkTeaName);
System.out.println("不想买了?输入【000】");
} else {
System.out.println("欢迎再次光临!");
}
} while (noExit);
}
private void handleOrderByMilkTeaName(String milkTeaName) {
// 调用 ”创建奶茶的工厂类“ 创建奶茶
MilkTeaAbstract milkTeaAbstract = MilkTeaFactory.create(milkTeaName);
if (milkTeaAbstract == null) {
System.out.println("没有该奶茶");
return;
}
System.out.println("您点了 ❀ " + milkTeaAbstract.getName() + " ❀ ");
System.out.println("---------------------");
milkTeaAbstract.prepareMaterial();
milkTeaAbstract.make();
milkTeaAbstract.box();
System.out.println("给您!请慢用 ❀");
System.out.println("---------------------");
}
private boolean checkExist(String name) {
for (String n : milkTeaTypes) {
if (n.equals(name)) {
return true;
}
}
return false;
}
private String getMilkTeaName() {
try {
InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader reader = new BufferedReader(isr);
System.out.println("input milk tea name:");
return reader.readLine();
} catch (IOException e) {
e.printStackTrace();
return "";
}
}
private void showMilkTeaList() {
System.out.println("本店现有如下奶茶可供销售");
System.out.println("❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀");
for (String type : milkTeaTypes) {
System.out.println("❀❀❀❀❀❀❀❀❀❀❀ " + type + " ❀❀❀❀❀❀❀❀❀");
}
System.out.println("❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀");
}
}
public class MilkTeaFactory {
public static MilkTeaAbstract create(String milkTeaName) {
MilkTeaAbstract milkTeaAbstract = null;
switch (milkTeaName) {
case "珍珠奶茶":
milkTeaAbstract = new PearlMilkTea();
break;
case "冰冰奶茶":
milkTeaAbstract = new IcedMilkTea();
break;
case "苹果奶茶":
milkTeaAbstract = new AppleMilkTea();
break;
case "花儿奶茶":
milkTeaAbstract = new FlowerMilkTea();
break;
case "西瓜奶茶":
milkTeaAbstract = new WatermelonMilkTea();
break;
}
return milkTeaAbstract;
}
}
【简单工厂模式介绍】
① 简单工厂模式(静态工厂模式)属于创建型模式,是工厂模式的一种。
② 由一个工厂对象决定创建出哪一种类的实例。简单工厂模式是工厂模式家族中最简单实用的模式。
③ 定义了一个创建对象的类,由这个类来封装实例化对象的行为(代码)。
④ 软件开发中,当需要大量地创建某种、某类或者某批对象时,就会使用到工厂模式。
需求:客户在购买奶茶的时候可以选择地区(如韩国的珍珠奶茶,韩国的苹果奶茶,日本的珍珠奶茶,日本的苹果奶茶…)
public abstract class MilkTeaAbstract {
private String name = setMilkyTeaName();
public String getName() {
return name;
}
public abstract String setMilkyTeaName();
public abstract void prepareMaterial();
public abstract void make();
public abstract void box();
}
public class KoreaPearlMilkTea extends MilkTeaAbstract {
@Override
public String setMilkyTeaName() {
return "韩国珍珠奶茶";
}
@Override
public void prepareMaterial() {
System.out.println("prepare material for 【KoreaPearl】 milk tea");
}
@Override
public void make() {
System.out.println("make 【KoreaPearl】 milk tea");
}
@Override
public void box() {
System.out.println("box 【KoreaPearl】 milk tea");
}
}
public class KoreaAppleMilkTea extends MilkTeaAbstract {
@Override
public String setMilkyTeaName() {
return "韩国珍苹果奶茶";
}
@Override
public void prepareMaterial() {
System.out.println("prepare material for 【KoreaApple】 milk tea");
}
@Override
public void make() {
System.out.println("make 【KoreaApple】 milk tea");
}
@Override
public void box() {
System.out.println("box 【KoreaApple】 milk tea");
}
}
public class JapanPearlMilkTea extends MilkTeaAbstract {
@Override
public String setMilkyTeaName() {
return "日本珍珠奶茶";
}
@Override
public void prepareMaterial() {
System.out.println("prepare material for 【JapanPearl】 milk tea");
}
@Override
public void make() {
System.out.println("make 【JapanPearl】 milk tea");
}
@Override
public void box() {
System.out.println("box 【JapanPearl】 milk tea");
}
}
public class JapanAppleMilkTea extends MilkTeaAbstract {
@Override
public String setMilkyTeaName() {
return "日本苹果奶茶";
}
@Override
public void prepareMaterial() {
System.out.println("prepare material for 【JapanApple】 milk tea");
}
@Override
public void make() {
System.out.println("make 【JapanApple】 milk tea");
}
@Override
public void box() {
System.out.println("box 【JapanApple】 milk tea");
}
}
public abstract class OrderMilkTea {
private String[] milkTeaTypes;
public OrderMilkTea(String[] milkTeaTypes) {
this.milkTeaTypes = milkTeaTypes;
}
public abstract MilkTeaAbstract createMilkTea(String milkTeaName);
public void order() {
boolean noExit = true;
showMilkTeaList();
do {
String milkTeaName = getMilkTeaName();
if (milkTeaName.equals("000")) {
noExit = false;
}
boolean existMilkTea = checkExist(milkTeaName);
if (!existMilkTea && !milkTeaName.equals("000")) {
System.out.println("不存在这种奶茶哦!!!");
System.out.println("不想买了?输入【000】");
} else if (existMilkTea) {
handleOrderByMilkTeaName(milkTeaName);
System.out.println("不想买了?输入【000】");
} else {
System.out.println("欢迎再次光临!");
}
} while (noExit);
}
private void handleOrderByMilkTeaName(String milkTeaName) {
// 调用 ”创建奶茶的工厂类“ 创建奶茶
MilkTeaAbstract milkTeaAbstract = createMilkTea(milkTeaName);
if (milkTeaAbstract == null) {
System.out.println("没有该奶茶");
return;
}
System.out.println("您点了 ❀ " + milkTeaAbstract.getName() + " ❀ ");
System.out.println("---------------------");
milkTeaAbstract.prepareMaterial();
milkTeaAbstract.make();
milkTeaAbstract.box();
System.out.println("给您!请慢用 ❀");
System.out.println("---------------------");
}
private boolean checkExist(String name) {
for (String n : milkTeaTypes) {
if (n.equals(name)) {
return true;
}
}
return false;
}
private String getMilkTeaName() {
try {
InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader reader = new BufferedReader(isr);
System.out.println("input milk tea name:");
return reader.readLine();
} catch (IOException e) {
e.printStackTrace();
return "";
}
}
private void showMilkTeaList() {
System.out.println("本店现有如下奶茶可供销售");
System.out.println("❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀");
for (String type : milkTeaTypes) {
System.out.println("❀❀❀❀❀❀❀❀❀❀❀ " + type + " ❀❀❀❀❀❀❀❀❀");
}
System.out.println("❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀");
}
}
public class KoreaOrderMilkTea extends OrderMilkTea {
public KoreaOrderMilkTea(String[] milkTeaTypes) {
super(milkTeaTypes);
}
@Override
public MilkTeaAbstract createMilkTea(String milkTeaName) {
return KoreaMilkTeaFactory.create(milkTeaName);
}
}
public class KoreaMilkTeaFactory {
public static MilkTeaAbstract create(String milkTeaName) {
MilkTeaAbstract milkTeaAbstract = null;
switch (milkTeaName) {
case "韩国珍珠奶茶":
milkTeaAbstract = new KoreaPearlMilkTea();
break;
case "韩国苹果奶茶":
milkTeaAbstract = new KoreaAppleMilkTea();
break;
}
return milkTeaAbstract;
}
}
public class JapanMilkTeaFactory {
public static MilkTeaAbstract create(String milkTeaName) {
MilkTeaAbstract milkTeaAbstract = null;
switch (milkTeaName) {
case "日本珍珠奶茶":
milkTeaAbstract = new JapanPearlMilkTea();
break;
case "日本苹果奶茶":
milkTeaAbstract = new JapanAppleMilkTea();
break;
}
return milkTeaAbstract;
}
}
public class JapanOrderMilkTea extends OrderMilkTea {
public JapanOrderMilkTea(String[] milkTeaTypes) {
super(milkTeaTypes);
}
@Override
public MilkTeaAbstract createMilkTea(String milkTeaName) {
return JapanMilkTeaFactory.create(milkTeaName);
}
}
public class GqMilkTeaStore {
public static void main(String[] args) {
String inputStr = getInputStr();
if (inputStr.equals("日本")) {
JapanOrderMilkTea order =
new JapanOrderMilkTea(new String[]{"日本珍珠奶茶", "日本苹果奶茶"});
order.order();
} else if (inputStr.equals("韩国")) {
KoreaOrderMilkTea order2 =
new KoreaOrderMilkTea(new String[]{"韩国珍珠奶茶", "韩国苹果奶茶"});
order2.order();
}
}
public static String getInputStr() {
try {
InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader reader = new BufferedReader(isr);
System.out.println("input region:");
return reader.readLine();
} catch (IOException e) {
e.printStackTrace();
return "";
}
}
}
工厂方法模式:定义了一个创建对象的抽象方法,由子类决定要实例化的类。工厂方法模式将对象的实例化推迟到子类。
定义一个 interface 用于创建相关或有依赖关系的对象簇,而无需指明具体的类。抽象工厂模式可以将简单工厂模式和工厂方法模式进行整合。从设计层面看,抽象工厂模式就是对简单工厂模式的改进(或者称为进一步的抽象)。将工厂抽象成两层,AbstractFactory(抽象工厂) 和具体实现的工厂子类。设计师可以根据创建的对象类型使用对应的工厂子类。这样将单个的简单工厂类变成了工厂簇,更利于代码的维护和扩展。
public interface AbstractFactory {
MilkTeaAbstract create(String name);
}
public class JapanMilkTeaFactory implements AbstractFactory {
public MilkTeaAbstract create(String milkTeaName) {
MilkTeaAbstract milkTeaAbstract = null;
switch (milkTeaName) {
case "日本珍珠奶茶":
milkTeaAbstract = new JapanPearlMilkTea();
break;
case "日本苹果奶茶":
milkTeaAbstract = new JapanAppleMilkTea();
break;
}
return milkTeaAbstract;
}
}
public class KoreaMilkTeaFactory implements AbstractFactory {
public MilkTeaAbstract create(String milkTeaName) {
MilkTeaAbstract milkTeaAbstract = null;
switch (milkTeaName) {
case "韩国珍珠奶茶":
milkTeaAbstract = new KoreaPearlMilkTea();
break;
case "韩国苹果奶茶":
milkTeaAbstract = new KoreaAppleMilkTea();
break;
}
return milkTeaAbstract;
}
}
工厂设计模式:用于生产对象。
七、原型模式


