? 首先需要说明的是,本文将直接讲解创建和使用类的各种技巧,一些基础的东西不再做解释,要理解如何在JavaScript中实现面向对象的设计,请先参考《JavaScript.高级程序设计(第2版)》(前7章)、《javascript.设计模式》(前四章)、《JavaScript.语言精粹》这三部经典之作。

? 在Mootools中使用Class构造函数创建一个类有两种方式,也就是传递两种不同类型的参数给构造函数,第一种也是标准方式传递一个对象字面量,这个对象字面量可以包括你为类添加的所有属性、方法。例如:
  1. var Person = new Class({
  2. // Methods
  3. initialize: function (name, age) {
  4. this.name = name;
  5. this.age = age;
  6. },
  7. log: function () {
  8. console.log(this.name + ',' + this.age);
  9. }
  10. });
  11. var mark = new Person('mark', 24);
  12. mark.log(); // returns 'mark,24'
? 第二种是传递一个普通函数,mootools会自动把这个函数包装成只含一个initialize键值的对象字面量,然后你可以使用implement方法对类进行扩展,例如:
  1. var Person = new Class(function (name, age) {
  2. this.name = name;
  3. this.age = age;
  4. });
  5. Person.implement('log', function () {
  6. console.log(this.name + ',' + this.age);
  7. });
  8. var mark = new Person('mark', 24);
  9. mark.log(); // returns 'mark,24'
? 当然推荐使用的还是第一种方式,直观明了嘛。你如果使用标准方式建立了一个类,也是可以使用implement方法对类进行扩展的,如果你真的认为有必要把一个类的设计拆成几个部分的话(例如在使用掺元对象实现多亲继承时,神马?等等...这个MooTools里实现多亲继承继承不是使用Implements Mutator吗,嗯呐,这个在接下来类的继承中将详细讲解......),呵呵,至于MooTools内部如果对构造函数进行解析,有兴趣的可看看MooTools 1.4 源码分析 - Class 修正版。
? Implement and Extend
? Implement方法用来为类添加新的方法、属性。需要注意的是,如果新添加的方法或属性与类中旧有的方法或属性同名,则会覆盖类中旧有的方法、属性。调用Implement方法有两种方式,第一种方式传递两个参数,第一个参数为String类型,存储要添加的方法或属性的名称,第二个参数为方法所对应的函数或属性所对应的值,这种方式每次只能为类添加一个方法或属性:

  1. Person.implement('log', function () {
  2. console.log(this.name + ',' + this.age);
  3. });
  4. Person.implement('city', '深圳');
? 第二种方式传递一个对象字面量参数,把要添加的方法属性包含在这个对象中,一次添加多个方法、属性,避免重复调用implement:
  1. Person.implement({
  2. 'city': '深圳',
  3. 'log': function () {
  4. console.log(this.name + ',' + this.age);
  5. }
  6. });
? MooTools关于Class的官方文档中只暴露了implement一个方法,其实对类本身进行操作的还有一个比较重要的方法extend,这个方法之所以没有出现在Class的文档中。这是因为它不是作为Class的特殊方法,而实际上是Type的方法。它的作用是为类创建静态成员,静态成员关联的是类本身,换句话说,静态成员是在类的层次上操作,而不是在实例的层次上操作,每个静态成员都只有一份。调用extend方法的方式同Implement,也是两种方式。
? 简单一点讲,implement为实例创建方法和属性,extend为类本身创建方法和变量,请看下面的例子:

  1. var Person = new Class(function (name, age) {
  2. this.name = name;
  3. this.age = age;
  4. });
  5. Person.implement({
  6. instanceMethod: function () {
  7. console.log('From an instance!');
  8. }
  9. });
  10. Person.extend({
  11. classMethod: function () {
  12. console.log('From the class itself!');
  13. }
  14. });
  15. var mark = new Person('mark', 24);
  16. console.log(typeOf(mark.instanceMethod)); // returns 'function'
  17. mark.instanceMethod(); // returns 'From an instance!'
  18. console.log(typeOf(mark.classMethod)); // returns 'null',说明实例是不能调用静态方法的
  19. console.log(typeOf(Person.classMethod)); // returns 'function'
  20. Person.classMethod(); // returns 'From the class itself!'
  21. console.log(typeOf(Person.instanceMethod)); // returns 'null',同样类也不能直接调用为实例而创建的方法
  22. Person.prototype.instanceMethod(); // 类只能通过这种方式调用原型上的方法
