Scala-Tutorial: Beispiel und Code der Scala-Programmiersprache

Zusammenfassung des Scala-Tutorials

Dieses Scala-Tutorial behandelt alle Aspekte und Themen von Scala. Sie lernen alle Grundlagen von Grund auf kennen, z. B. Was ist Scala, der Installationsprozess von Scala, Scala-Programme, Scala-Funktionen, verzögerte Auswertung, Typschnittstelle, Klassen und Objekte, Vererbung, Abstraktionen, Java- und Scala-Unterschiede usw.

Was ist Scala?

Scala ist eine statisch typisierte Programmiersprache, die sowohl funktionale als auch objektorientierte Programmierung umfasst, um die Skalierbarkeit von Anwendungen zu erhöhen. Scala läuft hauptsächlich auf der JVM-Plattform und kann auch zum Schreiben von Software für native Plattformen mithilfe von Scala-Native und verwendet werden JavaScript Laufzeiten durch ScalaJs.

Scala ist eine skalierbare Sprache, die zum Schreiben von Software für mehrere Plattformen verwendet wird. Daher erhielt es den Namen „Scala“. Diese Sprache soll die Probleme von Java gleichzeitig lösenneonormalerweise prägnanter. Ursprünglich von Martin Odersky entworfen, wurde es 2003 veröffentlicht.

Warum Scala lernen?

Hier sind die Hauptgründe für das Erlernen der Programmiersprache Scala:

  • Scala ist für objektorientierte Programmierer und Java-Entwickler leicht zu erlernen. Es hat sich in den letzten Jahren zu einer der beliebtesten Sprachen entwickelt.
  • Scala bietet erstklassige Funktionen für Benutzer
  • Scala kann ausgeführt werden JVMund ebnet so den Weg für die Interoperabilität mit anderen Sprachen.
  • Es ist für Anwendungen konzipiert, die gleichzeitig, verteilt und robust nachrichtengesteuert sind. Es ist eine der anspruchsvollsten Sprachen dieses Jahrzehnts.
  • Es handelt sich um eine prägnante, leistungsstarke Sprache, die je nach Bedarf der Benutzer schnell wachsen kann.
  • Es ist objektorientiert und verfügt über viele funktionale Programmierfunktionen, die den Entwicklern viel Flexibilität beim Codieren auf die von ihnen gewünschte Weise bieten.
  • Scala bietet viele Entenarten an
  • Es hat weniger Boilerplate, wenn Sie herkommen Javac
  • Die in Scala geschriebenen Frameworks Lift und Play befinden sich in der Wachstumskurve.

So installieren Sie Scala

Um mit dem Schreiben von Scala-Programmen beginnen zu können, muss es auf Ihrem Computer installiert sein. Dazu müssen Sie deren Website besuchen https://www.scala-lang.org/download/ um die neueste Version von Scala herunterzuladen.

Following Über den Link gelangen wir zu zwei Optionen, mit denen wir Scala auf unseren Maschinen installieren können. Für dieses Scala-Tutorial laden wir das herunter IntelliJ IDEA.

So installieren Sie Scala

Sobald Sie den Download-Link besuchen, finden Sie zwei Versionen 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.

So installieren Sie Scala

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

Es bietet uns die Möglichkeit, die IntelliJ-IDE zusammen mit JBR herunterzuladen, die eine JDK-Implementierung (Java Development Kit) OpenJDK enthält, die Scala zum Kompilieren und Ausführen des Codes benötigt.

So installieren Sie Scala

Schritt 2) Führen Sie die Installation aus
Sobald Sie IntelliJ heruntergeladen haben, double Klicken Sie darauf, um den Installationsassistenten auszuführen, und folgen Sie dem Dialog.

So installieren Sie Scala

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

So installieren Sie Scala

Wenn Sie die Version nicht mit dem JDK heruntergeladen haben, werden wir dennoch aufgefordert, die Option zum Herunterladen zu überprüfen, indem wir das Häkchen auswählenbox.

So installieren Sie Scala

Schritt 4) Klicken Sie auf Weiter
Lassen Sie die anderen Standardeinstellungen unverändert und klicken Sie auf „Weiter“.

So installieren Sie Scala

Schritt 5) Klicken Sie auf das Startsymbol
Sobald die Installation abgeschlossen ist, führen Sie die IntelliJ-IDE aus, indem Sie wie eine normale Anwendung auf das Startsymbol im Startmenü klicken.

