Ruby Language
Modificatori di accesso rubino

introduzione

Variabili di istanza e variabili di classe

Iniziamo a rispolverare le variabili di istanza: si comportano più come proprietà di un oggetto. Sono inizializzati su una creazione di un oggetto. Le variabili di istanza sono accessibili tramite i metodi di istanza. Per oggetto ha variabili di istanza. Le variabili d'istanza non sono condivise tra oggetti.

La classe di sequenze ha @from, @to e @by come variabili di istanza.

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

Variabili di classe Tratta le variabili di classe come variabili statiche di java, che sono condivise tra i vari oggetti di quella classe. Le variabili di classe sono archiviate nella memoria heap.

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

Condiviso tra oggetto e oggetto1.

Confronto tra le istanze e le variabili di classe di Ruby contro 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
    }
}

Controlli di accesso

Confronto dei controlli di accesso di Java contro Ruby: se il metodo è dichiarato privato in Java, è possibile accedervi solo tramite altri metodi all'interno della stessa classe. Se un metodo è dichiarato protetto, è possibile accedervi da altre classi presenti nello stesso pacchetto e sottoclassi della classe in un pacchetto diverso. Quando un metodo è pubblico è visibile a tutti. In Java, il concetto di visibilità del controllo di accesso dipende da dove queste classi si trovano nella gerarchia ereditari / dei pacchetti.

Mentre in Ruby, la gerarchia dell'ereditarietà o il pacchetto / modulo non si adattano. È tutto su quale oggetto è il destinatario di un metodo .

Per un metodo privato in Ruby , non può mai essere chiamato con un ricevitore esplicito. Possiamo (solo) chiamare il metodo privato con un ricevitore implicito.

Ciò significa anche che possiamo chiamare un metodo privato all'interno di una classe dichiarata e di tutte le sottoclassi di questa 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.

Il metodo protetto può essere chiamato con un ricevitore implicito, come se fosse privato. Inoltre il metodo protetto può anche essere chiamato da un ricevitore esplicito (solo) se il ricevitore è "self" o "un oggetto della stessa 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

Considera i metodi pubblici con la massima visibilità

Sommario

1. Pubblico: i metodi pubblici hanno la massima visibilità

2. Protetto: il metodo protetto può essere chiamato con un ricevitore implicito, come se fosse privato. Inoltre il metodo protetto può anche essere chiamato da un ricevitore esplicito (solo) se il ricevitore è "self" o "un oggetto della stessa classe".

3. Privato: per un metodo privato in Ruby , non può mai essere chiamato con un ricevitore esplicito. Possiamo (solo) chiamare il metodo privato con un ricevitore implicito. Ciò significa anche che possiamo chiamare un metodo privato all'interno di una classe dichiarata e di tutte le sottoclassi di questa classe.