面向对象类

1、类的声明

/*
类的声明
 */
function Animal(){
    this.name = 'name';
}
// ES6中的class声明
class Animal2{
    constructor(){
        this.name="name";
    }
}

// 实例化
console.log(new Animal(),new Animal2());

2、实现继承的几种方式

　　（1）借助构造函数实现继承

/*借助构造函数实现继承
缺点：只是改变this指向。Parent1中原型链上的东西并没有被Child1所继承
*/

function Parent1(){
    this.name= 'parent1';
}

function Child1(){
    Parent1.call(this);//apply ，Parent1在Child1里执行了,同时修改了父级构造函数this的指向，指向了子构造函数的实例上，从而导致父级函数内的属性挂载到Child1的实例中
    this.type='child1';
}
console.log(new Child1)

（2）借助原型链实现继承

/*借助原型链实现继承*/

function Parent2(){
    this.name = "Parent2";
    this.play = [1,2,3];
}
function Child2(){
    this.type = "Child2";
}
Child2.prototype = new Parent2();//重点
console.log(new Child2);
//s1 通过隐式原型找到构造函数Child2的显示原型，显示原型又是Parent2的实例，因此具有play属性
var s1 = new Child2();
var s2 = new Child2();
console.log(s1.play,s2.play);
//缺点：向s1的play属性添加数字，s2的play属性也会改变
s1.play.push(4);
console.log(s2.play);

（3）组合方式继承

/*组合方式*/

function Parent3(){
    this.name = "Parent3";
    this.play = [1,2,3];
}
function Child3(){
    console.log(this);
    Parent3.call(this);//this 将child3的实例，s3调用时this指向s3 s4调用时this指向s4,所以改变s3.play 不会导致s4.play的变化
    this.type='Child3';
}
Child3.prototype = new Parent3();
//不足：Parent3执行了两次
var s3 = new Child3();
var s4 = new Child3();
s3.play.push(4);
console.log(s3.play,s4.play);

（4）组合方式优化1

/*组合方式优化1*/

function Parent4(){
    this.name = "Parent4";
    this.play = [1,2,3];
}
Parent4.prototype.say = function(){
    console.log("hah ")
}
function Child4(){
    //这句话继承属性
    Parent4.call(this);
    this.type='Child4';
}

//这句话继承方法
Child4.prototype = Parent4.prototype;
var s5 = new Child4();
var s6 = new Child4();
s5.play.push(4);
console.log(s5,s6);
// console.log(s5.constructor);//缺点：s5的构造器直接指向Parent4 而不是Child4

（5）组合方式优化2

/*组合方式优化2*/

function Parent5(){
    this.name = "Parent5";
    this.play = [1,2,3];
}
function Child5(){
    Parent5.call(this);
    this.type='Child5';
}
//Object.create 创建一个中间对象，第一个参数就是这个中间对象的原型，改变中间对象的constructor不会影响中间对象的原型的constructor，因此可以采用这种方法解决之前的问题。
/*
var z = Object.create(Parent5.prototype);//中间对象z的原型是Parent5.prototype
z.constructor = Child5;//改变z的construrtor
console.log(z.constructor);//输出Chiled5
console.log(Parent5.prototype.constructor)//仍旧输出Parent5
*/
Child5.prototype = Object.create(Parent5.prototype);
Child5.prototype.constructor = Child5;
var s7 = new Child5();
var s8 = new Child5();
s7.play.push(4);
console.log(s7.play,s8.play);
console.log(s7.constructor);