Pakete in Kotlin

In Kotlin sind Pakete (engl. Packages) Sammlungen von verwandten Funktionen, Klassen, Objekten und Typdefinitionen. Sie dienen zur Strukturierung des Codes in logische Einheiten und helfen, Namenskonflikte zwischen identisch benannten Funktionen und Klassen in unterschiedlichen Teilen eines Programms zu vermeiden.

Die Organisation von Code in Form von Paketen ist besonders in großen Softwareprojekten von großer Bedeutung. Pakete helfen den Code übersichtlich zu halten. Sie erleichtern die Wartung und das Auffinden von spezifischen Code-Teilen. Zudem ermöglichen sie eine klare Trennung verschiedener Funktionsbereiche und fördern die Wiederverwendbarkeit von Code.

Anlage eines Pakets in Kotlin

Ein Paket wird mit dem Schlüsselwort package deklariert. Die Paketdefinition wird an den Beginn einer Datei gesetzt. Der gesamte Code in dieser Datei wird dann als Teil dieses spezifischen Pakets angesehen.

package finance

// Content of the package...

Mehrere Pakete können grundsätzlich in derselben Datei deklariert werden. Das ist aber in der Praxis nicht üblich. Normalerweise entspricht eine Datei einem Paket, um die Übersichtlichkeit und Wartbarkeit des Codes zu verbessern.

Dementsprechend erstellen wir für unser Projekt eine separate Datei mit dem Namen finance, in der alle Klassen und Funktionen definiert werden, die für die Abwicklung finanzieller Operationen relevant sind.

Um eine neue Kotlin-Datei zu erstellen, klicken wir im kotlin-Ordner mit der rechten Maustaste, wählen Neu und dann Kotlin-Klasse/Datei. Anschließend tragen wir den gewünschten Dateinamen ein:

Die neu erstellte Datei finance.kt wird im Editor geöffnet:

Anschließend definieren wir darin den folgenden Code:

package finance

class Invoice(val amount: Double)

fun payment(invoice: Invoice, accountNumber: String) {
    println("Invoice for ${invoice.amount} Euro has been paid from account $accountNumber")
}

In diesem Code ist ein finance Paket definiert, das eine Klasse Invoice mit einer Eigenschaft amount vom Typ Double beinhaltet. Diese Klasse repräsentiert eine Rechnung mit einem bestimmten Betrag.

Weiterhin gibt es eine Funktion pay, die ein Invoice-Objekt und eine Kontonummer als String akzeptiert und eine Nachricht auf der Konsole ausgibt, die bestätigt, dass die Rechnung bezahlt wurde und von welchem Konto das Geld abgebucht wurde.

Import eines Pakets in Kotlin

Angenommen, wir möchten die Funktionalitäten dieses Pakets in der Datei main.kt nutzen. Um Entitäten aus dem Paket einzubinden, muss die import-Anweisung verwendet werden. Es gibt verschiedene Möglichkeiten, Funktionalitäten aus dem Paket einzubinden. Man kann beispielsweise das gesamte Paket einbinden:

import finance*

Nach dem Paketnamen wird ein Punkt und ein Sternchen gesetzt, wodurch alle Typen aus diesem Paket importiert werden.

import finance.*

fun main() {
    val paidInvoice = invoiceAmountPaid(123.45)
    invoicePaidStatus(paidInvoice, "AB1234567890")
}

Da am Anfang der Datei alle Typen aus dem Paket finance importiert wurden, können wir die Klasse Invoice und die Funktion pay in der main-Funktion verwenden. Nach der Ausführung des Codes bekommen wir die folgende Ausgabe in der Konsole:

Invoice for 123.45 Euro has been paid from account AB1234567890

Man kann auch Typen, die im Paket definiert sind, einzeln importieren. Der Import einzelner Typen aus einem Paket erfolgt mit der Syntax import <Paketname>.<Typname>. In diesem konkreten Fall kann man die Klasse Invoice sowie die Funktion pay wie folgt importieren:

import finance.Invoice
import finance.payment

Pseudonyme in Kotlin

In Kotlin, wie in vielen anderen Programmiersprachen, können Pseudonyme (oder Aliase) verwendet werden, um Klassen, Funktionen oder andere Elemente umzubenennen oder neu zuzuweisen. Diese Funktion ist besonders nützlich, um die Lesbarkeit des Codes zu erhöhen, Namenskonflikte zu vermeiden oder einfach bestimmte Elemente unter einem kürzeren oder spezifischeren Namen zu referenzieren.

