【懒人精灵】什么是OOP？详解Lua的OOP模式

一、什么是OOP？

OOP（Object-Oriented Programming，面向对象编程）是一种编程范式，核心思想是将程序中的数据和操作数据的方法封装为“对象”，通过封装、继承、多态三大特性组织代码，提升代码的复用性、可维护性和扩展性。

OOP核心特性：

1. 封装：将对象的属性（数据）和方法（行为）绑定，隐藏内部实现细节，仅暴露对外接口；
2. 继承：子类复用父类的属性和方法，同时可扩展或重写父类逻辑；
3. 多态：同一方法在不同对象上表现出不同行为（如子类重写父类方法）。

不同于Java、C++等静态语言，Lua 本身没有内置的OOP语法（如class、extends关键字），但可通过其核心特性（表、元表、闭包）模拟完整的OOP模式。

二、Lua的OOP实现基础

Lua实现OOP的核心载体是表（table） 和元表（metatable）：

• 表：作为“对象”，存储属性（如obj.name）和方法（如obj:say()）；
• 元表：通过__index元方法实现“继承”（查找父类属性/方法），__newindex控制属性赋值，__call模拟构造函数等；
• 冒号语法：obj:method() 是 obj.method(obj) 的语法糖，自动将对象作为第一个参数传递（对应其他语言的this/self）。

三、Lua的经典OOP模式

模式1：基于表和元表的简单类（最常用）

核心思路：

• 用一个“原型表”（如Person）存储类的方法；
• 用new方法创建实例，实例的元表指向原型表，通过__index继承方法；
• 实例表存储自身属性，原型表存储共享方法。

-- 1. 定义“类”（原型表）
Person = {}
-- 2. 构造函数（创建实例）
function Person:new(name, age)
    -- 实例表：存储对象自身属性
    local obj = {name = name, age = age}
    -- 设置实例的元表为Person，继承方法
    setmetatable(obj, self)
    -- 元表的__index指向自身（Person），保证查找方法时能找到
    self.__index = self
    return obj
end

-- 3. 定义类的方法（共享）
function Person:sayHello()
    print("Hello, I'm " .. self.name .. ", " .. self.age .. " years old")
end

-- 4. 创建实例并调用方法
local p1 = Person:new("Alice", 20)
p1:sayHello() -- 输出：Hello, I'm Alice, 20 years old

-- 5. 实例扩展属性（仅属于当前实例）
p1.gender = "female"
print(p1.gender) -- female

模式2：继承的实现

基于上述基础，通过让子类的元表指向父类，实现继承：

-- 子类：Student 继承 Person
Student = Person:new() -- 子类原型表继承父类原型表

-- 子类构造函数（重写+复用父类逻辑）
function Student:new(name, age, grade)
    -- 复用父类构造函数创建实例
    local obj = Person:new(name, age)
    -- 子类专属属性
    obj.grade = grade
    -- 设置实例元表为Student，优先查找子类方法
    setmetatable(obj, self)
    self.__index = self
    return obj
end

-- 子类重写方法（多态）
function Student:sayHello()
    print("Hello, I'm " .. self.name .. ", grade " .. self.grade)
end

-- 子类新增方法
function Student:study()
    print(self.name .. " is studying")
end

-- 创建子类实例
local s1 = Student:new("Bob", 15, 9)
s1:sayHello() -- 输出：Hello, I'm Bob, grade 9
s1:study()    -- 输出：Bob is studying

模式3：闭包实现私有属性

Lua的表属性默认是公有的，可通过闭包（函数嵌套）实现私有属性（仅内部方法可访问）：

function Person:newWithPrivate(name, age)
    -- 私有属性（闭包变量，外部无法访问）
    local privateAge = age

    -- 实例表（仅暴露公有属性/方法）
    local obj = {name = name}
    setmetatable(obj, self)
    self.__index = self

    -- 公有方法：访问私有属性
    function obj:getAge()
        return privateAge
    end

    -- 公有方法：修改私有属性
    function obj:growUp()
        privateAge = privateAge + 1
    end

    return obj
end

-- 使用私有属性
local p2 = Person:newWithPrivate("Charlie", 25)
print(p2.name)      -- Charlie（公有）
print(p2.privateAge) -- nil（私有，外部不可见）
print(p2:getAge())  -- 25（通过方法访问）
p2:growUp()
print(p2:getAge())  -- 26

四、Lua OOP的特点

1. 灵活性：无固定语法，可按需模拟类、继承、私有属性等；
2. 轻量：基于表和元表实现，无额外开销；
3. 动态性：实例可随时扩展属性/方法，类可动态修改；
4. 无严格的访问控制：私有属性需通过闭包模拟，而非语言原生支持。