Zanim przeczytałem ten artykuł , pomyślałem, że kontrola dostępu w Rubim działa tak:

• public- może być dostępny przez dowolny obiekt (np. Obj.new.public_method)
• protected - można uzyskać dostęp tylko z samego obiektu, a także z dowolnych podklas
• private - to samo, co chronione, ale metoda nie istnieje w podklasach

Jednak wydaje się, że protectedi privatezachowujesz się tak samo, z wyjątkiem faktu, że nie możesz wywoływać privatemetod z jawnym odbiornikiem (tj. self.protected_methodDziała, ale self.private_methodnie działa).

Jaki to ma sens? Kiedy istnieje scenariusz, w którym nie chcesz, aby Twoja metoda była wywoływana z jawnym odbiornikiem?

protected metody mogą być wywoływane przez dowolną instancję klasy definiującej lub jej podklas.

privatemetody mogą być wywoływane tylko z poziomu obiektu wywołującego. Nie możesz uzyskać bezpośredniego dostępu do metod prywatnych innej instancji.

Oto szybki praktyczny przykład:

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

some_methodnie może privatetu być . Musi tak być, protectedponieważ potrzebujesz go do obsługi jawnych odbiorników. Twoje typowe wewnętrzne metody pomocnicze mogą być zwykle takie, privateponieważ nigdy nie trzeba ich tak nazywać.

Należy zauważyć, że różni się to od sposobu działania Java lub C ++. privatew Rubim działa podobnie jak protectedw Javie / C ++, ponieważ podklasy mają dostęp do metody. W Rubim nie ma sposobu na ograniczenie dostępu do metody z jej podklas, tak jak privatew Javie.

Widoczność w Rubim i tak jest w dużej mierze „zaleceniem”, ponieważ zawsze możesz uzyskać dostęp do metody za pomocą 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

Różnica

• Każdy może wywołać Twoje metody publiczne.
• Możesz wywołać metody chronione lub inny członek Twojej klasy (lub klasa podrzędna) może wywołać metody chronione z zewnątrz. Nikt inny nie może.
• Tylko Ty możesz wywołać swoje metody prywatne, ponieważ można je wywołać tylko z niejawnym odbiornikiem self. Nawet ty nie możesz zadzwonić self.some_private_method; musisz zadzwonić private_methodz selfdomniemaniem.
  • iGEL wskazuje: „Jest jednak jeden wyjątek. Jeśli masz prywatną metodę age =, możesz (i musisz) wywołać ją z self, aby oddzielić ją od zmiennych lokalnych”.
  • Od Ruby 2.7self odbiornik może być jawne, self.some_private_methodjest dozwolone. (Każdy inny jawny odbiornik jest nadal niedozwolony, nawet jeśli wartość środowiska wykonawczego jest taka sama jak self).

W Rubim te rozróżnienia są po prostu radami jednego programisty dla drugiego. Metody niepubliczne to sposób na powiedzenie: „Zastrzegam sobie prawo do zmiany tego; nie polegaj na tym”. Ale nadal masz ostre nożyczki sendi możesz przywołać dowolną metodę.

Krótki poradnik

# 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

Następnie możesz biegać ruby dwarf.rbi zrobić to:

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>

Metody prywatne w Rubim:

Jeśli metoda jest prywatna w Rubim, to nie może być wywołana przez jawnego odbiorcę (obiekt). Można to wywołać tylko niejawnie. Może być wywoływana niejawnie przez klasę, w której została opisana, jak również przez jej podklasy.

Poniższe przykłady zilustrują to lepiej:

1) Klasa Animal z prywatną metodą nazwa_klasy

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

W tym przypadku:

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

2) Podklasa zwierząt zwanych płazami:

class Amphibian < Animal
  def intro_amphibian
    class_name
  end 
end 

W tym przypadku:

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

Jak widać, metody prywatne można wywołać tylko niejawnie. Nie mogą być wywoływane przez jawnych odbiorców. Z tego samego powodu metody prywatne nie mogą być wywoływane poza hierarchią klasy definiującej.

Metody chronione w Rubim:

Jeśli metoda jest chroniona w Rubim, to może zostać wywołana niejawnie zarówno przez klasę definiującą, jak i jej podklasy. Dodatkowo mogą być wywoływane przez jawnego odbiorcę, o ile odbiorca jest sobą lub jest tej samej klasy co ja:

1) Klasa Animal z chronioną metodą protect_me

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

W tym przypadku:

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

2) Klasa ssaków dziedziczona z klasy zwierząt

class Mammal < Animal
  def mammal_call
    protect_me
  end
end 

W tym przypadku

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

