• 各大类库的类工厂


    类工厂是指用于生成类的函数,我们不能每写一个类都重复以下代码,要好好封装一下!

    var F = function(){}
    F.prototype = SuperClass.prototype;
    SubClass.prototype = new F;
    SubClass.prototype.constructor = SubClass
    

    Prototype.js1.6之后的类工厂

    var Animal = Class.create({
      initialize: function(name, sound) {
        this.name  = name;
        this.sound = sound;
      },
    
      speak: function() {
        alert(this.name + " says: " + this.sound + "!");
      }
    });
    
    // subclassing Animal
    var Snake = Class.create(Animal, {
      initialize: function($super, name) {
        $super(name, 'hissssssssss');
      }
    });
    
    var ringneck = new Snake("Ringneck");
    ringneck.speak();
    //-> alerts "Ringneck says: hissssssssss!"
    
    var rattlesnake = new Snake("Rattler");
    rattlesnake.speak();
    //-> alerts "Rattler says: hissssssssss!"
    
    // mixing-in Enumerable
    var AnimalPen = Class.create(Enumerable, {  
      initialize: function() {
        var args = $A(arguments);
        if (!args.all( function(arg) { return arg instanceof Animal }))
          throw "Only animals in here!"
    
        this.animals = args;
      },
    
      // implement _each to use Enumerable methods
      _each: function(iterator) {
        return this.animals._each(iterator);
      }
    });
    
    var snakePen = new AnimalPen(ringneck, rattlesnake);
    snakePen.invoke('speak');
    //-> alerts "Ringneck says: hissssssssss!"
    //-> alerts "Rattler says: hissssssssss!"
    

    通过Class.create来创建一个类与连结一个父类与其他材料构成一个子类。想调用同名父方法,需要在此方法的参数中传入一个$super参数。

    dojo的类工厂:

    var F = function(){}
    F.prototype = SuperClass.prototype;
    SubClass.prototype = new F();
    SubClassprototype.constructor = SubClass
    

    Prototype.js1.6之后的类定义

    dojo.declare(
        "TestClass",
        null,
        {
            id:"",
            info: { name : "",age:""},
            staticValue:{count:0},
            constructor : function(id,name,age) {
                this.id=id;
                this.info.name=name;
                this.info.age=age             
                this.staticValue.count++;  
                 }
        }
    );
    
    

    它有三个参数,类名,父类,与一个对象,里面包含构建这个类的材料。

    YUI的类工厂

    // http://blog.csdn.net/phphot/article/details/4325823
    
    YUI().use('oop', function(Y) {
        var Bird = function(name) {
            this.name = name;
        };
        Bird.prototype.getName = function(){ return this.name; };
    
        var Chicken = function(name) {
            Chicken.superclass.constructor.call(this, name);
        };
        Y.extend(Chicken, Bird);
    
        var chicken = new Chicken('Tom');
        Y.log(chicken.getName());
    });
    

    supperclass 有两个作用:一是可以用来调用父类的方法,二是可以通过 supperclass.constructor 调用父类的构造函数。一举两得.

    不过它相对于其他类工厂来说是非常原始的,只负责连结子类与父类。

    Simple JavaScript Inheritance

    这是jquery作者搞的东西

    // http://ejohn.org/blog/simple-javascript-inheritance/
    
    var Person = Class.extend({
      init: function(isDancing){
        this.dancing = isDancing;
      },
      dance: function(){
        return this.dancing;
      }
    });
    
    var Ninja = Person.extend({
      init: function(){
        this._super( false );
      },
      dance: function(){
        // Call the inherited version of dance()
        return this._super();
      },
      swingSword: function(){
        return true;
      }
    });
    
    var p = new Person(true);
    p.dance(); // => true
    
    var n = new Ninja();
    n.dance(); // => false
    n.swingSword(); // => true
    
    // Should all be true
    p instanceof Person && p instanceof Class &&
    n instanceof Ninja && n instanceof Person && n instanceof Class
    
    
    
    
    

    由Class.create来创建父类,然后通过父类的extend方法加个属性包创建子类.

    mootools的类工厂

    //  http://hmking.blog.51cto.com/3135992/682098
        var Animal = new Class({ 
            initialize: function (age) { 
                this.age = age; 
            } 
        }); 
        var Cat = new Class({ 
            Extends: Animal, 
            initialize: function (name, age) { 
                this.parent(age); // calls initalize method of Animal class 
                this.name = name; 
            } 
        }); 
         
        var cat = new Cat('Micia', 20); 
        console.log(cat.name); // 'Micia' 
        console.log(cat.age); // 20 
    

    它应该是所有框架中最复杂也是最强大的,涉及的API就有Mutator Extends Implements还有从Type继承过来的extend implement,它内部拷贝父类属性还用到了深拷贝!

    Extends: 可以实现父类,也可以调用父类初始化 this.parent()。而且会覆盖父类定义的变量或者函数。

    Implements: 实现父类,子类不可以覆盖父类的方法或者变量。即使子类定义与父类相同的变量或者函数,也会被父类取代掉。

    implement: 是用于调整已经创建好的类的原型成员.

    extend: 调用子类(非其实例)的extend方法创建一个新的子类.

    mass Framework的类工厂

    //http://rubylouvre.github.com/doc/index.html
    
    $.require("class,spec", function() {
     
        var Shape = $.factory({
            init: function(len) {
                $.log(len)
                this.length = len || 0;
            },
            getLength: function() {
                return this.length;
            },
            setLength: function(len) {
                this.length = len;
            },
            getArea: function() {
                throw "Subclasses must implement this method"
            }
        })
     
        var Triangle = $.factory({
            inherit: Shape,
            init: function(len, hei) { //len属性在父类中已定义,这里可以省去
                this.height = hei || 0;
            },
            getArea: function() {
                return this.length * this.height / 2
            }
        })
        var Square = $.factory({
            inherit: Shape,
            getArea: function() {
                return this.length * this.length;
            }
        });
        var t = new Triangle(3, 4)
        $.log(t.getArea(), true)
        var s = new Square(4)
        $.log(s.getArea(), true)
    });
    
    

    $.factory为类工厂,参数为一个普通对象,此对象拥有如下可选属性

    • init为新类的构造器,没有默认传入空函数进去
    • inherit为新类的父类
    • extend的参数是一个对象或对象数组,不管怎么样,这些对象的属性只是为新类添加静态成员,或者说它们是添加到类之上的
    • implement的参数是一个对象或对象数组或类(类即函数),这些对象的属性只是为新类添加实例成员,或者说它们是添加到类的原型上.
  • 相关阅读:
    【2018 “百度之星”程序设计大赛
    分班级(经典二分)
    【2018 “百度之星”程序设计大赛
    【zznu-夏季队内积分赛3-J】追忆
    常见网络名词解释
    【zznu-夏季队内积分赛3-G】2333
    【zznu-夏季队内积分赛3-F】学无止境
    【zznu-夏季队内积分赛3-I】逛超市
    html/css/javascript练习代码
    花生壳免费域名80端口无法访问问题处理
  • 原文地址:https://www.cnblogs.com/rubylouvre/p/2678663.html
Copyright © 2020-2023  润新知