9.4 继承的实现

9.4 继承的实现

Lua 面向对象编程：深入理解继承的实现

在 Lua 语言的背景下，面向对象编程 (OOP) 提供了强大的代码组织和重用机制。继承作为 OOP 的核心概念之一，允许我们创建新的类（在 Lua 中通常是表）来扩展和修改现有类的行为，从而实现代码的复用和层次化结构的构建。

1. Lua 的面向对象基础：元表和 __index 元方法

在深入继承之前，我们需要先回顾 Lua 中实现面向对象的基础机制：元表和 __index 元方法。

• 元表 (Metatable): Lua 中每个表都可以拥有一个元表。元表是一个普通的 Lua 表，它定义了当表作为操作数时，Lua 应该如何行为。我们可以使用 setmetatable(table, metatable) 函数为一个表设置元表。

• __index 元方法: 元表中最关键的元方法之一是 __index。当 Lua 试图访问一个表中不存在的键时，如果该表有元表，并且元表定义了 __index 元方法，Lua 就会调用 __index 元方法来查找键。__index 元方法可以是：

  • 一个函数: 当 __index 是一个函数时，Lua 会调用这个函数，并将原始表和缺失的键作为参数传递给函数。函数的返回值将作为访问结果。

  • 一个表: 当 __index 是一个表时，Lua 会直接在这个表中查找键。如果找到，则返回找到的值；如果没找到，则继续在该表的元表中查找 __index 元方法（形成原型链）。

利用 __index 实现原型继承

Lua 的面向对象编程的核心思想就是利用 __index 元方法来实现原型继承。我们可以将一个表设置为另一个表的元表的 __index，从而建立原型链。当子对象访问自身不存在的成员时，Lua 会沿着原型链向上查找，直到找到该成员或到达原型链的末端。

2. 基于原型继承的单继承实现

单继承是最简单和常见的继承形式，它表示一个类 (子类) 继承自另一个类 (父类)，并获得父类的属性和方法。在 Lua 中，我们可以使用 setmetatable 和 __index 元方法来实现单继承。

代码实践 1: 简单的单继承

-- 父类：Animal
Animal = {
    name = "Animal",
    sound = "Generic animal sound"
}
function Animal:makeSound()
    print(self.sound)
end
-- 子类：Dog，继承自 Animal
Dog = {
    name = "Dog",
    sound = "Woof!"
}
-- 设置 Dog 的元表，并将 __index 指向 Animal
setmetatable(Dog, {__index = Animal})
-- 创建 Dog 的实例
myDog = {name = "Buddy"}
setmetatable(myDog, {__index = Dog})
-- 调用 Dog 实例的方法和属性
print(myDog.name)       -- 输出: Buddy (实例自身的 name 优先)
myDog:makeSound()      -- 输出: Woof! (Dog 自身的 sound 优先，并调用 makeSound 方法)
print(Dog.name)         -- 输出: Dog (Dog 原型的 name)
Dog:makeSound()         -- 输出: Generic animal sound (Dog 原型自身没有 makeSound, 沿着 __index 找到 Animal 的 makeSound)
print(Animal.name)      -- 输出: Animal (Animal 原型的 name)
Animal:makeSound()      -- 输出: Generic animal sound (Animal 原型自身的 makeSound)
-- 修改子类 Dog 的属性
Dog.sound = "Bark!"
Dog:makeSound()         -- 输出: Bark! (修改了 Dog 原型的 sound)
myDog:makeSound()      -- 输出: Woof! (myDog 实例仍然指向旧的 Dog 原型，所以 sound 没有改变)
-- 创建新的 Dog 实例
anotherDog = {name = "Max"}
setmetatable(anotherDog, {__index = Dog})
anotherDog:makeSound() -- 输出: Bark! (新的 Dog 实例指向修改后的 Dog 原型)
-- 修改父类 Animal 的属性
Animal.sound = "New generic sound"
Animal:makeSound()      -- 输出: New generic sound (Animal 原型的 sound 被修改)
Dog:makeSound()         -- 输出: Bark! (Dog 原型的 sound 仍然是 Bark!, 因为它覆盖了 Animal 的 sound)
myDog:makeSound()      -- 输出: Woof! (myDog 实例仍然指向旧的 Dog 原型)
anotherDog:makeSound() -- 输出: Bark! (anotherDog 实例指向修改后的 Dog 原型，但 Dog 原型的 sound 优先)
​

代码详解 1:

1. 父类 Animal 和子类 Dog 的定义: 我们首先创建了两个表 Animal 和 Dog，分别作为父类和子类的原型。它们都包含 name 和 sound 属性，以及 makeSound 方法。

