您可以在此图表中看到问题：

（来源：phrogz.net）
所有对象示例都继承自Object。所有类都是对象，而Class是类，因此Class是对象。然而，对象示例继承自它们的类，而Object是Class类的示例，因此Object本身从Class获取方法。
但是，正如您在图中所看到的，并不存在循环查找循环，因为每个类都有两个不同的继承“部分”：示例方法和“类”方法。最后，查找路径是健全的。

• 注意：此图反映了Ruby 1.8，因此不包括Ruby 1.9中引入的核心BasicObject类。*

实际上，您需要理解的是 Object 是所有类的母亲。所有类都扩展 Object。您将在编程、理解继承等过程中使用这种关系。
你可以在任何时候对任何对象的任何示例调用hash（）？为什么？因为那个函数出现在 Object 类中，并且所有的类都继承了那个函数，因为所有的类都扩展了 Object。
至于 Class 的概念，出现的频率要低得多。一个 Class 类的对象就像一个蓝图，它就像你手中有一个类，而不是创建它的示例。它还有一点，但如果没有一个冗长的例子，它是很难描述的。请放心，当（如果有的话）使用它的时候，你会看到它的用途。
这段摘录说的是 Object 有一个类型为 Class 的类，而 Class 是一个对象，所以必须扩展 Object。这是循环的，但这是无关紧要的。答案埋在编译器的某个地方。

关于 * which-comed-first* 标准，有两种Ruby对象：

*内置对象。它们存在于Ruby程序的开头，可以认为创建时间为零。
*用户创建的对象。它们是在程序启动后通过对象创建方法（new/clone/dup、类定义、模块定义、文本构造等）创建的。这些对象按其创建时间线性排序。此顺序恰好与类继承和示例关系相反。

有关Ruby对象模型的详细说明，请访问www.atalon.cz。

我 知道 我 的 答案 至少 晚 了 3 年 ， 但 我 最近 才 了解 到 Ruby ， 我 必须 承认 ， 文献 有时 会 给出 （ 在 我 看来 ） 误导 性 的 解释 ， 即使 一 个 人 正在 处理 一 个 非常 简单 的 问题 。 此外 ， 我 （ 而且 是 ） 惊讶 于 这样 可怕 的 短语 ：

"The best way to deal with this paradox, at least for now, is to ignore it."

