반응형

3.5 실습: 흐름 제어 프로그램 작성 – 조건문과 반복문을 활용한 구구단 출력과 숫자 합계 계산

조건문과 반복문만 제대로 활용해도 복잡한 문제를 간단하게 해결할 수 있다는 사실, 알고 계셨나요? 구구단 출력, 숫자 누적 합계 등 실생활에서도 바로 쓸 수 있는 예제를 직접 만들어 보며 흐름 제어의 진짜 힘을 느껴보세요!

반응형

안녕하세요, 여러분! 오늘은 파이썬 초보자라면 반드시 한 번쯤 실습해봐야 할 조건문과 반복문 실습을 주제로 다뤄보려 합니다. 이번 주제는 단순히 문법을 익히는 수준이 아닌, 직접 코드를 작성하며 ‘흐름 제어’가 어떻게 동작하는지를 체감할 수 있도록 구성했어요. 예를 들어 구구단을 출력하거나, 사용자가 입력한 숫자들의 합계를 계산하는 등의 실습을 통해 조건과 반복의 개념이 머릿속에 자연스럽게 스며들도록 도와드립니다. 이런 간단한 예제들이 코딩 실력을 한 단계 업그레이드 시켜줄 중요한 디딤돌이 될 거예요!

1. 조건문이란? 🤔

프로그래밍에서 가장 기본이 되면서도 중요한 것이 바로 조건문입니다. 우리 일상에서 "만약 비가 오면 우산을 챙긴다"와 같은 조건적 행동은 매우 자연스럽죠? 마찬가지로, 프로그램도 특정 조건이 참일 때만 어떤 일을 하게 만들 수 있습니다.

파이썬에서는 조건문을 if, elif, else 키워드를 사용해서 구현합니다. 조건에 따라 프로그램의 흐름이 달라지기 때문에, 프로그램의 '두뇌' 같은 역할을 한다고 볼 수 있어요.

조건문 기본 구조

score = 85

if score >= 90:
    print("A학점")
elif score >= 80:
    print("B학점")
else:
    print("C학점 이하")

위 코드는 점수를 기준으로 A, B, C학점을 출력하는 예제입니다. 조건을 위에서부터 순차적으로 검사하면서 가장 먼저 맞는 조건에 도달하면 해당 블록의 코드가 실행되죠.

조건문 활용 팁 💡

  • 조건은 True 혹은 False로 평가됩니다.
  • elif는 조건이 여러 개인 경우 유용하게 쓰입니다.
  • else는 위의 모든 조건이 거짓일 때 실행됩니다.

실습 아이디어 ✨

  1. 입력받은 숫자가 짝수인지 홀수인지 판별하기
  2. 나이에 따라 유아/청소년/성인 분류하기
  3. 점수에 따라 다른 문장을 출력하는 학점 출력기 만들기

조건문은 복잡한 흐름을 분기 처리하는 데 매우 중요한 역할을 합니다. 다음 섹션에서는 반복문을 통해 반복적인 작업을 어떻게 자동화할 수 있는지를 배워볼 거예요.

2. 반복문의 기초와 구조 🔁

조건문이 '선택'의 역할을 한다면, 반복문은 '반복'을 담당합니다. 동일한 작업을 여러 번 수행해야 할 때 반복문을 사용하면 코드가 훨씬 깔끔하고 효율적이 되죠.

파이썬에서는 주로 for문과 while문을 사용해 반복을 구현합니다. for문은 정해진 횟수만큼 반복할 때, while문은 조건이 참인 동안 반복할 때 적합해요.

반복문 구조 예제

for i in range(5):
    print("안녕하세요", i+1, "번째 인사입니다.")

range(5)는 0부터 4까지 총 5번 반복합니다. 즉, "안녕하세요" 문장이 5번 출력되는 거죠. 숫자를 1부터 시작하고 싶다면 i+1처럼 표현하면 됩니다.

while문 예시 👇

count = 0
while count < 3:
    print("반복 중입니다!", count)
    count += 1
  • while문은 조건을 먼저 평가하고, 조건이 참이면 블록을 실행합니다.
  • 조건이 거짓이 되면 반복을 멈추므로, count += 1과 같은 종료 조건을 꼭 명시해야 해요!

반복문 사용 팁 💬

  1. 무한 루프 방지를 위해 종료 조건을 꼭 확인하세요.
  2. 중첩 반복문은 성능 저하의 원인이 될 수 있어요.
  3. 리스트, 문자열 등 순회 가능한 객체(iterable)와 자주 함께 사용됩니다.

이제 조건문과 반복문 모두 기초를 익혔다면, 다음 단계에서는 직접 구구단을 출력하는 프로그램을 만들어보며 두 개념을 동시에 실습해 볼 거예요!

3. 구구단 출력 프로그램 만들기 📊

자, 이제 본격적인 실습에 들어갑니다! 우리가 배운 조건문반복문을 이용해서 구구단을 출력해 볼 거예요. 이 실습은 반복문을 익히는 데 아주 좋은 훈련이고, 콘솔 출력에 익숙해지는 데도 도움이 돼요.

기본 구구단 출력 코드

for dan in range(2, 10):
    print(f"--- {dan}단 ---")
    for i in range(1, 10):
        print(f"{dan} x {i} = {dan * i}")
    print()

이 코드는 2단부터 9단까지 출력하는 구구단 전체 출력기입니다. for문이 2중으로 사용되어 외부 반복은 단(dan), 내부 반복은 곱해지는 수(i)를 담당합니다.

사용자 입력 기반 구구단 출력 🎯

이번에는 사용자가 원하는 단만 출력하도록 프로그램을 수정해봅시다. 조건문을 활용해서 입력값을 검증하는 것도 함께 연습할 수 있어요.

dan = int(input("출력할 단을 입력하세요 (2~9): "))

if 2 <= dan <= 9:
    for i in range(1, 10):
        print(f"{dan} x {i} = {dan * i}")
