1. What Is a Computer?

A computer is more than just a desktop or laptop; it is any device

capable of storing and processing data. While computers vary in
design, they share two essential hardware components:

 Processors (CPUs): These perform the actual computations

and simple calculations.

 Memory (RAM): This temporarily stores information while

the computer is turned on.

2. Programming Fundamentals

A program is a sequence of instructions specifying how to

perform a computation, which can range from mathematical
equations to text processing. Most programming languages use
five basic types of instructions:

 Input: Getting data from a keyboard, file, or sensor.

 Output: Displaying data on a screen or sending it to a file.

 Math: Performing basic operations like addition and division.

 Decision: Checking for specific conditions and executing the

appropriate code.

 Repetition: Performing an action repeatedly, usually with

variations.

3. Java Language Basics: The "Hello World" Program

The "Hello World" program is the traditional first step in learning

a language; its sole purpose is to display a message on the
screen. Key structural elements include:

 Classes and Methods: Java programs are made of class

definitions (collections of related methods) and methods
(named sequences of statements).

 Statements: A statement is a single line of code performing

a basic action, such as a print statement.

 Case-Sensitivity: Java distinguishes between uppercase and

lowercase letters (e.g., System is not the same as SYSTEM).

 Comments: Text beginning with // is a comment, used to

explain code to humans; Java ignores these during
execution.

4. Compiling and Running Java

Java is a high-level language, meaning it is designed to be easy
for humans to read and write, unlike low-level languages
(machine language) designed for computers.

 Portability: High-level languages can run on different types

of computers with little modification.

 The Hybrid Approach: Java uses both a compiler and an

interpreter. A compiler (javac) translates source code into
byte code, which is a special format for the Java Virtual
Machine (JVM). The Java interpreter then runs this byte code
on the specific hardware.

5. Formatting and Escape Sequences

 Output Control: [Link] appends a newline

(moving the cursor to the next line), while [Link]
does not.

 Strings: Sequences of characters enclosed in quotation

marks are called strings.

 Escape Sequences: These are special codes used inside

strings to represent characters that are otherwise hard to
type:

o \n : Newline

o \t : Tab

o \" : Double quote

o \\ : Backslash

 Formatting: While some spaces are required (like between

public and class), most whitespace and newlines are
optional but critical for making code readable for humans.

6. Computer Science and Debugging

Computer science is the science of algorithms, involving their

discovery and analysis. An algorithm is a step-by-step procedure
for solving a problem.

 Bugs: Programming errors are called bugs.

 Debugging: This is the process of tracking down and

correcting errors. It is described as an "experimental
science" where you form hypotheses about what is wrong
and test them through trial and error.
7. Key Vocabulary Summary

 Executable: Object code that is ready to run on specific

hardware.

 Source Code: A program written in a high-level language

before being compiled.

 Problem Solving: The process of formulating a problem,

finding a solution, and expressing it.

 Interpret: To run a high-level program by translating and

executing it line-by-line.

 Compile: To translate a high-level program entirely into a

low-level language before execution.

1. Understanding Variables

A variable is a named location in memory used to store a value.

 Declaration: Before using a variable, you must declare it by

specifying its type and name (e.g., String message; or int x;).

 Type: Determines what kind of values a variable can hold (e.g., int
for integers, char for single characters, double for decimals).

 Naming Rules:

o Names are case-sensitive (firstName is different from

firstname).

o They typically start with a lowercase letter.

o You cannot use keywords—reserved words like public, class,

or void that the compiler uses to understand the program's
structure.

2. Assignments and State

 Assignment Statement: Uses the = symbol to store a value in a

variable (e.g., hour = 11;).

 Initialization: The process of assigning a value to a variable for the

first time.

 The Concept of State: At any point during execution, the current

values of all variables represent the program's state.

 Memory Diagrams: A graphical way to represent the state of a

program, showing variables as boxes with their current values
inside.
3. Printing Variables

You can display a variable's value using [Link] or

[Link].

 To print the value of a variable, use its name without quotes (e.g.,
[Link](hour);).

 To print a literal name, put it in quotes (e.g.,

[Link]("hour");).

