After reading through this lesson, you will be able to confidently do the following 3 things.

• ▸✅ Explain the difference between the 4 primitives used in real projects (int/double/boolean/char) out of the 8 primitive types
• ▸✅ Know when to use for-each, for, while, and switch
• ▸✅ Explain the integer division pitfall + type casting and the truncate behavior of (int) double

Treat the learning goals as a checklist — close this lesson only when you can answer all of them.

Java Has 2 Categories

• ▸Primitive types — types that hold the actual value. 8 kinds.
• ▸Reference types — types that hold the address of an object. String, arrays, classes, etc.

Just memorize 4 primitives: int, double, boolean, char.

The 8 Primitives — One Table

Conclusion: At first, you only need to know int, double, boolean, and char.

Declaration and Assignment

int age = 30;
double height = 175.5;
boolean isStudent = true;
char grade = 'A';
String name = "Lim Dong-geun";   // String is a reference type, but frequently used

= means "assign", not "equal" — it places the right-hand value into the left-hand variable.

Output — println vs printf

System.out.println("Name: " + name);          // Includes newline

System.out.print("On one line "); // No newline

System.out.printf("Age: %d years old, Height: %.1fcm%n", age, height); // C-style formatting

``

%d = integer, %f = decimal, %s = string, %n = newline. The option %.1f` means 1 decimal place.

Implicit Conversion (Automatic)

Small type → large type is converted automatically.

int a = 10;
double b = a;    // 10 → 10.0 automatically converted
System.out.println(b);  // 10.0

Explicit Conversion (Manual)

Large type → small type requires explicit casting. This is intentional — it signals potential data loss.

double pi = 3.14;
int x = (int) pi;     // 3 — decimal truncated (not rounded)
System.out.println(x);

Specify the target type in parentheses. It truncates, not rounds — 3.99 becomes 3.

Common Pitfall — Integer Division

int a = 5, b = 2;
System.out.println(a / b);          // 2  (integer division results in integer)
System.out.println((double) a / b); // 2.5 (if one side is double, result is double)

The most common bug. Dividing two integers drops the decimal portion.

if / else

int score = 85;
if (score >= 90) {
    System.out.println("A");
} else if (score >= 80) {
    System.out.println("B");   // Printed
} else {
    System.out.println("C");
}

The condition must be a boolean. You cannot use 0/1 like in C (e.g., if (x) is not valid).

switch — When Comparing Many Values

Java 14+ introduced arrow syntax, which is much cleaner.

String day = "MON";
String korDay = switch (day) {
    case "MON", "TUE", "WED" -> "Weekday";
    case "SAT", "SUN"        -> "Weekend";
    default                  -> "Unknown";
};

The old syntax (Java 13 and below) had a pitfall: forgetting break causes fall-through to the next case — use arrow syntax in new code.

for — When the Number of Iterations is Known

for (int i = 0; i < 5; i++) {
    System.out.println(i);    // 0, 1, 2, 3, 4
}

The order is init → condition check → body → increment → condition check .... This is called the lifecycle.

while / do-while — When You Only Have a Condition

int n = 0;
while (n < 3) {       // Check condition first
    System.out.println(n++);
}

do {                   // Execute once, then check condition
    System.out.println("Execute at least once");
} while (false);

do-while always executes once before checking the condition. Rarely used in practice.

Example — Sum of 1 to 100

int sum = 0;
for (int i = 1; i <= 100; i++) {
    sum += i;
}
System.out.println(sum);   // 5050

Array Declaration and Initialization

int[] arr = new int[5];          // Length 5, all initialized to 0
int[] nums = {10, 20, 30, 40};   // Declared with values
String[] names = {"Kim", "Lee", "Park"};

int[] is the "int array" type. The C-style int arr[] also works but is not recommended.

Access — Indexes Start at 0

int[] nums = {10, 20, 30};
System.out.println(nums[0]);    // 10
System.out.println(nums[2]);    // 30
nums[1] = 999;                  // Modify
System.out.println(nums[1]);    // 999

Accessing out-of-bounds throws ArrayIndexOutOfBoundsException — the most common runtime error.

Length — .length

int[] nums = {10, 20, 30};
for (int i = 0; i < nums.length; i++) {
    System.out.println(nums[i]);
}

.length is a field (no parentheses) — it is not length(). Do not confuse it with String's length().

for-each — More Concise Iteration

int[] nums = {10, 20, 30};
for (int n : nums) {
    System.out.println(n);
}

When you don't need the index, this is far more readable. However, since the index is unavailable, use a regular for loop when you need to modify elements.

2D Arrays

int[][] grid = {
    {1, 2, 3},
    {4, 5, 6}
};
System.out.println(grid[1][2]);   // 6 — row 1, column 2

Commonly used for game boards and matrices. In production code ArrayList is used most of the time, but arrays are faster for algorithm problems.

What's Next

Variables, control flow, arrays — this is the fundamental building material of all Java code. In the next chapter on OOP, you will explore "why we need to group things into classes."

Once you know the concepts in this lesson, you can give the AI specific instructions. Instead of vague requests like "fix this," you can make vocabulary-driven requests — that is where token savings begin.

• ▸"Correct the use of int vs. long and float vs. double in this Java code where appropriate."
• ▸"Convert this for loop into an enhanced for-each loop."
• ▸"Refactor this if-else chain into a switch expression (Java 14+)."

Why This Saves Tokens

Without the concepts, you have to ask "what does that mean?" after every AI response. Those follow-up questions burn tokens. Learn the concepts once and the conversation ends in one round.