Ruby方法可见性：public、protected与private

1. 方法可见性基础概念

在Ruby中，方法可见性决定了哪些对象可以调用特定的方法。Ruby提供了三种主要的方法可见性修饰符：public、protected 和 private。这些修饰符帮助开发者控制类的接口，确保对象的内部状态得到适当的保护，同时也定义了对象之间交互的规则。

1.1 public 方法

public 方法是类中最开放的方法类型。任何对象都可以调用一个类的 public 方法，只要该对象能够访问到包含该方法的类实例。这使得 public 方法成为类与外部世界交互的主要接口。

以下是一个简单的示例：

class MyClass
  def public_method
    puts "This is a public method"
  end
end

obj = MyClass.new
obj.public_method

在上述代码中，public_method 方法没有显式地声明为 public，但在Ruby中，除非另有声明，所有在类主体中定义的方法默认都是 public 的。所以，我们可以在类的实例 obj 上直接调用 public_method。

显式声明 public 方法也是可行的，通过 public 关键字：

class MyClass
  public
  def public_method
    puts "This is a public method"
  end
end

obj = MyClass.new
obj.public_method

这里，我们通过 public 关键字明确表示 public_method 是一个 public 方法。这种显式声明在需要批量声明一组 public 方法时非常有用。

1.2 protected 方法

protected 方法的可见性介于 public 和 private 之间。protected 方法只能在类及其子类的实例之间调用，并且调用时必须通过对象引用。这意味着同一个类的不同实例之间可以互相调用 protected 方法，子类实例也可以调用父类的 protected 方法。

以下是一个示例：

class ParentClass
  protected
  def protected_method
    puts "This is a protected method"
  end
end

class ChildClass < ParentClass
  def call_protected_method
    protected_method
  end
end

parent = ParentClass.new
child = ChildClass.new
# parent.protected_method  # 这行代码会报错，因为不能从外部调用 protected 方法
child.call_protected_method

在上述代码中，protected_method 被声明为 protected。ChildClass 继承自 ParentClass，并且在 ChildClass 的实例方法 call_protected_method 中，我们可以调用 protected_method。然而，如果我们尝试在类外部，比如在 parent.protected_method 这行代码中直接调用 protected_method，Ruby会抛出一个 NoMethodError 错误。

1.3 private 方法

private 方法是最严格的访问级别。private 方法只能在定义它们的类及其子类的内部调用，并且调用时不能使用对象引用，只能在对象内部直接调用。

以下是一个示例：

class MyClass
  private
  def private_method
    puts "This is a private method"
  end

  def call_private_method
    private_method
  end
end

obj = MyClass.new
# obj.private_method  # 这行代码会报错，因为不能从外部调用 private 方法
obj.call_private_method

在上述代码中，private_method 被声明为 private。我们可以在 MyClass 的实例方法 call_private_method 中调用 private_method，但如果在类外部尝试通过 obj.private_method 调用，会导致 NoMethodError 错误。

2. 方法可见性的应用场景

理解了三种方法可见性修饰符的基本概念后，让我们来看一下它们在实际编程中的应用场景。

2.1 public 方法的应用场景

public 方法通常用于定义类的外部接口。这些方法是其他对象与当前类进行交互的主要方式。例如，在一个银行账户类中，deposit 和 withdraw 方法可能是 public 的，因为外部代码需要通过这些方法来操作账户余额。

class BankAccount
  def initialize(balance)
    @balance = balance
  end

  def deposit(amount)
    @balance += amount
    puts "Deposited #{amount}. New balance: #{@balance}"
  end

  def withdraw(amount)
    if @balance >= amount
      @balance -= amount
      puts "Withdrew #{amount}. New balance: #{@balance}"
    else
      puts "Insufficient funds"
    end
  end
end

account = BankAccount.new(1000)
account.deposit(500)
account.withdraw(300)

在这个例子中，deposit 和 withdraw 方法作为 BankAccount 类的 public 接口，允许外部代码与账户进行交互，而账户的内部状态（@balance）则通过这些 public 方法进行间接访问和修改，从而保护了账户余额的一致性。

2.2 protected 方法的应用场景