Zum Beispiel beim Import einer Klasse oder Funktion aus einem Paket kann man einen Alias mit Hilfe des Schlüsselworts as definieren. 

import finance.Invoice as invoiceAmountPaid    // Import of class 'Invoice' as alias 'invoiceAmountPaid'
import finance.payment as invoicePaidStatus    // Import of function 'payment' as alias 'invoicePaidStatus'

fun main() {
    val paidInvoice = invoiceAmountPaid(123.45)
    invoicePaidStatus(paidInvoice, "AB1234567890")
}

Pseudonyme können besonders nützlich sein, wenn man aus verschiedenen Paketen Elemente mit demselben Namen importieren möchte. Zum Beispiel nehmen wir an, in unserem Projekt gibt es noch ein Paket namens mailbox, in dem eingehende Post inkl. Rechnungen entsprechend registriert und für Weiterbearbeitung vorbereitet wird. Also, legen wir dafür eine neue Datei mailbox.kt an und definieren den folgenden Code:

package mailbox

class Invoice(val amount: Double)

fun payment(invoice: Invoice, invoiceNumber: String) {
    println("Invoice with number $invoiceNumber for ${invoice.amount} EUR has been registered and for a payment prepared")
}

In diesem Code haben wir ein Paket namens mailbox erstellt. Die Klasse Invoice repräsentiert eine Rechnung und nimmt die Rechnungssumme (amount) als Parameter. Die Funktion invoice registriert (in einer vereinfachten Form) die eingehende Rechnung und gibt eine Nachricht auf der Konsole aus. 

import mailbox.Invoice as invoiceAmountToPay
import mailbox.payment as invoicePreparedForPayment
import finance.Invoice as invoiceAmountPaid
import finance.payment as invoicePaidStatus

fun main() {
    val receivedInvoice = invoiceAmountToPay(123.45)
    invoicePreparedForPayment(receivedInvoice, "IN987654")

    val paidInvoice = invoiceAmountPaid(123.45)
    invoicePaidStatus(paidInvoice, "AB1234567890")
}

Standardpakete in Kotlin

Kotlin verfügt über eine Reihe von eingebauten Paketen, die standardmäßig in jeder Kotlin-Datei verfügbar sind. Diese Pakete umfassen grundlegende Funktionalitäten und Klassen, die in vielen Programmen häufig verwendet werden. Hier ist eine Übersicht über einige dieser Pakete:

• kotlin.*: Dieses Paket enthält die grundlegendsten Klassen und Funktionen von Kotlin, wie grundlegende Datentypen (Int, String, etc.), Kontrollstrukturen und grundlegende Funktionen.

• kotlin.annotation.*: In diesem Paket sind Annotationen definiert, die in Kotlin verwendet werden können, um zusätzliche Informationen über Programmteile zu geben.

• kotlin.collections.*: Dieses Paket enthält Klassen und Funktionen für die Arbeit mit Kollektionen wie Listen, Sets und Maps.

• kotlin.comparisons.*: Hier finden sich Hilfsfunktionen für den Vergleich von Objekten, was insbesondere beim Sortieren von Kollektionen nützlich ist.

• kotlin.io.*: Dieses Paket bietet Funktionen und Klassen für Ein- und Ausgabeoperationen, wie das Lesen und Schreiben von Dateien.

• kotlin.ranges.*: In diesem Paket sind Klassen und Funktionen enthalten, die das Arbeiten mit Bereichen und Intervallen vereinfachen, wie zum Beispiel die Range-Klassen.

• kotlin.sequences.*: Sequences in Kotlin sind ähnlich zu Streams in Java und bieten eine Möglichkeit, Elemente faul (lazy) zu verarbeiten.

• kotlin.text.*: Dieses Paket enthält Funktionen und Klassen zur Arbeit mit Text und Strings, wie String-Manipulation und Regex-Operationen.

Da diese Pakete automatisch in jeder Kotlin-Datei verfügbar sind, ist es nicht notwendig, sie explizit zu importieren. Diese Funktion macht die Entwicklung in Kotlin bequemer und reduziert die Notwendigkeit von umfangreichen Importlisten am Anfang von Dateien.