Scala 类和对象

Les classes sont des abstractions d'objets, tandis que les objets sont des exemples concrets de classes. Les classes sont abstraites et ne consomment pas de mémoire, tandis que les objets sont concrets et occupent de l'espace de stockage. Les classes sont des plans pour créer des objets, elles sont des modèles logiciels définissant les méthodes et les variables incluses dans un type d'objet spécifique.

我们可以使用new关键字来创建类的对象，示例如下：

Exemple

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("x的坐标点："　+　x);
　　　　　　println("y的坐标点："　+　y);
　　　}
}

Scala中的类不声明为public，一个Scala源文件中可以有多个类。

以上示例的类定义了两个变量 x 和 y ，一个方法：move，方法没有返回值。

Scala的类定义可以有参数，称为类参数，如上面的xc, yc，类参数在整个类中都可以访问。

接着我们可以使用new来示例化类，并访问类中的方法和变量：

Exemple

import java.io._
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("x的坐标点："　+　x);
　　　　　　println("y的坐标点："　+　y);
　　　}
}
object Test {
　　　def main(args: Array[String]) {
　　　　　　val pt = new Point(10,　20);
　　　　　　//　移动到一个新的位置
　　　　　　pt.move(10,　10);
　　　}
}

执行以上代码，输出结果为：

$ scalac Test.scala　
$ scala Test
x的坐标点：　20
y的坐标点：　30

Scala继承

Scala继承一个基类跟Java很相似，但我们需要注意以下几点：

1、重写一个非抽象方法必须使用override修饰符。
2、只有主构造函数才可以向基类的构造函数里写参数。
3、在子类中重写超类的抽象方法时，你不需要使用override关键字。

接下来让我们来看一个示例：

Exemple

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("x的坐标点："　+　x);
　　　　　　println("y的坐标点："　+　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 de coordonnées de x : ");　+　x);
　　　　　　println("Point de coordonnées de y : ");　+　y);
　　　　　　println("z的坐标点："　+　z);
　　　}
}

Scala使用extends关键字来继承一个类。示例中Location类继承了Point类。Point称为父类（基类），Location称为子类。

override val xc 为重写了父类的字段。

继承会继承父类的所有属性和方法，Scala只允许继承一个父类。

以下是一个示例：

Exemple

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 de coordonnées de x : ");　+　x);
　　　　　　println("Point de coordonnées de y : ");　+　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 de coordonnées de x : ");　+　x);
　　　　　　println("Point de coordonnées de y : ");　+　y);
　　　　　　println("z的坐标点："　+　z);
　　　}
}
object Test {
　　　def main(args: Array[String]) {
　　　　　　val loc = new Location(10,　20,　15);
　　　　　　//　移动到一个新的位置
　　　　　　loc.move(10,　10,　5);
　　　}
}

执行以上代码，输出结果为：

$ scalac Test.scala　
$ scala Test
Point de coordonnées de x :　20
Point de coordonnées de y :　30
z的坐标点：　20

Scala重新写一个非抽象方法，必须使用override修饰符。

Exemple

class Person {
　　var name = ""
　　override def toString = getClass.getName　+　"[name="　+　name　+　"]"
}
class Employee extends Person {
　　var salary = 0.0
　　override def toString = super.toString　+　"[salary="　+　salary　+　"]"
}
object Test extends App {
　　val fred = new Employee
　　fred.name = "Fred"
　　fred.salary =　50000
　　println(fred)
}

执行以上代码，输出结果为：

$ scalac Test.scala　
$ scala Test
Employee[name=Fred][salary=50000.0]

Objet singleton Scala

En Scala, il n'existe pas de static, mais il nous fournit également une méthode d'implémentation du patron singleton en utilisant la clé object.

Lorsque le patron singleton est utilisé en Scala, en plus de la classe définie, un objet object du même nom doit également être défini. La différence entre l'objet object et la classe est que l'objet object ne peut pas prendre de paramètres.

Lorsque l'objet singleton partage le même nom qu'une classe, il est appelé l'objet associé de cette classe : object companion. Vous devez définir la classe et son objet associé dans le même fichier source. La classe est appelée la classe associée à l'objet singleton : class companion. La classe et son objet associé peuvent se rendre mutuellement accessibles à leurs membres privés.

Exemple d'objet singleton

Exemple

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 Test {
　　　def main(args: Array[String]) {
　　　　　　val point = new Point(10,　20)
　　　　　　printPoint
　　　　　　def printPoint{
　　　　　　　　　println("Point de coordonnées de x : ");　+　point.x);
　　　　　　　　　println("Point de coordonnées de y : ");　+　point.y);
　　　　　　}
　　　}
}

执行以上代码，输出结果为：

$ scalac Test.scala　
$ scala Test
Point de coordonnées de x :　10
Point de coordonnées de y :　20

Exemple d'objet associé

Exemple

/*　Nom de fichier: Marker.scala
　*　auteur: Site de base du tutoriel
　*　url:fr.oldtoolbag.com
　*/
//　Constructeur privé
class Marker private(val color: String) {
　　println("创建"　+　this)
　　
　　override def toString(): String = "颜色标记："+　color
　　
}
//　伴生对象，与类名字相同，可以访问类的私有属性和方法
object Marker{
　　
　　　　private val markers: Map[String, Marker] = Map(
　　　　　　"red"　-> new Marker("red"),
　　　　　　"blue"　-> new Marker("blue"),
　　　　　　"green"　-> new Marker("green")
　　　　)
　　　　
　　　　def apply(color: String) = {
　　　　　　if(markers.contains(color)) markers(color) else null
　　　　}
　　
　　　　
　　　　def getMarker(color: String) = {　
　　　　　　if(markers.contains(color)) markers(color) else null
　　　　}
　　　　def main(args: Array[String]) {　
　　　　　　　　println(Marker("red"))　　
　　　　　　　　//　单例函数调用，省略了.(点)符号　　
　　　　　　　　　　　　　　　　println(Marker getMarker "blue")　　
　　　　}
}

执行以上代码，输出结果为：

$ scalac 标记.scala　
$ scala 标记
创建颜色标记：红色
创建颜色标记：蓝色
创建颜色标记：绿色
颜色标记：红色
颜色标记：蓝色

Scala Trait（特征）Scala Iterator（迭代器）

Scala 教程

Scala 类和对象

Scala继承

Objet singleton Scala

Exemple d'objet singleton

Exemple d'objet associé