Alienware^

设计模式之工厂模式（万字长文）

文章目录

概述
工厂模式的优点包括
工厂模式有几种主要的变体
- 看一个具体需求
- 使用传统的方式来完成
- - 传统的方式的优缺点
- 简单工厂模式基本介绍
- 使用简单工厂模式
- - 简单工厂模式的优缺点
  - - 优点：
    - 缺点：
- 工厂方法模式
- - 看一个新的需求
  - 思路 1
  - 思路 2
  - 工厂方法模式介绍
  - 工厂方法模式应用案例
- 抽象工厂模式
- - 基本介绍
  - 抽象工厂模式应用实例
工厂模式小结

概述

工厂模式是一种创建型设计模式，它提供了一种创建对象的接口，但将对象的实例化过程推迟到子类或具体的实现类中。工厂模式的主要目的是将对象的创建与使用分离，从而降低代码的耦合性，增强代码的可维护性和可扩展性。

工厂模式的优点包括

对象的封装：将对象的创建细节封装在具体的工厂类中，使客户端不需要了解具体的创建过程，只需通过工厂来获取所需的对象。
代码重用：由于对象的创建过程在工厂类中集中管理，可以避免在多个地方重复创建相同类型的对象。
易于扩展：当需要添加新的产品或变体时，只需创建新的具体工厂类和产品类，而不需要修改现有代码。
降低耦合：客户端只与抽象工厂类进行交互，不直接依赖于具体产品类，从而降低了代码的耦合性。

工厂模式有几种主要的变体

简单工厂模式：不是正式的设计模式，更像是一种编程习惯，将对象的创建封装在一个静态方法中。
工厂方法模式：定义了一个用于创建对象的抽象方法，由具体的子类工厂来实现创建逻辑。
抽象工厂模式：提供一个创建一组相关或相互依赖对象的接口，每个具体工厂类负责创建一组具体产品。

看一个具体需求

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

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

使用传统的方式来完成

思路分析(类图)

新建一个tradition.pizzastore包

编写 OrderPizza.java 去订购需要的各种 Pizza

代码展示：

package com.lh.factory.tradition.pizzastore.order;

import java.io.BufferedReader;

import java.io.IOException;
import java.io.InputStreamReader;

import com.lh.factory.simplefactory.pizzastore.pizza.CheesePizza;
import com.lh.factory.simplefactory.pizzastore.pizza.GreekPizza;
import com.lh.factory.simplefactory.pizzastore.pizza.PepperPizza;
import com.lh.factory.simplefactory.pizzastore.pizza.Pizza;

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 {
				System.out.println("不存在！");
				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 "";
		}
	}
}

Pizza类，作为抽象类，功能参考类图

package com.lh.factory.tradition.pizzastore.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 + "cuting");
	}
	
	//打包
	public void box() {
		System.out.println(name + "boxing");
	}
}

三个子类继承Pizza类

package com.lh.factory.tradition.pizzastore.pizza;

public class CheesePizza extends Pizza{

	@Override
	public void prepare() {

		System.out.println("给胡椒披萨，制作原材料");
	}
}

package com.lh.factory.tradition.pizzastore.pizza;

public class GreekPizza extends Pizza{

	@Override
	public void prepare() {

		System.out.println("奶酪准备原材料");
	}
}

package com.lh.factory.tradition.pizzastore.pizza;

public class PepperPizza extends Pizza {

	@Override
	public void prepare() {

		System.out.println(" 给希腊披萨 准备原材料 ");
	}
}

客户端：

package com.lh.factory.tradition.pizzastore.order;

//相当于一个客户端，发出订购
public class PizzaStore {

	public static void main(String[] args) {

		//传统方法
		new OrderPizza();
				
	}
}

传统的方式的优缺点

优点是比较好理解，简单易操作。
缺点是违反了设计模式的 ocp 原则，即对扩展开放，对修改关闭。即当我们给类增加新功能的时候，尽量不修改代码，或者尽可能少修改代码.
比如我们这时要新增加一个 Pizza 的种类(Pepper 披萨)，我们需要做如下修改.如果我们增加一个 Pizza 类，只要是订购 Pizza 的代码都需要修改.

