Java var Java 10+

Até aqui, toda variável começou com o tipo escrito por você: int idade = 29;. Desde o Java 10 existe um atalho: escrever var no lugar do tipo e deixar o compilador descobrir o tipo olhando o valor. Nesta aula você vai ver como o var funciona, onde ele pode e onde não pode ser usado, e quando ele deixa o código melhor ou pior.

A ideia: o Java lê a etiqueta por você

Quando você entrega um pacote nos Correios com uma garrafa dentro, o atendente não precisa que você escreva "GARRAFA" na caixa: ele vê a garrafa e já escolhe a embalagem certa. Com o var é assim: o compilador olha o valor do lado direito do = e escolhe o tipo da variável. Esse trabalho de "deduzir o tipo" se chama inferência de tipo (type inference).

public class Main {
    public static void main(String[] args) {
        var nome = "Ana";
        var idade = 29;
        var altura = 1.65;
        var inicial = 'A';
        var populacao = 8100000000L;
        var aprovada = true;
        System.out.println(nome + " " + idade + " " + altura + " " + inicial + " " + populacao + " " + aprovada);
    }
}

$ javac Main.java && java Main
Ana 29 1.65 A 8100000000 true

var

No lugar do tipo: "compilador, descubra o tipo pelo valor". Vem de variable, "variável".

idade

O nome, como sempre.

=

Recebe.

29

O valor. Como 29 é um literal int, a variável será int.

O tipo escolhido é sempre o tipo do valor, pelas regras que você viu nas aulas anteriores:

Vendo o tipo escolhido no JShell

No JShell, o comando /vars lista as variáveis com o tipo que o Java escolheu:

$ jshell
|  Welcome to JShell -- Version 25.0.4.1
|  For an introduction type: /help intro

jshell> var nome = "Ana"
nome ==> "Ana"

jshell> var idade = 29
idade ==> 29

jshell> var preco = 9.90
preco ==> 9.9

jshell> var grande = 10L
grande ==> 10

jshell> /vars
|    String nome = "Ana"
|    int idade = 29
|    double preco = 9.9
|    long grande = 10

jshell> /exit
|  Goodbye

var não é "sem tipo"

Quem conhece JavaScript ou Python pode achar que var cria uma variável que aceita qualquer coisa. Não cria. O tipo é decidido uma vez, na compilação, e nunca mais muda. O var só poupa você de escrever o tipo; o resultado é idêntico a ter escrito.

public class Main {
    public static void main(String[] args) {
        var idade = 29;
        idade = "trinta";
    }
}

$ javac Main.java
Main.java:4: error: incompatible types: String cannot be converted to int
        idade = "trinta";
                ^
1 error

Na linha 3, idade virou int para sempre. Na linha 4, guardar um texto nela dá o mesmo erro que daria com int idade. Do mesmo jeito, var x = 5; seguido de x = 2.5; dá possible lossy conversion from double to int.

public class Main {
    public static void main(String[] args) {
        int var = 5;
        System.out.println(var);
        var preco = 10;
        preco = preco / 4;
        System.out.println(preco);
        var preco2 = 10.0;
        System.out.println(preco2 / 4);
    }
}

$ javac Main.java && java Main
5                  « int var = 5; (curiosidade explicada adiante)
2                  « var preco = 10; preco = preco / 4;
2.5                « var preco2 = 10.0; preco2 / 4

public class Main {
    public static void main(String[] args) {
        String fruta = "Banana";
        int quantidade = 6;
        double preco = 4.5;
        boolean maduras = true;
        System.out.println(fruta + " " + quantidade + " " + preco + " " + maduras);
    }
}

public class Main {
    public static void main(String[] args) {
        var fruta = "Banana";
        var quantidade = 6;
        var preco = 4.5;
        var maduras = true;
        System.out.println(fruta + " " + quantidade + " " + preco + " " + maduras);
    }
}

Onde pode e onde não pode

O nome oficial do recurso é "inferência de tipo de variáveis locais". Ou seja: o var só vale para variáveis declaradas dentro de um método (como o main), e só quando há um valor do qual deduzir o tipo.

Todos esses erros têm a mesma raiz: o compilador precisa de um valor com tipo claro, na mesma linha, para escolher o tipo. Veja cada um em Quando dá errado.

Curiosidade: var não é palavra reservada

Para não quebrar programas antigos que tinham variáveis chamadas var, o Java tornou var um "nome de tipo reservado", e não uma palavra-chave como int. Por isso int var = 5; ainda compila (foi o 5 da saída acima). Funciona, mas não faça isso: confunde qualquer leitor.

Boas práticas: quando usar

O var é uma ferramenta de legibilidade. A regra de ouro: use quando o tipo fica óbvio lendo a linha; evite quando o leitor teria de adivinhar.

Quando dá errado

public class Main {
    public static void main(String[] args) {
        var total;
        total = 10;
    }
}

$ javac Main.java
Main.java:3: error: cannot infer type for local variable total
        var total;
            ^
  (cannot use 'var' on variable without initializer)
1 error

public class Main {
    public static void main(String[] args) {
        var cliente = null;
    }
}

$ javac Main.java
Main.java:3: error: cannot infer type for local variable cliente
        var cliente = null;
            ^
  (variable initializer is 'null')
1 error

public class Main {
    var contador = 0;

    public static void main(String[] args) {
        System.out.println("oi");
    }
}

$ javac Main.java
Main.java:2: error: 'var' is not allowed here
    var contador = 0;
    ^
1 error

$ javac Main.java
Main.java:3: error: 'var' is not allowed in a compound declaration
        var a = 1, b = 2;
        ^
1 error

$ javac Main.java
Main.java:3: error: cannot infer type for local variable notas
        var notas = {7, 8, 9};
            ^
  (array initializer needs an explicit target-type)
1 error

public class Main {
    public static void main(String[] args) {
        var cidade = "Recife";
        System.out.println(cidade);
    }
}

public class Main {
    public static void main(String[] args) {
        var cidade = null;
        System.out.println(cidade);
    }
}

Referência

Exercícios

Resumo

• var (Java 10+) deixa o compilador deduzir o tipo pelo valor: var idade = 29; é exatamente int idade = 29;.
• O tipo continua fixo: var não cria variável "sem tipo".
• Só para variáveis locais (dentro de métodos), com valor na mesma linha. Não vale sem valor, com null, em várias numa linha, com {…} de array, em atributos nem em parâmetros.
• Use quando o tipo é óbvio na linha (var leitor = new Scanner(System.in);); escreva o tipo quando ele ajuda a entender.
• Cuidado: var preco = 10; é int.