js面向对象

 对象其实就是一种引用类型。而对象的值就是引用类型的实例。在JavaScript 中引用类型是一种数据结构，将数据和功能组织在一起。它也常被称做为类，但JavaScript 中却没有类的概念。虽然JavaScript 是一门面向对象的语言，却不具备传统面向对象语言所支持的类和接口等基本结构。  
## 对象的创建以及常用操作 ##

1. **使用new运算符**

        var user = new Object();        //使用new运算符创建一个对象
        user.name = '编程浪子';        //给对象添加属性
        user.age = 22;
        user.address = '四川成都';  

2. **对象字面量(JSON方式)**  


        var user = {
            name:'编程浪子',
            age:22,
            address:'四川成都'    
        };  

3. **简单方式(传统赋值方式)**  


        var user = {};
        user.name = '编程浪子';        //给对象添加属性
        user.age = 22;
        user.address = '四川成都';
4. **属性的调用**  

    对于对象属性的调用有两种方式：
    
    调用方法如下：
    
    alert(user.name + " " +user.age);//返回 '编程浪子 四川成都'  
    
    另一种方法： 
     
    alert(user['name'] + " " +user['age']);//返回 '编程浪子 四川成都'    
5. **添加方法**  

    
    var user = {
            name:'编程浪子',        //给对象添加属性
            age:22,
            address:'四川成都',
            showInfo:function(){//添加一个方法
                alert(this.name+" "+this.age+" "+this.address);
            },
            showHello:showHello//将对象外部的方法添加到对象
        };
        function showHello(){
            alert("Hello!");    
        }
        user.showInfo();//调用方法
        user.showHello(); 

## 创建对象 ##
我们知道，要创建一个对象我们可以用如下代码：  

    var user = new Object();  
    user.name = '编程浪子';
    user.age = 22;
    user.address = '四川成都';  
用这样的方法创建对象比较简单直观，也是JavaScript种创建对象最基本的方法。但是这样就有一个问题，如果我们需要创建多个对象，那么我就得写很多重复的代码。比如我们想创建另一个对象user1，我们就得重新将上面的代码重新写一遍，这在实际开发过程中是不合适的，这样如果对象过多，代码量将大大增加。

为了解决这样的问题，我们可以使用一种叫做**工厂模式**的方法，这种方法 就是为了解决实例化对象产生大量重复代码的问题。  
## 工厂模式 ##
    function create(name, age) {
    　　var obj = new Object(); 
    　　obj.name = name; 
    　　obj.age = age;
    　　obj.show = function () {
    　　　　return this.name +' '+ this.age;
    　　};
    　　return obj;
    }
    var obj1= create('bclz', 30);    //第一个实例
    var obj2= create('bcxb', 20);    //第二个实例
    alert(obj1.show());
    alert(obj2.show());  
从上面的代码我们可以看出，工厂模式解决了实例化时代码大量重复的问题，但又出现了一个问题，那就是识别问题，我们根本无法弄清楚他们到底是哪个对象的实例。比如

    alert(typeof obj1);  //Object

    alert(obj1 instanceof Object);  //true

以上代码标明obj1是Object对象，但是我们无法知道具体是哪一个对象创建的。  
## 构造函数(构造方法) ##
    function User(name, age) {    //构造函数模式
    　　this.name = name;
    　　this.age = age;
    　　this.show = function () {
    　　　　return this.name  + ' '+this.age;
    　　};
    }  
创建对象的时候用new运算符就可以了：

    var user1 = new User('bclz', 30);    //第一个实例
    var user2 = new User('bcxb', 20);    //第二个实例

现在我们就可以检测user1或者user2是不是属于User。

alert(user1 instanceof User);//true

可见，使用构造函数的方法，即解决了**重复实例化**的问题，又解决了**对象识别**的问题。

要创建User对象的新实例，就要使用new操作符，使用这个方式构建实例对象，会经过下面4个步骤：

1.创建一个新对象；

2.将构造函数的作用域给新对象(因此this指向的这个新对象)。

3.执行构造函数内的代码在(为新对象添加属性)；

4.返回新对象。

不过需要注意下面两个问题:  


----------


