《Lua高级编程》4.3 继承、多态与封装的模拟

 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

-- 定义父类 Animal
local Animal = {}
Animal.__index = Animal

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

function Animal:initialize()
    self.species = "Unknown"
end

function Animal:makeSound()
    print("Some generic sound")
end

-- 定义子类 Dog，继承 Animal
local Dog = {}
Dog.__index = Dog
setmetatable(Dog, {__index = Animal})  -- Dog 继承 Animal 的方法

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

function Dog:initialize()
    Animal.initialize(self)  -- 调用父类初始化
    self.species = "Dog"
    self.breed = self.breed or "Undefined"
end

function Dog:makeSound()
    print("Woof! Woof!")
end

-- 测试继承效果
local pet = Dog:new({breed = "Labrador"})
pet:makeSound()         -- 输出：Woof! Woof!
print(pet.species)      -- 输出：Dog
print(pet.breed)        -- 输出：Labrador

 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

-- 定义两个功能模块，分别模拟 Flyer 和 Swimmer 行为
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

-- 定义一个混合类 Duck，通过组合方式同时具备飞行和游泳能力
local Duck = {}
Duck.__index = Duck

function Duck:new(o)
    o = o or {}
    setmetatable(o, self)
    -- 混合 Flyer 和 Swimmer 的功能：直接将两个模块的方法赋值给 Duck 对象
    for k, v in pairs(Flyer) do
        if type(v) == "function" then
            o[k] = v
        end
    end
    for k, v in pairs(Swimmer) do
        if type(v) == "function" then
            o[k] = v
        end
    end
    return o
end

function Duck:quack()
    print("Quack! Quack!")
end

-- 测试混合继承
local daffy = Duck:new()
daffy:fly()   -- 输出：I can fly!
daffy:swim()  -- 输出：I can swim!
daffy:quack() -- 输出：Quack! Quack!

 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

-- 定义父类 Vehicle
local Vehicle = {}
Vehicle.__index = Vehicle

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

function Vehicle:initialize()
    self.type = "Generic Vehicle"
end

function Vehicle:drive()
    print("Driving a " .. self.type)
end

-- 定义子类 Car 继承 Vehicle
local Car = {}
Car.__index = Car
setmetatable(Car, {__index = Vehicle})

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

function Car:initialize()
    Vehicle.initialize(self)
    self.type = "Car"
end

function Car:drive()
    print("The car is driving smoothly on the road.")
end

-- 定义子类 Truck 继承 Vehicle
local Truck = {}
Truck.__index = Truck
setmetatable(Truck, {__index = Vehicle})

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

function Truck:initialize()
    Vehicle.initialize(self)
    self.type = "Truck"
end

function Truck:drive()
    print("The truck is hauling heavy loads across rough terrain.")
end

-- 定义一个函数，统一调用 drive 方法，实现多态
local function testDrive(vehicle)
    vehicle:drive()
end

-- 测试多态效果
local myCar = Car:new()
local myTruck = Truck:new()

testDrive(myCar)    -- 输出：The car is driving smoothly on the road.
testDrive(myTruck)  -- 输出：The truck is hauling heavy loads across rough terrain.

 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

-- 定义不同的驾驶策略
local NormalDriveStrategy = {}
function NormalDriveStrategy.drive(self)
    print("Driving in normal mode.")
end

local SportDriveStrategy = {}
function SportDriveStrategy.drive(self)
    print("Driving in sport mode with high acceleration!")
end

-- Vehicle 类采用策略模式
local Vehicle2 = {}
Vehicle2.__index = Vehicle2

function Vehicle2:new(o)
    o = o or {}
    setmetatable(o, self)
    o.driveStrategy = NormalDriveStrategy  -- 默认策略
    if o.initialize then o:initialize() end
    return o
end

function Vehicle2:initialize()
    self.type = "Vehicle2"
end

function Vehicle2:drive()
    -- 调用当前策略的 drive 方法
    self.driveStrategy.drive(self)
end

-- 在运行时切换驾驶策略
local v = Vehicle2:new()
v:drive()  -- 输出：Driving in normal mode.
v.driveStrategy = SportDriveStrategy
v:drive()  -- 输出：Driving in sport mode with high acceleration!

 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

function createAccount(initialBalance)
    local balance = initialBalance or 0  -- 私有变量，仅在闭包内可见

    local account = {}

    function account.deposit(amount)
        if type(amount) ~= "number" or amount < 0 then
            error("Invalid deposit amount")
        end
        balance = balance + amount
        print("Deposited: " .. amount)
    end

    function account.withdraw(amount)
        if type(amount) ~= "number" or amount < 0 then
            error("Invalid withdrawal amount")
        end
        if amount > balance then
            error("Insufficient funds")
        end
        balance = balance - amount
        print("Withdrawn: " .. amount)
    end

    function account.getBalance()
        return balance
    end

    return account
