• 简介

Lua中table就是一种对象,这句话可以从三个方面来证实。

• table可以像类一样可以拥有独立的状态。
• table可以与对象一样拥有一个独立于其值得标识。
• table与对象一样具有独立与创建者和创建地的生命周期。

这里我们来尝试创建一个银行的账户Account，通过他来简单地实现面向对象

比如说我们创建了一个函数

Account={balance=0}        --余额balance
function Accout.withdraw(v)        --取出操作
  Acoount.balance=Account.blance-v
end

这里创建了一个新的函数。但是有一个问题是这个函数是在全局名称中的。一旦我们发生了

a=Account;
Acoount=nil
a.withdraw(100)  --错误，Acount已经是nil了却还在试图调用Account.balance

便会报错，因为函数中使用的是一个全局对象。所以我们应该创建的是针对每个调用他的对象工作的函数。

function Account.withdraw(self,v)    --self只是一个名字，没有特殊意义
  self.balance=self.balance-v
end

这里我们需要先将要操作的目标传入。而lua为我们提供了一种便捷的写法

function Acount:withdraw(v)
  self.balance-self.balance-v
end

a:withdraw(100)  --调用

冒号的作用是在一个方法中添加一个额外的影藏参数，以及在一个方法调用中添加一个额外的参数。冒号只是一种语法的遍历，并不是引入了什么新的东西。也就是说，冒号只是lua提供的一个语法糖
现在我们来为其创建一个存款的方法deposit

function  Account:deposit(v)
  self.balance=self.balance+v
end

• 1.类

一个类就像是一个创建对象的模具。有些面向对象语言提供了累的概念。这些里每个对象都是某个特定类的实例。（Class A{} A a=new A() a是A类型的一个对象），而lua里却没有这累的概念。table只能自定义自己的行为和形态，不过我们可以使用一些方法来模拟。例如说我们有两个对象a,b要让b成为a的一个原型，只需要创建以下的语句:

setmetatable(a,{__index=b})

之后a就会在b类中查找它没有的操作。我们回到上面Account的例子中，进行一些优化使得无需创建一个额外的table作为Account的元表

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

a=Account:new{balance=0}
a:diposit(100.00)

有一点需要注意的是 我们在创建新对象时，调用的是Account:new(o),这里展开写其实是
Account.new(Account，o)所以里面的self，其实指向的也是Account
这里我们在创建新的对象的时候，新对象额元表设置为Accoount 这样一来，新对象中便可继承Account中的一些行为。调用diposit时，实则是调用的Account中的。这里的展开真正的调用情况是

getmetatable(a).__index.deposit(a,100)

即

Account.deposit(a,100)

这里我们的例子是继承了元表中的方法。其实继承还可以继承一些属性。下面我们具体展开讲继承。

• 2. 继承

