Classes et objets Scala

Tutoriels
Scala

DataCamp vient de lancer leur premier cours en Scala : Introduction à Scala. Le consultez !

Veuillez également consulter les tutoriels suivants :

Introduction

Source

En général, la Programmation Orientée Objet (POO) se compose de classes et d’objets et vise à implémenter des entités du monde réel telles que la polymorphie et l’héritage.

La POO rend le développement beaucoup plus rapide et moins cher avec une meilleure maintainabilité du logiciel. La raison principale de ce phénomène magique est le nombre de fonctionnalités qu’il supporte ; vous avez des classes & objets qui peuvent facilement être réutilisés dans le futur en fonction des besoins, contrairement à un programme qui manque de classes & objets. Cela amène en retour à un logiciel de haute qualité, qui est également extensible avec de nouvelles méthodes et attributs.

Vous avez un salon d’exposition de voitures ; tous les quelques mois, une nouvelle voiture est lancée, et pour informer le public de son nom et de ses caractéristiques, vous devez définir de nouvelles méthodes, des attributs à partir de zéro. Cependant, si vous avez un programme orienté objet qui contient une classe voiture, tout ce que vous ajouterez est un objet pour cette nouvelle voiture, qui appellera les méthodes et attributs de classe avec les informations du véhicule.

La classe peut être considérée comme une représentation ou un design pour les objets. Les classes auront généralement leurs propres méthodes (comportement) et attributs.

Les attributs sont des entités individuelles qui distinguent chaque objet des autres et déterminent les différentes qualités d’un objet. Les méthodes, quant à elles, sont plus comme les fonctions qui opèrent habituellement dans la programmation. Elles déterminent comment fonctionne l’instance de la classe. C’est surtout grâce aux méthodes (comportement) ; les objets ont la capacité d’être traités.

Source

Le schéma ci-dessus vous donne une meilleure intuition sur le flux de la programmation orientée objet ou, pour être plus précis, à quoi ressemble une classe. Dans l’image ci-dessus, il y a une class car qui a des attributs : fuel, max speed et peut en avoir d’autres comme le model, make, etc. Elle possède différents ensembles de méthodes comme refuel(), getFuel(), setSpeed(), et d’autres méthodes supplémentaires peuvent être change gear, start the engine, stop the engine, etc.

Donc, lorsque vous parlez d’une voiture spécifique, vous aurez un objet, qui est une instantiation d’une classe.

Maintenant, Parlons de la programmation orientée objet en Scala.

Classes et Objets en Scala

Comme le C++ et Java, la programmation orientée objet en Scala suit pratiquement les mêmes conventions. Il a le concept de définition de classes et d’objets ainsi que des constructeurs dans les classes, et c’est tout ce qu’il y a à savoir sur la programmation orientée objet en Scala.

Déclaration de Classe

class Class_name{
// méthodes et attributs
}

Une classe en Scala est définie par le mot-clé class suivi par le nom de la classe, et généralement, le nom de la classe commence par une lettre majuscule. Il y a quelques mots-clés optionnels qui peuvent être utilisés dans la déclaration de classe en Scala, comme : class-name, il doit commencer par une majuscule : superclass, le nom de la classe parente précédé par le mot-clé extend : traits, il s’agit d’une liste séparée par des virgules implémentée par la classe précédée par le mot-clé extend.

Une classe en Scala ne peut hériter que d’une seule classe parente, ce qui signifie que Scala ne supporte pas l’héritage multiple. Cependant, cela peut être réalisé à l’aide de Traits.

Finalement, le corps d’une classe en Scala est entouré d’accolades {}.

// Le nom de la classe est Car
class Car
{

    // Variables de classe
    var make: String = "BMW"
    var model: String = "X7"
    var fuel: Int = 40

    // Méthode de classe
    def Display()
    {
        println("Make of the Car : " + make);
        println("Model of the Car : " + model);
        println("Fuel capacity of the Car : " + fuel);
    }
}
object Main  
{

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

        // Objet de classe
        var obj = new Car();
        obj.Display();
    }
}

Vous pouvez enregistrer le code ci-dessus sous le nom class.scala et l’exécuter sur le terminal en utilisant scala class.scala, et vous devriez voir la sortie ci-dessous.

En fait, le code ci-dessus ne fait pas complètement usage des privilèges qu’un programme orienté objet est capable de fournir. Puisque la sortie du code ci-dessus donnera le même résultat indépendamment du nombre de fois où vous le lancez. Vous avez défini des variables statiques à l’intérieur de la classe, et les valeurs de ces variables resteront constantes, même si vous créez un nombre infini d’objets nouveaux. En conclusion, vous ne pouvez pas attendre qu’il vous fournisse des détails pour une Mercedes Benz ou une Ferrari.

Les constructeurs en Scala

Les constructeurs sont principalement utilisés pour initialiser l’état de l’objet. Cette initialisation de l’objet a lieu au moment de sa création, et ils ne sont appelés qu’une seule fois.

