Kotlin - Orienta��o a Objetos: Heran�a

Fique por dentro

Ao ler esse artigo voc� aprender� como usar herança em Kotlin e estar� mais bem preparado para escrever aplicaç�es orientadas a objetos com essa linguagem, bem como entender o c�digo presente em diversos frameworks e bibliotecas.

Kotlin: Herança

Herança em Kotlin
Construtores secund�rios
Propriedades no Kotlin
Acessando uma implementaç�o da superclasse
Classes abstratas e interfaces

Artigos a S�rie Kotlin

Kotlin: Classes

Herança � um dos tr�s pilares da orientaç�o a objetos. � atrav�s desse recurso que podemos estender ou modificar o comportamento de um c�digo existente, promovendo a reutilizaç�o. Nesse processo a classe existente � chamada de superclasse e a classe a ser criada se chama classe derivada ou subclasse. Uma subclasse herda todos os membros presentes na superclasse por padr�o.

A herança pode ocorrer em forma de generalizaç�o e especificaç�o. Quando um conjunto de classes, geralmente concretas, exigem uma superclasse, dizemos que as caracter�sticas que elas compartilham ser�o combinadas em uma superclasse generalizada. Considerando as classes hamburger e pizza, ambas produtos do card�pio de uma lanchonete, pensar que elas se generalizam na superclasse Food � logicamente plaus�vel. De outra forma, pensar que Food se especializa em toppings, um tipo de alimento que geralmente acompanha um outro alimento, � natural. Apresentar como utilizar esses mecanismos em Kotlin � o objeto deste artigo.

Herança

Toda classe em Kotlin possui um supertipo chamado Any, que possui apenas um pequeno n�mero de funç�es, as quais s�o equals(), hashCode() e toString(). Dessa forma, ambas as declaraç�es abaixo s�o sintaticamente equivalentes:


class Food(val price: Double)

class Food(val price: Double) : Any()

Para declarar um supertipo explicitamente devemos coloc�-lo no cabeçalho da classe ap�s dois pontos. Por padr�o, classes em Kotlin s�o final, se nenhum outro modificador for utilizado em sua declaraç�o. Isso impede que qualquer classes seja usada como supertipo de uma outra classe. Assim sendo, � necess�rio que a superclasse utilize o modificador open como primeiro passo para que uma outra classe herde da mesma.


open class Food(val price: Double)

class Hamburger(price: Double) : Food(price)

Kotlin n�o suporta herança m�ltipla, motivo pelo qual apenas uma classe pode ser inclu�da na lista de supertipos de uma outra classe.

Observe que no construtor prim�rio da classe Hamburger n�o utilizamos a palavra reservada val antes do par�metro price, o que far� com que a propriedade price em Food n�o seja sobrescrita. De fato, com essa sintaxe apenas recebemos um par�metro no construtor prim�rio de Hamburger e delegamos para o construtor prim�rio de Food.

Note que embora a propriedade price seja final em Food, ela pode ser acessada atrav�s de uma inst�ncia de Hamburger, dessa forma:


val hamburger: Hamburger = Hamburger(2.89)

println("Total: ${hamburger.price}")

Esse � o comportamento natural para o modificador final. Caso seja necess�rio impedir que subclasses de Food acessem uma propriedade de uma superclasse, ser� preciso declar�-la com um outro n�vel de acesso, usando os modificadores protected ou private.

Construtores secund�rios

Na ocasi�o da superclasse n�o declarar um construtor prim�rio, cada um dos seus construtores secund�rios deve ser inicializado pela subclasse utilizando a palavra-chave super em lugar de this, assim como demonstrado abaixo.


open class Food {
    open val price: Double

    constructor(price: Double) {
        this.price = price
    }
}

class Hamburger : Food {
    constructor(price: Double) : super(price)
}

A seguir, analisamos um novo exemplo, o qual evidencia o fato de uma subclasse poder referenciar quaisquer construtores secund�rios da superclasse.


