2장 - 코틀린 기초

728x90

이번 장에서는 모든 프로그램의 필수 요소인 변수(variable), 함수(function), 클래스(class) 등을 코틀린에서 어떻게 선언하는지 살펴보고 프로퍼티(property)라는 개념을 배운다.

또한 코틀린의 여러 제어 구조를 배운다. 대부분의 코틀린 제어 구조는 자바와 비슷하지만 몇 가지 중요한 개선이 이뤄졌다.

그런 다음 스마트 캐스트(smart cast)에 대해 설명한다. 스마트 캐스트는 타입 검사와 타입 캐스트, 타입 강제 변환을 하나로 엮은 기능이다. 마지막으로 예외 처리(exception handling)를 살펴본다. 이번장을 다 읽고 나면 기본적인 코틀린 개념을 활용해 코드를 작성할 수 있다. (한 가지 주의할 점은 여기서 배운 내용만으로 작성할 수 있는 코드는 코틀린 다운 코드라고 부르기는 어렵다)

기본 요소: 함수와 변수

모든 프로그램을 구성하는 기본 단위인 함수와 변수를 살펴본다. 코틀린에서는 타입 선언을 생략해도 된다고 했는데, 코틀린이 어떻게 불변 데이터 사용을 권장하는지 배운다.

Hello, World!

고전적이면서도 간단한 예제 Hello, World!를 출력해보자.

fun main(args: Array<String>) {
    println("Hello, World!")
}

매우 간단한 코드이지만 아래와 같은 코틀린 문법의 특성을 발견할 수 있다.

함수를 선언할 때는 fun 키워드를 사용한다. 실제로도 코틀린 프로그래밍은 수많은 fun을 만드느느 재미있는 일이다.
파라미터 이름 뒤에 그 파라미터의 타입을 쓴다. 나중에 보겠지만 변수를 선언할 때도 마찬가지 방식으로 타입을 지정한다.
함수를 최상위 수준에 정의할 수 있다. 꼭 클래스 안에 함수를 넣어야 할 필요가 없다.
배열도 일반적인 클래스와 마찬가지다. 코틀린에는 자바와 달리 배열 처리를 위한 문법이 따로 존재하지 않는다.
System.out.println 대신에 println이라고 쓴다. 코틀린 표준 라이브러리는 여러 가지 표준 자바 라이브러리 함수를 간결하게 사용할 수 있게 감싼 래퍼(Wrapper)를 제공한다. println도 그런 함수 중 하나다.
최신 프로그래밍 언어 경향과 마찬가지로 줄 끝에 세미콜론(;)을 붙이지 않아도 된다.

함수

아무런 값도 반환하지 않는 함수를 어떻게 선언하는지 방금 살펴봤다. 하지만 의미 있는 결과를 반환하는 함수의 경우 반환 값의 타입을 어디에 지정해야 할까? 파라미터 목록 뒤의 어디쯤에 반환 타입을 추가하면 되리라 추측할 수 있다.

fun max(a: Int, b: Int) : Int {
    return if (a > b) a else b
}

println(max(1, 2)) 의 결과는 2가 출력된다.

함수 선언은 fun 키워드로 시작한다. fun 다음에는 함수 이름이 온다. 예제는 max라는 이름의 함수다. 함수 이름 뒤에는 괄회 안에 파라미터 목록이 온다. 함수의 반환 타입은 파라미터 목록의 닫는 괄호 다음에 오는데, 괄호와 반환 타입 사이를 콜론(:)으로 구분해야 한다.
코틀린 if는 (값을 만들어내지 못하는) 문장이 아니고 결과를 만드는 식(expression)이라는 점이 흥미롭다. 이 예제의 코틀린 if 식은 자바 3항 연산자로 작성한 (a > b) ? a : b 식과 비슷하다.

문(statement)과 식(expression)의 구분
코틀린에서는 if는 식이지 문이 아니다. 식은 값을 만들어 내며 다른 식의 하위 요소로 계산에 참여할 수 있는 반면 문은 자신을 둘러싸고 있는 가장 안쪽 블록의 최상위 요소로 존재하며 아무런 값을 만들어내지 않는다는 차이가 있다. 자바에서는 모든 제어 구조가 문인 반면 코틀린에서는 루프를 제외한 대부분의 제어 구조가 식이다. 나중에 이 책에서도 보여주겠지만, 제어 구조를 다른 식으로 엮어낼 수 있으면 여러 일반적인 패턴을 아주 간결하게 표현할 수 있다.

반면 대입문은 자바에서는 식이었으나 코틀린에서는 문이 됐다. 그로 인해 자바와 달리 대입식과 비교식을 잘못 바꿔 써서 버그가 생기는 경우가 없다.

식이 본문인 함수

조금 전에 살펴본 함수를 더 간결하게 표현할 수도 있다. 앞의 함수 본문은 if 식 하나로만 이뤄져 있다. 이런 경우 다음과 같이 중괄호를 없애고 return을 제거하면서 등호(=)를 식 앞에 붙이면 더 간결하게 함수를 표현할 수 있다.

fun max(a: Int, b: Int): Int = if (a > b) a else b

본문이 중괄호로 둘러싸인 함수를 블록이 본문인 함수라 부르고, 등호와 식으로 이뤄진 함수를 식이 본문인 함수라고 부른다.

인텔리J 아이디어 팁 인텔리J 아이디어는 이 두 방식의 함수를 서로 변환하는 메뉴가 있다. 각각은ㅇ 식 본문으로 변환(Convert to expression body)과 블록 본문으로 변환(Convert to block body)이다.

코틀린에서는 식이 본문인 함수가 자주 쓰인다. 그런 함수의 본문 식에는 단순한 산술식이나 함수 호출 식뿐 아니라 if, when, try 등의 더 복잡한 식도 자주 쓰인다. 잠시후에 when에 대해 설명할 때 그런 함수를 보여준다. 반환 타입을 생략하면 max 함수를 더 간략하게 만들 수 있다.

fun max(a: Int, b: Int) = if (a > b) a else b

여기서 반환 타입을 생략할 수 있는 이유는 무엇일까? 코틀린은 정적 타입 지정 언어이므로 컴파일 시점에 모든 식의 타입을 지정해야 하지 않는가? 실제로 모든 변수나 모든 식에는 타입이 있으며, 모든 함수는 반환 타입이 정해져야 한다. 하지만 식이 본문인 함수의 경우 굳이 사용자가 반환 타입을 적지 않아도 컴파일러가 함수 본문 식을 분석해서 식의 결고 타입을 함수 반환 타입으로 정해준다. 이렇게 컴파일러가 타입을 분석해 프로그래머 대신 프로그램 구성 요소의 타입을 정해주는 기능을 타입 추론(type inference)이라 부른다.

식이 본문인 함수의 반환 타입만 생략 가능하다는 점에 유의하라. 블록이 본문인 함수가 값을 반환한다면 반드시 반환 타입을 지정하고 return문을 사용해 반환 값을 명시해야 한다. 코틀린 언어를 이렇게 설계한 의도가 있다. 실전 프로그램에는 아주 긴 함수에 return 문이 여럿 들어있는 경우가 자주 있다. 그런 경우 반환 타입을 꼭 명시하고 return을 반드시 사용한다면 함수가 어떤 타입의 값을 반환하고 어디서 그런 값을 반환하는지 더 쉽게 알아볼 수 있다. 이제 변수 선언 문법에 대해 살펴보자.

변수

자바에서는 변수를 선언할 때 타입이 맨 앞에 온다. 코틀린에서는 타입 지정을 생략하는 경우가 흔하다. 타입으로 변수 선언을 시작하면 타입을 생략할 경우 식과 변수 선언을 구별할 수 없다. 그런 이유로 코틀린에서는 키워드로 변수 선언을 시작하는 대신 변수 이름 뒤에 타입을 명시하거나 생략하게 허용한다. 변수를 몇 개 선언해보자.

val question = "삶, 우주, 그리고 모든 것에 대한 궁긍적인 질문
val answer = 42

이 예제에서는 타입 표기를 생략했지만 원한다면 타입을 명시해도 된다.

val answer: Int = 42

식이 본문인 함수에서와 마찬가지로 우리가 타입을 지정하지 않으면 컴파일러가 초기화 식을 분석해서 초기화 식의 타입을 변수 타입으로 지정한다. 여기서 초기화 식은 42로 Int 타입이다. 따라서 변수도 Int 타입이 된다.
부동 소수점(floating point) 상수를 사용한다면 변수 타입은 Double이 된다.
val yearsToCompute = 7.5e6 <-- 7.5 x 10^6 = 7500000.0