protected 方法通常用于类内部或子类之间需要共享的逻辑，但不希望外部对象直接调用。例如，在一个图形绘制库中，可能有一个基类 Shape，其中定义了一些与图形属性计算相关的 protected 方法，子类 Circle 和 Rectangle 可以调用这些方法来进行自己的属性计算。

class Shape
  protected
  def calculate_area
    # 这里可以是通用的面积计算逻辑，子类可根据自身情况重写
    raise NotImplementedError, "Subclasses must implement calculate_area"
  end
end

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

  protected
  def calculate_area
    Math::PI * @radius ** 2
  end

  def display_area
    area = calculate_area
    puts "Area of the circle: #{area}"
  end
end

class Rectangle < Shape
  def initialize(length, width)
    @length = length
    @width = width
  end

  protected
  def calculate_area
    @length * @width
  end

  def display_area
    area = calculate_area
    puts "Area of the rectangle: #{area}"
  end
end

circle = Circle.new(5)
circle.display_area
rectangle = Rectangle.new(4, 6)
rectangle.display_area

在这个例子中，calculate_area 方法在 Shape 类中被声明为 protected，子类 Circle 和 Rectangle 重写了这个方法来实现自己的面积计算逻辑。通过将 calculate_area 方法设为 protected，我们确保外部代码不能直接调用这个方法，只能通过 display_area 这样的 public 方法间接调用，从而保护了内部的计算逻辑。

2.3 private 方法的应用场景

private 方法通常用于封装类内部的辅助逻辑。这些方法是类实现细节的一部分，对外部对象没有意义，并且不应该被外部对象调用。例如，在一个字符串处理类中，可能有一个 private 方法用于清理字符串中的特殊字符，这个方法只在类内部的其他方法中使用。

class StringProcessor
  private
  def clean_string(str)
    str.gsub(/[^\w\s]/, '')
  end

  def process_string(str)
    cleaned_str = clean_string(str)
    words = cleaned_str.split
    words.sort.join(' ')
  end
end

processor = StringProcessor.new
result = processor.process_string("Hello, world! 123")
puts result

在这个例子中，clean_string 方法是 private 的，它只在 process_string 方法内部被调用，用于清理字符串中的特殊字符。外部代码只关心 process_string 方法的功能，而不需要知道内部的字符串清理逻辑，从而提高了代码的封装性和可维护性。

3. 方法可见性修饰符的作用范围

方法可见性修饰符在类定义中的位置决定了它们的作用范围。

3.1 类主体中的声明

当在类主体中直接定义方法时，除非显式声明为 protected 或 private，否则方法默认是 public 的。例如：

class MyClass
  def public_method
    puts "This is a public method"
  end

  protected
  def protected_method
    puts "This is a protected method"
  end

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

在这个例子中，public_method 是 public 的，因为没有显式声明其他可见性。protected_method 被声明为 protected，private_method 被声明为 private。

3.2 使用关键字块

可以使用 public、protected 和 private 关键字块来批量声明一组具有相同可见性的方法。例如：

class MyClass
  public
  def public_method1
    puts "This is public method 1"
  end

  def public_method2
    puts "This is public method 2"
  end

  protected
  def protected_method1
    puts "This is protected method 1"
  end

  def protected_method2
    puts "This is protected method 2"
  end

  private
  def private_method1
    puts "This is private method 1"
  end

  def private_method2
    puts "This is private method 2"
  end
end

在这个例子中，public_method1 和 public_method2 是 public 的，protected_method1 和 protected_method2 是 protected 的，private_method1 和 private_method2 是 private 的。这种方式在组织和管理方法可见性时非常方便，尤其是当一个类有大量方法需要设置相同的可见性时。

3.3 方法定义后的声明

也可以在方法定义后使用可见性修饰符来改变方法的可见性。例如：

class MyClass
  def method1
    puts "This is method 1"
  end
  private :method1

  def method2
    puts "This is method 2"
  end
  protected :method2
end

在这个例子中，method1 最初定义时没有显式可见性，默认为 public，但通过 private :method1 将其改为 private。同样，method2 最初默认为 public，通过 protected :method2 将其改为 protected。

