工厂模式之三 - 抽象工厂(Abstract Factory)模式

抽象工厂(Abstract Factory)模式 不同于简单工厂和工厂方法,抽象工厂用于创建一个产品族

即抽象工厂模式用于创建一系列类,这些类在业务上有关联。

我们来举个快餐店的例子。

场景:快餐店的套餐分为汉堡和饮料,汉堡可以选鸡肉汉堡,鱼肉汉堡,巨无霸等等,

         饮料可以选咖啡,可乐,橙汁等等。

 

对于业务来说,汉堡和饮料分别可以被抽象为两类产品,因此,我们可以建立2个接口。

汉堡可以有2个方法,一个是打印汉堡名,一个是打印价钱,如下:

namespace designpattern.cs.AbstracFactory
{
    public interface IHamburger
    {
        void printName();
        void printCost();
    }
}

 

 饮料接口除了汉堡该有的方法外,由于我们可以选热饮或冷饮,热饮像咖啡我们可以加糖,或者冷饮我们可以加冰块。

所以,饮料接口必须有另外一个方法叫putAddition,如下:

namespace designpattern.cs.AbstracFactory
{
    public interface IDrink
    {
        void printName();
        void printCost();
        void putAddition();
    }
}

 

接下来,我们便可以设计汉堡和饮料的系列产品了。

汉堡类产品如下:

 

using System;

namespace designpattern.cs.AbstracFactory
{
    public class FishHamburger:IHamburger
    {
        public void printName()
        {
            Console.Write("Fish Hamburger : ");
        }

        public void printCost()
        {
            Console.WriteLine("$1.5");
        }
    }
}

using System;

namespace designpattern.cs.AbstracFactory
{
    public class ChickenHamburger : IHamburger
    {
        public void printName()
        {
            Console.Write("Chicken Hamburger : ");
        }

        public void printCost()
        {
            Console.WriteLine("$1.8");
        }
    }
}

using System;

namespace designpattern.cs.AbstracFactory
{
    public class SuperHamburger : IHamburger
    {
        public void printName()
        {
            Console.Write("Super Hamburger : ");
        }

        public void printCost()
        {
            Console.WriteLine("$2");
        }
    }
}

 

饮料类产品如下:

我们可以创建有糖或者无糖的咖啡,也可以创建加冰块或者不加冰块的可乐。

 

using System;

namespace designpattern.cs.AbstracFactory
{
    public class CoffeeWithoutSugar:IDrink
    {
        public void printName()
        {
            Console.Write("Coffee");
        }

        public void printCost()
        {
            Console.WriteLine("  $0.9");
        }

        public void putAddition()
        {
            Console.Write(" Without Sugar");
        }
    }
}

using System;

namespace designpattern.cs.AbstracFactory
{
    public class CoffeeWithSugar:IDrink
    {
        public void printName()
        {
            Console.Write("Coffee");
        }

        public void printCost()
        {
            Console.WriteLine("  $1");
        }

        public void putAddition()
        {
            Console.Write(" With Sugar");
        }
    }
}

using System;

namespace designpattern.cs.AbstracFactory
{
    public class CokeWithIce:IDrink
    {
        public void printName()
        {
            Console.Write("Coke");
        }

        public void printCost()
        {
            Console.WriteLine("  $0.8");
        }

        public void putAddition()
        {
            Console.Write(" With Ice");
        }
    }
}

using System;

namespace designpattern.cs.AbstracFactory
{
    public class CokeWithoutIce:IDrink
    {
        public void printName()
        {
            Console.Write("Coke");
        }

        public void printCost()
        {
            Console.WriteLine("  $0.8");
        }

        public void putAddition()
        {
            Console.Write(" Without Ice");
        }
    }
}

 

有了产品系列以后,我们可以构造一个抽象工厂接口,用于创建我们的订单,如下:

 

namespace designpattern.cs.AbstracFactory
{
    public interface OrderFactory
    {
        IHamburger createHamburger();
        IDrink createDrink();
    }
}

 

接下来,我们可以建立实体工厂类了,订单可能是各种可能的排列组合:

 

