最新要闻

广告

手机

iphone11大小尺寸是多少？苹果iPhone11和iPhone13的区别是什么？

iphone11大小尺寸是多少？苹果iPhone11和iPhone13的区别是什么？

 警方通报辅警执法直播中被撞飞：犯罪嫌疑人已投案

警方通报辅警执法直播中被撞飞：犯罪嫌疑人已投案

家电

  1. 首页
  2. 移动通信
  3. 内容

Lua 中如何实现继承

来源：博客园

本文主要参考了菜鸟教程中的 Lua 面向对象，再加上自己学习过程的中思考，特此记录，如果文中有不对的地方，请不吝赐教。

这里就不在介绍面向对象的基本思想了，主要讲一讲 Lua 中如何实现继承，包括单继承和多继承。

1、如何定义一个类

我们知道，对象由属性和方法组成。Lua 中最基本的结构是table，所以需要用 table 来描述对象的属性。


(资料图)

Lua 中的 function 可以用来表示方法。那么 Lua 中的类可以通过table + function 模拟出来。

那我们需要的继承，可以通过 metetable模拟出来（不推荐用，只模拟最基本的对象大部分实现够用了）。

Lua 中的 table 不仅在某种意义上是一种对象。既可以像对象一样，有自己的状态（成员变量）。同时也有与对象的值独立的本性，特别是拥有两个不同值的对象（table）代表两个不同的对象；一个对象在不同的时候也可以有不同的值，但他始终是一个对象；与对象类似，表的生命周期与其由什么创建、在哪创建没有关系。对象有他们的成员函数，表也有。

这段话是看懵逼了，说下自己的理解吧，不对的话，欢迎评论区指出，十分感谢。

这段话主要在介绍 Lua 中的表（table）与对象的相似之处。表不仅仅是一种数据结构，它也有状态（成员变量），并且每个表都是独立的，即使两个表的值相同，它们也代表两个不同的对象。与对象类似，表也有生命周期，与其创建方式和创建位置无关。此外，表也有成员函数，可以通过函数来操作表的数据。

先提一嘴，下面的 new 方法是自定义的，并不是规定必须这样做，写成 abc 都是可以的。

-- 元类Shape = {area = 0}-- 基础类方法 newfunction Shape:new (o,side)  o = o or {}  setmetatable(o, self)  self.__index = self  side = side or 0  self.area = side*side;  return oend-- 基础类方法 printAreafunction Shape:printArea ()  print("面积为 ",self.area)end-- 创建对象myshape = Shape:new(nil,10)myshape:printArea()

上面的方式在创建对象时，需要手动传入 nil 参数，不太优雅，我们可以对其进行封装。

--创建一个类，表示四边形local RectAngle = { length, width, area } --声明类名和类成员变量 function RectAngle: new (len,wid) --声明新建实例的New方法local o = {--设定各个项的值 length = len or 0, width = wid or 0, area =len*wid}setmetatable(o,{__index = self} )--将自身的表映射到新new出来的表中return oendfunction RectAngle:getInfo()--获取表内信息的方法return self.length,self.width,self.areaenda = RectAngle:new(10,20)print(a:getInfo())      -- 输出：10    20    200b = RectAngle:new(10,10)print(b:getInfo())      -- 输出：10    10    100print(a:getInfo())      -- 输出：10    20    200

上面 就是 把 变量 o 的创建时候，放到了函数里面而已，并没特别的地方，但是可以省去我们调用时每次都需要传 nil 的麻烦。

2、前置知识

在学习如何使用 Lua 实现继承之前，我们先来学习几个 Lua 的基本知识，为后面的继承打下基础。

  • table
  • Metatable

2.1 table 的简单介绍

下面看看如何初始化表

-- 初始化 表Stu1 = {age=10, sex=1}-- 指定值Stu1["name"] = "xiaoming"-- 添加方法function Stu1:getSex()return self.sexendfunction Stu1:getName()return Stu1.nameendprint(Stu1["name"])  -- xiaomingprint(Stu1["age"])  -- 10print(Stu1.age)  -- 10 print(Stu1:getSex())  -- 1-- print(Stu1["getSex"]())  报错print(Stu1["getName"]())  -- xiaoming

对于上面不清楚的同学，可以看看我之前写的 lua中 . 和 : 的区别 这篇文章。

