Forem: Hanna

📝 07-1. Java Practice: Nested If-Statements & Data Conversion (Login Logic!)

Hanna — Wed, 18 Mar 2026 04:10:33 +0000

● Study period: 260313
● Study scope: Honja 3-01,02 part operator part

Today, I worked through some practice exercises. It was a bit overwhelming at first, but seeing the code come together so cleanly was super satisfying! Here are the key takeaways from my session.

1. Direct Data Conversion in One Line

Instead of creating a separate String variable to store and then convert input, I learned that you can pass the input directly into the conversion method!

double num1 = Double.parseDouble(scanner.nextLine());

Why it's cool: It immediately feeds the scanner.nextLine() output into Double.parseDouble(). This makes the code much more concise and efficient.

2. Handling 0.0 and Infinity (Division Safety)

I learned that 0 and 0.0 are essentially treated as the same value in this context. It's crucial to use an if statement to prevent dividing by zero, which is a big "no-no" in programming.

if(num2 != 0.0) {
    System.out.println("Result: " + (num1/num2));
} else {
    System.out.print("Result: Infinity");
}

By checking if num2 is not 0.0, we can safely perform the division. If it is 0.0, it simply prints "Infinity." Using if for exception handling is so useful! (Though nested if statements still give me a headache... lol)

3. Combining Strings to Create Numeric Values

I found this specific piece of logic really clever:

double var4 = var1 * var2 * Double.parseDouble(var2 + "." + var3);

It combines var2, a dot ., and var3 to create a string like "3.14", then converts that entire string into a double for the calculation. I wasn't sure if you could mix strings into a numeric calculation like that, but this conversion makes it possible!

4. Creating Login Logic with Nested If-Statements

This exercise required both the ID and Password to be correct to "log in." Seeing the solution finally made it click for me.

if(name.equals("java")) { // Step 1: Check ID
    if(password == 12345) { // Step 2: Check Password
        System.out.println("Login Successful");
    } else {
        System.out.println("Login Failed: Wrong Password");
    }
} else {
    System.out.println("Login Failed: ID does not exist");
}

Lessons Learned: * Always use .equals() instead of == when comparing strings!
- I struggled at first because I tried to use = inside the if parentheses, but I realized the structure itself handles the logic without extra assignment symbols.
- Nested structures (an if inside an if) are still a bit dizzying, but I'm getting used to the flow.

🏁 Final Thoughts

Through these exercises, I realized there's a huge difference between understanding the concept and actually writing the code. Making mistakes now is the best way to ensure I don't make them later in the field! Another productive day in the books.

📝 07. Java Operators: More Than Just Math (and Why Java Feels "Human")

Hanna — Wed, 18 Mar 2026 04:03:06 +0000

● Study period: 260313
● Study scope: Honja 3-01,02 part operator part

Today, I dived into Java operators. I encountered some unfamiliar types and learned about their real-world applications. Here’s a summary of what I covered!

1. Essential Operators You Need to Know

% (Remainder Operator): It gives you the "leftover" value after division.
- I used to think this was useless, but it’s actually super handy for distinguishing between even/odd numbers or checking for multiples in practice.
Logical Operators (&&, ||, ^, !)
- &&, & (AND): Returns true only if both conditions are met.
- ||, | (OR): Returns true if at least one condition is met.
- ^ (XOR): Returns true only if the two values are different.
- !, != (NOT): Reverses the result (Negation).
- The "!" (Exclamation Mark) is crucial: It's used constantly—for example, "If NOT logged in (!isLoggedIn), block the page." It's a bit of a brain teaser, but I need to master this now so I don't get confused later in the field!

2. Increment & Decrement Operators (++, --)

These are tricky because their value changes depending on whether you put them before or after the variable.

++x (Prefix): The value is incremented first, then used in the expression.
x++ (Postfix): The current value is used first, then incremented later.

💡 Real-world Example:
I understood this better when I thought about an AI picking up game items and filling slots sequentially, or managing queue numbers. While x++; and ++x; act the same when used alone, they behave completely differently when used with an assignment operator, like z = x++;.

