3.1 조건 분기문 완전 정복 💡 – if문, else문, switch문까지 한 번에!

여러 갈래의 길 중 어떤 길을 선택하느냐에 따라 프로그램의 운명이 바뀝니다. 조건문은 자바 흐름 제어의 핵심 중 핵심이에요!

안녕하세요, 여러분 😊 오늘부터는 자바에서 흐름 제어를 다루는 아주 중요한 단원에 들어갑니다. 바로 조건문과 반복문이죠! 그중에서도 이번 시간에는 조건문에 집중해 볼 거예요. "if 문", "else 문", "else if", 그리고 "switch 문"까지! 이름만 들어도 좀 낯설고 복잡해 보이지만, 걱정 마세요. 하나하나 직접 예제를 따라가면서 이해하다 보면, 분기처리의 원리가 머릿속에 딱! 정리될 거예요. 특히 실무에서 자주 쓰이는 조건 처리 패턴과 주의할 점도 함께 알려드릴 테니 끝까지 집중해주세요! 😊

1. if 문 기본 구조와 예제 💬

자바에서 조건 분기를 위한 가장 기본적인 도구는 if 문이에요. 말 그대로, 조건이 참일 때만 특정 코드를 실행하게 만드는 구조입니다. 프로그램의 흐름을 제어할 수 있는 강력한 도구죠.

📌 기본 문법

if (조건식) {
    // 조건식이 true일 때 실행되는 코드
}

조건식은 true 또는 false로 평가되는 논리 표현식이에요. 조건이 참이면 중괄호 내부의 코드가 실행되고, 거짓이면 무시됩니다.

💻 실습 예제

int number = 10;

if (number > 5) {
    System.out.println("5보다 큽니다!");
}

위 코드에서 변수 number는 10입니다. 조건식 number > 5는 참이기 때문에 "5보다 큽니다!"가 출력돼요. 만약 조건이 거짓이면 아무 일도 일어나지 않아요.

🧠 자주 쓰이는 패턴

• 입력된 값이 특정 기준을 넘는지 확인할 때
• 로그인 성공 여부 판단 시
• 게임에서 조건에 따라 이벤트 발생 처리할 때

📊 요약 정리

이처럼 if 문은 자바 조건문 흐름 제어의 첫걸음이에요. 실전에서 가장 자주 쓰이는 기본 도구이니, 손에 익을 때까지 반복 연습하는 게 좋아요.

2. if ~ else 문으로 양자택일 처리하기 🔀

앞서 살펴본 if 문은 특정 조건이 참일 때만 코드를 실행하지만, else와 함께 사용하면 조건이 거짓일 때 실행할 대안 코드를 명확히 지정할 수 있어요. 이른바 양자택일 구조죠!

📌 기본 문법

if (조건식) {
    // 조건이 참일 때 실행
} else {
    // 조건이 거짓일 때 실행
}

조건식이 true라면 if 블록의 코드가 실행되고, false라면 else 블록의 코드가 실행됩니다. 단 하나만 실행되는 구조라서 의사결정에 매우 적합하죠.

💻 실습 예제

int score = 70;

if (score >= 80) {
    System.out.println("합격입니다!");
} else {
    System.out.println("불합격입니다.");
}

여기서 score가 80 이상이면 "합격입니다!"가 출력되고, 그렇지 않으면 "불합격입니다."가 출력돼요. 하나는 반드시 실행되니 판단의 흐름이 명확하죠.

🧠 if ~ else의 활용 예시

• 로그인 성공 여부 판단
• 버튼 클릭 여부에 따라 화면 전환
• 입력 값 유효성 확인 결과에 따라 처리 분기

📊 if vs if ~ else 비교

if ~ else는 두 가지 상황 중 하나를 고를 때 유용해요. 예/아니오, 참/거짓, 승/패 같은 이분법적인 상황에 적합하죠!

3. else if 문으로 다중 조건 분기하기 🪜

두 가지 경우만 처리하는 if ~ else로는 부족할 때가 있어요. 예를 들어 점수에 따라 A, B, C, F 등 여러 등급을 나누려면? 이럴 땐 else if를 써서 조건을 여러 단계로 나눌 수 있습니다.

📌 기본 문법

if (조건1) {
    // 조건1이 참일 때 실행
} else if (조건2) {
    // 조건2가 참일 때 실행
} else if (조건3) {
    // 조건3이 참일 때 실행
} else {
    // 위 모든 조건이 거짓일 때 실행
}

조건은 위에서부터 아래로 차례대로 평가되며, 처음으로 참이 되는 조건의 블록만 실행돼요. 나머지는 무시됩니다.

💻 실습 예제

int score = 85;

if (score >= 90) {
    System.out.println("A학점입니다!");
} else if (score >= 80) {
    System.out.println("B학점입니다!");
} else if (score >= 70) {
    System.out.println("C학점입니다!");
} else {
    System.out.println("F학점입니다!");
}

점수가 85이기 때문에 첫 조건(score >= 90)은 거짓, 두 번째 조건(score >= 80)이 참이 되어 "B학점입니다!"가 출력됩니다.

🧠 활용 시 유의사항

• 조건 순서가 중요해요. 먼저 참이 되는 조건이 실행되고 나머지는 무시돼요!
• 조건이 겹치지 않도록 조심하세요. 논리적 충돌 방지!
• 마지막 else는 생략 가능하지만, 모든 조건이 거짓일 경우를 대비해 넣는 것이 좋아요.

📊 구조 요약 비교

다중 조건을 깔끔하게 정리할 수 있는 else if 문! 실무 코딩에서도 자주 등장하니 익숙해지는 것이 중요해요. 다음에는 중첩 if 문으로 조금 더 복잡한 분기 상황을 다뤄볼게요.

4. 중첩 if 문 사용 시 주의할 점 🧩

자바에서는 if 문 안에 또 다른 if 문을 넣을 수 있어요. 이를 중첩 if 문(nested if)이라고 부릅니다. 복잡한 조건 분기를 처리할 수 있는 강력한 방법이지만, 주의해서 사용하지 않으면 가독성이 급격히 나빠질 수 있어요.

📌 기본 문법

if (조건1) {
    if (조건2) {
        // 조건1과 조건2가 모두 참일 때 실행
    }
}

이 구조는 "조건1이 참인 경우에만 조건2를 평가"하게 되므로, 조건 간 종속 관계를 표현할 때 유용해요.

💻 실습 예제

int age = 20;
boolean hasTicket = true;

if (age >= 18) {
    if (hasTicket) {
        System.out.println("입장 가능합니다.");
    }
}

위 예제는 나이가 18세 이상이고, 동시에 티켓이 있어야만 "입장 가능합니다."가 출력돼요. 조건 간 종속성을 표현할 때 중첩 if 문은 좋은 도구가 될 수 있어요.

⚠️ 중첩 if 문 주의사항

• 중첩이 깊어질수록 코드 가독성이 떨어지므로 2~3단계 이상은 피하기
• if ~ else if로 대체 가능한 경우 중첩 대신 평면 구조 사용 권장
• 중괄호 {} 생략은 절대 금지! 버그 발생 원인이 됨

💡 구조 개선 예시

// 중첩 대신 논리 연산자로 조건 간소화
if (age >= 18 && hasTicket) {
    System.out.println("입장 가능합니다.");
}

이렇게 논리 연산자를 활용하면 중첩 없이도 간단하고 읽기 쉬운 코드로 개선할 수 있어요. 꼭 필요한 경우가 아니라면 중첩은 줄이는 게 좋아요.

5. switch 문 개념과 사용법 🎛️

조건이 많을 때 if ~ else if 문을 사용하면 코드가 길어지고 읽기 어려워요. 이런 상황에서 switch 문을 사용하면 가독성이 훨씬 좋아지고 명확한 분기 구조를 만들 수 있어요.

📌 기본 문법

switch (변수) {
    case 값1:
        // 값1일 때 실행할 코드
        break;
    case 값2:
        // 값2일 때 실행할 코드
        break;
    default:
        // 어떤 case에도 해당하지 않을 때 실행
}

switch 문은 특정 변수의 값에 따라 분기를 나누는 구조예요. case별로 코드를 작성하고, break를 사용해 분기 처리를 끝내요.

💻 실습 예제

int day = 3;

switch (day) {
    case 1:
        System.out.println("월요일입니다.");
        break;
    case 2:
        System.out.println("화요일입니다.");
        break;
    case 3:
        System.out.println("수요일입니다.");
        break;
    default:
        System.out.println("기타 요일입니다.");
}

day가 3이므로 "수요일입니다."가 출력됩니다. break가 없으면 다음 case로 흘러가게 되니, 잊지 말고 꼭 break 쓰기!

🧠 switch 문 특징

• byte, short, int, char, String 등 사용 가능
• double, float, boolean은 사용 불가!
• default는 모든 case가 실패했을 때 실행됨

📊 비교: switch vs else if

switch 문은 단순한 값 비교에 특히 강력하고, 코드를 짧고 명확하게 만들 수 있어요. 하지만 복잡한 조건에는 if 문이 더 유연하답니다.

6. switch 문과 if 문 선택 기준 🎯

조건문을 사용할 때 항상 고민되는 것 중 하나! 과연 if 문을 쓸까, switch 문이 더 좋을까? 이 두 문법은 비슷한 역할을 하지만 각각의 특성과 용도에 따라 선택해야 해요. 자바에서는 다음과 같은 기준으로 구분하면 좋아요.

📌 선택 기준 요약

🧠 실전에서는 이렇게 선택하세요!

• 복잡한 조건을 다룰 땐 if 문을 사용하세요. 논리식, 범위 비교 등에 유리합니다.
• 단순한 선택지(숫자, 문자, 문자열 등)가 여러 개라면 switch 문이 더 깔끔합니다.
• 성능 차이는 크지 않지만, 가독성과 유지보수를 기준으로 판단하세요.

결론적으로, 두 조건문 모두 상황에 따라 강력한 도구입니다. 중요한 건 코드의 명확성과 가독성이에요. 그래서 복잡한 조건에는 if, 단순한 선택에는 switch를 쓰는 게 자바 개발자들의 기본 원칙이라고 할 수 있죠!

🔚 마무리하며

이번 글에서는 자바의 조건 분기문에 대해 처음부터 끝까지 정리해보았어요. if 문을 시작으로 else, else if, 중첩 if, 그리고 switch 문까지 — 흐름 제어의 모든 핵심을 하나하나 직접 예제로 익혀봤죠. 조건문은 자바에서 정말 기초 중의 기초이면서도 실전에서 계속 쓰이게 되는 문법입니다.

이제 여러분은 상황에 따라 if를 쓸지 switch를 쓸지 판단할 수 있고, 코드의 흐름을 자유롭게 설계할 수 있는 수준까지 도달하셨어요. 앞으로 자바로 더 복잡한 프로그램을 짤 때도, 오늘 배운 조건문이 가장 먼저 머릿속에 떠오를 거예요. 👏👏👏

다음 글에서는 반복문 (for, while)을 활용해서 어떻게 프로그램 흐름을 반복시키는지 알아볼 거예요. 반복문까지 익히면 진짜 '제어문 마스터'라고 할 수 있답니다!

2.6 실습: 변수와 연산자 활용 – 키보드로 두 수를 입력받아 사칙연산 계산하기

자바에서 변수와 연산자만 제대로 익혀도, 여러분은 이미 실전 개발의 절반을 이해한 셈입니다. 간단한 계산기 프로그램을 직접 만들어보면서, 변수 선언과 입력 처리, 연산자 사용법까지 한 번에 정리해보세요!

안녕하세요! 😊 이번 시간에는 자바의 변수와 연산자를 직접 활용해보는 실습을 진행해볼게요. 그동안 배운 변수 선언과 입력 처리 방식, 그리고 산술 연산자들을 종합적으로 활용해볼 수 있는 기회랍니다. 자바 초보자분들에게는 아주 좋은 연습이 될 거예요! 사칙연산(덧셈, 뺄셈, 곱셈, 나눗셈)을 수행하는 간단한 콘솔 프로그램을 만들어보면서 입력부터 연산, 출력까지 하나의 흐름으로 이해해볼 수 있도록 준비했어요. 자, 그럼 코딩의 세계로 들어가볼까요?

1. 키보드 입력을 위한 Scanner 클래스 소개 🧾

자바에서 키보드로 값을 입력받으려면 Scanner라는 도구를 사용합니다. 이 클래스는 자바에서 사용자로부터 값을 입력받을 수 있도록 도와주는 아주 중요한 클래스예요.

Scanner는 java.util 패키지에 포함되어 있어서 사용하려면 반드시 import 해야 해요. 아래처럼요:

import java.util.Scanner;

Scanner를 사용하는 기본 문법은 아주 간단해요. Scanner sc = new Scanner(System.in);으로 객체를 생성하고, sc.nextInt()나 sc.nextLine() 등을 이용해 입력을 받으면 됩니다.

Scanner 클래스의 주요 메서드들 🔍

🎯 Scanner 사용 시 주의할 점

• nextInt()와 nextLine()을 혼용할 경우 줄바꿈 문제 발생 가능 (버퍼 주의)
• Scanner 객체는 한 번만 선언하고 사용하는 것이 원칙
• 프로그램 마지막에는 sc.close()로 자원 해제하는 습관 들이기

Scanner는 실습에서 자주 쓰이기 때문에 익숙해져야 해요. 특히 다양한 입력 타입을 처리하면서 입력 오류를 방지하는 습관을 들이면 이후 복잡한 프로그램에서도 유용하게 쓰일 거예요. 😎

2. 변수 선언과 사용자 입력 받기 🧍

