TypeScript 类

继承

class Animal {
    name:string;
    constructor(theName: string) { this.name = theName; }
    move(distanceInMeters: number = 0) {
        console.log(`${this.name} moved ${distanceInMeters}m.`);
    }
}

class Snake extends Animal {
    constructor(name: string) { super(name); }
    move(distanceInMeters = 5) { //重写父类的方法
        console.log("Slithering...");
        super.move(distanceInMeters); // 调用父类方法
    }
}

class Horse extends Animal {
    constructor(name: string) { super(name); }
    move(distanceInMeters = 45) {
        console.log("Galloping...");
        super.move(distanceInMeters); 
    }
}

let sam = new Snake("Sammy the Python");
let tom: Animal = new Horse("Tommy the Palomino");

sam.move();
tom.move(34);
// Slithering...
// Sammy the Python moved 5m.
// Galloping...
// Tommy the Palomino moved 34m.

公共，私有与受保护的修饰符

public :公有          在当前类里面、 子类  、类外面都可以访问

protected：保护类型    在当前类里面、子类里面可以访问 ，在类外部没法访问

private ：私有       在当前类里面可以访问，子类、类外部都没法访问

属性如果不加修饰符 默认就是 公有 （public）

public

class Person {
    public name: string;  /*公有属性*/
    constructor(name: string) {
        this.name = name;
    }
    run(): string {
        return `${this.name}在运动`
    }
}
// var p=new Person('王五');
// console.log(p.run())

class Web extends Person {
    constructor(name: string) {
        super(name);  /*初始化父类的构造函数*/
    }
    run(): string {
        return `${this.name}在运动-子类`
    }
    work() {
        console.log(`${this.name}在工作`)
    }
}

var w = new Web('李四');
w.work();


// 类外部访问公有属性
 var  p=new Person('哈哈哈');
 console.log(p.name);

protected

保护类型 在当前类里面、子类里面可以访问 ，在类外部没法访问

class Person {
    protected name: string;  /*保护类型*/
    constructor(name: string) {
        this.name = name;
    }
    run(): string {
        return `${this.name}在运动`
    }
}
var p = new Person('哈哈哈');
console.log(p.name);
//Property 'name' is protected and only accessible within class 'Person' and its subclasses.

private

私有 在类里面可以访问，子类、类外部都没法访问

class Person{
    private name:string;  /*私有*/
    constructor(name:string){
        this.name=name;
    }
    run():string{
        return `${this.name}在运动`
    }
}


class Web extends Person{
    constructor(name:string){
        super(name)
    }
    work(){
        // Property 'name' is private and only accessible within class 'Person'.
        //属性“name”为私有属性，只能在类“Person”中访问。
        console.log(`${this.name}在工作`)
    }
}

var p=new Person('哈哈哈');
//属性“name”为私有属性，只能在类“Person”中访问。
console.log(p.name);
//可以通过其他公共方法 隐式调用
console.log(p.run());

静态属性 静态方法

class Per{
    public name:string;
    public age:number=20;
    static sex="男";//静态属性
    constructor(name:string) {
            this.name=name;
    }
    run(){  /*实例方法*/
        console.log(`${this.name}在运动`)
        // this.sex //不能使用this 调用静态属性和方法
    }
    work(){
        console.log(`${this.name}在工作`)
    }
    static print(){  /*静态方法  里面没法直接调用类里面的属性*/
        console.log('print方法'+Per.sex);
    }
    static run(){  /*静态方法  里面没法直接调用类里面的方法*/
        console.log('print方法'+Per.print());
    }
}

// var p=new Per('张三');
// p.run();

// Per.print();
console.log(Per.sex);
console.log(Per.run());

抽象类

抽象类中的抽象方法不包含具体实现并且必须在派生类中实现。 抽象方法的语法与接口方法相似。 两者都是定义方法签名但不包含方法体。 然而，抽象方法必须包含 abstract关键字并且可以包含访问修饰符。

abstract class Department {
    constructor(public name: string) {
    }
    printName(): void {
        console.log('Department name: ' + this.name);
    }
    abstract printMeeting(): void; // 必须在派生类中实现
}

class AccountingDepartment extends Department {
    constructor() {
        super('Accounting and Auditing'); // 派生类中的构造函数必须调用super（）
    }
    printMeeting(): void {
        console.log('The Accounting Department meets each Monday at 10am.');
    }
    generateReports(): void {
        console.log('Generating accounting reports...');
    }
}

let department: Department; 
department = new Department(); // 无法创建抽象类的实例。
department = new AccountingDepartment(); 
department.printName();
department.printMeeting();
department.generateReports(); // 类型“Department”上不存在属性“generateReports”。