lua类

最新推荐文章于 2025-02-06 13:10:01 发布
最新推荐文章于 2025-02-06 13:10:01 发布
阅读量516 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： lua 文章标签： lua
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/mooreliu/article/details/43016667
本文探讨了Lua语言中冒号(:)与点(.)在类方法定义与调用时的不同之处，通过一个简单的Account类实例，展示了如何使用冒号正确地引用self变量，并解释了在何种情况下使用点会引发错误。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

Account = {
  balance=123,
}

function Account:f()
	print(self.balance)
end

<pre name="code" class="plain">Account:f()
Account.balance=321print(Account.balance) 


输出为 -->123  -->321







上面是一个简单的Account类，需要注意的事Accout类中f 函数是采用的 冒号 ： 连接的


并且在f 函数中使用到了隐藏的self变量


如果调用Accout的f 函数 采用 点. 会报错


Account.f()


会报错

 attempt to index local 'self' (a nil value)




另外如果在定义Accout类的f 函数的时候 采用的是 点. 也会报同样的错


如果Accout类的 f  函数没有对self的引用 则  点 . 和 冒号 ： 都是OK的


这说明了：若定义lua 类函数时 采用的事 冒号：才能使用self


                

        

    

    
  



    



                



	

		

			

				
					
Lua类

				
			

			

				

					koganlee的博客
				

				

					06-21
					
					465
					
				

			

		

		

			
				
可以不在类初始化里面  定义某个成员修改类成员函数里面必须要使用 类名.成员类调用自己的成员函数  使用self :   函数名下面是一个装备类的例子。网上有些教程，写得十分不清楚，而且重新赋值就会覆盖之前的值。 必须要在类成员里添加local关键字。Equipment = { _name , _total, _power,  _agility, _wisdowm }
function Equip...

			
		

	



                

            
              



	

		

			

				
					
Lua 类的继承

				
			

			

				

					z2014z的博客
				

				

					07-26
					
					490
					
				

			

		

		

			
				
【代码】Lua 类的继承。

			
		

	



              


  
              

                


	

		

			

				
					
Lua 中实现类

				
			

			

				

					11-03
				

			

		

		

			
				
Lua中是没有类的概念的，但是程序猿说要面向对象，所以就有了。

			
		

	





	

		

			

				
					
lua学习：lua中“类”的实现

					
热门推荐

				
			

			

				

					——
				

				

					03-05
					
					3万+
					
				

			

		

		

			
				
Lua中的table就是一种对象，这句话可以从３个方面来证实。首先，table与对象一样可以拥有状态。其次，table也与对象一样拥有一个独立于其值的标识（一个self）。例如，两个具有相同值的对象（table）是两个不同的对象。最后，table与对象一样具有独立于创建都和创建地的生命周期。

			
		

	



		

			
		



	

		

			

				
					
lua 类

				
			

			

				

					哲学天空的博客
				

				

					01-16
					
					536
					
				

			

		

		

			
				

-- Meta class
Rectangle = {}
--Rectangle = {area = 0, length = 0, breadth = 0}
Rectangle.area = 0
Rectangle.length = 0
Rectangle.breadth = 0
-- 派生类的方法 new

function Rectangle:create (length, breadth)...

			
		

	





	

		

			

				
					
Lua 类的继承与函数override

				
			

			

				

					11-04
				

			

		

		

			
				
在 Lua 语言中，虽然它本身并没有内置的类（class）机制，但为了实现面向对象编程，程序员通常会采用一种称为“模拟”的方式来构建类和对象。这种模拟方法是基于表（table）和元表（metatable）的概念，以及一些特殊...

			
		

	





	

		

			

				
					
简单、完整的有继承功能的lua类实现

				
			

			

				

					manch1986的专栏
				

				

					09-27
					
					648
					
				

			

		

		

			
				
不到30行代码实现有继承功能的lua类

			
		

	





	

		

			

				
					
创建并实例化lua类_1_0-190807150128.alp

				
			

			

				

					10-27
				

			

		

		

			
				
Android andlua androlua lua实战工程

			
		

	





	

		

			

				
					
Lua 类的继承与override

				
			

			

				

					11-04
				

			

		

		

			
				
在 Lua 中，尽管其语言设计之初并没有直接支持传统的类（class）和面向对象编程概念，但程序员们通过元表（metatable）和闭包等机制，实现了模拟类和面向对象编程的功能。本文将深入探讨 Lua 中如何实现类的继承以及...

			
		

	





	

		

			

				
					
lua的类

				
			

			

				

					dong_forever的专栏
				

				

					10-30
					
					569
					
				

			

		

		

			
				
类是包含属性与方法的一个集合。是一个键值对的集合。 
可以用lua中的表来模拟类。A = {}
A.__index = A
function A:new()
    local o = {}
    setmetatable(o,A)
    return o
