Tutoriel Scala

Résumé du didacticiel Scala

Ce didacticiel Scala couvre tous les aspects et sujets de Scala. Vous apprendrez tous les principes fondamentaux à partir de zéro, comme Qu'est-ce que Scala, le processus d'installation de Scala, les programmes Scala, les fonctions Scala, l'évaluation paresseuse, l'interface de type, les classes et les objets, l'héritage, les abstractions, Java et les différences d'échelle, etc.

Scala est un langage évolutif utilisé pour écrire des logiciels pour plusieurs plates-formes. C'est pourquoi il a reçu le nom de « Scala ». Ce langage est destiné à résoudre les problèmes de Java tout en étant plus concis. Initialement conçu par Martin Odersky, il a été publié en 2003.

Pourquoi apprendre Scala

Voici les principales raisons d’apprendre le langage de programmation Scala :

• Scala est facile à apprendre pour les programmeurs orientés objet, Java développeurs. C’est devenu l’une des langues les plus populaires ces dernières années.
• Scala offre des fonctions de première classe aux utilisateurs
• Scala peut être exécuté sur JVM, ouvrant ainsi la voie à l’interopérabilité avec d’autres langages.
• Il est conçu pour les applications simultanées, distribuées et résilientes basées sur les messages. C'est l'une des langues les plus exigeantes de cette décennie.
• Il s’agit d’un langage concis et puissant qui peut rapidement évoluer en fonction de la demande de ses utilisateurs.
• Il est orienté objet et possède de nombreuses fonctionnalités de programmation fonctionnelles offrant une grande flexibilité aux développeurs pour coder comme ils le souhaitent.
• Scala propose de nombreux types de canards
• Il y a moins de passe-partout si vous venez de Java
• Les frameworks Lift et Play écrits en Scala sont dans la courbe de croissance.

Comment installer Scala

Pour commencer à écrire des programmes Scala, vous devez l'installer sur votre ordinateur. Pour ce faire, vous devrez visiter leur site https://www.scala-lang.org/download/ afin de télécharger la dernière version de Scala.

En suivant le lien, nous sommes dirigés vers deux options que nous pouvons choisir pour installer Scala sur nos machines. Pour ce tutoriel Scala, nous allons télécharger le IntelliJ IDEA.

Une fois que vous aurez visité le lien de téléchargement, vous trouverez deux versions de l'IDE IntelliJ.

Pour ce didacticiel Scala, nous téléchargerons l'édition communautaire, qui est gratuite et contient tout ce dont vous avez besoin pour écrire des programmes Scala.

Étape 1) Sélectionnez l'édition communautaire
Sur la page, cliquez sur le menu déroulant de l'édition communautaire.

Il nous présente une option pour télécharger l'IDE IntelliJ avec JBR qui contient une implémentation JDK (Java Kit de développement) OpenJDK dont Scala a besoin pour compiler et exécuter le code.

Étape 2) Lancez l'installation
Une fois que vous avez téléchargé IntelliJ, double-cliquez dessus pour exécuter l'assistant d'installation et suivez la boîte de dialogue.

Étape 3) Choisissez un emplacement
Choisissez un emplacement pour installer l'EDI.

Si par hasard vous n'avez pas téléchargé celui avec le JDK, nous recevons toujours une invite où nous pouvons vérifier pour le télécharger en cochant la case.

Étape 4) Cliquez sur suivant
Laissez les autres valeurs par défaut telles quelles et cliquez sur Suivant.

Étape 5) Cliquez sur l'icône de démarrage
Une fois l'installation terminée, exécutez l'IDE IntelliJ en cliquant sur son icône de démarrage dans le menu de démarrage comme une application classique.

Vous devez encore passer par une étape supplémentaire consistant à ajouter le plugin Scala à IntelliJ ; pour ce faire, cliquez sur le menu déroulant du menu de configuration situé en bas à droite de l'écran et sélectionnez l'option plugin.

Dans l'onglet Marketplace, une recherche sur Scala présentera le plugin comme premier résultat sous la balise Languages.

