ruby之对象体系

标题叫“对象”呢？不是还有类、Module等这些呢，为什么不介绍呢？不急，听我慢慢道来。

对象里有什么？

我们讲讲普通对象，也就是通过类new出来的对象有什么？

先举个例子：

class TestClass
    def test_method
      @v
    end
end
obj = TestClass.new  #<TestClass:0x0000000136ca08>
obj.class #TestClass

obj里有什么呢？

实例变量

obj.instance_variables #[]
obj.test_method #nil
obj.instance_variables #[:@v]

通过instance_variables可以得到对象的所有实例方法，这里提一下，为什么第一次调用的时候没有@v这个实例变量呢？这也是ruby很灵活的一个地方，那就是任何一个方法或者一个实例变量，甚至是类变量都可以在运行中生成，以我们的例子来说，如果不调用test_method方法的话，@v变量永远不存存在obj对象里。

方法

那么方法test_method是存在于类里，还是对象里呢？

我们看看：

2.1.1 :018 > obj.methods
 => [:test_method, :nil?, :===, :=~, :!~, :eql?, :hash, :<=>, :class, :singleton_class, :clone, :dup, :taint, :tainted?, :untaint, :untrust, :untrusted?, :trust, :freeze, :frozen?, :to_s, :inspect, :methods, :singleton_methods, :protected_methods, :private_methods, :public_methods, :instance_variables, :instance_variable_get, :instance_variable_set, :instance_variable_defined?, :remove_instance_variable, :instance_of?, :kind_of?, :is_a?, :tap, :send, :public_send, :respond_to?, :extend, :display, :method, :public_method, :singleton_method, :define_singleton_method, :object_id, :to_enum, :enum_for, :==, :equal?, :!, :!=, :instance_eval, :instance_exec, :__send__, :__id__]

2.1.1 :019 > TestClass.methods
 => [:allocate, :new, :superclass, :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, :nil?, :=~, :!~, :eql?, :hash, :class, :singleton_class, :clone, :dup, :taint, :tainted?, :untaint, :untrust, :untrusted?, :trust, :frozen?, :methods, :singleton_methods, :protected_methods, :private_methods, :public_methods, :instance_variables, :instance_variable_get, :instance_variable_set, :instance_variable_defined?, :remove_instance_variable, :instance_of?, :kind_of?, :is_a?, :tap, :send, :public_send, :respond_to?, :extend, :display, :method, :public_method, :singleton_method, :define_singleton_method, :object_id, :to_enum, :enum_for, :equal?, :!, :!=, :instance_eval, :instance_exec, :__send__, :__id__]

2.1.1 :020 > TestClass.instance_methods
 => [:test_method, :nil?, :===, :=~, :!~, :eql?, :hash, :<=>, :class, :singleton_class, :clone, :dup, :taint, :tainted?, :untaint, :untrust, :untrusted?, :trust, :freeze, :frozen?, :to_s, :inspect, :methods, :singleton_methods, :protected_methods, :private_methods, :public_methods, :instance_variables, :instance_variable_get, :instance_variable_set, :instance_variable_defined?, :remove_instance_variable, :instance_of?, :kind_of?, :is_a?, :tap, :send, :public_send, :respond_to?, :extend, :display, :method, :public_method, :singleton_method, :define_singleton_method, :object_id, :to_enum, :enum_for, :==, :equal?, :!, :!=, :instance_eval, :instance_exec, :__send__, :__id__] 

从上面的结果可以看出，obj的方法也是TestClass的实例方法，可以说obj有一个test_mothod方法，但是不能说TestClass有test_method方法，这样就可以说test_method方法就是属于obj吗，NONO，它还是属于TestClass，因为obj除了有自身的实例变量之外，还有一个本身类的引用，就是说它的方法实际上找到类中定义的实例方法才能调用的，本身是不存在这些方法的。

到这，我们可以简单的花一个图：

 到这里，我们总结一下，一个对象的实例变量存在于对象本身，但是一个对象的方法却存在于对象对应的类里，这就是同一个类的对象共享相同的方法，但是不会共享实例变量，我们再用一个例子描述一下，我们先创建一个类，并且对这个类实例化一个对象，然后在打开这个类，新增一个方法并且在这个方法里生成一个实例变量，最后再用这个类实例化一个对象，看看前后实例化的对象有什么差别。