4. Arithmetic Operators and Expressions

Java uses standard symbols for simple computations: + (addition), -

(subtraction), * (multiplication), and / (division).

 Expressions: Combinations of variables, operators, and values that

represent a single value (e.g., hour * 60 + minute).

 Operands: The values an operator acts upon.

 Integer Division: Dividing two integers always results in an

integer, rounding toward zero. For example, 59 / 60 results in 0
rather than 0.98333.

5. Floating-Point Numbers and Rounding

 Double: The default Java type for representing numbers with

decimal places.

 Floating-Point Division: If at least one operand is a double, Java

performs floating-point division (e.g., 59.0 / 60.0 results in
0.9833333333333333).

 Rounding Errors: Most floating-point numbers are only

approximate representations because repeating fractions cannot be
stored exactly in binary. This can lead to small inaccuracies over
time.

 Conversion: Java will automatically convert an int to a double (e.g.,

double y = 1;), but it will not automatically convert a double to an
int because it might lose information.

6. String Operations

 Concatenation: The + operator, when used with strings, joins

them end-to-end (e.g., "Hello, " + "World!").

 Automatic Conversion: When you add a number to a string, Java

converts the number to a string and then concatenates them (e.g.,
 "Hello" + 1 + 2 results in "Hello12", whereas 1 + 2 + "Hello" results
in "3Hello").

7. Order of Operations

Also known as operator precedence, these rules determine the order in

which expressions are evaluated.

 Multiplication and division take precedence over addition and

subtraction.

 If operators have the same precedence, they are evaluated from left
to right.

 Parentheses can be used to override these rules or to make the

code easier to read.

8. Types of Programming Errors

Understanding the three main types of errors is critical for debugging:

1. Compile-time (Syntax) Errors: Occur when rules of the language

are violated (e.g., a missing semicolon or unmatched braces). The
compiler finds these during the parsing phase before the program
runs.

2. Run-time Errors (Exceptions): Occur while the program is

running and cause it to "crash" (e.g., dividing by zero).

3. Logic Errors: The program runs successfully but produces the

wrong result because the programmer's logic was flawed.

1. The System Class and Packages

 The System Class: System is a built-in class providing methods

related to the environment where programs run.

 [Link]: This is a special value (an object) of the type

PrintStream, which provides the println method.

 Packages: A package is a collection of related classes. [Link]

belongs to the [Link] package (input/output).

 Automatic Imports: The [Link] package, which includes System

and String, is imported automatically by Java.

2. Reading Input with the Scanner Class

To read data from the keyboard, Java provides the Scanner class in the
[Link] package.
  Importing: You must use an import statement at the beginning of
your file: import [Link];.

 Setup: To create a Scanner that reads from the keyboard, use:

Scanner in = new Scanner([Link]);.

 Key Methods:

o nextLine(): Reads a full line of text and returns it as a String.

o nextInt(): Reads the next input and converts it to an integer.

o nextDouble(): Reads the next input and converts it to a

double.

3. Java Language Elements

Programs are organized into a hierarchy from largest to smallest units:

1. Package: A directory of related classes (e.g., [Link]).

2. Class: A collection of related methods (e.g., Scanner).

3. Method: A sequence of statements (e.g., main).

4. Statement: A line of code that performs a computation (e.g.,

variable assignment).

5. Expression: A combination of variables and operators representing

a single value (e.g., hour * 60).

6. Token: The most basic program element, including numbers,

variable names, and keywords.

4. Literals, Constants, and "Magic Numbers"

 Literals: Values that appear directly in source code, like the number
2.54 or the string "Hello".

 Magic Numbers: Using literals without explanation (e.g., using

2.54 in a calculation instead of a named variable). This is considered
poor practice because it makes code hard to maintain.

 Constants: Variables declared with the final keyword. Their values

cannot be changed once initialized.

o Convention: Constant names are written in

ALL_CAPS_WITH_UNDERSCORES.

5. Formatting Output with printf

While print and println are simple, printf (formatted print) provides
precise control over how values appear.
  Format String: The first argument, containing text and format
specifiers.

 Format Specifiers: Special codes starting with % that act as

