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

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

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

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

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

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

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

實例變量
在Ruby中，實例變量是存儲在對象中，但是，其于該對象的類沒有關(guān)系，當(dāng)給對象的實例變量賦值時，該實例變量就生成了，說白了，實例變量就像是一個掛載在對象上的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中，關(guān)于方法的定義并不在對象中，而是在對象自身的類中，這是因為“共享同一個類的對象也必須共享同樣的方法”。但是，不能說Class有一個叫做“method”的方法，因為無法使用"Class.method"調(diào)用該方法，而要說Class有一個實例方法“method”，這意味著必須創(chuàng)建該類的實例對象，通過實例對象調(diào)用該方法。

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

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

類本身也是對象
在Ruby中Class本身也是一個對象，關(guān)于對象的所有規(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é)點。
所有類都繼承自O(shè)bject。
Class是對Module的繼承增強，增加了new()和allocate()方法以創(chuàng)建實例。

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

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

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

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

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

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

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

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

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

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

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)語言，編譯器并不會檢測方法調(diào)用時的行為，因此你可以調(diào)用一個不存在的方法。 在運行時，所有找不到對應(yīng)方法的調(diào)用都會調(diào)用一個method_missing()方法，該方法定義在Kernal模塊中，因此每個對象都繼承了該方法。在kernal中method_missing()方法，會拋出一個NoMethodError的異常，這就是編譯器所做的工作。

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

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 

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

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

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

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