# 比继承家业还要简单的JS继承题_封装篇|博客系列

> 本文系统讲解了JavaScript面向对象三大特性之一的封装，涵盖ES6前后的封装方法、构造函数与class的用法，并通过17道精选题目帮助读者深入理解JS封装机制，为后续学习继承和多态打下坚实基础。

- 原文：https://feinterview.poetries.top/docs/fe-blog-docs/blog-docs/javaScript2/9-%E6%AF%94%E7%BB%A7%E6%89%BF%E5%AE%B6%E4%B8%9A%E8%BF%98%E8%A6%81%E7%AE%80%E5%8D%95%E7%9A%84JS%E7%BB%A7%E6%89%BF%E9%A2%98_%E5%B0%81%E8%A3%85%E7%AF%87
- 来源：前端进阶之旅（feinterview.poetries.top）
- 更新：2025.10.25
- 可见范围：免费部分

---

## JS继承系列介绍

看过文章的小伙伴应该都感觉的出，我比较喜欢针对每个知识点出一些比较**细节的题目**，然后将这些细节连串起来最后组合成大家**最爱的综合题**😄。

该系列主要为了让我们彻底理解`JavaScript`面向对象的三大特性：`封装`、`继承`、`多态`。

`"咦～这三大特性我知道啊，大清都完了你还在这谈"`

啊~ 看到这里你先别着溜，开始的我也是和你一样觉得背背概念，写点小例子就懂了，直到自己给自己出了几道`魔鬼`题，我才发现之前对它们的理解还是不太全面...因此才有了本系列。

系列总目录：

- 封装
  - `ES6`之前的封装-构造函数
  - `ES6`之后的封装-`class`

- 继承
  - 原型链继承
  - 构造继承
  - 组合继承
  - 寄生组合继承
  - 原型式继承
  - `class`中的`extends`继承
- 多态

(在开始写之前本想要一篇文章全部搞定的，但是发现字真太多了，所以才分开来写，而且我终于又可以用我最爱的`绯红`主题了 😄)

这一章节主要是想向大家介绍一下`JS`面向对象的第一大特性-**封装**，也是为了给后面最重要的`继承`打好基础。

题目也不太多，总共17道，算是牛刀小试吧。

通过阅读本章节你可以学习到：

- `ES6`之前的封装-构造函数
- `ES6`之后的封装-`class`

## 前期准备

先来理解一些最最最基本的概念：

（一）

```javascript
// 1. 构造函数
function Cat (name) {
    this.name
}
// 2. 构造函数原型对象
Cat.prototype
// 3. 使用Cat构造函数创建的实例'乖乖'
var guaiguai = new Cat('guaiguai')
// 4. 构造函数的静态方法,名为fn
Cat.fn = function () {}
// 5. 原型对象上的方法,名为fn
Cat.prototype.fn = function () {}
```

