Ruby疯狂：类与对象？

我刚开始玩JRuby。这是我的第一篇ruby帖子。我很难理解Ruby中的类和对象。它并不意味着像其他面向对象语言中的类和对象那样。例如

Class.is_a? Object

返回true 及

太多了

所以类和对象都是对象

又来了一个

Class.is_a? Class

返回true 及

太多了

等等，我还没做完

 Object.instance_of? Class
 Class.instance_of? Class

两者都是真的

 Object.instance_of? Object
 Class.instance_of? Object

 Class.kind_of? Object
 Object.kind_of? Object

两者都是错误的。对，任何东西都不能是对象的实例

及

两者都是真的

 Object.instance_of? Object
 Class.instance_of? Object

 Class.kind_of? Object
 Object.kind_of? Object

两者都是真的

 Object.instance_of? Object
 Class.instance_of? Object

 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_方法（对象）和print_方法（类）之间唯一的方法区别是

如果嵌套意味着继承，那么对象是否与密封类相似

有人能告诉我这是什么吗

更新：至Edds评论

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

c=Class.new
print_methods(c)

&

现在我明白了类的实例实际上是一个类实例（这个类实例实际上是一个对象），而不是一个对象实例。甚至这个实例也允许我跨越另一个实例

  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

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

  xx.is_a? Class 

是假的，但是

  xx.is_a? Object 

返回true

---

我说得对吗？

Ramesh，在ruby中，一切都是对象，类也不例外

在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 

ruby-1.9.2-p136:001>o=Object.new
=> # 
ruby-1.9.2-p136:002>o.is_a？等级
=>错误
ruby-1.9.2-p136:003>o.is_a？对象
=>正确

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

---

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

在Ruby中，一切都是一个

对象

，包括类和模块

Object

是最低级的类（Ruby 1.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]

如您所见，

类

和

模块

都继承自

对象

回到你最初的断言，你必须理解它们之间的区别

• 是一个吗？

• “

  种类”

• 实例？

它们不能互换<如果另一个是同一个类或祖先，则code>是一个？和

种类？

返回true。相反，只有当另一个是同一类时，的实例才返回true

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

---

基本上，要理解的关键是每个类都是

类

类的实例，每个类都是

对象

的子类（在1.8-1.9中，每个类都是

基本对象

的子类）。因此，每个类都是一个对象，因为它是

对象

的子类的实例，即

类

当然，这意味着

Class

本身就是一个实例。如果这让你的大脑受伤，那就不要想得太深

对象

和

类

是

吗？对象

x.u\a？如果
x.class==y或x.class
，则y

返回

true

，即如果

x

的类是

y

或

x

的类继承自

y

。因为每个类都继承自object

x？无论
x
是什么，对象都返回true。（无论如何，在1.8中，在1.9中还有
BasicObject
，它现在是继承层次结构中最基本的类）

它们也是
is_a？类别
Object
和
Class
实际上都是类，所以这并不奇怪

它们也是的
实例？类，但不是的实例？对象
。
不像
是一个？
，
x.instance\u的？仅当
x.class==y
时，y
才返回true，而当
x.class
是
y
的子类时，则不返回true。既然
x
和
y
都是
的实例？类，它们不是的实例？对象

对，任何东西都不能是对象的实例

那不是真的<代码>Object.new.instance\u of？对象

为真

什么样的？

kind\u of？

是

is\u a？

的别名，请参见上文

所以两者都是完全相同的，那么为什么我们有这两个呢

应该指出的是，到目前为止，所有的课程都是如此。例如，

String.is_a？对象

，

String.is_a？类的
和
String.instance\u？类
为真，且
String.instance\u为？对象
为false，原因与上述相同。（同样由于相同的原因，
String.is_？String
和
String.instance_？String
都为false-String是一个类，而不是字符串）

你不能由此推断所有的类都是相同的。它们只是同一类的所有实例

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

比较方法
由于
Object
和
Class
都是类，它们都具有
Class
定义的所有实例方法
Class
还具有单例方法
嵌套
<代码>嵌套
告诉您当前嵌套在哪个模块中，它与继承无关

对于任何给定的类，
类。方法
将返回由
类
定义的实例方法（例如，
超类
，它返回类

继承的类，以及创建类的新实例的

新

）以及该类定义的单例方法

无论如何

方法

o

class Apple
end

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

A.is_a?(Module)
 => true  

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