So installieren Sie Scala

Sie müssen noch einen zusätzlichen Schritt durchlaufen, um das Scala-Plugin zu IntelliJ hinzuzufügen. Klicken Sie dazu auf das Dropdown-Menü im Konfigurationsmenü unten rechts auf dem Bildschirm und wählen Sie die Plugin-Option aus.

So installieren Sie Scala

So installieren Sie Scala

Auf der Registerkarte „Marktplatz“ wird bei einer Suche nach Scala das Plugin als erstes Ergebnis unter dem Tag „Sprachen“ angezeigt.

Schritt 6) PIugin installieren
Klicken Sie auf „Installieren“, woraufhin das Plugin mit dem Download beginnt.

So installieren Sie Scala

Schritt 7) Starten Sie die IDE neu
Nachdem der Download abgeschlossen ist, werden Sie aufgefordert, die IDE neu zu starten, damit das installierte Plugin mit der Arbeit beginnen kann.

So installieren Sie Scala

Nach dem Neustart befinden Sie sich auf derselben Seite wie zuvor, als wir die IDE ausgeführt haben, aber dieses Mal haben wir das Scala-Plugin bereits installiert.

Scala Hello World-Programm

Schritt 1) Wählen Sie die Option „Projekt erstellen“, um zu einer Seite zu gelangen, auf der wir die Art der Sprache auswählen können, die unser Projekt verwenden soll.

Scala Hello World-Programm

Schritt 2) Wählen Sie Scala, indem Sie den Scala-Check auswählenbox und klicken Sie auf Weiter.

Scala Hello World-Programm

Schritt 3) Wählen Sie einen Speicherort für unsere Projektdatei und geben Sie unserem Projekt einen Namen.

Scala Hello World-Programm

Wenn das Verzeichnis nicht existiert, werden wir von IntelliJ aufgefordert, um Erlaubnis zum Erstellen des Ordners zu bitten. Akzeptieren Sie und klicken Sie auf „Fertig stellen“. Sie werden zu Ihrem Scala-Projekt weitergeleitet, das derzeit keinen Scala-Code enthält.

Das Laden einiger Indizes wird einige Zeit in Anspruch nehmen. Machen Sie sich also keine Sorgen, wenn Sie nicht sofort etwas tun können, während unten in Ihrer IDE ein Fortschrittsbalken angezeigt wird. Dies bedeutet lediglich, dass Ihre IDE einige Dateien lädt, die zum Ausführen von Scala und erforderlich sind Hilfe bei der IDE-Autovervollständigung.

Schritt 4) Als nächstes klicken wir auf die Registerkarte „Projekte“ links in der IDE und erweitern sie, damit wir den Inhalt unseres Projekts sehen können.

Scala Hello World-Programm

Im Moment ist das Projekt leer und enthält nur einen .idea-Ordner und eine von der IDE generierte hello-world.iml-Datei. Unser interessanter Punkt ist der Ordner src. Src ist der Ort, an dem wir den Quellcode für unser Projekt speichern. Hier erstellen wir unsere erste Scala-Datei.

Schritt 5) Klicken Sie mit der rechten Maustaste auf src, um ein Menü zum Erstellen einer neuen Scala-Datei zu öffnen.

Erstellen Sie eine neue Scala-Datei

Anschließend erstellen wir einen Namen für die Datei. In diesem Scala-Tutorial verwenden wir „Hallo“ und wählen dann aus einem Dropdown-Menü aus, was als Inhalt der Scala-Datei hinzugefügt werden soll. Wählen Sie „Objekt“

Scala Hello World-Programm

Sobald wir dies tun, verfügen wir über eine Scala-Datei mit einem Singleton-Objekt, das wir zum Ausführen unseres Codes verwenden.

Scala Hello World-Programm

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

Durch die Erweiterung unseres Objekts mit App teilen Sie dem Compiler mit, welcher Code ausgeführt werden soll, wenn er Ihr Programm startet. Unmittelbar nach dem Erweitern der App wird auf der linken Seite ein grüner Pfeil angezeigt, der anzeigt, dass Sie Ihr Programm jetzt ausführen können.

Scala Hello World-Programm

Scala Hello World-Programm

