타입 시스템

널 가능성

• null이 될 수 있는지 여부를 타입 시스템에 추가하여 컴파일러 단에서 미리 감지해 실행 시점에 발생할 수 있는 예외 가능성을 줄일 수 있다.

• 기본적으로 null 또는 null이 될 수 있는 인자를 넘기지 못하도록 되어있다.

fun strLen(s: String) = s.length

• null을 인자로 받을 수 있게 하려면 타입 뒤에 물음표를 명시해야 한다.

fun strLen(s: String?) = s.length

• 널이 될 수 있는 값은 널이 될 수 없는 타입에 할당할 수 없다.

val x: String? = null
val y: String = x // ERROR: Type mismatch: inferred type is String? but String was expected

• 널이 아님이 확실한 영역에서는 해당 값을 널이 될 수 없는 타입처럼 사용할 수 있다. 예를 들어 아래와 같이 널인지 값을 검사한 후에 사용한다면 널이 될 수 없는 타입처럼 사용할 수 있다.

fun strLen(s: String?) : Int =
    if (s != null) s.length else 0

• 타입이란 어떤 값들이 들어올 수 있는지와 타입에 대해 수행할 수 있는 연산의 종류를 결정한다.

• String 타입과 double 타입은 각각 할당 가능한 값과 실행할 수 있는 연산이 다르다. 하지만 null 값이 해당 타입에 할당될 경우 일반적인 값과 달리 실행할 수 있는 연산이 없어지게 된다.

• 코틀린에서는 널이 될 수 있는 타입과 널이 될 수 없는 타입을 구분하여 각 타입의 값에 어떤 연산이 가능한 지 쉽게 파악하도록 한다. 또한 이를 컴파일 타임에 검증하게 된다.

?. 호출 연산자

• null 검사와 메서드 호출을 한 번에 수행한다.

• 만약 호출 대상 객체가 null이라면 메서드를 수행하는 대신 null을 바로 반환한다.

• 예를 들어 s?.toUpperCase() 는 if (s != null) s.toUpperCase else null 과 같다. 또한 반환 결과가 널이 될 수 있는 타입인 String?이 된다.

• 프로퍼티를 읽거나 쓸 때에도 ?. 연산자를 사용할 수 있다.

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

• ?. 연산자 호출을 연쇄적으로 하여 여러 객체의 null 검사를 쉽게 수행할 수 있다.

fun Person.countryName(): String {
   val country = this.company?.address?.country
   return if (country != null) country else "Unknown"
}

?: 엘비스 연산자

• null 대신 사용할 디폴트 값을 지정할 때 사용하는 연산자이다.

• 아래는 s가 null이 아니면 그대로 변수에 할당하고, null이면 ""를 변수에 할당하는 예시이다.

val t: String = s ?: ""

• 코틀린에서는 return이나 throw 등의 연산도 식이다. 따라서 엘비스 연산자의 우항에 return, throw 등의 연산을 넣을 수 있다.

• 아래는 사람 객체에 연관된 회사의 주소가 없다면 예외를 발생시키는 예시이다.

fun printShippingLabel(person: Person) {
    val address = person.company?.address
      ?: throw IllegalArgumentException("No address")
    with (address) {
        println(streetAddress)
        println("$zipCode $city, $country")
    }
}

as?

• 어떤 값을 지정한 타입으로 캐스트할 수 있다면 변환하고, 불가능하면 null을 반환한다.

• 아래 예제에서는 인자를 Any 타입으로 받았을 때 as? 를 통해 타입 캐스팅을 하고, 만약 변환에 실패해 null이 반환되면 ?: 연산자로 검사한다.

fun equals(o: Any?): Boolean {
       val otherPerson = o as? Person ?: return false
       
       return otherPerson.firstName == firstName &&
              otherPerson.lastName == lastName
}

!! 단언문

• 널이 될 수 있는 타입의 값을 다룰 때 널이 될 수 없는 타입으로 변환하는 연산자이다.

• 널에 대해 !!를 적용하면 NPE가 발생한다.

