Lua学习笔记--面向对象

怼烎@ 2022-08-21 05:00 251阅读 0赞

# 一.引言 #

最近又开始折腾Lua了，说实话以前没有把Lua看成什么高深的语言，一直把他当做是配合宿主程序的所谓的“脚本”（虽然事实的确如此），不过最近看了一些Lua代码才发现，原来Lua可以通过很简单巧妙的变化，模拟出一些其他语言引以为傲的特性，真没想到Lua还可以这样玩，哈哈。

目前主流的编程语言C++/C\#/Java都是面向对象的语言，面向对象符合我们正常的思维观念，面向对象的特性，封装，继承等更是可以大大的帮助我们提升编程的效率。比如我们要写一系列的人物对象，每个对象的基础方法都相同，只是有一些特有的方法和字段，如果没有面向对象，我们可能就要“Ctrl+C”，"Ctrl+V"了，这可是写代码的大忌啊。所以机智的先人们早就想好了怎么让Lua面向对象了。

不过在学习怎么让Lua面向对象之前，还要学习一点预备知识，因为这个东东才是让Lua能够面向对象的秘密武器。

# 二.元表&元方法 #

## 1.元表（metatable）简介 ##

元表是Lua中很重要的一个概念，所谓元表(metatable)，就是对应一个类型最基本的一些方法的集合，这些方法叫做元方法（metamethod）。  
举个例子来说明一下。比如+方法，我们给两个数进行加法运算，系统就会自己调用数的\_\_Add元方法进行加法操作。我们并没有定义这个方法，  
但是Lua会去数的元表里找到\_Add进行加法运算。  
Lua中，我们定义一个table时，是不会自动生成元表的。

_G.Base = {}
    
    Base.name = "Base"
    
    function Test()
        print(getmetatable(Base));
    end
    
    Test()

结果：

nil

我们可以通过setmetatable方法来给table设置元表。看一个例子：

Set = {}
    
    --创建新的Set
    function Set.new(l)
    	local set = {}
    	for _,v in ipairs(l) do
    	set[v] = true
    	end
    	return set
    end
    
    --打印传入的Set
    function Set.Print(s)
    	for e in pairs(s) do
    	print(tostring(e))
    	end
    end
    
    --Union方法，合并两个Set
    function Set.Union(a,b)
    	local newSet = {}
    	for e in pairs(a) do newSet[e] = true end
    	for e in pairs(b) do newSet[e] = true end
    	return newSet;
    end
    
    s1 = Set.new{1,2,3}
    s2 = Set.new{4,5,6}
    Set.Print(s1) --输出1，2，3
    Set.Print(s2) --输出4，5，6
    newS = Set.Union(s1,s2)
    Set.Print(newS) --输出1，2，3，4，5，6

这是一个合并两个集合的代码，调用方式比较麻烦，有没有类似C++运算符重载的那种操作呢？这就要用到传说中的元表了。只要加上这样几句话，我们就可以实现“+”运算符把集合取并集的功能啦：

--元表
    local mt = {}
    --元表的Add方法（+运算符）设置为Set.Union方法
    mt.__add = Set.Union
    
    --创建新的Set
    function Set.new(l)
    	local s = {}
    	--在要返回的s上设置元表
    	setmetatable(s, mt)
    	for _,v in ipairs(l) do
    	s[v] = true
    	end
    	return s
    end
    
    --可以这样调用啦
    newSet = s1 + s2
    Set.Print(newSet) --输出1，2，3，4，5，6

当然，元方法不止这么多，类似的，我们还可以实现\_\_sub，\_\_tostring，\_\_index等等元方法。

## 2.\_\_index元方法 ##

有这么多元方法，不过还是要说一个跟面向对象关系最密切的元方法，\_\_index元方法。这个方法是干什么的呢？

我们知道，lua所有的东西都存储在表中，当我们访问一个存在表中的key-value对时，如果有这个key-value对，那么会返回value。但是如果不存在，就会返回nil。话是这么说，不过这中间还我们还忽略了一个过程，lua在找不到这个key-value对之后并不会立刻返回nil，而是会去找这个表有木有一个叫做\_\_index的元方法，如果index元方法有值，那么会先返回\_\_index元方法所指的内容，如过没有的话，才返回nil。

