;----------------------------------
; AHK的对象和类学习心得 By FeiYue
;----------------------------------
一、简单对象的使用（细节看帮助）
AHK-V1：
简单数组 arr:=[111, 222]
关联数组 arr:={x:111, y:222, id:“abc”}
这两种可以用 arr[1] 或 arr.x 中括号或点来混合读写
AHK-V2:
简单数组 arr:=[111, 222]
关联数组 arr:=Map(“x”,111, “y”,222, “id”,“abc”)
原始对象 arr:={x:111, y:222, id:“abc”}
前两种应该用 arr[1]、arr[“x”] 中括号来读写
第三种应该用 arr.x 点来读写，不能混用
二、类的使用（复杂对象，包含数据和方法，还可生成新的实例）
AHK的继承类似Lua和JS，是基于原型的，原型是一个普通的父对象。
原型继承的原理很简单，就是找不到就找原型对象，再找不到就再找原型对象。
Lua的继承原理：
- 继承链：
——>子表中找不到属性或方法
——>设置元表：setmetatable(子表, 元表对象={__index=父表})，
元表对象是过渡对象，可以使用下面的技巧省去过渡对象，
父表.__index=父表, setmetatable(子表, 父表)
——>在元表对象的__index属性指向的父表中找，如果找不到
——>设置元表：setmetatable(父表, 元表对象={__index=祖父表})
如果把父表看做类，那么继承的是类的本身对象。
AHK-V1的继承原理（类似Lua）：
继承链：
——>子对象中找不到属性或方法
——>设置基对象：（一般通过new自动设置）子对象.base:=父对象
——>再在父对象中找，先考虑其中的元函数__Get没有明确return，如果找不到
——>设置基对象：父对象.base:=祖父对象
如果把父对象看做类，那么继承的是类的本身对象。new的处理：子对象:=new 父对象() （这里的父对象一般为类）
——>父对象的非静态属性赋值给子对象，并运行__new()方法初始化子对象
——>设置基对象：子对象.base:=父对象
父对象的静态属性可以被父对象本身使用，非静态属性不能。extends的处理：class 子类 extends 父类
——>子类.base:=父类
JS的继承原理：
继承链：
——>子对象中找不到属性或方法
——>设置原型：（一般通过new自动设置）子对象.proto=父对象.prototype
——>在父对象.prototype属性对应的对象中找，如果找不到
——>设置原型：父对象.prototype.proto=祖父对象.prototype
如果把父对象看做构造函数，那么继承的是构造函数的prototype属性对应的对象。new的处理：子对象=new 父对象() （这里的父对象一般为构造函数）
——>父对象的属性和方法初始化到 父对象.prototype属性对应的对象中
，并运行constructor()方法初始化子对象
——>设置原型：子对象.proto=父对象.prototypeextends的处理：class 子对象 extends 父对象
——>设置原型：子对象.Prototype.proto=父对象.Prototype
AHK-V2的继承原理（类似JS）：
继承链：
——>子对象中找不到属性或方法
——>设置基对象：（一般通过new自动设置）子对象.base:=父对象.Prototype
——>再在父对象.Prototype属性对应的对象中找，
先考虑其中的元函数__Get没有明确return，如果找不到
——>设置基对象：父对象.Prototype.base:=祖父对象.Prototype
如果把父对象看做类，那么继承的是类的Prototype属性对应的对象。new的处理：子对象:=父对象() （这里的父对象一般为类）
——>父对象的非静态属性和非静态方法初始化到 父对象.Prototype属性
对应的对象中，并运行__new()方法初始化子对象
——>设置基对象：子对象.base:=父对象.Prototype
父对象的静态属性和静态方法、嵌套类不被子对象继承，由父对象本身使用。extends的处理：class 子类 extends 父类
——>设置基对象：子类.base:=父类（用于子类操作父类的静态属性和静态方法）
——>设置基对象：子类.Prototype.base:=父类.Prototype（用于实例对象继承）
