欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

Ruby面向对象编程中类与方法的基础学习

程序员文章站 2022-03-20 21:19:40
打开类和猴子补丁 在ruby中,类定义的方法和其他的语句没有任何区别,都是一行一行的执行下去的。如下例子: class example def meth...

打开类和猴子补丁
在ruby中,类定义的方法和其他的语句没有任何区别,都是一行一行的执行下去的。如下例子:

class example 
 def method_1 
  puts "method 1" 
 end 
end 
class example 
 def method_2 
  puts "method 2" 
 end 
end 

本例中,当第一次定义class example的时候,还没有一个叫做example的class存在,因此,ruby开始定义这个类,当后面在定义这个类时,ruby会发现该类已存在,并返回这个类,而不是定义一个新类。

因为这个特性,因此,ruby天生具有打开一个已经存在的类,并动态修改其内容的能力,即使其是标准类库的类也不例外。比方说,可以给sdk的string类添加一个去除string中的标点符号和特殊字符的方法:to_alphanumeric

class string 
 def to_alphanumeric 
  gsub /[^\w\s]/, '' 
 end 
end 
“h&&^^ello”.to_alphanumeric #==>hello 

,然后,所有的string对象都具备“to_alphanumeric”的能力了,这种技术一般简称为打开类技术。

上面描述的打开类技术其实是隐含了一定的风险的,尤其是在大型系统中使用打开类技术扩展标准类库时,因为,很多开发人员都在扩展类,当多个扩展方法的名字一样时, 后定义的总会覆盖掉前面,从而导致整个系统的崩溃,业界把这种鲁莽的修改类的方式简称为猴子补丁(monkey patch)。因此在使用打开类技术时,一定要慎之又慎。

实例变量
在ruby中,实例变量是存储在对象中,但是,其于该对象的类没有关系,当给对象的实例变量赋值时,该实例变量就生成了,说白了,实例变量就像是一个挂载在对象上的hashmap,每个对象都可以用自己不同的hashmap, 如下例:

class person 
 def name 
  @name = "xianlinbox" 
 end 
end 
p = person.new 
puts p.instance_variables   #==>nil 
p.name 
puts p.instance_variables   #==>@name 

方法
作为一个对象,除了有实例变量(也可以称之为属性),还需要有方法。 但是在ruby中,关于方法的定义并不在对象中,而是在对象自身的类中,这是因为“共享同一个类的对象也必须共享同样的方法”。但是,不能说class有一个叫做“method”的方法,因为无法使用"class.method"调用该方法,而要说class有一个实例方法“method”,这意味着必须创建该类的实例对象,通过实例对象调用该方法。

如果要定义类方法,那么在定义方法的时候,必须加类名前缀,如下:

class person 
 def person.name 
  @name = "xianlinbox" 
 end 
end 

类本身也是对象
在ruby中class本身也是一个对象,关于对象的所有规则都适用于class.

puts "hello".class          #=> string 
puts string.class           #=> class 
puts class.class           #=> class 
puts class.instance_methods(false)  #=> [:superclass,:allocate,:new] 
puts class.instance_variables    #=> nil 

类的继承体系

puts string.superclass    #=> object  
puts class.superclass     #=> module 
puts module.superclass    #=> object 
puts object.superclass    #=> basicobjec 
puts basicobject.superclass  #=> nil 

basicobject是继承体系的根节点。
所有类都继承自object。
class是对module的继承增强,增加了new()和allocate()方法以创建实例。

方法的查找与执行
ruby中对象的方法都定义在类中,当对象想要执行一个方法时,首先需要找到该方法,而ruby编译器查找方法的方式就是,第一步在自己的类中找,没有的话,就沿着该类的祖先链(ancestors)一直往上找。

string.ancestors    # => [string, comparable, object, kernel, basicobject] 

为什么这儿会出现comparable和kernal, 这是因为module的机制,当一个类include一个模块时,编译会把该模块放在最靠近该类的祖先链上, string类include了comparable模块,而kernal则是被object类include的。

方法执行的时候需要一个接收者,方法就会在接收者对象中被执行,该接收者就是所谓的self对象。一般情况下,self对象是由最后一个接收该方法的对象担当,在类和模块的定义中(并且在任何方法的定义外),self对象由类或模块担任。

