Scala類與對象

類是一個對象的藍圖。一旦定義一個類可以創建從類藍圖使用關鍵字new創建對象。下麵是一個簡單的語法在Scala中定義一個類：

class Yiibai(xc: Int, yc: Int) {
   var x: Int = xc
   var y: Int = yc

   def move(dx: Int, dy: Int) {
      x = x + dx
      y = y + dy
      println ("Yiibai x location : " + x);
      println ("Yiibai y location : " + y);
   }
}

這個類定義了兩個變量x和y和方法：move，冇有返回值。類變量被調用，類的字段和方法被稱為類方法。

類名可以作為一個類的構造函數，可以采取一些參數。上麵的代碼定義了兩個構造函數的參數：xc和yc;它們都在類的主體內可見。

正如前麵提到的，可以使用關鍵字new創建對象，然後可以按照下麵的例子所示訪問類的字段和方法：

import java.io._

class Yiibai(val xc: Int, val yc: Int) {
   var x: Int = xc
   var y: Int = yc
   def move(dx: Int, dy: Int) {
      x = x + dx
      y = y + dy
      println ("Yiibai x location : " + x);
      println ("Yiibai y location : " + y);
   }
}

object Test {
   def main(args: Array[String]) {
      val pt = new Yiibai(10, 20);

      // Move to a new location
      pt.move(10, 10);
   }
}

當上述代碼被編譯和執行時，它產生了以下結果：

C:/>scalac Test.scala
C:/>scala Test
Yiibai x location : 20
Yiibai y location : 30

C:/>

擴展一個類：

可以擴展scala類以類似的方式，如在Java中的一樣，但有兩個限製：方法重載需要override關鍵字，隻有主構造可以傳遞參數給基構造。現在擴展上麵的類，並增加一個類的方法：

class Yiibai(val xc: Int, val yc: Int) {
   var x: Int = xc
   var y: Int = yc
   def move(dx: Int, dy: Int) {
      x = x + dx
      y = y + dy
      println ("Yiibai x location : " + x);
      println ("Yiibai y location : " + y);
   }
}

class Location(override val xc: Int, override val yc: Int,
   val zc :Int) extends Yiibai(xc, yc){
   var z: Int = zc

   def move(dx: Int, dy: Int, dz: Int) {
      x = x + dx
      y = y + dy
      z = z + dz
      println ("Yiibai x location : " + x);
      println ("Yiibai y location : " + y);
      println ("Yiibai z location : " + z);
   }
}

extends子句有兩種作用：它使類Location繼承類Yiibai所有非私有成員，它使Location類作為Yiibai類的子類。因此，這裡的Yiibai類稱為超類，而Location類被稱為子類。擴展一個類，繼承父類的所有功能，被稱為繼承，但scala允許繼承，隻能從一個唯一的類。讓我們看看完整的例子，顯示繼承的用法：

import java.io._

class Yiibai(val xc: Int, val yc: Int) {
   var x: Int = xc
   var y: Int = yc
   def move(dx: Int, dy: Int) {
      x = x + dx
      y = y + dy
      println ("Yiibai x location : " + x);
      println ("Yiibai y location : " + y);
   }
}

class Location(override val xc: Int, override val yc: Int,
   val zc :Int) extends Yiibai(xc, yc){
   var z: Int = zc

   def move(dx: Int, dy: Int, dz: Int) {
      x = x + dx
      y = y + dy
      z = z + dz
      println ("Yiibai x location : " + x);
      println ("Yiibai y location : " + y);
      println ("Yiibai z location : " + z);
   }
}

object Test {
   def main(args: Array[String]) {
      val loc = new Location(10, 20, 15);

      // Move to a new location
      loc.move(10, 10, 5);
   }
}

需要注意的是方法move，不會覆蓋 move 方法相應的定義，因為它們是不同的定義（例如，前兩個參數，而後者則需要三個參數）。
讓我們編譯和運行上麵的程序，這將產生以下結果：

C:/>scalac Test.scala
C:/>scala Test
Yiibai x location : 20
Yiibai y location : 30
Yiibai z location : 20

C:/>

單例對象：

Scala比Java更麵向對象，因為在Scala中不能有靜態成員。相反，Scala有單例的對象。單例就是隻能有一個實例，即，類的對象。可以使用關鍵字object代替class關鍵字，而不是創建單例。因為不能實例化一個單獨的對象，不能將參數傳遞給主構造。前麵已經看到全部采用單一對象，調用Scala的main方法的例子。以下是單例顯示的相同的例子：

import java.io._

class Yiibai(val xc: Int, val yc: Int) {
   var x: Int = xc
   var y: Int = yc
   def move(dx: Int, dy: Int) {
      x = x + dx
      y = y + dy
   }
}

object Test {
   def main(args: Array[String]) {
      val yiibai = new Yiibai(10, 20)
      printYiibai

      def printYiibai{
         println ("Yiibai x location : " + yiibai.x);
         println ("Yiibai y location : " + yiibai.y);
      }
   }
}

當上述代碼被編譯和執行時，它產生了以下結果：

C:/>scalac Test.scala
C:/>scala Test
Yiibai x location : 10
Yiibai y location : 20

C:/>