Ruby類

Ruby類

類定義

#!/usr/bin/ruby

class Sample
   def hello
      puts "Hello Ruby!"
   end
end

# 使用上面的類來建立對象
object = Sample. new
object.hello

注意：無參數的函數調用能夠省略()

初始化方法

初始化方法有一個統一的名字叫 initialize

class Customer
   @@no_of_customers=0
   def initialize(id, name, addr)
      @cust_id=id
      @cust_name=name
      @cust_addr=addr
   end
end

Ruby變量

ruby支持5種類型

• 通常小寫字母、下劃線開頭：變量（Variable）。
• $開頭：全局變量（Global variable）。
• @開頭：實例變量（Instance variable）。
• @@開頭：類變量（Class variable）類變量被共享在整個繼承鏈中
• 大寫字母開頭：常數（Constant）。

變量(就是 局部變量)

變量的打印

變量在打印的時候不能省略 大括號，別的類型變量均可以省略大括號，好比

你這樣打印變量是打不出東西的

錯誤的寫法

a=1
b=2
puts "a: #a"
puts "b: #b"

打印結果

a: #a
b: #b

正確的寫法

a=1
b=2
puts "a: #{a}"
puts "b: #{b}"

打印結果

a: 1
b: 2

變量的生存週期

變量的生存週期只在方法中，出了方法就沒了，因此也只能定義在方法裏面，好比

錯誤的寫法

class Test2
    a=1
    b=2
    def printVar()
        puts "a: #{a}"
        puts "b: #{b}"
    end
end
hellotest = Test2.new
hellotest.printVar()

輸出

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

正確的寫法

class Test2
    def printVar(a,b)
        puts "a: #{a}"
        puts "b: #{b}"
    end
end
hellotest = Test2.new
hellotest.printVar(1,2)

輸出

a: 1
b: 2

變量的傳遞

簡單類型是值拷貝（字符串也是簡單對象，這點跟java不同）

class Test2
    def testPass(a,b)
        puts "before add : a: #{a}  b: #{b}"
        addVar(a,b)
        puts "after add : a: #{a}  b: #{b}"
    end
    def addVar(a,b)
        a += 1
        b += 2
    end
end
hellotest = Test2.new
hellotest.testPass(1,2)

輸出

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

複雜對象是對象引用

class Obj1
    def initialize(a)
        @a=a
    end
    def printVal()
        puts "a: #@a"
    end
    def setA(a)
        @a=a
    end
    def getA()
        return @a
    end
end


class Test2
    def testPass()
        testobj = Obj1.new("hello")
        a = testobj.getA()
        puts "before add : a: #{a}"
        addVar(testobj)
        a = testobj.getA()
        puts "after add : a: #{a}"
    end
    def addVar(obj)
        obj.setA(obj.getA() + " world")
    end
end
hellotest = Test2.new
hellotest.testPass()

輸出

before add : a: hello
after add : a: hello world

實例變量

實例變量的打印

實例變量的打印是能夠省略大括號的，好比 #@a  跟 #{@a} 是一回事

實例變量的生存週期

實例變量只能在 initialize 裏面被定義。若是想像在java中這樣定義是錯誤的

class LearnInstanceVar
    @a=1
    def printVar()
        puts "a: #{@a}"
    end
end

test1 = LearnInstanceVar.new
test1.printVar

輸出

$ ruby test.rb
a:

正確的定義

class LearnInstanceVar
    def initialize(a)
        @a=a
    end
    def printVar()
        puts "a: #{@a}"
    end
end

test1 = LearnInstanceVar.new("hello")
test1.printVar

輸出

$ ruby test.rb
a: hello

相似java中的private，可是更嚴格，連定義的位置都只能放在特定的方法裏面

類變量

類變量的打印

類變量的打印是能夠省略大括號的，好比 #@@a  跟 #{@@a} 是一回事

類變量的生存週期

• 類變量能夠在多個實例之間公用，相似java的 static
• 在類的方法體之外聲明

好比這樣定義和使用類變量

