深入理解ES6读书笔记8：类

ES6新增了类。

类的创建方式有：类声明、类表达式、具名类表达式。

//类声明 class PersonClass {
//类表达式 let PersonClass = class{
//具名类表达式 let PersonClass = class PersonClass2{
class PersonClass{
    //构造器
    constructor(name){
        this.name = name;
    }
    //方法
    sayName(){
        console.log(this.name);
    }
}
let person = new PersonClass("张三");
person.sayName();

类可以作为参数传入函数。

function createObject(classDef) {
    return new classDef();
}
let obj = createObject(class {
    sayHi() {
        console.log("Hi!");
    }
});
obj.sayHi(); // "Hi!"

类表达式的另一个用途是立即调用类构造器，以创建单例。

let person = new class {
    constructor(name) {
        this.name = name;
    }
    sayName() {
        console.log(this.name);
    }
}("Hi");
person.sayName(); // "Hi"

访问器属性

class PersonClass {
    constructor(name) {
        this._name = name;
    }
    get name(){
        return this._name;
    }
    set name(value){
        this._name = value;
    }
};
let person = new PersonClass("张三"); //"张三"
console.log(person.name);
person.name = "李四";
console.log(person.name); //"李四"

静态成员
ES5及更早版本中是在构造器上添加额外方法来模拟静态成员。

function PersonType(name) {
    this.name = name;
}
// 静态方法
PersonType.create = function(name) {
    return new PersonType(name);
};
// 实例方法
PersonType.prototype.sayName = function() {
    console.log(this.name);
};
var person = PersonType.create("张三");

ES6静态成员则是在方法与访问器属性的名称前添加static关键字。

class PersonClass {
    // 等价于 PersonType 构造器
    constructor(name) {
        this.name = name;
    }
    // 等价于 PersonType.prototype.sayName
    sayName() {
        console.log(this.name);
    }
    // 等价于 PersonType.create
    static create(name) {
        return new PersonClass(name);
    }    
}
let person = PersonClass.create("张三");

使用派生类进行继承
使用extends关键字指定当前类所需要继承的函数，调用super()方法访问基类的构造器。

class Rectangle {
    constructor(length, width) {
        this.length = length;
        this.width = width;
    }
    getArea() {
        return this.length * this.width;
    }
    static create(length, width) {
        return new Rectangle(length, width);
    }
}
class Square extends Rectangle {
    constructor(length) {    
        super(length, length);
    }
}
var square = new Square(3);
console.log(square.getArea()); // 9
console.log(square instanceof Square); // true
console.log(square instanceof Rectangle); // true
//继承静态成员
var rect = Square.create(3, 4);
console.log(rect.getArea()); // 12

继承了其他类的类被称为派生类。如果派生类指定了构造器，就需要使用 super() ，否则会造成错误。
若不使用构造器， super()方法会被自动调用，并会使用创建新实例时提供的所有参数。
使用 super()的注意点：
(1)只能在派生类中使用 super() 。
(2)在构造器中，必须在访问 this 之前调用 super() 。
(3)唯一能避免调用 super() 的办法，是从类构造器中返回一个对象。
(4)可以在派生类方法中使用super.xx()调用基类方法xx。
派生类中的方法会屏蔽基类的同名方法。