JavaScript类和对象（ES6）

类和对象

创建类和对象

 <script>
     // 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
  </script>
  

类中添加方法

 <script>
        // 1. 创建类 class  创建一个 明星类
        class Star {
            // 类的共有属性放到 constructor 里面
            constructor(uname, age) {
                this.uname = uname;
                this.age = age;
            }
            sing(song) {
                // console.log('我唱歌');
                console.log(this.uname + song);

            }
        }

        // 2. 利用类创建对象 new
        var ldh = new Star('刘德华', 18);
        var zxy = new Star('张学友', 20);
        console.log(ldh);
        console.log(zxy);
        // (1) 我们类里面所有的函数不需要写function 
        //(2) 多个函数方法之间不需要添加逗号分隔
        ldh.sing('冰雨');
        zxy.sing('李香兰');
    </script>

类继承的extends和super关键字

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

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

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

        // }
        // var son = new Son();
        // son.money();
        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();
  </script>

super关键字调用父类普通函数

<script>
        // super 关键字调用父类普通函数
        class Father {
            say() {
                return '我是爸爸';
            }
        }
        class Son extends Father {
            say() {
                // console.log('我是儿子');
                console.log(super.say() + '的儿子');
                // super.say() 就是调用父类中的普通函数 say()
            }
        }
        var son = new Son();
        son.say();
        // 继承中的属性或者方法查找原则: 就近原则
        // 1. 继承中,如果实例化子类输出一个方法,先看子类有没有这个方法,如果有就先执行子类的
        // 2. 继承中,如果子类里面没有,就去查找父类有没有这个方法,如果有,就执行父类的这个方法(就近原则)
    </script>

子类继承父类同时扩展自己的方法

<script>
    // 父类有加法方法
    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();
</script>

使用类注意事项

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

              this.uname = uname;
              this.age = age;
              // this.sing();
              this.btn = document.querySelector('button');
              this.btn.onclick = this.sing;
          }
          sing() {
              // 这个sing方法里面的this 指向的是 btn 这个按钮,因为这个按钮调用了这个函数
              //这里的console的this指的是调用这个方法的对象button
              console.log(this);

              console.log(that.uname); // that里面存储的是constructor里面的this
          }
          dance() {
              // 这个dance里面的this 指向的是实例对象 ldh 因为ldh 调用了这个函数
              _that = this;
              console.log(this);

          }
      }

      var ldh = new Star('刘德华');
      console.log(that === ldh);
      ldh.dance();
      console.log(_that === ldh);

      // 1. 在 ES6 中类没有变量提升，所以必须先定义类，才能通过类实例化对象

      // 2. 类里面的共有的属性和方法一定要加this使用.
  </script>