Variáveis em Java

Uma variável é um local de armazenamento nomeado com um tipo fixo. Uma vez declarada, o tipo não pode mudar, mas o valor armazenado geralmente pode. O tipo controla quanta memória a variável usa, quais valores são válidos e quais operações o compilador permite. Este capítulo aborda como declarar variáveis, como inicializá-las, os quatro tipos que o Java distingue e as regras sobre final, var e escopo.

Declarando uma variável

A forma básica é um tipo seguido de um nome e um ponto e vírgula:

type name;

Por exemplo, int score; reserva um espaço do tipo int chamado score. O tipo é um dos tipos embutidos do Java (int, double, boolean, char, …) ou qualquer classe ou interface — consulte Java Data Types para a lista completa.

As declarações mais simples:

int score;
String name;
boolean ready;

Essas reservam armazenamento; ainda não atribuem um valor.

Inicializando

Para atribuir um valor, use =:

int score = 0;
String name = "Ada";
boolean ready = true;

Você também pode declarar e atribuir separadamente:

int score;
score = 0;

Ou declarar várias variáveis do mesmo tipo de uma vez:

int x = 1, y = 2, z = 3;

(Uma por linha costuma ser mais claro.)

Variáveis locais devem ser atribuídas antes do uso

Uma variável local — declarada dentro de um método — não tem valor padrão. O compilador se recusa a permitir que você a leia antes de ter atribuído algo:

public static void main(String[] args) {
    int x;
    // System.out.println(x); // compile error: variable x might not have been initialized
    x = 5;
    System.out.println(x);    // OK
}

Esse é um dos recursos de segurança mais úteis do Java — ele detecta uma categoria de bugs que outras linguagens deixam passar.

Os quatro tipos de variáveis

O Java distingue quatro categorias de variáveis conforme onde são declaradas:

1. Variáveis locais — declaradas dentro de um método ou bloco. Existem apenas enquanto o método é executado. Sem valor padrão. Devem ser inicializadas antes do uso.
2. Variáveis de instância (campos) — declaradas dentro de uma classe, mas fora de qualquer método. Uma cópia por objeto. Padrão para 0 / 0.0 / false / null.
3. Variáveis estáticas (variáveis de classe) — declaradas com a palavra-chave static. Uma cópia compartilhada por todas as instâncias da classe. Padrão para 0 / false / null.
4. Parâmetros — declarados na assinatura de um método; recebem o valor passado pelo chamador.

public class Counter {
    static int totalCounters;   // static (class) variable
    int count;                  // instance variable

    public void add(int delta) { // delta is a parameter
        int doubled = delta * 2; // doubled is a local variable
        count += doubled;
    }
}

Você vai encontrar variáveis de instância e estáticas novamente nos capítulos de POO; por enquanto, a maioria das variáveis que você escreverá serão locais.

final — atribuição única

Prefixar uma declaração com final torna a variável uma associação de uso único. Após a primeira atribuição, ela não pode ser alterada:

final int MAX_RETRIES = 3;
// MAX_RETRIES = 4; // compile error: cannot assign a value to final variable

Usar final para coisas que não devem mudar torna a intenção explícita e permite que o compilador detecte reatribuições acidentais. Por convenção, campos final que armazenam constantes fixas são nomeados em UPPER_SNAKE_CASE (veja Java Naming Conventions).

Observe que final congela a associação, não o objeto apontado. Uma referência final não pode ser reatribuída, mas o objeto ao qual ela se refere ainda pode ser mutado:

final int[] nums = {1, 2, 3};
nums[0] = 99;        // OK — the array contents change
// nums = new int[5]; // compile error — the reference is final

var — deixe o compilador escolher o tipo

Desde o Java 10, você pode escrever var em vez de um tipo para variáveis locais quando o lado direito torna o tipo óbvio:

var name = "Ada";          // inferred as String
var score = 0;             // inferred as int
var values = new int[10];  // inferred as int[]

var não é tipagem dinâmica — a variável ainda tem um tipo fixo, o compilador apenas o descobre por você. Restrições:

• Apenas para variáveis locais.
• O lado direito deve estar presente (var x; é ilegal).
• Não é permitido para parâmetros, variáveis de instância ou variáveis estáticas.

var é mais útil quando o nome do tipo é longo ou óbvio pelo contexto:

var orders = new HashMap<String, List<Order>>();

Use declarações de tipo comuns quando o tipo inferido não for óbvio para quem lê o código.

Escopo

Uma variável está em escopo — visível — desde sua declaração até o final do bloco que a envolve:

public static void main(String[] args) {
    int outer = 1;

    if (outer > 0) {
        int inner = 2;
        System.out.println(outer + inner);   // both visible
    }

    // System.out.println(inner);   // compile error: inner is out of scope
}

Você não pode declarar duas variáveis locais com o mesmo nome em escopos sobrepostos — mas um nome pode ser reutilizado em dois blocos separados e não sobrepostos:

for (int i = 0; i < 3; i++) { /* i lives here */ }
for (int i = 0; i < 5; i++) { /* a new, separate i */ }  // fine

Manter os escopos das variáveis pequenos é uma boa prática: declare cada variável o mais próximo possível de onde ela é usada pela primeira vez.

Um exemplo funcional

O que vem a seguir

Java Naming Conventions aborda as regras padrão que todo código Java segue para nomear classes, métodos, variáveis e constantes.

Prática