3. The Betrayal of Floating Points: Why `0.1 == 0.1f` is False

This was the most surprising part of today's study.

Computers speak Binary: Decimal numbers that don't terminate in binary are inherently imprecise.
double vs float: A double has more precision than a float. Therefore, a 0.1 stored as a double is slightly different from a 0.1 stored as a float. Even if you move a float value into a double "container," the precision doesn't magically increase!

🤖 Computers Are Kind of Human?

Interestingly, computers love floating-point numbers that terminate perfectly in binary.

Examples: 1.0, 0.5, 0.25, 0.125 (powers of 2).
These have zero error, so comparing an int to a double for these values returns true. It reminded me of my part-time job at the convenience store—I love it when customers give me the exact change so I don't have to deal with coins. Computers are the same! lol.

4. Review Points (My "Oops" Note)

❌ char Operation Errors

char c3 = (char)c2 + 1; -> Error!
- Why? Even if you cast c2 to a char, adding the int 1 turns the whole result back into an int.
char c3 = (char)(c2 + 1); -> Correct!
- You have to wrap the whole expression in parentheses to cast the final result back to a char.

❌ The float Division Surprise

float var2 = var1 / 100; (where var1 is a float)
- I thought this might cause an error since Java’s default for decimals is double. However, since float / int results in a float, it fits perfectly into the float variable var2. Good to know!

❌ Other Weak Spots

I keep making mistakes with the ! (NOT) operator—need more practice.
Nested if statements with multiple parentheses still make my head spin.
I need to review Double.parseDouble() for converting strings to data.

🏁 Wrapping Up

The problems are getting spicier as I move through the operators. My head hurts a bit. 😭 Can I really finish this whole book on time? Can I even make it through the first read-through? Let's stay focused. Fighting! 🔥

📝 06. Java Self-Study: Variables & System I/O

Hanna — Wed, 18 Mar 2026 04:01:13 +0000

Date: 2026-03-12
Topic: Chapter02_sec04 (Variables and System I/O)

1. System I/O (System.in / System.out)

I finally understand the meaning behind System.out.println(), which I had been using without much thought.

System.out (Standard Output): Monitor
System.in (Standard Input): Keyboard

2. Output Methods: print, println, and printf

There are more ways to output data than just println.

print(): Outputs content without a newline.
println(): Outputs content and moves to the next line.
printf(): Outputs formatted content. This is essential for controlling decimal places or aligning data in professional projects.

💡 Understanding the Format Specifier: `%-10.2f`

It looked complicated at first, but it's actually quite logical:

%: Start of the format specifier.
-: Left-aligned (remaining space on the right is filled with blanks).
10: Total width (occupies 10 spaces, including the decimal point).
.2: Limits the output to 2 decimal places.
f: Formats the value as a floating-point number.

Note: You can specify the order using %1$d, %2$s, but Java is smart enough to match them in order automatically. Manual ordering is only necessary when reusing the same variable or changing the sequence.

3. Keyboards and KeyCodes

Computers process numbers faster than characters, so every key on a keyboard is assigned a unique number called a KeyCode.

System.in.read(): Reads a single KeyCode.
Important: When using this, you must include throws Exception. It’s like a safety valve where Java "passes the buck" if something goes wrong with the input.
Pro Tip: Experienced developers often use try-catch blocks instead of throws to handle errors gracefully and provide helpful feedback to the user.

4. Scanner: A Smarter Way to Handle Input

Since KeyCodes only read one byte at a time, they struggle with multi-byte characters like Korean. That's where the Scanner class comes in.

Setup: import java.util.Scanner; (Like taking a tool out of the Java storage room).
Shortcut: In Eclipse, pressing Ctrl + Shift + O automatically manages your imports.

🏗️ Reference Types and the `new` Operator

Unlike basic types like int, Scanner is a Reference Type (Class).

Class: A "blueprint" for creating an object.
new: A command to actually build the object in memory based on that blueprint.
Scanner(System.in): "Build a scanner that is connected to the keyboard."