2. 设置 Dog 的元表和 __index: 关键步骤是 setmetatable(Dog, {__index = Animal})。这行代码将 Dog 表的元表设置为一个新表，并将元表的 __index 元方法指向 Animal 表。这意味着当访问 Dog 表中不存在的键时，Lua 会去 Animal 表中查找。

3. 创建实例 myDog 和 anotherDog: 我们使用类似的 setmetatable 和 __index 机制创建了 myDog 和 anotherDog 实例，并将它们的元表的 __index 指向 Dog 表。这样，实例就可以访问 Dog 原型以及 Animal 原型中定义的属性和方法。

4. 属性和方法的访问顺序: 当我们访问 myDog.name 或 myDog:makeSound() 时，Lua 的查找顺序是：

   • 首先在 myDog 实例自身中查找。

   • 如果找不到，则在 myDog 的元表的 __index 指向的 Dog 原型中查找。

   • 如果仍然找不到，则继续在 Dog 原表的 __index 指向的 Animal 原型中查找。

   • 如果最终在原型链的末端仍然找不到，则返回 nil。

5. 属性覆盖和修改:

   • 子类 Dog 可以覆盖父类 Animal 的属性，例如 Dog.sound = "Woof!"。当子类和父类都定义了相同的属性时，子类优先。

   • 修改子类原型 Dog 的属性只会影响后续创建的实例，已经存在的实例仍然指向旧的原型。

   • 修改父类原型 Animal 的属性会影响所有直接或间接继承自 Animal 的类和实例，除非子类或实例自身已经覆盖了该属性。

代码实践 2: 使用构造函数和 new 方法

为了更清晰地创建对象和管理继承关系，我们可以引入构造函数和 new 方法。

-- 父类：Shape
Shape = {}
function Shape:new(x, y)
    local obj = {x = x or 0, y = y or 0}
    setmetatable(obj, self) -- self 指向 Shape 原型
    self.__index = self     -- 关键步骤：设置 Shape 原型自身的 __index 指向自身
    return obj
end
function Shape:area()
    return 0 -- 默认面积为 0
end
function Shape:perimeter()
    return 0 -- 默认周长为 0
end
-- 子类：Rectangle，继承自 Shape
Rectangle = {}
setmetatable(Rectangle, {__index = Shape}) -- 设置 Rectangle 继承自 Shape
function Rectangle:new(x, y, width, height)
    local obj = Shape:new(x, y) -- 调用父类的构造函数
    obj.width = width or 1
    obj.height = height or 1
    setmetatable(obj, Rectangle) -- self 指向 Rectangle 原型
    Rectangle.__index = Rectangle -- 关键步骤：设置 Rectangle 原型自身的 __index 指向自身
    return obj
end
function Rectangle:area()
    return self.width * self.height
end
function Rectangle:perimeter()
    return 2 * (self.width + self.height)
end
-- 子类：Square，继承自 Rectangle
Square = {}
setmetatable(Square, {__index = Rectangle}) -- 设置 Square 继承自 Rectangle
function Square:new(x, y, side)
    local obj = Rectangle:new(x, y, side, side) -- 调用父类的构造函数
    setmetatable(obj, Square) -- self 指向 Square 原型
    Square.__index = Square   -- 关键步骤：设置 Square 原型自身的 __index 指向自身
    return obj
end
-- 创建实例
local rect = Rectangle:new(10, 20, 5, 8)
print("Rectangle Area:", rect:area())      -- 输出: Rectangle Area: 40
print("Rectangle Perimeter:", rect:perimeter()) -- 输出: Rectangle Perimeter: 26
local sq = Square:new(30, 40, 6)
print("Square Area:", sq:area())         -- 输出: Square Area: 36
print("Square Perimeter:", sq:perimeter())    -- 输出: Square Perimeter: 24
local shape = Shape:new(0, 0)
print("Shape Area:", shape:area())         -- 输出: Shape Area: 0
print("Shape Perimeter:", shape:perimeter())    -- 输出: Shape Perimeter: 0
​

代码详解 2:

1. new 方法作为构造函数: 我们为每个类 (原型表) 定义了一个 new 方法，作为构造函数。new 方法负责创建新的对象实例，并设置正确的元表和原型链。

2. self.__index = self 的作用: 在 Shape:new 和 Rectangle:new 中，我们都添加了 self.__index = self 这行代码。这行代码的目的是让原型对象自身也能够访问自身的方法。例如，在 Shape:new 中，self 指向 Shape 原型表，self.__index = self 将 Shape 原型表的 __index 元方法设置为指向自身，这样当我们调用 Shape:area() 时，self 指向 Shape 原型，self.area 就能找到 Shape 原型表中定义的 area 函数。

