[Ruby学习总结]Ruby中的类

1、类名的定义以大写字母开头，单词首字母大写，不用"_"分隔

2、实例化对象的时候调用new方法，实际上调用的是类里边的initialize方法，是ruby类的初始化方法，功能等同于Java中的构造方法

[plain]  view plain copy

1. class Person  
2.   def initialize(name, gender, age)  
3.     @name = name  
4.     @gender = gender  
5.     @age = age  
6.   end  
7. end  

3、可以使用attr_accessor关键字标记实例变量，为其提供读写方法，类似java中的get&set方法，如定义个最简单的model对象：

[plain]  view plain copy

1. class Person  
2.   attr_accessor :name, :gender, :age  
3. end  

等同于：

[plain]  view plain copy

1. class Person  
2.   def name  
3.     @name  
4.   end  
5.   def name=(name)  
6.     @name=name  
7.   end  
8.   
9.   def gender  
10.     @gender  
11.   end  
12.   def gender=(gender)  
13.     @gender=gender  
14.   end  
15.   
16.   def age  
17.     @age  
18.   end  
19.   def age=(age)  
20.     @age=age  
21.   end  
22. end  

可见，使用了attr_accessor关键字，可以使代码更简洁易懂，此外，ruby中还提供读写分开的关键字：attr_writer（只写）、attr_reader（只读）。

4、Ruby中没有接口，但是有更神奇的Module和Mix-in机制，注意：module中的静态方法只能通过模块名访问，实例方法只能通过include到类中，然后通过类的实例访问。

[plain]  view plain copy

1. module Foo  
2.   PI = 3.14  
3.   def m1  
4.     puts 'Put out from m1!'  
5.   end  
6.   
7.   def Foo.m2  
8.     puts 'Put out from m2!'  
9.   end  
10.   
11.   class Fooc  
12.     def mfc  
13.       puts 'Put out from Foo>>Fooc!'  
14.     end  
15.   end  
16.   
17.   module Foos  
18.     def mfs  
19.       puts 'Put out from Foo>>Foos'  
20.     end  
21.   end  
22. end  
23. #通过module名访问，只能访问类一级的内容  
24. puts Foo::PI.to_s    #输出：3.14  
25. Foo::Fooc.new.mfc    #输出：Put out from Foo>>Fooc!!  
26. #Foo.m1               #无法访问，没有实例化  
27. Foo.m2                #静态方法通过模块名访问  
28. #引入后访问  
29. include Foo  
30. m1               #输出：Put out from m1!  
31. Fooc.new.mfc     #输出：Put out from Foo>>Fooc!!  
32.   
33. include Foos  
34. mfs              #输出：Put out from Foo>>Foos!  

可以来看看Module在实在应用中是怎么使用的：

[plain]  view plain copy

1. #鸭子类  
2. class Duck  
3.   def swim  
4.     print self.class , " can swim...\n";  
5.   end  
6. end  
7.   
8. #"会飞的"模块  
9. module FlyModule  
10.   def fly  
11.     print "    and I can fly...\n"  
12.   end  
13. end  
14.   
15. #野鸭(会飞，会游)  
16. class Mallard < Duck  
17.   include FlyModule #导入模块后，该类即具有模块中定义的方法（可以理解为实现了接口）  
18. end  
19.   
20. #家鸭(只会游泳)  
21. class Coot < Duck  
22. end  
23.   
24. m = Mallard.new  
25. m.swim  
26. m.fly  
27. c1 = Coot.new  
28. c1.swim  
29. #c1.fly               #无法调用，报错提示未定义  
30. #module中定义的方法也可以在实例中动态扩展  
31. c2 = Coot.new  
32. c2.extend(FlyModule)  #扩展c2对象引入FlyModule模块  
33. c2.swim  
34. c2.fly  
35.