Ruby中类 模块 单例方法 总结

最新推荐文章于 2022-04-26 20:39:16 发布
最新推荐文章于 2022-04-26 20:39:16 发布
阅读量160 收藏
点赞数
文章标签： ruby python
原文链接：https://my.oschina.net/u/3544267/blog/1574387
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

# 1 单例方法的一种写法和定义
# 在Ruby里，可以给具体的实例对象添加实例方法，这个方法只属于这个实例
# 对象，我们把这样的方法称之为单例方法。
# 单例方法也叫作单件方法。定义单例方法，首先要生成一个实例对象，其次，
# 要在方法名前加上对象名和一个点号“.”。
# 在下面示例中，对象p1不可以laugh , laugh方法只属于p2对象。
# 实例方法，属于类的每个实例对象。单例方法只出现在单个实例对象中。用单
# 例方法可以极大地丰富多态性在Ruby中的表现力。
class Person
end

p1 = Person.new
p2 = Person.new

def p1.lagugh
  puts '这是p1所独有的单例子方法'
end

# 2 接下来我们再看下导入模块
module MyModule
  def a_method
    puts 'Hello MyModule'
  end
end

# 3 直接extend导入 将模块的实例方法变为类方法
class F
  extend MyModule
end
F.a_method

# 4 直接include导入 将模块的实例方法变为实例方法
class H
  include MyModule
end
h = H.new
h.a_method

# 5 class << self 中 include Mymodule
# 此写法与类方法相同 使用include导入后变成类方法
class G
  class << self
    include MyModule
  end
end
G.a_method

# 6 用class << self 的写法无法使用extend
# class H
#   class << self
#     extend MyModule
#   end
# end
# H.a_method
# h.a_method
# H.a_method

# 7 使用实例 extend导入
obj = Object.new
obj.extend(MyModule)
obj.a_method

# 8 先说结论,本质上混入 module 都是将 Module 中的方法引入到对象(obj, 类E, 类F)的singleton_class(单件类)中.
# Ruby允许给单个对象增加方法,这种只针对单个对象生效的方法，称为单件方法。
# 9 extend与inclue 的区别
# include include to Object class
# extend include to Obj's singleton class
# 10总结 在类定义中使用include和extend时候
# include将类中的实例方法mixin变成类的实例方法
# extend将类中的实例方法变成类方法
# 但include可以使用定义类方法的class << self方法导入
# extend则可以通过实例mixn 究其原因
# include是将模块中的方法mixin对象的类中
# extend将模块中的方法mixin对象的单例类中
# 11 单例方法只属于这个对象 不属于这个类 这个类的其他实例都没有这个方法 因为单例方法就是这个类的 单例类的实例方法
# 每个对象的singleton class都不一样 每个对象都有自己的singleton class

str = 'Hello Ruby'
str2 = 'Hello Java'
def str.foo
  puts 'str的单例方法'
end

str.foo
# str2是没有foo这个属于str的单例方法的
# str2.foo

# 12 通过输出可知 str 和 str2 这两个类的内存地址不同 是相同类型的不相等的类
# str 和 str2 的类型也是 Class 类 把 Class看成对象
p str2.singleton_class
p str.singleton_class

# singleton_class 也是 Class类的一个对象
p str.singleton_class.class

# str2的实例方法中就没有str实例方法foo
# 13 所以 方法foo 可以看成是这个单例类的实例对象的方法
p str.singleton_class.instance_methods(false)
p str2.singleton_class.instance_methods(false)
p str.methods.grep(/foo/)
p str2.methods.grep(/foo/)

# 14 Ruby中类也是对象,而类名只是常量,所以在类上调用方法其实跟在对象上调用方法一样:
# 15 类方法的实质是:它是一个类的单件方法,实际上如果比较单件方法的定义和类方法的定义,会发现其实二者是一样的.

## 在定义单件方法时,存在着相似的地方
## 二者均使用了def关键词做定义。
## 上面的object可以是*对象的引用、常量类名或者self。
# 16 类方法定义与单例方法定义的比较
obj = Object.new

# 17 单例方法的定义
def obj.a_singleton_method
end

# 18 类方法的定义
class Myclass
  def self.clazz_method1
    puts '类方法1'
  end

  def Myclass.clazz_method2
    puts '类方法2'
  end

  class << self
    def clazz_method3
      puts '类方法3'
    end
  end
end

class << Myclass
  def clazz_method4
    puts '类方法4'
  end
end

def Myclass.clazz_method5
  puts '类方法5'
end

Myclass.clazz_method1
Myclass.clazz_method2
Myclass.clazz_method3
Myclass.clazz_method4
Myclass.clazz_method5

