第 6 章工厂模式

╰+哭是因爲堅強的太久メ 2022-12-08 01:47 182阅读 0赞

# 第 6 章 工厂模式 #

## 1、简单工厂模式 ##

> **简单工厂模式的实际需求**

看一个披萨的项目：要便于披萨种类的扩展，要便于维护

1.  披萨的种类很多(比如 GreekPizz、CheesePizz 等)
2.  披萨的制作有 prepare、bake、cut、box
3.  完成披萨店订购功能

> **传统方式的代码实现**

类图设计

![image-20200820155952740][]

代码实现

1.  `Pizza` 抽象父类
    
        //将Pizza 类做成抽象
        public abstract class Pizza {
              
        	
        	protected String name; //名字
        	
        	public void setName(String name) {
              
        		this.name = name;
        	}
        	
        	//准备原材料, 不同的披萨不一样，因此，我们做成抽象方法
        	public abstract void prepare();
        
        	// 烘烤
        	public void bake() {
              
        		System.out.println(name + " baking;");
        	}
        
        	// 切割
        	public void cut() {
              
        		System.out.println(name + " cutting;");
        	}
        
        	//打包
        	public void box() {
              
        		System.out.println(name + " boxing;");
        	}
        
        }
2.  `CheesePizza`：奶酪披萨
    
        public class CheesePizza extends Pizza {
              
        	@Override
        	public void prepare() {
              
        		System.out.println("给制作奶酪披萨 准备原材料 ");
        	}
        }
3.  `GreekPizza`：希腊披萨
    
        public class GreekPizza extends Pizza {
              
        	@Override
        	public void prepare() {
              
        		System.out.println("给希腊披萨 准备原材料 ");
        	}
        }
4.  `PepperPizza`：胡椒披萨
    
        public class PepperPizza extends Pizza {
              
        	@Override
        	public void prepare() {
              
        		System.out.println("给胡椒披萨准备原材料 ");
        	}
        }
5.  `OrderPizza`：表示披萨商店，可以根据用户的输入，制作相应的披萨
    
        public class OrderPizza {
              
        
        	// 构造器
        	public OrderPizza() {
              
        		Pizza pizza = null;
        		String orderType; // 订购披萨的类型
        		do {
              
        			orderType = getType();
        			if (orderType.equals("greek")) {
              
        				pizza = new GreekPizza();
        				pizza.setName("希腊披萨");
        			} else if (orderType.equals("cheese")) {
              
        				pizza = new CheesePizza();
        				pizza.setName("奶酪披萨");
        			} else if (orderType.equals("pepper")) {
              
        				pizza = new PepperPizza();
        				pizza.setName("胡椒披萨");
        			} else {
              
        				break;
        			}
        			// 输出pizza 制作过程
        			pizza.prepare();
        			pizza.bake();
        			pizza.cut();
        			pizza.box();
        
        		} while (true);
        	}
        
        	// 写一个方法，可以获取客户希望订购的披萨种类
        	private String getType() {
              
        		try {
              
        			BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
        			System.out.println("input pizza 种类:");
        			String str = strin.readLine();
        			return str;
        		} catch (IOException e) {
              
        			e.printStackTrace();
        			return "";
        		}
        	}
        
        }
6.  `PizzaStore`：相当于客户端，发出订购披萨的请求
    
        //相当于一个客户端，发出订购
        public class PizzaStore {
              
        
        	public static void main(String[] args) {
              
        		 new OrderPizza();
        	}
        
        }
7.  程序运行结果
    
        input pizza 种类:
        greek
        给希腊披萨 准备原材料 
        希腊披萨 baking;
        希腊披萨 cutting;
        希腊披萨 boxing;
        
        input pizza 种类:
        pepper
        给胡椒披萨准备原材料 
        胡椒披萨 baking;
        胡椒披萨 cutting;
        胡椒披萨 boxing;
        
        input pizza 种类:

--------------------

传统方式的优缺点分析

1.  优点是比较好理解，简单易操作。
2.  缺点是违反了设计模式的`ocp`原则，即对扩展开放(提供方)，对修改关闭(使用方)。即当我们给类增加新功能的时候，尽量不修改代码，或者尽可能少修改代码.
3.  比如我们这时要新增加一个`Pizza`的种类(`Pepper`披萨)，我们需要在使用方 `OderPizza` 中添加新的判断条件，违反开闭原则

--------------------

改进思路

1.  分析： 如果说新增 `Pizza` 需要修改代码，这可以接受， 但是如果我们在其它的地方也有创建 `Pizza` 的代码，就意味着，有很多处的代码都需要修改，而且这些创建 `Pizza` 的代码全都是冗余代码。
2.  思路： 把创建`Pizza`对象封装到一个类中，这样我们有新的`Pizza`种类时，只需要修改该类就可， 其它有创建到`Pizza`对象的代码就不需要修改了 --> 简单工厂模式

> **简单工厂模式的代码实现**

简单工厂模式介绍

1.  简单工厂模式是属于创建型模式，是工厂模式的一种。 简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式
2.  简单工厂模式：定义了一个创建对象的类，由这个类来封装实例化对象的行为(代码)
3.  在软件开发中，当我们会用到大量的创建某种、某类或者某批对象时，就会使用到工厂模式

--------------------

类图

![image-20200820214501845][]

--------------------

代码实现

1.  `Pizza` 抽象父类以及 `Pizza` 的具体实现类和上面一样
2.  `SimpleFactory`：工厂类，根据用户输入，制作相应的 `Pizza`，此时 `SimpleFactory` 为提供方
    
        //简单工厂类
        public class SimpleFactory {
              
        
        	// 根据orderType 返回对应的Pizza 对象
        	public Pizza createPizza(String orderType) {
              
        		Pizza pizza = null;
        		System.out.println("使用简单工厂模式");
        		if (orderType.equals("greek")) {
              
        			pizza = new GreekPizza();
        			pizza.setName("希腊披萨");
        		} else if (orderType.equals("cheese")) {
              
        			pizza = new CheesePizza();
        			pizza.setName("奶酪披萨");
        		} else if (orderType.equals("pepper")) {
              
        			pizza = new PepperPizza();
        			pizza.setName("胡椒披萨");
        		}
        		return pizza;
        	}
        
        }
3.  `OrderPizza`：根据用户的输入，调用 `SimpleFactory` 工厂类制作相应的 `Pizza`，`OrderPizza` 为使用方
    
        public class OrderPizza {
              
        
        	// 定义一个简单工厂对象
        	SimpleFactory simpleFactory;
        	Pizza pizza = null;
        
        	// 构造器
        	public OrderPizza(SimpleFactory simpleFactory) {
              
        		setFactory(simpleFactory);
        	}
        
        	public void setFactory(SimpleFactory simpleFactory) {
              
        		String orderType = ""; // 用户输入的
        		this.simpleFactory = simpleFactory; // 设置简单工厂对象
        		do {
              
        			orderType = getType();
        			pizza = this.simpleFactory.createPizza(orderType);
        			// 输出pizza
        			if (pizza != null) {
               // 订购成功
        				pizza.prepare();
        				pizza.bake();
        				pizza.cut();
        				pizza.box();
        				System.out.println();
        			} else {
              
        				System.out.println("订购披萨失败");
        				break;
        			}
        		} while (true);
        	}
        
        	// 写一个方法，可以获取客户希望订购的披萨种类
        	private String getType() {
              
        		try {
              
        			BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
        			System.out.println("input pizza 种类:");
        			String str = strin.readLine();
        			return str;
        		} catch (IOException e) {
              
        			e.printStackTrace();
        			return "";
        		}
        	}
        
        }