Breaking down the code: Scanner scanner = new Scanner(System.in);
-> "Create a physical scanner object that reads from the keyboard and store it in the box named 'scanner'!"

scanner.nextLine(): Very convenient because it reads an entire line until you hit Enter.

🏁 Wrapping Up

Learning how data is formatted and how keyboard input is stored in variables was fascinating. It feels like I'm finally learning features that are used in the real world. That's the end of Section 2 (Variables)! Starting Section 3 (Operators) tomorrow. 🔥

🧐 05. Surprised by Java’s Precision: Type Conversion and Calculation Traps

Hanna — Wed, 18 Mar 2026 03:28:03 +0000

● The study period: 3/6 to 3/12
● Research Range: Chapter02_sec03

After mastering primitive types, I moved on to "Type Conversion." It sounded complex at first, but the principle is surprisingly intuitive: It’s all about the size of the "containers."

1. "A Large Container Holds a Small One" (Promotion)

Automatic Type Conversion (Promotion) occurs when a smaller data type is stored in a larger one. Java handles this seamlessly.

Size Order: byte < short < int < long < float < double

For example, if you put the integer 2 into a double variable, Java automatically saves it as 2.0.
The Catch: byte or short cannot be automatically converted to char. Since char is an "unsigned" (positive-only) type, Java—the strict perfectionist—refuses to allow it unless it’s 100% certain.

2. "Force It to Fit" (Casting)

Sometimes we need to squeeze data from a large container into a smaller one. This is Explicit Conversion (Casting). It’s like telling Java, "I'll take responsibility, so trim this down and fit it in!"

int intValue = 65;
char charValue = (char) intValue; // Explicit Casting
System.out.println(charValue);    // Output: A

Even though I started with a number, looking through the char "glasses" revealed the character 'A'. One thing to remember: when converting a decimal to an integer, everything below the decimal point is chopped off (truncated).

3. Why Java Turns 0.5 into 0.0

This was the most "shocking" part of today’s study.

int x = 1;
int y = 2;
double result = x / y;
System.out.println(result); // Result: 0.0 (Not 0.5!)

I expected 0.5, but got 0.0. Why? Because of Integer Division.
Since both x and y are int, Java performs the calculation first, discards the remainder, and keeps only the integer 0. Only after that is the result stored in the double container, turning it into 0.0.
Solution: To get 0.5, at least one operand must be cast to (double) before the calculation. Java decides the result's type before it even finishes the math.

4. The `byte` Puzzle: `10 + 20` vs. `x + y`

I noticed another quirk in Java’s strictness:

byte result = 10 + 20; (Success: The values are fixed constants!)
byte x = 10; byte y = 20; byte result = x + y; (Error!)

Why? Because x and y are variables. Java thinks, "Since these values could change anytime, I’ll safely process their sum as an int." Trying to shove that int result back into a tiny byte causes a conflict.

5. Takeaway: Developers Must Foresee the Result

Learning type conversion taught me that a developer must anticipate the resulting type of every expression before writing the code.

Simply assuming "it'll work out" can lead to data errors or precision loss. Java’s logic is incredibly tight, and while it requires meticulous attention, I'm finding myself more and more drawn to its consistent and predictable nature.

🧐 04. Surprised by Java’s Honesty: Primitive Types and Memory Logic

Hanna — Wed, 18 Mar 2026 03:26:05 +0000

● Study period: 3/6 to 3/12
● Study scope: Chapter02_sec02

While starting my Java journey, the first thing I noticed was the absolute "Honesty" of the computer. Unlike human conversation, where context and nuance fill the gaps, a computer refuses to work (throws an error) if even the smallest rule is broken.

Understanding "Types" is the key to giving this honest machine clear instructions. Here’s what I’ve learned about how Java handles data.

1. Why is English the Language of IT? (ASCII & Unicode)

I grew curious: "Why are most programming languages based on English?"
Beyond historical reasons, I found the 'Economic Efficiency of the Alphabet' fascinating. Unlike complex characters in Korean or Chinese, the English alphabet fits perfectly within 128 characters (ASCII), making it optimal for early computing environments with limited memory.

This curiosity motivated me to understand Java’s char type (2 bytes, Unicode), which was designed to bridge that gap and embrace global languages.

2. [Key Point] Types are "Glasses" for Data

The most interesting part was the relationship between char and int.

char var1 = 'A'; // Stores Unicode 65
int var2 = 'A';  // Stores Unicode 65

System.out.println(var1); // Output: A
System.out.println(var2); // Output: 65

Internally, both variables store the number 65. However, Java interprets this data through the "glasses" of its Type:

char glasses: "Find Unicode 65 and show me the character shape 'A'!"
int glasses: "This is an integer, so just show me the number 65."

I realized that single quotes (' ') act as a Translation Switch, telling Java to handle the character mapping for us so we don't have to memorize every Unicode number.

3. Why `double` is the Default for Decimals: Reliability > Efficiency

While int (4 bytes) is the default for integers, why is the 8-byte double the default for decimals instead of the 4-byte float?

The answer is Precision. In decimal calculations, accuracy is everything. Java chooses data reliability over saving a few bytes of memory. Using suffixes like L or f is a way of giving Java explicit guidance—a habit I’m building to write clearer code for my future teammates.

4. `char` vs. `String`: Fundamentally Different

I learned that handling a single character (char) and a string of text (String) are entirely different concepts in Java:

char: A Primitive Type. Stored as a Unicode number, allowing for calculations. Uses ' '.
String: A Reference Type. Treated as an Object and fundamentally different from numbers. Uses " ".

Understanding that comparing their "size" (e.g., char < String) is logically impossible was a crucial takeaway.

Final Thoughts

Computers are honest and literal. By mastering data types, I’m learning how to communicate with them without any "lost in translation" moments. My goal is to move beyond just writing code that works, toward writing code that is explicit and reliable.

📦 03. Variables in Java: It's Not Just Math, It's About Storage and Decision Making

Hanna — Wed, 18 Mar 2026 03:09:05 +0000

● Study period: 3/6 to 3/12
● Study scope: Part part of Chapter02_sec01 of the book 'Java to Study Alone'

As a beginner transitioning from a non-CS background, the word "Variable" initially reminded me of $x$ and $y$ from math class. But in programming, I realized that while variables can change, their true essence lies in being a "Labeled Container."

1. Don't Get Tricked by the Name

A variable is like a box or a bowl where you store a piece of data and put a name tag on it. It doesn't have its own complex functions; its sole purpose is to hold a single value for later use.

The Name Tag (Variable Name): e.g., userAge, userName
The Content (Value): e.g., 25, Hanna

Think of it like moving to a new house. You pack items into boxes and write what’s inside with a marker. In programming, we do this so we can "unpacks" and use those values whenever the program needs them.

2. Math vs. Programming: Finding $x$ vs. Storing $x$

The mindset shift is key:

In Math: We ask, "What is the value of $x$?" (Finding the answer).
In Programming: We say, "I'm going to save this value as $x$ so I can pull it out and use it later!"

Unlike a fixed math equation, the contents of our "programming box" can be swapped out while the program is running. It's a dynamic storage space in the computer's memory.

3. Why Do We Need Different Types of Boxes?

Java uses different boxes for numbers, strings, and true/false (booleans). I wondered why we bother categorizing them, and I found the answer: Decision Making.

Variables are the foundation that allows a program to make choices. The program "opens the box" to see what's inside and decides what to do next.

Example in Game Design:
"Open the is_alive box. If it contains False, then trigger the 'Game Over' screen!"

4. Final Thoughts: The Flexible Foundation

Variables can hold numbers, text, or logical states. They are the flexible building blocks that turn a static script into an interactive program. Understanding that a variable is a functional space in memory rather than just a mathematical unknown has been a huge "aha!" moment for me.

☕ 02. "Hello, Java": Understanding the Magic Behind the Compilation

Hanna — Wed, 11 Mar 2026 09:21:20 +0000

● Study period: 3/3 to 3/5
● Study scope: Part 01-3 part (23p-44) of the book 'Java to Study Alone'

