TypeScript 高级类型类(class)

无亟發表於 2019-12-9 16:11:00

传统的JavaScript程序使用函数和基于原型的继承来创建可重用的组件，但对于熟悉使用面向对象方式的程序员来讲就有些棘手，因为他们用的是基于类的继承并且对象是由类构建出来的。从ECMAScript 2015，也就是ECMAScript 6开始，JavaScript程序员将能够使用基于类的面向对象的方式。而使用TypeScript，我们允许开发者现在就使用这些特性，并且编译后的JavaScript可以在所有主流浏览器和平台上运行，而不需要等到下个JavaScript版本。
　　下面看一个使用类的例子：
<div class="cnblogs_code">
<pre>class Greeter {
greeting: string;
constructor(message: string) {
 this.greeting = message;
}
greet() {
 return "Hello, " + this.greeting;
}
}

let greeter = new Greeter("world");　</pre>
</div>
　　如果你使用过C#或Java，你会对这种语法非常熟悉。我们声明一个 <code>Greeter</code>类。这个类有3个成员：一个叫做 <code>greeting</code>的属性，一个构造函数和一个 <code>greet</code>方法。
　　你会注意到，我们在引用任何一个类成员的时候都用了 <code>this</code>。它表示我们访问的是类的成员。
　　最后一行，我们使用 <code>new</code>构造了 <code>Greeter</code>类的一个实例。它会调用之前定义的构造函数，创建一个 <code>Greeter</code>类型的新对象，并执行构造函数进行初始化。
<h2>　　实现接口</h2>
　　与C#或Java里接口的基本作用一样，TypeScript也能够用它来明确的强制一个类去符合某种契约。
<div class="cnblogs_code">
<pre>interface ClockInterface {
currentTime: Date;
}

class Clock implements ClockInterface {
currentTime: Date;
constructor(h: number, m: number) { }
}</pre>
</div>
　　你也可以在接口中描述一个方法，在类里实现它，如同下面的<code>setTime</code>方法一样：
<div class="cnblogs_code">
<pre>interface ClockInterface {
currentTime: Date;
setTime(d: Date);
}

class Clock implements ClockInterface {
currentTime: Date;
setTime(d: Date) {
 this.currentTime = d;
}
constructor(h: number, m: number) { }
}</pre>
</div>
　　接口描述了类的公共部分，而不是公共和私有两部分。它不会帮你检查类是否具有某些私有成员。
<h1>　　继承</h1>
　　在TypeScript里，我们可以使用常用的面向对象模式。基于类的程序设计中一种最基本的模式是允许使用继承来扩展现有的类。
　　看下面的例子：
<div class="cnblogs_code">
<pre>class Animal {
move(distanceInMeters: number = 0) {
 console.log(`Animal moved ${distanceInMeters}m.`);
}
}

class Dog extends Animal {
bark() {
 console.log('Woof! Woof!');
}
}

const dog = new Dog();
dog.bark();
dog.move(10);
dog.bark();</pre>
</div>
　　这个例子展示了最基本的继承：类从基类中继承了属性和方法。这里， <code>Dog</code>是一个 派生类（子类），它通过 <code>extends</code>关键字派生自 <code>Animal</code> 基类（父类）。派生类通常被称作 子类，基类通常被称作 超类。
　　因为 <code>Dog</code>继承了 <code>Animal</code>的功能，因此我们可以创建一个 <code>Dog</code>的实例，它能够 <code>bark()</code>和 <code>move()</code>。
　　下面我们来看个更加复杂的例子。
<div class="cnblogs_code">
<pre>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 {
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);</pre>
</div>
　　这个例子展示了一些上面没有提到的特性。这一次，我们使用 <code>extends</code>关键字创建了 <code>Animal</code>的两个子类： <code>Horse</code>和 <code>Snake</code>。
　　与前一个例子的不同点是，派生类包含了一个构造函数，它 必须调用 <code>super()</code>，并会执行基类的构造函数。而且，在构造函数里访问 <code>this</code>的属性之前一定要调用 <code>super()</code>。这是TypeScript强制执行的一条重要规则。
　　这个例子演示了如何在子类里重写父类的方法。 <code>Snake</code>类和 <code>Horse</code>类都创建了 <code>move</code>方法，它们重写了从 <code>Animal</code>继承来的 <code>move</code>方法，使得 <code>move</code>方法根据不同的类而具有不同的功能。注意，即使 <code>tom</code>被声明为 <code>Animal</code>类型，但因为它的值是 <code>Horse</code>，调用 <code>tom.move(34)</code>时，它会调用 <code>Horse</code>里重写的方法：
<div class="cnblogs_code">
<pre>Slithering...
Sammy the Python moved 5m.
Galloping...
Tommy the Palomino moved 34m.</pre>
</div>
<h1>　　公共，私有与受保护的修饰符　</h1>
<h2>　　默认为 <code>public</code></h2>
　　在上面的例子里，我们可以自由的访问程序里定义的成员。如果你对其它语言中的类比较了解，就会注意到我们在之前的代码里并没有使用 <code>public</code>来做修饰；例如，C#要求必须明确地使用 <code>public</code>指定成员是可见的。在TypeScript里，成员都默认为 <code>public</code>。
你也可以明确的将一个成员标记成 <code>public</code>。我们可以用下面的方式来重写上面的 <code>Animal</code>类：
<div class="cnblogs_code">
<pre>class Animal {
public name: string;
public constructor(theName: string) { this.name = theName; }
public move(distanceInMeters: number) {
 console.log(`${this.name} moved ${distanceInMeters}m.`);
}
}</pre>
</div>
<h2>　　理解 <code>private</code></h2>
　　当成员被标记成 <code>private</code>时，它就不能在声明它的类的外部访问。比如：
<div class="cnblogs_code">
<pre>class Animal {
private name: string;
constructor(theName: string) { this.name = theName; }
}

