js原型和继承

原型

一、原型的概念

执⾏构造函数代码时， js系统会给这个构造函数创建⼀个原型对象，构造函数中也包含⼀个prototype属性指向这个原型对象。
原型的作用：通过原型给系统构造函数添加⼀些特殊的⽅法，（如：数组元素求和）这样通过Array创建出的对象都具备了这个⽅法。
通过原型给⾃定义的构造函数添加属性、⽅法，创建出来的对象所对应的属性、⽅法就是原型中的属性、⽅法，不需要新开辟内存空间，节约了内存。

二、原型相关属性、函数

原型属性：通过原型添加在构造函数中的属性；
原型方法：通过原型添加在构造函数中的函数；
实例属性：直接写在构造函数中的属性；
实例方法：直接写在构造函数中的函数。

三、proto/[[prototype]]、constructor、prototype⼏个属性的含义

proto:实例对象中的原型属性，指向创造他的构造函数对应的原型对象（我们⽆法访问到这个属性）。

image.png

constructor:构造函数所对应的原型对象中的⼀个属性，⽤来指向这个对象所对应的构造函数。
构造函数创建出来的对象也有这个属性，同样指向该对象的构造函数。
prototype：构造函数中的⼀个属性，指向他所对应的原型对象。

四、in和hasOwnProperty方法

//in运算符：只要该对象能访问到指定属性，都会返回true
console.log('gender' in per2);
//每创建出来的对象都具备hasOwnproperty()方法，该方法可以验证指定属性是否是该对象（实例）
//自己维护的属性
console.log(per2.hasOwnProperty('gender'));

继承

一、继承的概念

通过⼀个类（⽗类、⽗构造函数）创建出另⼀个类（⼦类、⼦构造函数），这样新创建出来的类不仅拥有了原有类的属性、⽅法，⽽且还可以添加⾃⼰独有的属性、⽅法，⼦类也可以重写⽗类的⽅法。

二、通过call和apply实现继承（“借⽤构造函数”实现继承）

call和apply是Function的原型⽅法，可以被⽤来调⽤函数，他们有的第⼀个参数表示被调函数内部this指针的指向对象，剩下的参数表示被调函数所需的参数，apply第⼆个参数是⼀个数组，数组元素表示被调函数所需参数。

//call方法
            function hello(a,b){
                console.log(a);
                console.log(b);
                console.log(this);
            }
//通过call方法驱动函数执行，如果call方法中第一个参数是对象，则该函数中的this指针就会
//指向这个对象,第二个参数才是函数的形参.
            hello.call(document,12,'ww');
            
//call函数通常用来修改this指针的指向，该函数需要两类参数，第一类参数是要修改指针指向
//的新对象 ，该参数只有一个，为对象类型的数据，放在实参列表的第一个位置；第二类参数
//是被调用函数所需要的形参，一次在第一个参数后按顺序给被调函数传参。
            
//apply,第二个参数用[]栝起来
            hello.apply(document,[12,'ww']);

三、js中的继承

function CreateAnimal(name,age){
                this.name=name;
                this.age=age;
                this.sayHi=function(){
                    alert('dzh');
                }
            }
            
            function CreateDog(name,age,gender){
//通过继承获取到另一个构造函数中的属性、方法（从父类中获取数据）
                CreateAnimal.call(this,name,age);
                this.gender=gender;
                this.eatFood=function(){
                    alert('kft');
                }
            }
//new关键字开辟一段名叫dog1的内存空间，并将这段内存空间的首地址返回出来，通过接收
//返回值的变量来访问这段内存空间。传递三个形参到CreateDog构造函数中，在CreateDog
//中通过使用call继承CreateAnimal的属性，CreateDog和CreateAnimal中的this指代的是名为dog1
//的内存空间。call和apply不能拿到父类原型属性.
            var dog1=new CreateDog('ah',12,'g');
            console.log(dog1);

四、原型链实现继承

function Parent(name) {
this.name = name;
this.say = function () {
alert("hello");
}
}
function Child(age) {
this.age = age;
}
// 通过⼦类的原型指针，从⽗类继承相关的属性、⽅法：让⼦类的原型指针指向⽗类对象
Child.prototype = new Parent(‘张三’);
// 因为prototype中还包含⼀个constructor属性，这个属性⽤来指向prototype所在的构造函数，
//所以要把constructor指向的构造函数改回Child,保证从该函数创建出的对象的constructor
//属性不会指向Parent。
Child.prototype.constructor = Child;
var child = new Child(23);
alert(child.age);
child.say();

五、组合方式实现继承

// 使⽤组合⽅式实现继承原理：属性使⽤Call继承⽅式，⽅法使⽤原型链⽅式
// ⽗类
function Person(name) {
this.name = name;
}
Person.prototype.say = function () {
alert("my name is"+this.name);
}
// ⼦类
function Child(name,age) {
Person.call(this, name);
this.age = age;
}
// 先继承⽗类的⽅法：⼦类的prototype指向⽗类的对象
Child.prototype = new Person();
// 然后添加⾃⼰的新⽅法
Child.prototype.cry = function () {
alert("哭了");
}
var child1 = new Child("baby",23);
// child1.say();
// child1.cry();
// 验证⼦类对象的构造函数是否指向Child
console.log(child1.constructor == Child); // 没有指向，说明继承结构出问题了，需
要修改
child1.constructor = Child;
console.log(child1.constructor == Child)

六、通过冒充调⽤⽅式实现继承

<script type="text/javascript">
// ⽗类
function ClassA(sColor) {
this.color = sColor;
this.show = function () {
alert(this.color);
}
}
var cA = new ClassA("red");
cA.show();
// ⼦类
function ClassB(sColor,age) {
// 通过冒充实现⼦类继承⽗类的⽅法、属性
this.newFn = ClassA; // 给this添加⼀个新的函数，也就是ClassA这个构造函数
this.newFn(sColor); // 执⾏新添加进去的函数，通过this.newFn调⽤ClassA,进⽽修改了ClassA中this指针的指向
delete this.newFn; // 修改完指针的指向后，就可以把新添加的这个⽅法删掉（过河拆桥）
// 继续添加新属性\⽅法
this.age = age;
}
var cB = new ClassB("green", 23);
cB.show();
console.log(cB.age);
</script>