Accout = {balance = 0}

functionAccout.count( v )

    print ("value is "..v)

end

--声明label对象（变量）accout
accout = Accout

--通过对象调用方法
accout.count(1000)

Accout = {balance = 10}


--显示传入self
functionAccout.count( self,  v )

    self.balance = self.balance + v;

    print ("value is "..self.balance)

end

--声明label对象（变量）accout
accout = Accout

--通过对象调用方法, 显示的把accout这个 table 这个对象传入到函数 (显示的传入 self)

accout.count(accout, 1000)


--还可通过 : 调用的方式隐试的传入 self 对象
accout:count(2000)

Accout = { balance = 10}


--通过 : 符号, 隐试传入 self
functionAccout:count( v )

    self.balance = self.balance + v;

    print ("value is "..self.balance)

end


--声明label对象（变量）accout
accout = Accout

--还可通过 : 调用的方式隐试的传入 self 对象
accout:count(2000)

class = require("myClass")


--函数写在 table的括号外

class:showName()


--函数写在 table的括号内

class.show(class)

--[[lua不是一个面向对象的语言。可是他又有面向对象的思想
lua中的面向对象是伪面向对象，伪面向对象就要用到table实现。
是table模拟了一个面向对象的编程。 table事实上也能够看做是一个对象，
和其它语言对象一样有个自身的标示（self）。具有自己的生命周期。]]



--1.用table实现面向对象
Accout = {balance = 0}


functionAccout.count( v )

    print ("value is "..v)

end


--声明label对象（变量）  accout
accout = Accout

--通过对象调用方法
accout.count(1000)





--2.通过 self 得到当前 lable 对象
Accout = {balance = 10}


--显示 传入 self
functionAccout.count( self,  v )

    self.balance = self.balance + v;

    print ("value is "..self.balance)

end


--声明label对象（变量）  accout
accout = Accout

--通过对象调用方法, 显示的把 accout 这个 table 这个对象传入到函数 (显示的传入 self)

accout.count(accout, 1000)


--还可通过 : 调用的方式 隐试的传入 self 对象
accout:count(2000)




--3.通过 : 符号，实现声明函数时的  隐试參数 self
Accout = { balance = 10}


--通过 : 符号, 隐试 传入 self
functionAccout:count( v )

    self.balance = self.balance + v;

    print ("value is "..self.balance)

end


--声明label对象（变量）  accout
accout = Accout

--还可通过 : 调用的方式 隐试的传入 self 对象
accout:count(2000)




--4.通过require 返回对象， 调用该对象方法

class = require("myClass")


--函数写在 table的括号 外

class:showName()


--函数写在 table的括号 内

class.show(class)


2、元方法与元表

元方法：就是两个 类型 变量之间进行操作的 函数

	比如，1.数字的相加。它可能不过一个函数：1 + 1--->add(1,1)--->add函数就是用来计算两个数字间相加的结果de
		   2.table类型相加？--->Lua中不存在两个{} + {}的元方法。

元表(metatable)：就是用来存放 元方法 的 table,是table提前定义的一系列操作。把两个table相加，那么Lua就会先去检查两个table是否有metatable，然后再检		 查metatable中是否有__add方法。

假设有依照__add方法中的操作来运行，否则，报错。



	比如，假设非要将两个table类型相加的话，直接执行必报错。

但Lua同意改动元表，例如以下所看到的：

一个元表，事实上就是一个table值，所以，我们仅仅须要新建一个table，加入元方法就可以。
比方加法运算的元方法就是：__add，这是Lua规定的。
仅仅要某个值的元表里含有__add这个元方法。那就能够使用+号进行运算。
 
例如以下代码：

    -- 创建一个元表
    local mt = {};
    mt.__add = function(t1, t2)
        print("两个table相加的结果就是...Good Good Study,Day Day Up!");
    end

    local t1 = {};
    local t2 = {};
   
    -- 给两个table设置新的元表
    setmetatable(t1, mt);
    setmetatable(t2, mt);
   
    -- 进行加法操作
    local result = t1 + t2;



首先创建了一个table变量mt，给这个table新增一个元素__add。这个table就拥有了作为元表的资格了。

