Rooted In Develop

Kotlin - DSL

RootedIn — Sat, 24 Jun 2023 22:27:36 +0900

Kotlin 의 편의성 지원

Java	Kotlin	특성
StringUtil.capitalize(s)	s.capitalize()	확장 함수
1.to("one")	1 to "one"	중위 호출
set.add(2)	set += 2	연산자 오버로딩
map.get("key")	map["key"]	get 메서드에 대한 관례
file.use({ f -> f.read() })	file.use { it.read() }	람다를 괄호 밖으로 빼내는 관례
sb.append("yes") sb.append("no")	with (sb) { append("yes") append("no") }	수신 객체 지정 람다

DSL

외부 DSL : SQL

SELECT Country.name, COUNT(Customer.id)
  FROM Country
  JOIN Customer ON Country.id = Customer.country_id
  GROUP BY Country.name
  ORDER BY COUNT(Customer.id) DESC
  LIMIT 1

내부 DSL : Exposed

(Country join Customer)
  .slice(Country.name, jCount(Customer.id))
  .selectAll()
  .groupBy(Country.name)
  .orderBy(Count(Customer.id), isAsc = false)
  .limit(1)

수신 객체 지정 람다

// 람다를 인자로 받는 함수
fun buildString(builderAction: (StringBuilder) -> Unit) : String {
  val sb = StringBuilder()
  builderAction(sb)
  return sb.toString()
}
>>> val s = buildString {
  it.append("Hello, ")
  it.append("World!")
}

// 수신 객체 지정 람다를 사용해 재정의
fun buildString(builderAction: StringBuilder.() -> Unit) : String {
  val sb = StringBuilder()
  sb.builderAction()
  return sb.toString()
}
>>> val s = buildString {
  this.append("Hello, ")
  append("World!")
}

val appendExcl : StringBuilder.() -> Unit = { this.append("!") }
>>> val stringBuilder = StringBuilder("Hi")
>>> stringBuilder.appendExcl() // appendExcl 를 확장 함수처럼 사용 가능
>>> println(stringBuilder)
Hi!
>>> println(buildString(appendExcl)) // appendExcl 를 인자로 넘길 수 있음
!

HTML 빌더 구현

open class Tag(val name: String) {
  private val children = mutableListOf<Tag>()
  protected fun <T : Tag> doInit(child: T, init: T.() -> Unit) {
    child.init()
    childrene.add(child)
  }
  override fun toString() = "<$name>${children.joinToString("")}</$name>"
}
fun table(init: TABLE.() -> Unit) = TABLE().apply(init)
class TABLE : Tag("table") {
  fun tr(init: TR.() -> Unit) = doInit(TR(), init)
}
class TR : Tag("tr") {
  fun td(init: TD.() -> Unit) = doInit(TD(), init)
}
class TD : Tag("td")
fun createTable() =
  table {
    tr {
      td {
      }
    }
  }
>>> println(createTable())
<table><tr><td></td></tr></table>

invoke 관례 활용

class Greeter(val greeting: String) {
  operator fun invoke(name: String) {
    println("$greeting, $name!")
  }
}
>>> val bavarianGreeter = Greeter("Servus")
>>> bavarianGreeter("Dmitry") // bavarianGreeter.invoke("Dmitry")
Servus, Dmitry!

Kotlin - annotation, reflection

RootedIn — Sat, 17 Jun 2023 18:15:43 +0900

애노테이션 사용 지점 대상 지정

대상	설명
property	프로퍼티 전체
field	프로퍼티에 생성되는 필드
get	프로퍼티 게터
set	프로퍼티 세터
receiver	확장 함수, 프로퍼티의 수신 객체 파라미터
param	생성자 파라미터
setparam	세터 파라미터
delegate	위임 프로퍼티의 위임 인스턴스를 담아둔 필드
file	파일 안에 선언된 최상위 함수와 프로퍼티를 담아두는 클래스

class HasTempFolder {
  @get:Rule
  val folder = TemporaryFolder()
  
  @Test
  fun testUsingTempFolder() {
    val createdFile = folder.newFile("myFile.txt")
    val createdFolder = folder.newFolder("subfolder")
  }
}

애노테이션 정의

annotation class JsonName(val name: String)

메타애노테이션 : 애노테이션 클래스에 적용할 수 있는 애노테이션

@Target(AnnotationTarget.PROPERTY)
annotation classJsonExclude

@Target(AnnotationTarget.ANNOTATION_CLASS)
annotation class BindingAnnotation

@BindingAnnotation
annotation class MyBinding

- AnnotationTarget.PROPERTY : 자바에서 사용 불가
- AnnotationTarget.FIELD : 자바에서 사용 가능

annotation class DeserializeInterface(val targetClass: KClass<out Any>)

interface ValueSerializer<T> {
  fun toJsonValue(value: T) : Any?
  fun fromJsonValue(jsonVluae: Any?) : T
}

annotation class CustomSerializer(val serializerClass: KClass<out ValueSerializer<*>>)

data class Person(
  val name: String,
  @CustomSerializer(DateSerializer::class) val birthDate: Date
)

리플렉션 : KClass, KCallable, KFunction, KProperty

- KFunction, KProperty 는 모두 KCallable 확장
- KCallable은 제네릭 call 메서드 제공
- KCallable.callBy 메서드 호출하면 디폴트 파라미터 값 사용 가능
- KFunction는 invoke 메서드로 함수 호출 가능
- Kproperty0은 최상위 프로퍼티나 변수, KProperty1은 수신 객체가 있는 프로퍼티에 접근
- KMutableProperty0은 KProperty0을 확장, set 메서드로 값 변경 가능