如图，obj1在未打开类之前是没有test_methods这个方法的，打开类，重新给类定义一个方法，即使打开类是在obj1实例化之后，obj1也是会有test_method这个方法的，我们以此证明了上面的结论。

什么是类

在ruby里，我们要永远记住一句：类也是对象。我们知道，在ruby进程里，每一个对象都有一个对象id，可以通过obj.object_id拿到，一个类也是有object_id的：

1.9.3-p551 :007 > String.object_id
 => 10636640

那么类是个对象，那么类的类是什么呢？

1.9.3-p551 :008 > String.class
 => Class 
1.9.3-p551 :009 > Class.class
 => Class

类的类是Class，Class的类也是Class。

既然说，普通类的类的类是Class，而Class也是一个类，抱歉，有点绕，那么能不能通过Class去创建一个新的类的，答案是能：

DemoClass = Class.new do
  def put_class_name
    puts self.class
  end
end

irb(main):006:0> d = DemoClass.new
=> #<DemoClass:0x007f490dba4ae8>
irb(main):007:0> d.put_class_name
DemoClass

很神奇吧。

什么是Module

Module是Class的父类，Class和Module的差别是Class是一个增强的Module，它比Module多了一个new，allocate方法，除了这一个区别，当然这个区别特别重要，Class和Module基本是一样的。在用途上，Class可以include一个Module之后拥有module里定义的方法。

注意：这里只能拥有Module里的实例方法，类方法是无法使用的：

module DemoModule
  class << self
    def getClassName
      self.to_s
    end                        
  end
 
  def initialize(*args)
    @initialized = true
  end
  
  def initialized?
    @initialized || false
  end
end

class DemoClass
  include DemoModule
end

puts DemoModule.getClassName #DemoModule
puts DemoClass.new.initialized? #true
puts DemoClass.getClassName # undefined method `getClassName' for DemoClass:Class (NoMethodError)

那么Class的父类是Module，那么Module的父类是什么呢？我们看看：

1.9.3-p551 :009 > 'aa'.class
 => String 
1.9.3-p551 :010 > String.class
 => Class 
1.9.3-p551 :011 > String.superclass
 => Object 
1.9.3-p551 :012 > Module.class
 => Class 
1.9.3-p551 :013 > Module.superclass
 => Object 
1.9.3-p551 :014 > Object.class
 => Class 
1.9.3-p551 :015 > Object.superclass
 => BasicObject 
1.9.3-p551 :016 > BasicObject.class
 => Class 
1.9.3-p551 :017 > BasicObject.superclass
 => nil 

我们从实例对象到Class再到Module一直往上走，最终会走到BasicObject，实际上BasicObject就是Ruby对象体系里的跟节点。

说到这，我们简单的介绍一下Class和Module的区别。

我们情不自禁的要问，为什么类和模块之间那么相似，还要存在不同的两个概念呢，不是多此一举吗？不是这样的，同时存在模块和类的主要原因是为了让代码更加清晰。

我总结了一下，主要原因有三点：

1. 如果有一个模块是公用的，定义出来本身是为了在别处用，而本身并没有什么业务上的作用，一般是让别的地方include或者是为了当初命名空间使用，那么这个时候就要作为模块。

2. 当希望它被实例化或者为了继承扩展时，就应该使用类。

所以使用的时候应该根据自己目的和使用方式来选择使用。

对象体系关系图

到此，我们可以画出Ruby对象体系里的关系图：

到这我们可以对ruby中的对象做个总结：

什么是对象？ruby中的对象是无非就是一组实例变量外加一个指向它的类的一个引用，通过这个引用可以拿到实例方法，因为对象的方法不是存在于对象其本身，而是存在于对象所属于的类里。

什么是类？类就是一个对象外加一组实例方法和一个对其超类的引用。Class是Module的子类，所以一个Class就是一个Module。只是比模块多了一些方法。和普通的对象一样，类必须通过引用进行访问，这个引用就是类名。