이제 Scanner를 사용해서 값을 입력받을 준비가 되었으니, 입력값을 저장할 변수를 선언해야겠죠? 자바에서 변수를 선언할 때는 자료형 변수명의 형식으로 작성합니다. 예를 들어 두 정수를 입력받는다면 다음과 같이 선언할 수 있어요:

int num1;
int num2;

그리고 사용자로부터 입력을 받아 변수에 값을 저장하는 코드는 이렇게 됩니다:

Scanner sc = new Scanner(System.in);
System.out.print("첫 번째 숫자를 입력하세요: ");
int num1 = sc.nextInt();

System.out.print("두 번째 숫자를 입력하세요: ");
int num2 = sc.nextInt();

🧠 변수 선언 시 체크 포인트

• 변수명은 의미 있게! – num1, num2도 괜찮지만 firstNumber, secondNumber처럼 직관적인 이름이 좋습니다.
• 정수는 int, 실수는 double로! 입력값의 유형에 따라 자료형을 알맞게 설정하세요.

✅ 전체 입력 코드 예시

import java.util.Scanner;

public class CalculatorInput {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        System.out.print("첫 번째 숫자를 입력하세요: ");
        int num1 = sc.nextInt();

        System.out.print("두 번째 숫자를 입력하세요: ");
        int num2 = sc.nextInt();

        sc.close(); // 입력 스트림 닫기
    }
}

입력만 잘 처리해도 절반은 성공이에요! 변수 선언, 입력값 저장까지 정확히 이해했다면 이제 이 값들을 가지고 실제 연산을 해볼 차례입니다. 다음 단계에서는 드디어 산술 연산자를 사용해서 다양한 계산을 구현해볼 거예요. 기대되시죠? 😄

3. 산술 연산자 활용법 🔢

사용자로부터 입력받은 두 숫자를 가지고 이제 본격적으로 사칙연산을 해볼 시간이에요. 자바에서 산술 연산을 하려면 +, -, *, /, %와 같은 산술 연산자를 사용합니다.

🛠️ 산술 연산자의 종류와 사용법

이 연산자들은 기본적으로 숫자 타입(정수, 실수 모두)에 사용할 수 있어요. 연산 순서는 괄호 → 곱셈/나눗셈 → 덧셈/뺄셈 순이기 때문에 복잡한 식을 작성할 때는 괄호를 적절히 활용하는 것도 중요해요.

🎯 예시 코드: 연산 결과 출력

int sum = num1 + num2;
int sub = num1 - num2;
int mul = num1 * num2;
int div = num1 / num2;
int mod = num1 % num2;

System.out.println("덧셈 결과: " + sum);
System.out.println("뺄셈 결과: " + sub);
System.out.println("곱셈 결과: " + mul);
System.out.println("나눗셈 결과: " + div);
System.out.println("나머지 결과: " + mod);

여기서 중요한 포인트는 나눗셈 연산 시 0으로 나누는 오류예요. 만약 사용자 입력값 중 두 번째 수가 0이라면, num1 / num2는 실행 시 오류를 발생시키고 프로그램이 종료됩니다. 이를 방지하기 위한 조건문 처리도 꼭 추가해줘야 해요.

🧩 팁: 정수 나눗셈의 주의점

정수와 정수를 나누면 결과는 소수점 없이 정수로 반환된다는 걸 기억하세요. 예를 들어 7 / 2의 결과는 3입니다. 만약 3.5와 같은 결과를 원한다면 double형을 사용하거나 (double)num1 / num2처럼 형변환을 사용해야 해요.

4. 실습: 두 수를 입력받아 사칙연산 계산하기 🧮

자, 지금까지 배운 내용을 종합해서 하나의 계산기 프로그램을 만들어볼게요. 사용자로부터 두 개의 정수를 입력받고, 덧셈, 뺄셈, 곱셈, 나눗셈, 나머지까지 모두 계산해서 출력해주는 프로그램입니다.

🔧 전체 코드 예시

import java.util.Scanner;

public class SimpleCalculator {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        System.out.print("첫 번째 정수를 입력하세요: ");
        int num1 = sc.nextInt();

        System.out.print("두 번째 정수를 입력하세요: ");
        int num2 = sc.nextInt();

        int sum = num1 + num2;
        int sub = num1 - num2;
        int mul = num1 * num2;

        System.out.println("덧셈 결과: " + sum);
        System.out.println("뺄셈 결과: " + sub);
        System.out.println("곱셈 결과: " + mul);

        if (num2 != 0) {
            int div = num1 / num2;
            int mod = num1 % num2;
            System.out.println("나눗셈 결과: " + div);
            System.out.println("나머지 결과: " + mod);
        } else {
            System.out.println("나눗셈과 나머지 연산은 0으로 나눌 수 없습니다.");
        }

        sc.close();
    }
}

이 코드에서는 입력부터 출력까지의 흐름이 자연스럽게 연결되어 있어요. 특히 조건문을 통해 0으로 나누는 경우를 체크한 부분이 아주 중요하답니다.

📌 실행 예시

첫 번째 정수를 입력하세요: 10
두 번째 정수를 입력하세요: 3
덧셈 결과: 13
뺄셈 결과: 7
곱셈 결과: 30
나눗셈 결과: 3
나머지 결과: 1

🧠 실습 포인트 정리

• Scanner를 사용해 사용자 입력 받기
• 입력값을 변수에 저장하고 산술 연산자 적용하기
• 나눗셈 전에 0인지 조건문으로 체크하기
• 프로그램 마지막에는 꼭 sc.close()로 자원 해제하기

이 실습은 자바 문법의 기초를 확실히 다질 수 있는 예제예요. 직접 여러 숫자를 넣어보면서 결과를 확인해보세요. 그리고 오류가 발생했다면 그 원인을 꼭 분석해보는 습관! 정말 중요합니다.

5. 자주 발생하는 입력 관련 오류와 해결법 🛠️

실습을 하다 보면 종종 입력 처리에서 오류가 발생하는 경우가 있어요. 그럴 땐 당황하지 말고, 문제의 원인을 하나씩 점검해보는 게 중요합니다. 여기서는 초보자들이 가장 많이 겪는 입력 관련 오류들을 정리하고, 그 해결 방법도 함께 알려드릴게요.

❗ 오류 1: nextInt() 후 nextLine()이 작동하지 않는 문제

nextInt()로 숫자를 입력받은 후 nextLine()을 바로 사용하면, 줄바꿈 문자(\n)가 남아 있어서 입력 없이 넘어가버리는 현상이 발생합니다.

해결 방법: nextLine()을 사용하기 전에 sc.nextLine();을 한 번 더 실행해서 줄바꿈 문자를 제거해 주세요.

sc.nextInt();     // 숫자 입력
sc.nextLine();     // 줄바꿈 제거
String str = sc.nextLine();  // 문자열 입력

❗ 오류 2: 숫자가 아닌 값 입력 시 예외 발생

nextInt()나 nextDouble()은 사용자가 숫자가 아닌 값을 입력하면 InputMismatchException이라는 예외를 발생시켜요. 이건 자바가 해당 입력을 숫자로 해석할 수 없기 때문이죠.

해결 방법: 예외 처리를 위한 try-catch 문을 사용해서 사용자 입력을 검증하면 프로그램이 갑자기 종료되는 걸 막을 수 있어요.

try {
    int num = sc.nextInt();
} catch (InputMismatchException e) {
    System.out.println("숫자를 입력해야 합니다.");
    sc.next(); // 잘못된 입력 제거
}

❗ 오류 3: 0으로 나누기

자바에서 0으로 나누는 건 절대 불가능해요. 정수를 0으로 나누면 ArithmeticException 예외가 발생하고, 실수의 경우에는 Infinity라는 결과가 나올 수도 있어요.

해결 방법: 나눗셈을 하기 전에 반드시 if(num2 != 0) 조건을 확인하고 실행하도록 하세요.

📝 요약 리스트

• nextInt() 이후 nextLine() 사용 시 줄바꿈 제거 필요
• 잘못된 입력은 try-catch로 예외 처리
• 0으로 나누는 연산은 반드시 조건문으로 방지

자바에서 입력 오류는 초보자들이 가장 많이 부딪히는 부분이에요. 하지만 그만큼 실력을 빨리 키울 수 있는 기회이기도 하죠. 💪 오류가 발생하면 무서워하지 말고, 차근차근 원인을 분석해보는 습관을 들이세요!

6. 실습 마무리 퀴즈 및 정리 📝

지금까지 우리는 Scanner를 이용한 입력 처리, 변수 선언, 산술 연산자 활용, 그리고 예외 처리까지 모두 실습해봤어요. 이 모든 개념은 자바 입문자의 필수 토대랍니다. 이번엔 복습을 겸해 간단한 퀴즈로 마무리해볼게요. 😊

✅ 복습 퀴즈

1. 자바에서 키보드 입력을 처리하는 클래스는 무엇인가요?
2. nextInt() 다음에 nextLine()을 사용할 때 주의해야 할 점은?
3. 0으로 나누기를 방지하기 위해 사용하는 조건문은 어떤 형식인가요?
4. 사용자로부터 두 정수를 입력받아 덧셈 결과만 출력하는 코드를 직접 작성해보세요.

📌 핵심 요약

• Scanner 클래스를 사용하면 키보드로부터 다양한 타입의 값을 입력받을 수 있음
• 변수는 입력된 값을 저장하고 연산을 가능하게 하는 핵심 도구
• 산술 연산자를 이용해 수학적 연산을 간단하게 수행할 수 있음
• 예외 처리는 프로그램을 더 안전하고 견고하게 만들어줌

이제 여러분도 자바로 아주 간단한 계산기를 구현할 수 있게 되었어요! 🎉 물론 지금은 아주 기본적인 수준이지만, 이 구조가 더 복잡한 프로그램의 밑거름이 된다는 점, 꼭 기억해두세요. 다음 단계에서는 조건문과 반복문을 활용한 더 다양한 흐름 제어 방법도 배워볼 거예요. 😊

마무리하며 ✨

이번 실습을 통해 여러분은 자바에서 가장 기초적이지만 중요한 개념인 변수 선언, 입력 처리, 산술 연산자 활용을 스스로 코드로 구현해보았어요. 단순한 계산기 프로그램이지만, 입력값의 흐름과 조건 분기, 예외 처리까지 연습할 수 있었죠.

자바 학습을 시작한 초보자분들에게 이 정도 프로젝트는 정말 좋은 훈련이에요. 직접 키보드로 입력값을 넣고 그 결과를 확인해보는 과정 속에서 프로그래밍이 단순히 이론이 아니라, 논리적인 흐름을 만드는 작업이라는 걸 자연스럽게 느낄 수 있었을 거예요.

앞으로는 조건문, 반복문, 배열 등 더 복잡한 구조로 나아가겠지만, 오늘 다룬 Scanner와 연산자의 개념은 그 모든 곳에서 계속 활용됩니다. 그러니 꼭 여러 번 연습해보세요. 틀려도 괜찮아요. 오히려 틀릴수록 더 많이 배울 수 있거든요! 😉

2.5 키보드 입력과 Scanner 사용 – 표준 입력을 통해 값 읽어오기, Scanner 클래스 활용

여러분, 프로그램 실행 도중에 사용자로부터 직접 값을 입력받을 수 있다면 훨씬 유연하고 똑똑한 코드가 될 수 있다는 사실, 알고 계셨나요? 바로 Scanner가 그 핵심 역할을 해낸답니다!

안녕하세요, 자바 학습자 여러분 😊 오늘은 자바 프로그램에서 키보드를 통해 데이터를 입력받는 방법을 배워볼 거예요. 사실 지금까지는 값을 직접 코드에 써 넣는 방식으로만 프로그램을 작성했을 텐데요, 이제는 사용자가 직접 입력한 정보를 읽어올 수 있는 표준 입력 방식에 대해 배워볼 차례입니다! Scanner 클래스는 자바에서 매우 자주 쓰이는 입력 도구인데요, 그만큼 실전에서도 활용도가 아주 높아요. 특히 초보 개발자 분들이 처음으로 사용자와 상호작용하는 프로그램을 만들어볼 수 있는 좋은 기회가 되니, 이번 주제 놓치지 말고 꼭 챙겨보세요!

1. 키보드 입력이란? 🤔

자바 프로그램에서 키보드 입력은 사용자로부터 실시간으로 값을 입력받는 방법입니다. 보통 우리가 작성한 프로그램은 정해진 값을 기준으로 동작하죠. 하지만 키보드 입력 기능이 들어가면 사용자의 행동에 따라 결과가 달라지는 인터랙티브한 프로그램이 됩니다.

예를 들어, 사용자의 이름을 입력받아 인사 메시지를 출력하거나, 두 수를 입력받아 더한 결과를 보여주는 프로그램처럼요! 이런 기능을 만들기 위해선 표준 입력이라는 개념을 이해해야 합니다.

🧾 표준 입력(Standard Input)의 개념

• 운영체제에서 표준 입력 장치는 보통 키보드입니다.
• 자바는 이 입력을 읽기 위해 System.in 스트림을 제공합니다.
• System.in은 기본적으로 바이트 단위로 입력을 처리합니다.

💡 하지만 문자열이나 숫자 입력을 처리하려면?

이때 등장하는 것이 바로 Scanner 클래스입니다. Scanner는 System.in을 기반으로 문자열, 정수, 실수 등 다양한 자료형을 손쉽게 읽을 수 있게 도와주는 아주 고마운 도구랍니다.

📋 정리: 키보드 입력 이해 포인트

다음 섹션에서는 본격적으로 Scanner 클래스가 뭔지, 왜 쓰는지, 그리고 어떻게 쓰는지를 차근차근 알려드릴게요! 🔍

2. Scanner 클래스의 개념과 필요성 📚

