Ruby快速入门（四）：类和模块

 ​​

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

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

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

则结果为：

BaseClass::initialize - obj
SubClass::initialize - obj
obj
name changed

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

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

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

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

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

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

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

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

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

完