**构造函数也是函数**  
构造函数与函数的唯一区别，就是调用方式的不同，不过，构造函数毕竟也是函数，不存在什么特殊的定义构造函数的语法。任何函数，只要通过new操作符来调用，就可以把它看作是构造函数；而任何函数，如果不通过new操作符调用，它就和普通函数没有什么区别，例如前面定义的User:  
    
    //当作构造函数调用
    var user1 = new User('bclz', 30);  
    user1.show(); //bclz 30;

    //当作普通函数调用
    User('bclz', 30);
    window.show(); //bclz 30;  
结果上没有什么区别，只是大家可以看到，当作普通函数调用的话，函数里this对象的指向，其实是指向的window全局对象。而通过new关键字调用，this指向的则是新对象而已，所以，其实还可以这么来写:
  
    var o = new Object();
    User.call(o,'bclz', 30)；
    o.show();  
通过函数方法call来重新定义对象的作用域，这里不多做解释，讲到函数细节时再仔细介绍这种方法，这里只是说明可以改变对象的作用域的，其实就是**改变this的指向**  


----------

   

**构造函数的问题**

构造函数的模式虽然好，但是并非没有缺点。构造函数最大的问题就是，每个方法都要在实例上重新创建一次。在前面的例子中,user1和user2中都有一个show方法，如果我们执行以下语句：

    alert(user1.show==user2.show);//结果返回的是false

结果返回的是false，这就说明方法其实也是一种引用地址。如果我们同样重复创建了多个对象，那么每个对象中的方法都会在内存中开辟新的空间，这样浪费的空间就比较多。要解决这个问题，我们就需要用到实例属性或者方法的共享。  我们可以使用一种变通的方式，来达到我们想要的效果，也就是让show方法不再重复创建  

    function User(name, age) {    
    　　this.name = name;
    　　this.age = age;
    　　this.show = show;
    } 
    function show(){
        alert(this.name + ' ' + this.age);
    }  

将show方法移到外部，相当于show方法成了一个全局函数,然后再到User构造函数内部去引用show方法，这样User内部的this.show都指向了同一个全局函数show，因此，我们实例化的user1和user2就实现了共享，可以再次调用:

    alert(user1.show==user2.show);//结果返回的是true  
但是这只是一个测试，如果你要让更多的属性或者方法实现共享，那不是要定义更多的全局函数或者变量，这种方式是不科学也不可行的。因此，我们需要引入另外一个javascript面向对象的重要概念**原型**

 

## Prototype原型模式 ##
 

----------
## 通过构造函数的弊端引出原型概念 ##
为了讲清楚原型，我们还是必须先回顾一下构造函数的问题，用一个简单的例子再次讲解一下,我们有一只猫的构造函数，如下:  

    function Cat(name,color){
        this.name = name;
        this.color = color;
    }
这个构造函数很简单，不再多说，那么现在再为这个函数添加一个不变的属性"type"（种类），再添加一个方法eat（吃老鼠）。那么，Cat就变成了下面这样:  

    function Cat(name,color){
        this.name = name;
        this.color = color;
        this.type = "猫科动物";
        this.eat = function(){alert("吃老鼠");};
    }
生成实例:  

    var cat1 = new Cat("大毛","黄色");
    var cat2 = new Cat ("二毛","黑色");
    alert(cat1.type); // 猫科动物
    cat1.eat(); // 吃老鼠  

表面上好像没什么问题，但是实际上这样做，有一个很大的弊端。那就是对于每一个实例对象，type属性和eat()方法都是一模一样的内容，每一次生成一个实例，都必须为重复的内容，多占用一些内存。这样既不环保，也缺乏效率。  

    alert(cat1.eat == cat2.eat); //false 
 
因此，为了让type属性和eat()方法在内存中**只生成一次**，然后所有实例都指向那个内存地址，引出了原型

----------
## 什么是原型？ ##

> 原型对象实际上就是构造函数的一个实例对象，和普通的实例对象没有本质上的区别。可以包含特定类型的所有实例的共享属性或者方法。 这个prototype的属性值是一个对象（属性的集合），默认的只有一个叫做constructor的属性，指向这个函数本身。  
  
