Parameter List in AP Computer Science A

In AP Computer Science A, a parameter list is the comma-separated set of typed variables declared in a method or constructor header. It sets the number, order, and types of arguments a call must supply, and together with the method name it forms the method signature.

What is the Parameter List?

A parameter list is the part of a method or constructor header inside the parentheses. In public double convert(double temp, String scale), the parameter list is (double temp, String scale). Each entry is a parameter, a variable declared in the header that you can use inside the method body (EK 1.9.A.2). The list tells Java three things about any call: how many values to send, what type each one must be, and in what order they go.

Think of it as the method's order form. The parameter list has the blanks, and the arguments are what you write in them when you call the method. The method name plus the ordered list of parameter types makes up the method signature. That signature is how Java (and you, reading documentation) figures out exactly which method a call refers to. The parameter names don't matter to the caller. The types and their order do.

Why the Parameter List matters in AP® Computer Science A

Parameter lists live in Unit 1: Using Objects and Methods, in Topic 1.9 (Calling a Void Method With Parameters). They support two learning objectives. AP Comp Sci A 1.9.A asks you to identify the correct method to call from documentation and method signatures, and the parameter list is the piece of the signature you actually match against. AP Comp Sci A 1.9.B asks you to describe how to call methods, and EK 1.9.B.3 says arguments must be compatible in number and order with the types in the parameter list. This idea doesn't stay in Unit 1. Every constructor call, every overloaded method, and every method you write yourself on an FRQ depends on getting the parameter list right.

How the Parameter List connects across the course

Argument (Unit 1)

Parameters and arguments are two sides of one handoff. The parameter list is the set of slots defined in the header, and the arguments are the actual values you drop into those slots at call time. If the count, order, or types don't line up, the call won't compile.

Method Signature and Method Overloading (Unit 1)

A class can have several methods with the same name as long as their parameter lists differ in number, type, or order of types. So log(String msg, int level) and log(int code, String msg) can coexist. Java picks the right one by matching your arguments to each parameter list. The return type plays no part, because it isn't in the signature.

Constructors (Unit 1)

Constructors have parameter lists too, and the same matching rules apply. When you write new Something(...), Java looks for the constructor whose parameter list fits your arguments. Overloaded constructors are the reason one class can be built in more than one way.

Call by Value (Unit 1)

When a call runs, each parameter gets a copy of its argument's value. For a primitive like int, changing the parameter inside the method does nothing to the caller's variable. The parameter is a fresh local variable that happens to start with the argument's value.

Is the Parameter List on the AP® Computer Science A exam?

Multiple-choice questions test parameter lists by having you match calls to headers. Common stems look like these:

• Direct recall. "When calling a method, the arguments passed must match the parameter list in what two ways?" The answer is number and order of types.
• Choosing the right call. Given public double convert(double temp, String scale), which call converts 98.6 to Celsius? The correct choice sends a double first and a String second, like t.convert(98.6, "C"). Distractors swap the order or leave out an argument.
• Overload resolution. A Logger class has log(String msg, int level) and log(int code, String msg). You have to trace which version a call like log(5, "error") runs, based only on argument types and their order.
• Writing a valid overload. A class already has process(int data, String label). To add a version for a decimal, the new header needs a different parameter list, such as process(double data, String label). Changing only the return type or the parameter names is a trap.

No released FRQ has used the phrase "parameter list" word for word. Still, every FRQ that asks you to write a method or constructor hands you a header, and your code has to use those parameters correctly and call other methods with matching arguments.

The Parameter List vs Argument

The parameter list belongs to the method header. It declares typed variables like (double temp, String scale). Arguments belong to the method call. They are the actual values you pass, like (98.6, "C"). One way to remember it: parameters are defined once when the method is written, and arguments change every time the method is called. Arguments don't carry type declarations, but each one has to be compatible with the type of the parameter in the same position.

Key things to remember about the Parameter List

• A parameter list is the typed, comma-separated set of variables inside the parentheses of a method or constructor header.

• Arguments in a call must match the parameter list in number and in the order of their types, or the code will not compile.

• The method signature is the method name plus the ordered parameter types, and that signature is what Java uses to decide which method to run.

• Overloaded methods share a name but must have different parameter lists, and changing only the return type or parameter names does not create a valid overload.

• Parameter names don't matter to the caller, so convert(double temp, String scale) and convert(double t, String s) have the same signature.

• Each parameter receives a copy of its argument's value, so reassigning a primitive parameter inside the method does not change the caller's variable.

Frequently asked questions about the Parameter List

What is a parameter list in AP Computer Science A?

It's the set of typed variables declared in a method or constructor header, like (int data, String label). It defines how many arguments a call needs, what type each must be, and the order they go in. Together with the method name, it forms the method signature (Topic 1.9).

What's the difference between a parameter and an argument?

A parameter is a variable declared in the method header, and an argument is the actual value you pass when you call the method. In convert(double temp, String scale) the parameters are temp and scale. In the call t.convert(98.6, "C") the arguments are 98.6 and "C".

Can you overload a method by changing only the return type?

No. The return type isn't part of the method signature, so two methods with identical parameter lists clash even if they return different types. To overload, change the number, types, or order of types in the parameter list, for example by adding process(double data, String label) next to process(int data, String label).

Does the order of parameters matter in Java?

Yes. log(String msg, int level) and log(int code, String msg) are two different methods because their parameter types come in different orders. A call like log("hi", 3) matches only the first one, and swapping the arguments matches only the second.

Do parameter names have to match the argument variable names?

No. Only the types and their positions need to line up. You can pass a variable called x into a parameter called temp, and the parameter just receives a copy of x's value.