# 17 所以,单件方法可以认为是添加在对象的某个空间内只针对该对象有效的方法.
# 如果对象是个实例对象,添加的方法就是他的单件方法,
# 如果对象是个类,添加的方法就是这个类的类方法.

# 18 我们知道Ruby中对象的方法的查找顺序是:先向右,再向上,其含义就是先向右找到对象的类,
# 先在类的实例方法中尝试查找,如果没有找到,再继续顺着祖先链找.
# 前面介绍的单件方法是指那些只针对某个对象有效的方法，那么如果为一个对象定义了单件方法,
# 那么这个单件方法的查找顺序又应该是怎样的?

class Myclass
  def my_method
  end
end

obj = Myclass.new

def obj.my_singleton_method
end

# 19 首先,单件方法不会在obj中,因为obj不是一个类,其次它也不在MyClass中,
# 那样的话所有的MyClass实例都应该能共享调用这个方法,也就构不成单件类了.
# 同理,单件方法也不能在祖先链的某个位置(类似superclass: Object)中.
# 正确的位置是在单件类中，这个类其实就是我们在irb中向对象询问它的类时(obj.class)得到的那个类,
# 不同的是这类与普通的类还是有稍稍不同的.也可以称其为元类或本征类.
# 前提及到的实例对象的单件方法和类的类方法在创建上是类似的,
# 所以,通过的关键词class配合特殊的语法应该可以将其取到.class << obj.

# 20 如果存在单件方法那么查找顺序先去类去中的单例方法
class C
  def a_method
    puts 'C#a_method'
  end
end

class D < C
end

d = D.new
d.a_method # C#a_method

puts 'abc'.singleton_class #<Class:#<String:0x0000000002ec90a8>> String类的实例

class << d
  def d_method
    puts 'D#d_method'
  end
end

puts d.singleton_class #<Class:#<D:0x0000000002ec9238>> Class类的实例
puts d.singleton_class.class # singleton_class 的类型是Class
## 既然d.singleton_class 也是个类,那么久试着查一下他的父类
puts d.singleton_class.superclass # D
## singleton_class是一个类，那么它肯定有父类，它的父类就是对象所属的类
## 单例方法则存在于对象的特征类中
# 单例方法存在于 对象单例类的实例方法中
puts d.singleton_class.instance_methods.grep(/d_method/)  ## d_method
puts d.singleton_class.instance_methods(false)

# 打开单件类
# Ruby 中 class 作用是把代码的上下文变换到这个类中,也就是『打开类』,
# 同一个类可以在任何地方被打开,也因此别人的类可以被自己随意打开并改写.
# Ruby提供了两种方法获取单件类的引用，一种是通过传统的关键词class配合特殊的语法。
# 通过关键字 class << obj 打开实例对象的单件类空间,为对象添加一系列的单件方法.
# 单件类的本质还是一个类,是一个拥有唯一实例的类,所以叫单件类,或者单例类.

# 定义对象的一系列单件方法
# class << an_object
#   def a_singleton_method
#     puts '单例方法1'
#   end
# end

obj = Object.new
singleton_class = class << obj
                    self
end
p singleton_class.class

# 另一个方法是，通过Object#singleton_class方法来获得单件类的引用:

p singleton_class = 'abc'.singleton_class  #<Class:#<String:0x0000000002ed7d10>>
p singleton_class.class # => Class

# 单件类的特性
# 1. 每个单件类只有一个实例(被称为单件类的原因),而且不能被继承.
# 2. 单件类是一个对象的单件方法的存活所在.
# 3. 引入单件类后的方法查找
# 基于上面对单件类的基本认识,引入单件类后,Ruby的方法查找方式就不应该是先从其类(普通类)开始,
# 而是应该先从对象的单件类中开始查找,如果在单件类中没有找到想要的方法,它才会开始沿着类(普通类)开始,
# 再到祖先链上去找.这样从单件类之后开始,一切又回到了我们在没有引入单件类时候的次序.
# 类方法,实例方法,单例方法
# 类方法只有类本身可以调用,在ruby中,类方法是一种特殊的单例方法.
# 之前的例子中可以得到这样的结论,singleton_class也是一种类，
# 在ruby中所有的类又都是对象.对象都有对应的singleton_class.

# Ruby 中方法的查找 遵循的规则是 'one step to the right, then up',即 向右一步然后向上.
# Ruby中查找顺序
# 1singleton method defined on object
# 1* super class of singleton class
# 2 instance method defined in class
# 3 instance method defined in module
# reverse order in which they were included
# 4 instance method defined in ancestors
# 5 method_missing defined in Kernel module

class C
  def a_method
    puts 'C#a_method'
  end

  def self.a_class_method
    puts 'C#a_class_method'
  end
end

class D < C
end

obj = D.new

