面向对象
>> 把一组数据结构和处理它们的方法组成对象（object），把相同行为的对象归纳为类（class）
>> 通过类的封装（encapsulation）隐藏内部细节
>> 通过继承（inheritance）实现类的特化（specialization）／泛化（generalization）
>> 通过多态（polymorphism）实现基于对象类型的动态分派（dynamic dispatch）
1.lua中的类
lua中其实是没有类的，有的只是表(table)，而类之间的继承也就是将父类的表连到了一起，派生类中没有找到的属性和方法就通过元表查找父类
2.lua中类的属性
classA = {width =10, height=10}
classA={}
classA.width=10
classA.height=10
两种方法都可以，通过点self.width统一调用
3.类方法
[cpp] view plaincopy
function Box:collsion()
– 默认第一个参数隐藏传递self，可以通过self.xxx 调用属性和方法
end
function Box.create(self)
–必须手动传递参数self,否则无法用self.xxx调用属性和方法
end
4.类与元表的用法
- lua查找一个表元素时的规则，其实就是如下3个步骤:
- 4.1.在表中查找，如果找到，返回该元素，找不到则继续
- 4.2.判断该表是否有元表，如果没有元表，返回nil，有元表则继续
- 4.3.判断元表有没有index方法，如果index方法为nil，则返回nil；如果index方法是一个表，则重复1、2、3；如果index方法是一个函数，则返回该函数的返回值
在Lua中，函数的声明和调用可以用”:”和”.”，属性调用全部用点”.”
我们知道，对象由属性和方法组成。LUA中最基本的结构是table，所以需要用table来描述对象的属性。
lua中的function可以用来表示方法。那么LUA中的类可以通过table + function模拟出来。
至于继承，可以通过metetable模拟出来（不推荐用，只模拟最基本的对象大部分时间够用了）。
Lua中的表不仅在某种意义上是一种对象。像对象一样，表也有状态（成员变量）；也有与对象的值独立的本性，特别是拥有两个不同值的对象（table）代表两个不同的对象；一个对象在不同的时候也可以有不同的值，但他始终是一个对象；与对象类似，表的生命周期与其由什么创建、在哪创建没有关系。
1. 初步面向对象
ObjectData = {balance = 0}
function ObjectData.count( v )
– body
print("value is :", v)
end
a = ObjectData
a.count("iCocos")
– value is : iCocos
2. 面向对象模拟
ObjectData = {balance = 100}
function ObjectData.count( self, v )
self.balance = self.balance + v
print("value is :", v, self.balance)
end
a = ObjectData
a.count(a, 99) – 传递self
– value is : 99 199
a:count(99) – 不传self，直接把a作为self传递进入，
– value is : 99 298
Lua中的继承
先来定义一个基类，
使用前面讲的setmetatable来实现基本的元表
local _M = {}
function _M:new(name)
return setmetatable({ name = name}, { __index = _M })
end
function _M:show()
print(self.name .. ": show in parent:")
end
function _M:hello(arg)
print(self.name .. ": hello in parent:" .. tostring(arg))
end
return _M
子类的实现
local parent = require("parent")
local _M = {}
function _M:new()
local obj = parent:new("the child")
local super_mt = getmetatable(obj)
– 当方法在子类中查询不到时，再去父类中去查找。
setmetatable(_M, super_mt)
– 这样设置后，可以通过self.super.method(self, …) 调用父类的已被覆盖的方法。
obj.super = setmetatable({}, super_mt)
return setmetatable(obj, { __index = _M })
end
– 覆盖父类的方法。
function _M:hello()
– 只能使用这种方法调用基类的方法。
self.super.hello(self, "call from child")
print(tostring(self.name) … ": hello in child")
end
return _M
test.lua (使用)
– local parent = require("parent")
local child = require("child")
local c = child:new()
– 从parent继承的show方法
c:show()
– child自己的方法。
c:hello()
执行lua test.lua 后 输出：
the child: show in parent:
the child: hello in parent:call from child
the child: hello in child
- 可以看到：
- show是继承了父类的方法。
- hello是由子类覆盖了，并且在hello中调用了父类的hello方法。