面向对象编程的模式

构造函数实现继承的两种方式

方式 1

function Viechle () {
	'use strict';
	this.name = 'Viechle';
	this.run = function () {
		console.log(this.name + ' is running.');
	};
}

function Bus () {
	Viechle.call(this);
	this.name = 'Bus';
}
Bus.prototype = Object.create(Viechle.prototype);
Bus.prototype.constructor = Bus;
1
2
3
4
5
6
7
8
9
10
11
12
13
14

方式 2

function Viechle () {
	'use strict';
	this.name = 'Viechle';
	this.run = function () {
		console.log(this.name + ' is running.');
	};
}

function Bus () {
	this.name = 'Bus';
}
Bus.prototype = new Viechle();
Bus.prototype.constructor = Bus;
1
2
3
4
5
6
7
8
9
10
11
12
13

并不推荐这种做法,因为在 Bus.prototype = new Viechle() 时,会污染 Bus.prototype 原型对象。

单个方法继承

有时候我们可能并不想继承整个原型对象,而是只想继承某个方法,那么可以这样做:

function Viechle () {
	'use strict';
	this.name = 'Viechle';
}

Viechle.prototype.run = function () {
	console.log(this.name + ' is running.');
};

function Bus () {
	this.name = 'Bus';
}

Bus.prototype.run = function () {
	const args = [].slice.call(arguments, 0);
	return Viechle.prototype.run.apply(this, args);
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

多重继承

多重继承也就是一个对象同时继承多个对象,但是在 js 中并不提供这种功能,不过我们也可以变通实现。

function Viechle () {
	'use strict';
	this.viehcleName = 'Viechle';
}
Viechle.prototype.run = function () {
	console.log('The viechle ' + this.name + ' is running.');
};

function Car () {
	'use strict';
	this.carName = 'Car';
}
Car.prototype.run = function () {
	console.log('The car ' + this.name + ' is running.');
};

function Bus () {
	Viechle.call(this);
	Car.call(this);
}
Bus.prototype = Object.assign(
	{}, 
	Object.create(Viechle.prototype),
	Object.create(Car.prototype)
);
Bus.prototype.constructor = Bus;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

这种模式又称为 「Mixin」(混入)。