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