Scala类与对象

于2017-07-06由小牛君创建

分享到:


类是一个对象的蓝图。一旦定义一个类可以创建从类蓝图使用关键字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