• 设为首页
  • 点击收藏
  • 手机版
    手机扫一扫访问
    迪恩网络手机版
  • 关注官方公众号
    微信扫一扫关注
    迪恩网络公众号
登陆 注册
描述文字

Ruby类

原作者: [db:作者] 来自: [db:来源] 收藏 邀请

类定义

[ruby] view plain copy
 
  1. #!/usr/bin/ruby  
  2.   
  3. class Sample  
  4.    def hello  
  5.       puts "Hello Ruby!"  
  6.    end  
  7. end  
  8.   
  9. # 使用上面的类来创建对象  
  10. object = Sample. new  
  11. object.hello  
注意：无参数的函数调用可以省略()

初始化方法

初始化方法有一个统一的名字叫 initialize
[ruby] view plain copy
 
  1. class Customer  
  2.    @@no_of_customers=0  
  3.    def initialize(id, name, addr)  
  4.       @cust_id=id  
  5.       @cust_name=name  
  6.       @cust_addr=addr  
  7.    end  
  8. end  

Ruby变量

ruby支持5种类型
  • 一般小写字母、下划线开头：变量（Variable）。
  • $开头：全局变量（Global variable）。
  • @开头：实例变量（Instance variable）。
  • @@开头：类变量（Class variable）类变量被共享在整个继承链中
  • 大写字母开头：常数（Constant）。

变量(就是 局部变量)

变量的打印

变量在打印的时候不能省略 大括号，别的类型变量都可以省略大括号，比如
你这样打印变量是打不出东西的
错误的写法
[ruby] view plain copy
 
  1. a=1  
  2. b=2  
  3. puts "a: #a"  
  4. puts "b: #b"  
打印结果
[ruby] view plain copy
 
  1. a: #a  
  2. b: #b  
正确的写法
[ruby] view plain copy
 
  1. a=1  
  2. b=2  
  3. puts "a: #{a}"  
  4. puts "b: #{b}"  
打印结果
[ruby] view plain copy
 
  1. a: 1  
  2. b: 2  

变量的生存周期

变量的生存周期只在方法中，出了方法就没了，所以也只能定义在方法里面，比如
错误的写法
[ruby] view plain copy
 
  1. class Test2  
  2.     a=1  
  3.     b=2  
  4.     def printVar()  
  5.         puts "a: #{a}"  
  6.         puts "b: #{b}"  
  7.     end  
  8. end  
  9. hellotest = Test2.new  
  10. hellotest.printVar()  