在orderType中新增的代码如下图：参考上方的orderType代码，代码块中有如下功能：

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

简单工厂模式基本介绍

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

使用简单工厂模式

简单工厂模式的设计方案: 定义一个可以实例化 Pizaa 对象的类，封装创建对象的代码。

uml类图如下：

看代码示例

简单工厂模式的pizza包下的类，均不做改动，参考如上代码即可（需要细心观看哦）

这里只展示修改后的OrderPizza和客户端了，以及新的简单工厂模式

package com.lh.factory.simplefactory.pizzastore.order;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

import com.lh.factory.simplefactory.pizzastore.pizza.CheesePizza;
import com.lh.factory.simplefactory.pizzastore.pizza.GreekPizza;
import com.lh.factory.simplefactory.pizzastore.pizza.PepperPizza;
import com.lh.factory.simplefactory.pizzastore.pizza.Pizza;

public class OrderPizza {

	SimlpleFactory simlpleFactory;
	Pizza pizza = null;
	
	//构造器
	public OrderPizza(SimlpleFactory simlpleFactory) {
		
		//接受简单工厂
		setFactory(simlpleFactory);
		
	}

	public void setFactory(SimlpleFactory simlpleFactory) {
		String orderType = ""; // 用户输入的

		this.simlpleFactory = simlpleFactory; // 设置简单工厂对象

		do {
			
			orderType = getType();
			pizza = this.simlpleFactory.createPizza(orderType);
			
			//输出pizza
			if (pizza != null) { //订购成功
				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 "";
		}
	}
}

好处：只需要修改工厂类的代码即可，不需要在业务场景下进行修改

下面的工厂类写了两个相同的方法，没别的意思，就是告诉大家，简单工厂模式，也叫静态工厂模式

package com.lh.factory.simplefactory.pizzastore.order;

import com.lh.factory.simplefactory.pizzastore.pizza.CheesePizza;
import com.lh.factory.simplefactory.pizzastore.pizza.GreekPizza;
import com.lh.factory.simplefactory.pizzastore.pizza.PepperPizza;
import com.lh.factory.simplefactory.pizzastore.pizza.Pizza;


//简单工厂类
public class SimlpleFactory {

	
	//返回对应的Pizza 
	public Pizza createPizza(String orderType) {

		Pizza pizza = null;

		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;

	}
	
	//简单工厂模式也叫静态工厂模式
	public static Pizza createPizza2(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;
	}
}

静态工厂模式的OrderPizza类（静态工厂模式看起来更加方便，减少了一部分代码）

package com.lh.factory.simplefactory.pizzastore.order;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;


import com.lh.factory.simplefactory.pizzastore.pizza.Pizza;

public class OrderPizza2 {

	Pizza pizza = null;
	String orderType = "";

	// 构造器
	public OrderPizza2() {

		// 接受简单工厂
		do {

			orderType = getType();
			pizza = SimlpleFactory.createPizza2(orderType);

			// 输出pizza
			if (pizza != null) { // 订购成功
				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 "";
		}
	}

}

简单工厂模式的优缺点

优点：

封装对象的创建逻辑：通过将对象的创建逻辑封装在静态工厂方法中，客户端代码无需了解对象的具体创建过程，降低了对象创建的复杂度。

代码组织：简单工厂模式可以集中管理对象的创建逻辑，使代码更加清晰、简洁，并且易于维护。

灵活性：如果需要更改或替换产品，只需修改工厂方法的实现，不会影响客户端代码，从而实现了产品变化对客户端的透明性。

缺点：

不符合开闭原则：当需要添加新的产品类型时，可能需要修改工厂方法的代码，这违背了开闭原则（对扩展开放，对修改关闭）。

工厂类职责过重：工厂类通常负责创建多种不同类型的对象，导致工厂类职责变得较重，随着产品种类的增加，工厂类会变得越来越复杂。

不支持多个工厂类：在简单工厂模式中，只有一个工厂类负责所有对象的创建，这可能会导致工厂类变得庞大，难以管理。

不够灵活：由于所有对象的创建逻辑集中在一个工厂类中，如果不同的产品有复杂的创建过程，可能无法很好地适应。

工厂方法模式

看一个新的需求

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

思路 1

使用简单工厂模式，创建不同的简单工厂类，比如 BJPizzaSimpleFactory、LDPizzaSimpleFactory 等等。从当前这个案例来说，也是可以的，但是考虑到项目的规模，以及软件的可维护性、可扩展性并不是特别好（考验大家抽象能力）

思路 2

使用工厂方法模式

工厂方法模式介绍

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

工厂方法模式应用案例

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

Pizza类与它的子类

package com.lh.factory.factorymethod.pizzastore.pizza;

//将Pizza 类做成抽象类
public abstract class Pizza {
	
