《Lua高级编程》4.2 类、对象与构造函数的设计模式

 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

local Person = {}
Person.__index = Person

-- 构造函数 new：负责创建新对象并设置元表
function Person:new(o)
    o = o or {}            -- o 可选，允许传入初始化数据
    setmetatable(o, self)   -- 设置 o 的元表为 Person，实现方法继承
    if o.init then         -- 如果存在 init 方法，则调用进行初始化
        o:init()
    end
    return o
end

-- 初始化方法 init：完成对象属性的赋值与设置
function Person:init()
    self.name = self.name or "Anonymous"
    self.age = self.age or 0
end

-- 示例方法，输出信息
function Person:greet()
    print("Hello, my name is " .. self.name .. " and I am " .. self.age .. " years old.")
end

-- 实例化对象
local p1 = Person:new({name = "Alice", age = 25})
p1:greet()  -- 输出：Hello, my name is Alice and I am 25 years old.

 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

local Car = {}
Car.__index = Car

-- 定义一个辅助的构造方法
function Car:new(make, model)
    local instance = {make = make or "Unknown", model = model or "Unknown"}
    setmetatable(instance, self)
    if instance.__init then
        instance:__init()
    end
    return instance
end

-- 可选的初始化方法，用于更复杂的初始化过程
function Car:__init()
    self.serial = math.random(10000, 99999)
end

-- 定义一些方法
function Car:getInfo()
    return string.format("Car: %s %s, Serial: %s", self.make, self.model, self.serial)
end

-- 设置 __call 元方法，使 Car() 形式能调用 new 方法
setmetatable(Car, {
    __call = function(cls, ...)
        return cls:new(...)
    end
})

-- 通过语法糖创建对象
local myCar = Car("Toyota", "Corolla")
print(myCar:getInfo())

 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

local Employee = {}
Employee.__index = Employee

-- 使用表传参模式，方便设置默认值
function Employee:new(params)
    params = params or {}
    local obj = {
        name = params.name or "Unnamed",
        id = params.id or math.random(1000, 9999),
        department = params.department or "General"
    }
    setmetatable(obj, self)
    if obj.init then obj:init() end
    return obj
end

function Employee:init()
    -- 可在此执行进一步初始化，如日志记录、数据校验等
    if type(self.name) ~= "string" then
        error("Employee.name 必须为字符串")
    end
end

function Employee:getDetails()
    return string.format("Employee: %s, ID: %d, Dept: %s", self.name, self.id, self.department)
end

local emp = Employee:new({name = "Bob", department = "IT"})
print(emp:getDetails())

 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

local ShapeFactory = {}

-- 假设有两个类：Circle 和 Rectangle
local Circle = {}
Circle.__index = Circle
function Circle:new(radius)
    local o = {radius = radius or 0}
    setmetatable(o, self)
    return o
end
function Circle:area()
    return math.pi * self.radius * self.radius
end

local Rectangle = {}
Rectangle.__index = Rectangle
function Rectangle:new(width, height)
    local o = {width = width or 0, height = height or 0}
    setmetatable(o, self)
    return o
end
function Rectangle:area()
    return self.width * self.height
end

-- 工厂函数，根据参数动态创建对象
function ShapeFactory.createShape(shapeType, ...)
    if shapeType == "circle" then
        return Circle:new(...)
    elseif shapeType == "rectangle" then
        return Rectangle:new(...)
    else
        error("未知的形状类型: " .. tostring(shapeType))
    end
end

local shape1 = ShapeFactory.createShape("circle", 5)
local shape2 = ShapeFactory.createShape("rectangle", 4, 6)
print("Circle area:", shape1:area())
print("Rectangle area:", shape2:area())

 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

local ConfigManager = {}
ConfigManager.__index = ConfigManager

local instance = nil

function ConfigManager:new(config)
    if instance then
        return instance
    end
    local o = config or {}
    setmetatable(o, self)
    o.settings = o.settings or {}
    instance = o
    return instance
end

function ConfigManager:set(key, value)
    self.settings[key] = value
end

function ConfigManager:get(key)
    return self.settings[key]
end

-- 多次调用 new 只返回同一实例
local config1 = ConfigManager:new({settings = {mode = "debug"}})
local config2 = ConfigManager:new()
config2:set("mode", "release")
print("Mode from config1:", config1:get("mode"))  -- 输出：release

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

