设计模式--Abstract Factory抽象工厂模式

  有这样一种场景：世界杯外围赛，有资格参加比赛的国家都会派出自己的球队。我们可以将每个国家的球队看成是一组系列化的对象，因为在这一支球队中，有领 队，教练，球员等角色，每一种角色都是一类对象。而每个国家派出的球队都有这些固定的角色。但不同的球队这些角色的具体对象又不一样。
  这就是抽象工厂适用的情景:提供一个创建一系列（上面的一个球队就是一个系列）相关或相互依赖对象(球队中的领队，教练，球员之间就是相关和相互依赖的关系)的接口，而无需指定它们具体的类(指不用直接定义和创建每一个具体的球队)。所以，它针对的的产品系列的情况。
  下面，我们就来实现抽象工厂。
  程序如下图:
                          
  抽象工厂的参考者，也就是该模式中的各个类或对象之间的关系：

 

抽象产品（Abstract Product）：为这一系列的某一种产品声明接口 
抽象工厂（Abstract Factory)：声明生成一系列抽象产品的方法 
具体产品（Product）：定义具体工厂生成的具体产品的对象，实现产品接口 
具体工厂（Concrete Factory）：执行生成一系列抽象产品的方法，生成一系列具体的产品 
客户（Client）：我们的应用程序客户端（不要理解成人），使用抽象产品和抽象工厂生成对象。 

 一、定义抽象产品类，这里我们定义了球队各成员的抽象产品类AbstractTeam

using  System;
using  System.Collections.Generic;
using  System.Linq;
using  System.Text;

namespace  MyAbstractFactory
{
   // 定义产品系列中的各个抽象产品角色，其作用是为这一系列的各种产品声明接口 
    //在本例就是定义一个球队(产品系列)中的各个成员(各种产品)角色的声明接口

    定义领队--抽象产品类 定义领队--抽象产品类
   public  abstract class Leader
   {
       public abstract void LeaderWorkMethod(); //领队的工作方式
   }
    #endregion

     定义教练--抽象产品类  定义教练--抽象产品类
    public  abstract  class  Coach
    {
       public abstract void CoachWorkMethod(); //教练的工作方式
   }
     #endregion

     定义球员--抽象产品类  定义球员--抽象产品类
    public  abstract  class  Players
    {
       public abstract void PlayerWorkMethod(); //球员的工作方式
   }
     #endregion

}

 二、定义抽象工厂类,这里我们定义了球队的抽象工厂类AbstractCreateTeamFactory

using  System;
using  System.Collections.Generic;
using  System.Linq;
using  System.Text;

namespace  MyAbstractFactory
{
     //  抽象工厂（Abstract Factory）角色：担任这个角色的是工厂方法模式的核心，它是与应用系统商业逻辑无关的。它负责声明生成一系列抽象产品的方法 

     // 本例就是负责声明生成球队这个系列中各个抽象产品(其内的领队，教练和球员)的方法

    public  abstract    class  AbstractCreateTeamFactory
    {
         public  abstract  Leader  CreateLeader();  // 生成领队的方法
         public  abstract  Coach CreateCoach();  // 生成教练的方法
         public  abstract  Players CreatePlayer(); // 生成球员的方法
    }
}

 三、定义具体产品类，这里我们定义了中国队ChinaTeam和澳大利亚队AustraliaTeam两个队

中国队ChinaTeam

using  System;
using  System.Collections.Generic;
using  System.Linq;
using  System.Text;

namespace  MyAbstractFactory
{
   // 具体产品（Product）定义具体工厂生成的具体产品的对象，实现产品接口 
   // 这里定义了中国队这个具体系列中的各个成员(领队，教练，球员)的具体产品对象并实现对应抽象类的接口。

    定义领队--抽象类 定义领队--抽象类
    public  class ChinaLeader:Leader 
    {
        public override  void LeaderWorkMethod(){} //中国队领队的工作方式
    }
    #endregion

     定义教练--抽象类  定义教练--抽象类
     public  class  ChinaCoach:Coach 
     {
        public override void CoachWorkMethod() { } //中国队教练的工作方式
    }
     #endregion

     定义球员--抽象类  定义球员--抽象类
     public  class  ChinaPlayer:Players
     {
        public override void PlayerWorkMethod() { } //中国队球员的工作方式
    }
     #endregion
}

澳大利亚队AustraliaTeam

using  System;
using  System.Collections.Generic;
using  System.Linq;
using  System.Text;