4. 方法可见性与继承

方法可见性在继承关系中遵循一定的规则。

4.1 子类继承父类的方法可见性

子类继承父类的方法时，方法的可见性保持不变。例如，如果父类有一个 public 方法，子类继承后该方法仍然是 public 的；如果父类有一个 protected 方法，子类继承后该方法仍然是 protected 的。

class ParentClass
  def public_method
    puts "This is a public method in ParentClass"
  end

  protected
  def protected_method
    puts "This is a protected method in ParentClass"
  end

  private
  def private_method
    puts "This is a private method in ParentClass"
  end
end

class ChildClass < ParentClass
  def call_public_method
    public_method
  end

  def call_protected_method
    protected_method
  end

  def call_private_method
    private_method
  end
end

child = ChildClass.new
child.call_public_method
child.call_protected_method
# child.call_private_method  # 这行代码会报错，因为不能在子类外部调用父类的 private 方法

在这个例子中，ChildClass 继承了 ParentClass 的方法。public_method 在 ChildClass 中仍然是 public 的，可以在 ChildClass 的实例上直接调用 call_public_method 来调用它。protected_method 在 ChildClass 中仍然是 protected 的，可以在 ChildClass 的实例方法 call_protected_method 中调用。而 private_method 在 ChildClass 中仍然是 private 的，不能在 ChildClass 的实例方法 call_private_method 外部调用。

4.2 子类重写父类方法的可见性

子类重写父类方法时，可以改变方法的可见性，但需要遵循一定的规则。一般来说，子类不能将父类的 public 方法重写为 protected 或 private 方法，也不能将父类的 protected 方法重写为 private 方法，因为这会缩小方法的可见范围，可能会破坏继承体系中其他代码的功能。

class ParentClass
  def public_method
    puts "This is a public method in ParentClass"
  end

  protected
  def protected_method
    puts "This is a protected method in ParentClass"
  end
end

class ChildClass < ParentClass
  # 以下重写会报错，不能将 public 方法重写为 protected 方法
  # protected
  # def public_method
  #   puts "This is a modified public method in ChildClass"
  # end

  # 以下重写会报错，不能将 protected 方法重写为 private 方法
  # private
  # def protected_method
  #   puts "This is a modified protected method in ChildClass"
  # end

  def public_method
    puts "This is a modified public method in ChildClass"
  end

  public
  def protected_method
    puts "This is a modified protected method in ChildClass"
  end
end

在这个例子中，如果我们尝试将 ParentClass 的 public_method 重写为 protected 方法，或者将 protected_method 重写为 private 方法，Ruby会抛出一个错误。然而，子类可以将 protected 方法重写为 public 方法，扩大方法的可见范围，这种做法在某些情况下是合理的，比如子类需要提供更广泛的访问权限来满足特定的需求。

5. 动态改变方法可见性

在Ruby中，还可以在运行时动态改变方法的可见性。这为程序的灵活性提供了更多的可能性。

5.1 使用 Module#public、Module#protected 和 Module#private 方法

可以通过 Module 类的 public、protected 和 private 方法在运行时改变方法的可见性。例如：

class MyClass
  def my_method
    puts "This is my method"
  end
end

obj = MyClass.new
obj.my_method

MyClass.private :my_method
# obj.my_method  # 这行代码现在会报错，因为 my_method 已经变成 private 方法

在这个例子中，最初 my_method 是 public 的，我们可以在 MyClass 的实例 obj 上调用它。然后，通过 MyClass.private :my_method 将 my_method 变为 private 方法，之后再尝试调用 obj.my_method 就会导致 NoMethodError 错误。

5.2 使用 Object#send 方法绕过可见性限制

Object#send 方法可以用于绕过方法可见性的限制来调用方法。虽然这种做法不推荐，因为它破坏了封装性，但在某些特殊情况下可能有用。例如：

class MyClass
  private
  def private_method
    puts "This is a private method"
  end
end

obj = MyClass.new
obj.send(:private_method)

