《TypeScript》入门与精通 - 一文了解TS中的类

}

}

const user = new User();

console.log(user.getName()); // oliver

这段代码中的两个类都没有使用到public，但是实际上，等同于下面这段代码：

class Human {

public name = “oliver”;

public getName() {

return this.name;

}

}

// 使用关键字extends

class User extends Human {

public age = 18;

public getAge() {

return this.age;

}

public getName() {

return super.getName();

}

}

const user = new User();

// 因为是public，所以实例对象也可以使用

console.log(user.getName()); // oliver

也正是因为使用了public这个关键词，所以，我们在实例化后，仍然可以访问类上面的属性和方法；

​

保护类型（protected）

---

保护类型则是介于public和private之间，它代表，它可以被子类继承，但是无法被实例化对象继承，比如：

class Human {

protected name = “oliver”;

public getName() {

return this.name;

}

}

// 使用关键字extends

class User extends Human {

public age = 18;

public getAge() {

return this.age;

}

public getName() {

return super.name; // 正确

}

public getNameFunc() {

return this.name(); // 正确

}

}

const user = new User();

console.log(user.name); // 报错，因为name是protected，无法访问

console.log(user.getName()); // test

实例化对象中无法调用类上定义的protected的属性或方法，但是子类上是能继承的，子类中的使用和public属性没有区别，这个就是protected;

​

小结

---

总的来说：、

• public类型：本类中可以使用，子类中可以使用，实例对象可以使用；

• private类型：本类中可以使用，子类中不能使用，实例对象不可以使用；

• protected类型：本类中可以使用，子类中可以使用，实例对象不可以使用；

如果还不清晰，那么看一个例子：

class Human {

protected name = “oliver”;

private sex = “男”;

public getName() {

return this.name;

}

}

// 使用关键字extends

class User extends Human {

public age = 18;

public getAge() {

return this.age; // 正确

}

public getName() {

return super.name; // 正确，因为是protected，可以被子类调用

}

public getSex() {

return super.sex; // 报错，因为是private，不能被子类调用

}

protected getNameFunc() {

return super.getName(); // 正确，因为是public

}

}

const user = new User();

console.log(user.name); // 报错，因为name是protected，能被子类调用，且无法被实例化对象调用

console.log(user.getName()); // 正确，因为是public