Innerhalb des Hello-Objekts schreiben wir eine Funktion println(), die verwendet wird, um den darin enthaltenen Text an die Konsole zu drucken. Wir führen unseren Code aus, indem wir auf den grünen Pfeil klicken.

Wenn wir auf den Pfeil klicken, wird uns die Option „Ausführen“ angezeigt. Hallo, wenn wir darauf klicken, beginnt unser Code mit der Kompilierung und nach einigen Sekunden sehen wir die Ergebnisse unseres Programms, die von der in die IntelliJ-IDE integrierten Konsole gedruckt werden.

Scala Hello World-Programm

Und schon haben wir Scala erfolgreich installiert und unser erstes Programm ausgeführt.

Was Sie mit Scala machen können

  • Frontend-Webentwicklung mit ScalaJS
  • Mobile Entwicklung, sowohl Android-Entwicklung als auch IOS – mit Scala Native
  • Serverseitige Bibliotheken wie HTTP4S, Akka-Http, Play Framework
  • Internet der Dinge nutzen
  • Spielentwicklung
  • NLP – Verarbeitung natürlicher Sprache unter Verwendung einer Reihe von Bibliotheken ScalaNLP
  • Testen fortgeschrittener Programmiertechniken wie der funktionalen Programmierung und der objektorientierten Programmierung
  • Erstellen Sie eine hochgradig gleichzeitige Kommunikationsanwendung mithilfe einer von Erlang inspirierten Bibliothek für die JVM
  • Verwenden Sie es für maschinelles Lernen mit Bibliotheken wie Figaro, das probabilistische Programmierung durchführt, und Apache Spark zur Verbesserung der Gesundheitsgerechtigkeit

Anonyme Funktionen

Die Scala-Sprache verfügt über anonyme Funktionen, die auch aufgerufen werden Funktionsliterale. Da Scala eine funktionale Sprache ist, bedeutet dies oft, dass Entwickler große Probleme in viele kleine Aufgaben zerlegen und viele Funktionen erstellen, um diese Probleme zu lösen. Um das Erstellen von Funktionen zu vereinfachen, enthält Scala die folgenden Funktionen ohne Namen instanziiert. Wir können sie direkt den Variablen oder Definitionen „def“ zuweisen, wie im folgenden Scala-Beispiel gezeigt:

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

Wir können dann wie gewohnt Funktionen verwenden, indem wir ihnen folgende Parameter übergeben.

multiplyByTwo(3)

//6

multiplyByThree(4)

//12

Diese Methoden sind praktisch, wenn wir einen sauberen und prägnanten Code haben möchten. Wir können anonyme Funktionen verwenden, wenn wir Methoden definieren, die nicht groß sind und nicht viel Code in ihrem Körper erfordern. Sie sind sehr einfach und erfordern keine Zeremonie.

Diese Methoden sind nicht auf Funktionen mit Argumenten beschränkt und können zum Instanziieren von Methoden verwendet werden, die keine Argumente akzeptieren.

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

Die meisten dieser anonymen Funktionen werden in anderen Teilen unseres Codes verwendet, wo wir vor Ort eine schnelle Funktion erstellen müssen.

Ein weiterer Grund, warum diese Funktionen auch als bezeichnet werden Inline-Funktionen. Die Verwendung anonymer Funktionen ist ein gängiges Muster, das in der Sammlungsbibliothek weit verbreitet ist, um schnelle Aktionen für eine Sammlung durchzuführen.

Wir haben zum Beispiel die Filtermethode, die eine Inline-Funktion/anonyme Funktion verwendet, um eine weitere Sammlung mit nur Elementen zu erstellen, die die Kriterien erfüllen, die wir in der anonymen Funktion definieren.

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 sind die Methoden, die wir als anonyme Funktionen haben, diejenigen, die prüfen, ob der Wert, den wir aus der Liste erhalten, ungerade oder gerade ist, und das Element zurückgeben.

//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, Platzhalter zu verwenden, wenn die Parameter unserer anonymen Funktion nicht benannt sind. Zum Beispiel

var timesTwo = (_:Int)*2

timesTwo(5)
//10

In diesem Szenario benennen wir den Parameter, den wir übergeben, nicht. Das einzige, was wir verwenden, ist ein Unterstrich, um ihn darzustellen.

Faule Bewertung

