▪️ 지연 초기화
- 지연 초기화란?
- 지연 초기화란, 변수를 선언할 때 즉시 초기값을 할당하지 않고, 나중에 해당 변수가 필요할 때 초기화하는 방식을 말합니다.
- 지연 초기화가 필요한 이유
- 변수나 객체의 값은 생성시 반드시 초기화가 필요하다.
- 클래스 내에서 선언한 후 객체의 정보가 나중에 나타나는 경우 초기화 할 수 있는 방법이 필요.
- 지연 초기화를 위해 lateinit과 lazy 키워드를 사용한다.
### ▪️ lateinit를 사용한 초기화 - 의존성이 있는 초기화나 unit 테스트를 위한 코드를 작성 시 프로퍼티 지연 초기화가 필요하다. - 클래스를 선언할 때 프로퍼티 선언은 null을 허용하지 않는다. (선언 하려면 ? 형으로 선언하고 null을 할당해야 한다.) 하지만, 지연 초기화를 위한 lateinit 키워드를 사용하면 프로퍼티에 값이 바로 할당되지 않아도 된다.
- var 키워드를 사용하여 선언한 경우에만 lateinit을 사용할 수 있다.
- primitive type에는 적용할 수 없다.
- lateinit로 선언한 프로퍼티는 getter, setter를 적용할 수 없다.
class Person {
lateinit var name: String // 지연 초기화를 위해 lateinit 키워드를 사용함
fun initName(name: String) {
this.name = name
}
fun printName() {
if (::name.isInitialized) { // 변수가 초기화되었는지 확인하기 위해 :: 연산자를 사용함
println("Name: $name")
} else {
println("Name is not initialized.")
}
}
}
fun main() {
val person = Person()
// person.name = "John" // 에러: lateinit 변수는 초기화되지 않은 상태에서 사용할 수 없음
person.initName("John")
person.printName() // 출력: Name: John
}▪️ lazy를 통한 지연 초기화
- 호출 시점에 by lazy {...} 정의에 의해 블록 부분의 초기화를 진행한다.
- 불변의 변수 선언인 val에서만 사용 가능하다. (읽기 전용)
- val이므로 값을 다시 변경할 수 없다.
class Person {
val name: String by lazy {
println("Initializing name...")
"John"
}
fun printName() {
println("Name: $name")
}
}
fun main() {
val person = Person()
person.printName() // 출력: Initializing name... \n Name: John
person.printName() // 출력: Name: John
}
lazy 프로퍼티는 최초 접근 시에만 초기화되기 때문에, main() 함수에서 printName() 함수를 호출하기 전에는 name 프로퍼티가 초기화되지 않는다.
printName() 함수를 호출하면, name 프로퍼티를 사용하는 코드에서 lazy 블록이 실행되어 초기화된다.
이때 println("Initializing name...") 구문이 실행되어 초기화되는 과정을 확인할 수 있다. 또한 printName() 함수를 한 번 더 호출하면, name 프로퍼티는 이미 초기화된 상태이기 때문에, lazy 블록은 다시 실행되지 않는다.
▪️ 위임 (delegation)
코틀린에서 위임(Delegation)은 객체 지향 프로그래밍에서 말하는 상속과 유사한 개념이다. 하지만 상속과는 달리 코드 재사용성을 높일 수 있는 장점이 있다.
코틀린에서 위임은 특정 클래스의 인스턴스를 다른 클래스가 대신 사용하는 것을 의미한다.
이 때 사용하는 클래스를 대리자(Delegate) 클래스라고 하며, 대리자 클래스는 특정 인터페이스를 구현하거나, 추상 클래스를 상속받아 구현한다. 그리고 이 대리자 클래스를 사용하는 클래스는 위임을 통해 대리자 클래스의 기능을 사용할 수 있다.
- by를 이용한 클래스 위임
- observable() 함수로 위임
- vetoable()함수로 위임
▪️ by
interface MediaPlayer {
fun play()
fun pause()
}
class AudioPlayer : MediaPlayer {
override fun play() {
println("Audio is playing")
}
override fun pause() {
println("Audio is paused")
}
}
class MusicPlayer(private val mediaPlayer: MediaPlayer) : MediaPlayer by mediaPlayer
fun main() {
val audioPlayer = AudioPlayer()
val musicPlayer = MusicPlayer(audioPlayer)
musicPlayer.play() // Audio is playing
musicPlayer.pause() // Audio is paused
}
위 코드에서 AudioPlayer 클래스는 MediaPlayer 인터페이스를 구현하고 있습니다. MusicPlayer 클래스는 MediaPlayer 인터페이스를 구현하지 않고 대신 by 키워드를 사용하여 AudioPlayer 인스턴스를 위임받았습니다.
이제 MusicPlayer 클래스의 인스턴스를 생성하면, 해당 인스턴스는 AudioPlayer 인스턴스의 메서드를 사용할 수 있습니다. play() 메서드를 호출하면 Audio is playing이라는 메시지가 출력되며, pause() 메서드를 호출하면 Audio is paused라는 메시지가 출력됩니다.
위임을 사용하면 기존 클래스의 코드를 변경하지 않고도 새로운 기능을 추가할 수 있으며, 코드의 재사용성을 높일 수 있습니다. 또한 코드의 가독성도 향상시킬 수 있습니다.
▪️ observable()
observable()은 코틀린 표준 라이브러리에 포함된 위임 프로퍼티 대리자 중 하나로, 변수의 값 변경을 감지하고 처리하는 기능을 제공합니다. 이를 통해 변수 값이 변경될 때마다 특정한 로직을 수행하거나 다른 변수의 값을 변경할 수 있습니다.
observable()을 사용하려면 kotlin.properties.Delegates 패키지를 import해야 합니다. 그리고 아래와 같은 형태로 사용할 수 있습니다.
var <property-name> : <property-type> by Delegates.observable(<initial-value>) {
prop, old, new -> // 코드 블록
}
여기서 은 위임을 사용할 변수의 이름, 은 변수의 타입, 는 변수의 초기값입니다. 또한 Delegates.observable() 함수의 인자로는 함수형 인자가 들어갑니다. 이 함수형 인자는 아래와 같이 세 개의 파라미터를 가집니다.
prop: 변경된 프로퍼티의 KProperty 객체
old: 이전 값
new: 새로운 값
이 함수형 인자는 변경이 일어날 때마다 호출되며, 이를 통해 변수 값의 변경을 감지하고 다른 로직을 수행할 수 있습니다.
import kotlin.properties.Delegates
class Observable{
var name :String by Delegates.observable("처음"){
property, oldValue, newValue ->
println("$oldValue -> $newValue")
}
}
fun main() {
var ob = Observable()
ob.name = "두번째"
ob.name = "세번째"
/* 결과
처음 -> 두번째
두번째 -> 세번째
*/
}▪️ vetoable()
vetoable()은 observable()과 비슷한 기능을 제공하는 코틀린 위임 프로퍼티 대리자 중 하나입니다. vetoable()은 변수의 값 변경을 감지하고, 새로운 값이 특정 조건에 부합하지 않으면 변경을 거부합니다. 즉, 변경을 허용할지 말지를 결정하는 기능을 제공합니다.
vetoable()을 사용하려면 kotlin.properties.Delegates 패키지를 import해야 합니다. 그리고 아래와 같은 형태로 사용할 수 있습니다.
var <property-name> : <property-type> by Delegates.vetoable(<initial-value>) {
prop, old, new -> // 코드 블록
}
여기서 은 위임을 사용할 변수의 이름, 은 변수의 타입, 는 변수의 초기값입니다. 또한 Delegates.vetoable() 함수의 인자로는 함수형 인자가 들어갑니다. 이 함수형 인자는 아래와 같이 세 개의 파라미터를 가집니다.
prop: 변경된 프로퍼티의 KProperty 객체
old: 이전 값
new: 새로운 값
이 함수형 인자는 변경이 일어날 때마다 호출되며, 이를 통해 변수 값의 변경을 감지하고 변경을 허용할지 말지를 결정할 수 있습니다. 이 함수형 인자의 반환값은 변경을 허용할지 말지를 나타내는 Boolean 값입니다.
예를 들어, 아래와 같이 VetoablePerson 클래스를 정의할 수 있습니다.
import kotlin.properties.Delegates
class VetoablePerson {
var age: Int by Delegates.vetoable(0) {
prop, old, new -> if (new >= 0) true else false
}
}이 클래스에서 age 변수는 vetoable() 대리자를 사용하여 변경을 감지하며, 변경을 허용할지 말지를 결정하는 조건은 if (new >= 0) true else false 코드 블록입니다. 이 코드 블록은 변수의 새로운 값이 0 이상일 경우에만 true를 반환하며, 그 외의 경우에는 false를 반환합니다. 이제 VetoablePerson 클래스를 사용하여 age 변수의 값을 변경하면, 변경을 허용할지 말지를 결정하는 조건에 따라 값을 변경하거나 변경하지 않습니다.
fun main() {
val person = VetoablePerson()
person.age = 20 // age 변수의 값이 20으로 변경됩니다.
person.age = -10 // age 변수의 값이 변경되지 않습니다.
println(person.age) // 출력값: 20
}
▪️ companion object
Kotlin에서 companion object는 클래스 내에서 생성하는 static 멤버를 관리하는데 사용됩니다.
companion object는 클래스의 인스턴스 생성과는 관련이 없으며, 클래스 내부에 존재하는 오직 하나의 객체입니다. 이 객체는 클래스가 로드될 때 자동으로 생성됩니다.
companion object는 클래스 내에서 정의된 속성과 메서드에 접근할 수 있는 공용 인터페이스를 제공합니다. 즉, companion object의 속성과 메서드는 외부에서 클래스명을 통해 직접적으로 호출할 수 있으며, static 멤버와 같이 사용될 수 있습니다.
class MyClass {
companion object {
const val TAG = "MyClass"
fun myFunction() {
println("Called myFunction() from companion object")
}
}
}
위의 예제에서, companion object를 사용하여 MyClass 내에서 TAG 상수와 myFunction() 함수를 정의했습니다. 이제 이들은 클래스명을 통해 직접 접근 가능합니다.
val tag = MyClass.TAG // "MyClass"
MyClass.myFunction() // "Called myFunction() from companion object"
따라서 companion object는 Kotlin에서 클래스 수준에서 static 멤버를 생성하고 관리하기 위한 간단하고 효과적인 방법을 제공합니다.