placeholders.

o %d: For integers (base 10 "decimal").

o %f: For floating-point numbers.

o %.2f: Rounds a floating-point number to 2 decimal places.

o %s: For strings.

o \n: Often needed at the end of a format string because printf

does not add a newline automatically.

6. Type Casting and Operators

 Type Casting: An operation to explicitly convert one data type to

another, such as converting a double to an int using (int).

o Note: Casting a floating-point number to an integer rounds

toward zero, effectively throwing away the fractional part.

 Remainder (Modulo) Operator: Represented by %, it calculates

the remainder of a division (e.g., 76 % 12 is 4). It is useful for
checking divisibility or extracting the last digits of a number.

7. Common Pitfalls and Debugging

 The "Scanner Bug": When you use nextInt() or nextDouble()

followed by nextLine(), the program may skip the input for
nextLine(). This happens because nextInt() leaves a newline
character in the input stream.

o Solution: Add an extra [Link](); after reading a number to

"clear" the newline character.

 Stack Trace: When a run-time error occurs (like a

MissingFormatArgumentException in printf), Java provides a list of
methods that were running at the time of the crash to help you
locate the error.

1. Defining New Methods

A method is a named sequence of statements that performs a specific

action.
  Void Methods: Some methods, like println, carry out actions
without returning a result. These use the void keyword in their
definition.

 Syntax & Naming: By convention, method names start with a

lowercase letter and use camelCase (e.g., newLine or threeLine).
You can use any name except for Java keywords or main.

 Classes and Methods: Methods are defined within a class. A class

is essentially a collection of related methods.

2. Flow of Execution

The flow of execution refers to the order in which Java runs statements.

 The Main Entry Point: Programs always begin at the first

statement of main, regardless of where it appears in the source file.

 The "Detour" Concept: When a method is invoked (called), the

program jumps to the first line of that method, executes all its
statements, and then returns to the exact spot in the previous
method where it left off.

 Benefits of Multiple Methods:

o Readability: Allows you to name blocks of statements,

making code easier to understand.

o Conciseness: Eliminates repetitive code by allowing you to

call a single method multiple times.

o Decomposition: Helps break complex problems into smaller,

manageable sub-problems.

o Testing: Makes it easier to test individual parts of a program

in isolation.

3. Parameters and Arguments

To make methods more flexible, they can accept input values.

 Arguments: The actual values provided in parentheses when you

call a method (e.g., the string "Hello" in println("Hello")).

 Parameters: Variables defined in the method's header that specify

what type of arguments are required (e.g., int hour).

 Parameter Passing: The process where the value of an argument

is assigned to the corresponding parameter variable before the
method executes.
  Local Variables: Variables and parameters defined inside a method
only exist within that specific method. This area where a variable
can be used is called its scope.

 Multiple Parameters: Methods can take multiple inputs, but the

arguments provided must match the parameters' types in the
correct order.

4. Stack Diagrams

A stack diagram is a visual representation of the program's state at a

specific point in time.

 Frames: Each currently running method has a box called a frame

containing its local variables and parameters.

 Hierarchy: Frames are "stacked" from top to bottom, representing

the order of method calls. This helps programmers track variable
values and scope during complex executions.

5. Math Methods and Composition

Java's Math class (found in [Link]) provides thousands of pre-written

methods for mathematical operations.

 Common Methods: Includes [Link] (square root), [Link],

[Link], [Link], and [Link].

 Constants: Provides high-precision constants like [Link] and

Math.E.

 Composition: This is the ability to use one method as an argument

for another or combine them into complex expressions (e.g.,
[Link]([Link](10.0))).

6. Return Values

Unlike void methods, value-returning methods compute a result and

"send it back" to the caller.

 Return Type: These methods must declare the type of value they
return (e.g., public static double calculateArea).

 Return Statement: They use a return statement followed by an

expression that matches the declared return type. Once a return is
executed, the method ends immediately.

7. Incremental Development and Testing

To avoid long debugging sessions, the sources recommend incremental

development—writing and testing a few lines of code at a time.
  Stub: A placeholder for an incomplete method (often just the
header and a dummy return statement) that allows the rest of the
program to compile while you work.

 Scaffolding: Temporary code, such as extra println statements,

