Ruby Language
Ruby Access Modifiers

Introduktion

Instansvariabler och klassvariabler

Låt oss först börja med vad som är instansvariablerna: De uppför sig mer som egenskaper för ett objekt. De initialiseras på ett objektskapande. Instansvariabler är tillgängliga via instansmetoder. Per objekt har variabler per instans. Instansvariabler delas inte mellan objekt.

Sekvensklass har @from, @to och @by som instansvariabler.

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

Klassvariabler Behandla klassvariabel samma som statiska variabler i java, som delas mellan olika objekt i den klassen. Klassvariabler lagras i högminnet.

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

Delas mellan objekt och objekt1.

Jämförelse av förekomst- och klassvariablerna för Ruby mot 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
    }
}

Åtkomstkontroller

Jämförelse av åtkomstkontroller av Java mot Ruby: Om metoden förklaras privat i Java kan den bara nås med andra metoder inom samma klass. Om en metod förklaras skyddad kan den nås av andra klasser som finns inom samma paket samt av underklasser av klassen i ett annat paket. När en metod är offentlig är den synlig för alla. I Java beror synlighetskonceptet för åtkomstkontroll beroende på var dessa klasser ligger i arv / pakethierarkin.

Medan Ruby passar inte arvhierarkin eller paketet / modulen. Det handlar om vilket objekt som är mottagaren av en metod .

För en privat metod i Ruby kan den aldrig ringas med en uttrycklig mottagare. Vi kan (endast) ringa den privata metoden med en implicit mottagare.

Det betyder också att vi kan kalla en privat metod från en klass som deklareras i samt alla underklasser i denna klass.

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.

Skyddad metod kan kallas med en implicit mottagare, precis som privat. Dessutom kan skyddad metod också kallas av en uttrycklig mottagare (endast) om mottagaren är "själv" eller "ett objekt i samma klass".

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

Överväg offentliga metoder med maximal synlighet

Sammanfattning

1. Offentligt: Offentliga metoder har maximal synlighet

2. Skyddad: Skyddad metod kan ringas med en implicit mottagare, precis som privat. Dessutom kan skyddad metod också kallas av en uttrycklig mottagare (endast) om mottagaren är "själv" eller "ett objekt i samma klass".

3. Privat: För en privat metod i Ruby kan den aldrig ringas med en uttrycklig mottagare. Vi kan (endast) ringa den privata metoden med en implicit mottagare. Det betyder också att vi kan kalla en privat metod från en klass som deklareras i samt alla underklasser i denna klass.