实现javaScript对象的"继承"的两种方法(prototype与闭包)

javaScript的prototype属性:

什么是prototype:

javaScript的方法分为三类:

• 类方法

• 对象方法

• 原型方法

function People(name)
{
  this.name=name;
  //对象方法
  this.Introduce=function(){
    alert("My name is "+this.name);
  }
}
//类方法
People.Run=function(){
  alert("I can run");
}
//原型方法
People.prototype.IntroduceChinese=function(){
  alert("我的名字是"+this.name);
}



//测试

var p1=new People("Windking");

p1.Introduce();

People.Run();

p1.IntroduceChinese();

javascript中的每个对象都有prototype属性，Javascript中对象的prototype属性的解释是：返回对象类型原型的引用。

定义：原型就是一个函数对象的属性。
作用：

• 利用原型为函数对象增加属性和方法
• 函数对象的属性或方法与原型的属性或方法同名时:
• 函数对象本身的属性和方法的优先级要高于原型上的熟悉感和方法
• 利用函数对象的属性和方法重写原型上的属性和方法
• 内建对象(应该都是函数对象)：都有prototype属性
• 可以扩展内建对象的属性和方法
• 实现继承

在简单了解了prototype的作用后，我们来使用prototype来实现继承。

利用prototype来实现继承

定义一个Person类

function  Person(){
   this.sayHello = function(){
      alert("helloworld");
     }
}
Person.prototype.setName=function(name){
  this.name = name;
}
Person.prototype.getName=function(){
  return this.name;
}
var p = new Person();
p.sayHello();
p.setName("wang");
alert(p.getName());

现在我们定义一个Student类来继续Person类:

function Student(){

}
Student.prototype = new Person();
var s = new Student();
s.sayHello();
s.setName("xi");
alert(s.getName());

这样Student类即继承了Person类。

使用javaScript的闭包来完成继承:

1.什么是js的闭包

js闭包Demo:

    function A(){ 

    function B(){
     alert("Hello Closure!"); 
} 
 return B; 
} 
  var b = A(); 
   b();//Hello Closure! 

这是史上最简单的闭包，不能再简单了，再简单就不是闭包了！B为在函数内部定义的函数，用A函数返回，并用b来接收，也就是说在函数内部定义的函数，在外部使用，这种现象为闭包，所以继承的封装是闭包的一种应用。

2.闭包的作用

avascript中的GC机制:在javascript中，如果一个对象不再被引用，那么这个对象就会被GC回收，否则这个对象一直会保存在内存中。

在上述例子中，B定义在A中，因此B依赖于A,而外部变量b又引用了B, 所以A间接的被b引用，也就是说，A不会被GC回收，会一直保存在内存中。
这就是闭包的作用，有时候我们需要一个模块中定义这样一个变量：希望这个变量一直保存在内存中但又不会“污染”全局的变量，这个时候，我们就可以用闭包来定义这个模块。

闭包无处不在，比如：jQuery、zepto的主要代码都包含在一个大的闭包中,上面的写法其实是最简单最原始的写法，而在实际应用中，没人这么玩，特别是在一些大型JS框架中更不会这么写。现在我们来写一个闭包的高端用法:

    (function(document){ 

        var viewport; 

        var obj = { 
           init:function(id)
           {         
           viewport = document.querySelector("#"+id);   
           },          
           addChild:function(child){ 
           viewport.appendChild(child); 
           }, 
           removeChild:function(child){
            viewport.removeChild(child); 
           } } 
        window.jView = obj; 

    })(document); 

这个组件的作用是：初始化一个容器，然后可以给这个容器添加子容器，也可以移除一个容器。功能很简单，但这里涉及到了另外一个概念：立即执行函数。 简单了解一下就行。主要是要理解这种写法是怎么实现闭包功能的。

(function(){})() 红色部分是一个表达式，而这个表达式本身是一个匿名函数，所以在这个表达式后面加()就表示执行这个匿名函数。

因此这段代码执行执行过程可以分解如下：

    var f = function(document){

        var viewport; 

        var obj = { 

         init:function(id){ 
            viewport = document.querySelector("#"+id);
         },
        addChild:function(child){        
             viewport.appendChild(child); 
         }, 
         removeChild:function(child){               
            viewport.removeChild(child);
          } }

 window.jView = obj; 

    }; 

    f(document); 

在这段代码中似乎看到了闭包的影子，但 f 中没有任何返回值，似乎不具备闭包的条件，注意这句代码：

    window.jView = obj;

obj 是在 f 中定义的一个对象，这个对象中定义了一系列方法， 执行window.jView = obj 就是在 window 全局对象定义了一个变量 jView，并将这个变量指向 obj 对象，即全局变量 jView 引用了 obj . 而 obj 对象中的函数又引用了 f 中的变量 viewport ,因此 f 中的 viewport 不会被GC回收，会一直保存到内存中，所以这种写法满足闭包的条件。

了解了js的闭包之后使用闭包来实现继承

function extend(obj1){
    function F(){ }
   //判断传递进行的是一个new出来的对象
   if(typeof obj1 == "object"){
        for(var i in obj1){
        //直接调用对象的属性来获取，调用方法的prototype来接受
          F.prototype[i] = obj1[i];
         }
    }
    //返回函数
    return  F;
}
var person_son = extend(new Person());
var p = new person_son();
p.sayHello();
p.setName("abc");
alert(p.getName());

如上使用闭包也可以完成继承。