day03
안녕하세요! 여러분의 Java 가이드, 홍순구 튜터입니다.
Day 3에 오신 걸 환영합니다!
지난 시간에 우리는 변수라는 "그릇"에 데이터를 담아 기억하고, 계산하고, 조합하는 방법을 배웠어요.
int, double, boolean, String — 다양한 자료형으로 인스타그램 프로필 카드까지 만들었죠.
그런데 한 가지 아쉬운 점이 있습니다. 우리 프로그램은 누구에게나 똑같이 동작했어요. 비공개 계정이든 공개 계정이든, 팔로워가 10만 명이든 10명이든 — 항상 같은 결과만 출력했습니다.
진짜 인스타그램은 어떤가요? 비공개 계정이면 "팔로우 요청" 버튼이 뜨고, 공개 계정이면 바로 "팔로우" 버튼이 뜹니다. 팔로워 수에 따라 "인플루언서" 배지가 붙기도 하죠.
오늘의 주제는 "연산자와 조건문" 입니다. 프로그램이 상황을 판단하고, 조건에 따라 다르게 동작하도록 만들어 봅시다!
🎯 학습 목표
- 산술·비교·논리·대입 연산자를 사용할 수 있다
if/else if/else로 조건 분기를 작성할 수 있다switch표현식(화살표 구문)으로 여러 선택지를 처리할 수 있다- 삼항 연산자로 간단한 조건을 한 줄로 표현할 수 있다
- 연산자와 조건문을 조합해서 인스타그램 프로필 카드를 업그레이드할 수 있다
Step 1: "계산기의 탄생 — 산술 연산자"
지난 시간 마무리에서 "+ 같은 기호를 연산자라고 부른다"고 했었죠.
오늘 본격적으로 연산자를 만나봅니다.
연산자(Operator) 란 데이터를 가공하는 기호입니다.
+로 더하고, -로 빼고, *로 곱하고, /로 나누죠.
수학 시간에 배운 사칙연산과 거의 같아요.
사칙연산 기호
| 연산자 | 의미 | 예시 | 결과 |
|---|---|---|---|
+ |
더하기 | 10 + 3 |
13 |
- |
빼기 | 10 - 3 |
7 |
* |
곱하기 | 10 * 3 |
30 |
/ |
나누기 | 10 / 3 |
3 |
% |
나머지 | 10 % 3 |
1 |
수학에서는 곱하기에 ×, 나누기에 ÷를 쓰지만, 키보드에는 이 기호가 없어요.
그래서 프로그래밍에서는 *(별표)와 /(슬래시)를 씁니다.
바로 코드로 확인해 볼까요?
// day03/ArithmeticOperators.java
void main() {
int likes = 150;
int comments = 38;
int total = likes + comments;
int diff = likes - comments;
System.out.println("총 반응: " + total);
System.out.println("좋아요 - 댓글: " + diff);
int postsPerDay = 3;
int days = 7;
int weeklyPosts = postsPerDay * days;
System.out.println("일주일 게시물: " + weeklyPosts);
}
실행하면 이렇게 나옵니다.
총 반응: 188
좋아요 - 댓글: 112
일주일 게시물: 21
정수 나누기의 함정
여기서 주의할 점이 하나 있어요. 정수끼리 나누면 소수점이 버려집니다.
void main() {
int totalLikes = 10;
int postCount = 3;
int avgInt = totalLikes / postCount;
System.out.println("평균 좋아요 (정수): " + avgInt);
double avgDouble = (double) totalLikes / postCount;
System.out.println("평균 좋아요 (실수): " + avgDouble);
}
평균 좋아요 (정수): 3
평균 좋아요 (실수): 3.3333333333333335
10 ÷ 3 = 3.333...인데, int끼리 나누면 소수점 아래가 잘려서 3이 됩니다.
지난 시간에 배운 형변환이 여기서 다시 등장해요.
(double)을 붙여서 하나를 실수로 바꿔주면 소수점이 살아납니다.
나머지 연산자 %
%는 나누고 남은 나머지를 구하는 연산자입니다.
수학에서 "10 ÷ 3 = 3 나머지 1"에서 그 나머지 1을 구하는 거예요.
이걸 대체 어디에 쓸까요? 실전에서 정말 자주 쓰입니다.
void main() {
int followerCount = 1537;
int remainder = followerCount % 2;
System.out.println("1537 % 2 = " + remainder);
System.out.println("홀수인가? " + (remainder != 0));
}
% 2의 결과가 0이면 짝수, 1이면 홀수입니다.
숫자가 짝수인지 홀수인지 판별하는 가장 흔한 방법이에요.
🙋 "나머지 연산자를 짝홀수 말고 또 어디에 쓰나요?"
실전에서 %를 쓰는 대표적인 상황이 있어요.
- 그룹 나누기:
userId % 5로 사용자를 5개 그룹에 분배 - 순환:
index % 배열길이로 배열을 돌려가며 접근 (Day 5 배열에서 다시 만나요) - N번째마다:
count % 10 == 0이면 10번마다 한 번씩 실행
Step 2: "같은가, 다른가 — 비교 연산자"
산술 연산자는 숫자를 계산했죠. 비교 연산자는 두 값을 비교해서 맞는지 틀린지 알려줍니다.
여기서 지난 시간에 배운 boolean이 드디어 제 역할을 합니다.
비교 연산자의 결과는 항상 true 아니면 false예요.
비교 연산자 6가지
| 연산자 | 의미 | 예시 | 결과 |
|---|---|---|---|
== |
같다 | 5 == 5 |
true |
!= |
다르다 | 5 != 3 |
true |
> |
크다 | 5 > 3 |
true |
< |
작다 | 5 < 3 |
false |
>= |
크거나 같다 | 5 >= 5 |
true |
<= |
작거나 같다 | 5 <= 3 |
false |
주의할 점이 하나 있어요.
"같다"는 =가 아니라 == (등호 두 개)입니다.
=는 Day 2에서 배운 대입(값을 넣는 것)이고, ==는 비교(같은지 확인)예요.
한 글자 차이지만 의미가 완전히 다르니 꼭 구분해 주세요.
// day03/ComparisonOperators.java
void main() {
int myFollowers = 1500;
int yourFollowers = 3200;
System.out.println("같은가? " + (myFollowers == yourFollowers));
System.out.println("다른가? " + (myFollowers != yourFollowers));
System.out.println("내가 더 많은가? " + (myFollowers > yourFollowers));
System.out.println("내가 더 적은가? " + (myFollowers < yourFollowers));
int threshold = 10000;
boolean isInfluencer = myFollowers >= threshold;
System.out.println("인플루언서인가? " + isInfluencer);
}
같은가? false
다른가? true
내가 더 많은가? false
내가 더 적은가? true
인플루언서인가? false
비교 결과를 boolean 변수에 담아두면, 나중에 조건문에서 바로 쓸 수 있어요.
이게 Step 5에서 배울 if문의 핵심 재료가 됩니다.
🙋 "= 하나와 == 두 개를 헷갈려서 실수하면 어떡하나요?"
좋은 질문이에요! 실제로 초보자가 가장 많이 하는 실수 중 하나입니다.
int x = 5;
// x = 3; 대입 — x에 3을 넣는다 (x가 바뀜)
// x == 3; 비교 — x가 3인지 확인 (x 안 바뀜, 결과는 boolean)
Java는 if (x = 3) 같은 코드를 쓰면 컴파일 에러를 내줘요.
"아, ==를 써야 하는구나!" 하고 알려주는 셈입니다.
에러 메시지가 여러분 편이에요.
Step 3: "그리고, 또는, 아니다 — 논리 연산자"
비교 연산자 하나로는 간단한 질문만 할 수 있어요. "팔로워가 10,000명 이상인가?"처럼요.
그런데 현실의 조건은 대부분 여러 가지가 동시에 걸립니다. "팔로워가 10,000명 이상이고 게시물이 30개 이상이고 아직 인증 배지가 없는 사람" — 이렇게요.
이렇게 여러 조건을 엮어주는 게 논리 연산자입니다.
논리 연산자 3가지
| 연산자 | 이름 | 의미 | 예시 |
|---|---|---|---|
&& |
AND | 둘 다 true여야 true | true && true → true |
|| |
OR | 하나만 true여도 true | false || true → true |
! |
NOT | true↔false 뒤집기 | !true → false |
놀이공원 비유로 이해해 볼까요?
&&(AND): 키 140cm 이상이고 나이 14세 이상이어야 탑승 가능 → 둘 다 충족해야 함||(OR): 주말이거나 공휴일이면 쉬는 날 → 하나만 충족하면 됨!(NOT): 비공개 계정이 아니면 공개 계정 → 반대로 뒤집기
// day03/LogicalOperators.java
void main() {
int age = 16;
int height = 145;
boolean canRide = age >= 14 && height >= 140;
System.out.println("놀이기구 탑승 가능? " + canRide);
boolean isPrivate = true;
boolean isPublic = !isPrivate;
System.out.println("공개 계정인가? " + isPublic);
boolean isFollower = false;
boolean canSeePost = isPublic || isFollower;
System.out.println("게시물을 볼 수 있는가? " + canSeePost);
}
인스타그램에서 게시물을 볼 수 있는 조건을 생각해 보세요.
공개 계정이거나(||) 내가 그 사람의 팔로워면 게시물을 볼 수 있어요.
복합 조건
논리 연산자를 여러 개 이어 붙이면 복잡한 조건도 표현할 수 있습니다.
void main() {
int followerCount = 12000;
int postCount = 50;
boolean isVerified = false;
boolean qualifiesForBadge = followerCount >= 10000
&& postCount >= 30
&& !isVerified;
System.out.println("인증 배지 신청 가능? " + qualifiesForBadge);
}
"팔로워 만 명 이상 그리고 게시물 30개 이상 그리고 아직 인증 안 된 사람"이 배지 신청 가능한 조건이에요.
&&로 엮으면 모든 조건이 다 참이어야 최종 결과가 true입니다.
단축 평가
Java는 논리 연산을 할 때 게으르게 동작합니다.
&&에서 앞의 조건이 false면, 뒤의 조건은 확인하지 않아요.
어차피 최종 결과는 false니까요.
void main() {
int divisor = 0;
boolean isSafe = divisor != 0 && (10 / divisor > 2);
System.out.println("안전한 나눗셈? " + isSafe);
}
divisor가 0이니까 divisor != 0은 false입니다.
&&는 앞이 false면 뒤를 아예 실행하지 않아서, 10 / 0이라는 위험한 계산을 피할 수 있어요.
이걸 단축 평가(Short-circuit Evaluation) 라고 합니다.
💡 지금 깊이 외울 필요는 없어요. "Java는 불필요한 계산을 건너뛴다" 정도만 기억하면 됩니다.
Step 4: "줄여 쓰는 계산 — 대입·증감 연산자"
코딩하다 보면 "기존 값에 뭔가를 더한 결과를 다시 저장"하는 상황이 정말 많아요.
팔로워 수가 늘어나면 followerCount = followerCount + 1처럼 쓰는데, 좀 길죠?
Java는 이걸 짧게 쓰는 방법을 제공합니다.
복합 대입 연산자
| 긴 버전 | 짧은 버전 | 의미 |
|---|---|---|
a = a + 5 |
a += 5 |
더하고 저장 |
a = a - 3 |
a -= 3 |
빼고 저장 |
a = a * 2 |
a *= 2 |
곱하고 저장 |
a = a / 4 |
a /= 4 |
나누고 저장 |
a = a % 3 |
a %= 3 |
나머지를 저장 |
// day03/AssignmentOperators.java
void main() {
int followerCount = 1000;
followerCount += 50;
System.out.println("팔로워 50명 증가: " + followerCount);
followerCount -= 20;
System.out.println("팔로워 20명 감소: " + followerCount);
}
팔로워 50명 증가: 1050
팔로워 20명 감소: 1030
증감 연산자: ++, --
"1만 더하기" 또는 "1만 빼기"는 워낙 자주 해서, 더 짧은 표기법이 있습니다.
void main() {
int likeCount = 99;
likeCount++;
System.out.println("좋아요 +1: " + likeCount);
likeCount--;
System.out.println("좋아요 -1: " + likeCount);
}
좋아요 +1: 100
좋아요 -1: 99
likeCount++은 likeCount = likeCount + 1과 같습니다.
인스타그램에서 좋아요를 누르면 1 증가, 취소하면 1 감소 — 딱 이 용도예요.
🙋 "++를 앞에 쓰는 것과 뒤에 쓰는 건 뭐가 다른가요?"
a++(후위)과 ++a(전위)는 혼자 쓰면 결과가 같지만, 다른 연산과 함께 쓸 때 차이가 납니다.
int a = 5;
System.out.println("후위: " + a++); // 5 출력 후 증가
System.out.println("지금 a: " + a); // 6
int b = 5;
System.out.println("전위: " + ++b); // 증가 후 6 출력
System.out.println("지금 b: " + b); // 6
후위(a++): 현재 값을 먼저 사용하고 그 다음에 증가
전위(++a): 먼저 증가시키고 그 값을 사용
헷갈리면? likeCount++처럼 한 줄에 단독으로 쓰는 게 가장 안전해요.
연산자 우선순위 — 수학이랑 같아요
void main() {
int result1 = 2 + 3 * 4;
int result2 = (2 + 3) * 4;
System.out.println("2 + 3 * 4 = " + result1);
System.out.println("(2 + 3) * 4 = " + result2);
}
2 + 3 * 4 = 14
(2 + 3) * 4 = 20
수학과 마찬가지로 *, /가 +, -보다 먼저 계산됩니다.
순서를 바꾸고 싶으면 괄호 () 를 쓰면 돼요.
💡 연산자 우선순위 표를 외울 필요 없어요. 헷갈리면 괄호를 쓰세요. 코드 읽기도 더 쉬워집니다.
Step 5: "갈림길에서 선택하기 — if/else"
여기까지 배운 연산자들은 모두 재료 준비였어요. 산술 연산자로 계산하고, 비교 연산자로 조건을 만들고, 논리 연산자로 조건을 엮었죠.
이제 그 재료로 진짜 요리를 할 차례입니다. 지난 시간에 "조건에 따라 다르게 동작하는 프로그램"을 예고했었죠? 바로 조건문입니다.
if — "만약 ~이면"
가장 기본적인 조건문입니다.
조건이 true이면 중괄호 {} 안의 코드를 실행해요.
// day03/IfElseExample.java
void main() {
int followerCount = 1500;
if (followerCount >= 1000) {
System.out.println("팔로워 1,000명을 돌파했습니다!");
}
}
followerCount가 1500이니까 >= 1000은 true예요.
그래서 중괄호 안의 코드가 실행됩니다.
만약 followerCount가 500이었다면?
>= 1000이 false니까 중괄호 안의 코드는 건너뛰고 넘어갑니다.
if-else — "이러면 이렇게, 아니면 저렇게"
void main() {
boolean isPrivate = true;
if (isPrivate) {
System.out.println("비공개 계정입니다. 팔로우 요청을 보내세요.");
} else {
System.out.println("공개 계정입니다. 바로 팔로우할 수 있습니다.");
}
}
if에 해당하지 않으면 else 쪽이 실행돼요.
둘 중 하나는 반드시 실행됩니다.
if-else if-else — "여러 갈래"
선택지가 두 개가 아니라 여러 개일 때 쓰는 패턴입니다.
void main() {
int followerCount = 1500;
if (followerCount >= 1000000) {
System.out.println("등급: 메가 인플루언서");
} else if (followerCount >= 100000) {
System.out.println("등급: 매크로 인플루언서");
} else if (followerCount >= 10000) {
System.out.println("등급: 마이크로 인플루언서");
} else if (followerCount >= 1000) {
System.out.println("등급: 나노 인플루언서");
} else {
System.out.println("등급: 일반 사용자");
}
}
위에서부터 아래로 조건을 확인하면서, 처음으로 true가 되는 곳에서 멈춥니다.
followerCount가 1500이면:
>= 1000000 false → >= 100000 false → >= 10000 false → >= 1000 true → "나노 인플루언서"
⚠️ 순서가 중요합니다! >= 1000을 맨 위에 놓으면 팔로워 100만인 사람도 "나노 인플루언서"로 분류돼요. 큰 수부터 비교해야 정확하게 분류됩니다.
중첩 if — 조건 안에 조건
if 안에 또 if를 넣을 수도 있어요.
void main() {
boolean isLoggedIn = true;
boolean isVerified = false;
if (isLoggedIn) {
System.out.println("로그인 상태입니다.");
if (isVerified) {
System.out.println("인증 배지가 있습니다.");
} else {
System.out.println("아직 인증 배지가 없습니다.");
}
} else {
System.out.println("로그인이 필요합니다.");
}
}
먼저 로그인 여부를 확인하고, 로그인되었으면 그 안에서 다시 인증 여부를 확인합니다.
💡 중첩이 3단 이상 깊어지면 코드가 읽기 어려워져요. 2단까지만 쓰고, 그 이상은 나중에 배울 메서드로 분리하는 게 좋습니다 (Day 6에서 만나요).
🙋 "if 다음에 중괄호 없이 한 줄만 쓰면 안 되나요?"
문법적으로는 가능해요.
if (isPrivate) System.out.println("비공개");
하지만 권장하지 않습니다. 나중에 코드를 추가할 때 중괄호를 깜빡하면 버그가 생기거든요. 항상 중괄호를 쓰는 습관을 들이면 안전해요.
Step 6: "선택지가 여러 개일 때 — switch 표현식"
Step 5에서 if-else if를 여러 개 쓰는 패턴을 봤죠.
선택지가 정해진 값들 중 하나일 때는 switch가 더 깔끔합니다.
인스타그램 알림을 떠올려 보세요.
"좋아요" 알림, "댓글" 알림, "팔로우" 알림, "언급" 알림 — 종류가 정해져 있죠?
이런 상황에 switch가 딱 맞아요.
화살표 switch (JDK 14+)
Java의 switch는 원래 좀 불편했는데, JDK 14부터 화살표(->) 구문이 생기면서 훨씬 깔끔해졌어요.
우리는 처음부터 깔끔한 방식으로 배웁니다.
// day03/SwitchExample.java
void main() {
String notificationType = "like";
String message = switch (notificationType) {
case "like" -> "누군가 회원님의 게시물을 좋아합니다.";
case "comment" -> "누군가 댓글을 남겼습니다.";
case "follow" -> "새로운 팔로워가 생겼습니다.";
case "mention" -> "누군가 회원님을 언급했습니다.";
default -> "새로운 알림이 있습니다.";
};
System.out.println("알림: " + message);
}
알림: 누군가 회원님의 게시물을 좋아합니다.
switch 뒤의 괄호 안에 검사할 값을 넣고, 각 case에 일치하는 값을 적습니다.
->(화살표) 오른쪽에 실행할 코드를 쓰면 돼요.
default 는 어떤 case에도 해당하지 않을 때 실행됩니다.
if-else의 else와 같은 역할이에요.
switch 표현식으로 값 반환
위 코드를 잘 보면, switch 전체가 값을 만들어서 변수에 담기고 있어요.
String message = switch (...) { ... }; — 이렇게 switch 자체가 결과를 내놓는 걸 switch 표현식이라고 합니다.
if-else로 같은 코드를 쓰면 더 길어져요.
// if-else 버전 (더 길다)
String message;
if (notificationType.equals("like")) {
message = "누군가 회원님의 게시물을 좋아합니다.";
} else if (notificationType.equals("comment")) {
message = "누군가 댓글을 남겼습니다.";
} else if (notificationType.equals("follow")) {
message = "새로운 팔로워가 생겼습니다.";
} else {
message = "새로운 알림이 있습니다.";
}
여러 case 묶기
같은 처리를 하는 값이 여러 개라면 쉼표(,)로 묶을 수 있어요.
void main() {
String reaction = "heart";
String emoji = switch (reaction) {
case "heart", "love" -> "❤️";
case "fire", "hot" -> "🔥";
case "laugh", "haha", "lol" -> "😂";
case "sad", "cry" -> "😢";
default -> "👍";
};
System.out.println("반응: " + emoji);
}
"heart"와 "love"가 같은 ❤️를 반환합니다.
🙋 "if-else if와 switch, 언제 뭘 써야 하나요?"
간단한 판단 기준이 있어요.
- 값이 정해진 목록 중 하나일 때 →
switch(알림 종류, 요일, 등급 코드) - 범위 비교(크다, 작다)일 때 →
if-else if(팔로워 수 >= 10000) - 복합 조건(
&&,||조합)일 때 →if-else if
정해진 값 목록이면 switch가 더 읽기 쉽고, 범위나 복합 조건이면 if가 더 자연스럽습니다.
Step 7: "한 줄로 고르기 + 인스타 프로필 업그레이드"
마지막으로 삼항 연산자를 배우고, 오늘 배운 모든 것을 종합해서 Day 2의 프로필 카드를 업그레이드해 봅시다!
삼항 연산자
if-else가 딱 한 줄씩일 때, 더 짧게 쓸 수 있는 방법이 있어요.
조건 ? 참일 때 값 : 거짓일 때 값
void main() {
int followerCount = 1500;
String status = followerCount >= 10000 ? "인플루언서" : "일반 사용자";
System.out.println("상태: " + status);
boolean isPrivate = true;
String accessLabel = isPrivate ? "비공개 계정" : "공개 계정";
System.out.println(accessLabel);
}
상태: 일반 사용자
비공개 계정
if-else로 4줄 걸릴 코드가 한 줄로 줄어들었어요.
💡 삼항 연산자는 간단한 경우에만 쓰세요. 조건이 복잡하면 if-else가 훨씬 읽기 쉬워요. 코드는 짧은 것보다 읽기 쉬운 것이 더 중요합니다.
인스타그램 프로필 카드 V2
Day 2에서 만든 프로필 카드는 변수를 그냥 출력만 했어요. 오늘 배운 연산자와 조건문을 활용하면, 조건에 따라 다르게 표시되는 프로필 카드를 만들 수 있습니다.
먼저 변수 선언과 조건 로직을 봅시다.
// day03/TernaryAndProfileV2.java
void main() {
String username = "hong_gildong";
String displayName = "홍길동";
int age = 20;
boolean isVerified = false;
boolean isPrivate = true;
int postCount = 42;
int followerCount = 1500;
int followingCount = 300;
String verifiedBadge = isVerified ? " [인증]" : "";
String accountType = isPrivate ? "비공개" : "공개";
삼항 연산자로 isVerified가 true면 " [인증]" 문자열을, false면 빈 문자열을 넣어요.
이렇게 하면 인증된 계정에만 배지가 붙습니다.
등급 판정은 if-else if로 처리합니다.
String grade;
if (followerCount >= 1000000) {
grade = "메가 인플루언서";
} else if (followerCount >= 100000) {
grade = "매크로 인플루언서";
} else if (followerCount >= 10000) {
grade = "마이크로 인플루언서";
} else if (followerCount >= 1000) {
grade = "나노 인플루언서";
} else {
grade = "일반 사용자";
}
팔로워/팔로잉 비율도 삼항 연산자로 평가합니다.
double ratio = (double) followerCount / followingCount;
String ratioEval = ratio >= 5.0 ? "우수"
: ratio >= 1.0 ? "보통" : "성장 중";
그리고 최종 출력!
System.out.println("=== 인스타그램 프로필 V2 ===");
System.out.println("사용자명: @" + username + verifiedBadge);
System.out.println("이름: " + displayName);
System.out.println("나이: " + age + "세");
System.out.println("계정: " + accountType);
System.out.println("등급: " + grade);
System.out.println("게시물: " + postCount);
System.out.println("팔로워: " + followerCount);
System.out.println("팔로잉: " + followingCount);
System.out.println("팔로워/팔로잉 비율: "
+ Math.round(ratio * 100.0) / 100.0
+ " (" + ratioEval + ")");
System.out.println("============================");
}
실행 결과:
=== 인스타그램 프로필 V2 ===
사용자명: @hong_gildong
이름: 홍길동
나이: 20세
계정: 비공개
등급: 나노 인플루언서
게시물: 42
팔로워: 1500
팔로잉: 300
팔로워/팔로잉 비율: 5.0 (우수)
============================
Day 2의 프로필 카드와 비교해 보세요.
| Day 2 | Day 3 |
|---|---|
인증 계정: false |
@hong_gildong [인증] (또는 빈칸) |
비공개 계정: true |
계정: 비공개 |
| 등급 없음 | 등급: 나노 인플루언서 |
| 비율 숫자만 출력 | 5.0 (우수) |
boolean 값을 그대로 출력하던 것이, 조건에 따라 사람이 읽을 수 있는 문장으로 바뀌었어요.
이것이 조건문의 힘입니다!
마무리
오늘 우리가 한 일을 돌아봅시다.
- 산술 연산자(
+,-,*,/,%)로 계산하는 법을 배웠어요 - 비교 연산자(
==,!=,>,<)로 두 값을 비교하고boolean결과를 얻었어요 - 논리 연산자(
&&,||,!)로 여러 조건을 엮었어요 - 대입·증감 연산자(
+=,++)로 코드를 짧게 쓰는 법을 배웠어요 - if/else if/else로 갈림길에서 분기하는 프로그램을 만들었어요
- switch 표현식으로 여러 선택지를 깔끔하게 처리했어요
- 삼항 연산자와 모든 것을 조합해서 인스타그램 프로필 카드를 업그레이드했어요
Day 2에서는 프로그램이 "기억"하는 법을 배웠고, 오늘은 "판단"하는 법을 배웠습니다. 기억하고 판단할 수 있는 프로그램 — 이제 꽤 그럴듯해졌죠?
그런데 아직 하나 부족한 게 있어요.
프로필 카드에서 팔로워 5명의 이름을 출력하고 싶으면, System.out.println()을 5번 복사해야 합니다.
50명이면? 50번 복사해야 해요.
다음 시간에는 이 문제를 해결합니다. 컴퓨터가 가장 잘하는 일, 바로 "반복" 이에요!
과제
[실습] 인스타그램 계정 등급 판정기
팔로워 수를 변수로 선언하고, 다음 기준에 따라 등급을 판정하는 프로그램을 만들어 보세요.
등급 기준:
- 100만 이상: "메가 인플루언서"
- 10만 이상: "매크로 인플루언서"
- 1만 이상: "마이크로 인플루언서"
- 1,000 이상: "나노 인플루언서"
- 1,000 미만: "일반 사용자"
추가 요구사항:
- 등급 판정은
if-else if-else사용 - 등급 이름을
switch표현식으로 한 줄 설명과 매핑 (예: "메가 인플루언서" → "브랜드 협찬이 가능한 수준") - 최종 결과를
등급: OOO (설명)형태로 출력
[실습] 간단한 계산기
두 수와 연산 기호(+, -, *, /)를 각각 변수로 선언하고, switch 표현식으로 결과를 계산하는 프로그램을 만들어 보세요.
요구사항:
- 두 수는
int변수, 연산 기호는String변수로 선언 - 나눗셈에서 0으로 나누는 경우를
if로 먼저 검사 - 지원하지 않는 연산 기호일 때
default로 에러 메시지 출력
생각해볼 주제
1. "==와 equals()는 뭐가 다를까?"
int끼리 비교할 때는 ==를 쓰면 됩니다. 문제없어요.
그런데 String을 ==로 비교하면 예상과 다르게 동작할 때가 있어요.
왜 그런지, equals()라는 메서드와 뭐가 다른지 생각해 보세요.
(힌트: Day 2에서 기본형과 참조형이 다르다고 했었죠?)
2. "if-else를 100개 쓰면 어떻게 될까?"
만약 인스타그램 알림 종류가 100가지라면, if-else if를 100개 써야 할까요?
그렇게 하면 코드가 어떻게 될지 상상해 보세요.
이 문제를 해결하는 더 좋은 방법이 있을 텐데, 어떤 방향일지 자유롭게 떠올려 보세요.
3. "switch에 화살표(->)가 왜 생겼을까?"
옛날 switch 문법에는 break;를 꼭 써야 했고, 빠뜨리면 아래 case까지 실행되는 "fall-through" 문제가 있었어요.
이 문제가 왜 위험한지, 화살표 구문이 이걸 어떻게 해결했는지 생각해 보세요.
✅ 예시 답안정답 보기
🎯 [과제 1 예시 답안] 인스타그램 계정 등급 판정기
팔로워 수에 따라 등급을 나누고, 각 등급에 한 줄 설명을 붙이는 프로그램입니다.
채점 포인트
| 항목 | 배점 | 기준 |
|---|---|---|
if-else if-else 올바른 사용 |
30% | 큰 수부터 비교, 모든 등급 분기 존재 |
switch 표현식으로 설명 매핑 |
30% | 화살표 구문, default 포함 |
| 출력 형식 | 20% | 등급: OOO (설명) 형태 |
| 코드 가독성 | 20% | 변수명 의미 있게, 들여쓰기 정리 |
예시 코드
void main() {
int followerCount = 52000;
// 1단계: if-else if-else로 등급 판정
String grade;
if (followerCount >= 1000000) {
grade = "메가 인플루언서";
} else if (followerCount >= 100000) {
grade = "매크로 인플루언서";
} else if (followerCount >= 10000) {
grade = "마이크로 인플루언서";
} else if (followerCount >= 1000) {
grade = "나노 인플루언서";
} else {
grade = "일반 사용자";
}
// 2단계: switch 표현식으로 설명 매핑
String description = switch (grade) {
case "메가 인플루언서" -> "브랜드 협찬이 가능한 수준";
case "매크로 인플루언서" -> "전문 분야에서 영향력 보유";
case "마이크로 인플루언서" -> "소규모 커뮤니티의 리더";
case "나노 인플루언서" -> "성장 가능성이 높은 단계";
default -> "꾸준히 활동하면 성장할 수 있어요";
};
// 3단계: 결과 출력
System.out.println("팔로워 수: " + followerCount);
System.out.println("등급: " + grade + " (" + description + ")");
}
실행 결과:
팔로워 수: 52000
등급: 마이크로 인플루언서 (소규모 커뮤니티의 리더)
핵심 포인트
if-else if로 범위 기반 분류를 하고, switch로 정해진 값에 대한 매핑을 하는 조합이 핵심입니다.
이 두 가지가 각각 어떤 상황에 적합한지 구분할 수 있으면 충분해요.
followerCount 값을 바꿔가며 모든 등급이 정상 출력되는지 직접 확인해 보세요.
🎯 [과제 2 예시 답안] 간단한 계산기
두 수와 연산 기호를 변수로 선언하고, switch 표현식으로 결과를 계산합니다.
채점 포인트
| 항목 | 배점 | 기준 |
|---|---|---|
switch 표현식 사용 |
30% | 화살표 구문, 4칙연산 모두 구현 |
| 0 나누기 검사 | 25% | if로 사전 검사, 에러 메시지 출력 |
default 처리 |
20% | 지원하지 않는 연산 기호에 대한 메시지 |
| 출력 형식 | 25% | 계산식과 결과를 보기 좋게 출력 |
예시 코드
void main() {
int num1 = 10;
int num2 = 3;
String operator = "/";
// 0으로 나누기 검사
if (operator.equals("/") && num2 == 0) {
System.out.println("오류: 0으로 나눌 수 없습니다.");
return;
}
String result = switch (operator) {
case "+" -> num1 + " + " + num2 + " = " + (num1 + num2);
case "-" -> num1 + " - " + num2 + " = " + (num1 - num2);
case "*" -> num1 + " * " + num2 + " = " + (num1 * num2);
case "/" -> num1 + " / " + num2 + " = " + (num1 / num2)
+ " (나머지: " + (num1 % num2) + ")";
default -> "지원하지 않는 연산입니다: " + operator;
};
System.out.println(result);
}
실행 결과:
10 / 3 = 3 (나머지: 1)
핵심 포인트
if로 예외 상황을 먼저 검사하고, switch로 정상 로직을 처리하는 패턴입니다.
0으로 나누기를 검사하지 않으면 프로그램이 ArithmeticException으로 중단돼요.
operator와 num2 값을 바꿔가며 모든 경우를 테스트해 보세요.
특히 num2 = 0일 때와 operator = "%"처럼 지원하지 않는 기호일 때를 확인하면 좋습니다.
💡 [생각해볼 주제 1 예시 답안] "==와 equals()는 뭐가 다를까?"
문제 상황 요약
int 같은 기본형은 ==로 비교하면 값 자체를 비교합니다.
그런데 String 같은 참조형은 ==로 비교하면 값이 아니라 "같은 객체인지"를 비교해요.
void main() {
String a = "hello";
String b = "hello";
String c = new String("hello");
System.out.println(a == b); // true (같은 곳을 가리킴)
System.out.println(a == c); // false (다른 곳을 가리킴!)
System.out.println(a.equals(c)); // true (내용이 같음)
}
튜터의 가이드 및 해설
Day 2에서 "기본형은 값을 직접 저장하고, 참조형은 값이 있는 위치를 저장한다"고 배웠어요.
==는 저장된 것 자체를 비교합니다.
기본형이면 "값"을 비교하니까 문제없지만, 참조형이면 "위치"를 비교하게 돼요.
a와 b는 Java가 내부적으로 같은 문자열을 재활용해서 같은 위치를 가리키지만, new String("hello")로 만든 c는 새로운 위치에 따로 생성됩니다.
그래서 a == c는 false가 나와요.
문자열의 내용을 비교하려면 equals() 메서드를 써야 합니다.
이건 Day 17(String 심화)에서 자세히 다루지만, 지금부터 습관을 들이면 좋아요.
💡 "기본형은 ==, 문자열은 equals()" — 이 한 줄만 기억하세요.
🎯 면접관을 홀리는 핵심 멘트
"
==는 주소를 비교하고,equals()는 내용을 비교합니다. 기본형은 값 자체가 들어 있어서==로 충분하지만, 참조형은 주소가 들어 있기 때문에 내용 비교에는 반드시equals()를 써야 합니다."
💡 [생각해볼 주제 2 예시 답안] "if-else를 100개 쓰면 어떻게 될까?"
문제 상황 요약
알림 종류가 5개일 때는 if-else if로 충분하지만, 100가지로 늘어나면 코드가 수백 줄이 되고 읽기도 수정하기도 어려워집니다.
튜터의 가이드 및 해설
이 문제는 프로그래밍에서 자주 만나는 확장성(Scalability) 문제입니다. 코드가 5줄일 때는 괜찮아도, 100줄, 1000줄이 되면 관리가 불가능해지죠.
해결 방향은 크게 두 가지가 있어요.
1. 데이터와 로직을 분리한다
알림 종류와 메시지를 if에 하드코딩하는 대신, 데이터 구조에 저장해 놓고 꺼내 쓰는 방법이 있습니다.
Day 19에서 배울 Map이라는 자료구조를 쓰면, 100가지 알림도 데이터만 추가하면 됩니다.
2. 다형성으로 행동을 분리한다 각 알림 종류를 별도의 객체로 만들고, 공통 행동을 인터페이스로 정의하는 방법입니다. Day 13(인터페이스)에서 배울 내용이에요.
지금은 "조건이 많아지면 if를 나열하는 것보다 더 좋은 방법이 있다"는 감각만 가져가세요.
앞으로 배울 배열, 컬렉션, 다형성이 이 문제를 하나씩 해결해 줍니다.
🎯 면접관을 홀리는 핵심 멘트
"조건 분기가 늘어나면 if-else 나열보다 데이터 구조(Map)나 다형성(인터페이스)으로 해결하는 게 유지보수에 유리합니다. 데이터가 바뀌면 코드를 수정하는 게 아니라 데이터만 추가하면 되니까요."
💡 [생각해볼 주제 3 예시 답안] "switch에 화살표(->)가 왜 생겼을까?"
문제 상황 요약
전통 switch 문법은 break;를 빠뜨리면 의도치 않게 아래 case까지 실행되는 "fall-through" 문제가 있었습니다.
튜터의 가이드 및 해설
전통 switch 문법은 이렇게 생겼어요.
// 전통 switch (옛날 방식)
switch (day) {
case 1:
System.out.println("월요일");
break; // 이걸 빠뜨리면?
case 2:
System.out.println("화요일");
break;
default:
System.out.println("기타");
}
break;를 빠뜨리면 case 1을 실행한 뒤 멈추지 않고 case 2까지 실행합니다.
이걸 fall-through라고 하는데, 의도한 게 아니면 찾기 어려운 버그가 됩니다.
화살표 구문(->)은 이 문제를 원천 차단합니다.
-> 오른쪽의 코드를 실행하면 자동으로 멈추고, break가 필요 없어요.
// 화살표 switch (모던 방식)
String label = switch (day) {
case 1 -> "월요일";
case 2 -> "화요일";
default -> "기타";
};
프로그래밍 언어도 시간이 지나면서 실수하기 쉬운 문법을 개선합니다. Java가 20년 넘게 쓰이면서 쌓인 경험이 "화살표 switch"라는 결과로 나온 거예요.
이처럼 언어가 진화하는 이유는 개발자가 실수하기 어렵게 만들기 위해서입니다. 우리가 처음부터 화살표 구문을 배우는 것도 같은 이유예요.
🎯 면접관을 홀리는 핵심 멘트
"전통 switch의 fall-through는 break 누락으로 인한 버그가 흔했습니다. JDK 14의 화살표 switch는 이 문제를 구조적으로 제거하고, switch를 표현식으로 쓸 수 있게 해서 코드도 간결해졌습니다."