Ruby 是一门 纯面向对象编程（OOP，Object-Oriented Programming） 语言，即所有数据类型都是对象，包括数字、字符串等基本类型。面向对象编程通过 类（Class） 和 对象（Object） 组织代码，提高代码的封装性、可重用性和扩展性。

📌 目录

  1. 🔹 面向对象编程（OOP）基础
  2. 🔹 类（Class）和对象（Object）
  3. 🔹 实例变量（@instance_var）和实例方法
  4. 🔹 类变量（@@class_var）和类方法
  5. 🔹 访问控制（public、private、protected）
  6. 🔹 继承与方法重写
  7. 🔹 super 关键字（调用父类方法）
  8. 🔹 self 关键字（当前对象引用）
  9. 🔹 attr_accessor、attr_reader、attr_writer
  10. 🔹 模块（Module）和 Mixin
  11. 🔹 方法动态调用与 method_missing
  12. 🔹 参考资料

🔹 面向对象编程（OOP）基础

Ruby 的 OOP 主要包括 类（Class）、对象（Object）、继承（Inheritance）、封装（Encapsulation） 和 多态（Polymorphism）。

  • 类（Class）：定义对象的模板，包含属性和方法。
  • 对象（Object）：类的实例，具有具体的数据和行为。
  • 封装（Encapsulation）：隐藏对象内部实现，提供公共接口访问数据。
  • 继承（Inheritance）：子类继承父类的方法和属性，可扩展和修改。
  • 多态（Polymorphism）：不同类的对象可以调用相同方法，行为不同。

🔹 类（Class）和对象（Object）

定义类

class Car
  def initialize(brand)
    @brand = brand
  end

  def info
    puts "This is a #{@brand} car."
  end
end

创建对象

car1 = Car.new("Toyota")
car2 = Car.new("BMW")

car1.info  # 输出: This is a Toyota car.
car2.info  # 输出: This is a BMW car.

解释：

  • initialize 方法是 构造方法，创建对象时自动调用。
  • @brand 是 实例变量，存储对象的数据。
  • info 是 实例方法，用于打印信息。

🔹 实例变量（@instance_var）和实例方法

实例变量

实例变量以 @ 开头，属于对象本身，不同对象的实例变量相互独立。

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

  def introduce
    puts "My name is #{@name} and I am #{@age} years old."
  end
end

p1 = Person.new("Alice", 25)
p2 = Person.new("Bob", 30)

p1.introduce  # My name is Alice and I am 25 years old.
p2.introduce  # My name is Bob and I am 30 years old.

🔹 类变量（@@class_var）和类方法

类变量

类变量以 @@ 开头，属于 整个类，被所有对象共享。

class Counter
  @@count = 0

  def initialize
    @@count += 1
  end

  def self.total_instances
    puts "Total instances: #{@@count}"
  end
end

c1 = Counter.new
c2 = Counter.new

Counter.total_instances  # Total instances: 2

类方法

使用 self.method_name 定义 类方法，可以在不创建对象的情况下调用。

class MathUtil
  def self.square(num)
    num * num
  end
end

puts MathUtil.square(5)  # 25

🔹 访问控制（public、private、protected）

Ruby 提供 3 种方法访问控制：

public（默认，任何地方可访问）

class Demo
  def hello
    puts "Hello, world!"
  end
end

d = Demo.new
d.hello  # Hello, world!

private（只能在类内部调用，外部无法访问）

class Demo
  def public_method
    private_method
  end

  private

  def private_method
    puts "This is a private method."
  end
end

d = Demo.new
d.public_method  # This is a private method.
d.private_method  # 错误: private method `private_method' called

protected（只能在相同类或子类内部访问）

class Parent
  protected

  def protected_method
    puts "Protected method"
  end
end

class Child < Parent
  def call_protected
    protected_method  # 子类内部可以访问
  end
end

c = Child.new
c.call_protected  # Protected method

🔹 继承与方法重写

继承

class Animal
  def speak
    puts "Animal makes a sound"
  end
end

class Dog < Animal
  def speak
    puts "Dog barks"
  end
end

dog = Dog.new
dog.speak  # Dog barks

🔹 super 关键字（调用父类方法）

class Parent
  def greet
    puts "Hello from Parent"
  end
end

class Child < Parent
  def greet
    super  # 调用父类方法
    puts "Hello from Child"
  end
end

c = Child.new
c.greet
# Hello from Parent
# Hello from Child

🔹 attr_accessor、attr_reader、attr_writer

class Person
  attr_accessor :name, :age  # 自动生成 getter 和 setter 方法

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

p = Person.new("Alice", 25)
puts p.name  # Alice
p.name = "Bob"
puts p.name  # Bob

🔹 模块（Module）和 Mixin

module Flyable
  def fly
    puts "I can fly!"
  end
end

class Bird
  include Flyable  # Mixin
end

b = Bird.new
b.fly  # I can fly!

🔹 方法动态调用与 method_missing

class DynamicMethod
  def method_missing(method_name, *args)
    puts "Undefined method: #{method_name}, Args: #{args}"
  end
end

d = DynamicMethod.new
d.unknown_method(1, 2, 3)
# Undefined method: unknown_method, Args: [1, 2, 3]

🔹 参考资料