比如我们简单定义一个SuperType名字的函数，里面什么属性也没有在函数内部是这个样子的   
 
    function SuperType(){
    }  
  

从上图我们看到，函数里面虽然什么都没有，但是有一个默认的prototype属性,它是一个对象，它指向的是自己的地址，而prototype这个对象本身里面又有一个属性constructor，而这个属性，又指向了函数本身,有点绕，你可以通过下面的代码做一下测试，看看效果  

    alert(SuperType.prototype) //object
    alert(SuperType.prototype.constructor) //弹出函数本身function SuperType(){}   


----------
  
prototype和constructor是原型最基本的概念,现在看可能还有点晕，没关系，我直接上以前的代码，看看区别,还是之前的Cat构造函数，将它修改一下:  

    function Cat(name,color){
        this.name = name;
        this.color = color;
    }
    Cat.prototype.type = "猫科动物";
    Cat.prototype.eat = function(){alert("吃老鼠")};  
生成实例:

    var cat1 = new Cat("大毛","黄色");
    var cat2 = new Cat("二毛","黑色");
    alert(cat1.type); // 猫科动物
    cat1.eat(); // 吃老鼠  
这时所有实例的type属性和eat()方法，其实都是**同一个内存地址**，**指向prototype对象**，因此就提高了运行效率。 
 
    alert(cat1.eat == cat2.eat); //true

## Prototype模式的验证方法 ##
为了配合prototype属性，Javascript定义了一些辅助方法，帮助我们使用它。  

**isPrototypeOf()**  

这个方法用来判断，某个proptotype对象和某个实例之间的关系。   

    alert(Cat.prototype.isPrototypeOf(cat1)); //true
    alert(Cat.prototype.isPrototypeOf(cat2)); //true   

**hasOwnProperty()**  
每个实例对象都有一个hasOwnProperty()方法，用来判断某一个属性到底是本地属性，还是继承自prototype对象的属性。

    alert(cat1.hasOwnProperty("name")); // true
    alert(cat1.hasOwnProperty("type")); // false  

**in运算符**  
in运算符可以用来判断，某个实例是否含有某个属性，不管是不是本地属性。  

    alert("name" in cat1); // true
    alert("type" in cat1); // true  

in运算符还可以用来遍历某个对象的所有属性。  

    for(var prop in cat1) { 
        alert("cat1["+prop+"]="+cat1[prop]); 
    }

----------

来看一下 **javascript高级程序设计** 书中对与原型的描述和说明  

    function Person(){ }  //创建Person构造函数
    Person.prototype.name = "Nicholas";//创建共享属性name 
    Person.prototype.age = 29; //创建共享属性age 
    Person.prototype.job = "Software Engineer"; //创建共享属性job 
    Person.prototype.sayName = function(){     //创建共享函数sayName
        alert(this.name); 
    };  
    
    //分别创建了person1和person2,里面都有sayName函数，并且弹出的值都是一样
    var person1 = new Person(); 
    person1.sayName();   //"Nicholas"  
    var person2 = new Person();
    person2.sayName();   //"Nicholas"  
    alert(person1.sayName == person2.sayName);  //true   
  
通过上面的图，可以看到，person1和person2，他们内部都有一个指向Person.prototype的指针，可以通过原型的isPrototype方法测试一下 
 
    alert(Person.prototype.isPrototypeOf(person1));  //true
    alert(Person.prototype.isPrototypeOf(person2));  //true
    function User(){};
    var person3 = new User();
    alert(Person.prototype.isPrototypeOf(person3));  //false
    alert(User.prototype.isPrototypeOf(person3));  //true  


作为类比，我们考虑下JavaScript中的数据类型 - 字符串（String）、数字（Number）、数组（Array）、对象（Object）、日期（Date）等。 我们有理由相信，在JavaScript内部这些类型都是作为构造函数来实现的，比如：
    // 定义数组的构造函数，作为JavaScript的一种预定义类型
    function Array() {
        // ...
    }
            
    // 初始化数组的实例
    var arr1 = new Array(1, 56, 34, 12);
    // 但是，我们更倾向于如下的语法定义：
    var arr2 = [1, 56, 34, 12];  

