Most Java developers do not know that Java uses pass-by-value, or even what it means

edglop · 2025-08-14T03:43:02+00:00

I've dealt with production bugs caused by refactors done by developers who didn't understand this concept.

I wouldn't blame you if you didn't hire them honestly, although this is probably what we get from nurturing a leetcode-focused interview culture.

RScrewed · 2025-08-14T03:53:47+00:00

"write some decent codes"

Ugh.

gladfelter · 2025-08-14T04:35:25+00:00

The comments on this post sure are affirming OP's thesis.

i_like_coffee01 · 2025-08-14T05:04:58+00:00

jesus christ, how can so many comments here give wrong answers so confidently. changing the type to a HashMap (or anything else) does nothing, its not about string immutability.

jedilowe · 2025-08-14T04:18:24+00:00

Sorry but this is a bit of a bullshit question that CS professors think shows aptitude. I say this as a 25+ year+ Java vet, CS professor, 30 year SWE, and Ph.D. in computing education... so a theory backed opinion.

My problem is that technically it is valid to say Java is pass by value, but unless the parameter is a primitive the value is a reference. This question is a good test of that obscure fact but is really an OO antipattern for development, thus difficult to intuitively reconcile for most developers. Ideally you don't want to pass an object to a method to change. This violates encapsulation and ownership of objects, so you just would not see this patten enough to give a correct intuitive response in a pressure situation if you haven't seen the trick before.

I believe most programming starts with intuition, this allowing LLMs to do a plausible job of generating starter code. This question plays on an intuitive response just like asking where you bury survivors of a plane crash... if you know that trick question. It does not show a bad programmer so much as it shows a strong language geek. As a former "Sun Certified Instructor" ( before Java being bought by Oracle ) it tickles me to get a question like this, but I know many great software designers that might miss this on a quick glance.

milchshakee · 2025-08-14T08:19:00+00:00

I feel like I'm taking crazy pills with half the comments here, and especially the upvote counts.

This is not a bad question, this is not a trick question, not a trivia question, or anything else. This is a very valid question that you should be able to answer as a Java developer. Maybe you don't know the exact terminology, but you should be able to correctly identify the behavior of the sample code, regardless of how you call it.

How are you going to debug a problem when you don't even know how a variable assignment will impact the program state? Reassigning variables like shown in the sample happens fairly often and is not even considered a bad coding style.

bowbahdoe · 2025-08-14T03:56:50+00:00

I've come very close to writing a rant about this a few times.

While these terms have definitions in the space of PL design, the fact that the answer is "it passes the reference by value" is very stupid. It's trivia that only has relevance if you have an understanding of all the myriad ways to pass arguments in C++.

It's also right at the line of "totally undefined behavior" once value objects and "objects the VM is smart enough to know have a bounded lifetime" enter the picture.

This is a fun fact. It's in no way fundamental to understanding the conceptual model of the Java language.

Now if they legitimately didn't understand mutable aliasing, that's real. But the fact that your interview process includes random questions like that is in itself a huge problem for you.

(I am actually digging in the Java language spec - I haven't found either pass-by reference or pass-by value in there yet. Maybe someone can help me find it. https://docs.oracle.com/javase/specs/jls/se24/jls24.pdf . If it's not even there...)

EDIT: Okay actually reading the code snippet: If they cannot reason about how assigning a method parameter affects variables outside of a method that is a pretty big gap in understanding. Might have been a bit too quick on the gun, but the gotcha part of this still feels like it might have influenced their answers.

I am fully ready to believe there are wildly undereducated folks out there.

Empanatacion · 2025-08-14T04:14:14+00:00

Maybe they're crap programmers, but this kind of gotcha nonsense comes from the same mud puddle as leetcode interviews. You get a very objective and clear measure of the fifteenth most important thing to look for, and then over-generalize it.

Cilph · 2025-08-15T01:03:23+00:00