• 아래와 같이 널이 될 수 있는 값에 !!를 적용하면 널일 때는 NPE를 발생시키고, 널이 아닐 때에는 값을 적용시킨다.

fun ignoreNulls(s: String?) {
    val sNotNull: String = s!!
    println(sNotNull.length)
}

• 널이 될 수 있는 타입에 항상 널이 아닌 값이 들어오는 경우 유용하게 사용할 수 있다.

• 널에 대해 !! 를 사용하여 예외가 발생할 때 어떤 식에서 발생했는지에 대한 정보가 없기 때문에 여러 !! 단언문을 한 줄에 쓰지 않는 것이 좋다.

person.company!!.address!!.country 

let 함수

• let 함수는 자신의 수신 객체를 인자로 전달받은 람다에 넘긴다.

• 널이 아닌 타입을 인자로 받는 함수에 널이 될 수 있는 타입을 넘길 때 안전한 호출 구문과 함께 let 함수를 사용하면, 널이 아닌 타입으로 바꾸어 람다에 전달하게 된다.

• 아래와 같이 ?. 호출 연산자로 let 함수를 호출하면 email 값이 null이 아닐 때에만 람다가 수행된다.

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

• 아래와 같이 함수의 결과를 변수에 저장할 필요 없이 바로 let 메서드를 통해 null이 아니면 람다를 수행하도록 할 수 있다.

getTheBestPersonInTheWorld()?.let { sendEmailTo(it.email) }

지연 초기화

• 널이 될 수 없는 프로퍼티에 대해서는 생성자가 아닌 별도 메서드에서 지연 초기화가 불가능하다.

• 따라서 지연 초기화 이후에 항상 널이 될 수 없는 필드를 널이 가능한 타입으로 두고 접근할 때 마다 널 검사를 하거나 !! 연산자를 붙여야 한다.

• lateinit 변경자를 붙이면 프로퍼티를 나중에 초기화할 수 있다.

• 만약 lateinit 프로퍼티에 초기화 되기 전 접근하면 예외가 발생한다.

• 아래와 같이 JUnit을 사용할 때 myService 필드를 널이 될 수 없는 필드로 두고 lateinit 변경자를 붙인다. 그렇게 되면 최초에는 널로 할당되고, @Before 함수에서 해당 필드가 초기화된다.

class MyTest {
    private lateinit var myService: MyService

    @Before fun setUp() {
        myService = MyService() 
    }

    @Test fun testAction() {
        Assert.assertEquals("foo", myService.performAction())
     }
}

널이 될 수 있는 타입 확장

• 널이 될 수 있는 타입에 대한 확장 함수를 정의하면 null 값을 다루는 강력한 도구로 활용될 수 있다.

• 코틀린에서는 String? 타입의 수신 객체에 대해 호출할 수 있는 isNullOrEmpty, isNullOrBlank 함수가 제공된다.

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

• 널을 검사하는 기능을 담은 확장 함수를 직접 작성할 수도 있다. 이 때 this는 널이 될 수 있으므로 명시적으로 널 여부를 검사해야 한다.

제네릭과 널 가능성

• 함수나 클래스의 모든 타입 파라미터는 기본적으로 널이 될 수 있다.

• 따라서 타입 파라미터를 사용할 때에는 널이 아닌지 확인한 후 사용해야 한다.

fun <T> printHashCode(t: T) {
    println(t?.hashcode())
}

• 널이 될 수 없도록 타입 상한을 지정하면 널 검사를 하지 않아도 된다.

fun <T: Any> printHashCode(t: T) {
    println(t.hashcode())
}

자바와 널 가능성

• 자바에서는 JSR-305 표준이나 jetbrains 어노테이션 등에서 제공하는 @Nullable, @NotNull어노테이션으로 널이 가능한지 아닌지 표현할 수 있다.

• 코틀린에서는 이 어노테이션에 따라 널 가능 타입인지 확인한다.

• 코틀린이 널 관련 정보를 알 수 없는 타입은 플랫폼 타입이 된다. 플랫폼 타입은 널이 될 수 있는 타입으로 처리해도 되고 널이 될 수 없는 타입으로 처리해도 된다. 즉, 모든 연산의 책임을 사용자에게 두게 된다.

