JavaScript中的面向对象--对象继承

最新推荐文章于 2025-03-02 17:53:06 发布

原创最新推荐文章于 2025-03-02 17:53:06 发布 · 173 阅读

0 ·

CC 4.0 BY-SA版权

web开发专栏收录该内容

18 篇文章

订阅专栏

JavaScript高级程序设计第3版 p162

这里总结一下JavaScript中对象继承的方式，主要有原型链和借用构造函数模式，衍生的出来的有组合式继承、原型式继承、寄生式继承和寄生组合式继承。原型链是指，将构造函数的原型指向另一种对象类型的实例,而这个实例中又有指向另一种原型的指针，如此就构成了原型链。

原型链

function SuperType(){
	this.property = 'SuperType is true';
};

SuperType.prototype.getSuperValue = function(){
	return this.property;
};

function SubType(){
	this.subproperty = 'SubType is true';
};
//先重写原型，后定义方法
SubType.prototype = new SuperType();
SubType.prototype.getSubValue = function(){
	return this.subproperty;
};

var instance = new SubType();
console.log(instance.getSuperValue());
instance instanceof SuperType;//true
instance instanceof SubType;//true
instance instanceof Object;//true
Object.prototype.isPrototypeOf(instance);//true
SuperType.prototype.isPrototypeOf(instance);//true
SubType.prototype.isPrototypeOf(instance);//true

画图理清原型链的关系
所有函数的默认原型都是 Object 的实例。
注意原型链继承与在原型上定义方法属性的先后顺序,注意使用对象字面量定义原型时产生的覆盖问题。
原型链存在的两个问题，一是属性是引用类型时的共享问题，二是不能传递参数。

借用构造函数

借用构造函数就是，在子类型的构造函数中，通过调用函数类型的call或apply方法，将父类型构造函数的作用域绑定到新创建的子类型对象上，实现在子类型构造函数中对父类型构造函数的借用。

function SuperType(name){
	this.name = name;
	this.colors = ['red','blue','green'];
	this.sayColor = function(){
		console.log(this.colors);
	}
};

function SubType(name,area){
	SuperType.call(this,name);
	this.area = area;
};

let instance1 = new SubType('Azalea','China');
instance1.colors.push('yellow');
instance1.sayColor();//["red", "blue", "green", "yellow"]
let instance2 = new SubType('Rose','China');
instance2.sayColor();//["red", "blue", "green"]

借用构造函数存在的问题是，同构造函数创建对象一样，函数复用无从谈起。

原型链与借用构造函数组合继承

使用原型链实现对原型属性和方法的继承,而通过借用构造函数来实现对实例属性的继承。

function SupType(name){
	this.name = name;
	this.colors = ["red", "blue", "green"];
};
SupType.prototype.sayColor = function(){
	console.log(this.colors);
};

function SubType(name, area){
	SupType.call(this, name);//一次调用父类构造函数
	this.area = area;
};

//继承方法
SubType.prototype = new SupType();//二次调用父类构造函数
SubType.prototype.constructor = SubType;
//定义子类型方法
SubType.prototype.sayArea = function(){
	console.log(this.area);
}

var instance1 = new SubType('Azalea','China');
instance1.colors.push('yellow');
instance1.sayColor();//["red", "blue", "green", "yellow"]
instance1.sayArea();//China

var instance2 = new SubType('Rose','US');
instance2.sayColor();//["red", "blue", "green"]
instance2.sayArea();//US

如此，组合继承避免了原型链和借用构造函数的缺陷,融合了它们的优点。
组合继承的问题是，像上述程序，调用了两次父类构造函数，这将在子类实例上和子类原型对象上都添加了父类型的属性，这完全是没有必要的，降低了性能。

原型式继承

借助原型可以基于已有的对象创建新对象，同时还不必因此创建自定义类型。

function object(o){
	function F(){}
	F.prototype = o;
	return new F();
};
var person = {
	name: "Nicholas",
	friends: ["Shelby", "Court", "Van"]
};

var anotherPerson = object(person);
anotherPerson.name = "Greg";
anotherPerson.friends.push("Rob");

var yetAnotherPerson = object(person);
yetAnotherPerson.name = "Linda";
yetAnotherPerson.friends.push("Barbie");
console.log(person.friends);//"Shelby,Court,Van,Rob,Barbie"

ECMAScript 5 通过新增 Object.create() 方法规范化了原型式继承。
包含引用类型值的属性始终都会共享相应的值。
适用于没有必要兴师动众地创建构造函数,而只想让一个对象与另一个对象类似的情况

寄生式继承

创建一个仅用于封装继承过程的函数，在内部以某种方式来增强对象,最后再像真地是它做了所有工作一样返回对象。

function parasiticCreate(supObject){
	var obj = Object.create(supObject);//任何创建新对象的函数都可
	obj.sayHello = function(){//增强对象
		console.log('Hello');
		}
	return obj;
}

在父对象非自定义类型和构造函数的情况下,寄生式继承也是一种有用的模式，可以增强对象，添加自定义方法。

寄生组合式继承

在普通的借用构造函数继承和原型链组合继承中，调用了两次构造函数，为了让子类型的原型继承父类型原型的属性，是通过让子类型的prototype指向父类型的实例来实现的，产生了冗余，其实，可以直接将父类型的原型对象赋值给子类型的原型，这样就不用两次调用父类型的构造函数了。这可通过定义一个寄生函数，借助寄生式继承来实现。

通过借用构造函数来继承属性,通过原型链的混成形式来继承方法。不必为了指定子类型的原型而调用超类型的构造函数,通过寄生函数获取超类型原型的一个副本。

function inheritPrototype(subType, superType){
	var prototype = Object.create(superType.prototype);
	prototype.constructor = subType;
	subType.prototype = prototype;
}
//改写组合继承中的程序
function SupType(name){
	this.name = name;
	this.colors = ["red", "blue", "green"];
};
SupType.prototype.sayColor = function(){
	console.log(this.colors);
};

function SubType(name, area){
	SupType.call(this, name);//一次调用父类构造函数
	this.area = area;
};

//继承方法
//SubType.prototype = new SupType();//二次调用父类构造函数
inheritPrototype(SubType,SupType);
SubType.prototype.constructor = SubType;
//定义子类型方法
SubType.prototype.sayArea = function(){
	console.log(this.area);
}

var instance1 = new SubType('Azalea','China');
instance1.colors.push('yellow');
instance1.sayColor();//["red", "blue", "green", "yellow"]
instance1.sayArea();//China

var instance2 = new SubType('Rose','US');
instance2.sayColor();//["red", "blue", "green"]
instance2.sayArea();//US

与组合继承的区别在于给子类型构造函数原型对象添加父类型原型时的方式
避免了在 SubType prototype 上面创建不必要的、多余的属性。

继承也是创建对象，在理解创建对象的几种方式的基础上，对继承的理解主要在于弄明白，派生对象也就是子对象与父对象之间的关系。

在JavaScript中，没有类的概念，不利于对继承的理解。假如有类的概念，JavaScript中创建对象，一种是创建之创建一个对象，像var obj = {name:'Einstan'}，另一种是创建一种类型，像构造函数，再通过构造函数创建一个构造函数类型的对象。继承也是一样，像原型式继承和寄生式继承，是一个对象继承另一个对象，像组合继承，是一种类型继承一种类型，如此应该会好理解一些。