used during development to verify intermediate values. This code is
removed once the program works correctly.

Key Vocabulary Recap

 Invoke: To cause a method to execute (also called "calling").

 Long: A 64-bit integer type used for very large whole numbers (up
to 9 quintillion).

 Temporary Variable: A short-lived variable often used to store

intermediate results during debugging.

1. Relational Operators

Relational operators test the relationship between two values, resulting in

a boolean value (true or false).

 The Six Operators:

o == : equal to

o != : not equal to

o > : greater than

o < : less than

o >= : greater than or equal to

o <= : less than or equal to.

 Key Distinction: Do not confuse the assignment operator (=) with

the relational operator (==).

 Compatibility: The two sides being compared must be compatible.

For example, comparing an int to a String is invalid. However, if you
compare an int to a double, Java automatically converts the int to a
double before evaluating.

2. Conditional Statements (if-else)

Conditional statements allow programs to check conditions and react

accordingly.

 The if Statement: The simplest form; it executes a block of code

only if the condition in parentheses is true.
  The if-else Statement: Provides two "branches" of execution. If
the condition is true, the first block runs; if false, the else block runs.

 The Use of Braces {}: While optional for single-line branches, it is

a best practice to always use braces to avoid logic errors (like the
famous Apple "goto fail" bug) and improve readability.

 Common Error: Placing a semicolon immediately after an if

condition (e.g., if (x == 0);) creates an empty statement, causing
the code that follows to execute regardless of the condition.

3. Chaining and Nesting

For more complex decision-making, you can combine multiple conditional

statements.

 Chaining: Using else if to check a series of related conditions until

one is true. An optional final else acts as a "catch-all".

 Nesting: Placing one conditional statement inside another. This is

useful for hierarchical decisions, but requires careful indentation to
remain readable.

4. The switch Statement

When you need to choose between many possible values for a single
expression (like a menu or converting digits to words), a switch statement
can be cleaner than long if-else chains.

 Structure: Organized into case blocks. Each case should end with a
break statement to prevent execution from "falling through" to the
next case.

 Default: An optional default block executes if none of the specific

cases match.

5. Logical Operators

Logical operators combine boolean values to create more complex

conditions.

 && (AND): True only if both sides are true.

 || (OR): True if at least one side is true.

 ! (NOT): Negates the value (e.g., !true is false).

 Short-circuit Evaluation: Java optimizes by only evaluating the

second half of a logical expression if necessary. For instance, in false
&& anything, Java skips "anything" because the result is guaranteed
to be false.
6. De Morgan’s Laws

These are mathematical rules used to simplify or negate complex logical

expressions.

 !(A && B) is the same as !A || !B

 !(A || B) is the same as !A && !B.

 They also apply to relational operators: negating < results in >=.

7. Boolean Variables and Methods

 Boolean Variables: You can store the result of a comparison in a

boolean variable.

 Flags: A boolean variable used to signal the "presence or absence"

of a specific condition.

 Naming Convention: It is better to use if (flag) rather than if (flag

== true), as it is less redundant.

 Boolean Methods: Methods can return boolean values, which is

helpful for hiding complex tests inside a named function (e.g.,
isSingleDigit(int x)).

8. Input Validation

One of the most important tasks in programming is ensuring user input is

valid before processing it.

 Protecting Against Crashes: Using [Link]() on text

input will cause a run-time error (InputMismatchException).

 hasNextDouble(): This Scanner method checks if the next input

can be read as a number without actually reading it yet. This allows
you to print an error message instead of crashing.

 [Link]: A dedicated output stream for error messages and

warnings, which often appears in a different color in development
environments.

 Early Exit: Using a return statement inside main allows you to

terminate the program early if validation fails.

9. Key Vocabulary Summary

 Block: A sequence of statements surrounded by braces.

 Branch: One of the alternative blocks of code in a conditional

statement.
 NaN: A special value standing for "not a number," often returned by
math operations like [Link](-1).

 Validate: To confirm an input value is the correct type and within

the expected range.

1. Iteration and the while Statement

