Scala-Tutorial

Was ist Scala?

Scala Scala ist eine statisch typisierte Programmiersprache, die objektorientierte und funktionale Programmierung kombiniert, um die Skalierbarkeit von Anwendungen zu verbessern. Scala läuft primär auf der JVM-Plattform. Entwickler können Scala aber auch verwenden, um Software für native Plattformen mit Scala-Native oder für den Browser mit ScalaJS zu entwickeln. JavaSkript Laufzeit.

Scala ist eine skalierbare Sprache, die zur Entwicklung von Software für verschiedene Plattformen verwendet wird – daher auch ihr Name. Die Sprache wurde entwickelt, um einige der Probleme mit der Ausführlichkeit von Code zu lösen, die in anderen Sprachen auftreten. Java und dabei prägnant zu bleiben. Martin Odersky entwarf Scala, und die erste öffentliche Version erschien 2004.

Warum Scala lernen?

Hier sind die wichtigsten Gründe, warum man die Programmiersprache Scala lernen sollte:

• Scala ist für objektorientierte Programmierer leicht zu erlernen und Java Entwickler, und es hat sich in den letzten Jahren zu einer der beliebtesten Programmiersprachen entwickelt.
• Scala bietet erstklassige Funktionen für Benutzer.
• Scala kann auf dem JVMund ebnet so den Weg für die Interoperabilität mit anderen Sprachen.
• Sie ist für Anwendungen konzipiert, die nebenläufig, verteilt und robust nachrichtenorientiert sind, was sie zu einer der gefragtesten Sprachen dieses Jahrzehnts macht.
• Es handelt sich um eine prägnante, ausdrucksstarke Sprache, die sich schnell an die Bedürfnisse ihrer Nutzer anpassen kann.
• Es ist objektorientiert und beinhaltet viele funktionale Programmiermerkmale, was den Entwicklern viel Flexibilität beim Schreiben des Codes bietet.
• Scala bietet Duck Ty anping durch Strukturtypen.
• Es enthält weniger Standardtext als Java.
• Die in Scala geschriebenen Frameworks Lift und Play reifen stetig weiter und erfreuen sich wachsender Beliebtheit.

So installieren Sie Scala

Um mit dem Schreiben von Scala-Programmen zu beginnen, muss Scala auf Ihrem Computer installiert sein. Besuchen Sie dazu die offizielle Website unter [Website-Adresse einfügen]. https://www.scala-lang.org/download/ Um die neueste Version von Scala herunterzuladen.

Über den Link gelangen Sie zu zwei Installationsoptionen für Scala. In diesem Scala-Tutorial verwenden wir die IntelliJ IDEA, das von Haus aus hervorragende Scala-Unterstützung bietet.

Nach dem Aufrufen des Download-Links finden Sie dort zwei Editionen der IntelliJ IDE.

Für dieses Scala-Tutorial laden wir die Community Edition herunter, die kostenlos ist und alles enthält, was Sie zum Schreiben von Scala-Programmen benötigen.

Schritt 1) Wählen Sie die Community Edition.
Klicken Sie auf der Seite auf das Dropdown-Menü „Community Edition“.

Es bietet die Möglichkeit, die IntelliJ IDE zusammen mit JBR herunterzuladen, welches eine JDK-Implementierung enthält (Java Entwicklungskits) wie beispielsweise OpenJDK, die Scala zum Kompilieren und Ausführen von Code benötigt.

Schritt 2) Führen Sie die Installation durch.
Sobald Sie IntelliJ heruntergeladen haben, doppelklicken Sie auf die Installationsdatei und folgen Sie dem Installationsassistenten auf dem Bildschirm.

Schritt 3) Wählen Sie einen Standort.
Wählen Sie einen Speicherort für die Installation der IDE.

Falls Sie das Bundle nicht zusammen mit dem JDK heruntergeladen haben, werden Sie vom Installationsprogramm während der Einrichtung dennoch aufgefordert, das JDK über ein Kontrollkästchen hinzuzufügen.

Schritt 4) Weiter klicken.
Belassen Sie die übrigen Standardeinstellungen und klicken Sie auf Weiter.

Scala Hello World-Programm