val s: String? = person.name
val s2: String = person.name

• 플랫폼 타입은 코틀린에서 생성할 수는 없으며, 널 가능성을 알지 못한다는 의미에서 ! 가 붙는다. 예를 들어 자바에서 선언된 String 타입에 대해 코틀린이 널 가능성을 알 수 없다면 String! 타입으로 두게 된다.

• 코틀린에서 자바 클래스를 상속받아 메서드를 오버라이드할 때 파라미터와 반환타입을 널이 될 수 있는 타입으로 선언할지 널이 될 수 없는 타입으로 선언할 지 정할 수 있다.

• 아래는 java에 정의된 StringProcessor 인터페이스를 kotlin으로 상속받는 예제로, 메서드 파라미터를 널이 될 수 없는 String 타입으로 둘 수도 있고 널이 될 수 있는 String? 타입으로 둘 수도 있다.

interface StringProcessor {
    void process(String value);
}

class StringPrinter: StringProcessor {
    override fun process(value: String) {
        println(value)
    }
}

class NullableStringPrinter: StringProcessor {
    override fun process(value: String?) {
        if (value != null) {
            println(value)
        }
    }
}

원시 타입

• 코틀린은 자바와 달리 원시 타입과 래퍼 타입을 구분하지 않는다.

• 코틀린의 Int 타입은 기본적으로 자바의 원시 타입인 int로 컴파일된다. 단, 컬렉션과 같은 제네릭 클래스를 사용할 경우 자바의 래퍼 타입인 Integer로 컴파일된다.

• 아래와 같이 널 값이나 널이 될 수 있는 타입을 사용하지 않더라도 Integer 타입 컬렉션으로 컴파일된다.

val listOfInts = listOf(1, 2, 3)

• 코틀린에서 널이 될 수 있는 타입 중 Int?, Boolean? 과 같은 타입은 int, boolean으로 컴파일될 수 없으므로 Integer, Boolean과 같은 래퍼 타입으로 컴파일된다.

숫자 변환

• 한 타입의 숫자를 다른 타입의 숫자로 자동 변환하지 않는다.

• 코드에서 동시에 여러 숫자 타입을 사용할 때 예상치 못한 동작을 피하기 위해 항상 변수를 명시적으로 변환해 사용해야 한다.

val x = 1
println(x.toLong() in listOf(1L, 2L, 3L)

원시 타입 리터럴

• 숫자 리터럴 종류는 아래와 같다.

  • Long 타입 리터럴: L 접미사를 붙인다. ex) 123L

  • Double 타입 리터럴: 표준 부동소수점 표기법을 사용한다. ex) 0.12, 1.2e-10

  • Float 타입 리터럴: f나 F 접미사를 붙인다. ex) 123.4f

  • 16진 리터럴: 0x나 0X 접두사를 붙인다. ex) 0x123CB, 0xbcdL

  • 2진 리터럴: 0b나 0B 접두사를 붙인다. ex) 0b0000101

• 숫자 리터럴 중간에 _ 을 넣어 단위를 구분하기 쉽도록 할 수 있다. ex) 1_000_000

• 숫자 리터럴 사용 시 보통 변환 함수를 호출할 필요가 없다. 타입이 정해진 변수에 대입하거나 함수 인자로 넘기면 자동으로 변환 함수가 호출될 것이다.

• 산술 연산자의 경우 오버로딩이 되어 있어 여러 타입을 받아들일 수 있다.

val b: Byte = 1
val l = b + 1L

Any, Any?

• 자바에서 Object가 모든 클래스의 최상위 타입이듯, 코틀린에서는 Any 타입은 널이될 수 없는 모든 타입의 최상위 타입이다.

• 자바의 원시 타입은 Object 타입이 아니지만 코틀린에서는 Int, Double 등 모든 타입이 Any 타입이다.

• Any 타입은 널이 될 수 없으므로 null이 들어갈 수 없다.

• 널을 포함하는 모든 값을 대입하려면 Any? 타입을 사용해야 한다.

