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