Lua 之面向对象编程

Lua 之面向对象编程

Lua并不是为面向对象而设计的一种语言，因此，仅从原生态语法上并不直接支持面向对象编程，但Lua的设计中仍然包含了很多面向对象的思想，理解它们也更有助于理解Lua自身的一些高级机制。

对象

Lua中的table就是一种对象，它可以有函数字段。在面向对象（Object Oriented）编程中，对象的方法（method）通常使用self（或this）参数标识对象自身，在Lua中也可以使用冒号（:）实现类似的功能，如下面的例子：

Account = {balance=0}

function Account:withdraw1(v)
    self.balance = self.balance - v
end

function Account.withdraw2(self, v)
    self.balance = self.balance - v
end

Account:withdraw1(100)
print(Account.balance)
    
Account.withdraw2(Account, 100)
print(Account.balance)

上面的例子中，withdraw1使用了冒号，隐式使用了self参数；而withdraw2使用了点语法，显式使用self参数；

可以看出，冒号的作用是在一个方法定义中添加一个额外的隐藏参数（self），以及在一个方法调用中添加一个额外的实参。

类

在C++、python等这样的OO语言中，使用class的语法来创建object（或instance），即每个对象都是特定类的实例。

而在Lua中没有类的概念，也就是说对象是没有类型的，那么要如何创建多个具有类似行为的对象呢？

答案是通过元表的__index元方法，将一个table的__index元方法设置为另一个table，那么后者的方法就被前者继承了。

一个例子：

Humman = {age=0}

function Humman:SetAge(v) self.age=v end
function Humman:GetAge() return self.age end
    
Chinese = {}
setmetatable(Chinese, {__index = Humman})

Chinese:SetAge(76.3)
print(Chinese:GetAge())

上面的例子中，Chinese会在Humman查找它自己不存在的方法。

甚至可以模仿构造函数的方式来创建对象：

    
class = {doc='hello'}

function class:new(obj)
    obj = obj or {}
    setmetatable(obj, self)
    self.__index = self
    return obj
end

local a1 = class:new()
print(a1.doc)

这里名为class的这个table就充当了类的作用，通过调用它的new方法，就能返回一个跟它具有类似行为的对象，正如例子中所示，a1对象继承了class的所有字段。

继承

在OO编程思想中，另外一个重要的概念就是继承与派生，即允许由父类派生子类，除了继承基类的行为，子类还可以定义自己独有的行为。

Lua中实现这种特性，仍然是利用了__index元方法的性质——仅在自身没有索引字段时，才会使用__index元方法的返回结果。

一个例子：

Humman = {age=0}

function Humman:SetAge(v) self.age=v end
function Humman:GetAge() return self.age end

function Humman:new(obj)
    obj = obj or {}
    setmetatable(obj, self)
    self.__index = self
    return obj
end

Chinese = Humman:new()

function Chinese:SetAge(v) self.age = v*0.9 end

Beijing = Chinese:new{city='bj'}

Beijing:SetAge(70) 
print(Beijing:GetAge()) -- 63

例子中，Chinese继承自Humman，但它重新定义了SetAge方法，而在Beijing这个对象中调用SetAge时，首先查找Chinese，找不到才继续查找 Humman，所以这里，时Chinese的SetAge方法生效了。

上面提供的继承实现思路是将派生类的__index元方法置为代表基类的table，如果要实现多继承，这种方法就不可行了。多继承要求把__index实现为一个函数，它需要遍历所有基类的字段。

一个例子：

parent1 = {a="hello"}
parent2 = {b="world"}

local function search(field, parents)
    for i=1, #parents do
        local v = parents[i][field]
        if v then return v end
    end
end

function createClass(...)

    local c = {}
    local parents = {...}

    setmetatable(c, {__index=function(t, field) return search(field, parents) end} )
    c.__index = c

    function c:new(o)
        o = o or {}
        setmetatable(o, c)
        return o
    end

    return c
end

c = createClass(parent1, parent2)
print(c.a)  -- hello
print(c.b)  -- world

访问权限

我们知道C++的类中，每个成员都有一个访问标签：public、private、protected，通过访问标签来限定对象中每个成员是否对外可见。而通常的做法是将数据成员标记为private，将函数成员标记为public。

前面介绍过Lua的对象是通过table实现的，而table的每个字段都可以直接通过索引访问，因此lua并不打算直接提供对其内部字段访问权限的控制机制。但如果我们一定要让lua对象也实现访问控制，也是有办法的。

一个例子：

function Humman(initialAge)

    local self = {age=initialAge}

    local SetAge = function(v) self.age=v end
    local GetAge = function() return self.age end

    return {GetAge=GetAge, SetAge=SetAge}

end

Chinese = Humman(73)
print(Chinese.GetAge()) -- 73

Chinese.SetAge(80)
print(Chinese.GetAge()) -- 80

上例中，Humman是一个工厂函数，使用它创建了一个Chinese对象。在Humman内部，将类的状态（需要保护的类成员）赋给了一个局部变量，并将类的方法（即类的对外接口）作为一个table返回给了Chinese对象，之后Chinese对象只能通过返回的方法间接操作Humman类的状态，而无法直接访问到它们。

单一方法（single-method）对象

 当对象只有一个方法时，将这个单独的方法作为对象返回。比如，一个具有状态的迭代器就是单一方法对象。

单一方法对象还有一种情况，它根据某个参数来完成不同的操作，实现一个类似调度器的功能，例如：

function newObject(value)

    return function(action, v)
    if action == "get" then return value;
        elseif action == "set" then value = v
        else error("invalid action")
        end
    end
end


d = newObject(0)
print(d("get"))

d("set", 10)
print(d("get"))
                 

上面的例子中，返回的单一方法对象用一个closure。