各大类库的类工厂
类工厂是指用于生成类的函数，我们不能每写一个类都重复以下代码，要好好封装一下！
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的类工厂
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作者搞的东西
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的类工厂
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的类工厂
$.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的参数是一个对象或对象数组或类(类即函数),这些对象的属性只是为新类添加实例成员,或者说它们是添加到类的原型上.
标签:
javascript