同时对数组操作的很多方法（比如concat、join、push）应该也是在prototype属性中定义的。 
实际上，JavaScript所有的固有数据类型都具有只读的prototype属性（这是可以理解的：因为如果修改了这些类型的prototype属性，则哪些预定义的方法就消失了）， 但是我们可以向其中添加自己的扩展方法。  

        // 向JavaScript固有类型Array扩展一个获取最小值的方法
        Array.prototype.min = function() {
            var min = this[0];
            for (var i = 1; i < this.length; i++) {
                if (this[i] < min) {
                    min = this[i];
                }
            }
            return min;
        };
        
        // 在任意Array的实例上调用min方法
        console.log([1, 56, 34, 12].min());  // 1 

注意：这里有一个陷阱，向Array的原型中添加扩展方法后，当使用for-in循环数组时，这个扩展方法也会被循环出来。 
下面的代码说明这一点（假设已经向Array的原型中扩展了min方法）：  

        var arr = [1, 56, 34, 12];
        var total = 0;
        for (var i in arr) {
            total += parseInt(arr[i], 10);
        }
        console.log(total);   // NaN  

解决方法也很简单：  

        var arr = [1, 56, 34, 12];
        var total = 0;
        for (var i in arr) {
            if (arr.hasOwnProperty(i)) {
                total += parseInt(arr[i], 10);
            }
        }
        console.log(total);   // 103

## constructor ##
constructor始终指向创建当前对象的构造函数。比如下面例子：  

        // 等价于 var foo = new Array(1, 56, 34, 12);
        var arr = [1, 56, 34, 12];
        console.log(arr.constructor === Array); // true
        // 等价于 var foo = new Function();
        var Foo = function() { };
        console.log(Foo.constructor === Function); // true
        // 由构造函数实例化一个obj对象
        var obj = new Foo();
        console.log(obj.constructor === Foo); // true
        
        // 将上面两段代码合起来，就得到下面的结论
        console.log(obj.constructor.constructor === Function); // true 
  
但是当constructor遇到prototype时，有趣的事情就发生了。 
我们知道每个函数都有一个默认的属性prototype，而这个prototype的constructor默认指向这个函数。如下例所示：   

        function Person(name) {
            this.name = name;
        };
        Person.prototype.getName = function() {
            return this.name;
        };
        var p = new Person("ZhangSan");
        
        console.log(p.constructor === Person);  // true
        console.log(Person.prototype.constructor === Person); // true
        // 将上两行代码合并就得到如下结果
        console.log(p.constructor.prototype.constructor === Person); // true  

当时当我们重新定义函数的prototype时 **（注意：和上例的区别，这里不是修改而是覆盖）** ，constructor的行为就有点奇怪了，如下示例：  

        function Person(name) {
            this.name = name;
        };
        Person.prototype = {
            getName: function() {
                return this.name;
            }
        };
        var p = new Person("ZhangSan");
        console.log(p.constructor === Person);  // false
        console.log(Person.prototype.constructor === Person); // false
        console.log(p.constructor.prototype.constructor === Person); // false  

为什么呢？ 
原来是因为覆盖Person.prototype时，等价于进行如下代码操作：  

        Person.prototype = new Object({
            getName: function() {
                return this.name;
            }
        });  

而constructor始终指向创建自身的构造函数，所以此时Person.prototype.constructor === Object，即是：  

        function Person(name) {
            this.name = name;
        };
        Person.prototype = {
            getName: function() {
                return this.name;
            }
        };
        var p = new Person("ZhangSan");
        console.log(p.constructor === Object);  // true
        console.log(Person.prototype.constructor === Object); // true
        console.log(p.constructor.prototype.constructor === Object); // true  

怎么修正这种问题呢？方法也很简单，重新覆盖Person.prototype.constructor即可：  

        function Person(name) {
            this.name = name;
        };
        Person.prototype = new Object({
            getName: function() {
                return this.name;
            }
        });
        Person.prototype.constructor = Person;
        var p = new Person("ZhangSan");
        console.log(p.constructor === Person);  // true
        console.log(Person.prototype.constructor === Person); // true
        console.log(p.constructor.prototype.constructor === Person); // true


