工厂模式
工厂模式
乒乓狂魔 发表于3年前
工厂模式
  • 发表于 3年前
  • 阅读 208
  • 收藏 4
  • 点赞 0
  • 评论 0

新睿云服务器60天免费使用,快来体验!>>>   

本文章内容是看完《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的乒乓狂魔
  • 打赏
  • 点赞
  • 收藏
  • 分享
共有 人打赏支持
粉丝 926
博文 104
码字总数 265075
×
乒乓狂魔
如果觉得我的文章对您有用,请随意打赏。您的支持将鼓励我继续创作!
* 金额(元)
¥1 ¥5 ¥10 ¥20 其他金额
打赏人
留言
* 支付类型
微信扫码支付
打赏金额:
已支付成功
打赏金额: