Syntaxe de base Scala

Si vous êtes auparavant un programmeur Java et connaissez 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 de l'instruction Scala est facultatif.

Nous pouvons considérer un programme Scala comme une collection d'objets qui implémentent la transmission de messages en s'appelant mutuellement. Ensuite, comprenons les concepts de classes, d'objets, de méthodes et de variables d'instance :

Object - Les objets ont des attributs et des comportements. Par exemple : les attributs d'un chien incluent : la couleur, le nom et les comportements incluent : aboyer, courir, manger, etc. Un objet est une instance d'une classe.
Classe - Une classe est une abstraction d'un objet, et un objet est une instance concrète d'une classe.
Méthode - La méthode décrit le comportement de base. Une classe peut contenir plusieurs méthodes.
Champs - Chaque objet a son ensemble unique de variables d'instance, qui sont des champs. Les propriétés des objets sont créées en attribuant des valeurs aux champs.

Le premier programme Scala

Programmation interactive

La programmation interactive ne nécessite pas la création de fichiers de script et peut être appelée avec ce qui suit commande :

$ 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>

Formulaire de script

On peut également exécuter le code en créant un fichier HelloWorld.scala Le code HelloWorld.scala est le suivant :

object HelloWorld {
   /* 这是我的第一个 Scala 程序
    * 以下程序将输出'Hello World!' 
    */
   def main(args: Array[String]) {
      println("Hello, world!") // 输出 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 est généré dans le répertoire, qui peut être exécuté sur la machine virtuelle Java (JVM).

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

$ scala HelloWorld
Hello, world!

Exemple en ligne»

Syntaxe de base

Syntaxe de base Scala a besoin d'attention Les 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 plusieurs mots sont nécessaires 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 de la méthode main(), qui est la partie d'entrée de programme obligatoire de chaque programme Scala.

Identifiants

Scala peut utiliser deux formes d'identifiants, alphanumériques et symboliques.

Les numéros de caractères commencent par des lettres ou des traits de soulignement et peuvent être suivis de lettres ou de chiffres. Le symbole « $ » est également considéré comme une lettre en Scala. Cependant, les identifiants commençant par « $ » sont réservés à une utilisation avec les identifiants générés par le compilateur Scala, et les applications doivent éviter d'utiliser des identifiants commençant par « $ » pour éviter les conflits.

Les règles de dénomination de Scala adoptent des règles de dénomination de type chameau similaires à celles de Java, avec le premier caractère minuscule, tel que toString. Le premier caractère du nom de classe est toujours en majuscule. Évitez également d'utiliser des identifiants se terminant par un trait de soulignement pour éviter les conflits. Les identifiants de symboles contiennent un ou plusieurs symboles, tels que +, :, ?, etc., tels que :

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

Scala utilisera des identifiants avec échappement dans l'implémentation interne, tels que : -> Utilisez $colon$minus$. plus grand pour représenter ce symbole. Donc, si vous devez accéder à la méthode :-> dans le code Java, vous devez utiliser le nom interne de Scala $colon$minus$greater.

Un identifiant mixte consiste en un identifiant alphanumérique suivi d'un ou plusieurs symboles, tels que unary_+ qui est le nom de l'implémentation interne de Scala de la méthode +. Les identifiants littéraux sont des chaînes définies à l'aide de ", telles que `x` `yield`.

Vous pouvez utiliser n'importe quel identifiant Scala valide entre ", et Scala les interprétera comme un identifiant Scala. Une utilisation typique est la méthode de rendement de Thread. Vous ne pouvez pas utiliser Thread.yield() dans Scala car rendement est un mot-clé dans Scala. Vous devez utiliser Thread.`yield`() pour utiliser cette méthode.

Mots-clés Scala

Le tableau suivant répertorie les mots-clés réservés Scala, nous ne pouvons pas utiliser les mots-clés suivants comme 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 est similaire à Java et prend en charge les commentaires sur une seule et plusieurs lignes. Les commentaires multilignes peuvent être imbriqués, mais ils doivent être correctement imbriqués. Un symbole de début de commentaire correspond à un symbole de fin. Les commentaires seront ignorés lors de la compilation Scala. Les exemples sont les suivants :

object HelloWorld {
   /* 这是一个 Scala 程序
    * 这是一行注释
    * 这里演示了多行注释
    */
   def main(args: Array[String]) {
      // 输出 Hello World
      // 这是一个单行注释
      println("Hello, world!") 
   }
}

Lignes et espaces vides

Si une ligne ne contient que des espaces ou des commentaires, Scala la considérera comme vide. ligne et l’ignorera. Les balises peuvent être séparées par des espaces ou des commentaires.

Newline

Scala est un langage orienté ligne, les instructions peuvent être terminées par un point-virgule (;) ou une nouvelle 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 s'il n'y a que Il n'est pas nécessaire d'écrire une déclaration. D'un autre côté, si vous écrivez plusieurs instructions sur une seule ligne, des points-virgules sont requis. Par exemple,

val s = "php中文网"; println(s)

Scala package

define package

Scala utilise le mot-clé package pour définir un package. Il existe deux façons de définir du code dans un package dans. Scala :

La première méthode est la même que Java, définissant le nom du package dans l'en-tête du fichier. Dans cette méthode, tout le code suivant sera placé dans le package. Par exemple :

package com.php
class HelloWorld

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

package com.php {
  class HelloWorld 
}

La deuxième méthode peut définir plusieurs packages dans un seul fichier.

Référence

Scala utilise le mot-clé import pour référencer les packages.

import java.awt.Color  // 引入Color
 
import java.awt._  // 引入包内所有成员
 
def handler(evt: event.ActionEvent) { // java.awt.event.ActionEvent
  ...  // 因为引入了java.awt，所以可以省去前面的部分
}

Les déclarations d'importation peuvent apparaître n'importe où, pas seulement en haut du fichier. L'effet de l'importation s'étend du début à la fin du bloc d'instructions. Cela réduit considérablement la possibilité de conflits de noms.

Si vous souhaitez présenter plusieurs membres du package, vous pouvez utiliser le sélecteur :

import java.awt.{Color, Font}
 
// 重命名成员
import java.util.{HashMap => JavaHashMap}
 
// 隐藏成员
import java.util.{HashMap => _, _} // 引入了util包的所有成员，但是HashMap被隐藏了

Remarque : Par défaut, Scala présentera toujours Java. lang._, scala._ et Predef._, cela peut également expliquer pourquoi les packages commençant par scala omettent scala lors de leur utilisation.