精华内容
下载资源
问答
  • js抽象工厂模式

    2017-03-25 12:27:00
    抽象工厂模式,提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类。 抽象工厂允许客户使用抽象的接口来创建一组相关产品,而不需要知道或关心实际生产出的具体产品是什么。这样客户就可以从具体...

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

    抽象工厂允许客户使用抽象的接口来创建一组相关产品,而不需要知道或关心实际生产出的具体产品是什么。这样客户就可以从具体产品中被解耦。下面通过抽象工模式的类图来了解各个类中之间的关系:

    抽象工厂的分析

    抽象工厂模式将具体产品的创建延迟到具体工厂的子类中,这样将对象的创建封装起来,可以减少客户端与具体产品类之间的依赖,从而使系统耦合度低,这 样更有利于后期的维护和扩展,这真是抽象工厂模式的优点所在,然后抽象模式同时也存在不足的地方。下面就具体看下抽象工厂的缺点(缺点其实在前面的介绍中 以已经涉及了):

    抽象工厂模式很难支持新种类产品的变化。这是因为抽象工厂接口中已经确定了可以被创建的产品集合,如果需要添加新产品,此时就必须去修改抽象工厂的接口,这样就涉及到抽象工厂类的以及所有子类的改变,这样也就违背了“开发——封闭”原则。

    知道了抽象工厂的优缺点之后,也就能很好地把握什么情况下考虑使用抽象工厂模式了,下面就具体看看使用抽象工厂模式的系统应该符合那几个前提:

    • 一个系统不要求依赖产品类实例如何被创建、组合和表达的表达,这点也是所有工厂模式应用的前提。
    • 这个系统有多个系列产品,而系统中只消费其中某一系列产品
    • 系统要求提供一个产品类的库,所有产品以同样的接口出现,客户端不需要依赖具体实现。

    C#抽象工厂-多数据库:

    namespace 抽象工厂多数据库
    {
        class Program
        {
            static void Main(string[] args)
            {
                User user = new User();
                Department dept = new Department();
    
                //AbstractFactory 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; }
            }
        }
    
        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; }
            }
        }
    
        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;
            }
        }
    
        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();
            }
        }
    }

     

    C#抽象工厂-用简单工厂来改进:

    namespace 抽象工厂用简单工厂来改进
    {
        class Program
        {
            static void Main(string[] args)
            {
                User user = new User();
                Department dept = new Department();
    
                IUser iu = DataAccess.CreateUser();
    
                iu.Insert(user);
                iu.GetUser(1);
    
                IDepartment id = DataAccess.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; }
            }
        }
    
        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; }
            }
        }
    
        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;
            }
        }
    
        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;
            }
        }
    
        class DataAccess
        {
            private static readonly string AssemblyName = "抽象工厂用简单工厂来改进";
            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);
            }
        }
    }

     

    转载于:https://www.cnblogs.com/gongshunkai/p/6616777.html

    展开全文
  • JS 抽象工厂模式

    2017-12-14 13:53:34
    抽象工厂模式(Abstract Factory)就是通过类的抽象使得业务适用于一个产品类簇的创建,而不负责某一类产品的实例。 JS中是没有直接的抽象类的,abstract是个保留字,但是还没有实现,因此我们需要在类的方法中抛出...
        

    0. 简介

    抽象工厂模式(Abstract Factory)就是通过类的抽象使得业务适用于一个产品类簇的创建,而不负责某一类产品的实例。

    JS中是没有直接的抽象类的,abstract是个保留字,但是还没有实现,因此我们需要在类的方法中抛出错误来模拟抽象类,如果继承的子类中没有覆写该方法而调用,就会抛出错误。

    const Car = function() { }
    Car.prototype.getPrice = function() {return new Error('抽象方法不能调用')}

    1. 实现

    面向对象的语言里有抽象工厂模式,首先声明一个抽象类作为父类,以概括某一类产品所需要的特征,继承该父类的子类需要实现父类中声明的方法而实现父类中所声明的功能:

    /**
    * 实现subType类对工厂类中的superType类型的抽象类的继承
    * @param subType 要继承的类
    * @param superType 工厂类中的抽象类type
    */
    const VehicleFactory = function(subType, superType) {
      if (typeof VehicleFactory[superType] === 'function') {
        function F() {
          this.type = '车辆'
        } 
        F.prototype = new VehicleFactory[superType]()
        subType.constructor = subType
        subType.prototype = new F()                // 因为子类subType不仅需要继承superType对应的类的原型方法,还要继承其对象属性
      } else throw new Error('不存在该抽象类')
    }
    
    VehicleFactory.Car = function() {
      this.type = 'car'
    }
    VehicleFactory.Car.prototype = {
      getPrice: function() {
        return new Error('抽象方法不可使用')
      },
      getSpeed: function() {
        return new Error('抽象方法不可使用')
      }
    }
    
    const BMW = function(price, speed) {
      this.price = price
      this.speed = speed
    }
    VehicleFactory(BMW, 'Car')        // 继承Car抽象类
    BMW.prototype.getPrice = function() {        // 覆写getPrice方法
      console.log(`BWM price is ${this.price}`)
    }
    BMW.prototype.getSpeed = function() {
      console.log(`BWM speed is ${this.speed}`)
    }
    
    const baomai5 = new BMW(30, 99)
    baomai5.getPrice()                          // BWM price is 30
    baomai5 instanceof VehicleFactory.Car       // true

    2. 总结

    抽象类创建出的结果不是一个真实的对象实例,而是一个类簇,它指定了类的结构,这也就区别于简单工厂模式创建单一对象,工厂模式创建多类对象。

    通过抽象工厂,就可以创建某个类簇的产品,并且也可以通过instanceof来检查产品的类别,也具备该类簇所必备的方法。


    本文是系列文章,可以相互参考印证,共同进步~

    1. JS 抽象工厂模式
    2. JS 工厂模式
    3. JS 建造者模式
    4. JS 原型模式
    5. JS 单例模式
    6. JS 回调模式
    7. JS 外观模式
    8. JS 适配器模式
    9. JS 利用高阶函数实现函数缓存(备忘模式)
    10. JS 状态模式
    11. JS 桥接模式
    12. JS 观察者模式

    网上的帖子大多深浅不一,甚至有些前后矛盾,在下的文章都是学习过程中的总结,如果发现错误,欢迎留言指出~

    参考:《Javascript 设计模式》 - 张荣铭
    展开全文
  • 浅析JS抽象工厂模式

    2020-10-18 22:00:39
    本篇文章主要给大家总结了一下作者在学习JS抽象工厂模式时的经验和总结,有兴趣的朋友跟着学习下吧。
  • js 抽象工厂模式

    2017-08-30 15:37:42
    抽象类的主要作用:定义一个产品簇,声明必备的方法,如果子类没有重写就会抛出错误. var abstructFactory = function(child,father){ if(typeof abstructFactory[father] === 'function'){ function tempClass(){}; ...

    抽象类的主要作用:定义一个产品簇,声明必备的方法,如果子类没有重写就会抛出错误.

    var abstructFactory = function(child,father){
        if(typeof abstructFactory[father] === 'function'){
            function tempClass(){};
            tempClass.prototype = new abstructFactory[father]();
            child.constructor = child;
            child.prototype = new tempClass();
        }else{
            throw new Error('no abstructFactory');
        }
    }
    //抽象工厂方法
    
    abstructFactory.ball = function(){
        this.title = '球';
    }
    abstructFactory.ball.prototype = {
        info : function(){
            return new Error("can't use abstructFactory function");
        },
        action : function(){
            return new Error("can't use abstructFactory function");
        }
    }
    //球类抽象类
    
    var football = function(){
        this.title = '足球';
    }
    
    abstructFactory(football,'ball');
    football.prototype.info = function(){
        console.log(this.title);
    }
    football.prototype.action = function(){
        console.log('踢球');
    }
    
    //继承的子类
    
    
    var obj = new football();
    obj.info();
    obj.action();
    
    展开全文
  • js 抽象工厂模式B

    2012-06-30 23:41:04
    // 抽象工厂 var AbstractFactory = (function() { // 抽象方法检查 function checkImplements(object) { var isContain = false; var v_method = ''; if (arguments.length ) { throw new Error(...

    // 接口
    var Interface = function(name, methods) {
    if (arguments.length != 2) {
    throw new Error("Interface constructor called with " + arguments.length
    + "arguments, but expected exactly 2.");
    }

    this.name = name;
    this.methods = [];
    for (var i = 0, len = methods.length; i < len; i++) {
    if (typeof methods[i] !== 'string') {
    throw new Error("Interface constructor expects method names to be "
    + "passed in as a string.");
    }
    this.methods.push(methods[i]);
    }
    };
    // 接口检查
    Interface.ensureImplements = function(object) {
    if (arguments.length < 2) {
    throw new Error("Function Interface.ensureImplements called with "
    + arguments.length + "arguments, but expected at least 2.");
    }

    for (var i = 1, len = arguments.length; i < len; i++) {
    var v_interface = arguments[i];
    if (v_interface.constructor !== Interface) {
    throw new Error("Function Interface.ensureImplements expects arguments "
    + "two and above to be instances of Interface.");
    }

    for (var j = 0, methodsLen = v_interface.methods.length; j < methodsLen; j++) {
    var method = v_interface.methods[j];
    if (!object[method] || typeof object[method] !== 'function') {
    throw new Error("Function Interface.ensureImplements: object "
    + "does not implement the " + v_interface.name
    + " interface. Method " + method + " was not found.");
    }
    }
    }
    };
    // 原形继承
    function clone(object) {
    function F() {
    }
    F.prototype = object;
    return new F;
    }

    // 抽象工厂
    var AbstractFactory = (function() {
    // 抽象方法检查
    function checkImplements(object) {
    var isContain = false;
    var v_method = '';
    if (arguments.length < 2) {
    throw new Error("Function AbstractFactory.checkImplements called with "
    + arguments.length + "arguments, but expected at least 2.");
    }
    for (var i = 1; i < arguments.length; i++) {
    var v_AbstractClass = arguments[i];
    for (key in v_AbstractClass) {
    if (!object[key] && typeof object[key] !== 'function'
    && key != 'getFactory') {
    isContain = true;
    v_method = key;
    break;
    }
    }
    }
    if (isContain) {
    throw new Error("Function AbstractFactory.ensureImplements: object "
    + "does not implement the AbstractFactory "
    + "AbstractCalss. AbstractMethod "
    + v_method
    + " was not found.");
    }
    }
    // 选择具体工厂
    function chooesFactory(mode) {
    var factory = null;
    switch (mode) {
    case 'giant' :
    factory = GiantFactory;
    break;
    case 'cnforever' :
    factory = CnforeverFactory;
    break;
    case 'merida' :
    factory = MeridaFactory;
    break;
    default :
    throw new Error("mode not found");
    }
    checkImplements(factory, AbstractFactory)
    return factory;
    }
    return {
    getFactory : function(mode) {
    return chooesFactory(mode);
    },
    // 抽象方法
    createBicycle : function() {
    throw new Error('Unsupported operation on an abstract class:createBicycle');
    }
    }
    })();
    // 继承
    var GiantFactory = clone(AbstractFactory);
    GiantFactory = {
    // 实现父类抽象方法
    createBicycle : function() {
    var giantBicycle = new GiantBicycle();
    Interface.ensureImplements(giantBicycle, Bicycle);
    return giantBicycle;
    }
    };
    // 创建接口
    var Bicycle = new Interface("Bicycle", ['assemble', 'wash', 'ride', 'repair']);
    var GiantBicycle = function() {

    };
    // 实现接口
    GiantBicycle.prototype = {
    assemble : function() {
    alert('组装');
    },
    wash : function() {
    alert('清洗');
    },
    ride : function() {

    },
    repair : function() {

    }
    };

    var BicycleShop = function() {
    };
    // 入口
    BicycleShop.prototype = {
    sellBicycle : function(mode) {
    var bicycle = AbstractFactory.getFactory(mode).createBicycle();
    bicycle.assemble();
    bicycle.wash();;
    return bicycle;
    }
    }

    var bicycleShop = new BicycleShop();
    bicycleShop.sellBicycle('giant');

    展开全文
  • js 抽象工厂模式A

    2012-06-30 23:41:26
    [code="javascript"] var Interface = function(name, methods) { if (arguments.length != 2) { throw new Error("Interface constructor called with " + arguments.length ...
  • 抽象工厂模式(Abstract Factory) 通过类的抽象使得业务适用于一个产品类簇的创建,而不负责创建某一类产品的实例。 JS中是没有直接的抽象类的,因此我们需要在类的方法中抛出错误来模拟抽象类,如果继承的子类中没有...
  • JS设计模式 - 构造函数模式,工厂模式与抽象工厂模式 1. 构造函数模式 (1) JS中创建新对象的三种常用方法 var newObject = {}; var newObject = Object.create( Object.prototype ); var newObject = ...
  • 简单工厂模式(Simple Factory Pattern): 使用一个类(通常为单体)来创建实例;...抽象工厂模式 多个抽象产品类,每个抽象产品类可以派生出多个具体产品类。 一个抽象工厂类,可以派生出多个具体工厂类。 每个
  • js实现抽象工厂模式

    2019-03-28 11:46:41
    class Circle { constructor() { this.shape = "circle" } } class Rectangle { constructor() { this.shape = "rectangle" } } class ShapeFactory { constructor() {} getShapeInstance(shapeType) { ...
  • 待定
  • 抽象工厂模式 抽象工厂是工厂模式的升级版,他用来创建一组相关或者相互依赖的对象。上节学习了工厂模式,类的创建依赖工厂类,程序需要扩展时,我们必须创建新的工厂类。工厂类是用来生产产品的,那我们也可以把...
  • 设计模式(6)[JS版]-JavaScript如何实现抽象工厂模式

    千次阅读 多人点赞 2020-07-24 21:28:39
    3 掌握使用JS实现抽象工厂模式的代码编写。 2 什么是抽象工厂模式抽象工厂模式提供了一种封装一组具有相同主题的单个工厂而无需指定其具体类的方法。即工厂的工厂;一个将单个但相关/从属工厂分组在一起的工厂...
  • 这个模式归根到底可以认为是子类将父类的对象复制,然后在子类中实现,这样的好处是相同的东西放到父节点里,子节点里负责特异化并实现抽象的内容,就可以生产出一堆东西 代码难以理解:  
  • 这里要多实现一个超级工厂,常见不同的工厂,然后再创建实体,相比工厂模式,继承上要多了一个抽象类的继承 class Football { round () { console.log('我是脚踢的') } } class Basketball { round () { ...
  • 抽象工厂模式一般用在多人协作的超大型项目中,并且严格的要求项目以面向对象的思想进行完成。 实例 // 抽象工厂方法 var abstractFactory = function(subType, superType) { // 判断抽象工厂中是否有该...
  • 1)抽象工厂模式 JavaScript 的动态性质 排除了描述类的需要接口。 Instead of interfaces, JavaScript trusts that the class you provide implements all the appropriate methods. At runtime the ...
  • 抽象工厂:提供一个注册方法,然后实例这个类 工厂维护一个类的清单,用一个对象来维护所有的类的内容,注册的时候可以提供预审查功能,比如我们要求所有的注册类都必须要有update和render方法,否则不允许注册 ...
  • 抽象工厂模式用于封装一组具有共同目标的单个工厂。它能够将一组对象的实现细节从一般用法中分离出来。 应用场景:一个系统必须独立于它所创建的对象的生成方式,或它需要与多种对象类型一起工作。 接着上期我们已经...
  • 场景:定义一个抽象类 AbsProducer(生产商),该生产商有两个行为,一个生产,一个出售,其中生产方法为抽象方法,由具体的厂家(工厂)去实现,出售的产品均是电子产品(返回的对象为电子产品对象,即对象都要实现电子...
  • 简单工厂模式又称为静态工厂方法,由一个工厂对象决定创建某一种产品对象类的实例,主要用来创建同一类的对象。其实,工厂模式的思想主要是将相同/相似的的对象或类进行提取归类,这样的话,就可以避免写太多重复性...
  • js-工厂模式

    2019-09-22 18:34:34
    抽象工厂模式 1.简单工厂模式 简单工厂模式:又称为静态工厂方法模式,它属于类创建型模式。 在简单工厂模式中,可以根据参数的不同返回不同类的实例。 由工厂对象决定创建某一种产品对象类的实例。 let Ball= ...
  • js工厂模式

    2019-02-19 11:05:00
    工厂模式:  什么叫工厂模式,工厂就是大家大脑里想的那样,一个流水...抽象工厂模式 简单工厂:  简单工厂说白了,就是需要想到你要干什么,要分几步做,把每个事件全都摆出来,完咯,开始着手建厂,在厂里...
  • 工厂设计模式, 顾名思义就是生产对象的工厂, 在这里需要注意的是生产的对象都是同一规格的, 具有某些相同的特性, 否则工厂模式的意义荡然无存接口在工厂模式中有着重要的作用, 如果对生产的对象不实现某个接口, 试问...
  • 三:抽象工厂模式   向客户端提供一个接口,使得客户端在不必指定产品的具体类型的情况下,创建多个产品族中的产品对象。“抽象”来自“抽象产品角色”, 而“抽象工厂”是抽象产品角色的工厂。该模式...
  • 在这里,抽象化创建模式不是一个真实的对象实例,而是一个类簇,制定了类的结构,这也就区别于简单工厂模式创建单一对象,工厂模式创建多类对象。// 抽象工厂方法var VirtualFactory = function ( subType , ...
  • JS工厂模式

    2019-10-08 16:00:00
    什么是工厂模式工厂模式是一种用来创建对象的设计模式。我们不暴露对象创建的逻辑,而是将逻辑封装在一个...抽象工厂 1.简单工厂: let factory = function (role) { function superman() { this.name =...
  • 复杂工厂模式 ** 工厂模式转变为复杂工厂模式–也就是由粗粒度变成细粒度。也就是每个对象实现的方法的变得更具体化。** 看下面代码,同上文一样要先插入CommonUtil.js文件。 <script> // 复杂工厂模式(由粗...

空空如也

空空如也

1 2 3 4 5 ... 9
收藏数 166
精华内容 66
热门标签
关键字:

js抽象工厂模式