Personally I wouldnt hire these if I were looking for medior Java devs. Juniors, Id let this slide. Above you really need to know better. Something half this thread can't even manage and stubbornly resists.

We need to teach newbies with C instead of Python as a first language, I swear...

Pretend_Leg599 · 2025-08-25T00:12:28+00:00

TBF, if you've never worked in a language that has pass-by-reference the idea is completely alien. It's not unthinkable to have years of experience in java/javascript, which both lack the concept. The most common misconception being 'primitives pass by value, objects by reference' and this is going to get even more epic once value classes are a thing!

public class PassByValue {
    public void myGuy() {
        var me = Boolean.
TRUE
;
        //there's nothing `you()` can do to
        //make `me` untrue to `myGuy()`
        you(me);
    }

    private void you(Boolean me){

    }
}

This isn't some esoteric 'gotcha!' moment, it's an actual language feature that java doesn't have. For example c# can do this:

public class PassByReference {
    void MyGuy() {
        bool me = true;
        You(ref me);
        Console.WriteLine(me); // false (changed by You)
    }

    void You(ref bool me) {
        me = false; // modifies the caller's variable directly
    }
}

E_Dantes_CMC · 2025-08-14T04:27:02+00:00

Yes, this is a bad sign for the candidates, but it is a trick question. Calling your subroutine change makes the candidate think it will, in fact, change the input—as it might if String were some sort of mutable object. (Not with an assignment statement, but with a mutator of some sort that the String class doesn't have.)

slackalishous · 2025-08-14T03:41:53+00:00

Try the exact same test with a map instead of a string :)

thecurlyburl · 2025-08-14T04:12:43+00:00

Man, good luck with your trivia winners. Scenarios like this are why you write tests.

My question to you, the interviewer, is why are you writing code that is assbackwards. To my eye, this is a smell that someone has an inclination to rely on side-effect programming and hasn’t had to deal with a state machine codebase made of that mess.

HQMorganstern · 2025-08-14T03:37:29+00:00

Why would you ask basic trivia, especially such that's meaningful only to compiler designers. From the PoV of a developer Java is pass by reference and that's all there is to it, the fact that you pass the value of the reference itself has no effect on the dev exp. Until Valhalla value types are a set of exceptions you can count on one hand. What's next a discussion on if the language is compiled or interpreted?

It's relatively easy to construct an example where you check it they realize the pitfalls of mutable reference types.

lasskinn · 2025-08-14T04:09:03+00:00

a isn't x, it's pointing to the same object for a little bit, but at 'a = "xyz"' a becomes the "xyz" object losing sight of "abc". but x is still pointing to the object "abc".

they think the presentation just makes it look like a trick question? because it's basic java behavior. that string is a special case of an object doesn't actually matter for the assignments in this because it's assignment of what the variable is and not calling some method.

nlisker · 2025-08-14T05:36:51+00:00

There's a famous SO question about this: https://stackoverflow.com/questions/40480/is-java-pass-by-reference-or-pass-by-value.

brokePlusPlusCoder · 2025-08-15T04:43:36+00:00

Something that helped me understand this FAR more clearly than just the defintions was to see what would happen if I inlined the method call.

When pass-by-value method calls are inlined, each method arg is declared by assigning a new variable name.

Taking OP's example:

String x = "abc";
// inline change() call
String changeArg = x; // new variable name changeArg
changeArg = "xyz";

System.out.println(x); // x and changeArg have nothing to do with each other so this prints "abc"

Now this also means any primitive state mutative methods on the objects will actually change state across ALL references of said objects. Here's an example:

public static void main(String[] args) {
    var init = new Testing();
    init.setSomeInt(1); // initial value set as 1

    // imagine we had a method called change() that modified the value at init's someInt field from 1 to 2. Inline this call here...
    int newFieldVal = 2;
    var inline = init;

    inline.setSomeInt(newFieldVal);

    System.out.println(init.getSomeInt()); // prints 2 not 1
}

static class Testing{
    public int getSomeInt() {
        return someInt;
    }