3. 调用父类构造函数: 子类 Rectangle 和 Square 的 new 方法都调用了父类的构造函数 Shape:new 和 Rectangle:new，以复用父类的初始化逻辑。例如，Rectangle:new 调用 Shape:new(x, y) 初始化了 x 和 y 坐标。

4. 方法重写 (Override): 子类可以重写父类的方法，例如 Rectangle 和 Square 都重写了 area 和 perimeter 方法，提供了更具体的实现。当子类实例调用这些方法时，会优先执行子类自身定义的方法。

3. 多重继承的实现 (Lua 模拟)

Lua 本身并不直接支持像 C++ 或 Python 那样的多重继承，但我们可以通过一些技巧来模拟多重继承的效果。一种常见的模拟方法是使用一个函数作为 __index 元方法，并在该函数中遍历多个父类原型，查找所需的成员。

代码实践 3: 模拟多重继承

-- 父类 1: Speaker
Speaker = {
    functionality = "Speak"
}
function Speaker:speak(message)
    print("Speaker says:", message)
end
-- 父类 2: Writer
Writer = {
    functionality = "Write"
}
function Writer:write(text)
    print("Writer writes:", text)
end
-- 子类: TalkingWriter，模拟继承自 Speaker 和 Writer
TalkingWriter = {}
-- 模拟多重继承的 __index 元方法
local multi_inheritance_index = function(table, key)
    -- 遍历父类原型列表
    for _, parent in ipairs({Speaker, Writer}) do
        local value = parent[key]
        if value ~= nil then
            return value -- 找到成员，直接返回
        end
    end
    return nil -- 没有找到
end
setmetatable(TalkingWriter, {__index = multi_inheritance_index})
function TalkingWriter:new(name)
    local obj = {name = name}
    setmetatable(obj, TalkingWriter)
    TalkingWriter.__index = TalkingWriter
    return obj
end
function TalkingWriter:introduce()
    print("I am", self.name, ", I can", Speaker.functionality, "and", Writer.functionality) -- 直接访问父类的属性
end
-- 创建 TalkingWriter 实例
local tw = TalkingWriter:new("Alice")
tw:speak("Hello world!")        -- 输出: Speaker says: Hello world! (继承自 Speaker)
tw:write("This is my story.")    -- 输出: Writer writes: This is my story. (继承自 Writer)
tw:introduce()                -- 输出: I am Alice , I can Speak and Write (访问父类的属性)
print(TalkingWriter.functionality) -- 输出 nil (TalkingWriter 自身没有 functionality 属性，__index 函数优先查找实例的元表)
​

代码详解 3:

1. 多个父类原型 Speaker 和 Writer: 我们定义了两个父类原型 Speaker 和 Writer，分别具有不同的功能。

2. 模拟多重继承的 __index 函数: 我们定义了一个名为 multi_inheritance_index 的函数，作为 TalkingWriter 的元表的 __index 元方法。这个函数接受两个参数：table (原始表，即 TalkingWriter 实例) 和 key (要查找的键)。

3. 遍历父类原型列表: 在 multi_inheritance_index 函数中，我们使用 ipairs 遍历一个包含父类原型 Speaker 和 Writer 的列表。对于每个父类原型，我们尝试查找 key。如果找到，则立即返回找到的值。

4. 查找顺序: 在上面的例子中，multi_inheritance_index 函数的查找顺序是先查找 Speaker，再查找 Writer。这意味着如果 Speaker 和 Writer 中都定义了相同的键，则 Speaker 中的定义会优先被访问到 (类似于 C++ 的多重继承中的菱形继承问题)。

5. 局限性: 这种模拟多重继承的方法有一些局限性：

   • 性能开销: 每次访问不存在的键时，都需要遍历父类原型列表，可能会有性能开销。

   • 命名冲突: 如果多个父类原型中存在相同的键，需要仔细考虑查找顺序，避免命名冲突导致意外的结果。

   • 复杂性: 当继承层次和父类数量增加时，__index 函数的逻辑可能会变得复杂。

4. 基于原型克隆的 "继承" (原型式继承)

Lua 作为一种原型语言，也支持直接基于原型克隆的 "继承" 方式。这种方式更符合原型语言的本质，它不是通过建立原型链来继承，而是直接克隆一个现有对象作为新对象的基础。

代码实践 4: 原型克隆 "继承"

-- 原型对象：Vehicle
Vehicle = {
    type = "Vehicle",
    speed = 0
}
function Vehicle:accelerate(increment)
    self.speed = self.speed + increment
    print(self.type, "speed increased to", self.speed)