using System;

namespace designpattern.cs.AbstracFactory
{
    public class OrderA:IOrderFactory
    {
        public IHamburger createHamburger()
        {
            return new ChickenHamburger();
        }

        public IDrink createDrink()
        {
            return new CokeWithIce();
        }
    }
}

using System;

namespace designpattern.cs.AbstracFactory
{
    public class OrderB:IOrderFactory
    {
        public IHamburger createHamburger()
        {
            return new FishHamburger();
        }

        public IDrink createDrink()
        {
            return new CoffeeWithoutSugar();
        }
    }
}

using System;

namespace designpattern.cs.AbstracFactory
{
    public class OrderC:IOrderFactory
    {
        public IHamburger createHamburger()
        {
            return new SuperHamburger();
        }

        public IDrink createDrink()
        {
            return new CoffeeWithSugar();
        }
    }
}

 

 

最后,我们些个客户端,构建2份订单,如下:

 

using System;

namespace designpattern.cs.AbstracFactory
{
    public class ClientDemo1
    {
        static void Main(string[] args)
        {
            //Order A
            IHamburger food1;
            IDrink drink1;
            IOrderFactory orderA = new OrderA();
            food1 = orderA.createHamburger();
            drink1 = orderA.createDrink();
            Console.WriteLine("Your Order List:");
            Console.WriteLine("------------------------------------------------");
            food1.printName();
            food1.printCost();
            drink1.printName();
            drink1.putAddition();
            drink1.printCost();
            Console.WriteLine("------------------------------------------------");

            //Order C
            IHamburger food2;
            IDrink drink2;
            IOrderFactory orderC = new OrderC();
            food2 = orderC.createHamburger();
            drink2 = orderC.createDrink();
            Console.WriteLine("Your Order List:");
            Console.WriteLine("------------------------------------------------");
            food2.printName();
            food2.printCost();
            drink2.printName();
            drink2.putAddition();
            drink2.printCost();
            Console.WriteLine("------------------------------------------------");

            Console.ReadLine();
        }
    }
}

 

运行结果如下:

Your Order List:
------------------------------------------------
Chicken Hamburger  $1.8
Coke With Ice  $0.8
------------------------------------------------
Your Order List:
------------------------------------------------
Super Hamburger  $2
Coffee With Sugar  $1
------------------------------------------------

 

 

时间: 2024-09-20 18:52:51

工厂模式之三 - 抽象工厂(Abstract Factory)模式的相关文章

简单工厂、工厂方法、抽象工厂、策略模式、策略与工厂的区别

[本文转自简单工厂.工厂方法.抽象工厂.策略模式.策略与工厂的区别] 结合简单示例和UML图,讲解工厂模式简单原理. 一.引子 话说十年前,有一个爆发户,他家有三辆汽车(Benz(奔驰).Bmw(宝马).Audi(奥迪)),还雇了司机为他开车.不过,爆发户坐车时总是这样:上Benz车后跟司机说"开奔驰车!",坐上Bmw后他说"开宝马车!",坐上 Audi后他说"开奥迪车!".你一定说:这人有病!直接说开车不就行了?!而当把这个爆发户的行为放到我们

Java设计模式编程中的工厂方法模式和抽象工厂模式_java

工厂方法模式 动机 创建一个对象往往需要复杂的过程,所以不适合包含在一个复合工厂中,当有新的产品时,需要修改这个复合的工厂,不利于扩展. 而且,有些对象的创建可以需要用到复合工厂访问不到的信息,所以,定义一个工厂接口,通过实现这个接口来决定实例化那个产品,这就是工厂方法模式,让类的实例化推迟到子类中进行. 目的 1. 定义一个接口,让子类决定实例化哪个产品. 2. 通过通用接口创建对象. 实现 1. 产品接口和具体产品很好理解. 2. 工厂类提供一个工厂方法,返回一个产品对象.但是这个工厂方法是

java中简单工厂模式、工厂方法模式、抽象工厂模式介绍