• 내부적으로 Any 타입은 자바의 Object와 대응된다. Any 타입은 toString, equals, hashcode 메서드를 사용할 수 있지만 wait, notify 등 Object 클래스의 다른 메서드는 사용할 수 없다. 따라서 해당 메서드를 사용하고자 한다면 Object 타입으로 캐스팅해야 한다.

Unit 타입

• 코틀린 함수를 자바의 void 메서드처럼 사용하려 할 때 Unit 타입을 반환하도록 하면 된다.

• Unit이란 단 하나의 인스턴스만 갖는 타입을 의미한다.

• Unit 타입은 모든 기능을 갖는 일반적인 타입이고, Unit이라는 값을 가진다.

• 아래 두 함수는 반환값이 없다는 의미를 동일하게 가진다.

fun f(): Unit {
    // ...
}

fun f() {
    // ...
}

• 제네릭 파라미터를 반환하는 함수를 오버라이드하면서 Unit을 반환할 수 있다.

• 아래는 제네릭 타입의 결과를 반환하지 않고 싶을 때 Unit 타입을 사용하는 예제이다. process 메서드는 결국 Unit 타입을 반환해야 하지만, 컴파일러가 자동으로 return Unit 를 넣어준다.

interface Processor<T> {
    fun process() : T
}
    
class NoResultProcessor : Processor<Unit> {
    override fun process() {
        // ...
    }
}

Nothing 타입

• 아무 값도 포함하지 않으며 함수의 반환 타입이나 반환 타입으로 쓰일 타입 파라미터로 사용되는 타입이다.

• 컴파일러는 Nothing이 반환 타입인 함수가 정상 종료되지 않는다는 것을 알고, 함수를 호출하는 코드를 분석할 때 사용한다.

• 아래와 같이 코틀린 테스트 시 제공되는 fail함수는 Nothing 타입을 반환한다. 컴파일러는 company.address가 널이라면 예외가 발생한다는 사실을 파악하고 address 값이 널이 아님을 추론한다.

fun fail(message: String) : Nothing {
    throw IllegalStateException(message)
}

val address = company.address ?: fail("No address")

컬렉션과 배열

널 가능성과 컬렉션

• 컬렉션 타입 인자 뒤에 ?를 붙이면 컬렉션의 원소로 널을 저장할 수 있다. 이 때 리스트 자체는 널이 될 수 없다.

fun searchAll(list: List<Int?>): Boolean {
}

• 아래와 같이 사용하면 리스트 필드 자체에 널을 저장할 수 있다. 하지만 컬렉션 원소로 널을 저장할 수는 없다.

fun searchAll(list: List<Int>?): Boolean {
}

• 코틀린 표준 라이브러리에서는 filterNotNull이라는 함수를 제공해 null 원소들을 제외한 원소들만 구할 수 있다.

val validNumbers = numbers.filterNotNull() // List<Int> 타입이다.

읽기 전용 / 변경 가능한 컬렉션

• 코틀린 컬렉션에는 Collection 인터페이스와 MutableCollection 인터페이스가 존재한다.

• Collection 인터페이스에는 읽기 전용 연산들이 존재하며, MutableCollection 인터페이스는 Collection 인터페이스를 확장하고 원소 추가/제거 연산들을 가진다.

• 코드에서는 되도록 읽기 전용 인터페이스를 사용하고 필요할 때에만 변경 가능한 인터페이스를 사용해야 한다.

• 원본 컬렉션의 변경을 막기 위해 다른 함수에 전달할 때 복사본을 넘길 수도 있다.

fun<T> copyElements(source: Colleciton<T>, target: MutableCollection<T>) {
    for (item in source) {
        target.add(item)
    }
}

fun main(args: Array<String>) {
    val source: Collection<Int> = arrayListOf(3, 5, 7)
    val target: MutableCollection<Int> = arrayListOf(1)
    
    copyElements(source, target)
}

• 읽기 전용 컬렉션이라고 해서 변경 불가능한 컬렉션인 것은 아니다. 다른 참조에서 MutableCollection 타입으로 사용할 수도 있기 때문이다.

코틀린 컬렉션과 자바

• 다음은 코틀린 컬렉션 인터페이스의 계층 구조이다.

