2025-02-22T01:33:42
This commit is contained in:
216
docs/06_예외 처리 및 흐름 제어.md
Normal file
216
docs/06_예외 처리 및 흐름 제어.md
Normal file
@@ -0,0 +1,216 @@
|
||||
# **코틀린 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`를 표현식으로 사용할 수 있어
|
||||
**보다 유연하고 직관적인 코드 작성이 가능**하다. 🚀
|
||||
Reference in New Issue
Block a user