Ruby快速入门，四：类和模块

原文地址：http://blog.csdn.net/zhu_xz/article/details/4936800

我在第一篇文章 里简单的提过类和对象，但说得太过简单，所以这里重新再说一遍，也加上了对模块的简单介绍。再重申一遍，在Ruby中，一切都是对象，即便是简单的如1、2、3、4这样的数字都是对象。

下面的代码向我们展示了如何使用类和对象 ：

1. # 定义类
2. class BaseClass
3. # 定义accessor
4. attr_accessor:name
5. # 构造函数
6. def initialize(name)
7. puts "BaseClass::initialize - #{name}"
8. @name = name
9. end
10. # 自定义函数
11. def printName
12. puts @name
13. end
14. end
15. # Ruby只支持单继承
16. class SubClass < BaseClass
17. def initialize(name)
18. # 调用父类构造函数
19. super(name)
20. puts "SubClass::initialize - #{name}"
21. end
22. end
23. # 创建对象
24. obj = SubClass.new("obj")
25. # 调用对象方法
26. puts obj.name
27. obj.name = "name changed"
28. obj.printName

则结果为：

BaseClass::initialize - obj

SubClass::initialize - obj

obj

name changed

Ruby提供了public、protected和private来修饰类成员，其含义与C++相同。但不同的是，在Ruby中，所有类变量都默认 是private的，而类函数都默认是public的。对类成员而言，也可像第4行那样用attr_accessor对其进行修饰，使其可被外部访问。

和C++或Java相比，Ruby中的类具有更大的灵活性，随时随地都可以对类的内容进行修改。

1. class Original
2. def fun
3. puts "original::fun"
4. end
5. end
6. obj = Original.new
7. obj.fun
8. class Original
9. def fun2
10. puts "original::fun2"
11. end
12. end
13. obj.fun2

另一方面，为了降低程序的复杂度，Ruby只支持单继承，每个类只能有一个父类。但同时为了提高程序的灵活性，Ruby通过模块 为多重继承提供了可能。

Ruby中的模块从某种角度说类似于C++中的namespace，例如：

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

这段代码定义了一个名为Mod的模块，其中包含一个名为myFunction的函数和一个名为Class的类。然后直接调用函数 myFunction（注意需要声明为module_function），并创建了一个名为object的Mod::Class对象及调用其函数。

通过模块，也能够“实现”多重继承。或者更加准确的说，模块中的类和函数都被mixed-in到了新的类中，所以在Ruby中这又被成为mixin。

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

完