TOC

Objetos em Kotlin

Objetos em Kotlin

1. Introdução

Kotlin pegou emprestado muitas idéias de outras linguagens; uma dessas construções é oobject.

Neste artigo rápido, veremos o que são objetos e como podem ser usados.

2. Objetos em Kotlin

No Kotlin, como em quase todas as linguagens JVM, existe o conceito de aclass como o núcleo do modelo de Programação Orientada a Objetos. Kotlin introduces the concept of an object on top of that.

Enquanto aclass descreve estruturas que podem ser instanciadas como e quando desejado e permite quantas instâncias forem necessárias,an object instead represents a single static instance, e nunca pode ter mais ou menos do que esta instância.

Isso é útil para várias técnicas, incluindo objetos singleton e empacotamento simples de funcionalidades para encapsulamento: 

object SimpleSingleton {
    val answer = 42;
    fun greet(name: String) = "Hello, $name!"
}

assertEquals(42, SimpleSingleton.answer)
assertEquals("Hello, world!", SimpleSingleton.greet("world"))

Objects also offer full support for visibility modifiers, permitindo a ocultação e encapsulamento de dados como com qualquer outra classe: 

object Counter {
    private var count: Int = 0

    fun currentCount() = count

    fun increment() {
        ++count
    }
}
Counter.increment()
println(Counter.currentCount())
println(Counter.count) // this will fail to compile

Além disso,objects can extend classes and implement interfaces. Ao fazer isso, eles são efetivamente instâncias únicas de classes pai, exatamente como o esperado.

Isso pode ser muito útil para os casos em que temos uma implementação sem estado e não há necessidade de criar uma nova instância sempre - por exemplo, Comparator: 

object ReverseStringComparator : Comparator {
    override fun compare(o1: String, o2: String) = o1.reversed().compareTo(o2.reversed())
}

val strings = listOf("Hello", "World")
val sortedStrings = strings.sortedWith(ReverseStringComparator)

3. O que é um objeto complementar?

Os objetos companheiros são essencialmente iguais à definição padrão deobject, apenas com alguns recursos adicionais para tornar o desenvolvimento mais fácil.

Um objeto complementar é sempre declarado dentro de outra classe. Whilst it can have a name, it doesn’t need to have one, caso em que tem automaticamente o nomeCompanion: 

class OuterClass {
    companion object { // Equivalent to "companion object Companion"
    }
}

Companion objects allow their members to be accessed from inside the companion class without specifying the name.

Ao mesmo tempo, membros visíveis podem ser acessados ​​de fora da classe quando prefixados pelo nome da classe: 

class OuterClass {
    companion object {
        private val secret = "You can't see me"
        val public = "You can see me"
    }

    fun getSecretValue() = secret
}

assertEquals("You can see me", OuterClass.public)
assertEquals("You can't see me", OuterClass.secret) // Cannot access 'secret'

4. Campos estáticos

The main use for companion objects is to replace static fields/methods known from Java. No entanto, esses campos não são gerados automaticamente como tal no arquivo de classe resultante.

Se precisarmos que eles sejam gerados, precisamos usar a anotação@JvmStatic no campo, que irá gerar o bytecode conforme o esperado: 

class StaticClass {
    companion object {
        @JvmStatic
        val staticField = 42
    }
}

Sem fazer isso, o campo estáticostaticField não é facilmente acessível a partir do código Java.

Adding this annotation generates the field exactly as needed for a standard static field, allowing for full interoperability from Java if necessary.

Isso significa que o acima gera um métodostaticgetStaticField() na classeStaticClass.

5. Conclusão

Objetos no Kotlin adicionam uma camada extra inteira que podemos usar, simplificando ainda mais nosso código e facilitando o desenvolvimento.

Os objetos complementares levam isso ainda mais longe, permitindo um código mais limpo, mais fácil de manter e trabalhar.

Como sempre, trechos de código podem ser encontrados emover on GitHub.

Related