The process of running the same code multiple times is called

iteration. A loop is a statement that executes a sequence of
statements repeatedly.

 The while Loop: This statement repeats a block of code as long as

a specified boolean condition remains true.

 Flow of Execution:

1. Evaluate the condition in parentheses (resulting in true or

false).

2. If false, skip the loop body.

3. If true, execute the loop body and return to step 1.

 Infinite Loops: If the loop's condition is always true, it will repeat

forever. This usually happens when the loop body fails to update
the variables that control the condition.

2. Increment and Decrement Operators

Java provides concise shorthand for updating variables, which is

frequently used in loops.

 Increment (++): Adds 1 to a variable (e.g., i++ is the same as i = i

+ 1).

 Decrement (--): Subtracts 1 from a variable (e.g., i-- is the same as

i = i - 1).

 Compound Assignment: += and -= allow for incrementing or

decrementing by amounts other than 1 (e.g., i += 2 adds 2 to i).

3. The for Statement

The for loop is often used for definite iteration, where you know
exactly how many times a loop should run. It combines three elements
in one line:

 Initializer: Runs once at the start (e.g., int i = 0).

 Condition: Checked before every iteration; if false, the loop ends.

 Update: Runs at the end of every iteration (e.g., i++).

 Scope: If a loop variable is declared in the initializer, it exists only
inside that loop.

4. Nested Loops

Loops can be placed inside one another, often to iterate over two
variables (like rows and columns in a multiplication table).

 Outer Loop: Controls the first dimension of iteration.

 Inner Loop: Completes its entire cycle for every single iteration of
the outer loop.

5. Working with Characters and Unicode

Strings are sequences of characters (char type).

 charAt(index): This method returns the character at a specific

position.

 Zero-based Indexing: String indexes start at 0 and end at length

- 1.

 Unicode: Java uses the Unicode standard to represent characters

numerically. You can use type casting to convert between integers
(code points) and their corresponding characters.

 Character Literals: Appear in single quotes (e.g., 'A'), whereas

string literals use double quotes (e.g., "A").

6. String Manipulation and Searching

 String Iteration: You can use a for loop to traverse every character
in a string using its .length() and .charAt() methods.

 Reversing a String: This is done by iterating through the original

string backwards and building a new string through concatenation.

 indexOf: This method searches for a character or substring within a

string. It returns the index of the first occurrence or -1 if not
found. It can also take a second argument to specify where to start
searching.

 Substrings: The substring(startIndex, endIndex) method returns a

copy of a portion of a string. The character at startIndex is
included, but the character at endIndex is not. If only one
argument is provided, it returns everything from that index to the
end.

7. String Comparison and Formatting

 Content vs. Reference: You must not use == or != to compare
the text inside strings; these operators check if two strings are the
exact same object in memory.

 .equals(): Use this method to check if two strings contain the same
characters.

 .compareTo(): Compares strings alphabetically (case-sensitive). A

negative result means the first string comes before the second.

 [Link]: Works like [Link] but returns a new

formatted string instead of displaying it on the screen.

8. Key Vocabulary Summary

 Loop Body: The statements inside a loop.

 Iteration: One complete execution of a loop sequence.

 Index: An integer value used to point to a specific character in a

string.

 Empty String: A string ("") with no characters and a length of zero.

 Overloaded: When multiple methods share the same name but

have different parameters (e.g., the different versions of substring).

1. Creating and Initializing Arrays

An array is a sequence of values called elements.

 Declaration: You declare an array variable by adding square

brackets [] to the type (e.g., int[] counts;).

 Allocation: Use the new operator to allocate memory for the array
(e.g., counts = new int;). This automatically initializes all elements
to zero.

 Direct Initialization: You can create and initialize an array in one

step using braces: int[] a = {1, 2, 3, 4};.

 Size: The size of an array must be a non-negative integer.

Attempting to create an array with a negative size results in a
NegativeArraySizeException.

2. Accessing Elements and References

 Indexing: Each element is identified by an index, starting from 0.

For an array of size $n$, the legal indexes are $0$ to $n-1$.

 The [] Operator: Used to select or update elements (e.g., counts =

7;).
 References: An array variable does not store the array itself but a
