js面向對象

一. JavaScript面向對象前言

1.1 什麼是對象？

Everything is object （萬物皆對象）。
對象究竟是什麼，咱們能夠從兩個層次來理解。

對象的組成

    方法（有歸屬）－－－－函數（自由的）

 

    屬性（有歸屬）－－－－變量（自由的）

1.對象是單個事物的抽象

           一本書、一輛汽車、一我的均可以是對象，一個數據庫、一張網頁、一個與遠程服務器的鏈接也能夠是對象。當實物被抽象成對象，實物之間的關係就變成了對象之間的關係，從而就能夠模擬現實狀況，針對對象進行編程。

2.對象是一個容器，封裝了屬性(property)和方法(method)

     屬性是對象的狀態，方法是對象的行爲（完成某種任務）。好比，咱們能夠把動物抽象爲animal對象，使用「屬性」記錄具體是那一種動物，使用「方法」表示動物的某種行爲（奔跑、捕獵、休息等等）

在實際開發中，對象是一個抽象的概念，能夠將其簡單理解爲 : 數據集或功能集。

1.2 什麼是面向對象？

面向對象編程是用抽象方式建立基於現實世界模型的一種編程模式。它使用先前創建的範例，包括模塊化，多態和封裝幾種技術。今天，許多流行的編程語言（如Java，JavaScript，C＃，C+ +，Python，PHP，Ruby和Objective-C）都支持面向對象編程（OOP）。

相對於「一個程序只是一些函數的集合，或簡單的計算機指令列表。」的傳統軟件設計觀念而言，面向對象編程能夠看做是使用一系列對象相互協做的軟件設計。 在 OOP 中，每一個對象可以接收消息，處理數據和發送消息給其餘對象。每一個對象均可以被看做是一個擁有清晰角色或責任的獨立小機器。

面向對象程序設計的目的是在編程中促進更好的靈活性和可維護性，在大型軟件工程中廣爲流行。憑藉其對模塊化的重視，面向對象的代碼開發更簡單，更容易理解，相比非模塊化編程方法 1, 它能更直接地分析, 編碼和理解複雜的狀況和過程。

1.2.1 什麼是面向對象編程？

面向對象編程 —— Object Oriented Programming，簡稱 OOP ，是一種編程開發思想。
它將真實世界各類複雜的關係，抽象爲一個個對象，而後由對象之間的分工與合做，完成對真實世界的模擬。
在面向對象程序開發思想中，每個對象都是功能中心，具備明確分工，能夠完成接受信息、處理數據、發出信息等任務。
所以，面向對象編程具備靈活、代碼可複用、高度模塊化等特色，容易維護和開發，比起由一系列函數或指令組成的傳統的過程式編程（procedural programming），更適合多人合做的大型軟件項目。

1.2.2 面向對象與面向過程

• 面向過程就是親力親爲，事無鉅細，面面俱到，步步緊跟，有條不紊
• 面向對象就是找一個對象，指揮得結果
• 面向對象將執行者轉變成指揮者
• 面向對象不是面向過程的替代，而是面向過程的封裝

  注意：面向對象是一種通用思想，並不是只在程序中使用，任何事情均可以使用－－－－公司老闆分配任務

1.3 面向對象的特色

－封裝

對於一些功能相同或者類似的代碼，咱們能夠放到一個函數中去，屢次用到此功能時，咱們只須要調用便可，無需屢次重寫。

　　創造對象的幾種模式：單例模式，工廠模式，構造函數模式,原型模式等。

• 繼承

  子類能夠繼承父類的屬性和方法

• 多態(重載和重寫)
  1. 重載：嚴格意義上說js中沒有重載的功能，不過咱們能夠經過判斷函數的參數的不一樣來實現不一樣的功能來模擬重載。
  2. 重寫：子類能夠改寫父類的屬性和方法

OOA和OOD

    OOA面向對象分析：

        人類起源：單細胞－－－－人，進化過程當中，增長了各類器官，各個器官之間分工協做

        爲何統治世界的是人類？－－－－－精密的分工協做

 

        大規模分工，精密協做

 

    面向對象分析：將大問題拆分紅小問題，並試圖用分工協做來完成的思惟方式。

 

    OOD面向對象設計：

        1.分析模塊後，肯定職責

            大哥招小弟－－端茶倒水，點菸捶背捏腳

 

        2.肯定耦合關係

            肯定通訊關係，如何交流，暗號

            弊端：當耦合達到必定程度時，若是換了一個助理，須要從新耦合，資源消耗太大

 

            高內聚低耦合

 

        3.爲OOP作準備

 

        分析角色特性：

            講師－－－－技術過硬

               －－－－講課技能（口才）

 

            銷售－－－－溝通技巧（口才）

            

            找到角色共同特性－－－－繼承

    

    

    對象如何被髮明的？

        大量信息的處理和加工困難，打包以後，將內容包含在其中。信息傳遞速度更快，效率更高

        

    面向對象和麪向 過程的區別

        面向對象－－先實現功能，再運行。分工協做，同時發生，解決問題。

        面向過程－－一邊實現，一邊運行。效率低下。

    

    面向對象並非程序員發明的。在程序中咱們叫面向對象（OO），在生活中叫分工協做。

 

    思考 > 語法

