Kotlin - 코틀린 간단한 문법 예제(함수, 변수, 클래스, for문, 예외처리, map iterator, 스마트 캐스팅..)
오늘은 코틀린에 대해 아주 기초를 다루어본다.
함수(Function)
코틀린에서 함수는 "fun"이라는 키워드로 정의한다. 간단하게 리턴값이 있고, 없는 함수와 바디 내용이 식으로만 이루어졌을때 함수를 간략화 하는 방법은 아래와 같다.
/**
* 리턴이 없는 함수
*/
fun helloWorld() {
println("hello, world")
}
/**
* 리턴값이 있는 함수
*/
fun max(a: Int, b: Int): Int {
//코틀린의 if문은 식(리턴 값이 존재)이지 문(block, return이 없음)이 아니다.
return if (a > b) a else b
}
/**
* max 함수와 간략 버전
* 함수의 본문이 식으로만 이루어져있다면, 아래처럼 간략하게 바꿀 수 있다.
* 또한 반환 타입도 생략이 가능하다. 그 이유는 식이 반환하는 타입을 컴파일러가 추론하기 때문이다.
* fun max2(a: Int, b: Int): Int = if (a > b) a else b
* ->
* fun max2(a: Int, b: Int) = if (a > b) a else b
*/
fun max2(a: Int, b: Int) = if (a > b) a else b
변수(Variable)
크게 어색하지 않은 키워드이다. 하지만 val은 자바의 final과 거의 비슷한 느낌인데, 선언시 반드시 초기화 식이 들어가지 않아도 된다. 그 이유는 블록내에 컴파일러에게 오직 한번만 할당한다라는 보장을 줄 수 있다면, 블록내에 여러군대에서 할당하는 코드가 들어가도 된다.
//타입을 명시하지 않아도 컴파일러가 타입을 추론한다.
val question = "sample question" -> String
val num = 42 -> Int
val yearsToCompute = 7.5e6 -> Double
//변수의 타입을 직접 명시해줄 수도 있다.
val answer: Int = 42
//변경, 재할당이 가능한 변수
//한번 타입이 추론되면 다른 곳에서 어싸인할때 다른 타입으로 못넣음.
var variable = 1
/**
* val 키워드지만, 컴파일러가 오직 하나의 초기화 문장만
* 실행됨이 확실하면 여러 곳에서 할당하는 코드가 들어갈 수 있다.
*/
fun variableExam(b: Boolean): String {
val message: String
if (b) {
message = "true"
} else {
message = "false"
}
return message
}
/**
* 타입이 생략가능하다지만, 다른 타입을 재할당 할 수는 없다.
*/
var intValue = 1
intValue = "123" -> 컴파일에러
마지막에 var에 다른 타입으로 재할당이 불가능하지만, 변환 함수나 강제 형변환을 통해 다른 타입의 값을 변수에 재할당 가능하다.
문자열 템플릿
문자열을 다룰때 "$" 키워드로 변수값을 그대로 넣을 수 있다. 마치 자바에서 "Hello" + name + "!" 과 비슷하지만 조금더 간결하게 작성가능하다. 또한 "${}"를 이용하여 변수명만 아니라, 복잡한 식도 넣을 수 있다.
//컴파일된 코드는 StringBuilder를 사용하고, 문자열 상수와 변수의 값을 append로 문자열 빌더 뒤에 추가한다.
fun main(args: Array<String>) {
val name = if (args.isNotEmpty()) args[0] else "Kotlin"
println("Hello, $name!")
}
fun stringTemplate(args: Array<String>) {
if (args.isNotEmpty()) {
println("Hello, ${args[0]}!")
}
}
fun stringTemplate2(args: Array<String>) {
if (args.isNotEmpty()) {
println("Hello, ${if (args.isNotEmpty()) args[0] else "Kotlin"}!")
}
}
클래스와 프로퍼티
자바의 클래스와 코틀린의 클래스 선언 방법을 비교해보자.
/**
* Java class definition
*/
public class Person {
private final String name;
public Person(String name) {
this.name = name;
}
public String getName() {
return this.name;
}
}
/**
* Kotlin class definition
*/
class Person(val name: String)
자바에서는 프로퍼티가 증가할 수록 생성자에 매개변수가 증가함에 따라 내부 this 연산자로 프로퍼티를 초기화하는 코드도 증가한다.(물론 롬복이라는 라이브러리를 사용하면 되지만..) 코틀린은 프로퍼티가 많아져도 아주 간단하게 클래스를 정의할 수 있다. 또한 코틀린은 기본 접근제어자가 public 이기 때문에 public 키워드도 생략가능하다.
/**
* Kotlin class definition
*/
class Person(val name: String,
var age: Int)
fun main(args: Array<String>) {
val person = Person("levi", 29)
println(person.name)
println(person.age)
person.age = 30
}
생성자에서 var로 프로퍼티를 선언하면, 실제 변경가능한 프로퍼티로 생성된다. 자바와 달리 setxx, getxx이 필요없고, 실제 프로퍼티를 참조해 값을 가져오거나 값을 변경할 수 있다.(프로퍼티를 참조하면 내부적으로 getter, setter를 호출해준다.)
/**
* Kotlin class definition
*/
class Person(val name: String,
var age: Int) {
val isProgrammer: Boolean
get() {
return name == "levi"
}
//get() = name == "levi"
}
fun main(args: Array<String>) {
val person = Person("levi", 29)
println(person.isProgrammer)
}
또한 위 예제처럼 실제 초기화 시점에는 값을 받을 필요가 없는 프로퍼티의 경우 직접 프로퍼티의 접근자(getter)를 정의해줄 수 있다. 함수로 fun isProgrammer() = name == "levi"를 정의할 수 있지만, 성능상 차이는 없고, 가독성 차이 뿐이다.
디렉토리와 패키지
코틀린은 자바와 패키지에 대한 개념이 비슷하다. 하지만 아래와 같이, 최상위 함수가 정의되어있다면 다른 패키지에서 해당 함수만 임포트해서 사용가능하다.
package com.example.kotlin.ch_1
class Rectangle(val height: Int, val width: Int) {
val isSquare: Boolean
get() = height == width
fun sumHeightAndWidth() = height + width
}
fun createRandomRectangle(): Rectangle {
val random = Random()
return Rectangle(random.nextInt(), random.nextInt())
}
=========================================================
import com.example.kotlin.ch_1.createRandomRectangle
fun main(args: Array<String>) {
var rectangle = createRandomRectangle()
}
또한 같은 패키지라면, 함수를 임포트할 필요없이 얼마든지 가져다 사용할 수 있다.
선택 표현과 처리: enum과 when
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);
fun rgb() = (r * 256 + g) * 256 + b
}
when 절은 자바의 switch case와 상응하는 문법이다. if else와 같이 리턴값을 가지는 식이다.
fun getMnemonic(color: Color) = when (color) {
Color.RED -> "GOOD"
Color.ORANGE -> "NOT BAD"
Color.GREEN, Color.YELLOW -> "BAD"
}
자바의 switch 문과 달리 코틀린의 when은 임의의 객체를 인자로 받을 수 있다.
#setOf Set 객체를 만드는 함수
fun mix(c1: Color, c2: Color) = when (setOf(c1, c2)) {
setOf(Color.RED, Color.ORANGE) -> "first"
setOf(Color.YELLOW, Color.GREEN) -> "second"
else -> throw Exception("exception")
}
또한 when은 인자가 없이 만들 수도 있다.
fun mixOptimized(c1: Color, c2: Color) = when {
(c1 == Color.RED && c2 == Color.YELLOW) -> "first"
(c1 == Color.YELLOW && c2 == Color.GREEN) -> "second"
else -> throw Exception("exception")
}
위처럼 인자가 없는 when 식을 사용하면, 각 분기의 조건이 Boolean을 반환하는 식을 넣으면 된다.
스마트 캐스트: 타입 검사와 타입 캐스트를 조합
자바와 달리 코틀린은 명시적으로 타입 캐스팅하는 코드를 넣을 필요가 없다.
interface Expr
class Num(val value: Int) : Expr
class Sum(val left: Expr, val right: Expr) : Expr
fun eval(e: Expr): Int =
if (e is Num) {
val num = e as Num
num.value
} else if (e is Sum) {
eval(e.left) + eval(e.right)
} else {
throw IllegalArgumentException("Unknown expression")
}첫번째 if문은 자바처럼 명시적으로 "as" 키워드를 사용해 타입 캐스팅을 하였다. 하지만 else if 문을 보면 딱히 타입 캐스팅을 하지 않았는데도, Sum 타입으로 변환이 되었다. 이것을 스마트 캐스팅이라고 한다.
이번엔 위 eval 함수를 when식로 리팩토링 해보자.
fun eval(e: Expr): Int =
when (e) {
is Num -> {
val num = e as Num
num.value
}
is Sum -> {
eval(e.left) + eval(e.right)
}
else -> {
throw IllegalArgumentException("Unknown expression")
}
}
코틀린에서 조금 특이하게 동등성 검사가 아닌 다른 기능에도 when식을 사용할 수 있다. 그리고 조금 특이한것이 블록 내에 return이 생략되어 있는 것을 볼 수 있다. 이 말은 "블록의 마지막 식이 블록의 결과"라는 규칙이 항상 성립되는 것이다.
for문
코틀린은 자바의 forEach문만 지원한다. 이말은 for(int i=0; i<10; i++) 같은 문법을 지원하지 않는것이다.
package com.example.kotlin.ch_2
fun forEach() {
val list = listOf("a", "b", "c")
for (str in list) {
println(str)
}
}
fun forEach1() {
val list = arrayListOf(10, 11, 12)
for ((index, elem) in list.withIndex()) {
println("$index, $elem")
}
}
fun forEach2() {
//range 1부터 10까지 포함
val oneToTen = 1..10
for (i in oneToTen) {
println(i)
}
}
fun forEach3() {
for (i in 10 downTo 1 step 2) {
println(i)
}
}
fun main() {
forEach()
println("===============")
forEach2()
println("===============")
forEach3()
}
->
a
b
c
===============
0, 10
1, 11
2, 12
===============
1
2
3
4
5
6
7
8
9
10
===============
10
8
6
4
2
특이하게 코틀린은 range라는 변수를 선언할 수 있어서 자바의 for문처럼 흉내를 낼 수 있다. 또한 downTo, step 문법을 지원해 역순으로 출력하는 것도 가능하고, withIndex로 리스트의 인덱스와 요소를 같이 받을 수도 있다.
맵에 대한 for문
fun forEach4() {
val lowerUpperCaseMap = HashMap<Char, Char>()
for (c in 'A'..'F') {
val lowerCase = c.toLowerCase()
//자바의 map.put(lowerCase, c)와 같다.
lowerUpperCaseMap[lowerCase] = c
}
for ((lower, upper) in lowerUpperCaseMap) {
println("$lower $upper")
}
}
in으로 컬렉션이나 범위의 원소 검사
fun recognize(c: Char) = when (c) {
//'0' <= c && c <= '9'
in '0'..'9' -> "It's digit!"
//'a' <= c && c <= 'z'
in 'a'..'z', in 'A'..'Z' -> "It's a letter"
else -> "I don't know"
}
Comparable 등이 구현되어 있다면, 일반 오브젝트에서도 "in" 사용이 가능하다.
코틀린의 예외 처리
코틀린은 자바와 같이 checked exception과 unchecked exception을 구분하지 않는다. 즉, 예외 처리를 강제하지 않아며, 메서드에 throws 문을 명시하지 않아도 된다.
fun readNumber(reader: BufferedReader): Int? {
try {
val line = reader.readLine() //checked exception이 발생
return Integer.parseInt(line)
} catch (e: NumberFormatException) {
return null
} finally {
reader.close()
}
}
위 코드의 경우 reader.readLine()이 IOException(checked exception)을 발생시키지만, 코틀린에서는 어디에도 다시 throw하거나, 캐치해서 처리하지 않는다. 즉, checked exception을 강제하지 않는 것이다.
또한 try-catch는 물론 식이므로 아래와 같이 코드를 변경할 수 있다.
fun readNumber2(reader: BufferedReader) {
val number = try {
Integer.parseInt(reader.readLine())
} catch (e: NumberFormatException) {
null
}
println(number)
}
fun readNumber3(reader: BufferedReader) {
val number = try {
Integer.parseInt(reader.readLine())
} catch (e: NumberFormatException) {
return
}
println(number)
}
하지만 조금 다른 것이 catch에서 null을 반환하냐, return 키워드를 쓰냐의 차이인데 return 키워드를 사용하면 catch문 아래의 로직은 수행하지 않고, 해당 메서드가 스택에서 반환된다.
여기까지 아주 간단한 코틀린 문법에 대해 다루어 보았다. 다음 포스팅에는 조금더 자세히 코틀린에 대해 다루어본다.
<참고 서적>
