百度搜索一下，给出出的解决方案和学习帖子很多，可是我还是有很多的问题！
（1）什么是面向对象？
（2）lua中怎么实现面向对象？
（3）什么样的实现既简单又能完成我的功能？
（4）一定要按照c++的方式实现类的继承吗？
能力有限，在学习lua面向对象的时候我比较喜欢两种实现方式：
1. 简单粗暴的实现
参考[1]：参考同事的方法，如果借鉴、转载请注明
在lua中，我们知道table是万能的一个类型，当我们用table实现一个基类和子类的时候，他们都是确确实实存在的一个个table，都是有地址的。不会说像c++一样，类定义是类定义，只有new出来才是真正可以使用的，而lua却不是这样。所以，最简单的一种方法就是，每次继承基类的时候，直接copy基类的所有内容，函数除外，其他的成员都重新复制一遍，如果是table的话重新构建一个，并且把内容拷贝过来。代码如下：
--lua面向对象：简单粗暴的实现
function copytable(tbArg)
local tbCollsion = {}
--local的作用域问题
local copy
copy = function (obj)
if type(obj) ~= "table" then
return obj;
end
--检查是否有嵌套循环的table
if tbCollsion[obj] then
return tbCollsion[obj];
end
local tbNew = {}
tbCollsion[obj] = tbNew;
--递归复制
for k, v in pairs(obj) do
tbNew[k] = copy(v);
end
--复制完之后，元表关系也要保留下来
return setmetatable(tbNew, getmetatable(obj))
end
return copy(tbArg);
end
function inherit(tbBase, tbClass)
--复制基类
local tbNew = copytable(tbBase)
local tm = {}
tm.__index = tbClass;
setmetatable(tbNew, tm)
--修改tbBase为tbClass中的成员或者新增加tbClass中的成员
if tbClass then
for k, v in pairs(tbClass) do
tbNew[k] = v
end
end
return tbNew;
end
--使用
local tbObject = {}
local tbFruit = inherit(tbObject)
local tbApple = inherit(tbFruit)
local tbBanana = inherit(tbFruit)
local tbBanana1 = inherit(tbFruit)
local tbBanana2 = inherit(tbFruit, tbBanana1)
优点：
（1）好理解
（2）好用，不会出现共用一个table引用，导致其中一个修改影响了另外一个
（3）共享函数引用
缺点：
（1）真正意义上的面向对象，继承等概念不清晰
（2）一个子类new多个对象的概念是没有的，和继承已经混在了一起，所以如果要实现new多个对象的话，有代码冗余
2. 概念意义上的实现
参考[2]：云风的blog，如果借鉴、转载请注明
这种从概念上实现面向对象的方法做到以下几点：
（1）有类定义和对象的概念，类定义通过new来创建对象，并且同时调用自己的构造函数
（2）子类可以访问基类的成员函数
（3）类定义不能够调用函数（除了new之外），只有对象才能调用函数
（4）构造函数调用有和c++一样的层级关系，先调用父类的构造函数，再调用子类的构造函数
--lua面向对象：概念意义上的实现
local _class={}
function class(super)
local class_type={}
--注意：因为重载了__newindex函数, 所以ctor不要定义为nil
class_type.ctor=false
class_type.super=super
class_type.new=function(...)
local obj={}
--下面的块只做了一件事：依次从父类到当前子类调用构造函数ctor
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
})
--只有定义类修改了__newindex
--vbtl只属于定义类
--new出来的对象共享所有定义类的引用，但独享自己新增加的成员变量
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
说明几点：
（1）只有定义类修改了__newindex
（2）vbtl只属于定义类
（3）new出来的对象共享所有定义类的引用，但独享自己新增加的成员变量
有点：
（1）概念上更加清晰，熟悉c++面向对象的很容易了解这个继承的关系
（2）写法上感觉很牛逼，做到了定义不能调用函数这一点
（3）共享函数引用
缺点：
（1）概念上清晰的成本是要更多的时间去理解
（2）虽然做到了c++类定义和对象上的概念区别，但是还是有多东西没有实现
（3）对象也可以定义自己的函数，这一点就直接打破了区分定义和对象的本源，但是价值还是有的
（4）所有new出来对象共享类定义的引用对象，包括不需要复用的函数和table。由此多个对象共享一个定义的table很是个问题！
* 针对（4），可以通过实现定义的init函数，在init函数给不同的对象初始化不同的数据，即使是table！
参考：
[1]同事
[2]http://blog.codingnow.com/cloud/LuaOO