reference (or address) to it in memory. In a memory diagram, this
is shown as an arrow from the variable to the array.

 Bounds Checking: If you use an index that is negative or greater

than or equal to the array's length, Java throws an
ArrayIndexOutOfBoundsException.

3. Displaying and Copying Arrays

 Displaying: [Link](array); does not show the elements;

it prints a representation of the array's memory address. To see the
contents, use [Link](array) from the [Link] package.

 Aliasing: If you assign one array variable to another (b = a;), both

variables refer to the same array. Any change made through b will
be seen in a.

 True Copying: To create a separate copy, you must either loop

through the elements or use [Link](array, length).

4. Traversing Arrays

Performing an operation on every element in an array is called a

traversal.

 Length Property: All arrays have a built-in constant called length

that stores the number of elements (e.g., [Link]). Note: This does
not use parentheses like [Link]().

 Common Patterns:

o Search: Traversing to find a specific element and returning its

index.

o Reduce: Combining all elements into a single value (e.g.,

finding the sum).

o Accumulator: A variable used during a reduction to keep a

running total.

5. Enhanced for Loop

Java provides a compact syntax for traversing arrays when you don't
need the index:

for (int value : values) {

[Link](value);

}
 Syntax: Read as "for each value in values".

 Pros: It is more readable and less error-prone for simple traversals.

 Cons: It is not helpful if you need the index (e.g., for search
operations) or if you want to modify the array elements directly.

6. Advanced Concepts: Histograms and Logic

 Random Numbers: You can use [Link] to generate

pseudorandom numbers (sequences that appear random but are
deterministic) to fill arrays.

 Building a Histogram: A histogram is an array of counters that

track how many times specific values appear in a data set.

 Counting Characters: By performing arithmetic on char values

(e.g., letter - 'a'), you can map lowercase letters to array indexes
$0$ through $25$ to count their frequencies in a string.

Key Vocabulary Recap

 Allocate: Reserving memory for an object using new.

 Deterministic: A program that does the same thing every time it

runs with the same input.

 Nondeterministic: A program that may behave differently on

different runs (e.g., using random numbers).

1. Recursive Void Methods

A recursive method is one that calls itself, whereas an iterative

method uses loops like while or for to repeat actions.

 The countdown Example: A method that prints numbers from $n$

down to 1. If $n$ is 0, it prints "Blastoff!". Otherwise, it prints $n$
and then calls countdown(n - 1).

 Execution Flow: When a method calls itself, the current execution

is paused, a new instance of the method starts with a new
argument, and once that new instance finishes, the original
execution resumes.

2. Recursive Stack Diagrams and the Base Case

 Stack Frames: Every time a method is called, Java creates a new

frame in the stack containing that instance's parameters and local
variables.
 The Base Case: This is the condition that causes the recursion to
stop (e.g., if (n == 0) in countdown). Without a base case, a method
would call itself forever.

 StackOverflowError: In practice, the computer's memory is finite.

If a recursion goes on too long or lacks a base case, the stack grows
until it exceeds its limit, triggering a StackOverflowError.

3. Value-Returning Recursive Methods

Recursion is often the most natural way to express mathematical

functions.

 The factorial Example: The factorial of $n$ ($n!$) is defined as $n

\cdot (n-1)!$, with $0!$ defined as 1.

 Implementation: The Java method checks if n == 0 (base case)

and returns 1. Otherwise, it calculates the factorial of n - 1 and
multiplies it by n.

 Complex Recursion: Some functions, like the Fibonacci

sequence, use double recursion, where a method calls itself
twice in a single statement (e.g., fibonacci(n - 1) + fibonacci(n - 2)).

4. The "Leap of Faith"

When reading or writing recursive code, following the flow of execution

through every nested call can be overwhelming.

 The Strategy: Instead of tracing the execution, you assume that

the recursive call works correctly for the smaller sub-problem and
then check if the overall logic holds true. This is known as the leap
of faith.

5. Counting Up and Recursive Binary Conversion

 Order of Operations: In the countdown example, the print

