Ruby类

Ruby类

类定义

1. #!/usr/bin/ruby
2. class Sample
3. def hello
4. puts "Hello Ruby!"
5. end
6. end
7. # 使用上面的类来创建对象
8. object = Sample. new
9. object.hello

注意：无参数的函数调用可以省略()

初始化方法

初始化方法有一个统一的名字叫 initialize

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）。

变量(就是 局部变量)

变量的打印

变量在打印的时候不能省略 大括号，别的类型变量都可以省略大括号，比如

你这样打印变量是打不出东西的

错误的写法

1. a=1
2. b=2
3. puts "a: #a"
4. puts "b: #b"

打印结果

1. a: #a
2. b: #b

正确的写法

1. a=1
2. b=2
3. puts "a: #{a}"
4. puts "b: #{b}"

打印结果

1. a: 1
2. b: 2

变量的生存周期

变量的生存周期只在方法中，出了方法就没了，所以也只能定义在方法里面，比如

错误的写法

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()

输出

1. test.rb:5:in `printVar': undefined local variable or method `a' for #<Test2:0x00000002cf2248> (NameError)
2. from test.rb:10:in `<main>'

正确的写法

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)

输出

1. a: 1
2. b: 2

变量的传递

简单类型是值拷贝（字符串也是简单对象，这点跟java不一样）

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)

输出

1. before add : a: 1  b: 2
2. after add : a: 1  b: 2

复杂对象是对象引用

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. class Test2
16. def testPass()
17. testobj = Obj1.new("hello")
18. a = testobj.getA()
19. puts "before add : a: #{a}"
20. addVar(testobj)
21. a = testobj.getA()
22. puts "after add : a: #{a}"
23. end
24. def addVar(obj)
25. obj.setA(obj.getA() + " world")
26. end
27. end
28. hellotest = Test2.new
29. hellotest.testPass()

输出

1. before add : a: hello
2. after add : a: hello world

实例变量

实例变量的打印

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

实例变量的生存周期

实例变量只能在 initialize 里面被定义。如果想像在java中这样定义是错误的

1. class LearnInstanceVar
2. @a=1
3. def printVar()
4. puts "a: #{@a}"
5. end
6. end
7. test1 = LearnInstanceVar.new
8. test1.printVar

输出

1. $ ruby test.rb
2. a:

正确的定义

1. class LearnInstanceVar
2. def initialize(a)
3. @a=a
4. end
5. def printVar()
6. puts "a: #{@a}"
7. end
8. end
9. test1 = LearnInstanceVar.new("hello")
10. test1.printVar

输出

1. $ ruby test.rb
2. a: hello

类似java中的private，但是更严格，连定义的位置都只能放在特定的方法里面

类变量

类变量的打印

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

类变量的生存周期

• 类变量可以在多个实例之间公用，类似java的 static
• 在类的方法体以外声明

比如这样定义和使用类变量

1. #!/usr/bin/ruby
2. class Customer
3. @@no_of_customers=0
4. def printCus()
5. @@no_of_customers += 1
6. puts "Total number of customers : #{@@no_of_customers}"
7. end
8. end
9. cust1=Customer.new
10. cust2=Customer.new
11. cust1.printCus()
12. cust2.printCus()

 

全局变量

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

Ruby 运算符

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

比较运算符

== 和 equal？

== 和 equal 跟java中定义的正好相反：

• equal? 是比较两个对象是否是同一个对象
• == 是比较两个对象是否相等

例子

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定义===来判断等号两边的符号对象是否相同。

例子：

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。

 

并行赋值

1. a = 10
2. b = 20
3. c = 30

可以写成这样

1. a, b, c = 10, 20, 30

于是在java和c中很麻烦的变量交换，在ruby中可以很简单的写成

1. a, b = b, c

这样的代码

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}"

执行结果为

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

比如

1. foo = 42
2. defined? foo    # => "local-variable"
3. defined? $_     # => "global-variable"
4. defined? bar    # => nil（未定义）

还可以检测方法是否定义了

1. defined? method_call # 如果方法已经定义，则为 True

1. defined? puts        # => "method"
2. defined? puts(bar)   # => nil（在这里 bar 未定义）
3. defined? unpack      # => nil（在这里未定义）

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

请记住：在 Ruby 中，类和方法也可以被当作常量。
您只需要在表达式的常量名前加上 :: 前缀，即可返回适当的类或模块对象。
如果未使用前缀表达式，则默认使用主 Object 类。

例子

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" 的局部常量