Scala类与对象

类是一个对象的蓝图。一旦定义一个类可以创建从类蓝图使用关键字new创建对象。下面是一个简单的语法在Scala中定义一个类：

class Codeinn(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 ("Codeinn x location : " + x);
      println ("Codeinn y location : " + y);
   }
}

这个类定义了两个变量x和y和方法：move，没有返回值。类变量被调用，类的字段和方法被称为类方法。

类名可以作为一个类的构造函数，可以采取一些参数。上面的代码定义了两个构造函数的参数：xc和yc;它们都在类的主体内可见。

正如前面提到的，可以使用关键字new创建对象，然后可以按照下面的例子所示访问类的字段和方法：

import java.io._

class Codeinn(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 ("Codeinn x location : " + x);
      println ("Codeinn y location : " + y);
   }
}

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

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

当上述代码被编译和执行时，它产生了以下结果：

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

C:/>

扩展一个类：

可以扩展scala类以类似的方式，如在Java中的一样，但有两个限制：方法重载需要override关键字，只有主构造可以传递参数给基构造。现在扩展上面的类，并增加一个类的方法：

class Codeinn(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 ("Codeinn x location : " + x);
      println ("Codeinn y location : " + y);
   }
}

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

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

extends子句有两种作用：它使类Location继承类Yiibai所有非私有成员，它使Location类作为Yiibai类的子类。 因此，这里的Yiibai类称为超类，而Location类被称为子类。扩展一个类，继承父类的所有功能，被称为继承，但scala允许继承，只能从一个唯一的类。让我们看看完整的例子，显示继承的用法：

import java.io._

class Codeinn(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 ("Codeinn x location : " + x);
      println ("Codeinn y location : " + y);
   }
}

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

   def move(dx: Int, dy: Int, dz: Int) {
      x = x + dx
      y = y + dy
      z = z + dz
      println ("Codeinn x location : " + x);
      println ("Codeinn y location : " + y);
      println ("Codeinn 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
Codeinn x location : 20
Codeinn y location : 30
Codeinn z location : 20

C:/>

单例对象：

Scala比Java更面向对象，因为在Scala中不能有静态成员。相反，Scala有单例的对象。单例就是只能有一个实例，即，类的对象。可以使用关键字object代替class关键字，而不是创建单例。因为不能实例化一个单独的对象，不能将参数传递给主构造。前面已经看到全部采用单一对象，调用Scala的main方法的例子。以下是单例显示的相同的例子：

import java.io._

class Codeinn(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 codeinn = new Codeinn(10, 20)
      printCodeinn

      def printCodeinn{
         println ("Codeinn x location : " + codeinn.x);
         println ("Codeinn y location : " + codeinn.y);
      }
   }
}

当上述代码被编译和执行时，它产生了以下结果：

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

C:/>