Does Java is overstep past times value or overstep past times reference is ane of the tricky Java question generally asked on fresher flat interviews. Before debating whether Java is overstep past times value or overstep past times reference lets outset clear what is overstep past times value together with what is overstep past times reference. This query has its rootage on C together with C++ where y'all tin flame overstep component subdivision parameter either value or retention address, where value is stored (pointer). As per Java specification everything inward Java is overstep past times value whether its primitive value or objects together with it does construct feel because Java doesn't back upwardly pointers or pointer arithmetic, Similarly multiple inheritance together with operator overloading is equally good non supported inward Java. This query becomes confusing when interviewer inquire virtually how object is passed inward Java ? Answer to this query is uncomplicated whenever a method parameter await object, reference of that object is passed. Many programmer confuses reference amongst pointers hither which is non correct, reference is a form of handgrip which is used to locate object or alter object, but it doesn’t allows whatever pointer arithmetics i.e. y'all tin flame non increase or decrease retention address together with locate a dissimilar object using reference inward Java.
Pass past times Value together with Pass past times Reference Example inward Java
Let’s run into 2 instance of calling method together with passing parameter this volition clear whatever incertitude whether Java is overstep past times value or overstep past times reference. reckon next example: public class PassByValueExample {
public static void main(String args[]) {
int give away = 3;
printNext(number);
System.out.println("number Inside main(): "+number);
}
public static void printNext(int number){
number++;
System.out.println("number Inside printNext(): "+number);
}
}
Output:
give away Inside printNext(): 4
give away Inside main(): 3
public static void main(String args[]) {
int give away = 3;
printNext(number);
System.out.println("number Inside main(): "+number);
}
public static void printNext(int number){
number++;
System.out.println("number Inside printNext(): "+number);
}
}
Output:
give away Inside printNext(): 4
give away Inside main(): 3
Above instance clearly shows that primitives are passed equally overstep past times value to method parameters, had Java overstep past times reference both main method and printNext() would convey printed same value. Now expression at unopen to other instance of passing object equally method parameter which volition confuse y'all that Java is overstep past times reference, which Java is not.
public class PassByReferenceConfusion {
public static void main(String args[]) {
Car auto = new Car("BMW");
System.out.println("Brand of Car Inside main() before: "+ car.brand);
printBrand(car);
System.out.println("Brand of Car Inside main()after: "+ car.brand);
}
public static void printBrand(Car car){
car.brand = "Maruti";
System.out.println("Brand of Car Inside printBrand(): "+car.brand);
}
private static class Car{
private String brand;
public Car(String brand){
this.brand = brand;
}
}
}
Output:
Brand of Car Inside main() before: BMW
Brand of Car Inside printBrand(): Maruti
Brand of Car Inside main()after: Maruti
public static void main(String args[]) {
Car auto = new Car("BMW");
System.out.println("Brand of Car Inside main() before: "+ car.brand);
printBrand(car);
System.out.println("Brand of Car Inside main()after: "+ car.brand);
}
public static void printBrand(Car car){
car.brand = "Maruti";
System.out.println("Brand of Car Inside printBrand(): "+car.brand);
}
private static class Car{
private String brand;
public Car(String brand){
this.brand = brand;
}
}
}
Output:
Brand of Car Inside main() before: BMW
Brand of Car Inside printBrand(): Maruti
Brand of Car Inside main()after: Maruti
If y'all run into change made inward method parameter is reflected globally i.e. construct of auto is changed inward all places it agency ane object is used inward both method. Well inward reality if y'all overstep object equally method parameter inward Java it passes "value of reference" or inward uncomplicated term object reference or handgrip to Object inward Java. Here reference term is solely dissimilar than reference term used inward C together with C+ which straight points to retention address of variable together with bailiwick to pointer arithmetic. inward Java object tin flame simply locomote accessed past times its reference equally y'all tin flame non larn retention address where object is stored or to a greater extent than just at that topographic point is no method to larn value of object past times passing retention address.
Further Learning
Complete Java Masterclass
How to notice if a Thread holds lock inward Java ?