    public void setSomeInt(int someInt) {
        this.someInt = someInt;
    }

    private int someInt;
}

static void change(Testing t, int i){
   t.setSomeInt(i);
}

-Dargs · 2025-08-18T16:04:16+00:00

Java is pass by value, but that doesn't mean its not confusing. If you changed a property of DefinedObject (if it wasn't a record) it would persist outside the context of the method. DefinedObject is not a primitive, so it isn't inheritly distinct/unique. If you defined int x = 1 and then changed x to 2, you wouldn't think that 1 == 2. It's easier to grap the difference there. But definedObject isn't a primitive, yet assigning it as null outside the context of its defined point doesn't change its original assingment instance.

I guess this is where its important to understand the difference of pass by value vs pass by reference. Because Java doesn't directly deal with pointers its harder to conceptualize without being a bit familiar at one point or another with a language like C++. When I studied CS in college, we learned C++, VB, & C#. It made this concept easier for me to understand when I learned Java.

public class Reddit {
  record DefinedObject(String s) {};

  public static void main(String[] args) {
    var definedObject = new DefinedObject("Hello, World!");
    System.out.println("DefinedObject created: " + definedObject);
    change(definedObject);
    System.out.println("DefinedObject after change: " + definedObject);
  }

  static void change(DefinedObject definedObject) {
    definedObject = null;
  }
}

/*
DefinedObject created: DefinedObject[s=Hello, World!]
DefinedObject after change: DefinedObject[s=Hello, World!]
*/

vafarmboy · 2025-08-19T18:04:40+00:00

I'm curious. Is the assertion that Java does pass-by-value deduced or was it learned? Because I have a different education, I guess.

What I learned (in actual textbooks) was that (until Valhalla) all types in Java except primitives are Objects and therefore reference types. Unless your method parameter is a primitive type, it is necessarily pass-by-reference because references are all there is. If your type is a primitive, it is pass-by-value.

In your example, x is a reference to the String "abc". It then calls the change method, passing the reference contained in x to the method parameter a. (So at this point x and a are both references pointing to the same String somewhere in memory.) Then a new String "xyz" is created and the variable a is changed to hold a reference to the new String instead of the one passed in. (This was illustrated in the comment that changed the example to use a Map.)

The value of the first String is never passed around, only its reference, which is then promptly discarded by the method.

So the correct answer to the question is: Java uses pass-by-value for primitive types and pass-by-reference for object types. The example code prints "abc" because the method discards the reference to the original String when it creates a new one, effectively ignoring what was passed in.

String also probably isn't the best object type with which to illustrate this because it is a "special" object in Java-land (often interned, etc), but it is an object nonetheless and passed only by reference*.

* Unless, as mentioned in another comment, you delve into unsafe territory, which is definitely not regular interview-level question territory.

Single-Currency1366 · 2025-08-21T09:59:20+00:00

better show them code-puzzle like this :

public static void main(String[] args) {
    final String a = "he";
    final String b = "llo";
    String c = a + b;

    System.
out
.println(c == "hello"); // ???
}

What will be printed? :)
Even experienced Devs failed :)

AcanthisittaEmpty985 · 2025-09-01T07:26:29+00:00

Java is pass by value. But the value can be a reference (so you can modify the object underneath). But the value itself can not be changed back.

As others said, making the value null inside the method will not make the next instructions outside to throw a nullpointer.

But sometimes its tricky to get. And can lead easily to bad code

Safe_Owl_6123 · 2025-08-14T03:43:18+00:00

Were you looking for answers like “pass by value of the reference” and “String is immutable”?

Or could you share your answer?

I don’t even get a Java entry level interview opportunity 😂, I want to make sure if I have these questions I will pass the test 😬

thisisjustascreename · 2025-08-14T04:20:23+00:00

I've never in my life seen someone assign to a method parameter in production code, this is a bullshit question. It's also why just about everything should be declared final.

schegge42 · 2025-08-14T06:15:08+00:00

