基础类型
Never
never类型表示的是那些永不存在的值的类型。
例如
// 返回never的函数必须存在无法达到的终点
function error(message: string): never {
throw new Error(message);
}
接口 Interface
可索引类型
可索引类型具有一个 索引签名，它描述了对象索引的类型，还有相应的索引返回值类型。
interface NumberDictionary {
[index: string]: number;
length: number; // 可以，length是number类型
name: string // 错误，因为 [index: string] 包含了 name, 所以name的返回值必须跟[index: string]一致
}
类 Class
修饰符：public、private
class Person {
private age: number
public name: string
constructor(age: number, name: string) {
this.age = age
this.name = name
}
}
class Person1 {
private age: number
public name: string
constructor(age: number, name: string) {
this.age = age
this.name = name
}
}
let person = new Person(18, 'lwx')
let person1 = new Person(19, 'mjc')
let person2 = new Person1(20, 'wxy')
person.name // 正确，可以获取到`public`的属性
person.age // 错误，不可以获取`private`的属性
person = person1 // 正确，都从同一个Person类创建出来，公私有属性都一致
person = person2 // 错误，`private`属性只属于类本身，就算字面意义相同(这个例子中的`age`)，也是无法赋值的
修饰符：protected
protected修饰符与 private修饰符的行为很相似，但有一点不同， protected成员在派生类中仍然可以访问。
class Person {
protected name: string
constructor(name: string) {
this.name = name
}
}
class Employee extends Person {
constructor(name: string) {
super(name)
}
public getName(): string {
return `My name is ${this.name}`
}
}
const xiaoming = new Employee('xiaoming')
xiaoming.name // 报错
Person.name // 报错
xiaoming.getName() // My name is xiaoming
简而言之，不能直接通过类访问例如：Person.name，但是可以通过public一个方法，将protected的属性return出来。
修饰符：readonly
你可以使用 readonly关键字将属性设置为只读的。 只读属性必须在声明时或构造函数里被初始化。无法在别的地方重新设置属性。
class Person {
readonly name: string
constructor(name: string) {
// 初始化readonly属性
this.name = name
}
// 错误方法，私有属性无法被设置
setName(name: string) {
this.name = name
}
}
修饰符：static静态属性
静态类型属性只存在于类本身上面而不是类的实例上。只能通过类名去使用，可以被继承。
class Person {
static parent: string = 'lm'
name: string = ''
constructor(name: string) {
this.name = name
}
getName(): string {
return `${Person.parent} is ${this.name}'s parent.`
}
}
修饰符：abstract抽象类关键字
抽象类中的抽象方法不包含具体实现并且必须在派生类中实现。 抽象方法的语法与接口方法相似。 两者都是定义方法签名但不包含方法体。 然而，抽象方法必须包含 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(); // 错误: 方法在声明的抽象类中不存在
