Ruby 物件導向

Ruby 類別定義

當您定義一個類別時，您實際上是定義了一個資料類型的藍圖。這實際上並沒有定義任何的數據，而是定義了類別的名稱意味著什麼，也就是說，定義了類別的物件將由什麼組成，以及在該物件上能執行什麼操作。

類別定義以關鍵字 class 開始，後面跟著類別名稱，最後以一個 end 進行分隔表示終止該類別定義。例如，我們使用關鍵字class 來定義Box 類，如下所示：

class Box
   code
end

按照慣例，名稱必須以大寫字母開頭，如果包含多個單詞，每個單字首字母大寫，但此間沒有分隔符（例如：CamelCase）。

定義 Ruby 物件

類別提供了物件的藍圖，所以基本上，物件是根據類別進行建立的。我們使用 new 關鍵字聲明類別的物件。下面的語句宣告了類別Box 的兩個物件：

box1 = Box.new
box2 = Box.new

initialize 方法

initialize 方法是一個標準的Ruby 類別方法，是類別的建構函數，與其他物件導向程式語言中的constructor 工作原理類似。當您想要在創建物件的同時初始化一些類別變量，initialize 方法就派上用場了。此方法帶有一系列參數，與其他Ruby 方法一樣，使用該方法時，必須在前面放置def 關鍵字，如下所示：

class Box
   def initialize(w,h)
      @width, @height = w, h
   end
end

實例變數

實例變數是類別屬性，它們在使用類別建立物件時就變成物件的屬性。每個物件的屬性是單獨賦值的，和其他物件之間不共享值。在類別的內部，是使用 @ 運算子存取這些屬性，在類別的外部，則是使用稱為存取器方法的公共方法進行存取。下面我們以上面定義的類別 Box 為實例，把 @width 和 @height 作為類別 Box 的實例變數。

class Box
   def initialize(w,h)
      # 给实例变量赋值
      @width, @height = w, h
   end
end

訪問器(accessor) & 設定器(setter)方法

為了在類別的外部使用變量，我們必須在訪問器方法內部定義這些變量， accessor 其實相當於getter。下面的實例示範了存取器方法的用法：

#!/usr/bin/ruby -w

# 定义类
class Box
   # 构造函数
   def initialize(w,h)
      @width, @height = w, h
   end

   # 访问器方法
   def printWidth
      @width
   end

   def printHeight
      @height
   end
end

# 创建对象
box = Box.new(10, 20)

# 使用访问器方法
x = box.printWidth()
y = box.printHeight()

puts "Width of the box is : #{x}"
puts "Height of the box is : #{y}"

當上面的程式碼執行時，它會產生以下結果：

Width of the box is : 10
Height of the box is : 20

與用於存取變數值的存取器方法類似，Ruby 提供了一種在類別的外部設定變數值的方式，也就是所謂的設定器方法，定義如下：

#!/usr/bin/ruby -w

# 定义类
class Box
   # 构造器方法
   def initialize(w,h)
      @width, @height = w, h
   end

   # 访问器方法
   def getWidth
      @width
   end
   def getHeight
      @height
   end

   # 设置器方法
   def setWidth=(value)
      @width = value
   end
   def setHeight=(value)
      @height = value
   end
end

# 创建对象
box = Box.new(10, 20)

# 使用设置器方法
box.setWidth = 30
box.setHeight = 50

# 使用访问器方法
x = box.getWidth()
y = box.getHeight()

puts "Width of the box is : #{x}"
puts "Height of the box is : #{y}"

當上面的程式碼執行時，它會產生以下結果：

Width of the box is : 30
Height of the box is : 50

實例方法

實例方法的定義與其他方法的定義一樣，都是使用def 關鍵字，但它們只能透過類別實例來使用，如下面實例所示。它們的功能不限於存取實例變量，也能按照您的需求做更多其他的任務。

#!/usr/bin/ruby -w

# 定义类
class Box
   # 构造方法
   def initialize(w,h)
      @width, @height = w, h
   end
   # 实例方法
   def getArea
      @width * @height
   end
end

# 创建对象
box = Box.new(10, 20)

# 调用实例方法
a = box.getArea()
puts "Area of the box is : #{a}"

當上面的程式碼執行時，它會產生以下結果：

Area of the box is : 200

類別方法& 類別變數

類別變數是在類別的所有實例中共享的變數。換句話說，類別變數的實例可以被所有的物件實例存取。類別變數以兩個 @ 字元（@@）作為前綴，類別變數必須在類別定義中被初始化，如下面實例所示。

類別方法使用 def self.methodname() 定義，類別方法以 end 分隔符號結尾。類別方法可使用帶有類別名稱的classname.methodname 形式調用，如下面實例所示：

#!/usr/bin/ruby -w

class Box
   # 初始化类变量
   @@count = 0
   def initialize(w,h)
      # 给实例变量赋值
      @width, @height = w, h

      @@count += 1
   end

   def self.printCount()
      puts "Box count is : #@@count"
   end
end

