JS高级面向对象类和对象，继承

面向对象是什么？它的优缺点是什么？
面向对象是把事物分解成一个个的对象，然后对象之间分工与合作。
它的三大特性：封装性，继承性，多态性。
它的优点是易维护，易复用，易扩展，缺点是性能比面向过程低。

创建类和对象：

// 1，创建类class创建一个明星类
    class Star {
        // 构造函数
        constructor(uname, age){
            this.uname = uname;
            this.age = age;
        }
        //创建唱歌这个方法
        sing(song) {
            console.log(this.uname+song);
        }
    }
    //2，利用类创建对象new
    var ldh = new Star('刘德华', 18);
    var zxy = new Star('张学友', 20);
    console.log(ldh);
    console.log(zxy);
    ldh.sing('冰雨');
    zxy.sing('吻别');
    //1，类里面所有的函数不需要写function
    //2，多个函数方法之间不需要添加逗号分隔

先创建一个明星类Star，类相当于一个模板，有uname和age两个属性和一个sing方法，利用类创建对象ldh和zxy，打印出ldh和zxy两个实例对象和sing方法。

类的继承

class Father {
        constructor() {

        }
        money() {
            console.log(100);
        }
    }
    class Son extends Father {

    }
    var son = new Son();
    son.money();

Father类有构造函数和money函数，Son 继承于Father，Son调用money方法，打印出100。

class Father {
        constructor(x,y){
            this.x = x;
            this.y = y;
        }
        sum() {
            console.log(this.x + this.y);
        }
    }
    class Son extends Father {
        constructor(x, y) {
            super(x, y); // 调用了父类中的构造函数
        }
    }
    var son = new Son(1,2);
    var son1 = new Son(11,22)
    son.sum();
    son1.sum();

父类中的构造函数有x,y两个参数，sum方法让x+y，子类继承父类，子类想调用父类中的构造函数就必须使用super关键字。

// super关键字调用父类普通函数
    class Father {
        say() {
            return '我是爸爸';
        }
    }
    class Son extends Father {
        say() {
            //console.log('我是儿子');
            console.log(super.say() + '---的娃');
            // super.say() 就是调用父类中的普通函数
        }
    }
    var son = new Son();
    son.say();
     // 继承中有就近原则，如果子类中有这个方法就直接调用子类中的方法，
     //如果子类没有就往父类中找，父类有就执行父类中的方法。

super关键字不仅可以调用父类的构造函数，还能调用父类中的普通函数。

子类不仅可以继承父类中的方法，还能扩展自己的方法

class Father {
        constructor(x,y) {
            this.x = x;
            this.y = y;
        }
        sum() {
            console.log(this.x + this.y);
        }
    }
    //子类继承父类的加法，同时扩展减法
    class Son extends Father{
        constructor(x,y) {
            // 利用super调用父类构造函数
            // super必须在子类this之前调用
            super(x,y);
            this.x = x;
            this.y = y;
        }
        subtract() {
            console.log(this.x - this.y);
        }
    }
    var son = new Son(5,3);
    son.subtract();
    son.sum();

子类继承父类中的方法，使用super关键字调用父类中的方法必须在this之前，否则会报错。

使用类注意事项：
1，在ES6中类没有变量提升，所以必须先定义类，才能通过类实例化对象
2，类中共有的属性和方法一定要加this使用。

this指向问题：
constructor里面的this指向的是实例对象，普通函数里的this指向的是函数的调用者。

按钮