True or False: If Variables Are Changed in a Java Method, They Are Also Changed Outside the Method

Continuing in our computer science problem series, I figured we’d dive into a couple of fun Java topics: parameter passing and primitive types. Specifically, we’ll be looking at whether or not you can change variables using methods.

Table of Contents

True or False Question

True of False: If `i` and `j` are changed in the following method, so are `a` and `b`.

void gcd(int i, int j) {
  // Code that modifies i and j
}
gcd(a, b)

Select one of the following:

• A. True
• B. False

Problem Solution

In this problem, the concept being tested is your understanding of primitive types in Java as well as your understanding of parameter passing. In Java, variables are passed to methods by value. For primitive types, that means the value itself is copied. Therefore, whatever happens to `i` and `j` can never be seen by `a` and `b` (i.e., B).

To see this in action, let’s use a simple example:

int a = 5;
int b = 11;

public static void swap(int i, int j) {
  int temp = j;
  j = i;
  i = temp;
}

swap(a, b);

Here, we’ve created a method that swaps the values of `i` and `j`. Unfortunately, this method is useless because the values of `i` and `j` immediately go out of scope as soon as the method ends. As a result, their values are deleted.

`a` and `b`, on the other hand, still exist. However, they are unchanged. The reason is that `a` gets copied into `i` and `b` gets copied into `j`. Therefore, whatever happens to `i` and `j` has no effect on `a` and `b`.

Interestingly enough, this concept extends beyond primitive types. For example, if we used the exact same code but swapped in the `Integer` reference type, we would still have the same problem. If you’re interested in why, I’ve written about this at depth. That said, that’s all I want to cover for this problem. Let’s move on!

Alternative Problem Solving Techniques

If you were approaching this problem without any knowledge of parameter passing or primitive types, you’re in luck. After all, true or false questions are down to a 50/50 chance, so you’re odds of accidentally getting the right answer are pretty good.

Outside of guessing, I’m not sure of any tricks to help get you the right answer for this question. I suppose you might be able to assume that methods work something like the following:

int a = 5;
int b = 11;
// start of method
int i = a;
int j = b;
// code that modifies i and j
// code that deletes i and j

If you think about methods in these terms, then you probably already have the intuition that the variables are copied, not aliased (for primitive types, of course). Therefore, the originals can’t change.

That said, that’s probably a bit of a stretch. Sorry I couldn’t help more!

Happy Learning

Hopefully, this article helped you learn or refresh some concepts—particularly around primitive types and parameter passing. Let me know if you want more content like this.

While you’re here, why not check out some of these related articles:

• Beware of Division by Zero in Java
• Be Careful When Modifying Data While Using a Java Iterator
• The `else if` Keyword Doesn’t Exist in Java

Otherwise, take care! See you next time.

A Computer Science Problem a Day (3 Articles)—Series Navigation

As an educator, I tend to dislike examination as a form of summative assessment. However, I do like multiple choice questions as a form of formative assessment—especially in the context of peer instruction. If done correctly, multiple choice questions are great way of testing concepts and exposing misconceptions. As a result, I thought it would be fun to put together a little series covering questions I’ve seen or used as a way of teaching computer science concepts. Enjoy!

← Previous Post: [#1] [#3]: Next Post →