Avant de lire cet article , je pensais que le contrôle d'accès dans Ruby fonctionnait comme ceci:

• public- accessible par n'importe quel objet (par exemple Obj.new.public_method)
• protected - ne peut être accédé qu'à partir de l'objet lui-même, ainsi que de toutes les sous-classes
• private - identique à protected, mais la méthode n'existe pas dans les sous-classes

Cependant, il semble que protectedet privateagir de la même manière, à l'exception du fait que vous ne pouvez pas appeler de privateméthodes avec un récepteur explicite (c'est-à-dire self.protected_methodfonctionne, mais self.private_methodne le fait pas).

À quoi ça sert? Quand y a-t-il un scénario où vous ne voudriez pas que votre méthode soit appelée avec un récepteur explicite?

protected Les méthodes peuvent être appelées par n'importe quelle instance de la classe de définition ou de ses sous-classes.

privateLes méthodes ne peuvent être appelées qu'à partir de l'objet appelant. Vous ne pouvez pas accéder directement aux méthodes privées d'une autre instance.

Voici un exemple pratique rapide:

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

some_methodne peut pas être privateici. Cela doit être protecteddû au fait que vous en avez besoin pour prendre en charge les récepteurs explicites. Vos méthodes d'assistance internes typiques peuvent généralement être privatecar elles n'ont jamais besoin d'être appelées comme ça.

Il est important de noter que cela est différent de la façon dont Java ou C ++ fonctionne. privatedans Ruby est similaire à protectedJava / C ++ en ce que les sous-classes ont accès à la méthode. Dans Ruby, il n'y a aucun moyen de restreindre l'accès à une méthode à partir de ses sous-classes comme vous pouvez le faire avec privateen Java.

La visibilité dans Ruby est en grande partie une "recommandation" de toute façon, car vous pouvez toujours accéder à une méthode en utilisant 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

La différence

• Tout le monde peut appeler vos méthodes publiques.
• Vous pouvez appeler vos méthodes protégées, ou un autre membre de votre classe (ou une classe descendante) peut appeler vos méthodes protégées de l'extérieur. Personne d'autre ne peut.
• Vous seul pouvez appeler vos méthodes privées, car elles ne peuvent être appelées qu'avec un récepteur implicite de self. Même vous ne pouvez pas appeler self.some_private_method; vous devez appeler private_methodavec selfimplicite.
  • iGEL souligne: "Il y a cependant une exception. Si vous avez une méthode privée age =, vous pouvez (et devez) l'appeler avec self pour la séparer des variables locales."
  • Depuis Ruby 2.7, le selfrécepteur peut être explicite, self.some_private_methodest autorisé. (Tout autre récepteur explicite est toujours interdit, même si la valeur d'exécution est la même que self.)

Dans Ruby, ces distinctions ne sont que des conseils d'un programmeur à l'autre. Les méthodes non publiques sont une façon de dire "Je me réserve le droit de changer cela; n'en dépendez pas." Mais vous avez toujours les ciseaux pointus sendet pouvez appeler n'importe quelle méthode que vous aimez.

Un bref tutoriel

# 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

Ensuite, vous pouvez exécuter ruby dwarf.rbet faire ceci:

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>

Méthodes privées dans Ruby:

Si une méthode est privée dans Ruby, elle ne peut pas être appelée par un récepteur (objet) explicite. Il ne peut être appelé qu'implicitement. Il peut être appelé implicitement par la classe dans laquelle il a été décrit ainsi que par les sous-classes de cette classe.

Les exemples suivants l'illustreront mieux:

1) Une classe Animal avec la méthode privée nom_classe

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

Dans ce cas:

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

2) Une sous-classe d'animal appelée amphibien:

class Amphibian < Animal
  def intro_amphibian
    class_name
  end 
end 

Dans ce cas:

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

Comme vous pouvez le voir, les méthodes privées ne peuvent être appelées qu'implicitement. Ils ne peuvent pas être appelés par des destinataires explicites. Pour la même raison, les méthodes privées ne peuvent pas être appelées en dehors de la hiérarchie de la classe de définition.

Méthodes protégées dans Ruby:

Si une méthode est protégée dans Ruby, elle peut être appelée implicitement à la fois par la classe de définition et ses sous-classes. De plus, ils peuvent également être appelés par un récepteur explicite tant que le récepteur est soi-même ou de la même classe que celui de soi:

1) Une classe animale avec la méthode protégée protect_me

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

Dans ce cas:

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

2) Une classe de mammifères héritée d'une classe animale

class Mammal < Animal
  def mammal_call
    protect_me
  end
end 

Dans ce cas

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

3) Une classe d'amphibiens héritée de la classe animale (identique à la classe de mammifères)

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

Dans ce cas

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

4) Une classe appelée Tree

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

Dans ce cas:

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

Considérez une méthode privée en Java. Il peut être appelé depuis la même classe, bien sûr, mais il peut également être appelé par une autre instance de cette même classe:

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

Donc - si l'appelant est une instance différente de ma même classe - ma méthode privée est en fait accessible de "l'extérieur", pour ainsi dire. Cela fait en fait que cela ne semble pas si privé.

Dans Ruby, d'autre part, une méthode privée est vraiment censée être privée uniquement pour l'instance actuelle. C'est ce que permet la suppression de l'option d'un récepteur explicite.

D'un autre côté, je dois certainement souligner qu'il est assez courant dans la communauté Ruby de ne pas utiliser du tout ces contrôles de visibilité, étant donné que Ruby vous donne quand même des moyens de les contourner. Contrairement au monde Java, la tendance est de tout rendre accessible et de faire confiance aux autres développeurs pour ne pas gâcher les choses.

Une partie de la raison pour laquelle les méthodes privées peuvent être accédées par les sous-classes dans Ruby est que l'héritage de Ruby avec les classes est mince en sucre par rapport aux modules inclus - dans Ruby, une classe, en fait, est une sorte de module qui fournit l'héritage, etc.

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

Cela signifie que fondamentalement, une sous-classe "inclut" la classe parente de sorte que les fonctions de la classe parente, y compris les fonctions privées , soient également définies dans la sous-classe.

Dans d'autres langages de programmation, l'appel d'une méthode implique de faire remonter le nom de la méthode dans une hiérarchie de classes parente et de trouver la première classe parente qui répond à la méthode. En revanche, dans Ruby, alors que la hiérarchie des classes parentes est toujours là, les méthodes de la classe parente sont directement incluses dans la liste des méthodes de la sous-classe définie.

Comparaison des contrôles d'accès de Java par rapport à Ruby: Si la méthode est déclarée privée en Java, elle n'est accessible que par d'autres méthodes de la même classe. Si une méthode est déclarée protégée, elle peut être accédée par d'autres classes qui existent dans le même package ainsi que par des sous-classes de la classe dans un package différent. Lorsqu'une méthode est publique, elle est visible par tous. En Java, le concept de visibilité du contrôle d'accès dépend de l'emplacement de ces classes dans la hiérarchie d'héritage / package.

Alors que dans Ruby, la hiérarchie d'héritage ou le package / module ne correspondent pas. Tout dépend de quel objet est le récepteur d'une méthode.

Pour une méthode privée dans Ruby, elle ne peut jamais être appelée avec un récepteur explicite. Nous pouvons (uniquement) appeler la méthode privée avec un récepteur implicite.

Cela signifie également que nous pouvons appeler une méthode privée depuis une classe dans laquelle elle est déclarée ainsi que toutes les sous-classes de cette classe.

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

Vous ne pouvez jamais appeler la méthode privée depuis l'extérieur de la hiérarchie de classes où elle a été définie.

La méthode protégée peut être appelée avec un récepteur implicite, comme comme private. De plus, la méthode protégée peut également être appelée par un récepteur explicite (uniquement) si le récepteur est "self" ou "un objet de la même classe".

 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

Résumé

Public: les méthodes publiques ont une visibilité maximale

Protégé: la méthode protégée peut être appelée avec un récepteur implicite, comme comme private. De plus, la méthode protégée peut également être appelée par un récepteur explicite (uniquement) si le récepteur est "self" ou "un objet de la même classe".

Private: pour une méthode privée dans Ruby, elle ne peut jamais être appelée avec un récepteur explicite. Nous pouvons (uniquement) appeler la méthode privée avec un récepteur implicite. Cela signifie également que nous pouvons appeler une méthode privée depuis une classe dans laquelle elle est déclarée ainsi que toutes les sous-classes de cette classe.

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. Liste d'objets
2. p test = Test.new ("test")
3. p test.name
4. p test.add_two (3)
5. Élément de liste
6. p test.view_address
7. pr = Result.new ("")
8. p r.nouveau_utilisateur