Lua的oop分析

1. self

它相当于c++的this指针，指向调用者自身。当我们在lua里使用它时，使用冒号就可以隐藏该self参数

function People:speak(v)
  self.setence = v
end

function People.speak(self,v)
  self.setence = v
end

2. Lua对象中的特殊现象

无须为指定一种新行为而创建一个新类。
假设我们现在有一个基类Acount、派生类SpecialAccount，此时我们实例化派生类并存储为s，而这个s这个对象需要某种特殊的行为，那么我们就可以直接在该对象中实现这个行为。
例如：s是一个特殊客户，他可透支额度为余额的10%。那么可以只修改这个对象：

function s:getLimit()
  return self.balance*0.10
end

看起来好像不错的样子，但是我觉得这样破坏了类的封装性（虽然Lua里也没有类的概念），以后工作上如果遇到了类似问题我再回来补充。

3. 多重继承

我们先来看一下多重继承的小demo，要创建一个新类FemaleProgrammer，同时从Human和Programmer中派生，那么只需要调用creatClass

local function search(k, tables)
    for i, v in ipairs(tables) do
        if v[k] then
            return v[k]
        end
    end
    return nil
end

-- 这里实现多重继承，参数arg为多重父类表

function createClassFrom(...)
    -- c为返回值的目标表，为实现多重继承的子类表

    local c = {}   
    local parents = {...}
    -- 类在父类列表里的搜索方法
    setmetatable(c, {__index = function(t, k)
        return search(k, parents)
    end})

    function c:new(o)
        o = o or {}
        setmetatable(o, {__index = c})
        return o
    end

    return c
end

-- 人 吃饭

Human = {name = "human"}
function Human:eat()
    print("human eat")
end

-- 程序员 写代码

Programmer = {name = "coder"}
function Programmer:doProgramming()
    print("do coding")
end

-- 女程序员 继承 人和程序员

-- 性别女

FemaleProgrammer = createClassFrom(Human, Programmer)
local femaleCoder = FemaleProgrammer:new({sex = "female", canBear = function() print("Female: can give birth a baby!") end})
femaleCoder:eat() -- human eat

femaleCoder:doProgramming() -- do coding

function createClass(...)
    local parents = {...};
    local child = {};
   
    -- 设置类的元表
    setmetatable(child, {
        __index = function(table, key)
            return search(parents, key);
        end
    })
   
    -- 给类新增一个new函数，用于创建对象
    function child:new()
        o = {};
        setmetatable(o, child);
        child.__index = child;
        return o;
    end
   
    -- 返回这个继承了多个类的子类
    return child;
end
function search(classes, key)
    for i = 1, #classes do
        local value = classes[i][key];
        if value ~= nil then
            return value;
        end
    end
end

--一个精灵类
    TSprite = {}
    function TSprite:hello()
        print("谁跟你hello！");
    end
   
    function TSprite:new()
        o = {}
        setmetatable(o, self);
        self.__index = self;
        return o;
    end
   
    -- 一个子弹类
    TBullet = {}
    function TBullet:fire()
        print("别动，再动我就瞄不准了！");
    end
    function TBullet:new()
        o = {}
        setmetatable(o, self);
        self.__index = self;
        return o;
    end
   
    -- 继承了两个类的子类
    local BulletSprite = createClass(TSprite, TBullet);
   
    -- 子类的对象
    local bSprite = BulletSprite:new();
    bSprite:hello();
    bSprite:fire();

4. Lua对象私有性的实现

4.1 实现一

function A()
     local _m
     local function B()
          call _m
     end 
     return instanceA
end

4.2 实现二

先创建一个table保存对象的内部状态，存储在局部变量self，然后函数创建并返回一个供外部使用的对象，因为这些方法无须额外的self参数，所以无法使用冒号来操作对象。如果我们不希望用户直接访问的信息，就不要让它返回。
如下的extra

function newAccount (initialBalance)
    local self = { balance = initialBalance , 
                   LIM = 1314 }

    local withdraw = function (v)
       self.balance = self.balance - v
    end

    local extra = function ()
       if self.balance > self.LIM then
           return self.balance*0.10
       else
           return 0
       end
    end

    local deposit = function (v)
       self.balance = self.balance + v
    end

    local getBalance = function () 
        return self.balance + extra()  --[此处非self.extra()]
    end
    
    return {
       withdraw = withdraw,
       deposit = deposit,
       getBalance = getBalance,
       -- extra = extra,
    }
end

快速删除表中一系列数据

function firedChicken:popUpDataFromList(list,index)

    local tempTable = {}
    for k,v in ipairs(list) do
        if k>index then
            table.insert(tempTabel,v)
        end
    end
    list = tempTabel
end