Scanner 클래스는 자바에서 사용자 입력을 쉽게 처리하기 위해 제공되는 도구입니다. 콘솔에 입력한 데이터를 텍스트 단위로 읽어들여 원하는 데이터 형식으로 바꾸어줍니다. 복잡한 입출력 처리를 직접 구현하지 않고도 다양한 형식의 데이터를 손쉽게 다룰 수 있어요.

🔍 Scanner 클래스의 주요 기능

• 문자열 입력 → next(), nextLine()
• 정수 입력 → nextInt()
• 실수 입력 → nextDouble(), nextFloat()

🧠 왜 Scanner가 필요한가요?

1. 입력을 자동으로 자료형에 맞게 변환해줘서 따로 파싱할 필요가 없어요.
2. 한 줄 전체 혹은 공백 단위로 유연하게 읽기가 가능해요.
3. 자바에서 제공하는 API라 설정 없이 바로 사용 가능하죠!

📌 Scanner 클래스 선언 예시

import java.util.Scanner;

public class InputExample {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in); // Scanner 객체 생성
        System.out.print("이름을 입력하세요: ");
        String name = sc.nextLine(); // 문자열 입력 받기
        System.out.println("안녕하세요, " + name + "님!");
    }
}

📢 Scanner 사용 시 주의할 점

next()와 nextLine()은 작동 방식이 달라서 입력값이 의도와 다르게 처리될 수 있어요. 줄바꿈(\n) 문제를 주의해서 사용해야 합니다. 이 부분은 뒤에서 더 자세히 다룰게요.

지금까지 Scanner의 기본 개념을 살펴봤어요. 다음 파트에서는 이 Scanner를 실제로 어떻게 쓰는지 단계별로 알아볼 거예요!

3. Scanner 클래스 기본 사용법 🔤

Scanner 클래스는 입력을 다룰 수 있는 다양한 메서드를 제공합니다. 가장 기본적인 사용법은 객체를 생성한 뒤, 필요한 입력 메서드를 호출하는 방식입니다.

✅ Scanner 객체 생성

Scanner sc = new Scanner(System.in);

위 코드는 키보드 입력을 받을 준비를 하는 것이고, sc는 Scanner 객체의 이름입니다. 다른 이름을 써도 되지만, sc는 관례적으로 많이 사용됩니다.

🧾 주요 입력 메서드

📌 주의! next() vs nextLine()

많은 초보자들이 실수하는 부분이 바로 next()와 nextLine()의 차이입니다. next()는 공백 전까지만 읽고, nextLine()은 한 줄 전체를 읽습니다. 그래서 앞에 nextInt() 등을 사용하고 바로 nextLine()을 쓰면, 줄바꿈 문자(\n)가 남아서 빈 문자열을 읽는 문제가 발생합니다.

🎯 입력 처리 기본 예제

import java.util.Scanner;

public class InputTypes {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        System.out.print("이름을 입력하세요: ");
        String name = sc.nextLine();

        System.out.print("나이를 입력하세요: ");
        int age = sc.nextInt();

        System.out.println("이름: " + name);
        System.out.println("나이: " + age);
    }
}

다음 장에서는 정수, 실수, 문자열 등 다양한 자료형을 입력받는 방법을 좀 더 구체적으로 살펴볼게요!

4. 다양한 자료형 입력 받기 🎛

Scanner 클래스를 활용하면 다양한 자료형의 입력을 받을 수 있습니다. 대표적으로 문자열, 정수, 실수, 불린값 등을 처리할 수 있어요. 아래에 각각의 자료형별 입력 방식과 주의할 점을 정리해드릴게요.

📦 자료형별 입력 메서드

💡 예외 상황 주의하기

• 숫자 입력 시 숫자가 아닌 문자를 입력하면 InputMismatchException 오류 발생
• nextInt() → nextLine() 순으로 쓸 때 줄바꿈 문제로 빈 값 입력될 수 있음

🧪 실습 예제: 다양한 입력 받기

import java.util.Scanner;

public class InputTypesExample {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        System.out.print("문자열 입력: ");
        String text = sc.nextLine();

        System.out.print("정수 입력: ");
        int number = sc.nextInt();

        System.out.print("실수 입력: ");
        double dnum = sc.nextDouble();

        System.out.print("참/거짓 입력 (true/false): ");
        boolean flag = sc.nextBoolean();

        System.out.println("입력된 문자열: " + text);
        System.out.println("입력된 정수: " + number);
        System.out.println("입력된 실수: " + dnum);
        System.out.println("입력된 불린값: " + flag);
    }
}

다양한 자료형을 입력받고 출력해보는 간단한 프로그램이지만, 실제 프로젝트에서도 아주 유용하게 쓰이는 패턴이랍니다. 다음 장에서는 입력 도중 발생할 수 있는 오류와 그 해결법을 살펴볼게요. 🙌

5. 자주 발생하는 입력 오류와 해결법 🛠

Scanner를 사용할 때 가장 자주 마주치는 문제는 바로 입력값의 처리 순서와 예외 발생입니다. 특히 nextInt()와 nextLine()의 혼용, 사용자가 예상치 못한 값을 입력했을 때 프로그램이 멈추는 현상 등이 대표적이에요.

😵 nextInt() 사용 후 nextLine()이 무시될 때

nextInt()는 숫자 입력 후 엔터키(\n)는 읽지 않고 남깁니다. 그래서 그 다음 nextLine()이 실행되면, 남아 있던 줄바꿈 문자를 그대로 읽어버려서 빈 문자열이 입력된 것처럼 처리되죠.

System.out.print("나이 입력: ");
int age = sc.nextInt();  // 숫자 입력

sc.nextLine(); // 줄바꿈 제거용 (중요!)

System.out.print("이름 입력: ");
String name = sc.nextLine(); // 이제 정상적으로 입력 받음

⚠️ InputMismatchException 예외

nextInt()나 nextDouble()은 숫자만을 입력받아야 하는데, 사용자가 실수로 문자열이나 특수기호를 입력하면 InputMismatchException이 발생해요.

🛡 해결 방법

• try-catch 문으로 예외 처리하기
• 문자열로 먼저 받은 후 Integer.parseInt()로 변환

try {
    int age = sc.nextInt();
} catch (InputMismatchException e) {
    System.out.println("정수를 입력해주세요!");
}

📝 오류 상황 정리

입력 도중 발생하는 오류는 처음에는 꽤 당황스럽지만, 그 원인을 정확히 알면 금방 해결할 수 있어요. 이제 마지막으로, Scanner를 활용한 실전 예제를 만들어 보며 정리해볼게요! 🎯

6. Scanner를 활용한 입력 예제 실습 ✍️

이제 우리가 배운 내용을 종합해서 Scanner 클래스를 실제로 사용하는 프로그램을 만들어 볼 차례예요. 이 실습에서는 문자열, 정수, 실수를 모두 입력받아 처리해보는 간단한 인터랙티브 콘솔 애플리케이션을 구현해봅니다. 🎮

🎯 목표

• 사용자로부터 이름, 나이, 키(cm)를 입력받기
• 입력된 정보를 바탕으로 간단한 인사 메시지 출력하기

📌 실전 코드

import java.util.Scanner;

public class UserProfile {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        System.out.print("이름을 입력하세요: ");
        String name = sc.nextLine();

        System.out.print("나이를 입력하세요: ");
        int age = sc.nextInt();
        sc.nextLine(); // 버퍼 비우기

        System.out.print("키(cm)를 입력하세요: ");
        double height = sc.nextDouble();

        System.out.println("\n--- 입력 결과 ---");
        System.out.println("이름: " + name);
        System.out.println("나이: " + age + "세");
        System.out.println("키: " + height + "cm");

        System.out.println("\n반갑습니다, " + name + "님! 👋");
    }
}

✅ 실행 예시

이름을 입력하세요: 민수
나이를 입력하세요: 24
키(cm)를 입력하세요: 175.5

--- 입력 결과 ---
이름: 민수
나이: 24세
키: 175.5cm

반갑습니다, 민수님! 👋

🔍 실습을 통해 확인할 포인트

• 입력 순서에 따라 줄바꿈 처리가 필요한 부분을 확인했나요?
• 다양한 자료형 입력을 자연스럽게 처리할 수 있었나요?

이제 여러분도 Scanner를 활용한 사용자 입력 처리를 충분히 이해하셨을 거예요. 다음 섹션에서는 마무리로 이 장에서 배운 핵심 내용을 정리하고, 태그와 함께 마무리 인사를 전하겠습니다 😊

마무리하며 ✨

이번 글에서는 자바에서 사용자로부터 값을 입력받기 위한 Scanner 클래스의 개념부터 실제 활용까지 꼼꼼히 살펴봤습니다. 단순히 값을 출력하는 프로그램을 넘어서, 사용자의 입력을 받아 동적으로 동작하는 프로그램을 만드는 데 있어 Scanner는 매우 강력한 도구라는 걸 알 수 있었죠.

특히 nextInt()와 nextLine()의 차이, 입력 예외 처리, 줄바꿈 버퍼 문제 등은 실무와 과제 모두에서 자주 마주치는 포인트이니 꼭 익혀두시기 바랍니다. 입력 예제 실습까지 직접 해보셨다면, 이제 여러분도 키보드 입력과 Scanner는 마스터하셨다고 봐도 좋아요! 💯

다음 장에서는 조건문과 흐름 제어에 대해 배워보게 될 텐데요, 그 전에 이번 Scanner 실습을 조금 더 응용해서 미니 계산기나 간단한 설문 프로그램도 한번 도전해보는 건 어떨까요? 😉

2.4 연산자 우선순위 개념과 괄호를 통한 제어

이 표현식, 과연 어떤 결과가 나올까요? 자바 연산자 우선순위와 평가 순서를 이해하지 못하면 의도치 않은 결과가 나올 수도 있어요!

안녕하세요! 오늘은 자바 연산자의 우선순위와 평가 순서에 대해 알아보려 해요. 프로그래밍을 처음 배우는 분들이 가장 혼란스러워하는 부분 중 하나인데요. 예를 들어 `a + b * c`라는 표현식에서 어떤 연산이 먼저 실행될지 바로 알 수 있으신가요? 😅 이런 혼란을 방지하려면 연산자의 우선순위와 평가 방향을 정확히 이해하는 게 정말 중요해요. 그리고 괄호를 적절히 활용하는 습관도요! 이번 글에서는 자바에서 사용되는 다양한 연산자의 우선순위를 한눈에 살펴보고, 어떤 상황에서 괄호를 사용해야 할지 예제를 통해 배워볼 거예요. 실전 코딩을 하다 보면 연산 순서가 결과에 큰 영향을 미치는 경우가 정말 많거든요. 자, 그럼 함께 알아볼까요? ✨

1. 연산자 우선순위란 무엇인가요? 🤔

프로그래밍 언어에서는 다양한 연산자들이 존재하죠. 자바에서도 덧셈(+), 곱셈(*), 논리 연산자(&&), 비교 연산자(==) 등 여러 종류의 연산자를 사용할 수 있습니다. 그런데 이 연산자들이 한 줄의 코드에서 여러 개 등장하면 어떤 순서로 연산이 될까요? 바로 그때 필요한 개념이 연산자 우선순위입니다.

예를 들어, 다음과 같은 식을 생각해볼게요:

int result = 10 + 2 * 3;

이 코드에서 *는 +보다 우선순위가 높기 때문에 2 * 3이 먼저 계산되고 그 결과에 10이 더해져 최종적으로 result = 16이 됩니다. 만약 +를 먼저 계산하고 싶다면 어떻게 해야 할까요? 그렇죠. 괄호를 사용해서 (10 + 2) * 3처럼 바꾸면 됩니다.

✅ 왜 우선순위가 중요할까요?

• 논리적 오류 방지: 연산 순서를 잘못 이해하면 전혀 다른 결과가 나올 수 있어요.
• 가독성 향상: 괄호를 적절히 활용하면 코드의 의도를 명확히 표현할 수 있어요.
• 디버깅 시간 절약: 우선순위를 제대로 이해하면 의도하지 않은 결과로 인한 디버깅 시간을 줄일 수 있어요.

🧠 실생활에 비유해 볼까요?

커피를 마시기 전에 물을 끓여야 하잖아요? 순서를 바꾸면 안 되죠! 자바에서도 마찬가지예요. 연산자의 순서를 잘못 지정하면 "끓이기 전에 마신" 것 같은 결과가 나옵니다. 😅

다음 섹션에서는 자바에서 제공하는 전체 연산자 우선순위를 표로 한눈에 정리해 드릴게요. 복잡한 것 같아도 금방 익숙해질 수 있어요!

2. 자바의 연산자 우선순위 표 📊

자바에서는 여러 연산자들이 미리 정해진 우선순위(priority)에 따라 평가됩니다. 아래는 자바 공식 문서 기준으로 정리한 연산자 우선순위 표입니다. 높은 우선순위를 가진 연산자가 먼저 실행됩니다.

표가 길다고 너무 부담 갖지 마세요! 처음에는 외우기보다는 "곱셈/나눗셈이 덧셈/뺄셈보다 먼저다"와 같은 자주 쓰는 우선순위만 기억해도 충분합니다. 그리고 항상 괄호를 통해 연산 순서를 명확하게 지정해주는 습관을 들이면 실수를 줄일 수 있어요.

3. 평가 순서(Associativity)란? 🔄

연산자 우선순위는 어떤 연산이 먼저 실행되는지를 알려주죠. 그런데 우선순위가 같은 연산자들이 나열되면 어떤 방향으로 평가될까요? 이때 필요한 개념이 바로 평가 순서(Associativity)입니다.

🧭 좌측 결합과 우측 결합

대부분의 연산자는 왼쪽에서 오른쪽으로(Left-to-Right) 평가됩니다. 하지만 몇몇 연산자는 오른쪽에서 왼쪽으로(Right-to-Left) 평가돼요. 예제를 보며 확인해볼게요!

