TypeScript（三）类

作者: 一蓑烟雨任平生_cui | 来源:发表于2019-10-25 16:26 被阅读0次

TypeScript（三）类
如何在TypeScript中定义类并进行调用
TypeScript——类
Typescript —— 类
TypeScript类
TypeScript类
typescript 类
TypeScript 类
TypeScript——类
TypeScript -- 类

TypeScript中的类不仅具有ES6中类的全部功能，还提供了修饰符、抽象类等其他新功能。

用法

类使用class关键字定义：

class Animal {
  name: string;
  constructor(name: string) {
    this.name = name
  }
  eat(): void {
    console.log( `${this.name}在吃东西` )
  }
}

const dog = new Animal('nike)

Animal类具有实例属性name、constructor构造函数和实例方法eat。最后通过new关键字创建了一个dog实例。

编译成js：

var Animal = /** @class */ (function() {
    function Animal(name) {
        this.name = name;
    }
    Animal.prototype.eat = function() {
        console.log(this.name + "\u5728\u5403\u4E1C\u897F");
    };
    return Animal;
}());
var dog = new Animal('nike));

继承

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

class Dog extends Animal {
  age: number
  constructor(name: string, age: number) {
    super(name)
    this.age = age
  }
}
const dog = new Animal('nike', 3)

调用super()相当于通过上下文的方式调用父类的constructor。

注意：super一定要在构造函数中访问this之前调用。这是TypeScript强制执行的一条重要规则，ES6也是同样的。

私有属性&私有方法

ES6

ES6并没有提供私有属性和方法的定义方式，只是通过变通的方法去模拟。比如：

在命名上区别：

在属性和方法名前加 _ 。

class Dog {
    _name: 'mike',
        _bar(val) {
            this._name = val
        }
    foo(val) {
        this._bar(val)
    }
}

但这种方式仅仅是通过命名区别，在外部仍然可以访问到。

将属性和方法移出模块：

let _name = ''
const _bar = val => name = val

class Dog {
    setName(val) {
        _bar(val)
    }
    getName() {
        return _name
    }
}

利用Symbol值的唯一性，将私有方法的名字命名为一个Symbol值:

const bar = Symbol('bar')
const age = Symbol('age')

class Dog {
    // 公有方法
    foo(baz) {
        this[bar](baz)
    }
    // 私有方法
    [bar](baz) {
        this[age] = baz
    }
}

以上方式bar和age都是Symbol值，一般情况下无法获取到它们，因此达到了私有方法和私有属性的效果。但是也不是绝对可行，Reflect.ownKeys()依然可以拿到它们。

const dog = new Dog()

Reflect.ownKeys(Dog.prototype)
// [ 'constructor', 'foo', Symbol(bar) ]

TypeScript访问控制修饰符

TypeScript 可以使用三种修饰符，分别是 public、private 和 protected。

public

public 修饰的属性或方法是公有的，可以在父类、子类以及类外部访问到，默认所有的属性和方法都是 public 的。

class Animal {
  public name: string;
  constructor(name: string) {
    this.name = name
  }
  public skill(): void {
    // 父类可以访问name属性
    console.log( `${this.name} 看门`)
  }
}

class Dog extends Animal {
  constructor(name: string) {
    super(name)
  }
  public eat(): void {
    // 子类可以访问name属性
    console.log( `${this.name} 吃肉`)
  }
}

const dog = new Dog('bei')
dog.skill()
dog.eat()
dog.name  // 类外部（类实例）可以访问name属性

private

有时我们希望有些属性无法被直接存取，这时就可以用 private 了。

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

class Animal {
  private name: string
  constructor(name: string) {
    this.name = name
  }
  eat(): void {
    console.log( `${this.name} 喜欢吃肉` )
  }
}

const dog = new Animal('nike')
dog.eat() // 'bei 喜欢吃肉'
dog.name  // 报错：Property 'name' is private and only accessible within class 'Animal'.

由此可见私有属性name不可在类外部访问。而且在子类中也是不允许访问的，如下：

class Dog extends Animal {
  constructor(name: string) {
    super(name)
  }
  skill(): void {
    // console.log(this.name)
    // Property 'name' is private and only accessible within class 'Animal'.
  }
}

const dog = new Dog('bei')
dog.eat()    // 'bei 喜欢吃肉'

当构造函数修饰为 private 时，该类不允许被继承或者实例化：

class Animal {
  public name: string;
  private constructor (name) {
      this.name = name
  }
}

// 报错：Constructor of class 'Animal' is private and only accessible within the class declaration.
let cat = new Animal('mike')

class Cat extends Animal {
  constructor (name: string) {
    super(name)
  }
}
// 报错：Cannot extend a class 'Animal'. Class constructor is marked as private.

protected

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

class Animal {
  protected name: string
  constructor(name: string) {
    this.name = name
  }
  eat(): void {
    console.log( `${this.name}吃肉` )
  }
}

class Dog extends Animal {
  constructor(name: string) {
    super(name)
  }
  skill(): void {
    console.log( `${this.name}睡觉` )
  }
}

const dog = new Dog('bei')
dog.skill()
dog.eat()
dog.name  // 报错： Property 'name' is protected and only accessible within class 'Animal' and its subclasses.

当构造函数修饰为 protected 时，该类只允许被继承，不能在包含它的类外被实例化：

class Animal {
  public name: string;
  protected constructor (name: string) {
    this.name = name
  }
}

class Cat extends Animal {
  constructor (name: string) {
    super(name)
  }
}

let cat = new Animal('mike')
// 报错：Constructor of class 'Animal' is protected and only accessible within the class declaration.

类型兼容性

TypeScript使用的是结构性类型系统。当比较两种不同的类型时，并不在乎它们从哪来，如果所有成员的类型都是兼容的，就认为它们的类型是兼容的。

此处的比较并不是通过 == 或 === 进行比较，而是对期望值（结构）的比较。

以下案例不会有问题：


class Animal1 {
   name: string
   constructor(name: string) {
       this.name = name
   }
}
class Animal2 {
   name: string
   constructor(name: string) { 
      this.name = name
   }
}
// 这种写法不会出错
let a: Animal1=new Animal2('cat')

但是，当我们比较带有 private 或 protected 成员的类型的时候，情况就不同了。如果其中一个类型里包含一个 private 成员，那么只有当另外一个类型中也存在这样一个 private成员，并且它们都是来自同一处声明时，我们才认为这两个类型是兼容的。对于 protected成员也使用这个规则。

具体看下例：

class Animal {
  private name: string
  constructor(name: string) {
    this.name = name
  }
}

class Dog extends Animal {
  constructor(name: string) {
    super(name)
  }
}

class Cat {
  private name: string
  constructor(name: string) {
    this.name = name
  }
}

let animal = new Animal('animal')
let dog = new Dog('dog')
let cat = new Cat('cat')

// animal 和 dog可以相互赋值
animal = dog 

// 但是 dog、animal 不能和cat相互赋值，因为Cat 和 Dog、Animal不兼容，所以以下两个赋值报错
cat = animal
dog = animal
// Type 'Cat' is not assignable to type 'Animal'. Types have separate declarations of a private property 'name'.

上例中因为 Animal 和 Dog 共享了来自 Animal里的私有属性name，因此它们是兼容的。

而 Cat 类，其类型结构看上去与 Animal是相同的。但当把 Cat 的实例赋值给 Animal或Dog的实例时候却得到一个错误，说它们的类型不兼容。虽然 Cat里也有一个私有成员 name，但它明显不是 Animal里面定义的那个。

readonly

readonly是class另一个修饰符，和public、protected、private用于修饰成员的访问权限不同，readonly用来修饰的是成员的修改权限。使用 readonly 关键字（修饰符）将属性设置为只读的。只读属性必须在声明时或构造函数里被初始化。

class Animal {
  readonly name: string
  // 声明时初始化
  readonly age: number = 12
  constructor(name: string) {
    // 构造函数中初始化
    this.name = name
  }
}

const dog = new Animal('dog')

const cat = new Animal('cat')

cat.name = 'jack' // 报错：Cannot assign to 'name' because it is a read-only property.

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

class Animal {
  private readonly name: string
  constructor(name: string) {
    this.name = name
  }
}

参数属性

上面例子中的属性都是在类中声明，在构造函数中初始化。参数属性可以方便地让我们在一个地方定义并初始化一个成员。

class Animal {
  readonly age: number = 12
  constructor(readonly name: string) {
    this.name = name
  }
}

参数属性同样适用于private protected public。

存取器

TypeScript的存取器类似于ES6。通过 getter 和 setter 来改变属性的读写行为，有效的控制对对象成员的访问。

class Dog {
  private _name: string = 'jack'
  get name() {
    console.log('取值')
    return this._name
  }
  set name(val) {
    console.log('赋值')
    this._name = val
  }
}

const dog = new Dog()
dog.name            // 取值 jack
dog.name = 'mike'   // 赋值

存取器注意点：只带有 get 不带有 set 的存取器自动被推断为 readonly

静态属性

静态属性是指class本身的属性。和ES6一样，使用 static 修饰符修饰。

class Dog {
  static fullName: string = 'jack Mr'
  static getFullName(): void {
    console.log(this.fullName)
  }
  name: string
  constructor(name: string) {
    this.name = name
  }
}

const dog = new Dog('dog')
console.log(Dog.fullName) // 'jack Mr'
Dog.getFullName()         // 'dog'

抽象类&抽象方法

abstract 关键用于定义抽象类和抽象方法。

抽象类

抽象类只能用作父类使用，不可直接被实例化。和接口不同，抽象类可以包含class的实现细节。

abstract class Animal {
  name: string
  constructor(name: string) {
    this.name = name
  }
}

const dog = new Animal('dog') // 报错：Cannot create an instance of an abstract class.

上述定义了抽象类Animal，直接实例化抽象类Animal时报错了。

抽象方法

抽象方法语法和函数接口相似。两者都是定义方法签名，不包含具体函数体。但是，抽象方法必须包含 abstract 关键字并且可以包含访问修饰符。

抽象方法必须在子类中实现：

abstract class Animal {
  name: string
  constructor(name: string) {
    this.name = name
  }
  protected abstract eat(): void
}

class Dog extends Animal {
  private age: number
  constructor(name: string, age: number) {
    super(name)
    this.age = age
  }
  protected eat(): void {
    console.log( `${this.name} 吃东西` )
  }
  skill(): void {
    this.eat()
  }
}

const dog = new Dog('bei', 12)
dog.skill()

子类中实现抽象类中的抽象方法时，修饰符、返回值不一定非与抽象方法一致，但一定要实现该方法！

类的类型

abstract class Animal {
  constructor(public name: string) {
    this.name = name
  }
  abstract eat(): void
}

class Dog extends Animal {
  age: number = 12
  constructor(name: string) {
    super(name)
  }
  eat(): void {
    console.log('吃东西')
  },
  skill() {
    console.log('子类skill')
  }
}

// 创建一个对抽象类型的引用
let dog: Animal

// 实例化一个抽象子类
dog = new Dog('bei')

// dog实例方法
dog.eat()
dog.skill() // '子类skill'

以上dog在调用实例方法skill时，虽然输出了结果（子类skill），但ts在编译时会报出错误：Property 'skill' does not exist on type 'Animal'。
假设抽象类Animal也有skill方法，dog调用skill，仍然调用的是子类上的skill方法，但ts编译不会报错。

ES6的new.target属性

ES6为new命令引入target属性，该属性一般用在构造函数之中，返回new命令作用于的那个构造函数。如果构造函数不是通过new命令或Reflect.construct()调用的，new.target会返回undefined，因此这个属性可以用来确定构造函数是怎么调用的。

利用这个特点，可以创建类似TypeScript抽象类。但是无法创建类似的抽象方法。

class Animal {
  constructor(name, age) {
    if (new.target === Animal) {
      throw new Error('本类不能实例化')
    } else {
      this.name = name
      this.age = age
    }
  }
}

class Dog extends Animal {
  constructor(name, age) {
    super(name, age)
  }
}

const animal = new Animal();    // 报错
const dog = new Dog('nike', 4)  // 正确

完结。

有关构造函数、类与接口下文单独总结。

TypeScript（三）类
TypeScript中的类不仅具有ES6中类的全部功能，还提供了修饰符、抽象类等其他新功能。用法类使用clas...
如何在TypeScript中定义类并进行调用
1. 类 1.1 定义类在TypeScript中，定义类使用关键字class，后面接类名；定义三个属性name、...
TypeScript——类
对类的使用：
Typescript —— 类
类：上面生成的按钮，点击的结果是“Hello，world”,上面例子中声明一个Greeter类。这个类有3个成员...
TypeScript类
继承和多态之前的JavaScript是基于原型(prototype)继承来实现可复用的“类”，而TypeScri...
TypeScript类
javascript提供构造函数和原型的方式来构造复用组件； TypeScript提供类的概念；共同点都要实例化；...
typescript 类
日期： 2019 年 9 月2 日类类的例子继承基于类的程序设计中一种最基本的模式是允许使用继承来扩展现有...
TypeScript 类
类常用的语法： extends与super private、public、protected、readonly g...
TypeScript——类
传统的JavaScript程序使用函数和基于原型的继承来创建可重用的组件，但对于熟悉使用面向对象方式的程序员来讲就...
TypeScript -- 类
一，继承和成员修饰符注意：类的属性都是实例属性而不是原型属性；方法是原型上的;类里面的属性都需要有初始值成员...

TypeScript（三）类

用法

继承

私有属性&私有方法

ES6

TypeScript访问控制修饰符

public

private

当构造函数修饰为 private 时，该类不允许被继承或者实例化：

protected

当构造函数修饰为 protected 时，该类只允许被继承，不能在包含它的类外被实例化：

类型兼容性

readonly

参数属性

存取器

静态属性

抽象类&抽象方法

抽象类

抽象方法

类的类型

ES6的new.target属性

相关文章

TypeScript（三）类

如何在TypeScript中定义类并进行调用

TypeScript——类

Typescript —— 类

TypeScript类

TypeScript类

typescript 类

TypeScript 类

TypeScript——类

TypeScript -- 类

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

JavaScript 进阶营

TypeScript