Classes et objets Scala
Une classe est une abstraction d’objets, tandis qu’un objet est une instance concrète d’une classe. Les classes sont abstraites et n’occupent pas de mémoire, alors que les objets sont concrets et occupent un espace de stockage. Une classe est un plan pour créer des objets ; c’est un modèle logiciel qui définit les méthodes et les variables incluses dans les objets d’un type particulier.
Nous pouvons utiliser le mot-clé new pour créer un objet d'une classe, comme le montre l'exemple suivant :
Exemple
var x: Int = xc
var y: Int = yc
def move(dx: Int, dy: Int) {
x = x + dx
y = y + dy
println ("coordonnée x du point : " + x);
println ("coordonnée y du point : " + y);
}
}
En Scala, les classes ne sont pas déclarées comme publiques ; un seul fichier source Scala peut contenir plusieurs classes.
La classe de l'exemple ci-dessus définit deux variablesxety, et une méthode :move, la méthode n'a pas de valeur de retour.
Les définitions de classe Scala peuvent avoir des paramètres, appelés paramètres de classe, tels que xc et yc ci-dessus. Les paramètres de classe sont accessibles dans toute la classe.
Ensuite, nous pouvons utiliser new pour instancier la classe et accéder aux méthodes et variables de la classe :
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 ("coordonnée x du point : " + x);
println ("coordonnée y du point : " + y);
}
}
object Test {
def main(args: Array[String]) {
val pt = new Point(10, 20);
// Se déplacer vers un nouvel emplacement
pt.move(10, 10);
}
}
L'exécution du code ci-dessus produit la sortie suivante :
$ scalac Test.scala $ scala Test x 的坐标点: 20 y 的坐标点: 30
Héritage en Scala
L'héritage d'une classe de base en Scala est très similaire à Java, mais nous devons noter les points suivants :
- 1. La redéfinition d'une méthode non abstraite doit utiliser le modificateur override.
- 2. Seul le constructeur principal peut passer des paramètres au constructeur de la classe de base.
- 3. Lors de la redéfinition d'une méthode abstraite d'une superclasse dans une sous-classe, vous n'avez pas besoin d'utiliser le mot-clé override.
Ensuite, regardons un exemple :
Exemple
var x: Int = xc
var y: Int = yc
def move(dx: Int, dy: Int) {
x = x + dx
y = y + dy
println ("coordonnée x du point : " + x);
println ("coordonnée y du point : " + 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 ("coordonnée x du point : " + x);
println ("coordonnée y du point : " + y);
println ("coordonnée z du point : " + z);
}
}
Scala utilise le mot-clé extends pour hériter d'une classe. Dans l'exemple, la classe Location hérite de la classe Point. Point est appelée la classe parente (classe de base), et Location est appelée la sous-classe.
override val xcIl s'agit de redéfinir les champs de la classe parente.
L'héritage hérite de toutes les propriétés et méthodes de la classe parente. Scala ne permet d'hériter que d'une seule classe parente.
Un exemple est le suivant :
Exemple
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 ("coordonnée x du point : " + x);
println ("coordonnée y du point : " + 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 ("coordonnée x du point : " + x);
println ("coordonnée y du point : " + y);
println ("coordonnée z du point : " + z);
}
}
object Test {
def main(args: Array[String]) {
val loc = new Location(10, 20, 15);
// Se déplacer vers un nouvel emplacement
loc.move(10, 10, 5);
}
}
L'exécution du code ci-dessus produit la sortie suivante :
$ scalac Test.scala $ scala Test x 的坐标点 : 20 y 的坐标点 : 30 z 的坐标点 : 20
En Scala, la redéfinition d'une méthode non abstraite doit utiliser le modificateur override.
Exemple
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)
}
L'exécution du code ci-dessus produit la sortie suivante :
$ scalac Test.scala $ scala Test Employee[name=Fred][salary=50000.0]
Objets singleton en Scala
En Scala, il n'existe pas de static, mais il nous fournit quand même un moyen d'implémenter le patron singleton, qui consiste à utiliser le mot-clé object.
Lorsque vous utilisez le patron singleton en Scala, en plus de la classe définie, vous devez également définir un objet portant le même nom. La différence entre celui-ci et une classe est qu'un objet ne peut pas avoir de paramètres.
Lorsqu'un objet singleton partage le même nom qu'une classe, il est appelé objet compagnon de cette classe. Vous devez définir la classe et son objet compagnon dans le même fichier source. La classe est appelée classe compagnon de l'objet singleton. Une classe et son objet compagnon peuvent accéder aux membres privés l'un de l'autre.
Exemple d'objet singleton
Exemple
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 ("coordonnée x du point : " + point.x);
println ("coordonnée y du point : " + point.y);
}
}
}
L'exécution du code ci-dessus produit la sortie suivante :
$ scalac Test.scala $ scala Test x 的坐标点 : 10 y 的坐标点 : 20
Exemple d'objet compagnon
Exemple
* auteur : Exemple
* url : www.example.com
*/
// Constructeur privé
class Marker private(val color:String) {
println("Créer" + this)
override def toString(): String = "Marqueur de couleur : "+ color
}
// L'objet compagnon, avec le même nom que la classe, peut accéder aux propriétés et méthodes privées de la classe
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"))
// Appel de fonction singleton, en omettant le symbole . (point)
println(Marker getMarker "blue")
}
}
L'exécution du code ci-dessus produit la sortie suivante :
$ scalac Marker.scala $ scala Marker 创建颜色标记:red 创建颜色标记:blue 创建颜色标记:green 颜色标记:red 颜色标记:blueAutres extensions