Pasar y devolver objetos en Java

Aunque Java se pasa estrictamente por valor , el efecto preciso difiere entre pasar un tipo primitivo o un tipo de referencia. Cuando pasamos un tipo primitivo a un método, se pasa por valor. Pero cuando pasamos un objeto a un método, la situación cambia dramáticamente, porque los objetos son pasados ​​por lo que efectivamente es una llamada por referencia. Java hace algo interesante que es una especie de híbrido entre pasar por valor y pasar por referencia. 
Básicamente, la función no puede cambiar un parámetro, pero la función puede pedirle al parámetro que se cambie solo llamando a algún método dentro de él.

• Al crear una variable de un tipo de clase, solo creamos una referencia a un objeto. Así, cuando pasamos esta referencia a un método, el parámetro que la recibe se referirá al mismo objeto al que hace referencia el argumento.
• Esto significa efectivamente que los objetos actúan como si fueran pasados ​​a métodos mediante el uso de llamada por referencia.
• Los cambios en el objeto dentro del método reflejan el objeto utilizado como argumento.

Ilustración: supongamos que se crean tres objetos ‘ob1’, ‘ob2’ y ‘ob3’: 

ObjectPassDemo ob1 = new ObjectPassDemo(100, 22);
ObjectPassDemo ob2 = new ObjectPassDemo(100, 22);
ObjectPassDemo ob3 = new ObjectPassDemo(-1, -1);

Desde el lado del método, se declara una referencia de tipo Foo con un nombre a y se asigna inicialmente a nulo. 

boolean equalTo(ObjectPassDemo o);

Cuando llamamos al método equalTo, la referencia ‘o’ se asignará al objeto que se pasa como argumento, es decir, ‘o’ se referirá a ‘ob2’ cuando se ejecute la siguiente declaración. 

System.out.println("ob1 == ob2: " + ob1.equalTo(ob2));

Ahora, como podemos ver, el método equalTo se llama en ‘ob1’, y ‘o’ se refiere a ‘ob2’. Dado que los valores de ‘a’ y ‘b’ son los mismos para ambas referencias, si (condición) es verdadera, se devolverá la verdad booleana. 

if(o.a == a && o.b == b)

Nuevamente, ‘o’ se reasignará a ‘ob3’ cuando se ejecute la siguiente declaración. 

System.out.println("ob1 == ob3: " + ob1.equalTo(ob3));

• Ahora, como podemos ver, el método equalTo se llama en ‘ob1’ y ‘o’ se refiere a ‘ob3’. Dado que los valores de ‘a’ y ‘b’ no son los mismos para ambas referencias, entonces si (condición) es falso, entonces se ejecutará el bloque y se devolverá falso.

En Java podemos pasar objetos a métodos como se puede percibir en el siguiente programa de la siguiente manera:

Ejemplo:

// Java Program to Demonstrate Objects Passing to Methods.
 
// Class
// Helper class
class ObjectPassDemo {
    int a, b;
 
    // Constructor
    ObjectPassDemo(int i, int j)
    {
        a = i;
        b = j;
    }
 
    // Method
    boolean equalTo(ObjectPassDemo o)
    {
        // Returns true if o is equal to the invoking
        // object notice an object is passed as an
        // argument to method
        return (o.a == a && o.b == b);
    }
}
 
// Main class
public class GFG {
    // MAin driver method
    public static void main(String args[])
    {
        // Creating object of above class inside main()
        ObjectPassDemo ob1 = new ObjectPassDemo(100, 22);
        ObjectPassDemo ob2 = new ObjectPassDemo(100, 22);
        ObjectPassDemo ob3 = new ObjectPassDemo(-1, -1);
 
        // Checking whether object are equal as custom
        // values
        // above passed and printing corresponding boolean
        // value
        System.out.println("ob1 == ob2: "
                           + ob1.equalTo(ob2));
        System.out.println("ob1 == ob3: "
                           + ob1.equalTo(ob3));
    }
}

ob1 == ob2: true
ob1 == ob3: false

Definición de un constructor que toma un objeto de su clase como parámetro

Uno de los usos más comunes de los parámetros de objeto involucra a los constructores. Con frecuencia, en la práctica, existe la necesidad de construir un nuevo objeto para que inicialmente sea igual a algún objeto existente. Para hacer esto, podemos usar el método Object.clone() o definir un constructor que tome un objeto de su clase como parámetro.

Ejemplo

// Java program to Demonstrate One Object to
// Initialize Another
 
// Class 1
class Box {
    double width, height, depth;
 
    // Notice this constructor. It takes an
    // object of type Box. This constructor use
    // one object to initialize another
    Box(Box ob)
    {
        width = ob.width;
        height = ob.height;
        depth = ob.depth;
    }
 
    // constructor used when all dimensions
    // specified
    Box(double w, double h, double d)
    {
        width = w;
        height = h;
        depth = d;
    }
 
    // compute and return volume
    double volume() { return width * height * depth; }
}
 
// MAin class
public class GFG {
    // Main driver method
    public static void main(String args[])
    {
        // Creating a box with all dimensions specified
        Box mybox = new Box(10, 20, 15);
 
        //  Creating a copy of mybox
        Box myclone = new Box(mybox);
 
        double vol;
 
        // Get volume of mybox
        vol = mybox.volume();
        System.out.println("Volume of mybox is " + vol);
 
        // Get volume of myclone
        vol = myclone.volume();
        System.out.println("Volume of myclone is " + vol);
    }
}

Volume of mybox is 3000.0
Volume of myclone is 3000.0

Devolución de objetos

En Java, un método puede devolver cualquier tipo de datos, incluidos los objetos. Por ejemplo, en el siguiente programa, el método incrByTen( ) devuelve un objeto en el que el valor de an (una variable entera) es diez veces mayor que el del objeto que lo invoca.

Ejemplo

// Java Program to Demonstrate Returning of Objects
 
// Class 1
class ObjectReturnDemo {
    int a;
 
    // Constructor
    ObjectReturnDemo(int i) { a = i; }
 
    // Method returns an object
    ObjectReturnDemo incrByTen()
    {
        ObjectReturnDemo temp
            = new ObjectReturnDemo(a + 10);
        return temp;
    }
}
 
// Class 2
// Main class
public class GFG {
 
    // Main driver method
    public static void main(String args[])
    {
 
        // Creating object of class1 inside main() method
        ObjectReturnDemo ob1 = new ObjectReturnDemo(2);
        ObjectReturnDemo ob2;
 
        ob2 = ob1.incrByTen();
 
        System.out.println("ob1.a: " + ob1.a);
        System.out.println("ob2.a: " + ob2.a);
    }
}

ob1.a: 2
ob2.a: 12

Nota: cuando se pasa una referencia de objeto a un método, la referencia misma se pasa mediante el uso de llamada por valor. Sin embargo, dado que el valor que se pasa hace referencia a un objeto, la copia de ese valor seguirá haciendo referencia al mismo objeto que su argumento correspondiente. Es por eso que dijimos que Java es estrictamente pass-by-value .

Este artículo es una contribución de Gaurav Miglani . Si te gusta GeeksforGeeks y te gustaría contribuir, también puedes escribir un artículo usando write.geeksforgeeks.org o enviar tu artículo por correo a review-team@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks. Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.