javascript面向對象三大特征之繼承的示例分析

小編給大家分享一下javascript面向對象三大特征之繼承的示例分析，相信大部分人都還不怎么了解，因此分享這篇文章給大家參考一下，希望大家閱讀完這篇文章后大有收獲，下面讓我們一起去了解一下吧！

具體如下：

繼承

在JavaScript中的繼承的實質就是子代可以擁有父代公開的一些屬性和方法，在js編程時，我們一般將相同的屬性放到父類中，然后在子類定義自己獨特的屬性，這樣的好處是減少代碼重復。繼承是面向對象的基礎，是代碼重用的一種重要機制。

——此文整理自 《jQuery 開發從入門到精通》 ，這是本好書，講的很詳細，建議購買閱讀。

繼承的作用

實現繼承的主要作用是：

① 子類實例可以共享超類屬性和方法。
② 子類可以覆蓋和擴展超類屬性和方法。

繼承的分類

在JavaScript中是不支持類的概念，使用構造器機制來實現類的特性。
JavaScript中類的繼承不止一種，主要包括：類繼承(構造函數繼承)，原型繼承，實例繼承，復制繼承，克隆繼承，混合繼承，多重繼承等。

類繼承

類繼承也叫構造函數繼承，其表現形式是在子類中執行父類的構造函數。實現本質：比如把一個構造函數A的方法賦值為另一個構造函數B，然后調用該方法，使構造函數A在構造函數B內部執行，這是構造函數B就擁有了構造函數A中定義的屬性和方法。這就是B類繼承A類。示例如下：

function A(x){
  this.x = x;
  this.say = function() {
   console.log(this.x + ' say');
  }
}
function B(x,y) {
  this.m = A; // 把構造函數A作為一個普通函數引給臨時方法m()
  this.m(x); // 把當前參數作為值傳給構造函數A,并且執行
  delete this.m; // 清除臨時方法
  this.y = y;
  this.call = function(){
   console.log(this.y);
  }
}
// 測試類繼承
var a = new A(1);
var b = new B(2,3);
a.say(); // 1 say
b.say(); // 2 say
b.call(); // 3

上面的實現方式很巧妙對吧，但是這種設計方式太隨意，缺乏嚴密性。嚴禁的設計模式應該考慮到各種可能存在的情況和類繼承關系中的互相耦合性。所以一般我們盡可能把子類自身的方法放在原型里去實現。下面這種創建方式會更好：

function A(x){
 this.x = x;
 this.say = function() {
  console.log(this.x + ' say');
 }
}
function B(x,y){
 this.y = y;
 A.call(this,x); // 在構造函數B內調用超類A,實現綁定，用call來實現借用
}
B.prototype = new A(); // 設置原型鏈，建立繼承關系
B.prototype.constructor = B; // 恢復B的原型對象的構造函數為B,如果不操作就會指向A
B.prototype.gety = function(){ // 給類B添加新的方法
 return this.y;
}
// 測試 類繼承
var a = new A('A');
var b = new B('Bx','By');
a.say(); // A say
b.say(); // Bx say
console.log(b.gety()); // By
console.log(B.prototype.__proto__ === A.prototype); // true;
console.log(b.constructor === B); // true 這里也可以把B中的 B.prototype.constructor = B; 去除，結果為false

在js中實現類繼承，需要設置3點：

① 在子類構造函數結構體內，使用函數call()調用父類構造函數，把子類的參數傳遞給調用函數如上面的例子：A.call(this,x) 這樣子類可以繼承父類的所有屬性和方法。
② 在子類和父類之間建立原型鏈，如上例：B.prototype = new A() 為了實現類的繼承必須保證他們原型鏈上的上下級關系。即設置子類的prototype 屬性指向父類的一個實例即可。
③ 恢復子類原型對象的構造函數， 如上例：B.prototype.constructor = B

在類繼承中，call() 和 apply() 方法被頻繁使用，它們之間的功能和用法都是相同的，唯一區別就是第2個參數類型不同。如果深入，請看前面的文章：https://www.jb51.net/article/166093.htm

此處需要提一下，就是類的構造函數中的成員，一般稱之為本地成員，而類的原型成員就是類的原型中的成員，此處我們只考慮原型中的成員繼承。本地成員繼承可以用call 和 apply。下面我們來看下類繼承的原型成員的繼承封裝函數：