Étape 6) Installer le plugin
Cliquez sur Installer, ce qui amènera le plugin à commencer le téléchargement.

Étape 7) Redémarrez l'IDE
Une fois le téléchargement terminé, vous serez invité à redémarrer l'IDE afin que le plugin installé puisse commencer à fonctionner.

Après le redémarrage, vous vous retrouverez sur la même page qu'avant lorsque nous avons exécuté l'EDI, mais cette fois-ci, nous avons déjà installé le plugin Scala.

Programme Scala Hello World

Étape 1) Sélectionnez l'option Créer un projet, qui nous mènera à une page où nous pourrons sélectionner le type de langage que notre projet utilisera.

Étape 2) choisissez Scala en cochant la case Scala et cliquez sur suivant.

Étape 3) Sélectionnez un emplacement pour enregistrer notre fichier de projets et donnez un nom à notre projet.

Si le répertoire n'existe pas, IntelliJ nous demandera de nous demander l'autorisation de créer le dossier. Acceptez et cliquez sur Terminer. Vous serez redirigé vers votre projet Scala, qui ne contient actuellement aucun code Scala.

Le chargement de certains index prendra un certain temps, alors ne vous inquiétez pas si vous ne parvenez pas à faire quoi que ce soit immédiatement alors qu'il y a une barre de progression en bas de votre IDE, cela signifie simplement que votre IDE charge certains fichiers nécessaires à l'exécution de Scala et aide à la saisie semi-automatique de l'IDE.

Étape 4) Ensuite, nous allons cliquer sur l'onglet projets à gauche de l'EDI et le développer pour pouvoir voir le contenu de notre projet.

Pour le moment, le projet est vide et ne contient qu'un dossier .idea et un fichier hello-world.iml générés par l'EDI. Notre point d’intérêt est le dossier src. Src est l'endroit où nous stockons le code source de notre projet. C'est là que nous allons créer notre premier fichier Scala.

Étape 5) Faites un clic droit sur src pour ouvrir un menu permettant de créer un nouveau fichier Scala.

Nous allons ensuite créer un nom pour le fichier, dans ce didacticiel Scala, nous utiliserons hello puis choisirons dans une liste déroulante ce qu'il faut mettre comme contenu du fichier Scala. Sélectionnez « Objet »

Une fois cela fait, nous aurons un fichier Scala contenant un objet Singleton que nous utiliserons pour exécuter notre code.

Maintenant que vous disposez d'un fichier Scala avec un objet Hello. Vous écrirez votre premier programme en étendant l'objet que vous avez créé à l'aide du mot-clé App.

L'extension de notre objet avec App indique au compilateur quel code exécuter lorsqu'il démarre votre programme. Immédiatement après l'extension de l'application, une flèche verte apparaît sur le côté gauche, indiquant que vous pouvez désormais exécuter votre programme.

À l’intérieur de l’objet Hello, nous écrivons une fonction println() qui est utilisée pour imprimer le texte qu’il contient sur la console. Nous allons exécuter notre code en cliquant sur la flèche verte.

En cliquant sur la flèche, nous obtenons l'option Exécuter, bonjour, en cliquant dessus, notre code commencera à se compiler et après quelques secondes nous verrons les résultats de notre programme imprimés depuis la console intégrée à l'IDE IntelliJ.

Et voilà, nous avons installé avec succès Scala et exécuté notre premier programme.

Ce que vous pouvez faire avec Scala

• Développement web front-end avec ScalaJS
• Développement mobile, les deux Android Développement et IOS – avec Scala Native
• Bibliothèques côté serveur comme HTTP4S, Akka-Http, Play Framework
• Internet des objets utilisant
• Développement de jeu
• NLP – Traitement du langage naturel utilisant une suite de bibliothèques ScalaNLP
• Tester des techniques de programmation avancées telles que la programmation fonctionnelle et la programmation orientée objet
• Construire une application de communication hautement concurrente en utilisant des acteurs, une bibliothèque pour la JVM inspirée d'Erlang
• Utilisez-le pour l'apprentissage automatique en utilisant des bibliothèques comme Figaro qui fait de la programmation probabiliste et Apache Spark qui