else:
    print("2부터 9 사이의 숫자만 입력해주세요.")
  • 조건문을 통해 입력값의 유효성을 검증할 수 있습니다.
  • 반복문을 통해 한 단의 구구단을 출력합니다.

실습 확장 아이디어 ✨

  1. 짝수 단만 출력해보기 (조건문과 continue 활용)
  2. 거꾸로 출력하기 (range의 step 활용)
  3. 가로로 정렬된 구구단 출력에 도전하기 (문자열 포매팅 응용)

이번 실습을 통해 반복 구조와 조건 제어가 프로그램의 흐름을 얼마나 잘 조절할 수 있는지를 실감하셨을 거예요. 다음은 숫자 누적 합계를 계산하는 프로그램으로 실력을 더 키워볼 차례입니다!

4. 사용자 입력 기반 합계 계산 프로그램 🧮

이번에는 반복문과 조건문을 함께 활용해서 사용자가 입력한 숫자들의 합계를 구하는 프로그램을 만들어볼 거예요. 단순하지만 매우 실용적이고, 반복 처리와 조건 판단 능력을 동시에 테스트할 수 있는 좋은 예제입니다!

기본 합계 계산 코드

total = 0

for i in range(5):
    num = int(input(f"{i+1}번째 숫자를 입력하세요: "))
    total += num

print("입력한 숫자의 총합은:", total)

이 코드는 사용자가 숫자 5개를 입력하면 그 합계를 출력하는 방식이에요. 누적 변수 total을 활용해서 반복할 때마다 입력된 숫자를 더합니다.

입력 조건을 추가해보자 🎯

이제 입력값이 음수일 경우에는 더하지 않도록 조건을 걸어보는 것도 좋은 연습입니다.

total = 0

for i in range(5):
    num = int(input(f"{i+1}번째 숫자를 입력하세요: "))
    if num < 0:
        print("음수는 더하지 않습니다.")
        continue
    total += num

print("양수만 더한 총합은:", total)
  • continue문은 해당 반복을 건너뛰게 만듭니다.
  • 조건문으로 음수를 걸러내고, 반복문으로 누적 계산하는 구조입니다.

실전 확장 아이디어 💡

  1. 사용자가 0을 입력하면 조기 종료하기 (break 사용)
  2. 입력받는 숫자의 개수를 사용자에게 먼저 받도록 하기
  3. 입력된 수 중 가장 큰 수 또는 평균값 계산하기

여기까지 따라오셨다면 반복문과 조건문을 활용한 프로그램 작성에 대한 감이 확실히 잡히셨을 거예요! 다음은 실습 중 가장 많이 하는 실수와, 이를 피하기 위한 팁들을 정리해드릴게요.

5. 실습 팁과 자주 하는 실수 💡

조건문과 반복문을 사용한 실습을 진행하다 보면, 누구나 한 번쯤 겪는 실수가 있어요. 이런 실수는 전혀 부끄러운 게 아닙니다! 오히려 그걸 알아차리고 고치는 과정에서 실력이 늘어요. 그래서 이번 장에서는 자주 발생하는 실수와 꿀팁들을 정리해볼게요.

자주 하는 실수 리스트 🧨

  • IndentationError : 들여쓰기를 잘못하면 실행조차 안 돼요. 파이썬은 들여쓰기가 ‘문법’입니다.
  • 반복문 안에 input()을 잘못 넣어서 무한 입력에 빠지는 경우
  • 조건을 잘못 써서 조건문이 항상 True 또는 False가 되는 경우

실습 꿀팁 모음 🧠

  1. 한 줄씩 출력해보고 출력 순서를 꼭 확인하세요.
  2. print()를 활용해 변수의 중간값을 자주 체크해보세요. 디버깅의 핵심이에요.
  3. range()의 시작값, 끝값, step을 헷갈리지 않도록 조심하세요.

range() 이해도 테스트!

for i in range(10, 0, -2):
    print(i)

이 코드는 10부터 1까지 2씩 감소하면서 출력돼요. range()의 인자가 3개일 때는 시작, 종료, 증가값을 지정하는 겁니다.

이제 조건문과 반복문을 섞어서 활용하는 실전 예제로 넘어가 볼까요? 다음 섹션에서는 지금까지 배운 개념들을 종합해서 직접 작성해보는 흐름 제어 프로그램을 구성해봅니다. 기대되시죠? 😊

6. 실전 예제로 배우는 흐름 제어 요령 🚀

지금까지 조건문과 반복문의 개념을 이해하고, 구구단과 합계 계산 실습도 해봤죠? 이제는 실전에서 자주 쓰이는 흐름 제어 프로그램을 직접 구성해보는 시간입니다. 아래 예제는 조건문과 반복문을 자연스럽게 엮어 활용하는 연습이에요.

예제: 사용자 점수 입력받아 통계 내기 📊

사용자가 점수를 여러 개 입력하면, 프로그램은 입력값 중 평균, 최대, 최소값을 계산합니다. 입력 중 0을 입력하면 종료하도록 조건 제어도 넣어보죠.

scores = []

while True:
    num = int(input("점수를 입력하세요 (종료는 0): "))
    if num == 0:
        break
    if num < 0 or num > 100:
        print("0~100 사이의 점수만 입력하세요.")
        continue
    scores.append(num)

if scores:
    print("입력한 점수 개수:", len(scores))
    print("평균 점수:", sum(scores) / len(scores))
    print("최고 점수:", max(scores))
    print("최저 점수:", min(scores))
else:
    print("입력된 점수가 없습니다.")

여기서는 while True를 사용해 무한 입력을 받고, break로 탈출 조건을 걸었습니다. 또한 continue를 이용해 유효하지 않은 점수는 패스하고, append()로 리스트에 유효 점수를 누적해요.

이 예제로 확인하는 흐름 제어 핵심

  • 조건문: 유효성 검증, 종료 여부 판단
  • 반복문: 사용자 입력 반복 처리
  • 리스트 활용: 입력값 저장과 통계 처리

