Kotlin

val 은 read-only지만 constant는 아니다.

컴파일 시점 상수는 프로그램 실행 전에 생성과 초기화된다.

const 키워드를 사용해 컴파일 시점 상수를 선언할 수 있다.

함수 밖에 정의된 변수를 top-level(혹은 file-level) 변수라고 한다.
파일 수준 변수는 항상 선언되ㅏㄹ 때 초깃값이 지정되어야 하며, 그렇지 않으면 컴파일 에러가 발생한다.

const val MAX_LENGTH: Int = 5000 // (1)

fun main(args: Array<String>) {
  ...
}

Kotlin에서는 var이나 val 중 어느것으로 정의되든 모든 문자열은 불변이다.

== 을 통해 문자열 비교가 가능하다.

=== 연산자를 통해 참조 동등^{referential equality} 비교가 가능하다.

숫자 타입은 크게 정수와 실수로 분류된다.

정수는 소숫점 없는 수: Int

소수는 소숫점이 있는 수: Float, Double

String 을 숫자 타입으로 변환하는 함수들

format 함수를 호출하여 형식을 지정할 수 있다.

println("amount: ${"%.2f".format(balance)}")

Kotlin은 비트 연산^{bitwise operation}을 하는 함수들을 제공한다.

실행될 수 없는 표현식을 나타낸다. 기본적으로 예외를 던진다.

조건 표현식(conditional expression)은 조건문과 비슷하지만, if/else를 값으로 지정한다.

val message = if (point == 0) {
  "The point is empty"
} else if (point < 0) {
  "error"
} else {
  "point: " + point
}

println(message)

표현식이 하나만 있을 경우에는 중괄호를 생략할 수 있다.

val code = if (isEmpty) "EMPTY" else "NOT_EMPTY"

if (a) b else c

.. 키워드를 사용하면 범위(range)를 나타낼 수 있다.

val healthStatus = if (healthPoints == 100) {
  "BEST"
} else if (healthPoints in 90..99) { // (1)
  "GOOD"
} else if (healthPoints in 75..89) {
  "NOT_BAD"
} else {
  "BAD"
}

Kotlin은 범위에 관련된 다양한 함수를 지원한다.

1 in 1..3
// res0: kotlin.Boolean = true
(1..3).toList()
// res1: kotlin.collections.List<kotlin.Int> = [1, 2, 3]
1 in 3 downTo 1
// res2: kotlin.Boolean = true
(3 downTo 1).toList();
// res3: kotlin.collections.List<kotlin.Int> = [3, 2, 1]
1 in 1 until 3
// res4: kotlin.Boolean = true
3 in 1 until 3
// res5: kotlin.Boolean = false
2 in 1..3
// res6: kotlin.Boolean = true
2 !in 1..3
// res7: kotlin.Boolean = false
'x' in 'a'..'z'
// res8: kotlin.Boolean = true

Conditionals - Kotlin Programming Language

Java에서의 Swtich

