有关此示例，请查看 protected.rb 程序。在这里，我创建了一个名为 的 MyClass 对象和一个 MyOtherClass 对象 myotherob，并且 MyOtherClass 继承自 MyClass。我尝试将 myotherob 作为参数传递给 myob 的公共方法，shout：

但是 shout 方法在参数对象上调用 private 方法 priv：

def shout( anOb ) # calls a private method
  puts( anOb.priv( "This is a #{anOb.class} - hurrah" ) )
end

这将不能运行！Ruby 解释 priv 方法是私有的。

同样，如果我反过来这样做 - 也就是说，通过将父类对象 myob作为参数传递，并在子类对象上调用方法 shout，我会得到同样的错误：

myotherob.shout( myob )

MyClass 类还有另一个公共方法，exclaim。这次会调用一个 protected 方法，prot：

def exclaim( anOb ) # calls a protected method
  puts( anOb.prot( "This is a #{anOb.class} - hurrah" ) )
end

现在，我可以将 MyClass 对象 myob 或 MyOtherClass 对象 myotherob 作为参数传递给 exclaim 方法，并且在调用 protected 方法时都不会发生错误：

myob.exclaim( myotherob )  # This is OK
myotherob.exclaim( myob )  # And so is this…

不用说，这仅在两个对象（接收器和参数）共享相同的继承链时才有效。如果发送不相关的对象作为参数，则无论其保护级别如何，你都无法调用接收器对象所属类的方法。

私有方法的重点在于它不能从它所属的对象作用域之外被调用。所以这将不起作用：

class X
  private
  def priv( aStr )
    puts("I'm private, " << aStr)
  end
end
ob = X.new
ob.priv( "hello" ) # This fails

符号后面提供的任何参数（如字符串，”hello”）都以正常方式传递给指定的方法。

可以说使用 send 获取私有方法的公共访问权通常不是一个好主意（否则，为什么你首先将该方法设为私有的），所以应谨慎使用或根本不使用…

之前，我们通过将方法名称附加到类的名称后面来创建类方法（class method），如下所示：

def MyClass.classMethod

有一种“快捷”语法。这是个示例：

  def MyClass.methodA
  end
  class << self
    def methodB
      puts("b")
    end
    def methodC
      puts("c")
    end
  end
end

这里，methodA，methodB 和 methodC 都是 MyClass 的类方法；methodA 是使用我们之前使用的语法声明的：

但是,使用实例方法的语法声明了 methodB 和 methodC：

def <methodname>

class << self
  # some method declarations
end

这可能会让你想起用于声明单例类（singleton classe）的语法。例如，在 singleton_class.rb 程序中，你可能还记得我们首先创建了一个名为 ob 的对象，然后给它声明了一个自己的方法，blather：

class << ob
  def blather( aStr )
    puts("blather, blather #{aStr}")
  end
end

这里的 blather 方法是 ob 对象的单例方法（singleton method）。类似地，在 class_methods3.rb 程序中，methodB 和 methodC 方法是 self 的单例方法，而 self 恰好是 MyClass 类。我们可以类似地通过使用 << 后跟类名来从类定义之外添加单例方法，如下所示：

class << MyClass
    puts( "d" )
  end
end

你可以嵌套（nest）方法（将一个方法嵌套在另一个方法中）。这为你提供了一种将长方法划分为可重用块的方式。因此，例如，如果方法 x 需要在几个不同的点进行 y 计算，则可以将 y 方法放在 x 方法中：

嵌套方法默认在定义它们的作用域之外是不可见的。因此，在上面的示例中，虽然可以从 x 内部调用 y 和 z，但是任何其它代码都不能调用它们：

ob = X.new
ob.z # <= error

但是，当你运行一个包含嵌套方法的方法时，这些嵌套方法将被带入该方法之外的作用域内！

class X
  def x
    print( "x:" )
    def y
      print("y:")
    end
    def z
      print( "z:" )
      y
    end
  end
end
ob = X.new
ob.x #=> x:
puts
ob.y #=> y:
puts
ob.z #=> z:y:

最后一点，值得一提的是 Ruby 中的方法名称几乎总是以小写字符开头，如下所示：

def fred

但是，这只是一个习惯约定，而非必须的。也可以用大写字母开头的方法名称，如下所示：

def Fred

由于 Fred 方法看起来像一个常量（以大写字母开头），因此你需要在调用它时添加括号来告诉 Ruby，它是一个方法：

Fred   # <= Ruby complains "uninitialized" constant