Kotlin Academy · Aula

Classes Aninhadas

Classes dentro de classes

Classes Aninhadas é uma aula grátis de Kotlin Academy no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Kotlin Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Kotlin Academy inclui 4 aulas no total.

Classes dentro de classes

O Kotlin permite declarar uma classe dentro de outra classe. Por padrão, essa classe é aninhada e não mantém uma referência à instância externa.

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

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

Criando uma instância aninhada

Como uma classe aninhada é independente, você a cria por meio do nome da classe externa, sem uma instância externa: Outer.Nested().

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

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

Sem acesso aos membros externos

Uma classe aninhada não pode acessar os membros de instância da classe externa porque não tem uma referência externa. Ela se comporta como uma classe de nível superior dentro do escopo de um nome.

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

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

Por que aninhar?

O aninhamento expressa um agrupamento lógico: o tipo interno pertence conceitualmente ao tipo externo, melhorando a organização e o espaço de nomes.

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

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

Classe aninhada com propriedades

Classes aninhadas são classes comuns: podem ter construtores, propriedades e métodos.

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

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

Acessando membros companheiros ou semelhantes a estáticos

Classes aninhadas podem ser referenciadas de qualquer lugar usando o nome da classe externa, de forma semelhante a uma classe aninhada estática em Java.

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

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

Várias classes aninhadas

Uma classe externa pode conter várias classes aninhadas para agrupar tipos relacionados.

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

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

Aninhada dentro de outra

É possível aninhar classes em mais de um nível, embora um aninhamento profundo possa prejudicar a legibilidade.

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

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

Aninhada versus de nível superior

Funcionalmente, uma classe aninhada é como uma classe de nível superior; a única diferença é o nome qualificado. Escolha o aninhamento quando a relação melhorar a clareza.

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

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

Um agrupamento prático

Agrupar o tipo de resultado de um construtor sob seu proprietário torna a leitura natural.

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}")
}

Regra principal para lembrar

A palavra-chave que faz uma classe manter uma referência à classe externa é inner. Sem ela, uma classe aninhada é semelhante a uma classe estática e fica isolada.

class Box {
    class Lid
}

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

Teste rápido

Teste sua compreensão sobre classes aninhadas.

Recapitulação

Você aprendeu sobre classes aninhadas:

Declaradas dentro de outra classe; por padrão, são class (aninhadas).
Não têm referência à instância externa; não podem acessar membros externos.
Criadas por meio do nome da classe externa: Outer.Nested().
São ótimas para agrupamento lógico e organização de nomes.

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

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

Perguntas Frequentes

A aula “Classes Aninhadas” é grátis?

Sim — o texto completo de “Classes Aninhadas” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Kotlin Academy, atualize para CoddyKit PRO. O curso de Kotlin Academy inclui 4 aulas no total.

O que vou aprender em “Classes Aninhadas”?

Classes dentro de classes Você pratica Kotlin Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Kotlin Academy?

Nenhuma experiência prévia é necessária. Kotlin Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.

Quanto tempo leva a aula “Classes Aninhadas”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Kotlin Academy?

Sim. Cada aula de Kotlin Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Kotlin Academy