Ruby Language
Ruby Access Modifiers

Invoering

Instantievariabelen en klassenvariabelen

Laten we eerst eens kijken wat de instantievariabelen zijn: ze gedragen zich meer als eigenschappen voor een object. Ze worden geïnitialiseerd bij het maken van een object. Instantievariabelen zijn toegankelijk via instantiemethoden. Per object heeft variabelen per instantie. Instantievariabelen worden niet gedeeld tussen objecten.

Sequentieklasse heeft @from, @to en @by als de instantievariabelen.

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

Klasse variabelen Behandel klasse variabelen hetzelfde als statische variabelen van Java, die worden gedeeld tussen de verschillende objecten van die klasse. Klasse variabelen worden opgeslagen in heap geheugen.

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

Gedeeld tussen object en object1.

De instantie- en klassenvariabelen van Ruby vergelijken met 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
    }
}

Toegangscontrole

Vergelijking van toegangscontroles van Java met Ruby: als de methode in Java privé wordt verklaard, kan deze alleen worden benaderd door andere methoden binnen dezelfde klasse. Als een methode beschermd wordt verklaard, is deze toegankelijk voor andere klassen die binnen hetzelfde pakket bestaan, alsmede voor subklassen van de klasse in een ander pakket. Wanneer een methode openbaar is, is deze voor iedereen zichtbaar. In Java hangt het concept voor toegangscontrole af van waar deze klassen zich bevinden in de overerving / pakkethiërarchie.

Terwijl in Ruby de overervinghiërarchie of het pakket / de module niet passen. Het gaat erom welk object de ontvanger van een methode is .

Voor een privémethode in Ruby kan deze nooit worden aangeroepen met een expliciete ontvanger. We kunnen (alleen) de privémethode oproepen met een impliciete ontvanger.

Dit betekent ook dat we een privémethode kunnen aanroepen vanuit een klasse waarin deze wordt gedeclareerd, evenals in alle subklassen van deze 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.

De beveiligde methode kan worden opgeroepen met een impliciete ontvanger, zoals privé. Bovendien kan de beveiligde methode ook worden opgeroepen door een expliciete ontvanger (alleen) als de ontvanger "zelf" of "een object van dezelfde klasse" is.

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

Overweeg openbare methoden met maximale zichtbaarheid

Samenvatting

1. Openbaar: openbare methoden zijn maximaal zichtbaar

2. Beschermd: de beveiligde methode kan worden opgeroepen met een impliciete ontvanger, zoals privé. Bovendien kan de beveiligde methode ook worden opgeroepen door een expliciete ontvanger (alleen) als de ontvanger "zelf" of "een object van dezelfde klasse" is.

3. Privé: voor een privémethode in Ruby kan deze nooit worden opgeroepen met een expliciete ontvanger. We kunnen (alleen) de privémethode oproepen met een impliciete ontvanger. Dit betekent ook dat we een privémethode kunnen aanroepen vanuit een klasse waarin deze wordt gedeclareerd, evenals in alle subklassen van deze klasse.