D2: Arithmetic Operators, Precedence, and Escape Sequences

An arithmetic expression is defined as a combination of numbers, variables, and operators that instructs the computer to perform a mathematical calculation.
The primary arithmetic operators in Java include:
- + : Addition
- - : Subtraction
- * : Multiplication
- / : Division
- % : Modulus (Modulo)

Integer (int) Data Type:
- Represents whole numbers without fractional components.
- When performing integer division using int values, Java truncates or chops off the decimal portion completely.
- Arithmetic operations involving exclusively int values produce an int result:
- $4 \times 2 = 8$
- $-2 + 11 = 9$
- $23 \% 2 = 1$
- $10 / 3 = 3$ (The exact quotient is $3.33\dots$ , but Java truncates the decimal portion to return $3$ ).
Double (double) Data Type:
- Represents floating-point numbers and is always stored with at least one decimal place.
- Internal Promotion: Assigning an integer value to a double variable causes Java to store it with a decimal (e.g., double num = 5; is stored internally as double num = 5.0;).
- Data Type Compatibility & Storage Restrictions:
- int values can be directly stored in double variables.
- double values cannot be stored in int variables without explicit type casting.
- Expressions such as int x = 2.0 / 3; or int x = 4 / 5 * 3.0; produce compilation errors because a double result cannot be assigned to an int variable type.
Mixed-Type Arithmetic Operations:
- Any arithmetic operation involving at least one double value will automatically evaluate to a double result.
- Examples:
- $32.2 - 3 = 29.2$
- $4.0 \times 2 = 8.0$

The modulo operator (%) computes and returns the remainder of integer division performed between two numbers.
Examples and Evaluation:
- int x = 8 % 3; evaluates to $2$ , because $8 / 3 = 2$ with a remainder of $2$
- $17 \% 5 = 2$ , derived from $17 / 5 = 3$ with a remainder of $2$

Compound Expressions: Expressions that combine multiple numbers, variables, and operators into a single calculation.
Hierarchy of Precedence (Order of Operations for Computers):
1. Parentheses () and Type Casting (Highest Precedence)
2. Multiplication *, Division /, and Modulo % (Middle Precedence)
3. Addition + and Subtraction - (Lowest Precedence)
Step-by-Step Compound Expression Evaluation:
- Expression: $4 + 15 \% (2 \times 3) - 2$
- Step 1 (Parentheses): Evaluate $(2 \times 3) = 6$ , updating the expression to $4 + 15 \% 6 - 2$
- Step 2 (Modulo): Evaluate $15 \% 6 = 3$ (since $15 / 6 = 2$ remainder $3$ ), updating the expression to $4 + 3 - 2$
- Step 3 (Addition & Subtraction left to right): Evaluate $4 + 3 = 7$ , then $7 - 2 = 5$ . The final evaluation result is $5$

Type Casting:
- Used to convert a value explicitly from one data type to another.
- Syntax example: (int) 4.7 truncates the decimal portion and evaluates to integer 4.
- Casting operations share the highest precedence level along with parentheses.
Shortcut Operators:
- x++; : Increment operator; increments x by $1$
- x--; : Decrement operator; decrements x by $1$
- x += 3; : Addition assignment operator; adds $3$ to x
- x -= 1; : Subtraction assignment operator; subtracts $1$ from x

Dividing an int by 0:
- Java stores the evaluation as undefined (throwing an arithmetic runtime error).
- An undefined result cannot be used in subsequent arithmetic operations.
Dividing a double by 0:
- Java stores the evaluation as infinity.

Literals:
- Fixed values written directly into source code that remain constant throughout execution.
- Figurative usage employs comparisons to establish meaning.
- Numerical literal example: 10
- String literal example: “I am a string”
Escape Sequences:
- Allow you to include special characters in string
- \n (line break in middle of string)
- \t (tab space)
- \\ (one backslash)
- \” (for literal qoute)