Fonctions anonymes

Le langage Scala possède des fonctions anonymes, également appelées littéraux de fonction. Scala étant un langage fonctionnel, cela signifie souvent que les développeurs décomposent les gros problèmes en plusieurs petites tâches et créent de nombreuses fonctions pour résoudre ces problèmes. Pour faciliter la création de fonctions, Scala contient ces fonctions qui peuvent être instancié sans nom. Nous pouvons les attribuer directement à des variables ou à des définitions « def », comme le montre l'exemple Scala ci-dessous :

val multiplyByTwo = (n:Int) => n * 2
def multiplyByThree = (n:Int) => n *3

Nous pouvons ensuite utiliser la manière normale dont nous utilisons les fonctions en leur passant les paramètres suivants.

multiplyByTwo(3)

//6

multiplyByThree(4)

//12

Ces méthodes sont utiles lorsque nous voulons avoir un code propre et concis. Nous pouvons utiliser des fonctions anonymes pour définir des méthodes qui ne sont pas volumineuses et ne nécessitent pas beaucoup de code dans leur corps. Ils sont très simples et ne nécessitent pas de cérémonie pour être créés.

Ces méthodes ne se limitent pas aux fonctions avec arguments et peuvent être utilisées pour instancier des méthodes qui ne prennent aucun argument.

val sayHello = ()=>{ println("hello") }

La plupart de ces fonctions anonymes sont utilisées dans d'autres parties de notre code où nous devons créer une fonction rapide en place.

Une autre raison pour laquelle ces fonctions sont également appelées fonctions en ligne. L'utilisation de fonctions anonymes est un modèle courant qui est largement utilisé dans la bibliothèque de collections pour effectuer des actions rapides sur une collection.

Par exemple, nous avons la méthode filter qui prend une fonction en ligne/une fonction anonyme pour créer une autre collection avec uniquement des éléments qui répondent aux critères que nous définissons dans la fonction anonyme.

val myList = List(1,2,3,4,5,6,7)

val myEvenList = myList.filter((n: Int) => n % 2 == 0)
//List(2,4,6)

val myOddList = myList.filter((n:Int) => n % 2 != 0)
//List(1,3,5,7)

Ici, les méthodes que nous avons en tant que fonctions anonymes sont celles qui vérifient si la valeur que nous obtenons de la liste est paire et impaire et renvoient l'élément.

//the one checking that the value is even
(n: Int) => n % 2 == 0

//the one checking that the value is odd
(n:Int) => n % 2 != 0

Dans Scala, il est également possible d'utiliser des caractères génériques où les paramètres de notre fonction anonyme ne sont pas nommés. Par exemple

var timesTwo = (_:Int)*2

timesTwo(5)
//10

Dans ce scénario, nous ne nommons pas le paramètre que nous transmettons. La seule chose que nous utilisons est un trait de soulignement pour le représenter.

Évaluation paresseuse

La plupart des langages évaluent séquentiellement les variables et les paramètres de fonction, les uns après les autres. Dans Scala, nous avons un mot-clé appelé lazy, qui aide à gérer les valeurs que nous ne voulons pas voir évaluées tant qu'elles ne sont pas référencées.

Une variable marquée comme paresseuse ne sera pas évaluée là où elle est définie, c'est ce qu'on appelle communément une évaluation hâtive, elle ne sera évaluée que lorsqu'elle sera référencée plus tard dans le code.

Cela peut être utile lorsque l'évaluation d'une valeur peut être un calcul coûteux, si la valeur n'est pas toujours nécessaire, nous pouvons nous éviter d'exécuter un calcul coûteux qui peut ralentir notre logiciel en rendant notre variable paresseuse.

lazy val myExpensiveValue = expensiveComputation

def runMethod()={
    if(settings == true){
        use(myExpensiveValue)
    }else{
        use(otherValue)
    }
}

Ce n'est pas le seul cas d'utilisation des variables paresseuses. Ils aident également à résoudre les problèmes de dépendance circulaire dans le code.

