1.点与冒号 self机制
local a = {}
function a.test()
print("a.test")
end
a.test()
local b = {}
function b:test()
--self代表调用表的实例
print("b:test", self)
end
--
b:test()
--self机制下a应该改为 b则不需要修改
local a = {}
function a.test(self)
print("a.test",self)
end
a.test(a)
--self机制需要两个点 1 定义函数需要使用冒号才会隐式传递self 2.调用需要冒号调用
2.元表(两个表相加)
local a ={}
local b={
__index ={
name = "kjh",
age =23
}
}
-- b叫做a的原表
setmetatable(a,b) --设置表的原表
getmetatable(a) --获取表的元表
--__index很关键当主表里面没有所在值时候会从元表里面的__index取相应的值
print(a.name)
3.面向对象
lua本身不是面向对象的语言但是可以通过设计模拟面向对象的存在
假设我们有一个类叫做base
local base = {}
--成员函数
function base:test()
print("base:test");
end
--其他函数等等 base叫做类的表
function base:new(instant)
if not instant then
instant = {}
end
--setmetatable(instant,self)--将本表里面的方法传递给空的实例
setmetatable(instant,{__index = self})--将本表里面的方法传递给空的实例
return instant
end
--实例化对象使用处理
local b = base:new()
b:test()
--也可以这样
local b = base:new({ age =12, name ="三哥"})
b:test()
b.age
--面向对象的基本步骤:
--(1)定义一个类的表;
--(2)定义一个实例的表;
--(3)为这个实例的表加一个元表,并且元表__index指向了这个类的表;
--(4)利用self基础 表的实例:表的函数的时候,
--隐士的帮我们传递了实例的表为self到函数里面;
--end
4.继承
--继承
-- 基类是 person
-- 子类: 男人
local person = {} --基类的表
function person:test()
print("person:test", self)
end
function person:get_age()
print("person:get_age", self)
end
function person:new(instant)
if not instant then
instant = {} --类的实例
end
setmetatable(instant, {__index = self})
return instant
end
--end
--man子类的表
local man = person:new()
function man:test_man()
print("man:test_man", self)
end
function man:test_man2()
print("man:test_man2", self)
end
function man:get_age()
print("man:get_age", self)
--调用基类的函数
person.get_age(self)
--end
end
--
--为这个man类实例化一个类的表
local p = man:new() -- new的self里面不再是person而是man
-- p的元表里面的__index = 类的表;
print("p = =====", p)
p:test_man() --调用 man里面找到;
p:test() -- p,-->man--> person-->只到所有的元表全部找完,
--end
--重载
p:get_age() --> p表,-->man查-->person
--end