반응형
지난 시간에는 코틀린이라고 하는 프로그래밍 언어가 가지고 있는 특성 위주로 공부해보았습니다. 이번 시간에는 코틀린에서 사용하는 기본적인 문법에 대해서 깊게 파고드는 시간 가져보겠습니다.
Package Definition and Imports
패키지 선언은 소스 파일의 최상단에 위치해야 합니다.
package my.demo
import kotlin.text.*
// ...
파일 디렉터리와 패키지를 일치시킬 필요는 없습니다. 소스 파일은 파일 시스템에 임의로 배치할 수 있습니다.
Packages and Imports
소스 파일은 패키지 선언과 같은 레벨에서 시작할 수 있습니다. 다음 예제를 참고해주세요.
package org.example
fun printMessage() { /*...*/ }
class Message { /*...*/ }
// ...
위 패키지에서는 원본 파일의 클래스 및 기능과 같은 모든 내용이 포함됩니다. 따라서 위의 예제에서 printMessage 메서드의 전체 이름은 org.example.printMessage 이고, Message 클래스의 전체 이름은 org.example.Message 입니다.
Default Imports
코틀린에서는 개발을 더 쉽게 하고 일련의 공통 기능을 제공하기 위해 특정 패키지들을 모든 코틀린 파일에 기본적으로 가져옵니다. 다음은 이러한 기본 가져오기에 대해 더 자세히 살펴본 내용입니다.
- kotlin.* : Kotlin을 위한 루트 패키지이며 Kotlin 프로그램에서 일반적으로 사용되는 필수 클래스와 함수를 포함합니다.
- Any: Kotlin의 모든 null이 불가능한 유형에 대한 Root 클래스입니다.
- Unit: 값이 없는 것을 나타내는 유형(Java의 void와 유사)입니다.
- String: 텍스트를 처리하기 위한 클래스입니다.
- Int, Long, Double: Primitive 데이터 유형에 대한 클래스입니다.
- let, apply, run, also, takeIf, takeUnless 등과 같은 기본 연산을 위한 확장 기능을 제공합니다.
- kotlin.annotation.* : 이 패키지는 코틀린에서 주석을 정의하고 작업하기 위한 클래스와 인터페이스를 포함합니다. 주요 요소는 다음과 같습니다.
- Annotation: 모든 annotation에 대한 기본 클래스입니다.
- Target: Annotation을 달 수 있는 가능한 요소 종류를 지정합니다
- Retention: Annotation을 보존할 기간을 지정합니다
- kotlin.collections.* : 이 패키지에는 list, set, map 과 같은 컬렉션을 작업하기 위한 클래스와 함수가 포함되어 있습니다.
- List, MutableList: 순서화된 컬렉션입니다.
- Set, MutableSet: 순서화되지 않은 컬렉션입니다.
- Map, MutableMap: Key-Value 쌍의 모음입니다.
- filter, map, reduce, fold ,groupBy 와 같은 컬렉션에 대한 extension 기능들을 포함하고 있습니다.
- kotlin.comparisons.* : 이 패키지에는 개체를 비교하기 위한 함수와 클래스가 포함되어 있습니다.
- Comparable: 클래스에 대한 자연스러운 순서를 정의하는 인터페이스입니다.
- compareBy, thenBy, maxOf, minOf 등과 같은 비교를 위한 함수들 또한 포함되어 있습니다.
- kotlin.io.* : 이 패키지는 입력 및 출력 작업을 위한 클래스와 기능을 제공합니다.
- File: 파일 작업을 처리하기 위한 클래스입니다.
- BufferedReader, BufferedWriter: 버퍼링된 I/O 에 대한 클래스입니다.
- 이외에 파일 읽기 및 쓰기, 표준 입출력 등을 위한 기능을 제공합니다.
- kotlin.ranges.* : 이 패키지는 범위를 다루는 클래스와 함수를 포함합니다.
- IntRange, LongRange, CharRange: 각각 Int, Long 및 문자 범위를 나타내는 클래스입니다.
- 범위 생성 및 조작을 위한 함수 또한 제공합니다. (rangeTo, until, step etc...)
- kotlin.sequences.* : 이 패키지는 Lazy Evaluated Collection 를 처리하기 위한 클래스와 함수를 제공합니다. 이는 필요할 때만 값을 계산하므로 메모리 효율적이며, 특히 큰 데이터셋을 처리할 때 유용합니다. 주요 구성 요소는 다음과 같습니다.
- Sequence: Sequence 의 메인 인터페이스입니다.
- asSequence, sequence, generateSequence 와 같은 기능들을 통해 시퀀스를 생성하고 조작할 수 있습니다.
- 스퀀스에 대한 Extension 기능들은 컬렉션과 유사한 모습과 특징을 띄고 있습니다.
- kotlin.text.* : 이 패키지에는 텍스트 작업을 위한 클래스와 함수가 포함되어 있습니다.
- StringBuilder: 변경 가능한 문자열을 만들고 조작하는 클래스입니다.
- substring, replace, split, toUpperCase, toLowerCase 등등의 기능을 하는 함수들이 있습니다.
- Regex 와 같은 클래스를 통한 정규식 기능들을 제공합니다.
Program Entry Point
코틀린 애플리케이션의 엔트리 포인트는 main 함수입니다.
fun main() {
println("Hello world!")
}
다른 형태로는 Array 형태의 String 인수를 가지고 있습니다.
fun main(args: Array<String>) {
println(args.contentToString())
}
JVM 은 도대체 어떻게 main 함수를 찾고 실행할 수 있는가?
JVM이 main 함수를 찾고 실행하는 과정에 대해서 컴파일 / 런타임 단계로 구분해서 파악해보겠습니다.
- 컴파일 단계
- 소스 코드 작성
- 개발자가 main 함수가 포함된 코틀린 소스 코드를 작성합니다.
- 컴파일
- 코틀린 컴파일러(kotlinc) 는 코틀린 소스 코드를 바이트 코드로 컴파일합니다. 이 바이트코드는 JVM이 이해할 수 있는 형식입니다.
- 컴파일러는 main 함수가 포함된 클래스 파일 (.class) 을 생성합니다.
- 소스 코드 작성
- 실행 단계
- JVM 초기화
- 프로그램 실행 시, JVM 은 초기화 과정을 거칩니다. 이 과정에서 클래스 로더가 사용됩니다.
- 클래스 로더는 클래스 파일들을 로드하고, 이를 JVM 내의 메모리 영역에 배치합니다.
- 클래스 로딩 및 링크
- JVM 은 메인 클래스(main class) 를 로드합니다. 메인 클래스는 main 함수가 정의된 클래스를 의미합니다.
- 로드된 클래스는 링크 단계(Linking stage) 를 거칩니다. 이 단계에서 클래스의 바이트 코드는 Verification(검증), Preparation(준비), Resolution(해석) 과정들을 통해 실행 준비를 갖추게 됩니다.
- 메인 함수 호출
- 클래스 로딩이 완료되면, JVM 은 메인 클래스에서 main 함수를 찾습니다.
- main 함수는 다음과 같은 Signature 를 가져야 합니다(아래 코드 참조). 이는 자바의 표준 메인 함수 시그니처와 동일한데, 코틀린에서는 컴파일러가 이 형태로 변환해줍니다.
- main 함수가 발견되면, JVM 은 이를 호출하여 프로그램의 실행을 시작합니다.
- JVM 초기화
public static void main(String[] args)Functions
코틀린의 함수(Function)는 프로그램의 기본 구성 요소로, 특정 작업을 수행하는 코드 블록을 정의합니다. 코틀린의 함수는 선언, 호출, 고차 함수, 람다 함수 등의 다양한 기능을 제공하며, 이는 코틀린의 강력한 기능성의 기초가 됩니다.
함수 선언
- 코틀린에서 함수를 선언하는 기본 형태는 다음과 같습니다.
fun 함수이름(매개변수: 타입): 반환타입 {
// 함수 본문
}- 두 숫자를 더하는 함수는 다음과 같이 선언할 수 있습니다.
fun add(a: Int, b: Int): Int {
return a + b
}
함수 호출
- 함수를 호출할 때는 함수 이름과 괄호를 사용합니다. 필요한 경우 매개변수를 전달합니다.
val result = add(3, 5)
println(result) // 8
단일 표현식 함수
- 코틀린에서는 단일 표현식으로 함수를 정의할 수 있습니다. 이 경우 반환 타입을 생략할 수 있으며, 코틀린이 자동으로 추론합니다.
fun multiply(a: Int, b: Int) = a * b
기본 인자 값
- 함수 매개변수에 기본 값을 설정할 수 있어, 함수 호출 시 생략된 매개변수에 대해 기본 값이 사용됩니다.
fun greet(name: String = "World") {
println("Hello, $name!")
}
greet() // Hello, World!
greet("Kotlin") // Hello, Kotlin!
가변 인자
- 함수에 가변 개수의 인자를 전달할 수 있습니다. 이를 위해 vararg 키워드를 사용합니다.
fun sum(vararg numbers: Int): Int {
return numbers.sum()
}
val result = sum(1, 2, 3, 4, 5)
println(result) // 15
고차 함수와 람다 함수
- 코틀린은 고차 함수를 지원하며, 이는 함수를 매개변수로 받거나 반환하는 함수입니다. 람다 함수는 이러한 고차 함수와 함께 자주 사용됩니다.
fun operate(a: Int, b: Int, operation: (Int, Int) -> Int): Int {
return operation(a, b)
}
val sum = operate(3, 4) { x, y -> x + y }
println(sum) // 7
val multiply = operate(3, 4) { x, y -> x * y }
println(multiply) // 12
익명 함수
- 코틀린에서는 람다 외에도 익명 함수를 사용할 수 있습니다.
- 익명 함수란 이름이 없는 함수로, 이름을 가지지 않고 직접 정의되어 사용되는 함수입니다.
val add = fun(a: Int, b: Int): Int {
return a + b
}
println(add(3, 4)) // 7
멤버 함수와 확장 함수
- 클래스 내부에서 정의된 함수는 멤버 함수 (member function) 이라고 하며, 특정 클래스에 대해 추가적인 함수를 정의할 때는 확장 함수 (extension function)을 사용할 수 있습니다.
class Calculator {
// 멤버 함수
fun add(a: Int, b: Int): Int {
return a + b
}
}
// 확장 함수
fun Calculator.multiply(a: Int, b: Int): Int {
return a * b
}
val calculator = Calculator()
println(calculator.add(3, 4)) // 7
println(calculator.multiply(3, 4)) // 12
함수 타입
- 코틀린에서는 함수 자체도 타입으로 취급됩니다.
- 함수 타입은 매개변수의 타입과 반환 타입으로 정의됩니다.
// 예시 함수 정의
fun add(a: Int, b: Int): Int {
return a + b
}
val operation: (Int, Int) -> Int = ::add
println(operation(3, 4)) // 7
Variables
변수 선언
- 코틀린에서는 두 가지 형태의 변수를 선언할 수 있습니다: val / var
- val (value): 읽기 전용 변수로, 한 번 값을 할당하면 변경할 수 없습니다. 이를 통해 불변성을 유지할 수 있습니다.
val name: String = "Kotlin"
// name = "Java" // 오류 발생: val로 선언된 변수는 값을 변경할 수 없습니다.- var (variable): 가변 변수로, 값을 여러 번 변경할 수 있습니다.
var count: Int = 10
count = 20
타입 추론
- 코틀린은 변수 선언 시 타입을 명시하지 않아도, 초기 값을 기반으로 변수의 타입을 추론할 수 있습니다.
val language = "Kotlin" // String 타입으로 추론
var version = 2.0 // Double 타입으로 추론
지연 초기화 (Late Initialization)
- 코틀린에서는 lateinit 키워드를 사용하여 나중에 초기화될 수 있는 var 변수를 선언할 수 있습니다. 이는 주로 클래스의 프로퍼티에 사용됩니다.
lateinit var description: String
fun initialize() {
description = "Kotlin 2.0.0"
}
Nullable Variable
- 코틀린에서는 Nullable Variable 을 명시적으로 선언해야 합니다.
- 변수 타입 뒤에 ? (elvis operator) 를 붙여 널 가능성을 표시합니다.
var nullableName: String? = null
nullableName = "Kotlin"
상수
- const val 키워드를 사용하여 상수를 선언할 수 있습니다. 이는 객체나 클래스 내부에서만 사용 가능합니다.
const val MAX_COUNT = 100
스마트 캐스트
- 코틀린에서는 스마트 캐스트(Smart Cast) 를 사용하여 타입 변환을 자동으로 처리할 수 있습니다.
- 이는 주로 조건문 내에서 사용됩니다.
fun getStringLength(obj: Any): Int? {
if (obj is String) {
return obj.length // obj가 String으로 스마트 캐스트됨
}
return null
}
Getter and Setter
- 클래스의 Property 에는 기본 Getter, Setter 가 자동으로 제공됩니다.
- 커스텀 Getter, Setter 를 정의할 수도 있습니다.
var size: Int = 0
get() = field
set(value) {
field = value
}
Backing Fields
- 코틀린에서 Backing Fields 는 Property 의 값을 저장하는 숨겨진 필드입니다.
- 백킹 필드는 속성의 접근자(Getter/Setter) 내에서만 field 식별자를 통해 참조할 수 있습니다.
- 백킹 필드는 다음 경우에 생성됩니다.
- 속성이 기본 Getter / Setter 구현을 사용하는 경우
- 커스텀 접근자에서 field 식별자를 참조하는 경우
- 다음과 같은 경우에는 백킹 필드가 생성되지 않습니다. 속성의 값을 저장하지 않고 호출 때마다 매번 계산합니다.
val isEmpty: Boolean
get() = this.size == 0- 다음과 같은 경우에는 백킹 필드가 생성됩니다. 이 경우 field 식별자를 사용하여 백킹 필드를 참조하고 있으므로, 코틀린 컴파일러는 name 속성을 위한 백킹 필드를 생성합니다.
var name: String = "Default"
get() = field
set(value) {
field = value
}- 백킹 필드가 필요하지 않다면, 커스텀 접근자에서 직접 다른 속성을 참조하거나, 값을 계산하는 방식으로 구현할 수 있습니다.
Backing Properties
- Backing Properties 는 기본 Backing Field 가 제공하는 기능으로는 충분하지 않은 경우에 사용할 수 있습니다.
private var _table: Map<String, Int>? = null
public val table: Map<String, Int>
get() {
if (_table == null) {
_table = HashMap()
}
return _table ?: throw AssertionError("Set to null by another thread")
}- 위 예제에서는 _table 이라는 private property 를 통해 table 이라는 public property 를 구현합니다. 이 방식으로 보다 복잡한 초기화 로직이나 조건부 접근 제어를 구현할 수 있습니다.
- 백킹 속성은 일반적으로 private 으로 선언되고, public 속성의 값을 저장하거나 보조하는 역할을 합니다.
Classes and Inheritance
기본 클래스 정의
- 코틀린에서 클래스는 class 키워드를 사용하여 정의합니다.기본 클래스 정의는 다음과 같습니다.
class Person {
// 클래스 본문
}
생성자
- 코틀린 클래스는 주 생성자와 보조 생성자를 가질 수 있습니다.
- 주 생성자는 클래스 헤더에 정의되며, 클래스의 인스턴스가 생성될 때 주로 사용됩니다.
- 보조 생성자는 constructor 키워드를 사용하여 클래스 본문에 정의됩니다.
주 생성자
- 다음은 속성과 함께 주 생성자를 정의하는 예제입니다.
class Person(val firstName: String, val lastName: String)
Initializer Blocks (초기화 블록)
- 주 생성자에서는 초기화 블록을 사용할 수 있습니다. 초기화 블록은 init 키워드를 사용합니다.
class Person(val firstName: String, val lastName: String) {
init {
println("Initialized with firstName = $firstName and lastName = $lastName")
}
}
보조 생성자
- 클래스는 여러 개의 보조 생성자를 가질 수 있습니다.
class Person {
var children: MutableList<Person> = mutableListOf()
constructor(parent: Person) {
parent.children.add(this)
}
}
- 보조 생성자는 다른 생성자와 상호작용할 수 있으며, 주 생성자를 통해 초기화할 수 있습니다.
class Person(val name: String) {
var children: MutableList<Person> = mutableListOf()
constructor(name: String, parent: Person) : this(name) {
parent.children.add(this)
}
}
상속
- 코틀린에서 클래스는 기본적으로 final 입니다.
- 따라서 상속을 허용하려면 open 키워드를 사용해야 합니다.
open class Base(p: Int)
class Derived(p: Int) : Base(p)
- 코틀린에서 클래스가 기본적으로 final 인 이유는 여러 가지 이유에서 기인하는데, 주된 이유는 안정성과 설계의 명확성을 제공하기 위함입니다. 여기에는 몇 가지 중요한 이유가 포함됩니다:
- 불변성과 안정성 향상
코틀린의 기본 설계 철학 중 하나는 안정성과 예측 가능성을 중시하는 것입니다. 클래스가 final 로 선언되면 상속을 통해 클래스의 동작이 변경되는 것을 방지할 수 있습니다. 이는 클래스의 불변성을 유지하고, 의도하지 않은 방식으로 클래스가 확장되는 것을 막아 안정성을 높입니다. - 코드의 명확성
기본적으로 클래스가 final 로 선언됨으로서 개발자는 해당 클래스를 상속할 수 없는 것으로 간주합니다. 이는 코드의 명확성을 높여주며, 클래스 설계 시 명확한 의도를 전달할 수 있습니다. 만약 클래스를 상속 가능하게 설계하고자 한다면, 명시적으로 open 키워드를 사용해야 하므로 상속 가능성을 명확하게 의도하고 있다는 점을 표현할 수 있습니다. - 성능 최적화
클래스가 final 로 선언되면, 컴파일러가 특정 최적화를 수행할 수 있습니다. 이는 런타임 성능을 향상시킬 수 있으며, 더 효율적인 코드 생성을 가능하게 합니다. 다음은 클래스가 final 으로 선언될 때 컴파일러가 수행할 수 있는 최적화의 예시에 대해서 설명합니다.- 인라이닝 (Inlining)
final 클래스로 선언된 메서드는 인라인 최적화의 후보가 될 수 있습니다. 인라이닝은 메서드 호출을 해당 메서드의 바디로 대체하는 최적화 기법입니다. 이를 통해 메서드 호출에 따른 오버헤드를 줄일 수 있습니다. (아래 예제 코드 참조) - 가상 메서드 테이블 (Virtual Method Table, VMT) 최적화
자바와 같은 JVM 언어에서는 동적 디스패치를 위해 가상 메서드 테이블을 사용합니다. 하지만 final 메서드는 오버라이딩될 수 없으므로, 컴파일러는 이 메서드 호출을 가상 메서드 테이블을 통해 간접적으로 호출할 필요 없이 직접 호출할 수 있습니다. 이는 메서드 호출의 성능을 향상시킵니다. (아래 예제 코드 참조) - 클래스 계층 구조 분석 (Class hierarchy Analysis, CHA)
컴파일러는 클래스가 final 로 선언된 경우, 해당 클래스의 서브 클래스가 없음을 보장할 수 있습니다. 이를 통해 클래스 계층 구조 분석을 보다 효율적으로 수행할 수 있으며, 메서드 호출을 더욱 최적화할 수 있습니다. - 메모리 레이아웃 최적화
final 클래스를 사용할 경우 객체의 메모리 레이아웃이 보다 효율적으로 최적화될 수 있습니다. 상속을 고려하지 않아도 되므로, 객체의 메모리 배치를 더 단순하고 효율적으로 설계할 수 있습니다. - JIT 컴파일러 최적화
JIT(Just-In-Time) 컴파일러는 런타임에 추가 최적화를 수행합니다. final 메서드와 클래스는 JIT 컴파일러가 추가적인 최적화를 적용하기에 더 좋은 후보가 됩니다. 예를 들어, JIT 컴파일러는 인라인 캐싱과 같은 최적화 기법을 적용할 수 있습니다.
- 인라이닝 (Inlining)
- 상속에 대한 신중한 접근
상속은 강력한 기능이지만, 남용될 경우 코드의 유지보수가 어려워질 수 있습니다. 상속 구조가 복잡해지면 의도하지 않은 버그가 발생할 가능성이 높아지며, 코드의 가독성과 이해도를 떨어뜨릴 수 있습니다. 코틀린에서는 상속을 명시적으로 허용하도록 함으로서 개발자가 상속을 신중하게 사용하도록 장려합니다. - 언어 창시자의 의도
코틀린의 창시자인 JetBrains 측에서는 Java의 단점을 보완하고, 더 안전하고 효율적인 언어를 설계하는 것을 목표로 하였습니다. Java 에서는 클래스가 기본적으로 상속 가능하며, 이는 때로 의도하지 않은 상속으로 인한 문제를 초래할 수 있습니다. 이러한 문제를 방지하지 위해 코틀린에서는 클래스가 기본적으로 final 으로 선언되도록 설계되었습니다.
- 불변성과 안정성 향상
// 인라이닝 예제
final class FinalClass {
fun finalMethod() {
println("This is a final method.")
}
}
// 인라이닝 이전
fun callerMethod() {
val obj = FinalClass()
obj.finalMethod()
}
// 인라이닝 이후
fun callerMethod() {
val obj = FinalClass()
println("This is a final method.")
}
// 가상 메서드 최적화 예제
open class BaseClass {
open fun virtualMethod() {}
}
// 가상 메서드 테이블 최적화 전
final class FinalClass : BaseClass() {
final override fun virtualMethod() {
println("Final method.")
}
}
// 가상 메서드 테이블 최적화 이후
fun callerMethod() {
val obj = FinalClass()
// 가상 메서드 테이블을 통한 간접 호출 대신 직접 호출
obj.virtualMethod()
}
오버라이딩 메서드
- 기반 클래스의 메서드를 오버라이딩하려면 override 키워드를 사용해야 합니다.
open class Base {
open fun v() {}
fun nv() {}
}
class Derived() : Base() {
override fun v() {}
}- 기반 클래스의 속성을 오버라이딩할 수도 있습니다.
open class Base {
open val x: Int get() { return 0 }
}
class Derived : Base() {
override val x: Int get() { return 1 }
}
Abstract Class (추상 클래스)
- 추상 클래스는 일부 메서드가 구현되지 않은 클래스입니다.
- abstract 키워드를 사용하여 정의합니다.
abstract class Polygon {
abstract fun draw()
}
class Rectangle : Polygon() {
override fun draw() {
println("Drawing a rectangle")
}
}
Interfaces (인터페이스)
- 코틀린에서 인터페이스는 interface 키워드를 사용하여 정의합니다.
- 인터페이스는 추상 메서드뿐만 아니라 구현을 포함할 수도 있습니다.
interface MyInterface {
fun bar()
fun foo() {
// 메서드 본문
}
}
class Child : MyInterface {
override fun bar() {
// 구현
}
}
Visibility Modifiers (가시성 수정자)
- 코틀린에서는 클래스, 객체, 인터페이스, 생성자, 속성, 메서드, 초기화 블록에 가시성 수정자를 사용할 수 있습니다.
- 기본 가시성은 public 입니다.
- public: 모든 곳에서 볼 수 있습니다.
- internal: 같은 모듈 안에서만 볼 수 있습니다.
- protected: 하위 클래스에서만 볼 수 있습니다.
- private: 같은 클래스 안에서만 볼 수 있습니다.
class Example {
private val x = 1
internal val y = 2
protected val z = 3
}
Data Classes (데이터 클래스)
- 코틀린에서는 데이터를 저장하는 용도로 사용되는 클래스에 대해 data 키워드를 사용하여 데이터 클래스를 정의할 수 있습니다.
- 데이터 클래스는 toString(), equals(), hashCode(), copy() 메서드를 자동으로 생성합니다.
data class User(val name: String, val age: Int)
Nested and Inner Classes (중첩 클래스와 내부 클래스)
- 코틀린에서는 클래스 안에 클래스를 정의할 수 있습니다.
- 기본적으로 중첩 클래스는 외부 클래스의 참조를 가지지 않습니다.
class Outer {
class Nested {
fun foo() = 2
}
}- inner 키워드를 사용하여 내부 클래스를 정의할 수 있습니다. 내부 클래스는 외부 클래스의 참조를 가집니다.
class Outer {
private val bar: Int = 1
inner class Inner {
fun foo() = bar
}
}Null Safety
코틀린은 null 참조에 대한 안정성을 제공하는 언어입니다. null 참조는 많은 프로그래밍 언어에서 일반적인 오류 원인입니다. Kotlin 에서는 null 참조를 명시적으로 처리하여 이러한 오류를 방지할 수 있습니다.
Nullable 과 Non-Nullable 타입
- 코틀린에서는 변수에 null 값을 허용할지 여부를 타입 시스템에서 명확하게 구분합니다.
var a: String = "abc" // null을 허용하지 않음
a = null // 컴파일 오류
var b: String? = "abc" // null을 허용
b = null // 허용
Null 검사
- Nullable 타입을 사용할 때는 null 검사를 통해 안전하게 값을 다룰 수 있습니다.
- 조건문을 통한 null 검사
val b: String? = "Kotlin"
if (b != null) {
println(b.length) // 안전하게 호출 가능
}- Safe Call 연산자 (?.): Safe Call 연산자는 객체가 null 이 아닌 경우에만 호출을 수행합니다. null 인 경우에는 null을 반환합니다.
val b: String? = "Kotlin"
println(b?.length) // b가 null이 아니면 길이를 반환, null이면 null 반환- Elvis 연산자 (?:) : Elvis 연산자는 null 값을 대체할 기본 값을 제공하는 데 사용됩니다.
val b: String? = null
val length = b?.length ?: -1 // b가 null이면 -1을 반환
println(length)- !! 연산자: !! 연산자는 nullable 타입을 강제로 non-null 타입으로 변환합니다. 만약 값이 null 인 경우, NPE 을 발생시킵니다. 이 연산자는 정말 값이 null 이 아님을 확신할 때만 사용해야 합니다.
val b: String? = null
val length = b!!.length // b가 null이면 NPE 발생
Safe Casts
- 안전한 타입 캐스팅은 as? 연산자를 사용하여 실패 시 null 을 반환합니다.
val obj: Any? = "Kotlin"
val str: String? = obj as? String // obj가 String이면 캐스팅, 아니면 null
컬렉션의 null 안전성
- 코틀린은 null 을 허용하지 않는 컬렉션과 null 을 허용하는 컬렉션을 구분합니다.
val list: List<String?> = listOf("Kotlin", null) // null을 허용하는 리스트
val list2: List<String> = listOf("Kotlin", "Java") // null을 허용하지 않는 리스트
이상으로 코틀린의 기본 문법에 대한 내용을 살펴보았습니다. 다음 시간에는 코틀린의 타입과 Control Flow (if, for, while ...) 에 대해 알아보겠습니다.
반응형
'Kotlin' 카테고리의 다른 글
| [Kotlin] Asynchronous Programming Techniques - 2 (0) | 2024.08.07 |
|---|---|
| [Kotlin] Asynchronous Programming Techniques - 1 (0) | 2024.08.05 |
| [Kotlin] Types (0) | 2024.08.01 |
| [Kotlin] 언어 소개 (0) | 2024.07.21 |