Ruby面向對象編程中類與方法的基礎學習

打開類和猴子補丁
在Ruby中，類定義的方法和其他的語句沒有任何區(qū)別，都是一行一行的執(zhí)行下去的。如下例子：

class Example 
 def method_1 
  puts "method 1" 
 end 
end 
class Example 
 def method_2 
  puts "method 2" 
 end 
end 

本例中，當?shù)谝淮味xClass Example的時候，還沒有一個叫做Example的Class存在，因此，Ruby開始定義這個類，當后面在定義這個類時，Ruby會發(fā)現(xiàn)該類已存在，并返回這個類，而不是定義一個新類。

因為這個特性，因此，Ruby天生具有打開一個已經存在的類，并動態(tài)修改其內容的能力，即使其是標準類庫的類也不例外。比方說，可以給SDK的String類添加一個去除String中的標點符號和特殊字符的方法：to_alphanumeric

class String 
 def to_alphanumeric 
  gsub /[^\w\s]/, '' 
 end 
end 
“H^^ello”.to_alphanumeric #==>Hello 

，然后，所有的String對象都具備“to_alphanumeric”的能力了，這種技術一般簡稱為打開類技術。

上面描述的打開類技術其實是隱含了一定的風險的，尤其是在大型系統(tǒng)中使用打開類技術擴展標準類庫時，因為，很多開發(fā)人員都在擴展類，當多個擴展方法的名字一樣時， 后定義的總會覆蓋掉前面，從而導致整個系統(tǒng)的崩潰，業(yè)界把這種魯莽的修改類的方式簡稱為猴子補?。∕onkey Patch）。因此在使用打開類技術時，一定要慎之又慎。

實例變量
在Ruby中，實例變量是存儲在對象中，但是，其于該對象的類沒有關系，當給對象的實例變量賦值時，該實例變量就生成了，說白了，實例變量就像是一個掛載在對象上的HashMap，每個對象都可以用自己不同的HashMap, 如下例：

class Person 
 def name 
  @name = "xianlinbox" 
 end 
end 
p = Person.new 
puts p.instance_variables   #==>nil 
p.name 
puts p.instance_variables   #==>@name 

方法
作為一個對象，除了有實例變量（也可以稱之為屬性），還需要有方法。 但是在Ruby中，關于方法的定義并不在對象中，而是在對象自身的類中，這是因為“共享同一個類的對象也必須共享同樣的方法”。但是，不能說Class有一個叫做“method”的方法，因為無法使用"Class.method"調用該方法，而要說Class有一個實例方法“method”，這意味著必須創(chuàng)建該類的實例對象，通過實例對象調用該方法。

如果要定義類方法，那么在定義方法的時候，必須加類名前綴，如下：

class Person 
 def Person.name 
  @name = "xianlinbox" 
 end 
end 

類本身也是對象
在Ruby中Class本身也是一個對象，關于對象的所有規(guī)則都適用于Class.

puts "hello".class          #=> String 
puts String.class           #=> Class 
puts Class.class           #=> Class 
puts Class.instance_methods(false)  #=> [:superclass,:allocate,:new] 
puts Class.instance_variables    #=> nil 

類的繼承體系

puts String.superclass    #=> Object  
puts Class.superclass     #=> Module 
puts Module.superclass    #=> Object 
puts Object.superclass    #=> BasicObjec 
puts BasicObject.superclass  #=> nil 

BasicObject是繼承體系的根節(jié)點。
所有類都繼承自Object。
Class是對Module的繼承增強，增加了new()和allocate()方法以創(chuàng)建實例。

方法的查找與執(zhí)行
Ruby中對象的方法都定義在類中，當對象想要執(zhí)行一個方法時，首先需要找到該方法，而Ruby編譯器查找方法的方式就是，第一步在自己的類中找，沒有的話，就沿著該類的祖先鏈（ancestors）一直往上找。

String.ancestors    # => [String, Comparable, Object, Kernel, BasicObject] 

為什么這兒會出現(xiàn)Comparable和Kernal， 這是因為Module的機制，當一個類include一個模塊時，編譯會把該模塊放在最靠近該類的祖先鏈上， String類include了Comparable模塊，而Kernal則是被Object類include的。

方法執(zhí)行的時候需要一個接收者，方法就會在接收者對象中被執(zhí)行，該接收者就是所謂的self對象。一般情況下，self對象是由最后一個接收該方法的對象擔當，在類和模塊的定義中（并且在任何方法的定義外），self對象由類或模塊擔任。

