注意，只会包含实例方法。在上面的示例中，已经包含了 greet（实例）方法，但是 MyModule.greet（模块）方法没有被包含…

module MyModule
  GOODMOOD = "happy"
  BADMOOD = "grumpy"
  def greet
    return "I'm #{GOODMOOD}. How are you?"
  end
  def MyModule.greet
    return "I'm #{BADMOOD}. How are you?"
  end
end

正如它所包含的那样，greet 方法可以像使用当前作用域中的普通实例方法一样被使用…

puts( greet )

包含模块的过程也称为“混入”（mixing in） - 这解释了为什么包含的模块通常被称为 “mixins”。将模块混入到类定义中时，从该类创建的任何对象都将能够使用被混入模块的实例方法，就像它们在类本身中定义一样。

class MyClass
  include MyModule
  def sayHi
    puts( greet )
  end
end

模块（Modules）可以被认为是离散的代码单元，可以简化可重用代码库的创建。另一方面，你可能更感兴趣的是使用模块作为实现多继承的替代方式。

回到我在本章开头提到的一个示例，让我们假设你有一个剑（Sword）类，它不仅是一种武器（Weapon），也是一种珍宝（Treasure）。或许 Sword 是 Weapon 类的后代（因此继承了 Weapon 的 deadliness 属性），但它也需要具有 Treasure 的属性（例如 value 和 owner），并且这是拥有魔法（MagicThing）的精灵之剑。如果你在 Treasure 和 MagicThing 模块（modules）而不是类（classes）中定义这些属性，则 Sword 类将能够以“混入”（mix in）方式包含这些模块其方法或属性：

module MagicThing
  attr_accessor :power
end
module Treasure
  attr_accessor :value
  attr_accessor :owner
class Weapon
  attr_accessor :deadliness
end
class Sword < Weapon
  include Treasure
  include MagicThing
  attr_accessor :name
end

Sword 对象现在可以访问 Sword 类本身，它的祖先类 Weapon，以及它的混入（mixed-in）模块 Treasure 和 MagicThing 的方法和属性：

s = Sword.new
s.name = "Excalibur"
s.deadliness = "fatal"
s.value = 1000
s.owner = "Gribbit The Dragon"
s.power = "Glows when Orcs Appear"
puts(s.name)
puts(s.deadliness)
puts(s.value)
puts(s.owner)
puts(s.power)

x = 1                          # local to this program
module Foo
  x = 50                      # local to module Foo
  # This can be mixed in but the variable x won't then be visible
  def no_bar
    return x
  end
  def bar
    @x = 1000
    return @x
  end
  puts( "In Foo: x = #{x}" ) # this can access the „module local‟ x
include Foo
puts(x)
puts( no_bar )                  # Error! This can't access the module-local variable
                             # needed by the no_bar method
puts(bar)

请注意，实例变量（instance variables）可用于混入方法（例如 bar）。但是，即使在混入方法的当前作用域中存在具有相同名称的局部变量时，局部变量也不可用（因此，即使 x 在当前作用域中已经声明，no_bar 也无法访问名为 x 的变量）。

模块可以具有其自己的实例变量，这些变量仅仅属于模块“对象”。这些实例变量存在于模块方法的作用域内：

但实例对象中引用的实例变量“属于”包含该模块的作用域：

module X
  @instvar = "X's @instvar"
  def amethod
    @instvar = 10             # creates @instvar in current scope
    puts(@instvar)
  end
end
include X
X.aaa                     #=> X's @instvar
puts( @instvar )         #=> nil
amethod #=> 10
puts( @instvar )         #=> 10
@instvar = "hello world"
puts( @instvar )         #=> "hello world"

module X
  @@classvar = "X's @@classvar"
end
include X
puts( @@classvar )         #=> X's @@classvar
@@classvar = "bye bye"
puts( @@classvar )         #=> "bye bye"

你可以使用 instance_variables 方法获取实例变量的名称数组：

p( self.instance_variables )