Ruby 有人能解释Class.superclass.Class.superclass悖论吗？

这可能根本不是一个悖论，但从新手的角度来看，它确实是这样

> Class.superclass
=> Module
> Class.superclass.class
=> Class
> Class.superclass.class.superclass
=> Module

所以一个类的父类是module，但module是一个类

我如何理解这一点？

• 。这在您的第一个和第三个示例中进行了演示

在第二个示例Class.superclass.Class中，您调用的是Module.Class。模块是指一个类，模块类

AnyClass.superclass.class

将返回类，除了

BasicObject.superclass.class

类和实例之间的区别很重要。BasicObject是一个类。它是一个扩展了nil的类，这是一种说它没有超类的奇特方式。它是树的根。一切都是对象，也就是说一切都是某个类的实例

字符串示例

"Nathan" is an object.
"Nathan" is an instance of the String class.
"Nathan" is not a class.
"Nathan" has no superclass, because "Nathan" is not a class.

String is an object.
String is an instance of the Class class.
String's superclass is Object.

Object is an object.
Object is an instance of the Class class.
Object's superclass is BasicObject.

BasicObject is an object.
BasicObject is an instance of the Class class
BasicObject's superclass is nil.

nil is an object.
nil is an instance of the NilClass class
nil has no superclass, because it is not a class.

Fixnum示例

1 is an object.
1 is an instance of the Fixnum class.
1 is not a class.
1 has no superclass, because it is not a class.

Fixnum is an object.
Fixnum is an instance of the Class class.
Fixnum's superclass is Integer.

Integer is an object.
Integer is an instance of the Class class
Integer's superclass is Numeric.

Numeric is an object.
Numeric is an instance of the Class class.
Numeric's superclass is Object.

# everything below here is in the above example.
Object is an object.
Object is an instance of the Class class.
Object's superclass is BasicObject.

BasicObject is an object.
BasicObject is an instance of the Class class
BasicObject's superclass is nil.

nil is an object.
nil is an instance of the NilClass class
nil has no superclass, because it is not a class.

因此，最后：

Class is an object.
Class is an instance of the Class class. # this is probably the most important part.
Class's superclass is Module # 2nd most important part

Module is an object
Module is an instance of the Class class. # 3rd
Module's superclass is Object # 4th

# everything below here is in the above examples.
Object is an object.
Object is an instance of the Class class.
Object's superclass is BasicObject.

BasicObject is an object.
BasicObject is an instance of the Class class
BasicObject's superclass is nil.

nil is an object.
nil is an instance of the NilClass class
nil has no superclass, because it is not a class.

表格形式：

如果你想验证这一切都是真的，你可以在Ruby中运行它

"Nathan".is_a?(BasicObject) # => true    "Nathan" is an object.
"Nathan".class #=> String                "Nathan" is an instance of the String class.
"Nathan".is_a?(Class) #=> false          "Nathan" is not a class.
"Nathan".superclass # NoMethodError      "Nathan" has no superclass, because "Nathan" is not a class.

String.is_a?(BasicObject) #=> true       String is an object.
String.class #=> Class                   String is an instance of the Class class.
String.superclass #=> Object             String's superclass is Object.

Object.is_a?(BasicObject) #=> true       Object is an object.
Object.class #=> Class                   Object is an instance of the Class class.
Object.superclass #=> BasicObject        Object's superclass is BasicObject.

BasicObject.is_a?(BasicObject) #=> true  BasicObject is an object.
BasicObject.class #=> Class              BasicObject is an instance of the Class class
BasicObject.superclass #=> nil           BasicObject's superclass is nil.

nil.is_a?(BasicObject) #=> true          nil is an object.
nil.class #=> NilClass                   nil is an instance of the NilClass class
nil.superclass # NoMethodError           nil has no superclass, because it is not a class.

从课堂开始：

Class.is_a?(BasicObject) #=> true        Class is an object.
Class.class #=> Class                    Class is an instance of the Class class. # this is probably the most important part.
Class.superclass #=> Module              Class's superclass is Module # 2nd most important part

Module.is_a?(BasicObject) #=> true       Module is an object
Module.class #=> Class                   Module is an instance of the Class class. # 3rd
Module.superclass #=> Object             Module's superclass is Object # 4th

Object.is_a?(BasicObject) #=> true       Object is an object.
Object.class #=> Class                   Object is an instance of the Class class.
Object.superclass #=> BasicObject        Object's superclass is BasicObject.

BasicObject.is_a?(BasicObject) #=> true  BasicObject is an object.
BasicObject.class #=> Class              BasicObject is an instance of the Class class
BasicObject.superclass #=> nil           BasicObject's superclass is nil.

