Tipos de dados em Java: primitivos, tipos de referência e valores padrão

Duas famílias: primitivos e referências

Todo valor em Java tem um tipo, e esse tipo pertence a uma de duas famílias. Os tipos primitivos guardam um valor bruto diretamente: um número, um único caractere ou um verdadeiro/falso. Os tipos de referência guardam uma referência (um ponteiro) para um objeto que vive em outro lugar na memória: String, arrays e toda classe que você ou as bibliotecas definem.

A distinção importa porque os primitivos são leves e copiados por valor, enquanto as variáveis de referência apontam para objetos compartilhados. Comece pelos oito primitivos: eles são a base sobre a qual tudo o mais é construído.

Os oito tipos primitivos

Java tem exatamente oito tipos primitivos embutidos. Seis são números, um é um caractere e um é um booleano:

public class Main {
    public static void main(String[] args) {
        byte   b = 100;          // inteiro de 8 bits,  -128 .. 127
        short  s = 30000;        // inteiro de 16 bits
        int    i = 2_000_000;    // inteiro de 32 bits (o padrão para inteiros)
        long   big = 9_000_000_000L; // inteiro de 64 bits - repare no L

        float  f = 3.14f;        // decimal de 32 bits - repare no f
        double d = 3.141592653589793; // decimal de 64 bits (o padrão para decimais)

        char   c = 'A';          // um único caractere Unicode de 16 bits
        boolean flag = true;     // apenas true ou false

        System.out.println(b + " " + s + " " + i + " " + big);
        System.out.println(f + " " + d);
        System.out.println(c + " " + flag);
    }
}

Algumas coisas que vale notar de início: os sublinhados em 2_000_000 são apenas separadores visuais que o compilador ignora, os sufixos L e f são obrigatórios (mais sobre isso abaixo), e char usa aspas simples, enquanto uma String usaria aspas duplas.

Escolhendo um tipo numérico

Você quase nunca precisa de byte ou short - eles só economizam memória em arrays enormes. As decisões reais são entre int/long para inteiros e float/double para decimais.

Tipo	Tamanho	Use quando
int	32 bits	O padrão para inteiros (até ~2,1 bilhões)
long	64 bits	Valores acima de ~2 bilhões: timestamps em milissegundos, tamanhos de arquivo
double	64 bits	O padrão para decimais - boa precisão
float	32 bits	Apenas quando a memória é escassa e a precisão pode sofrer

A armadilha é o overflow. Um int dá a volta silenciosamente quando ultrapassa sua faixa - nenhum erro, apenas uma resposta errada:

public class Main {
    public static void main(String[] args) {
        int maxInt = Integer.MAX_VALUE; // 2147483647
        System.out.println(maxInt);
        System.out.println(maxInt + 1); // dá a volta para um número negativo!

        long safe = (long) maxInt + 1;  // primeiro promovemos para long
        System.out.println(safe);
    }
}

maxInt + 1 estoura para -2147483648 porque ambos os operandos são int e o resultado continua sendo um int. Converter um dos lados para long primeiro faz a conta em 64 bits. Quando um valor pode ser grande - especialmente milissegundos desde 1970 - recorra a long.

Literais e seus sufixos

Um literal numérico simples tem um tipo padrão, e isso prega peças nas pessoas. 100 é um int; 3.14 é um double. Para escrever um literal long ou float, você precisa adicionar um sufixo:

public class Main {
    public static void main(String[] args) {
        long population = 8_000_000_000L; // sem o L isso é grande demais para int -> erro
        float ratio = 0.5f;               // sem o f o lado direito é um double -> erro
        double pi = 3.14;                 // ok - decimais são double por padrão

        System.out.println(population);
        System.out.println(ratio + " " + pi);
    }
}

Tire o L de 8_000_000_000L e o código não compilará, porque o literal excede a faixa de int antes mesmo de chegar à variável long. Tire o f de 0.5f e o Java reclama que um double não pode ser atribuído a um float sem uma conversão. O sufixo não diferencia maiúsculas de minúsculas, mas use o L maiúsculo - um l minúsculo parece exatamente o dígito 1.

char é um número disfarçado

Um char armazena uma unidade de código Unicode de 16 bits, o que significa que ele também funciona como um pequeno inteiro sem sinal. Você pode fazer aritmética com ele e convertê-lo de um lado para o outro com uma conversão (cast):

public class Main {
    public static void main(String[] args) {
        char letter = 'A';
        int code = letter;          // 65 - o valor Unicode de 'A'
        char next = (char) (letter + 1); // 'B'

        System.out.println(code);
        System.out.println(next);
    }
}

Isso é ocasionalmente útil para deslocar letras, mas não conte com isso para texto - é para isso que existe a String. Note que char usa aspas simples ('A'); aspas duplas ("A") criam uma String de um único caractere, que é um tipo completamente diferente.

Valores padrão (e a pegadinha das variáveis locais)

Campos e elementos de arrays que você não inicializa recebem um valor padrão sensato. Mas isso só se aplica a campos e posições de arrays: variáveis locais não recebem nenhum valor padrão, e usar uma antes de atribuir um valor é um erro de compilação, não uma surpresa em tempo de execução.

public class Main {
    static int counter;        // campo -> padrão 0
    static boolean ready;      // campo -> padrão false
    static String name;        // campo -> padrão null

    public static void main(String[] args) {
        System.out.println(counter); // 0
        System.out.println(ready);   // false
        System.out.println(name);    // null

        int[] nums = new int[3];     // elementos do array têm padrão 0
        System.out.println(nums[0]); // 0
    }
}

Se, em vez disso, você escrevesse int x; System.out.println(x); dentro de main, o compilador o rejeitaria com "variable x might not have been initialized". Esse rigor é uma vantagem: impede que você leia lixo. Os valores padrão a lembrar: tipos numéricos 0, boolean false, char ' ' e todo tipo de referência null.

A seguir: Strings

String é o tipo de referência que você mais vai usar: texto, valores concatenados, entrada do usuário. Ele se comporta de forma diferente dos primitivos vistos aqui: é um objeto, é imutável e comparar strings tem suas próprias armadilhas. A próxima página aborda isso.