4.  `PizzaStore`：相当于客户端，发出订购披萨的请求
    
        //相当于一个客户端，发出订购
        public class PizzaStore {
              
        
        	public static void main(String[] args) {
              
        		// 使用简单工厂模式
        		new OrderPizza(new SimpleFactory());
        		System.out.println("~~退出程序~~");
        	}
        
        }

--------------------

其他说明：简单工厂模式也叫静态工厂模式，很多代码中都将简单工厂中提供示例 `Bean` 的方法声明为静态 `static` 方法，可通过工厂类直接调用

//简单工厂类
    public class SimpleFactory {
        
    
    	// 简单工厂模式 也叫 静态工厂模式
    	public static Pizza createPizza(String orderType) {
        
    		Pizza pizza = null;
    		System.out.println("使用简单工厂模式2");
    		if (orderType.equals("greek")) {
        
    			pizza = new GreekPizza();
    			pizza.setName("希腊披萨");
    		} else if (orderType.equals("cheese")) {
        
    			pizza = new CheesePizza();
    			pizza.setName("奶酪披萨");
    		} else if (orderType.equals("pepper")) {
        
    			pizza = new PepperPizza();
    			pizza.setName("胡椒披萨");
    		}
    		return pizza;
    	}
    
    }

--------------------

简单工厂模式总结：

1.  如果使用传统方法，使用方为 `OrderPizza`，提供方 `Pizza` 及其实现类，这样编写代码使用方和提供方紧紧耦合在一起，但凡需要新增 `Pizza` 的实现类，都需要修改 `OrderPizza` 中的代码，添加新的判断逻辑
2.  为了满足 `OCP` 原则，我们建立简单工厂类 `SimpleFactory`，通过 `SimpleFactory` 作为一个中间者的角色：`SimpleFactory` 向上为 `OrderPizza` 提供相应的 `Pizza`，`SimpleFactory` 向下负责与 `Pizza` 及其实现类打交道，完成 `Pizza` 的生产
3.  我们将生产 `Pizza` 的具体细节放在 `SimpleFactory` 工厂类里面实现，让 `SimpleFactory` 作为 `Pizza` 的提供方，这样新增 `Pizza` 的实现类时，我们只需要修改提供方（`SimpleFactory`）的代码，而无需修改使用方（`OrderPizza`）的代码

## 2、工厂方法模式 ##

> **工厂方法模式的实际需求**

看一个新的需求

披萨项目新的需求： 客户在点披萨时， 可以点不同口味的披萨， 比如北京的奶酪 `pizza`、 北京的胡椒 `pizza` 或者是伦敦的奶酪 `pizza`、 伦敦的胡椒 `pizza`。

--------------------

思路一：简单工厂模式

使用简单工厂模式， 创建不同的简单工厂类， 比如 `BJPizzaSimpleFactory`、`LDPizzaSimpleFactory` 等等。

从当前这个案例来说， 也是可以的， 但是考虑到项目的规模， 以及软件的可维护性、 可扩展性并不是特别好，因为过多的工厂类会导致整个项目类膨胀

--------------------

思路二：使用工厂方法模式

> **工厂方法模式介绍**

1.  工厂方法模式设计方案： 将披萨项目的实例化功能抽象成抽象方法， 在不同的口味点餐子类中具体实现。
2.  工厂方法模式： 定义了一个创建对象的抽象方法， 由子类决定要实例化的类。 工厂方法模式将对象的实例化推迟到子类

> **工厂方法模式应用案例**

项目需求：披萨项目新的需求： 客户在点披萨时， 可以点不同口味的披萨， 比如 北京的奶酪 `pizza`、 北京的胡椒 `pizza` 或者是伦敦的奶酪 `pizza`、 伦敦的胡椒 `pizza`

--------------------

类图

![image-20200820193838764][]

--------------------

代码实现

