抽象工厂（Abstract Factory）

最新推荐文章于 2024-09-05 14:09:31 发布
最新推荐文章于 2024-09-05 14:09:31 发布
阅读量264 收藏
点赞数
分类专栏： 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jiangxt211/article/details/48767943
版权
抽象工厂（Abstract Factory）
抽象工厂，提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
别名
Kit
结构

参与者

AbstractFactory
——声明一个创建抽象产品对象的操作接口。
ConcreteFactory
——实现创建具体产品对象的操作。
AbstractProduct
——为一类产品对象声明一个接口。
ConcreteProduct
——定义一个将被相应的具体工厂创建的产品对象。
——实现AbstractProduct接口。
Client
——仅使用由AbstractFactory和AbstractProduct类声明的接口。

效果
1)它分离了具体的类 Abstract Factory 模式帮助你控制一个应用创建的对象的类。因为一个工厂封装创建产品对象的责任和过程，它将客户与类的实现分离。客户通过它们的抽象接口操纵实例。产品的类名也在具体工厂的实现中被分离；它们不出现在客户代码中。
2)它使得易于交换产品系列 在一个应用中只需要在初始化的时候出现一次，这就使得改变一个应用的具体工厂变得非常容易，它只需要改变具体工厂即可使用不同的产品配置。
3)它有利于产品的一致性。
4)难以支持新种类的产品。
实现
1）将工厂作为单件。
2）创建产品 最通常的一个办法是为每一个产品定义一个工厂方法（Factory Method），一个具体的工厂将为每个产品重定义该工厂方法以指定产品。虽然这样的实现很简单，但它却要求每个产品系列都要有一个新的具体工厂子类，即使这些产品系列的差别很小。如果有多个可能的产品系列，具体工厂也可以使用Prototype模式来实现。具体工厂使用产品系列中每一个产品的原型实例来初始化，且它通过复制它的原型来创建新的产品。在基于原型的方法中，使得不是每个新的产品系列都需要一个新的具体工厂类。

3）定义可扩展的工厂 AbstractFactory通常为每一种它可以生产的产品定义一个操作。产品的种类被编码在操作型构中。增加一种新的产品要求改变AbstractFactory的接口以及所有与它相关的类。一个更灵活但不太安全的设计是给创建对象的操作增加一个参数。该参数指定了将被创建的对象的种类。它可以是一个类标识符、一个整数、一个字符串，或其他任何可以标识这种产品的东西。

工厂方法

在抽象工厂中使用工厂方法


