小知识,大挑战!本文正在参与“程序员必备小知识”创作活动。
序言
上文我们基础的了解了一下TS中的类,今天我们来看一下类里面的一些特性
类的访问器
在TS 中,我们可以通过 getter
和setter
方法来实现数据的封装和有效性校验
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 类型中,我们可以使用 public、protected 或 private 来描述该类属性和方法的可见性。目的是为了实现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'."
我们通过上例的输出,可以知道,共有属性可以在任意地方访问,受保护属性,可以在类与子类中使用,私有属性在子类中访问也会报错。