AP Computer Science A Unit 1 Review: Using Objects and Methods

An algorithm is a step-by-step process where sequencing matters: each step runs one at a time in order. Java source code is written in a text editor or IDE, then a compiler translates it into a form the computer can run. The compiler catches some errors before the program runs, but not all of them.

• Syntax error: A violation of Java language rules caught by the compiler before the program runs; for example, a missing semicolon or mismatched brace.
• Logic error: A mistake in the algorithm that causes wrong output; the program compiles and runs but produces an unexpected result. Found only through testing.
• Run-time error: An error that occurs during execution and typically terminates the program abnormally; for example, dividing an int by zero.
• Exception: A specific type of run-time error, such as ArithmeticException or NullPointerException, that interrupts normal program flow.
• IDE: An integrated development environment that provides tools to write, compile, and run code in one place.

A variable is a named storage location whose value can change while the program runs. Every variable has a declared type. The three primitive types in AP CSA are int (whole numbers), double (real numbers), and boolean (true or false). Reference types, like String, store a pointer to an object rather than the value itself. You must initialize a variable before using it in an expression.

• int: Stores whole-number values; arithmetic between two ints produces an int result.
• double: Stores real-number values; any arithmetic involving at least one double produces a double result.
• boolean: Stores only true or false; used in conditions and logical expressions.
• Reference type: A type whose variable holds a memory address pointing to an object, not the object's value directly. String is the main reference type in Unit 1.
• Variable declaration: Syntax: type variableName; or type variableName = value; The variable must be initialized before use.

System.out.print displays output and keeps the cursor on the same line; System.out.println moves to a new line after printing. Arithmetic expressions follow precedence rules: *, /, and % evaluate before + and -. When both operands are int, division truncates the decimal. Mixing an int and a double promotes the result to double. The + operator concatenates strings when at least one operand is a String.

• System.out.println vs System.out.print: println adds a newline after output; print does not. Both accept strings, numbers, and expressions.
• Integer division: 7 / 2 evaluates to 3, not 3.5, because both operands are int. The fractional part is discarded.
• Remainder operator %: 7 % 2 evaluates to 1. Useful for checking divisibility or cycling through a range.
• Operator precedence: *, /, % are evaluated before + and -. Use parentheses to override the default order.
• String concatenation: "Score: " + 95 produces "Score: 95". A primitive concatenated with a String is implicitly converted to a String.

The assignment operator = evaluates the right-hand expression first, then stores the result in the left-hand variable. The value must be a compatible type. Casting with (int) or (double) converts between primitive types explicitly. Casting a double to an int truncates toward zero. Widening from int to double happens automatically. Integer overflow occurs when an int expression exceeds Integer.MAX_VALUE or goes below Integer.MIN_VALUE, producing an unexpected in-range result. Round-off error occurs when a double value cannot be represented exactly in memory.

• Assignment operator =: Stores the value of the right-hand expression into the left-hand variable. Not equality comparison.
• (int) cast: Truncates the decimal part of a double: (int) 3.9 produces 3, not 4.
• Widening conversion: An int is automatically promoted to double when needed, such as in mixed arithmetic or assignment to a double variable.
• Integer overflow: When an int result exceeds Integer.MAX_VALUE (about 2.1 billion), it wraps around to a negative value instead of throwing an error.
• Round-off error: A double cannot always represent a value exactly, so the stored result may differ slightly from the mathematical result.

Compound assignment operators combine an arithmetic operation with assignment in one step. x += 5 is equivalent to x = x + 5. The post-increment operator x++ adds 1 to x and stores the result back in x. These operators appear frequently in loop counters and running totals, so tracing the exact value of a variable after each statement is the key skill.

• +=, -=, *=, /=, %=: Each performs the indicated operation on the current variable value and the right-hand operand, then stores the result back in the variable.
• x++ (post-increment): Adds 1 to x and stores the new value in x. In AP CSA, x++ is used as a standalone statement, not inside a larger expression.
• x-- (post-decrement): Subtracts 1 from x and stores the new value in x.

A library is a collection of classes grouped into packages. An API specification tells you how to use those classes without needing to read their source code. Attributes are the data a class stores in variables; behaviors are what the class can do, defined by methods. Comments document code for human readers but are ignored by the compiler. Preconditions state what must be true before a method runs; postconditions state what is guaranteed to be true after it runs.

