[Java] 연산자와 조건문

✅ 산술 연산자

1️⃣ 기본적인 사칙 연산

int a = 10;
int b = 3;

// 기본 사칙연산
int sum = a + b;
System.out.println("sum = " + sum);

int sub = a - b;
System.out.println("sub = " + sub);

int mul = a * b;
System.out.println("mul = " + mul);

2️⃣ 나눗셈에서 주의할 점

• 정수 나눗셈: 정수끼리 나누면 소수점 이하가 버려짐.
• 실수 나눗셈: 소수점을 유지하려면 실수와 함께 연산해야함.

int a = 10;
int b = 3;

// 정수 나눗셈 (소수점 버림)
int div = a / b;
System.out.println("div = " + div); // 결과: 3

// 실수 나눗셈 (소수점 유지)
double div2 = a / 3.0;
System.out.println("div2 = " + div2); // 결과: 3.333...

3️⃣ 모듈러 연산자 (%) – 나머지 구하기

모듈러 연산자는 나머지 계산에 유용.

int mod = 10 % 3;
System.out.println("mod = " + mod); // 나머지: 1

int mod2 = 15 % 4;
System.out.println("mod2 = " + mod2); // 나머지: 3

int mod3 = 20 % 7;
System.out.println("mod3 = " + mod3); // 나머지: 6

 

활용 예시:

• 시간 연산:
  현재 시간이 10시일 때, 5시간 후는 몇 시일까요?
  (10 + 5) % 12 = 3
• 짝수/홀수 판별:
  6 % 2 = 0; // 짝수
  7 % 2 = 1; // 홀수

 

✅ 대입 연산자

1️⃣ 대입 연산자 (=)

• 변수에 값을 할당하는 데 사용되며, 연산 순서상 가장 마지막에 수행.

int num = 5;
System.out.println("변수 num의 값: " + num); // 출력: 5

 

2️⃣ 복합 대입 연산자 (+=, -=, *=, /=, %=)

• 누적 계산 시 자주 사용됩니다.
• 예를 들어, num += 3; 은 num = num + 3; 과 동일.

int num = 5;
num += 3;  // num = num + 3;
System.out.println("+= 결과: " + num); // 출력: 8

num -= 2;  // num = num - 2;
System.out.println("-= 결과: " + num); // 출력: 6

num *= 2;  // num = num * 2;
System.out.println("*= 결과: " + num); // 출력: 12

num /= 3;  // num = num / 3;
System.out.println("/= 결과: " + num); // 출력: 4

num %= 3;  // num = num % 3;
System.out.println("%= 결과: " + num); // 출력: 1

 

✅ 증감 연산자

1️⃣ 증감 연산자의 기본 활용

• 변수의 값을 1씩 증가(++) 또는 감소(--)
• 전위 연산 (++i)는 연산 후 값을 사용
• 후위 연산 (i++)은 값 사용 후 연산

int num = 1;
System.out.println("num: " + num);  // 출력: 1
num++;  // num = num + 1;
System.out.println("num++ 실행 후: " + num);  // 출력: 2

num--;  // num = num - 1;
System.out.println("num-- 실행 후: " + num);  // 출력: 1

2️⃣ 전위 연산 vs 후위 연산

• 전위 연산 (++i):
  연산 후에 값이 사용됩니다.
   

  int a = 5;
  System.out.println("++a: " + (++a));  // 출력: 6 (먼저 증가 후 출력)
  System.out.println("현재 a 값: " + a);  // 출력: 6

• 후위 연산 (i++):
  값이 사용된 후에 연산됩니다.
   

  int b = 5;
  System.out.println("b++: " + (b++));  // 출력: 5 (출력 후 증가)
  System.out.println("현재 b 값: " + b);  // 출력: 6

 

✅ 비교 연산자

두 값이 같거나 다른지, 혹은 크고 작은지를 비교할 때 사용

1️⃣ 같음 연산자 (==)

• 두 값이 같으면 true, 다르면 false를 반환합니다.

System.out.println("10 == 10: " + (10 == 10)); // 출력: true

 

2️⃣ 다름 연산자 (!=)

• 두 값이 다르면 true, 같으면 false를 반환합니다.

System.out.println("10 != 5: " + (10 != 5)); // 출력: true

 

3️⃣ 크기 비교 연산자 (>, <, <=, >=)

System.out.println("10 < 5: " + (10 < 5));   // 출력: false
System.out.println("10 >= 10: " + (10 >= 10)); // 출력: true
System.out.println("10 <= 5: " + (10 <= 5));   // 출력: false

 

비교 연산자 정리

