lua self 点 冒号 元表 面向对象 继承

点 冒号 self

1: 代码如下:

    a = {};
    function a.test() 
    end


2: 冒号解决这个问题
    a = {}
    function a:test() :多了self这个机制
    end
    a:test() 把a这个实例作为self传递给test函数,在test函数里面访问self就能获得这个a;

3:显示传递self

元表

1: 每一个表，可以为这个表设置一个元表: metatable
2: 设置这个表的元表:setmetatable(table,metatable)
     获取这个表的元表:getmetatable(table) 
3: 元表__index键
     metatable中的常用键;

     如果在表里面找不到的key,lua解释器在元表里面的__index表里进行查找;

面向对象

1: 类的表 --> 类的实例的元表:
   function ClassA:
2: 类的实例
function ClassA:new(instant) 
if not instant then 
instant = {} --类的实例
end


setmetatable(instant, {__index = self}) 
return instant
end
3: 类的实例调用类的方法:

    self: 绑定的实例对象;

继承

1: 子类的表是父类的一个实例
2: 子类的表作为一个原型再new了一个表;
类的实实例-->元表-->子类的表-->元表-->父类的表;
3: 现在子类的实例找，找不到到元表找，元表找不到,到元表的元表找;
4: 子类重载父类的函数;

5: 子类调用父类的函数;

-- self点 冒号 元素 面向对象 继承

--self机制

-- 点号 和 冒号的区别

-- 用冒号定义的函数， 多一个机制 self

local a = {}

function a.test( self, a, b)

print( "a.test", self)

print(a,b)

end

a. test(a, 3, 4)

local b = {}

function b:test( a, b)

-- self 调用这个函数的表的实例

print( "b:test", self)

print(a,b)

end

b: test( 5, 6) --在test函数里面 self 就是 b

--self机制要正常运行，需要有两个点：

-- (1) 定义的函数必须使用冒号（：） 才会隐式的传递self

--（2）定义用冒号，使用用冒号；定义用分号，使用用分号

-- end

print( "###################")

-- 元表

local a = {

--name = 'huangdong'

}

local meta_a ={

__index = {

name = "blake",

age = 34,

sex = 0,

}

}

-- 元表end

--两个表相加，第一个参数是一个表，第二个参数也是一个表

-- meta_a 叫做a的元表

setmetatable(a, meta_a) --设置表的元表

print( getmetatable(a)) --获取表的元表

--元表里面有一个重要的key： __index

-- 特点: 当我们搜索一个表的key的时候，如果在当前的表里面没有搜索的到，

-- 那么lua解释器会去表的元表里面的__index的这个key所对应的表里面来查找

-- 优先在自己的表里面查找，在没有找到的情况下，再去元表里面查找

print(a. name)

--end

print( "###################")

-- lua面向对象

local base ={

}

-- 成员函数

function base:test()

print( "base:test")

end

function base:new( instant)

if not instant then

instant = {}

end

setmetatable(instant, {__index = self})

return instant

end

-- 可以定义其他很多的类的函数

-- base叫做类的表

--做一个类的实例

local b = base: new()

-- 在new里面把新创建的实例的表的元表变成了base

b: test() -- test self对象就是b

-- end

-- 面向对象的几个特点

--[[

(1)定义类的表

（2）定义一个实例的表

（3）位这个实例的表加一个元表，并且元表__index指向这个类的表

]]

print( "########jicheng###########")

-- 继承 重载

--基类: person

--子类: man

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

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() --重载 覆盖基类的test

print( "man:get_age")

end

-- 实例化一个子类，为man类实例化一个类的表

local p = man: new() --new的self里面不在是person 而是man，

-- p的元表里面的__index = 类的表

p: test_man() -- 调用在man类里面找到

print( "p=",p, "man=",man, "person=",person)

p: test() -- p-->man -- >person

p: get_age() --重载get_age

-- 继承end 重载end