gdjlc

培养良好的习惯,每天一点一滴的进步,终将会有收获。

  博客园 :: 首页 :: 博问 :: 闪存 :: 新随笔 :: 联系 :: 订阅 订阅 :: 管理 ::

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。
派生类中的方法会屏蔽基类的同名方法。

posted on 2021-03-16 23:21  gdjlc  阅读(59)  评论(0编辑  收藏  举报