Kotlin Academy · Aula

Delegação versus Herança

Escolha a composição

Delegação versus Herança é uma aula grátis de Kotlin Academy no CoddyKit. Esta é a aula 3 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.

Duas formas de reutilizar

Herança e delegação reutilizam comportamentos. Herança diz que uma classe é um tipo de outra. Delegação diz que uma classe tem um colaborador para o qual encaminha chamadas.

O conselho clássico: prefira composição à herança.

Exemplo de herança

Com herança, uma subclasse estende uma classe-base e substitui membros. A classe-base precisa ser open em Kotlin.

open class Animal {
    open fun sound() = "..."
}

class Dog : Animal() {
    override fun sound() = "woof"
}

fun main() {
    println(Dog().sound())
}

Exemplo de Delegação

A mesma reutilização com delegação: o comportamento reside em um membro para o qual a classe encaminha as chamadas.

interface Sound { fun sound(): String }
class Bark : Sound { override fun sound() = "woof" }

class Dog(s: Sound) : Sound by s

fun main() {
    println(Dog(Bark()).sound())
}

A Classe Base Frágil

A herança acopla fortemente uma subclasse aos detalhes internos da classe pai. Uma mudança na classe base pode quebrar subclasses silenciosamente — o problema da classe base frágil. A delegação depende apenas da interface.

Encapsulamento

Uma subclasse pode acessar membros protegidos e substituir pontos de extensão, examinando o interior da classe pai. Uma classe que delega vê apenas a interface pública, preservando o encapsulamento.

interface Counter { fun increment(): Int }

class SimpleCounter : Counter {
    private var n = 0
    override fun increment(): Int { n++; return n }
}

class GuardedCounter(private val c: Counter) : Counter by c {
    override fun increment(): Int {
        println("incrementing")
        return c.increment()
    }
}

fun main() {
    val g = GuardedCounter(SimpleCounter())
    println(g.increment())
    println(g.increment())
}

Flexibilidade em Tempo de Execução

A herança fixa a classe pai em tempo de compilação. A delegação permite injetar implementações diferentes em tempo de execução, facilitando os testes com implementações falsas.

interface Clock { fun now(): Int }
class RealClock : Clock { override fun now() = 100 }
class FakeClock : Clock { override fun now() = 0 }

class Timer(c: Clock) : Clock by c

fun main() {
    println(Timer(RealClock()).now())
    println(Timer(FakeClock()).now()) // easy to test
}

Vários Comportamentos

Uma classe pode estender apenas uma classe pai, mas pode delegar para várias interfaces. A delegação permite combinar várias capacidades de forma escalável.

interface Walk { fun walk() = "walking" }
interface Swim { fun swim() = "swimming" }
class Walker : Walk
class Swimmer : Swim

class Amphibian : Walk by Walker(), Swim by Swimmer()

fun main() {
    val a = Amphibian()
    println(a.walk() + ", " + a.swim())
}

Quando a Herança é Adequada

A herança continua sendo adequada para uma verdadeira relação de é-um com uma hierarquia estável e projetada para extensão: famílias de tipos selados, classes base de bibliotecas e polimorfismo sobre um tipo abstrato compartilhado.

sealed class Shape
class Circle(val r: Double) : Shape()
class Square(val s: Double) : Shape()

fun area(shape: Shape) = when (shape) {
    is Circle -> 3.14 * shape.r * shape.r
    is Square -> shape.s * shape.s
}

fun main() {
    println(area(Circle(2.0)))
}

Quando a Delegação é Adequada

Escolha a delegação quando desejar:

Reutilizar comportamentos entre tipos não relacionados
Combinar várias capacidades
Manter o acoplamento baixo e os testes fáceis
Encapsular e decorar implementações existentes

Comparação Lado a Lado

Herança: uma classe pai, acoplamento forte, fixada em tempo de compilação, é-um. Delegação: vários colaboradores, acoplamento fraco, substituível em tempo de execução, tem-um. Kotlin torna a delegação simples com by, favorecendo a composição.

Uma Escolha Prática Padrão

Uma boa regra: comece com delegação. Recorra à herança apenas quando surgir uma hierarquia é-um genuína e estável. Assim, os projetos permanecem flexíveis e resistentes a mudanças.

Verificação Rápida

Verifique sua compreensão sobre delegação e herança.

Recapitulação

Você comparou as duas abordagens:

Herança: é-um, uma única classe pai, acoplamento forte
Delegação: tem-um, vários colaboradores, acoplamento fraco
Prefira a composição; use herança para hierarquias é-um estáveis

A seguir: padrões práticos de decorador com delegação.

Perguntas Frequentes

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

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

Escolha a composiçã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 3 de 4.

Quanto tempo leva a aula “Delegação versus Herança”?

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