Scala - 类和对象

类是对象的样例模板，一旦定义了一个类，就可以使用关键字 new 从该类创建对象 ，通过实例化对象 ，您可以使用类的所有函数。

下图以学生类为示例演示了类和对象 ，其中包含成员变量(名称和编号)和成员方法(setName()和setRollNo())，最后，所有人都是类成员。

在下图中，"Student"是一类，而"Nesfkni"，"John"和"Maria"是"Student"类的对象 ，它们具有name和rollNo。

Class类

以下是在Scala中定义基本类的简单语法，此类定义了两个变量 x 和 y 以及一个方法: move ，该方法不返回值。

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

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);

      //移动到新位置
      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仅允许从一个类继承。

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

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);

      //移动到新位置
      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(" H​​ello")"，这意味着println(" H​​ello")语句将执行4次。

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 而不是class关键字来创建单例，由于无法化单例对象，因此无法将参数传递给主构造函数。

无涯教程网

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

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