typeScript 类

类描述了所创建的对象共同的属性和方法。

类的定义

继承

类里面的修饰符

静态属性 静态方法

抽象类 继承 多态

类的定义
class person {
    name:string;  //属性，省略public
    constructor(n:string){
        this.name = n
    }
    run():void{
        console.log(this.name+"在跑步")
    }
}
var p = new person("fur");
console.log(p.name)//fur
p.run()//fur在跑步
继承

关键词：extends super

run方法说明：子类继承父类方法

study方法说明：子类重写父类方法

class person {
    name:string;  //属性，省略public
    constructor(n:string){
        this.name = n
    }
    run():void{
        console.log(this.name+"在跑步")
    }
    study():void{
        console.log(this.name+"在学习")
    }
}
class man extends person{
    constructor(name:string){
        super(name) /*初始化父类的构造函数*/
    }
    study():void{
        console.log(this.name+"在学习-子类")
    }
}
var p = new person("fur");
console.log(p.name)//fur
p.run()//fur在跑步
var m = new man("furfur");

console.log(m.name)//furfur
m.run()//furfur在跑步(继承父类的run)
m.study()//furfur在学习-子类(重写父类study)

对比es5的继承有很大的改善，es5继承

类里面的修饰符

类里面的修饰符 typescript里面定义属性的时候给我们提供了 三种修饰符

  • public : 公有，在当前类里面、 子类 、类外面都可以访问
  • protected：保护类型，在当前类里面、子类里面可以访问 ，在类外部没法访问
  • private ：私有，在当前类里面可以访问，子类、类外部都没法访问

例子：

class person {
    private name:string;  
    constructor(n:string){
        this.name = n
    }
    protected run():void{
        console.log(this.name+"在跑步")//正确，private只能在类“person”中访问
    }
    public study():void{
        console.log(this.name+"在学习")
    }
    
}
class man extends person{
    constructor(name:string){
        super(name) /*初始化父类的构造函数*/   
    }
    protected run():void{
        super.run() // 正确，protected只能在类“person”及其子类中访问。
    }
}
var p = new person("fur");
// console.log(p.name)//报错：属性“name”为私有属性，只能在类“person”中访问。
// p.run()//报错：属性“run”受保护protected，只能在类“person”及其子类中访问。
p.study()//furfur在学习


var m = new man("furfur");
// console.log(m.name)//报错：属性“name”为私有属性，只能在类“person”中访问。
// m.run()//报错：属性“run”受保护protected，只能在类“man”及其子类中访问。
m.study()//furfur在学习
静态属性 静态方法

关键词：static

class person {
     name:string; 
     static age = 1
    constructor(n:string){
        this.name = n
    }
    // static run():void{
    //     console.log(this.name+"在跑步")//静态方法  里面没法直接调用类里面的非静态属性
    // }
    static getAge():void{
        console.log(this.age)
    }   
}
person.age=1
person.getAge()
多态

多态:父类定义一个方法不去实现，让继承它的子类去实现 每一个子类有不同的表现，多态属于继承

例子：person中的paly方法，子类man和woman有各自的具体方法

class person {
    name:string; 
    age = 1
    constructor(n:string){
        this.name = n
    }
    play():void{
        console.log("玩法")
    }
}
class man extends person{
    constructor(name:string){
        super(name)
    }
    play():void{
        console.log(`${this.name} lol`)
    }
}
class woman extends person{
    constructor(name:string){
        super(name)
    }
    play():void{
        console.log(`${this.name} shopping`)
    }
}
var m = new man("boy")
m.play()//boy lol
var w = new woman("girl")
w.play()//girlshopping
抽象类

typescript中的抽象类：抽象类和抽象方法用来定义标准 。它是提供其他类继承的基类，不能直接被实例化。

用abstract关键字定义抽象类和抽象方法，抽象类中的抽象方法不包含具体实现并且必须在派生类中实现。abstract抽象方法只能放在抽象类里面。

抽象类的子类必须实现抽象类里面的抽象方法，否则仍然要作为一个抽象类。

abstract class person {
    name:string; 
    age = 1
    constructor(n:string){
        this.name = n
    }
    abstract play():void;
}
class man extends person{
    constructor(name:string){
        super(name)
    }
    play():void{
        console.log(`${this.name} lol`)
    }
}
class woman extends person{
    constructor(name:string){
        super(name)
    }
    play():void{
        console.log(`${this.name} shopping`)
    }
}
var m = new man("boy")
m.play()//boy lol
var w = new woman("girl")
w.play()//girlshopping

typeScript系列学习文章目录