class << obj
  def a_singleton_method
    puts 'obj#a_singleton_method'
  end
end

# 欲调用 obj.a_singleton_method
# 此时调用对象是obj ,则会先去 #obj 处查找(向右一步)
# #obj
puts obj.a_singleton_method #obj#a_singleton_method

# 欲调用 D.a_class_method
# 此时调用对象是D ,则会先去 #D 出查找(向右一步)
# D.singleton_class 然后往上查(superclass)
# 单例类的父类就是对象所属的类
puts D.singleton_class.superclass #<Class:C>
puts D.singleton_class.class #Class
puts D.singleton_class.class.superclass #Module
# #D -> #C
# D的类方法方法 a_class_method 在 #C 里
puts D.a_class_method ## C#a_class_method

# 欲调用 obj.a_method
# 此时调用对象是obj ,则会先去 #obj 处查找(向右一步)
puts obj.singleton_class ## #<Class:#<D:0x007f9e88340b60>>
# obj.singleton_class 然后往上查(superclass)
puts obj.singleton_class.superclass ## D
# #obj 的父类 是 D 然后往上查(superclass)
puts D.superclass  ## C
# D 的父类 是 C
# 查找顺序即: #obj -> D -> C
# D的实例方法 a_method 在 类C 里
obj.a_method  ## C#a_method

###module
module C
  def foo
    puts 'foo in C'
  end
end

module D
  def foo
    puts 'foo in D'
  end
end

####classess
class A
  def foo
    puts 'foo in A'
  end
end

# class B < A
#   # include C
#   # include D
#   # def foo
#   #   puts 'foo in B'
#   # end
# end

class E
end

a = A.new
# b = B.new
e = E.new

# def b.foo
#   puts 'singleton foo'
# end

# 1 第一种情况有单例方法
# 输出 foo in A 和 singleton foo
a.foo
# b.foo
e.foo

# 2 第二种情况去除 单例方法
# 输出 foo in A  foo in B

# 3 第三种情况去除 类中的实例方法
# 输出foo in A 和 foo in D

# 4 第四种情况 从父类中找实例方法
# 输出foo in A 和 foo in A

# 5 父类中找不到的话就是方法丢失

# 总结找方法 先找单例中的方法 然后是类中定义的实例方法 模块中的实例方法 祖先类的实例方法 underfined method

 

转载于:https://my.oschina.net/u/3544267/blog/1574387

weixin_33854644
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Ruby实现单例模式
teashown
06-27 931
单例模式是一种常用的设计模式，在ruby的标准库中有singleton模块，可以直接像下面这样使用： require 'Singleton' class Test include Singleton end a, b = Test.instance, Test.instance puts a==b #=>true 如果不使用标准库，该如何实现呢？在看完《ruby元编程》第五章后
Ruby module里使用类方法
weixin_42842896的博客
12-10 622
直接上代码： module M # 一个普通的实例方法 def mul @x * @y end module ClassMethods # 一个类方法 def factory(x) new(x, 2 * x) end end #included方法是include方法的回调 def self.included(base)...
RUBY设计模式之单例模式
bee100的专栏
03-10 172
     单例singleton，是所有设计模式中最简单的，但又是问题最多的。其实并不简单，一定要慎用。        singleton,和全局变量很相似，所以要尽量的不用它，问题也就不会出来。而不是我们常常说的那样这个我们可以用   singleton来实现。不出问题的唯一方法就是：别那么做。        如果要使用了，在使用之前必须知道你要做的东西是否必须要用他来实现，还有就是...
