Ruby 面向对象原理

ruby面向对象初步理解

类与对象无疑是ruby的核心，可能最开始看上去有一点困惑，似乎有太多的概念：类、对象、类对象、模块、实例方法、类方法、单例类.... 太多太多，许多从事ruby开发的工程师们，大多都有其他编程语言的开发经验，也会借助其他语言（比如java）的面向对象理念来理解ruby，大多数情况下，能认识到的也只是千篇一律的 class、new、initialize等等，很经典的Ruby元编程一书中，也有不少朋友觉得面向对象这部分的概念比较绕脑，我决定记录并分析一下

ruby虚拟机启动之初，提供了哪些类, 模块或者说对象

# 我们随意创建一个类class Aoo
  def hello
    puts 'hello world'
  endend# 打印祖先链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] 
# 如果我们定义一个类去继承Aooclass Boo < Aooendputs 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的元编程和面向对象的思维确实很绕，自己琢磨的过程中也只是略有收获而已！

作者：感觉被掏空
链接：https://www.jianshu.com/p/960abd1bc858