도전 과제 ✍️

  1. 짝수 점수만 평균 내기
  2. 90점 이상은 ‘우수’, 60점 미만은 ‘미달’로 분류해서 출력
  3. 점수 범위를 그래프로 그릴 수 있는 추가 기능 고민하기

실전 예제를 통해 조건문과 반복문, 그리고 리스트 활용까지 모두 섭렵했어요! 다음 단계에서는 이 흐름 제어 개념을 실생활 문제에 어떻게 적용할 수 있는지 마무리 정리해드릴게요.

마무리 🎯 지금이 바로 흐름 제어에 도전할 때!

지금까지 조건문과 반복문을 활용한 실습 예제를 통해 프로그래밍의 흐름을 제어하는 핵심 개념들을 하나씩 짚어봤습니다. 구구단 출력부터 사용자 입력 기반의 합계 계산, 그리고 평균·최댓값·최솟값을 구하는 프로그램까지! 우리가 배운 코드는 단순히 결과를 출력하는 데 그치지 않고, 실제 문제 해결에 바로 활용할 수 있는 훌륭한 도구가 됩니다.

 

"조건을 어떻게 나누느냐, 반복을 어떻게 설정하느냐에 따라 프로그램의 성격이 완전히 달라진다"

 

는 말, 실감하셨죠?😊 앞으로 더 복잡한 로직을 작성할 때도 이 기본 원리를 바탕으로 확장해나가면 됩니다.

자, 이제는 여러분 차례입니다. 오늘 배운 내용을 가지고 직접 새로운 실습 문제를 만들어 보세요! 아래는 추천 실습 키워드입니다.

  • 숫자 맞추기 게임 (랜덤 숫자와 비교)
  • 점수에 따라 등급 출력 프로그램
  • 반복문으로 특정 패턴 출력 (삼각형, 피라미드 등)

배우고 끝내지 말고, 실습으로 체화하세요. 이제 여러분은 흐름 제어의 세계를 이해한 입문자가 아닌, 직접 제어할 수 있는 초보 프로그래머입니다. 다음 장에서는 반복문과 조건문의 조합을 한 단계 더 끌어올리는 ‘함수’ 개념으로 이어갈 준비를 해볼게요.

 

반응형
반응형

3.3 반복 제어 키워드 – break와 continue를 사용한 반복문 제어, 반복문의 라벨(label) 활용

여러분은 반복문 안에서 원하지 않는 흐름을 우아하게 빠져나오는 방법을 알고 계신가요? 자바에서는 단 한 줄의 키워드로 루프를 꺼내거나 건너뛸 수 있습니다.

반응형

안녕하세요! 자바 기초 문법을 차근차근 함께 배우고 있는 여러분 반갑습니다 😊 오늘은 반복문을 더욱 유연하게 제어할 수 있는 핵심 키워드 breakcontinue에 대해 알아보려고 해요. 이 두 키워드는 반복문에서 특정 조건에 따라 루프를 빠져나오거나 다음 반복으로 건너뛰고 싶을 때 아주 유용하게 사용됩니다. 특히 자바는 라벨(label)을 이용해 중첩 반복문까지도 깔끔하게 제어할 수 있답니다. 자, 지금부터 코딩 실전에서 자주 마주치게 될 이 키워드들을 어떻게 쓰는지 차근차근 알아볼게요!

1. break 키워드 – 반복문 즉시 종료 🚪

break 키워드는 반복문을 즉시 종료할 때 사용되는 제어 키워드입니다. 일반적으로 조건에 따라 더 이상 반복이 필요 없다고 판단될 때 유용하게 사용되며, 반복문 안에 있는 어떤 위치에서든 실행되면 반복문을 빠져나오게 됩니다.

📋 기본 문법 구조

for (int i = 1; i <= 10; i++) {
    if (i == 5) {
        break;  // i가 5일 때 반복 종료
    }
    System.out.println("i = " + i);
}

위 예제에서 i == 5인 경우 break가 실행되며, 반복문은 그 즉시 종료됩니다. 결과적으로 1부터 4까지만 출력되고 끝나게 되죠.

💡 사용 시 유의할 점

  • break는 가장 가까운 반복문 하나만 종료합니다.
  • 중첩 반복문에서는 원하는 반복문만 종료하려면 라벨(label)을 사용해야 합니다.

🧾 break 키워드 특징 요약

항목 설명
종료 범위 가장 가까운 하나의 반복문만 종료
위치 반복문 내부 어디든 위치 가능
대표 활용 무한 루프 탈출, 조건 충족 시 조기 종료

2. continue 키워드 – 다음 반복으로 건너뛰기 ⏭️

continue 키워드는 반복문의 현재 반복을 중단하고 다음 반복으로 건너뛰도록 합니다. 반복문 내부에서 특정 조건에 해당할 경우, 나머지 코드를 건너뛰고 루프의 조건 검사 또는 증감식으로 이동합니다.

📋 continue 기본 구조

for (int i = 1; i <= 5; i++) {
    if (i == 3) {
        continue;  // i가 3일 때 아래 코드를 건너뜀
    }
    System.out.println("i = " + i);
}

위 코드에서는 i = 3일 때 continue가 실행되어 System.out.println() 부분이 무시되고, i = 1, 2, 4, 5만 출력됩니다.

✅ 언제 사용할까요?

  • 특정 조건일 때만 코드를 건너뛰고 반복을 계속하고 싶을 때
  • 홀수/짝수 걸러내기, 음수 무시하기 등 필터링 상황에 유용

🧾 continue 키워드 특징 요약

항목 설명
제어 흐름 현재 반복을 중단하고 다음 반복으로 이동
위치 반복문 내부에서 조건문 안에 주로 위치
활용 예시 조건 필터링, 예외 상황 건너뛰기

3. 중첩 반복문에서 break 사용 시 주의점 🌀

중첩 반복문에서 break를 사용할 경우 가장 안쪽에 있는 반복문만 종료됩니다. 실수로 원하는 반복문이 아닌 내부 반복문만 종료되는 경우가 많기 때문에 주의가 필요합니다.

