《Lua高级编程》4.1 Lua中实现面向对象的思路与技巧

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

-- 定义一个基本的类
local Class = {}
Class.__index = Class

-- 构造函数，用于创建对象实例
function Class:new(o)
    o = o or {}  -- o 是一个可选的初始化表
    setmetatable(o, self)
    if o.init then o:init() end  -- 如果存在初始化函数则调用
    return o
end

-- 示例的初始化方法
function Class:init()
    self.name = "Default"
end

-- 类中的方法定义
function Class:greet()
    print("Hello, " .. self.name)
end

-- 使用类创建实例
local obj = Class:new({name = "LuaObject"})
obj:greet()  -- 输出：Hello, LuaObject

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

-- 定义一个基类
local Animal = {}
Animal.__index = Animal

function Animal:new(o)
    o = o or {}
    setmetatable(o, self)
    if o.init then o:init() end
    return o
end

function Animal:init()
    self.type = "Animal"
end

function Animal:speak()
    print("Animal sound")
end

-- 定义一个子类，继承 Animal
local Dog = Animal:new()  -- 复制 Animal 表作为 Dog 的起点
Dog.__index = Dog  -- 设置子类的 __index 为自身

-- 重写 init 方法，实现子类的初始化
function Dog:init()
    Animal.init(self)  -- 调用父类的初始化方法
    self.type = "Dog"
    self.breed = "Undefined"
end

-- 重写 speak 方法，实现多态
function Dog:speak()
    print("Woof! Woof!")
end

-- 创建一个 Dog 的实例
local myDog = Dog:new({breed = "Bulldog"})
myDog:speak()  -- 输出：Woof! Woof!
print(myDog.type)  -- 输出：Dog

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

local Person = {}
Person.__index = Person

function Person:new(o)
    o = o or {}
    o._data = {}  -- 内部存储实际数据
    setmetatable(o, self)
    return o
end

-- 重载 __index，实现属性访问代理
function Person:__index(key)
    if key == "age" then
        return self._data.age or 0
    else
        return rawget(Person, key)
    end
end

-- 重载 __newindex，实现属性赋值控制
function Person:__newindex(key, value)
    if key == "age" then
        if type(value) ~= "number" or value < 0 then
            error("年龄必须为非负数")
        else
            self._data.age = value
        end
    else
        rawset(self, key, value)
    end
end

local p = Person:new()
p.age = 25  -- 合法赋值
print(p.age)  -- 输出 25
-- p.age = -5  -- 赋值错误，将触发 error

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

local Car = {}
Car.__index = Car

-- 定义构造函数
function Car:__init(make, model)
    self.make = make
    self.model = model
end

-- 定义一个辅助函数创建新实例
function Car:new(...)
    local obj = setmetatable({}, self)
    obj:__init(...)
    return obj
end

-- 设置 __call 元方法，使 Car() 能够直接调用构造器
setmetatable(Car, {
    __call = function(cls, ...)
        return cls:new(...)
    end
})

local myCar = Car("Toyota", "Corolla")
print(myCar.make, myCar.model)  -- 输出：Toyota Corolla

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

local Vector = {}
Vector.__index = Vector

function Vector:new(x, y)
    local obj = {x = x or 0, y = y or 0}
    setmetatable(obj, self)
    return obj
end

-- 定义向量加法：重载 __add 元方法
function Vector.__add(v1, v2)
    return Vector:new(v1.x + v2.x, v1.y + v2.y)
end

function Vector:__tostring()
    return "(" .. self.x .. ", " .. self.y .. ")"
end

local v1 = Vector:new(1, 2)
local v2 = Vector:new(3, 4)
local v3 = v1 + v2
print(v3)  -- 输出：(4, 6)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

function createCounter()
    local count = 0  -- 私有变量，只能通过闭包访问
    return {
        increment = function()
            count = count + 1
            return count
        end,
        getValue = function()
            return count
        end
    }
end

local counter = createCounter()
print(counter.increment())  -- 输出：1
print(counter.getValue())   -- 输出：1

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

-- 定义两个父类
local Flyer = {}
Flyer.__index = Flyer
function Flyer:fly()
    print("I can fly")
end

local Swimmer = {}
Swimmer.__index = Swimmer
function Swimmer:swim()
    print("I can swim")
end

-- 定义一个混合类
local Duck = {}
Duck.__index = Duck

function Duck:new(o)
    o = o or {}
    setmetatable(o, self)
    return o
end

-- 通过组合方式“继承” Flyer 和 Swimmer
function Duck:fly()
    Flyer.fly(self)
end

function Duck:swim()
    Swimmer.swim(self)
end

local daffy = Duck:new()
daffy:fly()   -- 输出：I can fly
daffy:swim()  -- 输出：I can swim

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

