JavaScript继承与聚合实例详解

//创建一个人员类
function Person(name) {//现在Person里面的域是由Person里面的
来this来控制的
  this.name=name;
}

function Teacher(name,books) {
  Person.call(this,name);//相当于java中的super函数 在new Teacher时将Person的name初始化
  this.books=books;
}

Teacher.prototype=new Person();
Teacher.prototype.constructor=Teacher;//确保继承后任然是Teacher自己的构造函数

Teacher.prototype.getBook=function () {
  return this.name+" "+this.books;
}

var jim=new Teacher("Jim","Javascript");
alert(jim.getBook())

//创建一个人员类
function Person(name) {//现在Person里面的域由Person里面的来this来控制的
  this.name=name;
}

/*创建extend函数为了程序中所有的继承操作*/
//subClass:子类 superClass：超类（2）
function extend(subClass,superClass) {
    //1，使子类原型属性等于父类的原型属性
    //初始化一个中间空对象，目的是为了转换主父关系
    var F = function () {};
    F.prototype = superClass.prototype;
    //2， 让子类继承F
    subClass.prototype = new F();
    subClass.prototype.constructor = subClass;
    //3，为子类增加属性 superClass ==》原型链的引用
    subClass.superClass = superClass.prototype;
    //4，增加一个保险，就算你的原型类是超类（Object）那么也要把你的构造函数级别降下来  【说明一些：这里只是其中一个简单的保险，其余情况后续增加。。。】
    if (superClass.prototype.constructor == Object.prototype.constructor) {
      superClass.prototype.constructor = superClass;
    }
}

function Author(name,books) {
  Author.superClass.constructor.call(this,name);//没有直接写父类，降低了耦合度
  //Person.call(this,name)  直接写Person代表其构造函数
  this.books=books;
  this.getBooks=function () {
    return this.name+" "+this.books ;
  }
}

//继承
extend(Author,Person);//（子类，父类）

var peter=new Author("Peter","Javascript");
alert(peter.getBooks());

Author.superClass.constructor.call(this,name);

var JSON={//写到类的内部
    toJsonString:function () {
      var output=[];
      for(key in this){//this代表那个调用，就指向那个一个对象
        output.push(key+"---->"+this[key]);
      }
      return output;
    }
};

/*聚合函数
receivingClass：接受聚合内容的类
givingClass：被聚合的目标类
* */
function mixin(receivingClass,givingClass){
    for(methodName in givingClass){
      if(!receivingClass.__proto__[methodName]){//判断当前原型中是否含有即将要被聚合的方法，若没有则聚合进来
        receivingClass.__proto__[methodName]=givingClass[methodName];//直接获得类中的方法，因为方法是直接写在方法内部的。
      }
    }
}

var get={name:"Text",age:20};

mixin(get,JSON);//(受体，给体)

document.write(get.toJsonString().join(","));

var a=function(){}

var JSON={};
JSON.prototype={//写到类的原型对象上
 toJsonString:function () {
 var output=[];
 for(key in this){//this代表那个调用，就指向那个一个对象
 output.push(key+"---->"+this[key]);
 }
 return output;
 }
}

function mixin(receivingClass,givingClass) {
 for(methodName in givingClass.prototype){
 if(!receivingClass.prototype[methodName]){//判断当前原型中是否含有即将要被聚合的方法，若没有则聚合进来
 receivingClass.prototype[methodName]=givingClass.prototype[methodName];
 }
 }
}

var o=function () {
 this.name="聚合";
 this.age=19;
}

mixin(o,JSON);//（受体，给体）

var useO=new o();
document.write(useO.toJsonString().join(","));