🔁 예제: 중첩 반복문에서의 break

for (int i = 1; i <= 3; i++) {
    for (int j = 1; j <= 3; j++) {
        if (j == 2) {
            break;  // 이 break는 안쪽 for문만 종료
        }
        System.out.println("i = " + i + ", j = " + j);
    }
}

위 코드에서는 j == 2일 때 내부 반복문만 종료되므로, j = 2 이상이 출력되지 않습니다. 하지만 외부 반복문은 계속 진행되기 때문에 i는 계속 증가하죠.

❗ 실수 주의 포인트

  • 외부 반복문까지 종료하고 싶을 경우 라벨(label)을 사용해야 합니다.
  • break가 어떤 반복문에 적용되는지 항상 구조를 파악하고 작성하세요.

🧾 중첩 break 동작 정리

상황 break 동작
중첩 반복문 내부에서 break 사용 가장 안쪽 반복문만 종료
외부 반복문까지 종료하고 싶을 때 라벨을 붙여서 break 사용

4. 라벨을 활용한 break – 바깥 반복문 종료하기 🎯

자바에서는 라벨(label)을 사용해 특정 반복문을 지정하고 breakcontinue를 통해 원하는 반복문에 직접 적용할 수 있습니다. 특히 중첩 반복문에서 바깥 루프를 종료할 때 유용하게 쓰입니다.

📋 라벨 break 기본 예제

outerLoop:
for (int i = 1; i <= 3; i++) {
    for (int j = 1; j <= 3; j++) {
        if (j == 2) {
            break outerLoop;  // 바깥 반복문까지 종료
        }
        System.out.println("i = " + i + ", j = " + j);
    }
}

위 코드에서 break outerLoopouterLoop라는 이름이 붙은 바깥 for문까지 종료시킵니다. 따라서 i = 1, j = 1까지만 출력되고 모든 반복이 멈추게 됩니다.

🛑 라벨 break의 핵심 사용처

  • 중첩 반복문에서 외부 루프까지 종료하고 싶을 때
  • 특정 조건에 따라 복잡한 흐름을 명확히 정리하고 싶을 때

📌 라벨 break 요약 표

항목 내용
라벨 선언 위치 반복문 앞에 작성 (예: outerLoop:)
라벨 지정 방식 break 다음에 라벨 이름 작성
대표 사용 예시 중첩 반복문에서 외부 루프 종료

5. 라벨을 활용한 continue – 바깥 반복으로 이동하기 🔁

continue라벨(label)과 함께 사용할 수 있습니다. 이는 특정 반복문을 기준으로 다음 반복으로 건너뛰고 싶을 때 유용합니다. 중첩 반복문 내에서 조건이 맞을 경우 바깥 반복문으로 제어를 옮기고자 할 때 자주 사용되죠.

📋 라벨 continue 예제

outerLoop:
for (int i = 1; i <= 3; i++) {
    for (int j = 1; j <= 3; j++) {
        if (j == 2) {
            continue outerLoop;  // 바깥 반복문의 다음 반복으로 이동
        }
        System.out.println("i = " + i + ", j = " + j);
    }
}

이 코드는 j가 2일 때 outerLoop로 라벨이 붙은 반복문의 다음 반복으로 바로 이동합니다. 결과적으로 i = 1, j = 1만 출력되고, j = 2부터는 안쪽 루프는 무시되고 외부 루프로 넘어가죠.

🚀 라벨 continue의 장점

  • 특정 조건에 따라 바깥 반복으로 점프 가능
  • 복잡한 조건 분기에서 제어 흐름 간결화에 효과적

📌 라벨 continue 요약 정리

항목 내용
적용 대상 지정된 라벨의 반복문
실행 동작 해당 반복문의 다음 반복으로 건너뜀
활용 예시 중첩 루프에서 조건 필터링 시 유용

6. 요약 및 실습 예제 정리 🧠✍️

이번 섹션에서는 반복문의 흐름을 능동적으로 제어할 수 있게 해주는 breakcontinue 키워드, 그리고 이를 한 단계 확장해주는 라벨(label) 문법에 대해 배웠습니다. 단순 반복문은 물론이고, 중첩된 구조 속에서도 명확하게 흐름을 제어할 수 있게 되어 더욱 견고한 코드를 작성할 수 있게 되었죠!

🧾 전체 키워드 요약표

키워드 설명 사용 위치
break 현재 반복문을 즉시 종료 반복문 내부
continue 현재 반복을 중단하고 다음 반복으로 이동 반복문 내부
라벨 + break 특정 라벨이 붙은 반복문을 종료 중첩 반복문
라벨 + continue 지정된 반복문의 다음 반복으로 이동 중첩 반복문

💻 실습 예제: break, continue, label 총정리

public class LoopControlTest {
    public static void main(String[] args) {
        outer:
        for (int i = 1; i <= 3; i++) {
            for (int j = 1; j <= 3; j++) {
                if (i == 2 && j == 2) {
                    break outer;  // 외부 반복문까지 종료
                }
                if (j == 3) {
                    continue;     // 안쪽 반복문에서 건너뛰기
                }
                System.out.println("i = " + i + ", j = " + j);
            }
        }
    }
}

이 예제를 직접 실행해보면서 break와 continue, 라벨이 어떻게 상호작용하는지를 느껴보세요. 각각의 키워드가 반복문 흐름에 미치는 영향을 체감하며 코드를 이해하면, 복잡한 로직도 쉽게 정리할 수 있게 됩니다.

실전에서는 코드 가독성과 논리 흐름을 명확하게 하기 위해 불필요한 라벨 사용을 줄이고, 필요한 경우에만 사용하는 습관도 꼭 함께 들이세요!

마무리 및 다음 단계 안내 🌱

자바의 반복문은 단순히 루프를 도는 것에 그치지 않고, breakcontinue 같은 제어 키워드를 통해 원하는 흐름으로 제어할 수 있다는 점에서 매우 강력한 기능을 제공합니다. 특히 라벨(label)을 활용하면 중첩 루프 안에서도 유연하게 바깥 흐름을 바꿀 수 있어, 복잡한 조건 처리가 깔끔해지죠.

