lua 面向对象

对象的特点是:

  对象拥有自己的数据,两个对象即使数据完全相同,他们也是相互独立的;

  对象之间可以共享对象的行为,也就是他们的方法是一致的;

lua中的table就非常适合作为一个对象,可以在table中方便的定义属性和方法:

  Point = { x = 0, y = 0 }

  Point.set = function (x, y)

    Point.x = x

    Point.y = y

  end

  Point.set(1, 2)

但是要符合面相对象的规则,方法可以操作不同的对象,而不是同一个特定对象,我们可以将需要操作的对象作为参数传入:

  Point = {}

  Point.set = function (pt, x, y)

      pt.x = x

      pt.y = y

    end

  local pt1 = { x = 0, y = 0 }

  Point.set(pt, 1, 2)

我们可以将所有方法定义在一个集合中,然后在调用的时候将第一个参数作为对象传入即可。不过传统的面向对象是可以隐藏对象这个参数,而直接使用this代替,lua也提供了一种类似的操作,就是“:”操作符:

  Point = {}

  function Point:set (x, y) // 等价于 function Point.set(self, x, y)

    self.x = x

    self.y = y

  end

  Point:set(1, 2) // 等价于Point.set(Point, 1, 2)

这里冒号操作符的作用就是省略了第一个参数self,self是代表冒号之前的那个对象。.操作符和:操作符是可以随意互换的,只要在调用的时候确定参数的正确性即可,因为冒号操作符并没有引入新的东西,只是一种“语法糖”而已。

类是创建对象的模版,同一个类型的所有对象都具有相同的行为。

在lua中,如何创建一个类?lua中使用table来创建一个类,然后所有实例的元表都可以设置为这个类,即相同类型的对象具有相同的元表:

创建一个Point类:

  Point = {}

  function Point.new (x, y)

    local instance = {} // 创建一个实例

    setmetatable(instance, Point) // 设置所有实例的元表都是Point,所以实例的方法都会去Point中查找

    Point.__index = Point // 同时必须设置__index元方法为Point,因为实例的所有方法,我们都会定义在Point中

    instance.x = x

    instance.y = y

    return instance

  end

添加类的方法:

  function Point:set (x, y)

    self.x = x

    self.y = y

  end

  function Point:get ()

    return {x, y}

  end

使用:

  local pt = Point.new(1, 2)

  pt:set(3, 4)

  local data = pt:get()

类的继承:根据lua的table特性,如果一个字段在table中不存在,那么lua回去尝试调用元表的__index元方法,如果元方法是一个table,那么该规则会持续下去,直到找到一个定义或者搜索结束。这种机制就类似一个链式结构,这个链式结构就形成了一个继承关系。子类不存在某个方法的时候,总是会向父类去寻找,依次类推。

从Point类继承一个子类Point3D:

  Point3D = {}

  function Point3D:new (x, y, z)

    local instance = Point:new(x, y) // 创建一个父类对象,继承了父类所有的属性

    instance.z = z

    setmetatable(Point3D, Point) // 设置子类Point3D的元表为父类Point

    Point3D.__index = Point3D // 设置元方法为自己

    setmetatable(instance. Point3D) // 设置instance的元表为Point3D

    return instance  

  end

重写父类的方法:

  function Point3D:set (x, y, z)

    Point.set(self, x, y)

    self.z = z

  end

实现自己的方法:

  function Point3D:setZ (z)

    self.z = z

  end

甚至为instace实现特有的方法:

   function instance:print()

    print("it is a printer for instance ", self)

  end

使用:

  local pt3d = Point3D:new(1, 2, 3)

  pt3d:set(4, 5, 6)

  pt3d:setZ(10)

  pt3d:print()

这样实现后,就形成了instance -> Point3D -> Point 的链式结构,lua会按照这个顺序依此搜索方法,调用最先找到的方法。

实例:

Point.lua

--#! /usr/local/bin/lua

