Kotlin Academy · Aula

Classes Internas

Acesse o escopo externo

Classes Internas é uma aula grátis de Kotlin Academy no CoddyKit. Esta é a aula 2 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.

A palavra-chave interna

Marcar uma classe aninhada como inner fornece a ela uma referência à instância externa, permitindo que acesse os membros da classe externa.

class Outer {
    val msg = "Hello"
    inner class Inner {
        fun show() = msg
    }
}

fun main() {
    println(Outer().Inner().show())
}

Criando uma instância interna

Como uma classe interna precisa de uma instância externa, ela é criada a partir de uma: Outer().Inner().

class Engine {
    val power = 100
    inner class Turbo {
        fun boosted() = power * 2
    }
}

fun main() {
    println(Engine().Turbo().boosted())
}

Acessando propriedades externas

Uma classe interna lê e usa diretamente as propriedades externas, como se fossem suas próprias propriedades.

class Counter {
    var count = 0
    inner class Stepper {
        fun step() { count++ }
    }
}

fun main() {
    val c = Counter()
    c.Stepper().step()
    println(c.count)
}

Chamando métodos externos

Classes internas também podem chamar métodos na instância que as contém.

class Printer {
    fun line(s: String) = println(s)
    inner class Job {
        fun run() = line("printing")
    }
}

fun main() {
    Printer().Job().run()
}

A sintaxe this@Outer

Para fazer referência explícita à instância externa, por exemplo quando há conflito entre nomes, use this@Outer.

class Outer {
    val value = 10
    inner class Inner {
        val value = 20
        fun outerValue() = this@Outer.value
    }
}

fun main() {
    println(Outer().Inner().outerValue())
}

Por que usar uma classe interna

Use inner quando o tipo aninhado realmente precisar colaborar com uma instância externa específica, compartilhando seu estado.

class Wallet {
    var balance = 50
    inner class Transaction(val amount: Int) {
        fun apply() { balance += amount }
    }
}

fun main() {
    val w = Wallet()
    w.Transaction(25).apply()
    println(w.balance)
}

Cada Inner vinculada a uma Outer

Uma instância de Inner está vinculada exatamente à instância de Outer que a criou; as alterações são refletidas nesse objeto.

class Box(var size: Int) {
    inner class Resizer {
        fun grow() { size += 1 }
    }
}

fun main() {
    val b = Box(3)
    b.Resizer().grow()
    println(b.size)
}

Inner versus Nested

Sem inner, uma classe aninhada fica isolada. Com inner, ela captura a instância externa. Essa palavra-chave é a única diferença.

class Outer {
    val tag = "X"
    inner class A { fun get() = tag }
}

fun main() {
    println(Outer().A().get())
}

Observação sobre memória

Como uma instância interna mantém a instância externa ativa, tenha cuidado com objetos internos de longa duração para evitar manter o objeto externo na memória sem intenção.

class Service {
    val id = 1
    inner class Worker { fun who() = id }
}

fun main() {
    println(Service().Worker().who())
}

Um iterador realista

Uma classe interna é ideal para um iterador que percorre o estado da coleção que a contém.

class Stack {
    private val items = mutableListOf(1, 2, 3)
    inner class Reader {
        fun all() = items.joinToString()
    }
}

fun main() {
    println(Stack().Reader().all())
}

Combinando os conceitos

Classes internas podem usar o estado externo e eliminar ambiguidades com this@Outer.

class Outer {
    val n = 5
    inner class Inner {
        fun doubled() = this@Outer.n * 2
    }
}

fun main() {
    println(Outer().Inner().doubled())
}

Teste rápido

Teste sua compreensão sobre classes internas.

Recapitulação

Você aprendeu sobre classes internas:

inner fornece acesso à instância externa e aos seus membros.
São criadas por meio de uma instância externa: Outer().Inner().
Use this@Outer para fazer referência à instância que contém a classe.
Instâncias internas mantêm a instância externa ativa.

class Outer {
    val v = 1
    inner class Inner { fun get() = v }
}

fun main() {
    println(Outer().Inner().get())
}

Perguntas Frequentes

A aula “Classes Internas” é grátis?

Sim — o texto completo de “Classes Internas” é 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 Internas”?

Acesse o escopo externo 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 2 de 4.

Quanto tempo leva a aula “Classes Internas”?

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