ruby 中的单件方法和单件类
weixin_33878457的博客
06-11 191
singleton_class 和Singleton Method class 混入 module 时的相关思考 在Ruby里, 我们可以通过在 class 里混入 module 来达到一些用途,那么 module 里面的代码是怎么混入class 里,又是被放置在了什么地方呢? module MyModule def a_...
Ruby 的 Singleton 单例模块
Looking的博客
04-26 739
一般来说，对于某个类，我们可以创建无穷多个对象，且不会受到任何限制。但是，有时候，我们只需要类的一个实例来协调整个程序的操作，并不需要多个实例。对于这种场景，我们希望确保正在运行的程序只存在给定类的一个实例。也就是所谓的 单例模式。单例模式 是一种设计模式，它将给定类的实例化限制为一个对象。 常规模式 直接用例子来说更简单易懂一些。 class HelloWorld def instance_method puts "instance method" end end
ruby的单例方法
系统运维
06-22 131
=begin 在Ruby里，可以给具体的实例对象添加实例方法，这个方法只属于这个实例 对象，我们把这样的方法称之为单例方法。 单例方法也叫作单件方法。定义单例方法，首先要生成一个实例对象，其次， 要在方法名前加上对象名和一个点号“.”。 在下面示例中，对象p1不可以laugh , laugh方法只属于p2对象。 实例方法，属于类的每个实例对象。单例方法只出现在单个实例对象中。用单 例...
Ruby中钩子方法的运用实例解析
09-21
通过以上内容，我们可以了解到Ruby钩子方法在实际编程中的应用，如何监控和控制类或模块的生命周期，以及如何利用它们实现更高级的功能，如属性验证。理解并熟练使用这些钩子方法对于提升Ruby编程的效率和代码质量...
详解Ruby设计模式编程中对单例模式的运用
09-21
主要介绍了Ruby设计模式编程中对单例模式的运用,讲到了包括对Singleton模块的使用,需要的朋友可以参考下
poodir:Ruby 中实用的面向对象设计
07-07
在Ruby编程语言中，面向对象设计（Object-Oriented Design, OOD）是一种常见的软件开发方法，它将现实世界中的实体抽象为类，通过实例化这些类来创建对象，以此来处理复杂的数据和逻辑。"poodir"项目，根据其标题...
Ruby API 帮助文档.zip
07-03
Ruby API 帮助文档是开发者们在...以上只是Ruby API帮助文档中涵盖的部分关键知识点，实际内容会更广泛，包括更多类、模块和框架的详细说明。在开发过程中，不断查阅和理解这些文档将极大地提升开发效率和代码质量。
Ruby-Ruby中的GoF设计模式实现
08-15
GoF设计模式是四本同名书籍中的核心概念，由Erich Gamma、Richard Helm、Ralph Johnson和John Vlissides四位作者提出，书中总结了23种经典的设计模式。 1. **工厂模式**：这个模式提供了一种创建对象的方式，而无需...
Ruby单例模式写法
素年小事
09-06 290
Ruby单例模式写法:   class Logger @@instance = Logger.new def self.instance return @@instance end private_class_method :new end logger1 = Logger.instance logger2 = Logger.i...
[ruby]单例类 singleton class，class_eval vs instance_eval
深度的博客
08-29 186
单例类定义被用于定义对象的专属实例方法。 # 初始化变量 str1 = 'Ruby' # String的一个对象 str2 = 'Ruby' # String的一个对象 str3 = 'ruby' # String的一个对象 str4 = [1,2] # Array的一个对象 str5 = {a:6} # Hash的一个对象 str6 = 1 # Numeric的一个对象 str7 = Numeric.new 在类中定义类方法， class << 类名 ~ end这种写法的.
ruby中的类方法与单例类
Nick_Zhang的专栏
08-07 2076
类方法 类方法：方法的接受者就是类本身的方法称为类方法。 直白一点来说，类方法不需要实例化得到对象去调用，可以直接通过类名.方法名去调用一个方法。 类方法有三种定义形式 第一种：class class def hello(name) p "#{name},hello" end end 第二种：class class Hello class def hello(na
ruby单例方法 单例类_Ruby中的单例方法
cumtv80668的专栏
07-31 269
ruby单例方法 单例类 Ruby| 单例方法 (Ruby | Singleton Methods) In the last tutorial frozen objects, we have studied the way to freeze the objects in Ruby. We can't assign singleton methods to the objects which ar...
Ruby设计模式透析之 —— 单例(Singleton)
runfeel
04-30 392
转载请注明出处：http://blog.csdn.net/sinyu890807/article/details/8868758 此为Java设计模式透析的拷贝版，专门为Ruby爱好者提供的，不熟悉Ruby语法的朋友请转阅 ： Java设计模式透析之 —— 单例(Singleton) 写软件的时候经常需要用到打印日志功能，可以帮助你调试和定位问题，项目上线后还可以帮助你分析数据，但是...
ruby Singleton Class和Singleton Method
eric的博客
07-11 1307
也许你经常听说singleton class，但是并没有搞清楚它到底是什么，为啥呢，就我查的，概念太绕。绕了半天也不知道咋回事，所以要总结下呢，咳咳。 首先我们要搞明白一个问题，管他是不是单例类，所以我们先搞明白一个类中的作用域，先举个例子吧： class A p self class self p self end def hello
ruby中的单例模式
u012966670的专栏
08-06 334
#引入文件singleton，引入模块Singleton require 'singleton' class Singletontest attr_accessor :data include Singleton end a=Singletontest.instance b=Singletontest.instance p a.inspect p b.inspect
Ruby语言进阶探索
第六章深入介绍了面向对象编程在Ruby中的应用，包括方法的重载和重写、增强父类方法、实例变量、类变量、类方法以及单例方法。这些概念是理解Ruby面向对象编程的关键，也是提升代码组织和复用能力的基础。 第七章...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值