Types de données Scala Installation et configuration de l'environnement Scala

Grammaire de base Scala

Si vous êtes un programmeur Java avant tout et que vous connaissez les bases du langage Java, vous apprendrez rapidement 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 optionnel.

Nous pouvons considérer que le programme Scala est une collection d'objets, qui communiquent entre eux en appelant des méthodes. Passons à présent à la compréhension des concepts de classe, d'objet, de méthode et de variable d'exemple :

Objet - Les objets ont des propriétés et des comportements. Par exemple : les attributs de l'état d'un chien sont : couleur, nom, les comportements sont : aboyer, courir, manger, etc. L'objet est un exemple d'une classe.
Classe - La classe est une abstraction de l'objet, et l'objet est une exemple concret de la classe.
Méthode - La description de base d'une méthode, une classe peut contenir plusieurs méthodes.
Champ - Chaque objet a sa collection unique de variables d'exemple, c'est-à-dire des champs. Les propriétés de l'objet sont créées en assignant des valeurs aux champs.

Premier programme Scala

Programmation interactive

La programmation interactive n'a pas besoin de créer de fichier de script, et peut être appelée par la commande suivante :

$　scala
Bienvenue dans Scala version　2.11.7　(Java　HotSpot(TM)　64-Bit　Server　VM,　Java　1.8.0_31).
Tapez des expressions pour les évaluer.
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 le code en créant un fichier HelloWorld.scala, le code HelloWorld.scala est le suivant :

