Cocos2d-x 脚本语言Lua中的面向对象

https://blog.csdn.net/wwj_748/article/details/33313777

面向对象不是针对某一门语言,而是一种思想,在面向过程的语言也可以使用面向对象的思想来进行编程。在Lua中,并没有面向对象的概念存在,没有类的定义和子类的定义,但同样在Lua中可以利用面向对象的思想来实现面向对象的类继承。

一、复制表的方式面向对象
[javascript]  view plain  copy
  1. --Lua中的面向对象  
  2. --[[  
  3.   复制表方式面向对象  
  4.   参数为一张表,通过遍历这张表取值,赋给一张空表,最后返回新建的表,来达到克隆表  
  5. ]]  
  6. function clone(tab)  
  7.     local ins = {}  
  8.     for key, var in pairs(tab) do  
  9.         ins[key] = var  
  10.     end  
  11.     return ins  
  12. end  
  13.   
  14. --[[  
  15.   复制表  
  16.   第一参数是目标表,第二个参数是需要复制的表  
  17.   通过遍历tab来取值将它赋值到目标表中  
  18. ]]  
  19. function copy(dist,tab)  
  20.     for key, var in pairs(tab) do  
  21.         dist[key] = var  
  22.     end  
  23. end  
  24.   
  25. -- 定义一张空表,相当于一个类  
  26. People ={}  
  27.   
  28. --function People.sayHi()  
  29. --  print("People say hi")  
  30. --end  
  31.   
  32. -- 定义类中的方法sayHi,传入一个self参数  
  33. People.sayHi = function (self)  
  34.     print("People say hi:"..self.name)  
  35. end  
  36.   
  37. -- 定义一个new方法,传进一个name参数,通过克隆People这张表来生成一个对象  
  38. -- 相当于类当中的一个构造方法  
  39. People.new = function (name)  
  40.     local self = clone(People)  
  41.     self.name = name  
  42.       
  43.     return self  
  44. end  
  45.   
  46. --local p = clone(People)  
  47. --p.sayHi()  
  48. --生成一个新的对象  
  49. local p = People.new("ZhangSan")  
  50. --p.sayHi(p)  
  51. --p:sayHi()  
  52.   
  53.   
  54. --定义一张空表,也代表一个类  
  55. Man = {}  
  56. --Man中的构造方法,实现Lua中类的继承  
  57. Man.new = function (name)  
  58.     local self = People.new(name)  
  59.     --附加Man中所有的键值对到People中的实例中去  
  60.     copy(self,Man)  
  61.     return self  
  62. end  
  63.   
  64. Man.sayHello = function ()  
  65.     print("Man say hello")  
  66. end  
  67.   
  68. --重写父类People中的sayHi方法  
  69. Man.sayHi = function (self)  
  70.     print("Man sayHi "..self.name)  
  71. end  
  72.   
  73. --创建Man的一个实例  
  74. local m = Man.new("Lisi")  
  75. m:sayHi()  

以上代码已经有详细的注释,读者需要仔细阅读这里所给出的例子。

二、使用函数闭包的形式实现面向对象
[javascript]  view plain  copy
  1. --以函数闭包的形式实现面向对象  
  2.   
  3. --定义一个方法,函数闭包实现一个类的概念  
  4. function People(name)  
  5.     local self = {}  
  6.   --初始化方法,私有的  
  7.     local function init()  
  8.         self.name = name  
  9.     end  
  10.     
  11.     self.sayHi = function ()  
  12.         print("Hello "..self.name)  
  13.     end  
  14.   
  15.   --调用初始化  
  16.     init()  
  17.     return self  
  18. end  
  19.   
  20. --实例化一个对象  
  21. local p = People("ZhangSan")  
  22. p:sayHi()  
  23.   
  24. --函数闭包的形式实现类继承  
  25. function Man(name)  
  26.     local self = People(name)  
  27.       
  28. --  local function init()  
  29. --        
  30. --  end  
  31.   
  32.     self.sayHello = function ()  
  33.         print("Hi "..self.name)  
  34.     end  
  35.       
  36.     return self  
  37. end  
  38.   
  39.   
  40. local m = Man("Lisi")  
  41. --m:sayHello()  
  42. m:sayHi()  

以上两种方式均可实现面向对象,目测第二种方法更为简洁一些,具体使用按照个人的喜好来做。


猜你喜欢

转载自blog.csdn.net/tropicofcancer9/article/details/80004164