Fundamentos do autoboxing e os métodos

Definição

• Autoboxing: Conversão automática de um tipo primitivo para o seu equivalente encapsulador de tipo (como int para Integer).
• Autounboxing: Extração automática do valor de um encapsulador de tipo para o seu tipo primitivo (como Integer para int).

Vantagens

• Simplifica o código ao eliminar a necessidade de conversões manuais.
• Reduz a probabilidade de erros ao lidar com tipos primitivos e encapsuladores.
• Permite usar tipos primitivos em contextos onde objetos são esperados.

Exemplo de Autoboxing

Integer iOb = 100; // O valor int 100 é encapsulado automaticamente.

Sem autoboxing (antes do JDK 5):

Integer iOb = new Integer(100);

Exemplo de Autounboxing

int i = iOb; // O valor encapsulado em iOb é extraído automaticamente.

Sem autounboxing (antes do JDK 5):

int i = iOb.intValue();

Demonstração Básica

class AutoBox {
    public static void main(String[] args) {
        Integer iOb = 100; // Autoboxing
        int i = iOb; // Autounboxing

        System.out.println(i + " " + iOb); // Exibe: 100 100
    }
}

Uso em Métodos
Autoboxing e Parâmetros de Método

static void m(Integer v) {
    System.out.println("m() received " + v);
}

public static void main(String[] args) {
    m(199); // 199 é encapsulado automaticamente em um Integer.
}

Autounboxing e Valores de Retorno

static int m2() {
    return 10; // Retorna um int.
}

static Integer m3() {
    return 99; // Retorna um Integer (autoboxing de 99).
}

public static void main(String[] args) {
    Integer iOb = m2(); // Autoboxing do valor retornado (10).
    int i = m3(); // Autounboxing do Integer retornado (99).

    System.out.println("Return value from m2() is " + iOb);
    System.out.println("Return value from m3() is " + i);
}

Exemplo Completo

class AutoBox2 {
    static void m(Integer v) {
        System.out.println("m() received " + v);
    }

    static int m2() {
        return 10;
    }

    static Integer m3() {
        return 99;
    }

    public static void main(String[] args) {
        // Autoboxing ao passar argumento
        m(199);

        // Autoboxing ao atribuir retorno de um int a um Integer
        Integer iOb = m2();
        System.out.println("Return value from m2() is " + iOb);

        // Autounboxing ao atribuir retorno de um Integer a um int
        int i = m3();
        System.out.println("Return value from m3() is " + i);

        // Autounboxing em operações
        iOb = 100;
        System.out.println("Square root of iOb is " + Math.sqrt(iOb));
    }
}

Saída do Programa

m() received 199
Return value from m2() is 10
Return value from m3() is 99
Square root of iOb is 10.0

Observações

Parâmetros e Retornos:

• Argumentos primitivos passados para métodos que esperam encapsuladores sofrem autoboxing.
• Valores retornados de métodos podem ser automaticamente encapsulados ou extraídos, conforme necessário.

Promoção de Tipos:

• Durante o autounboxing, se necessário, o tipo encapsulado é promovido para atender aos requisitos do contexto (exemplo: Integer para double no Math.sqrt()).
• Esses conceitos tornam o uso de tipos primitivos e objetos em Java mais intuitivo e eficiente.