Kotlin/문법

#!if top = 문서명1 != null ? 문서명1 : calleeTitle != null ? (i = calleeTitle.lastIndexOf("/")) != -1 ? calleeTitle.substr(0, i) : '상위 문서' : '상위 문서'
[[파일:상위 문서 아이콘.svg|align=left&width=21.6px]] {{{#!html  }}} 상위 문서: [[]]

#!style
.table > div {
    margin: 5px 0;
}
.table td {
    border-style: solid none;
}
.sub-title {
    margin: 5px;
    padding: 3px;
    border-radius: 5px;
    background: #154c79;
    color: #fff;
    font-weight: bold;
}

#!wiki class="sub-title"
프로그래밍 언어 문법

#!wiki class="sub-title"
마크업 언어 문법

#!wiki class="sub-title"
개념과 용어

#!wiki class="sub-title"
기타

1. 개요

2. 기본

3. 파일 구조

• 패키지를 실제 파일의 경로와 동일하게 명시할 필요가 없다. 다만, 일관성을 위해 동일하게 명시하는 것을 추천한다.
• 하나의 파일이 여러개의 public class를 가질 수 있다. 비슷하게 파일 이름에 제한이 없다.[2]
• top-level에 변수와 함수를 선언할 수 있다.

4. 패키지

#!syntax kotlin
// Main.kt
package com.example

fun main() {
    println(MainKt::class) // class com.example.MainKt
}

#!syntax kotlin
fun main() {
    println(MainKt::class) // class MainKt
}

5. 모듈

6. import

#!syntax kotlin
// Main.kt
package com.example

import net.sample.foo

fun main() {
    foo()
}

// Foo.kt
package net.sample

fun foo() {
    println("foo")
}

#!syntax kotlin
import kotlin.io.println as log

fun main() {
    log("Hello, World!")
}

7. 타입

• 부호 있는 정수: Long(long) > Int(int) > Short(short) > Byte(byte)
• 실수: Double(double) > Float(float)
• 논리: Boolean(boolean)
• 문자: Char(char)

7.1. 리터럴

#!syntax kotlin
val a = 12 // Int
val b = 10000000000 // Long
val c = 1L // Long
val d: Byte = 2 // Byte
val e = 3.14 // Double
val f = 3.14f // Float
val g = 3u // UInt
val h = 3uL // ULong

7.2. String

#!syntax kotlin
val a = "abc"
val b = String("abc")

7.3. Unit

7.4. Any

7.5. Nothing

7.6. Array

• 원시 타입 배열[15]
• 부호 있는 정수의 배열: LongArray, IntArray, ShortArray, ByteArray
• 부호 없는 정수의 배열: ULongArray, UIntArray, UShortArray, UByteArray
• 실수 배열: DoubleArray, FloatArray
• 논리 배열: BooleanArray
• 문자 배열: CharArray
• 참조 타입 배열: Array<T>[16]

#!syntax kotlin
val intArr = intArrayOf(1, 2, 3, 4) // { 1, 2, 3, 4 }가 저장된다.
val uintArr = uintArrayOf(1, 3, 7, 1)
val boolArr1 = BooleanArray(3) // { false, false, false }가 저장된다.
val boolArr2 = BooleanArray(5) { it % 2 == 0 } // { true, false, true, false, true }가 저장된다.
val strArr1: Array<String> = arrayOf("a", "b", "c")
val strArr2: Array<String?> = arrayOfNulls<String>(2) // { null, null }이 저장된다.
val anyArr: Array<Any> = arrayOf(1, "a", 3.4, false)

7.7. 컬렉션

#!syntax kotlin
val list = listOf<String>()
list += "a"
list += "b"
println(list[0]) // a
println(list.getOrNull(3)) // null

8. 변수 선언

#!syntax kotlin
var namu: Int

#!syntax kotlin
namu = 3

#!syntax kotlin
var namu: Int = 3;

#!syntax kotlin
val namu: Int = 3;

#!syntax kotlin
val namu = 3;

#!syntax kotlin
println(namu);

#!syntax kotlin
namu = namuwiki;

8.1. Nullable

#!syntax kotlin
val a: Int? = null
//val b: Int = null // error

val c: String? = " Hello, World! "
// trim()은 앞 뒤 공백을 제거하는 함수다.
//c.trim() // error
c?.trim() // 만약 c가 null이라면 호출 대신 null을 반환한다.

val d: Int? = getIntOrNull() // 정수 또는 null을 반환하는 임의의 함수
println(d!!) // d가 null이라면 NPE를 발생시키며, 아니면 그대로 사용한다. 이후에 사용되는 d는 자동으로 non-nullable로 항변환된다. 스마트 항변환이라고 한다.

val e: Int = getIntOrNull() ?: 0 // null이 반환되면 뒤에 있는 0을 사용한다.

val f = getIntOrNull()
if (f != null) println(f + 1) // 스마트 항변환. if문 내에서는 non-nullable로 항변환한다.

9. 출력

#!syntax kotlin
println("Hello, World!")
print("Hello, World!\n")

#!syntax kotlin
System.err.println("error message")
val str = "World!"
System.out.printf("Hello, %s", str)

10. 입력

#!syntax kotlin
val str = readln()

#!syntax kotlin
val str = readlnOrNull()

11. 연산자

11.1. 오버로딩

11.2. 산술

11.3. 증감

11.4. 부호

11.5. 비교

11.6. 논리

11.7. 비트

11.8. 시프트

11.9. 대입

11.10. 형변환

11.11. 범위

11.12. null 관련

11.13. 호출

11.14. 기타 특수 연산자

#!syntax kotlin
class Point(val x: Int, val y: Int) {
    operator fun component1() = x
    operator fun component2() = y
}

val p = Point(1, 2)
val (a, b) = p
//val a = p.component1()
//val b = p.component2()

11.15. 우선순위

12. 조건문

12.1. if

#!syntax kotlin
if (exp1) {
    stmt1
} else if (exp2) {
    stmt2
}
...
} else {
    stmtN
}

#!syntax kotlin
val x = if (a) b else c

12.2. when

#!syntax kotlin
when (exp) {
    value1 -> stmt1
    value2 -> {
        stmt2
    }
    value3, value4 -> stmt3
    in list -> stmt4
    is Char -> stmt5
    else -> stmt6
}

#!syntax kotlin
val a = when (exp1) {
    value1 -> exp2
    value2 -> {
        stmt
        exp3
    }
    else -> exp4
}

#!syntax kotlin
val a = 12
val b = "hello"
when {
    a == 12 -> stmt1
    "h" in b -> stmt2
}

13. 반복문

13.1. while

#!syntax kotlin
while (exp1) {
    stmt1
}

do {
    stmt2
} while (exp2)

13.2. for

#!syntax kotlin
for (i in iterable) {
    stmt
}

#!syntax kotlin
for (i in 0..9) {
    println("안녕하세요")
}
for (i in 0 until 10) {
    println("안녕하세요")
}
for (i in 9 downTo 0) {
    println("안녕하세요")
}
for (i in 0 until 10 step 2) {
    println("안녕하세요")
}
for (i in 10 downTo 1 step 3) {
    println("안녕하세요")
}
for (i in arrayOf("0", "1", "2", "3", "4", "5", "6", "7", "8", "9")) {
    println("안녕하세요")
}

13.3. 분기

#!syntax kotlin
for (e in arr) {
    if (e == null) continue
    println(e)
}

#!syntax kotlin
while (true) {
    val str = readln("비밀번호:");
    if (str == "pass") break;
}

14. 라벨

#!syntax kotlin
outer@for (arr : arr2d) for (e : arr) {
    if (...) continue@outer
}

#!syntax kotlin
list.forEach {
    if (it == null) return@forEach
    println(it)
}

run {
    if (...) return@run
    stmt
}

15. 메인 함수

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

#!syntax kotlin
fun main() {
    println("Hello, World!")
}

16. 제어자

16.1. 접근 제어자

• public: 공개. 어디에서나 접근 가능하다.
• Internal: 내부. 코틀린에 새로 추가된 제어자로, 동일 모듈[30]에서만 접근 가능하다.
• protected: 보호. 해당 클래스나 파일에서만 접근 가능하지만, 상속 관계라면 외부에서도 접근 가능하다.
• private: 비공개. 해당 클래스나 파일에서만 접근 가능하다.

• 코틀린에서 자바 코드 사용
• default: 코틀린에서는 package-private 개념이 없어. private로 취급된다.
• protected: 코틀린의 접근 범위가 적용되어 상속 관계가 아니면 접근할 수 없다.
• 자바에서 코틀린 코드 사용
• internal: public으로 취급하지만 권장하지 않는다. 경고를 하는 IDE도 있다.
• protected: 자바의 접근 범위가 적용되어 동일 패키지라면 사용 가능하지만, 권장하지 않는다. 이 역시 경고를 하는 IDE도 있다.

16.2. 기타 제어자

• final, open: 수정 가능. 기본값은 final이며 기본값이 다르다는 걸 제외하면 자바와 동일하다.
• abstract: 추상. 자바와 동일하다. 추상 클래스는 open이 자동으로 적용된다.
• override: 재정의. 자바에서는 동일한 이름, 매개변수를 가지면 재정의되었고, 어노테이션을 사용해 명시했다면 코틀린에서는 제어자를 사용해야 한다.
• lateinit: 초기화 지연. 변수의 초기화 시점을 지연한다. 객체 타입인 가변 변수에서만 사용할 수 있다.
• const: 상수. 원시 타입 또는 String 타입인 val 키워드로 선언된 상수에 사용 가능하며, 자바의 static final로 컴파일된다.
• data: 데이터. 클래스에 사용 가능하며, 필드에 대해 equals, hashCode, toString 등의 메서드를 자동으로 생성한다.
• infix: 객체 a에 대해 하나의 매개 변수 m을 받는 메서드에 사용 가능하다. 메서드 이름을 method라고 할 때 호출을 a.method(b) 대신 a method b로 호출할 수 있다.
• operator: 해당 메서드가 연산자를 정의하는 메서드임을 알린다. 이는 자바에서 원시 타입과 String에서만 사용 가능한 연산자를 다른 객체에서 사용할 수 있게 된다. 예를 들어 + 연산자는 plus()메서드를 호출하고, 이 메서드를 정의하면 다른 객체에서 + 연산자를 쓸 수 있다
• external: 해당 메서드의 구현이 현재 언어 밖에 있음을 선언한다. JVM에서는 자바의 native와 동일하다.

17. 함수

#!syntax kotlin
// fun 키워드와 함수이름을 쓰고 뒤에 소괄호를 쓴다. 반환 타입은 마지막에 쓴다.
fun name(): Unit {
    // 함수 내용
}

#!syntax kotlin
private fun myFunction(i: Int): Unit {
    // 함수 내용
}

#!syntax kotlin
// 두 정수를 받고 더한 결과를 반환하는 함수
fun sum(a: Int, b: Int): Int {
    return a + b
}

#!syntax kotlin
// 문자열을 출력하는 함수
fun printHelloWorld() { // 반환타입 Unit이 생략되었다.
    println("Hello, World!")
    // 자바와 마찬가지로 return 또는 return Unit이 생략되었다.
}

#!syntax kotlin
fun sum(a: Int, b: Int) = a + b // 이 경우 타입 추론이 가능하다.

fun printHelloWorld() = println("Hello, World!")

#!syntax kotlin
fun print(a: Any, newLine: Boolean = false) {
    print(a)
    if (newLine) println()
}

#!syntax kotlin
// 문자열들을 받아 하나의 문자열로 결합 후 출력하는 함수
fun printJoinedText(vararg args: String) {// 가변 매개변수이다. 배열로 취급된다.
    if (args.length == 0) return // return은 값 반환 뿐만 아니라 함수 종료도 하므로 args가 비어있을 경우 아래코드가 실행되기 전에 함수가 종료된다.
    println(args.joinToString(", ")) // 문자열 배열을 하나의 문자열로 합친다. ", "로 원소가 이어진다.
}

17.1. 오버로딩

#!syntax kotlin
fun println() = println()
fun println(i: Int) = println(i)
fun println(s: String) = println(s)
fun println(i: Int, s: String) = println(i + s)
fun println(s: String, i: Int) = println(s + i)

#!syntax kotlin
fun print(a: Any, newLine: Boolean) {
    print(a)
    if (newLine) println()
}
fun print(a: Any) = print(a, false)

#!syntax kotlin
fun print(i: Int) = println(i)
fun print(vararg args: Int) {
    for (i in args) print(i)
    println()
}
fun print(vararg args: String) {
    for (i in args) print(i)
    println()
}

17.2. 확장 함수

#!syntax kotlin
fun String.sayHello() {
    println("Hello, $this") // this는 객체 자기 자신을 가리킴
}

fun main() {
    "NamuWiki".sayHello() // "Hello, NamuWiki" 출력
}

17.3. infix 함수

• 확장 함수 또는 메서드여야 한다
• 매개 변수 1개여야 한다
• 매개 변수는 기본 값이 없으면서 vararg 매개변수가 없어야 한다

#!syntax kotlin
class Human(var name: String, var age: Int, var location: String) {
    fun travel(location: String) {
        this.location = location
    }
    override fun toString(): String {
        return "${name}, ${age}세, ${location} 거주"
    }
    infix fun eat(food: String) = println("${this.name}님이 ${food}를 먹었습니다.")
}

fun main() {
    Human("홍길동", 30, "서울") eat "피자" // 홍길동님이 피자를 먹었습니다.
    Human("홍길동", 30, "서울") browse URL("https://namu.wiki/") // 홍길동님이 https://namu.wiki/를 검색했습니다.
}

infix fun Human.browse(url: URL) = println("${this.name}님이 ${url}를 검색했습니다.")

18. 스코프 함수

18.1. let

#!syntax kotlin
package HelloWorld

class Human(var name: String, var age: Int, var location: String) {
    fun travel(location: String) {
        this.location = location
    }
    override fun toString(): String {
        return "${name}, ${age}세, ${location} 거주"
    }
}

fun main() {
    Human("홍길동", 30, "서울").let {
        println(it)
        it.travel("부산")
        println(it)
    } // 마지막 println()의 결과인 Unit이 반환됨
    /*
        실행결과
        홍길동, 30세, 서울 거주
        홍길동, 30세, 부산 거주
    */
}

#!syntax kotlin
package HelloWorld

class Human(var name: String, var age: Int, var location: String) {
    fun travel(location: String) {
        this.location = location
    }
    override fun toString(): String {
        return "${name}, ${age}세, ${location} 거주"
    }
}

fun main() {
    val human = Human("홍길동", 30, "서울")
    println(human)
    human.travel("부산")
    println(human)
}

• null이 가능한 오브젝트가 null이 아닐 때 코드를 실행하게 할 때
  {{{#!folding [ 예시 ]

#!syntax kotlin
package HelloWorld
val humans = ArrayList<Human>()


class Human(var name: String, var age: Int, var location: String) {
    fun travel(location: String) {
        this.location = location
    }
    override fun toString(): String {
        return "${name}, ${age}세, ${location} 거주"
    }
}

fun main() {
    
    Human("홍길동", 30, "서울").let {
        humans.add(it)
    }
    // ?. 연산자를 사용, getHuman()의 결과가 null이라면 람다식이 무시되고 null이 반환된다.
    getHuman("홍길동")?.let {
        println(it.name)
    }
}

fun getHuman(name: String): Human? {
    return humans.firstOrNull {
        it.name == name
    }
}

• 특정 변수를 제한적인 블록에서만 접근하게 만들 때

18.2. run

#!syntax kotlin
fun main() {
    Human("홍길동", 30, "서울").run {
        println(this)
        this.travel("부산")
        println(this)
    } // 마지막 println()의 결과인 Unit이 반환됨
}

#!syntax kotlin
fun main() {
    run { // Top-level이므로 this 키워드 사용 불가
        val human = Human("홍길동", 30, "서울")
        println(human)
        human.travel("부산")
        println(human)
    } // 마지막 println()의 결과인 Unit이 반환됨
}

18.3. also

#!syntax kotlin
fun main() {
    val type = Human("홍길동", 30, "서울").also {
        println(it)
        it.travel("부산")
        println(it)
    } // Human 객체가 그대로 반환됨

    println(type::class.simpleName) //Human 출력
}

#!syntax kotlin
fun main() {
    val type = Human("홍길동", 30, "서울").let {
        println(it)
        it.travel("부산")
        println(it)
        it
    } // Human 객체가 그대로 반환됨

    println(type::class.simpleName) //Human 출력
}

18.4. with

#!syntax kotlin
fun main() {
    with(Human("홍길동", 30, "서울")) {
        println(this)
        this.travel("부산")
        println(this)
    } // 마지막 println()의 결과인 가 그대로 반환됨
}

18.5. apply

#!syntax kotlin
fun main() {
    Human("홍길동", 30, "서울").also {
        println(this)
        this.travel("부산")
        println(this)
    } // Human 객체가 그대로 반환됨
}

18.6. takeIf

#!syntax kotlin
fun main() {
    val human = Human("홍길동", 30, "서울").also {
        this.travel("부산")
    }.takeIf {
        it.location == "서울"
    }
    println(human) // it.location == "서울"이 false이므로 null 출력
}

18.7. takeUnless

#!syntax kotlin
fun main() {
    val human = Human("홍길동", 30, "서울").also {
        this.travel("부산")
    }.takeUnless {
        it.location == "서울"
    }
    println(human) // it.location == "서울"이 false이므로 "홍길동, 30세, 부산 거주" 출력
}

19. 람다식

19.1. 기본

• 함수형
  {{{#!syntax kotlin

package Kotlin

• 람다식
  {{{#!syntax kotlin

package Kotlin

19.2. 고차함수

• 함수를 인자로 받기
  {{{#!syntax kotlin

package Kotlin

#!syntax kotlin

printer(3, 5, {i, j -> i + j}) // 작동
printer(3, 5) {i, j ->
    i + j
} // 작동

#!syntax kotlin
package HelloWorld

object NamuWiki {
    fun getDocument(name: String): String {
        // TODO
        return document
    }
}

fun <T> namuWiki(lambda: NamuWiki.() -> T) : T { // lambda는 일종의 확장 함수
    return NamuWiki.lambda()
}

fun main() {
    val kotlin: String = namuWiki { // namuWiki 함수 호출 및 결과
        getDocument("Kotlin/문법") // 문서 얻기 (확장 함수로 가능한 this 생략)
    }

    getDocument("Kotlin/문법") // ERROR: function getDocument doesn't exist

    println(kotlin)
}

20. 클래스

#!syntax kotlin
class Person(name: String) {
    companion object { // 이 블록 안의 함수와 변수는 static이 붙은 것처럼 호출해야 한다.
        const val SPECIES = "Homo sapiens"
    }

    var name = name
        private set
}

fun main() {
    val myPerson = Person("John")
    println(myPerson.name)
    println(myPerson.SPECIES)
}

20.1. Getter, Setter

#!syntax kotlin
class Car {
    var speed = 0
        set(speed: Int) {
            if (speed < 0) throw IllegalArgumentException("속력은 음수가 될 수 없음")
            field = speed // field는 필드 자기 자신을 가리킨다.
        }
    private var gear = 0
    val trunk = mutableListOf<Any>()
        get() = field.toMutableList()
    var licensePlate = "12가 3456"
        protected set
}

20.2. 상속

#!syntax kotlin
open class ParentClass()

class ChildClass: ParentClass()

#!syntax kotlin
interface SampleInterface()

class ChildClass: SampleInterface

20.3. 추상 클래스

#!syntax kotlin 
abstract class Animal(val name: String) {  // 생성자 가능
    abstract fun makeSound()               // 추상 메서드 — 반드시 override
    abstract val legs: Int                 // 추상 프로퍼티

    fun breathe() = println("$name 호흡") // 구체 메서드 — 그대로 상속
}

20.4. 데이터 클래스

#!syntax kotlin
data class Point(val x: Int, val y: Int)

val p1 = Point(1, 2)
val p2 = p1.copy(y = 10)  // Point(1, 10)
val (x, y) = p1  // 구조 분해

20.5. 봉인 클래스

#!syntax kotlin
sealed class Shape

class Circle(val radius: Double) : Shape()
class Rectangle(val w: Double, val h: Double) : Shape()
class Triangle(val base: Double, val height: Double) : Shape()

#!syntax kotlin
fun area(shape: Shape): Double = when (shape) {
    is Circle ->    Math.PI * shape.radius * shape.radius
    is Rectangle -> shape.w * shape.h
    is Triangle ->  0.5 * shape.base * shape.height
    // else 없어도 됨 — 컴파일러가 모든 경우를 알기 때문
}

#!syntax kotlin
sealed class Shape

class Circle(val radius: Double) : Shape()
class Rectangle(val w: Double, val h: Double) : Shape()
class Triangle(val base: Double, val height: Double) : Shape()
class Square(val side: Double) : Shape()

#!syntax kotlin
sealed class Expr

// 일반 클래스
class Num(val value: Int) : Expr()

// 데이터 클래스 (가장 흔하게 쓰임)
data class Add(val left: Expr, val right: Expr) : Expr()

// 오브젝트 (싱글톤, 상태 없음)
object Zero : Expr()

// 봉인 클래스가 봉인 클래스를 상속 (계층 구조)
sealed class BinaryOp : Expr()
class Mul(val left: Expr, val right: Expr) : BinaryOp()
class Div(val left: Expr, val right: Expr) : BinaryOp()

#!syntax kotlin
fun eval(expr: Expr): Int = when (expr) {
    is Num -> expr.value
    is Add -> eval(expr.left) + eval(expr.right)
    is Zero -> 0
    is BinaryOp -> when (expr) {
        is Mul -> eval(expr.left) * eval(expr.right)
        is Div -> eval(expr.left) / eval(expr.right)
    }
}

20.6. 위임

#!syntax kotlin
interface Printer { fun print() }
class RealPrinter : Printer { override fun print() = println("print") }

class SmartPrinter(p: Printer) : Printer by p

#!syntax kotlin
val config: String by lazy { loadFromFile() }  // 최초 접근 시 초기화

var name: String by Delegates.observable("init") { _, old, new ->
    println("$old → $new")
}

21. 인터페이스

22. 여러 객체

22.1. 오브젝트

#!syntax kotlin
object Object1 {
    var v = 0
}

fun main() {
    val a = Object1
    val b = Object1
    println("a=${a.v}, b=${b.v}")  // a=0, b=0
    a.v = 10
    println("a=${a.v}, b=${b.v}")  // a=10, b=10
}

22.2. 동반 객체

#!syntax kotlin
class clazz {
    companion object {
        var v = 0
        fun f() { println("v") }
    }
}

fun main() {
    clazz.v = 10
    clazz.f()
}

23. 제네릭

#!syntax kotlin
package HelloWorld

fun <T> a(args: Array<T>) {      // 기본 제네릭
    // TODO
}
fun <T> b(args: Array<out T>) {  // 공변성 제네릭
    // TODO
}
fun <T> c(args: Array<in T>) {   // 반공변성 제네릭
    // TODO
}
fun d(args: Array<*>) {          // star-projections
    // TODO
}

23.1. where

#!syntax kotlin
package HelloWorld

fun <T> a(arg: T) where T: AutoCloseable {
    // TODO
}
fun <T> b(arg: T): Any where T: AutoCloseable {
    // TODO
}
fun <T> c(arg: T) where T: AutoCloseable, T: Iterable<*> {
    // TODO
}
fun <T> d(arg: T): Any where T: AutoCloseable, T: Iterable<*> {
    // TODO
}

23.2. reified

#!syntax kotlin
package HelloWorld

inline fun <T, E> a(args: List<E>, clazz: Class<T>): T {
    // TODO
    if (clazz.isInstance(args[0])) {
        // TODO
    }
}

#!syntax kotlin
package HelloWorld

inline fun <reified T, E> a(args: List<E>): T {
    // TODO
    if (args[0] is T) {
        // TODO
    }
}

24. 예외