typescript 学习系列-类

传统的JavaScript程序使用函数和基于原型的继承来创建可重用的组件，但对于熟悉使用面向对象方式的程序员来讲就有些棘手，因为他们用的是基于类的继承并且对象是由类构建出来的

class Infos { // 类其实是方法和属性的集合，相当于模板，有人要用可以重复使用这个模板
	name: string; // 属性
	constructor(firstName: string) { // 构造函数用于new 对象
		this.name = firstName;
	}
	work(): void { // 方法
		console.log(`His name is ${this.name}`)
	}
}
// 实例化类
let somebody = new Infos('Alice')
somebody.work()

继承 extends 关键字

继承可以最大化的实现组件之间的数据复用，减少重复

class Animal {
	name: string;
	constructor(theName: string) {
		this.name = theName;
	}
	eat(): void {
		console.log(`${this.name} is running`)
	}
}
class Dog extends Animal {
	constructor(name: string) {
		super(name) // 在子类中要访问父类的(属性)构造函数必须调用super()方法
	}
	bark(): void {
		console.log(`the dog is barking`)
	}
}
let d = new Dog('哈士奇')
d.bark();
d.eat();

修饰符

public (默认为public) 在类中和外部都可以访问
private 只能在类中使用不能在子类或是外部访问
protected 可以在类中或是子类中访问，不能在外部访问
readonly 只读属性 只读属性必须在声明时或构造函数里被初始化

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

存取器

class Preson {
	name: string;
	getName(): string {
		return name;
	}
	setName(theName: string): void {
		this.name = theName;
	}
}

let p = new Person("Tony")
person.getName()
person.setName('Bob Smith')

静态属性

实例成员：那些仅当类被实例化的时候才会被初始化的属性。
类的静态成员：这些属性存在于类本身上面而不是类的实例上

class Person {
	static car: string = 'baoma'
	name: string;
	constructor(theName: string) {
		this.name = theName
	}
}
let p = new Person("zhangsan")
p.name;
// 要访问类的静态属性：类名.属性名
Person.car;

抽象类

抽象类做为其它派生类的基类使用。 它们一般不会直接被实例化。 不同于接口，抽象类可以包含成员的实现细节。
abstract关键字是用于定义抽象类和在抽象类内部定义抽象方法。

abstract class Animal {
    abstract makeSounds(): void; // 抽象方法只是方法签名没有方法体
    move(): void {
        console.log('roaming the earch...');
    }
}

抽象类中的抽象方法不包含具体实现并且必须在派生类中实现。 抽象方法的语法与接口方法相似。 两者都是定义方法签名但不包含方法体

abstract class Company {
    constructor(public name: string) {
    }
    printDepartments(): void {
        console.log('Department name: ' + this.name);
    }
    abstract printMeeting(): void; // 必须在派生类中实现
}
class HRDepartment 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 Company(); // 错误: 不能创建一个抽象类的实例
department = new HRDepartment(); // 允许对一个抽象类的子类进行实例化和赋值
department.printDepartments();
department.printMeeting();
department.generateReports(); // 错误: 方法在声明的抽象类中不存在