local function clone(original)
    local copy = {}
    for k, v in pairs(original) do
        if type(v) == "table" then
            copy[k] = clone(v)
        else
            copy[k] = v
        end
    end
    setmetatable(copy, getmetatable(original))
    return copy
end

local prototype = {name = "Prototype", value = 100}
local newObj = clone(prototype)
newObj.name = "Clone"
print("Prototype name:", prototype.name)
print("Cloned object name:", newObj.name)

 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

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.species = "Unknown"
end

local Dog = setmetatable({}, {__index = Animal})
Dog.__index = Dog

function Dog:new(o)
    o = o or {}
    -- 显式调用父类构造函数
    local obj = Animal.new(self, o)
    return obj
end

function Dog:init()
    -- 调用父类初始化
    Animal.init(self)
    self.species = "Dog"
    self.barkVolume = self.barkVolume or 10
end

local myDog = Dog:new({barkVolume = 15})
print("Species:", myDog.species)
print("Bark Volume:", myDog.barkVolume)

 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

local BaseClass = {}
BaseClass.__index = BaseClass

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

function BaseClass:__init()
    self.id = math.random(1, 1000)
end

local SubClass = setmetatable({}, {__index = BaseClass})
SubClass.__index = SubClass

function SubClass:new(o)
    o = o or {}
    local obj = BaseClass.new(self, o)
    return obj
end

function SubClass:__init()
    BaseClass.__init(self)  -- 调用父类初始化
    self.name = self.name or "SubClassInstance"
end

local instance = SubClass:new({name = "TestInstance"})
print("Instance ID:", instance.id)
print("Instance Name:", instance.name)

 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
80
81
82
83
84
85

-- 定义 User 类
local User = {}
User.__index = User

-- 使用表传参方式作为构造函数
function User:new(params)
    params = params or {}
    local o = {
        id = params.id or math.random(10000, 99999),
        username = params.username or "Guest",
        password = params.password or "default",  -- 密码需在真实系统中加密处理
        email = params.email or ""
    }
    setmetatable(o, self)
    if o.init then o:init() end
    return o
end

function User:init()
    -- 可加入参数校验
    if type(self.username) ~= "string" or self.username == "" then
        error("用户名不能为空且必须为字符串")
    end
    if type(self.password) ~= "string" or self.password == "" then
        error("密码不能为空且必须为字符串")
    end
    -- 初始化状态信息
    self.createdAt = os.date("%Y-%m-%d %H:%M:%S")
end

function User:getInfo()
    return string.format("User[ID:%d, Username:%s, Email:%s, CreatedAt:%s]", 
        self.id, self.username, self.email, self.createdAt)
end

function User:changePassword(newPassword)
    if type(newPassword) ~= "string" or newPassword == "" then
        error("新密码不合法")
    end
    self.password = newPassword
    print("Password changed successfully for user " .. self.username)
end

-- 定义 Admin 类，继承 User
local Admin = setmetatable({}, {__index = User})
Admin.__index = Admin

function Admin:new(params)
    params = params or {}
    local o = User.new(self, params)  -- 调用父类构造函数
    return o
end

function Admin:init()
    User.init(self)
    self.role = "admin"
    -- 管理员特有初始化，如权限列表等
    self.permissions = {"ban", "reset", "modify"}
end

function Admin:banUser(user)
    if not user or type(user) ~= "table" or not user.username then
        error("无效的用户对象")
    end
    print("Admin " .. self.username .. " banned user " .. user.username)
end

function Admin:resetPassword(user, newPassword)
    if not user or type(user) ~= "table" or not user.username then
        error("无效的用户对象")
    end
    user:changePassword(newPassword)
    print("Admin " .. self.username .. " reset password for user " .. user.username)
end

-- 测试创建用户与管理员
local user1 = User:new({username = "Alice", password = "alice123", email = "alice@example.com"})
local admin1 = Admin:new({username = "SuperAdmin", password = "adminPass"})

print(user1:getInfo())
print(admin1:getInfo())

-- 模拟管理员操作
admin1:banUser(user1)
admin1:resetPassword(user1, "newAlicePwd")