![](https://s.poetries.top/gitee/2020/09/163.png)

（二）

`语法糖`的意思是现有技术本可以实现，但是采用某种写法会更加简洁优雅。

比如`class`就是语法糖。

（三）

原型链继承的思维导图

(这个暂时看不懂没关系，在继承那一章节中会讲到)

![](https://s.poetries.top/gitee/2020/09/164.png)

### 封装

把客观事物封装成抽象的类，隐藏属性和方法，仅对外公开接口。

### 1. ES6之前的封装

（虽然以下内容是概念部分，但是对你解题很有帮助哦，请务必仔细阅读它 😁）

都知道`ES6`的`class`实际就是一个语法糖，那么在`ES6`之前，是没有类这个概念的，因此是借助于**原型对象**和**构造函数**来实现。

- 私有属性和方法：只能在构造函数内访问不能被外部所访问(在构造函数内使用`var`声明的属性)
- 公有属性和方法(或实例方法)：对象外可以访问到对象内的属性和方法(在构造函数内使用`this`设置，或者设置在构造函数原型对象上比如`Cat.prototype.xxx`)
- 静态属性和方法：定义在构造函数上的方法(比如`Cat.xxx`)，不需要实例就可以调用(例如`Object.assign()`)

#### 1.1 题目一

(理解**私有属性方法**和**公有属性方法**)

比如我现在想要封装一个生产出猫，名为`Cat`的构造函数。

- 由于猫的`心`和`胃`都是我们肉眼看不见的，所以我把它们设置为私有属性(隐藏起来)
- 并且猫的`心跳`我们也是看不到的，所以我把它设置为私有方法(隐藏起来)
- 然后猫的`毛色`是可以看见的，所以我把它设置为公有属性
- 并且猫`跳起来`这个动作我们是看的到的，所以我把它设置为公有方法

```javascript
function Cat (name, color) {
  var heart = '❤️'
  var stomach = '胃'
  var heartbeat = function () {
    console.log(heart + '跳')
  }

  this.name = name
  this.color = color

  this.jump = function () {
    heartbeat() // 能跳起来表明这只猫是活的,心也就能跳
    console.log('我跳起来了~来追我啊')
  }
}
var guaiguai = new Cat('guaiguai', 'white')
console.log(guaiguai)
guaiguai.jump()
```

上述代码打印出来的应该是：

```
Cat{ name: 'guaiguai', color: 'white', jump: function(){} }
❤️跳
我跳起来了~来追我啊
```

可以看到，我们生产出名字叫做`乖乖`的小猫咪只有这几个属性能访问到(也就是能被肉眼看到)，为公有属性：

- `name`
- `color`
- `jump`

而私有属性，是我们看不到的：

- `heart`
- `somach`
- `heartbeat`

所以如果你想要直接使用它是不能够的：

```
// 私有
console.log(guaiguai.heart) // undefined
console.log(guaiguai.stomach) // undefined
guaiguai.heartbeat() // 报错
```

**小结：**

很好区分：

- 在函数内用`var`定义的就是私有的
- 在函数内用`this`承接的就是公有

#### 1.2 题目二

(理解**静态属性方法**和**公有属性方法**)

我们现在往刚刚的`Cat`构造函数中加些东西。

- 我们需要对`Cat`这个构造函数加一个描述，表明它是用来生产猫的，所以我把`descript`设置为它的静态属性

- 由于一听到猫这种动物就觉得它会卖萌，所以我把`卖萌`这个动作设置为它的静态方法
- 由于猫都会用唾液清洁身体，所以我把`清洁身体`这个动作设置为它的公有方法

```javascript
// 这段是旧代码
function Cat (name, color) {
  var heart = '❤️'
  var stomach = '胃'
  var heartbeat = function () {
    console.log(heart + '跳')
  }

  this.name = name
  this.color = color

  this.jump = function () {
    heartbeat() // 能跳起来表明这只猫是活的,心也就能跳
    console.log('我跳起来了~来追我啊')
  }
}
// 这段是新增的代码
Cat.descript = '我这个构造函数是用来生产出一只猫的'
Cat.actingCute = function () {
  console.log('一听到猫我就想到了它会卖萌')
}
Cat.prototype.cleanTheBody = function () {
  console.log('我会用唾液清洁身体')
}
var guaiguai = new Cat('guaiguai', 'white')

console.log(Cat.descript)
Cat.actingCute()
console.log(guaiguai.descript)
guaiguai.cleanTheBody()
```

上述代码打印出来的应该是：

```
'我这个构造函数是用来生产出一只猫的'
'一听到猫我就想到了它会卖萌'
undefined
'我会用唾液清洁身体'
```

可以看到，我们定义的`descript`和`actingCute`是定义在构造函数`Cat`上的，所以可以直接被`Cat`调用，为静态属性和方法。

但是`descript`和`actingCute`并不能存在于`乖乖`这个实例上，`descript`只是对构造函数`Cat`的描述，并不是对`乖乖`的描述，所以打印出`undefined`。

不过`清洁`身体是定义在原型对象`prototype`中的，属于公有方法(实例方法)，也就是`乖乖`这个实例可以用它来调用。

静态属性和方法：

- `descript`
- `actingCute`

实例(公有)属性和方法：

- `name`
- `color`
- `jump`
- `cleanTheBody`

**小结：**

也很好区分：

- 在构造函数上也就是使用`Cat.xxx`定义的是静态属性和方法
- 在构造函数内使用`this`设置，或者设置在构造函数原型对象上比如`Cat.prototype.xxx`，就是公有属性和方法(实例方法)

（也有小伙伴可能会有疑问，这个`静态属性和方法`是有什么用的啊，感觉我们编码的时候并没有用到过啊。`Really?` 哈哈 😄，`Promise.all()、Promise.race()、Object.assign()、Array.form()`这些不就是吗？）

（至于`实例方法`，想想`push、shift`，它们实际上不是存在于原型对象上的吗？`Array.prototype.push`）

#### 1.3 题目三

（理解**实例自身的属性**和**定义在构造函数原型对象中的属性**的区别）

OK👌你刚刚既然已经说了使用`this.xxx = xxx`的方式和使用`Cat.prototype.xxx = xxx`都是属于实例对象`guaiguai`上的公有属性，那它们是有什么区别吗？

来看这道题我们就能理解它们的区别了：

```javascript
function Cat (name) {
  this.name = name
}
Cat.prototype.prototypeProp = '我是构造函数原型对象上的属性'
Cat.prototype.cleanTheBody = function () {
  console.log('我会用唾液清洁身体')
}
var guaiguai = new Cat('guaiguai')
console.log(guaiguai)
console.log(guaiguai.name)
console.log(guaiguai.prototypeProp)
guaiguai.cleanTheBody()
```

这里输出的结果 🤔️？

```
Cat {name: "guaiguai"}
'guaiguai'
'我是构造函数原型对象上的属性'
'我会用唾液清洁身体'
```

看到没，`name`是使用`this.xxx = xxx`的形式定义的，它能直接让实例`guaiguai`就拥有这个属性。

而`prototypeProp 、cleanTheBody`毕竟是定义在构造函数原型上的，所以并不能出现在实例`guaiguai`上，但是`guaiguai`却能访问和调用它们。

因此我们得出结论：

**定义在构造函数原型对象上的属性和方法虽然不能直接表现在实例对象上，但是实例对象却可以访问或者调用它们**

#### 1.4 题目四

既然我们已经知道了**实例自身的属性**和**定义在构造函数原型对象中的属性**的区别，那么我们一般是如何区分它们的呢？

来看看这里：

```javascript
function Cat (name) {
  this.name = name
}
Cat.prototype.prototypeProp = '我是构造函数原型对象上的属性'
Cat.prototype.cleanTheBody = function () {
  console.log('我会用唾液清洁身体')
}
var guaiguai = new Cat('guaiguai')

for (key in guaiguai) {
  if (guaiguai.hasOwnProperty(key)) {
    console.log('我是自身属性', key)
  } else {
    console.log('我不是自身属性', key)
  }
}
console.log('-分隔符-')
console.log(Object.keys(guaiguai))
console.log(Object.getOwnPropertyNames(guaiguai))
```

这道题中，我分别用了三种方式来获取实例对象`guaiguai`上的属性名：

- `for...in...`
- `Object.keys()`
- `Object.getOwnPropertyNames()`

输出的结果为：

```
'我是自身属性 name'
'我不是自身属性 prototypeProp'
'我不是自身属性 cleanTheBody'
'-分隔符-'
["name"]
["name"]
```

由此可以得出：

- 使用`for...in...`能获取到实例对象自身的属性和原型链上的属性
- 使用`Object.keys()`和`Object.getOwnPropertyNames()`只能获取实例对象自身的属性
- 可以通过`.hasOwnProperty()`方法传入属性名来判断一个属性是不是实例自身的属性

（上面👆的说法其实并不太严谨，因为要建立在可枚举属性的前提下(属性的`enumerable`为`true`)，不过这边我不发散下去了...）

#### 1.5 题目五

下面让我们来做道题，看看你到底有没有掌握上面的知识点呢 😁。

```javascript
function Person (name, sex) {
  this.name = name
  this.sex = sex
  var evil = '我很邪恶'
  var pickNose = function () {
    console.log('我会扣鼻子但不让你看见')
  }
  this.drawing = function (type) {
    console.log('我要画一幅' + type)
  }
}
Person.fight = function () {
  console.log('打架')
}
Person.prototype.wc = function () {
  console.log('我是个人我会wc')
}
var p1 = new Person('lindaidai', 'boy')
console.log(p1.name)
console.log(p1.evil)
p1.drawing('国画')
p1.pickNose()
p1.fight()
p1.wc()
Person.fight()
Person.wc()
console.log(Person.sex)
```

答案：

```
'lindaidai'
undefined
'我要画一幅国画'
Uncaught TypeError: p1.pickNose is not a function
Uncaught TypeError: p1.fight is not a function
'我是个人我会wc'
'打架'
Uncaught TypeError: Person.wc is not a function
undefined
```

解析：

- `name`为公有属性，实例访问它打印出`'lindaidai'`
- `evil`为私有属性，实例访问它打印出`'undefined'`
- `drawing`是共有(实例)方法，实例调用它打印出`'我要画一幅国画'`
- `pickNose`是私有方法，实例调用它会报错，因为它并不存在于实例上
- `fight`是静态方法，实例调用它报错，因为它并不存在于实例上
- `wc`存在于构造函数的原型对象中，使用实例调用它打印出`'我是个人我会wc'`
- `fight`存在于构造函数上，使用构造函数调用它打印出`'打架'`
- `wc`存在于构造函数的原型对象中，并不存在于构造函数中，所以报错
- `sex`为公有(实例)属性，并不存在于构造函数上，使用构造函数访问它为`undefined`

这里大家可能会有一个疑惑点了，为什么最后一个`Person.sex`也会是`undefined`呢？

我明明已经这样写了：

```javascript
function Person (sex) {
	this.sex = sex
}
```

看起来`sex`是定义在`Person`里的呀。

注意了，`this.sex`表示的是给使用构造函数创建的实例上增加属性`sex`，而不是给构造函数本身增加(只有`Person.sex`才是给构造函数上增加属性)。

#### 1.6 题目六

如果我的构造函数和构造函数原型对象上存在相同名称的属性咋办呢 🤔️ ？

```javascript
function Cat () {
  this.color = 'white'
  this.getColor = function () {
    console.log(this.color)
  }
}
Cat.prototype.color = 'black'
var cat = new Cat()
cat.getColor()
```

这里的执行结果为：

```
'white'
```

其实这个很好理解，你原型对象上虽然有一个名叫`color`的属性，但是我实例对象自己就也有一个啊，那我为什么要用你的呢？只有我自己没有，我才会到你那里去拿。

所以这也就引出了另一个经常听到的概念：

**当访问一个对象的属性 / 方法时，它不仅仅在该对象上查找，还会查找该对象的原型，以及该对象的原型的原型，一层一层向上查找，直到找到一个名字匹配的属性 / 方法或到达原型链的末尾（`null`）。**

也就是大名鼎鼎的**原型链查找**。

咱要是没理解没关系哈，一起来看下面一个例子。

#### 1.7 题目七

现在我在`Cat`的原型对象上，还有它原型对象的原型对象上都定义一个叫做`color`的属性。

(原型对象本质也是个对象，所以它的`__proto__`也就是`Object.prototype`)

```javascript
function Cat () {
  this.color = 'white'
  this.getColor = function () {
    console.log(this.color)
  }
}
Cat.prototype.color = 'black'
Object.prototype.color = 'yellow'
Object.prototype.feature = 'cute'
var cat = new Cat()

cat.getColor()
console.log(cat)
console.log(cat.feature)
```

然后让我们来看看结果：

```
'white'
Cat {color: "white", getColor: ƒ}
'cute'
```

看到了不。

`color`这个属性还是以它自身的`white`为主，但是`feature`这个属性没在实例`cat`上吧，所以它就会向上层一层查找，结果在`Object.prototype`中找到了，因此打印出`cute`。

整个过程就是这样：

![](https://s.poetries.top/gitee/2020/09/165.png)

#### 1.8 题目八

`"等会等会，让我缓一下"`

`"wc，我突然就想明白了很多事情！"`

比如下面这种写法：

```javascript
var obj = { name: 'obj' }
console.log(obj.toString())
console.log(obj.hasOwnProperty('name'))
console.log(Object.prototype)
```

为什么我的`obj`中明明就没有`toString()、hasOwnProperty()`方法，但是我却可以调用它。

现在我知道了，原来`obj`本质是个`Object`类型。

使用`var obj = { name: 'obj' }`就相当于是调用了`new Object`：

```javascript
var obj = new Object({ 'name': 'obj' })
```

这样的话，我当然就可以使用`Object.prototype`上的方法啦！

执行结果为：

![](https://s.poetries.top/gitee/2020/09/166.png)

(`obj.toString()`这里的结果为`[object Object]`应该都知道是什么原因吧？)

#### 总结-构造函数

现在在来回头看看那句话：

**把客观事物封装成抽象的类，隐藏属性和方法，仅对外公开接口**

是不是好理解多了呢？

然后让我们对**构造函数配合原型对象**封装来做一个总结吧：

**(一) 私有属性、公有属性、静态属性概念：**

- 私有属性和方法：只能在构造函数内访问不能被外部所访问(在构造函数内使用`var`声明的属性)，见题`1.1`
- 公有属性和方法(或实例方法)：对象外可以访问到对象内的属性和方法(在构造函数内使用`this`设置，或者设置在构造函数原型对象上比如`Cat.prototype.xxx`)，见题`1.2`
- 静态属性和方法：定义在构造函数上的方法(比如`Cat.xxx`)，不需要实例就可以调用(例如`Object.assign()`)

**(二) 实例对象上的属性和构造函数原型上的属性：**

- 定义在**构造函数原型对象上的属性和方法**虽然不能直接表现在实例对象上，但是实例对象却可以访问或者调用它们。(见题`1.3`)
- 当访问一个对象的属性 / 方法时，它不仅仅在该对象上查找，还会查找该对象的原型，以及该对象的原型的原型，一层一层向上查找，直到找到一个名字匹配的属性 / 方法或到达原型链的末尾（`null`）。(见题`1.7`)

**(三) 遍历实例对象属性的三种方法:**

- 使用`for...in...`能获取到实例对象自身的属性和原型链上的属性
- 使用`Object.keys()`和`Object.getOwnPropertyNames()`只能获取实例对象自身的属性
- 可以通过`.hasOwnProperty()`方法传入属性名来判断一个属性是不是实例自身的属性

### 2. ES6之后的封装

在`ES6`之后，新增了`class` 这个关键字。

它可以用来代替构造函数，达到创建“一类实例”的效果。

并且类的数据类型就是**函数**，所以用法上和构造函数很像，直接用`new`命令来配合它创建一个实例。

还有一件事你可能不知道吧，那就是，**类的所有方法都定义在类的prototype属性上面**。

例如：

```javascript
class Cat {
    constructor() {}
    toString () {}
    toValue () {}
}
// 等同于
function Cat () {}
Cat.prototype = {
    constructor() {}
    toString () {}
    toValue () {}
}
```

这个可以看下面👇的题目`2.2`来理解它。

####  2.1 题目一

现在我们将`1.1`的题目换成`class`版本的来看看。

```javascript
class Cat {
  constructor (name, color) {
    var heart = '❤️'
    var stomach = '胃'
    var heartbeat = function () {
      console.log(heart + '跳')
    }

    this.name = name
    this.color = color
    this.jump = function () {
      heartbeat()
     	console.log('我跳起来了~来追我啊')
    }
  }
}
var guaiguai = new Cat('guaiguai', 'white')
console.log(guaiguai)
guaiguai.jump()
```

其实你会发现，当你使用`class`的时候，它会默认调用`constructor`这个函数，来接收一些参数，并构造出一个新的实例对象(`this`)并将它返回，因此它被称为`constructor`构造方法(函数)。

---

> 以上是免费部分。完整内容需要「前端进阶之旅」会员，原文：https://feinterview.poetries.top/docs/fe-blog-docs/blog-docs/javaScript2/9-%E6%AF%94%E7%BB%A7%E6%89%BF%E5%AE%B6%E4%B8%9A%E8%BF%98%E8%A6%81%E7%AE%80%E5%8D%95%E7%9A%84JS%E7%BB%A7%E6%89%BF%E9%A2%98_%E5%B0%81%E8%A3%85%E7%AF%87