1.  `Pizza`：抽象父类，和之前的定义一样
    
        //将Pizza 类做成抽象
        public abstract class Pizza {
              
        
        	protected String name; // 名字
        
        	public void setName(String name) {
              
        		this.name = name;
        	}
        
        	// 准备原材料, 不同的披萨不一样，因此，我们做成抽象方法
        	public abstract void prepare();
        
        	// 烘烤
        	public void bake() {
              
        		System.out.println(name + " baking;");
        	}
        
        	// 切割
        	public void cut() {
              
        		System.out.println(name + " cutting;");
        	}
        
        	// 打包
        	public void box() {
              
        		System.out.println(name + " boxing;");
        	}
        
        }
2.  `BJCheesePizza`：北京的奶酪披萨
    
        public class BJCheesePizza extends Pizza {
              
        	@Override
        	public void prepare() {
              
        		setName("北京的奶酪pizza");
        		System.out.println("北京的奶酪pizza 准备原材料");
        	}
        }
3.  `BJPepperPizza`：北京的胡椒披萨
    
        public class BJPepperPizza extends Pizza {
              
        	@Override
        	public void prepare() {
              
        		setName("北京的胡椒pizza");
        		System.out.println("北京的胡椒pizza 准备原材料");
        	}
        }
4.  `LDCheesePizza`：伦敦的奶酪披萨
    
        public class LDCheesePizza extends Pizza {
              
        	@Override
        	public void prepare() {
              
        		setName("伦敦的奶酪pizza");
        		System.out.println("伦敦的奶酪pizza 准备原材料");
        	}
        }
5.  `LDPepperPizza`：伦敦的胡椒披萨
    
        public class LDPepperPizza extends Pizza {
              
        	@Override
        	public void prepare() {
              
        		setName("伦敦的胡椒pizza");
        		System.out.println("伦敦的胡椒pizza 准备原材料");
        	}
        }
6.  `OrderPizza`：含有抽象方法的工厂父类，其抽象方法待子类去实现
    
        public abstract class OrderPizza {
              
        	
        	// 定义一个抽象方法，createPizza , 让各个工厂子类自己实现
        	abstract Pizza createPizza(String orderType);
        
        	// 构造器
        	public OrderPizza() {
              
        		Pizza pizza = null;
        		String orderType; // 订购披萨的类型
        		do {
              
        			orderType = getType();
        			pizza = createPizza(orderType); // 抽象方法，由工厂子类完成
        			// 输出pizza 制作过程
        			pizza.prepare();
        			pizza.bake();
        			pizza.cut();
        			pizza.box();
        			System.out.println();
        		} while (true);
        	}
        
        	// 写一个方法，可以获取客户希望订购的披萨种类
        	private String getType() {
              
        		try {
              
        			BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
        			System.out.println("input pizza 种类:");
        			String str = strin.readLine();
        			return str;
        		} catch (IOException e) {
              
        			e.printStackTrace();
        			return "";
        		}
        	}
        	
        }
7.  `BJOrderPizza`：北京披萨的生产工厂
    
        public class BJOrderPizza extends OrderPizza {
              
        	@Override
        	Pizza createPizza(String orderType) {
              
        		Pizza pizza = null;
        		if (orderType.equals("cheese")) {
              
        			pizza = new BJCheesePizza();
        		} else if (orderType.equals("pepper")) {
              
        			pizza = new BJPepperPizza();
        		}
        		return pizza;
        	}
        }
8.  `LDOrderPizza`：伦敦披萨的生产工厂
    
        public class LDOrderPizza extends OrderPizza {
              
        	@Override
        	Pizza createPizza(String orderType) {
              
        		Pizza pizza = null;
        		if (orderType.equals("cheese")) {
              
        			pizza = new LDCheesePizza();
        		} else if (orderType.equals("pepper")) {
              
        			pizza = new LDPepperPizza();
        		}
        		return pizza;
        	}
        }
