TypeScript中的类

01_类的基本使用

//类的基本使用
class Person{
    //字段（属性）
    name: string
    age:number
    //构造函数
    constructor(name:string,age:number){
        this.name=name
        this.age=age
    }
    //函数方法
    sayHellow():void{
        console.log(`我的名字叫${this.name},我今年${this.age}岁了，并且我是电焊宝贝`);
    }
}
let p=new Person("亚鑫",20)
p.sayHellow()

02_类的继承

export default{}

//类的基本使用
class Person{
    //字段（属性）
    name: string
    age:number
    //构造函数
    constructor(name:string,age:number){
        this.name=name
        this.age=age
    }
    //函数方法
    sayHellow():void{
        console.log(`我的名字叫${this.name},我今年${this.age}岁了，并且我是电焊宝贝`);
    }
}
let p=new Person("亚鑫",20)
p.sayHellow()

class Student extends Person{
    woker:string
    constructor(name:string,age:number,woker:string){
        //调用父类中的构造函数
        super(name,age)
        this.woker=woker
    }
    sayHellow(): void {
        //调用父类方法
        // super.sayHellow()
        //重写父类中的方法
        console.log(`我是继承的,我现在的名字是${this.name},我的年龄是${this.age}，我是${this.woker}`);
    }
}
let s=new Student("李彬",48,"电焊大王")
s.sayHellow()

03_static和instanceof

static 关键字用于定语类的数据成员（属性和方法）

class StaticTest{
    static salary:number
    static say():void{
        console.log(`我们想要的工资是${StaticTest.salary}k`);
    }
}
StaticTest.salary=12;
StaticTest.say();

instanceof运算符

instanceof 运算符用于判断对象是否指定的类型，如果是返回true，不是则返回flase

class Person{}
let p=new Person();
let isPerson=p instanceof Person;
console.log("p是Person实例化出来的吗？",isPerson);

class Student extends Person{}

let s=new Student();
let isStudent=s instanceof Person;
console.log("s是Person实例化出来的吗？",isPerson);

04_类中的修饰符

public(默认)：公有，可以在任何地方被访问

protected：受保护，可以被其自身以及其子类访问

private：私有，只能被其定义所在的类访问

readonly可以使用readonly关键字将属性设置为只读的。只读属性必须在声明时或构造函数里被初始化。

export default{}
//public(默认)：公有，可以在任何地方被访问
//protected：受保护，可以被其自身以及其子类访问
//private：私有，只能被其定义所在的类访问
//readonly可以使用readonly关键字将属性设置为只读的。只读属性必须在声明时或构造函数里被初始化。
class Person{
    public name:string
    protected age:number
    private sex:string

    constructor(name:string,age:number,sex:string){
        this.name=name
        this.age=age
        this.sex=sex
    }

    say():void{
        console.log(`我的名字是${this.name},年龄${this.age}，性别${this.sex}`);
        
    }
}
class Student extends Person{
    score:string
    constructor(name:string,age:number,sex:string,score:string){
        super(name,age,sex)
        this.score=score
    }
    say(): void {
        console.log(this.name);
        console.log(this.age);
        // console.log(this.sex);
        console.log(this.score);
        
    }
}
let s=new Student("亚鑫",18,"男","b")
s.say()

05_getter与setter

getter与setter

 * 别名：存取器

 * 通过getters/setters来截取对对象成员的访问

 * 注意点：

 * 如果存在get，但没有set，则该属性自动是只读的

 * 如果没有指定setter参数的类型，它将从getter的返回类型中推断出来

 * 访问器和设置器必须有相同的成员可见性

class GetNameClass{
    private _fullName:string="亚鑫"

    get fullName():string{
        console.log("我是get方法");
        return this._fullName
    }

    set fullName(newName:string){
        console.log("我是set方法");
        this._fullName=newName;
    }
}

let starname=new GetNameClass()
starname.fullName="袁世凯"

console.log(starname);
console.log(starname.fullName);

06_抽象类

抽象类

 * 定义

 * 抽象类作为其他派生类的基类使用。它们一般不回直接被实例化

 * 抽象类是专门用于定义哪些不希望被外界直接创造的类的

 * 抽象类和接口一样用于约束子类

 * 抽象类和接口区别

 * 抽象方法必须包含abstract关键字并且可以包含访问修饰符

 * 接口中只能定义约束，不能定义具体实现。而抽象类中既可以定义约束，又可以定义具体实现

abstract class Person{
    abstract name:string
    abstract show():string

    showName(){
        console.log(this.show());
    }
}

class Student extends Person{
    name: string="亚鑫"
    show():string{
        return "利宾"
    }
}