乱 继承 多态 单例模式 面向对象



    

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

标签： lua继承多态面向对象编程单例模式

2014-06-15 21:56 1001人阅读 评论(0) 收藏 举报

分类：

Cocos2dx（34）

作者同类文章 X

Lua（18）

作者同类文章 X

版权声明：本文为博主原创文章，未经博主允许不得转载。

目录(?)[+]

1. 继承
   1. 基类 class222lua
   2. 子类class111lua
   3. test
2. 多态
3. 单例模式
   1. class3lua
   2. test

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

继承

基类 class222.lua

[plain] view plain copy print ?

1. --声明，这里声明了类名还有属性，并且给出了属性的初始值。  
2. class2 = {}  
3. class2.a = "class2 aaa"  
4. class2.b = "class2 bbb"  
5. class2.c = "class2 ccc"  
6. --这句是重定义元表的索引，就是说有了这句，这个才是一个类。具体的解释，请百度。  
7. class2.__index = class2  
8.   
9. --新建一个实例对象并返回  
10. function class2:new(data)  
11.     local self = {}   --初始化self，如果没有这句，那么类所建立的对象改变，其他对象都会改变  
12.     setmetatable(self , class2) --将self的元表设定为Class  
13.     self.a = data   --属性值初始化  
14.     return self --返回自身  
15. end  
16.   
17. --这里定义类的其他方法  
18. function class2:func2()  
19.     print("class2 : func2")  
20. end  
21.   
22. function class2:test()  
23.     print("class2 : test")  
24.     return "asdsd"  
25. end  
26.   
27. function class2:ooo()  
28.     return 432  
29. end  
30.   
31. function class2:ppp()  
32.     return 100  
33. end  
34.   
35. function class2:qqq()  
36.     return self:ppp() * 2  
37. end  

--声明，这里声明了类名还有属性，并且给出了属性的初始值。
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

[plain] view plain copy print ?

1. require "class2"    --因为继承class2，所以这里一定要包含class2文件，否则报找不到方法的错  
2. -声明类和属性  
3. class1 = {}  
4. class1.u = "class1 uuu"  
5. class1.i = "class1 iii"  
6.   
7. --设置类型是class2  
8. setmetatable(class1, class2)  
9. --还是和类定义一样，表索引设定为自身  
10. class1.__index = class1  
11.   
12. --新建一个实例对象并返回  
13. function class1:new(data,xxx)  
14.     local self = {}  
15.     self = class2:new(data)  
16.     setmetatable(self,class1)  
17.     self.u = xxx  
18.     return self  
19. end  
20.   
21. -- 添加新的方法  
22. function class1:func1()  
23.     print("class1 : func1")  
24. end  
25.   
26. -- 重写父类中得ooo方法  
27. function class1:ooo()  
28.     return 999  
29. end  
30.   
31. function class1:ppp()  
32.     return 22  
33. end  

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

[plain] view plain copy print ?

1. local a = class2:new("init data aaa")  
2.             a:func2()  
3.             print(a.a)  
4.                   
5.             local b = class1:new("www","xxx啊")  
6.             b:func1()  
7.             print(b.a)  
8.             print(b.u)  
9.             b:func2()  
10.               
11.             local n = b:test()  
12.            print(n)  
13.              
14.         local m = b:ooo()  
15. --        node:addChild(m)  
16.         print(m)  
17.              
18.          local h = class2:new("hhh")  
19.          print(h:qqq())  
20.            
21.          local j = class1:new("jjj","jjjnew")  
22.          print(j:qqq())  
23.          print(h:qqq())  

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())

结果：

多态

[plain] view plain copy print ?

1. local h = class2:new("hhh")  
2.          print(h:qqq())  
3.            
4.          local j = class1:new("jjj","jjjnew")  
5.          print(j:qqq())  
6.          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

[plain] view plain copy print ?

1. CatManager = {}  --新建一个类  
2. CatManager.num = 1  --定义num属性并付志伟  
3. CatManager.__index = CatManager --定义元表的索引，使之成为一个类  
4.   
5. function CatManager:new()  
6.     local self = {} --新建一个实例对象  
7.     setmetatable(self,CatManager)   --设置实例类型为CatManager  
8.     return self --返回实例对象  
9. end  
10.   
11. function CatManager:getInstance()  
12.     if self.instance == nil then      
13.         self.instance = self:new()  
14.     end  
15.     return self.instance  
16. end  
17.   
18. function CatManager:func1()  
19.     print("catManager func1")  
20. end  

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

[plain] view plain copy print ?

1. local cat1 = CatManager:getInstance()  
2.          print(cat1.num)  
3.          cat1.num = cat1.num + 10  
4.            
5.          local cat2 = CatManager:getInstance()  
6.          print(cat2.num)  
7.            
8.          if cat1 == cat2 then  
9.             print("cat1和cat2两个是同一个对象")  
10.          end  

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两个是同一个对象