9.  `PizzaStore`：相当于客户端，发出订购披萨的请求
    
        public class PizzaStore {
              
        
        	public static void main(String[] args) {
              
        		String loc = "bj"; // 假设这里是用户输入的位置信息
        		if (loc.equals("bj")) {
              
        			// 创建北京口味的各种Pizza
        			new BJOrderPizza();
        		} else {
              
        			// 创建伦敦口味的各种Pizza
        			new LDOrderPizza();
        		}
        	}
        
        }
10. 程序运行结果
    
        input pizza 种类:
        cheese
        北京的奶酪pizza 准备原材料
        北京的奶酪pizza baking;
        北京的奶酪pizza cutting;
        北京的奶酪pizza boxing;
        
        input pizza 种类:
        pepper
        北京的胡椒pizza 准备原材料
        北京的胡椒pizza baking;
        北京的胡椒pizza cutting;
        北京的胡椒pizza boxing;
        
        input pizza 种类:

--------------------

工厂方法模式总结

1.  首先要说明的是，对于此案例，我们也可以采用简单工厂模式来实现，缺点是：对于一个地区的披萨，我们就需要创建一个对应的工厂类，这会造成项目类膨胀；并且生产披萨的代码几乎都是相同的，这就造成披萨工厂类中的代码冗余
2.  对于这种情况，我们可以使用工厂方法模式，将具体的抽象方法声明在父类工厂中，其具体的实现下沉到工厂子类，我们通过工厂子类可以获得所需要的 `Bean`
3.  对于此例，抽象父类 `OrderPizza` 中有一个抽象方法 `abstract Pizza createPizza(String orderType);`，该方法接收 `Pizza` 的类型，并生产指定类型的 `Pizza`；在工厂子类 `BJOrderPizza`，`LDOrderPizza` 中实现了该抽象方法，实现了具体生产 `Pizza` 的逻辑
4.  对于工厂方法模式，抽象工厂父类 `OrderPizza` 为 `Bean` 的使用方，它负责调用工厂子类 `BJOrderPizza`，`LDOrderPizza` 中已重写的抽象方法，获得生产好的 `Pizza`，然后使用该 `Pizza` 实例

--------------------

简单工厂模式与工厂方法模式的对比：

1.  简单工厂模式：工厂类作为 `Bean` 的制造者（提供方），负责与具体的实体类打交道，并负责相应业务逻辑的处理；使用方调用工厂类获取 `Bean`，使用即可，无需关心该 `Bean` 是如何得到的，也无需关心制造此 `Bean` 的具体业务逻辑，满足 `OCP` 原则
2.  工厂方法模式：工厂父类中有一个抽象方法负责制造 `Bean`，该抽象方法会下沉到其子类，由工厂子类实现其具体的业务细节，所以工厂子类是 `Bean` 的提供方，此时的工厂父类消费由工厂子类制造的 `Bean`，为使用方

## 3、抽象工厂模式 ##

> **抽象工厂模式的基本介绍**

1.  抽象工厂模式： 定义了一个 `interface` 用于创建相关或有依赖关系的对象簇， 而无需指明具体的类
2.  抽象工厂模式可以将简单工厂模式和工厂方法模式进行整合。
3.  从设计层面看， 抽象工厂模式就是对简单工厂模式的改进(或者称为进一步的抽象)。
4.  将工厂抽象成两层， `AbsFactory`(抽象工厂) 和 具体实现的工厂子类。 程序员可以根据创建对象类型使用对应的工厂子类。 这样将单个的简单工厂类变成了工厂簇， 更利于代码的维护和扩展。

> **抽象工厂模式的案例**

使用抽象工厂模式来完成披萨项目

--------------------

类图

![image-20200820205058529][]

--------------------

代码实现

1.  `Pizza` 抽象父类以及 `Pizza` 的具体实现类和上面一样
2.  `AbsFactory`：工厂抽象层，定义制造 `Bean` 的抽象方法
    
        //一个抽象工厂模式的抽象层(接口)
        public interface AbsFactory {
              
        	// 让下面的工厂子类来 具体实现
        	public Pizza createPizza(String orderType);
        }