초기화 식을 사용하지 않고 변수를 선언하려면 변수 타입을 반드시 명시해야한다.

val answer: Int
answer = 42

초기화 식이 없다면 변수에 저장될 값에 대해 아무 정보가 없기 때문에 컴파일러가 타입을 추론할 수 없다. 따라서 그런 경우 타입을 반드시 지정해야 한다.

변경 가능한 변수와 변경 불가능한 변수

변수 선언 시 사용하는 키워드는 다음과 같은 2가지가 있다.

val(값을 뜻하는 value에서 따옴) - 변경 불가능한(immutable) 참조를 저장하는 변수다. val로 선언된 변수는 일단 초기화하고 나면 재대입이 불가능하다. 자바로 말하자면 final 변수에 해당한다.
var(변수를 뜻하는 variable에서 따옴) - 변경 가능한(mutable) 참조다. 이런 변수의 값은 바뀔 수 있다. 자바의 일반 변수에 해당한다.

기본적으로는 모든 변수를 val 키워드를 사용해 불변 변수로 선언하고, 나중에 꼭 필요할 때에만 var로 변경하라. 변경 불가능한 참조와 변경 불가능한 객체를 부수 효과가 없는 함수와 조합해 사용하면 코드가 함수형 코드에 가까워진다. 1장에서 함수형 스타일의 장점에 대해 간략히 설명했었다. 5장에서 좀 더 자세하게 함수형 프로그래밍에 대해 설명한다.

val 변수는 블록을 실행할 때 정확히 한 번만 초기화해야 한다. 하지만 어떤 블록이 실행될 때 오직 한 초기화 문장만 실행됨을 컴파일러가 확인할 수 있다면 조건에 따라 val 값을 다른 여러 값으로 초기화할 수도 있다.

val message: String
if (canPerformOperation()) {
    message = "Success"
    // ... 연산을 수행한다. 

} else {
    message = "Failed"
}

val 참조 자체는 불변일지라도 그 참조가 가리키는 객체의 내부 값은 변경될 수 있다는 사실을 기억하라. 예를 들어 다음 코드도 완전히 올바른 코틀린 코드다.

val languages = arrayListOf("Java") // 불변 참조를 선언한다. 
languages.add("Kotlin") // 참조가 가리키는 객체 내부를 변경한다.

6장에서 변경 가능한 객체와 불변 객체에 대해 더 자세히 살펴본다.
var 키워드를 사용하면 변수의 값을 변경할 수 있지만 변수의 타입은 고정돼 바뀌지 않는다. 예를 들어 다음 코드는 컴파일 할 수 없다.

var answer = 42
answer = "no answer" // "Error: type mismatch" 컴파일 오류 발생

문자열 리터링(stirng literal)에서 컴파일 오류가 발생한다. 이유는 그 타입이 컴파일러가 기대하는 타입과 다르기 때문이다. 컴파일러는 변수 선언 시점의 초기화 식으로부터 변수의 타입을 추론하며, 변수 선언 이후 변수 재대입이 이뤄질 때는 이미 추론한 변수의 타입을 염두에 두고 대입문의 타입을 검사한다.

어떤 타입의 변수에 다른 타입의 값을 저장하고 싶다면 변환 함수를 써서 값을 변수의 타입으로 변환하거나, 값을 변수에 대입할 수 있는 타입으로 강제 형 변환(coerce)해야 한다.

더 쉽게 문자열 형식 지정: 문자열 템플릿

'Hello, World!' 예제로 다시 돌아가자. 다음은 그 예제의 다음 단계로, 사람 이름을 사용해 환영 인사를 출력하는 코틀린 프로그램이다.

fun main(args: Array<String>) {
    val name = if (args.size > 0) args[0] else "Kotlin"
    println("Hello, $name!")
}

이 예제는 문자열 템플릿(string template)이라는 기능을 보여준다. 이 코드는 name이라는 변수를 선언하고 그 다음 줄에 있는 문자열 리터럴 안에서 그 변수를 사용했다. 여러 스크립트 언어와 비슷하게 코틀린에서도 변수를 문자열 안에 사용할 수 있다. 문자열 리터럴의 필요한 곳에 변수를 넣되 변수 앞에 $를 추가해야 한다.

이 문자열 템플릿은 자바의 문자열 접합 연산("Hellom, " + name + "!")과 동일한 기능을 하지만 좀 더 간결하며, 자바 문자열 접합 연산을 사용한 식과 마찬가지로 효율적이다. 물론 컴파일러는 각 식을 정적으로 (컴파일 시점에) 검사하기 때문에 존재하지 않는 변수를 문자열 템플릿 안에서 사용하면 컴파일 오류가 발생한다.

$ 문자를 문자열에 넣고 싶으면 println("$x")와 같이 \를 사용해 $를 이스케이프(escape) 시켜야 한다. println("$x")는 화면에 x의 값을 출력하지 않고 $x를 출력한다.

문자열 템플릿 안에 사용할 수 있는 대상은 간단한 변수 이름만으로 한정되지 않는다. 복잡한 식도 중괄호({})로 둘러싸서 문자열 템플릿 안에 넣을 수 있다.

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

문자열 템플릿 안에서 변수 이름만 사용하는 경우라도 ${name} 처럼 중괄호로 변수명을 감싸는 습관을 들이면 더 좋다. 필요할 때 정규식 등을 통해 검색하거나 일괄 변환할 때도 중괄호를 쓴 경우 처리가 더 쉽고, 코드를 사람이 읽을 때도 문자열 템플릿 안에서 변수가 쓰인 부분을 더 쉽게 식별할 수 있다.

중괄호로 둘러싼 식 안에서 큰 따옴표를 사용할 수도 있다.

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

함수나 변수를 정의하는 방법을 배웠으므로 이제는 수준을 한 단계 더 높여서 클래스에 대해 살펴보자. 이번에는 코틀린 언어의 새로운 특성을 배울 때 자바

~~코틀린 변환기를 어떻게 활용할 수 있는지 보여주기 위해 자바~~

코틀린 변환기를 사용할 것이다.

클래스와 프로퍼티

이 책의 독자라면 객체지향에 대해 알고있으며 클래스라는 추상화도 잘 알기 때문에 코틀린의 클래스 개념도 이미 잘 아는 내용일 것이다. 그런 독자들도 코틀린을 활용하면 더 적은 양의 코드로 클래스와 관련 있는 대부분의 작업을 수행할 수 있다는 사실을 차차 알게 될 것이다. 이번 절은 클래스를 선언하는 기본 문법을 소개한다. 좀 더 자세한 내용은 4장에서 다룬다.

시작하기 위해 간단한 자바빈(JavaBean) 클래스인 Prseon을 정의하자. Person에는 name이라는 프로퍼티(Property)만 들어있다.

/* 자바 */
public class Person {
    private final String name;

