Scala-Tutorial

Zusammenfassung des Scala-Tutorials

Dieses Scala-Tutorial behandelt alle Aspekte und Themen von Scala. Sie lernen alle Grundlagen von Grund auf, wie Was ist Scala, den Installationsprozess von Scala, Scala-Programme, Scala-Funktionen, Lazy Evaluation, Typschnittstelle, Klassen und Objekte, Vererbung, Abstraktionen, Java und Scala-Unterschiede usw.

Scala ist eine skalierbare Sprache, die zum Schreiben von Software für mehrere Plattformen verwendet wird. Daher erhielt sie den Namen „Scala“. Diese Sprache soll die Probleme von lösen Java und ist gleichzeitig 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 leicht zu erlernen, Java Entwickler. Es wird in den letzten Jahren zu einer der beliebtesten Sprachen.
• 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 Java
• 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.

Wenn wir dem Link folgen, werden wir zu zwei Optionen geführt, die wir wählen können, um Scala auf unseren Maschinen zu installieren. Für dieses Scala-Tutorial laden wir die IntelliJ IDEA.

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.

Schritt 1) Community Edition auswählen
Klicken Sie auf der Seite im Dropdown-Menü auf die Community Edition.

Es bietet uns die Möglichkeit, die IntelliJ IDE zusammen mit JBR herunterzuladen, die eine JDK-Implementierung enthält (Java Development Kit) OpenJDK, das Scala benötigt, um den Code zu kompilieren und auszuführen.

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

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

Wenn Sie zufällig nicht die Version mit dem JDK heruntergeladen haben, erhalten wir dennoch eine Eingabeaufforderung, wo wir den Download durch Aktivieren des Kontrollkästchens prüfen können.

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

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.

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.

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.

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.

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.

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

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

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.

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.

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“

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

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.

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.

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, beides Android Entwicklung und 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 Abwicklung, Integrierung, Speicherung und

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 an der Stelle ausgewertet, an der sie definiert ist. Dies wird allgemein als „Eager-Evaluation“ bezeichnet. Sie wird nur ausgewertet, wenn später im Code auf sie verwiesen wird.

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 durch 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 später wiederverwendet werden, ohne dass er erneut ausgewertet 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.

Diese Art von Methoden werden jedoch nicht empfohlen, da sie eine Blackbox zu sein scheinen, die ein System auf unbekannte Weise beeinflussen kann. Sie sind außerdem nicht testbar. Durch explizite Eingabe- und Ausgabetypen 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 bestimmten Kriterien entspricht, ähnlich wie wir es in einer Switch-Anweisung in Java oder in einer Reihe von if/else-Anweisungen. Die Sprache verfügt über Mustervergleich, mit dem wir prüfen können, ob eine Variable von einem bestimmten Typ ist. Mustervergleich in Scala ist leistungsstark und kann verwendet werden, um die Komponenten zu destrukturieren, die eine Unapply-Methode haben, um die Felder, an denen wir interessiert sind, direkt aus der Variable abzurufen, die wir vergleichen.

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

Es ist möglich, Werte zu erstellen, die von anderen Funktionen in Scala nicht geändert werden können, indem man das Schlüsselwort val verwendet. Dies wird erreicht in Java indem wir das Schlüsselwort final verwenden. In Scala tun wir dies, indem wir beim Erstellen einer Variablen das Schlüsselwort val verwenden, anstatt var zu verwenden, was die Alternative ist, die wir zum Erstellen einer veränderbaren Variable 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.

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 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 Vererbungsarten (wie einfach, mehrstufig, mehrfach, hierarchisch, hybrid), die viele Gemeinsamkeiten mit traditionellen Formen in Java. Sie können sowohl von Klassen als auch von Merkmalen erben. Sie können die Mitglieder einer Klasse mit dem Schlüsselwort „extends“ in eine andere Klasse vererben. Dies ermöglicht die 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.

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

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.

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 Merkmal oder die abstrakte Klasse erweitern. Sie können Merkmale verwenden, um Verträge darüber zu erstellen, was unsere Anwendung tun kann, und diese Methoden dann später implementieren.

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 neuen Funktionen, die nach Version 2.1 hinzugefügt wurden. Sie dienen in erster Linie dazu, den geschlossenen Klassen neue Funktionen 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 der OOP werden Programme erstellt, indem Daten und die Funktionen, die auf diese Daten zugreifen, in eng miteinander verbundene Einheiten gruppiert werden. Objekte tragen ihre Daten in den Feldern und Methoden, die auf sie zugreifen. Bei diesem Programmierstil sind die Daten die Hauptabstraktion, da die erstellten Methoden dazu bestimmt sind, auf die Daten zuzugreifen.

Funktionsprogrammierungtrennt dagegen Daten und die Funktionen, die auf 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 als First-Class-Citizens anerkennt, sodass sie als Werte an andere Funktionen übergeben und auch als Werte zurückgegeben werden können. Die Kombination dieser beiden Paradigmen hat Scala zu einer hervorragenden Wahl für die Entwicklung komplexer Software in verschiedenen Branchen, wie beispielsweise Data Science, gemacht.

Wichtige Frameworks auf Scala

Hier sind einige wichtige Frameworks von Scala

• Spielen 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.
• Lift 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 asynchrone Datenverarbeitung und unterstützen so die Parallelität.
• Akka – Toolkit, das das Actor-Parallelitätsmodell verwendet. Es gibt eine Reihe von Akteuren, die handeln, wenn sie Nachrichten empfangen.
• Parallelität mit Threads aus Java kann auch 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 der Java Ökosystem.

• Ureinwohner Java Themen
• Fasern aus Bibliotheken wie Vertex
• ZIO – eine Bibliothek mit Primitiven, die uns bei der Bewältigung von Parallelität und asynchronen Berechnungen helfen
• STM – Transaktion
• Zukunft – in der Scala-Sprache integriert

Java Vergleich mit Scala

Hier sind die wichtigsten Unterschied zwischen Java und Scala.

Scala	Java
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 unterstützt seit Kurzem funktionale Programmierfunktionen. Als funktionale Programmiersprache ist sie jedoch noch nicht so 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 Operatorüberladung	Unterstützt keine Operatorüberladung
Die Kompilierung des Quellcodes ist vergleichsweise langsam	Die Kompilierung des Quellcodes ist schneller als bei Scala
Eigenschaften – benimm dich wie Java 8 Schnittstellen	Java 8 Schnittstellen versuchen, die Lücke zwischen Klassen und Schnittstellen zu überbrücken
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 unterschiedlich behandelt in Java und sind keine Methodenaufrufe.	Alle Operatoren für Einträge erfolgen über eine in Scala aufgerufene Methode.
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. Dieses Tutorial sollte Ihnen mit einer Vielzahl gut demonstrierter Beispiele geholfen haben.