Schritt 5) Klicken Sie auf das Startsymbol.
Sobald die Installation abgeschlossen ist, starten Sie die IntelliJ IDE, indem Sie wie bei einer normalen Anwendung auf das entsprechende Symbol im Startmenü klicken.

Sie müssen das Scala-Plugin noch zu IntelliJ hinzufügen. Klicken Sie dazu auf das Dropdown-Menü im Konfigurationsmenü unten rechts auf dem Bildschirm und wählen Sie die Option „Plugins“.

Suchen Sie auf der Registerkarte „Marketplace“ nach Scala. Das Plugin erscheint als erstes Ergebnis unter dem Tag „Sprachen“.

Schritt 6) Installieren Sie das Plugin.
Klicken Sie auf „Installieren“, um den Download des Scala-Plugins zu starten.

Schritt 7) Starten Sie die IDE neu.
Nach Abschluss des Downloads werden Sie aufgefordert, die IDE neu zu starten, damit das installierte Plugin funktionsbereit ist.

Nach dem Neustart gelangen Sie wieder auf dieselbe Seite wie zuvor, aber jetzt ist das Scala-Plugin installiert und einsatzbereit.

Schritt 8) Wählen Sie „Projekt erstellen“. Daraufhin gelangen Sie zu einer Seite, auf der Sie die Sprache für das Projekt auswählen können.

Schritt 9) Wählen Sie Scala aus, indem Sie das Kontrollkästchen „Scala“ aktivieren und auf „Weiter“ klicken.

Schritt 10) Wählen Sie einen Speicherort für die Projektdatei und geben Sie dem Projekt einen Namen.

Falls das Verzeichnis nicht existiert, fragt IntelliJ nach der Berechtigung zum Erstellen des Ordners. Bestätigen Sie die Anfrage und klicken Sie auf „Fertigstellen“. Anschließend gelangen Sie zu Ihrem Scala-Projekt, das derzeit noch keinen Scala-Code enthält.

Das Laden der Indizes kann einige Zeit dauern. Machen Sie sich daher keine Sorgen, wenn Sie während der Anzeige des Fortschrittsbalkens am unteren Rand nicht mit der IDE interagieren können. Die IDE lädt die für die Ausführung von Scala und die Autovervollständigung erforderlichen Dateien.

Schritt 11) Klicken Sie auf der linken Seite der IDE auf die Registerkarte „Projekt“ und erweitern Sie diese, um den Inhalt des Projekts anzuzeigen.

Das Projekt ist zu diesem Zeitpunkt leer und enthält lediglich einen .idea-Ordner und eine vom IDE generierte hello-world.iml-Datei. Von Interesse ist der src-Ordner, der den Quellcode des Projekts enthält. Hier erstellen Sie Ihre erste Scala-Datei.

Schritt 12) Klicken Sie mit der rechten Maustaste auf src, um ein Menü zu öffnen und eine neue Scala-Datei zu erstellen.

Wählen Sie einen Namen für die Datei. Verwenden Sie für dieses Scala-Tutorial HALLOWählen Sie anschließend im Dropdown-Menü für den Inhaltstyp der Scala-Datei die Option „Objekt“ aus.

Sobald Sie dies getan haben, verfügen Sie über eine Scala-Datei, die ein Singleton-Objekt enthält, mit dem Sie den Code ausführen können.

Nachdem Sie nun eine Scala-Datei mit einem Hello-Objekt haben, schreiben Sie Ihr erstes Programm, indem Sie das erstellte Objekt mit dem Schlüsselwort App erweitern.

Durch die Erweiterung des Objekts mit `App` wird dem Compiler mitgeteilt, welcher Code beim Programmstart ausgeführt werden soll. Unmittelbar nach der Erweiterung von `App` erscheint links ein grüner Pfeil, der anzeigt, dass das Programm nun ausführbar ist.

Schreiben Sie innerhalb des Hello-Objekts die Funktion println(), um den Text auf der Konsole auszugeben. Starten Sie das Programm durch Klicken auf den grünen Pfeil.

Durch Klicken auf den Pfeil wird die Option „Hello ausführen“ angezeigt. Durch Auswahl dieser Option wird der Code kompiliert, und nach einigen Sekunden erscheint die Programmausgabe in der IntelliJ-Konsole.