    public Person(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

필드가 둘 이상으로 늘어나면 생성자인 Person(String name)의 본문에서 파라미터를 이름이 같은 필드에 대입하는 대입문의 수도 늘어난다. 자바에서는 생성자 본문에 이 같은 코드가 반복적으로 들어가는 경우가 많다. 코틀린에서는 그런 필드 대입 로직을 훨씬 더 적은 코드로 작성할 수 있다.

자바 - 코틀린 변환기를 써서 방금 Person 클래스를 코틀린으로 변환해보자.

class Person(val name: String)

멋지다. 다른 최신 JVM 언어에서 이와 비슷한 클래스 정의를 이미 본 독자도 있을 것이다. 이런 유형의 클래스(코드가 없이 데이터만 저장하는 클래스)를 값 객체(value Object)라 부르며, 다양한 언어가 값 객체를 간결하게 기술할 수 있는 구문을 제공한다.

자바를 코틀린으로 변환한 결과, public 가시성 변경자(visibility modifier)가 사라졌음을 확인하라, 코틀린의 기본 가시성은 public이므로 이런 경우 변경자를 생략해도된다.

프로퍼티

클래스라는 개념의 목적은 데이터를 캡슐화(encapsulate)하고 캡슐화한 데이터를 다루는 코드를 한 주체 아래 가두는 것이다. 자바에서는 데이터를 필드(field)에 저장하며, 멤버 필드의 가시성은 보통 비공개(private)다. 클래스는 자신을 사용하는 클라이언트가 그 데이터에 접근하는 통로로 쓸 수 있는 접근자 메소드(accessor method)`를 제공한다. 보통은 필드를 읽기 위한 게터(getter)를 제공하고 필드를 변경하게 허용해야 할 경우 세터(setter)를 추가 제공할 수 있다. 이런 예를 Person 클래스에서도 볼 수 있다. 세터는 자신이 받은 값을 검증하거나 필드 변경을 다른 곳에 통지하는 등의 로직을 더 가질 수 있다.

자바에서는 필드와 접근자를 한데 묶어 프로퍼티(property)라고 부르며, 프로퍼티라는 개념을 활용하는 프레임워크가 많다. 코틀린은 프로퍼티를 언어 기본 기능으로 제공하며, 코틀린 프로퍼티는 자바의 필드와 접근자 메서드를 완전히 대신한다. 클래스에서 프로퍼티를 선언할 때는 앞에서 살펴본 변수를 선언하는 방법과 마찬가지로 val이나 var를 사용한다. val로 선언한 프로퍼티는 읽기 전용이며, var로 선언한 프로퍼티는 변경 가능하다.

class Person {
    val name: String,  // 읽기전용 프로퍼티로, 코틀린은(비공개) 필드와 필드를 읽는 단순한 (공개) 게터를 만들어낸다. 
    var isMarried: Boolean // 쓸 수 있는 프로퍼티로, 코틀린은 (비공개) 필드, (공개) 게터, (공개) 세터를 만들어낸다. 
}

기본적으로 코틀린에서 프로퍼티를 선언하는 방식은 프로퍼티와 관련 있는 접근자를 선언하는 것이다(읽기 전용 프로퍼티의 경우 게터만 선언하며 변경할 수 있는 프로퍼티의 경우 게터와 세터를 모두 선언한다). 코틀린은 값을 저장하기 위한 비공개 필드와 그 필드에 값을 저장하기 위한 세터, 필드의 값을 읽기 위한 게터로 이뤄진 간단한 디폴트 접근자 구현을 제공한다.

위의 코드는 간결한 Person 클래스 정의 뒤에는 원래의 자바 코드와 똑같은 구현이 숨어있다. Person에는 비공개 필드가 들어있고, 생성자가 그 필드를 초기화하며, 게터를 통해 그 비공개 필드에 접근한다. 이는 어떤 언어로 정의했느냐와 관계없이 자바 클래스와 코틀린 클래스를 동일한 방식으로 사용할 수 있다는 뜻이다. 사용하는쪽의 코드는 완전히 똑같다. 다음은 Person을 자바 코드에서 사용하는 방법을 보여준다.

/* 자바 */
Person person = new Person("Bob", true);
System.out.println(person.getName());
Bob
System.out.println(person.isMarried());
true

자바와 코틀린에서 정의한 Person 클래스 중 어느 쪽을 사용해도 이 코드를 바꿀 필요가 없다는 사실을 기억하라. 코틀린의 name 프로퍼티를 자바 쪽에서는 getName이라는 이름으로 부를 수 있다. 게터와 세터의 이름을 정하는 규칙에는 예외가 있다. 이름이 is로 시작하는 프로퍼티의 게터에는 get이 붙지 않고 원래 이름을 그대로 사용하며, 세터에는 is를 set으로 바꾼 이름을 사용한다. 따라서 자바에서 isMarried 프로퍼티의 게터를 호출하려면 isMarried()를 사용해야 한다.

코틀린에서는 게터를 호출하신 대신 프로퍼티를 직접 사용한다. 로직은 동일하지만 코드는 더 간결해졌다. 변경 가능한 프로퍼티의 세터도 마찬가지 방식으로 동작한다. 자바에서는 person.setMarried(false)로 어떠 사람이 이혼했다는 사실을 기록하지만, 코틀린에서는 person.isMarried = false를 쓴다.

[Tip] 자바에서 선언한 클래스에 대해 코틀린 문법을 사용해도 된다. 코틀린에서는 자바 클래스의 게터를 val 프로퍼티처럼 사용할 수 있고, 게터 / 세터 쌍이 있는 경우에는 var 프로퍼티처럼 사용할 수 있다. 예를 들어 setName과 getName이라는 접근자를 제공하는 자바 클래스를 코틀린에서 사용할 때는 name이라는 프로퍼티를 사용할 수 있다. 자바 클래스가 isMarried와 setMarried 메서드를 제공한다면 그에 상응하는 코틀린 프로퍼티의 이름은 isMarried다.

대부분의 프로퍼티에는 그 프로퍼티의 값을 저장하기 위한 필드가 있다. 이를 프로퍼티를 뒷받침하는 필드(backing field)라고 부른다. 하지만 원한다면 프로퍼티의 값을 그때그때 계산(예를 들어 다른 프로퍼티들로부터 값을 계산할 수도 있다)할 수도 있다. 커스텀 게터를 작성하면 그런 프로퍼티를 만들 수 있다.

커스텀 접근자

이번 절에서는 프로퍼티의 접근자를 직접 작성하는 방법을 보여준다. 직사각형 클래스인 Rectangle을 정의하면서 자신이 정사각형인지 알려주는 기능을 만들어보자. 직사각형이 정사각형인지를 별도의 필드에 저장할 필요가 없다. 사각형의 너비와 높이가 같은지 검사하면 정사각형 여부를 그때그때 알 수 있다.

class Rectangle(val height: Int, val width: Int) {
    val isSquare: Boolean 
      get() { // 프로퍼티 게터 선언
          return height == width
      }
}

isSquare 프로퍼티에는 자체 값을 저장하는 필드가 필요 없다. 이 프로퍼티에는 자체 구현을 제공하는 게터만 존재한다. 클라이언트가 프로퍼티에 접근할 때마다 게터가 프로퍼티의 값을 매번 다시 계산한다.

블록을 본문으로 하는 복잡한 구문을 꼭 사용하지 않아도 좋다. 이런 경우 get() = height == width라고 해도 된다. 커스텀 게터를 사용하는 프로퍼티도 앞에서 살펴본 프로퍼티와 마찬가지 방식으로 사용할 수 있다.

val rectangle = Rectangle(41, 43)
println(rectangle.isSquare)
false

이 접근자를 자바에서 사용하려면 isSquare 메서드를 호출하면 된다.
파라미터가 없는 함수를 정의하는 방식과 커스텀 게터를 정의하는 방식 중 어느 쪽이 더 나은지 궁금한 독자도 있을 것이다. 두 방식 모두 비슷하다. 구현이나 성능상 차이는 없다. 차이가 나는 부분은 가독성뿐이다. 일반적으로 클래스의 특성(프로퍼티에는 특성이라는 뜻이 있다)을 정의하고 싶다면 프로퍼티로 그 특성을 정의해야 한다. (4장에서 클래스와 프로퍼티에 대한 예제를 더 보여주고 생성자를 명시적으로 선언하는 문법을 다룬다)

코틀린 소스코드 구조: 디렉터리와 패키지

자바의 경우 모든 클래스를 패키지 단위로 관리한다는 사실을 잘 알고 있을 것이다. 코틀린에도 자바와 비슷한 개념의 패키지가 있다. 모든 코틀린 파일의 맨 앞에 package 문을 넣을 수 있다. 그러면 그 파일 안에 있는 모든 선언(클래스, 함수, 프로퍼티 등)이 해당 패키지에 들어간다. 같은 패키지에 속해 있다면 다른 파일에서 정의한 선언일지라도 직접 사용할 수 있다. 반면 다른 패키지에 정의한 선언을 사용하려면 임포트를 통해 선언을 불러와야 한다. 자바와 마찬가지로 임포트문은 파일의 맨 앞에 와야하며 import 키워드를 사용한다. 다음은 패키지 선언과 임포트문을 보여주는 예제다.

package geometry.shape

import java.util.Random

class Rectangle(val height: Int, val width: Int) {
    val isSquare: Boolean
      get() = height == width
}

fun createRandomRectangle() : Rectangle {
    val random = Random()
    return Rectangle(random.nextInt(), random.nextInt())
}

코틀린에서는 클래스 임포트와 함수 임포트에 차이가 없으며, 모든 선언을 import 키워드로 가져올 수 있다. 최상위 함수는 그 이름을 써서 임포트할 수 있다.

package geometry.example

import geometry.shapes.createRandomRectangle // 이름으로 함수 임포트하기

fun main(args: Array<String>) {
    println(createRandomRectangle().isSquare) // "true"가 아주 드물게 출력된다.
}

패키지 이름 뒤에 .*를 추가하면 패키지 안의 모든 선언을 임포트할 수 있다. 이런 스타 임포트(star import)를 사용하면 패키지 안에 있는 모든 클래스뿐 아니라 최상위에 정의된 함수나 프로퍼티까지 모두 불러온다는 점에 유의하라. 위의 코드에서 구체적인 임포트문 대신 import geometry.shapes.*를 사용해도 컴파일에 아무 문제가 없다.

자바에서는 패키지의 구조와 일치하는 디렉터리 계층 구조를 만들고 클래스의 소스코드를 그 클래스가 속한 패키지와 같은 디렉터리에 위치시켜야 한다. 예를 들어 shapes라는 패키지 안에 일부 클래스가 들어있다면 각각의 클래스를 자신의 이름과 똑같은 자바 파일로 저장하되 그 모든 파일을 shapes 디렉터리 안에 넣어야 한다.

코틀린에서는 여러 클래스를 한 파일에 넣을 수 있고, 파일의 이름도 마음대로 정할 수 있다. 코틀린에서는 디스크상의 어느 디렉터리에 소스코드 파일을 위치시키든 관계없다. 따라서 원하는 대로 소스코드를 구성할 수 있다. 예를 들어 geometry.shapes라는 패키지가 있다면 그 패키지의 모든 내용을 shapes.kt라는 파일에 넣고, 하위 패키지에 해당하는 별도의 디렉터리를 만들지 않고 geometry라는 폴더 안에 shapes.kt를 넣어도 된다.

하지만 대부분의 경우 자바와 같이 패키지별로 디렉터리를 구성하는 편이 낫다. 특히 자바와 코틀린을 함께 사용하는 프로젝트에서는 자바의 방식을 따르는 게 중요하다. 자바의 방식을 따르지 않으면 자바 클래스를 코틀린 클래스로 마이그레이션할 때 문제가 생길 수도 있다. 하지만 여러 클래스를 한 파일에 넣는 것을 주저해서는 안 된다. 특히 각 클래스를 정의하는 소스 코드 크기가 아주 작은 경우 더욱 그렇다(코틀린에서는 클래스 소스코드 크기가 작은 경우가 자주 있다).

선택 표현과 처리: enum과 when

이번 절에서는 코틀린의 구성 요소 중 when에 대해 설명한다. when은 자바의 switch를 대체하되 훨씬 더 강력하며, 앞으로 더 자주 사용할 프로그래밍 요소라고 생각할 수 있다. when에 대해 설명하는 과정에서 코틀린에서 enum을 선언하는 방법과 스마트 캐스트(smart cast)에 대해서도 살펴본다.

enum 클래스 정의

색을 표현하는 enum을 하나 정의하자.

enum class Color {
    RED, ORANGE, YELLOW, GREEN, BLUE, INDIGO, VIOLET
}

enum은 자바 선언보다 코틀린 선언에 더 많은 키워드를 써야 하는 흔치 않은 예다. 코틀린에서는 enum class를 사용하지만 자바에서는 enum을 사용한다. 코틀린에서 enum은 소프트 키워드(soft keyword)라 부르는 존재다. enum은 class 앞에 있을 때는 특별한 의미를 지니지만 다른 곳에서는 이름에 사용할 수 있다. 반면 class는 키워드다. 따라서 class라는 이름을 사용할 수 없으므로 클래스를 표현하는 변수 등을 정의할 때는 clazz나 aaClass와 같은 이름을 사용해야 한다.

자바와 마찬가지로 enum은 단순히 값만 열거하는 존재가 아니다. enum 클래스 안에도 프로퍼티나 메서드를 정의할 수 있다. 다음은 프로퍼티와 메서드를 enum 안에 선언하는 방법을 보여준다.

enum class Color (
    val r: Int, val g: Int, val b: Int // 상수의 프로퍼티를 정의한다. 
) {
    RED(255, 0, 0), ORANGE(255, 165, 0), // 각 상수를 생성할 때 그에 대한 프로퍼티 값을 지정한다. 
    YELLOW(255, 255, 0), GREEN(0, 255, 0), BLUE(0, 0, 255),
    INDIGO(75, 0, 130), VIOLET(238, 130, 238);

    fun rgb() = (r * 256 + g) * 256 + b // enum 클래스 안에서 메서드를 저의한다. 
}
>>> println(Color.BLUE.rgb())
255

enum에서도 일반적인 클래스와 마찬가지로 생성자와 프로퍼티를 선언한다. 각 enum 상수를 정의할 때는 그 상수에 해당하는 프로퍼티 값을 지정해야만 한다. 이 예제에서는 코틀린에서 유일하게 새미콜론(;)이 필수인 부분을 볼 수 있다. enum 클래스 안에 메서드를 정의하는 경우 반드시 enum 상수 목록과 메서드 정의 사이에 세미콜론을 넣어야 한다. 이제 enum 상수로 할 수 있는 멋진 일을 살펴보자.

when으로 enum 클래스 다루기

무지개의 각 색에 대해 그와 상응하는 연상 단어를 짝지어주는 함수가 필요하다고 상상해보자(그리고 그 연상 단어 정보를 enum 안에 저장하지 않는다고 하자). 자바라면 switch문으로 그런 함수를 작성할 수 있다. switch에 해당하는 코틀린 구성 요소는 when이다.

if와 마찬가지로 when도 값을 만들어내는 식이다. 따라서 식이 본문인 함수에 when을 바로 사용할 수 있다. 2장의 앞부분에서 함수에 대해 이야기할 때 여러 줄 식을 본문으로 하는 함수를 나중에 보여준다고 약속했는데, 여기에 바로 그 함수가있다.

fun getMnemonic(color: Color) =
    when (color) {
        Color.RED -> "Richard"
        Color.ORANGE -> "Of"
        Color.YELLOW -> "York"
        Color.GREEN -> "Gave"
        Color.BLUE -> "Battle"
        Color.INDIGO -> "In"
        Color.VIOLET -> "Vain"
    }

앞의 코드는 color로 전달된 값과 같은 분기를 찾는다. 자바와 달리 각 분기의 끝에 break를 넣지 않아도 된다(자바에서는 break를 빼먹어서 오류가 생기는 경우가 자주 있다). 성공적으로 매치되는 분기를 찾으면 switch는 그 분기를 실행한다. 한 분기 안에서 여러 값을 매치 패턴으로 사용할 수도 있다. 그럴 경우 값 사이클 콤마(,)로 분리한다.

한 when 분기 안에 여러 값을 사용하기

fun getWarmth(color: Color) = when(color) {
    Color.RED, Color.ORANGE, Color.YELLO -> "warm"
    Color.GREEN -> "neutral"
    Color.BLUE, Color.INDIGO, Color.VIOLET -> "cold"
}
>>> println(getWarmth(Color.ORANGE))
warm

지금까지 살펴본 두 예제에서는 Color.YELLOW처럼 Color라는 enum 클래스 이름을 enum 상수 이름 앞에 붙인 전체 이름을 사용했다. 상수 값을 임포트하면 이 코드를 더 간단하게 만들 수 있다.

enum 상수 값을 임포트해서 enum 클래스 수식자 없이 enum 사용하기

import ch02.colors.Color // 다른 패키지에서 정의한 Color 클래스를 임포트한다. 
import ch02.colors.Color.* // 짧은 이름으로 사용하기 위해 enum 상수를 모두 임포트한다. 

fun getWarmth(color: Color) = when(color) {
    RED, ORANGE, YELLOW -> "warm" // 임포트한 enum 상수를 이름만으로 사용한다. 
    GREEN -> "neutral"
    BLUE, INDIGO, VIOLET -> "cold"
}

when과 임의의 객체를 함께 사용

코틀린에서 when은 자바의 switch보다 훨씬 더 강력하다. 분기 조건에 상수(enum 상수나 숫자 리터럴)만 사용할 수 있는 자바 switch와 달리 코틀린 when의 분기 조건은 임의의 객체를 허용한다. 두 색을 혼합했을 때 미리 정해진 팔레트에 들어있는 색이 될 수 있는지 알려주는 함수를 작성하자. 팔레트에 있는 색을 조합할 수 있는 방법이 많지 않기 때문에 모든 경우를 쉽게 열거할 수 있다.

리스트 2.15 when의 분기 조건에 여러 다른 객체 사용하기

fun mix(c1: Color, c2: Color) = 
    when (setOf(c1, c2)) { // when 식의 인자로 아무 객체나 사용할 수 있다. when은 이렇게 인자로 받은 객체가 각 분기 조건에 있는 객체와 같은지 테스트한다. 
        setOf(RED, YELLOW) -> ORANGE // 두 색을 혼합해서 다른 색을 만들 수 있는 경우를 열거한다. 
        setOf(YELLOW, BLUE) -> GREEN
        setOf(BLUE, VIOLET) -> INDIGO
        else -> throw Exception("Dirty color") // 매치되는 분기 조건이 없으면 이 문장을 실행한다. 
    }

>>> println(mix(BLUE, YELLOW))
GREEN

c1과 c2가 RED와 YELLOW라면(또는 반대라면) 그 둘을 혼합한 결과는 ORANGE다. 이를 구현하기 위해 집합 비교를 사용한다. 코틀린표준 라이브러리에는 인자로 전달받은 여러 객체를 그 객체들을 포함하는 집합인 Set 객체로 만드는 setOf라는 함수가 있다. 집합(set)은 원소가 모여있는 컬렉션으로, 각 원소의 순서는 중요하지 않다. 이는 우리가 검사하려는 성질과 일치한다.

when 식은 인자 값과 매치하는 조건 값을 찾을 때까지 각 분기를 검사한다. 여기서는 setOf(c1, c2)와 분기 조건에 있는 객체 사이를 매치할 때 동등성(equility)을 사용한다. 그러므로 앞의 코드는 처음에는 setOf(c1, c2)와 setOf(REDm YELLOW)를 비교하고, 그 둘이 같지 않으면 계속 다음 분기의 조건 객체와 setOf(c1, c2)를 차례로 비교하는 식으로 작동한다. 모든 분기 식에서 만족하는 조건을 찾을 수 없다면 else 분기의 문장을 계산한다.

when의 분기 조건 부분에 식을 넣을 수 있기 때문에 많은 경우 코드를 더 간결하고 아름답게 작성할 수 있다. 이 예제에서는 조건에서 동등성을 검사했다(코틀린 1.3부터는 when()의 괄호 안에서 검사 대상을 변수에 포획해서 새로운 이름으로 부를 수 있다) 다음 예제에서는 임의의 불리언(Boolean)식을 조건으로 사용하는 모습을 살펴본다.

인자 없는 when 사용

앞의 리스트 2.15가 약간 비효율적이라는 것을 쉽게 알 수 있을 것이다. 이 함수는 호출될 때마다 함수 인자로 주어진 두 색이 when의 분기 조건에 있는 다른 두 색과 같은지 비교하기위해 여러 Set 인스턴스를 생성한다. 보통은 이런 비효율성이 크게 문제가 되지 않는다.

하지만 이 함수가 자주 호출된다면 불필요한 가비지 객체가 늘어나는 것을 방지하기 위해 함수를 고쳐 쓰는 편이 낫다. 인자가 없는 when 식을 사용하면 불필요한 객체 생성을 막을 수 있다. 코드는 약간 읽기 어려워지지만 성능을 더 향상시키기 위해 그 정도 비용은 감수해야 하는 경우도 자주 있다.

리스트 2.16 인자가 없는 when

fun mixOptimized(c1: Color, c2: Color) = 
    when {
        (c1 == RED && c2 == YELLOW) || 
        (c1 == YELLOW && c2 == RED) -> 
            ORANGE
        (c1 == YELLOW && c2 == BLUE) ||
        (c1 == BLUE && c2 == YELLOW) ->
            GREEN
        (c1 == BLUE && c2 == VIOLET) ||
        (c1 == VIOLET && c2 == BLUE) ->
            INDIGO
        else -> throw Exception("Dirty color")
    }

>>> println(mixOptimized(BLUE, YELLOW))
GREEN

when에 아무 인자도 없으려면 각 분기의 조건이 불리언 결과를 계산하는 식이어야 한다. mixOptimized 함수는 앞에서 살펴본 mix 함수와 같은 일을 한다. mixOptimized는 추가 객체를 만들지 않는다는 장점이 있지만 가독성은 더 떨어진다.

이제 when을 사용하는 과정에서 스마트 캐스트가 쓰이는 예를 살펴보자.

스마트 캐스트: 타입 검사와 타입 캐스트를 조합

이번 절에서 사용할 예제로 (1 + 2) + 4 와 같은 간단한 산술식을 계산하는 함수를 만들어보자. 함수가 받을 산술식에서는 오직 두 수를 더하는 연산만 가능하다. 다른 연산(뺄셈, 곱셈, 나눗셈)도 비슷한 방식으로 구현할 수 있다. 연습문제 삼아 한번 풀어볼 것을 권장한다.

우선 식을 인코딩하는 방법을 생각해야한다. 식을 트리 구조로 저장하자. 노드는 합계(Sum)나 수(Num) 중 하나다. Num은 항상 말단(leaf 또는 terminal) 노드지만, Sum은 자식이 둘 있는 중간(non-terminal) 노드다. Sum노드의 두 자식은 덧셈의 두 인자다. 다음 리스트는 식을 표현하는 간단한 클래스를 보여준다. 식을 위한 Expr은 아무 메서드도 선언하지 않으며, 단지 여러 타입의 식 객체를 아우르는 공통 타입 역할만 수행한다. 클래스가 구현하는 인터페이스를 지정하기 위해서 콜론(:) 뒤에 인터페이스 이름을 사용한다.

리스트 2.17 식을 표현하는 클래스 계층

interface Expr
class Num(val value: Int) : Expr // value라는 프로퍼티만 존재하는 단순한 클래스로 Expr 인터페이스를 구현한다. 
class Sum(val left: Expr, val right: Expr) : Expr // Expr 타입의 객체라면 어떤 깃이나 Sum 연산의 인자가 될 수 있다. 따라서 Num이나 다른 Sum이 인자로 올 수 있다.

Sum은 Expr의 왼쪽과 오른쪽 인자에 대한 참조를 left와 right 프로퍼티로 저장한다. 이 예제에서 left와 right는 각각 Num이나 Sum일 수 있다. (1 + 2) + 4라는 식을 저장하면 Sum(Sum(Num(1), Num(2)), Num(4)) 라는 구조의 객체가 생긴다.

아래의 그림 2.4는 이런 트리 표현을 보여준다.

이제 식의 값을 어떻게 계산하는지 살펴보자. 앞에서 살펴본 예를 평가한 값은 7이어야 한다.

>>> println (eval(Sum(Sum(Num(1), Num(2)), Num(4)))
7

Expr 인터페이스에는 두 가지 구현 클래스가 존재한다. 따라서 식을 평가하려면 두 가지 경우를 고려해야 한다.

어떤 식이 수라면 그 값을 반환한다.
어떤 식이 합계라면 좌항과 우항의 값을 계산한 다음에 그 두 값을 합한 값을 반환한다.

자바 스타일로 작성한 함수를 먼저 살펴본 다음 코틀린 스타일로 만든 함수를 살펴보자. 자바였다면 조건을 검사하기 위해 if문을 사용했을 것이다. 따라서 코틀린에서 if를 써서 자바 스타일로 함수를 작성해보자.

리스트 2.18 if 연쇄를 사용해 식을 계산하기

fun eval(e: Expr) : Int {
    if (e is Num) {
        val n = e as Num // 여기서 Num으로 타입을 변환하는데, 이는 불필요한 중복이다. 
        return n.value
    }
    if (e is Sum) {
        return eval(e.right) + eval("Unknown expression") // 변수 e에 대해 스마트 캐스트를 사용한다. 
    }
    throw IllegalArgumentException("Unknown expression")
}

>>> println(eval(Sum(Sum(Num(1), Num(2)), Num(4)))
7

코틀린에서는 is를 사용해 변수 타입을 검증한다. C#을 아는 개발자라면 is가 낯익을 것이다. is 검사는 자바의 instanceof와 비슷하다. 하지만 자바에서 어떤 변수의 타입을 instanceof로 확인한 다음에 그 타입에 속한 멤버에 접근하기 위해서는 명시적으로 변수 타입을 캐스팅해야 한다. 이런 멤버 접근을 여러 번 수행해야 한다면 변수에 따로 캐스팅한 결과를 저장한 후 사용해야 한다. 코틀린에서는 프로그래머 대신 컴파일러가 캐스팅을 해준다. 어떤 변수가 원하는 타입인지 일단 is로 검사하고 나면 굳이 변수를 원하는 타입으로 캐스팅하지 않아도 마치 처음부터 그 변수가 원하는 타입으로 선언된 것처럼 사용할 수 있다. 하지만 실제로는 컴파일러가 캐스팅을 수행해준다. 이를 스마트 캐스트(smart cast)라고 부른다.

eval 함수에서 e의 타입이 Num인지 검사한 다음 부분에서 컴파일러는 e의 타입을 Num으로 해석한다. 그렇기 때문에 Num의 프로퍼티인 value를 명시적 캐스팅 없이 e.value로 사용할 수 있다. Sum의 프로퍼티인 right와 left도 마찬가지다. Sum 타입인지 검사한 다음부터는 e.right와 e.left를 사용할 수 있다. IDE를 사용하면 스마트 캐스트 부분의 배경색을 달리 표시해주므로 이런 변환이 자동으로 이뤄졌음을 쉽게 알 수 있다.

스마트는 캐스트는 is로 변수에 든 값의 타입을 검사한 다음에 그 값이 바뀔 수 없는 경우에만 작동한다. 예를 들어 앞에서 본 예제처럼 클래스의 프로퍼티에 대해 스마트 캐스트를 사용한다면 그 프로퍼티는 반드시 val이어야 하며 커스텀 접근자를 사용하는 경우에는 해당 프로퍼티에 대한 접근이 항상 같은 값을 내놓는다고 확신할 수 없기 때문이다. 원하는 타입으로 명시적으로 타입 캐스팅하려면 as 키워드를 사용한다.

val n = e as Num

이제 eval 함수를 리팩토링해서 더 코틀린다운 코드로 만드는 방법을 살펴보자.

리팩토링: if를 when으로 변경

코틀린의 if와 자바의 if는 어떻게 다를까? 이미 그 차이에 대해 살펴봤다. 2장을 시작하면서 코틀린 if 식을 자바 3항 연산자처럼 쓴 예제를 살펴봤다. 코틀린의 if (a > b) a else b 는 자바의 a > b ? a : b처럼 작동한다. 코틀린에서는 if가 값을 만들어내기 때문에 자바와 달리 3항 연산자가 따로 없다. 이런 특징을 사용하면 eval 함수에서 return문과 중괄호를 없애고 if식을 본문으로 사용해 더 간단하게 만들 수 있다.

리스트 2.19 값을 만들어내는 if 식

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

>>> println(eval(Sum(Num(1), Num(2)))
3

if의 분기에 식이 하나밖에 없다면 중괄호를 생략해도 된다. if 분기에 블록을 사용하는 경우 그 블록의 마지막 식이 그 분기의 결과 값이다.
이 코드를 when을 사용해 더 다듬을 수도 있다.

리스트 2.20 if 중첩 대신 when 사용하기

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

when 식을 앞에서 살펴본 값 동등성 검사가 아닌 다른 기능에도 쓸 수 있다. 이 예제는 받은 값의 타입을 검사하는 when 분기를 보여준다. 리스트 2.19의 if 예제와 마찬가지로 타입을 검사하고 나면 스마트 캐스트가 이뤄진다. 따라서 Num이나 Sum의 멤버에 접근할 때 변수를 강제로 캐스팅할 필요가 없다.

when과 if 식을 사용한 eval을 서로 비교해보고, when으로 if를 대신할 수 있는 경우가 언제인지 생각해보라. if나 when의 각 분기에서 수행해야 하는 로직이 복잡해지면 분기 본문에 블록을 사용할 수 있다. 블록을 사용한 if와 when을 한번 살펴보자.

if와 when의 분기에서 블록 사용

if나 when 모두 분기에 블록을 사용할 수 있다. 그런 경우 블록의 마지막 문장이 블록 전체의 결과가 된다. 예제로 봤던 eval 함수에 로그를 추가하고 싶다면 각 분기를 블록으로 만들고 블록의 맨 마지막에 그 분기의 결과 값을 위치시키면 된다.

리스트 2.21 분기에 복잡한 동작이 들어가 있는 when 사용하기

fun evalWithLogging(e: Expr): Int = 
    when (e) {
        is Num -> {
            println("num: ${e.value}")
            e.value // 이 식이 블록의 마지막 식이므로 e의 타입이 Num이면 e.value가 반환된다.
        }
        is Sum -> {
            val left = evalWithLogging(e.left)
            val right = evalWithLogging(e.right)
            println("sum: $left + $right")
            left + right // e의 타입이 Sum이면 이 식의 값이 반환된다. 
        }
        else -> throw IllegalArgumentException("Unknown expression")
}

이제 evalWithLogging 함수가 출력하는 로그를 보면 연산이 이뤄진 순서를 알 수 있다.

>>> println(evalWithLogging(Sum(Sum(Num(1), Num(2)), Num(4))))
num: 1
num: 2
sum: 1 + 2
num: 4
sum: 3 + 4
7

'블록의 마지막 식이 블록의 결과'라는 규칙은 블록이 값을 만들어내야 하는 경우 항상 성립한다. 2장의 마지막에는 try 본문과 catch 절에서 마찬가지 규칙이 쓰이는 예가 있으며, 5장에서는 람다 식에서 이 규칙이 어떻게 쓰이는지 설명한다. 하지만 2.2절에서 설명한 대로 이 규칙은 함수에 대해서는 성립하지 않는다. 식이 본문인 함수는 블록을 본문으로 가질 수 없고 블록이 본문인 함수는 내부에 return문이 반드시 있어야 한다. 지금까지 코틀린에서 여러 선택 중 하나를 고르는 올바른 방법을 배웠다. 이제는 어떤 대상을 이터레이션(iteration)하는 방법을 살펴보자.

대상을 이터레이션: while과 for 루프

2장에서 설명한 코틀린 특성 중 자바와 가장 비슷한 것이 이터레이션이다. 코틀린 while 루프는 자바와 동일하므로 간략하게 다루고 넘어간다. for는 자바의 for-each 루프에 해당하는 형태만 존재한다. 코틀린의 for는 C#과 마찬가지로 for <아이템> in <원소들> 형태를 취한다. 이런 for 루프는 자바에서와 마찬가지로 컬렉션에 대한 이터레이션에 가장 많이 쓰인다. 컬렉션을 다루는 경우를 포함하는 여러 반복 시나리오를 살펴보자.

while 루프

코틀린에는 while과 do-while 루프가 있다. 두 루프의 문법은 자바와 다르지 않다.

while (조건) { // 조건이 참인 동안 본문을 반복 실행한다.
    /*...*/
}

do {
    /*...*/
} while (조건) // 맨 처음에 무조건 본문을 한 번 실행한 다음, 조건이 참인 동안 본문을 반복 실행한다. 

이 두 루프를 매우 단순하며 코틀린에서 추가한 새로운 기능도 없다. 이제 주저하지말고 for 루프를 바로 살펴보자. 

### 수에 대한 이터레이션: 범위와 수열 
앞에서 설명했지만 코틀린에는 자바의 for 루프(어떤 변수를 초기화하고 그 변수를 루프를 한 번 실행할 때마다 갱신하고 루프 조건이 거짓이 될 때 반복을 마치는 형태의 루프)에 해당하는 요소가 없다. 이런 루프의 가장 흔한 용례인 초깃값, 증가 값, 최종 값을 사용한 루프를 대신하기 위해 코틀린에서는 범위(range)를 사용한다. 

범위는 기본적으로 두 값으로 이뤄진 구간이다. 보통은 그 두 값은 정수 등의 숫자 타입의 값이며, .. 연산자로 시작 값과 끝 값을 연결해서 범위를 만든다. 

`val oneToTen = 1..10`

코틀린의 범위는 폐구간(닫힌 구간) 또는 양끝을 포함하는 구간이다. 이는 두 번째 값(위 예에서는 10)이 항상 범위에 포함된다는 뜻이다. 
정수 범위로 수행할 수 있는 가장 단순한 작업은 범위에 속한 모든 값에 대한 이터레이션이다. 이런 식으로 어떤 범위에 속한 값을 일정한 순서로 이터레이션하는 경우 `수열`(progression)이라고 부른다. 

피즈버즈(Fizz-Buzz) 게임을 위해 정수 범위를 사용해보자. 피즈버즈 게임은 장거리 여행을 하면서 초등학교 이후 퇴화한 나눗셈 기술을 연마할 때 아주 좋다. 참가자는 순차적으로 수를 세면서 3으로 나눠떨어지는 수에 대해서는 피즈, 5로 나눠떨어지는 수에 대해서는 버즈라고 말해야 한다. 어떤 수가 3과 5로 모두 나눠떨어지면 '피즈버그'라고 말해야 한다. 

다음 리스트는 1부터 100까지의 피즈즈 결과를 보여준다. 인자가 없는 when을 사용해서 조건을 검사한다. 

> 리스트 2.22 when을 사용해 피즈버즈 게임 구현하기 

```kotlin 
fun fizzBuzz(i: Int) = when {
    i & 15 == 0 -> "FizzBuzz " // i가 15로 나눠떨어지면 FizzBuzz를 반환한다. 자바와 마찬가지로 %는 모듈로 연산자다.
    i % 3 == 0 -> "Fizz " // i가 3으로 나눠떨어지면 Fizz를 반환한다.
    i % 5 == 0 -> "Buzz "
    else -> "$i " // 다른 경우에는 그 수 자체를 반환한다. 
}

for (i in 1..100) {
    ... print(fizzBuzz(i))
    ...
}
1 2 Fizz 4 Buzz Fizz 7 ...

같은 게임을 너무 오래해서 지겨워졌으므로 더 어려운 게임을 하고 싶다. 이제는 100부터 거꾸로 세되 짝수만으로 게임을 진행해보자.

리스트 2.23 증가 값을 갖고 범위 이터레이션하기

>>> for (i in 100 downTo 1 step 2) {
... print(fizzBuzz(i))
... }
Buzz 98 Fizz 94 92 FizzBuzz 88 ...

여기서는 증가 값 step을 갖는 수열에 대해 이터레이션한다. 증가 값을 사용하면 수를 건너 뛸 수 있다. 증가 값을 음수로 만들면 정방향 수열이 아닌 역방향 수열을 만들 수 있다. 이 예제에서 100 downTo 1은 역방향 수열을 만든다(역방향 수열의 기본 증가 값은 -1이다). 그 뒤에 step 2를 붙이면 증가 값의 절댓값이 2로 바뀐다(이때 증가 값의 방향은 바뀌지 않는다. 따라서 증가 값은 실제로는 -2와 같다).

앞에서 언급한 대로 ..는 항상 범위의 끝 값(..의 우항)을 포함한다. 하지만 끝 값을 포함한다. 하지만 끝 값을 포함하지 않는 반만 닫힌 범위(half-closed range, 반폐구간 또는 반 개구간)에 대해 이터레이션하면 편할 때가 자주 있다. 그런 범위를 만들고 싶다면 until 함수를 사용하라. 예를 들어 for (x in 0 until size)라는 루프는 for (x in 0..size-1)과 같지만 좀 더 명확하게 개념을 표현한다. 나중에 3.4.3절에서 downTo, step, until에 대해 더 자세히 다룬다.

범위나 수열로 좀 더 복잡한 피즈버즈 게임을 만드는 방법을 살펴봤다. 이제 for 루프를 사용하는 예제를 더 살펴보자.

맵에 대한 이터레이션

앞 절에서 컬렉션에 대한 이터레이션을 위해 for .. in 루프를 자주 쓴다고 말했다. 그런 for 루프는 자바와 마찬가지로 작동하기 때문에 설명한 내용이 많지 않다. 대신 맵(map)에 대한 이터레이션을 살펴보자.

예제로 문자에 대한 2진 표현을 출력하는 프로그램을 살펴보자. 이때 2진 표현을 맵에 저장하자(단지 예제로 쓰기 위한 목적이다). 다음 코드는 맵을 만들고, 몇 글자에 대한 2진 표현으로 맵을 채운 다음, 그 맵의 내용을 출력한다.

리스트 2.24 맵을 초기화하고 이터레이션하기

val binaryReps = TreeMap<Char, String>() // 키에 대해 정렬하기 위해 TreeMap을 사용한다. 
for (c in 'A'..'F') { // A부터 F까지 문자의 범위를 사용해 이터레이션한다. 
    val binary = Integer.toBinaryString(c.toInt()) // 아스키 코드를 2진 표현으로 바꾼다. 
    binaryReps[c] = binary // c를 키로 c의 2진 표현을 맵에 넣는다. 
}

for ((letter, binary) in binaryReps) { // 멥에 대한 이터레이션한다. 맵의 키와 값을 두 변수에 각각 대입한다. 
    println("$letter = $binary")
}

.. 연산자를 숫자 타입의 값뿐 아니라 문자 타입의 값에도 적용할 수 있다. 'A'..'F'는 A부터 F에 이르는 문자를 모두 포함하는 범위를 만든다.
리스트 2.24는 for 루프를 사용해 이터레이션하려는 컬렉션의 원소를 푸는 방법을 보여준다(맵은 키/값 쌍을 원소로 하는 컬렉션이다). 원소를 풀어서 letter와 binary라는 두 변수에 저장한다. letter에는 키가 들어가고, binary에는 2진 표현이 들어간다. (7.4.1절에서 객체를 풀어서 각 부분을 분리하는 구조 분해 문법에 대해 자세히 다룬다) 리스트 2.24은 이 밖에도 키를 사용해 맵의 값을 가져오거나 키에 해당하는 값을 설정하는 멋진 코틀린 기능을 보여준다. get과 put을 사용하는 대신 map[key]나 map[key] = value 를 사용해 값을 가져오고 설정할 수 있다.

binaryReps[c] = binary 라는 코드는 binaryReps.put(c, binary) 라는 자바 코드와 같다.

출력은 다음과 비슷하다(출력을 두 열로 배열했다).

A = 100001 D = 1000100
B = 1000010 E = 1000101
C = 100011 F = 1000110

맵에 사용했던 구조 분해 구문을 맵이 아닌 컬렉션에도 활용할 수 있다. 그런 구조 분해구문을 사용하면 원소의 현재 인덱스를 유지하면서 컬렉션을 이터레이션할 수 있다. 인덱스를 저장하기 위한 변수를 별도로 선언하고 루프에서 매번 그 변수를 증가시킬 필요가 없다.

val list = arrayListOf("10", "11", "1001")
for ((index, element) in list.withIndex()) { // 인덱스와 함께 컬렉션을 이터레이션한다. 
    println("$index: $element")
}

이 코드는 예상대로 다음과 같은 결과를 출력한다.

0: 10
1: 11
2: 1001

withIndex의 정체에 대해서는 3장에서 살펴본다.
컬렉션이나 범위에 대해 in 키워드를 사용하는 방법을 살펴봤다. 한편 어떤 값이 범위나 컬렉션에 들어있는지 알고 싶을 때도 in을 사용한다.

in으로 컬렉션이나 범위의 원소 검사

in 연산자를 사용해 어떤 값이 범위에 속하는지 검사할 수 있다. 반대로 !in을 사용하면 어떤 값이 범위에 속하지 않는지 검사할 수 있다. 다음은 어떤 문자가 정해진 문자의 범위에 속하는지를 검사하는 방법을 보여준다.

리스트 2.25 in을 사용해 값이 범위에 속하는지 검사하기

fun isLetter(c: Char) = c in 'a'..'z' || c in 'A'..'Z'
fun isNoDigit(c: char) = c ! in '0'..'9'

>>>println(isNotDigit('x'))
true

어떻게 어떤 문자가 글자인지 검사하는 방법은 간단해 보인다. 내부적으로 교묘한 부분은 전혀 없다. 이렇게 코드를 작성해도 여전히 문자의 코드가 범위의 첫 번째 글자의 코드와 마지막 글자의 코드 사이에 있는지를 비교한다. 하지만 그런 비교 로직은 표준 라이브러리의 범위 클래스 구현 안에 깔끔하게 감춰져 있다. in과 !in 연산자를 when 식에서 사용해도 된다.

리스트 2.26 when에서 in 사용하기

fun recognize(c: Char) = when (c) {
    in '0'..'9' -> "It's a digit!" // c 값이 0 부터 9 사이에 있는지 검사한다. 
    in 'a'..'z', in 'A'..'Z' -> "It's a letter!" // 여러 범위 조건을 함께 사용해도 된다. 
    else -> "I don't knwo.."
}

>>>println(recognize('8'))
It's a digit!

범위는 문자에만 국한되지 않는다. 비교가 가능한 클래스라면(java.lang.Comparable 인터페이스를 구현한 클래스라면) 그 클래스의 인스턴스 객체를 사용해 범위를 만들 수 있다. Comparable을 사용하는 범위의 경우 그 범위 내의 모든 객체를 항상 이터레이션하지는 못한다. 예를 들어 'Java'와 'Kotlin' 사이의 모든 문자열을 이터레이션할 수 있을까? 그럴 수 없다. 하지만 in 연산자를 사용하면 값이 범위 안에 속하는지 항상 결정할 수 있다.

>>> println("Kotlin" in setOf("Java", "Scala")) // 이 집합에는 "Kotlin"이 들어있지 않다. 
false

(나중에 7.3.2절에서 범위나 수열과 우리가 직접 만든 데이터 타입을 함께 사용하는 방법에 대해 살펴보고 in 검사를 적용할 수 있는 객체에 대한 일반 규칙을 살펴본다)

2장에서 살펴보려는 코틀린 요소가 하나 더 있다. 바로 예외를 처리하는 문장이다.

코틀린의 예외 처리

코틀린의 예외(exception) 처리는 자바나 다른 언어의 예외 처리와 비슷하다. 함수는 정상적으로 종료할 수 있지만 오류가 발생하면 예외를 던질(throw) 수 있다. 함수를 호출하는 쪽에서는 그 예외를 잡아 처리할 수 있다. 발생한 예외를 함수 호출 단에서 처리(catch)하지 않으면 함수 호출 스택을 거슬러 올라가면서 예외를 처리하는 부분이 나올 때까지 예외를 다시 던진다(rethrow).

코틀린의 기본 예외 처리 구문은 자바와 비슷하다. 예외를 던지는 방법은 전혀 놀랍지 않다.

if (percentage !in 0..100) {
    throw IllegalArgumentException(
        "A percentage value must be between 0 and 100: $percentage")
}

다른 클래스와 마찬가지로 예외 인스턴스를 만들 때도 new를 붙일 필요가 없다. 자바와 달리 코틀린의 throw는 식이므로 다른 식에 포함될 수 있다.

val percentage = if (number in 0..100)
                     number
                 else
                     throw IllegalArguementException( // 'throw' 는 식이다! 
                         "A percentage value must be between 0 and 100: $number")

이 예제에서는 if의 조건이 참이므로 프로그램이 정상 동작해서 percentage 변수가 number의 값으로 초기화된다. 하지만 조건이 거짓이면 변수가 초기화되지 않는다. throw를 식에 활용할 때의 기술 사항에 대해서는 6.2.6절에서 자세히 설명한다.

try, catch, finally

자바와 마찬가지로 예외를 처리하려면 try, catch, finally 절을 함께 사용한다. 파일에서 각 줄을 읽어 수로 변환하되 그 줄이 올바른 수 형태가 아니면 null을 반환하는 다음 예제에서 그 세 가지 요소를 모두 볼 수 있다.

리스트 2.27 자바와 마찬가지로 try 사용하기

fun readNumber(reader: BufferedReader): Int? { // 함수가 던질 수 있는 예외를 명시할 필요가 없다. 
    try {
        val line = reader.readLine()
        return Integer.parseInt(line)
    }
    catch (e: NumberFormatException) { // 예외 타입을 :의 오른쪽에 쓴다. 
        return null
    }
    finally { // "finally"는 자바와 똑같이 작동한다. 
        reader.close()
    }
}

>>> val reader = BufferedReader(StringReader("239"))
>>> println(readNumber(reader))
239

자바 코드와 가장 큰 차이는 throws(이 경우 s가 붙어있다) 절이 코드에 없다는 점이다. 자바에서는 함수를 작성할 때 함수 선언 뒤에 throws IOException을 붙여야 한다. 이유는 IOException이 체크 예외(checked exception)이기 때문이다. 자바에서는 체크 예외를 명시적으로 처리해야 한다. 어떤 함수가 던질 가능성이 있는 예외나 그 함수가 호출한 다른 함수에서 발생할 수 있는 예외를 모두 catch로 처리해야 하며, 처리하지 않은 예외는 throws 절에 명시해야 한다.

다른 최신 JVM 언어와 마찬가지로 코틀린도 체크 예외나 언체크 예외(unchecked exception)를 구별하지 않는다. 코틀린에서는 함수가 던지는 예외를 지정하지 않고 발생한 예외를 잡아내도 되고 잡아내지 않아도 된다. 실제 자바 프로그래머들이 체크 예외를 사용하는 방식을 고려해 이렇게 코틀린 예외를 설계했다. 자바는 체크 예외 처리를 강제한다. 하지만 프로그래머들이 의미 없이 예외를 다시 던지거나, 예외를 잡되 처리하지는 않고 그냥 무시하는 코드를 작성하는 경우가 흔하다. 그로 인해 예외 처리 규칙이 실제로는 오류 발생을 방지하지 못하는 경우가 자주 있다.

예로 들어 리스트 2.27에서 NumberFormatException은 체크 예외가 아니다. 따라서 자바 컴파일러는 NumberFormatException을 잡아내게 강제하지 않는다. 그에 따라 실제 실행 시점에 NumberFormatException이 발생하는 모습을 자주 볼 수 있다. 하지만 입력 값이 잘못되는 경우는 흔히 있는 일이므로 그런 문제가 발생한 경우 부드럽게 다음 단계로 넘어가도록 프로그램을 설계해야 한다는 점에서 이는 불행한 일이다. 동시에 BufferedReader.close는 IOException을 던질 수 있는데, 그 예외는 체크 예외이므로 자바에서는 반드시 처리해야 한다. 하지만 실제 스트림을 닫다가 실패하는 경우 특별히 스트림을 사용하는 클라이언트 프로그램이 취할 수 있는 의미 있는 동작은 없다. 그러므로 이 IOException을 잡아내는 코드는 그냥 불필요하다.

자바 7의 자원을 사용하는 try-with-resource는 어떨까? 코틀린은 그런 경우를 위한 특별한 문법을 제공하지 않는다. 하지만 라이브러리 함수로 같은 기능을 구현한다. (8.2.5절에서 그 방법을 살펴본다)

try를 식으로 사용

자바와 코틀린의 중요한 차이를 하나 더 살펴보기 위해 방금 살펴본 예제를 고쳐보자. finally 절을 없애고 파일에서 읽은 수를 출력하는 코드를 추가하자.

리스트 2.28 try를 식으로 사용하기

fun readNumber(reader: BufferedReader) {
    val number = try {
        Integer.parseInt(reader.readLine()) // 이 식의 값이 "try" 식의 값이 된다. 
    } catch (e: NumberFormatException) {
        return
    }
    println(number)
}

>>> val reader = BufferedReader(StringReader("not a number"))
>>> readNumber(reader) // 아무것도 출력되지 않는다.

코틀린의 try 키워드는 if나 when과 마찬가지로 식이다. 따라서 try의 값을 변수에 대입할 수 있다. if와 달리 try의 본문을 반드시 중괄호 {}로 둘러싸야 한다. 다른 문장과 마찬가지로 try의 본문도 내부에 여러 문장이 있으면 마지막 식의 값이 전체 결과 값이다.

이 예제는 catch 블록 안에서 return 문을 사용한다. 따라서 예외가 발생한 경우 catch 블록 다음의 코드는 실행되지 않는다. 하지만 계속 진행하고 싶다면 catch 블록도 값을 만들어야 한다. 역시 catch 블록도 그 안의 마지막 식이 블록 전체의 값이된다. 다음은 그런 동작을 보여준다.

리스트 2.29 catch에서 값 반환하기

fun readNumber(reader: BufferedReader) {
    val number = try {
        Integer.parseInt(reader.readLine()) // 예외가 발생하지 않으면 이 값을 사용한다. 
    } catch (e: NumberFormatException) {
        null // 예외가 발생하면 null 값을 사용한다. 
    }
    println(nuimber)
}

>>> val reader = BufferedReader(StringReader("not a number"))
>>> readNumber(reader)
null // 예외가 발생했으므로 함수가 "null"을 출력한다.

try 코드 블록의 실행이 정상적으로 끝나면 그 블록의 마지막 식의 값이 결과다. 예외가 발생하고 잡히면 그 예외에 해당하는 catch 블록의 값이 결과다. 리스트 2.29에서는 NumberFormatException이 발생하므로 함수의 결과 값이 null이다.