Lua中的面向?qū)ο缶幊淘斀?/h1>

 更新時間：2014年09月29日 11:45:50   作者：果凍想  

這篇文章主要介紹了Lua中的面向?qū)ο缶幊淘斀?本文講解了Lua中的類、繼承、多重繼承等內(nèi)容,需要的朋友可以參考下

簡單說說Lua中的面向?qū)ο?/strong>

Lua中的table就是一種對象，看以下一段簡單的代碼：

復(fù)制代碼 代碼如下:

local tb1 = {a = 1, b = 2}
local tb2 = {a = 1, b = 2}
local tb3 = tb1
 
if tb1 == tb2 then
     print("tb1 == tb2")
else
     print("tb1 ~= tb2")
end
 
tb3.a = 3
print(tb1.a)

上述代碼會輸出tb1 ~= tb2。說明兩個具有相同值得對象是兩個不同的對象，同時在Lua中table是引用類型的。我在《Lua中的模塊與包》中也總結(jié)了，我們是基于table來實現(xiàn)的模塊，在table中可以定義函數(shù)，也就是說，每個table對象都可以擁有其自己的操作?？匆欢未a：

復(fù)制代碼 代碼如下:

Account = {balance = 0}
function Account.withDraw(v)
     Account.balance = Account.balance - v
end
 
Account.withDraw(10) -- 調(diào)用函數(shù)
print(Account.balance)

上面的代碼創(chuàng)建了一個新函數(shù)，并將該函數(shù)存入Account對象的withDraw字段中，然后我們就可以調(diào)用該函數(shù)了。不過，在函數(shù)中使用全局名稱Account是一個不好的編程習慣，因為這個函數(shù)只能針對特定對象工作，并且，這個特定對象還必須存儲在特定的全局變量中。如果改變了對象的名稱，withDraw就再也不能工作了。例如以下代碼：

復(fù)制代碼 代碼如下:

a = Account
Account = nil
a.withDraw(100)

這樣就會出現(xiàn)錯誤。我在這里使用Account創(chuàng)建了一個新的對象a，當將Account賦值為nil時，應(yīng)該要對a對象不產(chǎn)生任何影響。但是，由于在函數(shù)withDraw內(nèi)部使用了Account，而不是變量a，所以就出現(xiàn)了錯誤。如果我們將withDraw函數(shù)內(nèi)部的Account.balance = Account.balance – v語句修改為：a.balance = a.balance – v，這樣就不會出現(xiàn)錯誤了。這就表明，當我們需要對一個函數(shù)進行操作時，需要指定實際的操作對象，即這里的a，這就需要一個額外的參數(shù)來表示該操作者，就好比C++中的this一樣，只不過這里將這個關(guān)鍵字換成了self，換完以后的代碼如下：

復(fù)制代碼 代碼如下:

Account = {balance = 0}
function Account.withDraw(self, v)
     self.balance = self.balance - v
end
 
a = Account
Account = nil
a.withDraw(a, 100)
print(a.balance)

這樣再調(diào)用，就不會出現(xiàn)錯誤了。

使用self參數(shù)是所有面向?qū)ο笳Z言的一個核心。大多數(shù)面向?qū)ο笳Z言都對程序員隱藏了self參數(shù)，從而使得程序員不必顯示地聲明這個參數(shù)。Lua也可以，當我們在定義函數(shù)時，使用了冒號，則能隱藏該參數(shù)，那么上述代碼使用冒號來改下，就是下面這個樣子了。

復(fù)制代碼 代碼如下:

Account = {balance = 0}
function Account:withDraw(v) -- 注意這里的冒號":"
     self.balance = self.balance - v
end
 
a = Account
Account = nil
a:withDraw(100) -- 注意這里的調(diào)用時，也需要冒號":"
print(a.balance)

冒號的作用很簡單，就是在方法定義中添加一個額外的隱藏參數(shù)，以及在一個方法調(diào)用中添加一個額外的實參。冒號只是一種語法便利，并沒有引入任何新的東西；如果你愿意，你可以可以不使用self，而是在每次定義一個函數(shù)時，手動的加上self，只要你處理好了self，它們都是一樣的。

這里亂亂的講了一些Lua中的東西，主要還是說了table是一個不一樣的東西，還有self。接下來，就正式進入面向?qū)ο蟮氖澜?。不要忘了，上面總結(jié)的東西是非常有用的。

類