Sie haben Scala nun erfolgreich installiert und können Ihr erstes Programm ausführen.

Was Sie mit Scala machen können

Scala ist aufgrund seiner Flexibilität und JVM-Interoperabilität in vielen Bereichen weit verbreitet. Typische Anwendungsfälle sind:

• Frontend-Webentwicklung mit ScalaJS.
• Mobile-Entwicklung für Android und iOS mit Scala Native.
• Serverseitige Bibliotheken wie HTTP4S, Akka-Http und das Play Framework.
• Anwendungen des Internets der Dinge (IoT).
• Spieleentwicklung.
• Verarbeitung natürlicher Sprache mithilfe der ScalaNLP-Bibliothekssuite.
• Fortgeschrittene Techniken wie funktionale Programmierung und objektorientierte Programmierung gemeinsam üben.
• Hochgradig parallele Kommunikationsanwendungen mit Aktoren, eine von Erlang inspirierte Bibliothek für die JVM.
• Maschinelles Lernen mit Bibliotheken wie Figaro für probabilistische Programmierung und Apache Spark für die Verarbeitung großer Datenmengen.

Anonyme Funktionen

Die Programmiersprache Scala unterstützt anonyme Funktionen, auch anonyme Funktionen genannt. FunktionsliteraleDa Scala eine funktionale Sprache ist, zerlegen Entwickler große Probleme oft in viele kleine Aufgaben und erstellen viele Funktionen. Um dies zu vereinfachen, ermöglicht Scala die Verwendung von Funktionen. ohne Namen instanziiertSie können sie direkt Variablen oder Definitionen zuweisen, indem Sie def, wie das folgende Scala-Beispiel zeigt:

val multiplyByTwo = (n:Int) => n * 2
def multiplyByThree = (n:Int) => n * 3

Sie können sie dann wie reguläre Funktionen verwenden, indem Sie Parameter übergeben:

multiplyByTwo(3)
//6

multiplyByThree(4)
//12

Diese Methoden sind praktisch, wenn man sauberen und prägnanten Code schreiben möchte. Anonyme Funktionen eignen sich gut, um kurze Methoden zu definieren, die wenig Code im Funktionskörper benötigen. Sie sind sehr einfach und lassen sich unkompliziert erstellen.

Diese Methoden sind nicht auf Funktionen mit Argumenten beschränkt und können auch zur Instanziierung von Methoden verwendet werden, die keine Argumente benötigen.

val sayHello = () => { println("hello") }

Die meisten dieser anonymen Funktionen werden in anderen Teilen des Codes verwendet, wo man schnell eine passende Funktion benötigt. Aus diesem Grund werden sie auch als anonyme Funktionen bezeichnet. Inline-FunktionenDie Verwendung anonymer Funktionen ist ein gängiges Muster, das in der gesamten Collections-Bibliothek vorkommt, um schnelle Aktionen auf einer Collection durchzuführen.

Die Filtermethode verwendet beispielsweise eine Inline-Funktion, um eine weitere Sammlung zu erstellen, die nur die Elemente enthält, die den in der anonymen Funktion definierten Kriterien entsprechen.

val myList = List(1,2,3,4,5,6,7)

val myEvenList = myList.filter((n: Int) => n % 2 == 0)
//List(2,4,6)

val myOddList = myList.filter((n:Int) => n % 2 != 0)
//List(1,3,5,7)

Hier prüfen die anonymen Funktionen, ob der Wert aus der Liste gerade oder ungerade ist, und geben das entsprechende Element zurück.

//the one checking that the value is even
(n: Int) => n % 2 == 0

//the one checking that the value is odd
(n:Int) => n % 2 != 0

In Scala ist es auch möglich, Wildcards zu verwenden, wenn der anonyme Funktionsparameter keinen Namen hat. Zum Beispiel:

var timesTwo = (_:Int) * 2

timesTwo(5)
//10

In diesem Fall wird der Parameter nicht benannt. Er wird durch einen Unterstrich dargestellt.

Faule Bewertung

Die meisten Sprachen werten Variablen und Funktionsparameter nacheinander aus. In Scala ist das Schlüsselwort lazy Hilft dabei, mit Werten umzugehen, die man erst dann bewerten möchte, wenn sie explizit erwähnt werden.

