TS中的类(class)

ts中的类和js中类基本相同，但还是有所差别，所以还是需要单独去写一下
ts类的一个简单例子

class Person {
    name: string
    age: number
    constructor(name: string, age: number) {
        this.name = name;
        this.age = age;
    }
    say() {
        console.log(`年龄为${this.age}的${this.name}say`)
    }
}
let person: Person = new Person('张三', 18);
person.say()

可以看到用法基本相同，除了ts类型检查外，在ts的class中，变量需要提前在constructor前声明

extends继承 set get关键字 static静态属性 和es6类基本相同，

ts中class特有的属性

 名词解释：
派生类：子类
基类：父类

修饰符

1. 默认公共 public 自由访问程序里定义的变量和方法
2. 私有的 private 当成员被标记为私有属性，只能在类进行使用，不能外部使用,子类也不可访问
3. 受保护的 protected 和private相似，唯一不同的是，被protected修饰的属性可以在子类中访问

//私有 private
class PrivateClass {
    private name: string
    constructor(name: string) {
        this.name = name;
    }
}

let privateState: PrivateClass = new PrivateClass('私有变量')
//privateState.name = '111' //error 属性“name”为私有属性，只能在类“PrivateClass”中访问

//受保护的 protected  
class ParentClass {
    protected name: string
    private age: number
    constructor(name: string, age: number) {
        this.name = name
        this.age = age
    }
}
class ChildClass extends ParentClass {
    constructor(name: string, age: number) {
        super(name, age)
        console.log(this.name);
        // console.log(this.age);//error 因为是私有属性，子类不能访问 属性“age”为私有属性，只能在类“ParentClass”中访问

    }
}
let childClass: ChildClass = new ChildClass('张三', 18)
//childClass.name='asas' //error 属性“name”受保护，只能在类“ParentClass”及其子类中访问

readOnly 只读

只读属性必须在声明或构造函数时被初始化

class ReadOnlyPerson {
    readonly name: string
    readonly age: number = 18 //将声明和赋值放在一起
    constructor(name: string) {
        this.name = name;
    }
}
let readOnlyState: ReadOnlyPerson = new ReadOnlyPerson('readOnly');
console.log(readOnlyState.name); //可以对只读属性进行访问
//ReadOnlyPerson.name = '我要修改readOnly的名称'//error 无法分配到 "name" ，因为它是只读属性

抽象类

抽象类作为其他派生类的基类使用，一般不会被实例化。与接口不同的是抽象类中可以包括具体实现细节；
abstract关键字用于定义抽象类以及在抽象类内部定义抽象方法

//普通抽象类
abstract class AbstractClass {
    name: string
    constructor(name: string) {
        this.name = name
    }
    say(name: string): string {
        return `${name}say:hello,world`
    }
}
//抽象类中的抽象属性
abstract class AbstractStateClass {
    abstract name: string;
    // constructor(name:string) {
    //     this.name = name //error 不能在构造函数中访问类“AbstractClass”中的抽象属性“name”
    // }
    say(): string {
        return this.name + 'say:Hello,world'
    }
}
//抽象类中的抽象方法
//抽象类中的抽象方法在派生类中必须实现
abstract class AbstractFunClass {
    name: string
    constructor(name: string) {
        this.name = name
    }
    abstract say(name: string): string
}
class AbstractPerson extends AbstractFunClass {
    constructor(name: string) {
        super(name)
    }
    say(name: string): string {
        return name + 'say:hello,world'
    }
}

接口继承类

可以把类当成接口使用，因为类可以创建出类型

class InterfaceClass {
    name: string;
    age: number
}
interface ExtendsClassInterface extends InterfaceClass { //接口继承类
    sex: boolean
}
let specialPerson: ExtendsClassInterface = {
    name: '张三',
    age: 18,
    sex: false
}