namespace  MyAbstractFactory
{
    // 具体产品（Product）定义具体工厂生成的具体产品的对象，实现产品接口 
    // 这里定义了澳大利亚队这个具体系列中的各个成员(领队，教练，球员)的具体产品对象并实现对应抽象类的接口。

    定义领队--抽象类 定义领队--抽象类
    public class AustraliaLeader : Leader
    {
        public override void LeaderWorkMethod() { } //澳大利亚队领队的工作方式
    }
    #endregion

     定义教练--抽象类  定义教练--抽象类
     public  class  AustraliaCoach : Coach
     {
        public override void CoachWorkMethod() { } //澳大利亚队教练的工作方式
    }
     #endregion

     定义球员--抽象类  定义球员--抽象类
     public  class  AustraliaPlayer : Players
     {
        public override void PlayerWorkMethod() { } //澳大利亚队球员的工作方式
    }
     #endregion
}

 四、定义具体工厂类,这里我们定义了中国队具体工厂ChinaTeamFactory和澳大利亚队具体工AustraliaTeamFactory厂
中国队ChinaTeamFactory

using  System;
using  System.Collections.Generic;
using  System.Linq;
using  System.Text;

namespace  MyAbstractFactory
{
    class ChinaTeamFactory:AbstractCreateTeamFactory
    {
        生成领队的方法 生成领队的方法
        public override  Leader CreateLeader()
        {
            Console.WriteLine("生成中国队领队");
            return new ChinaLeader();

        }
        #endregion
        生成教练的方法 生成教练的方法
        public override Coach CreateCoach()
        {
            Console.WriteLine("生成中国队教练");
            return new ChinaCoach();
        }
        #endregion 

         生成球员的方法  生成球员的方法
         public  override  Players CreatePlayer()
         {
            Console.WriteLine("生成中国队球员");
            return new ChinaPlayer();
        }
         #endregion

    }

}

澳大利亚队AustraliaTeamFactory

using  System;
using  System.Collections.Generic;
using  System.Linq;
using  System.Text;

namespace  MyAbstractFactory
{
    class AustraliaTeamFactory:AbstractCreateTeamFactory 
    {
        生成领队的方法 生成领队的方法
        public override Leader CreateLeader()
        {
            Console.WriteLine("生成澳大利亚领队");
            return new AustraliaLeader();
        }
        #endregion
        生成教练的方法 生成教练的方法
        public override Coach CreateCoach()
        {
            Console.WriteLine("生成澳大利亚教练");
            return new AustraliaCoach();
        }
        #endregion

         生成球员的方法  生成球员的方法
         public  override  Players CreatePlayer()
         {
            Console.WriteLine("生成澳大利亚球员");
            return new AustraliaPlayer();
        }
         #endregion
    }
}

 五、TeamsCreater

using  System;
using  System.Collections.Generic;
using  System.Linq;
using  System.Text;

namespace  MyAbstractFactory
{
    class TeamsCreater
    {
        AbstractCreateTeamFactory   teamCreatureFactory;  // 
        Leader  leader;
        Coach  coach;
        Players player;

        public  TeamsCreater()
        {
        }

        public TeamsCreater(AbstractCreateTeamFactory pteamCreatureFactory)
        {
            this.teamCreatureFactory = pteamCreatureFactory;
        }

        public void FormTeamsCreature()
        {
            Console.WriteLine("现在生成的球队各成员分别是:");
            leader = teamCreatureFactory.CreateLeader();
            coach = teamCreatureFactory.CreateCoach();
            player = teamCreatureFactory.CreatePlayer();
        }
    }
}

 

 六、客户端应用抽象工厂

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace MyAbstractFactory
{
    class Program
    {
        static void Main(string[] args)
        {

            //我们的应用程序客户端（不要理解成人），使用抽象产品和抽象工厂生成对象。 

            生成中国球队 生成中国球队
            AbstractCreateTeamFactory teamfactory = (AbstractCreateTeamFactory)new ChinaTeamFactory();
            TeamsCreater tc = new TeamsCreater(teamfactory);

            tc.FormTeamsCreature();
            #endregion

            生成澳大利亚球队 生成澳大利亚球队
            teamfactory = (AbstractCreateTeamFactory)new AustraliaTeamFactory();
            tc = new TeamsCreater(teamfactory);
            tc.FormTeamsCreature();
            Console.Read();
            #endregion
        }
    }
}

 运行效果如下:
                        

前往：设计模式学习笔记清单