Eine als „lazy“ gekennzeichnete Variable wird nicht bei ihrer Definition ausgewertet; dies wird gemeinhin als „eager Evaluation“ bezeichnet. Sie wird erst ausgewertet, wenn später im Code auf sie zugegriffen wird.

Dies kann hilfreich sein, wenn die Auswertung eines Wertes eine aufwändige Berechnung erfordern würde. Wird der Wert nicht immer benötigt, erspart man sich eine rechenintensive und die Software verlangsamende Berechnung, indem man die Variable verzögert auswertet.

lazy val myExpensiveValue = expensiveComputation

def runMethod() = {
    if(settings == true) {
        use(myExpensiveValue)
    } else {
        use(otherValue)
    }
}

Dies ist nicht der einzige Anwendungsfall für Lazy Variables. Sie helfen auch beim Umgang mit zirkulären Abhängigkeiten im Code.

Wenn die entsprechende Einstellung deaktiviert ist, benötigen Sie „myExpensiveValue“ nicht, wodurch eine aufwändige Berechnung vermieden wird. Dies trägt zu einer reibungslosen Benutzererfahrung bei, da keine Ressourcen für Werte verschwendet werden, die nie verwendet werden.

Faulheit hilft auch bei Funktionsargumenten, da diese nur dann verwendet werden, wenn innerhalb der Funktion auf sie zugegriffen wird. Dieses Konzept wird als Namensaufruf bezeichnet.

def sometimesUsedString(someValue:String, defaultValue: => String) = {
 if(someValue != null) {
   use(defaultValue)
 } else {
   use(someValue)
   }
 }

Viele Programmiersprachen verwenden die Wertübergabe zur Auswertung von Argumenten. Ein Parameter, der per Namensübergabe übergeben wird, wird nur dann innerhalb des Funktionskörpers ausgewertet, wenn dies erforderlich ist. Sobald der Wert ausgewertet wurde, wird er gespeichert und kann später ohne erneute Auswertung wiederverwendet werden – ein Konzept, das als Memoisation bekannt ist.

Typ Inferenz

In Scala müssen Sie nicht für jede Variable einen Typ deklarieren, da der Scala-Compiler den Typ aus der rechten Seite eines Ausdrucks ableiten kann. Dadurch wird Ihr Code prägnanter und Sie vermeiden unnötigen Code, wenn der erwartete Typ offensichtlich ist.

var first:String = "Hello, "
var second:String = "World"
var third = first + second
//the compiler infers that third is of type String

Funktion höherer Ordnung

Eine Funktion höherer Ordnung ist eine Funktion, die Funktionen als Argumente entgegennehmen und eine Funktion als Rückgabetyp zurückgeben kann. In Scala werden Funktionen als erstklassige Objekte betrachtet. Durch die Verwendung von Funktionen auf diese Weise können Sie sehr flexibel verschiedene Arten von Programmen erstellen. Sie können Funktionen dynamisch erstellen und anderen Funktionen dynamisch Funktionalität zuweisen.

def doMathToInt(n:Int, myMathFunction:Int=>Int): Int = {
    myMathFunction(n)
}

In der obigen Funktion übergeben Sie einen Int und eine Funktion, die eine Int und gibt ein zurück IntSie können jede Funktion mit dieser Signatur übergeben. Mit Signatur meinen wir die Eingabe und Ausgabe einer Funktion. Eine Signatur von Int => Int bedeutet, dass eine Funktion einen Int-Wert als Eingabe nimmt und einen Int-Wert als Ausgabe zurückgibt.

Eine Unterschrift von () => Int Das bedeutet, dass eine Funktion keine Eingabe benötigt und einen Integer-Wert als Ausgabe zurückgibt. Ein Beispiel für eine solche Funktion ist eine, die einen zufälligen Integer-Wert generiert.

def generateRandomInt() = {
 return scala.util.Random.nextInt()
}

Die obige Funktion hat eine Signatur () => Int.

Eine Funktion kann auch eine Signatur haben. () => UnitDas bedeutet, dass die Funktion keine Parameter entgegennimmt und keinen Typ zurückgibt. Stattdessen kann die Funktion einen Zustand ändern oder eine vorbestimmte Aktion ausführen.