nil.is_a?(BasicObject) #=> true          nil is an object.
nil.class #=> NilClass                   nil is an instance of the NilClass class
nil.superclass # NoMethodError           nil has no superclass, because it is not a class.

---

TL；DR:Module是类的超类。模块是类的一个实例。

---

让我试着更清楚地解释一下。请原谅我的手写图纸-我没有任何花哨的绘图软件

Ruby中的每个类都有一个超类*

*除了BasicObject，它没有超类

阅读上图：Float的超类是数值型的。Numeric的超类是Object等

当您实例化一个对象时，该对象将是某个类的实例。例如，“Nathan”是String类的一个实例。“乔”或“约翰”也是如此。1是Fixnum类的实例，2、3、4等也是如此

阅读上图：“Joe”是String的一个实例。1是Fixnum的实例，等等

在Ruby中，和大多数其他语言不同，类只是另一个类，它也可以被实例化，就像Fixnum或String一样

像这样阅读上图：0.01是Float的一个实例。字符串是类的实例，等等

认识到Fixnum是类的一个实例，就像“Nathan”是String的一个实例一样。就像“John”是String的一个实例一样，Float只是类的一个实例。每个类都只是类的一个实例，甚至是类本身

无论何时在应用程序中编写新类，都只是实例化一个类为class的新对象，就像Hash.new实例化一个新哈希，或者“Nathan”实例化一个新字符串一样

# By running this, you will be instantiating a new Class, and 
# it will be named Post 
class Post < ActiveRecord::Base
end

# Here is another perfectly valid way to write the above code:
Post = Class.new(ActiveRecord::Base)

# you can even instantiate a Class without giving it an explicit name:
x = Class.new(ActiveRecord::Base)

# and since your new things are classes, they can be instantiated
obj1 = Post.new
obj2 = x.new

旁白：模块只是方法和常量的集合。类也是方法和常量的集合，但具有可以实例化的附加功能。无法实例化模块。也就是说，

m.new

将不起作用

因此，回到上图，您的问题可以直接得到回答：

所以一个类的父类是module，但module是一个类

您可以从上图中看到：模块是类的超类

---

从下图看：模块是类的一个实例。

可能是类的副本。另请参见。这些都是很好的参考资料。谢谢你指出来安德鲁。谢谢你指出来！也许让我困惑的是，每个人都说一切都是对象，但当我执行BasicObject.class时，它返回class。所以我对如何理解“类”感到困惑。如果BasicObject的类是类，那么不是所有的东西都是类，而不是对象吗？哈哈，这开始让人感觉像哲学101，亚里士多德的无动于衷的搬运工等等。所以，如果一切都是对象（类的实例），那么BasicObject呢？BasicObject.class=>class。Class.Class=>Class。然而，当您向上到达nil时，会得到nil.class=>NilClass和NilClass.class=>class。所以，如果一切都是一个对象（类的实例），那么一切实例化的初始类是什么？它是如何产生的？所以除了

nil

和您自己的自定义对象之外，一切都是类的实例——包括类。还有一个叫做Module的类，它的超类是Object。模块是类的超类。这意味着该对象是类的超级复制器类。听起来是这样吗？如果是的话，那么剩下的唯一一件事就是思考对象如何成为类的实例，而类（通过模块）是对象的子对象？顺便说一句，非常感谢您的帮助和解释。我的大脑总是觉得递归、反转和诸如此类的东西有点笨拙。我想这对一些人来说比较容易，但想象一下，每个人都觉得用这些术语来思考有点奇怪。无论如何，再次感谢。所有的类都是对象，但不是所有的对象都是类。没问题。我希望这对你有帮助。也许有人能过来，把事情说得比我清楚。哇，很有帮助。我把选择的答案换成了这一个，尽管你提供的两个答案都对我有帮助。这个话题值得全面讨论，它有很多相切之处——不幸的是，堆栈溢出并没有为这类事情提供一个很好的论坛。但最终，我从中得到的好处是，在对象和类之间存在一些循环逻辑。从外行的角度来看（我已经编程了5个月了），我的看法是，既然Ruby是用C实现的，那么它也是用C实例化的。在这个实例化过程中，循环逻辑被声明。我希望我在这方面是正确的。@@Nathan您可以从上图中看到：Module是类的超类。从下图中可以看到：Module是类的实例。这是一个循环的过程。当我在Ruby中通过键入class Foo创建一个类，然后在下一行执行Foo.s时结束时，我想这一点很重要

# this will instantiate a new Module, and assign it to Foo
module Foo
end

# Here is another perfectly valid way to write the above code:
Foo = Module.new

# you can even instantiate a Module without giving it an explicit name.
m = Module.new