Lua 点 冒号面向对象 继承

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