# 创建两个对象
box1 = Box.new(10, 20)
box2 = Box.new(30, 100)

# 调用类方法来输出盒子计数
Box.printCount()

當上面的程式碼執行時，它會產生以下結果：

Box count is : 2

to_s 方法

您定義的任何類別都有一個to_s 實例方法來傳回物件的字串表示形式。下面是一個簡單的實例，根據width 和height 表示Box 物件：

#!/usr/bin/ruby -w

class Box
   # 构造器方法
   def initialize(w,h)
      @width, @height = w, h
   end
   # 定义 to_s 方法
   def to_s
      "(w:#@width,h:#@height)"  # 对象的字符串格式
   end
end

# 创建对象
box = Box.new(10, 20)

# 自动调用 to_s 方法
puts "String representation of box is : #{box}"

#當上面的程式碼執行時，它會產生以下結果：

String representation of box is : (w:10,h:20)

存取控制

Ruby 為您提供了三個層級的實例方法保護，分別是public、private 或protected。 Ruby 不在實例和類別變數上套用任何存取控制。

• Public 方法： Public 方法可被任意物件呼叫。預設情況下，方法都是 public 的，除了 initialize 方法總是 private 的。

• Private 方法： Private 方法不能從類別外部存取或檢視。只有類別方法可以存取私有成員。

• Protected 方法： Protected 方法只能被類別及其子類別的物件呼叫。存取也只能在類別及其子類別內部進行。

下面是一個簡單的實例，示範了這三種修飾符的語法：

#!/usr/bin/ruby -w

# 定义类
class Box
   # 构造器方法
   def initialize(w,h)
      @width, @height = w, h
   end

   # 实例方法默认是 public 的
   def getArea
      getWidth() * getHeight
   end

   # 定义 private 的访问器方法
   def getWidth
      @width
   end
   def getHeight
      @height
   end
   # make them private
   private :getWidth, :getHeight

   # 用于输出面积的实例方法
   def printArea
      @area = getWidth() * getHeight
      puts "Big box area is : #@area"
   end
   # 让实例方法是 protected 的
   protected :printArea
end

# 创建对象
box = Box.new(10, 20)

# 调用实例方法
a = box.getArea()
puts "Area of the box is : #{a}"

# 尝试调用 protected 的实例方法
box.printArea()

當上面的程式碼執行時，它會產生以下結果。在這裡，第一種方法呼叫成功，但是第二方法會產生一個問題。

Area of the box is : 200
test.rb:42: protected method `printArea' called for #
<Box:0xb7f11280 @height=20, @width=10> (NoMethodError)

類別的繼承

繼承，是物件導向程式設計中最重要的概念之一。繼承允許我們根據另一個類定義一個類，這使得建立和維護應用程式變得更加容易。

繼承有助於重複使用程式碼和快速執行，不幸的是，Ruby 不支援多繼承，但是 Ruby 支援 mixins。 mixin 就像是多繼承的一個特定實現，在多繼承中，只有介面部分是可繼承的。

當建立類別時，程式設計師可以直接指定新類別繼承自某個已有類別的成員，這樣就不用從頭開始編寫新的資料成員和成員函數。這個已有類別被稱為基底類別或父類別，新類別被稱為衍生類別或子類別。

Ruby 也提供了子類別化的概念，子類別化即繼承，而下面的實例解釋了這個概念。擴展一個類別的語法非常簡單。只要加入一個 < 字元和父類別的名稱到類別語句中即可。例如，下面定義了類別BigBox 是Box 的子類別：

#!/usr/bin/ruby -w

# 定义类
class Box
   # 构造器方法
   def initialize(w,h)
      @width, @height = w, h
   end
   # 实例方法
   def getArea
      @width * @height
   end
end

# 定义子类
class BigBox < Box

   # 添加一个新的实例方法
   def printArea
      @area = @width * @height
      puts "Big box area is : #@area"
   end
end

# 创建对象
box = BigBox.new(10, 20)

# 输出面积
box.printArea()

當上面的程式碼執行時，它會產生以下結果：

Big box area is : 200

方法重載

雖然您可以在衍生類別中新增的功能，但有時您可能想要改變已經在父類別中定義的方法的行為。這時您可以保持方法名稱不變，重載方法的功能即可，如下列實例所示：

#!/usr/bin/ruby -w

# 定义类
class Box
   # 构造器方法
   def initialize(w,h)
      @width, @height = w, h
   end
   # 实例方法
   def getArea
      @width * @height
   end
end

# 定义子类
class BigBox < Box

   # 改变已有的 getArea 方法
   def getArea
      @area = @width * @height
      puts "Big box area is : #@area"
   end
end

# 创建对象
box = BigBox.new(10, 20)

# 使用重载的方法输出面积
box.getArea()

以上實例執行輸出結果為：

Big box area is : 200

運算子重載

我們希望使用+ 運算子執行兩個Box 物件的向量加法，使用* 運算子來把Box 的width 和height 相乘，使用一元運算子- 對Box 的width和height 求反。下面是一個帶有數學運算子定義的 Box 類別版本：

class Box
  def initialize(w,h) # 初始化 width 和 height
    @width,@height = w, h
  end

  def +(other)         # 定义 + 来执行向量加法
    Box.new(@width + other.width, @height + other.height)
  end

  def -@               # 定义一元运算符 - 来对 width 和 height 求反
    Box.new(-@width, -@height)
  end

  def *(scalar)        # 执行标量乘法
    Box.new(@width*scalar, @height*scalar)
  end
end

凍結物件

有時候，我們想要防止物件被改變。在 Object 中，freeze 方法可實現這一點，它能有效地將一個物件變成一個常數。任何物件都可以透過呼叫 Object.freeze 進行凍結。凍結物件不能被修改，也就是說，您不能改變它的實例變數。

您可以使用 Object.frozen? 方法檢查一個給定的物件是否已經被凍結。如果物件已被凍結，則該方法將傳回 true，否則傳回一個 false 值。下面的實例解釋了這個概念：

#!/usr/bin/ruby -w

# 定义类
class Box
   # 构造器方法
   def initialize(w,h)
      @width, @height = w, h
   end

   # 访问器方法
   def getWidth
      @width
   end
   def getHeight
      @height
   end

   # 设置器方法
   def setWidth=(value)
      @width = value
   end
   def setHeight=(value)
      @height = value
   end
end

# 创建对象
box = Box.new(10, 20)

# 让我们冻结该对象
box.freeze
if( box.frozen? )
   puts "Box object is frozen object"
else
   puts "Box object is normal object"
end

# 现在尝试使用设置器方法
box.setWidth = 30
box.setHeight = 50

# 使用访问器方法
x = box.getWidth()
y = box.getHeight()

puts "Width of the box is : #{x}"
puts "Height of the box is : #{y}"

當上面的程式碼執行時，它會產生以下結果：

Box object is frozen object
test.rb:20:in `setWidth=': can't modify frozen object (TypeError)
        from test.rb:39

