设计模式工厂模式 AbstractFactory(抽象工厂)

工厂模式是对现实生活中工厂的一种高度抽象，它是由一系列的接口(抽象类)架构起来的，是和具体实体类相分离的。

AbstractFactory是工厂的基类，所有工厂都继承自他，他可以生产各种产品。

AbstractProduct是产品的基类，所有实体类都继承自他。

Client是与用户交互的。

示例代码：

根据创建工厂模式的先后顺序创建一下类：

1.AbstractCar(AbstractProductA) and AbstractBicyle(AbstractProductB)

public abstract class AbstractBicycle
    {
        public abstract void ShowSelfType(AbstractBicycle bicycle);
    }

 public abstract class AbstractCar
    {
        public abstract void ShowSelfType(AbstractCar car);
    }

2.创建抽象工厂，包含抽象的创建实例的方法(生产产品的方法)

public abstract class AbstractFactory
    {
        public abstract AbstractCar CreateAbstractCar();
        public abstract AbstractBicycle CreateAbstractBicycle();
    }

3.创建分工厂

    public class NewAbstractFactory : AbstractFactory
    {
        public override AbstractCar CreateAbstractCar()
        {
            return new NewCar();
        }

        public override AbstractBicycle CreateAbstractBicycle()
        {
            return new NewBicycle();
        }
    }

    public class OldAbstractFactory : AbstractFactory
    {
        public override AbstractCar CreateAbstractCar()
        {
            return new OldCar();
        }

        public override AbstractBicycle CreateAbstractBicycle()
        {
            return new OldBicycle();
        }
    }

4.创建实际的产品（最终的实体类）

 public class OldCar : AbstractCar
    {
        public override void ShowSelfType(AbstractCar car)
        {
            Console.WriteLine(car.GetType().Name);
        }
    }

    public class NewCar : AbstractCar
    {
        public override void ShowSelfType(AbstractCar car)
        {
            Console.WriteLine(car.GetType().Name);
        }
    }

    public class NewBicycle : AbstractBicycle
    {
        public override void ShowSelfType(AbstractBicycle bicycle)
        {
            Console.WriteLine(bicycle.GetType().Name);
        }
    }

    public class OldBicycle : AbstractBicycle
    {
        public override void ShowSelfType(AbstractBicycle bicycle)
        {
            Console.WriteLine(bicycle.GetType().Name);
        }
    }

5.创建Client(给用户的客户端)

    public class Client
    {
        private AbstractBicycle AbstractBicycle;
        private AbstractCar AbstractCar;

        public Client(AbstractFactory factory)
        {
            AbstractBicycle = factory.CreateAbstractBicycle();
            AbstractCar = factory.CreateAbstractCar();
        }

        public void Run()
        {
            AbstractBicycle.ShowSelfType(AbstractBicycle);
            AbstractCar.ShowSelfType(AbstractCar);
        }
    }

6.运行

    class Program
    {
        static void Main(string[] args)
        {
            AbstractFactory oldFactory = new OldAbstractFactory();
            AbstractFactory newFactory = new NewAbstractFactory();

            Client c1 = new Client(oldFactory);
            Client c2 = new Client(newFactory);

            c1.Run();
            c2.Run();

            Console.Read();

        }
    }

7.运行结果

感觉是不是很神奇啊，这主要利用的是面向对象编程语言的继承特性。慢慢体会吧！