動態(tài)調用方法
通常方法的調用方式是“對象名.方法名”，在Ruby中有一個很酷的特性，可以通過send()方法，把想調用的方法名作為參數(shù)，這樣就可以在代碼運行時，直到最后時刻才決定調用哪個方法，這種技術稱之為動態(tài)派發(fā)（Dynamic Dispatch）。這個技術非常有用，比方說，當在項目中有一個配置文件對象，會根據(jù)配置文件初始化，在使用過程中，不同用戶可能會設置不同的值。通常做法是，判斷屬性的鍵值是對應到哪個屬性，然后，調用對應的set方法，代碼如下：

config.name = v if isNameProperty?(k)  
config.password = v if isPasswordProperty?(k)  
config.port = v if isPortProperty?(k)  
...  

看著這么一堆的長得像親兄弟似的代碼，不由得產生一種閹掉它們的沖動。如果使用動態(tài)調用方法的話，代碼可以簡化如下：

load_config('config.properties').each do |k, v|  
config.send("#{k}=", v)  
end 

 根據(jù)獲取的每個鍵值，去調對應屬性的set方法，代碼清爽很多，而且以后擴展config對象不需要修改load方法。

動態(tài)定義方法
除了動態(tài)調用方法外，Ruby甚至支持動態(tài)定義方法，通過使用Module#define_method()方法，提供一個方法名和一個充當方法體的塊即可定義一個方法。例：

class MyClass  
define_method :doubleString do |args|  
args * 2  
end  
end  
t = MyClass.new  
puts t.doubleString("he")  # => hehe 

有了這個黑魔法之后，以后，就可以多個相似方法中不同的部分抽出來作為參數(shù)，然后，使用一個方法定義搞定所有的方法。

method_missing()方法
Ruby是動態(tài)語言，編譯器并不會檢測方法調用時的行為，因此你可以調用一個不存在的方法。 在運行時，所有找不到對應方法的調用都會調用一個method_missing()方法，該方法定義在Kernal模塊中，因此每個對象都繼承了該方法。在kernal中method_missing()方法，會拋出一個NoMethodError的異常，這就是編譯器所做的工作。

但是，我們可以覆寫這個方法，讓它變得很有意思。比方說，創(chuàng)建一個Struct，當你想要新的屬性時，只需要給它賦個值就神奇的產生了。

class MyStruct  
def initialize  
@attributes = {}  
end  
 
def method_missing(name, *args)  
attribute = name.to_s  
if attribute =~ /=$/  
@attributes[attribute.chop] = args[0]  
else  
@attributes[attribute]  
end  
end  
end  
s = MyStruct.new  
s.weibo = "@xianlinbox"  
puts s.weibo       # => @xianlinbox 

這種，從調用者角度看，跟普通方法沒什么區(qū)別，但是實際接收者卻并沒有相對應的方法的方法，Ruby術語稱之為幽靈方法（Ghost Method）。對于幽靈方法，除了自定義該方法以外，還可以把該方法轉發(fā)給另外一個對象的方法，當然，你可以在轉發(fā)前后包裝一些自己的邏輯，這種處理技術稱之為動態(tài)代理（Dynamic Proxy），和前面提到的動態(tài)調用異曲同工。

使用了method_missing處理幽靈方法后，所有不存在方法的調用都會到這里來，這可能會導致一些錯誤信息不直觀的問題（你看不到NoSuchMethod這樣的提示了），因此， 在使用method_missing方案的時候，一定要限定其使用范圍，并且調用父類的super.method_missing方法，讓不屬于這個范圍的，該報什么錯還是報什么錯。

白板類與保留方法
每一個類都有從父類繼承下來的一堆方法，在使用動態(tài)代理技術時，如果一個幽靈方法和真實的方法（你沒有意料到的繼承來的方法）發(fā)生名字沖突時，后者會獲勝，從而導致系統(tǒng)報錯。因此在使用動態(tài)代理技術時， 可以在代理類中刪除絕大多數(shù)繼承來的方法，避免發(fā)生名字沖突，刪除了繼承方法的類，就是所謂的白板類（Blank Slate），刪除類方法的途徑有2個，一個是調用Module#undef_method方法，一個是調用Module#remove_method方法。

在Ruby的Object類中，有一些方法是內部使用的，如果對其重新定義，或刪除，可能導致Ruby莫名其妙的掛掉，為了防止這種事情的發(fā)生，Ruby在這些方法名前面用“__”打頭，這些方法稱之為保留方法，當你試圖修改這些方法時，Ruby會給出警告。