Ramos da Informática

Quais são as diferenças entre Java e Kotlin?

Diferenças entre Java e Kotlin

Quais são as diferenças entre Java e Kotlin? Neste artigo vamos fazer uma comparação do desenvolvimento com Java e Kotlin que possa ajudar a entender as diferenças e vantagens ao Java.

Quais são as diferenças entre Java e Kotlin? Neste artigo vamos fazer uma comparação do desenvolvimento com Java e Kotlin que possa ajudar a entender as diferenças e vantagens ao Java.

Então vamos começar com comparativos:

  1. 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.

Evento gratuito de tecnologia: inscreva-se na 3ª edição do Dev Summit:

  1. Vem ai a 3ª edição do maior evento hands-on de desenvolvimento de software do Brasil. Vamos apresentar tecnologias, ferramentas e práticas em mais de 20 horas em sessões ao vivo com profissionais de referência em Full Stack, Flutter, Angular, React e muito mais.
  2.  



    Leia também:

    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.

    Leia também: Release do livro: Desenvolvedor Kotlin Android – Bibliotecas para o dia a dia

    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?

    2. 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.

    Vai gostar: Motivos para trocar o Java pelo Kotlin ainda hoje | Movile

    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.

Outras Vantagens Kotlin vs Java

Por conta da linguagem Kotlin ser influenciada por outras como JavaScalaGroovyC# e Gosu, encontramos recursos diferenciados nela que a tornam elegante escrevendo pouco mas fazendo muito.

Proteção Contra Nulo (Null Safety)

Quem já não teve problemas com variáveis de valores nulos? Kotlin possui uma solução bem simples para os conhecidos NullPointerException em Java que aqui serão chamados simplesmente de NPE.

// 

Java

String a = "kotlin"
a = 

null

// ok
...
// 

Kotlin
var

 a: String = "kotlin" 
a = 

null

 // erro de compilação

Em muitos casos esta proteção pode ser muito importante para garantir uma segurança ao seu código. E nativamente o Kotlin oferece essa possibilidade. Para forçar o uso de valores nulos você precisa chamar o operador String? para permitir valores nulo.

// 

Kotlin
var

 a: String? = "kotlin" 
a = 

null

 // ok

Outra funcionalidade atraente é a chamada segura de valores nulo utilizando o mesmo operador em variáveis.

// 

Java
int

 l = (a != 

null

)? a.length : 0
...
// 

Kotlin
val

 l = a?.length

Lambdas

As expressões lambda em particular seguem o paradigma Programação Funcional (o termo em si vem do Cálculo Lambda, fundação matemática que sustenta esse paradigma. Expressões deste tipo são cercadas por aparelhos de proteção, seus parâmetros (se houver) são declarados antes -> (os tipos de parâmetros podem ser omitidos), ou o corpo segue depois -> (quando presente).

// 

Java

TextView

 textView = (

TextView

) findViewById(R.id.text_view);
textView.setOnClickListener(v -

>

 System.out.println("

Long Click

"));
...
// 

Kotlin

textView.setOnClickListener(view 

->

println("

Long Click

"))

Existem muitos exemplos de como utilizar expressões lambda em diferentes situações, recomendo este link sobre function e lambda na página oficial do Kotlin, onde é possível encontrar vários exemplos.

Classes de Dados (Data Classes)

Toda aplicação orientada a objetos, por exemplo, necessita de uma classe de dados para armazenamento. Estas classes são acompanhadas por métodos set/get de cada atributo. A diferença é extremamente grande entre Java e Kotlin.

// 

Java

class

User{

private

 String name;

private


int

 age;

void

 setAge(

int

 age){

this

.age = age;
 }

void

 setName(String name){

this

.name = name 
 }

void

 getAge(){

return

 age;
 }

void

 getName(){

return

name; 
 }
}
...
// 

Kotlin
data


class

 User(var name: String, var age: Int)

Argumentos padrões

Com este recurso podemos predefinir valor a um atributo, por exemplo:

// 

Java

// aqui a alternativa é utilizar o padrão Builder

class

 ToastBuilder{

private

 String msg;

private int

 duration;

public

 ToastBuilder(){}

public

ToastBuilder message(String msg){

this

.msg = msg;

return


this

;
}

public

ToastBuilder duration(int duration){

this

.duration = duration;

return


this

;
}

public

Toast buildToast(){

return

 Toast.makeText(getApplicationContext(), msg, duration);;
}
}
...
// 

Kotlin

// declaração de método
fun Activity.toast(message: String, 

duration: Int = Toast.LENGTH_LONG

){
  Toast.makeText(this,message,duration).show()
}
// construtor de um classe
class Contact(val email: String, 

val active: Boolean = true

)

Desta maneira, o uso do método se torna mais simples, permitindo repassar apenas 1 parâmetro se necessário.

// 

Java

Toast

 t1 = new 

ToastBuilder

().message("Hello Java").buildToast();

Toast

 t2 = new 

ToastBuilder

()
                 .message("Hello Java")
                 .duration(Toast.

LENGTH_SHORT

)
                 .buildToast();
...
// 

Kotlin

toast("Hello Kotlin")
//ou
toast("Hello Kotlin" , Toast.

LENGTH_SHORT)

Strings

Agora você pode concatenar strings de maneira mais simples.

// 

Java

System.out.println(“A view " 

+ view +

 " tem visibilidade " 

+ view.getVisibility() +

 ".");
...
// 

Kotlin

println(“A view 

$view

 tem visibilidade 

${view.visibility}

.")

Para descobrir mais recursos consulte String interpolation dentro da documentação oficial.

Algumas Mudanças

Como já sabemos a definição de classes dentro do Java por padrão são públicas permitindo a herança por qualquer outra classe subsequente. Já em Kotlin a definição é diferente, todas as classes definidas com o operador class recebem a proteção para não permitir a extensão por outra classe. Para permitir o uso da herança você precisa utilizar o operador open class.

// 

Javapublic class

Student{
  ...//pode ser extendida
}

private class

Student{
  ...// não pode ser extendida
}
...
// 

Kotlinclass

 Student{
  ... //não pode ser extendida
}

open


class

 Person{
 ...//pode ser extendida
}

Conclusão

Sem dúvida Kotlin é uma rica linguagem com um arsenal imenso de recursos, posso dizer até páreo ao Java, pois como verificamos muitas técnicas feitas em Java no Kotlin são compatíveis e até de uma maneira mais simples.

Então você me pergunta, o que eu faço agora? Dediquei anos da minha vida para aprender Java, quer dizer que vai ser descontinuado?

Talvez, isso o futuro poderá dizer. Mas o que posso dizer que Java é muito utilizado para outras questões além de Aplicativos móveis e há um legado muito grande e difícil de as empresas abandonarem o Java no curo e médio prazo. Mas é uma forte tendência, sim. Porém não é perda de tempo, caso deseje trabalhar com desenvolvimento.

Leia também: Release do livro: Desenvolvedor Kotlin Android – Bibliotecas para o dia a dia

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 😉

 

Você está nas seções:  MundoJS » Kotlin 

 

 

Sair da versão mobile