zoukankan      html  css  js  c++  java
  • 设计模式(3)---抽象工厂模式及工厂模式总结

    一、引言  

      在前面分别讲述了简单工厂模式和工厂模式,工厂方法模式是为了克服简单工厂模式的缺点而设计出来的,但是在现实生活中,一个工厂只创建单个产品这样的例子很少,因为现在工厂都多元化了,是一个工厂创建一系列产品,此时工厂模式显示不适用,抽象工厂模式可以很好的解决此问题。本节学习抽象工厂模式,最后会对这三种模式做简单总结,加深对这几种模式的理解。

      

    二、定义

      抽象工厂模式:提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类。

       角色:

      抽象工厂:声明生成一系列抽象产品的方法。具体工厂:执行生成一系列抽象产品的方法,生成一系列具体的产品。

      抽象产品:声明一系列某一种产品的接口。具体产品:定义具体工厂生成的具体产品的对象,实现产品接口。

    三、UML图:

      

    四、举例说明:

      在实际项目中,需要用到数据库,必然有一些数据库连接语句。在本例中,项目需要同时兼任sqlserver和access两种数据库,为了更加便利地解决此问题,用抽象工厂解决。 

      抽象产品和具体产品角色: 

    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; }
            }
        }
    
        interface IUser
        {
            void Insert(User user);
        }
    
        class SqlserverUser:IUser 
        {
            public void Insert(User user)
            {
                Console.WriteLine("在sqlserver中给User表增加一条记录");
            }
        }
    
        class AccessUser:IUser 
        {
            public void Insert(User user)
            {
                Console.WriteLine("在Access中给User表增加一条记录");
            }
        }

      抽象工厂和具体工厂角色: 

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

      客户端调用: 

    User user = new User();
    
                IFactory factory = new SqlserverFactory();
                IUser iu = factory.CreateUser();
                iu.Insert(user);

      看了上面这个实例,给人的感觉就是工厂模式,而不是抽象工厂,对不对?我的理解也是如此。给出UML图看看:

      下面贴出一段代码:

    class Program
        {
            static void Main(string[] args)
            {
                User user = new User();
                Department dept = new Department();
    
                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; }
            }
        }
    
        interface IUser
        {
            void Insert(User user);
            User GetUser(int id);
        }
    
        class SqlserverUser : IUser
        {
            public void Insert(User user)
            {
                Console.WriteLine("在sqlserver中给User表增加一条记录");
            }
    
            public User GetUser(int id)
            {
                Console.WriteLine("在sqlserver中根据ID得到User表一条记录");
                return null;
            }
        }
    
        class AccessUser : IUser
        {
            public void Insert(User user)
            {
                Console.WriteLine("在Access中给User表增加一条记录");
            }
    
            public User GetUser(int id)
            {
                Console.WriteLine("在Access中根据ID得到User表一条记录");
                return null;
            }
        }
    
        class Department
        {
            private int id;
            public int ID
            {
                get { return id; }
                set { id = value; }
            }
    
            private string name;
            public string Name
            {
                get { return name; }
                set { name = value; }
            }
        }
    
        interface IDepartment
        {
            void Insert(Department department);
            Department GetDepartment(int id);
        }
    
        class SqlserverDepartment : IDepartment
        {
            public void Insert(Department department)
            {
                Console.WriteLine("在sqlserver中给Department表增加一条记录");
            }
    
            public Department GetDepartment(int id)
            {
                Console.WriteLine("在sqlserver中根据ID得到Department表一条记录");
                return null;
            }
        }
    
        class AccessDepartment : IDepartment
        {
            public void Insert(Department department)
            {
                Console.WriteLine("在Access中给Department表增加一条记录");
            }
    
            public Department GetDepartment(int id)
            {
                Console.WriteLine("在Access中根据ID得到Department表一条记录");
                return null;
            }
        }
    
        interface IFactory
        {
            IUser CreateUser();
            IDepartment CreateDepartment();
        }
    
        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();
            }
        }
    View Code

      它的UML类图如下:

      

      抽象工厂模式的定义是:提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类。

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

      简单工厂:一个类专门负责创建其他类的实例,具体创建什么实例由传入的参数而决定,并且这些类都共同继承于一个父类或者有共同的接口。

      从抽象工厂的UML类图和工厂模式的UMl类图中似乎可以看出其区别,抽象工厂模式是提供一系列对象的接口,而工厂模式则不是。(不知道理解的对不对)。抽象工厂模式有多个方法,是创建多个产品的,工厂模式只有一个方法,创建一种产品。(这里可以在IUser中加入多个方法,此处暂时没有添加。)既然抽象工厂、工厂模式的UML类图都有了,今天把简单工厂的也放在一起,对比出效果。

      简单工厂UML:

      总而言之:

      简单工厂:是系统根据外界传入的具体信息创建所需的实例,等于是客户端不必关心产品如何生产,只负责指定生产什么产品。

      工厂模式:让子类决定创建什么产品,即:使一个类的实例化延迟到子类。

      抽象工厂模式:便于交换产品系列,同时让具体的创建实例过程与客户端分离,客户端是通过它们的抽象接口操纵实例,产品的具体类名也被具体工厂的实现分离,不会出现在客户端。

      

  • 相关阅读:
    Python之路【第七十一篇】:django日更
    Python之路【第七十篇】:django日更
    Python之路【第六十九篇】:django日更
    选包
    Python之路【第六十八篇】:django日更
    Python之路【第六十七篇】:django日更
    Python之路【第六十六篇】:django日更
    Python之路【第六十五篇】:django日更
    Python之路【第六十四篇】:django日更
    Python之路【第六十三篇】:django日更
  • 原文地址:https://www.cnblogs.com/ysyn/p/3658313.html
Copyright © 2011-2022 走看看