Kotlin - 제네릭스

RootedIn — Sat, 10 Jun 2023 22:34:40 +0900

제네릭 함수와 프로퍼티

fun <T> List<T>.slice(indices: IntRange): List<T>
>>> println(letters.slice<Char>(0..2))
[a, b, c]
>>> println(letters.slice(10..13))
[k, l, m, n]

val authors = listOf("Dmitry", "Svetlana")
val readers = mutableListOf<String>(/* ... */)
fun <T> List<T>.filter(predicate: (t) -> Boolean): List<T>
>>> readers.filter { it !in authors }

val <T> List<T>.penultimate: T get() = this[size-2]
>>> println(listOf(1, 2, 3, 4).penultimate)
3

제네릭 클래스

interface List<T> {
  operator fun get(index: Int) : T
}
class StringList: List<String> {
  override fun get(index: Int) : String = /* ... */
}
class ArrayList<T>: List<T> {
  override fun get(index: Int) : T = /* ... */
}

interface Comparable<T> {
  fun compareTo(other: T) : Int
}
class String : Comparable<String> {
  override fun compareTo(other: String) : Int = /* ... */
}

타입 파라미터 제약

fun <T : Number> List<T>.sum() : T
fun <T : Number> oneHalf(value: T) : Double {
  return value.toDouble() / 2.0
}
fun <T: Comparable<T>> max(first: T, second: T) : T {
  return if (first > second) first else second
}
fun <T> ensureTrailingPeriod(seq: T)
  where T : charSequence, T : Appendable {
  if (!seq.endsWith('.') {
    seq.append('.')
  }
}

타입 파라미터를 널이 될 수 없는 타입으로 제한

class Processor<T : Any> {
  fun process(value: T) {
    value.hashCode()
  }
}

제네릭스 동작

실행 시점 : 타입 검사, 캐스트

if (value is List<String>) { ... } // ERROR
if (value is List<*>) { ... }

fun printSum(c: Collection<*>) {
  val intList = c as? List<Int> // Int가 아닌 경우 ClassCastExcpetion
    ?: throw IllegalArgumentException("List is expected")
  println(intList.sum())
}
fun printSum(c: Collection<Int>) {
  if (c is List<Int>) {
    println(c.sum())
  }
}

실제화한 타입 파라미터를 사용

- 인라인 함수로 만들고 타입 파라미터를 reified로 지정

inline fun <reified T> isA(value: Any) = value is T
>>> println(isA<String>("abc"))
true
>>> println(isA(String>(123))
false

>>> val items = listOf("one", 2, "three")
>>> println(items.filterIsInstance<String>()) // 표준 라이브러리 함수 filterIsInstance
[one, three]

하위 타입 / 상위 타입

- 타입 A의 값이 필요한 모든 장소에 어떤 타입 B의 값을 넣어도 문제가 없는 경우 타입 B는 타입 A의 하위 타입
- A는 A?의 하위 타입이지만 A?는 A의 하위 타입이 아님

공변성 : 하위 타입 관계를 유지

- A가 B의 하위 타입일때 Producer<A>가 Producer<B>의 하위 타입이면 Producer는 공변적(하위 타입 관계가 유지된다)
- 제네릭 클래스가 타입 파라미터에 대해 공변적임으로 표시하려면 타입 파라미터 이름 앞에 out을 붙임

interface Producer<out T> {
  fun produce() : T
}

open class Animal {
  fun feed() { ... }
}
class Herd<T : Animal> {
  val size: Int get() = ...
  operator fun get(i: Int) : T { ... }
}
fun feedAll(animals: Herd<Animal>) {
  for (i in 0 until animals.size) {
    animals[i].feed()
  }
}
class Cat : Animal() {
  fun cleanLitter() { ... }
}
fun takeCareOfCats(cats: Herd<Cat>) {
  for (i in 0 until cats.size) {
    cats[i].cleanLitter()
  }
  // feedAll(cats) // Herd<Cat> <-> Herd<Animal> 간의 에러 발생
}

// 공변적 컬렉션 역할로 변경
class Herd<out T : Animal> {
}
fun takeCareOfCats(cats: Herd<Cat>) {
  for (i in 0 until cats.size) {
    cats[i].cleanLitter()
  }
  feedAll(cats)
}

- 공변적이기 위해서는 out 위치에만 T가 존재해야함

interface List<out T> : Collection<T> {
  operator fun get(index: Int) : T // out 위치
}

interface List<out T> : Collection<T> {
  fun subList(fromIndex: Int, toIndex: Int) : List<T> // out 위치
}

interface MutableList<T> : List<T>, MutableCollection<T> {
  override fun add(element: T) : Boolean // in 위치이므로 MutableList는 T에 대해 공변적일 수 없음
}

- 읽기 전용 프로퍼티 : out
- 변경 가능 프로퍼티 : out, in

반공변성 : 뒤집힌 하위 타입 관계

interface Comparator<in T> {
  fun compare(e1: T, e2: T) : Int { ... } // in 위치
}

공변성	반공변성	무공변성
Producer<out T>	Producer<in T>	MutableLisit<T>
타입 인자의 하위 타입 관계가 유지됨	타입 인자의 하위 타입 관계가 뒤집힘	하위 타입 관계가 성립하지 않음
Producer<C>은 Producer<A>의 하위 타입	Consumer<A>은 Consumer<C>의 하위 타입
T를 out 위치에서만 사용	T를 in 위치에서만 사용	T를 아무 위치에서나 사용

사용 지점 변성 : 타입이 언급되는 지점에서 변성 지정

// out-projection 타입 파라미터
fun <T> copyData(source: MutableList<out T>, destination: MutableList<T>) {
  for (item in source) {
    destination.add(item)
  }
}
>>> val list: MutableList<out Number> = ...
>>> list.add(42)
ERROR

// in-projection 타입 파라미터
fun <T> copyData(source: MutableList<T>, destination: MutableList<in T>) {
  for (item in source) {
    destination.add(item)
  }
}

- Kotlin의 MutableList<out T> 는 Java의 MutableList<? extends T> 와 같음
- Kotlin의 MutableList<in T> 는 Java의 MutableList<? super T>와 같음

스타 프로젝션 : 타입 인자 대신 * 사용

- MutableList<*>는 MutableList<Any?>와 같지 않음
- MutableList<*>는 구체적인 특정 타입의 원소만 담을 수 있다는 의미
- 스타 프로젝션을 위한 검증기 구현

object Validators {
  private val validators = mutableMapOf<KClass<*>, FieldValidator<*>>()
  fun <T: Any> registerValidator(kClass: KClass<T>, fieldValidator: FieldValidator<T>) {
    validators[kClass] = fieldValidator
  }
  @Suppress("UNCHECKED_CAST")
  operator fun <T: Any> get(kClass: KClass<T>) : FieldValidator<T> =
    validators[kClass] as? FieldValidator<T>
      ?: throw IllegalArgumentException("No validator for ${kClass.simpleName}")
}

>>> Validators.registerValidator(String::class, DefaultStringValidator)
>>> Validators.registerValidator(Int::calss, DefaultIntValidator)
>>> println(Validators[String::class].validate("Kotlin"))
true
>>> println(Validators[Int::class].validate(42))
true

Kotlin - 고차 함수

RootedIn — Sat, 3 Jun 2023 20:20:17 +0900

고차 함수 : 다른 함수를 인자로 받거나 함수를 반환하는 함수

함수 타입

val sum: (Int, Int) -> Int = ( x, y -> x + y }
val action: () -> Unit = { println(1) }

문법 : 파라미터 타입 -> 반환 타입

인자로 받은 함수 호출

fun twoAndThree(operation: (Int, Int) -> Int) {
  val result = operation(2, 3)
  println("result = $result")
}
>>> twoAndThree { a, b -> a + b }
result = 5
>>> twoAndThree { a, b -> a * b }
result = 6

자바에서 코틀린 함수 타입 사용

// Kotlin
fun processTheAnswer(f: (Int) -> Int) {
  println(f(42))
}

// Java
>>> processTheAnswer(number -> number + 1);
43

디폴트 값을 지정한 함수 타입 파라미터나 널이 될 수 있는 함수 타입 파라미터

fun <T> Collection<T>.joinToString(
  separator: String = ", ",
  prefix: String = "",
  postfix: String = "",
  transform: (T) -> String = { it.toString() }
): String {
  val result = StringBuilder(prefix)
  for ((index, element) in this.withIndex()) {
    if (index > 0) result.append(separator)
    result.append(element)
  }
  result.append(postfix)
  return result.toString()
}
>>> val letters = listOf("Alpha", "Beta")
>>> println(letters.joinToString())
Alpha, Beta
>>> println(letters.joinToString { it.toLowerCase() }
alpha, beta
>>> println(letters.joinToString(separator = "! ", postfix = "! ", transform = { it.toUpperCase() }))
ALPHA! BETA!

함수에서 함수를 반환

enum class Delivery { STANDARD, EXPEDITED }
class Order(val itemCount: Int)
fun getShippingCostCalculator(delivery: Delivery): (Order) -> Double {
  if (delivery == Delivery.EXPEDITED) {
    return { order -> 6 + 2.1 * order.itemCount }
  }
  return { order -> 1.2 * order.itemCount }
}
>>> val calculator = getShippingCostCalculator(Delivery.EXPEDITED)
>>> println(calculator(Order(3)))
12.3

람다를 활용한 중복 제거

data class SiteVisit(val path: String, val duration: Double, val os: OS)
eunm class OS { WINDOWS, LINUX, MAC, IOS, ANDROID }
val log = listOf(
  SiteVisit("/", 34.0, OS.WINDOWS),
  SiteVisit("/", 22.0, OS.MAC),
  SiteVisit("/login", 12.0, OS.WINDOWS),
  SiteVisit("/signup", 8.0, OS.IOS),
  SiteVisit("/", 16.3, OS.ANDROID)
)

val averageWindowsDuration = log.filter { it.os == OS.WINDOWS }
  .map(SiteVisit::duration)
  .average()
>>> println(averageWindowsDuration)
23.0
// 일반 함수
fun List<SiteVisit>.averageDurationFor(os: OS) = filter { it.os == os }.map(SiteVisit:duration).average()
// 고차 함수
fun List<SiteVisit>.averageDurationFor(predicate: (SiteVisit) -> Boolean) = filter(predicate).map(SiteVisit::duration).average()
>>> println(log.averageDurationFor { it.os in setOf(OS.ANDROID, OS.IOS) })
12.15
>>> println(log.averageDurationFor { it.os == OS.IOS && it.path == "/signup" })
8.0

인라인 함수

- 함수를 호출하는 바이트코드 대신에 함수 본문을 번역한 바이트코드로 컴파일함

inline fun <T> synchronized(lock: Lock, action: () -> T) : T {
  lock.lock()
  try {
    return action()
  }
  finally {
    lock.unlock()
  }
}

fun foo(l: Lock) {
  println("Before Sync")
  synchronized(l) {
    println("Action")
  }
  println("After Sync")
}
// 컴파일
fun __foo__(l: Lock) {
  println("Before Sync")
  l.lock()
  try {
    println("Action")
  } finally {
    l.unlock()
  }
  println("After Sync")
}

filter, map : 인라인 함수

람다를 인자로 받는 함수를 인라이닝할 때 이익이 많다.

fun readFirstLineFromFile(path: String): String {
  BufferedReader(FileReader(path)).use { br ->
    return br.readLine() // non-local return
  }
}

람다 안의 return

data class Person(val name: String, val age: Int)
val people = listOf(Person("Alice", 29), Person("Bob", 31))
fun lookForAlice(people: List<Person>) {
  for (person in people) {
    if (person.name == "Alice") {
      println("Found")
      return
    }
  }
  println("Not Found")
}

fun lookForAlice(people: List<Person>) {
  people.forEach {
    if (it.name == "Alice") {
      println("Found")
      return // non-local return
    }
  }
  println("Not Found")
}

non-local return문 : 더 바깥에 있는 다른 블록을 반환하게 하는 return문

람다로부터 반환: 레이블을 사용한 return

fun lookForAlice(people: List<Person>) {
  people.forEach label@{ // 레이블 추가
    if (it.name == "Alice") return@label // 앞에서 정의한 레이블 참조
  }
  println("Alice might be somewhere") // 항상 출력
}

fun lookForAlice(people: List<Person>) {
  people.forEach {
    if (it.name == "Alice") return@forEach
  }
  println("Alice might be somewhere") // 항상 출력
}

무명 함수: 기본적으로 로컬 return

fun lookForAlice(people: List<Person>) {
  people.forEach(fun (person) {
    if (it.name == "Alice") return
    println("${person.name} is not Alice")
  })
}

people.filter(fun (person): Boolean {
  return person.age < 30
})

people.filter(fun (person) = person.age < 30)

- 무명 함수 본문의 return은 무명 함수를 반환시키고, 함수 밖의 다른 함수를 반환시키지 못한다.

Kotlin - 연산자 오버로딩

RootedIn — Sat, 27 May 2023 21:45:35 +0900

산술 연산자 오버로딩

이항 산술 연산 오버로딩

연산자	키워드
a * b	times
a / b	div
a % b	mod
a + b	plus
a - b	minus

data class Point(val x: Int, val y: Int) {
  operator fun plus(other: Point) : Point {
    return Point(x + other.x, y + other.y)
  }
}
>>> val p1 = Point(10, 20)
>>> val p2 = Point(30, 40)
>>> println(p1 + p2)
Point(x=40, y=60)

피연산자 타입이 다른 경우

operator fun Point.times(scale: Double) : Point {
  return Point((x * scale).toInt(), (y * scale).toInt())
}
>>> val p = Point(10, 20)
>>> println(p * 1.5)
Point(x=15, y=30)

- 자동으로 교환 법칙을 지원하지 않음
- 1.5 * p 를 오버로딩하려면 operator fun Double.times(p: Point) : Point 를 정의해야함

결과 타입이 다른 경우

operator fun Char.times(count: Int) : String {
  return toString().repeat(count)
}
>>> println('a' * 3)
aaa

복합 대입 연산자 오버로딩

연산자	키워드
+=	plusAssign
-=	minusAssign
*=	timesAssign

- ex) a += b 는 a = a.plus(b) 또는 a.plusAssign(b)

컬렉션
- +=, -= : 새로운 컬렉션 반환
- +, - : 객체 상태 변화

단항 연산자 오버로딩

연산자	키워드
+a	unaryPlus
-a	unaryMinus
!a	not
++a, a++	inc
--a, a--	dec

operator fun Point.unaryMinus() : Point {
  return Point(-x, -y)
}
>>> val p = Point(10, 20)
>>> println(-p)
Point(x=-10, y=-20)

비교 연산자 오버로딩

동등성 연산자 : equals

class Point(val x: Int, val y: Int) {
  override fun equals(obj: Any?) : Boolean {
    if (obj === this) return true
    if (obj !is Point) return false
    return obj.x == x && obj.y == y
  }
}
>>> println(Point(10, 20) == Point(10, 20))
true
>>> println(Point(10, 20) != Point(5, 5))
true
>>> println(null == Point(1, 2))
false

순서 연산자 : compareTo

a >= b : a.compareTo(b)

class Person(val firstName: String, val lastName: String) : Comparable<Person> {
  override fun compareTo(other: Person) : Int {
    return compareValuesBy(this, other, Person::lastName, Person::firstName)
  }
}
>>> val p1 = Person("Alice", "Smith")
>>> val p2 = Person("Bob", "Johnson")
>>> println(p1 < p2)
false

컬렉션과 범위에 대해 쓸 수 있는 관례

인덱스로 원소에 접근 : get, set

operator fun Point.get(index: Int) : Int {
  return when(index) {
    0 -> x
    1 -> y
    else -> throw IndexOutOfBoundsException("Invalid coordinate $index")
  }
}
>>> val p = Point(10, 20)
>>> println(p[1])
20

data class MutablePoint(var x: Int, var y: Int)
operator fun MutablePoint.set(index: Int, value: Int) {
  when(index) {
    0 -> x = value
    1 -> y = value
    else -> throw IndexOutOfBoundsException("Invalid coordinate $index")
  }
}
>>> val p = MutablePoint(10, 20)
>>> p[1] = 42
>>> println(p)
MutablePoint(x=10, y=42)

in 관례

data class Rectangle(val upperLeft: Point, val lowerRight: Point)
operator fun Rectangle.contains(p: Point) : Boolean {
  return p.x in upperLeft.x until lowerRight.x && p.y in upperLeft.y until lowerRight.y
}
>>> val rect = Rectangle(Point(10, 20), Point(50, 50))
>>> println(Point(20, 30) in rect)
true
>>> println(Point(5, 5) in rect)
false

rangeTo 관례

>>> val now = LocalDate.now()
>>> val vacation = now..now.plusDays(10)
>>> println(now.plusWeeks(1) in vacation)
true

for 루프를 위한 iterator 관례

operator fun ClosedRange<LocalDate>.iterator() : Iterator<LocalDate> = object : Iterator<LocalDate> {
  val current = start
  override fun hasNext() = current <= endInclusive
  override fun next() = current.apply {
    current = plusDays(1)
  }
}

>>> val newYear = LocalDate.ofYearDay(2017, 1)
>>> val daysOff = newYear.minusDays(1)..newYear
>>> for (dayOff in daysOff) { println(dayOff) }
2016-12-31
2017-01-01

구조 분해 선언과 component 함수

>>> val p = Point(10, 20)
>>> val (x, y) = p
>>> println(x)
10
>>> println(y)
20

val (a, b) = p
- val a = p.component1()
- val b = p.component2()
- componentN 함수 호출로 변환됨

data class NameComponents(val name: String, val extension: String)
fun splitFilename(fullName: String) : NameComponents {
  val result = fullName.split('.', limit = 2)
  return NameComponents(result[0], result[1])
}
>>> val (name, ext) = splitFilename("example.txt")
>>> println(name)
example
>>> println(ext)
txt

data class NameComponents(val name: String, val extension: String)
fun splitFilename(fullName: String) : NameComponents {
  val (name, extension) = fullName.split('.', limit = 2)
  return NameComponents(name, extension)
}

fun printEntries(map: Map<String, String>) {
  for ((key, value) in map) {
    println("$key -> $value")
  }
}
>>> val map = mapOf("Oracle" to "Java", "JetBrains" to "Kotlin")
>>> printEntries(map)
Oracle -> Java
JetBrains -> Kotlin

프로퍼티 접근자 로직 재활용 : 위임 프로퍼티

위임 프로퍼티

class Delegate {
  operator fun getValue() {}
  operator fun setValue() {}
}
class Foo {
  var p: Type by Delegate()
}
>>> val foo = Foo()
>>> val oldValue = foo.p
>>> foo.p = newValue

프로퍼티 초기화 지연 : by lazy()

class Email {}
fun loadEmails(person: Person) : List<Email> {
  println("${person.name}")
  return listOf(/*...*/)
}
class Person(val name: String) {
  private var _emails: List<Email>? = null
  val emails: List<Email>
    get() {
      if (_emails == null) {
        _emails = loadEmails(this)
      }
      return _emails!!  // 저장해 둔 데이터가 있으면 그 데이터를 반환
    }
}

class Person(val name: String) {
  val emails by lazy ( loadEmails(this) )
}

위임 프로퍼티 구현

open class PropertyChangeAware {
  protected val changeSupport = PropertyChangeSupport(this)
  fun addPropertyChangeListener(listener: PropertyChangeListener) {
    changeSupport.addPropertyChangeListener(listener)
  }
  fun removePropertyChangeListener(listener: PropertyChangeListener) {
    changeSupport.removePropertyChangeListener(listener)
  }
}
// 프로퍼티 변경 통지 직접 구현
class Person(val name: String, age: Int, salary: Int) : PropertyChangeAware() {
  var age: Int = age
    set(newValue) {
      val oldValue = field
      field = newValue
      changeSupport.firePropertyChange("age", oldValue, newValue)
    }
  var salary: Int = salary
    set(newValue) {
      val oldValue = field
      field = newValue
      changeSupport.firePropertyChange("salary", oldValue, newValue)
    }
}
// 도우미 클래스로 프로퍼티 변경 통지 구현
class ObsservableProperty(val propName: String, var propValue: Int, val changeSupport: PropertyChangeSupport ) {
  fun getValue() : Int = propValue
  fun setValue(newValue: Int) {
    val oldValue = propValue
    propValue = newValue
    changeSupport.firePropertyChange(propName, oldValue, newValue)
  }
}
class Person(val name: String, age: Int, salary: Int) : PropertyChangeAware() {
  val _age = ObservableProperty("age", age, changeSupport)
  var age: Int
    get() = _age.getValue()
    set(value) { _age.setValue(value) }
    val _salary = ObservableProperty("salary", salary, changeSupport)
    var salary: Int
      get() = _salary.getValue()
      set(value) { _salary.setValue(value) }
}
// ObservableProperty를 프로퍼티 위임에 사용할 수 있도록 변경
class ObservableProperty(var propValue: Int, val changeSupport: PropertyChangeSupport) {
  operator fun getValue(p: Person, prop: KProperty<*>): Int = propValue
  operator fun setValue(p: Person, prop: KProperty<*>, newValue: Int) {
    val oldValue = propValue
    propValue = newValue
    changeSupport.firePropertyChange(prop.name, oldValue, newValue)
  }
}
// 위임 프로퍼티를 통해 프로퍼티 변경 통지 받기
class Person(val name: String, age: Int, salary: Int) : PropertyChangeAware() {
  var age: Int by ObservableProperty(age, changeSupport)
  var salary: Int by ObservableProperty(salary, changeSupport)
}
// Delegates.observable 사용해서 프로퍼티 변경 통지 구현
class Person(val name: String, age: Int, salary: Int) : PropertyChangeAware() {
  private val observer = {
    prop: KProperty<*>, oldValue: Int, newValue: Int -> changeSupport.firePropertyChange(prop.name, oldValue, newValue)
    var age: Int by Delegates.observable(age, observer)
    var salary: Int by Delegates.observable(salary, observer)
  }
}

위임 프로퍼티 컴파일 규칙

val x = c.prop / val x = <delegate>.getValue(c, <property>)
c.prop = x / <delegate>.setValue(c, <property>, x)

프로퍼티 값을 맵에 저장

class Person {
  // 추가 정보
  private val _attributes = hashMapOf<String, String>()
  fun setAttribute(attrName: String, value: String) {
    _attributes[attrName] = value
  }
  // 필수 정보
  val name: String
  get() = _attributes["name"]!!
}

위임 프로퍼티로 맵에 저장

class Person {
  private val _attributes = hashMapOf<String, String>()
  fun setAttribute(attrName: String, value: String) {
    _attributes[attrName] = value
  }
  val name: String by _attributes
}

프레임워크에서 위임 프로퍼티 활용

object Users : IdTable() {
  val name = varchar("name", length = 50).index()
  val age = integer("age")
}

class User(id: EntityID) : Entity(id) {
  var name: String by Users.name
  var age: Int by Users.age
}

Kotlin - 타입 시스템

RootedIn — Sat, 6 May 2023 19:48:22 +0900

널 가능성

fun strLen(s: String) = s.length // null 전달 불가
fun strLen(s: String?) : Int = if (s != null) s.length else 0 // null 전달 가능

- 널이 될 수 있는 값을 널이 될 수 없는 타입의 변수에 대입 불가
- 널이 될 수 있는 타입의 값을 널이 될 수 없는 타입의 파라미터를 받는 함수에 전달 불가

안전한 호출 연산자 : ?.

fun managerName(employee: Employee): String? = employee.manager?.name

엘비스 연산자 : ?:

fun foo(s: String) {
    val t: String = s ?: ""
}

- null 대신 디폴트 값을 지정할 때 사용

안전한 캐스트 : as?

- as : 대상 타입으로 캐스팅하는 연산자
- as? : 대상 타입으로 캐스팅 불가시 null 반환

널 아님 단언 : !!

- 어떤 값이든 널이 될 수 없는 값으로 변경
- null 인경우 NullPointException 발생

let 함수

email?.let { email -> sendEmailTo(email) }

- null 이 아닌 경우만 람다식 호출하도록 활용

지연 초기화 (late-initialized)

class MyService {
    fun preformAction(): String = "foo"
}
class MyTest {
    private lateinit var myService: MyService // lateinit 선언
    @Before fun setUp() {
        myService = MyService() // 메서드에서 프로퍼티 초기화
    }
    @Test fun testAction() {
        Assert.assertEquals("foo", myService.performAction()) // null 검사 없이 수행
    }
}

nullable 객체의 확장 함수

- String? 타입에는 isNullOrEmpty, isNullOrBlank 메서드 존재, 안전한 호출하지 않아도 가능

fun String?.isNullOrBlank(): Boolean = this == null || this.isBlank()

타입 파라미터의 널 가능성

fun <T> printHashCode(t: T) {
    println(t?.hashCode()) // 안전한 호출
}
fun <T: Any> printhashCode(t: T) { // null이 될 수 없는 타입
    println(t.hashCode())
}

원시 타입

- 정수 타입 : Byte, Short, Int, Long
- 부동소수점 수 타입 : Float, Double
- 문자 타입 : Char
- 불리언 타입 : Boolean

숫자 변환

- 자동 변환 불가
- toByte(), toShort(), toChar() 등의 메소드로 변환 함수가 제공

최상위 타입

- Java의 최상위 타입 : Object
- Kotlin의 최상위 타입 : Any

Unit 타입

- 아무것도 반환하지 않는 타입
- Java의 Void 타입은 null도 포함하기 때문에 항상 return null이 필요함

Nothinig 타입

- 테스트 코드 등에서 예외를 던지는 케이스처럼 정상적으로 종료되지 않을 경우에 명시적으로 선언

컬렉션

- 표준 라이브러리에서 null인 값을 필터링하는 filterNotNull 함수 제공
- kotlin.collections.Collection : 읽기 전용 / size, iterator(), contains()
- kotlin.collections.MutableCollection : 변경 가능 / add(), remove(), clear()
- 컬렉션 생성 함수

컬렉션 타입	읽기 전용 타입	변경 가능 타입
List	listOf	mutableListOf, arrayListOf
Set	setOf	mutableSetOf, hashSetOf, linkedSetOf, sortedSetOf
Map	mapOf	mutableMapOf, hashMapOf, linkedMapOf, sortedMapOf

// Java
interface DataParser<T> {
    void parseDate(String input, List<T> output, List<String> errors);
}
// Kotlin
class PersonParser : DataParser<Person> {
    override fun parseDate(input: String, output: MutableList<Person>, errors: MutableList<String?>) {}
}

배열

- arrayOf : 입력한 원소를 기준으로 배열 생성
- arrayOfNulls : 입력한 정수 값 기준으로 모든 원소가 null이고 입력한 값의 크기로 배열 생성
- Array 생성자 : 각 원소가 null이 아닌 배열을 만들어야 하는 경우 사용

val letters = Array<String>(26) { i -> ('a'+i).toString() }
val zeros = IntArray(5) // 기본값 0
val zeros = intArrayOf(0,0,0,0,0)
val squares = IntArray(5) { i -> (i+1) * (i+1) }
>>> println(squares.joinToString()) // 1, 4, 9, 16, 25

- 컬렉션을 배열로 변경 : toTypedArray()

val strings = listOf("a", "b", "c")
println("%s/%s/%s".format(*strings.toTypedArray())) // 스프레드 연산자(*)

Kotlin - 클래스, 객체, 인터페이스

RootedIn — Mon, 1 May 2023 11:13:13 +0900

인터페이스

interface Clickable {
    fun click()
    fun showOff() = println("clickable")
}

interface Focusable {
    fun setFocus(b: Boolean) = println("${if (b) "got" else "lost"} focus")
    fun showOff() = println("focusable")
}

class Button : Clickable, Focusable {
    override fun click() = println("click")
    override fun showOff() {
        super<Clickable>.showOff()
        super<Focusable>.showOff()
    }
}

클래스

open class RichButton : Clickable {
    fun disable() {} // final
    open fun animate() {} // open
    override fun click() {} // open(default)
    final override fun click() {} // final
}

abstract class Animated {
    abstract fun animate()
    open fun stopAnimating() {} // open
    fun animateTwice() {} // final
}

- final : override 불가
- open : override 가능
- abstract : override 필수

- public : 모든 곳
- internal : 같은 모듈
- protected : 하위 클래스
- private : 같은 클래스

내부 클래스에서 외부 클래스 참조에 접근하려면 this@Outer

class Outer {
    inner class Inner {
        fun getOuterReference(): Outer = this@Outer
    }
}

sealed class

interface Expr
class Num(val value: Int) : Expr
class Sum(val left: Expr, val right: Expr) : Expr
fun eval(e: Expr): Int =
    when (e) {
        is Num -> e.value
        is Sum -> eval(e.right) + eval(e.left)
        else -> throw Exception() // else 분기 필수
    }
}

sealed class Expr {
    class Num(val value: Int) : Expr()
    class Sum(val left: Expr, val right: Expr) : Expr()
}
fun eval(e: Expr): Int =
    when (e) {
        is Expr.Num -> e.value
        is Expr.Sum -> eval(e.right) + eval(e.left)
        // else 없어도됌
    }

데이터 클래스

- equals, hashCode, toString 메소드 포함

Kotlin - 람다 프로그래밍

RootedIn — Mon, 1 May 2023 11:10:56 +0900

람다 기본 문법

val peoples = listOf(Person("alice", 29), Person("bob", 31))
println(peoples.maxBy { it.age }) // Persion(name=bob, age=31)

peoples.maxBy(persion::age)

val = sum { x: Int, y: Int -> x + y }
sum(1, 2)

run : 인자로 받은 람다를 실행해주는 라이브러리 함수

run { println(42) }

peoples.maxBy({ p: Person -> p.age })
peoples.maxBy() { p: Person -> p.age })

