`
king_tt
  • 浏览: 2083305 次
  • 性别: Icon_minigender_1
  • 来自: 深圳
社区版块
存档分类
最新评论

【设计模式】学习笔记6:抽象工厂模式(Abstract Factory)

阅读更多

 

 

 

本文出自 http://blog.csdn.net/shuangde800

 

 

——所有工厂都是用来封装对象的创建

——工厂是很有威力的技巧,帮助我们针对抽象编程,而不要针对具体类编程。

 

认识抽象工厂模式

在之前的工厂模式已经创建了一个比萨工厂,但是真正要生产的产品——比萨,却还没有涉及到。

比萨店会生产很多不同的比萨产品,而比萨又有格式不同风格的原料。

所以,我们要建造一个工厂来生产原料,这个工厂将负责创建原料家族中的每一个原料:酱料、芝士、面团等。

 

开始先为工厂定义一个接口,这个接口负责创建所有的原料:

 

public interface PizzaIngredientFactory {

	// 接口中,每个原料都有一个对应的方法创建该原料
	// 下面方法返回各原料对象
	public Dough createDough();
	public Sauce createSauce();
	public Cheese createCheese();
	public Veggies[] createVeggies();
	public Pepperoni createPepperoni();
	public Clams createClam();
 
}

 

 

下面要做的是:

1、给每个比萨店建造一个工厂。需要创建实现PizzaIngredientFactory接口的类,实现接口的方法。

2、实现一组原料类供工厂使用。

3、把这一切组织起来,将新的原料工厂整合进旧的PizzaStore中。

 

下面创建了纽约原料工厂,实现了PizzaIngredientFactory接口:

 

public class NYPizzaIngredientFactory implements PizzaIngredientFactory {
 
	public Dough createDough() {
		return new ThinCrustDough();
	}
 
	public Sauce createSauce() {
		return new MarinaraSauce();
	}
 
	public Cheese createCheese() {
		return new ReggianoCheese();
	}
 
	public Veggies[] createVeggies() {
		Veggies veggies[] = { new Garlic(), new Onion(), new Mushroom(), new RedPepper() };
		return veggies;
	}
 
	public Pepperoni createPepperoni() {
		return new SlicedPepperoni();
	}

	public Clams createClam() {
		return new FreshClams();
	}
}



 

然后就可以重新定义“比萨”,这个抽象类:

 

public abstract class Pizza {
	String name;

	Dough dough;
	Sauce sauce;
	Veggies veggies[];
	Cheese cheese;
	Pepperoni pepperoni;
	Clams clam;

	abstract void prepare();//把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 box");
	}

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

	String getName() {
		return name;
	}

	public String toString() {
		StringBuffer result = new StringBuffer();
		result.append("---- " + name + " ----\n");
		if (dough != null) {
			result.append(dough);
			result.append("\n");
		}
		if (sauce != null) {
			result.append(sauce);
			result.append("\n");
		}
		if (cheese != null) {
			result.append(cheese);
			result.append("\n");
		}
		if (veggies != null) {
			for (int i = 0; i < veggies.length; i++) {
				result.append(veggies[i]);
				if (i < veggies.length-1) {
					result.append(", ");
				}
			}
			result.append("\n");
		}
		if (clam != null) {
			result.append(clam);
			result.append("\n");
		}
		if (pepperoni != null) {
			result.append(pepperoni);
			result.append("\n");
		}
		return result.toString();
	}
}



然后就是创建真正的比萨了! 比萨店生产的比萨都是继承自Pizza类,假设要生产一个奶酪比萨(CheesePizza):

 

 

// 这是应用了简单工厂模式
// 比萨要用到原料,把生产原料任务委托给了ingredientFactory工厂
public class CheesePizza extends Pizza {
	PizzaIngredientFactory ingredientFactory;
 
	public CheesePizza(PizzaIngredientFactory ingredientFactory) {
		this.ingredientFactory = ingredientFactory;
	}
        // 实现prepare方法
	void prepare() {
		System.out.println("Preparing " + name);
		dough = ingredientFactory.createDough();
		sauce = ingredientFactory.createSauce();
		cheese = ingredientFactory.createCheese();
	}
}

上面这个真正的比萨,是不是很眼熟?没错,起始就是简单工厂模式, Pizza利用相关的工厂生产原料。所生产的原料依赖所使用的工厂,Pizza类根本不关心这些原料,它只知道如何制作比萨。现在,Pizza和原料之间被解耦,无论原料工厂是在北京还是上海,Pizza类都可以轻易地复用。

 

最后,是时候让新的比萨店登场了!

 

public class NYPizzaStore extends PizzaStore {
 
	protected Pizza createPizza(String item) {
		Pizza pizza = null;
		
		// 原料工厂负责生产所有的原料
		PizzaIngredientFactory ingredientFactory = 
			new NYPizzaIngredientFactory();
 
		if (item.equals("cheese")) {
			
			pizza = new CheesePizza(ingredientFactory); // 把工厂传递给每一个比萨,以便使比萨能从工厂中取得原料
			pizza.setName("New York Style Cheese Pizza");
  
		} else if (item.equals("veggie")) {
 
			pizza = new VeggiePizza(ingredientFactory);
			pizza.setName("New York Style Veggie Pizza");
 
		} else if (item.equals("clam")) {
 
			pizza = new ClamPizza(ingredientFactory);
			pizza.setName("New York Style Clam Pizza");
 
		} else if (item.equals("pepperoni")) {

			pizza = new PepperoniPizza(ingredientFactory);
			pizza.setName("New York Style Pepperoni Pizza");
 
		} 
		return pizza;
	}



 

小结:

上面一连串代码到底做了什么?

其实就做了一件事,引入了新类型的工厂——抽象工厂,来创建比萨原料家族。

我们创建了接口类PizzaIngredientFactory,这个接口可以创建产品的家族,利用这个接口,我们的代码将从实际工厂解耦,以便在不同上下文中实现各式各样的工厂,制作出不同的产品。

 

定义抽象工厂模式

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

 

抽象工厂允许客户使用抽象的接口来创建一组相关的产品,而不需要知道(或关心)实际产出的具体产品是什么。这样一来,客户就从具体的产品中解藕。

 

生产原料的类图:

 

我们可以发现抽象工厂主要是为“产品”而服务的。

 

 

抽象工厂的方法经常以工厂方法的方式实现(例如createDough(), createSource(),每个方法都被声明为抽象,而子类的方法覆盖这些方法来创建某些对象),抽象工厂的任务是定义一个负责创建一组产品的接口。这个接口内的每个方法都负责创建一个具体产品,同时我们利用实现抽象工厂的子类来提供这些具体的做法,所以,在抽象工厂中利用工厂方法实现生产的做法是相当自然的做法。

 

 

比较工厂方法和抽象工厂

 

抽象工厂和工厂方法都是负责创建对象,但工厂方法用的是继承,而抽象方法用的是对象的组合

利用工厂方法创建对象,需要拓展一个类,并覆盖它的工厂方法。整个工厂方法模式,只不过就是通过子类来创建对象。用这种做法,客户只需要知道他们所使用的抽象类型就可以了,而由子类负责决定具体的类型,将客户从具体类型中解耦。

而抽象工厂用来创建一个产品家族的抽象类型,这个类型的子类定义了产品被产生的方法。要想使用这个工厂,必须先实例化它,然后将它传入一些针对抽象类型所写的代码中。所以和工厂方法一样,也实现解耦。

总之,他们都能将对象的创建封装起来,使应用程序解耦,并降低对特定实现的依赖。

 

 

 

 

分享到:
评论

相关推荐

Global site tag (gtag.js) - Google Analytics