TypeScript 类的使用 （三）

类的使用

类本身就可以充当类型，用来描述实例（类类型）
ts 中要求所有的属性，必须先声明再使用（修饰符声明）

class Circle {
    public x: number
    public y: number
    constructor(x:number,y:number) {
        this.x = x
        this.y = y || y
    }
}

constructor 是构造函数，用来构造实例

声明修饰符

• public 公开属性 （父、子、外界都能访问） 默认值
• protected 受保护（父、子）
• private 私有属性（父）
• readonly 仅读属性 只能初始化赋值，后续不能被修改

直接在constructor参数用public修饰符修饰，不用赋值，会自动赋值

class Animal {
    constructor(public name:string,private age:number,protected a:string, readonly b:string) {}
}

class Dog extends Animal {
    constructor(name:string, age:number, a:string) {
        super(name,age,a)
        this.name = name; // public
        this.age = age;// private
        this.a = a; // protected
        this.b = '123' // readonly只能初始化赋值
    }
}
animal.name = 'dog'  //public

注：private 使用 animal["age"] 这种方式可以访问私有属性可以，绕过ts检测 可以使用 #属性名 的方式定义私有属性 是将该定义属性放到了 weakmap 中管理

继承

使用extends关键字用来继承其它类
在 constructor 中使用 super()调用父类中的 constructor 方法

class Dog extends Animal {
    constructor(name:string, age:number, a:string, b:string) {
        super(name,age,a,b)
        this.name = name; // public
        this.age = age;// private
        this.a = a; // protected
        this.b = '123' // readonly只能初始化赋值
    }
}

• 属性访问器

就是在类中定义get 和 set 方法用来获取私有属性和属性赋值(Object.defineProperty)

• 原型属性

在类中可以定义自己的属性方法，并且可以通过子类重写父类方法

• 静态属性

用 static 修饰符修饰的方法或变量，可以在子类中获取

class Person {
    static name2:string ='smz' //静态属性
    static getName():string { //静态方法
        return this.name2 //this 指向类本身
    }

    private _age:string = '18'
    constructor(public name:string) {}
    get age():string { // 获取私有属性
        return this._age
    }
    set age(value:string) {// 给私有属性赋值
        this._age = value
    }
    movement(posture: string) { //定义属性方法
        console.log('movement',posture)
    }
}
class Student extends Person {
    constructor(name:string) {
        super(name)
    }
    movement(posture: string) { //子类重写父类方法
        super.movement('听课') // 该super指向实例
        return 'student movement ${posture}'
    }
}
const student = new Student('smz')
student.age = '20' //属性访问器 调用set
console.log(student.age) //属性访问器 调用get
student.movement('run') // 原型方法
console.log(Student.getName()) // 调用父类静态方法 this指向父类

定义一个唯一的类

使用 private 修饰 constructor 构造函数，让该类不能通过 new 实例化
在 单例模式时 使用，定义一个静态属性接收实例，通过一个静态方法暴露该实例，方法内部判断这个静态属性是否为空，
不为空则创建实例，有则直接返回，保证实例只存在一个

class Singleton {
    private static instance:Singleton
    private constructor() {}
    static getInstance():Singleton {
        if (!Singleton.instance) {
            Singleton.instance = new Singleton()
        }
        return Singleton.instance
    }
}
let singleton = Singleton.getInstance()
let singleton2 = Singleton.getInstance()
console.log(singleton === singleton2) // true

---

抽象类

用 abstract修饰符修饰类

特点：

• 不能被 new
• 抽象类中可以创建抽象属性和方法，但是不可以创建抽象静态属性和方法
• 抽象类中可以拥有具体实现

abstract class Animal2 {
    static habitat:string ='smz'
    abstract eat():void // 一般描述的是原型方法
    abstract play: () => void // 一般描述的是实例方法
    drink() { // 具体实现
        console.log('water')
    }
}
class Cat extends Animal2 {
    public play: () => void = () => {}
    eat() {
        console.log('eat')
    }
}
let dog = new Cat()
console.log(dog)

play 为实例方法，而 eat为原型方法:

函数重载

class ToArray {
    convert(value: number): number[] // 属性定义
    convert(value: string): string[] // 属性定义
    convert(value: string | number): string[] | number[] { // 方法实现
        if (typeof value === 'number') {
            return [value]
        } else if (typeof value ==='string') {
            return value.split('').map(Number)
        }
        return value
    }
}
let a = new ToArray()
a.convert(123)
a.convert('smz')
a.convert(true)	

当传入没有重载的值时，会提示没有重载匹配这个调用，而之前伪重载只是对类型的判断