《Lua高级编程》4.4 实战案例：构建一个简单的对象系统

-- 定义基础类 Object
local Object = {}
Object.__index = Object

-- 通用构造函数，所有类均可调用
function Object:new(o)
    o = o or {}                   -- 若未传入参数，则创建一个空表
    setmetatable(o, self)         -- 将 o 的元表设置为当前类，确保方法查找
    if o.init then o:init() end   -- 如果存在 init 方法，则调用初始化
    return o
end

-- 提供一个用于打印对象信息的通用方法
function Object:toString()
    local s = "{ "
    for k, v in pairs(self) do
        if type(v) ~= "function" then
            s = s .. tostring(k) .. " = " .. tostring(v) .. ", "
        end
    end
    return s .. "}"
end

-- 返回 Object 作为模块
return Object

-- 定义一个 Person 类，继承自 Object
local Object = require("Object")   -- 引入基础类模块

local Person = setmetatable({}, {__index = Object})
Person.__index = Person

-- 构造函数，通过调用 Object:new 创建实例
function Person:new(name, age)
    local instance = Object.new(self)  -- 调用父类构造函数
    instance.name = name or "匿名"
    instance.age = age or 0
    return instance
end

-- 初始化方法（可选，在 new 中直接初始化也可以）
function Person:init()
    -- 这里可以做一些统一的初始化工作，如日志记录、数据校验等
    if type(self.name) ~= "string" then
        error("name 必须为字符串")
    end
    if type(self.age) ~= "number" then
        error("age 必须为数字")
    end
end

-- 示例方法：自我介绍
function Person:introduce()
    print("大家好，我是 " .. self.name .. "，今年 " .. self.age .. " 岁。")
end

return Person

-- 定义 Student 类，继承自 Person
local Person = require("Person")  -- 引入 Person 类

local Student = setmetatable({}, {__index = Person})
Student.__index = Student

-- Student 的构造函数
function Student:new(name, age, school)
    local instance = Person.new(self, name, age)  -- 调用父类构造函数
    instance.school = school or "未知学校"
    return instance
end

-- 重写自我介绍方法，实现多态
function Student:introduce()
    -- 调用父类的方法以获取基本信息
    local baseIntro = "我是 " .. self.name .. "，今年 " .. self.age .. " 岁"
    print(baseIntro .. "，就读于 " .. self.school .. "。")
end

return Student

-- 定义一个测试多态的函数
local function testIntroduce(obj)
    if obj.introduce then
        obj:introduce()
    else
        print("对象没有实现介绍方法")
    end
end

-- 创建 Person 与 Student 对象
local Person = require("Person")
local Student = require("Student")

local p = Person:new("李四", 40)
local s = Student:new("王五", 20, "清华大学")

-- 测试多态
testIntroduce(p)  -- 调用 Person 的介绍方法
testIntroduce(s)  -- 调用 Student 重写的介绍方法

-- 定义 Counter 类，利用闭包封装内部变量
local Counter = {}
Counter.__index = Counter

function Counter:new()
    local selfInstance = {}
    setmetatable(selfInstance, self)
    -- 私有变量封装在闭包内，不会暴露到对象表中
    local count = 0

    -- 公开方法，通过闭包访问私有变量
    function selfInstance:increment()
        count = count + 1
    end

    function selfInstance:getCount()
        return count
    end

    return selfInstance
end

-- 测试 Counter 类
local counter = Counter:new()
counter:increment()
counter:increment()
print("计数器当前值为：" .. counter:getCount())  -- 输出：计数器当前值为：2

-- 定义 Employee 类，利用元表实现封装
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("薪资必须为非负数字")
        end
        rawset(self, "_salary", value)
    else
        rawset(self, key, value)
    end
end

function Employee:new(name, salary)
    local instance = setmetatable({}, self)
    instance.name = name or "未知"
    instance.salary = salary or 0
    return instance
end

function Employee:showInfo()
    print("员工姓名：" .. self.name .. "，薪资：" .. self.salary)
end

-- 测试 Employee 类
local emp = Employee:new("赵六", 5000)
emp:showInfo()   -- 输出：员工姓名：赵六，薪资：5000
-- emp.salary = -1000  -- 此处会报错，保证了封装的安全性

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