類是什么？一個類就是一個創(chuàng)建對象的模具。例如C++中，每個對象都是某個特定類的實例。在C++中，如果一個類沒有進行實例化，那這個類中對應(yīng)的操作，基本就是一堆“沒有用”的代碼；而Lua則不一樣，即使你不實例化一個“類”，你照樣也可以使用“類”名直接調(diào)用它的方法（對于C++，請忽視靜態(tài)的方法）；這說明Lua中的“類”的概念與C++這種高級語言中類的概念還是有差別的。在Lua中則沒有類的概念，而我們都是通過Lua現(xiàn)有的支持，去模擬類的概念。在Lua中，要表示一個類，只需創(chuàng)建一個專用作其他對象的原型（prototype）。原型也是一種常規(guī)的對象，也就是說我們可以直接通過原型去調(diào)用對應(yīng)的方法。當其它對象（類的實例）遇到一個未知操作時，原型會先查找它。

在Lua中實現(xiàn)原型是非常簡單的，比如有兩個對象a和b，要讓b作為a的原型，只需要以下代碼就可以完成：

復(fù)制代碼 代碼如下:

setmetatable(a, {__index = b})  -- 又是元表，不會的請看前幾篇關(guān)于元表的文章:http://m.dhdzp.com/article/55812.htm

設(shè)置了這段代碼以后，a就會在b中查找所有它沒有的操作。若將b稱為是對象a的“類”，就僅僅是術(shù)語上的變化?，F(xiàn)在我就從最簡單的開始，要創(chuàng)建一個實例對象，必須要有一個原型，就是所謂的“類”，看以下代碼：

復(fù)制代碼 代碼如下:

local Account = {}  -- 一個原型

好了，現(xiàn)在有了原型，那如何使用這個原型創(chuàng)建一個“實例”呢？接著看以下代碼：

復(fù)制代碼 代碼如下:

function Account:new(o)  -- 這里是冒號哦
     o = o or {}  -- 如果用戶沒有提供table，則創(chuàng)建一個
     setmetatable(o, self)
     self.__index = self
     return o
end

當調(diào)用Account:new時，self就相當于Account。接著，我們就可以調(diào)用Account:new來創(chuàng)建一個實例了。再看：

復(fù)制代碼 代碼如下:

local a = Account:new{value = 100} -- 這里使用原型Account創(chuàng)建了一個對象a
a:display()

上面這段代碼是如何工作的呢？首先使用Account:new創(chuàng)建了一個新的實例對象，并將Account作為新的實例對象a的元表。再當我們調(diào)用a:display函數(shù)時，就相當于a.display(a)，冒號就只是一個“語法糖”，只是一種方便的寫法。我們創(chuàng)建了一個實例對象a，當調(diào)用display時，就會查找a中是否有display字段，沒有的話，就去搜索它的元表，所以，最終的調(diào)用情況如下：

復(fù)制代碼 代碼如下:

getmetatable(a).__index(display(a))

a的元表是Account，Account的__index也是Account。因此，上面的調(diào)用也可以使這樣的：

復(fù)制代碼 代碼如下:

Account.display(a)

所以，其實我們可以看到的是，實例對象a表中并沒有display方法，而是繼承自Account方法的，但是傳入display方法中的self確是a。這樣就可以讓Account（這個“類”）定義操作。除了方法，a還能從Account繼承所有的字段。

繼承不僅可以用于方法，還可以作用于字段。因此，一個類不僅可以提供方法，還可以為實例中的字段提供默認值?？匆韵麓a：

復(fù)制代碼 代碼如下:

local Account = {value = 0}
function Account:new(o)  -- 這里是冒號哦
     o = o or {}  -- 如果用戶沒有提供table，則創(chuàng)建一個
     setmetatable(o, self)
     self.__index = self
     return o
end
 
function Account:display()
     self.value = self.value + 100
     print(self.value)
end
 
local a = Account:new{} -- 這里使用原型Account創(chuàng)建了一個對象a
a:display() --(1)
a:display() --(2)

在Account表中有一個value字段，默認值為0；當我創(chuàng)建了實例對象a時，并沒有提供value字段，在display函數(shù)中，由于a中沒有value字段，就會查找元表Account，最終得到了Account中value的值，等號右邊的self.value的值就來源自Account中的value。調(diào)用a:display()時，其實就調(diào)用以下代碼：

復(fù)制代碼 代碼如下:

a.display(a)

在display的定義中，就會變成這樣子：

