Ruby-方法调用

=begin
 方法的调用：
 　当你在调用某一个方法的时候，Ruby会完成下面的事务：
    Step 1： 找到这个方法，我们把这个过程称作方法查找method lookup；
    Step 2： 执行这个方法，为了执行这个方法，Ruby需要一个叫做self的伪变量；

Method lookup：

 要理解Ruby的方法查找，你需要了解下面两个概念：接受者（receiver）和先祖链（ancestors chain）。

 接受者就是方法的调用者。
 方法链，每个类都有一个始祖链， 开始于它自己，结束于BasicObject

 To understand the concept of an ancestors chain？
  仅仅需要看一个类（任何一个类），他的superclass ，他的超类的超类，and so on.until BasicObject。
   你可以使用方法看下他的先祖连：Class.ancestors
=end

p Class.ancestors  #=>[Class, Module, Object, Kernel, BasicObject]

# 看清楚了？ 里面是包含module的哦~~ 为什么？module是class，实现多继承。。的功能。。

module M
  def my_method
    'M#my_method()'
  end
end
class C
  include M
end
class D < C; end
p D.new.my_method() # => "M#my_method()"
p D.ancestors # => [D, C, M, Object, Kernel, BasicObject]

# 每个ancestors都是包含Kernel的
p Kernel.private_instance_methods.grep(/^pr/) # => [:printf, :print, :proc]
# 故而 你增加一个方法在Kernel中的话，任何对象都是可以访问了。。
=begin
 现在明白了什么是接收着和先祖链，我们就可以来总结下他的过程了。
     Ruby解释器会不断地向对象所属的类、对象所属类的先祖类、对象所属的类的先祖类所包含的模块中寻找方法，
逐层向上查找，直到找到对应的方法，并执行他。
     （没有找到的话，会进入method_missing机制。否则抛出NoMethodError。）
=end

#  关于Self

# 我们来看下面的一个例子

class MyClass
  def testing_self
    @var = 10 # An instance variable of self
    my_method() # Same as self.my_method()
    self
  end
  def my_method
    @var = @var + 1
  end
end
p obj = MyClass.new # =>#<MyClass:0xe9ef68>
p obj.testing_self # => #<MyClass:0x510b44 @var=11>
# 实例变量是变化的哦。

=begin
    在Ruby中，self是一个很特殊的变量，他总是指向当前对象（current object）；
    self被认为是默认的receiver。也就是说，你如果没有明确指出receiver，那么系统将把self当做receiver；
    实例变量是在self（当前对象）中查找的。也就是说，如果我使用@var，那么Ruby就会在self所指向的对象中去寻找此实例变量。
    需要注意的是，实例变量并不是由类定义的，他们也和子类以及继承机制无关。

    因此，当我们在调用一个明确指出receiver的方法时，Ruby会按照下面的步骤执行：

    Setp 1：将self指向obj；
    Setp 2：在self所属的类中查找do_method(param)方法（方法是存放在类中，而不是实例中！）；
    Setp 3：调用方法do_method(param)；

=end
# 下面我们来看下示例：

p self # => main
p self.class # => Object

class MyClass
  p self # => MyClass
end

class Foo
  p self #=>Foo
  def bar(a = self)
    p self #=>#<Foo:0xe9b080>
  end
  # bar方法等价于：def bar(a = (p self)) end
end
p Foo.new.bar("a")
class Foo

  p self #=>Foo
  class Baz < self   # displays "Foo"
    #这2句等价于： class Baz < (p self; self)

    p self  #=>Foo::Baz
  end
end