`

深入浅出设计模式四——多区域比萨加盟店生产比萨实现(抽象工厂模式)

阅读更多

有关抽象工厂文章可先看:http://quicker.iteye.com/blog/575183

http://quicker.iteye.com/blog/607944 中我们使用工厂方法给不同地区的比萨店生产出相应口味的比萨。不过当时我们考虑的各个店同一种比萨的口味和用来生产的原料是一样的。比如纽约的芝士比萨和北京的芝士比萨口味与生产所用原料是一样的 。

但是实际上各个地域不同,同一名称的比萨,口味可能不同,生产的原料也可能不同。

于是公司总部决定自己建立一个原料生产基础,给不同地域的比萨加盟店运送相应的原料。

好了,结合http://quicker.iteye.com/blog/575183中电脑的生产示例,生产的都是电脑,生产电脑都要用到CPU和RAM,但是在中国生产的电脑可能用的是龙芯,RAM也是自己的品牌,而在美国用的CPU和RAM就不是同一种。但不管怎么样他们最终都将用来生产各自的电脑,只不过使用的原料不一样。。

 

正确的理解应是:所有的产品都使用相同的组件制造而成,但是每个区域的这些组件都有不同的实现

在比萨店的示例里面,我们使用了工厂方法。

但是我们不难发现:Pizza,NYCheesePizza,ChicagoCheesePizza这几个类实际上是相似的。他们的区别只是不同地域的pizza所使用的原料不同,那么我们就利用抽象工厂来实现。。

 

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

具体实现:

原料类:

package com.lwf.disign.learn.abstractfactory.cheese;

public interface Cheese {

}

package com.lwf.disign.learn.abstractfactory.cheese;


public class ChicagoCheese implements Cheese {

}

package com.lwf.disign.learn.abstractfactory.cheese;


public class NYCheese implements Cheese {

}

 

 

package com.lwf.disign.learn.abstractfactory.daugh;

public interface Dough {

}

package com.lwf.disign.learn.abstractfactory.daugh;


public class NYDough implements Dough {

}

package com.lwf.disign.learn.abstractfactory.daugh;


public class ChicagoDough implements Dough {

}

 

package com.lwf.disign.learn.abstractfactory.sauce;

public interface Sauce {

}

package com.lwf.disign.learn.abstractfactory.sauce;


public class NYSauce implements Sauce{

}

package com.lwf.disign.learn.abstractfactory.sauce;


public class ChicagoSauce implements Sauce{

}

 

原料工厂类:

package com.lwf.disign.learn.abstractfactory.ingreditfactory;

import com.lwf.disign.learn.abstractfactory.cheese.Cheese;
import com.lwf.disign.learn.abstractfactory.daugh.Dough;
import com.lwf.disign.learn.abstractfactory.sauce.Sauce;

public interface PizzaIngredientFactory {

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

 

package com.lwf.disign.learn.abstractfactory.ingreditfactory;

import com.lwf.disign.learn.abstractfactory.cheese.Cheese;
import com.lwf.disign.learn.abstractfactory.cheese.NYCheese;
import com.lwf.disign.learn.abstractfactory.daugh.Dough;
import com.lwf.disign.learn.abstractfactory.daugh.NYDough;
import com.lwf.disign.learn.abstractfactory.sauce.NYSauce;
import com.lwf.disign.learn.abstractfactory.sauce.Sauce;

public class NYPizzaIngredientFactory implements PizzaIngredientFactory {

	public Cheese createCheese() {
		return new NYCheese();
	}

	public Dough createDough() {
		return new NYDough();
	}

	public Sauce createSauce() {
		return new NYSauce();
	}

}

 

 

package com.lwf.disign.learn.abstractfactory.ingreditfactory;

import com.lwf.disign.learn.abstractfactory.cheese.Cheese;
import com.lwf.disign.learn.abstractfactory.cheese.ChicagoCheese;
import com.lwf.disign.learn.abstractfactory.daugh.ChicagoDough;
import com.lwf.disign.learn.abstractfactory.daugh.Dough;
import com.lwf.disign.learn.abstractfactory.sauce.ChicagoSauce;
import com.lwf.disign.learn.abstractfactory.sauce.Sauce;

public class ChicagoPizzaIngredientFactory implements PizzaIngredientFactory {

	public Cheese createCheese() {
		return new ChicagoCheese();
	}

	public Dough createDough() {
		return new ChicagoDough();
	}

	public Sauce createSauce() {
		return new ChicagoSauce();
	}

}

 

 

Pizza类:

package com.lwf.disign.learn.abstractfactory.pizza;

import com.lwf.disign.learn.abstractfactory.cheese.Cheese;
import com.lwf.disign.learn.abstractfactory.daugh.Dough;
import com.lwf.disign.learn.abstractfactory.sauce.Sauce;

public abstract class Pizza {

	String name;	//名称
	Dough dough;	//面团类型
	Sauce sauce;	//酱料类型
	Cheese cheese;
	
	public abstract void prepare();

	public void bake() {
		System.out.println("Bake for 25 minutes at 350");
	}

	public void cut() {
		System.out.println("Cutting the pizza into diagonal slices");
	}

	public void box() {
		System.out.println("Pizza in offical PizzaStrore box");
	}
	
	public String getName(){
		return name;
	}
}

 

 

package com.lwf.disign.learn.abstractfactory.pizza;

import com.lwf.disign.learn.abstractfactory.ingreditfactory.PizzaIngredientFactory;


public class CheesePizza extends Pizza {

	
	private PizzaIngredientFactory pizzaIngredientFactory;
	public CheesePizza(PizzaIngredientFactory pizzaIngredientFactory){
		this.pizzaIngredientFactory = pizzaIngredientFactory;
	}
	
	public void prepare(){
		dough = pizzaIngredientFactory.createDough();
		sauce = pizzaIngredientFactory.createSauce();
		cheese =pizzaIngredientFactory.createCheese();
		
	}
	public void cut(){
		System.out.println("cut it into CheesePizza slices");
	}
}

 

 

package com.lwf.disign.learn.abstractfactory.pizza;

import com.lwf.disign.learn.abstractfactory.ingreditfactory.PizzaIngredientFactory;


public class VegglePizza extends Pizza {

	private PizzaIngredientFactory pizzaIngredientFactory;
	public VegglePizza(PizzaIngredientFactory pizzaIngredientFactory){
		this.pizzaIngredientFactory = pizzaIngredientFactory;
	}
	
	public void prepare(){
		dough = pizzaIngredientFactory.createDough();
		sauce = pizzaIngredientFactory.createSauce();
		cheese =pizzaIngredientFactory.createCheese();
		
	}
	public void cut(){
		System.out.println("cut it into VegglePizza slices");
	}

}

 

 

PizzaStore类:

package com.lwf.disign.learn.abstractfactory.pzstore;

import com.lwf.disign.learn.abstractfactory.pizza.Pizza;

public abstract class PizzaStore {

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

 

package com.lwf.disign.learn.abstractfactory.pzstore;

import com.lwf.disign.learn.abstractfactory.ingreditfactory.NYPizzaIngredientFactory;
import com.lwf.disign.learn.abstractfactory.ingreditfactory.PizzaIngredientFactory;
import com.lwf.disign.learn.abstractfactory.pizza.CheesePizza;
import com.lwf.disign.learn.abstractfactory.pizza.Pizza;
import com.lwf.disign.learn.abstractfactory.pizza.VegglePizza;

public class NYPizzaStore extends PizzaStore {

	Pizza createPizza(String type) {
		Pizza pizza = null;
		PizzaIngredientFactory pizzaIngredientFactory = new NYPizzaIngredientFactory();
		if(type.equals("cheese")){
			pizza = new CheesePizza(pizzaIngredientFactory);
		}else if(type.equals("veggle")){
			pizza = new VegglePizza(pizzaIngredientFactory);
		}
		return pizza;
	}

}

 

package com.lwf.disign.learn.abstractfactory.pzstore;

import com.lwf.disign.learn.abstractfactory.ingreditfactory.ChicagoPizzaIngredientFactory;
import com.lwf.disign.learn.abstractfactory.pizza.CheesePizza;
import com.lwf.disign.learn.abstractfactory.pizza.Pizza;
import com.lwf.disign.learn.abstractfactory.pizza.VegglePizza;

public class ChicagoPizzaStore extends PizzaStore {

	Pizza createPizza(String type) {
		Pizza pizza = null;
		ChicagoPizzaIngredientFactory chicagoPizzaIngredientFactory = new ChicagoPizzaIngredientFactory();
		if(type.equals("cheese")){
			pizza = new CheesePizza(chicagoPizzaIngredientFactory);
		}else if(type.equals("veggle")){
			pizza = new VegglePizza(chicagoPizzaIngredientFactory);
		}
		return pizza;
	}

}

 

测试类:

package com.lwf.disign.learn.abstractfactory.pzstore;

import com.lwf.disign.learn.abstractfactory.pizza.Pizza;

public class PizzaStoreTest {

	public static void main(String[] args) {

		PizzaStore pizzaStore = new NYPizzaStore();
		Pizza pizza = pizzaStore.orderPizza("cheese");
		print(pizza.getName());
		
		pizza = pizzaStore.orderPizza("veggle");
		print(pizza.getName());
		
		pizzaStore = new ChicagoPizzaStore();
		pizza = pizzaStore.orderPizza("cheese");
		print(pizza.getName());
		
		pizza = pizzaStore.orderPizza("veggle");
		print(pizza.getName());
		
	}

	public static void print(String name){
		System.out.println(name);
		System.out.println("-------------------------------------------------------------");
	}
}

 

 我们再看看抽象工厂的UML图。

看看pizzastore的抽象工厂图。

 

我们使用了工厂方法与抽象工厂实现了比萨店。

那么工厂方法与抽象工厂有什么区别呢。

他们都用来创建对象,工厂方法使用继承;而抽象工厂则使用对象组合。这意味着使用工厂方法就要扩展一个类,并覆盖它的工厂方法。

 

工厂方法只负责将客户从具体类型中解藕。

当你需要创建产品家族和想让制造的相关产品集合起来时,你可以使用抽象工厂。

如果你目前还不知道将来需要实例化哪些具体类时,你可以使用工厂方法。

分享到:
评论

相关推荐

    深入浅出设计模式四——比萨店生产比萨实现(工厂方法模式)

    本文将深入探讨“工厂方法模式”,并结合比萨店生产比萨的实例来解析这一模式的运用。首先,我们要理解工厂方法模式的核心思想:定义一个创建对象的接口,但让子类决定实例化哪一个类。这样,工厂方法可以把类的实例...

    抽象工厂模式代码

    抽象工厂模式是软件设计模式中的一种,属于创建型模式,它的主要目的是提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类。在实际应用中,当我们需要创建一组具有共同特性的对象,而这些对象分别...

    设计模式 - 抽象工厂模式

    在披萨店的例子中,我们可以使用抽象工厂模式来创建原料工厂,该工厂能够生产不同类型的原料。我们首先创建一个抽象的原料工厂接口,定义了一组用于创建原料的方法。然后,我们创建了具体的原料工厂类,继承了抽象...

    学习笔记-深入浅出设计模式

    在《深入浅出设计模式》的学习笔记中,我们可以看到几种关键的设计模式及其应用,包括策略模式、观察者模式、装饰者模式、工厂模式和抽象工厂模式。 1. **策略模式**: - 策略模式的核心在于将算法族封装在独立的...

    设计模式-简单工厂模式-披萨店C#语言版

    压缩包中的`setup.exe`和`Pizza.msi`可能是安装程序,用于部署这个披萨店的简单工厂模式实现。`setup.exe`通常是Windows应用程序的自解压安装包,而`.msi`文件是Microsoft Installer格式,用于在Windows上进行软件...

    深入浅出之[Head First 设计模式]

    《深入浅出之[Head First 设计模式]》是一本专为初学者和有经验的开发者设计的经典设计模式教程。这本书以其独特的、易于理解的教学方式,深入浅出地阐述了设计模式这一复杂的软件工程概念。设计模式是软件开发中...

    抽象工厂模式abstractFactory

    抽象工厂模式(Abstract Factory Pattern)是一种创建型设计模式,它提供了一种创建对象集合的接口,而无需指定具体的产品类型。这种模式适用于当系统需要在不同平台或环境中创建一组相关或相互依赖的对象时,而这些...

    抽象工厂模式

    抽象工厂模式是一种设计模式,属于创建型模式,它提供了一种创建对象集合的接口,而无需指定具体的类。这种模式的关键在于,它允许客户端代码与具体实现细节解耦,使得在不修改现有代码的情况下,可以方便地更换或...

    AbstractFactory 抽象工厂

    抽象工厂(Abstract Factory)模式是设计模式中的一种创建型模式,它提供了一种创建对象族的接口,而无需指定它们的具体类。这种模式允许客户端在不关心具体实现的情况下,使用一组相关或相互依赖的对象。在Java或...

    工厂模式-设计模式

    工厂模式是软件设计模式中的一种基础模式,它在对象创建方面提供了一种抽象化的方式,使得代码在实例化具体类时更加灵活。这个压缩包文件可能是关于如何在实际项目中运用工厂模式的教学材料,特别适合那些正在学习...

    HeadFirst设计模式笔记

    总的来说,《HeadFirst设计模式笔记》通过`PizzaIngredientFactory`的例子,深入浅出地介绍了设计模式的重要性及其在实际编程中的应用。学习和掌握设计模式,能帮助开发者编写出更加优雅、灵活的代码,提高团队协作...

    工厂设计模式总结

    工厂设计模式是面向对象设计中的一种创建型模式,它的主要目的是为了解耦对象的创建过程,使得客户端代码不再直接通过new关键字创建对象,而是通过一个工厂类来获取所需的对象。这样做的好处在于,当需要添加新的...

    第5讲 工厂模式(简单工厂、抽象工厂)

    工厂模式是一种设计模式,主要用来解决对象创建的问题,特别是当有多个相关联的具体类需要实例化,而这些实例化操作可能会随着需求的变化而变化时。工厂模式的核心思想是定义一个创建对象的接口(或者抽象类),但让...

    [创建型模式] head first 设计模式之工厂模式(Factory)

    在《Head First 设计模式》这本书中,作者用生动有趣的例子和图形来解释这些概念,比如披萨店的例子,不同的披萨店(工厂)制作不同口味的披萨(产品)。通过这样的例子,读者能更好地理解如何在实际项目中应用工厂...

    head first工厂模式

    《Head First工厂模式》是软件设计模式学习领域中的一本经典书籍,主要讲解了工厂模式这一重要的设计模式。工厂模式是一种创建型设计模式,它的核心思想是为对象的创建提供一个接口,使得客户端代码可以避免与具体类...

    设计模式培训资料之工厂方法模式

    ### 设计模式培训资料之工厂方法模式 #### 工厂方法模式详解 工厂方法模式是一种常用的软件设计模式,属于创建型模式的一种。它的主要目的是封装对象的创建过程,通过引入工厂角色来创建对象,从而避免在客户端...

    Head First 设计模式(中文完整版+附书源码)

    例如,工厂模式通过制作比萨的例子,展示了如何抽象出一个创建对象的通用接口,而具体的产品由不同的子类实现。代理模式则通过经纪人与演员的互动,解释了如何在不修改原有对象的基础上增加新的功能或控制访问。 书...

    简单工厂实现多态比萨店

    总的来说,"简单工厂实现多态比萨店"展示了如何在.NET环境中运用简单工厂模式来处理多态性问题。通过这种方式,我们能够有效地管理和组织代码,使得业务逻辑更加清晰,同时也降低了代码的复杂度。这是一个很好的实践...

    Head First 设计模式 英文版

    《Head First设计模式》是软件开发领域中一本非常知名的经典著作,它以英文版的形式提供了深入浅出的设计模式讲解。这本书以其独特的“Head First”学习风格,通过丰富的图像、幽默的语言和互动性的教学方法,帮助...

Global site tag (gtag.js) - Google Analytics