Lua的面向对象

Lua语言本身并没有提供面向对象的语法机制，这需要我们自己设计实现一套类的机制。首先，对于面向对象来说，我们至少需要类和对象这两个概念。同时，类至少包含一个用于构造对象的方法。对应到Lua上，就是一个代表类的table，它有一个构造函数，返回代表该类对象的table：

Class = {}
function Class:New()
    local o = {}
    return o
end

local inst = Class:New()

另外，一个类可以定义若干的方法，该类的所有对象都可以调用这个方法。可是返回的对象table和类table实际上并无关联，如何让对象table索引到类table里定义的方法呢？答案是使用metatable。利用__index属性，当对象table找不到方法时，就会去索引类table里的方法：

Class = {}
function Class:New()
    local o = {}
    setmetatable(o, {__index = self})
    return o
end
function Class:A()
    print("hello world!")
end
local inst = Class:New()
inst:A()

运行可以看到hello world正常输出了。

一个类除了定义方法以外，还可以定义一些成员变量，每个对象拥有各自的成员变量，是相互独立的。另外，我们不希望一个类对象可以随便定义新的成员变量或者成员函数。同样地，这里也是用到了metatable，__index属性可以让对象table去索引类table里的成员变量，利用__newindex属性，我们可以对要写入table的key进行检查，当对象想定义不在类table中存在的成员，或者覆盖类table中存在的函数时，可以进行报错提示；而覆盖已经存在于类的成员变量，则在对象table中写入一份新的副本，保证不同对象table的成员变量互相独立：

Class = {}
function Class:New()
    self.var = 1
    local o = {}
    setmetatable(o,
    {
        __index = self,
        __newindex = function(t, k, v)
            if self[k] then
                if type(self[k]) ~= "function" then
                    rawset(t, k, v)
                else
                    print("overriding function in object is forbidden")
                end
            else
                print("declaring new var/function in object is forbidden")
            end
        end
    })
    return o
end
function Class:A()
    print("hello world!")
end
local a = Class:New()
local b = Class:New()
print(a.var, b.var)
a.var = 2
print(a.var, b.var)
b.var = 3
print(a.var, b.var)
a.newvar = 1
b.A = function()
    print("object hello world")
end
print(a.newvar)
b:A()

运行输出的结果如下：

既然有了成员变量，那么在面向对象的机制中，还有一个很重要的访问控制，即我们需要实现private机制，来使得某些成员变量或者成员函数只在这个类内部可见，对象引用它是不可见的。私有函数是比较好实现的，毕竟一个类的所有对象共享一个函数，我们只需要定义该函数为local function，对象就无法访问到它了：

local function PrivateFunc(self)
    print("private func ", self.var)
end

function Class:B()
    PrivateFunc(self)
end

local a = Class:New()
a:B()
a:PrivateFunc()

运行后会报错提示，找不到PrivateFunc这个函数调用，这个函数只能在类的内部进行调用，对象是访问不到的，也就实现了私有函数。

但是对于私有变量来说，实现起来却比较困难，如果我们按照私有函数的方式来做，那么会出现类的所有对象都引用着同一个local变量，虽然对象无法访问到变量本身，但是这个变量一旦发生变化，将会影响到所有对象。它实际上变成了一个static的private变量，这个不是我们想要的。

也许我们想说，可以通过操纵metatable的__index，来禁止对象外部访问私有变量。虽然这样行得通，但是同样的问题没有解决，即这个变量还是一个static变量。

为了让每个对象都拥有各自的私有变量，我们只能将私有变量塞到Class:New()方法中。但是这就引发了另一个问题：就是这个私有变量定义之后，只在Class:New()方法中可见，其他方法也访问不到这个私有变量了。因此，我们还需要将类的其他成员函数的定义全部挪到New方法中，也就是说，从原先所有的对象通过metatable来共享一份成员函数，变成了所有的对象都拥有自己的成员函数：

local Class = {}

function Class:New()
    local o = {}
    o.var = 1
    local pvar = 1

    function o:A()
        print("hello world!")
    end

    function o:setPrivate(newval)
        pvar = newval
    end

    function o:getPrivate()
        return pvar
    end

    setmetatable(o,
    {
        __newindex = function(t, k, v)
            if self[k] then
                if type(self[k]) ~= "function" then
                    rawset(t, k, v)
                else
                    print("overriding function in object is forbidden")
                end
            else
                print("declaring new var/function in object is forbidden")
            end
        end
    })

    return o
end

local a = Class:New()
local b = Class:New()
a.pvar = 1
b.pvar = 1
a:setPrivate(3)
b:setPrivate(2)
print(a:getPrivate())
print(b:getPrivate())

输出如下：

两个对象都无法直接访问到私有变量，而且它们各自拥有各自的私有变量，互不干扰。

