Déclarations Scala


Si vous avez une bonne compréhension du langage Java, il sera alors facile d'apprendre Scala. La plus grande différence de syntaxe entre Scala et Java réside dans le fait que les terminateurs de ligne sont facultatifs. Considérons un programme Scala qui peut être défini comme une collection d'objets qui communiquent en appelant les méthodes des uns et des autres. Examinons maintenant brièvement ce qu'on appelle les classes, les objets, les méthodes et les variables temporaires.

  • Objets - Les objets ont un état et un comportement. Par exemple : un chien a des états – couleur, nom, race, et il a des comportements – remuer, aboyer, manger. Un objet est une instance d'une classe.

  • Classe - Une classe peut être définie comme un modèle/un plan pour décrire le comportement/indiquer son type d'objets de support.

  • Méthode – Une méthode est essentiellement une action. Les classes peuvent contenir de nombreuses méthodes. C'est dans la méthode que la logique est écrite, les données sont manipulées et toutes les actions sont effectuées.

  • Fields - Chaque objet possède son ensemble unique de variables temporaires, appelées champs. L'état de l'objet est créé par les valeurs attribuées à ces champs.

Le premier programme Scala :

Programmation en mode interactif :

L'appel de l'interpréteur sans passer un fichier de script en paramètre affichera l'invite suivante : 

C:>scalaWelcome to Scala version 2.9.0.1Type in expressions to have them evaluated.Type :help for more information.scala>

     Tapez le texte suivant dans l'invite Scala et appuyez sur Entrée : 

scala> println("Hello, Scala!");

Cela produira le résultat suivant : 

Hello, Scala!

Programmation en mode script :

Regardons un code simple qui imprime une phrase simple : Hello, World !

object HelloWorld {   /* This is my first java program.  
    * This will print 'Hello World' as the output
    */   def main(args: Array[String]) {
      println("Hello, world!") // prints Hello World   }}

Voyons comment enregistrer le fichier, compiler et exécuter le programme. Veuillez suivre les étapes ci-dessous :

  1.                 Ouvrez le bloc-notes et ajoutez le code ci-dessus.

  2. Enregistrez le fichier sous : HelloWorld.scala.

  3. Ouvrez une fenêtre d'invite de commande et accédez au répertoire dans lequel vous avez enregistré les fichiers du programme. Disons que c'est C:>

  4.                       Tapez "scalac HelloWorld.scala" et appuyez sur Entrée pour compiler le code. S'il n'y a aucune erreur dans le code, l'invite de commande passera automatiquement à la ligne suivante.

  5. La commande ci-dessus générera plusieurs fichiers de classe dans le répertoire courant. L'un des noms est HelloWorld.class. Il s'agit d'un bytecode qui peut être exécuté sur la machine virtuelle Java (JVM).

  6. Maintenant, tapez "scala HelloWorld" pour exécuter le programme.

  7. Vous pouvez voir « Hello, World ! » imprimé sur la fenêtre. 

C:> scalac HelloWorld.scala
C:> scala HelloWorldHello, World!

Grammaire de base

Concernant les programmes Scala, il est très important de prêter attention aux points suivants.

  • Case Sensitive - Scala est sensible à la casse, ce qui signifie que les identifiants Hello et Hello auront des significations différentes dans Scala.

  • Nom de classe - Mettez en majuscule la première lettre de tous les noms de classe.

    Si vous devez utiliser plusieurs mots pour former un nom de classe, mettez en majuscule la première lettre de chaque mot.

    Exemple : class MyFirstScalaClass

  • Nom de la méthode - La première lettre de tous les noms de méthode est en minuscule.

    Si plusieurs mots sont utilisés pour former le nom d’une méthode, la première lettre de chaque mot doit être en majuscule.

    Exemple : def myMethodName()

  • Nom du fichier programme - Le nom du fichier programme doit correspondre exactement au nom de l'objet.

    Lors de l'enregistrement du fichier, vous devez l'enregistrer en utilisant le nom de l'objet (rappelez-vous que Scala est sensible à la casse) et ajouter « .scala » comme extension de fichier. (Si le nom du fichier et le nom de l'objet ne correspondent pas, le programme ne sera pas compilé).

    Exemple : Supposons que "HelloWorld" soit le nom de l'objet. Ensuite, le fichier doit être enregistré sous 'HelloWorld.scala"

  • def main(args: Array[String]) - Le programme Scala démarre le traitement à partir du main( ), il s'agit de la partie d'entrée de programme obligatoire de chaque programme Scala. Modificateurs Scala :

