【14. 面向对象】

定义

OOP     Object Oriented Programming
特征    封装、继承、多态
创造对象-描述对象-调用

构造函数

首字母一般大写，使用new关键字调用
默认return返回this指向实例对象，一般不修改return

function Func() {}
const fn = new Func()

Func.prototype.isPrototypeOf(fn)  // true
fn instanceof Func    // true

new关键字的作用
第一步  fn = {}
第二步  fn.__proto__= Func.prototype
第三步  构造函数正常赋值
第四步   把这个对象return回去

原型对象

原型对象：是每一个函数都会存在的一个属性，属性名prototype，属性值是一个对象
构造函数的实例可以访问这个构造函数的原型对象中的所有方法和属性

每一个非字面量定义的对象（实例）都有一个属性__proto__, 指向构造出这个对象的构造函数的原型对象，顶级对象为OBJECT

如 Func.prototype === fn.__ptoto__ === Object.getPrototypeOf(fn)

Object.setPrototypeOf(fn, {})会强制改变fn的__proto__, 但是Func.prototype不受影响

重置原型对象

function Func() {
  this.name = 'a'
}
Func.prototype = {
// 重置原型对象，需要注意的是 重置原型对象之后 会导致 原型对象失去
// constructor属性,导致不知道这个原型对象是哪个构造函数的原型对象
// constructor属性是每一个原型对象都会存在的属性，指向的是一个构造函数
  constructor: Func,
  init() {},
}

// enumerable: 布尔值 表示这个属性是否可遍历
// true 表示可遍历   // false 表示不遍历
// 让constructor不在Drag.prototype(实例.__proto__)的可遍历中
Object.defineProperty(Func.prototype, 'constructor', {
  enumerable: false,
})

原型链

对象访问属性的机制，就近原则
现在实例fn上查询， 没有就查fn.__proto__（构造函数的原型对象），一直向上查询，直到Object.__proto__ = {}

class声明函数

class People {
  //  初始化
  constructor(race) {
    this.race = race
  }
  // 这里往下所有方法实际都是写在People的原型对象上的
  static init() {
    console.log('静态方法')
  }

  say() {
    People.init()
    console.log(`I am a ${this.race}`)
  }
}

class Man extends People {
  constructor(sex) {
    super('human')
    this.sex = sex
  }

  declare() {
    console.log(`I am a ${this.sex}`)
  }
}

const boy = new Man('man')
boy.say()
boy.declare()
console.log(boy)  // Man { race: 'human', sex: 'man' }