118 lines
4.2 KiB
Markdown
118 lines
4.2 KiB
Markdown
# **코틀린 vs 자바: 기본 문법 비교**
|
|
|
|
코틀린은 자바 개발자가 배우기 쉬운 언어이지만, 몇 가지 중요한 문법적 차이가 있다. 이 글에서는 **변수 선언**, **null 안정성**, **타입 추론**을 중심으로 코틀린과 자바의 차이점을 비교해보겠다.
|
|
|
|
## **1. 변수 선언: `val`과 `var`**
|
|
|
|
자바에서 변수를 선언할 때는 반드시 데이터 타입을 명시해야 한다.
|
|
|
|
### **자바의 변수 선언**
|
|
```java
|
|
int x = 10; // 변경 가능한 변수
|
|
final int y = 20; // 변경 불가능한 변수 (상수)
|
|
```
|
|
|
|
코틀린에서는 `var`와 `val` 키워드를 사용하여 변수를 선언한다.
|
|
|
|
- `var` → **변경 가능**(mutable) 변수
|
|
- `val` → **변경 불가능**(immutable) 변수 (자바의 `final`과 유사)
|
|
|
|
### **코틀린의 변수 선언**
|
|
```kotlin
|
|
var x = 10 // 변경 가능
|
|
val y = 20 // 변경 불가능 (한 번만 할당 가능)
|
|
```
|
|
|
|
> **차이점 요약**
|
|
> - 코틀린에서는 **데이터 타입을 생략**할 수 있다. (타입 추론 덕분)
|
|
> - `val`은 `final`과 유사하지만, **런타임 상수는 아님**. (즉, `val` 변수는 런타임에서 초기화 가능)
|
|
|
|
---
|
|
|
|
## **2. 널 안정성 (Null Safety)**
|
|
|
|
자바에서는 `null` 값이 있을 경우 `NullPointerException(NPE)`이 발생할 수 있다.
|
|
|
|
### **자바의 null 처리**
|
|
```java
|
|
String name = null; // 컴파일러가 오류를 발생시키지 않음
|
|
System.out.println(name.length()); // NullPointerException 발생 가능
|
|
```
|
|
|
|
코틀린에서는 **기본적으로 모든 변수는 null을 허용하지 않는다.** 만약 null을 허용하려면 `?`를 붙여야 한다.
|
|
|
|
### **코틀린의 null 처리**
|
|
```kotlin
|
|
var name: String = "Kotlin" // null 허용 X
|
|
// name = null // 컴파일 오류 발생
|
|
|
|
var nullableName: String? = "Kotlin" // null 허용 O
|
|
nullableName = null // 가능
|
|
```
|
|
|
|
#### **안전한 null 처리 방법**
|
|
1. **안전 호출 연산자 (`?.`)**
|
|
```kotlin
|
|
println(nullableName?.length) // null이면 null 반환, 아니면 length 값 반환
|
|
```
|
|
2. **엘비스 연산자 (`?:`)**
|
|
```kotlin
|
|
val length = nullableName?.length ?: 0 // null이면 기본값(0) 반환
|
|
```
|
|
3. **강제 호출 연산자 (`!!`)**
|
|
```kotlin
|
|
println(nullableName!!.length) // null이면 강제 NPE 발생
|
|
```
|
|
|
|
> **차이점 요약**
|
|
> - 코틀린은 기본적으로 모든 변수에 대해 null을 허용하지 않음.
|
|
> - `?`를 붙이면 null 허용 변수로 선언 가능.
|
|
> - 안전한 호출 (`?.`), 기본값 제공 (`?:`), 강제 호출 (`!!`) 등의 문법을 제공.
|
|
|
|
---
|
|
|
|
## **3. 타입 추론 (Type Inference)**
|
|
|
|
자바에서는 변수 선언 시 반드시 타입을 명시해야 한다.
|
|
|
|
### **자바의 타입 선언**
|
|
```java
|
|
String message = "Hello, Java!";
|
|
int number = 42;
|
|
```
|
|
|
|
코틀린에서는 타입을 **컴파일러가 자동으로 추론**하므로, 명시적으로 쓸 필요가 없다.
|
|
|
|
### **코틀린의 타입 추론**
|
|
```kotlin
|
|
val message = "Hello, Kotlin!" // String으로 추론
|
|
var number = 42 // Int로 추론
|
|
```
|
|
|
|
하지만 타입을 명확하게 하고 싶다면 명시적으로 적을 수도 있다.
|
|
|
|
```kotlin
|
|
val message: String = "Hello, Kotlin!"
|
|
var number: Int = 42
|
|
```
|
|
|
|
> **차이점 요약**
|
|
> - 코틀린은 **타입을 생략 가능**(컴파일러가 추론).
|
|
> - 하지만 필요하면 타입을 명시할 수도 있음.
|
|
|
|
---
|
|
|
|
## **정리: 자바 vs 코틀린 비교**
|
|
|
|
| 기능 | 자바 | 코틀린 |
|
|
|------|------|--------|
|
|
| **변수 선언** | `int x = 10;`<br>`final int y = 20;` | `var x = 10`<br>`val y = 20` |
|
|
| **null 안정성** | `String name = null;` (가능하지만 NPE 위험) | `var name: String? = null` (null 허용 여부를 명확히 지정) |
|
|
| **안전한 null 처리** | `if (name != null) { name.length(); }` | `name?.length ?: 0` |
|
|
| **타입 추론** | `String message = "Hello";` | `val message = "Hello"` (타입 생략 가능) |
|
|
|
|
---
|
|
|
|
코틀린은 **더 간결하고 안전한 코드**를 작성할 수 있도록 설계된 언어다. 자바 개발자가 코틀린을 배우면 **불필요한 코드가 줄어들고**, **NPE 걱정 없이 더 안전한 프로그래밍**이 가능해진다.
|
|
|
|
다음에는 어떤 코틀린 개념을 비교해볼까? |