Técnicas de paso de parámetros en Java con ejemplos

Hay diferentes formas en las que los datos de los parámetros se pueden pasar dentro y fuera de los métodos y funciones . Supongamos que se llama a una función B() desde otra función A() . En este caso, A se denomina «función de llamador» y B se denomina «función de llamado o función de llamado» . Además, los argumentos que A envía a B se denominan argumentos reales y los parámetros de B se denominan argumentos formales .
 

Tipos de parámetros:

• Parámetro Formal: Una variable y su tipo tal como aparecen en el prototipo de la función o método. 
  Sintaxis: 
   

function_name(datatype variable_name)

• Parámetro real: la variable o expresión correspondiente a un parámetro formal que aparece en la llamada de función o método en el entorno de llamada. 
  Sintaxis: 
   

func_name(variable name(s)); 

Métodos importantes de paso de parámetros

1. Pasar por valor: los cambios realizados en el parámetro formal no se transmiten a la persona que llama. Cualquier modificación a la variable de parámetro formal dentro de la función o método llamado afecta solo a la ubicación de almacenamiento separada y no se reflejará en el parámetro real en el entorno de llamada. Este método también se llama llamada por valor .
Java, de hecho, es estrictamente llamada por valor.
 

Ejemplo: 
 

// Java program to illustrate
// Call by Value
 
// Callee
class CallByValue {
 
    // Function to change the value
    // of the parameters
    public static void Example(int x, int y)
    {
        x++;
        y++;
    }
}
 
// Caller
public class Main {
    public static void main(String[] args)
    {
 
        int a = 10;
        int b = 20;
 
        // Instance of class is created
        CallByValue object = new CallByValue();
 
        System.out.println("Value of a: " + a
                           + " & b: " + b);
 
        // Passing variables in the class function
        object.Example(a, b);
 
        // Displaying values after
        // calling the function
        System.out.println("Value of a: "
                           + a + " & b: " + b);
    }
}

Value of a: 10 & b: 20
Value of a: 10 & b: 20

Deficiencias: 

• Ineficiencia en la asignación de almacenamiento
• Para objetos y arrays, la semántica de copia es costosa

2. Llamada por referencia (aliasing): los cambios realizados en el parámetro formal se transmiten de vuelta a la persona que llama a través del paso de parámetros. Cualquier cambio en el parámetro formal se refleja en el parámetro real en el entorno de llamada, ya que el parámetro formal recibe una referencia (o puntero) a los datos reales. Este método también se denomina llamada por referencia . Este método es eficiente tanto en el tiempo como en el espacio.
 

// Java program to illustrate
// Call by Reference
 
// Callee
class CallByReference {
 
    int a, b;
 
    // Function to assign the value
    // to the class variables
    CallByReference(int x, int y)
    {
        a = x;
        b = y;
    }
 
    // Changing the values of class variables
    void ChangeValue(CallByReference obj)
    {
        obj.a += 10;
        obj.b += 20;
    }
}
 
// Caller
public class Main {
 
    public static void main(String[] args)
    {
 
        // Instance of class is created
        // and value is assigned using constructor
        CallByReference object
            = new CallByReference(10, 20);
 
        System.out.println("Value of a: "
                           + object.a
                           + " & b: "
                           + object.b);
 
        // Changing values in class function
        object.ChangeValue(object);
 
        // Displaying values
        // after calling the function
        System.out.println("Value of a: "
                           + object.a
                           + " & b: "
                           + object.b);
    }
}

Value of a: 10 & b: 20
Value of a: 20 & b: 40

Tenga en cuenta que cuando pasamos una referencia, se crea una nueva variable de referencia para el mismo objeto. Entonces solo podemos cambiar los miembros del objeto cuya referencia se pasa. No podemos cambiar la referencia para hacer referencia a algún otro objeto ya que la referencia recibida es una copia de la referencia original. ¡ Vea el ejemplo 2 en Java es Strictly Pass by Value!