输出
[plain] view plain copy
 
  1. test.rb:5:in `printVar': undefined local variable or method `a' for #<Test2:0x00000002cf2248> (NameError)  
  2.         from test.rb:10:in `<main>'  
正确的写法
[ruby] view plain copy
 
  1. class Test2  
  2.     def printVar(a,b)  
  3.         puts "a: #{a}"  
  4.         puts "b: #{b}"  
  5.     end  
  6. end  
  7. hellotest = Test2.new  
  8. hellotest.printVar(1,2)  
输出
[plain] view plain copy
 
  1. a: 1  
  2. b: 2  

变量的传递

简单类型是值拷贝（字符串也是简单对象，这点跟java不一样）
[ruby] view plain copy
 
  1. class Test2  
  2.     def testPass(a,b)  
  3.         puts "before add : a: #{a}  b: #{b}"  
  4.         addVar(a,b)  
  5.         puts "after add : a: #{a}  b: #{b}"  
  6.     end  
  7.     def addVar(a,b)  
  8.         a += 1  
  9.         b += 2  
  10.     end  
  11. end  
  12. hellotest = Test2.new  
  13. hellotest.testPass(1,2)  
输出
[ruby] view plain copy
 
  1. before add : a: 1  b: 2  
  2. after add : a: 1  b: 2  
复杂对象是对象引用
[ruby] view plain copy
 
  1. class Obj1  
  2.     def initialize(a)  
  3.         @a=a  
  4.     end  
  5.     def printVal()  
  6.         puts "a: #@a"  
  7.     end  
  8.     def setA(a)  
  9.         @a=a  
  10.     end  
  11.     def getA()  
  12.         return @a  
  13.     end  
  14. end  
  15.   
  16.   
  17. class Test2  
  18.     def testPass()  
  19.         testobj = Obj1.new("hello")  
  20.         a = testobj.getA()  
  21.         puts "before add : a: #{a}"  
  22.         addVar(testobj)  
  23.         a = testobj.getA()  
  24.         puts "after add : a: #{a}"  
  25.     end  
  26.     def addVar(obj)  
  27.         obj.setA(obj.getA() + " world")  
  28.     end  
  29. end  
  30. hellotest = Test2.new  
  31. hellotest.testPass()  
输出
[plain] view plain copy
 
  1. before add : a: hello  
  2. after add : a: hello world  

实例变量

实例变量的打印

实例变量的打印是可以省略大括号的，比如 #@a  跟 #{@a} 是一回事

实例变量的生存周期

实例变量只能在 initialize 里面被定义。如果想像在java中这样定义是错误的
[ruby] view plain copy
 
  1. class LearnInstanceVar  
  2.     @a=1  
  3.     def printVar()  
  4.         puts "a: #{@a}"  
  5.     end  
  6. end  
  7.   
  8. test1 = LearnInstanceVar.new  
  9. test1.printVar  
输出
[plain] view plain copy
 
  1. $ ruby test.rb  
  2. a:  
正确的定义
[ruby] view plain copy
 
  1. class LearnInstanceVar  
  2.     def initialize(a)  
  3.         @a=a  
  4.     end  
  5.     def printVar()  
  6.         puts "a: #{@a}"  
  7.     end  
  8. end  
  9.   
  10. test1 = LearnInstanceVar.new("hello")  
  11. test1.printVar  
输出
[plain] view plain copy
 
  1. $ ruby test.rb  
  2. a: hello  
类似java中的private，但是更严格，连定义的位置都只能放在特定的方法里面

类变量

类变量的打印

类变量的打印是可以省略大括号的，比如 #@@a  跟 #{@@a} 是一回事

类变量的生存周期

  • 类变量可以在多个实例之间公用，类似java的 static
  • 在类的方法体以外声明
比如这样定义和使用类变量
[ruby] view plain copy
 
  1. #!/usr/bin/ruby  
  2.   
  3. class Customer  
  4.   @@no_of_customers=0  
  5.   def printCus()  
  6.     @@no_of_customers += 1  
  7.     puts "Total number of customers : #{@@no_of_customers}"  
  8.   end  
  9. end  
  10.   
  11. cust1=Customer.new  
  12. cust2=Customer.new  
  13.   
  14. cust1.printCus()  
  15. cust2.printCus()  
 

 全局变量

  • 全局变量以$符号打头
  • 全局变量可以在类与类之间共享

Ruby 运算符

下面只说ruby比较特殊的一些运算符

比较运算符

== 和 equal？

== 和 equal 跟java中定义的正好相反：
  • equal? 是比较两个对象是否是同一个对象
  • == 是比较两个对象是否相等
例子
[ruby] view plain copy
 
  1. a = "Ruby" # 定义一个字符串对象  
  2. b = "Ruby" # 虽然和a的内容相同，但是他们是不同的对象  
  3. a.equal?(b) # false: a和b指向不同的对象  
  4. a == b # true: 他们的内容是相同的  

eq? 是 equal? 的缩写

<=>  联合比较运算符

这是一个神奇的运算符：联合比较运算符。如果第一个操作数等于第二个操作数则返回 0，如果第一个操作数大于第二个操作数则返回 1，如果第一个操作数小于第二个操作数则返回 -1。

=== 三等号


这个运算符更神奇：
通常情况下这中方式与==是一样的，但是在某些特定情况下，===有特殊的含义：

  • 在Range中===用于判断等号右边的对象是否包含于等号左边的Range；
  • 正则表达式中用于判断一个字符串是否匹配模式，
  • Class定义===来判断一个对象是否为类的实例，
  • Symbol定义===来判断等号两边的符号对象是否相同。
例子：
[ruby] view plain copy
 
  1. (1..10) === 5 # true: 5属于range 1..10  
  2. /\d+/ === "123" # true: 字符串匹配这个模式  
  3. String === "s" # true: "s" 是一个字符串类的实例  
  4. :s === "s" # true   

.eql?

如果接收器和参数具有相同的类型和相等的值，则返回 true。比如 1 == 1.0 返回 true，但是 1.eql?(1.0) 返回 false。
 

并行赋值

[ruby] view plain copy
 
  1. a = 10  
  2. b = 20  
  3. c = 30  
可以写成这样
[ruby] view plain copy
 
  1. a, b, c = 10, 20, 30  
于是在java和c中很麻烦的变量交换，在ruby中可以很简单的写成
[ruby] view plain copy
 
  1. a, b = b, c  
这样的代码
[ruby] view plain copy
 
  1. a=1  
  2. b=2  
  3. c=3  
  4. a,b=b,c  
  5. puts "a: #{a}"  
  6. puts "b: #{b}"  
  7. puts "c: #{c}"  
执行结果为
[plain] view plain copy
 
  1. $ ruby test.rb  
  2. a: 2  
  3. b: 3  
  4. c: 3  

范围运算符

  • 1..10 创建了一个从1 到10的范围，并且包含10
  • 1...10 跟上面那个唯一的不同是不包含10

define? 运算符

我们在别的语言中都见到过如何判断变量是否被定义的方法，比如js的是否等于undefined，和php的isset，ruby专门为这种操作设计了一个运算符叫 define? 这个运算符不仅可以告诉你该变量是否定义还可以告诉你变量的范围
defined? variable # 如果 variable 已经初始化，则为 True
比如
[ruby] view plain copy
 
  1. foo = 42  
  2. defined? foo    # => "local-variable"  
  3. defined? $_     # => "global-variable"  
  4. defined? bar    # => nil（未定义）  
还可以检测方法是否定义了
[ruby] view plain copy
 
  1. defined? method_call # 如果方法已经定义，则为 True  
[ruby] view plain copy
 
  1. defined? puts        # => "method"  
  2. defined? puts(bar)   # => nil（在这里 bar 未定义）  
  3. defined? unpack      # => nil（在这里未定义）  

Ruby 点运算符 "." 和双冒号运算符 "::"

请记住：在 Ruby 中，类和方法也可以被当作常量。
您只需要在表达式的常量名前加上 :: 前缀，即可返回适当的类或模块对象。
如果未使用前缀表达式，则默认使用主 Object 类。
例子
[ruby] view plain copy
 
  1. MR_COUNT = 0        # 定义在主 Object 类上的常量  
  2. module Foo  
  3.   MR_COUNT = 0  
  4.   ::MR_COUNT = 1    # 设置全局计数为 1  
  5.   MR_COUNT = 2      # 设置局部计数为 2  
  6. end  
  7. puts MR_COUNT       # 这是全局常量  
  8. puts Foo::MR_COUNT  # 这是 "Foo" 的局部常量   

鲜花
握手
雷人
路过
鸡蛋
该文章已有0人参与评论

请发表评论

全部评论

专题导读
More+
上一篇：
脱离Rails看Ruby发布时间：2022-07-13
下一篇：
ruby start发布时间：2022-07-13
热门推荐
More+
热门话题
More+
阅读排行榜

扫描微信二维码

查看手机版网站

随时了解更新最新资讯

139-2527-9053

在线客服（服务时间 9:00～18:00）

在线QQ客服
地址：深圳市南山区西丽大学城创智工业园
电邮：jeky_zhao#qq.com
移动电话：139-2527-9053

Powered by 互联科技 X3.4© 2001-2213 极客世界.|Sitemap