Using objects and methods

ALGORITHMS, INPUT, AND THE WRITE–COMPILE–RUN LOOP

An algorithm is a finite, sequenced set of steps for completing a task or solving a problem. It can be represented in ordinary written language or with a diagram. Before it becomes code, sequencing matters: each step completes one at a time, in the stated order. A trace is simply an algorithm executed on paper.

An integrated development environment, or IDE, can help write, compile, and run a program. The compiler checks syntax and type rules; code containing a detected compile-time error must be repaired before it can run. Passing the compiler does not establish correctness. Test with specific data to expose logic errors, and distinguish those from a run-time error or exception that interrupts execution.

Input may be tactile, audio, visual, or text. Java’s Scanner class is one way to obtain keyboard text, but the current AP exam does not require a particular user-input form or a particular Scanner call. Whatever the source, input becomes values stored in variables; for example, boolean confirmed = true; stores one Boolean value that later code can use.

THE ONE IDEA UNDER EVERYTHING: TWO KINDS OF BOX

Every variable is a labeled box, and there are exactly two kinds. A primitive box (int, double, boolean) holds the value itself. A reference box (String, or any class type) holds either an arrow to an object that lives somewhere else or the special value null — never the object itself.

Three consequences follow, and they organize much of the unit:

• Assignment copies what’s in the box — a value, an arrow, or null. int m = n; copies the number 7 and the two variables are then strangers. String t = s; copies the arrow, and now two variables point at one object.
• == compares what’s in the boxes. For primitives that is the exact stored value. It directly fits int and boolean; a computed double that is only approximately expected may need a tolerance. For objects that’s the arrows: true only when both variables hold the same reference; two null references also compare true. For Strings, .equals reads the characters. Other classes define their own documented equality behavior, or inherit identity-based equals from Object.
• A method called through a non-null reference travels down the arrow and acts on whatever it finds there — which may be an object that other variables also point at. Calling an instance method through null instead throws a NullPointerException.

The dependable rule is question-specific: use .equals for String content and compareTo for String order. Use == only when reference identity is actually the question. Problem 5 shows why == cannot stand in for String-content equality.

TYPES, DECLARATIONS, AND THE COMPOUND ASSIGNMENTS

The three primitive types this unit uses. int — whole numbers, no fractional part, ever. double — real-number values represented with finite precision. boolean — true or false, nothing else. Their names are lowercase because they are built into the language. Class types — String, Counter, anything you or somebody else wrote — are capitalized by convention, and they are reference types.

A declaration builds the box; an assignment fills it. int a = 8; does both at once: make a box named a that can hold an int, and put 8 in it. The type is chosen once and never changes — an int box cannot later hold 3.5, and the compiler will refuse rather than round.

A literal has a type of its own, before any variable sees it. 5 is an int. 5.0 is a double. "5" is a String. Those are three different things, and the difference between the first two is what decides whether a division keeps its remainder. When you write 2.0 instead of 2 in a division, you are not decorating — you are changing which operation runs.

= is not equality. a = a + 1; is not a false statement about numbers; it is an instruction with two halves: evaluate the right side using the values that exist right now, then store the result in the box on the left, discarding whatever was there. Read every assignment right side first.

Compound assignment performs, converts, then stores.

For the same-type examples in this guide, the result matches the familiar long form. In full Java, however, compound assignment also converts the result back to the left variable’s type. Thus int a = 5; a /= 2.0; compiles and stores 2, while a = a / 2.0; does not compile without a cast. The left-hand location is also evaluated once, a distinction that matters for more complex expressions later in the course.

PRECEDENCE AND ORDER OF EVALUATION

Two separate questions, and mixing them up is its own error. Precedence says which operator claims which operands. Order says which one fires first among equals.

The binary arithmetic and concatenation operators shown here evaluate left to right within a tier. That rule decides 17 / 5 * 5.0 (the division goes first, on two ints) and "total: " + a + b (the left + makes a String, so the right one can only glue). Both look like they should come out otherwise, and neither does.

