Interfaces em Kotlin
Tags: kotlin, java, oop
Published: 2022-11-15 01:42:06

Hoje vamos nos aprofundar no entendimento de Programação Orientada a Objetos em Kotlin, veremos como a linguagem lida com interfaces e suas diferenças em relação a Java. As interfaces de Kotlin se diferenciam da sua equivalente em Java. Em Kotlin, as interfaces podem conter declarações de propriedades, por exemplo, algo que não ocorre em Java.

Similarmente a Java, elas podem conter definições de métodos abstratos assim como definições de métodos não abstratos, mas elas não podem conter nenhum estado.

```kotlin
interface Clickable {
	fun click()
}
```

Para criar um interface usamos a palavra-chave `interface`, seguida de seu nome e chaves. No exemplo acima temos uma interface chamada `Clickable` que contém a definição de um método abstrato chamado `click()`. Qualquer classe não abstrata que implemente essa interface será obrigada a implementar esse método:

```kotlin
class Button : Clickable {
	override fun click() = println("I was clicked")
}
```

```
>>> Button().click()
I was clicked
```

A classe desenvolvida acima `Button` implementa a interface `Clickable` (indicado pelos `:`, que substituem ambas as palavras-chave `implements` e `extends` de Java) e sobrescreve o método `click()`. Essa sobrescrita foi indicada pelo modificador `override` que é obrigatório em Kotlin, diferentemente de Java.

Como dito anteriormente, as interfaces tanto em Kotlin quanto em Java podem ter definições de métodos não abstratos, com a diferença que a notação `default` não é necessária:

Kotlin:

```kotlin
interface Clickable {
	fun click()
	fun showOff() = println("I'm clickable!")
}
```

Java 8:

```java
interface Clickable {
	void click();
	default void showOff() {
		System.out.println("I'm clickable!")
	}
}
```

## Implementando propriedades declaradas em interfaces

Se uma interface declarou uma ou mais propriedades, todas as classes que a implementam devem dar algum jeito de obter o valor dessa ou dessas propriedades.

Interface `User`:

```kotlin
interface User {
	val nickname: String
}
```

Vamos observar três possíveis formas de se inicializar a propriedade `nickname` da interface `User` em três classes que a implementam: `PrivateUser`, `SubscribingUser` e `FacebookUser`:

```kotlin
class PrivateUser(override val nickname: String) : User

class SubscribingUser(val email: String) : User {
	override val nickname: String
			get() = email.substringBefore('@')
}

class FacebookUser(val accountId: Int) : User {
	override val nickname = getFacebookName(accountId)
}
```

A primeira classe `PrivateUser` diz que o valor da propriedade será passado no construtor primário dela mesma, a classe `SubscribingUser` desenvolve um `getter` customizado para obter o valor da propriedade e, por fim, a classe `FacebookUser` apenas inicializa a propriedade de cara. Note que todas as implementações da propriedade foram marcadas com o modificador `override`.

As interfaces em Kotlin também podem conter `getters` e `setters`, mas não podem armazenar dados, visto que isso seria armazenar um estado, o que não é permitido como já dito. Vamos ver um exemplo:

```kotlin
interface User {
	val email: String
	val nickname: String
		get() = email.substringBefore('@')
}
```

Podemos ver que o valor da propriedade não é armazenado na interface, mas sim calculado todas as vezes que ela é implementada.

## Fonte

O post de hoje foi baseado totalmente no incrível e conciso capítulo 4 de *Kotlin in Action* de Dmitry Jemerov e Svetlana Isakova. Confira o material original para maior entendimento de interfaces na nossa querida linguagem Kotlin.

## Próximos posts

Nos próximos post vamos finalizar nossos estudo em Kotlin entendendo como a linguagem lida com classes e objetos. Obrigado pela atenção e até a próxima!

Post anterior:
{% embed https://dev.to/ronaldocoding/estruturas-de-controle-em-kotlin-3d2n %}