open class Food {
    open var price: Double = 0.0
    open var name: String = ""

    constructor(price: Double) {
        this.price = price
    }

    constructor(price: Double, name: String) {
        this.price = price
        this.name = name
    }
}

class Hamburger : Food {
    constructor(price: Double) : super(price)
    
    constructor(price: Double, name: String) : super(price, name)
}

Dessa vez, na listagem de supertipos da classe Hamburger usamos a sintaxe Food em lugar de Food(), porque nesse contexto Food n�o possui um construtor prim�rio.

Propriedades

� poss�vel sobrescrever uma propriedade da superclasse na subclasse utilizando a palavra reservada override. Contudo, assim como as classes, propriedades em Kotlin tamb�m s�o final por definiç�o e n�o podem ser sobrescritas ou herdadas sem a substituiç�o expl�cita do modificador final por open. Vemos um exemplo disso no c�digo abaixo.


open class Food(open val price: Double)

class Hamburger(override val price: Double) : Food(price)

Mesmo sobrescrevendo a propriedade price na subclasse � necess�rio delegar ao construtor da superclasse.

Uma subclasse pode incluir em seu construtor prim�rio suas pr�prias propriedades. Considere que al�m de Hamburger a aplicaç�o tamb�m contenha outros subtipos de Food, os quais seguem a sua pr�pria cadeia de especificaç�o, a fim de implementar um sistema de pedido no qual o cliente possa escolher adicionar para a sua comida. Poder�amos modelar a classe Topping da seguinte forma:


open class Topping(price: Double, private val food: Food) : Food(price) {

    override val price: Double = price
        get() = field + food.price
}

A classe Topping, al�m de ser uma especificaç�o de Food, tamb�m recebe um objeto do tipo Food como par�metro em seu construtor. Uma vez que n�o desejamos sobrescrever a propriedade price, tratamos de receber um par�metro no construtor, cujo valor � transferido para a propriedade atrav�s de delegaç�o. Contudo, food � uma propriedade que existe apenas na subclasse e, por esse motivo, usamos o modificador private e a palavra reservada val para criar essa propriedade.

Apesar de a propriedade price n�o ser sobrescrita na subclasse, o seu getter � redefinido para retornar a inst�ncia de price no pr�prio objeto somada �quela presente na propriedade food.

Na linguagem Kotlin, o conceito de propriedade torna desnecess�rio escrever getters e setters, pois implicitamente os dados de um objeto s�o encapsulados atrav�s de m�todos acessores impl�citos. Contudo, se desejarmos sobrescrever o comportamento padr�o de um m�todo de acesso podemos usar essa sintaxe:


var <propriedade>[: <tipo>] [= <valor>]
    [<getter>]
    [<setter>]

Assim como Food, uma vez que Topping tamb�m � modificada com open, ela tamb�m pode ser utilizada como um supertipo. A t�tulo de exemplo, vamos declarar os subtipos Jalapeno e Mushroom, ambos derivados de Topping.


class Jalapeno(price: Double, food: Food) : Topping(price, food)

class Mushroom(price: Double, food: Food) : Topping(price, food)

Feito isso, podemos instanciar um objeto a partir da composiç�o de toppings e foods, usando at� mesmo o supertipo como tipo para o objeto criado, tal qual apresentado a seguir.


val food: Food = Mushroom(
    .10,
    Jalapeno(
        .15,
        Jalapeno(
            .15,
            Hamburger(2.99)
        )
    )
)

Em tempo de execuç�o, o compilador saber� qual implementaç�o da propriedade price invocar em uma relaç�o de herança. Dessa forma, podemos passar uma inst�ncia de Hamburger em lugar de um Food, em primeiro lugar porque Hamburger � um Food. Num segundo momento, ocorrer� um processo chamado late binding, no qual a JVM saber� que tipo do objeto � Hamburger, executando assim a vers�o sobrecarregada da propriedade price desse objeto.

