JS2 -- 继承：（封装、多态、抽象）

 

Js所有的函数都有一个prototype属性，这个属性引用了一个对象，即原型对象，也简称原型。

每一个对象都有原型，在浏览器中它体现在一个proto的内置属性上。
当一个对象需要调用某个方法时，它回去最近的原型上查找该方法，如果没有找到，它会再次往下继续查找。这样逐级查找，一直找到了要找的方法。 这些查找的原型构成了该对象的原型链条。原型最后指向的是null。

我们说的原型继承，就是将父对像的方法给子类的原型。子类的构造函数中不拥有这些方法和属性。

 

函数	prototype,函数也是对象所以也有下面的属性
对象	__proto__, contructor

function.__proto__    =>  object  => null

 

 

例子：

var person = function () {}
person.prototype.getName = function (k) {}

var student = new person {}
student.getName('Jan')
　　 

1.函数a有个内置属性： __proto__

2.属性proto的作用是 指向创建它的函数对象(创建函数a的函数对象 -- person)的prototype

3.因此，函数a.proto == person.prototype

（父亲 会吃喝拉撒(属性)，还会骑单车、玩游戏(方法)，将来想传承给儿子们(prototype)。生了个大儿子，他通过(proto)继承了父亲的传承。）

 

二、__prototype__（内置原型，函数原型prototype,包含所有实例共享的属性和方法）     

function Foo(name,job,born){
    this.name=name || 'tony';
    this.job=job || 'ok';
    this.born=born;
}
Foo.prototype.a = '共有1'
Foo.prototype.b = '共有2'
let f1 = new Foo();


console.log(f1.__proto__)                                // Foo.prototype => {a: '共有1', b: '共有2'}
console.log(f1.__proto__.__proto__)                      // 对象
console.log(f1.__proto__.__proto__.__proto__)            // null

f1.__proto__                           f1 -> Foo

f1.__proto__.__proto__                 f1 -> Foo -> Object

f1.__proto__.__proto__.__proto__       f1 -> Foo -> Objcet -> null

 

三、.添加的属性 和 prototype添加的属性 的区别

1.
. : 只影响这个对象自身（私有）
prototype: 影响这个类的所有实例对象（共有）
2.一个是对象本身 一个是原型上所有对象共享

function Foo(name,job,born)
{
    this.name=name || 'tony';
    this.job=job || 'ok';
    this.born=born;
}
Foo.spot = '私有'
Foo.prototype.a = '共有'
let f1 = new Foo();

console.log(Foo.spot)                    // '私有'   => 函数私有
console.log(Foo.a)                        // undefined => 未实例前
console.log(f1.spot)                    // undefined => 不是实例共有
console.log(f1.a)                        // '共有' => 实例共有

四、判断是否是自身继承属性与删除

console.log(Array.prototype.hasOwnProperty('toString'))  // true
delete Array.prototype.toString    
console.log(Array.prototype.hasOwnProperty('toString'))  // false

五、call

 调用者.函数（参数1，参数2，参数3） ==   函数.call（调用者，参数1，参数2，参数3）

function a(e) {
    this.kk = 1;
}
a.prototype.aaaa = function(e) {
    console.log(1)
    console.log(e)
    return e;
}
let nn = new a();
console.log(nn.aaaa.call(null,'kkkk'))

 

 

抽象、封装、继承、多态

 

https://www.jianshu.com/p/60aaf95a4f78

https://mp.weixin.qq.com/s/2kxBrYZJaKPHilYpWwPK_A