Syntaxe de base de Scala
Si vous êtes un programmeur Java et que vous comprenez les bases du langage Java, vous pouvez rapidement apprendre la syntaxe de base de Scala.
La plus grande différence entre Scala et Java est que le point-virgule ; à la fin des instructions Scala est facultatif.
Nous pouvons considérer les programmes Scala comme des collections d'objets qui implémentent le passage de messages en appelant les méthodes les uns des autres. Ensuite, comprenons les concepts de classes, d'objets, de méthodes et de variables d'instance :
Objet -Les objets ont des propriétés et des comportements. Par exemple : les propriétés d'état d'un chien sont : couleur, nom ; les comportements sont : aboyer, courir, manger, etc. Un objet est une instance d'une classe.
Classe -Une classe est une abstraction d'objets, et un objet est une instance concrète d'une classe.
Méthode -Les méthodes décrivent des comportements de base. Une classe peut contenir plusieurs méthodes.
Champ -Chaque objet possède son propre ensemble unique de variables d'instance, à savoir des champs. Les propriétés d'un objet sont créées en affectant des valeurs aux champs.
Premier programme Scala
Programmation interactive
La programmation interactive ne nécessite pas de créer des fichiers de script ; elle peut être invoquée avec la commande suivante :
$ scala
Welcome to Scala version 2.11.7 (Java HotSpot(TM) 64-Bit Server VM, Java 1.8.0_31).
Type in expressions to have them evaluated.
Type :help for more information.
scala> 1 + 1
res0: Int = 2
scala> println("Hello World!")
Hello World!
scala>
Forme de script
Nous pouvons également exécuter du code en créant un fichier HelloWorld.scala. Le code de HelloWorld.scala est le suivant :
Code du fichier HelloWorld.scala :
/* Ceci est mon premier programme Scala
* Le programme suivant affichera 'Hello World!'
*/
def main(args: Array[String]) = {
println("Hello, world!") // Affiche Hello World
}
}
Ensuite, nous utilisons la commande scalac pour le compiler :
$ scalac HelloWorld.scala $ ls HelloWorld$.class HelloWorld.scala HelloWorld.class
Après compilation, nous pouvons voir le fichier HelloWorld.class généré dans le répertoire. Ce fichier peut s'exécuter sur la machine virtuelle Java (JVM).
Après compilation, nous pouvons utiliser la commande suivante pour exécuter le programme :
$ scala HelloWorld Hello, world!
Syntaxe de base
Il convient de noter les points suivants concernant la syntaxe de base de Scala :
Sensibilité à la casse- Scala est sensible à la casse, ce qui signifie que les identifiants Hello et hello ont des significations différentes en Scala.
Noms de classes- Pour tous les noms de classes, la première lettre doit être en majuscule.
Si plusieurs mots sont utilisés pour former un nom de classe, la première lettre de chaque mot doit être en majuscule.
Exemple :class MyFirstScalaClassNoms de méthodes- La première lettre de tous les noms de méthodes doit être en minuscule.
Si plusieurs mots sont utilisés pour former un nom de méthode, la première lettre de chaque mot doit être en majuscule.
Exemple :def myMethodName()Noms de fichiers de programme- Le nom de fichier du programme doit correspondre exactement au nom de l'objet (les versions plus récentes ne l'exigent plus, mais il est recommandé de conserver cette habitude).
Lors de l'enregistrement du fichier, vous devez l'enregistrer avec le nom de l'objet qu'il utilise (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 se compilera pas).
Exemple : Supposons que "HelloWorld" soit le nom de l'objet. Alors le fichier doit être enregistré sous 'HelloWorld.scala"def main(args: Array[String]) - Les programmes Scala commencent le traitement à partir de la méthode main(), qui est le point d'entrée obligatoire du programme pour chaque programme Scala.
Identificateurs
Scala peut utiliser deux formes d'identifiants : alphanumérique et symbolique.
Les identificateurs alphanumériques commencent par une lettre ou un trait de soulignement, et peuvent être suivis de lettres ou de chiffres. Le symbole "$" est également considéré comme une lettre en Scala. Toutefois, les identificateurs commençant par "$" sont réservés aux identificateurs générés par le compilateur Scala. Les applications devraient éviter d'utiliser des identificateurs commençant par "$" pour éviter les conflits.
Les règles de nommage de Scala adoptent les règles de casse camel similaires à Java, avec le premier caractère en minuscule, comme toString. Le premier caractère des noms de classes reste en majuscule. De plus, vous devriez également éviter d'utiliser des identificateurs se terminant par un trait de soulignement pour éviter les conflits. Les identificateurs symboliques contiennent un ou plusieurs symboles, tels que +, :, ?, etc., par exemple :
+ ++ ::: < ?> :->
Scala utilise des identificateurs échappés dans son implémentation interne. Par exemple, :-> est représenté par $colon$minus$greater. Par conséquent, si vous devez accéder à la méthode :-> dans du code Java, vous devez utiliser le nom interne de Scala $colon$minus$greater.
Les identificateurs mixtes se composent d'un identificateur alphanumérique suivi d'un ou plusieurs symboles. Par exemple, unary_+ est le nom que Scala utilise pour l'implémentation interne de la méthode +. Les identificateurs littéraux sont des chaînes définies à l'aide de backticks, telles que `x` et `yield`.
Vous pouvez utiliser n'importe quel identificateur Scala valide entre backticks, et Scala l'interprète comme un identificateur Scala. Un usage typique est la méthode yield de Thread. En Scala, vous ne pouvez pas utiliser Thread.yield() car yield est un mot-clé en Scala ; vous devez utiliser Thread.`yield`() pour utiliser cette méthode.
Mots-clés de Scala
Le tableau suivant répertorie les mots-clés réservés de Scala. Nous ne pouvons pas utiliser les mots-clés suivants comme variables :
| abstract | case | catch | classe |
| def | do | else | extends |
| false | final | finally | for |
| forSome | if | implicit | import |
| lazy | correspondance | nouveau | null |
| objet | override | package | private |
| protected | return | sealed | super |
| this | throw | trait | try |
| vrai | type | val | var |
| while | with | yield | |
| - | : | = | => |
| <- | <: | <% | >: |
| # | @ |
Commentaires en Scala
Scala, comme Java, prend en charge les commentaires sur une seule ligne et les commentaires multilignes. Les commentaires multilignes peuvent être imbriqués, mais doivent être correctement imbriqués ; un symbole de début de commentaire correspond à un symbole de fin. Les commentaires sont ignorés pendant la compilation Scala. Voici quelques exemples :
object HelloWorld {
/* 这是一个 Scala 程序
* 这是一行注释
* 这里演示了多行注释
*/
def main(args: Array[String]) {
// 输出 Hello World
// 这是一个单行注释
println("Hello, world!")
}
}
Lignes vides et espaces
Si une ligne ne contient que des espaces ou consiste en un commentaire, Scala la traite comme une ligne vide et l'ignore. Les jetons peuvent être séparés par des espaces ou des commentaires.
Sauts de ligne
Scala est un langage orienté ligne. Les instructions peuvent être terminées par un point-virgule (;) ou un saut de ligne. Dans les programmes Scala, le point-virgule à la fin d'une instruction est généralement facultatif. Vous pouvez en saisir un si vous le souhaitez, mais il peut être omis s'il n'y a qu'une seule instruction sur une ligne. En revanche, s'il y a plusieurs instructions sur une ligne, les points-virgules sont obligatoires. Par exemple
val s = "Example"; println(s)
Paquets Scala
Définition des paquets
Scala utilise le mot-clé package pour définir des paquets. En Scala, il existe deux façons de définir du code dans un paquet :
La première méthode est la même qu'en Java : définir le nom du paquet en haut du fichier. Avec cette méthode, tout le code suivant est placé dans ce paquet. Par exemple :
package com.example class HelloWorld
La deuxième méthode est quelque peu similaire à C#, par exemple :
package com.example {
class HelloWorld
}
Avec la deuxième méthode, vous pouvez définir plusieurs paquets dans un seul fichier.
Importations
Scala utilise le mot-clé import pour importer des paquets.
import java.awt.Color // 引入Color
import java.awt._ // 引入包内所有成员
def handler(evt: event.ActionEvent) { // java.awt.event.ActionEvent
... // 因为引入了java.awt,所以可以省去前面的部分
}
Les instructions d'importation peuvent apparaître n'importe où, pas seulement en haut d'un fichier. L'effet d'une importation s'étend du point où elle commence jusqu'à la fin du bloc englobant. Cela peut grandement réduire la possibilité de conflits de noms.
Si vous souhaitez importer plusieurs membres d’un package, vous pouvez utiliser un sélecteur :
import java.awt.{Color, Font}
// 重命名成员
import java.util.{HashMap => JavaHashMap}
// 隐藏成员
import java.util.{HashMap => _, _} // 引入了util包的所有成员,但是HashMap被隐藏了
Autres extensionsRemarque :Par défaut, Scala importe toujours java.lang._, scala._ et Predef._. Cela explique aussi pourquoi les packages commençant par scala peuvent omettre le préfixe scala. lorsqu’ils sont utilisés.