工厂（factory）模式

最新推荐文章于 2024-08-06 10:50:19 发布

booooooooooooooooooo

最新推荐文章于 2024-08-06 10:50:19 发布

阅读量921

点赞数

CC 4.0 BY-SA版权

分类专栏： design pattern

本文链接：https://blog.youkuaiyun.com/liubo2012/article/details/8762837

design pattern 专栏收录该内容

23 篇文章

订阅专栏

本文详细介绍了工厂模式的概念及其三种类型：简单工厂模式、工厂方法模式和抽象工厂模式。通过对比它们的特点和应用场景，帮助读者理解如何选择合适的工厂模式来提高代码的灵活性。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一.概述

工厂模式主要是为创建对象提供过渡接口，以便将创建对象的具体过程屏蔽隔离起来，达到提高灵活性的目的。

工厂模式分为三类：1）简单工厂模式（Simple Factory）；2）工厂方法模式（Factory Method）；3）抽象工厂模式（Abstract Factory）；

这三种模式从上到下逐步抽象，并且更具一般性。

二、简单工厂模式

简单工厂模式又称静态工厂方法模式（也可以声明为非静态的，下例即是）。总结：1.产品的种类是基本不变的。 2.只是想隐藏产品创建的过程。

先来看看它的组成：

1) 工厂类角色：这是本模式的核心，含有一定的商业逻辑和判断逻辑。
2) 抽象产品角色：它一般是具体产品继承的父类或者实现的接口。在java中由接口或者抽象类来实现。

3) 具体产品角色：工厂类所创建的对象就是此角色的实例。

public abstract class Pizza {

	abstract void prepare();
	abstract void cut();
	abstract void box();
}

class CheesePizza extends Pizza{
	
	CheesePizza() {
		super();
		System.out.println("cheese init");
	}

	@Override
	void box() {
	}

	@Override
	void cut() {
	}

	@Override
	void prepare() {
	}
	
}

class ClamPizza extends Pizza{
	
	ClamPizza() {
		super();
		System.out.println("clam init");
	}

	@Override
	void box() {
	}

	@Override
	void cut() {
	}

	@Override
	void prepare() {
	}
	
}

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

}

public class ShopClient {
	
	SimplePizzaFactory pizzaFactory;

	private ShopClient(SimplePizzaFactory pizzaFactory) {
		super();
		this.pizzaFactory = pizzaFactory;
	}
	
	public Pizza orderPizza(String type){
		Pizza pizza;
		
		pizza = pizzaFactory.createPizza(type);
		
		pizza.prepare();
		pizza.cut();
		pizza.box();
		
		return pizza;
		
	}
	
	public static void main(String[] args) {
		SimplePizzaFactory pizzaFactory = new SimplePizzaFactory();
		ShopClient shopClient = new ShopClient(pizzaFactory);
		shopClient.orderPizza("cheese");
		shopClient.orderPizza("clam");
	}

}

三、工厂方法模式

工厂方法模式是简单工厂模式的进一步抽象化，工厂方法模式里不再只由一个工厂类决定那一个产品类应当被实例化,这个决定被交给抽象工厂的子类去做。
　　来看下它的组成：

1)抽象工厂角色：这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。

2)具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。

3)抽象产品角色：它是具体产品继承的父类或者是实现的接口。

4)具体产品角色：具体工厂角色所创建的对象就是此角色的实例。

工厂方法模式使用继承自抽象工厂角色的多个子类来代替简单工厂模式中的工厂类。正如上面所说，这样便分担了对象承受的压力；而且这样使得结构变得灵活起来——当有新的产品产生时，只要按照抽象产品角色、抽象工厂角色提供的要求来生成，那么就可以被客户使用，而不必去修改任何已有的代码。可以看出工厂角色的结构也是符合开闭原则的！

public abstract class PizzaStore {

	public Pizza orderPizza(String type){
		Pizza pizza;
		
		pizza = createPizza(type);
		
		pizza.prepare();
		pizza.cut();
		pizza.box();
		
		return pizza;
		
	}
	abstract Pizza createPizza(String type);
}

public class NYPizzaStore extends PizzaStore {

