Uma das coisas que me faz gostar do Kotlin em relação ao Java

Lâmpada com possibilidades

Muitos amigos e colegas de trabalho, fazem diversas perguntas sobre Kotlin, porém, uma que é muito comum é:

“O que você gosta mais na linguagem Kotlin?”

Provavelmente você também tem esse tipo de pergunta quando se depara com diversos conteúdos na internet, ou então, quando lê alguns dos meus artigos que agrego neste post:

Pensando justamente neste tipo de pergunta que é bem frequente, neste artigo, vou abordar uma das características que mais gosto do Kotlin, tem ideia do que seja?

Muito provavelmente, você pensou em diversas das features mirabolantes que essa linguagem possui, porém, trata-se de um assunto muito comum em qualquer linguagem de programação! 😄

Isso mesmo! Desta vez, vou destacar as diferenças que temos ao utilizarmos variáveis no Java e no Kotlin.

A princípío parece exagero considerando que trata-se de um assunto simples, porém, veremos o quão impactante é a abordagem entre ambas linguagens, principalmente no quesito verbosidade e boas práticas…

Achou interessante a proposta? Então não perca tempo e confira:

Já começa na declaração

Essa primeira abordagem pode parecer bobagem, mas, declarar variáveis no Kotlin é uma experiência incrível em relação com a maneira como fazemos no Java, pois existe uma série de técnicas e boas práticas que facilitam a vida do desenvolvedor.

A primeira que destaco é a obrigação de tomar uma das decisões mais importantes para uma variável, ou seja, indicar se ela é mutável ou não:

var name = "Alex" //mutável
val fullName = "Alex Felipe" //imutável

Além disso, perceba que o esforço de mudar para mutável ou imutável é bem pequeno comparado ao que fazemos no Java:

String name = "Alex"; //mutável
final String fullName = "Alex Felipe"; //imutável

O esforço para deixarmos imutável é muito maior, pois precisamos adicionar o final que é um tanto quanto verboso…

Isso significa que ao declarmos variáveis no Java, é muito mais custoso manter a boa prática da imutabilidade em nossas variáveis.

Um outro ponto que não vou dar destaque mas é bem nítido de se perceber, é a possibilidade de declarar variáveis com a tipagem implícita que deixa o código menos verboso 😅

Sempre inicializar por padrão

Com toda certeza, essa segunda feature é bem importante durante o desenvolvimento, pois o Kotlin exige a inicialização de qualquer variável durante a sua declaração, seja local ou property:

class Person {

//somos obrigados a inicializar, seja mutável ou não
val name = "Alex"
var lastName = "Felipe"

fun showFullname(){
// somos obrigados a inicializar variáveis locais
val fullname = "$name $lastName"
print(fullname)
}

}

Já no Java, por padrão, temos que ficar atentos quando declaramos atributos:

public class Person {

//somos obrigados a inicializar constantes
private final String name = "Alex";
//não somos obrigados a inicializar
private String lastName;

public void showFullName(){
String fullName;
fullName = name + " " + lastName;
//variáveis locais precisam ser inicializadas ao serem utilizadas
System.out.println(fullName);
}

}

Considerando um exemplo “equivalente” em Java, temos a proteção em constantes e variáveis locais que supre 66% das possibilidades.

Porém, a abordagem de atender todos os casos é muito mais atrativa para evitar problemas como o famoso NPE (NullPointerException), concorda?

3) Tipos que recebem ou não null

E agora que mencionei o NPE, um dos grandes atrativos no Kotlin está relacionado a este tópico que é mais conhecido como Null Safety.

Basicamente, todas as variáveis no Kotlin que são explicitamente tipadas, por padrão, não compilam ao receber o valor null durante a inicialização:

val name: String = null

Essa é uma característica incrível! Pois evita o NPE de graça… Claro, se não declaramos o tipo de maneira explicíta, conseguimos inicializar a variável com null:

val name = null

Entretanto, nesta abordagem, a variável name recebe o tipo Nothing? que trata-se de uma classe que não possui instância e representa um valor que não existe!

Inclusive, é nítido observar que o tipo vem com o ? pendurado, essa keyword indica que uma variável pode receber valores null, portanto, se ajustarmos o exemplo inicial para uma String?:

val name: String? = null

O código compila! Mas não é algo inesperado neste tipo de situação, pois se tentarmos utilizar a variável name seremos obrigados a tratá-la!

Em outras palavras, com a abordagem do Null Safety, o Kotlin evita o máximo possível que o NPE aconteça. Inclusive, eu faço uma breve demonstração do assunto em alguns dos meus posts:

Para saber mais

Essas são as abordagens inicias que mais destaco sobre variáveis no Kotlin em relação ao Java, porém, existem outros detalhes que envolves os casos que não é possível inicializar variáveis ou properties de imediato, para isso eu deixo a referência.

E aí, o que achou da forma como trabalhamos com variáveis no Kotlin? Aproveite e deixe o seu comentário sobre alguma feature que mais te chamou atenção ou, de repente, de um assunto que você gostaria de discutir 😉

Like what you read? Give Alex Felipe a round of applause.

From a quick cheer to a standing ovation, clap to show how much you enjoyed this story.