update

Darylxyx · Darylxyx · commit 788415810221 · 2017-11-22T17:53:29.000+08:00
diff --git a/OO/inherit.html b/OO/inherit.html
@@ -73,40 +73,43 @@
 
 
 //【组合继承（伪经典继承）】
-// function SuperType(name) {
-// 	this.name = name;
-// 	this.colors = ['red', 'blue', 'green'];
-// }
+function SuperType(name) {
+	this.name = name;
+	this.colors = ['red', 'blue', 'green'];
+}
 
-// SuperType.prototype.sayName = function() {
-// 	console.log(this.name);
-// };
+SuperType.prototype.sayName = function() {
+	console.log(this.name);
+};
 
-// function SubType(name, age) {
-// 	SuperType.call(this, name);
-// 	this.age = age;
-// }
+function SubType(name, age) {
+	SuperType.call(this, name); //第二次调用 SuperType()
+	this.age = age;
+}
 
-// SubType.prototype = new SuperType();
+SubType.prototype = new SuperType(); //第一次调用 SuperType()
 // console.log(SubType.prototype.constructor); //SuperType
-// SubType.prototype.constructor = SubType;
-// SubType.prototype.sayAge = function() {
-// 	console.log(this.age);
-// };
+SubType.prototype.constructor = SubType;
+SubType.prototype.sayAge = function() {
+	console.log(this.age);
+};
 
-// var instanceA = new SubType('AAA', 29);
-// instanceA.colors.push('black');
-// console.log(instanceA.colors);
-// instanceA.sayName();
-// instanceA.sayAge();
+var instanceA = new SubType('AAA', 29);
+instanceA.colors.push('black');
+console.log(instanceA.colors);
+instanceA.sayName();
+instanceA.sayAge();
 
-// var instanceB = new SubType('BBB', 27);
-// console.log(instanceB.colors);
-// instanceB.sayName();
-// instanceB.sayAge();
+var instanceB = new SubType('BBB', 27);
+console.log(instanceB.colors);
+instanceB.sayName();
+instanceB.sayAge();
 
 //组合继承问题
 //组合继承融合了原型链与借用构造函数的优点，避免了二者的缺陷，是最常用的继承模式。
+//由于调用了两次 SuperType，会分别在 SubType 的原型对象和实例对象上分别创建属性。
+
+console.log(instanceA); //instanceA.name & instanceA.__proto__.name
 
 //【组合继承】
 
@@ -178,31 +181,39 @@
 //【寄生式继承】
 
 //【寄生组合式继承】
-function inheritPrototype(subType, superType) {
-	var prototype = Object.create(superType.prototype);
-	prototype.constructor = subType;
-	subType.prototype = prototype;
-}
+// function inheritPrototype(subType, superType) {
+// 	var prototype = Object.create(superType.prototype);
+// 	prototype.constructor = subType;
+// 	subType.prototype = prototype;
+// }
 
-function SuperType(name) {
-	this.name = name;
-	this.colors = ['red', 'blue', 'green'];
-}
+// function SuperType(name) {
+// 	this.name = name;
+// 	this.colors = ['red', 'blue', 'green'];
+// }
 
-SuperType.prototype.sayName = function() {
-	console.log(this.name);
-};
+// SuperType.prototype.sayName = function() {
+// 	console.log(this.name);
+// };
 
-function SubType(name, age) {
-	SubType.call(this, name);
-	this.age = age;
-}
+// function SubType(name, age) {
+// 	SuperType.call(this, name);
+// 	this.age = age;
+// }
 
-inheritPrototype(SubType, SuperType);
+// inheritPrototype(SubType, SuperType);
+
+// SubType.prototype.sayAge = function() {
+// 	console.log(this.age);
+// };
+
+// var instanceA = new SubType('aaa', 26);
+
+// console.log(instanceA);
+
+//寄生组合式继承问题
+//上例的高效率体现在它只调用了一次 SuperType 构造函数，并且因此避免了在 SubType.prototype 上创建不必要的属性。寄生组合式继承是引用类型最理想的继承范式。
 
-SubType.prototype.sayAge = function() {
-	console.log(this.age);
-};
 //【寄生组合式继承】
 
 </script>