代码

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace MyAbstractFactory
{
    public interface IFactory
    {
        IUser CreateeUser();

        IDepartment CreateDepartment();
    }

    public class SqlserverFactory : IFactory
    {
        public IUser CreateeUser()
        {
            return new SqlserverUser();
        }

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

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

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

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace MyAbstractFactory
{
    public interface IUser
    {
        void Insert(string user);

        string GetUser(int id);
    }

    public class SqlserverUser : IUser
    {
        public void Insert(string user)
        {
            Console.WriteLine("在SQL server中给User表增加一条记录");
        }

        public string GetUser(int id)
        {
            Console.WriteLine("在SQL server中根据ID得到User表一条记录");
            return null;
        }
    }

    public class AccessUser : IUser
    {
        public void Insert(string user)
        {
            Console.WriteLine("在Access中给User表增加一条记录");
        }

        public string GetUser(int id)
        {
            Console.WriteLine("在Access中根据ID得到User表一条记录");
            return null;
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace MyAbstractFactory
{
    public interface IDepartment
    {
        void Insert(string dapartment);

        string GetDepartment(int id);
    }

    public class SqlserverDepartment : IDepartment
    {
        public void Insert(string dapartment)
        {
            Console.WriteLine("在SQL server中给Department表增加一条记录");
        }

        public string GetDepartment(int id)
        {
            Console.WriteLine("在SQL server中根据ID得到Department表一条记录");
            return null;
        }
    }

    public class AccessDepartment : IDepartment
    {
        public void Insert(string dapartment)
        {
            Console.WriteLine("在Access中给Department表增加一条记录");
        }

        public string GetDepartment(int id)
        {
            Console.WriteLine("在Access中根据ID得到Department表一条记录");
            return null;
        }
    }

}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace MyAbstractFactory
{
    class Program
    {
        static void Main(string[] args)
        {
            string user = "user";
            string dept = "Department";

            IFactory factory = new AccessFactory(); // 实例化工厂

            IUser iu = factory.CreateeUser(); // 实例化产品
            iu.Insert(user);
            iu.GetUser(1);

            IDepartment id = factory.CreateDepartment(); // 实例化产品
            id.Insert(dept);
            id.GetDepartment(1);

            Console.ReadKey();
        }
    }
}
(C#) 在使用简单工厂的地方，可以考虑用 反射技术 来去除switch或if，解除分支判断带来的耦 合。
抽象工厂（配置文件）+反射 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Reflection;
using System.Configuration;

namespace MyAbstractFactory2
{
//     class DataAccess // 简单工厂
//     {
//         //private static readonly string db = "Sqlserver";
//         private static readonly string db = "Access";
// 
//         public static IUser CreateUser()
//         {
//             IUser result = null;
//             switch (db)
//             {
//                 case "Sqlserver":
//                     result = new SqlserverUser();
//                     break;
//                 case "Access":
//                     result = new AccessUser();
//                     break;
//             }
//             return result;
//         }
// 
//         public static IDepartment CreateDepartment()
//         {
//             IDepartment result = null;
//             switch (db)
//             {
//                 case "Sqlserver":
//                     result = new SqlserverDepartment();
//                     break;
//                 case "Access":
//                     result = new AccessDepartment();
//                     break;
//             }
//             return result;
//         }
//     }

    class DataAccess // 利用反射
    {
        private static readonly string assemblyName = "MyAbstractFactory2";
        // private static readonly string db = "Sqlserver";
        // 可以放到配置文件中
        private static readonly string db = ConfigurationManager.AppSettings["DB"];     

        public static IUser CreateUser()
        {
            string className = assemblyName + "." + db + "User";
            return (IUser)Assembly.Load(assemblyName).CreateInstance(className);
        }

        public static IDepartment CreateDepartment()
        {
            string className = assemblyName + "." + db + "Department";
            return (IDepartment)Assembly.Load(assemblyName).CreateInstance(className);
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace MyAbstractFactory2
{
    public interface IUser
    {
        void Insert(string user);

        string GetUser(int id);
    }

    public class SqlserverUser : IUser
    {
        public void Insert(string user)
        {
            Console.WriteLine("在SQL server中给User表增加一条记录");
        }

        public string GetUser(int id)
        {
            Console.WriteLine("在SQL server中根据ID得到User表一条记录");
            return null;
        }
    }

    public class AccessUser : IUser
    {
        public void Insert(string user)
        {
            Console.WriteLine("在Access中给User表增加一条记录");
        }

        public string GetUser(int id)
        {
            Console.WriteLine("在Access中根据ID得到User表一条记录");
            return null;
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace MyAbstractFactory2
{
    public interface IDepartment
    {
        void Insert(string dapartment);

        string GetDepartment(int id);
    }

    public class SqlserverDepartment : IDepartment
    {
        public void Insert(string dapartment)
        {
            Console.WriteLine("在SQL server中给Department表增加一条记录");
        }

        public string GetDepartment(int id)
        {
            Console.WriteLine("在SQL server中根据ID得到Department表一条记录");
            return null;
        }
    }

    public class AccessDepartment : IDepartment
    {
        public void Insert(string dapartment)
        {
            Console.WriteLine("在Access中给Department表增加一条记录");
        }

        public string GetDepartment(int id)
        {
            Console.WriteLine("在Access中根据ID得到Department表一条记录");
            return null;
        }
    }
}

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <appSettings>
    <add key="DB" value="Sqlserver"/>
  </appSettings>
</configuration>
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace MyAbstractFactory2
{
    class Program
    {
        static void Main(string[] args)
        {
            string user = "user";
            string dept = "Department";

            IUser iu = DataAccess.CreateUser(); // 简单工厂
            iu.Insert(user);
            iu.GetUser(1);

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

            Console.ReadKey();
        }
    }
}








jiangxt211
关注
专栏目录
Creational模式之Abstract Factory模式
feiyangxiaomi的专栏
06-25 780
1.意图提供一个创建一系列相关或相互依赖对象的接口，而无需指定他们具体的类。2.别名Kit3.动机考虑一个支持多种视感（look-and-feel）标准的用户界面工具包。不同的视感风格为诸如滚动条、窗口和按钮等用户界面”窗口组件“定义不同的外观和行为。为保证视感风格标准间的可移植性，一个应用不应该为一个特定的视感外观硬编码它的窗口组件。4.适用性以下情况使用Abstract Factory模式： 一
抽象工厂
吴渣渣的博客
09-09 1万+
抽象工厂 示例 使用典范 抽象工厂 定义 ：抽象工厂模式提供了一个创建一系列相关或者相互依赖对象的接口，无需指定它们具体的类 创建型 ：创建型 适用场景： 客户端（应用层）不依赖于产品类实例如何被创建、实现等细节 强调一系列相关的产品对象（属于同一产品族）一起使用创建对象需要大量的重复代码 提供一个产品类的库，所有的产品以同样的接口出现，从而使得客户端不依赖于具体的实现 ...
抽象工厂 Abstract Factory
「有且仅有」
05-20 512
父博文地址：设计模式 - Design Patterns 一、是什么？ 作用： 当我需要创建一个产品家族（很多产品）时，我可以使用抽象工厂。 客户通过抽象接口来创建产品家族，而不需要知道实际产出的具体产品类型。 实现了解耦客户和具体产品。 行为 定义一个抽象工厂接口，每个抽象工厂的子类都能创建所有产品家族的产品。 二、实例 上面类图的实现 其它代码就不给了按照...
抽象工厂AbstractFactory
热门推荐
07-06 2万+
/** * 水果的工厂方法 * @param name * @return */ public Fruit createFruit(String name) { return new NorthernFruit(name); } /** * 蔬菜的工厂方法 * @param name * @return */ public Veggie createVeggie(String name) { return new North
「聊设计模式」之抽象工厂模式（Abstract Factory）
**My Coding Family**
09-18 601
🏆本文收录于《聊设计模式》专栏，专门攻坚指数级提升，助你一臂之力，带你早日登顶🚀，欢迎持续关注&&收藏&&订阅！
抽象工厂模式（Abstract Factory Pattern）
果酱 の 博客
07-12 5983
抽象工厂模式是一种常用且灵活的创建型设计模式，它通过引入抽象工厂和具体工厂来实现对象的创建和管理。抽象工厂模式可以帮助我们将客户端代码与具体产品的创建过程解耦，使得客户端代码只需关注抽象工厂和抽象产品的接口，而无需关注具体的产品类。这样可以提高代码的可扩展性和可维护性。
抽象工厂模式abstract factory
最新发布
alike_meng的博客
09-05 267
abstract factory
抽象工厂模式(Abstract Factory)
weixin_43956958的博客
05-06 1128
抽象工厂模式（Abstract Factory Pattern）：属于创建型模式，它提供了一种创建对象的最佳方式。在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类，每个生成的工厂都能按照工厂模式提供对象。 意图： 提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。 主要解决：主要解决接口选择的问题。 何时使用：系统的产品有多于一个的产品族，而系统只消费其中某一族的产品。 如何解决：在一个产品族里面，定义多个产品。 关键代码： 在一个工厂里聚合多个同类产品。 优点：
抽象工厂模式 Abstract Factory
02-21 752
提供一个创建一系列相关或互相依赖对象的接口，而无需指定它们具体的类。程序需要处理不同系列的相关产品，但是您不希望它依赖于这些产品的。2.可以避免具体产品和客户端代码之间的紧密耦合。1.可以确信你从工厂得到的产品彼此是兼容的。具体类时， 可以使用抽象工厂。3.符合单一职责原则。
设计模式：抽象工厂模式（Abstract Factory）
ProgramNovice的博客
04-25 1710
设计模式：抽象工厂模式（Abstract Factory）
C# 抽象工厂 AbstractFactory.rar
09-20
这个压缩包“C# 抽象工厂 AbstractFactory.rar”可能包含了一个关于如何在C#中实现抽象工厂模式的实例或教程。 抽象工厂模式是一种创建型设计模式，它提供了一种创建对象族的方式，而无需指定具体类。在C#中，这种...
设计模式之抽象工厂模式(AbstractFactory)摘录
03-04
面向对象系统的分析和设计实际上追求的就是两点：高内聚(Cohesion)和低耦合(Coupling).
抽象工厂模式abstractFactory
03-24
抽象工厂模式（Abstract Factory Pattern）是一种创建型设计模式，它提供了一种创建对象集合的接口，而无需指定具体的产品类型。这种模式适用于当系统需要在不同平台或环境中创建一组相关或相互依赖的对象时，而这些...
设计模式C++学习之抽象工厂模式（AbstractFactory）
09-07
在这个例子中，`AbstractProductA`和`AbstractProductB`是抽象产品，`ConcreteProductA1/A2`和`ConcreteProductB1/B2`是具体产品，`AbstractFactory`是抽象工厂，`ConcreteFactory1/2`是具体工厂。客户端代码通过...
享元模式（Flyweight Pattern）
jiangxt211的专栏
11-08 1772
享元模式（Flyweight Pattern）：运用共享技术有效地支持大量细粒度的对象。 flyweight是一个共享对象，它可以同时在多个场景(context)中使用，并且在每个场景中flyweight都可以作为一个独立的对象—这一点与非共享对象的实例没有区别。flyweight不能对它所运行的场景做出任何假设，这里的关键概念是内部状态和外部状态之间的区别。内部状态存储于flyweight中，
组合/聚合复用原则（CARP）
jiangxt211的专栏
11-15 787
组合/聚合复用原则（CARP），尽量使用组合/聚合，不要使用类继承。 组合（Composition，也作合成）和聚合（Aggregation）都是关联的特殊种类。聚合表示一种弱的“拥 有”关系，体现的是A对象可以包含B对象，但B对象不是A对象的一部分；组合则是一种强的“拥有”关系，体现了严格的部分和整体的关系，部分和整体的生命周期一样。 看大雁与雁群、翅膀的关系 组合/聚合复用原则
模式总结（一）——创建型模式（Creational Pattern）
jiangxt211的专栏
09-27 490
1）工厂方法（Factory Method） 定义一个用于创建对象的接口，让子类决定实例化那一个类。Factory Method使一个类的实例化延迟到子类。 别名 虚构造器（Virtual Constructor） 结构 参与者 Product ——定义工厂方法所创建的对象的接口。 ConcreteProduct ——实现Product接口。 Creator ——
适配器模式（Adapter Pattern）
jiangxt211的专栏
11-15 414
适配器模式（Adapter pattern）：将一个类的接口转换成客户希望的另外的接口。 Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。 别名 包装器Wrapper 类适配器和对象适配器 1、类适配器使用多重继承对一个接口与另一个接口进行匹配； 2、对象匹配器依赖于对象组合。 参与者 Target ——定义Client使用的与特定领域相关的接口
抽象工厂模式详解与示例
- 抽象工厂（AbstractFactory）角色：定义一个创建一组相关或相互依赖对象的接口，使得这些对象均属于某个特定的产品族。抽象工厂不涉及具体的实现细节，而是定义了一系列创建对象的方法。 3. 具体工厂角色： - ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值