local Singleton = {}
Singleton.__index = Singleton

local instance = nil

function Singleton:new()
    if not instance then
        instance = setmetatable({}, self)
        if instance.init then instance:init() end
    end
    return instance
end

function Singleton:init()
    self.value = 0
end

function Singleton:increment()
    self.value = self.value + 1
    return self.value
end

local s1 = Singleton:new()
local s2 = Singleton:new()
print(s1:increment())  -- 输出：1
print(s2:increment())  -- 输出：2，表明只有一个实例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

local ShapeFactory = {}

function ShapeFactory.createShape(shapeType, ...)
    if shapeType == "Circle" then
        return Circle:new(...)
    elseif shapeType == "Square" then
        return Square:new(...)
    else
        error("未知形状类型")
    end
end

-- 假设 Circle 与 Square 已经通过面向对象方式实现
local circle = ShapeFactory.createShape("Circle", 5)  -- 例如半径为 5
local square = ShapeFactory.createShape("Square", 10)  -- 例如边长为 10

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

local Subject = {}
Subject.__index = Subject

function Subject:new()
    local obj = {observers = {}}
    setmetatable(obj, self)
    return obj
end

function Subject:attach(observer)
    table.insert(self.observers, observer)
end

function Subject:detach(observer)
    for i, v in ipairs(self.observers) do
        if v == observer then
            table.remove(self.observers, i)
            break
        end
    end
end

function Subject:notify(...)
    for _, observer in ipairs(self.observers) do
        observer:update(...)
    end
end

-- 定义一个观察者
local Observer = {}
Observer.__index = Observer

function Observer:new(name)
    local obj = {name = name}
    setmetatable(obj, self)
    return obj
end

function Observer:update(msg)
    print(self.name .. " received message: " .. msg)
end

local subject = Subject:new()
local obs1 = Observer:new("Observer1")
local obs2 = Observer:new("Observer2")
subject:attach(obs1)
subject:attach(obs2)
subject:notify("Event Occurred")  -- 两个观察者均收到通知

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

local Resource = {}
Resource.__index = Resource

function Resource:new(resourceName)
    local obj = {name = resourceName, active = true}
    setmetatable(obj, self)
    return obj
end

function Resource:destroy()
    if self.active then
        print("Releasing resource: " .. self.name)
        self.active = false
        -- 此处执行资源释放操作，如关闭文件、释放连接等
    end
end

local res = Resource:new("FileHandle")
-- 当确定不再使用该资源时
res:destroy()

1
2
3
4
5
6
7
8

local weakCache = setmetatable({}, {__mode = "v"})  -- 值为弱引用
function cacheObject(key, obj)
    weakCache[key] = obj
end

function getCachedObject(key)
    return weakCache[key]
end

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

-- 定义基本图形类 Shape
local Shape = {}
Shape.__index = Shape

-- 使用 __call 实现构造函数语法糖
setmetatable(Shape, {
    __call = function(cls, ...)
        return cls:new(...)
    end
})

function Shape:new(o)
    o = o or {}
    setmetatable(o, self)
    if o.init then o:init() end
    return o
end

function Shape:init()
    self.color = "black"
end

function Shape:area()
    error("子类必须实现 area 方法")
end

function Shape:draw()
    print("Drawing shape with color: " .. self.color)
end

-- 定义圆形类 Circle，继承 Shape
local Circle = setmetatable({}, {__index = Shape})
Circle.__index = Circle

function Circle:new(radius, color)
    local obj = Shape.new(self, {radius = radius})
    obj.color = color or "red"
    return obj
end

function Circle:area()
    return math.pi * self.radius * self.radius
end

function Circle:draw()
    print("Drawing circle with radius " .. self.radius .. " and color " .. self.color)
end

-- 定义矩形类 Rectangle，继承 Shape
local Rectangle = setmetatable({}, {__index = Shape})
Rectangle.__index = Rectangle

function Rectangle:new(width, height, color)
    local obj = Shape.new(self, {width = width, height = height})
    obj.color = color or "blue"
    return obj
end

function Rectangle:area()
    return self.width * self.height
end

function Rectangle:draw()
    print("Drawing rectangle with width " .. self.width .. " and height " .. self.height .. " and color " .. self.color)
end

-- 运算符重载示例：将两个形状的面积相加
function Shape.__add(s1, s2)
    return s1:area() + s2:area()
end

-- 测试代码
local circle = Circle(5, "green")
local rect = Rectangle(4, 6, "yellow")
circle:draw()      -- 输出圆形绘制信息
rect:draw()        -- 输出矩形绘制信息
print("Circle area: " .. circle:area())
print("Rectangle area: " .. rect:area())
print("Combined area: " .. (circle + rect))