int a = 10, b = 20, c = 30;
int result = a + b + c;

위 식에서는 + 연산자의 우선순위는 같고, 좌측 결합이 적용되므로 (a + b) + c로 계산됩니다. 반면 아래와 같은 예제를 볼까요?

int x;
x = y = z = 100;

여기서 대입 연산자 =는 우측 결합을 따릅니다. 그래서 z = 100이 먼저 실행되고, 그 결과가 y에 대입되고, 마지막으로 x에 대입돼요. 즉 x = (y = (z = 100))과 같은 순서로 평가됩니다.

📝 주요 연산자의 결합 방향

이렇게 평가 순서까지 이해하면 복잡한 식도 더욱 명확하게 읽을 수 있어요! 다음 장에서는 이 모든 우선순위와 평가 순서를 괄호를 이용해 어떻게 제어할 수 있는지 실전 예제로 알아볼게요. 💡

4. 괄호의 필요성과 사용법 🎯

연산자 우선순위나 평가 순서를 완벽하게 외우지 못해도 괜찮아요. 왜냐하면 괄호를 활용하면 어떤 연산을 먼저 처리할지 프로그래머가 직접 제어할 수 있기 때문이에요! 괄호는 우선순위를 강제로 바꾸는 가장 강력한 도구이자, 가독성을 높이는 최고의 방법이에요.

📌 괄호 사용의 예

int result1 = 10 + 2 * 3;        // 결과: 16
int result2 = (10 + 2) * 3;      // 결과: 36

위 코드에서 result1은 기본 우선순위에 따라 곱셈이 먼저 계산돼 2 * 3 = 6이 되고, 그 후에 10 + 6이 돼서 결과는 16이 나와요. 하지만 result2는 괄호로 덧셈이 먼저 실행되도록 했기 때문에 (10 + 2) * 3 = 36이라는 결과가 나옵니다. 바로 이런 차이를 의도적으로 만들기 위해 괄호를 사용하는 거예요.

🧼 괄호는 가독성 향상에도 효과적!

• 팀원들이 코드를 볼 때, 괄호로 연산 순서가 명확히 드러나면 해석하기 훨씬 쉬워요.
• 코드 리뷰 시 혼란을 줄이고, 예기치 않은 오류 가능성을 줄일 수 있어요.

💡 괄호 사용 꿀팁

1. 복잡한 수식이거나 연산자가 여러 개 섞여 있을 때는 무조건 괄호로 명확히 하자!
2. 조건문, 반복문 안의 조건식에서도 괄호를 적극 활용하자.
3. 계산 결과가 다르게 나올 수 있는 경우에는 실험적으로 괄호를 써서 테스트해보자.

괄호 하나로 코드의 운명이 바뀐다는 말, 과장 같지만 사실이에요! 😉 다음 섹션에서는 실전에서 자주 마주치는 헷갈리기 쉬운 표현식들을 통해 우선순위의 실제 활용을 확인해볼게요.

5. 헷갈리기 쉬운 표현식 예제 ⚠️

실제로 코드를 작성하다 보면, 우선순위와 평가 순서를 제대로 이해하지 못해 의도와 다른 결과를 얻게 되는 경우가 많아요. 아래 예제들을 함께 보며 어떤 부분이 헷갈리는지, 그리고 어떻게 해결하면 좋은지 확인해봐요!

🔍 예제 1: 논리 연산자와 비교 연산자의 충돌

boolean result = 5 < 3 && 10 > 5;

이 표현식은 5 < 3이 먼저 계산돼서 false가 되고, 이후 false && true가 되죠. 결과는 false입니다. 괄호 없이도 잘 작동하긴 하지만, 다음처럼 명시적으로 괄호를 써주는 게 좋아요:

boolean result = (5 < 3) && (10 > 5);

🔍 예제 2: 문자열 연결과 덧셈의 혼동

System.out.println("합계: " + 10 + 5);

이 코드는 "합계: 10"에 5가 문자열로 붙어서 "합계: 105"가 출력됩니다. 예상했던 "합계: 15"가 아니죠. 이를 해결하려면 괄호를 사용해서 덧셈이 먼저 되도록 해야 해요.

System.out.println("합계: " + (10 + 5)); // 출력: 합계: 15

🔍 예제 3: 삼항 연산자 중첩 사용

int a = 5;
String result = (a > 0) ? (a < 10 ? "0~9" : "10이상") : "0이하";

삼항 연산자는 우측 결합이기 때문에 위와 같이 중첩해서 쓸 수 있어요. 하지만 조건이 복잡해질수록 괄호로 각 조건을 명확히 구분하지 않으면 가독성이 떨어지고 버그가 발생할 위험이 커져요.

📌 실수 줄이는 팁 요약

• 문자열 연산과 숫자 연산이 섞일 때는 꼭 괄호로 연산 순서를 분명히 하기
• 조건문 안에서 삼항 연산자 중첩 사용은 최대한 피하고, 꼭 필요하다면 괄호로 구분
• 애매한 표현식은 변수로 나눠서 중간 계산값을 확인하는 것도 좋은 습관

실제 개발자들도 종종 겪는 실수들, 미리 알고 있으면 훨씬 수월하게 피할 수 있겠죠? 😊 이제 마지막으로, 우리가 배운 개념들을 실전 문제로 풀어보면서 연산자 우선순위에 익숙해져 볼까요?

6. 연산자 우선순위 실전 문제와 해설 🧩

자, 이제까지 배운 연산자 우선순위와 평가 순서, 괄호 사용 등을 종합해서 실전 문제로 연습해볼 시간입니다! 직접 코드를 예측해보며 실력을 점검해보세요 💪

🔧 실전 문제 1

int result = 4 + 3 * 2;
System.out.println(result);

• 예상 결과: 10
• 해설: 3 * 2가 먼저 계산돼서 6, 그 다음 4 + 6 = 10

🔧 실전 문제 2

int result = (4 + 3) * 2;
System.out.println(result);

• 예상 결과: 14
• 해설: 괄호로 4 + 3를 먼저 계산하므로 7 * 2 = 14

🔧 실전 문제 3

int x = 10;
int y = 5;
int result = x > y && y < 3 ? 100 : 200;
System.out.println(result);

• 예상 결과: 200
• 해설: x > y는 true, y < 3는 false, 전체 true && false = false. 삼항 조건식의 결과는 200

📚 정리 요약

• 자바 연산자는 우선순위에 따라 순서가 정해지며, 같은 순위일 경우 평가 방향(결합 순서)에 따라 결정됩니다.
• 복잡하거나 혼동되는 식은 괄호를 사용해 명확히 제어하세요!
• 우선순위를 외우기보다, 자주 쓰이는 연산의 순서를 기억하고 실습을 통해 익히는 것이 효과적입니다.

이제 자바의 연산자 우선순위에 대해 훨씬 더 자신이 생기셨을 거예요. 🙌 다음 시간에는 연산자 외에 또 다른 핵심 개념인 제어문으로 넘어가볼게요! 😊

마무리하며 🧠

연산자 우선순위와 평가 순서, 그리고 괄호의 사용법은 자바를 비롯한 모든 프로그래밍 언어에서 핵심적인 개념이에요. 우리가 생각하는 연산 순서와 컴파일러가 실제로 계산하는 순서가 다르면, 전혀 의도하지 않은 결과가 나올 수 있어요. 그래서 항상 명확한 괄호 사용과 기본 원칙의 이해가 중요하답니다.

지금 당장은 모든 연산자의 우선순위를 외우기 어렵더라도, 자주 사용하는 것부터 하나씩 익혀가면서 연습을 하다 보면 자연스럽게 익숙해질 거예요. 그리고 괄호는 언제나 여러분의 친구라는 사실! 😉 복잡한 코드일수록 괄호로 감싸주는 습관을 들이면 실수도 줄고, 협업 시에도 훨씬 가독성 좋은 코드를 만들 수 있답니다.

 끝까지 함께 해주셔서 고맙습니다 🙏

2.3 연산자와 표현식 – 산술, 대입, 비교, 논리 연산자 및 삼항 연산자 사용법

"자바 연산자는 단순한 기호가 아닙니다. 코드의 흐름과 논리를 결정하는 핵심 도구죠. 여러분은 그 진짜 의미를 제대로 알고 계신가요?"

안녕하세요, 여러분 😊 오늘은 자바 기본 문법에서 아주 중요한 파트인 연산자와 표현식에 대해 함께 배워볼 시간이에요! 숫자 계산뿐 아니라 조건 판단, 변수 값 변경, 논리 흐름 제어까지... 프로그래밍의 거의 모든 흐름은 연산자로 이루어진다고 해도 과언이 아니죠. 이번 포스팅에서는 산술 연산자부터 삼항 연산자까지 꼭 알아야 할 자바 연산자들의 사용법을 초보자 시선에서 차근차근 설명해 드릴게요. 실습 예제도 함께 보면서 하나씩 익혀보면 훨씬 쉬워질 거예요. 그럼 바로 시작해볼까요?

1. 산술 연산자 ✏️

산술 연산자는 숫자를 다룰 때 가장 기본이 되는 연산자입니다. 더하기(+), 빼기(-), 곱하기(*), 나누기(/), 나머지(%)와 같이 수학 시간에 배웠던 사칙연산 개념이 그대로 적용돼요. 자바에서는 정수, 실수에 상관없이 이 연산자들을 자유롭게 사용할 수 있어요.

📌 산술 연산자 종류

🧪 간단한 실습 예제

int a = 10;
int b = 3;

System.out.println("a + b = " + (a + b));
System.out.println("a - b = " + (a - b));
System.out.println("a * b = " + (a * b));
System.out.println("a / b = " + (a / b));
System.out.println("a % b = " + (a % b));

위 예제를 실행해 보면 각각의 연산 결과를 콘솔에 출력할 수 있어요. 특히 정수형 나눗셈은 결과가 소수가 아닌 정수로 나온다는 점, 그리고 나머지 연산자는 '짝수/홀수 판단' 같은 곳에서 자주 사용된다는 점을 꼭 기억하세요!

• Tip: 나머지 연산자(%)는 짝수인지 홀수인지 판단할 때 유용하게 쓰여요.
• 실수형 연산에서는 int 대신 double 타입을 사용해야 더 정확한 결과를 얻을 수 있어요.

산술 연산자는 우리가 코딩을 하면서 제일 자주 만나게 되는 친구입니다. 친숙해지면 생각보다 금방 손에 익게 돼요. 다양한 숫자 조합으로 직접 실습해보는 것도 큰 도움이 되겠죠?

2. 대입 연산자와 복합 대입 🔄

변수에 값을 넣어주는 대입 연산자는 프로그래밍에서 가장 기본적이면서도 자주 쓰이는 연산입니다. 단순히 = 기호 하나지만, 그 의미는 '같다'가 아니라 오른쪽 값을 왼쪽 변수에 넣는다라는 뜻이에요. 여기에 산술 연산자를 조합한 복합 대입 연산자를 사용하면 코드가 훨씬 짧고 간결해진답니다.

📌 기본 대입 및 복합 대입 연산자 종류

🧪 예제로 이해하기

int x = 10;

x += 5;  // x = 15
x -= 3;  // x = 12
x *= 2;  // x = 24
x /= 4;  // x = 6
x %= 4;  // x = 2

System.out.println("최종 값: " + x);

이처럼 복합 대입 연산자를 사용하면 가독성이 좋아지고 코드도 간결해지죠. 반복적으로 사용하는 연산에는 매우 유용하답니다!

• 주의: 대입 연산자에서 =는 '같다'가 아니라 '할당한다'라는 의미예요!

복합 대입 연산자는 초보자들이 자바 문법에 익숙해지는 데 아주 좋은 연습 대상이에요. 조금만 익숙해지면, 반복문에서도 정말 편하게 사용할 수 있게 된답니다 😊

3. 비교 연산자 📊

조건을 검사할 때 빠질 수 없는 도구가 바로 비교 연산자입니다. 숫자나 값이 서로 같은지, 큰지, 작은지를 판단해서 true 또는 false를 반환해요. 이 결과는 조건문(if, while 등)과 함께 사용되며, 프로그램의 흐름을 결정하는 핵심 역할을 합니다.

📌 비교 연산자 종류

🧪 조건문과 함께 사용해 보기

int age = 20;

if (age >= 18) {
  System.out.println("성인입니다.");
} else {
  System.out.println("미성년자입니다.");
}

비교 연산자 결과는 항상 true 또는 false로 반환되며, 조건문에서 이 값에 따라 코드의 흐름이 달라집니다.

• Tip: ==는 값이 같은지를 비교하지만, 문자열 비교에는 equals()를 사용해야 해요!

비교 연산자를 자유자재로 다룰 수 있다면, 조건문과 반복문까지 훨씬 쉽게 활용할 수 있어요. 다양한 숫자와 조건으로 실습해보는 걸 추천드려요 😊

4. 논리 연산자 ✅❌

논리 연산자는 여러 조건을 AND(&&), OR(||), NOT(!)으로 결합하거나 부정할 때 사용하는 연산자입니다. 단일 조건을 넘어서 복잡한 조건식을 만들 때 필수적으로 사용돼요. 조건문과 함께 자주 쓰이며, 연산 결과는 항상 true 또는 false입니다.

📌 논리 연산자 종류

🧪 논리 연산자 실습 예제

int age = 25;
boolean hasID = true;

if (age >= 20 && hasID) {
  System.out.println("입장 가능합니다.");
}

if (age < 18 || !hasID) {
  System.out.println("입장 불가입니다.");
}