二. 對象定義的兩種方式

2.1 字面量的方式進行定義

var obj = { name: "Tom ", sex: " man", age:19, run:function(){ console.log("一天跑一千米"); } }

2.2 使用 new Object() 進行定義

var obj = new Object(); obj.name = "Tom "; obj.sex = " man"; obj.age = 19; obj.run = function(){ console.log("一天跑一千米"); }

三. 類和對象

3.1 什麼是類(Class)？

具備相同特性（數據元素）和行爲（功能）的對象的抽象就是類。所以，對象的抽象是類，類的具體化就是對象，也能夠說類的實例是對象，類實際上就是一種數據類型。類具備屬性，它是對象狀態的抽象，用數據結構來描述類的屬性。類具備操做，它是對象行爲的抽象，用操做名和實現該操做的方法來描述。

3.2 類和對象的區別

做爲初學者，容易混淆類和對象的概念。類(Class)是一個抽象的概念，對象則是類的具體實例。好比：人是一個類，司馬遷，李白，杜甫都是對象；首都是一個類，則北京，倫敦，華盛頓，莫斯科都是對象；動物貓是一個類，則Kitty、Grafield 和 Doraemon 都是對象。
咱們能夠說 Kitty 貓的體重是 1.5kg，而不能說貓類的體重是 1.5kg；能夠說李白是詩人，而不能說人類是詩人。狀態是描述具體對象而非描述類的，行爲是由具體對象發出的而非類發出的。

3.3 類和對象的關係

類與對象的關係就如模具和鑄件的關係，類實例化的結果就是對象，而對象的抽象就是類，類描述了一組有相同特性（屬性）和相同行爲的對象

class person{ }//這個是類 $obj = new person();//類的實例化就是對象

四.建立對象的三種方式

4.1 工廠模式，使用簡單的函數建立對象，爲對象添加屬性和方法，而後返回對象

// Class 模板 function Person(name,sex,age){ var obj = {}; obj.name = name; obj.sex = sex; obj.age = age; obj.run = function(){ console.log("天天堅持跑步"); } return obj; } // 實例化 var person1 = Person("Tom","sex",19); //操做 person1.run(); // 輸出結果：天天堅持跑步

4.1.1 工廠模式的優缺點

優勢：
一、 在工廠模式中，用戶只須要知道所要生產的具體東西，無須關心具體的建立過程，甚至不須要具體產品類的類名。
二、 在系統增長新的產品時，咱們只須要添加一個具體產品類和對應的實現工廠，無需對原工廠進行任何修改，很好地符合了「開閉原則」。
缺點：
一、 每次增長一個產品時，都須要增長一個具體類和對象實現工廠，使得系統中類的個數成倍增長，在必定程度上增長了系統的複雜度，同時也增長了系統具體類的依賴。這並非什麼好事。

 

 工廠模式：原料、加工、出廠

    function createPeople (name ,age ,like ){

            var obj = new Object();           //原料

            obj.name = name;                //加工

            obj.age = age;

            obj.like = like;

            obj. show = function (){

                alert( "我叫"+ this.name +",今年" +this .age+ "歲,喜歡"+ this.like)

            };

            return obj;                      //出廠

        }

        var obj = createPeople( "AAA", 23, "LOL");

        var obj2 = createPeople( "BBB", 30, "JAVA");

 

        obj.show();

        obj2.show();

    可是這種工廠模式已經被JS拋棄，

 

    由於JS內置了一種的工廠模式

    function CreatPeople (name ,age ,like ){

            this .name = name;

            this .age = age;

            this .like = like;

            this .show = function (){

                alert( "我叫"+ this.name +",今年" +this .age+ "歲,喜歡"+ this.like);

            }

        }

        var obj = new CreatPeople( "ABC", 20, "PHP");

        var obj2 = new CreatPeople( "QWE", 32, "Python");

        obj.show();

        obj2.show();

    JS內置的工廠模式比傳統的工廠模式更高效，複用性更強。

 

    JS內置的工廠模式叫 構造函數。

4.2 構造函數模式。建立自定義引用類型，能夠像建立內置對象實例同樣使用new操做符，這種方法的缺點是，構造函數的每一個成員都沒法複用，每次建立出的對象都只有私有變量和私有方法，不能實現共用

