javaScript面向對象是什麼？（一）

js就是個面嚮對象語言，一切皆對象

1、什麼是面向對象？

　　簡單點，就這麼說吧。生活中有一些個物品，譬如（哈哈，還想起個譬如）說一個iPhone，咱們也不知道里面的工做原理吧？可是我們會按按鈕呀，用一倆天就會用了， oh my god，不知道原理就會用，好厲害。

　　那麼javaScrip中的自帶方法Date對象都知道吧， 這兄弟有個兒子（閨女也行，你說什麼就是什麼）getMonth的方法，那你知道它是怎麼知道如今是哪一個月嗎？不知道。管他呢，可是me會用

　　其實呢，咱們不須要知道原理就能夠用它的功能，就是面向對象。

　　 其實對象就是一個總體，對外提供一些功能和操做，而你不知道它內部是怎麼操做的。在編程中咱們叫面向對象，在生活中也有，可是叫法不同

　　在編程中，就像jQuery，你知道它的$('div') 怎麼獲取到的DOM對象嗎，不知道。（‘’我知道‘’，‘去一邊去，你是看了源碼。你拆機了，你能不知道？’）只要知道它幹嗎的就行，那他是否是面向對象編程的呢？

2、面向對象特色

一、抽象：抽指把核心的東西抽出來，把與咱們要解決的問題有關的東西拿出來擺在面前 

二、封裝：讓使用對象的人不考慮內部實現，只考慮功能使用  把內部的代碼保護起來，只留出一些個api接口供用戶使用

三、繼承：就是爲了代碼的複用，從父類上繼承出一些方法和屬性，子類也有本身的一些屬性 

四、多態：其實是不一樣對象做用與同一操做產生不一樣的效果。多態的思想其實是把「想作什麼」和「誰去作「分開

3、對象的組成

一、方法   函數：過程、動態的

二、屬性   變量：狀態、靜態的

4、this       當前的方法屬於誰就是誰

例如點擊事件裏的this，其實就是觸發事件的那個dom對象的onclick方法裏的this，固然是人家本身咯

 再好比說一個函數裏的this，這個函數都屬於window的一個方法，固然裏面的this也是window咯

  還有哦，不要在系統對象上面添加屬性和方法，這樣不太好

 那麼在誰身上加呢？在object這個對象身上，別的date呀array呀，這些對象都是有一些個好玩的功能的，

  object也就本身最強大的一個功能就是，沒有功能~~~~ 這樣我們就能夠隨意給他加屬性和方法而不用去想會不會覆蓋了

5、建立對象的方法

一、最基礎的

1 var obj = new Object（）
2 obj.name = 'shizhikai'
3 obj.age = '3歲'
4 obj.showAge = function(){
5   console.log(this.age)  //這個this是誰？知道嗎？ obj 6 }

可是這樣太麻煩，我要寫100我的，那得寫100次。有別的方法嗎？有

二、工廠方式 經過構造函數

function createPerson(name,age){
   // 原料
   var obj=new Object();
   // 加工
   obj.name=name;
   obj.age=age;
   obj.showAge=function() {
      alert(this.age)
   }
   // 出廠
   return obj;
}
var obj1=createPerson("shizhikai",'3歲')
var obj2=createPerson("ni",'18歲');

alert(obj1.showName)//function(){alert(this.name)}
alert(obj2.showName)//function(){alert(this.name)}

結果都同樣可是比較一下：

1 console.log(obj1.showName==obj2.showName) //false

這裏竟然是不同！！這樣的話那我一百個對象就有一百個不同的方法要佔用內充~~~~

 

也就說會有兩種問題：1.  建立對象沒有用到new  感受內心空落落的  2. 方法都不同的話太佔據空間了~~~~

那就去解決

 1 function createPerson(name,age){
 2    // 原料   系統偷偷摸摸作的
 3    // var this=new Object();
 4    // 加工
 5    this.name=name;
 6    this.age=age;
 7    this.showName=function() {
 8       alert(this.name)
 9    }
10    // 出廠   系統偷偷摸摸作的
11    // return this;
12 }
13 
14 var obj1=new createPerson("shizhikai",'3歲')
15 var obj2=new createPerson("ni",'18歲');

這樣的話代碼又少了不少，很爽，並且還有new了，其實就是利用了一個概念，任何函數均可以new一下

譬如

 

function aa(){}
console.log(new aa())  //Object

 

那它就變成對象啦，那它裏面的this就是它new出來的本身啦~~~~

可是這樣仍是有一個問題，

console.log(obj1.showName==obj2.showName) //false

 

還要佔內存

那繼續解決

這裏就要用到面向對象中不得不說的，並且很重要的的東西.prototype 原型~~~

6、.prototype

先來看個例子，好比說有兩個熊，熊大、熊二去偷了同一顆蘋果樹上的蜂蜜窩，熊大偷了後又拿了個蘋果，熊二看見熊大有蘋果就不幹了，去找蘋果樹的理論，爲何他

有我沒有，這就不講道理了吧，畢竟熊大那個蘋果是本身順便拿的，熊二固然沒有了，可是若是說蜂蜜窩就在蘋果上面築的巢話，這樣熊大就不用去拿蘋果了，直接全窩端，哈哈哈。倆只熊都有了呢，皆大歡喜。

 

 

 1 var xiong1=[1,2,3];
 2 var xiong2=[4,5,6];
 3 xiong1.sum=function(){
 4    var result=0;
 5    for(var i=0;i<this.length;i++){
 6       result+=this[i]
 7    }
 8    return result;
 9 }
10 alert(xiong1.sum()) //6
11 alert(xiong2.sum()) //error

就像這個例子，xiong2根本沒有這個方法嘛，想要的話，只能本身去添加咯，再寫一遍

1 xiong2.sum=function(){
2    var result=0;
3    for(var i=0;i<this.length;i++){
4       result+=this[i]
5    }
6    return result;
7 }

這樣仍是麻煩，佔內存

 1 var xiong1=[1,2,3];
 2 var xiong2=[4,5,6];
 3 Array.prototype.sum=function(){
 4    var result=0;
 5    for(var i=0;i<this.length;i++){
 6       result+=this[i]
 7    }
 8    return result;
 9 }
10 
11 alert(xiong1.sum()) //6
12 alert(xiong2.sum()) //15
13 
14 
15 function createPerson(name,age){
16    this.name=name;
17    this.age=age;
18 }
19 createPerson.prototype.showAge=function(){
20    this.showAge=function() {
21       console.log(this.age)
22    }
23 }

那麼上一個知識點的那兩個問題可就都解決了哦~~~

這樣也就發展出一個普遍的一個寫法了哦

用構造函數去寫自有屬性和方法，用原型去寫共有的屬性和方法，這種方式叫混合方式

 

那麼面向對象說完沒？沒有，下節再看吧。我吃飯去了。。。。。。。。。。