2.2 Metatable

下面的内容都是来自 Lua 元表(Metatable)

在 Lua table 中我们可以访问对应的 key 来得到 value 值，但是却无法对两个 table 进行操作(比如相加)。

因此 Lua 提供了元表(Metatable)，允许我们改变 table 的行为，每个行为关联了对应的元方法。

例如，使用元表我们可以定义 Lua 如何计算两个 table 的相加操作 a+b。

当 Lua 试图对两个表进行相加时，先检查两者之一是否有元表，之后检查是否有一个叫 __add的字段，若找到，则调用对应的值。 __add等即时字段，其对应的值（往往是一个函数或是 table）就是元方法。

有两个很重要的函数来处理元表：

  • setmetatable(table,metatable):对指定 table 设置元表(metatable)，如果元表(metatable)中存在 __metatable 键值，setmetatable 会失败。
  • getmetatable(table):返回对象的元表(metatable)。

以下实例演示了如何对指定的表设置元表：

mytable = {}                          -- 普通表mymetatable = {}                      -- 元表setmetatable(mytable,mymetatable)     -- 把 mymetatable 设为 mytable 的元表

以上代码也可以直接写成一行：

mytable = setmetatable({},{})

以下为返回对象元表：

getmetatable(mytable)                 -- 这会返回 mymetatable
3.2.1 __index 元方法

这是 metatable 最常用的键。

当你通过键来访问 table 的时候，如果这个键没有值，那么Lua就会寻找该table的metatable（假定有metatable）中的__index 键。如果__index包含一个表格，Lua会在表格中查找相应的键。

我们可以在使用 lua 命令进入交互模式查看：

$ luaLua 5.3.0  Copyright (C) 1994-2015 Lua.org, PUC-Rio> other = { foo = 3 }> t = setmetatable({}, { __index = other })> t.foo3> t.barnil

如果__index包含一个函数的话，Lua就会调用那个函数，table和键会作为参数传递给函数(这句话很重要，后面的多重继承就使用到了这个原理)。

__index 元方法查看表中元素是否存在，如果不存在，返回结果为 nil；如果存在则由__index返回结果。

mytable = setmetatable({key1 = "value1"}, {  __index = function(mytable, key)    if key == "key2" then      return "metatablevalue"    else      return nil    end  end})print(mytable.key1,mytable.key2)

实例输出结果为：

value1    metatablevalue

实例解析：

  • mytable 表赋值为 {key1 = "value1"}。

  • mytable 设置了元表，元方法为 __index。

  • 在mytable表中查找 key1，如果找到，返回该元素，找不到则继续。

  • 在mytable表中查找 key2，如果找到，返回 metatablevalue，找不到则继续。

  • 判断元表有没有__index方法，如果__index方法是一个函数，则调用该函数。

  • 元方法中查看是否传入 "key2" 键的参数（mytable.key2已设置），如果传入 "key2" 参数返回 "metatablevalue"，否则返回 mytable 对应的键值。

我们可以将以上代码简单写成：

mytable = setmetatable({key1 = "value1"}, { __index = { key2 = "metatablevalue" } })print(mytable.key1,mytable.key2)

总结：

Lua 查找一个表元素时的规则，其实就是如下 3 个步骤:

  • 1.在表中查找，如果找到，返回该元素，找不到则继续
  • 2.判断该表是否有元表，如果没有元表，返回 nil，有元表则继续。
  • 3.判断元表有没有__index方法，如果__index方法为 nil，则返回 nil；如果__index方法是一个表，则重复 1、2、3；如果__index方法是一个函数，则返回该函数的返回值。

3、单继承

当我们学习了 Lua 中如何定义一个类后，就可以考虑，如何在 Lua 中实现单继承了。接下来，我们一起看看如何实现单继承。

