Kotlin Academy · Aula

Padrões Práticos

Decoradores com delegação

Padrões Práticos é uma aula grátis de Kotlin Academy no CoddyKit. Esta é a aula 4 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.

O Padrão Decorador

Um decorador encapsula um objeto para adicionar comportamento, mantendo a mesma interface. A palavra-chave by do Kotlin torna os decoradores triviais: encaminhe tudo e substitua apenas as partes que você aprimorar.

Um Componente Base

Começamos com uma fonte de dados simples. Os decoradores encapsularão essa fonte.

interface DataSource {
    fun fetch(): String
}

class NetworkSource : DataSource {
    override fun fetch() = "raw-data"
}

fun main() {
    println(NetworkSource().fetch())
}

Um Decorador de Registro

O decorador delega à fonte encapsulada e adiciona registros em torno da chamada relevante.

interface DataSource { fun fetch(): String }
class NetworkSource : DataSource { override fun fetch() = "raw-data" }

class LoggingSource(private val inner: DataSource) : DataSource by inner {
    override fun fetch(): String {
        println("fetching...")
        val result = inner.fetch()
        println("done")
        return result
    }
}

fun main() {
    println(LoggingSource(NetworkSource()).fetch())
}

Um Decorador de Armazenamento em Cache

Outro decorador armazena o primeiro resultado em cache, para que chamadas repetidas ignorem a fonte subjacente.

interface DataSource { fun fetch(): String }
class NetworkSource : DataSource { override fun fetch() = "raw-data" }

class CachingSource(private val inner: DataSource) : DataSource by inner {
    private var cached: String? = null
    override fun fetch(): String {
        return cached ?: inner.fetch().also { cached = it }
    }
}

fun main() {
    val s = CachingSource(NetworkSource())
    println(s.fetch())
    println(s.fetch()) // served from cache
}

Encadeando Decoradores

Como cada decorador também é um DataSource, você pode encadeá-los. A ordem importa: o externo encapsula o interno.

interface DataSource { fun fetch(): String }
class NetworkSource : DataSource { override fun fetch() = "raw-data" }

class LoggingSource(private val inner: DataSource) : DataSource by inner {
    override fun fetch(): String { println("log"); return inner.fetch() }
}
class CachingSource(private val inner: DataSource) : DataSource by inner {
    private var c: String? = null
    override fun fetch() = c ?: inner.fetch().also { c = it }
}

fun main() {
    val s = LoggingSource(CachingSource(NetworkSource()))
    println(s.fetch())
    println(s.fetch())
}

Um Decorador de Validação

Os decoradores também podem proteger as entradas. Aqui, um decorador valida as entradas antes de delegar ao processador real.

interface Processor { fun process(input: String): String }
class UpperProcessor : Processor { override fun process(input: String) = input.uppercase() }

class ValidatingProcessor(private val inner: Processor) : Processor by inner {
    override fun process(input: String): String {
        require(input.isNotBlank()) { "empty input" }
        return inner.process(input)
    }
}

fun main() {
    println(ValidatingProcessor(UpperProcessor()).process("hello"))
}

Adaptador de Coleção Somente para Leitura

A delegação facilita a criação de adaptadores. Aqui, encapsulamos uma lista e adicionamos um método de resumo personalizado, encaminhando todas as operações da lista.

class SummarizedList(private val inner: List<Int>) : List<Int> by inner {
    fun total() = inner.sum()
}

fun main() {
    val list = SummarizedList(listOf(1, 2, 3))
    println(list.size)
    println(list.total())
}

Contagem de Chamadas

Um decorador pode acompanhar métricas de forma transparente, o que é útil para monitoramento sem tocar na implementação real.

interface Service { fun call(): String }
class RealService : Service { override fun call() = "ok" }

class CountingService(private val inner: Service) : Service by inner {
    var calls = 0
        private set
    override fun call(): String {
        calls++
        return inner.call()
    }
}

fun main() {
    val s = CountingService(RealService())
    s.call(); s.call()
    println(s.calls)
}

Por que a Delegação Vence Aqui

Criar decoradores por herança obrigaria a classe base a ser open e vincularia cada decorador a uma classe concreta. A delegação depende apenas da interface, portanto os decoradores permanecem pouco acoplados e combináveis.

Lista de Verificação do Padrão

Para criar um decorador baseado em delegação:

Receba o objeto encapsulado como um private val
Delegue a interface com by
Substitua apenas os membros que você aprimorar
Chame o objeto interno dentro da substituição

Reunindo Tudo

Decoradores, adaptadores e objetos intermediários surgem naturalmente da delegação de classes. Combinados com interfaces pequenas, eles permitem criar sistemas flexíveis e organizados em camadas, fáceis de testar e estender.

Verificação Rápida

Verifique sua compreensão sobre padrões práticos de delegação.

Recapitulação

Você criou decoradores práticos com delegação:

Invólucros de registro, armazenamento em cache, validação e contagem
Decoradores encadeados, pois cada um usa a mesma interface
Substituição apenas dos membros aprimorados; encaminhamento dos demais

Isso conclui o curso de delegação de classes.

Perguntas Frequentes

A aula “Padrões Práticos” é grátis?

Sim — o texto completo de “Padrões Práticos” é 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 “Padrões Práticos”?

Decoradores com delegação 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 4 de 4.

Quanto tempo leva a aula “Padrões Práticos”?

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