1.建構函式實現繼承

程式碼：

  function Parent(username){
    this.username = username;
    this.hello = function(){
      alert(this.username);
    }
  }
  Parent.prototype.bye = function(){
      alert(this.username+": Goodbye!");
    };
  function Child(username,password){
    this.father = Parent;
    this.father(username);//最關鍵的一行
    delete this.father;
//以上3行等價於Parent.call(this,username)或Parent.call(this,[username])
    this.password = password;
    this.world = function(){
      alert(this.password);
    }
  }
  var parent = new Parent("zhangsan");
  var child = new Child("lisi","123456");
  parent.hello();//zhangsan
  child.hello();//lisi
  child.world();//123456
  parent.bye(); //zhangsan ：Goodbye
  child.bye();// Error: child.bye is not a function
 

缺點：由於方法在建構函式內建立，不能做到函式複用而降低效率，並且不能繼承父類的prototype定義的屬性與方法。

2.原型鏈方式:子類通過prototype將所有在父類中通過prototype追加的屬性和方法都追加到Child，從而實現了繼承

程式碼:

function Parent(){
     this.elements=["ul","li","p"];
  }
  Parent.prototype.hello = "hello";
  Parent.prototype.sayHello = function(){
    alert(this.hello);
  }
 
  function Child(){
  }
  Child.prototype = new Parent();//這行的作用是：將Parent中將所有通過prototype追加的屬性和方法都追加到Child，從而實現了繼承
  Child.prototype.world = "world";
  Child.prototype.sayWorld = function(){
    alert(this.world);
  }
  var c = new Child();
  c.sayHello();//hello
  c.sayWorld();//world
  alert(c.elements);//ul,li,p
  c.elements.push("div");
  c.hello="div";
  var c2 = new Child();
  c2.sayHello();//hello
  alert(c2.elements);//ul,li,p,div
 

缺點：由於prototype是各個子類的例項共享的，故對某一個子類prototype中的屬性進行修改，也會體現在所有子類上（如以上程式碼，Child.prototype 繼承了Parent的例項，故Child.prototype.elements為所有Child的例項共享），另外本方法還有一個缺點是不能想超類的建構函式傳引數。
3.組合繼承：結合以上兩種方式，用prototype繼承超類的prototype的屬性、方法，用建構函式繼承超類的例項的屬性、方法。
程式碼：

 function Parent(username){
    this.elements =["li","ul","p"];
    this.username = username;
    this.hello = function(){
      alert(this.username);
    }
  }
  Parent.prototype.hello = "hello";
  Parent.prototype.bye = function(){
      alert(this.username+": Goodbye!");
    };
  function Child(username,password){
    Parent.call(this,[username]);
    this.password = password;
    this.word = function(){
      alert(this.password);
    }
  }
  Child.prototype=new Parent();
  var parent = new Parent("zhangsan");
  var child = new Child("lisi","123456");
  parent.hello();//zhangsan
  child.hello();//lisi
  child.word();//123456
  child.elements.push("div");
  var child2 = new Child("wangwu","111111");
  alert(child2.elements);//ul,li,p
 

缺點：與建構函式模式相比，函式複用問題未解決。
4.寄生式繼承：寄生式繼承是建立一個僅用於封裝繼承過程的函式，該函式在內部以某種方式來增強物件，最後再返回物件。

 var person = {name : "Nicholas", friends :["shelby","Court","Van"],
sayGoodbye :function(){alert("Goodbye");}};
  function createSon(original){  
   var clone = original;//通過呼叫函式建立一個新物件  
   clone.sayHi =function(){ //以某種方式來增強這個物件  
      alert("hi");
   };  
   return clone;//返回這個物件  
  }
var son = createSon(person);  
son.sayHi();//"hi"  
son.sayGoodbye();

缺點：與建構函式模式類似，不能做到函式複用而降低效率。

5.寄生組合式繼承:本質上，就是使用寄生式繼承來繼承超型別的prototype，然後再將結果指定給子型別的prototype。

程式碼：

function inheritPrototype(subType, superType) {
    var prototype = superType.prototype; 
    prototype.constructor = subType; 
    subType.prototype = prototype; 
}
    function Parent(name) {
        this.name = name;
        this.elements=["ul","li","p"];
    }


    Parent.prototype.sayName = function() {
        alert(this.name);
    }


    function Child(name, age) {
        Parent.call(this, name);
        this.age = age;
    }


    inheritPrototype(Child, Parent);
    Child.prototype.sayAge = function() {
        alert(this.age);
    }
     var parent = new Parent("zhangsan");
  var child = new Child("lisi","12");
  parent.sayName ();//zhangsan
  child.sayName ();//lisi
  child.sayAge();//12
  child.elements.push("div");
  var child2 = new Child("wangwu","22");
  child2.sayAge();//22
  alert(child2.elements);//li,ul,p