위 예제에서 AND 조건은 둘 다 참일 때만 동작하고, OR 조건은 하나만 참이어도 참이 되며, NOT은 조건을 부정하는 역할을 해요.

• Tip: 복잡한 조건식은 괄호 ()를 사용해서 우선순위를 명확히 해주세요!

논리 연산자는 if문, while문과 정말 자주 사용되기 때문에 반드시 익숙해져야 해요. 직접 조건을 바꿔보면서 다양한 결과를 실습해보는 걸 추천드려요 💡

5. 삼항 연산자 (조건 연산자) 🎯

삼항 연산자는 조건문을 한 줄로 간결하게 표현할 수 있는 유용한 연산자입니다. 형식은 아래와 같이 간단한 구조를 가지며, 복잡한 조건 없이도 짧은 분기 처리에 자주 활용됩니다.

조건식 ? 참일 때의 값 : 거짓일 때의 값;

🧪 간단한 삼항 연산자 예제

int score = 85;

String result = (score >= 80) ? "합격" : "불합격";

System.out.println("결과: " + result);

위 예제에서는 점수가 80 이상이면 "합격", 아니면 "불합격"이라는 문자열을 출력합니다. if-else 문을 간단하게 대체할 수 있는 멋진 표현이죠!

🧩 삼항 연산자 실전 예시

int num = 7;

String type = (num % 2 == 0) ? "짝수" : "홀수";

System.out.println("이 숫자는 " + type + "입니다.");

삼항 연산자는 코드를 짧고 깔끔하게 만들고 싶을 때 정말 유용합니다. 단, 너무 많은 조건을 삼항 연산자 하나에 몰아넣으면 오히려 가독성이 떨어질 수 있으니 간단한 조건에서만 사용하는 게 좋아요.

• Tip: 삼항 연산자는 return 문 안에서도 자주 사용돼요. 예: return (x > 0) ? x : -x;

삼항 연산자는 초보자에게 꼭 추천하는 표현 방식이에요. if문만 쓰던 코드가 한 줄로 정리되면 뭔가 뿌듯하거든요 😎

6. 연산자 우선순위와 표현식의 흐름 🔁

자바에서 여러 개의 연산자가 한 줄에 함께 등장할 경우, 어떤 연산이 먼저 수행될까요? 바로 이때 연산자 우선순위가 중요한 역할을 해요. 우선순위가 높은 연산자부터 먼저 계산되고, 우선순위가 같다면 연산 방향(왼쪽 → 오른쪽)에 따라 처리됩니다.

📌 주요 연산자 우선순위 (상위 순)

🧪 우선순위에 따른 연산 흐름 예제

int result = 10 + 2 * 3;

System.out.println("결과: " + result);  // 출력값은 16

위 예제에서 덧셈보다 곱셈이 먼저 수행되기 때문에 2 * 3 = 6이 계산되고, 그 결과에 10을 더해 16이 출력되는 거예요.

• Tip: 우선순위가 헷갈릴 땐 ()로 명확히 지정해주는 습관이 좋아요!

표현식을 분석하고 계산하는 능력은 코딩 실력을 키우는 데 정말 중요한 포인트예요. 눈으로 계산 순서를 따라가며 직접 예제를 실습해 보세요 🔍

마무리 ✨

지금까지 자바에서 사용되는 다양한 연산자들을 하나하나 살펴보면서 산술, 대입, 비교, 논리, 삼항 연산자와 연산자 우선순위에 대해 학습해봤어요. 처음엔 단순한 기호처럼 보이지만, 실제 프로그래밍에서는 코드의 흐름을 결정짓는 중요한 요소들이라는 걸 느끼셨을 거예요.

연산자는 단순히 외워서 끝낼 게 아니라 직접 손으로 코드에 적용해보면서 감각적으로 익히는 것이 훨씬 중요해요. 연산자들을 조합해 다양한 표현식을 만들고, 직접 실행 결과를 확인해보는 과정을 반복하다 보면 어느새 여러분도 자연스럽게 익숙해질 거예요 😊

다음 챕터에서는 조건문과 반복문을 활용해 더 유용한 프로그램 흐름 제어를 배워볼 예정이에요. 기대해주세요!

2.2 리터럴과 형 변환 – 정수/실수/문자 리터럴, 자료형 간의 묵시적/명시적 형 변환

숫자 하나 입력했을 뿐인데, 갑자기 에러가? 🤯 자바에서 ‘리터럴’과 ‘형 변환’ 제대로 이해하지 못하면 진짜 골치 아파요!

안녕하세요, 자바를 처음 배우는 여러분! 지난 시간엔 변수와 자료형의 개념을 배워봤죠. 오늘은 그 연장선으로, 변수에 값을 넣을 때 필수로 알아야 할 리터럴(literal)과 형 변환(type casting)에 대해 알아볼 거예요. "int num = 10.5;" 이런 코드에서 왜 오류가 나는지, 혹은 "char c = 65;"가 어떻게 동작하는지 궁금하셨던 적 있죠? 이 챕터에서 그 모든 궁금증을 해소해드릴게요. 실습 중심으로 쉽게 설명드릴 테니 끝까지 따라와 주세요! 😊

1. 리터럴이란 무엇인가요? 🔤

프로그래밍에서 리터럴(Literal)이란 말은 낯설지만, 사실 우리는 매번 사용하고 있어요. 리터럴이란 고정된 값 자체를 의미해요. 예를 들어, 숫자 10, 문자 'A', 문자열 "Hello" 이런 것들이 모두 리터럴이에요.

조금 더 쉽게 말하면, 개발자가 코드에 직접 입력한 값은 전부 리터럴이에요. 반대로 변수나 메서드를 통해 결과로 얻는 값은 리터럴이 아니죠.

📌 리터럴의 예시

💡 꼭 알아두세요!

• 정수형 리터럴은 기본적으로 int로 간주됩니다. long으로 저장하고 싶다면 숫자 뒤에 L 또는 l을 붙여야 해요.
• 실수형 리터럴은 기본적으로 double 타입입니다. float으로 선언하려면 f 또는 F를 붙여야 해요.
• char형 리터럴은 작은따옴표(' ')로 감싸야 하며, 반드시 하나의 문자만 포함해야 해요.

자, 여기까지가 리터럴의 기본이에요! 다음 섹션에서는 실제로 이런 리터럴들이 변수와 어떻게 어울리는지, 그리고 리터럴이 자료형과 어떻게 관계되는지 살펴볼게요!

2. 정수, 실수, 문자, 논리 리터럴의 종류 📊

자바에서는 다양한 형태의 리터럴을 사용할 수 있어요. 변수에 대입하는 값이 숫자인지, 문자나 문자열인지, 또는 true/false인지에 따라 각기 다른 형식과 규칙이 적용됩니다. 이 섹션에서는 각각의 리터럴을 유형별로 정리해볼게요.

📌 기본 리터럴 종류와 표현 방식

✅ 리터럴 표현 시 주의할 점

• 정수형에서 큰 수를 다룰 때는 반드시 L을 붙여 long 타입으로 표현해야 오류가 없어요.
• 실수형에서 float을 사용하려면 접미사 f 또는 F를 반드시 붙여야 해요. 안 그러면 double로 인식돼요!
• char는 정수로 변환도 가능해요. 예를 들어 char c = 65;는 'A'로 해석됩니다!

이제 리터럴을 어떤 자료형에서 어떻게 표현하는지 좀 더 명확해지셨죠? 다음 장에서는 이런 리터럴들이 실제 자료형과 어떻게 연결되는지 구체적인 예제로 살펴볼게요.

3. 자바의 자료형과 리터럴 매칭 예시 🧩

리터럴을 정확히 이해하려면, 자바의 기본 자료형(primitive type)과 어떻게 매칭되는지를 아는 것이 매우 중요해요. 어떤 값이 어떤 타입과 잘 어울리는지 명확하게 정리해볼게요.

📌 기본형과 리터럴 매칭 표

💡 리터럴을 변수에 넣을 때 주의사항

• int i = 3.14;처럼 실수형 리터럴을 정수형 변수에 넣으면 오류가 발생해요.
• char c = 'AB';처럼 char에는 한 글자만 넣을 수 있어요. 문자열은 String으로 써야 해요.

변수 선언과 리터럴 간의 매칭을 정확히 알면 컴파일 오류 없이 안전한 코드를 작성할 수 있어요. 다음은 이 리터럴과 자료형이 서로 변환되는 과정, 형 변환(type casting)에 대해 본격적으로 다뤄보겠습니다!

4. 묵시적 형 변환이란? (자동 형 변환) 🔄

프로그래밍을 하다 보면 서로 다른 자료형끼리 연산하거나 값을 대입하는 경우가 생기는데요, 이때 자바는 자동으로 형 변환을 해주는 경우가 있어요. 이를 묵시적 형 변환(Implicit Type Conversion)이라고 해요.

쉽게 말해, 작은 범위 → 큰 범위로는 자바가 자동으로 변환을 해준다는 이야기예요. 예를 들어, int는 long으로, float는 double로 변환돼요. 우리가 따로 뭔가를 하지 않아도요!

📌 묵시적 형 변환 규칙

• byte → short → int → long → float → double 순으로 변환 가능해요.
• 문자형 char도 int로 자동 변환될 수 있어요.

💡 예제: 자동 형 변환

int i = 100;
long l = i;  // int → long 자동 형 변환
float f = l; // long → float 자동 형 변환

위 코드처럼 int 값을 long 변수에 대입해도 문제 없이 작동해요. 더 큰 그릇으로 옮기는 느낌이라고 생각하면 이해가 쉬워요.

⚠️ 자동 변환되지 않는 경우

• double d = 3.14f;은 가능하지만, float f = 3.14;는 오류 발생! 작은 그릇에 큰 값은 안 들어가요.

그럼 이 다음은 반대로 명시적 형 변환, 즉 강제로 자료형을 바꾸는 방법에 대해 알아볼 거예요. 이건 좀 더 주의가 필요하니 꼭 집중해주세요!

5. 명시적 형 변환이란? (강제 캐스팅) 🛠️

이번에는 자바에서 명시적 형 변환(Explicit Type Casting)에 대해 알아볼게요. 자동 형 변환과 반대로, 작은 자료형으로 바꿔야 할 경우엔 개발자가 직접 의도를 명확히 표시해줘야 해요. 이걸 캐스팅(casting)이라고 부릅니다.

즉, 큰 자료형을 작은 자료형으로 바꾸는 행위는 데이터 손실 가능성이 있기 때문에 자바가 자동으로 하지 않아요. 대신 괄호 ()를 이용해 우리가 직접 명령해야 하죠.

💡 기본 문법

변수 = (변환할_자료형) 값;

예를 들어 double 값을 int로 바꾸고 싶다면 이렇게 해요: int i = (int) 3.14; → 결과는 3 (소수점 이하 절삭!)

📌 명시적 형 변환 예제

double d = 9.99;
int i = (int) d;   // d의 값 9.99가 9로 변환됨

long l = 1000L;
short s = (short) l; // long에서 short로 변환

char c = (char) 65;  // 숫자 65는 문자 'A'로 변환

⚠️ 주의사항

• 데이터 손실 가능성: (int) 3.99 → 3처럼 소수점은 버려짐
• 범위 초과 문제: short s = (short) 33000;은 잘못된 값이 저장될 수 있어요!
• 형 변환은 코드 가독성을 떨어뜨릴 수 있어서 최소화하는 것이 좋아요.

명시적 형 변환은 꼭 필요한 경우에만 사용하는 것이 좋습니다. 코드의 안정성과 예측 가능성을 해칠 수 있기 때문이죠. 이제 자동 vs 명시적 형 변환의 차이도 확실해졌죠? 😎

6. 형 변환 실습 예제 모음 ✍️

이제 개념은 다 배웠으니, 진짜 중요한 실습 시간입니다! 🔧 묵시적 형 변환과 명시적 형 변환을 어떻게 활용하는지 직접 코드로 확인해 볼게요. 하나씩 실행하면서 자료형 간의 관계를 직접 체감해보세요.

🧪 예제 1: 묵시적 형 변환

byte a = 10;
int b = a;  // byte → int 자동 형 변환
float c = b; // int → float 자동 형 변환

System.out.println("b = " + b); // 10
System.out.println("c = " + c); // 10.0

위 코드처럼 작은 자료형 → 큰 자료형으로는 자바가 스스로 형을 맞춰줍니다. 개발자가 캐스팅을 명시할 필요가 없어요.

🧪 예제 2: 명시적 형 변환

double d = 7.89;
int i = (int) d;  // double → int 명시적 형 변환 (소수점 버림)

System.out.println("d = " + d); // 7.89
System.out.println("i = " + i); // 7

명시적 형 변환은 데이터 손실이 있을 수 있으니 주의해야 해요. 위 예제처럼 소수점이 버려지는 경우가 대표적이죠.

🧪 예제 3: 문자와 숫자 간의 형 변환

char c = 'A';
int code = c;   // 문자 → 정수 (묵시적 변환)
char c2 = (char) 66; // 정수 → 문자 (명시적 변환)

System.out.println("code = " + code); // 65
System.out.println("c2 = " + c2);     // B

자바에서는 char도 숫자로 간주되기 때문에 묵시적 형 변환이 가능해요. 아스키(또는 유니코드) 값을 기반으로 작동하죠!

📋 형 변환 요약 리스트

• 묵시적 형 변환: 작은 자료형 → 큰 자료형 (자동 변환)
• 명시적 형 변환: 큰 자료형 → 작은 자료형 (데이터 손실 주의)
• 문자와 숫자는 서로 변환 가능 (아스키/유니코드 기반)

이제 리터럴과 형 변환의 모든 기초를 직접 실습해봤어요. 완벽하게 이해되셨다면 다음 장에서 이 내용을 종합적으로 정리하면서 마무리해볼게요! 😊