-- 元类local Base = {}-- 基础类方法 newfunction Base:new(name)local o = {name = name or "default"}--将自身的表映射到新new出来的表中setmetatable(o, self)self.__index = self  return oendfunction Base:run()print(self.name .. " is running....")end-- 创建对象b = Base:new("Base")b:run()print(string.rep("*", 30))-- 创建派生类对象-- 重点理解这里为何需要这样初始化对象，而不能像这样 T3 = {} 初始化变量 T3-- 原因就在于 T3:new() 中 self 变量就是 T3 这个变量，当使用 setmetseatable、__index 时，才会给-- T3:new() 中的变量o 添加上 Base 定义的属性和方法。T3 = Base:new()-- 派生类方法 newfunction T3:new(name)-- 实现继承，这里实现继承不仅仅是靠下面这一句实现的-- 而是 加上 setmetatable、__index 才模拟出 继承的现象local o = Base:new(name)setmetseatable(o, self)self.__index = selfreturn oendlocal t3 = T3:new("T3")t3:run()print(string.rep("*", 30))-- 创建派生类对象BYD = Base:new()-- 派生类方法 newfunction BYD:new(name)-- 实现继承，这里实现继承不仅仅是靠下面这一句实现的-- 而是 加上 setmetatable、__index 才模拟出 继承的现象local o = Base:new(name)setmetatable(o, self)self.__index = selfreturn oend-- 派生类创建方法function BYD:power()print(self.name .. " 正在充电.....")endlocal byd = BYD:new("BYD")byd:run()byd:power()print(string.rep("*", 30))

运行结果：

Base is running....******************************T3 is running....******************************BYD is running....BYD 正在充电.....******************************

从上面可以看到，T3、BYD 这两个类 继承 了 Base 类的 run 方法。

4、多继承

4.1 线性多重继承

A1 = {}function A1:new(name)local o = {name = name or "A1"}setmetatable(o, {__index = self})return oendfunction A1:printA1()print(self.name .. "is coming printA1")end-- 重点理解这里为何需要这样定义，而不能 A2 = {} 这样初始化变量 A2A2 = A1:new()function A2:new(name)-- 这样就可以继承A1定义的方法local o = A1:new(name) setmetatable(o, {__index = self})return oendfunction A2:printA2()print(self.name .. "is coming printA2")endA3 = A2:new()function A3:new(name)local o = A2:new(name)setmetatable(o, {__index = self})return oendfunction A3:printA3()print(self.name .. "is coming printA3")end-- 创建对象a = A3:new("I"m a ")a:printA1()a:printA2()a:printA3()

运行结果：

I"m a is coming printA1I"m a is coming printA2I"m a is coming printA3

上面这种方法，是比较容易想到的实现多重继承的方式，但是这种方式有一定的局限性，继承不够灵活。下面再来看看另外一种继承方式，相当而言就会灵活很多。

4.2 更加灵活的多重继承

-- 在 table 变量 cList 中查找 klocal function search(k, cList)for i=1,#cList dolocal v = cList[i][k]-- 尝试第i个基类if v thenreturn vendendendfunction createClass(...)local c = {}print("c 的地址 -->", c)local parents = {...}-- 类在其父类列表中的搜索方法  setmetatable(c, {__index = function(t, k)-- 这里传入的 t 就是 刚刚定义的 c-- 如果__index包含一个函数的话，Lua就会调用那个函数，table和键会作为参数传递给函数。-- __index 元方法查看表中元素是否存在，如果不存在，返回结果为 nil；如果存在则由 __index 返回结果。print("t 的地址 -->", t)print("k -->", k)    return search(k, parents)  end})  -- 将"c"作为其实例的元表  c.__index = c  -- 为这个新类定义一个新的构造函数  function c:new(o)    o = o or {}    setmetatable(o, c)    return o  end  return c                       -- 返回新类end-- 类NamedNamed = {}function Named:getname()  return self.nameendfunction Named:setname(n)  self.name = nend-- 类AccountAccount = {balance = 0}function Account:withdraw(w)  self.balance = self.balance - wendprint("Account -->", Account["withdraw"])-- 创建一个新类NamedAccount，同时从Account和Named派生NamedAccount = createClass(Account, Named)account = NamedAccount:new()account:setname("Ives")print(account:getname())         -- 输出 Ivesaccount:withdraw(10)print(account.balance)

运行结果：

Account["withdraw"] --> function: 039BD710c 的地址 -->    table: 039BB7E8t 的地址 -->    table: 039BB7E8k -->   setnamet 的地址 -->    table: 039BB7E8k -->   getnameIvest 的地址 -->    table: 039BB7E8k -->   withdrawt 的地址 -->    table: 039BB7E8k -->   balance-10

参考资料：

Lua 面向对象

关键词：