Como os argumentos são passados

Duas Maneiras de Passar Argumentos para Métodos:

Chamada por Valor:

• Copia o valor do argumento no parâmetro formal da sub-rotina.
• Alterações feitas no parâmetro dentro do método não afetam o argumento original.

Chamada por Referência:

• Passa uma referência ao argumento, não o valor.
• Alterações feitas no parâmetro afetam o argumento original na chamada.

Passagem de Tipos Primitivos:

• Quando um tipo primitivo (como int ou double) é passado, é usado a chamada por valor.
• O método recebe uma cópia do argumento, portanto, mudanças feitas dentro do método não afetam o valor original.

Exemplo:

class Test {
    void noChange(int i, int j) {
        i = i + j;
        j = -j;
    }
}

class CallByValue {
    public static void main(String[] args) {
        Test ob = new Test();
        int a = 15, b = 20;
        System.out.println("a and b before call: " + a + " " + b);
        ob.noChange(a, b);
        System.out.println("a and b after call: " + a + " " + b);
    }
}

Passagem de Objetos:
Quando um objeto é passado para um método, Java usa a chamada por referência.
O método recebe uma referência ao objeto, o que significa que mudanças feitas dentro do método afetam o objeto original.

Exemplo:

class Test {
    int a, b;
    Test(int i, int j) {
        a = i;
        b = j;
    }
    void change(Test ob) {
        ob.a = ob.a + ob.b;
        ob.b = -ob.b;
    }
}

class PassObRef {
    public static void main(String[] args) {
        Test ob = new Test(15, 20);
        System.out.println("ob.a and ob.b before call: " + ob.a + " " + ob.b);
        ob.change(ob);
        System.out.println("ob.a and ob.b after call: " + ob.a + " " + ob.b);
    }
}

As alterações dentro do método change() afetam o objeto ob passado como argumento.

Diferença Entre Tipos Primitivos e Objetos:
Tipos Primitivos: Passados por valor, mudanças no método não afetam os valores originais.
Objetos: Passados por referência, mudanças no método afetam o objeto original.

Resumo Final:
A passagem de argumentos em Java pode ser por valor ou por referência. Tipos primitivos são passados por valor, enquanto objetos são passados por referência, resultando em diferentes efeitos sobre os argumentos originais.