類別常數

您可以在類別的內部定義一個常數，透過把一個直接的數值或字串值賦給一個變數來定義的，常數的定義不需要使用@ 或@@。按照慣例，常數的名稱使用大寫。

一旦常數定義，您就無法改變它的值，您可以在類別的內部直接存取常數，就像是存取變數一樣，但是如果您想要在類別的外部存取常數，那麼您必須使用classname::constant，如下面實例所示。

#!/usr/bin/ruby -w

# 定义类
class Box
   BOX_COMPANY = "TATA Inc"
   BOXWEIGHT = 10
   # 构造器方法
   def initialize(w,h)
      @width, @height = w, h
   end
   # 实例方法
   def getArea
      @width * @height
   end
end

# 创建对象
box = Box.new(10, 20)

# 调用实例方法
a = box.getArea()
puts "Area of the box is : #{a}"
puts Box::BOX_COMPANY
puts "Box weight is: #{Box::BOXWEIGHT}"

當上面的程式碼執行時，它會產生下列結果：

Area of the box is : 200
TATA Inc
Box weight is: 10

類別常數可被繼承，也可像實例方法一樣被重載。

使用allocate 建立物件

可能有一種情況，您想要在不呼叫物件建構器initialize 的情況下建立對象，即，使用new 方法建立對象，在這種情況下，您可以呼叫allocate 來建立一個未初始化的對象，如下面實例所示：

#!/usr/bin/ruby -w

# 定义类
class Box
   attr_accessor :width, :height

   # 构造器方法
   def initialize(w,h)
      @width, @height = w, h
   end

   # 实例方法
   def getArea
      @width * @height
   end
end

# 使用 new 创建对象
box1 = Box.new(10, 20)

# 使用 allocate 创建两一个对象
box2 = Box.allocate

# 使用 box1 调用实例方法
a = box1.getArea()
puts "Area of the box is : #{a}"

# 使用 box2 调用实例方法
a = box2.getArea()
puts "Area of the box is : #{a}"

當上面的程式碼執行時，它會產生以下結果：

Area of the box is : 200
test.rb:14: warning: instance variable @width not initialized
test.rb:14: warning: instance variable @height not initialized
test.rb:14:in `getArea': undefined method `*' 
   for nil:NilClass (NoMethodError) from test.rb:29

類別資訊

Ruby的 self 和 Java 的 this 有相似之處，但又大不相同。 Java的方法都是在實例方法中引用，所以this一般都是指向目前物件的。而Ruby的程式碼逐行執行，所以在不同的上下文(context)self就有了不同的意義。讓我們來看看下面的實例：.

#!/usr/bin/ruby -w

class Box
   # 输出类信息
   puts "Class of self = #{self.class}"
   puts "Name of self = #{self.name}"
end

當上面的程式碼執行時，它會產生以下結果：

Class of self = Class
Name of self = Box

這意味著類定義可透過把該類別當作目前物件來執行，同時也意味著元類別和父類別中的該方法在方法定義執行期間是可用的。