Ruby Language
Modificadores de acceso Ruby

Introducción

Variables de instancia y variables de clase

Primero repasemos cuáles son las variables de instancia: se comportan más como propiedades para un objeto. Se inicializan en la creación de un objeto. Las variables de instancia son accesibles a través de métodos de instancia. Por objeto tiene variables por instancia. Las variables de instancia no se comparten entre objetos.

La clase de secuencia tiene @from, @to y @by como variables de instancia.

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

Variables de clase Trate la variable de clase igual que las variables estáticas de java, que se comparten entre los diversos objetos de esa clase. Las variables de clase se almacenan en la memoria del montón.

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

Compartido entre objeto y objeto1.

Comparando las variables de instancia y clase de Ruby con 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
    }
}

Controles de acceso

Comparación de los controles de acceso de Java contra Ruby: si el método se declara privado en Java, solo se puede acceder a él mediante otros métodos dentro de la misma clase. Si un método se declara protegido, puede ser accedido por otras clases que existen dentro del mismo paquete, así como por subclases de la clase en un paquete diferente. Cuando un método es público es visible para todos. En Java, el concepto de visibilidad de control de acceso depende de dónde residen estas clases en la jerarquía de herencia / paquete.

Mientras que en Ruby, la jerarquía de herencia o el paquete / módulo no encajan. Se trata de qué objeto es el receptor de un método .

Para un método privado en Ruby , nunca se puede llamar con un receptor explícito. Podemos (solo) llamar al método privado con un receptor implícito.

Esto también significa que podemos llamar a un método privado desde una clase en la que se declara, así como a todas las subclases de esta clase.

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.

El método protegido se puede llamar con un receptor implícito, como privado. Además, el método protegido también puede ser llamado por un receptor explícito (solo) si el receptor es "self" o "un objeto de la misma clase".

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

Considerar métodos públicos con la máxima visibilidad.

Resumen

1. Público: los métodos públicos tienen máxima visibilidad.

2. Protegido: el método protegido se puede llamar con un receptor implícito, como privado. Además, el método protegido también puede ser llamado por un receptor explícito (solo) si el receptor es "self" o "un objeto de la misma clase".

3. Privado: para un método privado en Ruby , nunca se puede llamar con un receptor explícito. Podemos (solo) llamar al método privado con un receptor implícito. Esto también significa que podemos llamar a un método privado desde una clase en la que se declara, así como a todas las subclases de esta clase.