Lua 继承 多态 单利模式 面向对象

lua模拟面向对象编程中得继承、多态，这里也同时演示设计模式中得单利模式，类的实现都是通过lua中table，这个table太强大了，又可以当集合、数组

继承

基类 class222.lua

--声明，这里声明了类名还有属性，并且给出了属性的初始值。
class2 = {}
class2.a = "class2 aaa"
class2.b = "class2 bbb"
class2.c = "class2 ccc"
--这句是重定义元表的索引，就是说有了这句，这个才是一个类。具体的解释，请百度。
class2.__index = class2

--新建一个实例对象并返回
function class2:new(data)
    local self = {}   --初始化self，如果没有这句，那么类所建立的对象改变，其他对象都会改变
    setmetatable(self , class2) --将self的元表设定为Class
    self.a = data   --属性值初始化
    return self --返回自身
end

--这里定义类的其他方法
function class2:func2()
    print("class2 : func2")
end

function class2:test()
    print("class2 : test")
    return "asdsd"
end

function class2:ooo()
    return 432
end

function class2:ppp()
	return 100
end

function class2:qqq()
	return self:ppp() * 2
end

子类class111.lua

require "class2"    --因为继承class2，所以这里一定要包含class2文件，否则报找不到方法的错
-声明类和属性
class1 = {}
class1.u = "class1 uuu"
class1.i = "class1 iii"

--设置类型是class2
setmetatable(class1, class2)
--还是和类定义一样，表索引设定为自身
class1.__index = class1

--新建一个实例对象并返回
function class1:new(data,xxx)
    local self = {}
    self = class2:new(data)
    setmetatable(self,class1)
    self.u = xxx
    return self
end

-- 添加新的方法
function class1:func1()
    print("class1 : func1")
end

-- 重写父类中得ooo方法
function class1:ooo()
    return 999
end

function class1:ppp()
	return 22
end

test

local a = class2:new("init data aaa")
            a:func2()
            print(a.a)
                
            local b = class1:new("www","xxx啊")
            b:func1()
            print(b.a)
            print(b.u)
            b:func2()
            
            local n = b:test()
           print(n)
           
        local m = b:ooo()
--        node:addChild(m)
        print(m)
           
         local h = class2:new("hhh")
         print(h:qqq())
         
         local j = class1:new("jjj","jjjnew")
         print(j:qqq())
         print(h:qqq())

结果：

多态

local h = class2:new("hhh")
         print(h:qqq())
         
         local j = class1:new("jjj","jjjnew")
         print(j:qqq())
         print(h:qqq())

class1中重写了ppp方法，返回另一个值，调用父类class2中继承下来的qqq方法时，qqq方法中的self:ppp()中的self指的是class1，这就实现的多态的行为

结果

单例模式

class3.lua

CatManager = {}  --新建一个类
CatManager.num = 1  --定义num属性并付志伟
CatManager.__index = CatManager --定义元表的索引，使之成为一个类

function CatManager:new()
    local self = {} --新建一个实例对象
    setmetatable(self,CatManager)   --设置实例类型为CatManager
    return self --返回实例对象
end

function CatManager:getInstance()
    if self.instance == nil then    
    	self.instance = self:new()
    end
    return self.instance
end

function CatManager:func1()
    print("catManager func1")
end

test

local cat1 = CatManager:getInstance()
         print(cat1.num)
         cat1.num = cat1.num + 10
         
         local cat2 = CatManager:getInstance()
         print(cat2.num)
         
         if cat1 == cat2 then
         	print("cat1和cat2两个是同一个对象")
         end

[LUA-print] 1

[LUA-print] 11

[LUA-print] cat1和cat2两个是同一个对象