在这个例子中，我们通过 obj.send(:private_method) 调用了 MyClass 的 private_method，绕过了 private 方法的可见性限制。然而，这种做法应该谨慎使用，因为它违反了方法可见性的设计初衷，可能会导致代码的维护性和安全性问题。

6. 方法可见性与元编程

元编程是Ruby的强大特性之一，它允许程序在运行时修改自身的结构和行为。方法可见性也可以与元编程结合使用，实现一些灵活且强大的功能。

6.1 使用元编程动态定义具有不同可见性的方法

可以使用元编程技术在运行时动态定义具有不同可见性的方法。例如：

class MyClass
  def self.define_methods
    (1..3).each do |i|
      define_method("public_method_#{i}") do
        puts "This is public method #{i}"
      end
      public :"public_method_#{i}"

      define_method("protected_method_#{i}") do
        puts "This is protected method #{i}"
      end
      protected :"protected_method_#{i}"

      define_method("private_method_#{i}") do
        puts "This is private method #{i}"
      end
      private :"private_method_#{i}"
    end
  end
end

MyClass.define_methods
obj = MyClass.new
obj.public_method_1
# obj.protected_method_1  # 这行代码会报错，因为不能从外部调用 protected 方法
# obj.private_method_1  # 这行代码会报错，因为不能从外部调用 private 方法

在这个例子中，通过 define_method 动态定义了 public_method_1、protected_method_1 和 private_method_1 等方法，并分别设置了它们的可见性。public_method_1 可以在类外部调用，而 protected_method_1 和 private_method_1 不能从外部调用，遵循了它们各自的可见性规则。

6.2 使用元编程检查方法可见性

元编程还可以用于检查方法的可见性。例如，可以通过 Module#method_defined? 和 Module#protected_method_defined?、Module#private_method_defined? 等方法来检查方法是否存在以及其可见性。

class MyClass
  def public_method
    puts "This is a public method"
  end

  protected
  def protected_method
    puts "This is a protected method"
  end

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

puts MyClass.method_defined?(:public_method)  # true
puts MyClass.protected_method_defined?(:protected_method)  # true
puts MyClass.private_method_defined?(:private_method)  # true
puts MyClass.public_method_defined?(:private_method)  # false

在这个例子中，通过这些方法可以检查类中不同可见性方法的定义情况，这在编写一些通用的工具方法或者进行反射操作时非常有用。

7. 最佳实践与注意事项

在使用Ruby的方法可见性时，有一些最佳实践和注意事项需要牢记。

7.1 最小化公开接口

尽量将类的公开接口（public 方法）保持在最小化。只公开那些外部对象真正需要调用的方法，这样可以减少类的暴露面，提高代码的安全性和可维护性。例如，如果一个类内部有一些辅助方法只在类内部使用，应该将它们声明为 private 或 protected。

7.2 合理使用 protected 和 private

正确区分 protected 和 private 方法的使用场景。protected 方法适用于类内部或子类之间共享的逻辑，而 private 方法适用于完全封装在类内部的辅助逻辑。避免过度使用 protected 方法，导致类的内部逻辑暴露过多。

7.3 文档化方法可见性

在编写代码时，应该对方法的可见性进行文档化。这有助于其他开发者理解类的接口和内部结构。可以使用Ruby的文档生成工具，如 YARD，在文档注释中明确说明方法的可见性。例如：

class MyClass
  # @return [void] This is a public method that does something.
  def public_method
    # 方法实现
  end

  # @return [void] This is a protected method that is used internally.
  protected
  def protected_method
    # 方法实现
  end

  # @return [void] This is a private method that is used for internal helper logic.
  private
  def private_method
    # 方法实现
  end
end

通过这样的文档注释，其他开发者在阅读代码时可以清楚地了解每个方法的作用和可见性。

7.4 避免动态改变可见性

虽然Ruby允许在运行时动态改变方法的可见性，但这种做法应该尽量避免。动态改变可见性会使代码的行为变得难以预测，增加代码的复杂性和维护成本。只有在非常特殊的情况下，经过充分的考虑和测试后，才使用动态改变可见性的技术。

通过遵循这些最佳实践和注意事项，可以更好地利用Ruby的方法可见性机制，编写出更加健壮、安全和易于维护的代码。