接下来，让我们考虑类的继承。由于我们现在实际上有两种实现方式，一种是使用metatable，实现的思路其实也比较直观，就是当类本身找不到方法或者变量时，就往它的父类寻找：

local Class = {}
function Class:New(base)
    self.var = 1

    setmetatable(self,
    {
        __index = base,
    })

    local o = {}
    setmetatable(o,
    {
        __index = self,
        __newindex = function(t, k, v)
            if self[k] then
                if type(self[k]) ~= "function" then
                    rawset(t, k, v)
                else
                    print("overriding function in object is forbidden")
                end
            else
                print("declaring new var/function in object is forbidden")
            end
        end
    })
    return o
end

function Class:A()
    print("hello world!")
end

local Extend = {}
function Extend:New(base)
    -- 注意这里显式传入了self，因为需要的是扩展类信息而不是基类信息
    local o = base and base.New(self) or {}
    return o
end

function Extend:A()
    print("hello from extend")
end

一种是使用闭包，这种情况下，new出来的对象已经包含了这个类的所有信息，那就初始化的时候直接构造的是基类对象而不是空table即可：

local Extend = {}
function Extend:New(base)
    local o = base and base:New() or {}
    function o:A()
        print("hello from extend")
    end
    return o
end

以上讨论的是单继承的情况，那么多继承呢？对于使用metatable的方式，比较简单，直接修改__index方法，让其遍历所有基类，直到查找到第一个符合的为止：

function CreateClass(...)
    local class = {}

    local baseList = { ... }
    setmetatable(class,
    {
        __index = function(_, k)
            for _, base in ipairs(baseList) do
                local v = base[k]
                if v then
                    return v
                end
            end
        end,
    })

    function class:New()
        local o = {}
        setmetatable(o,
        {
            __index = self,
            __newindex = function(t, k, v)
                if self[k] then
                    if type(self[k]) ~= "function" then
                        rawset(t, k, v)
                    else
                        print("overriding function in object is forbidden")
                    end
                else
                    print("declaring new var/function in object is forbidden")
                end
            end
        })
        return o
    end

    return class
end

local Base1 = CreateClass()
function Base1:A()
    print("hello world from base 1")
end

local Base2 = CreateClass()
function Base2:B()
    print("hello world from base 2")
end

local Base3 = CreateClass(Base1, Base2)

local a = Base3:New()
a:A()
a:B()

对于使用闭包的方式，却有点麻烦，因为这种方式类本身是不包含任何具体信息的，需要在调用New方法的时候，先构造出基类对象，将对象里的信息复制填充；不仅如此，由于我们要抽象出一个通用方法，定义类具体的方法，成员只能通过外部参数的形式进行传递：

function CreateClass(template, ...)
    local class = {}
    local baseList = { ... }

    function class:New()
        local o = {}
        for _, base in ipairs(baseList) do
            local bo = base:New()
            for k, v in pairs(bo) do
                if not o[k] then
                    o[k] = v
                end
            end
        end
    
        for k, v in pairs(template) do
            o[k] = v
        end
    
        setmetatable(o,
        {
            __newindex = function(t, k, v)
                if self[k] then
                    if type(self[k]) ~= "function" then
                        rawset(t, k, v)
                    else
                        print("overriding function in object is forbidden")
                    end
                else
                    print("declaring new var/function in object is forbidden")
                end
            end
        })
    
        return o
    end

    return class
end

local Base1 = CreateClass({ A = function() print("hello world from base 1") end })
local Base2 = CreateClass({ B = function() print("hello world from base 2") end })
local Base3 = CreateClass({}, Base1, Base2)

local a = Base3:New()
a:A()
a:B()

这种方式，用起来其实有点复杂了。

云风在博客中提到了另外一种lua实现面向对象的做法：

local _class={}
 
function class(super)
	local class_type={}
	class_type.ctor=false
	class_type.super=super
	class_type.new=function(...) 
			local obj={}
			do
				local create
				create = function(c,...)
					if c.super then
						create(c.super,...)
					end
					if c.ctor then
						c.ctor(obj,...)
					end
				end
 
				create(class_type,...)
			end
			setmetatable(obj,{ __index=_class[class_type] })
			return obj
		end
	local vtbl={}
	_class[class_type]=vtbl
 
	setmetatable(class_type,{__newindex=
		function(t,k,v)
			vtbl[k]=v
		end
	})
 
	if super then
		setmetatable(vtbl,{__index=
			function(t,k)
				local ret=_class[super][k]
				vtbl[k]=ret
				return ret
			end
		})
	end
 
	return class_type
end

这里有个小小的优化，就是把访问过的字段缓存到vtbl中，避免频繁调用元方法。

如果你觉得我的文章有帮助，欢迎关注我的微信公众号（大龄社畜的游戏开发之路）^-