2.2Ruby类型之类(Class)

1.类声明

类 总是以关键字 class 开始，后跟类的名称。

class User
end

2.继承

Ruby语言只提供单继承，就是说1个子类不可以继承多个父类，只可以继承1个父类，可以用mix-in的方式引入模块从而支持“多继承”的效果。

class 类名 < 父类名
  类定义
end

Class是Module的子类，Module是Object的子类，Object是BaseObject的子类，BaseObject是所有类的根类。

irb(main):001:0> p Class.superclass
Module
=> Module
irb(main):002:0> p Module.superclass
Object
=> Object
irb(main):003:0> p Object.superclass
BasicObject
=> BasicObject
irb(main):004:0> p BasicObject.superclass
nil
=> nil

3.抽象(Abstract)类

我们可以定义一个抽象类，在抽象类内部定义一些抽象方法，这些方法留待子类进行实现。抽象的反面是 具体(concrete) ，如果一个继承自抽象类的类实现了祖先类中的所有的抽象方法，它就是具体类。

class AbstractGreeter
  def greet
    puts "#{greeting} #{who}"
  end
end

class WorldGreeter < AbstractGreeter
  def greeting
    "Hello"
  end

  def who
    "World"
  end
end

WorldGreeter.new.greet     #Hello World

4.重写(Override)

当一个子类从父类继承的时候，可以在子类定义与父类同名的方法来覆盖父类的方法，以达到方法重写的功能。

class WorldGreeter
  def greet
    puts "#{greeting} #{who}"
  end

  def greeting
    "Hello"
  end

  def who
    "World"
  end
end

class SpanishWorldGreeter < WorldGreeter
  def greeting
    "Hola"
  end
end

SpanishWorldGreeter.new.greet   #Hola World

5.构造方法

def initialize(x,y)
    @x, @y = x, y
  end

6.创建对象

对象是类的实例，使用 new 方法创建对象。下面的示例创建了类 User 的两个对象 user1 和 user2：

user1 = User.new
user2 = User.new

使用new方法创建对象的时候，许多其他语言通过自动调用一个“构造函数(constructor)“来实现初始化对象的，而Ruby则是通过自动调用一个initialize方法实现初始化对象的，new方法会把实参原封不动地传给initialize方法的myname形参，将传递过来的参数赋值给@name实例变量，然后执行实例方法hello。

class HelloWorld                        # class语句
  def initialize(myname = "Ruby")       # initialize方法
    @name = myname                      #初始化实例变量
  end

  def hello                             #实例方法
    puts "Hello,world.I am #{@name}."
  end

bob = HelloWorld.new("Bob")
bob.hello

7.访问成员

类.类变量
类.类方法()

对象.实例变量
对象.实例方法()

上面的对象被称为接收者(receiver)。调用方法被称为“向对象发送消息(message)”，调用的结果是“对象接收（receive）了消息”。也就是说，方法的调用就是把几个参数组成的消息一起发送给对象的过程。

8.访问器方法(Accessor)

由于initialize方法是private，所以Ruby类的实例变量不可以使用对象调用的方式直接被读取或修改，只能在实例方法中读取或修改，所以可以通过getter或setter实例方法分别读取和修改。

class MutablePoint
  def initialize(x,y)
    @x, @y = x, y
  end

  def x              #getter方法
    @x
  end

  def y              #getter方法
    @y
  end

  def x=(value)      #setter方法
    @x = value
  end

  def y=(value)      #setter方法
    @y = value
  end
end

给实例变量增加这种读写方法的需求俯拾皆是，但是以上的代码显得非常的繁琐，于是访问器方法应运而生。

class MutablePoint
  attr_reader :x, :y       #只读
  attr_writer :x, :y       #只写
  attr_accessor :x, :y     #读和写
  attr_:x                  #只读且只能定义一个属性             
  attr :y, true            #读和写且只能定义一个属性
end

9.self关键字

如果self在类的代码体中，但是在任何实例方法定义体外，self表示定义的当前类。

如果self在实例方法定义体内，self表示定义的当前实例。

10.superclass方法

当想知道某个子类(subclass)继承哪个父类(superclass)，我们可以使用superclass方法。

File.superclass          #=> IO
IO.superclass            #=> Object
Object.superclass        #=> BasicObject
class Foo; end
class Bar < Foo; end
Bar.superclass           #=> Foo

当被给予的类没有父类时，将返回nil值。

BasicObject.superclass   #=> nil

注：父类（superclass）又称为超类，但笔者认为父类更贴切。

返回对象o的类

o.class

返回类c的超类

c.superclass

11.class方法

当想知道某个对象是哪个类的实例时，我们可以使用class方法。

irb(main):001:0> p "Hello world".class
String
=> String
irb(main):002:0> p 5.class
Integer
=> Integer
irb(main):003:0>

12.object_id方法

irb(main):001:0> :george.object_id == :george.object_id
=> true
irb(main):002:0> "george".object_id == "george".object_id
=> false
irb(main):003:0>

object_id 方法返回的是对象的身份标识。如果两个对象有相同的 object_id， 那么它们就是相同的（指向同一个内存地址）。 可以看出，当符号在使用过一次后，任何相同字符的符号都会在内存中指向同一个对象地址。 也就是说任何相同字符的符号的 object_id 都是相同的。

通过object_id方法判断字符串对象与符号对象是不是同一个对象，相同内容的字符串对象不是同一个对象，相同内容的符号对象是同一个对象。

ho@ho-Inspiron-N3010:~$ irb
3.2.0 :001 > p "string".object_id
4840
 => 4840 
3.2.0 :002 > p :"string".object_id
305628
 => 305628 
3.2.0 :003 > p "string".object_id
14060
 => 14060 
3.2.0 :004 > p :"string".object_id
305628
 => 305628 
3.2.0 :005 >