Die meisten Sprachen werten Variablen und Funktionsparameter sequentiell nacheinander aus. In Scala gibt es ein Schlüsselwort namens „lazy“, das beim Umgang mit Werten hilft, die erst ausgewertet werden sollen, wenn auf sie verwiesen wird.

Eine als „lazy“ markierte Variable wird nicht dort ausgewertet, wo sie definiert ist. Dies wird allgemein als Eager-Auswertung bezeichnet. Sie wird nur ausgewertet, wenn an einigen Stellen auf sie verwiesen wird later im Code.

Dies kann hilfreich sein, wenn die Auswertung eines Werts eine teure Berechnung sein könnte. Wenn der Wert nicht immer benötigt wird, können wir uns die Durchführung einer teuren Berechnung ersparen, die unsere Software verlangsamen kann, indem sie unsere Variable lazy macht.

lazy val myExpensiveValue = expensiveComputation

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

Dies ist nicht der einzige Anwendungsfall für Lazy-Variablen. Sie helfen auch dabei, Probleme der zirkulären Abhängigkeit im Code zu lösen.

Falls die Einstellungen falsch sind, müssen wir myExpensiveValue möglicherweise nicht verwenden, was dazu führen kann, dass wir uns eine teure Berechnung ersparen, was dazu beiträgt, dass Benutzer eine angenehme Zeit mit unserer Anwendung haben, da ihre anderen Bedürfnisse ordnungsgemäß berechnet werden können, ohne sie zu überfordern der RAM.

Wenn die Einstellungen falsch sind, müssen wir myExpensiveValue möglicherweise nicht verwenden, was dazu führen kann, dass wir uns eine teure Berechnung ersparen und sicherstellen, dass Benutzer eine angenehme Zeit mit unserer Anwendung haben, da ihre anderen Anforderungen angemessen berechnet werden können, ohne sie zu überfordern der RAM.

Die Faulheit hilft auch bei Funktionsargumenten, bei denen die Argumente nur verwendet werden, wenn innerhalb der Funktion auf sie verwiesen wird. Dieses Konzept wird Call-by-Name-Parameter genannt.

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

Viele Sprachen verwenden die Call-by-Value-Methode zur Auswertung von Argumenten. Der über Call-by-Name übergebene Parameter wird nur ausgewertet, wenn er im Funktionskörper benötigt wird, und wird vorher nicht ausgewertet. Sobald der Wert ausgewertet ist, wird er gespeichert und kann wiederverwendet werden later ohne dass es neu bewertet werden muss. Ein Konzept, das als Memoisierung bekannt ist.

Typ Inferenz

In Scala müssen Sie nicht für jede von Ihnen erstellte Variable Typen deklarieren. Dies liegt daran, dass der Scala-Compiler Typinferenzen auf Typen basierend auf der Auswertung der rechten Seite durchführen kann. Dadurch wird Ihr Code prägnanter – es erspart uns das Schreiben von Textbausteinen, bei denen der erwartete Typ offensichtlich ist

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

Funktion höherer Ordnung

Eine Funktion höherer Ordnung ist eine Funktion, die Funktionen als Argumente annehmen und eine Funktion als Rückgabetyp zurückgeben kann. In Scala gelten Funktionen als erstklassige Bürger. Wenn wir diese Funktionen auf diese Weise nutzen, können wir bei der Art der Programme, die wir erstellen können, sehr flexibel sein. Wir können Funktionen dynamisch erstellen und Funktionalität dynamisch in andere Funktionen einspeisen.

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

In der obigen Funktion übergeben wir ein int und eine Funktion, die ein int annimmt und ein int zurückgibt. Wir können jede Funktion dieser Signatur übergeben. Mit Signatur meinen wir die Eingabe und Ausgabe einer Funktion. Eine Signatur von Int=>Int bedeutet, dass eine Funktion ein Int als Eingabe akzeptiert und ein Int als Ausgabe zurückgibt.

Eine Signatur von ()=>Int bedeutet, dass eine Funktion nichts als Eingabe akzeptiert und als Ausgabe ein Int zurückgibt. Ein Beispiel für eine solche Funktion wäre eine, die für uns einen zufälligen Int generiert.

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

Die obige Funktion hat eine Signatur ()=>Int

Wir können eine Funktion haben, die eine Signatur hat: scala ()=>Unit. Das bedeutet, dass die Funktionen nichts aufnehmen und keinen Typ zurückgeben. Die Funktion könnte darin bestehen, eine Art Berechnung durchzuführen, indem sie etwas ändert, um etwas Vorherbestimmtes zu tun.

