AP CSA · Unit 1 Part B · Lessons 1.9–1.15

Methods, Objects & Strings Review

Built around the two study methods with the strongest research behind them: testing yourself and spacing it out. Take the test first, then use the notes to fix what you missed.

Tonight's plan

Take the test cold. ~30 min
Don't read the notes first. Work each question on paper before tapping, especially the tracing ones. Getting answers wrong now is part of how this works: trying to recall before you look makes the right answer stick better.
Fix only what you missed. ~20 min
Each question links to its lesson notes. For every miss, say out loud why the right answer is right. Skip rereading the lessons you already got right.
Retry your misses. ~10 min
Hit Retry missed. The page remembers which ones you got wrong in this browser.
Write one FRQ on paper. ~15 min
Pick the one that covers what you missed most, write it by hand, then grade yourself with the rubric. Do the others tomorrow if you have time.
Stop and sleep.
Sleep is when the brain locks in what you studied. An extra hour of cramming costs more than it gives.
Tomorrow morning: retry missed once more. ~10 min
A short second round after a gap (spacing) beats one long session.

Why this order: a large review of study techniques (Dunlosky et al., 2013) rated practice testing and spaced practice as the two most effective methods, and rated rereading and highlighting as low value. The test also mixes lessons together instead of going in order, because the real test won't tell you which lesson a question comes from.

✓ Mixed practice test

32 questions, lessons mixed. Tap an answer to check it.

✎ Free response

Write the code yourself. Do it on paper if your test is on paper; typing with autocomplete hides mistakes. Then open the sample solution and check off each rubric point you earned. Any correct solution counts, even if it doesn't match the sample.

1.9 Method Signatures

A method is a named block of code that runs when it's called. Use one when code repeats.
Procedural abstraction: you can use a method by knowing what it does, without knowing how.
Parameter = variable in the method header. Argument = value you pass in the call. In add(3, 4), 3 and 4 are arguments; in add(int a, int b), a and b are parameters.
Signature = method name + ordered list of parameter types. calc(int, double). Return type and parameter names are not part of it.
Arguments must match the parameters in number, order, and type. An int argument can go into a double parameter, but not the reverse.
Call by value: the parameter gets a copy of the argument. Changing the parameter inside the method doesn't change the caller's variable.
Overloading: same name, different signatures (different number, types, or order of parameters).
Flow of control: a call jumps into the method, runs all of it, then comes back to the line right after the call.
void methods return nothing. Non-void methods return a value of the return type, which you should store, print, or use.

TrapChanging only the return type is not overloading. int f(int x) and double f(int x) have the same signature, so that's a compile error.

1.10 Calling Class Methods

Class methods (also called static methods) have static in the header and belong to the class, not to an object.
Header pattern: public static returnType name(parameters)
Call them with the class name: ClassName.method(). Inside the same class, the class name is optional.
You can't print or store the result of a void method: System.out.println(sayHi()); is a compile error if sayHi is void.
The variable that receives a return value needs a compatible type: int x = methodReturningDouble(); is an error.

1.11 The Math Class

Math is in java.lang, so no import is needed. All its methods are static: Math.method().

Method	Returns	Example
`Math.abs(int)` / `Math.abs(double)`	Absolute value, same type as input	`Math.abs(-3)` → 3
`Math.pow(double, double)`	double: first to the power of second	`Math.pow(2, 3)` → 8.0
`Math.sqrt(double)`	double: positive square root	`Math.sqrt(16)` → 4.0
`Math.random()`	double ≥ 0.0 and < 1.0	never exactly 1.0

Random int from min to max (inclusive):

(int)(Math.random() * range) + min      // range = max - min + 1
(int)(Math.random() * 6) + 5            // 5 to 10  (range = 10 - 5 + 1 = 6)
(int)(Math.random() * 20) + 10          // 10 to 29 (biggest is 19 + 10)

Trappow and sqrt always return a double, so they print with .0 and can't be stored in an int without a cast. Also: the parentheses in (int)(Math.random() * 6) matter. (int) Math.random() * 6 casts first, which is always 0.

1.12 Objects: Instances of Classes

A class is the blueprint; it defines a new type. An object is one specific instance of a class.
Dog pet = new Dog(); → Dog is the class, pet is the object (instance).
A reference-type variable holds a reference (think: memory address) to the object, or null.
Attributes / instance variables = what an object knows (name, age). Behaviors / methods = what it can do.
Inheritance: a subclass extends a superclass and gets its attributes and behaviors. class Poodle extends Dog → Poodle is the subclass. Every class is a subclass of Object.

Trap"An instance of the pet class is Dog" has it backwards. The object is an instance of the class. Read these answer choices slowly.

1.13 Creating & Initializing Objects

A constructor builds a new object and sets its attributes. It has the same name as the class and no return type.
Call it with new: Movie m = new Movie("Up", "Docter", 8.3);
Overloaded constructors differ in number, type, or order of parameters. A no-argument constructor takes nothing: new Cat().
Arguments must match one constructor's parameter list in number, order, and type. If none matches, it won't compile.
Arguments are passed by value, same as methods.

public Cat()                                 // no-arg
public Cat(String c, String b, boolean h)    // 3 args

new Cat();                          // ✓
new Cat("orange", "Tabby", false);  // ✓
new Cat("Shorthair", true);         // ✗ no 2-arg constructor
Cat("orange", "Tabby", false);      // ✗ missing new

1.14 Calling Instance Methods

Instance methods (no static) are called on an object with the dot operator: myParty.inviteFriend();
You need an object first. Cat.meow() doesn't work if meow is an instance method.
Calling a method on null → NullPointerException (run-time error).
Arguments must match the signature. Parentheses are required even with no arguments.
Do something with a non-void method's return value: store it, print it, or use it in an expression.

	Class (static) method	Instance method
Header	`public static void go()`	`public void go()`
Call	`ClassName.go()`	`obj.go()`
Needs an object?	No	Yes

1.15 Strings heavy

Create with a literal "hi" or new String("hi"). String is in java.lang.
Strings are immutable. Methods like substring return a new String; the original never changes.
Indexes go from 0 to length() - 1. Going outside → IndexOutOfBoundsException.
+ concatenates. A primitive joined with a String becomes text. Evaluated left to right.
Compare contents with .equals, not ==.

Method (on Quick Reference)	Example with `s = "computer"`	Result
`length()`	`s.length()`	8
`substring(from, to)` to is not included	`s.substring(2, 5)`	"mpu"
`substring(from)`	`s.substring(3)`	"puter"
`substring(i, i + 1)`	`s.substring(0, 1)`	"c"
`indexOf(str)`	`s.indexOf("t")` / `s.indexOf("z")`	5 / -1
`equals(other)`	`s.equals("Computer")`	false
`compareTo(other)`	`"apple".compareTo("banana")`	negative (a comes first)

// index:  c=0 o=1 m=2 p=3 u=4 t=5 e=6 r=7
1 + 2 + "3" + 4 + 5     // 3 → "33" → "334" → "3345"
"1" + 2 + 3             // "12" → "123"
"Java".substring(4)     // "" (empty; from == length is allowed)
"Java".substring(1, 5)  // IndexOutOfBoundsException (5 > length)

How to do substring questionsWrite the word out and number every letter, starting at 0, before you answer. substring(a, b) gives b - a characters.