Kotlin Academy · Lektion

Nästlade klasser

Klasser inuti klasser

Lektion 1 av 413 steg

Nästlade klasser är en gratis lektion i Kotlin Academy på CoddyKit. Detta är lektion 1 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för Kotlin Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Kotlin Academy innehåller totalt 4 lektioner.

Klasser inuti klasser

I Kotlin kan Ni deklarera en klass inuti en annan klass. Som standard är en sådan klass nästlad och innehåller ingen referens till den yttre instansen.

class Outer {
    class Nested {
        fun hello() = "Hi from Nested"
    }
}

fun main() {
    println(Outer.Nested().hello())
}

Skapa en nästlad instans

Eftersom en nästlad klass är fristående skapar Ni den via den yttre klassens namn utan en yttre instans: Outer.Nested().

class Computer {
    class Cpu {
        val cores = 8
    }
}

fun main() {
    val cpu = Computer.Cpu()
    println(cpu.cores)
}

Ingen åtkomst till yttre medlemmar

En nästlad klass kan inte se den yttre klassens instansmedlemmar eftersom den saknar en referens till den yttre instansen. Den fungerar som en toppnivåklass med ett namn som omfång.

class Bank {
    val name = "ACME"
    class Branch {
        fun describe() = "A branch"
    }
}

fun main() {
    println(Bank.Branch().describe())
}

Varför nästla alls?

Nästling uttrycker en logisk gruppering: den inre typen hör begreppsmässigt till den yttre, vilket förbättrar organisation och namnområden.

class Http {
    class Request(val url: String)
}

fun main() {
    val r = Http.Request("/home")
    println(r.url)
}

Nästlad klass med egenskaper

Nästlade klasser är vanliga klasser: de kan ha konstruktorer, egenskaper och metoder.

class Garage {
    class Car(val model: String) {
        fun honk() = "$model: beep"
    }
}

fun main() {
    println(Garage.Car("Tesla").honk())
}

Åtkomst till companion- eller statikliknande medlemmar

Nästlade klasser kan refereras till var som helst med hjälp av det yttre namnet, på samma sätt som en statisk nästlad klass i Java.

class Config {
    class Defaults {
        val timeout = 30
    }
}

fun main() {
    println(Config.Defaults().timeout)
}

Flera nästlade klasser

En yttre klass kan innehålla flera nästlade klasser för att gruppera relaterade typer.

class Shapes {
    class Circle(val r: Int)
    class Square(val side: Int)
}

fun main() {
    println(Shapes.Circle(5).r)
    println(Shapes.Square(4).side)
}

Nästlad inuti nästlad

Ni kan nästla klasser på flera nivåer, men djup nästling kan försämra läsbarheten.

class A {
    class B {
        class C {
            val value = 42
        }
    }
}

fun main() {
    println(A.B.C().value)
}

Nästlad jämfört med toppnivå

Funktionellt fungerar en nästlad klass som en klass på toppnivå; den enda skillnaden är dess kvalificerade namn. Välj nästling när relationen gör koden tydligare.

class Order {
    class Item(val price: Int)
}

fun main() {
    val total = Order.Item(10).price + Order.Item(5).price
    println(total)
}

En praktisk gruppering

Att gruppera en builder-resultattyp under dess ägare känns naturligt.

class Parser {
    class Result(val ok: Boolean, val message: String)

    fun parse(text: String) = Result(text.isNotEmpty(), "parsed")
}

fun main() {
    val res = Parser().parse("data")
    println("${res.ok} ${res.message}")
}

En viktig regel att komma ihåg

Nyckelordet som gör att en klass innehåller en referens till den yttre instansen är inner. Utan det är en nästlad klass statikliknande och isolerad.

class Box {
    class Lid
}

fun main() {
    println(Box.Lid() != null)
}

Snabbtest

Testa era kunskaper om nästlade klasser.

Besvara frågan i den interaktiva lektionen

Sammanfattning

Ni har lärt er om nästlade klasser:

Deklareras inuti en annan klass; standardvärdet är class (nästlad).
Har ingen referens till den yttre instansen och kan inte komma åt yttre medlemmar.
Skapas via det yttre namnet: Outer.Nested().
Utmärkta för logisk gruppering och namnrymder.

class Outer {
    class Nested { val x = 1 }
}

fun main() {
    println(Outer.Nested().x)
}

Gratis att börja

Lär dig Kotlin med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 51
Lektioner: 203

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Nästlade klasser” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Kotlin Academy, inklusive ”Nästlade klasser”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i Kotlin Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Nästlade klasser”?

Klasser inuti klasser Ni övar på Kotlin Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Kotlin Academy?

Du behöver inga förkunskaper. Utbildningen i Kotlin Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 1 av 4.

Hur lång tid tar lektionen ”Nästlade klasser”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Kotlin Academy-lektionen?

Ja. Varje Kotlin Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till Kotlin Academy