Assignment comes after the right-side expression. The entire right side finishes before anything is stored — so the type of the variable on the left cannot reach backwards and change how the arithmetic ran.

Assignment expressions themselves associate right to left, but chained assignment expressions are outside the AP CSA scope.

INTEGER ARITHMETIC: / AND %

When both operands are int and the divisor is nonzero, the answer is an int — and an int has nowhere to put a fraction. So Java splits the result in two: / hands you the whole part and % hands you what was left over. Neither one is broken. Between them they lose nothing; take only one and you have thrown half the answer away.

The negative cases are the ones that surprise people, and the reason is one word: truncation is toward zero, not downward.

And % takes its sign from the left operand, which is not an arbitrary decision either. Java guarantees that the quotient and the remainder fit back together:

Check it both ways: $3\cdot 5+2=17$, and $(-3)\cdot 5+(-2)=-17$. Once the quotient truncates toward zero, the remainder has no choice about its sign — it has to make up the difference back to a negative dividend, so it must be negative. This identity is also the fastest self-check you own: if your quotient and remainder don’t rebuild the number you started with, one of them is wrong and you know it in five seconds.

Scope and zero. The signed examples above describe Java, but a negative dividend for % is outside the current AP CSA exam scope. Integer division by zero is required knowledge: an expression such as 17 / 0 throws an ArithmeticException at run time. The program does not receive a quotient.

Two idioms worth recognizing on sight, because they show up everywhere later: for a non-negative n, n % 10 is its last digit and n / 10 is n with that digit removed. Together they take a number apart one digit at a time. (Negative n gives a negative last digit, for exactly the reason above.)

CASTING: MOVING BETWEEN INT AND DOUBLE

Widening is automatic. An int can always be carried inside a double without losing anything, so Java promotes it for you the moment the two meet in one operation: 17 / 5.0 is real division, and the 17 becomes 17.0 on its way in. No cast needed, no permission asked.

Narrowing must be requested, and it truncates. Going the other way loses information, so Java refuses to do it silently — you have to write (int), which is you signing for the loss. And it chops rather than rounds, toward zero from both sides: (int) 7.9 is 7 and (int)(-7.9) is -7.

A cast grabs only the next value — it sits in the tightest precedence tier, alongside parentheses. This is where the two forms separate:

A cast produces a value; it does not change a variable. After (int) x, the variable x is still a double holding exactly what it held before. The cast made a temporary int for that one expression to use.

The rounding idiom. The AP reference sheet hands you abs, pow, sqrt, and random — and no rounding method at all. So you build one:

Adding 0.5 moves every value that deserves to round up across the next whole number, and leaves every value that doesn’t below it. Truncation then does the rest. For negative x, subtract instead: (int)(x - 0.5), because “round away from the fraction” now points the other way — (int)(-6.78 + 0.5) is -6, which is wrong, and (int)(-6.78 - 0.5) is -7, which is right.

FINITE STORAGE: INTEGER OVERFLOW AND DOUBLE ROUND-OFF

Java gives every int four bytes. Its inclusive endpoints are Integer.MIN_VALUE ($-\mathrm{2,147,483,648}$) and Integer.MAX_VALUE ($\mathrm{2,147,483,647}$). If an integer expression’s mathematical result lies outside that range, an integer overflow occurs. Java still stores an allowed int, but it may not be the mathematical value you expected:

No compiler message announces the overflow. Before adding or multiplying large whole-number quantities, compare the possible result with the two named limits.

A double also has finite storage. Many decimal fractions cannot be represented exactly in binary, so the stored result is the nearest representable value. That round-off error is why 0.1 + 0.2 can produce 0.30000000000000004 rather than exactly 0.3. Use int when the quantity is inherently a whole-number count and must remain exact; for measured or fractional quantities, carry enough precision and round only as the task requires.

