разница

• любой может вызвать ваши публичные методы.
• вы можете вызвать свои защищенные методы,или другой член вашего класса (или класс-потомок) может вызывать ваши защищенные методы извне. Никто другой не может.
• только вы можете вызвать свои частные методы, потому что они могут быть вызваны только с неявным приемником self. даже ты не могу назвать self.some_private_method; вы должны позвонить private_method С self подразумевается. ( iGEL указывает: "однако есть одно исключение. Если у вас есть частный метод age=, вы можете (и должны) вызвать его с помощью self, чтобы отделить его от локальных переменных.")

в Ruby эти различия - просто советы от одного программиста к другому. непубличные методы, это способ сказать "я оставляю за собой право изменить это; не зависеть от него." но вы все равно получите острые ножницы send и может вызвать любой метод вы как.

краткое руководство

# dwarf.rb
class Dwarf
  include Comparable

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

  attr_reader :name, :age, :beard_strength
  public    :name
  private   :age
  protected :beard_strength

  # Comparable module will use this comparison method for >, <, ==, etc.
  def <=>(other_dwarf)
    # One dwarf is allowed to call this method on another
    beard_strength <=> other_dwarf.beard_strength
  end

  def greet
    "Lo, I am #{name}, and have mined these #{age} years.\
       My beard is #{beard_strength} strong!"
  end

  def blurt
    # Not allowed to do this: private methods can't have an explicit receiver
    "My age is #{self.age}!"
  end
end

require 'irb'; IRB.start

тогда вы можете запустить ruby dwarf.rb и этого:

gloin = Dwarf.new('Gloin', 253, 7)
gimli = Dwarf.new('Gimli', 62,  9)

gloin > gimli         # false
gimli > gloin         # true

gimli.name            # 'Gimli'
gimli.age             # NoMethodError: private method `age'
                         called for #<Dwarf:0x007ff552140128>

gimli.beard_strength # NoMethodError: protected method `beard_strength'
                        called for #<Dwarf:0x007ff552140128>

gimli.greet          # "Lo, I am Gimli, and have mined these 62 years.\
                           My beard is 9 strong!"

gimli.blurt          # private method `age' called for #<Dwarf:0x007ff552140128>

частные методы в Ruby:

если метод является частным в Ruby, то он не может быть вызван явным получателем (объектом). Его можно вызвать только неявно. Он может быть вызван неявно классом, в котором он был описан, а также подклассами этого класса.

следующие примеры проиллюстрируют это лучше:

1) класс животных с частным методом class_name

class Animal
  def intro_animal
    class_name
  end
  private
  def class_name
    "I am a #{self.class}"
  end
end

в этом дело:

n = Animal.new
n.intro_animal #=>I am a Animal
n.class_name #=>error: private method `class_name' called

2) подкласс животных называется амфибия:

class Amphibian < Animal
  def intro_amphibian
    class_name
  end 
end 

в этом случае:

  n= Amphibian.new
  n.intro_amphibian #=>I am a Amphibian
  n.class_name #=>error: private method `class_name' called

как вы можете видеть, закрытые методы могут быть вызваны только косвенно. Они не могут быть вызваны явными получателями. По той же причине частные методы не могут быть вызваны вне иерархии определяющего класса.

защищенные методы в Ruby:

если метод защищен в Ruby, то он может быть вызван неявно обоими определяющий класс и его подклассы. Кроме того, они также могут быть вызваны явным приемником, если приемник является self или того же класса, что и self:

1) класс животных с защищенным методом protect_me

class Animal
  def animal_call
    protect_me
  end
  protected
  def protect_me
    p "protect_me called from #{self.class}"
  end  
end

в этом случае:

n= Animal.new
n.animal_call #=> protect_me called from Animal
n.protect_me #=>error: protected method `protect_me' called

2) класс млекопитающих, который наследуется от класса животных

class Mammal < Animal
  def mammal_call
    protect_me
  end
end 

в этом случае

n= Mammal.new
n.mammal_call #=> protect_me called from Mammal

3) класс амфибий, унаследованный от класса животных (таких же, как млекопитающие класс)

class Amphibian < Animal
  def amphi_call
    Mammal.new.protect_me #Receiver same as self
    self.protect_me  #Receiver is self
  end   
end

в этом случае

n= Amphibian.new
n.amphi_call #=> protect_me called from Mammal
             #=> protect_me called from Amphibian  

4) класс называется Дерево

class Tree
  def tree_call
    Mammal.new.protect_me #Receiver is not same as self
  end
end

в этом случае:

n= Tree.new
n.tree_call #=>error: protected method `protect_me' called for #<Mammal:0x13410c0>

