[TOUR OF Scala] 2-Grundlagen – TOUR OF SCALA

Auf dieser Seite stellen wir die Grundlagen von Scala vor.

Probieren Sie Scala im Browser aus

Sie können Scala in ScalaFiddle im Browser ausführen.

1. Öffnen Sie https://scalafiddle.io

2. Einfügen println("Hello, world!")

3. im linken Bereich

   Klicken Sie auf die Schaltfläche „Ausführen“. Die Ausgabe wird im rechten Bereich angezeigt.

Dies ist eine einfache und einrichtungsfreie Möglichkeit, Scala-Codefragmente zu testen.

Ausdruck

Ausdrücke sind berechenbare Aussagen.

1 + 1

Mit println können Sie das Ergebnis eines Ausdrucks ausgeben.

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

Wert

Sie können das Schlüsselwort val verwenden, um das Ergebnis eines Ausdrucks zu benennen. Das Ergebnis eines

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

-Namens, wie hier x, wird als Wert bezeichnet. Durch die Referenzierung eines Werts wird dieser nicht neu berechnet.

Werte können nicht neu zugewiesen werden.

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

Der Compiler kann auf den Typ des Werts schließen, aber Sie können den Typ auch explizit wie folgt deklarieren:

val x: Int = 1 + 1

Beachten Sie, dass die Typdeklaration Int in ist Bezeichner x, und dazwischen muss ein : hinzugefügt werden.

Variablen

Variablen sind wie Werte, aber Sie können sie neu zuweisen. Sie können eine Variable mit dem Schlüsselwort var definieren.

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

Wie bei Werten können Sie Typen explizit deklarieren:

var x: Int = 1 + 1

Codeblöcke

Sie können umgebende Ausdrücke kombinieren. Wir nennen diesen Codeblock. Das Ergebnis des letzten Ausdrucks des

-Blocks ist auch das Ergebnis des gesamten Blocks.

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

Funktion

Eine Funktion ist ein Ausdruck mit Parametern.

Sie können eine anonyme Funktion (d. h. ohne Namen) definieren, die eine bestimmte Ganzzahl + 1 zurückgibt:

(x: Int) => x + 1

Auf der linken Seite des Startsymbols => befindet sich eine Parameterliste . Auf der rechten Seite befindet sich ein Ausdruck, der Parameter enthält.

Sie können Funktionen auch benennen.

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

Funktion kann mehrere Parameter annehmen.

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

Oder es werden keine Parameter benötigt.

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

Methoden

Methoden sehen Funktionen sehr ähnlich, es gibt jedoch einige wesentliche Unterschiede zwischen ihnen. Die Methode

wird mit dem Schlüsselwort def definiert. Auf def folgen der Methodenname, die Parameterliste, ein Rückgabetyp und ein Textkörper.

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

Beachten Sie, dass der Rückgabetyp nach der Parameterliste und dem Doppelpunkt : Int deklariert wird.

Methoden können mehrere Parameterlisten annehmen.

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

Oder überhaupt keine Parameterliste.

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

Es gibt noch einige andere Unterschiede, aber im Moment können Sie sie sich als etwas Ähnliches wie Funktionen vorstellen.

Methoden können auch mehrzeilige Ausdrücke haben. Der letzte Ausdruck von

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

body ist der Rückgabewert der Methode. (Scala hat ein Rückgabeschlüsselwort return, das jedoch selten verwendet wird.)

Klasse

Sie können eine Klasse mit dem Klassenschlüsselwort class definieren und dann ihren Namen und ihre Konstruktorfunktion verwenden Parameter. Der Rückgabetyp der

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

-Methode greet ist Unit, was bedeutet, dass die Rückgabe keine Bedeutung hat. Es ähnelt dem Schlüsselwort void in Java und C (der Unterschied besteht darin, dass jeder Scala-Ausdruck einen bestimmten Wert haben muss, es tatsächlich einen Singleton-Wert vom Typ Unit gibt, geschrieben als (). Er enthält keine Informationen )

Sie können das Schlüsselwort new verwenden, um eine Instanz einer Klasse zu erstellen.

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

Wir werden die Kurse später im Detail vorstellen.

Beispielklasse

Scala verfügt über einen speziellen Klassentyp, der als „Beispielklasse“ bezeichnet wird. Standardmäßig sind Beispielklassen unveränderlich und werden nach Wert verglichen.

Sie können Beispielklassen mit dem Schlüsselwort case class definieren.

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

Sie können Beispielklassen instanziieren, ohne das Schlüsselwort new zu verwenden.

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

Sie werden nach Wert verglichen.

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.

Es gibt noch viele weitere Beispielkurse, die wir vorstellen möchten. Wir glauben, dass Sie sich in sie verlieben werden! Wir werden sie später im Detail vorstellen.

Objekte

Objekte sind einzelne Instanzen ihrer eigenen Definition. Sie können sie sich als Singletons ihrer eigenen Klasse vorstellen.

Sie können Objekte definieren, indem Sie das Schlüsselwort object verwenden.

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

Sie können auf ein Objekt zugreifen, indem Sie auf seinen Namen verweisen.

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

Wir werden die Objekte später im Detail behandeln.

Eigenschaften

Eigenschaften sind Typen, die bestimmte Felder und Methoden enthalten. Mehrere Funktionen können miteinander kombiniert werden.

Sie können Merkmale definieren, indem Sie das Schlüsselwort trait verwenden.

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

Funktionen können auch Standardimplementierungen haben.

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

Sie können Funktionen mit dem Schlüsselwort extends erweitern und Implementierungen mit dem Schlüsselwort override überschreiben.

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?

Hier erweitert DefaultGreeter nur ein einzelnes Merkmal, es können jedoch mehrere Merkmale erweitert werden.

Wir werden die Merkmale später im Detail vorstellen.

Hauptmethode

Die Hauptmethode ist der Einstiegspunkt eines Programms. Die Java Virtual Machine erfordert eine Hauptmethode namens main und akzeptiert einen Parameter, ein Array von Zeichenfolgen.

Mithilfe von Objekten können Sie eine Hauptmethode wie folgt definieren:

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

                                                

Das obige ist der detaillierte Inhalt von[TOUR OF Scala] 2-Grundlagen – TOUR OF SCALA. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!