ES6-------学习（6）class

基本使用

class Point {
  constructor(x = 0, y = 0) {
    this.x = x;
    this.y = y;
  }
  toString() {
      return this.x + ':' + this.y;
  }
}

let point = new Point();
console.log(point.toString());

可以看到里面有一个constructor方法，这就是构造方法，而this关键字则代表实例对象。也就是说，ES5 的构造函数Point，对应 ES6 的Point类的构造方法。
constructor方法默认返回实例对象（即this）,完全可以指定返回另外一个对象；

class B{};
var b = new B();
B.prototype.constructor = b.constructor;

Point类除了构造方法，还定义了一个toString方法。注意，定义“类”的方法的时候，前面不需要加上function这个关键字，直接把函数定义放进去了就可以了。另外，方法之间不需要逗号分隔，加了会报错。

在类和模块的内部默认就是严格模式，所以不需要use strict指定运行模式,只要代码写在类或者模块之中，就只有严格模式可用；

class内部只允许定义方法，不允许定义属性（包括静态属性），下面这种写法是无效的

class Foo{
  bar:2
}

继承

class Point {
  constructor(x, y, color) {
    super(x, y); // 调用父类的constructor(x, y)
    this.color = color;
  }

  toString() {
    return this.color + ' ' + super.toString(); // 调用父类的toString()
  }
}

class ColorPoint extends Point {
}
let sunny=new ColorPoint;
sunny.name('haha');

//例子2

class Animal {
  constructor(name = 'John Doe', species = '物种'){
      this.name = name;
      this.species = species;
  }

  sayHello(){
    console.log('hello',this.name,this.species)
  }
}

class Sheep extends Animal{
    constructor(name = 'Jimmy',species = '羊'){
        super(name, species);
    }

    sayHello(){
        console.log('child');
        super.sayHello()
    }
}

let sheep = new Sheep('Tom');
sheep.sayHello();

静态方法

class Foo{
    static say(){
        console.log('I am saying: ');
    }
}

class Bar extends Foo{
    sayHello(){
        super.say(); // 报错，因为sayHello不是静态方法
        console.log('hello');
    }

    static singHello(){
        super.say();
        console.log('hello')
    }
}

Bar.say();
let bar = new Bar();
bar.sayHello();

在子类的静态方法中，可以使用super调用父类的静态方法。注意，子类静态方法中的super只能调用父类的静态方法，而不能调用父类的其它方法，反之亦然，子类的实例方法中的super只能调用父类的实例方法，不能调用其静态方法，如果想要调用父类的静态方法，可以使用父类名.方法的方式。