Call by value is Java's parameter-passing rule: when you call a method or constructor, each argument's value is copied into the corresponding parameter. The parameter is a separate variable, so reassigning it inside the method does not change the original argument.
Call by value is how Java hands arguments to methods and constructors. When you write modify(num), Java doesn't send the variable num itself. It makes a copy of the value stored in num and puts that copy into the parameter. The parameter and the original variable are two different boxes that happen to start with the same contents.
This is true for every call in Java, including constructor calls (EK 1.13.C.3). For a primitive like an int, the copied value is the number itself, so nothing the method does can touch the caller's variable. For an object, the copied value is the reference (the address of the object). The method gets its own copy of that reference, but both copies point to the same object. That one distinction explains most of the tricky parameter questions you'll see.
Call by value lives in Unit 1 (Using Objects and Methods), specifically Topic 1.9 (Calling a Void Method With Parameters) and Topic 1.13 (Creating and Storing Objects). It supports learning objectives 1.9.B (describe how to call methods) and 1.13.C (create an object by calling a constructor), where the CED states directly that arguments are passed using call by value. It also leans on 1.13.B, since you can't reason about passing objects without knowing that a reference-type variable holds an object reference. This concept is the foundation for every code-tracing question that asks "what prints?" after a method call. If you don't know that parameters are copies, you'll predict the wrong output again and again.
Keep studying AP® Computer Science A Unit 1
Object reference (Unit 1)
This is the concept call by value gets tangled with most. When an object is the argument, Java copies the reference, not the object. So the method can change the object's attributes (both references point to the same object), but it can't make the caller's variable point somewhere new. Copy of the address, same house.
Argument (Unit 1)
Arguments are the values you pass in; parameters are the variables that receive the copies. Call by value is the handoff rule between them. EK 1.9.B.3 requires arguments to match the parameter list in number, order, and type, and call by value is what happens once they match.
Object construction (Unit 1)
Constructors follow the exact same rule as methods. When you write new Dog("Rex", 3), copies of those argument values initialize the constructor's parameters, which then set the object's attributes (EK 1.13.C.2 and 1.13.C.3). One rule, every call.
Call by value shows up as code-tracing multiple choice. A classic stem gives you a method like public static void modify(int x) { x = x * 2; }, calls it with modify(num) where num is 5, then prints num. The answer is 5, because x was only ever a copy. A second classic gives a non-void method like square(value) called without storing the result. The original variable still prints unchanged, because the return value was thrown away and value was never touched. On FRQs, call by value is implicit rather than named. Every method you write receives copies of its arguments, so don't expect reassigning a parameter to change anything in the caller. The skill you actually need is tracing: track the parameter as its own variable, separate from the argument.
Java does not have call by reference, full stop. The confusion comes from objects: when you pass an object, the reference is copied by value. The method's parameter points to the same object, so calling a mutator like dog.setName("Rex") inside the method changes the real object. But reassigning the parameter (dog = new Dog()) only redirects the copy and leaves the caller's variable alone. True call by reference would let the method reassign the caller's variable. Java never does that.
Every method and constructor call in Java passes arguments by value, meaning the parameter gets a copy of the argument.
Reassigning a parameter inside a method never changes the original variable in the caller.
When an object is passed, the reference is copied, so the method can modify the object's state but cannot make the caller's variable point to a different object.
If a non-void method's return value isn't stored or used, the original variable stays unchanged, so square(value) alone does nothing to value.
Constructor arguments follow the same call-by-value rule as method arguments (EK 1.13.C.3).
Call by value means Java copies each argument's value into the method or constructor's parameter when a call happens. The parameter is an independent variable, so changes to it don't affect the original argument. The CED states this rule explicitly in Topics 1.9 and 1.13.
Java is always call by value, even for objects. What gets copied for an object is the reference, which is why a method can mutate the object but can't reassign the caller's variable. "Java passes object references by value" is the precise way to say it.
Not if it's a primitive. In the classic exam example, modify(num) doubles its parameter x, but num still prints 5 afterward because x was a copy. For objects, the method can change the object's attributes but not which object the caller's variable refers to.
They're not opposites. Passing an object reference IS call by value: the reference itself gets copied. Both the argument and the parameter then point to the same object, so mutator methods affect the original object even though no variable was shared.
Two reasons. First, call by value means value was never sent into the method, only a copy of 4 was. Second, square returns a result, and a return value must be stored in a variable or used in an expression (EK 1.9.B.2). Calling it on its own line just discards the 16.
Connect this key term to the AP exam workflow: review the course, practice questions, and check related study tools.
Review units, study guides, and course resources.
Check this vocabulary in multiple-choice context.
Apply key concepts in written AP responses.
Estimate the exam score you are working toward.
Review the highest-yield facts before practice.
Put the full course together before test day.