Passing an Object to The Method in Java

In Java, objects are fundamental building blocks that let us organize our code and build complicated data structures. In Java programming, passing objects to methods is a crucial idea since it allows us to operate on those objects and change their characteristics. With code samples and explanations, we will examine several approaches to passing objects to methods in this article.

Understanding Object References

In Java, you send a reference to an object rather than the actual object when you pass it to a method. This implies that any modifications made to the method's object will also impact the original object. Let's examine several object-passing techniques and their effects to provide clarification.

Person.java

class Person {
    String name;

    public Person(String name) {
        this.name = name;
    }
}

PassObjectByValueExample.java

public class PassObjectByValueExample {
    public static void main(String[] args) {
        Person person = new Person("Alice");
        modifyPersonName(person);
        System. out.println("Person's name: " + person.name);
    }
    public static void modifyPersonName(Person person) {
        person.name = "Bob";
    }
}

Output:

Person's name: Bob

In this example, even though we passed the person object to the modifyPersonName method, any changes made to the object's name attribute are reflected outside the method.

2. Passing by Reference

Java always passes objects by reference because the reference to the object is passed to the method. However, you cannot modify the reference itself within the method. This means you can't make the reference point to a different object.

MyData.java

class MyData {
    int value;
    public MyData(int value) {
        this.value = value;
    }
}

PassObjectByReferenceExample.java

public class PassObjectByReferenceExample {
    public static void main(String[] args) {
        MyData data = new MyData(42);
        modifyDataValue(data);
        System.out.println("Data value: " + data.value);
    }
    public static void modifyDataValue(MyData data) {
        data.value = 100;
    }
}

Output:

Data value: 100

As you can see, we passed the data object to the modifyDataValue method. Any changes made to the object's value attribute are reflected outside the method.

3. Returning Modified Objects

In Java, it is also common to return modified objects from methods. The approach does not modify the original object but creates a new object with the desired changes.

Rectangle.java

class Rectangle {
    int width;
    int height;
    public Rectangle(int width, int height) {
        this.width = width;
        this.height = height;
    }
    public Rectangle resize(int newWidth, int newHeight) {
        return new Rectangle(newWidth, newHeight);
    }
}

ReturnModifiedObjectExample.java

public class ReturnModifiedObjectExample {
    public static void main(String[] args) {
        Rectangle original = new Rectangle(10, 20);
        Rectangle resized = original.resize(30, 40);
        System.out.println("Original: " + original.width + "x" + original.height);
        System.out.println("Resized: " + resized.width + "x" + resized.height);
    }
}

Output:

Original: 10x20
Resized: 30x40

In this example, the resize method returns a new Rectangle object with the modified dimensions.

4. Passing Object References in Arrays or Collections

You can also pass object references in arrays or collections. This allows you to work with multiple objects simultaneously.

Student.java

import java.util.ArrayList;
class Student {
    String name;
    public Student(String name) {
        this.name = name;
    }
}

PassObjectInArrayExample.java

public class PassObjectInArrayExample {
    public static void main(String[] args) {
        Student[] students = new Student[3];
        students[0] = new Student("Alice");
        students[1] = new Student("Bob");
        students[2] = new Student("Charlie");
        updateStudentNames(students);
        for (Student student : students) {
            System.out.println("Student name: " + student.name);
        }
    }
    public static void updateStudentNames(Student[] students) {
        for (Student student : students) {
            student.name += " Smith";
        }
    }
}

Output:

Student name: Alice Smith
Student name: Bob Smith
Student name: Charlie Smith

In this example, we passed an array of Student objects to the updateStudentNames() method, and it modified the names of the students.

5. Passing Objects as Method Parameters

We can send objects of custom classes as method arguments in addition to basic data types like int, double, and String. It allows us to access and modify the object's attributes from within the function.

Book.java

class Book {
    String title;
    public Book(String title) {
        this.title = title;
    }
}

PassObjectAsParameterExample.java

public class PassObjectAsParameterExample {
    public static void main(String[] args) {
        Book book = new Book("Java Programming");
        printBookTitle(book);
    }
    public static void printBookTitle(Book book) {
        System.out.println("Book Title: " + book.title);
    }
}

Output:

Book Title: Java Programming

In this example, we passed a Book object as a parameter to the printBookTitle method, which printed the book's title.

Conclusion

One of the most important aspects of object-oriented programming in Java is passing objects to methods. It's important to keep in mind that Java always passes objects by reference, which implies that any modifications made to an object within a method have an impact on the original object. Depending on your needs, you can decide between altering the original object and delivering a changed duplicate. You may effectively work with objects in your Java programs by comprehending the concepts and techniques discussed in this tutorial.

Next TopicPermutation program in Java

← prev next →