cocos2d-Lua02Lua面向对象

1 Lua中的面向对象

1.1 问题

lua不是一个面向对象的语言。可是他又有面向对象的思想。

lua中的面向对象是伪面向对象。伪面向对象就要用到table实现。

由table模拟了一个面向对象的编程， table事实上也能够看做是一个对象。和其它语言对象一样有个自身的标示（self），具有自己的生命周期。本案例演示lua中的面向对象。

1.2 方案

首先用table实现面向对象。

然后通过self得到当前lable对象。

接下来通过 : 符号实现声明函数时的隐试參数self。

最后通过require返回对象，调用该对象方法。

1.3 步骤

实现此案例须要依照例如以下步骤进行。

步骤一：用table实现面向对象

首先定义一个table类型的数据Account。然后声明label对象。通过对象调用方法，代码例如以下所看到的：

Accout = {balance = 0}
functionAccout.count( v )
print ("value is "..v)
end
--声明label对象（变量）accout
accout = Accout
--通过对象调用方法
accout.count(1000)

编辑器中的效果如图-13所看到的：

图-13

步骤二：通过self得到当前lable对象

通过对象调用方法。显示的把accout这个table 这个对象传入到函数 (显示的传入 self)，还可通过冒号调用的方式隐试的传入self对象代码例如以下所看到的：

Accout = {balance = 10}
--显示传入self
functionAccout.count( self,  v )
self.balance = self.balance + v;
print ("value is "..self.balance)
end
--声明label对象（变量）accout
accout = Accout
--通过对象调用方法, 显示的把accout这个 table 这个对象传入到函数 (显示的传入 self)
accout.count(accout, 1000)
--还可通过 : 调用的方式隐试的传入 self 对象
accout:count(2000)

编辑器中的效果如图-14所看到的：

图14

步骤三：通过冒号实现声明函数的隐式參数

通过冒号符号隐式传入self。还可通过冒号调用的方式隐式的传入self对象，代码例如以下所看到的：

Accout = { balance = 10}
--通过 : 符号, 隐试传入 self
functionAccout:count( v )
self.balance = self.balance + v;
print ("value is "..self.balance)
end
--声明label对象（变量）accout
accout = Accout
--还可通过 : 调用的方式隐试的传入 self 对象
accout:count(2000)

编辑器中的效果如图-15所看到的：

图-15

步骤四：通过require 返回对象

通过require 返回对象，调用该对象方法，代码例如以下所看到的：

class = require("myClass")
--函数写在 table的括号外
class:showName()
--函数写在 table的括号内
class.show(class)

编辑器中的效果如图-16所看到的：

图-16

-------------》require（“XXX”）  --  仅仅运行一次，避免了反复运行

1.4 完整代码

本案例中。完整代码例如以下所看到的：

--[[lua不是一个面向对象的语言。可是他又有面向对象的思想
lua中的面向对象是伪面向对象，伪面向对象就要用到table实现。
是table模拟了一个面向对象的编程。 table事实上也能够看做是一个对象，
和其它语言对象一样有个自身的标示（self）。具有自己的生命周期。]]
--1.用table实现面向对象
Accout = {balance = 0}
functionAccout.count( v )
print ("value is "..v)
end
--声明label对象（变量）  accout
accout = Accout
--通过对象调用方法
accout.count(1000)
--2.通过 self 得到当前 lable 对象
Accout = {balance = 10}
--显示 传入 self
functionAccout.count( self,  v )
self.balance = self.balance + v;
print ("value is "..self.balance)
end
--声明label对象（变量）  accout
accout = Accout
--通过对象调用方法, 显示的把 accout 这个 table 这个对象传入到函数 (显示的传入 self)
accout.count(accout, 1000)
--还可通过 : 调用的方式 隐试的传入 self 对象
accout:count(2000)
--3.通过 : 符号，实现声明函数时的  隐试參数 self
Accout = { balance = 10}
--通过 : 符号, 隐试 传入 self
functionAccout:count( v )
self.balance = self.balance + v;
print ("value is "..self.balance)
end
--声明label对象（变量）  accout
accout = Accout
--还可通过 : 调用的方式 隐试的传入 self 对象
accout:count(2000)
--4.通过require 返回对象， 调用该对象方法
class = require("myClass")
--函数写在 table的括号 外
class:showName()
--函数写在 table的括号 内
class.show(class)


2、元方法与元表


元方法：就是两个 类型 变量之间进行操作的 函数


	比如，1.数字的相加。它可能不过一个函数：1 + 1--->add(1,1)--->add函数就是用来计算两个数字间相加的结果de
		   2.table类型相加？--->Lua中不存在两个{} + {}的元方法。


元表(metatable)：就是用来存放 元方法 的 table,是table提前定义的一系列操作。把两个table相加，那么Lua就会先去检查两个table是否有metatable，然后再检		 查metatable中是否有__add方法。

假设有依照__add方法中的操作来运行，否则，报错。



	比如，假设非要将两个table类型相加的话，直接执行必报错。