工厂模式适合凡是出现大量对象需要创建,而且这些对象拥有相同的接口,可以使用工厂模式进行创建. 简单工厂模式 简单工厂模式分为三种:普通工厂模式.多个方法工厂模式.静态方法工厂模式 -------------------------------------------------------------------------------- 以发送QQ消息或者微信消息为例来说明: 普通工厂模式 /**  * 两种共同的接口  */ public interface Message {     pu

工厂模式与抽象工厂模式小览(二)

一.文章来由 就等啦~~还记得工厂模式与抽象工厂模式小览(一)第一部吗?我们在第一部中,分别详细的描述了(1)简单工厂(2)工厂模式(3)抽象工厂模式,但是并没有描述他们之间的关系,也没有比较工厂模式和抽象工厂模式,这对难舍难分的好基友之间的异同点,这些工作我们在第二部中完成~ 二.工厂模式和简单工厂 话说十年前,有一个暴发户,他家有三辆汽车--Benz奔驰.Bmw宝马.Audi奥迪,还雇了司机为他开车.不过,暴发户坐车时总是怪怪的:上Benz车后跟司机说"开奔驰车!",坐上Bmw后他

工厂模式、简单工厂模式和抽象工厂模式有什么区别和联系?

问题描述 这三者主要区别和联系是什么?谁可以简单的说下? 解决方案 解决方案二: 解决方案三:有什么区别?解决方案四:简单工厂模式和工厂方法模式之对比1.简单工厂模式将选择权交给了工厂,根据客户端的选择条件动态实例化相关的类:工厂方法模式将选择权交给了客户端,客户端需要哪一个产品,只需要实例化其对应的具体工厂.2.工厂方法模式相对简单工厂模式复杂性增加,但灵活性更高了.3.工厂方法克服了简单工厂违背开放-封闭原则的缺点.4.两者都降低了客户端与具体类的耦合.5.工厂方法模式是简单工厂模式的进一步

轻松掌握Java工厂模式、抽象工厂模式_java

在面向对象编程的程序设计中,我们最常见的操作就是new对象,但在创建一个新对象的过程中,会有一些问题,比如我们需要注意创建新对象的实现细节,初始化一些必要的参数等.这样会让我们在讲更多的心思放在对象的创建上,而不是程序逻辑的实现上,严重拖延了我们的程序开发效率.工厂模式和抽象工厂模式的出现则完美解决了这个问题,让我们不再关心对象的创建,更多的在重心放在业务的实现上. 特点:     1.程序员直接通过工厂方法创建对象,不再关注创建对象的细节.     2.隐藏对象的实现细节,也有利于程序的安全性

设计模式的解析和实现(C++)之二-Abstract Factory模式

作用: 提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类. UML结构图: 抽象基类: 1)ProductA,ProductB:分别代表不同类型的产品,而它们的派生类则是这种产品的一个实现. 2)AbstractFactory:生产这一系列产品的一个抽象工厂,它的派生类是不同的实现. 接口函数: 1)AbstractFactory::CreateProductA和AbstractFactory::CreateProductB:分别是生产不同产品的不同的实现,由各个派生出来的抽象

Design Pattern: Abstract Factory 模式

原文地址:http://www.riabook.cn/doc/designpattern/AbstractFactory.htm 假设您要制作一个对话方块(Dialog)元件,您希望的是这个对话方块可以有不同的视感(Look-and- feel),最基本的想法是,藉由Setter将不同视感的元件设定给这个对话方块,例如: CustomDialog.java public class CustomDialog { private IButton button; private ITextField

简单工厂、工厂方法、抽象工厂模式

           最近一直再将设计模式,于是趁热打铁,对这三种设计模式做一个总结.           首先我先用一句话总结一下这三个模式:简单工厂是一个工厂只能造一种奔驰,工厂方法是一个工厂可以造多种车,比如劳斯莱斯.奥迪等,而抽象工厂是说工厂不光可以造越野式奔驰,还可以造家用式奔驰.还有商用式奔驰.            那么究竟简单工厂是什么呢?为什么它不是23的设计模式中的一个?            用一个类图和一段代码我们来解释一下: