Tipos primitivos no Java

Java é uma linguagem de programação que possui uma tipagem estática e forte. Isso quer dizer que os tipos devem ser definidos em momento de compilação. Por isso, vou apresentar os tipos primitivos que a linguagem possui.

Números

O Java representa números usando 6 tipos diferentes: byte, short, int, long, float e double.

Inteiros

Dentre os tipos que representam números no Java, os números inteiros são representados pelos tipos byte, short, int e long. A diferença entre eles está no tamanho e na capacidade de armazenamento.

• byte -> Ocupa um tamanho de 1 bytes (8 bits), 1 bit para o sinal e 7 bits para o número. Ou seja, pode armazenar do número -128 até 127.
• short -> Ocupa um tamanho de 2 bytes (16 bits), 1 bit para o sinal e 15 bits para o número. Ou seja, pode armazenar do número -32768 até 32767. O dobro de bytes de armazenamento em relação ao tipo byte.
• int -> Ocupa um tamanho de 4 bytes (32 bits), 1 bit para o sinal e 31 bits para o número. Ou seja, pode armazenar do número -2^31 até 2^31 - 1. O dobro de bytes de armazenamento em relação ao tipo short.
• long -> Ocupa um tamanho de 8 bytes (64 bits), 1 bit para o sinal e 63 bits para o número. Ou seja, pode armazenar do número -2^63 até 2^63 - 1. O dobro de bytes de armazenamento em relação ao tipo int.

Caso você ultrapasse o limite superior do tipo da variável ela irá voltar o ciclo para o limite inferior dela e vice e versa.

public class Main {
    public static void main(String[] args) {
        byte b = (byte) 127;
        System.out.println("Máximo byte: " + b); // 127
        b++; // ultrapassa o limite somando 1
        System.out.println("Mínimo byte: " + b); // -128

        short s = (short) 32767;
        System.out.println("Máximo short: " + s); // 32767
        s++; // ultrapassa o limite somando 1
        System.out.println("Mínimo short: " + s); // -32768

        int i = 2147483647;
        System.out.println("Máximo int: " + i); // 2147483647
        i++; // ultrapassa o limite somando 1
        System.out.println("Mínimo int: " + i); // -2147483648

        long l = 9223372036854775807L;
        System.out.println("Máximo long: " + l); // 9223372036854775807
        l++; // ultrapassa o limite somando 1
        System.out.println("Mínimo long: " + l); // -9223372036854775808
    }
}

Ponto flutuante

Caso você precise armazenar números com casas decimais, ponto flutuante, o java oferece os tipos float e double.

• float -> Ocupa um tamanho de 4 bytes (32 bits), 1 bit de sinal, 8 bits para o expoente (número antes da vírgula) e 23 bits para o decimal (parte depois da vírgula.
• double -> Ocupa um tamanho de 8 bytes (64 bits), 1 bit de sinal, 11 bits para o expoente (número antes da vírgula) e 52 bits para o decimal (parte depois da vírgula.

public class Main {
    public static void main(String[] args) {
        float f = Float.MAX_VALUE;

        System.out.println("Máximo float: " + f); // 3.4028235E38

        f = Float.MAX_EXPONENT;
        System.out.println("Máximo exponente float: " + f); // 1.7976931348623157E308

        f = Float.MIN_VALUE;
        System.out.println("Mínimo float: " + f); // 127.0

        f = Float.MIN_EXPONENT;
        System.out.println("Mínimo exponente float: " + f); // -126.0

        double d = Double.MAX_VALUE;

        System.out.println("Máximo double: " + d); // 1.7976931348623157E308

        d = Double.MAX_EXPONENT;
        System.out.println("Máximo exponente double: " + d); // 1023.0

        d = Double.MIN_VALUE;
        System.out.println("Mínimo double: " + d); // 4.9E-324

        d = Double.MIN_EXPONENT;
        System.out.println("Mínimo exponente double: " + d); // -1022.0
    }
}

Booleanos

Para representar expressões booleanas, expressões que geram valores verdadeiro ou falso, existe o tipo boolean. Esse tipo ocupa o tamanho de 1 bit.

public class Main {
    public static void main(String[] args) {
        // valor booleano
        boolean condition = true;

        System.out.println(condition); // true;

        condition = false;
        System.out.println(condition); // false;

        // expressão booleana. Gera um valor booleano
        condition = 10 > 5;
        System.out.println(condition); // true;

        condition = 10 < 5;
        System.out.println(condition); // false;
    }
}

Caracteres

O último tipo primitivo do java é o char esse tipo é usado para armazenar um único caractere. Esse tipo ocupa um valor de 2 bytes (16 bits).

O char pode receber valor como um caracter entre aspas simples ou como o código numérico da tabela ASCII

public class Main {
    public static void main(String[] args) {
        char c = 'a';
        System.out.println("Caracter: " + c); // a

        c = 77; // código da letra 'M' em ASCII
        System.out.println("Caracter: " + c); // M
    }
}