【Lua学习笔记】Lua进阶——Table（4）继承，封装，多态

文章目录

• 封装
• 继承
• 多态

---

封装

// 定义基类
Object = {}

//由于表的特性，该句就相当于定义基类变量
Object.id =1

//该句相当于定义方法，Object可以视为定义的对象，Test可以视为方法名
//我们知道Object是一个表，但是抽象地看，请把Object看着面向对象中的 "对象"
function Object:Test()
    print(self.id)
end
// 以上语句等同于：
// public class Object{
	int id=1;
	void Test(Object obj)
		print(obj.id);
}


//定义一个new方法，用于创建这个基类的对象
function Object:new()
	//定义空表obj,用面向对象比喻相当于new了一个空对象
    local obj = {}
    //绑定元表，将元表看作一个基类
    self.__index = self
    setmetatable(obj, self)
    //返回空对象
    return obj
end

local Car = Object:new()  //实际是将new出的空对象return给外部定义的Car
// 以上语句等同于：
// Object Car = new Object();

// 由于Car实际上是空的table，所以访问Car其实是通过__index访问基类中的索引
// 相当于虽然没有定义Car内的变量，但初始化时继承基类的值作为了初始值
print(Car.id) --1，来自元表

// 同样的，Car实际使用了__index基类提供的方法
// 但是由于入参是self，此处就是Car，print(Car.id)，最终还是访问了基类__index找到的Object.id
Car:Test() --1，来自元表

// 定义Car中的变量
Car.id = 2
// 现在Car表中有了索引id，那么就能找到这个索引，所以输出为2
Car:Test() --2，来自子表

现在我们可以像面向对象一样，new一个对应基类的对象了。但是这里的new也不完全相似与面向对象的new，例如我们可以这样做:

Car.name = "a"
print(Car.name)
输出：
a

我们在封装Object类的时候可完全没有name这个索引，而在Lua中我们new了一个新对象，还能新加入一些变量和方法，这些特性明显是继承了父类的子类才有的。算不上坏处，不过我们想要完全实现封装还能加以限制：

//定义一个垃圾列表，将添加到子类的垃圾都丢进去
garbage={}

//定义一个new方法，用于创建这个基类的对象
function Object:new()
	//定义空表obj,用面向对象比喻相当于new了一个空对象
    local obj = {}
    // 禁止子类的添加
    self.__newindex = garbage
    //绑定元表，将元表看作一个基类
    self.__index = self
    setmetatable(obj, self)
    //返回空对象
    return obj
end
local Car = Object:new()
Car.name = "a"
print(Car.name)

输出：
nil

现在我们确实实现封装了，既能访问基类的方法和变量，又能阻止新加的其他东西，但是还得把垃圾及时清理，这点我们将在后文垃圾回收中讲解。

---

继承

面向对象重要的特性之继承，光new一个新对象无法满足全部需要，我们想要重写父类的一些方法而非直接使用它们，就需要继承。

观察上面的Object:new()代码，其实我们如果想用进行继承，其实只需要在上面改改即可

Object = {}
Object.id = 1;
function Object:Test()
    print(self.id)
end

//换种方式，如果我们不return的话，想要返回这个值，可以直接把它丢进全局表中
function Object:subClass(className)
    _G[className] = {}
    self.__index = self
    setmetatable(_G[className], self)
end
Object:subClass("Cat")
print(Cat.id)
输出：
1

继承比封装还要简单一点，其实它和我们第一次定义的封装是一模一样的，只是换了种方式来实现。

// new一个Cat类的对象
local WhiteCat = Cat:new()
print(WhiteCat.id) -- 1

function Object:Test()
    print("我是基类")
end

function Object:new()
    local obj = {}
    self.__newindex = garbage
    self.__index = self
    setmetatable(obj, self)
    return obj
end

function Object:subClass(className)
    _G[className] = {}
    self.__index = self
    setmetatable(_G[className], self)
end

//Cat继承基类
Object:subClass("Cat")
//new一个Cat类的对象WhiteCat
local WhiteCat = Cat:new()
WhiteCat:Test()  -- 我是基类

// 重写Test方法（其实只是新写了一个放在Cat表里被调用，更像重载？）
function Cat:Test()
    print("我是猫类")
end
WhiteCat:Test()  --我是猫类

//想要重写Cat的Test方法？不好意思我已经用__newindex封装好了
//白猫是个对象，而不是Cat这个类，它不应该重写方法
//下面重写的方法会被丢到garbage里
function WhiteCat:Test()
    print("我是白猫")
end
WhiteCat:Test() --我是猫类
garbage:Test() --我是白猫

如果看不明白，建议重学Table，元表以及面向对象

---

多态

多态就是对于一个父类的相同方法，子类可以执行不同的逻辑。实现多态我们可以怎么做？

1. 重写和重载方法
2. 实现接口
3. 实现抽象类和抽象方法

如果重写应当是这样：

function Object:Test()
    print("我是基类")
end
Object:subClass("Cat")
Object:subClass("Dog")
function Cat:Test()
    print("我是猫类")
end
function Dog:Test()
    print("我是狗？")
end

重写固然可以实现，问题在于继承了父类之后的重写是无法保留父类的同名方法的，那我想要访问父类的方法怎么办？

别忘了我们的类其实是个table，我直接把父类存进去，然后要使用的时候访问不就行了吗？反正又没有面向对象语法限制。

function Object:subClass(className)
    _G[className] = {}
    local obj = _G[className]
    self.__index = self
    // 直接把父类表存进子类的base
    obj.base = self
    setmetatable(obj , self)
end

function Dog:Test()
    print("我是狗？")
end
Dog:Test()
Dog.base:Test()

输出：
我是狗？
我是基类

function Dog:Test()
	// 如果想在继承了父类的方法的基础之上重写
    self.base:Test()
    print("我是狗？")
end

Dog:Test() --我是基类 我是狗？

注意，如果我们直接用的父类方法，在调用父类的时候应当避免不同的类共享全局变量：

Object = {}
Object.id = 1;
function Object:Test()
    self.id = self.id + 1
    print(self.id)
end

Object:subClass("Cat")
function Cat:Test()
	self.base:Test()
    print("我是猫类")
end
Object:subClass("Dog")
function Dog:Test()
    self.base:Test()
    print("我是狗？")
end

输出：
2
我是猫类
3
我是狗？

原因也很简单，table内存放了父类的table，我们直接调用父类的Test方法，那么self.id每次调用都会加一。两个table中的父类是同一个地址，而Object:Test()这个方法中每次传入给self的都是这个xxx.base，也就是这个父类table本身，所以self.id增加的是父类中的id，作为一个全局变量，它自然是不断增加的。

那么我们想让子类既能在继承Object:Test()这个父类方法基础之上重写，又想使得self.id改变的self是我们使用方法的那个子类table，那么就应当这样写：

Object = {}
Object.id = 1;
function Object:Test()
    self.id = self.id + 1
    print(self.id)
end

Object:subClass("Cat")
function Cat:Test()
	// 手动地传入参数，因为冒号传入给self的是base
	// 因此需要手动地改变传入的参数的值
	self.base.Test(self)
    print("我是猫类")
end
Cat:Test()

输出:
2
我是猫类

重载应该是最简单的多态方法，只需要改变函数的入参数量就行了

至于接口和抽象类，lua本身的函数就可以重写，抽象性还是很强的。而接口我们应当可以访问另一个table结构来实现，例如self.base应当就能视为一种接口，当然这些只是我的想法，目前还没学习到。