1.類的定義

class Person {
    name: String;//屬性不加修飾符時，預設是public的
    age: number;
    //構造方法 與java不同，不是使用類名，而是使用constructor
    constructor(name: String, age: number) {
        this.name = name;
        this.age = age;
    }
    //方法，不用加function關鍵字
    say() {
        return `Hello，my name is ${this.name},I'm ${this.age} years old`;
    }
}
var person = new Person("yzq", 23);
alert(person.say());
 

2.繼承

class Student extends Person{
    school:String;
    constructor(){
        super("yzq",23);//呼叫父類建構函式
        this.school="清華"
    }
    /*這個地方類似 重寫 */
    say(){
        return `姓名:${this.name},年齡${this.age},學校${this.school}`
    }
}

3.訪問修飾符

跟java類似，TypeScript的訪問修飾符有三個，分別是public、private、protected 。 

3）private宣告的方法和屬性只能在其類的內部訪問。

4.readonly修飾符

           使用readonly關鍵字會將屬性設定為只讀的。 只讀屬性必須在宣告時或建構函式裡被初始化。且值不能不能被修改，和const類似。 

class Person { 
    readonly name: string;
    readonly age: number=23;//必須初始化
    constructor(name:string) {
        this.name = name;//必須初始化
   }
}
let p = new Person("yzq");
p.name = "aaa"//錯誤，不能被修改
p.age=24//錯誤，不能被修改
 

6.存取器（Getter And Setter）

TypeScript中的存取器就類似與java中set和get方法，只不過呼叫的方式不一樣。比如在一個類中我們將其中一個屬性用private修飾，那麼，在類的外部就無法訪問到該屬性，這個時候我們可以通過getters/setters來封裝一下，以便在類的外部去訪問該屬性。

class Person {
    private age: number;
    get age() {
        return this._age;
    }
    set age(inputAge: number) {
        /*這裡可以做一些邏輯處理 */
        if (inputAge < 0 || inputAge > 150) {
            alert("年齡異常");
        } else {
            this._age = inputAge;
        }
    }}

7.靜態方法

靜態屬性直接通過類名訪問，無需例項化。用static修飾的屬性會在這個類被載入的時候就進行初始化。

（1）es5中靜態方法定義（直接在建構函式上定義）：

Person.talk=function(){
}

（2）TypeScript在方法名前加上static，靜態方法不能訪問類裡面的非靜態屬性，只能訪問類裡面的靜態屬性

class Person {
    static name: String; 
    static age: number;
    constructor(name: String, age: number)
         { this.name = name; this.age = age; }
     static say() {
             return “Hello，my name is”+Person.name+“,I'm ”+Person.age+“years old”;
           }
}

8.多型類

多型屬於繼承。父類有個方法不去實現，讓繼承的子類去實現，每個子類都有不同的表現。

              class Animal {//父類
                    name:string;
                    constructor(name:string) {
                        this.name=name;
                    }
                    eat(){   //具體吃什麼  不知道   ，  具體吃什麼?繼承它的子類去實現 ，每一個子類的表現不一樣
                        console.log('吃的方法')
                    }
                }
                class Dog extends Animal{//子類
                    constructor(name:string){
                        super(name)
                    }
                    eat(){
                
                        return this.name+'吃糧食'
                    }
                }
                class Cat extends Animal{//子類
                    constructor(name:string){
                        super(name)
                    }
                    eat(){
                        return this.name+'吃老鼠'
                    }
                }

8.抽象

用abstract關鍵字定義抽象類和抽象方法，抽象方法只能存在於抽象類中，不包含具體實現{...}

abstract class Animal{ 
    public name:string;
    constructor(name:string){
        this.name=name;
    }
    abstract eat():any;  //抽象方法不包含具體實現並且必須在子類中實現。
    run(){
        console.log('其他方法可以不實現')     //抽象類中可以有非抽象方法
    }
}
// var a=new Animal() /*錯誤的寫法，抽象類不能被例項化，只能用作其他類的基類*/

class Dog extends Animal{
    constructor(name:any){
        super(name)
    }
 //抽象類的子類必須實現抽象類裡面的抽象方法
    eat(){
        console.log(this.name+'吃糧食')
    }
}
var d=new Dog('小狗');
d.eat();