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