超详细的typeScript笔记(二)类的基本使用

1 引入

2 使用

2.1 基本使用

• 三种定义方式

class Person{
    // 成员变量
    name:string
    age:number

    // 构造函数
    constructor(name:string,age:number){
        this.name=name
        this.age=age
    }
    // 成员方法
    say():void{
        console.log("我是"+this.name+",今年"+this.age);
    }
}
let person = new Person("张予曦",20) // 类型推断
let person1:any = new Person("张予曦",20) // 任意类型
let person2:Person = new Person("张予曦",20) // 类类型
console.log(person.name);
person.say()

2.2 封装使用

• 每个类中定义get set 方法

class Person{
    // 成员变量
    name:string
    age:number

    // 构造函数
    constructor(name:string,age:number){
        this.name=name
        this.age=age
    }
    // 封装
    getName():string{
        return this.name
    }
    setName(name:string):void{
        this.name=name
    }

    getAge():number{
        return this.age
    }
    setAge(age:number):void{
        this.age=age
    }
    // 成员方法
    say():void{
        console.log("我是"+this.getName()+",今年"+this.getAge());
    }
}
let person = new Person("张予曦",20) // 类型推断
let person1:any = new Person("张予曦",20) // 任意类型
let person2:Person = new Person("张予曦",20) // 类类型
console.log(person.name);
person.setName('崽崽')
person.say()

2.3 继承

2.3.1 基本继承(只继承父类)

• 必须存在super 方法

class Lay extends Person{
    constructor(name:string,age:number){
        super(name,age)
    }
}
let lay = new Lay("张艺兴",20)
lay.say()

2.3.2 继承并修改

• 增加成员变量

class Lay extends Person{
    constructor(name:string,age:number,job:string){
        super(name,age)
        this.job=job
    }
    getJob():string{
        return this.job
    }
    setJob(job:string):void{
        this.job=job
    }
}
let lay = new Lay("张艺兴",20,"歌手")
console.log(lay.getJob());

lay.say()

2.4 多态

• 类为抽象类 里面的方法若为抽象方法 子类必须重写 非抽象方法 直接可以继承

父类

abstract class Actor {
    constructor(name:string) {
        this.name=name
    }
    getName():string{
        return this.name
    }
    setName(name:string):void{
        this.names=name
    }
    say():void{
        console.log("非抽象方法,不能修改"+this.getName());
    }
    // 必须继承,并且重新
    abstract run():any
}

子类1

class Laker extends Actor{
    constructor(name){
        super(name)
    }
    run(){
        console.log(this.getName()+"继承");     
    }
}

let person0 = new Laker("张艺兴")
console.log(person0.getName());
person0.run()

子类2

class Lay extends Actor{
    constructor(name){
        super(name)
    }
    run(){
        console.log(this.getName()+'我的继承');
        
    }
}
let lay =new Lay("lay")
console.log(lay.getName());
lay.run()

2.5 修饰符

• public 公共类型 内部 子类 外部 都能访问
• protected 保护类型 内部 子类 可以访问 外部 不能访问
• private 私有类型 内部 可以访问 子类,外部 不能访问

abstract class Actor {
    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
    }
    getName():string{
        return this.name
    }
    setName(name:string):void{
        this.name=name
    }
    say():void{
        console.log("非抽象方法,不能修改"+this.getName());
    }
    // 必须继承,并且重新
    abstract run():any
}
let actor = new Actor("张艺兴1",18,"男")
// 内部访问
console.log(actor.name);
console.log(actor.age);
console.log(actor.sex);

class Lay extends Actor{
    constructor(name:string,age:number,sex:string){
        super(name,age,sex)
    }
}
// 子类访问
let lay = new Lay("崽崽",20,"女")
console.log(lay.name);
console.log(lay.age);
console.log(lay.sex);