인자에 람다 넘기기

peoples.joinToString(seperator = " ", transform = { p: Person -> p.name })

peoples.joinToString(" ") { p: Person -> p.name }

peoples.maxBy { p: Person -> p.age }
peoples.maxBy { p -> p.age }

it : 디폴트 파라미터 이름

peoples.maxBy { it.age }

람다를 변수에 저장할 때는 파라미터 타입 추론이 불가하여 반드시 명시

val getAge = { p: Person -> p.age }

여러 줄로 이뤄진 람다는 마지막 식이 람다의 결과 값

val sum = { x: Int, y: Int ->
    println("$x plus $y")
    x + y
}

현재 영역에 있는 변수에 접근

fun printMessagesWithPrefix(messages: Collection<String>, prefix: String) {
    messages.forEach {
        println("$prefix $it")
    }
}

람다 안에서 바깥 함수의 로컬 변수 변경하기

fun printProblemCounts(responses: Collection<String>) {
    var clientErrors = 0
    var serverErrors = 0
    responses.forEach {
        if (it.startsWith("4")) {
             clientErrors++
        } else if (it.startsWith("5")) {
             serverErrors++
        }
    }
    println("$clientErros client errors, $serverErrors server errors")
}

멤버 참조, 함수 참조

멤버 참조
val getAge = Person::age

최상위 함수 참조
fun salute() = println("salute")
run(::salute)

val nextAction = ::sendEmail

val createPerson = ::Person
val p = createPerson("alice", 29)

확장 함수도 참조 가능
fun Person.isAdult() = age >= 21
val predicate = Person::isAdult

컬렉션 함수형 API

- filter
- map
- 맵의 경우 filterKeys, mapKeys, filterValues, mapValues 함수 존재
- all
- any
- count
- find

val isAdult = { p: Person -> p.age >= 21 }

peoples.all(isAdult) // 모두 만족
peoples.any(isAdult) // 하나라도 만족
peoples.count(isAdult) // 만족하는 갯수
peoples.find(isAdult) // 만족하는 원소 한개 찾기, 없는 경우 null

- groupBy : 컬렉션을 맵으로 변환
- flatMap : 중첩된 컬렉션 안의 원소 처리

books.flatMap { it.authors }.toSet()
val strs = listOf("abc", "def")
str.flatmap { it.toList() } >> a, b, c, d, e, f

지연 컬렉션 연산

- 시퀀스 연산 실행 : 중간 연산과 최종 연산

sequence.map { }.filter { }.toList()
- 중간 연산 : map, filter
- 최종 연산 : toList

- 자바 8 이후 스트림 = 시퀀스는 동일 / 이전 자바 버전 사용할 경우 시퀀스 사용

