classe TypeScript

definição de classe

As classes contêm propriedades, construtores e métodos

class Person {
    name: string
    constructor(name:string) {
        this.name = name
    }
    say(content: string){
        console.log(content)
    }
}
const p = new Person('东方不败')
p.say('hello')

herdar

1. Use extendspara estender a classe, você pode herdar as propriedades e métodos da classe pai
2. Antes de acessar esta propriedade no construtor, devemos chamar super()
3. Reescrever o método herdado da classe pai

class Animal {
    name:string
    constructor(name: string) {
        this.name = name
    }
    move(len: number = 0){
        console.log(`${this.name}移动了${len}米`)
    }
}
class Dog extends Animal {
    constructor(name: string) {
        super(name)
    }
    move(len?: number): void {
        console.log('Dog-----')
        // super.move()
        console.log(`${this.name}移动了${len}米`)
    }
}
class Cat extends Animal {
    constructor(name: string) {
        super(name)
    }
    move(len?: number): void {
        console.log('Cat-----')
        super.move(len)
    }
}
const dog = new Dog('二哈')
const cat = new Cat('汤姆')
dog.move(500)
cat.move(200)

modificador

public: Os modificadores padrão no TypeScript são public
privados: quando um membro é marcado como privado, ele não pode ser acessado fora da classe em que foi declarado.
Protected: O comportamento do modificador privado é muito semelhante, mas há uma diferença, membros protegidos ainda podem ser acessados ​​em classes derivadas
readonly: defina a propriedade como somente leitura. Propriedades somente leitura devem ser inicializadas no momento da declaração ou no construtor
Sintaxe: coloque na frente do nome da propriedade

class Animal {
    private name:string
    constructor(name: string) {
        this.name = name
    }
    move(len: number = 0){
        console.log(`${this.name}移动了${len}米`)
    }
}

Propriedades do parâmetro

Use modificadores no construtor para criar e inicializar o nome do membro, a declaração e a atribuição são combinadas e outros modificadores (private, public, protected) também são aplicáveis

class Person {
    readonly id: number = 1;
    constructor(readonly name: string) {
    }
}
const p = new Person('dong')
console.log(p.name)

acessor

O TypeScript oferece suporte à interceptação de acesso a membros de objeto por meio de getters/setters.

class Person {
    firstName: string = 'A'
    lastName: string = 'B'
    get fullName() {
        return this.firstName + '_' + this.lastName
    }
    set fullName(name: string) {
        let arr = name.split('_')
        this.firstName = arr[0]
        this.lastName = arr[1]
    }
}
let p = new Person()
console.log(p.fullName) // get A_B
p.fullName = '东方_不败' // set 
console.log(p.fullName) // 东方_不败

Atributo estático estático

Membros de instância de uma classe: atributos que são inicializados quando a classe é instanciada e podem ser acessados ​​por
objetos de instância de classe para acessar

class Person {
    firstName: string = 'A'
    lastName: string = 'B'
    static address: Array<string> = ['北京', '朝阳']
}
let p = new Person()
console.log(Person.address)
console.log(p.address) // 报错

classe abstrata

1. Geralmente, ela não será instanciada e usada como a classe pai de outras classes.
2. A palavra-chave abstract é modificada.
3. Ao contrário das interfaces, as classes abstratas podem conter métodos implementados ou métodos abstratos não implementados.
4. Classes abstratas O método abstrato in deve ser implementado na subclasse, o método abstrato é semelhante à interface, possui apenas a assinatura do método, sem corpo do método; mas o método abstrato deve ser modificado com abstract

abstract class Animal {
    name: string 
    abstract move(len: number):void
    eat(food: string):void {
        console.log(`${this.name}吃${food}`)
    }
    constructor(name: string) {
        this.name = name
    }
}
class Dog extends Animal {
    move(len: number): void {
        console.log(`${this.name}移动了${len}米`)
    }
}

// let animal = new Animal('动物') // 报错：无法创建抽象类的实例对象
let dog = new Dog('二哈')
dog.eat('大骨头')
dog.move(500)