오늘 학습한 내용은 실무에서도 아주 자주 등장합니다. 예를 들어 사용자 입력이 특정 조건을 만족할 때 루프를 종료하거나, 유효하지 않은 값은 건너뛰는 필터링 처리를 할 때도 이러한 키워드를 효과적으로 사용할 수 있습니다. 앞으로 더 복잡한 알고리즘을 구현할 때 이 구조들을 적극적으로 활용해보세요.

다음 장에서는 반복문을 이용한 실전 문제 해결에 도전해보며, 우리가 지금까지 배운 반복문의 흐름 제어 문법을 직접 활용해볼 거예요. 준비되셨죠? 😄

반응형
반응형

3.2 반복문 기초 – for 루프와 while/do-while 루프 구조 및 동작 원리

복잡한 조건문보다 반복문이 더 헷갈리셨던 적 있으신가요? 반복문의 구조와 흐름을 제대로 이해하면, 코딩의 50%는 이미 마스터한 셈입니다!

반응형

안녕하세요, 자바를 처음 시작한 여러분을 위한 필수 기초 강의, 오늘은 흐름 제어에서 아주 중요한 개념인 반복문에 대해 배워볼 시간입니다. 반복문은 일정한 조건을 기준으로 코드를 반복 실행하는 구조로, 실무에서도 거의 모든 로직에 들어간다고 해도 과언이 아니에요. 자바에서는 for, while, do-while 세 가지 반복문이 기본인데요, 각각의 구조와 동작 원리를 예제와 함께 천천히 익혀볼게요. 반복문을 이해하면 단순한 계산부터 복잡한 데이터 처리까지 다양한 문제를 효율적으로 해결할 수 있답니다!

1. for 루프 구조 이해하기 ✍️

for 반복문은 자바에서 가장 기본적이고 널리 사용되는 반복문 중 하나입니다. "정해진 횟수만큼 무언가를 반복"해야 할 때 가장 적합하죠. 예를 들어, 배열이나 리스트를 순회하거나 숫자를 1부터 10까지 출력하는 등의 작업에서 아주 유용하게 쓰입니다.

for 문 기본 구조

for (초기화식; 조건식; 증감식) {
    // 반복할 코드 블록
}

위 구조는 한 줄씩 해석하면 아래와 같습니다:

  • 초기화식: 반복문이 시작될 때 한 번만 실행되는 코드 (예: int i = 0)
  • 조건식: 반복을 계속할지 결정하는 불리언(boolean) 조건 (예: i < 10)
  • 증감식: 반복할 때마다 실행되는 식으로 반복 변수의 값을 조절 (예: i++)

for 문 예제: 1부터 5까지 출력

public class ForExample {
    public static void main(String[] args) {
        for (int i = 1; i <= 5; i++) {
            System.out.println("현재 숫자: " + i);
        }
    }
}

이 코드는 1부터 5까지의 숫자를 차례로 출력합니다. 반복 횟수가 명확히 정해져 있을 때 for문을 쓰는 이유를 쉽게 이해할 수 있는 예제죠.

for문 사용 팁

  1. 배열이나 리스트를 순회할 때 가장 적합
  2. 반복 횟수가 명확할 때 사용하면 가독성과 유지보수성이 좋음
  3. breakcontinue를 통해 반복을 제어할 수 있음

자, 이제 for문은 어렵지 않죠? 😊 다음에는 조건 기반 반복에 적합한 while문을 알아보겠습니다!

2. while 루프의 개념과 활용 🔁

while문은 조건을 만족하는 동안 계속해서 반복되는 루프입니다. for문과는 달리, 반복 횟수가 정해져 있지 않거나 조건에 따라 반복 여부를 유연하게 처리하고 싶을 때 자주 사용돼요.

while 문 기본 구조

while (조건식) {
    // 반복할 코드 블록
}

조건식이 true일 때만 반복이 실행되고, false가 되면 반복을 종료합니다. 조건식이 처음부터 false면 코드 블록은 단 한 번도 실행되지 않아요.

예제: 1부터 5까지 출력

public class WhileExample {
    public static void main(String[] args) {
        int i = 1;
        while (i <= 5) {
            System.out.println("현재 숫자: " + i);
            i++;
        }
    }
}

while문은 초기화와 증감이 반복문 밖에서 명시적으로 이루어져야 합니다. 실수로 증감식을 빠뜨리면 무한 루프에 빠질 수 있으니 주의하세요!

while문 사용 시 주의사항

  • 조건식이 true에서 false로 바뀌지 않으면 무한 루프 발생
  • 루프 내부에서 반드시 조건식에 영향을 주는 코드 포함 필요
  • 무한 루프가 필요한 경우에는 break로 명확히 종료 조건 지정

이처럼 while문은 조건에 따라 유연하게 반복을 제어할 수 있어서 입력값이 정확하지 않거나, 종료 조건이 외부 입력에 따라 달라지는 경우에 아주 유용하답니다!

3. do-while 루프의 특징과 차이점 🔄

do-while문은 조건과 관계없이 무조건 한 번은 실행되는 반복문입니다. 조건 검사가 반복문 에 이뤄지기 때문에, 사용자의 입력을 최소 한 번 받아야 하는 경우나, 반복이 반드시 한 번 이상 일어나야 할 때 사용합니다.

do-while 문 기본 구조

do {
    // 반복할 코드 블록
} while (조건식);

보셨다시피 while 키워드가 뒤에 위치하고 세미콜론(;)으로 마무리되는 점이 특징이에요. 다른 반복문과는 문법적으로도 살짝 다르죠.

예제: 1부터 5까지 출력

public class DoWhileExample {
    public static void main(String[] args) {
        int i = 1;
        do {
            System.out.println("현재 숫자: " + i);
            i++;
        } while (i <= 5);
    }
}

while과 거의 비슷해 보이지만, 조건이 false여도 한 번은 출력됩니다. 이게 바로 핵심 차이예요.