总结一下Lua查找table中值的过程如下：

1）查找table中对应key的字段，有则返回，没有进行下一步；

2）查找table是否有元表，元表中是否有\_\_index元方法，如果有返回元方法的值，没有进行下一步；

3）如果\_\_index是一个值，或者函数，返回该值或函数，如果是nil，返回nil，如果是一个表，进行下一步；

4）在\_\_index指向的这个表中继续1）2）3）步骤。

好了，为了验证这个结论，我们做一个小实验：

--直接输出
    Set1 = {}
    print(Set1.hello); --输出nil
    
    
    --只设置元表
    Set2 = {}
    Set2.mt2 = {}
    
    function Set2.new()
    	local o = {}
    	setmetatable(o, Set2.mt2)
    	return o
    end
    
    so2 = Set2.new()
    print(so2.hello) --虽然设置了元表，但是没有设置__index元方法，所以还是nil
    	
    
    --设置元表和__index元方法
    Set3 = {}
    Set3.mt3 = {}
    
    function Set3.func()
    	return "I am meta method!"
    end
    Set3.mt3.__index = Set3.func
    
    function Set3.new()
    	local o = {}
    	setmetatable(o,Set3.mt3)
    	return o
    end
    
    so3 = Set3.new()
    print(so3.hello) --输出I am meta method! 有元方法__index，就返回index所指向的内容
    
    --设置元表和__index元方法，此处__index指向了一个含有hello的表
    Set4 = {}
    Set4.mt4 = {}
    
    Set4Base = {}
    Set4Base.hello = "I am base, I have hello"
    
    Set4.mt4.__index = Set4Base
    
    function Set4.new()
    	local o = {}
    	setmetatable(o,Set4.mt4)
    	return o
    end
    
    so4 = Set4.new()
    print(so4.hello) --输出I am base, I have hello 有元方法__index，且index指向了一个表，在这个表中找到了hello字段

通过上面的实验，我们看出，\_\_index元方法确实比较强大，可以让我们在找不到内容的时候将内容指向我们希望返回的函数，值，或者table。

# 三.面向对象 #

## 1.重要关键字：self ##

所谓面向对象，就是一些数据和方法被封装在了对象里面。lua能不能做到这一点呢？想想table，我们在一个table里面定义字段，方法，那么这个table不就相当于对象了吗？并且Lua为我们提供了一个面向对象最关键的关键字self，相当于C++中的this指针。

关于self，我们可以先看一下在table中定义的lua函数：

Set = {}
    Set.hello = "1"
    Set.world = "2"
    
    --这个s参数就是要被操作的Set对象
    function Set.Get1(s, key)
    	return s[key]
    end
    
    --不过Lua还有另外一种方式，简化了函数的定义和调用
    --这种方式使用：来定义和调用函数。相当于把对象本身传递进去
    function Set:Get2(key)
    	return self[key] 
    end
    
    
    
    --把对象本身也传递进去
    print(Set.Get1(Set, "hello")) --输出1
    --省略了对象自己，有木有像C++那样默认传递this指针,注意要用：调用！
    print(Set:Get2("hello")) --输出1

看到了self倍感亲切，尤其是跟C++省略this指针一样的使用方式。看来lua也专门为了面向对象做了些工作呢。

## 2.怎么创建对象 ##

既然我们把方法和函数都放到了一个table里面了，这个table就相当于一个对象了。但是，但是！只有一个啊！那么我们怎么创建一个类的多个实例呢？对，没有对象就要new一个，只不过这个new要我们自己实现：

Set = {}
    --传说中的new方法，自己创建一个local对象返回回去就是新对象啦！
    function Set:new(name)
    	local o = {}
    	o.name = name
    	return o
    end
    
    
    
    set1 = Set:new("set1")
    set2 = Set:new("set2")
    print(set1.name)--输出set1
    print(set2.name)--输出set2

我们看到，通过我们Set类的new方法，创建了两个不同的对象，每个对象内部都封装了自己的name字段。

## 3.继承 ##

还是上面的例子，我们想要打印一下name，那么我们直接在Set上写一个printName的方法，是不是可以打印对象的Name字段了呢？我们试一下：

