protected методы могут быть вызваны любым экземпляром определяющего класса или его подклассов.

private методы можно вызывать только из вызывающего объекта. Вы не можете напрямую получить доступ к закрытым методам другого экземпляра.

Вот небольшой практический пример:

def compare_to(x)
 self.some_method <=> x.some_method
end

some_method не может быть private здесь. Он должен быть protected, потому что он нужен для поддержки явных получателей. Вашими типичными внутренними вспомогательными методами обычно могут быть private, поскольку их никогда не нужно вызывать таким образом.

Важно отметить, что это отличается от того, как работает Java или C ++. private в Ruby похож на protected в Java / C ++ в том, что подклассы имеют доступ к методу. В Ruby нет способа ограничить доступ к методу из его подклассов, как это можно сделать с private в Java.

В любом случае видимость в Ruby в основном является «рекомендацией», поскольку вы всегда можете получить доступ к методу, используя send:

irb(main):001:0> class A
irb(main):002:1>   private
irb(main):003:1>   def not_so_private_method
irb(main):004:2>     puts "Hello World"
irb(main):005:2>   end
irb(main):006:1> end
=> nil

irb(main):007:0> foo = A.new
=> #<A:0x31688f>

irb(main):009:0> foo.send :not_so_private_method
Hello World
=> nil

Разница

• Кто угодно может вызывать ваши общедоступные методы.
• Вы можете вызывать свои защищенные методы, или другой член вашего класса (или класс-потомок) может вызывать ваши защищенные методы извне. Никто другой не может.
• Only you can call your private methods, because they can only be called with an implicit receiver of self. Even you cannot call self.some_private_method; you must call private_method with self implied.
  • iGEL points out: "There is one exception, however. If you have a private method age=, you can (and have to) call it with self to separate it from local variables."
  • Поскольку Ruby 2.7, self получатель может быть явным, self.some_private_method разрешено. (Любой другой явный получатель по-прежнему запрещен, даже если значение времени выполнения такое же, как 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) Класс Animal с частным методом 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) Подкласс Animal под названием Amphibian:

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, он может вызываться неявно как определяющим классом, так и его подклассами. Кроме того, они также могут вызываться явным получателем, если получатель является самим собой или принадлежит к тому же классу, что и сам:

1) Класс Animal с защищенным методом 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) Класс амфибий, унаследованный от класса Animal (то же, что и класс млекопитающих).

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) Класс под названием Tree

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, существует тенденция делать все доступным и доверять другим разработчикам, чтобы они ничего не облажались.

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

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

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

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

Сравнение средств управления доступом 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

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

Защищенный метод может вызываться с неявным получателем, как и частный. Кроме того, защищенный метод также может быть вызван явным получателем (только), если получатель является «самим собой» или «объектом того же класса».

 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: открытые методы имеют максимальную видимость

Защищенный: Защищенный метод может быть вызван с неявным получателем, как и частный. Кроме того, защищенный метод также может быть вызван явным получателем (только), если получатель является «самим собой» или «объектом того же класса».

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

First Three types of access specifiers and those define thier scope.
1.Public    ->  Access anywhere out side the class.
2.Private   ->  Can not access outside the class. 
3.Protected ->  This Method not access anywhere this method define 
                scope.

But i have a solution for this problem for all method how to access explain in depth. 

class Test
attr_reader :name
def initialize(name)
  @name = name
end

def add_two(number)
  @number = number 
end

def view_address
  address("Anyaddress")
end

private 
def address(add)
   @add = add
end

protected 
def user_name(name)
  # p 'call method'
  @name = name
end
end

class Result < Test
def new_user
  user_name("test355")
end
end

1. Список объектов
2. p test = Test.new ("тест")
3. p test.name
4. p test.add_two (3)
5. Пункт списка
6. p test.view_address
7. p r = Result.new ("")
8. p r.new_user

Какая разница?

Объяснение частных методов

@freddie = Person.new
@freddie.hows_it_going?
# => "oh dear, i'm in great pain!"

class Person   
    # public method
    def hows_it_going?
        how_are_your_underpants_feeling?
    end

    private

    def how_are_your_underpants_feeling? # private method
        puts "oh dear, i'm in great pain!"
    end
end

Мы можем спросить Фредди, как дела, учитывая, что это общедоступный метод. Это совершенно верно. И это нормально и принято.

Но ... единственный человек, который может знать, как обстоят дела с трусами Фредди, - это сам Фредди. Случайным незнакомцам не следует лезть в трусы Фредди и проверять ситуацию - нет, нет - это очень, очень личное, и мы не хотим раскрывать то, что личное, внешнему миру.

@freddie.how_are_your_underpants_feeling?
# => # NoMethodError: private method `how_are_your_underpants_feeling?' called

Объяснение защищенных методов

Учти это:

class Person
    
    protected

    def gimme_your_credit_card! # protected method
        puts "Fine. Whatever. Here it is: 1234-4567-8910"
    end
end

class Rib < Person
end

class Wife < Rib # wife inherits from Rib
    def i_am_buying_another_handbag_with_your_card(husband)        
        husband.gimme_your_credit_card!
    end
end

@husband = Person.new
@mrs = Wife.new
@mrs.i_am_buying_another_handbag_with_your_card(@husband)
# => puts "Fine. Whatever. Here it is: 1234-4567-8910"

Мы в некоторой степени согласны с mrs получением данных нашей кредитной карты, учитывая, что mrs - это плоть от нашей плоти, унаследованная от Person, но мы не хотим, чтобы случайные люди получали доступ к данным нашей кредитной карты.

Если бы мы попытались сделать это вне подкласса, ничего не вышло:

@mrs = Wife.new
@mrs.gimme_your_credit_card!
# => protected method gimme_your_credit_card! called for #<Wife:0x00005567b5865818> (NoMethodError)

Резюме

• частные методы могут быть вызваны только изнутри и без явного получателя. (Строго говоря, вы можете получить доступ к частному методу, используя немного рубиновой магии, но я пока проигнорирую это).
• защищенные методы могут вызываться внутри подклассов.
• Я использовал примеры / аналогии, чтобы помочь вам лучше запомнить.