Traits Scala

DataCamp a récemment lancé leur premier cours en Scala : Introduction à Scala. Le voir !

Vous pourriez également être intéressé(e) à lire les tutoriels suivants :

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

Introduction

Un Trait est un concept principalement utilisé en programmation orientée objet, qui peut étendre les fonctionnalités d’une classe en utilisant un ensemble de méthodes.

Les traits sont similaires aux interfaces dans le langage de programmation Java. Contrairement à une classe, les traits Scala ne peuvent pas être instanciés et n’ont ni arguments ni paramètres. Cependant, vous pouvez les hériter (étendre) à l’aide de classes et d’objets. Cela dit, les traits fournissent un ensemble spécifique de méthodes/fonctions qui exécutent un comportement pour une classe et attendent que la classe implémente un ensemble de méthodes qui paramètrent ensuite le comportement fourni.

Un trait utilisé pour définir un objet est créé comme un mélange de méthodes qui peuvent être utilisées par différentes classes sans nécessiter d’héritage multiple. Cependant, il peut y avoir des exceptions où deux traits ont une méthode avec le même nom (collision de noms), qui doivent être utilisés par une classe, auquel cas l’ambiguïté doit être résolue explicitement.

Les traits peuvent avoir à la fois des méthodes abstraites et non abstraites, ainsi que des champs en tant que membres. Lorsque vous n’initialisez pas une méthode dans un trait, elle est abstraite, tandis que celles qui sont initialisées sont appelées non abstraites. Dans les méthodes abstraites, c’est la classe qui implémente le trait qui prend en charge l’initialisation.

Voyons maintenant rapidement les traits Scala à l’aide de quelques exemples !

Syntaxe des traits Scala

La syntaxe pour le trait Scala est simple, elle est définie par le mot-clé trait suivi du nom du trait.

trait Trait_Name{
// Variables
// Méthodes
}

Comme vous pouvez le voir dans la définition de caractéristique ci-dessus, une caractéristique nommée DataCamp a été définie, qui n’a pas de variables et de méthodes définies à l’intérieur.

Allons passer à un exemple simple de caractéristiques Scala, qui vous donnera davantage de clarté sur la manière dont elles fonctionnent programmatiquement.

Comme discuté dans l’introduction, les caractéristiques Scala sont héritées par une classe à l’aide du mot-clé extends.

class Scala_Tutorial extends DataCamp{
// Variables
// Méthodes
}

Définissons une caractéristique nommée Scala_Course, qui sera héritée par la classe DataCamp. Dans la caractéristique, vous définirez 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()  
    }  
}

Maintenant, exécutons le code ci-dessus.

Dans l’exemple précédent, la méthode scala() était une méthode abstraite, et donc, sa déclaration a été faite dans la classe qui héritait de cette caractéristique.

Mais que se passe-t-il si vous avez déjà implémenté une méthode (non abstraite) dans la caractéristique ? Bien sûr, dans ce cas, la classe qui hérite de cette caractéristique n’a pas besoin d’implémenter la méthode qui est déjà implémentée dans la caractéristique.

Expliquons cela avec l’aide d’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();
    }
}

Exécutez le code ci-dessus :

Maintenant que vous avez compris la différence entre les méthodes abstraites et non-abstraites, voyons ce qui peut se passer quand une méthode abstraite n’est pas implémentée dans la classe qui l’hérite ou l’étend.

Nous allons utiliser le même exemple pour comprendre ce concept.

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

L’exécution du code ci-dessus entraîne une erreur, comme illustré ci-dessous, car vous n’avez pas défini la méthode de traits scala() (abstraite) dans la classe qui l’hérite.

Pour que le code ci-dessus fonctionne, deux solutions possibles peuvent être :

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

Le dernier sujet du tutoriel d’aujourd’hui est la manière dont vous pouvez hériter de plusieurs traits dans une seule classe. Donc, essayons de terminer rapidement.

trait A{
// Méthodes
}
trait B{
// Méthodes
}
class C extends A with B{
}

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  
{

    // Méthode principale
    def main(args: Array[String])  
    {

        // Objet de classe
        var obj = new Car();
        println("Calling the BMW Trait")
        obj.BMW_Specs();
        println();
        println("Calling the Merc Trait")
        obj.Merc_Specs();
    }
}

Voici la traduction en français :

Finalement, exécutons le code ci-dessus.

Félicitations !

Félicitations pour avoir terminé ce tutoriel.

Vous savez maintenant ce que sont les Traits en programmation et comment les utiliser en Scala. Un bon exercice pour vous serait de trouver une solution pour la méthode abstraite non définie dans la classe qui l’a héritée. Essayez d’écrire du code pour la même chose et voyez si le code s’exécute sans erreur de compilation. Un petit conseil, vous pourriez regarder les Classes Abstraites en Scala.

N’hésitez pas à poser toutes les questions relatives à ce tutoriel dans la section des commentaires ci-dessous.

Enfin, n’oubliez pas de suivre le nouveau cours Scala sur DataCamp, Introduction à Scala.