原型继承

function Person(name) { //给构造函数添加了参数
this.name = name;
this.sex = "male";
this.say = function() {
console.log(this.name);
}
}
Person.prototype.age = 21; //给构造函数添加了原型属性
console.log(Person.prototype.age)
1. 原型链继承
function Programmer() {
this.name = "Jayee";
}

Programmer.prototype = new Person(); //子类构造函数.prototype=父类实例

var per1 = new Programmer();
console.log(per1); //Programmer {name: "Jayee"}
console.log(per1.sex); //male
console.log(per1.age); //21
console.log(per1 instanceof Person); //true
//借用构造函数继承
function Coder() {
Person.call(this, "Jayee"); //重点：借用了Person
this.age = 18;
}
var cod1 = new Coder();
console.log(cod1);
//Coder {name: "Jayee", sex: "male", hobby: "", age: 18, say: ƒ}
console.log(cod1.name); //Jayee
console.log(cod1.age); //18
console.log(cod1 instanceof Person); //false
2.组合继承
function Typer(name) {
Person.call(this, name);
}
Typer.prototype = new Person();
var typ = new Typer("Jayee");
console.log(typ);
//Typer {name: "Jayee", sex: "male", hobby: "", say: ƒ}
console.log(typ.name); //Jayee，继承了构造函数
console.log(typ.age); //21，继承了父类的原型的属性
3.原型式继承
function Rocker(obj) {
//先封装一个函数容器，用来输出对象和承载继承的原型
function F() {}
F.prototype = obj; //继承了传入的函数
return new F(); //返回函数对象
}
var per = new Person(); //拿到父类实例
var roc = Rocker(per); //F {}
console.log(per.__proto__); //{age: 21, constructor: ƒ}
console.log(roc.age); //21，继承了父类函数的属性
4.寄生式继承
function Rocker(obj) {
function F() {}
F.prototype = obj; //继承了传入的函数
return new F(); //返回函数对象
}
var per4 = new Person();
//以上是原型式继承,给原型式继承再套个壳子传递参数
function Artist(obj) {
var roc = Rocker(obj);
roc.name = "Jayee";
return roc;
}
var art = Artist(per4)
//这个函数经过声明之后就成了可增添属性的对象
console.log(typeof Artist); //function
console.log(typeof art); //object
console.log(art.name); //Jayee，返回了个roc对象，继承了roc的属性
// /寄生式组合式继承

5.寄生
function Rocker(obj) {
function F() {}
F.prototype = obj; //继承了传入的函数
return new F(); //返回函数对象
}
//Rocker就是F实例的另一种表示法
var roc = new Rocker(Person.prototype);
//roc实例（F实例）的原型继承了父类函数的原型
//上述更像是原型链继承，只不过继承了原型属性

//组合
function Sub() {
Person.call(this);
//这个继承了父类构造函数的属性
//解决了组合式两次调用构造函数属性的缺点
}
//重点
Sub.prototype = roc; //继承了roc实例
roc.constructor = Sub; //一定要修复实例
var sub1 = new Sub();
//Sub的实例就继承了构造函数属性，父类实例，roc的函数属性
console.log(sub1.age); //21