Bevor ich diesen Artikel las , dachte ich, dass die Zugriffskontrolle in Ruby folgendermaßen funktioniert:

• public- kann von jedem Objekt zugegriffen werden (z Obj.new.public_method)
• protected - kann nur vom Objekt selbst sowie von Unterklassen aus aufgerufen werden
• private - wie protected, aber die Methode ist in Unterklassen nicht vorhanden

Es scheint jedoch, dass protectedund privatedasselbe zu tun ist, außer dass Sie keine privateMethoden mit einem expliziten Empfänger aufrufen können (dh self.protected_methodfunktioniert, aber self.private_methodnicht funktioniert).

Was ist der Sinn davon? Wann gibt es ein Szenario, in dem Ihre Methode nicht mit einem expliziten Empfänger aufgerufen werden soll?

protected Methoden können von jeder Instanz der definierenden Klasse oder ihrer Unterklassen aufgerufen werden.

privateMethoden können nur innerhalb des aufrufenden Objekts aufgerufen werden. Sie können nicht direkt auf die privaten Methoden einer anderen Instanz zugreifen.

Hier ist ein kurzes praktisches Beispiel:

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

some_methodkann nicht privatehier sein. Dies muss protecteddaran liegen, dass Sie explizite Empfänger unterstützen müssen. Ihre typischen internen Hilfsmethoden können normalerweise sein, privateda sie niemals so aufgerufen werden müssen.

Es ist wichtig zu beachten, dass sich dies von der Funktionsweise von Java oder C ++ unterscheidet. privatein Ruby ähnelt protectedin Java / C ++ darin, dass Unterklassen Zugriff auf die Methode haben. In Ruby gibt es keine Möglichkeit, den Zugriff auf eine Methode aus ihren Unterklassen zu beschränken, wie dies privatein Java möglich ist.

Die Sichtbarkeit in Ruby ist sowieso weitgehend eine "Empfehlung", da Sie jederzeit Zugriff auf eine Methode erhalten können, indem Sie 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

Der Unterschied

• Jeder kann Ihre öffentlichen Methoden aufrufen.
• Sie können Ihre geschützten Methoden aufrufen, oder ein anderes Mitglied Ihrer Klasse (oder eine untergeordnete Klasse) kann Ihre geschützten Methoden von außen aufrufen. Niemand sonst kann.
• Nur Sie können Ihre privaten Methoden aufrufen, da sie nur mit einem impliziten Empfänger von aufgerufen werden können self. Auch Sie können nicht anrufen self.some_private_method; Sie müssen private_methodmit selfimplizierten anrufen .
  • iGEL weist darauf hin: "Es gibt jedoch eine Ausnahme. Wenn Sie eine private Methode age = haben, können (und müssen) Sie diese mit self aufrufen, um sie von lokalen Variablen zu trennen."
  • Seit Ruby 2.7 kann der selfEmpfänger explizit sein, self.some_private_methodist erlaubt. (Jeder andere explizite Empfänger ist weiterhin nicht zulässig, auch wenn der Laufzeitwert derselbe ist wie self.)

In Ruby sind diese Unterscheidungen nur Ratschläge von einem Programmierer zum anderen. Nicht öffentliche Methoden sind eine Art zu sagen: "Ich behalte mir das Recht vor, dies zu ändern; hängen Sie nicht davon ab." Aber Sie haben immer noch die scharfe Schere sendund können jede Methode aufrufen, die Sie mögen.

Ein kurzes Tutorial

# 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

Dann können Sie laufen ruby dwarf.rbund dies tun:

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>

Private Methoden in Ruby:

Wenn eine Methode in Ruby privat ist, kann sie nicht von einem expliziten Empfänger (Objekt) aufgerufen werden. Es kann nur implizit aufgerufen werden. Es kann implizit von der Klasse, in der es beschrieben wurde, sowie von den Unterklassen dieser Klasse aufgerufen werden.

Die folgenden Beispiele veranschaulichen dies besser:

1) Eine Tierklasse mit der privaten Methode class_name

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

In diesem Fall:

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

2) Eine Unterklasse von Tieren namens Amphibien:

class Amphibian < Animal
  def intro_amphibian
    class_name
  end 
end 

In diesem Fall:

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

Wie Sie sehen, können private Methoden nur implizit aufgerufen werden. Sie können nicht von expliziten Empfängern aufgerufen werden. Aus dem gleichen Grund können private Methoden nicht außerhalb der Hierarchie der definierenden Klasse aufgerufen werden.

Geschützte Methoden in Ruby:

Wenn eine Methode in Ruby geschützt ist, kann sie implizit sowohl von der definierenden Klasse als auch von ihren Unterklassen aufgerufen werden. Zusätzlich können sie auch von einem expliziten Empfänger aufgerufen werden, solange der Empfänger selbst oder von derselben Klasse wie der von sich selbst ist:

1) Eine Tierklasse mit der geschützten Methode protected_me

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

In diesem Fall:

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

2) Eine Säugetierklasse, die von der Tierklasse geerbt wird

