ruby面向对象初步理解
类与对象无疑是ruby的核心，可能最开始看上去有一点困惑，似乎有太多的概念：类、对象、类对象、模块、实例方法、类方法、单例类.... 太多太多，许多从事ruby开发的工程师们，大多都有其他编程语言的开发经验，也会借助其他语言（比如java）的面向对象理念来理解ruby，大多数情况下，能认识到的也只是千篇一律的 class、new、initialize等等，很经典的Ruby元编程一书中，也有不少朋友觉得面向对象这部分的概念比较绕脑，我决定记录并分析一下
ruby虚拟机启动之初，提供了哪些类, 模块或者说对象
# 我们随意创建一个类
class Aoo
def hello
puts 'hello world'
end
end
# 打印祖先链
puts Aoo.ancestors
>> [Aoo, Object, Kernel, BasicObject]
# 打印Aoo单件的祖先链
puts Aoo.singleton_class.ancestors
>> [#<Class:Aoo>, #<Class:Object>, #<Class:BasicObject>, Class, Module, Object, Kernel, BasicObject]
# 打印祖先链中各个对象的类型
puts Class.class
>> Class
puts Module.class
>> Class
puts Object.class
>> Class
puts Kernel.class
>> Module
puts BasicObject.class
>> Class
puts Aoo.class
>> Class
结论：
- Class, Module, Object, Kernel, BasicObject 这几个对象早已被ruby虚拟机提供，并且ruby中所有对象都直接或者间接继承了他们，众所周知，模块是需要通过include引入的，并非显示继承，不过从模块被插入祖先链来看，也是一种变相的继承，并且模块的此种特性，可以满足多继承需要
疑问：
- 为何Module.class得到的结果是Class，而Kernel.class得到的结果是Module
- Aoo的祖先链和Aoo单件的祖先链为何差距这么大
- 我们所谓的类，比如Aoo, Object, BasicObject，或者我们所谓的模块，比如Module, Kernel，它们的类型要么是Class，要么是Moudle，是不是意味着这些类都是对象？
- 祖先链中，Class和Module居然在Object的下方，是不是意味着它们继承了Object?
探究原生类或者对象的继承关系
在面向对象的理论中，核心即一切皆对象，ruby对此作出了很好的诠释，在ruby中，不管是+ - * / 还是一个我们所说的类，都是一个对象
虽然从祖先链来看，顶层是BasicObject，但实际上Class、Module才是ruby最初始的核心
我们刚才用.class方法获取对象的类型，在ruby中，只有类型是Class的才可以被继承，模块只能混入，不可以继承，ruby里模块的.class都为Module，但是Module本身是一个Class，这是ruby自身的设定
我们把类型为Class的对象，叫做类对象，也就是.class是Class的对象，更多时候，我们直接称作类，由于Class的类型也是Class，所以Class是一个可以创建类对象的类对象
我们查看Class中的自有方法
# 查询方法时带上false参数 表示只查询自有方法，而不查询继承得来的方法
puts Class.methods false
>> [] # 结论 -- Class类并没有定义自己的类方法
puts Class.instance_methods false
>> [:allocate, :new, :superclass] # 结论 -- Class仅有3个公有实例方法，其中有创建对象必备的new方法
puts Class.private_methods false
>> [:inherited, :initialize]
puts Class.private_instance_methods false
>> [:inherited, :initialize]
# 结论 -- Class的私有方法中，类方法和实例方法相同，是用于对象初始化的initialize
结论：
- Class中定义的方法很少，但是包含了面向对象的特性
- 我们知道，Object/BasicObject的类方法中，已具备new方法（不知道的朋友可以自己打印出来看
- new方法定义在Class中，只能从Class获取，恰好Class中的new方法是实例方法（类的实例方法会作为对象的类方法）
- 并且BasicObject/Object的class属性指明了类型是Class
-
证明：Object/BasicObject..等等带有new方法的类都是Class的对象，所以类也是对象的一种 -
注意：Class的私有方法中，不论类方法还是实例方法都带有构造方法initialize，证明Class本身也是有实例化过程的(由虚拟机实例化)，Class本身也是一个对象，正因为如此，Class可以调用实例方法的new去创建Object - Class非常特殊，它的类型就是自身，即Class.class === Class，这是ruby自身设定，用于形成类型引用的闭环（下面讨论）
以上根据Class的内部方法定义，以及所有类都具有new方法，证明了所有类都是Class的对象，并且Class本身也是对象
我们再看看Module
puts Module.methods false
>> [:nesting, :constants]
puts Module.instance_methods false
>> [:freeze, :===, :==, :<=>, :<, :<=, :>, :>=, :to_s, :inspect, :included_modules, :include?, :name, :ancestors, :instance_methods, :public_instance_methods, :protected_instance_methods, :private_instance_methods, :constants, :const_get, :const_set, :const_defined?, :const_missing, :class_variables, :remove_class_variable, :class_variable_get, :class_variable_set, :class_variable_defined?, :public_constant, :private_constant, :singleton_class?, :include, :prepend, :module_exec, :class_exec, :module_eval, :class_eval, :method_defined?, :public_method_defined?, :private_method_defined?, :protected_method_defined?, :public_class_method, :private_class_method, :autoload, :autoload?, :instance_method, :public_instance_method]
puts Module.private_methods false
>> [:inherited, :initialize]
puts Module.private_instance_methods false
>> [:included, :extended, :prepended, :method_added, :method_removed, :method_undefined, :initialize_copy, :attr, :attr_reader, :attr_writer, :attr_accessor, :initialize, :initialize_clone, :remove_const, :append_features, :extend_object, :prepend_features, :refine, :using, :remove_method, :undef_method, :alias_method, :public, :protected, :private, :module_function, :define_method]
结论：
- Module中，私有类方法带有构造方法initialize，证明Module本身也是有实例化过程的(由虚拟机实例化)，Module本身也是一个对象
- Module中定义了大量在面向对象中常用操作，可以看做是面向对象的主要实现
- 我们知道，Class虽然自己只有几个方法，但是继承而来的方法却很多，如果你打印出来看的话，和Module中提供的方法基本一致，所以：Class继承了Module
以上总结，Class和Module都是由虚拟机实例化的对象，既是对象也是类，他们是虚拟机初始阶段提供的核心
在虚拟机已提供Class和Module的前提下，就可以开始正常的对象创建和继承了，ruby以此为基础，又创建了Kernel模块，BasicObject, Object
- Kernel -- 定义了大量常用工具方法比如输入输出之类的，通过Module.new创建
- BasicObject -- 基本是个空的类，可以作为洁净室，通过Class.new创建
- Object -- 该类作为我们自定义类的基类，暴露给我们使用， 通过Class.new创建
疑问：
- Module哪来new方法，虽然它和Class一样，有虚拟机帮助实例化，既是类也是对象，但是Module不管类方法还是实例方法都没有new，它得从Class中继承到new方法才行，然而刚才已经证明Class继承了Module
Ruby核心对象的继承方式，其实是一个环
Module要想获取new，没法继承Class，因为Class已经继承了Module，由于他们的.class都是Class，所以可以继承Class的实例化对象Object(也可以叫做类对象)，所以Class Module Object构成了环状继承关系，Module和Class中的实例方法，在Object中以类方法的形式存在（因为Object是Class对象），当Module继承Object之后，获取了Object的类方法，换而言之，此种方式，让自己的实例方法转变为了类方法，这3个对象间形成了方法的大范围共享，以此为基础，才有了ruby各种面向对象机制
ruby的单件
我们回到之前提到的单件类的祖先链问题，对比下两种情况下的祖先链
# 打印Aoo单件的祖先链
puts Aoo.singleton_class.ancestors
>> [#<Class:Aoo>, #<Class:Object>, #<Class:BasicObject>, Class, Module, Object, Kernel, BasicObject]
# 为何Aoo的单件祖先链不是如下 ？？？？？
[#<Class:#Aoo>, Class, Module, Object, Kernel, BasicObject]
# 打印Aoo实例化对象的祖先链
puts Aoo.new.singleton_class.ancestors
>> [#<Class:#<Aoo:0x007fdac100dba8>>, Aoo, Object, Kernel, BasicObject]
# 如果我们定义一个类去继承Aoo
class Boo < Aoo
end
puts Boo.new.singleton_class.ancestors
>> [#<Class:#<Boo:0x007fdabf8d48d8>>, Boo, Aoo, Object, Kernel, BasicObject]
总结：
- 如果你平时仔细观察，会发现，Class的直接对象（类对象）和普通类的对象，他们单间类的祖先链会出现这两种情况
- 我们知道，ruby的单件是无限的，除了单件，还有单件的单件 ......，可以无限递归下去，所以单件类在被我们使用前，是不会自己实例化的，只有当我们访问单件的时候，才会实例化单件，并且这个单件也是当前对象.class所指明类型的实例
当你访问对象单件的时候，绝对不仅仅只是根据类型再创建一个实例，比如我们访问Aoo的单件，不仅生成了Class:Aoo，还有Class:Object，Class:BasicObject
- 主要区别还是在于对象的.class是否是Class，也就是看它是否是一个类对象，如果当前对象是一个类对象，证明它的单件也一定是一个Class的实例，既然都是类对象，就会有相同的继承关系，所以Aoo单件的祖先链，会先列出[#<Class:Aoo>, #<Class:Object>, #<Class:BasicObject>]
- 普通对象的的.class并非Class，对象自身并没有所谓的继承关系，所以普通对象的单件不涉及祖先链，直接就追溯到了类对象本身
最后
- Class和Module是由虚拟机提供的特殊类，之后的一切类都由Class创建
- 被new创建出来的，可以是对象，也可以是类对象（类），对象的.class属性为Class的都是类对象，Class不仅可以创建类对象，自身也是一个类对象
- Class中定义了创建对象的基本方法，比如new
- Module中定义了大量类操作相关方法
- Class、Module、Object、Kernel、BasicObjec这一层的初始化操作对用户透明，将Object作为自定义类的基类
- 类对象（类）的实例方法会作为对象的类方法
- Class、Module、Object的继承关系，让他们的类方法与实例方法相同，BasicObject只是没有混入Kernel，作为一个类对象，Class和Module中的方法是必不可少的，并不是所谓的内部几乎没有方法
- 单件是访问的时候产生，并且根据继承关系不同，产生的单件个数不同，会为单件生成一个完备的祖先链
ruby的元编程和面向对象的思维确实很绕，自己琢磨的过程中也只是略有收获而已！
