es6 class

1.Es6引入了Class 类这个概念，作为对象的模板，通过class 关键字，可以定义类。

2.类和模块的内部，默认就是严格模式，所以不需要使用use strict 指定运行模式。

3.constructor 方法就是类的默认方法，通过new 命令生成对象实例时，自动调动该

　　方法，一个类必须有constructor 方法，如果没有显示定义，一个空的constructor

　　方法会默认添加。

4.类的实例对象

　　必须使用new ，像函数那样调用Class ，将会报错。

　　　　例如:　

　class Point {
　　　　　　}
　　　　　　// 报错
　　　　　　var point = Point(2,3);
　　　　　　// 正确
　　　　　　var point = new Point(2,3)

5.Class表达式

　　与函数一样，类也可以使用表达式的形式定义。

　const MyClass = class Me{
　　　　　　getClassName() {
　　　　　　　　　　return Me.name;
　　　　　　　　}
　　　　};

　　采用Class 表达式，可以写出立即执行的Class

let person = new clas {
　　　　　　　　constructor(name){
　　　　　　　　this.name = name;
　　　　　　}
　　　　sayName() {
　　　　　　console.log(this.name);
　　　　}
　　}('张三')；
　　person.sayName(); //张三

6.类不存在变量提升。

7.不提供私有方法和私有属性。

8.this 的指向

　　类德丰放内部含有this,它默认指向类的实例。

9.class 的静态方法。在类中定义的方法，都会被实例继承，

　　如果在一个方法前加上static 关键字，就表示该方法

　　不会被实例继承，而是直接通过类来调用。

　class Foo {
　　　　static classMethod() {
　　　　　　return 'hello';
　　　　}
　　}
　　Foo.classMethod() // 'hllo'
　　var foo = new Foo();
　　foo.classMethod(); // 报错

10.class 可以通过extends关键字实现继承。

　class Point {}
　　　　class ColorPoint extends Point{}
 
　　　　class ColorPoint extends Point {
　　　　　　constructor(x,y.color){
　　　　　　　　super(x,y); // 调用父类的 constructor(x,y)
　　　　　　　　this.color = color;
　　　　}
 
　　toString() {
　　　　return this.color + ' '+ super.toString(); // 调用父类的方法
　　　　}
　　}

　　子类必须在constructor 方法中调用super 方法，否则新建实例时会报错，因为子类没

　　有自己的 this 对象，而是继承父类的this 对象，而活对其进行加工，如果不调用

　　super 方法，子类就的不到this 对象。

11.Object.getPrototypeOf()

　Object.getPrototypeOf(ColorPoint) == Point

　　可以使用这个方法判断，一个类是否继承另一个类。

12.super 关键字

　　　　super 这个关键字既可以当作函数使用，也可以当做对象使用。

　　　　1.super 作为函数调用的时，代表父类的构造函数。子类的构造函数必须

　　　　执行一次super函数。　　

　　　　　　class A {}
　　　　　　class B extends A {
　　　　　　　　constructor() {
　　　　　　　　　　super();
　　　　　　　　}
　　　　　　}

　　　　2.super 作为对象时，在普通方法中，指向父类的原型对象，在

　　　　　　静态方法中指向父类。

　　　class A {
　　　　　　p() {
　　　　　　　　return 2;
　　　　　　}
　　　　}
　　　　class B extends A{
　　　　　　constructor() {
　　　　　　　　super();
　　　　　　　　console.log(super.p()); // 2
　　　　　　}
　　　　}

13.类的prototype 属性和__proto__ 属性

　　　　class 作为构造函数的语法糖，同时有prototype 属性和__proto__属性，因此

　　　　存在两天继承连。

　　　　1.子类的__proto__ 属性,表示构造函数的继承，总是指向父类。

　　　　2.子类的prototype 属性的__proto__属性，表示该方法的继承，总是指向父类

　　　　　　的protoype属性。

　class A {}
　　　　class B extends A {}
　　　　　　B.__proto__===A // true
　　　　　　B.proptoype.__proto__ === A.prototype // true

14.extends 的继承目标

　　extends 关键字后面可以跟很多类型的值。

15.实例的__proto__属性

　　子类属性的__proto__属性的__proto__属性，指向父类实例的__proto__，也就是说

　　子类原型的原型，是父类的原型。

　var p1 = new Point(2,3);
　　var p2 = new ColorPoint(2,3,'red');
　　　　p2.__proto__===p1.__proto // false
　　　　p2.__protot__.__proto__===p1.__proto__ // true