🔚 마무리하며: 리터럴과 형 변환, 이제 확실하게 이해되셨나요?

자바에서 리터럴은 변수에 직접 넣는 값 그 자체이고, 형 변환은 그 값이나 변수를 다른 자료형으로 바꿔주는 과정이에요. 묵시적 형 변환은 자바가 자동으로 해주는 ‘편리한 변환’이고, 명시적 형 변환은 프로그래머가 책임지고 직접 지시해야 하는 ‘주의가 필요한 변환’이죠.

오늘 내용을 정리해보면 다음과 같아요:

• 정수, 실수, 문자, 논리형 등 다양한 리터럴이 존재한다는 것!
• 자동 형 변환은 자료형의 크기 순서에 따라 자바가 스스로 해준다!
• 명시적 형 변환은 괄호 ()를 사용해 개발자가 직접 변환을 지시해야 한다!

이 개념을 확실히 이해하고 연습해두면, 나중에 복잡한 연산이나 타입 간의 연동에서도 훨씬 수월하게 자바를 다룰 수 있어요. 다음 시간에는 조건문과 제어문을 통해 자바의 흐름 제어 방식에 대해 배워볼게요. 놓치지 마세요! 🚀

2.1 자바 기본 문법과 자료형: 변수와 자료형의 모든 것

프로그래밍의 핵심은 바로 ‘변수’와 ‘자료형’! 자바를 제대로 배우고 싶다면 이 개념부터 제대로 이해해야 합니다. 처음엔 복잡하게 느껴질 수도 있지만, 하나씩 풀어가다 보면 어느새 마스터할 수 있어요.

안녕하세요! 오늘은 자바 프로그래밍의 가장 기초적이지만 가장 중요한 개념 중 하나인 변수와 자료형에 대해 알아보려 합니다. '변수 선언이 뭐야?', 'int와 double의 차이는 뭐지?' 같은 질문이 생겼다면, 이 글이 바로 정답입니다. 이 장에서는 자바의 기본 데이터 타입과 변수 선언 방법, 식별자 규칙 등 개발의 뿌리가 되는 내용들을 알기 쉽게 정리해 드릴게요. 실제 코딩할 때도 바로 적용 가능한 팁도 함께 알려드릴 테니 끝까지 함께해주세요!

1. 변수란 무엇인가요? 🤔

우리가 무언가를 기억하려면 어디엔가 적어두거나 저장해둬야 하잖아요? 컴퓨터도 마찬가지예요. 어떤 값을 저장하고, 필요할 때 꺼내 쓸 수 있도록 저장 공간이 필요한데, 바로 이 역할을 해주는 것이 변수입니다.

변수는 값을 저장할 수 있는 이름이 붙은 공간이에요. 예를 들어, 나이를 저장할 수 있는 공간을 만들고 싶다면 이렇게 쓸 수 있어요:

int age = 25;

여기서 int는 정수형 자료형을 의미하고, age는 변수 이름, 25는 변수에 저장되는 실제 값이에요.

변수의 핵심 역할 ✍️

• 데이터를 저장하는 공간 역할을 한다.
• 저장된 데이터를 나중에 참조하거나 수정할 수 있다.
• 코드의 가독성과 재사용성을 높여준다.

변수가 없다면?

모든 값을 하드코딩해야 하므로 유지보수가 거의 불가능해집니다. 예를 들어 아래 코드는 비효율적이에요:

System.out.println(25);
System.out.println(25 + 5);
System.out.println(25 * 2);

하지만 변수를 사용하면 이렇게 깔끔하게 정리할 수 있어요:

int age = 25;
System.out.println(age);
System.out.println(age + 5);
System.out.println(age * 2);

변수는 자바의 모든 것의 시작입니다! 💡

결국 변수는 데이터를 담는 가장 기본적인 도구이고, 프로그래밍의 기본기를 쌓는 데 필수적인 개념이에요. 이후에 나올 연산, 조건문, 반복문, 클래스 등 모든 문법과도 연결되니 이 개념은 꼭 확실히 짚고 넘어가야겠죠?

2. 변수 선언과 초기화 방법 ✍️

자바에서 변수를 사용하는 첫 번째 단계는 바로 선언(declaration)입니다. 변수를 선언한다는 건, 해당 값을 저장할 공간을 마련하고 이름을 붙이는 일이에요. 마치 집을 짓고 주소를 등록하는 느낌이라고 할까요? 😊

변수 선언 기본 문법

자료형 변수명;

예를 들어, 정수형 변수 score를 선언하려면 이렇게 하면 돼요:

int score;

하지만 선언만 하면 변수 안에는 아직 아무 값도 들어있지 않기 때문에 바로 사용할 수 없어요. 그래서 필요한 게 바로 초기화(initialization)입니다.

초기화란?

초기화란, 변수를 선언한 후 처음으로 값을 넣어주는 작업을 말해요. 선언과 동시에 초기화하는 것도 자주 사용하는 방법입니다:

int score = 100;

이렇게 하면 변수 score에 100이라는 값이 저장되며, 이후 이 값을 다른 코드에서 사용할 수 있습니다.

자바 변수 선언의 다양한 예 ✨

초보자가 자주 실수하는 예 ❗

• 선언만 하고 초기화하지 않아 오류 발생
• 자료형과 값이 맞지 않아 컴파일 에러 (예: int num = "10";)

이제 변수 선언과 초기화 방법이 조금 더 명확해졌나요? 다음은 변수 이름을 지을 때 꼭 알아야 할 식별자 규칙에 대해 알아볼 차례입니다!

3. 식별자 이름 규칙 알아보기 🏷️

변수나 메서드, 클래스 이름을 정할 때 우리는 식별자(Identifier)라는 이름을 사용합니다. 그런데 아무 이름이나 막 붙이면 오류가 발생할 수 있어요. 그래서 자바에서는 식별자에 대한 엄격한 규칙이 존재한답니다!

식별자 작명 규칙 정리 📋

• 영문자(A~Z, a~z), 숫자(0~9), 밑줄(_), 달러기호($)만 사용할 수 있어요.
• 숫자로 시작하면 안 돼요. (예: 2age는 오류!)
• 자바의 키워드(int, class, if 등)는 사용할 수 없어요.
• 대소문자를 구분합니다. (Age와 age는 다른 변수!)

개발자들이 자주 쓰는 네이밍 스타일은?

💡 좋은 변수 이름은 어떤 이름일까요?

좋은 식별자는 읽기 쉬우면서도 변수의 의미를 정확히 드러내야 합니다. 아래는 나쁜 예와 좋은 예를 비교한 표예요.

이제 식별자 규칙과 좋은 변수 이름의 기준을 이해하셨다면, 자바의 기본 데이터 타입에 대해 본격적으로 알아볼 시간입니다!

4. 자바의 기본 데이터 타입 정리 📦

자바에서는 데이터를 저장할 때 어떤 종류의 값인지를 정확하게 지정해야 해요. 그래야 컴퓨터가 그 값들을 정확하게 다룰 수 있거든요. 그래서 자바는 자료형(Data Type)을 엄격하게 사용합니다.

자바의 자료형은 크게 기본형(Primitive Type)과 참조형(Reference Type)으로 나눌 수 있어요. 이 장에서는 그 중 기본형을 중심으로 설명드릴게요.

기본형 데이터 타입이란?

기본형 데이터는 자바에서 가장 단순한 형태의 데이터를 의미합니다. 숫자, 문자, 논리값 등 실제 값을 저장하는 역할을 하죠. 자바에는 총 8개의 기본형 데이터 타입이 있어요.

다음 단계에서는 이 기본 타입들을 각각 자세히 분석하고, 실제 예제도 함께 살펴볼게요. 실수형과 정수형, 문자형, 논리형은 자주 헷갈리는 부분이니 꼭 정리해보세요!

5. 정수형, 실수형, 문자형, 불린형 자세히 보기 🔍

자바에서 데이터를 표현할 수 있는 네 가지 대표적인 기본형 타입은 정수형, 실수형, 문자형, 불린형이에요. 각각 어떤 특징이 있고, 어떤 상황에서 사용해야 하는지 구체적으로 알아볼게요!

① 정수형 (byte, short, int, long)

• int는 가장 자주 사용하는 정수 타입이며, 대부분의 숫자는 이걸로 처리 가능해요.
• long은 범위가 매우 넓고, 큰 숫자에는 접미사 L을 붙여야 해요.

int score = 100;
long population = 7500000000L;

② 실수형 (float, double)

소수점이 포함된 값을 표현할 때 사용하며, 자바에서는 double이 기본이에요. float을 사용할 땐 접미사 f를 꼭 붙여야 한다는 점도 기억해주세요.

float pi = 3.14f;
double avg = 85.75;

③ 문자형 (char)

char는 한 글자만 저장할 수 있는 타입이에요. 반드시 작은 따옴표 ' '로 감싸서 표현해야 해요.

char grade = 'A';
char korean = '한';

④ 불린형 (boolean)

논리적인 조건이 필요한 경우, boolean 타입을 사용합니다. 값은 오직 두 가지! true 또는 false입니다.

boolean isLogin = true;
boolean isAdult = false;

✅ 정리! 어떤 타입을 써야 할까?

• 정수 값 → int, 큰 수면 long
• 소수점 → double, 공간이 부족하면 float
• 문자 하나 → char
• 참/거짓 판단 → boolean

이제 다양한 기본 자료형들을 실제 코드에서 어떻게 선언하고 사용할 수 있는지, 다음 장에서 실습 예제로 이어서 확인해볼게요!

6. 변수와 자료형 실습 예제 💻

이제 자바에서 변수를 선언하고, 다양한 자료형을 활용하는 방법을 실전 코드로 익혀볼 차례입니다. 아래 예제들은 콘솔 출력 프로그램을 통해 각 자료형의 선언과 사용 방식을 보여주고 있어요. 직접 따라해 보면서, 변수 개념을 몸에 익혀보세요!

예제 1️⃣: 다양한 변수 선언과 출력

public class VariableExample {
    public static void main(String[] args) {
        int age = 30;
        double height = 174.5;
        char grade = 'A';
        boolean isMember = true;

        System.out.println("나이: " + age);
        System.out.println("키: " + height);
        System.out.println("등급: " + grade);
        System.out.println("회원 여부: " + isMember);
    }
}

출력 결과는 각각의 변수에 저장된 값이 그대로 출력되는 형태입니다. 각 변수의 자료형이 다름에도 불구하고 자바는 + 연산자를 사용해 문자열과 함께 출력할 수 있도록 해줍니다.

예제 2️⃣: 자료형 간 연산 및 형 변환

public class TypeCastingExample {
    public static void main(String[] args) {
        int x = 10;
        double y = 3.5;
        double result = x + y;

        System.out.println("결과: " + result);

        // 명시적 형 변환
        int intResult = (int) y;
        System.out.println("강제 변환된 값: " + intResult);
    }
}

이 예제는 정수형 int와 실수형 double이 자동으로 계산되고, 명시적으로 실수를 정수로 변환하는 모습을 보여줍니다. 중요한 건 데이터 손실이 발생할 수 있다는 점이에요!

예제 3️⃣: 문자와 아스키 코드

public class CharExample {
    public static void main(String[] args) {
        char ch = 'C';
        int ascii = ch;

        System.out.println("문자: " + ch);
        System.out.println("아스키 코드: " + ascii);
    }
}

문자형 char은 내부적으로 숫자(아스키 코드)로 표현됩니다. int ascii = ch;처럼 자동 변환을 통해 숫자로 확인할 수 있어요.

🧠 연습 문제

• 사용자 이름(String), 나이(int), 키(double), 성별(char), 회원 여부(boolean)를 변수로 선언하고 값을 초기화한 후 출력해보세요.

이렇게 실습을 통해 변수와 자료형 개념을 직접 다뤄보면, 개념이 머리에 쏙쏙 들어올 거예요! 이제 자바의 변수와 자료형에 대한 감이 확실히 잡히셨죠?

마무리 🌱

자바에서 가장 기본이자 중요한 개념인 변수와 자료형에 대해 정말 꼼꼼하게 살펴봤습니다. 변수는 프로그램 안에서 데이터를 저장하고 다루는 핵심 도구이고, 자료형은 그 데이터를 어떤 형식으로 다룰지 결정하는 기준이죠.

오늘 학습한 내용을 바탕으로 앞으로 나올 연산자, 조건문, 반복문까지도 더 쉽게 이해할 수 있을 거예요. 실습 예제도 꼭 직접 입력해보고, 잘못된 부분이 있다면 고쳐가며 복습해 보세요. 그렇게 하나하나 익숙해지는 게 중요하거든요!

다음 장에서는 다양한 연산자와 계산 방법을 통해 변수들을 어떻게 조작하는지 배워볼 거예요. 벌써부터 기대되지 않나요? 😉

1.6 실습: Hello World 프로그램 실행 – 작성한 프로그램을 컴파일하고 실행하여 동작 확인

여러분, 자바 파일 하나 만들고 실행하는 게 이렇게 재밌는 일이라는 걸 아셨나요? 처음으로 "Hello, World!"를 출력해보는 그 순간, 진짜 개발자가 된 것 같은 뿌듯함이 느껴질 거예요!

안녕하세요, 자바 입문자 여러분! 지난 시간까지는 자바 언어의 역사와 특징, 그리고 개발 도구 설치까지 차근차근 살펴봤습니다. 이제는 실제로 자바 파일을 작성하고, 컴파일하고, 실행해보는 실습 단계에 도달했어요. 직접 코드를 작성해서 출력 결과를 확인하는 이 단계는 자바의 문법과 동작 방식을 몸으로 익히는 데 큰 도움이 됩니다. 오늘은 간단한 "Hello World" 예제를 통해 컴파일과 실행 과정을 단계별로 따라가 보면서, 자바 개발의 첫걸음을 함께 내딛어보겠습니다.