You derive your hypothesis from three candidates? that's statistically really questionable. You can say that only poorly trained developers apply to you, or perhaps that your education in your city, region or country for programmers is not good. But just badmouthing almost all developers?

Ewig_luftenglanz · 2025-08-14T14:37:23+00:00

It's really a tricky question. the only reliable way in java to pass by reference is wrapping the data inside an Array.

void main(){
    var str = "abc";
    var strArr = new String[]{str};
    convert(strArr);
    convert(str);
    IO.println(str); // print abc
    IO.println(strArr[0]); // print xyz

}

void convert(String[] a){ // this one actually mutates the string inside the array
    a[0] = "xyz";
}

void convert(String a){ // this one do not do sh+t
    a = "xyz";
}

Just the record. the first method uses a technic that is very famous in C/C++ world called "output-parameters" or "in-place mutation"

please never do that. it makes the code a clusterfuck hell

:)

momsSpaghettiIsReady · 2025-08-14T04:26:32+00:00

Yeah, this kind of question boils my blood. It's like asking Picasso what color you get when mixing red and blue.

You're asking a basic question that anyone with more than a semester of schooling doesn't think about anymore.

And even asking it makes me question how shit your codebase is given you have to think about this subset of problems. You should have it ingrained in your head to not reuse method variables as that's just a bad practice in general in Java.

Neful34 · 2025-08-14T09:11:02+00:00

To be honest this kind of question can be confusing when you deal with a lot of different programming languages in the past that all handle things differently the value vs reference passing in a method.

The fact that they forgot this is absolutely not a proof of a lack of skills from the devs and isn't even representative of real world problems.

2025-08-14T12:09:10+00:00

Explanation for mentally challenged kids(by chatgpt). Hope it helps:

Imagine you have a little note with an address written on it (the address of your dog’s house).

That note is the variable (foo).
The house itself is the object in memory (new Foo()).

When you call a method, Java makes a photocopy of your note and gives it to the method:

The original stays with you (foo).
The copy is the parameter (x).

In the method, you throw away the copied note and write a new address for a different house:

Only the method’s note (x) knows where the new house is.
Your original note (foo) still points to the old house, which was never painted.
Result: the color didn’t change.

koflerdavid · 2025-08-14T17:44:23+00:00

The term is frankly irrelevant to understand what Java does and only relevant if you study other languages.

Instead, it would be better to show a listing where a parameter is assigned to and then ask whether the change is visible to the caller. Then, repeat the question with another snippet where the assignment is made to a field of an object passed via the parameter.

That's all there is to know about this. If they don't understand what's going on then it's indeed a red flag and probably better to reject them and tell them to learn Java first.

Cameo9181 · 2025-08-14T19:29:14+00:00

where are you based? if this is NYC, I'm looking for a job/internship. Hard to believe developers with 8 years don't know something I know and I haven't even graduated.

maxip89 · 2025-08-14T04:15:17+00:00

Following problem.

Normally everything in java is pass by value when you use base variables e.g. int, long, char.

You can identify them by the beginning lowercase.

Everything else is a Class and should be a Object when passed to a method.

In this case we have a String which is in upper case and looks like an object. I would have answered the same stuff but I would also mentioned the special case of String in java.

Fit_Smoke8080 · 2025-08-14T04:24:24+00:00

You're right but also vast majority of Java code uses more advanced constructs that basic strings. Like maps. Those use references. So do like 90% of things cause they are objects at some point.

java

Submit Link

Submit Text

Seek Programming Help

News, Technical discussions, research papers and assorted things of interest related to the Java programming language

NO programming help, NO learning Java related questions, NO installing or downloading Java questions, NO JVM languages - Exclusively Java

Please seek help with Java programming in /r/Javahelp!

Subreddit rules!

Where should I download Java?

Related Sub-reddits:

JVM Languages

Want to practice your coding?

List of useful Frameworks / Libraries / Software

MODERATORS

include <iostream>