? 私有成员
? 严格来讲,JavaScript中没有私有成员的概念,所有对象的属性都是共有的。不过,倒是有一个私有变量的概念,任何在函数中定义的变量,都可以认为是私有变量,因为不能在函数的外部访问浙西变量。私有变量包括函数的参数、局部变量和在函数内定义的其他函数。所以我们可以通过使用闭包来为类制造私有成员:

  1. var Person = (function () {
  2. // 私有变量
  3. var numOfPersons = 0;
  4. // 私有方法
  5. var formatName = function (name) {
  6. return name.capitalize();
  7. };
  8. return new Class({
  9. initialize: function (name, age) {
  10. this.name = name;
  11. this.age = age;
  12. numOfPersons++;
  13. },
  14. // 公有方法
  15. log: function () {
  16. console.log(formatName(this.name) + ',' + this.age);
  17. },
  18. getNumOfPersons: function () {
  19. return numOfPersons;
  20. }
  21. });
  22. })();
  23. var mark = new Person('mark', 24);
  24. mark.log(); // returns 'mark,24'
  25. console.log(mark.getNumOfPersons()); // returns 1
? 使用这个模式有一个好处就是,私有成员在内存中只会存放一份,是由所有实例共享的,不必为每一个实例生成一个副本。但这也延伸出一个问题,来看下面的代码:
  1. var Person = (function () {
  2. // 私有变量
  3. var name = '';
  4. return new Class({
  5. initialize: function (v1, v2) {
  6. name = v1;
  7. this.age = v2;
  8. },
  9. getName: function () {
  10. return name;
  11. },
  12. setName: function (value) {
  13. name = value;
  14. },
  15. getAge: function () {
  16. return this.age;
  17. },
  18. setAge: function (value) {
  19. this.age = value;
  20. }
  21. });
  22. })();
  23. var mark = new Person('mark', 24);
  24. console.log(mark.getName()); // 'mark'
  25. mark.setName('grey');
  26. console.log(mark.getName()); // 'grey'
  27. console.log(mark.getAge()); // 24
  28. var john = new Person('john', 18);
  29. console.log(john.getName()); // 'john'
  30. console.log(john.getAge()); // 18
  31. console.log(mark.getName()); // 'john'
  32. console.log(mark.getAge()); // 24
? 这个例子中的Person构造函数(这里指initialize)与getName()和setName()方法一样,都有权访问私有变量name,在这种模式下,变量name就变成了一个静态的、有所有实例共享的属性,也就是说,在一个实例上调用setName()会影响所有实例,结果就是所有实例getName()都会返回相同的值,而age是实例变量就不存在这个问题。到底是使用实例变量还是静态私有变量,最终还是要视你的需求而定。
? 当然上面这个问题只是针对私有变量的,私有方法就不存在这个问题,相比实例方法会更有效率(从内存占用的意义上来说),应为它只会被创建一份。
? 使用闭包还带来一个问题,多查找作用域链中的一个层次,就会在一定程度上影响查找的速度(一般情况下可以忽略不计),鱼与熊掌不可兼得啊......
? 常量
? 最简单设置常量的方法是为类添加一个静态属性,然而静态属性是公有的,类的使用者可以随时改变它的值,这个样的操作后果是很严重的。这里我们可以使用前面介绍的为类设置静态私有变量的方式来模拟常量,然后在实例方法中只创建取值器方法而不创建赋值器方法。这样类的使用者只能使用暴露出来的取值器方法来得到私有变量的值而不能改变它的值。来看下面的代码:

  1. var Person = (function () {
  2. // 私有变量
  3. var AGE_UPPER_BOUND = 32;
  4. return new Class({
  5. initialize: function (v1, v2) {
  6. // ...
  7. },
  8. getAGEUPPERBOUND: function (value) {
  9. return AGE_UPPER_BOUND;
  10. }
  11. });
  12. })();
? 如果需要使用多个常量,设置一个私有的对象字面量来存储这些常量,然后设置一个通用的取值器方法来取得这些常量:
  1. var Person = (function () {
  2. // 私有变量
  3. var constants = {
  4. AGE_UPPER_BOUND: 32,
  5. AGE_LOWER_BOUND: 18
  6. };
  7. return new Class({
  8. initialize: function (v1, v2) {
  9. // ...
  10. },
  11. getConstants: function (name) {
  12. return constants[name];
  13. }
  14. });
  15. })();
