Kotlin 공식 문서 살펴보기 (1) - Basic syntax

kotlin04 Jan 2022

Package

패키지 사양은 소스 파일 가장 위에 있어야 한다. 디렉토리와 패키지를 일치시켜야 하는 것은 아니며, 소스 파일은 임의로 파일 시스템에 위치할 수 있다.

package my.demo

import kotlin.text.*

Entry Point

코틀린 앱의 진입점(entry point)는 main 함수에 있어야 한다.

fun main() {
  println("Hello World!")
}

다른 형태의 main은 다양한 수의 String 인자를 허용한다.

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

표준 출력

print 는 인자를 표준 출력하는 함수이다.

print("Hello")
print("World")
// Hello World

println은 인자에 줄 바꿈을 더하여 출력한다.

println("Hello")
println(2022)
// Hello
// 2022

함수

아래 함수는 두 개의 Int형 매개변수를 받아 Int 형을 반환하는 함수이다.

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

함수 본문은 표현식이 될 수 있어 반환 타입은 추론된다.

fun sum(a: Int, b: Int) = a + b

반환 타입이 없을 때는 아래와 같이 쓸 수 있다.

fun printSum(a: Int, b: Int): Unit {
  println("sum of $a and $b is ${a + b}")
}

또한, Unit 반환 타입은 생략될 수 있다.

fun printSum(a: Int, b: Int) {
  println("sum of $a and $b is ${a + b}")
}

변수

읽기 전용 지역 변수는 val 키워드를 이용하여 선언한다. 이 변수들은 오직 한 번만 값을 할당할 수 있다.

변수 a는 바로 값을 할당하였고, 변수 b는 타입을 선언하지 않았지만 Int 타입이라는 것이 추론된다. 변수 c처럼 초기화되지 않을 때는 꼭 타입이 선언되어야 한다.

val a: Int = 1
val b = 2
val c: Int
c = 3

값을 재할당 할 수 있는 변수는 var 키워드를 사용한다.

var x = 5
x += 1
print(x)
// 6

또한, 최상위 수준에 변수를 선언할 수도 있다.

val PI = 3.14
var x = 0

fun incrementX() {
  x += 1
}

fun main() {
  println("x = $x; PI = $PI")
  incrementX()
  println("incrementX")
  println("x = $x; PI = $PI")
}
// x = 0; PI = 3.14
// incrementX
// x = 1; PI = 3.14

Class & Instance

클래스를 정의할 때는 class 키워드를 사용한다. 클래스의 속성은 클래스의 선언이나 본문에 나열할 수 있으며 클래스 선언에 나열된 매개변수가 있는 기본 생성자는 자동으로 사용할 수 있다.

class Rectangle(var height: Double, var length: Double) {
  var perimeter = (height + length) * 2
}

val rectangle = Rectangle(5.0, 2.0)
println("The perimeter is ${rectangle.perimeter}")
// The perimeter is 14.0

클래스간의 상속은 콜론(:)으로 선언된다. 클래스는 기본적으로 final이며 클래스를 상속 가능하게 하려면 open 키워드를 사용해야 한다.

open class Shape

class Rectangle(var height: Double, var length: Double): Shape() {
  var perimeter = (height + length) * 2
}

주석

코틀린도 한 줄과 여러 줄의 주석을 지원한다.

// This is an end-of-line comment

/* This is a block comment
   on multiple lines. */

String templates

문자열에서 $를 이용해 변수를 사용할 수 있다. 더 복잡한 식을 쓸 때는 $ 안에 중괄호{}를 이용하면 된다.

var a = 1
val s1 = "a is $a"

a = 2
val s2 = "${s1.replace("is", "was")}, but now is $a"

조건식

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

fun main() {
  println("max of 0 and 42 is ${maxOf(0, 42)}")
}
// max of 0 and 42 is 42

위의 코드는 함수 본문에 조건식이 포함되어 조건식의 결과에 따라 반환 값이 달라진다. 코틀린에서는 if 가 표현식이 될 수 있어 아래와 같이도 사용할 수 있다.

fun maxOf(a: Int, b: Int) = if (a < b) a else b

for loop

아래와 같이 사용하면 items의 값을 for 문을 돌면서 하나씩 꺼낼 수 있다.

fun main() {
  val items = listOf("apple", "banana", "kiwi")
  for (item in items) {
    println(item)
  }
}
// apple
// banana
// kiwi

인덱스를 가져올 때는 아래처럼 사용할 수 있다.