復(fù)制代碼 代碼如下:

a.value = getmetatable(a).__index(value) + 100

第一次調(diào)用display時，等號左側(cè)的self.value就是a.value，就相當于在a中添加了一個新的字段value；當?shù)诙握{(diào)用display函數(shù)時，由于a中已經(jīng)有了value字段，所以就不會去Account中尋找value字段了。

繼承

由于類也是對象（準確地說是一個原型），它們也可以從其它類（原型）獲得（繼承）方法。這種行為就是繼承，可以很容易的在Lua中實現(xiàn)?，F(xiàn)在我們有一個類（原型，其實在Lua中說類這個概念，還是很別扭的，畢竟用C++的腦袋去想，還是覺的有點奇怪的。）CA：

復(fù)制代碼 代碼如下:

local CA = {value = 0}
 
function CA:new(o)
     o = o or {}
     setmetatable(o, self)
     self.__index = self
     return o
end
 
function CA:display()
     print(self.value)
end
 
function CA:addValue(v)
     self.value = self.value + v
end

現(xiàn)在需要從這個CA類派生出一個子類CLittleA，則需要創(chuàng)建一個空的類，從基類繼承所有的操作：

復(fù)制代碼 代碼如下:

local CLittleA = CA:new()

現(xiàn)在，我創(chuàng)建了一個CA類的一個實例對象，在Lua中，現(xiàn)在CLittleA既是CA類的一個實例對象，也是一個原型，就是所謂的類，就相當于CLittleA類繼承自CA類。再如下面的代碼:

復(fù)制代碼 代碼如下:

local s = CLittleA:new{value1 = 10}

CLittleA從CA繼承了new；不過，在執(zhí)行CLittleA:new時，它的self參數(shù)表示為CLittleA，所以s的元表為CLittleA，CLittleA中字段__index的值也是CLittleA。然后，我們就會看到，s繼承自CLittleA，而CLittleA又繼承自CA。當執(zhí)行s:display時，Lua在s中找不到display字段，就會查找CLittleA；如果仍然找不到display字段，就查找CA，最終會在CA中找到display字段?？梢赃@樣想一下，如果在CLittleA中存在了display字段，那么就不會去CA中再找了。所以，我們就可以在CLittleA中重定義display字段，從而實現(xiàn)特殊版本的display函數(shù)。

多重繼承

說到多重繼承，我在寫C++代碼的時候也用的很少，一般都是使用組合的方式解決的，對于“組合”這個概念不明白的朋友，可以閱讀我的設(shè)計模式系列的文章。既然說到了Lua中的多重繼承，那也總結(jié)一下，順便開拓一下視野和知識面。

實現(xiàn)單繼承時，依靠的是為子類設(shè)置metatable，設(shè)置其metatable為父類，并將父類的__index設(shè)置為其本身的技術(shù)實現(xiàn)的。而多繼承也是一樣的道理，在單繼承中，如果子類中沒有對應(yīng)的字段，則只需要在一個父類中尋找這個不存在的字段；而在多重繼承中，如果子類沒有對應(yīng)的字段，則需要在多個父類中尋找這個不存在的字段。

就像上圖表示一樣，Lua會在多個父類中逐個的搜索display字段。這樣，我們就不能像單繼承那樣，直接指定__index為某個父類，而是應(yīng)該指定__index為一個函數(shù)，在這個函數(shù)中指定搜索不存在的字段的規(guī)則。這樣便可實現(xiàn)多重繼承。這里就出現(xiàn)了兩個需要去解決的問題：

1.保存所有的父類；
2.指定一個搜索函數(shù)來完成搜索任務(wù)。

對于以上的多重繼承，我們來看一段頭疼的代碼：

復(fù)制代碼 代碼如下:

-- 在多個父類中查找字段k
local function search(k, pParentList)
    for i = 1, #pParentList do
        local v = pParentList[i][k]
        if v then
            return v
        end
    end
end
 
function createClass(...)
    local c = {} -- 新類
    local parents = {...}
 
    -- 類在其元表中搜索方法
    setmetatable(c, {__index = function (t, k) return search(k, parents) end})
 
    -- 將c作為其實例的元表
    c.__index = c
 
    -- 為這個新類建立一個新的構(gòu)造函數(shù)
    function c:new(o)
        o = o or {}
        setmetatable(o, self)
 
        -- self.__index = self 這里不用設(shè)置了，在上面已經(jīng)設(shè)置了c.__index = c
        return o
    end
 
    -- 返回新的類（原型）
    return c
end
 
-- 一個簡單的類CA
local CA = {}
function CA:new(o)
    o = o or {}
    setmetatable(o, {__index = self})
    self.__index = self
    return o
end
 
function CA:setName(strName)
    self.name = strName
end
 
-- 一個簡單的類CB
local CB = {}
function CB:new(o)
    o = o or {}
    setmetatable(o, self)
    self.__index = self
    return o
end
 
function CB:getName()
    return self.name
end
 
-- 創(chuàng)建一個c類，它的父類是CA和CB
local c = createClass(CA, CB)
 
-- 使用c類創(chuàng)建一個實例對象
local objectC = c:new{name = "Jelly"}
 
-- 設(shè)置objectC對象一個新的名字
objectC:setName("JellyThink")
local newName = objectC:getName()
print(newName)

代碼雖然頭疼，但是還的繼續(xù)看。首先大體閱讀一下上面的代碼，看不懂不要緊。現(xiàn)在我來解釋上面的代碼。

1.使用createClass創(chuàng)建了一個類（原型），將CA和CB設(shè)置為這個類（原型）的父類（原型）；在創(chuàng)建的這個類（原型）中，設(shè)置了該類的__index為一個search函數(shù)，在這個search函數(shù)中尋找在創(chuàng)建的類中沒有的字段；

2.創(chuàng)建的新類中，有一個構(gòu)造函數(shù)new；這個new和之前的單繼承中的new區(qū)別不大，很好理解；

3.調(diào)用new構(gòu)造函數(shù)，創(chuàng)建一個實例對象，該實例對象有一個name字段；

4.調(diào)用object:setName(“JellyThink”)語句，設(shè)置一個新的名字；但是在objectC中沒有這個字段，怎么辦？好了，去父類找，先去CA找，一下子就找到了，然后就調(diào)用了這個setName，setName中的self指向的是objectC；設(shè)置以后，就相當于修改了objectC字段的name值；

5.調(diào)用objectC:getName()，objectC還是沒有這個字段。找吧，CA也沒有，那就接著找，在CB中找到了，就調(diào)用getName，在getName中的self指向的是objectC。所以，在objectC:getName中返回了objectC中name的值，就是“JellyThink”。

還有什么？什么也沒有了，對于多重繼承，貌似看起來很難，很麻煩，其實也就這么點東西。不懂的話，再來一遍。

我拿什么保護你

我們都知道，在C++或Java中，對于類中的成員函數(shù)或變量都有訪問權(quán)限的。public，protected和private這幾個關(guān)鍵字還認識吧。那么在Lua中呢？Lua中是本身就是一門“簡單”的腳本語言，本身就不是為了大型項目而生的，所以，它的語言特性中，本身就沒有帶有這些東西，那如果非要用這樣的保護的東西，該怎么辦？我們還是“曲線救國”。思想就是通過兩個table來表示一個對象。一個table用來保存對象的私有數(shù)據(jù)；另一個用于對象的操作。對象的實際操作時通過第二個table來實現(xiàn)的。為了避免未授權(quán)的訪問，保存對象的私有數(shù)據(jù)的表不保存在其它的table中，而只是保存在方法的closure中。看一段代碼：

復(fù)制代碼 代碼如下:

function newObject(defaultName)
     local self = {name = defaultName}
     local setName = function (v) self.name = v end
     local getName = function () return self.name end
     return {setName = setName, getName = getName}
end
 
local objectA = newObject("Jelly")
objectA.setName("JellyThink") -- 這里沒有使用冒號訪問
print(objectA.getName())

這種設(shè)計給予存儲在self table中所有東西完全的私密性。當調(diào)用newObject返回以后，就無法直接訪問這個table了。只能通過newObject中創(chuàng)建的函數(shù)來訪問這個self table；也就相當于self table中保存的都是私有的，外部是無法直接訪問的。大家可能也注意到了，我在訪問函數(shù)時，并沒有使用冒號，這個主要是因為，我可以直接訪問的self table中的字段，所以是不需要多余的self字段的，也就不用冒號了。

總結(jié)

這篇文章對Lua中的“面向?qū)ο蟆边M行了一些簡單的總結(jié)，本來Lua就很簡單，我們只是使用了Lua本身的特性去實現(xiàn)一些更高大上的特性，這樣沒有什么不好，有的時候也沒有什么好。要不要用面向?qū)ο蟮倪@些特性，在具體項目中具體分析，至于如何理解面向?qū)ο蟮母拍睿皇沁@里的重點。Lua的面向?qū)ο螅偨Y(jié)到此為止，以后有了實際的項目應(yīng)用，接著總結(jié)，這篇基礎(chǔ)篇的文章，希望對大家有用。

