Cours
Introduction à Scala
3 h
27.1K
DataCamp a récemment lancé son premier cours Scala : Introduction to Scala. Allez y jeter un œil !
Découvrez également les tutoriels suivants :
Introduction
De manière générale, la programmation orientée objet (POO) repose sur des classes et des objets, et vise à modéliser des entités du monde réel comme le polymorphisme et l’héritage.
La POO rend le développement plus rapide et moins coûteux, avec une meilleure maintenabilité logicielle. La principale raison de cet avantage tient aux nombreuses fonctionnalités qu’elle propose : vous disposez de classes et d’objets facilement réutilisables selon les besoins, à l’inverse d’un programme qui en serait dépourvu. Résultat : un logiciel de meilleure qualité, extensible avec de nouvelles méthodes et de nouveaux attributs.
Supposons que vous teniez un showroom automobile : tous les quelques mois, un nouveau modèle sort. Pour informer votre audience de son nom et de ses caractéristiques, vous devez définir de nouvelles méthodes et de nouveaux attributs à partir de zéro. En revanche, si votre programme orienté objet comporte une classe car, il vous suffit d’ajouter un objet pour ce nouveau modèle, qui appellera les méthodes et attributs de la classe avec les informations du véhicule.
Une classe peut être vue comme la représentation ou le plan d’objets. Les classes disposent en général de leurs propres méthodes (comportements) et attributs.
Les attributs sont des éléments qui distinguent chaque objet et en déterminent diverses propriétés. Les méthodes, quant à elles, s’apparentent au fonctionnement habituel d’une fonction en programmation. Elles définissent le fonctionnement de l’instance de la classe. C’est surtout grâce aux méthodes (au comportement) que les objets peuvent « subir » des actions.
La figure ci-dessus illustre le flux de la programmation orientée objet et, plus précisément, l’apparence d’une classe. On y voit une class car avec des attributs : fuel, max speed, à laquelle on pourrait ajouter d’autres attributs comme le model, le make, etc. Elle possède différentes méthodes comme refuel(), getFuel(), setSpeed(), auxquelles on peut adjoindre change gear, start the engine, stop the engine, etc.
Ainsi, lorsque vous parlez d’une voiture précise, vous avez un objet, c’est-à-dire une instanciation de la classe.
Passons maintenant à la programmation orientée objet en Scala.
Classes et objets en Scala
À l’instar de C++ et Java, la POO en Scala suit peu ou prou les mêmes conventions. On y définit des classes et des objets, ainsi que des constructeurs au sein des classes : c’est l’essentiel de la POO en Scala.
Déclaration d’une classe
class Class_name{
// methods and attributes
}
En Scala, une classe est définie par le mot-clé class suivi du nom de la classe, qui commence généralement par une majuscule. Quelques éléments optionnels peuvent s’ajouter à la déclaration, par exemple : class-name, qui doit débuter par une majuscule ; superclass, le nom de la classe parente précédé du mot-clé extend ; traits, une liste séparée par des virgules et implémentée par la classe, également précédée de extend.
Une classe en Scala ne peut hériter que d’une seule classe parente : Scala ne prend donc pas en charge l’héritage multiple. Toutefois, on peut s’en approcher grâce aux Traits.
Enfin, le corps d’une classe en Scala est délimité par des accolades {}.
// Name of the class is Car
class Car
{
// Class variables
var make: String = "BMW"
var model: String = "X7"
var fuel: Int = 40
// Class method
def Display()
{
println("Make of the Car : " + make);
println("Model of the Car : " + model);
println("Fuel capacity of the Car : " + fuel);
}
}
object Main
{
// Main method
def main(args: Array[String])
{
// Class object
var obj = new Car();
obj.Display();
}
}
Enregistrez le code ci-dessus sous le nom class.scala et exécutez-le dans le terminal avec scala class.scala : vous devriez obtenir la sortie ci-dessous.
Ce code n’exploite pas pleinement les atouts de la POO. La sortie restera identique, quel que soit le nombre d’exécutions. Vous avez défini des variables statiques dans la classe, dont les valeurs restent constantes, même si vous créez un nombre infini de nouveaux objets. En clair, vous ne pourrez pas obtenir des détails pour une Mercedes-Benz ou une Ferrari.
Constructeur en Scala
Les constructeurs servent principalement à initialiser l’état d’un objet. Cette initialisation s’effectue lors de la création de l’objet et n’a lieu qu’une seule fois.
Scala propose deux types de constructeurs : Primary et Auxiliary. Dans ce tutoriel, vous verrez le constructeur principal (Source : O'Reilly).
class Class_name(Parameter_list){
// methods, attributes
}
Le constructeur principal partage le même corps que la classe et est créé implicitement avec la définition de la classe. Il commence à la définition de la classe et couvre l’intégralité de son corps. Lorsqu’il n’y a qu’un seul constructeur dans un programme Scala, on parle de constructeur principal. Il peut être défini avec zéro, un ou plusieurs paramètres.
Reprenons l’exemple précédent, en y ajoutant cette fois un constructeur principal, et observons l’effet.
Vous découvrirez aussi une autre caractéristique : une même classe peut avoir plusieurs objets ou instances, indépendants les uns des autres.
// Name of the class is Car
class Car(make: String, model: String, fuel: Int)
{
// Class method
def Display()
{
println("Make of the Car : " + make);
println("Model of the Car : " + model);
println("Fuel capacity of the Car : " + fuel);
}
}
object Main
{
// Main method
def main(args: Array[String])
{
// Multiple Class object
var obj1 = new Car("BMW", "X7", 40);
var obj2 = new Car("Mercedes Benz", "S350D", 50);
obj1.Display();
obj2.Display();
}
}
Voyons rapidement la sortie :
Plutôt convaincant, non ? Grâce au constructeur, vous pouvez produire des résultats bien plus utiles.
Déclarer des objets en Scala
Déclarer des objets en Scala revient à instancier ou invoquer une classe. Comme les classes, les objets sont une brique fondamentale de la POO.
Un objet peut être décrit par trois caractéristiques (Source : GeeksforGeeks) :
State :les attributs d’un objet le représentent et en reflètent les propriétés.Behavior :les méthodes d’un objet le représentent et reflètent ses interactions avec d’autres objets.Identity :donne un nom unique à l’objet et lui permet d’interagir avec d’autres objets.
Considérez Dog comme un objet et voyez ci-dessous son identité, son état et son comportement.
Toutes les instances ou objets partagent les attributs et méthodes de la classe. Une classe peut avoir plusieurs objets, comme vous l’avez vu ici. En revanche, l’état ou les valeurs de chaque objet lui sont propres.
Pour finir, vous allez écrire un code qui combine constructeur principal, variables de classe, attributs et méthodes dans un seul exemple.
Ci-dessous, une représentation visuelle des composants réunis dans la classe Motorcycle.
Le code suivant est assez explicite : à haut niveau, il vérifie si le moteur de la moto est on ou off. Au départ, le moteur est à l’arrêt, le programme vous en informe puis l’allume.
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 désormais 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 vous seront utiles non seulement en Scala, mais aussi dans d’autres langages.
Les concepts de POO sont à la fois passionnants et puissants. Ils ajoutent une nouvelle dimension à votre code et favorisent la réutilisabilité. À mesure que votre programme grandit, la complexité augmente. La POO recèle de nombreuses notions riches comme l’héritage, le polymorphisme, les méthodes d’instance. Une autre fonctionnalité puissante est le Singleton. Les principes de conception aident à garder un code structuré et lisible. Pour aller plus loin sur les design patterns, nous vous recommandons cet ouvrage.
N’hésitez pas à poser vos questions sur ce tutoriel dans les commentaires ci-dessous.
Enfin, n’oubliez pas de suivre le nouveau cours Scala sur DataCamp, Introduction to Scala.
Sujets