在 Ruby 中，类和对象是面向对象编程的基础。通过定义类，你可以创建自定义的数据类型，并为这些数据类型添加行为（方法）。本章将详细介绍如何在 Ruby 中使用类和对象。

定义一个类

在 Ruby 中，你可以使用 class 关键字来定义一个类。

类的名称通常首字母大写。例如，我们定义一个名为 Person 的类：

class Person
end

这个简单的 Person 类没有任何属性或方法。

不过，你可以通过添加实例变量、初始化方法和行为方法来丰富它。

实例变量

实例变量是以 @ 开头的变量。它们属于类的实例，而不是类本身。

例如，我们可以在 Person 类中添加 @name 和 @age 实例变量：

class Person
  def initialize(name, age)
    @name = name
    @age = age
  end
end

在这个例子中，initialize 方法是一个特殊的方法，用于设置新对象的状态。

当你创建一个新的 Person 对象时，这个方法会被自动调用。

创建对象

一旦你定义了一个类，就可以使用 new 方法来创建该类的对象。

下面是如何创建 Person 类的新对象：

person = Person.new("Alice", 30)

在这个例子中，person 是一个 Person 类的新实例。

你可以通过 @name 和 @age 访问它的属性：

puts person.instance_variable_get(:@name) # 输出 "Alice"
puts person.instance_variable_get(:@age) # 输出 30

访问器方法

虽然能够借助 instance_variable_get 和 instance_variable_set 这两个方法来访问与修改实例变量，但更常见的做法是使用访问器方法，也就是 getter 和 setter 方法。

Ruby 为我们提供了 attr_accessor、attr_reader 以及 attr_writer 这几个工具，以此简化整个过程。

• attr_accessor：定义读写方法。
• attr_reader：定义只读方法。
• attr_writer：定义只写方法。

例如，我们可以为 Person 类添加读写属性 name 和只读属性 age：

// www.ja vascriptcn.com code example
class Person
  attr_accessor :name
  attr_reader :age

  def initialize(name, age)
    @name = name
    @age = age
  end
end

person = Person.new("Bob", 25)
puts person.name # 输出 "Bob"
person.name = "Charlie"
puts person.name # 输出 "Charlie"

puts person.age # 输出 25
# person.age = 30 # 这行代码会报错，因为 age 是只读的

三种访问器的区别

• attr_accessor 同时提供读取和修改能力。
• attr_reader 只允许读取属性值。
• attr_writer 只允许修改属性值。

自定义方法

除了实例变量和访问器方法外，你还可以定义自己的方法来扩展类的功能。

例如，我们可以在 Person 类中添加一个 greet 方法，用于输出问候语：

// www.ja vascriptcn.com code example
class Person
  attr_accessor :name
  attr_reader :age

  def initialize(name, age)
    @name = name
    @age = age
  end

  def greet
    puts "Hello, my name is #{@name} and I'm #{@age} years old."
  end
end

person = Person.new("Da vid", 35)
person.greet # 输出 "Hello, my name is Da vid and I'm 35 years old."

通过这种方式，类不仅可以保存数据，还可以定义对象的行为。

继承

继承是面向对象编程中的一个重要概念。

它允许你创建一个基类（父类），然后从这个基类派生出新的子类。

子类可以继承父类的所有属性和方法，也可以添加新的属性和方法，或者覆盖父类的方法。

例如，我们可以定义一个 Student 类，它是 Person 类的子类：

// www.ja vascriptcn.com code example
class Student < Person
  attr_accessor :grade

  def initialize(name, age, grade)
    super(name, age)
    @grade = grade
  end

  def study
    puts "#{@name} is studying in grade #{@grade}."
  end
end

student = Student.new("Eva", 16, 10)
puts student.name # 输出 "Eva"
puts student.age # 输出 16
student.study # 输出 "Eva is studying in grade 10."

在这个例子中，super 关键字用于调用父类的 initialize 方法。

这样，Student 类的实例也会有 name 和 age 属性。

多态性

多态性是指不同的子类对象对同一消息作出不同响应的能力。

在 Ruby 中，多态性是通过方法重载和接口实现的。

例如，我们可以在不同的子类中实现相同的接口方法，但提供不同的实现。

假设我们有两个类 Dog 和 Cat，它们都实现了 make_sound 方法：

// www.ja vascriptcn.com code example
class Dog
  def make_sound
    puts "Woof!"
  end
end

class Cat
  def make_sound
    puts "Meow!"
  end
end

def animal_sound(animal)
  animal.make_sound
end

dog = Dog.new
cat = Cat.new

animal_sound(dog) # 输出 "Woof!"
animal_sound(cat) # 输出 "Meow!"

在这个例子中，animal_sound 方法接受任何类型的动物对象，并调用它们的 make_sound 方法。

由于 Dog 和 Cat 都实现了 make_sound 方法，所以这个方法可以处理不同类型的对象。

总结

本章详细介绍了 Ruby 中类和对象的概念。

• 如何定义类
• 如何创建对象
• 如何使用实例变量和访问器方法
• 如何定义自定义方法
• 如何理解继承和多态性

通过这些基础知识，你可以开始构建更复杂的面向对象程序。