[VISITE DE SCALA] 2-Bases - VISITE DE SCALA

Dans cette page, nous présenterons les bases de Scala.

Essayez Scala dans le navigateur

Vous pouvez exécuter Scala dans ScalaFiddle dans le navigateur.

1. Ouvrez https://scalafiddle.io

2. Collez println("Hello, world!")

3. dans le volet de gauche

   Cliquez sur le bouton "Exécuter". La sortie est affichée dans le volet de droite.

Il s'agit d'un moyen simple et sans configuration de tester des extraits de code Scala.

Expression

Les expressions sont des déclarations calculables.

1 + 1

Vous pouvez utiliser println pour afficher le résultat d'une expression.

println(1) // 1
println(1 + 1) // 2
println("Hello!") // Hello!
println("Hello," + " world!") // Hello, world!

Valeur

Vous pouvez utiliser le mot-clé val pour nommer le résultat d'une expression. Le résultat d'un nom

val x = 1 + 1println(x) // 2

, comme x ici, s'appelle une valeur. Faire référence à une valeur ne la recalcule pas.

Les valeurs ne peuvent pas être réaffectées.

val x = 1 + 1x = 3 // This does not compile.

Le compilateur peut déduire le type de la valeur, mais vous pouvez également déclarer le type explicitement, comme suit :

val x: Int = 1 + 1

Notez que la déclaration de type Int est dans identifiant x, et un : doit être ajouté entre eux.

Variables

Les variables sont comme des valeurs, mais vous pouvez les réaffecter. Vous pouvez définir une variable à l'aide du mot-clé var.

var x = 1 + 1x = 3 // This compiles because "x" is declared with the "var" keyword.
println(x * x) // 9

Comme pour les valeurs, vous pouvez déclarer explicitement des types :

var x: Int = 1 + 1

Blocs de code

Vous pouvez combiner des expressions environnantes. Nous appelons ce bloc de code. Le résultat de la dernière expression du bloc

est également le résultat du bloc entier.

println({
  val x = 1 + 1
  x + 1
}) // 3

Fonction

Une fonction est une expression avec des paramètres.

Vous pouvez définir une fonction anonyme (c'est-à-dire sans nom) qui renvoie un entier donné + 1 :

(x: Int) => x + 1

Sur le côté gauche du symbole de lancement => se trouve une liste de paramètres . À droite se trouve une expression contenant des paramètres.

Vous pouvez également nommer des fonctions.

val addOne = (x: Int) => x + 1
println(addOne(1)) // 2

La fonction peut prendre plusieurs paramètres.

val add = (x: Int, y: Int) => x + y
println(add(1, 2)) // 3

Ou alors, cela ne prend aucun paramètre.

val getTheAnswer = () => 42
println(getTheAnswer()) // 42

Méthodes

Les méthodes ressemblent beaucoup aux fonctions, mais il existe quelques différences clés entre elles. La méthode

est définie à l'aide du mot-clé def. def est suivi du nom de la méthode, de la liste des paramètres, d'un type de retour et d'un corps.

def add(x: Int, y: Int): Int = x + y
println(add(1, 2)) // 3

Notez que le type de retour est déclaré après la liste des paramètres et les deux points : Int.

Les méthodes peuvent prendre plusieurs listes de paramètres.

def addThenMultiply(x: Int, y: Int)(multiplier: Int): Int = (x + y) * multiplier
println(addThenMultiply(1, 2)(3)) // 9

Ou pas de liste de paramètres du tout.

def name: String = System.getProperty("name")
println("Hello, " + name + "!")

Il existe d'autres différences, mais pour l'instant, vous pouvez les considérer comme quelque chose de similaire aux fonctions.

Les méthodes peuvent également avoir des expressions multilignes. La dernière expression de

def getSquareString(input: Double): String = {
  val square = input * input
  square.toString
}

body est la valeur de retour de la méthode. (Scala a un mot-clé de retour return, mais il est rarement utilisé.)

Classe

Vous pouvez définir une classe en utilisant le mot-clé de classe class puis utiliser son nom et sa fonction constructeur paramètres. Le type de retour de la méthode

class Greeter(prefix: String, suffix: String) {
  def greet(name: String): Unit =
    println(prefix + name + suffix)
}

greet est Unit, ce qui signifie que le retour n'a aucune signification. Il est similaire au mot-clé void en Java et C (la différence est que, comme chaque expression Scala doit avoir une certaine valeur, il existe en fait une valeur singleton de type Unit, écrite sous la forme (). Elle ne contient aucune information. )

Vous pouvez utiliser le mot-clé new pour créer une instance d'une classe.

val greeter = new Greeter("Hello, ", "!")
greeter.greet("Scala developer") // Hello, Scala developer!

Nous présenterons les cours en détail plus tard.

Classe d'exemple

Scala a un type spécial de classe appelé classe "exemple". Par défaut, les exemples de classes sont immuables et se comparent par valeur.

Vous pouvez définir des exemples de classes à l'aide du mot-clé case class.

case class Point(x: Int, y: Int)

Vous pouvez instancier des exemples de classes sans utiliser le mot-clé new.

val point = Point(1, 2)
val anotherPoint = Point(1, 2)
val yetAnotherPoint = Point(2, 2)

Ils sont comparés par valeur.

if (point == anotherPoint) {
  println(point + " and " + anotherPoint + " are the same.")
} else {
  println(point + " and " + anotherPoint + " are different.")
}
// Point(1,2) and Point(1,2) are the same.
if (point == yetAnotherPoint) {
  println(point + " and " + yetAnotherPoint + " are the same.")
} else { 
  println(point + " and " + yetAnotherPoint + " are different.")
}
// Point(1,2) and Point(2,2) are different.

Il y a de nombreux autres exemples de cours que nous souhaitons vous présenter, nous pensons que vous en tomberez amoureux ! Nous les présenterons en détail ultérieurement.

Objets

Les objets sont des instances uniques de leur propre définition. Vous pouvez les considérer comme des célibataires de leur propre classe.

Vous pouvez définir des objets en utilisant le mot-clé object.

object IdFactory {  
  private var counter = 0 
  def create(): Int = { 
    counter += 1    
    counter
  }
}

Vous pouvez accéder à un objet en référençant son nom.

val newId: Int = IdFactory.create()
println(newId) // 1
val newerId: Int = IdFactory.create()
println(newerId) // 2

Nous aborderons les objets en détail plus tard.

Traits

Les traits sont des types qui contiennent certains champs et méthodes. Plusieurs fonctionnalités peuvent être combinées ensemble.

Vous pouvez définir des traits en utilisant le mot-clé trait.

trait Greeter { 
  def greet(name: String): Unit
}

Les fonctionnalités peuvent également avoir des implémentations par défaut.

trait Greeter {
  def greet(name: String): Unit = 
    println("Hello, " + name + "!")
}

Vous pouvez étendre les fonctionnalités à l'aide du mot-clé extends et remplacer les implémentations à l'aide du mot-clé override.

class DefaultGreeter extends Greeter
class CustomizableGreeter(prefix: String, postfix: String) extends Greeter { 
  override def greet(name: String): Unit = {    
    println(prefix + name + postfix)
  }
}
val greeter = new DefaultGreeter()
greeter.greet("Scala developer") // Hello, Scala developer!
val customGreeter = new CustomizableGreeter("How are you, ", "?")
customGreeter.greet("Scala developer") // How are you, Scala developer?

Ici, DefaultGreeter n'étend qu'un seul trait, mais il peut étendre plusieurs traits.

Nous présenterons les traits en détail plus tard.

Méthode principale

La méthode principale est le point d'entrée d'un programme. La machine virtuelle Java nécessite une méthode principale nommée main et accepte un paramètre, un tableau de chaînes.

À l'aide d'objets, vous pouvez définir une méthode principale comme suit :

object Main {  
  def main(args: Array[String]): Unit = 
    println("Hello, Scala developer!")
}

                                                

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!