TS中的类,你真的了解吗?(中)

479 阅读2分钟

小知识,大挑战!本文正在参与“程序员必备小知识”创作活动。

序言

上文我们基础的了解了一下TS中的类,今天我们来看一下类里面的一些特性

类的访问器

在TS 中,我们可以通过 gettersetter 方法来实现数据的封装和有效性校验

​
let passcode = "Hello TypeScript";
​
class Employee {
  private _fullName: string = "";
​
  get fullName(): string {
    return this._fullName;
  }
​
  set fullName(newName: string) {
    if (passcode && passcode == "Hello TypeScript") {
      this._fullName = newName;
    } else {
      console.log("Error: Unauthorized update of employee!");
    }
  }
}
​
let employee = new Employee();
employee.fullName = "Semlinker";

这里的get, 和set ,与 getter 和 setter

类的继承

继承是一种类与类之间联结的层次模型,指的是一个类(子类)继承另外一个类(父类)的功能,并且可以扩展自己的新功能,通过继承,我们可以实现代码复用。

class father {
  constructor(public name: string) {}
​
  public say(words: string) :void {
    console.log(`${this.name} says:${words}`);  
  }
}
​
class son extends father {
  constructor(name: string) {
    super(name);
    this.say("Learn TypeScript")
  }
}
​
const p2 = new son("coolFish"); 
// 输出: "coolFish says:Learn TypeScript"

我们看上例,父类中有一个say的方法,子类继承父类后,自己没有实现say的方法,但是却可以直接使用。因为继承后,子类拥有了父类中的属性和方法。 在TS 中使用 extends 时,只能继承单个类,但是允许我们实现多个接口(interface)。

interface speak {
   say(words: string) :void 
}
​
interface paly {
  walk(): void;
}
​
class Person implements speak, paly {
  constructor(public name: string) {}
​
  public say(words: string) :void {
    console.log(`${this.name} says:${words}`);  
  }
​
  public walk(): void {
    console.log(`${this.name} walk with feet`);
  }
}

extends 是继承某个类, 继承之后可以使用父类的方法, 也可以重写父类的方法; implements 是实现多个接口,** 接口的方法一般为空的, 必须重写才能使用 **

抽象类

使用 abstract 关键字声明的类,我们称之为抽象类。抽象类不能被实例化,因为它里面包含一个或多个抽象方法。 简单说抽象类就像是接口一样,定义的是一种规范,继承了抽象类的类,需要实现其中的抽象方法才能实例化。

abstract class Person {
  constructor(public name: string){}
​
  abstract say(words: string) :void;
}
​
// Cannot create an instance of an abstract class.(2511)
const lolo = new Person(); // Error
//实现抽象类,实例化class Developer extends Person {
  constructor(name: string) {
    super(name);
  }
  
  say(words: string): void {
    console.log(`${this.name} says ${words}`);
  }
}
​
const lolo = new Developer("lolo");
lolo.say("I love ts!"); // 输出:lolo says I love ts!

类的访问修饰符​

在TS 类型中,我们可以使用 publicprotectedprivate 来描述该类属性和方法的可见性。目的是为了实现oop思想中的封装,确保属性和方法的安全性。

public

见名知意,公有的,就是开放的属性,没有任何限制条件,可以在任何地方访问。

protected

翻译过来是,受保护的,仅可以在当前类,或者这个类的子类中访问,外部不可访问。

private

私有的,很明显代表着只有在当前类的内部,才可以访问,其他地方都无法访问。 ​

接下来我们看个例子来体验一下这三个修饰符的作用

class people {
  constructor(public name: string) {}
​
  public publicSay()  {
    return 'publicSay'  
  }
​
  protected protectedSay() {
    return "protectedSay";
  }
  private privateSay(){
    return 'privateSay'
  }
}
​
class sonOne extends people {
  constructor(name: string) {
    super(name);
 console.log(`${this.protectedSay()}`)
  }
}
class sonTwo extends people {
  constructor(name: string) {
    super(name);
    this.privateSay
  }
}
​
const p1 = new people("one");
p1.publicSay()  // 输出:"publicSay" 
p1.protectedSay()  // 输出:"Property 'protected' does not exist on type 'people'." 
const p2 = new sonOne("two"); // 输出:"protectedSay" 
const p3 = new sonTwo("three"); // 输出:"Property 'privateSay' is private and only accessible within class 'people'." 

我们通过上例的输出,可以知道,共有属性可以在任意地方访问,受保护属性,可以在类与子类中使用,私有属性在子类中访问也会报错。