面向对象、原型链、类

面向对象

1.1 对象的基本概念

1.1.1对象是什么？为什么引入对象？
（1）除了基本类型（String、Number、Boolean、Null、Undefined）以外的数据类型都是对象（Object）
（2）由于基本类型数据都是单一的值，值和值之间没有关系，所以使用对象来使值与值之间存在关系。
对象属于复合类型数据在对象中可以保持不用数据类型的属性

1.1.2 对象分类
（1）内建对象：js标准中定义的对象
Boolean、Math、String、 Number、Function、Object
（2）宿主对象：由js的运行环境所提供的对象
Dom、console、document
（3）自建对象：由开发人员之间创建的对象

1.2 创建对象

1.2.1 对象字面量

let point = { x: 0, y: 0 }; 

1.2.2 new方法

 var o = new Object();
 o.name="tom";

1.2.3 Object.create( )
使用此方法，在创建的时候设置对象原型。

let obj1 = Object.create({ x: 1, y: 2 });

---

原型

2.1 原型基本

2.1.1原型是什么？
创建的每一个函数（包括构造函数、普通函数）解析器都会向函数中添加一个唯一的prototype属性，这个prototype指向一个对象，这个对象就是原型对象。

2.1.2原型对象的作用
当这个函数作为普通函数调用的时候，prototype没有任何作用，但是作为构造函数调用的时候，所创建的对象中会有一个隐含的属性（_ proto_ ）来指向该构造函数的原型对象。
所以可以理解原型对象就是一个公共的区域，所有同一个类的实例都可以访问到
在开发的过程中就可以把对象共有的内容放在原型中，不会污染全局空间

补充constructor属性：
原型对象存在constructor属性 。指回构造函数
constructor属性是仅存在于原型对象中的

2.2 原型链

2.2.1什么是原型链，原型链是如何形成的？
当对象原型是另一个构造函数的实例 如此迭代 形成一连串继承关系 即为原型链

由此产生原型链。

说明：Object对象的原型对象没有原型对象。

2.3 原型链的作用：
当我们使用一个对象的属性或方法的时候，会先在自身中寻找
自生中有，就直接使用
如果没有，就去原型对象中找，如果原型对象中有，则使用
如果没有就去原型的原型中找
直到找到Object对象的原型

不同情况下的原型

3.1 创建方式不同 原型不同

3.2 通过 Object.setPrototypeOf() 方法 可以设置和修改原型

参数一：需要被修改原型的对象。
参数二：将会成为前者原型的对象。

let a={name:'aa'}
let b={name:'bb'}
Object.setPrototypeOf(a,b)//将a的原型设置为b
console.log(Object.getPrototypeOf(a) === b) //true

3.3 通过 构造函数.prototype = 原型对象 的方式可以设置和修改原型

注意：这种修改 不会使已有的对象实例的原型修改

        function A(){

        }
        //原来的对象实例
        let a1=new A()
        A.prototype={name:'lihua'}
        //新的原型对象
        let a2=new A()
        console.log(a1.name) //undefinded
        console.log(a2.name) //lihua

类

4.1 为什么引入类？

解决es5中对象继承问题

        //es5实现继承
        function Parent(name,age){
            this.name=name
            this.age=age
        }
        Parent.prototype.setProto = function(attr,value){
            this[attr]=value
        }
        function Student(name,age,score){
            Parent.call(this,name,age) //盗用构造函数 解决数据和结构的问题
            this.score = score
        }
        Student.prototype = new Parent() //强制将原型设置为Person
        Student.prototype.constructor = Student // 强制将原型的constructor设置为本身
        let student1=new Student('小明',12,60)
        let student2=new Student('小张',15,70)
        console.log(student1,student2)
        student2.setProto('like','eat')
        console.log(student2)

4.2 es6类的基本使用

        //类
        class Car{
            // 在这里接收参数
            constructor(options){
                this.name = options.name
            }
            // 方法
            sayHello(){
                console.log('hello')
            }
        }
        //以对象的形式传参
        let car = new Car({name:'lihua'})
        console.log(car)//car:{name:'lihua'}
        console.log(car.sayHello)//hello

4.3 类的继承

使用super

        //类
        class Person{
            constructor(options){
                this.name = options.name
            }
            sayHello(){
                console.log('hello')
            }
        }
        class Student extends Person{
            constructor(options){
                super(options);
                this.score=options.score
            }
        }

        let student1=new Student({name:'李华',score:'80'})
        console.log(student1)//student1:{name:'李华',score:'80'}
        student1.sayHello()//hello