Lua的面向对象——类和继承

标签：

本文转载于：http://www.benmutou.com/archives/1791

终于来了，在Lua中的面向对象编程，相信目前学习Lua的大部分人都是为了开发手机网游吧。
而且基本都是奔着脚本语言的热更新特性去的，所以全脚本开发变得十分流行。

对于普及不太广的Lua（相对于C++、Java等主流语言），需要短时间上手开发游戏，对新手而言不算简单。
所以大家才更习惯于继续用面向对象思想去折腾Lua吧~

好了，不唠叨了，我最不喜欢唠叨了。（小若：是是是，你一点都不唠叨，赶紧开讲！）

1.类的对象

至于如何创建一个类，大家已经很清楚了，就是一个table而已。

那么，要使用这个类去创建多个对象，又如何实现呢？

使用元表和元方法即可。

如下代码：

 TSprite = {
        x = 0,
        y = 0,
    }
    function TSprite:setPosition(x, y)
        self.x = x;
        self.y = y;
    end
   
    function TSprite:new()
        o = {}
        setmetatable(o, {__index = self});
        return o;
    end
   
    local who1 = TSprite:new();
    local who2 = TSprite:new();
    who1:setPosition(1, 2);
    who2:setPosition(44, 6);
    print("who1坐标(" .. who1.x .. "," .. who1.y .. ")");
    print("who2坐标(" .. who2.x .. "," .. who2.y .. ")");

留意TSprite的new函数，函数里创建了一个新的table，并且给新的table设置一个元表，这个元表的__index元方法就是TSprite本身，最后返回这个新的table。

于是，所有通过new生成的新table，都可以使用TSprite的函数和各个字段属性（因为__index的值是TSprite）。

因此，我们利用new函数创建了who1和who2，并且调用它们的setPosition函数，最后，who1和who2的x、y值都是不同的。

这就是类的对象了。

2.类对象的__index都是同一个TSprite，为什么x、y值可以不相同？

不知道大家有没有这样一个疑惑，那就是，为什么who1和who2的x、y是不一样的，它们最终调用的不是setPosition函数么？调用self.x时最终不是调用了TSprite的x值么？

这里是会有点混乱，理一理就没问题了：

1). 当who1里不存在setPosition时，回去__index元方法里查找，于是，会找到TSprite的setPosition函数

2). 在setPosition函数里，使用了self.x = x，此时的self就是who1，who1中是不存在x字段的，所以，如果我们要打印self.x的值，则其实是打印了TSprite的x值

3). 但是，注意，但是来了。__index元方法是用于调用的，而不是用于赋值的，因此，self.x = x这句话，其实只是给who1这个table的x字段赋值了，who1本身不存在x字段，此时给它赋值了，于是who1存在了x字段，以后who1都不会再去TSprite里查找x字段了。

4). 因此，对who1和who2的x、y字段进行赋值操作时，是完全不会影响到TSprite的。

3.节省资源——使用TSprite作为元表

我们再仔细观察一下new函数，我们在给新table设置元表的时候，是重新创建了一个元表的：setmetatable(o, {__index = self});

这么做的话，每次调用new函数创建一个新对象时，都会产生一个新的元表，虽然这开支似乎可以忽略，但，拥有强迫症的你，一定很喜欢下面的代码：

function TSprite:new()
        o = {}
        setmetatable(o, self);
        self.__index = self;
        return o;
    end

在这段新的new函数里，使用self作为元表，然后又使用self作为__index的值。

这么一看，有点绕不过来，我就喜欢大家绕不过来，这样我又可以唠叨了：

1). 调用new函数时，self其实就是TSprite本身，这里完全可以用TSprite代替，不过，为了给以后做铺垫，这里还是使用self吧。

2). self.__index = self，不要被这句代码吓到了，其实还是那么一回事，设置元表的__index元方法，这里就 相当于TSprite.__index = TSprite。

3). TSprite自己作为__index的值没问题么？确实没问题，TSprite也是一个table，table可以作为元表，元表可以有__index元方法，这丝毫没有英雄。

4). 于是，通过这个小技巧，我们就避免了每次调用new函数时都额外创建一个新的元表了。

4.富二代什么的我才不喜欢——继承

我们总是笑话富二代，但谁的内心深处不希望自己是一个富二代呢~

像我这种立志靠自己成为富一代的人，可不多了~（小若：啊我呸~！）

那么，在Lua里如何实现继承呢？很简单，但是需要认真思考，如下代码：

TSprite = {
        x = 0,
        y = 0,
    }
    function TSprite:setPosition(x, y)
        self.x = x;
        self.y = y;
    end
   
    function TSprite:new()
        o = {}
        setmetatable(o, self);
        self.__index = self;
        return o;
    end
   
    local MoneySprite = TSprite:new();
    function MoneySprite:setPosition(x, y)
        print("呵呵，我是富二代，根本不需要改变。");
    end

TSprite仍然没变，但是，我们看看MoneySprite，按之前的理解，它是TSprite的一个对象。

只是，“对象”这称呼是我们自己定的，实际上它还是一个table而已。

此时，我们修改了MoneySprite的setPosition函数，于是，调用MoneySprite的setPosition函数时，与TSprite无关了。

但，这不是重点，重点是接下来的代码：

 local who = MoneySprite:new();
    who:setPosition(44, 6);
   
    print("who坐标(" .. who.x .. "," .. who.y .. ")");

我们再次调用MoneySprite的new函数创建了一个新对象。

这又是什么情况呢？关键是new函数里的代码，此时，new函数里的self是谁？

new函数是由MoneySprite调用的，因此，self就是MoneySprite。

于是新对象的元表就是MoneySprite，元表的__index也是MoneySprite。

因此~！很神奇的，调用who的setPosition函数的时候，其实也是调用了MoneySprite的setPosition函数。

于是，who就是是MoneySprite的对象，而MoneySprite就是TSprite的子类。

来看看输出结果吧：

[LUA-print] 呵呵，我是富二代，根本不需要改变。
[LUA-print] who坐标(0,0)

怎么样？继承的实现方法也很简单吧？

如果对元表、元方法、self比较生疏的话，可能一时间会理解不过来，没关系，多思考一会，或者隔天再回头思考，就会豁然开朗了。

5.结束

不知不觉这个系列的文章已经写了20篇了，真是太出乎我的意料了。

我竟然可以坚持下来，但写文章的效果确实很好，每晚的1个多小时付出也很值得。

起码，我对Lua基础的理解又更加巩固了~

好吧，继续坚持…（小若：所以说啊~！为什么每次都要用省略号，用感叹号不是更能表达你的决心吗…）

Lua的面向对象——类和继承

标签：

原文地址：http://www.cnblogs.com/guangyun/p/4685529.html