Assim, ao executar a linha abaixo, o valor apresentado no terminal ser� a soma de todas propriedades price:


println("Total: ${food.price}") // Total: 3.39

Acessando uma implementaç�o da superclasse

A palavra reservada super pode ser utilizada tamb�m para acessar funç�es da superclasse. No exemplo abaixo, usamos esse recurso para oferecer na subclasse uma funç�o que calcula o valor de um alimento, considerando tanto uma taxa quanto um desconto.


open class Food(open val price: Double) {

    open fun calculate(fee: Double): Double {
        return price * fee
    }
}

class Hamburger(override val price: Double) : Food(price) {
    
    fun calculate(fee: Double, discount: Double): Double {
        return super.calculate(fee) - discount
    }
}

� importante notar que a funç�o calculate(fee: Double, discount: Double) existe apenas na subclasse. Sendo assim, caso haja uma tentativa de invoc�-lo a partir de uma inst�ncia de Food um erro ser� emitido pelo compilador com a seguinte mensagem.


val food: Food = Mushroom(
    .10,
    Jalapeno(
        .15,
        Jalapeno(
            .15,
            Hamburger(2.99)
        )
    )
)

println("Total: ${food.calculate(1.2, 0.2)}")

Error:(38, 43) Kotlin: Too many arguments for public open fun calculate(fee: Double): 
Double defined in Food

Classes abstratas e interfaces

Uma classe abstrata, assim como os seus m�todos abstratos, � open por padr�o. Ao herdar de uma classe abstrata, todos os m�todos abstratos da superclasse devem ser implementados na subclasse, a n�o ser que a mesma tamb�m seja abstrata. Caso contr�rio, um erro ser� emitido pelo compilador:


abstract class Food(open val price: Double) {

    abstract fun calculate(fee: Double): Double
}

class Hamburger(price: Double) : Food(price)

Class 'Hamburger' is not abstract and does not implement abstract base class member 
public abstract fun calculate(fee: Double): Double defined in Food

Em Kotlin tamb�m � poss�vel que uma classe abstrata herde de uma classe n�o abstrata. Quando isso for necess�rio, os m�todos da superclasse n�o abstratos devem utilizar o modificador open.

Ainda que isso seja incomum, h� casos em que uma classe herda de uma outra que compartilha um membro com alguma interface, implementada pela subclasse. Quando isso acontecer, podemos usar uma forma qualificada de super para acessar a implementaç�o da superclasse. Vejamos um exemplo que deixar� isso mais claro:


open class Food {
    open fun calculate() { /* Alguma implementaç�o aqui */ }
}

interface Calculable {
    fun calculate() { /* Alguma implementaç�o aqui */ }
}

class Hamburger : Food(), Calculable {
    override fun calculate() {
      super<Food>.calculate()
      super<Calculable>.calculate()
    }
}

Via de regra, sempre que uma classe herdar membros de mesmo nome de supertipos diferentes, ela mesma deve fornecer uma implementaç�o para esse membro. No exemplo acima, a classe Hamburger fornece uma implementaç�o para calculate, a qual invoca calculate() de Food e Calculable a partir de super qualificado.

Conclus�o

Para aqueles que v�m de outras linguagens de programaç�o, como o Java, a relaç�o de herança impl�cita Type : Any do Kotlin pode ser imediatamente transcrita para Type extends Object, uma vez que todo objeto em Java deriva de Object. Contudo essa relaç�o n�o deve ser vista dessa forma, dado que apenas um limitado conjunto dos m�todos presentes em Object podem ser encontrados tamb�m em Any. Quando usamos Kotlin para a JVM, toda vez que for necess�rio usar um Object, o compilador se encarrega de fazer a traduç�o para Any e usar� m�todos de extens�o para completar o conjunto de m�todos em Any.

Confira tamb�m

Aprender Java

S�rie

Cursos de Mobile

Curso

Android Developer