```现在来整理一下我们的基类Account

Account={balance=0}

function Account:new(o)
 o=o or {}
 setmetatable(0,self)
 self.__index=self
 return 0
end

function Account:deposit(v)
 balance=balance+v
end

function Account:withdraw(v)
 if v>self.balance then error "insufficient funds" end
 self.balance=self.balance-v
end

现在我们想从当前的类中派生一个子类SpecialAccount使得客户可以透支，先创建一个新的类，从基类中继承已有的操作

SpecialAccount=Account.new()
s=SpecialAccount:new{limit=1000}

这里显示SpecialAccount从Account处继承了new。不过此处的self参数时SpecialAccount。故s中的metatable和__index 指向的都是SpecialAccount。
而SpecialAccount的metatable和__index又指向Account

这里比较混乱，下面来看一个本人自己测试用的例子。

Account={balance=100}
function Account:new(o)
    o=o or {}
    setmetatable(o, self)
    print(self)
    self.__index=    --这里吧__index包一下，输出具体是哪个table进行了调用
    function(t,k)
        print("account run find element key is "..tostring(k)..", now table is "..tostring(t))    
        return self[k]
    end
    return o
end

function Account:deposit(v)
    self.balance=self.balance+v
end

SpecialAccount=Account:new()
S=SpecialAccount:new{}
print(S.balance)
print(S.balance)        --第二次访问，输出S.balance测试访问是否会在S中开辟新空间
S:deposit(100)
print("************************************************")
print(S.balance)
print("************************************************")
print("Account pos in memory is "..tostring(Account))
print("SpecialAccount metatable pos in memory is "..tostring(getmetatable(SpecialAccount)))
print("SpecialAccount pos in memory is"..tostring(SpecialAccount))
print("S metatable pos in memory is"..tostring(getmetatable(S)))
print("S pos in memory is "..tostring(S))

在写这个例子的时候，当时比较疑问的是两点。

1. S表中，一直都没有balance字段。但却给他赋值了并且输出结果也正常。而且该balance字段在有多个SpecialAccount的实例时，各自均是独立的。（之前代码中有过测试，但为了避免输出太多混乱故删除）那么S中的balance字段是什么时候开辟的？
2. 在第一点的基础上，找出内部调用的具体关系和嵌套的关系。

下面我们来对上面的例子进行具体分析。
先对于问题1，我进行了断电测试，先上截图结果。

第一步，当只是对balance进行了两次访问并没有对值进行修改时

在图上我们可以发现几个比较有意思的点

• 此时S{}内是空的，并没有balance字段。
• S的metatable有着嵌套的关系。metatable中还有这一个metatable(下面再讲)
• metatable中，存在balance并且赋予了初值。
• 两次访问输出的值均为100

然后我们继续运行到下一断点

image.png

然后我们将程序运行结束，查看所有的debug

image.png

这里我们发现，当涉及S到对__index的访问时，输出都是两两一对的。
然后我们在查看最后输出三个表的内存地址以及对应的元表，可以看出：
S的元表为SpecialAccount 而SpecialAccount的元表为Account。同理，与metatable同时赋值的__index也相同。
这也就解释了为什么每次调用__index是两两一对的。当S在查找不存在的key -> balance时,由于对__index指向了SpecialAccount，开始在SpecialAccount中进行查找。(第一次调用__index，第一次输出。)而在对SpecialAccount进行查找时，也未找到对应的key(__index第二次输出)。跳转到其__index指向的目标Account，在此处找到对应的值并输出。
而这其中S的balance值 为何出现在表S中呢？ 我们来看上图中存在中间四次输出的时候。但是对应运行的函数是

function Account:deposit(v)
    self.balance=self.balance+v
end

S:deposit(100)

这里有一个比较容易产生误区的是，函数中的self并不是Account，而是S。由于在这里对self.balance。我们发现首先S在分别对deposit和balance进行了查找。最后将找到的值进行计算，然后赋给了self.balance
我们把S:deposit(100)可以展开为

S.__index(S,"deposit").__index(SpecialAccount,"deposit")(100)

而其中self.balance=self.balance+v可以展开为

S["balance"]=S.__index(S,"balance").__index(SpecialAccount,"balance")["balance"]+100

然后我们接着之前的例子讲
我们可以对SpecialAccount继续进行修改，添加借记卡的属性

Account={balance=0}

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

function Account:deposit(v)
 balance=balance+v
end

function Account:withdraw(v)
 if v>self.balance then error "insufficient funds" end
 self.balance=self.balance-v
end

function SpecialAccount:getLimit()
 return self.limit or 0
end

function SpecialAccount:withdraw(v)
 if v-self.balance>=self.getlimit() then
   error"insufficient funds"
 end
 self.balance=self.balance-v
end

lua中的对象有一个特殊的现象，就是无须为指定一种新行为而创建一个新类。如果只有一个对象需要某种特殊的行为，那么可以直接在该对象中实现这个行为。 例如我们现在有一个新的客户H，账户透支额度为余额的百分之十那么只需要如下。

H=SpecialAccount:new
{
  function H:getLimit()
    return self.balance*0.10
  end
}

• 3.多重继承

多重继承以为这一个可以有多个基类，所以无法使用之前一个类中的方法来创建子类，而是需要定义一个特殊的函数。但原理上来说还是大同小异。区别是，我们在__index由原来的赋值为table改为赋值为函数，这个函数回去方位一系列的table从而找到有key所对应的的value

在之前的基础上继续延伸

local function search(k,plist)
    for _,v1 in pairs(plist) do
    local v=v1[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.__index=c
    function c:new(o)
      o=o or {}
      setmetatable(o,c)
      return o
    end

  return c
end
Named={}
function Named:getname()
    return self.name
end
function Named:setname(n)
    self.name=n
end

NamedAccount=createClass(Account,Named)

account=NamedAccount:new{name="paul"}
print(account:getname())

这里的嵌套关系为：
account.metatable -> NamedAccount ->{Account,Named}
account去NamedAccount中寻找对应的值或函数，而NamedAccount则去它内部的plist中遍历，查找自己想要得到值再返回。

由于这项操作有着一定的复杂性，所以这里的集成方法性能不如单一继承。但我们有一种可以改进性能的简单方法，就是讲继承的方法复制到子类之中。修改完成之后的__index方法如下

setmetatable(c,{__index=function(t,k)
  local v=serch(k,parents)
  t[k]=v          --初次访问时保留下来，下次可直接访问
  return v
end})

这样便可加快访问的速度。但缺点是当系统运行后较难修改方法的定义，因为这些修改的方法不会沿着继承体向下传播

4. 私密性

不同于c++等语言，lua在设计对象是，没有提供私密性机制。主要因为lua并不打算构建需要许多程序员长期投入的大型程序，鹅肉念想开发中小型程序，或者是一个更大的系统中的一部分。
Lua的另一项设计目标是灵活性。通过提供给程序员各种元机制，来让他们能够模拟其他的机制。虽然Lua对象的基础设计中没有提供私密性机制。但可以用其它方法来实现对象，从而获得对象的访问控制。
这种做法的基本思想是，通过两个table来表示一个对象。一个table保存对象的状态，另一个保存对象的操作（行为，接口）。对象本身是通过第二个table来访问的。即通过其接口的方法来访问。