new Animal("Cat").name; // 错误: 'name' 是私有的.</pre>
</div>
　　TypeScript使用的是结构性类型系统。当我们比较两种不同的类型时，并不在乎它们从何处而来，如果所有成员的类型都是兼容的，我们就认为它们的类型是兼容的。
　　然而，当我们比较带有 <code>private</code>或 <code>protected</code>成员的类型的时候，情况就不同了。如果其中一个类型里包含一个 <code>private</code>成员，那么只有当另外一个类型中也存在这样一个 <code>private</code>成员，并且它们都是来自同一处声明时，我们才认为这两个类型是兼容的。对于 <code>protected</code>成员也使用这个规则。
　　下面来看一个例子，更好地说明了这一点：
<div class="cnblogs_code">
<pre>class Animal {
private name: string;
constructor(theName: string) { this.name = theName; }
}

class Rhino extends Animal {
constructor() { super("Rhino"); }
}

class Employee {
private name: string;
constructor(theName: string) { this.name = theName; }
}

let animal = new Animal("Goat");
let rhino = new Rhino();
let employee = new Employee("Bob");

animal = rhino;
animal = employee; // 错误: Animal 与 Employee 不兼容.</pre>
</div>
　　这个例子中有 <code>Animal</code>和 <code>Rhino</code>两个类， <code>Rhino</code>是 <code>Animal</code>类的子类。还有一个 <code>Employee</code>类，其类型看上去与 <code>Animal</code>是相同的。我们创建了几个这些类的实例，并相互赋值来看看会发生什么。因为 <code>Animal</code>和 <code>Rhino</code>共享了来自 <code>Animal</code>里的私有成员定义 <code>private name: string</code>，因此它们是兼容的。然而 <code>Employee</code>却不是这样。当把 <code>Employee</code>赋值给 <code>Animal</code>的时候，得到一个错误，说它们的类型不兼容。尽管 <code>Employee</code>里也有一个私有成员 <code>name</code>，但它明显不是 <code>Animal</code>里面定义的那个。
<h2>　　理解 <code>protected</code></h2>
<code>　　protected</code>修饰符与 <code>private</code>修饰符的行为很相似，但有一点不同， <code>protected</code>成员在派生类中仍然可以访问。例如：
<div class="cnblogs_code">
<pre>class Person {
protected name: string;
constructor(name: string) { this.name = name; }
}

class Employee extends Person {
private department: string;

constructor(name: string, department: string) {
 super(name)
 this.department = department;
}

public getElevatorPitch() {
 return `Hello, my name is ${this.name} and I work in ${this.department}.`;
}
}

let howard = new Employee("Howard", "Sales");
console.log(howard.getElevatorPitch());
console.log(howard.name); // 错误</pre>
</div>
　　注意，我们不能在 <code>Person</code>类外使用 <code>name</code>，但是我们仍然可以通过 <code>Employee</code>类的实例方法访问，因为 <code>Employee</code>是由 <code>Person</code>派生而来的。
　　构造函数也可以被标记成 <code>protected</code>。这意味着这个类不能在包含它的类外被实例化，但是能被继承。比如，
<div class="cnblogs_code">
<pre>class Person {
protected name: string;
protected constructor(theName: string) { this.name = theName; }
}

