Lua继承与对象系统

发布时间: 2025-03-24 12:07

↑

# Lua继承与对象系统

本文将介绍如何在Lua中实现面向对象编程，包括类的定义、继承机制和多态性。

## 面向对象基础

Lua本身不是面向对象的语言，但我们可以使用表和元表来实现面向对象编程的核心特性。

### 1. 基本概念

```lua
-- 创建一个简单的类
local Person = {}
Person.__index = Person

-- 构造函数
function Person.new(name, age)
    local self = setmetatable({}, Person)
    self.name = name
    self.age = age
    return self
end

-- 实例方法
function Person:introduce()
    return string.format("我叫%s，今年%d岁", self.name, self.age)
end

-- 使用示例
local person = Person.new("张三", 25)
print(person:introduce())  -- 输出：我叫张三，今年25岁
```

### 2. 封装

```lua
-- 使用闭包实现私有成员
local function createPerson(name)
    -- 私有变量
    local age = 0
    
    -- 公共接口
    return {
        getName = function()
            return name
        end,
        
        setAge = function(self, newAge)
            if type(newAge) == "number" and newAge >= 0 then
                age = newAge
            end
        end,
        
        getAge = function(self)
            return age
        end
    }
end

-- 使用示例
local person = createPerson("李四")
person:setAge(30)
print(person:getName(), person:getAge())  -- 李四 30
```

## 类的实现

### 1. 类的定义

```lua
-- 创建类的工厂函数
local function class(name)
    local cls = {}
    cls.__index = cls
    cls.__name = name
    
    -- 创建新实例
    function cls.new(...)
        local instance = setmetatable({}, cls)
        if instance.init then
            instance:init(...)
        end
        return instance
    end
    
    return cls
end

-- 使用示例
local Animal = class("Animal")

function Animal:init(name)
    self.name = name
end

function Animal:speak()
    return "动物的声音"
end

local cat = Animal.new("小猫")
```

### 2. 实例方法和类方法

```lua
-- 定义一个类
local Calculator = class("Calculator")

-- 实例方法（使用冒号语法）
function Calculator:add(a, b)
    return a + b
end

-- 类方法（使用点号语法）
function Calculator.version()
    return "1.0.0"
end

-- 使用示例
local calc = Calculator.new()
print(calc:add(2, 3))        -- 5（调用实例方法）
print(Calculator.version())   -- 1.0.0（调用类方法）
```

## 继承机制

### 1. 单继承

```lua
-- 基类
local Animal = class("Animal")

function Animal:init(name)
    self.name = name
end

function Animal:speak()
    return "动物的声音"
end

-- 子类
local Cat = class("Cat")

-- 设置继承关系
setmetatable(Cat, {__index = Animal})

function Cat:init(name, color)
    Animal.init(self, name)  -- 调用父类构造函数
    self.color = color
end

function Cat:speak()
    return "喵喵喵"
end

-- 使用示例
local cat = Cat.new("咪咪", "白色")
print(cat.name)    -- 咪咪
print(cat.color)   -- 白色
print(cat:speak()) -- 喵喵喵
```

### 2. 多重继承

```lua
-- 实现多重继承的辅助函数
local function multipleInherit(...)
    local parents = {...}
    return setmetatable({}, {
        __index = function(t, k)
            for _, parent in ipairs(parents) do
                local v = parent[k]
                if v then
                    return v
                end
            end
        end
    })
end

-- 示例：多重继承
local Walker = class("Walker")
function Walker:walk()
    return self.name .. "正在走路"
end

local Swimmer = class("Swimmer")
function Swimmer:swim()
    return self.name .. "正在游泳"
end

-- 创建一个继承自Walker和Swimmer的类
local Duck = class("Duck")
Duck.__index = multipleInherit(Walker, Swimmer)

function Duck:init(name)
    self.name = name
end

-- 使用示例
local duck = Duck.new("唐老鸭")
print(duck:walk())  -- 唐老鸭正在走路
print(duck:swim())  -- 唐老鸭正在游泳
```

## 多态性

### 1. 方法重写

```lua
-- 基类
local Shape = class("Shape")

function Shape:init(name)
    self.name = name
end

function Shape:area()
    return 0
end

-- 子类：圆形
local Circle = class("Circle")
setmetatable(Circle, {__index = Shape})

function Circle:init(radius)
    Shape.init(self, "圆形")
    self.radius = radius
end

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

-- 子类：矩形
local Rectangle = class("Rectangle")
setmetatable(Rectangle, {__index = Shape})

function Rectangle:init(width, height)
    Shape.init(self, "矩形")
    self.width = width
    self.height = height
end

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

-- 多态示例
local function printArea(shape)
    print(string.format("%s的面积是：%.2f", shape.name, shape:area()))
end

local circle = Circle.new(5)
local rectangle = Rectangle.new(4, 6)

printArea(circle)     -- 圆形的面积是：78.54
printArea(rectangle)  -- 矩形的面积是：24.00
```

### 2. 接口模拟

```lua
-- 定义接口（约定）
local Drawable = {
    required = {"draw"}  -- 必须实现的方法
}

-- 检查接口实现
local function implements(class, interface)
    for _, method in ipairs(interface.required) do
        if not class[method] then
            error(string.format("%s必须实现%s方法", class.__name, method))
        end
    end
end

-- 实现接口的类
local Button = class("Button")

function Button:init(text)
    self.text = text
end

function Button:draw()
    return string.format("绘制按钮：[%s]", self.text)
end

-- 验证接口实现
implements(Button, Drawable)

-- 使用示例
local button = Button.new("点击我")
print(button:draw())  -- 绘制按钮：[点击我]
```

## 常见问题解答

### Q1: 如何选择使用冒号语法还是点号语法？

- 冒号语法（`:`）自动传入self参数，用于实例方法
- 点号语法（`.`）不传入self，用于类方法或静态方法

```lua
-- 示例
local MyClass = {}
MyClass.__index = MyClass

-- 使用冒号语法（实例方法）
function MyClass:instanceMethod()
    print(self.value)
end

-- 使用点号语法（类方法）
function MyClass.classMethod()
    print("这是类方法")
end
```

### Q2: 如何实现单例模式？

```lua
-- 单例模式实现
local Singleton = {
    instance = nil
}

function Singleton.getInstance()
    if not Singleton.instance then
        Singleton.instance = {
            data = {},
            -- 其他成员...
        }
    end
    return Singleton.instance
end

-- 使用示例
local instance1 = Singleton.getInstance()
local instance2 = Singleton.getInstance()
print(instance1 == instance2)  -- true
```

### Q3: 如何处理继承中的构造函数调用？

```lua
-- 基类
local Base = class("Base")

function Base:init(value)
    self.value = value
end

-- 子类
local Derived = class("Derived")
setmetatable(Derived, {__index = Base})

function Derived:init(value, extra)
    Base.init(self, value)  -- 调用父类构造函数
    self.extra = extra     -- 添加子类特有的初始化
end
```

## 下一步

现在你已经掌握了Lua的面向对象编程，可以继续学习[协程基础](/article/lua/advanced/coroutines)来了解Lua的并发编程特性。

## 参考资源

- [Lua 5.4 参考手册](http://www.lua.org/manual/5.4/manual.html)
- [Programming in Lua - 面向对象编程](http://www.lua.org/pil/16.html)
- [Lua设计模式](http://lua-users.org/wiki/ObjectOrientedProgramming)

元素码农