设计模式—三个工厂

前言

简单工厂、工厂方法、抽象工厂。后边两个是创建型设计模式。
它们主要区别就是创建对象，实例化过程。根据结构图、代码实现来做对比。

内容

1、简单工厂
     结构图：

     代码实现：

          工厂类：

public  class OperationFactory
    {
        public static Operation createOperate(string operate)
        {
            Operation oper = null;
            switch (operate)
            { 
                case "+":
                    oper=new OperationAdd ();
                    break ;
                case "-":
                    oper = new OperationSub();
                    break;
                case "*":
                    oper = new OperationMul();
                    break;
                case "/":
                    oper = new OperationDiv();
                    break;
            }
            return oper;
        }
    }

          客户端：

class Program
    {
        static void Main(string[] args)
        {
            Operation oper;
            oper = OperationFactory.createOperate("+");
            oper.NumberA = 1;
            oper.NumberB = 2;
            double result = oper.GetResult();
            Console.Write(result);
            Console.Read();
        }
    }

根据客户端选择的条件工厂类动态的创建相对应的对象。

2、工厂方法

     结构图：

     代码实现：

          工厂接口：

interface IFactory
    {
        Operation CreateOperation();
    }

          加减乘除类们：

class AddFactory:IFactory 
    {
        public Operation CreateOperation()
        {
            return new OperationAdd();
        }
    }

class SubFactory:IFactory 
    {
        public Operation CreateOperation()
        {
            return new OperationSub();
        }
    }

class MulFactory:IFactory 
    {
        public Operation CreateOperation()
        {
            return new OperationMul();
        }
    }

class DivFactory:IFactory 
    {
        public Operation CreateOperation()
        {
            return new OperationDiv();
        }
    }

          客户端：

class Program
    {
        static void Main(string[] args)
        {
            IFactory operFactoru = new AddFactory();
            Operation oper = operFactoru.CreateOperation();
            oper.NumberA = 1;
            oper.NumberB = 2;
            double result = oper.GetResult();
            Console.Write(result);
            Console.Read();
        }
    }

定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。

3、抽象工厂
     结构图：

     代码实现：
          工厂接口类：

interface IFactory
    {
        IUser CreateUser();
        IDepartment CreateDepartment();
    }

          访问SQL server、Access数据库的类：

class SqlServerFactory:IFactory 
    {
        public IUser CreateUser()
        {
            return new sqlserverUser();
        }   

        public IDepartment CreateDepartment()
        {
            return new SqlserverDepartment();
        }
    }

class AccessFactory:IFactory 
    {
        public IUser CreateUser()
        {
            return new AccessUser();
        }

        public IDepartment CreateDepartment()
        {
            return new AccessDepartment();
        }
    }

          客户端：

class Program
    {
        static void Main(string[] args)
        {
            User user = new User();
            Deparment dept = new Deparment();

            IFactory factory = new AccessFactory();

            IUser iu = factory.CreateUser();

            iu.Insert(user);
            iu.GetUser(1);

            IDepartment id = factory.CreateDepartment();
            id.Insert(dept);
            id.GetDepartment(1);

            Console.Read();

        }
    }

总结

     简单工厂：

          优点：简单工厂模式能够根据外界给定的信息，决定究竟应该创建哪个具体类的对象。明确区分了各自的职责和权力，有利于整个软件体系结构的优化。
          缺点：很明显工厂类集中了所有实例的创建逻辑，容易违反高内聚的责任分配原则。

     工厂方法：

          优点：子类提供挂钩。基类为工厂方法提供缺省实现，子类可以重写新的实现，也可以继承父类的实现。
          屏蔽产品类。产品类的实现如何变化，调用者都不需要关心，只需关心产品的接口，只要接口保持不变，系统中的上层模块就不会发生变化。
          典型的解耦框架。高层模块只需要知道产品的抽象类，其他的实现类都不需要关心，符合迪米特法则，符合依赖倒置原则，符合里氏替换原则。
          多态性：客户代码可以做到与特定应用无关，适用于任何实体类。

     抽象工厂：

          优点：
抽象工厂模式隔离了具体类的生产，使得客户并不需要知道什么被创建。
当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。
增加新的具体工厂和产品族很方便，无须修改已有系统，符合“开闭原则”。