Ruby Language
Modyfikatory Ruby Access

Wprowadzenie

Zmienne instancji i zmienne klas

Najpierw pomalujmy, czym są zmienne instancji: zachowują się bardziej jak właściwości obiektu. Są inicjowane przy tworzeniu obiektu. Zmienne instancji są dostępne za pomocą metod instancji. Na obiekt ma zmienne na instancję. Zmienne instancji nie są współużytkowane między obiektami.

Klasa sekwencji ma @from, @to i @by jako zmienne instancji.

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

Zmienne klasy Traktuj zmienną klasy tak samo, jak zmienne statyczne Java, które są wspólne dla różnych obiektów tej klasy. Zmienne klasy są przechowywane w pamięci sterty.

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

Współużytkowane przez obiekt i obiekt 1.

Porównanie zmiennych instancji i klas Ruby z Javą:

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
    }
}

Kontrola dostępu

Porównanie kontroli dostępu Java z Ruby: Jeśli metoda jest zadeklarowana jako prywatna w Javie, dostęp do niej można uzyskać tylko innymi metodami w tej samej klasie. Jeśli metoda zostanie uznana za chronioną, dostęp do niej mogą uzyskać inne klasy, które istnieją w tym samym pakiecie, a także podklasy klasy w innym pakiecie. Gdy metoda jest publiczna, jest widoczna dla wszystkich. W Javie koncepcja widoczności kontroli dostępu zależy od tego, gdzie znajdują się te klasy w hierarchii dziedziczenia / pakietu.

Natomiast w Ruby hierarchia dziedziczenia lub pakiet / moduł nie pasują. Wszystko zależy od tego, który obiekt jest odbiorcą metody .

W przypadku prywatnej metody w Ruby nigdy nie można jej wywołać z jawnym odbiornikiem. Możemy (tylko) wywołać metodę prywatną z niejawnym odbiornikiem.

Oznacza to również, że możemy wywołać metodę prywatną z klasy, w której jest zadeklarowana, a także ze wszystkich podklas tej klasy.

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.

Metoda chroniona może być wywoływana z niejawnym odbiornikiem, tak jak prywatny. Ponadto metoda chroniona może być również wywoływana przez jawny odbiornik (tylko), jeśli odbiornik jest „własny” lub „obiekt tej samej klasy”.

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

Rozważ metody publiczne z maksymalną widocznością

streszczenie

1. Publiczne: metody publiczne mają maksymalną widoczność

2. Protected: Metoda chroniona może być wywoływana z niejawnym odbiornikiem, tak jak prywatny. Ponadto metoda chroniona może być również wywoływana przez jawny odbiornik (tylko), jeśli odbiornik jest „własny” lub „obiekt tej samej klasy”.

3. Prywatne: W przypadku prywatnej metody w Ruby nigdy nie można jej wywołać z jawnym odbiornikiem. Możemy (tylko) wywołać metodę prywatną z niejawnym odbiornikiem. Oznacza to również, że możemy wywołać metodę prywatną z klasy, w której jest zadeklarowana, a także ze wszystkich podklas tej klasy.