Solche Methoden sind nicht empfehlenswert, da sie wie eine Blackbox wirken und ein System auf unbekannte Weise beeinflussen können. Außerdem sind sie schwieriger zu testen. Die explizite Angabe von Eingabe- und Ausgabetypen ermöglicht es, die Funktionsweise der jeweiligen Funktion nachzuvollziehen.

Eine Funktion höherer Ordnung kann ebenfalls eine Funktion zurückgeben. Beispielsweise könnte man eine Methode erstellen, die eine Potenzierungsfunktion zurückgibt, also eine Funktion, die eine Zahl entgegennimmt und sie potenziert.

def powerByFunction(n:Int): Int=>Int = {
  return (x:Int) => scala.math.pow(x,n).toInt
}

Die obige Funktion erwartet einen Integer-Wert. Ihr Rückgabetyp ist eine anonyme Funktion, die einen Integer-Wert erwartet. x und verwendet es als Argument für die Potenzfunktion.

Curry

In Scala kann man eine Funktion, die zwei Argumente erwartet, in eine Funktion umwandeln, die jeweils nur ein Argument entgegennimmt. Beim Übergeben eines Arguments wird dieses teilweise angewendet, und die Funktion erhält das verbleibende Argument, um den Aufruf abzuschließen. Currying ermöglicht es, Funktionen durch das schrittweise Hinzufügen einzelner Argumente zu erstellen.

Dies ist nützlich, um Funktionen dynamisch zu erstellen, bevor man über einen vollständigen Satz von Argumenten verfügt.

def multiplyTwoNumbers(n:Int)(m:Int): Int = {
  return n * m
}

Wenn Sie eine Funktion benötigen, die mit einer bestimmten Zahl multipliziert, müssen Sie keine weitere Multiplikationsmethode erstellen. Sie können ein Argument an die Curried-Funktion übergeben und das Ergebnis wiederverwenden:

def multiplyTwoNumbers(n:Int)(m:Int): Int = {
  return n * m
}

var multiplyByFive = multiplyTwoNumbers(5) _

multiplyByFive(4)

//returns 20

Musterabgleich

Scala verfügt über einen leistungsstarken, integrierten Mechanismus, mit dem Sie überprüfen können, ob eine Variable bestimmte Kriterien erfüllt, ähnlich wie eine Switch-Anweisung in … Java oder eine Kette von if/else-Anweisungen. Die Sprache unterstützt Pattern Matching, mit dem Sie überprüfen können, ob eine Variable einen bestimmten Typ hat. Pattern Matching in Scala ist leistungsstark und kann Komponenten dekonstruieren, die ein unapply Methode, um die gewünschten Felder direkt aus der übereinstimmenden Variable zu erhalten.

Scala Pattern Matching bietet zudem eine angenehmere Syntax als eine Switch-Anweisung.

myItem match {
  case true => //do something
  case false => //do something else
  case  _ => //if none of the above do this by default
}

Sie vergleichen die Variable mit einer Reihe von Optionen. Wenn die Variable die Kriterien erfüllt, wird der Ausdruck rechts vom Pfeil (=>) ausgewertet und als Ergebnis der Übereinstimmung zurückgegeben.

Der Unterstrich kennzeichnet Fälle, die im Code nicht abgedeckt werden, und spiegelt damit das Verhalten des Standardfalls in einer Switch-Anweisung wider.

class Animal(var legs:Int, var sound:String)
class Furniture(var legs:Int, var color:Int, var woodType:String)

myItem match {
case myItem:Animal => //do something
case myItem:Furniture => //do something else
case _ => //unknown type, do something else
}

Im obigen Code können Sie den Typ des myItem Variable und, basierend darauf, Verzweigung zu spezifischem Code.

Beim Mustervergleich wird der Reihe nach geprüft, ob die Variable mit jedem Fall übereinstimmt.

Der Unterstrich dient als Platzhalter, der auf jede Bedingung zutrifft, die von den anderen Fallunterscheidungen nicht abgedeckt wird. Sie nehmen eine Variable. myItem und rufen Sie die match Methode.