Dans le cas où les paramètres sont faux, nous n'aurons peut-être pas besoin d'utiliser myExpensiveValue, ce qui peut nous éviter d'effectuer un calcul coûteux, ce qui permet de garantir que les utilisateurs passent un bon moment en utilisant notre application, car leurs autres besoins peuvent être correctement calculés sans surcharger. le bélier.

Dans le cas où les paramètres sont faux, nous n'aurons peut-être pas besoin d'utiliser myExpensiveValue, ce qui peut nous éviter d'effectuer un calcul coûteux, ce qui permet de garantir que les utilisateurs passent un bon moment en utilisant notre application, car leurs autres besoins peuvent être calculés de manière appropriée sans surcharger. le bélier.

La paresse aide également avec les arguments de fonction, où les arguments ne sont utilisés que lorsqu'ils sont référencés à l'intérieur de la fonction. Ce concept est appelé paramètres d'appel par nom.

def sometimesUsedString(someValue:String, defaultValue:=> String)={
 if(someValue != null){
   use(defaultValue)
 }else{
   use(someValue)
   }
 }

De nombreux langages utilisent la méthode appel par valeur pour évaluer les arguments. Le paramètre passé via l'appel par nom ne sera évalué qu'en cas de besoin dans le corps de la fonction et ne sera pas évalué avant cela. Une fois la valeur évaluée, elle est stockée et peut être réutilisée ultérieurement sans qu'il soit nécessaire de la réévaluer. Un concept connu sous le nom de mémorisation.

Inférence de type

Dans Scala, vous n'avez pas besoin de déclarer des types pour chaque variable que vous créez. En effet, le compilateur Scala peut effectuer une inférence de type sur les types en fonction de l'évaluation du côté droit. Cela permet à votre code d'être plus concis – cela nous libère de l'écriture passe-partout où le type attendu est évident

var first:String = "Hello, "
var second:String = "World"
var third = first + second
//the compile infers that third is of type String

Fonction d'ordre supérieur

Une fonction d’ordre supérieur est une fonction qui peut prendre des fonctions comme arguments et renvoyer une fonction comme type de retour. À Scala, les fonctions sont considérées comme des citoyens de première classe. Utiliser ces fonctions de cette manière nous permet d'être très flexibles dans le type de programmes que nous pouvons créer. Nous pouvons créer des fonctions de manière dynamique et intégrer dynamiquement des fonctionnalités à d’autres fonctions.

def doMathToInt(n:Int, myMathFunction:Int=>Int): Int ={
    myMathFunction(n)
}

Dans la fonction ci-dessus, nous transmettons un int et une fonction qui prend un int et renvoie un int. Nous pouvons transmettre n'importe quelle fonction de cette signature. Par signature, nous entendons l’entrée et la sortie d’une fonction. Une signature de Int=>Int signifie qu'une fonction prend un Int comme entrée et renvoie un Int comme sortie.

Une signature de ()=>Int signifie qu'une fonction ne prend rien en entrée et renvoie un Int en sortie. Un exemple d’une fonction comme celle-là serait celle qui génère un entier aléatoire pour nous.

def generateRandomInt()={
 return scala.util.Random.nextInt()
}

La fonction ci-dessus a une signature ()=>Int

Nous pouvons avoir une fonction qui a une signature scala()=>Unit. Cela signifie que les fonctions ne prennent rien et ne renvoient pas de type. La fonction pourrait effectuer une sorte de calcul en modifiant quelque chose pour faire quelque chose de prédéterminé.

Ces types de méthodes ne sont cependant pas encouragés, car ils semblent être une boîte noire qui peut affecter un système de manière inconnue. Ils sont également intestables. Avoir des types d'entrée et de sortie explicites nous permet de raisonner sur ce que fait notre fonction.

Une fonction d'ordre supérieur peut également renvoyer une fonction.

Par exemple, nous pourrions créer une méthode qui créera une fonction d'alimentation, c'est-à-dire qui prend un nombre et lui applique une puissance.