Set = {}
    --传说中的new方法，自己创建一个local对象返回回去就是新对象啦！
    function Set:new(name)
    	local o = {}
    	o.name = name
    	return o
    end
    
    --把对象本身传入的方法
    function Set.printName1(s)
    	print(s.name)
    end
    
    --使用self省略对象本身的方法
    function Set:printName2()
    	print(self.name)
    end
    
    set1 = Set:new("set1")
    set2 = Set:new("set2")
    --直接使用Set方法调用（有木有点像C++的Static方法？）
    Set.printName1(set1) --输出set1
    --下面的会报错
    --set1.printName1(set1)--找不到printName1方法
    --set2.printName1(set2)--找不到printName1方法
    --set1:printName2()--找不到printName2方法
    --set2:printName2()--找不到printName2方法
    --没有定义Set对象本身的name字段，所以是nil
    Set:printName2()   --nil

HOHO，好像失败了呢！除了使用Set对象自身的printName方法把并且把set1对象自己穿进去的那个示例，其他的都挂掉了。我们分析一下，为什么会酱紫。

Set.printName1和Set.printName2都是定义在Set类（姑且称之为类吧，其实它也是个对象）上的，而我们使用set1,set2来调的时候，这两个对象并没有定义这个方法，所以当然找不到了。最后，Set.printName2虽然调用成功了（肯定成功了，函数就是定义在它上面的），但是值却是nil。因为Set对象并没有定义name字段。

那么，那么，我们难道要给set1和set2分别定义一个printName方法吗？答案肯定是不用啦，不然我们这么半天不是白忙活了...

下面进入正题！怎么用Lua实现继承！

上一大节说到，\_\_index元方法如果指向了一个table，在表本身找不到相应字段的时候，就会去该table中找。想想看，这个table像什么？对了，基类！我们把子类的元表的\_\_index方法设置成基类的表。这样，在我们找一个方法找不到的时候，就会去相应的基类去寻找，这正是面向对象继承的特性。

废话多说，上代码：

Set = {}
    
    --Set类的元表mt
    Set.mt = {}
    --设置元表的__index元方法为Set本身，这样在子类找不到方法定义时，会到Set类去找方法定义
    Set.mt.__index = Set
    
    
    --传说中的new方法，自己创建一个local对象返回回去就是新对象啦！
    function Set:new(name)
    	local o = {}
    	o.name = name
    	--给new粗来的对象设置元表
    	setmetatable(o, Set.mt)
    	return o
    end
    
    --把对象本身传入的方法
    function Set.printName1(s)
    	print(s.name)
    end
    
    --使用self省略对象本身的方法
    function Set:printName2()
    	print(self.name)
    end
    
    set1 = Set:new("set1")
    set2 = Set:new("set2")
    --直接使用Set方法调用（有木有点像C++的Static方法？）
    Set.printName1(set1) --输出set1
    --下面的会报错
    set1.printName1(set1)--set1
    set2.printName1(set2)--set2
    set1:printName2()--set1
    set2:printName2()--set2
    --没有定义Set对象本身的name字段，所以是nil
    Set:printName2()   --nil

set1，set2对象虽然没有定义printName1,2方法，但是他们设置了元表，元表的\_\_index方法设置了找不到方法时指向的Set对象。调用时如果本类中没有该方法，就会去基类Set中找这个方法，这样就实现了继承！！

我们如果不想要基类的方法，也可以覆盖掉这个方法：

set1 = Set:new("set1")
    set2 = Set:new("set2")
    
    --覆写set1对象的printName2方法，注意：要在set1创建之后！不然会找不到set1的
    function set1:printName2()
    	print("haha")
    end
    
    --会调用被覆写了的函数
    set1:printName2()--haha

# 四.总结 #

关于Lua面向对象暂时就说这么多。总结一下个人的一点点想法：Lua所谓的面向对象并不是真正的面向对象，而是方便我们实现代码复用的一种方式。因为一般一个类只有一个对象，子类对象继承基类的固有方法，实现一些自己的方法，覆写一些方法就可以了。

当然，还有一些更高级的应用，比如多重继承，字段的封装，可能我不知道，也欢迎大家指正。