Lua-- 面向对象

print("******* OO *******")
-- 面向对象
-- print("******* 封装 *******")
-- 所有面向对象、类，其实都是基于 table 来实现
-- 以及 元表相关知识点
Object = {}
Object.id = 1       -- 类似与c#的静态方法

function Object:Test()
    print(self.id)
end

-- 实现一个实例化方法
-- 冒号 是会自动将调用这个函数的对象作为第一个参数传入的写法
function Object:new()
    -- self 代表的是我们传入的第一个参数
    -- 对象就是变量，即返回一个新的变量
    -- 返回出去的内容，本质上就是 table 对象
    -- 注意是 local， 否则 obj 是全局变量
    local obj = {}
    -- 元表知识, __index 当找自己的变量找不到时，就会去找元表当中 __index 指向的内容
    -- 这样就可以在生成的实例对象中得到 id 的值
    self.__index = self
    setmetatable(obj, self)     -- 由于之后要继承，这里不能直接写 Object
    return obj
end
local myObj = Object:new()
print(myObj)
print(myObj.id)     -- 通过元表来进行访问
-- 这里调用 self 时是在 myObj 表中寻找 id 属性，找不到通过 __index 从 Object 中寻找
myObj:Test()

-- 相当于是对 new 方法中的空表 obj 进行操作，声明一个新的属性
-- 与 Object 中的 id 没关系
myObj.id = 2
print(Object.id, myObj.id)
-- 这里调用 self 时直接在 myObj 表中寻找已有的 id 属性
myObj:Test()

-- print("******* 继承 ******")
-- C# class 类名 ： 继承类
-- Lua 中写一个用于继承的方法
-- 首先补充 _G 表的一种使用方法，可以直接在 _G 表中添加元素
print(_G)
_G["a"] = 1
_G.b = "123"
print(a)
print(b)
function Object:subClass(className)
    -- _G 知识点：总表，所有声明的全局变量，都以键值对的形式存储
    _G[className] = {}

    -- 写相关继承的规则
    -- 用到元表
    local obj = _G[className]
    self.__index = self
    -- 子类定义一个 base 属性代表父类，以在多态中使用
    obj.base = self
    setmetatable(obj, self)
end

-- 声明一个 Object 的子类 Person，其元表为 Object，且 __index = Object
Object:subClass("Person")
print(Person)
print(Person.id)
-- 通过实例化, 这里的过程是：
-- Person 调用 new 方法，由于 Person 中没有 new 方法， 根据其元表的 __index 去寻找，
-- 而 Person 是由 Object:subclass 中添加的，其元表为 Object， 且在 subClass 中设置其 __index
-- 是 Object，因此 Person 调用 Object 的 new() 方法中返回一个空表，并且在 new 方法中 self
-- 其实为 Person，在该方法中，返回的 obj（即p1) 的元表为 Person, __index 也是 Person
-- 元表关系即为： obj(p1) -> Person -> Object
--                            |         |
-- __index 关系：           Person     Object
--
local p1 = Person:new()
-- 首先 p1 实际上是通过 new 方法返回的空 talbe, 其中没有 id 属性，那么就要通过其元表的 __index
-- 去寻找，而 Person 中也没有该属性，因此通过 __index 的嵌套最后从 Object 中去寻找 id
print(p1.id)    -- 实际为 Object 的 id
p1.id = 100
print(p1.id)    -- p1 自己的 id


-- print("******* 多态 *******")
-- 相同行为，不同表现就是多态
-- 相同方法，不同执行逻辑，就是多态
Object:subClass("GameObject")
GameObject.posX = 0
GameObject.posY = 0
function GameObject:move()
    self.posX = self.posX + 1
    self.posY = self.posY + 1
    print(self.posX, self.posY)
end

GameObject:subClass("Player")

local p1 = Player:new()
p1:move()       -- 调用的 GameObject 中的 move 方法

-- 直接重写 move 方法实现多态
function Player:move()
    -- C#中通过 base 保留父类的方法. base.move()
    -- 因此需要构建一个 base
    -- 此处 base 指的是 GameObject 表（类）
    -- 这种方式调用相当于是把基类表作为第一个参数传入
    -- 注意，此处是通过 base 调用父类 GameObject 中的 move 方法
    -- 而不是通过 元表的 __index, 因此调用的 move 中的 self 并不是
    -- Player 而是 GameObject，会导致后面的一个【坑】
    self.base:move()
end
p1:move()

-- !!!! 大坑
local p2 = Player:new()
-- 与 p1:move() 打印的结果不一致
-- p1:move() 打印的是 （1， 1）； p2:move() 打印的是 （2，2）
-- 因为此时 p1,p2 是对 GameObject 中同一个 posX,posY 进行修改
-- 即不同对象使用的是 同一个成员变量
-- 原因是在 move 中调用时通过 base 是调用同一个 GameObject 的 move 方法
-- 修改的也是 GameObject 中的 posX，posY
p2:move()       -- (2,2)
p1:move()       -- (3,3)
-- 因此要避免把基类表传入到方法中
-- 如果要执行父类逻辑，不要直接使用冒号调用，把调用者自己当作第一个参数传入
function Player:move()
    self.base.move(self)
end
local p3 = Player:new()
local p4 = Player:new()
-- 这里的步骤是：
-- 调用 move 的时候传入的是 self,即 p3, 也是 GameObject 中的 self
-- 在 self.posX = self.posX + 1 式子中， p3 一开始没有 posX 变量，
-- 通过元表得到 GameObject 的 posX 的值然后加1，赋值给 self.posX 左值
-- 此时 p3 就有了新的变量 posX，即自己的变量，而不是 GameObject 的
p3:move()
p4:move()
p3:move()



--  总结
print("******* OO All *******")
-- 封装、继承、多态汇总
-- 万物之父 所有对象的基类 Object
Object = {}

-- 实例化方法
function Object:new()
    local obj = {}
    self.__index = self
    -- 给空对象设置元表 以及 __index 对象
    setmetatable(obj, self)
    return obj
end

-- 继承
function Object:subClass(className)
    -- 根据名字生成一张表
    _G[className] = {}
    local obj = _G[className]
    -- 设置自己的“父类”
    obj.base = self
    -- 给子类设置元表 以及 __index
    self.__index = self
    setmetatable(obj, self)
end

-- 声明一个新的类
Object:subClass("GameObject")
GameObject.posX = 0
GameObject.posY = 0

function GameObject:move()
    self.posX = self.posX + 1 
    self.posY = self.posY + 1
end

-- 实例化对象使用
local obj = GameObject:new()
print(obj.posX)
obj:move()
print(obj.posX)


local obj2 = GameObject:new()
print(obj2.posX)
obj2:move()
print(obj2.posX)

-- 多态
-- 声明一个新类 Player 继承 GameObject
GameObject:subClass("Player")
-- 重写 move 方法
function Player:move()
    -- base 调用父类方法用 . 自己传第一个参数
    self.base.move(self)
end

-- 实例化 Player 对象
local p1 = Player:new()
local p2 = Player:new()
print(p1.posX)
print(p2.posX)
p1:move()
p2:move()
print(p1.posX)
print(p2.posX)