ruby - ¿Cuáles son las diferencias entre "privado", "público" y "métodos protegidos"?

access-specifier public-method

Question

Estoy aprendiendo Ruby, y he llegado a un punto en el que estoy confundido.

El libro que estoy usando habla de protected methods private , public y protected methods , pero todavía estoy un poco confundido. ¿Cuáles son las diferencias entre cada uno?

Answer 1

Al estudiar la información que he tomado de here , extendí las explicaciones a través de errores, y para mi opinión, ayuda a entender por qué y cómo usar protegido y no privado.

1) Protegido:

La línea num 12 falla porque el parámetro recibido es de otra clase, el mensaje de error es claro:

v.rb:12:in `=='': undefined method `sku'' for "Object of another class ==> crash":String (NoMethodError)

2) Privado:

Si se elimina de la línea 8 y 12, y cambio protegido para privado , crash porque en la línea 12, otro no sabe qué es sku :

v.rb:12:in `=='': private method `sku'' called for #<Product:0x00000001574e68 @name="Bread", @quantity=1> (NoMethodError)

El programa:

class Product
  attr_accessor :name, :quantity

  def initialize(name)
    @name = name
    @quantity = 1

    puts "The SKU is #{self.sku}"
  end

  def == (other)
    self.sku == other.sku
  end

  protected
    def sku
      name.crypt("yo")
    end
end

milk1 = Product.new("Milk")
milk2 = Product.new("Milk")
bread = Product.new("Bread")

puts milk1 == bread

puts milk1 == milk2

puts milk1 == "Object of another class ==> crash"

Answer 2

Consulte " Ruby Programming / Syntax / Classes " para obtener un ejemplo detallado y una explicación.

En pocas palabras, las diferencias entre private métodos private , public y protected son la visibilidad de ese método en el programa, algo así como de solo lectura, lectura y escritura, y casi invisible.

A diferencia de algunos de los otros idiomas, no puede ocultar por completo un método privado de Ruby, solo puede acceder a métodos privados para su instancia de objeto y no a ninguna otra instancia de objeto de una clase.

Público, por supuesto, es la accesibilidad total y los métodos suelen ser predeterminados para el público con algunas excepciones.

Los métodos protegidos son accesibles desde objetos de la misma clase o incluso niños, lo que no es el caso de un método privado.

Answer 3

Creo que analizar un receptor explícito es lo importante si tienes problemas para captar el concepto.

Un receptor explícito es un objeto que está aceptando un mensaje.

 person.get_name

persona es el receptor y el método "get_name" está dando instrucciones al objeto "persona" para realizar el método "get_name".

class Person
    attr_accessor :first_name, :last_name 

  def initialize(first_name, last_name)
    @first_name = first_name
    @last_name = last_name
    puts "And #{phone_number}" # Private method called when initialized
  end

  private 
  def phone_number
    return "XXX-XXX-XXXX"
  end
end


p p1 = Person.new("mike", "jones")


p p1.phone_number # Not within the context of the object instance.

Cuando un método es privado, solo puede ser utilizado por otros métodos dentro del objeto en cuya clase está definido.

Answer 4

La diferencia estará en Visibilidad y cómo se ven afectados por la herencia :

Visibilidad :

|| En cualquier lugar || Se puede acceder al público desde dentro y fuera de la clase.

|| Dentro de la clase || Tanto Privado como Protegido solo se puede acceder desde dentro de la clase.

La similitud entre Protegido y Privado:

• Se puede acceder a ambos desde fuera de la clase a través de un método público.

Las diferencias entre Protegido y Privado son:

• El método privado no se puede llamar con un receptor (ni siquiera con #self). A MENOS QUE ... llamando a un método PRIVATE SETTER . Si intentas eliminar el receptor, Ruby creará una variable local. El yo es imprescindible en este caso.

• Protected puede o no usar self.

• Protected puede acceder al método protegido de otro objeto que proviene de la misma clase, Private can not.

Cuando se trata de herencia :

• Los métodos privados solo se pueden invocar en subclases implícitamente (simplemente el nombre del método) pero no explícitamente (usando #self).

• Protected se puede llamar en ambos sentidos (con o sin #self || implícita o explícitamente).

Ejemplo con el siguiente código:

class Foo
  private
  def pri
    ''hey I am private of Foo''
  end

  protected
  def prot
    ''Hey I am protected of Foo''
  end
end

Answer 5

Permítanme explicar Private métodos Private y protected funcionan de manera diferente en Ruby que en la mayoría de los otros lenguajes de programación. Supongamos que tiene una clase llamada Foo y una subclase SubFoo . En idiomas como Java , SubFoo no tiene acceso a ningún método privado definido por Foo. Como se ve en la Solución, Ruby no ofrece forma de ocultar los métodos de una clase de sus subclases. De esta manera, las obras privadas de Ruby como las de Java protected .

Supongamos además que tiene dos instancias de la clase Foo, a y b . En idiomas como Java , a y b pueden llamar a private methods los demás. En Ruby , necesitas usar un protected method para eso. Esta es la principal diferencia entre private métodos private y protected en Ruby .

class SubFoo < Foo
  def call_pri_of_foo
    pri
  end

  def call_prot_of_foo
    prot
  end
end

Ahora subclase de Foo

 > sub_foo = SubFoo.new
 => #<SubFoo:0x00000002b56ad8> 
 > sub_foo.call_pri_of_foo
 => "hey I am private of Foo" 
 > sub_foo.call_prot_of_foo
 => "Hey I am protected of Foo"

Ahora llamando a los accesorios dentro de SubFoo

next_sub_foo = SubFoo.new
 => #<SubFoo:0x00000002b1a0b0>

def next_sub_foo.access_private(child_of_sub_foo)
  child_of_sub_foo.pri
end

def next_sub_foo.access_protected(child_of_sub_foo)
  child_of_sub_foo.prot
end

Hasta aquí; parece que no hay diferencia

> next_sub_foo.access_private(sub_foo)
# => NoMethodError: private method `pri'' called for #<SubFoo:0x00000002b56ad8>

Ahora llamando al accessor

> next_sub_foo.access_protected(sub_foo)
# => "Hey I am protected of Foo"

pero puede acceder a los métodos protegidos de sus hermanos

 class Dog
  attr_accessor :name, :age

  def initialize(n, a)
    self.name = n
    self.age = a
  end

  def accessing_private
    "#{self.name} in human years is #{human_years}. This is secret!"
  end

  def accessing_protected
    "Will this work? " + a_protected_method
  end

  def eat_more_than(other) 
  # accessing other instance''s protected method from the same class
    daily_diet < other.daily_diet 
    "#{name} eats more than #{other.name}"
  end

  def boy 
    gender_method("boy") # accessing private setter method
  end

  protected

  def daily_diet 
    age * 2 # the younger, the more they have to eat 
  end

  def a_protected_method
    "Yes, I''m protected!"
  end

  private

  attr_writer :gender

  def gender_method(gender)
    self.gender = gender # private setter method requires self
    "#{name} is a #{gender}"
  end

  def human_years
    age * 8
  end
end

# Create the first object of Dog
blake = Dog.new("Blake", 5)

p blake.accessing_private # "Blake in human years is 16. This is secret!"

p blake.accessing_protected # "Will this work? Yes, I''m protected!"

# Create the second object of Dog
jackson = Dog.new("Jackson", 1)

# Below, protected methods from different objects of the same type/class 
# are proven to share access
p jackson.eat_more_than(blake) # true -> "Jackson eats more than Blake"

# Below, accessing private setter method through a public method.
p blake.boy # Blake is a boy 

También puede ver el blog de @tenderlove para obtener una imagen más clara http://tenderlovemaking.com/2012/09/07/protected-methods-and-ruby-2-0.html

Answer 6

public métodos public están abiertos a todos. En cuanto a private versus protected , me refiero a " Métodos privados de Ruby vs. Métodos protegidos ":

¿Cuál es la diferencia entre los métodos "privados" y "protegidos" en Ruby? En Ruby, la principal diferencia entre un método ''privado'' y ''protegido'' es que no se puede llamar a un método privado con un receptor explícito, mientras que un método protegido puede hacerlo. ¿Qué es un "receptor explícito", preguntas? Un receptor explícito es el objeto que está recibiendo un mensaje. En el siguiente ejemplo, tenemos un receptor (''parent'') y un método (''get_name''). El objeto ''padre'' está recibiendo las instrucciones para realizar el método ''get_name''.

Answer 7

Público : se puede llamar desde cualquier lugar

Privado : el método no se puede llamar fuera del alcance de la clase. El objeto solo puede enviarse el mensaje

por ejemplo: el panadero tiene el método de bake como público pero break_eggs es privado

Protegido : puede llamar a los métodos protegidos de un objeto, siempre que el objeto predeterminado sea una instancia de la misma clase que el objeto cuyo método está llamando.

ej .: con n método protegido, c1 puede solicitar a c2 que ejecute c2.n , porque c1 y c2 son instancias de la misma clase

Y por último pero no menos importante:

• Herencia : las subclases heredan las reglas de acceso a los métodos de su superclase

si es "clase D <C", entonces D exhibirá el mismo comportamiento de acceso que las instancias de C

referencia: http://www.amazon.com/Ruby-Rails-Techniques-Developers/dp/1932394699