极客教程Scala 类和对象
本章将介绍如何在Scala编程中使用类和对象。类是对象的蓝图。定义类后，您可以使用关键字 new 从类蓝图创建对象。通过对象，您可以使用定义类的所有功能。
下图通过以学生类为例，展示了类和对象的关系。学生类包含了成员变量（姓名和学号）和成员方法（设置姓名和设置学号）。最终，这些都是类的成员。类是一个蓝图，而对象则是实际存在的。在下图中，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 构造函数可以将参数传递给基本构造函数。让我们扩展我们上面的类，并添加一个更多的类方法。
示例
我们以两个类点类（与上面相同的示例）和位置类为例，位置类是使用 extends 关键字继承的类。这样一个“ extends ”子句有两个效果：它使位置类继承点类的所有非私有成员，并将类型 位置 成为类型 点 类的子类型。所以这里的点类称为 超类 ，而类 位置 称为 子类 。扩展一个类并继承父类的所有特性称为 继承 ，但是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
隐式类
隐式类允许在类在范围内时与类的主构造函数进行隐式转换。隐式类是一个用 ‘implicit’ 关键字标记的类。这个特性在Scala 2.10中引入。
语法 −下面是隐式类的语法。在所有方法定义都允许的对象范围内，隐式类总是存在的，因为隐式类不能是顶级类。
语法
object <object name> {
implicit class <class name>(<Variable>: Data type) {
def <method>(): Unit =
}
}
示例
让我们以一个隐式类为例，命名为 IntTimes ，它有一个名为times()的方法。这意味着times()方法包含一个循环事务，将根据我们提供的次数执行给定的语句。假设给定的语句是”4 times 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 而不是class关键字来创建单例。由于不能实例化单例对象，因此不能向主构造函数传递参数。您已经看到了所有使用单例对象的示例，其中调用了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
}
}
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