// Employee 能够继承 Person
class Employee extends Person {
private department: string;

constructor(name: string, department: string) {
 super(name);
 this.department = department;
}

public getElevatorPitch() {
 return `Hello, my name is ${this.name} and I work in ${this.department}.`;
}
}

let howard = new Employee("Howard", "Sales");
let john = new Person("John"); // 错误: 'Person' 的构造函数是被保护的.</pre>
</div>
<h1>　　readonly修饰符（只读属性）</h1>
　　你可以使用 <code>readonly</code>关键字将属性设置为只读的。只读属性必须在声明时或构造函数里进行初始化。
<div class="cnblogs_code">
<pre>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"; // 错误! name 是只读的.</pre>
</div>
<h2>　　参数属性</h2>
　　在上面的例子中，我们必须在<code>Octopus</code>类里定义一个只读成员 <code>name</code>和一个参数为 <code>theName</code>的构造函数，并且立刻将 <code>theName</code>的值赋给 <code>name</code>，这种情况经常会遇到。 参数属性可以方便地让我们在一个地方定义并初始化一个成员。下面的例子是对之前 <code>Octopus</code>类的修改版，使用了参数属性：
<div class="cnblogs_code">
<pre>class Octopus {
readonly numberOfLegs: number = 8;
constructor(readonly name: string) {
}
}</pre>
</div>
　　注意看我们是如何舍弃了 <code>theName</code>，仅在构造函数里使用 <code>readonly name: string</code>参数来创建和初始化 <code>name</code>成员。我们把声明和赋值合并至一处。
　　参数属性通过给构造函数参数前面添加一个访问限定符来声明。使用 <code>private</code>限定一个参数属性会声明并初始化一个私有成员；对于 <code>public</code>和 <code>protected</code>来说也是一样。
<h1>　　存取器</h1>
　　TypeScript支持通过getters/setters来截取对对象成员的访问。这可以有效的控制如何访问对象成员。
　　下面来看如何把一个简单的类改写成使用 <code>get</code>和 <code>set</code>。首先，我们从一个没有使用存取器的例子开始。
<div class="cnblogs_code">
<pre>class Employee {
fullName: string;
}

let employee = new Employee();
employee.fullName = "Bob Smith";
if (employee.fullName) {
console.log(employee.fullName);
}　</pre>
</div>
　　我们可以随意的设置 <code>fullName</code>，这是非常方便的，但是这也可能会带来麻烦。
　　下面这段代码里，我们先检查用户密码是否正确，然后再允许其修改员工信息。我们把对 <code>fullName</code>的直接访问改成了可以检查密码的 <code>set</code>方法。我们也加了一个 <code>get</code>方法，让上面的例子仍然可以工作。
<div class="cnblogs_code">
<pre>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);
}</pre>
</div>
　　我们可以修改一下密码，来验证一下存取器是否是工作的。当密码不对时，会提示我们没有权限去修改员工。
　　对于存取器有下面几点需要注意的：
<ul>
<li>需要将编译器设置为输出ECMAScript 5或更高。不支持降级到ECMAScript 3</li>
<li>只带有 <code>get</code>不带有 <code>set</code>的存取器自动被推断为 <code>readonly</code>。这在从代码生成 <code>.d.ts</code>文件时是有帮助的，因为利用这个属性的用户会看到不允许够改变它的值</li>
</ul>
<h1>　　静态属性</h1>
　　到目前为止，我们只讨论了类的实例成员，以及那些仅当类被实例化时才会被初始化的属性。我们也可以创建类的静态成员，这些属性存在于类本身上面，而不是类的实例上。在这个例子里，我们使用 <code>static</code>定义 <code>origin</code>，因为它是所有Grid类都会用到的属性。每个实例想要访问这个属性的时候，都要在 <code>origin</code>前面加上类名。如同在实例属性上使用 <code>this.</code>前缀来访问属性一样，这里我们使用 <code>Grid.</code>来访问静态属性。
<div class="cnblogs_code">
<pre>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) { }
}

let grid1 = new Grid(1.0);// 1x scale
let grid2 = new Grid(5.0);// 5x scale

