MyException - 我的异常网
当前位置:我的异常网» 设计模式 » C语讲和设计模式之工厂模式家族

C语讲和设计模式之工厂模式家族

www.myexceptions.net  网友分享于:2013-04-10  浏览:1次
C语言和设计模式之工厂模式家族

    在工厂模式家族中最出名的是工厂三姐妹,根据抽象的程度不同分为简单工厂、工厂模式和抽象工厂模式。他们在我们平时的编程中会经常使用。所以我们应该详细地了解一下他们三者之间优缺点。

简单工厂

定义

    简单工厂模式又叫做静态工厂方法(Static FactoryMethod)模式,但不属于23种GOF设计模式之一。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式,可以理解为是不同工厂模式的一个特殊实现。

举例说明:  

                                          

代码实现:

//客户端代码
        static void Main(string[] args)
        {
            Operation oper;
            oper = OperationFactory.createOperate("*");
            oper.NumberA = 1;
            oper.NumberB = 2;
            double result = oper.GetResult();

            
        }
    }
     //Operation运算类
    public class Operation
    {
        private double _numberA = 0;
        private double _numberB = 0;

        public double NumberA
        {
            get { return _numberA; }
            set { _numberA = value; }

        }
        public double NumberB
        {
            get { return _numberB; }
            set { _numberB = value; }
        }
        public virtual double GetResult()
        {
            double result = 0;
            return result;
        }
    }

    //加减乘除类
    class OperationAdd : Operation  //加法类,继承运算类
    {
        public override double GetResult()
        {
            double result = 0;
            result = NumberA + NumberB;
            return result;
        }
    }
    class OperationSub : Operation //减法类,继承运算类
    {
        public override double GetResult()
        {
            double result = 0;
            result = NumberA - NumberB;
            return result;
        }
    }

    class OperationMul : Operation //乘法类,继承运算类
    {
        public override double GetResult()
        {
            double result = 0;
            result = NumberA * NumberB;
            return result;

        }
    }

    class OperationDiv : Operation  //除法类,继承运算类
    {
        public override double GetResult()
        {
            double result = 0;
            if (NumberB == 0)
                throw new Exception("除数不能为0。");

            result = NumberA / NumberB;
            return result;
        }
    }
    //简单运算工厂类

    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;
        }
    }

简单工厂的优点:

1工厂类是整个模式的关键.包含了必要的逻辑判断,根据给定的信息,决定究竟应该创建哪个具体类的实例。

2明确了各自的职责和权利,有利于整个软件体系结构的优化。

简单工厂的缺点:

    1由于工厂类集中了所有实例的创建逻辑,违反了高内聚低耦合原则,将全部创建逻辑集中到了一个工厂类中;

2它所能创建的类只能是事先考虑到的,每次扩展都需要更改工厂类,违反了开放封闭原则。

 

简单工厂模式的实质是由一个工厂类根据传入的参数,动态决定应该创建哪一个产品类的实例。

工厂模式

定义:

    用于创建对象的接口,让子类决定实例化哪一个类。工厂模式对类的实例化延迟到其子类。

举例说明:数据访问程序       

                

代码实现:

 static void Main(string[] args)
        {
            User user = new User();
            IFactory factory = new SqlServerFactory();
            IUser iu = factory.CreateUser();
            iu.Insert(user);
            iu.GetUser(1);

            Console.Read();
        }
    }
    //User类
    class User
    {
        private int _id;
        public int ID
        {
            get {return _id;}
            set {_id=value;}
        }
        private string _name;
        public string Name
        {
            get {return _name;}
            set {_name =value ;}
        }
    }
    //IUser接口
    interface IUser
    {
        void Insert(User user);
        User GetUser(int id);
    }
    //SqlserverUser类
    class SqlserverUser : IUser
    {
        public void Insert(User user)
        {
            Console.WriteLine("在SQL Server 中给User表增加一条记录");
        }
        public User GetUser(int id)
        {
            Console.WriteLine("在SQL Server 中根据ID得到User表一条记录");
            return null;
        }
    }
    //AccessUser类
    class AccessUser : IUser
    {
        public void Insert(User user)
        {
            Console.WriteLine("在Access中给User表增加一条记录");
        }
        public User GetUser(int id)
        {
            Console.WriteLine("在Access中根据ID得到User表一条记录");
            return null;
        }
    }
    //IFactory接口
    interface IFactory
    {
        IUser CreateUser();
    }
    //SqlServerFactory :IFactory
    class SqlServerFactory : IFactory
    {
        public IUser CreateUser()
        {
            return new AccessUser();
        }
    }
    //AccessFactory类
    class AccessFactory:IFactory 
    {
        public IUser CreateUser()
        {
            return new AccessUser();
        }
    }