시퀀스 생성

val naturalNumbers = generateSequence(0) { it + 1 }
val numbersTo100 = naturalNumbers.takeWhile { it <= 100 }
numbersTo100.sum()

fun File.isInsideHiddenDirectory() = generateSequence(this) { it.parentFile }.any { it.ishidden }
val file = File("/Users/user/.HiddenDir/a.txt")
file.isInsideHiddenDirectory()

자바 메소드에 람다를 인자로 전달
void postponeComputation(int delay, Runnable computation);
postponecomputation(1000) { println(42) }

SAM 생성자 : 람다를 함수형 인터페이스로 명시적으로 변경

fun createAllDonerunnable() : Runnable {
    return Runnable { println("done") }
}

>>> createAllDoneRunnable().run()

val listener = OnClickListener { view ->
    val text = when (view.id) {
        R.id.button1 -> "first"
        R.id.button2 -> "second"
        else -> "unknown"
    }
    toast(text)
}
button1.setOnClickListener(listener)
button2.setOnClickListener(listener)

수신 객체 지정 람다 : with, apply

with

fun alphabet() : String {
    val result = StringBuilder()
    for (letter in 'A'..'Z') {
        result.append(letter)
    }
    result.append("\nDone")
    return result.toString()
}

// with 사용
fun alphabet() : String {
    val stringBuilder = StringBuilder()
    return with(stringBuilder) {
        for (letter in 'A'..'Z') {
            this.append(letter)
        }
        this.append("\nDone")
        this.toString()
    }
}