动态调用方法
通常方法的调用方式是“对象名.方法名”,在ruby中有一个很酷的特性,可以通过send()方法,把想调用的方法名作为参数,这样就可以在代码运行时,直到最后时刻才决定调用哪个方法,这种技术称之为动态派发(dynamic dispatch)。这个技术非常有用,比方说,当在项目中有一个配置文件对象,会根据配置文件初始化,在使用过程中,不同用户可能会设置不同的值。通常做法是,判断属性的键值是对应到哪个属性,然后,调用对应的set方法,代码如下:

config.name = v if isnameproperty?(k)  
config.password = v if ispasswordproperty?(k)  
config.port = v if isportproperty?(k)  
...  

看着这么一堆的长得像亲兄弟似的代码,不由得产生一种阉掉它们的冲动。如果使用动态调用方法的话,代码可以简化如下:

load_config('config.properties').each do |k, v|  
config.send("#{k}=", v)  
end 

 根据获取的每个键值,去调对应属性的set方法,代码清爽很多,而且以后扩展config对象不需要修改load方法。

动态定义方法
除了动态调用方法外,ruby甚至支持动态定义方法,通过使用module#define_method()方法,提供一个方法名和一个充当方法体的块即可定义一个方法。例:

class myclass  
define_method :doublestring do |args|  
args * 2  
end  
end  
t = myclass.new  
puts t.doublestring("he")  # => hehe 

有了这个黑魔法之后,以后,就可以多个相似方法中不同的部分抽出来作为参数,然后,使用一个方法定义搞定所有的方法。

method_missing()方法
ruby是动态语言,编译器并不会检测方法调用时的行为,因此你可以调用一个不存在的方法。 在运行时,所有找不到对应方法的调用都会调用一个method_missing()方法,该方法定义在kernal模块中,因此每个对象都继承了该方法。在kernal中method_missing()方法,会抛出一个nomethoderror的异常,这就是编译器所做的工作。

但是,我们可以覆写这个方法,让它变得很有意思。比方说,创建一个struct,当你想要新的属性时,只需要给它赋个值就神奇的产生了。

class mystruct  
def initialize  
@attributes = {}  
end  
 
def method_missing(name, *args)  
attribute = name.to_s  
if attribute =~ /=$/  
@attributes[attribute.chop] = args[0]  
else  
@attributes[attribute]  
end  
end  
end  
s = mystruct.new  
s.weibo = "@xianlinbox"  
puts s.weibo       # => @xianlinbox 

这种,从调用者角度看,跟普通方法没什么区别,但是实际接收者却并没有相对应的方法的方法,ruby术语称之为幽灵方法(ghost method)。对于幽灵方法,除了自定义该方法以外,还可以把该方法转发给另外一个对象的方法,当然,你可以在转发前后包装一些自己的逻辑,这种处理技术称之为动态代理(dynamic proxy),和前面提到的动态调用异曲同工。

使用了method_missing处理幽灵方法后,所有不存在方法的调用都会到这里来,这可能会导致一些错误信息不直观的问题(你看不到nosuchmethod这样的提示了),因此, 在使用method_missing方案的时候,一定要限定其使用范围,并且调用父类的super.method_missing方法,让不属于这个范围的,该报什么错还是报什么错。

白板类与保留方法
每一个类都有从父类继承下来的一堆方法,在使用动态代理技术时,如果一个幽灵方法和真实的方法(你没有意料到的继承来的方法)发生名字冲突时,后者会获胜,从而导致系统报错。因此在使用动态代理技术时, 可以在代理类中删除绝大多数继承来的方法,避免发生名字冲突,删除了继承方法的类,就是所谓的白板类(blank slate),删除类方法的途径有2个,一个是调用module#undef_method方法,一个是调用module#remove_method方法。

在ruby的object类中,有一些方法是内部使用的,如果对其重新定义,或删除,可能导致ruby莫名其妙的挂掉,为了防止这种事情的发生,ruby在这些方法名前面用“__”打头,这些方法称之为保留方法,当你试图修改这些方法时,ruby会给出警告。

相关标签: Ruby 方法