3.  `BJFactory`：北京工厂子类（提供方），负责制造北京各种口味的 `Pizza`
    
        //这是工厂子类
        public class BJFactory implements AbsFactory {
              
        
        	@Override
        	public Pizza createPizza(String orderType) {
              
        		System.out.println("~使用的是抽象工厂模式~");
        		Pizza pizza = null;
        		if (orderType.equals("cheese")) {
              
        			pizza = new BJCheesePizza();
        		} else if (orderType.equals("pepper")) {
              
        			pizza = new BJPepperPizza();
        		}
        		return pizza;
        	}
        
        }
4.  `LDFactory`：伦敦工厂子类（提供方），负责制造伦敦各种口味的 `Pizza`
    
        public class LDFactory implements AbsFactory {
              
        
        	@Override
        	public Pizza createPizza(String orderType) {
              
        		System.out.println("~使用的是抽象工厂模式~");
        		Pizza pizza = null;
        		if (orderType.equals("cheese")) {
              
        			pizza = new LDCheesePizza();
        		} else if (orderType.equals("pepper")) {
              
        			pizza = new LDPepperPizza();
        		}
        		return pizza;
        	}
        
        }
5.  `OrderPizza`：使用方，负责消费 `Pizza`
    
        public class OrderPizza {
              
        
        	AbsFactory factory;
        
        	// 构造器
        	public OrderPizza(AbsFactory factory) {
              
        		setFactory(factory);
        	}
        
        	private void setFactory(AbsFactory factory) {
              
        		Pizza pizza = null;
        		String orderType = ""; // 用户输入
        		this.factory = factory;
        		do {
              
        			orderType = getType();
        			// factory 可能是北京工厂子类，也可能是伦敦工厂子类
        			pizza = factory.createPizza(orderType);
        			if (pizza != null) {
               // 订购ok
        				pizza.prepare();
        				pizza.bake();
        				pizza.cut();
        				pizza.box();
        			} else {
              
        				System.out.println("订购失败");
        				break;
        			}
        		} while (true);
        	}
        
        	// 写一个方法，可以获取客户希望订购的披萨种类
        	private String getType() {
              
        		try {
              
        			BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
        			System.out.println("input pizza 种类:");
        			String str = strin.readLine();
        			return str;
        		} catch (IOException e) {
              
        			e.printStackTrace();
        			return "";
        		}
        	}
        }
6.  `PizzaStore`：客户端，发出订购披萨的请求
    
        public class PizzaStore {
              
        
        	public static void main(String[] args) {
              
        		//new OrderPizza(new BJFactory());
        		new OrderPizza(new LDFactory());
        	}
        
        }

--------------------

抽象工厂模式总结

1.  `AbsFactory` 仍然是简单工厂（简单工厂模式），但是工厂方法的具体实现需下沉到各个工厂子类（工厂方法模式），所以说抽象工厂模式可以将简单工厂模式和工厂方法模式进行整合。
2.  抽象工厂模式分为两层：抽象层和实现层。`AbsFactory` 作为工厂抽象层，只对工厂规范进行定义，其具体的实现交由工厂子类
3.  简单工厂模式很难满足对多种不同类型的 `Bean` 进行创建，所以我们使用抽象工厂模式，定义一个工厂抽象层，但具体实现需下沉到各个工厂子类

## 4、JDK Calendar ##

> **JDK Calendar 中使用到了简单工厂模式**

测试代码

public class Factory {
        
    
    	public static void main(String[] args) {
        
    		
    		// getInstance 是 Calendar 静态方法
    		Calendar cal = Calendar.getInstance();
    	    // 注意月份下标从0开始，所以取月份要+1
    	    System.out.println("年:" + cal.get(Calendar.YEAR));
    	    System.out.println("月:" + (cal.get(Calendar.MONTH) + 1));       
    	    System.out.println("日:" + cal.get(Calendar.DAY_OF_MONTH));
    	    System.out.println("时:" + cal.get(Calendar.HOUR_OF_DAY));
    	    System.out.println("分:" + cal.get(Calendar.MINUTE));
    	    System.out.println("秒:" + cal.get(Calendar.SECOND));
    	    
    	}
    
    }

