Pourquoi Ruby ont à la fois privé et protégé méthodes?

protected méthodes peuvent être appelées par une instance de la classe de définition ou de ses sous-classes.

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

Voici un petit exemple pratique:

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

some_method ne peut pas être private ici. Il doit être protected parce que vous avez besoin de soutien explicite des récepteurs. Votre intérieur typique des méthodes d'assistance peuvent généralement être private puisqu'ils n'ont jamais besoin d'être appelé comme ça.

Il est important de noter que ceci est différent de la façon dont Java ou C++ fonctionne. private en Ruby, c'est similaire à protected en Java/C++ dans les sous-classes ont accès à cette méthode. En Ruby, il n'existe aucun moyen de restreindre l'accès à une méthode à partir de ses sous-classes comme vous le pouvez avec private en Java.

Visibilité en Ruby, c'est en grande partie une "recommandation" de toute façon puisque vous pouvez toujours accéder à une méthode 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

Méthodes privées en Ruby:

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

Les exemples suivants illustrent mieux:

1) Un Animal de la classe avec une méthode privée class_name

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 de l'Animal appelé Amphibiens:

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 peut être appelé qu'implicitement. Ils ne peuvent pas être appelé explicitement par les récepteurs. Pour la même raison, les méthodes privées ne peut pas être appelé en dehors de la hiérarchie de la classe de définition.

Protégé Méthodes de Ruby:

Si une méthode est protégé en Ruby, alors il peut être appelé implicitement par à la fois la définition de la classe et de ses sous-classes. En outre, ils peuvent aussi être appelés par un explicite récepteur tant que le récepteur est de l'auto ou de la même classe que celle de l'auto:

1) Un Animal de la classe avec une 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 des mammifères qui est héritée de l'animal de la classe

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) Un amphibien de la classe héritée de l'Animal de la classe (même en tant que classe mammifère)

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 Arbre

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>

Comparaison des contrôles d'accès de Java contre Ruby: Si la méthode est déclarée privé en Java, il ne peut être accédé que par d'autres méthodes dans la même classe. Si une méthode est déclarée protégée, il peut être consulté par d'autres classes qui existent dans le même package ainsi que par les sous-classes de la classe dans un package différent. Lorsqu'une méthode est public, il est visible par tout le monde. En Java, le contrôle d'accès visibilité concept dépend de l'endroit où ces classes mensonge est dans l'héritage/paquet hiérarchie.

Alors que dans le Rubis, la hiérarchie d'héritage ou le module ne fonctionne pas. Il est tout au sujet de l'objet qui est le récepteur d'une méthode.

Pour une méthode privée en Ruby, il ne peut jamais être appelée explicitement avec un récepteur. Nous pouvons (uniquement), appelez la méthode privée avec un récepteur implicite.

Cela signifie également que nous pouvons appeler une méthode d'une classe, il est déclaré en tant que bien 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 pouvez ne jamais appeler la méthode privée de l'extérieur de la hiérarchie de classe où il a été défini.

Protégé méthode peut être appelée avec un récepteur implicite, comme privé. En outre protégé méthode peut aussi être appelée par un explicite récepteur (uniquement) si le récepteur est "auto" 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: Public les méthodes de maximum de visibilité

De la protection: Protégé méthode peut être appelée avec un récepteur implicite, comme privé. En outre protégé méthode peut aussi être appelée par un explicite récepteur (uniquement) si le récepteur est "auto" ou "un objet de la même classe".

Privé: Pour une méthode privée en Ruby, il ne peut jamais être appelée explicitement avec un récepteur. Nous pouvons (uniquement), appelez la méthode privée avec un récepteur implicite. Cela signifie également que nous pouvons appeler une méthode d'une classe, il est déclaré en tant que bien que toutes les sous-classes de cette classe.