lua 实现类的功能

function class(classname, superCls)
    local cls = {}
    cls.__came = classname

    if superCls then
        for k, v in pairs(super) do
            if k ~= "Ctor" then
                cls[k] = v
            end
        end
        
        cls.__superCls = superCls
    end

    cls.__Init = function(instance, ...)
        if cls.__superCls then
            cls.__superCls.__Init(instance, ...)
        end

        if cls.Ctor then
            cls.Ctor (instance, ...)
        end
    end

    cls.New = function(...)
        local instance = setmetatable({}, cls)
        for k, v in pairs(cls) do
            instance[k] = v
            if type(v) == "function" and not cls["S_"..k] then
                rawset(instance, "S_"..k, function(...) return v(instance, ...) end)            
            end
        end

        cls.__Init(instance, ...)

        return instance
    end

    return cls
end

 

### Lua 实现面向对象编程:类定义与继承 #### 类的定义 在 Lua 中,可以利用表(table)和元表(metatable)来模拟类的概念。一个类通常由一个表表示,其中包含了静态变量、静态函数以及用于创建实例的方法 `new`。以下是实现类的一个基本方式: ```lua -- 定义一个类 MyClass local MyClass = {} MyClass.__index = MyClass -- 设置元表的 __index 属性指向自身 function MyClass:new(instance) instance = instance or {} -- 创建一个新的实例或者使用传入的对象 setmetatable(instance, self) -- 将实例的 metatable 设为类本身 return instance end function MyClass:method() print("This is a method of MyClass.") end -- 使用类创建实例 local obj = MyClass:new() -- 调用 new 方法创建实例 obj:method() -- 输出 "This is a method of MyClass." ``` 上述代码展示了如何通过表和元表构建一个简单的类[^1]。 --- #### 成员变量与成员函数 在 Lua 的面向对象模型中,成员变量和成员函数都存储在实例表中。可以通过 `self` 关键字访问当前实例的数据。 ```lua function MyClass:new(name) local instance = { name = name -- 初始化成员变量 } setmetatable(instance, self) return instance end function MyClass:sayHello() print("Hello, my name is " .. self.name) -- 访问成员变量 end -- 测试 local person = MyClass:new("Alice") -- 创建实例并初始化名称 person:sayHello() -- 输出 "Hello, my name is Alice" ``` 此部分实现了带有成员变量和成员函数的简单类结构[^4]。 --- #### 继承机制 Lua 并不提供内置的关键字支持继承,但可以通过设置元表的 `__index` 字段来实现继承关系。子类会自动查找父类中的方法或字段。 ```lua -- 父类 BaseClass local BaseClass = {} BaseClass.__index = BaseClass function BaseClass:new() local instance = {} setmetatable(instance, self) return instance end function BaseClass:greet() print("Greeting from BaseClass!") end -- 子类 SubClass local SubClass = {} SubClass.__index = SubClass setmetatable(SubClass, { __index = BaseClass }) -- 子类继承自父类 function SubClass:new() local instance = BaseClass:new() -- 调用父类构造器 setmetatable(instance, self) return instance end function SubClass:hello() print("Hello from SubClass!") -- 自定义方法 end -- 测试 local subObj = SubClass:new() subObj:hello() -- 输出 "Hello from SubClass!" subObj:greet() -- 输出 "Greeting from BaseClass!" (继承自父类) ``` 这段代码演示了如何通过 `__index` 元方法实现继承功能[^5]。 --- #### 动态扩展与多态 由于 Lua 是动态类型的脚本语言,可以在运行时修改类的行为或添加新的方法。这使得 Lua 的 OOP 更加灵活。 ```lua function SubClass:overrideMethod() print("Overridden method in SubClass.") -- 重写父类方法 end if not SubClass.overrideMethod then function SubClass:defaultBehavior() print("Default behavior added dynamically.") end end local dynamicInstance = SubClass:new() dynamicInstance:overrideMethod() -- 输出 "Overridden method in SubClass." dynamicInstance:defaultBehavior() -- 如果未被覆盖,则执行默认行为 ``` 以上代码片段说明了 Lua 支持动态扩展的能力[^2]。 --- #### 工具库辅助开发 对于更复杂的项目,可以直接借助现有的工具库简化类定义和继承过程。例如 Cocos2d-x 提供了一个名为 `cc.class` 的工具函数,能够快速完成类的设计和继承操作[^3]。 ```lua local cc = require("cocos.framework.cc") local Animal = cc.class("Animal") function Animal:ctor(name) self._name = name end function Animal:speak() print(self._name .. " makes a sound.") end local Dog = cc.class("Dog", Animal) -- Dog 继承自 Animal function Dog:ctor(name) Dog.super.ctor(self, name) -- 调用父类构造器 end function Dog:bark() print(self._name .. " barks loudly.") end local doggy = Dog.new("Rex") doggy:speak() -- 输出 "Rex makes a sound." doggy:bark() -- 输出 "Rex barks loudly." ``` 这一例子进一步证明了 Lua 在实际应用中的灵活性和可扩展性。 ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值