Ruby类，模块1

类的扩展和继承

class Fixnum

  def dosome(str)

    puts str

  end

  def abs

    puts "覆盖了原有的方法"

  end

end

puts 1.class

1.dosome("动态添加的方法")

1.abs#覆盖原有的方法

 

freeze冻结对象

class Test

  attr_accessor :value 

end

t=Test.new

t.value=1

a="test"

a.freeze

#a<<"1" 异常 a<<"1"或导致生成一个新的对象，a=a+"1"还是指向原有的对象

a=a+"1"

puts a

#t.freeze 冻结不能在被修改，所以下面扩展修改该对象就会报错TypeError



def t.newmethod()

  puts "t的新方法"

end



dup=t.dup

clone=t.clone

t.value=2

puts t.value

t.newmethod

clone.newmethod#clone获取到了为t定义的方法newmethod

#dup.newmethod dup没有获得为t定义的方法newmethod

=begin

dup和clone都能复制对象的内容数据，唯一不同的是clone方法还能保留与对象相关联的方法等内容。

dup和clone都是浅复制，如果对象中还包含了对其他对象的引用，将不会复制这些包含的对象，而只是复制了它们的引用。

=end

序列化

class My_class

  attr_accessor :value 

end

a=My_class.new

a.value=123

#获取a的序列化字符

tempa=Marshal.dump(a)

puts tempa

#通过序列化字符重建对象

b=Marshal.load(tempa)

puts b.class

puts b.value

=begin
对象序列化方式不仅限于Marshal，还有其他方式，Marshal是Ruby内置的模块，性能还是比较出众的
=end

模块

module MyModule  

  def function

    puts "模块对象方法"

  end 

  def self.function  

    puts "模块方法"    

  end

end

module MyModule

  def self.otherfunction

    puts "模块方法2"

  end

  CONST1="模块的常量"

  module MysubModule

    CONST1="子模块的常量"

  end

end

#p =MyModule.new

#p.function 模块是没有实例对象的概念的， 使用new 会抛出异常

puts MyModule.class

MyModule.function

MyModule.otherfunction

#::来引用模块中的模块或者方法，可以看出清晰的层次结构关系，而不同模块中同名的常量或方法也不会造成冲突

MyModule::function

puts MyModule::MysubModule::CONST1

加载模块（require，load，include，extend）

#load('testxml.rb', wrap) #加载testxml.rb文件

#require 'testxml' #加载testxml库，通常也是加载testxml.rb文件

=begin

load和require都是加载相应的模块文件到当前的环境中，load会无条件的加载源文件，不管之前是否加载过。

require则会检查，保证模块只被加载过一次，经常用于加载一些扩展库。

require和load加载后，被加载文件中的局部变量不会加载进来

如果传入的文件不包含路径，会在当前加载的目录下查找搜索

=end



module MyModule

  def method

    puts "method"

  end

end

class MyClass

  include MyModule 

  #因为include作用为混入模块其作用等价于

#  def method

#    puts "method"

#  end

end

class MyClass1

  extend MyModule

  #exted方法所扩展的对象取决于调用extend方法的对象，需要注意的是该处的extend，本质上等价于self.extend MyModule

  #这里的代码中的self指代的是MyClass1类，所以MyModule被定义为MyClass1的类方法

#  def self.method

#    puts "method"

#  end

end

my_class=MyClass.new

#类中使用include 模块中的方法变成 类的实例方法

my_class.method

#类中使用extend 模块中的方法变成了 类的方法

MyClass1.method

aa="0"

#所有对象都可以extend模块而活的模块中的方法，因为aa变量所引用的是一个字符串对象的实例，extend所调用的对象为实例对象

#因此extend起作用的也是实例对象

aa.extend(MyModule)

aa.method

=begin

include和extend不会自动加载文件，他们只是将模块混入货扩展已有的模块或类。

include会建立一个由类到所包含模块的引用，自动添加为类的实例方法，当模块发生改变是，类中所混入的放发也会发生相应的改变

extend和inc极其相似，不过extend是用来在一个对象中引入一个模块，使得这个对象也具有这个模块的方法。



=end