Lua该如何实现一个类，实现继承

 Lua是一门解释型语言，C++，C#，Java等高级语言都属于编译型语言，编译型语言同解释型语言有着很大差别。（看官请自行百度）

 Lua没有类和继承的概念，但是很多业务场景中，我们会需要自行实现类与继承的概念，以方便开发工作：Lua中table 是一个很强大的东西。

不多说无关紧要的：进入正题：

 

--@param string classname 类名
--@param [mixed super] 父类或者创建对象实例的函数

function class(classname, super)
    local superType = type(super)
    local cls

    if superType ~= "function" and superType ~= "table" then
        superType = nil
        super = nil
    end

    if superType == "function" or (super and super.__ctype == 1) then
        -- inherited from native C++ Object
        cls = {}

        if superType == "table" then
            -- copy fields from super
            for k,v in pairs(super) do cls[k] = v end
            cls.__create = super.__create
            cls.super    = super
        else
            cls.__create = super
            cls.ctor = function() end
        end

        cls.__cname = classname
        cls.__ctype = 1

        function cls.new(...)
            local instance = cls.__create(...)
            -- copy fields from class to native object
            for k,v in pairs(cls) do instance[k] = v end
            instance.class = cls
            instance:ctor(...)
            return instance
        end

    else
        -- inherited from Lua Object
        if super then
            cls = {}
            setmetatable(cls, {__index = super})
            cls.super = super
        else
            cls = {ctor = function() end}
        end

        cls.__cname = classname
        cls.__ctype = 2 -- lua
        cls.__index = cls

        function cls.new(...)
            local instance = setmetatable({}, cls)
            instance.class = cls
            instance:ctor(...)
            return instance
        end
    end

    return cls
end

如果对象是指定类或其子类的实例，返回 true，否则返回 false

简单实例：

local Animal = class("Animal")
local Duck = class("Duck", Animal)

print(iskindof(Duck.new(), "Animal")) -- 输出 true

 

-- 定义名为 Shape 的基础类
local Shape = class("Shape")

-- ctor() 是类的构造函数，在调用 Shape.new() 创建 Shape 对象实例时会自动执行
function Shape:ctor(shapeName)
    self.shapeName = shapeName
    printf("Shape:ctor(%s)", self.shapeName)
end

-- 为 Shape 定义个名为 draw() 的方法
function Shape:draw()
    printf("draw %s", self.shapeName)
end

--

-- Circle 是 Shape 的继承类
local Circle = class("Circle", Shape)

function Circle:ctor()
    -- 如果继承类覆盖了 ctor() 构造函数，那么必须手动调用父类构造函数
    -- 类名.super 可以访问指定类的父类
    Circle.super.ctor(self, "circle")
    self.radius = 100
end

function Circle:setRadius(radius)
    self.radius = radius
end

-- 覆盖父类的同名方法
function Circle:draw()
    printf("draw %s, raidus = %0.2f", self.shapeName, self.raidus)
end

--

local Rectangle = class("Rectangle", Shape)

function Rectangle:ctor()
    Rectangle.super.ctor(self, "rectangle")
end

--

local circle = Circle.new()             -- 输出: Shape:ctor(circle)
circle:setRaidus(200)
circle:draw()                           -- 输出: draw circle, radius = 200.00

local rectangle = Rectangle.new()       -- 输出: Shape:ctor(rectangle)
rectangle:draw()      

 

以上创建class 概念的方法是cocos2d 中使用到的方式，也是推荐的方式，这个方式可以在Unity 中同样适用。

 

 

第二种更简单实用的方式：

在Unity 开发过程中我们很多时候会采用热更新的解决方案，当然在cocos 开发过程中也一样，作为解释型语言，lua脚本可以作为资源被打包，逻辑写在lua脚本中

Account={name='li',balance=100}

function Account:withdraw(v)
    self.balance=self.balance-v
    end
    
function Account:new(o)
    o =o or {}  --如果用户没有提供table，则创建一个
    setmetatable(o,self) --设置o的原表为Account
    self.__index=self--设置Account的索引为它自身
    return o
end

acc = Account:new()
acc:withdraw(0)
print(acc.balance)
print(acc.name)

---------------Lua模拟继承---------------------------
--子类继承父类
SpecialAccount =Account:new({limit=1000}) 
--子类重写父类的方法
function SpecialAccount:withdraw(v)
    print('SpecialAccount的方法')
    self.balance=self.balance-v
end
--实例化一个子类对象
 vip=SpecialAccount:new()
--调用从写的方法
vip:withdraw(100)
print(vip.balance)