(function() {// 新建类var Person = my.Class({// 添加静态方法
    STATIC: {AGE_OF_MAJORITY: 18},// 构造函数constructor: function(name, age) {this.name = name;this.age = age;},// 实例方法sayHello: function() {console.log('Hello from ' + this.name + '!');},// 实例方法drinkAlcohol: function() {this.age < Person.AGE_OF_MAJORITY ?console.log('Too young! Drink milk instead!') :console.log('Whiskey or beer?');}});// 暴露给命名空间myLib.Person = Person;})();var john = new myLib.Person('John', 16);
john.sayHello(); //log "Hello from John!"
john.drinkAlcohol(); //log "Too young! Drink milk instead!"

(function() {//Dreamer 继承 Personvar Dreamer = my.Class(Person, {// 构造方法constructor: function(name, age, dream) {Dreamer.Super.call(this, name, age);this.dream = dream;},// 实例方法sayHello: function() {superSayHello.call(this);console.log('I dream of ' + this.dream + '!');},// 实例方法wakeUp: function() {console.log('Wake up!');}});// Super访问父类var superSayHello = Dreamer.Super.prototype.sayHello;// 暴露给全局命名空间myLib.Dreamer = Dreamer;})();var sylvester = new myLib.Dreamer('Sylvester', 30, 'eating Tweety');
sylvester.sayHello(); //log "Hello from Sylvester! I dream of eating Tweety!"
sylvester.wakeUp(); //log "Wake up!"

// 给myLib.Dreamer添加新方法
my.extendClass(myLib.Dreamer, {// 添加静态方法
  STATIC : {s_dongSomeThing : function(){console.log("do some thing!");    }},// 添加实例方法touchTheSky: function() {console.log('Touching the sky');},// 添加实例方法reachTheStars: function() {console.log('She is so pretty!');}});

// 声明一个新类
myLib.ImaginaryTraveler = my.Class({travel: function() { console.log('Traveling on a carpet!'); },crossOceans: function() { console.log('Saying hi to Moby Dick!'); }
});(function() {//Dreamer 继承 Person 实现 ImaginaryTraveler的方法var Dreamer = my.Class(Person, ImaginaryTraveler, {// 构造方法constructor: function(name, age, dream) {Dreamer.Super.call(this, name, age);this.dream = dream;}// ...
});// 暴露给全局命名空间myLib.Dreamer = Dreamer;})();var aladdin = new Dreamer('Aladdin');
aladdin instanceof Person; //true
aladdin instanceof ImaginaryTraveler; //false
aladdin.travel();
aladdin.wakeUp();
aladdin.sayHello();

var Person = my.Class({//you can now call the constructor with or without newconstructor: function(name, city) {if (!(this instanceof Person))return new Person(name, city);this.name = name;this.city = citye;}});

/*globals define:true, window:true, module:true*/
(function () {// Namespace objectvar my = {};// 保证AMD分模块可用if (typeof define !== 'undefined')define([], function () {return my;});else if (typeof window !== 'undefined')// 保证客户端可用window.my = my;else// 保证后台可用module.exports = my;//============================================================================// @method my.Class// @params body:Object// @params SuperClass:function, ImplementClasses:function..., body:Object// @return functionmy.Class = function () {var len = arguments.length;var body = arguments[len - 1];    // 最后一个参数是指定本身的方法var SuperClass = len > 1 ? arguments[0] : null;     // 第一个参数是指继承的方法，实例和静态部分均继承var hasImplementClasses = len > 2;    // 如果有第三个参数，那么第二个就是implementClass,这里其实只继承实例对象var Class, SuperClassEmpty;// 保证构造方法if (body.constructor === Object) {Class = function() {};} else {Class = body.constructor;// 保证后面不覆盖constructordelete body.constructor;}// 处理superClass部分if (SuperClass) {// 中间件实现实例属性的继承SuperClassEmpty = function() {};SuperClassEmpty.prototype = SuperClass.prototype;Class.prototype = new SuperClassEmpty();    // 原型继承，解除引用Class.prototype.constructor = Class;    // 保证constructorClass.Super = SuperClass;    // 父对象访问接口// 静态方法继承，重载superClass方法extend(Class, SuperClass, false);}// 处理ImplementClass部分,其实只继承实例属性部分,除SuperClass #arguments[0]# 和 body #arguments[length-1]#if (hasImplementClasses)for (var i = 1; i < len - 1; i++)// implement是继承的实例属性部分, 重载父对象implementClass方法extend(Class.prototype, arguments[i].prototype, false);    // 处理本身声明body部分，静态要STATIC指定,实例部分要删除STATIC部分
    extendClass(Class, body);return Class;};//============================================================================// @method my.extendClass// @params Class:function, extension:Object, ?override:boolean=truevar extendClass = my.extendClass = function (Class, extension, override) {// 静态部分继承静态部分if (extension.STATIC) {extend(Class, extension.STATIC, override);// 保证实例部分不继承静态方法delete extension.STATIC;}// 实例属性继继承实例部
    extend(Class.prototype, extension, override);};//============================================================================var extend = function (obj, extension, override) {var prop;// 其实这里的flase是表明，覆盖父对象的方法if (override === false) {for (prop in extension)if (!(prop in obj))obj[prop] = extension[prop];} else {// 这里其实不覆盖父对象的方法,包括toStringfor (prop in extension)obj[prop] = extension[prop];if (extension.toString !== Object.prototype.toString)obj.toString = extension.toString;}};})();

// 声明一个类
var Person = klass(function (name) {this.name = name
}).statics({//静态方法head: ':)',feet: '_|_'}).methods({//实例方法walk: function () {}})

// SuperHuman 继承 Person
var SuperHuman = Person.extend(function (name) {// 自动调用父类的构造方法
}).methods({walk: function() {// 显式声明调用父类的walk方法this.supr()this.fly()},fly: function() {}})new SuperHuman('Zelda').walk()

var Foo = klass({foo: 0,initialize: function() {this.foo = 1},getFoo: function () {return this.foo},setFoo: function (x) {this.foo = xreturn this.getFoo()}
})

// 可以传递一个字面量去继承
var Alien = SuperHuman.extend({beam: function() {this.supr()// beam into space
  }
})var Spazoid = new Alien('Zoopo')if (beamIsDown) {// 覆写beam方法
  Spazoid.implement({beam: function() {this.supr()// fallback to jetsthis.jets()}})
}

/*** Klass.js - copyright @dedfat* version 1.0* https://github.com/ded/klass* Follow our software http://twitter.com/dedfat :)* MIT License*/
!function (context, f) {// fnTest用来验证是否可能通过正则找出调用super父类方法的方法var fnTest = /xyz/.test(function () {xyz;}) ? /\bsupr\b/ : /.*/,noop = function (){},proto = 'prototype',isFn = function (o) {return typeof o === f;};// 基础类function klass(o) {return extend.call(typeof o == f ? o : noop, o, 1);}// 包装成一个借用super同名方法的函数function wrap(k, fn, supr) {return function () {// 缓存原this.supervar tmp = this.supr;// 暂把this.super改造成借用super的同名方法above// 供o里显式的声明(fnTest.text(fn)==true)要借用super的同名方法使用this.supr = supr[proto][k];// 借用执行并保存返回值var ret = fn.apply(this, arguments);// 恢复原this.superthis.supr = tmp;// 返回返回值，保证wrap后的返回值跟原来一致return ret;};}// 如果o和super有同名方法，且o显式声明借用super的同名方法，就wrap成一个待执行函数供使用// 如果没有显式的声明借用super的同名方法,或者是o独有的方法，或者不是方法就直接用function process(what, o, supr) {for (var k in o) {// 如果是非继承方法,按方法注释规则执行,最终都放进whatif (o.hasOwnProperty(k)) {what[k] = typeof o[k] == f&& typeof supr[proto][k] == f&& fnTest.test(o[k])? wrap(k, o[k], supr) : o[k];}}}// 继承方法的实现,fromSub是用来控制是否继承而来,上面的klass里面fromSub是1,表明非继承而来,构造函数不借用super执行function extend(o, fromSub) {// noop做为媒介类实现原型继承的解除引用noop[proto] = this[proto];var supr = this,prototype = new noop(), // 创建实例对象供原型继承使用，解除引用isFunction = typeof o == f,_constructor = isFunction ? o : this,// 如果o是一个构造方法就用,否则由this来决定构造函数_methods = isFunction ? {} : o,    // 如果o是一个{...}应该用methods放到fn原型里,如果里面有initialize就是构造函数,如果o是函数就由上面_constructor决定o是构造函数fn = function () { // 因为kclass借助了kclass,所以最终实际上返回的就是fn,fn其实就新类的构造函数//1 如果o是{...}就会被methods直接过滤并添加到fn的原型里,如果o里面有initialize,那么fn的原型里就有initialize,那么它就是构造方法//2 如果o是function,methods什么也添加不到fn的原型里,但是_constructor会接受o当构造函数//3 如果o是{....},同时里面也没有initialize,那么就是this当构造函数,如果在klass里由call决定,显然构造函数是noop,如果在非基础类里,构造函数就是父类的构造函数//  由于o不是函数不会自动调用父类的构造函数,只是把父类的构造函数当做当前类的构造函数----这都是由于this的指向决定的console.log(this);if (this.initialize) {this.initialize.apply(this, arguments);} else {// 调用父类构造方法// 如上面3,o不是函数,不会调用父类的构造方法// 基础类无父类,不会调用父类构造方法fromSub || isFn(o) && supr.apply(this, arguments);// 调用本类构造方法// 参考上面2,3要么是noop要么是oconsole.log(_constructor==noop);_constructor.apply(this, arguments);}};// 构造原型方法的接口fn.methods = function (o) {process(prototype, o, supr);fn[proto] = prototype;return this;};// 执行实现新类原型，保证新类的constructorfn.methods.call(fn, _methods).prototype.constructor = fn;// 保证新类可以被继承fn.extend = arguments.callee;// 添加实例方法或者静态方法,statics:静态方法,implement实例方法fn[proto].implement = fn.statics = function (o, optFn) {// 保证o是一个object对象，如果o是一个字符串，那么就是添一个方法的情况，如果o是一个object对象说明是批量添加的// 因为要从o里面拷贝o = typeof o == 'string' ? (function () {var obj = {};obj[o] = optFn;return obj;}()) : o;// 添加实例方法或者静态方法,statics:静态方法,implement实例方法process(this, o, supr);return this;};return fn;}// 后台用,nodejsif (typeof module !== 'undefined' && module.exports) {module.exports = klass;} else {var old = context.klass;// 防冲突klass.noConflict = function () {context.klass = old;return this;};// 前台浏览器用//window.kclass = kclass;context.klass = klass;}}(this, 'function');

function F() {};
F.prototype = superCtor.prototype;
ctor.prototype = new F();
ctor.prototype.constructor = ctor;

var Class = (function() {  /**  * Inherits function.(node.js)  *   * @param ctor subclass's constructor.  * @param superctor superclass's constructor.  */  var inherits = function(ctor, superCtor) { // 显式的指定父类ctor.super_ = superCtor;  // ECMAScript 5  原型式继承并解除引用if (Object.create) {  ctor.prototype = Object.create(superCtor.prototype, {  constructor: {  value: ctor,  enumerable: false,  writable: true,  configurable: true  }  });  } else {  // 无Object.create方法的平稳退化function F() {};  F.prototype = superCtor.prototype;  ctor.prototype = new F();  ctor.prototype.constructor = ctor;  }  };  /**  * Class function.  */  return function() {  // 最后一个参数是新类方法、属性和构造函数声明var subClazz = arguments[arguments.length - 1] || function() {};  // initialize是构造函数，否构造函数就是一个空函数var fn = subClazz.initialize == null ? function() {} : subClazz.initialize;  // 继承除最一个参数以的类，多继承，也可以用作扩展方法 for (var index = 0; index < arguments.length - 1; index++) {  inherits(fn, arguments[index]);  }  // 实现新类的方法for (var prop in subClazz) {  if (prop == "initialize") {  continue;  }  fn.prototype[prop] = subClazz[prop];  }  return fn;  }  })(); 

/**  * The definition of Cat Class.  */
var Cat = Class({  /**  * Constructor.  *   * @param name Cat's name  */  initialize: function(name) {this.name = name;  },  /**  * Eat function.  */  eat: function() {  alert(this.name + " is eating fish.");  }
});  /**  * The definition of Black Cat Class.  */
var BlackCat = Class(Cat, {  /**  * Constructor.  *   * @param name Cat's name.  * @param age Cat's age.  */  initialize: function(name, age) {  // call the constructor of super class.  BlackCat.super_.call(this, name);  this.age = age;  },  /**  * Eat function.  */  eat: function() {  alert(this.name + "(" + this.age + ") is eating dog.");  }
});  /**  * The definition of Black Fat Cat Class.  */
var BlackFatCat = Class(BlackCat, {  /**  * Constructor.  *   * @param name Cat's name.  * @param age Cat's age.  * @param weight Cat's weight.  */  initialize: function(name, age, weight) {  // call the constructor of super class.  BlackFatCat.super_.call(this, name, age);  this.weight = weight;  },  /**  * Eat function.  */  eat: function() {  alert(this.name + "(" + this.age + ") is eating dog. My weight: " + this.weight);  }
});  /**  * The definition of Dog Class.  */
var Dog = Class({});  var cat = new BlackFatCat("John", 24, "100kg");
cat.eat();  // true
alert(cat instanceof Cat);  // true
alert(cat instanceof BlackCat);  // true
alert(cat instanceof BlackFatCat);  // true
alert(cat.constructor === BlackFatCat);  // false
alert(cat instanceof Dog);  

var Cat = new Class({initialize: function(name){this.name = name;}
});
var myCat = new Cat('Micia');
alert(myCat.name); // alerts 'Micia'var Cow = new Class({initialize: function(){alert('moooo');}
});

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 classthis.name = name;}
});
var myCat = new Cat('Micia', 20);
alert(myCat.name); // alerts 'Micia'.
alert(myCat.age); // alerts 20.

var Animal = new Class({initialize: function(age){this.age = age;}
});
var Cat = new Class({Implements: Animal,setName: function(name){this.name = name}
});
var myAnimal = new Cat(20);
myAnimal.setName('Micia');
alert(myAnimal.name); // alerts 'Micia'.