Today, I finally printed my first "Hello, Java!" and dove deep into how this language actually works. As a non-major, I had a fundamental question: "Why do we need a middleman (Bytecode) instead of just running the code directly?"

1. The "Meal Kit" Analogy: Java’s Portability

I learned that Java follows a specific process:

Source Code (Raw Ingredients) → javac (The Prep Chef) → Bytecode (The Meal Kit) → java Command (The World-Class Chef/JVM).

At first, I wondered if creating a bytecode file was just an extra, time-consuming step. But I realized this is Java's greatest strength: "Write Once, Run Anywhere." Since the bytecode acts like a pre-prepped meal kit, each Operating System (Windows, macOS, Linux) just needs its own "chef" (JVM) to finish the cooking. This versatility is why Java remains a global standard.

2. Java vs. C: Drivers and Engineers

I also looked into C, the "Latin of programming." While C-language masters are like F1 Engineers who understand every piston movement in the engine, Java developers are more like Skilled Drivers. Java takes the best parts of C but makes it more accessible and safer for the developer.

One day, I hope to add a "spoonful of C" to my knowledge to understand exactly how computers store data at a hardware level. A developer who understands both the high-level logic (Java) and low-level efficiency (C) is truly formidable.

3. Safety First: Modules and Syntax

Java is strict. A single case-sensitivity error (like hello vs Hello) can break the project. I actually struggled with a filename mismatch today and had to manually refactor it.
I also explored Modules—think of them as security guards or passkeys for your code packages. This rigid structure is exactly why Java is trusted by large enterprises worldwide for its high security and stability.

4. Thinking in Code: The `=` Sign

The most interesting "aha!" moment was the assignment operator =.
In math, x = x + 1 is impossible. In Java, it's a standard command: "Calculate the right side first, then store it in the left container." Shifting my brain from "Result" to "Storage" was a small but vital step in thinking like a programmer.

5. My Roadmap to Becoming a "Commander" of AI

As AI evolves, I believe the role of a developer is shifting toward being a Commander. To lead AI effectively, I need to understand the "First Principles." Even if I don't memorize every syntax, I must master the core pillars:

Variables & Data Types (Choosing the right containers)
Object-Oriented Programming (The heart of Java: Inheritance, Polymorphism, Encapsulation)
Exception Handling (Defensive driving for code)
Clean Code (Sustainability and Maintenance)

My goal is to understand the "Big Picture" so I can direct AI to optimize code effectively. I’m focusing on Java, Spring Boot, and JPA as my core stack, keeping an eye on global enterprise standards.

🚀 01. My First Step into Java: Setting Up the Environment

Hanna — Wed, 11 Mar 2026 07:21:46 +0000

● Study period: 3/3 to 3/5
● Study scope: Part part of Chapter01_sec01 of the book 'Java to Study Alone'

Starting something new is always a mix of excitement and "Expected Unexpected" challenges. As I prepare for an intensive 6-month Java & Spring boot camp starting this May, I’ve decided to self-study the fundamentals beforehand. My goal is to complete at least 2 or 3 rounds of the textbook to ensure I hit the ground running.

Today’s mission: Setting up the Java Development Kit (JDK) and Eclipse IDE.

Coming from a non-technical background, I realized today that I didn't even know where the backslash (\) key was! (For those wondering, it’s usually right above the Enter key). It made me pause for a second—"Can I really become a developer if I don't even know the keyboard layout?" But I shook it off. Everyone starts at zero, and today was my Day Zero.

2. The Battle with Environment Variables

I followed the instructions to set up the environment variables, but when I ran javac -version in the terminal, it kept returning an error. I restarted my PC, double-checked the paths, embed and scratched my head for a while.

I was typing javac-version (no space) or javac - version (extra space). The correct command is:
javac -version

It felt a bit frustrating that a single space could break everything. However, this was a great lesson: Computers are honest and literal. They don't infer context like humans do. Precision isn't just a preference in coding; it’s a requirement.

3. Overcoming IDE Installation Hurdles

