Passing Object to Method in Java

Java is strictly pass-by-value language. When we pass a primitive type to a method, the method receives a copy of the value. However, when we pass an object to a method, the method receives a reference to the object. When we made changes to the object inside the method will be reflected in the object outside the method.

Basically, a parameter cannot be changed by the function, but the function can ask the parameter to change itself via calling some method within it.

While creating a variable of a class type, we only create a reference to an object. Thus, when we pass this reference to a method, the parameter that receives it will refer to the same object as that referred to by the argument.
It means that objects act as if they are passed to methods by use of call-by-reference.
Changes to the object inside the method do reflect the object used as an argument.

ObjectPassing.java

class ObjectPassDemo {
    int a, b;
    // Constructor
    ObjectPassDemo(int i, int j)
    {
        a = i;
        b = j;
    }
    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);
    }
}
public class ObjectPassing {
    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 is 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));
    }
}

Output:

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

Defining A Constructor That Takes an Object of Its Class as A Parameter

One of the most common uses of object parameters involves constructors. Frequently, in practice, there is a need to construct a new object so that it is initially the same as some existing object. To do this, either we can use Object.clone() method or define a constructor that takes an object of its class as a parameter.

PassingObjectExample.java

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; }
}
public class PassingObjectExample{
    // 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);
    }
}

Output:

Volume of mybox is 3000.0
Volume of myclone is 3000.0

Returning Objects

In Java, a method can return any type of data, including objects. For example, in the following program, the incrByTen( ) method returns an object in which the value of an (an integer variable) is ten greater than it is in the invoking object.

PassingObject.java

class ObjectReturnDemo {
    int a;
    // Constructor
    ObjectReturnDemo(int i) { a = i; }
    // Method returns an object
    ObjectReturnDemo incrByTen()
    {
        ObjectReturnDemo temp
            = new ObjectReturnDemo(a + 10);
        return temp;
    }
}
public class PassingObject {
    // 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);
    }
}

Output:

ob1.a: 2
ob2.a: 12

Note: When an object reference is passed to a method, the reference itself is passed by use of call-by-value. However, the value being passed refers to an object, the copy of that value will still refer to the same object that its corresponding argument does. That's why we said that Java is strictly pass-by-value.

Conclusion

Passing objects to methods is a powerful technique that allows we to share data between different parts of our program. It is also essential for using many of the built-in Java classes and libraries.

Next TopicPattern Matching for Switch in Java 21

← prev next →