• Prüfe ob myItem is true und führe die Logik auf der rechten Seite des fetten Pfeils „=>“ aus.
• Verwenden Sie den Unterstrich, um alles zu kennzeichnen, was keiner der im Code definierten Fallunterscheidungen entspricht.

Mit Case-Klassen können Sie die Klasse destrukturieren, um beispielsweise …tract Felder innerhalb des Objekts.

Durch die Verwendung der sealed Wenn Sie ein Schlüsselwort zur Definition von Klassen verwenden, profitieren Sie davon, dass der Compiler alle Fälle, die Sie abgleichen möchten, vollständig überprüft und Sie warnt, falls Sie einen Fall vergessen haben.

Unveränderlichkeit

Es ist in Scala möglich, Werte zu erzeugen, die von anderen Funktionen nicht geändert werden können, indem man die val Schlüsselwort. Dies wird erreicht durch Java mit dem final Schlüsselwort. In Scala verwendet man ein val beim Erstellen einer Variablen anstatt var, was die Alternative für veränderliche Variablen darstellt.

Eine Variable, die mithilfe der val Das Schlüsselwort ist schreibgeschützt, wohingegen ein mit var kann später von anderen Funktionen oder vom Benutzer im Code gelesen und geändert werden.

var changeableVariable = 8

changeableVariable = 10
//the compiler does not complain, and the code compiles successfully

println(changeableVariable)
//10

val myNumber = 7

myNumber = 4

//this will not compile

Ich versuche, einen Wert zuzuweisen myNumber nachdem es als ein val wirft einen Kompilierfehler: „Neuzuweisung an val“.

Warum Unveränderlichkeit verwenden?

Unveränderlichkeit verhindert, dass Code und andere Programmierer Werte unerwartet ändern, was zu unvorhersehbaren Ergebnissen führen würde. Wenn Nutzer eines Wertes diesen ändern müssen, können sie stattdessen eine Kopie erstellen. Dadurch werden Fehler vermieden, die entstehen, wenn mehrere Akteure dieselbe Variable ändern.

Klassen und Objekte

Objekte sind Entitäten der realen Welt, und eine Klasse ist eine Vorlage, die Objekte definiert. Klassen besitzen sowohl einen Zustand als auch ein Verhalten. Die Zustände sind entweder Werte oder Variablen. Das Verhalten sind die Methoden in Scala.

Im nächsten Abschnitt wird gezeigt, wie man eine Klasse definiert, sie instanziiert und in Scala verwendet.

Hier ist eine Klasse namens Rechteck, die zwei Werte und zwei Funktionen besitzt. Sie können auch die Parameter verwenden. l und b direkt als Felder im Programm. Sie haben ein Objekt, das eine main-Methode besitzt und die Klasse mit zwei Werten instanziiert.

Ejemplo:

class Rectangle(l: Int, b: Int) {
  val length: Int = l
  val breadth: Int = b
  def getArea: Int = l * b
  override def toString = s"This is a rectangle with length $length and breadth $breadth"
}
object RectObject {
  def main(args: Array[String]) {
    val rect = new Rectangle(4, 5)
    println(rect.toString)
    println(rect.getArea)
  }
}

In Scala sind alle Felder und Methoden standardmäßig öffentlich. Es ist unerlässlich, sie zu verwenden. override weil toString ist bereits für jedes Objekt in Scala definiert.

Erbe

Scala verfügt über verschiedene Vererbungsarten (einfach, mehrstufig, mehrfach, hierarchisch und hybrid), die viele Gemeinsamkeiten mit traditionellen Formen aufweisen, die in … zu finden sind. JavaSie können sowohl von Klassen als auch von Traits erben. Die Mitglieder einer Klasse werden mithilfe des Schlüsselworts `property` in eine andere Klasse vererbt. extendsDies ermöglicht die Wiederverwendbarkeit.

Es ist möglich, von einer oder mehreren Klassen zu erben. Ebenso ist es möglich, von Unterklassen zu erben, die selbst Oberklassen besitzen, wodurch eine Vererbungshierarchie entsteht.

