有人能解释一下Class.superclass.class.superclass悖论吗？

Question

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

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

那么一个类的父类是module，但是module是一个类？

我怎么才能理解这一点呢？

Answer 1

是类的超类。模块是类的一个实例。

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

​

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

​

​

*除了BasicObject，它没有超类。

像这样阅读上图: Float的超类是Numeric。Numeric的超类是Object等。

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

​

​

如上图所示："Joe“是String的一个实例。1是Fixnum的实例，等等...

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

​

​

如上图所示: 0.01是Float的一个实例。字符串是Class的实例，等等...

认识到Fixnum是Class的实例，就像"Nathan“是String的实例一样。就像"John“是String的一个实例一样，Float只是Class的一个实例。每个类都只是Class的一个实例，甚至class本身也是如此！

每当您在应用程序中编写一个新类时，您只是实例化一个类为Class的新对象，就像Hash.new实例化一个新的Hash，或者"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

此外，Module只是Class的另一个实例。每当您在应用程序中编写新模块时，您只是实例化了一个新模块。

# 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

顺便说一句:模块只是方法和常量的集合。类也是方法和常量的集合，但增加了能够被实例化的功能。无法实例化模块。也就是说，m.new将无法工作。

因此，返回到顶部的图形，您的问题可以直接回答：

，所以类的父类是模块，但是模块是类？

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

从下图开始：是类的一个实例。

Answer 2

• Class extends Module.这在您的第1和第3个examples.
• Module extends Object.中进行了演示
• Object extends BasicObject
• BasicObject is the root of the class hierarchy

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

除BasicObject.superclass.class外，类将返回AnyClass.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开始：

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.