中 的 每 一 个
作者 D.Black 所 述 ， 并 在 问题 中 引用 ， 但 这种 态度 似乎 是 普遍 存在 的 。 我 在 物理 学界 经历 过 这种 倾向 ， 但 我 没有 怀疑 它 也 通过 编程 传播 。 我 不是 说 没有 人 知道 背后 隐藏 着 什么 ， 但 至少 看 起来 很 有趣 ， 为什么 不 提供（ 事实 上 ） 非常 简单 和 精确 的 答案 ， 因为 在 这种 情况 下 有 一 个 ， 没有 调用 任何 晦涩 的 话 ， 如 " 悖论 " 内 的 解释 。
这种 所谓 的 " 悖论 "（ 即使 它 绝对 不是 这样 的 东西 ） 来自（ 至少 是 误导 性 的 ） 认为 " 作为 一 个 示例（ 的 子类 ） " 应该 是 某物 作为 " 的 一 个 元素 "（ 在 ， 说 ， 幼稚 的 集合 论 ） ， 或者 换 句 话说 ， 类（ 在 Ruby 中 ） 是 一 个 集合 ， 其中 包含 共享 某 个 公共 属性 的 所有 对象（ 例如 ，在 这个 幼稚 的 解释 下 ， String 类 包含 了 所有 的 字符 串 对象 ） 。（ 我 可以 称 之 为 " 成员 资格 解释 " ） 可能 有助于 理解 孤立 的（ 相当 容易 ） 类 ， 如 字符 串 或 符号 ， 它 确实 产生 了 一 个 明显 的 矛盾 与 我们 的 天真 的 理解（ 也 是 axios 化 的 ， 因为 它 与 冯 · 诺依曼 的 集合 论 的 正则 性 axios 相 矛盾 ， 如果 有人 知道 我 在 说 什么 的 话 ） ， 因为 一 个 对象 不 可能 是 它 自己 的 元素 ， 就 像 前面 关于 对象 类 的 解释 所 暗示 的 那样 。
如果 我们 用 一 个 非常 简单 的 模型 来 摆脱 这种 误导 性 的 成员 解释 ， 前面 提到 的 问题 就 很 容易 避免 了 。 我 猜想 我 下面 的 解释 是 Maven 们 所 熟知 的 ， 所以 我 声称 根本 没有 独创 性 ， 但 也许 它 没有 用 我 将要 介绍 的 （ 简单 的 ） 术语 来 重新 表述 ：从 某种 意义 上 说 ， 我 完全 惊讶 于 （ 显然 ） 没有 人 从 一 开始 就 用 这些 术语 来 说明 ， 我 的 意图 只是 强调 我 所 相信 的 基本 的 潜在 结构 。
让 我们 考虑 一 个 集合 O（ 基本 ） 对象 ， 它 由 所有（ 基本 ） 对象 ， 提供 了 从 O 到 O 的 Map f（ 这 或 多 或 少 是 . class 方法 ） ， 满足 f 的 合成 图像 与 其 自身 只有 一 个 元素 。 后 一 个 元素（ 或 对象 ） 表示 为 Class（ 实际 上 ，我 很 想 用 LaTeX 代码 来 写 这 篇 文章 ， 但是 我 不 太 确定 它 是否 会 被 解析 并 转换 成 典型 的 数学 表达式 。Map f 的 图像 （ 根据 定义 ） 是 Ruby 类 的 集合 （ 例如 String 、 Object 、 Symbol 、 Class 等 ） 。 Ruby 程序 员 （ 即使 他们 不 知道 ） 对 前面 的 结构 解释 如下 ：我们 说 一 个 对象 " x 是 y 的 一 个 示例 " 当 且 仅 当 y = f （ x ） 。 顺便 说 一下 ， 这 确切 地 告诉 我们 Class 是 Class 的 一 个 示例 （ 即 它 自己 的 示例 ） 。
现在 ， 我们 需要 对 这个 简单 的 模型 进行 更多 的 修饰 ， 以 获得 类 和 功能 的 完整 Ruby 层次 结构（ 在 Map F 的 图像 上 强加 一些 固定 成员 的 存在 、 在 Map F 的 图像 上 强加 偏序 以便 定义 子类 以 获得 随后 的 继承 等 ） ， 并且 特别 是 为了 获得 有趣 地 被 向上 投票 的 好 图片 ，但 我 想 每个 人 都 可以 从 我 给出 的 原始 模型 中 理解 这 一 点 （ 在 阅读 了 几 本 Ruby 手册 之后 ， 我 已经 写 了 几 页 来 解释 这 一 点 。 如果 有人 觉得 有用 ， 我 可以 提供 一 份 副本 ） 。

• • 哪个 先 出现 ：* 类 类 * 还是 * 类 对象 * ？ * *

每个 类 都 是 类 Class 的 一 个 示例 。 因此 ， * 类 Object * 是 * 类 Class * 的 一 个 示例 。 因此 ， 您 需要 * 类 Class * 来 创建 * 类 Object * 。 因此 ：
1.* 类 Class * * * 存在 于 * * * 类 Object * 之前 。

• 类 Class * 是 * 类 Object * 的 子类 。 因此 ， 您 需要 从 * 类 Object * 创建 * 类 Class * 。 因此 ：

1.* 类 对象 * * * 存在 于 * * * 类 Class * 之前 。
因此 ， 陈述 2 与 陈述 1 相 冲突 ， 于是 我们 就 有 了 鸡 和 蛋 的 困境 。 或者 ， 你 可以 接受 它 作为 一 个 循环 定义 !

我已经深入研究了Ruby的源代码，并创建了this post来理解它。