metatable的介绍：
Lua的table可以模拟面向对象，都得益于metatable的强大之处。在一个table中，如果索引一个元素未能找到，解释器会去该table下的metatable中的__index元素中去寻找，即table.metatable.__index.xxx中寻找。
但是如果要修改table中的元素或赋值操作，但是该元素不存在，那么会在table中创建该元素，而不会去metatable.__index中寻找。
类创建方法的实现方式：
--function.lua
--clone function
function Clone(object)
local lookup_table = {}
local function _copy(object)
if type(object) ~= "table" then
return object
elseif lookup_table[object] then
return lookup_table[object]
end
local new_table = {}
lookup_table[object] = new_table
for key, value in pairs(object) do
new_table[_copy(key)] = _copy(value)
end
return setmetatable(new_table, getmetatable(object))
end
return _copy(object)
end
--class create
class = function (classname, super)
local cls
-- inherited from Lua Object
if super then
cls = Clone(super)
cls.super = super
if not cls.Ctor then
cls.Ctor = function() end
end
else
cls = {Ctor = function() end}
end
cls.__cname = classname
cls.__ctype = 2 -- lua
cls.__index = cls
function cls.New(...)
local instance = setmetatable({}, cls)
instance:Ctor(...)
return instance
end
return cls
end
分析：
1.class方法中两个参数，classname代表的是要创建的类的类名，super代表所创建类的基类。首先class判断是否有supper，如果没有基类，会为本类创建空的构造方法。如果有基类，则调用Clone方法来克隆基类，这里Clone方法会把基类的成员函数映射到派生类里面去。
2.New方法实现：这里会把构造出来的类的实例instance的元表设定成类table自身，并且由于类table自身的__index参数还是类table自身。instance中没有任何成员函数，用instance调用成员函数的时候，本是找不到函数的，但是因为instance里面的元表（metatable）存在即指挥类自身，并且类自身里面还有__index。所以还会去类自身table中的__index中搜索，此时__index还是指向自身，所以自身的成员方法就能找到了。
3.类自身只放成员方法，不能放成员变量，原因如下：
a.由于metatable的原理，即只有读的时候会去metatable中找，写的时候如果instance中没有，不会去索引metatable而是在instance中新增一个。
b.由于继承时候，Ctor构造方法的直接调用者是instance，所以各级构造方法构造的变量都会放到instance中，而非类自身table里。
Lua多实例（一个类可以获取多个类的对象）基类实现：
--object.lua
local Object = class("Object")
return Object
使用方法：
--multi.lua
local Object = require "object"
local Multi = class("Multi", Object)
function Multi:Ctor(...)
--super constructor
Object.Ctor(self)
--class memebers constructor
self.m_mem = 0
end
function Multi:Show()
print(self.m_mem)
end
local instance1 = Multi:New()
instance1:Show()
local instance2 = Multi:New()
instance2:Show()
第一步：用class方法创建multi类继承于Object类。
第二步：派生类multi中的构造方法是Object.Ctor的引用，所以要重新写派生类multi的构造方法。multi类Ctor构造multi的数据时候，首先要在multi中构造父类的数据，所以要在派生类的Ctor中先调用父类的Ctor。这里必须使用Object.Ctor(self)，不能使用Object:Ctor。原理是这样的：调用起源是New方法中instance:Ctor，Object.Ctor(self)是在instance:Ctor中调用的，所以这里的self则是instance。如果写成Object:Ctor，则以后的Ctor参数则变成Object，这样父级的构造方法构造的数据就放不到instance中了。总体来说由于调用Ctor的调用者是instance，所以之后派生链上的所有Ctor方法的参数都是instance，即派生类的实例。
第三步：在super.Ctor调用之后构造派生类的成员变量，即self.m_mem = 0这一行。
第四步：定义multi类的方法Show，注意所有成员方法中的self也是instance，因为外部调用成员方法是用instance:func()的。
总结：类中的所有成员方法，包括Ctor方法和普通方法，调用者都是instance，即类的对象。self自然也是instance而非multi自身。
Lua单实例类（即一个类只能初始化一个对象）的实现：
--singleton.lua
local Object = require "object"
local Singleton = class("Singleton",Object)
function Singleton:GetSingleton(...)
if self._instance == nil then
self._instance = self.New(...)
end
return self._instance
end
return Singleton
分析：此处Singleton为单实例的最高基类，该类中添加的GetSingleton方法的实质作用是在所有以Singleton为基类的方法中都用该方法获取实例（第一次获取则初始化实例），而不用New方法。此方法的调用者是Singleton或派生类本身，所以传入的self也是Singleton或派生类本体，这时要在类本体中添加一个_instance的变量，并调用New来获取一个实例放在此变量中，这便是唯一的实例。
使用方法：
--single.lua
local Singleton = require "singleton"
local Single = class("Single", Singleton)
function Single:Ctor(...)
--super constructor
Singleton.Ctor(self)
--class memebers constructor
self.m_mem = 0
end
function Single:Show()
print(self.m_mem)
end
local instance = Single:GetSingleton()
instance:Show()
派生类的重写构造方法是一样的，初始化实例的时候要用GetSingleton方法而非New方法。
图像解析两种基类的内存表示：