----------
## 对象的\__proto\__隐式原型 ##
上面我们创建了两个对象,person1和person2,这两个对象，也都指向了Person构造函数的原型,这是因为每个对象都有一个隐藏的属性——“\__proto\__”，这个属性引用了创建这个对象的函数的prototype。即：person1.\__proto\__ === Person.prototype  
这个\__proto\__是一个隐藏的属性，javascript不希望开发者用到这个属性值，有的低版本浏览器甚至不支持这个属性值。看下面的代码:  

    console.log(Object.prototype);
    var obj = new Object();
    console.log(obj.__proto__);
你会发现打印了相同的内容:
  

obj这个对象本质上是被Object函数创建的，因此obj.\__proto\__=== Object.prototype。我们可以用一个图来表示。   
  
关于隐式原型，主要涉及到原型继承的主要原理，这里只是抛出这个概念稍作介绍

 

## Prototype原型模式 ##
上一章罗列一直知识点，但是主要是为了说明prototype原型，现在主要来看看，通过原型来创建对象的几种方式  

### 基本原型 ###
    function Person(){ }  
    Person.prototype.name = "Nicholas"; 
    Person.prototype.age = 29; 
    Person.prototype.job = "Software Engineer"; 
    Person.prototype.sayName = function(){     
        alert(this.name); 
    };  
当然这种方式只是说明原型的道理，实际使用中很少把属性写在原型中  

### 更简单的方式 ###
    function Person(){ } 
 
    Person.prototype = {     
        name : "Nicholas",     
        age : 29,     
        job: "Software Engineer",     
        sayName : function () {         
            alert(this.name);     
        } 
    }; 

这种方式只是上面方式的简单写法，通过对象字面量直接写完所有属性。效果和上面的写法是一样的，只是写法不一样。  
但是直接全部把属性和方法全部写在原型中，这并不现实，看下面的列子:  

    function Person(){ }
  
    Person.prototype = {     
        constructor: Person,     
        name : "Nicholas",     
        age : 29,     
        job : "Software Engineer",     
        friends : ["Shelby", "Court"],     
        sayName : function () {         
            alert(this.name);     
        } 
    }; 
 
    var person1 = new Person(); 
    var person2 = new Person();  
    person1.friends.push("Van");  
    alert(person1.friends);    //"Shelby,Court,Van" 
    alert(person2.friends);    //"Shelby,Court,Van" 
    alert(person1.friends === person2.friends);  //true  

上面的列子很容易看出，将属性写在原型中的问题,列子中的friends是个数组，引用数据类型在person1中修改了friends,添加了一个条数据之后，可以看到person1和person2对象的friends都发生了改变，这其实很好理解，因为prototype对象本身就是共享的，数组又是属于引用类型，改变了一个，其他的都会发生改变。

所以，在实际中使用的更多的方法是构造函数与原型结合的方式  

### 构造函数与原型结合的方式 ###

    function Person(name, age, job){     
        this.name = name;     
        this.age = age;     
        this.job = job;     
        this.friends = ["Shelby", "Court"]; 
    }  
    Person.prototype = {     
        constructor : Person,     
        sayName : function(){         
            alert(this.name);     
        } 
    } 

    var person1 = new Person("Nicholas", 29, "Software Engineer"); 
    var person2 = new Person("Greg", 27, "Doctor");  
    person1.friends.push("Van"); 
    alert(person1.friends);    //"Shelby,Count,Van" 
    alert(person2.friends);    //"Shelby,Count" 
    alert(person1.friends === person2.friends);    //false 
    alert(person1.sayName === person2.sayName);    //true   

这里就可以看到，friends的属性在两个对象中就算改变了其中一个，并不会对另外一个产生影响。这种构造函数加原型的混成模式，是目前使用率，认可率最高的一种自定义类型的方式，所以，一般情况下，我们定义自定义类型默认都使用这种模式  

