Traits Scala

DataCamp vient de lancer son premier cours Scala : Introduction to Scala. Allez y jeter un œil !

Vous pourriez aussi être intéressé par les tutoriels suivants :

• Guide du débutant pour Scala
• IF ELSE en Scala
• Opérateurs en Scala
• Listes en Scala
• Classes et objets en Scala

Introduction

Un trait est un concept largement utilisé en programmation orientée objet, qui permet d’étendre la fonctionnalité d’une classe via un ensemble de méthodes.

Les traits sont proches, dans l’esprit, des interfaces du langage Java. À la différence d’une classe, un trait Scala ne peut pas être instancié et n’accepte pas d’arguments ou de paramètres. En revanche, vous pouvez les hériter (les étendre) avec des classes et des objets. Autrement dit, un trait fournit un ensemble précis de méthodes/fonctions qui apportent un comportement à une classe, et suppose que la classe implémente certaines méthodes qui vont paramétrer ce comportement.

Un trait utilisé pour définir un objet est un assemblage de méthodes réutilisables par différentes classes, sans recourir à l’héritage multiple. Il peut toutefois arriver que deux traits exposent une méthode du même nom (collision de noms) et qu’une classe doive les utiliser ; dans ce cas, l’ambiguïté doit être levée explicitement.

Les traits peuvent contenir des méthodes et des champs à la fois abstraits et concrets. Quand une méthode n’est pas définie dans un trait, elle est abstraite ; celles qui le sont sont dites non abstraites (concrètes). Pour les méthodes abstraites, c’est la classe qui implémente le trait qui fournit l’implémentation.

Voyons maintenant rapidement les traits Scala au travers de quelques exemples !

Syntaxe d’un trait Scala

La syntaxe d’un trait Scala est simple : on utilise le mot-clé trait suivi du nom du trait.

trait Trait_Name{
// Variables
// Methods
}
Propulsé par

Comme vous pouvez le voir dans la définition ci-dessus, un trait nommé DataCamp a été défini, sans variables ni méthodes à l’intérieur.

Passons à un exemple simple de traits Scala, qui éclairera leur fonctionnement en pratique.

Comme expliqué dans l’introduction, les traits Scala sont hérités par une classe avec le mot-clé extends.

class Scala_Tutorial extends DataCamp{
// Variables
// Methods
}
Propulsé par

Définissons un trait nommé Scala_Course, qui sera hérité par la classe DataCamp. Dans ce trait, vous déclarerez une méthode abstraite appelée scala(), qui sera définie dans la classe DataCamp.

trait Scala_Course{  
    def scala()  
}  

class DataCamp extends Scala_Course{  
    def scala(){  
        println("DataCamp has recently launched there first Scala course")  
    }  
}  

object Main{  
    def main(args:Array[String]){  
        var a = new DataCamp()  
        a.scala()  
    }  
}
Propulsé par

Exécutons maintenant ce code.

Dans l’exemple ci-dessus, la méthode scala() était abstraite ; sa définition a donc été fournie dans la classe qui a hérité du trait.

Mais que se passe-t-il si une méthode (non abstraite) est déjà implémentée dans le trait ? Dans ce cas, la classe qui étend ce trait n’a pas besoin de redéfinir la méthode déjà implémentée.

Illustrons cela avec un petit exemple.

trait BMW{

    // trait variables
    var make: String = "BMW"
    var model: String = "X7"
    var fuel: Int = 40

    // trait method: NON-ABSTRACT
    def Display()
    {
        println("Make of the Car : " + make);
        println("Model of the Car : " + model);
        println("Fuel capacity of the Car : " + fuel);
    }
}


class Car extends BMW{
    // class variables
    var make1: String = "Mercedes Benz"
    var model1: String = "S350D"
    var fuel1: Int = 50

    // Class method
    def Merc_Specs()
    {
        println("Make of the Car : " + make1);
        println("Model of the Car : " + model1);
        println("Fuel capacity of the Car : " + fuel1);
    }
}

object Main  
{

    // Main method
    def main(args: Array[String])  
    {

        // Class object
        var obj = new Car();
        println("Calling the Class Method")
        obj.Merc_Specs();
        println("Calling the Trait Method")
        obj.Display();
    }
}
Propulsé par

Exécutons le code ci-dessus :

À présent que vous avez compris la différence entre méthodes abstract et non-abstract, voyons ce qui peut poser problème lorsqu’une méthode abstract n’est pas implémentée dans la classe qui l’inherits ou l’extends.

Reprenons le même exemple pour illustrer ce point.

trait Scala_Course{  
    def scala()  
}  

class DataCamp extends Scala_Course{  
    def print(){  
        println("Error: Class DataCamp needs to be Abstract")  
    }  
}  

object Main{  
    def main(args:Array[String]){  
        var a = new DataCamp()  
        a.print()  
    }  
}
Propulsé par

L’exécution de ce code produit une erreur, comme ci-dessous, car vous n’avez pas défini la méthode de trait scala() (abstraite) dans la classe qui l’hérite.

Pour faire fonctionner ce code, deux solutions sont possibles :

• Définir la méthode scala() dans la classe DataCamp ; ou
• Déclarer la classe DataCamp comme abstract.

Dernier point pour aujourd’hui : comment hériter de plusieurs traits dans une même classe. Allons à l’essentiel.

trait A{
// methods
}
trait B{
// methods
}
class C extends A with B{
}
Propulsé par

trait BMW{


    var make: String = "BMW"
    var model: String = "X7"
    var fuel: Int = 40
}

trait Merc{


    var make1: String = "Mercedes Benz"
    var model1: String = "S350D"
    var fuel1: Int = 50


}



class Car extends BMW with Merc{

    def BMW_Specs()
    {
        println("Make of the Car : " + make);
        println("Model of the Car : " + model);
        println("Fuel capacity of the Car : " + fuel);
    }


    def Merc_Specs()
    {
        println("Make of the Car : " + make1);
        println("Model of the Car : " + model1);
        println("Fuel capacity of the Car : " + fuel1);
    }

}


object Main  
{

    // Main method
    def main(args: Array[String])  
    {

        // Class object
        var obj = new Car();
        println("Calling the BMW Trait")
        obj.BMW_Specs();
        println();
        println("Calling the Merc Trait")
        obj.Merc_Specs();
    }
}
Propulsé par

Enfin, exécutons le code ci-dessus.

Félicitations !

Bravo pour avoir terminé ce tutoriel.

Vous savez désormais ce que sont les traits en programmation et comment les utiliser en Scala. Un bon exercice serait de trouver une solution lorsque la méthode abstraite n’est pas définie dans la classe qui en hérite. Essayez d’écrire le code correspondant et vérifiez qu’il s’exécute sans erreur de compilation. Petit indice : regardez du côté des classes abstraites en Scala.

N’hésitez pas à poser vos questions sur ce tutoriel dans les commentaires ci-dessous.

Et pour finir, n’oubliez pas de suivre le nouveau cours Scala sur DataCamp, Introduction to Scala.