Kotlin Academy · Aula

Delegação a Membros

Componha comportamentos

Delegação a Membros é 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.

Compondo comportamentos

Objetos reais frequentemente precisam combinar várias capacidades. Em vez de herdar de várias fontes, você pode delegar cada capacidade para um objeto membro dedicado.

Duas funções, uma classe

Suponha que uma classe deva tanto fazer read quanto write. Defina duas interfaces e delegue cada uma à sua própria implementação.

interface Reader { fun read(): String }
interface Writer { fun write(s: String): String }

class FileReader : Reader { override fun read() = "contents" }
class FileWriter : Writer { override fun write(s: String) = "wrote " + s }

class FileIO(r: Reader, w: Writer) : Reader by r, Writer by w

fun main() {
    val io = FileIO(FileReader(), FileWriter())
    println(io.read())
    println(io.write("data"))
}

Vários delegados

Uma classe pode delegar várias interfaces ao mesmo tempo, cada uma para um membro diferente. A classe compõe seus comportamentos sem herança.

interface Logger { fun log(m: String): String }
interface Validator { fun valid(m: String): Boolean }

class ConsoleLogger : Logger { override fun log(m: String) = "LOG: " + m }
class LengthValidator : Validator { override fun valid(m: String) = m.isNotEmpty() }

class Service(l: Logger, v: Validator) : Logger by l, Validator by v

fun main() {
    val s = Service(ConsoleLogger(), LengthValidator())
    println(s.valid("hi"))
    println(s.log("started"))
}

Delegado armazenado como membro

Quando precisar referenciar o delegado dentro de substituições, mantenha-o como uma propriedade do construtor. A mesma instância sustenta tanto o encaminhamento quanto seu código personalizado.

interface Cache { fun get(k: String): String }

class MapCache : Cache {
    override fun get(k: String) = "value-of-" + k
}

class TracingCache(private val inner: Cache) : Cache by inner {
    override fun get(k: String): String {
        println("lookup " + k)
        return inner.get(k)
    }
}

fun main() {
    println(TracingCache(MapCache()).get("id"))
}

Combinando delegação e estado próprio

Uma classe que delega pode adicionar suas próprias propriedades e métodos aos métodos encaminhados, enriquecendo o objeto composto.

interface Engine { fun start(): String }
class V8 : Engine { override fun start() = "vroom" }

class Car(e: Engine) : Engine by e {
    var doors = 4
    fun honk() = "beep"
}

fun main() {
    val c = Car(V8())
    println(c.start())
    println(c.honk())
    println(c.doors)
}

Trocando implementações

Como o delegado é apenas um membro, você pode construir o mesmo invólucro com diferentes implementações subjacentes, escolhendo o comportamento durante a execução.

interface Notifier { fun send(msg: String): String }
class EmailNotifier : Notifier { override fun send(msg: String) = "email: " + msg }
class SmsNotifier : Notifier { override fun send(msg: String) = "sms: " + msg }

class Alerts(n: Notifier) : Notifier by n

fun main() {
    println(Alerts(EmailNotifier()).send("hi"))
    println(Alerts(SmsNotifier()).send("hi"))
}

Delegando para uma propriedade

A expressão depois de by pode ser qualquer expressão avaliada uma vez, inclusive uma chamada de construtor. Ela não precisa ser um parâmetro.

interface Greeter { fun greet() = "hi" }
class DefaultGreeter : Greeter

class Page : Greeter by DefaultGreeter()

fun main() {
    println(Page().greet())
}

Evitando o problema do diamante

A herança múltipla de comportamentos é impossível com classes, mas delegar várias interfaces para membros separados contorna perfeitamente o problema clássico do diamante.

interface A { fun a() = "A" }
interface B { fun b() = "B" }
class AImpl : A
class BImpl : B

class Combined : A by AImpl(), B by BImpl()

fun main() {
    val c = Combined()
    println(c.a() + c.b())
}

Projetando para a composição

Para compor bem:

Defina interfaces pequenas e focadas
Forneça implementações reutilizáveis
Delegue cada função na classe que faz a composição

Isso mantém as classes flexíveis e fáceis de testar.

Recapitulação da delegação para membros

Delegar para objetos membros permite que uma classe monte comportamentos a partir de partes. Você pode combinar muitas interfaces, substituir seletivamente, trocar implementações e adicionar seu próprio estado — tudo sem herança.

A seguir: uma comparação direta

Você viu como a delegação é flexível. Na próxima lição, compararemos diretamente a delegação com a herança, para que você saiba quando escolher cada uma.

Verificação rápida

Teste sua compreensão sobre a delegação para membros.

Recapitulação

Você aprendeu a delegação para membros:

Delegar várias interfaces para objetos separados
Substituir seletivamente e adicionar estado próprio
Trocar implementações durante a construção
Evitar problemas da herança múltipla

A seguir: delegação vs herança.

Perguntas Frequentes

A aula “Delegação a Membros” é grátis?

Sim — o texto completo de “Delegação a Membros” é 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 “Delegação a Membros”?

Componha comportamentos 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 “Delegação a Membros”?

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