• 읽기 전용, 변경 가능 인터페이스의 기본 구조는 자바 컬렉션 인터페이스를 그대로 옮겨 놓은 형태이다.

• 코틀린에서는 자바의 ArrayList, HashSet 클래스를 MutableList, MutableSet을 상속받은 것처럼 취급한다.

• 컬렉션 생성 함수는 아래와 같이 나뉘게 된다.

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

• 자바는 읽기 전용 컬렉션과 변경 가능 컬렉션을 구분하지 않으므로, 코틀린에서 읽기 전용 컬렉션을 자바 메서드 인자로 넘길 때 변경 가능해진다는 문제가 있다.

• 널이 아닌 원소로 이뤄진 컬렉션 타입을 자바 메서드 인자로 넘길 때에도 마찬가지로 컬렉션에 널이 들어갈 가능성이 있다.

• 이러한 문제를 해결하는 방법은 따로 없고, 사용자가 올바른 파라미터 타입을 넘겨 혼돈이 없도록 해야 한다.

컬렉션을 플랫폼 타입으로 다루기

• 코틀린은 자바에서 선언한 컬렉션 타입 변수를 플랫폼 타입으로 본다.

• 따라서 읽기 전용 컬렉션이나 변경 가능한 컬렉션 중 원하는 형태로 사용할 수 있다.

• 컬렉션 타입이 자바 메서드 시그니처에 있고 이를 코틀린에서 오버라이드하려 하면 마찬가지로 읽기 전용 컬렉션이나 변경 가능한 컬렉션 중 어떤 타입을 사용할 지 정해야 한다.

• 컬렉션이 널이 될 수 있는지, 원소로 널이 들어올 수 있는지, 오버라이드하는 메서드가 컬렉션을 변경하는지 등 자바에서 인터페이스나 클래스가 어떤 맥락에서 사용되는지 확인해 적절한 타입을 정해야 한다.

배열

• 타입 파라미터를 받으며 자바의 배열과 호환된다.

• arraysOf 함수에 여러 원소를 인자로 넣어 배열을 만들 수 있다.

• arraysOfNulls 함수에 정수 값을 인자로 넘겨 원하는 개수만큼 null이 담긴 배열을 만들 수 있다.

• 배열 크기와 람다를 인자로 받아 배열 원소를 초기화해주는 생성자도 존재한다.

val letters = Array<String>(26) { i -> ('a' + i).toString() }

• 코틀린에서 배열이 사용되는 상황은 다음과 같다.

  • 배열을 인자로 받는 자바 메서드 호출

  • vararg 인자를 받는 코틀린 함수 호출

• 컬렉션을 배열로 바꾸려면 toTypedArray 함수를 사용할 수 있다.

• 아래는 vararg 인자를 넘기기 위해 리스트 컬렉션을 배열로 변경한 후 스프레드 연산자 * 를 사용한 예제이다.

val strings = listOf("a", "b", "c")
println("%s/%s/%s".format(*strings.toTypedArray()))

• Array<Int>는 제네릭 타입이기 때문에 자바의 Integer[]로 변환된다.

• int[]와 같은 원시 타입 배열로 변환되도록 하려면 IntArray, CharArray, BooleanArray와 같이 원시 타입 배열을 위한 별도 클래스를 사용해야 한다.

• 원시 타입 배열을 만드는 방법은 아래 세 가지가 있다.

  • 생성자에 size 인자를 입력해 고정 크기 배열을 만들 수 있다.

  • 팩토리 함수를 사용해 여러 원소를 인자로 넣어 배열을 만들 수 있다.

  • 크기와 람다를 인자로 받는 생성자로 배열을 만들 수 있다.

val arr1 = IntArray(5)
val arr2 = IntArrayOf(0, 0, 0, 0, 0)
val arr3 = IntArray(5) { i -> (i+1) * (i+1) }

• forEachIndexed 함수를 사용해 배열의 인덱스와 원소를 순회할 수 있다.

fun main(args: Array<String>) {
    args.forEachIndexed { index, element ->
        println("Argument $index is: $element")
    }
}