类的知识

构造对象的三种方法：

（1）利用new Object（）创建对象

var obj1 = new Object();

（2）利用对象字面量创建对象

var obj2 = {};

（3）利用构造函数创建对象

类的相关知识：

代码：

<script>
        // <!-- 定义类的·关键词是class -->
    // <!-- 创建一个person类 -->
    class person {
        // 类你得需要接受来自实例对象
        // 通过构造器方法
        constructor (name, age) {
            // 构造器中的this是谁？-类的实例对象
            this.name = name
            this.age = age
        }
        // 一般方法
        speak () {
            // speak方法放在了哪里？==类的原型对象上，供实例使用
            // 这个this具体看谁点的speak
            console.log(`我叫${this.name},我的年龄是${this.age}`)
        }
    }
    // 类的作用就是实例化一个对象
    // 创建一个person的实例对象
    const p1 = new person('tom', 18)
    const p2 = new person('jerry',19)
    console.log(p1)
    console.log(p2)
    p1.speak()
    p2.speak()
    // call的作用是你传什么我改什么
    p1.speak.call({a:1,b:2})
    </script>

类的继承：

如果子类和父类的属性都一样的话，这个时候就不需要写构造器了，方法也可以继承

<script>
        class person {
        // 类你得需要接受来自实例对象
        // 通过构造器方法
        constructor (name, age) {
            // 构造器中的this是谁？-类的实例对象
            this.name = name
            this.age = age
        }
        // 一般方法
        speak () {
            // speak方法放在了哪里？==类的原型对象上，供实例使用
            // 这个this具体看谁点的speak
            console.log(`我叫${this.name},我的年龄是${this.age}`)
        }
    }

        class Student extends person {
        }
        const s1 = new Student('小张','19','高一')
        console.log(s1)
    </script>

如果子类有多余的属性，这个时候

（1）不仅要写构造器

（2）还要通过super关键字接受它们共有的属性

（3）共有的属性必须放在多于属性之前

<script>
        class person {
        // 类你得需要接受来自实例对象
        // 通过构造器方法
        constructor (name, age) {
            // 构造器中的this是谁？-类的实例对象
            this.name = name
            this.age = age
        }
        // 一般方法
        speak () {
            // speak方法放在了哪里？==类的原型对象上，供实例使用
            // 这个this具体看谁点的speak
            console.log(`我叫${this.name},我的年龄是${this.age}`)
        }
    }

        class Student extends person {
           constructor (name, age, grade) {
           // 构造器中的this是谁？-类的实例对象
              super(name, age)
              this.grade = grade
           } 
        }
        const s1 = new Student('小张','19','高一')
        console.log(s1)
    </script>

关于方法：

<script>
        class person {
        // 类你得需要接受来自实例对象
        // 通过构造器方法
        constructor (name, age) {
            // 构造器中的this是谁？-类的实例对象
            this.name = name
            this.age = age
        }
        // 一般方法
        speak () {
            // speak方法放在了哪里？==类的原型对象上，供实例使用
            // 这个this具体看谁点的speak
            console.log(`我叫${this.name},我的年龄是${this.age}`)
        }
    }

        class Student extends person {
           constructor (name, age, grade) {
           // 构造器中的this是谁？-类的实例对象
              super(name, age)
              this.grade = grade
           }
           speak () {
            console.log(`我叫${this.name},我的年龄是${this.age},我的年级是${this.grade}`) 
           }
           study () {
            console.log('我很努力学习')
           }
        }
        const s1 = new Student('小张','19','高一')
        console.log(s1)
        s1.speak()
        s1.study()
    </script>

如果实例化对象没有进行外部传参，但是又想添加新的属性，可以如下a的写法：写在构造器之外

<script>
        // <!-- 定义类的·关键词是class -->
    // <!-- 创建一个person类 -->
    class person {
        // 类你得需要接受来自实例对象
        // 通过构造器方法
        constructor (name, age) {
            // 构造器中的this是谁？-类的实例对象
            this.name = name
            this.age = age
        }
        // 类中可以直接写赋值语句
        // 这样相当于是给实例添加新的属性
        a = 1
        // 一般方法
        speak () {
            // speak方法放在了哪里？==类的原型对象上，供实例使用
            // 这个this具体看谁点的speak
            // console.log(`我叫${this.name},我的年龄是${this.age}`)
            console.log(this)
        }
    }
    // 类的作用就是实例化一个对象
    // 创建一个person的实例对象
    const p1 = new person('tom', 18)
    const p2 = new person('jerry',19)
    console.log(p1)
    console.log(p2)
    p1.speak()
    p2.speak()
    // call的作用是你传什么我改什么
    // p1.speak.call({a:1,b:2})
    const x = p1.speak
    x()

构造原型对象prototype的原理：

（1）在构造函数中，里面this指向的是对象实例ldh

（2）在原型对象函数里面的this指向的是实例对象ldh

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9glQ3VIy-1617324779468)(D:\微信小程序笔记\es6语法\1.PNG)]

如上图所示中，两个实例对象ldh和zxy，他们中的函数是一样的，但是存储的地址是不一样的，这就造成了内存的浪费

构造函数通过原型分配的函数是所有对象所共享的，每一个构造函数都有一个prototype属性，可以把那些不变的方法，直接定义在prototype对象上，这样所有对象的实例就可以共享这些方法

<script>
        function star (uname,age) {
            this.uname = uname;
            this.age = age;
        }
        star.prototype.sing = function () {
            console.log('我会唱歌')
        }
        var ldh = new star ('刘德华','30')
        var zxy = new star ('张学友','30')
        ldh.sing()
        zxy.sing()
    </script>

对象有个属性，_proto_指向构造函数的prototype原型对象

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QSNqEFbB-1617324779470)(D:\微信小程序笔记\es6语法\e308b8183c8aea6062ca12d070382ce.png)]

假如有多个方法需要写入的话，按照如下格式：

如下格式会将constructor给覆盖掉

        function star (uname,age) {
            this.uname = uname;
            this.age = age;
        }
        
        star.prototype = {
            sing:function () {
                console.log()
            },
            movie:function () {}
        }


        var ldh = new star ('刘德华','30')
        var zxy = new star ('张学友','30')
        console.log(ldh)
        ldh.movie()

正确写法：

如果我们修改了原来的原型对象，给原型对象赋值的是一个对象，则必须手动的利用constructor:star,指回原来的构造函数

constructor的作用：告诉我们对象到底是通过哪个构造函数创建出来的

function star (uname,age) {
            this.uname = uname;
            this.age = age;
        }
        
        star.prototype = {
            constructor:star,
            sing:function () {
                console.log("我会唱歌")
            },
            movie:function () {
                console.log("我会演电影")
            }
        }


        var ldh = new star ('刘德华','30')
        var zxy = new star ('张学友','30')

原型链：

1.实例对象本身有属性

ldh.sex = '男'

2.原型对象prototype身上有没有属性

star.prototype.sex = '男'

3.原型对象的原型

object.prototype.sex = '男'

对象方法：

Object.defineProperty()定义对象中新属性或修改原有的属性

Object.defineProperty(obj，prop，descriptor)

obj：必须，目标对象

prop：必须，需定义或修改的属性的名字

descriptor：必须，目标属性所拥有的特性

descriptor说明：以对象{}书写

value：设置属性的值

writable：值是否可以重写，true/false，默认为false

enumerable：目标属性是否可以被枚举

configurable：目标属性是否可以被删除或是否可以再次被修改特性