TS-类

类的定义

一 定义类的 方法 和 属性

class Person {
    name: string; // 属性
    constructor(name: string) { // 构造函数  实例化时 触发的方法
        this.name = name;
    }
    run(): void { // 方法
        console.log(`${this.name}在跑步`);
    }
}
let p = new Person('张三');
p.run(); // 张三在跑步

二 定义 set 和 get 方法

// 类的定义
class Person {
    name: string;
    constructor(name: string) { // 构造函数  实例化时 触发的方法
        this.name = name;
    }
    run(): void {
        console.log(`${this.name}在跑步`);
    }
    setName(name: string): void {
        this.name = name;
    }
    getName(): string {
        return this.name;
    }

}
let p = new Person('张三');
p.run(); // 张三在跑步
console.log(p.getName()); // 张三
p.setName('李四');
console.log(p.getName()); // 李四

继承

一 通过 extends 和 super

// 继承 extends super 
class Girl extends Person { // 继承父类
    constructor(name: string) {
        super(name); // 初始化父类的构造函数
    }
}
let g = new Girl('丽丽');
g.run(); // 丽丽在跑步
g.setName('花花');
g.run(); // 花花在跑步

二 子类可以自定义 方法 和 属性

class Girl extends Person { // 继承父类
    constructor(name: string) {
        super(name); // 初始化父类的构造函数
    }
    eat(foodName: string): void {
        console.log(`${this.name}爱吃${foodName}`);
    }
}
let g = new Girl('丽丽');
g.run(); // 丽丽在跑步
g.setName('花花');
g.run(); // 花花在跑步
g.eat('苹果'); // 花花爱吃苹果

三 若子类中存在与父类同名的方法，则直接调用子类的方法

class Boy extends Person { // 继承父类
    constructor(name: string) {
        super(name); // 初始化父类的构造函数
    }
    run(): void { // 若与父类方法重名，则调用子类的方法
        console.log(`${this.name}在跑马拉松`);
    }
}
let b = new Boy('乐乐');
b.run(); // 乐乐在跑马拉松
b.setName('高高');
b.run(); // 高高在跑马拉松

类里面的修饰符

• public 公有的； 在类里面、子类、类外面都可以访问
• protected 保护类型；在类里面、子类里面可以访问，在类外面没法访问
• private 私有的；在类里面可以访问，子类、类外面都没法访问

注：若不加任何修饰符，默认 public

class Animal {
    public name: string; // 公有属性 类里面和子类和类外面都可以使用
    protected objName: string; // 保护属性  只能在类里面和子类中使用。类外面不可以使用
    private age: number; // 私有属性  只能在该类中使用。子类和类外面均不可以
    constructor(name: string, objName: string, age: number) {
        this.name = name;
        this.objName = objName;
        this.age = age;
    }
    public getName(): void { // 公有方法
        console.log(`我叫${this.name}`);
    }
    public getInfo() { // 公有方法
        console.log(`我叫${this.name},我`+this.getAge()+'岁了');
    }
    protected getObjName(): void { // 保护方法
        console.log(`对象是${this.objName}`);
    }
    private getAge(): number { // 私有方法 只能在该类中使用，不能在子类以及类外部访问
        return this.age;
    }
}
let a = new Animal('咪咪', '雅雅', 12);
a.getName(); // 我叫咪咪
a.getInfo(); // 我叫咪咪,我12岁了
// a.getAge(); // error

• 子类 只能调用父类中的 public protected

class Dog extends Animal {
    constructor(name: string, objName: string, age: number) {
        super(name, objName, age);
    }
    getObjName(): void {
        console.log(`${this.name}对象是${this.objName}`);
    }
}
let d = new Dog('来福', '咪咪', 2);
d.getName(); // 我叫来福
d.getInfo(); // 我叫来福,我2岁了
d.getObjName(); // 来福对象是咪咪
// d.getAge(); // error

静态属性 和 静态方法

注：静态方法只能访问静态属性、静态方法，不能访问非静态的属性或方法。

class Fruits {
    public name: string;
    public static sex: string = '男孩';
    constructor(name: string) {
        this.name = name;
    }
    grow(): void { // 实例方法
        console.log(`${this.name}在慢慢长大`);
    }
    // 静态方法不能调用 非静态属性
    static cky(): void { // 静态方法
        console.log(`${Fruits.sex}在哭`);
        // console.log(`${this.sex}在哭`);
    }
}
let f = new Fruits('苹果');
// 这是实例方法  通过new对象调用
f.grow(); // 苹果在慢慢长大
Fruits.cky(); // 男孩在哭

多态

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

class Bank {
    name: string;
    constructor(name: string) {
        this.name = name;
    }
    money(): void {
        // 让子类实现 是存钱还是取钱，让子类实现
        console.log('父类的open方法');
    }
}
class BeiJing extends Bank {
    constructor(name: string) {
        super(name);
    }
    money(): void { // 实现父类的方法，多态
        console.log(`${this.name}银行，取出30元`);
    }
}
class ShanDong extends Bank {
    constructor(name: string) {
        super(name);
    }
    money(): void { // 实现父类的方法，多态
        console.log(`${this.name}银行，存入100元`);
    }
}
let bj = new BeiJing('北京');
bj.money(); // 北京银行，取出30元
let sd = new ShanDong('山东');
sd.money(); // 山东银行，存入100元

抽象类 和 抽象方法

• 是提供其他类继承的基类，不能直接被实例化
• 使用 abstract 关键字定义抽象类和抽象方法
• 抽象类中的抽象方法不包含具体实现，并且必须在派生类中实现
• 抽象方法只能放在抽象类中，抽象类中可以放非抽象属性或方法
• 抽象类和抽象方法用来定义标准（Season 类中必须有 来临 coming 方法）
• 抽象类的子类 必须实现抽象类的方法

abstract class Season {
    public name: string;
    constructor(name: string){
        this.name = name;
    }
    abstract coming(): any;
    go(): void {
        console.log(`${this.name}走了`)
    }
}
// let s = new Season(); // error 无法创建抽象类的实例。


class Spring extends Season {

    constructor(name: string){ 
        super(name)
    }
    // 抽象类的子类 必须实现抽象类的方法
    coming() {
        console.log(`${this.name}来临了`)
    }

}
let spring = new Spring('春天');
spring.coming(); // 春天来临了
spring.go(); // 春天走了