Solche Methoden werden jedoch nicht empfohlen, da sie scheinbar schwarz sind box Dies kann sich auf unbekannte Weise auf ein System auswirken. Sie sind auch nicht testbar. Wenn wir über explizite Eingabe- und Ausgabetypen verfügen, können wir darüber nachdenken, was unsere Funktion tut.

Eine Funktion höherer Ordnung kann auch eine Funktion zurückgeben.

Beispielsweise könnten wir eine Methode erstellen, die eine Potenzfunktion erstellt, also eine Zahl nimmt und diese potenziert.

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

Die obige Funktion benötigt einen int. Unser Rückgabetyp ist eine anonyme Funktion, die einen Int x akzeptiert. * Wir verwenden den Int x als Argument für die Potenzfunktion.

Curry

In Scala können wir eine Funktion, die zwei Argumente akzeptiert, in eine Funktion umwandeln, die jeweils ein Argument akzeptiert. Wenn wir ein Argument übergeben, wenden wir es teilweise an und erhalten am Ende eine Funktion, die ein Argument benötigt, um die Funktion abzuschließen. Mit Currying können wir Funktionen erstellen, indem wir teilweise einige Argumente hinzufügen.

Dies kann nützlich sein, um Funktionen dynamisch zu erstellen, bevor wir über einen vollständigen Satz von Argumenten verfügen

def multiply two numbers(n:Int)(m:Int): Unit ={
  return n * m
}

Wenn wir eine Funktion erstellen müssen, die mit einer bestimmten Zahl multipliziert, müssen wir keine weitere Multiplikationsmethode erstellen.

Wir können einfach .curried für unsere obige Funktion aufrufen und erhalten eine Funktion, die zuerst ein Argument akzeptiert und eine teilweise angewendete Funktion zurückgibt

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

var multiplyByFive = multiplyTwoNumbers(5) 

multiplyByFive(4)

//returns 20

Musterabgleich

Scala verfügt über einen leistungsstarken integrierten Mechanismus, der uns dabei hilft, zu überprüfen, ob eine Variable bestimmte Kriterien erfüllt, ähnlich wie wir es in einer Switch-Anweisung in Java oder in einer Reihe von if/else-Anweisungen tun würden. Die Sprache verfügt über einen Mustervergleich, mit dem wir prüfen können, ob eine Variable von einem bestimmten Typ ist. Der Mustervergleich in Scala ist leistungsstark und kann verwendet werden, um die Komponenten zu zerstören, die über eine Unapply-Methode verfügen, um Felder, an denen wir interessiert sind, direkt aus der Variablen abzurufen, die wir abgleichen.

Der Mustervergleich von Scala bietet im Vergleich zur Switch-Anweisung auch eine angenehmere Syntax.

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

Wir vergleichen unsere Variable mit einer Reihe von Optionen, und wenn die Variable, die wir abgleichen, die Kriterien erfüllt, wird der Ausdruck auf der rechten Seite des dicken Pfeils (=>) ausgewertet und als Ergebnis des Abgleichs zurückgegeben.

Wir verwenden einen Unterstrich, um Fälle abzufangen, die in unserem Code nicht übereinstimmen. Es spiegelt das Verhalten des Standardfalls bei der Verarbeitung von Switch-Anweisungen 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 _ => //case we have a type we don't recognize do sth else
}

Im obigen Code können Sie den Typ der Variable „myItem“ ermitteln und auf dieser Grundlage zu einem bestimmten Code verzweigen.

Beim Mustervergleich wird geprüft, ob die Variable übereinstimmt

Der Unterstrich fungiert als Platzhalter, der jede andere Bedingung erfüllt, die nicht von den anderen Elementen in den obigen Case-Anweisungen erfüllt wird. Wir nehmen eine Variable myItem und rufen die match-Methode auf.

  • Wir überprüfen, ob myItem wahr ist, indem wir auf der rechten Seite des dicken Pfeils „=>“ etwas Logik anwenden.
  • Wir verwenden den Unterstrich, um alles zu finden, was mit keiner der von uns im Code definierten Case-Anweisungen übereinstimmt.

Mit Case-Klassen können wir sogar noch weiter gehen und die Klasse zerstören, um Felder innerhalb des Objekts zu erhalten.

