Ответ 1

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

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

Вот быстрый практический пример:

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

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

Важно отметить, что это отличается от того, как работает Java или С++. private в Ruby аналогичен protected в Java/С++ в том, что подклассы имеют доступ к этому методу. В 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

Ответ 2

Разница

• Любой пользователь может вызвать ваши общедоступные методы.
• Вы можете вызвать защищенные методы, или, другой член вашего класса (или класс потомков) может вызывать ваши защищенные методы извне. Никто другой не может.
• Только вы можете вызывать свои частные методы, потому что их можно вызвать только с неявным приемником 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>

Ответ 3

Частные методы в 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) A Класс животных с защищенным методом 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>

Ответ 4

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

Ответ 5

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

Резюме

Публикация: общедоступные методы имеют максимальную видимость

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

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

Ответ 6

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

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

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

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

Ответ 7

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

конец

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

конец

1. Список объектов
2. p test = Test.new("test")
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