Il existe deux types de constructeurs en Scala : Principal et Secondaire. Pour ce tutoriel, vous apprendrez à propos du constructeur principal (Source: O’Reilly).

class Class_name(Parameter_list){
// méthodes, attributs
}

Le constructeur principal contient le même corps que la classe, et il est créé implicitement avec la définition de la classe. Il commence à la définition de la classe et s’étend à tout le corps de la classe. De plus, lorsque’il n’y a qu’un seul constructeur dans le programme Scala, on parle de constructeur principal. Un constructeur principal peut être défini avec zéro, un ou plusieurs paramètres.

Voici la traduction en français du texte fourni :

Ainsi, prenez l’exemple précédent, mais cette fois-ci ajoutez la caractéristique du constructeur primaire et observez l’effet.

Vous apprendrez également ici une nouvelle caractéristique d’une classe, à savoir qu’une classe peut avoir plusieurs objets ou instances mais qui sont tous indépendants les uns des autres.

// Le nom de la classe est Car
class Car(make: String, model: String, fuel: Int)
{

    // Méthode de classe
    def Display()
    {
        println("Make of the Car : " + make);
        println("Model of the Car : " + model);
        println("Fuel capacity of the Car : " + fuel);
    }
}

object Main

{

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

        // Multiples objets de classe
        var obj1 = new Car("BMW", "X7", 40);
        var obj2 = new Car("Mercedes Benz", "S350D", 50);
        obj1.Display();
        obj2.Display();
    }
}

Voyons rapidement la sortie :

Voilà, n’est-ce pas formidable ? Avec l’aide d’un constructeur, vous avez été capable de générer des résultats plus efficaces.

Déclaration d’objets en Scala

La déclaration d’objets en Scala peut également être appelée instanciation d’une classe ou invocation d’une classe. Comme les classes, les objets sont également une unité fondamentale de la programmation orientée objet.

Un objet peut se composer de trois caractéristiques (Source: GeeksforGeeks:

  • État : Les attributs d’un objet le représentent. Ils reflètent également les propriétés d’un objet.
  • Comportement : Les méthodes d’un objet le représentent. Elles reflètent également la réponse d’un objet avec d’autres objets.
  • Identité : Elle donne un nom unique à un objet et permet à un objet d’interagir avec d’autres objets.

Considérer le Chien comme un objet et consulter le diagramme ci-dessous pour sa représentation de l’identité, de l’état et du comportement.

(Source)

Toutes les instances ou objets partagent les attributs et méthodes de classe. Une seule classe peut avoir plusieurs objets, comme vous l’avez appris ici. Cependant, l’état ou les valeurs de chaque objet sont uniques.

Enfin, vous écririez du code qui réunirait les constructeurs primaires, les variables de classe, les attributs et les méthodes toutes dans un seul code.

Voici une représentation graphique des composants mis ensemble dans la classe Motorcycle.

Le code ci-dessous est assez explicite ; à un niveau supérieur, il vérifie si le moteur de la moto est allumé ou éteint. Initialement, le moteur est mis à l’état d’arrêt, et il vous notifiera de son état et le basculera sur.

class Motorcycle(make:String,color:String) {


       var engineState: Boolean = false;

       def startEngine() {
          if (engineState == true){
            println("The engine is already on.");
          }
          else {
            engineState = true
            println("The engine is now on.");
         }
       }

       def showAtts() {
         println("This motorcycle is a "+ color + " " + make);
         if (engineState == true){
           println("The engine is on.");
         }
         else{
            println("The engine is off.");
         }
      }

}
object Main
{
    def main (args: Array[String])
    {
        var m = new Motorcycle("BMW K 1600 GTL","White");
        println("Calling showAtts...");
        m.showAtts();
        println("------");
        println("Starting engine...");
        m.startEngine();
        println("------");
        println("Calling showAtts...");
        m.showAtts();
        println("------");
        println("Starting engine...");
        m.startEngine();
    }
}

Félicitations !

Félicitations pour avoir terminé ce tutoriel.

Vous savez maintenant comment déclarer des classes et des méthodes, instancier des objets, définir leurs attributs et appeler des méthodes d’instance en Scala. Ces concepts seront utiles à vous non seulement en Scala mais également dans d’autres langages de programmation.

Les concepts de programmation orientée objet sont intéressants et, en même temps, très puissants. Ils ajoutent une nouvelle dimension à votre code, le rendant réutilisable. Comme votre programme devient plus grand, votre code se compliquera. Les concepts de programmation orientée objet tels que l’héritage, la polymorphie, les méthodes d’instance contiennent beaucoup de contenu. Une autre fonction puissante est le Singleton. Les principes de conception aident à maintenir votre code plus structuré et lisible. Pour en savoir plus sur les patrons de conception, envisagez de lire ce livre.

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

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

Source:
https://www.datacamp.com/tutorial/scala-classes-objects