? 继承
? 继承的主要好处表现在代码的重用方面,通过建立类之间的继承关系,有些方法我们只需要定义一次就可以了。同样,如果需要修改这些方法或排查其中的错误,那么由于其定义只出现在一个位置,所以非常有利于节省时间和精力。MooTools实现类的继承有两种模式:原型式继承和多亲继承,原型式继承由内建的Extends Mutator来实现,多亲继承由Implements Mutator或implement方法来实现。
? 原型式继承这里就不多讲了,着重讲一下多亲继承。在JavaScript里,因为一个对象只能拥有一个原型对象,所以不允许子类继承多个超类,不过我们可以利用多个掺元类(minix class)或掺元对象对一个类进行扩充,这样类的实例就可以拥有mixin类(对象)中的方法、属性,所以这实际上实现了多继承的效果。通常mixin类(对象)包含一些通用的方法,大家可以看看MooTools里Class.Extras模块中三个mixin类的定义(Chain、Events、Options)。
? 这里还需要注意的的一点是,在派生具有私有成员的的类或implement mixin类(对象)时,因为在父类(或mixin)中访问这些私有变量的方法是公有的,所以他们也会被遗传下来。所以子类可以间接访问父类(或mixin)的私有成员,但子类自身的实例方法都不能直接访问这些私有属性,而且你也不能在子类中添加能够直接访问他们的方法(作用域变量,你想访问也访问不了啦,呵呵)。
? 首先我们先建立一个基类:
  1. var Animal = new Class({
  2. initialize: function (age) {
  3. this.age = age;
  4. }
  5. });
? 使用Extends Mutator派生一个子类:
  1. var Cat = new Class({
  2. Extends: Animal,
  3. initialize: function (name, age) {
  4. this.parent(age); // calls initalize method of Animal class
  5. this.name = name;
  6. }
  7. });
  8. var cat = new Cat('Micia', 20);
  9. console.log(cat.name); // 'Micia'
  10. console.log(cat.age); // 20
? 利用Implements Mutator扩充一个类,首先建立一个mixin类:
  1. var Mixin = new Class({
  2. getName: function () {
  3. return this.name;
  4. },
  5. setName: function (value) {
  6. this.name = value
  7. }
  8. });
  9. var Cat = new Class({
  10. Extends: Animal,
  11. Implements: Mixin,
  12. initialize: function (name, age) {
  13. this.parent(age); // calls initalize method of Animal class
  14. this.name = name;
  15. }
  16. });
  17. var cat = new Cat('Micia', 20);
  18. console.log(cat.name); // 'Micia'
  19. console.log(cat.age); // 20
  20. cat.setName('Dog');
  21. console.log(cat.getName()); // 'Dog'
? 使用implement方法扩充一个类,首先家里一个mixin对象:
  1. // mixin对象存储一些通用方法,可以被不同的类implement
  2. var objMixin = (function () {
  3. var counter = 0;
  4. return {
  5. init: function () {
  6. counter += 1;
  7. },
  8. getCounter: function () {
  9. return counter;
  10. },
  11. getAge: function () {
  12. return this.age;
  13. },
  14. setAge: function (value) {
  15. this.age = value;
  16. }
  17. };
  18. })();
  19. var Cat = new Class({
  20. Extends: Animal,
  21. Implements: Mixin,
  22. initialize: function (name, age) {
  23. this.parent(age); // calls initalize method of Animal class
  24. this.name = name;
  25. }
  26. });
  27. Cat.implement(objMixin);
  28. var Dog = new Class({
  29. Extends: Animal,
  30. Implements: Mixin,
  31. initialize: function (name, age) {
  32. this.parent(age); // calls initalize method of Animal class
  33. this.name = name;
  34. }
  35. });
  36. Dog.implement(objMixin);
  37. var cat = new Cat('Micia', 20);
  38. console.log(cat.name); // 'Micia'
  39. console.log(cat.age); // 20
  40. cat.setName('汤姆');
  41. console.log(cat.getName()); // '汤姆'
  42. cat.setAge(12);
  43. console.log(cat.getAge()); // 12
  44. // 对mixin对象的私有属性进行操作
  45. cat.init();
  46. console.log(cat.getCounter()); // 1
  47. var dog = new Dog('小狗', 6);
  48. console.log(dog.name); // '小狗'
  49. console.log(dog.age); // 6
  50. dog.setName('布鲁托');
  51. console.log(dog.getName()); // '布鲁托'
  52. dog.setAge(8);
  53. console.log(cat.getAge()); // 8
  54. // 对mixin对象的私有属性进行操作
  55. dog.init();
  56. console.log(dog.getCounter()); // 2
  57. console.log(cat.getCounter()); // 2