рассмотрим частный метод в Java. Он может быть вызван из того же класса, конечно, но он также может быть вызван другим экземпляром того же класса:

public class Foo {

   private void myPrivateMethod() {
     //stuff
   }

   private void anotherMethod() {
       myPrivateMethod(); //calls on self, no explicit receiver
       Foo foo = new Foo();
       foo.myPrivateMethod(); //this works
   }
}

Итак -- если вызывающий объект является другим экземпляром моего же класса -- мой частный метод фактически доступен "снаружи", так сказать. Это на самом деле заставляет его казаться не таким уж частным.

в Ruby, с другой стороны, частный метод действительно должен быть частным только для текущего пример. Это то, что удаление опции явного приемника обеспечивает.

С другой стороны, я должен, конечно, отметить, что в сообществе Ruby довольно часто не использовать эти элементы управления видимостью вообще, учитывая, что Ruby дает вам способы обойти их в любом случае. В отличие от мира Java, тенденция заключается в том, чтобы сделать все доступным и доверять другим разработчикам, чтобы не испортить ситуацию.

сравнение элементов управления доступом Java с Ruby: если метод объявлен частным в Java, он может быть доступен только другими методами в том же классе. Если метод объявлен защищенным, он может быть доступен другим классам, которые существуют в том же пакете, а также подклассами класса в другом пакете. Когда метод является общедоступным, он виден всем. В Java концепция видимости управления доступом зависит от того, где находятся эти классы иерархия наследования / пакетов.

в то время как в Ruby, иерархия наследования или пакет/модуль не подходит. Все дело в том, какой объект является приемником метода.

для частного метода в Ruby он никогда не может быть вызван с явным приемником. Мы можем (только) вызвать частный метод с неявным приемником.

Это также означает, что мы можем вызвать частный метод из класса, в котором он объявлен, а также все подклассы этот класс.

class Test1
  def main_method
    method_private
  end

  private
  def method_private
    puts "Inside methodPrivate for #{self.class}"
  end
end

class Test2 < Test1
  def main_method
    method_private
  end
end

Test1.new.main_method
Test2.new.main_method

Inside methodPrivate for Test1
Inside methodPrivate for Test2

class Test3 < Test1
  def main_method
    self.method_private #We were trying to call a private method with an explicit receiver and if called in the same class with self would fail.
  end
end

Test1.new.main_method
This will throw NoMethodError

вы не можете вызвать Private метод из-за пределов иерархии классов, где он был определен.

защищенный метод может быть вызван с неявным приемником, как и private. Кроме того, защищенный метод также может быть вызван явным приемником (только), если приемник является "self" или "объектом того же класса".

 class Test1
  def main_method
    method_protected
  end

  protected
  def method_protected
    puts "InSide method_protected for #{self.class}"
  end
end

class Test2 < Test1
  def main_method
    method_protected # called by implicit receiver
  end
end

class Test3 < Test1
  def main_method
    self.method_protected # called by explicit receiver "an object of the same class"
  end
end


InSide method_protected for Test1
InSide method_protected for Test2
InSide method_protected for Test3


class Test4 < Test1
  def main_method
    Test2.new.method_protected # "Test2.new is the same type of object as self"
  end
end

Test4.new.main_method

class Test5
  def main_method
    Test2.new.method_protected
  end
end

Test5.new.main_method
This would fail as object Test5 is not subclass of Test1
Consider Public methods with maximum visibility

резюме

Public: публичные методы имеют максимум видимость

Protected: защищенный метод может быть вызван с неявным приемником, как и private. Кроме того, защищенный метод также может быть вызван явным приемником (только), если приемник является "self" или "объектом того же класса".

Private: для частного метода в Ruby он никогда не может быть вызван с явным приемником. Мы можем (только) вызвать частный метод с неявным приемником. Это также означает, что мы можем вызвать Private метод из класса объявлен в так же как и все подклассы этого класса.

часть причины, по которой частные методы могут быть доступны подклассами в Ruby, заключается в том, что наследование Ruby с классами является тонким сахарным покрытием над модулем includes - in Ruby, класс, по сути, является своего рода модулем, который обеспечивает наследование и т. д.

http://ruby-doc.org/core-2.0.0/Class.html

Это означает, что в основном подкласс "включает" родительский класс, так что эффективно функции родительского класса,в том числе частных функции, также определяются в подклассе.

в других языках программирования вызов метода включает в себя выделение имени метода вверх по иерархии родительского класса и поиск первого родительского класса, который отвечает на метод. Напротив, в Ruby, в то время как иерархия родительского класса все еще существует, методы родительского класса непосредственно включены в список методов подкласса.