Variáveis em Java: declaração, atribuição e escopo explicados

O que é uma variável

Uma variável é uma caixa com nome que guarda um valor. Em Java toda variável tem um tipo fixo - decidido quando você a declara - e esse tipo nunca muda. É isso que torna Java uma linguagem de tipagem estática: o compilador conhece o tipo de cada variável antes de o programa rodar, e se recusará a compilar código que coloque um valor do tipo errado em uma caixa.

Uma declaração tem três partes: o tipo, o nome e (geralmente) um valor inicial.

public class Main {
    public static void main(String[] args) {
        int age = 30;
        String name = "Ada";
        boolean isActive = true;

        System.out.println(name + " is " + age + ", active: " + isActive);
    }
}

Leia int age = 30; como "crie um int chamado age e coloque 30 nele". O ponto e vírgula encerra a instrução, exatamente como a página de comentários mostrou que toda instrução faz.

Declarar agora, atribuir depois

Você pode separar uma declaração de sua primeira atribuição. O tipo aparece uma única vez, na declaração; depois disso você atribui usando apenas o nome e =:

public class Main {
    public static void main(String[] args) {
        int score;        // declarada, ainda sem valor
        score = 95;       // atribuída agora
        score = 100;      // reatribuída - perfeitamente válido

        System.out.println(score);
    }
}

Uma regra que pega os iniciantes de surpresa: você precisa atribuir um valor a uma variável local antes de lê-la. O compilador controla isso e rejeita código que lê uma variável local não inicializada:

int score;
System.out.println(score);   // compile error: variable score might not have been initialized

Isso é um recurso, não um aborrecimento - ele captura uma classe inteira de erros antes mesmo de o programa rodar.

Regras e convenções de nomenclatura

Java impõe algumas regras rígidas e, sobre elas, adiciona convenções. As regras: um nome pode conter letras, dígitos, _ e $, mas não pode começar com um dígito, não pode ser uma palavra reservada (como int ou class) e diferencia maiúsculas de minúsculas (age e Age são duas variáveis diferentes).

As convenções que todo mundo segue:

• Variáveis e métodos usam camelCase: firstName, totalScore.
• Constantes usam UPPER_SNAKE_CASE: MAX_USERS.
• Os nomes devem descrever o valor: count, não c; userEmail, não x.

public class Main {
    public static void main(String[] args) {
        int itemCount = 3;
        double pricePerItem = 4.50;
        double totalPrice = itemCount * pricePerItem;

        System.out.println("Total: " + totalPrice);
    }
}

Nomes claros não são enfeite - são a forma como o seu eu do futuro lê o código. totalPrice = itemCount * pricePerItem é autoexplicativo de um jeito que t = c * p nunca será.

Segurança de tipos: a caixa mantém o seu tipo

Como o tipo é travado na declaração, você não pode jogar um valor do tipo errado em uma variável. Isso captura os erros em tempo de compilação:

int age = 30;
age = "thirty";   // compile error: incompatible types - String cannot become int

Atribuir entre tipos numéricos segue as regras de ampliação (widening) - um tipo menor flui automaticamente para um maior, mas não o contrário. Vamos cobrir isso em detalhe nas páginas de tipos de dados e conversão de tipos; por enquanto, basta saber que o compilador está de olho.

A palavra-chave var

Desde o Java 10 você pode escrever var no lugar do tipo e deixar o compilador inferi-lo a partir do valor à direita:

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        var name = "Ada";              // inferido como String
        var count = 5;                 // inferido como int
        var prices = new ArrayList<Double>();

        prices.add(9.99);
        System.out.println(name + " " + count + " " + prices);
    }
}

var não é tipagem dinâmica - name é tão String quanto se você tivesse escrito String name, e você continua não podendo atribuir um int a ele mais tarde. Ele só economiza digitação. O detalhe: var precisa de um inicializador para inferir o tipo, então var x; é ilegal, e ele só funciona com variáveis locais - nunca com campos, parâmetros de método ou tipos de retorno. Use-o quando o tipo for óbvio pelo lado direito; escreva o tipo por extenso quando isso trouxer mais clareza.

Constantes com final

Quando um valor nunca deve mudar depois de definido, marque-o como final. Qualquer tentativa de reatribuí-lo vira um erro de compilação:

public class Main {
    public static void main(String[] args) {
        final double TAX_RATE = 0.20;
        double price = 50.0;

        System.out.println("Tax: " + price * TAX_RATE);

        // TAX_RATE = 0.25;   // não compilaria - não dá para reatribuir uma variável final
    }
}

final comunica a intenção ("este é um valor fixo") e deixa o compilador protegê-lo por você. Recorra a ele sempre que um valor for conceitualmente uma constante - taxas, limites, chaves de configuração - para que uma reatribuição acidental seja capturada em vez de seguir silenciosamente como um bug.

Escopo das variáveis

Uma variável existe apenas dentro do bloco - o { ... } - onde é declarada, e morre na chave de fechamento. Isso é o seu escopo. Uma variável declarada dentro de um laço ou de um bloco if é invisível fora dele:

public class Main {
    public static void main(String[] args) {
        int total = 0;

        for (int i = 1; i <= 3; i++) {
            int square = i * i;     // 'square' vive apenas dentro do corpo deste laço
            total += square;
        }

        System.out.println("Total: " + total);
        // System.out.println(square);   // erro - 'square' está fora de escopo aqui
    }
}

Tanto i quanto square pertencem ao laço e somem quando ele termina; total é declarada no bloco externo, então sobrevive. A lição prática: declare cada variável no menor bloco que precisa dela. Um escopo restrito significa menos nomes competindo pela sua atenção e menos chances de usar mal um valor longe de onde ele foi definido.

Próximo: tipos de dados

Cada variável desta página começou com um tipo - int, double, String, boolean. A próxima página detalha os tipos de dados de Java: os oito primitivos, o tamanho de cada um, a diferença entre primitivos e objetos, e qual tipo escolher em cada situação.