Ruby Language
Ruby-Zugriffsmodifizierer

Einführung

Instanzvariablen und Klassenvariablen

Lassen Sie uns zunächst die Instanzenvariablen auffrischen: Sie verhalten sich mehr wie Eigenschaften eines Objekts. Sie werden bei einer Objekterstellung initialisiert. Instanzvariablen sind über Instanzmethoden zugänglich. Pro Objekt hat pro Instanzvariablen. Instanzvariablen werden nicht von Objekten gemeinsam genutzt.

Die Sequenzklasse enthält @from, @to und @by als Instanzvariablen.

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

Klassenvariablen Behandeln Klassenvariablen wie statische Variablen von Java, die von verschiedenen Objekten dieser Klasse gemeinsam genutzt werden. Klassenvariablen werden im Heap-Speicher gespeichert.

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

Geteilt zwischen Objekt und Objekt1.

Vergleich der Instanz- und Klassenvariablen von Ruby mit 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
    }
}

Zugriffskontrollen

Vergleich der Zugriffssteuerungen von Java gegen Ruby: Wenn die Methode in Java als privat deklariert ist, kann auf sie nur von anderen Methoden innerhalb derselben Klasse zugegriffen werden. Wenn eine Methode als geschützt deklariert ist, kann auf andere Klassen, die im selben Paket vorhanden sind, sowie auf Unterklassen der Klasse in einem anderen Paket zugegriffen werden. Wenn eine Methode öffentlich ist, ist sie für alle sichtbar. In Java hängt das Sichtbarkeitskonzept für die 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 .

Bei einer privaten 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 innerhalb einer Klasse aufrufen können, in der sie deklariert ist, sowie alle 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

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

Geschützte Methoden können wie private mit einem impliziten Empfänger aufgerufen werden. Außerdem kann die geschützte Methode (nur) von einem expliziten Empfänger aufgerufen werden, wenn der Empfänger "selbst" 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

Erwägen Sie öffentliche Methoden mit maximaler Sichtbarkeit

Zusammenfassung

1. Public: Öffentliche Methoden sind maximal sichtbar

2. Geschützt: Geschützte Methoden können wie private mit einem impliziten Empfänger aufgerufen werden. Außerdem kann die geschützte Methode (nur) von einem expliziten Empfänger aufgerufen werden, wenn der Empfänger "selbst" oder "ein Objekt derselben Klasse" ist.

3. Private: 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 innerhalb einer Klasse aufrufen können, in der sie deklariert ist, sowie alle Unterklassen dieser Klasse.