typescript（四）--- class（类）

利用class关键字定义类

类的定义

 class Person {
    
    
     name:string;
     constructor(name:string) {
    
     // 构造函数，实例化类的时候触发
         this.name = name;
     }
     getName():string {
    
    
         return this.name;
     }
     setName(name:string):void {
    
    
         this.name = name;
     }
 }

 let P = new Person('小飞');
 P.getName() // 小飞
 p.setName('小刚');
 P.getName() // 小刚

类的继承 关键词（extends、super）

class Person {
    
    
    name: string;
    constructor(name: string) {
    
     // 构造函数，实例化类的时候触发
        this.name = name;
    }
    getName(): string {
    
    
        return this.name;
    }
    setName(name: string): void {
    
    
        this.name = name;
    }
}


class Work extends Person {
    
    
    constructor(name:string) {
    
    
        super(name); // 初始化父类的构造函数
    }

    run():string {
    
    
        return this.name;
    }
}

let w = new Work('继承');
console.log(w.getName());

类的修饰符（public、protected、private ）；不加默认 public

public 公有属性 （在类、子类、类外面可以访问）

class Person {
    
    
    public name: string;
    constructor(name: string) {
    
     // 构造函数，实例化类的时候触发
        this.name = name;
    }
    getName(): string {
    
    
        return this.name;
    }
    setName(name: string): void {
    
    
        this.name = name;
    }
}

class Work extends Person {
    
    
    constructor(name:string) {
    
    
        super(name); // 初始化父类的构造函数
    }

    run():string {
    
    
        return this.name;
    }
}
let P = new Person('小闵');
console.log(P.name); // 小闵 

protected 保护类型（在类、子类里面可以访问）

class Person {
    
    
    protected name: string;
    constructor(name: string) {
    
     // 构造函数，实例化类的时候触发
        this.name = name;
    }
    getName(): string {
    
    
        return this.name;
    }
    setName(name: string): void {
    
    
        this.name = name;
    }
}

class Work extends Person {
    
    
    constructor(name:string) {
    
    
        super(name); // 初始化父类的构造函数
    }

    run():string {
    
    
        return this.name;
    }
}

let w = new Work('继承');
console.log(w.getName()); // ts 报错

private 私有类型（在类里面可以访问）

class Person {
    
    
    private name: string;
    constructor(name: string) {
    
     // 构造函数，实例化类的时候触发
        this.name = name;
    }
    getName(): string {
    
    
        return this.name;
    }
    setName(name: string): void {
    
    
        this.name = name;
    }
}

class Work extends Person {
    
    
    constructor(name:string) {
    
    
        super(name); // 初始化父类的构造函数
    }

    run():string {
    
    
        return this.name;
    }
}

let w = new Work('继承');
console.log(w.getName()); // ts 报错

类的静态方法 （关键词 static）

class Person {
    
    
    static age: number = 20;
    constructor(name: string) {
    
     // 构造函数，实例化类的时候触发

    }
    static get(): string {
    
    
        return `${
      
      Person.age} 是静态属性`
    }
}

console.log(Person.get()); // 20 是静态属性

多态 （父类定义一个方法不去实现，每个子类有不同的表现；也属于继承的一种表现）

class Car {
    
    
    name: string;
    money: number;
    constructor(name: string, money: number) {
    
    
        this.name = name || '宝马';
        this.money = money || 100;
    }

    getMoney(): number {
    
    
        return this.money;
    }
}

class Tire extends Car {
    
    
    constructor(money: number) {
    
    
        super(money)
    }

    price(): string {
    
    
        return `轮胎的价格是${
      
      this.money}`;
    }
}

class Shell extends Car {
    
    
    constructor(money: number) {
    
    
        super(money)
    }

    price():string {
    
    
        return `外壳的价格是${
      
      this.money}`
    }
}


let t = new Tire();
console.log(t.price()) // 轮胎的价格是100
let s = new Shell();
console.log(s.price()) //外壳的价格是100