	@Override
	Pizza createPizza(String type) {
		Pizza pizza = null;
		
		if(type.equals("cheese")){
			pizza = new NYCheesePizza();
		}else if(type.equals("clam")){
			pizza = new NYClamPizza();
		}
		
		return pizza;
	}

}


public abstract class Pizza {

	abstract void prepare();
	abstract void cut();
	abstract void box();
}

 class NYCheesePizza extends Pizza{

	@Override
	void box() {}
	@Override
	void cut() {}
	@Override
	void prepare() {}
	 
 }


public class Client {

	public static void main(String[] args) {
		PizzaStore pizzaStore = new ChicagoPizzaStore();
		Pizza pizza = pizzaStore.createPizza("cheese");
	}
}

      工厂方法模式和简单工厂模式在定义上的不同是很明显的。工厂方法模式的核心是一个抽象工厂类,而不像简单工厂模式, 把核心放在一个实类上。工厂方法模式可以实际上是多个简单工厂模式的综合,从而推广了简单工厂模式。 
     反过来讲,简单工厂模式是由工厂方法模式退化而来。设想如果我们非常确定一个系统只需要一个工厂类, 那么就不妨把抽象工厂类合并到实的工厂类中去。而这样一来,我们就退化到简单工厂模式了。

四、抽象工厂模式

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

在抽象工厂模式中，抽象产品 (AbstractProduct) 是多个，从而构成多个产品族(Product Family)。在只有一个产品族的情况下，抽象工厂模式实际上退化到工厂方法模式。

使用抽象工厂模式的两个条件：

1）生产的族数大于等于2.

2）产品组之间存在特殊的关联或者依赖关系。

抽象工厂的组成基本和工厂方法类似，最明显的不同之处在于：

工厂方法模式通过对象（抽象工厂类）的继承来实现具体对象的创建；而抽象工厂模式则是通过相关产品的组合来创建系列对象的。

public interface PizzaIngredientFactory {

	public Dough createDough();
	public Sauce createSauce();
}


public class NYPizzaIngredientFactory implements PizzaIngredientFactory {

	@Override
	public Dough createDough() {
		return new ConcreteBDough();
	}

	@Override
	public Sauce createSauce() {
		return new ConcreteBSauce();
	}

}


public abstract class Pizza {

	String name;
	Dough dough;
	Sauce sauce;
	
	void prepare(){};
	
	public String getName(){
		return name;
	}
}

class CheesePizza extends Pizza{
	PizzaIngredientFactory pizzaIngredientFactory;

	CheesePizza(PizzaIngredientFactory pizzaIngredientFactory) {
		super();
		this.pizzaIngredientFactory = pizzaIngredientFactory;
	}
	
	@Override
	void prepare(){
		System.out.println("name:" + name);
		dough = pizzaIngredientFactory.createDough();
		sauce = pizzaIngredientFactory.createSauce();
	}
	
}


public abstract class PizzaStore {

	public Pizza orderPizza(String type){
		Pizza pizza;
		
		pizza = createPizza(type);
		
		pizza.prepare();
		
		return pizza;
		
	}
	abstract Pizza createPizza(String type);
}



public class NYPizzaStore extends PizzaStore {

	@Override
	Pizza createPizza(String type) {
		Pizza pizza = null;
		PizzaIngredientFactory factory = new NYPizzaIngredientFactory();
		
		if(type.equals("cheese")){
			pizza = new CheesePizza(factory);
		}else if(type.equals("clam")){
			pizza = new ClamPizza(factory);
		}
		
		return pizza;
	}

}



public class Client {
	
	public static void main(String[] args) {
		PizzaStore pizzaStore = new NYPizzaStore();
		Pizza pizza = pizzaStore.createPizza("cheese");
		pizza.getName();
		
	}
}

五、总结

（1）简单工厂模式是由一个具体的类去创建其他类的实例。
（2）工厂方法模式是有一个抽象的父类定义公共接口，子类负责生成具体的对象，这样做的目的是将类的实例化操作延迟到子类中完成。
（3）抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口，而无须指定他们具体的类。它针对的是有多个产品的等级结构；而工厂方法模式针对的是一个产品的等级结构。