코틀린에서 예외 처리는 어떻게 하나요?

Q: 코틀린에서 예외 처리는 어떻게 하나요?

A: 코틀린에서 예외 처리는 자바와 유사하며, 주로 `try-catch` 블록을 사용해 처리합니다. 기본 문법과 주요 특징은 다음과 같습니다.

---

1. 기본 예외 처리 구문

```kotlin
try {
// 예외가 발생할 가능성이 있는 코드
} catch (e: ExceptionType) {
// 예외 발생 시 처리할 코드
} finally {
// 예외 발생 여부와 관계없이 항상 실행되는 코드 (선택 사항)
}
```

- `try` 블록에는 예외가 발생할 가능성이 있는 코드를 작성합니다.
- `catch` 블록에서 특정 예외 타입을 잡아 처리할 수 있습니다. 여러 개 작성해 다양한 예외를 각각 처리할 수 있습니다.
- `finally` 블록은 예외 발생 여부와 관계없이 반드시 실행됩니다. 자원 해제 등에 주로 쓰입니다.

---

2. 예외 여러 개 처리 예시

```kotlin
try {
val number = "abc".toInt() // NumberFormatException 발생 가능
} catch (e: NumberFormatException) {
println("숫자 형식 예외 처리: ${e.message}")
} catch (e: Exception) {
println("기타 예외 처리: ${e.message}")
}
```

---

3. 코틀린의 특징: Checked Exception 없음

- 코틀린은 자바와 달리 Checked Exception을 강제하지 않습니다. 즉, 메서드 시그니처에 예외 선언(`throws`)이 필요 없으며, 예외 처리를 강제하지 않습니다.
- 예외 처리는 선택사항이나, 안전한 코드 작성을 위해 `try-catch`를 권장합니다.

---
4. 예외를 반환하는 함수 호출에서 결과 처리하기 (`runCatching`)

```kotlin
val result = runCatching {
// 예외가 발생할 수 있는 코드
"123".toInt()
}

result.onSuccess {
println("변환 성공: $it")
}.onFailure {
println("예외 발생: ${it.message}")
}
```

- `runCatching`은 예외 발생 시 `Result` 타입으로 감싸 반환합니다.
- `onSuccess`, `onFailure`로 예외를 간편하게 처리할 수 있습니다.

---

5. 예외 직접 던지기

```kotlin
fun validate(number: Int) {
if (number < 0) throw IllegalArgumentException("음수는 허용되지 않습니다.")
}
```

- `throw` 키워드로 예외를 직접 발생시킬 수 있습니다.
- 함수 선언부에 `throws` 키워드는 사용하지 않으며, 호출자가 반드시 예외 처리를 할 필요는 없습니다.

---

요약

| 항목 | 설명 |
|------------------------|----------------------------------------------|
| 예외 처리 기본 구조 | `try` - `catch` - (`finally`) 블록 |
| 다중 예외 처리 | 여러 `catch` 블록으로 예외 타입별 처리 가능 |
| Checked Exception 여부 | 없음, 예외 처리가 강제되지 않음 |
| 간편한 처리 | `runCatching`과 `Result` 활용 |
| 예외 던지기 | `throw` 키워드 사용, 함수 선언에서 예외 명시 불필요 |

이와 같이 코틀린은 기존 자바보다 더 간결하면서도 예외 처리를 유연하게 지원합니다.

코틀린(Kotlin)에서 예외 처리는 Java와 유사하지만, 몇 가지 차이점이 있습니다.

예외 처리는 프로그램 실행 중 발생할 수 있는 오류를 처리하는 방법으로, 이를 통해 프로그램이 비정상적으로 종료되는 것을 방지하고, 사용자에게 적절한 피드백을 제공할 수 있습니다.

코틀린에서는 `try`, `catch`, `finally` 블록을 사용하여 예외를 처리합니다.

기본 구조 코틀린에서 예외 처리를 위한 기본 구조는 다음과 같습니다: ```kotlin try { // 예외가 발생할 수 있는 코드 } catch (e: ExceptionType) { // 예외가 발생했을 때 실행되는 코드 } finally { // 항상 실행되는 코드 (예외 발생 여부와 상관없이) } ``` 예외 처리의 흐름 1. try 블록 : 예외가 발생할 가능성이 있는 코드를 작성합니다.

이 블록 내에서 예외가 발생하면, 즉시 catch 블록으로 제어가 넘어갑니다.



2. catch 블록 : 발생한 예외를 처리하는 코드입니다.

여러 개의 catch 블록을 사용하여 다양한 예외를 처리할 수 있습니다.



3. finally 블록 : 예외 발생 여부와 관계없이 항상 실행되는 코드입니다.

자원 해제와 같은 작업에 유용합니다.

예외 처리 예제 다음은 코틀린에서 예외 처리를 사용하는 간단한 예제입니다: ```kotlin fun divide(a: Int, b: Int): Int { return try { a / b } catch (e: ArithmeticException) { println("0으로 나눌 수 없습니다.

") 0 // 기본값 반환 } finally { println("divide 함수가 호출되었습니다.

") } } fun main() { val result1 = divide(10,

2) // 정상적인 호출 println("결과: $result1") val result2 = divide(10, 0) // 예외 발생 println("결과: $result2") } ``` 위 예제에서 `divide` 함수는 두 숫자를 나누는 기능을 합니다.

두 번째 인자가 0일 경우 `ArithmeticException`이 발생하며, catch 블록에서 이 예외를 처리하여 사용자에게 경고 메시지를 출력하고 기본값인 0을 반환합니다.

finally 블록은 함수 호출 여부와 관계없이 항상 실행됩니다.

여러 개의 catch 블록 코틀린에서는 여러 개의 catch 블록을 사용하여 다양한 예외를 처리할 수 있습니다.

예를 들어: ```kotlin fun parseInt(value: String): Int { return try { value.toInt() } catch (e: NumberFormatException) { println("잘못된 숫자 형식입니다.

") 0 } catch (e: Exception) { println("알 수 없는 오류가 발생했습니다.

") 0 } } ``` 위의 예제에서는 `NumberFormatException`과 일반적인 `Exception`을 처리하는 두 개의 catch 블록이 있습니다.

특정 예외를 먼저 처리하고, 그 외의 예외는 일반 catch 블록에서 처리합니다.

사용자 정의 예외 코틀린에서는 사용자 정의 예외를 만들 수 있습니다.

이를 통해 특정한 상황에서 발생하는 예외를 정의하고 처리할 수 있습니다.

사용자 정의 예외는 `Exception` 클래스를 상속받아 생성합니다.

```kotlin class CustomException(message: String) : Exception(message) fun riskyOperation() { throw CustomException("사용자 정의 예외 발생!") } fun main() { try { riskyOperation() } catch (e: CustomException) { println(e.message) } } ``` 위의 예제에서 `CustomException`이라는 사용자 정의 예외를 만들고, `riskyOperation` 함수에서 이 예외를 발생시킵니다.

main 함수에서는 이 예외를 catch 블록에서 처리합니다.

결론 코틀린에서 예외 처리는 프로그램의 안정성을 높이는 중요한 요소입니다.

`try`, `catch`, `finally` 블록을 통해 예외를 효과적으로 처리하고, 사용자에게 유용한 피드백을 제공할 수 있습니다.

또한, 사용자 정의 예외를 통해 특정한 상황에 맞는 예외 처리를 구현할 수 있습니다.

이러한 기능들을 적절히 활용하여 코틀린 프로그램의 품질을 향상시킬 수 있습니다.