JavaScript模拟Java类继承

javascript采用原型继承的方式继承一个类（javascript没有类这个概念，暂时这么称呼吧），但一些使用过Java的程序员可能习惯使用经典的类继承，但javascript原生并不支持这种方式，因此需要手动实现。这里通过定义一个定义类（defineClass）的函数实现，经测试越用越顺手。由于javascript没有访问修饰符，因此如果需要使用到private成员，请使用闭包。

 

 1 /* 简单的对象扩充方法

 2  */

 3 merge:function (target, origin) {

 4     for (var attribute in origin) {

 5         if (origin.hasOwnProperty(attribute)) {

 6             target[attribute] = origin[attribute];

 7         }

 8     }

 9 },

10 defineClass:function defineClass(constructor, parent, properties, statics, isSingleton) {

11 

12     /* 如果为单例模式，保存实例，并在以后的调用中返回此实例

13      */

14     if (isSingleton) {

15         var oldConstructor = constructor,

16             instance;

17         constructor = function () {

18             if (instance) return instance;

19             oldConstructor.apply(this, arguments);

20             instance = this;

21         }

22     }

23 

24     /* 设置原型属性，这意味着传入的构造函数的原型属性将被覆盖

25      * 重要：parent内部需要检测参数，下面将会讲到

26      */

27     constructor.prototype = parent ? new parent() : {};

28 

29     /* 将自有属性复制到原型中

30      * 将静态属性复制到构造函数中，这意味着将不会继承parent的静态属性

31      */

32     Lang.merge(constructor.prototype, properties);

33     Lang.merge(constructor, statics);

34 

35     /* 将构造函数更改为当前构造函数

36      * 将parent的引用保留

37      */

38     constructor.prototype.constructor = constructor;

39     constructor.prototype.parent = parent;

40     constructor.parent = parent;

41 

42     /* 借用父类函数

43      */

44     constructor.borrow = function(methodName, context, args){

45         var oldParent;

46 

47         if(typeof methodName === "object") {

48             args = context;

49             context = methodName;

50         }

51 

52         oldParent = context.parent;

53         context.parent = parent;

54 

55         if(typeof methodName === "string") {

56             constructor.prototype[methodName].apply(context, args || []);

57         } else {

58             constructor.apply(context, args || []);

59         }

60 

61         context.parent = oldParent;

62     };

63     return constructor;

64 }

 

使用时，父类如此定义

 

 1 var Body = Lang.defineClass(function(x, y, shapes, sprites, detection){

 2     /* 由于类定义函数会创建父类实例作为子类的原型，因此必须检测参数

 3      * 如果没有参数，相当于调用父类的默认构造函数 

 4      */

 5     if(arguments.length) {

 6         /* 使用父类方法 

 7          */

 8         this.parent.borrow(this, arguments);

 9 

10         /* 非基本类型请放到构造函数中而不是原型中

11          */

12         this._tasks = [];

13     }

14 }, Object, {

15     _distance: 0,

16     setX: function(x){},

17     setY: function(y){}

18 }, {

19     type: 'Base'

20 });

 

继承Body

 

 1 var Ninja = Lang.defineClass(function(){

 2     this.parent.borrow(this, arguments);

 3 }, Body, {

 4     _status: 1,

 5     setStatus: function(x){

 6         /* 使用父类方法

 7          */

 8         this.parent.borrow('setStatus', this, arguments);

 9     }

10 }, {});

 

注意，不能用此方法继承如Array等内置对象，如果你想通过定义一个类扩展Array的功能，那么在调用Array的某些方法时会出现问题，比如concat返回的数组直接包含两个对象，而不是包含两个对象中的元素。原因是虽然子类的原型链包含Array.prototype，但毕竟不是由Array直接构造，在调用某些方法时可能不会按照原始的方式执行。