def powerByFunction(n:Int):Int=>Int = {
  return (x:Int)=> scala.math.pow(x,n).toInt
}

La fonction ci-dessus prend un int. Notre type de retour est une fonction anonyme qui prend un Int x, * nous utilisons l'int x comme argument pour la fonction puissance.

Curry

En Scala, nous pouvons convertir une fonction qui prend deux arguments en une fonction qui prend un argument à la fois. Lorsque nous transmettons un argument, nous l'appliquons partiellement et nous nous retrouvons avec une fonction qui prend un argument pour compléter la fonction. Le currying nous permet de créer des fonctions en ajoutant partiellement quelques arguments.

Cela peut être utile pour créer des fonctions dynamiquement avant d'avoir un ensemble complet d'arguments

def multiply two numbers(n:Int)(m:Int): Unit ={
  return n * m
}

Si nous devons créer une fonction qui multiplie par un nombre spécifique, nous n'avons pas besoin de créer une autre méthode de multiplication.

Nous pouvons simplement appeler le .curried sur notre fonction ci-dessus et obtenir une fonction qui prend d'abord un argument et renvoie une fonction partiellement appliquée.

def multiplyTwoNumbers(n:Int)(m:Int): Unit ={
  return n * m
}

var multiplyByFive = multiplyTwoNumbers(5) 

multiplyByFive(4)

//returns 20

Correspondance de motif

Scala dispose d'un puissant mécanisme intégré pour nous aider à vérifier si une variable correspond à certains critères, un peu comme nous le ferions dans une instruction switch dans Java ou dans une série d'instructions if/else. Le langage propose une correspondance de modèles que nous pouvons utiliser pour vérifier si une variable est d'un type particulier. La correspondance de modèles dans Scala est puissante et peut être utilisée pour déstructurer les composants qui ont une méthode de désapplication afin d'obtenir les champs qui nous intéressent directement à partir de la variable que nous faisons correspondre.

La correspondance de modèles de Scala fournit également une syntaxe plus agréable par rapport à l'instruction switch.

myItem match {
  case true => //do something
  case false => //do something else
  case  _ => //if none of the above do this by default
}

Nous comparons notre variable à un ensemble d'options, et lorsque la variable que nous faisons correspondre répond aux critères, l'expression à droite de la grosse flèche (=>) est évaluée et est renvoyée comme résultat de la correspondance.

Nous utilisons un trait de soulignement pour détecter les cas qui ne correspondent pas à notre code. Il reflète le comportement du cas par défaut lors du traitement des instructions switch.

class Animal(var legs:Int,var sound:String)
class Furniture(var legs:Int, var color:Int, var woodType:String)

myItem match {
case myItem:Animal => //do something
case myItem:Furniture => //do something else
case _ => //case we have a type we don't recognize do sth else
}

Dans le code ci-dessus, vous pouvez connaître le type de la variable myItem et, en fonction de cette branche, passer à un code spécifique.

La correspondance de modèles vérifie si la variable correspond

Le trait de soulignement fonctionne comme un espace réservé qui correspond à toute autre condition qui ne correspond pas aux autres éléments des instructions case ci-dessus. Nous prenons une variable myItem et appelons la méthode match.

• nous vérifions si myItem est vrai en utilisant et faisons un peu de logique sur le côté droit de la grosse flèche « => ».
• nous utilisons le trait de soulignement pour faire correspondre tout ce qui ne correspond à aucune des instructions case que nous avons définies dans le code.

Avec les classes Case, nous pouvons même aller plus loin et déstructurer la classe pour obtenir des champs à l'intérieur de l'objet.

En utilisant le mot-clé scellé pour définir nos classes, nous bénéficions de l'avantage de permettre au compilateur de vérifier de manière exhaustive les cas avec lesquels nous essayons de comparer et de nous avertir si nous oublions de gérer un cas particulier.

Immutabilité