Im folgenden Scala-Beispiel ist die Basisklasse Circleund die abgeleitete Klasse ist SphereEin Kreis besitzt einen Wert namens Radius, der von der Klasse Sphere geerbt wird. Die Methode calcArea wird durch das Schlüsselwort überschrieben override.

Ejemplo:

class Circle {
  val radius = 5
  def calcArea = {
    println(radius * radius)
  }
}
class Sphere extends Circle {
 override def calcArea = {
    println(radius * radius * radius)
  }
}
  object SphereObject {
    def main(args : Array[String]) {
      new Sphere().calcArea
    }
  }

AbstracProduktion

In Scala können Sie Abs erstellentract-Methoden und Mitgliedsfelder unter Verwendung von abstracT-Klassen und Merkmale. Innerhalb der Bauchmuskelntract-Klassen und -Merkmale, Sie können absolute definierentract-Felder, ohne sie zu implementieren.

Ejemplo:

trait MakesSound {
    var nameOfSound:String
    def sound():String
}
abstract class HasLegs(var legs:Int) {
    val creatureName:String

    def printLegs():String = {
        return s"$creatureName has this number of legs: $legs"
    }
}

Diese Felder werden von den Klassen implementiert, die das Trait oder abs erweitern.tract-Klasse. Sie können Traits verwenden, um Verbindungen herzustellen.tracts für das, was eine Anwendung tun soll, und implementieren Sie diese Methoden dann später.

trait DatabaseService {
    def addItemName(itemName:String)
    def removeItem(itemId:Int)
    def updateItem(itemId:Int, newItemName:String)
}

Auf diese Weise können Sie planen, wie eine Anwendung aussehen soll, ohne die Methoden implementieren zu müssen.ping Man stellt sich vor, wie verschiedene Methoden aussehen werden. Es folgt einem Muster, das als Programmierung bekannt ist, um zu verstehen, wie man es umsetzt.traceher auf die Umsetzung als auf die tatsächliche Umsetzung.

Eine Klasse, die mit dem/der/dem eingeleitet wird abstract Das Schlüsselwort kann beides enthalten: Abs.tract und Nicht-Abstract-Methoden. Mehrfachvererbung wird in abs jedoch nicht unterstützt.tract-Klassen, sodass Sie nur einen Abs erweitern könnentract-Klasse.

Singleton-Objekte

Ein Singleton ist eine Klasse, die in einem Programm nur einmal instanziiert wird. Es stammt aus einem bekannten und nützlichen Programmiermuster, dem „Singleton-Muster“. Es eignet sich für die Erstellung von Instanzen, die langlebig sein und im gesamten Programm häufig verwendet werden sollen, da ihr Zustand für die Koordination von Ereignissen im System unerlässlich ist. In Scala ist die Erstellung einer solchen Klasse einfach, da Scala eine unkomplizierte Möglichkeit zur Erzeugung von Singletons bietet. object Stichwort.

object UserProfile {
    var userName = ""
    var isLoggedIn:Boolean = false
}

Sie können dann im gesamten Programm auf dieses Objekt verweisen und sich darauf verlassen, dass alle Teile des Programms die gleichen Daten sehen, da es nur eine Instanz davon gibt.

def getLoggedInStatus():Boolean = {
   return UserProfile.isLoggedIn
}

def changeLoggedInStatus():Boolean = {
    UserProfile.isLoggedIn = !UserProfile.isLoggedIn
    return UserProfile.isLoggedIn
}

Das Konzept statischer Member existiert in Scala nicht. Deshalb verwendet man Singleton-Objekte, die sich wie statische Member einer Klasse verhalten.

Implizite Klassen

Implizite Klassen sind ein Feature, das in Version 2.10 hinzugefügt wurde und hauptsächlich dazu dient, bestehenden geschlossenen Klassen neue Funktionalität hinzuzufügen.

Das implicit Das Schlüsselwort muss in einer Klasse, einem Objekt oder einem Trait definiert sein. Der primäre Konstruktor einer impliziten Klasse muss genau ein Argument in seiner ersten Parameterliste haben. Er kann auch eine zusätzliche implizite Parameterliste enthalten.

Im folgenden Scala-Beispiel wird eine neue Funktionalität hinzugefügt, um Vokale eines Strings durch * zu ersetzen.

