设计模式之简单工厂、工厂方法、抽象工厂

     设计模式书籍目前身边有的是《Head First 设计模式》、《大话设计模式》，其中也阅读过多人对设计模式的看法，其中谈论过"不可过度设计模式"，若只阅读该类书籍不做实际项目很难记得模式的灵活运用。故而，将设计模式的各类情况一一记录，以作学习。

一、简单工厂模式

先贴代码如下：

  //抽象产品角色：交通工具车
   public abstract class Car
    {
        public virtual void GoToWork()
        {
        }
    }

    //具体产品角色：自行车
   public class Bike : Car
    {
        public override void GoToWork()
        {
           Console.WriteLine("骑自行车去上班");
        }
    }
    //具体产品角色：公交车
   public class Bus : Car
    {
        public override void GoToWork()
        {
            Console.WriteLine("做公交车去上班");
        }
    }
    //工厂角色：简单工厂类
   public class SimpleFactory
    {
        public static Car CreateSimple(string str)
        {
            Car simple = null;
            switch (str)
           {
                case "Bike":
                    simple = new Bike();
                    break;
                case "Bus":
                    simple = new Bus();
                    break;
                //……
            }
            return simple;

        }
    }

针对上面代码绘制结构图：

其中SampleFactory 类实现了对没类继承类的对象创建。

简单工厂模式包括三个角色：抽象产品角色、具体产品角色、工厂角色。

客户端实现代码：

Car car=SampleFactory.CreateSimple("Bus");

car.GoToWork();

二、工厂方法模式

代码如下：

    //抽象产品角色：交通工具车
    public abstract class Car
    {
        public virtual void GoToWork()
        {
        }

    }

    //具体产品角色：自行车
    public class Bike : Car
    {
        public override void GoToWork()
        {
            Console.WriteLine("骑自行车去上班");
        }
    }
    //具体产品角色：公交车
    public class Bus : Car
    {
        public override void GoToWork()
        {
            Console.WriteLine("做公交车去上班");
        }
    }

    //抽象工厂角色：工厂接口
    public interface IFactory
    {
        Car ByWhatWay();
    }
    //具体工厂类：自行车类
    public class BikeFactory : IFactory
    {
        public Car ByWhatWay()
        {
            return new Bike();
        }
    }
    //具体工厂类：公交车类
    public class BusFactory : IFactory
    {
        public Car ByWhatWay()
        {
            return new Bus();
        }

    }

 

结构图如下：

其中IFactory是接口父类，BikeFactory 和BusFactory两个类实现了对new Bike() 和new Bus()对象的实现。

工厂方法模式包括四个角色：抽象产品角色、具体产品角色、抽象工厂角色、具体工厂角色。

客户端实现代码：

//根据客户端实例化的工厂决定如何去上班
//常规写法
IFactory factory=new BusFactory();
//反射优化
//IFactoyr factory=(BusFactoyr)Assembly.Load("当前程序集名称").CreateInstance("当前命名空间名称。要实例化的类名")
//using System.Reflection; 引用命名空间
Car car=factory.ByWhatWay();
car.GoToWork();

三、抽象工厂模式

代码如下：

    //抽象交通工具车
    public abstract class Car
    {
        //名字
        public string CarName { get; set; }
        public virtual string GoToWork()
        {
            return CarName;
        }

    }
    //抽象早饭类
    public abstract class BreakFast
    {
        //早饭名称
        public string FoodName { get; set; }

        public virtual string Eat()
        {
            return FoodName;
        }
    }

    //自行车
    public class Bike : Car
    {
        public override string GoToWork()
        {
            CarName = "骑着自行车";
            return CarName;
        }
    }
    //公交车
    public class Suv : Car
    {
        public override string GoToWork()
        {
            CarName = "开着SUV汽车";
            return CarName;
        }
    }

    //高逼格早饭：三明治牛奶
    public class SandWichAndMilk : BreakFast
    {
        public override string Eat()
        {
            FoodName = "三明治和牛奶";
            return FoodName;
        }
    }

    //苦逼早饭：包子豆浆
    public class BaoziAndDoujiang : BreakFast
    {
        public override string Eat()
        {
            FoodName = "包子豆浆";
            return FoodName;
        }
    }

    //抽象工厂类
    public abstract class AbstractFactory
    {
        //创建交通工具方法
        public abstract Car CreatCar();

        //创建早饭方法
        public abstract BreakFast CreateBreakFast();

    }

    //具体工厂类
    public class LowFactory : AbstractFactory
    {
        public override Car CreatCar()
        {
            return new Bike();
        }

        public override BreakFast CreateBreakFast()
        {
            return new BaoziAndDoujiang();
        }
    }
    //具体工厂类
    public class HighFactory : AbstractFactory
    {
        public override Car CreatCar()
        {
            return new Suv();
        }

        public override BreakFast CreateBreakFast()
        {
            return new SandWichAndMilk();
        }
    }

    public class CoderLove
    {
        private Car car;
        private BreakFast breakFast;
        public CoderLove(AbstractFactory fac)
        {
            car = fac.CreatCar();
            breakFast = fac.CreateBreakFast();
        }

        public void GetCoderLove()
        {
            Console.WriteLine("早饭吃完" + breakFast.Eat() + "," + car.GoToWork() + "去上班");
        }
    }

结构图如下：

 

其中抽象工厂模式（Kit模式）包括四个角色：抽象产品角色、具体产品角色、抽象工厂角色、具体工厂角色

客户端调用：

//抽象工厂模式
AbstractFactory factory = new HighFactory();
CoderLove coder = new CoderLove(factory);
coder.GetCoderLove();

总结：

1.这三个模式都属于对象创建型模式。

2.简单工厂模式简单的理解为客户端告诉工厂他想要什么实例，工厂就生产什么实例。

3.工厂方法模式可以理解客户端有了创建实例的机器，他想要什么实例就自己生产什么实例。

4.抽象工厂模式最常见的情况是一套程序需要多套数据实现的情况下。

 

本文抄录并增加了而自己的一个结构图：原文作者是 http://www.cnblogs.com/yinrq/