3) Klasa płazów dziedziczona z klasy zwierząt (taka sama jak klasa ssaków)

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

W tym przypadku

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

4) Klasa o nazwie Drzewo

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

W tym przypadku:

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

Rozważ prywatną metodę w Javie. Można go oczywiście wywołać z poziomu tej samej klasy, ale może też zostać wywołany przez inną instancję tej samej klasy:

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
   }
}

Tak więc - jeśli wywołujący jest inną instancją tej samej klasy - moja metoda prywatna jest faktycznie dostępna z „zewnątrz”, że tak powiem. To faktycznie sprawia, że ​​nie wydaje się to aż tak prywatne.

Z drugiej strony, w Rubim metoda prywatna ma być prywatna tylko dla bieżącej instancji. To właśnie zapewnia usunięcie opcji jawnego odbiornika.

Z drugiej strony, z pewnością powinienem zauważyć, że w społeczności Ruby dość często nie używa się tych kontrolek widoczności, biorąc pod uwagę, że Ruby i tak daje ci sposoby na obejście ich. W przeciwieństwie do świata Java, istnieje tendencja, aby wszystko było dostępne i ufać innym programistom, że nie schrzanią sprawy.

Jednym z powodów, dla których prywatne metody mogą być dostępne przez podklasy w Rubim, jest to, że dziedziczenie Rubiego z klasami jest cienką powłoką cukrową nad zawartością modułu - w Rubim klasa jest w rzeczywistości rodzajem modułu, który zapewnia dziedziczenie itp.

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

Oznacza to, że w zasadzie podklasa „zawiera” klasę nadrzędną, tak że efektywnie funkcje klasy nadrzędnej, w tym funkcje prywatne , są również zdefiniowane w podklasie.

W innych językach programowania wywołanie metody obejmuje propagowanie nazwy metody w górę hierarchii klas nadrzędnych i znalezienie pierwszej klasy nadrzędnej, która odpowiada na metodę. W przeciwieństwie do tego, w Rubim, podczas gdy hierarchia klas nadrzędnych nadal istnieje, metody klasy nadrzędnej są bezpośrednio włączane do listy metod zdefiniowanej przez podklasę.

Porównanie kontroli dostępu Javy z Rubim: Jeśli metoda jest zadeklarowana jako prywatna w Javie, można uzyskać do niej dostęp tylko za pomocą innych metod w tej samej klasie. Jeśli metoda jest zadeklarowana jako chroniona, można uzyskać do niej dostęp z innych klas, które istnieją w tym samym pakiecie, jak również przez podklasy klasy w innym pakiecie. Gdy metoda jest publiczna, jest widoczna dla wszystkich. W Javie koncepcja widoczności kontroli dostępu zależy od tego, gdzie te klasy znajdują się w hierarchii dziedziczenia / pakietu.

Podczas gdy w Rubim hierarchia dziedziczenia lub pakiet / moduł nie pasują. Wszystko zależy od tego, który obiekt jest odbiorcą metody.

W przypadku metody prywatnej w Rubim nigdy nie można jej wywołać z jawnym odbiornikiem. Możemy (tylko) wywołać metodę prywatną z niejawnym odbiornikiem.

Oznacza to również, że możemy wywołać metodę prywatną z klasy, w której jest zadeklarowana, jak również ze wszystkich podklas tej klasy.

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

Nigdy nie można wywołać metody prywatnej spoza hierarchii klas, w której została zdefiniowana.

Metoda chroniona może zostać wywołana z niejawnym odbiornikiem, tak jak private. Dodatkowo metoda chroniona może być również wywołana przez jawnego odbiorcę (tylko), jeśli odbiorcą jest „self” lub „obiekt tej samej klasy”.

 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

Podsumowanie

Publiczne: metody publiczne są maksymalnie widoczne

Protected: Metoda chroniona może być wywołana z niejawnym odbiornikiem, tak jak private. Dodatkowo metoda chroniona może być również wywołana przez jawnego odbiorcę (tylko), jeśli odbiorcą jest „self” lub „obiekt tej samej klasy”.

Prywatna: W przypadku metody prywatnej w Rubim nigdy nie można jej wywołać z jawnym odbiornikiem. Możemy (tylko) wywołać metodę prywatną z niejawnym odbiornikiem. Oznacza to również, że możemy wywołać metodę prywatną z klasy, w której jest zadeklarowana, jak również ze wszystkich podklas tej klasy.

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. Lista obiektów
2. p test = Test.new ("test")
3. p nazwa.testu
4. p test.add_two (3)
5. Element listy
6. p test.view_address
7. pr = Result.new („”)
8. p r.new_user