lua实现面向对象封装/继承/多态
lua实现面向对象(封装/继承/多态)
lua
print("***********面向对象**********")
print("*************封装************")
--表就是表现类的一种形式
--实现了new方法:本质上是创建一个空表，__index,元表
--如果子表寻找某元素时在自身找不到时，会去元表的__index中寻找
--修改创建出来的对象的属性变量时： 为这个空表对象新建一个成员属性
--冒号：自动将调用这个函数的对象作为第一个参数传入。self代表函数调用者
Object={}
Object.id=1
function Object:Test()
print(self.id)
end
--冒号 自动将调用这个函数的对象 作为第一个参数传入
function Object:new()
--self表示默认传入第一个参数
--对象就是变量 返回一个新的变量
--返回的内容 本质上就是表变量
local obj={}
self.__index=self
setmetatable(obj,self)
return obj
end
local myObj=Object:new()
local myObj2=Object:new()
--对空表中 声明一个新的属性 叫做id
myObj.id=3
myObj:Test()
myObj2.id=2
myObj2:Test()
print("*************继承************")
--写一个继承的方法(_G,元表,__index)
function Object:subClass(classname)
--_G是总表 所有声明的全局变量(以键值对存储)
--在_G表中注册
_G[classname]={}
--相关继承的规则(元表)
local obj=_G[classname]
--设置Object的__index表为Object
self.__index=self
--给子类定义一个属性base base属性代表父类
obj.base=self
--设置classname的元表为Object
setmetatable(obj,self)
end
--创建类(Person)
--调用Person类的new方法
--实际上调用的是Person元表(Object)中的new方法
--new 方法中将调用者的__index设置为调用者
--并返回一个将调用者视为元表的表对象
--该表对象如果没找到元素会在元表__index（此时调用者为它的元表，且调用者的__index是它本身）里面找
Object:subClass("Person")
local p1=Person:new()
print(p1.id)
print("修改值为100")
p1.id=100
print(p1.id)
Object:subClass("Monster")
local m1=Monster:new()
print(m1.id)
print("修改值为200")
m1.id=200
print(m1.id)
print("*************多态************")
--相同行为 不同表现 就是多态
--相同方法 不同执行逻辑 就是多态
--相同方法名 子类有不同的处理逻辑
--直接重写方法
--如果想要保留父类逻辑执行
--加入自定义属性base
--在subclass方法中赋值
--坑点：通过base调用父类方法时候，如果改变属性一定不要使用：，而是通过.将自己传入第一个参数进入父类函数
Object:subClass("GameObject")
GameObject.posX=0
GameObject.posY=0
--GameObject 定义move方法
function GameObject:Move()
--赋值会新建变量
--查询不到会找元表的__index表(self->player->gameobject)
self.posX=self.posX+1
self.posY=self.posY+1
print(self.posX)
print(self.posY)
end
GameObject:subClass("Player")
--多态 相同方法 不同执行逻辑
--相同行为 不同表现
function Player:Move()
--调用Player父类(GameObject/Object)的方法
--传递自己的参数self(而不是base)
self.base.Move(self)
end
local b=Player:new()
b.posX=3
b:Move()
-- local b1=Player:new()
-- b1.posX=3
-- b1:Move()