在我阅读this article之前,我认为Ruby中的访问控制工作方式如下:
public
- 可以被任何对象访问(例如Obj.new.public_method
)protected
- 只能从对象本身以及任何子类private
- 与protected相同,但子类中不存在该方法但是,protected
和private
的行为似乎相同,只是您不能使用明确的接收方调用private
方法(即self.protected_method
有效,但self.private_method
没有。)
这有什么意义?什么时候你不希望你的方法用显式接收器调用?
答案 0 :(得分:147)
protected
方法可以由定义类或其子类的任何实例调用。
private
方法只能在调用对象中调用。您无法直接访问其他实例的私有方法。
这是一个快速的实际例子:
def compare_to(x)
self.some_method <=> x.some_method
end
some_method
此处不能private
。它必须是protected
,因为您需要它来支持显式接收器。典型的内部帮助方法通常可以是private
,因为它们永远不需要像这样调用。
值得注意的是,这与Java或C ++的工作方式不同。 Ruby中的private
类似于Java / C ++中的protected
,因为子类可以访问该方法。在Ruby中,没有办法限制从子类访问方法,就像在Java中使用private
一样。
Ruby中的可见性在很大程度上是一个“推荐”,因为您始终可以使用send
访问方法:
irb(main):001:0> class A
irb(main):002:1> private
irb(main):003:1> def not_so_private_method
irb(main):004:2> puts "Hello World"
irb(main):005:2> end
irb(main):006:1> end
=> nil
irb(main):007:0> foo = A.new
=> #<A:0x31688f>
irb(main):009:0> foo.send :not_so_private_method
Hello World
=> nil
答案 1 :(得分:76)
self
的隐式接收器进行调用。 即使您也无法致电self.some_private_method
;您必须以隐含private_method
的{{1}}来致电self
。 (iGEL指出:“但是有一个例外。如果你有一个私有方法age =,你可以(并且必须)用self调用它来将它与局部变量分开。”)在Ruby中,这些区别只是从一个程序员到另一个程序员的建议。 非公开方法是一种说法“我保留改变这一点的权利;不依赖它。”但是你仍然可以得到send
的尖锐剪刀,可以打电话给任何人你喜欢的方法。
# dwarf.rb
class Dwarf
include Comparable
def initialize(name, age, beard_strength)
@name = name
@age = age
@beard_strength = beard_strength
end
attr_reader :name, :age, :beard_strength
public :name
private :age
protected :beard_strength
# Comparable module will use this comparison method for >, <, ==, etc.
def <=>(other_dwarf)
# One dwarf is allowed to call this method on another
beard_strength <=> other_dwarf.beard_strength
end
def greet
"Lo, I am #{name}, and have mined these #{age} years.\
My beard is #{beard_strength} strong!"
end
def blurt
# Not allowed to do this: private methods can't have an explicit receiver
"My age is #{self.age}!"
end
end
require 'irb'; IRB.start
然后你可以运行ruby dwarf.rb
并执行此操作:
gloin = Dwarf.new('Gloin', 253, 7)
gimli = Dwarf.new('Gimli', 62, 9)
gloin > gimli # false
gimli > gloin # true
gimli.name # 'Gimli'
gimli.age # NoMethodError: private method `age'
called for #<Dwarf:0x007ff552140128>
gimli.beard_strength # NoMethodError: protected method `beard_strength'
called for #<Dwarf:0x007ff552140128>
gimli.greet # "Lo, I am Gimli, and have mined these 62 years.\
My beard is 9 strong!"
gimli.blurt # private method `age' called for #<Dwarf:0x007ff552140128>
答案 2 :(得分:44)
如果某个方法在Ruby中是私有的,则它不能被显式接收器(对象)调用。它只能被隐式调用。它可以通过描述它的类以及该类的子类隐式调用。
以下示例将更好地说明:
1)具有私有方法class_name
的Animal类class Animal
def intro_animal
class_name
end
private
def class_name
"I am a #{self.class}"
end
end
在这种情况下:
n = Animal.new
n.intro_animal #=>I am a Animal
n.class_name #=>error: private method `class_name' called
2)动物的一个子类叫做两栖动物:
class Amphibian < Animal
def intro_amphibian
class_name
end
end
在这种情况下:
n= Amphibian.new
n.intro_amphibian #=>I am a Amphibian
n.class_name #=>error: private method `class_name' called
如您所见,私有方法只能隐式调用。它们不能被显式接收器调用。出于同样的原因,不能在定义类的层次结构之外调用私有方法。
如果一个方法在Ruby中受到保护,那么它可以被定义类及其子类隐式调用。此外,只要接收者是自己的或与自己的同一类别,它们也可以由显式接收者调用:
1)具有受保护方法protect_me
的Animal类class Animal
def animal_call
protect_me
end
protected
def protect_me
p "protect_me called from #{self.class}"
end
end
在这种情况下:
n= Animal.new
n.animal_call #=> protect_me called from Animal
n.protect_me #=>error: protected method `protect_me' called
2)遗传自动物类的哺乳动物类
class Mammal < Animal
def mammal_call
protect_me
end
end
在这种情况下
n= Mammal.new
n.mammal_call #=> protect_me called from Mammal
3)从动物类继承的两栖动物类(与哺乳动物类相同)
class Amphibian < Animal
def amphi_call
Mammal.new.protect_me #Receiver same as self
self.protect_me #Receiver is self
end
end
在这种情况下
n= Amphibian.new
n.amphi_call #=> protect_me called from Mammal
#=> protect_me called from Amphibian
4)一个名为Tree
的类class Tree
def tree_call
Mammal.new.protect_me #Receiver is not same as self
end
end
在这种情况下:
n= Tree.new
n.tree_call #=>error: protected method `protect_me' called for #<Mammal:0x13410c0>
答案 3 :(得分:7)
考虑Java中的私有方法。当然,它可以在同一个类中调用,但也可以由同一个类的另一个实例调用:
public class Foo {
private void myPrivateMethod() {
//stuff
}
private void anotherMethod() {
myPrivateMethod(); //calls on self, no explicit receiver
Foo foo = new Foo();
foo.myPrivateMethod(); //this works
}
}
所以 - 如果调用者是我同一个类的不同实例 - 我的私有方法实际上可以从“外部”访问,可以这么说。这实际上使它看起来不是那么私密。
另一方面,在Ruby中,私有方法实际上只对当前实例是私有的。这就是删除显式接收器提供的选项。
另一方面,我当然应该指出,在Ruby社区中根本不使用这些可见性控件是很常见的,因为Ruby无论如何都会为你提供绕过它们的方法。与Java世界不同,趋势是让所有开发人员都可以访问并信任其他开发人员,而不是搞砸了。
答案 4 :(得分:2)
Java与Ruby的访问控制的比较:如果在Java中将方法声明为private,则只能由同一类中的其他方法访问。如果方法被声明为protected,则可以由存在于同一个包中的其他类以及该类在不同包中的子类访问。当一个方法公开时,每个人都可以看到它。在Java中,访问控制可见性概念取决于这些类在继承/包层次结构中的位置。
而在Ruby中,继承层次结构或包/模块不适合。关键在于哪个对象是方法的接收者。
对于Ruby中的私有方法,永远不能使用显式接收器调用它。我们可以(仅)使用隐式接收器调用私有方法。
这也意味着我们可以在声明的类中调用私有方法以及此类的所有子类。
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
您永远不能从定义它的类层次结构之外调用私有方法。
可以使用隐式接收器调用受保护的方法,就像私有一样。另外,如果接收者是“自我”或“同一类的对象”,也可以由显式接收者(仅)调用受保护的方法。
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
Consider Public methods with maximum visibility
摘要
公开:公共方法具有最大可见性
受保护:可以使用隐式接收器调用受保护的方法,就像私有一样。另外,如果接收者是“自我”或“同一类的对象”,则受保护的方法也可以由显式接收者(仅)调用。
Private:对于Ruby中的私有方法,永远不能使用显式接收器调用它。我们可以(仅)使用隐式接收器调用私有方法。这也意味着我们可以从声明的类中调用私有方法以及该类的所有子类。
答案 5 :(得分:0)
Ruby中的子类可以访问私有方法的部分原因是,使用类的Ruby继承比使用模块包含的内容更薄 - 在Ruby中,类实际上是一种提供继承的模块等。
http://ruby-doc.org/core-2.0.0/Class.html
这意味着基本上子类“包含”父类,以便有效地在父类中定义父类的函数包括私有函数。
在其他编程语言中,调用方法涉及将方法名称冒泡到父类层次结构并查找响应该方法的第一个父类。相比之下,在Ruby中,虽然父类层次结构仍然存在,但父类的方法直接包含在已定义的子类的方法列表中。
答案 6 :(得分:0)
First Three types of access specifiers and those define thier scope.
1.Public -> Access anywhere out side the class.
2.Private -> Can not access outside the class.
3.Protected -> This Method not access anywhere this method define
scope.
But i have a solution for this problem for all method how to access explain in depth.
class Test
attr_reader :name
def initialize(name)
@name = name
end
def add_two(number)
@number = number
end
def view_address
address("Anyaddress")
end
private
def address(add)
@add = add
end
protected
def user_name(name)
# p 'call method'
@name = name
end
end
class Result < Test
def new_user
user_name("test355")
end
end
答案 7 :(得分:0)
@freddie = Person.new
@freddie.hows_it_going?
# => "oh dear, i'm in great pain!"
class Person
# public method
def hows_it_going?
how_are_your_underpants_feeling?
end
private
def how_are_your_underpants_feeling? # private method
puts "oh dear, i'm in great pain!"
end
end
我们可以询问 Freddie 事情进展如何,因为它是一种公共方法。这是完全正确的。而且很正常,可以接受。
但是……唯一能知道弗莱迪内裤情况的人,只有弗莱迪本人。随便的陌生人伸手进入弗莱迪的内裤并测试情况是行不通的——不,不——这是非常非常私密的,我们不想将私密的东西暴露给外界。
@freddie.how_are_your_underpants_feeling?
# => # NoMethodError: private method `how_are_your_underpants_feeling?' called
考虑一下:
class Person
protected
def gimme_your_credit_card! # protected method
puts "Fine. Whatever. Here it is: 1234-4567-8910"
end
end
class Rib < Person
end
class Wife < Rib # wife inherits from Rib
def i_am_buying_another_handbag_with_your_card(husband)
husband.gimme_your_credit_card!
end
end
@husband = Person.new
@mrs = Wife.new
@mrs.i_am_buying_another_handbag_with_your_card(@husband)
# => puts "Fine. Whatever. Here it is: 1234-4567-8910"
我们对 mrs
获取我们的信用卡详细信息有些满意,因为 mrs
是我们的肉体,继承自 Person,但我们不希望随机的个人访问我们的信用卡详情。
如果我们试图在子类之外这样做,就会失败:
@mrs = Wife.new
@mrs.gimme_your_credit_card!
# => protected method gimme_your_credit_card! called for #<Wife:0x00005567b5865818> (NoMethodError)