do-while문의 대표 활용 사례

  • 사용자로부터 입력을 반복해서 받을 때 (예: 메뉴 선택)
  • 최소 한 번은 작업을 실행해야 하는 루틴

예를 들어, 사용자가 'q'를 입력할 때까지 반복하는 프로그램을 만든다고 해봐요. do-while은 입력값을 먼저 받고 조건을 검사하니, 이럴 때 딱 적합하답니다.

자, 이제 for, while, do-while의 기본 개념과 활용법을 익혔어요. 다음 단계에서는 이 반복문들의 차이점과 사용 시 주의점을 비교해보겠습니다!

4. for와 while의 차이점 비교 ⚖️

앞서 for문과 while문, do-while문을 각각 살펴봤는데요, 이번에는 이 세 가지 반복문을 비교 분석해보는 시간을 가져볼게요. 상황에 따라 어떤 반복문을 선택해야 할지 고민될 때가 많죠. 하지만 각 문법의 용도와 특징만 잘 이해하면 선택은 훨씬 쉬워집니다.

반복문 비교 표

특징 for문 while문 do-while문
반복 조건 확인 시점 반복 전 반복 전 반복 후
반복 횟수 정해져 있을 때 모를 때 최소 1회는 무조건 실행
가독성 높음 보통 낮음
사용 예 배열/리스트 순회 무한 루프 또는 조건 기반 반복 메뉴 입력 등 최초 1회 실행 보장

반복문 선택 팁

  1. 반복 횟수가 명확할 때는 for
  2. 조건이 동적으로 바뀌거나 횟수를 모를 때는 while
  3. 사용자 입력 등 최소 1회 실행이 필수인 경우 do-while

코드를 처음 배울 땐 어떤 문을 선택해야 할지 헷갈릴 수 있어요. 하지만 반복문의 구조적 차이실행 흐름만 명확히 이해한다면, 실수도 줄고 로직 설계도 훨씬 쉬워질 거예요.

5. 반복문의 흐름도와 실행 순서 🔃

반복문을 잘 이해하려면 단순히 문법만 외우는 게 아니라, 코드가 실제로 어떻게 흐르는지 흐름도를 통해 파악하는 것이 아주 중요해요. 특히 복잡한 조건이나 여러 반복문이 중첩되어 있을 때는 흐름을 놓치기 쉽거든요.

for문 흐름도

  • 초기화 → 조건 검사 → 코드 실행 → 증감식 → 조건 검사 → 반복
int i = 0;           // 초기화
for (; i < 5; i++) { // 조건 검사 → 코드 실행 → i 증가
    System.out.println(i);
}

while문 흐름도

  • 조건 검사 → 조건이 true면 코드 실행 → 다시 조건 검사 → 반복
int i = 0;
while (i < 5) {
    System.out.println(i);
    i++; // 조건을 바꾸는 코드가 꼭 있어야 함!
}

do-while문 흐름도

  • 코드 실행 → 조건 검사 → 조건이 true면 반복
int i = 0;
do {
    System.out.println(i);
    i++;
} while (i < 5);

요약 포인트 🎯

  • for: 초기화 → 조건 검사 → 실행 → 증감 (반복 횟수가 정해졌을 때)
  • while: 조건 먼저 검사 → 조건 만족하면 실행 (유동적인 반복)
  • do-while: 무조건 한 번 실행 → 조건 검사 → 반복 여부 결정

각 반복문의 흐름을 확실하게 익혀두면, 복잡한 알고리즘에서도 "언제 반복을 시작하고, 언제 끝내야 하는지" 판단이 훨씬 쉬워져요. 다음 단계에서는 실수를 줄이기 위한 팁도 함께 알아볼게요!

6. 반복문에서 자주 하는 실수 😵

처음 반복문을 배우다 보면 의도하지 않게 무한 루프에 빠지거나, 조건을 잘못 설정해서 실행이 한 번도 안 되는 경우가 많아요. 이런 실수들은 아주 흔하고, 저도 처음엔 수없이 겪었던 시행착오랍니다.

자주 발생하는 반복문 실수 유형

  1. 조건식 오류 – 조건이 절대 false가 되지 않아 무한 루프에 빠짐
    int i = 0;
    while (i < 5) {
        System.out.println(i);
        // i++; ← 빠뜨리면 무한 루프
    }
        
  2. 증감식 오류 – 증감 방향이 잘못돼서 조건이 영원히 true인 상태 유지
    for (int i = 0; i > -10; i++) { // 조건은 감소해야 true인데 증가 중
        System.out.println(i);
    }
        
  3. 세미콜론(;) 실수 – for/while 바로 뒤에 세미콜론 붙여서 반복문이 비어버림
    for (int i = 0; i < 5; i++); {
        System.out.println("출력됨?");
    }
        
  4. 조건의 중복 처리 미흡 – 반복 조건이 중복되거나 충돌해서 예상보다 더 많이 실행됨
    int i = 0;
    while (i++ < 5) {
        System.out.println(i);
    } // 실제 출력은 1부터 5까지가 아닌 1부터 6까지 됨
        

반복문 실수 줄이는 꿀팁 💡

  • 변수 변화 확인용 출력문을 초기에 자주 넣어보세요 (디버깅용 System.out.println())
  • break, continue 문으로 루프를 제어하는 습관을 들이세요
  • 테스트는 짧고 단순한 루프부터 시작하고 점차 확장하세요

반복문은 처음엔 헷갈릴 수 있지만, 예제와 실습을 통해 충분히 익숙해질 수 있어요. 실수도 경험이고 배움의 일부랍니다 😉
이제 다음 단계에서는 반복문을 더 확실히 이해할 수 있는 실전 예제 실습을 진행해볼게요!

마무리 🎯

