`
simohayha
  • 浏览: 1403647 次
  • 性别: Icon_minigender_1
  • 来自: 火星
社区版块
存档分类
最新评论

ruby way之高级OOP特性之二

    博客分类:
  • ruby
阅读更多
1 把代码像对象一样存储

当你想要以对象的形式存储一块代码的时候,ruby给了你几种方法。下面我们会介绍Proc 对象, Method 对象和 UnboundMethod 对象.

内置的Proc 类包装ruby block到一个对象.Proc对象,像一个blocks,是一个闭包而且保存了它定义时的上下文:

myproc = Proc.new { |a| puts "Param is #{a}" }

myproc.call(99)         # Param is 99


当一个方法接受一个&的参数,然后这个方法紧跟着一个block被调用的时候,Proc 对象就会自动被创建:

def take_block(x, &block)
  puts block.class
  x.times {|i| block[i, i*i] }
end

take_block(3) { |n,s| puts "#{n} squared is #{s}" }


这里要注意的是[]方法是call方法的别名。

如果你有一个Proc的对象,你可以把它传递给可以接收block的方法。只要在它前面加上&就行了.

myproc = proc { |n| print n, "... " }
(1..3).each(&myproc)                    # 1... 2... 3...


ruby也可以让你把一个方法插入到一个对象.这时要用到Object#method方法:

str = "cat"
meth = str.method(:length)

a = meth.call               #  3  (length of "cat")

str << "erpillar"

b = meth.call               # 11  (length of "caterpillar")

str = "dog"

# Note the next call! The variable str refers to a new object
# ("dog") now, but meth is still bound to the old object.

c = meth.call               # 11  (length of "caterpillar")


最后一次调用请注意,由于str已指向另一个对象,因此这次调用,依然是老的对象.

你还能通过Module#instance_method 创建一个UnboundMethod 对象,它表示一个方法联系到一个类。你要调用unboundmethod对象,你必须首先绑定他到一个对象:

umeth = String.instance_method(:length)

m1 = umeth.bind("cat")
m1.call                         # 3

m2 = umeth.bind("caterpillar")
m2.call                         # 11


2   How Module Inclusion Works

具体的ruby中怎么处理include一个module,可以去看宝石书。

在一个被包含的模块里面的方法,都会被类里面所出现的方法所隐藏:

module MyMod
  def meth
    "from module"
  end
end

class ParentClass
  def meth
    "from parent"
  end
end

class ChildClass < ParentClass
  include MyMod
  def meth
    "from child"
  end
end

x = ChildClass.new
p x.meth              #from child 


这边可以看到MyMod里面的meth方法被ChildClass 中的所隐藏:

当我们在子类中调用super,会发生什么呢?

class ChildClass < ParentClass
  include MyMod
  def meth
    "from child: super = " + super
  end
end

x = ChildClass.new
p x.meth              # from child: super = from module


这个例子展示了,其实模块才是子类真正的父类。那么让我们在模块的方法里面调用super:

module MyMod
  def meth
    "from module: super = " + super
  end
end

# ParentClass is unchanged

class ChildClass < ParentClass
  include MyMod
  def meth
    "from child: super = " + super
  end
end

x = ChildClass.new
p x.meth       # from child: super = from module: super = from parent


我们能在MyMod里面调用super方法,那是因为ParentClass类有meth方法,如果没有的话呢:
module MyMod
  def meth
    "from module: super = " + super
  end
end

class Foo      include MyMod
end

x = Foo.new
x.meth


他就会抛出一个NoMethodError 。

3 检测默认的参数

在2004年,Ian Macdonald 在邮件列表里面问了个问题:怎么样才能知道参数的值是默认的还是调用者付的.

Nobu Nakada给了一个最简单和最好的方法:

def meth(a, b=(flag=true; 345))
  puts "b is #{b} and flag is #{flag.inspect}"
end

meth(123)        # b is 345 and flag is true
meth(123,345)    # b is 345 and flag is nil
meth(123,456)    # b is 456 and flag is nil


4 Delegating 或者 Forwarding


ruby有两个库,它能够从接收者或者另外的对象来解决delegating或者forwarding 的方法调用.

SimpleDelegator用来委托给一个特定的对象,这个对象能够用__setobj__方法来改变:

DelegateClass 接受一个类作为参数:

require 'delegate'

class MyQueue < DelegateClass(Array)

  def initialize(arg=[])
    super(arg)
  end

  alias_method :enqueue, :push
  alias_method :dequeue, :shift
end

mq = MyQueue.new

mq.enqueue(123)
mq.enqueue(234)

p mq.dequeue        # 123
p mq.dequeue        # 234


这里还有一种方法,就是从Delegator 继承,然后实现__getobj__ 方法,这也是SimpleDelegator 的实现方法。

如果你想要更多的控制,你可能想做到方法的委托,而不是类的委托,这时你可以使用forwardable 库。
require 'forwardable'

class MyQueue
  extend Forwardable

  def initialize(obj=[])
    @queue = obj    # delegate to this object
  end

  def_delegator :@queue, :push,  :enqueue
  def_delegator :@queue, :shift, :dequeue

  def_delegators :@queue, :clear, :empty?, :length, :size, :<<

  # Any additional stuff...
end


在这里要注意,def_delegator方法也就是把push方法委托到@queue对象,并且重命名为enqueue方法。

而def_delegators则是直接把他后面的参数都委托给@queue对象,并且方法名不变。

这个控制的比我们第一个例子,控制的细的多。

看例子:

q1 = MyQueue.new                    # use an array
q2 = MyQueue.new(my_array)          # use one specific array
q3 = MyQueue.new(Queue.new)         # use a Queue (thread.rb)
q4 = MyQueue.new(SizedQueue.new)    # use a SizedQueue (thread.rb)


q3和 q4 都是线程安全的,因为他们委托给了一个线程安全的对象。

SingleForwardable 操作实例。当你需要把一个指定的对象委托给另一个对象时,就用得到了。

你可能会问有了委托,我们还要继承干嘛?这是一个错误的问题。比如ruby中没有多继承,你这时就能使用委托,来模拟实现。

5 自动定义类级别的读方法和写方法。

ruby中不能自动创建这个,可是我们可以模拟实现。

class MyClass

  @alpha = 123                # Initialize @alpha

  class << self
    attr_reader :alpha          # MyClass.alpha()
    attr_writer :beta           # MyClass.beta=()
    attr_accessor :gamma        # MyClass.gamma() and
  end                           #   MyClass.gamma=()

  def MyClass.look
    puts "#@alpha, #@beta, #@gamma"
  end

  #...
  end


  puts MyClass.alpha             # 123
  MyClass.beta = 456
  MyClass.gamma = 789
  puts MyClass.gamma             # 789

  MyClass.look                   # 123, 456, 789


这里要注意的是,这里我们打开了一个singleton class ,在一个singleton class 里面的实例变量,其实就是外面那层类的类实例变量.类实例变量不会被继承体系所共享,他是严格的per-class 。














3
0
分享到:
评论

相关推荐

    Addison Wesley The Ruby Way 2Nd Edition Oct 2006.pdf(英文版)

    ### Addison Wesley《The Ruby Way》第二版(2006年10月) #### 书籍概览 《The Ruby Way》是由Hal Fulton编写的关于Ruby编程语言的经典著作,该书的第二版出版于2006年10月,由Addison Wesley Professional出版社...

    ruby-event-oop

    继承、封装和多态是OOP的三大特性,它们在Ruby中都有强大的支持。 在"ruby-event-oop"中,我们可能关注以下几点: 1. **EventMachine库**:Ruby社区广泛使用的事件库,它提供了一个异步I/O框架,允许开发者编写...

    prototype_oop_javascript_ruby_prototype_

    标题 "prototype_oop_javascript_ruby_prototype_" 暗示了我们将探讨的是关于原型(Prototype)面向对象编程(Object-Oriented Programming, OOP)的概念,主要关注JavaScript和Ruby这两种语言之间的相似性和差异性...

    php中高级OOP技术

    在PHP中,面向对象编程(OOP)是高级开发中不可或缺的一部分。OOP技术使得代码更加模块化、可维护和可扩展。以下是对标题和描述中提到的几个关键知识点的详细解释: 1. **序列化(Serializing)**: 序列化是将对象...

    探索C语言中的面向对象编程:模拟OOP特性

    尽管C语言不是面向对象的编程语言,但通过结构体、函数指针和手动内存管理等技术,我们仍然可以在C语言中模拟面向对象编程的一些核心特性。这种方法虽然有一定的局限性,但也提供了足够的灵活性,允许我们在C语言中...

    C#继承OOP实例

    C#继承OOP实例源码Class 。 `

    .NET C# OOP面向对象技术

    面向对象编程(Object-Oriented Programming,简称OOP)是软件开发中的一种核心编程范式,C#语言作为.NET框架的主要编程语言,充分利用了OOP的特性。在本主题".NET C# OOP面向对象技术"中,我们将深入探讨C#中的面向...

    Ruby编程Ruby Programming

    这本面向初学者和高级读者的指南旨在全面介绍Ruby编程语言的基础及其高级特性,因此我们将从多个角度来解析这些内容。 ### 一、Ruby编程语言简介 #### 1.1 Ruby语言的历史与发展 Ruby是一种动态、面向对象的脚本...

    ruby 经典教程从新手到专家

    - **面向对象编程(OOP)**:详细解释Ruby中的类、对象、继承、封装、多态等OOP核心概念。 - **程序结构**:探讨模块、混合和命名空间,如何组织大型Ruby项目。 #### 第二部分:进阶技巧 - **元编程**:讲解Ruby的元...

    Ruby语言入门教程v1.0

    教程的第二章提供了Ruby的下载和安装指南,针对不同操作系统(如Windows)给出了具体步骤。随后,通过编写第一个小程序,让学习者快速上手,体验Ruby的基本语法和运行流程。这不仅增强了学习者的实践能力,也激发了...

    eloquent ruby

    2. **面向对象编程(OOP)** - Ruby是一种纯面向对象的语言,一切皆对象。 - 类(Class)与实例(Instance)的概念。 - 继承(Inheritance)与多态(Polymorphism)。 - Ruby的元编程特性,如模块(Module)和混入(Mixins)等...

    From Java to Ruby

    Ruby是一种灵活、简洁且富有表现力的编程语言,它提倡元编程和代码简洁性,与Java的面向对象特性有所不同。 首先,我们要理解Java和Ruby在面向对象编程(OOP)上的差异。Java的OOP体系严谨,类定义严格,而Ruby则...

    C++(OOP)教材

    继承是OOP的另一个关键特性,允许新类从已有的类(父类)继承属性和方法,同时还可以添加新的特性或修改已有行为。这样,代码复用性大大提升,软件设计的灵活性也得以增强。父类和子类的关系形成了类的层次结构,...

    PHP OOP入门必读

    "PHP5面向对象初步(第二章).php"可能涉及封装的概念,这是OOP的四大特性之一。封装允许我们将数据和操作这些数据的方法绑定在一起,保护内部数据不受外界干扰。通过访问修饰符(如public、private、protected),...

    learn_oop_ruby:启动School Ruby OOP教程

    在Ruby编程语言中,面向对象编程(Object-Oriented Programming, OOP)是一种核心特性,它使得代码更加结构化和可重用。"learn_oop_ruby:启动School Ruby OOP教程"是一个针对初学者的资源,旨在帮助他们掌握Ruby中的...

    新闻快客(纯OOP编写)

    面向对象编程是现代软件开发中的核心编程范式之一,它以类和对象为基本单元,强调数据封装、继承和多态这三大特性。这款应用的创建旨在帮助学员深入理解和实践OOP思想。 首先,我们要理解什么是面向对象编程。OOP的...

    浅谈OOP之uml设计模式

    面向对象编程(Object-Oriented Programming,简称OOP)是一种编程范式,它以对象为中心,强调数据和操作数据的方法,通过封装、继承和多态等特性来实现软件的模块化和可扩展性。在OOP中,UML(Unified Modeling ...

    从零开始学习Ruby编程-基础语法与进阶实战

    内容概要:本文是一份详尽的Ruby语言教程,涵盖从基础知识到高级特性的多个方面。文章首先介绍了Ruby的基本情况,包括其历史背景和主要特性。接着,详细讲解了Ruby环境的搭建过程,适用于各种常见操作系统。接下来,...

Global site tag (gtag.js) - Google Analytics