Ruby Language
Modificateurs d'accès Ruby

Introduction

Variables d'instance et variables de classe

Relevons d'abord quelles sont les variables d'instance: elles se comportent plus comme des propriétés pour un objet. Ils sont initialisés sur une création d'objet. Les variables d'instance sont accessibles via des méthodes d'instance. Par objet a des variables par instance. Les variables d'instance ne sont pas partagées entre les objets.

La classe de séquence a les variables d'instance @from, @to et @by.

class Sequence
    include Enumerable

    def initialize(from, to, by)
        @from = from
        @to = to
        @by = by
    end

    def each
        x = @from
        while x < @to
            yield x
            x = x + @by
        end
    end

    def *(factor)
        Sequence.new(@from*factor, @to*factor, @by*factor)
    end

    def +(offset)
        Sequence.new(@from+offset, @to+offset, @by+offset)
    end
end

object = Sequence.new(1,10,2)
object.each do |x|
    puts x
end

Output:
1
3
5
7
9

object1 = Sequence.new(1,10,3)
object1.each do |x|
    puts x
end

Output:
1
4
7

Variables de classe Traiter la variable de classe de la même manière que les variables statiques de Java, qui sont partagées entre les différents objets de cette classe. Les variables de classe sont stockées dans la mémoire de tas.

class Sequence
    include Enumerable
    @@count = 0
    def initialize(from, to, by)
        @from = from
        @to = to
        @by = by
        @@count = @@count + 1
    end

    def each
        x = @from
        while x < @to
            yield x
            x = x + @by
        end
    end

    def *(factor)
        Sequence.new(@from*factor, @to*factor, @by*factor)
    end

    def +(offset)
        Sequence.new(@from+offset, @to+offset, @by+offset)
    end

    def getCount
        @@count
    end
end

object = Sequence.new(1,10,2)
object.each do |x|
    puts x
end

Output:
1
3
5
7
9

object1 = Sequence.new(1,10,3)
object1.each do |x|
    puts x
end

Output:
1
4
7

puts object1.getCount
Output: 2

Partagé entre objet et objet1.

En comparant les variables d'instance et de classe de Ruby contre Java:

Class Sequence{
    int from, to, by;
    Sequence(from, to, by){// constructor method of Java is equivalent to initialize method of ruby
        this.from = from;// this.from of java is equivalent to @from indicating currentObject.from
        this.to = to;
        this.by = by;
    }
    public void each(){
        int x = this.from;//objects attributes are accessible in the context of the object.
        while x > this.to
            x = x + this.by
    }
}

Contrôles d'accès

Comparaison des contrôles d'accès de Java avec Ruby: Si la méthode est déclarée privée en Java, elle ne peut être accédée 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 héritage / package.

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

Pour une méthode privée dans Ruby , il ne peut jamais être appelé avec un récepteur explicite. Nous pouvons (seulement) 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

You can never call the private method from outside the class hierarchy where it was defined.

La méthode protégée peut être appelée avec un récepteur implicite, comme si elle était privée. De plus, la méthode protégée peut également être appelée par un récepteur explicite (uniquement) si le destinataire 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

Envisager des méthodes publiques avec une visibilité maximale

Résumé

1. Public: Les méthodes publiques ont une visibilité maximale

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

3. Privé: pour une méthode privée dans Ruby , il ne peut jamais être appelé avec un récepteur explicite. Nous pouvons (seulement) 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.