Kotlin para javeiros — 4 recursos que você vai gostar

Nas últimas semanas um amigo que trabalha massivamente com Java comentou que estava trabalhando em uma implementação feita em Kotlin pela primeira vez e achou algumas coisas legais. Isso me lembrou um livro que me foi muito útil há alguns anos, quando já tinha algum conhecimento em Java e queria muito me familiarizar com o C# (e me apaixonei, só pra constar). O livro é o C# para Programadores de Java, da Altabooks.

Embora o Kotlin seja interoperável com o Java e até mesmo o IntelliJ já possua uma ajuda convertendo código oriundo de copy/paste, achei interessante escrever um breve artigo com alguns dos mais básicos recursos que gosto muito da linguagem.

Named Arguments

Nomear parâmetros na chamada do método é uma boa forma de evitar equívocos e deixar as coisas bem claras. Em Java teríamos a chamada de um método da forma abaixo:

//Construção do método 
getErrorData(String userId, String password, Exception error); //Chamada 
getErrorData("password", "userId", new Exception());

Percebeu o erro? Claro que estamos tratando de dados fictícios, mas eu passei um argumento na ordem errada, como ambos são strings isso pode gerar um erro desnecessário e até bobo.

Agora veja o mesmo exemplo usando os named arguments do Kotlin:

//Construção do método 
getErrorData(String userId, String password, Exception error) //Chamada utilizando named arguments 
getErrorData(userId="userId", password="password", Exception())

Um detalhe que protege nós, devs, de nós mesmos.

Data class

Essa é uma das coisas que mais curti quando comecei a migrar do Java para o Kotlin em apps Android, há alguns anos.

Esse recurso traz paz de espírito ao substituir as classes POJO do Java e enxugar muito o código e mantendo atribuições simples de forma implícita. Veja a diferença.

public class Profile { 
    private String id; 
    private String name;
    public String getId() { return id; } 
    public void setId(String id) { this.id = id; } 
    public String getName() { return name; } 
    public void setName(String name) { this.name = name; } 
}
//Criação do data class 
data class Profile(val id: String, val name: String) 
//Chamada do construtor 
Profile(id = "bc93ef54-d217-4a74-ad51-1c169f47cbad", 
        name = "UserProfile")

Desta forma, inclusive, o atributo declarado como val não permite que a variável seja alterada após a construção do objeto, trazendo segurança.

Scoped Functions

Esse recurso também é bem legal, permitindo fazer transformações ou apenas iterações dentro de um objeto/lista de forma limpa e reduzindo repetição de código, veja a comparação abaixo:

//Java
UserData userData = new UserData(); 
userData.configurePermissions(); 
userData.createAccount();
userData.defineAsActive();
//Kotlin com scoped functions
val userData = UserData().apply{ 
    configurePermissions() 
    createAccount() 
    defineAsActive() 
}

Note que após construir o objeto já podemos usar o apply para as chamadas imediatas e a repetição do userData é evitada. Aqui no blog tem outro artigo falando sobre as várias scoped functions e suas aplicações.

Range expressions

Os tipos range são uma mão na roda, segue o exemplo:

//Verificação de range manual em Java
String[] names = {"Antonio", "João", "Pedro"}; 
List<String> namesList = Arrays.asList(names);
if (namesList.size() > 0 && namesList.size() < 3) {
    System.out.println(namesList.get(1)); 
}
//Utilizando o recurso de ranges do Kotlin
val names = listOf("Antonio", "João", "Pedro") 
if (names.size in 0.. 3) { println(names[1]) }

Veja que a verificação fica mais curta. Um detalhe interessante é que o tipo IntRange não é o único, também é possível fazer isso com Longs e Chars.

Neste link da documentação do Kotlin você consegue encontrar ainda outros muitos recursos úteis da linguagem e diferenças em relação ao Java.

Se você gostou comenta aqui que tem muito mais coisas legais do Kotlin para falar. Feedbacks são bem-vindos, até mais.