자, 여기까지 for, while, do-while 반복문에 대해 차근차근 살펴봤습니다. 반복문은 프로그래밍에서 가장 많이 쓰이는 제어 구조 중 하나이자, 코드의 효율성과 간결함을 결정짓는 중요한 요소예요. 단순한 문법을 넘어서서 흐름도를 이해하고, 조건을 설정하고, 어떤 상황에서 어떤 반복문을 써야 하는지를 판단할 수 있다면 여러분의 자바 실력은 확실히 한 단계 성장하게 됩니다.

이제 여러분도 반복문을 "왜, 어떻게, 언제 써야 하는지"에 대한 감을 잡으셨을 거예요. 앞으로 더 복잡한 로직이나 알고리즘을 공부할 때도 이 반복문이 여러분의 든든한 도구가 되어줄 거예요.

다음 글에서는 반복문과 조건문을 함께 조합한 실전 알고리즘 예제를 다뤄볼 예정이니 기대해주세요! 오늘도 끝까지 읽어주셔서 고맙습니다 😊

반응형
반응형

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 조건이 참일 때 실행될 코드 블록 지정
조건식 true 또는 false로 평가되는 표현식
중괄호 {} 조건이 참일 때 실행할 코드의 범위 지정

이처럼 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 조건이 참일 때만 실행, 거짓이면 아무 것도 하지 않음
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는 생략 가능하지만, 모든 조건이 거짓일 경우를 대비해 넣는 것이 좋아요.

📊 구조 요약 비교

조건 분기 방식 특징
if 단일 조건만 평가
if ~ else 양자택일 구조
if ~ else if ~ 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 ~ else if 문
가독성 case가 명확히 구분됨 조건이 복잡할 경우 적합
지원 타입 int, char, String 등 일부만 모든 타입과 조건식 지원
유연성 정해진 값 비교에 적합 복잡한 조건, 논리식 사용 가능

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

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

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

📌 선택 기준 요약

조건문 유형 사용하면 좋은 경우 주의사항
if 참/거짓 여부 판단, 복잡한 조건식 사용 분기가 많으면 코드 길어짐
if ~ else 두 가지 경우로 나눌 때 else의 순서에 주의
if ~ else if ~ else 3개 이상의 조건 분기 시 가독성 저하 주의
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 클래스의 주요 메서드들 🔍

메서드 설명
nextInt() 정수를 입력받습니다.
nextDouble() 실수를 입력받습니다.
nextLine() 한 줄 전체를 문자열로 입력받습니다.
next() 공백 전까지의 문자열을 입력받습니다.

🎯 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. 산술 연산자 활용법 🔢

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

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

연산자 설명 예시
+ 덧셈 num1 + num2
- 뺄셈 num1 - num2
* 곱셈 num1 * num2
/ 나눗셈 (정수 나눗셈은 소수점 이하 버림) num1 / num2
% 나머지 num1 % num2

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

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

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을 기반으로 문자열, 정수, 실수 등 다양한 자료형을 손쉽게 읽을 수 있게 도와주는 아주 고마운 도구랍니다.

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

항목 내용
표준 입력 System.in으로 처리되는 기본 키보드 입력 스트림
문자 처리 System.in은 바이트 단위로만 처리하기 때문에 불편함 존재
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() 단어 하나 (공백 전까지)
nextLine() 줄 전체 입력 (엔터 전까지)
nextInt() 정수 입력
nextDouble() 실수 입력

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

📦 자료형별 입력 메서드

자료형 메서드 예시
문자열 nextLine() sc.nextLine();
정수 nextInt() sc.nextInt();
실수 (double) nextDouble() sc.nextDouble();
실수 (float) nextFloat() sc.nextFloat();
불린 (true/false) nextBoolean() sc.nextBoolean();

💡 예외 상황 주의하기

  • 숫자 입력 시 숫자가 아닌 문자를 입력하면 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("정수를 입력해주세요!");
}

📝 오류 상황 정리

오류 상황 원인 해결책
nextLine()이 건너뛰어짐 nextInt() 이후 줄바꿈 문자가 남아있음 sc.nextLine() 한 번 호출해서 제거
입력 예외 발생 입력값과 메서드 자료형 불일치 try-catch로 예외 처리

입력 도중 발생하는 오류는 처음에는 꽤 당황스럽지만, 그 원인을 정확히 알면 금방 해결할 수 있어요. 이제 마지막으로, 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)에 따라 평가됩니다. 아래는 자바 공식 문서 기준으로 정리한 연산자 우선순위 표입니다. 높은 우선순위를 가진 연산자가 먼저 실행됩니다.

우선순위 연산자 설명
1 (가장 높음) [], (), . 배열 인덱스, 괄호, 멤버 접근
2 ++, -- 단항 후위 연산자
3 ++, --, +, -, ~, ! 단항 전위 연산자
4 *, /, % 곱셈, 나눗셈, 나머지
5 +, - 덧셈, 뺄셈
6 <<, >>, >>> 비트 이동
7 <, <=, >, >=, instanceof 비교 연산자
8 ==, != 등가 비교
9 & 비트 AND
10 ^ 비트 XOR
11 | 비트 OR
12 && 논리 AND
13 || 논리 OR
14 ?: 삼항 연산자
15 =, +=, -= 등 대입 연산자

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

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))과 같은 순서로 평가됩니다.

📝 주요 연산자의 결합 방향

연산자 결합 방향 예시
+, -, *, /, %, &, |, ^, &&, || Left-to-Right a + b + c → (a + b) + c
=, +=, -=, *=, /=, %= Right-to-Left x = y = z = 100 → x = (y = (z = 100))
?: (삼항 연산자) Right-to-Left result = condition ? a : b;

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

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 > ytrue, y < 3false, 전체 true && false = false. 삼항 조건식의 결과는 200

📚 정리 요약

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

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

마무리하며 🧠

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

 

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

 

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

반응형
반응형

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

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

반응형

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

1. 산술 연산자 ✏️

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

📌 산술 연산자 종류

연산자 기능 예시
+ 더하기 3 + 5 → 8
- 빼기 10 - 4 → 6
* 곱하기 6 * 2 → 12
/ 나누기 10 / 2 → 5
% 나머지 7 % 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. 대입 연산자와 복합 대입 🔄

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

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

