Object as Parameter in Java

Similar to primitive types, Java makes it easier to give objects as parameters to methods. It is crucial to recognize that sending an object as an argument transmits merely a reference to the item-not a duplicate of it. It means that any changes made to the object inside the method will have an immediate impact on the original object. In this section, we will discuss passing an object as a parameter in Java.

Object Passing as Parameters

Pass-by-Value

Java is a pass-by-value language.
When forwarding objects, only the object's reference-not the actual object-is duplicated.

Encapsulation

Object passing supports encapsulation.
Methods act as interfaces, controlling access to the internal state of an object.

Immutability Considerations

Care is needed with immutable objects.
Methods should avoid modifying the state and return new instances if necessary.

Null Checks and Defensive Programming

Include null checks to handle potential null object parameters.
Defensive programming ensures robustness and prevents null pointer exceptions.

Code Reusability and Modularity:

Object passing enhances code reusability.
Promotes modularity by allowing methods to operate on different object instances.

Understanding the Concept

Let's examine the fundamental syntax and application of Java's "object as parameter" now.

ObjectParameter.java

public class ObjectParameter{
    private int attribute1;
    private String attribute2;
    private double attribute3;
    // Constructor
    public ObjectParameter(int attribute1, String attribute2, double attribute3) {
        this.attribute1 = attribute1;
        this.attribute2 = attribute2;
        this.attribute3 = attribute3;
    }
    public void myMethod(ObjectParameter obj) {
        System.out.println("Attribute 1: " + obj.attribute1);
        System.out.println("Attribute 2: " + obj.attribute2);
        System.out.println("Attribute 3: " + obj.attribute3);
    }
    public static void main(String[] args) {
        ObjectParameter myObject1 = new ObjectParameter(10, "Hello", 3.14);
        ObjectParameter myObject2 = new ObjectParameter(20, "World", 6.28);
        myObject1.myMethod(myObject2);
    }
}

Output:

Attribute 1: 20
Attribute 2: World
Attribute 3: 6.28

Explanation

The method myMethod()takes an object of the same class as an input, enabling the method to work with the provided object and access its properties and methods.

Passing Object in an Array

ObjectasArray.java

public class ObjectasArray {
    public static void modifyPersonNames(Person[] people, String newName) {
        for (Person person : people) {
            person.setName(newName);
        }
    }
    public static void main(String[] args) {
        Person[] people = {new Person("John"), new Person("Alice")};
        System.out.println("Original Names:");
        for (Person person : people) {
            System.out.println(person.getName());
        }
        modifyPersonNames(people, "Jane");
        System.out.println("Modified Names:");
        for (Person person : people) {
            System.out.println(person.getName());
        }
    }
}
class Person {
    private String name;
    public Person(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setName(String newName) {
        this.name = newName;
    }
}

Output:

Original Names:
John
Alice
Modified Names:
Jane
Jane

Explanation

A method called modifyPersonNames() has been added to the ObjectPassingExample class. It modifies the names of all the individuals in the array.

The "people" array is generated in the main method using two Person objects, originally named "John" and "Alice."

The modifyPersonNames() method is called after the original names are printed, changing them to "Jane."

Passing Object in an ArrayList

ObjectList.java

import java.util.*;
public class ObjectList {
    public static void modifyPersonNames(List<Person> people, String newName) {
        for (Person person : people) {
            person.setName(newName);
        }
    }
    public static void main(String[] args) {
        List<Person> people = new ArrayList<>();
        people.add(new Person("Ram"));
        people.add(new Person("Ravi"));
        System.out.println("Original Names:");
        for (Person person : people) {
            System.out.println(person.getName());
        }
        modifyPersonNames(people, "Seetha");
        System.out.println("Modified Names:");
        for (Person person : people) {
            System.out.println(person.getName());
        }
    }
}
 class Person {
    private String name;
    public Person(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setName(String newName) {
        this.name = newName;
    }
}

Output:

Original Names:
Ram
Ravi
Modified Names:
Seetha
Seetha

Advantages of Passing an Object as a Parameter

1. Flexibility

Object parameters provide flexibility in handling different types of objects. A method can accept various objects as parameters, enhancing the adaptability of the code.

2. Reusability of Code

It is possible to create methods that are particular to an object type by using passing objects. Because several instances of the same object can utilize the same method, this encourages code reusability.

3. Encapsulation

When methods work with objects, they provide more support for encapsulation and other object-oriented programming concepts. The object contains both data and behavior, which encourages a simpler design.

Conclusion

Understanding Java's object-passing syntax is necessary for writing effective object-oriented code. By utilizing this feature, code can become more legible, modular, and clean. When you take part in coding tests and projects, remember the advantages and best practices discussed here to enhance your Java programming abilities.

Next TopicOptimizing Java Code Performance

← prev next →