object HelloWorld {
　　　/*　Ceci est mon premier programme Scala
　　　　*　Le programme suivant affichera 'Hello　World!'　
　　　　*/
　　　def main(args: Array[String]) {
　　　　　　println("Hello, world!")　//　Affichage de "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 que le fichier HelloWorld.class a été généré dans le répertoire, ce fichier peut être exécuté sur le Java Virtual Machine (JVM).

Après compilation, nous pouvons utiliser la commande suivante pour exécuter le programme :

$　scala　HelloWorld
Hello,　world!

Exemple en ligne »

Grammaire de base

Il convient de noter les points suivants dans la grammaire de base de Scala :

Distinction entre les majuscules et les minuscules - 　Scala est sensible à la casse, ce qui signifie que Hello et hello ont des significations différentes en Scala.
Nom de classe -　La première lettre de tous les noms de classe doit être en majuscule.
Si plusieurs mots sont utilisés pour former le nom d'une classe, la première lettre de chaque mot doit être en majuscule.

Exemple :class MyFirstScalaClass
Nom de méthode - La première lettre de tous les noms de méthode doit être 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 du programme - Le nom du fichier du programme doit correspondre au nom de l'objet en tout point (ce n'est plus nécessaire dans les versions nouvelles, mais il est recommandé de conserver cette habitude).
Lors de l'enregistrement du fichier, il doit être enregistré sous le nom de l'objet utilisé (n'oubliez pas que Scala est sensible à la casse), et ajoutez ".scala" comme extension de fichier. (Si le nom du fichier et le nom de l'objet ne correspondent pas, le programme ne peut pas être compilé).

Exemple : Supposons que "HelloWorld" soit le nom de l'objet. Alors ce fichier devrait être enregistré sous 'HelloWorld.scala'
def main(args: Array[String]) -　Le programme Scala commence par la méthode main(), c'est la partie obligatoire d'entrée du programme pour chaque programme Scala.

Identificateur

Scala peut utiliser deux formes d'identificateurs, littéraux et symboliques.

Les caractères numériques commencent par une lettre ou un trait de soulignement, peuvent être suivis de lettres ou de chiffres, et le symbole "$" est considéré comme une lettre dans Scala. Cependant, les identificateurs commençant par "$" sont des identificateurs réservés générés par le compilateur Scala, les applications doivent éviter d'utiliser des identificateurs commençant par "$" pour éviter les conflits.

Les règles de nommage de Scala adoptent une règle de nommage camel similaire à Java, avec la première lettre en minuscule, par exemple toString. La première lettre du nom de la classe est toujours en majuscule. De plus, il est recommandé d'éviter les identificateurs se terminant par un trait de soulignement pour éviter les conflits. Les identificateurs symboliques contiennent un ou plusieurs symboles, comme+，:，? 等，par exemple:

+　++　:::　<　?>　:->

L'implémentation interne de Scala utilise des identificateurs échappés, par exemple:->Utilisez $colon$minus$greater pour représenter ce symbole. Par conséquent, si vous devez accéder dans le code Java:->La méthode, vous devez utiliser le nom interne de Scala $colon$minus$greater.

Un identificateur mixte est composé de caractères numériques suivis d'un ou plusieurs symboles, par exemple unary_+ Pour Scala+Le nom interne de l'implémentation de la méthode. Les identificateurs littéraux sont des chaînes définies par "", par exemple `x` `yield`.

Vous pouvez utiliser n'importe quel identificateur valable de Scala entre "", Scala les interprète comme un identificateur Scala. Une utilisation typique en est la méthode yield de Thread, dans Scala, vous ne pouvez pas utiliser Thread.yield() car yield est un mot-clé de Scala, vous devez utiliser Thread.`yield`() pour utiliser cette méthode.

Mots-clés Scala

Le tableau suivant liste les mots-clés réservés Scala, nous ne pouvons pas utiliser les mots-clés suivants en tant que variables :

abstract	case	catch	class
def	do	else	extends
false	final	finally	for
forSome	if	implicit	import
lazy	match	new	null
object	override	package	private
protected	return	sealed	super
this	throw	trait	try
true	type	val	var
while	with	yield
-	:	=	=>
<-	<:	<%	>:
#	@

Commentaires Scala

Scala, comme Java, supporte les commentaires en une ligne et sur plusieurs lignes. Les commentaires sur plusieurs lignes peuvent être imbriqués, mais doivent être correctement imbriqués, avec un début de commentaire correspondant à un fin de commentaire. Les commentaires sont ignorés pendant la compilation Scala, comme dans les exemples suivants :

object HelloWorld {
　　　/*　C'est un programme Scala
　　　　*　C'est un commentaire en une ligne
　　　　*　Voici un exemple de commentaires sur plusieurs lignes
　　　　*/
　　　def main(args: Array[String]) {
　　　　　　//　Affichage de "Hello World"
　　　　　　//　C'est un commentaire en une ligne
　　　　　　println("Hello, world!")　
　　　}
}

Lignes vides et espaces

Si une ligne ne contient que des espaces ou des commentaires, Scala le considère comme une ligne vide et l'ignore. Les commentaires peuvent être séparés par des espaces ou des commentaires.

Retour à la ligne

Scala est une langue orientée lignes, où les instructions peuvent être terminées par un point-virgule (;) ou un retour à la ligne. Dans un programme Scala, un point-virgule à la fin de l'instruction est généralement optionnel. Vous pouvez en entrer un, mais si une seule instruction est sur une ligne, Il existe également une instruction qui peut être omise. D'un autre côté, si plusieurs instructions sont écrites sur une seule ligne, un point-virgule est nécessaire. Par exemple :

val s = "基础教程网"; println(s)

Paquet Scala

Définir un paquet

Scala utilise la clé de package pour définir un paquet, et il existe deux manières de définir un code dans un paquet en Scala :

La première méthode est semblable à Java, où le nom du paquet est défini en tête du fichier. Cette méthode place tous les codes suivants dans ce paquet. Par exemple :

package com.w3codebox
class HelloWorld

La deuxième méthode est quelque peu similaire à C# :

package com.w3codebox {
　　class HelloWorld　
}

La deuxième méthode consiste à définir plusieurs paquets dans un même fichier.

Référence

Scala utilise la clause import pour référencer les paquets.

Introduction de java.awt.Color　　//　Introduction de Color
　
import java.awt._　　//　Introduction de tous les membres du paquet
　
def handler(evt: event.ActionEvent) {　//　java.awt.event.ActionEvent
　　...　　//　Parce que java.awt a été introduit, on peut omettre la partie précédente
}

Les instructions import peuvent apparaître n'importe où et pas seulement en haut du fichier. L'effet de l'instruction import s'étend du début à la fin du bloc de statements. Cela peut considérablement réduire la probabilité de conflits de noms.

Si vous souhaitez introduire plusieurs membres d'un paquet, vous pouvez utiliser un sélecteur (sélecteur) :

import java.awt.{Color, Font}
　
//　Renommage de membre
import java.util.{HashMap => JavaHashMap}
　
//　Membre caché
import java.util.{HashMap => _, _}　//　Tous les membres du paquet util ont été introduits, mais HashMap a été caché

Attention :Par défaut, Scala introduit toujours java.lang._, scala._ et Predef._, c'est pourquoi les paquets commençant par scala. sont généralement utilisés sans scala..