#!/usr/bin/ruby

class Customer
  @@no_of_customers=0
  def printCus()
    @@no_of_customers += 1
    puts "Total number of customers : #{@@no_of_customers}"
  end
end

cust1=Customer.new
cust2=Customer.new

cust1.printCus()
cust2.printCus()

 

 全局變量

• 全局變量以$符號打頭
• 全局變量能夠在類與類之間共享

Ruby 運算符

下面只說ruby比較特殊的一些運算符

比較運算符

== 和 equal？

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

• equal? 是比較兩個對象是不是同一個對象
• == 是比較兩個對象是否相等

例子

a = "Ruby" # 定義一個字符串對象
b = "Ruby" # 雖然和a的內容相同，可是他們是不一樣的對象
a.equal?(b) # false: a和b指向不一樣的對象
a == b # true: 他們的內容是相同的

eq? 是 equal? 的縮寫

<=>  聯合比較運算符

這是一個神奇的運算符：聯合比較運算符。若是第一個操做數等於第二個操做數則返回 0，若是第一個操做數大於第二個操做數則返回 1，若是第一個操做數小於第二個操做數則返回 -1。

=== 三等號

這個運算符更神奇：
一般狀況下這中方式與==是同樣的，可是在某些特定狀況下，===有特殊的含義：

• 在Range中===用於判斷等號右邊的對象是否包含於等號左邊的Range；
• 正則表達式中用於判斷一個字符串是否匹配模式，
• Class定義===來判斷一個對象是否爲類的實例，
• Symbol定義===來判斷等號兩邊的符號對象是否相同。

例子：

(1..10) === 5 # true: 5屬於range 1..10
/\d+/ === "123" # true: 字符串匹配這個模式
String === "s" # true: "s" 是一個字符串類的實例
:s === "s" # true

.eql?

若是接收器和參數具備相同的類型和相等的值，則返回 true。好比 1 == 1.0 返回 true，可是 1.eql?(1.0) 返回 false。

 

並行賦值

a = 10
b = 20
c = 30

能夠寫成這樣

a, b, c = 10, 20, 30

因而在java和c中很麻煩的變量交換，在ruby中能夠很簡單的寫成

a, b = b, c

這樣的代碼

a=1
b=2
c=3
a,b=b,c
puts "a: #{a}"
puts "b: #{b}"
puts "c: #{c}"

執行結果爲

$ ruby test.rb
a: 2
b: 3
c: 3

範圍運算符

• 1..10 建立了一個從1 到10的範圍，而且包含10
• 1...10 跟上面那個惟一的不一樣是不包含10

define? 運算符

咱們在別的語言中都見到過如何判斷變量是否被定義的方法，好比js的是否等於undefined，和php的isset，ruby專門爲這種操做設計了一個運算符叫 define? 這個運算符不只能夠告訴你該變量是否認義還能夠告訴你變量的範圍

defined? variable # 若是 variable 已經初始化，則爲 True

好比

foo = 42
defined? foo    # => "local-variable"
defined? $_     # => "global-variable"
defined? bar    # => nil（未定義）

還能夠檢測方法是否認義了

defined? method_call # 若是方法已經定義，則爲 True

defined? puts        # => "method"
defined? puts(bar)   # => nil（在這裏 bar 未定義）
defined? unpack      # => nil（在這裏未定義）

Ruby 點運算符 "." 和雙冒號運算符 "::"

請記住：在 Ruby 中，類和方法也能夠被看成常量。
您只須要在表達式的常量名前加上 :: 前綴，便可返回適當的類或模塊對象。
若是未使用前綴表達式，則默認使用主 Object 類。

例子

MR_COUNT = 0        # 定義在主 Object 類上的常量
module Foo
  MR_COUNT = 0
  ::MR_COUNT = 1    # 設置全局計數爲 1
  MR_COUNT = 2      # 設置局部計數爲 2
end
puts MR_COUNT       # 這是全局常量
puts Foo::MR_COUNT  # 這是 "Foo" 的局部常量