lua class module

模块

 

模块是一个独立的空间，一个独立的环境，访问模块成员需要先require，并使用“模块名.成员名称”的格式访问。注意：模块是一个table。

 

类

 

在lua中所有对象都是一个table，类也是一个table，但类应该是一个只读的table，类的定义是通过创建一个模块实现的。

 

lua代码：

[plain] view plaincopyprint?

1. module("Student",package.seeall)  
2.   
3. function study(self)  
4.   
5. end  

module("Student",package.seeall)

function study(self)

end

 

在调用module方法时添加package.seeall参数的作用是：让该模块可以访问全局变量。

 

对象

 

对象是一个类的实例，在Lua中对象是一个table，在Lua中类更像是一个原型（一个只读的对象）。

 

通过设置tableA的元表的__index字段为tableB，当读tableA中没有的字段时就会从tableB中读该字段。

 

可以先创建一个空table，然后通过设置元表的方式，创建一个对象，当访问该对象没有的字段时就会在类中寻找。

 

lua代码：

[plain] view plaincopyprint?

1. -- 创建对象方法  
2. function new( moduleName )  
3.     local obj = {}  
4.     setmetatable(obj,{__index = moduleName})  
5.     return obj  
6. end  

-- 创建对象方法
function new( moduleName )
	local obj = {}
	setmetatable(obj,{__index = moduleName})
	return obj
end

 

 

继承

 

在Lua中继承也可以通过设置元表的方式实现。

 

lua代码：

[plain] view plaincopyprint?

1. -- 继承  
2. function extend( child, parent )   
3.     setmetatable(child,{__index = parent})  
4. end  

-- 继承
function extend( child, parent ) 
    setmetatable(child,{__index = parent})
end

 

 

静态与非静态

 

静态成员与非静态成员的区别就在于：是否可以通过类名访问，如果可以通过类名访问则是公有静态成员，否则是非公有静态成员或非静态成员。而在Lua中类名就是模块名称，如果可以“模块名.成员名”形式访问则是公有静态成员。

 

lua代码：

[plain] view plaincopyprint?

1. module("Student",package.seeall)  
2.   
3. -- 公有静态成员变量（可通过模块名访问）  
4. flag = 1  
5. -- 私有静态成员变量（外部不可访问）  
6. local flag2 = 2  
7.   
8. -- 非静态成员方法（需要传self）  
9. function init(self, name)  
10.     -- 非静态成员变量      
11.     self.name = name  
12. end  
13.   
14. -- 静态成员方法（不需要传self）  
15. function getFlag()  
16.     return flag  
17. end  
18.   
19. -- 非静态成员方法  
20. function getName(self)  
21.     return self.name  
22. end  

module("Student",package.seeall)

-- 公有静态成员变量（可通过模块名访问）
flag = 1
-- 私有静态成员变量（外部不可访问）
local flag2 = 2

-- 非静态成员方法（需要传self）
function init(self, name)
    -- 非静态成员变量    
	self.name = name
end

-- 静态成员方法（不需要传self）
function getFlag()
	return flag
end

-- 非静态成员方法
function getName(self)
	return self.name
end

 

tools.lua

[plain] view plaincopyprint?

1. -- 创建一个对象并初始化  
2. function create( moduleName, ... )  
3.     local obj = new(moduleName)  
4.     obj:init( ... )  
5.     return obj  
6. end  

-- 创建一个对象并初始化
function create( moduleName, ... )
	local obj = new(moduleName)
	obj:init( ... )
	return obj
end

调用代码：

[plain] view plaincopyprint?

1. require "utils/tools"  
2. require "Student"  
3.   
4. -- 访问公有静态成员变量      
5. cclog("flag = %d",Student.flag)  
6. -- 访问静态方法      
7. cclog("flag = %d",Student.getFlag())  
8. -- 创建一个Student对象      
9. local obj = create(Student,"xiaoming")  
10. -- 通过对象访问公有静态成员变量      
11. cclog("falg = %d",obj.flag)  
12. -- 访问非静态成员变量      
13. cclog("name = %s",obj.name)  
14. -- 访问非静态成员方法      
15. cclog("name = %s",obj:getName())  

    require "utils/tools"
    require "Student"

    -- 访问公有静态成员变量    
    cclog("flag = %d",Student.flag)
    -- 访问静态方法    
    cclog("flag = %d",Student.getFlag())
    -- 创建一个Student对象    
    local obj = create(Student,"xiaoming")
    -- 通过对象访问公有静态成员变量    
    cclog("falg = %d",obj.flag)
    -- 访问非静态成员变量    
    cclog("name = %s",obj.name)
    -- 访问非静态成员方法    
    cclog("name = %s",obj:getName())

 

打印结果：

 

 

 

1.静态成员变量与非静态成员变量的区别在于：该变量是存在模块的环境中，还是存在self中。

 

 

2.静态成员方法与非静态成员方法的区别在于：该方法是否需要传self。

 

 

3.访问静态成员与非静态成员

 

访问模块中的成员都可以通过“模块名.成员名称”的方式访问，但访问模块中非静态成员方法时，通过“self:成员名称()”的方式会更方便（注意：":"只是为了语法便利，作用只是把self作为方法的第一个实参，与“模块名称.(self)”没什么区别）。

 

注意：在Lua中本来并没有静态与非静态这个概念。