Durch die Verwendung des Schlüsselworts „sealed“ zum Definieren unserer Klassen haben wir den Vorteil, dass der Compiler die Fälle, mit denen wir einen Abgleich durchführen möchten, gründlich prüft und uns warnt, wenn wir vergessen, einen bestimmten Fall zu behandeln.

Unveränderlichkeit

Mit dem Schlüsselwort val ist es möglich, Werte zu erstellen, die nicht von anderen Funktionen in Scala geändert werden können. Dies wird in Java durch die Verwendung des Schlüsselworts final erreicht. In Scala tun wir dies, indem wir beim Erstellen einer Variablen das Schlüsselwort val verwenden, anstatt var zu verwenden, was die Alternative wäre, die wir zum Erstellen einer veränderlichen Variablen verwenden würden.

Eine mit dem Schlüsselwort val definierte Variable ist schreibgeschützt, wohingegen eine mit var definierte Variable von anderen Funktionen oder willkürlich vom Benutzer im Code gelesen und geändert werden kann.

var changeableVariable = 8

changeableVariable =10
//the compiler doesn't complain, and the code compiles successfully

println(changeableVariable)
//10

val myNumber = 7

myNumber = 4

//if we try this the code won't compile

Der Versuch, myNumber einen Wert zuzuweisen, nachdem wir ihn als Wert deklariert haben, löst einen Fehler bei der Kompilierung oder eine „Neuzuweisung zu Wert“ aus.

Warum Unveränderlichkeit verwenden?

Unveränderlichkeit hilft uns, zu verhindern, dass Code und andere Programmierer unsere Werte unerwartet ändern, was zu unerwarteten Ergebnissen führen würde. Wenn sie den von uns gespeicherten Wert verwenden sollen, können sie stattdessen eine Kopie davon erstellen. Auf diese Weise werden Fehler verhindert, die dadurch verursacht werden können, dass mehrere Akteure dieselbe Variable ändern.

Klassen und Objekte

Wir alle wissen, dass Objekte die Entitäten der realen Welt sind und dass eine Klasse eine Vorlage ist, die Objekte definiert. Klassen haben sowohl Zustände als auch Verhaltensweisen. Die Zustände sind entweder Werte oder Variablen. Die Verhaltensweisen sind die Methoden in Scala.

Schauen wir uns an, wie Sie eine Klasse definieren, instanziieren und mit Scala verwenden können.

Hier die Klasse namens „Rechteck“, die zwei Variablen und zwei Funktionen hat. Sie können die Parameter l und b auch direkt als Felder im Programm verwenden. Sie haben ein Objekt, das über eine Hauptmethode verfügt und die Klasse mit zwei Werten instanziiert hat.

Beispiel:

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 rectangle with length as $length and breadth as  $breadth"
  }
object RectObject {
  def main(args: Array[String]) {
    val rect = new Rectangle(4, 5)
    println(rect.toString)
    println(rect.getArea)    
  }
}

Alle Felder und Methoden sind in Scala standardmäßig öffentlich. Die Verwendung von Override ist unbedingt erforderlich, da die toString-Methode für Object in Scala definiert ist.

Erbe

Scala verfügt über mehrere Arten der Vererbung (z. B. Einzel-, Mehrebenen-, Mehrfach- und Hier.-Vererbung).archical, hybrid), die viele Gemeinsamkeiten mit traditionellen Formen haben, die in Java vorkommen. Sie können sowohl von Klassen als auch von Merkmalen erben. Mit dem Schlüsselwort „extends“ können Sie die Mitglieder einer Klasse in eine andere Klasse vererben. Dies ermöglicht eine Wiederverwendbarkeit.

Es ist möglich, von einer oder mehreren Klassen zu erben. Es ist auch möglich, von Unterklassen zu erben, die selbst über Oberklassen verfügen, wodurch eine Vererbungshierarchie entsteht.

Im folgenden Scala-Beispiel ist die Basisklasse „Circle“ und die abgeleitete Klasse „Sphere“. Ein Kreis hat einen Wert namens Radius, der in der Sphere-Klasse geerbt wird. Die Methode calcArea wird mit dem Schlüsselwort override überschrieben.

Beispiel:

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

Abstraktion

