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

简介: 抽象工厂(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
------------------------------------------------

 

 

目录
相关文章
|
3月前
|
设计模式
设计模式-工厂模式 Factory Pattern(简单工厂、工厂方法、抽象工厂)
这篇文章详细解释了工厂模式,包括简单工厂、工厂方法和抽象工厂三种类型。每种模式都通过代码示例展示了其应用场景和实现方法,并比较了它们之间的差异。简单工厂模式通过一个工厂类来创建各种产品;工厂方法模式通过定义一个创建对象的接口,由子类决定实例化哪个类;抽象工厂模式提供一个创建相关或依赖对象家族的接口,而不需要明确指定具体类。
设计模式-工厂模式 Factory Pattern(简单工厂、工厂方法、抽象工厂)
|
7月前
|
设计模式 Java 数据库连接
Java设计模式--简单工厂、工厂方法和抽象工厂之间的区别
设计模式中的工厂模式(Factory Design pattern)是一个比较常用的创建型设计模式,其中可以细分为三种:简单工厂(Simple Factory)、工厂方法(Factory Method)和抽象工厂(Abstract Factory)。那么三者有什么区别呢?
165 1
Java设计模式--简单工厂、工厂方法和抽象工厂之间的区别
|
设计模式 Java uml
Java设计模式-抽象工厂模式Abstract Factory
Java设计模式-抽象工厂模式Abstract Factory
|
设计模式
一文搞懂设计模式--抽象工厂(Abstract Factory)
一文搞懂设计模式--抽象工厂(Abstract Factory)
112 0
|
设计模式 安全 Java
设计模式学习(九):Abstract Factory抽象工厂模式
Abstract的意思是“抽象的”,Factory的意思是“工厂”。在Abstract Factory模式中,不仅有“抽象工厂”,还有“抽象零件”和“抽象产品”。抽象工厂的工作是将“抽象零件”组装为“抽象产品”。
设计模式学习(九):Abstract Factory抽象工厂模式
|
设计模式
《一天一个设计模式》----抽象工厂模式(Abstract Factory)
《一天一个设计模式》----抽象工厂模式(Abstract Factory)
137 0
《一天一个设计模式》----抽象工厂模式(Abstract Factory)
|
设计模式
【愚公系列】2021年12月 二十三种设计模式(二)-抽象工厂模式(Abstract Factory Pattern)
【愚公系列】2021年12月 二十三种设计模式(二)-抽象工厂模式(Abstract Factory Pattern)
111 0
【愚公系列】2021年12月 二十三种设计模式(二)-抽象工厂模式(Abstract Factory Pattern)
|
设计模式 Java
JAVA设计模式(02):创建型-抽象工厂模式(Abstract Factory)
转自:http://blog.csdn.net/lovesomnus/article/details/23672625
151 0
JAVA设计模式(02):创建型-抽象工厂模式(Abstract Factory)
|
Windows 设计模式
设计模式四: 抽象工厂(Abstract Factory)
简介 抽象工厂模式是创建型模式的一种, 与工厂方法不同的是抽象工厂针对的是生产一组相关的产品, 即一个产品族. 抽象工厂使用工厂方法模式来生产单一产品, 单一产品的具体实现分别属于不同的产品族. 抽象工厂即是对产品族的抽象.
1938 0