// with 사용
fun alphabet() = with(StringBuilder()) {
    for (letter in 'A'..'Z') {
        this.append(letter)
    }
    this.append("\nDone")
    this.toString()
}

apply

fun alphabet() = StringBuilder().apply {
    for (letter in 'A'..'Z') {
        append(letter)
    }
    append("\nDone")
}.toString()

Kotlin - 함수 정의와 호출

RootedIn — Sat, 15 Apr 2023 23:16:27 +0900

컬렉션

val rank = listOf("1st", "2nd", "3rd")
val ints = setOf(1, 2, 3)

함수 정의

fun <T> joinToString(
  collection: Colletion<T>,
  separator: String = ",",
  prefix: String = "(",
  postfix: String = ")"
) : String {
  val result = StringBuilder(prefix)
  for ((index, element) in collection.withIndex()) {
    if (index > 0) result.append(separator)
    result.append(element)
  }
  result.append(postfix)
  return result.toStrinig()
}

joinToString(collection, ",", "(", ")")
joinToString(collection)
joinToString(collection, separator = "/", prefix = "[", postfix = "]")

확장 함수

fun String.lastChar(): Char = get(length - 1)

확장 프로퍼티

val String.lastChar: Char
  get() = get(length - 1)
  set(value: Char) {
    this.setCharAt(length - 1, value)
  }
  
"Kotlin".lastChar = 'x'

가변 인자 함수

fun listOf<T>(vararg values: T): List<T> { }

중위 호출

1.to("one") // 일반적인 방식
1 to "one" // 중위 호출 방식

구조 분해 선언

val (number,name) = 1 to "one"

로컬 함수

// 로컬 함수로 추가하기
fun saveUser(user: User) {
  fun validate(value: String) {
    if (value.isEmpty()) {
      throw IllegalArgumentException("${user.id}")
    }
  }
  validate(user.name)
  validate(user.address)
}

// 확장 함수로 추출하기
fun User.validateBeforeSave() {
  fun validate(value: String) {
    if (value.isEmpty()) {
      throw IllegalArgumentException("${user.id}")
    }
  }
  validate(user.name)
  validate(user.address)
}

fun saveUser(user: User) {
  user.validateBeforeSave()
}

Kotlin - 기초

RootedIn — Sat, 15 Apr 2023 22:33:49 +0900

함수

fun sum(a: Int, b: int) : Int {
    return a + b
}
fun sum(a: Int, b: Int) = a + b

변수

val = value, 변경 불가
var = variable, 변경 가능

문자열 템플릿

fun main(args: Array<String>) {
    println("${if (args.size > 0) args[0] else ""}")
}

클래스

class Database(val name: String)

프로퍼티

class Database(
    val name: String,
    var isOpenSource: Boolean
)

커스텀 접근자

class Database(
    val name: String,
    var isOpenSource: Boolean
) {
    val isFree: Boolean
      get() {
        return isOpenSource
      }
}

enum

enum class DatabaseType {
  MYSQL, MARIADB, POSTGRESQL, ORACLE
}

enum class DatabaseType(
  val tp: String
) {
  MYSQL("RDBMS"), MARIADB("RDBMS"), MONGODB("NoSQL")
}

when

interface Expr
class Num(val value: Int) : Expr
class Sum(val left: Expr, val right: Expr) : Expr

fun eval(e: Expr) : Int =
  when (e) {
    is Num ->
      e.value
    is Sum ->
      eval(e.right) + eval(e.left)
    else ->
      throw IllegalArgumentException("Unknown expression")
  }

while

while (condition) {

}

do {

} while (condition)

for

for (i in 1..100) {
  // 1 ~ 100
}

for (i in 100 downTo 1 step 2) {
  // 100, 98, ..., 4, 2
}

for (c in 'A'...'Z') {
  // A, B, ..., Z
}

in

fun isDigit(c: Char) = c in '0'..'9'
fun isNotDigit(c: Char) = c !in '0'..'9'
fun categorize(c: Char) = when (c) {
  in '0'..'9' -> "digit"
  in 'a'..'z', in 'A'..'Z' -> "letter"
  else -> "?"
}

try catch finally

fun readNumber(reader: BufferedReader) {
  val number = try {
    Integer.parseInt(reader.readLine())
  } catch (e: NumberFormatException) {
    null
  }
  println(number)
}