Question

我刚开始玩JRuby。这是我的第一篇ruby帖子。我很难理解Ruby中的类与对象。这并不意味着喜欢什么类&；其他面向对象语言中的对象。例如

Class.is_a? Object

returns true and

Object.is_a? Object

也。

所以阶级&；对象既是对象

又来了一个

Class.is_a? Class

returns true and

Object.is_a? Class

也。

等等，我还没做完

 Object.instance_of? Class
 Class.instance_of? Class

两者都是真的

 Object.instance_of? Object
 Class.instance_of? Object

两者都是假的。对，任何事物都不可能是对象的实例。

和

 Class.kind_of? Class
 Object.kind_of? Class

两者都是真的

 Class.kind_of? Object
 Object.kind_of? Object

两者都是真的

所以两者完全相同，那么为什么我们都有呢。？

经过更多的挖掘，我编写了这个简单的方法来返回两者都支持的方法列表

irb(main):054:0> def print_methods(obj)
irb(main):055:1>    obj.methods.each do |mm|
irb(main):056:2*        puts mm
irb(main):057:2>    end
irb(main):058:1> end

print_methods（Object）和print_method（Class）之间的方法差异仅为

     Nesting

如果嵌套意味着继承，那么Object是否类似于密封类？？

有人能告诉我这是怎么回事吗？

更新：致Edds评论

有趣的是，我在中的方法列表中看到了很多差异

c=Class.new
print_methods(c)

&；

o=Object.new
print_methods(o)

Now I understand Instance of a class is really an class instance (和this class instance is actually a Object) not an object instance. 和even this instance allow me to span another instances

  xx = c.new //works - c is an Object / and xx is a instance of an Object c
  yy = o.new //nope  - o is already a instance of an Object, so it cannot be instantiated again

最后，Object实际上是一个类的实例。因为

  xx.is_a? Class

是假的，但是

  xx.is_a? Object

返回true

我说得对吗？？

Answer 1

基本上，需要理解的关键是，每个类都是class类的一个实例，每个类是对象的一个子类（在1.8-1.9中，每个类均是2asicObject）。因此，每个类都是一个对象，因为它是object的子类的实例，即class。

当然，这意味着Class是其自身的一个实例。如果这会让你的大脑受伤，那就不要想得太深。

`Object` and `Class` are `is_a? Object`

x.is_a？y返回true如果x.class==y或x.class<；y，即如果xs类是y或xs类从y继承。既然每个类都继承自对象x.is_a？无论x是什么，对象都返回true。（无论如何，在1.8中，在1.9中还有BasicObject，它现在是继承层次结构中最基本的类）。



They are also is_a? Class

Object和Class都是类，所以这并不奇怪。

They are also instance_of? Class, but not instance_of? Object.

与不同的是，is_a，x.instance_of？y仅在＜code＞x.class＝＝yx.class的子类的情况下。既然x和y都是instance_of？类，它们不是instance_of？对象。

对，任何事物都不可能是对象的实例。

那不是真的<代码>Object.new.instance_of？对象为true。

kind_of?

＜code＞种类是is_a的别名吗，请参见上文。




  所以两者完全相同，那么为什么我们都有呢。？


应该指出的是，到目前为止，所有阶级的一切都是正确的。例如String.is_a？对象，String.is_a？类和String.instance_of？类为true，并且String.instance_of？由于与上述相同的原因，对象为false。（同样，由于相同的原因，String.is_a？String和String.instance_of？String都为false-字符串是一个类，而不是字符串）。

你不能因此得出所有的类都是一样的结论。它们只是同一类的所有实例。

Comparing methods

由于Object和Class都是类，所以它们都具有Class定义的所有实例方法Class还具有嵌套的singleton方法nesting告诉您当前嵌套在哪个模块中，它与继承无关。

对于任何给定的类，TheClass.methods将返回class定义的实例方法（例如，超类，它返回TheClassnew创建TheClass的新实例）以及该类定义的单例方法。

无论如何，方法只会告诉哪些方法可以直接在给定对象上调用。它不会告诉您哪些方法可以在类的实例上调用。为此，您可以使用instance_methods，它为Object和Class返回明显不同的结果。

Answer 2