endfunction A:test()
    print("this is a class test")
end--使用类A
objA

			
		

	





	

		

			

				
					
Lua类（面向对象程序设计）

				
			

			

				

					昔拉的博客
				

				

					02-20
					
					2029
					
				

			

		

		

			
				
面向对象程序设计
Lua 中的表不仅在某种意义上是一种对象。像对象一样，表也有状态（成员变量）；也有与对象的值独立的本性，特别是拥有两个不同值的对象（table）代表两个不同的对象；一个对象在不同的时候也可以有不同的值，但他始终是一个对象；与对象类似，表的生命周期与其由什么创建、在哪创建没有关系。对象有他们的成员函数，表也有：
Account = {balance = 0} 
function A...

			
		

	





	

		

			

				
					
lua实现类

				
			

			

				

					m0_45371381的博客
				

				

					02-06
					
					1070
					
				

			

		

		

			
				
在 Lua 中并没有像传统面向对象语言（如 Java、Python 等）那样内置的类和继承机制，但可以通过表（table）和元表（metatable）来模拟实现类、继承、封装和多态的概念。下面将详细介绍如何实现这些特性，并给出具体的代码示例。function Person:new(“Alice”, 25) 被 Lua 内部转换为 function Person:new(self, “Alice”, 25)，此时 self 指向 Person 表。

			
		

	





	

		

			

				
					
lua中实现类

				
			

			

				

					ninesnow_c的博客
				

				

					11-17
					
					192
					
				

			

		

		

			
				
要求：

模仿C++类的行为
实现 a = A()
类的复制实现深拷贝
实现构造函数
只考虑单继承，多继承实现在lua程序设计中有提及，但是个人认为在lua中使用多继承会不会不太合适。

local function class(...) --只考虑单继承
    local tmpClass = {
        classType = 'class',
        _ctor = function () end
    }
    local mt = {}
    for key, value 

			
		

	





	

		

			

				
					
Lua学习-------类

				
			

			

				

					木辛木又
				

				

					03-22
					
					206
					
				

			

		

		

			
				
print("************类************")

