Javascript是一种弱类型语言，不存在类的概念，但在js中可以模仿类似于JAVA中的类，实现类与继承
第一种方法：利用Javascript中的原型链
1 //首先定义一个父类
2
3 function Animal(name,age){
4 //定义父类的属性
5 this.name = name || "Animal";
6 this.age = age ;
7 //定义父类的方法
8 this.sleep = function(){
9 console.log("这只"+this.name+"正在睡觉！");
10 };
11 this.showAge = function(){
12 console.log("这只"+this.name+"的年龄是"+this.age+"岁！");
13 }
14 };
15
16 //为父类添加原型方法
17
18 Animal.prototype.eat =function(food){
19 console.log("这只"+this.name+"正在吃"+food+"!")
20 }
21
22 Animal.prototype.weight = 10;
23
24 Animal.prototype.bark = function(){
25 console.log("bark");
26 }
27
28 //Javascript实现继承的方法一：
29
30 //原型链法 核心：将父类的实例作为子类的原型
31
32 function Cat(){
33
34 };
35
36 Cat.prototype = new Animal();
37
38 Cat.prototype.name = "猫";
39
40 Cat.prototype.age = 3;
41
42 Cat.prototype.bark = function(){
43 console.log("喵喵");
44 }
45
46 //测试上面的例子
47
48 var cat = new Cat();
49
50 console.log(cat.name); //输出猫
51
52 console.log(cat.age); //输出 3
53
54 console.log(cat.weight); // 输出10
55
56 cat.sleep(); //输出 这只猫正在睡觉！
57
58 cat.showAge(); //输出 这只猫的年龄是3岁！
59
60 cat.eat("鱼"); //输出 这只猫正在吃鱼！
61
62 cat.bark(); //输出喵喵
63
64 console.log(cat instanceof Animal); //输出 true
65
66 console.log(cat instanceof Cat); //输出 true
67
68
69 var Dog = new Function; // 为什么这样写也可以呢？ 例子最后将做解释
70
71 Dog.prototype = new Animal();
72
73 Dog.prototype.name = "狗";
74
75 Dog.prototype.age = 4;
76
77 Dog.prototype.bark = function(){
78 console.log("汪汪");
79 }
80
81 var dog = new Dog();
82
83 console.log(dog.name); //输出 狗
84
85 console.log(dog.age); //输出 4
86
87 console.log(dog.weight); //输出 10
88
89 dog.sleep(); //输出 这只狗正在睡觉！
90
91 dog.eat("骨头"); //输出 这只狗正在吃骨头
92
93 dog.bark(); //输出 汪汪
94
95 console.log(dog instanceof Dog); //输出true
96
97 console.log(dog instanceof Animal); //输出true
98
99 console.log(Animal.constructor); //输出 Function
100
101 console.log(Cat.constructor); //输出 Function
102
103 console.log(Dog.constructor); //输出 Function
104
105 console.log(cat.constructor); //输出 function Animal(){...}
106
107 console.log(dog.constructor); //输出 function Animal(){...}
108
109 /*有上面四行的输出结果可以看书，Animal 父类，以及Cat 和 Dog 子类，都是由Function 创建出来的构造函数，
110 而 cat 和 dog 是由Animal 父类构建出来的子类 */
原型链法实现继承的特点分析
优点： 1.是非常纯粹的继承关系，实例是子类的实例，也是父类的实例， 2.父类新增原型属性和原型方法，子类都可以访问到 3.简单方便，易于实现
缺点 ： 1.想要为子类添加原型属性和原型方法，则必须在new Animal() 语句之后执行 2.无法实现多继承 3.来自原型对象的引用属性是所有实例共享的（由Cat 和 Dog 都可以使用weight 属性 和 eat 方法可以看出） 4.创建子类实例时，无法向父类构造函数传参
第二种方法： 构造函数法
//首先定义一个父类 function Animal(name,age){ //定义父类的属性 this.name = name || "Animal"; this.age = age ; //定义父类的方法 this.sleep = function(){ console.log("这只"+this.name+"正在睡觉！"); }; this.showAge = function(){ console.log("这只"+this.name+"的年龄是"+this.age+"岁！"); } }; //为父类添加原型方法 Animal.prototype.eat =function(food){ console.log("这只"+this.name+"正在吃"+food+"!") } Animal.prototype.weight = 10; Animal.prototype.bark = function(){ console.log("bark"); } //Javascript 实现继承的方法二 ： //构造函数法 核心：使用父类的构造函数来增强子类实例，等于是复制父类的实例属性给子类,但父类的原型属性和原型方法在子类中不能提现 function Cat(name,age){ Animal.call(this); //使用call方法继承父类的属性和方法 this.name = name || "猫"; //使用子类自己的属性覆盖从父类继承来的属性 this.age = age; //使用子类自己的属性覆盖从父类继承来的属性 this.bark = function(){ //定义子类自己的方法 console.log("喵喵"); } }; //测试 var cat = new Cat("猫",4); //新创建一个子类实例化对象，并传参 console.log(cat.name); // 输出 猫 console.log(cat.age); //输出 4 console.log(cat.weight); //这一句会报undefined，因为父类的原型属性在子类中无法使用 cat.sleep(); // 输出 这只猫正在睡觉 cat.bark(); //输出喵喵 //cat.eat("鱼"); //这一句会报错，因为父类的原型方法在这里不能使用 cat.showAge(); //输出 console.log(cat instanceof Animal); // false console.log(cat instanceof Cat); // true //上面这两句可以看书，cat 并不属于Animal 父类的实例对象，而只是Cat 子类的实例对象 //总结 /*构造函数法实现继承的方法的特点分析 优点： 1.解决了原型链法中，子类实例对象会共享父类引用属性的问题； 2.创建子类实例对象时，可以向父类传递参数 3.可以实现多继承（通过call多个父类对象） 缺点： 1.实例对象并不是父类的实例对象，而只是子类的实例对象，（举例（小花猫属于猫类，却不属于动物类），这点很不好） 2.只能继承父类的实例属性和实例方法，不能继承父类的原型属性和原型方法 3.无法实现函数的复用，每个子类都有父类实例函数的副本，影响性能
构造函数法实现继承的优缺点分析：
优点： 1.解决了原型链法中，子类实例对象会共享父类引用属性的问题； 2.创建子类实例对象时，可以向父类传递参数 3.可以实现多继承（通过call多个父类对象）
缺点： 1.实例对象并不是父类的实例对象，而只是子类的实例对象，（举例（小花猫属于猫类，却不属于动物类），这点很不好） 2.只能继承父类的实例属性和实例方法，不能继承父类的原型属性和原型方法 3.无法实现函数的复用，每个子类都有父类实例函数的副本，影响性能
第三种方法：实例继承法
//首先定义一个父类 function Animal(name,age){ //定义父类的属性 this.name = name || "Animal"; this.age = age ; //定义父类的方法 this.sleep = function(){ console.log("这只"+this.name+"正在睡觉！"); }; this.showAge = function(){ console.log("这只"+this.name+"的年龄是"+this.age+"岁！"); } }; //为父类添加原型方法 Animal.prototype.eat =function(food){ console.log("这只"+this.name+"正在吃"+food+"!") } Animal.prototype.weight = 10; Animal.prototype.bark = function(){ console.log("bark"); } //Javascript 实现继承的方法二 ： //实例继承 核心：为父类实例添加新特性，作为子类实例返回 function Cat(name,age){ var obj = new Animal(); // 创建一个父类的实例对象obj //这里为obg添加了一个不可枚举属性 sex Object.defineProperty(obj, "sex", { value: "female", enumerable: false }); obj.name = "猫"; // 为实例对象添加 属性 obj.age = 3; // 为实例对象添加 属性 obj.bark = function(){ // 为实例对象添加方法 console.log("喵喵"); } return obj; // 将这个实例对象作为返回值返回 }; //测试代码 var cat = new Cat(); console.log(cat.name); //输出 猫 console.log(cat.age); //输出 3 console.log(cat.weight); // 输出 10 console.log(cat.sex); //输出female cat.sleep(); // 输出 这只猫正在睡觉 cat.eat("鱼"); // 输出 这只猫正在吃鱼 cat.bark(); //输出 喵喵 console.log(cat instanceof Cat); //输出false //instanceof 运算符用来测试一个对象在其原型链中是否存在一个构造函数的 prototype 属性。 //instanceof 运算符可以用来判断一个对象是否属于某种对象类型 //instanceof 运算符更好的用途是可以判断一个实例是否属于它的父类 console.log(cat instanceof Animal); //输出 true //上面这两句可以看书，cat 并不属于Cat的实例对象，而只是Animal父类的实例对象 //总结 /*实例继承法的特点分析 优点： 1.不限制调用方式 确定： 1.实例是父类的实例，并不是子类的实例（这里好像违反了继承的理念，就好像小花猫属于动物，却不属于猫类一样） 2.不支持多继承
优点： 1.不限制调用方式
确定： 1.实例是父类的实例，并不是子类的实例（这里好像违反了继承的理念，就好像小花猫属于动物，却不属于猫类一样） 2.不支持多继承
第四种法法：组合继承法
/首先定义一个父类 function Animal(name,age){ //定义父类的属性 this.name = name || "Animal"; this.age = age ; //定义父类的方法 this.sleep = function(){ console.log("这只"+this.name+"正在睡觉！"); }; this.showAge = function(){ console.log("这只"+this.name+"的年龄是"+this.age+"岁！"); } }; //为父类添加原型方法 Animal.prototype.eat =function(food){ console.log("这只"+this.name+"正在吃"+food+"!") } Animal.prototype.weight = 10; Animal.prototype.bark = function(){ console.log("bark"); } //Javascript 实现继承的方法五 ： //组合继承法 核心：通过调用父类构造，继承父类的属性并保留传参的优点，然后通过将父类实例作为子类原型，实现函数复用 function Cat(name,age){ Animal.call(this); this.name = name; this.age = age; this.bark = function(){ console.log("喵喵"); } }; Cat.prototype = new Animal(); //测试代码 var cat = new Cat("猫",3); console.log(cat.name); //猫 console.log(cat.age); // 3 console.log(cat.weight); // 10 cat.showAge(); // 这只猫的年龄是3岁 cat.eat("鱼"); // 这只猫正在吃鱼 cat.sleep(); // 这只猫正在睡觉 cat.bark(); // 喵喵 console.log(cat instanceof Animal); // true console.log(cat instanceof Cat); // true //从上面两行的输出结果来看，cat 是 父类 Animal 的 实例 ，也是子类Cat 的 实例
组合继承法实现继承的特点分析
优点： 1.弥补了构造函数法的缺陷，可以继承实例属性和方法，也可以继承原型属性和方法 2.既是子类的实例，也是父类的实例（比较符合继承的理念） 3.不存在引用属性共享问题 4.子类的实例对象可传参 5.函数可复用 缺点： 1.在生成子类实例对象的过程中，调用了两次父类构造函数，生成了两份实例（子类实例将子类原型上的那份屏蔽了）
结论 ： 一般情况下，推荐使用这种方式的继承，缺点是多消耗一点内存
第五种方法：寄生组合继承法
//第六种，寄生组合继承法实现继承 //首先定义一个父类 function Animal(name,age){ //定义父类的属性 this.name = name || "Animal"; this.age = age ; //定义父类的方法 this.sleep = function(){ console.log("这只"+this.name+"正在睡觉！"); }; this.showAge = function(){ console.log("这只"+this.name+"的年龄是"+this.age+"岁！"); } }; //为父类添加原型方法 Animal.prototype.eat =function(food){ console.log("这只"+this.name+"正在吃"+food+"!") } Animal.prototype.weight = 10; Animal.prototype.bark = function(){ console.log("bark"); } //Javascript 实现继承的方法六 ： //寄生组合继承 通过寄生方式，砍掉父类的实例属性， //这样，在调用两次父类的构造的时候，就不会初始化两次实例方法/属性，避免的组合继承的缺点 function Cat(name,age){ Animal.call(this); this.name = name; this.age = age ; this.bark = function(){ console.log("喵喵"); } }; //通过一个立即执行函数将父类的实例作为子类的原型 (function(){ //创建一个没有实例方法的类 var superClass = new Function; // 这里也可以写成，var sup = function(){}; 总之就是定义一个空构造函数 superClass.prototype = Animal.prototype; //将实例作为子类的原型 Cat.prototype = new superClass(); })(); //测试代码 var cat = new Cat("猫",3); console.log(cat.name); // 猫 console.log(cat.age); // 3 console.log(cat.weight); // 10 cat.showAge(); //这只猫的年龄是3岁！ cat.eat("鱼"); //这只猫正在吃鱼！ cat.sleep(); //这只猫正在睡觉！ cat.bark(); //喵喵 console.log(cat instanceof Animal); // true console.log(cat instanceof Cat); //true //上面两行可以看出，cat 是 子类 Cat 的实例对象， 也是 父类 Animal 的 实例对象
寄生组合继承法的特点分析
优点 ： 1.集中了几种方法的优点，堪称完美
缺点 ： 1.实现比较复杂
结论： 在实际项目和工程中，推荐使用这种方法
