眾所周知Lua沒有提供原生OOP的基礎，在lua里面是沒有類一說的。但是，我們可以利用LUA內提供的表、__index、MetaTable等的一些技術來實現LUA對OOP的支持。

簡單的對象封裝就是一個含有值屬性和函數屬性的表。

類對象==table;

類對象==屬性+函數；

local Circle = {};

Circle.new = function( radius) -- 構造函數（工廠）

    local self = {}         --返回局部變量

           local _privateRadius = radius;

    -- local _privateRadius,利用閉包的性質，局部變量可以成為這種模式中的私有成員

           self.radius = radius or 1       --直接依附在對象的屬性，都是public的

           self.area = function()

                    return 3.1425* self.radius * _privateRadius

           end

           return self;

end

local c = Circle.new(10)

print(c.area());

print(c:area());

print(c.radius);

1、   簡單明了。

2、   缺點：A：對于類型每一個對象除了要保存屬性的值，還要保存自己的一份函數。在這種方法中，成員函數是重復多余的。因為一個類，函數是公用，所以只要保存一份就OK就行了。B：函數的定義自在new函數里面，不能分散在外面。每調用一次new函數，都會重新構造一次所有成員函數賦給該對象。

3、   實現繼承的方式很丑陋

元表為重定義Lua中任意一個對象(值)的默認行為提供了一種公開入口. 具體的說, Lua中每種類型的值都有都有他的默認操作方式, 如, 數字可以做加減乘除等操作, 字符串可以做連接操作, 函數可以做調用操作, 表可以做表項的取值賦值操作. 他們都遵循這些操作的默認邏輯執(zhí)行, 而這些操作可以通過Metatable來改變. 如, 你可以定義2個表如何相加等.

metatable通過其包含的函數來給所掛接的table定義一些特殊的操作，包括:

Metatable和__index查找步驟：

1、在子表中查找屬性A，存在則直接返回；不存在則：

2、查看當期表T中是否存在元表：不存在直接返回nil

3、若存在元表M：則判斷M中的__index屬性存在；若不存在返回Nil。

4、若存在__index,則根據__index指示的函數或者表查找屬性A，若存在，則返回A值

   若不存在則跳到步奏2。

 

local BaseClass = {};

BaseClass.__index = BaseClass;

function BaseClass:new(x)

local obj = {["x"]=x};

setmetatable(obj,self)

return obj;

end

function BaseClass:OperationBase()

print("BaseClass x  : "..self.x)

end

local  c = BaseClass:new(23)

c:OperationBase()

local DerivedClass = {}

setmetatable(DerivedClass,BaseClass) –實現繼承的關鍵

DerivedClass.__index = DerivedClass

function DerivedClass:new(x,y)

           local obj = BaseClass:new(x)

           obj.y = y;

           setmetatable(obj,DerivedClass)

           return obj;

end

function DerivedClass:OperationDerived()

print("Derived  : x: "..self.x.." y:  "..self.y)

end

local d = DerivedClass:new(444,555)

d:OperationBase()

d:OperationDerived()

在lua中實現多態(tài)是一件相對簡單的事情。因為根據屬性在Metatable和__index查找步驟，而且函數總是 <名字：函數對象>成對存在在元表中。

     v:Operation()函數調用等同 v["Operation"](v)

子類按函數名稱在元表中查找，找到就會返回，所以父類的同名函數沒有被查找。子類的優(yōu)先級總是先于父類同名函數的查找。

function BaseClass:Operation()

print("Polymorphism BaseClass Operation : "..self.x)

end

function DerivedClass:Operation()

print("Polymorphism DerivedClass Operation : "..self.x.." y:  "..self.y)

end

local a = BaseClass:new(2222);

local b = DerivedClass:new(4,5);

local  c = BaseClass:new(23)

local d = DerivedClass:new(444,555)

local mixed = { c , d ,a ,b}

function Polymorphism(d)

for i, v in ipairs(d) do

           v:Operation()          --表現出多態(tài)        

end

end

Polymorphism(mixed)

總的來說，在lua中實現OOP不是難事；但是，lua最初并不是為OOP設計的。Lua的OOP是隨著metatable的引入出現的，metatable被反復的應用。所以，過多的的類層次，或者過多運用lua進行OOP，會導致性能的折損。