类_TypeScript笔记4

class Grid {
   static origin = {x: 0, y: 0};
}class Employee {
   private _fullName: string;   get fullName(): string {
       return this._fullName;
   }   set fullName(newName: string) {
       this._fullName = newName;
   }
}

class Animal {
   // 私有成员属性
   private name: string;
   // 受保护成员属性
   protected ancestor: string;
   // 不写的话，默认public
   constructor(theName: string) { this.name = theName; }
   // public成员方法
   public move(distanceInMeters: number) {
       console.log(`${this.name} moved ${distanceInMeters}m.`);
   }
}

class Animal {
   name: string;
   constructor(theName: string) { this.name = theName; }
}
class Person {
   name: string;
   constructor(theName: string) { this.name = theName; }
}
// 正确：鸭子类型（长得像就是）
let person: Animal = new Person('Sam');class Plant {
   // 私有成员name
   private name: string;
   constructor(theName: string) { this.name = theName; }
}
// 错误：name属性可访问性不匹配（长得像也不行，可访问性不一样）
// Property 'name' is private in type 'Plant' but not in type 'Person'.
let invalidPlant: Plant = new Person('Stone');

class Octopus {
   readonly name: string;
   public 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.

class Octopus {
   readonly name: string;
   constructor (theName: string) {
       this.name = theName;
   }
}

class Octopus {
   readonly numberOfLegs: number = 8;
   constructor(readonly name: string) {
   }
}

class A extends B {
   //...
}

function _inherits(subClass, superClass) {
 // 继承父类原型属性
 subClass.prototype = Object.create(superClass && superClass.prototype, {
   constructor: {
     value: subClass,
     enumerable: false,
     writable: true,
     configurable: true
   }
 });
 // 继承父类静态属性
 if (superClass)
   Object.setPrototypeOf
     ? Object.setPrototypeOf(subClass, superClass)
     : (subClass.__proto__ = superClass);
}// 子类构造函数中继承父类实例属性
function A() {
   // 通过父类构造函数给子类实例this添上父类实例属性
   return A.__proto__ || Object.getPrototypeOf(A)).apply(this, arguments)
}

var __extends = (this && this.__extends) || (function () {
   var extendStatics = function (d, b) {
       extendStatics = Object.setPrototypeOf ||
           ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
           function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
       return extendStatics(d, b);
   };   return function (d, b) {
       // 继承父类静态属性
       extendStatics(d, b);
       function __() { this.constructor = d; }
       // 继承父类原型属性，及实例属性
       d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
   };
})();// __extends(A, B);

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

class Cat extends Animal {
   makeSound() {
       console.log('meow meow meow');
   }
}

interface Animal {
 // 对比 abstract makeSound(): void;
 makeSound(): void;
}// 对比 class Cat extends Animal
class Cat implements Animal {
   makeSound() {
       console.log('meow meow meow');
   }
}

class Greeter {
   static standardGreeting = "Hello, there";
   greeting: string;
   constructor(message: string) {
       this.greeting = message;
   }
   greet() {
       return "Hello, " + this.greeting;
   }
}let greeter: Greeter;
greeter = new Greeter("world");

class GreeterDuck {
   // 类自身的类型约束
   static standardGreeting = 'Hi';
   greeting: string;
   constructor(message: string) { }
   greet() { return 'there'; }
   // 允许多不允许少（鸭子类型）
   sayHello() { /*...*/ }
}let greeterType: typeof Greeter = GreeterDuck;

// 从Class类型扩展出Interface
interface HelloGreeter extends Greeter {
   sayHello(): void;
}let hGreeter: HelloGreeter = new GreeterDuck('world');