面向对象编程

面向对象

对象是什么？为什么要面向对象 / 优势 =》 简化我们对于行为岔路的预备

特点：逻辑迁移更加灵活，代码复用性高，高度模块化的体现

• 模块、接口 => 对象

对象的理解

• 对象对于有单个物体的简单抽象
• 对象是一个容器，封装了属性和方法 ** 属性：对象的状态 ** 方法：对象的行为

//简单对象
const Course = {
teacher:`云隐`,
leader:`小异`,
startCourse:function(name){ 
     return `开始${name}课`;
   }
}

function Course(){
     this.teacher:`云隐`;
     this.leader:`小异`;
     this.startCourse = function(name){
         return `开始${name}课`;
     }
}
//构造函数 => 严谨化构造一个对象

构造函数 - 生成对象

需要一个模板-表征了一类物体的共同特征，从而生成对象

类即对象模板

js其实本质上并不是直接基于类，基于构造函数+原型链 => constructor+ prototype

function Course(teacher){
     this.teacher = teacher;
     this.leader = `小异`;
     this.startCourse = function(name){
         return `开始${name}课`;
     }
}
const course = new Course('云隐');//新的对象

Course 本质就是构造函数

• 1.函数体内使用的this，指向所要生成的实例
• 2. 生成实例对象需要new来进行实例化
• 3.可以做初始化传参

追问:

如果构造函数不初始化，可以作为对象生成器使用吗？ - 不可以

如果项目需要使用，（又不想被外部感知），通常如何解决？

//使用方
const course = Course();

//单例模式 => 全局维护唯一实例 => 解决对象实例化生成问题
function Course(teacher){
   const _isClass = this instanceof Course;
   if(!_isClass){
      return new Course();
      }
   this.teacher = teacher;
   this.leader = "小伊"
   this.startCourse= function(name){
       return `开始${name}课`;
     }
  }

• 启发:在编写底层api时，尽量做到不需要让外部感知内部类型

引发思考， new是什么 / new原理 / new的时候做了什么

function Cpurse(){}
const course =  new Course();

• 1.结构上:创建了一个空对象，作为返回的对象实例
• 2.将生成空对象的原型对象（proto）指向了构造函数的prototype属性
• 3.关系上:将当前实例对象赋给了内部的this
• 4.生命周期上:执行了构造函数的初始化代码

追问:实例化生成对象原因 - 独立

functionCourselves（teacher）{
this.teacher= teacher；
this.leader= '小伊';
this.startCourse = function(name)【
return `开始${name}课`;
}
}
const course1 = new Course(`云隐`);
const course2 = new Course(`吴彦祖`);

course2.teacher = `云隐帅`

• => 都是面向对象做铺垫的

(重点)

constructor 是什么？

functionCourselves（teacher）{
this.teacher= teacher；
this.leader= '小伊';
this.startCourse = function(name)【
return `开始${name}课`;
}
}
const course =  new Course();

• 1.每个对象在创建时，会自动拥有一个构造函数属性constructor
• 2.constructor继承自原型对象，指向了构造函数的引用
• 实力获得类的属性 => （大胆点） 继承了类的属性

追问:使用构造函数继承属性就没有问题么/ 会有什么性能上的问题?

function Course(name){
     this.teacher = `云隐`;
     this.leader = `小伊`;
     this.startCourse =  function(name){
       return `开始${name}课`;
      }
  }
  const course1 = new Course(`this`)
  const course2 = new Course(`OOP`)
    //构造函数中的方法会存在于每一个生成的实力内，而方法往往需要模板统一化，重复的挂载只会浪费资源

=> 思考：如何进行优化? 前面提到的原型对象又是什么?

原型对象

function Course();
const course1  = new Course();
const course2  - new Course();

• 1.构造函数:用来初始化创建对象的函数 - Course ** 自动给构造函数赋予一个属性prototype,该属性等于实例对象的__proto__

• 2.实例对象:course1,根据原型对象创建出来的实例 ** 每个实例都会在创建是，具备一个constructor ** constructor由继承而来，并指向当前的构造函数 ** 每个被生产的对象中，都有一个__proto__

• 那么prototype是什么呢？

• 3.原型对象：Course.prorotype

function Course(name){
     this.teacher = `云隐`;
     this.leader = `小伊`;
  }
  //方法挂载到构造函数的原型对象上
  Course.prototype.startCourse = function(name){
     return `开始${name}`
   }
  const course1 = new Course(`this`);
  const course2 = new Course(`OOP`);