Kotlin에는 함수명이 백틱(backtick) 기호(`)로 감싸인 함수를 정의할 수 있다.

Java와 Kotlin 의 예약어(reserved keyword)는 다르므로, Java와의 상호운용 시에 생길 수 있는 함수 이름 충돌을 피하기 위함이다.

코드를 테스트하는 파일에서 사용되는 함수 이름을 더 알기 쉽게 나타내기 위함이다.

중괄호를 통해 익명함수를 사용할 수 있다.

val numLetters = "Mississippi".count({ letter -> letter == 's' })

익명함수의 닫는 중괄호 다음에 빈 괄호(())를 사용하여 함수를 호출할 수 있다.

println({
  val year = 2020
  "Hello $year"
}())

익명함수도 타입을 가지며 이를 함수 타입이라고 한다.

익명함수도 함수처럼 인자를 받을 수 있으며, 함수명은 함수 내부에 지정한다.

val greetingFunction: (Int) -> String = { year ->
  "Hello $year"
}

하나의 인자만 받는 익명 함수에는 매개변수 이름을 지정하는 대신 편리하게 it 키워드를 사용할 수 있다.

val greetingFunction: (Int) -> String = {
  "Hello $it"
}

// as-is
val numLetters = "Mississippi".count({ letter -> letter == 's' })
// to-be
val numLetters = "Mississippi".count({ it == 's' })

익명함수에도 타입 추론(type inference)이 적용된다.

val greetingFunction = {
  val year = 2020
  "Hello $year"
}

val greetingFunction = { year: Int -> // (1)
  "Hello $year"
}

함수에서 마지막 매개변수로 함수 타입을 받을 때는 람다 인자를 둘러싼 괄호를 생략할 수 있다.

// as-is
"Mississippi".count({ it == 's' })
// to-be
"Mississippi".count { it == 's' }

fun runSimulation(name: String, getMessage: (String, Int) -> String) {
  val year = (2019..2020).shuffled().last()
  println(getMessage(name, year))
}

fun main(args: Array<String>) {
  val func = { name: String, year: Int ->
    println("Hello $year, $name")
  }
  runSimulation("yeongjun", func)
}

fun runSimulation(name: String, getMessage: (String, Int) -> String) {
  val year = (2019..2020).shuffled().last()
  println(getMessage(name, year))
}

fun main(args: Array<String>) {
  runSimulation("yeongjun") { name: String, year: Int ->
    println("Hello $year, $name")
  }
}

이 기능은 코틀린으로 도메인 특화 언어^{DSL, Domain Specific Language}를 생성할 수 있는 가능성을 열어준다.

함수 참조(function reference)는 이름이 있는 함수가 인자로 전달될 수 있게 한다.

람다 표현식을 사용할 수 있는 곳이라면 어디든 함수 참조를 사용할 수 있다.

Kotlin의 Lambda는 클로저(closure)다.

Higher-Order Functions and Lambdas - Kotlin Programming Language

Kotlin 라이브러리에 있는 표준 함수는 보편적으로 사용할 수 있는 유틸리티 함수이며, 람다를 인자로 받아 동작한다.

원칙적으로 중첩은 하지 않는 것이 좋다.

중첩이 아닌 호출 체인에 결합하면 코드의 가독성이 향상된다.

invoke 함수는 연산자다. invoke 연산자는 이름 없이 호출될 수 있다.

enum class UserType {
  STUDENT, WORKER
}

internal class Tests {
  @Test
  fun test() {
    val user = User("jun")
    user(UserType.STUDENT)

    Users("학생입니다.")
    Users(UserType.WORKER)
    User(1)
  }
}

class User(val name: String) {
  operator fun invoke(type: UserType) = when (type) {
    UserType.STUDENT -> "학생"
    UserType.WORKER -> "회사원"
  }

  companion object {
    operator fun invoke(value: Int) = User(value.toString())
  }
}

object Users {
  operator fun invoke(name: String) = User(name)
  operator fun invoke(type: UserType) = User(
    when (type) {
      UserType.STUDENT -> "학생"
      UserType.WORKER -> "회사원"
    }
  )
}

이것이 괄호로 람다 함수를 직접 호출할 수 있는 이유다.

타입 안전 빌더는 데이터를 선언적 방식으로 정의할 수 있게 해준다.

https://kotlinlang.org/docs/type-safe-builders.html#how-it-works

Scope control: @DslMarker

컴파일/런타임 에러 없이 항상 실행되도록 해야 할 경우 사용된다.

컴파일러가 안전 호출 연산자(?.)를 발견하면 null 값을 검사하는 코드를 자동으로 추가해준다.

null이 아니면 capitalize 함수를 호출하고, null이면 다른 코드를 수행한다.

안전 호출 연산자를 연속적으로 사용할 수 있다.

name?.capitalize()?.plus(", hello")

null일 때 샐행되는 코드가 복잡해진다면 if / != 연산자를 사용해서 null 검사를 하자.

var name = readLine()

if (name != null) {
  name = name.capitalize()
} else {
  // create user with default name
  // get readLine
  // set name
  // ...
}

non-null 단언 연산자(assertion operator)인 !! 는 null이 될 수 없다는 것을 단언하는 연산자다.

왼쪽의 피연산자 값이 null이 아니면 정상적으로 코드를 수행하고, null이면 런타임시에 NPE 예외를 발생시킨다.

한 함수에서 단언 연산자를 통해 non-null이라는 것을 확인한다면, 이 값을 받아 사용하는 함수들에서는 null checking을 할 필요가 없을 것이다.

null 가능 변수에 !! 연산자를 사용하는 것은 위험하다.

null 복합 연산자(null coalescing operator)인 ?: 는 왼쪽 피연산자의 값이 null이면 오른쪽 피연산자를 실행하고, null이 아니면 왼쪽 피연산자의 결과를 반환한다.

https://kotlinlang.org/docs/reference/java-interop.html#nullability-annotations

https://kotlinlang.org/docs/reference/java-interop.html#null-safety-and-platform-types

코틀린은 편의를 위해 전제 조건 함수^{precondition function}를 제공한다.

코드가 실행되기 전에 충족되어야 하는 전제 조건을 정의하는 함수이다.

Kotlin 1.3부터 더 나은 예외 핸들링을 위한 API가 추가되었다.

Result 는 함수의 반환 값으로 사용할 수 없으며, 함수 안에서 처리하고 결과를 반환해야 한다.

JDK7에는 Closable 을 구현한 객체에 대해서 close() 처리해주는 try-with-resource 기능이 있다.

Kotlin에서는 use() 함수를 활용할 수 있다.

listOf 를 통해 read-only list를 생성할 수 있다.

val list: List<String> = listOf("Yeongjun", "0jun", "wicksome") (1)

println(list.first()) // get first element
println(list[2])
println(list.last()) // get last element

안전한 인덱스 사용을 위한 메서드를 제공한다. (ArrayIndexOutOfBoundsException 를 피하기 위함)

list[3] // throw
list.getOrElse(3) { "jun" } // (1)
list.getOrNull(3) ?: "jun" // (2)

mutableListOf 를 통해 mutable한 list로 생성할 수 있다.

val list = listOf(1, 2, 3).toMutableList()
val mutableList = mutableListOf(1, 2, 3)

List는 destructure이 가능하다.

val (first, middle, last) = listOf(1, 2, 3)
val (first, second, _) = listOf(1, 2, 3) // (1)

다양한 함수를 제공한다.

val list = listOf(1, 2, 3, 4, 1)
list.contains(1)
list.containsAll(listOf(1, 2)

var numberSet = list.toSet()
var list2 = list.distinct() // (1)

Kotlin은 Array 라는 참조 타입으로 배열을 지원한다.

Set의 element는 고유하며(중복 없음), 순서를 갖지 않는다.

setOf 를 통해 생성할 수 있다.

elementAt(Int) 를 사용하면 인덱스 기반으로 사용이 가능하나, List 사용시보다 처리 속도가 느리다.

Map은 Key와 Value의 쌍(Pair)으로 데이터(이것을 entry라고 한다)를 저장한다.

mapOf, mutableMapOf 함수를 통해 생성할 수 있다.

mapOf(
  "Eli" to 10.5, // (1)
  "Mordoc" to 8.0
)

다양한 함수를 제공한다.

val map = mapOf(
  "ab" to 10,
  "cd" to 20
)

map["ab"] // 10
map["xx"] // null
map.getValue("xx") // throw NoSuchElementException
map.getOfElse("xx") { 30 } // 30
map.getOrDefault("xx", 30) // 30
map.getOrPut("xx") { 30 } // 30

가시성 제한자를 통해 정보은닉^{information hiding}, 캡슐화^{encapsulation}가 가능하다.

Kotlin은 클래스 함수나 속성에 가시성 제한자^{visibility modifier}를 지정하지 않으면 기본적으로 public 이다.

속성의 가시성이 public 이라면 getter/setter도 public 이다.

Java의 기존 가시성인 package-private은 Kotlin에는 없다.

Kotlin은 package-private의 대안으로 internal 이라는 새로운 가시성 변경자를 도입했다.

모듈^module은 한번에 한꺼번에 컴파일되는 코틀린 파을들을 의미한다.

Kotlin은 최상위 선언에 대해 private 가시성을 허용한다.

Kotlin과 Java의 protected 는 다르다는 사실에 유의하라.

클래스 속성은 클래스의 데이터, 즉 상태나 특성을 나타낸다.

Kotlin은 Getter를 통해 값을 가져오고, Setter를 통해 값이 설정한다.

Kotlin에서 클래스의 필드^field는 속성^property의 데이터가 저장되는 곳이며, 우리가 직접 정의할 수 없다.

위 코드는 보면 weapon은 nullable한 속성이지만 조건문을 통해 null이 발생할 수 없다.

하지만 스마트 캐스팅^{smart casting}이 일어나지 않는다.

null 체크하는 코드와 println 코드 사이에 weapon 속성 값이 변경될 가능성이 여전히 있으므로 에러가 된다.

Java는 기본적으로 패키지 가시성을 사용한다.

Kotlin은 패키지 가시성이 없다.

Kotlin은 Java에 없는 internal 가시성을 지원한다.

생성자에 기본 인자 설정이 가능하다.

class Payment(
  _productName: String
  _unitPrice: Int,
  _count: Int = 1, // (1)
  private val isUsingPoint: Boolean
) {
  val name = _productName
      get() = field.capitalize()

  var total = _unitPrice * _count

  constructor(name: String) : this(
    name,
    0,
    isUsingPoint = false)
}

기본 인자 설정은 기본 생성자, 보조 생성자 모두 가능하다.

클래스의 속성에 기본값 설정이 가능하다.

class Payment(
  val name: String
  val price: Int = 0
) {
  val receipt = getRecentReceipt() // (1)

  private fun getRecentReceipt() = File("data/receipt.txt")
    .readText()
    .split("\r\n")
    .first()
}

Kotlin에서는 init 키워드를 통해 클래스의 초기화 블록^{initializer block}을 정의할 수 있다.

전제 조건 검사는 생성자나 속성보다는 초기화 블록에서 하는 것이 좋다. 초기화 블록은 어떤 생성자를 통해 호출되든 인스턴스가 생성될 때마다 자동으로 호출되어 실행된다.

여러 가지의 초기화 코드(기본 생성자, 보조 생성자, 초기화 블록)에서 같은 속성이 참조될 때, 초기화가 처리되는 순서가 중요하다.

아래 코드를 디컴파일된 바이트 코드를 보면 다음과 같다.

class Player(_name: String, val health: Int) { // (1)
  val race = "DWARF" // (2)
  var town = "Bavaria"
  val name = _name
  val alignment: String
  private var age = 0

  init {
    println("initializaing player") // (3)
    alignment = "GOOD"
  }

  constructor(_name: String) : this(_name, 100) {
    town = "The shire" // (4)
  }
}

public final class Player {
  @NotNull private final String race;
  @NotNull private String town;
  @NotNull private final String name;
  @NotNull private final String alignment;
  private int age;
  private final int health;

  public Player(@NotNull String _name, int health) {
    super();
    this.health = health; // (1)
    this.race = "DWARF"; // (2)
    this.town = "Bavaria";
    this.name = _name;
    String var3 = "initializaing player"; // (3)
    boolean var4 = false;
    System.out.println(var3);
    this.alignment = "GOOD";
  }

  public Player(@NotNull String _name) {
    this(_name, 100);
    this.town = "The shire"; // (4)
  }
}

초기화 블록에서 사용되는 모든 속성은 소스 코드에서 초기화 블록이 정의되기 전에 초기화되어야 한다.

class Player {
  init {
    val healthBonus = health.times(3) // (1)
  }
  val health = 100
}

컴파일러는 초기화 블록에서 속성을 사용하는 함수와 비교하면서까지 속성의 초기화 순서를 검사하지 않는다.

class Player {
  val name: String

  private fun firstLetter() = name[0]

  init {
    println(firstLetter()) // (1)
    name = "Madrigal" // (2)
  }
}

is 키워드를 통해 현재 객체가 특정 타입인지 검사할 수 있다.

val room = Room("Foyer")
room is Room // true
room is TownSquare // false

val townSquare = TownSquare()
townSquare is Room // true (1)
townSquare is TownSquare // true

Kotlin의 모든 non-null 클래스는 자동으로 Any 라는 최상위 슈퍼 클래스로부터 상속받는다.

as 키워드를 통해 타입 변환이 가능하다.

fun print(any: Any) {
  val isPlayerAOrMyRoom = if (any is Player) {
    true
  } else {
    (any as Room).name == "MyRoom"
  }
}

타입 변환은 유용하지만 우리가 안전하게 사용해야 한다.

위 코드를 보면 any.name == "A" 에 타입 변환없이 name 속성을 참조했다.

Kotlin 컴파일러는 any 객체 타입이 Player 타입 비교 이후에 Player 인 것을 알고 있으므로 스마트 캐스팅^{smart casting}이라는 타입 변환이 일어난다.

즉, 우리가 직접 타입 변환을 하지 않아도 된다.

null이 아님을 확신하지만 초기화 시점에 할당을 안하는 속성일 경우 notNull

val name: String by Delegates.notNull<String>()

fun main(args: Array<String>) {
  name = "jun"
  println(name)
}

인스턴스의 생성 시점에 속성을 초기화 할 수 없을 땐 지연 초기화를 활용할 수 있다.

lateinit 키워드를 사용한다.

Kotlin의 표준 라이브러리인 isInitialized 함수를 사용하여 초기화 되었는지 확인할 수 있다.

대안으로 nullable 타입의 속성을 사용할 수 있지만, 모든 코드에서 null 체크를 해야하므로 코드 작성이 번거로울 수 있다.

lateinit 키워드는 클래스 속성 외에 최상의 수준 속성과 함수의 지역 변수에도 사용될 수 있다.

lateinit, Delegates.notNull() 모두 var 속성에서만 동작한다. 그렇다면 val 속성을 사용할 때는 무엇을 사용해야 하는가?

변수나 속성이 최초 사용될 때까지 초기화를 연기할 수 있다.

Kotlin에서 늦 초기화^{lazy initialization}는 위임^delegation 메커니즘을 사용해서 구현한다.

Kotlin 표준 라이브러리인 lazy 함수를 대리자로 사용하여 초기화를 위임한다.

언어 자체에서 lazy 계산법을 기본적으로 제공하지는 않지만, 코틀린 표준 라이브러리와 델리게이트 속성이라는 언어 기능의 일부로 제공한다.

by lazy vs lateinit: https://stackoverflow.com/questions/36623177/kotlin-property-initialization-using-by-lazy-vs-lateinit

속성의 값 변경을 살펴봐야 하며, 변경이 일어나는 즉시 뭔가를 수행해야 하는 경우

값 변경을 거부할 수 있게 하는 표준 델리게이트

맵 위임은 위임과 함께 제공되는 멋진 기능 중 하나

맵 위임은 함수/클래스 생성자에서 여러 파라미터 대신에 하나의 파라미터로 맵을 전달할 수 있다.

https://kotlinlang.org/docs/delegated-properties.html#storing-properties-in-a-map

직접 델리게이트를 만들 수 있다.

var 속성에 대해 델리게이트를 만들려면 ReadWriteProperty 인터페이스를 구현한다.

델리게이트를 사용할 땐 함수가 있어야 한다. 확장한 클래스를 익명 오브젝트로 생성하는 inline 함수를 만들어서 사용할 수 있다.

코틀린 1.1부터는 로컬 속성에 대해서도 델리케이트가 가능하다.

https://kotlinlang.org/docs/delegation.html

https://nwillc.medium.com/kotlin-data-class-inheritance-by-delegation-2ad3fe6f9bd7

object 키워드를 사용하여 싱글톤^singleton 객체를 정의할 수 있다.

object 키워드를 사용하는 세 가지 방법이 있다.

다른 클래스 내부에 중첩된 클래스를 정의할 수 있다.

특정 객체에서만 필요하고 다른 코드에서는 사용하지 않을 때 활용할 수 있다.

외곽 클래스에서는 중첩된 클래스의 속성과 함수를 사용할 수 없다.

위 코드는 Java 코드로 디컴파일하면 클래스 내부에 private static final class GameInput 로 정의된다.

데이터를 저장하기 위해 특별히 설계된 클래스이다.

다음과 같은 요구사항이 충족되야 한다.

데이터 클래스를 정의하면 속성에 맞게 처리되는 toString, equals, hashCode 함수들이 자동으로 생성된다.

데이터가 있는 불변 엔티티를 나타낸다.

value 키워드를 사용한다.

단 하나의 프로퍼티만 가진다.

모든 프로퍼티는 val 이어야 한다.

=== 을 지원하지 않는다.

inline class 였다.

@JvmInline annotation

열거형^{enumerated type}은 enum 클래스로 정의할 수 있다.

Kotlin에서 enum 클래스의 각 항목에 대해 내부적으로 name과 ordinal 속성을 갖는다.

== vs ===

ADT(Algebraic data type, 대수적 데이터 타입)는 지정된 타입과 연관될 수 있는 서브 타입들의 폐집합(closed set)을 나타낼 수 있다.

enum 클래스를 포함해서 ADT의 장점은 우리가 모든 타입을 처리했는지 컴파일러가 검사할 수 있다는 것이다.

enum class Grade {
  GOLD, SILVER
}

fun getRate(grade: Grade) = when (grade) { // compile error
  GOLD -> 4.5
}

sealed 클래스는 자신의 서브 클래스 종류를 제한하기 위해 사용된다.
(sealed: 봉인을 한, 봉인하다, 밀봉하다.)

sealed 클래스에 속하는 서브 클래스들은 일반 클래스이므로 인스턴스 갯수에 제한이 없다.

sealed 클래스는 두 가지 형태로 사용할 수 있다.

Kotlin에는 여러가지 연산자가 있다.

Kotlin 컴파일러는 a + b 를 컴파일하여 a.plus(b) 를 실행하도록 바이트코드로 생성한다.

Kotlin의 연산자들을 함수이므로 오버로딩이 가능하다.

Type aliases는 기존 타입의 대체 이름을 제공한다.

typealias NodeSet = Set<Network, Node>

오브젝트로 함께 사용할 수 있다.

typealias UserFactory = User.Companion

Type aliases - Kotlin Guide

추상 클래스는 class 키워드 앞에 abstract 키워드를 추가하여 정의한다.

추상 클래스는 인스턴스를 생성할 수 없다.

Kotlin에서는 in 과 out 키워드를 사용하여 제네릭 타입 매개변수를 더 다양한 방법으로 조정할 수 있다.

제네릭 타입 매개변수에 out 키워드를 지정한 것을 공병형^covariance 이라고 하고, in 키워드를 지정한 것을 반공변형^{contravariance} 이라고 한다.

in, out 키워드는 컴파일러가 <> 로 나타낸 제네릭 타입 간의 슈퍼-서브 관계가 있더라도 인식하지 못하는 문제를 해결해준다.

internal class LocalTest {
  @Test
  fun test() {
    var child1: Generic<Child1> = Generic(Child1("child1"))
    var parent: Generic<Parent> = Generic(Child2("child2"))

    parent = child1 // 컴파일 오류 발생 (1)
  }
}

class Generic<T>(var value: T)

open class Parent(var value: String)
class Child1(value: String) : Parent(value)
class Child2(value: String) : Parent(value)

제네릭으로 인라인 함수에서 사용되며, 런타임에 타입 정보를 알고 싶을 때 사용된다.

컴파일된 JVM 바이드코드에는 제네릭 타입 매개변수의 정보가 수록되지 않고 소거된다.

이와 같은 문제를 해결하기 위해 코틀린은 제네릭 타입 매개변수를 컴파일러가 실페 타입으로 변경해 주는 기능을 지원한다. 이것을 제네릭 타입 매개변수의 실체화^reification라고 하며, reified 키워드를 사용한다.

reified 키워드를 사용하면 제네릭 매개변수로 전달된 인자의 타입과 제네릭 클래스 인스턴스의 타입을 런타임 시에 검사할 수 있다.

reified 키워드를 사용한 타입 매개변수의 실체화는 inline 키워드가 지정된 인라인 함수에서만 가능하다.

https://codechacha.com/ko/kotlin-reified-keyword/

확장 함수 정의하기

fun String.addEnthusiasm(amount: Int = 1) = this + "!".repeat(amount)

함수의 확장은 클래스 상속 없이도 가능하다. 그러나 확장 함수의 호출 가능 범위를 넓히기 위해서 상속과 함께 사용될 수 있다.

fun Any.easyPrint() = println(this)

상속 관계에서의 확장 함수

import org.junit.jupiter.api.Test

internal class Tests {
  @Test
  fun test() {
    printSpeak(Feline()) // "일반적인 고양잇과 소리"
    printSpeak(Cat()) // "일반적인 고양잇과 소리"
  }
}

open class Feline

fun Feline.speak() = "일반적인 고양잇과 소리"

class Cat : Feline()

fun Cat.speak() = "야옹!!"

fun printSpeak(feline: Feline) {
    println(feline.speak()) // (1)
}

제네릭 확장 함수

Type aliases와 함께 사용하면 불필요한 타입을 만드는 것을 피할 수 있다.

typealias AccountNumber = String

fun AccountNumber.masked(): String {
	return "${this.substring(0..2)}****${this.takeLast(4)}"
}

val accountNumber: AccountNumber = "123456789"

println(accountNumber)
println(accountNumber.masked())

nullable한 타입에도 확장함수를 사용할 수 있다.

fun String?.printlnWithDefault(default: String) = println(this ?: default)

확장 함수는 바이트코드에서 static 메서드로 변환된다.

확장 속성은 산출 속성처럼 후원 필드를 갖지 않는다.

따라서 속성에서 반환된 값을 산출하는 get을 반드시 정의해야 한다.

확장 속성은 후원 필드를 갖지 않으므로 초기화할 수 없기 때문이다.

따라서 var 대신 val을 지정하고 원하는 값을 반환하는 get을 정의해야 한다.

확장 함수가 선언된 클래스의 인스턴스를 디스패치 리시버라 함

참고: https://blog.kotlin-academy.com/programmer-dictionary-extension-receiver-vs-dispatch-receiver-cd154e57e277

하나의 파라미터만 가진 (일반 혹은 확장) 함수는 infix 로 표기할 수 있다.

infix 키워드는 하나의 인자를 갖는 확장 함수와 클래스 함수 모두에 사용할 수 있다.

함수 호출 문법을 간결하게 해준다.

함수에 infix 키워드를 지정한 것을 중위 함수^{infix function}라고 한다.

중위 함수를 호출할 때는 수신자 객체와 함수 호출 사이의 점(.)은 물론이고 인자 주위의 괄호도 생략할 수 있다.

Kotlin의 비트 연산자^{bitwise operator}는 shl, shr, ushr, and, or, xor, inv 와 같은 중위함수로 정의되어 있다.

Kotlin의 Extension은 어떻게 동작하는가 part 1

Kotlin의 Extension은 어떻게 동작하는가 part 2

Kotlin의 Extension은 어떻게 동작하는가 part 3

명령형 프로그래밍에서는 항상 해당 시점의 상태를 저장하는 변수들을 많이 생성해야 한다.

함수형 코드 구현에서는 새로운 축적 변수를 정의할 필요가 없다.

확장성이 좋다.

List, Set, Map 과 같은 컬렉션 타입들은 조기 컬렉션^{eager collection}이라고 한다.

다른 컬렉션으로는 지연 컬렉션^{lazy collection}이 있다.

Kotlin은 시퀀스^sequence라는 내정된 지연 컬렉션 타입을 제공한다. (ref)

시퀀스는 저장되는 항목의 갯수에 제한이 없다. → 무한 수열

시퀀스를 사용할 때는 새로운 값이 요청될 때마다 참조되는 반복자 함수^{iterator function}를 정의한다.

generateSequence(0) { it + 1 }
  .onEach { println("value: $it" }

1000개의 소수를 얻기 위해서는 얼마나 많은 수를 검사해야 할까?

함수형 프로그래밍에서는 새로운 컬렉션을 자주 생성해야 한다.

Java의 모든 객체는 언제든지 null이 될 수 있다.

Java 코드에 @Nullable 어노테이션을 사용하면 Kotlin에서 String? 타입으로 간주된다.

import org.jetbrains.annotations.Nullable;

public class Jhava {
  @Nullable
  public String getNull() {
    return null;
  }
}

Kotlin 타입은 Java 타입과 일대일로 매핑된다.

Kotlin에서는 기본 타입을 포함해서 모든 타입이 객체다.

런타임시 point 변수는 Java의 기본 타입은 int 로 변환된다.

Kotlin에서는 기본 타입도 객체를 사용하므로 객체지향의 장점을 활용할 수 있다.

Kotlin은 런타임 시, 성능 향상을 위해 상황에 따라 자동으로 Java의 기본 타입으로 매핑시켜 준다.

Kotlin은 속성의 데이터를 갖는 후원 필드의 접근을 제한하며, 자동 생성된 게터와 세터를 통해서만 외부에서 사용할 수 있다.

@JvmName

@JvmOverloads

@JvmField

@JvmStatic

@Throws

FunctionN

Kotlin-Java interop guide

Kotlin에서 속성과 Java의 필드는 다르므로, 어노테이션을 필드에 추가하려면 @field: 을 활용해야 한다.

val, var 모두 적용 가능하다.

https://kotlinlang.org/docs/reference/annotations.html#annotation-use-site-targets

https://www.baeldung.com/spring-boot-bean-validation

Kotlin 기반의 멀티플랫폼 테스트 프레임워크

Test Framework / Assertions Library / Property Testing 의 subproject로 구성

BDD 스타일을 포함한 총 10가지 테스트 스타일 지원

Assertions

JVM위에서 Kotest는 JUnit Platform 의존성 필요

Kotlin 기반의 Mocking 라이브러리

Mockito와 흡사하게 기존적인 mocking feature 지원

Kotlin 특화 기능 지원

Annotation기반의 mock 객체 생성 지원

Strict vs. Relaxed mock

BehaviorSpec

DescribeSpec

Coroutine이 표준 라이브러리에 정식 포함

Gradle

fun interface

value class

sealed interface