### 动态原型模式 ###
这种模式只是上面模式的变种，对于一些习惯书写面向对象语言的程序员来说，一个类要分开两个部分来写，是非常不习惯的，所以，就有了动态原型模式，其实无非就是，把之前分开两部分写的内容，全部提到函数中，加上判断就行了

    function Person(name, age, job){  

        //属性  
        this.name = name;     
        this.age = age;     
        this.job = job; 
 
        //方法  
        if (typeof this.sayName != "function"){              
            Person.prototype.sayName = function(){             
                alert(this.name);         
            };              
        } 
    }  

    var friend = new Person("Nicholas", 29, "Software Engineer"); 
    friend.sayName();  

注意上面的判断，这种方式只有在sayName函数不存在的情况下，才会将它添加到原型中，如果sayName函数已经存在，那么这段代码就不会再运行，而且就算有很多方法的话，if语句也不用全部判断，只是需要判断一个就行了。  
这样的写法，对于java或者C#程序员相对来说感官上比较容易接受，而且写法也没有任何缺陷。但是，有一点不算是缺陷的缺点，javascript是一门动态语言，也就是说，属性和方法是随时可以添加的，如果全部写在构造函数里面去，反而看起来不是那么的灵活。所以，一般情况下，使用构造函数与原型的混合模式的还是比较多的

 

 现在有一个"动物"对象的构造函数。  

    function Animal(){
        this.species = "动物";
    }  

还有一个"猫"对象的构造函数。  
  
    function Cat(name,color){
    　　　　this.name = name;
    　　　　this.color = color;
    }  

怎样才能使"猫"继承"动物"呢？  

## 一、 构造函数绑定  
先来看下面两个函数的意义：

    function ClassA(sColor){
        this.color=sColor;
        this.sayColor=function(){
            alert(this.color);
        };
    }  

    function ClassB(sColor,sName){
        this.newMethod=ClassA;
        this.newMethod(sColor);
        delete this.newMethod;
        this.name=sName;
        this.sayName=function(){
            alert(this.name);
        };
    }  

初一看，这种方式貌似很复杂，其实道理很简单，就是在继承的函数里面，新建一个变量newMethod，然后将ClassA的指针指向这个变量，然后在ClassB中调用这个方法，这样实际上newMethod引用的作用域也就是说this的指向就是ClassB实例化的对象了。注意:最后一行删除对ClassA的引用，这样以后就不能再调用它。所有的新属性和新方法都必须在删除了新方法的代码后定义，否则覆盖超类的相关属性和方法    

为证明前边的有效，运行下面例子  

    var objA=new ClassA("red");
    var objB=new ClassB("blue","Nicholas");
    objA.sayColor();
    objB.sayColor();
    objB.sayName();

由于这种继承方法流行，ECMAScript为Function对象加入了两个新方法，即call()和apply()，所以上面的方法完全可以使用call或apply方法进行替代，将父对象的构造函数绑定在子对象上，即在子对象构造函数中加一行：  

    function ClassB(sColor,sName){
        //this.newMethod=ClassA;
        //this.newMethod(sColor);
        //delete this.newMethod;
        ClassA.call(this,sColor);
    
        this.name=sName;
        this.sayName=function(){
            alert(this.name);
        };
    }   
这里可以看到，前面三行的代码直接改成了call方法，所以针对最上面的例子，我们改成下面的样子，就可以直接实现继承了  

    function Cat(name,color){
        Animal.apply(this, arguments);
        this.name = name;
        this.color = color;
    }
    var cat1 = new Cat("大毛","黄色");
    alert(cat1.species); // 动物   

## 二、 prototype模式 ##
第二种方法更常见，使用prototype属性。
如果"猫"的prototype对象，指向一个Animal的实例，那么所有"猫"的实例，就能继承Animal了。  

    Cat.prototype = new Animal();
    Cat.prototype.constructor = Cat;
    var cat1 = new Cat("大毛","黄色");
    alert(cat1.species); // 动物  

代码的第一行，我们将Cat的prototype对象指向一个Animal的实例。
  
    Cat.prototype = new Animal();  

它相当于完全删除了prototype 对象原先的值，然后赋予一个新值。但是，第二行又是什么意思呢？  

    Cat.prototype.constructor = Cat;  