但Lua同意改动元表，例如以下所看到的：


一个元表，事实上就是一个table值，所以，我们仅仅须要新建一个table，加入元方法就可以。

比方加法运算的元方法就是：__add，这是Lua规定的。

仅仅要某个值的元表里含有__add这个元方法。那就能够使用+号进行运算。

例如以下代码：


-- 创建一个元表
local mt = {};
mt.__add = function(t1, t2)
print("两个table相加的结果就是...Good Good Study,Day Day Up!");
end
local t1 = {};
local t2 = {};
-- 给两个table设置新的元表
setmetatable(t1, mt);
setmetatable(t2, mt);
-- 进行加法操作
local result = t1 + t2;




首先创建了一个table变量mt，给这个table新增一个元素__add。这个table就拥有了作为元表的资格了。
然后创建两个新的table变量。使用setmetatable函数给table设置新的元表。此时，两个table变量就以mt作为元表了。
最后，对t1和t2进行加法操作。这时就会从元表中查找__add元方法。假设找到的话，就调用这个元方法对两个变量进行加法操作。

Lua中的每个值都有或者能够有一个元表，但table和userdata能够拥有独立的元表，其它类型的值就仅仅能共享其类型所属的元素。比方字符串使用的是
string的元表。注意：Lua在新建table时，不会创建metatable，须要使用setmetatable来设置元表。setmetatable的參数能够使随意table,包含要赋值的table本身。




------》查看一个变量是否有元表：
	print(getmetatable(a))     -- nil 表示没有元表




Lua中的重要的元方法：__eq等于、__lt小于、__le小于等于、__add：加法、__sub：减法、__mul：乘法、__div：除法、__unm：相反数、__mod：取模、__pow：乘幂、__index   function(table,key)、__newindex   function(table,key,value)、__tostring 被print()调用、__metatable设置后可隐藏mt



仅仅要在自己定义元表的时候，给这些元方法名赋予新的函数就能够实现自己定义操作了。
Lua訪问table元素 首先。通过__index元方法来查找是否有这个函数（假设没有。返回nil）;__index的值能够直接是一个table。也能够是函数（若是table,则以该table作为索引进行查询。若是函数。则将table和缺少的域作为參数，调用这个函数）
样例1、
我们新建一个自己定义的元表（也就是一个table变量）。用来定义一些操作：


-- 创建一个元表
local mt = {};
mt.__add = function(s1, s2)
local result = "";
if s1.sex == "boy" and s2.sex == "girl" then
result = "青梅竹马";
elseif s1.sex == "girl" and s2.sex == "girl" then
result = "空对空";
else
result = "硬碰硬"
end
return result;
end




事实上这和上一节的样例基本一样。仅仅是多说一次而已，使用方式例如以下：


-- 创建两个table，能够想象成是两个类的对象
local s1 = {
name = "Hello",
sex = "boy",
};
local s2 = {
name = "Good",
sex = "girl",
};
-- 给两个table设置新的元表
setmetatable(s1, mt);
setmetatable(s2, mt);
-- 进行加法操作
local result = s1 + s2;
print(result);




样例2、
Window = {}
Window.mt = {}
Window.prototype = {x = 0,y = 0,width = 100,height = 100}
Window.mt.__index = function(table,key)
	return Window.prototype[key]
end


function Window.new(t)
	setmetatable(t,Window.mt)
	return t
end


--測试
w = Window.new{x = 10,y = 20}
print(w.heigth)




__newindex的使用方法基本与样例2一致。差别在于__newindex的作用是用于table的更新，__index用于table的查询操作。



当对table中不存在的索引赋值时，就会调用__newindex元方法。组合使用__index和__newindex能够实现非常多功能










封装：
	有了元表（metatable）之后。Lua类的封装就会变得非常easy。仅仅要为table加入metatable，并设置__index方法。


比如：
People = {age = 18}
function People:new()
	local p = {}
	setmetatable(p,self)
	self.__index = self
	return p
end


function People:groupUp()
	self.age = self.age + 1
	print(self.age)
end


--測试
p1 = People:new()
p1:growUp()   --19
p2 = People:new()
p2:growUp()   --19


--[[执行结果能够看出：两个对象拥有的age成员是全然独立的。并且全部的有关People的方法都能够对外不可见，这样全然实现了面向对象中的类的封装--]]






继承：
	继承是面向对象中不可缺少的一部分。依旧使用上例中的People，展示Lua中实现继承的方法。

创建一个People实例Man，再在Man上重写People的同名方法：
Man = People:new()
function Man:growUp()
	self.age = self.age + 1
	print("man's growUp:"..self.age)
end


--測试
man1 = Man:new()
man1.growUp()  --man's growUp:19






多态：
	Lua不支持函数多态，而支持指针的多态，因为Lua动态类型的特性，本身就能支持。



person = People:new()
person:growUp()         --People's growUp:19
person = Man:new()
person:growUp()         --Man's growUp:19