1. Hello World 자바 소스 코드 살펴보기 📝

자바에서 가장 처음 만나게 되는 코드, 바로 Hello World 프로그램입니다. 이 코드는 짧지만 자바의 핵심 구조가 어떻게 구성되어 있는지 잘 보여주는 예제이기도 해요. 먼저 전체 코드를 먼저 살펴보고, 각 구성 요소를 하나씩 뜯어보겠습니다.

HelloWorld.java 예제 코드

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

이 코드에는 자바의 가장 기본적인 요소들이 모두 포함돼 있어요. 자, 이제 한 줄씩 살펴볼까요?

1️⃣ public class HelloWorld

자바는 클래스 단위로 프로그램이 구성돼요. HelloWorld라는 이름의 클래스를 선언했고, 클래스 이름은 파일 이름과 반드시 일치해야 해요. 그래서 이 파일의 이름은 HelloWorld.java여야 합니다.

2️⃣ public static void main(String[] args)

이 부분은 자바 프로그램의 시작점이에요. 자바 프로그램을 실행하면 JVM이 이 메서드부터 실행을 시작해요. 'main 메서드'라고 부르며, 반드시 다음과 같은 형식으로 작성돼야 합니다:

• public: 어디서든 호출 가능하게 함
• static: 객체를 만들지 않아도 사용 가능
• void: 반환값이 없음
• String[] args: 명령줄 인자 받기용 매개변수

3️⃣ System.out.println("Hello, World!");

이 줄은 실제로 화면에 출력을 담당하는 부분이에요. 콘솔에 "Hello, World!" 라는 문장을 출력하죠. 자바에서 표준 출력은 System.out을 통해 이루어지고, println()은 줄 바꿈을 포함해 출력해 줍니다.

이제 코드의 각 줄이 어떤 역할을 하는지 조금 감이 잡히셨나요? 😀 다음 단계에서는 이 파일을 어떻게 저장하고, 어떤 확장자를 써야 하는지 설명드릴게요.

2. 파일 저장 및 확장자 명명 규칙 📂

이제 자바 코드를 직접 작성해봤으니, 이 파일을 저장해볼 차례예요. 여기서 중요한 점은 자바 파일의 저장 이름과 클래스 이름은 반드시 동일해야 한다는 것입니다. 이 규칙을 지키지 않으면 컴파일 에러가 발생해요.

파일 저장 이름 규칙 🔤

• 클래스 이름이 HelloWorld라면 파일명은 HelloWorld.java여야 합니다.
• 자바 소스 파일의 확장자는 반드시 .java 여야 합니다.
• 대소문자를 구분하므로 정확하게 입력해야 해요!

예시 저장 과정 💾

1. 텍스트 에디터(예: VS Code, Notepad++, 이클립스 등)를 열고 코드를 붙여넣기
2. 메뉴에서 다른 이름으로 저장 선택
3. 파일 이름을 HelloWorld.java로 지정 후 저장

💡 팁: 윈도우에서는 파일 저장 시 확장자가 숨김 처리될 수 있으니, 폴더 옵션에서 “알려진 파일 형식의 파일 확장명 숨기기”를 해제해 주세요!

이제 파일 저장까지 완료했으니, 다음 단계에서는 이 파일을 컴파일해서 자바 프로그램이 어떻게 바이트코드로 바뀌는지 알아볼 거예요. 터미널을 사용할 준비 되셨죠? 😊

3. 컴파일: 자바 파일을 바이트코드로 변환하기 🔧

자바 프로그램은 소스 코드를 바로 실행하는 것이 아니라 컴파일 과정을 거쳐 바이트코드(.class 파일)로 변환된 뒤, JVM(Java Virtual Machine)이 이를 실행합니다. 자바의 대표적인 특징이죠! 이 과정을 직접 실행하면서 확인해보겠습니다.

자바 컴파일 명령어 사용 방법

파일을 컴파일하려면 명령 프롬프트(Windows)나 터미널(Mac/Linux)에서 아래 명령어를 입력하면 됩니다:

javac HelloWorld.java

📌 이 명령어는 javac(Java Compiler)를 통해 HelloWorld.java 파일을 HelloWorld.class라는 바이트코드 파일로 변환해 줍니다.

✅ 컴파일 결과 확인

• 컴파일 성공 시, 별다른 메시지 없이 HelloWorld.class 파일이 생성됩니다.
• 컴파일 에러가 발생하면 오류 메시지가 표시되고, .class 파일은 생성되지 않아요.

컴파일이 잘 되었다면 이제 실행만 남았네요! 다음 섹션에서는 우리가 만든 바이트코드를 실제로 실행해서 "Hello, World!" 메시지를 출력해 보겠습니다 😊

4. 실행: 자바 프로그램 실행 결과 확인하기 ▶️

자바 코드를 작성하고 컴파일까지 완료했다면, 이제는 실행 단계입니다. 우리가 만든 HelloWorld.class 파일을 자바 가상 머신(JVM)을 통해 실제로 실행해 볼 거예요.

자바 클래스 실행 명령어

java HelloWorld

☝ 주의: 확장자인 .class는 입력하지 않고, 클래스 이름만 입력해야 해요!

실행 결과 화면

Hello, World!

바로 이거죠! 여러분의 터미널에 Hello, World!가 출력됐다면, 첫 자바 프로그램 실행에 성공한 거예요. 🎉 진심으로 축하드립니다! 이제 여러분은 자바 개발자로서의 첫걸음을 내디딘 거랍니다.

실행 과정 요약 🔄

1. 터미널에서 해당 파일이 있는 디렉터리로 이동
2. javac HelloWorld.java로 컴파일
3. java HelloWorld로 실행

혹시 실행이 잘 안 되거나 오류 메시지가 나왔다면 괜찮아요! 다음 섹션에서는 자주 발생하는 오류와 그 해결 방법들을 하나씩 정리해 드릴게요 😊

5. 자주 발생하는 컴파일/실행 오류와 해결법 💡

Hello World 예제는 간단하지만, 처음 접하는 분들에겐 의외로 많은 오류가 발생할 수 있어요. 자바는 문법에 엄격하기 때문에, 아주 작은 실수에도 에러가 발생합니다. 아래는 가장 많이 나오는 오류들과 그 해결법이에요.

❌ 컴파일 시 자주 발생하는 오류

⚠️ 실행 시 자주 나오는 오류

• Error: Could not find or load main class HelloWorld
  → 클래스 파일이 없는 위치에서 실행하거나 .class가 존재하지 않을 경우 발생.
• Exception in thread "main"
  → main 메서드 오탈자 또는 잘못된 선언 형식 (예: static 빠짐)

에러 메시지를 무서워하지 마세요! 대부분 아주 사소한 실수에서 비롯되며, 그만큼 쉽게 고칠 수 있어요. 😊

지금까지의 과정을 통해 여러분은 단순한 텍스트 출력 이상의 경험을 하셨을 거예요. 이제 마지막으로 이번 실습을 정리하고, 다음 단계에서 어떤 걸 배울지 살짝 알려드릴게요!

6. 실습 요약과 다음 학습 연결 고리 🔗

처음으로 자바 프로그램을 직접 작성하고 실행해보는 이 경험, 어떠셨나요? 지금까지 진행한 Hello World 실습은 자바의 전체 구조와 실행 흐름을 이해하는 데 있어 매우 중요한 첫걸음이에요. 우리가 실습한 과정을 한 번 정리해볼게요.

🧾 실습 요약: Hello World 작성부터 실행까지

1. 자바 기본 구조를 이해하고 HelloWorld 클래스를 작성함
2. HelloWorld.java로 파일 저장 (클래스 이름과 일치해야 함)
3. javac HelloWorld.java 명령어로 컴파일 수행
4. java HelloWorld 명령어로 실행 후 "Hello, World!" 출력 확인
5. 오류 메시지 확인 및 해결 방법 학습

이 짧은 실습 안에 자바 문법, 클래스 구조, 컴파일러 사용법, JVM의 동작 방식까지 정말 많은 개념이 녹아 있었답니다!

💡 다음 단계 예고: 변수와 자료형

이제 "Hello, World!"만 출력하던 우리 프로그램을 한 단계 발전시켜 볼 차례예요. 다음 시간에는 변수 선언과 자료형을 배우면서 프로그램에 데이터를 다루는 방법을 익혀볼 거예요. 직접 숫자와 문자열을 입력하고 출력해보며 자바의 기본 타입과 연산에 대해 실습해볼 예정입니다.

지금까지 첫 번째 자바 실습을 멋지게 마무리하셨습니다. 👏 이제 진짜 자바의 세계로 한 걸음 더 나아가 볼 준비 되셨죠?

이번 시간에는 자바의 가장 기본이 되는 Hello World 프로그램을 직접 작성하고, 컴파일하고, 실행하는 과정을 차근차근 실습해보았어요. 처음이라 약간은 생소했을 수도 있지만, 이런 작은 성공들이 모여 큰 자신감으로 이어진다는 걸 꼭 기억해 주세요 😊

이 실습을 통해 자바의 클래스 구조, 컴파일과 실행 흐름, 오류 해결 방법 등 필수적인 기초를 하나씩 내 것으로 만들 수 있었을 거예요. 앞으로 배울 변수, 연산자, 조건문 등을 통해 훨씬 더 다양한 프로그램을 만들어보게 될 거니까 기대 많이 해주세요!

모든 개발자들의 시작은 Hello World였어요. 이제 여러분도 자바 개발자로서의 첫 발걸음을 내딛은 거랍니다 🚀

1.5 첫 번째 자바 프로그램 작성 – Hello World 예제 코드 작성 및 분석

자바를 처음 접하는 분들이 가장 먼저 작성하는 코드, 바로 Hello World입니다. 하지만 이 간단한 코드 속에도 자바의 구조와 철학이 담겨 있다는 사실, 알고 계셨나요?

안녕하세요, 여러분! 😊

이번 시간에는 자바 프로그래밍의 첫걸음을 내딛는 가장 클래식한 예제, Hello World 프로그램을 작성해보고 그 안에 담긴 의미를 하나하나 분석해 보려 합니다. 자바가 어떤 구조로 되어 있는지, 실행 흐름은 어떻게 되는지, 어떤 키워드가 반드시 필요한지 등 기초를 탄탄히 다질 수 있는 주제이니 초보자분들께 꼭 추천드리는 내용이에요. 앞으로 자바 프로그램을 작성할 때 매우 중요한 기초 개념이니 꼼꼼히 함께 살펴봐요!

1. Hello World 프로그램 작성

자바 프로그래밍을 처음 배울 때 가장 먼저 작성하게 되는 프로그램이 바로 Hello World입니다. 이 예제는 단순히 화면에 문장을 출력하는 코드지만, 자바 프로그램이 동작하기 위해 필요한 핵심 요소들을 모두 포함하고 있어요. 지금부터 한 줄 한 줄 어떤 의미를 가지는지 함께 살펴볼게요.

📝 Hello World 예제 코드

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

이제 이 코드가 어떤 구조로 되어 있고, 어떤 의미를 담고 있는지 구체적으로 분석해보겠습니다.

2. 코드 구조 한눈에 보기

• 클래스 이름은 대문자로 시작하며, 보통 명사형으로 작성합니다.
• main 메서드는 자바에서 프로그램 실행을 위한 필수 구성요소예요.
• System.out.println()은 출력용 메서드로 콘솔에 결과를 보여줄 때 사용됩니다.

3. 클래스와 메서드의 역할

자바는 객체지향 프로그래밍 언어이기 때문에 클래스와 메서드의 개념이 매우 중요해요. 모든 자바 프로그램은 클래스로 시작해서 클래스로 끝난다고 해도 과언이 아닙니다. 그 안에서 메서드는 '행동' 또는 '동작'을 정의하는 단위죠.

📦 클래스란 무엇인가요?

클래스는 객체를 생성하기 위한 설계도입니다. 자바에서 모든 코드는 클래스 안에 들어가야 하며, public class HelloWorld와 같은 형식으로 정의됩니다. 여기서 HelloWorld는 클래스 이름이자 프로그램의 시작점을 나타내는 이름입니다.

• 클래스 이름은 파일명과 반드시 일치해야 하며, 대소문자를 구분합니다.
• 하나의 자바 파일에는 하나의 public 클래스만 존재할 수 있어요.

🛠️ 메서드는 프로그램의 동작을 정의해요

main() 메서드는 자바 애플리케이션의 진입점이자 가장 먼저 실행되는 코드 블록이에요. 자바 가상 머신(JVM)은 이 메서드를 찾아 실행을 시작합니다. 아래의 구성요소를 함께 기억해두면 좋아요.

정리하자면, 클래스는 자바 프로그램의 설계도이고, 메서드는 행동의 실행 단위입니다. 이 두 가지 개념을 정확히 이해하는 것이 자바의 문법과 구조를 익히는 데 있어 가장 중요한 첫걸음이에요.

4. main 메서드란 무엇인가?

자바 애플리케이션에서 가장 먼저 실행되는 메서드는 main()입니다. main() 메서드는 자바 가상 머신(JVM)이 프로그램을 시작할 때 가장 먼저 호출하는 메서드이며, 우리가 작성한 프로그램의 실행 흐름을 시작하는 출발점이에요.

🎯 main 메서드의 형태와 규칙

public static void main(String[] args)

이 메서드는 정확히 위와 같은 형태를 따라야 자바 애플리케이션으로서 정상적으로 실행됩니다. 여기서 중요한 포인트는 다음과 같아요.

