TypeScript学习笔记2----es6类与ts类

ES6 中类的用法

1.属性和方法：使用 class 定义类，使用 constructor 定义构造函数。

通过 new 生成新实例的时候，会自动调用构造函数。、

class Animal {

constructor(name) {

this.name = name;

}

sayHi() {

return `My name is ${this.name}`;

}

}

let a = new Animal('Jack');

console.log(a.sayHi()); // My name is Jack

 

2.类的继承

使用 extends 关键字实现继承，子类中使用 super 关键字来调用父类的构造函数和方法。

 

class Cat extends Animal {

constructor(name) {

super(name); // 调用父类的 constructor(name)

console.log(this.name);

}

sayHi() {

return 'Meow, ' + super.sayHi(); // 调用父类的 sayHi()

}

}

let c = new Cat('Tom'); // Tom

console.log(c.sayHi()); // Meow, My name is Tom

 

3.存取器

使用 getter 和 setter 可以改变属性的赋值和读取行为。

class Animal {

constructor(name) {

this.name = name;

}

get name() {

return 'Jack';

}

set name(value) {

console.log('setter: ' + value);

}

}

let a = new Animal('Kitty'); // setter: Kitty

a.name = 'Tom'; // setter: Tom

console.log(a.name); // Jack

 

 

4.静态方法

使用static修饰符修饰的方法称为静态方法，它们不需要实例化，而是直接通过类来调用：

class Animal{

static isAnimal(a){

return a instanceof Animal;

}

}

 

let a = new Animal('Jack');

Animal.isAnimal(a);

 

 

5.ts类的使用：

TypeScript 可以使用三种访问修饰符（Access Modifiers），分别是 public、private 和 protected。

 

public 修饰的属性或方法是公有的，可以在任何地方被访问到，默认所有的属性和方法都是 public 的。

 

private 修饰的属性或方法是私有的，不能在声明它的类的外部访问。

 

protected 修饰的属性或方法是受保护的，它和 private 类似，区别是它在子类中也是允许被访问的。

 

class Animal {

public name;

public constructor(name) {

this.name = name;

}

}

let a = new Animal('Jack');

console.log(a.name); // Jack

a.name = 'Tom';

console.log(a.name); // Tom

 

readonly：只读属性关键字，只允许出现在属性声明或索引签名中。

class Animal {

readonly name;

public constructor(name) {

this.name = name;

}

}

let a = new Animal('Jack');

console.log(a.name); // Jack

error：a.name = 'Tom';

注意如果readonly和其他访问修饰符同时存在的话，需要写在其后面。

class Animal{

public constructor(public readonly name){

this.name = name;

}

}

 

6.抽象类

abstract 用于定义抽象类和其中的抽象方法。

抽象类是不允许被实例化的。

abstract class Animal {

public name;

public constructor(name) {

this.name = name;

}

public abstract sayHi();

}

error:let a = new Animal('Jack');

 

抽象类中的抽象方法必须被子类实现。

abstract class Animal {

public name;

public constructor(name) {

this.name = name;

}

public abstract sayHi();

}

 

class Cat extends Animal {

public sayHi() {

console.log(`Meow, My name is ${this.name}`);

}

}

let cat = new Cat('Tom');

 

7.类的类型

给类加上 TypeScript 的类型很简单。

 

class Animal {

name: string;

constructor(name: string) {

this.name = name;

}

sayHi(): string {

return `My name is ${this.name}`;

}

}

let a: Animal = new Animal('Jack');

console.log(a.sayHi()); // My name is Jack