然后创建两个新的table变量。使用setmetatable函数给table设置新的元表。此时，两个table变量就以mt作为元表了。

最后，对t1和t2进行加法操作。这时就会从元表中查找__add元方法。假设找到的话，就调用这个元方法对两个变量进行加法操作。



Lua中的每个值都有或者能够有一个元表，但table和userdata能够拥有独立的元表，其它类型的值就仅仅能共享其类型所属的元素。比方字符串使用的是
string的元表。注意：Lua在新建table时，不会创建metatable，须要使用setmetatable来设置元表。setmetatable的參数能够使随意table,包含要赋值的table本身。



------》查看一个变量是否有元表：

	print(getmetatable(a))     -- nil 表示没有元表


Lua中的重要的元方法：__eq等于、__lt小于、__le小于等于、__add：加法、__sub：减法、__mul：乘法、__div：除法、__unm：相反数、__mod：取模、__pow：乘幂、__index   function(table,key)、__newindex   function(table,key,value)、__tostring 被print()调用、__metatable设置后可隐藏mt


仅仅要在自己定义元表的时候，给这些元方法名赋予新的函数就能够实现自己定义操作了。
Lua訪问table元素 首先。通过__index元方法来查找是否有这个函数（假设没有。返回nil）;__index的值能够直接是一个table。也能够是函数（若是table,则以该table作为索引进行查询。若是函数。则将table和缺少的域作为參数，调用这个函数）


 样例1、
我们新建一个自己定义的元表（也就是一个table变量）。用来定义一些操作：

    -- 创建一个元表
    local mt = {};
    mt.__add = function(s1, s2)
        local result = "";
        if s1.sex == "boy" and s2.sex == "girl" then
            result = "青梅竹马";
        elseif s1.sex == "girl" and s2.sex == "girl" then
            result = "空对空";
        else
            result = "硬碰硬"
        end
       
        return result;
    end



 
事实上这和上一节的样例基本一样。仅仅是多说一次而已，使用方式例如以下：


    -- 创建两个table，能够想象成是两个类的对象
    local s1 = {
        name = "Hello",
        sex = "boy",
    };  
    local s2 = {
        name = "Good",
        sex = "girl",
    };
   
    -- 给两个table设置新的元表
    setmetatable(s1, mt);
    setmetatable(s2, mt);
   
    -- 进行加法操作
    local result = s1 + s2;
   
    print(result);





样例2、
Window = {}
Window.mt = {}
Window.prototype = {x = 0,y = 0,width = 100,height = 100}
Window.mt.__index = function(table,key)

	return Window.prototype[key]

end


function Window.new(t)
	setmetatable(t,Window.mt)
	return t
end


--測试
w = Window.new{x = 10,y = 20}
print(w.heigth)




__newindex的使用方法基本与样例2一致。差别在于__newindex的作用是用于table的更新，__index用于table的查询操作。




当对table中不存在的索引赋值时，就会调用__newindex元方法。组合使用__index和__newindex能够实现非常多功能










封装：
	有了元表（metatable）之后。Lua类的封装就会变得非常easy。仅仅要为table加入metatable，并设置__index方法。


比如：
People = {age = 18}
function People:new()

	local p = {}

	setmetatable(p,self)

	self.__index = self

	return p
end


function People:groupUp()

	self.age = self.age + 1

	print(self.age)
end


--測试
p1 = People:new()
p1:growUp()   --19
p2 = People:new()
p2:growUp()   --19


--[[执行结果能够看出：两个对象拥有的age成员是全然独立的。并且全部的有关People的方法都能够对外不可见，这样全然实现了面向对象中的类的封装--]]






继承：

	继承是面向对象中不可缺少的一部分。依旧使用上例中的People，展示Lua中实现继承的方法。

创建一个People实例Man，再在Man上重写People的同名方法：

Man = People:new()
function Man:growUp()

	self.age = self.age + 1

	print("man's growUp:"..self.age)
end


--測试
man1 = Man:new()
man1.growUp()  --man's growUp:19






多态：

	Lua不支持函数多态，而支持指针的多态，因为Lua动态类型的特性，本身就能支持。





person = People:new()
person:growUp()         --People's growUp:19
person = Man:new()
person:growUp()         --Man's growUp:19