1. 90前端首页
  2. 前端开发
  3. JavaScript

TypeScript系列(四)类的初体验

类的介绍

ES6之前Javascript是使用函数和基于原型的继承来实现类的概念。而在Typescript中则可以和ES6及更新的版本中一样使用class 关键字,面向对象的方式使用类。这篇文章,就让我们一起好好了解一下类。

类的定义

类可以有自己的构造函数,属性,以及方法。使用new 构造一个对象的实例。这个过程中会调用类的构造函数,创建一个新对象,并在执行完构造函数后返回这个新对象;

class Animal {
    // 构造函数默认返回Animal对象
    constructor (msg: string) {
        this.name = msg;
    }
    name: string;
    run() {
        console.log(\'run\');
    }
}

let animal = new Animal(\'test\');

这里值得一提的是,虽然我们用的是class关键字来使用类,但是我们还是要明白,这只是高级语法糖而已,其实最终还是基于原型的。类的成员属性都是实例属性,不是在原型上,类的成员方法都是在原型上。以上面的例子说明,name 属性就存在与实例 animal,而方法run则是在原型Animal.prototype上。

类的成员修饰符

类的成员修饰符可以有以下几种,publicprivateprotected以及readonly

public
typescript中,成员默认都是public,也可以明确的写出来。我们可以自由的访问程序里定义为的public成员,包括实例和子类。

private
private的成员不能在类的外部访问。实例和子类中都不行。当在构造函数constructor上加上private修饰符的话,那么这个类既不能被实例化,也不能被继承。

protected
和私有化成员类似,但是受保护的成员可以在子类中访问。当constructor被声明为protected的时候,这个类就不能被实例化,只能被继承,相当于一个基类使用。

readonly
readonly关键字将属性设置为只读的。 只读属性必须在声明时或构造函数里被初始化。

static
使用static修饰符的成员为静态成员,只能通过类名来访问,举个例子:

class People {
    constructor() {
    }
    static name = \'Kobe\';
}
let p = new People();

console.log(p.name) // 会报错,不能通过实例访问
console.log(People.name); // Kobe

参数属性
在构造函数的参数前使用修饰符声明,那么参数属性直接声明一个属性成员,举个例子:

class Foo {
    constructor(public name: string){
    }
}

let f = new Foo(\'Mike\');
// 可以直接访问name属性
console.log(f.name); // Mike

存取器

TypeScript通过getters/setters来截取对对象成员的访问。 能有效的控制对对象成员的访问。只带有get不带有set存取器的属性会被自动推断为readonly

class Student{
    private _name: string;
    get name() {
        return this._name
    }
    set name(value) {
        this._name = value;
        console.log(\'setter: \' + value);
    }
}

let s = new Student();
s.name = \'Tom\'; // setter: Tom
console.log(a.name); // Tom

抽象类

抽象类就是只能被继承,不能实例化的类。使用abstract关键字来定义抽象类和抽象方法。用来抽离事物的共性,实现代码复用和扩展。其中抽象类的方法可以有具体实现,也可以没有,没有的话就必须在子类中实现,比较灵活。然后就是在派生类的构造函数中必须调用 super()。看下面的例子:

abstract class People{
    abstract task(): void; // 必须被实现
    sayHi(): void {
        console.log(\'Hi\');
    }
}

class Student extends People {
    constructor() {
        super();
    }
    
    task(): void {
        console.log(\'learing\');
    }
}

类和接口的关系

接口之间可以相互继承,类之间也可以相互继承。类可以实现接口,接口可以继承类。主要举两个例子说明一下。

接口继承接口

interface People {
    name: string;
}

// 接口继承单个接口
interface Boy extends People {
    classNumber: number;
}

// 接口继承多个个接口, 以 , 分隔
interface Student extends People, Boy {

}
// 对象具有两个`interface`的属性
let stu: Student = {
    name: \'Mike\',
    classNumber: 5
}

接口继承类
这种用法不是很多,相当于接口把类的成员抽象出来,只有成员结构,没有具体实现。

class Component {
    name: string;
    dispaly(): void {
        console.log(\'displaying\');
    }
}

interface Widget extends Component {
    hide(): void;
}

// 类实现接口,必须实现两个方法
class Button implements Widget {
    // name属性也是必须的
    name: string;
    dispaly(): void {
        console.log(\'displaying in Button\');
    }
    hide(): void {
        console.log(\'hiding\');
    }
}

本文来自网络整理,转载请注明原出处:https://blog.csdn.net/weixin_45831283/article/details/104288538

展开阅读全文

发表评论

登录后才能评论