end
function Vehicle:brake(decrement)
    self.speed = math.max(0, self.speed - decrement)
    print(self.type, "speed decreased to", self.speed)
end
-- 克隆原型创建 Car 对象
Car = {}
for k, v in pairs(Vehicle) do
    Car[k] = v -- 浅拷贝原型属性
end
Car.type = "Car" -- 修改 Car 自身的 type 属性
-- 克隆原型创建 Bike 对象
Bike = {}
for k, v in pairs(Vehicle) do
    Bike[k] = v -- 浅拷贝原型属性
end
Bike.type = "Bike" -- 修改 Bike 自身的 type 属性
-- 创建 Car 实例
myCar = {}
for k, v in pairs(Car) do
    myCar[k] = v -- 浅拷贝 Car 属性
end
setmetatable(myCar, {__index = Car}) -- 可选，如果 Car 本身有方法需要被实例访问，则需要设置元表
-- 创建 Bike 实例
myBike = {}
for k, v in pairs(Bike) do
    myBike[k] = v -- 浅拷贝 Bike 属性
end
setmetatable(myBike, {__index = Bike}) -- 可选，同上
-- 使用实例
myCar:accelerate(20)   -- 输出: Car speed increased to 20
myCar:brake(5)        -- 输出: Car speed decreased to 15
myBike:accelerate(10)  -- 输出: Bike speed increased to 10
myBike:brake(2)       -- 输出: Bike speed decreased to 8
print(Vehicle.speed)   -- 输出: 0 (原型对象的速度不受实例操作影响)
print(Car.speed)       -- 输出: 0 (Car 原型的速度也不受实例操作影响)
print(myCar.speed)     -- 输出: 15 (实例自身的速度被修改)
​

代码详解 4:

1. 原型对象 Vehicle: 我们定义了一个原型对象 Vehicle，它包含了 type 和 speed 属性，以及 accelerate 和 brake 方法。

2. 克隆原型创建 Car 和 Bike: 我们使用 for k, v in pairs(Vehicle) do Car[k] = v end 循环来浅拷贝 Vehicle 原型对象的属性和方法到 Car 对象中。然后，我们修改 Car.type = "Car" 来定制 Car 对象的 type 属性。Bike 对象的创建过程类似。

3. 浅拷贝: 这里的克隆是浅拷贝。这意味着对于基本类型属性 (如数字、字符串)，会复制值；对于复杂类型属性 (如表、函数)，会复制引用。在上面的例子中，方法 (函数) 是被共享的，而属性 (如 type 和 speed) 是独立的。

4. 实例创建: 创建 myCar 和 myBike 实例的过程也类似，我们浅拷贝 Car 和 Bike 对象的属性和方法到实例中。

5. 独立性: 基于原型克隆的 "继承" 方式创建的对象是相对独立的。修改实例的属性不会影响原型对象或其他实例。每个实例都拥有自己的一份属性副本。

6. 适用场景: 原型克隆 "继承" 更适合创建彼此之间差异较小的对象，或者需要避免原型链查找开销的场景。它更强调对象的复制和定制，而不是通过原型链进行动态查找。

5. 总结和最佳实践

Lua 提供了灵活的方式来实现面向对象编程中的继承，主要依赖于元表和 __index 元方法。

• 单继承: 是最常见的继承形式，可以使用 setmetatable 和 __index = 父类原型 来实现。

• 多重继承 (模拟): 可以使用函数作为 __index 元方法，遍历多个父类原型来模拟多重继承，但需要注意性能开销和命名冲突。

• 原型克隆 "继承": 通过浅拷贝原型对象来创建新对象，更符合原型语言的本质，适用于创建差异较小的对象或需要避免原型链查找开销的场景。

最佳实践:

• 优先使用组合 (Composition) 而非继承: 在很多情况下，组合比继承更灵活、更易于维护。可以考虑使用组合来构建复杂对象，而不是过度依赖继承层次。

• 谨慎使用多重继承: Lua 模拟的多重继承方式较为复杂，容易引入命名冲突和性能问题。除非必要，尽量避免使用多重继承。

• 理解原型继承的本质: Lua 的面向对象编程是基于原型的，理解原型继承的机制对于编写高效和可维护的 Lua 代码至关重要。

• 选择合适的继承方式: 根据具体的应用场景和需求，选择最合适的继承方式。单继承通常足以应对大多数情况，原型克隆 "继承" 适用于特定场景，而多重继承应谨慎使用。

• 代码清晰和可读性: 在实现继承时，保持代码的清晰和可读性非常重要。合理使用注释和命名，使代码易于理解和维护。