ES6-第一天

谈谈对面向对象的理解：
首先，可以先谈谈“面向过程”vs“面向对象”。
面向过程更多是以执行者的角度来思考问题，而面向对象更多是以组织者的角度来思考问题，举个例子，比如我要去买电脑，如果是面向过程，就应该是我-打的-去电脑市场-选电脑-付钱-回家，而面向对象的做法应该是我-找朋友帮忙买-付钱给朋友-电脑到手。
面向过程性能比面向对象好点，但不如面向对象易维护与扩展。
所以，面向对象的思维更多的是考虑如何去选择合适的工具，然后组织到一起干一件事。
好比一个导演，要拍一场电影，那么首先要有男猪脚和女猪脚，然后还有其他等等，最后把这些资源组织起来，拍成一场电影。
再说回我们的程序世界，这个组织者的思维无处不在，比如，我们要开发项目，以三层架构的模式来开发，那么这个时候，我们不需要重复造轮子，只需要选择市面上主流的框架即可，比如SpringMVC，vue.js，这些都是各层的主流框架。
在JavaScript中，对象是一组无序的相关属性和方法的集合，所有事物都是对象。

说出类和对象的关系：
先看代码：

 // 1. 创建类 class  创建一个 明星类
        class Star {
            constructor(uname, age) {
                this.uname = uname;
                this.age = age;
            }
        }

        // 2. 利用类创建对象 new
        var ldh = new Star('刘德华', 18);
        var zxy = new Star('张学友', 20);
        console.log(ldh);
        console.log(zxy);
        //(1) 通过class 关键字创建类, 类名我们还是习惯性定义首字母大写
        //(2) 类里面有个constructor 函数,可以接受传递过来的参数,同时返回实例对象
        //(3) constructor 函数 只要 new 生成实例时,就会自动调用这个函数, 如果我们不写这个函数,类也会自动生成这个函数
        //(4) 生成实例 new 不能省略
        //(5) 最后注意语法规范, 创建类 类名后面不要加小括号,生成实例 类名后面加小括号, 构造函数不需要加function

类是拥有相同行为特征对象的一个抽象概念，而对象是类这个抽象概念中事实存在的个体。
打个比方：类;人，对象：你。人这个类可以是黄种人、黑种人、白种人等等，但是对象实实在在的
就是指类当中的一个个体.

继承：
1.使用关键字extends继承父类的属性和方法。
代码：

// 1. 类的继承
        // class Father {
        //     constructor() {

        //     }
        //     money() {
        //         console.log(100);

        //     }
        // }
        // class Son extends Father {

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

2.使用super关键字可以让父类使用子类数据。
代码：

class Father {
            constructor(x, y) {
                this.x = x;
                this.y = y;
            }
            sum() {
                console.log(this.x + this.y);

            }
            say() {
                return '我是爸爸';
            }
        }
        class Son extends Father {
            constructor(x, y) {
                super(x, y); //调用了父类中的构造函数,且super只能在this前面使用
                this.x = x;
                this.y = y;
            }
            say() {
                // console.log('我是儿子');
                console.log(super.say() + '的儿子');
                // super.say() 就是调用父类中的普通函数 say()
            }
            subtract() {
                console.log(this.x - this.y);
                 }
        }
        var son = new Son(1, 2);
        var son1 = new Son(11, 22);
        son.sum();
        son.say();
        son.subtract();
        son1.sum();
        // 继承中的属性或者方法查找原则: 就近原则
        // 1. 继承中,如果实例化子类输出一个方法,先看子类有没有这个方法,如果有就先执行子类的
        // 2. 继承中,如果子类里面没有,就去查找父类有没有这个方法,如果有,就执行父类的这个方法(就近原则)

注意：

1. 在 ES6 中类没有变量提升，所以必须先定义类，才能通过类实例化对象
2. 类里面的共有的属性和方法一定要加this使用.
3. constructor 里面的this指向实例对象, 方法里面的this 指向这个方法的调用者

 <button id="btn">点击</button>
    <script>
        var that;
        class Star {
            constructor(uname, age) {
                // constructor 里面的this 指向的是 创建的实例对象
                that = this;
                console.log(this);

                this.uname = uname;
                this.age = age;
                document.getElementById("btn").onclick = this.sing;
               }
            sing() {
                // 这个sing方法里面的this 指向的是 btn 这个按钮,因为这个按钮调用了这个函数
                console.log(this);
                console.log(that.uname); // that里面存储的是constructor里面的this
            }
        }
		var ldh = new Star('刘德华');
        console.log(that === ldh);
//此案例是想在点击按钮的时候调用sing方法，并且sing方法的参数是"刘德华",由于this的指向问题，sing方法的this是btn对象，
//btn对象是没有uname属性，所以在调用时会显示undifined，因此全局定义一个变量that，让that指向constructor中的this，
//这样在调用时就会显示实例的uname属性。

JavaScript原型：
1.方法才有prototype属性，对象实例有_proto_属性。，且实例的_proto_属性指向方法的prototype属性。
2.方法的prototype属性又拥有constructor属性，方法名.prototype.constructor指向方法对象，而实例对象.constructor也指向方法对象，
所以方法名.prototype.constructor== 实例对象.constructor 为true。
3.方法在创建的时候，就会有一个prototype属性，那这个prototype属性也是一个对象，那么它的_proto_属性应该指向它的构造方法的prototype属性，它的构造方法为Object()，这时候Object()的prototype也是个对象，但是它的_proto_属性指向null，就此终结。这就是原型链。
js原型和原型链
十八岁以上能看懂的原型和原型链