typescript 中的class

class 用来创建对象。TS中的class与面向对象语言（java,c++）中的class就比较相似了。

内容：

• 基本使用
• 继承
• 访问修饰符
• 静态属性
• 抽象类

基本使用

class Person {

name:string
constructor(name:string){
  this.name = name
}
say(){
  console.info(this.name)
}
}
let p1 = new Person("jake")
p1.say()

constructor()是构造方法，它用来初始化对象的属性。

继承

两个关键字：extends，super

class Person {
  name:string
  constructor(name:string){
    this.name = name
  }
  say(){
    console.info(this.name)
  }
}
class Student extends Person {
    className:string
    constructor(name: string, className: string) {
        super(name);
        this.className = className

    }
    say() {
        console.info(this.className + this.name)
    }
}

let s1 = new Student("jake", "class 3")
s1.say()

在constructor内部，先使用super（），之后才能使用this。

访问修饰符

对象有三个访问修饰符：public,private,protected

序号	类的内部	类的对象	子类内部	子类对象
public	可以	可以	可以	可以
private	可以	不可	不可	不可
protected	可以	不可	可以	不可

类内部是指通过this.XXX的方式访问
类对象是通过 对象.XXX的方式访问

以上规则与面向对象语言中规定的相识

readonly修饰符

你可以使用 readonly关键字将属性设置为只读的。 只读属性必须在声明时或构造函数里被初始化。

class Person {

public  readonly name:string
constructor(name:string){
  this.name = name
}
say(){
  console.info(this.name)
}
}

静态属性

static 修饰。 只能通过类名去访问。

class Person {

public  name:string
constructor(name:string){
  this.name = name
}
say(){
  console.info(this.name)
}
}

class Student extends Person {
    static num: number = 0;
    className:string
    constructor(name: string, className: string) {
        super(name);
        this.className = className
        Student.num++

    }
    say() {
        console.info(this.className + this.name+Student.num)
    }
}

let s1 = new Student("jake1", "class 3")
s1.say()
let s2 = new Student("jake2", "class 3")
s2.say()

抽象类

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

abstract class Animal {
    abstract makeSound(): void;
    move(): void {
        console.log('roaming the earch...');
    }
}

抽象类中的抽象方法不包含具体实现并且必须在派生类中实现。 抽象方法的语法与接口方法相似。 两者都是定义方法签名但不包含方法体。 然而，抽象方法必须包含 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(); // 错误: 方法在声明的抽象类中不存在