console.log(user.sex; // 报错，因为sex是private，无法被子类调用，也无法被实例化对象调用

构造器

=============================================================

构造器，也就是contructor，它是一种用于创建和初始化class创建的对象的特殊方法，先看个例子：

// 基本写法

class Human {

public name: string;

// 构造器

constructor(name: string) {

this.name = name;

}

}

const user = new Human(“oliver”);

console.log(user.name); // oliver

这里定义了一个类，class，它有一个私有类型的属性name，name的类型是string，并且在构造器中对其进行了初始化，初始化的值来自于new时候传入的参数，另外在TS中是可以简写的，下面这段代码和上例效果完全相同

// 简化写法

class Human {

// 构造器

constructor(public name: string) {}

}

const user = new Human(“oliver”);

console.log(user.name); // oliver

那么，子类能继承到这个属性吗，答案是可以的，先再看下面这一个例子：

class Human {

constructor(public name: string) {}

}

class User extends Human {

getName() {

return this.name;

}

}

const user = new User(“oliver”);

console.log(user.getName()); // oliver

因为是public属性，那么子类是可以继承到name属性的，这么写没问题，那么子类如果也有构造器怎么办？那么再看一个例子：

class Human {

constructor(public name: string) {}

}

class User extends Human {

constructor(public age: number, name: string) {

super(name);

}

getName() {

return this.name;

}

getAge() {

return this.age;

}

}

const user = new User(20, “oliver”);

console.log(user.getName()); // oliver

console.log(user.getAge()); // 20

这个例子中存在子类和父类，两个类都有构造器，特别的是，在子类的构造器constructor中使用了一个super函数，这就有点奇怪了，这个用法和上文中的不一样，上文的用法是super.getName()这种，这里为啥是一个函数，实际上，super在方法中使用，代表的是父类，用法就是类似于super.getName()，而在构造函数中，它就可以用作一个函数，代表的是父类的contructor函数，这样我们就可以将一些初始化的值赋予父类使用了，否则父类没办法接受实例化对象的参数；

​

到这里，又有一个新问题，如果父类的constructor中没有参数，那么怎么使用，实际上这种只要使用一下super就好了，比如：

class Human {}

class User extends Human {

constructor(public age: number, public name: string) {

super();

}

getName() {

return this.name;

}

getAge() {

return this.age;

}

}

const user = new User(20, “oliver”);

console.log(user.getName()); // oliver

console.log(user.getAge()); // 20

Getter和Setter

=======================================================================

getter和setter，主要用途是对私有属性进行读取和设置，可能有同学会问，这个有什么用，既然都设置成私有属性了，那么就是希望不对它进行修改，怎么说呢，实际上是不对的，私有属性的作用却是是为了不将属性直接对外暴露，但是不代表某些情况下不能对他进行修改，因此Getter和Setter还是很有必要的，直接看个例子吧：

class User {

constructor(private _age: number, private _name: string) {}

get name() {

return this._name;

}

get age() {

return this._age;

}

}

const user = new User(20, “oliver”);

console.log(user.name); // oliver

console.log(user.age); // 20

这个就是Getter的用法，例子中定义了两个私有属性_age和_name，另外定义了两个getter，分别获取这两个私有属性，就这么简单，同理Setting也是这么简单；

class User {

constructor(private _age: number, private _name: string) {}

get name() {

return this._name;

}

get age() {

return this._age;

}

set name(value: string) {

this._name = value;

}

set age(value: number) {

this._age = value;

}

}

const user = new User(20, “oliver”);

user.age = 18;

user.name = “demo”;

console.log(user.name); // demo

console.log(user.age); // 18

值得注意的是，Getter和Setter看上去好像是一个方法，但实际上是属性，因此在调用的时候不需要加括号，以及，set中设置return是不会生效的；

静态属性和静态方法

===================================================================

static，这又是一个新的关键词，在MDN上的解释：类（class）通过 static 关键字定义静态方法。不能在类的实例上调用静态方法，而应该通过类本身调用。这些通常是实用程序方法，例如创建或克隆对象的功能。

什么意思呢，简单的说，就是这个方法不能被实例调用，只能在类上调用，讲到这里，有些同学可能会问这个和protected感觉好像，但实际上，这两个可以说完全不是一个东西，举个例子

class User {

protected static name: string;

}

可以看出，私有类型和静态属性是可以并存的，这两者不是一个东西，值得注意的是，所有的访问类型，都是实例化后才生效的，也就是说，如果不实例化而是直接调用，public，private这些没有意义；

​

接着再说上面这段代码，真要去使用的时候会发现报错，提示：静态属性“name”与构造函数“User”的内置属性函数“name”冲突，好家伙，恭喜你，找到一个保留字，不知道为啥，我个人查了许久没有找到答案，网上流传的解释是：static下的name是一个保留词，不能使用（如果有人找到了合理的答案，记得告诉博主）；

​

接着说static，我们还是直接看一个示例吧，题目：有一个构造函数，它只能被new一次，也就是设计模式中的单例模式，很多库文件就是基于单例模式实现的，比如VueX，VueX使用的就是单例模式，只有第一次使用的使用才会注入一个store，如果被多次Vue.use(vuex)，那么它不会被多次覆盖生效，达到的效果如下

解答：

class User {

private static User: User;

private constructor() {}

static init() {

if (!this.User) {

this.User = new User();

}

return this.User;

}

}

const user1 = User.init();

const user2 = User.init();

console.log(user1 === user2); // true

只有第一次调用init的时候才会去进行new，第二次开始，都是将其已经new好的实例返回回去，这样就达到了单例模式；

​

只读属性

==============================================================

好吧，有一个新关键字，readonly，根据字面意思，代表着只读属性，用法也比较简单，直接看例子：

class User {

private readonly name: string;

constructor(name: string) {

this.name = name;

}

}

const user = new User(“oliver”);

user.name = “demo”; // 报错

可以看出，尝试修改的时候会直接报错，只读属性是不允许被修改的；

​

抽象类

=============================================================

关键字：abstract，使用abstract定义的类就是抽象类，抽象类和普通类最大的区别就是抽象类不能被实例化，也就是不能被new，比如：

abstract class Human {}

new Human(); // 报错，无法被实例化

那么抽象类的作用是什么，主要的作用是抽离贡性的东西，比如：

// 抽象类

abstract class Human {

// 抽象类中的抽象方法

abstract getSex(): string;

}

class Man extends Human {

getSex() {

return “男”;

}

}

class Woman extends Human {

getSex() {

return “女”;

}

}

我们定义了一个抽象类Human，他里面有一个抽象方法，规定了所有继承这个抽象类的类都必须包含getSex这个方法，并且这个方法返回的类型是字符串，讲到这里，有的同学可能会问，这个和接口Interface好像， 用法几乎一样，没错，是挺像的，区别在于，抽象类是对类进行共性的剥离，并且抽象类的内部也是可以存在具体实现的功能的代码的，比如：

// 抽象类

abstract class Human {

getPlace(){

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数前端工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Web前端开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上前端开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注：前端）

最后

整理面试题，不是让大家去只刷面试题，而是熟悉目前实际面试中常见的考察方式和知识点，做到心中有数，也可以用来自查及完善知识体系。

《前端基础面试题》，《前端校招面试题精编解析大全》，《前端面试题宝典》，《前端面试题：常用算法》PDF完整版点击这里免费领取

效果低效又漫长，而且极易碰到天花板技术停滞不前！**

因此收集整理了一份《2024年Web前端开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

[外链图片转存中…(img-aKUByuo1-1713609600833)]

[外链图片转存中…(img-zmetqi2Q-1713609600834)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上前端开发知识点，真正体系化！

[外链图片转存中…(img-RhatWNIs-1713609600834)]

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注：前端）

[外链图片转存中…(img-Vj5jrMeh-1713609600834)]

最后

整理面试题，不是让大家去只刷面试题，而是熟悉目前实际面试中常见的考察方式和知识点，做到心中有数，也可以用来自查及完善知识体系。

《前端基础面试题》，《前端校招面试题精编解析大全》，《前端面试题宝典》，《前端面试题：常用算法》PDF完整版点击这里免费领取

[外链图片转存中…(img-x5s6WZSc-1713609600834)]

[外链图片转存中…(img-BnwI94tN-1713609600835)]

[外链图片转存中…(img-QZceogAP-1713609600835)]