Scala - 类和对象

本章将带您了解如何在 Scala 编程中使用类和对象。 类是对象的蓝图。 定义类后，您可以使用关键字new 从类蓝图创建对象。 通过该对象，您可以使用已定义类的所有功能。

下图以student类为例演示了类和对象，其中包含成员变量（name和roll no）和成员方法（setName()和setRollNo()）。 最后，所有人都是班级的成员。 班级是蓝图，这里的物品是真实的。 在下图中，Student 是一个类，Harini、John 和 Maria 是 Student 类的对象，它们具有名称和编号。

基础类

以下是在 Scala 中定义基本类的简单语法。 该类定义了两个变量 x 和 y 以及一个方法：move，它不返回值。 类变量被调用，类的字段和方法被称为类方法。

类名用作类构造函数，它可以接受许多参数。 上面的代码定义了两个构造函数参数，xc和yc； 它们都在整个班级中可见。

语法

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

如本章前面所述，您可以使用关键字 new 创建对象，然后可以访问类字段和方法，如下面的示例所示 −

示例

import java.io._

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

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

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

将上述程序保存在 Demo.scala 中。 以下命令用于编译和执行该程序。

命令

\>scalac Demo.scala
\>scala Demo

输出

Point x location : 20
Point y location : 30

扩展类

您可以扩展一个 Scala 基类，也可以像在 Java 中那样设计一个继承类（使用 extends 关键字），但有两个限制：方法覆盖需要 override 关键字，并且只有 primary 构造函数可以将参数传递给基构造函数。 让我们扩展上面的类并添加一个类方法。

示例

让我们以两个类的示例 Point 类（与上面相同的示例）和 Location 类是使用 extends 关键字继承的类。这样的 'extends' 子句有两个作用：它使Location 类继承Point 类的所有非私有成员，并使Location 类型成为Point 类型的子类型。 所以这里的 Point 类称为 超类，而 Location 类称为 子类。 扩展一个类并继承父类的所有特性称为继承，但 Scala 只允许从一个类继承。

注意 − Point 类中的 move() 方法和 Location 类中的 move() 方法 方法不会覆盖 move 的相应定义，因为它们是不同的定义（例如，前者带两个参数，而后者带三个参数 论据）。

尝试以下示例程序来实现继承。

import java.io._

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

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

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

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

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

将上述程序保存在 Demo.scala 中。 以下命令用于编译和执行该程序。

命令

\>scalac Demo.scala
\>scala Demo

输出

Point x location : 20
Point y location : 30
Point z location : 20

隐式类

当类在作用域内时，隐式类允许与类的主构造函数进行隐式对话。 隐式类是用"隐式"关键字标记的类。 此功能在 Scala 2.10 中引入。

语法 − 以下是隐式类的语法。 这里隐式类总是在允许所有方法定义的对象范围内，因为隐式类不能是顶级类。

语法

object <object name> {
   implicit class <class name>(<Variable>: Data type) {
      def <method>(): Unit =
   }
}

示例

让我们举一个名为 IntTimes 的隐式类的示例，该类使用方法 times()。 这意味着 times() 包含一个循环事务，它将按照我们给出的次数执行给定的语句。 让我们假设给定的语句是"4 次 println ("Hello")"，这意味着 println ("Hello") 语句将执行 4 次。

以下是给定示例的程序。 在此示例中，使用了两个对象类（Run 和 Demo），因此我们必须将这两个类保存在不同的文件中，并使用它们各自的名称，如下所示。

Run.scala − 将以下程序保存在 Run.scala 中。

object Run {
   implicit class IntTimes(x: Int) {
      def times [A](f: =>A): Unit = {
         def loop(current: Int): Unit =
         
         if(current > 0){
            f
            loop(current - 1)
         }
         loop(x)
      }
   }
}

Demo.scala − 将以下程序保存在 Demo.scala 中。

import Run._

object Demo {
   def main(args: Array[String]) {
      4 times println("hello")
   }
}

以下命令用于编译和执行这两个程序。

命令

\>scalac Run.scala
\>scalac Demo.scala
\>scala Demo

输出

Hello
Hello
Hello
Hello

注意 −

• 隐式类必须在另一个类/对象/特征中定义（不在顶层）。

• 隐式类在其构造函数中只能采用一个非隐式参数。

• 隐式类不能是范围内与隐式类同名的任何方法、成员或对象。

单例对象

Scala 比 Java 更面向对象，因为在 Scala 中，我们不能有静态成员。 相反，Scala 有单例对象。 单例是只能有一个实例的类，即 Object。您使用关键字 object 而不是 class 关键字创建单例。 由于无法实例化单例对象，因此无法将参数传递给主构造函数。 您已经看到了使用调用 Scala 的 main 方法的单例对象的所有示例。

以下是实现单例的相同示例程序。

示例

import java.io._

class Point(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 Demo {
   def main(args: Array[String]) {
      val point = new Point(10, 20)
      printPoint

      def printPoint{
         println ("Point x location : " + point.x);
         println ("Point y location : " + point.y);
      }
   }
}

将上述程序保存在 Demo.scala 中。 以下命令用于编译和执行该程序。

命令

\>scalac Demo.scala
\>scala Demo

输出

Point x location : 10
Point y location : 20