面向对象

1.self

Account={balance=0}
function Account.with(v)
    Account.balance= Account.balance-v
end
Account.with(100)
print(Account.balance)

local person={name="nAMW",age=26}
function  person.eat(self)
 print(self.name.."今年"..self.age.."岁了")
 end
 person2={name="nAMW55",age=100,eat=person.eat}
 person2:eat() --nAMW55今年100岁了
 person:eat()--nAMW今年26岁了

2.类

local Account={balance=0}
function Account:withdraw(v)
    self.balance=self.balance-v
end
function Account:deposit(v)
    self.balance=self.balance+v
end
function Account:new(o)
    o=o or {}
    return setmetatable(o, {__index=self})
end
a= Account:new({balance=100})
print(a.balance) --100
a:deposit(100)
print(a.balance) --200

3.继承

local Account={balance=0}
function Account:new(o)
    o=o or {}
    return setmetatable(o, {__index=self})
end
function Account:deposit(v)
    self.balance=self.balance+v
end
function Account:withdraw(v)
    if v>self.balance then
       return
    end
    self.balance=self.balance-v
end
SpecialAccount=Account:new()
s=SpecialAccount:new({limit=1000})
s:deposit(100)
print(s.balance) --100

SpecialAccount=Account:new()
function SpecialAccount:withdraw(v)
print(55)
end
s=SpecialAccount:new({limit=1000})
s:withdraw(100) --55

SpecialAccount=Account:new()
function SpecialAccount:withdraw(v)
self:getlimit()
end
function SpecialAccount:getlimit()
 print("SpecialAccount:getlimit")
end
s=SpecialAccount:new({limit=1000})
function s:getlimit()
    print("s:getlimit")
end
s:withdraw(100) --s:getlimit

4.多重继承

local function search(k,plist)
    for i=1,#plist do
       local v =plist[i][k]
       if v then
        return v 
       end
    end
end

function createClass(...)
    local c = {}
    local parents={...}
setmetatable(c, {__index=function(t,k) 
    return search(k,parents)
end})
    c.__index=c
    function c:new(o)
        o=o or {}
        return setmetatable(o,c)
    end
    return c
end
Named={}
function Named:getName()
    return self.name
end
function Named:setName(name)
   self.name=name
end
local Account={balance=0}
function Account:deposit(v)
    self.balance=self.balance+v
end
function Account:withdraw(v)
    if v>self.balance then
       return
    end
    self.balance=self.balance-v
end

NamedAccount=createClass(Account,Named)
NamedAccount:setName("pllp") 
print(NamedAccount:getName()) --pllp
print(NamedAccount.balance) --0

--多重继承是查找两个或以上的table。
function search(classes,key )
    for i = 1, #classes do
        local value=classes[i][key]
        if value then
        return value
        end
    end
end
local t1 = {name = "hehe"};
local t2 = {game = "who"};
print(search({t1, t2}, "game"));
--这里的classes参数，是一个table，这个table里又存放了多个table，也就是我们想要继承的那些类。
--而key就是要查找的字段。
--只需要遍历所有的table，判断这个字段是否在某个table里，找到之后，就返回这个值。
--我们的测试代码就是从t1、t2中查找game这个字段，t1、t1可以看成是两个类。

createClass函数就是用来创建一个继承了多个类的子类，有点小复杂，慢慢分析：

1） 参数是一个可变参数，我们要将多个被继承的类作为参数传递进来

2） parents用于保存这些被继承的类

3） 创建一个新的table——child，它就是我们想要的那个继承了多个类的子类

4） 给child设置元表，并且设置index元方法，index元方法可以是一个函数，当它是一个函数时，它的参数就是元表所属的table，以及要查找的字段名。

5） 我们在__index元方法函数里调用search函数，从多个父类中查找所需的字段。于是，当调用child的某个函数时，就会从各个父类中查找，这已经完成了继承的工作了。

6） 接下来就是我们所熟悉的new函数，用来创建child的子类。

7） 最后返回child，一切都完成了。

--多重继承是查找两个或以上的table。
function search(classes,key )
    for i = 1, #classes do
        local value=classes[i][key]
        if value then
        return value
        end
    end
end

--参数是一个可变参数，我们要将多个被继承的类作为参数传递进来
function createClass(...)
    local parents={...}
    local child={}
    -- 设置类的元表
    setmetatable(child,{__index=function(table,key )
        return search(parents,key)
    end})
    -- 给类新增一个new函数，用于创建对象
    function child:new( )
      o = o or {}
      return setmetatable(o,{__index=child})
    end
    return child
end


local person={}
function person:hellow()
   print("person:hellow")
end

local student={}
function student:study()
    print("student:study")
end
local newClass=createClass(person,student)
newClass:study() --student:study
newClass:hellow() --person:hellow

5.类的私有性

function newAccount(initBalance)
    local self={balance=initBalance}
    local withdraw=function(v)
       self.balance=self.balance-v
    end
    local getbalance=function() 
        return self.balance
    end
    return {withdraw=withdraw,getbalance=getbalance}
end
cc=newAccount(100)
cc.withdraw(40)
print(cc.getbalance())--60

6.单方法对象

7.对偶表示