Point = {}
Point.__index = Point; local POINT_PROPS = {
x = ,
y =
} function Point:new(x, y)
local instance = {}
for k, v in pairs(POINT_PROPS) do
instance[k] = v
end
instance.x = x
instance.y = y setmetatable(instance, Point) return instance
end function Point:set (x, y)
print("Point set x:"..x.." y:"..y) self.x = x
self.y = y
end function Point.get (self)
print("Point get x:"..self.x.." y:"..self.y) return {x, y}
end

Point3D.lua

--#! /usr/local/bin/lua

require "Point"

Point3D = {}
Point3D.__index = Point3D; local POINT3D_PROPS = {
z =
} function Point3D:new (x, y, z)
local instance = Point:new(x, y)
for k, v in pairs(POINT3D_PROPS) do
instance[k] = v
end
instance.z = z setmetatable(Point3D, Point)
setmetatable(instance, Point3D) return instance
end function Point3D:set (x, y, z)
print("Point3D set x:"..x.." y:"..y.." z:"..z) Point.set(self, x, y)
self.z = z
end function Point3D:setZ (z)
print("Point3D setZ z:"..z) self.z = z
end function Point3D:get ()
print("Point3D get x:"..self.x.." y:"..self.y.." z:"..self.z)
end

test.lua

require "Point3D"

local pt = Point3D:new(, , );
for k, v in pairs(pt) do
print(k, v)
end
pt:set(, , )
pt:get() function pt:print()
print("pt", self.x, self.y, self.z, self)
end pt:print()

多重继承:

  为了实现多重继承,就无法为对象设置一个父类作为元表,必须将多个父类保存起来,然后设置一个元方法__index为函数,在函数调用的时候,在多个父类中为对象寻找适合的方法。

Color.lua

Color = {}

function Color:setColor (r, g, b, a)
self.r = r
self.g = g
self.b = b
self.a = a
end function Color:getColor ()
print("color r:"..self.r.." g:"..self.g.." b:"..self.b.." a"..self.a) return {self.r, self.g, self.b, self.a}
end

test.lua

require "Point"
require "Color" ColorPoint = {}
ColorPoint.__interfaces = { Point, Color }
ColorPoint.__index = function (t, key)
local interfaces = ColorPoint.__interfaces; for i = , #interfaces do
local func = interfaces[i][key]
if func then return func end
end
return nil
end function ColorPoint:new ()
local instance = {}
setmetatable(instance, ColorPoint)
return instance
end local cp = ColorPoint:new()
local cp1 = ColorPoint:new() cp:set(, )
cp:get()
cp:setColor(, , , )
cp:getColor()

单列模式,利用了闭包的原理,将数据隐蔽起来:

local _instance = {}

local filelist = {}
local fileCount = local isExist = function (filename)
return not (filelist[filename] == nil)
end function _instance:load (filename)
if (isExist(filename)) then print(filename) return end local file = io.open(filename) if (file) then
io.input(file)
local data = assert(io.read("*all"))
filelist[filename] = data fileCount = fileCount + io.close(file)
else
error("FileManager load file "..filename.." failed")
end
end function _instance:getFileCount ()
return fileCount
end function _instance:getFileData (filename)
return filelist[filename]
end function _instance:removeFileData (filename)
if (filelist[filename]) then
filelist[filename] = nil
fileCount = fileCount -
end assert(fileCount >= , "FileManager removeFileData file count error")
end function _instance:isExist (filename)
return not (filelist[filename] == nil)
end FileManager = {
getInstance = function()
return _instance
end
}
_G["FileManager"] = FileManager
return FileManager
FileManager:getInstance():load("1.txt")
FileManager:getInstance():load("2.txt")
print(FileManager:getInstance():getFileCount())
print(FileManager:getInstance():getFileData("1.txt"))
FileManager:getInstance():removeFileData("1.txt")
print(FileManager:getInstance():getFileCount())
print(FileManager:getInstance():getFileData("1.txt"))
print(FileManager:getInstance():getFileData("2.txt")
上一篇:Sql复习之安全性与权限管理+vmware增加硬盘容量


下一篇:Python基础之条件和循环