模块全解======>>ruby的类是单继承生物、所以出现了module、实现了多继承

作者: kloboHYZ
发布时间:2015-07-13 11:31:24

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)    end  end  

在类中用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行的代码、因为这个方法是错误的!不能够被调出去、





标签: Ruby
来源:http://www.cnblogs.com/klobohyz/archive/2011/10/19/2217305.h

推荐: