1.self的使用

2.private方法的使用

3.方法查找

4.方法执行

5.refinement

6.单件类

7.单例方法定义

1.self的使用

#1 当调用一个方法时，接收者会扮演self的角色
#2 类和模块的定义中，并且在任何方法定义之外，self的角色由这个类或模块担任
class MyClass
  puts self      #打印结果是MyClass
end
#3 当前对象显示，在类或者模块外面，当前对象是main
puts self  #这段代码返回的是main

2.private方法的使用

#权限设置中已经说明

3.方法查找

#方法查找规则：向右一步，再向上

#include和prepend的区别：在导入关系中，include在类的正上面，prepend在类的正下面
module One
end

module Two
end

class Demo
  include One
  prepend Two
end
Demo.ancestors #[Two, Demo, One, Object, Kernel, BasicObject]

#include和prepend的执行顺序是先入后出
module Printable
end

module Document
end

class Book
  include Document
  include Printable
end
Book.ancestors #[Book, Printable, Document, Object, Kernel, BasicObject]

class Book
  prepend Document
  prepend Printable
end
Book.ancestors #[Printable, Document, Book, Object, Kernel, BasicObject]

4.方法执行

#对象是一组实例变量和指向类的引用，若方法不执行，则对象中则不包括方法中的实例变量
class Demo
  def one
    @test=1
  end
end
obj = Demo.new
obj.instance_variables #[]
obj.one
obj.instance_variables #[@test]

#方法内部已经定义的方法在外部方法被调用后执行，且指向同一对象
class MyClass
  def testing_self
    my_method  #这段代码的作用和self.my_method一致
  end

  def my_method
    puts "this is my_method"
  end
end

obj = MyClass.new
obj.testing_self  #这段代码返回的是this is my_method

5.refinement

#refine中已经说明，说明了using和refine两个方法 的使用

6.单件类

1.为了补全对象模型的知识，找到单件方法的藏身之所。
2.我们称单件方法所在的类为单件类。
3.单件类是一个特殊的类，它只有一个实例，并且不能被继承（理解？）。
4.一个对象的单件类的父类是这个对象的类。
5.一个类的单件类的超类是这个类的超类的单件类。

#获得eigenclass:
obj =  Object.new
eigenclass = class << obj
  self
end
#通过class << obj的形式可以进入obj单件类的领域中
#这里的self对象就是单件类，整个返回的就是一个单件类
puts eigenclass.class #=>Class


#为了方便查找对象的eigenclass，在Object类中定义了如下的代码：
class Object
  def eigenclass
    class << self
      self
    end
  end
end

#任何类（除了BasicObject）都是继承于Object,因此此方法eigenclass能适用于所有的对象
#任何对象调用eigenclass方法，返回的都是该对象的单件类。

#对象单件方法表示形式：
obj = Object.new
class << obj
  def a_singleton_method
    puts "this is the obj singleton method"
  end
end

obj.a_singleton_method #=>this is the obj singleton method

#演示如何寻找单件类的父类：
class Object
  def eigenclass
    class << self
      self
    end
  end
end

class C
  def a_method
    puts "this is the class C method"
  end
end

class D < C
end

obj = D.new
obj.a_method

class << obj
  def a_singleton_method
    puts "this is the singleton method"
  end
end

#对象单件类的父类是该对象的类
obj.eigenclass.superclass #=>D

对象模型查找方法补充：
1.对象有eigenclass,从这个eigenclass类中开始查找方法。
2.在eigenclass类中找不到方法，那么它会沿着祖先链向上来到eigenclass的超类。

class Object
  def eigenclass
    class << self
      self
    end
  end
end

class C
  class << self
    def a_class_method
      puts "C.a_class_method"
    end
  end
end

class D < C
end

C.eigenclass  #=>#<Class:C>
D.eigenclass  #=>#<Class:D>
D.eigenclass.superclass #=>#<Class:C>
C.eigenclass.superclass  #=>#<Class:Object>

结论：类的单件类的父类是其类的父类的单件类

#D（D类的eigenclass）的超类是#C，#C的超类是#Object,于是可以在子类调用父类的类方法
D.a_class_method #=>"C.a_class_method"

7.单例方法定义

# 定义单例方法的方式
# 1
class A 
  def self.hi 
    p 'hi' 
  end
end

# 2
class A 
  class << self 
    def hello 
      p 'hello' 
    end 
  end
end

# 3
def A.hey 
  p 'hey'
end

# 4
(class << A; self; end).class_eval do 
  def you 
    p 'you' 
  end
end

# 5
A.singleton_class.class_eval do 
  def folk 
    p 'folk' 
  end
end

# 6
A.define_singleton_method(:hello) do |*args| 
  p args
end