	//名字
	protected String name;
	
	//原材料（不同的披萨，不一样的原材料）,做成抽象方法，自定义实现
	public abstract void prepare();
	
	//烘烤
	public void bake() {
		System.out.println(name + "baking");
	}
	
	//切割
	public void cut() {
		System.out.println(name + "cuting");
	}
	
	//打包
	public void box() {
		System.out.println(name + "boxing");
	}

	public void setName(String name) {
		this.name = name;
	}
}

public class LDPepperPizza extends Pizza{

	@Override
	public void prepare() {
		
		setName("伦敦胡椒披萨...");
		System.out.println("伦敦胡椒pizza,准备原材料");
		
	}
}

public class LDCheesePizza extends Pizza{

	@Override
	public void prepare() {
		
		setName("伦敦奶酪披萨...");
		System.out.println("伦敦奶酪pizza,准备原材料");
	}

}

public class BJPepperPizza extends Pizza{

	@Override
	public void prepare() {
		
		setName("北京胡椒披萨...");
		System.out.println("北京pizza,准备原材料");
		
	}
}

public class BJCheesePizza extends Pizza{

	@Override
	public void prepare() {
		
		setName("北京奶酪披萨...");
		System.out.println("北京pizza,准备原材料");
	}
}

工厂抽象类，定义一个工厂的抽象方法，让其子类自己实现，这样可以不需要动工厂自身的代码，如果想添加新的品种，可以新创建一个，继承工厂抽象类重写其方法就可以

package com.lh.factory.factorymethod.pizzastore.order;

import java.io.BufferedReader;

import java.io.IOException;
import java.io.InputStreamReader;

import com.lh.factory.factorymethod.pizzastore.pizza.Pizza;

public abstract class OrderPizza {

	// 构造器
	public OrderPizza() {
		Pizza pizza = null;

		String orderType; // 订购披萨的类型

		do {
			orderType = getType();
			
			//抽象方法，由工厂子类完成
			pizza = createPizza(orderType);

			// 输出 Pizza 制作过程
			pizza.prepare();
			pizza.bake();
			pizza.cut();
			pizza.box();

		} while (true);

	}

	// 定义一个抽象方法，createPizza,让各个工厂子类自己实现
	abstract Pizza createPizza(String orderType);

	// 写一个方法，可以获取客户希望订购的披萨种类
	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 "";
		}
	}
}

两个分工厂分别继承OrderPizza 类，分别实现各自的功能

package com.lh.factory.factorymethod.pizzastore.order;

import com.lh.factory.factorymethod.pizzastore.pizza.LDCheesePizza;
import com.lh.factory.factorymethod.pizzastore.pizza.LDPepperPizza;
import com.lh.factory.factorymethod.pizzastore.pizza.Pizza;

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


package com.lh.factory.factorymethod.pizzastore.order;

import com.lh.factory.factorymethod.pizzastore.pizza.BJCheesePizza;
import com.lh.factory.factorymethod.pizzastore.pizza.BJPepperPizza;
import com.lh.factory.factorymethod.pizzastore.pizza.Pizza;

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