• API: Application programming interface: documentation that describes a class's attributes and behaviors so you can use it without knowing its internal implementation.
• Single-line comment //: Documents one line; ignored by the compiler.
• Block comment /* */: Documents multiple lines; ignored by the compiler.
• Javadoc comment /** */: Used to generate API documentation; appears before class and method headers.
• Precondition / postcondition: A precondition must be true before a method is called. A postcondition describes what is guaranteed to be true after the method returns.

A method signature consists of the method name and its ordered list of parameter types. Arguments passed in a method call must match the parameter list in number, order, and compatible type. Void methods do not return a value and cannot be used in an expression. Non-void methods return a value that must be stored or used. Static (class) methods belong to the class, not to any object, and are called using the class name and dot operator, like Math.sqrt(16).

• Method signature: The method name plus the ordered list of parameter types. Return type is not part of the signature.
• Call by value: Arguments are copied into parameters. Changing a parameter inside a method does not affect the original variable.
• Void method: Returns no value; called as a standalone statement. Example: System.out.println("hi");
• Non-void method: Returns a value of the declared return type; the result must be stored or used in an expression.
• Static method: Belongs to the class, not an instance. Called as ClassName.methodName(args). The keyword static appears in the method header.
• Method overloading: Multiple methods share the same name but have different parameter lists. The compiler selects the correct version based on the arguments.

The Math class is in java.lang, so no import is needed. All Math methods are static. The four methods on the Java Quick Reference are Math.abs (int and double versions), Math.pow(base, exponent), Math.sqrt(x), and Math.random(). Math.random() returns a double in [0.0, 1.0). To generate a random int in a range, use the scale-and-shift pattern: (int)(Math.random() * (max - min + 1)) + min for an inclusive range.

• Math.abs(x): Returns the absolute value of x. Works for both int and double arguments.
• Math.pow(base, exp): Returns base raised to the power exp as a double. Math.pow(2, 10) returns 1024.0.
• Math.sqrt(x): Returns the nonnegative square root of x as a double.
• Math.random(): Returns a random double d where 0.0 <= d < 1.0. Cast and scale to get integers in a specific range.
• Scale-and-shift formula: (int)(Math.random() * (max - min + 1)) + min generates a random int from min to max inclusive.

A class is the blueprint that defines attributes (instance variables) and behaviors (methods). An object is a specific instance of a class created at runtime. You create an object with the new keyword followed by a constructor call. The constructor's name matches the class name, and constructors can be overloaded. A reference variable stores the memory address of the object. If a reference variable holds null, calling any method on it causes a NullPointerException.

• Class vs object: A class defines the structure; an object is a specific instance with its own attribute values created from that class.
• Constructor: A special method with the same name as the class, called with new to initialize a new object's attributes.
• Constructor overloading: Multiple constructors with different parameter lists allow objects to be created with different initial values.
• Object reference: A reference variable holds the memory address of an object, not the object itself. Two variables can reference the same object.
• null: A special value indicating a reference variable does not point to any object. Calling a method on null causes NullPointerException.

Instance methods are called on a specific object using the dot operator: objectReference.methodName(arguments). Each object runs the method using its own instance variables, so two objects of the same class can return different results from the same method call. A void instance method is called as a standalone statement. A non-void instance method returns a value that must be stored or used. Always verify the reference is not null before calling a method on it.

• Dot operator: Used between an object reference and a method name to call an instance method: myObject.doSomething().
• NullPointerException: Thrown at runtime when you call an instance method on a reference variable that holds null.
• Instance method vs static method: Instance methods require an object; static methods are called on the class name. Both use the dot operator but with different left-hand sides.

A String is an immutable reference type in java.lang. You can create one with a string literal or with new String(). Because Strings are immutable, methods like substring and toUpperCase return new String objects; they do not modify the original. String indices run from 0 to length() - 1. The five String methods on the Java Quick Reference are length(), substring(from, to), substring(from), indexOf(str), equals(other), and compareTo(other).

• String immutability: Once created, a String's characters cannot change. Methods return new String objects rather than modifying the original.
• length(): Returns the number of characters in the String as an int. "hello".length() returns 5.
• substring(from, to): Returns the substring from index from up to but not including index to. "hello".substring(1, 3) returns "el".
• indexOf(str): Returns the index of the first occurrence of str, or -1 if not found.
• equals(other): Returns true if the two Strings contain the same sequence of characters. Use equals, not ==, to compare String content.
• compareTo(other): Returns a negative int if this String comes before other lexicographically, 0 if equal, positive if after.