-- 构造函数，利用闭包封装私有数据
function Book:new(params)
    params = params or {}
    local instance = {}
    setmetatable(instance, self)
    
    -- 公有属性
    instance.title  = params.title  or "未知书名"
    instance.author = params.author or "未知作者"
    instance.isbn   = params.isbn   or "000-0000000000"
    
    -- 内部私有数据封装：库存和下载次数
    local private = {
        stock         = params.stock or 0,
        downloadCount = params.downloadCount or 0
    }
    
    -- 通过闭包提供受控访问接口
    function instance:getStock()
        return private.stock
    end
    
    function instance:setStock(num)
        if type(num) ~= "number" or num < 0 then
            error("库存数量必须为非负数")
        end
        private.stock = num
    end
    
    function instance:getDownloadCount()
        return private.downloadCount
    end
    
    function instance:incrementDownload()
        private.downloadCount = private.downloadCount + 1
    end
    
    return instance
end

-- 通用方法：显示图书信息
function Book:displayInfo()
    print("书名：" .. self.title)
    print("作者：" .. self.author)
    print("ISBN：" .. self.isbn)
    print("库存：" .. self:getStock())
    print("下载次数：" .. self:getDownloadCount())
end

return Book

-- 定义 EBook 类，继承自 Book
local Book = require("Book")  -- 假设 Book 模块已保存在同目录下
local EBook = setmetatable({}, {__index = Book})
EBook.__index = EBook

-- 构造函数
function EBook:new(params)
    params = params or {}
    local instance = Book.new(self, params)  -- 调用父类构造函数
    instance.fileFormat = params.fileFormat or "PDF"
    instance.fileSize   = params.fileSize   or 0.0  -- 单位：MB
    return instance
end

-- 重写 displayInfo 方法，增加电子书特有的信息
function EBook:displayInfo()
    -- 调用父类方法展示基础信息
    Book.displayInfo(self)
    print("文件格式：" .. self.fileFormat)
    print("文件大小：" .. self.fileSize .. " MB")
end

return EBook

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

-- 构造函数
function PrintedBook:new(params)
    params = params or {}
    local instance = Book.new(self, params)  -- 调用父类构造函数
    instance.weight = params.weight or 0.0      -- 单位：kg
    instance.dimensions = params.dimensions or {length = 0, width = 0, height = 0}  -- 尺寸：cm
    return instance
end

-- 重写 displayInfo 方法，增加纸质书特有的信息
function PrintedBook:displayInfo()
    Book.displayInfo(self)
    print(string.format("重量：%.2f kg", self.weight))
    print("尺寸（长×宽×高）：" .. self.dimensions.length .. "×" ..
          self.dimensions.width .. "×" .. self.dimensions.height .. " cm")
end

return PrintedBook

-- 测试脚本：test_object_system.lua

-- 引入各个类
local Book = require("Book")
local EBook = require("EBook")
local PrintedBook = require("PrintedBook")

-- 创建一个普通图书对象
local book1 = Book:new{
    title = "Lua 编程入门",
    author = "张三",
    isbn = "978-7-100-12345-6",
    stock = 20,
    downloadCount = 5
}

-- 创建一个电子书对象
local ebook1 = EBook:new{
    title = "深入理解 Lua",
    author = "李四",
    isbn = "978-7-100-54321-0",
    stock = 10,
    downloadCount = 50,
    fileFormat = "EPUB",
    fileSize = 3.2
}

-- 创建一个纸质书对象
local pbook1 = PrintedBook:new{
    title = "Lua 高级编程",
    author = "王五",
    isbn = "978-7-100-98765-4",
    stock = 5,
    downloadCount = 0,
    weight = 1.5,
    dimensions = {length = 22, width = 15, height = 3}
}

-- 定义一个函数，根据传入对象调用 displayInfo 方法，展示多态效果
local function showBookInfo(book)
    print("====================================")
    book:displayInfo()
    print("====================================")
end

-- 测试不同类型的图书对象
showBookInfo(book1)
showBookInfo(ebook1)
showBookInfo(pbook1)

-- 模拟电子书被下载的场景
print("\n模拟电子书下载：")
ebook1:incrementDownload()
print("新的下载次数：" .. ebook1:getDownloadCount())