Il est possible de créer des valeurs qui ne peuvent pas être modifiées par d'autres fonctions dans Scala à l'aide du mot-clé val. Ceci est réalisé dans Java en utilisant le mot-clé final. Dans Scala, nous le faisons en utilisant un val mot-clé lors de la création d'une variable au lieu d'utiliser var, qui est l'alternative que nous utiliserions pour créer une variable mutable.

Une variable définie à l'aide du mot-clé val est en lecture seule, alors qu'une variable définie avec var peut être lue et modifiée par d'autres fonctions ou arbitrairement par l'utilisateur dans le code.

var changeableVariable = 8

changeableVariable =10
//the compiler doesn't complain, and the code compiles successfully

println(changeableVariable)
//10

val myNumber = 7

myNumber = 4

//if we try this the code won't compile

Essayer d'attribuer une valeur à myNumber après l'avoir déclarée comme val génère une erreur de compilation ou une « réaffectation à val ».

Pourquoi utiliser l'Immuabilité ?

L'immuabilité nous aide à empêcher le code et d'autres programmeurs de modifier nos valeurs de manière inattendue, ce qui entraînerait des résultats inattendus s'ils sont destinés à utiliser la valeur que nous stockons, ils peuvent à la place en faire une copie. De cette façon, les bogues pouvant être provoqués par plusieurs acteurs modifiant la même variable sont évités.

Classes et objets

Nous savons tous que les objets sont les entités du monde réel et que la classe est un modèle qui définit les objets. Les classes ont à la fois un état et des comportements. Les états sont soit des valeurs, soit des variables. Les comportements sont les méthodes de Scala.

Voyons comment définir une classe, l'instancier et l'utiliser à l'aide de Scala.

Ici, la classe appelée Rectangle, qui possède deux variables et deux fonctions. Vous pouvez également utiliser les paramètres l et b directement comme champs dans le programme. Vous avez un objet qui a une méthode principale et qui a instancié la classe avec deux valeurs.

Exemple :

class Rectangle( l: Int,  b: Int) {
  val length: Int = l
  val breadth: Int = b
  def getArea: Int = l * b
  override def toString = s"This is rectangle with length as $length and breadth as  $breadth"
  }
object RectObject {
  def main(args: Array[String]) {
    val rect = new Rectangle(4, 5)
    println(rect.toString)
    println(rect.getArea)    
  }
}

Tous les champs et méthodes sont publics par défaut dans Scala. Il est essentiel d'utiliser override car la méthode toString est définie pour Object dans Scala.

Droit des successions

Scala possède plusieurs types d'héritage (comme l'héritage simple, à plusieurs niveaux, multiple, hiérarchique, hybride) qui partagent beaucoup de points communs avec les formes traditionnelles trouvées dans Java. Vous pouvez hériter à la fois des classes et des traits. Vous pouvez hériter des membres d'une classe dans une autre classe en utilisant le mot-clé « extends ». Cela permet la réutilisation.

Il est possible d'hériter d'une ou plusieurs classes. Il est également possible d'hériter de sous-classes qui ont elles-mêmes leurs superclasses, créant ainsi une hiérarchie d'héritage.

Dans l'exemple Scala ci-dessous, la classe Base est Circle et la classe dérivée est Sphere. Un cercle a une valeur appelée rayon, héritée de la classe Sphere. La méthode calcArea est remplacée à l'aide du mot-clé override.

Exemple :

class Circle {
  val radius = 5;
  def calcArea = {
    println(radius * radius )
  }
}
class Sphere extends Circle{
 override def calcArea = {
    println(radius * radius * radius )
  }
}
  object SphereObject{
    def main(args : Array[String]){
      new Sphere().calcArea 
    }
  }

Abstraction

Dans Scala, nous pouvons créer des méthodes abstraites et des champs membres à l'aide de classes et de traits abstraits. À l'intérieur des classes et des traits abstraits, nous pouvons définir des champs abstraits sans nécessairement les implémenter.

Exemple :

trait MakesSound{
    var nameOfSound:String
    def sound():String
}
abstract class HasLegs(var legs:Int){
    val creatureName:String

    def printLegs():String={
        return s"$creatureName has this number of legs: $legs"
    }
}