原来，任何一个prototype对象都有一个constructor属性，指向它的构造函数。如果没有"Cat.prototype = new Animal();"这一行，Cat.prototype.constructor是指向Cat的；加了这一行以后，Cat.prototype.constructor指向Animal。  

    alert(Cat.prototype.constructor == Animal); //true  

更重要的是，每一个实例也有一个constructor属性，默认调用prototype对象的constructor属性。  

    alert(cat1.constructor == Cat.prototype.constructor); // true  

因此，在运行"Cat.prototype = new Animal();"这一行之后，cat1.constructor也指向Animal！  

    alert(cat1.constructor == Animal); // true  

这显然会导致继承链的紊乱（cat1明明是用构造函数Cat生成的），因此我们必须手动纠正，将Cat.prototype对象的constructor值改为Cat。这就是第二行的意思。  

## 三、 直接继承prototype ##
第三种方法是对第二种方法的改进。由于Animal对象中，不变的属性都可以直接写入Animal.prototype。所以，我们也可以让Cat()跳过 Animal()，直接继承Animal.prototype。
现在，我们先将Animal对象改写：  

    function Animal(){ }
    Animal.prototype.species = "动物";  

然后，将Cat的prototype对象，然后指向Animal的prototype对象，这样就完成了继承。  

    Cat.prototype = Animal.prototype;
    Cat.prototype.constructor = Cat;
    var cat1 = new Cat("大毛","黄色");
    alert(cat1.species); // 动物  

与前一种方法相比，这样做的优点是效率比较高（不用执行和建立Animal的实例了），比较省内存。缺点是 Cat.prototype和Animal.prototype现在指向了同一个对象，那么任何对Cat.prototype的修改，都会反映到Animal.prototype。所以，上面这一段代码其实是有问题的。请看第二行 
 
    Cat.prototype.constructor = Cat;  

这一句实际上把Animal.prototype对象的constructor属性也改掉了！ 

    alert(Animal.prototype.constructor); // Cat  

## 四、 利用空对象作为中介  ## 
由于"直接继承prototype"存在上述的缺点，所以就有第四种方法，利用一个空对象作为中介  

    var F = function(){};
    F.prototype = Animal.prototype;
    Cat.prototype = new F();
    Cat.prototype.constructor = Cat;  

F是空对象，所以几乎不占内存。这时，修改Cat的prototype对象，就不会影响到Animal的prototype对象。  

    alert(Animal.prototype.constructor); // Animal  

我们将上面的方法，封装成一个函数，便于使用。  

    function extend(Child, Parent) {
        var F = function(){};
        F.prototype = Parent.prototype;
        Child.prototype = new F();
        Child.prototype.constructor = Child;
        Child.uber = Parent.prototype;
    }  

使用的时候，方法如下：  

    extend(Cat,Animal);
    var cat1 = new Cat("大毛","黄色");
    alert(cat1.species); // 动物  

这个extend函数，就是YUI库如何实现继承的方法。
另外，说明一点，函数体最后一行  

    Child.uber = Parent.prototype;  

意思是为子对象设一个uber属性，这个属性直接指向父对象的prototype属性。（uber是一个德语词，意思是"向上"、"上一层"。）这等于在子对象上打开一条通道，可以直接调用父对象的方法。这一行放在这里，只是为了实现继承的完备性，纯属备用性质。  

## 五、 拷贝继承 ##
上面是采用prototype对象，实现继承。我们也可以换一种思路，纯粹采用"拷贝"方法实现继承。简单说，如果把父对象的所有属性和方法，拷贝进子对象，不也能够实现继承吗？这样我们就有了第五种方法。  

首先，还是把Animal的所有不变属性，都放到它的prototype对象上。  

    function Animal(){}
    Animal.prototype.species = "动物";  

然后，再写一个函数，实现属性拷贝的目的。  

    function extend2(Child, Parent) {
        var p = Parent.prototype;
        var c = Child.prototype;
        for (var i in p) {
            c[i] = p[i];
        }
        c.uber = p;
    }  

这个函数的作用，就是将父对象的prototype对象中的属性，一一拷贝给Child对象的prototype对象。
使用的时候，这样写：  

    extend2(Cat, Animal);
    var cat1 = new Cat("大毛","黄色");
    alert(cat1.species); // 动物