`Calendar.getInstance()` 方法的实现

/**
     * Gets a calendar using the default time zone and locale. The
     * <code>Calendar</code> returned is based on the current time
     * in the default time zone with the default
     * {@link Locale.Category#FORMAT FORMAT} locale.
     *
     * @return a Calendar.
     */
    public static Calendar getInstance()
    {
        
        return createCalendar(TimeZone.getDefault(), Locale.getDefault(Locale.Category.FORMAT));
    }

`createCalendar()` 方法的实现：如果 `provider == null`，就会根据 `caltype` 的值，来创建具体的工厂子类对象

private static Calendar createCalendar(TimeZone zone,
                                           Locale aLocale)
    {
        
        CalendarProvider provider =
            LocaleProviderAdapter.getAdapter(CalendarProvider.class, aLocale)
                                 .getCalendarProvider();
        if (provider != null) {
        
            try {
        
                return provider.getInstance(zone, aLocale);
            } catch (IllegalArgumentException iae) {
        
                // fall back to the default instantiation
            }
        }
    
        Calendar cal = null;
    
        if (aLocale.hasExtensions()) {
        
            String caltype = aLocale.getUnicodeLocaleType("ca");
            if (caltype != null) {
        
                switch (caltype) {
        
                case "buddhist":
                cal = new BuddhistCalendar(zone, aLocale);
                    break;
                case "japanese":
                    cal = new JapaneseImperialCalendar(zone, aLocale);
                    break;
                case "gregory":
                    cal = new GregorianCalendar(zone, aLocale);
                    break;
                }
            }
        }
        if (cal == null) {
        
            // If no known calendar type is explicitly specified,
            // perform the traditional way to create a Calendar:
            // create a BuddhistCalendar for th_TH locale,
            // a JapaneseImperialCalendar for ja_JP_JP locale, or
            // a GregorianCalendar for any other locales.
            // NOTE: The language, country and variant strings are interned.
            if (aLocale.getLanguage() == "th" && aLocale.getCountry() == "TH") {
        
                cal = new BuddhistCalendar(zone, aLocale);
            } else if (aLocale.getVariant() == "JP" && aLocale.getLanguage() == "ja"
                       && aLocale.getCountry() == "JP") {
        
                cal = new JapaneseImperialCalendar(zone, aLocale);
            } else {
        
                cal = new GregorianCalendar(zone, aLocale);
            }
        }
        return cal;
    }

## 5、工厂模式小结 ##

工厂模式的意义：将实例化对象的代码提取出来，放到一个类中统一管理和维护，达到和主项目的依赖关系的解耦。从而提高项目的扩展和维护性。

--------------------

三种工厂模式

1.  简单工厂模式
2.  工厂方法模式
3.  抽象工厂模式

--------------------

设计模式的依赖抽象原则

1.  创建对象实例时，不要直接 `new` 这个类，而是把这个`new` 类的动作放在一个工厂的方法中，并返回。有的书上说，变量不要直接持有具体类的引用。这样做的好处是：我们依赖的是一个抽象层（缓冲层），如果之后有什么变动，修改工厂类中的代码即可
2.  不要让类继承具体类，而是继承抽象类或者是实现`interface`(接口)
3.  不要覆盖基类中已经实现的方法

[image-20200820155952740]: /images/20221123/431bd29f63994a9d969fc4507f09ca92.png
[image-20200820214501845]: /images/20221123/614ffaa100fa4061a030911d720d0110.png
[image-20200820193838764]: /images/20221123/e295478175db46449a15f8cc78a2a282.png
[image-20200820205058529]: /images/20221123/163f32ccd4dd48b99ca52706ac6d43cf.png