? 大家都看明白了吧,呵呵,不过通过上面的代码我们引申出另外一个问题,注意上面的Cat类的设计,我们首先设计了Extends,然后是Implements,再就是Cat类本身的方法属性,MooTools内部对Class构造函数解析时是按照我们设计时的顺序解析的吗?答案是按照我们设计时的顺序解释的。简单来讲MooTools通过for-in对对象进行枚举来遍历每个成员进行解释的,等等......那个ECMAScript最新版对for-in 语句的遍历机制又做了调整,属性遍历的顺序是没有被规定的,也就是说随机的,那么MooTools是怎样保证按顺序解释的呢?先看下面这段代码:
  1. var obj = {
  2. Waa: "Waa",
  3. aa: 'aa',
  4. 68: '68',
  5. 15: '15',
  6. tt: 'tt',
  7. '-7': '-7',
  8. _: "___",
  9. online: true
  10. };
  11. for (var k in obj) {
  12. console.log(k);
  13. }
? 把它放在各个浏览器都执行一遍,你会发现IE、火狐、Safari浏览器的JavaScript 解析引擎遵循的是较老的ECMA-262第三版规范,属性遍历顺序由属性构建的顺序决定,而Chrome、Opera中使用 for-in 语句遍历对象属性时会遵循一个规律,它们会先提取所有 key 的 parseFloat 值为非负整数的属性, 然后根据数字顺序对属性排序首先遍历出来,然后按照对象定义的顺序遍历余下的所有属性。其它浏览器则完全按照对象定义的顺序遍历属性。
? 这下明白了吧,只要你为类设计的方法、属性还有Mutator的名称不为数字就可以了(当然如果你非要有这样的嗜好,我也只能@#%&$......)。请看下面的代码:

  1. var Super = new Class({
  2. log: function () {
  3. console.log('Super');
  4. }
  5. });
  6. var Mixin = new Class({
  7. log: function () {
  8. console.log('Mixin');
  9. }
  10. });
  11. var Sub = new Class({
  12. Extends: Super,
  13. Implements: Mixin
  14. });
  15. var obj = new Sub();
  16. obj.log(); // ?
? 在这里obj.log()会返回什么呢?对了是'Maxin',这里Sub类首先继承了Super类,Sub的原型实际就是Super类的一个实例,Super的log方法也就是成了Sub的原型上的一个方法,然后执行Implements Mutator 为Sub类的原型扩展了一个Mixin类的实例上的方法,这时Mixin类实例上的log方法就覆盖了Sub类原型上原来的log方法(继承自Super类)。
? 如果把Extends、Implements的顺序颠倒一下:

  1. var Sub = new Class({
  2. Implements: Mixin,
  3. Extends: Super
  4. });
  5. var obj = new Sub();
  6. obj.log(); // ?
? 这时obj.log()会返回什么呢?还是'Maxin'吗?其实这里返回的是'Super',Why?前面我们介绍了MooTools对Class构造函数解析时是按照我们设计的顺序解析的,所以在这里首先执行的是Implements Mutator,它首先为Sub类的原型扩展了一个Mixin类的实例上的log方法,然后才是对超类Super的继承,因为在JavaScrpt里每个对象只有一个原型,原型式继承的原理就是超类的一个实例赋予子类的原型,子类原来的原型这时会被超类的实例替换掉,所以这是Sub类原型的引用已经指向了超类的实例,而他自己的原型对象这时被消除了,所以之前从Mixin类得来的那个log方法,对不起跟着一起魂飞湮灭了,所以这里返回的是'Super'。
? 当然如果你嫌不过瘾,那就在为Sub类添加一个log方法:

  1. var Sub = new Class({
  2. Implements: Mixin,
  3. Extends: Super,
  4. log: function () {
  5. console.log('sub');
  6. }
  7. });
  8. var obj = new Sub();
  9. obj.log(); // ?
? 你可以把Sub类的Implements、Extends、log来回颠倒一下看看效果,呵呵,再用implement方法在扩展一个试试:
  1. var objMixin = {
  2. log: function () {
  3. console.log('objMixin');
  4. }
  5. };
  6. var Sub = new Class({
  7. Implements: Mixin,
  8. Extends: Super,
  9. log: function () {
  10. console.log('sub');
  11. }
  12. });
  13. Sub.implement(objMixin);
  14. var obj = new Sub();
  15. obj.log(); // ?
? 呵呵,别晕掉,一切都是为了把问题搞的跟明白不是......
? 最后不要忘记两个重要的方法:parent()和protect(),这里就不多说了,在前面的Class源码分析里有详细介绍。
? 下一篇在详细讲解一下Mutators。
? 苦苦的苦瓜 2011-10-07

转载于:https://blog.51cto.com/hmking/682098

MooTools Class 使用、继承详解相关推荐

  1. python类继承中构造方法_第8.3节 Python类的__init__方法深入剖析:构造方法与继承详解...

    第8.3节Python类的__init__方法深入剖析:构造方法与继承详解 一.    引言 上两节介绍了构造方法的语法及参数,说明了构造方法是Python的类创建实例后首先执行的方法,并说明如果类没 ...

  2. (117)System Verilog类继承详解

    (117)System Verilog类继承详解 1.1 目录 1)目录 2)FPGA简介 3)System Verilog简介 4)System Verilog类继承详解 5)结语 1.2 FPGA ...

  3. 【职坐标】java面向对象三大特性(二)——继承详解

    [职坐标]java面向对象三大特性(二)--继承详解 a) 什么是继承? i. 多个类中存在相同属性和行为时,将这些内容抽取到单独一个类中,那么多个类无需再定义这些属性和行为,只要继承那个类即可 b) ...

  4. C++继承详解之四——is-a接口继承和has-a实现继承

    在学习继承的过程中,不管是在书中还是在网上找资料,都跟多态分不开,其中还有个很抓人眼球的问题,那就是书上总是说的is-a关系和has-a关系. 很多书中讲到继承时都会说: public继承是一个接口继 ...

  5. JavaScript继承详解(四)

    文章截图 - 更好的排版 在本章中,我们将分析Douglas Crockford关于JavaScript继承的一个实现 - Classical Inheritance in JavaScript. C ...

  6. JavaScript继承详解(四) 转

    在本章中,我们将分析Douglas Crockford关于JavaScript继承的一个实现 - Classical Inheritance in JavaScript. Crockford是Java ...

  7. python3类的继承详解_python3中类的继承以及self和super的区别详解

    python中类的继承: 子类继承父类,及子类拥有了父类的 属性 和 方法. python中类的初始化都是__init__().所以父类和子类的初始化方式都是__init__(),但是如果子类初始化时 ...

  8. C++继承和多态特性——继承详解(2)

    目录 一.派生类和基类的构造析构关系 1.派生类并不继承基类的构造和析构函数,只继承成员变量和普通成员方法 2.派生类的构造函数一定会调用基类的构造函数,析构也一样 3.为什么派生类的构造(析构)必须 ...

  9. 组合、聚合、继承详解

    有人学了继承,认为他是面向对象特点之一,就在所有能用到继承的地方使用继承,而不考虑究竟该不该使用,无疑,这是错误的.那么,究竟该如何使用继承呢? java中类与类之间的关系 大部分的初学者只知道jav ...

