Class类

es6

class Person {
    constructor() {}
}

ts

class Person {
    // 在TypeScript是不允许直接在constructor 定义变量的 需要在constructor上面先声明
    // 如果了定义了变量不用 也会报错 通常是给个默认值 或者 进行赋值
    name: string
    age: number

    constructor(name: string, age: number) {
        this.name = name
        this.age = age
    }
}

类的修饰符

public private protected

class Person {
    // 使用public 修饰符 可以让你定义的变量 内部访问 也可以外部访问 如果不写默认就是public
    public name: string
    // 使用  private 修饰符 代表定义的变量私有的只能在内部访问 不能在外部访问
    private age: number
    // 使用  protected 修饰符 代表定义的变量私有的只能在内部和继承的子类中访问 不能在外部访问
    protected data: any

    constructor(name: string, age: number, data: any) {
        this.name = name
        this.age = age
        this.data = data
    }
}

static 静态属性 和 静态方法

class Person {
    static name: string = 'mk'

    constructor() {
        this.name // error 用static 定义的属性 不可以通过this 去访问 只能通过类名去调用
    }
}

Person.name // 0k

如果两个函数都是static 静态的是可以通过this互相调用

class {
    static run() {
        return this.sing()
    }

    static sing() {
        return 'sing'
    }
}

static 静态函数 同样也是不能通过this 去调用 也是通过类名去调用

interface 定义 类

interface Person {
    get(type: boolean): boolean
}

interface Person2 {
    set(): void
    name: string
}

class A {
    age: number

    constructor() {
        this.age = 18
    }
}

class P extends A implements Person, Person2 {
    name: string

    constructor() {
        super()
        this.name= 'mk'
    }

    get(type: boolean) {
        return type
    }

    set() {}
}

interface 定义类 使用关键字 implements 后面跟interface的名字多个用逗号隔开 继承还是用extends

抽象类

abstract class A {
    public name: string
}

new A() // error 抽象类无法被实例化

我们定义的抽象方法必须在派生类实现

abstract class A {
    name: string

    constructor(name: string) {
        this.name = name
    }

    print(): string {
        return this.name
    }

    abstract getName(): string
}

class B extends A {
    constructor() {
        super('mk')
    }

    getName(): string {
        return this.name
    }
}

const b = new B()