本系列文章只为记忆使用，非一步一步学习资料。

1.下面就是一个基本类的形式。定义了属性greeting，定义方法greet()

class Greeter {
    greeting: string;
    constructor(message: string) {//构造方法
        this.greeting = message;//使用了this
    }
    greet() {//一般方法
        return "Hello, " + this.greeting;
    }
}

let greeter = new Greeter("world");

2.继承，和C#等语言差不多

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 {//关键字extends是继承
    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);

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

class Octopus {
    readonly name: string;
    readonly numberOfLegs: number = 8;//定义时初始化
    constructor (theName: string) {
        this.name = theName;//构造方法中初始化
    }
}
let dad = new Octopus("Man with the 8 strong legs");
dad.name = "Man with the 3-piece suit"; // error! name is readonly.

4.参数属性可以方便地让我们在一个地方定义并初始化一个成员。
这个和别的语言时候区别的，在构造方法中，在定义参数的时候，加上private,protected,public等访问限制符号就可以定义一个属性，这个的确是比较方便的。显得有点懒了:)，不过的确好

class Animal {
    constructor(private name: string) { }//构造方法中使用了访问修饰符，就相当于定义了一个属性了,调用构造方法，就给name赋值了
    move(distanceInMeters: number) {//在一般方法中，不能使用访问修饰符来添加属性的
        console.log(`${this.name} moved ${distanceInMeters}m.`);
    }
}

let a=new Animal("test");//这样就给name赋值了
console.log(a.name);//可以打印出test了

5.存取器，get，set这个是比较方便的检查数据的方式，优美的语法糖(注意格式，和c#还是有差距的，这样写感觉不是很优美呀)(编译的时候，需要使用：tsc --target es5 greeter.ts,只有高版本的javascript才支持这样的特性)

let passcode = "secret passcode";

class Employee {
    private _fullName: string;

    get fullName(): string {//格式，其实是个方法
        return this._fullName;
    }

    set fullName(newName: string) {
        if (passcode && passcode == "secret passcode") {
            this._fullName = newName;
        }
        else {
            console.log("Error: Unauthorized update of employee!");
        }
    }
}

let employee = new Employee();
employee.fullName = "Bob Smith";
if (employee.fullName) {
    alert(employee.fullName);
}

6.静态属性(与C#的静态属性一样)

class Grid {
    static origin = {x: 0, y: 0};//申明静态属性
    calculateDistanceFromOrigin(point: {x: number; y: number;}) {
        let xDist = (point.x - Grid.origin.x);//引用静态属性，记得使用类名
        let yDist = (point.y - Grid.origin.y);
        return Math.sqrt(xDist * xDist + yDist * yDist) / this.scale;
    }
    constructor (public scale: number) { }
}

console.log(Grid.origin);//直接可以使用类名和静态属性计算了

let grid1 = new Grid(1.0); 
let grid2 = new Grid(1.0);  

console.log(grid1.calculateDistanceFromOrigin({x: 10, y: 10}));

Grid.origin.x=2;
Grid.origin.y=2;
console.log(grid2.calculateDistanceFromOrigin({x: 10, y: 10}));

console.log(Grid.origin);

7.抽象类
抽象类做为其它派生类的基类使用。 它们一般不会直接被实例化。 不同于接口，抽象类可以包含成员的实现细节。 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'); // constructors in derived classes must call super()
    }

    printMeeting(): void {
        console.log('The Accounting Department meets each Monday at 10am.');
    }

    generateReports(): void {
        console.log('Generating accounting reports...');
    }
}

let department: Department; // ok to create a reference to an abstract type(注意，他是抽象类的对象)
department = new Department(); // error: cannot create an instance of an abstract class（抽象类不能实例化）
department = new AccountingDepartment(); // ok to create and assign a non-abstract subclass
//（这个非抽象类可以实例化，它是抽象类的子类）
department.printName();
department.printMeeting();
department.generateReports(); // error: method doesn't exist on declared abstract type
//抽象类的引用对象，只能调用抽象类的存在的方法，而不能调用子类的方法

8.类具有 实例部分与静态部分这两个部分。

class Greeter {
    static standardGreeting = "Hello, there";
    greeting: string;
    greet() {
        if (this.greeting) {
            return "Hello, " + this.greeting;
        }
        else {
            return Greeter.standardGreeting;
        }
    }
}

let greeter1: Greeter;
greeter1 = new Greeter();
console.log(greeter1.greet());

let greeterMaker: typeof Greeter = Greeter;
greeterMaker.standardGreeting = "Hey there!";

let greeter2: Greeter = new greeterMaker();
console.log(greeter2.greet());

let greeterMaker: typeof Greeter = Greeter;这个变量保存了这个类或者说保存了类构造函数。 然后我们使用 typeof Greeter，意思是取Greeter类的类型，而不是实例的类型。 或者更确切的说，"告诉我 Greeter标识符的类型"，也就是构造函数的类型。 这个类型包含了类的所有静态成员和构造函数。
注意这句：let greeter2: Greeter = new greeterMaker();说明它是包含了构造函数了的，可以用它来实例化。但是greeterMaker变量不是类型，let greeter2:greeterMaker = new greeterMaker();这样使用时错误的。