console.log(grid1.calculateDistanceFromOrigin({x: 10, y: 10}));
console.log(grid2.calculateDistanceFromOrigin({x: 10, y: 10}));　　</pre>
</div>
<h1>　　抽象类</h1>
　　抽象类一般作为其它派生类的基类使用。不会直接被实例化。不同于接口，抽象类可以包含成员的实现细节。 <code>abstract</code>关键字是用于定义抽象类和在抽象类内部定义抽象方法。
<div class="cnblogs_code">
<pre>abstract class Animal {
abstract makeSound(): void;
move(): void {
 console.log('roaming the earch...');
}
}</pre>
</div>
　　抽象类中的抽象方法不包含具体实现并且必须在派生类中实现。抽象方法的语法与接口方法相似。两者都是定义方法签名但不包含方法体。然而，抽象方法必须包含 <code>abstract</code>关键字并且可以包含访问修饰符。
<div class="cnblogs_code">
<pre>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'); // 在派生类的构造函数中必须调用 super()
 }

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

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

let department: Department; // 允许创建一个对抽象类型的引用
department = new Department(); // 错误: 不能创建一个抽象类的实例
department = new AccountingDepartment(); // 允许对一个抽象子类进行实例化和赋值
department.printName();
department.printMeeting();
department.generateReports(); // 错误: 方法在声明的抽象类中不存在</pre>
</div>
<h1>　　高级技巧</h1>
<h2>　　构造函数</h2>
　　当你在TypeScript里声明了一个类的时候，实际上同时声明了很多东西。首先就是类的 实例的类型。
<div class="cnblogs_code">
<pre>class Greeter {
greeting: string;
constructor(message: string) {
 this.greeting = message;
}
greet() {
 return "Hello, " + this.greeting;
}
}

let greeter: Greeter;
greeter = new Greeter("world");
console.log(greeter.greet());</pre>
</div>
　　这里，我们写了 <code>let greeter: Greeter</code>，意思是 <code>Greeter</code>类的实例的类型是 <code>Greeter</code>。这对于用过其它面向对象语言的程序员来讲已经是老习惯了。
　　我们也创建了一个叫做 构造函数的值。这个函数会在我们使用 <code>new</code>创建类实例的时候被调用。下面我们来看看，上面的代码被编译成JavaScript后是什么样子的：
<div class="cnblogs_code">
<pre>let Greeter = (function () {
function Greeter(message) {
 this.greeting = message;
}
Greeter.prototype.greet = function () {
 return "Hello, " + this.greeting;
};
return Greeter;
})();

let greeter;
greeter = new Greeter("world");
console.log(greeter.greet());</pre>
</div>
　　上面的代码里， <code>let Greeter</code>将被赋值为构造函数。当我们调用 <code>new</code>并执行了这个函数后，便会得到一个类的实例。这个构造函数也包含了类的所有静态属性。换个角度说，我们可以认为类具有 实例部分与 静态部分这两个部分。
　　让我们稍微改写一下这个例子，看看它们之间的区别：
<div class="cnblogs_code">
<pre>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());</pre>
</div>
　　这个例子里， <code>greeter1</code>与之前看到的一样。我们实例化 <code>Greeter</code>类，并使用这个对象。与我们之前看到的一样。
　　再之后，我们直接使用类。我们创建了一个叫做 <code>greeterMaker</code>的变量。这个变量保存了这个类或者说保存了类构造函数。然后我们使用 <code>typeof Greeter</code>，意思是取Greeter类的类型，而不是实例的类型。或者更确切的说，"告诉我 <code>Greeter</code>标识符的类型"，也就是构造函数的类型。这个类型包含了类的所有静态成员和构造函数。之后，就和前面一样，我们在 <code>greeterMaker</code>上使用 <code>new</code>，创建 <code>Greeter</code>的实例。
<h2>　　把类当做接口使用</h2>
　　如上一节里所讲的，类定义会创建两个东西：类的实例类型和一个构造函数。因为类可以创建出类型，所以你能够在允许使用接口的地方使用类。
<div class="cnblogs_code">
<pre>class Point {
x: number;
y: number;
}

interface Point3d extends Point {
z: number;
}

let point3d: Point3d = {x: 1, y: 2, z: 3};</pre>
</div>
  
来源：https://www.cnblogs.com/fanqisoft/p/12011655.html

頁: [1]

琼殿技术论坛's Archiver

TypeScript 高级类型 类(class)

TypeScript 高级类型类(class)