In Scala können wir mithilfe abstrakter Klassen und Merkmale abstrakte Methoden und Mitgliedsfelder erstellen. Innerhalb abstrakter Klassen und Merkmale können wir abstrakte Felder definieren, ohne sie unbedingt zu implementieren.

Beispiel:

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 Merkmal oder die abstrakte Klasse erweitern. Mithilfe von Merkmalen können Sie Verträge darüber erstellen, was unsere Anwendung tun können soll, und diese Methoden dann implementieren later.

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

Auf diese Weise können wir planen, wie unsere Anwendung aussehen wird, ohne Methoden zu implementieren, die uns helfen können, uns vorzustellen, wie verschiedene Methoden aussehen werden. Es folgt einem Muster, das als Programmierung auf Abstraktionen bekannt ist, und nicht der tatsächlichen Implementierung.

Die Klasse, der das Schlüsselwort abstract vorangestellt ist, kann sowohl abstrakte als auch nicht abstrakte Methoden enthalten. Mehrfachvererbungen werden in abstrakten Klassen jedoch nicht unterstützt. Sie können also höchstens eine abstrakte Klasse erweitern.

Singleton-Objekte

Ein Singleton ist eine Klasse, die nur einmal in einem Programm instanziiert wird. Es stammt aus einem beliebten und nützlichen Programmiermuster, das als „Singleton-Muster“ bekannt ist. Dies ist nützlich beim Erstellen von Instanzen, die langlebig sein sollen und auf die im gesamten Programm häufig zugegriffen wird und deren Status für die Koordinierung der Ereignisse eines Systems von entscheidender Bedeutung ist. Das Erstellen einer solchen Klasse in Scala ist einfach, da Scala uns eine einfache Möglichkeit bietet, Singletons mithilfe des Schlüsselworts object zu erstellen.

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

Wir können dieses Objekt dann in unserem gesamten Programm referenzieren, mit der Garantie, dass alle Teile unseres Programms dieselben 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 der statischen Mitglieder gibt es in Scala nicht. Aus diesem Grund müssen Sie Singleton-Objekte verwenden, die sich wie statische Mitglieder einer Klasse verhalten.

Implizite Klassen

Implizite Klassen sind die neue Funktionalität, die nach Version 2.1 hinzugefügt wurde. Es geht in erster Linie darum, den geschlossenen Klassen neue Funktionalität hinzuzufügen.

Das implizite Schlüsselwort sollte in einer Klasse, einem Objekt oder einem Merkmal definiert werden. Der primäre Konstruktor einer impliziten Klasse sollte genau ein Argument in seiner ersten Parameterliste haben. Es kann auch eine zusätzliche implizite Parameterliste enthalten.

Im folgenden Scala-Beispiel wurde eine neue Funktionalität zum Ersetzen von Vokalen eines Strings durch * hinzugefügt.

object StringUtil {
  implicit class StringEnhancer(str: String) {
    
    def replaceVowelWithStar: String = str.replaceAll("[aeiou]", "*")
  }
}

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

import StringUtil.StringEnhancer

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

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

In OOP werden Programme erstellt, indem Daten und die mit diesen Daten arbeitenden Funktionen in hochgradig verbundenen Einheiten gruppiert werden. Objekte tragen ihre Daten in den Feldern und Methoden, die mit ihnen arbeiten. Bei diesem Programmierstil sind die Daten die Hauptabstraktion, da die erstellten Methoden dazu gedacht sind, mit den Daten zu arbeiten.

Funktionsprogrammierunghingegen trennt Daten und die Funktionen, die mit den Daten arbeiten. Dadurch können Entwickler Funktionen als Abstraktion und treibende Kraft bei der Modellierung von Programmen betrachten.

Scala ermöglicht funktionale Programmierung, indem es Funktionen wie erstklassige Bürger hatwing Sie sollen als Werte an andere Funktionen übergeben und auch als Werte zurückgegeben werden. Die Kombination dieser beiden Paradigmen hat Scala zu einer großartigen Wahl beim Aufbau von Computern gemachtplex Software in verschiedenen Branchen, wie zum Beispiel Data Science.

Wichtige Frameworks auf Scala

