lua类

最新推荐文章于 2025-10-15 09:56:45 发布
原创 最新推荐文章于 2025-10-15 09:56:45 发布 · 531 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#lua

本文探讨了Lua语言中冒号(:)与点(.)在类方法定义与调用时的不同之处，通过一个简单的Account类实例，展示了如何使用冒号正确地引用self变量，并解释了在何种情况下使用点会引发错误。 
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类（面向对象程序设计）

				
			

			

				

					昔拉的博客
				

				

					02-20
					
					2054
					
				

			

		

		

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

			
		

	



                

            
              



	

		

			

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

				
			

			

				

					manch1986的专栏
				

				

					09-27
					
					679
					
				

			

		

		

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

			
		

	



              


  
              

                


	

		

			

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

					
热门推荐

				
			

			

				

					——
				

				

					03-05
					
					3万+
					
				

			

		

		

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

			
		

	





	

		

			

				
					
Lua中，表、元表、对象、类的解析

					
最新发布

				
			

			

				

					一个金牛座猿猿子的技术分享空间
				

				

					10-15
					
					1121
					
				

			

		

		

			
				
本文系统解析了Lua中的表、元表、对象和类的关系。表是Lua唯一的复合数据结构，可作数组、字典、对象等用途。元表作为表的"行为说明书"，通过元方法(__index、__call等)控制表的操作行为。对象本质上是表+方法+可选元表，支持状态和行为封装。通过原型继承机制，利用元表的__index特性可实现类式编程，包括构造函数、继承等面向对象特性。文章详细介绍了四者的实现方式、核心作用及最佳实践，提供了完整的代码示例和关系图谱，揭示了Lua基于原型实现面向对象编程的核心机制。

			
		

	



		

			
		



	

		

			

				
					
Lua 中实现类

				
			

			

				

					11-03
				

			

		

		

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

			
		

	





	

		

			

				
					
lua 类

				
			

			

				

					哲学天空的博客
				

				

					01-16
					
					549
					
				

			

		

		

			
				

-- 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类_1_0-190807150128.alp

				
			

			

				

					10-27
				

			

		

		

			
				
Android andlua androlua lua实战工程

			
		

	





	

		

			

				
					
Lua 类的继承与override

				
			

			

				

					11-04
				

			

		

		

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

			
		

	





	

		

			

				
					
Lua类

				
			

			

				

					koganlee的博客
				

				

					06-21
					
					482
					
				

			

		

		

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

			
		

	





	

		

			

				
					
lua的类

				
			

			

				

					dong_forever的专栏
				

				

					10-30
					
					579
					
				

			

		

		

			
				
类是包含属性与方法的一个集合。是一个键值对的集合。 
可以用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实现类

				
			

			

				

					m0_45371381的博客
				

				

					02-06
					
					1278
					
				

			

		

		

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

			
		

	





	

		

			

				
					
lua中实现类

				
			

			

				

					ninesnow_c的博客
				

				

					11-17
					
					215
					
				

			

		

		

			
				
要求：

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

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

			
		

	





	

		

			

				
					
Lua学习-------类

				
			

			

				

					木辛木又
				

				

					03-22
					
					236
					
				

			

		

		

			
				
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
					
					4637
					
				

			

		

		

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

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


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

Student.name= '少年'

--表外加函数有两种写

			
		

	





	

		

			

				
					
lua 类的详解

				
			

			

				

					boshuzhang的专栏
				

				

					03-03
					
					377
					
				

			

		

		

			
				
lua对象类


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



 分类：

各种脚本（4） 



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



0.lua的类

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

    就是先去第一个ta

			
		

	





	

		

			

				
					
lua的类与继承

				
			

			

				

					牛儿吃草的博客
				

				

					02-28
					
					1708
					
				

			

		

		

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

			
		

	





	

		

			

				
					
Lua 关于类的理解整理

				
			

			

				

					qq_32725345的博客
				

				

					09-20
					
					456
					
				

			

		

		

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

			
		

	





	

		

			

				
					
lua类方法

				
			

			

				

					08-11
				

			

		

		

			
				
### 类方法的实现原理

Lua 语言本身并没有“类和对象”的概念，但可以通过 `table` 和元表（metatable）机制来模拟类的行为。类方法的实现依赖于元表中的 `__index` 元方法，该方法用于在访问表中不存在的键时提供查找路径。通过将方法定义在元表的 `__index` 字段中，可以实现类方法的共享机制，使得所有实例都能访问到相同的方法。

```lua
local Person = {}
Person.__index = Person

function Person:new(name)
    local instance = setmetatable({}, self)
    instance.name = name
    return instance
end

function Person:sayHello()
    print("Hello, " .. self.name)
end

local p = Person:new("Alice")
p:sayHello() -- 输出 Hello, Alice
```

在上述示例中，`Person` 是一个表，通过将其自身设置为元表的 `__index` 值，使得所有实例在访问未定义的字段或方法时会查找 `Person` 表中的内容。`new` 方法用于创建新的实例，并设置其元表为 `Person`，从而实现类与实例的关系。

### 静态方法的实现

静态方法不属于类的实例，而是直接定义在类表上。静态方法的调用不依赖于实例，而是通过类本身调用。这种方式常用于实现与类相关但不涉及实例状态的功能。

```lua
function Person.createDefault()
    return Person:new("Unknown")
end

local defaultPerson = Person:createDefault()
defaultPerson:sayHello() -- 输出 Hello, Unknown
```

上述 `createDefault` 方法即为静态方法，它不依赖于具体的实例，而是通过类名 `Person` 调用。

### 继承与方法重写

通过设置子类的元表，并将子类的 `__index` 指向父类，可以实现继承机制。子类可以重写父类的方法，或者通过 `super` 机制调用父类方法。

```lua
local Student = {}
Student.__index = Student
setmetatable(Student, Person)

function Student:new(name, school)
    local instance = Person.new(self, name)
    instance.school = school
    return instance
end

function Student:sayHello()
    print("Student: " .. self.name .. " from " .. self.school)
end

local s = Student:new("Bob", "MIT")
s:sayHello() -- 输出 Student: Bob from MIT
```

在此示例中，`Student` 类继承自 `Person` 类，并重写了 `sayHello` 方法。通过 `setmetatable(Student, Person)` 设置元表，使得 `Student` 可以访问 `Person` 的静态方法和属性。

### 动态扩展类方法

由于 Lua 的 `table` 是引用类型，可以在运行时动态地为类添加方法。通过修改类表中的方法定义，所有实例都会共享这些新增的方法。

```lua
function Person:sayGoodbye()
    print("Goodbye, " .. self.name)
end

s:sayGoodbye() -- 输出 Goodbye, Bob
```

通过在 `Person` 表中添加 `sayGoodbye` 方法，所有 `Person` 实例都可以访问该方法，包括 `Student` 的实例，因为它们共享相同的 `__index` 查找路径。

---

###

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

  

	
    

      

      

      

        
        

          
          

            

              成就一亿技术人!
            

            

              拼手气红包6.0元
            

          

        

        

          

            还能输入1000个字符
          

          

             
          

          

            

              红包
              添加红包
            

            

              表情包
              插入表情
              

                

              

            

            

              表情包
              代码片
              

                
              

            

            

              
              
              
              
              
              
              
            

          

        

      

    

		

			

			

			

					 条评论被折叠 查看
			

			

				
			

		

	

	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

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

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值