statement happens before the recursive call, leading to a "count
down". If you move the print statement after the recursive call, the
program will print "Blastoff!" first and then count up as the stack
frames return.

 Binary Number System: Computers store data using binary

(base 2), which uses only 0s and 1s.

 Recursive Conversion: You can display a decimal number in

binary by repeatedly dividing by 2 and printing the remainder. A
recursive method (displayBinary) can do this by calling itself with
value / 2 before printing value % 2. This ensures the bits are printed
in the correct order (left to right).
6. Recursive Problem Solving: Strings and Arrays

Recursion is highly effective for processing data structures like strings

and arrays by looking at one element and then recursively handling the
rest.

 Strings (noX): To remove all 'x' characters from a string, the base
case is an empty string. For non-empty strings, you check the first
character; if it's 'x', you ignore it and return the result of the
recursive call on the rest of the string. Otherwise, you keep the first
character and attach it to the recursive result.

 Arrays (array11): To count how many times the number 11

appears, you pass the current index as an argument. The base case
occurs when the index reaches the end of the array.

Key Vocabulary Summary

 Recursive: A method that invokes itself.

 Iterative: A method that repeats steps using loops.

 Base Case: The condition that prevents further recursive calls.

 Factorial: The product of all integers from 1 up to $n$.

 Binary: A base-2 number system using only 0 and 1.

 Leap of Faith: Assuming a recursive call produces the correct

result without tracing the execution.

1. Object-Oriented Programming (OOP) Basics

Java is an object-oriented language, meaning it organizes programs

using objects to represent data and provide methods related to that
data.

 What is an Object? An object is a collection of related data and

methods. For example, Scanner is an object used for parsing input,
and [Link] is an object used for output.

2. Primitives vs. Objects (References)

A critical concept in Java is distinguishing how different data types are

stored in memory.

 Primitive Types: Types like int, double, char, and boolean store a
single value directly in the variable's memory location.

 Objects and Arrays: These are not stored directly in the variable.
Instead, the variable stores a reference, which is the memory
address where the actual data is located.
 Memory Diagrams: In visual representations, primitives are shown
as boxes containing values, while object variables are shown as
boxes with arrows pointing to the actual object.

3. The null Keyword

The keyword null is a special value that means "no object".

 Usage: You can initialize object or array variables to null if they

don't refer to anything yet.

 NullPointerException: If you attempt to invoke a method or

access an element on a variable that is null, Java throws this error,
causing the program to crash.

 Safe Checking: To avoid crashes, you should check if a variable is

null before using it. Using the logical OR (||) operator allows for
"short-circuiting," where the program checks for null first and only
continues if the variable is safe to use.

4. Strings Are Immutable

An immutable object is one that cannot be modified after it is created.

 Why Immutability? It simplifies passing data as parameters

because you don't have to worry about a method accidentally
corrupting the original data.

 Working with Strings: Methods like toUpperCase, toLowerCase,

and replace do not change the original string. Instead, they create
and return an entirely new string object.

 Common Mistake: Beginners often call a method like

[Link](); and expect name to change. To actually
update the variable, you must assign the return value back to it:
name = [Link]();.

5. Wrapper Classes

For every primitive type, there is a corresponding wrapper class in

the [Link] package (e.g., Integer for int, Character for char).

 Purpose: They allow primitives to be treated as objects, providing

useful methods and constants.

 Constants: Wrapper classes define MIN_VALUE and MAX_VALUE

constants, such as Integer.MIN_VALUE, which is -2147483648.

 Parsing: They provide methods to convert strings to numbers, such

as [Link] or [Link]. If a string cannot be
 converted (e.g., trying to parse "five"), Java throws a
NumberFormatException.

6. Command-Line Arguments

The args parameter in the main method is an array of strings used to

pass values into a program when it starts from a command-line
interface.

 Parsing args: Since all command-line arguments are strings, you

must use wrapper class methods like [Link] to convert
them if you need to perform math.

 Validation: Good programs check the length of args to ensure the

user provided the necessary input before trying to access the array.

7. BigInteger Arithmetic

Standard integers (int and long) have maximum limits. For calculations
involving extremely large numbers, Java provides the BigInteger
class.

 Arbitrary Precision: There is no upper limit to a BigInteger except

