0Pricing
Kotlin Academy · Lektion

companion object: Statische Member in Kotlin

Fügen Sie Klassen companion objects hinzu, um statische Methoden und Konstanten zu simulieren.

companion object: Statische Member in Kotlin ist eine kostenlose Kotlin Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. 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 Kotlin Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Kotlin Academy-Kurs umfasst insgesamt 4 Lektionen.

Kein static, aber ein companion object

Kotlin verfügt über kein static-Schlüsselwort. Stattdessen stellt ein innerhalb einer Klasse deklariertes companion object Member auf Klassenebene (ähnlich wie statische Member) bereit.

Ein companion object deklarieren

Fügen Sie ein companion object in eine Klasse ein. Seine Member können als ClassName.member aufgerufen werden.

class MathUtils {
    companion object {
        fun square(x: Int) = x * x
    }
}
fun main() {
    println(MathUtils.square(5)) // 25
}

Konstanten im companion object

Konstanten befinden sich typischerweise im companion object, häufig zusammen mit const val für Literale zur Compile-Zeit.

class HttpClient {
    companion object {
        const val DEFAULT_TIMEOUT = 5000
        const val USER_AGENT = "MyApp/1.0"
    }
}
fun main() {
    println(HttpClient.DEFAULT_TIMEOUT)
    println(HttpClient.USER_AGENT)
}

Benanntes companion object

Sie können dem companion object einen Namen geben. Sowohl ClassName.member als auch ClassName.CompanionName.member funktionieren.

class Database {
    companion object Factory {
        fun create() = Database()
    }
}
fun main() {
    val db1 = Database.create()       // works
    val db2 = Database.Factory.create() // also works
    println("$db1 / $db2")
}

Factory-Method-Pattern

Verwenden Sie das Companion-Objekt, um Instanzen mit Validierungs- oder alternativer Erstellunglogik zu erzeugen.

class User private constructor(val name: String, val email: String) {
    companion object {
        fun create(name: String, email: String): User {
            require(email.contains("@")) { "invalid email" }
            return User(name, email)
        }
    }
}
fun main() {
    val u = User.create("Ada", "ada@example.com")
    println("${u.name} <${u.email}>")
}

Interfaces implementieren

Das Companion-Objekt selbst kann Interfaces implementieren – nützlich, um es mit Klassen zu kombinieren, die einen statisch wirkenden Vertrag benötigen.

interface Loadable<T> { fun load(): T }
class Config(val data: String) {
    companion object : Loadable<Config> {
        override fun load() = Config("loaded data")
    }
}
fun main() {
    println(Config.load().data)
}

@JvmStatic für Java-Interop

Annotieren Sie Mitglieder des Companion-Objekts mit @JvmStatic, um sie für Java-Aufrufer als echte statische Methoden bereitzustellen.

class Util {
    companion object {
        @JvmStatic
        fun greet(name: String) = "Hello, $name!"
    }
}
fun main() {
    println(Util.greet("Kotlin"))
    // In Java: Util.greet("Java")
}

Auf das Companion-Objekt selbst zugreifen

ClassName.Companion verweist direkt auf das Companion-Objekt. Verwenden Sie dies, wenn Sie es als Argument übergeben.

class Counter {
    companion object {
        fun greet() = "hi from companion"
    }
}
fun main() {
    val ref = Counter.Companion
    println(ref.greet())
}

Companion-Objekt vs. Top-Level

Für Hilfsfunktionen, die nicht zu einer Klasse gehören, sollten Sie Top-Level-Funktionen gegenüber einer Klasse bevorzugen, die nur ein Companion-Objekt enthält.

// File-level — usually cleaner:
fun greet(name: String) = "Hi, $name!"
// Versus:
class Greeter { companion object { fun greet(n: String) = "Hi, $n!" } }
fun main() {
    println(greet("Ada"))
    println(Greeter.greet("Ada"))
}

Ein Companion-Objekt pro Klasse

Eine Klasse kann höchstens ein Companion-Objekt besitzen. Bei Bedarf können innere reguläre Objekte zusätzlichen gemeinsamen Zustand aufnehmen.

class Service {
    companion object {
        val version = "1.0"
    }
    object InternalHelper { fun log() = println("internal") }
}
fun main() {
    println(Service.version)
    Service.InternalHelper.log()
}

Erweiterungsfunktionen des Companion-Objekts

Sie können das Companion-Objekt außerhalb der Klasse erweitern und so pseudo-statische Hilfsfunktionen hinzufügen.

class Lib {
    companion object
}
fun Lib.Companion.helper() = "added later"
fun main() {
    println(Lib.helper())
}

Kurztest

Was entspricht in Kotlin den static-Mitgliedern von Java?

Zusammenfassung

Kotlin besitzt kein static. Verwenden Sie ein Companion-Objekt für klassenbezogene Mitglieder – Konstanten, Factorys und Interface-Implementierungen. Annotieren Sie es für die Java-Interop mit @JvmStatic oder erweitern Sie es mit Erweiterungsfunktionen für pseudo-statische Hilfsfunktionen.

Häufig gestellte Fragen

Ist die Lektion „companion object: Statische Member in Kotlin“ kostenlos?

Ja — der vollständige Text von „companion object: Statische Member in Kotlin“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Kotlin Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Kotlin Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „companion object: Statische Member in Kotlin“?

Fügen Sie Klassen companion objects hinzu, um statische Methoden und Konstanten zu simulieren. Du übst Kotlin Academy 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 Kotlin Academy zu starten?

Keine Vorkenntnisse erforderlich. Kotlin Academy 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 2 von 4.

Wie lange dauert die Lektion „companion object: Statische Member in Kotlin“?

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 Kotlin Academy-Lektion Code schreiben und ausführen?

Ja. Jede Kotlin Academy-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

  1. object-Deklaration: Kotlin-Singletons
  2. companion object: Statische Member in Kotlin
  3. Anonyme Objekte und Object Expressions
  4. Factory-Methoden mit companion object
← Zurück zu Kotlin Academy