一、啥是方法查找路径

在 Ruby 里，当你调用一个方法时，Ruby 得知道上哪儿去找这个方法的定义。这就好比你要找一本书，得知道它放在哪个书架上。这个寻找方法定义的路线，就是方法查找路径。

咱们来看个简单例子：

# Ruby 代码示例
class Animal
  def speak
    puts "Some sound"
  end
end

class Dog < Animal
  def bark
    puts "Woof!"
  end
end

dog = Dog.new
dog.bark  # 调用 Dog 类自己的 bark 方法
dog.speak # 调用从 Animal 类继承来的 speak 方法

在这个例子里，当你调用 dog.bark 时，Ruby 先在 Dog 类里找 bark 方法的定义，找到了就执行。当你调用 dog.speak 时，Dog 类里没有 speak 方法，Ruby 就顺着继承链往上，到 Animal 类里找，找到了就执行。

二、继承链是咋回事

继承链就是类之间的一种关系，子类可以继承父类的方法和属性。就像儿子可以继承爸爸的财产一样。在 Ruby 里，继承用 < 符号表示。

接着上面的例子，Dog 类继承自 Animal 类，Dog 就是子类，Animal 就是父类。当你创建一个 Dog 对象时，它不仅有自己定义的方法，还能使用 Animal 类里的方法。

# Ruby 代码示例
class Animal
  def eat
    puts "Eating..."
  end
end

class Dog < Animal
  def play
    puts "Playing fetch!"
  end
end

dog = Dog.new
dog.eat  # 调用从 Animal 类继承来的 eat 方法
dog.play # 调用 Dog 类自己的 play 方法

这里，Dog 对象可以调用 eat 方法，因为它继承了 Animal 类的这个方法。

三、方法查找路径的详细过程

当你调用一个对象的方法时，Ruby 会按照一定的顺序去找这个方法的定义。具体顺序是：

  1. 先在对象所属的类里找。
  2. 如果没找到，就到这个类的父类里找。
  3. 一直往上找，直到找到方法的定义或者到了 Object 类（所有类的基类）。

咱们看个复杂点的例子：

# Ruby 代码示例
class Grandparent
  def greet
    puts "Hello from Grandparent!"
  end
end

class Parent < Grandparent
  def greet
    puts "Hello from Parent!"
  end
end

class Child < Parent
  def greet
    puts "Hello from Child!"
  end
end

child = Child.new
child.greet # 先在 Child 类里找 greet 方法，找到了就执行

在这个例子里，当你调用 child.greet 时，Ruby 先在 Child 类里找 greet 方法，找到了就执行，不会再去父类里找。

四、应用场景

代码复用

继承和方法查找路径可以让你复用已有的代码。比如你有一个 Shape 类，里面定义了一些通用的方法，像计算面积、周长等。然后你可以创建 Circle、Rectangle 等子类，继承 Shape 类的方法，这样就不用在每个子类里都重新实现这些方法了。

# Ruby 代码示例
class Shape
  def area
    puts "Calculating area..."
  end
end

class Circle < Shape
  def initialize(radius)
    @radius = radius
  end

  def area
    # 重写父类的 area 方法
    puts "Calculating area of circle: #{3.14 * @radius * @radius}"
  end
end

circle = Circle.new(5)
circle.area # 调用 Circle 类重写的 area 方法

多态

多态是指不同的对象可以对同一个方法做出不同的响应。通过继承和方法查找路径，你可以实现多态。比如上面的 Shape 类和 Circle 类，虽然都有 area 方法，但实现方式不同。

# Ruby 代码示例
def print_area(shape)
  shape.area
end

shape = Shape.new
circle = Circle.new(5)

print_area(shape) # 调用 Shape 类的 area 方法
print_area(circle) # 调用 Circle 类的 area 方法

五、技术优缺点

优点

  • 代码复用：通过继承和方法查找路径，你可以复用已有的代码，减少代码重复。
  • 可维护性：将通用的代码放在父类里，修改时只需要修改父类的代码，所有子类都会受到影响，提高了代码的可维护性。
  • 多态性：可以实现多态，让不同的对象对同一个方法做出不同的响应，增加了代码的灵活性。

缺点

  • 耦合度高：继承会让子类和父类之间的耦合度变高，如果父类的代码发生变化，可能会影响到子类。
  • 层次过深：如果继承层次过深，会让代码变得复杂，难以理解和维护。

六、注意事项

避免滥用继承

不要为了复用代码而过度使用继承。有时候，组合可能是更好的选择。比如，你可以把一个对象作为另一个对象的属性，而不是通过继承来复用代码。

# Ruby 代码示例
class Engine
  def start
    puts "Engine started!"
  end
end

class Car
  def initialize
    @engine = Engine.new
  end

  def start_car
    @engine.start
  end
end

car = Car.new
car.start_car # 调用 Car 类的 start_car 方法，间接调用 Engine 类的 start 方法

重写方法时要注意

当你重写父类的方法时，要确保方法的参数和返回值类型一致，否则可能会导致错误。

# Ruby 代码示例
class Parent
  def add(a, b)
    a + b
  end
end

class Child < Parent
  def add(a, b)
    # 重写父类的 add 方法
    a * b
  end
end

child = Child.new
result = child.add(2, 3)
puts result # 输出 6

七、继承链调优

减少继承层次

尽量减少继承层次，避免代码变得过于复杂。可以把一些通用的方法提取到模块里，然后通过混合模块的方式来复用代码。

# Ruby 代码示例
module Printable
  def print_info
    puts "Printing information..."
  end
end

class Animal
  include Printable
end

class Dog < Animal
  # 可以直接使用 Printable 模块里的 print_info 方法
end

dog = Dog.new
dog.print_info

使用委托

委托是指把一个对象的方法调用委托给另一个对象。这样可以避免继承带来的耦合问题。

# Ruby 代码示例
class Printer
  def print_document
    puts "Printing document..."
  end
end

class Office
  def initialize
    @printer = Printer.new
  end

  def print_doc
    @printer.print_document
  end
end

office = Office.new
office.print_doc # 调用 Office 类的 print_doc 方法，间接调用 Printer 类的 print_document 方法

八、文章总结

在 Ruby 里，方法查找路径和继承链是非常重要的概念。方法查找路径决定了 Ruby 如何找到方法的定义，而继承链则让子类可以继承父类的方法和属性。通过合理使用继承和方法查找路径，你可以实现代码复用和多态。但同时也要注意继承带来的耦合问题，避免滥用继承。可以通过减少继承层次、使用委托等方式来优化继承链。掌握这些知识，能让你写出更高效、更易维护的 Ruby 代码。