欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

工厂模式

程序员文章站 2022-05-17 15:12:30
...
本文章内容是看完《HeadFirst设计模式》书籍的工厂模式后为了加深印象而写。其实有的时候,某些博客并不是仅仅为了分享,更主要的是写给自己,主要是为了自己在写的过程去更加深刻去体会,光看看别人所说的,感觉挺有道理的,却没有转化成自己的东西,就更不会在实际的工作中去使用设计模式了。

言归正传,工厂模式分成3种,简单工厂模式、工厂方法模式、抽象工厂模式。这些模式都是通过接口和抽象进行解耦。

简单工厂模式:(为了偷懒,我也不会独自去想一个实际的场景,将那本书所用场景复述下来,纯手打)
订购一个披萨现状如下:

public Pizza orderPizza(String type){
		Pizza pizza;
		if(type==null || type.equals("cheese")){
			pizza=new CheesePizza();
		}else if(type.equals("greek")){
			pizza=new GreekPizza();
		}else{
			pizza=new PepperoniPizza();
		}
		
		pizza.prepare();
		pizza.bake();
		pizza.cut();
		pizza.bake();
		
		return pizza;
	}

这个过程完成了太多的职责,披萨的生产过程、装配过程。一旦有新的披萨类型加进来就要修改这个函数。简单工厂模式就是把生产披萨的过程独立出去,使得职责划分的更加细致,更好的复用。所以建一个工厂类SimplePizzaFactory单独负责创建各种披萨,改变如下:
public class SimplePizzaFactory {

	public Pizza createPizza(String type){
		Pizza pizza;
		if(type==null || type.equals("cheese")){
			pizza=new CheesePizza();
		}else if(type.equals("greek")){
			pizza=new GreekPizza();
		}else{
			pizza=new PepperoniPizza();
		}
		return pizza;
	}
}

再回到订购披萨的函数中:
public static Pizza orderPizza(String type){
		SimplePizzaFactory factory=new SimplePizzaFactory();
		Pizza pizza=factory.createPizza("cheese");
		
		pizza.prepare();
		pizza.bake();
		pizza.cut();
		pizza.bake();
		
		return pizza;
	}

我们使用了SimplePizzaFactory 来创建披萨,任何地方都可以使用SimplePizzaFactory 来创建披萨,达到复用的效果,同时要新增一个披萨类型时,只需在SimplePizzaFactory 里修改即可。这就是简单工厂模式。看完后,可能你会不屑一顾,没什么特别之处吗?我没看到多大的优点,整体来说不就是把一段代码封装起来达到复用效果吗。我也感觉是这样

工厂方法模式:
上述的简单工厂模式的缺点也很明显,简单工厂模式就是一个大杂烩,把所有的披萨的创建全依靠if else判断来进行,一旦新增一个新的披萨类型,就要去改动if else判断。工厂方法模式就是对这种缺点的改进:
PizzaStore是一个抽象的披萨商店,负责为客户订购披萨,如下:

public abstract class PizzaStore {

	public Pizza orderPizza(){
		Pizza pizza=createPizza();
		
		pizza.prepare();
		pizza.bake();
		pizza.cut();
		pizza.bake();
		
		return pizza;
	}

	protected abstract Pizza createPizza();
}

PizzaStore 根据客户传进来type类型,由它的子类来具体实现这一创建过程,PizzaStore 这一抽象类仅仅对披萨的prepare、bake、cut、bake等装配流程(相同的部分)进行封装。
protected abstract Pizza createPizza()方法就是工厂方法。新增一个披萨类型,只需继承PizzaStore实现抽象方法createPizza方法即可,不再关心披萨的装配流程。

public class CheesePizzaFactory extends PizzaStore{

	@Override
	protected Pizza createPizza() {
		return new CheesePizza();
	}

}
public class GreekPizzaFactory extends PizzaStore{

	@Override
	protected Pizza createPizza() {
		return new GreekPizza();
	}

}

此时实现订购的代码即为:
public static Pizza orderPizzaFactory(String type){
		PizzaStore pizzaStore=new CheesePizzaFactory();
		return pizzaStore.orderPizza();
	}