    • Tous les composants Scala nécessitent des noms. L'utilisation de noms d'objet, de classe, de variable et de méthode est appelée identifiant. Les mots clés ne peuvent pas être utilisés car les identifiants sont sensibles à la casse. Scala prend en charge les quatre identifiants de type suivants :

Identifiant littéral

Les identifiants alphanumériques commencent par une lettre ou un trait de soulignement et peuvent utiliser des lettres, des chiffres ou des traits de soulignement. Le caractère "$" est un mot-clé réservé dans Scala et ne peut pas être utilisé dans les identifiants. Les identifiants alphabétiques légaux suivants sont : 

age, salary, _value,  __1_value

Les identifiants suivants sont illégaux : 

$salary, 123abc, -salary

          Identifiant de l'opérateur

Un identifiant d'opérateur se compose d'un ou plusieurs caractères d'opérateur. Les caractères d'opération sont des caractères ASCII imprimables tels que +, :, ?, ~ ou #. Les identifiants suivants sont des identifiants légaux d'opérateur : 

+ ++ ::: <?> :>

Le compilateur Scala "roulera" en interne les identifiants d'opérateur afin qu'ils deviennent des identifiants Java légaux, intégrant le caractère $. Par exemple, l'identifiant :-> sera représenté en interne par $colon$moins$greater.

Identifiant mixte

Les identifiants mixtes sont identifiés par un identifiant alphanumérique, suivi d'un trait de soulignement et d'un opérateur. Les identifiants suivants sont des identifiants mixtes légaux : 

unary_+,  myvar_=

Ici, unary_+ est utilisé comme nom de méthode pour définir un opérateur unaire + et myvar_= est utilisé comme nom de méthode pour définir un opérateur d'affectation.

Identifiant immédiat

Un identifiant littéral est une chaîne de caractères entourée de guillemets (` . . . `). Les balises de texte suivantes sont des balises de texte légale : 

`x` `<clinit>` `yield`

Mots-clés Scala :

La liste suivante montre les mots réservés en Scala. Ces mots-clés réservés ne peuvent pas être utilisés comme constantes ou variables, ou tout autre nom d'identifiant.

                        résumé                        cas                        attraper                        cours
                        déf                        faire                        autre                        s'étend
                        faux                        finale                        enfin                        pour
                        pourCertains                        si                        implicite                        importer
                        paresseux                        match                        nouveau                        nul
                        objet                        remplacer                        forfait                        privé
                        protégé                        retour                        scellé                        super
                        ceci                        lancer                        trait                        essayez
                        vrai                        tapez                        val                        var
                        pendant                        avec                        rendement                         
                        -                        :                        =                        =>
                        <-                        <:                        <%                        > :
                      #                     @                                            

Commentaires dans Scala

Scala prend en charge les commentaires sur une seule ligne et sur plusieurs lignes, tout comme Java. Les commentaires multilignes peuvent être imbriqués, mais ils doivent être correctement imbriqués. Tous les commentaires et tous les caractères disponibles seront ignorés par le compilateur Scala. 

object HelloWorld {   /* This is my first java program.  
    * This will print 'Hello World' as the output
    * This is an example of multi-line comments.
    */   def main(args: Array[String]) {      // Prints Hello World      // This is also an example of single line comment.
      println("Hello, world!") 
   }}

Lignes et espaces vides :

Une ligne contenant uniquement des espaces, éventuellement avec un commentaire, est appelée une ligne vide et Scala l'ignorera complètement. Les balises peuvent être séparées par des espaces et/ou des commentaires.

Saut de ligne :

Scala est un langage orienté ligne et les instructions peuvent se terminer par un point-virgule (;) ou un caractère de nouvelle ligne. Un point-virgule à la fin d'une instruction est généralement facultatif. Vous pouvez saisir une instruction souhaitée si elle apparaît seule sur une ligne. En revanche, si vous écrivez plusieurs déclarations sur une seule ligne, un point-virgule est requis : 

val s = "hello"; println(s)

                 Forfait Scala :

Un package est un module nommé par code. Par exemple, le package utilitaire Lift net.liftweb.util. La déclaration du package est la première ligne sans commentaire du fichier source, comme indiqué ci-dessous : 

package com.liftcode.stuff

Les packages Scala peuvent être importés, ce qui leur permet d'être référencés dans la portée de compilation actuelle. L'instruction suivante est le contenu du package scala.xml importé : 

import scala.xml._

Les classes et objets encapsulés peuvent être importés, par exemple, HashMap depuis scala.collection.mutable : 

import scala.collection.mutable.HashMap

Plusieurs classes ou objets peuvent être importés à partir d'un seul package scala.collection.immutable encapsulé, par exemple, TreeMap et TreeSet : 

import scala.collection.immutable.{TreeMap, TreeSet}