Trait Scala (fonctionnalité)

Le Trait Scala (Fonctionnalité) est équivalent à l'interface Java, mais en fait il est plus puissant qu'une interface.

Contrairement aux interfaces, il peut également définir des attributs et des implémentations de méthodes.

En général, les classes Scala ne peuvent hériter que d'une seule classe parente, mais lorsqu'il s'agit de Trait (Fonctionnalité), plusieurs traits peuvent être hérités, ce qui conduit à l'héritage multiple.

Un Trait (Fonctionnalité) est défini de manière similaire à une classe, mais le mot-clé qu'il utilise esttrait, comme indiqué ci-dessous :

Exemple

trait Equal {
  def isEqual(x: Any): Boolean
  def isNotEqual(x: Any): Boolean = !isEqual(x)
}

Le trait (fonctionnalité) ci-dessus se compose de deux méthodes :isEqualetisNotEqual. La méthode isEqual ne définit pas l'implémentation de la méthode, tandis que isNotEqual définit l'implémentation de la méthode. Une sous-classe héritant du trait peut implémenter la méthode non implémentée. Donc en fait, le trait Scala ressemble davantage à la classe abstraite de Java.

Ce qui suit présente un exemple complet d'un trait :

Exemple

/* Nom du fichier : Test.scala
* auteur : Example Tutorial
 * url : www.example.com
 */

trait Equal {
  def isEqual(x: Any): Boolean
  def isNotEqual(x: Any): Boolean = !isEqual(x)
}

class Point(xc: Int, yc: Int) extends Equal {
  var x: Int = xc
  var y: Int = yc
  def isEqual(obj: Any) =
    obj.isInstanceOf[Point] &&
    obj.asInstanceOf[Point].x == x
}

object Test {
   def main(args: Array[String]) {
      val p1 = new Point(2, 3)
      val p2 = new Point(2, 4)
      val p3 = new Point(3, 3)

      println(p1.isNotEqual(p2))
      println(p1.isNotEqual(p3))
      println(p1.isNotEqual(2))
   }
}

L'exécution du code ci-dessus produit la sortie suivante :

$ scalac Test.scala 
$ scala Test
false
true
true

Ordre de construction des traits

Les traits peuvent également avoir des constructeurs, qui consistent en l'initialisation de champs et d'autres instructions dans le corps du trait. Ces instructions sont exécutées lorsqu'un objet qui intègre le trait est construit.

L'ordre d'exécution des constructeurs :

  • Appeler le constructeur de la superclasse ;
  • Le constructeur du trait est exécuté après le constructeur de la superclasse et avant le constructeur de la classe ;
  • Les traits sont construits de gauche à droite ;
  • Au sein de chaque trait, le trait parent est construit en premier ;
  • Si plusieurs traits partagent un trait parent, le trait parent ne sera pas construit plusieurs fois ;
  • Une fois tous les traits construits, la sous-classe est construite.

L'ordre des constructeurs est l'inverse de la linéarisation de la classe. La linéarisation est une spécification technique qui décrit tous les super-types d'un certain type.

Autres extensions