首先创建一个相应的披萨工厂,然后直接调用工厂的orderPizza即可获取对应的披萨。
这样的做法的确改变了简单工厂模式的大杂烩模式,新增一个披萨类,并不需要去改动以前的任何代码,只需创建一个对应的工厂,继承抽象的披萨工厂PizzaStore。然而这样也存在着一个缺点,每当新增一个新的披萨类型时,就需要新增一个对应的披萨工厂(也可以在已有的工厂中进行if else判断,但这样又会沦落为一个大杂烩),新增一个披萨类型,就要写披萨类和对应的工厂类,有人说不要工厂了,直接new一个披萨。这就说到了工厂和new的区别,其实工厂创建对象也是通过new来创建的,然而它的功能是对new出来的对象进行控制,控制对象的某些参数等等(我们的例子比较简单,工厂没有进行相应的控制)。

抽象工厂模式:
这种模式其实是另一种的使用场景即多件东西组合来合成一件东西。即工厂方法模式是用于生产一件产品,而抽象工厂模式则更适用于多件产品来组合。
如披萨的产生有多种原料来生成,所以构建这样一个抽象的原料工厂,披萨原料抽象工厂如下:

public interface PizzaSourceFactory {

	public Salt getSalt();
	
	public Sugar getSugar();
	
	public Flour getFlour();
}

Salt、Sugar、Flour都是接口,都有不同的实现类。
上面仅仅是一个抽象的原料工厂,下面就需要实现这个工厂,北京披萨原料工厂,BeijingPizzaSourceFactory 如下:

public class BeijingPizzaSourceFactory implements PizzaSourceFactory{

	@Override
	public Salt getSalt() {
		return new BeijingSalt();
	}

	@Override
	public Sugar getSugar() {
		return new BeijingSugar();
	}

	@Override
	public Flour getFlour() {
		return new BeijingFlour();
	}

}

北京披萨原料工厂都是生产的北京的盐、北京的糖、北京的面。同理上海的披萨原料工厂都生产上海的盐、上海的糖、上海的面。
有了披萨的原料工厂,来看看如何制作披萨:

public abstract class NewPizza {

	private Salt salt;
	
	private Sugar sugar;
	
	private Flour flour;
	
	protected abstract void prepare();
	
	public void bake(){
		System.out.println("bake pizza");
	}
	
	public void cut(){
		System.out.println("cut pizza");
	}
	
	public void box(){
		System.out.println("box pizza");
	}
}

这是一个抽象类,留出prepare()方法要求子类来实现,子类就需要通过原料工厂来实现:
public class BeijingPizza extends NewPizza{
	
	private PizzaSourceFactory pizzaSourceFactory;
	
	public BeijingPizza(PizzaSourceFactory pizzaSourceFactory) {
		super();
		this.pizzaSourceFactory = pizzaSourceFactory;
	}

	@Override
	protected void prepare() {
		salt=pizzaSourceFactory.getSalt();
		sugar=pizzaSourceFactory.getSugar();
		flour=pizzaSourceFactory.getFlour();
	}

}

BeijingPizza 需要接收一个原料工厂,在prepare()方法中不断的向原料工厂来获取原料,这些都是针对接口不是针对实现,披萨与原料之间实现解耦。
不同的披萨可以由不同的原料工厂来为它提供原料。
原料工厂提供原料的大致类图如下:


工厂模式
            
    
    博客分类: 设计模式 设计模式工厂方法模式抽象工厂模式 

下面说说工厂方法和抽象工厂的区别:
1 抽象工厂内部的方法其实都是工厂方法,即工厂方法用于生产一个产品,而抽象工厂则用于生产一组产品。
2 工厂方法更多的用于继承基础类,抽象工厂则更多用于提供各种原料来组合创建一个产品。

若想转载请注明出处:   http://lgbolgger.iteye.com/blog/2155213
作者:iteye的乒乓狂魔
  • 工厂模式
            
    
    博客分类: 设计模式 设计模式工厂方法模式抽象工厂模式 
  • 大小: 45 KB