(转)工厂模式的三种情形

一、前言

同样在上班的路上,一个程序员想着是买梅干菜肉包还是买酸辣粉丝包,到了包子点却发现只有馒头馅子的包子了,却买了一包豆浆;

一个程序员可能在在家吃完饭开车去上班了,这尼玛是富二代;

一个程序员可能想着如何把自己的代码如何优化,如何提高性能,如何的如何……

上班路上的程序员让你轻松了解三个设计模式

二、简单工厂模式

简单工厂模式(Simple Factory Pattern):又称为静态工厂方法(Static Factory Method)模式,它属于类创建型模式。在简单工厂模式中,可以根据参数的不同返回不同类的实例。简单工厂模式专门定义一个类来负责创建其他类的实例,被创建的实例通常都具有共同的父类。

简单工厂模式就好比一个是一个富二代程序员,你要什么,简单工厂就给你什么。

简单工厂模式包括三个角色:抽象产品角色,具体产品角色,工厂角色

代码实现如下:

    //抽象产品角色:交通工具车
    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、抽象工厂模式最常见的情况是一套程序需要多套数据实现的情况下

进阶:依赖注入和控制反转(参考spring的核心思想)

时间: 2024-10-08 10:06:49

(转)工厂模式的三种情形的相关文章

工厂模式(综合三种)

软件领域中的设计模式为开发人员提供了一种使用专家设计经验的有效途径.设计模式中运用了面向对象编程语言的重要特性:封装.继承.多态,真正领悟设计模式的精髓是可能一个漫长的过程,需要大量实践经验的积累.最近看设计模式的书,对于每个模式,用C++写了个小例子,加深一下理解.主要参考<大话设计模式>和<设计模式:可复用面向对象软件的基础>两本书.本文介绍工厂模式的实现. 工厂模式属于创建型模式,大致可以分为三类,简单工厂模式.工厂方法模式.抽象工厂模式.听上去差不多,都是工厂模式.下面一个

Android 工厂模式,三种工厂模式的理解

工厂模式是一种创建者模式,在任何生成复杂对象的地方都可以使用工厂模式.理论来说在任何使用A a = new A()的方式都可以使用工厂模式,虽然使用工厂模式可能需要多做一些工作,但是在后续的开发和维护都带来了方便. 如果我们需要在构建对象的时候,需要做很多的处理工作,比如初始化工作,查询工作等一些耗时的工作,如果我们将这些操作全部放入到构造方法中去写,那么势必在后期维护的带来不方便,而且始化工作如果是很长一段代码,说明要做的工作很多,将很多工作装入一个方法中,相当于将很多鸡蛋放在一个篮子里,是很

MVC学习之数据库开发模式:三种开发模式总结:

先介绍下三种开发模式的使用方法: 1.数据库优先: 数据库开发之:数据库优先主要步骤: 1.在数据库中建立好数据库和所需要得到表 2.选中Models文件夹,添加新项目--数据--ADO.NET实体数据模型……在生成数据库页面选着从数据库中生成 在完成2之后,会在web.config里面自动生成数据库连接字符串 3.创建控制器和对应的视图页面 4.在控制器中创建数据上下文实例对象,该对象是通过连接数据库字符串的名字来创建的. 2.代码优先: 数据库开发之代码优先步骤: 1.在Models文件夹中

Linux进入root模式的三种方法

首先打开终端(Ctrl+Alt+T) 在这里解释一下[email protected]:~$这句话的含义: bwj是用户名,也就是你自己起的名字. @是分割的符号 ubuntu是主机名,也就是你所使用的机器的名称 ~是当前目录,"~"表示根目录 $是提示符,当进入root时,会变成# 现在开始介绍第一种方法:sudo(暂时的) 输入sudo后显示了可以输入的指令 sudo -b:在后台执行指令 -h:帮助 -H:将HOME环境变量设为新身份的HOME环境变量 -k:结束密码的有效期限,

Android启动模式(三种)

1,标准启动模式 通过任务栈,每点一次button,将每一个实例都压入,然后点返回键时候,就弹出之前压入的实例. 测试代码:通过创建一个button和textView来显示本身的TastId和实例的ID 1 public class MainActivity extends AppCompatActivity { 2 3 private TextView tv; 4 @Override 5 protected void onCreate(Bundle savedInstanceState) {

java 责任链模式的三种实现

责任链模式 责任链模式的定义:使多个对象都有机会处理请求,从而避免请求的发送者和接受者之间的耦合关系, 将这个对象连成一条链,并沿着这条链传递该请求,直到有一个对象处理他为止.这里就不再过多的介绍什么是责任链模式,主要来说说java中如何编写.主要从下面3个框架中的代码中介绍. servlet中的filter dubbo中的filter mybatis中的plugin 这3个框架在实现责任链方式不尽相同. servlet中的Filter servlet中分别定义了一个 Filter和Filter

生产者消费者模式的三种实现方式

synchronized版本 public class Test { public static void main(String[] args) { Shared s = new Shared(); Thread t1 = new Thread(new Product(s)); Thread t2 = new Thread(new Consumer(s)); t1.start(); t2.start(); } } class Product implements Runnable { priv

三种工厂模式(转)

资源:http://download.csdn.net/detail/zhangerqing/4835830 原文链接:http://blog.csdn.net/zhangerqing 工厂模式分为三种:普通工厂方法模式,静态工厂模式,抽象工厂模式: 11.普通工厂模式,就是建立一个工厂类,对实现了同一接口的一些类进行实例的创建.首先看下关系图: 举例如下:(我们举一个发送邮件和短信的例子) 首先,创建二者的共同接口: [java] view plaincopy public interface

设计模式一:工厂模式

注:第二篇章讲的是设计模式,主要是LZ对<大话设计模式>这书的记录,以及一些简单例子. 首先工厂模式分为三种:简单工厂模式.工厂方法模式.抽象工厂模式.下面分别介绍这三种模式. 一:简单工厂模式 简单工厂模式的实质是由一个工厂类根据传入的参数,动态决定应该创建哪一个种类(这些种类继承自一个父类或接口)的实例.如上面AnimalFactory是工厂类,Animal类是父类,Bird.Dog都是种类,因此如果要在加一个Pig类,只需要继承父类,并在工     类种加入类型判断即可.代码如下: //