Kurs
Einführung in Scala
3 Std.
27.2K
DataCamp hat kürzlich den ersten Scala-Kurs veröffentlicht: Introduction to Scala. Schau ihn dir an!
Sieh dir außerdem diese Tutorials an:
Einführung
Objektorientierte Programmierung (OOP) besteht im Kern aus Klassen und Objekten und bildet reale Konzepte wie Polymorphie und Vererbung ab.
OOP beschleunigt die Entwicklung, senkt Kosten und verbessert die Wartbarkeit. Der Hauptgrund: die Vielzahl an Features. Klassen und Objekte lassen sich je nach Bedarf wiederverwenden – anders als in Programmen ohne diese Struktur. Das führt zu hochwertigerer Software, die sich mit neuen Methoden und Attributen leicht erweitern lässt.
Angenommen, du betreibst einen Autoshowroom. Alle paar Monate erscheint ein neues Modell, und um Name und Features zu kommunizieren, müsstest du ohne OOP jedes Mal Methoden und Attribute neu definieren. Mit einem objektorientierten Programm, das eine Klasse car besitzt, fügst du für das neue Modell lediglich ein Objekt hinzu, das die Klassenmethoden und -attribute mit den passenden Informationen nutzt.
Eine Klasse kannst du dir als Entwurf oder Bauplan für Objekte vorstellen. Klassen besitzen in der Regel eigene Methoden (Verhalten) und Attribute.
Attribute unterscheiden Objekte voneinander und bestimmen deren Eigenschaften. Methoden funktionieren ähnlich wie Funktionen in der Programmierung und legen fest, wie die Instanz der Klasse arbeitet. Durch Methoden erhalten Objekte ihr Verhalten und man kann etwas mit ihnen tun.
Die Grafik oben veranschaulicht den Ablauf objektorientierter Programmierung und zeigt, wie eine Klasse aussieht. Es gibt eine class car mit attributes: fuel, max speed und möglichen weiteren Attributen wie model oder make. Außerdem sind verschiedene methods definiert, etwa refuel(), getFuel(), setSpeed() sowie mögliche zusätzliche Methoden wie change gear, start the engine oder stop the engine.
Sprichst du über ein konkretes Auto, hast du dafür ein Objekt – also eine Instanz der Klasse.
Kommen wir nun zur objektorientierten Programmierung in Scala.
Klassen und Objekte in Scala
Ähnlich wie in C++ und Java folgt OOP in Scala weitgehend denselben Konventionen. Es gibt classes und objects sowie constructors innerhalb der Klasse – das ist im Wesentlichen alles, was du für OOP in Scala brauchst.
Klassendeklaration
class Class_name{
// methods and attributes
}
Eine Klasse in Scala wird mit dem Schlüsselwort class gefolgt vom Klassennamen definiert; üblicherweise beginnt der Name mit einem Großbuchstaben. Es gibt einige optionale Angaben, die in der Klassendeklaration genutzt werden können: class-name, er sollte mit einem Großbuchstaben beginnen; superclass, der Name der Elternklasse, dem das Schlüsselwort extend vorangestellt wird; traits, eine durch Kommata getrennte Liste, die von der Klasse mit dem Schlüsselwort extend implementiert wird.
Eine Klasse kann in Scala nur von einer Elternklasse erben, Mehrfachvererbung wird also nicht unterstützt. Über Traits lässt sich Ähnliches jedoch erreichen.
Der Klassenkörper in Scala wird schließlich von geschweiften Klammern {} umschlossen.
// Name of the class is Car
class Car
{
// Class variables
var make: String = "BMW"
var model: String = "X7"
var fuel: Int = 40
// Class method
def Display()
{
println("Make of the Car : " + make);
println("Model of the Car : " + model);
println("Fuel capacity of the Car : " + fuel);
}
}
object Main
{
// Main method
def main(args: Array[String])
{
// Class object
var obj = new Car();
obj.Display();
}
}
Du kannst den obigen Code als class.scala speichern und im Terminal mit scala class.scala ausführen. Du solltest dann die folgende Ausgabe sehen.
Allerdings nutzt dieser Code die Möglichkeiten der OOP noch nicht wirklich aus. Die Ausgabe bleibt immer gleich, egal wie oft du ihn startest. Du hast statische Variablen in der Klasse definiert, deren Werte konstant bleiben – selbst wenn du unendlich viele neue Objekte erzeugst. Kurz: Du kannst damit keine Details zu einem Mercedes-Benz oder Ferrari ausgeben.
Konstruktor in Scala
Konstruktoren initialisieren in erster Linie den Zustand eines Objekts. Diese Initialisierung passiert bei der Objekterzeugung und wird nur einmal aufgerufen.
In Scala gibt es zwei Arten von Konstruktoren: Primary und Auxiliary. In diesem Tutorial lernst du den Primary Constructor kennen (Quelle: O'Reilly).
class Class_name(Parameter_list){
// methods, attributes
}
Der Primary Constructor teilt sich den Körper mit der Klasse und wird implizit zusammen mit der Klassendefinition erzeugt. Er beginnt bei der Klassendefinition und umfasst den gesamten Klassenkörper. Gibt es in einem Scala-Programm nur einen Konstruktor, spricht man vom Primary Constructor. Er kann null, einen oder mehrere Parameter besitzen.
Nehmen wir also das vorherige Beispiel und ergänzen diesmal den Primary Constructor, um den Effekt zu sehen.
Außerdem lernst du hier ein weiteres Merkmal: Eine Klasse kann mehrere Objekte bzw. Instanzen haben – und diese sind voneinander unabhängig.
// Name of the class is Car
class Car(make: String, model: String, fuel: Int)
{
// Class method
def Display()
{
println("Make of the Car : " + make);
println("Model of the Car : " + model);
println("Fuel capacity of the Car : " + fuel);
}
}
object Main
{
// Main method
def main(args: Array[String])
{
// Multiple Class object
var obj1 = new Car("BMW", "X7", 40);
var obj2 = new Car("Mercedes Benz", "S350D", 50);
obj1.Display();
obj2.Display();
}
}
Schauen wir uns schnell die Ausgabe an:
Ganz schön praktisch, oder? Mit Hilfe eines Konstruktors konntest du deutlich flexibelere Ergebnisse erzeugen.
Objekte in Scala deklarieren
Das Deklarieren von Objekten in Scala nennt man auch Instanziieren oder Erzeugen einer Klasse. Wie Klassen sind Objekte eine grundlegende Einheit der OOP.
Ein Objekt kann drei Merkmale besitzen (Quelle: GeeksforGeeks):
State:Attribute eines Objekts repräsentieren es und spiegeln seine Eigenschaften wider.Behavior:Methoden eines Objekts repräsentieren es und zeigen, wie es mit anderen Objekten interagiert.Identity:Eine eindeutige Identität ermöglicht es dem Objekt, mit anderen Objekten zu interagieren.
Betrachte einen Hund als Objekt und sieh dir dazu das folgende Diagramm zu Identität, Zustand und Verhalten an.
Alle Instanzen bzw. Objekte teilen sich die Klassenattribute und -methoden. Eine einzelne Klasse kann mehrere Objekte haben, wie du hier gesehen hast. Die Zustände bzw. Werte der einzelnen Objekte sind jedoch einzigartig.
Abschließend schreiben wir Code, der Primary Constructor, Klassenvariablen, Attribute und Methoden in einem Beispiel vereint.
Unten siehst du eine grafische Darstellung der Bausteine der Klasse Motorcycle.
Der folgende Code ist weitgehend selbsterklärend. Auf hoher Ebene prüft er, ob der Motorradmotor on oder off ist. Zu Beginn ist der Motor aus, der Status wird ausgegeben und dann eingeschaltet.
class Motorcycle(make:String,color:String) {
var engineState: Boolean = false;
def startEngine() {
if (engineState == true){
println("The engine is already on.");
}
else {
engineState = true
println("The engine is now on.");
}
}
def showAtts() {
println("This motorcycle is a "+ color + " " + make);
if (engineState == true){
println("The engine is on.");
}
else{
println("The engine is off.");
}
}
}
object Main
{
def main (args: Array[String])
{
var m = new Motorcycle("BMW K 1600 GTL","White");
println("Calling showAtts...");
m.showAtts();
println("------");
println("Starting engine...");
m.startEngine();
println("------");
println("Calling showAtts...");
m.showAtts();
println("------");
println("Starting engine...");
m.startEngine();
}
}
Glückwunsch!
Glückwunsch – du hast dieses Tutorial abgeschlossen.
Du weißt jetzt, wie man Klassen und Methoden deklariert, Objekte instanziiert, ihre Attribute setzt und Instanzmethoden in Scala aufruft. Diese Konzepte helfen dir nicht nur in Scala, sondern auch in anderen Programmiersprachen.
OOP-Konzepte sind spannend und zugleich sehr mächtig. Sie geben deinem Code eine neue Dimension und machen ihn wiederverwendbar. Mit wachsender Programmgröße steigt die Komplexität. In der OOP steckt viel Substanz: Vererbung, Polymorphie, Instanzmethoden. Eine weitere starke Technik ist das Singleton. Gute Designprinzipien halten deinen Code strukturiert und lesbar. Für mehr zu Design-Patterns lohnt sich dieses Buch.
Stell gerne Fragen zu diesem Tutorial in den Kommentaren unten.
Und vergiss nicht, den neuen Scala-Kurs auf DataCamp zu machen: Introduction to Scala.
Themen
