文章目录
  1. 1. 一、前言
  2. 2. 二、简单工厂模式
  3. 3. 三、工厂方法模式
  4. 4. 四、抽象工厂模式
  5. 5. 五、总结

一、前言

同样在上班的路上,一个程序员想着是买梅干菜肉包还是买酸辣粉丝包,到了包子点 却发现只有馒头馅子的包子了,却买了一包豆浆;一个程序员可能在在家吃完饭开车 去上班了,这尼玛是富二代;一个程序员可能想着如何把自己的代码如何优化,如何 提高性能,如何的如何……上班路上的程序员让你轻松了解三个设计模式

二、简单工厂模式

简单工厂模式(Simple Factory Pattern):又称为静态工厂方法(Static Factory Met hod)模式,它属于类创建型模式。在简单工厂模式中,可以根据参数的不同返回不同 类的实例。简单工厂模式专门定义一个类来负责创建其他类的实例,被创建的实例通 常都具有共同的父类。简单工厂模式就好比一个是一个富二代程序员,你要什么,简 单工厂就给你什么。简单工厂模式包括三个角色:抽象产品角色,具体产品角色,工 厂角色代码实现如下:

//抽象产品角色:交通工具车
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;

    }
}

客户端调用代码:

//根据客户端传入的参数简单工厂决定如何去上班
Car car = SimpleFactory.CreateSimple("Bus");
car.GoToWork();

三、工厂方法模式

工厂方法模式(Factory Method Pattern)又称为工厂模式,也叫虚拟构造器(Virtual Constructor)模式或者多态工厂(Polymorphic Factory)模式,它属于类创建型模式 。在工厂方法模式中,工厂父类负责定义创建产品对象的公共接口,而工厂子类则负 责生成具体的产品对象,这样做的目的是将产品类的实例化操作延迟到工厂子类中完 成,即通过工厂子类来确定究竟应该实例化哪一个具体产品类。工厂方法模式包括四 个角色:抽象产品角色,具体产品角色,抽象工厂角色,具体工厂角色具体示例代码 实现如下:

//抽象产品角色:交通工具车
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 factory = new BusFactory();   //常规写法            //反射优化  (BusFactory)Assembly.Load("当前程序集名称").CreateInstance("当前命名空间名称.要实例化的类名")            //using System.Reflection; 引用命名空间            //var factoryName = "BusFactory";            //IFactory factory = (BusFactory) Assembly.Load("当前程序集名称").CreateInstance("当前命名空间名称." + factoryName);            
Car car = factory.ByWhatWay();
car.GoToWork();

四、抽象工厂模式

抽象工厂模式(Abstract Factory Pattern):提供一个创建一系列相关或相互依赖对 象的接口,而无须指定它们具体的类。抽象工厂模式又称为Kit模式,属于对象创建型 模式。抽象工厂模式包括四个角色:抽象产品角色,具体产品角色,抽象工厂角色, 具体工厂角色具体示例代码如下:

//抽象交通工具车
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()+"去上班");
    }
}

客户端调用:

AbstractFactory factory=new HighFactory();
CoderLove coder=new CoderLove(factory);
coder.GetCoderLove();

抽象工厂模式隔离了具体类的生成,使得客户并不需要知道什么被创建。由于这种隔 离,更换一个具体工厂就变得相对容易。所有的具体工厂都实现了抽象工 厂中定 义的那些公共接口,因此只需改变具体工厂的实例,就可以在某种程度上改变 整 个软件系统的行为。除了以上苦逼程序员,高逼格程序员,还可以具体添加一个开 车SUV吃着包子豆浆的具体工厂,也可以添加骑着自行车吃着三明治牛奶的具体工厂 。

五、总结

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

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

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

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

示例代码下载:https://yunpan.cn/cY8cctUs7pXSb (提取码:157b)

博客地址:http://www.cnblogs.com/yinrq/


本文出处程序员头条:http://www.iswifting.com/2016/03/27/work-code-factory-way/
转载请在开头注明本文出处。

欢迎关注本站微信公众号:为程序员提供最优质的博文、最精彩的讨论、最实用的开发资源;提供最新最全的编程学习资料:PHP、Objective-C、Java、Swift、C/C++函数库、.NET Framework类库、J2SE API等等.并不定期奉送各种福利.
微信公众号猿圈:CodePush

文章目录
  1. 1. 一、前言
  2. 2. 二、简单工厂模式
  3. 3. 三、工厂方法模式
  4. 4. 四、抽象工厂模式
  5. 5. 五、总结