fun main() {
  val items = listOf("apple", "banana", "kiwi")
  for (index in items.indices) {
    println("item at $index is ${items[index]}")
  }
}
// item at 0 is apple
// item at 1 is banana
// item at 2 is kiwi

while loop

fun main() {
  val items = listOf("apple", "banana", "kiwi")
  var index = 0
  while (index < items.size) {
    println("item at $index is ${index[index]}")
    index++
  }
}
// item at 0 is apple
// item at 1 is banana
// item at 2 is kiwi

when expression

아래의 예제에서는 when 표현식의 순서대로 확인하며 해당되는 값을 반환한다.

fun describe(obj: Any): String =
		when (obj) {
      	1						-> "One"
      	"Hello"			-> "Greeting"
      	is Long			-> "Long"
      	!is String 	-> "Not a string"
      	else				-> "Unknown"
    }

fun main() {
  println(describe(1))
  println(describe("Hello"))
  println(describe(1000L))
  println(describe(3))
  println(describe("other"))
}
// One
// Greeting
// Long
// Not a string
// Unknown

범위

숫자가 범위 안에 있는지 확인할 때는 in을 사용하며 범위는 첫번째 숫자와 마지막 숫자를 모두 포함한다.

fun main() {
  val x = 10
  val y = 9
  if (x in 1..y+1) {
    println("fits in range")
  }
}
// fits in range

숫자가 범위를 벗어나는 것도 확인할 수 있다.

fun main() {
  val list = listOf("a", "b", "c")
  
  if (-1 !in 0..list.lastIndex) {
    println("-1 is out of range")
  }
  if (list.size !in list.indices) {
    println("list size is out of valid list indices range")
  }
}
// -1 is out of range
// list size is out of valid list indices range

범위를 반복하거나 진행 단위를 두고 반복할 수도 있다.

fun main() {
  for (x in 1..3) {
    print(x) // 123
  }
  println()
    
  for (x in 1..10 step 2) {
    print(x)	// 13579
  }
 	println() 
  
  for (x in 9 downTo 0 step 3) {
    print(x) // 9630
  }
}

Collections

컬렉션에 객체를 포함하는지 확인할 때는 in 연산자를 사용한다.

fun main() {
  val items = setOf("apple", "banana", "kiwi")
  when {
    	"orange" in items -> println("juicy")
    	"apple" in items -> println("apple is fine too")
  }
}
// apple is fine too

람다 표현식으로 컬렉션을 필터링하거나 매핑할 수도 있다.

fun main() {
  val fruits = listOf("banana", "avocado", "apple", "kiwi")
  fruits
  		.filter { it.startsWith("a") }
  		.sortedBy { it }
  		.map { it.uppercase() }
  		.forEach { println(it) }
}
// APPLE
// AVOCADO

Nullable values

null 값이 가능할 때는 반드시 명시적으로 표기해야 하며 이는 ?를 타입 이름 끝에 붙여주면 된다.

fun parseInt(str: String): Int? {
  return str.toIntOrNull()
}

fun printProduct(arg1: String, arg2: String) {
  val x = parseInt(arg1)
  val y = parseInt(arg2)
  
  if (x != null && y != null) {
    println(x * y)
  } else {
    println("'$arg1' or '$arg2' is not a number")
  }
}

fun main() {
  printProduct("6", "7")
  printProduct("a", "7")
  printProduct("a", "b")
}
// 42
// 'a' or '7' is not a number
// 'a' or 'b' is not a number

타입 검사 & 자동 캐스트

is 연산자는 식이 타입의 인스턴스인지 확인한다. 만약 값을 바꿀 수 없는 지역 변수나 속성이 특정 타입으로 확인된다면 자동으로 캐스팅 되므로 명시적으로 캐스팅하지 않아도 된다.

fun getStringLength(obj: Any): Int? {
  if (obj is String) {
    return obj.length
  }
  
  return null
}

fun main() {
  fun printLength(obj: Any) {
    println("'$obj' 의 길이. 결과: ${getStringLength(obj) ?: "Error: 문자열이 아닙니다."}")
  }
  printLength("코틀린")
  printLength(1000)
  printLength(listOf(Any()))
}
// '코틀린' 의 길이. 결과: 3
// '1000' 의 길이. 결과: Error: 문자열이 아닙니다.
// '[java.lang.Object@41cf53f9]' 의 길이. 결과: Error: 문자열이 아닙니다.

기록하는 공간