6.5 访问控制

在Ruby里，要读取，或是改变对象的属性，唯一的途径是调用对象的方法。控制了对方法的访问，也就控制了对对象属性的访问。
控制对方法的访问，有三种方式： 

访问控制	意义
public	可以被任何实例对象调用，不存在访问控制；
protected	可以被定义它的类和其子类访问， 可以在 类中 或子类中 指定 给实例对象；
private	可以被定义它的类和其子类访问， 不能被实例对象调用。

方法默认都是公有的（ initialize方法除外，它永远是私有的）。
看程序  E6.5-1.rb ：

ruby 代码

1. #E6.5-1.rb     
2. class Person     
3.  def talk   
4.     puts "    public :talk,   将调用speak"  
5.     speak   
6.   end       
7.   
8.   def speak   
9.     puts "protected :speak,将调用laugh"  
10.     laugh   
11.   end       
12.   
13.   def laugh   
14.     puts "   private:laugh"        
15.   end       
16.   protected :speak  
17.   private    :laugh  
18. end  
19.   
20. p1=Person.new  
21. p1.talk   
22. #p1.speak   实例对象不能访问protected方法   
23. #p1.laugh    实例对象不能访问private方法   

 运行结果：
>ruby E6.5-1.rb
    public :talk, 将调用speak
protected:speak,将调用laugh
   private:laugh
>Exit code: 0

再看程序  E6.5-2.rb ：

ruby 代码

1. #E6.5-2.rb     
2.   
3. class Person     
4.      
5.   def speak   
6.     "protected:speak  "  
7.   end     
8.      
9.   def laugh   
10.     "   private:laugh"      
11.   end    
12.      
13.   protected :speak  
14.   private     :laugh  
15. end  
16.   
17. class Student < Person     
18.      
19.   def useLaugh   
20.     puts laugh   
21.   end     
22.      
23.   def useSpeak   
24.     puts speak   
25.   end     
26.      
27. end  
28. p2=Student.new  
29. p2. useLaugh         # =>    private:laugh   
30. p2. useSpeak         # =>  protected:speak    

从程序 E6.5-1.rb 和程序 E6.5-2.rb ，我们没有看出 protected 和 private 的区别，到底区别在哪里呢？
答案在程序  E6.5-3.rb ：

ruby 代码

1. #E6.5-3.rb    
2.   
3. class Person       
4.   def speak   
5.     "protected:speak  "  
6.   end     
7.      
8.   def laugh   
9.     "   private:laugh"      
10.   end    
11.      
12.   protected :speak  
13.   private     :laugh  
14.      
15.   def useLaugh(another)       
16.     puts another.laugh   #这里错误，私有方法不能指定对象   
17.   end     
18.      
19.   def useSpeak(another)      
20.     puts another.speak   
21.   end     
22.      
23. end  
24.   
25. p1=Person.new    
26. p2=Person.new  
27.   
28. p2.useSpeak(p1)          # =>  protected:speak   
29. #p2.useLaugh(p1)  

从上面三个程序可以得出结论：
 public方法，可以被定义它的类和其子类访问，可以被类和子类的实例对象调用；
 protected方法，可以被定义它的类和其子类访问，不能被类和子类的实例对象直接调用，但是可以在类和子类中指定给实例对象；
 private方法，可以被定义它的类和其子类访问，私有方法不能指定对象。

Ruby语言的访问控制是动态的，是在程序运行时刻确立的。你可以根据自己的需要，在程序的不同位置，改变某个方法的访问控制级别，让你的程序更加富于变化。

ruby 代码

1. #E6.5-4.rb     
2. class Person       
3.   private    #后面的方法设定为private   
4.   def talk   
5.     puts " already talk "  
6.   end        
7. end  
8.   
9. p1=Person.new  
10. #p1.talk   private方法不能访问   
11.   
12. class Person         
13.   public :talk  
14. end  
15.   
16. p1.talk     # =>  already talk  

 

完整阅读，请看我写的 Ruby语言中文教程all in one