연산자	설명	예제	결과
==	두 값이 같으면 true	10 == 10	true
!=	두 값이 다르면 true	10 != 5	true
>	왼쪽 값이 크면 true	10 > 5	true
<	왼쪽 값이 작으면 true	10 < 5	false
>=	왼쪽 값이 크거나 같으면 true	10 >= 10	true
<=	왼쪽 값이 작거나 같으면 true	10 <= 5	false

 

✅ 논리 연산자

여러 조건을 결합하여 참/거짓을 판단할 때 사용.

1️⃣ AND 연산자 (&&)

• 두 조건이 모두 참일 때만 true를 반환.

System.out.println("true && true: " + (true && true));   // 출력: true
System.out.println("true && false: " + (true && false)); // 출력: false

int age = 20;
boolean isStudent = true;
System.out.println(age > 18 && isStudent); // 출력: true

 

2️⃣ OR 연산자 (||)

• 조건 중 하나라도 참이면 true를 반환.

System.out.println("true || false: " + (true || false)); // 출력: true
System.out.println("false || false: " + (false || false)); // 출력: false

int age = 20;
boolean isStudent = true;
System.out.println(age > 18 || isStudent); // 출력: true

3️⃣ NOT 연산자 (!)

• 논리값을 반전.

System.out.println("!true: " + (!true));  // false
System.out.println("!false: " + (!false)); // true


int age = 20;
boolean isStudent = true;
System.out.println(age > 18 && isStudent); // true

 

논리 연산자 정리

연산자	설명	예제	결과
&& (AND)	두 조건 모두 참이면 true	true && true	true
		true && false	false
		false && true	false
|| (OR)	하나라도 참이면 true	true || true	true
		true || false	true
		false || true	true
		false || false	false
! (NOT)	참이면 거짓, 거짓이면 참으로 변경	!true	false
		!false	true

 

✅ 연산자 우선순위

연산자들이 어떤 순서로 평가되는지 이해하면 코드의 의도를 명확하게 표현할 수 있음.
혼란스러울 경우 괄호 ()를 사용해 우선순위를 명확하게 해주는 것이 좋음.

1️⃣ 산술 연산자 우선순위

System.out.println(10 - 3 * 2); 
// 실행 순서: 10 - (3 * 2) → 10 - 6 = 4

2️⃣ 기본 연산자 우선순위 (산술 → 비교 → 논리 → 대입)

boolean flag = 10 + 5 > 12 && true;
System.out.println(flag);
// 실행 순서: (10 + 5) > 12 && true 
// → 15 > 12 && true 
// → true && true → true

3️⃣ 비교와 산술 연산자 우선순위

System.out.println(10 - 3 > 5 + 1);
// 실행 순서: (10 - 3) > (5 + 1) → 7 > 6 → true

 

4️⃣ 논리 연산자 우선순위 (! → && → ||)

boolean result = true || false && !false;
// 실행 순서: true || (false && false) → true || false → true

 

5️⃣ 복합 예시

System.out.println(10 / 2 + 3 * 2 > 10 || false);
// 실행 순서: ((10 / 2) + (3 * 2)) > 10 || false
// → (5 + 6) > 10 || false → 11 > 10 || false → true || false → true

System.out.println(5 + 3 > 2 * 4 && 10 % 3 == 1);
// 실행 순서: (5 + 3) > (2 * 4) && (10 % 3) == 1
// → 8 > 8 && 1 == 1 → false && true → false

결론: 우선순위를 명확하게 하기 위해 괄호를 적극 활용

 

✅ 문자열 비교

실무에서 문자열 비교 시에는 == 를 사용하지 않고 .equals() 메서드를 사용.
== 는 객체의 메모리 주소를 비교하기 때문에, 문자열의 실제 값을 비교하려면 .equals() 를 사용해야함.

 

String text1 = "Hello";
String text2 = "Hello";
boolean isEqual = text1.equals(text2);
System.out.println("text1과 text2가 같은가? " + isEqual);
// 출력: text1과 text2가 같은가? true

왜 .equals() 를 사용해야 할까요?
== 는 문자열 객체의 주소를 비교하지만, .equals() 는 두 문자열의 내용을 비교.
따라서 문자열 비교에는 항상 .equals() 를 사용

 

 

✅ 조건문

조건문은 프로그램 내에서 주어진 조건에 따라 어떤 코드 블록을 실행할지 결정하는 제어 구조.

✅ if 문

조건 수식의 결과가 참(true) 인 경우에만 특정 명령문이 실행됩니다.

기본 구조

if (조건수식) {
    명령문; // 조건이 참일 때 실행
}

• 조건이 참인 경우
  예:

  if (1 < 2) { // true
      명령문; // 실행됨 ✅
  }

