TypeScript类

类的定义

类中包含属性、构造函数和方法

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

继承

1、使用extends进行类的扩展，可以继承父类中的属性和方法
2、构造函数里访问 this的属性之前，我们 一定要调用 super()
3、重写了从父类继承来的方法

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)

修饰符

public：TypeScript中默认修饰符都是public
private ：当成员被标记成 private 时，它就不能在声明它的类的外部访问。
protected：与 private 修饰符的行为很相似，但有一点不同，protected成员在派生类中仍然可以访问
readonly：将属性设置为只读的。 只读属性必须在声明时或构造函数里被初始化
语法：放在属性名前面

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

参数属性

在构造函数中使用修饰符来创建和初始化成员name，声明和赋值合并到一起，其他修饰符（private、public、protected）同样适用

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

存取器

TypeScript 支持通过 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) // 东方_不败

静态属性 static

类的实例成员：当类被实例化的时候才会被初始化的属性，可被类实例对象访问
静态成员：使用 static定义，存在于类的本身，不存在类的实例对象上，所以只能通过类进行访问

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

抽象类

1、一般不会被实例化，作为其他类的父类使用
2、abstract关键字修饰
3、不同于接口，抽象类中可以包含已经实现的方法，也可以包含未实现的抽象方法
4、抽象类中的抽象方法必须在子类中实现，抽象方法和接口类似，都是只有方法签名，没有方法体；但抽象方法必须用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)