最新文章

  1. SAP MM 对于MRKO事务代码的几点优化建议
  2. c++ explicit(显式)关键字
  3. python interpreter 中没有torch_PyTorch扩展自定义PyThon/C++(CUDA)算子的若干方法总结
  4. JQuery中的.attr()与.removeAttr()
  5. rapidjson 嵌套json_[整理][RapidJson用法2]C++之RapidJson创建嵌套数组json | 勤奋的小青蛙...
  6. mfc大观之五、六(消息机制和消息运行)
  7. Windows 编程[20] - 改变菜单项并换行
  8. 二十四种设计模式:策略模式(Strategy Pattern)
  9. 二分法猜数——C/C++
  10. MySQL_DBA整理
  11. 500个运营工具大全,速度收藏!!!
  12. 前端 后端 MD5加盐
  13. 【Redis系列】Redis 入门指南
  14. hibernate 注解方式 属性mappedBy详解
  15. 设置华表Cell插件外观时的“闪烁”问题
  16. python 计算字符串表达式_python计算数学表达式
  17. nmn抗衰老是骗局吗,美国nmn骗局,正面解答
  18. 关于我很想吐槽公司的策划同学这件事
  19. Java异常 | JedisException: Could not get a resource from the pool
  20. android 5.1 随机IMEI号

热门文章

  1. 全国计算机等级2级试题,全国计算机等级考试二级QBASIC试题
  2. linux中如何撤销上次命令,使用git reset命令撤销上次Git提交
  3. 案例 | 新零售如何精细化运营?百联全渠道经验谈
  4. 恭喜神策数据客户趣店赴美 IPO 上市!
  5. 神策数据面向互联网金融企业提供行业解决方案
  6. Asp.net中网站级异常捕获
  7. VSCode插件开发全攻略(六)开发调试技巧
  8. mikrotik ros ***借线
  9. POJ 3417 Network
  10. Ubuntu下一个好用的终端