您可能感興趣的文章:

• Lua中的string庫（字符串函數(shù)庫）總結(jié)
• Lua中的函數(shù)（function）、可變參數(shù)、局部函數(shù)、尾遞歸優(yōu)化等實例講解
• Lua中的一些常用函數(shù)庫實例講解
• Lua中的模塊與module函數(shù)詳解
• Lua中的函數(shù)知識總結(jié)
• Lua字符串庫中的幾個重點函數(shù)介紹
• Lua的table庫函數(shù)insert、remove、concat、sort詳細介紹
• Lua中的常用函數(shù)庫匯總
• Lua面向?qū)ο笾惡屠^承
• Lua面向?qū)ο笾嘀乩^承、私密性詳解
• Lua面向?qū)ο缶幊虒W習筆記
• Lua中函數(shù)與面向?qū)ο缶幊痰幕A(chǔ)知識整理

• Lua
• 面向?qū)ο?/a>

相關(guān)文章

• 

  使用Lua編寫Nginx服務(wù)器的認證模塊的方法

  這篇文章主要介紹了使用Lua編寫Nginx服務(wù)器的認證模塊的方法,即諸如當今流行的社交應(yīng)用接入等功能,需要的朋友可以參考下

  2015-06-06
• 

  Lua中的函數(shù)代碼實例

  這篇文章主要介紹了Lua中的函數(shù)代碼實例,本文著重講解函數(shù)的寫法以及一些小知識,需要的朋友可以參考下

  2015-04-04