Ces champs sont implémentés par les classes qui étendent le trait ou la classe abstraite. Vous pouvez utiliser des traits pour créer des contrats sur ce que notre application devrait être capable de faire, puis implémenter ces méthodes ultérieurement.

trait DatabaseService{
    def addItemName(itemName:String)
    def removeItem(itemId:Int)
    def updateItem(itemId:Int, newItemName:String)
}

De cette façon, nous pouvons planifier à quoi ressemblera notre application sans implémenter les méthodes qui peuvent nous aider à imaginer à quoi ressembleront les différentes méthodes. Il suit un modèle connu sous le nom de programmation d'abstractions et non d'implémentation réelle.

La classe précédée du mot-clé abstract peut contenir à la fois des méthodes abstraites et non abstraites. Mais les héritages multiples ne sont pas pris en charge dans la classe abstraite. Ainsi, vous pouvez étendre au plus une classe abstraite.

Objets Singleton

Un Singleton est une classe qui n'est instanciée qu'une seule fois dans un programme. Il s'agit d'un modèle de programmation populaire et utile connu sous le nom de « modèle singleton ». Il est utile pour créer des instances censées durer longtemps et qui seront communément accessibles dans tout votre programme dont l'état fait partie intégrante de la coordination des événements d'un système. Créer une telle classe dans Scala est simple car Scala nous fournit un moyen simple de créer des singletons à l'aide du mot-clé object.

object UserProfile{
    var userName=""
    var isLoggedIn:Boolean = false
}

Nous pouvons alors référencer cet objet tout au long de notre programme avec la garantie que toutes les parties de notre programme verront les mêmes données puisqu'il n'y en a qu'une seule instance.

def getLoggedInStatus():Boolean={
   return UserProfile.isLoggedIn
}

def changeLoggedInStatus():Boolean={
    UserProfile.isLoggedIn = !UserProfile.isLoggedIn
    return  UserProfile.isLoggedIn
}

Le concept de membres statiques n'existe pas dans Scala, c'est la raison pour laquelle vous devez utiliser des objets singleton, qui agissent comme des membres statiques d'une classe.

Classes implicites

Les classes implicites sont la nouvelle fonctionnalité ajoutée après la version 2.1. Il s'agit avant tout d'ajouter de nouvelles fonctionnalités aux classes fermées.

Le mot-clé implicite doit être défini dans une classe, un objet ou un trait. Le constructeur principal d'une classe implicite doit avoir exactement un argument dans sa première liste de paramètres. Il peut également inclure une liste de paramètres implicites supplémentaires.

Dans l'exemple Scala ci-dessous, une nouvelle fonctionnalité permettant de remplacer les voyelles d'une chaîne par * est ajoutée.

object StringUtil {
  implicit class StringEnhancer(str: String) {
    
    def replaceVowelWithStar: String = str.replaceAll("[aeiou]", "*")
  }
}

Vous devez importer dans la classe où vous l'utilisez.

import StringUtil.StringEnhancer

object ImplicitEx extends App {
  val msg = "This is Guru99!"
  println(msg.replaceVowelWithStar)
}

Programmation orientée objet (POO) vs programmation fonctionnelle (FP)

Dans la POO, les programmes sont construits en regroupant les données et les fonctions qui opèrent sur ces données en unités hautement connectées. Les objets transportent leurs données dans les champs et les méthodes qui les utilisent. Dans ce style de programmation, l'abstraction principale concerne les données, car les méthodes créées sont censées opérer sur les données.

Programmation fonctionnelle, d'autre part, sépare les données et les fonctions qui opèrent sur les données. Cela permet aux développeurs de traiter les fonctions comme une abstraction et une force motrice lors de la modélisation des programmes.

Scala permet la programmation fonctionnelle en ayant des fonctions en tant que citoyens de première classe, ce qui leur permet d'être transmises en tant que valeurs à d'autres fonctions et également renvoyées en tant que valeurs. La combinaison de ces deux paradigmes a fait de Scala un excellent choix pour créer des logiciels complexes dans divers secteurs, tels que la science des données.

