js面向对象三大特性之系列一 封装

面向对象三大特性：封装，继承，多态

1、什么是封装

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

其实封装就是将属性和方法组成一个类的过程就称之为封装；

`封装实现的三种方式：

• new Object()方式
• 工厂模式
• 构造函数
  • 直接将属性、方法写在构造函数内部，实现全部的私有化；
  • 构造函数 + 构造函数的prototype，实现私有+公有的方式；
  • 构造函数 + 构造函数的静态属性方法
• class方式

2、封装的四种方式

• 1、创建对象
• 2、工厂函数
• 3、构造函数
• 4、class类

2.1、创建对象的方式---- new Object()

//普通方式
const Player = new Object();
Player.color = "white";
Player.start = function () {
  console.log("white下棋");
};

2.2、工厂模式 ---- 通过创建一个函数返回一个对象；

//工厂模式
function createObject() {
  const Player = new Object();
  Player.color = "white";
  Player.start = function () {
    console.log("white下棋");
  };
  return Player;
}

let player1 = createObject()

2.3、构造函数方法

2.3.1、普通构造函数的方法

构造函数添加属性和方法实际上也就是通过this添加的属性和方法

function Cat(name,age){
    // 相当于 this = new Object()
    this.name = name
    this.age = age
    this.eat = function(){
        alert("吃老鼠")
    }
}
 
// 实例化
var cat1 = new Cat('王花花',7)
var cat2 = new Cat('李栓但',5)
 
console.log(cat1) 
console.log(cat2)
 
console.log(cat1.eat == cat2.eat) //引用地址不一致，两个实例

输出如下：

通过this方法我们会发现，每次调用 Cat进行实例化时，我们cat1和cat2里的eat方法其实是两个不同的方法，这么说的意思是，在内存当中存在两个eat方法，而非一个。
优点：通过构造函数形式进行封装时好处是彼此之间相互独立，
缺点：但是对于通用的方法每次都新复制一份，占用内存资源

2.3.2、构造函数 + 原型prototype方式

原型prototype方式，能够让实例化的对象所使用的方法直接使用指针指向同一个方法，即能够解决构造函数产生的资源浪费现象

function Catp(name,age){
    this.name = name;
    this.age = age
}
 
Catp.prototype.eat = function(){
    alert("吃老鼠")
}
 
var catp1 = new Catp("王花花",5)
var catp2 = new Catp("李栓但",3)
 
console.log(catp1)
console.log(catp2)
 
console.log(catp1.eat == catp2.eat ) //会发现属于同一个引用，提高了运行效率

输出结果

先说下原型链：每个实例对象（ object ）都有一个私有属性（称之为 __proto__ ）指向它的构造函数的原型对象（prototype ）。该原型对象也有一个自己的原型对象( proto ) ，层层向上直到Object.prototype.__proto__ === null。根据定义，null 没有原型，因此 Object.prototype.__proto__作为这个原型链中的最后一个环节。这整条关系链接就是原型链

比如说：Number类型的原型链：

var num = 100;
//第一个
num.__proto__ === Number.prototype;
//第二个
Number.prototype.__proto__ === Object.prototype;
//第三个，原型链的最顶端
Object.prototype.__proto__ === null

可以看到catp1.eat === catp2.eat， 是true，这就意味着两个实例对象中的eat方法是指向内存中同一个地址的，也就是说eat这个方法只在内存当中创建了一次，以此来节约内存资源。

优点：在prototype上属性与方法成为公用的，只占用一处内存资源 ，节约内存
缺点：在prototype上属性与方法，由于是公用的，某个对象改变其prototype的话，就就会影响到其它对象，缺乏独立性。

总结：
所以 ，对于公用的方法、属性，可以添加在prototype上，但是不要去改变它，否则就会影响到其它由它实例化的对象；
而对于要保持独立性的方法、属性，写在构造函数内部即可；（每次实例化构造函数，都会为构造函数内部的属性、方法重新开辟一个新的内存空间，以保持其的独立性）

2.3.3、构造函数 + 构造函数的静态属性方法：绑定在构造函数上的属性方法，需要通过构造函数访问。

function CatC(name,age) {
    this.name = name;
    this.age = age
}
CatC.eat = function(){    // 静态属性的方式
    alert("吃老鼠")
}
//只有这个类CatC才能访问到eat方法
console.log(CatC.eat) 

//实例化后的对象是访问不到的
let demo = new CatC('Tony',18);
demo.eat()   // 访问不到，undefined
//通过找到实例的构造函数，再行调用eat方法
demo.constructor.eat()

我们在CatC上添加了一个eat方法，这个eat方法只能通过CatC来访问，其实例化后的对象是不能访问到的

优点：创建的属性和方法只会创建一次
缺点：这样创建的实例化的对象是访问不到的，只能通过类的自身访问

2.4、class方式

版权声明：本文为CSDN博主「crq131290x」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/crq131290x/article/details/83582746