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

最新推荐文章于 2020-10-08 18:20:18 发布
最新推荐文章于 2020-10-08 18:20:18 发布
阅读量254 收藏
点赞数
分类专栏： 设计模式 文章标签： 设计模式 制造 UML Blog

有关抽象工厂文章可先看：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的抽象工厂图。

 

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

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

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

 

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

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

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

luweifeng1983
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
工厂方法与抽象工厂结合(Pizza)
水神
08-31 720
工厂方法和抽象工厂作用都是一样 ： 解耦客户端代码,不用指定具体类就可产生具体对象. 摘自: Head First 设计模式 说一下大概意思 1. 在不指定具体类的情况下可产生具体披萨 2.不同区域可产生不同风味的披萨 3.同一区域可产生不同原料料理的披萨 首先我们来定义披萨 public abstract class Pizza { private Pizza
Java设计模式-抽象工厂模式
最新发布
zcyiysj的博客
12-11 129
抽象工厂模式
深入浅出设计模式四——比萨店生产比萨实现(工厂方法模式）
05-27
NULL 博文链接：https://quicker.iteye.com/blog/607944
设计模式学习之四（上）—开自己的比萨店
越国岩的专栏
05-18 2777
    前面说过其中之一的设计原则我们不应该依赖实现编程，但是当我们每次用new时不正是在依赖实现编程吗Duck duck = new MallardDuck(); 正如上面的代码，我们使用接口让代码有了弹性，但是还是得建立具体类的实例，当有一群相关的具体类时通常会写出这样的代码：Duck duck; if(picnic){ duck = new MallardDuck(); } else if(hunting) { duck = new DecoyDuck(); } else if(inBa
设计模式之四：抽象工厂(披萨店生产披萨模拟流程)
weixin_30702413的博客
09-18 1046
抽象工厂模式：提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。(披萨店生产披萨模拟流程) 抽象工厂允许客户使用抽象的接口来创建一组相关的产品，而不需要知道(或关心)实际产出的具体产品是什么。这样一来就从具体的产品中被解藕。 依赖倒置原则：要依赖抽象，不要依赖具体类。 这个原则说明了：不能让高层组件依赖底层组件，而且，不管高层或底层组件，“两者”都应该依赖抽象。 工程名称...
：工厂模式2：抽象工厂模式--Pizza
weixin_30508241的博客
04-21 293
#ifndef __INGREDIENT_H__ #define __INGREDIENT_H__ #include <iostream> using namespace std; class Dough { }; class ThinDough:public Dough { }; class BigDough :public Dough { }; class Ca...
设计模式——工厂模式
记录只为更好地前行
07-04 4716
工厂模式 在《Head First 设计模式》一书中，一共介绍了一种类似于工厂模式的编程习惯、两种工厂模式，在这篇文章中，我将对它们分别进行介绍，下面首先来看一下简单工厂。 1、简单工厂 按照惯例，我们应该先介绍一下简单工厂的定义，然后举例说明，这一次，我们不这样做，我们首先举例说明，然后再引出简单工厂的定义，后续两个工厂模式均按此方式进行叙述，从案例中理解模式的定义才能够更加印象深刻。...
Yii2设计模式——工厂方法模式
米粒人生
01-02 487
应用举例 yii\db\Schema抽象类中： //获取数据表元数据 public function getTableSchema($name, $refresh = false) { if (array_key_exists($name, $this-&amp;gt;_tables) &amp;amp;&amp;amp; !$refresh) { return $this...
《HeadFirst设计模式》第四章-3.抽象工厂模式
qq_32293345的博客
04-25 236
1.声明 设计模式中的设计思想、图片和部分代码参考自《Head First设计模式》，作者Eric Freeman & Elisabeth Freeman & Kathy Siezza & Bert Bates。 在这里我只是对这本书进行学习阅读，并向大家分享一些心得体会。 2.依赖具体类的缺陷 由第2篇，我们知道了，工厂方法模式可以较好的解决对象依赖的问题，使程序...
抽象工厂模式代码
02-15
设计模式，AbstractFactory，抽象工厂模式
抽象工厂模式--演示代码
11-01
JAVA抽象工厂模式--演示代码，抽象工厂模式，也称为工厂的工厂，有一个工厂创建其他工厂
抽象工厂模式uml类图
03-07
java设计模式 抽象工厂模式详解 一张图让你彻底明白抽象工厂模式
dream-pizza：Dream Pizza是一个虚构的比萨连锁店的网站。 如果用户想离线访问餐厅，或者可以在线订购比萨饼，则用户可以在地图上查看Dream Pizza的位置。 该网站允许用户选择披萨，将其标记为收藏夹，添加至购物车或从购物车中删除，在披萨页面上留下评论
02-16
梦想披萨 用React开发的披萨店网站。
设计模式之工厂模式（披萨店案例）
yxZhuSir的博客
10-08 2047
设计模式之工厂模式（披萨店案例） 披萨类如下： import java.util.ArrayList; public abstract class Pizza { String name; String dough; String sauce; ArrayList toppings = new ArrayList(); void prepare(){ System.out.println("Preparing " + name); System
重新组织披萨店 AbstractFactory----抽象工厂
m15527097561的博客
06-17 558
上次讲了工厂方法，现在让我们来试试抽象工厂来组织我们的披萨店。（为什么我写了这么多，因为我不是单纯写设计模式，带着这了编程的思想） 先看概念：提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类。 这句话看上去很简略，通过下面的例子，我们可以很好的理解这句话。 ----------------------------- 我们做披萨，针对不同的披萨有不同
设计模式之四：工厂方法模式(披萨店生产披萨模拟流程)
weixin_30247159的博客
09-17 553
工厂方法模式：定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个。工厂方法让类把实例化推迟到子类。(披萨店生产披萨模拟流程) 工厂方法模式通过让子类决定该创建的对象是什么，来达到将对象的过程封装的目地。 简单工厂和工厂方法之间的差异： 1）简单工厂不是一个设计模式，常被误认为是“工厂模式”。 2）简单工厂把全部的事情，在一个地方都处理完了，然而工厂方法却是创建一个框架，让子类决定要...
抽象工厂模式
qq_37520037的博客
09-17 128
抽象工厂模式原理介绍 抽象工厂模式实例介绍 抽象工厂模式代码实现 原理介绍：抽象工厂模式是所有形态的工厂模式中最为抽象和最具一般性的一种形态。抽象工厂模式是指当有多个抽象角色时，使用的一种工厂模式。抽象工厂模式可以向客户端提供一个接口，使客户端在不必指定产品的具体的情况下，创建多个产品族中的产品对象。根据里氏替换原则，任何接受父类型的地方，都应当能够接受子类型。因此，实际上系统所需要的...
抽象工厂模式（Abstract Factory Pattern）
hqing159的博客
07-31 868
前言​ 在工厂方法模式中，我们使用一个工厂创建一个产品，也就是说一个具体的工厂对应一个具体的产品。但是有时候我们需要一个工厂能够提供多个产品对象，而不是单一的对象，这个时候我们就需要使用抽象工厂模式。一些概念​ 产品等级结构：也就是产品的继承结构。例如一个为电视的抽象类，它有长虹电视、乐视电视、康佳电视等一系列的子类，那么这个抽象类电视和他的子类就构成了一个产品等级结构。​ 产品族：是在
工厂模式在对象创建中的应用——以披萨店为例
"该资源是一个关于工厂设计模式的PPT，通过具体的NYStyleCheesePizza类展示了如何在Java中实现这个模式。工厂设计模式是一种常用的对象创建型设计模式，旨在提供一个创建对象的接口，但让子类决定实例化哪一个类。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值