JavaScript面向对象三个基本特征实例详解【封装、继承与多态】

本文实例讲述了javascript面向对象三个基本特征。分享给大家供大家参考，具体如下：

了解过面向对象的同学应该都知道，面向对象三个基本特征是：封装、继承、多态，但是对于这三个词具体可能不太了解。对于前端来讲接触最多的可能就是封装与继承，对于多态来说可能就不是那么了解了。

封装

在说封装之先了解一下封装到底是什么？

什么是封装

封装：将对象运行所需的资源封装在程序对象中——基本上，是方法和数据。对象是“公布其接口”。其他附加到这些接口上的对象不需要关心对象实现的方法即可使用这个对象。这个概念就是“不要告诉我你是怎么做的，只要做就可以了。”对象可以看作是一个自我包含的原子。对象接口包括了公共的方法和初始化数据。（节选自百度百科）

我对于封装的理解，可能还有一个步骤就是抽离，首先你要清楚在一个对代码中你应该抽离那些属性方法，有了这些为基础才能更好的做好封装。

封装无非就是其属性和方法封装。

1. 类：封装对象的属性和行为
2. 方法：封装具体逻辑功能
3. 访问封装：访问修饰封装无非就是对其访问权限进行封装

class employees {
  constructor(name,age){
    this.name = name;
    this.age = age;
  }
  getinfo(){
    let {name,age} = this;
    return {name,age};
  }
  static seyhi(){
    console.log("hi");  
  }
}

let lisi = new employees("aaron",18);
lisi.seyhi();  // lisi.seyhi is not a function
lisi.getinfo(); // {name: "aaron", age: 18}
employees.seyhi(); // hi

在employees中抽出的公共属性有name,age,公共方法有getinfo,seyhi，然而getinfo与seyhi所不同的是seyhi使用了static修饰符，改变其为静态方法，seyhi只属于employees这个类。然而getinfo方法则是属于实例的。

这里使用了static对seyhi方法对其进行了访问权限的封装。

再举一个例子。

promise.then() // promise.then is not a function
let p1 = new promise(() => {})
p1.then(); // promise {<pending>}
promise.all([1]);  // promise {<resolved>: array(1)}

从上面的代码中可以看出promise也使用了static对其方法的访问权限进行了封装。

继承

继承：说到继承并不太陌生，继承可以使得子类具有父类的各种的公有属性和公有方法。而不需要再次编写相同的代码。在令子类别继承父类别的同时，可以重新定义某些属性，并重写某些方法，即覆盖父类别的原有属性和方法，使其获得与父类别不同的功能。（节选自百度百科）

子类继承父类后，子类具有父类属性和方法，然而也同样具备自己所独有的属性和方法，也就是说，子类的功能要比父类多或相同，不会比父类少。

class employees {
  constructor(name){
    this.name = name;
  }
  getname(){
    console.log(this.name)
  }
  static seyhi(){
    console.log("hi");  
  }
}
class java extends employees{
  constructor(name){
    super(name);
  }
  work(){
    console.log("做后台工作");
  }
}
let java = new java("aaron");
java.getname();
java.work();
// java.seyhi();  // java.seyhi is not a function

从上面的例子可以看出继承不会继承父类的静态方法，只会继承父类的公有属性与方法。这一点需要注意。

子类继承之后既拥有了getname方法，同样也拥有自己的worker方法。

多态

多态：按字面的意思就是“多种状态”，允许将子类类型的指针赋值给父类类型的指针。（节选自百度百科）

说白了多态就是相同的事物，一个接口，多种实现，同时在最初的程序设定时，有可能会根据程序需求的不同，而不确定哪个函数实现，通过多态不需要修改源代码，就可以实现一个接口多种解决方案。

多态的表现形式重写与重载。

什么是重写

重写：子类可继承父类中的方法，而不需要重新编写相同的方法。但有时子类并不想原封不动地继承父类的方法，而是想作一定的修改，这就需要采用方法的重写。方法重写又称方法覆盖。（节选自百度百科）

class employees {
  constructor(name){
    this.name = name;
  }
  seyhello(){
    console.log("hello")
  }
  getname(){
    console.log(this.name);
  }
}
class java extends employees{
  constructor(name){
    super(name);
  }
  seyhello(){
    console.log(`hello,我的名字是${this.name},我是做java工作的。`)
  }
}
const employees = new employees("aaron");
const java = new java("leo");
employees.seyhello();  // hello
java.seyhello();  // hello,我的名字是leo,我是做java工作的。
employees.getname();  // aaron
java.getname(); // leo

通过上面的代码可以看出java继承了employees,然而子类与父类中都存在seyhello方法，为了满足不同的需求子类继承父类之后重写了seyhello方法。所以在调用的时候会得到不同的结果。既然子类继承了父类，子类也同样拥有父类的getname方法。

什么是重载

重载就是函数或者方法有相同的名称，但是参数列表不相同的情形，这样的同名不同参数的函数或者方法之间，互相称之为重载函数或者方法。（节选自百度百科）

class employees {
  constructor(arg){
    let obj = null;
    switch(typeof arg)
    {
      case "string":
         obj = new stringemployees(arg);
         break;
      case "object":
         obj = new objemployees(objemployees);
         break;
      case "number":
        obj = new numberemployees(objemployees);
        break;
    }
    return obj;
  }
}
class objemployees {
  constructor(arg){
    console.log("objemployees")
  }
}
class stringemployees {
  constructor(arg){
    console.log("stringemployees")
  }
}
class numberemployees {
  constructor(arg){
    console.log("numberemployees")
  }
}
new employees({})  // objemployees
new employees("123456") // stringemployees
new employees(987654)  // numberemployees

因为javascript是没有重载的概念的所以要自己编写逻辑完成重载。

在上面的代码中定义了employees,objemployees,stringemployees,numberemployees类,在实例化employees的时候在constructor里面进行了判断，根据参数的不同返回不同的对应的类。

这样完成了一个简单的类重载。

总结

1. 封装可以隐藏实现细节，使得代码模块化；
2. 继承可以扩展已存在的代码模块（类），它们的目的都是为了——代码重用。
3. 多态就是相同的事物，调用其相同的方法，参数也相同时，但表现的行为却不同。多态分为两种，一种是行为多态与对象的多态。

在编程的是多多运用这个写思想对其编程时很有用的，能够使你的代码达到高复用以及可维护。

感兴趣的朋友可以使用在线html/css/javascript代码运行工具：http://tools.jb51.net/code/htmljsrun测试上述代码运行效果。