Kotlin Academy · Aula

Boas Práticas

Mantenha os operadores intuitivos

Boas Práticas é 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.

Mantenha os operadores intuitivos

Sobrecarregue um operador somente quando seu significado for óbvio. + para vetores é claro; + com o significado de enviar um e-mail não é.

data class Vec(val x: Int, val y: Int) {
    operator fun plus(o: Vec) = Vec(x + o.x, y + o.y)
}

fun main() {
    println(Vec(1, 2) + Vec(3, 4))
}

Preserve a semântica esperada

Respeite a álgebra usual: a + b deve parecer comutativo para tipos simétricos e não deve surpreender quem lê o código.

data class Money(val cents: Int) {
    operator fun plus(o: Money) = Money(cents + o.cents)
}

fun main() {
    println(Money(100) + Money(50))
}

Prefira a imutabilidade

Operadores como plus devem retornar um valor novo, em vez de modificar o receptor, seguindo o comportamento dos números.

data class Point(val x: Int) {
    operator fun plus(o: Point) = Point(x + o.x)
}

fun main() {
    val a = Point(1)
    val b = a + Point(2)
    println("${a.x} ${b.x}")
}

plus versus plusAssign

Defina plus para valores imutáveis; defina plusAssign para a mutação no próprio local de contêineres mutáveis. Evite definir ambos com comportamentos conflitantes.

class Cart {
    val items = mutableListOf<String>()
    operator fun plusAssign(item: String) { items.add(item) }
}

fun main() {
    val c = Cart()
    c += "book"
    println(c.items)
}

Combine os tipos de retorno

Retorne o mesmo tipo nos operadores binários para que os resultados possam ser encadeados naturalmente.

data class N(val v: Int) {
    operator fun plus(o: N) = N(v + o.v)
}

fun main() {
    println((N(1) + N(2) + N(3)).v)
}

Não sobrecarregue por exibicionismo

Se uma função nomeada for mais clara, use-a. Os operadores servem para semânticas genuinamente numéricas ou semelhantes às de contêineres, não para criar enigmas.

data class Log(val lines: List<String>) {
    fun append(line: String) = Log(lines + line)
}

fun main() {
    println(Log(emptyList()).append("start").lines)
}

Mantenha equals e hashCode consistentes

Se você sobrecarregar a comparação ou a igualdade, mantenha equals e hashCode sincronizados para evitar coleções com comportamento incorreto.

data class Id(val v: Int)

fun main() {
    val set = hashSetOf(Id(1), Id(1))
    println(set.size)
}

Observe a precedência dos operadores

Os operadores sobrecarregados mantêm a precedência incorporada à linguagem. Projete-os para que a precedência natural produza os resultados esperados.

data class N(val v: Int) {
    operator fun plus(o: N) = N(v + o.v)
    operator fun times(o: N) = N(v * o.v)
}

fun main() {
    println((N(2) + N(3) * N(4)).v)
}

Documente operadores surpreendentes

Se um operador fizer algo que não seja óbvio, adicione um comentário ou KDoc para não induzir quem o chama ao erro.

data class Range2(val start: Int, val end: Int) {
    // contains: is value inside the range?
    operator fun contains(v: Int) = v in start..end
}

fun main() {
    println(5 in Range2(1, 10))
}

Use contains para in

O operador in corresponde a contains. Substitua-o apenas quando a pertinência estiver bem definida para o seu tipo.

class Team(val members: List<String>) {
    operator fun contains(name: String) = name in members
}

fun main() {
    val t = Team(listOf("Ann", "Bo"))
    println("Ann" in t)
}

Na dúvida, use uma função

Um método com nome claro quase sempre é mais seguro do que um operador obscuro. Reserve a sobrecarga para os casos em que ela realmente melhora a legibilidade.

data class Temperature(val c: Int) {
    fun warmerThan(o: Temperature) = c > o.c
}

fun main() {
    println(Temperature(30).warmerThan(Temperature(20)))
}

Verificação rápida

Teste sua compreensão sobre as boas práticas de sobrecarga de operadores.

Recapitulação

Você aprendeu as boas práticas de sobrecarga de operadores:

Sobrecarregue somente quando o significado for óbvio e convencional.
Prefira retornos imutáveis do mesmo tipo; mantenha os resultados encadeáveis.
Separe plus (valor) de plusAssign (mutação).
Mantenha equals/hashCode consistentes; prefira funções nomeadas quando forem mais claras.

data class V(val x: Int) {
    operator fun plus(o: V) = V(x + o.x)
}

fun main() {
    println((V(2) + V(5)).x)
}

Perguntas Frequentes

A aula “Boas Práticas” é grátis?

Sim — o texto completo de “Boas Práticas” é 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 “Boas Práticas”?

Mantenha os operadores intuitivos 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 “Boas Práticas”?

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