工厂模式的优点:

    1、克服了简单工厂违背开放封闭原则的缺点,保持了封装的优点。工厂模式集中封装了对象的创建,更换对象时更加容易。
        2、使用了多态性,保持了简单工厂的优点。
        3、降低耦合度。降低了客户程序与产品对象的耦合。

抽象工厂

定义:

    创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类。

举例说明:数据访问程序

             

代码实现:

 static void Main(string[] args)
        {
            User user=new User ();
            Department dept = new Department();
            //IFactory factory = new SqlServerFactory();
            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();
            
        }
    }
    class User   //用户类
    {
        private int _id;
        public int ID
        {
            get {return _id;}
            set {_id =value;}
        }
        private string _name;
        public string Name
        {
            get {return _name ;}
            set {_name =value ;}
        }
    }
    //IUser接口
    interface IUser 
    {
        void Insert(User user);
        User GetUser(int id);
    }
    // IUser接口的子SqlserverUser类,用于访问SQL Server的User
    class SqlserverUser :IUser 
    {
        public void Insert(User user)
        {
            Console.WriteLine("在SQL Server中给User表增加一条记录");
        }
        public User GetUser(int id)
        {
            Console.WriteLine ("在SQL Server中根据ID得到User表一条记录");
            return null;
        }
    }
    // IUser接口的子AccessUser类,用于访问Access的User

    class AccessUser :IUser 
    {
        public void Insert(User user)
        {
            Console.WriteLine ("在Access中给User表增加一条记录");
        }
        public User GetUser(int id)
        {
            Console.WriteLine ("在Access中根据ID得到User表中一条记录");
            return null;
        }
    }
    //增加一个Department表
    class Department
    {
        private int _id;
        public int ID
        {
            get { return _id; }
            set { ID = value; }
        }
        private string _deptName;
        public string DeptName
        {
            get { return _deptName; }
            set { DeptName = value; }
        }
    }

    //IDpartment接口
        interface IDepartment
    {
        void Insert(Department department);

        Department GetDepartment(int id);
    }
    //sqlserverDepartment类
        class SqlserverDepartment : IDepartment
        {
            public void Insert(Department department)
            {
                Console.WriteLine("在SQL Server中给Department表增加一条记录");
            }
            public Department GetDepartment(int id)
            {
                Console.WriteLine("在SQL Server中根据ID得到Department表一条记录");
                return null;
            }
        }
    //AccessDepartment类
        class AccessDepartment : IDepartment
        {
            public void Insert(Department department)
            {
                Console.WriteLine("在Access中给Departmen表增加一条记录");
            }
            public Department GetDepartment(int id)
            {
                Console.WriteLine("在Access中根据ID得到Departmen表一条记录");
                return null;
            }
        }
    //抽象工厂的接口
    interface IFactory
    {
        IUser CreateUser();
        IDepartment CreateDepartment(); //增加的接口方法
    }
    class SqlServerFactory : IFactory
    {
        public IUser CreateUser()
        {
            return new SqlserverUser();
        }
        public IDepartment CreateDepartment()
        {
            return new AccessDepartment();
        }
    }
    class AccessFactory : IFactory
    {
        public IUser CreateUser()
        {
            return new AccessUser();
        }
        public IDepartment CreateDepartment()
        {
            return new AccessDepartment();
        }
    }

抽象工厂的优点:

    抽象工厂模式除了具有工厂方法模式的优点外,最主要的优点就是可以在类的内部创建不同的产品对象。

抽象工厂的缺点:

    对于增加需求,扩展程序时,需要增加许多子类,使得程序变得臃肿,麻烦。(此时可以利用放射+抽象工厂的方法避免)。

总结:

        无论是简单工厂模式,工厂模式,还是抽象工厂模式,他们都属于工厂模式,并且是创建型模式,在形式和特点上也是极为相似的,他们的最终目的都是为了解耦。

文章评论

软件开发程序错误异常ExceptionCopyright © 2009-2015 MyException 版权所有