Frameworks importants sur Scala

Voici quelques frameworks importants de Scala

• JOUER est un framework d'application Web open source qui utilise Architecture MVC. Sorti en 2007 et désormais sous licence Apache, il est devenu le framework le plus populaire sur GitHub en 2013. Des entreprises telles que LinkedIn, Walmart, Samsung, Eero utilisent ce framework.
• Hauteur de levage est un autre framework Web gratuit écrit en Scala lancé en 2007. Foursquare utilise le framework Lift. Il est très performant et plus rapide à créer un framework.
• Akka
• Chats
• Spark

Prise en charge de la concurrence

• Les valeurs dans Scala sont par défaut immuables. Cela le rend très adaptatif à l’environnement concurrent.
• Il existe de nombreuses fonctionnalités dans Scala qui le rendent idéal pour les applications simultanées.
• Futures and Promises facilite le traitement des données de manière asynchrone, prenant ainsi en charge le parallélisme.
• Akka – boîte à outils qui utilise le modèle de concurrence d'acteur. Il existe un certain nombre d'acteurs qui agissent lorsqu'ils reçoivent des messages.
• Concurrence utilisant les threads de Java peut également être pris en charge dans Scala.
• Le traitement des flux est une autre fonctionnalité intéressante qui permet un traitement continu et en temps réel des données.

Scala possède certaines des meilleures bibliothèques de concurrence du marché. Java écosystème.

• Originaire Java discussions
• Fibres de bibliothèques comme Vertex
• ZIO – une bibliothèque qui contient des primitives pour nous aider à gérer la concurrence et le calcul asynchrone
• STM – Transaction
• Future – intégré au langage Scala

Java contre Scala

Voici les principaux différence entre Java et Scala.

Scala	Java
Plus compact et concis	Des morceaux de code comparativement plus gros
Conçu et développé pour être un langage orienté à la fois objet et fonctionnel. Prend en charge une grande variété de fonctionnalités de programmation fonctionnelle telles que la concurrence et l'immuabilité.	Développé à l’origine comme un langage orienté objet et a commencé à prendre en charge des fonctionnalités de programmation fonctionnelle ces derniers jours. Ce n’est toujours pas fort en tant que langage de programmation fonctionnel.
Utilise un modèle d'acteur pour prendre en charge la concurrence qui est moderne	Utilise le modèle conventionnel basé sur les threads pour la concurrence.
Cadres pris en charge – Play, Lift	Prend en charge Spring, Grails et bien plus encore
Prend en charge l'évaluation paresseuse	Ne prend pas en charge l'évaluation paresseuse
Aucun membre statique	Contient des membres statiques
Prend en charge la surcharge de l'opérateur	Ne prend pas en charge la surcharge de l'opérateur
La compilation du code source est relativement lente	La compilation du code source est plus rapide que Scala
Traits – agir comme Java 8 interfaces	Java 8 interfaces tentent de combler le fossé entre les classes et les interfaces
Une réécriture est nécessaire	La réécriture n'est pas nécessaire
Aucune garantie sur les codes sans bug	Assurance complète des moindres défauts
Prend en charge la rétrocompatibilité.	Scala ne prend pas en charge la rétrocompatibilité.
Operales torseurs sont traités différemment dans Java et ne sont pas des appels de méthode.	Tous les opérateurs sur les entrées sont effectués via une méthode appelée en Scala.
Prend en charge plusieurs héritages en utilisant des classes mais pas par des classes abstraites	Ne prend pas en charge les héritages multiples à l'aide de classes, mais par interfaces
Le code est écrit sous une forme compacte.	Le code est écrit sous forme longue.
Scala ne contient pas le mot-clé static.	Java contient le mot clé static.

Résumé

Dans ce didacticiel, vous avez appris à démarrer avec Scala. Vous avez également appris les fonctionnalités fonctionnelles et orientées objet. Vous avez également découvert les similitudes et les différences entre Java et Scala. Ce tutoriel aurait dû vous aider avec une grande variété d'exemples bien démontrés.