在函數體內，首先定義一個空函數F(),用來實現功能中轉，把它的原型指向父類的原型，把空函數的實例傳遞給子類的原型，這樣就避免了直接實例化父類引發的內存問題，因為實際開發中，父類可能很大，實例化后，會占用很大一部分內存。

// 定義一個繼承函數
function extend(Sub,Sup){ // 有兩個入口參數，Sub是子類，Sup是父類
 var F = function(){}; // 建立一個臨時的構造函數
 F.prototype = Sup.prototype; // 把臨時構造函數的原型指向父類的原型
 Sub.prototype = new F(); // 實例化臨時類，此處相當于把子類的原型指向父類的實例
 Sub.prototype.constructor = Sub; // 恢復子類的構造函數
 Sub.sup = Sup.prototype; // 在子類中定義一個本地屬性存儲超類原型，可避免子類和超類耦合
 if(Sup.prototype.constructor === Object.prototype.constructor) { // 檢測超類構造器是否為Object構造器
  Sup.prototype.constructor = Sup;
 }
}
// 下面定義兩個類用來測試上面的繼承函數
function A(x,y) {
 this.x = x;
 this.y = y;
}
A.prototype.add = function() {
 return (this.x-0) + (this.y-0); // 此處-0 的目的是確保字符串類型可轉成數值型
}
A.prototype.minus = function() {
 return this.x - this.y;
}
function B(x,y) {
 A.apply(this,[x,y]);
}
// 開始實現類繼承中的原型成員繼承
extend(B,A);
// 為了不與A類中的代碼耦合可以單獨為B定義一個同名的add
B.prototype.add = function() {
 return B.sup.add.call(this); // 避免代碼耦合
}
// 測試繼承
var b = new B(1,2);
console.log(b.minus()); // -1
console.log(b.add()); // 3

原型繼承

原型繼承是js中最通用的繼承方式，不用實例化對象，通過直接定義對象，并被其他對象引用，這樣形成的一種繼承關系，其中引用對象被稱為原型對象。

function A(){
 this.color = 'red';
}
function B(){}
function C(){}
B.prototype = new A();
C.prototype = new B();
// 測試原型繼承
var c = new C();
console.log(c.color); // red

原型繼承顯得很簡單，不需要每次構造都調用父類的構造函數，也不需要通過復制屬性的方式就能快速實現繼承。但它也存在一些缺點：

① 每個類型只有一個原型，所以不支持多重繼承
② 不能很好的支持多參數或動態參數的父類，顯得不夠靈活。
③ 占用內存多，每次繼承都需要實例化一個父類，這樣會存在內存占用過多的問題。

實例繼承

實例化類可創建新的實例對象，這個實例對象將繼承類的所有特征。

function Arr() {
 var a = new Array();
 return a;
}
var arr = new Arr();
arr[0] = 1;
arr[1] = 2;
console.log(arr); // [1,2]
console.log(Array.isArray(arr)); // true
console.log(arr instanceof Array); // true
console.log(arr instanceof Arr); // false

通過構造函數中完成對類的實例化操作，然后返回實例對象，這就是實例繼承的由來。實例繼承可實現對所有對象的繼承，包括自定義類，核心對象和DOM對象。但是也有一些缺點

① 實例繼承無法傳遞動態參數，它是封閉在函數體內試下你，不能通過call和apply來實現動態傳參。
② 實例繼承只返回一個對象，不支持多重繼承
③ 實例繼承對象它仍然保持與原對象的實例關系，無法實現繼承對象是封裝類的實例。如：console.log(arr instanceof Arr); // false

復制繼承

復制繼承就是利用for in 遍歷對象成員，逐一復制給另一個對象。通過這種方式來實現繼承。

function A(){
 this.color = 'red';
}
A.prototype.say = function() {
 console.log(this.color);
}
var a = new A();
var b = {};
// 開始拷貝
for(var item in a) {
 b[item] = a[item];
}
// 開始測試
console.log(b.color); // red
b.say(); // red.

我們把它封裝一下：

Function.prototype.extend = function(obj){
 for(item in obj){
  this.constructor.prototype[item] = obj[item];
 }
}
function A(){
 this.color = 'green';
}
A.prototype.say = function(){
 console.log(this.color);
}
// 測試
var b = function(){};
b.extend(new A());
b.say(); // green

復制繼承實際上是通過反射機制復制類對象中的可枚舉屬性和方法來模擬繼承。這種可以實現多繼承。但也有缺點：

