Ruby 中 Base 类和 Derived 类的元类之间有什么关系？

Question

在Ruby中，我们可以在单例方法中使用super来调用相应超类的单例方法，如下面的代码所示。

class Base
  def self.class_method
    puts "Base class method"
  end
end

class Derived < Base
  def self.class_method
    puts "Derived class method"
    super
  end
end

Derived.class_method
# Derived class method
# Base class method

但是，我似乎不太明白 Derived.class_method 中对 super 的调用如何到达 Base.class_method。我假设 class_method 是在他们的元类上定义的，这是否意味着他们的元类具有父/子关系？ （我无法通过实验完全证实这一点）

更新：我问这个问题是因为我记得在某个地方看到基类和派生类的元类之间存在某种关系（但我再也找不到了）。除了了解 super 实际上是如何工作的之外，我还想确认这两个元类是否完全独立。

Answer 1

这里有四个类对象在起作用：

<Class>---class---><Class>
Base               #Base
   ^                  ^
   |                  |
   |                  |
 super              super
   |                  |
   |                  |
<Class>            <Class>
Derived---class--->#Derived

命名法：

• <...>是每个对象的类。
• 类的名称位于第二行。
• 如果名称以 # 开头，则它是特征类（又名单例类）。
• super 指向类的超类
• class 指向该类的类。

当您调用 Derived.class_method 时，Ruby 遵循“右一后向上”规则：首先转到对象的类，然后沿着超类链向上，找到方法时停止：

• “class_method”调用的接收者是 Derived 。因此，沿着链一直到 Derived 的类对象，这是它的特征类 (#Derived)。

• Derived 没有定义该方法，因此 Ruby 沿着链向上到达 #Derived 的超类，即 #Base。

• 在那里找到了该方法，因此 Ruby 将消息分派到 #Base.class_method

您认为我不可能立即知道所有这些内容，是吗？这就是我的大脑获得所有这些元juju的地方：元编程Ruby。

第 2 部分。 如何使“特征类”（又名“单例类”）不再隐藏。

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

此方法将返回任何对象的特征类。现在，课程怎么样？这些也是物体。

p Derived.eigenclass               # => #<Class:Derived>
p Derived.eigenclass.superclass    # => #<Class:Base>
p Base.eigenclass                  # => #<Class:Base>

注：以上来自Ruby1.9。当在 Ruby 1.8 下运行时，你会得到一个惊喜：

p Derived.eigenclass.superclass    # => #<Class:Class>

Answer 2

为了澄清和纠正我在评论中写的有关 Ruby 隐藏/公开特征类的方式的内容，情况如下：

Ruby 1.8:

(1) Object#class 方法始终返回第一个实数（非特征类）或 iclass）对象的实际类的超类。
换句话说

o = Object.new
class << o; end
o.class #=> returns Object, even though the _actual_ class is the eigenclass of o

，Object#class 方法永远不会返回特征类，它会传递它们
而是返回它在继承层次结构中找到的第一个“真实”类。

(2)Class#superclass方法有两种情况。如果接收者不是特征类，那么它只是返回超类。但是，如果接收者是一个特征类，则此方法返回接收者的实际（即不一定是真实的）类。

# case where receiver is a normal class (i.e not an eigenclass)
Module.superclass #=> Object (behaves as expected)

# case where receiver is an eigenclass
class << Module; superclass; end #=> returns Class, this is NOT the superclass

从上面来看，Class#superclass 在普通类的情况下表现得与预期相同，但对于 eigenclass 示例，它声明 Module eigenclass 的超类是 Class，但事实并非如此。从该图中http://banisterfiend.wordpress。 com/2008/10/25/the-secret-life-of-singletons/我们知道Module的特征类的超类实际上是Object的特征类。我不确定为什么 Ruby 1.8 有这种奇怪的行为。

Ruby 1.9：

(1) Object#class 方法的行为与 1.8 版本相同。

(2) Class#superclass 方法不再有两种情况，它现在像对待普通类一样对待特征类，并按预期返回实际的超类。

例如

class << Module; superclass; end #=> #<Class:Object>

Answer 3

下图解释了这种关系： http://banisterfiend .wordpress.com/2008/11/25/a-complete-ruby-class-diagram/

另外，这里还有一些其他帖子更多地解释了特征类的复杂性：
http://www.klankboomklang.com/2007/10/05/the -metaclass/

http://www.klankboomklang。 com/2007/09/21/the-singleton-class/

这是一个相当困难的例子，它解释的内容比您可能想知道的更多：
http://banisterfiend.wordpress.com/2008 /10/25/单身人士的秘密生活/