I also ran into an issue while installing Eclipse. The initial installer wouldn't execute properly. After some troubleshooting and consulting with AI, I opted for the "Full Zip" version instead of the standard installer. Problem solved! Since my textbook was written for an older version of Java, navigating the latest updates required some extra research, but I successfully configured the latest environment.

4. Key Takeaways: Thinking like a Developer

Through this setup process, I realized that a developer is essentially a translator between human logic and machine execution. This is why "Computational Thinking" and "Algorithms" are so vital.

I’ve learned that to succeed in this field, I need to:

Ask "Why?": Don't just follow steps; understand the underlying mechanism.
Deconstruct Problems: Break down big errors into smaller, manageable pieces.
Be Patient: Accuracy over speed.

It’s a bit overwhelming to learn all this new terminology, but knowing that every senior developer once struggled with a space or a backslash gives me comfort. I’m moving forward slowly but surely!

Forem: Hanna

📝 07-1. Java Practice: Nested If-Statements & Data Conversion (Login Logic!)

1. Direct Data Conversion in One Line

2. Handling 0.0 and Infinity (Division Safety)

3. Combining Strings to Create Numeric Values

4. Creating Login Logic with Nested If-Statements

🏁 Final Thoughts

📝 07. Java Operators: More Than Just Math (and Why Java Feels "Human")

1. Essential Operators You Need to Know

2. Increment & Decrement Operators (++, --)

3. The Betrayal of Floating Points: Why 0.1 == 0.1f is False

🤖 Computers Are Kind of Human?

4. Review Points (My "Oops" Note)

❌ char Operation Errors

❌ The float Division Surprise

❌ Other Weak Spots

🏁 Wrapping Up

📝 06. Java Self-Study: Variables & System I/O

1. System I/O (System.in / System.out)

2. Output Methods: print, println, and printf

💡 Understanding the Format Specifier: %-10.2f

3. Keyboards and KeyCodes

4. Scanner: A Smarter Way to Handle Input

🏗️ Reference Types and the new Operator

🏁 Wrapping Up

🧐 05. Surprised by Java’s Precision: Type Conversion and Calculation Traps

1. "A Large Container Holds a Small One" (Promotion)

2. "Force It to Fit" (Casting)

3. Why Java Turns 0.5 into 0.0

4. The byte Puzzle: 10 + 20 vs. x + y

5. Takeaway: Developers Must Foresee the Result

🧐 04. Surprised by Java’s Honesty: Primitive Types and Memory Logic

1. Why is English the Language of IT? (ASCII & Unicode)

2. [Key Point] Types are "Glasses" for Data

3. Why double is the Default for Decimals: Reliability > Efficiency

4. char vs. String: Fundamentally Different

Final Thoughts

📦 03. Variables in Java: It's Not Just Math, It's About Storage and Decision Making

1. Don't Get Tricked by the Name

2. Math vs. Programming: Finding $x$ vs. Storing $x$

3. Why Do We Need Different Types of Boxes?

4. Final Thoughts: The Flexible Foundation

☕ 02. "Hello, Java": Understanding the Magic Behind the Compilation

​1. The "Meal Kit" Analogy: Java’s Portability

​2. Java vs. **C: Drivers and Engineers**

​3. Safety First: Modules and Syntax

​4. Thinking in Code: The = Sign

​5. My Roadmap to Becoming a "Commander" of AI

🚀 01. My First Step into Java: Setting Up the Environment

2. The Battle with Environment Variables

3. Overcoming IDE Installation Hurdles

4. Key Takeaways: Thinking like a Developer

3. The Betrayal of Floating Points: Why `0.1 == 0.1f` is False

💡 Understanding the Format Specifier: `%-10.2f`

🏗️ Reference Types and the `new` Operator

4. The `byte` Puzzle: `10 + 20` vs. `x + y`

3. Why `double` is the Default for Decimals: Reliability > Efficiency

4. `char` vs. `String`: Fundamentally Different

1. The "Meal Kit" Analogy: Java’s Portability

2. Java vs. C: Drivers and Engineers

3. Safety First: Modules and Syntax

4. Thinking in Code: The `=` Sign

5. My Roadmap to Becoming a "Commander" of AI