연산자 설명 예시
= 우변 값을 좌변 변수에 대입 x = 10;
+= 덧셈 후 대입 x += 5; // x = x + 5
-= 뺄셈 후 대입 x -= 3; // x = x - 3
*= 곱셈 후 대입 x *= 2; // x = x * 2
/= 나눗셈 후 대입 x /= 2; // x = x / 2
%= 나머지 후 대입 x %= 3; // x = x % 3

🧪 예제로 이해하기

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 등)과 함께 사용되며, 프로그램의 흐름을 결정하는 핵심 역할을 합니다.

📌 비교 연산자 종류

연산자 기능 예시
== 같은 값인지 비교 5 == 5 → true
!= 같지 않은지 비교 4 != 3 → true
> 왼쪽이 더 큰가 7 > 5 → true
< 왼쪽이 더 작은가 3 < 6 → true
>= 크거나 같은가 5 >= 5 → true
<= 작거나 같은가 4 <= 5 → true

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

int age = 20;

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

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

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

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

4. 논리 연산자 ✅❌

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

📌 논리 연산자 종류

연산자 기능 예시
&& AND: 모두 참일 때만 true (x > 0) && (x < 10)
|| OR: 하나라도 참이면 true (x < 0) || (x > 100)
! NOT: true → false, false → true !(x == 0)

🧪 논리 연산자 실습 예제

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. 연산자 우선순위와 표현식의 흐름 🔁

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

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

우선순위 연산자 종류 예시
1 괄호 () (a + b)
2 단항 연산자 +, -, ! -x, !flag
3 산술 연산자 *, /, % a * b
4 산술 연산자 +, - a + b
5 비교 연산자 >, <, == x == y
6 논리 연산자 &&, || a && b
7 삼항 연산자 ? : 조건 ? 참 : 거짓
8 대입 연산자 =, +=, -= x = 5

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

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" 이런 것들이 모두 리터럴이에요.

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

📌 리터럴의 예시

리터럴 종류 예시 설명
정수형 리터럴 10, -5, 0 int, long 등 정수형 변수에 사용
실수형 리터럴 3.14, -0.5 float, double 등 실수형 변수에 사용
문자 리터럴 'A', '가' char 타입에 사용, 반드시 작은따옴표('')
문자열 리터럴 "Hello", "Java" String 클래스에서 사용
논리 리터럴 true, false boolean 타입에 사용

💡 꼭 알아두세요!

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

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

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

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

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

리터럴 유형 예시 설명
정수형 10, -7, 0xFF, 0b1010 10진수, 16진수(0x), 2진수(0b) 등 다양한 형태 사용 가능
실수형 3.14, -0.001, 1.0e3 기본적으로 double, 접미사 f/F로 float 표현
문자형 'A', '9', '가' char 타입은 작은따옴표로 감싼 단일 문자
문자열형 "Hello", "123", "자바" String 객체에 저장되는 문자열 값
논리형 true, false boolean 타입에서 조건문 등에 사용

✅ 리터럴 표현 시 주의할 점

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

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

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

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

📌 기본형과 리터럴 매칭 표

자료형 예시 리터럴 설명
byte 100 -128~127 범위의 정수 리터럴만 가능
short 10000 16비트 정수 범위 내에서 사용 가능
int 123456 기본 정수형, 별도 접미사 없이 사용
long 12345678900L 끝에 L 또는 l 붙여야 long으로 인식
float 3.14f 접미사 f/F 필수 (소수점 표현)
double 3.14 기본 실수형, 접미사 필요 없음
char 'A' 한 글자만 작은따옴표로 감쌈
boolean true, false 참/거짓만 표현 가능

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

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

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

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

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

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

📌 묵시적 형 변환 규칙

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

💡 예제: 자동 형 변환

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.993처럼 소수점은 버려짐
  • 범위 초과 문제: 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);

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

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

용어 설명
변수(variable) 값을 저장하는 이름이 있는 메모리 공간
자료형(data type) 변수에 저장될 값의 종류를 지정
선언(declaration) 변수를 처음 정의하고 자료형과 이름을 지정하는 행위
초기화(initialization) 변수에 값을 처음 대입하는 작업

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

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

변수 선언 기본 문법

자료형 변수명;

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

int score;

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

초기화란?

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

int score = 100;

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

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

선언 형식 설명
int age = 20; 정수형 age 변수 선언 및 초기화
double pi = 3.14; 실수형 pi 변수 선언 및 초기화
char grade = 'A'; 문자형 grade 변수 선언 및 초기화
boolean isLogin = true; 논리형 isLogin 변수 선언 및 초기화

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

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

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

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

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

식별자 작명 규칙 정리 📋

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

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

스타일 설명 예시
camelCase 소문자로 시작하고 단어마다 대문자 userName, totalCount
PascalCase 모든 단어의 시작을 대문자로 UserName, TotalCount
snake_case 단어 사이에 밑줄 사용 user_name, total_count

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

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

나쁜 이름 좋은 이름 설명
a age 단순한 글자보다는 의미 있는 이름 사용
b1 isLogin 불린 변수는 보통 is로 시작
tmp userInput 의미 없는 이름보다 정확한 정보 전달

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

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

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

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

기본형 데이터 타입이란?

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

타입 크기 예시 설명
byte 1 byte 127, -128 작은 정수 저장용
short 2 bytes 32_000 중간 크기의 정수
int 4 bytes 1_000_000 기본 정수형, 가장 많이 사용됨
long 8 bytes 123456789L 매우 큰 정수 저장 시 사용
float 4 bytes 3.14f 소수점 포함, 접미사 f 필요
double 8 bytes 3.141592 정밀한 실수, 기본 실수형
char 2 bytes 'A' 하나의 문자 저장 (문자열 아님)
boolean 1 byte true, false 논리값 저장

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

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)를 변수로 선언하고 값을 초기화한 후 출력해보세요.

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

마무리 🌱

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

 

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

 

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

반응형

+ Recent posts