object StringUtil {
  implicit class StringEnhancer(str: String) {

    def replaceVowelWithStar: String = str.replaceAll("[aeiou]", "*")
  }
}

Sie müssen die implizite Klasse in der Klasse importieren, in der Sie sie verwenden.

import StringUtil.StringEnhancer

object ImplicitEx extends App {
  val msg = "This is Guru99!"
  println(msg.replaceVowelWithStar)
}

Objektorientierte Programmierung (OOP) vs. Funktionale Programmierung (FP)

In der objektorientierten Programmierung (OOP) werden Programme durch Gruppenbildung erstellt.ping Daten und die Funktionen, die auf diesen Daten operieren, werden zu eng miteinander verbundenen Einheiten zusammengefasst. Objekte speichern ihre Daten in Feldern, und die Methoden operieren auf diesen Feldern. In diesem Programmierstil ist die HauptabstraktiontracDie Daten sind entscheidend, denn die erstellten Methoden sind dazu bestimmt, auf den Daten zu operieren.

FunktionsprogrammierungAndererseits trennt es Daten und die Funktionen, die darauf operieren. Dies ermöglicht es Entwicklern, Funktionen als absolute Datenstrukturen zu behandeln.traction und treibende Kraft bei der Modellierung von Programmen.

Scala ermöglicht funktionale Programmierung, indem Funktionen als vollwertige Objekte behandelt werden. Dadurch können sie als Werte an andere Funktionen übergeben und auch als Werte zurückgegeben werden. Die Kombination dieser beiden Paradigmen macht Scala zu einer hervorragenden Wahl für die Entwicklung komplexer Software in Branchen wie der Datenwissenschaft.

Wichtige Frameworks auf Scala

Hier sind einige wichtige Frameworks für Scala:

• Spielen ist ein Open-Source-Webanwendungs-Framework, das verwendet MVC-ArchitekturEs wurde 2007 veröffentlicht und steht heute unter der Apache-Lizenz. Bis 2013 entwickelte es sich zu einem der beliebtesten Frameworks auf GitHub. Unternehmen wie LinkedIn, WalmartSamsung und Eero nutzen dieses Framework.
• Lift Lift ist ein weiteres kostenloses Webframework, das in Scala geschrieben und 2007 veröffentlicht wurde. Foursquare nutzt das Lift-Framework. Es ist ein leistungsstarkes Framework, mit dem sich schnell Anwendungen entwickeln lassen.
• Akka bietet ein Toolkit zum Erstellen hochgradig paralleler, verteilter und robuster nachrichtenbasierter Anwendungen auf der JVM.
• Katzen ist eine Bibliothek, die Abs bietettracKonzepte für die funktionale Programmierung.
• Spark ist eine einheitliche Analyse-Engine für die Verarbeitung großer Datenmengen, die in Big-Data- und Machine-Learning-Workflows weit verbreitet ist.

Parallelitätsunterstützung

• In Scala sind die Werte standardmäßig unveränderlich, was es sehr anpassungsfähig an Umgebungen mit gleichzeitiger Verarbeitung macht.
• Scala verfügt über viele Eigenschaften, die es ideal für parallele Anwendungen machen.
• Futures und Promises erleichtern die asynchrone Datenverarbeitung und unterstützen so die Parallelität.
• Akka ist ein Toolkit, das das Actor-Concurrency-Modell verwendet. Actors werden aktiv, wenn sie Nachrichten empfangen.
• Parallelität mit Threads aus Java wird auch in Scala unterstützt.
• Streamverarbeitung ist eine weitere großartige Funktion, die eine kontinuierliche Echtzeitverarbeitung von Daten ermöglicht.

Scala verfügt über einige der besten Parallelitätsbibliotheken der Java Ökosystem:

• Ureinwohner Java Threads.
• Fibers aus Bibliotheken wie Vertx.
• ZIO ist eine Bibliothek mit Grundfunktionen zur Unterstützung von Parallelverarbeitung und asynchroner Berechnung.
• Software Transactional Memory (STM) für Transaktionen.
• Future, das in die Scala-Sprache integriert ist.

Java Vergleich mit Scala

Hier sind die wichtigsten Unterschiede zwischen Java und Scala.

Häufig gestellte Fragen