【TS】类的定义、继承、访问类型、constractor、getter、setter

类的定义与实例化

// index.ts     ts-node index.ts
// 定义类
class Person {
    name = 'lily';
    getName () {
        return this.name
    }
}
// 创建类的实例
const person = new Person()
console.log(person.getName()) //lily

类的继承

class Teacher extends Person {
    getTeacherName () {
        return 'Juny'
    },
    getTeacher (){
        // return super.getName() + 'Wang' // lily Wang
        return 'John' 
    }
}

const teacher = new Teacher()
// console.log(teacher.getName()) // 'lily'
console.log(teacher.getTeacherName()) // 'Junny'
console.log(teacher.getName()) // 'John' 子类覆盖父类方法

类的访问类型

1. private        允许在类内被使用，一般用在需要被保护属性的场景下
2. protected    允许在类内及继承的子类内使用
3. public         默认为public 允许在类的内外被调用

class Person {
    protedcted name: string;
    private age: number;
    public sayHi() {
        return 'Hi'
    };
}

class Teacher extends Person {
    public sayBy() {
        this.age // 不可用
        this.name // 可用
    }
}

const person = new Person()
person.age = 18 // 不允许在类外被调用

constructor 构造器

constructor 函数在类被实例化的一瞬间自动被执行。

class Person {
    // 传统写法
    public name: string;
    constractor(name: string){ // 在类被实例化时自动执行
        this.name = name;
    }
    // 简化写法
    constructor(public name: string) {}
}
const person = new Person('Lily')

如父类有constructor，子类也有constructor，则需要在子类的constructor 内部用 super 调用父类构造器。

class Person {
    constractor (public name: string) {}
}
class Teacher extends Person {
    constractor (public age: number) {
        // super() 如果没有参数传递则调用空的super
        super('Lily')
          
    }
}

const teacher = new Teacher(18)

Getter Setter

当无法直接调用私有属性时，可以通过添加getter为实例提供访问进而间接访问类的私有属性，注意getter的调用与方法不同，不需要().

class Person {
    constractor (private _name: string) {}
    get name () {
        return this._name + ' Wang'
    }
    set name (name: string) {
        return this._name = name
    }
}

const person = new Person('Lily')
person.name
person.name = 'Lily Wang'

单例模式Demo

// 该类只能生成一个实例
class Demo {
    private static instance: Demo;
    private constructor (public name: string) {
        
    }
    // static 把该方法直接挂载在类而非类的实例上
    static getInstance () {
        if(!this.instance) {
            this.instance = new Demo('Lily')
        }
        return this.instance
    }
}

const demo = Demo.getInstance()

readonly 修饰器，限定属性只可读不可写 

class Person {
    public readonly name: string;
    constractor (name : string) {
        this.name = name
    }
}

const person = new Person ('Lily')
console.log(person.name) // Lily

抽象类

把可以共用的属性或方法抽离出来，生成一个抽象类，该抽象类可包含抽象方法或具体的方法和属性。抽象类只能被继承，不能被实例化。如抽象类内有抽象方法，继承的子类里必须有该抽象方法的具体实现。

abstract class Geom {
    width: number;
    radio: number;
    getType () {
        return 'Geom'
    }
    // 抽象方法，无具体实现
    abstract getArea(): number
}

class Circle extends Geom {
    getArea () {
        return 1
    }
}
class Square extends Geom {
    getArea () {
        return 2
    }
}