模組全解======>>ruby的類是單繼承生物、所以出現了module、實現了多繼承

ruby的類是單繼承生物、所以出現了module、實現了多繼承、

註：模組、常量和類的命名都是以大寫字母開頭

、 模組引用：
      1、如果引用的模組在同一個檔案中，則直接使用模組操作
      2、如果不在同一個檔案中，則需要使用require載入被引用模組所在檔案。(引用的是完整名稱)

可以使用module包含著各種class、再建立一個類使用include包含各種class、從而實現多重繼承、=。 =真是複雜的生物、想簡單點覺得變和更複雜了、

其實modeule不是能夠被執行個體化的、所以只能通過module.method這樣來引用方法、當然首先得來一句

instance_method :fun1 

Ruby提供了public、protected和private來修飾類成員，其含義與C++相同。但不同的是，在Ruby中，所有類變數都預設 是private的，而類函數都預設是public的。對類成員而言，也可像第4行那樣用attr_accessor對其進行修飾，使其可被外部存取。

類包括多個模組

 1 module Mod1  
 2   def fun1  
 3     puts "Mod1::fun1"  
 4   end  
 5   instance_method :fun1  
 6 end  
 7 module Mod2  
 8   def fun2  
 9     puts "Mod2::fun2"  
10   end  
11   instance_method :fun2  
12 end  
13 class Cls  
14   include Mod1  
15   include Mod2  
16 end  
17 obj = Cls.new  
18 obj.fun1  
19 obj.fun2  

模組包含類

 1 module Mod  
 2   def myFunction  
 3     puts "myFunction"  
 4   end  
 5   module_function :myFunction  
 6   class Class  
 7     def yourFunction  
 8       puts "Mod::Class.yourFunction"  
 9     end  
10   end  
11 end  
12 Mod.myFunction  
13 object = Mod::Class.new  
14 object.yourFunction 

假如module定義下以下的方法

 1 module MyModule 
 2 　　GOODMOOD = "happy" 
 3 　　BADMOOD = "grumpy" 
 4     def greet
 5         return "I'm #{GOODMOOD}. How are you?" 
 6     end 
 7     def MyModule.greet
 8           return "I'm #{BADMOOD}. How are you?" 
 9     end 
10 end

其中的MyModule.greet方法、等同於

1   def self.greet
2     return "I'm #{BADMOOD}. How are you?"
3   end

這裡定義的常量可以使用以下方法來訪問

MyModule::GOODMOOD

某天邇想引用一下greet方法時、可以使用

MyModule.greet

但是若果邇覺得煩瑣、可以先include該模組先

include MyModule 
puts( greet )

注意一下、使用include方法這僅僅只是引用greet方法、而非MyModule.greet、模組自己的方法只能由模組名稱引出、無法使用include方法替邇減少些打字的痛苦、

承接上面的例子、寫了一個類、引用上面的模組、沒錯啦！這就是RUBY多承繼承的實現方法 ！

class MyClass  include MyModule  def sayHi puts    (greet)  endend

在類中用include包含了上面的模組、好吧、莪們執行個體化一下

1 ob = MyClass.new 
2 ob.sayHi 
3 puts(ob.greet)

可以驚奇的發現、居然類的執行個體對象也可以訪問模組的執行個體方法、太神奇了、相當於已經繼承了模組的所有方法

下面再來個多重繼承的範例

 1 module MagicThing
 2   attr_accessor :power
 3 end
 4 
 5 module Treasure
 6   attr_accessor :value
 7   attr_accessor :owner
 8 end
 9 
10 class Weapon
11   attr_accessor :deadliness
12 end
13 
14 class Sword < Weapon
15   include Treasure
16   include MagicThing
17   attr_accessor :name
18 end

從上面看、設定了多個模組、MagicThing和Treasure、還有一個Weapon的類、它們統統都在Sword的繼承中實現啦~ 首先Sword繼承了Weapon、然後再用include引入了兩個模組、所以下面的實現方法是完全成立的！

1 s = Sword.new
2 s.name = "Excalibur"
3 s.deadliness = "fatal"
4 s.value = 1000
5 s.owner = "Gribbit The Dragon"
6 s.power = "Glows when Orcs Appear"

下面莪們來關注一下模組裡頭的變數、注意一點、模組裡的本地變數是無法被模組外所調用的、甚至是return都不可以、這就是為什麼模組內部執行個體變數滿天飛的原因了

 1 x = 1 # local to this program
 2 
 3 module Foo
 4   x = 50 # local to module Foo
 5 
 6   # This can be mixed in but the variable x won't then be visible
 7   def no_bar
 8     return x
 9   end
10 
11 
12   def bar
13     @x = 1000
14     return @x
15   end
16 
17   puts("In Foo: x = #{x}") # this can access the „module local‟ x
18 end
19 
20 
21 include Foo
22 
23 puts(x)
24 #puts(no_bar) # Error! This can't access the module-local variable
25       ## needed by the no_bar method
26 puts(bar)

可以看到莪已經屏蔽了第24行的代碼、因為這個方法是錯誤的！不能夠被調出去、