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

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

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

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 ("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

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

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

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 ("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

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

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

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 ("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

/* Nom du fichier : Marker.scala
* 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
颜色标记:blue
Autres extensions