设计模式之四工厂模式（简单工厂、工厂方法、抽象工厂）

本文链接：https://blog.csdn.net/m0_37298602/article/details/82586423

工厂模式

定义

简单工厂其实并不是一个设计模式，反而比较像是一种编程习惯。有些开发人员把这个编程习惯误认为是“工厂模式”（Factory Pattern）。

所有工厂模式都用来封装对象的创建。工厂方法模式（Factory Method Pattern）通过让子类决定该创建的对象是什么，来达到将对象创建的过程封装的目的。

工厂方法模式定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个。工厂方法让类把实例化推迟到子类。

抽象工厂模式提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。

优缺点

应用场景

例子

Pizza店的简单工厂类

public class SimplePizzaFactory {
	public SimplePizzaFactory createPizza(String type) {
		Pizza pizza = null;
		
		if(type.equals("cheese" )) {
			pizza = new CheesePizza();
		} else if(type.equals("pepperoni" )) {
			pizza = new PepperoniPizza();
		} else if(type.equals("clam" )) {
			pizza = new ClamPizza();
		}
		return pizza;
	}
}

使用简单工厂的PizzaStore类

public class PizzaStore {
	SimplePizzaFactory factory;
	
	public PizzaStore(SimplePizzaFactory factory) {
		this.factory = factory;
	}
	
	public Pizza orderPizza(String type) {
		Pizza pizza;
		
		pizza = factory.createPizza(type);
		
		pizza.prepare();
		pizza.bake();
		pizza.cut();
		
		return pizza;
	}
	
}

针对不同地区加盟店的披萨具有特色的风味，下面把PizzaStore改为超类，每个域类型继承这个PizzaStore，每个子类各自决定如何制造披萨。

public abstract class PizzaStore {
//	SimplePizzaFactory factory;
//	
//	public PizzaStore(SimplePizzaFactory factory) {
//		this.factory = factory;
//	}
	
	public Pizza orderPizza(String type) {
		Pizza pizza;
		
		pizza = createPizza(type);
		
		pizza.prepare();
		pizza.bake();
		pizza.cut();
		
		return pizza;
	}
	
	abstract Pizza createPizza(String type);
}

下面尝试无锡风味的加盟店：

public class WXPizzaStore extends PizzaStore {

	@Override
	Pizza createPizza(String type) {
		if(type.equals("cheese" )) {
			return new WXStyleCheesePizza();
		} else if(type.equals("pepperoni" )) {
			return new WXStylePepperoniPizza();
		} else if(type.equals("clam" )) {
			return new WXStyleClamPizza();
		}
		
		return null;
	}
}

原本是由一个对象（SimplePizzaFactory）负责所有具体类的实例化，现在对PizzaStore做些小改变，变成由一群子类负责实例化；现在，实例化披萨的责任被移到一个“方法”中，此方法就如同是一个“工厂”。

abstract Pizza createPizza(String type);

工厂方法负责处理对象的创建，并将这样的行为封装在子类中。这样，客户程序中关于超类的代码就和子类对象创建代码解耦了。

abstract Product factoryMethod(String type);

抽象工厂模式（工厂接口）客户从具体的产品中解耦

现在需要解决加盟店的原料问题，为了保证产品的品质，加盟店必须从工厂获取原料。

public abstract class Pizza {

	String name;
	Dough dough;
	Sauce sauce;
	Veggies[] veggies;
	Cheese cheese;
	Pepperoni pepperoni;
	Clams clam;
	
	abstract void prepare();
	
	void bake() {
		System.out.println("Bake for 25 minutes at 350");
	}
	
	void cut() {
		System.out.println("Cutting the pizza into diagonal slices");
	}
	
	void box() {
		System.out.println("Place pizza in official PizzaStore");
	}
	
	String getName() {
		return name;
	}
	
	void setName(String name) {
		this.name = name;
	}
	
	@Override
	public String toString() {
		return "Pizza [name=" + name + "]";
	}
}

不同风味的Pizza使用原料工厂来获取原料。

public class CheesePizza extends Pizza {

	PizzaIngredientFactory ingredientFactory;//原料工厂
	
	public CheesePizza(PizzaIngredientFactory ingredientFactory) {
		this.ingredientFactory = ingredientFactory;
	}
	@Override
	void prepare() {
		System.out.println("Preparing " + name);
		dough = ingredientFactory.createDough();
		sauce = ingredientFactory.createSauce();
		cheese = ingredientFactory.createCheese();
	}
}

哈喇披萨：

public class ClamPizza extends Pizza {



    PizzaIngredientFactory ingredientFactory;//原料工厂

   

    public ClamPizza(PizzaIngredientFactory ingredientFactory) {

       this.ingredientFactory = ingredientFactory;

    }

    @Override

    void prepare() {

       System.out.println("Preparing " + name);

       dough = ingredientFactory.createDough();

       sauce = ingredientFactory.createSauce();

       clam = ingredientFactory.createClam();

    }

}

设计原则

找出应用中可能需要变化之处，把他们独立出来，不要和那些不需要变化的代码混在一起。

要依赖抽象，不要依赖具体类（依赖倒置原则）。（不能让高层组件依赖底层组件）

多用组合，少用继承。

针对接口编程，不针对实现编程。

为交互对象之间的松耦合设计而努力。

类应该对扩展开放，对修改关闭，

小结

所有工厂模式都用来封装对象的创建。工厂方法模式（Factory Method Pattern）通过让子类决定该创建的对象是什么，来达到将对象创建的过程封装的目的。

本图摘自《Head First 设计模式》一文，如有侵权，请联系博主删除

小知识

依赖倒置：所谓依赖倒置原则，就是不论高层组件和低层组件都应该依赖于抽象，而不是具体实现类。听起来更像是“针对接口编程，而不是针对实现编程”，但是这里依赖倒置原则更强调“抽象”的概念，不要让高层组件依赖低层组件，更不能依赖具体实现类，都要依赖于抽象。依赖倒置原则的核心在于“面向接口编程”，目的在于”解耦“。