TypeScript學習: 類

一.類

類類似於Java的類
只能有一個構造函數,不寫則會默認創建一個無參構造函數
可以有public,private,protected屬性或者方法
可以繼承

class Demo1 {
  public _name: string;
  private _age: number;
  protected _size: number;
  constructor(name:string, age: number, size: number) {
    this._name = name;
    this._age = age;
    this._size = size;
  }

  get getName(): string {
    return this._name;
  }
  get getAge(): number {
    return this._age;
  }
  get getSize(): number {
    return this._size;
  }
}

class Demo2 extends Demo1 {
  _eat: string;
  constructor(name:string, age: number, size: number, eat: string) {
    super(name, age, size);
    this._eat = eat;
  }
  get getEat(): string {
    return this._eat;
  }
}

let d2 = new Demo2('s', 13, 20, 'yes');
console.log(d2.getName);
console.log(d2.getAge);
console.log(d2.getSize);

二.類繼承

1. public 屬性或方法會被繼承
2. private 屬性或方法只能在自身類中訪問,即使是自身類的實例也不能訪問
3. protected 屬性或方法能在自身類中或者子類中訪問,但即使是自身類的實例也不能訪問protected屬性或方法,子類的實例也不能
   

下面類Demo1中getSize變爲protected方法, getAge變爲private方法
最下面的調用出錯

class Demo1 {
  public _name: string;
  private _age: number;
  protected _size: number;
  constructor(name:string, age: number, size: number) {
    this._name = name;
    this._age = age;
    this._size = size;
  }

  get getName(): string {
    return this._name;
  }
  private get getAge(): number {
    return this._age;
  }
  protected get getSize(): number {
    return this._size;
  }
}

class Demo2 extends Demo1 {
  _eat: string;
  constructor(name:string, age: number, size: number, eat: string) {
    super(name, age, size);
    this._eat = eat;
  }
  get getEat(): string {
    return this._eat;
  }
}

let d2 = new Demo2('s', 13, 20, 'yes');
console.log(d2.getName);
console.log(d2.getAge);     // [ts] 屬性“getAge”爲私有屬性，只能在類“Demo1”中訪問
console.log(d2.getSize);    // [ts] 屬性“getSize”受保護，只能在類“Demo1”及其子類中訪問。

三.靜態屬性和方法

靜態屬性和方法不需要類實例化就能被調用
若加上修飾符,和其他屬性和方法效果一樣

class Demo1 {
  public _name: string;
  private _age: number;
  protected _size: number;
  static common: string = 'hello world';
  constructor(name:string, age: number, size: number) {
    this._name = name;
    this._age = age;
    this._size = size;
  }

  get getName(): string {
    console.log(Demo1.common);
    return this._name;
  }
  private get getAge(): number {
    console.log(Demo1.common);
    return this._age;
  }
  protected get getSize(): number {
    console.log(Demo1.common);
    return this._size;
  }
  static hello(): string {
    return '你好啊';
  }
}

class Demo2 extends Demo1 {
  _eat: string;
  constructor(name:string, age: number, size: number, eat: string) {
    super(name, age, size);
    this._eat = eat;
  }
  get getEat(): string {
    console.log(Demo1.common);
    return this._eat;
  } 
}

console.log(Demo1.common);
Demo1.hello();
let d2 = new Demo2('s', 13, 20, 'yes');
console.log(d2.getName);
// console.log(d2.getAge);
// console.log(d2.getSize);

三.抽象類

抽象類和抽象方法
抽象類中可以有抽象方法和非抽象方法
抽象方法必須在子類中實現
抽象類不可被實例化

abstract class Demo3 {
  abstract hello(): string;
  test(): number {
    return 3;
  }
  constructor(public name: string) {

  }
}

class Demo4 extends Demo3 {
  constructor(name: string) {
    super(name);
  }
  hello(): string {
    return 'hello';
  }
}

let d4 = new Demo4('shen');
d4.hello();
d4.test();

四.其他

獲取類的類型,即類的類型和構造函數(typeof Greeter)

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());