//構造函數(這裏就建立了一個Class模板) function Person(name,sex,age){ this.name = name; this.sex = sex; this.age = age; this.run = function(){ console.log("天天堅持跑步"); } } // 實例化 ( new Object()) var person1 = new Person("Tom","man",19); //操做 person1.run();// 天天堅持跑步

4.2.1 構造函數的改進

// 構造全局的對象 var action = { run:function(){ console.log("天天堅持跑步"); } } //構造函數 funcction(name,sex,age){ this.name = name; this.sex = sex; this.age = age; this.run = action.run; } //實例化 var person1 = new Person("Tom","man",19); person1.run();

分析： 爲何要改進構造函數？
咱們都知道當實例化一個對象後，那麼這個對象就擁有了模板的屬性和方法，
當咱們使用方法時首先會在內存中開闢一份空間，而後在執行相應的操做。假設咱們實例化一萬個對象，那麼這一萬個對象在執行方法時都要在內存中開闢空間，這樣只會浪費內存的空間，這時若是能用一個操做代替一萬個操做那樣豈不是美哉，因此小編這裏用了一個全局的對象，即便是一萬個對象使用這個方法只會在內存中開闢一份空間。
可是這也有缺點，咱們都知道全局變量和局部變量，全局變量易形成污染而且聲明週期比較長，那麼全局對象也是同樣的，有沒有一種方式能夠不用所有對象呢？固然有，見下面的第三種建立模式

使用Json建立對象

    var obj = {

         name:"admin" ,

         age:23 ,

         like:"LOL" ,

         show:function (){

             alert("我叫" +this.name+ ",今年"+ this.age+"歲,喜歡" +this.like)

         }

    }

    obj.show()

 

使用構造函數建立對象

        fun ction CreatPeople( name,age ,like){

            this.name = name;

             this .age = age;

             this.like = like;

             this. show = function (){

                 alert( "我叫"+this .name+",今年" +this.age +"歲,喜歡" +this .like);

             }

         }

         var obj = new CreatPeople("ABC" ,20, "PHP");

         var obj2 = new CreatPeople("QWE" ,32, "Python");

         obj.show();

 

         obj2.show();

 

 

構造函數和對象的關係

    面向對象－－－－對一個對象進行編程

    構造函數－－－－提供一個對象供你編程

 

    經過構造函數，實現面向對象編程

4.3 原型模式，使用構造函數的prototype屬性來指定共享的屬性和方法，即便用構造函數定義實例屬性，使用原型定義共享的屬性和方法

 

//構造函數 function Person(name,sex,age){ this.name = name; this.sex = sex; this.age = age; } //使用原型對象 Object.prototype Person.prototype.run = function() { console.log("天天堅持跑步"); } //實例化 var person1 = new Person("Tom","man",19); person1.run();// 天天堅持跑步

五.構造函數、原型對象、實例化對象三則的關係

首先先明白幾個屬性：
__proto__: 對象的原型。全部對象都有(包括函數)

prototype:函數的原型對象。只有函數(準確來講是構造函數)纔有

constructor：對象上的一個屬性，默認指向這個原型的構造函數

原型的概念

    在對象中，兩個新建立的函數，是不相等的：

    var obj1 = {

        fn :function (){

            alert( 1);

        }

    }

    var obj2 = {

        fn :function (){

            alert( 1);

        }

    }

    console .log(obj1.fn == obj2.fn);     //false

 

    在構造函數中，一樣屬於兩個新建立的函數，也是不相等的

    function Fn (name ){

        this .name = name;

        this .show = function (){

            alert( this.name);

        }

    }

    var obj1 = new Fn( "AAA");

    var obj2 = new Fn( "BBB");

    console .log(obj1.show== obj2.show);        //false

    

    此時能夠看出構造函數的屢次建立會產生多個同名函數，形成冗餘太多。

    

    利用原型prototype解決。

     function Fn (){}

    console .log(Fn.prototype);

      // constructor表示當前的函數屬於誰

    // __proto__  ==  [[prototype]]，書面用語，表示原型鏈

 

 

     var fn1 = new Object();

    var fn2 = new Object();

    Object.prototype. show = function (){

        alert( 1);

    }

     console .log(fn1.show== fn2.show);     //tu re

    

    此時，任何一個對象的原型上都有了show方法，由此得出，Object.prototype身上的添加的方法，至關於添加到了全部的Object身上。

   

    爲了解決構造函數的冗餘問題，咱們將 屬性寫在構造函數內，方法寫在原型中。這是面向對象的編程格式之一。

    面向對象的編程格式之一：

        1.屬性寫在構造函數內；

        2.方法寫在原型中

        3.構造函數中的this指向當前函數同名對象

       4.原型方法中的this指向當前原型所屬的函數同名對象

 

 

面向對象編程中常見概念深刻解析