“私人”，“公共”和“受保护的方法”之间有什么区别？
我正在学习Ruby，并且已经到了让我感到困惑的地步。
我正在使用的这本书谈论的是private ， public ， protected methods ，但我仍然有点困惑。 每个之间有什么区别？
公共 – 可以从任何地方调用
Private – 该方法不能在类范围外调用。 对象发送消息给自己
例如：面包师的烘焙方法是公开的，但是break_eggs是私人的
受保护 – 只要默认对象self是与您调用的方法相同的对象的实例，就可以调用对象的受保护方法
例如：用n保护的方法，c1可以要求c2执行c2.n，因为c1和c2都是同一类的实例
最后但并非最不重要：
- inheritance ：子类inheritance其超类的方法访问规则
如果“类D <C”，那么D将展示与C的实例相同的访问行为
参考： http : //www.amazon.com/Ruby-Rails-Techniques-Developers/dp/1932394699
public方法向所有人开放。 至于private与protected ，我指的是“ Ruby私人方法与保护方法 ”：
Ruby中'private'和'protected'方法有什么区别？ 在Ruby中，“private”和“protected”方法之间的主要区别在于私有方法不能用明确的接收方来调用，而受保护的方法可以。 你问什么是“明确的接收者”？ 明确的接收者是接收消息的对象。 在下面的例子中，我们有一个接收者（'parent'）和一个方法（'get_name'）。 “父”对象正在接收执行“get_name”方法的指令。
查看“ Ruby编程/语法/类 ”了解详细的例子和解释。
简而言之， private ， public方法和protected方法之间的区别是程序中该方法的可见性，类似于只读，读写和几乎不可见。
与其他一些语言不同，您不能完全隐藏Ruby私有方法，您只能访问对象实例的私有方法，而不能访问任何其他对象实例的私有方法。
公众当然是完全的可访问性，除了一些例外情况外，方法通常是默认公开的。
受保护的方法可以从同一个类的对象甚至孩子访问，而私有方法则不是这种情况。
让我来解释在Ruby Private和protected方法的工作方式与其他大多数编程语言有所不同。 假设你有一个名为Foo的类和一个子类SubFoo 。 在像Java这样的Java ， SubFoo不能访问由Foo定义的私有方法。 从解决scheme中可以看出，Ruby没有办法从类的子类中隐藏类的方法。 通过这种方式， Ruby的私有作品像Java一样protected 。
进一步假设你有两个Foo类的实例a和b 。 在像Java这样的Java ， a和b可以调用彼此的private methods 。 在Ruby ，您需要使用protected method 。 这是Ruby private和protected方法的主要区别。
class Foo private def pri 'hey I am private of Foo' end protected def prot 'Hey I am protected of Foo' end end
现在是Foo子类
class SubFoo < Foo def call_pri_of_foo pri end def call_prot_of_foo prot end end
现在调用SubFoo的访问SubFoo
> 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"
到这里; 似乎没有区别
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
现在调用访问器
> next_sub_foo.access_private(sub_foo) # => NoMethodError: private method `pri' called for #<SubFoo:0x00000002b56ad8>
但它可以访问其兄弟姐妹的受保护的方法
> next_sub_foo.access_protected(sub_foo) # => "Hey I am protected of Foo"
你也可以看到@tenderlove的博客更清晰的图片http://tenderlovemaking.com/2012/09/07/protected-methods-and-ruby-2-0.html
我认为，打破一个明确的接收者是重要的，如果你无法理解这个概念。
明确的接收者是接受消息的对象。
person.get_name
person是接收者，方法“get_name”正在指示对象“person”执行方法“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.
当一个方法是私有的，它只能被定义在其类中的对象内的其他方法使用。
不同之处在于可见性以及它们如何受到inheritance的影响：
可视性 ：
|| 任何地方 || 公众可以从课堂内外进行访问。
|| 在课堂内部 || “私人”和“受保护”只能从课堂内部进行访问。
受保护和私有之间的相似性 ：
- 两者都可以通过公开的方法从课堂外进行访问。
受保护的和私有的区别是：
-
私人方法不能用接收器调用（甚至不用#self）。 除非 …调用PRIVATE SETTER方法 。 如果您尝试删除接收器，Ruby将创build一个局部variables。 在这种情况下，自我是必须的。
-
受保护可能会或可能不会使用自己。
-
受保护的可以访问来自同一个类的另一个对象的受保护方法，Private不能。
当谈到inheritance ：
-
私有方法只能隐式地（仅仅是方法的名字）在子类上调用， 但不能明确地使用（使用#self）。
-
受保护的可以被称为两种方式（隐含或显式地带或不带#self ||）。
代码如下：
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
研究我从这里获取的信息，我通过错误扩展了解释，并且对于我的观点，有助于理解为什么以及如何使用受保护的而不是私有的。
1）保护：
第12行因为接收到的参数来自另一个类而崩溃，错误消息是明确的：
v.rb:12:in `==': undefined method `sku' for "Object of another class ==> crash":String (NoMethodError)
2）私人：
如果从第8行和第12行中删除自己 ，并且由于在第12行中我更改为私人 保护 ，崩溃， 其他不知道sku是什么：
v.rb:12:in `==': private method `sku' called for #<Product:0x00000001574e68 @name="Bread", @quantity=1> (NoMethodError)
该程序：
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"