在Ruby中，一切都是一个＜code＞对象＜/code＞，包括类和模块Object是最低级的类（在Ruby1.9.2中也有BasicObject

请参阅以下输出。



> Object.ancestors
# => [Object, Kernel, BasicObject] 
> Class.ancestors
# => [Class, Module, Object, Kernel, BasicObject] 
> Module.ancestors
# => [Module, Object, Kernel, BasicObject] 
> String.ancestors
# => [String, Comparable, Object, Kernel, BasicObject]


如您所见，Class和Module都继承自Object。

回到你最初的断言，你必须理解


is_a?
kind_of 
instance_of?


它们不能互换<代码>is_a返回true。相反，＜code＞instance_of才会返回true。

> Class.is_a? Object
# => true 
> Class.kind_of? Object
# => true 
> Class.instance_of? Object
# => false

Answer 3

其中一个答案提到：

Basically the key thing to understand is that every class is an instance of the Class class and every class is a subclass of Object. So every class is an object in the sense that it is an instance of a subclass of Object, i.e. Class.

我只是想用不同的词来形容那些有点脑筋急转弯的人。首先问问自己：编程中的实例是什么？什么是编程中的子类？实例只是蓝图（类）的已实现变体。子类只是从另一个类（蓝图）继承的一个类。因此，当您创建一个新类时：

class Apple
end

苹果是Class的一个例子，也就是说，它是蓝图的一个已实现的变体。它采用蓝图，并用自己的变体填充细节（方法和变量）。这个蓝图继承自另一个蓝图，也就是Object。所以每个类都是class的一个实例，class是Object的一个子类。

class A 
end
A.superclass  
=> Object     
A.class  
=> Class

注意，类在其继承链中有Module（Module作为mixin包含在类中，可能是因为类的父级是Object？）。

A.is_a?(Module)
 => true

类A的实例（A.new）将有它们自己实现的A的变体。但它们是对象实例。因此，我们必须区分类实例（例如A类结束）和对象实例（A=A.new）。对象实例有不同的继承链。它们是类实例蓝图的已实现变体，而不是类class的变体。

这意味着在它们的继承链中不是类或模块。而是其他对象实例，所以如果A有对象实例，B有对象实例并且A从B继承，当我们实例化A的新对象实例时，该实例的继承链中将有B个实例。

它们也将继承自Object，因为Ruby中的所有内容都继承自Object。

a = A.new
 => #<A:0x007f966449b8d8> 
a.is_a?(Class)
 => false 
a.is_a?(Module)
 => false 
a.is_a?(Object)
 => true

这是思考这一切的最佳方式。不要想得太深。照我写的接受这个。

Answer 4

Ramesh，在ruby中，所有都是对象，Class也不例外。

在irb试试这个

ruby-1.9.2-p136 :001 > o = Object.new
=> #<Object:0x000001020114b0> 
ruby-1.9.2-p136 :002 > o.is_a? Class
=> false 
ruby-1.9.2-p136 :003 > o.is_a? Object
=> true

在本例中，我创建了一个Object的实例，并检查它是类（false）还是Object（true）。

ruby中的类是用于创建该类实例的某种模板对象。很抱歉，这不是很清楚。关键概念是ruby是一种纯面向对象的语言，而不是Java。

Answer 5

类/元类层次结构总是有点令人费解：）只是为了进行比较，这是Smalltalk中的设置；在Ruby中，设置基于相同的原则，只是它没有Behavior和ClassDescription的区别，并且需要考虑模块和本征类。

Smalltalk对象模型的完整解释可在Pharo by Example，正如相关问题。

Answer 6

正如他在本文

对象不存储方法，只有类可以。

前几节有一些关于类与对象的好观点

Answer 7

将类视为全局对象。

`Object` and `Class` are `is_a? Object`

They are also `is_a? Class`

They are also `instance_of? Class`, but not `instance_of? Object`.

kind_of?

Comparing methods

友情链接

Object and Class are is_a? Object

They are also is_a? Class

They are also instance_of? Class, but not instance_of? Object.

kind_of?

Comparing methods

友情链接

`Object` and `Class` are `is_a? Object`

They are also `is_a? Class`

They are also `instance_of? Class`, but not `instance_of? Object`.