Hier sind einige wichtige Frameworks von Scala

  • Play ist ein Open-Source-Webanwendungs-Framework, das verwendet MVC architektur. Es wurde 2007 veröffentlicht und jetzt unter Apache lizenziert und wurde 2013 zum beliebtesten Framework auf GitHub. Unternehmen wie LinkedIn, Walmart, Samsung und Eero verwenden dieses Framework.
  • Aufzug ist ein weiteres kostenloses Web-Framework, das 2007 in Scala geschrieben wurde. Foursquare verwendet das Lift-Framework. Es ist ein leistungsstarkes und schneller zu erstellendes Framework.
  • Akka
  • Katzen
  • Spark

Parallelitätsunterstützung

  • Die Werte in Scala sind standardmäßig unveränderlich. Dadurch ist es sehr anpassungsfähig an die gleichzeitige Umgebung.
  • Es gibt viele Funktionen in Scala, die es ideal für gleichzeitige Anwendungen machen.
  • Futures und Promises erleichtern die Datenverarbeitung asyncchronisch und unterstützt so die Parallelität.
  • Akka – Toolkit, das das Actor-Parallelitätsmodell verwendet. Es gibt eine Reihe von Akteuren, die handeln, wenn sie Nachrichten empfangen.
  • Auch die Parallelität mit Threads aus Java kann in Scala unterstützt werden.
  • Die Stream-Verarbeitung ist eine weitere großartige Funktion, die eine kontinuierliche Datenverarbeitung in Echtzeit ermöglicht.

Scala verfügt über einige der besten Parallelitätsbibliotheken in Java ecosSystem.

  • Native Java-Threads
  • Fasern aus Bibliotheken wie Vertex
  • ZIO – eine Bibliothek mit Grundelementen, die uns beim Umgang mit Parallelität helfen, und asyncchronologische Berechnung
  • STM – Transaktion
  • Zukunft – in der Scala-Sprache integriert

Java vs. Scala

Hier sind die wichtigsten Unterschied zwischen Java und Scala.

Scala Javac
Kompakter und prägnanter Vergleichsweise größere Codeblöcke
Entworfen und entwickelt, um sowohl objekt- als auch funktionsorientierte Sprache zu sein.
Unterstützt eine Vielzahl funktionaler Programmierfunktionen wie Parallelität und Unveränderlichkeit.
Ursprünglich als objektorientierte Sprache entwickelt und in den letzten Tagen mit der Unterstützung funktionaler Programmierfunktionen begonnen. Als funktionale Programmiersprache ist sie immer noch nicht stark.
Verwendet ein Akteurmodell zur Unterstützung der modernen Parallelität Verwendet das herkömmliche Thread-basierte Modell für Parallelität.
Unterstützt Frameworks – Play, Lift Unterstützt Spring, Grails und vieles mehr
Unterstützt verzögerte Auswertung Unterstützt keine verzögerte Auswertung
Keine statischen Mitglieder Enthält statische Mitglieder
Unterstützt die Überlastung des Bedieners Unterstützt keine Überlastung des Bedieners
Die Kompilierung des Quellcodes ist vergleichsweise langsam Die Kompilierung des Quellcodes ist schneller als bei Scala
Merkmale – wirken wie Java-8-Schnittstellen Java 8-Schnittstellen versuchen, die Lücke zwischen Klassen und Schnittstellen zu schließen
Umschreiben ist erforderlich Ein Umschreiben ist nicht erforderlich
Keine Garantie für fehlerfreie Codes Vollständige Garantie für kleinere Mängel
Unterstützt Abwärtskompatibilität. Scala unterstützt keine Abwärtskompatibilität.
Operatoren werden in Java unterschiedlich behandelt und sind keine Methodenaufrufe. Alle Operatoren für Einträge werden über eine in Scala aufgerufene Methode ausgeführt.
Unterstützt Mehrfachvererbungen mithilfe von Klassen, jedoch nicht durch abstrakte Klassen Unterstützt keine Mehrfachvererbung über Klassen, sondern über Schnittstellen
Code ist in kompakter Form geschrieben. Der Code ist in Langform geschrieben.
Scala enthält nicht das Schlüsselwort static. Java enthält das Schlüsselwort static.

Zusammenfassung

In diesem Tutorial haben Sie gelernt, wie Sie mit Scala beginnen. Sie haben auch die funktionalen und objektorientierten Funktionen kennengelernt. Sie haben auch die Ähnlichkeiten und Unterschiede zwischen Java und Scala entdeckt. Dieses Tutorial sollte Ihnen mit einer Vielzahl von Beispielen geholfen haben, die gut demonstriert werden.