for the computer's memory.

 Immutable Math: Like strings, BigInteger objects are immutable.

You cannot use standard symbols like + or *; you must use methods
like .add() or .multiply(), which return a new BigInteger.

8. Incremental Design Process

The sources describe a design process to help manage complex

programming tasks.

1. Encapsulation: "Wrapping" a few lines of working code inside a

new method.

2. Generalization: Replacing specific literal values (like the number

6) with variables or parameters (like int rows) to make the method
more versatile and reusable.

Key Vocabulary Summary

 Empty Array: An array with no elements and a length of zero.

 Parse: To read a string and translate or interpret its meaning (e.g.,

turning "123" into an integer).

 Design Process: The method for determining which classes or

methods a program should have.

1. Point and Rectangle Objects

The sources use two classes from the [Link] package to illustrate
mutability: Point and Rectangle.

 Point Objects: Represent a 2D location with coordinates x and y.

 Rectangle Objects: Represent a rectangular area with four

attributes: x, y, width, and height.

 Attributes (Fields): These are variables that belong to an object.

 Dot Notation: The syntax used to access an object's attributes or

methods (e.g., blank.x accesses the x-coordinate of the Point object
blank).

2. Objects as Parameters and Return Values

 Passing Objects: You can pass objects to methods just like

primitive types. This makes code more readable and less error-prone
by bundling related values together (e.g., passing one Point
instead of two separate double coordinates).

 Returning Objects: Methods can create and return new objects.

For example, a findCenter method might take a Rectangle as an
argument and return a new Point representing its center.

 toString Method: Standard objects like Point and Rectangle

provide a toString method that Java automatically calls when you
print the object, displaying its type and attribute values.

3. Mutability and Aliasing

An object is mutable if you can change its state by modifying its

attributes.

 Modification: You can change an object's attributes directly via

assignment (e.g., box.x = 50;) or by invoking methods designed to
modify the object, such as translate (moves a rectangle) or grow
(resizes it).

 Aliasing: This occurs when multiple variables refer to the same

object.

o If you assign box2 = box1;, both variables point to the same

memory location.

o Any change made to the object through box1 will also be

reflected when accessing it through box2. This can make
debugging difficult because it isn't always obvious which
method call modified an object.

4. UML and Class Diagrams

Unified Modeling Language (UML) provides a standardized
graphical way to represent the structure of a program.

 Class Diagrams: These diagrams visualize the source code at

compile-time. They typically show a box for each class containing:

o The Class Name.

o A list of Attributes (e.g., +x: int).

o A list of Methods (e.g., +toString(): String).

 Access Modifiers: In UML, a plus sign (+) indicates a public

attribute or method, while a minus sign (-) indicates private.

5. Scope and Memory Management

Understanding how variables and objects exist in memory is vital for

managing resources.

 Variable Scope:

o Parameters and Local Variables: Created when a method

is invoked and disappear when it returns.

o Attributes: Created when an object is created and exist as

long as the object exists.

 Garbage Collection: When there are no more references to an

object (e.g., a variable is set to null), the object is "stranded". Java’s
garbage collector automatically finds these objects and deletes
them to reuse the memory space.

6. Mutable vs. Immutable: StringBuilder

While immutable objects (like String) are safer and can improve
performance by sharing memory, mutable objects are often more
efficient for operations involving frequent changes.

 The String Concatenation Problem: Using the + operator to join

many strings in a loop is inefficient because it creates a new String
object at every step, creating a lot of "garbage" for the system to
collect.

 StringBuilder: This is a mutable class in the [Link] package

designed for efficient string manipulation.

o It uses an append method to add text to the existing object

without creating new ones.
 o It is much faster than standard String concatenation for large
amounts of text.

Key Vocabulary Summary

 Attribute: A named data item that makes up an object.

 Reference: A value that indicates where an object is stored in

memory.

 Null: A special value indicating that a variable refers to nothing.

 Identity vs. Equality: Two variables are identical if they refer to

the same object (aliasing); they are equivalent if they refer to
different objects that happen to have the same attribute values.