end

local acc = createAccount(100)
acc.deposit(50)
acc.withdraw(30)
print("Current balance:", acc.getBalance())

 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 Employee = {}
Employee.__index = function(self, key)
    -- 当访问私有属性时，可以进行判断和处理
    if key == "salary" then
        return rawget(self, "_salary") or 0
    else
        return rawget(Employee, key)
    end
end

Employee.__newindex = function(self, key, value)
    if key == "salary" then
        if type(value) ~= "number" or value < 0 then
            error("Salary must be a non-negative number")
        end
        rawset(self, "_salary", value)
    else
        rawset(self, key, value)
    end
end

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

local emp = Employee:new()
emp.salary = 5000   -- 正确赋值
print("Employee salary:", emp.salary)
-- emp.salary = -1000  -- 错误赋值，将触发 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
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

-- 定义 Book 基类
local Book = {}
Book.__index = Book

-- 使用局部闭包封装私有数据
function Book:new(params)
    params = params or {}
    local selfData = {
        _stock = params.stock or 0,        -- 内部库存量
        _downloadCount = params.downloadCount or 0  -- 内部下载次数
    }
    local obj = {
        title = params.title or "Untitled",
        author = params.author or "Unknown",
        isbn = params.isbn or "N/A",
        -- 将私有数据绑定到一个内部表中，不直接暴露在对象上
        _data = selfData
    }
    setmetatable(obj, self)
    if obj.initialize then obj:initialize() end
    return obj
end

-- 定义基类的初始化方法
function Book:initialize()
    -- 此处可以执行额外的校验或数据转换
    if type(self.title) ~= "string" then
        error("书名必须为字符串")
    end
end

-- 定义受控接口：获取库存量
function Book:getStock()
    return self._data._stock
end

-- 定义受控接口：修改库存量
function Book:setStock(newStock)
    if type(newStock) ~= "number" or newStock < 0 then
        error("库存量必须为非负数")
    end
    self._data._stock = newStock
end

-- 定义受控接口：获取下载次数（针对电子书）
function Book:getDownloadCount()
    return self._data._downloadCount
end

-- 定义受控接口：增加下载次数
function Book:incrementDownload()
    self._data._downloadCount = self._data._downloadCount + 1
end

-- 定义通用的描述信息接口
function Book:describe()
    print(string.format("《%s》 作者：%s, ISBN：%s", self.title, self.author, self.isbn))
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

-- 定义 EBook 子类，继承自 Book
local EBook = {}
EBook.__index = EBook
setmetatable(EBook, {__index = Book})

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

function EBook:initialize()
    Book.initialize(self)
    self.fileFormat = self.fileFormat or "PDF"
    self.sizeMB = self.sizeMB or 0.0
end

-- 重写 describe 方法，增加电子书特有的信息
function EBook:describe()
    Book.describe(self)
    print(string.format("格式：%s, 文件大小：%.2fMB, 下载次数：%d", 
          self.fileFormat, self.sizeMB, self:getDownloadCount()))
end

-- 定义 PrintedBook 子类，继承自 Book
local PrintedBook = {}
PrintedBook.__index = PrintedBook
setmetatable(PrintedBook, {__index = Book})

function PrintedBook:new(params)
    params = params or {}
    local obj = Book.new(self, params)
    return obj
end

function PrintedBook:initialize()
    Book.initialize(self)
    self.weight = self.weight or 0.0  -- 单位：kg
    self.dimensions = self.dimensions or {length = 0, width = 0, height = 0}
end

-- 重写 describe 方法，增加纸质书特有的信息
function PrintedBook:describe()
    Book.describe(self)
    print(string.format("重量：%.2fkg, 尺寸：%dx%dx%d cm, 库存量：%d 本", 
          self.weight, self.dimensions.length, self.dimensions.width, self.dimensions.height, self:getStock()))
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

local function displayBookInfo(book)
    -- 统一调用 describe 接口，实现多态效果
    book:describe()
end

-- 创建电子书实例
local ebook1 = EBook:new({
    title = "Lua编程精粹",
    author = "李雷",
    isbn = "978-7-302-12345-6",
    fileFormat = "EPUB",
    sizeMB = 2.5,
    downloadCount = 100
})

-- 创建纸质书实例
local pbook1 = PrintedBook:new({
    title = "深入浅出Lua",
    author = "韩梅梅",
    isbn = "978-7-302-54321-0",
    weight = 1.2,
    dimensions = {length = 21, width = 14, height = 3},
    stock = 50
})

displayBookInfo(ebook1)
displayBookInfo(pbook1)