1. 메서드 이름은 반드시 main이어야 하며, 대소문자를 정확히 구분해야 합니다.
2. 접근 제어자는 public이어야 외부에서 호출할 수 있어요.
3. static 키워드는 객체를 만들지 않고 실행 가능하도록 합니다.
4. 반환형은 void로, 실행 결과를 반환하지 않습니다.
5. 매개변수 String[] args는 외부에서 전달되는 명령줄 인자들을 의미해요.

💡 main 메서드가 없는 경우는?

만약 main 메서드를 작성하지 않으면 자바 프로그램은 실행되지 않아요. 컴파일은 되더라도 실행 도중 "Main method not found in class..."와 같은 오류 메시지를 만나게 됩니다.

📌 main 메서드 관련 실수 TOP 3

• 메서드 이름을 Main처럼 대문자로 시작함 → 오류 발생
• 매개변수 형태를 String args[] 대신 다른 형태로 작성함 → 실행 불가
• static이나 public 키워드를 빠뜨림 → 컴파일되지만 실행 안 됨

결국 main 메서드는 자바 프로그램의 문을 여는 열쇠입니다. 이 문을 제대로 열기 위해서는 정확한 문법과 이해가 꼭 필요해요.

5. System.out.println()의 의미

처음 자바를 접하면 가장 자주 보게 되는 코드 중 하나가 바로 System.out.println()입니다. 단순히 문자열을 출력하는 역할을 하지만, 이 문장이 실제로 어떤 구조로 이루어졌는지 알고 있으면 자바 언어에 대한 이해도가 한층 더 깊어질 수 있어요.

🔍 구성 요소 하나씩 뜯어보기

✨ println()과 print()의 차이

• print()는 줄바꿈 없이 문자열을 출력해요.
• println()은 출력 후 자동으로 줄을 바꿔줍니다.

System.out.print("Hello");
System.out.print("World!");
// 출력 결과: HelloWorld!

System.out.println("Hello");
System.out.println("World!");
// 출력 결과: 
// Hello
// World!

이처럼 단순한 출력 명령어 하나에도 자바의 정적 클래스, 스트림, 메서드 호출 구조가 고스란히 녹아 있어요. 단순해 보여도 알고 보면 꽤 많은 개념이 숨어 있는 셈이죠!

6. 소스코드 컴파일과 실행 흐름

자바 프로그램은 단순히 파일을 저장하고 실행하는 것으로 끝나지 않아요. 컴파일과 실행이라는 두 단계를 거쳐야 실제로 동작하게 됩니다. 이 과정은 자바가 플랫폼 독립성을 유지하고 다양한 환경에서 실행될 수 있도록 해주는 핵심 기전이기도 해요.

⚙️ 자바 프로그램 실행 과정 4단계

1. ① 작성 (Writing): 자바 소스 파일(.java) 생성
2. ② 컴파일 (Compile): javac HelloWorld.java 명령으로 바이트코드(.class) 생성
3. ③ 실행 (Run): java HelloWorld 명령으로 JVM이 클래스 실행
4. ④ 출력 (Output): 콘솔에 Hello, World! 메시지 출력

🖥️ 터미널 명령어 예시

javac HelloWorld.java
java HelloWorld

컴파일을 하면 HelloWorld.class라는 바이트코드 파일이 생성되며, JVM은 이 파일을 읽어 실행하게 됩니다.

🚀 JVM은 어떻게 실행할까요?

• JVM은 OS에 독립적인 가상 머신으로, 바이트코드를 해석하고 실행합니다.
• 덕분에 동일한 자바 코드를 윈도우, 리눅스, 맥OS 등 다양한 환경에서 동일하게 실행할 수 있어요.

이처럼 자바는 한 번 작성하고 어디서든 실행할 수 있는 진정한 플랫폼 독립 언어예요. Hello World 한 줄로도 자바의 이 철학을 충분히 느낄 수 있답니다!

마무리하며: 첫 Hello World에 담긴 의미

Hello World 프로그램은 단순히 화면에 문장을 출력하는 코드가 아닙니다. 그 안에는 자바 언어의 기본 구조와 JVM의 실행 원리, 그리고 객체지향 프로그래밍의 철학까지 녹아 있습니다. 처음 이 코드를 작성하는 순간부터 우리는 자바 프로그래머로서 첫 발을 내디딘 것이죠.

처음에는 모든 것이 낯설고 어렵게 느껴질 수 있어요. 하지만 하나하나 코드를 뜯어보고, 왜 그렇게 작성되는지를 이해하려는 자세만 있다면 어느 순간 자바가 익숙하고 재밌게 다가올 거예요. Hello World는 끝이 아니라 시작입니다. 자바의 세상에 온 걸 환영해요! 🎉

1.4 프로젝트 구조와 컴파일: 소스 작성부터 실행까지 한눈에 보기

Java 프로젝트를 시작하려는데 어디서부터 손대야 할지 막막하신가요? 이 글 하나면, 자바 파일을 만들고 컴파일해서 실행하는 전 과정을 단숨에 이해할 수 있어요!

안녕하세요, 자바 입문자 여러분! 😊 자바라는 언어는 구조적으로 탄탄하고 배우기 좋은 언어지만, 막상 개발을 시작하려고 보면 처음부터 헷갈리는 게 한두 가지가 아니죠. 특히 소스 코드를 어디에 저장하고, 어떻게 컴파일하고, 또 실행은 어떻게 하는지 같은 기본적인 흐름이 제대로 정리되어 있지 않으면 시작부터 멘붕 오기 딱 좋아요. 이번 글에서는 자바 프로젝트의 기본 구조와 컴파일부터 실행까지의 전체 과정을 아주 쉽게, 그리고 실습 가능한 예제 중심으로 정리해드릴게요. 그럼, 천천히 따라오시죠!

1. 기본 프로젝트 디렉터리 구조 이해하기 📁

자바를 처음 시작하면, "도대체 자바 프로젝트를 어디에 어떻게 구성해야 하지?"라는 고민부터 생기기 마련이에요. 사실 자바는 아주 단순한 구조로도 실행이 가능한 언어지만, 나중에 확장성과 관리까지 고려하면 어느 정도 구조화된 형태가 필요하죠.

💡 자바 기본 디렉터리 구조 예시

이 구조는 매우 기본적인 형태로, IDE 없이 직접 컴파일/실행할 때도 적합해요. 이후에 Maven, Gradle 같은 빌드 도구를 쓰게 되면 구조가 더 복잡해지지만, 지금은 단순한 것이 좋아요.

• src/ 폴더 안에 클래스별로 파일을 나누어 작성
• 컴파일 후 결과물은 bin/ 폴더에 자동으로 생성
• 폴더 명은 자유롭게 설정 가능하나 관례를 따르는 것이 좋음

정리하자면, src → bin으로 이어지는 단순한 구조만 기억하면, 자바의 세계에 한발 더 들어갈 준비가 된 거예요! 그럼 다음 섹션에서는, 이 안에 들어갈 소스 파일이 어떤 구성인지 알아볼까요?

2. 자바 소스 파일(.java)의 구성 요소 🔤

자바 파일을 하나 열어보면 "public class ~"부터 시작해서, main이라는 단어가 보이고, 중괄호가 잔뜩 있어요. 이걸 처음 보면 “이게 대체 뭔데요?”라는 생각부터 들죠. 그래서 자바 파일의 구조를 이해하는 게 아주 중요해요!

🧩 자바 클래스 파일 기본 구조

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

이제 각 요소를 하나씩 분해해서 설명해볼게요. 너무 어렵지 않게요 😉

🔍 주의할 점

• 클래스 이름과 파일 이름은 반드시 동일해야 해요 (예: HelloWorld.java)
• 대소문자를 구분하므로 정확히 입력해야 해요!

이제 이 구조만 이해해도 기본적인 자바 파일은 직접 작성해볼 수 있어요. 다음 단계에서는, 이 소스 파일을 컴파일해서 실행 가능한 형태로 만드는 과정을 설명해볼게요!

3. 컴파일: 자바 소스를 바이트코드로 변환하기 ⚙️

우리가 작성한 .java 파일은 바로 실행할 수 없어요. 자바에서는 먼저 이 소스 코드를 컴파일해서 .class라는 형태로 바꿔줘야 하죠. 이게 바로 바이트코드예요! 컴파일은 이 작업을 자동으로 해주는 과정입니다.

🔧 자바 컴파일 명령어 예시

javac -d bin src/HelloWorld.java

이 명령은 src 폴더에 있는 자바 파일을 컴파일해서 bin 폴더에 .class 파일로 저장하라는 의미예요.

📌 컴파일 성공 시 구조

• src/HelloWorld.java → bin/HelloWorld.class로 생성됨
• .class 파일은 JVM에서 읽을 수 있는 중간 코드 (기계어 아님!)

컴파일 과정이 익숙해지면, 여러 개의 파일도 한꺼번에 컴파일할 수 있고, 자동화 도구나 IDE에서도 손쉽게 할 수 있어요. 하지만 처음엔 꼭 명령어 기반으로 연습해보세요! 자바의 구조와 흐름을 몸으로 익힐 수 있거든요. 😊

4. 실행: JVM으로 클래스 파일 실행하기 🚀

컴파일이 끝나면 .class 파일이 생기죠. 이제 이걸 실행하면 프로그램이 동작하게 돼요. 자바 프로그램은 JVM(Java Virtual Machine)이라는 가상 머신 위에서 실행됩니다. 즉, JVM이 자바 바이트코드를 읽고 해석해서 실제 운영체제에서 동작하게 만들어줘요.

🎯 자바 실행 명령어 예시

java -cp bin HelloWorld

이 명령어는 bin 폴더에 있는 HelloWorld.class 파일을 실행해달라는 의미예요. java 명령어는 JVM을 호출하는 거고, -cp는 클래스 경로(classpath)를 지정해주는 옵션이에요.

🚨 주의할 점

• 클래스 경로에 해당 클래스가 정확히 포함되어야 실행이 돼요.
• 클래스 이름만 쓰고 .class 확장자는 쓰면 안 돼요!

실행에 성공하면 여러분은 콘솔에서 Hello, World! 메시지를 볼 수 있어요! 그럼 이제 다음 단계에서는 이 모든 과정을 터미널에서 직접 실습해보는 흐름을 정리해드릴게요. 직접 손으로 해보는 게 제일 빨리 느는 법이니까요. 🧑‍💻

5. 터미널을 이용한 프로젝트 실습 예제 👨‍💻

이제 진짜 자바를 실습해볼 시간이에요! 여기서 알려드리는 예제를 따라 하면, Java 설치 → 코드 작성 → 컴파일 → 실행까지 한 번에 정리할 수 있어요. 터미널만 있으면 끝! ✨

🧪 1단계: 폴더 및 파일 생성

mkdir -p myjava/src myjava/bin
cd myjava/src
nano HelloWorld.java

코드를 입력할 때는 아래 내용을 붙여넣으세요.

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("자바 실습 성공!");
    }
}

⚙️ 2단계: 컴파일

cd ..
javac -d bin src/HelloWorld.java

🚀 3단계: 실행

java -cp bin HelloWorld

터미널에 아래처럼 출력되면 성공입니다! 🎉

자바 실습 성공!

✅ 실습 팁

• 윈도우에서는 cmd 대신 PowerShell 또는 Git Bash를 사용해도 좋아요.
• 에러가 났을 땐 파일 이름, 경로, 클래스명 대소문자 확인!

이렇게 직접 실습해보면서 자바의 흐름을 몸에 익히는 게 정말 중요해요. 다음 단계에서는 흔히 발생하는 컴파일 또는 실행 오류와 해결 방법도 알려드릴게요!

6. 컴파일/실행 오류 상황과 해결 방법 ❗

자바 처음 시작할 때 가장 당황스러운 순간은 에러 메시지예요. 😵 “분명히 똑같이 했는데 왜 안 되지?” 싶은 순간, 꼭 있죠. 그런데 대부분의 에러는 파일 이름, 클래스명, 경로 문제로 발생해요. 자주 발생하는 실수와 해결 방법을 모아봤어요.

🚫 자주 발생하는 컴파일 오류

💥 자주 발생하는 실행 오류

• Error: Could not find or load main class HelloWorld → 클래스 경로가 잘못되었거나 -cp 옵션 누락
• java.lang.NoClassDefFoundError → 클래스 경로가 빌드 시와 실행 시 다름
• Exception in thread "main" → main 메서드가 잘못되었거나 오타가 있음

🛠 에러 해결 체크리스트

1. 클래스명과 파일명이 같은지 확인
2. main 메서드가 정확한지 확인
3. 컴파일 시 javac, 실행 시 java 사용 구분
4. 클래스 경로 지정 -cp 사용 여부 확인
5. 터미널 위치(폴더 경로)가 맞는지 다시 체크

에러는 처음엔 무서워도, 하나하나 해결해 나가다 보면 어느새 친숙한 친구가 돼요. 정말이에요. 😉 앞으로 실습을 하다가 비슷한 에러가 나면 이 글을 다시 열어보세요!

마무리하며 ✨

자바 프로젝트의 구조부터 컴파일, 실행 과정까지 직접 따라 해보셨나요? 처음에는 복잡하게 느껴질 수 있지만, 단계를 하나하나 밟아보면 자바가 얼마나 체계적이고 명확한 언어인지 느끼게 됩니다. 소스 코드를 작성하고, 컴파일하고, JVM으로 실행하는 이 일련의 과정은 앞으로 여러분이 만나게 될 수많은 프로젝트의 기본이 될 거예요.

이 글이 자바 학습의 첫걸음을 좀 더 쉽고 친절하게 만들어주는 데 도움이 되었기를 바라며, 앞으로 이어질 내용들에서도 실습 중심의 설명을 이어갈게요. 우리 함께 끝까지 자바 마스터, 도전해봐요! 💪