# **코틀린 vs 자바: 예외 처리와 흐름 제어 차이점**  

코틀린과 자바는 기본적으로 예외 처리(Exception Handling)와 흐름 제어(Control Flow)를 비슷하게 제공하지만,  
코틀린은 **더 간결한 문법과 강력한 기능**을 제공하여, 예외를 보다 효과적으로 처리하고 흐름 제어를 쉽게 구현할 수 있다.  

이 글에서는 **예외 처리와 흐름 제어**에서 **코틀린과 자바의 차이점**을 비교해 보겠다.  

---

## **1. 예외 처리 (Exception Handling)**  

자바와 코틀린 모두 **`try-catch-finally`** 블록을 지원하지만,  
코틀린에서는 **예외가 표현식(Expression)으로 사용 가능**하고, **Checked Exception이 없다**는 차이가 있다.  

### **1.1. 자바의 예외 처리**
```java
public class JavaExceptionExample {
    public static void main(String[] args) {
        try {
            int result = divide(10, 0);
            System.out.println(result);
        } catch (ArithmeticException e) {
            System.out.println("예외 발생: " + e.getMessage());
        } finally {
            System.out.println("예외 여부와 관계없이 실행됨");
        }
    }

    static int divide(int a, int b) throws ArithmeticException {
        return a / b; // 0으로 나누면 예외 발생
    }
}
```
**출력 결과:**  
```
예외 발생: / by zero
예외 여부와 관계없이 실행됨
```

> **자바의 특징:**  
> - `throws` 키워드를 사용하여 Checked Exception을 선언해야 할 수 있음  
> - `try-catch-finally` 블록 필요  

---

### **1.2. 코틀린의 예외 처리**
```kotlin
fun main() {
    try {
        val result = divide(10, 0)
        println(result)
    } catch (e: ArithmeticException) {
        println("예외 발생: ${e.message}")
    } finally {
        println("예외 여부와 관계없이 실행됨")
    }
}

fun divide(a: Int, b: Int): Int {
    return a / b  // 0으로 나누면 예외 발생
}
```
**출력 결과:**  
```
예외 발생: / by zero
예외 여부와 관계없이 실행됨
```

> **코틀린의 특징:**  
> - `throws` 선언이 필요 없음 (Checked Exception이 없음)  
> - 예외 처리를 **표현식(Expression)으로 사용할 수 있음**  

---

### **1.3. 예외를 반환값으로 사용하는 경우 (코틀린만 가능)**
자바에서는 `try-catch` 블록을 표현식으로 사용할 수 없지만,  
코틀린에서는 **`try` 자체가 값(value)을 반환할 수 있다**.  

```kotlin
val result: Int = try {
    divide(10, 2)
} catch (e: ArithmeticException) {
    -1  // 예외 발생 시 기본값 반환
}
println(result)  // 5
```
> **코틀린의 특징:**  
> - `try-catch` 블록을 값처럼 사용 가능  
> - 예외 발생 시 기본값을 쉽게 설정 가능  

---

## **2. 흐름 제어 (Control Flow) 차이점**  

자바와 코틀린은 기본적인 흐름 제어 구조(`if`, `when`, `for`, `while`)가 유사하지만,  
코틀린은 **표현식(Expression) 기반으로 설계**되어 보다 간결하게 코드를 작성할 수 있다.  

### **2.1. `if` 문법 차이**
#### **자바의 `if-else` (Statement 기반)**
```java
int number = 10;
String result;

if (number % 2 == 0) {
    result = "짝수";
} else {
    result = "홀수";
}

System.out.println(result);
```

#### **코틀린의 `if-else` (Expression 기반)**
```kotlin
val number = 10
val result = if (number % 2 == 0) "짝수" else "홀수"

println(result)
```
> **차이점 요약:**  
> - 자바는 `if-else`가 **Statement(문장)**  
> - 코틀린은 `if-else`가 **Expression(값을 반환할 수 있음)**  

---

### **2.2. `switch-case` vs `when`**
자바에서는 `switch-case` 문을 사용하지만, 코틀린에서는 더 강력한 **`when`**을 제공한다.  

#### **자바의 `switch-case`**
```java
int number = 2;
String result;

switch (number) {
    case 1:
        result = "One";
        break;
    case 2:
        result = "Two";
        break;
    default:
        result = "Unknown";
}

System.out.println(result);
```

#### **코틀린의 `when` (더 강력한 표현 가능)**
```kotlin
val number = 2
val result = when (number) {
    1 -> "One"
    2 -> "Two"
    else -> "Unknown"
}

println(result)
```
> **코틀린의 특징:**  
> - `when`은 **Expression**으로 값을 반환 가능  
> - `break`가 필요 없음  
> - 복합 조건 사용 가능 (`in`, `is` 활용 가능)  

```kotlin
val result = when (number) {
    in 1..5 -> "1~5 범위"
    is Int -> "정수"
    else -> "알 수 없음"
}
```

---

### **2.3. 반복문 차이점**
#### **자바의 `for` 반복문**
```java
List<String> names = List.of("Alice", "Bob", "Charlie");

for (String name : names) {
    System.out.println(name);
}
```
#### **코틀린의 `for` 반복문**
```kotlin
val names = listOf("Alice", "Bob", "Charlie")

for (name in names) {
    println(name)
}
```
> **차이점 요약:**  
> - 코틀린은 **`for (element in collection)`** 형식을 사용  
> - **인덱스가 필요하면 `withIndex()` 활용 가능**  

```kotlin
for ((index, name) in names.withIndex()) {
    println("$index: $name")
}
```

---

## **3. 결론: 코틀린이 더 간결하고 유연하다**  

| 기능 | 자바 | 코틀린 |
|------|------|------|
| 예외 처리 | Checked Exception 있음 | Checked Exception 없음 |
| `try-catch` | Statement (값 반환 불가) | Expression (값 반환 가능) |
| `if-else` | Statement | Expression |
| `switch-case` | `break` 필요 | `when`으로 더 강력하게 가능 |
| `for` 반복문 | `for (item : collection)` | `for (item in collection)` |
| `for` 인덱스 | `for (int i = 0; i < list.size(); i++)` | `for ((index, item) in list.withIndex())` |

코틀린은 **표현식 기반**으로 설계되어 불필요한 문법을 줄이고 **더 간결한 코드**를 작성할 수 있다.  
특히 예외 처리에서 Checked Exception이 없고, `when`과 `try-catch`를 표현식으로 사용할 수 있어  
**보다 유연하고 직관적인 코드 작성이 가능**하다. 🚀