class Mammal < Animal
  def mammal_call
    protect_me
  end
end 

In diesem Fall

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

3) Eine Amphibienklasse, die von der Tierklasse geerbt wurde (wie die Säugetierklasse)

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

In diesem Fall

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

4) Eine Klasse namens Tree

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

In diesem Fall:

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

Betrachten Sie eine private Methode in Java. Es kann natürlich aus derselben Klasse heraus aufgerufen werden, aber es kann auch von einer anderen Instanz derselben Klasse aufgerufen werden:

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

Wenn der Aufrufer also eine andere Instanz derselben Klasse ist, ist meine private Methode sozusagen von außen zugänglich. Dies lässt es tatsächlich nicht allzu privat erscheinen.

In Ruby hingegen soll eine private Methode nur für die aktuelle Instanz privat sein. Dies bietet das Entfernen der Option eines expliziten Empfängers.

Auf der anderen Seite sollte ich auf jeden Fall darauf hinweisen, dass es in der Ruby-Community ziemlich üblich ist, diese Sichtbarkeitssteuerelemente überhaupt nicht zu verwenden, da Ruby Ihnen sowieso Möglichkeiten bietet, sie zu umgehen. Anders als in der Java-Welt besteht die Tendenz darin, alles zugänglich zu machen und anderen Entwicklern zu vertrauen, dass sie nichts vermasseln.

Ein Grund dafür, dass Unterklassen in Ruby auf private Methoden zugreifen können, besteht darin, dass die Ruby-Vererbung mit Klassen über Modul-Includes dünn beschichtet ist. In Ruby ist eine Klasse tatsächlich eine Art Modul, das Vererbung usw. bereitstellt.

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

Dies bedeutet, dass eine Unterklasse im Grunde genommen die übergeordnete Klasse "einschließt", so dass die Funktionen der übergeordneten Klasse, einschließlich privater Funktionen , effektiv auch in der Unterklasse definiert werden.

In anderen Programmiersprachen umfasst das Aufrufen einer Methode das Aufblasen des Methodennamens in eine übergeordnete Klassenhierarchie und das Suchen der ersten übergeordneten Klasse, die auf die Methode reagiert. Im Gegensatz dazu werden in Ruby, während die übergeordnete Klassenhierarchie noch vorhanden ist, die Methoden der übergeordneten Klasse direkt in die Liste der Methoden der Unterklasse aufgenommen, die definiert wurden.

Vergleich der Zugriffssteuerungen von Java mit Ruby: Wenn die Methode in Java als privat deklariert ist, können nur andere Methoden innerhalb derselben Klasse auf sie zugreifen . Wenn eine Methode als geschützt deklariert ist, können andere Klassen, die im selben Paket vorhanden sind, sowie Unterklassen der Klasse in einem anderen Paket auf sie zugreifen. Wenn eine Methode öffentlich ist, ist sie für alle sichtbar. In Java hängt das Sichtbarkeitskonzept der Zugriffssteuerung davon ab, wo diese Klassen in der Vererbungs- / Pakethierarchie liegen.

Während in Ruby die Vererbungshierarchie oder das Paket / Modul nicht passen. Es geht darum, welches Objekt der Empfänger einer Methode ist.

Für eine private Methode in Ruby kann sie niemals mit einem expliziten Empfänger aufgerufen werden. Wir können die private Methode (nur) mit einem impliziten Empfänger aufrufen.

Dies bedeutet auch, dass wir eine private Methode aus einer Klasse heraus aufrufen können, in der sie deklariert ist, sowie aus allen Unterklassen dieser Klasse.

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

Sie können die private Methode niemals von außerhalb der Klassenhierarchie aufrufen, in der sie definiert wurde.

Die geschützte Methode kann mit einem impliziten Empfänger wie privat aufgerufen werden. Darüber hinaus kann eine geschützte Methode auch (nur) von einem expliziten Empfänger aufgerufen werden, wenn der Empfänger "self" oder "ein Objekt derselben Klasse" ist.

 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

Zusammenfassung

Öffentlich: Öffentliche Methoden sind maximal sichtbar

Geschützt: Die geschützte Methode kann mit einem impliziten Empfänger wie privat aufgerufen werden. Darüber hinaus kann eine geschützte Methode auch (nur) von einem expliziten Empfänger aufgerufen werden, wenn der Empfänger "self" oder "ein Objekt derselben Klasse" ist.

Privat: Für eine private Methode in Ruby kann sie niemals mit einem expliziten Empfänger aufgerufen werden. Wir können die private Methode (nur) mit einem impliziten Empfänger aufrufen. Dies bedeutet auch, dass wir eine private Methode aus einer Klasse heraus aufrufen können, in der sie deklariert ist, sowie aus allen Unterklassen dieser Klasse.

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. Objektliste
2. p test = Test.new ("test")
3. p test.name
4. p test.add_two (3)
5. Listenpunkt
6. p test.view_address
7. pr = Result.new ("")
8. p r.new_user