Klassen, Objekte und Paketierung
Verstehen Sie, wie Sie Klassen definieren, Objekte erstellen und Ihren Code in Scala mithilfe von Paketen organisieren.
Klassen, Objekte und Paketierung ist eine kostenlose Scala for Backend Engineering & Functional Programming-Lektion auf CoddyKit. Dies ist Lektion 1 von 2. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Scala for Backend Engineering & Functional Programming-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Scala for Backend Engineering & Functional Programming-Kurs umfasst insgesamt 2 Lektionen.
Willkommen bei OOP in Scala
In dieser Lektion tauchen Sie in den Kern der objektorientierten Programmierung (OOP) in Scala ein. Wir untersuchen, wie Sie Ihren Code mithilfe von Klassen strukturieren, Instanzen dieser Klassen (Objekte) erstellen und mit Paketen für Ordnung sorgen.
Beginnen wir mit der Entwicklung robuster und modularer Anwendungen!
Klassen: Die Baupläne
Stellen Sie sich eine Klasse als Bauplan zum Erstellen von Objekten vor. Sie definiert die Eigenschaften (Daten) und das Verhalten (Methoden), die ihre Objekte haben. Klassen enthalten selbst keine Daten, sondern beschreiben, welche Daten ein Objekt enthalten kann.
Hier ist eine grundlegende Klassendefinition:
class Car {
// Properties and methods go here
}Eine einfache Klasse definieren
In Scala definieren Sie eine Klasse mit dem Schlüsselwort class, gefolgt von ihrem Namen. Erstellen wir eine einfache Klasse Dog. Sie kann bisher noch nicht viel, aber sie ist ein Anfang!
Führen Sie diese leere Klassendefinition aus:
class Dog {
// This dog has no properties or behaviors yet
}
object Main {
def main(args: Array[String]): Unit = {
println("Dog class defined!")
}
}Objekte (Instanzen) erstellen
Ein Objekt ist eine Instanz einer Klasse. Es ist ein konkretes „Ding“, das aus dem Bauplan erstellt wurde. Um ein Objekt zu erstellen, verwenden Sie das Schlüsselwort new, gefolgt vom Klassennamen.
Jedes Objekt erhält einen eigenen Datensatz, wie von der Klasse festgelegt.
class Dog {
// Still an empty dog blueprint
}
object Main {
def main(args: Array[String]): Unit = {
val myDog = new Dog()
val yourDog = new Dog()
println("Two dog objects created!")
}
}Eigenschaften zu einer Klasse hinzufügen
Klassen können Eigenschaften (auch Felder oder Member genannt) enthalten, in denen Daten gespeichert werden. Sie können diese im Konstruktor der Klasse definieren, sodass sie beim Erstellen eines Objekts als Parameter angegeben werden.
Geben wir unserem Dog einen name und eine breed:
class Dog(val name: String, val breed: String) {
// 'val' makes name and breed immutable properties
}
object Main {
def main(args: Array[String]): Unit = {
val myDog = new Dog("Buddy", "Golden Retriever")
println(s"My dog's name is ${myDog.name} and breed is ${myDog.breed}.")
}
}Verhalten hinzufügen (Methoden)
Klassen definieren außerdem Methoden. Dabei handelt es sich um Funktionen, die das Verhalten des Objekts beschreiben. Methoden können auf die Eigenschaften des Objekts zugreifen und diese ändern.
Unser Dog kann jetzt bark():
class Dog(val name: String, val breed: String) {
def bark(): String = {
s"${name} says Woof!"
}
}
object Main {
def main(args: Array[String]): Unit = {
val myDog = new Dog("Max", "Labrador")
println(myDog.bark())
}
}Scalas `object` (Singletons)
In Scala definiert das Schlüsselwort object ein Singleton. Das bedeutet, dass davon immer nur eine Instanz existieren kann. Sie verwenden nicht new, um es zu erstellen, sondern verweisen einfach auf seinen Namen.
Singletons werden häufig für Hilfsmethoden oder einen einzigen Einstiegspunkt verwendet.
object MathUtils {
def add(a: Int, b: Int): Int = a + b
def subtract(a: Int, b: Int): Int = a - b
}
object Main {
def main(args: Array[String]): Unit = {
val sum = MathUtils.add(5, 3)
println(s"5 + 3 = ${sum}")
}
}Begleitobjekte
Ein Begleitobjekt ist ein object, das denselben Namen wie eine class hat und in derselben Quelldatei definiert ist. Beide haben besonderen Zugriff auf die privaten Member des jeweils anderen.
- Die Klasse enthält instanzspezifische Daten und Methoden.
- Das Begleitobjekt enthält statisch wirkende Methoden oder Factory-Methoden.
class Circle(val radius: Double) {
def area: Double = Circle.PI * radius * radius
}
object Circle {
// This is the companion object for the Circle class
val PI: Double = 3.14159
def apply(r: Double): Circle = new Circle(r) // Factory method
}
object Main {
def main(args: Array[String]): Unit = {
val c = Circle(5.0) // Using the apply method from companion object
println(s"Circle area: ${c.area}")
}
}Code mit Paketen organisieren
Pakete bieten eine Möglichkeit, Ihre Klassen und Objekte in logischen Gruppen zu organisieren. Dadurch werden Namenskonflikte verhindert und die Wartbarkeit des Codes verbessert.
Stellen Sie sie sich als Ordner für Ihren Code vor. Mit dem Schlüsselwort package wird das Paket am Anfang einer Scala-Datei deklariert.
package com.coddykit.animals
class Cat(val name: String) {
def meow(): String = s"${name} says Meow!"
}
// This class is now inside com.coddykit.animals packageMember aus Paketen importieren
Um in einem anderen Paket definierte Klassen oder Objekte zu verwenden, müssen Sie sie importieren. Das Schlüsselwort import macht die Member eines Pakets in Ihrem aktuellen Gültigkeitsbereich verfügbar.
Importieren wir unsere Klasse Cat:
package com.coddykit.app
// Define a class in a package first for import example
package com.coddykit.animals {
class Cat(val name: String) {
def meow(): String = s"${name} says Meow!"
}
}
import com.coddykit.animals.Cat
object Main {
def main(args: Array[String]): Unit = {
val myCat = new Cat("Whiskers")
println(myCat.meow())
}
}Schnelltest: Klasse oder Objekt?
Sie haben Klassen, Objekte und Pakete kennengelernt. Testen wir Ihr Verständnis!
Zusammenfassung: Klassen, Objekte, Pakete
Hervorragende Arbeit! Sie haben die Grundlagen der objektorientierten Programmierung (OOP) in Scala kennengelernt:
- Klassen sind Baupläne, die Eigenschaften und Verhalten definieren.
- Objekte sind Instanzen, die mithilfe von
newaus Klassen erstellt werden. - Scalas Schlüsselwort
objecterstellt Singletons, die für Hilfsfunktionen oder Factorys nützlich sind. - Begleitobjekte ergänzen Klassen um statisch wirkende Member.
- Pakete organisieren Ihren Code, verhindern Namenskonflikte und verbessern seine Struktur.
Als Nächstes bauen wir auf dieser Grundlage auf und beschäftigen uns mit Vererbung und Polymorphie!
Häufig gestellte Fragen
Ist die Lektion „Klassen, Objekte und Paketierung“ kostenlos?
Ja — der vollständige Text von „Klassen, Objekte und Paketierung“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Scala for Backend Engineering & Functional Programming-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Scala for Backend Engineering & Functional Programming-Kurs umfasst insgesamt 2 Lektionen.
Was lerne ich in „Klassen, Objekte und Paketierung“?
Verstehen Sie, wie Sie Klassen definieren, Objekte erstellen und Ihren Code in Scala mithilfe von Paketen organisieren. Du übst Scala for Backend Engineering & Functional Programming mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um Scala for Backend Engineering & Functional Programming zu starten?
Keine Vorkenntnisse erforderlich. Scala for Backend Engineering & Functional Programming auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 2.
Wie lange dauert die Lektion „Klassen, Objekte und Paketierung“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser Scala for Backend Engineering & Functional Programming-Lektion Code schreiben und ausführen?
Ja. Jede Scala for Backend Engineering & Functional Programming-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- Klassen, Objekte und Paketierung
- Vererbung und Polymorphie