• 

  Lua函數(shù)與字符串處理簡明總結(jié)

  這篇文章主要介紹了Lua函數(shù)與字符串處理簡明總結(jié),本文總結(jié)了單一參數(shù)、多個參數(shù)、可變參數(shù)、函數(shù)返回值及字符串處理等內(nèi)容,需要的朋友可以參考下

  2014-10-10
• 

  Lua下基本的網(wǎng)絡(luò)編程示例

  這篇文章主要介紹了Lua下基本的網(wǎng)絡(luò)編程示例,包括簡單的服務(wù)器的搭建和相關(guān)web組件的介紹等,需要的朋友可以參考下

  2015-05-05
• 

  舉例說明Lua中元表和元方法的使用

  這篇文章主要介紹了舉例說明Lua中元表和元方法的使用,文中--兩個橫線開始單行的注釋,--[[加上兩個[和]表示多行的注釋--]],需要的朋友可以參考下

  2015-07-07
• 

  使用lua實現(xiàn)php的var_dump()函數(shù)功能

  小編比較熟悉php，所以這篇文章主要介紹了使用lua實現(xiàn)php的var_dump()函數(shù)功能,需要的朋友可以參考下

  2014-11-11
• 

  Lua中的函數(shù)相關(guān)知識點整理匯總

  這篇文章主要介紹了Lua中的函數(shù)相關(guān)知識點整理匯總,包括函數(shù)的參數(shù)傳遞和定義函數(shù)等基本知識,需要的朋友可以參考下

  2015-05-05
• 

  Lua檢測數(shù)組(tabble)中是否包含某個值

  這篇文章主要介紹了Lua檢測數(shù)組(tabble)中是否包含某個值以及l(fā)ua 判斷一個字符是否存在某個數(shù)組兩個方法,需要的朋友可以參考下

  2015-05-05
• 

  OpenResty中正則模式匹配的2種方法詳解

  在 OpenResty 中，同時存在兩套正則表達式規(guī)范：Lua 語言的規(guī)范和 Nginx 的規(guī)范，下面這篇文章主要給大家介紹了關(guān)于OpenResty中正則模式匹配的2種方法，文中通過示例代碼介紹的非常詳細，需要的朋友可以參考下。

  2018-04-04
• 

  Lua教程（四）：函數(shù)詳解

  這篇文章主要介紹了Lua教程（四）：函數(shù)詳解,本文講解了多重返回值、變長參數(shù)、具名實參、閉合函數(shù)、匿名函數(shù)、非全局函數(shù)等內(nèi)容,需要的朋友可以參考下

  2015-04-04

最新評論