ruby基础(四)

ruby基础知识

模块

模块是ruby的特色功能之一。如果说类是事物的实体以及行为，那么模块表现的

就是事物的行为部分，模块和类有以下两点不同：

模块不能拥有实例
模块不能被继承

模块的使用方法

module Mymodule

    #共同的方法

end

class Myclass1

    include Mymodule

    #Myclass1独有的方法

end

class Myclass2

    include Mymodule

    #Myclass2独有的方法

end

使用模块可以灵活的解决下面的问题

虽然两个类拥有相同的功能，但是不希望他们作为相同的种类来考虑
Ruby不支持父类多重继承。

ruby中模块会提供独立的命名空间，一个模块的方法、变量和另一个模块的方法、

变量是不同的。

模块函数

使用模块名.方法名的形式来调用模块中方法，这样的方法称为模块函数。

#检查文件是否存在

p FileTest.exist?("/user/bin/ruby")  #false

#圆周率常量

p Math::PI                           #3.141592653589793

使用include方法把模块内的方法名、常量名合并到当前的命名空间中

include Math

p PI  #3.141592653589793

p sqrt 2   #1.4142135623730951

创建模块

module 模块名

   模块定义

end

模块的名字必须大写。eg:

module Helloworld

  Version="1.0"

  def hello(name)

    puts "hello,#{name}."

  end

  #指定模块函数

  module_function :hello

end

Helloworld.hello("ruby")  #hello,ruby.

p Helloworld::Version  #"1.0"

include Helloworld  #包含模块

p Version  #"1.0"

hello "ruby" #hello,ruby

和类一样，在模块中定义的常量可以用模块名访问

p Helloworld::Version  #"1.0"

方法调用

如果只定义了方法，可以在模块内调用和包含该模块的语句中使用，但是不能以

“模块.方法名”调用,如果想要这样使用，可以这样在模块中使用 module_function

方法。

 module_function :hello

以“模块.方法名”调用，方法中的self指向模块对象，如果将模块包含今类中

，则该方法变成了类的实例方法,self指向类的实例。

module Helloworld

  Version="1.0"

  def hello

    self

  end

  #指定模块函数

  module_function :hello

end

p Helloworld.hello  #Helloworld

module Helloworld

  Version="1.0"

  def hello

    self

  end

end

class Foo

  include Helloworld

  def aaa

    puts "I am aaa"

  end

end

foo=Foo.new()

p foo.hello           #  #<Foo:0x0055c23667a338>

想要知道类是否包含某个模块,可以使用include?方法

module Helloworld

  Version="1.0"

  def hello

    self

  end

end

class Foo

  include Helloworld

  def aaa

    puts "I am aaa"

  end

end

p Foo.include? Helloworld  #true

类的实例在调用方法的时候，会按照类、包含的模块、父类的顺序查找方法。

被包含的模块相当于类的虚拟父类。

使用ancestors方法和superclass方法调查类的继承关系

module Helloworld

  Version="1.0"

  def hello

    self

  end

end

class Foo

  include Helloworld

  def aaa

    puts "I am aaa"

  end

end

p Foo.superclass  #Object

p Foo.ancestors   #[Foo, Helloworld, Object, Kernel, BasicObject]

p Object.ancestors #[Object, Kernel, BasicObject]

p Object.superclass #BasicObject

p BasicObject.superclass #nil

p BasicObject.ancestors  #[BasicObject]

p Class.superclass  #Module

p Class.ancestors   #[Class, Module, Object, Kernel, BasicObject]

p Module.superclass #Object

p Module.ancestors #[Module, Object, Kernel, BasicObject]

我们看出Object的父类是BasicObject.

Class的父类是Module，Module的父类是Object.

包含模块时查找方法的顺序

原类中方法优先级高于包含模块的
类中包含多个模块，优先使用最后包含的模块
多个模块，模块中包含模块，优先使用最后一个模块和模块中包含的模块。
相同模块第二次包含会被省略。

可以使用ancestors查看方法的顺序。

extend方法

Obejct#extend的方法用来给对象扩展功能

module Helloworld

  Version="1.0"

  def hello

    self

  end

end

str="ruby"

str.extend Helloworld

p str.hello  #"ruby"

ruby中的类方法：Class类的实例方法，类对象的单例方法。使用extend

方法给类添加类方法。

eg:include给对象添加实例方法，extend给类添加类方法。

module Instance_Method

  Version="1.0"

  def hello

    puts "hello"

  end

end

module Class_Method

  def say

    "Ruby"

  end

end

class Hello

  include Instance_Method

  extend  Class_Method

end

p Hello.say  #"Ruby"

Hello.new.hello  #hello

巴特西

ruby基础(四)

ruby基础知识

模块

最新文章

热门文章