• 조건이 거짓인 경우
  예:

  if (2 < 1) { // false
      명령문; // 실행되지 않음 ❌
  }

   

✅ if 문 실습 예제

초록불일 때 “건너세요!” 문자열을 출력하는 예제.

public class Main {
    public static void main(String[] args) {
        String light = "초록불"; // (1) light 변수에 "초록불" 저장

        // (2) 만약 light가 "초록불"과 같다면?
        if (light.equals("초록불")) {
            System.out.println("건너세요!"); // (3) 조건이 참이면 실행됨
        }
        // (4) 이후 코드 계속 진행
    }
}

 

실행 흐름 (if 문):

• 조건이 참(true) 일 때:
  1. light 변수에 값 저장
  2. 조건 확인 → 참이면 (3) 실행
  3. 다음 코드 진행
• 조건이 거짓(false) 일 때:
  1. light 변수에 값 저장
  2. 조건 확인 → 거짓이면 (3)은 건너뛰고 (4) 다음 코드 진행

 

✅ if-else 문

단순 if 문은 조건이 참일 때만 동작하므로, 초록불이 아닐 때의 처리는 if 문 밖에서 하면 모두 출력되어 버리는 문제가 있음.

따라서 if-else 문을 사용하여 조건이 거짓일 때 다른 동작을 정의할 수 있음.

예제

public class Main {
    public static void main(String[] args) {
        String light = "초록불"; // (1)

        // (2) 만약 light가 "초록불"과 같다면?
        if (light.equals("초록불")) {
            System.out.println("건너세요!"); // (3) 초록불일 때 실행
        } else {
            System.out.println("멈추세요!"); // (4) 초록불이 아닐 때 실행
        }
        // (5) 이후 코드 계속 진행
    }
}

 

실행 흐름:

• 조건이 참(true)인 경우: (1) → (2) → (3) 실행 → (5) 진행
• 조건이 거짓(false)인 경우: (1) → (2) → (4) 실행 → (5) 진행

 

✅ else-if 문

여러 조건을 처리해야 하는 경우, if-else 문만으로는 부족함.
예를 들어, 신호등의 불빛이 초록불, 노란불, 빨간불 세 가지 상태에 따라 다르게 동작하게 하려면 else-if 문을 사용.

예제

public class Main {
    public static void main(String[] args) {
        String light = "초록불"; // (1)

        if (light.equals("초록불")) {           // (2)
            System.out.println("건너세요!");     // (3) 초록불일 때
        } else if (light.equals("노란불")) {    // (4)
            System.out.println("주의하세요!");   // (5) 노란불일 때
        } else {
            System.out.println("멈추세요!");     // (6) 그 외 (빨간불 등)
        }
        // (7) 이후 코드 진행
    }
}

 

 

실행 흐름:

• 초록불: (1) → (2) 참 → (3) 실행 → (7) 진행
• 노란불: (1) → (2) 거짓 → (4) 참 → (5) 실행 → (7) 진행
• 빨간불 또는 다른 상태: (1) → (2) 거짓 → (4) 거짓 → else (6) 실행 → (7) 진행

참고: "파란불"과 같이 예상하지 못한 값이 들어오면 else 문으로 처리.

 

✅ Switch 문

Switch 문은 단일 값에 따라 여러 동작을 선택적으로 실행할 때 사용.
조건식 대신 단일값만 허용하며, 각 case마다 break를 사용하여 다음 case로의 fall-through 현상을 방지.

기본 구조

switch (단일값) {
    case 값1:
        // 값1일 때 실행할 코드
        break;
    case 값2:
        // 값2일 때 실행할 코드
        break;
    default:
        // 위의 case와 일치하지 않을 때 실행할 코드
}

 

예제 1

public class SwitchNumber {
    public static void main(String[] args) {
        int number = 1;

        switch (number) {
            case 1:
                System.out.println("1 입니다.");
                break;
            case 2:
                System.out.println("2 입니다.");
                break;
            default:
                System.out.println("1 도 아니고 2도 아닙니다.");
        }
    }
}

 

 

예제 2: fall-through 현상 주의

break 문을 생략하면 다음 case가 실행됩니다.

public class SwitchNumber {
    public static void main(String[] args) {
        int number = 1;

        switch (number) {
            case 1:
                System.out.println("1 입니다.");
                // break;  // break를 생략하면 아래 case도 실행됨
            case 2:
                System.out.println("2 입니다.");
                break;
            default:
                System.out.println("1 도 아니고 2도 아닙니다.");
        }
    }
}

팁: 항상 각 case 끝에 break를 추가하여 의도하지 않은 fall-through를 방지.