封装
// 定义基类
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，元表以及面向对象
多态
多态就是对于一个父类的相同方法，子类可以执行不同的逻辑。实现多态我们可以怎么做？
- 重写和重载方法
- 实现接口
- 实现抽象类和抽象方法
如果重写应当是这样：
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应当就能视为一种接口，当然这些只是我的想法，目前还没学习到。