--Lua中默认没有面向对象 需要自己实现
--成员变量 成员函数
student = {
	--年龄 
	age = 1,
	--性别
	sex = true,
	--成长函数
	Up = function ()
		student.age = student.age + 1
		print("我成长了")
	end,
	--学习函数
	Learn= function ()
		print("好好学习，天天向上")
	end,
	In

			
		

	





	

		

			

				
					
Lua 类和结构体

				
			

			

				

					LuckyMechanic的博客
				

				

					07-19
					
					4556
					
				

			

		

		

			
				
Lua中默认是没有面向对象的，需要靠我们自己实现
成员变量 成员函数
Student = {
	age = 18,
	sex = true,
	Up = function ()
		print('长大了')
	end
}

Lua中类的表现更像是一个类中包含有很多的静态变量和函数
print(Student.age)
Student.Up()


在声明表后，可以在表外去声明表有的变量和方法
表内是没有name这个属性的，我们在表外给它添加了

Student.name= '少年'

--表外加函数有两种写

			
		

	





	

		

			

				
					
lua 类的详解

				
			

			

				

					boshuzhang的专栏
				

				

					03-03
					
					362
					
				

			

		

		

			
				
lua对象类


2014-05-29 16:22 4937人阅读 评论(3) 收藏 举报



 分类：

各种脚本（4） 



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



0.lua的类

(1)lua的类实际上就是lua的 table ，类之间的继承实际上就是吧 table 连到一起了，调用方法和属性，

    就是先去第一个ta

			
		

	





	

		

			

				
					
lua的类与继承

				
			

			

				

					牛儿吃草的博客
				

				

					02-28
					
					1692
					
				

			

		

		

			
				
一些面向对象的语言中提供了类的概念，作为创建对象的模板。在这些语言里，对象是类的实例。Lua 不存在类的概念，每个对象定义他自己的行为并拥有自己的形状（shape） 。在这些语言中， 对象没有类。 相反， 每个对象都有一个 prototype（原型） ，当调用不属于对象的某些操作时，会最先会到 prototype 中查找这些操作。在这类语言中实现类（class）的机制，我们创建一个对象，作为其它对

			
		

	





	

		

			

				
					
Lua 关于类的理解整理

				
			

			

				

					qq_32725345的博客
				

				

					09-20
					
					440
					
				

			

		

		

			
				
1. Lua 是过程式的语言，本身没有类的概念。但是Lua 是用C实现的，本身很多东西可以拓展，类也是一样的。
2. 在Lua中，有一个表的东西，本质上是一个Hashmap,key-value 键值对这种，如果在map中找不到这个值，就会触发lua表的一套查找机制，
正是通过这个查找机制，来实现“类”的操作。
3. 元表的概念。

			
		

	





	

		

			

				
					
lua 类实现

					
最新发布

				
			

			

				

					03-22
				

			

		

		

			
				
### Lua 实现面向对象编程：类定义与继承

#### 类的定义
在 Lua 中，可以利用表（table）和元表（metatable）来模拟类的概念。一个类通常由一个表表示，其中包含了静态变量、静态函数以及用于创建实例的方法 `new`。以下是实现类的一个基本方式：

```lua
-- 定义一个类 MyClass
local MyClass = {}
MyClass.__index = MyClass -- 设置元表的 __index 属性指向自身

function MyClass:new(instance)
    instance = instance or {} -- 创建一个新的实例或者使用传入的对象
    setmetatable(instance, self) -- 将实例的 metatable 设为类本身
    return instance
end

function MyClass:method()
    print("This is a method of MyClass.")
end

-- 使用类创建实例
local obj = MyClass:new() -- 调用 new 方法创建实例
obj:method() -- 输出 "This is a method of MyClass."
```

上述代码展示了如何通过表和元表构建一个简单的类[^1]。

---

#### 成员变量与成员函数
在 Lua 的面向对象模型中，成员变量和成员函数都存储在实例表中。可以通过 `self` 关键字访问当前实例的数据。

```lua
function MyClass:new(name)
    local instance = {
        name = name -- 初始化成员变量
    }
    setmetatable(instance, self)
    return instance
end

function MyClass:sayHello()
    print("Hello, my name is " .. self.name) -- 访问成员变量
end

-- 测试
local person = MyClass:new("Alice") -- 创建实例并初始化名称
person:sayHello() -- 输出 "Hello, my name is Alice"
```

此部分实现了带有成员变量和成员函数的简单类结构[^4]。

---

#### 继承机制
Lua 并不提供内置的关键字支持继承，但可以通过设置元表的 `__index` 字段来实现继承关系。子类会自动查找父类中的方法或字段。

```lua
-- 父类 BaseClass
local BaseClass = {}
BaseClass.__index = BaseClass

function BaseClass:new()
    local instance = {}
    setmetatable(instance, self)
    return instance
end

function BaseClass:greet()
    print("Greeting from BaseClass!")
end

-- 子类 SubClass
local SubClass = {}
SubClass.__index = SubClass

setmetatable(SubClass, { __index = BaseClass }) -- 子类继承自父类

function SubClass:new()
    local instance = BaseClass:new() -- 调用父类构造器
    setmetatable(instance, self)
    return instance
end

function SubClass:hello()
    print("Hello from SubClass!") -- 自定义方法
end

-- 测试
local subObj = SubClass:new()
subObj:hello()      -- 输出 "Hello from SubClass!"
subObj:greet()       -- 输出 "Greeting from BaseClass!" (继承自父类)
```

这段代码演示了如何通过 `__index` 元方法实现继承功能[^5]。

---

#### 动态扩展与多态
由于 Lua 是动态类型的脚本语言，可以在运行时修改类的行为或添加新的方法。这使得 Lua 的 OOP 更加灵活。

```lua
function SubClass:overrideMethod()
    print("Overridden method in SubClass.") -- 重写父类方法
end

if not SubClass.overrideMethod then
    function SubClass:defaultBehavior()
        print("Default behavior added dynamically.")
    end
end

local dynamicInstance = SubClass:new()
dynamicInstance:overrideMethod() -- 输出 "Overridden method in SubClass."
dynamicInstance:defaultBehavior() -- 如果未被覆盖，则执行默认行为
```

以上代码片段说明了 Lua 支持动态扩展的能力[^2]。

---

#### 工具库辅助开发
对于更复杂的项目，可以直接借助现有的工具库简化类定义和继承过程。例如 Cocos2d-x 提供了一个名为 `cc.class` 的工具函数，能够快速完成类的设计和继承操作[^3]。

```lua
local cc = require("cocos.framework.cc")

local Animal = cc.class("Animal")
function Animal:ctor(name)
    self._name = name
end

function Animal:speak()
    print(self._name .. " makes a sound.")
end

local Dog = cc.class("Dog", Animal) -- Dog 继承自 Animal
function Dog:ctor(name)
    Dog.super.ctor(self, name) -- 调用父类构造器
end

function Dog:bark()
    print(self._name .. " barks loudly.")
end

local doggy = Dog.new("Rex")
doggy:speak() -- 输出 "Rex makes a sound."
doggy:bark()  -- 输出 "Rex barks loudly."
```

这一例子进一步证明了 Lua 在实际应用中的灵活性和可扩展性。

---

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

  
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值