STRINGS: INDEXING, SUBSTRING, IMMUTABILITY

A String is an object, and its characters are numbered from 0. Spaces are characters and get numbers like everything else. Every question in this family becomes reading rather than guessing the moment you draw the ruler.

On compareTo, and what this guide does with it. It is on the AP Java Quick Reference, so the exam may hand it to you — and the reference sheet specifies only the sign, which means the sign is all you should ever reason from. The comparison runs left to right and stops at the first position where the two strings differ; if neither differs and one simply runs out, the shorter string comes first. Capital letters sort before lowercase ones, which is the result that surprises people: "Zoe".compareTo("ada") is negative. No problem in this guide exercises it, because every comparison here asks whether two things are equal — that is .equals’s job, not ordering. It is in the table so the reference sheet is not the first place you meet it.

Legal ranges, precisely. For substring(a, b) you need $0\le \mathtt{\text{𝚊}}\le \mathtt{\text{𝚋}}\le \mathtt{\text{𝚕𝚎𝚗𝚐𝚝𝚑()}}$. Note the last one: b is allowed to equal the length, one past the last valid character index — that is how you say “to the end,” and it is legal precisely because b is a cut line rather than a character. An index outside that range is not a wrong answer, it is a crash: StringIndexOutOfBoundsException, at run time.

indexOf fails politely. It returns -1 rather than crashing when the argument isn’t there, and -1 was chosen because it is not a valid index — there is no way to confuse it with a real answer. It also reports where the match starts, and it matches the whole argument, so a partial match at an earlier position does not count.

Strings are immutable, and this is the fact with consequences. A String object cannot be modified after it is built. A method that appears to transform text returns a String result while leaving the original unchanged; the API does not promise that every such result has a fresh identity.

• Ignoring a returned String has no persistent effect on the variable. word.substring(0, 3); drops the returned reference. Store it in another variable or assign it back to word; neither operation modifies the original object.
• You can hand a String to any method without defending it. Nobody can alter it. This is why Strings are safe in a way that mutable objects (Problem 5’s Counter) are not.

The one-character idiom is substring(i, i + 1) — length $(i+1)-i=1$, by the same subtraction as everything else. Escapes inside literals: \n (new line), \" (a quote that doesn’t end the string), \\ (a backslash).

String is in java.lang. A literal is the usual way to create one, but new String("hi") also calls a String constructor and creates a distinct String object containing the same characters.

APIS, COMMENTS, CONTRACTS, AND SIGNATURES

A library is a collection of classes; related classes are grouped into a package. An application programming interface, or API, documents how clients may use those classes: their attributes, behaviors, constructors, methods, parameter types, return types, and stated conditions. The implementation may remain hidden. The Math and String classes belong to the java.lang package, which is available without an import.

Comments are ignored during execution but communicate intent: // begins a one-line comment, /* ... */ encloses a block comment, and /** ... */ is a Javadoc comment used to generate API documentation. A precondition must be true just before a method runs for its promised behavior to apply; the method is not required to check it. A postcondition states what must be true after a successful call, in terms of a return value or object state.

A method signature is its name plus its ordered list of parameter types; the return type is not part of the signature. A constructor signature uses the class name plus ordered parameter types. Methods or constructors are overloaded when one class supplies the same name with different signatures. Documentation tells you which one matches the number, order, and compatible types of the arguments.

A parameter is the local variable declared in a header; an argument is the value supplied at a call. Java uses call by value: a primitive argument copies its value, while an object argument copies its reference. The method can therefore mutate a shared object, but reassigning the parameter cannot retarget the caller’s variable. Control enters at the call and returns after return or the end of a void method.

OBJECTS: NEW, CONSTRUCTORS, AND READING A CLASS

A class is a description — what one object of that kind knows, and what it can do. Reading one is a four-line skill:

What new Counter(3) actually does, in order: builds a new object with its own set of instance variables; runs the constructor with the argument 3; and hands back an arrow to that object, which is what gets stored in your variable. In a trace of explicit constructor calls such as Problem 5, each successful new Counter(...) creates one Counter object. Other expressions and library code can allocate objects without a visible new, so do not turn that local counting tool into a rule about every object in a program.

void has no value, so it cannot be used as one. System.out.println( b.increment()); does not compile — not sometimes, not depending on anything else in the program. The message is ’void’ type not allowed here, and it is exactly right: there is nothing there to print. A void method is a command; a returning method is a question.

NULL, INHERITANCE, AND OBJECT TEXT

A reference variable may hold an object reference or the special literal null, meaning it currently refers to no object. The assignment Counter c = null; is legal. Calling an instance method through that reference, such as c.getCount(), throws a NullPointerException at run time because there is no receiving object. Merely declaring or assigning the null reference does not throw.

Related classes can share attributes and behaviors through inheritance: a subclass draws on a superclass. Every Java class ultimately inherits from the Object class. Designing and implementing inheritance relationships is outside the current AP CSA scope, but recognizing the relationship is not.

One inherited behavior explains object concatenation. When a String is concatenated with an object, Java uses that object’s toString method to obtain text. Every class has such a method through Object; a class may supply a more useful class-specific result. Implementing a toString override is outside the current exam scope, but using the documented result is required Unit 1 reasoning.

CALLING METHODS: STATIC, INSTANCE, AND THE MATH CLASS

The calls emphasized in this unit normally advertise their kind before the dot. A class method is typically called with the class name; inside its own class, that qualifier may be omitted. An instance method is called on an object expression. Java also permits the discouraged syntax of calling a static method through an instance, so the method’s documented header — not punctuation alone — is the final authority.

• Constructor: new ClassName(args) — builds the object, runs the constructor, hands back the arrow.
• A returned value you don’t capture evaporates. The method still ran; the answer just went nowhere. Store it, print it, or use it inside a larger expression.
• The class-name rule is about the method, not the class. String does have static methods — String.valueOf(7) is one — so “String methods are instance methods” is not the rule. The rule is that length is a fact about a particular String, and a fact about a particular object needs that object.

The Math methods this unit leans on, with the return type that catches people:

Build the random range rather than memorizing it, in three moves — scale, truncate, shift. For a positive integer range, (int)(Math.random() * range) + min produces the integers min through min + range - 1. Every time you use it, check the two ends by hand; the half-open interval $[0.0,1.0)$ is what makes the top end come out one lower than it looks.

THE + OPERATOR, AND HOW VALUES PRINT

+ has two entirely different jobs, and which one runs is decided operand by operand, at the moment that particular + fires:

Because + runs left to right, and because the result of a concatenation is itself a String, the first String in a chain converts every + after it. Nothing downstream can turn the gluing back off — but parentheses can protect arithmetic by making it happen first.

How the printed characters get chosen. An int prints as its digits and nothing else. A double always prints with a decimal point, even when the value is whole: the number 4 stored in a double prints as 4.0, and that .0 is part of the exact output. Otherwise Java prints the shortest run of digits that could only mean the value it is holding, which is why 12.75 prints as 12.75 and not 12.750000.

System.out.println versus System.out.print: println ends the line, so the next output starts below; print leaves the cursor where it is. Count your line breaks when the question asks for exact output — they are graded too.

THREE KINDS OF ERROR, AND WHICH ONE YOU ARE LOOKING AT

Naming the kind is most of the diagnosis, because each kind is found a different way.

The compiler checks grammar and types. It has no access to your intentions, so it cannot catch a mismatch between a legal computation and the intended algorithm. Integer division or an in-range off-by-one index is a logic error only when it produces unintended behavior; an out-of-range String index instead throws a run-time exception. Problem 7 contains one compile-time error and two logic errors, while Problem 4’s out-of-range case illustrates a run-time exception.