① 由于是反射機制，不能繼承非枚舉類型的屬性和方法。對于系統核心對象的只讀方法和屬性也無法繼承。
② 執行效率差，這樣的結構越龐大，低效就越明顯。
③ 如果當前類型包含同名成員，這些成員會被父類的動態復制給覆蓋。
④ 多重繼承中，復制繼承不能清晰描述父類和子類的相關性。
⑤ 在實例化后才能遍歷成員，不夠靈活，也不支持動態參數
⑥ 復制繼承僅僅是簡單的引用賦值，如果父類成員包含引用類型，那么也會帶來很多副作用，如不安全，容易遭受污染等。

克隆繼承

通過對象克隆方式繼承，可以避免賦值對象成員帶來的低效。
為Function對象擴展一個clone方法。該方法可把參數對象賦值給一個空的構造函數的原型對象，然后返回實例化后的對象，這樣該對象就擁有構造哈數包含的所有成員了。

Function.prototype.clone = function(obj){
 function Temp(){};
 Temp.prototype = obj;
 return new Temp();
}
function A(){
 this.color = 'purple';
}
var o = Function.clone(new A());
console.log(o.color); // purple

混合繼承

混合繼承是把多種繼承方式一起使用，發揮各個優勢，來實現各種復雜的應用。最常見的就是把類繼承和原型繼承一起使用。

function A(x,y){
 this.x = x;
 this.y = y;
}
A.prototype.add = function(){
 return (this.x-0) + (this.y-0);
}
function B(x,y){
 A.call(this,x,y);
}
B.prototype = new A();
// 測試
var b = new B(2,1);
console.log(b.x); // 2
console.log(b.add()); // 3

多重繼承

繼承一般包括單向繼承和多向繼承，單向繼承模式較為簡單，每個子類有且僅有一個超類，多重繼承是一個比較復雜的繼承模式。一個子類可擁有多個超類。JavaScript原型繼承不支持多重繼承，但可通過混合模式來實現多重繼承。下面讓類C來繼承類A和類B：

function A(x){
 this.x = x;
}
A.prototype.hi = function(){
 console.log('hi');
}
function B(y){
 this.y = y;
}
B.prototype.hello = function(){
 console.log('hello');
}
// 給Function增加extend方法
Function.prototype.extend = function(obj) {
 for(var item in obj) {
  this.constructor.prototype[item] = obj[item];
 }
}
// 在類C內部實現繼承
function C(x,y){
 A.call(this,x);
 B.call(this,y);
};
C.extend(new A(1));
C.extend(new B(2));
// 通過復制繼承后，C變成了一個對象，不再是構造函數了，可以直接調用
C.hi(); // hi
C.hello(); // hello
console.log(C.x); // 1
console.log(C.y); // 2

一個類繼承另一個類會導致他們之間產生耦合，在js中提供多種途徑來避免耦合的發生如 摻元類

摻元類是一種比較特殊的類，一般不會被實例化或者調用，定義摻元類的目的只是向其他類提供通用的方法。

// 定義一個摻元類
function F(x,y){
 this.x = x;
 this.y = y;
}
F.prototype = {
 getx:function(){
  return this.x;
 },
 gety:function(){
  return this.y;
 }
}
// 原型拷貝函數
function extend(Sub,Sup){ // Sub 子類 ， Sup 摻元類
 for(var item in Sup.prototype){
  if(!Sub.prototype[item]){ // 如果子類沒有存在同名成員
   Sub.prototype[item] = Sup.prototype[item]; // 那么復制摻元類成員到子類原型對象中
  }
 }
}
// 定義兩個子類 A,B
function A(x,y){
 F.call(this,x,y);
}
function B(x,y){
 F.call(this,x,y);
}
// 調用extend函數實現原型屬性，方法的拷貝
extend(A,F);
extend(B,F);
console.log(A.prototype);
// 測試繼承結果
var a = new A(2,3);
console.log(a.x); // 2
console.log(a.getx()); // 2
console.log(a.gety()); // 3
var b = new B(1,2);
console.log(b.x); // 1
console.log(b.getx()); // 1
console.log(b.gety()); // 2

通過此種方式把多個子類合并到一個子類中，就實現了多重繼承。

以上是“javascript面向對象三大特征之繼承的示例分析”這篇文章的所有內容，感謝各位的閱讀！相信大家都有了一定的了解，希望分享的內容對大家有所幫助，如果還想學習更多知識，歡迎關注億速云行業資訊頻道！